From 8f0cc4cfed97f05e47a7ad15e8b42f35b831dfd0 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Mon, 30 Jul 2018 15:01:55 -0600 Subject: [PATCH 01/10] Add NDBC latest observations. --- siphon/simplewebservice/ndbc.py | 65 +++++++++++++++++++++++++++++++++ 1 file changed, 65 insertions(+) create mode 100644 siphon/simplewebservice/ndbc.py diff --git a/siphon/simplewebservice/ndbc.py b/siphon/simplewebservice/ndbc.py new file mode 100644 index 000000000..612a9a837 --- /dev/null +++ b/siphon/simplewebservice/ndbc.py @@ -0,0 +1,65 @@ +# Copyright (c) 2013-2015 Siphon Contributors. +# Distributed under the terms of the BSD 3-Clause License. +# SPDX-License-Identifier: BSD-3-Clause +"""Read data from the National Data Buoy Center.""" + +from io import StringIO +import warnings + +import pandas as pd + +from ..http_util import HTTPEndPoint + +warnings.filterwarnings('ignore', 'Pandas doesn\'t allow columns to be created', UserWarning) + + +class NDBC(HTTPEndPoint): + """Download and parse data from the National Data Buoy Center.""" + + def __init__(self): + """Set up endpoint.""" + super(NDBC, self).__init__('https://www.ndbc.noaa.gov/') + + @classmethod + def latest_observations(cls): + """Retrieve the latest observations for all buoys from NDBC. + + Returns + ------- + :class:`pandas.DataFrame` containing the data + """ + endpoint = cls() + col_names = ['station', 'latitude', 'longitude', + 'year', 'month', 'day', 'hour', 'minute', + 'wind_direction', 'wind_speed', 'wind_gust', + 'wave_height', 'dominant_wave_period', 'average_wave_period', + 'dominant_wave_direction', 'pressure', '3hr_pressure_tendency', + 'air_temperature', 'water_temperature', 'dewpoint', + 'visibility', 'water_level_above_mean'] + + col_units = {'station': None, + 'latitude': 'degrees', + 'longitude': 'degrees', + 'wind_direction': 'degrees', + 'wind_speed': 'meters/second', + 'wind_gust': 'meters/second', + 'wave_height': 'meters', + 'dominant_wave_period': 'seconds', + 'average_wave_period': 'seconds', + 'dominant_wave_direction': 'degrees', + 'pressure': 'hPa', + 'air_temperature': 'degC', + 'water_temperature': 'degC', + 'dewpoint': 'degC', + 'visibility': 'nautical_mile', + '3hr_pressure_tendency': 'hPa', + 'water_level_above_mean': 'feet', + 'time': None} + resp = endpoint.get_path('data/latest_obs/latest_obs.txt') + + df = pd.read_fwf(StringIO(resp.text), skiprows=2, + na_values='MM', names=col_names) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df From 5e7b937b5f55554bebd29ca9d9614becbe782b4b Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Mon, 30 Jul 2018 15:53:01 -0600 Subject: [PATCH 02/10] Add test and data for latest NDBC data. --- siphon/tests/fixtures/ndbc_latest | 414 ++++++++++++++++++++++++++++++ siphon/tests/test_ndbc.py | 76 ++++++ 2 files changed, 490 insertions(+) create mode 100644 siphon/tests/fixtures/ndbc_latest create mode 100644 siphon/tests/test_ndbc.py diff --git a/siphon/tests/fixtures/ndbc_latest b/siphon/tests/fixtures/ndbc_latest new file mode 100644 index 000000000..c010b3b3a --- /dev/null +++ b/siphon/tests/fixtures/ndbc_latest @@ -0,0 +1,414 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+37.gbd8b5d3.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/latest_obs/latest_obs.txt + response: + body: + string: !!binary | + H4sIAAAAAAAAA7W9y3Jcu5IePNdTVISHO0jjvrCGLFIiuXmrw6otSj1z2G33Pzj+I+we2G9v5AVY + WEBiVYna3RG7mkcSmQSQSOTlyy//0/H0uoP/e7457eiLt/QHP9P/7V5ednd3u3/7t90//7n7uHt8 + 330cD3fpX9wfT7uP7w/p39+l/32T/nv5gD8/vH89ps/T3c/d7ub0ctjtPvDz7utH+vz+mP5yd3q8 + +/rlP/37v/6ffwdZ/+1f/wcJpS/+7//a/fP/3/23//J/d/+Wvvqf8KdJyD//8//elc/03//+1/+K + /9Hf7v7t8F/yZ/qT2/Xn//zn/4c//7//+xdjtNK7nZ2ujUt/ok24Vma3M0rHnZp2Vu2M3im107OC + v76GT9gC+qi/0Er5a5v/2tjrOX3qa7f6Bvx/KDQJse56mlGov56iIHTnQZzZFupWQtPXxjXfsAi1 + KFThUsx0DT++F2rgr8O5lZZ1pR2b0qe/jgOhjlY6odB4PYtCXfpPq22hFgSx0Am3d1r+pBHq8Uw9 + nqlV12q8UrstNIAgFornm9Y7WmlIPy1cW48rneUztXim87ntNdX2elypHQhNO2DTGmLWXjva3t20 + LdQs60rHpPBTD4RGXKnxWXu9dGXCRdq7bC+eZhIqrdSa40ntrvR8HWz6jquYvjHJq4Uq+NTm/Ep1 + XITqCVad/gQ+DWr1ItTBrqSV6usJ1nI1uevoVLNSnY0DXTu6OILQuVKbvF5JkUAoXBmTrqcGoUlX + 5rkXavAa++tlvYLQWnvxNA2uNB3Z3AmNuFIHP/YqqusY2u1Nmqv9skYUqnANEVaffumoQCj+8Ct9 + Hco9nfFrh+q0Fjrjr0QrTUJ1dKPtDdsrnVaKtHwtCNWk2xHu59UUr130gtDpgu2N1ZWZqu21sN5G + qMV76mwAoUnVnR2t9IzQabmVJixmkM3+Sii8aUlotBOvNFnh5p6mQ4b92OGNZwssKlJtey2dmqy9 + YBVsWgPY4KspvRRKWKkxy0qHVyYKKyVF6rbXzHhlIpg/uDLBtIpUVkri5pFQjz88Xxmfz1RaqbUo + 1Ewzaa9LL0AnVMdPCZ0XHW6EksGfYyRFssEIK1UXCJ2EV8YMhEZ8xLXTrL26vTJlpaS3caxItefg + 8plKQtEncNfew/b69MZNtrFI8C8Wg8o/leSDcsUdOne7/h+tPtdCNQq1oFBXLu1gbLcXlGi64Mr4 + 6gTPCbXoK2qbtv8qpFfGt4oExkFdIDSuHnGT31NDvtNaqEOhfgbj4GO6Mnq00u0zNZXfxraIzL5g + kVzAXybSSpNF0q1FKisN54S27+nQIjn6lTzYnKspLdlKjzj6SPQr+5FQU12Qc2dK72lEzyHMaZ+H + nsO2wTeV31s2ebRSMpIuwpkGcz27M9u7IbTR3oFjloR6gx6U8Yq0dwqtwQeBsdFejT8ua+XsQHvR + sLPnQC/p8Ey9RaFuciA0CD6SLFRXQn0stjcJpcsS8qcoNNBKA5jBkJ620L0yScjcXBkSmp+sEEio + Q6EOxdHnwOCDAqWdifCYX/kUgjZXBh0zwQyCUDSDaQeD3W3orSTU4CM+kY+UFHTuDH4Wun1lNFqh + K10pz1goxadTNCR0drpZqcp+71mhCoVqtDZ6UyjFp0ahj5TcDNcpUrzUMVse8fyeytpLAVS610aT + Y6b691Q406JI4GzrEMUzJbMvCQVzvn7EO29QFIpLB6E++f8DoZOY6AChoEjqelLoI6VbNnfuiiCU + jDucDDziTtZeilJFoeSglljGW+me9kLBMIAOJmXVgyszCIpBKDkz3rNQc9H2KlSayBodgiw0DLfX + o0WyExr85L/F9pUZn+lEZ5puyGilst+r9YRnqmh70w/rhBojrXSmlVoQOk8jRZJtr9b0HATFznb/ + no63F4IDkD7eXimPlISC6wnGQdtsHDoPX9xek890gvzIr6309aTOGfz0WT1ta0NUWyS/CqAiCk3f + YEwbFCejqjEtENEbjCmAasL/ynMgD9uOzGCV0rG4/VZz1OY7oQZ/MTWDRZqTPfRSzgFdUFJZTTkH + UFg0Dml7p1h7DjNZGxQ640pNJ9RSAsSi9qbX30ortcsah69M5eEbdKeSaIcvTieUzSC+NlcRrITg + bFNQfOZpc6tQcfna92eKZnC61hNob0zeYBMUoyKZKqWzESq23uAsW6T048kFnfE9nf219UY4U7Oc + qaEzdfWZelqpK47ZjGfaJhOLULA3mNCGnENMP6PzHCA3qMvGDgIo6Z7SmYpCKRuM+SQQqmIQtrdK + SA63N7RRWxIqvjJGWcqYTRj+xyRdCVfGxOaeqms2yJa/QO31xUea4UpZxcmrqRUKoVH6N0ah0PQb + GiE+Nb4RKl+Z5QTpF5JLJCDU4/bCM5oUKTlUSvXe4C4siuQGQpXBlRpUIVeJk4RSqEhmMFkkiI57 + F7QyDhsrXWzvzGfqZePgPdlkjE+T0DlIoaJexA2Ng11WRypk6Xx9m9k2FMvMmEWndLpkBimWsZvb + C09Vpb1LntC1SeYkNP0tJKVJkdLRGym70gZQ8kpNJTTkUJHrUCuhGECFa0tBcXLuvLC99J7iDdXm + Au0t2RWzE5LMKZqgBIi3nv1ed5nfC28kvCFp79B33vX/yLZlyCI0eqpoUM4hXZnO4Ct+xDkcNhSf + gnLwpdc60JmScYioSHZ9smuhM5X/JvIG7XXotveMh5+M/cAxG5vBmZwZcALpabPtezr2Bj17+JOc + G6T1ikLpabPO05Ux0yVRG50pCg1Db5A8JUGohbNMZjBMEBTP6TGahJWSRVq9p7AGu9JevKfpTJcb + OsvxqbEz2V4HlSgQOklRGz3iphUaRaGRSlpjzyEFaxCQJHUwWDhQGKj2nkNVa3MklAMoMLjwLVhr + S0f7B6q4wV9KY45FUxV1LRTc9HREuNKQDLUT3lPhTKcs1CShU0lIXpGRR6dFt1XeRSi4qelXwjzS + lKIE1Wa2fXa2ySJpuqdmx5F4Cv+T95HzvewjYVxlHCZgbetsO/QGnUnaG2h7w9oFTV8Ux2y1vW5Z + 6W6ytL0eVxrx2bL46XG9uhPqsFIctM71U2GluwpcwYoEL8dED50OhlZqUeiM1oYuBYmeO6ETnmmY + MWpLP7FJ6ZCPVNVPAwmFMw2sSBOeKf5OV9mrj9nUQ9q8Expxe40KWXulM8VYxtbb62l7A/zc2ZAi + uaK9lcdLmbS1UDgtl+w3rVRhKap3zPRypsPMduXlUsaM4jWzOMqLUIPbGyMKhSxW6zmoddQmv6fr + G1VEi7bXYVUxCTVek1Ad2qetbG9VOKBXBjNmyfYGTSs1eKalJG3cyCIZUKRk53GlIVmPzgX1aw8/ + Ntob8GlD7fX5TKkoT9GN7kokDkuZSZG84TP1oQ0rkq2iQnzlghZFqmxvlbE36AfWf6KvQyUU3o9k + ezWWMpNQZyShsVEksr2hEaoqoQpVKAyEGhQKxUS0vdb7XminvbS9rdBFe2mT41CoxTNFpxsqUPMs + rJTe09WZToLQ8nrSxupBHikJdSgUEVggFFy7gdDVSqNwpmV7tWfUih+slN5Th9mVpL0xttoLQl0R + l82gJHTx8MkCV+aiETqjRdI2ku0N3Zk6z9CglRnUW8aB0XRWTkg6jE+TcZh9IOPgu5WC0Cp5ZS4R + 6laa3D1tzuAjjgoFuUFrW2/Q8HvKzrYeZ1d0tdK2ULIS6gljpueZSiRCIV6N3JWJ3ZVRvjfI3mAS + GglNF7hEYrxUVdQXrXTJmNmulroSGmh7PZ1p8kW7lWoBjyQJnass2ZntxQpUsgmTZqEdSsfkSvEZ + 7MrcvqcbQslHmudIQlVstxeU6BKMWY3osFuJjiSU3lMbZn7EJZROjegYJq8qYFvxkQKaiO7KQJhn + k/cY2Dj4LmPmhe0t2gtQV0jJo1B6xKfdlfVnVjqzN8grbbeXcoOtRTrjrpBx4HS64GxDtAagYsWK + ZEKbMStnOl+ckDx3ZeKMQic/kXGwF5W9dI5PEUmMJy4YBy9XFZ2CNSSDD8BI9BwAOXNe6JmV8m82 + qEA5LBgkReLydNLecIlQMkvoDSb19oO6jJNzDg5K4FgTxwIfbm+XR4qSUC7aYljh5ZxDEjraXopl + Zrqn6YeZzvZayeDDxk1U/dduULQdOtszxTITWaR0kbtiEEQ5vdCQhUJ8OhCqZZyDw+wKmEHNuMHJ + XJZHmvKZxrQVg6piGGwv+gSAZA58pn7uAKh+JDS/p9bJQv3gPcXfEkJFStMZLKT2KZ1LUK/4tF1h + REOlrpXZXwudKZbBe+qTyyEK9Ys4sks50VEJRS/3DxIa2O9VslD4cRDLYG4wJJt50ZmuEpL1K/MH + vimUaSFHtBfqsaro0vV0jkokTrcZM5OjtjPVihrRgTtB2ttH4h6riiAU49NoOqB4F/7blQtqrkMW + Wic6FAsVLZJHoLhLjln0tFIfW2e7vKcrobznlr8oKB306jXlmWbZOHjE9SaDHxBykFZq59Y4wNZW + JZJh4aCCx9DTRpG4ntpqRRIacKWW0unJ8s9CdsX0ySuTt9cvQl1OXpG/VNcvGqF0T8PERVvVBcVJ + qK3aHNoznRehc0nTGUZrO4zg5k5orHIOaXudPiPUNEL9cqaUw1c5j7RCEq6EaorEg2FokJ2FjBn5 + BlLUhq0j+Z6qkl0xHLWJZtBTQtKiIcLtjb69MslQCtqrO0Wqw39s4jB6uFKKxGMWOnW1Npv93gpy + IGlvnV3xnCEcrNSQRXIY/sfk2sb2yqRP216Zor3wYbFyQ34vC1XcYqaLMVwLtXhlzKSoaBtU6zng + 57JG0wldfmD+pLimpDtiJ9Thmc4EOQgYvvW2tzeDlVCILnF7lzqFZmM44y9gO6FgkQL7SGmlvUWC + 7XWje7qySKpSJJ/fGr1EXIvQgGZwjrzS0MG9ypmuUjrw2/PrYY0qFqmYQZ1dUB2ElU64UirwzUm6 + besyRvW5Qdn21pE4xWsmF0oaoZGEYqU4CY1dvtfkK7O9vaYuXOZNFh0zn7OgM93T5KFN7UrLma5C + RVdtL4WK08o4zHm9OrTxqUf8fRLqcHuhaCu5Kx0IigLd7BHk7Y3lEbcMQ5VfGQ1PGmRBYQMhVIyT + JBTPVC0WiYSuC3x4ZYrQUgwShYL2RkTC4/bOUtFWt4gOVJFOKLkrFj0HhwlJ+UzJ701esePtVXro + gq6uTL+9Gd+rKh9JDYSC9s4sNEDGTBK69J/mmnif79WL30utSaxCktAZz5Qg8dPcdRwQdqVqMQvL + Sl2zUlO9p1P+lITCGjzUahUBZqYuPlXiPTXd9tbIq8D+w0B7AUwc0huUfuyVTv6M1dJK7bLSaaBI + 1JP4B2aTdS1OEkr3dHK8vWaWhFaegxttLzlmGfhkdutk3VooFQ5m0t50IkaABgk1cVAUJd5TX562 + AbAtCU2/rk+/GN7TOXYrrdocVorku5V6dsxIeyd8SUXIQRKavttrNESoSLNkkWx1T10JKzpFMuWe + WlakkVByth1ZpPTPJCRz567IT5uqzjSgDo/OlIxDwHs6uw5jNroyvUUKlUXKINuBGXRkHNgMpp8r + be+ujU9l46ArD3/a2l5YYQB3Be9pcjAk40Df0rkr7T0NaAap9gQu2fDKQDDsHIf/6Z5a8WnrsSuS + wbcFrOiZ5UCOTzU0/UPjns+K1EXi2eB3oeLgEY85oDBq4OEjUBwecbwyU8R9HngObSzTrXQ5U80Q + CyULBfhIKdpGYB4QCge27bRduaDLD8yfZOqHsQygMdAMEgA1maYOj2REnEPlDeq5Tb0SYGa8vYFC + xTkGEuq7dqSmRNI729q1GDMCKG6s1KGHP2GvYnJXQpcbLABU3xxRZ5Fi0V7DJRIxTZeEUnZlUoa3 + N7Tba9cevlA/jd1Kc3YlYs6hTV7pQLZX0/amH2a7FrN5tdLK2c7GwZs2gNose3nsXwI8EnUcQP1U + WKmthE6dhw+ZyS6AUvlTyK7oQOXpoBmWGbumV7BGvQtaC51aWCYlXSmHL8SneBngTD2n6eYunQ5C + ex/JV9um51aoYZ8w5Ae9EWrQDJKPFL1gkUy2SJXvvFakWTWReF2qls4Uwv4k1JfwfxLA/7u4KfTl + pTlT8oH1gC4jCXWkvZQbnDrIQbW9tj7T7eq/YRydKmCStVCPsUw0jAWdpPjUtPDpLrvSAGZy8mpg + kSbKOXCLGdCSSCutrozv7ymCoFaZbbu05+hZUKSJCnwzZ0GDblOvcl1mM49ULPDADE6UBQ2KMWZW + sr2EBT3TA4UZs4KmIw9/4DmAXjpAdPBKxQBqvFJTltz/o46SZhHKYQU2vaZ7GiUkc528Gvq9cxW1 + aU7pyCUSNPRge7EQDyuV3tMaCyrf0+Y0LVukgfZG9vARjwRCO7CiWa/0IqGOk+qiIgXsa/PpcVEu + bY1L4V6T0qHCQWV7A4X/DCrG/4XbS92mf6BVphSHbqmjFqEUnwZtklDo+7ACYKZzzIQzraulDPfC + 6hs17zRCHYb/0NeWhIauwKeWqmKVRzKrNvwX9vCnSuiURYsrpdQr5B6SUC3EMjqf6TaMpEaUCZ8r + oQAmtg7hXlcaMj9aqFZYvQjlNny/46LtnP5ZKE06XPZCs6AHabpAHXxT8rFRaPLiooBOty0WtJQy + oUJgtS8oHcaC2kW0KJTwSMZGEJr+WZfD17xSnX+evL01wwyf7CBjFgizncymtSR0DpLQFiEpCa1Y + y/jK5LDRtEIZVAxF/yQUGmckNpJLqooVHkmjb68tR6ndlUGqIugWnCEoTqrpJaqiS4RW0Si9OPTW + 6EXdF6GBUTqOFckKmO1Ke7dImZaV5rzZ4EwNP+Le0PbaKDhmVjcrLVjQkH66NVMp8BXt1VtXBgoH + AJhBMwjBrNTe29316p4aVDPUXlsJ9Vi0FbOggQoHAeH3uNKW3Ytq4hXcyzYrBTzY3GK2URz13rLo + lVBOp0NOLJlBi0nCwSNeNXSYHrNNocQVZQ0xPtV+9LQhADU9B2mBqEht2WuxSNw/YpenjXv/rXa1 + GaTLQmscWCRHfbggC6+Mk4QKZ+ry9iYzqLi9d86ZbS7EDxKSAVM54A0mV5SMwxgLegbRUXU8aeyC + Z7tk+nvqiY3E4JUBqyIah7CYhY2W7eWeYlxDK+1xDkkos5EEPFMlMLYVz2GbH6nuEy+iB1fGUzsS + gBavgLhy7sCK5RE/S1W0oO5DdbK+vzKwcSGpXETHLJkyJdxTqhSvsqBFkTz3iRPOqjEOYuo1IADV + G74yPi3GXcal4yiHD9oLb3GVBSVxGu+YmAUNCEBNNgFgJHimpgP/wz1taW300hlkF3dFlZWSYzYg + ZQoIQPUa2wavNPRARalPHI2D4Z+nqEUR6TKgR4VWSt3Tf2Aqcodvq6a0ZRcqJqEeqxVQE79KJvY6 + XkhVBGZOg1qlG2bmkk7/o+4yUKNXBoJin+61Muzhd8Ugn/3e1fbqZXvNoNN27IJCUOyTLA0G3ycF + mATtpbrPSntL22DaXgfNdASW/oPMoGZFMrsaQ78Ihe/0iKlIQgE+LWVX+u1V+UzBpWLtNUV7qzSd + Nm2iIwC3C67Uge1N8YVyEp9D25VZBVBplTOcqcm4wQkFWfwsXzdCDZ5pSD52OtPk94p5pP6V4ZWC + wTWGt3fOV+bcmUIk7iM2eaVHHBRJ0F7bd2UW+HT657RSPOyrbBxsflVFoR7PFNhW00ohOhZW2mFB + aaWoSFO2vZEVSZWwYviIQ/hvKRJPTxtkPCTb21cV513xkUywS6VYce4o5Ey+KHRCHwl6FfERnzoS + CZOFruoyMa80/Y5EExdXGuurp7zz8KFKAY6ZdRTL6CCttEK9Vt1e2LI955V6bnqd8zVhu6l7Mwg4 + fJeuuMFHHFjUhFCxwzno5Z6mf6ZNqf6XtkHKgg7OdGZv0GvyBpVpg2Llau1dv9215+C51kYbG3fr + cvxaaCBne+IzbdHp1FtxCYnE3FohPUzpzNSVCUTQFMuoVW5Qz2iRqqLtcKU1ETQ5xwNwRSBIPMRN + moTOa2AbC63YSDaE1tmVsJFdQZo4eNpmtL1QrbikzaG04YOVN0p+2jqy9SKUW7YnYzms6KiKZMx2 + gcRDICm3OehBb0VAdq90TyfDQbGfOtSrgMOXtrdmI6nqiULGDLkYHFEVodAW0aHRK8Fv2ebD11V3 + zOpr23n42BcB0KBsBvvcYAFXbCnS4EwH22s14hzIXQHtlWAkdSG+wpj53Xp751LKtAzLHGgvwkgc + Fv3Te5qusxQUk4df9UBpoad4ZoyZR3s7Z4MvCg24UosJSQA8iyAoEbPdAWZMQdNlzLaY2Q6IXYHr + aTkLKuIGOyxoicTblf5BaDq/mV3RUaOzTUKBrO8c3IvBFfhlf2WIGKR02sqPOFYrPADFeaVikplC + xZW70itSXFpXKPbQw+2NBIIi7U2BagsUp+3t8722+mEvSw6/tkXaD95TjY5ZUlpKSM4Iqxucacdq + u9be3HFQSgZ6UPZKu+pQkWzkM51E5FVVOKhiGVkoudlzMYCSULqn8Eyn7QXu65HQGiFp+s4gwquU + lYbdEAsakG41RRNx4u1t6zLVmYb6TF230sjOtq0yZiOhEc/UG7ZIQTzTKih2S5qutUhLxixntmUP + 38AbAvkNH8n2Gnc5GelEiQ4T2+p/eV/UQKjFdLqZPTvbHVB8TDBbnako1AyujEHPYUIsMdpe19XE + JaFknLCDb04nLnfw6UFNPAmlrkyjOLsSfVcMmkYrZY4O4KQdbO9IKFHJAXCGsqB977/uf15pkMRI + PMhnakaOmQEfCfjrPK90ihLPdr/SQuATMbMtrtQPtZeSVwZjGciCdnz4Y28QQ8UkVMvsXsOEpIHN + g7kV3lN8Gi7k70WLA0JT8NSBoHh7R2GFgQoUpOl0JKH2Qv7eSHkepCqKg/beUVhheEIH4B2S0OnC + K8M5lCz01xqZg8GyF3CmWRJq58vI0yZK02Ej81jowDgYRkgGjtp8n3odNjKfs0ijR9wAdA9ox9BH + gu3t4F7jlSrKriAU5ZfOFCd0JN2OXCm+THsrTub0z+fBlRmVvYyl7mnrOGpT82VMxaVlG5LMciPz + sFKMIFpg9zJciJ+78rRsBmENjtrwrZa3d+gNGmfYIuUztZ3BF9rwy5mCgo6C4qGHbxwB24wOOdEh + cF6NtZeqioNXZmh7AfwPRFszC+3xvbLQkqZzSfllspdhdsU46vZKPhkJDf09FTviWeiZezoQ6sng + T0HTK+P9ZYkOOFNLr8zQ4I/iU+NpJBOkGtDg63ixcaB7mkz1iIR/6Dlggc9wvheqYx24YswhGenK + 4LwhSaiX4V5JaKDtxcw2JBXVZSuNtL3I/D//8kojrnSi+umEQ75+QSi+MiMfaRhAMWE7uLtokUI3 + oUOipjfZ9qKPNGCu0H5ke4Ph7XUMI1EXe/jwnkKhFPGk0koHDR1JqMO6jJtmyg2GuSNPE4TqVf20 + w+HzPxrg8AOUpXfBoZdypWEAynR5LINcr3roIw2a6bzGMQOgZgiCgoyHRHldkwavmSvQ6Myxzq4Q + Yy3g8GXmCk+D/wDNbjH1OqXtFWri1RyordleS8t2zfTlmrIXCLVYRoFwD+unPkht+C0OXy/laWAj + 0VQ/1Vi01buF+V86U0/TBgEPjPVTD9AOAVxx4UoXUDFNBQ0MLTaNUHyAYTqq9ry9U/eeOkl7S5IZ + rP6Ad0XmMQOh1HCn0MP36Xk0l01d8VmR0t/GoVAp5wBCiWd7ilwpbpvpRvFpCaAsU3+LQmXtxewK + bO/E2jv1JPzi9jLyajncX1opaC1gV8AMAofkfEl8ylU0Knvp0ZnKU1eSUBzmuFrpZX5vgWUabvcQ + VyqFFSCUOGDNzELnC90VJq7E99QNQkV5Bh8IpStjsS7j04b0g4pGQimWmXfYXSQLHVwZHCGhkPMK + V6o6mrgzTxtQ6Q6cbRkS7/XHg6LwKgudxQEo7c/rLJIoVH7EvUE6YADieqycO5ywcGnOQcHLY4Zj + tozMpQNCMQt1jdADPaXD7Xi2Zfqp4uH78RwoGU0HQjk9G3mlUV+eG2Tba0ZnKjOKJ6Gaku3oMGuX + Xop+bKUo1OxW3dO/sNJAQ22SLELwXvkB0Raj6ZaqXSZPy0LXSOZVVbHl6EhCMdEREckMPih2NPdC + 8RGvEmCZQockk1DDj7jP2XtiTOJU80oorNArIhzYXbkLh091VwaF1h0HqnzdljKhbkBC0UEDoU7c + Xtz8yo3Vpa9tWWkFgK+DxA5qCyl8jSUSGj4FGVqpGERCKyQ4/vZroWpinm1Xam2B4W3dSmcCtiHR + 7BWchXimXDhYxh8xAVQtVDEpkyl1GYIWtzzbgca1Q9GWtpe4UAYrrVJ9+rpQ88Vle31VVVzOl2rl + pViPQqkugwPqd1d9F0kl1NdCXSfUMJ+D2mUsaFh6xtcrhcIBI692WKIU2/CdEvIWa+1VM1egiJ7I + VCv1rVBD9VNPQg1Gx8MWs7ghlGaRMISvZthuWYNAKJUyA50pfTHY3u17qmbeXrKrC8C4ZYKCWpDC + 7Z1opbqjMV+2d217fbdSXdXaqlgm4zp8LZSqiiYLFVdKhfgzFkkzFnTe7VZtocL2Ml2Gy0LlM+WJ + zJXBV/nnuEVoxO0ltHZtneb2yjgyDnRlwJCLZ4r+ha4OShBqOT6NqEj19vZCA4b/JmuveE91+8os + NfFdoYlDy0PV/5qRD79OL0qohcZKe0FBxlemdWO7Mw24vUuPTG2R1mc6o9CivfJK+Z4WoWoxg9WZ + umKRan54MmRmqoTi01ZWqmRFypPToyDULkLnaqXLptDnSmggxjZPjzgMt5WEYiReT4FbzrR6T5cj + D9VK29leINTViqRk7SVoUEtv31mkwtGx2l5O7JhaKBkHtXmmeYh5daZTd6aK8b1Ey1l7DqHdXtg4 + r4kBFePOsXGYaqElYViujGMsKK20MIJ2bQ7BWEZ0sHHQg+2dmu2thIZF6PKezhUJle9WahHRobIZ + HLyneZBuWIT2jpljzPbifE7sL8FW1xbJISnTnB2zfl7bCu61+Z7WAIP+s9peq2GlQS+KFMRBRXih + fJNC6B5xX2xv7SNxfttXQjGcnrPnMDKDqGaxCSuaMzUMI1no/gYG3+IwsEA3BYXK2uubK1P1pFfG + QRVFqsGKjPJdrdSut3dS0qiXXqhar3R9gvWYjN4iWZxpG/Tyymy4K6EOoKSVLra3FkpXZr29Ewp1 + mxZJcyPzlhksQpWovZVQhyMOkyIpZA2C50nkGwyNIlUGPyuSUvy0EWJQl+BCtX5vEhqw8cpBzgGi + Ni1VoDLDTBW1Te32qtpbyHAvbOVpXNCbm5dbTTVxajEz8plm8D+CBYteNNvrmTyNAgqH8bhUDLq5 + /XHUVP33M9HaAHJmnUdKB5ApxdZ5i0ZolWg1NXNmO77n5vbnK3VPWyLhT0GxviSPJAilyWXMXEE0 + cTKi4+bu6Ya6vSLWT6f04kugYso5zMzUaEWhSnO314T/1OyojCwIvb99Id4VIg2OAKv7bM6h6rQ1 + /aT4WuiPW64Uay7aGmkis2HjYHb5KR/d0yvFtGljWpubP3/g9iZZcWKEZE95bUqDpN7Y3mZmUN2+ + vS6R3Dw/otAUMmOnLURSTrqnql6pfGWI94njU7OAqPuVPv94DdTmAIBx4MOfL8KuyCudcqhYLouU + prt5ueHtnakYlH43Lz3ild8bBmdKPMx/ZDLScme7oPjm5f1ZY+bQEfVfOrBu/mmxvWQcbMm6NSvN + szKpqSp9g5XBijevL6/EuwJikNbmk5nt3IbPG1tVTvXcrvT1cDJotSLgkq5mqGkKhQNtl+0d2l7D + QHGPW6fwUwJX3LyebshdIeaK5BbGvivTsUWiBsTR9pq6e9pzX5u8vd/ROGRFAvB/x/yvlk5bbFAs + 4Waz0onDilBcFDmzfXO4eTEkNPIcKNfR2lx+ZUK+MitYRS/09htp74Qz4mF6r8Q3uOOO+LClvZ5Z + g+hMARKjxArUzeEVDb6/VkSPbJO70oErsudAL5UTha7XRfy9w5W+HxDjc+0cVyuCBIJazz+VV6ri + knPg8vQsFoNuDj/y9hJVkcNZh53noKdF3PBM157DwlPXDke+eX87ELO6QyLoEJADsD9Trv6TSkqv + TLOZsuZloQdcaRJqedxAWHuD0NeWh8RZdsz0aKVLtr3Kc9VCAdL75eZ4emM0nZr4nvbzZdaJjqFF + ihUxCM0DHTxtp/sXIiOFEhvO4DMSSifzOSAOfuQ5xGpAp+euTFGRTuSYpdAE8UiTw07JYesKlvwH + FkkpjtqoDR8bPuSV/nV/Q93TdmLAjHXS07Yy+PKZlvdUrd/TXujHO74yMBp+ItLgSQKg6rAIHT3i + FHFTQtKicbByt9f+Zs9Pm5n5aXNKQnTMy/bOI4NvOQsaUKgiZKAo9P2GEtGe5ipKHJKXGvzcYhZx + 6+xuVD/d35zQc4A8pKawAliaPhtWxBxA8bDglr00Cy3OdijOtvDK2LPGofmdtizS/u79lVCvyAGA + I4M7wIwNhcBnS3ubwX/U3Sa5K/u740Fj1DYTCX/akE8/4rkCpXaZ+V9Gp+/vvn+jv3U4xSzFp3Ps + WrYvESptqemIQaAZ6Mv+62FPbqrFoTbBoUYNi7abjpnnFjNXCZU8/P230yv1y0x6Ih8piEPM2THb + DP8zlS494modj9dC78lHykPMget1je/lpw1tr9+0vTX1qO2pJGqhr6y90JyO2qul+PTCe1pazJjy + Wu7g29//eCV6ZCTygXltbSsouSt4Ty/vKa7dFR5nWQl92L9Y4pBEVttJI+H2Z/3eOSvSChTUrfTh + /dESfy8OMY/Tte6DYgHfK5/pksYxG872/vH+hRjFIz5tQFzZsRy4zFRMkd/IBa1rMStb1As9cliB + oAKcCipGbRz+k/YO3ZVYtpfGtUcxpbN/OkFQnDRc0wgJ4Bv81NPW/DVdHHkk0/7pJ5tBrTlNF22b + pvu8GWypLqA5NX7ZU3YFGIqQRAION0reYPW02ZGPVDHMrBhXupU+P36j7bU4rj1ZJJjxPShlnjGD + WPqhRMcKVIwKxuULEnri7IrDZjrr00o72tXAZtBc/IhvEkEnoai9M3Y3oPZ66T3NLPGbYUXFN8jj + ZWW/F4Ra5k53ZJG0hE433FO8lRuklDILdZW4TujrE2sv0tuA9vqOjPTzV0Y1VwZeg+nL/m2fhRoW + Gjoy0t8R2l0Za7/s3x9uaXuRbxuSV22/DKZ09OrKDMxgFXdTTnvQeLV/f73jlA5u7wRWQroy6K5s + B1BlViaZwZZsthJ63KPBzzPigcZcd4WDhS1Tl9sqCl3yn5sG//jMBn+Kmq5MU2vTM35W2yufaZMb + rOiYOhrz/V/fOCEZaZBu7NJ0Vc6BHrXhSvMjHtZXpoN77f+i1Gv69wq3N7kW42Y6UsalitUI9Ry1 + zai3RYVMC/fa//UvbBxo3AC4K1ZQJDIObvNMaUsvUaSPY37asofvbHumv/O0rWMZuKfpaft5z5nt + CUgDrmYlVxUJ9ZozZoMzxfCQgmIKKKycXdn/y56312NCMrmgood/fqVVfEpZULXLVbZe6PHEUUDg + 8F93zP9VomOckMTMNmVByTsae4O3Ny98Tz2ZQZD+u6EiVaDmtcu9EvqaQ0XoXsNQsWPh+51QUbK9 + tzeHrEjIEg/eoJOujLtgey1DgxzeU4eKJAXFtze5LjNjQnJWONbh73NBZaFHzA2m5woaJUF7xari + hWe6GAea8dqipljo/vlN72iCpGbPQWxdYWiQ2W1kzPJ4WZ1zDiPt3b9/WMzhYzsnxDK2mX+KT1tm + Ddp82upYpmMXr4XevXM6HacOQuGg5aarbK/lV2YYQBVn21T1064Qf3v3g+un0ASARVuQ3hdtOfUK + GzsKoExFq7UitGkZUG+/3t7SmU4u94lLYQVVoOw5Dz9WYYUflr1uv31wZjsg5CAAlk+4MqYqHIwq + xcTWy7bXMNePKPTh5o1yDtYzIZ7tZgal/aaVngmK59be6sE9fdh/NwgjUTiSCWxvV5eB9p35gpVW + qIbVQJBe6C3HMt6wCxqlCZLaXLTSuYplSm+mIPTuSKnXEBhcobuJzDSy8ozQ9bpMt9UroY+PhiyS + 5uxKO76HxmwtOIeB9jZCK/ZIPbX39OH4ncDkE4CLISEZZuk9raqK4RKhMxf4lLjSE0OD2NkG+ilp + vgzjkcJQaC7wcUJy5iqq5CPdPvz8ThSdswmsvUpCdFTTkYaOWQZB0SC8FlS8EvqhsR0pBiYGmS7q + VZSFEgtfGw53Qp8pPoUBOoGrimtYZp16ddvhf3VBTF1lE4Ry/dRiiSSk31asn16y0sDuiske7+hM + n584sx0MWyQv9RTnJDNp7zBNR4qkmt+vF3pk5JWb2DjEjiW+WKTtAl+Z3jut72kv9OUGgW0Rh5dh + ZnvuJqcXoWfC/1iZQRpxKFOg3L6c2CIBiyNZJAmls1sp0ubTln2kdZvDSuhrzq7wDD6Nc/H+vuxK + U8pM26CT0Dv2Br1joSKEr67+b3iDpcWsftq4h7FeaTb40bPBD6o1DrDxZ6FB6zXWU6e7GXy3b985 + gHKKr4yNUtRWoV6HRdvsbIcdZ7ZH2nt4KWZQZTMolacZMKN3I9u7FkEZFS3zrtweTu/sDWrOOVi3 + YRy2ztSohdybkhuD5vTbQ97eefZ5ez8FQG3OtGIEpQi9SjLfHqhSDIkOxdx0rpsKatgxO+PhV9XS + FSS+7T+9fT/dcDpdYSwTcQrVINFxBvyf5xS7xtR32/v+nQsHHukcUyTVUit0yauFyL85U1f1Knrm + /xdDxffsOUQcugpnKprBSugwY1YNn9r2HI4HLhyA54kDxdpBujQApboyQxhJbRAqSu4OKH77ccO2 + lxAdOCPeNp7D32d7ofHCJ6HZXZkpTQcjmYYAVL/hguY+cbZIuNVW5gW9/bh93GG3l6VpgzD4T5ir + qCsI31B7a1BxRX7CXdWL0Lv9M+d7HQ5zhInMfmOm7aZjFrk8HdfGoVvp3dfnOwJXeEJ0+PTFBgB1 + K49E3Jh/5Ph02o34Bu++HtHgA7EMM6C2c6B+pTxtq0h8nO+9ezx+UAefmjj1OkmZbcMB1LStSDE7 + 26ZuyW8THXdPuQKFgQMmmdc5/N+8Mmr1DVA/9V/uXo65lBn5nl7G2HapUCnncPf2kgOowJ5DD0AF + oYwF3YzEp6rjwG4Y/LvDI78yhoauwpgk6RE3i/YOrwzq6hVBxKuN5etTC/3BSGaVpw2ajsdMZdt7 + xiLhc8tdmVtP2937t/K0WWKCasdAV/Hp9iNOLkpfE6e235XQIxsHHJoBxsHZFoBayl4tDFAyDryl + FQDVtHQZd6dnRjLPVIi32GQxXOlmFjSHFcSTs9zTqXna7v6iUDFgShBXOo2TzGce8VC1rgSGoa7v + aRb6/OIRuzLBlKSrGXhBhafNhGV7N67MYpHqlu22xezrvthelbu9JHfFXlKByuj0gl0ZcKd/fXzl + woHF2dPQ0LGF6NgsZWZvMK6rFR1j29fnb8VHsuQjWalJ55JXhjLYf2SCdWTpE8/06zMZh+QNUpsD + RMctIV6KM3KS+VJ0+mpYZ9uV+fXlhvG9E0QrV3O6OxIANSM6NnMOlrfX5zSd1aKP9PVwOlFWzWGa + bnZdv0zXGTQM/+1SyrRoDK1MTf/1/StgQWGe+MS1NiUZh7WPdD4oHihBFvqWe6AmTSgd04GK01uX + oUGbK62AbTXQglu2a6E/LhBqVkI34tPa9I2LQV+PB07TKXRBkUNSqBTrqkln2MHn+UwJOO2G+d5v + N4+cXZkCY0GNyPWKZ5prbcPtnao80nJ95sY4fNs/cpI5RE/OdpQi8ZqNZKNaEYoZrJC9zINaCb29 + 53s6O0v3VMyC6qrNYcNdcSULqrivrUlekdBv1KuYzgnbe6Fs0QBQK3eFngs9etpmftr8bldbp17o + Q25d0Z5bV6IS8L2aR6edKXst0JFJjmWgA+nLt8fn3FuBDR3Qq9ixZaqMBd1+T02mVlC71YAt5oip + Vvryll1Qw4kOJfm9FzW95jOdd+vup257X94ZPg38zwSfFjHbRpU1DhVpWliD+D1VYtT27e0HZ8yi + 4oyZE9Hp3Jx+JlTUxcMPS96sF3p4uqd7ClPwCFwhkRwSOv1MM11gYpCI20sOiVTg+3Y45nuKJZIZ + Mh7D9/TMPbVVvje/p5KP9O1wYr83ENQ2Ha5U/c8r3UK9ruDTekuR3m9Lx4HKBb5PRuIml73IDOrd + qC7z7f2O41MI/1F7XZCSzPECizSxULVjdHoXFBehnGT2jvtPVTfp1WZCjO3cYE2lS+mdQcv2t/ev + GbOtQoZ7SQZ/rrV3qEh6l+dAxY10+rf3bzmWQaA4xDIdCb90poU7Hf9XlIkrh0K/d/heKSi+SJH0 + 4mxTG8sgnf7t/YPDCu8NBVBWBFdw2WvTDLpVi5kdv6fvP3ilQDpNKxXbe8+udP3XpiZ7Qa2ucvjf + jk8Zs43GAUuZkrvC8OnNjoM1ZlsJv2UW+toLle6puUjoktneKmV+O+aq4jzlspdrAyjYXrdcmYu2 + d3OlJ+oisVj0R3dFvqdVdmUj9Vpme5lKhTr6qW+nA/OuRMV5JNeN9i7vqWFne8i7UrpIKLGsZZ7t + bx+5oYMaJDGAklq2V9iV4UqXom3kV1Uyg/f7RxZqKYevpfmnv35l+GS7PnEF3uD9/pRTr4Fx+I0L + +ptCu2qFSULvXjClA4AZTjLbrtZ2aWY7D4lzjSK1YcX93Y8XtlrEpRM7UDFx6VxSa6tSVbaazcFt + kpXQxyPbXhw7AEDx2W/kkTYVCd3Eknqdhu1I99yO5HAYKIMr/gao7YpUYaVI3n+5f/2TEx3EGjTD + cOShu3IG0ZG9QQqHPa5USSt9f+S+tokIfJIydETQsLWrmvhWbpDPsfKOeHhlLfSFhSL7NJS95m57 + we5WqdeNLhJVCR2jXu/f3/P2IuQgbW8Um9MrMzjMDeY8kscznXdM+dILPT7nLhIdKcncTnqllV6S + c6hXukVVdF8y28i3Ddvb0iNT68olKJ01w8y4wHd/esvbqzlNN41Z+My5NF1JdFjKPMjTBu9P77jS + 6VpPbJGMZAZrv3cDybyk0+1Gge/+lIlBgudXxnRFW5dJFNsoYS3UrAtAS0rHtFfmr5ymcypSmk6Y + nG5WvCujHihTcyLVIYZqPIeHmx+c6DA4OT0Jda4zDjk3mPmRho94nZBcHLMWPv2w/4nw6fTL4FxF + 09OYE6h4BYIaXpm6BWnajSZePdx+zZAD77h+6tp54r/ziK+FUpPOw+09BlAwtpLLXpPIRnIJ70oN + 9wrcECo5Zg8PuePAKcYNegmPtLukg6/GOWxdmYfHIxsHj3ikGQhYhFjmwsLBXAIovCYD4/Dw/MoI + yQmLQREGt0m8K5W7ciFusGafXlcVH17e+coE7DjwMN2mtb3weQFr0KrjSda8LPRYhJostJvBZy7j + c3Cr8HAxFG1C8uF9z7FMdBnfK3UG7aoukqHnECsKlKrXgPuLa6FfSw8U5/DVOnn1m/e08/D9/OXx + 9gYDKGAq5qmgMqttlU4fAtsc9596dFcMrleqQD3e/uQznQ2YQWha7MAVcKYVUFxOXjVrrBzvq9g4 + 24/Pbw+EEACobVIkj9iDwUrP1E8zxszhlQm70cygx7fjK5FIzNQnnuyJ2BFfYUE32nt12d4aYxYb + RXp8v2PWICLampMpkyLxXVU4GAqtq4rogg5Ygx6ZCSpdKxyHlyy/7d7TS5NXhm0vsTEbfL6lJPOf + N08ZPh3Zw/eTgDHbnXXMGkXagnv9efvODKge0+nAgBra7mm7htoOV1qHEtMq0bG2SH8WEglFxSDI + 4f99j3g7/gH2Xn/587nwgiJFJ4xm7nKDoM6xKNIWL+gCr62y94wIrVb68lzISEMmI20tEvS1YQ5/ + 5vHvbiR0yeFX8ak2zZX58+XAbQ44D+pqouG2A2c7bDbTlZwDzaSjxI50Zf58/dptr0TnaCqhG0Bx + Yg1SuL2qeLyd0LcfWJ6GkV5grUP6uUby8PFMzyQ6auq/yu/tirZPN6eCMeMCX+uukOdgVbmhQ6FV + 6/1mt1cSetjREZBjppBNosH3ZhjJFj1ye2WsWr6GpzrSL4xC9/tvOzxxhSudfZddQaG6apC8TKip + gG0w3nol9B8/SKiFOTMgNHQd8cuYrZ26WKitInHo6aqF3n7/2JFfgYkO5NIRhNZNr58Q2mzv3Q2/ + MpPVBOHz4pVZdQbJfi+x9RZmRTVEpz/dPR9opZrySHM32rva3l8503ql8Fmv9OstrtQjU3EyDukJ + ljJmpL1nq/96t3SRuHXfQb3Srw+3pEjOzFQMit3YSjhTdrZ/4Uyr9xQGNnOhhoQ+vpPQgEDxOb0O + HXwahHJY8bntbRXp68vTDo1DxLoMRG2dY/b7V6YV+iOfKflIGpOEg6cNDX4VmnRnWn4nU09Hcs3T + 9nS/55UarCqmMzVd9f9zK63PtFnpfdZeFXCQbvLoJO70erCCzPWaDT7PraBeEhlc8XT/sOczxSlm + MzAPCNpbZ8w+p72rlb7e7Lha4XO1om2mgziDk1ebYMUaoDitADNrH+np/v0nrRRsAtXEu9zg5860 + ek+NbYT+9UxCrWKD3/cqfk5oVYiHJqp6ex8evu8wvJot39PQs3sp/u5fesQ3tPfhH4+00tnySkNH + gQKeQwUN+oRxiGuhj0+nHfmK9MpEnJI8WOkvbW+VvIKV6kro8yMExdDvNnseGSySvSz3dOxsh2qa + A0ZtgzTd08vdn7TSgBC+CDTUrRksivR3OWYvj8cdPuIGIQdpe2MXnxZ35dOvTGMcXqlfxmBDEMan + ses/LVjQM9iVqcrhu40SydMBIkSoQDnsygQQVFciAd+/QnRsWKSFAqXCpXNqfSUUzBUWg3JVUXVC + NYMr2ikfndAllLAr2G1shcJfJtvrqDw9CTTmSajlCtRmWFHnA+fNlWam4ojFoAnYgyXAjFpWOnRB + deWYOU7sSImOJJSJQXCwGM6tEJteVyQSUnzaai9u8sAbPN5+oyujkS5jlhCScGWqjoPPXRk+cBJ6 + YG/QzzMJhQHjvdCKse33jcPplcte5A1CKVMCK9ZMUMMcvudInMrTZaWsydX2fr/B7Z1oIjM+bZ2H + /7n3tF6pphnVReiezSBxMsPT9rc84lftcM16e78//SShxnH4L7or5OH/isFfBcWN7f3+dsNCDdve + qYPEmxxA/VIkXiGvWkX6/g9+xHEt6Gx3ED7wHM6OZOrOtAkr2Fyh0I8HfsSVnSizHUX6qRXkYKi9 + cx6HR1xtRmb+f/r48wD7kBYPnpQOEJJ/dpIOJg3/qPCfPYkEC33F99Qh2JUQHSLOARUpo16VLDSj + XgEorrfySD8eH0iRqP803VPfdZF8Lqyo/d5GkX4c+MpowzRxpmtzgCtTAcU/Z3troT8/GBrkiS4D + YOrDmUFbtbZWqKgEJPT55gX5kSB5xfxIk9j0elaR1n9NFNCDyenPNwfu4Ju1pUJ8y0ZSIZnPaG/s + Splyk87zPrNlGp0L8bZlDfqdAt8aNwioN/vl+fb5OfdWcCxjxGLQJSvNfW0xo8sG+N7n29fMTYck + EtAi1OXwkwm0lxDiTSsQVJ3oWCeZn++emb/XIlB8MteqYw3SOeewVVXECtQitCradp22z3cnrhTP + jp3t/mkrtnert6I5zepKM5NbJfQx12W8U1RrU11CErArFfJqlF0xVS5FuxV2pVnpn1QpTg4qYleg + MCcNKqqRVxsYs4UPfwvJ/Pzn4ZxQuqptkpls/yp1drlFevrInUGaa21KetrWkPghyeFcXpmM7y1v + ay305a5Q6QYSGuzfSQzSoXTUlIR+O1L1XyvugTKdh28u7K2owBUjLCiv9D3Dp/Mro8N/HKP4Diql + X55f7/KATkx0ADJBapA01VTQDQIfl6O2FUS8W+nbK7+n0bHBj2JDR+X3boT/qhT45qVxm5m+aqEH + Zp+OsZS9fLO93ibnQ+1WnUGqDF2tV7rEL9X7YmyTZE5C8T0N2KSD2zuLvCuXvDKBm3RqxKAUnz6/ + vWe4V2S4l57blcIqz2JB17+TqUPZTmg1JI6pFZzkbNdwr6EiRe5VVLsW0bGmy3h+z+B/E7Mizf+h + ED6drsz7E2vvHLlPPK5hmb8p1LdCrf7yfMxE0Cb3KrrO4P+O0NAKdebL82nPFJ0BK8XggkraWyev + htWKwIAZcj4ZNiwp0unPzDBD+N70LZ/jZG7W6Few2+YRZ1Bx8igi2l4nd0/bKgu60SeuCyxz0FNM + Qv96ZISkmrgVVI87g86SvdTo9DEs8/njyIMVJhpbSeNXeqGW7ukmsC0uLdtlTrF4ph85TVe46eSu + TBCq8xDXYYHPlO21C5ikE/pyc8sWaZomOtOpi0+r8P+Ms70IrUn/TOOuvOy/cnsvEbbPQS7wURb0 + DJ2jYXyvL0+bFZHML/tnhpE4nPQKfeK6bUdC0Wp3ttZmVzCScXvvy/6dobYzddqmrZAU6fw9rfra + FCrS+Mq83N7zSoNj8L+SOoNM1cF3tiuzNJcNLFISysbB5+FTVhxqU43ZGmZXQjWDryKI6/plXm5/ + Zm46CoqhbfDv5MOXYJlJKI/Zmgz3ic9SZ5A9C8tci1vhXTuhd0/lEec5UHb+O9/T9Uph7+ck9J2Z + /+cAQkNMtldSJPSRSC82MGYEy6S3cqnLtJntl68/mcAnKCbwaUcyYXalJmwfAlDXdH9x3dZRC71/ + zMA2asNPDrP0nurVlRm2gobK2Z52I96Vl/sDP20hcuPVLHK94iuzVZfR66mghvuDpGLQy8M7V6CC + 0wRA1WHYjrRVrZAUaaS9j3mEBMG9kiJFaRYJQYPyoKJhI7PO4X8N0ZSEFi4dPtNZGhJ3ke313Fth + K8dM3N6n3MhMk14jkJEKhXjLbCRnSA5rKpslpdNyMr8856AYGBXIOEySN4j39GxmO1Q5B9/E47XQ + jw+eq+h8rp8KaTpd4RwuIuHfYip+eX3JAdTMr4wX+2XOZszWjOI1ZrvjkHx5PTCz4jRlglnR7111 + kQwjcV1RKyh8vERFenvCuozG2dNXGlCL3Yx4mPRa8ZhtkzLx9kYmX5XqMi//ODH43xOl2NS1mFWQ + gzMtZnlksEehLaNOJfT9lsfLxtzt5fRnyUjzCImlt2Lg974/FEZx9hwAFNqfaVUp3ujgc+XK1IrU + Qg5e3rHNIWic3otzFYNke8kFnRfMmiCUABUEFF+NPulX+lpY+Bgo3qdeATd4SUKyirt1XGHMmkf8 + /S1P6KCZQRGnZnz2TKccVmy/Mu+5I97h0wZ0jmFIOLDl965F2E1n+/1nBisSETSwkUitoBUAVVYk + cXUDoafMyVwGoIiQA72iFFPy9uZSJjUiLSk79CLcQoHycnpCzyH9ICzET+nQPzssg7z6Qo9M0GLR + OHzP1QobHGlv6BAdkA+opg0OATPVQ7aaumIahOTLjyI0T0fqwwoQipltdFQq+sBOe5ctrfuL2y6S + l5+HMv+Uu6fFwX96ZZGGkbgvRNBuySb12/svhUrXcmZbi0DxitZmCBTPLqjaMV7FZOukV1w6rzd7 + DhV5Kqhve4qZaGtFGjx82haMWV1PbFf6epPJ04Jl8rTWMSOOjgsYxetzXJG3z43n8Lrf31j0HGCl + VxomBnZnCltbZcxQNCIY1kJVhYe02JJvrRhWvO6fkaJTIUExevgiCb+5wHMo91Tlp83IHXyvt3fo + I6UrQxOZJ8STDD0Hvdtg4ZtW/Eh2N5pp+3r7wAHUZDg3aCQCH3vJlaE8ElGg4HtqWyVgoV9vmMfM + 5jb8IHG9XvS0TUtQzCrUojFY6OMN2l6LVWlky1SfFhor2+s2klevjx/8iFvMI00AYhGuTM2AOhS6 + 7vZa7HBLa/P6RB18BplPrrQYKhaDjz4IYyh6oaoexlQ9bTvf3tOnE5N7h2ipT9xKY7bWpcxBn7hf + iLaoBKat6OG/PpUGSZo9nd7ajnAAPIelQXKcXYlVlqy2SLpd6fMLWqRkchFcAW3X3ZXRatfNKca3 + s9neChRrPeM6lLTS59cMrkB3BcAVW1HbVgBFkIOCejVo9sXtfaEzddiTnhQJuNMloRUAdQOWSRgz + jUXbsTf4erjjCZKG2L2S4ZoEWpuasH2DNaitmY6EHhlyoHHwXySC0M9apKniBTVC9Z+FvuecA7CX + U09xl07/nZ7itSJRge/1eDpAhTide4QzhY54EckcFu3dyJgFPNNSgSLOzH6lpz2zHDhMSMKk7Fkg + rqwRHRvV/7KuTSLo19MTkxwaokdWmPEYZMy2R5ES+zRXoCxfHPGe/vWVw/+IijRPWOnrtxfN4LTd + eJXD/6I8Ayao149bxpjRuHaYaSsOMZ/PG4fC31tAMrZtxshC87h2QwW+9NyIYEWGe22RpxnFrLZz + sUhe9pE+Dm8EQA0ZNwijmfszrbR3uNJ5NXVlQ5E+Duz3+swLajt+pJJz2GauKCst0BEjswa9fnxw + 8gqAHOk9Beo2iQKlmt47DCsie4NEQxoE40BC3/b36CM5nkwHeSQpKL7IDGYfKTTOZy80VxUnGtee + fjdpzNZFQjOBD41rp1Sz5IK+7X8U4krHIyQ+R3K4/usasUMkllXU9nb7+JI9/Ejbq2aJUgwtkj+X + w6/nKiq8OJKH/3Z7zEJtFjqttndQ9iJHhNPkWrlmpYOtYaEPZPBtCisU0dqYjhgEui4uPtPV0yab + wbencqZa57EgEs92RXk9fNoyxmxqCl6d0OdbDissFYNggIXg99qq03abhY+vjN66Ms/H7OEjABU8 + /Em4MmTwtzk6FIYVf9CAjLrK1gl9eShXpmyvIDRTFV2aG9xWpLe/2AxaxTn8KCI6quTV8MqEKrMd + GdEhpXTeDifODUbP89q8ZHszW+a4wFfI0+hMPdP4SE/b2/sjM7ZNxMmcXsCONBhRUWq3oHSG4f8S + HqK2Md61E3q8Z+11OLcC6JElPofd6hEfOGZZe23OObAdafmR3r4/Mv2UQ+31Gq3E57KgecbBIk7m + XXn7+MHVCptn8HklDLVBwOJmZ9C642DFadZyXh1ubjkhqZHcOyYFEN2ViiZuwyLZXJ6m8H8ArkhC + 2QVlPoekDGIeqZoKupGQDBWaLqBQSXsP+2+c0nHBZSLoDnKQ80i/kOjY6j897PMESYPGAXDUTsoN + 4rec4cOvOSTj6hFfY0EPt3s+U6IqgrmKEnf6hUhmU84UG4EGjVcHnrqSdmbisEJLirSeyHwGwtd6 + R73QZ16pQ783Tkj6OnhlziSZHWe2qYgZd6PqfxLKtKtm4j7xliWeCGYr1qANi1RjmMfv6eH2NaPp + EHkFaDqxr+0SKt0ctYUdw716SDwLfWtn8CkJXEHuSjwXKpIi6RJAKdEbPHy950SHitzmoKWqYs5s + jzHbhWgrh//jLOjh2132BrFEogdUunUF6rcLfIdvP7JQN7FQqSZuKmjQJe6KqebF90Lv94cJjQYU + nlJY6fA174XilVGbQbGa2TFrQba90B+Z+k8zY1vQrRk0lsvTeFDVrOPxShuKzuZpe9gz5GC2Gd/7 + Wb7BMmVb7TLUtn0hWGiZjjQ5rP5DG7VkeyvtHY7vCUuSeXt7H5+5Js5E0Om3HRdtz8xVzCzxNKho + 3vHgP0komsGI7HBoBu14sILbTF6RW8I4h7iRej087TH1Gq4DvTIwoFMYTF9nzOQzba7MtAGuOBQ+ + /FlzFnRyf2fHQd+VOX85PB8zCf/Ms72maejhnzWDutjeLUK8A9M5JsVDiwT3VBzmWNGubmTMaopO + XTBXndCXm4xzsNnvlQAzF93TOpZxG7HM4eWV3RWP0xwgC/q5nmKsKsackLS59VU0Dq9l6GqI7JhJ + XDo5ybx5ZSYWqrEkPS4cgFDaBxuYWsEHKU33Ke0dtPce3t7fiNYGhiLR7GlpgmTNTbdR9nIVC58t + WA5BKFeKI5K9zMkzl+BeF4Er1oOKSjuzIPSU4V5BEdxrUoLBr23vyMOnOimvdNryBg+FLXNi5gov + MRVfpL006TWPBdkUymk6bXMk3jH/w7TBFb73PCR+8FtmoTljNue2QStmV8BdOdcv46tXZquD7/B+ + B2c6QViBZwoevhQUo9+b49NNzDaldMjNHgTF738WF9SSN6iluozxy5WR80i/sr3vpzxYQTMIau4K + 8Tr3KuaE5DCHv5SkK2ebkswroX9llA6m06FaITH//6pFqocbEtttldk+vP/MijTn/tOu97+AoGpK + aVGRYoPoGPhIx30OoDCPhG0OQ6F5vOxgew0LnXYrCJ8kFHH46Shxe0O4nuOG57BZE5+WlVLBS8ud + tofjLUPiHUKDcLCCZAYr5NVG2UtVj/jWSp9xez22h6ftVXJXJlWK9faIw5xO9zmNo1tq4yz0xN3T + MxXik4cvFeL1WWr6YpHqkUyDSPxIlGLAkqEZGtTlkS4ve6mLoEGHY4lPAzP/G7GqWA2f+v2g+HST + y9ME9wK6eOkRX+WRBoq0zg3qnJA0oc2YnTLcC4CROLay5ejA6j/FpznRMWxHWtKtaIC0kV3Q054d + M07TwWCF4VzFM/XTnHqlho5x0+vhdFsQkozvtdI9NWcJfCrcoGvC4V7oPYMr/DTRPW2nDVYQvrD9 + nvoFu6LNptDH0siMRVsg8JHA/2q5pxsNHYsiVVGl1k33dBKas6AIgsLeCsldqfBIG56DyVlQW7Xq + CCvNfPjAK4uPeI8FBfB/xQS1McR8SUjW4/Da9t7DKU9kDpPmmri0vect0vqv65IB5QnrR/z0zt1e + Fj38AGQvAhvJrkJeyQHUWqjZDKBOH9k45KLtFKQrY5ftHabTQ9VFYngcgpgF/X7H93TCLCjcU+kR + zxySW+l0cjtLO1I9X0att/d7Sb3O3GKmJTLS8wZ/HZ/WmKuOGOTwccMtZjZGimViGKLpzs5rs5Wg + jaftx0152hw/bVJYcZ5+qhGx+bT9eCsMM5FjmVk60yrfO6wUV5N0Vo5KL/RYauI2C/0UbnD91/Ti + FOPgV4r0j3RRGY+UtVf0kS5B01GZgLWXGFC9GEC93z6xwTdYKU4GX4vYFVcLHWhv5ug41470fvuS + wwrD29tOvFqRvWymdNzCN0ijtVatr7XQd66JG2zZnoDl+7Phf1z83prHTBD6MzOgwo8GAGo7V/F3 + 8khy/+n7HUbiAab2gGMWBmi6C3GDIYMr6EGve29XQn/eUeHAe8Yj+W5Cxy8VDkqbA/UqKkloYWzT + 6CMBY5v0iBOfQ9xk/jcVmldvddq+P/3IBt/zmU7d9N4yzPHyM60rUCY06PT35+wjmcCVYiN2xK+c + 7TMAVFPSdEa+Ms95QKfXPIPPiwDUCjCzASpeZvBpHmIuKtLbDVeKKSEZYTyoZPDRMTtDrRAXuoz6 + mROE7mH4FPT+e+4MUmLGrMI5bHiDvgoVN4QenpnWxlvunpZbV6ay0mHTaz3wetv2HhYzyCOZvJRk + XjPMDIFtoQIrjgOo9+OfrL1RsYfvOkK8gpCMm+29hdbGZNTKoNvrfQmKaW7FhCiLMymdM+AKR3js + XT/bKwvNGTOvJibE6yhQwEeqWA6G7opf+k8pNzigMT/eZEI8Vwhmu94KuC6X2N6JEx0NoY1pY5nj + zYErUFPutA2mE+ouaO/NFSgWlNF0Uh7pePNXfk99ZlYcMkHxPd0gZZqq8rTfjaYNHm9+3FMaxOk8 + vVeq/tvK2R5ub6ioFfxyZUxLrXDc71+JWgFeGWqQlEBQtp2yLTVIVi+LnZkCRQqKj/uvGYdPKR2H + FBaDHP6Z4cjVI06zZgbTBo/7R4bwBWINSkouwUhslZAcjmvP2BW9W4EVBaHPeRQpRCvANyiDFafl + nm7MgQrlTLeFHkpXJrPEi/jePCzjDMasNHRYzU2vUhb0eFua6ZTP5WmpT/wSb7DCldVIJN3Gp8e7 + PRPMTtoRwaye2kbmy4HirYM92N67x7zSiQvxthv1olxJSMbdBj9S3YlZT5NsGySPd+8ZY6YmwphN + ksHXVUPHBsZsoSpCHbZy0fb4LTenG6y1AcbMtIgOuLh4pmemDVavZw0n1i3J4fE+o+kmTF7BODyR + AuUS3KDl1GsBGwwqxUkoJzomx0XbIIX/etUZNLgykfmRJkzTLSudW+29f+NXBianY1AcRZq4+QKh + 47kVa2qF48Oe8UiRIAfprknYlZqbbqMQ73KJhFA6g5bt40OmVqC5immlZh3+6xnR6ZdUoOrnLDBC + snnEYXxNElqAbdTe67GNemCRJk74DcheKmq4Gh6vdXumj9ldiYHTdE582irHbHhl5qoNf1o2ud/e + x2Mbn/YYM1hp9cpcUv3XvsuxrITmNnzDqddo2/jUL6nXzVcmLD3FtaHQqqG1Of75yklmh9CgEGQA + ao5l4saZslBCMkemrxQdsz/fmENSETFIkPva7NnWla7NYYwFPf555DnFVvHMICvVxDXDMs3wTNe9 + isZyZ7GoSNSGD70V6A3ClZHAFRe9pzMD2zw+bQ5PUzQO3IYPDR0xCz3DMLPB9bqwyqz5kZqw4nlp + ptMUFDuJo0NXvCvDACrPiA87BooPOK+Ozy/obHt0GKj333SzSHIWtBrXLrORFBF26uLxWmgZW0nj + BtJr6LqxlbaYQYN5qVleaSXIVOMGdPfKvGT26WA4lmmrFRQqXvK0hYpnu2ox67jTj693Zegq1NpC + evElmjjqKT5LgeJKQpIaBuWOgyT0QARrUEy8SgYYORY+146k2OBPOUgc3dNDLgZN1FMckbJ44A2e + 4WSObAZpe8cYs+P710w44E0+U9Wc6e+AFdVaKPB4JaHPhR7ZcuGgH/WSI/HLp5gZu4C+ulkkx/dj + 4QW1lJBUYiuoWu7pBn9v7YJuGPzjHjv4LIaleKYutiwH0vYSKoXvjp6MuL0joac7zoLqmJt0JPop + Yg0iuO4QnZ4THaWnuNjexkc6ZcdMU8dB0qiuGFRq4tvhv6m9hbpLsR2Acvz+yo+4w9xgesRNP15W + MYfkFtyrU6QxzuH48cy0NhobmaHjQEpeXWQcKuYKXq+R3ZWPQyaCppUmDZQSkvaSmnjdpBM2Uq9J + KFN0zjgVFCg6pcEKl6yUHOy6t2L0nv544I4DH3jMluuMA7yl1YSOYUonVknIrff0dPOPnO+lasUk + hf8XrtQsLihjzGR0+unmA88UqCMd5ZGc65igFIP/z1ikiqpoU3tP+8fM9UrTHJKudHMrTPaRfmE6 + 0lYp87T/mSfpeB4hMZlLzOAZofTZlTJhWEb4crrdozc4M9xrgiYLic6xCoo3EpK+yveG4SN+un3h + KWbQq8jlaQl5VT1tvz2v7XT7moWGKQv9VMdBlRsM2TjodjRsFvq9jE7jkUz+b52OtBYKZ+q+nL5m + MtKAiQ4YRSo2Mld5pGFVMT/isbqnUkf86eGZk8yEkOyvTB1WbNFPNVfGbtje00NmgoJGZmaf/tsm + 09m2FRSKNgaE5nT6nC2S2AOlzq20eA55WMaSMfNNWHF63GfAzGxYe/seKL/y8De0VxVBdSKm297H + H5xkJpwDBEHdI16yoGeGI9fjXaoykGlnxJ+evrKPNE0zp3Q6YhDgpuNexfMWiVda5QY5rqmFHhjJ + rHCaw2RlwnZztnu60V6/mEHdjk47Pe/fiLHNe8b3zp+e0JGLQTX8Sar+n96eeOLVRPVTmLAwZII6 + +576qgfK5Ja6XughN9NR0ysMyxCbdM6C/6V7OtLeQ47aHFWg0u0Nf9/wqa48nWzvlIQ+c3Yl4hho + yK5YqSP+EuYKjLs5eWUYYzbtcrmkWuk7zeCDfhluTvcihK9K6QyxK/OCR2Jx7cSrLLTYXpqcroRx + 7b/Tf9p4g9D29OV0fMiKlEuZTsSYhXp7z8cy24r0YxmWMXNVUWrZroPiDZSOqYLiMRvJX8/vGEBB + BdNQSgcGWHw2rNB5OPLmSv96Jcy2RWqOJBSa6YZdJLkdSVYkRXSO1ApK9lbGDX6/yfNlgAaf8L3j + TtszbCR5DhRRFXGHqSS00CMDcSUmJF1XVdRLTZw+PcvvVlpO0MaNAOr77Q3nBietcx5pmNk+y7Ot + cvKKADMDuFcSylXFQCgdmG4zHPy3jbwqVUUa9WJ3o4lX32+/50QH4hwmdRZNN0i97uZ5Zu0lIBql + +6VQ8fvdv3DTKwlNb5yYkKwZZobodLdgzKjrVst8g9+/vrJFIoYZsEgS5xUVg7a6SNZqU2htljHf + i9CPmwcGtgXFWNAgsmVWvCvDHH6GxKvyysgonY+bJ5icDp4GdHuBcejpMsqZnh2kqzJHB2W2rYxd + +bg53vF7OjGaTnWFg4JHon3a4HMIVQWK3lPpynzcnHi8rM3DHCfV0a7mK/ML3uCWcfi4+cG0qx5H + MqUr47v5pwX1qpqccaO9a5b4enDGOjf4sf+ZJ9PRIw4Nbv/RU8w+7o45Y0aM4umeSu1IdpVdGULi + 6zPd2N6vzzwHilnilUw4QEHxVqW4SnTQXMWWHqQW+iMLJT789C1dIb7Y3l8gBnGr3G9zpt9yFhQa + gjALOjcgKMqYcb/McltF41BnzMYlko+H90eDARTxbIMi6dbDL2m6rTNtVrrVTPfx+JEnMkcGK6pu + msPvuKDrOwaXzn35ePqRr4zJK+2Jti5Bp2c+h3JZytfGtWf6/IYlEndtiAF1+q05xbEAUDEmHSSZ + P16/5taV3KtoxC6S1keSFalOp49zDh+H5+wNUtSWvqXL9/5OSqeJZdKzMyWhb5wbhKFIlF0Ro7Zq + OPIGHskVF7TCXBFEc7XSE0fiM1HpwjTzlRlM8SmIXs0iGT5tiyDErmgrP23v+zyvbWKUDnCLddtb + p+l+6cp0GTMTvnwccykT4iZkmNFWggZVc4qH2hsZwqd33PRqctftOo/08ZHDf2N5pbONzfb+jnHo + xkC7pEg/bzOtDWVB5wHlta3PdAjhiwVjlvvEpTP9ebPP0waxcBDSPktF219dae2SsRdRC82AGU/Y + lRkZQj5X/c8tZjVzheTh/7x/Lb0V6CMlEy0Opq96ijeuzFL938Ij/Xx6Z2cbunrJXZHCf0xIFrKX + QXalHnFo27LmSmieyEzDHCGPJM20pff0DNxrYpSOy0nmAX/vz/cjC3WauXRaqC36vSS0NaWN0Hn1 + nLnm60Xo/wNFByJz0oABAA== + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['21790'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Mon, 30 Jul 2018 21:37:43 GMT'] + Last-Modified: ['Mon, 30 Jul 2018 21:36:50 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/test_ndbc.py b/siphon/tests/test_ndbc.py new file mode 100644 index 000000000..d2e4835d3 --- /dev/null +++ b/siphon/tests/test_ndbc.py @@ -0,0 +1,76 @@ +# Copyright (c) 2018 Siphon Contributors. +# Distributed under the terms of the BSD 3-Clause License. +# SPDX-License-Identifier: BSD-3-Clause +"""Test National Data Buoy Center (NDBC) dataset access.""" + +from datetime import datetime + +import numpy as np +from numpy.testing import assert_almost_equal, assert_equal +import pytest + +from siphon.simplewebservice.ndbc import NDBC +from siphon.testing import get_recorder + + +recorder = get_recorder(__file__) + + +@recorder.use_cassette('ndbc_latest') +def test_ndbc_latest(): + """Test that we are properly parsing latest NDBC observations.""" + #truth = ['41004', 32.501, -79.09899999999999, 190.0, 6.0, 7.0, 1.2, + # 5.0, 4.8, 186.0, 1016.5, np.nan, 28.0, 28.7, 25.9, + # np.nan, np.nan, Timestamp('2018-07-30 20:50:00')] + #'station', 'latitude', 'longitude', 'wind_direction', 'wind_speed', + #'wind_gust', 'wave_height', 'dominant_wave_period', + #'average_wave_period', 'dominant_wave_direction', 'pressure', + #'air_temperature', 'water_temperature', 'dewpoint', 'visibility', + #'3hr_pressure_tendency', 'water_level_above_mean', 'time' + + + + # + #['41004' 32.501 -79.09899999999999 200.0 5.0 7.0 nan nan nan nan 1016.9 + # nan 28.1 28.8 25.9 nan nan Timestamp('2018-07-30 21:10:00')] + + df = NDBC.latest_observations() + + assert(df['station'][10] == '41004') + assert_almost_equal(df['latitude'][10], 32.501, 3) + assert_almost_equal(df['longitude'][10], -79.0989, 3) + + assert_almost_equal(df['wind_direction'][10], 200.0, 1) + assert_almost_equal(df['wind_speed'][10], 5.0, 1) + assert_almost_equal(df['wind_gust'][10], 7.0, 1) + assert_equal(df['wave_height'][10], np.nan) + assert_equal(df['dominant_wave_period'][10], np.nan) + assert_equal(df['average_wave_period'][10], np.nan) + assert_equal(df['dominant_wave_direction'][10], np.nan) + assert_almost_equal(df['pressure'][10], 1016.9, 1) + assert_almost_equal(df['air_temperature'][10], 28.1, 1) + assert_almost_equal(df['water_temperature'][10], 28.8, 1) + assert_almost_equal(df['dewpoint'][10], 25.9, 1) + assert_equal(df['visibility'][10], np.nan) + assert_equal(df['3hr_pressure_tendency'][10], np.nan) + assert_equal(df['water_level_above_mean'][10], np.nan) + assert_equal(df['time'][10], datetime(2018, 7, 30, 21, 10)) + + assert(df.units['station'] is None) + assert(df.units['latitude'] == 'degrees') + assert(df.units['longitude'] == 'degrees') + assert(df.units['wind_direction'] == 'degrees') + assert(df.units['wind_speed'] == 'meters/second') + assert(df.units['wind_gust'] == 'meters/second') + assert(df.units['wave_height'] == 'meters') + assert(df.units['dominant_wave_period'] == 'seconds') + assert(df.units['average_wave_period'] == 'seconds') + assert(df.units['dominant_wave_direction'] == 'degrees') + assert(df.units['pressure'] == 'hPa') + assert(df.units['air_temperature'] == 'degC') + assert(df.units['water_temperature'] == 'degC') + assert(df.units['dewpoint'] == 'degC') + assert(df.units['visibility'] == 'nautical_mile') + assert(df.units['3hr_pressure_tendency'] == 'hPa') + assert(df.units['water_level_above_mean'] == 'feet') + assert(df.units['time'] is None) From b8e498c4f01a84acbda0950e50273cc3f3abefe5 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Wed, 1 Aug 2018 10:33:25 -0600 Subject: [PATCH 03/10] Add realtime observation parsing and testing. --- siphon/simplewebservice/ndbc.py | 495 ++++++ siphon/tests/fixtures/ndbc_realtime_cwind | 792 ++++++++++ siphon/tests/fixtures/ndbc_realtime_dart | 362 +++++ siphon/tests/fixtures/ndbc_realtime_drift | 221 +++ siphon/tests/fixtures/ndbc_realtime_ocean | 268 ++++ siphon/tests/fixtures/ndbc_realtime_rain | 86 ++ siphon/tests/fixtures/ndbc_realtime_spec | 270 ++++ siphon/tests/fixtures/ndbc_realtime_srad | 597 ++++++++ siphon/tests/fixtures/ndbc_realtime_supl | 1694 +++++++++++++++++++++ siphon/tests/fixtures/ndbc_realtime_txt | 1070 +++++++++++++ siphon/tests/test_ndbc.py | 222 ++- 11 files changed, 6062 insertions(+), 15 deletions(-) create mode 100644 siphon/tests/fixtures/ndbc_realtime_cwind create mode 100644 siphon/tests/fixtures/ndbc_realtime_dart create mode 100644 siphon/tests/fixtures/ndbc_realtime_drift create mode 100644 siphon/tests/fixtures/ndbc_realtime_ocean create mode 100644 siphon/tests/fixtures/ndbc_realtime_rain create mode 100644 siphon/tests/fixtures/ndbc_realtime_spec create mode 100644 siphon/tests/fixtures/ndbc_realtime_srad create mode 100644 siphon/tests/fixtures/ndbc_realtime_supl create mode 100644 siphon/tests/fixtures/ndbc_realtime_txt diff --git a/siphon/simplewebservice/ndbc.py b/siphon/simplewebservice/ndbc.py index 612a9a837..dadf5e6d9 100644 --- a/siphon/simplewebservice/ndbc.py +++ b/siphon/simplewebservice/ndbc.py @@ -6,7 +6,9 @@ from io import StringIO import warnings +import numpy as np import pandas as pd +import requests from ..http_util import HTTPEndPoint @@ -20,6 +22,402 @@ def __init__(self): """Set up endpoint.""" super(NDBC, self).__init__('https://www.ndbc.noaa.gov/') + @classmethod + def station_observations(cls): + """Retrieve the most recent 45 days of data for a buoy from NDBC. + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + + @classmethod + def realtime_observations(cls, buoy, type='txt'): # noqa: A002 + """Retrieve the realtime buoy data from NDBC. + + Parameters + ---------- + buoy : str + Name of buoy + type : str + Type of data requested, must be one of: + 'txt': standard meteorological data + 'drift': meteorological data from drifting buoys and limited moored buoy data + mainly from international partners + 'cwind': continuous winds data (10 minute average) + 'spec': spectral wave summaries + 'ocean': oceanographic data + 'srad': solar radiation data + 'dart': water column height + 'supl': supplemental measurements data + 'rain': hourly rain data + + Returns + ------- + Raw data string + + """ + endpoint = cls() + parsers = {'txt': endpoint._parse_met, + 'drift': endpoint._parse_drift, + 'cwind': endpoint._parse_cwind, + 'spec': endpoint._parse_spec, + 'ocean': endpoint._parse_ocean, + 'srad': endpoint._parse_srad, + 'dart': endpoint._parse_dart, + 'supl': endpoint._parse_supl, + 'rain': endpoint._parse_rain} + endpoint = cls() + raw_data = endpoint.raw_buoy_data(buoy, type=type) + return parsers[type](raw_data) + + @staticmethod + def _parse_met(content): + """Parse standard meteorological data from NDBC buoys. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'wind_direction', 'wind_speed', 'wind_gust', + 'wave_height', 'dominant_wave_period', 'average_wave_period', + 'dominant_wave_direction', 'pressure', + 'air_temperature', 'water_temperature', 'dewpoint', + 'visibility', '3hr_pressure_tendency', 'water_level_above_mean'] + + col_units = {'wind_direction': 'degrees', + 'wind_speed': 'meters/second', + 'wind_gust': 'meters/second', + 'wave_height': 'meters', + 'dominant_wave_period': 'seconds', + 'average_wave_period': 'seconds', + 'dominant_wave_direction': 'degrees', + 'pressure': 'hPa', + 'air_temperature': 'degC', + 'water_temperature': 'degC', + 'dewpoint': 'degC', + 'visibility': 'nautical_mile', + '3hr_pressure_tendency': 'hPa', + 'water_level_above_mean': 'feet', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, na_values='MM', names=col_names) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_drift(content): + """Parse meteorological data from drifting buoys and limited moored buoy data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour_minute', + 'latitude', 'longitude', + 'wind_direction', 'wind_speed', 'wind_gust', + 'pressure', '3hr_pressure_tendency', + 'air_temperature', 'water_temperature'] + + col_units = {'latitude': 'degrees', + 'longitude': 'degrees', + 'wind_direction': 'degrees', + 'wind_speed': 'meters/second', + 'wind_gust': 'meters/second', + 'pressure': 'hPa', + 'air_temperature': 'degC', + 'water_temperature': 'degC', + '3hr_pressure_tendency': 'hPa', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + df['hour'] = np.floor(df['hour_minute'] / 100) + df['minute'] = df['hour_minute'] - df['hour'] * 100 + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour_minute', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_cwind(content): + """Parse continuous wind data (10 minute average). + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'wind_direction', 'wind_speed', 'gust_direction', + 'wind_gust', 'gust_time'] + + col_units = {'wind_direction': 'degrees', + 'wind_speed': 'meters/second', + 'gust_direction': 'degrees', + 'wind_gust': 'meters/second', + 'gust_time': None, + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + df['gust_direction'] = df['gust_direction'].replace(999, np.nan) + df['wind_gust'] = df['wind_gust'].replace(99.0, np.nan) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df['hours'] = np.floor(df['gust_time'] / 100) + df['minutes'] = df['gust_time'] - df['hours'] * 100 + df['hours'] = df['hours'].replace(99, np.nan) + df['minutes'] = df['minutes'].replace(99, np.nan) + df['gust_time'] = pd.to_datetime(df[['year', 'month', 'day', 'hours', 'minutes']], + utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute', + 'hours', 'minutes']) + df.units = col_units + return df + + @staticmethod + def _parse_spec(content): + """Parse spectral wave summaries. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'significant_wave_height', 'swell_height', + 'swell_period', 'wind_wave_height', 'wind_wave_period', + 'swell_direction', 'wind_wave_direction', 'steepness', + 'average_wave_period', 'dominant_wave_direction'] + + col_units = {'significant_wave_height': 'meters', + 'swell_height': 'meters', + 'swell_period': 'seconds', + 'wind_wave_height': 'meters', + 'wind_wave_period': 'seconds', + 'swell_direction': None, + 'wind_wave_direction': None, + 'steepness': None, + 'average_wave_period': 'seconds', + 'dominant_wave_direction': 'degrees', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values=['MM', 'N/A'], names=col_names) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_ocean(content): + """Parse oceanographic data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'measurement_depth', 'ocean_temperature', + 'conductivity', 'salinity', 'oxygen_concentration', + 'oxygen_concentration_ppm', 'chlorophyll_concentration', + 'turbidity', 'pH', 'Eh'] + + col_units = {'measurement_depth': 'meters', + 'ocean_temperature': 'degC', + 'conductivity': 'milliSiemens/centimeter', + 'salinity': 'psu', + 'oxygen_concentration': 'percent', + 'oxygen_concentration_ppm': 'ppm', + 'chlorophyll_concentration': 'micrograms/liter', + 'turbidity': 'ftu', + 'pH': 'dimensionless', + 'Eh': 'millivolts', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_srad(content): + """Parse solar radiation data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'shortwave_radiation_licor', 'shortwave_radiation_eppley', + 'longwave_radiation'] + + col_units = {'shortwave_radiation_licor': 'watts/meter^2', + 'shortwave_radiation_eppley': 'watts/meter^2', + 'longwave_radiation': 'watts/meter^2', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_dart(content): + """Parse water column height data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', 'second', + 'measurement_type', 'height'] + + col_units = {'measurement_type': 'minutes', + 'height': 'meters', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + + # Replace measurement type integer with minute value + # 1 = 15-minute measurement + # 2 = 1-minute measurement + # 3 = 15-second measurement + df['measurement_type'] = df['measurement_type'].replace(1, 15) + df['measurement_type'] = df['measurement_type'].replace(2, 1) + df['measurement_type'] = df['measurement_type'].replace(3, 0.25) + + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', + 'minute', 'second']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute', 'second']) + df.units = col_units + return df + + @staticmethod + def _parse_rain(content): + """Parse hourly rain data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'hourly_accumulation'] + + col_units = {'hourly_accumulation': 'millimeters', + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) + df.units = col_units + return df + + @staticmethod + def _parse_supl(content): + """Parse supplemental measurements data. + + Parameters + ---------- + content : str + Data to parse + + Returns + ------- + :class:`pandas.DataFrame` containing the data + + """ + col_names = ['year', 'month', 'day', 'hour', 'minute', + 'hourly_low_pressure', 'hourly_low_pressure_time', + 'hourly_high_wind', 'hourly_high_wind_direction', + 'hourly_high_wind_time'] + + col_units = {'hourly_low_pressure': 'hPa', + 'hourly_low_pressure_time': None, + 'hourly_high_wind': 'meters/second', + 'hourly_high_wind_direction': 'degrees', + 'hourly_high_wind_time': None, + 'time': None} + + df = pd.read_fwf(StringIO(content), skiprows=2, + na_values='MM', names=col_names) + + df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) + + df['hours'] = np.floor(df['hourly_low_pressure_time'] / 100) + df['minutes'] = df['hourly_low_pressure_time'] - df['hours'] * 100 + df['hours'] = df['hours'].replace(99, np.nan) + df['minutes'] = df['minutes'].replace(99, np.nan) + df['hourly_low_pressure_time'] = pd.to_datetime(df[['year', 'month', 'day', 'hours', + 'minutes']], utc=True) + + df['hours'] = np.floor(df['hourly_high_wind_time'] / 100) + df['minutes'] = df['hourly_high_wind_time'] - df['hours'] * 100 + df['hours'] = df['hours'].replace(99, np.nan) + df['minutes'] = df['minutes'].replace(99, np.nan) + df['hourly_high_wind_time'] = pd.to_datetime(df[['year', 'month', 'day', + 'hours', 'minutes']], utc=True) + df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute', 'hours', 'minutes']) + df.units = col_units + return df + @classmethod def latest_observations(cls): """Retrieve the latest observations for all buoys from NDBC. @@ -27,6 +425,7 @@ def latest_observations(cls): Returns ------- :class:`pandas.DataFrame` containing the data + """ endpoint = cls() col_names = ['station', 'latitude', 'longitude', @@ -63,3 +462,99 @@ def latest_observations(cls): df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units return df + + @staticmethod + def _check_if_url_valid(url): + """Check if a url is valid (returns 200) or not. + + Parameters + ---------- + url : str + URL to check + + Returns + ------- + bool if url is valid + + """ + r = requests.head(url) + if r.status_code == 200: + return True + else: + return False + + @classmethod + def buoy_data_types(cls, buoy): + """Determine which types of data are available for a given buoy. + + Parameters + ---------- + buoy : str + Buoy name + + Returns + ------- + dict of valid file extensions and their descriptions + + """ + endpoint = cls() + file_types = {'txt': 'standard meteorological data', + 'drift': 'meteorological data from drifting buoys and limited moored' + 'buoy data mainly from international partners', + 'cwind': 'continuous wind data (10 minute average)', + 'spec': 'spectral wave summaries', + 'data_spec': 'raw spectral wave data', + 'swdir': 'spectral wave data (alpha1)', + 'swdir2': 'spectral wave data (alpha2)', + 'swr1': 'spectral wave data (r1)', + 'swr2': 'spectral wave data (r2)', + 'adcp': 'acoustic doppler current profiler', + 'ocean': 'oceanographic data', + 'tide': 'tide data', + 'srad': 'solar radiation data', + 'dart': 'water column height', + 'supl': 'supplemental measurements data', + 'rain': 'hourly rain data'} + available_data = {} + buoy_url = 'https://www.ndbc.noaa.gov/data/realtime2/' + buoy + '.' + for key in file_types: + if endpoint._check_if_url_valid(buoy_url + key): + available_data[key] = file_types[key] + return available_data + + @classmethod + def raw_buoy_data(cls, buoy, type='txt'): # noqa: A002 + """Retrieve the raw buoy data contents from NDBC. + + Parameters + ---------- + buoy : str + Name of buoy + type : str + Type of data requested, must be one of: + 'txt': standard meteorological data + 'drift': meteorological data from drifting buoys and limited moored buoy data + mainly from international partners + 'cwind': continuous winds data (10 minute average) + 'spec': spectral wave summaries + 'data_spec': raw spectral wave data + 'swdir': spectral wave data (alpha1) + 'swdir2': spectral wave data (alpha2) + 'swr1': spectral wave data (r1) + 'swr2': spectral wave data (r2) + 'adcp': acoustic doppler current profiler + 'ocean': oceanographic data + 'tide': tide data + 'srad': solar radiation data + 'dart': water column height + 'supl': supplemental measurements data + 'rain': hourly rain data + + Returns + ------- + Raw data string + + """ + endpoint = cls() + resp = endpoint.get_path('data/realtime2/{}.{}'.format(buoy, type)) + return resp.text diff --git a/siphon/tests/fixtures/ndbc_realtime_cwind b/siphon/tests/fixtures/ndbc_realtime_cwind new file mode 100644 index 000000000..1b42b2786 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_cwind @@ -0,0 +1,792 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/41008.cwind + response: + body: + string: !!binary | + H4sIAAAAAAAAA429zc4ty44cNvdTfIDn12T+17wNQQMBhiRA0NyGe9I2II/09l6VZLByZd+KXMDp + jd3nxM1azF9mJBn8X//7f//7+0//6e9f/uXvX//179/+7e+//ct//M9//+2//B//8vcf/uU///2H + //Jf//7Df/2P/+l//1/+1//5P/7+/u3//fs//+ffv/6Pv3/7f/7+z//r//6vf//2v/1/z1/+9V// + 7d/+lyQ6/uTzj/5p+avyp3X8/bV/3H+Rv7/r/ksp14Yr97/tf3/1H9ffdd3/98F9/rLj8t1Mutsr + FJduXLtxneI0cLw9ie9Wgstmr9649vmfff4fue1NtW+44u11+vvytLdcN65RXPLu7f9IFHfbW8aN + E4q77c3l72/8IxNcmvYWvdsrZq9Oe0vfcPd/auUeX2Zvmva268Yxe9O0t+u5vdveNs7tSfw+htNp + r/2++vkL7P0M8IaDveMfStvLPv/GPwbFzfGtdz/z9tTnX6fzWWM+8/UmNp8/9pZ7PjexiaOSxoYr + bkelv09sfPONY/NPzN5h32W4Ob7pxjF7Zdp7z5fC5otc017DXX86xDYuGTVvuNvens/t3fb264yb + 87ncODIPPrjb3p7s9zHctHeOB9kPPn/e9o52t1dXeyVtuNveSw3H2rvtveSMu+0dcrJjTHuHHubV + /eeNSyd7u9krhpt/ueezdNENd9s75jwl+98HlwPHfl83e39oT30eVDoPuo1vPuxX0mw+Z9snH3tr + 1Q1XfF6d2sux73LcnM/1sL98cBjfRvuv2fgecdXsLe5v3PaOaW9KG64Ejo1HDXsbnVfV7E1nnAaO + 24H1y9sz/6r3xd45vuX7/JUS9tLzUsy/svnC5l9Z7GV2mH9l84DtB+Zf2X7Avmv+1ah+HnXYm2Vs + uBL7HzkXxPyr8/6SY3/m89n8KxsP3t6zP7PxSIu/kczeuT+nMjZccRzfT92/aqd9yPyrUQ7nqiQ7 + qj+4TOep+1fz97Hvapy/t3+QBPaq5g1XvJ+5veZfjXbwN8T8q+uH9u7xva7TPNWYz/y75l9hfczx + vferlOvYcOWndWT+1Xmemn9l85SNh/lXfZxx4n5OezkXPiflp5N9/Wa/Hw2/D6ZUZcOVaO+fzz/g + cuD+eT8D99jLfx/2q7d7I3A4j97uUYaz9dvn/a1Ox0jTba/G+Qtc8X2N22vrd5B7CnDJ/aG3+ypw + cz4X+30MN+3t93D983lgOI39edz+8+X3o6SxXwFX3I7+Mk+By9F//Lu4D/Jxs/Vr++k/X7/APf4k + G18JfyP8q7l+JfYr4HBf4PPP1+84jdu6fln/+folPAhwj79B2lO/H4n9vtiv9Mppw+E8ets3gMu/ + 9Itei71kfajdj0Z595uAe/xJ9l2/HyXrl2nvZY5W3nDPfGa/b8R94Y2nAQ7rl+4vOmJ/fuOHgJPA + sfG1+5HhxmJvLzsO5xHdN7THefTGcwGXfP51ti61x/58+i7OX95/dj+ycVO7uE572za+dj+6fmhv + ju91Wkd2Pxr1NA/8ftRO9vr9qJ5+X439efJ1YW9NbcMVt4Puu1qX+cx+X4377zj8Pv2xPQkc6+cS + 4ztw39/4Z+BKrDc2/8piL1vnZRlfjtOYf8zesqxf1l6O9dvAX839OZe84eA/03NBn/sRPY+cfza/ + jv8+jf2U7VfuX5VTeyn4q3n/jf1Kv/1J559/aS8Hjtnr/PN1Wm8p7OXrPC3z+Z/fGw2nwV91H1/j + n6WODVd83N74Z+Cy/75B+0XjPnhqT8P/Y+OrYe8b7204869uv/N+h5j+5HxPkW1/Nv9qHM83ifEd + dDxk2a/YPJBYv9xeifOI4px/Ntx4xleuohsO63cwexf+mY4v+OdxGF/wz/39XQi4Z78i+4vzz/AP + Yv3KKG3DwV66jpx/Nhqb/b6x7Fdk/Tr/fOWDP+n881XeeR/DmX91uV+cFPxkF9lw5Z6Cp/ub8c+T + f6H7uPHP83On9vTH9iaFkA9+jvHPbsdlP2COb9O24Yr3M93/nH++2uEcNP758y9O86+Zvemwbzj/ + fJF3WMOZf3V1O8+T+H4lNbcNVxzH15v5V9fJL3H++arn36fhx3Lc40+y75a4H3XsV9PeXNOGK3Fu + sfnn/lU9jUeJ9yPqT4J/vk77VYn7L93vnX/u6m5VD3u/+Q3wz/nUfzneF3i/OH91ujeCfybvv8CB + j+XtOf/s8QLz/XfuV2mzN/123wf/TOI8gLvtbYTvBG7yOSc+zPnner3z7Ybz933nxx979ft+5Pyz + xbWw/vP3/ROP6fxzk9N5pPHefbJD3I43ntpwsrx36/MDROL9CLji53mm/SzB52S6r4ntzx87ErVj + +lfpjgtKh/buJu/fl977WZx/Tvc8zZ//nG7j51/SyseK88+ptfd3bODuPyvnE8X551QHXW/i/HNq + /J4szj9/fvS9/bD25vqdOP30S7r3qzLtXcdXnH9On578HM/Mjmf9kv1KwD+36Ufw9uZ85jycgH9u + 5H3VcBrxKs3jc4yPfeJzgEP8FfFzBPxz7dQvEfDPLD4HOHUc2Q8E/HPh+4aAf65i+6kHgE0PbsfB + XrKfCvjnqnR/FvDPhuPtaeC4HU88EsE5/1w9/iDs/XjeY8PNeELy/gsc4utOuBT9TNal88+1vMf7 + ACduB8eNsLdgfO2hf+VzJq4I4rRez9+Jy37OnHDJ5z3d/3RE/OTbOzFw4vtGpu31iGfI9/mLB9TP + CdU3HPjJTMejRzzSCZecPzj9PnV//ISb9wW9caxfnH+e4+bv3dPelvKGw30hs/3U+OfZTGH7kPPP + V7XvMty8H/Uzbh7px/b8fjQ83gyEupZaNxzuv2/xf8DlpdsYLkV7ZF9z/vm63uMjgJv3o3Y498E/ + 5+19UHPdceDr6PkG/lkO+zP4Z85bCPjnw/uggH82XpSNR4737p1/LhvusZd9d33f598Ff0X8Zwn+ + eZz6Lwefw88Fux9dHqcVfI5u/hX45+twXjr/fJ3OaeefDcfmqb/v9/e4SOAk1hHDTf8qabF4qWnv + XL9adty9flM7nTNq3t1xXWrwV3yde3yO0nuogH82Ho7tk+ZfXc4nzr/M8ZX1vVvAPxuO2eH88zjN + e3OdLv7uIiv/TP1s8M+ndQ7+udu738PnjO/7kfPP9i5J5ovzz2Mc+sX5Z4unIePm/PPgvJ6Afz7w + QxL8czYe7uFzNv8K/DN/3xfwz4ZjdowlfpLsa84/dx5nJOCfD3zOzTMbv9Ftvjx8e6s7bvI5x/H1 + 0/80/8T8q3acf+Zf2f2S2duD3+DfNf+qIX6jhb05b7giSG8g+4Hzz5W/iwvin4/3Ro9/NtqF9Yvx + z5W/1wr459p8W65P/LNsuHlfON1XnX+ux/ln/HPNZxzspfu98891HPZ755+b3y8jHkmK6Iab4zsO + 9y3nn9vp3Hf+uZ38DeefWz6NW4n8I74fmH/Vqp9HMb4564YrMe+ZHeZfNZIHBFwS5O3w36dhB5tX + eeFzGM7557LFm0kquuGKrw/qNzn/XEkeBnDgc/g8SHH/5f3n/HM79Z/zV3XjN0S/77/OPzehPLAE + /9xO/aKRb0XvM84/V5IfABz2Z26vxP4849sL9ucPZMOVmPdsvTl/dfKvPP65nfw1xD/LaR15/CTl + E9OF+GfgnnjvtMRvGK4I4lnf+tlwOe5vb/1suBR2cJzGdzlO4vx4G48bl2J/nvaWsFfqhpt8HclL + BS7H73sbD8OlmC/MDlu/JbPz3HCwl4+vrd/i574mxLfrch4Zbtpb2PlruHkbpX6Y4W57M/U3DHfb + m+k7u+Ek2mPjYes3j2V8b5xeS/yV4aa9NH7ScNNe6pcYLkW/sHGz9Vvoe6jhpr3XAef8s/VLW+0t + Y8OVX+xw/vnYz84/ZxpvZjhdxoPh5vtCYvfkG2f3o+JxKOFvfG5gsuHKgmPtZZ8H7/uu4R57Wf/Z + /SjTeFvDYT7T/cD556Kbf/W5IaYNV3zfoPuQ88/2XbJ+nX/OlJcy3JzPlfkvhhPfT995+Rtn96M6 + 87fW94W2+BuGK37uF2pHC3/j9F28p7zzu4bTsIPN57bYy3B+P0qGi/fuTw+kDVcE7y5sPte4D55w + OI94v9TIT3nn7w2H+wL/bol44OL8htlbRDYc8iX5d5/80Hdez3DI/z3hnnx2Nm7lmL9vuCc+p4Bv + n/bmJR/HcI+9vD3w7Scc8jVOOMS3n3CIv+Lrzfln1z9IKfjYmjZcOb4LGW7yz/mMS4Fj69fzQ5XF + oRhOPO6Q72vGPxsuLfyzfPvPzj/LxfgDw+Xgszlu8s/03mi4aS99dzbc5J9J/q/hJOIJm8cTmr8h + 23nk/PPxvDT/yuInOW7OZxrPZTjE151wc/3S/K0PDvobdckPnff9S9qGQzwSPVfBP9N3NcOlwJF+ + Af9M+RzDTXuJjoPhRtz3v/nYoWnD4T5I/VPwzzTu2nBPvhU5P6C/QfNTDDf3KxrfdON6vIfOeG/E + 80vPsuHwvvAep2+4Ob6d8fyGS97eezym4fA++B6Xazjx9cG/6+/7w+L+Ix9W1vd9wyE/5T1O33DZ + z5lBx7fFfL5o/7UlX4P4ndDfGCx/4cbVJV/DD845nzf/yvlnG1/Wf55fdrrnOf9s85TZW5d8SdZ/ + NfYruk9Cf8Pv08/6zbVvuGe/Yv1clv2KzdPHv6L3QfDPp3st+Gf6rnHjcrwfdcTHmr25brjn/Yh9 + N4c/Se9li/7G6fchnuE9vt1wT34o29fSkg+7jm/KO64sONbeb+ObIt/51N4Tv8HmVYrziOM05nPD + /cjin6VsOLyn0Pu+8888L99wz3sox6nfo/g6d/6ZvienK/hn8fkc7ynyzecg/pm+NxoO+zP3N2Tx + Nzju8TfYPJAln/21vRH6G84DP/GxeYlvN9yTv/C6vwzwz43P+wH+uZVzexrjxnEi4G0Zbn0/as/4 + plR2XBG8izM7bP0a//I6Dwb450LjeAyngXvdJwf450LfJW+c88/V31PA53xuLmXDlWjvdZ8cwT93 + ej8a4J8L0fUDDvzke5yR4aa9NB4pDfDPxXUHNUc8cC0brgjid1n/2fotR3tt/f6Ce8aXzRdZ+MnX + /WoE/wy9kcfedb8awT8T3SPg5vjye/II/nnQe/wI/rlT3mKs/DPhGe6EMrN3xvn2JwD7s4OVDYf3 + hfx+fkxcDtzrOThxmM/v8baGU2/vZMcc33r6rt2PDDdsfC3+uZQNB779Pb7YcFi/mc6rHnzse/6M + 4bB+3/NxDDft/bSndF7Z/ejztz/5jNudnzIDiD83YtlwM56wGI61d/M5931G2b5m/LPnC7F5avHP + tx+bDu3N/CO9cWy+VMs/8nFLMZ/r+j44EP/c9DRuFv988+3veVmGm/lH5bQ+5v0oVaKnCtxtb6H5 + YDdu3o9Snvlbl/GT0978vT8b/5ySGo61h3jR93h+wyWPP33TpQPutjeNM06cT+T9Z/ll2g0XAaua + U9pwZWYlnfYXyy/T4z5k+WX2XdZ/OfjJE+62V/W0r1l+mWbnnxV8+6erNty0l+bTGe62V07+gfHP + s/8IHzuCfx5nHOx904E0nPPPHk89+Vjj27f1u/LPvL18jGs23BP/zNal88+V8srD+WfHsfUrC9+u + fyGo9DF3xxXn+fnvc/6Z8/wj4p85Lz+cf/a8E7Y+zL+6TvPK+GfPd/n8G/hXMmrbcCXWB+k/45/n + uqR2GP8897/T71Pf12j/Gf888znp/cP455Sz4RZ7l/wFwxXfJ/nvG2Hve3yn4bB+6Tlj/LPvL2R8 + jX9OieaLp/lnddy8FuXQ39C64UrgWD9b9mIa9F3D/rxxNJ/TcOrnJYkDmH+K4+h91fU3ssdjPuPb + sm644vOA8gfGPycdh/3F9TeO+6nrb6Rymlct7OXrqMZ8nusX76FSat9wc3xP91Xjn33fZb+vLucR + G7ca8/mEm+fRcb6Yf6XOwz36Kl/v+8P55+k3Ub5EHv+K8GvD+eekVKfDcLCXvLsM55/nfCF88XD+ + eeJuHi4p3o9STRsO5y/hO4fzzz99N/2IU/8u75cc+jnvuiQ3zvyrG3f/52nvfD/6bCUbDva+67Ma + 7rGX/T7zr6RRfndA/1mpjpLhJPZxdl66f9WMP4jETtFSN1wJHNtfNOx9z9c1HN736T3AS1MkPdx7 + XGI5y8FvN/55ngvZ9XJtv5IsG66c4yMG+Gfzc9g8df/qeE6bf5WoTofhxP17Ym+H/kb2e14Cv/E5 + oeqGK35f1ffvduhvNM5bdOhv3Pupvtvbob9xv0Po+7zqzj9ns+N1vnTnn3NS83OWeO81frI7/5yV + 83Ud/PNF6noA97wPMjtSxF+R/b6H/kan7ykd/DPy1SI+Nn3F53Twz43qFxsO+Slk3+2hvzHoe14P + /Q3+XtGDf6Y6pKkH/+y4xd6kG27ydfx9tQf/THU+DZeiPY7TH3HQo6DzAPobe37Z56ZWNhzyy8h7 + Xgf/XKnenOGQX0be33rob1TqF/fQ3yD1NQw3wt6G9+5p+NjsHYu97Lsj4kXJe8DEJUFeG5kvOiJf + ktx7Jk4Cx35fj3oTBXrXJqyax4ZDPBLdrxb9Z3LO9NDfIPWPgFN/XyXxkz30n3k8cAf/fHl8pydw + 3z2QdcNBn/DU3tyfaT674ZDfzcejhR4juSd38M9aqH/VwT+rx8dGfY3PQpYN9/AbbDwe/Y0TDnqM + fL7U0GPk/VIjf5+eg84/i8fLL3ojkjYc/MlTe/nsh3Xwz+a+svGw+9EvuEePgs2/HHoyc1hDryCn + seGKQK+U7Rs54oHJPbQj/vni75cd8c8X1V0wHPQoyL2ig38Wv08/8cBp0Y81XAkemPWz88+k/iBw + KXhgNh4p7oN8f/b4Z6q7deN00VPVRW9EpW848LG8nzXWLz8HveQEj2vpwT/n07xy/pnmJ6ce/DPi + VUKvXpJsuEc/ls0Xif2Z+kPgn9PBX/P454vHI/XQ3zj5nYseRYce4+Rzei0bbp6/cvh9Hg9sfjux + 1+OBG49P7IgHbjwurYceRaNxtP3+E/nsd9zrrKdp8cBFNhzuC4QvmbgsiGMk61fM3zjEJ04c8tnp + +EqP+Enefy30VHc9irThfoif7IgHtu+S8xf1+Hj+bw89inpub9rL4zY74oGb6+4v+gw1bbinPg6b + LzXi6wi/0SMeWA9+tscDD/6u1iMe+Drsf4gHbo9eAfSQ84Z76luR8wP1+PphP13q8fF57/lWx/lc + Ip+dxEn3iAe+vL5GD35y26+eeEIS791Dj2IwHWbDpfgumy8eT0h1nQ0n/t2L4p54wlsnde5Xadqb + ZcMVu799hp/tV66nOuP0WT97Pns6/z7oq1x0PqfQV7noeGjkh856MRXzedX7MtyjN8Lbg718Hbke + Mn/H7hEPfLpXIB6Yx2n10ENOHoaE+6CItA0H/ToSf9WDj538KduHJPLpSHxJRzzwdbonezzwxfNw + W8QDI1/yqT+43o8a4oEvWg/NcMg/Iv5uCz0KqktiOI1zgdsx9yuqq3vj0qKfY/HPXp9ujTdrEQ/M + 45Ub+NhK644YDnpQJJ+pgY813Os+3lY9CpLf00IPudi+sdi73o/aqod8va+PFnrIpC48cClwvL3f + 7NXg68i+1sDHol8ee2V9X2gRD9xo3lMDH8vqswOXfuoXCf0cck634GMr9Sdb8LF1y9f47BBpwxUB + z0rGA3wsf59u4GMLjz9o4GMLv3e3iAfmcQV3QmjoXd/fXfQoVn5y4pC/z3/fWOzl301y0s82nAaO + rEsdi/4z6+ce41t8PiMeeGw49zeI/q7hsvvt5J2ugY9tQuNPG/jYez8lcZsNfOzt75K44RZ87HxX + E4vf8HjgvuFK4Nh4uB5ypudvQzyw/oDD+y+31/nYQeNUG/hYe09Oz3uolvW+0MDHJh4v2sDHKtVr + NhzeQ0+4aW+nfklDPHDicaUt4oHVcKk8ehR5wyEe6dTebW/hOhMNfGzh+iUNfGwp5/Ykvsv2NXvv + LheeuYOfrHXD3faW475h792Zx5U2xAMX/r7QEA+ceX5KAx+buD5NAx+b/d4d8XWq23z2ehPH/d74 + 2Hw8j9ISX8fsTTGfTzjEExJ+o4GPTf2JR3J+sqYNh/wFwpu1iAfm7/Et4oF53mcDH6tc36yBjzX6 + nPhX4GP9fXqxV2TDlbCD9Z9EfDvhGfwRDN9l/SJmL8/rbc7Henvk9yEe2PPPn/i6K5UNh/gcel9A + PDCPw2uIB9ZEebiGeGDh7y4N8cDCdf0a4oEF+lehv9G/57PHAwPH2oM+A11vSz0+us6hR8F5hgb+ + udN6nzeuR/1BK6uB+Kv+7U9KX/J/mR3+3s31uSbuuf/y9qCvQu/d0kPfm7fXQp+hQk/G4oG1brjn + vs/6z9+7+ftWi3p8nM9pUY/v5I97PLDw+PYW9fj8Pe+Jr6tFNhz8ST5uzj/z98EW9fh4nH5b6/Hx + fn7qHfPvluBzvudzWfRyDVdiXrF+fvQoqF/i/PMhnqEhHli4jleLeOBE84XaGg9cvP6g2fuVb9XA + PxsfxvYX1/vi7+wN/PM4zue8jC+3Q5z/4/286n2N5T1Fa9lwxYef75Mp4nP4PunxhCf/D3oUJ78J + ehRC3z9a6FFA/zn0ZDb/yvnnzt+xW+hRHM+PVY+C9Ysu8ZNs3ht/xetBphb8s/sboTeS8jc/CT2K + dPBznH/uPN67hR7ydW5Pww7WzxLnL2mvrnrIqP873xc+nveOK8t2xtrL0X/8u8n7hbxH1dCjoPVD + DYf4Oo57+OcB/tnsXfOtavDPib5b1eCfrzMO8bEnnAriO1/naQ3+mb9P1+CfXY9n8nVzPusaP1mD + f6Z1BQ2XBbrTrJ8f/pnsQzX4Z77Oa/DPPL+nRjyw851LPb413rsG/5zoeV6Df+Z+cQ3+medv1eCf + +X2/Bv/M9UFq8M/Z80Nh7+eE6hsOfDu1A/X4OF9cg3/m+Yg14oE5r1JX/pn4B/cBFO8pBeNrehSr + fzVxP/CxE5d93hNeb+IePpb/PsSrkHyXicP+TN4vK/jn4fyuOzJz59QNV/xeRnjRCv75us646U/y + vPwK/vmidQUNh/s+4WOr88+Tp5n5KTG+rciGK84TkvyPCv65TD0KNr52PzL9jVc/ooJ/roXmu1Tw + z5YXw75bUR924lb+uW64Er+Ptzftbaz+r+FS4Nh4GP9s+i+sn41/zuM0n41/Nt2KbgaZPvCan1LB + P9t+wH6f8c8103f2Cv658vjxCv658njqCv758H5UwT9Xz19NEODXnOqGw3wm99UK/rnw+3kN/pnr + VdXgnzl/UME/F34PreCfi+sGpNDn/3rfr+CfC88Xr8E/83fEGvwzj9Oq4J8z5+Eq+Oes9F5Rg392 + Hcj5XubxwHnDFUGeMJtXD/9M7mU1+Gee31PBPyd+z6vgn9PJD3P+OXndtMdeSTuu/PT7JPK7T7iH + j2Xj4fwzj2+qwT9fh/kC/nkYzxr6z1/1+AxXFhxrLzuffcIhX4Pck2vwz7ROoeHA19H5DP4ZfHsK + e9f42Br8M89rq9CjkNO8dz2KQ3x7Bf988fytCj0KOfm70sPe0Gcwvl3qhivOn9L5J30ZX2ZHX+Yz + G18LhU+ne4X0Ra+AzasWekH3Op/z2erTbfO5Rf7Rqb3HXjb/Wowv5Q/AP3Nd3Yr454vn19bgn7PH + TwZ/9aVHUYN/PvElzj9fnH+pEf88DvdkxD8Xyg/V4J/5u1oN/rn4fT/szat+TgX/PHg+bA3+OZ/W + eYn3FN4vHv/M3xFrxD+f+A2Pf4au86L/LG3DPfrAzN6Vv+K4J96b2ZEXfpLbIcETEr8EesjJ5ssT + 3540bbhHr57NK49/rge+SZ56XuSduEb88/FcSJGvQeITa/DP+thr46vffB345+P800X/mfWLRv4C + 9ROdfx6cb6/gnwevE1eDf/b1EfkpKW/7s4T+M5+nsuTjsH1Dgo894fSndSkRz0/mSwH/bGGT+sS3 + p1x2XBGkf7+OWwk95ETncwk9ZD5fyso/k/OoBP/M530B/2x5Y20Z36/3owL+ufO4kRL1+Pj7R4l6 + fFzXoIQeRT/1i69fWo/5xjn/PB7+2cZXtWy4suBYe+Db+TzQ4OtIvHdZ9SjIPlSCf+Z6SyXin69t + /X48lbTh5nzm+ZJl5Z/JuizBP9O63IZTQT4Jm1ey2Eva+9Kj6M/7wrcecln1KOh3Fz0KOv+gR0Hr + WRvu0aMg/Qc9Clrf+caN2K9mvRjM54/HteOe9xQyr/Thn3m/jLCXrjcdy/hyHN4XyDlYIv4Z778x + vn2tN1HAP/P604bL/h7Af1//e/RVWL8Y/1z5vbYg/vn8+1rEe3e8p0x72/q+UBD/XHm8WYEeReXx + YQV6FMYTchzmM4nzKM4/u84Jw9UY34rxNWGZUjZcifbY73vq8ZH3o/KHenz8Haz8oR4fr9NVoEfR + j/Z6fqjrbj16qmV9Lyuoxzc4v1tQj29kymMW1OM7xBkV1OO7eD5dgR7F4HxxCT0K1CN46vGt7ykF + ehSD636UqMfHdRtL1OPjuroFehRWB5DNgxz5sIS/L6jH112HeTpa8z3lS4+iOP882yPvVgX1+NpF + 8zAK6vH1St8/ivPPs//I+1tx/nnyXOQdp4Qehb/jPPreutZbLKFHMd+t2LrU0N8genMl9Cj4+2Vx + /nnyKryfNfSByTtTifjn6vZCb0SuuuMmf8XfJQv455SpnmAJ/llpXkIB/yzXad9w/pnrRhXU47vq + Hi96lbrhSuwvpP+8Ht/F39lL8M8/4NR5JBInWKIeH8+HLdDfGF7/MvTMpVfZcKhfRt7jC+KfLe6Q + 7EPgn+X8+37QgyrBPx/7pf9zfW9p3/dBcf45H/Zn8ff90zkj5l8NXh9x4h59Bo6T4OHI+vD45+48 + ul+EZz2+uuHm/lwoP14Q/9z5e0pZ9TfIe0AJ/Q2uV19Cf4PHv5TQ33Bdq8feUnXDIX6SnoOIf5bT + vKpLfDvrvxp6FHwfqhEvSv0w55+bv7s89cuKpg2H/G4+viX4ST6+5l9Ze6z/SugV0Psg6vEdv5tD + T6bC35j2pm2/cv7qOtm71uNj6zwv85nZ6/4Vj8stwT9zPbKy8s/f9VKT7rji65ze4xH/fOI35Ef+ + 6ot/ZuOWYnzpvRH6G36Pf/SRvupNFPDP9cTXOf9cTnyT8892DyV+ifPPdg9l61IXvSCGk8hfqKhH + 7/yzbLjifjbfTyXycfj8kxhfvr84f8V12Qv458rjszP4Z+vnRV/lm3/O4J8PugEZ/POBX8vgnyuv + s5fBPxeuW5ajHh/nqTP454L1W0IPuew41Kcj/ZyjHl+i+0YG/5wHnX8Z/HO+6DtJjnp8PB4kB/+c + l/k8A3W+4p9z8M+83kkO/nmccdAbIfnJOfjni/qTGfyz6ee8rrcM/rn5PeCptyiy43D+Ej8xB/9c + 6DrPwT/zuow5+Gfuh2Xwz1bfj/y+r/hnATE7b5x1wz38FRk38M/10M/gn/n9KIN/Pugj5ZV/Jv7k + nRC6xLd7fTrT31jv+xNXxOoU0nWkdj/6BTfXr1D/auLm+uXx8hP36I2w7/aoPzj1YyN+sq/vvxn8 + c+H6yhn8c+FxoDn4Z15HMQf/zHUIcvDPPA4+g38u0MsNPvaLf87gn80O1s8t9mdur92Pih72Ieef + TZ+B2yHeHrmf5+CfxfgXLzg6dxzdcNBvJ7xUBv9cEo0Lz+Cf86wzwH+fRnts/dr96I6nJnHmGfzz + ba/e8VdFjMj61t/IwT/Xu94i+30l9NxIXcYc9fjSuT3oMyjzXzz+ObcTzvU3Zj93i6+bejJf+oR5 + 1d8gejI54p+5/ktG/LPVyWT94vHP5fzdJ76dzYNHf+PmHZd44PX9N6/6GyTvJEf88/HcevQ3+Hnp + +hv8HSeH/gaP/8sR/+x+3T2fp96XSu0brgj0Qdi4Gf+cePxfBv+cef5gRvxznrpl3I45vvO6w/YN + ifG9XH9j6k9+roO64Yr3H9FLyxH/PPXh2PkR/PO8njAc9CiInmV2/nnm7VB7wT+7fudT/2h8z2fw + z/NeS74L/vk6jBv0N3i9p4z4Z+VxHjnin8vJ3hF87HB9frc39w1XBOGzZD4j/rn9MZ3PHPxzofmh + OfjnTvmDHPxzPf2+Hnrml9d7Mnt7zhsO/POpPeiZEx3DiUN8O58vPeLbif7fxCHem+NavJcN16s3 + e1vJG654vxBdxBzxz0rjzXLEP/M42gz++boon5NDfyPReKS8xj/7NdD5q5rbhoPeCF9Hj/4G5UGg + v8Hz7XPob/A4owz++Wqn75bQG/nWCyolbbgS7bH1VuL9iJ5b0N/geQ4Z/PPFdSAz+Gd792PfzaHX + N/MXIp4/b/uV62/w/IUM/vni75IZ9fgO+kN5rcdH/Q3obwzKE+bQ30B9qyv457W+Rg79DV6PKoN/ + Hu3Arzn/PE73ZOefB483y+CfB8/zyuCfL+dLnvHVsuNQf4GPm/FXF+djM/jn63Q/d/754vUHM/jn + 69h/EvVTvvMXJO+48tM+5PrPPC4yh/7zOPidIvH+S3lR45+9rurr+r0FJyPfGfVToL9RN9z0J3n8 + +MRlQR4k/y7yJQlPneB6KtdXTuhCbfT8SM4/x7VosXfV+0rOP888pVN7Oc7z1/WbnH92f/J1HiTn + n11HjvVzCr0+/vs8PueyczDOo/RVTzM5/3zSw0vOP7u/wezw9cvfhRL450PeUwL/fHF9wgT++fJ3 + l3v92v3oKz4ngX++uD51Av9s/guzw9evUv80gX8eXLc7gX82HBkP55+H3y+nvfP++xX/nMA/j2J1 + Vlh7eN8n94AE/rnzd8QE/nnUw7g5/zz4+8wdQLjUt7qW+lZf9fgmrkR7ZH9Rj8/hcQATB3+SvA9O + HO4LhAeZOPkJ18OfvOMynnptPY0Nh/sg4Z+T88/+XTL/1O9HPH4jOf8874MkbiSF/gZ/10jQ3xDn + 0SP+Stt6H0zQ3xDONyXob+gP30U+O+8/yw9VzqOn0H+uJ5zX4/P2Hr6urPmSCfobyuslJOhvCK9L + lkL/mb+fp9B/Lqd1VEMfmPidKfSfxfP3M+Lbc91xxXHEH0rQ30j83TkF/9zPuMdeNp9L+Ff0vHT+ + Obl/cBtk+Rp5fT9K4J/T6Vx1/vlQnz2Bf078XpHAPyde9yut+s+8vRR87N0vj/5G+vY3wD/zvIkU + /DPP207gn3M+2fHwz/w8SsHHUv900X++/Y1nfDXXDVe8X6gfAf65HPw6559TPZ2/Gu8pJzue8WX9 + 4vobvt4efYbr+77g/LOtc/ZdifEl95kE/tnaY+Nr96PUTvNFlvVLfp/rbySxdRnj+80/J+hvJM4j + JehvZM4rJ/DPOVGeOoF/zic/1vnnzPm1BP7Z5sv1vKfIkB1XAkf2Seefs5x+n/HPmfPUCfzzPf9O + ONhL/Wzpy/58zYG2el5f+hsTV2Jdkvkn5l/pdVjnYv6VTjtYv/TQz6H3AHH9jXGyt4Ve0OX8pNnb + UtpwsJe8WyXwz/MaR+1w/4q/gyXob+gP3xX3m/g8qKE38m1v/T6PxP2rQvn75Pzz5NF5P7t/Jad5 + YP6V8rpGyfnnaS95D0jOP/s9vj78hpTcN9xjL/tuiXwcyr8Y/+zpMKz/yqKvwnEiSDch/qTrP4vX + aX30kfJajy85/xw41l52HD1nwD+PAx8G/pnHIyXnn53XY/M5hb0V98EZz5++/UlJMb6E907OP89x + o/cFSbF+CR+bnH+efuwJB3+DxOsl55+9nsj13I9Ev/kN459T7qf+M//qELeZnH92fThmx/O+T++X + xj8ni29i7Zl/VcRwUR9HJKcNV376rvtXvC6AF5/+4CrN60jgnw3H+llCv47k02nwz8nrHyG+7pt/ + VvDPphf5Ol8U/DP6j+EwvqQepIJ/Nh1IbsfUY8yUj9C7a257G97LFv0N3XC3vY3HqU7cbW/jvMDE + 3fY2nhetcLUb18NTTJnKdV0U/LOl4bT5F68/mHXDFW+P+DkK/rlyv0mdf06mq/E6T9X55zke5B6v + zj+nxs8jdf7Zv/vpc9TDTV/vR+r8s/cLmy8S+qKEj/Vk2L9ZZ4r42er8c6r83UCdf546mhRn/LPf + k+vjP+u16l2r88+BY+3hvkD8IXX+Oc3K6gfcE6/yeg4q+OeL8z53gqTxz64TGO+Dn3+jG+7RzyHz + T8eij0TWmxr/3Pn9cuKQL0nXrw6zV+m5r84/R17qw8f2NZ9dQ/+ZxxNq6D8Xmu+s4J+10fxpBf+c + Bq1Pp+CfLR6Y/b4W9druczBFPH8T3XDzPOo0XllD/7nQ81JD/zkdzhnnnxvXG1bwz5bXwea93Y9K + 9Xp8oXdd13gkBf9c5DRuNewlegUK/rkex8PuR4Xn0Sv453JRPQAF/2z67Tr35z+vP1g3XAkcs8Pu + R43Hoyv45zZoHLyCf+6Vvqco+GfTeWft5fA37nFLod+eVv5KwT+3fhpf86+6UF0IBf88fsBNe8cZ + d9vbj7/P/Kt++fiifrem9b6g4J8PecwK/rnzOpQK/rm103ikWL98Ppt/Ze2xeeX+lc/7FHojup1H + 5l/1k//s/HM/7kPmcpjeCLPX/Kt+XOca48u/a/7V8HtPCv0ckbHh5vjy9zcF/3yo16bgnzuv/6vg + n02HgM1nifGl56/zzw36wJHffX2fv84/W744OWecf65cp1fBPx/yzxX8c+O6yQr+2fJ/yTxw/rm5 + Dtpj75e+mYJ/Ptth/LPptJFzwfnnwvXbFfyz4Xh78zzKlB/S+88auArH/Oaft/Htoc9P55UY/1w4 + DzJxye+19H4p5l9VPePEv0vvl84/Q3c/If9XmrQNh3oTfH24fzVO49HC3+DjYf5V4bp+Cv65HOe9 + +1eu95BCj6LmtOGe8WW/ry72snnq9TWU8msK/rnwukYK/rnw+E4F/1y8jmLU15Cy8pMK/rmc9l3n + n1G/guGSHOtrKPhny0dk88XrO/P8WgX/bP79sB9qfOyaX6bgn62f2bp88ssoj+T8s+VfsvFw/qqc + 7RCf93w8PL/MdRKcEJn8844DP8nny1rfmeMmP8nzsRX8s/0+3t5jL5svGvViGvhJ45+3/cr5K/6O + rcE/c716Bf980CHQ4J95nQsF/5x5vLeCf86eR/DYKyVtOMxnEr+h4J9t/2P7kPNXPM5DwT8X/r6v + 4J8L11cR8M/Z9V7jff/zF91weF8gcTcC/jlXypsJ+OfcKD8p4J8tz/B1Xgn4Z3vff12/Av45Z2vv + sTet8SoC/tlwr/NPwD9nHv8s4J/Njtd5L+CfM9eNF/DPqVE+TO6pMN8X1Mc3BR9bdxzic8i738Rh + vyLrXEDJHuJpBFeLlE/jphFPSHhvAf9s8ej9L/Kt0tf6FfDPMk7z1PNDeX6ZxD9cb0kQ/3zxvBhB + /POhvoaAfxaP05rjO/PZx6oXJOCfD/XoBfyz8vd9Cf5Z/1j8gYB/tnxd3p6vXyV59LddGF+989nv + +Ge1Qs9FNpzzsUrqxE1ctvhsltc7cSniwsn6UOOfO69HOnHi8eh0HqD+YF7ivSff/pUfKiv/TM4F + Cf6Z38sk6g8qPS8l6g/ye61Af+Pi9wqB/gbygCJfQ5vKhpvrt5++6/HPPH9QIv5ZD+sX8c9yxkF/ + kttr9yPx8fWAmfvfr/HtAv5Z+HuKRPwzr58i4J+F118Q8M/K63UI+GerN8bWm92P1OdBxE9q0bbh + 5n7F45ol4p+P47bGP3Pc3K/ktO+6/sZxPB7/qnk8oY1vqrrhcF8g92kB/3zQ95HQ3+DxNAL+uXB+ + Q6L+IH+PF/DPqK+bQr89fZ+/zj8f6uEK+OfCdekE/HPhdesF/HPh+QEC/vnAH0jEP3sexlNfcvOv + nH/OU1+FfVfDfz7hkrdH9FAk4p95vIqAf678PUWcf57vsIr3sslvXJu/Mf0r+TQzdXZYezlwbB6Y + S2S6OGx9zH9Ep94N2//sfnTVw3edf7bxGE++hly5bTi8h9L15vxz4/dzCf45Ud5Cgn8WylsI+OfC + +XEB/1x00ZOxeG/tG27ae1FeSsA/277B7PX4Zx6fI+CfczrZO+x+JCd7jX/WsuTvz/HtsuNK4Njv + 65F/RM8PePm8jt3EPXoUzN4e8Rv8u+5f+Tn45O+37/u+6z+fv9siHpjeQ13/2b7LcfAnT7hpbzrh + 6pLPbvmwZm/VuuF+0CuQqD/I46Uk6g/yuBaJ+oNcb0nW+oPUn3T9je7vQovedekbDvpmJC5SQn+j + 0Pd4Af8sPM5SoL8x+PugQH/D6lyw7+ao52VhORH/LHnDPXrmbD7nqE/H9zWvr8F1uyX0n/l7hXzr + P7Pfp0t9K13qD37pfQn0KCyuj7c346+4DouEHvIPuNveyuvxCfQoKq9DKdCjsDCk8laPT6BHcdAV + F+hRVP7OKdCjONQ1EughF57fLaGHTPeNm1TJoU84XG/T+djlvcxwU4+R6j0YDnrX7+NmuHmrofpI + hpv2XuyeYrhpL60jduMePeQ5nx895Lzjpp6qsPul4fK8bbD9xXDTy6fvtYa77c203rHhRKCn+rY/ + 32TYsz8X6ItavvOSj2O4EuuI9B/qH3V2DzBcklN9F8Opt/d+XzDc3J9pPZEb5/WPutn75O+v8e2G + gz7S+3ue4XLg3vxiwyVB3RGOUz+33s83w4n7Oe/n242z+6+6Px75KfrZ6jZcifbYeKRFr4D1c4rx + fT+PDAf+mc+rFPbSdYT6R64L8fBXKrLhHnvJekP9o3TGwd84/T51np/bq4u9DCdxX/i2Vxb/2XDF + +TBuhyz5R2ye2vsCz1NysRHn+U/tSfB6b/7BTcpfoUfRvuvRf89nv/9ae2Se+v3X7lGkn6E/SeOW + DDftpXUjDSfOE77zxTfO7r96LXys2Stlw+E++O4fGO7hn9nvG2EvPS/9/st5UcPBXo7ry/ugvx9N + f7IvfKzh5vsgrRtpuOzvee/vl4ZLvj7e338Np86jn3CYzxzXIh92uL6K2dvy2HBlwbH2sH7f3wcN + l9wOPl/8fYHqOBhO4rtsPGroX7V1v/rcf9uGw/sgn6f2vqC03oThUvw+Np9rvKfwdVlDP4f3X1n0 + vvxhdOz3X8OVpV9Ye3hPOeGe9xT++57ziI1vWcaX7c859HPm+37sV2v9I8Od338Nl2NfY+Pm+b9U + T8ZwsPdkh/y0jlLkd48vvdzPlrPhivwd8s8Nl31evb/rGm7aW1g8iOHU/ZeL9ksK/av3uIcbp5Hv + PNyf9PpH23x+6kvy/erxr/j+7P4VjeMxnIYdHCfB/7HvSvCTA/p1c3w3/8rv+6aLzfY/Cf6K94vd + 98dxHth9f7TTvHL9OqqvrAP3/T51wPPkY2f+YMrLe7fhiuPe9RkMl/1++a4/brgUuFd7B+77I9F+ + GbjvD5q3eONS3H9Dr2/aqwt/ZbgS7b2uj4H7PvqP4dKP7WngXs+3gfv+uZ91sbes9i7xG4Yrznde + dHx1sfd1Hxoef+W413k/kLLRqS6T4STmH8P5++CwdTnttfirlDdcifXBxkMWPUY2ryTGl+wvFsTj + 3yXn4AC1N6i+2edP6E86f+8/dL5MtA1XfN8g/sHEQd+b+AcTl5wHIX7TiKtjpve8ga3N4nNYeyPO + o+b7ldnbv9evjjiPyD1v4h7/iuNStMf6b/xo7wh9Ff5dz/+F/gb8SW2bvT3ey07t5eBfyHyG/iTN + 1zCchh1s3Px98DrhWtRfiPdQr3/UNtxv4/u8D76/wxoO76GELxkRf0X1VQwnfk8mvNkI/UnoP+eI + v1ryYQ0HfULCAw/EX6V0xs33bhovYDjoq/D5bPejTHXPb1wJfbPmeozQnywb7qkXw75bFr1r/l28 + 75N71Ij4q4veP0bEX1EduRv36E92v/+6/uTqT47Qn6T6cIab9yOqq2G45POKnlv66HufcBI49vuc + f8b96NFjXPm6Af7Zfh+zI4WeGz1XPf5KOU8zQn+S8yoj6h9xv31E/FX1eP4U9opsuGd8WT/rol/H + ccl5R+oPOf+sncUDG06c/+PtScRPDt+vzF4puuFK4Jgdzj+f7hXgnwe9/47gn/v5u4gXpTjnn9Xr + 8jx83VVkwz3zmfw+8M/1MB7gn0/rF/wzv08P8M8HvnME/+x6/099nF7bhiu/7Afgn+thXoF//gGn + gjwMbod4/9H7lvSFj+2Lva3mDVd++n19mc9sPHrw7fR+JH2xl/Wz8880b+L+8+Gf7+8+epst7bgS + v4/136PvTe/d8uh7n3Aa3+V2wL/i/VdjPt/32sfeqnnDwb+i91rnn22bZ/1i/pXhmB0V5y/R7zTc + M75s/pXYr77q00lZ4zfGqj/J7S3L+DI7XH8yn+ZLifcFPm5leU8h5wL0J4efR7F+s44Nh3wNvu/m + 0Nvk+1qO95TT79Owg43boz/J20uRbxV8rPHPuW446G3y/f553+f2prgP8vMtxf2X8irgnzm/O4J/ + Lgvf7vzz2HBPfgobX13iRZkdurwv8PbAt5/aE7938/Yk6i02zy/z/N9vPgf8cznce8A/0/wow6Xg + Vdi5JRGvcmpPAvfaXkf+r1Z//8X6/TiWacM9792v/dyR/6u8nzvyf4X72T3qH1U6n3vUPxonXFre + y8bjT6a1fpnhSuwbr+u3I/+X6xIbLsU+yX+fnve/jvxf5eu8O/8c72DP+MrqX3Xnn/27r/tkd/7Z + 93Fmry77FW9Poz02TzXeB8l52Z1/jn6Z9nrhxbLhcB6R94/u/PO9X+l7HgvIurmf6rvumz6pLDeD + 8X7+Rmjp1e/2yO9z/vm6KyR7vTbLh71y2nDOt/Pf5/xzTywf1nDzfYHftzpCkvpgcfCGw3sZ2U/n + 1oZ8q1vvywtizRcq3XCPPiHpZ3X+edC4volDPOF73onGFfiiuh8aW/lVKD/Zo/6R850ael9tfd/v + wT/30+/r8b7A7bWpOng8YY/8Xx6X1oN/LpQX7ZH/67okC9+uecNNexPlJ7vzz/5Owubzk59C+Mnu + /LO3x9ZlW/wN1s819Aoa9MwnH1sXvXrDPf4VOReQ/1toXEaP/F9ab8xw2J9P7T35zqxfyre9KeKf + s2443Pf5d0voM3A7/H70A07DDo7DeUTecTr4Z2uvLPN51Ucy3JPPzuZzjvOX75OrPj+bL3mJv2Lz + NMd9gX83/fv3srlfpe/zV5/7Ed83UsznEy7F/sdxuvw+hpP4fQz33I+q85Me753qhoM/yX+fLvHA + bJ90/lnoO1iP+Gda/9dweA/l55Hrq7g+qxcG2uofGQ7xVyT+vgf/nGj8fQf/LFSPzA8j9//edcYM + 98P7YI/6R7qNr1y64yZ/ResjGi7L8R2xB/+cDucW+GeaJ2c48X2DzhcxfwN6pQo91S89RsMV8xOJ + Hq3hcrTH7DB/49ZxTYf27iG+dTTfdV0MJ9EemfeeD1s9D3wmGN0/9Csf1nAz32rmlbPfZ/7Grbug + dB6Yv3F/7j3/3HCTQhxnnER7bB5YPmwpu7219A037Z39zMbN8mFzP38X+Vbv+j6G0/nacePIuWV8 + rNz3Ct6e5Vvp1Be4ZYXFDPrmYzvyYdMcXzavLN/qXm/v+gKGm1nZs5+ZHdPfkEvO35326mn+TX/D + v/txshL0GVa9a8Pd+gx1nL47/Q0pU7eC2TH9DTGdBOJHGB8rKZ3WuZfwvmgeWnc+NtfL8tpyw36V + St5wt70ymD664fLdXmL67Ya7qYFcaD5ddz4237wU7xcrVWPzlH13+hsicx3VmT+Yp72bv+H5vzpx + bN/w/N85/1g/T39j/c+vOP0RJz/hPP/X743zvdv4WB0brni8HuHvO/QYp8dzwDk/yfkSjwduPH6j + Ix64UV2/+xJq8cBNIwzpn+X/NsQD1075yYZ44ErrdxvuyXfmv2/m/3bKAzfEAxdaT/3Gef5vd30z + 5MOmVU/VcPM84vePhnjgwuP/GuKBC9VRMty0l98XWuT/FupfNcQDQ99WoZf7pcdoONhL/MmGeGDT + M3qdzw3xwIZj/ef5+/z+0RAPXPh9tTkfq9XzDBX6z0nW+OfmfOzMFz+1N+cz1ZlFMCG++7rvNudj + tXL/uYGPrdy/b+Bja0IZEeQ7r3pBhiuBI/Y6H1v5faaBj7V6HWT+OR9bG+VFG/jYpvT8vQlJ26/6 + dl/QoTvuuS+QdaQD/PPxu8nvFdwOrweUma6V4ZDP/l6n4cb10JO525t87LT3i49twcfS+j2Gy86P + n3CTj03n3zf59uuME3s3OPSz3Y/GcL2Cpx6Q7rji332vX2E41Hsi9/iGpWn1Sdh8bnEfJH5YAx9r + dVtYP/v9KLu90N/47MR9w009Cq4L0ZyP1czzcJvzsZr5e3dzPnaeHyRPrjkfq4W/E7fQoxB/T0G+ + 1cfwtuGK76fEb2/Qo8i0fo/hHnvZuJXgn/k+WUL/mfACLeKBXW/OCbTJx+YNB76O+O0t4oHLjWPz + 2evR83tUCz0KWu/JcHhf4OvN/CvT6cjL/vylr9Kcj1Wr88PGN4VeEOEFGvjYwnmLBj0K43NYP5t/ + led32T5u/lX2ukGhB6Wy8pPN+dipP8Tns/tXVD/RcCm+y9sDn8P3P/OvGo/7b87H+rnq4zv3Zyk7 + Dvsz/33mX53ngflXfZzGQ+L9l9yjmvOx53NQ/L1bfHxRz0vG9/o1Pna+DxLesTkf6+c5x+E99IRD + fhk9j8Tfu4/2mn91Vdtfpr33RJS+6F8ZrgSOjIfFA/+EQ/zGCaex/5Hx9XhgUVbn7Mb5e/dl/RL+ + lXRJG664/0L9HPF8K85TT9wcX1pfzXAaOLJ+pYd+Hf997l+pr9/gr+r3fiVtWb/kfHP+2erO8e+m + +C6z1/2rfho3868arWt548y/al6v8nlfqKVsuBI4Nq/Mv2r1tI7Mv7J9ktlh/lWf5zRvb94H68Hf + cP65+vk2+fa5fnNtG674fZr6B84/H/jY5vzz/Nzp9932mt/E+tn0vvJ16hfjr3Kx7z72pu/7kesx + 5nzwm1yPMV1n3HxfOI6v8Veot81wt72pn3DmXyW/5833BeefdcOVn77r+nVyWueuX6dn3LS3ntaR + +VcWV8Vwzl/h/A17VXXD4X7Ex8P8q3S6v8nqX7Hz1/2rfvDrPB44TX+S7ZPmXyXfh8LetK9f869s + vrD+M/8q0TqZ2qBHgeXDcOrz4ISb9haq11fBP5teeLrT6JyfzGs+bAX/nC56P6/gn1Oh8WYV/LMO + qodXwT/bu/3rPlTBP2s/fdfWr8Vl3HPH/eektW64+Z5SKQ9XwT9rpv59Bf98iFOo4J+F8yXV+Wex + +BfWnr0fAbfYW+qGm/rttG6a4aZ+ezr1s5VUNx6JzRcrDWo4Nk+txNUZN9evQOf4b8BeWfnY6vyz + jH6af6ZXb3qWrF/E7OV8bHX+WQbn4arzz3LgJ6vzz/Nd/G7vL/jJa30vq84/i9XNJXYY/yxtHH6f + 8c9ifCzpP5ce/KW9295WKL97XxCmvc15x7+4/471vjBx0956+n3D7D32i0mENFon2HAznkGorunE + zfd9Wk/9xnUb3251HmM+a1/jN6rzz9KP9s77kRz49ur88w/90m18Oz3fKp5Ez+01G1+/l/3hfvS5 + aey44nEP5Pytzj9L4/fu6vyzHO4LFdRFU+oXVxzBjfOE1fnnOV9u/+WvuwOgtbQNVxYcay97/xH/ + vmKLqZ3yetX557mOCF9XnX/2fmHzr9j4enzEX/d4JC1rfnd1/lmanL5bzN4Z/8L2SYvPqdfJXovP + 6T/g5vmrp+9afM7wMKQ/8Dmfm1DecMX3ez6vzL+SYz9bfM5Vzrh5Hulpvlh8zuD3y+r8swy/T8/1 + O+1NqW64Ob6cB67OP891Tnip6vzz3P9Ov2/ae536JS32MpzG/nz33/Sv5nzWsuNw/vL5Yv7VXbee + xH1V55/nd0m8WXX+ec7nE07cL1E6Hu5fTZ6/2nye8YRX3XHF56nS+ez1gNrp95l/deVze/OffppX + 5l9dp3Xu/LN43GaM78cD7htu2pvO7WXH0fE1/nn62Scc4gmpvcY/n+e98c8eT3g955Fs/pXxz+d9 + w/hnsXcDMm7GP8uBh6vOP/u+wfrF/Kt2Oi/F/Cvj9e5LDca3lx2H/YqPh/lXrZ5xyc9pEjc8cer7 + Bp9X5l/VTN/fqvPP7h+k5/z91kOuzj/7uc/Gw/wre1djv8/8q8LjIqvzz5KvU7+Yf5WP/Wz+lbXn + 9yOPf95xt73ptE9KDX/y9N0U+ynZ7z3+efxgh8Q6Yr/P/Kve7BwMf+PTU2nDlcUPY+3lX/wcj38e + nC+uiH+285Lj5Kf2cpxHN5/4F++DWWTDwb+i/r3HPxuO+BEe/zz4O0RF/LMdk2x8zb+6eBxydf5Z + rK5Hs/PI+NhtfM2/OsQjVeefJz/E+8X8q4vzxRX8s/D35Ar+WdLh3uj8s2TjBRZ71/ejCv5Z+PtW + Bf98/n3GPwuPy6jgn5XHaVXwz0rrLdolqjqPOe+/F/irXGXDFfeH+Hi4fzVO9rp/xd8Rq/PPcz+g + /IFIzGfCmxXnn8Xyk/1+5Pzz2HBFwDu+2lucf3Ze79WO4vyz8HpjhlO/z5xw4vwfyS8rzj/L5fVn + Hnt1jWcozj97/72OW3H+WQ5528X557lfkfyy4vyz99/rPC3BP/M88BL8s+dB/kX8sy71JQ338LFs + vtj9aPA8yAL+uV7n9qZ/1U7ja/ejlk/9LMFv3PP0D/X40ld8TgH/3Dn/XIJ/5nWDCvjnznnqAv65 + 1XN7t72Fv6cU8M8WP9lsfC3+uYwNd9tb+PtlAf+cle5DBfyzvb/x9qY/men5VsA/J84z3AGT5k96 + fM5tlMc/r/nOE3fbm/l78sRNe/k78cSlwJH5p3Y/ypWeMxM3x5f7GwX8c8nmNv9FPOFX/HMB/1z4 + u24B/1x/wIGfJOdW+eaf2Xzx+9Gg/HMJ/tnj5Z/3hbbm45Tgn0/7M/hnzssX8M8HHr2Af648rq+A + f67H+ef8c7Z1FP6z1jUeuIB/PsRLFfDPds1i86ou/gbH4b2Mj6/fj+rp9zn/rL5+470s1x0Hvo7w + 9yX4Zx63VLCl9uO6LDGfyTtYAf9s9AwbX/OvmscBTD526hVs/pXzz43WhzUc3suoH+b8c9fDeen8 + c+N5NgX8c+VxuQX8s/EM6/6cvv0N559LO42v+VeghRgO/AY/j1LwGyec+O/jOI3zaK5f5P+qqmy4 + 214dp/ln/pXFM7B5Zf7VIc6jgH9Oyd4vGW5eGcYJZ/6VVtt3c+SniKYNVwLH28vxXTYPzL8SHr9R + nH8Wo4n5d++rmb1HkfE1/jlDXyBr8M+5bLiPvVkr5eGK8885VcrbFuefc+mUlyrOP+fC8+OL88/5 + zich+cnF+ed856vJV3zsKDvutrf80N5t7z2fhdph8c99fpfsVx7/nHhefgk95Ho4f6WHvugMM4Ne + 0Hc9vomb8c/jcO8Rr0cvNI9g4uaVodF6ExM345/5u/jEIT+F7qfQQy7mh6UCfZWmY8Pd+TiZ12kt + 0EPO7XDPcz3kwuO0CvSQM4+bK9BDPuQTF+ghV6+znJDfLbWkDTft1YM/6fHPg8cVFMQ/H+KzC+Kf + Tf+A2Vsj/5fejzz+Oc11ucSrfE6ovOFKvKux9bHyz2z++ft+pfx4Af989McX/Q263zv/3DxOcPob + c/2m2jbc9K9OfJjzz/XEbzj/XHhedAH/XHhdmQL+OfP6HwX8c/bv/qEegaTv89f55zRo/n4B/6xc + N6CAf06V5kEW558l0zrzhsN7GV9vGuN7n+fPe6iWtuGK4F2NjYf5V5Xn2RTnn2c/k3eX4vyzx7Xw + 9kSO7z3F+WeP30i2QKe9IjuuyPHduYB/Hjw+p4B/Hv20r5l/1U9+u/PPPVM/J4N/7h5PMwOwLd5b + 8oYrHq9M7gE54p85T5MR/5y5n5gR/5z5fpUR/5x4XGlG/HPyOMbH3i+9vhzxz/y9IiP+2fISXscj + R/zzZXmpDIf8BeK3Z+hvaKFxlhn6G4inVo3457Tj5nnE7wEZ+ht2P2K/z9+PhJ4fGfzzxXnb/B3/ + /LpfZfDP9j6T1/jnsuMQ783HV5b3QTZu/n5UqR+RwT9f/F6bI/6Z57Fk8M/2TuzvKTP+6iplw+E9 + lOzPGfobWui+lqG/Ubi/kUN/g7/b59DfSDTu4S6gafl0M16qWD7dfeH7eOhtw838QR5HNnEz/5fr + 103c1Bvh8WYTB70CotM2ccjvJvetDP2Nz3+e+nDpgr1f9WKy88+p6bm9+77Qf8DdU1+V3hszJC2V + 62nlkKLqf0x/LTv/nC6PL0mIV9G68u3Z+ed08fih7PxzGjx+KDv/nEY+zVO7H1lcJOs/ux8d4jaz + 889uZrK/TL6urPnO2fnn1E/7kPHPqfN7d3b+OR3y3jNCDy3O/NV/yXhCt/h7tm+YHnJ3HjPF+0Le + 7DU95PN3TQ+5l8P5a/zzxFE/wqkuc3PZPDWXrXP/OUN/A/ovKeqlZs0brvi6pOel62/0SnnljCOp + c14gQ3+jX/RdPEMPufN6pBl6yL16vcXQo/jKL8vQQx5ctyxDD9m+y+ZBivElujMZesg9Ud2ZDD3k + nqk+XIYecvd72W2v1+PTHYf5TOpcZOghN14PI0MPufM6Ohl6yJ3r3GXoIdtzPetn00M2XF3s3fwr + 10Nu4/RdsfEVel91kZhPe+00vtO/Sq3S+352/jlVrgefoYdsOm198ldzPsv17W+4HnLhevoZesjl + NE9dD7mMw3pzPWTjQUj/uR6y1V8l/eL1+FBXNerDfm7EZcNN/WfOb+Sox8fr8Oaox3ed+uXhn0/t + ifOsHNeDj21eH8f55218vR5fOrc3+eejvc4/j9N4dJv6P7QnzmeT+gsZ/LOorbeovyAtlw1XAsd+ + n9eb4PVrM/Q3Ls5LZehvXKd17vobh7oUGfob1p7V7za+rnz7k66/cXldKNZejvZYvxj/bO2x8TD+ + +eL1wTL450tpfdgM/tnKeH3Zm3fc1I+9aD2lDP2NX3DQCyL6rBn6G4PruGbobwxerzdDfwPtPfZm + lQ037eX1SDP0N8bp3HL9DbOXjYcdSRevi5ehv2HjS/xO19+4suGmfp3zz33D/Ta+Kd5TSJ3CDP2N + wevDZsQ/D15XOiP+2cr7sPPS+Kvh/kbom4lm2XC47/N1pHHfP+Gg98X3K4t/7uO0P2vofXH/wPXN + qtfja27v50TuGw76dfz8kNA34/upmL1C64tn6G+YP8nmixifw9d5Cv1n11eO8f2ux5fAPzf+TpLA + PzdefyuBf/6lvakHdZ1xEnaw76bgrzrqLU57v/QJE/hnzHvW3ly/vC58Av88+HmewD+bva/7WgL/ + 3Lh+ZwL/3JL9vmd8paYNN8f3aMej307WZQL/bN9l88/Wb+P7QYL+M+bpO8712/2cWexd9UaS888T + R+5byfnnqRfJ+0XivZv3i63flug+lJx/dvlbgnP950cmF/F1X/xzgv7zIX48gX8+xGenqMfH6+ik + qMfH4xkS+Oc+6PvMB2f884BebsSLjrX+wsRBr4+8R01c9nsA4eEmLkXcCLPX9Qm57vTE3Vt+OuLs + fmQ6VJfdf22ga9lwxe+NhP9L4J/zdRoPux+VQt+ZkvPP8/5L3o8SShwUnkeQwD9nz0uI+JzPxM4b + rsR32Xi0uO8TXi+Bf7bfx+af8c+mp89x4v3M11td7O3PfV+rlA03x3fQPJEE/jkPyicm8M8Wb8HG + w/jnzOu/JfDP9l02r4x/LuL16cLestbTTOCfczvtf8Y/Z84LJPDPidcLTOCfM49XSeCfE49fS+Cf + k/t/T/3BLLrhJr/B/dgE/tl4EP7dFLwFx2m0x/rZ6x0fcWmpP+j12m6c6hqPlMA/H+pBJvDPv+DS + 8l2Gg37sCTft1cN57vyzej3wqO+smmTDlQXH2pvjK2fctLfTe3KKenw/4CRwrF8k6ml6mWO//15V + N9wcX84fJPDPcvLDnH8+1I9P4J+Nh+PtyS+/z/lnw+lTz1pGHRuuRL+QcXP++RfcYy+xw/lnoxHJ + uY96fErrXqfQf87GR8zxNXtlx6HeBLdjBF9H6gGlVf/51N7kc3g98BT6z3KYL9KDn7ztffirzb+S + Hvre/Lv9F75u4uZ9sJ1/nwbvw9uT4NfIOQ3952zzKuovSCtjwz18HRu3R/+Zz1Pjn3s//z79ESfO + NxE+LIF/7j4eD19XU91wJXBsPGrUT+G/z/Wfj/OgBl9H92fnnwfnMRP4Z/tuXewtqW24EuPGfp/x + zzYerJ9LjC+3o8T4Up7G+Wf7LhuP/D2+D//8ff91/tnaY/tkXuxl45uDnzy199jL1keO+cz7z/gr + 4//6wsemnDZcCZ6Vt4f6R5RHcv75wE8m8M/95Dc5/2z8H5vPGvrtG/9c0oYr8V02Hs4//4CDvdTv + dP75yNc5/3zGSdTH6Ws9EZG1PnsC/2w8Jhu3lb9i69z5Kznj1Nuj/jP450bvgwr+2eIA1nptOe+4 + ErzZ63zR4J95HW0F/9yV5g9q8M+V6mpo8M+N8hsa/LPHDwVf97khjg338HWv80/BPzeum6zgnyvX + ddbgn3ncsAb/LJR/0eCfPa8o6sV8xz9r8M9cT1rBP5vuL//uHN9K47MV/LPh2Pj6+xHP/1Xwz915 + x6gn8rlB6IbDexnh/xT8s+Wfc1zyz5F4agX/fMijV/DPg+sVKPjnS+27T326scabKfhnw5HxcP55 + cF0mBf889IxT98fpuDn/fPF89g/O70cex7jwz+t9f+Iee1n/+f3oh+8mv38Qfnfi5n2Q6ytP3Nzy + T/PK+Wfx+jOe2Dl3sB1XnLfg3/X4nER5fkX9wYvnYyvqDx7yFzTqD47D/uL8s6Ce5hX8s44NV/y7 + hN9V55/V9IfIfuX1By+ez6nOP894n9N3wedwXA3+6j7fHr69rPdfBf+sXHdBwT/rD99NgSP7kPPP + qZ1x4vwuPS/BP1ezI9Wwd31fUPDPletRKPjnyvOiFfzzoe6rgn+2Oor8u3hPof6Q88+Wf+nxhJOP + Tdv4Gv9s7wGs/4x/Lry+pIJ/Ltx/VvDPmd8DFPxz5vcUBf+cLo+PRX6oah0bbsZPdnqfUfDPmccB + KPjnrPR+rqAyM4/zVbjkmcebKfjn7PU5H/5Zqmy44uuI3PcV/HPKJzvM5UjpZIfxzymd7RB//yD3 + fQX/rM6/pBT2rvdBBf9s8azs9xn/rPmMS/EewHHq+xq5dyv4Z+VxMgr+WT1+ch6w8z54Zd1wJX4f + Gd+Ffyb3cw3++aLvfgr+Wfl7mQb/zN+PFPHPUv0+iPgc6d/z2eOfDUfWL/hnnleuzj87jv8+dT+C + vCOq88/zPOc455/9/XL6z9Petr6XTVwJHPt9D//M58HDPxM+YuJwXzjhwE/SfdL55+7788NPNtUN + V/zec2ovR3tsPrclnpCNR4v74Om78hPO+WfEPwefU7VuuBK8D1tHzj/X075Rg9+g+zjqD/7wXTnz + fwr+2XipJd5MSqkbDvwGn1fGP7fj/DP+2fgmNr5lib9i42b8c+PxnQr+2XDl4XMkl7bhEF9H/TX5 + kb9y/rnpgZdy/tn4HLYf5LCX41LwdTfP9dibcttwRZ64NNbebW/leq8K/rlxvVcF/2z9wsbN+Kt6 + us+Af867vZrShitLv7D2ctjB5p8u9rJ5by5HPd1/wT/r6fdJxBOGvVM/R8rYcCX6j7eX4/ex8ZCF + n+TtTXvrgT9w/rkOypdI8M8NZY9Cj2KN9xbwz5XH6wn458rjDgX880EPVMA/V17/V8A/n79r67c4 + /zftnYnAqfQNVwL3Ok8F/HPh9a0k+Gc54zC+RJ9BwD9Xrr8rwT8jjR31gNJXfRwB/1x4XW4B/1zK + GZe8X0j9DwH/XMsZh/lM9CMk4p9dd0ZRXyPJGh8rEf888+hf15tE/PPUrWD2+vr9AYfxJXo8Av65 + ep2fVxzin6d+hE+wqc9wfc9n559N14981/Wfr8v0/xju7pp8UX0Gcf453zqVRI9CnH+eOKJvcXvE + U58wTZ2Oz1zMsLfXvOGK6w6e2rv1CcXrkzDcbW/i9Y8m7rZXpx1knuqwo+E64brZK4YL/Un90icU + 55+9X8g+afyz61myeWD6G0n+mH6ThP4G1y8R6G+kdvp9zex1PahcBAfTev8V55+zcj0tcf45Wz1r + jpvzOR32IeOfvT2Ou+3NctgnjX/OyXVrM/SgPietbLgSOPbdavb2wzlo/PMcX+ofeImwxPXgBaUu + dJxw836UkUcw57Ppjaz5VuL889R/ObWXXXeVvIOJ889zPzjh5nzm70cCabWDPpc4/5zV68g+4/uV + HyrOP7sdbH1ks/c69YtJRx3yKwQSCHqcL5bKp/ydTpx/zuLvg8/4pu/z1/jnLD+0d/N1F6/zI+Cf + D7pWAv754rpWAv75jDP+ebj/9+jJqJYNN/U3+DusgH/ujfr3Av7Z4gBYvxh1W/n7vuAKUiu9pwj4 + 5+r6a/7Acf/7nDdc8Xcc8n4p4J8Nx+wwF6vw/CgBtPB7lIB/PuhPSuhveBxF2Cvj299w/hnXJ9be + fC/jut0S+hs8D03AP1d+rxXwz4XX75HQ3/B6QIu9ZcchX4PuL66/Ie0w/8A/n+5R4J/z4Vx1/nnw + OoU3r27xwF5fNyXobfa048A/U39IeuSnUH9DLL/sF9y0l9drmzjEM3BcC73r5PHeZm/LdcNNe09+ + DvQ3+hmX4vdxHMb3ZIcEjs37GvkLCe9HXn+wbjjw7dQ/hf6zHPxd6G/Iwb93/vnmGei9DPrP6Y/p + rQv45/s9+cZp8fvR5/rbNty8D3JdZwH/nPsZd9ubLqrrJ+Cfb31Reh90/vneT3l7OeKBBfViZjx/ + Xt8HJfSfj7/P65ep6R0y3NTbTGfcXJ2X/T6Guym7ep3aS8v4qumLzvH9qj8oa/1Bbq/xV1YnmO2n + nrp9neaB1y8bZ5x4vxB9TIH+8+X3S431q2v9FAH/rPVwP3f+WfsZN/Vyj+vcn7zHGSfxXWav68d6 + vyz6z1k2HPRj+XkkUY+P76dGOfUTX2f88xzfU3vQj33n624nx+sPum536Mem9f3IcFMfOJ3bA3/1 + fi4YLvm4vfef4eb4VnYuGG7aS3U+b5zXH/Tz7bF3zV8wXPH95V2/03DTXsqLGi7JSX/XcNNeyvsY + bk4FWj/+xq3rdzz7VdJF78twGN/3dWS4OZ+pLrvh5nymdUIMN72J+fuYvfakUhvb18xpn3r1vs7/ + ULhIr+W+YLgipkPPf5+t33KcV7Z+K60TbLh5uuppPtv6ze0wD1B/0PeDxd6FfzbcrEdwWpfOPxv/ + R/oZ9Qep/rPh5u57WueoP3iaz2r1B9X307/gN3otG27WP6J8ouFm/QVa58xwc0ho3SrDqfffO09o + OPHvvt/fbpzVH1Svrzvtnff9/r1+vf6g0HwDw816TzSO23DTXqqbYribQuDvpoaTwJF15PUHg78K + YZla24ab9grjIwyX47vMDuOfa2F8hOHm6drYe7fhxHHvfMSNq2HvHUcxx3fGA6/xOYab85nqfhgu + +zw44e7x1cbiGQwHe9/jKAw353M5tVdiPt/xEVEvRtf67IYrvs7f45UNN9dvPePmfkXjWgw3bwOV + xT8bbu7PhcX/3Tjzr7LrfD72piUe2HBFTnVqDIf96l03xXC3vaabwsZtrY/D25v7M9V7vXFef1Cs + vT/o5WoqO27am1hcpOFue3ldHsOlsIPj1PvlPd7bcOLtcZz5V8V1SB97VfOGm/bS+DDDTX/j+PvM + vzIcs9f8q0LjRQ0n3h7HyWLvMHvnfP4c3RuuuN/0Hi/qxfN+/G4KO9j8c/+Kxs0ZTmL+kfVr/PP0 + 6xr8yakPfGnfcOWX32f8s+NIv7gLWKj+kOGe8SX2Gv8spRzWh/HPvn51sbd/n7/GP3t9bGav+VeF + 1r80XPLvntpT7xe63xv/7POA7OPi9Z2TnVt/yP+Vtb6z4Yr333vep+Fy/D6yfqXH+L6/GxgO4/se + T2g4iXnKvuv1nZOPb4l44Fo33Lwf5dP6aHE/4vPK6jvb/GPj2+I8ovuf8c+zrvl7/PONM/8quR78 + Xwp7y457/A3eXg4/gtlr/lWi9X8Np3GeM3vdvzruG+5fuY7XY28pO674fev9vcdw2e+hJ1wS1Jnn + uHk/ou/EhpvjO+9RbH2Yf5XmPXnY+p31UrPUDVcE9ejZd3PsV+/1Pg2H9XvCzdcDmu9suNveRvOT + b5z5V1b/vP5FffbPjMwbbvLt7XAv8/qDv+CSoC43x02+/XQvc/65jcO9zPlny2f3+t3TXs077raX + 63cabvJXNO7BcJO/ovXaDDftpbqchpv8JI0rsEO6xneT8ZMW/5zzhrvtNR1SNv8k3lN4P5t/NWh9 + HMPhPYXyFs4/dxrXch/6T/3QyW+EPsMa/2y44ufWe7yP4eZ8vmi/DOeffZ6+rrfh/LO397p+B/jn + RuvT3Thbv83r+kY9+qSLfp3hSvy+13Eb4J8tDoX1i69fzlsM55+F62AYTgLH+u+pH3qfl3897NW+ + 4fA+SM7VAf65UX1Rw017aT674dTn1ckO8f57jxsxJ3buz2PxJ6e9sr6nDPDPjfM5A/xzozoxEK/7 + 4Gj8iwd5+HlE/NgB/rkm6neO4J+9ztTDX12LvpnhivMlxG8f4J9zOtjh/LPpDfP21PkD2n/OP2eq + Y3Pj7H6UfD+Y/pXxsd/rV+1+lArd7ydu+pP9sF+pDYkOuj9P3PQn22HfVbsfJT3Za/ejNJyfxH3h + S//ZcMX9YnIPGOCf8w+4Ob5Uj9Zw6v4puS8M55+l0Dz6G2f3o+y6Vn+Rv7/GPxuuBI6tD78fUX15 + w4G/es/vNhz4jRMO9/33/MsbZ/cj4GZww0xkKLVuOPCT73qMhsuBY/1c4z74rgdgOHV//D0v33AY + 33cdyBtXgt+4//N89Jz5C2t8juGK9/NF7SjBT160X/x+dD+xUzucf06n/nv453c90BuXYz7f/WKP + vLe9ecmnM1xxO3j/5ZjPfNz8flRZvrPhsD8TnmaAf85Ul+TGpYWvq8t+lWRsuOL3KMKfDvDPldaF + Mhzef9/zhA0HPofvV84/Uz3pG2f+lcnyV/M3nH+uG65Ev7B5qsHnvOdZGy75d9/z3g2n7kfw/V5/ + 4a8G+OfqegV/0JORq44NV2I82Hcl+Fg+bs4/H+eL+Vd5nM4Z869yPfSf88/Z6wpOf8P450UvyHBF + 8G5Fxs35Z66Tb7gU643MF+ef7Twn69yvhFnoO9MA/5zxHpqR7zy+9yvnn1M++InOP1tYMft95l8l + qs9lOHW/7oSTsIPMK+lx/k7/Oebzqm9mOPDtvP968Fd8fHvwdaf2wNfRfUjMv0onP8z55+S6JOFf + felvGK7E72PjZv5VpXoyhkvx+5gdLfjYd70gw4n72dS/cv5Zq7WX4V99ds4dN/lnOX3X3/epTrnh + ZjxDZnrrhru3wHLZtGO4m0oqx/6z/DJ7h70s32ruV6XohiueR0XeP4bzz1mP683yy4TqkRnu3so7 + 1Ssw3NRzy5QvHs4/p+T8+Azsd/55bLipf1UoDzycf/Z8DWZHjnh+wjsO55+TUJ1Kw4nnGxBebzj/ + nMT55ydf4+t9f0B/w+JjeXvQJzzhZjx/NZ6f4e4jmMfHGk7i97H1Zvn7vVoc6Mxnn+MrNW846HuT + eNER+s/5ZK+Gfs4Jp/5dPk9dP5bmX9qhNfPZPb9xsbf0DYd8dvI+M0J/Y5z6xfP3K40THNDfyIPG + HQ7ob1j85Os86NDfKB5vqynin2XHzasizZ82XHYciRftEf9M888Nd9urPC6yQ3/D2ntdHx36G4a7 + N/3Qo1j5qw79DeXxyh36G8LjVHvEP1c6Dzr458HjMTv4Z4tbZ/ba+rX9T594/qTrfO6If7b0htd5 + 1aG/oTT/zXBJnnQJhptXhnKap56/0E79YutXXc9j/oBpr6z8Rof+hsW9sv6z9Zv4uuzQ30iFrssO + /Y3UT/PZ1+91+K7rbySPL1Yk/Ou11Cs3XJlRhod16frPuR/scP1n0xF5Pc879J9rYfkuhrvtTReN + v//gRuir3HHwGvHeY30fnLgSv4991/QJs9C4+omDXtAJN8+jmZfF7UB+6Hu+1Y3rUS9GED9peiOa + NtzUY6T5YIZDvOh7XpbhkvM+7/oqhpv5knL+rrhfwnGWH9oc93d5Pt1nJMuGm3pBP7T36MmQfdz5 + 5360w/UJ53iweWD3o3bsZ7sf5Wy4P2yYutZnNxz45/c8OcNlv8fzeVoj3uw979Nwk6rJ5/YQn8PX + r/HP1t5Y9FVyzRvuvh+ZnhH7rt2PSj2cH66/Ubj/3KG/UXn8S4f+RqG6EDfO9DfMH2omOGF6FCtf + 16G/YecMW2+mv2E6LGwemP5GpnpfhtOjnofhpitL8+1vnOlvqMfxLPaWHVcEckJsXSa7//K4oO78 + c7Y8Ed6eut7ICSfRL2weqOmNDPObEuJVVLb5rKY3QuvDGm7qjXQaz9Chv2H6/GzcTH9j8LjNDv2N + QfXWpTv/nIa6PsMV8c/SN1zx777rYxrutnfwPIfu/PPkLU64aS/VF5VIOeX14+9/TH+jO6889VUm + nzO+zyPjn11+hfhrxj/7d4kdxj9PfRXCP3eEhhuO9LOHODUez9qdf05WD+gzn/GeIr2mDTf1Rmh9 + U8NNvRFaN8hwt732/kHmnz9F1Hr+LuwlfN38Z/ob1eqr3fYaH9tL3nC3vRZ+x77bQ1+Fj5vXd6b6 + 3s/UTzxuzv4R0z3nOPOvDFfMcZvxdZt/ZfzzoZ6I4R6+jvVLC30VEs/VQ3/jOuxX4vU1ePxGh/4z + 6pNE/ZTP9rzjyk/fraE3Qvdn198Yg8bX9bX+ID0XXH/jSodz0PU3huuGagc/mb/9DdffsPo4bDy8 + /iCPV+5RfzAfzkvUHyxM18pwUy+X6vHc/zz6Gxn6z3N8s6QNV6I9ZofrP/N8zg7958rjbTv0n+vp + nIb+czp9N8X9N+yd/ORav8xwxe/dhG/v4J+bHPxn558r1c8xnP7Yngj0ShlOQy9XoSdj+hvaNhz0 + zOn9w/ln4yPYvuH6sVSPx3DgYykP4vyz5cez8TX+qrruR/AbIpI3XInvsvn88FeUB3H+2XgQZocs + 9rJ+Nv6qZvr7WvDPrisU9qa03n8b+GfTAXrtvwb+mesZGS79+Pvm+qU6WYab+kicx2zgn00mtyx6 + yCntOPBXhO9sof9M9ZANN8eX8+gN+huZ6x806G8Uri/QwD8X12F5xleXel6GK87/Eb69gX8+8KIt + 9J/l/Ps05j2bL7Z+E9fLaOCfTS83WcNTb0SWeriGA99OeKkG/tn4NTYec/3mRPWb3Amb0SSUn2zg + n7le1e2sPfrPN08Y70cfzyJvuBLrkvw+8M/lj+iMGW6+L/D3ngb+uVAdNMPN8aU6YzfO+OfU7ff9 + NfCxY403mzjE173rWBtu8pPtsK/piHhCOv/U45+p/rPhxON4+HctPqfP767vC2t9HMNNvSCh50xz + /tn1qlg/21PJ4dxq4J8P/H0D/5z5+0Jz/lmT63aHPpI23XFz/aZTPxv/PMpp3GzJtR9wM/9onOa9 + 88/8fbWBf27Jxvext9QdVwT6Q6z/jH8+vPc08M/XaT91/vmg49XAP0NH8x1n/PPw8/wvChOs+s+G + Q34KeQdriH+uXBesIf650ToDhpv5OJm+EzfEP3f+3tgQ/2zxFp4/aHy7tA2H/CPCjzfEP5sd7Pfl + yMch98GG+OfG4zwa4p8t3oL4OdDfcJ2ix970ff56/PPhPbSF/ga/BzTEP2euk9Ui/vnk5yD+mccf + tIh/9vXxh/vRZ2cqGw7rl88Xjfx9bq9GvgZfvxb/nKjeoeHkJ5zHP/v59hf1Jjb/yuOf2/Fclchn + 5+eH2PjqH9Npa4h/rkf/RSI/hbbn8c/Yx2f8xrwPju/z1+OfsY+z9nKcHxwHfUJ6fnj8s+kEkn72 + +OeLv+c1xD9fHp+z2JvzhpupHHq4Bxj/7DqB7PeNRY+RrF8PcdfTvuuhWsr14dr9Z3U/4sZFvMpn + x84brsR3yf4s7l9RPWTDzfP3tI+L+VcqZzumvXq4/xr/HO099taaNlyJfmHj0SL+iu5XfvVJnN9o + WMJKdU0NJ4K4LzYedbH3sh9g9ua+4aa9/XBeOv9s+nqsX4x/Tvwdu4F/Vh7H2MA/23sow5WIr5v8 + ZNj7Ff/cwD/bey1vLwviyNi8Mv5ZT/6B889W54LjJPqZ7X854q/CXtOjqHnDTf4q0Xf2Bv451TNu + 2kvrBxhOvZ/Je0UD/6w8L7qBf06eb6/Id5b0zec4/3z+fSniCUl8ewv950bz1Bv4Zxn0HbuBf1au + d9jAP8uw9yON9yPd1u8TP3lqL0d7bN5rnEd8Hjzxk+SdqYF/Nt1Ltk8afyU+bov+htQNV35sD/rA + JM+/QX/jSjQfokF/4yrn9uBvkPYq9DeujLANf99PWXfc5De4LmIN/Weus1gj/jnReIYK/Y2L54lU + 6G8Y7nUe1NB/dv2mOb5Tn+GLf66h/yyn32f3I4sbeZ33NeKfeR5LRfzzlek+VBH/bOHbDGf3o4H5 + PKCvout9oUJ/w3RnXvfJCv2Ngy5Ohf6GvetynAaO9Yvr5/D3+Ar9jdE2PRm9atlwxXmpU3sYXxL3 + VaG/Ye2x9SHBX5H9qkJ/o9P6M7fzYvej7utojq/pbxTZcNALIvtGhf7G4O+6FfobVzrY4fob4zSv + 9LkfcZzfj1z3I/ZnHbLj5vrl5/nE5bCDrF81/nlch/WrI+6Dp+9K7EOsvR77832ex36lfX1fqME/ + Z3ruV8Q/X1wnpiL+eXC9oAr9jcF1WCr0N8bx91l+6BjL+TvtbSIbDvsz/25bziNmr/HP534x6mJw + 3aMK/tlwr/5zBf98eT8/9pbv/cr5Z/t9rP+Mfx5cR6mu/PMJp+FHcJzE+cbGo8T6nfpIj71LPSDD + Yf1ye0u8H5G4qgr++eL6YRX8s8VpsXlg9yPh/m4F/zyK5ztf0GfIaz5OBf88xsG/cv7Z5gH/bop1 + xOzN8R5Kzzfnnxu//1bwz93v3eFvfG6csuGmv6H0fl7BPzd+D63gn41vZ/3i+oQ8/qqCfz7EpVXw + z8P1peaEmOOrWTbc4z+zfjb/6upUj6KCfx7jtD/rsl/x9p79is17+bL3Wb+SdlyJfZftBxLrl+8v + fj8ap31X7J922nf9ftQP9xTnn6+23Y8+O13ecLgPEj2FCv754vf4Cv2N63SvAP/cD/0H/pnXBajB + P3vc+rTX9DfW+jgV+hsX1yWu0N+4uF5zhf6G3d/YeLh/VQ/ji1RhOfVzj/zQaa9ifHvKG67E72N2 + OP98uieLp0JyvZuJA79xwonzFnz+Gf8s3eLgH3vbqq9SwT8L15OpwT+X83fhb1B/zZ+GRjvjnvs+ + +301+KtYv3M+f/HPFfyz8HoYFfyzHNelX/XKGafRHpunNcaXr9/y7+fztLdI3XAl2mO/r8T7Ap9/ + xj9LPfWf8c82/9j6KPG+wNsz/tlwbZnPOemGK87Lczty8O0kj6UG/yzn9tTfhUieQw3+mevzV/DP + miy/4rE3bedRivcykmdTV/6Z/z7jn5XXO6ngn7Wf28P7IMkTqeCftVneiYb+lZa24fCewueLxn7F + 93ENvp3va84/59O4Of987BeJ97L7u+FPfvPPFfyz4Zi9spxH7Fx9/Cui31SDf+5Ub6kG/1zp/CvB + P/s8CHtTXutbleCfeb2TEvwzzxsr0H8eXF+vBP9caN5TCf6Z59MV8M/D9ebiPph0jWco4J9Ho/eA + EvUHler1leCfMx23EvyznnHi/cd/nwYf2xFPaPau9/0C/hn9wtoDn0PmaQH/jOsJw2nMl9d1WcA/ + 23fZ77P7kdGSXk9zvqeIyoYrgWPzWeK+T86ZAv754nmQJeKf+XtKAf98yIct4J+H77s6g5dvR+v6 + thf8M68PVoJ/5u/xBfHPqVKeuiD+WQfVNS3BP19UL+2DG2FvA98+7/t9zS+buGnvaR/SEe8pdP2q + x+cI9XcnTv27RHd14vCeQuez88/D9U8Xe9f4nAL+2exg9vaov3DCJX8n4f3i1devw34F/llOOOef + 1ce3w94v/rmAfx6n/QDxz1zHsIB/NrqM4x572bx3/pnrnxbwz6Pt87nmseGe84jsQ+CfeZ2zAv75 + bK/HP5/OVcQ/c3+oRPyz5zH/IZ9dcy0bbs5n7v8V8M+d63IW8M+d+50F/HPn9+mC+Od2nfrP45+9 + n5/5nFe9ggL+uZfTfDb/ynBsHnh9jZO/5vxz5/qdBfzzOJ37zj8bLi32Jikbbtp78k+df7bfx+ww + /6of14fX1xgne5/6OBynER/bEc8/7dWy46a9/J5XwD8f9BkK+Od+PD+8vga/fxTwzy2d1q/5V833 + 8cdeKXnDIR6Yj4f5V798d+pBcd3kssY/n74rv+BQf9DHI+z9eHppwxX/fUR3uoB/Rpk7hkvRHukX + 559NZ5t/d8Z7j4Nf4vzznSc3XL/d9ChGkQ1XvD2ig1vAP1euV1/AP9d8mM/OP1s9Fm7HnM+F8nrl + /hP1gBrW7+TrNv9KzL9qp/knPfJT6H1BzL9qnP+bOPX1Qe8L0kPvi9vbYr+KekDGP6ey4eZ+lQ7+ + rvHPsw4RvUc5/9z4u0EB/9x43FwB/9z01F6N+kcF/rPpb3yfR8Y/ex0nNh417CXvfsX5Z6/PxH+f + +j5OeOUCSqfxeJri/PO0o8LeOZ+/9M2K88/znOG/r0S+xgmX3C/m89m23sHjKCYO/jNvz/2rbvNl + sVfHhiuBY/tpDnup/+f1Bwd/VyuoP2jvutwOifs565eHv6orvyFad9wTr8LmqcdP8nfYgvqDg9e9 + Lqg/aHEUbD57/OSJL/H6g5e/qy32buvX3/dP9wWvP3hxnr+g/uDF64EX1B8cJ/8U9QdPfphI3Pcn + fzVgr3zfF4x/9nsoO2ck7gun76aY9xz33Bf4dyXuZa/tZfDPHf4z7r8prffBDP65d+onZvDPneuC + 5eCf5YzDfkXuARn8s+Fe53MG/9yr4RZ7U9tw2J9J3aoc9Qcr1RnL4J8P98YM/tm+y3ES93M2Hhr2 + zvkMfyPJmm+VI/6Z33tyxD9Xus4z+GfDva7LDP65c34oR/1Bft/P4J+br6OoZ51krUeQwT83Xmc+ + g39u9YxDfjfxnzP458bfITL458O9MYN/tvbKch/8yg/N4J9bOnzX+WfDkXXk8c+Nv5NkxD/XflhH + zj/XRu9RH9yI+pLz/lvD3rzjoL9B14f6/Yjr8E1c8nvUqT2N+yqz1+5HhmPt9aWeVzd7J1/Xc91w + 017+3pPBP1d+7mfwz6Wfcfpje/P+y+OCMvhnq/fu9YCmvV/8cwb/fKgLn6P+II+Hy+CfzQ42n73+ + IPevctQfbKd+8fqD/t3H3lrKhisLjrWXfR7w+Vcjf5/Pe68/KOfvSuBYe3Y/yt5/U69g2lvK2HBT + n4HXu8tRf5DHDeeoP8jr4eaoP8jvKXmtP0ju+znqDw6/HxXEi+ZSN1zx9si9NoN/zvz+m8E/Z163 + OYN/LjxPM4N/LsfvpqjHV8HnePxz2nBYv+Q+naP+YD5/N8V32f6XYr86fVfiuwz36G8U1B80e7f5 + bP5VuWi+UAb/XHk8fwb/bPImbF16/cHr3B74Ov77JPSC7vyAv9CfvNZ65Tn4Z6H5qzn4507j7zP4 + Z9PvZOtSgm8n+QsZ/HM79TP0N7yOe+TTffPPOfQ32sFe8M/58Pucf271MB7OP1s/k/5z/rlmGleQ + wT/b71Ozd47vKGnDQR+J22v+FfR4GA7+1Qk35zPXec/gnwvXb8/3nzW+mxZ7W60brvg65/3Xl3wN + Nh7OP7czDvOZ5HVMnMQ6YriHf854TzF7844rgWPzz/wry2Mh/pA89TV4/7V4HyT6DBn8c+c6WRn8 + c3ed2dCD+qyEuuHKj+3h/kt0mTL458H1cjP4519w4GP5d0vEMyTkl5n+RuobbsYzcB2MHPwzz3vK + 4J8H1yvNwT9nqpuSg3/muqb5z/nny3VEHnu/8ssmriw41h7yNU445LOfcMjXILo4E4d8HI57+Ocb + 9+jnfPHPGfHPIlRvKYN/vrjeTQ7+mdf3y6G/wfPQMuKfpZz2F438o4x8nH9ffzAj/vmX9hAPzPcr + jXhgPv804mNPOIn5x/pPlvncV3tT2XDId+bnh0T9I5LHlyP++Yf2Hr0RZq9YfHui7SXoP1s9OY9v + n4VFvu5HCfrPpofyOm4p6g9ynfwE/Q37fbw9je++rvO01h8k+1qK+oP576nXZvrPq/5kgv6z8P0g + Qf9Zef3BBP1n5bpgCfrPyvWlUuhv8DqjCfzz5fVh/5Bgnr70cxL454vXF0rQf5ZO51+C/rPwe0CK + +oPcb0rQf7Z943X9Jug/2/6Xn/X7gdQNV2LfYP3n+QtyxiVBHjiz98lfIPtBgv6z8Ptbgv6zYP3C + Xr1Wva8E/vk69bPrPwuv05oQ/yzcH0+If7bxJf3i+s+mX8fsHbFf3bg4f3Vo2XDItyL3j4l79M2Y + HR7/fB32K330CU/fnfpmQs/zhPqDKbl+HfYr7at/lZx/dt14sn5d/xn10Bhuxrdf599325u4X5JC + /5nr1afQf/Z996kv2aRuuKlnzv2m5PyzFq6LmJx/9vZe/fuE+oOF67gm55+n3jr/ruWH2u9rTz0C + raVtuBLtsfVRo74GHw/LDzUdXP77bnvrcZ5aalbh96jk/LPXN/X6GtPektqGm/UX0snestRfYOvN + Uk9yP61zC6H8pT0JHNvXctRPmfV/Y/3mNT8lOf885wHfX7y+Bq97mJx/nnVC+H5v/lXh/nhy/nnW + +yS8T3L+WWv387fgPEpr/ZTk/LPW4zmTFnvZvmZHa+H6jsn55zlPT9+VGA+Gs/zQ3Pz8DXu/9M2S + 88/++1g/m39V8qmfzb+qXJckOf/s849/V3y98fbMv6ruh0X9o4/jkTbcHN+TP2n8s9dxZ/1s9XEq + 1+X0y+9dLeD83dte49fId41/1u5+2FOP/qu+c4L+hunOkPVm/POsv0X9RNd/Nl6Pt3fbOzhvm5x/ + 9rpkZP8z/lmH70M6gn+WsuFuew95cgn6z+M62WH+lZU/YONh/pXpCZL57Pobg+vDpfvP217TOyw2 + vvN9oX/7k2L+1eDvOBOXfTzIe97EYXzJu9rEzfnM3+kmTgTl5lj/mX/VvV8ee2uVDTfreXG9yAT9 + jc71bZPzz9r5e2iC/vNB5y5BinRwfcIE/Y3uejfaQ4+i1g1XfNz4d82/6jx/NUF/o3O9mwT9DYtD + 5u2J7xsk3iI5/6zNdTA04vmL5g03x5fHtyfnn7Ve9D0+Of+sFo/O5qn5V+3YL15/8Pj7zL8C7rE3 + i2y48tPv8/qDXM8oOf+sjeu9JjyJNq7XkkDtVa7vk+5/qp+rN04RjyRJ24Yr7ofxcTP/qg6ar5FA + XVSuM5FwBFu9WY6Tn77r9cuaxbUo4lVERTcc7kckTiaBfz7EVSXob1QeZ5mgv1GO9pp/VXieV4L+ + Rkm7vbLmwybobxSl8aIJ+huFxyMl559/wqnfo3i/mH91iAtS8M/Wntj9yPSf1/WrUX+Q1ydW8M+Z + 61op+Od00XFT8M+p035R8M+p0fFQ8M+pIgwJ9qaVr1Pwz2nQ+aLgn7PQ+azgn1Oj8WEa9Qfl1M82 + FVKl+5Wi/mDKfh4l35+TprThpr2J7qcK/jkp3dcU/LM9Z7Bxs/WbeB6QRv1Brmuv4J+zxzcp4s2S + rPkL6vzz5MOI/6fgnzPPe1LnnzVz/8VJeVuXJ5wIrrPEXuefDZcee/UqO6782B74Omqv88+HuDkF + /2xxfWSdO/+cOS//wdn9qHhdAN8wb89Rdhz4K3KfmbgcfAnHzfPoaIfdjyy+jsxntftR5fcoBf9c + cT+qsLev+WUK/hl0Hmsvx+9j/Wz3I4vD4zgN/oCsI+efz+3Z/ah6HNnDb7S046Y/Kef24D+fcCm+ + S/Y/558r58M0+Gdev0KDf3ae5rG31LThHr6Orbca9nI77H5UeVyLgn8+1CFX8M/n7/r9yNfbM5/L + ym8o+OdDPKGCf27Hde73o3LGPfayfi5x3+ft5bD3nn/P+OaSNlwJ/oCt37U+O8clQd16/vs0eCS2 + D5l/dahvr+Cfe9r4K/2Kz1Hwz52/6yr4537cn82/ajzeQsE/d67vreCfh572Z/Ovutez0Sf+OdUN + V3w8+Llg/lXjut0K/rnxfHEF/2xxvqyfzb+yecr2A/OvmteveNavrPU0Ffxz4/HeCv75kFeu4J8t + r5yNm4S93M9x/pnrmyn4Z/BwD193lbrhirdH54vzz4e4awX/3DifqOCf62m+OP9s7ZH14fxz8/z9 + mM8yythwxecBHQ/nn9vJn3T+ufE6HAr++RechL/G+rnHe0rF+jX9DRkbDucvvffI41/R+4y4fzXO + 7WngmL39F75OwT836OWGva3IhnvGl6xf558br4ehwT+f7h/OP/dE+T8F/3zgdzX45+x8XfDPNY0N + V3x/obyF88+N6wgr+GfrFzbv3b/Kp/4z/6qd7sngn9Oyfo1/3uwt4T/z+Vdi/fL5V2L9nn7fYy+b + B+5f8boACv65e57Ssz/nlW9X8M+d19lT8M8HPRQF/2w4Nm7OP/N6LAr+uR2/m+J+VOE/3zjZ/Ct5 + 3vcpvwb+mfOsGvwz1/XT4J+53oMG/8zzsfX+pwr4bL8fGR9bZcOV+C6zVyM+h9ursT9T/s9djsp1 + ISZOYjzYOpK474e9c3wl9w0He0meuoJ/PuiMKfjneuJZnX+unL9X8M+V6CbPk8P55yob355S5O8D + VwLH28t+n36zF7jJXxF7gdPA/fN1Dhzir97mveFSvC9Mmq6GvWXHTX6S9DNwk58cp9+XIh7phNMf + vzv5OrIfGM7jc8rOtz/67cDhfYGPm/PPRAcDuCR4h/jn+wFw015StwU4Ef5eYThbv8n3odCrT48+ + IXDg2994fuAQL8p/n4Qe8lt+N3AaODYPbP0az0++6/yzXrjm4z54RX4ZcFOvnryzAzfjgUndSOBm + PD+JDwPuiecn69z550T4HMONsDejnvU0fES8GXAl2iPrSO1+lAivB1wS1GNm/WL3o0TqQAOH9fsW + 3+mRJbZ+Lw8DXuKfd9xcv/XcXvb23uJegUvRHsfN/VnO333iY9l4tHhPUZy/0/BadcPN95TrxrHf + 53+WG8fGze5HrZ3bAz+p1N7nfvRWP96ZcbsvXJ6P89ibyobD/egt3hu4HDjWzzXiN/j4enyOnHG4 + L/Dv2v3o1lXT+/57wd4S7ynA3fZecupnux+NYz/b/cjyFtn+VyL+6tSe+O97y280nPlXw/Ojkvz7 + +GfgivcL7z/zr4accdNekk8CnMZ3ybnl/LPlzTKc+VdjeLx31IfVbf2af8XyYYGbpyHRDQBuxk+S + eEzgNL7L7ZjjS94HDWf+ldXDTTYwZm/UawMO8aKn9ub49nfeDLhpL3mHAA7z+dTetJe8/3qlMbN3 + +HtK2Cuy40q0x85V868sbZrjks/TN54VuGkviXsFTgTxxWR9fMU/F7N35jtfKW+4yeeQPC/g5v5M + 8jSBQzzwWz4JcHhPeXsXAm7am064EfGTM54/+JwhacOVpV9Ye9Pe0zpy/rnnwzwF/0zeU4BDfDud + V84/N1+XT3z7k18G3Bzfox3mXyGNieGe91CyDzn/zHROgAN/xdtrwU/G+E57n/hn4BD/TPcDeDsk + zwG45P3H7XD/iryDASfx+xiuLu+/7Xn/lfp9/3X+uZH4COByjBvZh8A/n/xx55+H+7sMN89fkp/n + SnMRH5sQ7z3tzd/nr/PP/fj7zL867y/uX8lp/3P/6nSPWvhn3s/OPyO/LPI10jafnX8m+efAPfsz + xyX3h7i9Ocb37Z0dOPhXfL/y9/26zOf5vqChfwUc8nHoeen8s72fs/Ew/6qP8+87vS8A9/DtrD1d + 3kPX90H55iedf2bvM8BlwbsQ2zecfyb1k4FDfijlh8A/kzhpwzn/fBkvtdibZcMhv+ztHQy4LNgG + WD/L8l7G5qks7/vMXon9+e2953MiXOCfm+sOxnt3euJzgCvHeWW4LHgH499FfPu7HYbTOM/f9mfD + ydEvuXEp/KsZv5Fhb9K04R5/g9nr70fCzkHDIb79fT8w3ORj67k98Dnvfs6N0+DbC94Xpr2ad9zk + c47f9fwFkj8IXIrvsv7TyId93/8MJz/hPH/B898iPudzg91xiI89tZejX5gdEu8pvP8k8lPe/TXD + zf2K8rsfHOKfPb/xib+6Utpwc3zpOWO4OZ8bO2cMh/x9Op+df2ZxucA98bEMZ/ej6vPviSdc+WfD + leg/Zq/djwrlLQyXBHngZB7oWPK7uR3i6/zdL7lxPfL35/0IAqfai2445B/RebXEP/N+8fgcYXyT + 4XAevfNwhkP8htD5Mu9H6ebl5eNHpCZGBH5OirbhPvam2x+SV3/DcDnaY/0870fp3q9Ov++mQurk + vZm9836Ubnvf+ewbN+9H6eZPb1zqwT8v72WGu+0dP7R323v7ESdcCjvYvK9m72yP9YuVUG7OK7/j + 5v0o9WTDmhDwq2XhYw1329sGux8ZbtpL3z8Md9vLdAyBU59XfH1YyY6rn/aD6V+ly/UUskb8c+4b + 7raX6V8BN+0lcebAJXmmE8Pd9o70rq8C3G0v08c03PSvYtmm0JNJkjbctFcYz2+42157T2H9nMLe + 93cSw6n3H58vlpJ4bk9tPs93q2H2mh5FlQ1321vp+5HhbnsLfYcw3NyvjuNhocOZ6BgCd9tbT36d + 8c8J+RApziNJY8OVwLHfN/2rVE9+rPHPqZz8bOOffZ6ydWRXLuikvuKMf07D36dT1Le6vu8Lxj+n + QeKQgbvtHURHHbjb3kHyu4HTwJH+M/557kNv8XWGG3Ee3d9NUf9o6Nhwxfv5/T5tOOxX73Eehpvr + l8bdGE6jPTIPjH9OjeSRGq7bfE723RTxZj3tuOLn4Ft+LXBzPtf3OjDA4fzl9nazt5xx097K4ptu + nPlX3eu2PPau7/uGm+NL4uaAyz/i5vhWFm9mOKzfU3vi8+CtXozh6jK+3farOZ/rt79h/HOqJD8Z + uBw4Zof7V6S+C3C3vVZPhLcnjnuPb7px5l9l56US8mElf/vPxj+nnN7jn4HLgWPzz/yrROKVgZvn + UT1/97Y3kThzw5l/lbyub5r7/z8m/5w23G2vkrrhwN32anmv5wXcbe8dp/VWRxa4eXRdVs+V4W57 + 1ZfjO878q1v38q77mqZo5T8m/9w23G3v5//54Jgd/r7fzt9NgWPzwKWyJo7NZ5d8KKf2zL+SWQ/3 + Wu395ieNf07a3+vhAjfHN5/Gzfwrre/1eoHTn+aL+Vcpv8crG878K+22rz3zWVLfcCX6hZ0zEvEb + 4/Dd9GN76v3C+8/8K7Pjtb3h/LOv35vW9AWw6D8DN/crUq8XuLlfkbw74OZ+ReqdAKe+D5F72XD+ + ORlP+LqvDeefU/Z6nwn12dP6fmS4eR6R/Cjg5n2hUf9vOP+cKo3fMJz6vYfs48P5Z/dLWL/Y+kVc + c8o+nz8rJm84vIcSf3KAf+6k3hhwiCckfuIA/2zvKdwOEeSDva7zAf4ZeUXxfvQV/2y4ItBbYvPZ + 80Np3LDhHr0C/vue/EGOA19Hcc4/o/7Rw09eRTYc8jXoegP/XFkciuGefEmyvzj/zOoBAYd82Pf4 + iBtn/LPFLSUETs0X5rbh8P5LeIaJy4K4TTIPdCzv+8zeEfFmhB+auBlvRvLeDWf3I3FdiBT8Vd/s + tftR4nzTcP45KY2DMhzOX26H3Y9QP4Dh5nlEdA0M1+I8uvm6FHqqte64eR6R+h/AgX/m/Wz3o8N7 + wAD/nEmdBuDEz0GOs/tRdn2QFHoyVfuGK843kfejAf65kHx24JLzXPTccv6Z6QUBJ97PfN8ocf7e + vNQzviXXDVf8+sTHoyzjy+az3Y9yobzUAP9s32Xzyu5H9t7Dfp/5V3jvecY3S95wxe+XhK8b4J+Z + vg9wKfwhNg/Mv7J5wPrP/KtMdE0NZ/5V8nqLCe/7mtb3wQH+OddzeznWG7Mjxfrl68P8q/LDd8X7 + mc9786+Ql5+QD6uqecNNf5LkhwKXg+di88DuR/Xk3zv/XInuIHCwl/AvA/yz5SPqYq+obrg5ny/K + 143gn+WMS97eW74ucHN808E/df7ZeBWyHzj/nJ23nefv5K8u0Q1X4h5F5ovzz4nUlQYu+XlJ7XX+ + WUnda+DkJ5zxz+o6ho+9o+y44v4B7z/jnxPnvQf453Tyd51/1uuwzp1/TjR+8saZf5X8XTJnxE+2 + KhuuCN6FyL7h/HOZcaWsn82/6krfiQf452u+p3DcTTVkokNluOlf5ex6D7e9ej8AfsU/G67cOM4X + zz+zWLcR/sX+/OAS50Hmn/eWcM97wtfNP29773lw0fk3/SvH3XPxdjWmvev70XD+Od/z+dRett/3 + uUZz3Lw63uZQe2vc9/m69Pf9435l/lX1dZke/Y3SNlxx3oKeg84/M51A4LA/U7/E+efC4xgH+OdC + 409vXI54lXkepeDbU9lwxfmmU3vgnylv4fyznPgwj3+2fCE2bl4Cjr/DDsQ/D7/HR/6RpLzjZr5V + PvBNHv9s12g2bp5fRnTogZtH9YkXcP5Z5z7Jfp/5V1ZvR2bAgvHPUtOGw3sZve87/9zHgc9x/nlU + +n45wD+PTN81Bvjna75XMJzE++98X3js/eZjnX82v53tkw//THkfj3++6sHfBf9M89UMJzEPXudV + R/zz5XWNIl8yfb0fdfDPN2/xnidiuOzrnNwHO/jnwudfB/+cab6L4aa9PP60g3+2uL60xgPXuuGK + 80hkP+iIf+58nXfEP1seEMdBT5XMgx7xz4muox7xz56XsOgh1x0HPXOyn/aIf+70HtUj/pnqZRgO + ernkvtDBP9s9heEk4kXv82P+D5x/7huueJw0OY96xD8X6j/3iH/m99UO/rmQuiPAScRdk/mC+OdV + j9H557Hhisf50vUB/WeaJ2y4J/6ZjAfin7n/0iP+mceFf3Aj8ssy6k0Y/1x2HPQYyXk0ccinI/Fm + E5f8/YPE603co8/A7UA+LP9uDz3VhPzuGR/by46Dv8F/n8U/W71jjoN/9a5XYDjcf0848Xstxxn/ + rF73MCFw/jPQbcMhfoOeH84/F1KnFbh5Hh3ngfHPVgeQje/DP5N4xx78s/ffEy/6xT938M/5OF9q + 3Bd4vxj/3DjP2sE/t3Sy1+5HldS3MlwJvi4j3sz1n8eGm3wd5+97xD/raV+z+1GjefmG02iP46a9 + PJ+kB//suvEJ55Hmlb/q4J8rf9foK/9M+Nge/PM49Yv5V5W/d3fwz43omhrO/SvXDY37r6btPFrf + 91k/p7D39N3k65Kev84/23nE+tn5Z56f14N/LnYve+azat1wiH8m97ce/PPJrwP/TOphAIf4yRMO + 65fPA7sfwT9N0GdQ2cbX70ec5+/gnzO/H3Xwz/m4fu1+ZO95rP/sflR4XlYP/tnXW7wfyVj5ug7+ + OXNetAf/THTFgZv2Ep1y4PTH7/7wPtjBP2fPs17sLXXDgW8/tZedZ6Dj5vyzcH6jg3+WdvCLXX/j + wJd06G9Y3XCLrzN7e+4bbsab1cO+4fyz8jj9Dv7ZdOT475vxV/wdtiP+2fh2Nh7+vl88nv/h21Pf + cMXnPeGRJi77d/k8Nf9KeX7exCG+jsQpTBz8SY4z/0r9/fLh60otG664X8zHrS58Hf/ujFfh7789 + 9DeoTozhHn0GNu9NfwP1OR89irKtX9Pf4DpPhsuBY/tLCb0gPg9Mf+Pi8Ugd+hvX8bs59L7m/fcK + vZGy40qMB1tHrm923HfzovfFxi3HfsXXufNXJ7/O+efLea5nv9LtPPL4Z6q/YbgcONYvHv/M49L6 + Gv/M98kn/pn6a4h/zvv+rNt8Nv9KOM/fwT8Lf+fs0N+4SB0J4J71y/rZ+Ktx4nNcf8PWW334WBFt + G64sONZe/mmdG381jueq8Ve/2DHt5fOqQc+tOC/61Ju41v25Qc+t8PFt0HOrpD4EcElQB4u3h/x9 + ck9p0HOrVFf3g3M9N8S9PvoqV95x0Gcg8c8Nem6Fx8c26LkVvi4b9NwKqasAnAQvyr47Qo9i1iPI + jz/ZN1yJ+F32+8YSH8u/mwT1sth4jLCXxG02+JOHvNQGfzK7ztO0N09/crPX+DrjuV73lwY9N536 + sWweGGXc5/sMs8OuPoXnHTf3JyUVyl819ycl+TtODn3+WseGKzeO63k09ydF+TtOc39SlN+jmvuT + IqRuC3D3Vll5/mBDPIPlv33srYhnKJu9Fs9QB83Pa4hnqJ3GZTTEM9w4klfU3J/M9T6Gqb3V7E33 + 8yabf8XszTeumL3uT+qGK9Yvn+++nqvN/cl8yANq7k9mOe5DrlfAz62GeIZK9SJvXI54s8lPSviT + UjZcifsWGw+PZ+D3nhb5dJ36nS38SZ6n3sKfPLaXlvtvN39jnkdfelAN8QwXv/+28Cf5/ah9xzPw + 9hC/QfywFv6knubLo5fb8J5i9axz2nDF4zxI/FWDntsgdT2AS+4PkffQBn+y8/fVBn/ykE/c4E92 + 36+mEJvVT9nG1/1JWi/BcL/Za/6V/T62H0jox56+K/H7Xs+FingGa6+YvTcu5TU+tkLPrfM85go9 + t07qSgOXHEfiyCr03DqPA63Qc+u0vsaNS6E/2RCPZPVE1vlcEc/QK80rrxHPIOfvJn+XJHHNFfEM + h3lQEc9gdrDv6jKfr2c+J13vR3XNp+P26jK+/Lsp2mPj5uv3OK90GV+G8/ugr8tnfGXVG6mIZ+g8 + j74inmHweO+KeAb7Lm9Pz/tBRTyDfffVH6qIZxgeDxL2LvWsgcP+TO5bFfEMY9BzoSKewXQ/iB0e + z2B6I2Qf8niGM24Ef1W/9NvHysdOHPTbuR12PxpUH9NwKXgBMg90xHw+4R5+kqwjj2cYqKcZ+vx9 + zU+piGe4ON9ZI56B81IVem4Xvy9U6LkNfr+s0HMbVK/5xpnedfc4meCv9Cveu6KeSO/Uz6moJ3Jx + f7einsh1HDenQnj8aUU8w4Gvq4hnEK+rGvHAWnVsOOgz8Hlq8QzC84Qr4hmU6swaDvGxfN8wvv3i + +kM16ok0f+8W2Fty2XB4XyD30Ip6IhfPe6+oJ2K/j42v8+3H/isRL8q/m5fxbYu9qfYNV87+eEU8 + g3C93Ip4Bimn/cXvR/y+X1FP5Bo0vriinsg1/p29ZceVn/o5xX7F532K8SX8aY16IhfNr61RT4Tn + 4daoJyLb/Vd1W79+P+L5khX1RKzeCbNDI/6ZxBlVxDNIonFkNeqJJMrrVfDPw+tChVCrrnrXhvsh + nrCCf7a4L2aH+VdWF4r1i/tX8sd0JSviGYTnM1Xwz6MbX6fq9n7HM1Twz/3Uf6hnfeoX55/BEzKc + zl/zx/K8qvPPcnEdwwr+WXwd/bV7cG57e00b7rZX2mG/d/5Z+D2+Ov8sl9K8hOr8s7ROdXaq889y + 61Fc9PdN/0ruvLY7j2raa/VEythwxfniwdYR4hl43FJFPIOQ+snAaZz7bHx77Fck3rvef1b365rX + 87J8jc2/khb1reh9VVrsV3zcHv+K5IdOHO4LRC9o4iRw7PfV2J8vr2/l+YO5bzjYe9HvPvEMF7XD + 4xkGzZ+piGe4eD5iRTyD4di8L3E/6vd+NcT1oIrohsN7KO/nEvcjwrfXqCdST/aWuC+c2pOfcE+9 + tu78htmbZceVsIP4L4hnUJrPWaOe9XH+OX91UZ2xGvVE9NR/nk+XzI5nfJPsOIwveU+pyKcb6TSv + 0mIvm/cp+MmTHeBz+PzTqJ/yPZ/XeriGKwuOtTf5K66/VsE/m+4lGzfXg7rOOHGekO9/rgflefT/ + rJ41cKg3Qd6FKvjnVs7fhX9FeS7nnxvn0Sv4ZwtPeB2PEvWsL+dj8R6avuKRStSzpnWlDTffuzk/ + XsA/N1pP2HAauNd5WtZ6IiTfuUQ9kQs0DvKt0sq3l6gnwu+r5Zt/ZnZ4Ph3Xjy3gn9s44yS+y/pZ + F3vzYq+u94UC/rlxPdUS/PMP302Be533JfjnY/+t9ehZv0jUm4h6QMY/r/xGAf980I8t4J8rf98q + 4J8Nx+aprd/aT/3i65e/HxXwz9BNjvic73y6Av65cb64gH8+6NeV0HPj+b8l9Nx4vFkJPTf+bnoT + 7FGfrv4jJs48uceGK94euQdMXP7JjhHr94TDexnhQSYO5y//fT3ej6xsysM/64Yr/p/57zP+eXBd + pgL++RB/WoJ/5nmVBfzzxXWoCvjny+MFHv26tr6XFfDPF49TKMinszhVjoOe6gmH/METTjxvguNq + 6NdNex99s7rjnvwFti5r6OeQd4MC/jnLGaeRh8HWZV3yU9jvs3y64t9d7N32K9e7Pn7X8ukSz2sr + oef2Q3saeTscJ4Fj6y1HvuS099E3q2XDlQXH2ss/4qa9PI62rHpufD9wPTeuB1CQT4f8qMfer3jv + 8q3nxn6f67kd7fB8Oq6XW5BPl3neXUE+XeZ5hgX5dOla9L7m+Svb+GrEXxG+riCfznDMDsunS/zd + oIB/1pMf6/l02g/+s+fTQcfreS+T0jZcifbY75OIN+P9IpF/RPIqC/Lp9NjPEvqitD3Pp1OMbwp9 + s1V/oyCfTnl+aEE+3bFfoOf2Aw72Uv8Uem7j4O9Cz+3y+guK+36vuuEwvuS+WpBPJ/z+WxD/bPwk + /30a/BrZr5BPp5QvKYh/Nh4zL/xG//Y3PP75wMMVxD/f/tUJh/i6E06Dl2L2+vs+10Er9594Txke + b2b8c/u+/4q/71+m48/ae+xl86BFPBLhbScO8YQn3PSf8wlXg78aHk9o9pZt/da47xP+uYB/7uXU + LzXs5eNb4/57wkF/g/CdBfxzzzbvJ99u/PO3f4V61pnysSXqWVfK1xXwz2Yvb0+j/zhOfP7xde78 + M46hiI/Na/5CCf65U96sgH++TnwT8ul4vZMSem68TlKJ+Ofjd1Poe1fk01k88Po+WCKf7nTue/yz + cv3Tgny6pKfzyPyr43mO+Odx4DeQTwc+Z2D9apINV+L8YPNKI7+Mzz/nr8rp/NB4X+Dnm7/v1wO/ + 4Xpu4jpPNjj/mJ5y2XCwl4+b+Vepn/wc869KPdkr5rLNejFs/7OS1jf9Q+IKMvhndV705q/U7E26 + 4fC+T95JctSz5udWjvhnofMgB//M50sO/nnQ948c/LO/w8796salr/icHPzzoPHAGfxz43G0OeKf + eV2yHPHPfF7l4J85f58j/jlt8bFJ1/jJHPHPfP/LwT/zOLe8xj+T+0xe45/J+sgR/8x1iTP45+76 + KsFPfnZ23XAl2mP2Suj1kX0jg3/uPL8xg3/uPC8mR/xzOuCcf+5+L3v4yavohkO+Brmf54h/5vGi + OeKfeXxdBv9s8ayv52AG/9x5Pfr7ghDxGxn3Xydm04Z78tnJ+Krfj3j+4MTN+yDXnZk4laNey8RN + fpLnO2fUEzGe8PqL+nSfiV03XBHo+JN15PVEMtcdzNBzy9x/ydBzy7xeZYaem7XH5kuLehMN9TVm + PH/TsuHA15H7dF7ridD9dKknQt5rc9QT4e/EOfTcEs0TyaHn1vxZsPh9QWvZcSVw5Jxx/jnze3wO + /rnQuKW81hMh948c/HM64Z56i93riZi9pey44vPg1F6O77J+efjnEw58O/U3wD8f+yW/2Juqbjjo + QZ3ay4FjduRYv9Qfcv75FzvwvkD80wz+uSSEMcDer3ptOfjni8bJ5OCff8CBfz79Pg0cWx8pxpfP + A416QN33Z7f3279y/vk8n41/zryOYgb/nHn8UI561j+0J7E+GM7uR0XNjsdeWe+DGfyz4dj8k9iv + +HhI7Fd8PIx/znrqF4n3BTpfnH9Ow3if29+w+++Vx4YrC461h/dBaq/zz6lS3jGDf04X5f8y+Ocz + zvjnhPqhGfaOXDfcb/Z6PZFEeb0c9UT03B74DcLXZdQT0dO88noihksr377Z25d6qby9LMd6qTn0 + 3MphvXn886Fuboaem1w0Hi7ff057PQ4vCuhKyzuuRHtkvUmL/BTCI01cCl6Pt6dnnnDiJHDM3hrv + Cw36SKY3UuqGg94XecfJ4J/HyZ90/vnicVo59Nx4Xm8OPTeeV54j/tlxDx9b0thwj728vew4yoMg + /vnEgyD++Qc7ML58/jn/7HnWHph+8895xxVB/DgbD+efeX2IHPxzOfjZ4J85P5kR/3zgT3Pobwwf + 35jPKe+4J3+B9fNTz5ree8A/83fODP7Z3u15exL3UIbTOH/v9TbPX6vvXMeGK35e8v7TOH9PuGlv + Oe2n5l+l070H9ax5HegM/jl5fk/4zyJrfbrs/POM8+DflcWfZPNUFn+SzVOJ+I2THT/4k3fBwYhX + ucfjqXecV/32iYOeORm3ics+/0i/TBzir4i9Ca5n4v5GQhem62RvWvxJ46+mHtTnL2PDFf99RL8p + oZ71zOij9sb70cede12/CfWs7d2A9UvUA1KSP5hQz/qmTaZe/QzS/cfOPyfnn9295u3lGA/WL34/ + 4nFpyfnnuc7JeZ7AP1/83SUF/9yXeIZZCEnKjkO+Btl308o/E14+Bf/M8+lS8M+N+mEJ/HPncVAp + +GeP93kegq+1XmoK/jlR/j6t+huEL07BP/M4shT6G4XGXafQ3+D6FveD0VLPqy16FCO3DQc9Cm7v + iPoa5H1h4qB/Rd4XJu7RU+XtzS2f6+omxD9fbdGPtcBvLRuuxLix39eX9wWy3qC/8UN7uB9xe72e + CM+PT+CfxfXg5/vCHN+25g8m8M96/H3GPyuvj5PAPyvXL04R/8zfU1LEP3OdjhTxz67b7QfnfShV + 3XDlx/YefW/2+2rwG3z91jh/+bw3/vnw/pGCf0Z92Ir3hbzGx6bgn7neawr+meuGJvDPh/qNKepZ + c12XFPWsefxLAv9cPG/seU/J3+cv6lnzuloJ/HPh78Qp6okc97+1ngjrP/OvrK4HG48U9WIa6uPc + OP3KL0tRT4Tfa1PUE+ln3G1v5Xx7inoi4+DHop7IoPePFPVEmt1X13rWuuFK/D7Wz15PhL8HpLWe + NeFjU9SzHvS+kMA/Nz34z84/V8+Pv8fX+eey40p8l+0bXs+ax4sm8M+V888J/HPlvHcC/1z4+0IC + /1yc54/xla/8sgT+uZzmqfPPhccDJ/DPZdD3ywT+uXA+J4F/Pu4vSz2RGbaB/UqGtg1XFhxr79mv + yL7r/LO1R8bN+eecD+eM88/Gb7Dx7fHeXf/hB+y0t32fR84/Z65/lcA/53Hwd51/zjxOP4F/tvdu + 1s897r/kPT7df9YF5xfc217pGw75Gny+PPVETjj4G3yemn+VxhkncW9k68PriXh7c3ynvV/1RJLz + zzOvg/Bryflnr3fM7HV9s9P55vWs8R7AcBLtsXll/pWq9cu8LxgfW9uGg54b72fzr+Q4bp4CfNyv + PJWF84QJ+s/C4woS9J9F7Vx9+OcvfbME/Wdrj41bjnzJ03envXKyw/nno73OP5fTd1Pkh875HOOb + SttwD//M5lVa4r35d5GfQvkI1BPh8XUp4p953GEC/6yucxf5ZaJZN9xcv/ngnzr/rFzXL4F/Vl5P + JIF/Vl6HLYF/Vq7HmMA/a1r0CS2Qo+YNV2K98fawfnm/mH8lJ//e+Wdrj42bLOP72s8K/llcLyPy + NdLX+lXwz8J1PxT8s+0vr/NewT8L57MVIQ0Xj1tSUPODv3ffAptLvsZY9K4/ntaGg941uQdM3KOH + /Dr/Ji75d/l4rPrPr/NKMRUOuuca8c+uW7HqP/cN98S3s+8++hvkfVAR/9z4PU8R/2x6Mq/zWcE/ + N84XK/jn5uMRehTf9awV/HPj+aYK/rnx9abgnw+6FQr+uXGdXgX/bDgy76G/gXjvqKd55bzhHv0N + Mh766BMS/kpDf4PXM9TQ3+D1FzTinwfVK7gTcOJ9oSB/weKfv9evjtAHJrzoxGX/7gmXfB1xO1b9 + Z94e1i+pX6ah/+z6ovMvU2+zb/b2iGcg9Tp05Z+Jrqmu+hskf0ahv3FxPUsF/yyzPg6Z9+Cfp75o + M39j1u9u3+sX+huzTjWzt0V8O6nfo8E/f+wgdcg14p/zGYf4Oo7z+Odkv88LrsgW/6wR/8zrbWvE + P/M6RAr+2ep8k/3K+efaz+2Bn+S/z+tZO84Lat98+/rereCfezt91+tZX+fvJufXSF1zjXrWx3lv + 96PG65or+Od2LfW7536V1vgNBf9s3cH2e69n3aiOsIJ/ruO0vxj/3Liuiwb/zHXeNfhnf9+Kerj6 + 8aQ3HPhJ8h6lK/9Mz0vwzzxfSCP+mb8vKPjnwu8fCv4Zdd0ee7/0NxT88y/tga+jfoTzz4XX+Vbw + z4XriGjEP3P9CAX/nDzf6nkv+4p/VvDP0CVh7WXf/6gf5vxz4u/YCv75kCes4J8Tv6/qt/7GsPPI + 9Tf6hnv0KIi90N/g9T809Dc4f6Whv8H5Og39jXxqbyzxsSu/MdZ8OgX/LKf7EfQ3eJyWRj1rpfyQ + Qn/j4nG+Cv5Z5GRvX/grWeIJex4b7of8boX+xsV1KhX6G4e4YYX+xsX1+jT0n8dpPru+mev2PPXL + 2ja+LeqX0f1Anvhnus6lBV9H9zXx+hq83sTEifOsdJ07/5ycH4r8QampbDjEm9H92fnnzPNmFfxz + Pt3zwD+3c3vivBRvr8T6vXGxAOTrfV+Df+6H+6XHPx/qL2jUs+a8nkY960TzKjXqWWcap6WIf4YO + wbN+81qvTSP+mcfL6xr/zPdnj3/W0zp/+GfKW4B/Pv6+tNi78JOSsmw41Nfg333qD1K+DvWsM31f + 0OCf+TuYgn823Q/2XeefO2RyQ2/k+z4I/rmc7HX+meuQavDPx/X28M8n3KNfx/ZJifzBgveyuX4l + 7bhHz43tG7LYy+aV+1cnHsT5Z+X6fwr+Wbl/L+CftXr8lTzxz3XDlRiP13GT4J+5HyvBPwudzxL8 + M6/7IME/83wwCf65WR5a6H19PNu+4Safc1E+W8A/Dx5fIsE/c70lWflnEociK/9MePl7xEKPon/V + l9Sy46B/dWoP+ip83Jx/5nlFgitD5fukYOo3HocswT/v+s+fE0A3XInvsvGVRV+FzT8xewu9f0jw + z/z9XIJ/5voCsvLPDfXZvf5g23AlcMQO8M8/4FLMAzIe0N/g/qRE/LOecE/8c4W/4fUH04bD+iV+ + 08ShngjxnycO+YMnHPwNst9PnPyE60s9r7UeX887Dv4V7z+/H3FeQCL++aL+uCD+Wfg5KFF/MJ3a + ay/x/C21DffoXZN9w+sPDs4zCOoPjmP/WX6ozRc2bpYfevG4UnH+2edzXvTM65q/IM4/e71P1n81 + 9Bj5vHd9wnEatxp6jHy+1DiPOK7Ee0p1f8Ps/bofCeoPDs4TCuoPDh6PLlF/8If21PkI3n9r/UFy + vqH+oOtVPXq5eduvcvjPfD7nyGfn8/mpz35qD/FXJzsQf8XHN0W8Wf2K50/SNxzyJfl4pMiX5OPh + +WU//D4Nv52t3xT67bw9Df32Cn3vaa+KbrgS/Cmz98kvO3334WPZ/qIRT8jtffJD+Xxx/tnreiz6 + zylvOORr8Hn66D9zf0OW+czb0x9x0Geg/gv4Z68r89wHv/TNJPhn/h4gwT+f/CHwz5wPk+Cfhb67 + SPDPp30N/LPPqyferNcd9+iLMnvHch/k303RHpn30N/g8c8S+hv51M99Gd+28Btd84b7Qc9cQn+j + Ut5MEP+ceD0bCf2N63Cv8Phne9dg9ra470Pf2+O913j+icN8Ju8aE5d//C7mM7e3LfwVxz38FVu/ + Nc7fBn/D9DdkbLgSONbPT31nbq+XpO+neVAXfpLZWyP/l+O8vrO399hbNnuf+s6n9nKMG7PX3vcP + 72qC+OcD7yiIf1YevyuIf0bc68o/1w33Q3y7RPzz6d7t/PO46PuWBP+cTuvo4a84Li31JU0P2eOf + RTYc/GfyXiZRf5DHCQrinwd/fxPUHxyF5h8J6g+OfOCbvP6g1UfsS3y7buevRn43/30a9SXJ+6VA + /3nweHkJ/WeudyjQfx78/Vecf3ac11uc+lfyff81/tnrB7D5LBFfR3lR459dN4DZK3EfpPykyA/8 + 5E0irfrt7SX+2XAl5tXb+jDcM585Lvm6fB83w2ngeHsSuLd+uXHP+h2oh2v2LvcFwz31Jt72P8NB + H+mESz7v3/lsw2nMK46b43sxPvvGafA5sz5s8O2y1F8wHPicU3uYz+/7i+FS4Ni4afDtp+9Cj4Lj + ZLG3LXz7Wn/QcDM+Vk+/z9cvzccx3LSXviM6aSuP/jjDTXupDtVN7rr+hmzvC1/1Bw33xLeT7zr/ + jPcKhsN+9f4OYbhHb4TMF/DP1D+9cc4/6/Le7YUnZMMVn3/v/obh8o/fTb7O3/0hw+H8ffdfDCeL + He+4J/75/m7UD/2MUNtw0Pd+v3cbDva+xx8YLh35U8Opn5cnnMR3yTpy/tnsGH8L/1xkwz16Muy7 + a3wO2TfAP/+Ag73v933DSbT35m/cuBrvoQXxdZOPLVU23KOvwtZRjfoap+8+48vms+sTXid7a8Sr + 8PEokT9Yv9ZvXuqnGK4Ejq3fpz77CZd+bA/5Vu/8huGe9yNmr8fnOE+92Ks77tELYt/1+Jx2Wkfu + X9F6zIZDfN0JJ9Eem38en+N8YsRfaUpjwz3xOWz+PfE57zyD4ZLH5/B9LUV83TsvYLjnfYG1p8v7 + wlIPSFXahkO+JB9fjXwNPh6eckXv04Y78zmGO9/37TB/7vt94euuOjbcEw/M28vxXsHsdf6Z5hm6 + sxF8HVuXT3wOxUH/2f2Dxd7SN1yJ9sjvA//cDvPqq/4gWefgn0/7EPhnWofoxo3l/ags/GT/Hl/w + z+Nkx1j4OjIPnH+2+UfWJfhnGndoOIn1wXA96nk15FuZvWXHPfnOrP96rN8TLkW/8N+H9wXef55f + RvV3b5znl/07frJl3XBPvjNZl9IWvo7NA4+qofyV4fD+y+eB8c+GY+utLnq5aRnfmnZc+bG9HO2x + 8XX/isYtGe45f9m41eA36D4pj3/VoIds/LOWDVfi9zF7yxIPzOx1/0oP97wl/pnPlxL28vmXl/G9 + lvmck2y4J/6Z/b4ceozvPKHhkvcLvU87/zyojrrhHv0N1l4Kf3Lnn/uGe/Su2XdT+M+UZwD/TOvF + GO7hn9m+ZvxV6wceyfnn5r8v+A1Z88sMN+PrqK6z4XK0x36f81ftwIOAf5YDP+T8c6e6YEaCVLdj + 8pOPvbLjpr0nfg38sxx4UeefG9V1dpImvsvbk/PvG+CfW0GZJ/B1eT2PBvjnRusgGC47jvTzAP9s + enOv83mAf+Y6fIaTaO91Xg3wzzGfw9602ZvCXv5dW7+V1oE23G1v5feeAf65Ur0vw932VqrrcuNs + /RbPH9QKPYo1/tlwt72F+8UD/DPXvTTcbW+h+jSG0/h9bNxs/VbONw3wz9C9nPZa/cG842b8M63D + Zrjs3yX8ywD/XGn8leHm+NJ4LsPJL7/P+efqeSJh7+ckkw037aV1BQ2H9Uvt1VV/g7envi5POPHt + h+OMf7a8bauX+uf6GzuuRHus/4x/rhfLZzdc8v5717cwHOx916M1HM7fdx2MG2f88z0ed3thkPac + NhzOo8zmlfPPlufPv5sCx/rP+GfD8e8+9pL9b4l/zl6/2+xtWTYc3lPe9QoMh3h+Ph5tGV/WLy3O + Iz4PWsxn/t0a51GGfzXtrUU33LS3nL7r9dnradxqvO+/60cYDnw7H7ca7ykcVyL/N+G+MO0tS/yk + 4cBPvuu6GA56fafvJufv3/U3DKd+nznhkN/9ridz43LEIyXUi5n2ZpUN9+jnMDue/FA+T/1+dNxf + ctjL59WTH8rns9dnL/ZdD8y8+WfZcSVwbN9w/jmd7Hj4Z76PP/wz3zdS3H/5/Hvic+75Mtfv1JNR + 2XHF19G7Tozh8P57wiXfN0449X33XcfGcOL7WqLzT8LfuHV7FHpBcq3xKsP55x++6/5VPn83BY7N + P/ev6hknvt9TnLh/Ne1oz4Eo16LfbrgSON5edv+Ujps8/tUJp4Hj35XAkfVm/PM0M+H+O+3ti36s + 4aa9chg345+1lDNu2nud7BjLfGb9MuL+m9g6N/7Z15vF58z9SrrohkO8Ct0PXH/DdKP4d5/1y3Hz + /D35Ya6/Mai+mf2J9+6pb4bzV1pKGw58HfUPpC37M5tXLfh2er5JC7791J6Ef8DsrcHHJugDT3tL + TRsO+ZJ8XtV4/+XzoMb7L7fD+Wc94/C+T883efyrDP2NOu3dxreEngw9z8E/l/N3Ec/wrvdlOHU/ + 7PTdx59k68P8q+73t9Bj/Ko/aDjoMfLflyO+7vTdyU/SuiOGQ74z77+83BfYektx/t44rbA3rfFm + A/xzPfk5zj/XevCvnH+up/ul88/2XbbOU/AbHKfBxyaM71y/mvuGK7FPst/n/lU67afmX9V+xqnz + ZnwfN/+qHPdn96/8vNTs45vytl+Zf1Wu03lu/lU+3fedf05ymqfmX+XjvDf/KvP9qoN/xu+bf5n1 + +HLZcbe9etHx7eCfE7+XdfDPqdH+6+CfE/ebOvhnTdTf7eCf73vPrcup4gd7Sjo2XLm9zET9pu78 + s9g5yL+b/Lsn3LS3n+y19avX6ffZ+rXxkGV8P5/YcHN8x+n32fo1HBtfXex9nacd/LPd41/PhQ5J + mYuv8+78s1yuL/qMr5Sx4e7xHcf5N9evNH4v82CGz9+ve14xO+b6lZrPOJle0o0j/Wz8s5Q5n+/H + Awz0VfKGu+2919t7fUnD3fbe8SXvdTINd3dNrWfcvOpNe1/9uo4nM9PfJf2i834k6usyh37syHnD + FbeDjq/O+5Hbwb877S1n3H2lvt9dTrj7aMC6fMfN+1HGfpWDz2lr/kJ3/jlrO3133o+ynvYXTP16 + WG/GP2e7L5D1Yfxz1kLPwe78c07Z/KbZQfN94Sv+uTv/nFUP55vxz7NfyHnZnX+ev4/ct7rzz1mp + 3rXhJPqZtTfvR7O9m//LCnu/4nO688/ez8zeeT/Kwv3Y7vxzFu4Xd+g/X1RX3HC3CzM4n9ih/zyg + hxx8bNnG1/QJ7f7Bvmv8s+HYvHL95+uMu+1t9WzHbW/lPHCH/kb1fknxfpQ3e3PUL+PzxesP6uGc + Rv1Bqp9tuNte48M4btp78jecf27On6Yr+NhF/8pwU9/7uO+mmM/83DL++Uqn/dT453E8Fyz+eXAe + syP+eXTzh575rGt+Skf88+B8Z3f+OQvVKTfctPc4bhb/PKjOu+Ek+o/hLP7Z/LB7AHEfvNb7UUf8 + 8+XnFmsvRz+zeSVmbzn/PvV9iPqnHv98eM/riH/uft8P/Xa58o6b+u35sO96/LO9n5N56vHP9i7O + 21OBzjuZLx7/fHgX74h/bn7OzHoEc3zH93z2+Od62k89/rmezg+Pf278nbMj/rmdzhmPfza+mMwD + j3/uPq+mv2F8bO0broQ/xNu712/i71bd+eecf8DdSySf7kfGP+fE3wf7/Wf133eP72LvNr4t/EnC + X03c3K/6GYf9+fT7pr8hh3NQLP550PofN870N3q1ffJZv2v9QcM99SbYd01/4zz/6rJ++e/TWG9s + fM2/ap3V27lx5l8115lNyB/83BB3XHF/6F23zHA5cGx8zb8yepCNr/lX0BNkOPFzn8SFd+hv9OL6 + SKhvJfn7Puj6G5aHy/YX8686j0fvqD/YeP5Hd/45WZ0pjhP/Lv995l9ZPuw1/2L6DEnKhivRHpvP + KfxnEmfZof/cZ/wp6xfzr+7vXvR8M/+qVab3cOO8vrPrOKQMe1XrhkN9DaIb0KH/XPRkh+ubuU4v + w03XpNG43A79Z2k0LreDf75cNyVNf+a2V8qOe/RzmL0S+pMkDrSH/sZF4x17xD8XphNtOLx3/3v/ + 5f8HsV2v9FHtAwA= + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['43331'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:43 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 15:11:33 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_dart b/siphon/tests/fixtures/ndbc_realtime_dart new file mode 100644 index 000000000..d4a36d3a5 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_dart @@ -0,0 +1,362 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/41421.dart + response: + body: + string: !!binary | + H4sIAAAAAAAAA33dva7lsNad6dxXUYDjNkhRIqncjXYHzpw478DJ1w3Yke/eZ7l6n6PxzK1V2Kjk + hTSXKHJy8Ecc//6//tc/f/7zf/7zH//jn//23/7827/9+R//489/+fPnz3/6P//v/+s//Zd/9+// + 53//8+ff/r8//8///PPf/vuff/t///z5H3/+jz///79/+3dH6/tP+8df/9OPP619/vqfa7f5H+52 + BO5/zuuB9xaP59V7nuAeV58XOGLvYwVuxG43OGKve4Aj9lpeHbHXDNzujL1mB2fsa4Az9tXAGfuK + Qv3H/xn7muCMPS8wz73B7UuptUWZ9wbO9z3E+b6vDs73vTL2JPa9wRH7Pjo4Yt+nV2c9J/aVse/7 + Bj9ir//Qjgl+xP4H5rmvZ+x/4JVXn8/Y/8DEPjN27xscsftY4IjdqWsjY/c5wRl7XeCMTV0bxM4m + 2A5irwUm9gnu33754XPn++7EptQ6salrnfd9ezXvO395431TW5p17QJnPSc2ee3+Z177R9Ptf45B + PT9PcLaxf9a1H5zt++7gbN9zBD5o32cDZ24h9kFeu09w5rV1BO7m1AucOXXc4Ix9bHDGPvLB6MdW + H+CM3Tu4f786Y/f1xN1+7BhgnnuCX/qxH0wfGq+k24/tAc733S5w1rVDnHXtjFfS7cemOGPfBzjb + GIVKP3Znben0Y/fs4Gxju4Fp3xucuaVnmV/kluMGZ245B5h+zJtn7Jm/3H5sTnDGngucsalMp7Gz + UIc59QDz3F6dsY8Fpsyz1A61wwR/fd/ktfu6wVnXMmmqz62p6nMqk/p8XeBsY1feXH0+NvhbPlef + 73aAM7fsKNSiz1cHo89vcOa1U5yxz/hpRZ9n8y/6PN9Y0edZFYs+vxKvt3HJD87Y+ULV5+v26nzf + PX+5+nwc4HzfmTzU53stcNbzlj9NfZ4tNPX5pxGd4Gxj2QSLPm95c/PaGODMLZdXZ27ZXp06NXvB + os+z/y76nKqoPr+8ecaeiYs+P8AvY4MfzNhggjP2yleiPuenqc+vAWZMNMEZO5Nm0eeZz4s+J/U0 + 3vfpzbOuPbViq/p832DquTjr+VOntqrP77xafb4aONv3Myu2os/3s5NsVZ/v/Gnq8znA7zm1/aLP + xRn7mVta0eeTn0Y/NtcJjtiTUqMfm09R1Io+n8963oo+r1cT+wRn7J1X04/Ne4EZlxxgytyb04cm + Lv3YBR5faov6/F8zgz846/nIYrEfy0akPt+7g7ONtQOc/dgRFbnbj2Uj6vZjU5yx1wRn7Dtj24+1 + C5x5jfdtP3aIyWsZW31eMHMeHZyx+wWm/85i+abP2y/6fICzzOcCZ5lf+cvV51RF8trNg6nPaaHq + c6qD+vwa4PGtlTTz+QXO9n1HC636XMwc9glGI3t1xh5RLEWfZ2Yq+rx7NfMt4ozd8+bmtWwlRZ9n + B130eXZz6vOVL1R9vrInUp+v26t53wtMTo2kqT7fvFDy2r4bmPmWDc42RnU4aWPZDIo+z4Rd9Pnh + zTO3zPzl5rV9glOntg1OnXrc4NSp2YcWfT47GH0+wBl7H+CMndqh6POCMzY3V5+vC5yxqUzoc4sF + fd55oY3YTZzve//rpx03+vxTHQ5w1rXh1VnXHrH/4qznjyHyB9uPPWYt/mL6kg1+nbv/i7N9PwT4 + B7sOPA5wtu92gV/WJH8wee0M7Pz5GGDyuTg18r3AaOS4uujzJUafL3DGnl7dvl2tPn/k87+YcYlX + 89wdnGWeb6zo86OBs8zHDWbdYIMz9s6bq8/bAGddO24wa9AnGM2UpWY/dt/gbGPHAWYN+gJn++Z9 + 249RFUs/1sBo5BOMPs+fZl4bJ5i8tsHMeTRwxj6z1OjHKib2ANN/X+CMTbF0x0QdzNhgghkb3OB8 + 31fevDk2GGDy+QEmn59g6nlg9TmtRH2+sx9Tn+/satTnz6n9Dy7rghucuSVbaNHnWeZFn88o86LP + MzMVfX7dYGIPcMZeGbvo8xuMPj/AzHlscJb5kdi8dk5wvm8K9bKuXeCs50c+t3ktdUvq85yc/4vJ + aweY3JKvxLzGKzGv8WBFn3vzV33+wUWfLzAa+QJn7OyJ1OdHzwcjrx20UPT5kf2Y+vzgudHnR4oD + 9fnBG0OfH03MuOQGZ5k/FiWOXfT5c2HgL84yHw3M2MCrs649M9NGn38WghqY+bUNZo1qgulLzsDO + Mx0DzPj7AGf7nuLMLSNvXvZpXmDmcjsYrTjBmVNHPHfZ39IHODXysxHtqs/vBk59nr+86vMNftfn + u+rzcnNi583px+Ytfp27/4tf5+7/4izzMwvVfixri/qc9130efPm9GNRmYo+P29w1vM1wO+aaVd9 + 3vPmpR/rYObuB5j27dUZ+87aYj/WTzDz5wOcfejw6nd9vn/R5wucsc8JZmxwgomdTVB9Pjr4dd3g + L36fb9lVn99ZaupzGrD6/Nrg/q22kNfu/OXq8+cq01/8ukb1F5PPBzjbWLZv9TlNUH2+2wS/7tP8 + izO37MTq83WBWTfYYPT5AmfsGe276vMDzLhkgzP2XuCMnQm76PN+gRmPNTBzHuJ83ysxeW3fEzy+ + 1VTz2rnBWc+zERV9TmUq8w4nmD2DHZy5JfvQos+zkyz6fEww+88bGJ2az+38eQqyos9TUhV9nqqn + 6POev7zo8wXO2NwcfX40r87nfiquVfX5s5Wsqs+f7XtVfX5684x95M19389CXVWfrw1++cbjB2dd + e46oVtXndwe/9yWr6PObB1Of34nV51NMbtng170WfzH5fDxx0edPdb9+2X9+gFmLPcGpkfO5iz7f + Fxh9foJf9/X8xRk7C7Xoc65e32MvxwYHmOfOMrcfaxPMGnQHv+5P/YvpQ/PB6MdC/K+qz7MJFn0+ + vHnW8yuLxX5sTTBj4BtMG+vg7MfO/Gnu27tucLZvfpr79jI71P0tWVvU532C0cgXmLFBB2fskXWt + 6HMxsW8wc/cTnLF7tjH3aVIs6nMKVX2+vHm+76znRZ9nK1GfU5nU53cb4KznmbiKPs/UU/R5dlTq + 851vTH2+j3xuv6vJBlz0+X2C0cjizC3ZA1d9foLR5we4f7/6a+yS1xaY5xazXtLBlHm0kqLPzw1+ + n7tfRZ+Hul9Vn6duaeV7wRtMXrvAjL87GM2UD1bmU8WZW6hM6vPULUWfj7xafX6J2VsjZu6+g1Of + tyzzb/Pn6xd9foOZu/fqjP3MTLPo8xgbzKLPY9VhFn0eDzarPn+Ox2bV50/NNIs+75eYtRpvnrFb + /nL7sbXAzHHdYNaoxNnGdt7ceaanRp5Fn988mPr8vsGZW2ZcrT4P8T+LPt/5vos+3xOMVhyBXQc+ + DzA6dYIZGzRwxm6Jy/z5AU59njW16vMJRp9n7GnsC5zP3Qb4fUw0qz4/8ub2Y2cHM7/WwPShNzjr + Wraxos+PA5x17Rxg5jQXOGNT5vZjlJr92Bjg1GvXAc72nYmr7D/P5l/0OaWmPu8XmD408Td9Pqs+ + HwvM2GCDMzZYfT4OMGODCea5vXnGbnF10efZvos+X17N+97gfN9nvG/1+Z1drPr8zvZd9HnWlqLP + s64VfX5dYNpYB2fsY4Ezds9SK/v2xGjkG8y6wQBnXsv2XfQ57/ubPp9Vn7cLzHNH8ij6PCty0efU + FvPatcC876yK5rVMHkWfZ3Zo5rWUNa3ktXww9Tmxy769BmY+1Ztn+975QtXn1LVyfssGp1a8Oji1 + YnY16vO+T3DGvjcYjSxOff5sY1fV58/cclV9/uxir6rPnzr1Kvr8eNbzq+jzWJS4qj6/DzB7/ic4 + y/zZDK6iz/sQZ+x+gbOuPZPHhT5nU/+FPqcPvdDnTENdRZ/fS0xfEr9cfX5ndSj6fIv7a29wFX0e + 6f4q+ny3Bma+ZYLZ1zPAmc9HFEvZf54vtOxvaQP8vvf9qvp859Xq83WDmbsXv8/dX0Wfx8jiKvo8 + ljSuqs97A7OvZ4CzzM8sFvqx2Bt7FX2+eG77MWqL/VimHvX55qfRj8WGhqvo89BMV9XnLR9MfT46 + mLW5A0z79uqMTVUs+88XGI3cwMyfezX6PBtRyWsLzJxHB7/v+b+qPs/Yqc+Z+rvQ50yoXOhz9vVc + VZ/fkZmKPs/mX/T59GrGBg2csbOzUJ/f2cUWfX7fYOq5V2cbm3l1+e59gN/HBlfdfz4OMH1J/rSy + v2WB3+eZrl/0+QZn7JbPrT7vA8z3RA38viZ5VX2ezUB9Ht9ZXEWf70we6vN9e/Osa9kbtJLXBpi8 + tsDsVzzA2b5btpIy79DA2b4zp6rP27rAqRWzqyn6PHvBos9PMft6DnDGfqqes+5veb6xs+rz5wT5 + +cv8+Q1Gn1+B1efP3HIWfV7x+76es+rz56jmrPp8X2DWSxqY8dgAZ+yRv9z3/UweZ9Xne4Lf95Cd + 6HN2oJ3o8zxT4y9mnmmB3/fOnUWf30eUWtHn9wFGM51g8toEt9eMfFZ9nu+76PM5wOwx8erUqUeW + muvAvYHfxwZn1edZkYs+v/OnFX1+gsf3q/O5Wwfnc1Pm6vNjgNlLdYIZjzVwxp5Z5sP3PcDs6znB + zCuK6UOz1DyXaooZA4uzjVFb1OcjG5H79q4ORitu8Hsfev6y/zybYNnfssDvGvms+vy4wOS1KJai + z0cHv8/tnVWfHxOcsTOvpT7ni78TfZ7nefzF7KUSZ5ln/130efYG6vPn8cl/MXvINhi9lj+tnH8+ + wdRzr2Z9bIOzjV1RHer3oQPMHlHxt/Zd58+jIld9foLfxwZn1ecFEztLTX3eJ5ixwQC/j4nOos83 + taXktQ5mbHCDGRtsMHUtrzavnQ38/i3TiT7/5LULnO07Zaz6vFGZzGvUVPPaEmfsZwc9qj7vYvb8 + H+D3/eej7m95ltr4ZX/LCeZ74AOcsfcNRp+3wOV7AzGxN5jYXs1zr8Dq8+sEU+YbzL6eA5yxn5Jq + VH3+rC0Dfc6m/oE+57O6UfX5Hc+tPr/XAX7vS0bR53cXZ27Z+WBlHXiDyecnmPmWBU6tSOzyfegA + p049vZo57A1GI+fVrgO3E/yuz0fR57FuMIo+n9kE1edefRp7gfu3X64+pzqozym1YZkfYMYGNzhj + r7w5/djiwb74OvzF7+PQUfS5Fbn4EzUwey0OMHrtAmf7PvOFum9vHmDG/hv8rlPHL/tbAhd93gf4 + fd1g/KLPTzD6PIql6POCiX2A2dezwBm7R5mnPmexdVR9fovfx2Oj6vMZzUB9fmc/VvyJsrYUf6LD + m6PX8oWWc6kuMGODBn7fOzeqPufByv7zA0xf0sGMDQY4Y1NTv+nzUfU5paY+L1dn7J6vRH1OKzGv + pVYs+pzqUPJa3ty8NjeY9+3V79+XDPQ5G9QG+rwIk2ZemxNMG9tg8tqjzI96vuKzMh31fMXnpqGj + nq/4VNhHPb/lmXKPqs/7CUanDjBjgwlOnfpcbTmqPn++7+OX+fMJRp93cMZ+Zoej6vO1wcQeYNZL + xDx3/DT1eezrOYo+74dX843HAc73ncXS7cfylXT7sXGAWYP26mxjWebq8/s5yD2KPg9hclR9fk9w + 5paVsZ1nyppaz1fsYPZpejVaMX+5+jwbcNnfMsSMDToYjZzY+XNqS9HnYsYGDdzaFzwcGwwwsW8w + Y4MNzuc+Mrb6nIpMP7ZoofquZWZSn8dY8Kj6nFZiPzYamP1rHUw9j4Rdzj+nzMv5iguc/djw5tm+ + syKX/eeZNMv+87uDyS1ejUaOX/5Vnx9Vn2c/VvR5NsGiz0dUh6LPuXoZ+wQzLvHmPHe0ktTnH9zA + rBuI0S3ePN939sDFn2h2MHstGpi6NsDtS00t5ytmXiv6fE9wtjFqqvp85i8v+/YWmPZ9gxn7d3DG + PvKnqc/7BjM2OMGMDcQZmzI3rx0nmD70BvPc3jxjU6jlPI8OZt3gAn/TDs289pxf+8U/9Nm+f/EP + vcTsldzgbN/PuVz9Q5m10D+Ug8b0D13hL3joH8rXxPqHcjKk/qGfocMNTp06Ojg18pllXubPB5jv + Ym/wuz7XP7Tgos9nBxN7gRkTiTP2SEw/Fvu49A/Ng/wP/UM/L/QG5/ueGdt+LCtTtx97znH94h96 + e3W2sZm/3Hmms4PRLSeYPaIX+D2f6x9KZtI/lNVU/UM/YvAGp1ZcGVt9ft5gxgYHmLGBN8/YPbHz + 5+0Ao883mLHBBLdvV6vPia0+55erz48OzufmhRZf5AEe396Yvg57g+lD8+riHzrAWdfILfZj6wZn + G8u+pOjz7EuKPs+MXL4PnROcsXdi9Xk7weSWDkafX+DMa2fGNq9dG5yx5wVmfq2DM/aKilz0eVam + os8zI6c+X2HEc+gf+nmwqExNX+TM501f5OHVrFncYHRLXl18HW4w60RezfcGFzjr2sibq9eo5+q1 + NsHv+8/1D2XooH9o6WqKPj83+F0j6x8687x7/UOZxNI/lIUB/UNLN1f0Odi8lhK66PO+wayXLHDG + fo6/q39oHJFW/UNjWaH6h8ZQsfqH3s/JnOofeh8T/D4Grv6h0Qyqf2hIKv1DOS1A/1A+VtI/lD3g + +ocyj6x/KFtQ9A/9yNgGZmywwamRs9SqPhdn7LnAGXsd4Iydr6To89XBxJ5g9vwvcMZ+9sCt6PMY + UbWiz+N74IY+/ywEbTD9WP40+7HrBL+vGzT0Ob1/q/6hK3+a80xXB7NucILf9wy2os8379t1YGKX + 76huMHuKNjh16k6sPp83mDnsA5w6dXjzjH3k+1afZwOu+vwEZ+yCM3bP2OrzY4Df9/y3qs9Pb56x + Z95c37V9gNnz38Hve4Jb9Sc6IzsUf6J83+X883uA2Tu3wdnGzniw8n1oJq7yfWjW1Lq/pYMzt+Qb + q/r8AGduyZRb9Hn230Wf31mo5LXeG5icusHs0zzBmc9THKjPvfoy9g3O2P0AZ+xMuU1f5PsAU+YL + jHbw6ixz6nnxRRazZnGBWbM4wVnPs32X70NpBuq1THt1//kNpi9JXPa3HGDGBhPM2KCB0ed5dfGr + WeDMqTwYeW2Reshrz4OIuv6heUBq1z80Y3f9Q2ecsNSrf+hzzaJX/9DnhqVe/UOf1ir9F//QOcEZ + e2dsvzd49P69+oc+F8B69Q99nq7cq3/o01ql6x+anyp3/UNz0bHrH5oZuesfmhvMu/6h+TlC1z/0 + k7gGmJy6wGjkeO6iz68TjD4/wKwb3OCMvfKXq8/XCSb2BhO7gzP2ldh+bCzw63is6x+anWTXP3SF + S0DXPzTHBl3/0PxurusfWmqq+vxe+dOcZ6JYio/HCSafLzD5PGtLWQeeYMYGXk1OvcGZU3eWmvp8 + DvDr/pauf+gMK9uuf+hHgCcu+nyBMzZlrj4/LnDGprYUX+QFZs//DWZfzwmmzAMXfd7EvO8JZl9P + A1PX4sGKPs9WUvR5dnP1/JYbTF+SN1efdzHzTAeY+fMGRp9HRa76/ASzP1XMWuwNzpw6oyoWfb4m + mO/HTjD7Uzc4Y6d2UJ/3PcDsT91g5rgamL4kr/Z7wXOA6UsmmP2pFzjf987aUs4/v8Gve6l69Q9t + bYGp53l1+e5dTF9yg1/3n3f9Q/Nrha5/aH7y0/UPneFN3PUPzen1fwqmZ+J69Ab6h+Y5/13/0Dzz + rusfmsulXf/QPGOh6x/6wRP8uhbbq3+oP63s08zYZZ/mAX5ds+i/+IeeDZxlPrPMfd/P9l39Q2Po + UP1Dn/s0e/UPfR7l26t/6PNL5q5/aG4p7PqH0gT1D81lha5/6Kf5X2D2tyzw63xL1z/0k7jihRZ9 + fl3g17n7rn8o4l//0BXeZ13/0N/w6/cGXf/Qz087weTzfDD7sbODyede/Z7P9Q/NPWRd/9Bce+/6 + h+YadNc/lHz+i3/oypsXH48JZk/RDWZscIJp3/nTnHc4T/Dr9wZd/1DGBvqHzjCc6vqHzvCq7fqH + 5gR51z8UhV39Q58f3fbqH7p4MPX50cDvY4PqH7pGYPU5D6Y+X5mZ1OcrM3LR59kMqn/oDWZfzwnu + X3qDos97xva7mqxrze9qspUUfd7E2b6zmyv7W+YNzvZ9i1kH9ubktXywos8XOPPaPcER++k48xdH + 7OPIm5PXjrHBEfs4L3DGPr06Y2fiUp8fvBLP2xsdzHN784zd8uZ+L7jF9KFi3vcBzvfd8qd98av5 + ixmHejVrVAOcbWznTyvfh97g1+9q/uLXPSb9p3E/s8OjOqy6v+XZSa66v+XxdelfTF6b4Hd9vqo+ + P2/w67drfzH53KvpS87AZZ7pAtOXLDD9mDfP2Gdi+7FnRV5Fn8fs3Cr6/On33lfR5zt/ufr8eWbt + X8y3LR3MOPQGZz0fGbusA19gvuGaYL5lEmdfckWZl/3na4MZGxxgxgYDnLnlzKvV59cCv+4p+osZ + G5zgjM2DlX7sBjM2WODX/Uz/LJPnL89icZ7pamDm1w4wa9AdnO87U093HXge4PexwUKf54czf3HW + 85VXl3XgC0w+n2Dy+Q3O9j3zpznvQBP8sk/zL2ZsIM68RmUqee0Av8+fr6rPzwZ+1+fVP5SMXPR5 + FkvR5+cAZ+wrY+u7NieYfL7BzK81cL7v7AXV5zuboPr8ua+nV//QOzuLVr6riRdazm+5N/hbG6v7 + z2/wu17TP5R5B/1DP4nrAqdObSc4dSqVSX2e+bzo88zIRZ/zSshro+XNyWujX+CIPfoN7nm1N8/Y + mXLV58d9g/O59wnO56aVoM+P7EPV58/Dtvsv/qFbzN7YAc66RrG43yFFUSu+DgP8Ps+kf+gMu4uu + fyizsfqH5gbUrn8oe0z0D0X86x+K0tQ/dIY/cNc/9JNTJxh9njdXnz9LTf/QPP6h6x/6OVjuBEfs + p+NMr/6h8ynAq3/o06yyV//Q57F0vfqHPs/U6NU/NEY11T80pqF+8Q9dDZyx7/jl6vPnDtNe/UNj + nqn6h+7tzbOe9/zl5fyWDmaP6AAz/p7g1Ipn/vLyHdUBZp5pgRkbdHDmljNvbj92bTD9WAOjz29w + xuaVlHVgMTn1ABPbqzP2zKvLOvACs26wwawbeHW+b355WQeeYPav3eD3sYH+oSWfl/PPzwFmbCD+ + 2sZcF7zyl5fvQy8wY4MBZmxwgDO3rLh50eezgclrG0xf0sEZe0SxFH0+NpjYJzhjXxeY584HK74O + N/hbmavPYx34F//QrGtFn2f/Xc5XpFg8v2Wd4GxjPapD+T70auBsY3uByakTTG7JB1OftwZmDtur + 0akHOHUqL7To8wOc+nyIU5+fFzj1efbA6vNxLXDGzrSnPh/nDc7YtDH0+TgOcMbmlaDPD5IH+vzI + PlR9fvQGpg89wawbTHDW86dmqv6hMe1Y/UNjYUD/UCaS9A9l553+oTP8arr+oWwK1D+UeQf9Qz95 + LR9Mff6cUNE/9CPfL3Bq5OcQWf/Qf+ArH0x9Pk5w6vOjgTN29+YZu8WDqc8rztj5vtXn8xBn7BHF + oj6fl5hxSQdnP9ZOMH1oXm0/NsV8ZzHAWdeOE5z92IxXUs5XvBeYfqyBs43xy/0+NBuR+vx5eETX + P/Qzsljg1IrZvsv+ljuLRX2eLbToc36a+nx4dfahI3+a+rxg5u4b+H29RP/Q+mDqcyqT+nxd4Czz + q4OzzKmK6nPqWvHxuMFZ184OzrrWE5d9ewf4ffytfyhbxPUPZZ/mVfX5mmD2/A9w5pZxgTO39Ci1 + os8zp6rP5y1mvmWAM6dmGyv6vDUw/dgG53MfBzif+0xcfB1OMDm1g+m/Fzjf95m/3HOp9gCzH/kA + k1PF2cYoVPftnWLGBmJyizhzS3aSZf95yrmyv+Xw6tSp1wKnTt35QtXnKYqKPs98XvR5ZuSizzP1 + FH1eMOOSCc7YhzhjZz4v+vwWZ5nPC5xlPsRZ5s+69ot/6PPm1T80Pgis/qGxyFz9Q9uZN7cf46eV + 81smONvYs7PQP3SGiV/XP5RNoPqHspKrfyjzLfqH5gFrXf/Qf6TceYMznw8x+ryDI/Z1R6Gqz691 + gCP2dd3giH1dHZyxr7w5/dj17KCrf+g1vTpjrwnmufNq+rHZT3CW+dnAWebPz0d/8Q/Niqw+fx4k + 2H/xD82aWs8/3+Cs5yOvth/jfduPNa9GrzVw6rWV1cF+jGKxHzsm+F2n6h/KooT+oR+N3MDsZ+rg + 7EPbDUafZ+zi63CB+Qa7g4k9wPncO39a2afZwVnm1wBnmR/eHN2Sjch9mmuByecNnHUtM3LR59m+ + 6/ktJ5hvuBYYrejNs33vvLrsbxlg5s8PMBr5BGfsrC1Vnw8wY4MJZmxwgVteHdWh6PO2wewRPcD0 + oQ2cz529gfp8pfIo/kTZBIs/0bnBWdd2xva796yp5XzF2cBZzynUcn5LXm1e2x2MXjvAmVumOPPa + nfXc/S2jgdGp4tSp25unRs6UW/Q5sdXn5wCnPj+9ecbOrkZ9PjJxqc+NjT4fmVPV5+M5I1r9Q4/n + 5rjqHxqLMdU/NN7YL/6hz+zwi3/otcH0YwvM3J43z3r+nE/VP5TP4vUPZSJJ/1BmRPUPZZO3/qHM + /Osfyq59/UP5SEv/0PRt6fqHfuawJ5i5e3Fq5Gduqf6h14qfVvT5HGDGBgc4Y58LnLHP/OXLsUED + MzboYMYGJzhj3/lg07HBBDM26ODsQ1cD876zzO3Hshmoz2PrbPUP3a2Bs56PrA6er7gGmLHBAjM2 + 8OqI/TSj7fqHrrCb7PqHMjbQP5TVc/1DGRvoH/rpQzeY/Uxi9PkFzpzaM7a+DgUzLrnA+dyZ14o+ + 3/lK3KeZiauXfZo3mLHBBc7YLWJXf6ILTD6fYMYGDZz1PNt3+T50XuDxpZXU/ecTnDr1jtRT9PkS + s25wg7MvuTo4Y59ZLGXe4QKz5/8As2YxwcROXHzXFvh9b2z1D42p/V/8Q3s+WPEP7eB838Q2r1GR + y/nnkR3K+edrgdnvcIHJawOcbezOX65eS7VXvw/d4NSKbYIj9kErcf85hfptf4v+oR+NfIJTI2dX + U/T5bOCMzXOrz1OnFn3+xNU/dDyfu/qHjil+H5dU/9AY9FT/0PgUovqHHusG5/s+vTrf93PC9Bf/ + 0Gc+/8U/dEww/dgBznr+HJ5X/9DGcxe/2Av83pfoH8pZYPqH8rmR/qEcHqF/KJMa+ocyFaR/KCu5 + +od+JqkXOHXq6c1Tpx75YGX+/ABn7Od8avUPve4T/K7Pq3/odW8we4o6OJ/7WOB87jNj04/NeYLZ + U7TA+b67mD40Y+tPtE5w9mPZDMr5iucBpp7nze3H2gCzp+gCs/69wNmH3omL79oAv39PpH/oCt+1 + rn8oZ+boH4r41z+UjfX6h7JxR/9QTl/VP5Sxgf6hjA30D2Ujpv6h5bmb58bOCabMxf3LGyv+oS2K + pZyvuDaYdYMOJp9PcNa1rMjq8zgaTv9QTofQP5RlBf1D2YKifyhbjvQPZdWh+oeu7IGLPl/5YOrz + 7CSLPi+YfuwGEztfiXmNByt5bYCzzA9xlnl2c8U/dG4w3wsu8Ne6Zl67slj87j27uXK+4uHV/VsL + Lee3RPJQn8dhnfqHMjbQP/QzNujg1IqpU9XnxzXBfBfr1Rk7JVXR50+dqn/oZ2SxwOzrucDo8wZG + n8/A6vPn3F71Dx3Pilz9Q0PdV//QWE6p/qGxaaj6hx5nB2eZ9wbOurby5vZjlFrpxwaYei7OvuS5 + wqV/KEcJ6R+aFgRd/9BPZ9HA7bU30D/0k5kamHx+gd/nevQP5XA3/UPTTL7rH8qWo+ofOs8NTo08 + 8ubOnx9i9PkJZj9TA2dssPq8TzDrJReY5/bmGfuKNqY+j680fvEPbR3MOtEE5/u+8peXc2MH+P27 + ueofuk9x1vOVv9x+rB1gxgYDzNggyrzsy83KVPblthvM+HuCs8wzaRbdksmj6pYGft8zWH0VeWPq + lpUNuOiWNsH5vjM7VN/zG0xeS+x3VJm4im9LtlB9W+7sJMu50DNx+d5gg1MzZRerbmnUNeeZ7sT2 + YxSq/VgmTXVLfFanr+Jn7f1R5voqfjZaDzD99wXO/nt6dWqHpz7XV/EjLcQZ+1lT9VXk/BZ9Fdns + XH0VY4t49VU81gCz//wGZ+yn6qm+isfz0OlffBXvC8zemgXO9z3i5vq2xHE+rZ4LvU5w1vOxwFnP + Wzy3uiUmTFvRLXH2eiu6Jc7qbUW37Hwl6pb4Kqf98t3cCWYcKs6cSpm7PtYHmL1zB5h1/xOc2mHm + 1eqWq4PZc7DBGftqYHRLvlB1y2xgtOIGZ+ztzbPMWz63uqXfYNYkxbzvC0z/nVfbj/UJzj70HOCs + 56uDs57fWWr2Y9Rz9zNRHfxubl3g7EPvvLnrJZS56/7Dq9/3WrQ6r5hdTZlXzF9e5hXXDeb7kgOc + sXf8tOJ7vhaY2Af4fR65VV/FK5/b8zQzIzd9W44DnLHbBc73vfPmnmsxxYyBxcxxbXDG7lnm6vO7 + g1l7H+BsY9cCZxvLFlrW/bOjKvOKXcw+jw7O2C2v/qbPW9Xn5Wpin+CMfeRPM6/x3CWvTXDGzo6q + +irmK/E7qpSxrfi2NPD7HrJWz4WmIvu9QaY99Xl8ydyKPo/tTj9J7XfF1fRV/Oi1BmYf9gVOrXh5 + dWrFRytp+ip+hGgHp0Z+TBw2fRU/I4sGTo08Mrb6/Ozg13FJ01cx9xw0fRU/OMtcfX42cMYeHcyc + 5g3O2A/d0qqv4vOwr/aLr+J1g/N9Z6EWX8VH8mjVV/F5NnOrvorPtblWfRVbP8H0Jflg5dy5BqZ9 + d3Dmln2DM7fMvLnrY+MAk1M3mPmWC5xaceYvd33sHGC+bdlg1v0vMBo5mkHR5/cGv37T06qv4vOb + nlZ9Fb1afd4ucD539+rXve/tF1/FbN/q8+dorv3iq8gLtR9rN5g+NLH92HWB0S1e/bpnsFVfxZti + sR+7DnC2sbXAfE90gbMfyzdW9Pk4wXwv2MFo5ANMH5qxix/VAc7Ye4EZG2xwxt4ZW32+B/h1XNJ+ + 8VWcG5yxr8Sep5nNoJ4L3cDk8wucde3OX05eI92Xcy2yCZZzLU5vnrGzBy7fzWVPVPQ5v1x9ns2/ + 6POVsdXnvBL1+SlmvcSbZ+yRda34YA8w+887mLn7E0zs/OXmtRQH6nOLxe+o5g3O2Dt/mnktJVUz + r6V2SH2eS7X/TCzPmvqoDtVX8TlEbvoq5umMTV9FsqK+irms0PRVzGmJpq9ifnve9FX87ALb4NSK + I7H7PK4LnLHXAc7Y26sz9p2Fqj5vF5hxyQ1Gn3cw+jyeW30e8r36KvZbzHM3cD73zNjF97yBGQve + 4NfviVr1VYxOsvoqtmuB6Uu8+nWeqemriPLQVzEnLZu+ip/2fYFf91o0fRVzpqjpq0jC1lcxD9Rr + +irmbM0/dcVDad7508q+3AvM3jmvTo183uCMPRKrzzMz1fnzDuabngEmdhZq8aOaYL5lErNfsYEz + 9s7YxS92gXnfXt2/1ZbiF5tl7vfAJI/iPzbB9GMNTD8WNy/fzW1xtu82wK/7cv/izC1n1JaizzO3 + fJs//4vR5yc4Y9/508xr9wbTh55gcuoEt29X60eVHXT1VRxgnnuC87lXYs/TnAPMeKyBv+mWcu5c + zxf65byevzjrOS/U7+aykyzfzV1ZW4qPxwV+nUf+i+lLTnC27ztfaNnf0sCM/cVo5AHO2FcWS5l3 + OMCMS24weU1M7Pzlxfd8gjM2D0Zeo4NWnz+P4m/VVzF6/+qr+HTDaNVXMWpL9VW8r7za/WtrgjP2 + 7dWMv8XZxkZivy95Vgd9FXO5tOmrmN/NNX0VP4krb172Mw0w3+wtMGsWHYxGjp9W5s+fXeyq+nwN + MHupxBl7RWUq+nxeYObuJzhjn+KMPfKn6XuetaXo83uD6UsaOOta1vPi2zImmDHwCWZesYPRLXlz + 55nOBqZ932D2FF3gzC3ZgMu5FtcAM99yglmL3eCM3fLm6vNsoUWf7w5GI5/g1MiUeZk/v8Cv3/T8 + xcTu4Iy98o153v1eYNZqOpgyn+As85GFWvqxDqb/FlPXvHnW8x5XF32ePVE51yJzSznXYi1w+9IT + FX2eNbXoc36a+vw6wejUfO4yfz7B6PMGZo5rgDOnHvnL1efHDR5fMnL1Pe9g8nn+cv2ojgnO2LwS + fVuauH3pDYo+3yc433d2sZ4L3a4DjG7J2J7X08WMQw9w1vM9wPQl+WDFL/YG871BB2fs7s0zt9DG + 1Odb/Lqf6S9mbNDB6PO82rx2bjBjgwvM2OAEt9erq69iDB1+8VV8Ko/ffBU3mP47cfFtGeB8382r + 2b92grOunflg7tPkwdzPtMRopgnONtbzp7lP81mR9VVc4aXR9FX8NP8LnLF33Fx93vKXF33+nLvX + VzG/lGj6KpKw9VXMb1Obvop5lkjTV5Fhi76KHxzFUvT5aGDm7juYfsyryef53Orz59zeL76K+UL1 + VaQ66KvYjmgl3XmmtsDM9Uwwcz0nmDYWDVh9flOo5dw5r2Yd+ABnbpl5tXntnOD3tVh9FRkb6Kv4 + Ubn5xtTntDH1+d3A7Gda4NTnvLGiz8VfYxff8w3O56YZlPM0bzBlfoHZEzzA9CVRHcq50PlgRZ93 + MfNM3jzr+RXNoJ5rMcHMM4mZZxKj16I6tG/rgvoqMgutr+IncV3gzKk9WknV5yeYfL7BzLeIMzZl + rj6fHZyxp1dn7EwexVeRQtWPKjWT+ryPG0wfusGUeb6Sct79BrOX6gC/7+OqvoottaLnzsUqU/VV + bE38PjbQV7F0NerzO/O5+hwxqD6/sxcs+vzOymReWxeY+XOvJq81MPr8cbW+iiRNfRXpx6qvYsUZ + +zmC/sVX8Zl6fvFVfA48fvFVvLw5/fcM7HjsOQ1VfRVjMqf6Kka6r76KUVuqr+LNKynnzjUwcz0b + nLHviF30eR9gvnVYYLTiBc72fcVPU58/XfqavorkFn0V6Uv0VczTQJq+igw89FVEgOur+Bsmdj53 + WQdu4Pd1YH0Vma3RV5HV8198Fa8FZizYwO/r/r/4KrZoY0Wf7w2mni8w+x0uMG0sry7rgmLadwP3 + 14ysryLfG+irWBJX+T50HOCMfYjRyHnzsr9lg5k/92r2Mw1wxgbbj1Edvviet998FS8wfUngos+v + DqYPXWDGgic461qWWtHnWRWLPj83mDHwDSaf54Opz7NQiz6n1NTn1wSTWxI773CLyali5lsOcObU + bP5Fn2dXU/W5mHXgCc7YO8tcfZ4dVdHn5eqvsdXnK3JL8VWc4vGt1PxeMPVa8W2hMhW/2BP8Pha8 + 6rlzl1dnXaM6uN+hdzDzTBtMG1vgbGNn/nL1Wso59fmdWbHo8y2mL3ncXF9F5u71VSQr6qvI9lV9 + FWecK9n0VZzxJXOrvoq7eTV9iZjYR2D7sedcT/VVjM6i+irG0nz1Vdxn/jT7sefovfoqxtCh+irG + QlD1Vbx7/PJy7tw4wPQlN/h971z1VYxWoq/iClu2pq/iCovupq8iu0T0VczPpJu+inwKoa8iKldf + RRYl9FXkCzB9FT95rYPR52Ji3+CvsdXn/HL1+RKTU28wZZ6vxHVg6prrwNTU4j+2wFnXVtY19fkl + pp53MGtzBxi9lr+87NPcYNr3AWbeYYHJLRnbvDYG+P17A30V2d+iryLiv/oqbtq3ea0d4PexwS++ + ipnuiz7vJ/hbPi/6fNzgjH3FL6++LTeYsWAHM9cjzrqWXU0r370vMLqlgfuXjFz0+ZE3L9+H3uD3 + PaL6KjLfoq8i88j6KrJcqq8im0D1Vcwz0Jq+ih+NHPW86vMF5huuC5yxb2+ese8s1C++5+0XX8W7 + gTP2Fmfs7N6Lb8t1gt/3M1VfxU49/+IX26qvYuOnuR/5PMDve6H1VWROU19F1L2+iqwi66vIKrK+ + isg5fRWZKdJXceZxAPoqIt/1VZzhT9T0VUyTkKavIucc6KvI12f6Kn52ee7ArgPPC8we0ROcsecC + Z+znGLj6KsYW0l98FZ/5vPoqRj9WfRVjTFR9FWNkUX0VY1Gi+irufLByLvRzcb36Koasqb6K8Z1k + 9VWM76Crr+LzzPlWfRVjDbr6Kt73AaYf8+b0Y/HG6v7zASa3nOD3/Yr6KjJBrq8iCltfxd+uJvYF + Rp9HG6v6fIEZj3k1OXWAM3bLqli+ez/BzN1vcNa1y5u/ayZ9FfkQUl9FPvnRV5H5Fn0VEYP6KpaE + XfT52cDMt0wwuSWfu+jzC0xeW2D21nRw5tQdV6vP47PZ6qsY+3qqr+K6L3A+d4tiKfq8i5njGmD2 + p24w7zt/WvFtucHv+3qqr+LNT1vU8ysfzO/e9wFmv4NXsza3weS1vLl5bS0w+zQ7+H2fpr6K7FDR + V5EPpfRVZAZcX0XOltBX8aOwo42pz49MHurzOP6h+ipWTOx8MPU5dU19zitRn88DnLHPvNrzPA4x + 73uAmeNqYOpalnnZj9zA73v+9VVkIklfRb4H1ldxxnm5TV/FmWcF6as4w9ys6auI2tNX8ZO4Gpj5 + lhvMPk0xGjljF33ewJnPKTX1+TnBGfs5O6evIsezVV/F9UzY1VdxXV6dsWc8t/o8RjW/+CruDe6v + PXD1VYxFieqrGKO56qu488HU5ztfqPo8diRVX8W7i/m2pYEZG9zgbGPP4Vr1VQytqK8iSlNfRcb+ + +iryMYO+imxg0VeRGXB9FTkGQV/FFWczN30V6WL1VVx55p2+igxb9FVk5V5fxRUu2k1fRb4Q+cVX + MdNe0ec7S019PjeYbxUb+F0z6auI+NdXsSTsos+piuU7qgtMPs9frj4fE/w+d6+vIpvb9VVkWkJf + RXbO66v4wV6NPm/gzKl3/HL1ubHNa22B3791qL6KO6tD0ef5StTnO6ui+nxnRS76vEcLLfqcn+a5 + VNnFlvPPt1dn+87qUPT5WGC+6TnAzN13cGrFzA5Fn48NZm9NA7/vb9FXEX2uryKHTuurmNYqTV/F + z5nUBzhiHykG1edPr5xWfRWN7XnYvFD1eSauos/3BX7fz1R9FfspzthHYs/zaCeYfbkd/D6/Vn0V + n6enN30VmdrXV5HTIfRV/LTQG0z7HoHLOrAYvTbBzN03cHvNivoqpkVY01eRU6X1VURh66vI6W36 + KqZ3StNX8YMbOGO3Cc7YLW5e9Hk/wRn76OCMPcQZO4tFfb7yharPY9XhF1/FfYN53ztw8ScSU9ca + mLFBB2fsOypy0eddzLrBDX6fy62+iiEGq69ijA2qr2JsItFX8TN08Obklvxp6nPKXH1OZVKfjwPc + vl2tPs/sUPT54dWMicQZu+XN1ed7g7PM1wHmfU9wvu9MudWf6AAzd3+B0WsbnPWcFlrObxlg5pEn + +H3fff9Fn8dzV30+wMw7iFmLXeDMayuvNq/lC1Wf16uJvcEZe8cbU5/Ht8i96vNswEWfpzhQn8e3 + a73o89g624s+jyM3etXn2c2V889HPrd5bQ7w+3qo/qElcZXzW84sNfPaOsHvc/f6h3Iojv6hHymZ + 9dz9LdkEy/4WyrzMnw9w6vMUB1WfN3Dq88OrGRsMMLHzufWrobboV9PE7CkSZ5nzQtXnmdfU5z27 + GvV5T71W9Pk/1f3/bj76E/1rCuwH04+dYOaZDjDaIW9uP/bPhP2DX/qSH4xmOsCZW/7Zj/3FZf/5 + AX6ZR/7B7G85wejzvLroc3HGbgMcsec/69oPjthzx4Opz//lRf2DI3bFGTsrk/p87nih6vN/Oc78 + YJ7bq7PMjwamzOOVqM//5Zr+g+lDDzDza94861qPN1b9iS7wyzj0B1PPb3C2sZYPZj92iF/2Yf9g + tOICZ+yVD1a+D73BL+sGP/hlT9EPzrzWM3Y5h2yBX/T5D0afbzCx8337HVVbYLTDBDOvKKbMsyqW + c6luMO97gNkrOcHUtXww9XkmzXq+YgOz736Ayedx87L/PDuqsv88K9P7/pYfjEbOmxd9PsHM9dxg + +hKvztgzf5p5bW7wy9jgBzPn4c2zzLOFFn2ebazo8yF++c7iB2fs7MeKPs+qWPR59gbNvDa9edbz + O7JD0ec8t3ntFGduya6m6HPKXH1+XODUisR2//kUZ+xM2EWfpzCp8+cTjD4Xpz4feXP1efahRZ+P + Dv4aWz/JzOfq83/tCvrBjIlOMGU+wVnmj4x8/OIf2m9w1rWHAD+qf2h7xD6qf2h75NSj+of+a3bu + B2cbWxPMnoMTnG2s5y9/Pb/lB2duOTeYeYcGzpx6Z5mrzx+t5NA/9Gn5+IPRqeKM3aLUij5/pJ5D + /9BU94f+oR/57s1Tn694JUWfP+TcoX9ojg0O/UM/P22Bee58MPuxfoGzzI8NZr3Eq1/70KP6hz57 + weObf+gPZp3oAGc/dmWZ60+0FpgxcAej17x5tjGKRX0+T3DG3h2MPm9gNHIWS9nfcoIzr40GZu7+ + BmfsM3+5ee08wMS+wcQe4Ix9ZBMs5xyIGRMNMGODG5zvm/Zd/EMXmLFBA1PXOjhjZyt5P1/xBzM2 + OMBoxQucbSzfd9l/nq+k7G/pC/yyZ/AH05fEK3mfP//BmdfuE9y/X/2qzw/9Q3PQc+gfWjrJos/H + Bf6W19TnO3uios/55SWvXWDyWj6YeW2Js431BqZ9T3C275RU7+cr/uDUipn2ij6/Oji1YnbQZf85 + VbHMnzdwauSxwKmR+Wnq83mAM/a8wRl7eXXGnlmo6vM5wBn7Emfs7A3U58+hw6F/6NNu8gczNhAz + NmjgfN8jY/u+mzjr+bO2VP/Q9pSx1T+08WDOMy0xfckEszZ3gjO37Pxprz4eP5i8JianHmC0YjxY + 2d/yGGAf+od+dOoEZ+zewWjkqA5Fn98dzNhgg9HnN7i1L3gZ+wQzdz/APLdX53Mf+cvV51lT1ef/ + 2kv1g5nj8mr60Pxp9mO8UP1Dzw1+XaM6qn/ovvPmxQf7Br/O3R/VP/SeYrRi/vKyb2+C6UMHmPXv + Bc7cMhIXfX6CmV/b4Jf9ij84Y1/ZxtTnmbiKPqfM/Y5qHOCM3fO5/Y6qXWDGYxuc73sNcL7vK25e + /YlucMbOnFrOP28H+Fs+r+e3TDDrYx2MTl3gjH3kc7tvr08wY38xY4MDnHntztjmtXuAGRts8Pu4 + ZFd93hOb10YDk9e8+uU7ix/M+05sXktp0cxr4wST17x51nPKvMw7DPC33FLOP18nOPVa9t9Fn2df + Ur4PzcRVvg9dXp2x72wGZX/LAWZscIHfxwa76nNqi/qcByv6vIPR5wtM7EeZ6x/6ebAbzJrFArOv + Z4OzzJ8KW/9QXqj+obmUc/ziH3qLsy95Js1f/EOHmHmmA0xf0sDZxkYWi/NMbYKZ6xngzC3P3l// + 0OcZC/8bF32+J/hdK+of+tlEcoEzn/cotarPLzD6vIOZu2/g1OczY6vPrxucsWcDZ+xy84zNT6Mf + m1ucse8TzNjgAGeZZwNWn6+rgVn/Fr/u6zl+8Q/N7FD8Q88Ozno+TzB7ob15trGWz118sE9w9qGX + mPZ9gDP2zthlXfACMzYQMzYQZ14b+dNKXjvBzN2L3/W5/qHM3esf+nmwG0xO3WD2SnpzyjwqU9Hn + c4AZC15g5lMXmLqWWH2+N5h6foNf9/X8xdnGMuUWfX40MPp8gd/nz1fV59lZFH2+xK97a/5i9vXc + 4Iy98n2b11JaqM9jUmMVfb7uBc4yz5qqPt/ZDNTnMeexij7fPJi+a/y0cp7HCSavdTB57QZn+6a2 + mNdSM5Xzz7OTLOef3+LUij1v7veh5wFOrZi6RX3eeW73n2c3V/R572DGBgPM2KCBU58/U+6s+vx5 + 9az6/Jm4ZtHnsaQxiz4/nn3orPr8Of6eVZ8/m+As+rxf4izzI2P7vp/TjrPqc2Lbj51enfW8J1af + 7wNMX7LB73P3s+rzHbicr/hswPqHPk9g+cHvc/f6h35SbmL3aT7bt/6hbEHRP/QjY705GjmvVp/z + 09Tnlzhj5/su+vyMZlD0+TnAxO5gxgbenOfOqy/HBhP8vm5Q/UPXcYDzfZ+J6ceeO2uP6h+69g3O + fqx3MLolf3nxRV7grOfbq5lPPcGp1458sOKDvcDZvucFZo9JB2fsO2+uPs+UW/R592rGBgOMPs9i + UZ9TW9TnRwez53+A0Q5RakWfZ3Yo+nw3MHOaA9y+ZOTiTzQ6OGN3cdZzfrn6PPNa0efXBKMVG5h9 + mt48Y/PLy/z5BtO+T3DmlrXA6PMslqLPG5h5pgVmbLDBxM7nNq9l8lCfWyzf81rR51SmktfEzO2d + YOraBJPX8uYlr20w+5EvMPsVDzC5JW9uXqOem9do3+rz5tWpFVMEq897igP1eV9enbH3Bc7Yz01D + +ocyNtA/9CPAxejzE9y+Xf36PfAPZu7eqzN2E+dzPyc19A/9FGoHs1bTwFnmz7ymf+inOhyB7ceW + mDWqBqYfE2cbW/G+iz/RKaYv2WDmNC9w5pbnVJD+oWzc0T+UyVr9Q8nI+od+tGLisv/8BqNTvZq9 + NRcYjZy/XH0+Bxh9vsEZu+CMfeWDqc+fGln/UD4o0D+ULUf6h35KLZ/bfuwpBqt/aCzGVP/QdXl1 + xt5ZmezH2gCzh+wCM6fZwO+a6Rf/0HuB2WvRwO/f1VT/0FD31T/03ieYOewGJrcsMH1o1rVyTrCY + vDbBzHlscMY+46c1fZHPC8y6wQS/r1lc6HPmWy70+adQO5ixgVczNrjB+b6v6CzU57FOdBV9fncx + em2Ds55nG1OfxwLYVfT5zheqPt/DqzN2dhZlf0vbYPqSG8w8UwOTW/LmRZ+fYMYlC0zsAc7nzsRV + 9Hmf4Czz0cGsvS9wxuaFlvP2LjB7/gf4fY3qQp9/6nleXfJaB5PXLjDte4OzfV9ZqOY1nlt93m5w + asXh1akVn9PM+od+dOoAZ+xnRdY/9KORJzj1ec/YRZ+fYMYGE/w+NtA/tOKyn2mCM3bzasZENzjL + fOXVZTx2gbPMn21M/1DGgvqHrodxw//GvfRjN5g5rgZ+/37sF//QK3HxwRZnbrnF7Bmc4Mwtzz1F + +ocya6F/KClX/1AWBvQPnY/z7v9i55mOAWZssMGsGyxw6nNeSZk/v8DsKTrB7+MS/UPzKKFD/9D6 + y+3Hmvh97r76h66Rz00/tq4JZu1d/L7+Xf1Dd883Zj92nmD2OywwmmmAs431vNp+7Gxg5u5PMO1b + 3F57Qf1DUbn6h7JrX//QmpnMa1dcXfR5PljR5/MC9+9XZ+wZ7bvo88znTV/kc4LZU3SCM/aRsfVF + zt6g6PP7ALPfwZuTzxOX888P8PvYQP9QRrH6h37GwNHGij7PjFz3ny8wY4MOpn1HVSz7WzJhf50/ + 1z90Pny4fnDmtczn6vMYOugf+ht+X//WP7T+cvNaEzPncYAp8wucZX5F2lOf7yVGO4jZczDBWc+z + L2nFP/QE08YamDmPCc72/dQO+oeSuPQP/QwdNhitKE6d+hwy6R/62VN0gpnDvsHsKepgNHL+tHLe + /QTzXewNRp9784y9s1DV5/w09flcYPb1nOCMPSK2+rz3Bc73fZ9gvi9pYOraCGw/1sXMM4mzjV0d + nG3syJ+mPr87GM0kfp/r0T+Ur7D0D52Ps/Z/MGuxDZw59RRnTj3yl7sO3AaYve9ejT4Xpz5f+dzq + 8zXAzN0fYL438OYZe+crGV/GBtU/ND50rv6h8cFv9Q9dZ/40fZHnCX6fX/vFP7Q3cNY1qqL9GJWp + +BMNMPt6Npg2Flmxnt8ywO/r39U/9L69OnNLj9pS9Hl2NUWfZy9Y9PklzthXFEvR5/m+iz7PfF70 + ecEZe0ZdK/o833fq8/pg+iKPDc7YR7yxpi9y1tSiz/OFqs+pDurzOAxI/9AZZzMf+ocyitU/lHUD + /UNnHu6mf+injQ3w+9hA/1DO49I/lA8K9A8t2aHMnzfx+9hA/1AOGtM/tPRj6vOVuUV9XjGxs8z1 + q+GNmdcolnLe3gCTUzN2Oc9jg8mpDfy+V/IX/9DnLPQv/qHPWYvqHxonalX/0PtZavqHsiFR/1DW + JPUP/aSeDc7csm9w6tTn7Jz+oRxEpH/o0yLsB6ORGzhjX/nT1OfzAqPPT3DGfkpJ/UM/seO5iz7P + 960+78Or2ddzgCnzqGtFn+8T/D7HpX8o2370D2UN+hf/0H2B+a5mg7OePzc7/+If2jK268BrgbN9 + XwNMbrnBmVuIrT7fHfw+NtA/lA3m+od+ZGw+WNnfcoLf977rH/pR2OLU53c+WNHnB5hxyQAT+wbn + c7fE9mPHALOvZ4HZ13OBM/bKNqY+bx3MHJdXs/59g9Et+ULLd+8NzL4er+5feqLyfeiKYqn7zzf4 + fV1Q/1B25ugfij7XP5T9ivqHftLeAmfsW0xOzedGn8cMmf6hn+mYBmZ+bYGJHRW56PP7An99bn2R + lzfPMs/MVPxDzwHmfZ9g9kJPcNa17CzK+S1zgvl+bIHZ5+HN6Uvy5urzvcHsP+9g9u1d4Hedqn9o + SR5l/jzTfZk/b+LMa1Smos8bmLGBVzM2WGBiZwP2POzsDYo+p401+28xZf4o1OofGseMVv/QWFao + /qH7Wai/+Yfegcv3Bg38vhZb/UPjuC79Q5ms1T+UVUX9Q9mRpH/oJ7eIM/adsYtf7A3OnHqcYPYz + TXDm1DNeSdHnVwOzZnGCGZccYGKvwNuxQQMzNhBn7D7BlHli55nWAvO+xe9r0PqH8t37L/6hT438 + i3/odYHf9+1V/9DYFVT9Q2nA6vPNG3OeKaui+jxma/QP/WRF8fvYQP9QTqXUP5Rza/QP5XsD/UM5 + FEf/0I8Av8Do87xafd4mmHHJDe7ffrn9GM9tP3Ye4Ix9eXX/9sbU5zy380zHAH+ta/Zjq4Op55Hu + iz7Pmlq+D820V74PXV5N+46fVvR5Pnfd33KD6Uu8ecbeeXXR5xNMX9LB9CUHOPP5yDKf5vMTnLEL + ztjZvtXndHPq835sMOOSE8y4pIEp82j+xZ8ohUn1JxKzF/oAp2bKfF7Ob1kb/K0vKee3jAFGr+VP + +7b/XP9QlhX0D/00f2+e7fvIV1LmHQb4XZ/rH8q3a/qHlp6o6POrgzN2Ki71Of2Y+nw9a4v+oZy/ + pn/oB2/w+3NX/9AoteofGiOq6h8a6f4X/9DTq/N9Pwe5v/iHPtNe9Q+Nmlr9Q+9xgbOezyyWcn5L + B/Otwwl+/5ZJ/1CyQ6v7z+cBzthrg9/XLFrd33InVp+3CeY7iw1+30vVij7vWWpFn/PT1Od3B9OH + LnA+d9a17jzTucDM9Xg1cz0DnHVt5YO5DnwNMHOaC8z425tnG1tZmcr5ihM8XjNyq/r89urMLSsf + 7Nv+81b1+Vjg973v7Rd9njcnr817g5m7P8DsKYoyL7oln7voljXB2cayIhfdsk5wxp6RetQtPcu8 + +J6fXs3a3AbTvvOXu09zi1mb62DG316d7btHTS3nWuwDjGYSM/4WZxvL2lJ0yxxgvhc8wcxpbjD9 + d15dfPY6GN3SwLSxAaaN/eundX0Vc/9a11cxP2zv+ip+8AC3vPoKXNp3A9O+F5ix/wbncx95c8ff + j2FLr76Kz7TXq6/ic/Gt/+areAcu4+8D/Po9cK++ipvYvO+nBUGvvorPjqpXX8VnG+vVV/E5/u7V + V/F5tGvXV3HFgbhdX8UVh9J2fRVzeN71VUxB1vVVzB3FXV/FFQfad30VU7d0fRVzmrnrq5jrgl1f + xRymdn0VP1OeA4xOzQdzfewxsdD1VVxxGFD/xVdx3eB839lKim/LaGC+gz7BWc+3V2c+v7IyuV5C + 7LJ/bYGZX5vgbN8zX4nziucEo5kamHlFb04+zxfazani8SUjO684ed/kNTF5jd7AecXnXotefRUX + VdF+rEdWdF5xDTFz2AeY932Bs671eGPlXOhxg1mb8+rXPaK9+io+90L36qv4/FS5V1/F53dzXV/F + XB7v+irmfoeur2Jqxa6vYs7tdX0Vc9Ky66uY29u6voqfT18aOGPfFzhiP7/37/oqpg9211cxzTJ6 + 9VU8qKno8+dxXb36Kh7ZvovvOWXuOQfZ1VRfxQHOMs/MVHxb2gDTh4pf9+316qvYeCXFZ2+As55T + mcr3Bl7dvrVQ9VpqRfX5buJvWrHo88ekRtdXERmrryIaWV/FtKru+irmYbxdX8XPebkLnLGHOGM/ + vk3t+ip+cMa2H3vMDPbqqzjPDs7Yl5jnPgOXfqyDWRcUv47H+i++ivnT1Ofr2cVWX8XnQLNXX8Wd + r6ScO/eYX+vVV/H58WmvvorPAXavvorPfXu9+ipGA66+ivctztzSL/Drun/XVzG/Tun6KuakRtdX + Mfefd30VUff6KpIV9VWsV6vPie3+tdnAGTsbcHd9LJtgL/7AA8yef6/O901dK98bHODX72q6vooz + XLS7vor5lWXXV7G2krJ/bYBfv23p+irOOC+366v4af4DzNhggl/nU7u+ih+NnMXiPFMTv86n9uqr + +JxP7dVXEaw+f3pC/cXkVDFjog3O584Xqj5/npD4F2fsJX7dr/gXZ10b8ULLudDZDMq50PcGsz52 + gr+1saLPs6NSn7fh1eSWG5xakWJRnw8x37Z0cOrUvcHo86ipRZ8PcerzzIpFn183OGPPvNpzgik1 + zwnOfK4+PzKfq8+P7GLV5wdl/uWc4L+YMr/A+b6vrC1fvqP6i9kDfoPf57h2PXeuZ+yyDtzA7MMe + 4PexwU/jfjbgR2XSVzH3Qnd9FXNHcddXkcykr2J+V9P1VUT866uYjhRdX8WPhN7gzOdHYvV5P8AZ + u4kj9vXsDaqv4vUUg9VX8bonmNgnOJ+7i/O5R/xy9fnToKRXX8Wn+0mvvorP74n6L76KR15d+rEB + Zm/NCc5+rE9w1vOsDuVciyVmLneB6cfE9GP5YGVf7gajUzuYOa4b/K6R9VX8ZKYb/K7P9VVkWUFf + RdYN9FVk6KCvYn4n2fVVZPJOX8UVp3l1fRU/4qCBWTe4wez5X2DedzYi14GpLa4D9wFm3eACZz2n + WFwHpvm7Dty8mnnkE5ztm+dWn5/i8S07kNcWr8S8dscvr/q8gVk3OMHv68DVV/FpftSrr+K8xYwN + Npgx0QXOMs96rj5f2UmqzxelVnxbbjDaIW/u98A8t98bDDFrcwe4fWmh9bu5C4xeO8F84+HN0Yp5 + c/e3ZHb4On+ur+JHBJ9g9Hn+NPX5Fkfs0QY4Yo/satTno+eDoc9Hv8DEvsEZu3VwPnemPfX5MU9w + lvnYYNZLxPm+sx9rfkc1bjD7FQ/w+xxX9VX8B/l3/wtjV9n7fQsCAA== + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['18850'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:45 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 12:27:33 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_drift b/siphon/tests/fixtures/ndbc_realtime_drift new file mode 100644 index 000000000..80298a722 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_drift @@ -0,0 +1,221 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/22101.drift + response: + body: + string: !!binary | + H4sIAAAAAAAAA51dTa8EuW28+1cM4PuLpP4+GtkgCJBNFvYCho8GHGQvmwDOyf8+b7pnRqwqltJO + 4Dw/P3sLEkWxSIpk//ZPf3o8fvzx8cMPj19++fXXx/P//vV3Pz+uX/793x5//OFffv/44x9++uHx + z394/vmn3//THx4//fzDnx6/+/nHnx5//P7xm9/+7a+Px6///fjL3x6//PXX/zr/2b/8x38+Pr98 + ///Pj1//4X8e14/H45ef/nz9+P5v/vH88ZtW6v4o3/+qjzqX8v0/mravNn//e23rV2mPR/v+Y/16 + /jffC66lzF/t+r3NX8ejta8KIFMGMtXvP5YAMn3/o2+QWUDKkYG04/uPcwBpH5Dle03fIBOA7CnI + /v3HCVYyf0CmJ8gOIJvdDoIsEWT6agCypivZvv/YQLDlA7I8V7ICyJKuZCGZzF/1BbJ+/yYySY/4 + BJkAZMKV4OnkRzzLdrpgz5UUAGk3t/MGmb82BalWY3E7C65kA5CSrsSr/YQr2b7V4fs/2+3U9Iif + 59Tq54gvEL+dCsq2f1ZyguwAkm9nEpADQY4IUtMLeB5xTZWtXXoCMqnpBXxMoifTRyZFQXK119PZ + PyvZdTt3LdsUQXgludrr3XnLZLrMI4LkejKLPVmjTOpHYy+QVE/OI84t21N3v0FmAPF64kA2WUlu + qE/z2ABk+4CsT5nASnJDLTaWLBsdsTHUagq6YE+NXQAkNdTfzIUgS2DABMQbagRZPiBAoxdIrrF8 + AZeP2m8XeSFIqrG1EsgaBFvEnuSGurKeRJBZTyfV2BNkTmWyPPWEQVKNfexWJvNlCoKN/d5eKpPH + QRq7fPTkvMVwd4qx9pU1dgl3Z1GQXCaHbGcarSSVSWuFbWy39pvIJLf2ld2tJVi2piDpLU6202l0 + JmX7BklvcXuqfTEgBxmlb5D0Fp8XMJfJ0+4LSH6L1ckhwSKId7fQydk+IIuC3OWd+QGCRZBUY9vI + tVj0dFKNbXwBp3A6u2is4R31qMvndA5RNsM7RUAagoBMDO+op/Q+nfWKMhYAyXmnCEgPVQ5iwOJ4 + R5Vt/YCcLmgDkFRjH3wBu6dEbvkFkvPOU9kWw4CH6EnOOw9W+yWsRI1SzjvJSrpMJgXJPepZQLoL + et4dPOKcd3QlXWMXXEk7DO8kt7j7J09fPjDgEySXyUoriaHKSaMVQO7JZAoe9aEguUw2uYDd8Tsp + o0WQnHfO7TiQFU/nCZJHGc+VrAZkV5D0Fp8rWVPBLsyAT5D8Fj/N426C66og+S3m7USQTbfjb3G+ + nTUTrL/Fa6on6UpyjVVlIxcUQe6F+e1zxC/BzgCS885cOKfUBTuJxhreURDyYxEk5x2OAeN2Gvr2 + T5B78c4UjriJTHLeGUSjC6c+niD34p2YDmoKkmssB5LdBX0JFu6O4R0fvq3XEYOymcTUKish3kHB + 5hqrDDh/VrIoiOedloJscnd2F++shV1Q8E/A2u+Od1hP5hDSrk/y2gDEy8T5sY0YcB/xTp57fPmx + JYIY3uG4eA7OMJuC/W52q3sFk5iC3fEOC3YQAz5Bct5hU7CEKIM1dh/xzpSq/YuLJwDx8U5LV9Iy + kFxj+YiXcDqHCjaP0J8ywUCyx4BNV5LHOyvpSTydWS5gzjt1kZXUz0qqbMc8iIwChIZu+RMkfxDx + wfWcKFvOO43vTsxuzRg0PUHuPYiswdrvup1UYxvHO2tw/DYFSTW2TSSTLRwxU8bueIfj4i2ofRVl + y3nn/COuhBIOYKhNno1l8nFH3ytBkDynxEe8hQCBV7IZ3qlsCraPnjQJVTbDO40j9C3cnWdKLHoF + m+EdEewattOIvDaXZ+P3nTW8ICyykpx3GlPGeCU57ySn05N1EzHg5vJsnLXYQhZUjzjnHZHJHlai + R5zzTt3odPYPodfLxjYAyW8xG+o9PFdxNLoZ3hGQjWkUBevfd5w9KQqSv+9wUnfFXAHYk83wzpms + Q5Bu7Zm8Nsc7fItX/9L0BMk1lm/xGvL27Clthnee/3MSrH2ueoLk8Q6vpJvHV6IbTmfAOw1AOgNS + nu0JkntK/L6zhyNOtpPbWLb2R9jOokec21j2T46xTHLe4UzOEXhnJd9+M7xzIjcA6be40kpWwzti + 2fYPjZ7kBStZ3fsOl47svJ0dQHKZcLyzBctWiTJWwzuVb/EWEpgnyBJBzPsOJ/8jFzdZiXnfWQtf + wPWznU1kYnhHV9JBJgVJb3Fl3ome0ixHbHiHw/xtEEiuhncq3+Iu2NeDCIL4V9qW8k7LtpNrrK5k + fsARI4i/xQgCpoBBct5Rd6ungzj3uDreYbd8/Qh2k6BpNbxzuhbIOz0GTFby92qsxsWri3f4uarb + k+Xi4gogucYq73RTsKtMck+Jt7OHoIldi9XxDucKjhC+FfIKVldXwKmPAyMvUjbDOxwXH8EF3cWe + GN5RkPfpNAFZXLyjrkXfDlPG4niH4+INC8AYxN/iZmxsIcpYHO8oeU0fkPN0pghieIezoFsImk6Q + GUDyW8x6sn382BcXrwCS3uJkJd087hR5LY532MmJhrooSH6LWbDdFNRnEoaO2PAO68nO2zkAxHuP + GHl1wTIXLyPeyWm0XRqLMsk1VkOV7rNxenlxeTbNKXVC5wfWxfDOKZMp5Z2XV1ABxFfCzGYlM5nH + xfHO84+LAWHeWRzvVAKJhL6Sf7KMeAdBIN5hweYa+wRZU8v2yuQgiNfYJb07Sl6L451NQDplsGux + ON5RkILbgbtjeIefZijhAGo/O97hlUT/hH372fGOrqRHXruC3IsB4y1uxDuz4x3dznsl9VpJiyCD + erZc7V+RVwWQPGvBPltcyUIMODve2cUU9FClEAPOjnfY3drYUwLBGt7hkHYUA86OdzSp2wmdLdvs + eEdBgNAbCfYe76zBU+KEwzyKd/I82yvjh3qSa6xmt6CimwRr4h0uiltDrQXXn8wuz8b5k66xK9cM + P0Huve/0u3OWBExolAa8kyvbWfXR8BabPJuGKu+VbJJyn12eTd3yHo1OWHj8BLlXM7yH17cS+3cu + kPwN3SfrXqcDdyfnHXnCO8LpFAXJI3R2/I7wqtIoLp4c7/DdiUHTRKczjfJsKNjuUW9kHqdRni2P + i2sG4uOdlipbvZIwNYIY3lEbu39AmoLk3qPK5H065VJ7BPG8M6WCfdEoguS8w8+aMR+7EBdPjnf4 + Fh8hQDjkdMz7DqeDDqwtB3drcnUFu4BAhN5IJvkt1sir55Qqkdfk6tk443d8UVEcCjavhGHLFkGY + 0CdXz6ZPeEdcSUFTkPPOQ1/f3sq2XTYWZGJ4h4/4Y2OnchmlA0B8XUFuY/drJaAng3gn15P9srG4 + Hd+/E0Dq5/erdgt8+8nFO3TEtYR6Ng7zJ/e+U2Ul82cl/KoyuXq2KiuZ40oagdzS2ADyKigNpqDd + rCv4Bum3eCO3vDneUZDyWclK5rE53uHX/APLJBjkHu8cIQYsZGPbKM/WrI2tR9ST5niHUx/R2k8K + kvMOhyp7kMmqIDnvqGUrAeRbJgVA8no2Jq9oqGcVbB7v8BFHxy8ByTVWCR3akQqqvYl3/KPz66UJ + 1N7EOxw07UHZVnp0bu59x78gTJKEaaP+nXw7y6X2cHdMvKM+W6+jZp+tOd7Riqn3Ea/ymt9GddT5 + Sk5rP5FMco1VwUK9fcO7Y3hHjVKv+mDfvrl4h8O36G7xg0hz8Q63fB74wEqG2vCOB3l5j3ABB7yD + 2+lhfqOVVNe/w07OEUKViZTNTQlICjb608xBls1OCeAJG92eVDHUbkqAvKF/lO35z8tKDO9wSUCM + MphG7ZQAft+Jlq3Jdgzv8KNzpIyiIHkdtT7N9PDtmWuMau/mFYhgj8926rUdBMl5R5VtRhDcTn6L + NfJqAUSOOL/FP/7oBbsoSJ610NOB8QtglNy8gkEM+JomAcqW806ynQ4yUWLKzivw7tYk5GXnFaih + BpmQYA3vaCBJNhb0xPTvcMbvCBdwVsF63kHB7lEmDdXeDJYhtQ9ueZMyCTevIIkyutozebl5BRwX + f4NQEgYow+TZSO1hJZzJcfMK2D8JIEWsvZtXwEccBFsu87gDSO49alz84p16XL49guRdeEwZH2U7 + eYdBzHQar7HZdsz7jhrq+bMSFazhHS676oReJPIqjndUJjFZ95QugPj+nfR0zvcdkcm9erYjeAWn + TDYAyW+xNQX1eU4Ccpd3+umoshneUXerczH7J8XxjnIxjP0peMTmfUdTqWTZQCYm3hl5jwsFknZe + gVLGW0+KZIbdvAIeygSWbZPTMbxDQVNIB2l9rJtXwN2atXx4p1w9TQVAvMZGkBrM40KU4eYVJDZ2 + QxBcSc47RUDmD4haNjPQjCq6YTsVL2C18wp4O/334zriFUDy3CNZtu/trB+QWVeSxztkCmr5UMZ+ + 2VgEuZW16IT+lKmAmP4dPZ32AdGVmDybuhZk2RAk5x31lFYE2QEkz7NpjroT+qYgOe/o6XR7UkRP + Bv07xdzik3cmAMnzbHrEJJMFQPxkpzRb/gbB7eS8Q49EXWPfXgGC5Le4CMjb2rdLY48IMpjPVlPB + Nk59VDuvgE+nQp+XrCTv32G3vELakJXNzMnhI25QOsJ3x+TZKB1UW+AdPR0T7zQBiU+9sh2fZ4tH + 3EchvV4QcDvexlYDQi8I1c0rEMvWwgU8TcEMID5Cx5X0oGkiEDevQJ6r4kpmBbnlPdYWUmQJiK/x + Q5DtYwoWsid2XgFb+xbsSSNls/MK+AK2EAMuCpLzzuRA3uSFIP59J72AbxCQyaCOugFIHa3E9+/g + SsoIJL/FfMSVbzHoicmzsWAruKDPcwaQXGObgHSPeiYGdPMK5NG5Qs+1nE6usXx36lec7MQgg7oC + BzKjM/z8eWvCRlD7mcs4z583KSOml2UlOe+oZSsfwVZRNsM7LJMJ0kECkmvsLiAxaJLTuVdXMAXX + IjkdXzOMK+nBNRX2PH/mNnaXlXTLxn7sfrN/R3kn6Mk2qitICf2d+igAksuEfTah0QYg+S1WQu/m + sZEp2FyejXOPHwasuxC6m1fAz1UAwoTu5hXw8zeALAriq1LLiEYRxOfZHBcn2/F11PlK9sstRxDf + v4MgE4IsAOLn5FRDo0XU3sQ7fAFrSGBuovb3+ndqDVkLyvhVO6+AneEKD6wMYt53VGPLB2SVu2N4 + RwXb34vZPNp5Baps/UGE8mzVzSvguaBAGRzvuHkF/MAKhlpNwaCerRkQVfu/m3deDIinc6tvNHDx + Sya4klu1W0oZcAEN77DGxhiwnIa2g7h5BVKK1sIFnM4UF4B4Lna80xTkVh11CJqK2BM3r4BH3HSN + fefZAGSQZ0MQsvYTgPjub9STbmMPBfF11PlKdrEndl7BKivpMklAfB11SdX+dToNQHz/jgvzOc9m + 5xWoeezZLeZiN68gCWn7BayisSbeYfJqwRTMJ5cCyN0IPc6YYpncqyvohH4+xLNMDO8oSPxwAAYI + bl5BIljqwgM9MXXUTKMTP5wVAPG8E0HmoLHMO25egdBoBNG7Y/JsHAP2mbqvBxGUiZ9HXQCka+yu + IL7jDAXbn3o34h03r0DeMuLpVOIdN69AlG3C04G74+YVJJ5Sz7MxA9p5BZp77M8Qi67Ec3Ee77wo + o0QQwzussTHyWhXEz8mpGe+8zWMFkHt5tk5eRwbiu/BSZXv+8wri57MhCAVNCOLrqPP8Sc224yfZ + 5o6f5tncvIKEMiZcyQQg/0/eAbU3faMcSMZkXRO1N/MK2BTUYE8WkYmZV8CWrX3FiYIYZdh5Bd4r + mOTR2c4roB6E4Ja/yn3hdEzfKBN6T5E1LjGqbl6BPIhMXNgDGmviHQ2ayNojiJ9k20YrAaNkeEc9 + 6m6UdgXxebb8zUvzbHZegebZ+kpOa78CyK05OXABq4J4Lp7h7hxxOwzib/Gc3Z0r3gFTYOcVaIqs + Z0ELOcNuXkGShOnbWRTE1xXkp1MlC2rnFWjevpMXa6ydV6BH3AWbrORWHXWXyUWjLBM/UXBKbWy5 + rD2C+Mr/MJIilAS83ndwO74Cc05BigTXdl6BgnQ/9hC1N/VsRUC6npzKtgCI19jVyGQTwea8I4Lt + xU6vyv8ZQHyn82q4eBHBDvpGt1RPXryDK/G8g/akv+/MupJb89kCF58pMhbsvTxbNNTJ6fiOsyk1 + SlWcHDevgL9AB5aNV2LnFdAEMADhldh5BUxeFYsT9niLh/MKcCXdoz4vYAUQPydnHq1kiiD35hUA + SCFT4OYVJOaxW3sO39y8gjNUSbfzplEE8bfY0SinUu28AvbZotozF7t5BQmN1hHIXU+ppw0nlck9 + jY0gyencywzXwDucrHPzCuR0Yo0fB9duXkFCXlsEAd5x8wrExsZaiyoyMbyjjl/5gLCT4+YVyHZa + CFVUYwe8gyBUxAKmwPAOX8AJCZ1BfKczhm/9dA7djvftc5CaqP3t9x0IVcAtd/MK5O7E5yrObg3n + FaTPEJfPBhpr5xUooRN5Ici9V1pKkW3xdNy8AskpxTf0k4tbBLnJO/HNa1WQe3XUHfC4GHAGkFtz + cuBphmPAdpd35IhBT27yzoTmEdS+3ZzPFnLUVax9uzmfDW5xsh0f7zjBHgqSV6XqA+uCMsHT8Z5S + zsXtusUgkwHv5AmHJullO69AfXuIAUljB3NBnbVXo3STd6K153SQm1eQgHTf/tDt+EqYGTS221iO + 0N28Ankvnvn5G4/41oSN2r/n9VoJCtZH6G4lnN1y8wok9TGzMxysvZtXICUBc3CGN1qJnVegKfcF + t4Mr8XXUDuTknR1A7sU73Z6c9WwEMphXMJuV7BS+uXkFyUq6edwUxL/v5HfnBTIDyL26gjmUXRWK + Ae28An6amcMtZo218wqYMpavOIJPQHzWAkG6eWQudvMKkpX0/AlThptXIDJZOEUGam94R7m4n47K + ZJBnwyPuUwI40e3mFQgXz5jUJT0Z8A6CQIqMZDLgnSm19k38EzevgIdah9NpkrVw8wqERqOeHCoT + zzu4kk5e7Cm5eQUSSEYQ9pTcvIIEZEGZ4Oncs7HxFlcySm5egVj7SKMJiI935vTuvIwSgnguztW+ + ZCB+hgOSF3AxBE1lVM+G1r53Jj5bPOMRF8c7nOj+kNcbBFdya6o88M5B5FVcXQFvZ+bk/wQg+S1W + kG4eJ4oBi+MdPeIuk12OeMA7uBIoz2OQey+SEzt+CHLPe4yuxaQg9953YtZik9Mx8Y7Gxf2IOb1s + 5xXo3fGpDzev4FxJfFXp8U5LBDt439lgJQ1lUgHEv0jmjt/LsqFMco3d6QLGCJ0dPzevIHH8+kqa + gnjffjE2dtfteN9+zi5gagoG30FY07vz8tk6SHHzCvjDAdAYlYB4meBK6HQQxNcVrKCxvexqRstW + 3LyCMx20AAhYe1qJiXcmWQkUY0fKKMN5BWnW4kqRbcHdKnZewSwr6U1AB4Zvxc4r4JXEeraCt7i4 + eQWnTNIL+M74IYivZ9sMyCpHPMizHaPtIIh9pa0lM4+XYBkk19gmK6E3LwTxFZhoY3twPQnIoJ7N + gTQFyTW2yi0eguQa+1zJDiDdU9IjNrzTaCUz1m4xiK+jThNTbycHQXKN1aCJ3kZB7Q3vsGAX1pMC + IH7CRhqqvF8kcTteY6dsO+kFHNQVpIGkvmUUN6/gXEmewNS74+YVJEaJai0QxGct0gDhvZIKIP4b + rHmKrMrdcfMKRNmEixHE32LX51VJ2dy8ggcHCLFAvRLvuHkFSQPd+3clLzev4KHF2NBxRqdj5hXo + q0r5gKwKktdR60tTVzb2T4bzCtKOs/fdmQDEv+/k5CWRV3HzCiatcCC1XyOImVfAtzh6SrqdwVxQ + rDakpxkQrOnf4TrqWNGtd8f0jY4K1On5+wniXyTRBa24HRSs95QQpIf5sxzxoG/UgVRR+0Eddbod + Lbt6gnjeWTLBvvUEQbyntGTK9t5OsGx2XgG7FjXklDYF8TLBkkXgYggQ3LyCIUiyEi8T3E7v1lSQ + Ae9EkDjQbKbT2RzvFAfytrG4Es87rtx3UhB/i12xk56OiXeY0AvHgDuA+C483A4UCjKI79/JZZIK + NuedGbcDA1cTPcn7d/hrsAebxwYged+ofr8YJvbE7Fax8wp0NH33lAqZRzuvQMf1d96psp3BfDaU + CYVvcHcG89lQ2coHJJGJ/w5CqrFvkBVAco3lXEFhtxxX4r8YhSCed9y8goe2mbx/zy5gzjvJ3dlG + ILnGar39iiDBnrh5BedKNmNjJwXxMkmL9rUUrbh5BaentGWnk4PkMtHtUHZrjyCD+WxuJWyo3byC + czs7XMCeItPTMbxDRxxmL+9c4VDcvAIWbJ9HrS9Nxc0rOEFWY09mFayfdrVmNvZyLeLDWXHzCmQl + +9cxAvEauwFINwWrysRrLH6Xtvv2s4J4jUUQ6GClIza8swxA2NrbeQWU1IUv5M66klxjFwGhXAGC + +MlOqxGsmoJBni0/HakOKsN5BfnnmJvEgHZeAWts/Fav6smAd1ZzxLOo/YB38tN5qf0CIF5j8+28 + TEEgdDuvQGUCCUzYjp1XwF8hX4OntCuI7/5GEPDtGSSXCZuCNXTNsFFy8wo8SCqTAe9sAFLwiBHE + Tx2JMllwEASD+HgHQRZcyQEgnncWAKkokx1A8uog/g7CHCiDM352XgF/FCyWcS50d+y8Av7URSzj + XOXu5Lwz8XYmNo94Or6uoABINwU7UYabV8BpwxKTupwOcvMKeOZ/AGn8daTi5hVM/LX6mBk+t4Mg + Pt7BlfQYkONiN69AAsk4A/OQ0xnEO82cjmqs4R3+unTM21OhYHHzCnhODmyH/RM7r4A/zhLf0E+N + bQDi5+QUA3JewLAdO6+AL2DMPTa6gHZeAX+KqzF5LQCSy0RX0lAmuJJbXXiFOuJB2ey8gkIg/fdd + eMfOK2C1ryHeYf/EzivgT7ZFmRSRyaCuALfTM8OLguR5Nj2dN6Fv4lq4eQVcMVV6Une/rP0MIHlV + KuVPSswVVAXJp8qzM9zv0StXAHfHvO8AyOM44kd8DlF7MxcUMjknCLRoEYipo+aV7CGBySl3N68g + WUl3LRoxoJtXkMiESkdwJf57GVO2nXeuAI7YVC8DjZ4gMHkS3C03JQA9pROE0oZ4OjfeAb9BNuyG + 2EiwuZ7sJJMNy2mAMtyUAPw60gkC7dIM4r8EtABI9+1nujtuSkA7aCVr8B6rgniZIEjPbrE9cVMC + piYg71u8XzJBkNxnmwcrYY11UwKSlWyflRwKkvtskC0/QVaUCQg2t/ZTExAYesAryb9dNQ1AVE8G + X1tLQd5PMwjio4wIsoTUR6ML6KYETGzZVuw4o7tjXvOhZDHqyTtUWSKIec2HR6J4d66cEslk8Jo/ + wy3umRzOKbkpASLYHRstdxSsiTLYKEXeWci1cFMCJLtVsGuGZeKnQK8AAl/IZRD/goAu6Fuwc3Y6 + t15VSvycEFeluikBAhK7eg/RWJPd2gQEysLXGHm5KQEPah8osbDnacniEbspAe0QkH4Bn8VNUWPt + lACqrINAspIpcFMCKj8mThy+AYjhHf4s5sy5xwYg976ZuGA0yiC5z8aB5MLVywjivy4dV7IOXIs2 + mgI9AQhUfbBgfbfmYkBmXYnvQZgBhPwTXInv1pzNSvTuDKbToEw6eVVRexNlFDri6OSosg26ZvCI + oeGFZGKijCoyoVqLBUD8VLQok57gPSRv76YENCp20uT/BCC3pgT0B5FU2UwV2SErod43FGyusZz8 + j88QyenkNrYICHychUFy377Yu/PKnyCI11j3gvC8n9EFtVMCvjW2onmE/p010qidEvC09kdmYy/L + BuRlpwRQS0X51JZf6SAGudU18w3yFux2mccSQQZdM/ggcoxAfNfMBnpCEXoFkFtdMwDCaj+cEhCV + bQ+Crbod/7W1BUC6eUxk4mtBVwDpp3MoiJ+piyDlAYJFEN/ntRmjVBQk11gF6UaJecdOCbBvo5eh + JrUfTKdZjLXX7QymBKypTPZrJbAdwztaV9AzfrOuxH+XFlfSLdukIL56eTcgq4L4rpktE+zbt0eZ + +Cqy9BZf4RuD+En7E6g9vUjidvwLQlzJEWRSdCW5xnJ6+UAa7SDrs6ZwQBkIAin39eOfXCD5drQW + tIMAZVwg/gK6cbiLbGdAGa5ksUQ/9gLx5TT4rV4qxi4A4i9g+sHft1uOIL4ALP9qcMlW4j+zm34P + /brFLNj8Auo34oEBGeTeKKS4klm3c2uQZijPezl+CJJrLL++HV9QKs8gvkWrAggFCGsEMQ/x/FwV + C4+b3J1BAZgDKTG7dYHc+jB0qOiu6AxfIDdSZHCLqc/rAvEf6GzpLX6tZAIQX7KYg7zuDm7n3qf9 + Cr7mk9obytALWD4gqxglkyLjkJbUnkHypO4qIN21mFDtm2vwFz35PFddbvkaTqfZBn9+iN/DC8Kk + IN7xQ5C3k7NeMkEQPx4qgnTffr1OZ4kgZrAMqX3ZPwy4XjLZAMSP6UCQd/i2XMq2A4gvAMtBVvQe + LxDPO8PtIIjnnQaCfdvYjdW+uQZ//uxUCPO3y7VAkJx32FB312tjr6DZBn9NYHaZJNvJEw70vdFe + RfY0aipYn3DAKrJ+AXfR2MFDPOao4ZOypLEmRca3eMbUx4YX8N4Ha4JMdoy8LpBbn1gqcRAEvHld + ID5UyRPdr1cVFKwfOZ4f8SveqQCS21h9QYCsBSmbSZHRh41C8n9n16INe/OxnGZ5OD1xvfmNS9Fq + SDjsCpJvh+1J9KjPW9wAxFc4TADyvjvrZWMrgPjaLQSZPiC7rMRQBvDO+Zi4oUxmALnxqnKCQAJz + DS5oc735jV/zIwiTl+vNl0R3CTZW9cTMIuMuvBLMI5sC15uPE8DO7XTzyGrvevMrF/b0iqkN87EX + yI1p4SdIZ8BZV+KdnPTRORds/jYKhvp8/n6DvEzBEkEGlIGFPV1PZtHYwSyyxYDsItg735qB7WyJ + xg5mYCJIQ5ngSvyrCtYV9Hzsoiu5UW0YK+v40fkC8TP/a6r2R2JjTW++VtZ1G3soiH/Nx+3AB7BY + sDe+NUMrmQnE9uazxh6Ye4Tt2N58LmI50LVYos9me/MhHwvW/mVjG4D4V5VmKGMSkHvfOOv1J0/X + hIIm25vPqdQSCL3I6dyb+R/KfbdL2RDEz8DEmuHux1Y54sGrSlprkXhKtjdfPeoeSPLdcb35PD2v + l468Twdl4jUWV9JLoPkCut58nh9bpnA6bNlcb768ebVAoxyqbKPXfCxief++i+O3jb5x5rZziNqb + UIVT7i3kT6BM4gLxMzARpB/xrDLxU1uXVGPVU9pu8Q4ECBqhb656mcskYqiiF3Dwmt/MSpiLt9Fr + vjMFiwr21jedIWhiENebn6ykB01FQXz4huV5/YgnBcllwi0VNYQqz5bxeMSuN79x6UiXjwZNrje/ + 8dto4SNGkNx75ObTPuLmlZgCmZh4h9+Le8PLK3ybACTnHQWhLOgMIPkt5lEDNbjlVbfjexC2+yC5 + xvJKSlD7qtu5MbUV/JMjk0musefLT+azvVPuuB37daSKbvnbBW0S77je/BME+zJgKhpprI93qnNB + 2Xt0vfmynSjYRVdiPaU4oZTbkUjtTbyzE0j8ZiIn/21vPlc4xC9GNdGTwTedo9rHjF8C4j2lHUB6 + 0DQpiK+YiiAL158giPXtK5a2dsGuBOJ682UlK2dyFgDxc0FxO/0dkMN815svJUb9pF4MOAHIre++ + QYnRs0IquhauN19c0C1w8UEX0PXmS2FP7PM6t1MAxGctsEyiJxz47ri2evkUVwzfVE9MikznKfWV + MGW4tnrOx8JK2FC7tvrKntKBFd0Mkicc/o+SABasT5Hl29mFvIZt9ROAdI3l1zfXVp/MIqOG3Aog + fpxLMyvZyLe3bfVaxLLGlTBI/g74pKw4XDROFFzldHLKmPgNvTIDrgDiC48dSNHT8eYx/5T5azu4 + khtJXVjJlphHTxn599DfwXWIi21bvYKsI5B7n8WsIdHNwbVtq2eQEtxyNo+2rZ4H8/bareUCKRHk + 5ufJ+hixJ7Uj79i2et1Of2mqFHnZtnr+rEP32dZL7XE7ecJBQeYHCBaO2KTIdDsd5FAQ3/CSn44+ + nNm2+iIgVBIAejJ4zV/AxnavoOpKfMLhLqHbtnrOn+zsgsJKfKhC/glV/i8AcuNppsYCdU2527Z6 + BaHXfATxSd0VQN6/awJzvvl5slBitEkMaBv89Yh71cdBXoFr8JeMX+/R0ISDbfDnZN0R0oZN9cTX + PSLI9PC3ePCZmFztX5UwwSi5Bn+ZOtLrqF/ZLQS5Vwu6czlNBZB7ie5YAJaAeJlEP3YN5KUyMbzD + b+gr1rNBqOIa/Jt2Jr41dpF4xzX4y9ytNWjsTOTlGvwbv6qs4Rmi6Ep8ScCcruSl9ijYGyUBtJ0E + 5MYDK4GwH+sa/KXacAkMyIlu1+Avt3gO7hY/iLgGf/7GWajdeoW0oPb3PscckjAaF7sGfzmdiZ/w + ZgC595g4fcE43BU11jzN6JsXvWUsAHLLU4J6tkW343lnBZCeDmJPyTX4CwPG7FbVI/a8g6185QGC + xZV4G9tStX8JFvXkXjoodn+zb+8a/IV3lhDS7mSUXIN/AgI9kgzivUcEgbw9g9yVSWfAXWRyM0W2 + fEExNq1k0GiJbbCQmIKgqbl4R5vZO42egl0AxI8RQ0KH8jxeyb2SgA3tCcvkHu9Et7wQjbZRvIMg + /QJyDNgM70iB+vYFLZ9wi9uId7AYm14QULC3PqoOIHqLDe9oWXg31EzorsG/0ldvwhFv8jTjGvzl + gTXGO2webYM/l0DvHEiCnhjeUT3pR9youcM1+Iu7dYSsBSemXIP/+UdsM+mRFxP6sME/7a56x4AI + 4p8h8nzsltjYe/FOSDisl0cdTsc2+HMvbU/qLqJswwZ//PpAj7x4O8MG/ykFea0Et3Pvo+olRBmL + gAy6NfPk/3bZWATJs+U8DjdW1rGNtQ3+7JbHSl3O+A0b/HMQJa9hgz/KpMeAp0xWALmVZ4OsRQJy + 6+O2wZ6sQui2wZ/dcmpH4tPJNda/A2pw7Rr8pfI/5pQ4k2Mb/Lk6aAv5WLb2rsFfLFvcDrugrsG/ + scbuHFyDYA3vcJgfq5fVnpg8m3acUU4JBZvzDvfv7OECcqGga/AfbCe7xTnvTLoSmB+7RAZ0Df6N + m4B2LOOkC2hK0dR7JD0JIMWVonHb2oaVuiATNyUgAYFUKoPkMmFPaQumYFMQP0izGhA2SsWVonFl + 3Yq3mEHysYTsbq3BU1rkdAalaJhTWkYr8Z/FRJBuqJl3yqgUDbcDt3iJt7i4UjSd+b/iSiYA8aVo + CNIZcNGV5BrLRqkDvrKgKBN/izGT0/Vk0yP2Y5Ndsm4lG+umBCQrIRtbACTnHQXpK+GgyU0JSLbT + T0eN0iDeaelKMsEa3tHc4+h0DO+wKSBlgxSZmxIwaSannw7n2dyUALEnEeTcTgOQXGM1z1YecIvx + iHON1Y9udHuy40qqmxJQtauXQGYA8TFgSY94YaNU7ZQAJq++khTk3rj+OdQVkD2pbkpA5a9URLUv + spKb8c6MFQ4M4rPl+XdVlstQI4hvZHAgiUzuZS0WDlVwJT7ecSAFeafaKQF6xJR7BLUf1BXMALI+ + Bkec32IuCZC7g4L1UwLugwzqCnIGFD+2uikBiSnoYT7lY6ubEpC8IMBTL6/Et3y61zfV2MF0mnwI + 7ZYc8eDzZG4kRVOQXGP9JNuNnyGqnRKgK+kMqKbA5NnYKK3BLW/IO9WNGhBlW79g6giAuFED8iIp + 3iOC3KpnAz2ZyJ64UQOSDlrCBSRCr8NRAzWVycIedXWjBmR20MoZvxlAfANdrieLELobNZCUSXSf + rep28lvM+ZM18A5bezdqoLKTswWZLLodP+vDRaNsCtyogcZTRzZ2/EBjB5+JcdHooSA57yhIz5+c + t7gCiI93mjFKlC1//vTDMfLtvF4kFwDx8Q4mHKhUHvTEfJ6MfbbNp8jOn7d8+5g/KUReu4t3+ALG + BGYVZTN11JrdgilGdHdMvMNj2HfOFSBIHu/4tKFUBz1/pho78RNeTBs+q1AJ5F5OaQ/W/tl1FzXW + jRpI3gHB8WOQ/BZ7kNOjhu24UQNC6HuId3a6xW7UQJLUfa9kvo4YQAZ5tvwFYZZA0o0aeKiy9Riw + kbK5UQPyVb74llF1Jf6zmPjS1BnwUBD/wZp8jt+Ld1Cw93jnCDKZdCW+OigfBpiezr3G7SNEo0/a + jJZtOGogX0l2dwzv8Gi1I7gWu9wd88EaFSylUkHZzAdrtDGqr4RtrBs1MPmBq1u2Ev9ZzHz065rc + nZx3OLsV2kwytTd5NnLLa+UkDILkvEOnU2P3t94dM41T+3e6YNUUmHiH1L63Cb9tLILcmjxZ+5cK + z1v8vDv/C5bbrJy2JAEA + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['10788'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:42 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 14:27:45 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_ocean b/siphon/tests/fixtures/ndbc_realtime_ocean new file mode 100644 index 000000000..349d9cd67 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_ocean @@ -0,0 +1,268 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/45183.ocean + response: + body: + string: !!binary | + H4sIAAAAAAAAA62dS48l21FG5/yKkhBDNzvfeYaAQR5gfAX2wGNAeIABgUDyv+ec3JkNVbmiYoW7 + LLvb7rq9HDv3I+KL2I8//e1v395++cu3n//87Xe/e/v979/e3n7+1z/9+hdvb7/69S9/ev6vv/rV + 3/38+ds//MXfPn/91fhnz//89NMvn3/+t8+fvL39+jd//5fPH7z99IvXr3/9iz/50z/859vb7//9 + 7Z/+8Pa7/3z7/b+99X89wf/0z//yV8//8g9//o+v/5f/+K//Pn7wZ6///h+vP/nvf/nzf33+9je/ + /s3xg58df+1//mRsw/7Wnv8e3oblrbXjh8O34/en4f/32/PXoa3flre3x7dl+n8/eHv+s/u3ae9/ + 8g44v00SOFtgbuF8AEcHnISFRaC1UH7DUX9DDfxiC4evtnD46nHYhIVrDZhbuBWA7SEs3Aoz5QnM + LdwrwF1YWARaCzcH3ISFjxrQWrg64JpauH0bKhauqYVF4CIsnGrA3MK58g1zn7Kdi4MGWgvlwM59 + yvUNwadsCLQWwmpDwNynXBYOFphbWGpy7lMuYLNAaeG8O2DuU8pA2cvzIwM+V8LhbdTjMLfwAtpv + CIsDAc04LDVZj0NroRmHcw2YW7jegD/rwBWAZhx2C2E9ZKC10AGHPLa5OkUDf2AuEzCPbS432lQv + D3lso5evDsxjm0+cFAOtT1kcMI9trgjWzZQhj22KwDy2uVQAjEMG5hZ2oFtgC3pZWmj08lKx0Otl + 2SlGL3cLnQtQevkI2tc0FLmAMsZe5UzRPmWFJu8IzC08ZsoG4RwBtU8hC6nJxqeMB9ANG6GXL6Cb + KUIv13pZ6OXLQg2031ACtU+x39D4lMPrrc5Jeb28pjrlAuYWtsJqI/TylXNwC6zSy63gApReHgqO + XunlsRCKKL08OPF4AXOf8nDytgO1T5FKSujlItDkYLca0I5D2SnGp7QoJIagXejlT3r5BmxOL49R + kxloVYC00OdtpIU6tqHMEgFNbBNm2hcE2l6G5YssNLWAIvBrLRR6+RI+Ri83o5c/ybQT0NQClggI + vSz0chFoagFr5OgZKLXe2hzQ6OU10inUKUYvL1H0RUAT24QhMQNzC4co4CSg0cstkhUMtBaazFJz + enmKpBkDcws70Pjl5vTyoQK2tLhwAXMLO9DEh83Vl4+ZspmQuBXqy5sJiZurLx8L7Gair+bqy4dP + 2YxOaa6+/ChY6PXy3u7AW86hOb18DJs93YlxAWUEa5ts9PIxDve0UHgBcwuPTtnTUmYHGp+yFOay + 0MvrmXOAcQjLl9DLS2+ydAFCLy9nus95PaGXL6ALiYVeXno4Z4G5TylamPuUq1MkMPcpF1B2ivEp + rQI0PqUItBa6YEno5Vr0pfRymDL9CBwfRi+foYiJvjpQxjYE/Bhjv4A6tqHli4EytrFAMw6LQBsf + Ngc043CsAW2M7Zqs9PJQsFDp5Vax0OjlVrHQ6OUWyQoC5rHNuWJ7oLVQJIJeQBPbFIHS61mg0cst + khUMlCs2RbAENHp5imQFA6WFpAIIaHxKlxVyHBqfUgIan9JqQDlTLFDHNh4oZ4rtZeNTShYan9Ii + C+c7UOnlcNgw8AfGIQGNT6kMbLUfuwQ0OdixBrSrjQQan1IEyuiLkhgEND6lCLQWyiYbnxLmbRgo + Y2wL1HuWbJP1niVroT7j44FfbKHOwXqgrKdYoPEpR5pld+Gc0sseuDu9vEf5QwbKLPFuAs7d6eVH + xUK9z8F+Q62XKYK9udG9opdNSLw7vexXm93tx24H0KiA3e3H7kCTt9ndfuyShXo/NiXGGWhXG9cp + qr486ZB4d3q5BDSxzVAY2Kq+HFZ8CKhrASpo341eXs5CoVschF5eznoKACcE5hYOUSmTgLlPmc8k + BriAEYGZhfO5lxhcAAFznzKfKzZMPQbmFoY1+gGAuU+Zz7Qz9DID7TcEr0dNzn3KcjopaDINm9yn + LLGjB6DSy2O0YsPUU3p5jGIbAnq9rIF2PYRvSEDjU4YoWGKgtVACtU/xwC/uZaOXj6n3aBYoVYAF + Gr18TL2HC0X8fuyHC9rVfuzD6z1c9KXOL08VC/W5UQ/MLey97EJidX65CMws3L+9Ng59O/+xFGj2 + Y/dxKLa6dWD+DUPgrVM2o5f3b4Nu8ub2Y/dhY5avrXB+2QOthZAVIaAZh2O02jDwB7TeLXLYnF7e + o8iBgdZCE7Rvrr4cWgjf0O/HtkCjl8NOYWD+DYfoGxLQ7J0btRvd3PnlElCfNSMgDRt9N4u10NzN + UrJQnzWzQHPWrAj8YgtNbFMEfrGFxqe0aMVmoLVQAk0O9hE1+SZvt8J+bKVGt0J9eYPoi4G5ou8b + Gk0SYzN6+QLCNwQLhV4+M0sWmPuUM+dA51MYmFu4R/sPCaj3LBEQFlihl4tAvWeJNjQyUOplyn0R + UNeXPTC3cI62uhFQ34lB+UMGSkVP2TkCmrpeB7qgXdWXSxbq88seKH0KpZ0JqHUKrdgMlPGhSt1v + Ti8XgTIrQjWpG3B155e9G12dXl6j7BwBTWyzR5XHmxtdnV4Ok2kEzMfhfsbYJnW/Or28R9KMgDpv + Q9+QOiUfh/uZc2h34G3qrUYvn9+QLGRgbuEedcots7QavXw12fiU1enlcM8S9LK/74sy7QQ08tYv + X6srBz90jL267dN7VBulJht5G1bACahT99ZCLW+prkdAE4qExzwZKN0o+RQC6pQp5b4YaFP3zgWo + 67nWaD28lYNXdz3XGrkAAhoXEDaZgfkCO0SpewAKebufOQfoZQbmFvZ0n6nRr0bevnzK0L4NrpeF + vH2KqBdwhGCpATB1AU/W/AJO8hum8vbJWl7AGYYNWZj6lGF4dsqLCosDAzMLh94pcCpzfAAw9SnD + 2Dvl8a5ThgN4KyGtQt4+gUdN6v3yFQNTn/IEHr0MMfb48ch2B+YWbgfwPpfRwtSnDFPv5fe1gN5k + CJZyeXt1yvucQwxMfcoTCMOmAyE+zOXta104FgfoFBqHuU959E5pcoHNfcrjLKnL9TD3KY9zgYXl + i4H5iv2ISkg34OLKwWHamYG5hVsUihAwj20uoOnlxcjbPT79QUAzDh/HOIROaXdgHsE+p96xOEAo + cl9tFhHBPl3A4aQg3Td+vBOjA3OfciywkNS9z+VFRLBP4BA5KbIwX22KTU57+QmcasDcwgMIOyTx + G6arzRU5QGI8AOYWhkBoch7BXp1CTWZgbuGxgQduCkVgGsFe4RxEXwEw93pzBZhHsGeToYR0j20W + F8Eejh6uiUNgHsG2HorAdYUBMLfwmClwyyUC8wj2Wm1g+YIFVkSw50yBagVaaCLYZ5OfP4XV5hZ9 + LS6CXQ8gWEjA3KdcQOgUBuYW7pUm5z7liLErQGVho7MVCMx9ytTnsgdmFk6nNIMFloC5T3kdNHhN + F1hgb7JiERHsE3h0ygCdcgPOIoJ9Apejl42Fs4hgh6VbOMLydcvBziKCHZZuIQkfsjAfh6/DGq8Q + rDkL83H4OlvxajKsh2RhPg7nvnzBTaFoYT4Olw4cwY2Shfk4PDsF8jZkYV6guSyEe4nHW8p0FrWA + az2EXQQIzL3euR5ukLdhYG5hbzJ0Cn1D4/WOJlM4d1u+ZqekHgfQeL3ZKKmxzxS4RpjGoVBSY5/L + CySCqFNM3uZo8grJNOoU4/U6cLgDqcn5anN+Q2thvtpcFm4OmK82l4UaaC2EqQffUCipsS9f71VA + aKFQUmNfHBYJzJXU0L/hDMOGgbkKOALOAeYyfUOjpI5OmVwvCyV1NnlyA1soqTPGXjQw7+WlsNqo + WkAIJAtznzL1gPMB45AszH3KBXReTyip6eWkxg9KKgaaWsDRyw8YhwzMLTz88vukbgzUSmqHWgAD + cws7UC4OUkkNHzbjfQa00RcMGwJ6nyIXWONTeihilq/JKKmxz5T3aZbPgLmFJaCJbZYaUEZfs+mU + ySipywW8s7B9AlR5bJZmBDRZ4iVSUgzMLVzvFobfUCip8xuOxqdMYqtbr1YMZyouB5rY5hg2A6RM + b6HIJLa6fQcaWTGJrW6vXOQBbBaossRPILgAApp9Du2eWfoMmFu43b9hDMxjm9bjQxo2DJS9PMmB + ncc2J1DF2JPRyxfQuNHJVR4PRz/DsGHgF1toKo/dQuPoJ1d5bAWfIvTyOQ4nmCkM/OJxaHzK0eRJ + dkruU2pTT+jlc3EYoVMYaFcbt3zZyuPHxHiw32aq6GUJND6lV3ygUxgoLWyQGCegqTwejl5VfCZX + eRyjrW4END5lugNjC3OfUgTmPuUsWD/ksMldQIs3492KrZORt2enwH7se7F1Mie5zg08cJIrAGZb + jM6daZS6J6De6qZ2Ykxuq9se7cQgC81WtwMIRxQDYG5h3ytigKPZ6nYC1T6H0Wx1KwLNOPQbJ0az + 1e0Cym9oxuEBnGWTzTjs26fNOBzNSa5HX2080PYy+BQAipNcj3M3CwhwBuYWToVxmMvbCyinXi5v + r2+oFofRnOQ6V2w4QXP3KaO5+eRcviwwPxp2WQidwkAbiphNoaOTt2O0p506xYQi3ULZyyYUadE3 + ZGBu4VCx0MQ2rfINjU953I9CxEDjU/rJBedTxNGwy0IJND6lTz2zd24U8rZqYS5vr16WK7aRt4M+ + nzI6NToWZopSo1NhYCs1WgIaNVoE5hbO9yM5MdC4gB4Sm93Oo7mo5NIpZrfzaC4quYCw2jDQWggD + m4D56eDrG8Jcvu1pH0319px69hsaF9DHoTkXMDp5O0fDhpqcZzjPPe20y5SBKvfF35CAMsPJCywD + VYaTHT0BjQs4LHxAHpsWB3224gHVihtwMNXbCwg52Ns4HEz19jwXsEugGYd92JgkxmCqt0OYCLof + vBpc9XYJVpv7sffBVW+jBRaBJtMOxzw/A+YW7kFmiYCqersGavR+hcXgqrfHAjvffQoCTWxzWDiZ + S9gGU709o6/RXN86OHnbj71LC428Pb7hYC4qGZy87UA3DsXNJ4/zdLC5E2MwN59cwPvyFQAzC6/r + F+61APyG5mLPRd+pO5ibTy4L5Tg0p4NbdOE2AzMLzydjtrsbRaB+5Gu9lzIDYG7heL9dMAaaiz0B + GH9Dc7HnHN0uSEBzsSd8ww68lTIHIW+/A839h4N7CGONepmB9hu6XlYPYfReNu9WDO4hjEXfcjkI + vfz9G8pOMQ9hbIVhoy72DJ9LZmBm4XU9l3nRYDB6+bx0iMI5BuYW7tF9X7ek7mD08nmLkXqganAP + YWzRbQkEdA8QBDdOMDD3ekvkpAhodEqPbaCXqVOMXj7iQ7oWCbSe0Mvn9QsUfd3k7eD08hg1GaRZ + rpePtPMbPyZCTc59yjkOaYG9dUorPBwJdb0AmFt43CsC1dt7k1vh4UgoZQbA3MJ2WNgc0MQ2xzec + zXMnrfAQBjWZgPohDA/Mvd4j+oYAVA9hbIVxqMrB/ToaNw5VOXiLbjG6LQ7NlIP3+ME+slC/CkFT + j76hcfRH5ECXsDHQWgjfkJqsX4WAg6hoob42kywkoH4VwgPtN5SdYq7NHCsWmgV2qlhors2cKxbq + azPtsNE3J8ORbRzY+QJ7Xs9Fr0IAUF2bGb65wEAZcFIoQkBzbeYaPZHAwNwFtOi9AALm4vG8Js4D + 5Te0wFw87qfWc25UiMfzOmslHpsRj3t8jTBZaIqtLdJ6BMx9yl5Qo82Ix8eZ4ZSdYsTjEr0KQZ1i + xON6f8QhyCw194pin8sAvGWWmnsVYrq/QRMDjU8Z7it2kBhv7lWIdvcpMdD4lA6E7BwDbeQggM8A + W70K0f0yJCQZmFu42G/4AppxOFWabK7NPL7hKspwL6B5FaJFfpmBNnIQT8a8gPk4PK8eJSf1cbXp + wNzCPcrBAlDtJV6iN2g+LrAdKFdss8C+gCa2CZO6DLQrtvDLL6CJbebo2R0GynFogSa2mSqdYvTy + Ixo2BDSxTasBbWJcDhtdbJVzWenlPRqHNPWMT9mjXmag9CnUZALqhCQJH/qGpti6RFqPgCYhCdHX + Z0Bb5BJVsxdQJyQ9UCYkJVDo5TP6MnW9DrRluOaA5mVe/RxeB8qsiKk8voDmpaFw+WKgXbFdbCP0 + chlok7riObwX0PiUsQb8AUVPQKOXlxpQxoeUGCegvt7fWmj0cgiEBVadvW01oM2KuGBJnb0dCpGD + OnsbxtjUKbrYaleb3Kc8/NaO56/q7K1fbXZ39jZMSBLQjMPwsTkG5hb2B6rMwN7d2dv+6KGRFbs7 + exs+1UFN1uPQfkMzDtcofwhAsTm5nY7eDWyxObn5J1ZfQPeEVpBmuQXtu9PLYdBOQK2XKc3CwC+s + +LyAWi+bekoH2tyXSIy/gKa+HD6KTRYavbxFw4aARi+vlWFj9PJ4T5nGFhq9PNrKYwfaLLG0UOtl + AtI3NHp5iqq34AL85mRTDu7AzMLzgXvaHnNL6u5GLy9nYlzsdu5AqegpWAKg2py8FWIbVV8eCo5e + 1Zd7bOOWL6GX9/jkAgGNT+lAURvtv1oLJdD4lCJQaj3aB0tAd+DlBRT7HDowj77663ViI9nrV3OY + d4k2kjEwt3CuNNnolLXSZKNTtgrQ3RH0xs/UMjC3cK98Q61TrIXurqpgphDQ6JTw0cOPGxo7UKpR + WhxuFm7mMG+LN8nfLNzcYd4WWUhAs0m+RT6FgVaNmpmyOb08R1qPgXI9pFQVAfXzoBQ5MNBqPddk + VV9udpvWsAm9/L1TjAvYjF7+JDt3c6PXdE6+YVigIaA5zNvszrQOlFkRs03rBTSHeVe7M60DbS8b + WbG5w7xzxUIT24SZJQK6i0qC3BcA1R7OrqSMCthMjH1GX3Qwn4FyxSZpRk0217e2KBHEwNzrTTqJ + sbnrW4eovszAL7bQ3Jk26Ozc5i7MCTuFho2JsbfKODQxdt/TbjLtm70P1qZZNncAsFXmsrkwpwPN + PofNHABs8YEXApoLc0rLVxrbHNciWeDqYuxZN3l1MXZo4S0RtLoYOzxOwkC52lgLzTico5nCQPsN + JdCMwxB4S/et5sKcFh8aAqAqIc06w7mKkPi7ha7JeUj8fdiYqtnqXicZIp9CQOPom97nsLqAMzys + AYuDDzjVptDVBZx+2+pqCjQX0Oy3WU2Bpgy0AlwOG+Pop4qFJokRqlECmk3yj6jyyMDcwqa3C66m + QFMGyl5Wm09WU6C5etl1iijQVDbwrKZAUwbauexmihKPcE7qM6BM6tLyRUCTxPBluNXdtrpVmmx8 + ShEoQxG1m2V14nGKcrDgU5R4LAFN0L7oXVWru2111cXW1d0es0WJcQbmFu4VoAna96gWwEBroQS6 + 96TeuL7MwMzCCnBxt602XQ5enHgMS0hkoRmHDz1sFiceH3qmLE48PiqdYsZhCWjEo596ixOPa8FC + v6HRA3MLw60dBHTvmgUD++akFqdGS0B3k/yb3Ae7uLcyhwpQJ8Zp6jFQRl/klwloYptwczIDZfRF + jp6ARi+H+7EZKBU9LQ4EdA9UFQa2TozT5hMC+k3yJuBcnF4ON/AQ0BT9p2jzCQOlGrVNNno5XGAZ + KHMOci4rvTwUBrbSy+HONPApSi+PUS8zUPayBRq9HI5DBuYWTpVv6G7wfnP3cHZgbmF47xwBXbH1 + BTRab7F6uQA0erkINHq5ADR6eax0itEpoYUgfPzrJLbJRqeUgEanrJVvaHTKVgEandJ3mbqgXenl + PvWaAM4FvWwu6e1AY+EbXzBLQPMO+KT98uxeJwl33RPQ3Pq7RvHhra43u9dJwqCdgCZvM+gIdrav + kwQRLFio9HKfekanzFYvB6sNAY1e7m7UhMSz0cvnZdEWmOvl1w+CxYE6xenlAEgW6pfX4B3wAGj0 + cgHoagGFJhu9PEc+hYCuvvwCmiTG7PRynylugZX15RLQqIAX0K3YQi/vcUjMwMzCItDUl/fK4mAu + YSsBzSVsReDXWqgumC0Cv7aX1QHAik+RF8wWLHSb5L0bVXq5FRy90st9cXCxjdLLU2H5UvXlynqo + DgBOhfVQHQAcK51ifMoUAUEFqM3Jc9RkBlq/LIEmB7tE45CBJktcAJoc7BqNQwaaWkABaHKwpSab + HOyqe3lyF+YsNaCNvszUm9yFOauODyd7YU4BaMahl2aTOwBYAroLcwpNNuMwnCkAVAcAw5nCwK8d + h7le/mzq3dToJPTyZ+OQgPo1T2uhiW3m6BsSUL/mSeEcA3MLhyjgJKC5DDDMcDLQWghzmYDmMsBH + lCJgoNUpzQHNZYBFYG5hqVOMXg6Bt0vLJ6eX98rAdpcBFqae0cuPyjg0PmWoLF/Gp4RZEQCq+nKo + pBgoV+zBTT1VX95qwB/wywQ0PqVbqIF5Dra/Ye3GodLLe8VCnYMd5LBxZ3xKwNzCDnSLgzzMWwLm + vTxVgKaud1g4tjsQwjlVX+697EJiUV8+qxWDSWJMpr5cBJq6Xqs02dT1SkBTXy4NbF1fVhaOrr5c + BP6Ahbcmj66+HD6xysAvttCMwyLwiy109WW7Yo+uvjwWgKK+PJwLrAmWRlNfHrpeJgthYIv68vV2 + sPHLo6svD5Um57udzyaPJvoazengoceHo1Gjo1CjdeAXW5hHDkOPD0cjfEahRoex+xQVH45CjR5b + OwoWmhV7qwybfMUez9hGNjlfsa9vKJtsVuzwpfKbXh6FGv0eOYCFBDQrdhhwMjD/hkNhpuRqdJj6 + ejiZ2ugo1OgTePiUyewVGYUafQKPmTKZlOko1Ogw9ybP7Q68FRdGoUafwMPC2WxOHo0anfuwmUzF + ZzRXS12OHjplQKD0eqToCWh8yhBlRRgoYxtKBBHQ+JQwEcTA3MKwNkpA4wLCTDsBTdAeVisYKMM5 + C3SbQktA+w3B6xHQuIAlysEyMLdwirLE7SNwcOJxrgGthTCXCWjGYcVC4QLOQ5SwH3t8ANAcouwW + 3sdhAMwtjK7ARaA5RDkXOkXdLjhHM4WAWlaQNLvNlMG4gCl2o7dgaTAuYOyJoAkW2Fs4NxgXcIXE + 4KToG5q5vEUJSQZaCyG2oU7J5/LUgRMMG/qGRlb0JpvIYXA+JSx/0DfMfcp4qgBwAQTMfcoYOykG + 2qDddEpzPuXweuc/9nmnNOdTQp1ya3KzPiXQKQzMe7mXkGBxIGA+DsduIQlwBuYWzsHicPcpzSQk + z8WBVmyy0MQ2YU0KgCIhOZ5pFuNTmktIrtFqQxaahGRP90EES0Dtl+EbUi+LdF8rDRuR7jtPIZFP + oSYbaebdaDPpvrPiY4HuAGCwONA41OuhHdjGLx8DezF5m2bSfXNvsrpGuJl0XxmYWzhWgPl6WAbm + K/YxDmdTeWwm3XcBzR7O5tJ9c2HYiHTf6QIoOwehiNB6p1+m7Bx9Q3dhDk89Wg9zrXdtCoXVZrw9 + JtLc5pM58Cnj7ZmJ5jaflIBm88kUAanJ+gAg+GUEmsMaWxAfBsDcwrUCdK/KctAeAHML9wrQ3STP + qfsAaC2UQHeTPCv6AJhHDh0o57LZfFIE5t9QD5vn+i9fN5ad0oE/YOHH1eYF9OPw7gICoJzL5AII + qA9rkAtgYG5hV6P3nMP48aKSF9BddMxqNADmFkaZJQKqwxpLtMAy0K7YzQH1xlqaKQy0FrpO8Yc1 + PNBa6MahfK2p8A11bGOB+iAqrdgMtBaCkyKgPohqm2xim6HSy8antGjFZqC1UALdZYBBp8CKrS4D + 7MuX8ynqsMax2sywHjJQRl8gzRBofMpesdD4lEqT1WGNioVCL5972meYKQQ0F+ZMQYogAOYWHuNw + FiHxC+ieOyl8Q1MbDYN2mMvy5bUSMLcwqjwi0ORgp2jqMTC3cI2cFHWK8SlRyhQt1HqZ4sOPybQX + UB8qhx2SAVCOQ0piUJPdi1dBEoOBshZgge7FqxLQWihninvxqmBhnoO9jobBwL4Nm929vBYqKQba + cSiBfhzKJruX1wpAPw5hxWagHYcS6MehbLIZh+HABqC6DLAItL0MwI+1gBfQxDZzJMAZmFu4RTqF + gCa2CXMODJS9bJvs9n2VgF/cyya2iTZOBEAZY5NfJqCPbWCB/VhC6kCpUyi2IaCJbfoWI3CjDJTZ + OThbgUB3ucGARyECYGZhEWguA+xnzWQvm8sNlugbfixlvoDmMsAOhJnCQGshzGUAqssAl2gcMjC3 + MByHH/c5vIDmMsBwppCFeQ52Dw9RooV5DnY//TL4FAbmFq5RLYCAeQ52C7cYDbcUwV64DJASkmSh + ycF2eSsHtr7cgAQ4AbVP8UCbWQKfQkCtUzxQKinKfRHQ6JQiUMY2Fmh0ShEo40PbKUanLBULtU6h + dN8NuNmXyu1M2ZxeDrNzBNR6mfKHDJQzhcpwt/Vwc3o5rKcwUNYCKG9DQH0pJakABkqfQiqg3YGq + vhwqegbmFkaXDiHQ1JfDNAsDcwtLTXYPAxWabGKb/R4SD0co8nEz3gto6sthlhjGoaovhzE2AU1s + E8bYDLSZdhNjb/axuSBFwEA7Dt3ioPRymCJoCPzcwuffff0Abhe8/ugDMNfL23kU4t4p9xh7c3q5 + BeIRZ4rRy2MwDgOgVPS2U4xeLgJzCx+R1wOgvwyQ/DIDrZKCcI6A7rG5goXGp0wVoPEpSw0o10ML + dI+zFzrF+JRwLzEB3QOmhSbrHCxFsATUj815oM20uxhb6eXoiGIAtBa6UMTrZbt8+boeOHoCmj1L + exR9MVCuNpAlJieV6+XvifF2B4JfzvXy5VMaRLA34Or2Y09BHvve5NXtx4YcbLfwtldktY/NBUmM + Wy+v7jLAFil6ArrH2UvAfKaEe+cI6B49DNIsDMwtXAMgDRv5OLvvZVVfLgHd4+yFJuuztxao933B + OAyANsPZBNC8VH4diIYDgPfly7xUfh2IXsBCBuYWeqB5uug69k6dcts4YZ4uum51gxp9AMyb/AiS + ugg0N5/0TLtssrn5pM9lkLcEzKOvMR7Yt6K/ebroe5NhYJOFxusdnbJKC3Ovd16lQhYS0Nw40TsF + UgQMzL/h0SlwIBqB5saJfsIaLKROyb3eZSHEhzcLzdNF13U0tB4yMLfwES1fBNQ38NBcZmBuYanJ + Zhz2Ffvu6ANgvh52C2E9JKC51W2uDJt8HJ5OihaH28A2TxddFyquxgWYp4uuJq9m6pmni64YewWd + wkAZYy/GSZmni66AcwELoZfV7r5H5PVuW4zM00XXpZQeKJWUXBz87j45U1QE2ypAk1lq2kmpp4vO + JIa10Cj6rQbMLSwBzWm4LfLLDJQZTtsp+oS1bbLJLFVcgDoN1y2EXVW0fJkK+FzoFFWtCC1kYG5h + CahPWKsYWz5dtFYs1CesPVCuh6sLllS1ovtlF86p03BD5OgJaHzKUGmy9il22Oini+w3NNWKsdJk + Xa2wnaJ391HASUBTrVgLAaeqVvQY263YqlrxiBZYiL78U78UcBJQn7D2QBvbGKB5uuizYImBuYWP + KHIgoL49xlpoxmHTw8Y8XVRtst7dZ3vZjMMwf3jbIWmeLrr2fcGx9+FWGzVPF7Xz5AIUF4aGwNzC + LbKQgObkQlitYGDey63yDfPY5tyzBIfK2624MJrdfeu53+Y+U9qt8mgeV2pLeMan3XyKeVzpCYzu + dkZgvhNjDfdwttv5ZfO4UjtPf1DuqwFQ3x5DsQ0NG33Sf4WQGBYHpZeLQGuhW76UXl4qFhq9PEex + DQGNTwnDOQbmFpaAxqdMUQTLwK+1UOnlUAUwMJ/LjyjDCVNPnYYL8zYMzC2cC6uN0MuXhRDbkIW5 + T7l6uTmgvm3V9rK+kYwsJKDeMe6Bdj2UQH0ajuQtA6WSshZ6neJcgL9t1QJ9Dtb5FH/bqgXqG8lo + tWHgD+RtCGh2VYWLAwNl7kt9Q/Va0ycW3qSZeq3pKtBIC/XuPnKjZKF+6pcsJKB+6pecFDXZjMOu + 9cBJEVA/Oa308uB293WgcfSD293XgdApDMwtDHMOBDQ3yY9RLzNQfkO1OAymvnwWW1XAOZj68hAn + xgmoHyO2FurHiCmpC3NZPUYcJnUZmFsY7nMgoKkFbJFOYWA+DsPUPXWK8Snhis1AW/GR41DnYFWM + PRT0sgpFhkp92a3YXi9bC3UOlpQUA3MLhwLQ62Vy9LBiq/py03p5cPXlYxxuGigjWAs0e5Y6UH5D + o5d7k40Aly9RdgtdKOLry7bJur5sm6xPw1mg8SlT1GSaerq+vJn8oXqJ8gI6J+Xryxaob+3wwNzC + DnRuVN0e04dNs0D7DZ0b9XrZWmh0yhRZ+H6mHOuM0stDFM4x0MY2EmjGYYsiWAbKXs4LNB2ox6EH + 2m8ogfqVnDyPfQGlX5ZAf9tqHttcQDlTLNDsx26RrGCgzB+u4PUaAM3euT2aKQyUsQ2V4QioT/rT + 4sBAWwuQTda1AFqxGZhbOFW+oa8vQ0jMQFvxkRbq22NsL+sT1raXzW2rjxows3CvzWVdXwYV8GGv + yAWUq81+HzYI1PXl/e6kAqDsZYixCej1MkSwAVAqeohg2w5Ao5fnGlCuh7B8IVDfSAa5rwBosyIw + sAno68swbBho10P5DfVrnrbJ+sUryCwhUPsUKC4EwHw9fATRFwJzn7KHe4kDoM19SQtNDjZKpgVA + O1OkhcanRNsSAmBu4Vppsr7l0jbZ+JSoRn8DjvI1z6hG/2HL5QW0FsI3JKDRy+GwYaBVo+ACCGj0 + crSRLADm33CJHD0B9bkAD8wt3IIMJwH9a54UHzLQZtohnCOgiW0qnaL08lwB5o5+L/WyEI8XEEIR + BloL3UwR4vHc7bzdK48INH55rXzDfD08t/Hbb2i0XgloLvacK3PZXOw5VjrFXOwZZdoD4Nd2inoI + Y42WrxWBuYVrZCEBdSnzAd+QgdIF7LLJ8nGl50+lhUaadUXfHFBLMw+UFkI5GIFGmkWVxwBokxgS + aKRZCKSpZ9J9JaBO93ngDySCCGikWclCI83GCtCn+2ST9cWeUAFHoN4eIwNOJc0m7QLMw5GlxcE8 + HPl9+QK/TEB9rGmHYImBUvjs0MsE1Nu0KEu8IFCmCMiNEtCMw8ONPmCmMFAK8AfMZQAqadaBMLAZ + mFv4qABNKXM4IofmgGbb6gGkk60zAM2Vj+sLSEldBmYWHjfjDVTkQmC+xWh6rTbjh284fALMLJxf + q8344TrrGJhv7biA0x1IvZxv7Zhf33D88AxZDMxTVXP/hu+fIfsMaL/h/SpmBOapquI3zLd2nE2G + O8YRmG/tKAOtha5Tcq33nCnrCziAG4WBnWu9C9jcapNrvWeTl6PJkPuiJqda7wlcIyBZaI5C9AXW + rYe51utnKwa6UxeB8ijEQI84BMDcwv0AymGjfQqc8QmAuU+ZDgsl0PiU7qTkwDY+pUVTjwZ27lOm + VygyYEjMwNzCY9g85EzJfcrSZ8rDOXqxbfUAfnT0MTD3KUvvZYpgGZhZuPa5TCqAgManHF6PLtmg + XjY+ZdALrHr08BrYxuupRw+n12oz0kMYCDTXCIdej4G5hYeTGuQ3zMfh9FJSI728FgBzC49hk98e + 04H5ODxjbPsN83E4nXPZDRuxbfW4fXo8/7YB5j5l08uXefTwEj60wJKFeWwznquNcVLm0cN++/SA + JSQG5pFDd1LNAfPY5nT0lBVhoIwcKBFEQPlEwhNofIp59LDfgs4Dm4DmiYQ+bEywZB497AdRB8zB + EtBcTX9YSIkgBubfcNPSzDx6eAHhxasAKJUUPPKFQO1TKCRmoLXw/vwTAo1P2e45h9hC41N6EqPd + LYRho/TyeBfgoYVeL8teVnr5WBze34wXdorSy8c3JGlGwNynnOEciUcGKp0yfrhxIm5y7lNO4Pt3 + Kz4DWgvdTBF6+UxizCaZthm9fAEhmXarVmxGL2P+MO5lo5d7hlP2stEpQ2H5Unq5FRZYoZenHsG+ + Xxzi5cv4lC1KmRLQ+JS+HprM0mb08qmkyC8T0PiUrpehlxkolZRq8mr08qWkTMC5Or0cKikC5uPw + UlImEbS6Z3c6UH5D8+xOj7GlhebZnSPDSVsuCWie3TmED53+YKBUUtJCpZengoVKL3cVAKEIAbVe + Vmp0dXp5uVsYA/PY5hKPJjG+FuTtQzbZyFso0MSdYuTtfl++PgNKefs+IRkDTeq+aRewGnl7LrAE + vDn61cjbE0g6hYHSQgs0ocgQVcAZaKWZ0Smrk7d7FGNTL5ty8OHoFzlTchew9GBplcPGpO6PJq+m + Ar4aeXsG7Yuby0LenkE7STMCGnn7iDqFmpy7gOXUejCwb6eQViNvl94pC3TKbTPeauTt2r/hJpuc + +5Slr4cEpE7Jfco5sDfYlkDA3Kecdb33ochnwHwc9mHjFgclb5dILzMwXw8f0Yo9AdD4lJ7hhMiB + gdKnUMWHgEZW9FBEA2U4R9VbAhpZMUaJcQbmFo5RgYaA5lXZOaovM1AG7TtIsxtwca/KzpE0Y6At + 0DQHNOOwqwDzDZeCGqUdkgzMm3wA6dwoAc2wOeopdNyYgbLyCNciEVCp0a3Qy0KNzufmE7PaLEaN + zn3Pkso5LEaNnvttCHhz9ItRo/NZvTXydjHV2zmeKWRhHopM/RuqHeOLkbfTWaM3Aedi5O21oREc + PQ0bszPtcW9yDDTV20E7qcXI2yLQuIBwnwMD7S4C40YXI2/PfQ7S6wl5e+YPrYXGp/REkLTQ+JQe + LEkLjU/Zos14DMwt3CILYS4LeXvuMvVAGyyZis9i5O3ZKbRXhIEqaGevR002Gc5Hpcm5T7l6uTkL + Tcp0jVYbBtqA09RTFrfbeYqCdgZaC92KLeTtJwObLDQ+ZSoES0LeXrUAaaGRFcdMoZP+BDSyoofE + 0kIjb/sWdDkOtbxVB68WJ2/nyjfU8lYVuRYnbxdt4ezk7bHaqJrU7OTtrmfK7ORtB8omy51pXJO6 + uYDZ6OX53O1sjmzPRi8jMMjBzkYvnynTAYJ2BubfEFJVQVJ3Nnp5OhdY12Shl4vAPLa5gO4bCr18 + xjbvd+rGQBPbQND+GVCVMj86+hhoYpu9BrSrjQTKcvDHYOkzoIwPrYUmtilZaGKb5S4eY6DxKUXg + HxV9xUDjU3r0Jb+hiW2Ge2YpBurYZoOKDwNl9GWBJrbpTZarjc7B0n4bACq9PERNvm0KnY1evvYs + mUs2ZqOXr21a5hqQ2ejl86gshcQENCdo1ruF8Tc0J2jWe0gcA83p4K3yDc3p4EcFaHxKH9jmNq3Z + 6eXhPlNioNbL6sKc2enl5b7AtnAua58iV2yll+f7ih1b+ENlOAbmFvYCTXNNNj5lrXxD41PWgtdT + enmrAa2FxutNFb2sgXYcGjc6FcrBKlia3G7nXeuUydWXoVrxGdDqFAk0u+5b5RvqWsDmvqGqL893 + R/8Z8AeyczcXMBm9fHk9k2aZjF6+Nnib1P3k9HKLsnMMzCOH3ilm/+Fk9HLrocgCFjIwt/BoMu3u + oyabB/u6hdBkBmYWXkBT9J+MXj7vt1FbLid3OniMgDRTcp9yhsSrCYknp5f7Bh7npJRehjz2Z0Ab + H8r10PiU+R5jfwa0kQOo0dvG2snp5fCwBlmot7qpm0Inp5eXGtCqUXND4+T0cndSzQJzC6f71IuB + 3qeAhTCXVX15isQjdYrJwc6RX2agtdAtDkovV1Ybr5dVVmRyerkDzVXMk9PL7R45xEDjU46gHd4B + D4AyK2LnstmztFfmst6zZOeyry+b3SyT08tTpZeNT5kqvWx8So9tzL0io9PLQxTOMVDOlMVcvzA6 + vXwAZ9lkXQuwQD0OPVDOZXVd4Vg4HTybXQSjOx186OXZCJ/R6OUzxvZAmce2QBPbHF5vbv8fGIjH + 0ejlC2g2TozuNq1jptCdGAyUSkrdcjkavXwBzRaj0ejl1sehun16dHq5A428HZ1eDi9Hve2dG41e + bn1g204xD9zv94HdouVL6OUTSL3MQJkVIQtvbnR0+7GHGlDOFFptCJj7lDIwt3CIOoWAxqcUgZ9b + +Py7rx+0+wbv64/eA4VebiUXoPRyH4fmXpHR6eVjcZhd9KX0cjiwCah9im1y7lOuBdY5KaGXTyB9 + Q1hgVX25x9jwDQmY+ZTywM59yhnbUJaYvqHJwe73oP0zoIwP6RsS0Ojl3sty2Gh5K2NsJW/XQowt + 5O0FNCcKRyNvz2QardgENC6gCJQJSVq+bsDByNszxqbVhoH2G5rVZjDy9grazeG1wcjbK8Y2Aefg + 3mw9xOMIM2VEoHQBdCU4Ac04bBULzTjsQJjLABTy9vqGrslK3h6OfoCBTUCduqdr1Rko5e3Y7kAY + h0reLtE3JKB29LaXc/F4dgqNQ7LQOPo+DkHekoVGPO5Rk8lCIx7XSi8b8XgMm0F+Q7Nih51y88uD + EY/X8iWbrCMHlXMYnHgMBTgD5VymO3WpyfmKfa6HtHwxUPoUdXvM4MTj8Q0H50aFeLyaLC00T7l1 + C916qMRjqzRZP11EV48y0H5DaaERj6VvaBKSR3zY3PIliq3XetjuQHABQjyeQLren4BGPK6RAGeg + TEg2F9uozcktUlIMzGfKHmVFqJdNkWvSWm9wm5NbJG+pycanPArSTBVbh0gvk4Wm2BoWuchCU2yd + ovzhDdhcsTUE3prcXLF1i/wyAeU9nAPePs3AzMJzpy69aEBAcw9nlxVmtWnu8qseEstvaMbhXrHQ + jMMwaAegv/xK6eXmNif3gLM5oL6KmRZYBuYWjtoFNKdGH4W5rIqtewWon2W0TTZ6uQQ0etn75VYo + ttphY/RyWHkcEJhbWAKap89Dv8xAa6HsFKOXZx2KNKOXzxjbAk2GswOdkxJ6+WqySaY1p5fnioVG + L1eASi8XgXYuu2+o9HIRaC2UTc59Shkos3MWaPTyUph6Si+XgEYvl5psfEoHmhxsM3q5DLQWym9o + crBh9ZaBX2yhzsHab2h8yl4ZNsanbJUmG5/yqFioc7DWQuNTdtspT00h9PIFFMKnA62FIrZ5Ac04 + fNSAMo9Nu/sIqKu3tEOSgTJLTNWKjwHnC2iqt+GmULLQ6OUewQoB/gQqvbza9fAFNMXW8BAlA/NO + CW/wJqAJRbqFbhwqeXt0yuLGYeHsrdB6HSgXWNspei+xtVCHInS2goA6FFncAuvLwXbY+FDELQ5K + 3q4VoHEBRaC0kA5eEdC4gKVioQlFShaaUOToZToaxkDpRiVQydsOdFNPydt+Gs4tDkre9gOAbi77 + cjAdryOg3ktMpzIZmFsY3olBQONTxmjF/ljx6UCZZiGfQkB9nwPd+svAH1gPCWh8yhY5egbabyhq + oy+g8SlTDSgTkhaoU6YeKNdDO7CNTwlDEQZ+sYVGVsyVcZj7lCvGFvXl569e3qom7wV5qzpld/K2 + JzHM4rA7eRsmggjoU/ca+AOJcQKa2CYsLjAwt3CI0iwAzOVtexTSLLsoB38HmthmF3r5e5HLRA67 + 0ctnkeu9oh9CoNHLzWbnXkATOYQH8wloIoci0FpotN4u1OjVy9bCNHL4DoRhc0tV7YViK7kABsrI + 4b2sGEKgXrFXuEOSgF7rwU1QBNTrIQWcDJQlJJJmAFRarwi031ACjdYrAq2FoJcJaNbDIvAHcg4E + 1KVMerOVgXIcqhzsXtj6q/I2u9N6PhG0O60XXulD31Bv/bVAH2ODk2LgD+gUApoVey/4FKX1Kk5K + ab3QLzPwj7Iwnno6f0jCh4FWp8BcvgE3p/Vgn0PQ5M1pvTkKiQnot2nJJptxuESygoA6j011vYZA + OZdJPBJQH0QlvUxNNuPwcdcpoYX+niUVEm/uIOp2jw9jC/WbCx6YW9ivzQSfQkCTx+73H7px6O9Z + oqvpCajvWaJHvhgoc1/0gCkBzdbf8ElBBuYWwntSMdAca5rvwOETYG5h+OghAXVtlF5eY6BcselR + bAJqn2IHtt76a4HGp3QLYcVm4Bd/QxPbFIEycpDf0G/99cAvttDo5UovK71cAhq9PNWAdqY4R6/0 + 8lxYbZReDi/pJQuNXh5rQNvLRuttha2/1MsMzC3skYMRPpvTyz1YMnp5c+/4jMez3aZasbmjssMB + NNWKzV3cFD59Tk02R2V7sCR72fgUeOElBhqfskY+hYF2pnxi4f8CKrrDb8BzAgA= + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['13499'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:44 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 15:11:23 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_rain b/siphon/tests/fixtures/ndbc_realtime_rain new file mode 100644 index 000000000..f2f658217 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_rain @@ -0,0 +1,86 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/BDVF1.rain + response: + body: + string: !!binary | + H4sIAAAAAAAAA3WcsW4jxxZEc38FAedCVc9MdTN8sNMNHTh3sIn8AGf++6d5I5LTw3sWiw0KQoPd + PBpRZ/vWr3/+ebv9+HH7/ffbz5+3z8/b7T+//fbHj19+/fef2+3zv7e//r39/Of2+fft68/n5y9N + Hjd9/fXN6036SvWh25QvkDfIDbnqXHfIB+Qd8kC+QQ6vX/D69f76+23xrb2fz5G/r3/k7+sf+XP9 + Zcr9fj5H/n4+R/5+Pkf+fj5H/n4+R/7Ow5HDfgsejhz2W/Dw/7zg4chhvwUPRw77LXg4cthXwcmR + w75qTgScCDgRcKITJ3NecyLgRMCJgBMBJwJOBJwIOBFwIuBEwImAEwEnAk4EnOjJSfvY5hz2VXOi + mpN2rznZ82r9Pa/W33NYv+Rkz6tz2/Pq3Pa8Orc9/z43X/ODE4/z823Pj/229rHOOey35GTPv/c7 + PjLlD06ur6fkZM9hvyUne15xsufwPpac7Dnsq+ZkACcDOBnAyThxMqb8xck256M65wGcDOBk1M+T + Pa+eJ3sO+605GcDJqJ8nX3n5PGkDOBnAyQBOBnAygJMBnAzgZAAnHTjpwEk/cbLM+bH+0i5f/+Ck + T9+/HZ4nHTjpwEkHTjpw0oGTDpx04KQDJx046SdO5nOrOenASQdOOnDSgZMOnHTgJE9OPL3+PDlZ + pu/3wPMk8HMn8HMnwEmAkwAnAU4CnAQ4CXAS4CTASYCTwPMkwEmAkwAnAU4CnAQ4CXCywfNkg+fJ + BpxswMl24mSZ8/LcNuBkA0424GQDTjbgZANONuBkA0424GQDTjbgZANONuBkA0424GQDTjbgZAVO + VuBkBU5W4GSF58kKnKzAyQqcrMDJeuJkmfPn7wWXHPZbc7ICJytwsp442ea8P57bY85hvzUnK3Cy + AicrcLICJwtwsgAnC3CyACcLcLIAJwtwsgAnC3CywPNkgefJApwswMkCnCzAyQLPkwWeJwtwsgAn + C3CyACcLcLIAJw04acBJA04acNKAkwacNOCkAScNOGnASQNOGnDSgJMGnDTgpAEnDThpwEkDThpw + 0oCTBpw04AR8bAMf28DHNgMn4GMb+NgGPraBj23gYxv42AY+toGPbeBjG/jYBj62gY9t4GMb+NgG + PraBj23gYxv42AY+toGPbeBjG/jYBj62gY9t4GMb+NgGPraBj23gYxv42AY+toGPbeBj90OA/dac + CDgRcCLgRMCJgBMBJ6o5MfhYg481+FiDjzX4WIOPNfhYg4/1vebE95oT32tODD7W4GN9rznxvebE + 4GMNPtbgYw0+1uBjDT7W4GMNPtbgYw0+1uBjPYCTAZwM4AR8rMHHGnyswccafKzBxxp8rMHH7v/C + fmtOBnAygJMBnAzgZAAnAzgZwEkHTjpw0oGTDpx04AR8rMHHGnyswccafKzBxxp8rMHHGnyswce6 + AyfgYw0+1uBj9xz2W/MDntbgaQ2e1gF+Avy8PO30/5UGT+unp/X60eb8+zyXs9/wy9OuZ89g8LQG + T2vwtAZPa/C0Bk9r8LQGT2vwtAZPa/C0Bk9r8LQGT2vwtAZPa/C0Bk9r8LQGT+sNnjPgaQ2e1uBp + DZ7W4GkNntbgaQ2e1uBpDZ7W4GkNntbgaQ2e1uBp/fK07ZrDvmpOwNMaPK3B0xo8rcHTGjytwdMa + PK3B03oFTlbgBDytwdMaPK3B03oFTlbgBDytwccafKzPPnaZ8/L1g481+FiDjzX4WIOPNfhYg481 + +FiDjzX4WIOPNfhYg481+FiDjzX4WIOPNfhYg481+FiDjzX4WIOP9dnHLnN+rN/6R5/z7/W3D885 + rF9zAj7W4GMNPtbgYw0+1uBjDT7W4GMNPtbgYw0+1uBjDT7W4GMNPtZnH7vN+XNfY85V/Tx6+lhv + Ew8vH3v/uM/5k5Mx5+W5gY81+FiDjzX4WIOPNfhYg481+FiDjzX4WIOPNfhYg481+FiDjzX4WIOP + NfhYn33smSvwsQYfa/CxBh/rs48dcz4eHHrOy3MDH2vwsQYfa/CxBh9r8LEGH7uHJScCTgScCDgR + cCLgRMCJgBPVP3cEPlbgYwU+VuBjBT5W4GMFPlbgYwU+VuBjBT5W4GMFPlbgYwU+VuBjBT5W4GMF + PlbgYwU+VuBjBT5W4GMFPlbgY/X0sfO9ZYGPFfhYgY8V+FiBjxX4WIGPFfhYgY8V+NgdBthvzckA + TgZwMoCTAZwM4GQAJwM4AR8r8LECHyvwsfujrDy3Dpx04KQDJx046cBJB046cNKBkw6cgI99vgVF + DvutOQG/KvCrAr8q8KsCvyrwq4J7sAK/KrgHK7gHK7gHK/CrAr8q8KsCvyrwqwK/KvCrAr8q8KsC + vyrwqwK/KvCrAr8q8KsCvyrwqwK/qrNfHXP+XH+b8oeHz+XrH5yM8+dVgV8V+FWBXxX4VYFfFfhV + gV8V+FWBXxX4VYFfFfhVgV8V+FXBPViBXxX4VYFfFfhVgV/V06+6X/JyTkfgVwV+VeBXBX5V4FcF + flXgVwV+VeBXBX5V4FcFflXgVwX3YAXeVS/v6un79Oldv96vS/79Prbz/6/p7F3HnJfnBt5V4F0F + 3lXgXQXeVeBdBd5V4F0F3lXgXQXeVeBdBd5V4F0F3lXgXQXeVeBdBd5V4F0F3lVwD1ZwD1ZwD1Zn + 7zqmvOYEvKvAuwq8q8C7CryrwLsKvKvAuwq8q8C7CryrwLsKvKvAuwq8q+AerOAerM73YM+/n8I9 + WME9WME9WIF3FXhXvbyrL6/nxcklL88NvGvdU9Ghp6JDT0WHnooOPRUdeio69FR06Kno0FPRoafi + yGFfNSfgXev+ikAvQaCXINBLEOglyNxLsM35gPz93AK9BJl7Ccacv3MS6CUI9BLk3Evg6+uE/Rac + BHoJAr0EgV6CQC9Bzr0Ebznsq+Ak0EuQuZdgm/Nq/bqXINBLEOglCPQS5NRL0PyaS825l8BnHlrp + XXPqJXjPq/OsewkCvQQ59xJc85KTupcg0EsQ6CXI3EuwzPlSn0/JSd1LEOglCPQSBHoJMvcSbHP+ + /nMtcy/BvE7NSeldA70EgV6CQC9BoJcg0EsQ6CUI9BIEegkCvQSBXoJAL0GglyDQSxDoJQj0EgR6 + CQK9BIFegsy9BJe85OTlXdvEVeldA70EgV6CQC9BoJcg0EsQ6CUI9BIEegkCvQSZewkuOey35qQD + Jx046cBJP3Eyv181J6WPzbmXwNe8PLfSxwZ6CQK9BIFegkAvQaCXINBLEOglCPQSBHoJAr0EgV6C + QC9BoJcg0EsQ6CUI9BIEegkCvQSBXoJAL0GglyBzL8Ey58f6Hpevrzk533ed16k5KX1szr0Ep/tR + OfcS3F/9KoFegkAvQaCXINBLEOglCPQSBHoJMvcSzOdTc1L62EAvQaCXINBLkLmXYJvzcv0VOHnd + d80lf3CyTp9Lzz52zHl5bqWPDfQSZO4luOTleZY+NtBLEOglCPQSZO4luOSw3/p5UvrYQC9BoJcg + 0EsQ6CUI9BIEegkCvQSBXoJAL0HmXoJtzr/Pbbzuy+XcS+DrOuW5lT420EsQ6CUI9BIEegkCvQSB + XoJAL0GglyDQSxDoJQj0EgR6CR4fQoq89LGBXoJAL0GglyDQSxDoJQj0EgR6CQL9A4H+gcD8fmB+ + PzC///jwVuSltwzM7wfm9wPz+4H5/cD8fmB+PzC/H5jfD8zvB+b3A/P7gfn9wPx+YH4/ML8fmN8P + zO8H5vcD8/uB+f3A/P7jw3yRg7es5/cD8/uB+f3A/H5gfj8wvx+Y3w/M7wfm9wPz+4H5/cD8fmB+ + PzC/H5jfD8zvB+b3A/P7gfn9wPx+YH4/8/z+6fNYPb+feX7/8vXV+vX8fmB+PzC/H5jfD8zvB+b3 + A/P7gfn9wPx+YH4/ML8fmN8PzO8H5vcD8/tHDvsqOann9wPz+49f9oscvKXBW7q8L3rksH7NCXhL + g7c0eEuDtzR4S4O3NHhLg7c0eMv9X9hvzckATgZwMoCTAZwM4GQAJwM4AW9Zz+8H5vcD8/uB+f3A + /H5gfj8wvx+Y3w/M7wfm9wPz+4H5/cD8fmB+PzC/H5jfD8zvB+b0A3P6gTn9wJz+Qwa+8v8Bt89q + OH9hAAA= + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['3083'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:47 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 14:51:27 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_spec b/siphon/tests/fixtures/ndbc_realtime_spec new file mode 100644 index 000000000..446f0922c --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_spec @@ -0,0 +1,270 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.spec + response: + body: + string: !!binary | + H4sIAAAAAAAAA619Ta8gu23lPr+igKzTo2+plgbexXgRXxjTRhpezWISjDeeAJnFIP9+SqWSyENS + da+NGMZ1v3b3efymSFGsf/zzn4/jD384fvvt+Mtfjr/+9fj1L7//03H8/H+/7z/+eBy/fv2+//jj + 9U+/Xf/72/Xbf/r4+OPnx8+fx/G7P/52/OHXb//wj//5H8fx138//vU/j7/8x/HX/3Nc//nr8+P/ + /tv/4r/6p+P413/733/qv9V/3f/Tf7//3j8E59vhrv/6w6cjuePwP8JxuB/lONqP2P/x+r3847yI + +Dh+/vw1/v5N0HGkH/kI7gSUyFHycdQftf+jP47Sf+9CuX4oFF8roARBy4PiCOXXoOV3//LxP373 + 3z86SrxYKIDiOUrtf3eixOtXP2+OPjQt2QGKe1B8R7l+1ZXHOLr+ScslHsEHjuJOjlIeWlwXbL7+ + 9I2gUMol3QwojaO0h4L7Vx3ll4lyHiGCdF1VKERLGfpRKO3wDTkqXLqE0oYUOy1aLhctGWnJnJa6 + OLpp6cK2OLqsrkRASRzltjrPbPcn2QtKN4GmXbTsheRictSOEMDqXFCaDgzF1lG9aEGO/N9hdVVZ + nVPSrcteyo3wU/lRZT5dj+gv87F11EgukqOuu+ALoAy53IKgv+t+pOGNA0FGhi5dDyhTLg7l4h48 + Uy7n4U/kCORyPhHu1lb/d/7c2a4HWvz5gpJfOHKAIn36kUt7PGBrdQFQKtkuxexbW5MW015CBpQi + POBBebzR9uluuw1QMkchHQXU0WVxf/6fzBuFjjAfxZWPwmN/l2TtfARWh/koLRRPWU17Y7o0jXIJ + SIu/2Vq0fOxQQgKUabsROYojes8Mi3LptERAcYKjJzdO6ZooPR+B1a18tNfRYdESQNMrH5FcGteR + me0ry/YDpXK5QJ7uVvfT5KgpjorygMi8cfq0QnHIUea0kFziW9wtMmK6ve126U57kR4grM7Js9Q5 + spofEvowzy+XH2XkKCDK1JEf/H98Dh0hLdcfOyHWOS9oIT96pwU17WyOHPMjZS8XSmW0OMpHwl64 + Txtx19cEKMHK9iuTzNMhyuWy3RwBBeTSVsRs0+o2tJQAKG6LMiOD6UepcBR/Ck2HjvLIpRyfn78M + joqkxbcXubgnvkiU619WQEcefLrIuGvby4WSTkApHCVdEbQHvJu0LkWbo05LBpRs54BAtntYtPBY + 5ygfTVp4rBvVhIkSwV5e66P65COJcv3LkgMUXR/NyNDlwlDYuU6j+JdYV58cYPh0QOk6FV8cP6ke + O+mCpl/y0Z6Wi6MAHoD5qHDbTdOPFEqUcnHV8oD7FJRWnjbkEsFeVj6yKz4b5eIoIi1Z0FIXCp08 + vrQ6zEei4jtfOAJNO1kH1HXyXdleoVRpLzwfkd0/edqOdfmHV/biRbZ/UOobSlD2IuMu13TboHT3 + o6wWTspHE6WyszxoennjzVFEFKgbqbavD4p53r0qmxYBBeojqklyr7LapudxQg7oKFAfJd4LmprW + KE2iqPqorKiXrl9ZtNzSzSAXno94ZbPOdTsUDyhVycWx6tPO9hdH+QSUwlHqqtXq4GjoyJBLRVry + Ky3D4vBEdnPUEqAkgVKXtuKqA6TV9QSEtERFS+EoDy3KXqoDlCBQbu95NB2XXFC63UAQBWy32ZrW + 1afPaHW6ti+iKrfraaAF+3VtVROinpanQ15Pd5S2jZh0lpL9l55hQdPYryvojbvzy4WSEOUtH+1y + wJWPSgMU2a/jHJ38vMs4wnNdR0k2SmMollwycqTzEe9uHSZKgxzQUWS/rqLlbHuHKBdZB3DpOs4R + +hHaLvbr8nPeJe+msxTj6ITzS2iiX9cee1mZ5MOwunwX7wlQZJ5u8+R7R4YPQ7r5PqIHQGF9zNti + H5Q8Yp2FcnPEeh4dZd+Dr8/p8EPFuosjD3JR+ait6mTKhWLdr49//ucHhXUgO0pT9iJPZDLu3lbH + avuOIvNRXXjpiQzajypG70b5aGqae4Db6KifX1AucMaE25YpF33bckpNY7/urj790pHfyyUjCtT2 + hddHwhuRlogcBeGNj6afzPRhSvdUOpI+fUKs26K4CiiOc9R49E7Y8xD2Ah6A9RFwdEfvQ6PcmnZg + L07W9ohi66hzBDrCfFS5XERNIlAaoMh+XVsS2lndfYIXtGTbpyvFF/MUhB7A6yNOyzp7WxHz+mMn + 2Av2684ll/achw4dX9L9x8BeVj6KCmXSYqK0E1C8oAVzo5UD7vgidCTrI05LMWnpOgKOKtRHXLpl + npqtKFXQdivUR7xuTLyykbdQ2A3tKF5ktXPdGaYnYhLK5Kig1VV9f9TY6XCXYS/b9Ymj8H4d5bJV + H1k5QNawHaWJTEIZ9s4k37GXSvnIG5p24oZjojQ8M1R9f8Qjpu1H6f5joCPMRydGBrexl251yFFS + 0p2ajk9tryPDJd0ImvbSdnnFZ98q3LX9iSjMp59bAPIAd8ybQokSQgSUabvpgWqAYse6gJmkUj5K + eK47SdMapZ8OM0dZ+SjxKPXk6Z0HeDyRVcpHiXcXForV8xiVMKJUgUK3CvHJ9lTZTJ/u7U+wF1es + uLs6DtuzlANvXPkocduFexKN4qUfrXw0UeiGIz59BrO71RAlbmlZ0ds4wR8NvHHlo/xA8arcmZVw + RwnoRysf5ecH70s9t/8KJUsPWPkoHwfdybF6Wtf2A4XpqFA+SvwU9PjlubHdgjoqlI8S0jL7mKbt + XvVRjYDihXSpR3ZHqS0K0iJ9ukAdsEfJHGXlI0HLytOW1V0H/RYAZfp0WSg0F9TMG7E7vmSQy8pH + +dEMVeW7XtCNUkAuKx9lLhdxxydRLj/KYC8rHxVOy+NHbu+NFVESoXBvnBI6rD5mxPNLoXw073Af + WjLeuKMfdVpQR4FQOC2Z+gyaloA91UL56JHpvG+cHD23cwqloKYd0jLrxkJy0dJNkqOVj8qj30cu + QfWlBEeI0riO6vfk4qXtrnxUsVsx+1z3DIGh6YK0FK7pxHOAmN1CuZzg0ysf1SXdc9kL9Zq/iAwu + KelWJl2GgmcGoSOwXfKj+KajLO1l5aPKNUNdZ5Ojgh3rQvmooh/NOL5FQVqm7Z6clnU/baP0FhKL + DJnyUUN7mV3E/k9m3HWAEjgtCT0gbqTbj+wVUDxHcdwbbzzztqWi7WbKR8/02Ly3fzygz5zYKJmj + PPko/JjCoU7bPu52lBNQGqG4u7k+OOI9VcsDGtJSOUqvC4YVnyQXM6tVkO6Tj4gWQhneaEVM4QGZ + 8tGJUarSJIIdd0FHTz5aHE2Uk/p1NkceUCKnhbpb7S2rBbzjyzMfhXmDNaJUWPe6u+gtaPGcFpoW + mTePn/qOT2W1LPIRcVTeOPKYpzPlo71Pm7eWBWhZ+eihReZGM8NqWipHIdutlANMFEFL+TKraR15 + jLuZ8tGccX2qrLS3unHfCD698lFFHeX9NNq4EwYPWPlootSVU6bVfUcugWc1yiRpVllWlLr8qCGK + 5zoqqKNwRwZ9rot49s4iH/mFkt/OUhEjZqJ8dK6Iea4IvIt1CfNRonwEFDwzSrvb/4Q37mnmozC7 + W4IWa+rqjpgpAorj8WV6QJjnRDvWZTzBJ8hHtzc+0m1vVpfxBjVRfXRLN8pMYqMkvEFNIh+Vb6Pw + +ihRPrrlElbcnb3In5t8lEHTKx89thseTT+2a03pjbgLOlr10WlytM+NGVCiyCSGpk17QU3PfPRM + DI5Zv8C7OJqjhJEhzXykaNE3YkJHSIsTtCRA+bXTET/XpZmPCIU0zXOA1hHQ4tqrdO2I2VFAR67a + tATyaTsygNU5OEsJWnbRu5+CECVzjq5f3XlsSXdbqyXwaZc4yry3X7R8M9Y5iLuTFr9ub7Z1I0pX + 2u5jLwFPh6hpnALuKNJ2udXtTkEqMrhpu8+NBKPltl3z/JJRR3Hmo7Ambx9NR5aPTJ8OgBI4Slw6 + im8+XTDuRspHGe0lv9lLQz+KlI/yE3cfjlifQXPUMEpFykeWdOt35bLqo+cGS+jopxlfKs7iRMpH + AaX76tPCXiL16ywP2Ek3KFrAp+PiyL3F3a7pCihJxBfyaf7KQOWAirTEbXzZ1wFBWt3KR45ztOrG + bcUn5AJnzLRQXs9SnQW0unnG1HXAO0eNo6z6aN54UpXFZyvUvVoBuaz6qOLMyTo1fw+l4vkF6umw + iQwez1JR1Edt1QGZ7EWjiIovUn0064AEtdp+2hU5SqjpWWW1N1o89hmiqI+ilO54s2xwhFGK9+se + lHPVsGFlEi0XtBcvULhcgmkvo26EWOccoky5vFjdePnMdBSoPipou6BpORt6Ymc2UH1keUDZeMAl + Fz7vHahfV1DTUAnLLnG/n0YUdq/G32WlNxQHb+cuFH5/RPOY9J7ErLL6A9gKKI1QeD29bi2tuyzR + Cwr6/ojfFD7v7a2OEp8hCJSP6B6WzwHYPXgnpYv3R9GixbrLCnzmJFB9RBzxKb0tikeUqGjhKPsb + VAco0IOHG7H5flq/CE/wfrqjQA8+c1p2r7BvWhyiOAuFpq52KOx1+oWy8tGMTXyDgP32v/9+iIjC + +nVcunE/e37LJYAHOFbbc1rCGy1KR3h/JPpSQ9NaR/2wjSiQj65fGXcTFgqfYA+Uj060l3nLveMo + Igo7S3mWYV9vxBq8n+4ogaNkzNNuQ0tHQR15rqMkUWwPqPBmuaOw+uju1+FJ1dZRf+TD4q6n+ijg + GTPQqVmjNHjLHTzVR1YlvNN0wRcPnuqjuORS18ljF19OtBdP9VFCWtIbR/0hlucoqz66UXorepzg + J4qx58SQy6qPCtJS9nIpPzxGBk/10d/CUUEP8NSvi2h1r3MeFd5yB0/1Eb+Tw3OdjRIAZdZHb5Ww + 5ggyrKf6KCJK5NWEMRfkkRaw3fCcVFeVZW0QUBnWi/oorJess7/7uTu/IIqjDMsj5jzvGvck4x2f + 4ygOzlIRbzh2L+X7MChIl8/X8V0Rkb1Ztl6nN/BpVzlKUfNSn9a7rFNqGufrKk4Mjgl2c+eKA9vl + 83X8XFefDLt9JQk+7eAtd5YZ1t44UfEEz/YzRDzBz/nOZ9ZP761AWuCtAr1XqzhhqjR9Iorcz4Dv + Jj62HFVAgXlvsl2+FcTcz8BoYfsZ/JYj8y0UpwX3M9Cs1Zr3tl/giUzC9jPQac6t+bq0pKve8fE8 + zfYzuDVVBxPsJkpGTbuZj9yafNQvHswdYB7k8uQjt+6ncY/SbneRP0EuTz6ibUz8bW40J+PGC1+Q + y5OP3JpEKLPrTK+YLNtNSEu2aYG3uQYtCeUi38OK/VLmVrMTa3s38xHfUnUulLRBwY02HUXvupIo + +k1hw/ewbuYjCyU92V6jnJgDHOUjSy7DjywUvnfrQnFgu4DSaflloNwT7CkDinyrwDkKJkejW4G0 + VOXTUdCiZ4k92/Y2UIpCIR2VzQm+t0rAdp1+y81RtrvR+OnQUT6yUJppdaMXhCjxhaO6ocXL+OLk + W258Z8N0hK+7eF/Kif0MHn161yHQ0nUKZXbL1rsJiyNmu57tZ5jZGePLthJmHQLP9jOIee/8pule + T2dA8YqWulAeWg5DLoIW94LSXlASR1n9OiGXTJnE9GkHtKx+XXyMhrYDzp6HRnHQrfCn6NdFPNft + 6mnsQHq2n6E+3XO3eijUyZeRwcH2Ls/2M0CtRhPxZq3m4K2CZ/sZ5qn5hAnTfU8VpRttqytzisbW + ET97e7afoWCPrOwzyeiGoo48R6Fp+jkFvPVGpAXqI9GxtnfpyW2S/oR5b15NvKIoD8B572b1vU3b + jcCRg3nvLK1udx/Az5j+hH4dt92KHOk3YhBfcL6uWvcBdr8Opbu/P1pzZN9AicjRRKlf0OKRI5hr + ht5hec7edl+qAgr0mmma3tEJXms6QW70p5ivm/pdHWv7FVNBq2P7GU7OB6s+Nyg81rH9DKLXzLrE + tnSRFpj3TouWSH3MX4qWxPYSDxSYma2o6Z3tRszTbD+DmGtuez8a+SgACvTgvRUZrPdqvLb3bD/D + nLz9TibB84tn+xkeb5wobB7TusuSHIFPUz566SiNvhRKV87Mklz4qzfdI6uAAnef8IqJd3EUikeO + AuZpuId9u/tEWrxA4fewds9j2AvqCO4+C77LsjttQ7onR1H5qK5Is7sTHtkeOMJ+XZWdtu0+sooo + lXNE09HxTdMOzwxN9OsKvmQlb+S0jH4daBr3qdI+j/CVpgugsH4dr2zWu/LNnXADTbvNW+729pa7 + ywVp0X2pyRt/salu/xtEb7UvCDmy7qdHFwdpgX7daXEkpTv6DMxeqthfl9U74e1URAQUsWdW3tub + KBXPmFXsU00WLXpLFb5i8lXsZ4AdPXyfqtqEynXE9jM47PrVN003ePHg2X4Gr1B4x1pvwy6AAvsZ + qL/rULpKLuwdn2f7GZySC9+LI7c+C03j/ros9zNY81JjzyzSkmyUE3doyD3WUi7Rkgv7lsFuq1kA + FOh51OWNlccXYzugQNG7F+eE0G5Dydi9iFa36ddlejdhfp0BaeH763ise9mWMmgB6Rr9urhocZt7 + Ek1LFX7EtwO6dQulNy2DTzu9ezEyPBslS+k66DVXrIRpYvAQ25j4bhG/9jO4VdnQbpG5oUTvUerp + HOUSOUpdKKvTttmW0sCPXNiiiP0vAgU17QUK3yKTzb04t0871JFTcqkChaIU3yLDOFr7GXYcsXtY + 2KFx8FPQ2s/AUaiPWQ+MDLQVBHS09jPQbYulow9BS0dJgOK2tCwdCVrGjh7HUdb9kcVRWu8blVwy + SHfdH52Ko5sWE6UHkAIo8v5IcGSg3ByxKWBfxP1RW1b3cITvhJmOCqLIHry2F5ujE1CSiJhku/G5 + /TdRCupI9uApMuxoueUiONr04LOyF9T0ibR4le3nGeTOsIYf3bGugAdgPiJ7qV9Il80Se7afwaG9 + 1K9oAavDfEQo5SurAw9Q+ahiDthxlDygyLtPTYsZdxNyJO8+udWVF5+G+IL3RwLlJTIk8IBVH1ko + ZaPpKO3FybtPHqVsudzbuyLSIu8+KTLc23U+dcS8TzhC0/Is9Z2IeaKOMuUjQUskTX8oWjpKAhTm + 03wLXuyDSpXTslDuOpvdWvos5hn84igO2/0gWhZHNwo/S7H9DA6jVHhyI0mXofRWhucoWB+RdAOT + y6dEuQiNQAvmoxNpSY+9GByhXDAfnc+LTeLoWChMur3xFAGlvMilbWjJaLsZ8pFAEfaCKAlpSUou + ddHiN9IVHsD2Mzw/fABNDzqkXHBXp8+Qj3hufOTyYcqlYobNkI8ELXRS1bTwLZs+Qz5SHI0T2SMX + hiJO8Bny0Y3y9NwYyjfshecjRUvY0NLb4xBfeD7a0KJRTtiy6bOYZ/DSdm8EZS8i22eYZ+BRinuj + xVEGb3TyLFUgMtxWp2ipWE1kyEc7ezGlC/aC+ej8nr1c3nhC9MZ8JFDKCwrai9uihPn+yEDhm+d8 + EvnoNDV9fOr4wnNAUvlISHdEhk/lAZ7fwyaqj0RuvGmJ3OpQLgU5cluOZsTsb4VVfElAi5czSjxK + JW4vGDH5PUnS+ejE3GhqumCtllQ+khHzp67ty71oIABKebG6Eb3lyePWkUO5ZEEL6Wj6keYoYZ8h + qXwkPADvyrm9IEp8QRm3LZ+WB7A3HD7p+bqipKs13Z8eonSF7RqRQdPS4wuiOEEL13R9UKSmi0SR + 83VAS3rkIqVbpb04ORuKtvtBfiS8ESKDqy8oQy4mCtrLqo/aVi6HhXIiirRdzRFNOjEdVYgv2K9r + zxtUkO6i5frVf/vdI10PPo39uiZ9GuxloRTstCWVjwzpao5OPL8klY8M6copvaGjBii6DiAUepur + 4i6/D4hf5SOrAzk8oAGKlIuO3jpiijwdRT7SmeSnRUuCLzr5qPPRiTWJsVN75GnHUVQ+OlXE1BVf + wmy/9jNYVVb8Ye/Jv1E80iK/N6GzmqYlY0eJ7WfQ57r43Ak/tou0sI0TPlJ9NKdeqj4FqWqiYfSO + cH+kTqplE6Vwq7yPqj4SNaz1dYY7MgREkbvp0RvtbN8H6sDqZH0krG6fYcEb+feP+H5vjqLyEX7j + wUdVHwGKnIzj+Qg4kvWRPKmatBT4sohn+xmcEV/KxqcLfCvFR7g/MjRtfYvJiAz8exNK0/ObQ/qM + yXf2+6jnvUX03kWpCJqW9ZGIddYmd3WWivD9I8VRu2mxuhX8G1We7WewbNfewT5oOQFF9uvQp+3z + bncclkmCzkeiJtmieEAJItbpPK05EvGF7WcQcomH7OQjLTyThCNIuSAKbjWj3iFEzAD9OsWR3F/H + OcqA0oS9GLSo3Jjgiys+wDwDR2FRSt43jvgCmvay56EzrD5LNalpL3x6TOm9xt1qSDf9nbQgR7Ln + wWmx4273eshHQeQjQFnfHPqUKBFrNbafIRgc1RcU5Ei84QCOynEYmr5R+NR40PMM2l4OSy48wwYr + H1Xb6vDkwU9kgfKRtpedBwwdgQfg9488dqzh63XC6pAWcZYClCbmpSZKVtJ9s91m2m69G5UFUOIL + LWXj0yfmgADfP/JrRw9IV3tAxDNDEO+PwvdQgowM+P4orM4sxLov5OJhvk5Il7qhVmRwgCK/IUP3 + R+K8C+c6qKe9eH8UEaVuUBp2rL1+f0S3UNRrligRq3J/qPdH/C7Lbbp+Ee9hPeUjSy7QIRC0gHT5 + 98rvH3VltY7y+cl1NLc89Dc5J6AUW7qJ5KI56mGoAQq8cScPSErTzF48diD9wd8fcY4eWj6hFzQ5 + uv5CQB3B+6P0PVquv8AntdlmhfygyPmXT0Mu/ogZpesELfw2Nx6jW40o/R42ZpAufikif4+W/vvg + R3zznLemixYtTLq9owJ+5NgrA46S5xnz07C6S/5HBJTyJYqp6QP8iG/68TgBNjmy5CKlm7hcCtJS + TLnkm0awF755jradL1os271RPMolCB1xlLShpV4cgQfwzdxKLs2Uy7A6pMVxq4OJwW51NkfdWxgt + TrwcIk2fY76ud4g1ysVRQhS5mVt8ldiwuk5L5BNga7PCswFpxhc/Z/0sq+sTGiDdtVnh2cak9ijZ + tFwofHLFwSZU8mnxBY1PJZeLaUBpHCUqlBtBo0ha3jb97GhpCoVt+hF7ceZ2nU9T08jR3PSz312k + US7bZZsVOgps+pkbHNemn36mM2mJoOm16eeZXpw7eupA6R7QUfD1xak4GrYbx4l7chTXWd6Q7sgk + iDJt90S5zF6BieLQp93MR2+0SLncKLwb6mY+irOGGGdMQjGke3MkUBrniDYKnzPv/Lr9CKV7WR0/ + 77qZj/4W6Y5YB9Jdm7m1dLntIi3Kdtdm7nPEScZRfXKAtrqm5JIejjJylJEjTsuwlwwo8UEJiBK+ + 8GmBMm3XI4r/CgXl4rcc7W03Stt17ku5SB0N26XI4NZmhTjiy4wMcb0WOyzbDRdKAZQpl6dLNyJD + nBHYji+XXGIDlL1c3jmKgOI4R4RS3qTrIXq7tVnBQtnTEiRHTz6KmEki3xmn/ajLJQNK3cpl5UYr + 7rKOklubFSLmo7jeHZsoPb6AdJ98FH883ykcPk1+9NiLzgEBUKZPNx4Z4jqbfVpW1zWNchm2mzDW + JRm9v9JR4LSQXNpXKOAB3n9pdXYOQBTHo1RcfjRnwZ6zlPIA1pdyJ+UjHet2mr5p8YjStrFuvVn+ + 2upWJmmYSdqb1V2ZJICmVya5z8pzp3aY76fvPpCFgrbr9vsOJ0e/LBQHtrt2mOoT2R6lHKGBptcO + 0zxqznkiS5TtNcp1gncoXc/lQrRUkq7NEWrafcmRrSMml0Y7TC2UPS2BTSK4RjtMtY7oG1X6pBrY + d35co0ziHunSiWx+dUvS0v1I0vJ2OvQmR/feUPau3DXKJC9nBisyeJCuh9MhyeV8o+XiiO3dco0q + m5Pn6YXyacjl3sqKclmVza1pv2y3ULbXdWNHqYACPu3X6fCpJn49G5AULRWlmzhKWJFhVtZ9L46R + SSQtUaA8HD0ov4yqfGg6AUrYeiO3XaWjirT4L/3IlEtBWhz3I88rvo5iS7d/+KlxlPXNIY81yfSA + z1+GN6aLI7CXVdk4hTK+6rfZUJLBAxzs85hyod0iplziRYsDFNjRk+SGWOyGsn0eJ8QX/CZr4t9V + mDsRNEcXSkZa4HvC9DWPQm+WNUpvIaGOYJ8HfY3s+SLCz2dCQ6GcqKPAUbK1dciWC3IE3zIgHYnc + iCjdj5Aj9/ehsDkyV/U3HmhDyfyWgc0RoohvX4i9OIcp3Yg5gO1EsFE+TJROSwMUJzRdhu3mqWkr + ene5ZI7i5V5ivkWmbOwlYCapdGfznF/EFzS2HDXgyMOek7xQEsrl1eoqfCNcoOxp6VaHctnvjLvf + gpnx5aKlIkfpBWXUAaZPZ0SB79sTR3Gg2PHl4igjR7DPY54JadfVM6cq3/6HgiiwzwO+q7BHOTHu + Vphp43tmz9lr1ii3XBCFzxBwuTz5yHrFdL8e5bGO7US4UdRLVja/i28t+Qle7kSgu4nKJjQMFD6l + 5+ROBHjJOrdfyDditx2dSEu2UfK8V9MTplnMEju2E0G8K480Myvn4O8ePD9LsZ0IYpo+HmsriOao + KLnoWWKipZjvAwYKRG/1BpXfcteDzXu/ymXzBpXd22uUftHKImahfDR/0FZW8RYKNc22GbiiZ9qM + PQQmSgUUuVOb3yz7DUce3ge4Ajt61Hv7NxSgBd+g1kVLofii7SXAXbkrlI+c4mhuBdEop6JFz6nW + JZe6QUmKliJQ+Mtnx1HWjfvQUQEUuRNBTyLId1k3Cs9H+50IbLOCGV8qykXug+dbQdxGLkHarpxp + E7fcNi29sYhygbkgxyPmzCQ2LRFQNvMvz1SE9dbyjgwo3ZWPAvr0Y7uMI3Z+6Q1X8KOVj+Z0EXJk + 05Jg/sWxnQgBPYChSLncubGCjvhMG/fGZ3OQjdL/GEiXz1irjRO2pseuiBNQ9Iw13biHF47AXoyd + CCSXF44KygXyUeEc5R9uc/IoSrqQjypq2o51cl+QK+INakWryxtaGuooQz6ydmiYfoQzSg53IvCt + Q6wSlq+w7y1VbCLZZfHmB1DojClRGkbMLGasG7eXOUemOXLo01m8+SFassqwgiOQi9c7eihiZs6R + kG4CFHjHV2WUsjLJ2HUVAKXYKFlFTJZJnKIlCxScI7M0fe9eRE379CVHC+V5gZfEC1+3diKoXVds + p9PiaKGceGpeOxFsFPvt/9h1hZre793a7WcY9gLeuN6g2hzZKA2m6V2mN6iWjsRr40cu95ZNgTJt + txo6Et64UJTtujfbhY0TTEcNTx5rJ4KNMiobydHwALCX9QZ1Rjgul2DKJYlX2C6LN6gVz3X2q5Rb + 0x5pAdsFWqhu1BwJP1r5aHKkz7umdE+UrrRdTkvjtRrz6QDvA1wWO+OEXPJhRW91OmR7CCqisFpN + W12F1zqO7SEQKGxSW0aG+7vcXNNJ72k7WfVpx5csIwPbQzBvLfm7ibahBV+EuyRyQFsocVxFbTny + SIv0I/22xUZBWjLSIuRi20uDdxOO7SHYaNqkJcK7CZdEDmiIAhsEGC0V3vy4tM0Bkd6TaI4SvLNx + SeSAJjmyacG3Ci6JHCBQ4gYlwlsFl0QOULuu9rQAR06eX74j3SQ5cnLHIFbCtnS94kjW0zxKvaEg + LXJP29e0JPHC1yVdk5zsjFk2KFWhwNmbrK491YTRI0va6vi7T9rvvb4+hLTQPlW+kc8lurOZ9czJ + Kj6703bnxoDSlf3dJ083RQvUJJDV5B6CsrrEs5ow6un7dMg2ODq5hwA6ShlP8FgfNaTFCx1Rl3jP + Eb7CdlHUJKTpQp18XU1UzLBR77HWtZrmqMLGCSf3EDROy+x7a9vF97Auij3WjetI96VoXzNUn1H0 + yDLarlu04K1ClJrmewjU3nOKdQolg6Y9203PbwoDVuWI0oepUEfwLUn64kr8iiOUi9zBzr+xSZEB + UTx2lNgeAo8oDnvwiHL9nxk5ckJHFBl4JaxRQEe4F4dQ2iNd04/6OAjYLuajxOPLPDXbcgHbxXyU + sc9g9zzSXR8hCpyl6EVVxQyr5JKQo/xfggI1SUaUXWQQPfgoahKghZ9fNC1gddgjEzqyObpP0+xt + i4uiR5Z5bqSXzxYtiOIER1zTO1r65DPLjUHssc487qpz3aqy+skjAQrUahn7L5HriKEE2K7jgqiP + BErY0BLgba4Loj4iTRfjXLdQHFYTgeqjasil7OXCvq/m1h4CjiLPUjYtwBHWR4lntZ2O4n3yQJQi + 5MJRbLnc9pLAXnwWKF/LJd5nTERJNi3ZqAM4R0K60dZ0fgb+jF1XN0cNNR1eaLGt7qbFg+2u+qig + pudUBH9vvzTdUyrKxXGUxE/w8yy1XsovlIQ1bKB8lBElsjPDfFfOultQTQTKRxk9QO+vYygO+wyB + 8hHMKMGWKl0JB+ziBMpHFi1+Q4vHu/JA+ehBgW6FremBghwlQYuxuUWhJOmNKx9lQy5vKBlQwotc + 0rA6CyUgin/hSOzzAFrAG1c+2qNoq6vIkad8pDkKc6uZQiloL57yUVG0BLmJY6cjT/lI64j24mg/ + glkcT/lIe8DKagZHkGE95SNLumWPwntBnvKRRcvDkYhSY1qkAIr0ab1j0JauA5TyEhnqBiXArgjn + KR+V5weXy9yAJFEiVsKe8pGFMuSiPaDi+cVTPtJWt/eABPvIOkrY0jKzmqlpfoL3Ih8V1FHc+HRV + tLhX6cK2FEABD3BwlhK07GwXd4A5T/nob6FFTF15kY8AZe/TWdqLK1/SYvs0xBd1Z4Nb5fdygcjg + kkDhtISN7WZpuy7+HRxlzI2e8pFldTtNR+y0ecpHlr28ZRKUixMoGSMD//Yoo4W+4VuO6CgfWdLd + WV1kchkocMYUPfi44SgwjgbK2/2R32g6sdw4UORdlr75seRCd583CtZH30ThFd9AaYIWfSNmRu/V + 9Rsochew7uTLnU5DRyAXL3cB6xsOjaJ0pO6P8pxlP+b3yvUXbwP7ruVASa8cgXTZfYDQtJdzqsY9 + yTfkIvdY6/sjjcJvfgaKvD+ydgxaHKFcYC7I3DFo6yhwFOzX2XdZllxWh2CgyB3sxv2RQkksqw0U + OY+Z2VRExCjF5+A96Ai/8/N9TQta9t+oEhzB3CGdMQeKvD/CHWB7q0OUKFD4PIOoA7i9NNSR/CbI + ueMIdRRQLvKbifjdOWsL3pAL2C7OWFfegVz3JAZH3OrCKWbavo/C8lE4tzNt5StaMqDIb3fxyTiy + OvWGIzRAYfdqfItverPdAFEqnHR/5A0d7TjSKE3QQh2lfXxJrLs1UGBO1a/7ozVN/9Pw6T7g7QFF + 7F48+Ncxy42gvwbfhx4joOQtyviupfU94T6qAla37o8ER2vee8fRCSjs/ojvO0xvkaGy8+5AkTsG + 8+rGxx9lk2Ez+zL9QNnsDU2U1eTuxXHeBQ/AGeuIOgpLR/KNe2ARM5x6xvpBqeP+6NfDkXqBl0Au + asaa+1HYRO8kpevYjkEed0+6KdRyiXCuC2snAqHwu8/nPsB6yVrAXhzcfdJc0ET5tFASe+E7UNIL + ymnuXrxPzRlR5He56Y6PpoClXApktXBSPhIolaKUaXUeIoPb2O6Tj2wUvrF8oMi4i7HOzrCZ9Rn6 + xgfKR3yi4mA37laUiuyN+0ARcpk6Yi8eTI6cAxT/d6Ak9nWGgQJy8daZwZZu5Cj+fIkvb5oGWrz0 + 6e+cXxqbxRkoMh8hyrHjiOfppvMRt5ddhi14fmk6H+lsr9/xFczTDeYZVCbZnRlOJV2xCxhqWPtr + QSofNSsfOZZJ7Oh95YBUAMULFHzDsX/fCN6I+UhEKXuj8DjvAoo7bZT5QmYX6/jpsFE+mij8q+du + E3d7Mxmk62DnrceI+Zy9FS2N3XAMlPISdx8P+DQ0HcDqcI+1w7O329BS2XcVBoo8S/Gz9xN3lVwa + e901UKKQizjBG1t873NSQekG2wPYa0C9D96xHvxAkfmIv8Abr5i07TY26TRQnKDlO5GhYWVT9R5r + /RpQn4K6AiugSLngN1m3HAkUud+bv3hwGxRNi1ORofLobaL0sOE4yspHtGlZophySQ1QmkDB+Tpb + uo29NBso1aalEor+WpBnr5gGSuEoQfqRRctdtQiUvEWhl2YSxbE3HAMF9lgn1DScmsV+7xNQwKdJ + LvG5nzblEtmU3kCRtit6zTsUHnfZToT5Q2xPN72Rv/kZKNDzOFV/18zT/fET2K787pzYe36YtGQ2 + WzFQ9vPeuz35o0eWAUX2mqm/O3ck631B118IiKK7xNDf/dSn5j55Gz3oSG0zyOzdRBvx/6ext6KB + 7aptBhwlHfMEr7dfIIrcZsD73qOG1XUA3woyUOQ2g6e2n52TT6u2d2wL3kCRXWLef6mHXZN4rD6L + /qI211HacHShJA8oWi7c6ubpUMslAYqcGOSz57KaoMlbiSKnXfHl8/QjpenYOIraZpDXFHp+Okqa + ll4QAS2+CY4KcHSYHDXsechtBvAedp4OdWTo42cRUIptu0+tNjeJSW8MPE8X+EKPqoSzaS9DumB1 + Xvs09evi3o8S6ki+fM6sG+pMjsZ2HQco8uZH267pAcJeZPecS9fvaUlIi8wk/J6kbqRbpQc4+cog + Q7a3vPG2OoHSlAdMTeeNTxu266Tt5tU95/aivFHQUgQt/D1Jrxv1hrXBUQEUuV2H224b+rFst0Cs + U1/Uzsu7d/YyOAqAsrFd1g3VHGlNB+WN50J50xHKBTZDUax77G+rI/RpXtlwWtrsS/1itwo8H7Eo + la1OG3Fk3xQOWgqggFzIXh6/tLrnNwrvKGXYrsPt5bFduwffRw+QI7flaNTTG1p4tyKLmx+ipZE3 + auk6jFJrm4HNUXuhBaSLL4fo5FH29yT3iyp+9s76i3F4w2Hf/HhFy/TpJ2aP/ZjPLcUpemRs21tE + WpKwl4zZYGt1qCPZPf9a0yOTIApUNkIudX+WSsiR7FYgim27fYzzBBTt03H5dDDv1e744sCPeKeN + e8DcGbfjCD1AddrKvOt4vPFDecB9IuNVeaZ89GzkA3sZeyu+w1FRVucfMZVbunyDAKNFcAS2S7TM + 274nq6nojT6NNz9BovzcnjEhSvGbH75NMtAGx8PkCLxRvWQ9MUt+am/sLxOFN+JLVqLF0y2U5qjg + STWLSYRyyE2FRsS85RLYiSyJfFRkJrGqrHFmiIAib8Tyehk7uqGWB/SbwgAo0qdp89zoEGx8mk1o + hET5aHoP+dHkyIyYBeTC8xHniEVvO9YBR+rmh+/Si6aOxr19AxT5BVNele8yScT76aS/qM3P3pQb + 1WZLQYu4zWV5ukfMfZ4GHaltb7wq3924e4yYCba98Rv3RN0KU0cZNS23veHslnXzo+rpdPCXrMJe + 0ub8Mk7w4Eden6Xo/BJfUApHwfqIOgTsJas+7xapI6yPitS0dd69UdCn8SVr4RytyKCq8utQmZEW + qO2zOr+YKHy/90CBzQoRuxXleZNl0FLBXtRLVop1aWN1o4uDKPLVG3/7f+ItFHsjJmkJihberYBY + t1A6R+BHTr7YzOvtw7z9N1FKBRTHUWbkX73Dn9x22e4iOJFFPanNI4PwAE4L94CoXw6l8eLmlZaE + p6CoX7Km9XYzPVFKy6U3CxOgSLkQLXx2S8sFaFGT2ly6c0/+T4FSsY+5NitwWogjh/mI0+KBI7Xt + La9Iw8/eqrZHTatNP1xHZSsXz28to972xqN32nAk5uui3vaGHNk5IGMOiGJSO8tYZ6N0e0FNg0/H + 78xj3rQEpMWLyICbCm2UrmmUruMoSaHw8y73I/QA3PRDHL32vTP2DtlmhUmL7tfJdxM3LQk0rTYr + YM/D1lGS0nXwClvpyHo30SMGnFTlZoWtplEuWrrpVbqHiSJqkijujwTKzuoK9qXkZoWC0t3lxoq9 + wygmtcvKsNXQNKCA7eL9UUaOTnFTyFB4HcA2K0y58Fmcc3PDkZGjICa1M05S7lB6DYso+40T6/sB + Zj1dAWVTN7a9jsZdFqCo7aN4UrU7Sg3j7tqssNtNz04esAk18PmXoLdh81NQ2FRZDmu1APURv7V8 + 6R2qii9sJ7UzyUVPageMLwEmtVUdYN9wjK7fCShRoPBKeHfzEzDuBt2vo28bp7faPiMtm34d05GJ + EjOgTNuNKF3GkTljjXLBft3sEKzab38nDB7A+3Vku8Tbrs+A9oKT2ml9FScM3qzb/8GRBxTo1xWO + Mr4W9FPFOvzm0EDJSMv8KnEgjkx7yUgLfFmEvhYUqUemURLe2QSYjFNysW/EhnTBj1wQHGHXDyfj + eC8IUTxHCYuWOL+ts7GXjBw5jkJdv0hfLrJpYba7NitQZxY1/WFOrgiO/MH7dfyrOPNNiElLj7sF + ULxAIenyelp1cQQK9OsydkPPjY4c9hm8uD/KyxsddQjM79mkDChN0IJysXV0sVCRlspReogc39aZ + Vrf9uhTSAvkofo8Wh1W5F/MMQi47nxYTPV7cH91fI2v8lsLsvzRFS3y3up2mhXSDyo1f94JO7AX5 + A78WlM3obaI4QHE2R4+mrY7S4Ag0zV8OCU3vTqoDBXSE/Tq6s5ma/rnTEdJSUdPfsLoxjQZycUVY + HX3/aB9fvEIB2y0cRfXIwBuRI3jJWtBe3N52eY/Mi3mGbNUBtlwQRc4z4JzHL/M7hSoyOH1vTyfV + bHJk2YuzUWaX2EQROnKUjxzXNJ1ZYSafyyUCStjSspeLUyh+GxnuHryBMmjJgAI+Xfnp8D57f48W + f25R3jQd+bssJ/KROKmWvb2cAVDka0DOUXtBSYAizpgyT++iFNoL3h8JHb14wAk6wk2o5EcnyeXL + DOtEPqrqNtf8xib/bu5ACdtsP7/H9x0UeDnkuE/fHchtZEBN7+8+XzXdQNNOzuJwlG97o9vb7jst + iFJfrI5ebKozZgWrw/oo8zy9+i9KR07ai5NbfJGWPQpyBLZbpVz20Rvsxe3PUjvbHbGuAEoQJw88 + wVtfDR0oaC/eRmHVhEnLiXKRZyku3WhqeuRp4sizzQrWbAV9YxNpqRAx/Snqo4j2Epd01Q1HQ1og + TwsdlQ0tjX3Dd6A4wZE+BWmUvqsichSc9xYoQ9Py694920V2C+XZZgWHHL2i9O+4N0CBHrzoqcZx + ajY5QlqKQMGOtW27+ZLuCShwJ5w4LfOexNJ0ZG+W/SnujxK+KZybUA3petA0filC37ZwTfO7LMHR + ZhPqvO3boEiOvEDBd8KgaYbi2d2EP4/dJtSnd7jjiG9u8SfdH+l9qmuzpYkCHOEmVIGSNigFXu37 + k+6PMsolsu0X6t6+wXYdvzYrEArfjRY2tDR4P+1Puj9KyFFg+1QFLWOnE0o3CRS+q1P0XxYtJ9ul + N1CiQKE9kOHHbvtoZPt3B0rgKBQZ/PgkvM1RhH0e/qR5honyyMWzb6XMWb+FwjctDxRnc+TZfilF + C75O943uj4SOPL3A0xtiT+RobVZQOvKzB/9hbIhtsHfLN7o/sjgS3+7icvFIi5QLcaS+27KXy7o/ + ekExaSmAIn2aONqjnLDPwzfKR3+LjhrsjPON8pGgJZC9aJTCvmk2UPI2Muylm+HFpm9iE2pGWnYc + FcWR3OJrbKs15VIBRW431l+60ihVeoDazI07b21NV9hb4dvxugl1pyOca+4/T4GipWvbLkjXyS2+ + euOnFRmOEzSt8hHfM5uP3TZJvv9l/EQd8eidDysHjO2joGm5mdvaeavk0p82Q5RSm7nxC2C7b5rx + 3UX959sWX2+i9BfhUi7Sdr/r06ij/Qbq/fb0/sfAdp174ahuUCrsxfGV8pFlu/ZXCJQ31kPN16EH + 2PmooO1WykcWR8OP5OZ/uY3JV8pHLztvv+bIv/n0kK6mBfco+bVZwUYpG7lktN0qNnMXM9aZtFRA + gRklO0pZX69D6Xq53Vjv6tRywV16vr5/SW9HS1AcydlQfvbefT/AKU2/bfHdfSvlVLS8bfFNGxRx + xqyUjyYKcRTmzY+F4oEWtZmby8X+8uL4dhd4o9tv8aXvfX4atIAHrHw0aeHzmM87YUVLgTn4jrKx + 3efdhGV1N0cOrO7la6qvKEK6cjb05VuSL3KRX1PFb4/atCh7wXnv+nQ62KafT5Iu61Yc/BTE9jNY + KGnQYX2Pz0OUwvm6eWu0ZoknipwY7Ds0/j8OgFBGmSoBAA== + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['13600'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:43 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 15:02:36 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_srad b/siphon/tests/fixtures/ndbc_realtime_srad new file mode 100644 index 000000000..1bfeea99d --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_srad @@ -0,0 +1,597 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/45027.srad + response: + body: + string: !!binary | + H4sIAAAAAAAAA429va71vLKdmfsqJuD8a/6TMzRwQjvpDhrOHZxkuwEnDd+9l1is0jS69WgAH9YL + 7D2gqZIoifVwVPE//tf/+vn8l//y+bd/+/z7v3/+9a/P5//6P//Tv+W/f/7vv38/n/98/fMf/uP/ + /B+fz7/+n89/+5+ff/8fn3/998/n8//+H/8q//s//6GkvD7p77/8yf2T0t//3tc/f8f67J+wf/43 + Vfv0rRr/dFS1rer/VFTVrcr/DFSVrSovv5gv1Zz/TFTtGFf95wuqemJc+IvVYqwLz75ajDX9k1C1 + Y8zz5bx2jHn8U1C1YywZz75YjPn7T0NVO8daqLIYO55XsRgr38diMZY3VTpXgs4rnxgXXvtsMWYe + q9li/PCYyBbjp+KVyBbjp7z84o7xk/FYyWL8JDxWshj/VPRspxMjj9V0YnxT5aOi8ZVOjInuY/pG + jPCk/amEGP9UVTpWkVRZ+kWPEa7X398uqTxGuKp/f6uk8hjp2q+Ikc9LiXFGjDCi/1QWY6Y3+Z/K + Y4Rx/6cSxuqfSolxRow0JsaJMeN5jbiP8L7/U3mMdCVGxMgqj5HPS3kee9xHeBf+qTxGuqpdirFL + Y7VLz2OXxmqTnscmxdgiRrpeTYrxzHP+xhf/ohJjlWKs8TzSyKnKtyPViJHeADVipOtV4/tIqiLF + WKT7WKSxWiJGevsW6Z1TpPuY453DKoux4vXyec7EZ8jnOd+XY/l8la7Emec0ft/bPCeniceyeU6u + mMMkm+fkgfPVZPOc/K34PNo8pxS+2zbPKe1pLvf3Nfu7pPY8lvn0/nLVFWNNb8eqWzUf7pCryv7F + +fBsu+qKsY76EKOrrhhbaviL9jy2/vSWc9UVY5tPM3dXXTH2XB9GjqvK/sW3Y+V99k+5qKt2jKs8 + fLdNZc9j70/Ziat2jI+Zoat2jPUpM3TVFePMT8+Qq64YZ3l6Hl2V9rEa/qI9j21+8XrZ8zheroQ9 + j3M9ZWCu2vcxP32HXLXvY3v6wrjqinHkpzxtq7LlHaviyMmWd8zS6Xplyzv6+L6orhhX+7784hXj + +nseWbXv48svWt6xvh2PZXnHGuNFdcW41pvqivGbOEbLO9Z3vqjSPi9WzXMfy4tqx5j5SljeMb+D + RmG2vGPOguPL8o6V8Q2QLe9YiUeh5R1zPn2HXLXHaucxYXnHbJ2+Q9nyjlnxScuWd4y/6wXviWx5 + x/i7XnT2lneMhu+vbHnHKPi1ypZ39O96UV0x9rXo/ZUt7+gvV9Xyjt74qbW8oxd+OizvaC9Ph+Ud + bVW8j5Z3tPbEMV1l38eBMVreUf/mTHQsm+fUl/fXmee0hnfozHNqxhhtnlPzF8eqzXPK94l2umrP + 5cbTHNNUNs8plceEzXMKf5EPX80L5wCHr+b5prpizP0pF3XVFWPmr+jhqznze/XkHX9fBbpeJ++Y + T0zUVTvvaPyeOHlH4Xe089WF1ytFbsUqzh9dxTmyq5hZuYrzR1dx/rhVP3yVVUKMP3yVVUKMP3yV + VUqMN1+FkfPDV/lYHiOM6B++ysdSYlxSjFO6j1OKcUr38Y2vukqJcUoxDinGIcU4pBiHFOOQYhxS + jF2K8Y2vukqJsUsxdinGN75qqje+6iolxibF2KQYmxTjG1811RtfdZUS4xtfdZUSY5VirFKMb3zV + VUqMRYqxSDG+8VVXKTFm6dvhfPXJGeGqHWPBGYzz1fG01uSqHeNqL6o9l0vIOpyv/uUdMPd1vto7 + nv3hqwtntYevlvTFr+jhq/VNZXPy/sy/UvDV9UStXbXzjvzEfV1leQdcieR8tfb2cqzNV78w903B + VzMQyhR8tT2tBbhq54+df9Gex/bteL3seewFuG9yvtrb2y/uHJk4QAq+ShQ2OV/tX+AAyfnqKE/r + Cq66Yhwd2FByvjoGZGDJ+er4wrOdnK/OBLl7cr46C3DfFHy1Vbz29jzOAdlvcr46Z3v5xc0eH31W + W+V8NUH+mJyvvqs2e8w47p2vJuAmKfhqBgaTnK+uwr94+GrhXzx8tQA53aoq/WKRVBbj23kl4aoe + vkqEMgVfTUB90s1X8dl2vvr3hYFRePjqNVZh3B++OgeOaOer/Wm12VX7eayw3pGCr2ZYO0nBV2md + LwVfXTA3ScFXB74Bgq82vEOHrz666lzlfJWuxOGrE7hcuvnqkyfQVfvbUfgXD19NQChT8NU58bwO + X+34xnS+WnCmEHy10Pve+erk+3j4aucxceY5hd+rNs8p3y8+Hb6OzOP+8NXO4+vw1YpzOeeric/L + 5jkXOaXzKuEHoOt1+Cox0RR8NfMoPHnHl78wJ+9Y/J44ecffrINV5rXueF7OV/l973wVZ6LBVzlG + 56s8CgW+miS+miS+miS+miS+miS+miS+miS+miS+miS+miS+mt79q65SYlxSjAJfTRJfTb98Fd6+ + SeCrW6XEOKUYBb66VUqMAl9NEl9NEl9NEl9NEl9NEl9NEl9NEl9Nv3yVxoTAV5PEV5PEV5PEV5PE + V5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV5PEV9MvX4X5 + ffBVZGnOVzPOfZ2vZpwzpXsdGeaY7l9lEnj46of51+GrnwYMOTlf/XQklIevfgYyq8NXr3V3PtaO + cT4fq3ydr34gFzXVnpPnZ2+UqfacHPJtU5nn4ZnommrPydd6+cXNyb/Pd/tS2fOY//JaVu0Yvw1/ + 0X0dz/fRVBbjc8ZqKvN1PPtNTLVj7E91J6Y6vo72/OUz1Y6xPHMTU+0Y8zNfNdUeq9/nTMdUO8a/ + scq/aF6y56y8fJ2vEuMzlXkCnzNWUxmzen4DmMqY1ZP/3lWbWa3nt5ypjK/iVT189fIqssq43HPO + Z6qamPGZarNHYEOmeuOrpjK++pwZXirnq3z2h6/WN9WOERzZpnrjq6bK0tkn4Uocvpqf6bCp7D7i + O/rw1ZU4xsNXv4Wex+CrTzWxrnIfMrwLg68+ryKZyvjq89fKVM5XWWV89XmFxVTGV58rJExlfJXP + y/nqs9PSVOZfxW/a4asjP/seTWV89dnlairnq6wyvvo8N7lUN1+l63X46uKxevjqfF65NtWOMT9X + upjK1h+fV91MtWNMT10ETHX4asKvwuGrlx+TVZuvpmfaaSpfR2bVXkdez/UwptoM+W8U0h2yeU4F + mm6q7V8Fym+qelQ0vmyeUzq/Mc88Z76dvXke+G1y8g5Y1TWV9Xl4zk5MtefkUGNgKuuB8LyuYKo3 + /6qprAfCszOifH/9q3Ssd75qqrf80VSeP/J5veWPpnrLH/9UAl81lRCjwFdN9ZYjm0qIUeCrl+qd + r5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pKifGdr5pK + ifGdr5pKeOf88FV4+wp89VK981VTKTG+81VTKffxna+aSonxna+aSonxna+aSonxna+aSonxna+a + Sonxna+aSonx5qswZwq+irlo8FXkJs5XM/KJ8K9ihu98teEMxvlqfXbomcr6kj3XD5Vv8NWBM1Hn + q7O9HGvHuHCW5v0BCmY6wVef+q64yvgq8Jx189XniiVTGZcD6rOCr9bnukxTlaN6vF4r+Crltcv5 + ahnPdeWX6uQdUM9nqp0/JriqK/yrDbjJcr5a1rMvzVTbuwK1uqbaMSZ40pbz1ZKeeyCYyrwrzw4X + U+3cqj77hky188fG196ex/YFirGiPwD4mcpyvjrqc/WmqTbPAUe2qa4Yr9p5uvbneVxP3fFc5Zyc + rqo9jxm6LvypDl/N4No0la13PFdTm2o/j+D/MpV5kN5Ue6yC09JUm1ktICJ/Kss7vpWPdfjql6/E + 4at8H/PhqwO+aVu1+Sp0SjDV5qvgZ7pU7/0BTGUeXeA5K/jqy5iYx4cM5GHdfPXZVWcq46uwirSC + r7bn+m1TuX+Vzuvdv2oq56t8XsZXYdVt/fYHoF88fBV8oqbafLUCEVk3XwU6vH77A8A7x/nq69lv + 9th5fB2+WnnkOF/lq+r+1Wevtam2fxX6PJhqfzvqs7/QVNYfAPjquvsDPFc1mGr7V4mJrrs/wNsv + 7jkA9GcylflXYWVx3f5V4NHL+eq1Ekuj8Kwjg5PXVLbGyiP6rCMnnMt5/9WF80L3rw4+lvNVWDFY + wVcbrHiu4KsNZ1bBV99U7l/lXzS+ym8A56uwOr9uvsp3SOCrS/Gvmuo1R14SX10SX10SX10SX10S + X10SX10SX12/fBXu9g9fhfv4w1dh3P/wVXjnKHx1SXx1/1Xuo8BX91/lPk7pPgp8df9VYhzSfbz5 + KquUGAW+uiS+uiS+uiS+uiS+uiS+uhT/qqmUGAW+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+ + un75Ko17ga8uia8uia8uia8uia8uia8uxb9qKo+R3vdZmQOEfxXWa9fNV3G+6ny1YgbmfBUqlkxl + fPWLMTpffdovwFW27wNmmcFXMe9w/+oEl8Vyvnp1fOVjWYzg2pzOV3OFuz2Dr05g2zP4KlTOmsp4 + zrMP2VReN/d47Wfw1QXezhl8FariTbV9HRX8E9P5aiG334z+AOSrndF/9XEPCVft/DHByJnBVzus + Bczov9ogK5/OV+t46ofsqs1XKSufzlc7Zb/T+Wpf8AxN56u9Pdc2m8r4KuRDM/yrA7zW0/lqL+Au + mnd/ACAiM/qvklNpRn8A8lDO6L86n7ugmGpzOfJQTuerIz339jPVZo/QF9ZU++XEb4C8gufA9crr + 3Ed8A2TLO77QKcFU5l/lsz98tfP1WoevsurwVegLa6q2zx5I8wy+Cr0jTWUMmWM8/VcXzAFm9F8d + 8B2azldXA3o3na++XfvxzpCn81Wk1tP56iKv4nS+eq3DkMryDuoobCp/57Bqv3P6c4cQU22GXGDd + ajpfnQlWMqbz1bHwjXn46qjgVZzOVwfN0qbz1fG4l5GrnCHTO+f4Vzuszs/wr2Zwk07nq+0LHsrp + fPXqwQ5f0cNXr37u/IvWAwFmaTP8q18eX8e/OvmpPfOcBhU40/lqhW5cptrznAXrMDP8q+O5U6ip + 9lyOvJ0z/Ku0Ejuj/+qAdeTpfDUX/CI7X/3ijC/4Kr+ZnK/yW875KuSi85ev0nm97W/lqtf8cUr+ + 1Snx1Snx1Snx1Snx1fnLV+Fu//BViFHhq/OXr9KxBP/qlPyr85evUoxLivHmq3ws5T7Od/a4VUqM + Al/dqlfWsVXKfRT46pT8q1Pyr06Jr06Jr06Jr06Jr85fvgrvaKE/gKmUGAW+OiW+OiW+OiW+OiW+ + On/5Kl2vm6/Cm1zhq1Piq/OXr9KzLfDV+ctX6W6/7W/lqiwdS4lR4KtT4qtT4qtT4qtT4qvz5qs4 + /wq+Cg6qefNVnEdHfwDkOc5XCzhA5+1ffTv7HWODasR581XMTsK/CivXM/gq7NdkKusPgJzJ+Wp5 + U1ldOXhOR/hXodubqayfFWQBI8jpAGfECGfqfN6bx1Q7o6gwjx7RWTVB34Lh5LTCfjqm2lTxC17F + cVf+vx1rx/iF7GRE5T8RpBGV/+RLG05OSwPiNpycNvJtDyen164odPb2pKHLdTg5zVTjOZycVupS + MX7JKY2c40yFXXdMtTPDL5D54eT06hNIMdqT1sj3OJyc4lrAcHJaM8Z4yGmDnqmmsg6A8PYd4Uyl + tYDhztRCrs0/1TpOcagO3irL8MGtvFWW4b/9olF+WHXbKqvCfTvWJjWV75BlFFcXTTrWfK+mHk5O + 68D31yGnhdjQcHJayFU3nJwW2LfmUllGUSa+7w85vcYqvCcOOS1UEzucnJYMHrfh5LRm+PINJ6eF + GMxwcoqewOHkNMOeeqayscojup/nEb98h5xee0nSfbSMonyhOmU4OaXu6qZqwnlZRlFovXY4OS0V + iNtwclrbc7dKU9n38bnX+aU6K8Q0/xpR+b+ApQ0np1fPG3oea6yCU4wno1hQgTOcnH5e3tHlfaV/ + ODn9TH6Tn4yi40zhkNO/Fz5e1ZNRFMgyRzhT/9739Isno3j5KpyMouCcyclpAdI8gpxm6JUygpx+ + IFcYd2fV5/0yy/jtrEoj53am0tmnd+I2JGfqkMjpkMjpkMjpkMjpkJypQyKnQyKnQ3KmDomcDomc + Dqnyf0iV/+OXnNKVWFKMgjN1q5QYBXK6VUqMAjndKiVGgZwOiZwOiZwOiZwOiZwOiZwOyZk6JGfq + kMjpkMjpkMjpkMjpkMjpkMjpkJypQ3KmDomcDomcDsmZOiRyOiRn6pAq/4fkTB0SOR0SOR0SOR0S + OR0SOR0SOR2/zlSYf/04U2EGE+QUaOe4ySnQznGTUyQiQU4xT3Ny+uVjOTkF9+34dabSVT3zHKqT + HkFOG87vvfK/ga92BDmlvLaHMxV2UTaVuTZh7ttjTyrKRXvsSbXAl9ZjT6oE3oL+W9NPv3jIKXmH + e3hOid71qOmHvXBNtSkG8cIeNf1Uh9+dnF5Okse73YOcLsgCupPTPp53rTCVkRrwUPao6a/wnuhO + ThvsgFF6kFPy+nQnp1eGTzGmQ6Mgm+tOThvVXHcnpz3B2kl3cloyvOX6b00/xOg1/QW6VPS7ph8q + CHvU9E980pycUh/d7uT0cp3Dtc9OTvFJy4ecJpjfb1U9KrpellE0ehdu1R6r1Jthq7x/Iakso2id + r9chpwmYe3dy2jKw2h49U6nPaXdyih7dHjX9xIb67TkFOtzDcwp7xZtqxziAknUnp5V6BHUnp4Xc + pN3JaaWq+O7ktMI+6qbaY5XqkXvsSTWAm/So6SfHbA9ySuu1PcjpBJbWb3IKrs3u5LRW/HY4OYV9 + 1E1l38f8cl62ssj38ZDTBGyoOzm9qCKd/ckoqPt1v8kpzJC7k9NrLZOPlaVftPohHqsno/gCL+zR + MzVBVXyPmv4F3uEeNf2Z3yZe04/znOiZCjPkHp7TxVfiZBSwf5qpzKeAs9pDTvPLO+feC5euvXsx + YLW5BzmlVaR+k1MeXzc55WO9ZoZdIqddIqddIqddIqddIqddqunvEjntEjntEjntEjntEjntEjnt + Uk1/l8hpv/4qMQrkdKuUGKcUo0BOt0qJUSCnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKn + XSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKnXSKn/ZecwhdZIaddIqddIqddIqddIqf9l5zC + t1ap6e83OYWV/n6TU8w7oqafr30OqsjHMqoInYT67TnFjMLJKdWU9SCn1BurS+S0Bzn9Ii1wzylV + /vfbcwreghbktEAFdIua/i/4C5uT00I1Ui2q9Sd4alpU6ycYXy3IaYEMrN2eU+CFLbqhVrhDzcnp + 5dqksz/V+l/wmzQnpx32ib1U+VSyQx/d5uR0UP12u8kpx2hP2iDa2Zycjg5crkW1fudjnW6oEzyB + LTynCd5MLar1yYfcnJxO6g/QolqfnJbNyemcsPLTYrcpciu3e7cpvI+x2xTktS12m0rwVWhRrU9d + BJqT05mg7vdP5btNwZtpq2y3KY7xdEMtUMm+VTvGDoxvq6xa/+1YVq3PqlOtz2PVu6HyyDnkdFKG + 34KcUvfr5uR0NB5fp1qfVgxakFPqtdmCnFIXgXZX6/NV9W6oQAKbk1Psh9yiWp86vrao1u9Qadyi + Wr9CJUKLav0CXrLm5HTQPj/NyemgCokW1fodvLAtqvUHrD+2u1ofKs9aVOsncPK2qNYfwAvbXa3P + T8ep1qedmJqT004rxC2q9b/gq21RrU99V1pU63fg5M3JaaMeCC2q9Wm/zBbV+hNmoi2q9Ruf16mt + ydBZokW1/uLn8awQd1hHbk5OS+Gxesjpl79Dp1qf9jFoTk4zdVdv4Tn9wnpaC3JKawHtJqf8i05O + IVdoNznF2bZSrd8kctokctokctokctokctokctokctokctokctokctokctokctokctokctokctqu + v0qMAjndKiXGKcUokNOtUmIUyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmTyGmT + yGmTyGmTyGn7Jafw5VPIaZPIaZPIaZPIaZPIaZM8p00ip00ip00ip00ip00ip03ynLbfan2YTwQ5 + xTm5k1PyibYgpw1qPFuQU6o+bzc5BQ9SC3JacR4d5JTHvZNTzNMOOb32KuVj7VXwijzHyelA8pDc + CQcZWHVyerkjH8++hud0wOyx3p5TqFGv4Tklj26Nav0J/tUa1foF5pg19pHqwMlrkNMJOUyNPqcZ + qhGrk9M+IJOuTk6v7JdiPJ7TxOflfU4hC6jR55T2h6nhOZ189t7nFCh/Dc/phOexBjml7Lc6OR3k + l6tRrV/hnVODnBbYV6Q6Ob0YMquMDgMnr05OxxfWAmqQU35qnZxSllmDnBKhrE5O38/enkegZH8q + yyhm5mNZRnH1X4UxkU+fU+o7vFX7PtJuQFtlnlN4k2+V02FSzbPHEjCFepNTvo+nz2mFlZ/q5LR3 + WDOsTk47dSasv/tIwYh2ckodQqqT07agy069PadA06uT00b9C2tU6y9Y+alOThutulUnp73AOnIN + clr4Spxq/S++Jw45rRlWfurtOQVXXXVy2haf/fGcDvC41fCcTh6F7Xj58U3u5LTBKlINclpgNlSd + nF6+bbqqZx8p6s5SYx8p6n5dYx+pxm+TM88p4AmssY/U6y9aZwnomVqdnF67atJ9PJ5TWomt4Tml + deQa5LRAvVV1cpoHVLLX8JwOWPutQU6p8r+G55Rc1PX2nPL30b0Y8+UXvf8XXXthH6l6V+tDb4b6 + W61PZy+Q0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR0yqR03r9VWIU + yOlWKTFOKUaBnG6VEqNATqtETqtETqtETqtETqtETqtETqtETqtETqtETqtETqtETqtETqtETqtE + TqtETqvkOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa0SOa2S57Te5BRnyD/7SEEW + EJ5TnCkkoZ97DXK6cH5/yOnFMWG+eshpzphRHHJ6uTYpRpvnXL30WWX1Q1BvVYOcfjEXdc8pqcol + 3HPyBB7KrTJyCmNiq3beQc6bclDTzjseZ4/lTNR2jsyqnVtlIM0l+Cp1cCjBVwfkyCX46hf6FpSb + r0IGVoKvki+tBF+tfCXcmQpZU/l1ptL1sudxUO1pcb46M9D04nx1NnC4FOers8KbqThfvX6RrsRx + ptKONCWcqQty9+J8ddEboDhfRc5UnK+it7PEPlIV3H4l+Crt4FOCr3a8qoevfhMQyhLO1C84B4vz + 1W/CEZ0t7/hSl9at2nssZT5730fq7Rd3jHwfs+UdX3LMbtWOkfbKKs5Xv1TtWmIfqVeVuahhZbE4 + X20VVh+K89WrQy48Q4ev4h44xflq/eL73ruh0jpfcb5aO/DoEjX9DdxrJfhqhy9yiZr+hm9y74ZK + hLI4Xy0VeheV4KsduEmJbqgvZ295R6b+E8X56odcrsX56tVHhM7L8o6cYb2jOF+9+BeNwhZ10jQm + Tt5BvVyL89W/hwjP/tTWUCV7iW6oxL+K89XrStC1r+FopKfj5B3UNblETT/ts1iipn8B7SzRDZW/ + fN4NlToJleiGSp3HS9T0T76qJ++g1eYS3VBpRaoEX21AO0vw1QrraSX4aoH17XLvIwX8vtzdUPn9 + 5XwVZ7U/fJVVr91Qi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RX + y/VXiVHgq1ulxDilGAW+ulVKjAJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJf + LRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLRJfLTdfxflq8FWo + 3Sq/fBXmJtENFef3P91Q+RdtLodsyJ2pL6rDVyt4TsvNV8FJUoKvVqhFKsFXG2YBh6+WDHS4hDO1 + w4wvB18lh152vpoXnH12vpqpBi87X8206052vpppx5DsfPVNVU7+CIRyq9o5e1btGKmeLx+c9mkV + OGY+k9HtX+Vf3L5H6vaWg6/O+Txzzzdf5ft4/Ku0A0YOvlqge1kO/+oEgpSdr67EYyKdGMHhkp2v + NtoxN0fPVNqnLDtfLQtWkbLz1dKAiOTomdqhni/HblMdeE52vlqIKWTnq9deWRBj7DYFb98cPVMX + vAtz7Db1hTrWP9XpmVqA8W3Vvo8VukFslXFyvNt5HW8nuMS2yvyrUDm7VZuvUr17jsr/DKw2O18d + A/Y7yc5XO9HO7Hx1TOioksO/Sn3Ac1T+Uw+E7Hz1uvZ0LMs7ZgaKkaPyfwC1zs5XB1WMZ+erY/K4 + P/7VBZUu+favAtvOzlcbv6O9Z2qGbjbZ+WorsCad78p/YHw5/KsT1jKz81V08ubYbYp2IMvhX23Q + HyBHz9TB48vyDtypMId/tcC6Qna+Wqj/ar75KlQsZeerhSqpsvPV641J4+usI1PNT47Kf+o3lKPy + n3Ziys5XM3Uez+FfLW+/aJz8TWUMGahiDr5KtfM5+OoAXpiDr1b+KnjewU+a7zbF7+iTd1C38Hzz + VT4v56vAyfMvX6XrJfDVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHVLPHV + LPHVfP1VYhT46lYpMU4pRoGvbpUSo8BXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RX8y9f + hZmCwlezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFezxFfzr38V + vsg/PVPpWDnmADD3db76wdm289UPsMccfJU8bjn4agY3aY7Kf85rvfK/Ii3wnqm0E1OOnqkVapGy + 89W/n8XrdeY5DRhfcr76GdD5MjlfRR6dnK9eew88xpiCrxbIMpPz1dKgEjQ5X60d5vfJ+eq1KzCr + LH/k63XvSfV4t5Pz1asv2eO4T85XG+2snZyvDtozO1033NgjZJlbZewRxupWWYzgJUsHGfKKQToT + 7l17SmMin/wRqhGT89XWYG+eFP0ByAeT7v4AQKOS89WrnwKNwnQ8gW/nZX45WAtIzldbglw0OV/t + tANZcr46aUUqhX+VdhZKzldHA5qenK8Oqon9U53OquQU3yrrgQCEcqs2lyOX61YZXwWX/lZtrzXR + gq3aXusC1a4p+gOQFzY5X51Ur5Ccr347Xy/LO74LvsjJ+eqiHY+S89XrPtL1sryjf2FtLjlfHdTJ + MTlfvdaH6LxOZ9WKT9rhq33BrCMFX53Q5TA5X23UET05X+2Zr4TlHaPiu9D3pFrQPyc5X21f/NY6 + X6V+MMn5al+wspicrzby8aXgq0Tmk/PVayc5Ptb+dnzxW3v4aqFu4Sn8qwtqWFLw1QErBin8qx3W + +VLsSUVrrMn5aqYumun2r/LTcfIO6tiTwr/aOcaTd9DqfAr/KvWNSsFXKz8dJ++gvlEp+CqR0/TL + V+lu3/5Vul7u6wCOmW6+ytfe+Sp/hwS+mn75KsUo9AdIEl9NEl9NEl9NEl9NEl9NEl9NEl9NEl9N + El9NEl9NEl9NEl9NEl9NEl9NEl9N118lRoGvbpUS45RiFPjqVikxCnw1SXw1SXw1SXw1SXw1SXw1 + SXw1SXw1SXw1SXw1SXw1Sf7VJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHVJPHV + JPHVJPHVJPHVJPHV9MtX4bv9w1dh1hF8FWcKwVeR+jhf5RmM81Wq00l3Z1WkK9FZFXwKKfgq7cyR + gq8O8E+k4Ku0U3QKvkp7ZqfgqzDHvNDKvRfuU4ym2jF+n318pjK++uxwMdWOESrsTbXzjvLsGjCV + 5R3PFPZSneexP18vU1ne8cxNTGX38Tl/NJXfx6fxZSrzWj9zX1N5jKQ6fckqX/t86lifyamprPfa + 89NhqivGq4sA3Ud7Hq/OqnyszR5LR9XpDwA+K1NtLgd74JjKuNwzszJVSUzvTLXryuebajMrHvfe + fxV6+5lqc4CJT8fhqxn2+THV5gDt2eNmKvM9Pu+eZKrttW7P61aXap0+ungfs/cHeCaBptrsceG1 + z6f/KvRmMFWWfnH7V2F161IdvgoVvaay3YCemaipbCe557UTU+3n8fvMJ0y1GfJ8rj01lfUKfu7q + caks72j9eRd4U22GDF0qTLXZ43zu526qcq4qja+zcxV0szHV5uTr2XF2qc7OVd/nampT7RjX87qo + qWwHsuc1ClPtGNPzHMBU1nfluTrYVPbOwa+771xVnim/qaz2gc/ed67iK3H6r0IvC1PtbwesGJjK + e8zSyLF5ToO1X1NZD/ZnJmqq3SMoc4ynDxL0ojaV9bJ4dmSbytYfeaze/Vdp5Jx15IHf2sNXr5oM + uqqn/yr0eTDVnsvBboym2rVIQHQv1ck7oJuzqXy3Azr7k3csjtF3rno7rz2Xgy75ptpzufK83mEf + Wt+5in7R+SrO0oKv8rf25qv0nnjnq6Z6y5GvacI7XzXVW45sqrcc2VRvObKphBgFvnqp3vmqqZQY + 3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mq + qZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY3/mqqZQY + 3/mqqSzGZ455qc48J+MXWdi5ylS2jowcwPlqwww/3fMcVlmvJ8zAnK8y/3K++n32kpnKPA/PfWFN + tVnHF7mc9weAfbdMZcwK5l8r+gN8IU9bzlcrXa8V/VehXtRUV4yN+NdyvtrasxPOVJZb8bHKqfF8 + 9oiYyjyBzy4LU5nv8XnFwFQ7fyRKtpyvDnCAmspZB6nyYVZAYZfz1ZGfvbCmMtbx3E/BVMYBgHUs + 56vXsfgXjXVAhr+Cr8J+TabarAO6x5pqs44v5EPL+erFYOhu2/M46Z2znK9eOx7BfTx8dU7gAMv5 + 6krwJl/OV6nm2lSbIffnlR9Tbd9jB/a4nK/SXlmX6vhXYcdvUxmzenbWm8r2fsI3gF3+vyvxdl5Z + uF7rxMiq0x9g8B06+1u9XNWzvxUR3eV8dRGrXcFXv8+9P0xlz+Nz9fmlOv0BJrCOFXx1wtrccr56 + MVF4TzhfhS7mptoxVlgxWMFXM5DT5Xx10Jrhcr56rTXRLx7/Ks1glvPVATXqptrv1QRzk+V8tdM6 + zAr/KrHa5Xy18xfm8NX2Bea+nK822PHIVFbfAbRz3ftbAe1csb/V4ifN5zkw/1r3/lbPHS9Mtflq + 5hhr9F3h89oe3fm80n+pDl9tzx5dU9n+Vs+dhEy1+Wp+dlmYyuarz/5VU1mvYB73h6+25+4sl8rX + kYHyL+erV0dhen+ddeQM2cm6+eqzT9RU+ajoDp28owP3XcFXX87e+Sqs4K1fvkrj692/aqrX/HFJ + fHVJfHVJfHVJfHVJfHVJfHVJfHVJfHVJfHVJfHVJfHVJfHVJfHX/VWIU+Or+q8Qo8FX7K6mUGAW+ + uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+ + uiS+uiS+uiS+uiS+uiS+uiS+uiS+uiS+un75Kny3g68iQQr/KqzOr1++CnOm2N8KZwrOVzus6q67 + /yrOan1/q4ozGOer0OPMVHu+mpBZef9V2PfUVNsPQP6J5Xy1FpzxBV8F2jmdr159KB/nhTP2t+qQ + ZU7nq2WCm3TG/lYNqOKM/a0KULLpfLV0yB9n9Af4QgY2na9ebixW+X3kX9z5I/RTMNX2BFbwFszg + q4Wv/ekPAN0NTGV+OcgoZvDVBuxx3nwVcoXpfHUmvkOHrxKrncFXiTTPm69yjL6/Fd9t96/CW86L + 4nDnquyWcty56oJfZ38r8kfP4KvzTbW5HOXuM/jq9+28treTiO50vvqFWt28X05776eK1ysf/yrs + ZGKq7V+F7gamKlvFV+L4V19VO8YKpGbG/lawY5updozEo2f0B4COwtmHGO6VZSrzWkO+PZ2vfnnc + H766aL1jOl9d5DCe0X+VKP90vroaX3vLO9bLHbK8Y2Ue9+5ffe7SaipjyOAKnuFfhV7UptrvVWIw + M/yrFd9yh69eXlh4r7p/FfYENdX+dkCXClOZfxXf5IevXgz5cQYzna9efR7gy3f46tWf/HG+Op2v + duhgaipjyDBDnuFfhR5BptpzANg/zVSbPQ5wnc/wr2Yg4DP6r8KumqbaDLkC7ZzOV2t67l1kKpuv + 4kzh8NUCfZBMtedysOfspTp8teEcwPkqz2Ccr76cl81zcuIx4XkHrMTO4KsvX5iTd7x8Hw9fhb1d + TeV8lZ7Hm6/SiBb46pT46pT46pT46pT46pT46pT46pT46pT46pT46pT46pT46pT46pT46rz+KjEK + fHWrlBgFvrpVSowCX50SX50SX50SX50SX50SX50SX50SX50SX50SX50SX52/fBXeTMFXcVar8NUp + 8dUp8dUp8dUp8dUp8dUp8dUp8dUp8dUp8dUp8dUp8dUp8dX5y1dp5Nx8lVVKjIJ/df76V2HmHnwV + Z9vOV6G7lKmMryJxc75acZ4T/lWot5p3fwB+Ht2/CpV6M/yrE2dp3h+g4zza/aucWx2+erkGYC53 + +OqleoxxhH8V9rA31earxDrG3R8Aqv6G89WyoD5tRP/VCtR6BF+dwMnH3X/1uZugqbw36eNVHc5X + L1ZLMR6+Cnv0mmrnj9CJ1lTGV/mqHr4KnXtNtfPHL1+vw1cLvHOG89XWwOszbv8qrFEM56ujgatu + OF8dHd5MI/hqe1Nt1tHgeRzhX+2QwwznqxefoCuRzloAqg5fHdDbz1TGV/F5zHf/VVbtGL9vxzL/ + Kr4nwr/Kv7jeudxW7Rih74qpNntMQCi3anM5oopbtWMkErhVO0ZyuQ7nq0jAh/PV9X071maP/CY/ + fHXBDj6mshjfzmvH2PkOHb7a+Q4dvtqAY47gqy8j5/BVYqIj+CqtBYy7PwCf/eGrE9/Rzlc7UMUR + fLUDLxzBV2luMsK/uvhun/4AE6pARvBV6MFuKuujy2d/+GoFp+WI/gAv75zDV6kSYQRfbeD3HdEf + APY8M5Xtqfem8jkAxXjWkQdUn4/oD9BgVjuCrxb8PjpfTTizynefebr2Zx15ANEdwVdpdX6Ef/UL + 6+4j/KtffjMdvjrB/TFuvvq8Z6OpbA8vcMyOm6++/aLxVajAGbd/FVwW4+ar/IvOV/kdffNVPpbn + j3xer/njkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjqkPjquP4qMQp8dauUGAW+ + ulVKjAJfHRJfHRJfHRJfHRJfHRJfHRJfHRJfHRJfHRJfHRJfHZJ/dUj+1SHx1SHx1SHx1SHx1SHx + 1SHx1SHx1SHx1SHx1SHx1SHx1SHx1SHx1SH5V4fkXx2/fBW+osFXwTUwgq9SZdC4+wNAtdgIvsp5 + x+GrOYF/dThfzdRPdDhfvbo48bH2XA72DLL0y/ZEAL46wr/aoDfWCP9qBn/hcL5aqd/jCL4KO0Wb + asc4wKHXna9elVSPMXbnqzhf7c5X0Q/QY3+rL8xq+72/FVz77nw1U3bSo//qhAysR//VAXy1O1/N + mc/+5B2Fz977kgF77M5Xc4F+HT36r1KP2X73X4W+ij32t8rgmO2xv1UCp3h3vlqJA/TovzrhbdKd + r7YEWXl3vtoSj9V0elkA7ezOV2sFZ1cPvkpMoTtfbdSTtwdfreD37c5X2wSnUne+enX1YJW/c1hl + HAA8gd35aqEumn8qyzsK7GBtqv3Ooe6eW7XHKvket8p8VuDl36r9zinAAbbKYoS1k+589XoD0HnN + U/sA37TufDW/nP08a3N8vSzvyJnv0Iz6DopxHNaBT8fhq4Xc3d35ahnPe8WbytYC8P3lfHXhe+Lw + VSTg3fnqovXHHny14rfW+wN8gUb16A/weqzNHqnmukd/gAFuvx79Aag6pUd/AP52RH8A/PJFfwB8 + 3x++Whesi/boD0D1HT34KtGofvcHAJrena+WL8xqe/DVDmSrB1/NwGp79Aeg7rH97r8K9TA9+CrV + 6fS7/+rbL9ocAOa+/ear4OTtd38AvhIn76D6jh79Vye/MY+vo0Ffsh79ASqw7R58tcJKRg++SllA + D7764ZmC9weATgn95quQUXSpP0CX+GqX+GqX+GqX+GqX+GqX+GqX+GqX+GqX+GqX+GqX+GqX+GqX + +GqX+Gq//ioxCnx1q5QYBb66VUqMAl/tEl/tEl/tEl/tEl/tEl/tEl/tEl/tEl/tEl/tEl/tEl/t + El/tEl/tEl/tv3wVvlY/fBW+Cgpf7RJf7RJf7RJf7RJf7RJf7RJf7RJf7RJf7RJf7RJf7ZJ/tUv+ + 1f67vxWNCfevIsVId595mMG4f5Vq+nvwVeYmzlcr0OEefLUjJXO+yrQg+gPAanO/+wPw2Xt/AOQm + 3n91gregR3+ABN67dvcHACbaov8qdY9t0X+VfAot+gOQt7NFf4C/bO7xerXov5oh02nOV1uFLLNF + /9UOfXRb9F+l3SGa89VBtW4t+q9mcJM256uDSE2L/qsLqiRb9Aeg7ovN+eoswAtb9Aegrn0t+gNQ + h8kW/QEmPLUt+gMQq23OV1cCX1pzvrpgH2JTWT0yZHMt+gM0cAS16A9AmWG7+wNgjO5fHUAL2t0f + AK/94avf9HasHeP37Vi7rjzx2Z/+AK+qJpzX6b/KYyIL/Ve36tXbuVXm7QTi1sK/ymPC/auVz36+ + 95ht4V/l94T7V6mDQwv/Ku1b05yvTlqjaM5X58R39OGrk1yuLfhqA5dYc746C3CmFv5VWh9qzlcH + 7MluKqudLxjj4avE71vw1QQrni346uIYD1/tsKLegq8SQWrBV6nXU7v5Ks46nK92WFls0X8Vdqc3 + lc0BoF6hRf9V6vXUgq/SbmYt/KvUxakFXyVfbQu+mmBVpN39V4E0t5uvArVuv/1X6ezPOvKXx9fp + vzp53Hv/VSC6Lfgqz0Tdv1qAWrfgq18e95534BzA+SrtLtiCrzYeE143x285778KndDab/9V+kXB + v9p++SqNQoGvNomvNomvNomvNomvNomvNomvNomvNomvNomvNomvNomvNomvNomvtuuvEqPAV7dK + iVHgq1ulxCjw1Sbx1Sbx1Sbx1fbLV+G9qvDVJvHVJvHVJvHVJvHVJvHVJvHVJvHV9stX6aoKfLVJ + /tUm+VebxFebxFebxFebxFebxFebxFebxFebxFebxFebxFebxFebxFfbL1+FL7LSf7XdfBVcA+3u + DwDVru3e3wpqdVv0B6COnC36AzTwf7W7PwDOo6P/KuwX0JyvXjtXwWzo8NWrFglmj94fIIF/ooV/ + NcGuwO32r0L2W6M/AO2cUKM/QIauCzX8qwvyxxr+1Qmerep8NdMuWNX5aqVOVfXuDwDXvjpfvfa2 + oPM6fJV206ixvxVVENabr8L7vgZfbdBttwZf7eBprsFXyclboz8A9eOrd/9VeNJq8NUC+XYNvkrd + DWrwVXJR1+gPQLvu1OgP8IWMogZfTfBercFXE2RNNfgq8a8afJX8cjX4KlHrGnyVquKr89VGq0jV + +eq1kxxcr8NXx8t5eX8AoIpbtWOk/Zq2ymJ8+8XNkKlTwlbZfXz7RasrB+JWna8O6ilena926qJZ + na+OAWyoOl/tAyhZdb46Onw7qvPV3vANcPgqdgipzlc7rZRV56vXTkx0JSzvGLTjZHW+Ojq+AQ5f + 7eQKrs5Xr/c9/WIPPzmNHMs7rh4u8BU9fLUnvvaWd7SCX9HDVyvtXlmdr14eShpflndcu9PT3W7H + T85jwvKO8oW9JKvz1dLefnGzR+K+1flq6bAuWp2vlgXr2zX8q1SHX52vlsTviRreTj6WzeX421HO + 3k/A0qrz1ctbQOd1+CpVi9Xgq5lH9OGrtKtmdb76oWqeGv7Vzlfi5B08n8j3vg98LMs7YE5eg6/y + DDn8q5B31OCrGVzB9ear4Bqov3yV7qPzVf7yCXy1Sny1/vJV+A4pfLX+8lWIUeGrVeKrVeKrVeKr + VeKrVeKrVeKrVeKr9Zev0h0S+OpWKTEKfHWrlBinFKPAV6vEV6vEV6vEV6vkX60SX60SX60SX60S + X60SX603X8WvVfBVnFn98FUaq4J/tUp8tUp8tUp8tUp8tUp8tUp8tUp8tUp8tUp8tUp8tUp8tUp8 + tUp8tf7yVfi6B1/FuYnz1dwpo4j+ADi/d75KvLDe/QGQ3jlfHd+XY9lcDvhqvf2rmGW6f7Xxebl/ + FdwyNfjqhLXyGnyV+stV56sX0aUYzzxnQQ+E6nz1s6DevUR/gAl1hiX6AyyYr5bY34pcYiX8q9TZ + qzhfbVRVWsK/WsHrU8K/2iDTKdF/tYFPoThfbZQFlOCrBbKmEv1XO+QwJfqvElMo0X+V1gJK8FXa + dbrc/VfhPVGcr157lND1ysFz+FjWJxC8ZCX6r1Ln3nL3XwXiVu7+q7CKVO7+APA2Kc5Xr17Bj2+T + Ev1XE46cw1dbA+pT7v4A4F0pt38V/Dkl9reiOunifHVSL+oSfDWDU+lPZXlHG8BztmrHOGD+tVXG + 5YCubJV5AoH6bNV+HhuO+7xOP2ToVlmcr7YBDvYSfPX7dqw9VjN0/ynOVyf1JCnhX61QO1+cr84v + 0M4S/lXaBas4X70cehTjiP458P46fPXqlcLHMr8cj5yTd1C/x+J89UOrD8X56t+rCcfXyTsW38d+ + 1liBIBXnq4U62xfnq9jPvThfzQNWyorz1bxgxaAEXy18vdrpEQSVG8X5aqau3MX5aqaevMX56ufl + STt5x4IaluJ89eq1CV+rw1c/VJNRnK9e9e70pJ28o+PM6vDVD3WzKc5XP9Rnvjhf/XsTvBxrx0gr + xMX56tWXjGK8fR30i+7rAAJegq9S7l6Cr9LeTyX4KtXzleCrryrPH2nce38AoJ3l5quQUZTf/gA0 + Cm//Kl2Jm6/SHUrvrKNI/tXyy1fhbit8tUh8tfzyVYjxh69SjAJfLb98lc7+5qvwDP3wVT5WllSv + rKNcf5UYpxSjwFe3SolxRox0vW6+Sqqbr9KYGFKMAl8tEl8tEl8tEl8tEl8tEl8tEl8tkn+1SP7V + IvlXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi8RXi+RfLZJ/tUj+1fLr + X6X3hM9zMJN2vloxo3C+SjvSlPCvdpyJhn8VZzDuXx2Yi7p/lXakKc5XPwvncoevfmi3lhJ8lTwi + 5earmBm6fzVBLpqDr1Ygbjn4aoUdyHL4Vwfk7vn2rwInz+FfXUDv8t1/FWbI2fnq1TP1cURn56u5 + Qj+rHP1XB5CtHP1XyQmXna9ePpjHsZqdrxba0zg7Xy2Zr/3Z92EAe8zOVzN198zRf5V2wcrOV0uF + Zzs7Xy20c1V2vlo6rHdk56u1QWaYna8WcgTl4Ku0kpGdr84B79XsfHVUPHvnqxNm7tn5ai/wLsyx + v9UC710OvkpdBLLz1S/t6pSDrw689nkdTyDk21tlawHgjdoq4+R4h7LlHZ12/N6qXav7BQ/SVu01 + HX7nHL7a6duRna+2L75zDl8tC1htjv6rX3xHH75aCjgHs/PVQusw2fnq1XmcjnX6r3aOcZx+yODZ + ys5XawdWm52vFqohzs5XrzoKUvWzZxBkYNn5aqUdorLz1bpgPS07X60J/IU5+Cqtw2Tnq1dXIhoT + 7l/lZ/v4V1/Ovp26cvAO5+CrBdZYs/NV3C8zO1+9CDj94sk7Bn5hnK82foZO3kE9n3PwVXL85/Cv + Jr5DZwbTOMYzg1mwJp2dnF47RNG1L7GSwb/o3Zz5F9O5EnQsd6byHfKMAlZi891ZFedM0Vn1TbVH + YeE3kztTwbGRb2cqf4d85yp+Opyc8shxcgoOhPxLTulKCM7ULJHTLDlTs1T5nyVymiVnapacqVki + p1lypmbJmZolZ2qWnKlZIqf5+qvEKDhTt0qJUXCmbpUSo+BMzZIzNUvO1CyR0yyR0yyR0yyR0yyR + 0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR0yyR + 0yyR0yyR03yTU5wDBDlFnhM7VwETzUFOB9I7J6fft1/0uRyrvIsTzBTcmfqXi8IM5pDTQhU4OTqr + VsykvbMquTZzdFaljlDZyWnNUL+do7MqVYyn6Kw6YeSk6Kz6Be9wcnLaMmTlyclpo0rQFM5U6hKW + nJz2BNlvcnLaqc9Dis6qA7xRKSr/vzDHTNFZNUO9e4rK/8oxnsp/2n8oReU/+eVSOFPJ/5XCmdrA + Q5nCmUoUNoUzlXZkTlH5n8AJl+7Kf2DuKZypLyPnOFMXPx1e+Q+ZYYrK/wKrIikq/8kTmKLyn2rn + 0135j7/ozlTq0ppucgoMOQU5TW/ntV9O1JHz7//3zqr8i6fyn3yPW2XkFJ/tfDqrTnj7bpXdR3wX + Zss7vtRrIDk5fYvR8o5v5188zlR+Ht2ZuoDMp3Cmvp69dY/ls7e841t4RFve8aUODsnJ6aKegyk6 + qw74Iqeo/Kf9ylNU/lNv5RTkNMN8IgU5TfyL/ewGBF/35OS0UEf05OQ00x7jKZypGVyIKZyp5B1O + 4Uyl+VcKckr9c1JU/if8KrgzlXbUSuFMpbW55OQ0L/7FM89JfL1OBQ7tqpmcnFaq3EhOTuvEmdVx + pl6dEmjcl5jL0fU6HY6o20hyvnr1eqL7ePgqrQYm56slQ9VMcr567RtIxzqdVcmnkJyvXp5m+sWz + Qvwyog9fJbdyCr7a+Fubo7sBHevwVZ7xOV+tfLedr/IzdDtTWeU5Ml1Vga8mia8mia8mia8mia8m + ia8mia8mia8mia+mX74KI0fhq0lypiaJr6brrxKj4EzdKuU+Cnw1nb+CSolR4KtJ4qtJ4qtJ4qtJ + 4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qvpl6/C/Evhq+mXr9KTJvDVJPHVJPHV + 9MtX+byUGAW+mn75Kv2iwFfTL1+FOVPwVZwpBF/FXFTprJp+O6tSjIevZlhjTeFMzbAmncKZSu61 + FM5U8uekcKZSpXG6nak4L3RnKu2Ym6KzauEnzeY5efDISSfveKaw15TjPI/r2YFgKtsJ4NmxYap6 + VE9zX1N5dwNW2Xz1OSs31XaJQX+5S3XyDiCnptousfzs/zLVZsj9mcuZajNkcMKZ6oqxwx5LpjIO + 8Oz2u1Sn8n8++5lMZXz1eXyZase4np2Dptp8tT9Xgppqs471zH1Ntfnqy9kfvvoycg5f/T77ak3l + XI7ukD2PtKOWqa4Yrx186Ok4fLU9v8mvyb13VsUx4XwV9j431Y4Rdlgx1Rt7NNWOEfbmMdWOEYju + pTqdVYHommrHON9U1lmVr4TvXPV2Xnmr+NqvV/Z4qc7OVUDATWWcnK/92bkKdnUy1Y4RdsEy1Y4R + 1gJMZV2A8e17+CrxaFMZJ39eozCVdTp+5pimMr76/N021R6rwNxNtd850Lv7Up2dq774VfCdq+Yz + lzOVdch95iam2u9VWH801X6v8rfDd65azz02LtXZuWo+V/6bytYfn9mQqfb6I+zvbirvHkvX6+xc + BV12TGVOcY7xrCOv5w40ptpr5fPZRW0qY4987b0CB2cKh69ea/h89laBw1f1+FcLv++Pf3U8d0Ex + lbFHfh4PX03PLgtT7bncxJmC89X67Ji9VKcCB9ZhTGUeXX5PeMex56zJVFYtxu/ok3es5xViU1kH + h+ceQQb4rKsav7+88p/vo/PV5/6rpnrLH03lOTLdR+erz36TC0/efBXu0A9fhbP/4av8i28cwFRv + PMdUzgHgDv3wVbheP3yVzv7mq3C3Bb5qqjfWYaq3qvhLNaX7ePNVeLbTzVf5F5UYna/i2ze989VL + 9c5XTfXWpcJUSoxDeR5/+CqNnHe+eqmcrz6vXJvqjcuZyjuqsMo7q9LZv/NVU3mMdLdvvkpX1fkq + n32T7uPNV+kNcPNVuvYt3qv0DN18ld6Y9ZU9msrvI519lcbqO1811VtHlUt181W6Xu981VTKfbz5 + Kh/L+Sqfvd9HOtbd4SihymOks88RI42Ju8MRvcnvDkf05csRI6m8w1F/UXkHeTqvex2ZxoTPc3D+ + 5ZX/GTmmd1atz0T3+hw7X4W57wq+CntAm8pryvhYe04OfRVNtRky7AViKosRxsRyvvqpwAuX89XL + gfB4VVdU/pfnemRTbX/OhJGzovIfdjIx1fYhDyCBK/gq5R3r7qzK99F3roL3xAq+Cr1JTbVZR4an + Y907V8E3bQVfrcABVvDV8uz1MZXxVb72h692eDOt4KvQndhUxqxwRDtfBcesqdyj+/itXc5XyR9t + KvPoAmdazlcX7PJhKosRaOef6vBVcG2aavOc9Lw/sqksRhxf+VT+d45xHZ7zXGlsqs1zBr7lvLMq + UbLlfLVCV25TbWbFz6PvXMXvHN+5asCcacXOVYvPy/KOq8csHcvyjkksbcXOVYOv19m5qjx7FU11 + xXj166DrNc57FVbdVvhXJ3y3V/hXYTczU1kHB1iHWcFXaSVjOV+9OkvwsawL8PPK9aU6lf/gjjTV + fh4XrLEu56vX08GqPVZhBx9T7ecR9pEylfFVfsvV07Gaf7GeNdZnB4KprE5n4B06/tUFs7R1+1ef + /QCm2mO18/No85zyhSxgOV+9Kqno7Mur19pU1v2Hr/3pD/Dlr0I5NWXP3Wwu1fGvViDN6/av8jva + /av8/srBkOkLc/KO8Vxhb6o9XyXXwAq+mnHmHnwVcoX1y1dpfKX33Gr98lV6Om6+Cm+AH74K4yu9 + +1dN9eZBMtUrl1sSX12/fJVU7/5VUykxvvcHMJUS43rncuuXr8LdTu/+VVMpMc53hrz/KjG++1dN + 9crl1i9fhedR8K+aSrmP7/5VUykxCnx1Kf5VU70yq/XrX2WVEqPAV9cvX6Wx2qR3zrt/1VTKfXz3 + r5pKifHdv3qp3vsDmEqJ8d2/aiolxvf+AKZSYizSfXzvD2AqjxFmaYJ/1VS+psPHcv8qfR+9P8Cb + ypgVzoZi5yrMa52vfmG9Y907V+E8x/sDQJ2hfV72XO6LszTvD5Bxjun9ASpSRe8PAN2lTLW53MQ5 + 0+Gr1164j1d1Ol8tFVb6Z/QHgI5jptqd48i/OmPnqi+4LKbz1Suv5fOyHPm5uu5Snf4ACbwYM/oD + QD8FU5m3E8b9jJ2riGzN8K9Chb2pdo48wXkzoz9AguxkBl/t4MaawVfn806+ptoc4PtcVWqqzR4T + 5Gnz5qs8JpyvQj40g6924CYz+Co4xU1VpGOZfxXI1nS+OmEP6GtSePhqxjHh/lWinTP6AxC1nsFX + C5D5GXy1A/edwVcrq5yvvql2jOT33SrzdoKXbKt2jI2v1/Gvvv7iq7dzhn+VMukZ/lXynM7wr0Ln + S1Mp9/H4V1/ukOUdc0G+PcO/SmR+Bl9d8N2e4V+lVbd5+1fhyzfDv1rwa+X+1QzO+nn7V2FmNW// + KlDrGf7Vzmd/+Gp53n/IVJuTE6GcwVe/4Amct38Vvx3hX4VZ7Qz/aoEVvHn7V/H7GP5VfjoOX4WK + pUt1+Cqtzc1fvsoq65D73IHZVHueM8C7MoOvvrxzzjwnAU2fwVdhf1FTGV+FFYN589XnvcVMZXwV + 5qtT4qsz+Cr0FL9Uh682oMMz+Gp9rvw3lfNVeoYOX315Y568I0HeMe/+AKw6fLWB52EGXy08Cu/+ + q3T26T1Hnr98lVWvOfL85auses2Rp8RXp8RXp8RXp8RXp8RXp8RXp8RXp8RX5y9fZZUSo8BX939K + jO/9AZJPpQWVEuOUYhT8q1Piq1Piq1Piq1Piq1Piq1Piq1Pyr06lP4CplBgFvjqV/gDXf+/9AUyl + xCjw1Snx1Snx1Snx1Snx1Snx1Snx1Snx1Snx1Snx1an0BzCVEuN7fwBTeYww6/jxr8LM6qf/KszS + gq/izMr5KnSFNJX1mUe64ny1IfVx/+oAt8wM/yp0cbJX747xi4Ty8NVcMe9w/+pCGuX9ATLmVt4f + YCL18f4AdCVG7Fw1gd+Puz8A5B0j/KsJXHXD+erleXic+47wr8LewabaeccEb+dwvtrycwcHU+3c + Crq0msq8ZEDJxt1/Far+xt1/9bnvsKl2/9UOPtERfJVI8wi+SmsUw/nqTDC+hvPVy036+DyO4KvQ + T9RUm3UQXRnBVzusw4zgqxWetBF8tUOeNu7+AFAvOn77A/DZby6XIMscN18FpjCCrxI5HTdffTuW + sce387La+TfVjnECcftTHb46gYlulfVAeDvWjpFy963aMX4hy9yqHeOXr6rlHWvx2R++Sh0cRvBV + Ikgj+Ork8zp8FfZiM5XdR5hPjLv/KqsOX234bHt/AOITI/qvEh0ewVe/z50cTWXPI9C7EXyV5gDD + +SqusAznqy/vnMNXZ4IVvBF8FfoNmWp/Ozp0JBjOVwdR/uF8dcDePKYy/yq4i0bw1clXtcX6I8wU + Dl/tGeoChvPVDp1CL9XhqwO/Vs5XaeV6hH+1g2d+OF9tsK+bqTZDTs/9ak215zlfmJOPu/8qj5zT + f7XzHbJ5TiXX5nC+eqlofJ06HfI0j+gPMJ73frpUpz8A8fvhfLUkvkO+QyeslY/gq9Bt11R7vvry + DN075pLq5B0Vul6N4KtUGTRuvgrr20Piq0Piq0Piq0Piq0Piq0Piq0Piq0Piq0Piq0Piq0Piq0Pi + q0Piq0Piq0Piq+P6q8Qo8NWtUmIU+OpWKTFOKUaBrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6J + rw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw6Jrw5lfytT + KTGWiBHmANEfALxk4+ar4I4cN1+FKtwRfJX6PY7gq7AvuKlsHRk45rj7r/L18v6rUKcznK9edeUw + z3G+2qCL0wi+ylmm+1czEMoe/tUGDLk7Xy2wL7iptucB9mow1Z6Tkxurh3+VMsN+81XwR/fgqwmq + B/rNVyE76Xf/VXBG9Oi/SnW/3flqg91HTGU1nsBgevQH6OC17s5XOzlvevhXM3i2evhXiQ736L86 + wNPcna8O2HXaPsebdcDuSaay/gA8or0/ADhJevBVqiHuzldbgty93/5VYDBd4qv99q++qYyvAv/q + N18FXthvvgqUrN/9V4Fj/qmcr/LZH776xbudD1+lXq5bZXwV3uRbdcX4pZ6WW5UE1dnfirqO9tjf + ikf04avfhO/Cw1dpRy1TZelY+z5+eeRY3jFpba47X23kJu3OV0eDCvvufBVdwd356nq5EuOsd/Ad + OnyVVil78NUBHWh68NUBK2Xd+epssFbena9O6mbTna9O8mP24Ks0n+jOVwdVlHTnq2OAJ7A7X732 + RqTr1c76I49CyzsG7I14qWye079AFbvz1T7xy3f46tVjlq6X81Xgvj36r1boSNCj/+oXVgN79F9t + fO2Pf7Xy8+j+1edd1ky153Kdr/3hqwvqh3rw1Zd39PGvZh73x78KO+aaaseY+Olw/yow0R79Ab6Q + NfW7/yrfbeerQNP7zVf57Zve88cu8dUu8dUu8dUu8dUu8dUu8dUu8dUu8dUu8dUu8dUu8dUu8dUu + 8dUu8dUu8dV+/VViFPjqVikxCnx1q5QYpxSjwFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7 + xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFe7xFf7L1+F + +UTwVVgX7bd/lY/lfBXnE85XK/gU+s1XYX27B1/9gsetR3+AgrNH7w9APc56+FcHEjfnqxU5k/PV + wVf18NUOjtke/lXqHNecF1ZyGDfnhbUDG2rOC2uCHKY5LyzEmZrzwvIFr09zXnjNyflYO8b+ptox + EnNvzgtrhfl9c15YaSeT5ryw0v4wzXnh1QOBrkQ63BfqH5vzwot1sGrzQiJbzXnhSPDUtpsXAo1q + wQvJHdmCF9J6R7v3a3o7lvVMBWdqc144KqwY/KlsHn2p4Kpmm0c36jayVeYbAmfXVm0P+IS8dqt2 + Xpvfzt58Q9B/ojkvpP2kTbWfxwKerea8sDSonG3OC3OHtbnmvDDTnmfNeWGhThzNeeF1LFZZjJC7 + N+eFNUNPy+a8sL5cVZtHF6IYzXlhph21mvPCa0d5OnubR+cM39rmvDBTJUJzXojrj815Ya48cs48 + mrp6NOeFH+q225wXVuoa05wXFuok1JwXXp1V+Rf3fWwws2rOC2sDV12L/Zpe3pinr0/Hb4fXu2eY + wbTYr2nBKnhzXnhV8/B57bFa+do7L4QV9Xbv1wQ1GS32a6JuEC32a6Ka/hb17h1WdZvzws8Xui40 + 54WfCbtWNOeFnwn8vsV+TY3fTGceXcCP2YIX0gy5BS8s0CO7/fYTpfPyfqLAfdtvP1EaX84LeUwI + vLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBJvLBdf5UYBV64VUqMAi/cKiXG + KcUo8MIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm + 8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm8cIm9RNt0n5N7eaF4BJrNy+EGpZ280JwwrXghQUzaeeF + lc/e/Zg4J3c/ZsPZo/sxqTawBS9MSB6cF2bwf7WbF+L8y/uJrjeV9xN9vPY1/JgL+ESNfqLp7VjG + HuG8avgxE/jl6t1PFGhBdT9mI5dYDT8m1SLV8GNSVWkNPyZx3xr9RAvUzdXoJ0re4Xr7MSHvqLcf + E3L36ny10S5F1fnqtXcKXYlT714gF63hx2zgGqi3HxOYVQ0/5oQcpt79ROENUJ2vFtrDqzpfvXwd + FON5HgusK1Tnq5m8w9X56pWxwrEOX/0seEdX56u4KlKdr9YCpLk6X60Z/PfV+WoteO3zOv0ngCBt + 1fZGkd93q/Y7h/ZF2irjOdCdZauMAwCf2CpjHTgmnK/SvvM19msiz1Z1vjoLdKussV8TrStU56tX + tStde8s7cPfw6nz1ctbTsQ5fHXwfb77Kv1jO3eZf9F7UrNoxdh45Z78m6mVRY78m8pJV56ud/F81 + 6t1pjaLGfk0TqE91vlpp1lGdr16+NHpPWN6RO34fD1/NtJd3db6aM6ynVeerOUFvmep8Nb88HfV9 + n5/qfDW/3O3T14f23arBV8nxX4OvFlgXrcFXM37dD1/90Epsdb76mdANojpfvfYfYpWt4eN84vDV + D9WK1OCrDVzUNfgqzzqcr+aJv3jyjgzr7jX4KlWe1eCrH1gfqsFXadfpGnz1w8+j81Wc+/74MflY + RVK95shV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qtV4qv1+qvEKPDVrVJiFPjq + VikxTilGga9Wia/WX74K7xyFr1aJr1aJr1aJr1aJr1aJr1aJr1aJr9Zfvgrvrx++Ct/HH74K7+gf + vgrzHIWv1l++yuel3EeBr1aJr26VEmN9Z4/1fBiEX1RiFPhqlfhqlfhqlfyY9dePCbOh4Ks4U/ip + d6dj+TwHSY3zVWK1NfgqUzLnqxXWt2vw1cFjwvumI4Pxencmbt5PlLO5w1evfu4wjz589drfCmZ8 + h69+BnCT4nz1M+G8ivNVzIeK89W/Az6ffXG++pckP599cb76odqt4nz1Qz1Ai/PVD+2JUJyvXleV + rtd5Hid4V4rz1SuHeRzRxflqpl1ui/PVy0nyOAqL89XPAndkcb6aG3Cm4ny1ZCAixfnqtecsjYnT + Z4t2finOV5EqFuermXaBL85Xy4DspDhfvTqh0dnb81i/sLdrCf/qy1g9/tUG78LifHVUmCmU8K9S + PXJxvnrtugNP2uGrnfxMxfnqlzy65fav4pOWLe/4Fj6W5R2TeuhtlcUIDGarinC9Tj/RBQRpq3YN + MXVDLdFPlPxyJfqJknOwRD/R/nasHSN1jy33fk0co+Udi+hwiX6itLdYiX6iCXoglNiviRzG5d6v + CVbdSvQT7eCsL9FPtECPjRL17hnqO0rs10Tdr0vs1/QFp2UJvko9eUv0E62wdlKin2gCGlViv6Yv + uCNL9BOlevcS/URp96Ry9xPF77b3E6VO7SX6iSac50Q/USDzJfqJVuhZX6KfaMbvkO/XNIGJltiv + qfPTcfr60L7zJfqJJuCrJerdF86/vN6dqoxK7NdE6x0l6t1p3b1EvXsBXlii3v0LzogS9e60+lCi + n2iDmXuJevfCT4f3E4U1w+J8NVOf0xJ8tfP48v2awMFefvuJ0vN4+1f5WK8coEh8tUh8tUh8tUh8 + tUh8tUh8tfzyVbgSCl8tEl8tEl8tEl8tEl8tEl8t118lRoGvbpUSo8BXt0qJcUoxCny1SHy1SP7V + IvHVIvHVIvHVIvHVIvHVIvHVIvHVIvHVIvlXi+RfLZJ/tUj+1SLx1SL5V4vEV4vEV4vEV8svX2WV + EqPAV4vEV8v1nxKjwFe3SolR4KvlfPw+11cUZgrp3q+Jvh2+joxMwfnqwvl98n0pcfZ4+OpV5c2/ + aMwKZ0Ne784zK693n8isDl+93B8U4/GvJnBZlOCrC/NH56sLZ+5e757AW5Bvvgoeyhx8dQHjy9FP + tIHrKd/7NcHIyeFfJbdM/t2viWI8/lXqEpadr5YvZIY5/KtfcLhk56uFaFSOfqIFcpjsfPXqrEox + nv4AGbhcDr5a+Eqc55Gczzn4aoeuatn56od2gc/OVz8LPODZ+eqHvHfZ+So62LPz1atnF13V8zxS + bpWdr35ot5Yc/lVarcnhX12wupWdr2bqFZzDv5rgPZGdr36oyjs7X71Wfh7fX9n56of2K/9Tnbxj + 8NmvUxcA5GGrrC6Ar9fJO75v52VrOsDctyodFTwdh69+OvSYzc5Xr04vfCwbq7BHSXa+eq01scrr + WGkUzli3omOdvKPw9Tp5R4XVwOx89boS8Dwevvpp8BXNzlevtUyKcUQNC43Ck3dQzXV2vvqhjirZ + +eq1skgxnryD33KHr36oc0mO/gBE03P0B3g5rxbvVRqrJ++Yb8eyGMETmJ2v4jwnO1+9VPSLZ55D + PS2z89UPrQZm56uf8faLNlbxC3P46odWDLLz1Wv1FL617l+dOONz/yp1vszhXyUvbA7/6sSvu/tX + ycmbw79K9Qo5/KvU9T3f/QFgZTGHf5V6DeTwrzbIYfLdHwByhfzbH4DO3vsDwPpQvv2rOPcNvspv + zNu/Sndb8K9mia9mia9mia9mia9mia9mia9myb+aJb6aJb6aJb6aJb6aJb6aJb6ar79KjAJf3Sol + RoGvbpUS45RiFPhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhqlvhq + lvhqlvhqlvhq/uWr8E1T+GqW+GqW+GqW+GqW+GqW+Gr+5at0JQS+mm++Cg69fPNVzGuT+1eRM6Xb + vwpzgOT9AaBKMh9EsWdpdPZnnjNwxpfOPOeLMyvnq42v/ekP8AW+mp2vXqvzdPbHL5dxLnf46lX1 + RzHaPKfMp1Xw/aY/fDWPp1zUVZY/PnEAV1k/q6fZo6ucA/Cx3If8/38lXLXvY3/yKZjqPI/rqbOq + q4xZPeWirvK+sHwsq7l+Gquu2nx1Po0JV1l/gCdqbSp7Httjt11XbX/Oo/PGVdvbOZ5WWFy1e5OO + Jy7nKq/VZZX5Hp/q3U11+gOkp/UhV9meVDxy7Hnsj31hXWVeMr729jxeO0RRjOl4AvF6Hb76LU+e + QFftfX4S/qL7V+sTaXbV9j32t/Pa/tXHfZFctT2Bic9+vexJ5aod4+O+867a3s7HXhau2r7Hhm+A + bHnHeP3FtM/r6ftoqrNfU3tT2b5bfPaWd4zH9SFX7efxcR91V21P4HharXGVeQKfWIepTn+A/rQu + 6qpdO1+e5gCucj85H8v65zw5/l3lPS3pSnj/VR4T/fS1fnJHuso8gU9czlXWA+GJf7lqfzse9zxz + 1f52pCdm5ap9H1+e2uNfHU8MxlX7vfro+HfVXn987A3vKvM94pfP+wM8doZ21b6PX5xPeH+A9USH + XeW9SensT3+Ax9UtV+2xmp44uatsLQC/MM5XJ99t56v8bJ+8oz/N3F1l7BHnAM5XxxMJdJXx1YIj + 5+Qdj9U8pjp5R8fvtvPVx3VRV+0Y85Nb2VU7xsdOtK7aMean9TRXWW711FnCVN4fgN8Azld5RN98 + lVWcP7qKc2RXeY4M9/GVr7rKc2Q4+1e+6iqPkc9LiDH4Kr4ngq/iGyD4Ks5qX/mqq4T7+MpXXcWs + w1RvfNVVzDpcpcT4xlddpcT4xldN9cZXXaXE+MZXXaXE+MZXXaU8jzdfZZUS4xtfdZUS4xtfdZVy + H9/4qquUGN/4qquUGN/4qquUGN/4qquUGN/4qquUGG++SuPr5qv0xnzjq65q0rE8Rnr73nwVvts/ + fJVivPdrIpXzVcykna9+MANLd38A+op6f4Anh4urjMvhnMn56qNfzlRnnsNZk/cH6HxVzzyn8Pg6 + 85zHHlSu8rwD5qvOV/NTnfTfO/wb/Vfzk3/VVZYjP7kZXHXFWB73ynLVzq0eOxK4anO5+sw6TLVj + XM8536Uqp8fs8/zeVFZX/kT5XWUc4DmbM5X1e3we96baMSa+9se/Wp+fjktlz2OtT+5uV+37uJ7n + q6ba9zE9dS9z1eY5wKxMtZnVeKbWprI+unxeZ3+r+Zx3mMpqPJ+fIVNtZtWfHEGu2lwuP7mLXGW9 + EJ8zMFPtGB+rlrfq8NU5cEx4f4D2TB5MdcX4XOXtKqsrx6t6+Oroz3maqYznPNUZmursb5X4WOuw + x+evqKmuGGd78oC7yu4jX9XDVx894K7ins+mmqc36ZMD1FV7rPZn9mgqY1ZPq26u2s/j93mFxVQ7 + xsc6VlfZO4fPfpwes8/fR1OZZ55jtLwj8/vL+Wp6ng2ZynyPT55TV1l9x5Ov1lQn7xjPpMZUNgfg + a3/yjse6X1eZt/N5nmOqfI5Fo/DkHfOZDl+qk3cAoTSV+Vef6Z2pdoyPFeOusrncU58aV7mfnM/L + fI/4rXX/6mNHTlfxfgGushifuYmpLMbn1S1TGZd78qa7Kh0VPR0n73jsYeyqdu4Q3ceTd3S+QyXG + Kl3Vk3fMp3oYV9lY5fd9jtoH+sV7fys+1o5x4XzV+eqjK9hV3rOL3tG+7wO/c07eUXisnrwjc4x3 + fwAaOXd/AP5Fz5H5WG8c4E/1w1fhF1/9q6564wCmeuMApnpjHaZSYnzzr7pKifGdr5pKifGdr5pK + ifGdr5rqjXWYSonx5qvwxvzhq/yLSozvfNVUyn28+Sq8V9M7XzWVch/f/KumevOvukqJ8Z2vmkqJ + 8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8Z2vmkqJ8a0/gKve+Kqp + nK/C9/GnPwAdy/sDPPseTWU9Lfkt5/McnD0m7/f47FU0FdeUuWrnVpXPK5388dkJZyrb+4nv0PGv + gs/KVBYjZnPOV3lO7v1Xv89r5WVFf4D61IXOVTaXg6x8hX81w1Vd4V/NkKet8K9SrrDCv/q4b7Op + PO+Acb+i/2qGfGhF/9XydiyvDaSrep7HAnnHcr56XdXHmeiK/qsfvo++3vG8+mCqeu7Q4/hazlc/ + +dnTbCqL8Xml31RWN/fseior+gPUpypvVxkHePZGmWrH+Nil1VX7eczwzlnOV/NjR2FXuQcJxtfh + q58G3GTF/lYF3pjL+eonP9Wxusr9OXAlvD9ABmq9oj8AvTH/VCt6y8B9zCfvILqyVXYfIX/cKruP + 9UVl95Hv0IpvB9xt7w+w8Hn0/gCTz/7kHQPf5IevXr39YNwfvnqNaD4v83Y+VUiY6vDVxSPH8o5r + vyY6++N9guoBU10xfh+72rrK+ui+qbaffAInX85X12O3XVfZesebaq8FFFjTWc5X52OXVldtz/yE + +ddyvjoHj/t2eszyyLG8Y4Dv0VR73arxs215xygwx1zRf/ULZGtF/9WXMWHznN74Stg8pxP3XdF/ + FTzNptrrHY9dk121fcj17Rf3esd6dkdeqtN/9bG3jKv2fPWxe4ar9joyrbot56s1vR1r91/tsLq1 + nK/mL2RgK/jqYzcIV+01HWLIK/qvVlh3X9F/tfF74vQle9yr1FU2J8c5pvPV8VyJYCrj5Pw8Ol99 + rhUxleWPPKJvvsq/6DkyPGk/fBXu9g9fZVWVVK8cYEl8dUl8dUl8dUl8dUl8dUl8dUl8dUl8dUl8 + dSn+VVMpMb77V02lxCjw1f1XiVHgq/uvEuOQYhT46v6rxCjw1SXx1SXx1SXx1SXx1SXx1SXx1SXx + 1SXx1SXx1SXx1SXx1SXx1SXx1SXx1fW+v5WrlBgFvrokvrokvrp++Sp804Kv4uxR4avr5qs4Swv/ + Ks4n0s1z6Bed5+BM9Me/Sl9R969iZvjTH4Cu6ukP8MVZrfcHIBfiiv6rjztguGr7HhPPTWyeU8hN + usK/Sp6aefcHAD/AdHL6vM+1q6wqHu72DGfqeq49NdV2iRUYhTM6qxbwBE4np+0LM+Tp5LQ/7lLk + qivGPp66Xrlqu8TSc38AU+2q+AQEaTo57Y8dTF21M8Mv8Ojp5HQm8A5PJ6eDHFQznKmP+xC7at/H + L48ve9JaAn4/w5mawfc4nZzWx86Xrtpj9bEDoKusCpevqj1pcwItmHflP45Cd6YSz5lOTr/57Vib + RkEdvql25X+G79B0croWrA/9qd52rnLVrvwnh/FWmfv27VjmvoVvx1btGBtfiXXuI6wrzKj8L3z2 + 83Q34POa5z7y3T47V72cve9c9XZeRhWf604u1TguamCi08np7G/H2u/Vx57irtrv1c6j8OxcVcEB + OmPnqi+4sWbsXPXY+9ZVtnPVc+cSU22qSLOO6eS0ffHLFztXARuaUfnf8B3tlf8d/HIzKv+pemDG + zlVQGWSqfR8rjwnLKNrgq2oZxVXfAV8F37lq4Xfbd66iFc/p5LQuHjmnAifj1/2Q00IVEtOZaCbX + +Yw9qch1Pp2JZlrBm85E84SVxRlMlFa3ZjDRBWuZM/akGjCrnTcTfe6BYKodY4Z1qxme0wFrYPPe + kwrWh2Yw0fW0F5upfO2Xx5d7TmEdef4yUTp7Z6JAh+cvE6UYBc/pVGr6TfWa107JczolJjolJjol + JjolJjolJjolJjolJjolJjolJjolJjolJjolJjolJjolJjqvv8rZC7Rzq5SzH9LZC7Rzq5Q7JNDO + KdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKdHOKblJp0Q7p0Q7p0Q7p0Q7 + p+QmnTfHhIreGRwzAzmdwTEzfkV/6vBhtu0ck5joDI75wbzDOeZj/1VXuZ+JzsvnJlD/OKMOvyEb + 8jr8Dk7eGXX45KudzjGp66iprOYHiNsIn+hjl3xX7bMnujKcY16dQh9nosM5ZiY+MZxjZqo0Hs4x + 84S7PaKDKfRyNdWeIXeYkw/nmNde8XS9fGdayCiGc8xCntPhhLIMWIcZ0ZuUHBvDCWV9OftDKDNk + c8MJ5ZecJCN6kxbw+gwnlFeVN539qZ1P8NQOJ5SNquuGE8q14I05nFB+aYVlBKHMeCUOoZyPXZNd + tWPku30IZV9Q+T+cUHbojmeqTZoTcJM/lc3vK1Wfb5V5AuEtt1U7xoxPWrb5/bX7GzxD2eb3dYJ3 + eKssRuBMwwnltfJDMc5TF4Djy2vnqS5gOKEs0GvTVPuNSXXSI7ydE9aahhPKnKFvwYja+QZu0uGE + shC9G04o6xeqGoYTyvYFn+hwQnn1g4E35iGUz93CXbXpXcY35iGU7XE3IFfZqgisiw4nlBeXoxgt + CyiP++CZqkX/HDp7ywLygore4YQyN75DlgVkcvuN6E26+Hqd3qQT1t1H9CZt/JY7vUmpq8eI2vkJ + DvYRtfMDCNKI2nlaCxh3b1L8wnjt/Hjuc2qqJh3LPfOsshj5Pp5cYfBVPblCw6+7ezvJgTCidj5D + hde4e5PirDZ6k/I72nuT8rvw5ApU1zSCY35gRX0Ex/zw8+gck5+Ou3aef/G1/nFIHHNIHHNIHHNI + HHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNIHHNI3s5x/VViFGjnVikx + DilGgXZulRKjQDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuHRDuH + RDuHRDuHRDuHRDuHRDvH7e2Ebknj19sJX/efvZ/gK/rDRFnlvZ7oF888h6oRx733E6yejnvvJ8wo + 0r1eC/MJ93ZCj39Ted4BMxivnS/gcRtRO/+dL79oxA28PuP2dsKqbo/epB2ufQ9vZ4H17R7ezgk1 + P92ZaOvQW6Y7E+00vroz0f64O6qrbNcKIA/dmWh73B/ZVVYRB7XgPXZ1qm+/aL5H6JTQ3ds50ptq + Ezdyk/bwdjbI3buT0zmBnHYnp5M6E3Ynp3OBG6sHOZ3g4ulOTifVzncnp6sAoexOThc5LXuQU3IO + dienL6pDThf5+HqQ0y/k7j26jlY8e+86mt5+MZ+7DSPad3WC/dMu1fuuTqba/tX0ptpj9YvPYz5d + R8lXu1U7xi9fiXUoP3DM7uR0UP/V7uS0Z6hG7E5OewMO0J2cjt7pDXDI6RxAarqT08urSONrRPdY + OtbZ1SnDF7k7OW38/nJyOoBj9iCnC7yK3clpg323LtUhpwO/ab6rU+JR2A8dBnrXnZyWl/FlGUV5 + GdGWUVwOdho5Lbob0PWyjOJaKaMrYRlFpUr27uS0TXCv9fB2Uk/x7uS0UGfV7uT0qgWHL8whp6XD + 3LeHt5Ncrt3JaYW9/ky1CXjhkXO6qxP37bcDFL+Ph5zmxG+Tk1F8+enwrqNQp9ODnHZwK/cgpwM8 + 8/3uOsoj+mQUROZ7kNOGsw4np9TXugc5rVDf0YOcFvAp9CCnmb+i7gDl65WiwxG9MZ2c8rfWySmP + CSenONtWyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmXyGmX + yGm//ioxCuR0q5QYhxSjQE63SolRIKddIqddIqddIqddIqddIqddIqddIqddIqddIqddIqddIqdd + IqddIqddIqddIqddIqddIqddIqddIqddIqdd6jraf92k8K396ToKs+0gp+Bd6UFOqeNYD3I6oDKo + BzmF/bdNZSv9UKvb76p4nA05OU1QX9uDnPJs26viO6wQ97vrKLgje3QdLeD+6E5OM7lc229V/OOV + aN519DovVu0YB+QwLTynFfxyLTynHShsc75ayffYnK9W6iXWnK9WyuZa8FXaC6QFX21AMZrz1d7h + GWrBV4nCtntXJ+D3LXZ1qjAnb85XGxGRFrs6Ua7QnK9eOzHR9bLnEXeRac5XK9Go5ny1JngDtKid + p/0VWtTOE9FtzlcH5e4tauc7XnvnqwnoSovaeapkb8FXyQHabr4KWVNzvopMtEXtPPWf+FMdvko9 + GrfKdnXi8zp8dYH/a6s2X818VS3vuDoT0h2yvKNPYDDN+WqvOHKcr1agUS346oKuts356uS3nPPV + BDOF5nz1W4CctqidTzjuvXa+wCplc746qNdAi9r5Bs7n5ny1V6h2bc5XRwNnV3O+Osjx36J2nirZ + m/PVt/t4auczfh8PX20F39FROw88ujlfbeQmbVE7T/UKzfnq1d/kcQbTnK/WL347nK9WqPxvUTtf + gLi1m6/y83hq5wusP7boOpqhDr9F7fzi++i7V+JMwbuO0u6CLbqOdnBatug6SvtSNuerhWrnW1TY + d6h3b1Fhn/g+ngr7l/fXqbB/Gfcn71h8t0/e0aHXQLv5KqyUteCrDarrWvBVorAt+GqB2pp281Wc + wYQzFdh2+3Wm0pUQnKlNcqY2ia82ia82ia82ia82ia82ia82ia82ia82ia82ia82ia82ia82ia82 + ia82ia82ia82ia82ia+2668So8BXt0qJcUgxCnx1q5QYBb7aJL7aJL7aJL7aJL7aJL7aJL7aJL7a + JL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7aJL7afvkqfPmUrqPt5qtQB9Zuvgqd + L1vw1YbcxPkq1bq1m6/CunsLvvoFv0mLXZ0SzkQPXy2041Fzvlo473BnakPq411HiUe3cKYucCo1 + 56u1QPZbb2cqVFxW56u1Ab2r4V8lz0O9/avgjarhX13AfWv0JqW9Gmrw1S/kQzV6ky6YY9abr4Jv + qEZvUqrWr9GbdALRrdGbtAGXq9GbdML8vkZv0sFnn081NeQwNXqTEl2pzlevnTnoPtrzOIjB1PCv + ZmBpNfyrLzHa83gRNz7WZlZfIDXV+erM8DzWuzcp1PPV4KvUrbIGXyUXYg2+Sg6qGnyVdq2owVcL + MNEq9Sb9Ux2+2vE9kS3vmOtNZfcRn6FseccgMr9V+z6uN5V5dIFQ1uhNSt7OGr1JiYDXuzfpm6oI + I+f0JqVK4xq9SQdf+3E4OTD36nx1dT57yzvQt12dr86B347DVwd/YXxXp8RX4vQmpa6j1fnq5Xym + Z/vs6jRhHbnGrk4dv1a+qxPtSldjVyfq5VpjV6cKs6EauzoRE62xqxOtldfoTUr9Hmvs6jRh9lid + rw6qmqnOV0fBb0fs6sRj4vDVBVyuBl9tMHuszlfzy5i4+SpdiTPPyVA1U4OvNpi51+CrBVwDNfjq + 4LeczXMyEcp681V+hnJ4HuhYzldhtl2Dry6c5zhfXcCQa/DVxe9C93Xw1+rwVdr7qQZfbThzD/8q + uCzqzVf5u33zVf7F1xy5Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1Sny1 + Sny1Sny1Sny1Sny1Xn+VGAW+ulVKjEOKUeCrW6XEKPDVKvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHV + KvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHVKvHV+stXWeV8FWYwwVehg2m9+Sr40upd + +Y/ZSVT+Q717vSv/cfbofJX2MajhXx04X/VuqFSDV6Mb6hc6JdTwr+Y3lXk7wQdTw7/acH7v/tUO + rpRyCc2/CsfaKutuALPtrdpzcnKJlYOaNtF9vEPlTNQ+ZUDlWTlh/h0LsvLifLVMoAXF+Wohllac + r1biq8X5apkw2y7RM3XB81icr9YEfLWEfzUDoSzhX6U9s4vz1etK0NmfzqoFekaU8K9+gT2W2Pup + gMOlOF8dVNlYorNqAd9Qic6qFXqcFeernTLp4ny1LfAhF+erV5cK+MXDVy9ODseKzqrgSyvRWXVB + nlZu/yrkyCX6A3RwdhXnq4NqiP9U6/gecazm01mV+gRuld1HoCtbtflqhZ3Rtso5OV0vyzsW9V0p + 995P+GZyvvqqsj4Pb6p9H78wByjBV8lZX+69n/CN6f5VYgrl5qs8vsbpSQLOrhJ8lXohltj7iVak + Suz9NIBjluCri0fO4avkQy7BVzs49Irz1UGcvARfJUJZnK8OIkjF+eog5l6Cr1ao+y3BV8m3XYKv + Uo+gEny187vQ8o5GPtESez9Rr/MS/tXO7+jDVxN+RQ9fbbSPegn/6uKreuY5i3+xRA0L3Uef5/Ad + OvOcAuu1xfnq1ZuBrteZ52TgqyX4Ks+ZnK9OqCkrsUNUh1XdEjtELcgCivPVa68suvZnh6gOq/PF + +WpOQChL8FXqglKCr5LzufzyVRpfzldx/hV8lZ/Hm6+CSuGrReKrReKrReKrReKrReKrReKrReKr + ReKrReKrReKrReKrReKrReKrReKrReKrReKrReKr5fqrxCjw1a1SYhxSjAJf3SolRoGvFomvFomv + FomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomvFomv + lt/+APAVDb4KFV7l179Kx3L/KvDVEnx1vh1rz3My5u6Hr+YM/axK+Fcrzh69PwDtTFuiPwDPrJyv + kjO13HwVVufLzVf5qh6+OsCtnG++CnPMHHyV5r7Z+SruAJuDr9KuOzn4Ku2TkZ2vNnLo5etiWA89 + 6F62VTu3apDpbNWu8SSvYj447S8zhK5X+UxGPyNBhp/PrfwMqjzL0X+VyFZ2vjomjNUc/VcTcIAc + /tUFeUe++6+CDzmHf5V21s7hX13QyzWHf/ULvf1y9F+lLoc5+q9+IYfJ0X91QF6bo/8qdffMsXMV + dXzNzle/1Js0O1/9ZiBbOfjqelPtGIm5Z+erXyKBfyrLO760k9xW7RhpD6+t2jGSh3KrrhjRJ7pV + Ob1UxW+V1c7jmHC+Sv0U8s1X31Q7RtqlKN98la+95R1vI+fw1ZcYx3svixx8lSr/c/DVCXw1B1+l + PeJy8NWCbznnqw3W+XLwVfLe5eCrCb9WzlfJaZnDv1phLTM7X726G/B57TWdAV7FHHyVXK45+gMM + qFrOzlf74vO6+Spdr8NXM6zgZeerl4qul81zOjlAc/DVDGs6OfqvTljDz3d/ACC62fnqtZbJqs1X + K/DV7Hy10M57Ofhqxlna4av5CwQ8h391wkw0h3918tv38NWGM4XoDwCu4Bx89eUr6nkHUNgc/tXB + V8J9HeC+zeFfpXqrHHy140w0/KvAavPNV8FlkX/5Kl0v56v8/nK+Cj27ssRXs8RXs8RXs8RXs8RX + s8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RXs8RX8/VXiVHgq1ulxDikGAW+ulVK + jAJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJfzRJf + zRJfzRJfzb98Fb6iwVfBN5SDr2bkOeneofORF+abr+JsKPqvggMhh391QT1MDr6awLGRg69mcHbl + 4KsVSHMOvpr4erl/FfMO7w9AO2vn6A9Ae0Dn4KsLVptT8NUFruDkfLU0IA8p/KvUMzUFXyXamX75 + Kv/izjsm5LUp+CpR2OR8tX6hkio5X23kG0rOVxt1vEjOV6+dq/gXd/5YoJI9XTd854/kL9yqnSOv + N9X2ICXw8aWDDDf3fXxq05lwf8YA1pHOcN18la7q3R+AftH3t4J8O0V/AMrmUvQHoF4DKfoDVCA1 + KfoDfMHlmpyvXgwGrpf3B2hAtlL0B8g47g9fvXauYpUxZMhY072/FewF8qc6/QFeftH5Kr5zsuUd + 6Nrcqtfa+a3aMfI7J1vescgzn5yvrgEcMzlfXePtWDtGWt1Kd38AvkPHv/p69hYjX4nDVwePwsNX + iYCn6A9Q31Q7xsZ3e7z3Ck7BV2ntJAVfnTDPScFXqVY3/fJVPtZ+r1LVTAq++gVfbYr+ALS7TYr+ + q+RVTM5X0UOZnK+Wl2e7nTkArAYm56uFulSk4KsNVjxT8NUBXZxS8FWqKEnOVwvVK6TgqwlW1FP0 + B+AvzOGrmVbwUuxvRV3yU+xvRXuopuCrVKeTYn+rCR7dFPtbvXw7Tt5BPoUU+1s1WD1N0R/g5Xn0 + /a2g8j8FX6Xe8Cn4Ks8xna9mnPE5X6XOqin4Ku1JlYKvFpzfB18Fh0v69a/S1z2958hJ4qtJ4qtJ + 4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qtJ4qvp+qvEKPDVrVJi + HFKMAl/dKiVGga8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8mia8m + ia8mia8mia8mia8mia+mX74K85yf/gAwU/jpDwDznOCr4BNNd38AqHRJd38AnEc7X+1QGZTu/a1g + d64U/QHIMZvu/gA4Qw6+inma89UEXowU/tUCjsYU/tWKZMv5Ksy2L7Ry+Op8zjtMtXMr2FHLVFZT + 9syjTWW51bPnwVRWU/Z29rt2fj6Pwkt1+Cr04zOV8dVnsmWq7c+pzyPHVFeMFxOlGEv0JqXrdfgq + VC1fqsNXgWOayjxIzw4EU+0YIfs11eYAsO+8qTZDns8cwFSbr85n7msYcLOO/kyaTWV7Pz1TH1MZ + z3l+55hq8xzwUJpq8xxgQ6YyZoWq6L+KV9X5KlRmm8r8q3glDl/9gr/QVNv3yDG6fxV2rrpU7/5V + U22+2vi8jn91PH8fTbVjHG+/uGMEjmkqJcadd+QEjM9UxpA5xuNfBWZlqp3BgzPVVDvG9fy1MtWO + 8eVY47xznvmEqfY7h5+hw1evnpbwnvD9rfir4PtbLfwqRH+AZ//9pTr7W7U31ear4Dgz1b6PwGBM + dcU4YQ3MVLam89wDwVTmX8XvkPtXYfckU+37CP5oU+1vx3yewZhq38f13OnFVPvbATsCmmrPAb7P + c8xLdfa3gmoeUxlf5bOv0Z8cvkPeH6A8E0pT2TznebXZVF47TzE6X+VRePgqeK1Ntefk32efgqn2 + fDXzG+D4VxOP6JN3wK4Cl+rkHfOZF5pq5x3j2YFgKvN14Hw1/Kv8hXH/Ks6jw7/6TJrtQ2t8ld8T + 9/5WFKPz1ee6AFNZ/shj4t2/airPkWHcC3zVVG85sqnecmRTvXEAU71xAFO9cYBL9c5XTaXE+M5X + TaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE + +M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTaXE+M5XTeUxwmwo + +Oqzq85UFuOzl+xSnXnO55k9msr4Ks4eY3+r5xViU/k8h39xx7ieq9hMZX2QkCC5f7Xwtff+ADjP + OXy1QM9BU+356ve5W5KpbE6O2cnhqwX6pV3Ywfe3evZjmsp6dgGpWcFXMzC+5Xy1VphHL+erdawX + leVWz77tS1WOPwfm9yv6A3SYua/wr0KXVlPt/LHC87iCr3agBSv4KnTIvVQ5epPS2Z/+ANBrwFTW + t/PZI2KqzVe/8AZYzlcndPUwldfqUozp1UtmKusPALnoCr4KDj1Tbb4KdYamMr4K74kVfJXeJiv4 + 6qvKGDJkYMv5KlV5m2rHSKR5OV8l/6qprG8nn737V99UTVLtGIk0r3P50dtpKuuBwFdiHfb47Ku9 + VL6/Fb4xna8m/kXvD8B32/IO8vuaymLkMSHw1eV8ddTnNUNT7ftIZH45OaUeCKayzqqwurWUnasu + 1XGmdvgiLyen6+XaW0Yxvs+14Kba5JTWO1aQ0wmztBXOVOhvcqkOOf0+d1Qx1f4qQG9SU1lnVX6G + 2ll1wy9MdFblsfpe+X+pvPIfVt1WkNMvj8LTWXU8VzWYas9goBLBVJsOp2fvsKmsw9GzA/RS+Q6d + z3uLmWqvEMNuU6bas7QOKwYryOl6rp031Sanf99Heh7dmcpPWo6uozRWT0YxYbV53eT0uY+uqXZG + 0Z7r5ky1MwqeR4czlZ/HQ04/OM8JZypfr0NOP3ztU2SG9HSkyAzpSqT37HdJ5HRJ5HRJ5HRJ5HT9 + klMY9wo5XRI5XRI5XRI5Xb/kFN6rCjldEjldEjldEjldEjldv+QUng6FnC6JnO6/HiONCYGcLokX + rl9eCM+2wguXxAvXLy+kXxR44ZJ44frlhXRVBV64JF64fnkhjZybF9KVEHjh+uWFFKPAC5fEC5fE + C9cvL6TzEnjhunkhfh+DF+KML3jhc2W2qSxG/Lo7L/zA6ukKXljANbCCFw781rofs/OV8L7p4AdY + zgs/0OPfVDaDea6mNtWOcb39ovVM5Tt0/JjjubbmSjGPH7PAOvK8d2KC8TWdBObvcychUxnthBny + dBKYoXPcpToOhFeV7TYFHHM6CcwF1qSnk0Dq8W8qq9SD7GQ6Cbz6FtAv5kN0YXxNJ4FlwOxxOgnM + 5AiaTgIvfzTFeJ40ytOmk8Dr2X7khdNJIL5NppPAS0X30efR8J6YTgKvY1GMPo+Gp3Y6CaQ6sAvT + fCNGuBLZ59E4Vg8J/Ds5ul6HBF49SeDsDwn8VHAqTSeBuPIzr9eOVSPieyKfefSEVZGtMgc75O5b + tZ9H2OHOVHv1gfjqPC/NnZXTsWwe3doXz36+7vxiqp27Q+8PU20+UXAUHhLYE9/HeVaRYL1jOgmk + Liim2u9VctZPd1qWzPfReGH7Plfhmmq/V2G3KVPZl4+vl/HCy/FPT63xwmvnPbpD/dxHyMpnVLKX + 512dTLUr2Rd+t30npoHf2qhkBx49nRdWYnzTeWGD/R9NtccqdC4x1X4eO8d4dmIaz3W/l+rsxNTw + fX94YUnP/R5NZV3f+ek485wOFHaG0xL2+TGVdewB3+O8nZZ8JW6nJT2PJbr3s8pW5/lKnIwCaqRM + ZS7EgdfLK7xgHXkGL8zgCp7BCzPOC50Xfvh5PPMc2MvIVDYHgLqTefNCfmpTZIasqudYdFXTe/Y7 + b14I+fb85YWgUnjh/OWFMO5/eCH/ohCj4rScv7wQ7uMPL4Sn44cXUowCL5y/vJCuhMAL5y8vpPO6 + eSH94nwnNfOXF/IvKvdR4IVT4oXz+quMVYEXbpUS4+20pJEzpBgFp+X8dVrSiO7SWL2dlvDt+CGn + FKPgtJwSOZ0SOZ2S03JK5HRK5HRKTsspkdP5S07hq/BDTuEr+kNOWaW8cwRyOiVyOiVyOiVyOn/J + KY3C90p2U3mMNO6dnMJ67bzJ6XM1tamcddBT6+QUs5Mgp+DFmEFOG48vryjhu33mOVSPPIOcli/+ + opNTJG7utORc1MnpQGbl5PT7/6XW/wtEpF89YMsDAA== + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['32236'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:45 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 15:17:04 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_supl b/siphon/tests/fixtures/ndbc_realtime_supl new file mode 100644 index 000000000..b23061720 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_supl @@ -0,0 +1,1694 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/PVGF1.supl + response: + body: + string: !!binary | + H4sIAAAAAAAAA5T9Tas3PbPlB879KTZ47o7Qa+a8PPDAUNgG42GDm65JdYN75G/fmVJKsWKFrr1P + weE+F7l/j5By/fUWWhn67/+P/+Pn53/+n3/+03/6+S//5ee//tefn5///L/8j//rz3/+3/6n//l/ + /Pn53//X//yfnv/+p//pf/n5398n/91//3//Xz8///X/+/N//t8//+X/+vmv/5+H//kv//n/+fzn + v4z/8X/9f/z/fn7+z//X//t/m0/+uyR6/Uj/yfqj9UfkR0Xv/yH//Gip5f0f/7T3P08NxhPHl58H + GXx6/1quwGfiH2TwOvg0+Gp8qcwn4HPj8nMj/kEGL+OvEnguPwvwKdQ/3cSnAvXRyHN7FduriXlN + zGN7JbRXlXjB9kporwjzYuXnoG+uvr156zv4oG+uQvzSVwbP7X2eMJ+Az6F80jdvfUd9gr45c/mo + b06hvekifuk7+KDv84T4qe/1P9zjr6G92pnH9gZ9szCP+mYJ9ZfCPLQ31Vl+33yi/pu2voP/9EU+ + E4/6ptB/U+nMJ3s/6eu/wOeb+Knv9T9c468SeK7P1PfjP32BT5X4qe/Hf/oiz+UvfSc/25uN18Z8 + Av7TNxkvF/HytbePv4b3KVwfEeP1679l81r9+9dP34//9AW+3MQXaK9++iLP5S99R/k5lJ8v4lFf + /fTNwBfmsb2fvvY+nyfEL33b+9egryrXZ+lbx1/5/T8vlPkEvPDv+XlE/NK3DJ5/zyqBF+OlVuKl + +vrL1nfwhdsrND7L1nfyrK+QvrL1HfzXf00vofFZtr6TD+Vnrk/G9ob+K6SvbH3f9YkEfSVx+Uvf + NHjWV2j+la3v4IO+zxPil746/sr6inB9lr4PL3el9j5PXH+Ue+sr71+5/z58Jn7pO3kar94nzCfg + P32hfN9/H37pO3nx/fF5UpkX4FPj+qRG/NJ3vJ8kXB/l97P0HTzr+z5hPgEvncsXrs/SN42/hvoI + t3fp+/IXj8/PE89fW9/8/vXTNwOvxC99J8/6Xr7/vnwCPuh7kb7X1nfUn8fn5wnXJ8Pv+fr6L/B+ + /fzwqO+V+PdzpUQ89F+5eP59nmTmQd9L+Pd2CbcX+u/zV9b38v335aG9Pejb/fz7/LcW5Gl8eJ4o + 8QV+z53H5+cJl1+gvT3z77kXLh/17bky79dX739lz3fSef38PiE+2XwkndfPD8/lK/yeu/J42DXw + 8HvuT38jnvpv3/qO+vP4/DypzMteP0irNL88TzzfcH31/JXHn+cJ8bC+kla4va1k5m39LO3TF3kh + Hva/Dz9++baef54E3vaD0tJ8n5fxpG/b+6NX3/bpexvv11fvy7+Qb1y+3x+9/Lc/evVqvD96eCV+ + 7Y8mL8wLt3ftj16+Vv59Vr++krr3R+/voYbxudL8W/f+qA++Mk/zb9373/f3UDPtFx5eiF/6Tl6Y + 9+vnlxeoP6+fnyeN+KXveD8a2qv8fpa+k8+B5/ez9B31eda7VB/St259x/uUwAu/n6Xv+35W/Mr4 + Qv3X4ldv/yrlZr5cxA99k4z+VT59kc/Mp8m//asEfSl+JV/8apUf9C2kr8WvRv0/fdX4xPzSd7yf + T18on+Zfi1+1wSfmNfDQfwvvf98nxGP/XfGrDDyXj/03Vy4/+/iGWPxq8KH/ZtLX4leT5/VGpvnX + 4leTZ71yZn713zb+Gnmuf8b2pkr6ZlpfWfxqlP/pC7xye1HfHPTNPr4h2fXfFb+C8oXLF2yvhPaS + vha/evkU+m+i/pvc+JxC/01+/yvJjc+pZOZLYT4BH/pvov6btr6TD/Wn9VXa+r79MYXxOSWuz9J3 + lB/6b0pKPI7PKeibqP8m139D/OrhuXzsv+nT134PD8u82HpAg75K/Ve3vu96b8WvgKf+q1vfNP7K + 7aX4lSieL4gGfdXHJ0Ux/iwrfqXAc/1xfaVhfKb4lSieL4iG/qukr259ZfChvdR/LX71zhca9FXh + 9ykWrxMN/ZfiV2Lxq5eXyv1RaH9k8au3Pit+pcAr8bh+lqCv0PrK4leDD/pS/EosftXGX7m9QvqK + 2x9J6L+SuHyIX4mE/kvxK7H4lQ4+tFe5vQrxHAn6ivL7nPr2+f6DvhS/enmZ/FPzFObf5M6Pnsau + +ffjuf8mN/8Ofuq7+BT4znwCnvV9nnD5uSEvgS/Mf+3t719TZT4xnwrwrO/DK/H6tbcOPrQX9Z38 + 197y/pX1fXguf+k7+dBe1HfyYnyYf5Obfx8+bX3z+KsyT/qmrW8df+X6P0+Y/9rb3r9y/Dm586PB + L30nz+1Nmeu/9B0899/nCZe/9J18KF+5vUvfPv7K+ibl+ii2N+ibhN+PYHuDvu78aPJi7z/Mv8nN + vw+vW9/B8/oqKemrW982/srt1ZKZh/aG+fd9Qjzqq0FfzcI8tjfoq4nLT9jeoK8mLl+xvUrxz+cJ + t3fp+/4e1vwLvPD7FBivwvz7PGG9BMarZ7Yl3p0fPbxsfe/3r2F8lnITv/SdPI+Hbv6dvM1Hz48x + 1Cd34rPFY1OYf5PQ+Gzzb3r/yvHn50klfs2/g+f4xsNn4vVCPjOv3F44P0oS9BUV4uF8IQnvf58n + 3F44X9A7nP/evv+qnR8NPpz/3jURD/FnDedHepfAm756h/PBuyjxcH6k4fzofcK8AM/nR88Tbi+c + Lzx/zYHn+oC+emtnXrm9S98y/qr8Pv34rHZ+1MdfZ3sr8FwfPN+/OD6pl59/9cL18/PXzLzvv3q5 + 8/0rnP9efn2ll/NvXEHfy4/Pernz/XB+9Dzh+i993/P6i/dHzxPml751/DWU7+dftfOjUX7Q91Ju + 79J3vH9p/H6E24v6XsG/cfn11fsP2x9p/8Zn06tT/+3On9ODvt3Pv9qdv64X9hd10rfv/e97nt7z + zTzp2/f+d/IS+Mq8QP2D/6onLj/ZeYqG86P3CfGob//G5wo8v0/Ut2uov3D5S997/DXymXlob/v8 + G8Y30rc5f906P0I+EY/6tuCva4XLR/9kC/6rRuOzOz96eG5vy1w+6rvOj4BPnXj0TzYNPOlr50eT + 599/Uy5/xa/e8TycH2lTbu+KX00+tJf0tfOjtz71m3/NL1dJ3+r8sev8CPlMPOpbg77V74+0On3X + +RHwfn2l1fkna9C3Zq5/xvaG/lv9/kir03edH0F7lXnUtwb/ZFV+P+iPrXz++/BCvGB7w/xbJfDw + ey7sz3me+Pdf3Pxbgv+q0Phc9vw7eZ4vCo3PBeNXz+apM5+5/Azj1To/ysBX5gV4Xj+/jmjiE7Y3 + 8frQnR8J+p/H+wz+yUL6FoxPbv+z/X6KcH1wfC5BX3d+JOZ//vy6Qd9M/Tc7fXPQN1P/zW59FeJX + z5PAw3yUeX/k/c9i/ufFs77O/yzmf/74xPuFnLh8nH9X/Ap4Gp/N/9x+zv5nrg+un7N00jdT/81b + 3zx41jcLv8+l78sv/zP4aan/JvRfbf8z+pkv4gvsF07+58q8+XO2/9neZ8pcH9j/6jo/Qj4xL1Cf + g/+5EA/735P/Wbm9CvvBFb9Cnuuj2N7gn0ykr/mfZfD8e07C9V/6vvyKX9l+QWl/pBjf2P5n5JV4 + iD9v/zPwtP+1+NX0PzfmSV+LX01eAp+Zlx1f+sv/LOZ/7s7/DDzNvxa/Qv8z1IfWVxa/Qv8z8MLt + XfGryYf2Cr9PiD+rcHzyfeJ4i1+h/xn5TPzSd/iHg75C869sfd/+Es6PvP958Evf4QcO8Q3JXJ+l + 7/t7lrD/lcTtnfq28XsW5d8zxa+2/7mN37MEfSl+tf3PHx/0FZp/V/yqjd+zBH2F4hsrfjX47X+2 + 877bnx9t//PHh/PB24/P2/+8eD4vu/34vP3PHx/OB2+v7/Y/L164PpnLz9jecP5L8avtf/541lco + frX9z4tPzPv11fY/t3G+eQf/BsWvtv+5jfPNW3LghXkx/gr+nMvHn7f/edbnCuf7VxXil76TZ30v + Pz5v//PHB30vf360/c9f/bn/Pk8K89jeRPGl1xFNfML2avB7+/67/c9t+CUuZb8Kxa+2//mrj/D5 + O8Wvtv/5q084/72kMi/G98r+t076dtd/e9C3+/iGdNd/O58PPk8K82mPh9KDvp307a7/9qBv9/Hn + NWotPoXyE9dn6fv6DXrQtycuH/tvD/72Tv23b30HH/ztXbi9gu0Vive+T5gXq38L/naKX23/88cX + 9mM3H3/e/uepVys18I35tOdHaTn4sX18Y/uf+/Qzf/oin5kX4IO/vfn97/Y/j/XA89dQPo3PK341 + 1huv25nLV24vrK9O/mfh9sL66vlrDXxi3taTUnn/6/3PYv7nxWf6PVTSt+L6efufoXwanyv6N7b/ + GXklHvwbD69cn8zlL30Hz/uj50knfuk7+cy8cnuXvvf4a2ivP9/f/ufpz6l8vvA84frA/uj5K/ff + Kvx+8PuUEvpvqb58i18NPnxfVkjf4r5PKSWUT/pa/OrtL4X3v97/LNv/vHkJfGVegA/6UvxKCu5/ + pXzxZyifxucVv5p+raL8vQzFr8TiV2X8NdRfuL34fcqKXyHP7V36Tv8zv/9M+lr8Cv3PwNP62eJX + 6H9GPjGfgA/6Zuq/Fr8qP+Z/Bp70tfjV+/6X/wp4mn+z89eF+NXDZ+JR3xW/Al65vfj9UebzXyH/ + lVj8arRXePzMwvWH73+3/9l4il+Ji19JCvomH9+Q5PpvCvomH5+UhOf7EuJXQvErMf/VPf7K+lL8 + Ssx/NXiOT0ry579i/qvBB31T4vrj+By+3xeKX23/88eH8ZniV2L+q+HfDv03SeBh/l3xK6sPxa/E + +a+2/xl46r+K8Q0J3+8Lxa9EMb6x/c/Ak74Wv5o8t1cz1x/XV8rnC0LxK7H41ft706CvJq7/0nfy + rC/Fr8TiV4MP62el/rviV+3zSwvzwvXH9bMEfSl+tf3Pc30uQV8hfcXtj6Tw91YUv9r+5+b8z8DT + /kjc/mjFr5BX5mE/GPxXQv4rEbf/fboT88r1UdjvS9CX4lfb//zxQV+KX23/8+L5ez2h/isYv0q5 + sn8sw/o53eZ/bs7/jLwQXy7k2W+G8+/HJ+C5/yY8P5o86JvC/Ps+YR7by/Ov8z9PHuJXKcy/Ceff + yYO+2/8M7YX188cn4Hl8fp8QD/Gr7X9GnusP8avtfwa/Membtr7Tz8z64vnR5IvFc9Kaf5FvzCfg + P38O+p+Zh/jV9j8jX5gXKD/4J1Pi+i99B8/xDed/nrxie4O+Ccbnj8f2Bv9kEm7v0nf4z4N/Mkll + /mvv6y8N82/C/Dkvr1vfwQd9lfTVra/8mP8ZeS5/6luHn/bgfy5C/NR38ey31xx4gfpw/Op5UolP + 2N6gL86/k1ds78H/HPiE5bNeCvGryS99E/ifkef2Ln2HnzboK9WXb/NvBv9zAV6IX/pOnvWVkplP + wIfvF4T6r82/ZfxVuT4w/348jFfC6+ckND7b/FvB/4w813/pO/nEPOkrGH/e/udqvHB7cXwWCe0V + rj+Mz3pXyneht9dXbzxfOPqfhXg4X3j4zLwfn9WdH2nIn/M84frA/Lv9z8hzfWD+1Tv4N27ff7f/ + +as/xzdeRzTxekH5rO/zhNsL86/ePD6/jmjiYX21/c/AC9cfzhe2/xn8t9X9HvTC9fP2PyOfiYf4 + s4b8Oc7//PG2X9ArX8yTvpc7/71yDbwwL3u/puv8COpP+l57f/Sed19B38uPz7rOj+b5+xX0vZTf + J3xfdvQ/c3vxfD/kz3kd0cyL8T3o20nfjvtf7aH/9nITD9+XaQ/6dtK3b33f9nYen53/efJL38nz + 763nxDzo24M/p5O+fes7eGV/Tvfrq+1/Xjzni+vK7UV9e/h+oQu3d+k7/NJB3+7n3+1/nv6ZcH70 + PPF6ta3v5Nlf1KoSD/nNtJXoZ07Mw/cpLeQnRP/z5NF/Fc6PnieBF+CDvo30bTs+OXnKz+P8z5NX + 8Ju1r/8i35nH9n799wJeiEf/VTg/ep4U5sX4cH70PPH6Vue/Wv5n5JV4+L5s+5+B9+srtfOjySvz + 1H+r07eG/lup/9at7/BvB32rX19t//PH8/rq4YV4hd9zDeNzVa6/YnvD/FuFeey/NfTfKlx/iE9u + /zP4df3+aPufP573Rw8vxMP3oQ/P32cVWl8V568rYXwumesD34c+f+XxrWSuT8b2HvzPhXj015Wg + b6H+u86P5nxUgr5Fuf7orytB3yL8fnD+DedHLv/zx4uN/+H8SCl+pfb9/vDfVq5/LswvfUf54fuy + XCrzMB+F+JVmGp+zm39z6L85Z+ZhvXHyPxficX2VOT6pFL9S9/2+hvjV8yTwoG8O+mL+58kLtjfo + S/Erte/3p/+Zf8/4/X66zf/cPz8z/54Tjc/2/b78mP/Z/H6YP+fjYf28zo+Q5/KXvpMX5ml8tvjV + yC8d/JMpcX3An7P9z8hz+bg/WvEr4JXfJ+x/t/8ZeOq/Fr8qP+Z/TsBzfdb+6OXD9/tK8Su1+NXk + NfBKfLH9vir7r5z/+eNhPxjiVw/P5eeGPLcXz48+XoD/1f88edz/nvzPF/F6Ic/fa6jy+0R9Q/4c + 53+ePMQ3NHy//zzh9mJ843f/88uLi2/87n+ePMY3Qv6c50ljHtp78D/7+KS6+NUf/uePh9/zyf98 + Ew/x53fdxDzpK1vfyfP4TPEr8D8Pf3gYn4XiG4Lxye1/hvYKvx+IT27/M/iNvb7gfx588E9S/Ar8 + z5Nnf+bt51/wP7/nxSf/8018blB+8E9S/Ar8z4MP+ZHuxO2F+PP2PwPv9QX/M+Z/Rr4xn5Dn88db + mBds7yH/M7cX9f09//PLX07fi/dHD5+IR30v3h85//PHQ3sP+Z99/wX/8+SF3s/lz4/A/yw/lv8Z + 6pMa8UvfwQd9KX4F/ufJ8/nvpYFPwIfz30u4PkvfyYf2Cr8fgfb2cL7f/f5XzP88+Oh/9utn6Xh+ + tPM/I9+Yt/MjCfGr5wmXv86Phj85+De6H59lxa8+PvhzKH4lK3718cFfR/ErWfGrxfPvsyvXR7G9 + fL4gFL+SFb9a/GxvAz4xL8a3St+nP0/cemD7nz+e78d5nxBfLuRT4Cvz0N71/T7wmcuH80EJ3+87 + //PHY3sP/ueb+ITt1dBeZV6xvRrqT/23uf578j9z+QLj1Sn/M7cXzn+l8vehUmn+rW58Dt/vO//z + 5HF8XvEr5DPzMP+G7/efJ1w+rK/ebM9cf5p/K66vJHy/LxS/2v7nxefAK/Fq+wWpwd9e/fp5+5+n + 36YGfaty+ejPqcHfXoXbi9+Xlcp6FdK3bH1n/ufIJ+Lx+4X1/b7lMy8l8PC9Rvniz8gr8UvfUX7I + 3178/kgsfvX2l5J4vCqpE7/iG8O/HfQtieuz4hvTL82/56JcnxXfGOUHffH7/cmv+Mbkhcun/mvx + q5df8St7n5n0tfjV4Au//+z3v2Lxq8mzvtmfH4nFrwYf5t9M43N236f8nv/547G9wV+Xaf7Nzj+5 + /FfIC/F6If+b//njwT+ZJfiraXzOTt8c/HVZuP4Qv5IUvh+k+JUk548N/iuX/3nycD4owX/1PmE+ + QX2CvsnHn8H/PPzVYf2cMtcf9U2cX1TIfwX+57c//p7/efLYf0/5n7k+S9/Bc3zD5X+e/NJ38vx7 + pvgV+J+Hf/iQ/9m3VzH+LCH/pJD/6h/+Z/RLF+ZBXw36qj8/Av/z5Flfil+B/3m091f/8+RR3+C/ + Eopfgf958tH/zPXB8fmU//km/i//szBv8dg//M/pRv8z5n9GP/NNPM6/J/8zl4/fD/7uf548zr8h + fvU8qcxje0P/Jf/V9j9/9Qn6inJ9cHw++Z8b89je8P0C+a8g//PkZ3sr8MK8rTdSuD/U+58v9D/f + 4H/uxhfmIT658z8j35kHv9mafyvwQvzSN//D/1yYF+CDPxbvX5g8xDeO+Z+5Pmt/1MH/DLxyfdb+ + t4P/Geoj/H7W/nfywb+N4/Nl/uexHz/6n5vj097/jvzGhfb77xPiywXll87ll8I8+GPD90fPk4t4 + iG88fw1+45yYFyj/4H/uxMP+9y//82X+568+B/9zZh7by/HJhN8fTR7iG3/kf/540Pf3/M8vr1vf + wUf/cxXiUd91fvQP//MV/c/8+3Hz72X+589vzPmRkmauf7b9/s7/DHzi8k/+Z+D1Jl4v5HvgE/Pg + B9agL35/NPmT/xnKJ31t/tV/+J99ewXjkynMv0lofBbnbw/zr8v//PHg95bC7ZWixEP8eed/Rr80 + l4/+9jX/Ap+4vahvmH/fJ8RD/Cr94X++zP/88eH7FKH+K67/hu+PnidcPpwvvG5nzz9PXP3B//ye + f4XzI70L88V+z3/kf/74BDz3X719/wX/86gP3z/4POHyvf85tNfPv+B/fv0Ay/+MPJcP66uHZ7/u + rYG39fPJ/yzcXlhfbf8zvH9R5r/2jvzJwb9x+fFZXf4cDfeHqjs/Gjye71/Bf3WVwMP5/sH/7Puv + Xs7ffmX2z1yZ65+xvfx9il6k7+X8GyF/zpsRmni9oP7h/Bfz53w8tle4v1zK7UV/ezg/cvmfPx78 + DL0Gv3H19XH5c3b+Z6tPp/5r50cjv3Q43+94vnCZ/3n2l5P/mctHf04P+mL+54+3+Ib2dHN9SN/u + /Fed719QvD908qv/Tj9zaK9fP7P/Ofg3OvVf8z9Pnv0zXbh89Le34N/A+0NfvmH86vkrt7eRvs35 + J1vQF+8P/fgEfNC30fjcnH+y8fz7POH6o3+yBX8O3h86efRPtpC/HfPnTH7p+/7+V/4c4JXrs/Qd + fnLhfKrN74/U8ufc46/8e25+/lXLnzP8t2F8rtR/1/nR8ktz+dXvj7b/+ePD/FtpfCb/c9C30vhs + +XMmP9//P/zPl/mfPz74Y2vi+kN+Bg33h7r8z5NX53/m+cj5ny/zP3989D/79ZW6/Dnb/4x+aX4/ + qO/J/+x/z+Z/HvmZD/7nTHyB33MJ+hbSt7j+e/I/N+KXvsMPHPpvof5bnD+2hPm3JG7vyf8M5ZO+ + Z/8zlK/8fnB8/sP/fKH/efKhveLaC/l5EpxPWbyu+N8P5OeZvDLvfz+QnyeP0yVafz5PfH0sP0+B + 8ynkhXifn4fPQ7Mf/8Xll5acOT9b9r8fsfw8Fc6nkC/MY3uDP4TiY5Lx+5dTfh5lfo0Pk+d4Zvbr + c8lO35AfQPB+0smjvqfzKWVeTK8U9E3V19/y81xwPoXnWUL80rfB+RTwPj4G+XkanE9Ze9351GXn + U4sXrn/m8jO295Cfh3m8//2UnycRv/SdfKi/cv2XvhXOp+z3mfz4AOdTHc6nbuD5/cP9Wc+2/CZe + SV/d+qaf4/2kpK9ufROcT+F5VmUefs+H+0n9/L7PpxY/22v5Wl1+gMvOpz6e1+f+fOqy86nZ3/84 + n7rsfGrx8XyqM4/tPZxPNeJX/53nWTnw/D4xP97pfMrXR3D9djqfIn1lz+/zfCqc1/j5Hc6n+j/O + py7iYX1+zM9TmBfgD/l5uHy4/+6v86kLz6fKP86nuL1rfs9wPoW8Er/67+Rjfh4uH75v2udTcD6C + 8bGO95MWOJ+C8xdcv3W8nzTD+RTwOD53vJ80w/kU8Dj/dryfNMH5FNQ/c/lwvrzPp/C8yfPJnceF + +cjnq+mYr2ae14TzC/w9d8xXc8F5DZ6/cPkrXjR54frgerVjvpoO5zXAh/bC9yAp+CX8eU3HfDUN + zmuQ5/pgPqLf7+ucPMSLjuc1XH+IF6Vw30Fy81HHfDUNzmuQT8RDPPB4X2fg4bz1dF9nJx7zEZ3u + 66zMy44Pp3Bf9vOEy1/6ZjivgfJJXzuvmXxor3L5/rxGuD44XnU8rxnt/cYr4HG90fG8psF5jfFS + /ftx3/vs8xrkE/GQL27nq7H2Sgk8/J7D9z4+X03H85oG5zXIK/PY3tB/hfqvuP4rQV8hfWXrO9ob + 8hG5+ahjvpoO5zXIC/EC45XwftCf13Q8rxnnETWcv3h993nNd14Q7iu5vb5wXjPKD/HAuwQ+Ic/x + qNuPz/u85jvvyBwPub2++7xmfn96h3iCO6/pdl4z9+93Em5vysRjPGHd1wm8779wXvPGK8J9B88T + 5qUhnwLP7xP2CztfzT/Oa0awGuOBh3w1fv7Vy8UDw/c+/rxm8hD/vNgP489rBo/xonDfgc9XM3lb + X+37OqH+idvr8tV8+gKvN/FL33le0wLP7cXvqX+/r3PyPl9NeJ+Smbf1s67vfaz8Tv3X8tVMnvNR + 9CrEY76LdV4D5Rcuv0B7O+/3Fe87mDzqu85roD6Z64Px/B7yEXXSt7t44CFfTUrEo75dw/vUwMPv + uQufL3c//8J5Dd7XCTzpa+c1I/5/yFfj22vnNZPn8hv1X85Xw/q20pl3+WpY35a5/FO+GjyvEeYF + eM7n6c9r+g/kq0njrzxeNeq/lq+mjL+G9pK+Dff7O18N8NR/G8br9n2dkG9HuL2w3z/mq/H9i85r + DvlqMvGn8xrMV5OYx/MLjse6+zon7/PVcHtr5vqjvjXx+F9J34rx2Dc7DfN+fQXnNenH8tUgz/VH + fSvH67RS/61O39N9nYEX40vl/FeF9LX7Dt71ye/3dU4e70M/3deZmE/Ah/m30PhcnL7hvoPnCZeP + +ob7Dt4THOJR33VegzyXr/B7PuWrKczD+WMJ/dd979PxvGbyPP4U6r/Fjc+nfDX+fWZ3HhfuO3ie + MI/3/Z3y1WTmYT465Kvx+yPIV4P3dSLP5a/591/3dV7E4/wbvvdx93VOHtfPp3w1ifk/8tVw+bi+ + yuE8LlP/zRiv+ytfTf9XvhpbrybS1773mTzvjyh+Bflq3v6SeP/r7uucPO6PQvxKk4/XqX3v8/av + EL9SvO9g8vC9gIb4lc9X0zFfzciHE85bkwbe4nUa4lfuvs7Jw/73mK+G6w/fY77ZaYjX6t+nOr9T + OE9RpfFZ8XsBDfErpfiVuvjVKV9N5vqgX/GUr6YwLztepCF+5fPVdMxX8/5+DvlqkhK/9JWfv+7r + /PgEfNj/qvD7hHwIx/s6hXkxXkJ8Q2j9bPGrt71/5KsZPPpRJeQjovgV5KuZPOvl8tUMHvKZ6Mq3 + DPlkcuBB3xC/UqH+KxiffOfVwHP5eiHPv2eKX4V8Ndy/hNZXFr8qg2d9RVgvyDd1zFfj+gvkq3nP + aw75anz/Dflq+Dz09vsjcX7jna8G7qP06yvIVyM/5/s6hXkB/vd8NR3z1Qxe+fz0Tlw+9N9jvprM + POR/uFlfub2+O1/N4oV5H7/a+WomfwV9KX6189WM732O93Um4tf3IO3nr/s6Pz4hz3pR/Grnq/nq + k/n7u8uvr3a+mq+9iX8/l++/O1/Nx3P/fZ8Qr/b9y/G+Tn6fqO8VzrspfrXz1Sye9b2E64/69qBv + J3371nfwv+erGTzmM+nhe8xO+prf+P39d77PwuerGTzmm+ocf36fMC/Ah/7bSd++++/k2d/VlesD + 4/ObnYbro9xevI/1dF8nlw/nR89f+by7+/lXOp4fSavMu3w13fLVfHzwMzTqvw3XVw/P7W1+f7Tz + 1cx8F+3rv8D79dXOV/PdH8r50p8nhXlbP0vwG0sjfRuun3e+GiifxmfzG0+ex9um/D7xe9smdF4j + Tbl8/F6+SWFe+H1iPoTK54M+X03H+zrf8mvov5X6b8X90c5Xg3xiHvID1NB/K+lrfuNR/+BXofgV + 3Nc5+OBXofgV3Nc5eGW/GcWv4L7OMv6aAs/tRb9KiF+5+zonj/qGfMtvBhvmxfjC34P4fDXd8tXM + +gS/sVD8Sgr6VXa+mgJ8Yh7aG+JX7r7OyeN9cIXjkz5fTcd8NYMPfsLiz/chX83gg75Fub16IR/a + q1z+KV8NvE+5icd8CCXMv0W4vXgfXA7zb6bx2d0XJsGP5O7rnDz4cyT4kdx9nR+fgA9+wkzr5+zG + 51O+Gi4/Y3tTqH/i+mM+ohzm3+zPf8XiV9MPHNqrXB+frya0l8Zni19NfrbXxtssgYf5KPH+V5L3 + m4mLX538wIV5HJ9TyOdJ8Sux+NXw0xbKfy7kv5KE8cnjfZ2FeQE+jM/Jn++Lxa8GH/pvUuaXvpPv + NJ5Q/Gr7gb/7N1UDL8TD9yDH+zqVeTFe+fxI1McnIV/NWx/l+PPDZ+Lxvmz97lM2Pz/FryBfzcjH + 8q2vLD8V+a8gX83wM3/xDfAze/8G5Kt513vK5wuvQ5h4nH8PfmBaX53z1cD7UW4v5iNS6YHn+qNf + 9JSvJvCw3hA+XxCh+Ia4/vv7fZ2Th3zp2w8M5ZO+4sZn4fMFEdr/Ov/V9gMDT/tf57/afmDgaf61 + +BX6gZHn+qz90X/AD9zND7x4zscrNP+K2x9J0FdofJY9/478MKyv9wM3zFcz+HAfXMb9UcN8NZNP + zGO+1ob5atAPDHxmHu/7O+Wr4fqs+Ma8rzO0N3H5qQDP+ib3PU77V74a8Cfj+qrFfDV8f6XLV9Ni + vhoJfGUe2nvKV+Prb/lqhv823tdJ+lq+mvpz9j8X5hPwB/9zI37pW37M/1yAV+a/9r6/n/A9TnLn + Rw3z1Uyef5/u/Khhvpr0Y/5n4DE+2TBfzZtPI3E+wOdJJ37pO8qXUL7w+xRor1buLy5fTcN8NcM/ + XPk+QXd+1DBfDfqfkU/Mg77hvuw3gw3xqK/y/sjf19nM//y1l+ff5ObfZv7n6vzPUJ/E9V/6jvqw + /8rnq2nmf/7aK53rI/w+l77Dfy6ZyxcuH/tvmH+fJ758wfjz63YOvBCP+YjW+RHwND7L1neUH/R1 + 3+M08z8vntvrvsdp5n/+6pM435Gbfxv6n+XneF8njc82/04+vB/SV/B88FkOx/KVeDgffG/nZF64 + fMhHpHfwb9zVtRfy1Uye/Wa377/qzo903XeAfGU+AX+4r5Prg+eDN+eb8vd1NsxXM/3P7Edy50cN + 89W853Hr/Ah45faqrTf2fZ3IJ+bhvPuWUL5w+UvfkW/n67/Ic3vxfP8K/qvLz796YXxDr8L1uaoS + 7+/rDP5ePz7r5fzt4b4D738ePOR7fPjgx/b9V83/PO73PPifO/GYj2idH0F7kxCv2N6grzs/mjz4 + Ny6OT74ZbIhH/8Yl7B+7/Prq/YfFN3a+GvQz+/qY/3nke/n6bwM+EQ/5lrf/GcovgQd/Tg/+ye7H + Z/A/T/5X/3ND//Pb30/3dd7EQ3xSe+i/PXH91eKxO18N8Br4BOUHfV2+mob+58mH+guXj/eFtUrz + u/c/N/Q/D3/v539GPhGP98G1oG8rgYf8D43jz8+TTjzeB/fHfZ3tB/LVDD5Rvnrvf24/kK9m5Of5 + 1s/IZ+KXvoMP+jZtzCfk+b7CRv3Xzo9G/hyef98MNsxbvG77n42vfn0F93UOPvgna2Ee85lUXj8/ + Tzrz4J+sYXyufv0M+WomL4EX5gX4xN8v1MT1P+WrQT4Rv/SdfGivBh7bG/yx1a+v4L7OyfPvuQqX + j/qWoG+h9VVx+pagbyF9z/lqkE/MJ+BDPsBC829x+paQD7BkLh/zEZ3u6+T6pwLla8hXQ/OvnR9N + nv1XRbk+qG/IJ+Pz1TT0P4/3E/yTRbj8pe/wG4d8YpnG57P/GflM/Mn/DLzfH4H/efiNg3/S5Vtu + 6H+efCg/c/1P93UCn5jH8TnkW/b+54b+5/Jj/mfkO/MwH4Xzo/cJ8RB/3v5n5JV5WG+koK/Lt9z+ + G/3PDf3Pw5/8u/+5/Qf8z9R//76vU5iH9WRK/H0rxa/gvs7pZw7tJX3N//yv+zo78wn44I9Nyu3F + /dE6P8L7PX3/ct/ja/ge/3lyE3/yMyOfmLf4+fYzI6/EQ/5zDflhlOJR4Gd+f29/3L/Z0M88+KAX + xaPAzzx5/n1SPAr8zMMv/bufuf03+plb9DOT30aF+qPLn7z9zMhn4sEvt+/fBJ70tXjU4IO+krk+ + cF6w79/8h5958gL8wc/M5YMfUkVDe5MSr9je0B8pHrX9zCM+tu/fhPr4ePL2M9d5n+nh/s3K/Nfe + 9/zoZn39/ZvN/Mx1+p9Z34dX4suFfGXez6fbz/zxBz9zJx7iyUc/M9cH4snbzwy8389uP/PHs75y + +/67/cxffTS0V/l9QjxZwvf4QvEo8DNPXgMvzIO+V9CX4lHgZx580Pfy/Rf8zOXH/MzoT27Mg75X + 0PfKXB/U9wr6Xr7/gp958EHfy6+Hwc88+KAvxaPAzzz54N9Wfj9L3/f3c/AzK5e/9J18aK8EHn7P + PdwPRfEo6a7/HvzMpG93+p7u36zMg7496Nv9eli607cHfSkeJd313x707Ynbi/13fY//Dz/z4Je+ + kw/t9esl6U7fkD/5ecI86ttDfrYu3F6B33Pj78XeGzkd31z/XfEo8NP6/aw09z1CK/w+nZ+54f2b + w88c9G1+/pXmvkdomf1sze93pOF50PYzQ/mJebxftYX+22h8blvfybO+TQOfkA/1F24vfo/Qgr5N + uP7+/k3Wt1L/Pd+/ibwQf7p/8x9+5ob3b06e20vxqHD/pgSe63O6fxN4v9/h+zdD/63Uf+3+zcmH + 8qn/2v2bdfw11J/05fs3Jw9+bGG98HuEEvQtPt4odv/muB8z3O9WaH1VnN+1BH0pHiXF+akK72e9 + n7nF+zf5/VA8avuZPz7oW/x50PYzf/XheJSUxOXDfnb7mYGn9VXB/ezRz8zthf2shPzJPr9xQz/z + yCcc8mdSPAr8zIM/5DdOxEO+sofn+ucS+IOfGXjqv+ZnnvmQub2Z1s/Z+eVCPErITyV2/9fgg74U + j9p+5sWzvlm5vZBvUML3+D6/cTM/8+JDe2n+za7/Bj+VkJ9KEsY3TvdvFubBL/fX/ZvN/Mwfz/eP + CPmpxPJJTn62twAvzAvw7Mfw+Y2b+Zk/XqOf+SIex+fgpxKKR4nFowYf9E3K9V/65h/zMwNP/de+ + xx/+2KCv+vMCsfjV4IO+SvOvuvn3dP9mZh7m38P9mz5+JRa/Gvl+D/dvcn3g/i853b9ZiYfv8SXE + rx6e6w/xDQnxq+dJYx6+f/wjv3EzP3N1928iX5i3eM7rXh68rQ+FxmcXv5IQvxKh8dnFryTEr4Ti + V+LiVxLiV0LxK3HxKwnxK5HM5eP3vBLWz+Sn2n7mub4N8av3CfFL35GfmeNXQvGr7Weunz85tFe4 + vQL7wfA9vvczN/MzT79fOA9Kbv6t5mee/sxDfmPcH1XzMy8+BT4zD/7PU37jTvzSV37Mz4y8Mj/a + W6b/+ff8xtX8zGX46073b3L9p76LD+1VLn/qW+b9pCHfr7v/upqfefGhvahvNT/z5MP3RN7PXM3P + XP7lZyZ91/y7+BT4xjy09w8/czU/c/n8zxJ4Zf5r7/A/H+7fLMQvfScfyk9c/tJ38If7NxPzCeof + /OrOz1zNz/y9HwnlC9cH9Q3zb3LfE1XzM5fhL9XK5bvzo2p+5o9nP6T3M1fzM8/+pfy9WHLzb0U/ + 89vflddX/v7Nin7mwafoT2Y+FeRD+dR/bf5N71+V+6Nq4BPwof+qCvHoV1eh8T+5+wWq+ZnneCJh + fBYan2XrO3n6/sXfv1nNzzz1CvcLJHf/dTU/81d+5vt2hfqv7P47yg/3q7rzo4p+5vf9hO+Jkrtf + oJqfefHkp0pu/q14/2b+sXzOHfjMPMxHa/7F8pV4gfkofE+UXD6can7mOvMzV/oe872RE3m9cf59 + /kr6ej9zNT9z/ef9m5X5BPXJ7He6vb7bz1xm/ufgl7u9vmrnR6P8xP7VO3F9lr6D18hn4pe+k+f7 + 3Vw+52p+5jr92OF88BZ+/9B/9/2bUL5we8V+zzufM/h7ff9Vd360799Ev/FFPJwv7Ps3G/CN+QTl + x3zOmfnckE+BF+Zlx8O3nxn9ydzehO0N+rrzoxmcvJAP9VEuX7G9Bz8ztxfWz89f2d97CZcP54Pa + K9e/k752fjTu3wx+9U76dvze5PkrjT/ez1zNz9y++zQjr8RDPivtof920re78/2Tn5nbi+f7PbFe + zs9czc/81UcT19+Pz9px//tmb+by/fpq+5mn32Plc4byhduL35usfM7g16XxueH5gq58OOhnzsTj + 9ybr/Aj9zIGH/GwrHw76kxvxEL86+pm5fDhf2PdvAk/jc8PzBW2h/zY//24/81d/5e9B3P2b1fzM + X/kSyxfiBdsb8nU34fLhe95jPmf/e67Of1VD/63Uf6vzX63zowY8lw/5jrafGcrPN/HwvfbRz5yZ + x/YGfWtqxEN8cvuZkU/E64U89/dK+rrzo2M+ZyEe8w3+kc958tDeEvQtpK+dHw3+dz9zNT/zrM/J + z9yZh9/zOj9Cf/JNPPrrTvmclXkBPnxPVBK3F/11IR+OFuX26oV8aK9yezUBH/M5k77Fjc+Fv/fU + ItxeHJ9P+Zx9fez8aPAxn3MV4jFf6Cmfc2Ue5qNwfuTzOVfzMy9eAs/l4/x7yufM7cX5N6fM5ZO+ + dn406nPwMxfmsb2/+5mr+Zm/+hz8zPz+If58zOfsy7fv8Qcf7s+l+JUm558M8avnSWce/IThfkxN + mXnwb2iIX3k/czU/88eH7xFcPpxqfua53l7nR8gn4tf6efKhvcrvE9fP4fzI53Ou5mdePOvr/MzV + 8jnP9bZyfEOVxmf3Pf4pnzOtr9Ttj/7I51zN/1yd/xl46r/ue/xjPmcuH/xXR/8zlw/xjZP/WW/i + Ffb7f/ifq/mfq/M/I6/ES0N+tvcf/udq/ufJh/iVio9Pbv9zdf5n5BPxEL/6y/88+QR80JfiV+ri + V9v/jDzXf8Wfh9/44H/uxCeLx6oEfYXGZ/n0LdOffMjnzPWH84W//M+Dh/jz0f+szMvmt//ZzkNv + r+/2P398zOdclXg4X5AQv3qeFOYT8MGfcxchPjfk+bz1zlyfjO1NIX9y4vokbC/r6/3P1fzPZfqT + D/mcA5+AD+e/zv9czf+8eOH3Kfx+UN8r6Hv5/e/2P398zOfs59/tfy5f/mfWl+JX2//8lR/O96/M + 5aO+4T4yn8+5mv/548P5/uX3v9v//PE8//p8ztX8z4sP7fXr5+1//vjf8zlX8z8vnv1Fl++/2/88 + 33+v7Jfr1H87ni/8lc958EvfybNevXD5MD5v/zPyQjyMz9v/DPXJXD6c/0oP91NT/Eo6xp+3/xnq + k7g+ekH5fH70PmE+Yfmh/sI8zL/SeXwWil9Jx/n3dTsT30hf8z/nH/M/A0/6Nudvb7y+ep5w+RB/ + 3v5n5IV4iD9LC/q2zOWv9dXgQ/9tpG/D+LOs7/GhfOX2wvp5+5+hfB+fBP/z4EP/baSv+Z8nH/3P + /H4g39HO5wx+Wr9+3v7nxefAZ+Ih/rz9z8CTvhX3R1KDvtWvr7b/efGcr6/6/dH2P09/zimfM9cH + 8+3X0H+rP9/f/uevPkHfqvx+0N9eg75VuL2C7Q39twrXf+k7/L0h36/zP1fzP398GJ8L6VucvqXQ + /adC8avtf66fnzn6n5lH/9XJ/6zMg74l5PstiduL92Ws+BXwfn8E/ufJs/+q+PgG+J8HH/xXhfS1 + +NXk+fu1Ilw+fB+6/c+QH5jWV9n561b8CvlEfLmQ5/ZmWj+7+NX2PwNP/dfFr56/8niVM9cH70PJ + KZRP+mbnn1z+K+CVeb2Q5/E8K9cHvv/9K59zRf/zqP/v+Zwr+p9fPnyPL4nm3+T0TWH+pfgV+J/1 + x/zPyHP5qG/4Hl/IfyXJ9d9wH9nzhMvH/pvC/oj8V+B/HvUJ990k5faivuE+Mkk0Pien78H/LNxe + 1Dfx+cL7hHnQ95TP2ZevbnxWPh98/pCIx+/LQvzqeVKYh+8HT/5nIR6/HwzxKyH/lbj4lYT4lVD8 + Spz/avufrb8o6Wvxq/E+w/isyuUr7BfC9/uiwuVLQz4HXpkXq0/4fl/If7X9z3O/E+JXQv4rEbf/ + laCvUP8Vt/89+Z878eCfPPqfhflvfzT8w0FfSdxe8E9u/zPyifi1P5p8aC/1X4tfTT8zj1dC/Ve2 + vvnH/M/Ic3vX/vf1j4Xvj7z/uZj/uTj/M/JC/NJXfsz/DDzGJ4v5nz/+kM+5Ez/1zf/M58z1mfrm + 6U8+5HO+iJ/6Zud/Bh7XV8X8z4sP9cfz32L+54/n88Hk5t9i/ufFh/ZK4KG9ic8Hvf+5mP958Vy+ + m3+L+Z8/PuT7dedHxfzPi5/lW/5bN/8W8z9PfRPnG3yeZObFfj/r/Aj4xPVf/XfwegU+Eb/0HfU5 + 5HPm9i59Bx/0df7nYv7nxYf3L1wf1Ff5vpvniddXnb7hPoWk1H/V6aulM18a89B/T/mcmV/j8+SF + 658r82LjT5h/k/v+qJj/+eOV/edu/i3mfy6f/5nHKyV9bf4d5fP6yudzLuZ/Xrxy/aUwD+OzhPFZ + aHy2+XfwYXwW6r82/06e9XX+54L+59f/L5wv1OdzLuh/nvmcuf8K9V93frT9z+A3Tlw+fp+y5l/0 + SyvxeiGfuT6amAc//5p/kefyYX21/c/A0/hs8+973rTOj8wfdXt91Z0f6To/Qj4TX+w8Zfufwc9c + Am/995jP+SIexufnr+xXuX3/1Rv7r96Jz9Pd+VEx/3OZfuMUyvfjs9r50Xu+fHP/9fmci/mfPz6c + 79/SiF/6jvoc/M9cf7H5SMP50Zvh2fF2fjT46H/247NeuL56+Mrl+/lX7fzorX84P/L+58Hnhjz7 + Z67M9YH1s178fYr3Pw8ez38v7r/Pk5t4vZBnf/6l/D6h/27/M/DC7wf6r678OeAn9/Pv+w847+68 + /30d0Y7vrv8u/7PVp5ebeNgfbf8z8pX5BPUJ+nbS186PJi9cfi7M2/mR9qBvT1wf/H6hJ/a7duX3 + A/vfYz7nzjzo24O+Xbh81Lfz92Vvhmfmob0t9N9W/ftsW9/BB/9VI32b82803h/5fM7F/M8fH/Rt + RYlH/0bj+15fRzTzdl62/c/gHyZ97fxo8KH/NtLXzo8mz/NR08J8Qp6/92nC5aM/5+R/5vaiP2fl + zwH/sF8/a3X+qxq+P6p+faXV+a/C+ZHP51zM/zz9TuH86OGV+BW/mjyPz5X0tfOjwQd/XaXx2c6P + Bh/0rcrvB/U9+Z8T8wl5/n6h0vxbnb41jM9VuL2obwnrK5fPufyonR8NPny/UGh9ZedHk+ffT6H+ + W5y+B/8z6Vucvif/M9cH9S2J/eQuf87gl77DLx30LaRv2fqO8jXkl6b5t2x9By/h/VD/LVvfyQvX + X7i9qG8O828mfbPz1+Wgb6b+a9/vT55/z7lw+fj94MH/TPq67/c1xK+eJ5l5mI9O/udC/FpfDT7o + 677fL+Z/XnwoXwOP7Q3fL2Th94Pzb4hfqbuPrJj/ea5PQvzK+5+L+Z/neungf6b1c3LrqxC/8vmc + i/mf5/othe9DU+HyYf+ric/3NdH6KqH/SsN9ZD6fczH/89zfHfzP1H/t+/3J83yUlMuH+LOG+JX3 + PxfzP8/9VIhfef9zMf/z5MP3+0rxK1WMb2jIn6NK/de+3x9+3aCvkr4ufqXh/EiV9NW9/71+zP8M + PO1/FePPGvLnPE868akAr7/6n4v5nxfP+qpyfVZ88v19HvzPwu9zxSfbj/mfoXxR5sX4EL9Sil9t + //PHB32F1s+y45OTZ32F4huy48/v7184/5UKjc+y9Z280Ptx+XMmL8AHfV3+58Evfcv4a/QzX8Qv + fUf5B/9zZz5B+SG+IcL1Wfrm8VfWV4Tbu/R96iB3uG/99vGN7X/OMx9yyH/l/M/F/M+Lj/7nznyC + +oTz39v3X7H4lQ6e/Vd3Djy2l/X1+Z+L+Z8/nsfn5wnzS9/Jh/b69fP2P398ON+n+NX2P3/v8+B/ + LsxDe1f8Cvy0fv7d/uf5Pi/eH8nl++/2P3/lF/bPXH583v7nWf8//M/F/M+L5/Zefv7d/uePD/pS + /Gr7nxdP60Pvfy7mf84u/zPylXlsL8+/cgmXj/pevH72+Z+L+Z/zl/+Z/Rvdr5+lu/7bg3+j+/lX + uuu/4T4yofiVdKdv5/2RUPxK+tY3jb/mwBfm4fccvt9/nnD52H+X/xnK9+cL0l3/7aH/UvxKuuu/ + y/8MvHB9UN8Qv/L+58mL/d5apfiwUPxq+5/z9AOH8bnR+Ny2vuh/Bp76b9v6Dj7030bjc9v6Tj74 + mf3+aPuf88wXnTrz1H/b1vcaf+XxiuJX2//8lX/wP1fm016fSJNQH+X3CesraWF8bhJ4W1/95X8u + 5n/++KBvpfG54vrqdTsHnsuH8/3tf0Y/cyMe1s/PX0P9szL/tfdf/meuz9L3X/7nRPzSd/KhfA28 + 7RekcnxSqnL94fxo+59tPKkSeNsfSbiPTCh+tf3PHx/0LTURD+e/O/8z8H79vP3PYz+1/c/A0/xb + 9v538vx7LqRvwfPB7X8GPnF71/538qH8xO1VbG/Qt2jgE7zP3/M/F/M/L577S6HxuTh9/8j/XMz/ + PP1gh/zP1H/NfzXKD/qS/0rMfzV5fp+Z+m/e+o76HPI/V+YF+NB/KX4lFr8afOi/OXH9Fdt7yP/M + 9UF9T/mfO/HYf0/5n7k+cP4rp/zPvr3mvxr+4Zj/mfqv+a8mz+1NtL4y/9X0M9/Mk74J/TkSvt8X + il+J819J+H7f+5+L+Z/n+B/iVw+fiYf4hoT4lVD8avufPz74J5Nwe8Ffd8z/zPURWG+c8j/79qqb + fw/5n6n/mv+q/pzzP3fmYf0cvt9/nlzE4/7oj/zPxfzPc716yv/M9U+wH9SgL/mvxOJXkw/tVW7v + 0nfwof8q6WvxK/mx/M/IV+bF+PD9vgitn1f8Kjn/cwFeiZ/6Lp7bK9R/V/wqOf8zlJ9v4qe+afqH + Q/52IX1X/CpN/3Di9YYkrk8qwIf9kSQuXy/kE/Ok74pfpfF7k7A/EuXypQEf1lfkv9r+5zT9xsEf + 6+bfbP7nxefAZ+KXvtMvzflj3fybzf+cph+b818lN/9m8z8vPtQH9c3mf/7qz/o+T27ip746/dXc + f5P7/iib/3nx7I91+XOy+Z/18zOz/9Dlz8nmf/7KP/if+f1PffWf/mdf/pp/Pz74Y935UTb/s/5H + /M/Z/M/q/M/A55v43IDn/HXe/5zN/6zDbxnOj1JKXP7Sd/KcLzeRvmnrO3g+/03u+6Ns/uePD/7Y + JFz+0reNv4b6CL9/gfZq0Fep/+rWd/L8/t38m83/rJ//eerbgE/MQ3s1+Nvd+VE2//PHB30V90fZ + /M8fz/Ern/85m/9ZR/7tNf8Cr9zepe/kefxx+XOy+Z8/PvhjXf6cbP7nxWd+n8L1X/o28D+Dn7b6 + +svWd/KZ+XIRv/QtP5b/GfnOfEKe9RIan8Xpu+Zf8DNT/5WtbwH/M5SfuL1L3wT+Z/QnMz/1lfH+ + 1/x7A5+YT5OX4V4e5c9ZePLC7Z36yqzPzL+hCjyXP/WVcV75+Z/VzrPc+VE2/7N++aIz817f7X/W + 6ded+lp99Pb6bv+zTn/ynH+tvT7/czb/81efGb9yPNd/6Tv46c/B+ieuz9J3+qXZf3InJV6xvSF/ + 7O313f5ndfmfkefyV/+dPPttbgm8/Z63/xn8t9W399r6zvzP7I+9/Pis19Z38vx+rlKZT1Cfz7+B + vBCfG5Sf+X1efnzWa+v7/p4vnn+9/3nwqSAf8i0nLh/WV9v/DPUhfa+9fn5/b4f8z8rlr/Xz5IXr + L4G39eTR/+z7S8f1s67zowZ8In6tnyfP77+XwCd7P4f8z359tf3PX/m5Bp7LX+vnkT858fvvpG/H + /dHzV36f3a+vtv957Nd05c+B8v36avufPz70X5f/OZv/+avPIf8zl7/0ffmVPwfzOfv32ba+gw/5 + gRuNz23rW37M/4x8Yx7a2774ldW/ZS5/6Yv5n5HPzAvwKZSfuPyl7+CVf89N+f0sfSfPv+emXJ+l + 7+RD/YXLF2xv0Lf59dX2P0+91vkR+GlJ37r1Hf7b4J+sfv+7/c+zf9Wgb6X+W7e+g4/5n2l8rq7/ + 1q//Yr5ors8an9/xYZ0fQXtTIx72v9v/DLzy+4H90dH/3JlPe716yv8szMP+6C//czb/8+RP/mf/ + eyi4fn7+yvUvpG/Z8+/b3hL0LYXLh/2Rlszvs9D6quD6efufka/MY3t5/fw8YR72v89fuT8W0rfs + /jv9z8FfrdxeHJ9L8Le7/M/Z/M8jHqjr/Aj9z1z+6r8vf/I/+/HK4lfDfxvzP9P6yuJXk2e/a6b1 + Vd7x5+HHDv52il9pRv/G81cNvDAvPyterTl8f5Rp/Wzf77/v/+B/Vn4/eiGfA5+YBz9h/sZn9DPz + +0T/ZDg/ep4o82Lln/I/+/IT+nOO+Z+ZB3/OMf9zYd78Ksf8z434bPF2DfeHaqL+m/b8O/JR8/mC + psT1SfB7PuV/VuKXvqM+4X6cROOznR+N9vL9ZZqE2ysNedY30frKzo+Gn/ngf/bvR9Ff95f/OZv/ + ebY3nB8pxa+2/3m+z4P/mdbPuufff/mfhXkYr07+50Z8KsjnwHP99QL+4H/OzCfggz9WheuD4/Mf + /uds/uc08xsf/M9eXzs/+pf/+SK+2HmKhvOj50lj3s4XjvmfO/EZ9gsS9BXSV9z+SIK+krj+CfaD + ouxvF2VeL+Rr4Ln+uP895H9Wrj+cL/yV/3nysvfvO/+znQ/ePr4hN54v/JX/OZv/efGJed9/5cb1 + 1cn/7MdnuXF99Zf/OZv/+ePD+S/Fr+TG9dXzVwl8Jl6xvRrqr1x/tf3+0f/M9ZEG5f+e/znj+XiD + 8/F9X564/GAZz8ernY9bPFAoPg/n4xnOx2/gM/Fr/vrX+TiXrzaey+l8vBO/xje8Hxl5Zd7mawnx + eZ8fLP/rfBz5TPwa32Z+MFqP+fPxjOfjs3xh3o9vcD4+eL6fUWh8g/PxDufjUH8/vsH5eIHz8Wa8 + Mr/GN4XzceQb8za+7fxgUB8f39vn4/P3/8f5eLbz8XmeEvYX/nw8vf8TPH/JHN/z+cEGv8a3yfP5 + mrsfefJwvpY5fpvc95WDx/PTzPGB5Pxpk5c9nqScAp+Yh/lrn48Dj/vH9IVMgQ/n+8rvc+mbx1/5 + Ptms3F6I7/11Pp7WT2j5E07n4769dj5+w/k4nEdXJf6v8/HCPJ4XB/+D+74y4fl4/8f5eOAF+HC+ + lhK3N8Hv+ZAfjPS18/HJh/bi+iTh+XiD83Hghcv35+O0Hvbn4ymej9N5ir8fOYXz8ZgfDNefCc/H + J8/+E+dPS3g+Ps7T2X/o70dOeD4+7lMO/hbNmXmx/qUplJ+4Pth//8gPlux8PH35xFhft79Idj7+ + lS8hfxruL5Kdj6fvfuRwf7QU5sV4qeE+4urrLxifT8Gf5s/Hk52PL55/n0L91+bfcb4c7r9282+y + 8/H0nY9Xrj+Nz4L7xxT2F8l9X5nsfPwrn+MDSaj/2vw7+dBe5frA/nHnB8PylXjYPz58aK/w+4T1 + 1b4f2eInt59/9/n43G/eIT5/+/F5n48vnvdH7n7kZOfjM55wF45n3l5fdd9XHu9HzswL8InPj1x+ + sGTn4/P75e/7SjxP9/ru8/HvfbL/wd+PnOx8fMZvD+fjvv/u8/H05RML5+/C9cfzl+v7fnbvL9R9 + XzkmlwrnTVfl93n5/qvX1reNv8bzcS4f/KU7Pxic/2bmV/+dPMefLzw/nTzEf/44Hx88xn/W+Tjw + pO/l9L1CfO8ife37yjT+KoFX4jG+dwl/f+3Oxycve3+nPeQX6tR/7fvKOv7K7XXn48nOx/OXT4y/ + f+/Uf+37ypFPLOjrzseTnY/nf+YH4/pgfoMe8s90Pz7v8/GZPzB8X+nPx5Odjy8+1J/0tfxg877j + 8P6FecjPuc/Hof5+fQX5web9yDw+u/PxhPnB0vgrv89G/dfyg83z9F/PxxPmBxvlh/wkLTO/vu8Y + 5fP+V5uff/f5ePnOx0P5ictf3++08VeOT7aUiVe43y18X/k84fLxfrcW4rfufuRk5+Pln/cjK/PQ + 3hr8D5X6b936jvPfeD9yzcRj/pka+m/16+d9Pl7+eT8y85h/pnL+1ecJ1x/v76uJ/TDV74/2+Xhx + 5+NQfhLil76Tj+fjjfkEfJh/q1zEY36hGu6vr8LvH/Lb/3U+nn4gP9jgg3+pkL6WH2zy8Xw8MQ/t + LcG/VGh8Lk7fwvFJfz9ysvPxqe86Hwee9LXvKwfP8auH5/YufScfz9P5fS5953l3OE8Xbu/Sd/Kh + vTQ+2/eVeD5u9ck0Ptv3lYOP+cFI3+z67yk/WGMe+m/4vuPhhXjUNwf/Q86BF+AT6+W+70g/IT8Y + j1c5cXsV86GF++uzBj4B/3t+sGTn44uf7cXz9MS8WP1T5fVDov5r+cHwfuQKvBKP/TcFfROtr+x+ + 5MHH83HS176vHPU5nI8n5uH3fMoP1ojH/rviV8DT+jnt/jvylYXxOSm3F+ffFPSl+BXkBys/dj6O + fGZebH0S7pdRil/9Iz+YtZfiV5AfbPLxfLwzD+urU34wJR7zJ/9xPp7sfPzLV3Y4H+f6LH3f31v4 + vlIpfqWW337y8Xycy4f7C3TFr/C8m8tf+o7yw/mpCrd37Y/Geevv5+NvTfD76NP9yKSv5QfD+5GR + L8xDeyXoS/EryA92jb9yeyVz+bg/WvEr4BOXj/ENCfq6/PaDV9gPrvMjPO/OzCfg4/k4xTfE+ZdO + +cGEedn72eP5uHs/kB+sns/Hvb6QH2zynF/l9usryA/WzufjfnyG/GCTF+Yz13/p2/5xPs780nfw + rK8/H0+YH2y09/f8YAnzg9W/z8cT5gcr/zgf5/Ixv9DpfmTf3gv9aft+ZOSFeMwfdbofOTGfgI/5 + wQqX/1d+sMq8AB/0pfhVyA8Wyvfjc8gPlgPfmQd9L/anCcWvID9YGzznJ7mE3w/mN+hBX4pficWv + Js/t7dR/LX51jb+GfFZ+/hWLXw0+5K/ofv4Vi1/h/cjA+/WVWH57ef8a9O2J2wvz71/5wQYP8+/O + Dwa8cnsxv1AP+nbl8iF+9df9yJO39Yas/PZ2PxrFr8TiV4MP43Oj/mvxq8mzf6lR/7X4lYy/cv0b + 6Wvxq1F+Vub9+YI0XF/t+5GBT9xezC/Uwv2MLXF7Fdsb7r9uyu1VW0+e7kdWLh/zzzSOPwvFr6Th + +nnnBzOe4ldi8avBB30r6VsxPvlmA6PfTyV9LX41+HB/X/XxSakYn5T1fQfyyrzs/cXODwa8X1+J + xa/e8XPFr4D3+yOx+NXkU+C5vUvfwUtor3B7IT4pK36FfGVe9v5LSiU/5PPEl18wPnm6H5nG54Lx + jZ0fDPnCfAL+cD8y1wfiG8f7kTPzAnwYnwvpa/GryfN8Wmh8dvGrfT8y1If0dfGrnR8MeOH2QvxK + Shifi3D5EL96b0Om+pP/Slz86pgf7CK+XMjz/Jup/1r8avBhfZVJX4tfTV4CL8xje0P+mZy4vQnb + q+wnzMrtVTtf2PnBkO/MQ//NYf7NyvVf+o7y2Z8jFL+SjOcLx/xg/n1a/Grwv+cHS5YfbI6Hp/uR + Aw/tTUHflC/iMf/bKT+YMg/jcwr5/RLp6+JXz1/595lof2Txq5HfTMP9y8rthftHTvnBSN8Vv1o8 + nfc9T7i963zhna+D/8rnB0t4P/L7fkL86vlDJh7ul5F1P6P9npX0tfuRhz+Z489C8at/3I8MfOby + 1/0j4H9G3p8vwP3Io3yl721Faf61+5GnX5r7L8Wvtv/5e//BH6vC5aO+yvHn5wm/H7h/5C//czL/ + 83efMp8fPXwiHuLPOz8YlF+4fIg/S8hPIkL6ytZ38Hy+8DwJvMXb32xgzPv48/Y/f3wYn4X6r+z+ + O/zJh/xg3F6cf1f8Cv3MXB+cf4Xjz97/nMz/PO+vPPmfoXw1//O8XzKcHz28Eg/zb8rcf5O7X0bN + /1y++44Dj+Ozmv+5fvcp58AX5gX44I9186+a/7m4/GDg31auj17wPkP+Gfd9pZr/ecxHz/TC+Wey + cPmwft7+5w58Zd7m3+1/vjafqi8/4f5o+5+RF+Jhf/S6nam9bv6dfEJ+1B/y57jzo8HD/Lv9z9Ze + 933l5AX4g//5Jh7yrx79z/x+9EKef59JG/Og75p/7ffjvq/UtWXe5fP37/5+ZF1DxOLD+ZHPD6bm + f/74T197n+78SM3/PPVa50fIN+YT8sp8Zh72vyl8f+TvR1a8H3nwfL7v84Mp3o+cfyw/WAM+Ea/Y + Xj7f9/5nxfuR84/lB4P6CLdXsL0S3qdwfSC+sfODWX2E+q/g+WAK86/3P2u8H5nr4+ZfxfuRdbiX + ub1C+grGr/7KD6Z4P/LgE/cvSVwfiF+lMP8+fCIe4lcpfH+U3PyreD+ygv8Z/NLC7RVsb+i/Itxe + yJ+8/c/gp/X9F+5HHv7hGvy3NRGP90Pd4Xz/9vMv3I/8nufewb9xe323/3nxEniu/9J38ME/eaeL + eBifl/8Z26vMw/h8zA/G9cH7v25ePz+8EI/n+zd/v6Du+0rF+5Gnn5nLd/nBxuAD+9/tfwY/sJ9/ + 1e5HRv8z8CUzD36GK+h7FS4/N+R/9T9P3taTenH/fZ8Qj/6Ni/uvzw82B+cL+Xg/MrcX/XWXBL+0 + 77/vP8Cfc0nwbwu3F/ZH2it9T+fzg6n5n+f9jz3o2/34vP3P8/7KcL/M86Qwn4AP+vbM9YH973sb + cuCFedv/arhf5nlyE7/2v8O/reE+aD8+w/3Iw7/N+yOfH0zN/1ynH1uiv5rrv/Sd9yOH9y+BF+PX + +RH6n/3vuW19J8/+MXc/spr/uY3fWys8/rdSmU+Tn/5n9l+58yM1/3P7/M/c3kb6rvOjjw/js7sf + Wc3/3Ga+Mo5vqDs/UvM/N5cfDMpXfp+akGe/a6P+u86P2vj9NAnvX7j+8rV3+IGDvrV6fp0ftc/P + zL+3SvrWre+//M+F+a+9b3+pQd9K/bdufSev9P4r6Vu3vqM+KfiNE9d/6Tvej4b2pkz80nfyob2k + b936Dp7XV97/rOZ/Xvz8PWfgWS/Ut4TxudD6qmx9Bx/ykxQan4vTt/D3od7/PPkEfLwfmfQtTt/T + /ciVeQE++CdL4vYufQcf9C2kb3H9twR9iwYe+m8Rnt+L8PsUbK+E8ml8Llvf4QcO/df5n9X8zx8f + 84PR+jk7fXPov7kEHvrvKT8Y1wf1zWH9nDOXj/qe7kfm8pe+7/s/3Y/M5aO+me8PUopfbf/zx4f+ + S/Gr7X+e80UO6+dM+uat7/DTHu5H9u1NW993/jrdj5yJX/pOnv2iFL/a/uc21nvh/EiTj09u//Pi + ebxKtD9KW1/5Mf+z+RVTYn7pO3gN7VWuj17Ih/Yqt3fpO/jw/RHFr7b/efGhvcLvH9dXp/xgvv7q + 1leH/GDUf+38aPLR/xz4BPzv+cHU/M9zvXryPyvzYuvhk/+Zy8f18yMP/R7c+ZGa//njgz9Wldu7 + 1s+DD/5Yil+pnR/Vnz/zg6n5nyf/x/3I+rP9z3M/8kd+sMHj/uiUH6wzD/ujg/+Z1s92fpQGz+0V + mn9l6zv4RH4VpfjV9j9/fOi/krg+S9/Jh/bS/Ct4PvjX/ciDh/PBv/zPk5fNb/+znU/dvv9u//PH + /54fTM3/vPjgB/bxje1//vjf84Op+Z8XL4EvzGN7f/c/q/mfP5719f5nNf/z4tnPcGtlHs5Db+6/ + z5ObeIhvbP8z8vz+4ftBuYL/6vL9d/ufF8/1v0jfy+n7h/9Zzf/88cEfe/n5d/uf5/n4yf/M9YH+ + e/Q/c/nQf2V9v4/+5Jt46L/7fmR4P77/bv/zxwd9KX61/c+Ln+1V4Cvz0N7lfwY/LenbXf/tJfqT + L+JR3xW/gvKp/3an74pfAU/9t7v+u/zPyAvz0H9Xfnvg/fwr3em7/M/AK/Oob+f8jc8Trr/afCQ9 + 6NuFy1/6Tj7o5eOTYvGr13/Swv31jfS1+FUdf+X+0vz6avuf67zP93A/cmYe/Dnr+33khfil7yg/ + s9+sZa4/rK+2/xn4xDysr2Tlt0ee66/Y3vB9CsWvtv/546P/mfpv2/pOPtRfuD5L39fvcfI/+99P + 3foOvrDfu/r90fY/13lfcOi/lcbnuvUd5edQPo3Pdes7yg/jcyV969YX70eG8lMjPhXgg7+9KtcH + 9kfb/wz1UX4/sD/a/mfkhXjYHz18qL9w+Wv/O+7/DfoWH58Ui19NPvh7af61+NU7Xq34FfqfO/Np + 75f/8j+r+Z8XH+pP47PFr97xqoTxuSRuL8Q3ZMWvkE/EQ3zjL/+zmv/54yXUR/l9Qvzq4cP7JH1d + /Grfj2x8Jn1d/Oq9DZl5H38WF7/a/mfkE/MWv9r+Z+SFeIhfbf8z8NR/Xfxq+5+BT9xeiE9u/zPw + 1H8tfoX+Z+S5fMX2SnifND5b/Gq8z7B+zrR+zk7fP/zPav7nWZ8U+i/Fr8TiV4MP99dT/EoSxp+3 + /xn90ko86puCvhS/kuT0DfErSaRvcvqmoG/y50eSXP9NQd9E86/Fr4YfO/qfhXmIT+77kZHn97P0 + HX7d0H/Jf7X9zx8f9r9K+qobnzX0X4pfbf/zx8f7kUlfxfiknO5H5vIhPimaeL4j/9X2P398WF9p + 4vbi/BviV0Lxq+1//vigryq3F85/JXy/L+rjG+B/nvmfefwXf/4L/ufBB30pfgX+58lze8X768D/ + PPigr/t+X9H/PHlur5C+4tZX4ft9ofjV9j9X5382fUW5vYrtDesrUa6/YnvD+kpofSVOX+H7Vb3/ + Wc3/XKe/l8fn5M6PxPzP1fmfgUd9xfzPdfqBQ35gd7+MmP/54zl+5fM/C/qfJy/M4/pK0P/cfsz/ + DDyun8X8w9X5h/fvwfuHxfzDH8+//+TmLzH/8OIT8yXwCXjePyZ3P4uYf3i2N5y/eP+wmH/448P7 + cf5hMf/wVx+ev7x/WMw/vPhQf+X2Kvwe1v0s9vtx5y9i/uHF8+8tCbdXoL1/3C8sb5epBfn5PsFv + XG7i8fe/5i/kO/NpxytS+H7H+4cHD/6l7R8Gvy6Ob5MX4A/3C3P5yeKZf/mHB7/0nXxiXgOfgA/+ + cFUhHuK32z8MepG+7vud1y1M7RXS1+av4TcO33e473fE/MP18w/z+5QS+ATlB30l38RD/Hb7h5Hn + +kP89ni/8EV8wvZqaK9yffRCnr6PS0L91+avt7+LcH5sIX0F4z/rfmGsjyjzFv/Ru7Lf0t3PIuYf + rl++5ex/b/5+YTH/cP3yJ6fAc/kwf538w37+0tudn97cf58niXkBPrGf0J2/iPmH5/n7zfo+vBAP + 68+jf7gyD/7Ddf5i+fpc/hkx//BX/5Df7xYuH/W9Kn2v8Txxv0+9nL6n/MnM4/n4KX9yYh7Ox5d/ + 2N7PlTvxsP58/jp/bxfwwrzFu3b+ZMtfffnxWS+n7zp/gfL9/KvX1reMv7K+Lv/M5C3edbpfWPh9 + SkO+cPm+/77/kL2f3fcLG9/9+Lz9w7P+637hDrwSj/6WP+4XFvMPf3wO9//6+Xf7hxcfys+ZeQE+ + 3E/aE7cX/aXrfmHg/fi8/cMfH/ylXbl89C+t/MnAU//tGN873i8szFs8RFvl7xca6duc/3Dln0E+ + E7/0nTz7sVsJPPgtW+i/7vxl8EvfyQc/LY3P5h8efNC3JW4v+kvX+Qv6gS/iFdsb7idt1H/NPzz4 + 0H+bcPnoL135k5Hn93PyDxtfSd/q9K3BH15JX/MPj3y/hetfqf+u85c+7y/+/X7hwU99F8/trX5/ + tP3DHx/8/5XG53X+snj2x9bE9Zn69uFXOeVP5vYqtjfoW5XLl6+9Mnjh+kjgxfgS9C1+/7v9w93l + Twb/ql8/b//w4hPztL6y8xfMnwz18etn8A8PP/PBPyzMw+/5j/uFBf3Dg9df/cOC/uHJB3+yNuah + /678M8hz/bH/rvwz4N+Wwjy0N+SfUYr/gH948Ox/UIr/gH948uzXyqUwD+0N8R91378L+ocnnwMv + zGN7g//Q3S8s6B8e/mdlf1pOSrzaeYRmju95/7Cgf3jwwZ/m7v8S9A9PvzHrm4Xbi+urP+4XFvQP + D/73+4UF/cOTr4HvzEN7T/7hRjz6wxPfX6kUvwL/8MhvzPlnnidcH9T35B/m9iq2N/hLE+mb3Prq + 5B/m8tEfHs5fNJG+7vxFw/nL88S3185f3vklnL94/7CYf7h99xFze93372L+4bl/1BzKz8zj/kg5 + Pq9K+irG57d/GPjE7U0Wr975k9V4Wl9Z/Gryob0+vgH+4cEf/MM38bj/PeVP5vJP/mHjhfR18au/ + 8icPHuJXx/zJXD740473C3P54E/b/mEFPjMvwHN+v+fJTTz4S1WCvpK4fLX4pJ7yJyfmE/LsPxca + nwXjk9s/DPURrg/6S//InyzoHx78wT+ciV/fR4/7cz99zQ95Fy4f8wvdIT/n7fsv+IfTj/mHka/M + C/DhfO32+oJ/ePAa2qvM64V85vYqtxf9hyf/cCce/Yc36yu3cPnoL72CvpdfP4N/ePqB+TyR4lfg + Hx7l/+4fFvQPv/pe4fyU4ldi37/fP+YfRr4wL8AHfa/EPOaPuoK+l98fbf/wzO90BX0v5fbC9+9y + ycW8Pz8C//B4P8Ln0Zdw/dH/f/IP+98/+Ycr57Ptfv6V7vT9wz88efBLL/+wtZfiV9Jd/+08PgvF + r6S7/tuDvhS/ku79w4l/P93Pv2L+4eHvDf6Hrvx+nH+Yx+fXUUy82HnZ81f2p3VhvWD+3fmTjW/U + f9k/zL/PVpj3/uFQPvXfhucL0kL/bf58AfzD1+D5/VP8CvzDgz/kTy7Ew/pq+4eBp/HZ/MOTZz9J + 8/tf8A+//beF/JyNxmeLX8n4a2gv6Wvxq5evfL+qUPxKqvOX1jA+V9K34vpZwvfvUguXD99XSvj+ + XSh+JdX5lyrvj6TmwMte/2//MPB+/Sz2/fvgeX8kFL8C//Dkuf9S/Ar8w4Pn+MbzhOuz9J18DTzX + B/1pIX4lhfQtuD/a+ZORz8Sf/MNWn1ICf/APA+/jV+AfHn7gzL+fQusri18Nv27Ir1t8fPIf/mHk + lXjY/0r4/t37hyX4h/l+c6H4VfAPC/MSeDE+fP8uFL8C//DkKZ+GZJp/z/5hKL8E/uAfBp7m37N/ + GHku/+QfBt7HJ8XFr56/CreX9LX41Ts+n/Inc32WvtMP3ALP5Xv/cHj/pO/ZP2ztTbS+Iv9wyK+b + /PmguPiVhPu/hPxX4B8e/tiQXzfR+jm5/hvur5dE43PC80EJ+Rt9/mRB//Dglccr8l+Bf3jkNw76 + JuX6K8xH4f56Scr1x/k3hf6bhOuP82/wX4nS+sp9/y6H/MmF+QLrDQ39V6n/qltfaei/FL8S9/37 + 89dQfxqfFf0bO38y8Inrv9ZXgw/jM8WvxH3/LuH+ep8/WTB/8uCDvipcPnz/Lqf8ycK82Hpbgr5C + 47OLX23/MPCkr4tfHfMnV+ZhfyQ5lE/6Wvxq1Cf0X5c/WdA/PPjQf4X6r/NfHfMnC/FL35GPOvRf + US4f859LGJ9FuL0C+/1T/mQuH+4veLMlD978exnik68Z6Zw/GfzAkN9v8j5/cvQPF+YT8MFfh/Pv + 5OH+ghTyzzxPKvPY3kP+5It4uJ8ihfsLXP7kya/4BuZPRp7ro9jekJ8Tv9+Z/NJ3lC+hfPDnfDy0 + N/H6OeH9my9v+ZOH/zb4J/H8aPJw/8jzV9YL59+PT8AHfXH+nTzkb3z+mgOvzH/tHf7kQ/5kbi/c + L/P8lX8/Cfyxk1/6jvoEffH86OMT8MEfm0hfy588eQl8ZR7au+Zf8N+SvpY/efKZedLX8icPvzT7 + r54nlXlo78n/fBGP+ob7C5z/+eMFeM7/5vInTx7uNz/5n5Xbi/qe/M9cPuq77t8EXjrx2H816Iv5 + kz9ejF/f7xgvpK+48fmQP7lm4nF8Xv5n4Evgwe+97i8AnvR150fH/Mlcf8xvv+Zf4FMjHv3tYf59 + nxCvdp6Slv8Zyqf+686Pdv5k4OUmHv3tp/zJwry1V2/uvy5/8mvWdedHJ/+z1xf8z+/54O/+54+H + fDt38E+i/3nysL465k8W5gX44K+7E7cX1lfH/Mk38XohH/zkfv4F//N7Xn+zvs7/PHmIP2//M/KJ + eVs/v25nqs9VfX0ujD+f/M9+faUXxp/14vspnidcPvrbf8+fPHn0t185+Kv9+KwXxp+3/9n8Tlfi + +uD5/u/5kz9xL+TZj3cp1wfizzt/MvLcXtj/6sX7I70k8Lb/fbMlE9/9+hn8zyPfcvDXdeq/3fk3 + Ot+f+zypzEN+3XD/5uuIJv7kf4b6+PUV+J+nn5n9Qp36b8f4pK78M8gn4vVCnv1OXQMP+UhX/hng + /fgM/ufJS+CFeYtfaavc3kb6nv3PyCvx3v/MfrPm90fB/8y/h+b3R+B/Hvmccyg/Z+ZHe6efsyX2 + n+D9m5Nf/tj39xbOj5z/efJ6Ic/9sSnXZ/lj8/gr+8eacHuXP7b+nP3PiXkxfvmfrfxK+tbtjx18 + 0LfS+Fy3P3by7G9E//PHJ+CDv67S/Gv+5/Jj/mfwA2euT8b2hvG5+v0v+J9H+crjVVXml755/DWU + r9xe1PeQP1m5vUvfyYf2SmZejC8cv3L5k1/e/M+Dj/5nvz8C/3P6OedPzsxDe0/5kzvxuSEv9Hso + NP+Wre/ggz8W79+cfML2plA+6Vu2vuXH8icjX5lPwIfxuVD/LVvfyYf6COu19H358P27ZtI3b30H + H/ovnh9NvlzIR/9zYx70PfmfmV/6ph/Ln3z2P3+8AH/wP9/E4/h88D+Tvnnrqz9n/3NmHr5fyMLz + UVauv2B7D/5nLn/pO/IPB/8kfr8/F/NL38EH/2Si9VVy36eE7/dd/uSPh+8Xfvc/Tz7DeiPkn9FE + +rL/Ofi9af3s8s9o+H7f5U/+NjsX8tH/XJg/+J/Rz8zl/+V/VubF1p8n/7Nvr8s/84f/efL4/eDJ + /xx4WD+H/DNK8Su1/DOT5/Zq5vqDf0M15Nel+JUq+je2/xn9zFwfhf3Cyf/M9cH82Cf/cyce8pMc + 8ycL82L7tZP/2Y9Xdn40+Oh/pv4reD549D8HHvzeh/zJ1H8F/VfH/MmFeWxv8LdLYh73vxL0FdJX + 3P735H/uzMN+X4K+Itxe9LdL6L/i48/gf37PH2+ef58njgf/8+B/9T9PHv11d8jvR/Ercd/vH/Mn + 38Rjfs6T/1mYx/Ye8idzezE/58H/7Pe/4H+uP3/lT/74hDz7J28/PoP/edTnkD+Z3z/qewV9L7++ + Av/z4KP/mfR18avtfwa/rl9fgf958CE/J8WvxMWvZMWvzv7njxfgf/U/Tx79k7/7nye/9J1+6Vkf + 9D9z+eifvHj97PzPk8f8UVfQ9xJ+/5h/9ff8yS/fcXz+w/88ecwPdvI/Bx7a24O+nfS1+JUMPtTH + x6/E4leDP/ifO/GY/+2UP/kifs2/k6+B5/aiPyfEr54nXP5aX02e9e3CemH+1ZP/2f9+mvPHrvgV + +J99/Erc/V87fzL6pRPz0N7lfwY+c33QH7v8z8gL89jeX/3Pk0d/7MH/nLj+S9/Js75NuXz0xzYJ + 5fv1Ffif88/Z/8zthftljvmT/fs0//PkuXyKX4H/+Z1fTvmTK/PgF61BX4pfgf958qH+meuD/thT + /uROPPpja+LfD8WvwP/cxl974BPz4J9c8Svghd8/+idX/Ap5fp/on1zxK+MpfgX+58GH9VUhfd39 + X1JC/y3Uf939X9v/DDz1X/f9vpSwvqL4lbjv97f/GXgf3xD3/f4pfzLp677ff/7K319Q/Ar8z4MP + 35cV5fcp2F6h8wKXP/njob2n/MleX/f9vuSgb/bxyf+m/Mkfj37g8P1g9vtfcd/vH/MnZ+bh93zK + n8ztRX0P+ZNpfXX2PwOvXB/UNwd9yX8F/ufJ8/caWbj+S993PXPyP3s+uf578D+Xi3jUd/mvkE/M + H/InIy/EQ/xq+5+Bz1x/7L+JzxeeJ1x/1Pd3//PkFdv7q//548HPf/A/C/P4/cLJ/5yZh/no5H/2 + vx+LXw0++p9pfaVu/v3d//zxMP/+7n+ePPrbNehL8SvIn/yuT373P08e/e2aQv2VeVxfKcefnydc + f1w/a1g/qzCP/vYQvxLyX23/8+TD/V8iPv68/c8f/2v+5Mmf8idD+aTvOX8y8KSvi1+9bufAV+YF + yg/xDfJf/Z0/OXH9cf8b4ldC/qt/5E8GXrg+uP8N8Suh+NU/8idvPuH9Bc9/IX/y4EN+4IzxjQvz + J08+MY/6Xpg/efAcf/b+5wvzJ09eAs/1z9jeFMpPzMP+N4X51/ufL/M/Lz60V7n+EH9+/qqBV+Lh + +8G05l/gcX90mf95jD/H/M/F8Qn3R8f8z0r8Gp8nz+11/ufL/M8fH/RNGJ+8zP/81T/o686PLvM/ + z/dzyv/ciIf8kynkz/H+58v8z4uvzGvgE9Sfx+fk5t/L/M+L5/y0Sbi98P3gU53gNyZ93fyb1vwL + fLmIh/n3mP85Mw/6HvzPRYmH+ffofxbm4fd8yv/M7YX4xvY/I8/1h/n34TvzyuWjvmv+BV5u4lHf + Nf8in5iH9grnB05u/r3M/zzf5yH/c7mJx/4rvL5y+Z8/HvQVXl8lofFZnL4Svl8Q0lcwvpEk3cwn + rj+c/6Y1/0J9lN+PXsiH9mpmPgEvsXyuP8Q3tv8ZeAk8nHffwV93+/6rt/PX3Xy+4P3Pg8f7r+9w + PujOjyYPfsI75L+6vb564/73+Wv1enn/8+QF+JCf8E7cXsxPeH/5gf/hfx780nfkx9bgZ1YuH/MT + HvzPfv7VG/e/2/8M9Rd+/5if8Ar5vS/S99r6zvzPKfBKPOafPOV/zsyDX+XgfyZ9r+3PmTy39/Lr + K72cP+dK7O/C+zcnj/6ri/dH6s6PrvV/mw/5RS/l9qK/7uL97+uIJh79dZcEf7WwXui/6jz/vk8c + 351/svP3+9r9/Lv9zx8f9O1+fN7+54/P7Cfvfn21/c995kMO+vbM5aN/sof+26n/9q3v5BP1r076 + 9q3vqM8h/3NlPiEvXD7p27e+1/hreP/C9V/6Dr9xyB/b/P5o+5/79Esf8j8L8Uvf6X+uzJfG/Nfe + 4WcuPB420nedH13Tz5xD/UnfdX50jf7egr4tcX2mvtfnZ+Z8/s2vr7b/efG03/f+58kn4Pn+FO9/ + Hrx87R1+aWG/ayN91/nR5fzP4Ket/vezzo8Wz37sSvPvOj+6xu+zcnzD+58v8z9/fOi/lcbnuvWd + /Kx/B57LX/q+v8+T/5nbu/QdvIb6+PXV9j9/7+eQ/5nfj2J7gz+2Crd36TvKD/4rd350mf958if/ + sy+/OH1LZb96ofm3OH1P+Z8T89Deg/+5cPmo7yn/M5efsb0H//NFfML2Kq8nizKP+ob8OVqU67P0 + HXyYf4tfP2//8+JDe6n/lq3vv/zPvv556/sP/3Nhfun7L/9zYT4Bf/A/38QvfSfPv7dM+man78n/ + XIlHff/wP1/mf158aK925kHf3/M/Tx71Pfmfub3Yf0/+Z//+k9P3lP/5Ih71TUHfRPNvcvqG+JW6 + 86PL/M+L5/a67/cv8z/P+esP//Nl/ueP1+B/9vGr7X+e82kK+iYan5Obf0/+Z34/S9/hP//d/3yZ + /3muZ07+Z1++7vXV4Pn+XO9/vsz/PNc/GvSl+NX2P3986L+auT64vgr3bz5PCvMC/CH/M/NL38EH + fZXWz7r1nTzv91W5/grryZP/+SJ+rZ/R/4w81wfXz+H8SIX6r2x9p5+Zv9+k+NX2P8/6CJ//ev/z + 5EHfEL96eCEe9Q35c1z+54+H37OE9ZXQ/Ct7f/Qf8D8PXi/kWV+h8Vm2vv/yP/P7FNgPnvI/8/tZ + +k7/8+15ofjV9j/36U8O/jqKX23/8+LZn3P79dX2P3fnf7bzrzt34mH/+5f/+TL/c3f+Z+B9fHL7 + n7vzP2M+Z+aXvpMP7VVuL+x/j/mfG/GC7RX2793C7V36Dj/wIf+zL/9y+l6V/eoUv5LL6XsFfS/S + 93L6/uF/vsz/3Kc/ObN/7MqBt/579D934lMBPujrvt+/zP/81ed3//Nl/uePD/66S7l8wfYGf90l + 3F4Yn6VXrn+n/ttx/pUe7q+n+JV0nH+P/ufOfAL+1/zP878wPu/8z1B+5vqjvif/M5eP+vagb/fr + qzUqbp717X59JR3nX1nxK6iP3x9J3+ur0d6gb5fAy16PHf3P/v23vX6ePOvV/Ppq+58/PujbSmU+ + Ic/1p/iVWPxq+IEP/ufCvACfeD5qidubbL/wl//5Mv/z4lnfplwfTcCH/tuE6yMN+VA+6eviV0f/ + sy/fxa92/mfgqf9a/Opf/mcuvyTklepfaXy2+NX0P/Pvv+bAY3sP/udKfML2plB/5fYufaf/mefH + qtzepS/6n4EXLn/pO/lQf+H6L32HnzboW2h8tvjV4KP/mfS1+NXk+f0Uv34Wi1+941UJ6yuKX23/ + 8z3Gq5P/WZgX4H/3P1/mf/740H8pfrX9z4vn/O3Fny9s//PHR/8zra9W/Ooe41vh/ZH3P1/mf558 + rvx7I//V9j/fwx/4h//5Mv/zV/7v/ufL/M8fH/TNpG/e+k6e11c5B16g/nw/jmS/P9r+56/8MP9m + 5fYufUf5B/8zt1exvb/7ny/zPy+e17fZxye3/3nWJ8Svnie+/LT1HfmKg74Uv9r+58Vzeyl+tf3P + Hx/0TZl57L/BfyXJn/9u//PHh/6baP5Nrv+G+NXDC/HYf8P3+5Jo/k2u/6Yw/1L8avufF8/9kfxX + 2/98u/zPxmv1v0/d+k6e4lFC/qvtf/744I9VH3/e/uePD/oq7X8tfjXyUQd9yX8lFr9654sQv3qe + NOITzEchfuX9z5f5n68vX3Ror3J74fxI/vA/X+Z/vlz+Z+SVebH12Mn/7MsXjD9v/zPyQjzEn4/+ + 58I8rCeF85sJxa9EMP688z/b+xcan2XrO/igrySuD66fJegrpO+KXy0+tFe5fFw/i/B8LcrtRX0l + 6Evxq+1/HuWncH6U3PdH3fzPH8/6Jnd+1M3/PPYjx/zPjXmLt6dw/8LzpBO/9J38bG8FXpi3/eAx + /zO3NxXglf2EGfdH3fzPl/M/A6/cXtj/pnD/wvOE3yfEn9M6P0Ke2wvnCylx/snniX+fCeMbp/zP + NREP8eeHZ39mKoV5aG/i8/3k5t9u/uf5PsP9C97/3M3//JV/yP98E5+wvUHflLi9iu095H+uzFv8 + KoXzo4dX4iF+tfM/q/HC5UP8aud/Nt6dH3XzP/eZfzj42933R938z4uvzJfEPLT3lP+5E4/6ama/ + tzs/6uZ/nv1x5X/+h/+5m/95jg+a2H/r5t9u/uc5XmnQF+8P/XgYr/7wP3fzPy+ef89K/dfm35df + 8y/6n72+4vrvKf+zEo/9V9h/lYT6rzh91/kR8PkmfsWfhx/4kP85MQ+/Z0kh33XqxMP5YFrzL/Ck + rzs/Smv+RZ7Lx/4b7l9Iovw+sf+KKJdP+gqOz3pX9svdXt/tf76+/M/BD1xu4iE++bqdff2fJ5V5 + ON+/g//qzlw+xK+O+Z8L8wJ8CvVJXP7S9z2PW+dHyCvxeiGfmNfEPPiRbtbX53/u5n/+6n/wPwvz + 0N6L+++bEdrxl/NfXUHfy/dfvZz/6uL7F/Ty47NeW9/hxy7s/7wy1wf2R89fI1+YF+CDf/Ly/Vev + re/kM/O+/+o6P7qnv1pDe/36Si+Mb2z/M7xPYR72vzv/M/LCvO1/tX/rK/Dfkr4d4xvPX1Pghfi1 + /339LT303+7H5+1/vj//M7e3+/l3+5/v6d/OoT45My9Q/sH/3Ihf8Y3Jc3/ppG/f+v7L/8zlK7Y3 + 9N8uzC99Jx/q49dX2/88+Rb87Xh/6Mu3rW8bf6X9zvMkE7/0nX5p1rdR/21b38GH7xfw/tDJL32H + vzrkb2+Zy1/6Dn/1wf9ciV/6Dl4vbm/i+ix9Jx/aq1yfoW+S6d8O/smmXP7Qd/PKvBTmZfJvf6xh + fK5+f7T8z5tnfavfHy3/88O/41W4P/TNCM18Aj7o686P+vY/b164/Bx4AT7oW/36efmfN8/jc01c + f8X2HvzP/H4U2xv6byV969Z38tx/q3D9l74jv/HB/+x/z2Xr+5Z/yP9M+hanb+H41fOkMA/tXedH + mM+5EY/6nvI/c/1R35P/mctHfQ/+Z+q/ZeurP+f8z5n5BLyE8n18Y/mfV30k+M+Fy0d9c+V88pn0 + zVvf6Zfm+mdaX+WtL/qfoXzSN299p585+I1pfZW3vsMPfMj/zPVf+k7/M/vl3PlR3/7nxQd9KX61 + /M+bD+9HuT5L3/+A/7lv//N6Pwf/M5e/9B3+4YP/2b/PtPUdfuBD/mclHvvvKf9zYR5+zwf/M/Xf + tPWVn3P+Z64Pzr/h/EhT4vLX/DvyRWv0P2ficX11yv/M5eP66uB/ViFeYD158j9zfdb66uVD/ErV + x5/Vzo8w/zPymXhcP6/zI+Bp/2vnR5NX5klf3eur9GP+Z+S5fDj/3f5n4BO3d+k7eA3tTdxe3B+t + 7/eBp/lXt76D5/NBVeH2CrY3+GNVuD5w/rv9z+CnJX3F7Y8k6Cv+fGH7nxfP+lL8avufPz7z+xFa + Pwue72//M/Ckr7j9rwR9JXF9cP8rQV9Rbu+Kb6D/GfnOPOz3RW7mSV87Pxr1+d3/PHnZ5e/8z+hn + du9HLH71L/+zEL/iG//yP2fmE/ISeCV+xTemXzrwmeuz9J3+58p84vYmbG9iP9iduP6K7T34nxvz + 2N5wvn/79ZXczn91s75C8Sux+NV/wP/czf98ufzPwPv4pLj4laz4FfKJeWjvFc73Lx/fkMvpe4Xz + 38vPv3I5fU/+Z65/wvby/CsUv9r+58Wzf+Py6+ftf/744M+h+NX2Py8+tJf0vba+L9/D+X4nfbvT + t3/5Y4H347N0138733/k8z9PHvTtvD96eCUe9T35nyvz8HvufP+Cz/88ePRvdA1+7yTEw/h8zP/M + 5S99h/9Z+Hyf4lfSnT+nC/9+up9/pWN88uh/dvORNOfPaaH/UvxKmvPnnPzPnXlo7yn/M/Poz/kj + /3NH//Pgg7+u+f0R+J8Hr9Evze1VbO/B/5yYBz9SC/23kb7N6ftH/udu/ufJ18q/n0r6VuevO/if + Sd/q/HU1zL8Uv9r+568+YXyufv28/c+L5/bWzPVHf93J/8zlo79ufb+PfCIe9a0hP3D1+9/tf/7e + z8H/zPVB/2QN+lbh94n+2JP/2feX4vRd3+9DfmbStzh9T/7nxDy094/8zx39z5MP9af+W5w/9g// + c0f/8+CDviVx/WF/JCXMvxS/Av/z4H/3P3f0P0+e/AyvI5p52fvNnf/ZePJfgf958jnwSvzS9/WP + nfzPjfkE5Uf/M43PGfe/O/8z+p8z89jeMP+S/wr8z6P+QV+KX4H/efLBn0z91/zPg4/+Zx/fAP/z + 5EN7JfDQ3pP/2b/P5PQ9+J9pf2T+5/Rz9j9z+f8N/ueO/ufJ83iVaHz+2/98Ef+H/1lv4nF8TmH+ + pfhV8D9zPn/yX4H/ebQ36Jsk8DA+h/iVkP8K/M+DD/oqrZ/P/mfkO/N/+J+5/P8G/3NH//PgD/5n + rg+ur0L8Ssh/Bf7n6ZcO7aX11dn/jLwSj/uj8P2+kP8K/M8vH+4vE/HxZ/A/D//t7/mfO/qf84/5 + n5HvzJvfbOd/Rl6IB3/s0f9cmP/a+/4+JcQ3JHH9wR+7/c/AK/MK34f+kf+5m/+5/yv/s3J78fvf + U/7nwMvkX3/aH/7nZv7nj4/+Z1xfNfM/Lz4xj+urZv7n8X36yf+M+jbzP4/8cn/lf27mf+7Tj839 + 1/ufm/mf+/RXa2gv6tvM/7z40F7c/zb0P09eub24vmrofx7+89/9zw39z5j/2fx4ifQ1//Pgg3/S + fX/U0P88+RT4znwCPke/tBIP9zs/fPAzk77mf35/DylFPzPzkJ/h+Sv7Y5NyexV+z0nZn+nm34b+ + 5+GXDv7JJMyjvz0Ffd3829D//PJr/gU/bfXv3+XPOeV/rko85Cc85n9OzP/hf27EQ/6NY/5nrg/k + 33iWP+znd/NvM//z59/W0F7SV52+p/zP3F70x6oEXri96I/9I/9zM//z508O/df5nxv6n4f/toT8 + ydR/2f/M+rr8OQ39z4MP+krm+uSGvHD9M5cP+ZGSsD/H539uwf+cQv2V27vWV/pj/mfkE/MJeAnv + U7i96G+XoK+7f6GZ/3nm17p5/6vu/Kih/3nwwZ9ze33B/zz5FPjMfEKe/a631xf8z/nn7H/m+mN+ + s3V+hH5mLh++L3v+mgKfiF/6Dn/ywf9cmHf+5+DHlpt4WD//lf+5of95+JMr5y+9/Pyrdn4080Vz + +Rfpa+dHwz9cgn+4cPkQfz7lf/brK70wPnnM/xx4AZ7HZ70S1wf2v7rOj9DPfBOvFq875n9OzB/8 + z8ALl+/9z8G/LVz+0vd9n53nX+2kr50fDZ7n3zcjNPGo7yn/c2ce9O1B3079186PRj7kQ/5nrj98 + /3v0P1fi4fxIe9C3+/H5PVK/kA/tVW4vnu93CeUL83i+f/I/Z+ZB38bfD2rz8y/4n3X8lctv1H+b + 82+0oK/L/9zQ//yOzwf/c+by0Z/Tgr6Nxufm/DktjM+N+m9z/pwWxmfnf27ofx75mYO+jfqvnR/N + fM6hvcrloz+nBX0b6WvnRy9/8j/792nnR4Pn9ZXP/9ws//Os/8n/XJkHfSvvf33+52b5nxcvgRfm + sb2J/aKV9K1O33V+BDyNz3Z+NPlQPvXf6vxXf+R/bpb/efESeG4v6ls4vvE88fUvTt/C8Q0t1H/d + +dHR/5yYh/no4H/2+19150dH/zOXj/NvOD/y/ueG+Z/f8S2cH/n8zw3zP08++JOV6wPx553/Gf3M + /P5x/i18v5UW0tflz9Fwf9nriHZ8duNz5vt/3yfEo77h/EgpfqUZ488azo/UnR81zP98/5j/GfnM + PMxHf+R/bpj/efAcv1KKX0H+5+vH/M9QH+X6g39Dw/mRUvwK8j+P8oM/luJXkP95+HsP/mdffkJ/ + ztH/LMTj94Mn/zOXj/nb/8j/3DD/8/APH/zPgRco/5D/uRCP+b3D/WXe/9ww//PwJx/8z4HHfNe/ + +58b5n8e/vOD/7kyL7bfPOV/9rxufXX8lctX0lfd/jecHz1PGvMJyg/6UvzqH/mfkef6/zfkf27/ + gfzP1H//zv/M5S99B3/wP3fiBdv7u/+5mf/5y5988D/78d99v/+X/3nweH9KOD9Sil+pxa9GPmT2 + bzxPuHz4fv91O3P51H8F45Pb/ww8zb+C8ef3PXF9KL4hn76LD+1Vbu+KT77jwx/5nwe/4pOT59+z + CLd3xSff8747nA/efnyG/M+DD+eDt18/Q/7n8mP+Z+D9/Av5nwd/yP/M9Vn6pp9z/ufKvAB/yP98 + Eb/0fc8Hb+6/3v/cMP/z5Nm/cSu3d+k7+EP+50780nfy7D+h+BXkf37be/I/+/dj+Z8HH/IDX358 + hvzP+cfyPwNP+lr+51H+wf98EY/6/uF/bpj/+X0/V2I/IcWvIP/zKP/zt5tf91Kuz9J38Af/c2Me + 2/u7/7lh/ufJC9dHuP6obw/6UvxKutO3h/7b/fgsdn+Zjr/S/uh50piH33MP+na/vhK7v2zyrG/3 + +yPpTt/O6yuh+JV0139X/Ap45fZi/+0a/NvK7xP1PfmfO/FL3zz+Gvzkwu8H7qeTVrn+zc+/0tz4 + fPA/k752f9nkg7/axyel4fn+9j8DT+Nzw/NBWd/vQ/39/Lv9zzM/fAv6tsT1gfNBaSE/cEtcvtp6 + Y/ufgafxuW19J6/MC79PWF9t/zPUX7h8WF9JrdHP7H/Plv958Af/sxKP+dvD/WVC8Sux/M+D/873 + gff7X6m4ft7+Z+QL89jeoG+l+bfi+nnnf0Y+Eb/Wz8OfHPITOv9zw/zPo/yD//kmHvWtHN+QKtxe + zN8e4ldSSN+C+yMJ8avnyU085m8P8Suh+BXkf55+5li+Er/0nTz5W7z/uZn/+eMTj58lcXshv9n2 + P1fjaXy2+NXkU+A78+A3W9/vo5+5EQ/7Xwn3l72OaObF+D/8z838zx/P579C/itx+Se3/9namwuX + v/RF/zOUn2/iMT9/5vxIkklfi1+97zPkn3yecPmob8g/+fBcPvbfkH9SMq2vLH41eWFemBf4PQf/ + 1fNEmYffc+LzheeJ/30mNz6noG8ifV3+ye1/Bp76b8L97/Y/Q31I34T7Xwn5J58nXB+cf0P+SZ// + uZn/ec7vIf+kz//czP+8eNY3KbcX9r8S/Ffe/9zM/zzXS8F/JUm4vbi+Uj7fF/JfifmvBh/0VVpf + qdv/atBXC5cP/rrtfwY+c/m5IS+BV+Zh/bziV8BT/1W3fl7xK+CV64Pr5xW/Qj4zD/uFFb8Cnvqv + +a/kx/zPyFfmxXgJ47NQ/7X41eCDvkLz74pftenvDfoK9d8Vv/r4zL83ofnX4lejPkFf8l+Jxa8G + H9ZXQvvfFb/66hP2R5K4fMX2Bn3Jf7X9z835n4EnfeXTd/GhvaSvfPq2mU/44H+G/lXN/9z+I/7n + av7n9k//c2H+a+/0P9N+8HlyEZ8blJ+Vy8f5t5r/edxHn8L5kfc/V/M/L16Yx/Pfav7n733+7n+u + 5n/+yufzweS+P6rmf/7ay/HJ5Obfav7n+T5T0Nf5n6v5n2f54f7Q58lNPOobzo+Sm3+r+Z+/+vD+ + 1+d/ruZ/Xjy31/mfq/mfPz7o6+bfav7nj+f4pPc/V/M/f+3l/a/P/1zN//zxv+d/ruZ/bi7/M/CS + mYffswZ9tfr669Z3+plj/udE/NIX/c/Al8DD7zncH/o8uYnPDXnuX0r9V13/1aCvu3+hmv/543l8 + Tu7+0Gr+58Xz9xHO/1zN/zz7e/j+6OG5fJh/U7h/wfufK/qfXz58f5Tc+VFF//Pg+f5Qn/+5ov95 + 8qyXlMZ8Aj58n+K+P6rof568MJ8Dj+1NF/M0PgvGn1OYf5Obfyvmf548nS8kd35UMf/z4MP47Obf + ivmfJ18Dz+XD9ylH/7Prv2rnR5On+e59QjycL2z/M/AlM5+Az+xfuv34rDd+n7L9z8gX5gX4xH7g + 24/PaudH088c/N7K70cv5EP9ff9VOz/q46/C70e4fPg+ZfufoXzh9mJ+75P/2bf3wv2vXrx+9v7n + weP9zhevn58nXD7e/3vx+lld/pzBQ/xq+5+RF+bhvPvi/dHzpBIP3w9u/7O9/0u5vRC/2v5nKF+5 + fIhf6RXyT16+/77/AP/GJaF80vfC+JX2Sv3d53+u6H8efPDXufzPFf3Pk+f+2/38C/7nwQf/ZC9c + Pn6/0IO+3a+vwP88+ODP6dR/O8avNJwfef9zRf/z5Nkv15XLR307z78+/3NF//PkQ/2F3w/q2yrF + 87WRvnZ/aBl/ZX9gK8zD/ZLb/4x8Yj4hz+N/I30tf87MFy30floOvAAf9G1+/lXLnzP50N7E5S99 + Rz5q5f7S/Pyrbes7/OfBP9lIXzs/mrwEnuuD/vbK9w+qOz+q6H+W96+h/1Yan83/PHnWt5K+Ln/O + 9j8jr8Tj9wvh/Oh5wvXH7xdC/hx150fV/M9T35A/5+GF+KXv5NmfU5XbC/nr/vI/V/M/Lz6016+v + 1M6PXr/Qyf/s21ucfzLcH6qF+m9x/ffkf87MQ//9I/9zNf/z4rm9JSvzYuPPKf9zIR6/Lzvlf+b6 + K8xHp/zPiXkYn0/+Z24vnC9oCfoW4frD+YKG+JVmH9/Q7NZXIX6lFL/S7NZXIX7l/c/V/M+X8z8D + 7+NX4H+ePLeX4lfgfx586L/u/Kia/7k7/zPwyrxeyIfyaX3l7i87+p+5fPj+9+h/VubF+JP/2evr + 7i87+Z9pfE7OP/lH/udq/ueP/93/XM3/vHhub8qBx/b+7n+u5n/++NB/E/Vf9/3+9j8Dr4158E+m + 0H+TMI/+yRT6bxJuL/gnX7cz8RS/Und+tPM/Iy/E4/433B+qFL9SRX+dhviVaub6gP9KQ/xKlcZn + d36kyuf7z5NKPMQ3/vI/V/M/L55/zxS/Ujs/Gnzov0r6KsY3NOTPUYpfqcWvRv7k0H+F+q/s+CT6 + n5EX4uH86Oh/Tswn4EP/FR+f3P7nNv3Vof+6+8smL8Af/M8X8cni7e+4zrwyrxfyob20fhaMPx/9 + z414OF9QCd8fifD7h/jz9j/b+dft9d3+5+byPyOfiYfzBQnxK+9/ruZ//viQP/b24/P2P7eZzzmc + D9458F97h387nP/efv7d/ueP5/HZ+5+r+Z8Xz/46il9t/3Obfu/of1au/9J38sK8cH2Wvi9/1eC/ + 9ePz9j/P+p/yPzNfLuS5vRS/2v7nxbN/jOJX2//88Qf/szAP+l4hP+GVuHw4Pzrlf06JeNT35H8O + fILyf/c/V/M/L17o90bxq+1/bv/M/+z5vvUdfOi/3e+PpG99J8/9txcuH84H32zPgRfiYXyWnvn3 + 0DOXv/Qd+ZbD9ws9MY/n+z3oS/Er6Vvfycf8z5l5O0+REL8Sil9Jd/6NU/7nyrzNvzv/M+Qr9vEr + 8D9PPvh1qf+a/zmNv+bAJ+bBn7PiVzZ+Nuq/Dc8Xnr/S9/jSMpd/8j8DT/qe/c/IZ+LV9gt/+Z8r + +p9H+TH/sz//3f7nxfPvpwnXB/ZHUnl9JdWfL2z/8+Iz/R4q9d/q/HW1hPzSPr4B/ufhH87BX+3j + G+B/TuOv/D4pfgX+58Ef8j9fxKN/8pD/WZnXC3keryh+Bf7nwfP5glTS1+JXkxfmhcuH70NftzPx + hfpvcf7YEL+S4s/3wf88eda30Pxr8au3P57yP1/EL30nL1w+zb8ufnXM/9yIh/jV9j9DfZTro9je + 3/M/V/Q/Tz/zr/mfK/qfh15hfUXxK/A/v3z4fv954vW1+NXgw/ybaXy2+NXkc+A78wf/M/DUf9n/ + zO3NND5nPD+S4L8S8l+B/3nwYf2clduL+mbl/kLxK/A/lx/zP0P9qf+a//ldn4T4lc//XNH/PPy6 + h/zPXl/3/b4E/5VQ/EoSxp+3/xn5ynwCPuhL8Stx3+8f8z9z+XC/8zH/M/PYf1O4X4P8V9v//JUf + +m+i8dl9vy/BfyUUvxL7fn/6pUN7qf/a9/vT/8ztVZp/Fc8HJdxf5v3P1fzP8/d8yv+cmYf+e8r/ + zPXB/vtH/ueK+Z/f8eSU//kmHvMDh/iVkP9K3Pf72/9sv0+KX4n7fl+U45Pivt+vmP958hJ4Zd7i + 7dv/bLyQvoLnCyf/s49fibj11cn/XJjHfMih/0rm+kD+yaP/meuz1s+DZ3+OCOkrGH/e/mf0M1/E + q8Wfn7/yel5ofJa9fp7lh/oLl3/K/4w8t/eU/9n8ZhnjGwXzP9cf8z9X4BPx8H1oCt8f+fzPBfM/ + Dz7kF3XnRyXmfy6BF+YF+JBfNGN8o2D+58lL4Ln+S9/h3w75Rd38WzD/8yg/5Ad23x+Vf+V/bsAr + 87L3m8f8z758Oz9KP8f8z1WIh/3vMf9zZh78hGv+RZ7Lh+/3t/8Z+MzlQ36G7X8GPlXi0T+Zvu/3 + MZ/zTbxe8D41lK+JectH8bqdSd8k/P7h/Oiv/M8F8z+/vNaQ35j6r50fjfzJMf9zYb5cyPPvWUlf + Oz+a+ZxZX5c/p8T8z5XLz4l5GK809F83/5aQ/zn0X01KPMQ3dv5nGw9VuT6Y31tD/3Xzb0H/8+Qz + l4/rq2L+5y+/8bf/BT8w6evm3xTmX5//ucT8z6H80pl3+Z9D+fkm3ud/ToHPzGN7D/mfC/Eu/7Py + eCU0Pq/51+d/hvpoYz5B+cL5vV3+nIL5nyefA8/tRf/GOj+yfJJ3de//H/mfkRfiT/mfgffzL+d/ + 5vz8ehcu3+d/pvf5PmHe9gtvtmfm00U85jdb94f+w/9cMP/zyM/M6yu9vb7q7g99/hryXQu/f8xf + dwd/7O37L+R/nv5nbu/l+69ezl938D/XTDz6666g71UCD/66K/Pvx50fDR7zT/7hf568AH/wP9/E + r/yi6H+G+iQuX13+55DPWbm9mF/0kP9ZuXzML3rx/Ps84fIxv2ivId9y9b+HvvWdfua5v2jG+/F5 + +59v53+G8guXj/d395C/vfv5d/uf5/3jp/zPyrwAz/drPE+4/KXv23//yP9czP+8+NBe7cx/7X37 + ew/6duH6LH0nL/z+RZgXq0/j9bM20tfyP08+BT4Tv/R969N4/azNz79q+Z9H+bkz7+dftfzPo3xe + Pz9PlHkBPuT3bonLX/oOPujbqP+2re/wSx/yP/P7XPoOXhrXX/j9oL6n/M9cH4H2nvI/+/aa/3ny + XL7LnzP4Au2tof9Wmn/N/zx4Xj/7/M+DX/pOvgZemP/ai/5n4BO3d+k7eF5fPXwmfuk7+cw89V/L + /zz856H/VuH6LH1H+UFfd35UVghl8SXoW6j/Wv7n932WsL4qND4Xp28J+haafy3/8/BXh/ztLn9O + Mf/z7fzPNp+WzPXH8bmE+bf4/e/2P3/lc/zK538ua0o1ntc/Rbk+cL/k9j8jL8RLQz60l/qv3Xf5 + znfhe/PnSWYe5sfwvfnzpBOP64HM8dLnSWEe1j/he3OleIvafZeDD37ORL+35NZ7J79uZx7We+G8 + 43nCPOajXvEW5CvzYuvhk1+XefyeInxvronmCzvvQL8u8KRvcuv5Q75i4fcP51l/+XUL5it++fC9 + +fPEj1fqvqc4+HVJXzvvmDz/nl2+4oL5igf/u1+3YL7iyXN7leYLO+8YfNCX4i2Qr3j4mTW0V7k+ + eiEf2uvjpZCvePifQ/9V4fez9J18aK9we/F7t3DeoUL7cXH7calcPsVbtl/344O+QvOFoJ9Ew3mH + Sub64PcU4bzjeaLMC/BhvqB4i7p4y/v/uT4+Xrr9uovn+UJIX3HfU4TvzZ8n3F78HjmcdzxPEvPy + s+J7Er43937dgvmK0a+LvBAP8dKjX7czD/kwl18X/beNeMyHefLrJuYF+OA3uBOXj/m4wvfmQvEW + cd+by4q3IM/1UWxvyOdzqxIP8XAJ8ZbnSeDF+CucV15+fIZ8xejXtfIv338hXzH6dZHvzEP+sSuc + V15+vQf5itGvC+X78RnyFU+/Lv+eKd4C+Yqn/za016/nIV/x8D+HfE2X77+Qr3jwQd/Lj8+Qrzj/ + mF8XeX4/cJ519Ov69lq+4sFzPpCHz8RjvrUe9O1+vyaWr3jwnC/C+3UHj37OzvPv+4R5AT6xn6f7 + 8Vm607cnfp8Ub5G+9R1+46AvxVuku/7beXx+nvD7l4Z8qL/w+8TxuQV9m18/g1938MEvRPEW8OtO + nv1gFG8Bv+7rBzjlK76IR79By+wPaaSvfW8+/MaHfMWFePSThO/NvV+3mF93+ltayCffaHxuuL76 + y69bMF/x5Pn33CTwtr46+nX976c6P+fy66L/9iJ+ra/Kj/l1wV/q18/g163jr+y3r5nLh/XzMV9x + ZV6AT8EfS/qaX3f4k0M++ar8fpa+w5988Otye5e+o/zQf6swD+cdR7+uMC9Wn8L5IoTiLVLwvGP7 + dW38cd+bF/PrLp7bW6j/Ftz/PotrHv8Lra/cfVsSvjd/nmTmBfjE65+SuL1wn5qEeIuUxOWv+Mbk + Q3up/1q8ZfpvQ/lyEb/iG9PfK4GvzIvxmc+j3yeOt/u2hr805ium/pvxvGP7dZHvzCco/+DX5fLh + vEPC9+ZCfqHt172dXxfqk7g+S9/JB78x6Wvxq+m/ZX0pfiUWvxp86L9ZuL2ob4hfeb9uMb/u5FPY + HyXqvwnPs/7y6xbz6y4++nU78/B7Pvh1M/NwH6KE+NXzRJmH/hviV88Trj+cV+58xfB+lPml7+T5 + +xryC22/7hyv/shXXNCvO/I/H/IVBx7GZw36UvwK/LqDD/pS/Ar8upPn9aT680rw677zi4Z88uQX + Ar/uKD/oq6SvYnxSQvxKKH4Fft3J8/ijyjzOv6d8xdxeyOcjp3zFnfjVf2X8lb8Xo/jV9uvO39sp + X7Gvj2D8eft10d+biS8wH4XvzX2+4mJ+3cXzekZIX3Hjc/jeXMgvtP26H594fqf41fbrjvOX56/C + 74f674pf3Z9fl/wwIsr1Wf13+nXJT+jzFRfz694uXzHylXnZ/Pbrov8W+Gx+3Y//PV9xNr/uPfPx + hnynzq+bza/78SGfrbvvMptf9/7yFUvghXnZeqWQ7+V50oiH86wU8r34fMXZ/Lr39NMe8hXz+4Hz + o1O+YuH6wPz7/JX9fm7+zebXnfU55Sv29U+4vjrmK76ILxfyOfCVefMbpDD/+nzF2fy6X/kh32ki + fRP23+3XBT5xexO2V0N7lXmYf3e+YihfE/M2/+58xcALtxfm3+3XRV6Zt/l35ytGv64v382/f/l1 + s/l1L5evGPnEvJ2Xbb8u+m9v4iGf3s5XjP5eYV6AD35sTZ34Nf8OP7Cyn9P5dbP5dRc/29uNV27v + mn8nz35vl684m1/3q3/w26sE3tYbO18x+FFx/s3o1518DnwiHva/rzuX+RL4ZL9/YT+Jz1ecza+7 + eG6vy/eSza97u3zF6L9txKcCvN6BV+Kx/67zI+BpfLb5d/DsF/L5irP5dRfP/cXNv9n8utMPcPLr + uvK3X3ee7x/8ur7/br/u4qP/NjEP/sY7+Elu33+3X3fx7M+5ff/dft2PD36hO3H5eF/8zf3X+3UH + D/ENXfddIs/tRf/G8ut246UTj36Sdd8l8sq87PnuzU5M/OX7r17O77fOj4AnfS/n97u++Rf5xDz4 + hdb5EfJKPPr9rsztvXJmXvZ6TFe+F+BJ38v5wa6grzs/mourC3nW150fTT4BL6F833/ff9j6+c1O + HHjWa+ibZPSv5dcF/2f1en3nRw8//L2h//bC/NB389Gv25lPUJ/Qf3tmfui7yj/kK1bmBfhwvu/u + u8zbr7v56L/l9urX3uE35v2Rdj8+L7/uww9/b/Tr+vl3+XU3L8xL4L/2vv29BT928+vn5dfdfPCj + +v3R8usuPuQbb9R/29Z38F/8Gcr38+/y637tXX5d4DPXZ+k7+INftxC/9J18KN/Pv8uvu3jNzFP/ + bU7fxuvnh+f2or6N18/er5u3X/d7nye/rm9vdfrW0H8r6VudvrVw/d35Ud5+3a/+NfRfd36Ut193 + 88EP7NdXy6/78MNvHPpvpfG5bn0HrxQP8fmK8/brbp5/z1W5PkvfyfP3OM6vm7df9+H/la+4Mi/G + n/IVe75sfYe/N/jr3PnR4Au095SvmMtHfQv7c54nXD7qW0L/LaRvcf335NctxCf4PR/8uonL1wv5 + 0F4NPIxXB7+uXMQvffP4K/ffQv23bH2Hn7Zy/TONz3nrO/Ibh++hchXil76Tr8zT+Jzd/Bvuu9Sc + uT5LXxl/5fZmmn/z1nfwwT+ZSd+89R08xzc00/rK4lczXzH336zcXvTb56Cvy/cyeFxfnfzPXB/0 + 2/+Rrzij/3nmHw5+YL//Bf/z8PeG/uu+N8/of8Z8xehnbsTj9xR/+J+z+Z8/nuPPPl9xNv/z7fzP + yCvxCvuFU75iLl8tXveX/zmb/3nuj/7wP2fzP8/91x/+52z+57m/C/dtPU+Yh/MFDfle1J0fZfM/ + 31/+YW6v0vpZt77yc/Y/c/kQ39CQ70XVxzfA//z2lz/yFWf0P18/f+Yrzuh/nrwwL1w+fq96ylfM + 7YX41TFfsW+vxa9GvtxyM0/7I/M/T57bS/Er8D+/v/9DvmJaP4vzt6/4lRqfAy/Af98jA0/9VzA+ + +f5/5pXbqxfyOfDcXvx+YcWvkFfiIT65/c/wfiTwsvntf7bztdvvf8W+N59+Zs5fdPvxWW78fmH7 + ny2/0+33v3KjvnJ/+yPg/fgst/Nf3ayv9z9n8z9/fAr1T1wf+D5l+5+hfD8+i31vPvnQXr//Ffe9 + +fY/Ay/8/kHfna8YeWEe2rv8z8ZfpK/dt4X+Z+SVeMy3dgV9KX4ll/PXrfgV8H59JXbf1uTZ73f5 + /iuX0/fi8VkofiV23xb6n6E+yu9Hsb3K+SEvP/9u//P1H8lXnM3/PPW9uP++T5iH/ttD/+1+fSXd + 9d8e+m/362fprv/2oC/Fr6Tj+ZF0Hp+F4lfS8fxo+5+RV+axvb/nKx489t8/8hUPHvtv5/n3fcI8 + tldC+aRvd/7JHvTtfv0sHc8Hj/5n397m/JONvz96nxAP5wvSgn+D4lfScH118j8XLh/9kyf/M9cf + /VctjM8Uv5Lm/JMt6NsS10cv5EN7tTFv5wvSgr7Nz79i35tP/3Nor3B94HzhdTsTT/Ercd+bSw39 + t/r1lVQ8X5Aa9K0+viEVzxck3Lfl8xVn8z8vnn+flcbnivujna8Y/c+deNgfSYhf+XzF2fzPi4/+ + Z24v5BM4+Z+V6y/Y3tB/KX4l9r35y5cwPhe/fgb/8+S5/xbS131vfvQ/V+ahvYXvE5fiz4/A/3z9 + /JmvOKP/efCJ1xslcXvh/OivfMUZ/c+j/mF9VWh9VZy+Jayvio9Pgv958jXwXD74r3a+YuMz9V/n + v3r+qsz7/a9Y/ErGX7m9mfQ1/9UoP6yfM/Vf819NXgIvzGN7g76Z+q/5rwYf9M0+Pgn+58lX+r1R + /Gr5n9f7Cesr8l8t//PmuX+R/2r5n2c8UIL/Ssh/tfzPiw/jM/mvlv/5q0/4ft/7n/P2Py8+zL8p + c/mo7ylfcWYe9D3lK+bysf+G7/e9/zmj/7n/nPMVc3shn88pXzHNvxa/qj/nfMXCvNh8vfIlGq+0 + P1L018kf+Yqz+Z9vl68Y+cQ8rDdO+Yob8UvfyXN7yX8liv6No/+5EI/rq/D9/uuIJh7XVyF+JRS/ + 2v7njw/3BahweyH/hpzyFXN7wZ8jwvdNC/mvwP/8/n5W/Ar8vaSv+a8mT34zER9/Bv/z5Of4fxlP + +19x8++KX0H5FN8Qt75a3+8D78/3wf88yk+hfIpvyNZ3+JO1cP2Vy8fxecWvoHzl8nF8XvEr4IXb + K9be7X82v587P0rofx78wf+ciIf1cwr3XXr/c0L/8/AbB3+sm38T+p+H3zj4Y938m9D/PPzDwR/r + zo8S+p9fP9uaf5HPxOuFPPtj3fyb0P8sP+Z/Rl6JR39smH+9/zmZ//nz0x78z93xyfknE58PpkT6 + JuePXfMv8CXwCXg+H3x4JR7uI07h/Mj7n5P5n6e/9OR/rsSjPzZ8f5QS6Wv5cyb/q/85mf/54w/+ + 54t4yJ/zup0Dz/WH+FUK50fPE88rni+k8P2R9z8n9D8Pf2/ovy5fcUL/8+BD/1Xqvy5/zvY/F+AT + 8wI8z79JE7f35H8GXrm9avHJFL4/ep5wezUhz3q5+Teh/3nUJ/Rfd36U0P/88uH7ozeDseMF45On + fMVViYf4cwr5c7z/OZn/eXwPvv3PwJO+dn40eW6vZK4/5LNNwvkZkrvvMmG+4sGH/uvyFSfMVzx5 + 1ldIXzs/GnzovyLcXsH2hu8XhPSVre/w07K+6vLnpB/IV/yeR9/lZt73X3XnRztfMfKdeTgfDPlz + vP958Hg+eOdQ/5yZt/FK79SZT1wf+H7w+Wuov3J7l773+GsOPJcP86+G/Dne/zx4+H7w+Wso38+/ + 4H8e+XU5n/zzxP3+9XLn+1dlP9hF+l64PzrmK27MJ+Q5n+1F+l64vnr+GsrPhXmLx+58xcAn5jFf + 4ilfcSZeL+T593Aptxf2vxry5zxPOvEQn9z+Z+S5PrB+1h76byd9O66fd75i4MtNPHw/qOG+y+dJ + Zh78OT303+7HZ8hXPHkJPNcf853+4X9OmK948Dw+P0+4vYrt5fxX2v36CvIVv/29S3ifKsSj/6oH + fbsfn8H//Pb3cH70PPG/H/M/Dz746xr1Xzs/un/O/ufGPLS3BX1d/pyE+Yonz/o2v36GfMWDD/66 + lrg+EJ/c+YqRV+IV26uhfD//gv95vM+Qv67JTTzq28J9082vn8H//JYf8uc8T3x7K8aft/8Z/LfU + f6vTt4b+W0thHvQN50c+X3HCfMWTl8Ar89B/K6+vnidcvstXnNhfVGl85nzFgVcuX2G8CudHWoV5 + acgLl0/6Vjc+/+F/Ttv/rD5fcQI+E4/fHxWOPz9PCvPgJywcn3yedOJP+YqRT8zD/Bvuu/T+57T9 + z996YJ0fIc/t1Qv50F7l+kN8UsN9l1pIXzs/0h/zPyPP9V/6vv033HepmdbPGc/3t/8Z+Uw85N/Q + 8P2+UvxKM8Y3NHy///BKPPg3NHy/rxS/0uzWzyf/cyUe8wOf/M9cf4hv/JX/efK2/9VwfqSZ9LX4 + 1eRDe4X1Wvuj4b89+J99e5PbHx38zzT/uvsuj/mfE/PQ3nB+pBS/UnffpYbzI+9/nrzYfjCcH6n7 + fn/wcJ/pKf+zMr/0nXxor3J7l75v//3D/zzgpe/kQ3tp/Wzxq5c/+Z+9Xha/Gv7k6H+m/mvxK/k5 + +58T8wn43/3PCfM/T57bqzT/2n1bw8/8u/85mf+5f/7k0N7E7dUL+dBercwn4IO+qlx/zA/8h/85 + mf+5/9P/7N/nil/16e8N+gr13xW/Wjz/fqRU5hPwh/zPjXjID6whfqUUv9r+55EvdOd/Bj4xv/R9 + +7uE8Vlo/Sxb3zx41leU3+fSd/BBX1Euf+mbBs/6CvVf2fq+54Mn/7P7PUD+58FH/7PXF/I/64/5 + n5HPzCfgw/nvnbn8pa/8mP8Zea7/0nfw4Xz/TsxPfds477u5/wrFr7b/efHsR7p9/93+548P5/u3 + 13f7nxc/24v+Z67/1LeN882T/9nzK37Vpv/24H8W4suFPJ/vXz4+uf3PH3/wPzfic0Oe23tlrk/+ + 2vsv/zO3d+k7/czsr7tI32vrO3n2D1x+fbX9z835n4EXLn/pO3kJPLd36TvyG4f8Zt2Pz9K3voMP + +c26P1+QvvWdPPff7uMb0re+rz/k5H9mfumbx1+5/3bSt299Bx/8Gz1xe5e+g+fx2fufB7/0nTzF + S4XiV2sUXXzIT9iFyxdsL8evfP7nyYu9z1Y5X3Tz6+ftf556HfI/+/jG9j/P31vj+IZQ/Gr7n2d/ + POV/Zh77b8uc747iV9v/PMerP/I/J/M/L57zATr/czL/88eH8bmRvm3rO/jQf5uPP2//8+K5/zY/ + /27/8+Qrr599/udk/uf5PkP86uGFeByfQ/zqeZKZB31ryA9c/f5o+58Xz+2tmeuz9P2X/7kRn7C9 + of9W6r916/sv/zO3V7G9EvJjC9cH9a0S8lH7+NX2P7cv/zP7OYvfH23/c3f5n5FX4tf6avLc3uLX + z9v/vHjl8qn/lr2+wvzPyHP5a3018z8HfzX137LXz+96MsSvvP85mf958ZnbS/13xa/6l8+Zfz9F + +X2u9fPkQ3uF64/r5xC/8vmfk/mf5/sJ/iuf/zlZ/ufFs76Z1lfZrZ9zDn7jIsTDfeIS4ldC8Sux + ++IHH9ZX5L/a/ufFc3/Jyu2F/dHzV+6PWbm9S993fvwj/3Oy/M/d5X+G+gu3F+/XCPGr54kv390X + f/I/+/iGuPvit//Z9ErUf+2++FGfsH5OpK/dFz95YT4HHvRd8SvgE7c3we95xa+QV+L1Qj60l/pv + 2vrKz9H/TOOz3Rc/ee4vFL/a/ufJa1hfKe2P1I3PGr5PIf+VqOu/f+R/TuZ//njOnyPkvxJ147Py + +b73PyfzP388n+8/T7j+CdurlH9MlPRd8avm8j9D+aTvil/N+TfcFy8Uv9r+57leXfEr4IXfp8B+ + cN0XD35mGp9lr68Gz/mRRLx/cvufm/M/g7+6cPlrfTX4cL+VeP/G9j+3L/8z7xeE4huy11ejfL6P + WITWV+L2v6LB703rZ9n6Tj60V7l8xfaG8VlofJat72hvWD+L8PsX2w9u/zP4b7H/qvmf2zu+nfzP + 2H/V/M9t+oEL+9kyrp/V/M+rfOH6YP9V8z9/9Q/+uozrKzX/88fz/SnJnR+p+Z+/+vD6+eGF+KXv + 5Gm+e55w/dX2+ymcH/n8z2r+56/+wv7PjPqq+Z+by/9s5bv7Q9X8z7P8P/I/q/mfZ3vD+VFKpG/a + +o78yYf8z534pa/8nP3PiXkBPoXyE7d36Tv4oK/7/kjN/1ynn5z77/OkMp+A5/77PLmJn/rW6fc+ + 5H8W5mXy6H8G/2315a/5t35+ZvaLuvw5av7n6vzPyFfmv/YOP3Dwt7v7Q9X8z3X8Pk/+58y8AJ9C + +YnLTwX4oK8q80vf/GP+Z+S5PkvfwcvNPPVf3fpOnn/PSvrq1vflhe/HSUL9V7a+w39bc+CV+KXv + +3uTEvzMJTGfgA/6uvlXzf88f5/h/tDk7g9V8z/P31u4PzQJjc+y9Z18aC+Nz+L677p/Af3PXL7C + fCQSeLmIx/FZ2B+bXP4cNf9z+6f/2b3P7X9uM79x8Nfdfnze/uc6/cDBH3t7fbf/uU6/8SH/cyce + 9NV1foS8MC/Ap8p84vYufaf/OZSv3N41/8r4K/snnf9Zzf/8vc/gn7yV67/0nbwwL4V5MT7cH/o8 + cf1XL6dvuD9UL99/9cL1lYb7Q33+58kn5IO/2vdfvXB99fw18pl5AT74Yy/ff/XC8wUN94c+T7g+ + eiEf2qvcXjhfeP4a6i+deNgfPX/l388l/P6Xvuh/hnzCfv2sHfdHz1/Zf95rIh7iz2+2Z6pP9/Ov + 2vnR8Pce/M838UvfyQv9Pjv1Xzs/Gvzv/mc1//PY/z5/5fffE7cX4hvaef71/mc1//NXfvBPdtK3 + Y3xj539GnsuH+PNf/mf90YbnCxrOj7z/efBwfvS6nQPfmE9QfvDntMz1yfB7bhyf9P7nydv+V1uq + zCeuD+x/T/5n6r92fjR59sM00tfOj0b9D/5nrg/233B+pO78aPIW33jdzsRX0tedH538z1WIx/5b + g76Vxufq+u/B/1yUePBvHP3PlXkBPvhz3P2hav7nrz5B30r61t1/R/mh/1bl9mL/Xf5nGx8q6Wvn + R6M+Yf6twu8f+28J66tC+rrzIw33h2qh/uvOj95sz4Hn8iE+ecz/3IhHfUuYf4vf/6o7P/or/7Oa + //njg77O/6zmf14861uU64P6FumBV+KlQfmh/xbh+gi09w//s5r/ubv8z+DvpfWVOz/ScH7k/c9q + /ufu8j8DT/pmp2+IXz1PuP7Yf0/+54t47L9/+J/V/M9t+reDvpnWzxnjzxrOj54nN/Gr/04+tJf6 + b3brq/D9vibaHyW3vjrlf1biIf589D9X5i1ed/I/Z64Prp9P/ufMvADP+euU4ldq8atRH408l68W + r/vL/zx52C/84X/WZflY+68/8j/rCnGv/any/c7e/6zv/1WL1x39z0o87n//8D9PPgF/8D/fxK/9 + 7+RZX6X1lcWvht/4d//z4HH/e/I/c/1XfKMPnvuvKpe/4ldvfzn4n4X5Fb+aPOurwvVZ+g7/cOi/ + 7vzo4S1+NfzDYXwWmn8tfjX54Gem+dfiVyO/8cH/zDzGN07+58I8tvfgf2Ye4lcqYXym+NX2Py+e + +4uQvrL1Hf7zMD6LMA/xZw3nRyqkr2x9Xz/PXdmPQfGr7X/++ODfoPiV3Bif3P5n5Dvzpu/R/8x8 + tt/z0f+cmJf9e/vL/6zmfx7x2JP/OSnxS9/JB7+3jz9v//PHR/+z8Ptf+g7/efBv3ML1Wfq+590h + fuX9z2r+58WzXlfNxC99Bx/8sVfh8pe+k2f/FcWvtv95tvcK+l5+f7T9zx+fgn87cX2Wvq8/5Ar6 + Xj4+uf3Piw/+ar++2v7nqe8h/7OPT27/8+KDXr7/bv/z/P33oC/Fr6Tj+dHJ/0z9t+P5kYTv96X7 + 80HpW9/JC/N+/Szd9d8Qv3qeJOah//7hfx489t8e/Fddub3YfzvHJ58nXP+l7/t7C/Er738ePPbf + Hvw53a+vpG99p/85+G99/Hn7n+u//M9+fbX9z4uP/ufMfAI+sz+t+fPB7X+e+ragb8tcH5h/pfH3 + 3W9GaOKXvsNfzfOvtMTlw/rq6H8uzMN8dPI/8/uH+Vda8Mc24fJh/fwspoL/lvpvxfXz89cc+Ew8 + nC9IuL9MKH4F/ufBB38Oxa/A/5x+zv5nrs/aHw3+4H/m9oJ/4y//s6L/efKhfH8+CP7nPP4a/cyN + ePTnVOHfZxV+n/h9Sgnrq0L6FoxPSohfSfHn+9v/PP1aJfivCulbtr6T5+8FCulbnL/9j/zPav7n + j2d/jlD8avuf25cvOvi3E9dHLV4nRXk+LbS+svjV8EuH+beQvi5+dfQ/c33+8j/78rPzx4b7y4T8 + V+B/njzrm2n9nJ0/NsSvnifMoz/2D/+zov958GF8pvgV+J8Hr6G9yrxie8P8S/Er8D8Pv/fv/mdF + //PkQ3tJX/M/v7+3xPFn739W9D9Pnsfn5M8HxeJX7+8/8fm+pBJ48IsmPt+XROurhOdH2/+MvDAP + 49XyP5vfNdH6KuH57/Y/I8/1V5iPVvwK6qNcf/Bfbf8z8MI8zr8rfoV8Zh7WG8t/ZflmlcZndesr + /fZHyGfiC6w3NOirJfCwvlrxq8t42h+pW19pDvWn/ZGif0OW/wp40tfFr+Tgf6b+6+JXsuJXUL7y + +4T4hqz4FZQvXD7qu+JXyHP5qG+IX70ZoR3v4lcS4ldvRmjiC+wXwv1lz5PCvPnNtv8Z+MzlL30n + L1wf6r+C/rrtfwY+cfm4fpYw/wrpa/Gr68fyP0P9aXwW139Feb8vwjzEn5+/8v0IQv1X9vpq+JP5 + /hTvfxb0P4/8zDw+J3f/gqD/eeQrLsEPjPOvmP+5f35p5fIz8zD/HvM/Z+ZtvfFX/mcx/3N3+Z8r + 8Eo8zL8ps//K538W8z9/PPff5wm3F/Iz7PzPUB/c/4r5n/v097I/J7n5V9D/PPy6Mf9zYR7O97f/ + uQFfmLf1cwrzb3Lzr6D/uf6Y/xn5yrydH6Uw//r8z4L+58krl58y8Wv+HX5ynn+9/1nM//z5q3n+ + TW7+FfQ/T7+0cP1JX3d+lNb5kfHO/yzmf579fZ0fVeAz8eiP1aCvOz8S9D9Pnt+nkr7q/LHr/AjK + z8K8xa92/mfLV+/OjwT9zzM/88XlU/+1+RfzPwNP+tr8O/jQf1W4PhCffP6auP7C9RFo77p/wcp3 + +XME/c/DD/zpa+UL9V9x/vZnOxr4yrzFc57FIL9PKUp8tvXG9j8DnwvzAnwK7U038fj9gnz9F3mu + D6yfkwR9Rbk+cP6b1vxrv2chfW3+Hbzw+OPyPwv6n9/z7jvkB759/wX/8/BL8/0aDy/E4/n+Xdif + efv+u/3P7csXzf7M28+/2//cnP85A8/1gfiG3uF80OV/FvM/L579P3fi8tXWGxry57xPmAd/ziH/ + s3L56J+8ef71+Z/F/M+Tv3j+fZ54fS/nv7r4+wW9SN/L+XOuwn7yy/dfvfb6avirg7/98uOzXnt9 + NflQf99/9drrq/f3eSX+fV6Jecx/tc6PmvHK72etryYf6q9c/6XvyBfN86/3Pw9+6Tv5HHh+n0vf + 6WfuxHe/vtr+5/7lc2Z/XSd9+9Z3+p+DH7hk5iG/WQ/n+5307VvfyQvXJyfmBeoT+m9P3N6l7+A5 + fvU6oolXbG/wt3ftzCfkg79auD5L3/H+f8//LOZ/vr78z+w/d/lzxPzPMz/hIf9zVeJXfsLJh/L9 + /mj7n2f+xpajv5rLX/kJJ8/6uvMjMf/zxwf/ZCN91/nRzFd5yv8sxOuFPPs3mp9/t//5+vzSyryf + f7f/+eMP/ufEvBgf8udo9fvf7X/++N/zPw8e84v+kf958tDeP/I/Dx7vX6g5lO/3R9v//PHBf1UT + 1wfvZ68c3/D+58EvfYffO/jrKvXfuvUdfPBfVWF+6Tv5UH+af+vWF/M/G19o/i1b37e9Jehb/Pp5 + +58Xz7+fQuursvUd9Qn6Fuq/xelbQv8ttL4qW1/M/4z+Z24v6lvC+srlzxHzP38873/VnR+J+Z8X + H+pP/bc4fdf5EfKFedA3fL+vFL/a/ufF8/ySaf61/M/DD/y7/1kw//PM5xz8wKTvOf8z+p+5Pj7/ + M+dvp/gV5H8e9U+Zeeq/lv95+qWj/5nbu/SdfKi/cntXfm/5Ofufuf5wf9lf/mcx//PiOf9/8vGN + 7X+e9fkj/7OY/3m+//D9vvc/i/mfF8/tpfiVuvvLjv7nQjzqe/I/C/F6Ic/6JuX2Ln0HH/yTSbl8 + 7L+n/M/KPLRXw/istL5SN/8e/M80Plv+5zL+GvzApK+69VW4v0wpfqXq1lca9FUff1a7v+zdT538 + zzfxCdaT4ft9VeX26oU893eKX23/88cHfZX6r91fJoMP7ZXAi/En/7N/n5b/+e2/B/8zjc+W/3ny + rK/Q+tnyPw8++NslX8Rn2C8In+8/TzLz8rP3IxL0Feq/svdH//A/0/gsP2t/NHke/0X5fSrsB0Vu + ro9w+Wt/NOp/yP/M71+svTv/M/qfXX0g//PkqfznSSZ+6Tv9z5z/kOJXkP955DeO/mc//0L+51H+ + wf8szAvwIT/h7fvv9j9/PI/PD8/1h/3v0f/cmU/AH/I/c/1B34cP5Uvgob1X8OdcPr4hF8Y3dv5n + 5IV41Pf64s+Y/7kwD/r+kf9ZzP+8eNb3ylwfyM9/zP9ciU8FeI1+6US8Xsgn5jXw2N7ofxZur2B7 + g74Uv9r+5zE+S698333362fpe/4dfNC3+/2v9D3/Tp7r3wuXD/cvSM8386Rv3/Ovjr8K1z9z+Wv+ + HXzQtycuH+bf56/8++l+/pUVv7qmPzn0X4pfSd/zL/qfkRfi1/w7+cLtJX0tfvX6H9b3+8Y30tfi + V4MP+dubX1+Jxa8mz79n9/2+mP958axXK0I83B8qLYf6+/iVNNz/Skv8Plvi9sL+d/ufkc/Ew/53 + +5+BJ30tfjX4oG8Tfp/SkM+B5/cD62cJ95f5/M9i/uePL9y/Kulbcf+78z8j35lPwIf+S/ErsfjV + 8G/nUH+/vhK7v+wdH1b8yn4PlcZnu79s8EHfqtxe/faDw78d9KX4ldj9ZYOXzvURbu/a/w5/dfBP + UvxK7P6y4b+twX9L86/dX/b2rxC/Eopfid1fNvngHyZ97f6ywYf1VcnMr/vLJs/vs/j9r9j9ZW9/ + D/eXPU+YX/oOPuhb/Pp5+5/v6ScP+haaf+3+ssEf/M9c/tJ38qxvIX3t/rKXP/mfffl2f9ngw/yb + Sd+89S0/5n9GvjGfgA/65szlw/2wf/mfxfzPH3/I/8ztRX3D9/uSaX2Vt76T5/GT4lfb//y9z6Av + +a8kO32z8H6E4lfb/3xPv/Eh/7Pn09Z3+I1/z/8s5n9efPBL0/4obX2n/5n3LxS/2v7ne/qBg74p + c/lwv6SE+8t8/mcx//PHh/5L8avtf14860Xxq+1//vjf8z+L+Z9v539GvjIP7Q3xK1Ean3XrO/3M + 3F6KX23/8+K5/1L8avuf78/PzO3VzOXD/ZIS4leitL7Sre/gw/dHSusr3foOPuirtL7Sre/kQ3s1 + 8NB/Vfj3rDQ+69Z3vJ+QH5jiV9v/fLv8z1a+UP8V13/D/WVC/qvtf75d/mf0SyfmYXwO3+8L+a+2 + //l2/meoD43PsvUdfOi/5L/a/ue5PpEwPotye5e+kw9+clpfydZ31Cf0X4pfbf/z4llf8l9t//Pt + 8j/v8p8nVv83mJNxffVH/ufJw/oqhfOjhOdHH5/2+0nh/Mjlf5780nf4kw/5nwvztn5OYf51/ufJ + w/p5+5+R5/qrnR+lzP3X+Z8/PgEf8gNj/ufJr/3R9WP+Z+Qr87Y/SuH8KOH8+/IJ90en/M8w/05+ + 7Y/Q/2ztxfzPH2/7wWP+50Y87H+P+Z+FeQE+cT5evD908rD/fd3OzCvzavvB56/hfWplPgEf8z/D + +cLkUd/E5/vPk8S82O9H+fvQpKSvzb9v/9Kgr1L/tfl38lPfAnxmHn7P4fzo4YV42P+mMP8m/P7o + 47G9of9qYn7pO/lQflLi1/j89nfVxu1Vfp8K49Uh/7Nye2F8ft3OzAvXB8fncH7k/M8vL258DudH + zv88edQ33L/g8j9/PLQ3zL/O/zz53JDPXD6Nz27+fX7sncun/iu4P0ph/k2izMP+KIXzo+cJtxfW + V0nYf+X8z5OH9VVa8y+0V4R5W1/9kf/5Pey4cf2s6/wIeK/v9j/P++KX/xn5zvzX3pkvOpSfuT5D + 3yTj/HSdHyEvzAvwif2Bd2rED30f/j0vXudH6E/m+gx9Nx/9zFz+0Pfhh/88+Otu4fcpX3uHn/yQ + /1mZ/9r76nsFfS8/Put3fvSVf8j/TPp+50eb5/Pfi/T9zo8WH/JPXn7+1WvrO/mY/7kyj+095H/m + +i99Jx/KJ32vrW8ffw319/1Xr63vNf7Kel3C9Zn66vSfB3/sJVz+1Hfy4f5Ql//55b/zo4cf+Y2/ + /ot+aSF+6qvj97z8z8D78Xn5nzcf8kuTvt/50eJD/vZO+n7nR4tPIR914vLT1963f538z5l4vZAP + 5Su3V7/2vv6WLpHn97n0rYPn3wP6nz9ejD/lf/a/n7b1HXzM/1wT8UvfybNfpZXC/Nfet7+04M/B + /DmTX/pOXgKvzAvwwd/eEtdn6Tt57r8tcflL37c/hvw5Lv/zxyfgY/5n5fKXvpNnfZsEXow/+Z/9 + +Fm3voP/Nf/z5Je+I1/xwf+cmE/AH/zPN/EZ2nvK/8zlZ2zvIf9zJT5he3n9/DxR4hXbe8j/3JgH + fWvQF/3Pk1/6Tv8zz9dV+P0vfaf/mf1ChdZXxel78D/7/e/yP6/yg3+ylMAn4KP/mcbn4vpvCfoW + Gp/L1neUH/QticvH/nvI/6z8fpa+6H9GnturMF6VoG8Rro9gew/5n4V5GK9y6L+Z9M1ufM7lDrwQ + j+Pz7/7nj0/A/5r/efK5Ic/tzaRv3vq+813m/ZHL/zz5pe/gg76YP2fyS9/Jh/ZqZz7ZfH3K/8zl + L30nH9or/D6Xvi9/8j/7+Shtfd/1SYhfKcWvlv/5W4+loC/mf/74ZOu9k/+5E58b8txeil8t//Oz + Xh3+7dB/KX61/M+LD/qmxO1d6+fJh/Zq4BPwv+Z/nvzaH02/dGivcHvX/ujlNehL8avlf/7W/+H+ + sodPxJcLeV5fKemre380+IP/+SZ+7Y/az9n/zPVf+g7/9sH/zHwqyPN8R/Gr5X9e/CH/c2ce9oMH + /7Nwe5e+w09+8D8L82L8yf/sy5et7+B/zf88+aXv5Lm9FL9a/udvv3/K/9yIX/pOntsrmctf+r7j + z+/+58ljfENC/xXl9i59dfw1tJf0la3v4A/5n/n9S0NeuP6kr2x9X//Pyf/s6i/31nfw4XyQ4ldy + b30nz+eDt9dX7q3v4MP54O3jk+LiVw/P+YXuHHhs76/5nycP+p78z8rthfjV0f/M7VVsb8hfd/vx + WW7U95j/uTIP7b3C+e9VPX85fQ/+Z9L3cvqe8j8n5r/2yo/5n629V+byl76T59/n5edfsfjV4MP5 + /kX6Wvxq8Nx/heJXYvGryfPv+fLz7/Y/387/XIwXLn/Fnycvgef3ueLPL98r51fs1H/7jj8PPuSf + 7IX5FX+efAp8Zh7aG+4ve3glHvXt/P2vdNK3u/57yv9ciE8F+ZD/OXH9sf+G+8uc//njE/CH/M83 + 8av/Tl4Cz+0Vm48kxK9c/uc5OFQYrw75n0nftvvv5Lm9zcefl/958UHflrk+uSHP7W2kb9v65p/h + dmae9G1b38FzfPLhE/FL38l35jXwaa9Ptv8ZeNK3/cD66s32HPjKvOz15/Y/G0/xq+V/nutbqaH/ + VtK3bn1H+aH/Uvxq+Z9X+SG/aCV969Z38iXwhXnbL2z/M9QnMb/0HXzQtyq3d+k7+VC+8vuE/ZGE + +8ueJzfxS9/Jc/7k6uOTUvF8Yfuf7fdcSN+C5wvPX+m81eV/nnyxePsx/zOXXxLwYf4tND5b/Gry + wuVT/7X41eCDvsXHJ6Xg+cL2PwOv3F7F9n7+2Ap8YR7bG/Qtwu9HsL1h/i3C7wfiGxK+33+e+PIt + fjV52s8K+a/E4lfof0Y+M5+AD+NzzlyfpS/6n6F8Wj+7+NUx/zOXD/Gr1+3M9aHx2cWvJMSvnieN + eWzvIf/zTTzqm4O+2Z8ficWv3vkrxK+E4lfi4lcS4leC95dNHuJXO/+z1Yf8V+LiVxLiV0L+K3Hx + q+evrFfy8cnlf171Cf03JW5vgvEqxK+E4lfL/7zqE/RNyuUvfUf5of8m0jdtfUf5YX1F8Sux+NU7 + nof4lVD8Six+NfzSQV/18Umx+NXkub1auPw1/w4+9F+l/ZHFrybPv2f18Q1RPN/f/mfg/fmCKJ7v + b/8z8Mr1gfjV9j8jz+8H11chfiUqXB+xeI5o6L8UvxJ16+cVv7L5QkhfcevnFb9CPhOP+9/gvxKK + Xy3/8+LD+oriV8v//O2PhM/3nyeVedj/StCX/Fcibv8rid8nxa/A/zzzOSeuj3J78fuFFb9CXohf + +9+Rjzrkb6f4FfifG/ifIZ8wzr8X+p8b+J+RT8TD9ykp3L/g/c8X+p8b+J+RV+KXv66B/xnqg+ur + C/3PDfzPmM+Z2wvfL6Rw/8LDZ+KXvhX8z8Dj/HuZ/3nxwrwwj/66MP+6/M8fD+1N3/fdxmP+nJd3 + 3x8d8z8zj/qG+Tcl0jc5fVPQ150fXeZ/Xjy3F78/+nhsL/vrEn5/NPml7/BvB31TUuIV2xv0dedH + l/mfv/J5/k1u/r3M/7z40F7S174/6tPtTLySvuZ/voYbmX8PWoV4iF+lcP+C9z9f5n9ePNff+Z+v + 7X+e4+fz8jLzuP+9tv958UFfJX0V41c7/zPUn/S1+Xfywe+N/vZr+58XL5156r82/04+lC9cPsy/ + 2/9svFTfXjf/Pn/l9y9ViS8Wz/nL/zz5BOWH/iukr2D86nU7M0/62vxbptuZ+cQ8nA+mMP8+TzLx + avGcJBzfSJj/+eMtnpMk9F8hfWXrO3nO/4/3h348nHef/M+ufLXzo+lPDn5gr6/a+dHkE/O+/6qd + Hw0++GNvry/4nzH/M+aLDrwAz/Ov3l5f8D9Pnv2fd+L2QvxK7+CfvJXLV9sP6i2cv9f5ny/zP0+/ + xMn/zO2F/e8x/7Pr73o5/8bF6yvvfx48+mNX/hzkO/Pgj70yvx93fjR4iF/pxfOv9z9P3uIbR/8z + 1wf9Oev8CHjl+kB8Qy8enxXvD/148MeG8yO9/Pz7/gPbG/S9pDBv8avtf0Y/s+e707fX4GeumXiI + T/7lf77Q/zz4zPm3nf/5Qv9zGX8N9Sd9zf88/MOpMU/6duevW+dHyHP9l76Y/xl4DXxCnsefLtxe + 9Md23h89T5R5Mb4FfRvp25x/soX+20jf5vyTLYzPmD/n46G94fxIW2Z+6Tt5bq/zP1//8j9D+aQv + +Z+Vf2+Y/3nyqG8L+jbS1/zPo/yQv71R/zX/8+RDe4Xbi/7YGvStND6b/7mNv3L51e+PwP88+DA+ + Vxqfq9M33B/6PLmIR31r0LfS/FudP7aG+bcmrv/Sd+Zz5vG5Ji4f9a1hfK6kb3X9N5wfaRWuD+pb + w/hchctHf2wJ66tC/bc4f2wJ/bf4/RH4nyfP7S20virOH1s4fuX9zxf6nyfP+ha//wX/M+Z/Bj5V + 4hO2N+hbEpev2F7NzCuXr9jeoG8Rbi9+n/J7/uePh/bmyuVnvz8C//M734X7Qx9eiYfzIw3xq+dJ + YR7WGyF+5f3PF/qfJ8/tzTT/sv+Zf885cXv/8D8nbi+ur07+Z64Prq8O/mcV4gXbe/A/Bx7WVyf/ + s2/v2f8Mfl0an8/+Z+Q78wn4kD82+fgk+J8nL8zT+Hz2PwNP+6Oz/xn5TDzuj1b8Cngan83//I6f + h/zPwu8f/bGn/M9cH/THnvI/+/aq88ce8j/7+DP4nyfPvx8tXD76Y3/P/zx59Mee/M+VednxkKP/ + mXmIXz1/Zb2U9kcWv5If8z8jz+8H/HXb/4y8Eg/5kbb/GXjqv4rxye1/Bj8t6Wvf708+M0/7X3Hf + d4f7Q1UKlw/5r075nym+Yd/vT57bKznwX3vf/rLOj8BvTOtn+35/8BryM9P8K1PfVZ+gr/jzhZ3/ + +eODvkLrKzs/quOv/HsW4fYufd/zx5P/2ZUv9v3+e755h/PfuzCP+QlP/ufMPOQLOvif/fp5+Z+/ + fESn/M+F+a+9/wH/87X9zzOfxjH/M9d/6Tv56H+uzCfgf/c/X9v/vHkJPJe/9H35U/5nr9fK/zzz + eV41+pmZh/sXJHy/7/3Pk4f2HvzPvv/KtfWdPOt75cBjew/5nwvxCdvL6yuh+NUXkpIvP+rJ/9yY + h3yqV9AX7y+bPOTP2f5n5JV5sfr30H+7jz9Ld/r20H+7H5/F8j9f46/BD1y4fMwf23MPvBCP+WM7 + z7/Pk8w8tjcFv7Gff6W7/tvD/c5dub2r/w6/9MH/XJiH3/PB/+znX+mu/3ZhP1IXfj+YP7ZV+t5T + ml8/7/zP938g//PkcXxuPP++T5iH8bnx/OvyP08ex+cW+m/z66ud//njf/c/X5b/+eND/21+f7Tz + Py8+lO/jzzv/89deCeXT+Ny2vmX8lX/PTfj94Pxbgz+20vhc3fxb+ftfqT6+sfM/L55/z9Wvr3b+ + 548P47P7fv+y/M+L5/ZS/AryPw8+9N/q11eQ/3nwQd9K/dfyP08+tFe5vZh/MtxfJhS/gvzPkw/t + FW4v5gcuof8W0regf+OP/M+Tx/yxp/zPiXnMh3zwPwvx4N+Q8P3+80SZF+BD/y3Ufwuun5+/hvIT + 10exvUHfQvMv538O71OYx/yiRdifXPz+VwrujyR8vy/Z748k4/5I1v1lyCfi8fujk/858PD9Uebz + wefJTTz6607+58y8AB/0zTT/Zuevy2H+pfjV9j9//MH/zO3F78syxyeF/Fdi/qvr50//8/Wv/M/o + Z/bjVXL6HvzPtH5ObnwO3+8/Twrz8HsO8Suh+JU4/9XO/2zrAfJfifNfHfM/c32w/578z1wf7L8n + /zO/z6Xv4GP+Zx+fhPzP4/1IaK9w/XH+PeV/9r9ndeurU/7nm3jIT/iX//nC/M+DD+Mz+a8g/7MO + nr//Veq/6tZXy39l70cT1x/zt2vKXD7py/mfefyk+BXkfx7+agn+auq/Ln4lyueDQvEryP88/Lef + vm3zQvsji1+97V3+Z+Qz8bh+DvErIf8V5H8efOi/FL/6R/5n04viV/+B/M+F+FP+Z+BpfWXxq+Hf + DvENUW4v7o9O+Z/5/eP+KHy//zzg94/5Y//I/9zN//zx3H99/udu/ufFp8A35r/97+sfC/cv+PzP + 3fzP1/QP8/7I+5+7+Z+vmY+a59/nCZe/4huvfy+cHyWXP6dj/ueRj5rHZ5//uZv/uX/5nFvglXix + +8uO+Z8z82L8H/mfu/mfu8v/DP7bmohf95fVn7P/mctf95e9/sZT/ueb+HV/2eRD+VmZF6hP8E+6 + +beb/7m7/M/Ic3v1Mr0Sn/+mpIEHfQ/+Z+X6L30nz/5J53/u5n/uX/5nLt/Nv938z9f0D/+e/7mb + /7k7/zOUXzLzCfjgj1Xqv5b/edQn+Nvd+VH/gfzPgw/fL7jzo779z6s+of+6+bdv//Pmuf8q6atb + 38lzf1Tl8gXbG/RV0tfuD33Hk5P/2f+eZes7eX6fQv1X9vg8/MmcH9j7n/v2P3/jp2QeH/D+0Mlj + /vaT/7kyLzaeC8c3nifMY/52Cfm9nf+5b//z4oO+7vyob//z4sP4LBh/7tv/vHnl9pK+Nv/OfM70 + e/D5n/v2P3/3Ed+V823eXt+d//n6/M+c//Augbf1hobzI+9/HjycL2z/M/B+fNYbzxf0Dvd336kT + v9ZXM190yM/s51+186M0/hr9z5V5u09Ew/nRmxGaeIhPajg/Und+NHlbT2o4P/L5n0fwHPZHGs6P + 1J0fDR7utzrmf87MJ+S5/pcfn/XC+OT2PyNfmRfgE/ttrsTl4/lvOD/y/ud5uHAhH/3PXD7sj47+ + Z+bx/Pfkf+b2QnxSO8cn3yeO7xiffP7Kv+fu51/t7nw/nB89TzrzCXnWq2fmIX6l4fxI8f7Qj5cd + L9Jwf6j2xPzSd/BB367cXr2QD+318+/2P3/1l/D+qf92l98s5M/R7sfn7X+efOP7Nbz/uZv/efpb + Gudn8P7nbv7njw/6NhqfXf6c56/8+2k0Pjfnzznlfw68QPmH/M8X8Zi/LpwfaUvcXsX2hvvZmwYe + /Ein/M9cf8H2SnifEvivve94WPn7UJ//uZv/WT4/c8j/TOOzy59zzP+cmQe/2R/5n7v5nxfP+rr8 + z938zx9/yP/M7cX8k+H8yOd/7uZ/XjzdR+bzP3fzP3988OdU0tfy5wy9Qv91+XO6+Z8nX3j/q4X0 + Lc5fd8j/TONzcf66cH7k/c/d/M8fH/M/U/8trv/+kf+5m/959q9wf+jz5CYe++8f+Z+7+Z/neHjK + /8z1wfyTh/zPyu3F8fmP/M/d/M+T/yP/czf/85wvwv1lmmn97M6PjvmfG/PgJwzxq4cX4tf6avLC + fA682Pwe7i/TTPOvfb//7i9O/mcuf82/kw/tVW4v+uvW9/tQH5p/7fxo8ME/6c6P+vY/f3y4P9T7 + n/v2Py8++p9JXzs/mjyvtxOtr9z9oUf/sxCP/sk//M99+5+/9eHJ/3wTj+vndX6kxiu/H7Xzhe1/ + Rp7fD+6PVvwKeOHy4X6ro/+Z24v7o5P/2b9/d370l/+5b//ztx8M94eqlsDD/vcP/3Pf/ufNS+CV + eQE+zL+auL3gr9Nwf+jDC/ErvjH8yb/7n7v5n2f84ZT/mdsL8Y1j/mdu74pvDD/t7/mfx5WUK74x + +KCv0PrZ4leTD35gH39Wi1+9v+eD/9nHr7b/+XL5n5FX5mXH0zScHz1PuPxk8br3//P7IX1l6yuD + 5/FZSF/Z+g4+5n9Wrj/EJx8+6CX8Ppe+D3/0Pztebow/n/zPvv9u//OIrx79z515i7dv/zP6mRvx + uSEvXH7m+q/zhcEH/8admF/x58mH+vv11fY/f+0N5/u38vtRbG/wb9zC5Qu293f/czf/8+SvoO/l + 59/tf/74oO9Vlfilb//5OeZ/bswn4IO+FL/a/ufFS+AL8wL87/7nbv7ncX60/c/IC/FL38nT/Cvu + +/1u/uevPjz/+vzP3fzPi9fAJ+ahvSf/s29vx/PBk//Zj8/Snb496NtJ3+707UHfnplf+rbxV9a3 + +/WV9K3v4IO+3Y/P0p2+Pfg3euL2KrZXQ/l+fyTd9d8ezve7cHux//Zwvt+Fy8f+23h9JRS/2v7n + jw/+nOb3v9v/vHjWl+JX2//88Qf/sxKP4/PJ/xx4bG8K5fv11fY/z/G2hf7bEtcfx+f23R8K/nAN + vM2/O/8zlE/9t+H8+/yVf28Uv9r+57F+2P5n46tfX23/81if7PzPyCvxcD748MFv7NdX2/881kvP + X4V5v77a/udr+reDvjVzfeB+Z6npZj5xfZKtJ5+/8nxaSd/lf75mvmu+H1YofrX9z9fMX63sH6vK + 9cfvU2rov1W4/nA++GZ7Jr5Q/y14Prj9z8gn4vH7lHB/2fOkMg/tPfifSd+y9Z08/x5K5vpkbG/o + vyVxexO2N/H7LD4+uf3PH3/wP2fm4XucEL/y/udu/ufFh/YK13/pO/y0YXym+JVkp2/wXwn5ryQ7 + fXMJ5VP/Nf/V9D/zeoPiV5Ld90crfgV8DrwA/82/wPvzfcm4/93+Z+QT8Su+IT/mfwZeAw/+uhzG + 50z6Wvxq8nwfShau/4pvjPzDQd9UffkWv5r5nKP/+SJ+xTcw/zPyXD5+P/hH/ueO/ufJT30L8MI8 + /J4T+3OE/Ffb//zx3/e/DfhE/Oq/94/5n6E+tH5Orv+e8j9ze7H/hvyTz5PKPLQ35J/0+Z+7+Z8v + l/8Z/Lekr+7+23/M/9yAz8zD+LziV8CTvurGZ82hfNJXnb76+TeAT9xe7L/r/jLglduL/XfFry7g + E/MwXuk8/51R6MkLtxf1/eJXjq/Mw3y04lfgHyZ9LX41+PD9oPjzQbH4Vfsx/zPyiflk65k//M/d + /M9zvRTiVyKZy4f41dH/XIkHf+zJ/5y4Pnohz+Onyz/Zzf/88Qf/M7/Ppe/wV4f5l/xX4H9+yKP/ + Gcpv6H8e/O/+52b+5+78z+DXRX2b+Z+78z8jL8TD/jeF74+8/7mZ/7m7/M/of+b6oz82fH+UsvL7 + gf3v0f9cmU9QfvQ/Y/9t6H+efGivcPlr/zv8wJW+p07u+6OG/ufhB2b/xvNEiC8X8MHf7s6PGvqf + Bx/9z4XL9/5nbq/7/qih//n1Z4b7Q73/uaH/Of0c8z+TvuZ/nnz0M3N7l76jPtH/LBfxS9/JS+D5 + /Qi094/8z838zx8f/c+4/23ofx75ig/+58R8Ap6/H/T5n5v5n+f7PPmfM/MCfKJ8rUlJX/M/j/Zy + /tjnCZe/9H37i2rwVyu3F/uvcv5J739u5n+e/naVUD71X936vuOnVMqv6P3PDf3P8v61RF6JX/Pv + 8EuX+T6b8aQv+Z+LcvmFy//L/yzMy14PJAn6Co3PNv+OfMuh/0ri+uiFPPdHofFZcH11zP98Ey8N + +Rx4bi98f3TM/+zKB//z5CXwQjzkV9G78H3Zt9d3+58vl/8Z/cwX8dnWk89fQ/0z18f7n9lvdidu + L3w/qDfr6/M/N/Q/Tz4z7/X9h/8ZeD//Bv9z8KsLv0+4f0GvGvIt+/6rl/NvXCG/6OXXV3o5f+w6 + P/pH/ufJJ+TZP3/58Vkv58+5cuD9+Kzu/tBj/meuP3zf/Zf/eQafL+TD+/Tjs17bf/WeRx/8z358 + fv/RkA/1F9Zr+a/e8/HO+TeeJ/731p2/rnP+jYcX4pe/bvirD/7nxDz4CXvovz3fxC9/3eRpP6I9 + c33QP3nyP3fi4f6j7X8GnvS1+0MnH9qrjXnLz6/h/Oh5wuUvfScvgS/MQ3vD+ZG6+0Mb+p9nPufg + B6b+a/5nzP+MPJeP97O3oK/L/9zQ/3z9nP3PmXkB/uB/LsTD/ZJH/3Mifuk7+dBeDXwCnvNvaBNu + 79L3Hn8N/nA//0L+53c8qcGfU6vXy/I/Dz7kj62F+ZVfdPIp8Jl5uI/g5H9uxMP9dEf/szAv9n7C + /aFaSV/zPw8+6FuV27v0nXxoL+lbnb7L/4x+5pt4acgLly/c3tV/X/6U/9mXb/7nwQd93f2hDf3P + /efsf07Mg7/94H8mfYvzt5/8z8q82Hge8uc8T7j8BPPRIf8z6Wv+58mzvkW5vXA/3TH/M5e/9J08 + 61v8/gj8z+/8e8r/7Ntr/ud3fg/3lynFr3b+56/8sL5y50fN8j9/fMjvnf3+SC1/zqjPIf9zZl6A + D/m9c+L6oL99+Z+RF+KXvpPn9XNWrg+ur7Lwet7lf26W/3nxwvURfj9w/9H2PxufaHxOTt8U9KX4 + 1c7/vHjWN5G+aes7+JDfm+JXO/+zuPzPwPv4FeR/HnwYnyl+BfmfBx/6b1J+P0vfyXP/pfgV5H8e + vPB6O9H62fI/y4/5n238ofgV+J+HvzeMz0r91/zPgw/rK3d/aEP/8+R5fNYSeNgf/eF/buh/HuUf + /M/CvED5QV9NXP7a/04/M+urPj6pdn6E/mfkE/PY3jA+q3B91v53+qX596zC7T3lfzae4lec/znM + vxS/gvzPk+f2SqnMH/I/Iy/EQ/6rhw/l0/gsW9/BH/zP3N7/hvzPg1/6Tj74vWl/JJi/bvuf7fsF + EeaXvpj/uQLP7wfzE4b4lVD86h/5n8Gf7OdfyP88+eh/TsxDfrNwf5ncXl/I/1x+zv7nwAvwB/9z + Jx7zX634FfqZub16IR/9z1w+xK/klvA+hcsHfWXFr9D/zO1FfU/+Z1+fy+l78j9n4lHfk/858KDv + H/7nZv7nxYfyc2Ue25v4fPby/Vfc9/t/+Z+b+Z+/8pX9jRS/2v7nr3xhv98l3F4Yn3f+Z+S5fMxP + 2Cuf13fqvx3H5+1/Bv+tX19Jx/H5dTtz+T4+Ke77/b/8z4Nf+k4++Kv9+Czu+/2d//kf/ufBw/pq + +5+h/sq82n7hr/zPk0/AB327X1+tUXfuj3b+Z6iPBN72g9v/DH5dP/+Kxa8mH/zMpK/Fr97f5x/+ + 58knKD/6n318Utz3+9v/DPXPXB/YH+38z//wPw9+6TvKD+NzI30tfjXKD/kJKX4lFr8aPMc3hOJX + YvErGX+d7S3Ac3th/Sy1sh+p+vWz2Pf7b/krfmX+IopfiX2/P/kSeC4f9kfb/9yNz8yjvvWLP0P5 + pK/7fn/nfwY+cf3h+/3nr7M+N/BcvsLvuSr7xyrNvxa/Gjyvn73/uW3/8+bp/FQqjc8Wv5r+Z/YT + Fn++IAXjzxLuL/P5n9v2P2+e8/1S/EosfjX8vWF9RfErKRh/ft3Ogef6Q3xy538GPnH5EJ98/pqZ + V26vWjxWwv1lUpTrs+63esf/EL+S4uMbYveXjfJD/y0SeDE+h/Vz9vENyRh/lnB/mVD8Six+hfmf + kU/MJ+CDvhS/Eotfof8ZeOq/2embU8gvTesru79stJf3v0LxK8lO38z7X6H4ldj9ZYMP+pL/SrLT + 95T/meuD+iaOTz5P/Hxn95eh/xn4wjzcXyYhfvU+YR5+z4njkz7/c9v+51X/sD9KtL5y95dJ8F89 + TxrxcH50yv9M/dfiV5OP/mcuH84H5eB/pv5r8av2c/Y/F+ZhffWH/7lt//O3ftOgr9L6SjE+efQ/ + V+YtXich/+Tz5CIe87ev+BX4sX18Ulz8SkL+SVFaX6nbH634FfLcXtwfhfjV84TLx/z8K36F+ZyZ + X/uj/GP5n6F8ycx/7R3+27D/FVpfWfxq8GH/K7T/tfjV5Hm/IIXLX/uj4e8N3y9Q/AryP8uP+Z+B + 9+dH4H9++2+4v0wofgX+5+H3Dv1XErdXLV/Bzv8MPOm74leff1ui/5nfz9R38RL4yvzX3jzczvR9 + WXLnRxX9z+Vv/3PF/M+TL4FPzCfgD/mfb+LRX3fK/1yYx/by90fJfX9UMf/z4Dm+kdz8WzH/cxp8 + Zl65veBvT+H7o+TOj6r5nxcf2itc/6VvAv8z+JOrfz9p65vB/4y8EI/6phLKJ30Tfr/w/FUDz+Uv + fadfmn8/KVfmZffHlDi+4f3P1fzPiw/+bb2IX/peP+Z/Rp7bi/7JcH/o8+QmXmy8ev7K/nl3f2g1 + //PkT/5n3147Pxp8yO+tpK+if/Iv/3M1//PH8/rK53+u5n9evASe65+xvbw/8v7nav7nj+f72ZM7 + P6rmf76nf1uDX1q5vZqAlyvwSvzSd/i3+XzhecLlQ36kJDX4gav//bv7F5Lw/je5748GD/ljt/8Z + +cy8rTeeH2PgSV93fvT8NfilM9c/Wzw2Ca+vkpC+gueDO/8z+LdTIl4v4DUxr9xeOB98/qCBV+KX + vtP/HOojXH88/73D+f7t9dXbnf+u86NmvNd3+Z+/8+ib/e3e/1y3//k7717nR914zB9bt/9588Ll + Zy4f/Rvr/Aj4xPVH/8bN34d6/3Pd/ufPf3JrqL8W5sGfs86PgBduL8Sfn7/O+fECPjMvxq/zI+Pd + /aEj+FYt3q7r/KgDL8Sf/M/Al8o8nP9eQd/L91+186PJC/0+Lz8+64X9V6/Ev7crMY/n+1dSLl/5 + /Si291tfQfl+fFY7Pxr+bQn1EW4vxJ+fv6bAZ+bF9Fr5n43vfv4F/3Maf+X+4vLnVPQ/D3918Oe4 + 86OK/ufBc37+9wnxGX7Py/8M5Wdh3uLPr9uZ+cTt9f7n8H6U66MWj33dzoGvzB/8z1Af0rdvfSev + XL4o8xbP2f5nK7/5/RH4nwcfxudG/dedH23/M5RP43Nz/snG6yt1+XMq+p/rj/mfgc9cH/RPNp5/ + nyc38ZgfeJ0fAa/ML33Lj/mfC/CF+YQ8f3/R5CJesL1BX3d+VDH/88g/zPdbaaXxuWL8avufK/CZ + eMwPXAv3L5c/p2L+51GfoG+l8bk6fSvHn58nlXls78H/fBF/yv8MvDK/9J18aK9y/eH86Nl8sL+u + +vUV+J/74On8Uavw+4Tzo6P/2Y+fdn40/MYH//NFPPbfk/+Zy//L/8w86nvyP2fmQd9wfvQ84fqf + /M/ol07EY//9w/9c0f/8zkcljM9FuL1L38nnwAvzYnwO43Om/mv+5+ln/tX/XP8j/ufGPPqBg78u + Z+b/8j8n5sXWJznomxPXH78vO+R/VubX+mrkow76Zhqfs/NPhu/3X0c08Wt/NPnQXtLX8ue8fAr9 + N5G+lj9n8MEfS/EryP88ee6/idbPyflj03e+n4Dn8sGfc8z/rMxjew/5nwvxuH4O50dK8SvI/3z/ + nP3PXD7qG86PXkc08WL7/b/8zxX9zy+vfL6gSvr+/ys7uy1dVV2L3p+nqEdI+NX3f7GjIGRkhFm1 + 9s3cq1l908B8KIZuVPTrjv6zEo/fxwn5K1WKr+WvBh/mrxZuH74vefSfM/MC/O/1nyv6z+/1IXy/ + 7OET8Wr5Og3fL3uONOax3nWYv+rzz+rq5xzrP3N/8PtWp/rP/vdm7+8PvzfEV2h95ernaNg/8v7z + 5BPw4f5L+Suo/zx84BBfyl9B/efBh/hS/grqPw8+xJfyV1D/efKhfeX+K443xFfo+mz7R5MP46X5 + a/tH6D+DT+vnL9R/Hr7u7/Wfq/nPX/uFfVTKX8mN+wsS3t/3/nM1/3nxwu376/P2ny/nP5uPd6dG + fMLxavCTE7evF/LsE97K48X9wfD9MrmF+7Pim8dfQ7z8+nn7z7P9qwb/1q+ft/882794f1Aun5/c + /vOs7/RH/edq/vPiud7mRfG9dnxHfw71nzPzAvzv/nM1//njef56/7ma/7x43v+9lPuD9a+uEN9L + +HzC/uD2n5Hn/sD+4LH+sz//fcd38LH+s18/S3fxDe/vP0cK8zDe8P7+wyvxuSHP8e1+/Sx9x3fw + h/rPlXisbxa+XyaUv5K+4zv54GMrj3fFd/jVYX+/+/uv9B3fybM/3yXwMN4W4tto/rYd37f9U/3n + m3ion3P0n7n9FV/5Mf8Z+pOZh+/DHus/V+YF+IP/XIhf8R18uD43im/b8Z08vz/S6PrcXHwP/jPF + t7n4tjB/m3D7vv4z+1fV7x9JdfE91X9OxGN8K+/vP0cCD/M3vL8vlL+S6uZveH//OZKZh99z5e9L + +vrPg8f5G97fl0r3X6v/PHn2r6pyf/D6XLk+g1D+Sqz+8+SVeeHzCX6OhO+XPUf877O4+2/4ftnD + C/F4fQ75K+8/V6z/PPhY/5muz8XFt2R+X6Bk7g/G91T/+SYe47vyV7YeK8rnB++/Jbx/RPmr5T9/ + 658Srs+F1ldW/3m0H/wryl9JcfEN3y8T8q8ku/hmrk8omeav868k1J98jlTmYbw58/Uh0/oqu/Vz + 8K+8/1yx/vPgQ/128q/E/KvXnwz+lVD+Ssy/mnwYr/L5gecjCfkr7z9Xq/+8eL5eZeH2V3yHTxvi + S/6VJPd89Ef952r1n+fvIXF+4zmSmYf6/Kf6zzfxuH4++c/CPMzf8P6+UP4K6j8PXoPvnbj/Cvej + k/+cmIf1RvCvJAmfT2nIh/EKt4/fPwr5q+eI/z1b/efBR/+Z4mv1nycffGBaX6lbXynv/wr5V1D/ + efrSof3M/cfno+BfPUe4//h8FN7fF/KvxL5fln7Mfwafme6/6u6/J/+Zx4v3X5XQvnD7eH0O9Sef + I/78i5u/f/jPFes/T56vV+RfQf3n0Z/f6z9XrP88fWlhnvIbK381v59yqv9ciMfvW0lYXwldn1f+ + avFhvD5/tf3n+T0dCfEVYX7Gd36vJ7y/7/3nav7zrHeaef/3PWJ8Mf958eTbpIzPRwXrP7efc/3n + zHyC9kP9WOc/F6z/PHnh9vH6XLD+8+AT+58Z81cF6z8Pnudvct9fKFj/efKZeQ38of4z8kr8im8B + /xl4jG/B+s9l2s50flz9nIL1n4f/HOoDu/tvwfrP6cfqPyOfmU/AB7/d7R8VrP88eY6vq59TsP6z + /vxZ/7lg/Wf5OdZ/Ttz+iu/k2QdOGvgEvPDvOVF8rf6zgv8MvPD5FBjvH/5zwfrPCv5zBl6JP9V/ + tni5+2+J9Z9vbp/mr9V/FvCfkRfmx3jb8EvD/lFSmr/r/ttmvWVeP3v/uZj/vPjK7VN81/336094 + f0HlIn7Gd/E8X1z9nGL+c/vqP/N43fdDi/nPs//h/vvwifhyIc/jde8fFfOfPz7Ub3f7R8X858Vz + fIXiKzu+F/jPwKdOPMY33H9fI5r4Fd8K/rPNF1E+Pyu+k5fAK/ErvsPf5vyGr/9czH9us35y5f2v + 28d3+8/N+c8FeCF+xXfyvP97l8J8Av5Q/7kRD/HVUD9H3f5R2f7z4oO/cSfuz4rvux93qv+ciIf4 + 6h32928N/Dfe6TOzf3Urn88V39EfCf331+dd/7l99Zx5v/Kq7n6t145vG3/l+qWXv//qteM72uf5 + 6+s/T97m7/afrf8Xxffa8Z31n/l8uvo5k7f70VvtmfuTuH2oz3+q/+znr679o8XzfvdF8b32/Xfw + wvWWL+Hzue6/kxcer3D7sL56qz1T+53i23H9rGH/SDvF174fOnkeb6f42vdDp8/M87f79ZXa90Mn + P8drvk2n+WvfD33PTw/7+53ia98PHe2H+PbE/VnxnXzi/iifT4xvD/HtwudTcLyH+s/cPsY37B9p + 8+srte+HDj58v7vVTHy5kK/Ml8Q8xDfUz/H+c9n+83d+Wg71kDP3P+N4E/9+GsW34fPR89cceO7P + iu+oX/17/eey/efFB3+jKbcPz7/aQnwbxbft+A7/NtT3rhTfuuM7eR5vpflbd3yHr8v7R68RzTyM + 94/6z2X7z6s/h/rP3H7G8Yb5WxO3n3C8Yf5Wv35e/vPmOb5VuT/w/Huq/0zxrTu+w68O8a1+fbX8 + 548P+0fPET/e4q7Pf9R/Ltt//ubLyX+uzMP8PfnP3D5en5f/DP2h+Vvc9flU/7kTD98/OvrPSrxe + yPP9riifT03Ah/i6/aOy/efN8++5CJ/PFd+XD/tHvv5z2f7ztz7J4f6baf2c8flXQ/7qOdKZT8CH + +ObC7eeGPP+eKX+l2a2vMucnff3nsv3nzYf2UyYe45vD/ZfyV5pdfMP7+77+czH/efGzfatHmoX7 + D9+30lSp3p2675cV858/Ptx/KX+lLn+l4ftlmvzzryYX35C/0pSZx/XzyX8W5sXW5yf/mce7no/e + +8XKXyGvxK/no+En8/cHvf9czH/+2g/xTcLjxeejFK7PSXi86/lo+Mzh/qs0f3U/H02fmcerPr+x + /ec2feMQXy2BT8Bz/srXfy7mP3/9OfjPhXkB/nf/uZj//PEhvu77ocX856//Yf5S/kotfzX4EF+l + +6/lrybP8aX8lVr+6p1fEuIrtL6y/NXgQ3yF5q/lrybP12eh+Fr+avAH//kmfsV38jxeyl9t//nj + D/Wfuf2E4w33X1Ee74qvjr+G8SqPd8V38Af/mdtf8ZXxV/49U/5q+8911As6+c/u97z958Wz/3P7 + 5yOx/JW8fw3+1e3XV2L5q8GH/cHb33/F8leTF+Yzt59xvGF/8E7MJxwvz1+h/NX2n+vYH1z5K/Cr + NfAJ+dB/f33e/nMd+4l38HNu4fZXfEc94fD97svnJ7f//PHRf/b7C9t/Xjzvh15+/m7/+eODv3EV + bj9/420/5j8D76/P23+uX/3nMN7E/IrvrOccxuvn7/af6/TJgx97Kbe/4jv44F9dyuNd8c0/f9Z/ + LuY/T74Hv73767P0Hd/BH+o/J+ILjLdz/SvpJfAw3j/qPw9+xXfyHN/ur8/Sd3wHH/zJnni8K76D + 5+vzw3P/Mb5dO/PamU/2++lh/nZhXuD3vOo/Q/vC48X5e/Kf/fxtbv6G75c9vBKP87eV0L5/Ptr+ + 87xetfD+AuWvtv/c/ov/XMx//vgU/GSKb9v33+Ebh/hS/mr7z4vn+dv88+/2nz9euN5p8/ff7T+3 + r1506D/N34brKwn5K6kU34rrq7/852L+8+J5vLUEPgEf5m/N3B9YX23/GXlhXux8hvzVc6QSv+L7 + /h5W/grap+tz3fGdfBiv8ng1IS8U30r33/oD6+fnr1QfwPvPxfzn8Tz12s6Dt3raha7PBfd/n7+m + wGfiYX9QCtdn8P7z5BPwmeqTPLwQD/uDsvJX0L7fX5Cy4zvGG+qLFr9+loLPR9t/tngVim/Z8Z08 + x7cojxeejyTkr4TyV1JcfIuwH1iEzw88/x79Z3/9zDu+k6d6IEL+1fafx/O7hPf3ff3nYv7zPP/h + +2W+/nMx/3nxMx9u61XKX23/+ePD/KX81fafF58Dn4lXHG+IL+Wvtv/88Qf/mc+n2PP+sf4zn58V + 3+Ezh/dTEs3fhPkNWfUnkc/Er/i+v4fgXwn5V9t//tr/3X8u5j8vXgLP/V/xfX//p/rPzOP1+eQ/ + C/F4fT75z9w+Xp8P9Z+FxwvPv3Kq/8z9EVhv/FH/uZj/PJ8HT/7zTfxaX02ex6uF21/rq8Ef6j9z + +2v9fP1Y/WfkE/MC/MF/bsSv9fPk+Xmf8lfbf/74Q/1n7g8+/4bvl4n6/PP2nxdfmff7C9t/nvzK + X6H/7HnZ8R18iC/lr7b/vHger9D6Wdz6+VD/OTOf4XlfQnyF5q/s+A5/OMRXEvd/xXfwenN//P7g + 9p8Xz9cryl9t/3k+H4X8lfefi/nP1dV/hv57P2f7z3X6tMGvc99fyOY/1+E3hv0jX/85m/9ch98Y + vr+Q3PtH2fznj+f5m1z9nGz+cxl+YKif4/3nbP7zxwe/LuP6Kpv/XIZfd/Cflcc741umzxz8uqzc + /xnfjxeup5qF25eGfBiv8HhFjA/fD/X1n7P5zx8f6gMnfP7N5j8vvnL7eP/N5j9/fIivu/9m858X + z+N19Z+z+c8fn27mE493xXfUfw7xdfffbP7z1/7Bf+7M43gP9Z+ZX/Et468SeO7Piu/L/+E/Z/Of + P/7gP2fiV3zrz7n+c2X+G2/+sfrPyAvxK76T5/hqDrwAn0L7NH91x3eMV/n3oInHu+I7+Uy/Z/f+ + UTb/+Ts/wr8fd//N5j8vPoxXuP0V3+HfVvbn3f03m/88f2/h/puE4itu/krh8+n852z+c/l8Zj6f + kpnH63P4fmhy999s/vO8/kuqzCfmE9yPJMRXEo933X/Tj/nP4Cfj/Teb//zxYf4KzV+7/06e56/Q + /LX777v/FfaP3iPI64355+0/Y73oRPy6/04+Me/n7/afP/7gP9/EQ/55+88FeGFeoP2D/9yJTzhe + vj77+s/Z/OfvfGrov7//qu0fjfY5P6lu/yib//yNN/ixt5+/avtHw6cN9QkvP3/V9o/K+Cu3f/n1 + ldr+UR1/5Xq8V+H2Yf38l/88eHg+eqs9B74wb/uDeoX4XhTfC/cHT/6z3sTrhXzl9pX7D8+/z1+F + 2xfm1/Pv8Lc5//weYd6e93f9Z/Sf/fnpzt/o/H0N7z9n85+nT3Lyn7l9yF9pD/5Gz514yF9p2D96 + jnD7kL/a/rOdf+c/Z/Ofp9/SU2g/JeIVx6v8++waePBzeqgP3IX7A+8fPX9Nga/Mi/F/+M/Z/Ofm + 6j8X4JV4fD+lhfg2f//d/vPio8/MPLxftus/Iy/M43iDn9MSjzfheMP8bf7+C/7z6E+oX9f8+hn8 + Zx1/Df0XHi/6daF+jq//nNF/fvka4uv2jzL6z29/Kq+fH16IR3+yFvaLqn8+Av958MGvq4XbR3/y + 5D8HXoA/+M8X8ehPnvxn5jG+J/85MQ+/54P/TPGtbv7+4T9n85+nT3jyn/3v2e0fPX9lv935z9n8 + 54//vf5zNv/546P/TPG1/aNRvzr4V67+czb/+eODf1UovgX3FzTsHz1HeLx4fS4hvkX5fOL7ZaF+ + znOE+wP7vxrq5/j6z9n85/Zf/Ods/vPHF74/Uv5Ks/MnT/5zYR58woP/nLk/6Nfl8H5K9vkNzbi/ + oKt+DvC0vrL9o8GH+Zt9fmP7z4tnPzYrjxfjm7n+lWbh8a741h+r/4w89wf92BTeL0t0fbb9o+Hf + hvVVoutzwv3Bo/+cmIf11R/+c0b/efT/d/85o//8ns+T/8ztY3wP/rPy+cH4pjB/k/J4V3zf32fI + Xynlr8B/Hn74of4ztw/7R0f/2f/eFPcX/qr/nM1/Hvn/7T8DT/FV9Ot2/WfkhXjYXzj6z5V5Af7g + P1/Ew/7CX/Wfs/nPi//Vf87mP8/nxz/852z+8+L596zC5wf2F47+s//92P7RqG/8u/88eHz+lTB/ + ha7Ptn806znzeCVzfzC/cfKfuf2M4z34z414zG9ImL9C81d2fKcvzdc3yl9t/3m1r4EX4sGfPPrP + yrxs/ug/u98/+M+v73Sq/6zElwv56DMn5hPwYf/3zhfxuSE/x1uBF+YF+MT+z+3jKy5/tfzn+RQz + eeX+6IV8DXxnHnzRU/1nbn/FV3/Mf0aexwv5ybfaM/GX3x8E/3nwIb6UvwL/efLRf67MQ3wP/rO/ + /4L/PHmh38NF8b1cfC/eP3qPEJ9wvHx9fvhEvOJ4D/WfA58sXlfY36f8FfjPk+f9a8pfBf+Z5y/l + r6Tj/u9f9Z8Hv+I7eR5v9/kNMf958KH+ZM/M54Y8/567fz4S858HH/wcyl9Jd/H9o/7z4DG+nfMb + vv7z5BOc/zB/u7//Ssfrs6z8FfB+fSUd77/SKtczb379DP7z6xuE/NV7hHj020P+Shpdn5vz21vh + eLXM/ckN+hPi2/z6avvPHx/89kbxbc7faMr+f1Mer9p6UsL7+77+czb/+eNj/Wfh/uD7KU1y4Hm8 + 6OdUfj6SSvO3Ov8q5K+E8lfbf148j7fS9bk6/+rkPzfiV3wnH9rP3B/02yvXZ3iOdOLRbz/Uf6b4 + mv88fOwwf937+xn95zz+Gus5c3/g+VdquP9Wv38E/vPLl/B+SqH7b3F+bOH188Mr8ehPrvwV1E/2 + +Sspzp9c+SvgKb7F+e0hf+XrP2f0nwcfrs8lcfvw/uDzV54vlL8C/3nw/P1uKcrt/+U/8/n3/jPH + t0hh3vI5R//Zt+/yV5JDfDPN3+zeX8j8fCTkX4nlrwYf1leZrs8uf3Ws/8ztY3xzqO+dKb4uf3Wq + /+z3fyW7+J7858I8jje8X0b+lVj+avJ8vco0f8/+s7Wf6Pkoufge6j/T/LX81aiHfPCfC/PwPk7I + Xwnlr8B/lp+z/8z9wfdDT/WfO/Hox4bvlwn5V9t/XnwYL91/077/Dv7gP1/E4/33VP+Zx4vvl/1R + /zmj/zz46D97f0Nc/uroPzfmYb1x8J99/kpc/kpC/krIvxKXv5KQv3qPEJ9wvCG+5F+Jy19J+H6Z + UP4K/OfBh+sz5a/E5a8kfL9MVDheuH4O9SdFaH0l6Of85T9n9J8nH/3nxDw8L0iIr2RuPzfkef0v + FF+Xv9r+M4w3VeLx/VBJ/D6OJO6/Wr5u+8/Aa+AP/jPySjzGV4LfLsLxEnte2P4z+LQY34T+8/Cl + g1/n9o8S+s+Tj/5zY97im8L7R29FaOIhvkf/uTIvwAd/0r1/lMx//niN9Z+VeHj+3f4z9B/jm8x/ + /niu753c/lEy/3nxEngeL+SvUnj/KLn9o2T+88dH/5nimzB/lcL3F1Ki+CbMbxz950485K+O9Z+F + eRzvof4zjzfheHn9nNz3Q5P5zx8f/MmEfmwy//kb78F/5v5gfNP3/AvnR5R5u16lcP99jvjzqW7+ + hvvvwwvxsL9w9J8b8wn43/3nZP7z4nn+uu+HJvOfPz7Ub1eav27/6Og/K/GQ33h4ni+qlXlbX6Xw + /YWkwucH1lfbf0ae21/xHX5ymL9C12e3f3T0n5V4jG+4/yZ3/03mPy9eA8/tQ/2N7T/b79PtHyX0 + n0f95EP950Y8rK+ev4b2E/cf1s/PH0K9a+X21fI5R/+ZeWnI8/VKhPsD9XOO9Z/d+YH6z/Jj/jPy + mXion3Os/5yYT8izT3j7+EL953e/++Q/c3/g/X292W/X28cX6j+/+33Lf4bx6k08PP8+f+2Br8yD + r3Jz/sr7zwnrP4/60gf/WZgHf+MKfuxF8eX6z5l5f/9Vrv/M+/tX4fZXfAcf/Ngrc/tY3/vi+fse + Yf4b7/Sf+fxfifsD3194qz3T+bwSt6/g1/1R/3ny4NeF74d6/3nwUL9dw/dD9aL4XlifQTtfn58j + /nx2F99e7sAL8RjfHup791KZB7+uBz+255t4+L7GazsHnvvj6z+H/lB8rf7z4MP87crnZ8V39CfE + 19XPSVj/efJhvMLtY33vHuLbhfuP9SdP/rM//1b/efLBTy438b7+M1+fG12fuf5z8Kvp+mz+86jP + fPCfC/MCfPDbG12fz/WfgVce74pvG38N41XuD9YHPtR/Fu7Pqf4z8sI8jDd8P/Q54n8/VP85+s+F + efj+kYb9o9eIZh7GW3n97Os/Dx7jW8P9t9L91/zn9/dTQ3wrzV/znwfPz78PL8TrhTzHt9L8tfrP + 73w51X/m9uH7OBq+H+r958mL8Sf/2cfL6j8PPsS30PqqOL/95D8n5sFvL/z+oBaKb3F+ewnvHxWf + 34D6z+/1sIT4Forvuf4z8MrnB6/PJcS3KLd/qv+MvBCP1+cS1ldF+Hye6j8bT/mrf9R/Rj4Tj/WB + Q/5KM8XX6j8PPszfTOur7O6/IX/1HOH+Y3xz4vf1KH8F9Z/f83nwn5X7s+I7+TBe5fOD8zfUz1HK + X0H958mzH+j2j1Ks/8zzN9H8/Z/qPyes/zx5nr+J4mv1nwd/8J9v4jG+J/+5MA/Xq5W/gnrXqROP + 76ec6j8L8Xohz75oUm4f3z9a+SvojyrxK77y82f954T+87s+/8N/Tlj/efCH+s+ZeHw/5VT/uTOf + bH2uIb5K12d17w9qiK/S9dnqPw9/OMRXfX4S6j+/v7c/6j8nrP9cfv70nxPWf548308pfwX1nwcf + 1lcqHC/Y/z36z/78WP3nwf/uPw8e3085+c+Z+WT5gZP/3Ij/q/4z9/+v+s+FePBzVEJ83fv7g1/x + xfrPwCu3f6r/bL83yl9B/efJh/HS/Vd2fIdPG/b3b399FstfDf6LL9Q39vMX6j9Pnv0cyl9B/efB + x/rPPr7/W/3nZP7zxyfeT6T8ldzOv1r5K+h/4vHqBe0Hf+NWHi/kJ7f/jLwQD/nJY/1nZV6MP9V/ + dtdP8J8nn2m8V03EY33vqwS+BB7iu/xn4Cm+F+Ynt/+MfGUe4nvx9Vkof7X9548P8aX81fafFx/G + q3w+sX7sxfNXKH+1/efFh/H6++/2nyffa6zn7MfbnZ9zqv8sxKN/1Qv3v1N8LX+Vx1+5PnD3+4Ni + 7++X8Vf+ffbM7cP9d/vPwKeLeHh/f/vP0H9lfsV38lyvvvv8s9j7+6+/sb5fBrxw+5CffP4a+i8c + L3j/d9d/tv43v/8r9v7+rM/M46X8lTRcX73Vnqk/lL8Sy1+9v//w/bLXiCYe3t+X9f0y6E8OvK2f + paXgM6dKPDz/7vrPwCuPF55/j/Wfebzw/Pv8NdS7pvha/mrWi5bA83ghv/FWex48+sy+fctfvf05 + 1X9W4uH591j/uTBvz0dSw/sLleJr+avyY/4z8Jnbh/zkrv8MPMW3Yn7yL/85mf+8+OBXU3zd98sk + 5K+kKp9PyE++tjP33z//iuWv3vl+8p/9eC1/NeotR/+Z5q/lrybPvlkp3P6K76znzOeT8ldi+atZ + Lzr4zBTflb+6Pp+Z11clcX9mfK/pG4f5S/mr7T8vPoxXuf8zvl9/wvqqCPMzvteYj+H9fSnC/Rcx + PtfgG9P9d+WvLuc/I5+ILxfy/P5aLtx+SXZ+/vCfk/nPl/Ofkef+YHxP9Z8b8QnHy/v77xHiFcd7 + 8J8z8xDfg/9M6+fs4hve3xfKX23/efIhf/Uc8eNNO77y/jXM30TXZ8tfDd/44D8n5pNdT071n7k/ + a/5Onsfr/OfJi13fwvv7Qv6VWP5q8GH+psT91wt5jm/yz79i+atRHztcn5PweCE/+Zf/PHnLxx79 + Zz9edfff8P7+e4R4vP+e/OfEvOXrjv6zEo/rq5P/XJm3fN1f9Z+T+c8fH+6/5F+J5a+w/jP6zNz+ + Wj9j/Wf0mfn8r/Xz5IV+P0rrK3Xr55P/7M+PuPVzyF89vBCP9fnD98uE/CsR9De2/4y8Eo/fX5AQ + X8ncn4zjPfjPN/EJxxvmr9D9V1x8Q/7K+8/J/OdvvPx95/cI8Rjf4F+JCI8X4nus/wztq/nPi2df + 1PnPav5zm/WWOb7JfT9UzX/+eH4+8v6zmv+8eAm8MC/A8/U5ufo5av5zc/Wfof/K41X7PW//GXlu + H+L73F5u5oV5iG9a+0fIV+YhvuH9o+T2j9T858UHH7gwD8+/Kdx/nyOd+QR8iK+7/6r5z4sXbh/X + z2r+88cf/GfuP8Y3cX3+5O6/av7z/P0kDecH11dq/vPX/sF/5v5gfE/1n5V5GO/Jf/bnU118D/Wf + y008XJ9TqJ/zHMnMWz7n5D9nbh/2j56/8vl3/rOa//z1h/2rpDR/1cVXuT5/Upq/6uKrIb7u/qvm + P4/1Qwr3X+8/q/nPi+f4uvrPav7z5Ff9Z5svzn9W85/7rIdcOV5C81dwfZXC/TcJzV/B/EYK+0fJ + vX+k5j8vnscrOTEvOx9y9J+5ffBzUvj+wsML8ZDfSCf/OTNv+Y0knJ/09Z/V/Oc+fWxeX3n/Wc1/ + nt+7vzm+zxH3+9n+88cf/GclHv2rO+wPuvrPav7z1/6h/nMnHp6Ptv+MfGJedv5k+8/A+/hu/7lP + P5zvv3or83ohnwLP/VnxHXyoX3fLTfx6/pXx1+hL8/mE599d/9l4V/95XHzW8+/gQ3wvP3/1wvzG + 0X/uzCdoP+z/Xv7+q9fOb8j4K8f38tdnvXZ8sf4z8InHi/G9OL/h6z/Pi/MF/Qn1gS/l/kB+Qy9h + X+gSHu+Kbx5/Df2RwvwX31HfOMS3U3z7ju/gg3/Vaf72Hd/Jc39c/efJf+N9/YEe5m+n+PYd39H+ + wX/m/q/81fCrQ3xd/ZzBr/zV4L/5W4Hn8a74Tp6vV92vn7f/fE0/PNSv6zR/+47v5LkeWvf33+0/ + z/604G80f//d/vPHh/nb/Ppq+8+zP6f6z5n5b7zD7w3xdftHav7z137OzGfu/4rv4A/+cyUe49vC + /G10fW47vrNedOL2lce74jt4YV+0qRI/43vPetEH/zkxL8af6j/78a79o/uf9Z+V+AK/5z/8ZzX/ + +XL+s/3eKt1/647v5CXwwjxcr071nwvxK77oPwNP8a07vug/I8/nUy3f/lf9ZzX/efFCv4cqfP7X + /H355T+DT0vxLbi/cPSfhXi8/xbeX9BSuH3YXzjVf/bPR9t/XjzH130/VM1/vpz/DDzF1/aPhl/N + +Stf/1nNf148X5+d/6zmP8/79an+cyNebL/sWP+Zz+daP798Dtdn9/1QRf/5nY+hfo5S/gr85/5j + /jPyiXl4fyHkr5TyV+A/T17o95Apvhn3fzXsHynlr8B/nnzm/iiPF56PNOwfaVYeL+wvaNg/8v6z + ov+M9Z+RF+ZhvCf/2Y/X/OfBR/+5JuLLhTyPN9H91/aPZj3n4D/T/Te591NW/gr84Rx42c/Lx/rP + hXj02/+o/6zoP6cf85/RZ+bzA/mNk/9M8bX81f3zp/+s6D8PP/l3/1nRf54+c/CBaf7+7T9X5i0f + e/KfixKP9flP/nNiXna+a/vPwCfuD9bn/8N/VvSfh1998J/5fIJ/dar/TOtn2z+afBgvxdf2j0a9 + 5TB/KX8F/jPWf0Y+E3/yn8Hvpevz2X8Gnp6PBP3Jo/8szH/jfefLH/7z4MGffO+TzFN85YvvfF/+ + 5D/zeMGP3f4z8MLjBT/26D/zeNGPPdV/dtdnqP/87k/9Uf9Zsf5z/zH/GXi/fob6z4MP+4O3X19B + /efJc/3M28cX6j+P/of9wdvPX6j/PHhePz98In7Fd/K83035K/CfB8/fH/T1n/Vf/jP0xz//gv/8 + th/yV0L5K/CfBx/rP/v7L9R/nnyoL03xtfrPw6+O9Z/9/RfqP08+9N/nr4L/zL7Zlbg/J/8ZeD9/ + of7z6E/Y/718fgPqPw/+y1+hL83jXdfn0R/ObzxH+Px7/5n92O6vz2L+M9Z/TsAL8fj+Qufr83Ok + Mw++d+frs1D+Srp7f6Hz9Vl65v5nHO/Bf2Ye31/ovH4Wyl+J+c+vr9JDfVHKX4n5z8PfDv5Vp/nb + d3wnH8Yr3B+sPxnyV0L5K/CfJ8/1bCl/Bf7zrBfN1+dG89e+Xzbaj/6zfz7a/vPXfvBjm19fScP1 + lTSuvyEt8XjR32ghvk15vCu+9/hrOJ8+fwX+8/v7bCG+TXi8sD/4/DWcT4ov+8/BB6b4uu+XPX/l + 80n5q//gPzfmwfeu4fpcM/OwPyjh+2Xef1b0nwfP+0dC+Stx7+8/f+XzWROPF55/j/WfE/P/3X/W + 6D+H8UrgZecfXtuZ+ELrq7P/DLx/Pgr+cw58Zd72yyTkr7z/rOY/T5+zhPgWWl9Z/mrwh/rPhfiV + vxq88vqn0PrK8leT5/VVUR4v5K+O9Z/5/AuOV0L7tL5i/zn4wDR/M+4PSnh/3/vPiv7z5NlXpPyV + mP/8zt/w/v7DC/ErvqP98P0U8q8k4/7g9p+BTzfxCX7Pof6kr/+s5j8vPoyX7r+Wvxr9CfVFyb8S + y19NXgLP/Vnz9+1PqD8plL+S5OZvqD/58Jl4nL+h/uRzpDKfkOf5SP4V+M/Drw7fTyH/CvxnrP8M + 7SceL8Y38fdhJdH6Obn4/lH/WdF/HvzBf+b2V3wnH/pD8U3u+nzyn3375j+PesUH//kmHvKTEvwr + 7z9PHnzv8P0yUYqvuveP/vCfJy/A/17/efB4/z34z8rnZ8V38mG8NH/Nv3qvVyf/mXl8v+xU/1mY + h/VVqD/5HPHn0/wr+TH/2don/0rMv5o8r1cpfyXmXw3+d/9ZzX9ePI+X8lfbf/743/1nNf958bx+ + IP9q+88ff/CfO/M43hBfEeZx/Xzyn/n8oF8X9o+g/vN4sgD/efrMwQfe83fx3n9mn9Duv5sHnzC8 + f/TwSjzE9632zPyO7+Lh95zCfkqy93Emn5xPmPh5MNn3NBcP9aCeyz+P1/ZTNm/zN4X3cZLVk1k8 + 1JN5/hraz9w+PC8cfeBOPOynpPA9AqiHvPj1e548+5NWT2bzON6DD8znH65XRx+Yx4vxPfnA/ves + Lr4HH7hm4jG+Jx+4M5+AD/G1+9Hiod7XsR5yYh7Hy74K+MCLTzherrcJPvDi1Z5/tw+MPLcP9aCS + sq/y8EK82P334bmesN2PNm/33ySV/Wqh+Wv3o8nzeO1+tHhYbxzrIRfmE/DB9xa6XgnuhyYJ1yuh + 65Xdj4Z/+0s95MXD+3TjD8Qrj3fFd/JhvMrjPfnAwAu3f/KBK/A8Xu8D0/PRc8RdD8EHnn4v+1G3 + n7/gA09/mP1J20/ZPPqxoZ7b7eMLPvDkhXkfX/CBBx98M/OBF3/ygYFX5ld8J58DX5kHX+UW9kXN + B148vA/7/DX4xsLn5+QDg3/r56+efWDkE/HwvL99YOALt/+XD3wRD8/72wdGXpnH8fL77OADLx7e + d9awnwI+8OJXPmfyof/K5wd9s1VPBnnuv/eBw3iF+4++WdhPeY7489+db7b2U5BPxKNv1kN8ewk8 + +M89xLfT/DUfePKZ+5MDL8CHem7d33/BBx58iG+n+dtdfHv4Hn2n+dtdfNd+CvRHuf8rvsOXlnA+ + pTD/jXfU+/3FB558c753q/z7aVWJR9/75AMn5hPwv/jAi0dftH37oc34zP1B3/vkA/N4nQ8crs8t + ZeJXfCcfxqs8XvS9f6uHvHj0vX+rh7x5sfNz8oF9+9XF9+QDJ+IxvmE/Re17mptHPzbE13zgxaMv + +psPvHm4Xp18YO4P1BvZPjC0n5T4Fd/JB59Z+fys+A5/OFyfq3L7OH9DPZnnCPcf528J89fqIU++ + uPiGejJa/PM++MDlx+ohI9+Zh/GG72lCPeTF/+UDC/MQ37CfooXi+6cPTPF1+ylHHzgxjz6w8nws + wuPF9VXh9fN7hHkxfuVz7PpG+Ry1/ZS3Pyuf0433z0fgA09/uAa+Mw/r5/A9L80+vwE+8PCNeT9F + s3/+BR948OH6bPspi3c+sPL7OFl5vHohn7h95fF6H5jfZ8w0f20/ZfjPBx/Yj1f2fv3w/fj5Tu17 + N4tX9AND/0UDj35guL/Q8x3UC5XxV/490/Md1At9yF99ucGL+97NyZfzv09x37s5+nKJ+QR82O+7 + /fXnH/VCkS/Mj/F+vtkvvtziT74c+m88XkU/8ODLcX+WTzV4CeP1z3fgy01euP/C7cP3qo6+nG/f + fLnBR1+O4mu+3OQ5vhfF13y5ybPPc1F8zZcbfIjv5e8v25f7+FAP50rc/orvuz91hfheyuNd8Z38 + HG8FnseL34tcz3fIK/ErvpMX5oXHC9+L3L6c8d3fX7YvN7+PuZ7vkM/Ew/ciZX3vBniKb9/xHf3J + PfBCPHxvbtcLBT5z+xjfHvbrO83fvuM7+cw8xbe7+dvD/O3+/rJ9ucUr8zR/u5u/631P6I/Pz2xf + rn71Qvn7ofR8J23Hd/hgldun5ztp7vq86oUC7/Mz0tz1ufH6Qej5Tpq7PrfMv5+WK/Pf/WjWC+X4 + tsT9we+tr+c75BPx6/47+XA+ldtHHzK87wn1Qhe/7r/DDwzfe21+f0Tavv8O/yrs51aKb93338nn + wGfisR5sDT4GPd9tX+7j+XtG4MstHuodvXYcnf/qn9/Bl3t/D5W/Fwm+3OJhf+T5axgvxdd8ueHj + cX71NeiY/9aHw8f71v/AC49XbL9g+3IwXuH+wPtiUir/PgvFtzgfo4T5W/zzO/hyw8crfD8qJfBQ + b7CE+Vt8/g3qhU6ex1v8/qbY924GH+YvPd+Jfe9m8nx9Lj6/un25zw/kegvPkc48+oH8PQUpwu2v + 5zv5OdcL5XidfDnjs8/P/MOXQ16I975cqIdJ8WVfjus/0349+HL5x3w54DP3B57fJdQrk+zzq5Ix + P7N9OeApvlYvdPLsY2Tl8UJ+VQ71QoX7IzjeEF96vhOrF/qez8T5c0m0fk6YP5dU+H2NROvnhPlz + Ce97Qr3Qzdv+iIT3PR9eiUcfMnzvBny5zYv9/sP3boT8BPDlhl8X4puUzw/O31O9UB7vyZcDnq7P + 5ieMeqQhvsnn38CXG/5bmL/kJ4AvN/y6MH/V59/Al5s8j1cLt3/y5ez8a+b2Yf9awvuezxFlXux+ + F973BF9u8eCfSHjfU8hPEOcnHH25zDzWR+X8xnOE21/xlR/z5QrwwjysN06+nD+f53qhwNP8PdcL + RT4zD98XCH7Cc4T7A/Xoti+HfGIe1pMnX64SD+/zSshfCeWvoF7o5Dm+ojxe/J6ChPkrNH9lr58n + z/XGRbj9tX4e9SoP9ULt95zuUC+U52/KsH6ePNaTDPUWEuZXPz4hr8xn5r0vlwMvzMueL8d6oZV4 + 9IvC/TdlyJ9Pfs3fyYfxwvPRx4NPFe6/KQvza/5OPvRf+PxDPedjvVA/XvIDQ3zRD5y89wPn702N + L4155wfezIOfMHmsNxjqLaSUuT8rvugHQv9TJx6+l7H9QGhfuT8Y33D/TXj//XjwP8P9F+qFLl7s + eTCF+29KwuNd83fUtwzx1erPv/ve3NEPTMSDz/xrvdDNY/3MUE9SKb6uXvdbHTTw3D7OX2X/JOH9 + d/IY33D/fXhuH+O7/EDglc8n+p+qHC+F56PJr/k7+BBflco8jDfUW4B6oZN3vnoKvrrzAyeP8T3V + C+X2Mb7C33tNkhvx6PcuP7ABn5mH69W6/3bjE/cHr8/r/gvt0/XZ7r/3z9kP5P6v++/kZ7zQ92Me + r88nP7AyL/t+d/QDHa+2f4T1QhvwiXisl7L2j4D312e98f67/UDoT1HisV7K2j8CPnP/swDP+Y33 + CPHwvartByLP413xnXzw/ZTbh3rdrw3I7Qufn3V9HudHQv+F+wPrZ71qqFdZ3fVBrz1/h/8W6kle + fv7qtefv8Nk4f+X8wI9P0H6I75WZx++9Xpx/1ovie+HzkYb9I70ovlYvdPDKvuulPN51fZ487/9e + mplPcH4k1BcVHq805EP/Kb4X+tvaK+X/tfvr8/YD+1dflOdL9+vn7QdOH2B9bw74kpgHP6GH+PZ8 + E49+bw/zF/3Ajxfgw/ztfv28/cCPD/O3Jx7viu/k+ffWlc8n+ifLDwReeLyC4w3+Ce4ffTyMt4X4 + Nr++Aj9Qxl/599lo/jbnfzZ+/n2OdObB/2zhe+uN4tucX9T4+fetIMq8AM/7C84PnDzWkwz7R1Av + dPF6Ic/Xq+bXz+AHDj7EtwmfH2nIc3ybv/+CHzh8s1BPslbff/MDh/8Wrs+1KvHlQp59yOrXV+AH + vvGtnN/QWoT4kx8IfA48xLeG63Ol+Xv2A5FPxCuON1yfq19f/aNeKPAUX/MDx/k51AvNzMN4S1hf + FYpvcfEtIb6Frs/FxbeE+Vvo/nv2A8GXy8yf/EBoPxfmcby/+oGTR3+78PcyniNCPMY3fG9Oi3L/ + Mb6h3sJrDBIvON7gXxXh8w/7CxryV1AvdPJnPxD8NIqv7R9Nnn3ITPff7N6/ONULbcTj+xc51OvO + FF/bPxp8qEeXE/Pof2a9A8/jVbgfneqFcv8Vx8v5Dc0UX9s/Gufz4Acq83D/DfkrTbR+tvzV4GO9 + ULr/unoLx3qhnXn4nsKhXmjm/qD/GfaPNFF8LX81+EO90EY8vB+n4f1WTXR9tvzVqF8a4pu0Mm/7 + +xryV88RHu9aX00+jFe4Pyu+73z/rV7o5G3/aPCHeqE38VDvSEP+SpXmr7rno/C9m+dIJx6fj0K9 + BcX3Wz9e7HnwVC+Uxwvv45/qhSZuH/Ibv9YL3Tw87x/qhdL8dd+b2/VCzW9XCbwYL7z/+xzx59Pt + H+16odYfyl9BvdA+/srjlcLtw/7RrhcKPF2fbf9o1C8N81do/tr+0fCTw/tTkrh98K/e6yLzehO/ + 4jvqlx7qhXJ/VnwnH/ov3J8V38GH+FL+Cvznd//xDvv7t5+/4D8PPuz/3n5/AfznyfN+1u3nL/jP + 7/7pHfb378LtQz3Y7T8D759/xfJXg09cv/H2+wtyO7/u5vg+R27iV3wnz/7JrTzeFd93f/nm+fvw + 3P8V38mH8QqfH7Hfs4T3W58jbj5u/3nx9L7hc0SIx3qDK38FPMX32vEdPO8fCeWvtv/cnP8M/c/c + H9z/De+3Pkc68cnysXLx+urhuf9q+djtP2P9T24fvwe68lfAC49XGvSH56/znz9ejP+tXujkO+af + Jbzf+h4hfsV3+MPB36D8FdQLHXyYvz1z+1hPsvP+kXSfn4R6oeg/A594vJB/lvB+q/OfJ68X8qE/ + yu3j/n6X0D7Ft7v4hvdbBd9v/Xi7/0qroV6lXz9Lc/5G+N6NUP5KmvNjW6h31Hx+QxruH722c+CF + eKgfIuF7N9Lo+txw/2j7z8An7g/sD+56ochn4tXy7RLeb4V6oZuHelbh/VZpyv2XhrxwvITPD+zv + H+uF+utJxfWzhPdb3yPEF8u3S8hfOf/549EH/qVe6OKxXtmpXii3j/5VDfO3UnypXmiYv1V5vBjf + yusrqcr9cf5zuP9W4fYFxxviWym+FfcX3uqgdH6Kzz+D/zx86bC+KhRf858nz+ez0PXZ/OfhV2fa + zxLKXwX/mX3yQvffgvsLz3I+tJ9u4k/1QuH8JO6/Xsjz9aFo4MEXPdQLpfnr3m/d/jP0X3i8K3/1 + 9idz/vk54n9vLn91rBeaiYf8lYR6ZUL5K/CfBx/mb/b7v+A/T57f1yD/Slz+SsL7rZIpvtnF91Qv + lNvH+Ib3W58jfD6xHuypXmgjXnC8Etqn+6/5z8MfPtQL9eM1/3nw4fqcKL7JxTd8r1kofyVULzT6 + z7S+cvmro/+szItdH0L+Sih/Bf7ze/05+c/cH4X7UeL6IZKUx4vX51O9UObx+nyqF8rnH6/Pv9UL + nbzi/v6pXig9H7n81fafwdel9ZWrz3asF9qJx3qSmvn3o5n7A/6VaArt+/0FcfXZtv8M/afrs/Ov + jv5z4H/3n+n6fPaf0ZfOzFu+7ug/+/Mv6Nf94T9PHupJPn8NPjPN3/9eL3Tx+H6ZhPWV5MAL8L/U + C118wvGG+6/Q9Vl2fEf/Qz1nofiKi6+E90NFuf+4fhb2N6Be6OYt/5zC/df7z5f5z9NPC/df7z9f + 5j8vPrRfuH30Y0/1QoV4rK+YeX/wNaKZF+ATf18b3z+aPPqTmeOb8P2jycP8PfrPiXnw69b913w5 + d/+9zH9efOb+CJ8f9GPD/df7z5f5zx8f4ptwf/8y/3n66qFet/efL/Ofp2+feH8hpcw85K9SqNf9 + HOH+Q37jWB+V21/zt/wc66MmHu/Kbwy/OviTSbl9yD+f6qMqt7/iKz9n/7kwL8b/Xh/15c1/Hnz0 + n/H6fJn/PN4fT+H+m9z+0WX+83g/PYX9o4TvH00e3t8/1kfNzAvwiXyb50gjfr2/P/qTNPBK/Irv + OD/sT7r6qB9v+edTfVTh8ymWr0vh/uvqo368GH+qj+rbd9+bS+H++xy5iYf8cxJ+f9/7z5f5z3P+ + rvsv+szcfrb9srTuv8gr8wLth/cX3P33Mv/543n9/B4hXi/k+fcsdH0WzE++1VADz/2XhjzH1+0f + Xeg/D183+Bu3n7/gPw8+1Ge7/fwF/3nyof1SmYf9wUN91NyJh+vz89cceGEe9kPvFNr38QX/+e/6 + qJPXC3n2kW4fX/CfJy/MC7cP6+ftPyPP44X3F3Z9VPCHKb7mP7/tL/8ZeSEe3l94+Mx8ycwn6M+X + f0ZeiYf3j3Z9VPSfuT/w/tGujwp84vF6/zmMl+Jr/vNoP/iTl7//6p/+s3L/Bccb/LpLAg/j7TX4 + t359Bf5zGX/l+dL9+hn85+FLB7+u++sz+M+TV+6Pvz6D/zz86hzaz9z+iu87fzvnr54jF/HwPZTt + PyOfiF/xnXxlXvl8Qn2G13YevF3fnP98/ct/Rp7H6/3n4BtTfMl/Dv5k8+tn8J8nz99bb359Bf7z + O38P9VEpvs35dS34Oc2vr8B/HnzwJ1vi8aJf15TPf6P5a/7z5NlHasrjRb+uCd/vmvL5XPnJ4YdL + aJ/mr/nPw7891Ef159P85+HfBj+n0v23Or/95D9n5g/+M/JCPNY3DvtHWv3zEfjPgw/+VU3Mox97 + qI+qPF6Mbw3xrXR9ri6+4XtzzxE+/9KQF+6P8PnB+pmF93+fI779gvnnY33Ui3isT36qj1qZh/EW + zj97//lC/3nyPN5C12f3vbmj/8w87C88f+V4lZSJx/ie/GduH+N78J+Fx4vxPfnPfD5P9VHRf/bx + PfvPdn3OhXmMbw7330zz9+w/o898Ee/9Zx5vpvXV3/4z99/7z8H3Vu4PxvfkP3fmf/efKb5/+888 + Xu8/036H958v859n+wf/mdZX5j9PX5rHm2h9ZftHgz/4zxfxa301/Oqsgef+4Prq5D9z+1D/SsP+ + kSZlfq2vJh/GS/df2z8afIhvovja/tHkOb6J5q+rn3P0n/3vzX1v7uQ/0/rK9o8mz+PF7/t8fAI+ + xFfp+uzq52ion6NK89f2jwZ/8J+5P/h8dPKfebz4fLT2j8BPpuuz+77P9p/RZ+bx4vPRyX/m/oCf + s/1n8G8pvoL7C3/5z4OH+htH/7kwb/tHR//5Jh72j47+c2VegA/xlcT9wfyGhPiK8ngxv/GH/zx5 + HG+Yv5S/Uts/mnwYr3D7sL+w/Wfbj759fMF/njz7RZS/khvzG7v+M/KZedgvu8P+4O3nr9zOr7vD + /uDt4yu32/+9w/eabx/f7T935z8jn4jXC9rX0H/l84l+3fKfgRcer+B4D/WfhXkY76n+s4+X5a8m + T7+f14gmHvf3w/d9vP98mf/88TnUl/bzV1z+6ug/K/MCfNj/vfz+glj+avAhvlfi8SqON+zvu/f3 + L/OfP57nr1D+avvPiw/+tgQextvD/O0+Pynd+ZOdr88PL8RDfYaHD+1TfLvzJ3tmn7z7/KR0vP9K + D/HtmfuDfk4P8e3++VcsfzX4EN+euD96Ic+/507z1/JXk1fmff5ZLH/1L/85M2/rSQnf9/H+8/gX + v9ccvu/j/efxL6yfpYX5S/krabh+lhbi2/z+gjTn17Uc2qf56/JX238GnuLr8ldvtWfmlce7no/S + +Cu/n9J8fkMsfzV8aV5fvRWhiV/PR5Pn+duExwvv77+2M/GV5q/lr0b959/958v858WzP1kLt7+e + f9/fZ+X11cMr8Su+k+ffW/XPR2L5q8Ef/Oeb+BXfyfP8ovyVWP5q1K8++M/cnxXfwQv/nqvyeFd8 + R71r4esP5a+2/3xPXzfcfyl/tf3nj4/+c03Ez/gunsdbSuAT8sL9ofm78lf39IFzqJ9M1+eVv7rH + /Ar5K+8/X+Y/f+2H63Oh+K781eIpn+P958v859v5z1BfWrg/guM9+M+VeTH+D//5Mv/5/qf/nIhf + 8/cePK83cuH21/wdfPSfaX1l+avrx+o/I6/MC/AhvpnWz9nN34P/rNyfNX8nz/58puuz5a8GL8F/ + Vu7/mr/tx+o/o/+cmf/GO/zeMH8pfwX+8+T5ekv+FfjPgw9+bKL5a/WfJ8/9T35/Qaz+8+BDfJPP + P4vVf37vX8G/eo7weGF/QYJ/5eo/Tx7vv+H71EL+1fafP588PB9R/mr7z1/7Ib5J+PxgfW/l/X1x + 9Scv85/n+VH+vq33ny/zn+f9/eQ/d+YT8KE+MOWvtv+8eOH+0/1Xd3xHvejE3/tQmr+64zt45e8X + KF2fdcd39OeLbwM+MQ/16lf+CnklXizfLit/Bf0RPv/4/oKE+AqtrwT3j7b/jHwmHuu3r/yV9V9o + /gruL2z/uRtP8RW3fpavvgry3H/YH9z+M/TH5ye3//y1H+avUHxX/qp/vjTPX1FuH7+/IOH6LMLt + C45X+H0rET7/EN+Ua/CBMb4d/edRLzr6z7h+7ug/t/HXHPjKfIL2gz/p3j/q6D+Xnz/9547+s/xY + /WfwjROPF/KTKXxf7+ET8frlJ0f9avZzniPcH3i/+y//uaP/PHkJvDAvxieev+8Rx5P/zPUJk9s/ + 6lj/+T2f6/4LfEnMYz3kzOcz4fq5Y/3n4Q8Hf9K9f9Sx/vPg2b9K7v7b/1X/GXhlHvJX239GvjGP + 9a6V/VtXP6eb//zxIb6J4mv7Ry8f7r/JvX/UzX/++HIzX27i8f0F5fqT7xHmLX+1/WfgM/cH52+4 + /3r/uWP958Gn0P/E7UP+6vlraF+ZX/EdvrSG/iuPF76vkdb9F/1nPp8rvqM/vL7y/nPH+s/Dpw3v + LwjNX9s/Qv8ZfeaLeHi/e9d/Rr4yb/tl238GPnP7vv4zn3+h+IqbvxKuz/j9hclDfaQkYf6694+6 + +c+LD+PVxDzWu5bghyu3Lw35MF7h8aIfe4f6oq7+czf/ee4/rv0j5JV49CfvUD/2Ltw+1je7+frs + /edu/nP/6kWz73rnxLzs9clrOzOfGvHob9yJ/ZPbz9/tP09f6w71Y2/l9rE+Yfh+6HOExwvPR3/5 + z93859n+FfzJy1+f9cLnX734+cj7z4OH/OT2n4EvhXl73t/1n823uSi+F+Ynt/+MPPcH8pN6JfY5 + L3//1WvH9x5/ZT/kUj4/avk6DftHvv7z5BPw/Pz7HOHxQv5q+8/I83ghf6Wd8xvef+4/23/++OBf + dX//3f7z4vn33/36avvPHx/qA3d/fd7+88g37vrP0P/M7Wccb/DreuLxJsvXaQ9+bPfX5+0/f+3z + /u9zhPuz4jv8c/4+3XuE+BXf4Z+H/f0u3P8V37f9VtlPaBTftuM7+PB+SvP33+0/Lz74xqUzn6z/ + jb//+xrRxGcY78l/TswL8Ly/7+s/d/Of73G9WvWfkc/Er/iO9g/+c+BxvBL8cOHxrviO/oT524T7 + LzDek//s+brjO/gQ30rxrTu+k+f5W/36efvPH8/7+8+RTjzG94/6z938548P87fS9bnu+A4+xLcq + jxfjG/aP3iPM43jD9bkq9x/nbw3xrRJ4GG/YP/L+czf/+eNDfN3+UTf/+Xb1n4Gn9ZXtHw3+9/rP + 3fznxfN4nf/czX++/1n/uROf4HoV9o/eitDEK4739/rP3fzn29V/TsBz+4LjDdfnQvEt7vp88p99 + f2z/6L3f5RBfyl9t//l2/jPyiXlYb5z855v4Fd/Jc3wzzV+3f6Rh/0gzxdf2jwYf4kv5K/CfJ5+Z + Vz6fa/38rt9ymL9Zuf/SoP0wfzNdn23/aPi0h/rPnrf9o8Ef6j/fxOP6+eQ/V+YT8L/7z93858Xz + 79m9v9/Nf57r/z/qP3fzn2c9+fD9socX4vVCPoyXrs+2fzT4MH8TzV/bP8o/5j9Df4THi89Hf9R/ + 7uY/X18951j/+SIe3184+c+NefD5D/5zEeLx/YU//Odu/vPHH/xn7j++n3LynzPxK76TD+Ol+Nr+ + 0eT5+UuV+y843nB9pvyVuv2jo//s42v7R29//vCfB4/vD/5R/3nyMN4/6j8PHuN78p8z8zje3/3n + wWN8JcRXlMeL8T35z4l5HG+YvyJ8fqQhH8ZL89f2jx7yr/rP3fznj4/1n318t/+8ePZzKH+1/eeP + j/WffXy3/7x4CXxmHsebQv8Tjxf3B2+Or/efu/nPi/+1/nM3//njOb6+/nM3/3nxYbx+/srt4nsF + v+7y62e53P7vFeJL+Su58Pp89J878zDeK8T3ovheLr5/+M8d/ed3v/Xi+SsXxdf851nPOYzXz1/w + nycf2tfKPOz/XsL1xil/tf3nb7whvpS/2v7z5E/+s+9Pd/HtvH729Z+7+c+L5/3uTvHtbn+/B7+u + +/3f7T/P/fo//Odu/vPHh/nbE/cfvn8kPdT37v7+u/3nxfPv2dV/7uY/f/yh/vNN/Irv8MO//X3k + ebzoX63398GnpfnbcP286z+Dr+v3F8Te3588X/+bfz4Se39/+NWhfnvz6ysx/3n60sK8Xz+L+c+D + //JXwNP8bZiffP7Kfmyj+Wv5q+FLh/g27cyDP9kkjFd5vGL5WFnv70P7Enh7/pUa4lspvpa/en8P + NcS30vXZ8leT5/hWiq/lr4Yvndn3rnR9tvzV5IPPnLk/K78xfeYw3sTtr/hOnznUf07c/orv8JMP + /jOPd8V3+syx/nMnfsV38vP3jP6zMi/Gr/f30X/27X/5qyTOf0Y+ET/iu/lQX7oEPk3+/X2G/NXD + K/EjvpsXOj+F5u+Xv3r44Q+H+2+h+fvlr1b/U2if4vvlrxYf4luUz6cm4EN8i88/L/959T/cfyl/ + tfznj8/h/kv5q+U/Lz6srzLFN+/4Tp7HS/7V8p8XH9ZXlL9a/vPmebzkXy3/efEhvjnxeBOON7yf + kun6nHd88/hr8KuV+7PiO3jOX3n/uW//efNzvHZ9yxJ4sd9/CuvnROurtOM7/OEQX/Kvlv/8nZ+Q + vxLyr5b/vPgwfxPdf5OL78l/DjzE9w//uW//efHh+kz+1fKfN8/rScpfLf958SG+iebvyl/N6+3J + f+bzj9dnZT/nOeLjq/v+O/jw/oLS/Vf3/XfyPF6l+Oq+/w7+4D934tf99/ox/xn5wrzY/Xrlr4BP + zMP+4Kn+M83flb+a65mVv0K+MZ9svRT8K3H1J7v5z/d/qf/c0X8e/u2h/rNv3/JX7/k81X++icf1 + s/D+oPefO/rP7/mXEF+h+Ip7f0FCfIWef8X57RLiK4nbX89Hoz8hvkLPR5a/Gu0f/Gce73o+GnyY + v6Lcf3w+CvUnvf/c0X8e/jDff73/3Mx/vma9aL4++/rPzfznxSfm8fm3mf+8+Pk8osbj/beZ//z1 + /3s/FHll3uK76z8Dn3i8EN/nr6E/icer9nve/jPwyuOF94+2/ww8Xp+b+c9ff/j++xypzIvxifOT + yb1/1Mx/nucn3H+T+35oM/95nv9w//X+czP/ecY37B8lt3/UzH++nP+MvDBv+asU9o+eI514yF+l + cP/19Z8b+s+TD+PVwjz4sYnr13n/uaH/PPovNfCZectfJeX6ZsnVz2nmP8/zqfx+ma//3Mx/nr+H + cP9NWrh9eL/stZ0HD35vbsTD/uDRfxbm4fe8/OdufKrEg1+36z/fxiuPd83fwX/xRZ77rwn6w/ff + 5wifH2lwfg7+szJv+4Pbfwaftvrxirs+/+E/N/OfF58D35m3/dC//Odm/vPX/sF/TszjePn9I+8/ + N/Ofr+lXf/MXeL2JV9tfSOv+izz3B/LP239GXoiXBu1/8bXfp1B87f6L/vNu/zni+q+2f/TuR6/9 + I+B9fPXG67Ou/SPkO/MJeQm8EA/3X137R8DnwrwAn8J4E/cf3h/c9Z/RZ2Ye1le7/jPyPF6Yv9t/ + Bt7ff8F/nnzm/ktiXvb9Xa/gt18U3wvXz6f6zxRf2z8a/nCI7+Xvv2r7R4PPfP6vzP1BP+fKhfuT + M/Oy87269o+w/nMjHt7f1/X90H/Uf57J52s/77y2c+C5P+hfXSG+lyrx6/lo8sq8FOa/8Q6ftoZ6 + xf7+C/7zrM8c/eeLeMg/H/3nxnxCXpnP3P6K7+CDP9lp/pr/PPhD/edKPPqxh/rPyv1RHC+/f+T9 + 54b+8zsfe4hvp/ia/zz5MF7h/q/4vnzj7y88R/z5Mf958OH9Bbd/1NB/7oPn+Lrvhzb0n9/rQ+Pn + X3X1cxr6z5Pn8TZ//wX/efDh/ZSWuD/J8jm6vh+KfCZeL+DD9bn59RX4z4Pn9ZU2v34G/3n0n98/ + 0iZ8/iF/tf1n4yvN34r5q+0/g2/sn3/Bf75+zv5zYh7iW8P7C5Wuz7Z/NPoT6vPXzO3D/tH2n4Gn + +Nr+0eDD/K2J29cLeb4+VA08jjfMX/f90Ib+82g/xLdSfG3/6OVL5d9z8etn8J8HH+JbqhCP87eE + +Baav+Y/Dz7M31K4/dyQ5/lbKL7FxbeE63NJ3J8E16sS4lto/pr/XH/+9J8b+s+Dl+A/C/MrvpPn + 9y+KcH9WfF/+5D/78WZ3/z3Vf76Ix/cXTvWfO/Pg8x/856LE4/sLJ/85Mw/rjZP/zP3H9xdO/jO3 + rzjeEN+sfD7x/YWD/yzcH8HxHvxnYR7GG+rnKOWvtv8812/r/X3gKb7JxTd8P9TXf27mP8/1Z9g/ + 0uTzG9t/Xnzoj89vbP95rodTmL+Uv9r+8+JD/5XPD66fw/fLvP/czH/++BDfJDzeFd/Rn7C+SsLt + 4/uDYf9I3fv7zfznxXP7WhPx+P5CyF89RzLz8P5C+H6oKt1/Ff2c7T8jL8wL8GH+Kl2fXf5q+8/I + 83jX8+/1Y/4znB/l8UL9Og3fD/X+c0P/uf+Y/ww83X8V88/bfzZeKL7i8hvC/sbDK/GY3/ij/vPk + Ib/xR/3nwWN+4+Q/C/MCfIivJO4Pfl9DQnyFrs+y4zv5zv2h+Svu/QUJ8RWav27/6C//efI23mP9 + Z9c++M/v/uZd2F+6fXzF5a+2/2z7a85/bug/j/YP9Z9v4mF/4eg/C/PfeOVn2M7M+/sv1H8e9a45 + vg/P49ULed4fvH18of7z4EP9Scpf/Qf/uTAP471CfC//fAT+8+AP/nMmHv32k/9cmEcf+OA/c39W + fYbJ83ivXJkX4IM/eSXm0W8/+c838Wv+Dt9b2Q90/nMz//n6V/1niu+14zv5EC/h9mF/QTp/X8PX + f27oPw//NtZ/9usr8J9H+yG+3a+fwX8e7Wf2hbpfX4H//B/qPzf0n0f7Yf72dBOfcLzBv6L8FfjP + /6H+c0P/efBh/nbl/sP99+HZR6X8FfjP/6r/7Pnm/I2D/0zxNf958sHXpfl79p+Bp/ie/WfkM/MC + fPBjKX8lzfvPYf42v74Sy19NPtZ/Djz4OS3M3yY83rV+nnyIl3D73n8O/rB/PgL/efBh/la/fhb3 + /r7UEN/q88/i3t8/1n8W4uH591j/OfACfOL7e03cH8hvSHh//60ITfyK7+TDeJXPj1o+R2p4f6EK + 92fFd9aLFu6PcPsrvi9favCT6fpcnF938J/LTTz6deH9fe8/N6z/PHnaX5CSuX3IT0p4f18ofwX1 + nwcf4ltofVUw//xX/eeG9Z8nH8ZL12fLX00+jFeYH/HdvrQEXpiH+J7qP/v4ZsxPnuo/0/XZ8lej + XjHXN/P+c7P6z9NXzLy///BCPM7fzPuDQvkrybh/JKH+5HOE+4P+ZOb6dd5/blb/+eN5f0HIvxKX + v5JQf1LIvxLLX6H/jDz3H+t7h/qTzxHffsL8xvafLb6UvxLLX8n4a+b2fX5DEuY3nodLrt+baP5a + /mr6z6F9mr8uf7X9Z+Dp/pvc/TfUn3x47v9aXw0/OcQ3KZ9PrM+fQnwTra/s/f3Jh/4L9wf9WK2h + vjGtryx/JeOv3H/yr8B/HnyYv0r3X8X9fQn1J4XyV+LyV8f6z4V5WE+e6j9z/6H+xrH+M/cH8lfb + f0Y+MQ/12zXEl/JX4vwr+aP+c0P/efi3B//Znx9Bf1JC/srXf27oPw9fN9x/he6/4vIbEvIb4vcX + wH+evDBP6yvLX73rz5C/eo7cxOP3UyTcfyVxfxSe9//wnxv6z4Pn/NXDc/8FnvdP/jPHS+x5P2V+ + /n2OwP2iYv3nwUf/GedvxfrPk2c/M+P8reg/y4/VfwY+c/vwfncK7x8lVz+nov88+ODHuvo5Ff3n + ydP5fI8QD/mNFPaPkts/qug/D57j+xzh/khDnv3VjOvniv7z8I05/+zrP1f0nyfP/XffX6j/8p+B + x/tvRf958Dx/k3v/qKL/PH1pjq+r/1zNf54+5Ml/5vHC/E3h+wspJe4Pxje8f+T952r+88fz829y + +0fV/OfF8+/N1X+u6D9Pn5mej54jt+Nd/ZwU3j9KSvE1/3ny/Ptx/nNF//mNl+bQn9yIx/cXwv5R + cvffiv7zaJ+vz0kT9wfe39/1n5Hn8eoFfIivu/9W9J8HH+avCo9XGpzPg//M44XvayTh9399/eca + /OfPby/AJ+Kh/tWu/wx8CTz47eH+m4Ti6/aPtv8M7dP8dftHKdx/kyQeL+Qnn79yvEQv4ld8R/95 + fzCJ8ngVx8vrq/cI8bC+ev4a/Grh8cL6Sm9+PvL1n+sP+M+Tp/i+R4iH98u2/2z7X3cpzEN94Jvn + r94+vuA/T57rkbr6z5OH/d877O/fifuD+7+3sg92+/iC/zz50L7y+cH6wLcK83ITL5af1Jvnr/ef + Jy/GXyG+V/Xn89rPR4MPfo6rnzP49Xw0efYJLz9/9drPv8M35udfvTL3B55/n7+q/z3r5eevnv1n + 4NNNvPOfOb/xHOH+K4437O9f2pkHf2PtHwEvPF7Ib+z6z8hX5i3/vOs/g0/rr8/gP0+e52/36+fg + P3M98+7XV+A/D783+HWd4vu3/5yYt/zz0X++iUf/6g//uaL/PHn+PXfl/qBf10N8u3B/BMcr7Cd0 + v74K/jPzza+vgv/M420U34b5yb/854r+8+Cj/+zXz+A/j3rIB/85My/Ap9D/xP1Bf7KF+Da/vgL/ + efLsuzaKb8P9BW3C74M05fbF9heO/jOPF/LP23+2/lf//Av+8+S5/erXz+A/T1+af8+Vrs/sPwcf + mOJbnd/+h/9c0X8e/MF/vohPON4Q35q4Pyu+kw/jVe4PxvfkPzfiV3zRf27Ac/s4f0u4/xa6/xY3 + f9f+EfA0f4u7Ppcvv9GAT8yjD/zt/wKfuT84f0uIr6ufU9F/HnyIb6H5W3B/YfvP0J/E/cfr89o/ + 6sZr4F3959C+8Hjx/ltCfItw+7i+WvtHxme6PmfnT678lfWf8lf/qP+MfGb+UP8Z+kPzNzt/Mn/7 + C9C+f/4F/3m0n/j3Q/kr8J9H/0N8KX8F/vPkE/PamMfxhvmbhc+/4HhDfLNwf8Df2P6z8ZS/gvrP + gw/vhyb//Av1nyfP400+Pwn1n0d9af7+oK//XP9V/xna9/nJf9R/Bj5xf/D90BTiS/mrf9R/hv4r + n0/8Ps7KX0H7wv2B/Mb2n5HPzIvxGuJL+St17+/v+s8V+Ey8r/9cuX2Kr+WvRn/C/VeLEg/1JzXs + H3n/uaL/PPhwfdbE40U/Nuwf+frPFf3nMd5D/efAY73rsH6m/JXa98uGjx2ej1R4vGt/4Z1ff9R/ + fnj7ftk7vw7+M12f7ftlk+f8hvj85Paf+/Sxg98udH2W7U/WwQv3n55/ZfuTgz/4z9z/5ccOXsN4 + 9SZeL+TDeOn+K9uP/Yf/rDzeFd88+NA+zV/bPxq+cfi+8+3nr9j3y4ZvHPYHb79+Fvt+2eSj/5yZ + H+Nt0wcO9ZFuf33e/vP4Pub2n9GX5vZnfD8+7A9S/mr7z4vP3J/E41Ucb9j/vZXbX/EdPM/f5wiP + d8V38hJ4YV6Mv8L+70XxvXZ85cf8Z+Qz8Rjfq1TmS+C/8Q6/N8SX8lfgP0+ex3v59TP4z4MP/obz + nyvWfx48X58fnvu/4psHz/G9lPuP8Q3v7wvlr7b/vHgJPPd/xfeNV+fno+eI//10F9/O99+HT8TD + 92Efnvvf/f13+8+z/52/P/gcuYnH+Ha+/z5HlHmIbw/+Rqf523d8h/8c4tspvn3Hd/Kdfm9dK/MJ + +BDfLnx+4Pos4f19ofzV9p8n38L8bX5/QdqO7+DD/G10fW47vpPn63Pzz7/Sdnwnz/1vhduH78NK + yF8J5a+k7fiO9kP9uubXz9J2fCfP1+fm77/SXHybRp7Hu+Jbx1/Zn2zC/VnxbeOv4XwKx2vFd/i3 + XJ9Bql9fbf951p+vlftT6fpcd3wHH+JbC7e/4jv4cH123y+r5j8vnuNbM7e/4jv4cH2uiflU4Pxw + fZWH5/Eqjjdcn6ty+4rj5fykUP5q+8/9q/9M+ynPEe4Pvn8U8lfPEX99Lvh89PxVA5+Ih/39Xf8Z + +BL4hLwEXolH/yrkr94jzAu0H+JL+avtP398uD6XxP1Zz0ejP5zfeI5w+1ifv/D3f4XyV8t//ny2 + Eu6/heZv2fEd/m2Ib6b5a/UnJ8/tU/5KrP7k8IFDfJ3/XM1/nu/jHPznzO1DfuPoPwvzsvMnEvJX + 3n+u5j9PPzOH+Gbl/qz4Tj703z//istfbf/Zrj/kX4n7ftnRf1bmLX8lf/jP1fznxQe/l+Jr+avh + Awc/lvwrSc6PTZyfFMpfieWvRn84f/Ua0cxDfFf+qhtP8bX81eQl8Er8iu/gv/l7GU/z1/JX7+9z + 5a+gff/8C/5z/bH6zzBe4fGiHxvyV6J+/0jU+bEhf+X952r+85zvJ/+5Mg/XKw3xJf9KXP7qL/+5 + ov/8zpdT/eebePw+zqH+s89Pbv+5O/8ZeOXxquVz5FT/mfsjsJ481X/m/uD6OeSvniO+fctfDX84 + +s8UX3HPvyf/uTOf7Hnq4D9TfGXnN4YPfKj/LMxDfuNU/5n7v/Ibo351iC/lr7b/3L560fx7pvzV + 9p8/PjwfifD5kW+8wz8P12cRHq/I5lPYP3qNaOOL+c+Lp/afI0p8sfGm8P6Rr/9czH/+eJ6/vv5z + Mf+5zfrJmX0z9/5RMf+5TR870fUwuftvMf+5T/9Zub6ou/8W85+/9kN90YzxLeY/f3yoL+q+v1DM + f/76w9dn7z8X859n+6mSP+P952L+88eH+rHu+wvF/Oc26xuH+Lr6z8X85xmvxOur50gnHuOb+Pr8 + HOH+r/h28J/Nb0wU37TnbwP/GXnu/4pvHXw4n8rnB+ZvCu8fef+5mP+8eI6v85+L+c+TD/ffpDR/ + 1c3fcP/19Z+L+c9t+sm8P5iU4qs7vtN/5vnr9o+K+c9t+sDBj9XM/V/xTeA/A59u4ld8B/89/6L/ + nIlf8Z3+M78Pohr4BOcn1Pd2999i/vN3/sP7C0rxVRdfqZRP8/Wfi/nP8/cvob63UHxlx3fUNy6R + L8zb/ffoP9/E54a80PmUzO3D/ffoP3P/E443UT7nRYlXuF6J0vPIcyQzD9dnYT82uftvMf/544Pf + LhRfwevz9p/Bp/XX5+0/j/7v+s/gS/v4bv+5Of8Z+c68Xa807B89vBKfG/KVeX//1Ruvz3qn4DP7 + +atu/+j5q/jfg7r9o2L+88eH/cFbuT8rvoMX3h+8/fV5+89f/0P9q9vHd/vP8/xcvD/4HHHzVy+8 + Pp/8Z4rvteM7+eADF25/xXfy3P/L33/1wvvv81c+n5efv3rh/NUrsT9/JW4/2XpD1/4R8MrjhfXV + 81f+vbn9o8nb9Uovrq/yHiEe1lcavh/6HMnM2/6Rdv7+4HPE96fj/q+G74c+vBIPz0e69o+A9/df + 7bg/qGv/CHh/fVa3f7T9Z+S5fdg/2v4z8KkQD/sLuurnoC8txKvtL2z/GdpX7o8maD/M3658PqUh + H8ZL8XX7R9oqn89G12fbPxr+cLkDn4lf8Z3+c2We4ttwf0FX/RzklXh4P3T7z8DnwAvwXH/D+8/F + /Ofpz7Qwf1vi/q/81Wg/xLcptw/v/+76z8DT9XntHy0+B57HC/sL2382vtL8tf2jWS+az6f7fmgx + //lr/1D/uTAP463Bz6l0fa47vjr+yufT1c8p5j9/fJi/le6/1cU31M95jxC/4jv50B+av9X5VzXE + twr3R3C8Yf5W4fOJ39coIb6F5q/bP9JQP+fhM/Ho14X6Od5/LuY/f3yIr6v/XMx/nr+HUD/H+8/F + /OePD/Eticeb4Pe89o/s/lX0Jl4tP6nh+6Hefy7mP3+8tMAr8ev6PHlhXvj8wP6vhu+XKeWvNDu/ + Lry/7/3nYv7z4nm8meKb9/V58KG+aKbrc9733/Zj9Z+Bz4EX4FMYL8XX8leDD/OX8lfbf573rz/q + Pxfznz8+xDfT/LX8Vfkx/xl5Hu+K7/B1Q3xT9dfDhP6Ghu+X+frPxfznxXN8E12fE/ob239W4zO3 + nxvyEnhhXmy9t/JXwCfuz4rvO9/D98veI8Sv+E4+jJfmb8LnXw3v7yvlr9TyV8MnD/FNtL6y/NXL + a4iv85+L+c8fH+JL+StVzD/v+s/IZ+bh+VfD/HX7R8X855H/+av+czH/eeSXjvWfO/Hr+WjwIb6U + v1LLX01fOvrP3P8V38EL/55VuD8rvtOX5vhS/kotf/X+3k71n/3v2fJXgz/UfxbiZ3zr9KsP9Z87 + 8wn4WP+Zrs8rf1WnXx3mr2Tuz4xvnX51qswnHu+M7+JD/xP3R7/xov8M7WtlPgEvF/M0f1f+6usP + f1/yNaKZt/Fu/9nqhVL+avvPoz+7/jPwfv5u/3nx2Z+f14hmPkF/Qv3JO3P7uSHP+5u3j+/2n8fv + 4S//uZj//PHK+4O3X19t//nrT9j/vZXbVxyv3Mz7+G7/uU4fO+wPUv5q+8+TD+/ve/+5mP88+3OF + /V/KX23/efHBr/bX5+0/z/N5hfqTl78+b//56//BfxbmIb7LfwY+8Xgxvn/Ufy7mPy8+Bb4zj+Pl + +69Q/mr7z9/5FJ4vl19fbf95tt/5+6HS/fpq+8/zfPbK/af81fafP77Q9crXfy7mP8/+9zB/O8W3 + u/nbc+gPxbe7+J7qPxfiMb49xLf7++/2n7/xHuo/V+YT8CG+XXi8OH+71MDzeFd8Rz3kQ/1nf/7b + ju/kheJF+Stpe30l719DfCl/JW2vr17fo4X4Nopv2+uryfN4m3/+lYb7g9t/hv5QfFf+avEcr+bX + z7LyV2360iG+TXm8a301eWVe+PyLrSel8frK+8+TF+Mr55+9/1zMf55+yPKf7fpc6fpccf38/JXr + D7v6z8X854/n5yOpPv+8/efFc7wof7X9548P8a2J+7/iO3mOV1Xuj9r+0bH+M59PeD6Slb9Cnvu/ + 4jt5nl+Uv9r+c//8Zz6flL/a/vPHh/rtheJb3PspJczfQvEtO76znjOPt/j85PafF8/jLRTfgn7O + 9p+h/cTjXfHF+s/Ic/t6IR/GS9fn4uK78lfA0/23uPiWEN8i3H/Y/93+s/GZ4pvRz9n1n4Gn+GYX + 3xzimym+2fl1uXD/yb8Sy1/p+KsGXpn/fs/v9Tan0H/v54jlr/KP1X9GPhOvtn/0Vntmnq7Plr8a + vESe+w/5q+0/Ay+BF+t/CvFNtH52+StJIb6UvxLLX6Uf85+RL8wn5DleyT//SnLvH4X8lVD+Six/ + Nfgwf8m/kuTiG/JXkhK3rzjeMH8pf7X9548P12fKX23/ef7+Q/5KknD7eH1e9Z+NV5q/ivu/ouH7 + R+77ZcX858Xz/Yj8q+0/f3zwYyl/tf3nxUvgM/MCfIgv+VfgPw8+xFdpfWX+8zifoT4w+Vei7vqs + Ib5K89fyV8Ov/t1/LuY/f/5teL9baP1s+av393+q/5yIB79OQv7qOdKYT8D/7j8X9J8nz79nofWz + YH5y+8/AJx4vrp8lxFdofbXyV+2rF83zl/JX4D9Pnq8/IjzeFd/Rn3B9FuH2V3xHPWF+Pkru/pvR + fx787/WfM/rPk0+Bb8wn4GP9Z7w+Z/SfJy/Mo7+R0X9OP+Y/A594vCu+efw19B+vzxn958Hz+tn7 + zxn958EL+4Tu+wvZ/Oev/8Gvc/VzMvrPD7nrP4PfS/FNmH9O4fsL3n/O5j/Xz5ee40X/OfAJeH6/ + 29d/zug/j/7w+2UpUXzNfx58CnxqxCfL55zqP+P8zeY/Lz4FvjKfgA/xTXIRD/mNFL4f6v3nbP7z + yM+k8P1QX/85m//88Xx99v5zNv958eyjuvtvNv/544Mf6+6/2fznxfN43f5RNv95np+T/9yJx/iG + 94+Su/9m858Xz367Ko9X4fcc3j9K7v6bzX/+2pfMvPB4IX+VpHL/heavuOuzfPkr88+l3MTj9flU + /7kzn2x+rfsv+MOZebw+C9c38/WfM/rPg0+F+cTjTTjeFNpP3L5e0P/f6z9n859nvETCeGn+iovv + uv9Cf4T7A/sLf/nP2fznOn3p3/3nbP7z1/7Bf07MJ+Q18Eo8XJ93/WfgM7cP8d31n4FPlXiIr679 + I+S5fYivhv2j5wi3D+srvUN90Vs68XD/ff6auX3h9sXWG0f/2cfX/OfB/+4/D37N38nzeC8/f9X8 + 53c//Qp+7JW5/RXfybNPePnrs5r//PoAVwrtJ+5PsnysXvx+iq//PBdX4DMs/xl96co8+O1h/+jh + uf/wfPTwvB99+fn7/oflr7Tz86+v/5zRf35/n+H7oerq52T0nyfP/ekl8OCrLP8ZeH//Bf95tM/7 + R8+RzLwAz89Hz5FKPOQnNewf+frP2fznxfPvrSu3j377wX8Wbl9wvAf/mdtHv/1U/9nHt2F+8lj/ + +SYe3j/a/jPyiXkY79o/asZTfBvmn7f/jHxlHn7Pq/4z8InHm+D33FJon+Jr9XOmLz3zjRfwPF70 + 29v3/Iu8Er/iO/zzUJ+w+fWVWv2ct/3K+/vPEd//6vy6yu+Xef85m/88/b3lPwNfKvMw3pP/3IiH + /NWu/4x8Zl6AZ3/D+8/Z/OfFh/H69ZVa/Zz3fnTynzvzCdoP87cKj1dwvAf/mc8/zt+T/+zPv9s/ + OvnPdP8tbv7+4T9n858/PvrPFF/bPxo+8MF/VuYF+HB9LhRf2z96/a6D/5y4/+v6PPnoMxfmE/Dh + /luEx7vuv5MP4xXuD75flkN8M8XX8lfoPxfghXh8fzCH+GZaX1n+Cv1n5Ll9fL8s8/OvZpq/Gfd/ + t/8MPF2fLX+F/jPySvyKL/rPUM+Zrs+Wv0L/GXluXywfqyF/pVk4XrC/ryF/pZS/Ustfof9cgU/E + 4/o5hfVzouuzvb8/+PB+aKL1c8Ln3+0/I8/9weejFN4PTYnHC/lnDe/va6L42vv74/yE+Cbl/kB+ + UsP7+0r5K/CfR/9DfCl/Bf7zQ2rIXz1HfPvq/Njw/TJViq+in7P9Z/CNff5ZFfOTGvJXSvkrtfzV + 5CXwlXmx5+uT/1yIB/9q+8/A+/ykWv5q8mG8yucH/DoN3y/z9Z+z+c+LD+Ol5yPLXw2f9uA/+/4L + +pPbfwYfmOIr6E8e/efMfAI++s8UX0G/7lj/WZj/xov1n4FP3P6KL9Z/Bp7Wz7LjW8Zfw3jp+Uh2 + fAcf7r+i3P8V38mH8Qqf/xXfd7/s5v0jX/85o//87k/dHN+HT8Sv+E6e9wdvf/8F/3nw0X/2+Svw + nycvzOfC/DfeUT85+Fd34vGu+MqP+c/Ic39WfCefmVc+Pyu+gxf2c24/f8F/nnwYr2TmxfgrxJfy + V+A/Dz7E9/LrK/CfJ8/7oZdfP4P/PPjg110+/7z95zL2x6/gb1yZ25/x/Xh+f+E1oomf8f14nr9y + +fm7/efFB59ZuT8Y35P/zOPF+Ib3998jzEN8V/1n8JP9/Rf858lzvHphfsV31HMufD67vz6D//zO + xx7iS/kr8J8nz/Ht/v4L/vPgg39F+Svwn9/rWw/zt/v7L/jPkw/nxz//gv88+DB/KX8F/vPkOb6d + 4tvd9bl99XPAp62+P+Y/D/82zN9G8W07vpPn6zPlr6Tt+A4+s//T6PrcdnxH/eTM57P55yNpO76v + r/KH/zz4VIAP8W2J29cL+dAf5fHi+wstzN9G1+eVv1p88L2F+4N+ew3zt/rn3+0/L57vL5XiW53f + XsP1uVJ8K+4Pbv/Z+l8ztw/r513/GfnMPI43Bb/ar6/Afx79Cdfn6v0N8J8nzz5kVW4f/Zwa/Mkq + PF6x/aOj/8z9gf2j7T9b/wvdfwvuH0kJfl2pSnyx58HtPwPvn4/Afx7th+tzKdw+vr9QQnyLXz+D + /zz4g/98Ew/7gyf/me6/lr+aPF8PC81fy1+N8Yb5S/kr8J8nH8YrPF6Mb/CvniO+/9nFN/hXD5+J + h/zGrv8MPM3fjPuDr+3MPN1/s/Prgn8lmdbPzr+S8P7+WxGaePTrVv7qH/5zNv958fx7pvzV9p8/ + PsSX/KvtPy8+jNfnr7b/PPnw/r5Q/koS+hvbfza/MdH12flX239GvjOfgA/+ZKL4pn19vn7Mf0ae + +4/vl538Z+4Pvl+WEr+Pk5THu+6/oz/Bj6X81fafv/Y5v/HwSjzef0/+szAP41XObwjlr8T5VxLe + 33/+oMSDfyUhfyXkX4nzr7b/bO9vaub+gH919J8r8zhezl89R7h9XF+F/JVQ/kosfzX5MF7NzMP7 + kiF/JeRfieWvJs/vo5F/Jerie/Kf/XwRF1/h/LOv/5zNf579WfmrBnxhHtbPEuIrdP+1/NXwmQ/+ + szAPz0cn//kmPkE+J+SvhPJX23+uzn9Gns/njG+Z9ajD9VmEefme98f5D367CI9Xvuf9p+XtP4NP + i9fn9P5f6ve8X96/Bj/W3X8HX77n/eH38vxN7v47+W+86f1r8Cfd/XfwK78xefYJ3fcXJi/Qn+DH + uv2jwa/8xuSVeYzv4Fd+Y5wf7YHvzCc4/8L+pKufk9YjlfESeB4vxjdV2k/x/nMy/7nM+smH+s+J + +BXfyZOP4es/J/Ofy/R7Q31g9/5RMv/5az/T/fE5UpkXaJ/3j1JKPF7IXx3rP2fiV3zH+Qz+pLv/ + JvOfi6v/jD5zI37Fd9SX5voM3n9O5j9Pfr1/ZOdTKb664/v+ntf9F3khfsY3T7/3UP85M/+NV96/ + fuvnDjy3v+Krg2d/VXPgYf6u+y/wqRKf4HqlKfQ/cfsrvuN8amif4qs7vsPf/p5/b+OlEy+Wj33+ + Otu/gOf+Q34ySaXvN/n6z8n85/n7/+6/0xqafLmIX/N38lx/3vnPyfznOd5w/01C12fZ8S0/Vv8Z + fenMvAAfrs/u/pvMf57X/3X/hf4r8yu+kw8+s/J4Fe5H6/6L/jO3L/B7FuH7hfOfk/nPZfq0PH+9 + /5zMfx6/T131c5BPxJcL+eAbl8Db9UrvHPrj47v95zLrIQe/7vbx3f7zxx/855v4VJBP3L6//27/ + uUw/nL+/oLfyeFd8By/sE95+/m7/efE18Nw+zN/tPxt/Vd9/2z96/YGLr8/efx487B89f+X+X6Uw + n6D98H3ni+Jr9XMmXwMvzFu+XVf9HOhP4v7D/oKG74fq5e+/avVzJt+Z18BD/asrxPfy83f+B/Ds + h1zC53PF9+V78Dd69e3b/tHkhXmKb3f7+z34OZ3mr6ufo52vzw8vxOP+fuf1s6//nMx/nv7Dqf5z + Jx79jVX/GX1mHi/kNzR8P/Q1opm3fPv2n4EXbl/Az/nDf07mP08+fD/U+88J/efBB3+yUXzNf558 + 8Kv9/Veb868aPx/5+s8J/efJ8++t0fx19XO0JVpveP85mf/cPj+Z56+r/5zMf148/94axdfVz9n1 + n6F9v35Wq58z+TneDjyPF99Pqd/91/hK1+fq/Lq1f9SAT8TD+93H+s+V+QR88NsrXZ8r5p+3/4y8 + MC/Q/+C3V7r/Vhffmvj3U5XPj+J4w/tH1a+vtLr41hDfKtw+xrfy85H3nycP8S2Vf5+Frs9u/2j7 + z8DT/C3Onyz8fOT954T+8+Q5XoXmb3Hzt4T5Wyi+xc3f8P1QX/85of88eH7+Vff90IT+8+T5/liU + x4v1RUuIb6H5a/tH+mP+M/LcPl6fc+X1WK6+fbd/tP1n8HV9/krd+/savl+mmeave39f1/4R+syd + eIxv5ucjzXT/dftHGvJXz5GLeHx/8OA/++cj8J8nz/M3K58ffH/w4D8Ln/8VXxl/5fcls/D5RD82 + fD9UE8U34f7+X/5zMv958Rzf5PMbavtH7/okfL/M+8/J/OfFc3zd/lEy/3mul8L7+68RTTyur07+ + M/dfL+Q5vu79/WT+81wfhv2j5wj3B9fPKayvkn/+Vds/eu8XJ//Z90fRz9Hw/r73n5P5z/N54eQ/ + Bz7tfP5f/nNC/3nyPF7KX4H/PPiD/3wTn+B58OA/J+6/XsjT/oKq8vkEv05D/RzvPyf0nycfxis8 + 3pXfeOfXyX/2/XH5q6P/nImH/PPRf27MJ8uH/OE/Dz435CXwwrzs/NXRf76Jh/0FFf3Vfx68XsiH + 8dL9VzB/dfSflXhpyIfxCo93xXf4wAf/2V3fxPJXgz/4z5n4FV/5+dN/TuY/f/yh/vNN/IzvyG8f + /WdlXoD/3X9O5j9/PMdXKH+1/efFh/H6+G7/+eMl+M/K/Rcc78F/FuZhvCf/2c2X7T9//O/+czL/ + efE83stfn7f//PEhvpe//27/OTv/GfnCPI437P9S/mr7z/m/+M/J/OfFJ4rX5Z+Ptv+8eK7Xdwmf + /zV/5cf8Z+Qr82L8yX/256e7+bve30deicf5e6r/3JiH+bve3/+H/5zMf/7683v952T+c/n8Z45v + Tzxe2F841X+m+K781eJD+/7+u/3nxfPvsyufzxXff/nPmXkxvgV/kvJX0nB//+Q/+/WVNNxfOPrP + jfkE/O/1nwcP99/tPyPP/V/xRf8Z+MT8ii/6z8BTfNuO7+S5HnJTPj+wPyiNvw8rlL+Slb+avkcL + /kYT7v+K76hXHPwcyl9t//njQ3wr3X8r7g8+PJ9Pyl9t/7l8PjN/36H6/Ab4z/Jj/jPwNH/Nfx6+ + cbj/Uv5q+8/Tz1n+M/Lc/lo/Tz744RTfutfP7/xa+Sv0mRvxa/08+XA+hduH5yMp4f5baP4WfD7a + 9Z+B9/mr7T8vnucX5a+2/zzfRzjUf6b4Fvf+wsl/Drzs500J3y8Tyl9t/3nxOfDcf3j+3fWfgdfG + fAKen3+fI534Fd/J8/wtwuNFvy68vy/kX23/eY43+FcPr8SjX5dD/Xbyr7b//PHBr8t+/2j7z4uf + 4zXfj/yr7T9/PL+//xxpxCf4PYf8leTE49UL+cQ8ra/yju/gJYzX55+3/zznb/CvhPyr7T9X5z8b + 775flsx/rv/Ff07oP08++MCF28f3B1OYv4nia/7V9KXZF0058AJ8mL8pcf8T3I8O9Z99fnL7z/N+ + +of/nMx/Lv/yn4X7s+6/7cf8Z4iX8HjBr5OQvxL1+wti/tXgQ3zJv9r+81z/KO8fCflXYv7V+3v+ + o/5zMv95rg9P/jP3B9fPJ/+5Ep/geeEP/zmZ/1y++s+Zx6uF+QTth/mrFF/zryYf4kXXZ3XrZwnx + pfyVCPp1b7XnwCvx4Mdu/xl8XYqv5a+mz8zXc/H7CyIuvsL7R0L5KxH067b/DDzdf13+avvPwNP6 + 2fJX05cO54fmr8tfiUgPPJ9PyF9t/xl44fFC/irlGvxbvP8q+s/DN67BN8b6Zor+s/yY/4x8Z/57 + 3n99vHD/fY5cxK/8xuQl8JX5L7/x+nvh/pvc/pGa/5ynb6zs0zr/Wc1//toPfl1W7s/Kbwye56+v + /6zmP+d/+s/K/Dfe1ycM+0fJ3X/1/Ums/FUeNnLwgctF/MpfpfHXxO3j+mryCfhQP9b5z4Nf8Z38 + HC/40rkw/433/T2f6j/fxK/4vr/Pg/+sPN4Z3/T50vx7Tsrnc8b340N83ftHuh6Zd394/Zzc9xd0 + XSIWr5WuD95/VvOf5/lR3h98jtzEr/hOns+nlso8xHfdf9FnvojH+Cqvn5Nmbn/Fd/Ap1GdOPN6E + 4/3iC36ycn8Ux6vBZ6b46p6/oz9ffhJ9aSV+xXf428FvV4qv7vi+7Yf7bxKav7Lj+/4ewvtHydXP + UfOfF8/vI7j3j9T85+zqPwNP8ZUd38nz/BWKr7j5K4n9eVc/R81/zs5/Rj4Trxfyc/6af+7uv2r+ + 84yXfPMXeSUe47vuv8AL9weuz7v+s/lXt5+/238e7e/6zxfwSvyK7+QTt+/vv9t/ztPH5vmrbv9I + zX9evASe+w/zV+9Evr33n9X856//KXP7KRG/4jt8bw3jVe7Piu/klfsj3B+4/+raP0JemBdr/+Q/ + +/Zt/2jw0X/281dt/2jy7F9dfv6q7R+9v7eL56/3nwe/4jt59v2unJkXOz8n/5n7A+ur56/zfKL/ + rMTD+kovDe0r9wfWV3pJ8KWFxyu2ntT1/VD0pYV52y97bWfiO8XX9o/kx+o/V+Az8bB+fnjuf/fr + K7X9o+H3ZvZXO8XX9o/S+Cv/nntW5gX44Od0iq/bP9r+M/JCvNrz4FvtmXnl/qs972//GXlufz0f + TZ5/b10CDz5D4/Xzc8TH1+0fbf8ZeSV+xXfyfH7c/pGa//zx/P2U5wj3B/2NxusrbTR/bf9o8KG+ + aEvc/orv4EP99pa4fbX9I131c6A/GnjwVZb/jL40n0+M7x/1n9X858lXXl89R/x4q4tv5eej5wjz + +P7RyX9uzMN41/6Rnc+auf1s+ToN9XOeI8q8AB/8nJoq8bA/qGv/6B/+s5r/vHj2zapfP2//+eOF + fTPnP6v5z9/5OdR/zszDeE/1n/31qmB+Ulf9HOSVePSvSohvoetz2fEdfHg/pfj18/afF8/jLZn7 + j++Xhf0j7z8PHt8vW/4z8pl4jG/YP9Li8xvbf/74MH/d/tHgpSEf2hc+/xjfU/1nP18sfzXqFQd/ + Mvv8hlr+arQf4ptpfWXv7w8+1n+m+2928zfz+91K+SvNLr6hfo6v/6zmP0+fMIf4Zlpf2fv7k+fz + n/3zkdr7+4MP8zdTfO39/dH/Q/3nzDyMN4X4Uv5K3fv7GvaPNNH6yr2/v/1nO5/Of1bznz8+xDdl + 7g/O3/X9MvCNszCP4w33X8pfaXLz9+A/0/U5ufkb9o+eIzxenL8hf6WJ1s/u/f2j/8ztw/v7Gurn + KOWvVN38PdR/pvuv2z/SsH/0HOnM2/7CyX8uQjzsLzw87Q8+RxLzsN4I3w9Vyl9t//lrX9mPpfzV + 9p/nevvkPzfmwY/9o/6zmv+8eI6ve39f0X8ePu3Bf/btC+4vbP8Z+UR8uZDn37OUwJtfp2H/6OGF + ePAnt/8MfA682POjpNC+319QQX9SJVyfRZlfz7+j/TB/Rfl84vPvyl+h/8z9X8+/kxfmJfCy+b/q + P6v5zx8f/Wd//xXLX7Wfs/9cmLd8ztF/7sSv+E5eAq/My86HbP8Z+MT9gfzV9p8z8Il4vZBnX5Ty + V+A/D57j6+s/K/rPk6/cH399Bv/55cP3y3z9Z0X/efAH/zkTD/nJv/xnRf/5Pf8H/9nPX/CfR/uh + fuyVA4/jPfjPlXiM78F/Ttx/jO/F12df/1nRf568cP/98+/2n7/zc/CfebyQf97+M/i0/vq8/eeP + D/Gl/NX2nxcf/GSKb3fzt4f4dopvd/O3h/lL+avtP3/87/6zmv/88SG+3V+ft/+8+DBe//y7/eeP + D/O3C59/wfEe/GceL+SfpdVQT5ji23Z8h9/7e/3nweP1+Y/6z5NPwEf/meLbXHxbiG/Lgcfx8ved + hfJX0jD/LOv7Zchz+2r5513/GX1pPp9w/5Umod61MC+Wf97+M/KZeVtvbP8ZfWb/e647vpPn/lea + v9W9v1BD/djq18/gPw9/+FD/mXnIP//lP6v5zx+fQn/o+lydn1MT+3tVb+LV8rFSQ3yr8vmE/LNU + Cb638Hjh+ej5a+b2hceLfl3h70tKofVVweff7T9jfeaLeHj+ff7K9fkLxdfyV+/v5+Q/C/ErvpNn + X7345yMpzp8sob53STxe/P7CH/Wf1fznxXN8i3J/oD7SX/Wf1fznb7yH+s+ZeRhvDu+nuO+XKfrP + Mv7K/c/++Qj858GH63Mu3D6+v5BDfLPPP0vG/Max/rMwL8Af6j9zf9CPDfkrIf9KLH812g9+LOWv + xPJXg+fnX+8/q/nPcz6u9/eRz8zDeEP+6jnix+vyVyf/uQrxOH/D98ueI415y+dI+H6Zr/+s6D/X + H6v/jHxm3vIbEvJXkmh9lXD/SEL+Sih/Bf7z5Gk/7j3CPLxvFfJXQvkr8J9H/3/3nxX95+Eb8/7g + c8S3r7h/JCF/Jer3F8B/nnzi9gu3j/ffU/1n5vH+q5yfFPKv/uE/A0/X5//Jf9boP/P8VeX+aAI+ + zF/1+Q3wnycvzEvgZednjvWfff/Nvxp8WD9T/mr7z3M9dvKfK/MJ+OC3k38lgn7s81deb5B/JZa/ + Gv0PfrukTnyC9aQor2/F7y9s//lrP8SX/KvtP2dX/xl5bh/Xz6f6z4G39XMK+0fJ1c8R858Xz/V4 + 3f1XzH/++EP9Z27f+8/0+/H1n+Vf/jO0j8+/8i//GdpP3D48/6Z1/wUe56+g/zz5MF6cv4L+8+vL + hfo5yd1/Bf3nNP4azr/weCF/lcL7R77+s/wH/xmfjwT958nzeJ3/LOg/D57XVylRfM/+M7Sfuf2T + /wz9Tzxe9GP/qP8s5j8vXzqMV7k/K76D5/uvr/8s5j8vX1ro9+Duv2L+8+TD/df7z/JO+RnfxafA + C/Hox4b7b1KKrzo/VjPXP9d8E49+7Ml/5v6v+A4++O1K81ed377uv8hz/zG+Gt5fcP7z5JP9fjTM + XxXuz5q/kw/jFT7/J/8ZfWZ/Pu3+O/lQf5jmr7j5KyG+QtdncfNXMs8X9/0FQf+5/JzrPyfmLX+1 + 6z9D+zR/xV2fJcxf0Yt4vD6v+y/0h67Pdv993zcRCT658nhXfCev3B/h/sP+0fafzQe7q+sP+M/v + /tfaPwK+3MSXC9ovvH99+/kL/vOob5y5/urtr8/q6ue8tnPgC/Oy15+7/jPwice71s+TV+aVx7vW + z/pj/jPy3H94f1Bv4f30299/of7z5EP7wucT93+vL/9s/OWvz3rt56M8/srjvfz6Si/nT15hf/8q + mXnY37/4+Ujd90MHj/v7V4jv5ddXern9/SvE96L42vdDJ8/7uRfF99rxHb53iO+lfH7Qn7yE6zFe + yv2H/IZe/Pzr/efJW35Se4hv9+tn8J9HPeSwv+/q5wj6z5MP7RduH/KT2sP87RRf85+Hv53peuj9 + Z0H/efAhvt1fn8F/HrwGH9vff6H+sww+9Ecz8wl5jlcXHq9APfMe4tuFx4v120/1n/3vuWF+8vlr + DnwmHuu3tzB/Wwk8jLeF+qItX8Rj/fZVPwf5wvw33vd6tfaPgPfrq+0/13/WfxbiV3wnH33mzrzV + Zzj5z8L8iu9o/+A/J+bF+Brmb/XrK7Xvh779qWH+Vr9+3v7z4vn65urniPnP1dV//of/LOY/L14C + z+2v+A4++LE1MZ9wvCm0n5T4Fd/hJ/P3JdXtH4n5z9X5z8hz+yu+kxfmhc//iu/0nyk/4+s/y49a + /ZzpP7NvVgrzWJ+/hPiWUpi3+jka9o+eI9w+1M95/sp+XfHrZ3X1czR8P/Q50olf8R3tc35DS+L2 + Mb5h/+g5wu3j9xfC/pH3nwcvON4Q30Lxtfo5w2fm/V/vP8uP2v4R+s/AF+Zx/ob9I820fs5u/ob9 + o4dX4uH7dBryV0r5K7X6OYP/3X8ePF6fc8rM++cjdfVzNHw/VDPF19XP0fD9UHXfLxu8NOQ5vlm4 + /xjfxP7Gc8S3n9z8Tbz/+/BKPM7fk/+cmIffc8hfef9ZsP7z5Hm8bv9IsP7z4EN8KX8F9Z8HH+Yv + 5a+g/nP5Mf8Zzo/yeDG+K3+FvBCP8Q3fD32OcP/x/qth/iqtr6z+86hvHOavlot4XF9piK/S9Vnd + +kpDfJWef9WtnzXEVzP3H9fPf/jPgv7zu/4/+M90/7X9o8mH8Sr3H/Z//6r/LOg/tx/zn5Hn8aLf + LiG+7v39l3Tvlx3qP1N8Xf2cY/3nxDw8/57qP3N/8Pn3VP85My/AH+o/F+Lx+VdCfCVx+4rjPdR/ + 5vYVxxvmrwifT8HxHvxnZd7Ge/Sf3fmE+s+D/73+s2D958mzv3H7+Qv1nwf/u/8s5j8vXgJfmcfx + Hvxn5rF+7B32B29//xXLX00+9F/5/CiOl+ev95/F/OfFi/89+PrPYv7z7M+p/rM//xe+v/CX/yzm + Py+e43v55yO53P7+yl+hz9yIx/rAq/7zP/xnMf/544N/dfn1s1xuf/+P+s9i/vPiw3iV+4/7+1eI + 7yXMr/hOnn/Pl/D59PWf2U/o/v4r7v39k//sr8//qP+MfGb+UP8Z+kPx5frPEvjCPMQ3fL/sOcLj + xfgu/xl45fHi/F31n5HvzMP8Xf4z8H79HOo/8/sLlL8S9/6+tOBvNLo+n+s/I5+JRz+nFfYrGs3f + c/1naN/nr4TrP3N8m38+Evf+/q7/DLy//0pz/lVL7LO1xOPVC/jgbzS/fhb3/v6u/wznR3i8sL46 + +s/CvBhfw/ytdH2uzq8L+av3CPG+/jPlD4XyV+A/Dz7M30r334rrZwn5K+8/C/rPgw/xrYnbRz+2 + hvlbE7e/4jt5vl5Vuv+a/zz56Fdz++v5SH6G7cy88PmE/PNf9Z8F6z9Pnn+fxT//iuWv3utbCfWB + i99fEMtfvde3EuZvoflbML8h4f19KRTfgvmNY/1nbh/yG3/5z4L1nyfP8S3K48X63n/4z4L1nyfP + 1+fi889i+av3+rm+XwY+rd8/Av958MFvzz7/LC5/9fB8fc60fnb5q6P/fBEP+eej/5yZx/GG91Mo + fyUZ8xsS/KuH5/b1Qp7fj8jK7UN+8nm84/V59vlnsfzV9KXDeIXPP9b3TmH+kn8llr+aPN+PEsXX + 8lfoPwPvn3/F8leDD/M3+fykWP5q8jxfEj0fue+XSchfPUca8QnHG+KbaP5a/uo/1H8W85/rV885 + jFd5vNKQ5+sV+VeScH9Bwvv7oj4/KYr5SQn5K1G/vy+Wv6o/5j8DT+tnxfyk/FH/Wcx/rv+s/1yY + F7v+r/qT0B+6/7rvl0nIXz28EK8X8ny9Uu/nbP+5uvrP6DPzeFd8J8/zl/yr7T9PPuSvfP1nMf95 + 3n/D+/vPkZt4fD8l5K+E/KvtP3/8wX9mHr+vEfJXvv6zmP/88Qf/+SI+4XjD+kr8/hHUf57+M9/v + KH+1/eev/RBfER4vrq9O/jPHC76fcvSfrT+vjGT1cyY/2ze/C/ePJg/r52P958R8Av7X+s+Th/fL + jvWfM/M43kP95058wvEe6j/zeBXHG/w6/H7ox1v++eg/N+LX89HkJfAcL3g++qP+88vb+0evHxi+ + H+rqP08e8pPH+s+Z+QR8pvqfz5GbeMhPpvD90IT1cz5egD/Ufy7EQ35y+8/QH+XxQn5j+8/IJ+YT + 8F98kVfiV3wnP8dr9Wzx/vvxlp9Myt93fitCO14x/7zrP1t/lOKrLr7r/ot8Yh7iu+6/wGduH+Or + uQZembf8xnOyQ/8pvrZ/9P7+Ve/Ac//V9o+ShvgqzV+3f/T8VZgXHq/A9UpFA1+Zt+f97T8bL3R9 + tv2jwYf4CsXX9o8mz7463n8/3u5Hf9R/njzcf4/1nzPztt7Y/jP0J3H7cP99/srxEorvuv9+7Yf4 + 4v334xPwYf6KcH9gfbXrPyOvzNt49f7e/8X6z27+bv95+ml3VeZ9fLf/XP9Z/7kyn4AP9YFx/2jy + 6G/cOQVemLfn313/Ges5c/u4v7/q50D7SYmH59+Hr9y+vz5v/3n6DzfPX72V21/xHf75of5z4MX4 + U/1nN7/02vG9x1+5/Yviu/aP5vfBT/Wfuf31ffbB51Bfuijx6/vskw/t+/mra/9ofg/9VP+5E4/f + Z1/7RxV4bl8v5BPzyuPVBDyvrx5eiBccb4jvJYEX43+v//zya/9o9qfz9fk5wjzGt4f49lKYT8hz + PfNO87fv+M560Tnwwvw33ne+9xDfnrg/K76DD/O3U3z7jm8ZfOiPcv9XfN/5vvaPgBfmV3yHry7h + fPr77/af2/BDTvWf/Xjbju/kNfBK/Irve3041X+uzCfgef2s+P3Qya/43j9W/xn5zLwAn/h8tsT9 + mfHt08cO9b2bXz9v/7lPHzvU9250fV77R3362CG+Tbj9Gd/FC7cv3P8Z38mv/SP0n3181/5Rn750 + eP8I/efJlwt5Pj/VPx9t//nj+fs47xHic0Oex1v9+nn7zx8f6rfXxONNON5wfa6J+6843nB9rsrt + Y3yX/wy88HhXfHX8ledXFR7viu/LlzB/C8W37PgOPsS30P237PhOnvuP9XM+HsZbQnxLZh7jW0J8 + sf7zx8PvuXB+w9V/nnzC8Yb4FlpfFTd/S4hv8c9H239ePN+PivB4cf4W4et/oftvcfM3h/hmuv/m + Hd/Bh/tvpvmbd3wnz+PNdP/NLr45xDdn7g/GN3w/VCl/tf3nr/0wfzNdn/OO7+DD/TfT9Tnv+E6e + 749Zebw4f0P+SrNw+xjf9f5+Ap7P/4rve37C/pHzn+diHq/PifcXHj4Rj9fn3+s/fzxcn0/1nxvx + GcYb8lfPEWUerlcpVW4/cfsY35W/Ap7im1x8T/Wf+fzg/A37R0r5q+0/L174fNL9N+34PuQf/vPL + 647v4H/1nye/1lfDNz74z4n5BPzBf76Jx/XVyX8W5mE9efKfuf0E68lQP8fVf578Wj8PPznEV5XH + u9bP02fm+Kpy/3H9fPKfuf21fn75k//sryey18/Dl471nym+suM7fWnaX1Ap3P6K7/SZQ/sUX9nx + Rf8ZeWFegA/vl0ni/uDzkYT4ivJ4V3zT+CvHV+j5SHZ8By/B96b5Kzu+k+f4ivB4V3zf/dCT/+zG + u/3n8bz5R/3nycPz72s7B74yn4D/1X+ePOQ3jv4z93/lr979u5P/zO2v/NXrg638FfDK49ULed4P + pfzV9p+nD/C7/zx5+fJX7cf8Z+R5vLi/f/H7g3L5+69czt/43X+ePPobv9d//ngY7xX2fy+ff97+ + 8+J5vJefv9t//sYb9n8vP3+3//zxPH+F8lfbf148+xuXcvvobxz8Z+X+r/jWn7P/HHgxvgd/o9P8 + 7Tu+gw/7+92vn7f/vHj2JTrN377j+463h/h2v77a/vPigw/s11fbf56/h5P/fBGPfs56fx/5RDzO + 31P958x8Ap7vv0L5K7H390d/Qv3JLnz+If/8Vnum/jSavw3zz7Le30deiMfr88pfgQ/s18/S3PW5 + FWGe4tswP3n0nyvzAnwKvjHN37bvv2n8NfRf+fys+28efw3+tr//Stv33+GHh/g24fGu++/k+ffc + /PpK2r7/vvOrVm6/+v2j7T+36Usf/Oeb+HIhz+en0vW57vgOvzrz/aIWIR7WzxK+X/YcycwL8Inn + Y008XshPPn/NgVfi4flIwvfLniOV+YQ8/z4pfyWWv8o/5j8jz+3D86+E75cJ5a+k4PPvrv9cgBfi + 4fn36D8n5r/xvr/Pwt+ne3glfj3/1h+r/4z+M7e/nn/f39vJf+7Er/iO+tVJeLy0vrL81eC5fo6r + //zxCXllXrj9Fd/Bh/hS/kosfzXqG4f4kn8llr+a/Pw9V+Np/Wz5q1HPOdSPJf9KLH+F9Z+Bp+uz + 5a8mL4GvzON4OX/l/OfJJxwv5yed/zx5jG/wr4T8K8kuviF/JZnuv9nFN/hXrv7zx8PvOdSffI74 + eFn+avCcfxbyr8TyV5Pn8Sa//yuWvxp8iG+i56Pk5u+p/nNlXuz6EPwrofyVWP5q8BrqP9P6yvJX + kw/j1cDD9SqF+FL+Six/lX/O9Z+5fbw+/17/+eUV88/bf0ZeiIf9BQnfL3uOVOYT8CG+mrk/K76T + 59+z0vOvuvuvptA+XZ/V3X81xBf958mv9dX1Y/WfoX2Kr+WvBs/fd36O3MSv9dXov9TAc38gP7n9 + Z+OF1leC+cnnr3w+KX+1/ed5/oX3j0To+iy4v7D9Z+ApvoL7C9t/Rl6ZF2g/8fmk/NX2n7/2lfYX + hPyr7T8vnuNL/tX2n7/+hPiK8PnH+SsS2qf1leD8TWH/6DkC7V/mPy+e64u6++9l/vPHBz82F24f + 9hdSuP96//ky/7nPesjBj8XvL3y8AB/8Onf/vcx/Hr/PFO6/yd1/L/Ofx+//6D8n5hPwfH32/vNl + /vPic+C5P7D/e/Sf/flMOH9P/jP6G5f5z23WKw5+bMLr82X+87hepXD/Tfj+0eTX89Hkebxu/+gy + //nrD8/f9wjxGN8U4uv2jy7znxcffG/l9mH+Hus/38RLQ14CL8zD71l5fZXw/aOXV9zfT+H7Cwm/ + Hzp5uD4/f82Bb8zDeJXrT3r/+TL/uX/+c2g/J+ZtfZXC9xeeI5V4WF+lcP/1/vNl/vPiQ3+0MJ/2 + +nDXfwZeOvErvpPn+Lr9o8v858mf6j/782/33wr+M/JK/Irv5Pn37PaPLvOf+6xvnEP7mfuz4tvB + f0ae+7PiO/gwfyVx+/B8lNb9F3khfsX3Av8ZeM3MJ+Al+s/cnxXfybPfLhRfu/+O+snBj3X7R9d7 + y17xHXzwN+4qxMPz7/afgS+Z+QT8wX9uxMPz7/NX9lXuzO3P+F5fPefKfOL2Z3yvr55z9J+5/Rnf + xbMfiPWfPz5NfvjkEnk+nzO+1/S9f/efr7WEe/l3f/bi+ev957E5Uou1f4X4Xv76rGv/aPHsE14U + 37V/9PUnxPfy12dd+0eLj/5zZf4b77t/ffH81cuvr/Ta8W3jr+yzXYn7v+L7+gAn/5nbX/EdPK+f + 9RI+/yu+w1c/+M/KvBjfw/ztNH/7ju/gS/SlhfgV31E/+eA/Z+YTtB/i22n+9h3fyYf+Z+7/iu+s + /8zz1+0fDX7G9/7qM0f/WYmf8b2njx38q66V+TT5d/7+4T8PfsZ38dF/TszL5N/51UJ8G8V37R99 + fJi/WD9n8uVCPvjAfn21/ed71kMO8W2Z+dyg/TB/G83ftX/0tR/8upZ4vCu+kw++d+Lxrvi+14cW + 5m9T7v+K7+RD+8L8iu/wzw/+c2JejK/h+lz98+/2nz/+4D9n4ld8Jx/a9+ur7T9/fKjPX+n6XHd8 + J58Dz+1nHG/wY6tfP2//+eM1+OF+fbX958Wzj1QpvnXH973+L//ZfJ4qzK/4Tp7jW4X7s+L7/n5K + Db4xxbfs+LbxVz6fxec3tv88x1uCf1UKt19gvCXEt9D8LTu+o/+ZvwdRaP6WHd/R/sF/5v4kHK8G + /1l5vDh/C39/0NV//niYvyV8X8PtH13mP3/9CfEtFN/i4vuH/3yZ/zzbz/z86+o/T37Fd/IcX7d/ + dJn//PHh+wuUv9r+8/z95BDfnLn9Fd/3fn3ynwvxK76DD/Gl/NX2nxcfxqvcH4Xr1cpfAU/zN7v4 + Zn7+fY5U5uF+FL4f6v3ny/znjw/xdf7zZf7z7fxnaN/nr7b/fDv/Gdqn+CZ3/w3fL3uOFObF1icp + fH8h0fNR2vEd7Wv0n/n8KI734D9z+yu+/8F/vsx/nuu9UD9Hk/D5X+vn4Q8f/Gd/PdG9fp4+c/CB + af2sbv2sIb5K81fd+jnUz1HKX23/efE8XvX5je0/X85/Bp7mr7rnoz/858v858VH/5nP53o++of/ + TPN35a8WH8YrPN4V3+Ezh/krPv+8/efL1X/+h/88eHz+Dd8PdfWfPx6e90P9HO8/D37FV8dfebyU + v9r+88cf/GduH/MbEtZXkrj9Fd/JR/85M58s3yIhvpS/2v7z4sN4hfsD+avtP9v+JuWv5Hb+xs3X + Z1f/efIrfzV59pEofyWWv5o8+4GUvxKXv9r+M/KVeRxv8HPuxONFf2Plr5AX4vUb7/CZg59D+avt + P3fnP0P7fn21/efu/GfklflvvMOnDfG9KL4X5p+3/4y8Eg/55+0/gw9cuH30r8L3y4TyV9t/XrwE + XpgX4H/3ny/znz8+xPdKPN4V38kH39uvr7b//PES/Wduf8UX/Wfoj98f3P5z//zn4N9SfLuL7x/+ + 82X+c3f+M/D++Wj7z/1f/rPfH9z+8+J5vD1zf9CvO/nP3J8V38mH9hP3Z8V38KF+XffX5+0/989n + 5nqV3V+ft//cP19aAl+ZF+NbDT6wXz9Lw/2FXf8Z+UQ8+nWn+s+Bt/uRrPf3gc/cn3X/nTyPt2Vu + H/YXpCX2byl/JW3ff4f/HOZv8+urddfbPPuiTbk/6/47fGmJvBK/7r/Tf+bfW/PPv9Jwf+HoP/vx + 1r2+Gr50oXpuUmn+1r2+mv5zaJ/iW3d8Bx/mb6X7b93xnb505v749dX2ny9X/xn4xONNBXheX0n1 + z7/bf1589J+5/RXfwYf7b/X55+0/L57jS/mr7T9PvtTgJ/v1s1j+atZzDvWQaf5a/mryfD8qJfAJ + ee4/5a/E8lfp51z/uTAv0P7Bf2Y+4Xij/5y4/3pBf0L9yaKBT8ALXx8KxdfyV8Mnl9B/uv8WzG8c + /Wd/Pc+Y39j1n5EX4ld8J8+/Z8pfScb9he0/I8/tr/hOnuNL/pVY/uo9PznEN/vnI7H81Xv+V/4K + eLo+ZxffkL9y9Z8/HuIb8ldC+Sux/JX+mP+MPMdL4PecKuUDXf3n91/LX739OfjPFN/k5m8q7MMn + v38kyc3fkL96eG4/w/UqvL8vKQcerlcp+LGJ4pvc9fngPyvzeH3+w3++zH8e+Znnr6H/dP9d+auP + D357ovmbcP93+8/mf1L+ShT3f//yny/znxefuH2fnxTLX73304P/TOtny1+1H/Ofof3M/VnxHTzX + v3qNaOIhf7X9Z+Bp/rr81a7/jDyfT8hfiYb4qvJ4V3zH+QnxpfyVWP7qbf/kP/v5K259Ffyrh8/E + r/hOnvbThfJXIuhvbP8ZeLr/Cvob239GXpkXW69KiC/5V2L5q3/5z9y+Xsjz71mUx4vrZ5EwXu9P + bv/5+nzpMF7h/qz4JvCfzddy+0fd/Odr+sChvqjzn7v5z4ufv+cOfGE+QX9CfVH3/lE3//lrP9QX + de8fdfOfr+kPc3x9/edu/vPHc3yTu/92858v5z8jz/2H/OT2n+H8CPMrvpOXwPN4BcabQnwTxTft + +Mo//OdEfLmQDz4w5ie7+c8fH/xJV/+5m/8843uq/1yZF+CDH+v2j7r5z5er/ww8xdfuv5MPPrZy + f2D+/uU/d/OfFy+BV+btenX0n33/Ff2656+J+cI87C+k8P6Rr//czX++XP1nOz9K89fuv5Nnv9fd + f7v5z9dX/znwifsP99+j/5yJh/vvrv+M/nNnPiHP74Oo8Hjh/pvC+0e+/nM3/3nyJ//ZXz/t/tv/ + 4T9n4iG/cfSfE/MwXuH1c8Lvh04e7r9H/1mYF+B/95+7+c/z97Duv//wn7v5z4sP7Su3j/GVMH9F + mF/xnXwYr3B/YH21/WfzE24/f7f//PHBv7oL8yu+5cf8Z+QT8+DH3nx99v5zN/957m/eHF+9/fUZ + /OfBBz8Wvx86+WS/5+0/F+Az8Su+k6/MK7cPz0dvtWfuj/B4V3yH783vlz1HuD/r+fc5M3pxff73 + iOMvzF/t+s/W/6swX+x5//kr+06u/vPkwRcN+0fefx485K/eas+BL8xbfmPXfwY+MY/+xhXieyn3 + Ry/k2c+5NDMPvsrF89f7z4Nf+Y3Jh/4L9x/9nFX/2fhe3fVw+8/T1+rBr+tViUf/qvP99z3CfEKe + fSq3f9TNf57+Ug/z19XPmbwAn3h+dX99Bv95+NUhvq5+Tl8hMz6MV/l8on/Vg1/Xhfuz4jvaD/5V + 9/df8J+x/rPxjeLbnF/XeP9XXf2cjv7z5Hm8zT8fgf88+DB/G8XX/OfJh/5n7g/Gt4X529JNPPqx + y39GnvuD8V37R8BrYv4db5JZX1p4frn6z337zw8/6ksHf6MJj3fE9+Hf61sN8a3V/x6+/aPNB7/X + r6+W//zw7/Uk1M/RSvP32z9afPBzKt1/v/2jzYf+U3y//aOHf69XNXVuP/F40zfe93oVvh/q/ee+ + /efNh/Eqj3fFd/RHwnhViV/xnTzHtwr3Z8X3PT+hfo6v/9y3/7z44F8Vuj6XHd9Z/5n2j54j3P6K + 7+BDfdHi18/Lf968BF6YF+BDfdGSuD8rvlj/GflEvOJ42d/w/nPf/vM3f8P3Q3395779582H8Qqf + /xXfl1/5q/09UMXvh7687R+967fM+4O+/nNH/3nyPN5M89f2jwYf4uv2jzr6z8M3DvGl/NU//GcY + b2Ier8/h+6FK+SvwnycfxquF+YP/DLzw+V/338mH8Qqfn3X/fe9fp/rPvj/J3X9P9Z8z8Xj/Xfkr + O5+J1s+2f/Re39b+EfCZeXx/YeWvkOf+r/gOPsQ3+fwG+M/v9XDlr4DXm/gV38mH8dL1Obn1cwrx + TTR/zX8e/vah/rMwL/a8c/Kf/fnRHd93vh/qP1N8dcd38vx71tKZT8Af6j834mF/8LWdA1+ZF+AP + 9Z+5P7A/uP1nBV6J1wt5jq9SfC1/NfztEF/KX4H/PHmOL+Wv1OWvnj9W6g/lr9Tlr7b/jHwmvlzI + c3wpfwX+8zvfJcRX6PnX5a+2/4y8MC/Ah/gKXZ/d/tH7v8zT/JUd38mH8SqfT3y/W0J8KX+lbv/o + WP+Z+7/iO+o5H+o/u9+z3Lh/tP1n+3435a/kxv2j7T8j35gHv+7m67NQ/kpu59fdfH0W9/5+/5f/ + DLx/PvqH/wy8Mq/oe/P8Fcpf/cN/Bl74/M/4ev8Z4uWvz+A/v/wV4nv59RX4z4OP9Z8pvuY/Tz74 + wH79DP7z4EN978uvn8F/njyP96L4Xs6PvXj+CuWvwH8evIb62P75CPznyQffW7k/iuPl5yPvP3f0 + nycfxiuBh/H2Gvxbiq/5z8PXPfjPSvyK7+Q5vq7+c0f/efAhvt2vn8F/nrwy79dX4D9j/Wfgaf6a + /zzrP/Pvufv1M/jPk+f4duXxev85+N7K48X4rvf3bb5T/gr857f9U/1nf37Mfx6+dPSfaf42935K + C9fnRtfn5uJ78p+ZX/Ed7R/8Z+4/1hdt4fvsLXH/V3yHv53499lo/q781edXh/cXmnL/YX//+Wvo + P12fzX8e9avD/G3C48X7bw3X50rxre7+u/xn4Cm+5j+nH6v/jDy3v+6/o/0wfytdnyvu78vKXyEv + zAv0J8zfmrg/6LfXMH+r3z8C/zkPnv3MqoEHH2nlr6B94fO54jt5jm8V7j/67SXEt3h/Y/vPi+d4 + lcI8+lcn/7kyn4AP8S00fwvuD0rIXwnlr7b//PEhviVxf9CvC/krX/+5m/+8eL4+F+X20a9b+Sv0 + mbn9Fd9/1X/OzNvz0fafrf/Z558lO38y5K8eXolHfzLkr4TyV2L+1eT5fpoLt49+7Ml/LswLtB/i + m+n+a/7V4EN8M12fzb/C+s/AK59PqI/0PMzx9TDT9Tm7+Ib8lVD+SrKLb8hfvUa04xM+/27/2e6n + ia7Pyb2fEr5f9hwpzMPvOYX5S/4V+M/1x/xn5IV5uF6lEN+UuD/oT4b39x9eicfrc1JePyTl9vH6 + HN7ff47w+VzxHe2H+ZuE+4P3X+X9BaH8FfjP8mP+M/JKPPh1Et7ff45w+/j8G97fF8pfQf3nUQ85 + zF/yr0Td+iq8vy9K81fd+vlQ/5muz1Z/cvJhvDR/1a2fl38FvHB/1vp59D/EV4XPP74/GN7f9/Wf + O9Z/fvsT3t9/K0ITj++Hhvf3RSi+Vn9y8CG+QvG1+pOTFzr/krn9Fd/Bh/hKYn7Fd/Dh+zjkX0H9 + 58kn7g/FV3Z8By+hfeX2Bccb4kv+FdR/fn2zXMlnSO77Cw3rP9fx1xT4TDzkN1J4/8j7zw3rPw8+ + +HVu/6hh/efJC/OZ+wP5je0/A4/+RsP6z4Pn6/PDK/EQ34cP7Sv3R3G8EsYr3B+IbwrvH3n/uWH9 + 5ze+oX7Oc8S3b/WfBx/qAzv/uZn/vHj+PaQSeKjvHb4fmtz+UTP/uTv/GdrPhXkB/uA/Mw/1+U/+ + M8XX6j9Pnn/Pbv+omf/81aPm+29y7x81858XH86ncP+hPv/Rf/a/h3P9Z+uP858b1n8e7fP7+95/ + blj/efAhvu79o4b1nycvzOfA43j5+uz952b+8zyfoX5OcvffZv7z4sN4lceL9duV39/3/nPD+s/j + /PP6Obn7b8P6zy8vnL9K7v7bsP7z4Pn5yPvPDes/Tz4xXwIP4w37R8ntHzWs/zx5jq/bP2pY/3n0 + J8RXaP6Km78S4uu+v9Cw/vPkO/PK7a/4jv5wfiO5948a1n+ePF8f3P23Yf3nd7/p5vf3nyOufaj/ + nMdflXk/f6H+8/Sfc+Ar87be0Ju/b+X95/YD9Z+Hj51Df3x89cb8867/DHzi8cL+0fNXuh7qrTze + Fd/hJyv7dbd25qE+Uqif4+s/N/SfJx/676/PUP95+szB7/XrK7X6z+/v4eLrs/efBw/5ydd2Dnxj + /lD/2fY3r8ztw/spz195f/+i+F5u/zfsHz1HKvG4/xvq56jbPxq84njD/u/lr896uf3fi6/Peim3 + Lzje4Ne5+jmTF+M711fx/vNYcmN9s/757cBTfLt7fyHsH3n/efIJ+dB+vonH/f1QP0c7xbe7+PbE + 8eoU377jO3xvfj7y/vPg1fI5GvaP3iPMJ2g/zN/u77/ad3wnH8br77/ad3xH/eHgTzaav23Hd/DB + z2n+/rv958XzeBtdnxvmn1/bma4nja7PVj9n+s883pa5P/B+9/afgU88XqxP2Pj7kuq+H7qnpHz+ + TAvxbRTf5vycxt+X1ObXz2r7R+/1v/H99znC5xPrT1be//X1nxvWf5Yfq/+MPvNFPPpXq/4z8o15 + qLdZw/23Zubx/ZQa4lspvlb/efAhvjVx+1Bf5eg/K/F6Ic/nv/r1FdR/HueH66uo2z9qWP95tH/w + n3m86Nf94T83rP88feZf/eeG9Z/lx/xn4On6XJxfV/j5yNd/blj/efI8Xlf/uWH958GH+JbEPNbn + P/nPmXjF8f7uPzer/zzn18l/vojH+Xvyn4V5mL9h/0izf/7V7Py6g/9M8zfj/sLRfy7Mg18X6uc8 + R27i8fp88p8z83A/CvtHSvkrtf2j93598J/p/mv7R/nH/Gfov3L78H739p+BFx4vrq9ymL9Z+Hzi + +upU/9n3J7n1cwrzN9H9N7n186n+c2Le9vc17B8p5a80oV93rP8szAvwYf4mn99Q2z8afLg+J7r/ + Wv7q/vmz/nMz//njQ3yTcPvr+ff6Odd/5vGCn6Nh/0iVnn8V/bqT/0zzVzH/fPSfC/Pw/Hvwn33+ + WRX3F3b9Z+Bz4AX43/3nZv7zx4f5qzR/3ffLtv8MvAY+IR/8beX+r/gOXkL7EngxXsL1Wej+K5h/ + 1pC/Urd/NHj4vuRf/vPkE/AH/7kRD9+ne/4a+p+5/RXfwR/85048fD/0nceB5/ZXfNPgw3g18An4 + MH/d90MHD/mrY/1nPv+Qn9z+s+03Uf4K6j+j/4y8Eo/fhz3Vfy7MJ+Az10uk/BXUf04/5/rP3J+M + 4w37+5S/Av9Zfsx/Rl6IV8s/b/8ZeB/f7T9/PMdXbuHxzvguPozXr5+3/zz5K8T3oviu/NXHh/he + fv5u/3nxPN6rdOZhvCf/uRGfG/IS+Mz8N953v/sP/7mZ/9zGfvcV4nv5/OT2n5vzn5Hn8a74znrO + YbzC413xxfrPyFfmv/G+fkgPfk731+ftP3988K86xbfv+E6ex9v9/sL2n9vwT5b/DH6vz09u/3nx + EnhlHscb3l/oicebcLzKPlL366vtP8/zv/JXyPN4Mb4rf4U8n0+M78pfof+cmBfjV/4K/GSKb9vx + nbwyX27iC/yeW+H+N4pv2/EdfIgv5a+k7fhOX5rH2/zzr7Qd38GH+FL+Spqbv+3LTwJP87ft+A6/ + OsSX8lfSdnwHL7F9IR6vzy3Et0ng4fpcQ3wrxbe66/N6fx94im911+flPyOfmLf9we0/A0/xrbg/ + uOs/I8/t4/23psp84vGu++97f68hvpS/2v5z//znMF7l/mgCXvj6QPmr7T/3z38O46X7b93rq+ED + V26/+Pzk9p+nf1XC/C0U3+LeXyiFzyflr7b/PH25EvxYyl+B/yzjr5FX5mU/Xx/954t4eP79y39u + 5j9//Q/3X8pfgf882g/xLcLjFRxviG+h+2/B/UEJ7+8L+Vfi6k9u/xl4//wrrv7k81eOb6brs6s/ + ues/A0/xzbg/uP1n5BPzAvxXfwP4xP1HP3blr4Cn+6/LXz1/De0r9wf92JW/Ql6JX/GdfIgXXZ8t + fzX82xDf5POT4D8P/uA/38TD/uDRf+b2sX5synw9TLS++tt/TswL8Cn41Ynbx/cXDv6zMq8XtB/8 + WFd/sqH/PPjwfJRo/iYX31B/Uih/Ja7+pAT/yvvPDf3nwYfv46jPT4qrPymh/qQoPR+5+pPbfwbe + 55+h/nP6Mf8ZeWFegA/fX1Cff4b6z8MP11/954b1nyc/x4v1nBPz6HtLC7wSv+6/6D9j/Wce78l/ + xnrO/nye/Wfwe+n6LJif3P4ztE/X57P/DHzuxOP3j0L9SV//uaH/PHiuLyqUvwL/efKh/8rnRy/g + Q31vyl+B/zz4L77AC5/PFd/8Y/7zBbwwb/m6Xf9588+R6//+H5OBuzxw3AcA + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:46 GMT'] + Last-Modified: ['Tue, 31 Jul 2018 15:23:04 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/fixtures/ndbc_realtime_txt b/siphon/tests/fixtures/ndbc_realtime_txt new file mode 100644 index 000000000..0dc9b11f4 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_realtime_txt @@ -0,0 +1,1070 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [Siphon (0.7.0+38.g5e7b937.dirty)] + method: GET + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.txt + response: + body: + string: !!binary | + H4sIAAAAAAAAA7X9S68tu5KlB/b1Kxag5sa+xYe/ZrOgSJSycYGAMqCAmkJJValGqABJHf37mu6k + 0Wl0PsbgmrNQuZHKc/Z37XCaG41mNsj/9n/6n35+/vnPn3/5l5//+l9//uM/fv79X/7z//Dz7//l + X//l5//1X/7t5+ff/8f//v3nz7+8/79/fv6f7z//+e/n/+1f/4f/9F/e/9//9s9/ff8r15//8p/+ + /f3n//if/8vPv/7bv7yZ//af/+U//Tf/7f/9f/z8/Mf/7+d/+b9//uv/8fMf//vP//K//n//7ec/ + /h//50/44/3/+4/3//k//9f/d/zz+uc/P//1X//nn/P//t/pP//3//jf4j/7+fn//F//jTP2+DHv + /7/9seuPNT92Mz8/2z/ef+znH9d/mPrz/X+sce4fL/l/cEf2L95/vP8s6OZNXwV89Oj+/ocl/Y/5 + x1ahLz/rk27/4a71Of/C8o/1x5nXgN6wfflZmvTrL2R0fmWWHw+vjPvHQdNdTn/16TtNtxndmj59 + o+niMwdg+1b7hx2f8dpnXlWfsfs+oDds99pnUNvBlfGXzywgfaXpjqAvNN0SK8PTTbQd8Rnf9Bn7 + D1uhu8tnCrr4zHH5zPs/b9kKOmi7Sz5D2Q7T/czKwHT3iXVv0i3hkbzt+N7U8ciGz9jkM5W9af+J + ceb8d2Zst5fPfGtlLBVn2F/VUnHG0rYzPsPTT5/xoM+YFv29N60Vurl8pqBH94p70ztIX5+Fs3TG + YS6fwWy3dE5gLp9J9O66W3rnM0ScsfTOZ5LPfIee+0w/W8rSy5L+10gMyunv9HN9rrv4TIgz23vx + 1kDP/d2ObX/T8TiTp8ZQJHjT8TijVwazHY8znXVv0hmf4W03hO3NCPz2mVeFfozjzHvx/D63Mkfy + mfGJcoYucWYDohi5873/dDl9YDuZpb7/tMTKkHHm/PMT9L9W/r8VfU/5TEbXceb9n3e4Jx3x953y + GZ7uc/rAZ3i6nLW/Y7vN6QPbN5qu4swsvRFntnEO/I4za4wzZI3jTWd8hqd7gv6q/cMu3cF0Oks1 + m/aZj9MNQW/G9z+mGmfWVJ+pxJlU09v81MnmTV/gr6lje5PuCTpvu/sqXdVnBnR2b1q1z8zSGz7T + qAPnPvP+4BYzZ/tC1fR4uifobMYR6sAb+KvydEvQyTOfCXVgtDOx1v5h9JlKHdiEOnBhu96b3smg + 28qV2bNY37Y91IH5lUHp/qt0l6/7x+lMnOHpeA6c/aoVnzkqdKf3plqceSeDi5+z3em9Se18119Q + 9J2me2LX5ulMPsOvDH5uyiMwSsdz4E4k+JPOsopuIZ8JNT26lmpsvUdZ+MyDDq6MJXLgPFtC6Y5Y + d0vT8TjD5++WyGfySm3pM0Z+E0U3PZ/Z5VcNnef8ZIOtjIHijNDZSGCIHHiGjuczdA3b3HXgFTjz + sfmMoeozTfrfMgfef/z7U/K6PvOMM+d/krMbW1sSOlO5ws9NQsdPlP0K+Vah393b5abHgkWMwGem + Z9mKodCXnL7m9Pg1ZXQ8wxb6+TXtQt/w2hJGxzM9xt+FfvqMi+BR34On5x3/afqjqxLoVnX8Iz0W + RlOF3L5ec+tuaydKm/1VRcdrekJnIjBPd9Ej19vfPxCBhW5z+sDfeboh6M2KYcNnwq5d0B9dFWvZ + eqTQlyY9+Uyip5VRf/bo/hMr06S7r9IZn+Hpn/KZyt5kQ/f26PnMuXuYKdvta+wzv6J/0Wfsa9Jn + Rnmk0BmfaebvTbp5/qoNemdKpB5n7JHiTLNCfv6qbkBv2B66t4dBcjHmVCZ0/7S9ScdPlEJ3xLrj + p2GhW4LO2658ZnZlHifKQN/rcSafen2f+dw6Z/uefOZJj3GmQT8A+lb398L25Xj+qhid8Xe8PiN0 + 2T3Y2tKe0/+U/dVAX9PKNOffN8kj9crsgO1r2j0Q23m6j+uO0B1NdwTd0nT7VbqB6XpvKn2mlnEs + Y585F2977quI7Uv6mpC5JZ4uPoPMXPF0R9i+0XRL2L7SdBVnZm1v+IxPu0dl/j34zHvx7Dq3Mr7m + M3r3yOjsyngdZwYrs9N0R/yqPF2yVITOrzvjM73+6lGhu+QzTZ3N+1d1y9yv6qg4k++rG0Rn4sxK + 03OfGVWueLr4zAugNzugTboh6M2c4O0ze4Vu096kqm4X5mcVn7k+C1UHxnzGpnzmSc/izDTdEyvD + 011Ot306m3FY7TMfpxuCblr0h2Yi0E3dZ/I4c2omzIDesP2uumW2673pV3QPr4xpZ3pNulT3xx5p + 6L3JEHFmho77TIde75VFzcTW85lzbzqmbI+aiYLetJ3ctc1ddUPo5L5q7qrbeOebsR3PZ2ZsN5+w + /W81nzGHPjfV8plddMO8zxxqb/r0uhdVt+6Jkl/3gzg3zdhun+v+Qdvx+kyH/reaz0TNxOOsnecz + h+wevM/syWe2Bz3uTb+iqxnDD/+qOzHHMUPH51JnVub0mVekT+/a9Y5Q1EwkulNxJvnM9VnwGUfU + TKB9DzLTi5qJNK0w6A3zdJl//w5d5sWQ2R+yhl1qJgY1vV4d2FTodx34lftMiDNp/l0musgKedRM + HDHZsB63HaPjcWaGLnGGU2midHxvmll3Nf8+8Jmm7Q2fWXQOrE42t89I1Y1dmaV+1s7PTRmd/VWX + FGeQCvlK0yWf4dSCKF11EeHpHJR+jkg6sZ2oXGmfKTWggX7VgS/6/vhVk9bcrsfcr3rVgW/6IM6w + 667rwEzVDaO7p79/LIp5HWdgzTNKZ+rATdv/2Fp9xnTrwCGfeUeB12M+ErN9vg6M0ZneAU9n+k3s + r+pUv4mpR2J08wnb/7hqnLE9n7njzON+Asx2S/S1dYaN0T38NenTAUZ3BH2n6XicMXSMtMln2CpE + mc/U6jNm3G96+8xu52w3RJyZoeNxxtD+bqj6jKXp8CyEfdH+bvBZiB69Vgc2opmoV1DSJJ3dl0Cn + vqaLDseZN53K9C46PD8zRYfnZ6bocJx506mvyYiaBPL3N73Zo6zVgY2oSbrzM+99afWBTvX5jKhJ + oErtFB0+N73pzSpEkw6fm6bolqBTFUMjahJ03ZuRoFYHNqImKZTs2mfecWZzc3HGpn7TcIJxig5P + eU/R4SnvKbqNtdSheupNP2i6Iei9vakWZ6585qze59XOR5wJd46Su7aJahKwTpAdHWC6j7YjmV5O + R77VkM9IhfyjGYcRNQlEn1r3vHfA5GLA3hTVJAX9kQNfccYZ7kRpRE2C2k5lqUbUJCidt/1ym6/R + GZ/h6cy5qbmv/q3Mz5xcfW7S+Uyqz2yVcxPwrdpCTfLJPt9Fx2fIyT7fRcdnyGdsZ3yGt53xmSa9 + 1jswuZqk0tdOd6gvr0Cn5rBNriZ50q+/oOjUVNRFZ3yGp+PzwDN0pqZnMvpwcvSiM3tTT3dQyYHt + Vt+b8lmIM86scz5zq3iOB/32mRodWZlNzQN/et23lM+wPoPRJc4gc3o8XeIMO8Go6DV9k8n1TZU5 + vXSHuszpsb9q6msH27v9Jn5lCn3Th3/V9QefIdfxHaPjcWZm3fEZ8o7tjTiz9GbIk894P7cy1b52 + 03Zqdt+Ivul7dLxHqfN3jG6/SmdmO5v02gy5EX1TQddxZrluA5myvagDz9repMP9puI0jNHh3sEU + Ha7pFXUCjK7yGZSu/gw+81DhG9E3Fbt202fykzxiu+5rj74mns7MdrLrft8qhHyrPF1mO7NZt495 + pCNmIfo+U4szth5n8r3pna5dOvkJ263SHYy+VXbnI/raU7bD88BTdPguwCm6MaDeo7fujThj1Jxe + 670y93r2PRDb77sAf2V7kw7fbTxluyPWnaerGfKP224+Qa/XZwp9U2tvuu425m1n9E1F9xaj53vT + 5+mOiAQ8PX8TpnsaLjqgGN0QX1PT9nrvIOqbGu8iBp/xMZ8puuaI7Uf9xjuto/wF3RNRjLqpxIi+ + 6Xt02ZuGp+GplZFbEn9F/1vebRzoe/KZZn3mHWP8Mefv95swnRnyRGdXZtd7EzFpgdFzn2FmUDC6 + Jej8usNvafbof1P5VdHvN2HUr5rfbbxcLzBNReBN+cyHd+3sTRiETtbFsjdhkDhDZqlR34S9KEaf + yjJ9E3Lma/p7I59Ze3Em5cBS02P9fU0+MzxRFvQVokucGd8vNmM7/sbdDJ3xGfZbXZXPTFc7azfe + GdE3ie3NvWmds32p7U0fW5klxRmkq8JGsQWPM0WFHPH3ReXAzIQ6Zjt+63Ovd1C+2Rvovrc3pZkr + t87Z7mt7U3nvfqKzPlO8DU5M12N0Js6wHul1nPm47Up7OxsjGz5TvAmzP+LM+g8b6zMTEfh+E2as + 1+ZX5n4TBqGTE7vZmzBjRTU9WUS9CTNDx9+EMe057Hpf29y3yyvdQe4zLtZnevSG7ffb4MjKUDp5 + Q70JU2SpGB1+R6jIsDH66TP+a3RD0Hv3z5gK/X4bvBlnzuR1f56bENtNzWfys7aiU7fGGdE3ob8q + G2cM5TNsfcbgcWbiJG/wONOtzzxreu71eBOmsTf5nV+ZQIfjDKlVCXTGZ5h1D3SH7nxTdOkdDHe+ + KbrJbZ+lV26XP+nAG3fvXObwcz5TfePuI5Eg0OGz9pTt8PurE/7uUk0P8Uh+ZUzukQN6b28qz9on + /dY3qfvfjfYZ0Tcxk9KBvjTp11/4JV18ZnirUNEBxehMnGGypUDH33nmMr1AV/0mQglTxhlTod9v + 3KmbNfUrFkmrYlr0hu1G12cGFRRmfibQ897BJyu17iX6JnT3YKrMgQ6/fJL7u/qzRzeE7c0KyuM9 + +Yse9U2dt8GvLHXdpyKBfdXjzF2fUXQyEti7r81qEYFfNb6Wg8Z3Ms5EfdP36Mze1PyaKvfpnfRD + 701P7W34Ve1UnLFHzWc+FQnsfW8n8jXxdPX632D34FeGyYFZfz+Sz/hf+kw5p3fSb33T1QzyKp+R + Oxjt+praPTJ9U0Zvrjt5OrB3X/uiL5PVziZdZsg9WXXD6OdQlzNALjZFP0sFFvHIXg270qM86be+ + Se1NwWdSPiP3zzBdlUCHz03FymD0vHcw6qqwPhP62lZ8hqi/Y7ZLTW8FMj1+ZaQ+g3yrTXpltvOk + 333tRpy5/pOOZc720Nf2oO3suq+6d/Bhj1zTuWn87u0MXc5NnowzGN1MRmDEZ66+thPbi5dpUx3Y + V/TaiO1LymcW4Ftlo9iSfMb/ZmWadLU3fZwu5yZkb/I0XXSUCL3nM7Uc2Kc4o+4SCT6T6jO7mbPd + Uz1KR9Ph+kyRiy0QHb9TeoYuvQOEbmi6Iei29g+jz5gK/a4DV2p6q/jMy8zZfr+ajvgMT2f62uyv + WvS1P267/Spd+QxKr/hMqb096Xdfu1kHPu9Gc89TGWK7xX1miu4J+kHTYZ+ZojO9A54O+0yPXtHE + XVMxdZ+pvYBdVN0Q2w3lMzwdjjNT9NneAUZnfIanqx7loKvSpNfjjHnV96bgM2FvkveGeX831Trw + p37VTN/EduIwOlMH5ulMHXil6YbwSN+i1/tN5q4DV3oHt/Z2efZXEdvvOjB79yVGlzow29fG6HAd + eMp2S9jO083Myqg//9nqa5vG+02FzyyTPrPreyGI2R+M7gm6o+nwPeRTdPj9pim6+QS9Pj8T9U0F + Xeczb3/ZKpo4D9i+UXe98nT/xUiwURp/ns7cKc1+TRt1P3Bz56uftaO+qbs3yY13xa4NVFCivqnu + kddfUHSyYli+30SsDEZnfIanM3GGX/dZjT9wbsreb1KK6mJvWpe5XGzRPkNozTE6fP/MRCRYtM98 + nG6JTI/NsBf95hcxQ6595qlVOem+F2eOn9ijlHsh2F/Va43/h1fGU3GGpzOznfzKMPfPsB7p8Tm9 + Hr3eb8r0TZU4E/KZ98a+VFT4iO2ufi9Evjf9is5o/Hk6rImbyFKd9pkBPa9hI3uTo+4SadIbObBV + 2tvqXSIvqQMfqvqD2H7XgZt3ifyKDuso3/SDprvYk/8OXembBnQ2n7nrwOO96WjnYpU3MtxL9E3F + uut85iU3xPC2G1yvPbHut75pfC/EDB2PMzN0WHtrs/9pMIoV+qZBnKn+w8tnKvnMkeubKj5zLsR6 + 3ipklmcUG9p+iL4J+5rI+H6Ivim9wDHI9HjbXaQjqgZq5ztE34TSqXzmEH1TmhfrzXGwZ+1D9E3n + SxBq5splPvP2F1tRkyC2X/nMz0vTm7bz9NMbzymRq6k6uPuSylKPqG/62UA6+6te+cz1jwxAZz3y + ymdgeq+m99AdHFHf5NIU4FI5N5190oomDrH9ymccNFlU+MywpndEfZNLU1Gznbgm3UU6MgXIRrEr + n3HFG9UfpJtAD++aD+79adJr/aYj6pvc4032Ym+yZm7dTfKZ4Q0xU3SPrvsU/fz/p/hO3MaK0eW9 + g+H0Jdu9PXJ9E/I1NeN7PZ+xr7pWpfCZ67Pgd49M38TefoDRmVkIMoqV+qbZuliTru4hJ5QwGF3u + IUduOe/FmUcd+E2/+trXy1YVHWWq6dl4qxCZpdqrr33TZ2Nkk+7jyiD3XPH02XdvMbr9Kl3dWTTw + SKpHeYi+qbgRKZ8hv+b0ZIactf3uay9f+JqK95uIewwxunojY+CR7Ne0px4le9MgRpc4g+RizZ2v + 8r72Sd9SnKnUgcPeFM6ED/UUYvvV175fjCQ0Qhj9zGfSWZu4XwyjSz6DzNTytkucYTVxGF10B8i0 + ca/fZCr0Vb/5pe+5us9NbuCRDdvv95vYuwAxusQZZG+ilDBH/n4T4pFUTe+I+qby7dgP2h7PTQFM + 3AWotSrP+4FPetA3ubjkdlE+E/amI1b3e/SG7Ut6w/T6VQcrQ2lVjvz9JvauV4zuvkqH5/SKnACj + q/coCSV7qW+q7U33+03qzqLwrkqKM3KnNPs1eeq9A/Zr0u83Ma9YYHRHrDs1P3M83m8iTmUYnfGZ + XpypnbVd0vhX7ka796Z1qpaavd/08XmCQ/RNM78qRpf3KL9juyXoZC016pug11179EY+Y3tvJb/E + Z0x5SyJou9U+0+hrm8ptfRidmQfm6XA+w3ezor4J/VV5OvxWco9e095eRYJqnMn3puPuHZgWvWG7 + qb2V3LD9oGt6Rp+1P07H3xY86Dhjks8gPXmebj5Br/coo77p8VZy3qO8cpkp26O+CXoX8U0no1jU + N0GvSL/pZJyJ+qbv0eE32d90svoT9U3o19TTN1Vy4KhvauxNKZ8xbm5ljvqb7OXeNE33cASeoTti + 3Vl/v+vAiO3st3oQuoMOvXY32vVnR9905zPHnO2MvmmGjuczB1v9MTt+1p6i20/8qk26miGf9pnq + uSnTNzXOTdfd9RIJWNsZfdPBVpmjvgldd54+6zPAaTjTNyFnPkPTmbN2bx640qOM+qaiylzvHbCz + zIfomx4ZdnFv5zyd0d7ydMZnyMpV1DehdGpS+hB908y5CfGZRdf0anHm/f/yivUZslIb9U3or8rT + 8TgzQ3cEPc9nhrf1HaJvQusE1B2Mh+ibUDp1B+Mh+qZHPqPrMz+vyv3AiO2+pokrc+Bf0BlNHLvu + flpHidGZt5J5ev6+9m/eSq70m6K+6fFWstc+c7ye1X3Edve1N9kD3Zu5zgRGZ3SU1O3Dh+ibfv2r + Numf8hlTodu6z+Rn7V3OTfy629qb7DrOZHR23e/3Dj79ymig528LfvpXDXVgVE3C7nyW0qostX8Y + faaWz9z6porPnMt8npvS7kHd+nyU+iZGi4jRGR0ldR/2IfqmGS0iRme0t/zKwHN6tvPiTM1ndtE3 + Nd4WDDnwJnVg8k2YXfRNqO3Mi2KBzrzFw9OVXpu4iQqjq7vRCNuHPrOLvgm9T69Jr+kO9vz9JnXX + 662jvHxmnXiTPdCXJ5339yZdzk3foUsdGLmTjqdL7wCxnXqLZ5f3mzC6Psnr95sqfe1d3m8q3oTR + e9N21/SYdxEDfcnXXUWx6y/8ku5zevdrmqG7fN2JeiRGx+dnZmxXvQNCN3zk9Jpee//J3m9q1vTe + v+g1VtajN2w3VH3G0nSmPuNpOqNVWWi6JXYP3nbZm9hX6EqfqeQzUd/kte2P3oHcP7Nxtkd9kwNt + J7/VqG9KK0OcbDB6rvEfKe54OqPXpt5v2kXflOizr0PV8xl7pDiTKe5EqyJ97VCfKfQeiO0Hns+w + L/1c9FN3YAz2IgFPl3yGXXeMbqPtrL9jdHmLB6lC9HLgWpzZ1fxMoYkLNb3zP2+Zs30f9ZsUnXrZ + ahd908tgL1tRtaU96pucRzxyamVOn0nf6sdtV/omQjc8fFdll/eb6tX96DNvg1+Vmt6wZ7PL+02L + wfTa1KT0nr/fhHxNPF3VZwbrTvUod9E3oXSqR7mLvunX9No88C76pobPSD7z86rsTYjt67ReG6Mz + 9+mx/n7f2/kd25k7GFmfWSlNXP6rljPkrkJf6rMQ+Zvs7xzYu2dOMJxB2UXf9Gvbm3T8rE3e3LDn + +qaPv2KxU/om9gaBXfRN6Eud7XlgW81nfK8+E94wte+d0T3PfMO7FXbRN6HrztP9DF392aMzPsPb + zryVbGi6gem6pqfojTjj6j4T+tpr9Bl3lbrz+gy47o7yGXZlHFXTa65Mk+6+SrcE/aDp8DtxPXpN + e7uLvunhM1eIymp60WdW0nZb25tsFgAV3dF0XBN30JHgrgOP4/uhdm2MrjRxKB38Vi1+/4w92t9q + bX7mOvBV373Nfeb8RdcBvWG7SVoVpezNfeZXdE+sO093sYIypu90JDCEz8zQDUHfW/Tauyp7rm96 + /qqx32TlbrSdzfQofZO2HaPjPrOzeWTQN8E+w9Nx7e0M3RDr3tOqPO5g3EXf1IgzIQcO8b9Pb9h+ + 6DgzWHdKI7SLvul7dOUzH/b3uw78HfpsnCm1KqZC38dx5izGveZs32t708dWZtc6yo/Tce0tH4H3 + lAOPp9Fm6Iz21rTojTizpRy4MQ8ctLfbM9NDbN/SuQmxnaf7STqQE2T6JkR7S+bv1PtNM3T8zS+t + AXU5vXaf3p6/36TqwHkObKUjRJ+byvebBuu+t2xv0nHdgaZbiI7rDvT8DGY7/n7TzMrgvYMOvTZD + vj/eb9J7U6oDH8vcyhTvN314Ze73m5AT5UHTGZ/h6Uy/ydB0xmdeLfof+9T476JvKl4p0nHm/X8/ + jqnaUvl+ExEJMLon6GyMLOaBCe0tRlf9po/T1bu3xBQgUAfO9E2q6nYtcDw3vT84X76Wo/5s287U + gWfoeO+ArtRm+iakhs1mS073Dgi9NkY36GTRoHdgKnSbzk0ZXfvMevcOWH+36dyE1LDZSHDXgcdT + UXweaXUOPDiVsRG4mAcenJuaWWqTjveb9naVuXb/zC76pkfvoPSZ69y00ZHAEO9rb3ROcL/fNN6b + NuWRGB3XUW7tnKBJV+emgc84mi4+M54s2ttZau3ctIm+qaDrfGaTc9POZamb6Jt+bXuTLjnweKJr + ho6ftXfOIzfRN2G9sp37mjbRN2HT9XsnB66cmzbRNxX7qq4Dv/1l98/qz/C8uom+6ZEt5f2mBh1Z + Gac1cUTlCqPj90Lo6g9GZ/ravO1S0xu/q9LxmVq/aZP3m7wpZsh1Dmz3ZUBv2B7ebyomdm02apbR + +XUP7zdJpbYfZ8i+9pa93xTeQBrkYjxd+k1X0bSbpZLZ0ib6Jrqvrf5s702m1zvY06+6DjqgDdsN + 1W+iqvub6JvQ+E7N6W2ib5qJBBgdPzeRFfJN9E3Hb+m1HHgTfVMxnVPmwPZwz7MHYHvUN6GnYeom + qk30TTN0zHZH/KrUDY+b6JvSdM7Adupm/O2nfL9pYHv7LZ7KfXpv+v1+k+prXwljjDPvbGP1c7/q + /X7TN9Y96JvSqy2zK9OkOwO+CTNl+9nXdrLzDSoo1B1dFz2fhRjRmx5Zz2eivqm4eU3iTPKZbXnW + ZxDbq/qmpu3UmwFbrm9CPJL9VndqTo/SHWzyfhOacVC6g030TehNstQbGZvomx6qtdxn3vvSuj3p + yNe0Ee8dzNDx+4HJ+9830Td9j47fD0y+Ir3l7zex988MdQeb6JsePpPvTW+f2bc526v3dn5sZVbK + Z0xGB/L37P0mtkeJ0Zk7pXk6E2eaJ5s/9nmn9Jbrm9QsRJnPHBO9gy3XN328i7jl+iaETr1huom+ + acZ2oE5A6ZsOrg68Pd5vmq0tNeKMr/vM5djx3HTGGTdVW4r6JnTWjaz+RH3TzCQdRmd8hl8Z+A1T + vpaavd905cCD+vvRotf62lv+ftPx9Jk7n7EDesP2u69N1d/Vnz06Pqe3q10bs91lKzNad0fTLUG3 + NN1M0k1Or92nt+X6pswjbdiEbp/ZfKCbFr1huyV8Rvf5MLon6AdNx/tNM7bjPcpN5QQY3RD0rUWv + 95usqc8D53Fmkb2pQ2/Yboh5YH5lDOUzPB2fhZhZGXxvmqGbT9BrmrhN9E1FFHucm1ZXzBOoP5u2 + mxcVZ8iVifqmL617fL/pe3RcdzBDx3UHHXrtnqstf79JxZncZ6zUgXnb7/ebxvvqDB3PZ3J6PgfU + ozN7E0+3me34yqB0fH5my6qdBf1vNQc2e31vyvOZsw4c44wnbd+pvYmnMz7jaLqbtH140+BFZ/IZ + no6/kdGh/63WZ0zjnqsinwnvqmj68D69Ldc3IXN6K01n8pmNpuc+05+0yDNslJ6/d8DQh3ejbbm+ + CfH3Jr2midua+qY8zmSzEKZFb9i+1uKMzRZV0S1Nx31mV/6O0Zk5PZ6O70272j0w+txs59Nnajnw + os7aRT6T7oUI56Z8wgWzfSH2pp3+mha1N+GVK5Tu4G91ZmVUnPm47VOznerPf9bfSt7y95uyGKn3 + pvWuz9xVCMz26vtNH1v3ex4YWfe99g+7dNE3IT7D7qv3ewfcvRAoPdfewitT5jO1O4u2XN/UrOlt + l089/B3JxRyhO8gr5FiW6igdJU/H7yE/6Az71jd9x3ZGq/Jq0Ws6yk30TcVM7dNnHlPemM/Y6TiD + 0XGf0d8qRsff4tEZB0Zn4oyj6bj2dm+fm+r9pqhvKtbdBneLPnO8fWorbFd/tm03hF6bXxmjdQcD + uqHpc/omlM6ctVl/N1TvIPf34d31q+ibumft9SfeWbRxp4M1f78JqS05mp6/EzdaGepUtoq+KSnu + BnUCnm4JOr8yBo6RHdtrM+Rr/n6T8pk8zpz3Wu+Bblr0hu2O0PjP0HGN/wwdjzMrdzpYRd+E5e8z + dKY+0/aZSj6zyvtNjxy49JlKHRixvZrP2CzRUnSqCrHK+03Yus/YzuxNK023hL9T56ZV9E2o7U16 + w2fufObo+cw6sa+uom+aWXeMjt9ZNEOf7Tdh9K/lM6vom+g5DvXn6TPumQOvom8qznwu/G/Emt7p + M69npRawPeqbMG3WDF3pmwZ0KsNeRd+EKu7IX9Vy93ZSJ8o11zdx85Flv6miozyz26RvyuKM+Ezq + HRzrRH3moouOklPho3RP0Nl1P5JW5aK7Pp1fGbm3E5ntpHqUF/089jmD1PQyFU8ZZ2rzM2vUN116 + 7Wzdtc+cvYP9p5iUxmy/+tonPVd+5auv6M2efJPuc9sHyi9qnmCN+ia3aNs/SLeBDtm+0nTxmYvu + e/SXiu9lTa+2N2165qrmM6l30KE3bNf3dmp69JlEP1QkwOhxbwq/ajcS8Ou+pRx4HGdm6Pi56eCm + RFbRN2Fd8w699ubXmr/f1MyBnZxs+JW57+1EbGc9clX1mdG6G5ruvkpnfIanG4LeizOmQr/v7ezu + TXaiq7KKvunXtjfpTI+y2VVp0h3s7zsdI1NfO8TI7u4xQ481PeAelH6/qbY33fd2ZhH4EWfWfc72 + VAfOdw9dn/kV3ef0D6/73ddGcmCebnP6hz3yrgMj9PYsRD3OOO0zEmes9pndzp097jpwtu4uk+j8 + ku6JlWHzd6d9ZkBnT/Iu9Q4QOntucpTPNO9gbJybbPKZSj6TdJSiiWMrKHcd+BnFsjhj59bdUj6T + 2w7UUq0lfEb3KDE6Hmdm6LjPbOpbLXuUNZ8x4jN698h7lFb02uRc6kVfnrbbzCEyOjk5etHxHHiG + Puszw9s+QgL8Vbp5fqs8vaaJW0XftPV85vzndsr2qG/a4qLYweyPoekqzgxWZqfpDs6W9NeE0e3z + W/0g3XyC/o4ze4V+UHGG9ZmjlgN/6muK+iY0B2Y98tA+M8iBLU23hO08HfeZzsrUZyHMDvnMVsln + ENv3+rmp2Jvm6cpnBvlM9R926cy5ifXInYoz+dc0vJnnohvY9g79b2UeeBV90+Osnc922nse2JK2 + b7V8prnujqYzObCn6cy5aaHpzFk7pyMeuRE+o0+UyN601n3m1t4ubze0e+xrb6TtoQ68lHHmTkEV + vWl7ky5317MdUIzuvkpnzto83RD0Xj7zuEtkFX1TQddxxojGv0Nv2L6Iz1TocW9KdF0hx+j+6ZGN + lZmhu5zezTgOel9dtM8MbHc0Hc9nOvTGucnX85lib9pi74CNkdU68MdWpqgDf5zuiF+V9RlPxJkZ + Ol6f4X3GSZxp58Dv/7yj0m9Cdm1H5DMHnXEwdeCDzjiYOvAMHc9nZlYG35s69LruIOqbHrtHfp/e + 6TNuznab9iakR8l6ZKgDe4N1zXm6y+lEfxWj22xl8Pv0ULr4DHdbHxZnTPKZpu7Ay2wnnxOYmu5A + 9w4yOrt7GEJ3cLBqEmPULARMV3/26PksxOdtN5ntzLeq6LV+0yL6pka/6Z7tNBO2Lw99E7FrY3Rc + 39RZmSZdzUIQcQajM3sTT8f1TX2fMRV6Q99U3D+zViIBYvudzyCqZJ4u8zPIOxM8ndFrs7/qfW8n + d4MvSv9InKnlM4vomwr6Y7ZzebyRAfRXF9E3zcy6YXT1tiChk8foks8guuFmb7hJtzmdUAZgdAPn + Yh16rT6ziL6pyFL1/Mw5k7w96zOI7YbIgWfoTE2P/VUNcdaesd3CK8P7O5fPNOl/KzNXi+ibRnFm + O6b8Peqb0GkF8leN+iZ0tpPSIi6ib8LmCWZsj5o4qItIvR27iL4p0Qf1yLbPVHqUZ3YrmrgwrSBv + JRc58FLJZ5CVOXR9ZvA+H0/H372l91V7UOcm6qbBi26/SmfiTO9eiMq5ye7jOPP+t+T9Jtb2ncpn + qLuilqhvgk8HbJzZCb32we5N8f0m9FTGxved0B282nGmdnf9Ivqmh+4g5DNBe7vG+nxBB/L3qG/a + oAg8Q/c5vRvFZuhMHZiaYFxE34R+TTyd6R006X8q93Yuom+qT19m88C+oKs/27avVH2GujFjyfVN + 3/hVV+0zg1+Vuq1vEX0TTYdtN89IwNP/VN6jXB76pppWZZV7IXjbFz1DPmt7k874DE/HZ654j1yo + ml7zNtYmHZ+f0TlB6TOP+ZmloW96nLWX7ZktIbb7mlalaTt1Q8yS6ZvoThxGZ/YmsmJI6Zv0yQaj + M7OdlL5peeibxGdc5jPLPX3J7h5MX3uGjs9CkHfsLpm+CaKzUazoaw/o1MzVwuqbmvRGPmP1/Iyv + xJnTZ7Y52y0RZ/T0JUafne3E6Lhem5xlXnJ9E3JHFzVdv4i+CdWq5F+TfsO02juwpqZV0XFmve/T + o2aZL3pFE+fuQP5bun/azq9Mk65qesSLBMivauSs/XklzEWPPhOqbgN6T99Uqc/U9U3aZ9JbyZ1b + tOq2Z/qmJz36TEYnV8a8KJ8hv9Wob9oN9q3ydFUHnv1Vm3SpA9thFaKj/KrdJbKIvmnT9Idee63c + p4fYfug4M4jAlGptyd9vYhWmGN0Rvyq/MrGvDdyINENXPtPt+Hfo9R6lufVN7qY/cuBQ09P3GCK2 + 71p3MFh3atr4onuCztuuZsgHcYanW8J21md2mdPLO0If85lQB/ZlnLn+N2Id2MX4X9yXitge6sBe + r4y+5yqjsz6zEbqDGdvxvvYMXfnM4Ffl6eYTK1N7v2kRfdNS/qr53uTf//yYs339apwp9E0fjgQr + 5TNsJFi1z3w4W1q1z8wqexv5zNLzmRBn0pwe+SrXkumbIHUsT8fjzAyd0VHydEZHydMZTVzv/pla + nPF13cEr8xkvvQPyDpdF9E11etybavTS9iadmbnibZ+9swijMzU93nbGZ5q213sHt76pXQfe5A5G + fmWc9pnaWTujsyvjvuozLu1NyH16hqbjmjjyzqKF0zd17iz6k1xZ0W3dZ6qzEB16w3ZL9A7IW/0X + 0Td9j87cWUTdvLbk7zchdOputCV/vwnJxZovLL3jTO3cZOr9psvIrA4cfYa6G23J9U2I7Yam43cW + rdxN4Uuubxr/qjN0/C6RlbtpcMn1TcjKNP39T+VeCJ/rm9TMVeEzixvQa7Z70TdhZ4+V+5q86Juw + DHvl/N1n7zdBvyrl7z57vwmgL9yLYl70Tdi5aWl75N/KG6Ze9E2F7dpnNpkHXrivyYu+CV0Zno6f + m2bo+L0QnXVv0hmf4el4fabvM49+kxd90+OsvWY+c0hHaKHjjCXuhZih43XgGTrjM9T7Hl70TVhN + j/cZS/lM82uq3VnkRd/0mIUofGbZihip/mzbnvKZvL/qssJRRud3D0P4zAwd95kZOpPPsLu2IWau + 1rYyoKaj9Jm+SftM2JvSuUnymaaqoW571DdhfY+O7U064zM8nclnqJO8F30Taruh6SrODNa9Sa/p + m85bQupn7Tyf2d8+tQQ6VZ+56BWtirt/vt/S8fuBZ+i4xp//mkJfG5vO0WcPjC7zM4hHNum1+Rmf + 6Zt0nClmrkJ9hre9uLdz1vYmHb/rdeXqM170TcW++kE6ftfrzMrMnrVLn6nFmU37TOuNjGUuvm9E + DqxtH3ZVvOibEn3wrVKz+/6nfL+JqM9gdDWnR9SWMLqZoas//9mqz9zvN+mzdt7XPs/a+9y6r9Nx + BqMzNT1Kd+BF34T6DKXI8KJvkldGRzsfvzKnzxwgvXf/TC3OLPJOXGXCJWriTi1nJeNAbF90HXiQ + i/F0Jp8xNB2fIV84zYTP3m8ClL36rI3R1bu33XtQOvRaX9uLvkneFoy2P2Y7HzW9Moo1bPfy7m0l + il1/IaPzv6onZjv5X9XreeBBfYany51FSIykZiG86JteBumvduh/3FNH6UXftNfjzCOfyX9VJJ9x + tb3pMac3T8dz4IXOUh1x1uYjQdHXHtDZCOyIHHhp76u1HqUXfVOyXe7TK+569bGmx+bAtjY/A9mO + 0fFZiBm6moUY7E1sfUbf29mne24Wwou+CVsZ377ToqajvAJkdeZqz3zGyWynp79Vo33G5PRsb5qm + e2Ld2fOq0bOdg3Vnqz/mB5+F8HQEZvraHXpNE+dF31RkeuIzIQe2churY/3dpDpwhR59pkZXf/bo + uM847oYYL/qm79HxODNDNwS9rdeu+8xB+Qxre7UOPLYd66oYpg48Q8fPTTN0XHvr2l3EJj33mf6p + rEOvz0KY6j1X+v4ZK/dc8bbf91yNT5QzdPx+YMf2hs2ufGZEJ/vaJtWBv7Qy+P3Aem8CZiGy95vU + /cB5nDFyLwT/NW01n3m8qxLonu0NZ+83IfkMT8d9RuczGB2PMzN0fG/yXd2BqdDXXpzZ5VcNWhV+ + 3VeVz+gbq2+fmaczOTBPZ3yGnFYw61d9ZtV3MA4y7KVFb/jMgu1N/nmyQWxfiHzGs1NRprjnakDn + bcfngWfozLmp+as26YZYmaa/1+5g9Nn7TZXT8L03hako/mvyhO5Ar8zwtXqfvd8E0T1NZ3yGpzM+ + w9OZ+kyTXu9Rtt5vKvOZ4xnfEduZe65m6IzPsB7JvN+k4wxGZ3xmpen4HYwZXf35z/odjF70TQU9 + 95nwYqSb83dbu4Mxz4EV3dF0T6yMoel4X1ufDjA6PnOVnZvKX7VJx+9G06eyMs7U9iZT06pon3nH + mCOem9iMwxBxxtFfE6Nv0mdtjI7f2+noOGOIODNDZ3ymSa/NA7vzf0DFGf3ubYozr3XC9osucQap + XPF0/L2DGTo+2zlDZ2p6zd2jScfvrnftXbt2bnL5+03NOvD7//nwA3rDdkf5DLXzufz9pvGJcobO + 7E3UvupE34RGAp6O5zP5eHbhkQ2fsb04E+oz733p9fCZ/Amstu1FPvN8X1vRV5qO58AzdKZ3wMYZ + 5t7OfF9FbWfizNaiN/amRj6T65vOjf0Y0Bu2G6rfxP6qhuo3sf5uKJ/hbVc+A8dIlM70KJv0mlbF + ib7p0XnOfeb9SRz71LrbRl8718T9ip7XgUc9m6X2D7t06WsjHSHedkvQ81/VQnT17m13trPj77X7 + 9N70W9+UvYuofeb9b+12Ks7Yu6990btvOtLx3d597fGbjuS56aJLPoPY3jyvNuk2p8O2o+tuCHrT + 9obP3H3tbGXEZ9K7Kq9yFgL8VveUzzw9MsaZGh1cmT3lwOOVyeszKB33GbIe6fL3mxDbqV6Zy99v + YunAuSnqm/byV10ynzGSpfK2h752Qf/YymxphnwcgWfo7qt0xmcMTRefQWxv0hs+k/RNOs7c9Zlz + HtgZN7cyq/YZ4lvF6H4yEmB091XbGZ+h+nxO9E2o7b0e5aPf5ETfVNB1PnPeTTHTO3CibzpA28kq + RNQ3fetXXSifoaYVnOibvme7Ida9PT9TmSF3ub6pEmdEr+2uo+FEjPTaZz4c30Md+Ht0R6w7vzIW + ppOzbi7XN1E5cMVnHj1KJ/qmgq51B+cb3/aZYSO2hzowbTtM9zl9sO7UbKcTfRP6q/J0S6zMXvuH + XbohVqY5+/PHPu+UdqJvKujaZ86NfaZH6UTfhNrO7tpW+8xg3dndI9SBUTobxaz2mcHKGJrO+EzT + 9kY+YyCfudL8Vmu3Y7shfMbSEfiqAzsD0tk6gdE+g9Jh23GfsXQUM4TPdOj13kHUN530NfeZ/C6R + 96Ez6CgtG2eivgm1nZpgdKJvwiKBZevAQd90eyRKh23H9ybLRuCobyp+1Sa9GYHrvYOob3rkM/kM + +Tufcfuc7UfymXGdgF/3I/nMd+jiM+Pq/gzd5rYP6Py6m0+sTMNn9nRuyuha45/OTfzK7MS5aYb+ + TZ/ZUw78DZ/ZKZ9h4/tO+UyT/jfFIEXfUpxRCiSt8Xc++gw1Xe9E34SuDLlrR30TSudtd1+l2+e3 + +kG61GeQ7q1p0WvvNznRN6WbSur3Qji3TJ0Oor6p+Fa1vimjN21v0j0RCSituRN9E0bXtmN0O0kf + 3iXiRN+E3XPl2jeV1HSUTvRNjziT58DvxfPLgN6wfan5DG97k47HGcfdXuZE34TSqdvLnOibJBIw + E10YXd1zRaiSy3uuaj7j6/lMfs/VOxm0fkBv2O6J3oGudmJ0pg5saDruMzN0C2ccMytjCH/v3QtR + y4FdLc48fWafs90R+Qw9aWEcFWfyCgpmOxNn2K/J/eA5MB9nHOUzzRhZr+kZW/cZk/nM+1+8SlAT + 8d0qn2FmyDH6N/cmS/kMb7v4DDc5itINQW9Wrv5U7hJxUd90VSGaN4W/3j5zzGUcVx24/Jf0LeeB + XrV6TD/rwJZdGdh2l9MHE7vULYku6psuOqs7wOgmpw+0Wc2+dq0ObKO+qbRd30P+3pvcMbEyNuqb + nIk/aN92y+18NuqbLn8fr4zl9iYb9U0wndo9bLp8DaRTO58VSR/2NemVGd6NZk+nXJ90/bbg9v63 + 1ufKDE+UF32BvyZdF8PoHv6aZmyPcQa4FVT/qhjd5nTCZzC6yT1ysO7te64q8zM26psae1P0mZdU + UMhOnBV9k+yrowoKT/dP26EohtEd7JFkbclGfRO/e8B0PM7kT8rmf/6z3juwUd9U7tpx878zDm/n + VsbI3kTnBBj99Bn3pV815DMOigQztlsiErD+biTOQLY3V+Zv5d1bG/VNN91XfCbLZ6gZFCv6ppdB + 3m8i52es6JteYvsK0suvqUl3Bj978LbPnpswuoEjcO8ORluLM/ZIe5PKgcNs5/kXzsdu4ywEOWN4 + 0ReDZnrk9OVF9/C3Ss5hX3Q8ByZnOy+68hnitg+MLmdt9paV0mce9Rkr+qaCruPMJr0Dft33lM+w + N/NgdOUzgxvAqA6ojfomMH/39Ne0E2ftGbqJu/bYI5eOz1TqMzbqm+58pvFO3MvO2b6lcxPyeggb + Z7bkMwid3VeZvjZ5M74VfRNW7dTvr2J0vA7ceQmiftaO+qaiZ6PjzOkzLtDJOoGt9rWbtvN0/Nw0 + Q8dnrmbodoau/uzR8XymQ69pVWzUNyXb01k71zdtoo5duBq2FX1T2puIt5IxevSZa0+23T4f+Z6N + jfqmq4JiAXq+a68Q3cJnPu2RGN3kdOLFGUWvvd9kM31T/kKq3ptW0cTp+I7Y7pOOEtlX2XW/329C + vibedpmfQegrTcdzYL3zYfS4N13u4ga2b7V/GOPMYxbC/tzvN+kcOO9rJ+2tzjgQ2534TPvNr4xu + aLp/0hsro3MxjO4m6QtEtzm9Gwl0/o7RTf6rDmxv0t9x5qFvsqJvKnxGz+mdZzc3tzI2xRnkhSVL + 0z2xMrzt8V4IyGc2mq7eMCVuksXo6m60WZ+p9yijvulxG2txB+O1d034uyF8Rr89hdHxtwU13UN0 + /D49ffswRrfEr+ppuiFiZJNe7x1EfdPDZ+77Z84EzB6vKdujvgldd0fTPbHulqYzPsOvjPgMe6s/ + RjcEPbddxxlby4Fb7zfdZ+1wP/A6oDdsP4h7O/XKYHT8rlc6Rpr7nivkjQwyRpqD8hlyX436Jpqu + /vxnq69t9hRnsrnU/M6icD/w65mlIrYz7zfRObC5329Cbm4gc2Czp/v0xvQZ2+UOxrHScWHrBOZ+ + v+mib5P0v6nTpej3+03b/avGI1byGRc0/nS1M3u/aTzlTVc7s/ebkF+VnEHJ3m9CflWyM2Hue67G + v6p+ERijG4Le1t7W96b7nquM/ogzx/GsXCG2r2lvGq+7pg/vLLKib8LuuVq5+7Bt/n4TQic7E1Hf + hN2sOUNX93YO4nuzI/TX1XqU2ftNam/K48wud9fz674knxnbvqqcAKN7mL5xtyRa0Tdhd9Jt3B1d + VvRN2N1omzprY3T8DsatXdOr3dtpRd9U3DQoPrP+hBw4zpBn9iJ3X1rRNwm9n4vt9K9665vG56ad + u5fZir4prXvXI3fufmCbv980jmL5yqB0A0fgDr2mO7Cib3rc9RpmyO84c8zZfr/fNN5XZ+j+q3QH + 52IzdAvHyJ275dzm7zeNz017t3dQ8xmb+trqxcjSZ/ZAp+42tqW+abQy1I3VNtc3IT7DRgKr758Z + fKuOpsv8zDfijE09Si6+P+NMLZ8J88DeqA6o9pl3ir/HOGNa9IbtYR7Yx5JYf/qS3/kMMdvJr7sh + zk157lh8q006ftbe6K/pfr9p7JFbO4rVegcmf79J3XNlM595SZzZuG/V5O83IStDZRxG3m9C152K + BEbebzrPHlf1ZeDvlEcaeb+JpiMeafL3m64g0J3DzsJz+ZpCbebKRH3T9atmdIkza/SZqFXRKzN8 + q8FEfVNJh9Ydo0u/CaE7mi6zEAidesXCyJV6r6/RDUFfWvRGnLn1TZm/S5wJPrP/RL02Hwlsmu1E + viY2itmkVfkO3RF0Kks10gR1BouRPF3yGWRv6r3F88iBTa5vUj5jMp9Z77M26zMhn0nr3s1S+d3j + 1muPc+AZust/1QGdXxkb80jEZ9idL+ibvMHqYr1+02N+xoi+KeXAwVviSF/0me0n3iVCr3vQN92T + o0SMxOgyD4z8qjzd5fTPRoKgbyrjO0AHKlcm1zche1OT/rcyp3fu12lvuug++kyYubpz4GWiHnnR + FyInoG6Nu+iSzyDrTum1L7rkM+tX6HLPFWI71Su76IagN2+Nq93BaETflFZmU3EmvZW8mQG9Yfut + b0IiAXUvhJH3m14G2fl2bh7Y5PomN1z3GbrkM+7+Vj9Il3xm/K3u/2jOYdfPTVHfVMRI7TPv/7xl + edKHsxBG9E2JPvhVqbklk+ubxruHpjuIrmp6cO9gQ042Qd9055FwtTNfwh5dNP4e8PejRa/NA5uo + bypPB484s8Q68KtFb9i+Sk0PiJEz9NNnFshnstI/TBef8QD9jgQrtGvf7zddKWS3V3ZkOTBKN5+g + 1+rARt5vWjVdzk33LIQt1x2z/e5rP+nXX8joub+jdOlRIvF9p+mio/RfoVuCvtJ0lQMP6EuL3ogz + Xp+1l/retO9lfMds96k+w+2rKN3n9NmVadLdV22XfAah87YbIr63faYy22mivskVNezH3nT1dCb8 + PdxzlXaPQT6z0XT/VbqDd76ZlTl9Bp2F4Omnz6CzEO07GCtvfpmob7prS0fFZ87d4zVn+93XRvw9 + z1INRFe9A+Jkg2SpSd8E2U5pJkymb8rje5NOKb9Mrm9CopjJ6OW5qZbPmHq/ySifcVepO+/egmc+ + Q/WbmrrhJt3D654Ti6+pSXdE9YfSmoemNkGn7hy90GaSXt4LUanpRX1TQc/jzKmjdMs6oNdtj/om + 1HZP0yUH/g7dEXRH05maHjWHbUTfVFTdeHrtvQMj+qZk+/aIM5f29mXnbL/rwN9YmUPX9IivCaPL + uYnrTEAVclPUgYlfFaMzdeAm/W91bzK79plnXzvEmbm+ttkn4wxKn4szKH12FgKjM7MQZI/S3O83 + Ibt2k17vHWTvN2X0fObqFEo4s0z1KKO+qe6R11/4Jd1/8VfdqHyGp0s+w3URofmZTN9E5ZHqzxBn + KvWZqG8qbNd7k5E7GOnubfZ+0xdmULL3m7g+H0pn8pmDpjM5MDX1akTfhNE7E7v1flPUNw18xh7b + nO1L2pu4Mx9Kx+NMo0TRpTs4vu/sjKFZiL1pZ2cMo76JrnGUK1PTqpiob2rN6aVzk33UgTHbfW1O + T+9NGZ1d97sOjKwMT5eZK64+g9JVHfjjtqs68KDaaVr0hs843TvQ56ZwL8RZ0/MDesN2V/eZ+79A + 0dmVcdQsRHPqtUnP+9ojvQebcdzzwAid9Uinz02Ezkb7TD0HvvVNWZ8v16pkWSr/q9qUzzzpMc78 + io73KPW+itFlb0LoB023X6VLjxKht+/trNzBaETfZE3nV7V3HTjX2SC2V99vEo9Mpoa/+rR6TPex + qzLu+NOz+/H9Jg+uO0+3X6Wb2CtD6M0IXNmbzpHXkM+sQpdphVvjf92SaLcBvWJ7oC+E7czKBLro + Dr5Dd4TtTJ0g0G2+7h+nnz6DRmDTolfOTSc95DPF2SO/SyS8r70O6A3bQz6DnZtW6lQW6BJnHEBn + 7mUOdBdtH6/7Sp3kA/30GWxvmqEbgt6sE/x53gtx0q98xhc7n82OX1fGEeIMd9tHoFf3pvz24UCv + /p5j+ttnPBrf0z+EbVc+M9j5eLqN/j4+N3XUJE06ronTv2rZbzIVukl1YBVnyl91GdAbtps0D8xp + QFG6J+jMawoiVMG7WUyvLD7zA9cJZmxX88BwfH/qDio+E/VNBV3nM+cHV4kzo+5toCufGXxNjCIj + 0FV9ZnADWLNC3qTj9ZmV0qoEOq6JW6lb4wJd6jPje1DWdsf/7/MukZN+pJkrdf9M7jMmvpZW3NE1 + muMI9IWwnblpMNC9wdWChqaLz3yHjt8lMrPuhqA3319txJk96Q6Uz9z3A18+Y47n7jGaigp0RnvL + vHcQ6D63fXADGPNmQKDLPDBy8xozLxbolrCdmXULdDzOaF1ZeXd9OQtx0jftM3I32l74zKusA48n + GAN9iSdK5M4iZj4y0H2kj9+Z6HRVmvR41gbeRZyx3Ub6mVzbQQ2buQ870I3sDkO69hlFr9T0Tvqq + 39fWd0rfe5N/fk2I7WvqHYzv6NJxBqOrN9m7PjNDl70JsT3POEaKu0C3BH2j6fi7tx16RXdw0pfk + M3vHZ8z2pAN1saBvAnOCGbr4DBKBV5ruDJoTzNiO5zMbpdIMdNmbuNucCvqf9ASOonutO9grPmPl + HnJ9bkJs90Q+o89NGJ05N5E1Pcv0tfV5FbNdzk3IWdvQdFzf1Fi2GGdq56aqvkneVZH6TNQ36ZVB + YuStb3rSr7/wS7o3aMd/hu5itoT4DHOfXqDbnE58Tci+GurA2I2mazvj+GNrdeCobypu9dc+c/Yo + Y5xhXpwJ9OVJb9rO5pE2aeKQu7wNTZceJfvaJUa3BD1f95G+KdDVu7cDelM9VdGqhMKSnJtUDny/ + 33TlM6F3wL0eEuhLTh+8lsOeKNM9V/m7iGM6GAmM7E0AnXsjIz7IDteWuLcFA13dczV4Z6Kpnvrz + fJP9LBfe91ype8hzn0m9gw69bnvQN4GRYGFPw0HfdEcxlI7VUoO+CbadUX4Fus3pA5/hbWd8ptmZ + qJ+1g76pNEHvTef/+mtAb9h+EOcm7gXsQPc5vbsynu2VGaYOrF//A3qUQd8E7h6e7Q0HfdMd34kX + 9Ep9k6nQ7zqwevPrruld2ttwbydv+57qM4jtzK1xgR59Bqi6eTX7YyC6y+mDV0YZrUqgW4JuaLrU + 9MYVQ9fRqriqz6Q6cHijWuaB7/v0Qg68FnRsbinom+57yLu/qqOmLwNd9qaxR87QJQce52IzdJUD + w68uonSTZ3qDPLJJr/cozV0HVnEm35v822e257eK2M7UgT3tkboOPNo9dpqO14Fn6OpN9oHP8PS5 + vel5p3Qtn1n0uan2VnLmM8wsc6AvsO15toTSPUFn/X3RcebjdOaszbx3EOjqrD2wvUmvz3ZGfdPI + Z672yITtdx34GytzzwMjdEalGeiO8EiejseZmZVh6jPN2c5GDuzqOfAr85n3xu72si6G2e5q5yab + JbgNOpYDu7Q3sRMuGB2fhdDv82F0S9B3mm5y+uCs3XxLs647CPqmss8n56bgM4soHbmXOgN9edJ5 + 25t0vEc5Q8d7lIs6a2N0vEep6Uh9xuqZq9naUiPOmKS93R6RIJ6btnpND7H9ngf+le1Nuifo5Hxk + 1Dd9j24n/R2jMz7TpNd85hB90yPOFD4T5vQWrjd8iL4J/ZqY+8UCnYkzVA37EH0TWt1nbgoPdNU7 + IGrYGH22DqzolTdMT/qdz6jeQZkDLwN6w/Y7n9ke9OsvKLqh6fhsJ/+rOqIOrH/VYSfuEH0TVsPW + XxNmu8pnBrY36bVz0yHvNxXZko4z56FzfUYxZGVszWcatussFaMrnxlEsebUa5PuCI/k6fg88ML1 + hg95vwmNM/mvisQZU58HzuvAXvTaOhdDbDfUWXul6bjuoLMyTXo+C/F5uiXo1IT6IfombIa8Q/9r + nn3tQ/RNMuVdnLVvfZMr6OrPpu1R37RLDbvbVaFXJuqbdqhns3CTFofomw6hD2auyF07Dlu8oI6Q + jsAYPWpvgdddez7zfPPrpB965qoWZ97Zxmuds/3WNyFTUWTGYYu+9qA+Q2mEDgk1WMZBarMuuiVs + NzTdfGJlavqmI9c3qfe1c59JN8RkdDDO7MQsBL8y+7TPDM+rh+ibvkdnfIaanzlE34RWO3v1mVqc + 2VSPMvmMngeOexOpAT1E34TaztPxHiWpjj1E34TSqQrKkb/fhNApzfOR6ZsgrYpp0evnpuz9pmdf + +/qrl+7giHcWsV/TWr8XIp8CDPTafxJAx3uU3D3kgc7om3i6fcb3Jt3SdHxv6vyqtXngo9Q3pTiT + 6yjP4tY+Z/tCxJmOZqJJx2t6fJxZdB34kyr8Q/RNWJV5hm4IejOK1e6fOUTfJC/TVueBz6qbm4uR + Xr17q+kxiv2K7p/08cqAHumTzyD7am47kov55DPfoZtP0BtxxtVnrrRe2x77nO1Oz3Z247vOCTA6 + vjfN2I7PQszQ7XPdxxEYpovPjOla+VX6TC0HtinONH3G3ucmdmUsMac3Q/czdDDO3H1txGea93E0 + 6dFngOnLle3E2buvPZ5L1acyfdauzEJcRYJq7yC/S+TMUl8DesN2Q/kMu2sbymd4uiPo7LnJEHGG + 1A1fdOas3VyZyrsq55+vus8UmjizFz6D2R71Td1TWUanZiEO0TdhqrUZunuuzAfp+MwV7e9R3/Tr + r+nv823B88+jXp/R90LEN0x52w99bvrsySbqm1A6mWFHfdOvzx5NOpMDN2+8a9Jn85nhfXrXn9Wz + tr7nKt0LQd0fef1ZPTfdjQFFZ9d9J85NdJ3A6HuuRlkqT2fuEuHpUp9B6M36zF9bOzfd+qawMjJD + ft+nd2niQh2YrlyZTeczg/tS2TizUT7D0/E4M0PH6zMzdLnr9VcrU3nz6/xzTXe9qh6lvoMxvcXD + 2r6md2/3B/2OM0Jn48ya3shAKoZsjLzfb0K+VXb3CO83pRcjP043+a86S6/PQsT3mwq69pl3jDmW + OduX5DPIO8+Gpvuv0h1BZ3cPpg680xl2UQce2N7MUuv9puz9JuUz+bsq58ptgc7GGa9nyAe2U7P7 + h+ibTjryJjul8T9E34TSKVXDIfqm9G7Wx21n3vxq0v/U44xLcSZbGfGZ0wHDC0vH3K/qUpz5xq96 + v980ju+HijMY3X2VbomviV+ZvHcwutGU0jcdom866VfF8Pl+0+UzEmdW0vb7/SZkZdhv9X6/CfFI + 1t+t9hk0zqg/e3RLRDHedvMJer13kOmb1B2Muc+cs4L7nM8YKp9hXsAOdA+fDmbo+Llpho7XZ3S2 + hNFVj3Jgu2nRa/WZXfRNhe0Pnzn8Mwce2r6LvgmrLc3QfU7vnuTJdd9F34SuO0+3BJ16gWMXfdOv + ba+dtXfRN3V9ZpebNXnbna7pDb4m6lvdRd+EeeSM7bI3jft8vM/c71GOO6Az9Lw+M6I37xf7W7m3 + c4/6pmd9pvCZbZ/7VW3am8bTaOTOt4u+6VseaYmZKzIX20XfhNWBZ+h4j7KTv9fqwLvom066ymfu + K1ROKUM8Nx30t9p4jzLMcq4ZvfafBNDxGfKDu61vF30TdofLoTxyeHPDHvVNYD3y4G6NSw9eYpme + /lX1fXrVvSnom65X01WcMdmvelz/XNOxXzXom8Bqp/5VgZUJ+ibw3ET/qkHfBObv9K8ar3vFTpQH + d5fILpcIoCvTjGK1WYgrya7WZ4pIEM7aB3fmu+h4fYZfmUPfCzFYd2rm6qLje9PB3T+TBnSw3SP7 + hzBdzVx1Y+SrHWdqdeBd9E1WaxHFZ1I+s6+Bzn6rO5HPzNAlziDr3lyZJl31m7rxfYZuCTobxfYU + Z8b+3qH/rcwD71Hf9MyBr/+NGGcWOWu/6Eiw6frMYGV4uifo1D21e9Q3gXXgF5ulBn0TuPO96Pi+ + 6R7lYGWap4NGnGn0tXOfef/nbZU4g9he9LWJSIDR8Zrei82Bg74JpvO22zxGzv6qTbohInDzvNrw + mdDXPow6HYjPLJfPeMlneH9fUg6MrAxVf9+jvunK33+1Mk26+8S6N+m5z/RrSzpGYnSVAw+iWK9H + +bjrdY/6pnLn0/nM+z9vc3MR2FN7E7synqjPzNiex5nRr8r6jE9707geyX+rd1/7V/RaX3uP+qbb + Z14qzqSztvgMa7sj+k38uruUAyN0dvco+trdM98M3RJ0dl91RI+yY3utr73n+iZV0ws+k/ra2xHo + ZA076ptQ23m6xJnxlMgM3X2Vjve1D7YTZ5m+dode095eB771Sdc+k+IMb7uhfMbQdNEdfIfucnrX + Z2ZWxsIeOUM3BL2ZE9Tu7dxF31TQdT5zxpltUDGs2x71TXX69RcUndz5or4JXRmeLj7D0oGTfKZv + +g7dEP7erHHUz01R3/T4Va9/tcxneNsPIs7Q9XdzUD5DVgwzfRNCJ2t65q4DIyvD0w1Bb65MTXu7 + n38OfeY87+9zv+pejzP3f8Ev6bNxBqMzPsPTmXyGpzP5TLPaWa8DR31TI58JPrNKDtyhN2zfdJwZ + 9GzYldmIGXK6m5XpmxDb+ZXB54FnbMd1B51vtXY32i7vNxV0k72RcV14GZSO/K+6UnsTuzIr1aPk + 6UyPkvWZlfIZno7rmzod0No88C7vNz185sh85v3n4Z4nSsT2hYgzL3YWIr7fxFchcjN6dFyr8lJv + rWF0fG/K1x2lM/WZJv1PdR446JtKJczTZ9a5db/rwE/69Rd+SfdTdTGUztT02F/1rgNTZ231Z4+O + 65vyk3zpM/Uc2GE+sw3oDdsd5jPTdP+JlWnSHUE/aLryGTgHRunMzFXvnbhKTS/om0q6+MzxE/va + Zi9PZZjtVs/pbRWfyejUW2s7p2866ChmU49yQNf/DzDdxv4qYjsbxa468O/pjfqMSbOdTZ85z0zr + TzFtjNke9E2o7Tcdy2dM6mt/hy4+g8SZ6j/s0sVnEDqb6ZkUZzxAp+b0tqhvumLkRV8ee9N1Lfu+ + T9i+RX3THYG7N1HN0Jm9icrft6hvgumUR25R3/RFOpPPNFem4TNO1/S0zxw/8X/vcHO2u7Q3feNX + vfvaHvBInu5g+s7NA2+5vuk7dDk3ISvT/FVrdeBN3m8q6DrOnD6zTETgLdc3cb8qsPNtub4JoVPn + pk30TWhHiKfLPeRcZwKlG4LetL2mO9hE31TQdT7zdr3DTOQz20/2ftPHM44t1zchZw+eLvomJCfg + 6apHORsJmnSmr92k1/TaW9Q3ldUfvTe9P//1kQNDtkd9E6pV4enMuYmaW9pE3zSjnsLo6p6rT/bk + t1zf9KteWa13cGoY01lbxZn8fe3z/7kyC4H8qketPtO0naczOTBPd0T+ztOZcxOZz9iD8pnezJWp + 0PfkMyqfCT6T9qal0qNE/H1PdzD+avanSVd9baJ7i9GZO4uoqagt1zeFhPHTdNxnOtNotX7TJvqm + RpxJ5yaZ7WzSG7YHfdMG2k7NR26ib/oe/fSZ9bfr3qTbr9LNJ+iNOLOmml5jwiXsTa8nfXif3tZ8 + v+nCZDtf8NDyPwmg4z6jv1XMdtxnZuiW8Hd+3c3kygzfyNhE3/TwmTDbeccZU8R38FddUh2YzTiG + rylsub6JpQ9fu9xE34TSqfdXt1zfRNHhdTe57YNcrGl7w2d88pksnxGfCT3Kl+xNOidAVsYnn0Eq + KDzdf5Xu4rf6HbrkwNdlSN03e2foks9cQb1731KHXutrb/J+01L6jEk+c521wz1XOkYitod7rlKM + HKz7i6bL+9psDozR3QwdjATh3s5z3dlJacx2E22n6KXtNU3cJvqm4vXu3GeuOT2ZIWdtt/qt5MHN + POzuYZPPjFWaM3T8XogZusQZZE7P03TJZ9jKFbI3FX3tvRJnzv9RP2e7Secm5LxKva990T2RpVb/ + YZfu8jySqEditsu56Ve/apNuPkGv6Zu2qG8q6eIzMgvxIwok6rX6Leqbbvrg1jhybwr6pouO3MZK + RoKgb7rpxI13GF3OTSwdOB0EfdOU7eU7cY+Zqy3qm8pvVfvMWdNb52wPdWBs156h+5xO3OqP/KpH + 8hmEzttu4d1jhi6zEAj9aNEbPrP39NrprL3YZyRAbN/TuQnZtQ1N9/C3OkN3xL5qabp95gQftN0Q + 6960vd5vCvqmcm/SvYO3ky/bnO1b2ptY25FIsBF7k961MdvdV+n2q3TzCXp9fia+31T8qrp3cPa1 + l2cOjNi+Uj7D0z1BZ9c91IHR0zBvu4X31Rm6mbR9+BbPJu83FbbrventM8vredYGatjx/aYF/FV5 + uidWhnoDaZP3m9BfladbwnZ+ZQxhe+/9plqc8XpvqvmMv+szZA076pvQMx85JRL1Tei6U68Zb6Jv + Qted7JpHfRO6MtR9HJvom9CVyW3XPlO5h3wTfVNB13vTO6j719zKOMpnmrY36X5y3TE64zPUa2ib + 6JvQfZW6AWwTfdNMFBvejbaJvqnuM9dfvZ4wXtapabSgbyr/Je2RgV77TwLo+FmbniGP+ib0VzU0 + nfEZns7UZ5rTOY2anqnlwHpvetXPTYjPGKKmN0PH44yuQiDrbnR9hqBjtuN7k67PYLbjdWBduSpn + Ox/1mVX0TZ2zdvCZpaQDM+Sr6JtQ2ymF6Sr6Jqx3kK87SsfnZ2bokgMj9HxlLETHZ6607S6n/63c + 9bpGfdNFr/S1T5+5nuxezIDesP3OZ35le5OufGagEcrpC0RX/SbC9mFtaRV9Ezado+nDs/Yq7zeh + sz+mRa+9lbzK+02Jrt7IuP7q5TNyE1VOH2Z6a9Q3lf9SPtEl9Np/EkAX3QG7MsPdY436pi/S1Tww + oajG6IzGv2l7w2eMngfWPcr9+lXfH+Vq51bGTOooUTrjM7muDPF3Q2lveTpzL8RK0+e0Kk+fqeQz + 8f2mgq73pvdy+L08r0K2Z+83sTdmYHQ/SQfie6ZvYtcds52Z7eTXnfGZo0Vv+MxRv3/m1jdl+Yym + I+t+UD7DrswxOQ+M0t1z14bWfXiyueiMvqn5qzbpsz5Tzs88anprrm96+sz1V68GxyvOXOX3/gB5 + ZNA3lf9SpFub0Wv/SQAd35vyuVTUdnyGXNOBHDjqm9K08cfpp8+cuuHxtLG+o0utTK3ftIq+yZvm + PPDVYvZRq5KrwX1Ob9ge+trOIHPYmg6cm6K+CaXnGQdmu3uuzAfpNrd98Kvmd0UBZ+1YAELpvftn + anEm9LXtwGcWP6A3bA997UQf2O5q/7BL9zN02Hb3XJkP0i1hO1XDXkXfhNreu+fq0aNcRd900rMo + ltf0trt3QN40uIq+qaDztjfpnqAbmn4dbr5mu/3qyhjC9ntlnnGmctaO+qZ0h4u8R3lhrLt85tyX + jmc+g9ge6sAFvWH7DN3DdP5b9clnEHpz3Zt0O7UyKP0kv77kMy75jHv4zPVXrzbtWulrI7a7nvb2 + yOi1/ySA7uGviby5YZX3mxJ9oCujbtte5f0m+zU6Hmc695A38hmrfcZV48zPay3o4K9q9d7kKh6Z + 0alXLNaob7pPB4N15+mSAyPrTr08voq+CaWz2ZIlzk0deuPcFOrABV37THZ3PWu7Seemb6yM0T4D + 07GdL9SBUY/kbWfiDG+7mfLI591ojxnyVfRNDZ/JKyiajn1NUd900hHdMLkyUd/0PbrEGYROZqlR + 37QIvftq+gz93DnOf2QAOuszR5q5ymzXceadCLy2Z1cFsf2gfIany7npO3TJZxA6ddv2Kvom1CN5 + 282k7ar6U68Dmz3V9DK6jjNnxrEP6A3b95rPPPOZfW5lQh14Zt0x20+70W91pemWoJPzM2an4kxO + L+dnanHmqgOX9Pwuka2q8Vd/tm3f0rnpSY8+U71BAKqlRn0TGt+p+fdV9E1ojMy7WZjtKs4QvypG + n/UZRa/d9bqKvmkztUiQnYbN3MqsqUeJrHtuO9ARivomlM7bLv0mJI9kf9U19Si5OgHUVTH3PVdI + ht2b06v0taO+qVh3HWfOMLo/O6CI7fc9V4jtPN0T687THWy7rjJjdNxnZujKZwi62vnqvYNM39TM + OHapoNA17KBvKv+lZ4Y9oztYRd+ExZkXnaXe88DfoeP5zIutLUV9UzodDOjNPLKmb1pF31TQZVoh + /KrvX/S1POlILuZS7wCxnV13p89NsyvTpOM58AzdftV2qekh/p6ftXWcqdxDvoq+qTivPn3GD6JY + w/ZQB0ZrSwdNZ87aO01XNT0in0F2D0vV9Ei9h+HqwL2zds1nqnXg0mesWebO2ibFGa66j627Sf0m + 9qyNZKmGqs+Qk0VR34SuTE5HTgdG9ygHdNOi17Qqi+ibim6Wnu1c67qD4cosom+q06+/8Eu6N2j3 + 9mhPozXp55d0TPyqQ39fRN+EdhGptxqWqG+CfaZJb/jMlc/8nPl7paYX4sx5p99MHXiJ+qYJ21G6 + J+j5vBiy7k7HGSK+Y7bb6JFIFKP02kvUN8H03hsZNZ+58pmfoj6jZ67eBm/LRF1sEX1Tsp2oQiDr + fuUzpb836dQcxxL1TT9ojYOacFmivgn+Van3Dpaob5qyvYwzj5reEvVN97rX9qZ0zxV57/4S9U0/ + WHWfvKF9ifqm298HZw/qFq34uHaIYojtN30FbbdwtqQnRw1EV3EGXpkV8ZmgbypX5jHbedgnHVj3 + oG8qoxiwMtC6B33TD1pByfcmIOMI+qaLjtT0bvqKxJmgb/pJfQ+4+gPcc7VEfdNt+6Cmt7botfmZ + N/3qa5e2i8+8ks+YJx35Va++9vV/ENupNwMuus/pg3VvTqM16e6rdGvwleHXnfGZfN0Rn9mTzzRn + yM9cxj3pyMrs2mcG6960vUm/lCQG+1bz2U7gVBb0TT9Y9UfTkV819LXRml7zNtYm/SxEoL2DJr3h + M6GvXdcd3Ocmsz3pwHk16JtKOrTuSJy5+trwyuR0zPYzYZr5VhGfCdeoo7t2Hmcw20+fQb+mrUX/ + U+lRLlHf5Bt7k8SZn2N9rvuwprdEfdNtO/yrrtDXdPW1PZpHbhkdyN+DvsnPxBlsZSxhOxsjQ0kS + 7cQ16X/qOfDV1y7ppfbW2vW57sjetPS0ty6j1/6TALonVib/VpEcOBydsJreDP0cOEbVJBtNN5P0 + sq9dqc8EfZMr6mKP3oH1c7ZfdWCPVcj1uiPf6lUH9ujOt9D0M86gfb78VGYguiWiWH7WxtbdEOue + n4bLfKbmM1cd2Be9Ml2fef/nOVdWULA4c9WBPTa7rysoyMpcdWCPdUA1HfEZl3yGm5/Bdj6XfIa1 + HfHIqw5c/qqA7VicuerA5croOHNOuLhnxRCx3VI+Y2i6JyIBT8fjjF4ZxN+vOnCZRzbpbP5+1YFh + 23O6sr2mo7w21fWZYT9qeuIzbC521YE9dtbWXRWM7ol1X2i6I+js7mGSz7BdRIyOn5sOVUstc2Dz + pAd9U8NnUpyJ9ZlD7XzA3hT0Tfe6D2aZ0z/Edo+gb/LYHHZ+Cy5UZQ76JvBb1XRsZSwRCUxGB3a+ + oG8Cs6XOr1p7I2OJ+qbrX8qm0WJIinXgs0e5l3TI34O+qaTztjfpPqcb3COB+B70TVN0oLYU9E3w + yuR0oAoR9E0gvfPC0t8kEVH0veMz11+9luBYB/SG7XvNZyA6su679pnZlWnSv+kzu/aZj9PNJL30 + mUpNr9Q3GRVn0iyEqPCpl62Whr6paTv1Ws4S9U0wnXrPZon6pi/SGZ9pdhGbdMZnem8LVnLgoG96 + RoK8R/lG7suA3rB9pXyGeiNjEX0Tmi3xdLnnCukImYyOrYyahRjYzsbIldibOrbXtLdL1Dc9feZa + YOujz1hr5lZmGe9NGZ163XWJ+iZ4ZZovWzXp+N6kK4YYHY8zM3Q8znS65jXdwRL1TY1fNZuf2aY6 + cZm+CbGder9pifqmL9IZn+HpjM/wdCbO9Hymls+48d70kvtn6DkO44i9aYbOxBn2W+X0Tbzts5o4 + xGdcmp/h1FPlnUX2qfFfor6p5TMpBz6OZw0bOQ1bKs5QKs0l6pvgdTc0ncmBD5o+lwOjdEbj36TX + 7kZbor6ppD80/ocvTweY7Wby3ITS1WwnXONA6e6rdHy2k7yzaBF9069tr9X0fNQ33TPkOs6EHuXZ + Ozie9GGl1kd9EzgPvKtvdVgx9KJvQun5raCY7cpn4EotEIF91Dd9xyO96Juwb1VXrnQduJIDe9E3 + FfTH3vRa5laGyWdm6DIPzHYmhjmBj/qmH6wzQb4N7kXfhPYOqLqYF33TTL9J6w4qdWAv+qbGnJ68 + xWPdPqA3bLdpHvhXtjfpnlj3XBkwzFK96JtQn8npiM+EfAb9VZeMjvhMyGfQlckn6co3Mh6zED7q + m8pemT43rVftqajpYSvD5TNHRkdWxugeJayJQ+n4/MyhepTYylh49ufg+qs+6pvgnnyT/o4z7km3 + vb529JlzX1qedCASBH0TPI1G9Sh91Dc5VLWWVwyBfCbqmzB/19oszHZL2E6pp7zom1Dbc/pQ4/+m + V/va+ty03JXapUVv2M70tbXtQA5sj8n6DPSt2mOyPoPaztRn8t1jOPtz0edqegW9dgejF31ToiuN + /z0L8TJPOuIz1b520/Z850NWhulrv9TehNEZn+HpjM/k8R3xyB2fuXJGxfdytvNRB/ZR3+Qfd6Pl + 9+mdc+zuSUdsv/raDfr1FxTdtWxv0v2T3lwZnu5QBVJBNxAdPjdN0c2k7YjPrMlnslwspj4/ctdr + mCGfWPdVz+l9eGXWpIlD6CajY7bj5yYdCTC6Rf19im4+Qa/pm3zUN5UxUuczV3/yGYER26t97abt + O02HfaagIzEy9LXRCXXedtHecqpklK60t7P0P9X6TNA33XHGVXzm/S86O7cyPu1NnDoWpfu47siv + yvq7p/TaPJ3R3rL+7vG9qbfutb62j/qm0t/1q+nvY+GVshUeidju0v0znCYOW3eXanqIR3qa7r5K + Z+IMmxM4SuOf07VWpe4zQd9U0PW5abt1lHkOjJwOgr6piJH5DpXRD/p0YIk4c9CnMqv3pkE9kj0N + 2+QziO3sSd4SceZon7UbObDpnZtSnBGtChtnzPjc1KAj627wc9MUHT439da9SVe9A7jjj9JV74Cg + lzU986QHfVNJf+QzZi/7fJDtQd800UVE6Xi/SSuQMDrjM7ntQOUq6pswf9e2Y3TzzFKb9L1Fr/co + g76pXBnxGZmFsNf226M3bD/S3oSsDE/Hz00zdNxndpUDY/Rv+sxBnLU7/t7wmR3yGW/nvqY93VnE + 9rWBPp/Zqb42T8fP2jN0qekhHVCyJ2/2tDch9GZXpd5vivqmour26DfJLMTWojds3/S5Cb7/HaXj + 5yadA2N0qel9x3blMx+3/VLBgPSjRW/EmbV2N5rOgd//ee5x1yvU1476Jv7GDJTOnLWp21h91DeB + 3+oMHZ+50uuORLGgb0JvBW3aXtP4e9E3FTOGjzjjK2dtYAYl6pvQm6jYdV+ou+vznACzXd1d/2GP + DHVglE7dgutF34TSmztfvXcQ9U0vAev6jLx3kOoz7L7qk89c4KVvOzlpYe73DhA62ZM393sHrO1I + JAjzwBtIP2i6IejNr+lPdeYq6psKut6bznfhl2cdGPEZl2bIL/Baqc9kdHbXdkl3kNEhn8HojqDn + PoPsq6EOjNLJmauob9pAenPWrfZOnBd9017+qtf/xj3baV/PfRWx3Wqf6fo7PQVo7vcOxiujMz3M + dnnvALE9V4MbiI7HmYyu/uzRlc8M6M0bTRt7k+n5TIgzZy36eFY7kV/VUD6T05GMwyStCrLuN32B + 4oyhfCanYytjn+s+poM+E+rAiT6wvRnfa70DJ/qmYmW0VuX0GVvSga/J5fom7lsFIoETfdMK+gw1 + g+JyfRMVCWDbbU4nTvLYuhuC3uwN13oHTvRNjXwm9SiNfVZ/ENvvfAY52VAzVy7XNyH0OycAIoET + fRM2x5HbvoxjpBN9E2q7oekGpudV5mVc03O5vqnZ1z4/CfOskCO/6q1v4lYGiwSWeCND04f9VSf6 + JrSWSp21Xa5vQlamObHbpM9p4paxJs7J+02NOnDwGSf3Ax/cHIfj3m/SFXLEIw3xRsbBqRqcvN+E + euRC0y1B51dGvatC2K7oNX2Ti/qmcvd4zM+Y9UkHfCa+31S8a/6Yn6nRgXWP7zehL76TOUHUN6Hv + Ud50aOeL7zeh7yLuGR2IYlHfhKmn8lxseei1K3HGHqmmV5nTS5q467NQeSS2Mod+jxJ9T1792aPj + deC8TrAgWao90nuUSF0sp2MrIz4zzlLzCgqUz9gj+Qxiu2/Ra/omJ/qmgq595uxPHk86sjJ78hmu + lrpAcWan6sB5JBjOzzjRN6F14JyOROA9nbW/QzeT9HJO73H/jJP3m9LK+IrPHHLWfqkYOay/O3m/ + CV33PEYiX1Poa8/QEY/cKJ/JIzDikRvlMzl92DtwUd80RS/vRqvtTav2GRVnzv+qn/3OgTv0hu1r + zWfy3kGTjvjMivuM0jdh/r7iPjNFlx7lsKbnGpdgdemqpjfoHTQjQa3f5ETfVO8IZXHmeEYx5FsN + fe3UVfnw7rGkOvB36I5Y97wOjK2M8hki48DoTI8yp+u9qXJnkYv6prLaGf/VGGfsrW/KT/LI13TX + gRHbczqyMp7oHczQ3Vfp0m9CPNLQdDzOHO1du/YWjxN90y7grbJ7eHknTndVEJ+577nK/tA7n598 + J86JvmnTtjdXJv+akJzgrgOvwLrn+Tu2MnhfW687Zrv5BL2xN9kUZ9TeFPTar/SrHs8qBLIydx2Y + 7fMhX9NdB2bpyNnDUv2mnI7sfFxfm/VIS+TAR3dvqp2177622puun+yOBO71rDIjtptU00Nsz+nI + 12RSTQ/pxBmarnzm43TpHSArk9OxdZcZ8rHte/tUVs9nMn1Toz5z5TNBe7uzJ5uob8LmgXf2JJ/p + mxAVTx4jDUTHdQc7G2eCvgnse+xs5Srom0Bd2d7etes1vfh+U3ce+NyXlkAnM734flNxk2zT9rza + Cewe8f2mRB+su6HpDqZv6mvCVkb2pvHKbCpLRb6mg7iDUdte6psqNT2zJ93BUx2bnZvMgN6wPdSB + 0W819xmg+mN24k5p7TMY/bQb69nolTEQ3cL03HaP9D3MHoa6aNv9o99UizNb6h0on7k/lVB1W550 + oHeQvd+U/SHZks3otf8kgM7EmTwCI7/qls7a7O6B0eVuNHZfRWLkluoznMK0jDPVs3bUNz3un8l/ + 1VVyYN72Vc/PwPpVLCdYdZz5OF1mITh1LLY3rWkWgp1wwWzHfUbTh/om99A3PfvaZ2C0V3ukoCMx + 8q4DIxp/sgMa9U1YnNEzKIi/L3pOj5hBwejM/Aw5Hxn1Tajt+bqXuoNanPF6fua5N4U7i15zv6of + 7U1Cr/0nAXQ1PzM4Dee7B3Lm8ykHRugrTVeaOGI6B6ObSbrWHdin7sCJvqmgx3Q5q+m558ogccYR + Oko9y2wguoczPf5bdeltQXbaGFsZm9Nnd48m3RC2N3eP2j1XLn+/Sc3pFTmwzEKk/2lw3a86sMUU + 1frGDIx++kyqi8HVH2z3uOrAFqu67ewUYNA3XW9pInT2W73qwDd9sDJ5BB6+Leiivsk+epR5Dpzy + mQ69YftVBy7pTds9TfcEPT/JI/vqVQeG6ekfgj5z1YEt1jvQJ3nEZ646ME9Xf/7zymceZ20b9U22 + cT/wPQtRqc8M191GfVNJb9renEtt0j1Bz0+Uw5zARn2TxXoHmo6tjJ1aGSBG2qhvmloZrTuonJts + 1Dc940zIZ+Q+vfi+NunvNuqbbn8nfAZZdzfpM9i6u+QzSF0szyOH/SYr+qbzH41vTt44laYVfRNK + b54Oam9+2ahvsqmmZys+8/7ztQV6vnsM68A26psslgNrOhIJQj6D0ql5Ahv1TQ6tpfL0swmK3QA2 + QzeTdFVbqvUObNQ3ueL+SO0zXt5k37h5Ahv1Ta7oHdisLKXo1InSRn1TSYciwbAuFh3m/e9OrDvy + NV35jJuJYsNMz0Z9E2x7c9f+Wzk32ahvKm1/+Mxin7YPq5026pumVgbwmfh+E0qnJtRt1DfBdKoO + bOX9JrQnT2lVbNQ3OfS82uya1/cme/W1S/ozzpiJc9NFX2IUQ2yn6mIX3RN0al7sojuCTs1xXHRL + /KqUJu6iy96E0POvqZyFqMWZq6997drumQPLWzzhsyjoiO1XX9sVujK9NyU6qWS3Ud9U0hsrQ05F + 2ahvmqIDu3bQN8H0PM4gUWxPPsPOupXvqlTymaBvKj1Sx5n3/8t+POkmpzdsv/raoL8fXOfZRn0T + TM9jJPKrXn1teN3zGInZbuEoRs6l2qhvcuidFs2V+VPNgYO+yT3uhQjTCaE+Y6/qf0EH5jhs1DfB + K+Npun/aDqwMSndfpTM+w9PNJ9b97TOPHqWN+qaSLj4T9qbzny1zv+pC+Yyj6YzPGJru4IzjqP/D + Ll3O2g6IYjydyYHbdWD31FHaqG9qxJnrr14+c+xFPgPa7tO5icr0YPrpM9iNSFn+DtNPn8Em1LOp + V5guZ+3v0E1OR7sqD5+x8osr+lUHdkWlNh7Lfw5N73QmGra75DNUHRime3hlZuiOsJ31d0f4TFb9 + genm+as26c2vqaZvslHfVH6ruc+c+YxfX0WlFrT9qgODkWCjvyarfWZAb35NTbqDY+QM3cb4Pvb3 + lf5WbarpIfTm1/Q+N9XizF0HVqfhJfnMabBfjwG9YXuoAy9V+vUXFJ39Vk3KZ5CV2Wi6g6PYSu98 + RseZAZ39mgzlM81IUO9RBn3T81fdks8ERes6oNdtNy+9Nyn69Rd+SWd8hlz3oG8qv6YmnYwzQd/0 + RdsZn2nSa/omG/VNN132pj3zmRO5zdl+1OLMx9b9oHyGp7uv0u1z3Zv06j/s0vEcuEOv3Y1mzz+r + cebIfOb8a37O9p04a/MeuRO9gxk6Xp+ZoVuCzkbgXefAs/vq38rd9Tbqm567R+4z1//L1K4d9E2w + 7ey6b8S5iV/3UAf+9bo36TbSxzc3rOy5KeibYHoz06tpVWzUN7l0U8lW9ZmUpbK2hzpwQedtb9I9 + sTJkhh30TQ67j4M+2QR9E0inT2VB3wRXIdr1mYpWxUZ90zPO3PlMOCztc7YvKc4gK8NGgiXFGYTO + RrGF8JmNrZAHfRPvMzAdjzPZh1zpHVT6TUHfVNLFZ3bxmfB+U4fesN3rOIN+qzDdf5XuiCjG05m9 + KZ+FMBCd2Zua9IbPuLHPvFPNdSl2D9B2R8SZGTqzN5Gd56Bv+iKd8RlKDW6jvgn+mtqzEHWfCXXg + Q8DPfCZU3XxxosR68kHf5NJNg4N8xtB0Js6w+6pN/aYxfVFzepjtlqAfNF35THfdFxVnEJ8xKc4o + nwk1vRBn3p/Q1Ya1i4oEiO1Gx5mB7eSUSNA3lbZ/kC4+g9DJ6Zygb5qiAzNXQd/0e3qtd2CivumK + BGG4KvrM/X7TtTct0WeoO0dN1DeV9KbtPN3nMRKlI3HGRH1TGYGbdOo2JxP1TTDd0HQDr4xvzzLX + egcm6ptujxSfCXuTxBm/bgN6w3aXcuDtQb/+gqJTN4WbqG8q6c2V2Wm6+ypdfOYCN0ZkhE5pJkzU + N8H09gx5paZnor6ppMcp+Ogzm+TAnrs1zkR9E2w7T/dfpbsv/qpW+0zjgZB5uvkEvaY7MKJv2jU9 + jmfdPrO8nl8TYrtJceYbv6pJceYb637nM6fZtnGB/DzdEnSqlmpE34TSm79q7f0mI/qmgu6yGfJw + fDfP3QNYmahvenjk/VcVnXpnwoi+CV0Zns74DE9nfIan5z7T/5p0tqR9pro32QPxmRhnFnXWRmw/ + ks+MV0bnwBgdjzMLG8XsQfjMDB33mYWNYvZIPrP/hl7rNxnRNz0iQT5zddw+Q+5NUd+0R7DtqgUX + +mvaVZwZ+QwbI/fkM5ftXZ38DF3yGcRn+JUxOX1ge5Neu3/GiL6pEWdSHXgxT/pQLWhE31Sse7k3 + JTp1C64RfVNaGcIjMbrkwIi/UzpKI/qmRO/OQsysTPSZ6wcd0ZsK01pNz4i+qYgELpvTu+rAy/6M + wIjta81nmrZTt/ob0TftsjKDX5Wnu3zdP063ue2DXzWnDzWgRvRNv6b/sdV8ZhGfuX7QmBC5OEOe + 4oyv1PQQ2xfxmWvJ83SrZjv13oERfVOyfVB/5+kut52oumF0S9jO001ue5euM+zSZyp14KhvKlbG + qZreS3aPDr1hu9c+M7B9p+ke/lX1aRijS5wB6eE+IZhuCTobZ1IdONAH9chmJKjpKI2831SYkMey + oFUxRZxRf7Ztd1LTg3wm/UNwZZzkM3mM/CDdwbY7+mtKdWDa9uHtB0b0TS/II137lpU/rlqfSXVg + HWfuflOY0/OBTt1JZ0TfdMQtdbTu1P0zRvRNiT5YGd52PM447h4UI2IY9FelbgAz0mLF4oxTFRTt + M5X7gc/ooX0m0KNj3z6zXPcDW+7en4sue9P4a7LqWx3eVHLRPfyrztBxn5mhW9jfrfL34X16F1ry + GYS+tOg1HaURfVPxq2qfsbfPUPeQG9E3YRE4O1TBdJXPdKOYVV8TRsf3JqN8BqPb/FftdlWM+lYx + usqBuz5jVHzXPmNqccYcOgde1d50wq6a3hVKe/SG7QeRAxv2azKpDgx8TTO2OzgSzNBVnOnuHjN0 + Q9je06qYCj3VgXN6HmfCnJ4p6KDtqQ6cr0yeYSs6G8V2Ip8x6qyN0R3xq/J0fG+aoTM+06Q3fGZL + +Uy2MhJnijow/6tuOgceRGCeLj6zAHR2b0p14DHdXO/Ju0tDBdMtsTKGphvU34PtTZ+p1IGjvulV + 95m73+TmftVQB3596WtaKZ8xNJ3Zm3L6UHdgRN+UbB9EMUvTDUHvvcVT85klxZmL/oq7R3mXyDq3 + MkuKM5nt+TiIolOvQxnRN834DEaH48wU3RJ0fmUMQb89sniroXFu8tpnjviruuQzV5yRX7VJb9ju + tc8o+vUXFN3RdMZnPE1nfIa3nfGZfN2HE+pG9E1HPHZM216vz0R9U6JLnLGFz5g5213NZyDbMfpU + PqP+7NGl38TFd9R2xmcMTTfPXxWilz5T6Tfd+qaL7kxlb/KxDvzOlvYWvWG71T6jdr64N2X0/A0k + ZGWSvimn11fmTWd/1bsOfKYyrteTf9NZf0/6Joie/6rAhPqtbwr03nSOOdS7WaVWpdJvMqYeZ3Kf + MXEW4k3P34QBZn+ivunQtmufyeg7Tffwrzpju/jMGWJcbxZiynZL0PM37oBJi6hvQulri145a5+l + zjufueg+/qr5PVfvLWDZAn0jbA/0JfPI0a/qabrPbR/QmXUPdPdcmSY9jzOjHmWg43Fmhm6Ir6lJ + r8x2nvSkb8rX3at54Hc+449AN6Ttdz6D+HueLY26WYHuYbp+uRCj43FmV1Fs1G8KdOlRsrZjdOlr + I3tT/quWvYOaz9z5zJb7TLk3+QG9Ybut7U287U26J+j51zQ6rwa6i+uOxEhD021G7+diOkZidPGZ + g9pX8yLUP5t7U9I35Suj9yYbZ8iV7QW9YXs1n2navtJ0xmd4Op4D57s2SreTto8y7ECXHBjZV5cW + vVIHPpurLx1nTMVn3L03Nel12+1L703Euo9OB4HuJ1cGo6u9qdeTV7kYSreE7TydOTfZFr2iiTvp + h86BXfSZ+72DkM+sT9sRnzlq+Uw2qqjpa8v2Jp05N20SA2C6e35NTfqLtt0Sth80ncmBm/RGnNlT + v6ly1k7zwNf2q+oE2/BEGejSbxpnei/l7xjdE3TeduaszfrM3ddG6BttO+Mze8v2eg5sN703SSTI + 9U3n/Iyf8/ekbwK+Vf2rYnSf0UedZ54uPjPOUl/07nH3tVdgZdh9dcPrwMH2cJas+Ez5TtxJX+s1 + veLu+quvrSq1mL+vRA48Q8dzYE0H6jNR34SdV2fo6qw9qAMvNN0Q9Dy+l/WZms8saW9S9Zn7qBvO + 2uvzWwXqM0HfVP5LvrxJdgk7YfmfBNDFZ8YnyhfVbwr0uTowujI2t32QA79ousSZ8zdzvfnIYvco + 36MsNXEn/a4DZ7bHM8Lz3MTc4BvoTE2vaXuT7vOVGZxseLrLV+bjdCaf4emqdzDwyLbPPN9KPumu + 3jvII8HpM1tBB33mrgMj655/q0ClNtM3Id8qc4dLoEtf+yC/Vcz202e2uOmN6LfiDqXLWfv6mnrz + Yon+etL/PmfIT3p6vylf92dNb5v7VdP7TcH2wa/K0/3T9gad31et3PUKfKs6B8Zst7BH6mwJo6ua + 3mDXXlr0v08dZRBMVH0mzFzJe5T+Klu+6Stpe7q3E1p31mfSvZ3QPMGLprucPsiBebr4DHJuyulA + vym25aGVUbM/Bf3vc+bqlMG8ks+oflPuM+/P2caZq4WzPeqbEr17t4JRHonRfbbuo8kinu7QX1Xp + bFC6+Awyc0X6jNF14NHKHC16Pc5k+qaMLnN6Qd8kNb0J2w89C2Fy+vUXMnquiUPp3oBViCl67jP9 + X9Wq8ypGVz4zsN3RdAN7pKXjTKFv6k4wXvTQNQBtv/VNiO3syux6To+gA11zc9eBx7OdVkUxjI7r + Dqz6VjE67jNOfU1aq1I9N7X0TfldIu+fxq0/hdYcs73QNw205uyvWuibPk7HfcapXRujS00PWZl8 + 5wNmITJ9E2J7k1656/Wk3/qmzCMjJu5Ne+wdTNi+1uaBm7avNH3OZ/J/sUfHdQczdJuv+8D2jaYr + Tdzgjl2T0ctZiHKG/KQvdb32qn3mGpO3WSJS0hu2L1p7O7iZx9F0/F6I/GYelI5r4q6mbpgUg+l4 + nPHKZzC6eUaCnu11er1Hmemb1N60ZT7zDtLHlq9M+SZa23av9yb4Jqod6cRFfRO6MgdNd3AkWJS/ + Y3T8nqtFRQKMru4Sge/d3x89yloO7Go5sI4z5xZg535VRt+U37yG0j2xMjzdEXTWI1MdmI4zGF3q + M0gEzm0v40wtB7b1val48+uSVuR3SoNxxuq7RAbfqslsR1aGueeK/1WLe64G97rxdPxeiCwSwOuO + 31nU8cg/z7eSQ+mnGmfyvek8N7k5fzfaZ8Y5QaIDsxCZvglZmYWmM/kMT2d8xtJ0/C6RKwcOESbQ + 4+sq/6znM4fomx5xJn/za3//r/sJ2w/RN6H+ztPVPVeDewwdTWfiDOXvR65vQuiURx6ib0LpvkWv + 7U2H6JuKna+8H9jt24DesD29RwnFGUPT8bvRnNo9MLqDbZ+hq3xmcJLn6XgO7Nr+/reyNx2ib1p1 + lqrvejUSZ1z7Fq2G7bY+c2WSR4rtmvi2fTiNdoi+aQErKJ6mu+fKNOk7TbcE/aDpJqP3e2Ud+t/n + PeShpbLGdVeznfeverYK3PGaW5mQzwh92vYmPb6vDXRvZ2wXnxl3s3TVDaNbgr7S9NxnRvS2z7ha + nIn6poKe3yUS+tqVmh5ge9Q3YV+Tj32sVejx5YAe3XN00naXR7HBi2I83eb0wVl7oekm0tmTfOkz + D33Tm36kOJPZnt+nd33CL/s8USK2HynOjH9VfdbG6B5emessEHpBySOPAd3ldPhVXdR2S9BZnzkI + n+nQ/6a7gxV9Tz7j6j5zln1jPrOw8T3qm1boa5qh43GG/1X3tDch6x7mLhc4Ru5pbxr7zEpHsT3t + TYhHvlr0eg4c9U0FvXyLxx17sN2Qtm+1vSnb/H9Lx+MMv+6b3pu6HrmqkzxGx+PMSseZLfnM+My3 + qt2j1B08epSH6JsSvVYHfv+q+yvQXy16w/Y1+QyyMjzdEyuz03T3XJkP2i4+g9jO001OH9je85mH + 9vYQfZMv6zPBZ0SBFCPBpiIBYnvoa3vI9k1FAozuv0p3X6WfPuNAOr/uJtLHr0N16H9MNZ8JdeBk + +1LxmfOsvcytTKgD1+nXX1B0R9MZn+HpjM/wdJvTuzXsTe1NGN1E+vg9m02dm8r3m0yF7lKcUf2m + e2+64swe44wnbXcpzoz3pk1lqRjdP21v0tm9ySWfQWzPf9Wh7uAQfRNqO/utuuQzbIzUb/E872A8 + 6Vafm3QOnPKZbXlGMWRlbDprsxEYo3uC3lyZJt3BdJ1xYHSVz3TjzKq+JoyucuCB7VuL3tibjM6B + a/2m9wFiO555JGK7IXxG52IYHfeZGdslzozfEeJ/VZPizDjjmKHjcabjM7W70Q7RNxX0WDKOPvNO + Bnc/te5R34SeDpq2N+n+e+tuXjrODE7yvO14PrNmdZ+L7sIEWY9uiJVxLdtrGv9D9E3F1xTlC3F+ + 5u0zq0v0vELgwhRW2/Yj5cDIt2patjfpnogEPN1F28fvDc/Q47kJeF+786s26afPWIO8Ua3ppb6p + UtMzoQ5c0OOV5dFnfOiqd+kN20Md2IC2G5ruCbql6S5fma4GdGZllM8MbPc03eT+PrB9bdEbPrOJ + z+Rfk1X6pvcB4rUV9Uj1Z9v2UAe2YCTYWrY36cpnZlemSXe57UT+jtFtsP1LdEPEyKNFr+mbDtE3 + pa9JfCbXN7mQI3fpDdtX8RkoAr9ous/9feAzvO2OiO883cJRbKNj5ErEma0dxep14KhvKuhx1OZn + vXzmzBmOAb1h+5LyGcT2haZ7OL7P0HGfmVkZ+1W6yb8moqan6PXZzqhvsnWf2cRnXn5Ab9ju0940 + jpG66jbUrx6ib8LizKaiGEbH8xmZsXBCjxfK9OhMnOFXBs+BNxUjy7vrKzW9qG965MB559kFZZii + qz/btju9Nw1WZmvZ3qQzPrPSdMZnFprOxBne9rg3/ZzteNudj+yse8NnrOxNOV3HmbMjdMzZbmVv + oiMwRvfEulua7gjbebo6NxH5DEY3n7D9T70+Y1J9xjzizO0zr0oXEbHdSL/pKz5jpD5D04c3CByi + b0p0Io/E6Jaw3dF03GeeWurcZx458C76ptP2Spy5z9rL82Qz/FV30Tcl2xX9n/8s6c19tUn3eYwc + rAyVE+yibypW5oN03GdmVsYQ9KbttTrwLvqmxaivSZ+1vegOVi7j2EXftIC25zvf8GvaRd9U2N6k + bzRdegfISX6n6Zawnacbwvbmuv+11Thz97VNy2fOSHDM/apW+8ys7U26/8TKNOniMxaoLfF01aMk + OqAYXfpNSE2v+TXV9E276Jt86TNlPrPO+XvKZ6CTjaXpTD5D5QS76JswfyfzmV30TZi/z9huPmF7 + TXewi77p4TP5XSJOtCr6RAnYHvVNaB7J0xmfIfemqG9Czx48ncmBebryGaI+o32mctZ+0w+dz9i6 + z8hZm8yB7ZF8RmXY96hZk46sTOprQ1UIno7nwNmgBExXPjOgkxHYHjoHHtCbUexvZeZqF31T/VfN + 4owJdDICR31Tonf9fafjzE74zM7mBFHfhH2rM7ZLDoysDHkqi/omdGWa9Fp9Zhd900m/vpVXxWfO + mt46Z/uWcmD2V8XonvBI3nbGZ3g6vjdp+rBns4u+ibA9f+MnXhf/z/oM+S76pkecWTKfeceZ/Shs + V3+2bV8pn2nOvzfpnqBTM+R7pm+6vqbP2x7vEoH8nbpBYBd90y70bh7ZodfuudpF31TYLj6T+trr + MWd7urcTyIFn6J6gU6qGXfRNK+iRlCJjF30T6u9Ba37nHb43H7mLvmk1WJyxQo/zo4neiDNeZshr + cSb4zHtvWtdntoT8ql50lBf9p3u3ws6pY3fRN0kk6NN1DozRHUdPd72GdXcDuiXoTaVjkx7vYLyk + RiN6c8r7T+Xd2z17vynQj+gzLvnMKV932/q0fTiXuou+6aXpvO1Nuifo7O7h5K5XaN15erxPjz5r + Y3TxmfHelL9MlP8ZfKaWA9t6nMl95iXzwKQmbhd9E/o1UVrEPXu/CYhiej4SiTOW2JtWOorZlM+M + /X2GLj6DrHszvv+paPyvA9/6tD2mPnc+Iz5D6fku+kKsDBuBTcpnEDr7rRq5g/FL9HgPOfCrrnQu + lu7thGxv0mv6pj17v0mftW9903U9ySvqmyjd8J693wR9qyHTs0Lvq3j27P0maN1d7R926Q7+Vlf2 + a4r6Joyub4jB6Ab+mjS91DdV6sBR33Tafk0j7spnwv0z7//7EXUHpkVv2H6kvelJv/6ColMqnl30 + TYXtY5+B6e6rdEvQ2W/1IHLgtZ1x1OvAJr3fFMyWven63/jZ469qjZv7mna5ux6KkWQ+Y3a5UzrQ + P7zuu9xdT/sMRpcc+KKjdxaBMXKXNzIg25v76t/KDPku+qbi7CE+E+LM2w1F30Tuq1HfhJ1s+F91 + S+em/St0yWe+kHFEfRO6r5L1SJPuuYLozdNw7d3bXfRNZx14uf1d+8zbyON4eiQSgdM9V3mMzM+V + ik6etU265wo4UZIKpF30TSidXxnm3ETWOKK+CaU31712N9ou+qaCbtQdjO8/a/dcIeu+JJ/JPDJ7 + 1vK3dJ/Tids+MLrkM35IJ1Vru+ibvkeXc9NFH9yI1KTX3jvYRd/00usuPhPizCb5DKnN2qO+6XyV + Bdi1Z+iyNyF0ShO3i74JyzjI+fc9e78JyDhIJcwu+iYs0+uoSer1mfv9ptx2HWdOn1me9UjE9nse + GPmayL521Dc5g31N2098GzXQXXjhpkeX+RmQTtpuCdv5lZG+tvsNvaZv2kXfdMb3K83wlTiTMg7e + dpvmZy7bCU0cMINi7jqwBejk/EzUN6F0crIo6Juuf3TF/0/qbPaob4LpzZmrmvZ2j/qmkq5z4Hdg + lNlO1varDuwXcN3Jqdegb4LpvO3nwPEK0slJuqBvuv6Pu7/VBl3nYhjd5PSxqsFd6xPo9/xM7dy0 + RX3TtTKZ7bo+84Yd7pm/D23for7JLwZbGWo6Z4v6Jp4O2376jPsa3eb0T2pVtqhv8qhH9nQHj/mZ + LeqbSrquA3s52fC2X/nMTR8oMnj66TNp5/vwr3rlM1+kW8Lf2W/1ymeuSDDOljrfak2rskV9k980 + Pe83her+Omf7lc+U9I+t+5XP/GB55IztDqbrOgFGt5E+rhOQO98W9U0wvadVqe1NIZ+xRp0on/2m + x/3AeZmobfuVz5T0pu1UhXyL+qbr/yD0OwKjtovPIOdVni75zLiGnZ+1Uboh6HuL/tc+z9pb1DeV + dJ3PvFPTI85CHC163fagb7rpgzk9k9GHL49vUd8Erkw+Y4jSncn8/eN0G3ePZejv+QQjSjcE3bfo + f+3z3PSmH2lvyqKY9pmXxJldfU2I7QcRZ2boPto+jgR5VRyKYjY8RId1nvf2t9qk2+e6N+mvjI6t + jPKZLv1Q36qyvXaf3hb1TdevWvGZdNYOceZQ/o6szNXXvr7Xsc8c6lvF6D5f9wGdzAmCvgnMxQ6u + TrBFfZPHegcHVyfYor6p/FWb9LbGv3rWDvqmvs94mXA5uKrbFvVNsO1kDhz0TTCdqnFsUd900wc+ + w9MZn+HpBo5iR5x8t1l9xiefqZybgr5p6DNB33Rw96BsUd8E/6o8XfnMIM7wdOUz0Lrf9+n53jtx + W9Q3wbZTmuct6ptA27Mks6Q3fObqa5enskd9Jryr8uLu6Nqivomx3e3xz/1a921Al7M2Qqdufd6i + vumLdHXW7vrMi+trb1Hf9ONBevse8sqc3hb1Tdcv2zxrO6kD8ytz1YHv03A3j9T+jtHxs/Yrxt7c + Izs9yi3qm2A6vzKWoPvaP+zSpT6D0Jsd/9osxBb1TaXtD5/ZtwG9YbvTPjNre5OufGbgkdQ95FvU + N8G2U7fgblHf9EW6+QS9dp/eFvVNzzjjtM+Ed29fnNZ8i/qmp0feEgBF3x6RYB3QmTjDrrtNPoPE + d57+TZ+xn/GZmlblSt6vyUu9MvEatXsWIuTAvO2hDryA687GmVAHxqZzZujiM+OzNh/FQh04favd + iuHMuptIH2uEOitTz2eCvqmM7xJnUl87aG/pfTXom761NwV9E58TwHRnHhH4g3RL0MlsKeibGNvT + 2+AhvsfX6us1vaBvuuhPvXbcPd6woKPkVybUgYt/Se98gV71xTGd8RkyEgR9E5wtkZEg6Ju+tTcF + fRNMb2Yc9VkIs6ezdiWfSTrK3U3lM2an4gy7Mns6a3/jV92JHuXMyojPjJUBL7a2FMaubvrA9ia9 + 3m8K+qbrl90fcSb6zPvPPWapZG0p6Jsa9Osv3HRnsk4KFme2lM8MO6A5HbZd9qZhTuAMN0O+xaTj + pvemL52hd+1N5TOjlaHe/Nqivunem7T2NvjMewm2V6KnKvM+rnYGfVODHn0mo5NdxKBvKunNlaG0 + KlvUN8F0Sj21RX3TF+mX1uO39Jpee4v6pvtE+ZyFCHvTNmf7knxmHfp79qnBdJ+vzMfpLtKH++oU + 3eb07q9q6Rx4ST6D0JtZar2mF/RNpUdqn3n/ublAZ/PIUAdO8wSDdWcjcKgDQ9MKU3T3VdstQefX + 3RD03ls8tXzG1eozub5pOZF79Bk203PJZ/bhrq3pSE7gks+MI7CNyqYl6yJ2birZor6JoZO22xm6 + +rNHNzP0is9UZiGCvqn8VnN90xVnrnngnkc2bA914Lri7voLv6T7SEdWhtJmbVHfBNOp+4E30TdB + Osp89wB9JtSBIR1lsTeV+qZK7yDqmwq6jjOHnGwsOw8c9E0T647Sfb7ugwjM2874DDkvFvVNKJ2c + dYv6phm6nu2s1IHXqG8q6Xp+xsY5vR69Zvsa9U2wv/N0Js7wdMZnDE2f9RmMzvhM0/bavRBr1Df1 + fOY8N1mzztnuanEmz2oUPbfdQXTcZ4yaqcXo12tiBolihpvYXaO+6Yv069XxCZ9RK1Orz6xR39Ta + m4LPHHG2s/AZZN0tFWccTfc5vVdLLfYmjD6Xz6B08Znv0Jl8Zm3Ra/2mVfRNBV3rDkzsa6ssFbPd + JJ9BMj2ePpcDZzPZXTrjMxtNx+NMfrJB6Yag5wokIM5EfVPxq+o4c+4e5kkHbI/6JtTfebon6OTe + FPVNqL/zdOUzvTkO59j4HvRNoM906A2fCX3tYufTd4mcOfAyZ3voa2P7qmN3D3sQPjNDV3Gmu/PN + 0PE449TeBOQz9kj5DEJfW/Ra72AVfVNBj+nync+8XKBTqrU16pusqdKvv6DolK5sjfqmkt5cmRdN + d/nKDDySp6t8ZuCRPB3PZzr0v5X6zCr6psLfc58JY2RXnMkuLwB9ZiPqM449HUR9E0b37Jkv6ptS + PZLwSIxuYbq2HfGZLZ21EXqztlTrN62ibyo6E+Izr+gz8TTsubrYKvomSOnYs71Jlx7lUE0yZbv0 + Dr5Dt1N0oMq8ir4p0XtzqXE2oeUzlfpM1Dft2na9N703pMMGOnW/2Cr6poIO2I7SJZ/5xrovRJzx + qvOM0WVvQr4mSje8ir5pB+m9u9FqPnPXgZsZxyveKZ3brv5s2+5rs53aIwNdE8GVuevAXHxH6YzP + 8HRmbzI0HT83dei195tW0Td18pkzS41nbcfd+7OKvonPCYAu4ir6Juw0rG3H6OqsPchSqb72Kvom + 9NzE2y7npnGccZ1ZCFvNgW06N/mWz5ylBD+gN2wv6sDdqagZOnPWpvraq+ibUHqYscj12seAjteB + ndq1MduZc1OTXntb8ErEqjW9Ms4cZRUCs52pA8/QmThDzQOHq+WJdTc0nekdsBGY62s3o9ifal/b + NOrA+bnJic906HXbzYvqHZDxPeqbsJ2PnM5ZRd+E0skoFvVNKJ38mgxTB+7Qa/fPrKJveuQz179a + 1oH1XCpi+0HkMzN0xmfC/bc22z06Gv9V9E2/XvcmXZ2bume+zlRUk24IevO82vCZPflM86x9zlzt + z68JsX3XcYb4VjH69aY5SCdP8qaoA4/paXI03PvTeff2otuv2m7gCnnfZx73z6yib6r3Dq6/Gqr7 + ds72bXzWDvTafxJAx3sHem/CbHcE/aj9wy7dztBh23GfaVxnff5RrwMHfdOzIxT2ptdPqOnZ6z9R + ZXpQtTPom2DbyQp51DehnTiejseZcJf4dc9joN/3izXpeJxxbF0s6Jt+v+4Nn1nGPcp3unYdDSds + X6i+NvurLslnuJMNSmd6lPbhM517UFbRNxF00namr91cmXodOOqbHrMQ97kpnLXXOdt98pnnqeyf + /yzpZL8p6pu+te6e8hnedibO8HTlM8TKqP5q7U32VfRNjzgT9qakO3jtT48EurdR3zSze2B0Zm/i + bSf3JpLO+ExOB6Zzor4JrTI36X8qGv9V9E2NvSnVZ+xRVFDUn23bLXVuyudnkJWxlFalOfXapDNn + bXJiN+qbsEhAT0pHfRN6Ksvpaj7yT/3cZEb5zH0HYzFDDkxfRn0Taruh6fi5Kdeao3Q8zhjl7wtE + x+vAM3Rcd2DU16TotRx4EX1TI585YHrN9kX0Tb+2vUnH96YZOn7WnqHjZ21NH76VvIi+aWZlhu9r + L6Jv6uxNv7KdyWeMmhzF6IzP8HQmzvB0fG+aoeM5sKaXbyXXfKaRz+S9g+s+6WeMHL7zvIi+aWbd + Mbram7oVcu3vGF18Zlx/539Vm+IMQufX3eR0Yl9FfMakmp7qHeQ+c0hNj7fdpJoesjL5TC2y7nc+ + w9Ix291X6afPQDe0T9ENTNd5ZOkzjxx4ifqmkq7PTWnmqkOv2x70TTe9O5eq83cgJwj6JvBX1XTA + I6O+CYszWqWJ2W5zOrEymO1q5mpgu23Raxr/N/3oxJnzvyruTZVzE2L7keJMdsduFq40vfof1qVL + PsP6DPKrHpTPNM+rTbp9rkyPHrvxF/1+mbZJV3sT4ZG6PlPRqixR3/T0mSPzmeOKFI8aB7Iyu/YZ + RY8+k9Ep7e2S65uQdafqM0vUN10xEqFv2a969hFcb05vifom2HZKV7ZEfdPv6bU5vSXqm56RoNib + 7ONuNGzdt5rPQL8qsjIbtTfxdDyfIec4lqhvmrLdQHTzCfqfio5yifqmRpy5fcaZYtdWf7ZtX9O5 + ic0JkJVZJ/cm7Fdd9d40+FYp3cES9U3M3kTS8XxG32g61Kosom9KM+Qq40jvN1m3POnDabQl6pvA + ldG3gmJ0fG8y3OToIvqm19folqBTc6lL1DfBK9PTHTw0/kvUN7X2plSfuUpQxd3GiO2e8hlqPnKJ + +iaYTr3EvER9E0yn5oGXqG+a+lWHd18uUd/0e3qtR7lEfVOZ6Wmfef9bVygN6+72OFm7X5le5yW3 + JeqbLvrwtfrgMwW9M4OyRH3TlEci6+50DjywnbrBd4n6JjDDnqGfPgO9CVPc0F76TO3cdNWB7WI6 + PuNk5iq7vh20/aoDl7brc5PQi5vxMbrP6b1ftbjVH6M7dN3Z1xSWqG+y14sKgO3UHbtL1DfBK9O8 + fbhxbgp14PqveuczduaduIu+PG3XPpPRc2VAiDOdG3wvuifWnc3fTYozCJ2NBKEO7EE69R7lRTc5 + feDv7ThT7R0EfdO17s9fNYsz8f0m06LXbQ/6pnJlnnFmmu6Jdefpp8+sX6PbGN/H9IONkUHfBNre + eRG49k7cEvVNF13Fmfyeq0V2j4PN34O+qaQ3bSfPHkHfVO6rTTpvuyNsJ3PgoG+aoiM+cySf+RW9 + 3jswu/YZX/EZK7sHb3uoAxdfU34PuaKftdTtqqXKqy12QPfE10RmHCbUgdFIwNNt7u8DOr/uBo7A + HdvrM1dB31TmBHJv5yv9qpU4g9i+pXOTf9Azn7FzETjUgaGTzRTd5bv24Fvl6fC5KY/A6s8e3eT0 + Xk2vePG99JmHjnIRfVN6i2d9xJmgVdkH9IbtQd9UvDyu3zvI6Oy6r3jvIL74vl0aR0B7u0R9E0if + WRm4d1B9rb57OojDo9AsxMBnKr2DoG+6f9XlEWfOVyyqvyqyay96FqI3+zNFh+eBJ7KlBZ/tnLId + nu2cosOauN7K1OvAmb4pmwLUd9dLTW8i07vrwM276zM6WanN9E3Zy4XNlaFuEFiivumyHaQXNwj0 + I8FdBx7e2zllu/kEvd5vCvqmcmXkbcHt+lXfjrLFLJW6w2WJ+qYrziDrbmi6h+k72yszdx34O7bb + nN67zWmKbj5Bb+QzNvUOMrr4TNJrOztnu9U+07V9pyPwPQ+M+MxORgJLxJmd3vnueWCEztYJbn3T + r+iNmp7RWhUdZ+57rta5lTF6b1L0uDf9io7vTfy6m9TXRujsvnrVgTEVT06HbYf1TT167aztH/qm + Q52bwt60XTfN8rZ7St9kd27X9rm+abxr71zX3Mv7TajP8HTlMwM6lUf6XN+ErHvT9obPuLomrngn + 7ljnflWHv5Fhdy5b8qJvQum87fB9ehM+U9zb+XHbYU1cb90bPmNTDqx2j+tfze7tdHO/6q1vQvIZ + Q9Nxn9m4HNhT7zdN2Q7fpze17krj/+E4Y3rvNwWf2aPGf+JrMl+NM8S9nVN0Js6wPmN0nBn4DE+H + 74XorUztjQyfv9/U8Zmf12vKZ+L7TcW7t03byWwpvt/kwJXh6Y6g8ytzVfZ/+6s26VeF2SB1YDrO + 2HBvZ+odbBWfuWozz3UfVsgv+hJtZ9cdo8sbGaxHYnRH2E6dmy66jXQ2B8Zsh99V6dFr+iYv7zcV + kUCfht/Lcb2VPGH7XruDUVcMA7264mM6rPGfsl2dmwa5GE+Xvel0F2s+6+972psOwPbeWbvmM/f7 + Taqmd/1v/KzXr+rvszZ55sveb0Js5+lyPzDyq7J70/1+E/Krsj5zv9/0DZ/Z0ls8yLo3ZwwbPnO/ + 35TZHgU1t8+s69zusSqfGa0MNR/pRd+E0nnb5f2m11fo9qv03Gem173WO/Cib3r4zD08u5zI7Sjo + 6s+27Ut9b/KZRwa6JoIrE+7tRFeGXfeF8pk8Sx3efuBF37RFsG1c0jtPNzm9IYXP6G7Lbh5Ns24N + n/HiM7nt+lc99yb/rHEgtoc68AqtzAzdE+tuaLoLtgefGa87SVdxZkA316+6pl/V9WZ/vLzfhNE7 + 617rN3l5v6mg673pvRzbOrfuLr0tiNhOzVx5eb8J85kZusSZcRTbODWJl/ebUDo1H+nl/SZ03Xvn + psc8sJf3m4oILCeb5UcO+Mec7Tb5zDfW3aazNrIyvO0SZxDb2Rw41IFR29kcONSBE33wNTXpjfpM + qAMXtsu56fYZM7cyRvYmICfgf1VD+QxbQTE6zsx+q006E2dYnzFEDtyh17QqXt5vKr4m6VGG+Zn3 + J+FfU7bH95uuCtDwzLexnbj4fhNKJyu18f2m79HtV+mGoPd6B5V8Jr7flOh6FmL5kXzGzv2qh/KZ + kb+TJ5v4ftP5NY1rqby/HynOgHSls+lqzb2837QKfdBfJXsH8f2mDaQ3f9XafXr+/HM1j5XRugMn + vQPe3/eUzzzp119QdLLqZnbKZ3jblc8M1p233RL0tfYPu3T4bcGe7fV8Jr7fVNBFe5vymeX13LWR + ldm0z6ArA9M9Qafm9HzUN32RzvgMT1c+M/iaerOdNZ9Ztc8cfZ9hbb/rwL+yvUln4gxPZ3yGmkv1 + 8n4TGgl4OhNnmnPY9bN20De14ozkwD/HPqA3bF+oOJOvzPAGMB/1TVPrjtHVzBXhkRhdxZmP02fj + zPBuNC/6pmGcWZ87H2K7T3EGyd+pewwvOhNneLrEmfE8MP+r3nVghM7bbnL6YN3bPlO5f8bL+00F + PT83XY+LL0tJB25J9PJ+E2p7qI0bocdbGXt0T9Dz13Iw2/P6zOfpcz6D0vG+dsf22ls8Xt5vKuj6 + rG1un6Fu1vTyfhNqO/WSm5f3m1C6yejDu169vN+E0deoA3dCjy869eiWoB+07Xic6dDrs53G6PqM + +My9N13SMb8F+t6iN2w3uqbX/Zr4lTFETW+Gjtf0Vu7WZy/6JqxytXJ3G3vRN6E+07S99r62E33T + I84Enwn1mfO2j2XCZ5zomx47350+/5J+zaQapEK+Rh3l+nPfFN65P9KJvknoo3V/0jtxxom+aQF/ + Vcrfneibfk3/W8mBneibfPmr3vcDXxMuryNFYMr2kM8k+pHTo8806MNbzp3om679CcgJDE0Xn+Eq + tShdZsgROm+7IehN2xs+Y5PPqLO29hlrX3MrY5PPcDVslC5xBqF7ms74DG+7JejUG9VO9E0zK4PE + mZDPFHT9JruJr1gU+TsSZ0zNZ3ScyejUO6BO9E3oylBvNTjRN83QsZVhfIbKlpzomzDNRIde6zc5 + 0Tclei3OvD8J56dsj/omTMUzQxefQehkthT1TSid3LWjvul7dMZnmvS/lXuu3vRD+0ztfW1z7005 + 3eT0hu2FvglWx6J0lc/ASkeU7gyaLe1q18bo183DX7Mdz2c6tjfizF7PZ+5zk79u+3g96Yi/7/W9 + 6T43Kbqj6YzP8HT3VTqeA8/QGZ/J6aXPPOozTvRNjRw41WeWLdCpmp4TfRNqO1XtdKJvQrWIVA3b + ib4JtX2n6eIz3I1IKF3lwAP60aLX+tpO9E0FPc9n/HWz5jagN2xf096E2M6uzErFGZ7O+Ay/MirO + ELdoDftNTvRNv6Y3fGYZnbWv3cP5OdsXHWee9RlFpzpxTvRN6Vv9cBRbKJ+hepRO9E3or8rTVU2P + UIMjPuO1z+g48/qJe9NRam/Vn23b/eisrejsynjirD1D/6bPeCqf2VKV+aI717uh3Ym+iY/AT595 + zAM70TeN4ow95uKM03sTHN9ROrM38XTGZ5rv8zXpjM/w9E/5TKWmZ209zlyfTTxrn7q8bc5nbM1n + sofJNJ39Ve1cPgPGSKYOPLMyeE2P37Utlc80Z2prsxCXs0sOvD99JtT0lvjuLXszz0Wv9JuatlMv + dV70ubM2Sp87a6P002eu3vZX6CbSf2V7Td/kRN9U2B63sexdFTtle9A3eWy2U2ueMbqPdPauKIzu + cvpsXaxJP13++l7/If8Tbbqh6SbaPqZ3aqk1fZOL+qaSrn3m/CS2ov6u/mzbHurA2FsNG3saDvom + eGX2YgpwMK0Q9E0MnbTdfpVuYI/s+0wlnzF73WfC3hTe4jmnFfap6r7ZU5z5le1Nuoc9kv9WQx0Y + e8+GjzN78pnv0FWc6b70068D13xm68SZ669ee9M1Js/XgaO+qfiXHjufuRraz/g1puNxZo9v9poU + Z2zv7noX9U0MPa4MtvNtaW8av9+0c9PGLuqbbo+cpdf7TUHfVNLjr3p+Y/FX3abqYkHfdNO7r3Lx + K7Mmn/kOXcWZ8bo7eU0hVFDMgG6JX5U8NwV9E7wyZB046pse72vnkWC5u4jkaTjqm7C3Y2foctcr + uDLqV7X92c6ob8JeoZuxXeozCJ2sz0R9E0bPvqCKz1R6lFHflN4W1D7zSj4TX1hizx53HRh5F9H8 + yOy+/KrHgC51YJBO2i5n7V+te5Mu9RluZWRfHa2M4ej1CFyv6RmX6jPqDdMizri19Hcsvt91YO5b + RemiO+CiGEoXrQpCZ082t77pog/udePpcpcIQm92/Bt7061vch2fMY8eJWb7rW9C1p2cVsj0TSwd + mEEx9z1XrM9gdPtVOh5nOvRGTe/WN9nbI7XP7D/phSV23U3S3roH/foLir7QdLlTGvmaeLrotZF1 + 96mLKJo4M6Bbgk7OXJn7vQOWXuoOHhp/K/qmwnbtM5vUZ8g5PSv6JnRlKFWDFX3Tr1emSZc3MthT + GUa3OX1wbqI0E1b0TSg9t93n9NpZ24q+adf0vN+kzk2LdJoCva+otqJv2kHb15btTbqfoas/e3Q3 + Qwd/1Tuf+Q5d7oX41brXZsit6JsavQN5k/3n9ZiKwn7VO5/pVAwTfaPpPqcPVibftReI7szD9iZ9 + o+l2ko6tjPkE/W/lrWQr+qaiE6d7B5uoY/W5CVkZk3wGeefZZPQVosu5CXl5nKe7STq2MnaSjtlu + JunK9rrPRH1TvQ6c8hl7hVJ+Zex9b+c4Rmo68DXZ+95Olg7Ed3vf24nQ81wMWxmpzyB0MheL+iYP + 0pu34Nb6TW/6oeszSyXOvP3n2Ao6aPuRanqI7eTOZw/KZ3g64zNb7R926TanDyIBufPZg4oz+a5d + 5jOVc1PUNxX0Zw5sAj2viyE+s9fymabtlMbfir7pe3R8b3qpKAacKKO+CaWT59Wob/o1vdY7sLm+ + qRlnzlmIdc72jYgzLzoC3/qmcQ78ihWUI1VQll4Fxeb6JoTenCdo0m1OH/yqPN18gl67g9GKvqnh + MyHOeHkrOaODEXhNPvOMYtdfUHRq0sLm+qZvrPutbxrn7zO24+9RvtRM7bCbZXN9ExdngPv0rOib + XPVXTXXgeENMHoEx20Nfu6Dztjfp6g1TePdA6fgbpq/s9aPQX136lauob0LpvO0Gph+qJ69nyG01 + zng9D7xVfOb8z9sLOhhnfJqFWFtxJtH1ygwn1K3omwrb+ZVp0sVnkGyJp+PzMzN08Zlf0f/YWk0v + 6pse8zO5z6R3b3nbXfIZ1TXPfSajU7c+26hvgteduuXcRn0TTKdeU7BR3wTOdh4xF9tSRrb0XlOw + Ud8E2958TaERZ2zHZ+Kvut9xxkgnLv5vLL25JSv6pmL5yp3vpNf+k4brblOcQSrk9413su6dGRQr + +iaCTvmMJeKMVmlidNGqcP0m4A3Ty/DqbGf5q/qyV4bZbvRsZ8sjfdlFxCLBVQeGZ2rDLJfPfKbv + 71cdGKZTL59c9NN8dLKIzfRM0h2M6Vu8p9ZnuVhcmb/VHDjom3wxx5Frb8+anrWV9ygB26O+Cat2 + kroDK/ombEoko2NRLOqbsBlDUk1iRd/kQDo1OWpF38TbXmribK0OHPVNxQTjM59xcz5z1YHhleHp + HqbT32rUN2F5pH6pE4gzUd+E0skoFvVN6N7UXJm3zzw0cfb8c32uu/aZVSoopI7youM+Q+o9LrqP + K/MduiPo1L0QF/3aWkH6keViYffo6PkuuiHWvfmt1vtNUd/U9ZlN7tMjJ6Vt1DeB6677fAaie/hr + OtiaXtQ3obbzdJvbPqCTFcOob0LP2k0FUu1uNCv6poKe38EY8pklnYaLypXr2r4mn0FWhpoHtqJv + Qn9VaobcRn0TGAkOOp+56sDuBdL5lTEcPf6q4WSccuDaDLmN+qaLrvIZnQPHOjC/Mlcd2GEzhvyv + etWBHTaNNmO7I+js3nTVgSdsR+nmE/TaXSI26ptc96x9fhJbouen7NF5NeibHKbn439Vn3wGjDNO + qjQvyHYH0+nqfnyMOc0yd+ffX7EudmR1gn1AN5Fuh/SjfSr7U525CvqmK84o3YHuUVpX1oHVn23b + rzpwSR/8qvnKdKudQd8Er0ye6SFnD5d85qJ339fWtiNZapgHPv+RAeiU9taKbGIBV6Z3n17t3HTV + gUu63pvOFH9JFfK4Jlg+c9WBYdvJ7q256sBXFEN+VTaPDOOdiT6wnT2V2bQ3fYduou3jKNZRx9Zn + IYK+qaSLz6w/Ic44u929g/z0NPqarjqww/R8HQ1ok+5z22cVpk26y23/pKLaRn0TuDLkzWs26pvc + jCZOrcwjB75OqkHf5NJZuxZn/E+6FwLX8wn9bbeF7gd2Vk2O9n9VoZ/rjlU7mfl3oZv4qyKRwLTo + D41QoIecoPAZve7uju9NesP2kBM4oyJwfl9qRteqZIzuv7juISdIdEKVjNFnfaY/BSh0E+ljn+l8 + q4+eTaCHnKCga59Zbi0iPlMr9IVYmXt2MXTQ26cDoXsiir10hOnk70J3OZ34VpEoFnICLFvifcYS + caZD/1vOEwR6kRNIjeN+ozpMMFbiDLIyRU6g6DHOZHRcvyp0lRPAWSpKdwSd3ZtMyiMROv7CktDl + vMpW3bRO3ha11IseNELlST6/y3u9X9A72JwgaITgKgReMRS6J1YGr6AI/fSZz1c7hS41js9WDIU+ + Vxd77k2uQj+Sz6i62P2ezRUJXi+2Yih0VRf72BSg0L1Bq27M9KXQmboY3nkWuqqlfpyuzqtjVUN9 + Zepnj6ARKnft0mfS1Gs+p7f/9KaNhb6YR8ZR7k2JvrRsb9LxHLizMk26M9mpbEDH5yOFbgk6Pusm + 9Ou4DdJfLfrjrqhAv3rDF70ZZ+Rk44z6VhHbr95wSW/aftD0K9/77co06bDPFCuzQXQbbWdXBqOb + aDtCf7Xof8q7FQJ9TXGm4jOb+EzYm16qPoPYvqYcGInAG01n9iae7gy6r86sDN7ne6kKOUaXcxPy + NTVvKvlTvmse6Euqi6mzdh5nrJy1eduXNIc97kzM0M8/sSrEDP083GDn1Rm6ijMDfdNC0yWfGd9d + H/RNW5w5PjMOL7cPP2b3A92nHPiqdsq75q/MZ1LGcdDx3ac4c31IAxUPT/d5BIZnUFC61PTYDBuj + W4Juabr5hO0PLWKgu/relPuMk3cm+F/VUWft5r7apHti5zM0XdVnCI/E6JZYGZ6uztqz9D/1s7at + z6DkNT17n7XZXdtSZ20247DaZwjlF0Z3BN3RdKkDI7c5sV+TTXEGoTd/1cZZ26TegdI8vzKfOT8J + V/YO9sGdRUJfmvTrLzTpyMqYdNb+1co06e6rdEvQ+ZXBfUZPSqtf9XFf6kUPGiGXlL2b8pmUz1jz + 9HfAZ4JGqKRDK4PRfU4nflWM7r5Kt7EKgbzfxNMNQQ/1tttzkkrzce9PoB+pPlOJM0knbx83DWK2 + hzpwenFmvDIuv6120KMMGqE70yMUpsC3GjRCU3RsZSxBJ+NM0AhN0ZXt9b0paITKk3xMl+Pc0nmX + 4j7nMzvV115o+tVbAemsz4Q6cKqlDnrD7K+6p3yGfYEDo0sOjPS1m/SHRijQt3qPstybKm9UI7Zv + +txETHRhdNWjJLTmGB2f3Z+xXfUoiYwDozPnJpMie9inVnnN+G+1phc0QuXJRuJM0Ai5++5LS9pe + 1IGJeyEwuspnupUr+mQTNEIwnbfdGrROwPsMUwfu0Bt701LrUYrP3DW9x32pmO1LOmtzej6o+pNp + hEC66q+ug2xp0b2Dj9tuiZVZaboh6M0O6J/q/EymEarkM6k+c5gBvWG7r9Vn8g7CL+l4v0n0TWvm + M60ZcqEzPrM/PLKlVRE6E2fIGra554FZXVnpM7V85p4HruxN6d2sa+R5wt9dmoXgtLco3RN0NhK4 + NNuJ1DjI6r6554G/Q5+tzwC9A3PPA2cneb03nfnM61mfQWy3qT7zpMc4k9Hx+5aE7p/0xsrM0B1B + Z2OkTfMzyAvY5HROlKs4MXtA97V/eP7RqOmZVNPL6OXukWp67LdqaveLlTufteH/+2H1mO5j9ecy + u6cmKW5ZwWyXs/b1d189+kZ/TSbV9IZKmCm6yeldn+nQH++av8+SL9EIFbY/flWzPdd9NOsW6Au8 + MsztNkL38Mrs1JxeoDuCjt+NJnSmDsyvDFMHbv6qFa3KSXfJZ5p70xkJ1qdHIrY77TOtKLbOeaSj + fKb6D7t0xmeYid1AVz7zcbqJERj5Vpu64Urv4KTbXpxJdWB3DOgN220tzpQ+k+i4slfonohiPN3F + KjPiM0ENfr8r1laDC91GOhIJ8LtehW4iHemVBavzGx598plSR+leUd9kD1PEmcuxs3ngPdmeVibo + 5Ft3jgp9mVwZ5Fc1qXfAdhExuiPiO0+3hEfiimqhm5ze/Zo6N4BVcuDzvPLScWbv+Qxzv5jQlc8o + eowzv6JLnGFnUDC6I+j47ZRCl9nOL/h71DcRdCcdhBAJXslnKnuTrfa1xWdSfSa7W4Gy/Uh7E3JD + O7lr20P7DPySG0rHfWaGbr/o70fKgVnbR/qmk77XfeY6BvwE3cHbXw77/FWBfTXqm4pZCJtJXxWd + PHtEfRPqMzyd8RmebjnbUyQ4ripzW1cW6IzPNG1/3PsT6KGvXUQx7TPr++wW68DkeTXqm+r06DMZ + ndHEBTq+N4VbA474hsiRR+Am3cHxnfeZjdib+G91I/YmuVXBPFemolU56aue06v5zHL9r/ejWMP2 + tTbb2YuRTm6iQn7VlagDc/X3QJeZK4TOVDsDXfUOPk43hO3NlXncSRfoi44zW8Vnzt2jvGNX/dm2 + fanFmY+tzJLqwGw+g9FVnBl0s3g6rqPk+h6BjusoO/RKv+mk+9Rv8nmcuTahmAPv93vDzGRRoONx + ZobOzAMzqrVAZ/pNPN0afFKa0UwEuoG/Jl11G2lvT7qrx5ngMymfMUdRIQfjjKPmgZu2N+l4nNmp + matAdxzdyURzmHVrz0IEOnPWZia6Ap05a5sWveEztqY7kL3p9SN37Faq+4jtltId8HQP03XfA6Pj + uoMZOp7PbHQEtukeQ8T2fPZH+XvlXohrBiHN6akcuIgzLr5NwszUBvryXBmbNd9/SffcypB0fH5G + 2z6afw90pYkb+AwzXR/o4jPjfbVDf9yXetGjvmkV+q7iTPCZ98a+LFO2R33ToumfWpmob0JXxtN0 + 8RlkWiGnj+5gDHRLrIyj6YbwSNui12t6Ud9UZKniM7e+aXnSkXU/UpxR3ay8PqPpKSdYxzlBpm9C + fMbQtuM58AzdwvSV0iIGOn7W7tAbPrPrOT2JM/m5yct9eiuldAx0yWdUXzvfm35FF58Z9/lm6O65 + Mh/7VfeUz1B09WePbuCV6fh7w2e2+pxe8Jl0l/f2moszG+IziW6yXCzEme48QZhJAycY+Uhw14ER + j2R95q4Dj3e+GbqBbZd1z+P7PQtRy2fWdNZWPuMyn1nev+ox5zNrOmsjOQFP91+lu6/S1Wznh/19 + pWY7m/RGnFnqM1eXz1xzupekYz2edCQXW7TPKI+MceZXdHxOT/+qHqK758pA647R8XngNfZTbj17 + T2cT6IazPa8Aj87apjEPnNdnsndA2ZXxtdnOpu3s6YCZB+ZPNp7Ym2bo9qt0fLZTn1f1ucnWepTG + 9famVNML91xt2fxfmNYb9ORNdR74Yz7DzANrOuLvzDzwlvXLJRKMVobxGTZG3nVg5CTfpP9JAntF + t8lnKvWZFGeuUvdEjLRpb0LOfEfL9ibdf5Xu4HVfVU0Po1vC9oWm47qDtf011fvaUd9U2K7n9K6+ + QaCbjI5EAkP5DE/38K+6qLMHRsd9ZoaO6w5m6HicWVSFvHyLx5T0Q/RNjzgTfCbVgfdXoG8tes32 + I9c3IbavNB3fmxYuJzg4fdMMHT83Le1KbZNuiHUP++orO2ub6DOVOHM89E1qb4rnpjMHNoGeR7Hh + me8QfVN957v+wi/p+N40Q2fiDHXWPkTfhNrO080n6JW3eE66re9NxVn7tcytu635zMdWhslnFm4W + 4pD3m1DbqfmZQ95vQm2nureHvN+E0sO7WSaLM0vymVqcMakO/Mxn7kgQ7rlauHrkEfVN5b+ks6VA + r/0nAXR8tnOlPdIQ/aZVTXmrWmqTzvSbqP7qIe83oXlkMxLUfSbqm+pxJjtrL8/8HbDdvmr3QjRt + X2k6PnM1Yzs+PzNDtwSdXxnGZ5r0hs8cY595/1vhDsaVzYHtQfnMluViy8+gr33RVZwZn4ZTJFhG + dYKLzsQZfmWYOHM8VmZkuyHozVNZ7V6IQ/RNj72pqM+4Sr8JWZmd8BmypneIvul7dGYWgqoYHvn7 + TeDsD14xPETfRNDrttdmrg7RN9UnXLKMwwzoDdu32vwMb3uTzvgMVRc78vebEHoe30evXQa6JVbm + nrsMk8fpZs0mnfGZrWV7bR74eOibtM8c4jNBUc2vzFqbB36etffWyvS/Jkbf1FmZJp2ZB+bpeD6j + 6aN3QAPdEPSlRa/1KI/8/abKPHCIM697kq5Jb9i+1LQqen7mV3T/pENRDKPj7x3oXRuj4/fpabqB + 6Ph9ejqfUfSajvLI9U2V2c5C37Rm3cmLflcMG7b7NA+M2H60bG/S1Qz5ONMjbZd5YLabhdmOz5DP + 0HHdwap6B4jPuJ7uIMxcvYP0sg3oDdvdV33GETPkM3RcdzCzMvardMZntha93m+K+qZi3cVn9ugz + P4d9nuQR2226h5zt3mJ0xmc8TWfijKPp4jPI5ChPN5+g1+b0riKB8pnaDPl5P7Cds90QWhXd18bo + Hl6Zpb1rN+m4VmWGbr9KZ3ymue61u9EO0TcVtmuf2eSWxLz+nikH27Zn+qbxbay5R6J0D697HmdQ + Ou4zeYxE6Uyc4emMzzTplXdVTvrR85lw1n5vSPsy96seyWe+8aselM+w635QPrOmetsW7xfbB3Sb + f03d24fznAC13RD05rrX7no9RN/UjTNnTrXO/aq79pkPf037V33m1jeBPkPS7VfpctZG4vvWojd8 + 5q4DN2fI3/95bi/PHpjtGxVnXsW3OjgNm43wmXz+HbUd95kZuoozH6cbwvbm7lHTNx2ibyoiweP+ + GbcN6A3bV8JnNjbDjvqmGUU1Rlc+Q2jNMbol6Lzt+HsHHXr93BT1TYXtunfw/vPwcyuz6B7lh1dm + IfraM7Y7gk5WIaK+CaU3KyhNuuHoqtqZcrHaDPkh+qaHz+Q58DugbMtzZYAKedQ3of6+1v5hl874 + DG874zNkR8jc91whK8PTSZ+p0/9UZzszfVOjr339v7zWOdudniGHurdO6KPubaZvYvvamO3uuTJQ + jMTo6p6rj9NVj3KWXu9rG1vvURZ702aeGQdiO3PPlVZpYnRmtpPsHVDvN9HV/fL9JnSiC4zAlpq5 + au6r9d5B9n5TJc6Iz8S3eOjeQdQ3obYvtX/YpTM+w2ZLhuhrz9DxvvYMnelrN88efytxZhd9U/fO + ovcntO4Ttu+ib/q17U06PgsxY7vEmfFrxmSvbBd9kwfpvO1Mj7K5a9fqM7vom9aezxx1nxnuHrvo + mwo65DMY3ZvsLU1i3TG6M+g7oGs8ddy5mO+9OLOLvimtzIBO5e+76JvQdW9mqbUZ8l30TV2fyeLM + Ttp+97WRX5Wnq3dvB+vO011OJ+Y4MLqFbSczvV30Tdh78nI/gX36+9/nW8luF33TYYp3b/Oz9tsN + F/Okm4veuV1+j/qm8rV6Paen6VQENul9bXBlSLrL6YNJOnZfDfnMAdLZvSnkM4dB4kyncvU3jeHm + 9KhvKt7NisfyO84sx8R5dRd9U6ITc9gY3Uc6O+WN0V1O/2QFZRd9E2o7T78OCCC9GYHr+Yy9+to3 + fa/4zHnWjncWkRHYHslnkHV/0XSJM2O6vssbo7uv0i1BJ+OMPdLehNCbcabWO9hF35To28NnrqC+ + x7vrqbP2Lvqm3RRV5vtQrej5m47vf9EtPeXXLvqmgs6vTJMu+cx36DanE29pIh4Z+toovZ0DV3qU + u+ibCrr2GXf/qmyMDH3tzWD+TmapUd+0gvQw/76mjGzkkVs6NyE+w0bgLZ2bvrMy5hP0RpxZ67Od + uc+c/8/7c2VMTm/YvhKauJ2bYNwf+ibiV8XoeF+b/1XvvjZiO9Wj3Ln3mzqRoOEzS11HmfvMezMN + dxbxK1Pomwa2s99qoW9CPVL92aMzb36lfwjbzrz5ldMRn7n62hY7yXfob5+pnLWDvskWlav8rH35 + TLgfOH9RDJif2aO+yWKn4dx2lO7jylx3BfpP0x1Mz2MkSreRfp1N3KfpJv6qCP28H3GN9UhzVVBM + 8hlToV91YOs1Pa/phTizzMXIqw7coF9/4Zf002cMsTJLnAU8/23Xry0FfdP1j66Vs0M6absl6Oy+ + etWB/QKuTHjH8c70nGiea5q4PeqbLrrL44xJPnOpY69xj4nd46oD+1RlHuwe7M531YFhOnuSv+rA + F/38naz5tO1Sn9mGdH7ns0SPsp8DP7Qq14GvOguR+8x6RYqplbnv7URs367Y67Madv9kc/e12ff5 + MNsdYTvZzYr6ptMjHUDnbZf6TBYJevQ4gV32Dqr5TKZvyjKO2AJPOkrrt6mVifomb5B8Zmfr70Hf + ZF+yMoOMg6yLBX3TlYtZgE52JoK+6QfdmwxNNwS9aXu9dxD0Td4atfOJz4Q440UTx6/MVQe+qszI + r2oufzfPXKxJ95GOeKR90DtTgHvUNzF0cmVUv+njdGOy+vugptfzmUo+E/VNRec5yud+wv3A5wKv + KRK4LWZL5mfY8Td3HRiJ72QEjvqm7Wt0l9OJnQ/5Vfe0NyE+Q54Oor4JpTfz99pdr/v550rQyfzd + bMT8DF2FMFcduPIvfYqO3wtBZ6nm1jchr3eTk0VmS70DpMYRFGV7Fgn25DOmQl9rPiNx5mwvncdT + H+6fOeivaU29A8R2NhKsqXeA/Kohwz6emV6T7gj6/qBvA7rl6OTK4HHmaEeCen0m6psaObD4jDv2 + Ab1h+6Jnrga2k6fhqG/C6C86EizEnN4rZktb5jOdN+520Tdh02gvtmse9U2E7XV6/awd9U1FJHj4 + TOg3vehzkyfizAwdn9OboTuOnjI9xGc8kc/M2M74TFurUp3tNPc9V9nJRnxGcmAXXnJ70fvqfc/V + +Nyk6cN7DHfRN32P7gi6uXzGCf3tM537I3fRN3mIruM7Zrv4zLgO3KH/qdwPvIu+qeh7lD7jw931 + el9FbLfp3PQr25t0H8+ryLrztjuCvj58pn+Sv+vACJ26FXQXfRN2kq/ZfvcOajW96jyw9hkrL9Me + 3F2vu+ib0B4lT8f3phk6vjcdKr5jdHxvmqGLVgWhNyNwrQ685fqmyt60is8stuxrA7Zvub7JP+jX + X1B0avfYcn0T8q3ydNE3sfThjdWb6Jtm6MM71DfRN1m97pBHKttr91xt+ftNz181+sz5PSxzK3Pr + tVl/R1bm1muz3ypm+9k7SLP7hO0YXWYhkPkZni6zEMjsT5Ne0zdtUd900/fKucnP+8yVz1jshhj+ + V73yGYvd+6OrP4hHXvmMxe6KmqHbnN69vUyvDEY3cUoEWffm+3w17e0W9U0/hynmgU3mM++ztj+e + eSRie3i/6dArk3fMFD3PgYcvzmxR33TePwBMK+jqD+KRVz7zs8dFsd38Xdc4MLqNMygbQGe/VZO0 + KmOf0baXPvPoN225vun5q1458PmMmA3vxOm6GOAzUd+Ezb8fsYq6Cz1MSHXpUtMD6aTtUtND4gxP + twSdesN0k/ebsJV5taNYrXfwplfv7dR70/H+58uTDkQCW723M8+BFZ16ye2iK5/pzmHP2K7ulP44 + 3eb0bsbxYnc+e6RzE2J7k167H3gTfdPjHvLrfyPOz7zTtcXP2X7f24msDPXu7Sb6JpS+ye+ZopgZ + 0PF7yF/srh31Td+jG4LejJG1ftMm+qaie5vXZ66M49L4O8Pu2rba19ZxJqOTu3ambxr2+abocI9y + ig77jDPs6SDqm6CefKCnr8n9xNng6DO1fGat+Uz+vnbIUl9P24EaR9Q3FWe+/IVURaeqbpvom6AT + 5ZTtLqf34vsUnfEZsrYU9U0o3bTotTrwJvqm4k2YR79pif2mV4vesH2p+Qxve5MudWAkn6HmCTbR + N6F5JDVdv4m+6Xu2y/wMks/c3XhRmG7JZx79pk3eb0p0nc+kOvBqEp2y3VP5DE9X+cxgZe7pwmJl + mnSliRuvO2m7el8b+FXzOyrT7tGkG47ejDOV+oy97+2sxJnkM/54ZqlIJLjrwI18pqSneTEHZKku + vZWMdPwX2nZ1N9qgr011ETd5v+m0Hema83TRqiD0Zvf2j63GmfvezovuVJxJPcqlEmcQ2+97O8Ff + VX1NXa3KJu83zczPYLbLXSLjSTpy0mITfVOiDyIw2eezd18bsb1J/1PRHVzJu+xN6pXR4DOhPrNL + 74Bfmfv9JqXsvf8LFJ1dmULfNLsyTTq+N4V65JqdPVxvFuKiqzuliYohZjv+rkpnSqR21+sm+qai + LqZ95rj7TdQMyib6piIX0z6T0ckoZl74uYmdJ9jk/Sbs1okZOn4POd2Tj+83YXdaHFFN8npmS7X7 + 9DZ5v+lxL0TwGekdxEotPQuRvd/U8xmhG5ruc48k7lbA6O7p7xAdqKBEfRNWw56xPY8zI93wrWEP + r9rcPuNqfe2ob3q8dxB8JvUo18qviqzMru+f+fDXtKf5GYS+pDWR17s7E7ub6JuwMx8fI299E2I7 + efbI9E2IRzbpNX3Tdv65Pm1/7k3bs0eJ2H7XgZEqBBvFNqrfxHrkpuszY7qTe90Qj9yIOEOf+Uxx + zxXRsynzmUq/KdM3VXwm1YE3O3VuMkUdeLZO0KQzPkPmkYaoA/PVzkzfhFSZDU2Hfaagq92j3m+K + +qZ6dT/rN7m0Mqkz4YGviagDF+uO7HwLkQPXbO8oA7Zc38T2+TDb7VfpTJxprnv9rB31TQ+fuf43 + nmdt1mc8FWdYn/G/9JmR7bDPFN8q0HnO9E3focN3MBadZ93Xrmj8t1zf1Iwz58lmG9AbtrvauYm3 + vUmHewdTdPXuLbF7YHT4reQp2/Gzdm8Won7Wtr23Be/Zztcz40Bst+ncxE5FYXRP0MkJ9ahvQuns + r3q/34ScbMgpwOz9JoTenM5p1PTue64qPnPrm/zzVIbYboi3Belp4+z9JoQeehL324ujvclQdWD2 + a7rfb2LP2hid8Zn2nF4lzqyib3r4TDk/sw3oNdvXXN+0PujXX1B0amVW0TehKxMymT3zGTOgO4NX + 9/mVYeIMvzKMz7R1B/apb1pF32T1yjx8xu7PCjliu0v36bFaFYzuczrkMxvsM8V7lJ+MM6u834TS + qRnyVd5vQlemufPV9E2rvN/UiTPXzJXxz5oeYrut7U15nFF0KidY5f0mrCNEzjKv8n4TOj8TPPKV + PLKrmVjl/aaZ6RzMdkPQe/nMo6a3yvtNj45QEWecfZ6GEdsNfm6aon/t3LTK+00oncqwV3m/CaWz + EfjuayOnsrZWpfJGxir6pkJN8ogz11QUb7t94eemKTp8buJ/1ahvQulhMvJA40zUN6GnsteD3rmj + axV9ExqBm99qTRP3ph/63dtWnNkmqhAXfbA3KToZCeyR8hm2/o7R4beSp2yH30oO/q58pvvy+EWH + 38jofau13sEq+qbHLIT2GXvdLu8MmxNEfRO6MuTpIOqboK/JGTYniPomlE7VCVbRN6F0qj6zir4J + Ojf1bP9T0VGuom/qxJmrPiORgLV902+yr48480s6PKc38atu+LsqU3Q4By7ow67KKvomlL616A2f + WXUdWPIZn/nM+9DplxQJnKgahlrENX+/SanB8zdMNZ1a9/v9puEE4xQdrs9MROD1B57tnKLDuoNi + ZYY9ylX0TcVJ/lnTs89dG/H3Ba/PsFrEVfRNFvQZ83NPowV/70yor/n7TeOZWrLzvObvNyF0qnu7 + ir4JzbCbUaymo1xF3/So1Ba9A1+Zn0Fsb9SB7xGQX9JVDvzhX/XWN41fPumse5Ou7pQmlF8YHX9X + pUOv6ZtW0TcV75VpnzH3zQ3NKNaw3dXeidM+k9GpmatV9E3YW2sv1W8aTtKtom8i6KTtKp+ZnaRr + 0g1he3P+veEzVvvMWo8z5jWgN2y3qab3K9ubdE98TdR85Cr6JnTdqcnRVfRN36Or+syAblr0mvb2 + SsTWJ13PQpyFipl7yC+6Oms/9yZFp95au+h472DGdkarct9REnKmURS79U1sXxuzHX/DtLPuNY3/ + Kvqmx/xMfm4y0js4sg6frEy3thT1TcS0ArMyUd80070dKqrXXN/E2o7RZ/vaGF3VZ4ie/PDd21X0 + TY9IcPvMdTfa5gb0hu0HXtMrvlX7M+w8R30ToVUhbcdnrg7uXohV9E0onboXYhV90689st6jLPVN + +k32NNspuwfr73cdeH/Qn3sT+6vuut80+Jpc4ZGDjlDUN0Enefa1nFX0TSideiNjFX0TVLmaiDNb + qs8cj6rbdTfaFWdkb6Learjoy5Pei+/Fr9rtxJkNr89M+PuWfOYYnrV5f9+Uz3yebj6xMrU7pVfR + NxX0cm9Kt7GSZ76ob0Jtp9Tgq+ibUsXw43QmzlDqqVX0TRid1CKuom/CvtWOFrE2D7yKvskY9TXl + Z+2gO6jMXCG2L+n+mSf93psWn9bd6XvdOrcKraJvKugf+1VDHRilsx4Z6sDfo5v4uise3/N1j7t2 + Y2+66sAlvfQZ67Y5273yGU1PPpPod69fbN8HdPGZLFviv6Ym3X2VbnP6bCRo0k2ks/cDl/fPVHoH + 5n7voDkPvMUuIl91M/c9V/uDHn3mV3R5Kxn5VcmaXtA32eK2bX7dm3QLR4JXdjNBEQmadEPY3qwY + /qnOkAd90zPOFD6z7nN7U3jvQOifjsA2+cx36I6I7zzdwr8qn0fa5DNsfaasA9fijNFxpqbxP65T + 20VnfcYkn3nS094U6TudcZjkM+MqxM6p8NeobwLXXTQweSTo3JK4Rn0TGCN32iMN4TPSg/OZ7TGP + rM0DL1HfVNIfsxBBE0favkR9E7PuJJ3xGao3vER9k03vmnfrkTvXvV2ivumLdBPfEULoS4te06os + Ud9U0nWP8r14oQ68czFyifqmBv36C4pO9YaXqG+yO7gyPN0R687+qnc+g7wnT01aLPJ+06/ptbd4 + FtE3Fe9mic+E9w7O6cvXnO3FvZ0fXhlL3PU6Q5f6DLLu1HTOIvomjK5zguGc3iL6pjRZRNwaV/rM + I59ZRN9U7zz/pNnOrZLPICtj9JxebeYqo1Oz+4vom1C1IKVVWUTfNHMHI0bH52dIZe8i+iaiz1en + 1+ozi+ibjCl2j2KG3LsnHfCZqG8qvqbHDPk83T9th1YGo7ucTvT5MLqFc7GDzcWivilVmQfnpqYi + 429lfuZNP+rnpnxvOmPdMaA3bD9SfYa9xxCjeziPJF+hu+gOzgn0WRuj4/nMzMpITW+cE3Tu42jE + mT2dm1Q+k8eZd5bq3IDesH3Xb5j6SpzJ6OlXVX/26MwbpmTGEfRN98oM3o6lpryX/P2m7P536FfF + 6CanE69ID+/TW0TfZDRdfCa9e2vvFyPT693neb57u/wi+qZHhl1o/O3xrJAjK1PomwYTjDwdjzMz + dAtH4Iv+Xvc1W/dO9Wd56JuIlSnjTOXcFPVNxb37jxlyueeKzCOjvim9OPPsNyk6u+5r0vgjPmMy + Oma75DPI7kHdT7CIvmkmRmJ08wl6Td+05Pqmyt6U3lWR+Rl2ZW590zdWZklxBqGzOcGSzk3foasZ + 8nE+47Reux9nFkKr0js32eec3pLrmxrvxGXvN/GnA6+1KoTtGB3XHXS6Kk26+AxCp17/W0Tf5A2W + pVId0EX0Tcl24j35skdZ25tcqs804ox6AZvqyS+ib0JtNzRd6jNjOtlvWh7vN32cbmGPpLsq9r7n + CqGHKHZ3zFIUq81CLKJvqldQ7h7l6qd6B1HfhNUjdzoSFPdcDeiURmjJ9U0Inf2a7ns7x/SN9khG + 39Sh1978ujbV4V0i6b2Djes8X/SlSb/+gqKTHSHL3Nu50f5uCK3KRvu7oXyGtx2/s2jr6igrPhP1 + TY9bha7/jbg3bXKy6dDrtptXTeOvZyEyOvmtRn0TdsPjDN0ZtDOR/eQw3RK283T8Dsa1HWdq88CL + 6JuKCrmen9mk87yy+6q568DN+ZmMTsYZcxD9ppX9VqO+6Xt03Gdm6IagN2Pk3+pZO+qbipXRb7Kv + 793jlX5VNW289tQki+ib0HVnfeauAyN01t/3VJ/5ju02pw9+1aTiif8ba2+6fhF9E0pvZhz1WQiz + 1eaBtc8sb5YfRLGG7VstznwsAm/aZwYr8yL9/a4Dj6cvZ1YGn9Pr/KpNuiHovb2pcm4K+qaS/ogz + u5n7Vdc0pze2fYaOz+nx+cxKxBk+01uJvjadYZtVx5kBvfe+9kPjv+T6JrU3HZnPeKnpbWyvLNM3 + Ibazu8dCxBn6zBf0TeBcKn0aDvqmKTq27nic6az7n+o8cNQ3HaaIM3vmM8sdZ8jecNA3XfRvrEyY + B/4e3eX0gb/zdEvYzn6r9zwwG2fKvnbtrH3PAzfjzLk32WeMRGx32mfGFZQi4+ioeBbRN6WJ3Q/H + d0f5DJsDO+0zH7fdxElpcF91+Q1gm9wQ86ei115E31TQdZx5+8y2BzpZS436JnRleLrymUFdjM04 + LDFDLut+TyukdW/S7aTtQAc06pt+Ta/3tYO+yaZZiFX5TKrpmUpND7HdJJ8Z9z1m6J6gk3McUd80 + Yzswp5fpm1jbMbp5/qpNus36Tevl7/Glzlqc8aJv6vrMKtX9lZuP9KJvwtZdn/kwOu4zuoKC0XGf + 0VU3jI77zIztSqvS7a92bK/Vgb3omwrb4/VG0WcWuVVIVwwR2106a39j3W+99nfo+Az59Yauk3uR + 1isX69xP4B/6pu7usaootkG2Kx3lwPa8ClH6zKM+43N9U2b7Y2+6+l4FHbH91muP99U1rviS1r17 + 67OP+iY4ElDx3Ud9E2X7EaM84jOWijPNX7VJN7m/Ex5Z+kxtbzI1rcozn9nnvlUzHWcQjzRUnNlo + uiMiAU+3X9xXDZEDr23NRN1ngr6p/Jq0z+zvL94+8xlgZYK+CbadzJaCvummfzZbCvqmqXXHVobZ + m0iPDPom+GtqrntN3/SmHzqfacQZu8z9qsdXfeag9qb83axwOnADOnNuep49RnQ8zmzs3mSPFGdw + 2/OVuc9NpkLf6z5zZD6z32dtMicI+qapOgFGJ+sz9ZVp0l1+ovy47cpnuicbqXYytjM+k9OXwmdq + cWZLdWB1bsp95n3Ofq3PebFhjcNHfRNcheDpeD6jf9VhDdtz+iaytuSjvgmmU/V3H/VNv1+Zen3G + rvWzdu4z53vNfm7dV8pnnjVsM6CrvQmKM/kbGZ3OhI/6pjvTI9Z9WGX2Ud8Enspm6Iagt3UH1bO2 + XernptJnjue+Oryn1ou+CTvz6ZXB6Lhee4aufIboe2B0ZhbifmVNbmjv6Jt81DfBtpuW7TUdpY/6 + ptJ2mZ+56zP7gN6w3ev6DDGXaiC6n6GrP3t03GdmbMd9Rp8OMDp+N5qucSh6w2eKvvZRjzPuGNAb + tjtiFmKGjs9CzNDl3ITMuvF0fH5mjREmf5ukW+207qs+Y+txRufA7tp+J1bGUnFmoelMnOHpjogE + jqbjsxC6DozR8fmZDr1xbjK9+ZnUbwq9g4WOwIaYhZihe4JO3VQSr3zG6fm9nQbIOAy6N+n/BzAn + MES/aWm/I1Sb0/NR39SPM+t190KfXrc96Jtg26kXZ3zUN32RjseZhZu58lHfBNMprYqP+qbf217v + a5tD9w4acSa8SLBkM3RyXu3uq0Hf9LWVOYi70RZu2tiLvgnra8/QLUFnPfIgZsj7PvOYIfeib3rM + kOfnpkVyYN72nZghn6Hj+qYZ+jfjzP6Da1UWbrbTR33Tnb93dTZLuz5T71GaTc+Qv6LP5P0mJ3e9 + Lpze46IvTfr1FxSdmu286P4TK9OkO4JevkgwmIUwW8qBQTppO+Mzzfheu4fci77p8as2cmD2a1pr + PvOx+L5qnxl8q5RWxUd9E2z78fCZjuLOi76JsJ2kMz7Tvheiem4K+qanVqU4a/vKuQlZ90X7zGBl + eDoTZ16aO1z3hajPzNiOa1Vm6MxZ27Tof2w1zvh6Ta+oA/st0V3+msKgZ5Ppm54qzbg3Pej418To + m1Z6Xy30TQN6c92b9FmfAfp8Ud+EaVXka/Lpz9Tnq90/40XftJuqzwStyjsZXN2c7aEOjNpOKe68 + 6Juw9w5m6I6gs7v2rW/6Dl3N6Q3Wvdk1/1N5I8OLvqmIYvoukdNn1mcuhqy7pc7a1L2dPn+/CVl3 + k9GBaYWgb4JPwzwdr8947nZK/3i/aUBv3h/ZyGfM+F6IXV4k8OyES9A3Nehxb8roPuuqLONZiKBv + AvXannszID7Oh9P5lVFvC37cdvzu+g69Nqfnzv+Byru3z/tn3ITtF129Lfiq+ExGp+aWLrp/0psr + kysdl1EudtHx9yhnbGd8Jp/9wWw33MrUba/NA7uob3q+R2kynzlfpo2/KqVFdFHfBH+r1LsqLtc3 + IevO247fCzFjO7M38bbjfe2O7TV9k4v6ppKu48z5vvY+tzJ2fG76FR0/a3suW3Kib0Lp7K9a9LXH + /l7EyM6J0kV9E1gn6Nheu+fKRX1TaXseZ67b5dd9LgIbYn5mho6ftcmMw4m+CaVT95C7XN8E0ql9 + 1ej6zIDezLD/muc95E70TY97Ico44wP9xdme6ZuQCEzdjO9yfdPHzx4u1zd9x3b8rD1Dx8/avl2F + qPWb3vRDv0epz9rh/ab3B7ctA3rD9oPymSPzSA945EHcP6NPw5jtjqCTO589iHxmhs7MQjSrnfVz + U6ZvatRnwssn7tnnQ2zfiTk9sovoRN+ErowjPZLra1OVKyf6JpRO9bWdvN+E1pZ672s/egcuf79J + +Uz1bUHe9uq9nY23Bfl136hZCGo6x0V9E0NPHjnse7jH+00ftx3X+Pfn9Cpn7fh+0+M9Spf5jFPz + M6nqZoGVWbVWZXbGsEn3X6UzdeCVpttJf8fozMxVU8VTmyF3ub5JnZsKn/GV+RnEdubeTp1xYHQ8 + zug80kB0pg58pD1P5oE78zNO3m9C6bzt+J3Set0V/Y99zuk5eb9p5DOLeebAiO2+vjfd4fWXdDyf + maFP9ZvUnz06E2co3YGT95tQ223aUcXf4y3nf9yzR+nk/abG3hTOTV7uru94ZMN2V9NRap9JdH9P + uJS2N+m4ViX3mexm1i4dz4F1fQZbGVx769U0GkbHdZS6I6Tof9LTqopux/nMeT/b+qy6IbZbQns7 + Q8fzGU9/q0xf29NfU3i/yUJ0R+9NlnhXxbU9snZv5+XslTcy4jaW+cwr0O9cDPtWTe2NDJsdin5J + x9/icZlHonT1rkq3d+BidLRCd2vvto8QZIhf1dG24++qZM80l/T6WTu+3/TIZ3KfeX9wy9U7sGx8 + b73flPtMRicjMPV+k2V3j/L9pgGdUpi6/P2mcTdrho7PQtj23lSbIXfyflNB1z7jpILSoTdsP5LP + POnRZ35F98S632pnyZY6tz67/P2m02xrJte9Sc99ZkRfk9Uhii39emT2fhNiezO+13sH2ftNGf25 + N9n0rRa2d+sz2ftNiO1by/YmnfGZnaYzPsNGsT35DEJnI/BO+UzT9r+V2U53/tnxmXRuCm9k8LZv + Os68cnqMMxmdPA2bTfnMaGXIPNJsyWcQj+RtZ/Ym3nblM3bS9vr8TNA39ePMe/dY7ZztKxFn8lwM + qukFfRNMJ+uR8f0m7Fd1qleG0XGfmaHnPjOi9+rApkJfVD6TfGbJfObUa28DesP2Jb2vfTzoMc78 + iu6f9ObKrLV/2KXLu7fjKOY4ZYCL+qZEH/2qlJ7PRX0T7JG995tqccbXfSbEmfVHstRjbmW8ijMj + 28lOXNA3fZHOxBmejuczM3Q8n+nQ/1RnroK+qZFx3HvTdvtMrEKEeu3Sr0IEfVPDI2OcyeiU9tZF + fRO8MvvD9v65yRE5MP81ua/6jKN8ZmmtTKM+Y8f5jJV3VVzsweHrbql8hlKyu6hvAjO9GTrjM+6x + Mp07pV3UN01lepjt4jOv39Ab+YwZn5vOSPB65sCI7YY6a7O7tiHizIztjM+wv6qZ9hkk0zPUuamn + 8X/4jM31TV2fOSZst6JvqtOfexN1srGib/rKulvRN82cyoY+Y0XfhOZi/MowOXBzZRo+08hn8h7l + +59v29y6u3p9Ju9rJ7r2d4zO1PSo+/QuusqBB/X3kC3de/fSu0/PSkOLoJMrg/uMju+KXrvnysr7 + TV2fsfevSlWubNQ3wSdK83NPAZpRhm2jvomhk7bnZ228z4fS7Vfp5hP0RpwJ+cxJb85cnZHAzdlu + tM98eGWM9pmP07/pM+arPmOSz3B97Wcd+NFvslHfVH6rMkO+is8s65TtQd9UroyeIf8VnYwzaqKr + +wqdjfommE5N59iob+Lp6s8e/fQZ/1vbazrKN/2o+0yxN+3uWcNGVuao7U06n8no7LoflM/wdCbO + 8CvD+Aw1P3PRzSfotR6ljfqmoc8c67PGgazMTuUz1FSUjfommL7QdMZnqHkxG/VNsO1Ux9+Kvonv + TDxnIR41PSv6psbedOcz+4DesH2jfIanMz6T0w+IzuxNR9rzLnq/pmdF34TSX5nt2MrgPpPPpRYr + Uz83RX3TyGfWY0Bv2L4SPpNP7KJ0PAeeobs8J4DvJ0DpuM94tXtgdDyf6dhePzdFfVM9S/1JGv/t + cS8EZvtSz2fulO6XdDzO8Ou+EHFGe+QO0Wd9BqMzcaZJr+koreibHj5TnLX38s4i9Wfbdl8/NxU1 + PaH7lu1NuvgMd1MJSneT9OHLtFb0TQQ99/R+n8+KvunXttfuYLSib+rUZ87RU7fHu0SWFr1he6gD + e/PT0sT9ku5zOnxrHOYzLu1N+K/6EvrwVw11YIJO2m4IevMk/yc1qhQ91IGLXfvpM2YuAtvkM2zG + gdE9QTc0XeUz4yw1eov4jBnQcZ/R+TtmO1Of2VPmXvh7bRbiMnx90p970/o88yG2G+0zxIkSo3uC + Ts3phZ+UoLORwCSfASctSPpsfabMZ8yTbhp14NJnHn1tyPaob0LXnaczPpPTgRw46psIevpWj/He + FPVNGN2qszZm+1wd+HnWfsx2WtE3PeKMST4TTjbrgN6w/VA+w3xNGJ3xGZ7O+AwZCaK+SeLM5+mM + zzRjZO0+PSv6pofP5Gft9wd3mEQvvqZu5Srqm2ZsR37VnfWZlHEgkWCnfGahVwaPM2J7Tu92/KO+ + 6dfr3ogz28hnQu/APOvvyK/K1YF5OtPX5umMz+w0fTYHxujKZ2bpjXxmTT6jztqFz0gOvD/8vTtZ + FPVN31qZlTprG5qOn7UdnXGs1Fmbt53xmabt9d5B1Dc9fMYkn7nymd3O2b7U6zP3f4GisxnHQvkM + u/Mt2mf2T9OZmt5934R8q52beazom37tkX/qPuPHPnPmM3ZuZXwtzmifyeisz3B14ObKNOl4HZiP + kV7HmYFH8rarOvAs/U915irqm0Z707EmeuHvnVvjrOib0JVhT2VFHXhAd7TtEme4G5FQ2xmfedre + uVvBir5pAW1vfqu1O4us6JsWU+weRV97P+ZWJtSB6/TrLyh609+bdNxnXMzCcJ+56sAVE+p0NgcO + RcPla7abnD6Ikc0bMxpxxmifacUZMzXhEvVNqO3k3FLUN32P7r5KtwSdnEaL+iaU3p7Tq5ybjOib + hvmMf9ZSh7Yb0Tc9PPL+Lyjpxe02na/JiL4J/VYtbTvjM9T0pRF90/dsZ3ym+avWZsiN6Ju6ccbM + +4yr+0yxN83T8b2JvNfNiL4JW/cZOh5nbLzR1GLnJiP6JoKebNdn7Upf25yBrOozRV/7eCgDgF37 + olfzmWIWYp4ucYab8gbq70bkKjNxBqPP7k0YnYkzzSmRhs808pmiRymRYG3RG7Zz+cxO05l8hjoN + G/n/ox7J021O/+QssxF9069tr/tM1Dd1feb8nO3E6cCIvulLv2rUN6F0qlJrRN+E0cnpHCP6ptUg + +yp5ojSib0r06Tpw3WdCX3vVHvnQqrzc3MqEvnZh+0PfJHRq5uqi+6ftzXUndw8b+trYupOTdBfd + fpVuCI9cspN8mLmKHdDaG6ZG9E0Pnynun3nFN7/yvWk4fWlE3/TwmeJ+4BodWZk9+Qz3tiBKZ+JM + Pi+GrQyez/jY53sJvd+TN6JvQulHy/Zaj9KIvumxN+U+Y6Q+47PupNje6fgb0Tf92vYmnfGZnL5C + dCbO8HQmzrxoOr43degNn1lTnOnkM+51nWzyNzIw21cdZ7oxcobO+Ay77ivhMzO24z6j6cP3KI3o + m2ZWZvgmuxF9U/GrPvYm6Tc16Q3bl9rexNvepM/6DEYXn0GypYOmM3Fmp+mMzzTpDZ/x2mdaeu3X + c9dGbPeUz2xpz7vow13ba58ZKL9yuofoTD6Tr/vwXUQj+ibsNKzXHaMz+czeWpma7sCIvqmwvekz + B2m7o3yGuonKiL6JyJbCvgH6jNN70+DskUcxbGWYOMOvO3Nuavp7TUdpRN/UzYFPn3FzX5Ot5TOP + c5PQ2a/J6jgzuzJNOpMD87aLzyDTCjzdfILe8BlTz2fKOFM5DSO2GyrOrFkkOCdGfO/1kIvO+IzX + O6rzvRmUUKadrKAM72C86LP1GYzO5DNpZdK6H8lnzJMe9U2Pc1O1R6nrYoDtUd+E2s7TmRzY0nTG + Z2y27nbs76aoA49vECDphqDn617ewVjJZ0xRB27lwP657sP7I43om0Z1YKGbjG4gun/a3lgZXSHH + 6LjPzNCZOFP6TFfZa0TfRHhk02ce+iYj+qZ6pfb2GdFrmxa9YftdB2b12hidOTfldORX3ak442i6 + JVbG03TzCXp9fsZsY58xd30mpyO/6lbzGZ0DZ/TlEYG7GYfZKJ9ZaNuZ+kye6SE736Z9ZlwnIOmn + z2wGzt+LPHJPPlPbm0IdeCt/1eosBH32MGvdZ4r7Z4ROng4MVwcma0uGqQPP0Jm9iacbwiPz+sxy + +cyWfOahVTGib3rkM0Wc2Sv1GcT2UAcu/P0RZ/b7fW2S7p/+3lwZnu5yenfd6ep+1DehdEvTDUd3 + okoOPhNvwa3NkBvRNxX055zeNme7Tz7zjZXx2mdmV6ZJ/6bPeMJn6F5Z1DfN2F72KGs+45LPHD2f + WZ6/KmK7Sz4zvmVlhk76DElnfIan5z7z+ZX5lM88NP5G9E2ds/blMy8/1fE3ljo38XT8rD1DdwR9 + o+lMDhzy07v74ft9D3PXgcffqj7ZALMQxvR8Zv0RRfX2pAMTLsZonyHuHMXojM/wdMZneLrNftXP + 05kc2LXolbtEzpFXX/eZ/P6Z/Z6+bNIrtgf68lwZfdfrr+iMz/B0x32rapLOd6pugW4nIwFm+2yc + KX2mzGdOuks+k9F1nNklB+Ztd8pnPr0yLvnMd+ikz5B0Js4wd44GusxCsLaXWpWyDnzSbd1nijul + X1u+r95fk+v0PQK94jOPO6WFztzBGOieWHdGCRPojM8wN2sGOhNneLohVubVov+1j5pekGOsT7r2 + mbPc6gf0hu23vglZGZ7uYbo+HWB03Gf0yQaj4z4zQ8f3pg79b9Ip5nT7qscZk/nMWW7dAz2/T2+/ + 4kxbAxroKs5039JcKEVGoOc+MzpRLrV/2KU7wiPJKBb1Td+j43vTwsYZe6SZq6bPnK3AY0Bv2H4Q + cWZlvyZ7EHFmhi4+M86wV0o9Fei4jnKGjvvMyuYzUd9UfKvxebCYA28SZ1Z1O2WIM+06QaAvcCRY + KQVSoOP3dq70t8rc27myGYdl7u3Mus0w3cAeuXX2pud7Byd90/PANZ9Z31nqK9BZf7/1TeOa3gwd + 1/hv7Mkm6pvQdfep3hZOB7ZzD0qg43FmxnbGZ3pxpuYza22GXPvM+TmbQCfPfFHfhP6q5Lkp6puw + GfIZOq472Ogotv4oHWV3LnWjc4KV0B3IOXhNu4eV21grsxAnfanNkMdSTooz/vos7EZH4IXQUeqV + Qb6mhfCZPd5Jt2SRoH0vc6A7+Ffd2Yph1DehdDbOLITPdGyv9A5OevWeq9Jn4t60q50Psb16b2fT + dp5O+gxJZ3yGeUco0Bmf4enqrtdZesNninuu9ugzu/KZuDfx/s7c28n/qsw9V7xH3vdcjfUeM3T7 + Vbr4zEXfhlHMSUYWIvA9P1PpN2X6pvXpM6/oM9Ytcz5z33OV2W6ybU3RWZ+577lC1j3sTS5bGTOg + u6ftH/N3q33m43TGZ2xrZSr6plBYWnO6+Mxl2M+RflUf6Ia03dTijMn+akbn85n7/SZwZUi6e67M + B+ly1l6+4DMm+cyv6JV7O89y4Uv7zNbwGTO1MlHf5KB1p30m6psSvbsy+mSD0R3skRt1D0qgW9gj + 9ZkPoxtiZZr0yj1XJ/3Q71FKJFgzn3n/i1cotXIeMymKmY4yINCXJj3GmYxOZnpR3/TrlWnS3Vfp + 9ov+HurA9tc+Y+Q7VvQ9+YyKM8FnQj7z/s+7WvcTX1OoA5+2j2MkH2d2ymd4uoPXnY/AO+EzM3SJ + M8jeFPIZm0WCJflMpXdg7vebLvpaiTPnJ7FP5cBmS/nMkx7jTEZn48yW8pmM3lwZ5l63QHcEnY0E + dx34O3RD2N6LM5VzU/Z+k/pVl+QzZ4PMWj+gN2xfaz7D296kMz7D013+rX6cbgnb2a9p1XFm9mtq + 5DNL2psaPnM1s4PScWe7iFHfZKv0GGd+RfeTK4PRmThDdiaivmkmimF0xmea9Eac8b04c6YAZ6vc + Xq37N/3IcuD92vlM13av48zSt53sqpi7DuyH9IPtgJq7Dvwdusxc+eGvOkM3ue0DerNHWa8Dm7sO + 3POZK5T26A3b7/cOGnFG0ckOqLnngcdf08HOXJm7DozQ8yg2uvU50PF85qBj5D0P/CvbGz5jx/nM + GWNecytjU5zJvlXtM7+iy96ERII1Ox286fbVn2WO+iaCTtpuv0o3BL35umu9rx31TQVdx5mzFr08 + 4wxiu0n1GcR2ns74DE9nfMZnu3bwyLayN9Dt82tq0plXFwNd+Yyf95lHPnPk7zdVfOYQn5Hdg3nZ + KtArPqPjzKu+N2F08RkHrAxvu8tXBqbnJd0e3RK/Kk+Xmh4XxQr63+fbgifd6Tjjq3vTzyvuHluL + 3rDdJZ9BftWdpjM+k9NH988EuiN+1YOmW+JXzW0f3T8T6IZYmdz20mcee9Mh+qaCrvemd8Zh17mV + sdpnBiuT05GVsYTPZOONMN3Bv+orq9Rm1ZQuHfeZV9Z5vuhxrXp03Ge07UqvXZshP0TfZOs+k/am + kM+8spwAWxmT6jNP+r03CX2h6VLTQ1Ymj8CIz5i0N32HLucmhJ5Xf4b5zCH6JtT25gtL9Thj7/eb + wnuQ9XNTmO18UW8gBbqcte1Nb9p+06G9yd73dg7pzqg4g9EdavubzrwIHOiSAyP0OweG4ntM4Ql6 + imLmimLyFk+6XkrRj5QD29xn7h5lyFLd03Zk3UNf24C2Ly3bm3R/viEC0skcOAaD3QDfqjPts0eT + fkbf8x8Z0naMfh7MXuDKtOvAld7BEfVN18rYTpy5St3OcBXyI+qbynV/1meWge1Nuid+1eYr0k26 + ix6J0M8K+Xq/VTT096uvbVeInslP4ZUxsO22rW+q1fSOqG+66bU4c+5LR6BTNewj6ptg23m6/yr9 + 9BksvluuUntEfZPFdj7L9eSPqG+yUD7Ts73hM1dfu6TnsxCnvNFe7RFn2Vws6JvulVH0GGcadGTd + r762hfLIsDJuvVU8w0hw9bUZerJ9dM9VoFviV2Vu0Qp0xmf2bGXWa2XW5DOVml7QN9nHWTvMdt5x + Zkl06le9+tolfbwy6s8e/fQZC9LZX/Xqa8P0haZbgu5o+lVoxulOdNXBZ+63eGo58FUH/imyJR1n + ZCpqwvarDmyxHNiq6j5G99F2B9CZewwD3eXrPqDzK2Nz2z/sM1cd+OcA6fm6l29+1eLMVQe+6Kq6 + n/vMHqv7xboDFZSgb5qyHVmZqw78g+XA/LpfdWDYdvv4Vs2AbolIwPr7VQeGPdK06H8q88BH1Ddd + K6PiTL437VcMFTq1Mjb5DBJn2JWxKc4g9ObKNOkOjpEmq2GjdNxnZugmt31A771hWoszJvmMe/pM + 2puuUneP3rDd6DgzWHeejvvMDN3FXIytcWB0O0lH4rtJexNCb96MX9M3HVHf1I8zR6zu9+h124O+ + 6cr01LnpTnYVfaXpnvhWeTqezxh2Xw36JjAHnqEb+Oxh2vG9Nj9zRH1TabuOM2/Pue6UDnS33HdP + jPamoG8Cz3wd25t0D1dQZmzHz9oztuNn7Rm6Omv3OqCquv/0mcddr0fUN9nHhEueA18dxAG9Yfue + 4syweztFF5/5Dt19lW4JOnmSD/omhu6y8c/7a2r4zJZqehV9U9ib3v/31z4XI7dUnxnOpU6sTKgD + E/SwMjHO7L3ZzutPR9DXjL4BUWxLexNITysD1IHNlvam4Qx5j17TxB1R33SvTC3OvD+h663kIp9B + bF+TzyD+ztM9se6hI2ThX3VN+czYdn0qw2zHfWaGLuemX9Er72uff4Y6cFqZWpw55/SOOduXVNMD + bXfrfadFnIPt0f0nVqZJP339JfSefrU4lWF0m9vepddWZh3Q5dyE0Hv3XNX2prsOrPamOwc+//di + PmM57e0R9U0lnbe9SfeTdKDvEfRNoM/M2G4Jus18Zr/21e6cnvHaZwYr0+trV+ozQd9U2v7sa/sB + vWG70z4z/ppIOu4zhlPcHVHfdFWZwZ2PpFv4V6WnRMxdB0boW1apDR65JZ953Fl0RH1TafszBzZ5 + ppduCY733bRtt0ScoSeLjKV8huzJB30T/KvydBVn0HOT+rNHx+OMnA5yn7n72qZCN7rf9NybrsuY + X5WqG+Lvdx1YneTzml5Gp1SaR9Q3lfTmylD6piPqm8qVadLJ2c6gb4LpvO2nz+zgyvT0TY++9h71 + TWUEfvSbQo9S04ezbnvUN8H+Tk2O7lHfNPGronQmzuT04cTuHvVNYJY6Q2fiTHNlarOde9Q39X1m + U3Vgat1DPoPmBKzP3H1tlo6sO5fP8PTTZ84ZQ9bfh6qGPeqb4DjjWvSGz4R8ZjO13SPuTWcOfM+Q + x4mui97PZ/aob4Jtz5Uwo/e1A90/bW/SV5qu9qaP05XPwJUrlG4I+t6iN3zGpDjTyWfS3kTp+fao + b4J95kXTGZ/h6c7gkYCni89wtSWUfvoMdGNGcRpWGcffyrlpj/qmkq73pvWuz5C7R9A3lSujc+CM + nscZIL4HfRP4q+bTlyjdxZUZ9/lm6Danw/NiKF3iDEtXv2pN47+fSbbEmeY88HrXgZs7X8P2I521 + uTk9zCOvvvYPdKtQMQ8M5O/2oHyGUuFfdPEZxHZKyb7HoxMYgTtT3rVZiD3qm1r5zB1n9kQvTvKd + 2f096pvglcnrYsMT5R71TfDXRFXd9hjiYTpVddujvgmeS6UUGXvUN8FzqU16rT6zR31TSc/vrg83 + Ubk52zcqzvB0OWt/41fd0rkJiTPULbh71DfBtlPdrD3qm+B1b9Jr88B71Dfdti8Vn1miXnvC9rWW + A+fvHWR0x92Cu0d9E5hhZwNZMF3lwAM6bzt+bpqh42dtp+bfzw7olurA9tmj3KO+6bk3BZ9Jd73K + 3sT6zKJ9Zq34TEZnv9WFqANbbg57j/qm0nYoRmJ02ZuQkw2lzdqjvgmsdtp2Z6LhM77eO8jjjPlJ + WhVq5mqP+iZ43Xm6+Ax7ohzOA+9R3wTTDU1negcvmi5x5le2/7HVc5Orz0LccWa57oXYn91bxHZH + 9Q54+myPEqM7gr7QdKavTU0w7qJvOgQ86Ew0v9U/lbtEdtE3vTRd+4zcrMnOMu+ibyroTdsNTfco + vbg7B6M7gs7ufHdf+zt0Q9Cb+2pt5uo68FVnIfI3v041yT6gN2w3ut80a3uTDveb8puo1J89uuo3 + DWwvp4233lRUGCDn6OTKwD1KdXvZ02cq9Zmob3r0KHOf2eW9gxc3Xb9HfRMWI6focD6jbo1D6YzP + 8HS4r20PNkYGfRO8MqZFr9dnzKF9Rvam8IZp2pvCC0sdesP2I8WZdWg7vzKHjjPdd7OOOENuskjQ + eQF7j/om0GcOdvcI+qZ7ZQb0nbZd5cCztte0KnvUN5W26zdMt7e9fm5l9tRvQlaGp4vPfIfuvkpX + PjP2d5IuvQPE9ua3Wu83ma3nM2lvOv/lGds3ymcozfNFJ30maVXWcd/DbITP8BF4o/IZnq58puuR + HXq9rx30TUOfkRyY3bXXms/od28zunv8qh3V2h71TaBH8tnSSvkMmaWauw78hdOBWfH6zODcVPOZ + uw6scuAj85ksn2HjzILP6U3RVT4zWHc2ii2pdzDOxWbo1uD+zvrMQuxNPZ+p1meivukRCYocOLx8 + wtvuib0pv5cZpTNxhqe7r9IZn+HpjM806X9srUcZ9U0Nnwk58Dn0YOYisEuzEIjtZO8g6pvQ+M7b + 7gi6v/bVV7av9k827gee0yv2VaATF/VNKL3ZAf1Tubt+F31TsTLaZ66LN1K25LK3km/1VMN2W5/T + u4djMrrOgZGVsURN71AxEqMzZ21Khb+Lvgm1nafj+czRVsf+qbyrsou+6VHTe2U+c8nsAt0WPtNV + VO+ib8K+1UPl78jKGCLO7GzXPOqbsPh+RRWXvTd8333ZpOPnpuvLdBuqZN9F34TVUjvvr2Z14P8/ + 8ICA2HxpCQA= + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['59174'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 15:29:41 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 15:27:41 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +version: 1 diff --git a/siphon/tests/test_ndbc.py b/siphon/tests/test_ndbc.py index d2e4835d3..e0a0e5139 100644 --- a/siphon/tests/test_ndbc.py +++ b/siphon/tests/test_ndbc.py @@ -7,7 +7,6 @@ import numpy as np from numpy.testing import assert_almost_equal, assert_equal -import pytest from siphon.simplewebservice.ndbc import NDBC from siphon.testing import get_recorder @@ -16,24 +15,217 @@ recorder = get_recorder(__file__) -@recorder.use_cassette('ndbc_latest') -def test_ndbc_latest(): - """Test that we are properly parsing latest NDBC observations.""" - #truth = ['41004', 32.501, -79.09899999999999, 190.0, 6.0, 7.0, 1.2, - # 5.0, 4.8, 186.0, 1016.5, np.nan, 28.0, 28.7, 25.9, - # np.nan, np.nan, Timestamp('2018-07-30 20:50:00')] - #'station', 'latitude', 'longitude', 'wind_direction', 'wind_speed', - #'wind_gust', 'wave_height', 'dominant_wave_period', - #'average_wave_period', 'dominant_wave_direction', 'pressure', - #'air_temperature', 'water_temperature', 'dewpoint', 'visibility', - #'3hr_pressure_tendency', 'water_level_above_mean', 'time' +@recorder.use_cassette('ndbc_realtime_txt') +def test_ndbc_realtime_txt(): + """Test that we are properly parsing realtime txt (met) observations.""" + df = NDBC.realtime_observations('41002') + + assert_almost_equal(df['wind_direction'][3], 150.0, 1) + assert_almost_equal(df['wind_speed'][3], 7.0, 1) + assert_almost_equal(df['wind_gust'][3], 8.0, 1) + assert_almost_equal(df['wave_height'][3], 1.2, 1) + assert_equal(df['dominant_wave_period'][3], np.nan) + assert_almost_equal(df['average_wave_period'][3], 4.5, 1) + assert_almost_equal(df['dominant_wave_direction'][3], 209.0, 1) + assert_almost_equal(df['pressure'][3], 1022.9, 1) + assert_equal(df['air_temperature'][3], np.nan) + assert_almost_equal(df['water_temperature'][3], 28.0, 1) + assert_equal(df['dewpoint'][3], np.nan) + assert_equal(df['visibility'][3], np.nan) + assert_equal(df['3hr_pressure_tendency'][3], np.nan) + assert_equal(df['water_level_above_mean'][3], np.nan) + assert_equal(df['time'][3], datetime(2018, 8, 1, 14, 40)) + + assert(df.units['wind_direction'] == 'degrees') + assert(df.units['wind_speed'] == 'meters/second') + assert(df.units['wind_gust'] == 'meters/second') + assert(df.units['wave_height'] == 'meters') + assert(df.units['dominant_wave_period'] == 'seconds') + assert(df.units['average_wave_period'] == 'seconds') + assert(df.units['dominant_wave_direction'] == 'degrees') + assert(df.units['pressure'] == 'hPa') + assert(df.units['air_temperature'] == 'degC') + assert(df.units['water_temperature'] == 'degC') + assert(df.units['dewpoint'] == 'degC') + assert(df.units['visibility'] == 'nautical_mile') + assert(df.units['3hr_pressure_tendency'] == 'hPa') + assert(df.units['water_level_above_mean'] == 'feet') + assert(df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_drift') +def test_ndbc_realtime_drift(): + """Test that we are properly parsing realtime drift observations.""" + df = NDBC.realtime_observations('22101', type='drift') + + assert_almost_equal(df['latitude'][3], 37.24, 2) + assert_almost_equal(df['longitude'][3], 126.02, 2) + assert_almost_equal(df['wind_direction'][3], 280.0, 1) + assert_almost_equal(df['wind_speed'][3], 3.0, 1) + assert_equal(df['wind_gust'][3], np.nan) + assert_almost_equal(df['pressure'][3], 1003.4, 1) + assert_equal(df['3hr_pressure_tendency'][3], np.nan) + assert_almost_equal(df['air_temperature'][3], 25.3, 1) + assert_almost_equal(df['water_temperature'][3], 22.8, 1) + assert_equal(df['time'][3], datetime(2018, 8, 1, 8, 0)) + + assert(df.units['latitude'] == 'degrees') + assert(df.units['longitude'] == 'degrees') + assert(df.units['wind_direction'] == 'degrees') + assert(df.units['wind_speed'] == 'meters/second') + assert(df.units['wind_gust'] == 'meters/second') + assert(df.units['pressure'] == 'hPa') + assert(df.units['air_temperature'] == 'degC') + assert(df.units['water_temperature'] == 'degC') + assert(df.units['3hr_pressure_tendency'] == 'hPa') + assert(df.units['time'] is None) + +@recorder.use_cassette('ndbc_realtime_cwind') +def test_ndbc_realtime_cwind(): + """Test that we are properly parsing realtime cwind observations.""" + df = NDBC.realtime_observations('41008', type='cwind') + assert_almost_equal(df['wind_direction'][3], 156, 1) + assert_almost_equal(df['wind_speed'][3], 6.7, 1) + assert_equal(df['gust_direction'][3], np.nan) + assert_almost_equal(df['wind_gust'][0], 9.0, 1) + assert_equal(df['gust_time'][0], datetime(2018, 8, 1, 14, 49, 0)) + assert_equal(df['time'][0], datetime(2018, 8, 1, 14, 50, 0)) - # - #['41004' 32.501 -79.09899999999999 200.0 5.0 7.0 nan nan nan nan 1016.9 - # nan 28.1 28.8 25.9 nan nan Timestamp('2018-07-30 21:10:00')] + assert(df.units['wind_direction'] == 'degrees') + assert(df.units['wind_speed'] == 'meters/second') + assert(df.units['gust_direction'] == 'degrees') + assert(df.units['wind_gust'] == 'meters/second') + assert(df.units['gust_time'] is None) + assert(df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_spec') +def test_ndbc_realtime_spec(): + """Test that we are properly parsing realtime spec observations.""" + df = NDBC.realtime_observations('41002', type='spec') + + assert_almost_equal(df['significant_wave_height'][3], 1.2, 1) + assert_almost_equal(df['swell_height'][3], 0.7, 1) + assert_almost_equal(df['swell_period'][3], 6.7, 1) + assert_almost_equal(df['wind_wave_height'][3], 1.0, 1) + assert_almost_equal(df['wind_wave_period'][3], 3.7, 1) + assert(df['swell_direction'][3] == 'SSE') + assert(df['wind_wave_direction'][3] == 'SSE') + assert(df['steepness'][3] == 'STEEP') + assert_almost_equal(df['average_wave_period'][3], 4.5, 1) + assert_almost_equal(df['dominant_wave_direction'][3], 150, 1) + assert_equal(df['time'][3], datetime(2018, 8, 1, 11, 40, 0)) + + assert(df.units['significant_wave_height'] == 'meters') + assert(df.units['swell_height'] == 'meters') + assert(df.units['swell_period'] == 'seconds') + assert(df.units['wind_wave_height'] == 'meters') + assert(df.units['wind_wave_period'] == 'seconds') + assert(df.units['swell_direction'] is None) + assert(df.units['wind_wave_direction'] is None) + assert(df.units['steepness'] is None) + assert(df.units['average_wave_period'] == 'seconds') + assert(df.units['dominant_wave_direction'] == 'degrees') + assert(df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_ocean') +def test_ndbc_realtime_ocean(): + """Test that we are properly parsing realtime ocean observations.""" + df = NDBC.realtime_observations('45183', type='ocean') + + assert_almost_equal(df['measurement_depth'][3], 1.0, 1) + assert_equal(df['ocean_temperature'][3], np.nan) + assert_equal(df['conductivity'][3], np.nan) + assert_equal(df['salinity'][3], np.nan) + assert_almost_equal(df['oxygen_concentration'][3], 106.4, 1) + assert_almost_equal(df['oxygen_concentration_ppm'][3], 9.52, 1) + assert_equal(df['chlorophyll_concentration'][3], np.nan) + assert_almost_equal(df['turbidity'][3], 0, 1) + assert_almost_equal(df['pH'][3], 8.38, 1) + assert_equal(df['Eh'][3], np.nan) + assert_equal(df['time'][3], datetime(2018, 8, 1, 13, 30, 0)) + + assert (df.units['measurement_depth'] == 'meters') + assert (df.units['ocean_temperature'] == 'degC') + assert (df.units['conductivity'] == 'milliSiemens/centimeter') + assert (df.units['salinity'] == 'psu') + assert (df.units['oxygen_concentration'] == 'percent') + assert (df.units['oxygen_concentration_ppm'] == 'ppm') + assert (df.units['chlorophyll_concentration'] == 'micrograms/liter') + assert (df.units['turbidity'] == 'ftu') + assert (df.units['pH'] == 'dimensionless') + assert (df.units['Eh'] == 'millivolts') + assert (df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_srad') +def test_ndbc_realtime_srad(): + """Test that we are properly parsing realtime srad observations.""" + df = NDBC.realtime_observations('45027', type='srad') + + assert_almost_equal(df['shortwave_radiation_licor'][3], 51.6, 1) + assert_equal(df['shortwave_radiation_eppley'][3], np.nan) + assert_equal(df['longwave_radiation'][3], np.nan) + assert_equal(df['time'][3], datetime(2018, 8, 1, 14, 30)) + assert (df.units['shortwave_radiation_licor'] == 'watts/meter^2') + assert (df.units['shortwave_radiation_eppley'] == 'watts/meter^2') + assert (df.units['longwave_radiation'] == 'watts/meter^2') + assert (df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_dart') +def test_ndbc_realtime_dart(): + """Test that we are properly parsing realtime dart observations.""" + df = NDBC.realtime_observations('41421', type='dart') + + assert_almost_equal(df['measurement_type'][3], 15, 1) + assert_almost_equal(df['height'][3], 5806.845, 3) + assert_equal(df['time'][3], datetime(2018, 8, 1, 11, 15)) + + assert (df.units['measurement_type'] == 'minutes') + assert (df.units['height'] == 'meters') + assert (df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_supl') +def test_ndbc_realtime_supl(): + """Test that we are properly parsing realtime supl observations.""" + df = NDBC.realtime_observations('PVGF1', type='supl') + + assert_almost_equal(df['hourly_low_pressure'][3], 1019.0, 1) + assert_equal(df['hourly_low_pressure_time'][3], datetime(2018, 7, 31, 14, 36)) + assert_almost_equal(df['hourly_high_wind'][3], 6, 1) + assert_equal(df['hourly_high_wind_direction'][3], np.nan) + assert_equal(df['hourly_high_wind_time'][3], datetime(2018, 7, 31, 14, 36)) + assert_equal(df['time'][3], datetime(2018, 7, 31, 14, 42)) + + assert (df.units['hourly_low_pressure'] == 'hPa') + assert (df.units['hourly_low_pressure_time'] is None) + assert (df.units['hourly_high_wind'] == 'meters/second') + assert (df.units['hourly_high_wind_direction'] == 'degrees') + assert (df.units['hourly_high_wind_time'] is None) + assert (df.units['time'] is None) + + +@recorder.use_cassette('ndbc_realtime_rain') +def test_ndbc_realtime_rain(): + """Test that we are properly parsing realtime rain observations.""" + df = NDBC.realtime_observations('BDVF1', type='rain') + + assert_almost_equal(df['hourly_accumulation'][3], 0.0, 1) + assert_equal(df['time'][3], datetime(2018, 8, 1, 11)) + + assert (df.units['hourly_accumulation'] == 'millimeters') + assert (df.units['time'] is None) + + +@recorder.use_cassette('ndbc_latest') +def test_ndbc_latest(): + """Test that we are properly parsing latest NDBC observations.""" df = NDBC.latest_observations() assert(df['station'][10] == '41004') From 0823384dbc717ed792b54ab8f360d031b9643514 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Wed, 1 Aug 2018 10:37:29 -0600 Subject: [PATCH 04/10] Add test for checking what buoy data are available. --- siphon/tests/fixtures/ndbc_buoy_data_types | 389 +++++++++++++++++++++ siphon/tests/test_ndbc.py | 15 + 2 files changed, 404 insertions(+) create mode 100644 siphon/tests/fixtures/ndbc_buoy_data_types diff --git a/siphon/tests/fixtures/ndbc_buoy_data_types b/siphon/tests/fixtures/ndbc_buoy_data_types new file mode 100644 index 000000000..a25ab2bc4 --- /dev/null +++ b/siphon/tests/fixtures/ndbc_buoy_data_types @@ -0,0 +1,389 @@ +interactions: +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.txt + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['59218'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:52 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:27:46 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.drift + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:52 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.cwind + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:53 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.spec + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['13600'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:53 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:06 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.data_spec + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:54 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:08 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.swdir + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:54 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:10 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.swdir2 + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:55 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:11 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.swr1 + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:55 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:13 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.swr2 + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:56 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:06:15 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.adcp + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:57 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.ocean + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:57 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.tide + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:58 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.srad + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:58 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.dart + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:59 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.supl + response: + body: {string: ''} + headers: + Accept-Ranges: [bytes] + Cache-Control: [must-revalidate] + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['36974'] + Content-Security-Policy: [frame-ancestors 'self'] + Content-Type: [text/plain; charset=ISO-8859-1] + Date: ['Wed, 01 Aug 2018 16:36:59 GMT'] + Last-Modified: ['Wed, 01 Aug 2018 16:27:25 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + X-Content-Type-Options: [nosniff] + X-Frame-Options: [SAMEORIGIN] + X-XSS-Protection: [1; mode=block] + status: {code: 200, message: OK} +- request: + body: null + headers: + Accept: ['*/*'] + Accept-Encoding: ['gzip, deflate'] + Connection: [keep-alive] + User-Agent: [python-requests/2.19.1] + method: HEAD + uri: https://www.ndbc.noaa.gov/data/realtime2/41002.rain + response: + body: {string: ''} + headers: + Connection: [close] + Content-Encoding: [gzip] + Content-Length: ['20'] + Content-Type: [text/html; charset=iso-8859-1] + Date: ['Wed, 01 Aug 2018 16:37:00 GMT'] + Server: [Apache] + Strict-Transport-Security: [max-age=31536000;] + Vary: [Accept-Encoding] + status: {code: 404, message: Not Found} +version: 1 diff --git a/siphon/tests/test_ndbc.py b/siphon/tests/test_ndbc.py index e0a0e5139..332d3cf60 100644 --- a/siphon/tests/test_ndbc.py +++ b/siphon/tests/test_ndbc.py @@ -266,3 +266,18 @@ def test_ndbc_latest(): assert(df.units['3hr_pressure_tendency'] == 'hPa') assert(df.units['water_level_above_mean'] == 'feet') assert(df.units['time'] is None) + + +@recorder.use_cassette('ndbc_buoy_data_types') +def test_ndbc_buoy_data_types(): + """Test determination of available buoy data.""" + resp = NDBC.buoy_data_types('41002') + truth = {'txt': 'standard meteorological data', + 'spec': 'spectral wave summaries', + 'data_spec': 'raw spectral wave data', + 'swdir': 'spectral wave data (alpha1)', + 'swdir2': 'spectral wave data (alpha2)', + 'swr1': 'spectral wave data (r1)', + 'swr2': 'spectral wave data (r2)', + 'supl': 'supplemental measurements data'} + assert(resp == truth) From 35c2fc6fc7841e21b535541294bb166b15cc2ac0 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Wed, 1 Aug 2018 13:15:11 -0600 Subject: [PATCH 05/10] [MNT] Update link to NEP 14 --- docs/installguide.rst | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs/installguide.rst b/docs/installguide.rst index 6d84f7387..0f9689512 100644 --- a/docs/installguide.rst +++ b/docs/installguide.rst @@ -14,7 +14,7 @@ This includes: * Core Python developers will `stop support for Python 2.7 January 1, 2020 `_ * NumPy feature releases will be - `Python 3 only starting January 1, 2019 `_, + `Python 3 only starting January 1, 2019 `_, and support for the last release supporting Python 2 will end January 1, 2020. * XArray will drop `2.7 January 1, 2019 as well `_ From f154dee31559dde9e8c68cd566cd643f92cb1863 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Thu, 2 Aug 2018 07:19:41 -0600 Subject: [PATCH 06/10] Rename type to data_type --- siphon/simplewebservice/ndbc.py | 24 +++++++----------------- siphon/tests/test_ndbc.py | 16 ++++++++-------- 2 files changed, 15 insertions(+), 25 deletions(-) diff --git a/siphon/simplewebservice/ndbc.py b/siphon/simplewebservice/ndbc.py index dadf5e6d9..e81b223f0 100644 --- a/siphon/simplewebservice/ndbc.py +++ b/siphon/simplewebservice/ndbc.py @@ -23,24 +23,14 @@ def __init__(self): super(NDBC, self).__init__('https://www.ndbc.noaa.gov/') @classmethod - def station_observations(cls): - """Retrieve the most recent 45 days of data for a buoy from NDBC. - - Returns - ------- - :class:`pandas.DataFrame` containing the data - - """ - - @classmethod - def realtime_observations(cls, buoy, type='txt'): # noqa: A002 + def realtime_observations(cls, buoy, data_type='txt'): """Retrieve the realtime buoy data from NDBC. Parameters ---------- buoy : str Name of buoy - type : str + data_type : str Type of data requested, must be one of: 'txt': standard meteorological data 'drift': meteorological data from drifting buoys and limited moored buoy data @@ -69,8 +59,8 @@ def realtime_observations(cls, buoy, type='txt'): # noqa: A002 'supl': endpoint._parse_supl, 'rain': endpoint._parse_rain} endpoint = cls() - raw_data = endpoint.raw_buoy_data(buoy, type=type) - return parsers[type](raw_data) + raw_data = endpoint.raw_buoy_data(buoy, data_type=data_type) + return parsers[data_type](raw_data) @staticmethod def _parse_met(content): @@ -523,14 +513,14 @@ def buoy_data_types(cls, buoy): return available_data @classmethod - def raw_buoy_data(cls, buoy, type='txt'): # noqa: A002 + def raw_buoy_data(cls, buoy, data_type='txt'): """Retrieve the raw buoy data contents from NDBC. Parameters ---------- buoy : str Name of buoy - type : str + data_type : str Type of data requested, must be one of: 'txt': standard meteorological data 'drift': meteorological data from drifting buoys and limited moored buoy data @@ -556,5 +546,5 @@ def raw_buoy_data(cls, buoy, type='txt'): # noqa: A002 """ endpoint = cls() - resp = endpoint.get_path('data/realtime2/{}.{}'.format(buoy, type)) + resp = endpoint.get_path('data/realtime2/{}.{}'.format(buoy, data_type)) return resp.text diff --git a/siphon/tests/test_ndbc.py b/siphon/tests/test_ndbc.py index 332d3cf60..fb3f5b5ff 100644 --- a/siphon/tests/test_ndbc.py +++ b/siphon/tests/test_ndbc.py @@ -56,7 +56,7 @@ def test_ndbc_realtime_txt(): @recorder.use_cassette('ndbc_realtime_drift') def test_ndbc_realtime_drift(): """Test that we are properly parsing realtime drift observations.""" - df = NDBC.realtime_observations('22101', type='drift') + df = NDBC.realtime_observations('22101', data_type='drift') assert_almost_equal(df['latitude'][3], 37.24, 2) assert_almost_equal(df['longitude'][3], 126.02, 2) @@ -84,7 +84,7 @@ def test_ndbc_realtime_drift(): @recorder.use_cassette('ndbc_realtime_cwind') def test_ndbc_realtime_cwind(): """Test that we are properly parsing realtime cwind observations.""" - df = NDBC.realtime_observations('41008', type='cwind') + df = NDBC.realtime_observations('41008', data_type='cwind') assert_almost_equal(df['wind_direction'][3], 156, 1) assert_almost_equal(df['wind_speed'][3], 6.7, 1) @@ -104,7 +104,7 @@ def test_ndbc_realtime_cwind(): @recorder.use_cassette('ndbc_realtime_spec') def test_ndbc_realtime_spec(): """Test that we are properly parsing realtime spec observations.""" - df = NDBC.realtime_observations('41002', type='spec') + df = NDBC.realtime_observations('41002', data_type='spec') assert_almost_equal(df['significant_wave_height'][3], 1.2, 1) assert_almost_equal(df['swell_height'][3], 0.7, 1) @@ -134,7 +134,7 @@ def test_ndbc_realtime_spec(): @recorder.use_cassette('ndbc_realtime_ocean') def test_ndbc_realtime_ocean(): """Test that we are properly parsing realtime ocean observations.""" - df = NDBC.realtime_observations('45183', type='ocean') + df = NDBC.realtime_observations('45183', data_type='ocean') assert_almost_equal(df['measurement_depth'][3], 1.0, 1) assert_equal(df['ocean_temperature'][3], np.nan) @@ -164,7 +164,7 @@ def test_ndbc_realtime_ocean(): @recorder.use_cassette('ndbc_realtime_srad') def test_ndbc_realtime_srad(): """Test that we are properly parsing realtime srad observations.""" - df = NDBC.realtime_observations('45027', type='srad') + df = NDBC.realtime_observations('45027', data_type='srad') assert_almost_equal(df['shortwave_radiation_licor'][3], 51.6, 1) assert_equal(df['shortwave_radiation_eppley'][3], np.nan) @@ -180,7 +180,7 @@ def test_ndbc_realtime_srad(): @recorder.use_cassette('ndbc_realtime_dart') def test_ndbc_realtime_dart(): """Test that we are properly parsing realtime dart observations.""" - df = NDBC.realtime_observations('41421', type='dart') + df = NDBC.realtime_observations('41421', data_type='dart') assert_almost_equal(df['measurement_type'][3], 15, 1) assert_almost_equal(df['height'][3], 5806.845, 3) @@ -194,7 +194,7 @@ def test_ndbc_realtime_dart(): @recorder.use_cassette('ndbc_realtime_supl') def test_ndbc_realtime_supl(): """Test that we are properly parsing realtime supl observations.""" - df = NDBC.realtime_observations('PVGF1', type='supl') + df = NDBC.realtime_observations('PVGF1', data_type='supl') assert_almost_equal(df['hourly_low_pressure'][3], 1019.0, 1) assert_equal(df['hourly_low_pressure_time'][3], datetime(2018, 7, 31, 14, 36)) @@ -214,7 +214,7 @@ def test_ndbc_realtime_supl(): @recorder.use_cassette('ndbc_realtime_rain') def test_ndbc_realtime_rain(): """Test that we are properly parsing realtime rain observations.""" - df = NDBC.realtime_observations('BDVF1', type='rain') + df = NDBC.realtime_observations('BDVF1', data_type='rain') assert_almost_equal(df['hourly_accumulation'][3], 0.0, 1) assert_equal(df['time'][3], datetime(2018, 8, 1, 11)) From 8e25cf804bff1e01383d41246a5c80e6e6449816 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Thu, 2 Aug 2018 15:47:38 -0600 Subject: [PATCH 07/10] Change from pandas read_fwf to read_table --- siphon/simplewebservice/ndbc.py | 105 ++++++++++++++++---------------- 1 file changed, 54 insertions(+), 51 deletions(-) diff --git a/siphon/simplewebservice/ndbc.py b/siphon/simplewebservice/ndbc.py index e81b223f0..5123180e5 100644 --- a/siphon/simplewebservice/ndbc.py +++ b/siphon/simplewebservice/ndbc.py @@ -31,20 +31,20 @@ def realtime_observations(cls, buoy, data_type='txt'): buoy : str Name of buoy data_type : str - Type of data requested, must be one of: - 'txt': standard meteorological data - 'drift': meteorological data from drifting buoys and limited moored buoy data - mainly from international partners - 'cwind': continuous winds data (10 minute average) - 'spec': spectral wave summaries - 'ocean': oceanographic data - 'srad': solar radiation data - 'dart': water column height - 'supl': supplemental measurements data - 'rain': hourly rain data - - Returns - ------- + Type of data requested, must be one of + 'txt' standard meteorological data + 'drift' meteorological data from drifting buoys and limited moored buoy data + mainly from international partners + 'cwind' continuous winds data (10 minute average) + 'spec' spectral wave summaries + 'ocean' oceanographic data + 'srad' solar radiation data + 'dart' water column height + 'supl' supplemental measurements data + 'rain' hourly rain data + + Returns + ------- Raw data string """ @@ -76,6 +76,7 @@ def _parse_met(content): :class:`pandas.DataFrame` containing the data """ + widths = [4, 2, 2, 2, 2, 3, 4, 4, 5, 5, 5, 3, 6, 5, 5, 5, 4, 4, 5] col_names = ['year', 'month', 'day', 'hour', 'minute', 'wind_direction', 'wind_speed', 'wind_gust', 'wave_height', 'dominant_wave_period', 'average_wave_period', @@ -99,7 +100,8 @@ def _parse_met(content): 'water_level_above_mean': 'feet', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units @@ -136,8 +138,8 @@ def _parse_drift(content): '3hr_pressure_tendency': 'hPa', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['hour'] = np.floor(df['hour_minute'] / 100) df['minute'] = df['hour_minute'] - df['hour'] * 100 df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) @@ -170,8 +172,8 @@ def _parse_cwind(content): 'gust_time': None, 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['gust_direction'] = df['gust_direction'].replace(999, np.nan) df['wind_gust'] = df['wind_gust'].replace(99.0, np.nan) df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) @@ -218,8 +220,8 @@ def _parse_spec(content): 'dominant_wave_direction': 'degrees', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values=['MM', 'N/A'], names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units @@ -257,8 +259,8 @@ def _parse_ocean(content): 'Eh': 'millivolts', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units @@ -287,8 +289,8 @@ def _parse_srad(content): 'longwave_radiation': 'watts/meter^2', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units @@ -315,8 +317,8 @@ def _parse_dart(content): 'height': 'meters', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') # Replace measurement type integer with minute value # 1 = 15-minute measurement @@ -352,8 +354,8 @@ def _parse_rain(content): col_units = {'hourly_accumulation': 'millimeters', 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) @@ -386,8 +388,8 @@ def _parse_supl(content): 'hourly_high_wind_time': None, 'time': None} - df = pd.read_fwf(StringIO(content), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(content), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) @@ -446,8 +448,8 @@ def latest_observations(cls): 'time': None} resp = endpoint.get_path('data/latest_obs/latest_obs.txt') - df = pd.read_fwf(StringIO(resp.text), skiprows=2, - na_values='MM', names=col_names) + df = pd.read_table(StringIO(resp.text), comment='#', na_values='MM', + names=col_names, sep='\s+') df['time'] = pd.to_datetime(df[['year', 'month', 'day', 'hour', 'minute']], utc=True) df = df.drop(columns=['year', 'month', 'day', 'hour', 'minute']) df.units = col_units @@ -520,25 +522,26 @@ def raw_buoy_data(cls, buoy, data_type='txt'): ---------- buoy : str Name of buoy + data_type : str - Type of data requested, must be one of: - 'txt': standard meteorological data - 'drift': meteorological data from drifting buoys and limited moored buoy data - mainly from international partners - 'cwind': continuous winds data (10 minute average) - 'spec': spectral wave summaries - 'data_spec': raw spectral wave data - 'swdir': spectral wave data (alpha1) - 'swdir2': spectral wave data (alpha2) - 'swr1': spectral wave data (r1) - 'swr2': spectral wave data (r2) - 'adcp': acoustic doppler current profiler - 'ocean': oceanographic data - 'tide': tide data - 'srad': solar radiation data - 'dart': water column height - 'supl': supplemental measurements data - 'rain': hourly rain data + Type of data requested, must be one of + 'txt' standard meteorological data + 'drift' meteorological data from drifting buoys and limited moored buoy data + mainly from international partners + 'cwind' continuous winds data (10 minute average) + 'spec' spectral wave summaries + 'data_spec' raw spectral wave data + 'swdir' spectral wave data (alpha1) + 'swdir2' spectral wave data (alpha2) + 'swr1' spectral wave data (r1) + 'swr2' spectral wave data (r2) + 'adcp' acoustic doppler current profiler + 'ocean' oceanographic data + 'tide' tide data + 'srad' solar radiation data + 'dart' water column height + 'supl' supplemental measurements data + 'rain' hourly rain data Returns ------- From 71e2691181137d2563fb9d472bd17229fe59e85c Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Thu, 2 Aug 2018 15:47:50 -0600 Subject: [PATCH 08/10] Add ndbc to docs --- docs/api/simplewebservice.rst | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/docs/api/simplewebservice.rst b/docs/api/simplewebservice.rst index 727a7a083..e4196272a 100644 --- a/docs/api/simplewebservice.rst +++ b/docs/api/simplewebservice.rst @@ -20,16 +20,23 @@ :members: :special-members: __init__ -====================================== +==================================== :mod:`siphon.simplewebservice.igra2` -====================================== +==================================== .. automodule:: siphon.simplewebservice.igra2 :members: :special-members: __init__ -====================================== +=================================== :mod:`siphon.simplewebservice.acis` -====================================== +=================================== .. automodule:: siphon.simplewebservice.acis + :members: + :special-members: __init__ + +=================================== +:mod:`siphon.simplewebservice.ndbc` +=================================== +.. automodule:: siphon.simplewebservice.ndbc :members: :special-members: __init__ \ No newline at end of file From 266e7245b2ad81f839b37476802febfc75e859b2 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Thu, 2 Aug 2018 15:48:03 -0600 Subject: [PATCH 09/10] Add NDBC examples --- examples/ndbc/README.txt | 7 +++++ examples/ndbc/buoy_met_request.py | 42 ++++++++++++++++++++++++++++++ examples/ndbc/buoy_type_request.py | 23 ++++++++++++++++ examples/ndbc/latest_request.py | 42 ++++++++++++++++++++++++++++++ 4 files changed, 114 insertions(+) create mode 100644 examples/ndbc/README.txt create mode 100644 examples/ndbc/buoy_met_request.py create mode 100644 examples/ndbc/buoy_type_request.py create mode 100644 examples/ndbc/latest_request.py diff --git a/examples/ndbc/README.txt b/examples/ndbc/README.txt new file mode 100644 index 000000000..fdbab29d6 --- /dev/null +++ b/examples/ndbc/README.txt @@ -0,0 +1,7 @@ +.. _ndbc_examples: + +National Data Buoy Center (NDBC) +-------------------------------- + +Examples of requesting data from the National Data Buoy Center latest and realtime +data sources. \ No newline at end of file diff --git a/examples/ndbc/buoy_met_request.py b/examples/ndbc/buoy_met_request.py new file mode 100644 index 000000000..1264ee21e --- /dev/null +++ b/examples/ndbc/buoy_met_request.py @@ -0,0 +1,42 @@ +# Copyright (c) 2018 Siphon Contributors. +# Distributed under the terms of the BSD 3-Clause License. +# SPDX-License-Identifier: BSD-3-Clause +""" +NDBC Buoy Meteorological Data Request +===================================== + +The NDBC keeps a 45-day recent rolling file for each buoy. This examples shows how to access +the basic meteorological data from a buoy and make a simple plot. +""" + +import matplotlib.pyplot as plt + +from siphon.simplewebservice.ndbc import NDBC + +#################################################### +# Get a pandas data frame of all of the observations, meteorological data is the default +# observation set to query. +df = NDBC.realtime_observations('41002') +df.head() + +#################################################### +# Let's make a simple time series plot to checkout what the data look like. +fig, (ax1, ax2, ax3) = plt.subplots(3, 1, figsize=(12, 10)) +ax2b = ax2.twinx() + +# Pressure +ax1.plot(df['time'], df['pressure'], color='black') +ax1.set_ylabel('Pressure [hPa]') + +# Wind speed, gust, direction +ax2.plot(df['time'], df['wind_speed'], color='tab:orange') +ax2.plot(df['time'], df['wind_gust'], color='tab:olive', linestyle='--') +ax2b.plot(df['time'], df['wind_direction'], color='tab:blue', linestyle='-') +ax2.set_ylabel('Wind Speed [m/s]') +ax2b.set_ylabel('Wind Direction') + +# Water temperature +ax3.plot(df['time'], df['water_temperature'], color='tab:brown') +ax3.set_ylabel('Water Temperature [degC]') + +plt.show() diff --git a/examples/ndbc/buoy_type_request.py b/examples/ndbc/buoy_type_request.py new file mode 100644 index 000000000..905cc5e15 --- /dev/null +++ b/examples/ndbc/buoy_type_request.py @@ -0,0 +1,23 @@ +# Copyright (c) 2018 Siphon Contributors. +# Distributed under the terms of the BSD 3-Clause License. +# SPDX-License-Identifier: BSD-3-Clause +""" +NDBC Buoy Data Request (of any type) +==================================== + +The NDBC keeps a 40-day recent rolling file for each buoy. This examples shows how to access +the other types of data available for a buoy. +""" + +from siphon.simplewebservice.ndbc import NDBC + +#################################################### +# Request the types of data available from a given buoy. +data_aval = NDBC.buoy_data_types('41002') +print(data_aval) + +#################################################### +# Get a pandas data frame of all of the observations, meteorological data is the default +# observation set to query. +df = NDBC.realtime_observations('41002', data_type='supl') +df.head() diff --git a/examples/ndbc/latest_request.py b/examples/ndbc/latest_request.py new file mode 100644 index 000000000..d56f5c89b --- /dev/null +++ b/examples/ndbc/latest_request.py @@ -0,0 +1,42 @@ +# Copyright (c) 2018 Siphon Contributors. +# Distributed under the terms of the BSD 3-Clause License. +# SPDX-License-Identifier: BSD-3-Clause +""" +NDBC Latest Data Request +======================== + +This example shows how to use siphon's `simplewebswervice` support query the most recent +observations from all of the NDBC buoys at once. +""" + +import cartopy.crs as ccrs +import cartopy.feature as cfeature +import matplotlib.pyplot as plt + +from siphon.simplewebservice.ndbc import NDBC + +#################################################### +# Get a pandas data frame of all of the observations +df = NDBC.latest_observations() +df.head() + +#################################################### +# In this case I'm going to drop buoys that do not have water temperature measurements. +df.dropna(subset=['water_temperature'], inplace=True) + +#################################################### +# Let's make a simple plot of the buoy positions and color by water temperature +proj = ccrs.LambertConformal(central_latitude=45., central_longitude=-100., + standard_parallels=[30, 60]) + +fig = plt.figure(figsize=(17., 11.)) +ax = plt.axes(projection=proj) +ax.coastlines('50m', edgecolor='black') +ax.add_feature(cfeature.OCEAN.with_scale('50m')) +ax.add_feature(cfeature.LAND.with_scale('50m')) +ax.set_extent([-85, -75, 25, 30], ccrs.PlateCarree()) + +ax.scatter(df['longitude'], df['latitude'], c=df['water_temperature'], + transform=ccrs.PlateCarree()) + +plt.show() From a5dcdb40183ece570feb1c8028bb425394349aa4 Mon Sep 17 00:00:00 2001 From: "J.R. Leeman" Date: Thu, 2 Aug 2018 15:56:23 -0600 Subject: [PATCH 10/10] Add datatype checking on realtime and test --- siphon/simplewebservice/ndbc.py | 7 +++++-- siphon/tests/test_ndbc.py | 7 +++++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/siphon/simplewebservice/ndbc.py b/siphon/simplewebservice/ndbc.py index 5123180e5..df043724e 100644 --- a/siphon/simplewebservice/ndbc.py +++ b/siphon/simplewebservice/ndbc.py @@ -58,7 +58,11 @@ def realtime_observations(cls, buoy, data_type='txt'): 'dart': endpoint._parse_dart, 'supl': endpoint._parse_supl, 'rain': endpoint._parse_rain} - endpoint = cls() + + if data_type not in parsers: + raise KeyError('Data type must be txt, drift, cwind, spec, ocean, srad, dart,' + 'supl, or rain for parsed realtime data.') + raw_data = endpoint.raw_buoy_data(buoy, data_type=data_type) return parsers[data_type](raw_data) @@ -76,7 +80,6 @@ def _parse_met(content): :class:`pandas.DataFrame` containing the data """ - widths = [4, 2, 2, 2, 2, 3, 4, 4, 5, 5, 5, 3, 6, 5, 5, 5, 4, 4, 5] col_names = ['year', 'month', 'day', 'hour', 'minute', 'wind_direction', 'wind_speed', 'wind_gust', 'wave_height', 'dominant_wave_period', 'average_wave_period', diff --git a/siphon/tests/test_ndbc.py b/siphon/tests/test_ndbc.py index fb3f5b5ff..6aa91ca23 100644 --- a/siphon/tests/test_ndbc.py +++ b/siphon/tests/test_ndbc.py @@ -7,6 +7,7 @@ import numpy as np from numpy.testing import assert_almost_equal, assert_equal +import pytest from siphon.simplewebservice.ndbc import NDBC from siphon.testing import get_recorder @@ -281,3 +282,9 @@ def test_ndbc_buoy_data_types(): 'swr2': 'spectral wave data (r2)', 'supl': 'supplemental measurements data'} assert(resp == truth) + + +def test_ndbc_realtime_keyerror(): + """Ensure an error is raised for invalid parsed data type requests.""" + with pytest.raises(KeyError): + NDBC.realtime_observations('41002', data_type='dartt')