-
Notifications
You must be signed in to change notification settings - Fork 12
/
index.html
169 lines (154 loc) · 440 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
<!--
redirect_blame by Will Leinweber
contribute at github.com/will/redirect_blame
-->
<html>
<script>
// BrowserDetect from http://www.quirksmode.org/js/detect.html
BrowserDetect = {
init: function () {
this.browser = this.searchString(this.dataBrowser) || "An unknown browser";
this.version = this.searchVersion(navigator.userAgent)
|| this.searchVersion(navigator.appVersion)
|| "an unknown version";
this.OS = this.searchString(this.dataOS) || "an unknown OS";
},
searchString: function (data) {
for (var i=0;i<data.length;i++) {
var dataString = data[i].string;
var dataProp = data[i].prop;
this.versionSearchString = data[i].versionSearch || data[i].identity;
if (dataString) {
if (dataString.indexOf(data[i].subString) != -1)
return data[i].identity;
}
else if (dataProp)
return data[i].identity;
}
},
searchVersion: function (dataString) {
var index = dataString.indexOf(this.versionSearchString);
if (index == -1) return;
return parseFloat(dataString.substring(index+this.versionSearchString.length+1));
},
dataBrowser: [
{
string: navigator.userAgent,
subString: "Chrome",
identity: "Chrome"
},
{ string: navigator.userAgent,
subString: "OmniWeb",
versionSearch: "OmniWeb/",
identity: "OmniWeb"
},
{
string: navigator.vendor,
subString: "Apple",
identity: "Safari",
versionSearch: "Version"
},
{
prop: window.opera,
identity: "Opera",
versionSearch: "Version"
},
{
string: navigator.vendor,
subString: "iCab",
identity: "iCab"
},
{
string: navigator.vendor,
subString: "KDE",
identity: "Konqueror"
},
{
string: navigator.userAgent,
subString: "PaleMoon",
identity: "Palemoon"
},
{
string: navigator.userAgent,
subString: "Firefox",
identity: "Firefox"
},
{
string: navigator.vendor,
subString: "Camino",
identity: "Camino"
},
{ // for newer Netscapes (6+)
string: navigator.userAgent,
subString: "Netscape",
identity: "Netscape"
},
{
string: navigator.userAgent,
subString: "MSIE",
identity: "Explorer",
versionSearch: "MSIE"
},
{
string: navigator.userAgent,
subString: "Gecko",
identity: "Mozilla",
versionSearch: "rv"
},
{ // for older Netscapes (4-)
string: navigator.userAgent,
subString: "Mozilla",
identity: "Netscape",
versionSearch: "Mozilla"
}
],
dataOS : [
{
string: navigator.platform,
subString: "Win",
identity: "Windows"
},
{
string: navigator.platform,
subString: "Mac",
identity: "Mac"
},
{
string: navigator.userAgent,
subString: "iPhone",
identity: "iPhone/iPod"
},
{
string: navigator.platform,
subString: "Linux",
identity: "Linux"
}
]
};
BrowserDetect.init();
chrome = "<html i18n-values="dir:textdirection" dir="ltr"><head>
<meta name="viewport" content="width=device-width, initial-scale=1.0,
                               maximum-scale=1.0, user-scalable=no">
<title i18n-content="title">http://what.com/ is not available</title>
<style>

body {
  background-color: #E6E6E6;
  font-family: Helvetica, Arial, sans-serif;
  font-size: 10pt;
  margin: 50px 40px 20px 40px;
  text-align: center;
}

#main-frame-error {
  margin: auto;
  max-width: 540px;
  min-width: 200px;
}

/* Don't use the main frame div when the error is in a subframe. */
html[subframe] #main-frame-error {
  display: none;
}

/* Don't use the subframe error div when the error is in a main frame. */
html:not([subframe]) #sub-frame-error {
  display: none;
}

#box {
  background-color: #fbfbfb;
  border: 1px solid #AAA;
  border-bottom: 1px solid #888;
  border-radius: 3px;
  color: black;
/* Not done on mobile for performance reasons. */
  box-shadow: 0px 2px 2px #AAA;
}

h1 {
  color: #666;
  margin: 10px 0px 25px 0px;
  font-weight: normal;
  font-size: 1.5em;
}

a {
  color: #15c;
  text-decoration: none;
}

.error-img {
  /**
   * Can't access chrome://theme/IDR_ERROR_NETWORK_GENERIC from an untrusted
   * renderer process, so embed the resource manually.
   */
  content: -webkit-image-set(
      url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAC4AAAAuCAYAAABXuSs3AAAAWUlEQVRo3u3U0Q0AERRFQT2+/mvZLQEhm8vOJP6IQ0JrAABkqapndgjfET4zJ+IAvwqPOMDIbR4fHvVYrwn/aq1w4cIXNu/9HsJ3hY+GCvc4TwpfGcIBAIK87I1OwILpQqsAAAAASUVORK5CYII=') 1x,
      url('data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAFwAAABcCAYAAADj79JYAAAAm0lEQVR42u3XOw4AEBBAQXfc+5+FWifx3ZhJtMTT2FIAAAAAAAAAAABIIiLqiaW04IILLvj+4Lv28QCCCy644HmDewDB3ww+GkZwwf8KbjASXHDBBc/zLcxyruCCCy644IILLrjgggsuuOCvXnx2VBdccMEFF/xc8NVBBRdccMEFN/gILrjgggt+fwkuuOCCCw4AAAAAAAAAAJ0G+LE7DCzzV9UAAAAASUVORK5CYII=') 2x);
  -webkit-user-select: none;
}

#content-top {
  margin: 20px 20px 20px 25px;
}

#help-box-outer {
  overflow: hidden;
  -webkit-transition: height ease-in 218ms;
}

#help-box-inner {
  background-color: #f9f9f9;
  border-top: 1px solid #EEE;
  color: #444;
  padding: 25px 20px;
  text-align: start;
}

#suggestions {
  margin-top: 15px;
}

#sub-frame-error-details {
  color: #8F8F8F;
/* Not done on mobile for performance reasons. */
  text-shadow: 0 1px 0 rgba(255,255,255,0.3);
}

[jscontent=failedUrl] {
  overflow-wrap: break-word;
}

button {
  border: 1px solid rgba(0, 0, 0, 0.25);
  border-radius: 2px;
  color: #444;
  margin: 0px 5px;
  min-height: 29px;
  min-width: 65px;
  -webkit-user-select: none;
  padding: 8px 13px;
/* iOS does not support linear-gradient without a prefix. */
  background-image: -webkit-linear-gradient(#ededed, #ededed 38%, #dedede);
  text-shadow: 0 1px 0 rgb(240, 240, 240);

/* Not done on mobile for performance reasons. */
  box-shadow: 0 1px 0 rgba(0, 0, 0, 0.08), inset 0 1px 2px rgba(255, 255, 255, 0.75);
}

button:hover {
  border: 1px solid rgba(0, 0, 0, 0.3);
  color: #000;
background-image: -webkit-linear-gradient(#f0f0f0, #f0f0f0 38%, #e0e0e0);

box-shadow: 0 1px 0 rgba(0, 0, 0, 0.12), inset 0 1px 2px rgba(255, 255, 255, 0.95);
}

button:active {
  border: 1px solid rgba(0, 0, 0, 0.3);
  color: #444;
background-image: -webkit-linear-gradient(#e7e7e7, #e7e7e7 38%, #d7d7d7);

box-shadow: none;
}

#reload-button {
  color: #fff;
background-image: -webkit-linear-gradient(#5d9aff, #5d9aff 38%, #5891f0);
  border: 1px solid rgba(45, 102, 195, 1);
  text-shadow: 0 1px 0 rgba(0,0,0,0.5);

box-shadow: 0 1px 0 rgba(0, 0, 0, 0.15), inset 0 1px 2px rgba(255, 255, 255, 0.2);
}

#reload-button:hover {
background-image: -webkit-linear-gradient(#659efd, #659efd 38%, #6097f1);
  border: 1px solid rgba(45, 102, 195, 1);
box-shadow: 0 1px 0 rgba(0, 0, 0, 0.25), inset 0 1px 2px rgba(255, 255, 255, 0.2);
}

#reload-button:active {
background-image: -webkit-linear-gradient(#6095ed, #6095ed 38%, #6095ed);
  border: 1px solid rgb(38, 84, 160);

box-shadow: inset 0 1px 1px rgba(0, 0, 0, 0.1);
}

.hidden {
  display: none;
}

.suggestions {
  margin-top: 18px;
}

.suggestion-header {
  font-weight: bold;
  margin-bottom: 4px;
}

.suggestion-body {
  color: #777;
}

.error-code {
  color: #A0A0A0;
  margin-top: 15px;
}

/* Increase line height at higher resolutions. */
@media (min-width: 641px) and (min-height: 641px) {
  #help-box-inner {
    line-height: 18px;
  }
}

/* Decrease padding at low sizes. */
@media (max-width: 640px), (max-height: 640px) {
  body {
    margin: 15px;
  }
  h1 {
    margin: 10px 0px 15px 0px;
  }
  #content-top {
    margin: 15px;
  }
  #help-box-inner {
    padding: 20px;
  }
  .suggestions {
    margin-top: 10px;
  }
  .suggestion-header {
    margin-bottom: 0px;
  }
  .error-code {
    margin-top: 10px;
  }
}

/* Don't allow overflow when in a subframe. */
html[subframe] body {
  overflow: hidden;
}

#sub-frame-error {
  -webkit-align-items: center;
  background-color: #DDD;
  display: -webkit-flex;
  -webkit-flex-flow: column;
  height: 100%;
  -webkit-justify-content: center;
  left: 0px;
  position: absolute;
  top: 0px;
  width: 100%;
}

#sub-frame-error:hover {
  background-color: #EEE;
}

#sub-frame-error-details {
  margin: 0 10px;
  visibility: hidden;
}

/* Show details only when hovering. */
#sub-frame-error:hover #sub-frame-error-details {
  visibility: visible;
}

/* If the iframe is too small, always hide the error code. */
/* TODO(mmenke): See if overflow: no-display works better, once supported. */
@media (max-width: 200px), (max-height: 95px) {
  #sub-frame-error-details {
    display: none;
  }
}

</style>
<script>

function toggleHelpBox() {
  var helpBoxOuter = document.getElementById('help-box-outer');
  helpBoxOuter.classList.toggle('hidden');
  var moreLessButton = document.getElementById('more-less-button');
  if (helpBoxOuter.classList.contains('hidden')) {
    moreLessButton.innerText = moreLessButton.moreText;
  } else {
    moreLessButton.innerText = moreLessButton.lessText;
  }
}

// Subframes use a different layout but the same html file.  This is to make it
// easier to support platforms that load the error page via different
// mechanisms (Currently just iOS).
if (window.top.location != window.location)
  document.documentElement.setAttribute('subframe', '');

</script></head>



<body id="t" jstcache="0">
<div id="main-frame-error" jstcache="0">
 <div id="box" jstcache="0">
  <div id="content-top" jstcache="0">
    <h1 jstcache="0">
     <div jstcache="0"><img class="error-img" jstcache="0"></div>
     <span i18n-content="heading" jstcache="0">Unable to connect to the Internet</span>
    </h1>

    <button id="reload-button" onclick="location = this.url" jsselect="reload" jsvalues=".url:reloadUrl" jscontent="msg" jstcache="3" style="display: none;"></button>
    <button id="more-less-button" onclick="toggleHelpBox()" jsdisplay="more" jsvalues=".moreText:more; .lessText:less;" jscontent="more" jstcache="4">More</button>
  </div>

  <!-- Outer and inner divs are needed both for margins and sizing. -->
  <div id="help-box-outer" class="hidden" jstcache="0">
   <div id="help-box-inner" jstcache="0">
    <div jsselect="summary" jstcache="5">
     <span jsvalues=".innerHTML:msg" jstcache="8"><span jscontent="productName" jstcache="11">Google Chrome</span>
          can't display the webpage because your computer isn't connected to the Internet.
          <br jstcache="0"><br jstcache="0">
          You can try to diagnose the problem by taking the following steps:
          <br jstcache="0"><br jstcache="0">
          Go to
          <strong jstcache="0">
          Applications &gt; System Preferences &gt; Network &gt; Assist me
          </strong>
          to test your connection.</span>
    </div>

    <div class="suggestions" jsselect="suggestions" jstcache="6" jsinstance="*0" style="display: none;">
      <div class="suggestion-header" jsvalues=".innerHTML:header" jstcache="9"></div>
      <div class="suggestion-body" jsvalues=".innerHTML:body" jstcache="10"></div>
    </div>
    <div class="error-code" jscontent="errorCode" jstcache="7">Error code: ERR_INTERNET_DISCONNECTED</div>
   </div>
  </div>
 </div>
</div>
<div id="sub-frame-error" jstcache="0">
  <!-- Show details when hovering over the icon, in case the details are
       hidden because they're too large. -->
  <img class="error-img" jsvalues=".title:errorDetails" jstcache="1" title="The Internet connection has been lost.">
  <div id="sub-frame-error-details" jsvalues=".innerHTML:errorDetails" jstcache="2">The Internet connection has been lost.</div>
</div>


<script jstcache="0">// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

/**
 * NOTE: The use of this file is deprecated. Use i18n_template2.js instead.
 *
 * @fileoverview This is a simple template engine inspired by JsTemplates
 * optimized for i18n.
 *
 * It currently supports two handlers:
 *
 *   * i18n-content which sets the textContent of the element
 *
 *     <span i18n-content="myContent"></span>
 *     i18nTemplate.process(element, {'myContent': 'Content'});
 *
 *   * i18n-values is a list of attribute-value or property-value pairs.
 *     Properties are prefixed with a '.' and can contain nested properties.
 *
 *     <span i18n-values="title:myTitle;.style.fontSize:fontSize"></span>
 *     i18nTemplate.process(element, {
 *       'myTitle': 'Title',
 *       'fontSize': '13px'
 *     });
 */

var i18nTemplate = (function() {
  /**
   * This provides the handlers for the templating engine. The key is used as
   * the attribute name and the value is the function that gets called for every
   * single node that has this attribute.
   * @type {Object}
   */
  var handlers = {
    /**
     * This handler sets the textContent of the element.
     */
    'i18n-content': function(element, attributeValue, obj) {
      element.textContent = obj[attributeValue];
    },

    /**
     * This handler adds options to a select element.
     */
    'i18n-options': function(element, attributeValue, obj) {
      var options = obj[attributeValue];
      options.forEach(function(values) {
        var option = typeof values == 'string' ? new Option(values) :
            new Option(values[1], values[0]);
        element.appendChild(option);
      });
    },

    /**
     * This is used to set HTML attributes and DOM properties,. The syntax is:
     *   attributename:key;
     *   .domProperty:key;
     *   .nested.dom.property:key
     */
    'i18n-values': function(element, attributeValue, obj) {
      var parts = attributeValue.replace(/\s/g, '').split(/;/);
      for (var j = 0; j < parts.length; j++) {
        var a = parts[j].match(/^([^:]+):(.+)$/);
        if (a) {
          var propName = a[1];
          var propExpr = a[2];

          // Ignore missing properties
          if (propExpr in obj) {
            var value = obj[propExpr];
            if (propName.charAt(0) == '.') {
              var path = propName.slice(1).split('.');
              var object = element;
              while (object && path.length > 1) {
                object = object[path.shift()];
              }
              if (object) {
                object[path] = value;
                // In case we set innerHTML (ignoring others) we need to
                // recursively check the content
                if (path == 'innerHTML') {
                  process(element, obj);
                }
              }
            } else {
              element.setAttribute(propName, value);
            }
          } else {
            console.warn('i18n-values: Missing value for "' + propExpr + '"');
          }
        }
      }
    }
  };

  var attributeNames = [];
  for (var key in handlers) {
    attributeNames.push(key);
  }
  var selector = '[' + attributeNames.join('],[') + ']';

  /**
   * Processes a DOM tree with the {@code obj} map.
   */
  function process(node, obj) {
    var elements = node.querySelectorAll(selector);
    for (var element, i = 0; element = elements[i]; i++) {
      for (var j = 0; j < attributeNames.length; j++) {
        var name = attributeNames[j];
        var att = element.getAttribute(name);
        if (att != null) {
          handlers[name](element, att, obj);
        }
      }
    }
  }

  return {
    process: process
  };
})();
</script><script jstcache="0">// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

(function(){var i=null;function k(){return Function.prototype.call.apply(Array.prototype.slice,arguments)}function l(a,b){var c=k(arguments,2);return function(){return b.apply(a,c)}}function m(a,b){var c=new n(b);for(c.f=[a];c.f.length;){var e=c,d=c.f.shift();e.g(d);for(d=d.firstChild;d;d=d.nextSibling)d.nodeType==1&&e.f.push(d)}}function n(a){this.g=a}function o(a){a.style.display=""}function p(a){a.style.display="none"};var q=":",r=/\s*;\s*/;function s(){this.i.apply(this,arguments)}s.prototype.i=function(a,b){if(!this.a)this.a={};if(b){var c=this.a,e=b.a,d;for(d in e)c[d]=e[d]}else for(c in d=this.a,e=t,e)d[c]=e[c];this.a.$this=a;this.a.$context=this;this.d=typeof a!="undefined"&&a!=i?a:"";if(!b)this.a.$top=this.d};var t={$default:i},u=[];function v(a){for(var b in a.a)delete a.a[b];a.d=i;u.push(a)}function w(a,b,c){try{return b.call(c,a.a,a.d)}catch(e){return t.$default}}
function x(a,b,c,e){if(u.length>0){var d=u.pop();s.call(d,b,a);a=d}else a=new s(b,a);a.a.$index=c;a.a.$count=e;return a}var y="a_",z="b_",A="with (a_) with (b_) return ",D={};function E(a){if(!D[a])try{D[a]=new Function(y,z,A+a)}catch(b){}return D[a]}function F(a){for(var b=[],a=a.split(r),c=0,e=a.length;c<e;++c){var d=a[c].indexOf(q);if(!(d<0)){var f;f=a[c].substr(0,d).replace(/^\s+/,"").replace(/\s+$/,"");d=E(a[c].substr(d+1));b.push(f,d)}}return b};var G="jsinstance",H="jsts",I="*",J="div",K="id";function L(){}var M=0,N={0:{}},P={},Q={},R=[];function S(a){a.__jstcache||m(a,function(a){T(a)})}var U=[["jsselect",E],["jsdisplay",E],["jsvalues",F],["jsvars",F],["jseval",function(a){for(var b=[],a=a.split(r),c=0,e=a.length;c<e;++c)if(a[c]){var d=E(a[c]);b.push(d)}return b}],["transclude",function(a){return a}],["jscontent",E],["jsskip",E]];
function T(a){if(a.__jstcache)return a.__jstcache;var b=a.getAttribute("jstcache");if(b!=i)return a.__jstcache=N[b];for(var b=R.length=0,c=U.length;b<c;++b){var e=U[b][0],d=a.getAttribute(e);Q[e]=d;d!=i&&R.push(e+"="+d)}if(R.length==0)return a.setAttribute("jstcache","0"),a.__jstcache=N[0];var f=R.join("&");if(b=P[f])return a.setAttribute("jstcache",b),a.__jstcache=N[b];for(var h={},b=0,c=U.length;b<c;++b){var d=U[b],e=d[0],g=d[1],d=Q[e];d!=i&&(h[e]=g(d))}b=""+ ++M;a.setAttribute("jstcache",b);N[b]=
h;P[f]=b;return a.__jstcache=h}function V(a,b){a.h.push(b);a.k.push(0)}function W(a){return a.c.length?a.c.pop():[]}
L.prototype.e=function(a,b){var c=X(b),e=c.transclude;if(e)(c=Y(e))?(b.parentNode.replaceChild(c,b),e=W(this),e.push(this.e,a,c),V(this,e)):b.parentNode.removeChild(b);else if(c=c.jsselect){var c=w(a,c,b),d=b.getAttribute(G),f=!1;d&&(d.charAt(0)==I?(d=parseInt(d.substr(1),10),f=!0):d=parseInt(d,10));var h=c!=i&&typeof c=="object"&&typeof c.length=="number",e=h?c.length:1,g=h&&e==0;if(h)if(g)d?b.parentNode.removeChild(b):(b.setAttribute(G,"*0"),p(b));else if(o(b),d===i||d===""||f&&d<e-1){f=W(this);
d=d||0;for(h=e-1;d<h;++d){var j=b.cloneNode(!0);b.parentNode.insertBefore(j,b);Z(j,c,d);g=x(a,c[d],d,e);f.push(this.b,g,j,v,g,i)}Z(b,c,d);g=x(a,c[d],d,e);f.push(this.b,g,b,v,g,i);V(this,f)}else d<e?(f=c[d],Z(b,c,d),g=x(a,f,d,e),f=W(this),f.push(this.b,g,b,v,g,i),V(this,f)):b.parentNode.removeChild(b);else c==i?p(b):(o(b),g=x(a,c,0,1),f=W(this),f.push(this.b,g,b,v,g,i),V(this,f))}else this.b(a,b)};
L.prototype.b=function(a,b){var c=X(b),e=c.jsdisplay;if(e){if(!w(a,e,b)){p(b);return}o(b)}if(e=c.jsvars)for(var d=0,f=e.length;d<f;d+=2){var h=e[d],g=w(a,e[d+1],b);a.a[h]=g}if(e=c.jsvalues){d=0;for(f=e.length;d<f;d+=2)if(g=e[d],h=w(a,e[d+1],b),g.charAt(0)=="$")a.a[g]=h;else if(g.charAt(0)=="."){for(var g=g.substr(1).split("."),j=b,O=g.length,B=0,$=O-1;B<$;++B){var C=g[B];j[C]||(j[C]={});j=j[C]}j[g[O-1]]=h}else g&&(typeof h=="boolean"?h?b.setAttribute(g,g):b.removeAttribute(g):b.setAttribute(g,""+
h))}if(e=c.jseval){d=0;for(f=e.length;d<f;++d)w(a,e[d],b)}e=c.jsskip;if(!e||!w(a,e,b))if(c=c.jscontent){if(c=""+w(a,c,b),b.innerHTML!=c){for(;b.firstChild;)e=b.firstChild,e.parentNode.removeChild(e);b.appendChild(this.j.createTextNode(c))}}else{c=W(this);for(e=b.firstChild;e;e=e.nextSibling)e.nodeType==1&&c.push(this.e,a,e);c.length&&V(this,c)}};function X(a){if(a.__jstcache)return a.__jstcache;var b=a.getAttribute("jstcache");if(b)return a.__jstcache=N[b];return T(a)}
function Y(a,b){var c=document;if(b){var e=c.getElementById(a);if(!e){var e=b(),d=H,f=c.getElementById(d);if(!f)f=c.createElement(J),f.id=d,p(f),f.style.position="absolute",c.body.appendChild(f);d=c.createElement(J);f.appendChild(d);d.innerHTML=e;e=c.getElementById(a)}c=e}else c=c.getElementById(a);return c?(S(c),c=c.cloneNode(!0),c.removeAttribute(K),c):i}function Z(a,b,c){c==b.length-1?a.setAttribute(G,I+c):a.setAttribute(G,""+c)};window.jstGetTemplate=Y;window.JsEvalContext=s;window.jstProcess=function(a,b){var c=new L;S(b);c.j=b?b.nodeType==9?b:b.ownerDocument||document:document;var e=l(c,c.e,a,b),d=c.h=[],f=c.k=[];c.c=[];e();for(var h,g,j;d.length;)h=d[d.length-1],e=f[f.length-1],e>=h.length?(e=c,g=d.pop(),g.length=0,e.c.push(g),f.pop()):(g=h[e++],j=h[e++],h=h[e++],f[f.length-1]=e,g.call(c,j,h))};
})()
</script><script jstcache="0">var templateData = {"errorCode":"Error code: ERR_INTERNET_DISCONNECTED","errorDetails":"The Internet connection has been lost.","heading":"Unable to connect to the Internet","less":"Less","more":"More","suggestions":[],"summary":{"failedUrl":"http://what.com/","hostName":"what.com","msg":"\u003Cspan jscontent=\"productName\"\u003E\u003C/span\u003E\n          can't display the webpage because your computer isn't connected to the Internet.\n          \u003Cbr /\u003E\u003Cbr /\u003E\n          You can try to diagnose the problem by taking the following steps:\n          \u003Cbr /\u003E\u003Cbr /\u003E\n          Go to\n          \u003Cstrong\u003E\n          Applications \u003E System Preferences \u003E Network \u003E Assist me\n          \u003C/strong\u003E\n          to test your connection.","productName":"Google Chrome"},"textdirection":"ltr","title":"http://what.com/ is not available"};</script><script jstcache="0">// Copyright (c) 2010 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Invoke the template engine previously loaded from i18n_template.js
i18nTemplate.process(document, templateData);
</script><script jstcache="0">var tp = document.getElementById('t');jstProcess(new JsEvalContext(templateData), tp);</script></body></html>
"
firefox = "<html xmlns="http://www.w3.org/1999/xhtml" hasBrowserHandlers="true">
  <head>
    <title>Problem loading page</title>
    <style>
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 *  This defines the look-and-feel styling of the error pages.
 *  (see: netError.xhtml)
 *
 *  Original styling by William Price <bugzilla@mob.rice.edu>
 *  Updated by: Steven Garrity <steven@silverorange.com>
 *              Henrik Skupin  <mozilla@hskupin.info>
 */

html {
  background: -moz-Dialog;
}

body {
  margin: 0;
  padding: 0 1em;
  color: -moz-FieldText;
  font: message-box;
}

h1 {
  margin: 0 0 .6em 0;
  border-bottom: 1px solid ThreeDLightShadow;
  font-size: 160%;
}

ul, ol {
  margin: 0;
  -moz-margin-start: 1.5em;
  padding: 0;
}

ul > li, ol > li {
  margin-bottom: .5em;
}

ul {
  list-style: square;
}

#errorPageContainer {
  position: relative;
  min-width: 13em;
  max-width: 52em;
  margin: 4em auto;
  border: 1px solid ThreeDShadow;
  border-radius: 10px;
  padding: 3em;
  -moz-padding-start: 30px;
  background: url("chrome://global/skin/icons/warning-large.png") left 0 no-repeat -moz-Field;
  background-origin: content-box;
}

#errorPageContainer.certerror {
  background-image: url("chrome://global/skin/icons/sslWarning.png");
}

#errorPageContainer:-moz-dir(rtl) {
  background-position: right 0;
}

#errorTitle {
  -moz-margin-start: 80px;
}

#errorLongContent {
  -moz-margin-start: 80px;
}

#errorShortDesc > p {
  overflow: auto;
  border-bottom: 1px solid ThreeDLightShadow;
  padding-bottom: 1em;
  font-size: 130%;
  white-space: pre-wrap;
}

#errorLongDesc {
  -moz-padding-end: 3em;
  font-size: 110%;
}

#errorLongDesc > p {
}

#errorTryAgain {
  margin-top: 2em;
  -moz-margin-start: 80px;
}

#brand {
  position: absolute;
  right: 0;
  bottom: -1.5em;
  -moz-margin-end: 10px;
  opacity: .4;
}

#brand:-moz-dir(rtl) {
  right: auto;
  left: 0;
}

#brand > p {
  margin: 0;
}

#errorContainer {
  display: none;
}

#securityOverrideDiv {
  padding-top: 10px;
}

#securityOverrideContent {
  background-color: #FFF090; /* Pale yellow */
  padding: 10px;
  border-radius: 10px;
}

/* Custom styling for 'blacklist' error class */
:root.blacklist #errorTitle, :root.blacklist #errorLongContent,
:root.blacklist #errorShortDesc, :root.blacklist #errorLongDesc,
:root.blacklist a {
  background-color: #722; /* Dark red */
  color: white;
}

:root.blacklist #errorPageContainer {
  background-image: url("chrome://global/skin/icons/blacklist_64.png");
  background-color: #722;
}

:root.blacklist {
  background: #333;
}

:root.blacklist #errorTryAgain {
  display: none;
}

</style>
    <!-- If the location of the favicon is changed here, the FAVICON_ERRORPAGE_URL symbol in
        toolkit/components/places/src/nsFaviconService.h should be updated. -->
    <link rel="icon" type="image/png" id="favicon" href="chrome://global/skin/icons/warning-16.png" />

    <script type="application/javascript"><![CDATA[
      // Error url MUST be formatted like this:
      //  moz-neterror:page?e=error&u=url&d=desc
      //
      // or optionally, to specify an alternate CSS class to allow for
      // custom styling and favicon:
      //
      //  moz-neterror:page?e=error&u=url&s=classname&d=desc

      // Note that this file uses document.documentURI to get
      // the URL (with the format from above). This is because
      // document.location.href gets the current URI off the docshell,
      // which is the URL displayed in the location bar, i.e.
      // the URI that the user attempted to load.

      function getErrorCode()
      {
        var url = document.documentURI;
        var error = url.search(/e\=/);
        var duffUrl = url.search(/\&u\=/);
        return decodeURIComponent(url.slice(error + 2, duffUrl));
      }

      function getCSSClass()
      {
        var url = document.documentURI;
        var matches = url.match(/s\=([^&]+)\&/);
        // s is optional, if no match just return nothing
        if (!matches || matches.length < 2)
          return "";

        // parenthetical match is the second entry
        return decodeURIComponent(matches[1]);
      }

      function getDescription()
      {
        var url = document.documentURI;
        var desc = url.search(/d\=/);

        // desc == -1 if not found; if so, return an empty string
        // instead of what would turn out to be portions of the URI
        if (desc == -1)
          return "";

        return decodeURIComponent(url.slice(desc + 2));
      }

      function retryThis(buttonEl)
      {
        // Note: The application may wish to handle switching off "offline mode"
        // before this event handler runs, but using a capturing event handler.

        // Session history has the URL of the page that failed
        // to load, not the one of the error page. So, just call
        // reload(), which will also repost POST data correctly.
        try {
          location.reload();
        } catch (e) {
          // We probably tried to reload a URI that caused an exception to
          // occur;  e.g. a nonexistent file.
        }

        buttonEl.disabled = true;
      }

      function initPage()
      {
        var err = getErrorCode();

        // if it's an unknown error or there's no title or description
        // defined, get the generic message
        var errTitle = document.getElementById("et_" + err);
        var errDesc  = document.getElementById("ed_" + err);
        if (!errTitle || !errDesc)
        {
          errTitle = document.getElementById("et_generic");
          errDesc  = document.getElementById("ed_generic");
        }

        var title = document.getElementById("errorTitleText");
        if (title)
        {
          title.parentNode.replaceChild(errTitle, title);
          // change id to the replaced child's id so styling works
          errTitle.id = "errorTitleText";
        }

        var sd = document.getElementById("errorShortDescText");
        if (sd)
          sd.textContent = getDescription();

        var ld = document.getElementById("errorLongDesc");
        if (ld)
        {
          ld.parentNode.replaceChild(errDesc, ld);
          // change id to the replaced child's id so styling works
          errDesc.id = "errorLongDesc";
        }

        // remove undisplayed errors to avoid bug 39098
        var errContainer = document.getElementById("errorContainer");
        errContainer.parentNode.removeChild(errContainer);

        var className = getCSSClass();
        if (className && className != "expertBadCert") {
          // Associate a CSS class with the root of the page, if one was passed in,
          // to allow custom styling.
          // Not "expertBadCert" though, don't want to deal with the favicon
          document.documentElement.className = className;

          // Also, if they specified a CSS class, they must supply their own
          // favicon.  In order to trigger the browser to repaint though, we
          // need to remove/add the link element.
          var favicon = document.getElementById("favicon");
          var faviconParent = favicon.parentNode;
          faviconParent.removeChild(favicon);
          favicon.setAttribute("href", "chrome://global/skin/icons/" + className + "_favicon.png");
          faviconParent.appendChild(favicon);
        }
        if (className == "expertBadCert") {
          showSecuritySection();
        }

        if (err == "remoteXUL") {
          // Remove the "Try again" button for remote XUL errors given that
          // it is useless.
          document.getElementById("errorTryAgain").style.display = "none";
        }

        if (err == "cspFrameAncestorBlocked") {
          // Remove the "Try again" button for CSP frame ancestors violation, since it's
          // almost certainly useless. (Bug 553180)
          document.getElementById("errorTryAgain").style.display = "none";
        }

        if (err == "nssBadCert") {
          // Remove the "Try again" button for security exceptions, since it's
          // almost certainly useless.
          document.getElementById("errorTryAgain").style.display = "none";
          document.getElementById("errorPageContainer").setAttribute("class", "certerror");
          addDomainErrorLink();
        }
        else {
          // Remove the override block for non-certificate errors.  CSS-hiding
          // isn't good enough here, because of bug 39098
          var secOverride = document.getElementById("securityOverrideDiv");
          secOverride.parentNode.removeChild(secOverride);
        }
      }

      function showSecuritySection() {
        // Swap link out, content in
        document.getElementById('securityOverrideContent').style.display = '';
        document.getElementById('securityOverrideLink').style.display = 'none';
      }

      /* In the case of SSL error pages about domain mismatch, see if
        we can hyperlink the user to the correct site.  We don't want
        to do this generically since it allows MitM attacks to redirect
        users to a site under attacker control, but in certain cases
        it is safe (and helpful!) to do so.  Bug 402210
      */
      function addDomainErrorLink() {
        // Rather than textContent, we need to treat description as HTML
        var sd = document.getElementById("errorShortDescText");
        if (sd) {
          var desc = getDescription();

          // sanitize description text - see bug 441169

          // First, find the index of the <a> tag we care about, being careful not to
          // use an over-greedy regex
          var re = /<a id="cert_domain_link" title="([^"]+)">/;
          var result = re.exec(desc);
          if(!result)
            return;

          // Remove sd's existing children
          sd.textContent = "";

          // Everything up to the link should be text content
          sd.appendChild(document.createTextNode(desc.slice(0, result.index)));

          // Now create the link itself
          var anchorEl = document.createElement("a");
          anchorEl.setAttribute("id", "cert_domain_link");
          anchorEl.setAttribute("title", result[1]);
          anchorEl.appendChild(document.createTextNode(result[1]));
          sd.appendChild(anchorEl);

          // Finally, append text for anything after the closing </a>
          sd.appendChild(document.createTextNode(desc.slice(desc.indexOf("</a>") + "</a>".length)));
        }

        var link = document.getElementById('cert_domain_link');
        if (!link)
          return;

        var okHost = link.getAttribute("title");
        var thisHost = document.location.hostname;
        var proto = document.location.protocol;

        // If okHost is a wildcard domain ("*.example.com") let's
        // use "www" instead.  "*.example.com" isn't going to
        // get anyone anywhere useful. bug 432491
        okHost = okHost.replace(/^\*\./, "www.");

        /* case #1:
        * example.com uses an invalid security certificate.
        *
        * The certificate is only valid for www.example.com
        *
        * Make sure to include the "." ahead of thisHost so that
        * a MitM attack on paypal.com doesn't hyperlink to "notpaypal.com"
        *
        * We'd normally just use a RegExp here except that we lack a
        * library function to escape them properly (bug 248062), and
        * domain names are famous for having '.' characters in them,
        * which would allow spurious and possibly hostile matches.
        */
        if (endsWith(okHost, "." + thisHost))
          link.href = proto + okHost;

        /* case #2:
        * browser.garage.maemo.org uses an invalid security certificate.
        *
        * The certificate is only valid for garage.maemo.org
        */
        if (endsWith(thisHost, "." + okHost))
          link.href = proto + okHost;
      }

      function endsWith(haystack, needle) {
        return haystack.slice(-needle.length) == needle;
      }

    ]]></script>
  </head>

  <body dir="ltr">

    <!-- ERROR ITEM CONTAINER (removed during loading to avoid bug 39098) -->


    <!-- PAGE CONTAINER (for styling purposes only) -->
    <div id="errorPageContainer">

      <!-- Error Title -->
      <div id="errorTitle">
        <h1 id="errorTitleText">Unable to connect</h1>
      </div>

      <!-- LONG CONTENT (the section most likely to require scrolling) -->
      <div id="errorLongContent">

        <!-- Short Description -->
        <div id="errorShortDesc">
          <p id="errorShortDescText">Firefox can't establish a connection to the server.</p>
        </div>

        <!-- Long Description (Note: See netError.dtd for used XHTML tags) -->
        <div id="errorLongDesc">
<ul>
  <li>The site could be temporarily unavailable or too busy. Try again in a few
    moments.</li>
  <li>If you are unable to load any pages, check your computer's network
    connection.</li>
  <li>If your computer or network is protected by a firewall or proxy, make sure
    that Firefox is permitted to access the Web.</li>
</ul>
</div>

        <!-- Override section - For ssl errors only.  Removed on init for other
            error types.  -->

      </div>

      <!-- Retry Button -->
      <button id="errorTryAgain" autocomplete="off" onclick="retryThis(this);" autofocus="true">Try Again</button>
      <script>
        // Only do autofocus if we're the toplevel frame; otherwise we
        // don't want to call attention to ourselves!  The key part is
        // that autofocus happens on insertion into the tree, so we
        // can remove the button, add @autofocus, and reinsert the
        // button.
        if (window.top == window) {
            var button = document.getElementById("errorTryAgain");
            var nextSibling = button.nextSibling;
            var parent = button.parentNode;
            parent.removeChild(button);
            button.setAttribute("autofocus", "true");
            parent.insertBefore(button, nextSibling);
        }
      </script>

    </div>

    <!--
    - Note: It is important to run the script this way, instead of using
    - an onload handler. This is because error pages are loaded as
    - LOAD_BACKGROUND, which means that onload handlers will not be executed.
    -->
    <script type="application/javascript">initPage();</script>

  </body>
</html>
"
ie11 = "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"
palemoon = "<!-- This Source Code Form is subject to the terms of the Mozilla Public
   - License, v. 2.0. If a copy of the MPL was not distributed with this
   - file, You can obtain one at http://mozilla.org/MPL/2.0/. -->
<html hasBrowserHandlers="true" xmlns="http://www.w3.org/1999/xhtml">
  <head>
<meta http-equiv="content-type" content="text/html; charset=">
    <title>Problem loading page</title>
    <style>

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

/*
 *  This defines the look-and-feel styling of the error pages.
 *  (see: netError.xhtml)
 *
 *  Original styling by William Price <bugzilla@mob.rice.edu>
 *  Updated by: Michael Ventnor <m.ventnor@gmail.com>
 */

html {
  background: #368;
}

body {
  margin: 0;
  padding: 0 1em;
  color: -moz-FieldText;
  font: message-box;
}

h1 {
  margin: 0 0 .6em 0;
  border-bottom: 1px solid ThreeDLightShadow;
  font-size: 160%;
}

ul, ol {
  margin: 0;
  -moz-margin-start: 1.5em;
  padding: 0;
}

ul > li, ol > li {
  margin-bottom: .5em;
}

ul {
  list-style: square;
}

#errorPageContainer {
  position: relative;
  min-width: 13em;
  max-width: 52em;
  margin: 4em auto;
  border: 2px solid #9BD;
  border-radius: 10px;
  box-shadow: 0px 0px 8px #DEF;
  padding: 3em;
  -moz-padding-start: 30px;
  background: url("moz-icon://stock/gtk-dialog-warning?size=dialog") left 0 no-repeat -moz-Field;
  background-origin: content-box;
}

#errorPageContainer.certerror {
  background-image: url("chrome://global/skin/icons/sslWarning.png");
}

#errorPageContainer:-moz-dir(rtl) {
  background-position: right 0;
}

#errorTitle {
  -moz-margin-start: 80px;
}

#errorLongContent {
  -moz-margin-start: 80px;
}

#errorShortDesc > p {
  overflow: auto;
  border-bottom: 1px solid ThreeDLightShadow;
  padding-bottom: 1em;
  font-size: 130%;
  white-space: pre-wrap;
}

#errorLongDesc {
  -moz-padding-end: 3em;
  font-size: 110%;
}

#errorLongDesc > p {
}

#errorTryAgain {
  margin-top: 2em;
  -moz-margin-start: 80px;
}

#brand {
  position: absolute;
  right: 0;
  bottom: -1.5em;
  -moz-margin-end: 10px;
  opacity: .4;
}

#brand:-moz-dir(rtl) {
  right: auto;
  left: 0;
}

#brand > p {
  margin: 0;
}

#errorContainer {
  display: none;
}

#securityOverrideDiv {
  padding-top: 10px;
}

#securityOverrideContent {
  background-color: InfoBackground;
  color: InfoText;
  padding: 10px;
  border-radius: 10px;
}

/* Custom styling for 'blacklist' error class */
:root.blacklist #errorTitle, :root.blacklist #errorLongContent,
:root.blacklist #errorShortDesc, :root.blacklist #errorLongDesc,
:root.blacklist a {
  background-color: #722; /* Dark red */
  color: white;
}

:root.blacklist #errorPageContainer {
  background-image: url("chrome://global/skin/icons/blacklist_large.png");
  background-color: #722;
}

:root.blacklist {
  background: #333;
}

:root.blacklist #errorTryAgain {
  display: none;
}

</style>
    <!-- If the location of the favicon is changed here, the FAVICON_ERRORPAGE_URL symbol in
        toolkit/components/places/src/nsFaviconService.h should be updated. -->
    <link href="chrome://global/skin/icons/warning-16.png" id="favicon" type="image/png" rel="icon">

    <script type="application/javascript"><![CDATA[
      // Error url MUST be formatted like this:
      //  moz-neterror:page?e=error&u=url&d=desc
      //
      // or optionally, to specify an alternate CSS class to allow for
      // custom styling and favicon:
      //
      //  moz-neterror:page?e=error&u=url&s=classname&d=desc

      // Note that this file uses document.documentURI to get
      // the URL (with the format from above). This is because
      // document.location.href gets the current URI off the docshell,
      // which is the URL displayed in the location bar, i.e.
      // the URI that the user attempted to load.

      function getErrorCode()
      {
        var url = document.documentURI;
        var error = url.search(/e\=/);
        var duffUrl = url.search(/\&u\=/);
        return decodeURIComponent(url.slice(error + 2, duffUrl));
      }

      function getCSSClass()
      {
        var url = document.documentURI;
        var matches = url.match(/s\=([^&]+)\&/);
        // s is optional, if no match just return nothing
        if (!matches || matches.length < 2)
          return "";

        // parenthetical match is the second entry
        return decodeURIComponent(matches[1]);
      }

      function getDescription()
      {
        var url = document.documentURI;
        var desc = url.search(/d\=/);

        // desc == -1 if not found; if so, return an empty string
        // instead of what would turn out to be portions of the URI
        if (desc == -1)
          return "";

        return decodeURIComponent(url.slice(desc + 2));
      }

      function retryThis(buttonEl)
      {
        // Note: The application may wish to handle switching off "offline mode"
        // before this event handler runs, but using a capturing event handler.

        // Session history has the URL of the page that failed
        // to load, not the one of the error page. So, just call
        // reload(), which will also repost POST data correctly.
        try {
          location.reload();
        } catch (e) {
          // We probably tried to reload a URI that caused an exception to
          // occur;  e.g. a nonexistent file.
        }

        buttonEl.disabled = true;
      }

      function initPage()
      {
        var err = getErrorCode();

        // if it's an unknown error or there's no title or description
        // defined, get the generic message
        var errTitle = document.getElementById("et_" + err);
        var errDesc  = document.getElementById("ed_" + err);
        if (!errTitle || !errDesc)
        {
          errTitle = document.getElementById("et_generic");
          errDesc  = document.getElementById("ed_generic");
        }

        var title = document.getElementById("errorTitleText");
        if (title)
        {
          title.parentNode.replaceChild(errTitle, title);
          // change id to the replaced child's id so styling works
          errTitle.id = "errorTitleText";
        }

        var sd = document.getElementById("errorShortDescText");
        if (sd)
          sd.textContent = getDescription();

        var ld = document.getElementById("errorLongDesc");
        if (ld)
        {
          ld.parentNode.replaceChild(errDesc, ld);
          // change id to the replaced child's id so styling works
          errDesc.id = "errorLongDesc";
        }

        // remove undisplayed errors to avoid bug 39098
        var errContainer = document.getElementById("errorContainer");
        errContainer.parentNode.removeChild(errContainer);

        var className = getCSSClass();
        if (className && className != "expertBadCert") {
          // Associate a CSS class with the root of the page, if one was passed in,
          // to allow custom styling.
          // Not "expertBadCert" though, don't want to deal with the favicon
          document.documentElement.className = className;

          // Also, if they specified a CSS class, they must supply their own
          // favicon.  In order to trigger the browser to repaint though, we
          // need to remove/add the link element.
          var favicon = document.getElementById("favicon");
          var faviconParent = favicon.parentNode;
          faviconParent.removeChild(favicon);
          favicon.setAttribute("href", "chrome://global/skin/icons/" + className + "_favicon.png");
          faviconParent.appendChild(favicon);
        }
        if (className == "expertBadCert") {
          showSecuritySection();
        }

        if (err == "remoteXUL") {
          // Remove the "Try again" button for remote XUL errors given that
          // it is useless.
          document.getElementById("errorTryAgain").style.display = "none";
        }

        if (err == "cspBlocked") {
          // Remove the "Try again" button for CSP violations, since it's
          // almost certainly useless. (Bug 553180)
          document.getElementById("errorTryAgain").style.display = "none";
        }

        if (err == "nssBadCert") {
          // Remove the "Try again" button for security exceptions, since it's
          // almost certainly useless.
          document.getElementById("errorTryAgain").style.display = "none";
          document.getElementById("errorPageContainer").setAttribute("class", "certerror");
          addDomainErrorLink();
        }
        else {
          // Remove the override block for non-certificate errors.  CSS-hiding
          // isn't good enough here, because of bug 39098
          var secOverride = document.getElementById("securityOverrideDiv");
          secOverride.parentNode.removeChild(secOverride);
        }
      }

      function showSecuritySection() {
        // Swap link out, content in
        document.getElementById('securityOverrideContent').style.display = '';
        document.getElementById('securityOverrideLink').style.display = 'none';
      }

      /* In the case of SSL error pages about domain mismatch, see if
        we can hyperlink the user to the correct site.  We don't want
        to do this generically since it allows MitM attacks to redirect
        users to a site under attacker control, but in certain cases
        it is safe (and helpful!) to do so.  Bug 402210
      */
      function addDomainErrorLink() {
        // Rather than textContent, we need to treat description as HTML
        var sd = document.getElementById("errorShortDescText");
        if (sd) {
          var desc = getDescription();

          // sanitize description text - see bug 441169

          // First, find the index of the <a> tag we care about, being careful not to
          // use an over-greedy regex
          var re = /<a id="cert_domain_link" title="([^"]+)">/;
          var result = re.exec(desc);
          if(!result)
            return;

          // Remove sd's existing children
          sd.textContent = "";

          // Everything up to the link should be text content
          sd.appendChild(document.createTextNode(desc.slice(0, result.index)));

          // Now create the link itself
          var anchorEl = document.createElement("a");
          anchorEl.setAttribute("id", "cert_domain_link");
          anchorEl.setAttribute("title", result[1]);
          anchorEl.appendChild(document.createTextNode(result[1]));
          sd.appendChild(anchorEl);

          // Finally, append text for anything after the closing </a>
          sd.appendChild(document.createTextNode(desc.slice(desc.indexOf("</a>") + "</a>".length)));
        }

        var link = document.getElementById('cert_domain_link');
        if (!link)
          return;

        var okHost = link.getAttribute("title");
        var thisHost = document.location.hostname;
        var proto = document.location.protocol;

        // If okHost is a wildcard domain ("*.example.com") let's
        // use "www" instead.  "*.example.com" isn't going to
        // get anyone anywhere useful. bug 432491
        okHost = okHost.replace(/^\*\./, "www.");

        /* case #1:
        * example.com uses an invalid security certificate.
        *
        * The certificate is only valid for www.example.com
        *
        * Make sure to include the "." ahead of thisHost so that
        * a MitM attack on paypal.com doesn't hyperlink to "notpaypal.com"
        *
        * We'd normally just use a RegExp here except that we lack a
        * library function to escape them properly (bug 248062), and
        * domain names are famous for having '.' characters in them,
        * which would allow spurious and possibly hostile matches.
        */
        if (endsWith(okHost, "." + thisHost))
          link.href = proto + okHost;

        /* case #2:
        * browser.garage.maemo.org uses an invalid security certificate.
        *
        * The certificate is only valid for garage.maemo.org
        */
        if (endsWith(thisHost, "." + okHost))
          link.href = proto + okHost;
      }

      function endsWith(haystack, needle) {
        return haystack.slice(-needle.length) == needle;
      }

    ]]></script>
  </head>

  <body dir="ltr">

    <!-- ERROR ITEM CONTAINER (removed during loading to avoid bug 39098) -->


    <!-- PAGE CONTAINER (for styling purposes only) -->
    <div id="errorPageContainer">

      <!-- Error Title -->
      <div id="errorTitle">
        <h1 id="errorTitleText">Unable to connect</h1>
      </div>

      <!-- LONG CONTENT (the section most likely to require scrolling) -->
      <div id="errorLongContent">

        <!-- Short Description -->
        <div id="errorShortDesc">
          <p id="errorShortDescText">Pale Moon can't establish a connection to the server.</p>
        </div>

        <!-- Long Description (Note: See netError.dtd for used XHTML tags) -->
        <div id="errorLongDesc">
<ul>
  <li>The site could be temporarily unavailable or too busy. Try again in a few
    moments.</li>
  <li>If you are unable to load any pages, check your computer's network
    connection.</li>
  <li>If your computer or network is protected by a firewall or proxy, make sure
    that Pale Moon is permitted to access the Web.</li>
</ul>
</div>

        <!-- Override section - For ssl errors only.  Removed on init for other
            error types.  -->

      </div>

      <!-- Retry Button -->
      <button id="errorTryAgain" autocomplete="off" onclick="retryThis(this);" autofocus="true">Try Again</button>
      <script>
        // Only do autofocus if we're the toplevel frame; otherwise we
        // don't want to call attention to ourselves!  The key part is
        // that autofocus happens on insertion into the tree, so we
        // can remove the button, add @autofocus, and reinsert the
        // button.
        if (window.top == window) {
            var button = document.getElementById("errorTryAgain");
            var nextSibling = button.nextSibling;
            var parent = button.parentNode;
            parent.removeChild(button);
            button.setAttribute("autofocus", "true");
            parent.insertBefore(button, nextSibling);
        }
      </script>

    </div>

    <!--
    - Note: It is important to run the script this way, instead of using
    - an onload handler. This is because error pages are loaded as
    - LOAD_BACKGROUND, which means that onload handlers will not be executed.
    -->
    <script type="application/javascript">initPage();</script>

  </body>
</html>"
safari = "<HTML>
<HEAD>
    <STYLE>
        BODY {font-family:'Helvetica Neue';}
       /*
    This file has a UTF-8 BOM in it so it can be included from a UTF-16 page
    without specifying an explicit character set. When editing it, please be
    sure to preserve the BOM (first three bytes of the file, EF BB BF).
 */

body {
    background-color: rgb(237, 239, 238);
    background-image: url(data:image/gif;base64,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);
    background-size: 100px 100px;
    text-align: center;
    -webkit-user-select: none;
    cursor: default;
}

.error-container {
    margin-top: 128px;
    padding-top: 0;
}

.error-container, .suggestion-container, .action-container {
    position: relative;
    width: 500px;
    min-height: 90px;
    margin-left: auto;
    margin-right: auto;

    padding-left: 93px;
    padding-right: 93px;
    padding-bottom: 0;
}

.suggestion-container {
    margin-top: 25px;
    padding-top: 20px;
    background: url(data:image/gif;base64,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) top center no-repeat;
    background-size: 686px 1px;
}

.icon {
    position: relative;
    margin-left: auto;
    margin-right: auto;

    width: 113px;
    height: 120px;
    background-image: url(data:image/gif;base64,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);
    background-repeat: no-repeat;
    background-size: 113px 120px;
}

.reading-list-glasses {
    display: inline-block;

    position: relative;
    top: 2px;

    margin-right: 8px;

    width: 35px;
    height: 16px;
    background-image: url(data:image/gif;base64,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);
    background-repeat: no-repeat;
    background-size: 35px 16px;
}

.error-text-engraving .reading-list-glasses, .error-text-inner-shadow .reading-list-glasses {
    /* Hide the duplicate Reading List glasses that are next to the envgraving and the shadow of the
    inner text. The images are just there for horizontal spacing of the components of the error text,
    we don't want to show them. */
    visibility: hidden;
}

html[dir=rtl] .icon {
    left: auto;
    right: 7px;
}

.text-container {
    position: relative;
    width: 100%;
    margin: auto;
    -webkit-font-smoothing: antialiased;
}

.error-text, .error-text-engraving, .error-text-inner-shadow
{
    margin: 0;
    word-wrap: break-word;
}

.error-text {
    position: absolute;
    top: 0;
    left: 0;
    right: 0;
    background-repeat: repeat;
    -webkit-background-clip: text;
    -webkit-text-fill-color: transparent;
}

.error-text-engraving {
    position: relative;
    top: 1px;
    width: 100%;
    color: white;
}

.error-text-inner-shadow {
    position: absolute;
    top: 1px;
    left: 0;
    right: 0;
    color: rgba(255, 255, 255, 0.25);
}

.error-title
{
    font-size: 18px;
    line-height:24px; /* This needs to be the same as the 2nd color stop position in -webkit-repeating-linear-gradient of error-title.error-text. */
    font-weight: bold;
}

.error-title.error-text {
    /* the position for rgba(124, 128, 130, 0.9) needs to be the same as the line-height in .error-title */
    background-image: -webkit-repeating-linear-gradient(rgba(79, 82, 85, 0.9) 0, rgba(124, 128, 130, 0.9) 24px), url(data:image/gif;base64,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);
}

.error-title.error-text-engraving {
    margin-top: 22px;
    margin-bottom: 25px;
}

.suggestion-form input
{
    font-size: 16px;
    margin: 0;
}

.suggestion-prompt
{
    margin-bottom: 12px;
}

.suggestion-prompt, .error-message {
    font-size: 14px;
    line-height: 17px;
}

.suggestion-prompt.error-text, .error-message.error-text {
    background-color: rgba(101, 105, 107, 0.9);
}

.suggestion-prompt.error-text-engraving {
    padding-bottom: 0px;
    margin-top: 6px;
}

.action-container {
    margin-top: 8px;
}

.action-container .suggestion-form {
    display: inline-block;
    margin: 5px;
    padding: 0;
}

.action-container .suggestion-form input {
    width: 132px;
    margin: 0;
}

.error-text a, .error-text-inner-shadow a {
    visibility: hidden;
}

.error-text-engraving a {
    z-index: 1;
    position: relative;
    top: -1px;
}

#help-button {
    display: inline-block;

    width: 25px;
    height: 24px;
    vertical-align: bottom;
    background-image: url(data:image/gif;base64,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);
    background-repeat: no-repeat;
    background-size: 25px 24px;
    -webkit-user-drag: none;

    margin-right: -35px;
    visibility: visible;
}

.error-text-engraving #help-button, .error-text #help-button {
    background-image: none;
    visibility: hidden;
}

#help-button:active {
    background-image: url(data:image/gif;base64,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);
}

html[dir=rtl] #help-button {
    margin-right: inherit;
    margin-left: -35px;
}

@media (-webkit-min-device-pixel-ratio:2) {
    body {
        background-image: url(data:image/gif;base64,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);
    }

    .suggestion-container {
        background-image: url(data:image/gif;base64,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);
    }

    .icon {
        background-image: url(data:image/gif;base64,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);
    }

    .reading-list-glasses {
        background-image: url(data:image/gif;base64,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);
    }

    .error-title.error-text {
        /* the position for rgba(124, 128, 130, 0.9) needs to be the same as the line-height in .error-title */
        background-image: -webkit-repeating-linear-gradient(rgba(79, 82, 85, 0.9) 0, rgba(124, 128, 130, 0.9) 24px), url(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAYAAACtWK6eAAAACXBIWXMAAAsTAAALEwEAmpwYAAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQrAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAArntJREFUeNpsnemW48qRpAM7yCx1v/8jTkt3rySxY36EfxYWLGmOTmvurcokgVjczW1p/vz7r/u6rnSeZxqHMZ3Xmc7zTE3TpOu60jRN6b7udN1XSiml+75T13XpOs/U93267zu1bZu2fU+P+ZG2bUvHeaRhGFJKKV3nlbquS6/XK/VDn7quS13X6Wet65ratk1936fjONJ93/q7fd+n7+/vNI5jalJK53Wl4zjSNE2J//B5zvNM6U7pvM40TVM69iM1TZOO80ht26Yr/u48z+k48j9r2zb/meNI6U75e11Xapom3Xf+zl3XpX3fU7pTmqYpvZd3Simltmn1Gc/zTMMwpOM8UkopP8fzTG2bn+Ewjvqd53nmn31eqR/6lO6Utm1Ld7rT0A/pvMqzTynpM/K/U0ppXdc0jmNKKf/dpmnSOAz5s8efSXdKTdvo72zrlv93k9JxHKlru5Sa/Pzapk3jOKZt21I/9Om6rvwZ4//yfbuuS8uypJRS6vp4j3dK/dCn+7rTfuzxvdu0rmuapzkd56F10bRNapomflZ8l21L0zimlJq071saxnh2TZvulD/bvu/puq/UpCalJr+npmm0To8jP/dpmtJxHPmZxxrati1t25a+vr5Suu90Xldea/uRuq5Ld7rTcRxpHMf8XWMNXWde+21KKQ3DkB/QvuWFlpIWiV7glRfiOI566PHs0hmbZV0XvcjzONO6rvWiv5MW6vv9TseRN9JxHFo4fPnjONKyLHoQd0qpbRptShbReZ75d1y3Xjg/j+/Cd+TvTtOkn3Ee+WC4ritd95UXZpPyyz7OdF1Xats2DeOQ2q7V52NzDMOQpmlK55UXBhtrGPqyeY8jDX2f2qZNbdPqeaU7VZv1uq58GDRN/rxdr993XZee3TAM6TzLZ+Pfc1Cc55naLv+efd/1c1lkbdvmzROLPjUprduaN6xtuuvKf56Dk83yeDyq73qeZ1q3tRys56XDaRgGHQD3faeu7VLTNmld88IdhiHd9532fU/3feu/HBD7vqdpmtK2bmk/9rzB4llxoI3jmMZxTPu+p2EYUtd1OiDbtk3jMKa2aXSopJTSMA5pP3atCw7yO+UDn+fS/PbH73fb5hfXtE16vV76EqfdEueR/3fb5dPhc7eyWJ/Ppx4wm4WXy6LiQXNat22bjuNIx36kYRzSsR96WTz0vu+1INYl3zrXfWmxt22blmXRn+MEWdc1PR/PfAvE72zj9LqvW4vlvu/8fbv8e1lM132l67zSMA6pSY1eXj/0ad/3vHmGIe1bfnn7saf7utM4jek6r/Re3lr053mWkyqeTdu2adu21LVdOo4jPZ75tPXbMaWUzuPU50x3Kosp5Y0+z3Pa9z2/5Ct/l9Tk3zGN+ebjHTRNk/Z9T/M855NyntJ1XmnbtvJs4ufP05wX8LFr4XGD8P66Ln/2fd/TOOTveqf8Hbnx+Xtt1+oG5YZjrbC5+77XBty2Lf//mzat25oej4du0OvK74bvxKHOTdmk/D5SSvkCWLeUmny75ks2P7smNamJ2561poOLF75ua37xfZ/udOt/8wC0s+Pq4SHyRVgor9dLC5ENxMbQn+V2iv9c55Xu607zPOtk5ybgZfL7jv3IJ/c45BdsJysnaNM0+WW3beq7Pi1xs3Eqtk2rP095x4u5rqtstPtKXdvp36/bqkW577te7LIsKp+maVLJ0bZtmqap/N44CHiZ53mm+7r1gpq2qU5vNlPbtKnru3yIpSZN05Rv/WlMwzDkZ7Tlm+K+bp3sLCIWydAPWgTTNKVlWdJ5nen753fepPGe+W5N06R1W9O2b1rIXZefx77v9U19p/w+7isd51GVrSz+rutSkxo9d/7udV1pXVfddrxrbph05wOLw5UFnFJK4zSmfuhT0za6hXi2tAWsiTvlv0upp3K/KeU6FQnrrvUFzKJq2zYNfZ/LgljUXZ9/0HGW0ofFpQ+RUhrjCzWpSY/5kfouX19cpSmltEVN7w8jNUkv5rpL6TCOY5qmST+DzbHvez4R+PsppWPP9W7btGnoh3Tsux7KnWLRTLnUaJt846Qmpe/vby3K/djzA0wpdW2bzutUH9O2uS6+rzsNfZ+mcdSC8TJiXdd03ZdO+ybl79G1bXy+Ji+ettNL8du16zodNl3bqbbnIHi9X2nd1lJuxGn8mB/5PbT55+9bXjDbmkvktmvzjXDlUuf5eKbn85nGacw9Rd/pZjv2Q2UHB9555mexH3tqowwco786zkM3atM0sXaaqkTklnm/36ntWm3CJuU/33Vd+vH1Fe8uv0ueXbrz59r3XYt4Xdd0HrmMvK/ynlnH9IbPxyMd+5FLLbu1r/PKvUjbqc/6en7lG/g40zgMqfcFNk1TOXn7UjuyYznVOD1Y4Jyc67Kkts27koXlzS8LiZtpGId0HmfqxrwI6F2u89JpwEPn4dz3nbpUXlqXcqM4DENucqnvU0rHcadxHKoykNOFUurYS03PBmzbNu1R66dYvNwA933nMvA4U98Pad/X1Pe9bpx930ut2yRt8nVbU9d1adu2ONl39XLcRLpl9kNXfBOb6TiO9Hg88s/YNy04TtQm5e91Xmdq73zjUBanNhVAYOeGOnNjvOzV7+fdbNuWhn7QpqckY1Hz2egdvQ9SDZ9SOuL58bm/vr7Suqw6DFnI/O59Lz0r7/48zzSMQ0pXKc3pzyizjz1vXPocL2GP40ipie+e8rqj2uAGvs9cGbxer1xaznOUhPGFrutK7/e7bIY71+ptk18Yf0ZXZVzT1L/xplMfJ1Hf9boa2fX3Vcqq75/f6fv7O7Vdm/ZjT/uW/3ueZ+r6fBVP46TF7b+PBzjNuf/ohz5te27irvvKKMR9qWYHjaFEpDlt2ibX0ueVhn6oru6u7QQysOG8TOr6vKm7Nv99mlhKIg6d88qLlp7ovq90XfmUP86ywLd1UwPPSc5B0fWdfq9Qq+hrMnLV6HZ7Pp9lcXS5Fr/TrdOfkuKMW4eDggV/X7fKNRbcfd/p6+tLi4+ylo1DY0wpeh4BqrRd3KAZUZumSQCCepf90C2be6cjxX7V71jWJW+AQAnpMe47l6fXWVBYUEd+7rquKqsfj0caxiHfjH2X5sec+687/v/TnLq+yxfFvuV36TU/p6d2XV7zuiU48Rx9oh49z1PoRooauGkb1XN9V26hfd/zqRvlFwuWWpJTjD+377sQNl4CfQ91+jAMOrlo3u47v2z+DqeG+oJo8FjsnP7UrPM869ajqWfh39et33Ece+4PeOmB3rCQt20T0MHtkkvSRogdoINDzfmmOtTPOLTL7cefP45866zLqv6NTcn3bpu8sHRTGpSq0ipupVwSdvr7x34UVPBO+d3FGIDPy/8dp/xOtn0T2smh6hVB0+QDqu1arS02mq9H0CXvJ67z0tqinD2OIzUprx9txvhdXd+pNDvOQ8992wpyu+1b9fybpknNH3/9eYMDH/uhRU05MQ5jPnnafJ1t65YfSjRAPMT38k7TOKXjPHQSOyRKc82t9P36FkrCA7nvWycxi6EB3biuNI1Ter1fGS4NtOU8ztxXxLXLi+nawMoDfnXcnM3FjTgMQy7BzjMt66pZBhDjdeUbIt0F+cgHQSlPQUeatlFP4IgTSI9O+/sWNJ17vkFgBC+r7/t0qzy8tVCuM0PRgA3Awtu2qcwBwkx30ufd911zBJ4XQMRxHipz+I+XT0O808aAlivqfiDyJjXqjRz94vCgXPKmuOH/E8/vvPJNIJQz+hiQueu+MgoVN0jf9Vrs9HNd16Xn85n7yZRvS74bz4eZFUgl6Jsfyud5pua333+/p3nK12pg2vd9p8fjoZfI4tVit6YVzFvQ7V0eMr+QssOvLr2MeIH8zPsK6K3J11eTGtXf1JKUbo5o0KRx8+m5G4wMSuMvaxiGtK5rGrhlWAipUd/CywRGPc+8KXlWfderNHI4lpLFT9j5MaflvehQ4LYB5r3u2OiBlFFrg/DwHYYx3wL7tqU7niGLz+F5nks/5Nv6ugqc2zatTlNuToegHYrPm+1OB/OqtkvXdaY7DoDzOrXghnGoGuExwAw2PfMNDlhmT9eZS1hQQEpD1pmXVvw3H2Rbfm9xCPN87uvWoQHySqlZZnmlbOTvqVpId2qnOH2pC/u+T/M8q3HiWmq7tkzTYxFv25Z/YNS5Xd9pQ/FSefhd32lXatIb8OadbqFc151nDEyHhUhcpxAkavfrujR/aLs2AIWugoqbpknv91t/3htSXmA+SfOtQh9GH3Mce0qBgKUmn3D9kJti3Q7Rd23bpimsytIuDxnvdAvG7fte/QDIEwtffctxpqEfNFsZhiHPYtq8AIe4Xc6rlIldfHfKX9AwLdYYhAJvnlf8jtRUv89LVTYe0DwAwnEe6eBEb1Kaxin3RQGh0rdO85TXTgA867oKOXKomhKyaZq0rZsqCW4Yvjsbpmsz7J031KAy6jjzWr2vK3Vd/mfDMOS+tskH5ziM+rnzNOv50b+dx5neS14zzd///H0z8i/oT5zIQz5N52lKe/QbmqpHI8mpLYSqy3Xjsi7WmN4VWsND4GTjNODk2rYtJYZk0b/se0Z/Xq+3EKPrutI8z7nutqHPdZcBFvCdmv+4jkVXOM7on2aVENuWG+Z86gYEG6hK0zTViUNJCTJ2XZc+C6Vc3/dpWRZRM8ZxTN+vb6FfnFb8TCa7wN/0MVAtjuMQgAHKNI1j2qPMoIQ7j9wXbvZut32rQIUfXz+iFIl3Y0NTeo/8HboMz8ctwaDwvq7UBwroDIx923XoTuMkCg23GoeH4O0r30J9l9fROI1Vqa+SjNv/iD60KyiYpujHEfSZIe3HEbdYrhS66IVZmz68PM8zLe+lTNGbJvVnDJcoQ0o9fole8v16qX6jgT7PM03jFKhMOZk4KQXNbvn0Y9FQpnR9V8HHNGdCaJhunnmIOQxDuu48oc4o0VVNp3ng13mleZw1xBqGQYM/Zi/3daerufRwgHWpzFiI67qqxAGZmsapWgzjOOrWBK3i5NOLsFOdzfF4PIT4UEJcd0bTtjUm2tHeeGPLBhJdYmN2lH/HeZwCV9pxSOu25plPHFiUsdNYSg76yKbNB4ZTVqChpGYq8G6y4XGgSL4uWD9UJPu+67Dltud3D0Ov56metSklGDQgcerOS4caE3IOXjZS6VlKhXFdd64Sor/NSGLdmzapSf3Qq+x+zI/U05QwIXc6Bw8B/hUvnI3Chx76XnDXfd9pWZY0z3NalrhFoqEEzQEa3LYtdX2n/oJyqhF0VhpFUJjCPbpTitP8OI9crx65HOQkouwB8tz3XQtyGAfdIGwUn85u6yaU6bzOdG2XTnIxAK4rpSujQlM3pff7rc+ufofBKCdrIGVsliY1eRLftalrOs0b9n1Xeea8KzbmsR/axNM86eZlJtLETTNPc3q9XuVnRt/hrAPRb86MTi3Loj6A+RI3F+AGkL1QpOPWWnEE6jiP4F6t0ewP6svyWjrjmWU2QNPmvm1+zpkc+c5DaZVXjSOsjQ5eykH+3dAPqkhgP7CJUxOQfUrpsj6r67oMEMStfd93av765+8bRi0vFTamIFM74Z1i4UPCIwY8sEGdo+MNn4hz0QPQwH2S77qu0wmuq9mYu4Kcz3IN+4zkiH5niBOG0+/7+zuXZtMsRIe6OqWU5scsmJiJvoZahp45MnWep1jC/LnzOrWZcjOdb85pntK6runr60sLFkapU1L4+cCXLDiVBdEvjcOY3u+3hp0QKnmf67rqmcC4zUTI3If8/P7WHIuek+EklQCkRXpEQBKoIzwnH+JRMvKdPqsFFjso49AP6nUpSxlWnteZ3u+3eHdeIvv7AdqlAtj3XcNjkKtpLBxCL8/4/JReVDrtsizp8Xio9/jkNVEa+EtTnxLMWH4JSAunA/+eBUrNvSyLmLksNvHA4rbwmcdxHLlUMGIhp1PFtdH1eaUx+EpsdpitPHw2IQ93nueKN5Qao980bYW+iEFwlGsedkFF9Jvn9Hw+taH9Bnm/3xrusZg/SXssJg1iAy5vUmMT+UvzmnEcU9/l+dK+7ekd/VrXdaK7O5Ln1QMHFt+Dcg2UxzlX3Fia4gdax815XXkT0ft5FcBn5Gb278xm/AWx6weRYymj/LCGjpTXVStelg6NILKex5nnXXFIcLj582f9Zh5fl2HeTFVfNV32G4DTZ9u2NA6j/hwDJr64YEmuMSN/OcymUg1MGj1FUFtEFWlimh39x3nkm+r9fqv+5qSndp4fs5rTjGQUVEi3S5xIQ5/1G8CyGia2ZdAn0l7KL7NrO52M0zSVcinKHUpANBP90IvuAYSb6e/Bl7IhntDBtik9QSBYfd+rZACcYLP1XQY6GIi+l7dKBWp/5i1893SnQmCMg6xtWlExeP4qI4Oi8ghOU9d1+USfp8KW2GLIGjcCh+o0TRXPDyiWd8L8p2lSesWh4TQRnksfvUqTAvXs+3Qcp0qscRgFhFD2NalJy7qkr6+vXCWch+Z69NR8Rw4b5mcAGq3Yq0NBsDjt2fFHIAHOjWFzQH3ghP08obnuaYZEyTaold9xnhlCBRYEW+dkfr1faZwKlMjvoKfYt70iUDKYY2AGzEhZwGAKWjx/h5OMlwMs7QxjlZaUkEGmo6RhMXBl88K5nTh8nK7dD/DA9oJodX11q9DYs5nvlHs+IHQJ1YKS738PbhwLap7nLHCD09X1eu/0GXxfanJOcH/ePHPvH0GUQK0o2zQDuVN9uwQdhE3DQgdGR8eiNXGeqYtZjvc0wPMcAvQ8YnPEoSjUq+1UAcDYXpalzPoQAonTE7+Qk3p5L0IkfN7QtHl3dn2nk3KeZtXlLMq2zRwYNpGr6tp4gOu65t0d0B4oCbcJE3iuVedXnVd5mRp05pG3PsO6rBkjP8rJAbGvp5Ts88OapknkQG4BcaGihuVFL0t5NhpAdW16PB/pTrdEaDSFnFCP+aEhV2qSblfKnufzqWbSiX4AEWD73CaAEIAT0FZgpbZdq42j2/7Yi7YjNhq90Hnm/gnRGLedf9e+y3QO/p0a5pQBBJXM0fdIBNUkccR4r6lJ+txA/5Ro4pzZd+U5noFu9UMs/OtUv8d3btomvZe3DiAnkX5/f6vyQXYw9EPFkmidx+T0gk8GK9Nuyo7jONLz+aykoZxGaj4Nv2bTiPIeiFaW75bf48xXbgL4Rf7PqK1hC0NJkIhpHDTYBIVzGNA1KvM06YrlBui6TkMkYGKQOaa5XuoALfIz+r5XeSSeUZRv7+WdN2FsOD956U9cs+A9DHApn5Pbmj5k3VYdTBxmXduJOwYV3qfZvLMpnhPPa5qm9HjMKn2ZuTRto4NJ5WRv4EzwnpzSw2Z04qim6CmlZV30vynjeWbcaK7kRGTWd702JINMdEX8Fw0IJZpz8tSkd/l5sdFUHf31z9+3KBOx4538pZLlznwrX6BeL25rLrWmedLDWZalGvFDMgMqPs6jwtSpGxkAOZyqejWUbZQmw5h7FwZnavrvq9rkTrVXrwEtxfoFrnDXQVB68Lulsf+oY+nlWLSgKRlVO/S9WJg+rGJQNvQZg6dnYOMvy5KVge93Lo3gasXhBaK0rItmHf7ntnXTZuFnUloJ5YoFRv/GfIkFtC5rRcVwXpnTVtwvwId7cKh4F9d5qTIASRynUd8X5E3T/AA1QKaoGDjcNCiOteVESjF/Y36G1n2cCnTfNq0a+/3IPLzm75//3Nu65V0XRDjqL0eHxOo02NY137B1aXgdg16WJYtVulyX36mQIHlwNMZnNF6fk1OfknPde7OuYRuU9KCjgKowB6D0Yl7iZD6uX5f5QlBc1/WXiTCfnfKUhpaXw8td1kU0Dk2a43Zx4wvnbXHSM7O4rkvsA5CvT3iS8pNBHQuAvgXKz3nUfCQWrprUAD3YUP7e2eRSRqamDFujcnCDDzYBZRkziWEYhKyx1sZx1Abnd6Y7Se7sm+44j1wOxZo6ryLDYJ7iqB3vVGhhvLdpGtMam7XrOx2cqCjbfEUWqgPCpeu8tODchQQqMVPOLkoU6mKw6jMgYxRhnE6ieNhCY4K8b3tFaGNhiHsTeDmN8zDkB4f2ZNs31aPAnSy+9+utUuH9fqtvadpGtOx1W1Wi0YfB65mmSaUVdAs2D2xi+EDTNInAeN9XmgPqBv0bxiH3ZYi+cE5JgS4xJw1eF4PB5/MpJIz3QDOsk75pK/UlNzSOMizovuuLsKgrQ2Bt9DiEZLARw1g/CHJJPKTOQA1kzhhUwJgYx9xvQfcBNGmDL8Wh9pgfWiPPx0PfgVsBwipgBuhZNmZodfs6UMMzppwFILjvO31/v4o7SpRq274FS+ROze9//nEXNddecYHmeU6v96s6xaW9HidpITJnqKmGTXl4uKdxmkRfOI5Dt4PX5fu+aSoO/Fjt9sD/aeacmQtyQ08AzMiVL4pM10vzMU+z/pz6n4CtRReJkqeVxqNoqmm4pXRjRmHiKm6PPRR8rbm19F0fE+MrDu+m+vwOIUNt58aUZiT6CUfzQGKkp+j6Smuimv4qWhQnAPpMAvTM9fmc9m3b5hKz69Mw9KmLZ4zxxjiNOgzZENwubddqZHCJUFje6b5laLqVrvwW3N93NfzsPgjTWCQYAnqCL0i/JT3NumnDsinELIhJPgPs1n2M0C/gdbSsS3o+nhWr0suWjGJlmomE8iGA2mNzwJTE5odFqeHdsae2KycIEB//4QT0etc3LAxOd+zwCTbXPD5OX8+vgrrQb8WVzxV7ncXo4A4/Lm/yKcVEAzmt/j1zKcRnmuY5dV1fiYWAt/VzQ3YHsc+5TaL1B5qm2zOoMhWrte+FslHSndcp4ZWYwiyEdOu094YfN5Bt39Lj+dBBM45jOo9M6BvHbJZwwZKOSoHybpzyTITegvKR0ozPsyyrQAesevZtT/txpDVAH+YXVCFQiu77rug9rBdYxdx055GZDs4jc08vd2ihH73u8Cf47Y/fbyeZgREfZ6ABsYj2bU9fP760kTjRHs9HoaWcZfrJB/Sr9zov1bUMAuH8e0NIWSTtxVAGUJzMXJ0uq2UQxrAQOgcQoV/XPhykbubqv+87rduqz0TPQiPnAzz6Ik5damENMOO7aUprN4HbAVHStF0raNW9n3ip+7ZLOsCshRsCkIUDZhgzUZMJ+OeNQ0mGDgJyKRvCKwJQQ34fi2nd1tzfhZ4IMifCO/obThsafiye+K5oTvZ9LxvMputqsO39pTv9YlNED8W6AyljlMH6Gcc8WPSmnXfnOqFW/lBNq1JIDhnRzGXqRlF5wSlCFwHEKbTKGiTg0XQn1aPqd0wfAhLCPIXTAr7Vvu0irjkVhF7lEyrth14a9WmaRHuQSUD4QDEPOfZcHjBvEGwZWmkcPJwUKHZw3Kpd36nf0tyl6wtJMk56X8xq8s0Ujx6h4kfFfGGaJhk00D8w/9C7iF6BZ/N4PFI/9KL97PsuOgc9wOv1Sn///beQRQ4g77nYwNue9RpM3pkzuUoThrgoR+OkIfBxHGmaJ/mA0TcxeExNPvV5Zl3XiWNGD0d5yNzGmeY8167t0nt5Z1O746yGmMxPKgQx0FVmc13X5Uk6wxrHilPKnBufiK7rqqvOCYQueay0v8bp4rRlobF5hIgdpyDRfd/VlOtFmvsgE2dJVbdd2L+feJwMy7JUGg3ERdjuOJnRHVjYbKnJFjpbuAHSG3DyDsMgEY7PkDgsdPoeh0AQylB+N6gTZciyLnqp3Fht12pq/vX1VS0K+YMhjzZjBWZOmBv41Pv1euWaOwwP4DJBb+H5bNsmcGOapjKn6IrBBJs9C80OETGpFABbfF4Fo1tsgeC33SlUrXGYuouLu35KbDWM+vd8Bv6jAzR9sDlw8mwbHWReqseaKPMGpqHXnTt5GhhOeKa3biQAx4aHBqtSVGjj5J9XtiMtGoarMlKjJmzaRu4kfktgF8kcY11XnfZQULpw0hBxkgeFG2GqpcPOEtb3ipsMzTZDN4Zxd+hS7nSndVk1I3q9XzrZh2HIqNOZodNlXSpTs2VdxHz2WhgaCJBsxfBFwx4bhXrfQQpe+H0VCoq7MLZNK/110zTpx48fYr6yobhlGNiyCL9+fBXJbtNWKB4nfz9k6HqaJ/VVqbQIOiB8Yn0ep3QY2IvC/1vXtTKP4L1DS9KGiXVwXpk5gD8yyNVlU3cm+/xuSnNuWOYhbdsmKfRVi8Y1gwn1OIy6FdTExG6j8WWI1TT5uvX6Hh4Xo39qZOpcfieTWm6wvuvT1VxaTF/Pr8qZBBQGoY87UTAVdQUjjV3XZtoG/C/dcF1+qdAUmNdw6shKtStm0E3b6IFzMIi8edemyCBgbpt0nmdqukan/HEc6fl46lR1PU5jrhvcrlA3XOLM79XpfpdZkdjOYdSAwQI1N6YOsLBhxFJuccIjIXYJA1wn+kf6nitdFTsZ/lpqUxq6oXDEjpBtQ/GP5+8Mb3rZcRhlJyWyIczdoEqtx6oN3LVdSm3S2nN59zAO1YBzGicpY+90p9YdHHSlpxqyfX2/0rquktv2UW+7jSU3zzzPmaIRVpTzNOcGMDBqbgb5zcYtQ924rVvxQoqxPw4VXM/8+7bL1yZcGgZw67JWGDj0EARUGmrGS2UDI1xClwD9m+Zu2zfxm+i7MjO52H/CIZLENqgT0B3ox/iPaPxxKLAJXEex77vIfDSmHDw+eMSogO+DBmV5L2WudF/iZ1EByDp2HDQ/er/feTL/XgSxA0OLThOzFdYF0/HlvVSbl5nL0A8qTdd1zXBzNOh5kY8qVymtKLe4KRnkuQRhnuZ0nldquzImgJWL/RL957ZtRVgXvRKHOehn0+aS9jiOYj0qARR0i/A+apomN3l9IcEta3Hy5rpzDte65S/vvH4mwjSZrrrDpM6vc8o0RD80Vpgs+Jdiwg1UieOHswG8J+IBItJxgqUGdmaPqnnBkRtTJ3fCEHbqCETFYz+0UZDuiixnzb9Lh/mekCfVf8WCEEJm0ObQDzqU+qHXjSG/2lhgqPrcbQaJ9X7susXkC5xuDSNB7/BDdu4dz40qgL7s/X5rU/rsAn9hvLbk6B8l73Ee+n0yFQ9Qo+1a9cb7tqtU9lgN53zB7vD+kD8nb6x1kwSZpl3S6X//9p/bdRYsWqcFeGPHlQrKUqxKIaglISE0P5wmWJtyMlb0iniZ1P2UQMCElEn8jPM6VZPDwgXO9QfrZU7f9yoBHbp142oN0MIlEgvS96v2k5UbYfz5676KaUVXdA/HecQD70XTHvpB9qEuHnKQwOn03Boyu26byrRN5nF7gWcp0+CDAUKAwHHofOohHFpVdAFlXlPYA8dxiI1MSU55zoHTtbnS4Nld4W1WSXdTgV3P40incaqWNVOUQOQczvXemc0BiODeXhykMAigoYCq8twgLvJ9WDetO6r3Xa9T5rzO4qARDfi2bTI1lhR06KsbCD0vVBInPOo0jboSmjuDOv6ejJqjDkVFhwY7L8ySa9L1nfIpzvNUY8cic6UgRhBO8uMwkIYlUK4mPve6rpU8032G92NP7+WtkxAahA9VJUoK5A0RmJxEmuIm6TOg67p0KAgACTIohL37ihCipkheQbya1OjW9VvDiaP+uzynQ0ZzFmGhMhvumJVBUIB8bnGeZzbgNsSLheeVizMmmO1Qxfjsi2fMTYthxnVeWlusZ3rqT0Vk0ew3Epnh28u745ls25aa3//IVBPRNsahonHI3vO6K6cLKBBQBrTwUvGnBU2pmMFmCtZ3vWrwigJhTbdfmTSd3EhOnZDLXttU7imQJZ+PZ4EKTYXmmnYnPHK6kJ/ByYOenSgEAAYndR77IU7Wvu36XlD5WVA0xa4s/FT0EUvgnDhO767PUtphHKRLdztVUCLqaYZorvhUVsg0VzqZHz9+yCvZWcyU4TjscwCAeObwoAIKuJk4vR+DUmB0SlQOQZd3e581DPnmhbJyeeIYrpdWAZCY5YeDC6S2fZNojA21bmv68eOHyvfm73/+ubEUZQcj0HHIln7CF7CE9m0xnWPBn8eZpnkSA9UNEODNeP3J9c+Xg9YA1CiXxKaUefQFbVc2mJ9UXK9eVyKJ5baifNDQ8k5aoMeeHR0dLv5vHl9ArO4NS1lAGaZSxYiNmAp43BtQM5R0UVyiv8Afy00RkATv+14OAmNKs5j8IIBj5Raz6NGBtd2+VUhSAAy4ZDIXk7VSbE4fHbC53++3AI1t37SwJcLqe607bg7K2k+Th08/YL81IL9S0VACzvNcKWGpCrImaNY/A7277zs1//z8eXMtk5sn/lKcGusaOoB4OJX1qD14+RtF7SmUIG6Nz2uVMT91sde9nPBAkixgSgeaeh8O9X2v6Dc5ddxlmAZNgzmJ7Ds/8kr4bG1wnTDVYwIMasakmLIUqrwo3+blu22bSiV8jhV2cxU3yWyalyqM36XP3gPR8wzjkPlR0yhbI0rV5+OZUpPSz58/y4DQG1aD8P330fM9v55ysOQdZ1vaK113ObEzNfkOKt9dDUIpx4T8nUd1MPk6wsmGmQYkU3pZtxNymYRLK9yQT4rHVIbElOlwDNH0K/slNEbDMKS2SvVJxTHCYV5OUR7Qtm6VFoQcQw/FLHb2Z2XgzKnItJybi9q0ooNE/JlsIGMQ6GYQ8K64Rrk5fFJPs05TihsKyI6nOWnaHq6OsHghFH5/f8tdBb8nWbempq7xw2eXW0keu/dVcai4cdGw83KHrq8cYtz0gtucuQxlDmwITnmiA6ZpqnQWLDIBFccp1IybA6jbMwNLebJXM49t29JxFdWha1Vcg665WGwgKghHEnHbH4dRnDfp4PddJaOnTjlKyf+GJuWADf0piKri1kK4lZqU0bf4MyIrTsMoBAHx+mCWklMsIBwIHbOvTl4zIeAkcS04/84FPsClmmek0li5SIeNRd2oXI2Y4ubNE3SKqMdBSnLAz1qZNjvdHSdDbiw3dRj6Pq3rpo3klkMQPLEpPa/iXKJEKhseEoPmRhUM75ir0MSKl4Q/cpz+vFA5nVyFdeDNLEgQJ3deiG1mF0d/iF8wnCd6Dr91hZYFm1j0kCBA5jTXRgeYoOJpTK/vl1DO7Dpfu6p7vyJia1MyBgXHBoXGKU7u4TbPs5zhKeHO80zzOKXNvdxsqj8Oo8zUcblJd74mhn7g8MqCoP04KtWYnNdTkTG6VxVQrCsHncrsDdY4jSK48cXYHNxAr9eryoi40y3PVDYTAzffHCTS7tueeUUp5SjkKG/YOMt7KfkXH965lWlFW5sIjMOQur6Xbt1zLhz9CYv1kj94FUsah8k5cKRjiV6Cm9TN4rZ9k8MlxhfMLajd/5slbF0mtmIA9EOfB44hqQXhEiIVtxkzAefWgSoCtHgveqfiDiMbzzANR4TlUX3Q7sXdCoSM8tzNHoaxWLkyBGQDOrVEeh64VmGOnYxtwQ3KbGfbNx3KHIyYpvNe2ibKiHVbJcZXAxhU8pzgtKch0CwP0lFU7zhluknQL47zUHoPtOq2bdP8yI6GGh5F0M48zRV1nGubupJrWcKi4OIwgBvHMQc6hr7hOI+SdhQm0NSrVbhomCBk95NiHAC36gjY+LW8C6/LbHsoLd/xd31q6yxTYgBwD9n2TZSXpilhlBlebrQw0Mq/vl8p3dncgBxFOHOfAAJ8NKgVsBTSnafOlGK4tzghFB2EJxDn2zvbmUI5F1Bj8yRkzHe6xW2iV9yPI7XxnmB+e5OMDmYYh5JFH4c3tw9DVahEHABd2wlxg42NOE7hpMYdXJdV/bGXtHld3KkJ1kfTNKml/GEqrnE7J9/QWw76qvkGzZX/WUFjyWxHmyZdZ60XdrcKFg/evJyezhtyLbcDAaA5yhtviqUQi8MxeAcCmJd4ZmJnHlTTNImcyBwHOWZlih1NJCe8zM2MX1VZqUa2uvdbdyyu9/tdlVOwhtuurXqkx+OhoMtK/nsVZ3fo2pPdfCx8QbxxAGaqxlnKG3M68di3BgQxykGGvsr5o+m1nEN6UH6O94K/yGL7wpoQBeUuVBBQ03EcK/kCFCcOSt/wHlkhGD4k2QjUWotJ8Lz667xSCzJFfNrQ92mMa9zLELS/Ho7DpiBrQizK8KXNp2wq+Q1ROnVt5vcT1cWJwJd0m9K2zX/u8XxUTe91X5k9exT9CciN+9dSZjld+jzO9PX8Ej2DUlBmBKm83H3PpVsR4ORTjf5jnLLt5ev1UrYfWhe4RaCEnLb+333bxRz2k78PSxt5at2F8Lmuq24Zmlf8pBCjtV2rCGdP2fIS1/UdNKsldXbQ8DjHOxci6TiOJZ/RBHG5zs9+BKwLFrvLdWFjw+q+7zuzf62hlw/Cdafv10tEUNai+paAx5XNEtN6R1nZrE2bkVE5O8atKGIl/WO4y4T0N39AegAWkv+H3Y1sdt92ha58jv55Gfq7gdhIhWhxvm5x6pY7lbmcEczc9Rz+zDRP6ZNP5tQVbwAb69A88xz8nU0sR3MTHMGNyv3ZUOWxv14vSQGAPN3G1V0bPZPdvYlZ6NxW67ZVybugf+lOonJ7s8qQjGwOZklyPInG232pFCPNTIFoN/OqdRESNzK3BjOd88wIHDdVigqCQ9Z5Txx455XBANH25Yfby0SDBhxCqpSOoRtias6t5KpU1oHfVp+T9aZp0j8/f4pDxrrBXipmK00d/nKnjNhEDoMLTqjlqJVdVIRWmP+4KZcPBaEXq2aNUodsD36PPGzjNAOdYhEimnKqBqcn9Je2aaW0Eys0pvCcFBARnXdEne/GaiB7DQhY9FS4c2BWTaOHPLVr2/Q///M/aegHDQU58YA0QaqgwgxjsdD0WQn6F7hQJLnCi7tT2OGMxXjaZc8genhPKRpvnKrsQG7iaZwEqbp9qSePScfeNKH4LIrAfdsr18J5njWnYk39+PoSzEwwE2vHtfgy2Q5wCC4bGxGgw9kRVAxw1BocXM6jmvf47Ql8rANEpLdAMLgO/S8AWTIYA7oFWoR965QATTIDbUEe6XEKvvHwYcoB7mM1uONEYePxxfc9n0Aqr65iQCEnjBDgi1ofNyRNM5JRZKFAv96EcxPRdAJDQgMXGyDVud9ZN5HSHte/T8Y9JWmapmIynZJ+l6KrobzEM0aKioQ1082vdGBZFOgTt7UGf5YHook3gMmdqgRhQA0Wt2yDmhKy45R8Diz/Wfpd0Qcs70Vok3oXex5A6B5zzc95vV9VZjs9sasyuZVI6KU3I5quYpcfxy9+YrhEskav60rNH3/+ectk4TzlMAL3CIat18/g3ZzCsrg5ChvXSXpowGXMdhSnDU5ibgNmKxDJymez5Ni4fn1Ow6ZF2snG81q7ivf9QGLQaZN228bE26kWQ99nHD/wf4wHtm3LE2scwYOe7nkaUjLepUGWoyD2ROG+4sIw/zlIWDmwRK5s25whHp9r3zNo4J/TJ/ae1wHiR0Kxi61cK0/TnhvkJm1h4wNjW6d22P5U4qoor1kjSGXd3MOpN/u+qycBLqZ6EcfM0gOoENx1U9KA+NnMm/75+c8v4I0Hgn4aDrbOpuwj0NEjc4d+UH0NnswvEEEvThtJRU3rfV+3pp8KkQwpqeP6XNnY7sgxMERAmLHx4UmsUmxyNGFumKaU2L4eMAEx8mDpvzJEnEsBxSPE5r6vKx3kbtuEed/2ipDJ7URZAiHRh6ScUgjIQAVhDsjEIlAY5ZFA2zZDjOu+0pXuauJNeZeapBsWXQinL1NlqPCv9+uXfpJhJtVEulOVQgY9RrB2mLrJ4uc8asPAaJKV+mQpyuQuMv/iJiM4BxUlfd8nB1Cf3eSy2EKROc/tgvDM7X9I+nKTxOu8UkuNiVM6nCxn1mIHybSZabeP9sH492MXZQW8mU02DqPQGnDm685UEhRtbDiQBtRy55XrX/U7gWODf/NnKaHOy9J5Q5I5RB0qo4SgKmRk7E5d16Zt39O6bSLN9Rhmu21onKQM46Y5Tl8zo0Yu4B5QTK4R8Mj5MBimig0ICg4JtOhLxmkkRFHpspTDj8ejuLsHBPoK18D38tbknFvVT9jMjMg30TgMqW0KHVxs5ZTS8+sZBhhJZSRsbvdBo5RG+8HidDIsn59N5EIzB4uez6fMLuBKscl8qPx4PNKPrx8aHDtIcpyH/LNI3qXswigc3RMHAmVqy8TYndJpYq770vXGici1Dt1AflrGt5c5dZRjbvVPgygE5bzS8/mU5b3b3PNzJaA3wwR+Bv9l+isY0SLjsqt6QcXQKtz3nZZ3zlPsTI8h9/cuD0gZBrrDPMgHYZxQOzAaqFjHTU1hpyF2kia3gw8Xl3XR95sfc43uWXgRJyo9jscue5YgGfPcbLCjPUCV5+Sm4jTxZ8wyPL2JwxDKDRA+P5cDRRERpuqkz9Ct35RkKJ+8z9NcyWddnwIyCrjAYeN8PX4X71Fu83eqYupgIfN7juNIzf/9+983NT7ogFt3cqXCcpQpQDQ/bqVJvDNDqXmaq8BIhe9Yg+okRBY0ztrAjs4pQt339eOrLlnOM9fFoS1RM2g0ciKGz+sswzMLnuFzstg53aix3clenmAxYHq/35Xj+SctXxqM0ECj6YbSTcITJtNuh4lFEciNb+TWRF34y45jSVFqcIZsmtQSeIpeJzhLPjMQ29pM/Xx+8XkYQm4ULyqMIFi0/dDLMd4hX9SUaDaU5IvwK3ouBfVg/EaZDAARo4HHnOOuBXenuzqoOeBYn0DUXAzHQel5Fp3Msafmz7//UvzBOIwVEY1r0VNugfbcKgea/HEc0ix/6tRzcGRwZ5qiVuOKlNYAl47w6Z3nTI0QyhZ9DfWvZiltm07zT5Jru9EZfKF71BZ9AJ9VTuSpoE0MKanlCQHFLhPGgRbZXacwueMisC6aF6jgLmqiTELzIp0LzvsxF3J2gzsEsnGOfZcvMOBHJVNIhXkrcVfTKFvRUS8OS/odgAX4dgjm1jW7UiLmUo8ZoAYzFw2TjbPmOg4AGDY9Bw23rfd1bdeKqUBf8+mugyPKvmcACucWPxB1exPn9tfff98gI8C2KNY82J4+hCEKHb8LkkhwLehKWfzqVYLC7CRHrlYm+uu6ahMoeWkr+eq+EFksKsXipGExciuCGMloOpzEgZD19wn+iY0KcrJvu+jWondwHbcFQiUnhdPVU7Pe77fgUE5BNodT991Jnn5HGX/xor++vsRRY3G6UR0vnmcjpu1Z3FxSys4zuLdjvgZc6/nwzAZERYl+0A81UDO+hw9CXccO7A9JkHcDFUZmha6/Hyf1qnwPoa1NuTF08LZd0TA1JUqPqkhG7XHoKbMlqiTNQXiI/dAr7Zb8aixGfTruJgGOqMii1G4b505VU27ztIJeQHPKoqbHIBWVk8f7DK7kT+d5NofscPqSB8JpyTS6mktEs8+mcQUgaj7KPMRPbgsErKnNFeiSdPLdR9ZGuqtYY6g8AicsUx0kh+kxC4Ob0e1G+ewIg/qhL3b+UctzuFERwCx2ozoiBtxsTyXN46HvqLnBXSN1x3GoGXZkkiEn02r6W+8fkCb4BvPoAoaJwzhoDND3eQ27ed55nkUuHf0t1CFHxNzEmnU1DENq4SpBTLuvO7ypkhpAb+JAvZq2EYmu73o9MGfKig2MHX+ksDon/zovITmcBKAcLC5NRM8jtTFZJ8ePoPqu71TnQstmo6g0DEBCmeQBq8pryf4dLwaFGp9/33Y5ljvBjs1IeQmCRbP7fD4rPhFGFBwEEAKddj3Ps5rQ8zirgaXyAz8Shc/j1Hfidhv6QWxt3hcbdFmWCgEcp1GbEIsl+ik2D2WUx8A5NYS52DRNmv6ziPn7MRCqUC31KMH3Yn6DXFdAg7m04NzZ9V1awym+clLse5l9swbmaS7AlGUWjsOYHvNDDPHzPLOi0EUrTuPw0kcWOsOophgkgQ8K9FpRpY2Xdd93ej6fFZnQwyWla1/XKslK/lkxi9DEk6CYgI5ZMNJgd+X3y4In/HRZyEx63QHRGzvZDxkDFgiZE9/jj+l9tJgjUxzlIdNfEBNJUo067/oOMYnvMuQTOzneE41xmV6fmgmJIBp1NvW5/JGD5UqfA4hBL8Qtx2Jik8sO1uju4j41v8avuXWs0MB4dygehW4Gu1bTeTPQc/cV/wwI0TwsVnqWo2Sm+KScm2UaJ93c5Khz87WcXr4Q6B1weUc0BSqVm+1LPKBtywMnKN+cXqj9PE5YiFg/pHVZlZRLM80Xp2SR2KVpdX26RtoXtTe7NNDMd+ifWAScGgzVnvND+P+Prx8iY0KUpAHs2k4DrWVZ0rqs0qrQl4AQ9X2fvn9+Z2RqGoXsYXTAvIeZiFvcaAgaswKeHQ0vbpQ+/S6ZhUXC68NLdBrndeYS5lNRaRY/274V6XQ8Yzf9oxlm2o+kl+a567IfMWUzdlF4A68W+Mqihdrihnv8big5LrDindPfUGJK4ntEmth9VfZV7pvgMmZSwRTj1jSpbVKJfqahhX9137egxSof3SC0fEIXvYPfFpRSLFzlNdyXNgZf/v1+V0xSZh/g7pye7hfrL5MvK3MEMkiMM8TwTlfrXXLdoaODnoGacSP8+PqhOAjoMO5P6w7raCw8caoaLpqwyhNqPScR8qS4RrFQ/bQGJQRmZQDoufSiore1myUNtixzomHlnSKAKyBJMAdiPXBgAAKwEZkfKQnLwZSAho/zSPM0C9ptmlRN8D0dl8Om0toEs4Jn4oRTwBbFUsQE/tOpkbKLAbejae4A2fz1z983TR9NJIgVGDdKPA/C8dzxzwgvIDOVWPedDoNKaa7gAjnu7RHLFepi1pP+OxhqgSRN0yQKddu2ORV2mlUK0ogVNisa7+LgQhkBD8iv7H3b5RKJ7y8b0nlbik67Sl7gvu/yzNIQLGBxboNpzJ+fKx4xEwAIUlV3BuFnKVCnK+GccoIJaJXJtlM1lMR0FXp9cYk5UtO0JXHLbuyKsNgViyXemWcnaogZA0QG0PuRpROfehD61yal1PV9Bfww3/KMFs++9CQrEEDPRnEu3vv9rjQijCcAm1rZh4Zoic3hO1HXJq4XfVf1Jl5zc63pejQd+DRO5Yay5CYWlIy/LD+PD88pt63ZFuf1fsks2TP8HAKWBxTGBanEjGFgvK5bGgIbd3o701ZQH2BrxElLSGwxvz7OoyrbOOE4AHhOnNxC8izHG5RINp/ImkMAhX8uWn2gSn9HPlDbj13Z9vRP82Mu7iHRl7jmxDcMQ9Tj2Cu/Mi3I4LvJIrVJ1aaTWVvXVUZ5rhLt+75Cq6DWcDv6c0AuwJ9VfjtKQcsPoQzk84GMEU5LFAflLsgl70fygz//+uvOV88liWOTGqUH0TRJ8BMdPouOhZuaItf0GGE3XqYf4KUiEc2662C0gqaE48SAScSVIVe36WGOoBIw1IUe9cy/R4fNy3QtCWWVgh/v4qRRxEn5d3y/XnnTDrm/4Kbi0Hg+nuHGXjvlK2Qo3fWJZ2Z1HD6YnEG2zC6U+XBaA1XkZHxoWHhV0WLKQ2cgGrMA0DJOTCFctqgqiyGzEiK3XWZ1lm85hTr0YrZwlIAcn3mpmabkaztlvyPqorwfpzFns8dB7QNEt4liUDxNU1rp3W7cc3qBO0zYKZ/gHTIvUY9s5V4rG/iU0hWnEkS9O9266pG6wrb0dB9mD8hnnS9FCfZ6vbRjeREo6KCZ+KJ9L++gKzTpiogshpBwZdxTiR4KCHNZF32P67rS/JhVJvJ3QMAwItDp0xTHcKbGeXNfIT/NIMHz+axO/8fjoT7AHQXlmNIVlqxbA9FvyH93nCoKOBsa5rO7HJ7nlfo+3wA+6POpM2I05i0Mg6WxP2rJgKf28s9lBBdRbGI6u1l1fFcEcq/XS+zuYRhk6iGdi8WMy9AOY7lU7IUITXIACFDgMT/SNE6SBTv36ziPtCxruq4yOhAUHcRIqEJOh1IE93XlGGil25pklgWvhtt0DJwkyuaOk0YNeRDWtFhS8SliOssLmh+zbqr7vtIRVqLcQLh7w0Tl9zqXSxrjuLYxP37Mj9S0jSSxHgXMycQ/H4Y+HeeZpnFMTdumdVlSaw6RXPFcxTBVGY45zOheTh4xB4uX+tnBDyVFJRuu3sU6k80PLR2aByWKKEBX3jDLsojrRd/hsQVSRAbEjbu/9xTc+Ojg+75PX8+nbvHB9BNKup3G9Hq9Kmd1eHVsHjYSrAoOYJpn9y2jhNKk22yPnE3ObbGbdasb67lAilZAh0WUofTMLklo1bRYKq2r7nigEtkE1XxZljKcso3CYqUMaJomrVuO+HXbHrTJNJwZauyqk4kBFTfXvu9pixmJ6zqoR+Xd1LWVxuTTNdFjpOkblkDglmVJ93Wlti3hNywY2ALwneQGHqerO7ynJgmdQr0n025cVGJAyUHi+XlehhFy6c73bJJHyHwpb+9wuaRXcg4b75XJOe+Jf+a+UW5e7rMyRgJt2xnB76jiMNCLOxkQ53Uo/K5th5HA+1m3VX9GwEDbaeQAfA0jmmpnjzUrE4a7+BGIyW0pvwjcnDHO9+a2bP7468+bQcqyLhlliDp8HEdRrqnRuCGapjYd3oM64EmzLs90szYPrPcT1zeLasyjoDBevrDYPDujyrGLeGIoC1DRmdVQBvAAQb/kMHidVfnGS+REhwLu4qmhzycticAdSrZpSj9//pTji5teNymlcZwU7cDN4rcRzSubS7Mc9BUxt3LFJLg/9b3Dnmi9Qfbw+KV8packXo/NCOzNzeJaoGVZshNI3wukQZ8C4okoKtN/+ly0qN5vdAhKERqH1L5vqbccRuD5rutklj6N+bvSEvC5uLGVpxi3Jc/5Mc9pZZPh6mmk0hbJp8Ol8s8NaE8JSyaiSk2T9rjaolXQKcIC/0SUGIjdV5gEx6nJfMXdNB6PR6UdcEdCuDOuuAOFgZRGTQls7N5anz9X8tM2DyNdqUipV1Etgrzn3+/TQbEP2Jh+gltMGvQew7spnWeNvgz9UIXjUAqQA+lsWg4Vz/XQjXccWUQU/SL9HwuRQ+nT/4v/MKzjfYLccYMrQcqCgFwwR43PWoAEWTLjs7TZ50KgX1Dx8/cqMRCa8H+47G/bloexcYhKNRm5MXfKCKgG0fEuvl+vioSpqAakCE5rEFEspJhOIASq8+Yq20OWpFia7uwm0pXQy7D/pNk6zjwL2AKCc6M1tyMVoe3KNSqQr7QWZyHVyaStbdQnUK7Ic7cvxtff39/Fcj9+b9M06efPn+U0CbapKPV9VxEbofhLGdh3Rs/JB8grwnUoMyBOHvuebhKW2tJDQPV4v99lU113tYHmea6Gik2T+8JxKA0xzTEcLEzyaD4//4NqkzKOhcZh8Xg8BI5AHAX2P3RQFg7WMBZvZDYeDjP5hswNVpYa3xWHS5Jc3NmbgvJxs3v0mouoPsEFNot6jghMcmMJ4iBgJUjr3japRcnHwhwDISC5CCIgpyZ1ODsRuJHpahkaFjMGMHkn77l/ryMICnInWKeraSiifMdQEXtJvyEwPeMGUHlhDuIuEvIYBeHyBFAaIqV0qzjtlDGIm8lRzPOQhyqpqcleXNx4Xd/nnmvfVWYoKfa6Rft3AifNqnodixnj+0A4fS/vtKxLiXoI4qL8lI3W71A0JavHOlzXldZlVUTAdV56xhpWBsyv9xeRGaU3MvvXvi7jVNpVkP1RuZwIMg4KCb2nZ5bABJc5dRwwcMhw7BfMbT7CHsvXNiVCr5UaLBbFFlY60ERw/vuMXVYaaLitA6+WJr0tY/6A1tq2VVIs3CXRqQMGhXqBRl3hOW05oYH+5NTR5dB7GK8KIY28bhHyYkLq8C+bcJ5nTarZQEKSYlrLVBuCIjg6nx+kCJtNEC6HozWQC8Jn1/WyHkUYRm/l3KDjPNKyLhrqUS75ZsFiE+ePeZ6V5EX5okDMUFx+om80rU2KvPbwETjOIz2eD20K6vhpnGSb5MpMBnBsWG5ZTKMhQTrYwt99PB4xPc+/6/F4VCgfYwZuMBk92O0COgngcN0Ffka3Tp/DxuOwRtO+LEtqRUe/yonn3fw4jRXK5RNXP5UxKVboTriM0Dv861//KqxK42bxu/zaV5ik5e7xZTyp1XlHSEcVHRDQ5/v11rxB1AtOT/P4VVnR9TKb8Nz1pmnS9+u7RlaAGAnyPEuEGX/Gm1s2Tv5nXZqmuUhRo4lEhurcLkcJ0TNww2qg6Eo6ZkUhDYCs90sIZlOImyxO547BboUzx+1AD8VzZ9CGXzGVhBMbaXrhavncy8NDpQVvmnRaUq0bVHjeI4NNZAmst/frXUkl5Expw2G5LtrnccpK3/eZasKDgE0JbeMxPyQWer1eJTtkyZJKT0aV75XF7N4xnEKv7TqQZV0qe1Evf6rYZzvdPJASK1CgTKBUJ/OxCIAopYqLwZmT/4QYxaRVdjSEzAdbOaUcsAJTWFqUtvCDVMIhLY4Sk4Xyer3SdV9p3dYc2RAcM0pXfha1PgNIbieCR539vB+7Fvy6rAIr3DbIIU838GNWovQrC51pgxnsMXy4r4v/FXOWZV0yr2qcinIy3B6dQeGzH5kHtl01J8NpEdsoeHXOyKA/Rf2q9x5+XbAm/OaEUqQQp4Dlu76rkgXacHhv2a1O/HL/WuA5dyPnynt9vwqa0JZTmF18pXKCrttaFkDTVjkkkP7klhI8H/6dW/TLptPgUq5Rd16hKQNu1ukQDo+Ym/mpymnnqaucyGwIJsIkEn32Xq5rz/qZoeSAx++l5+JneeAmIjQPwoFsB0lTccttPczVzTr0Va4gDu+yOzIOGQcQ4iYZXSOu6ouhAgcin4FcRCB0DgdlruOLFevHFyRGgMdekyDv61YpiYQaBO35fGYtu2WpcCg4W3hZs1ON5yZ6OjHDQQivHtZEuS059W+//37zxUGvnGP16QyurLhwovA4Apemgk4t61IsM83ShgUz9DkPAp0w8xdeMDg209XH/KjcHWG+ItmUK0lbyhaPuQYs8ObRw+bRJfvklUZfCUUBreLs4lNe2WqOg2YIymw0g27p31MdVwYyV02VI0xnGIYq2JLfBYzJzUepwSD2vbyLGUL8h3rerTtdapvL0ibt+1GVmty8EqTFaT0OeRYCjMvPYD1oin3WOebndUpGwMyEWYe7wWAIwiCS58Dm01yI4XJEmAN2MIPCEBCkknEGMzL6TqqSlk2gxCMw4aZkFnq/IJ7OflRmzG5nyf9d1kUxv26extXORsGdg+YXAQxRZ6S4egoqHCiHHHkxyuToO9XhhKuM4yidAzcfpzpljYIwowzgd3varvPM+r5XXS64MWBdp/Bz0n1mp7sdKoZq0zxVRhpu8cNhQGlAIi2IEjJkQBBuH951SpkNTVnFZ3GSXn7f5jIY5Ye4bXPhtrVNq+xG4HhXdnpKmG7TgFTP80zP5zM95od+ZgWSBJuB+Y8Qx3RXa85RTDYWLi4QIWGAIGOWVKMpUecMUadpygf7H3/+eVPLTdNU1GtxUoCzU/s5BcLzpyWUMd8mTra+6yV/pQzj4ToFxLn+MpAObtInC9TTVSnDBsslxGmQ65XGl/IEVxb8YJ03xUJ/v98ZpdlWIVhuIJfSnQ4c7A1IYMDqpdVjfmiwJr3+Vbyk+J0e6OMOg/CcKGkoU+50V1mF7tYPFOoMBbcQYjM5hA5Fh9vWQQkWub7T4yFqj2gsMTDMU/Rs2Ad3yh1upN3nOcVm9urF1xucKkpnKDQSNzVmHRqAAbcAE3wQL7cCQh2qIWuse3OSKQ4OeFbla7CTCRoPjaaYX+oUBU5w9+sFGaE5p5b08sZFVtICHKdERWxcl18CCzqh8hNZExvTcim0iYgEuFN6Pp/lWrfpuS9UzTXS5+8qMKuES1eRoEra2ZYyzFEdz5t3dxWMwR30gN2KQyMQOgxZhmk6rIJKgpRVwZoxW/jMKXGhFO/MwYZPjwG5bVofMs+zbsu2aZSYiZeYo5T8PmcWw+YlT5HbzZWmxBe46YLbr9K7HuchzQ+VCL+Lg5jb3UEJz31JKaXm37/95/aMcWUzmL7b1XTP51NxAiwIuWNHbBWG0+d1yqiMLyp7TTsBnO7thg/KiKCsgE5tCU+YrZF4VPqbPcLu97p8sYHYdV9SH7oEFKcSTjhKKOLj3BgZ3T0nMSdVMq4aNxTTf8pISj8XOgFiQMN2IIGSyC2BqmDVj7Qnl606hTvTxHMTC5wKVd5LIzevcCmt5zzq5A/i5eP5qEzd6A85DCuypxER3VuMQxFNEsZ73jfQnAMYbfumstPXCjw1d9fx/9L3wWp2cKVt2xIDva1blfHBCc7pDgoFrg7iwrWmEmHdKhsYfWmuthjmIbGk+cJChofnVHb1FoEkSUJ6XZVWm3/OIC4v0BJ/Bj/JLfdFk4kSjtNKznrUvqGlh2/2eev4Z0Xp+Hg+BGSIUXsW5w1uFTdNUALSVaSfoDGUVp4P6ZC24/wAIPCWMKco4Z277H3uaEzpVxRPHXR09zADPqafU477dVeeyGqEzSoUd3UlA+uH5ue5LIu8jkEi3aOXAwl0y5nNn04w+15/bso8QB1+ZxtyYt+okW6b3/8ff/15UzvSSNKLeBnEIqaUQgvBwtG0tC2ogxRfwdR07fg4jrK6VFB8P6TX+6WN5EM0XsS6rRWvf7aTsGoyo0n2aDVuQedQOR0Ev11HhXwjut6FCDf+zDzNeXhnKIpSsprSM5DLeIb25B3x1Fz19AnTXMwUEHTx55TaZBZNbDxFHCAEg1ZxZIf2O/JZFNy6rVUepX8nn2+RAwNcLLvQowS9Oj3FIXxKIN4xvxe4/zzz93UeFIpRRFP8vG3bpBFyx00oLOu2VvR5vie2t5SHcp6Ej7du0gJJotw0OcTTHcad0CfZYfwlalG+EB8Yoh7DsCwoykErLovlAzmkKAQF7pchRODdwzjIlkh2pfH/PObXUSZ/4TTuUj7GZvamE1jwvM76drgL6Y3Fweno7uTen3zqpJ1TVWXoxW3IgBb6hDTn4a7irobcOm4swebQLWwzJvHG7jsdcRixqcR87Uof4OE/lBtsFPhKoIzkRR57PmDfr3fFkPa8Sw4ozchiJAB0ToyFhwIx3MUuiOdIqQi7mOAmDtumyXZVnpjlDTggBCI/iInbvmf+WlOyQ1ofvNGUC3kyAhxzCFJTncLMjuRWOPYj+x4FFs8QjHQhWeHHwuADssj0eWKRL8tSZVyg7GNGw9wBET9/XjR+r28jw0QN89CLaJcJiFfOsjNHc7hWWCBpiBRN5fv91sxjP3bBxjwbXAIRm6GGPI9TNHRRfOKmBeljowFvI9dlmg1RlN+r+ObzkLIPowd6nPM8lbUORV0ZhPshvhwmFV2f/29Gy+6KgcBQcT/29Hg+9HOg1rD5BHH3nfhuKp3CuV5ewNcdZhplKMuNDpu7aZr09fWV2q5NU5ASeWYwEdSMtxmG9vLXA508D56q6b28Q1EYkbo0jF4Tt02rKDQGVZRbNN+arsZ15/kVfsLD54EuIrfwu1jwVKe+6S/Ey4q6kfJGc5W4IVhQIEr8bzch4CFv25aW91LldbhHVUopvb5fupE4raRPj+Ehp5Y3ot4EwmNLTTHAQ/m47Zvi4QAu8KF1WkhKKT0fz+o2QjQkoqm5esg4O244z4N0czhl1wNOEOcd7x//M48byMPiroqrgNC5rZtQJOl3jPFQNf3BMp4fs/7MsiyVE/t7eYugKtMIGyGA0uHqT0VAeBCDWB9TONL26cHlmn208c3/+/f/3T6sclyZh4sqzYlfOpHjhYhG3pRTFx22C4VcRbhtmzYmD2GcRg0Thabh9Bg9jGuyS/YfmpRR5QDggpvEFafzVjoMZi/7toucyQLLAZlhVBY+Sj4XcLtLLehAyNw6CUgRDpX7NtF/ELPgQzV6DQACbl3dcFd5dtBFKJtounNO45n6kDKg2Qfl+X59a3i6rmvIg680xxT68XhkXX8/VAK0rMh75MoiGLGe+8hBAiTv8y93/Ach4x1XAI/NvRyudS4XzwQY2AmeoIawMXQTD2U4XICErFGZ57kwOX7/84+bHqLSeuNyFyRDuWXECUEz5F8c6sfz+Uzv5a0GFYd0Ig3WJczZ0q2XJZ3wXXTmzkD9zMAWXcS8mPpgEROmAi3E9SAOMbsXsEPBzG9YbF4+siGhoMAb4oU6/Ox0azfi+zS4JpvFfQG0QAK58p4BOgqwNcwGegsFotrkPinEc9D3ZAAJcqWyqctmf30gP9D6lfXnE/Hjv5vE6dYPaJ9+wnMPFTkXB4GHl57XmZ6PvI4ovT5jE4SqQnk3TQ4Gf5KAB9XEUwHcnd4NL9T7XFdqlT4aYZQql/a9WhD+H3yUjv2obFu2fQuL0FOqNi2sGOEzeV3WXLNP86TYZ80WtmJ36hQOWLycdnooaB0Eu96Vw95xHiXGwZwZxehss34h17OT/GG5XYZ+kCinawv79bqu9OPHj6KTj1uFhe1Gz0UPfsnUAYUdJzM3nbvke20uCDsYxL2JjZ5fT/V/ZNx7CXXdt6gje8wMIEp+f3/nxWu3551yycRBJyukoImTD0npW2xEM1gw9IN6DWx8MNxzK9VKY9SkdN+XtETbvknJSM/J2tBcI91q5KlYkN8yxFYqQRiH+AHho4zrvtN5HqkPGPg8z0x3FyX4OitHdwWkuAmDiVJ8jiD7yaNMbWkEOfUxBB76oUI1/AQ/TfGHKIiH7vb7LDwn22XaSK8ZAHAmgq0GPlKQ43ip276ldVslcvJaHXWcaNDhQAmVY9/2ikXMJpHyLrhFzs5loyltFxnBulYhMgijyD0chzGsQCPbPUqVZVnS8l4kOuMgcDlsgWqLhancD81qiHmBH0BYOFGOcYJXGYDDqB708XhU4ZzTNMk4Al29w+ier3igw4l1w3dzTX8/5I3GZvEMxht5tMU8y8MYn4JUH0L7tosNcHOY9VlS0Pzn9980sRFebKE32REkpfeypHmapXZD+8BcASt5nAgVT9YW0cy6rIVPRI8Duc9oIoJpr3IFCr5NKTWYjLmew2vfyzZQKMd4McwRnDJC+QfmTinEIHSe59LMxpRbv6NJaej79PP7O/OtgplMaYPLIY0o4hyCfa670OWJdev7DJnC98JtkrJO8RTRY81TIeNNkiWU8hfJr3tp4beMkhGmLL2MrIqwOL1qWj2zD/oW0midwKhtFt7MYoV76pitEW5QkT7vYkM19EPlIONqUO9p1iVLfTH9YK2xhp6hrUmpqZnATap804DPW5z7Tsv78Jiwm/lBDAR1MzSFMuJptqKEp1Qt7mVZdKrRr/RdjlfuMHY23YfneMhtAzfHKCvk0DiURp+h5LYXpRx0CHm8GoUdCJKHxdUK5OyJqi6GEi3DnEhASQAqPKjHHfsYuh0RRoR01Rmuj2fuo+bHIxs4k7xr2eQAGK/3qxKW8WwUM2byAk7+Qmkv8GY/9IppwIaIBemwtVC28/olQg9WhpzuP7hY/Cy0JgxT4cCJydukdNja3I9dSOI0hfP8XZBJ+UmHTNvjEzRENScUH2x+yjC8D2x++/33m26ejcD15+YIqOPmx1zw5ib3EvJTTYUj5M0n5gHcHhoERhNJE0fzz8Ibx5wjQaPqBs28+HVZ0hDh8CIEGtNVwaTyaYL02CsizBWEotFYgqo4PpHzwbXM72ECn7PCx8pCiYUpKW1bPMZ8Iu1uHOMwiqUA7Kq8io4E3TNYBGulO8fLjNN5GHqVYpyKvsnQc9SM5FZev9Tr9ASKhGib+PmDaPRNyubY53HK65ihKg778hWw/ogeGD8Dcd0CtEHkhtu/Ayg0+fTD+Bs3KaXDZjJ4lQHuyMtsLHw4bSJLcG453dxTivmF1HFmJsypdB5npQKkJOLncBOIgWquE9TUsDlBYzzPIYvnj6rnQIMtnHo/CpIW5g9ApDxIGKGEW7q8Fth5XddiloCVTluQKhYDJV3f9cr9g1PmNBBKOd+0r9erYsDy+1wTr2xxaBxmA4vdD4PPFlMBO2BoYnMvWPqQ3vo93DGBU5lDwYig2FFqF0PhEBtxM8ro2uQIivILmhL/V1w+Q92a1FST93EaVaFQoimVa1krT7N1WStgxG8A9EMUMh7miQ6E9w+RknXojikKRfq///z7Bn9XiKL1Gd5gukUl9BAXHqH2cl2DqwLJkuMkI68aRq2mxusmWjYkyXmapcrzwEi+GLMErlNOAMoNKC/pTnJdBG3ipvgcot3XrVOTfoFTkSgH4ffu5N6W/kk+xHeZwG/m0M4GhUwpe6U4nTmB3bROJ6tZp1JayqS6LyI2L21E6TftdaWiNLf+ruu0sd3g2XXfTklyQ27mCAooMn6YeHapyJp5XwIzYmETKU0OS99nfwRlWsbz4rlWVP6ul0caZE9nTq/rqkPHeyBlpDdNhnmhVkP3EKfJ/ZJSnf3gMlwe3NfzS3U9p7Nq3JhvzMEYJvTTdcPUvFyHvGA26S/I2F02pxSFoRVnbqMEJDOA4CWIRhIaa6+LPcHX+VfYVwoaxFUwNhozA8Jy4Ed9Ojn2fZ+W95LOI0y2oxRD69APvYaDDCE5fCg/yDukxpfjZNdWQ0aehZz0DYhxPhc3NCXyvue4bwaT0tVbfgkm3imlTOdoG5WR7pDC6S6tSV+8gYUuxfuc57kQPVOxnMUZUQPStqmIle5vdl+3GBckpqHWpHdyY3HNb2JjF3ecvquir/Ztl+6B09mpw+dxFp+lO+P0y7pUJg9M3zEbRgSTb6dUcZZYaIoBtrQfkpy4ypnWbuumeQANtgh1UR4q6vk6K2O1O+WpeBt1seZA5hriKJc/G0218c6NF4QroWp2gIg+U2x8+q9DJcy7NashOTgGWD4YE9nyOCtu1uPxqCIfWstp95RhNsB1XoqF4DAYxkFqz+u60t///B10oLPyAXNInU1JDIJYuwFOyI85Sm5nz7r5Rt9nt3o2CrehmOJ9RvEwM8w5Mqc8gD1HvcqtN8Jr2zTpf//nf6qwUiogD26lvMIT4b5y4FOra7Drq3Kp63NIDjWqhoUxMHILefep4nqbTVdAPyPkJNRc9BAu60V4pLr6OOQ8yGnB7eNKRG4refTeRQG4rqtSnbZtU3IUV7vTOuAWMWGHbwaKx02KRoTT2rUvlIY6tS0shxfHzYNachyy0TLIHTf5vufUVVSNfrOi3OPVdB8Lld9FeeT6GdeT4G91HIc4XxlKLe+Xd+2u7CxmGBeAFTIqD6YEhxA8NPTzfA5fHyonzzOdx5Hatkt7NODQleht2LjQoLRGA4nMzXb4P1vfxN9/v9+a2qvXa8oeOK8zNX/9/fcNHAvejWOJPwTQC8lv0VdErcYCcr6NzAjMmV18Lk8+ip09jmM14KJZ5JSGIkCp5d5G8JpAQyAAEgF3xEnYpJL01DatqBNu2TNNU9rWkmdynMVpfhiHhOG3G5+56B9qCHXxsR85+izyCd1VnmfiwysQQg/fkf1Q/HuAEbmgm/0NaI9q/744S+J9VZrrXnAsBxOyXgRMrmZkjoJ7pcsXOI1JIPv6+qqCXYHDuf05uDzw1QOZQDrdJtTj2Oi16G+YL3mAKZ/HnWhgfquHuUpeC5udiqdVs8Zp13eVdYwyraOBpKYmN4/bAJSIybF7pLpZgadL+ZSTjQe65erCtit0D9Aq11JL+55SpUNgADmMY6Uoc+Nn7wnWdZXpNsMw5fKdGX/Hse/T2xVYGbSOA0fNdmxKdwYE0aPcmaapktkyj3i/30p2+kyC9SYZao+XKs7WdVscSj7PKnRpNOWU5jnx+/uwBIVGTj/CzzrOQ70GEoAy5G0ECTuT2mnmPvdiczHApLHmYPWAHl/gHmjkmnVQO0RWTo8R2pmaiovX/Pu3/9wucPEGl3/GbIOd69CsIw/4ZnFlV4E1LPamrUIcXSPO5nQfLKb1/Luu70TToPmGR/V+vTWU0ymJ7agFbCqU587Zdc/nsxLyQInggcIO3tZNZgguT3b/Ycoxd4P0BYp3lw/OJP+N27sShpmVkTT/btqGZxWlXKBsx34IkfRN5BUBYMIwDKoaqAQybH+lMdjAbAjmVEgW0L6IgR0hpG5SUQ3fuLVZpEeZi+37ntFB5kWxOdxyyZ1vqvAlyzrv+k4yAoAG2AQ6/MOPS2RJc3RnzXdtVzTp1N/etPPwt3VL01zyKmDpArFx4ucTuJez+TAOVYIt3rpS4N1l6i7K+HlVZhHUhyApXO2imrfF1U9Og0Fz0STVGmqJu4Yh7fE7gJU18DJzAMq7ylHFyrF924sXFe7swRfCq5eSkFoZRE84/nFWwTXO1vXhFcM4amTZHAVL1sEFeErQXrxEkXZi26syzs39ABKatpiQA8ZoIwIsGFqowSt9Ttz6DuP3XS+kC2ESz/86cywf7AugYWZKEFz9dqjsaaMElR1RPB/M+7yhB/UEnIIW7643ra7slF20aRZhR0I9cXG8qO59J6sVr3XbptVQUVkiMeACjQCPdnjV3Siw2cGGSL5P0chibEetDnZ93ZdsL8HA3YhM8KbVxdM0CaIFskVff6dbhmbjMFaBlukOe53wtdIiDt2IzCqGvorUdpiU2xlXdQ4NFizoGczY+TELomZRMqV3g4Su69LX11dVnvgANzN8Lw3wpL2328g3Aj0fKOK2b5JdQ4OfH4WQ6P2YS39BsO77Vp/CRu+6LhMRo/yaxiIr7vo8N3Imx3+LqnPqv3zMrpKhqIDTtvDJPF6hEr6lO7WcqNR87oLoU1wX1ONU1zR5GkrNSR1Kmo8QrrapVIJovC+jM7grIfWgGMaxUPli3FZiF4eJHLoGKODU8zRkMF+VdBo8M2fQSkrMNNXshxBfferq2bzuUk8NLI2L6UXEBzoylAoIwBSdhcHwsB/69Hg8pPD8+vGVCZRRDrgbvOK6rWQB/qZnEIMhTsrHVFCgYy8eYmtAxgwu+e7zPKd5mnUwsqDwPBOPzg7HYz90w/M5GfpxGCGHxS0T2bSCWW2w6WvAp/rjMArkwDOMntcJp95jkXqLF1el6f/9zz9uGjwaZJ8LeHa2GwIAJTpR7NMOx/1ONYzpOz1s+QAb+xNEDSIZMWbfr29dxTThHs65LpnnQ70KtCjRf1u7jRQpbyNvKM9nhMWK/RGaiE/bGsoxt9PEG4umFU26PkvXVg6NYhvEgUCNDdbPnIDP4IcXm1e2o9a/wCxQ/9aV1F42rodn8kzXbS23nBCsXuAIbpS6mYIL5rC5TuEQ3I3DWHh25JTjPDIUEZj0I/F75dMWzAQQU93asXa6vpN+yX3IOCS9IecQkTHdnaS7EbEz0s1adhSKLuIKfEoOuQtzMNz6fDYyjINMA6COE5i5LIuaUgZZUJe51gg1QVNMbX6eZwkSDU4TdTCxCpy2lAOK0zrNozf05nxPBb0E8vM5ALzuSzno+DB1bae6Xc1xU0wLsP6XCUIo2LZ104tT6WL5Jl73Oz2jindrS0yAb0pMDHg29D2eJy8iZqBAzprmFpYD+7FXJRHPyGcWHAz7sVe5MCJD9iVvY5onPRNuJjXsXStTDyoN3hnoVDWojYPZDxa0PZ5dIzZC12sT+oyFiok/gxBMMu8oDed5zglT9BUslCnSgUQVN+kokC/DOeS467IWdCQQrtfrpdsC+gRlGhtIaNlZ042xlJFJcjTm0zjpNuDfOSJGTp+sJYOkth+78vqu65K2HCiR202qyWVNy7qIpsBtpAZQZUiOLGYCqzy/yGuU7jls/Y/z0ILmgGBIyw1DmQcIwq1Mn+Q0DgEZTZvzXO4S4Pl+v3XwMPjyzHvZbl6lfOWwdOd+19uwYd/LW8le9ChIHygtucFwg+naLs3TXKDVtgiYKm149I1QaeDeDX1xpHfx1DAMaV1WMTm2dVMZNU1T6uOmYLOhd2GSr+SqptVNiHyhdciWHQUFWPj2OCikBDzfrS1FRQiKCj2BqB0Rmew2pK4kYzP41cc8AZ0INa2HUHoS73Xnf8f0G/Id9bmcNu7aE5gr2IebCqjfjypjoxoaRqMMUqeAz674dompahkl/y1bHqqK3GS6tmIhiAYffQqGePwMTngsQN0gbZ5mKTPnadYQlR5oHEd9N4EpTVOl27pnLXwvrEpf75ea4Pu+0/P50O3OKU/fAxdKuhSzdmLQyoGM4+ayLJrGL+tSNeX0X6xB9Q5DEYRJjHfdZZzQdr/wCAGWGF6Kb/jv//znZrZAgIqins0qhzqN5vf9fqev51dGtMIb1922ub4xI5Cs9zirkb6b1gEBbvsmS3rqerdukT7EJrht26Z1WdPz66nfo3ryPCTFvM0q1C1yZKNvUQvuIeszDCbNbruv1N2ukPrcPgaI1y1MOfkPi4Fm8xMDzSko5aR5DLucWCrIQGk8aYsTUTmGXQnYUZ6JTNwaaXuUV9KVGYM8rcKylF5hjkafm8AVm1Ds6TFVKqW7MnRQ7kfbVr0jg0veCYcitzmHE1Nw1g3zMzcb5Bl4ugAIF+xkMmhSE+bVIEC+692ogZ3nV63Tq6VdNv9c5+zI1iY2ASRCv7LVL0TJB5Wck5VoBUea+L1u7yJLnqCQFOr6pcB6z+tgwUr/3jbp+/s7kyaDHMd3hqbNRqWJRM8sfXZQ9VksLDIgSLLoKbMUHgRjOhSQlKD0DEDJLCyxY81qVdr8sUTZ8XzcCBwWwTzN4nk3JsxiwAj/iTVxSjqb0hW9DYM5D8vh0OL3Q4NxJrjSb1Oq9PyqFMJUmhkKg1iAB+9DfvG6CqHf583IwUmfcliM+TwV6vtx5k3feuPDYmX2IOePKI3C9SBN45jjEWJBuWkw1vU4d3BiyEWDpNfQWOSFm5m1nymz/dCLi4VUlQRev2aHfpBUdNszRg8sOE9zcJWytST9B3aZ0zSmR0RusYm/vr7EtAXHH/pBzFmEN+jvm6bJ7izTmJ7PRxwIGSFzLpEP1qj9ueKBTZnmPuZZMHQf8whuDy/lUH3i+oEYS0jhndRj4GrI7Z05XWtq2yYd56kcShSTZK+PsUBl/H1nBxk396bEHvoS/Uw/8H6/tfBm4uBsOAzqx4BTQiuzkGX9iLd13+k6z3SdZxrHQdnnMhyM2Y4PSMVFs9iMJjXp+XjKUwvnzSZFMOw4jsKgHTEAUQDGowxw3J9BEicNli40tk6jgDx431mE5P9uWZbK/hIIj94EH1WQDk51YgvcyM1z8srLu6teaRgGbQAMDqqkqeuq2aPm48QtQcPMZ97WyPC+rlrTHLSbz7AgcHsQn23bpMXIvdOerisvgnVdM20ifl/XdlrMit1uS3QEZEDqfkoHNiuHSv48bbquYhjtRtGKBzCbo8r7K5KsgHK5aR0yRuXpQz9k0p3pi7j9PwVeTmOi0imuM13FpOYA48CGAlMxl9tC+GQ9MekH4ZMB3XllsqJPIV1HjRW9at/zSuu6pfd7Scd5Zhpy0ABAmUBzPEeCzYKKLJcHZ2y8Mw1uCnen0Gu0OqXXdZVnE0Mlmns8l0QOPErPcllZ5WbTPhO5SLJNjZA4oWJGbqzqfmMAOAVF4qX7TvuR/YkpCxkcypITF441J932Q0ZUKg7VdYbBdVdxrpC4ZhugMjfhZKS0odTzJGHJWLdV03QaWkCMtgu3+dhc254dMFl89BQcJtM8CdnkMIUFzO0JWrfte+pCLHZEwA1rqOKlWelGyQm3irlV3qBt2sJRh+hqpvDv17uKxwYt9FxIt0lls3Gw3ukutj8ePslJQwMku/1IPmUyymzAA2TaprhkiHYcFAyafUhuDAIhA7ZNW+DmVKxIUYPJFj8m1dxwXvd6qqn7T4E2ARIAKniJwILCEpUGX4lKcSBILnuclUOhjMzi+0C/lyQgFpRHvbGoXC+O87nT1TWjYfgGl8huKdjBKnmbNn2/vpXaKn8wKzk4gB7PRxWl/EtmITnupm5EtScjBzP+A/Tw0B9nO7jEFUCDxcsz8SGe5zi62QaQOzw6Mk2Y2U1zpr1AivxMu0X+7MRPnwG1glQDb/c8abB8kKvn45kNy2CwNm3qI42JCC4Wjktyh3HQsEtmBEYZwKTrvLJslyayQifuGqf+/v7WzIAr/1//+leFOAF5QnEGmaCcVG07Tenr60uiGplsW76GK/7KaR7S0q4o86iDMVJrmjw8/Hp+Zcr8mNN/XabL7Yk1Ejfavuf01WVZNJd4v7Oh853y4nR7IRY1w1K0MiJdBpjg0/t1W5XIy8Tah31930cZW6bonPT7ET5hbTEmdzvReZrS8/FMTdNo6Cp29Y3wq8sIGkYZwRanBDyvQmfnAJWnMQzwdFcx5EQ8KMbPym/XirjP8jzP1SBZlrE77uttV/kbPR+PdEXtRy+wH3shGjq6MvTiSHHiuGM4Ozk1qdAmsBiKn48BMsM59Okydwiz4XVbs8tF1I5yOul6bdRxGAUSiGYe03TIjj5NLzqDMqWlpneSoQh1XZ+u80zpA+njRmQT0ifpeXSl3PGAIm6+acpeT+i8kR/P86ycknkqUchkS7qNvz97MW3NCV2oWmh/2FiySW3KwJONt+1bumJDsdm4ZbH+pCRlw97X9QuNxgNJCwU/W35iuO2zInfWpxwUhy811WSeuQkVj0sMmLe8Xq8qTUxMAmMyyCUyeGzN73/+cYuTFBoBLGtYPMSbeZjOZ8wabuJuIQQ1nabxsga2XJmpPCj6AnuQlBo8UGBSkRnjRFJeeSjGPMTGw3AoqebHXBEo/ebBURHiHJvJBUQgcsqcuGvKNc+h77p0AoUH9l9lp0OrMVvSdV3TNI5pP47UxImMBZIbP1AW+vem1lcuX8DjHBZuUO4QKA6ZChht6nx6Pyg0UDU9ugvIQNbYeP5efRPz7/jnwNK8pzvdcrYU8mfwen5fMaOJRe8zJTe8o8wq5fuRuoDNdbgZjxDNT1sE/m3lmaqbI06M0ZxF3HzAfV8pf/Y9aB0mQKo0w1F/Z/ZqYWLKEiggUEh90OYpk9x2ks+BRJaewCfVXJs02g71cVNodnMX3bYns2Jmne6kVFo/mR2F4UbAa1bCp67EMO/7Ji8qF53JLikOjjHKC8oyVyK6tnueswGFxGQm42XTnsf5ixuijCAiOZcD57ov3SogUJSoCKfY2MMwZL5ZoF1OnZfhR+hLmP1QJm/rJvrLZ0jn0PfpMT9Kkx3rzp121H/a3Mah3WqY3BTJ9m2pV7ADKsMPnGv+8/tvN80KpmsgGsqLC24WAhxZSUb6I7t0j1OfE4eF5cMeiXpCR+1kvTEcEiv0Ax5PV1iontrq03hcT8ZpLNYuZqrArVQ+e8xxumIWMfR96vtBZnKe7EpPABQ7z3MVLMqzQ7/i0/5pmtJ1nmnbSm+n0JZ4Foo5s9x2p3noZ/Pcgqjn0db8XXon6OSUhwAdsgIK+J3vh72OAAViucMS518/foRsoGiClmVJQ9/LEu7TDGPfCpcP4IWD5fl4pDultMZNscQtwkE4T3OZaQQ1RlmQMW1XLHjbpjZAH3RBnmXDwQ9nzbX29C94ALPGWvct8sgzFqW0uQYxyqysbeRh5MQ8uVfE3/fBjODHrtXGgw/ktI3jOGShqegtKCzhYu6Bon4rEc3sbpFS5UWJRA8AX4xN27RtOs+SedEPvRCRAc+sQGO+v78r3+BpLAE22PW0TZMNpR3RiRPRI+xcOYiCEah7mibFEgOFQwdxH1rxiowAqgogtOpsBFGCYuPARABSh7zpzFzKOblrcrAFC6GnDA12MIcZ6+I4wrziKCljOWZhrSTGbuKH3ZP0KmdZ0PLiZaoew8pfDOtskD1Nk6I3nBalgyOMHQT3//HXnzeQYN5RexqnKb2DVt4Yfu7527yIYcgICDnjDK7gVKEph6MEdx96ACffeZyau5AH4SbRLBQQqZRSzvwgSQhf1tiMcr3oinsKyAX8sAxvx7Xa1TRyd2Z0ePGIOva0ODGdZlexUHXM3Wtipt6P+VG5wtBDkIS7LIs06tzEAjxCAenlk0OU2RQ8zDKip3I6h8tm4UFpIHeV2Di0LzgsyrssBoruKPMZX+32QjxrZkrcEOlOsm6Fpt92rT6DNPCpkZSCxS6jvq30w8dx5NtpWfXcPJ7B3R7xVuZmE3cuSm36oebPv//SHIQR/rpt2Q7GBPLncaQtGisPs5evaUoV54fdD+uT5kkITQwHCYsXbSRoA+if1fd0xewaqaQ76XmZ4fHDKCUp+YgjAEJ2ERh1+jRNatQ9SlioW0QXKH8vFcWkQ9Ofyb5eyqIyhNZAGhafk8ZWCU4xbxLaEnQbbnuiKejZHEDxybhrTVx9yHOjLCmJWCWeAq0PoIt/p3maNYvZt03m12xuDgom4U2TZck+zEReDFucDchtg8eugkMDtmb+AVfrMzrBuVnur/aZpU4VIg1J06YWSjhX4KZbIH9BKMa92euAyUNRhnKsKCwg4Wi+XesNqew4D1lQAv8Sz/b3P39XMXD0G13fSVPChHToB0GfPoW9ztBgLEt1kiDDdDd1+GGYkHF6jWEXJEVahNNAdhP4AMQdgTrcGJANwfG5HbU4z3wbcCjwfeGbubvluq0y7YNrRm/z9fyq2ASY8uEiAkTOonethyK+2xLZQK+WF2MnhLHv+zTNOZWKclMzheVdaPxxYHFL9EOGsD37HCSOg0kRf7YR//Wvfyl0E/RJhgpx6zjjgYBXJ90iUiNKnNvjPPJteR5nJQV2NLFpm7xBfOpJM+0wWYqckL7rqkGRGykIN46dp5g0C8DkxPdeg0EQqanEHMiS9CierarB3XzBSgaZhMXcg5qb78CidIHWNE0SCPmE1p1W4HdxWvPM/PZEqutXOyULG8JFZ5SQaCkotfgM8vKNwBzsXllY5JPznaR/j7Lu+fUs9ptdDYS4Z5mDH7dJrOnz5DOFfxZON9iPWgSf3m9qFKpDWQPPCXRMfUYgS3ChYEvDDKakRCh13SU/cJonkTAxD8FjGsRTitlbsVma5nvWid9iAkCOI7UsTi8HtPAdAg7Ikiabprrt2moGQLnkPkaeWMvfAbbMJ+QtzcEwDKI9tF2WbNIow6j1zPNt2xT0CGRIKef8nmEoRDanPr/fb908X88vpQ0h9+UmojSR44mpGJ0Ix632maZ0HDm3nEzCr+dXFfUmD61o0PlcXddmLUtbXBSBc52tOo2TIGROWRbU6/WSUcZ5ZCiZCbgjTcmEZdu6yXuXYZ8r+XRgnSWYlMOSwZyHiM7GmKYk5WDxqGlInyqx2k5TdzYGn2/f9tSklEZ61q6t3NnbppiAK0sxxGnueoLtqsO+ha/VtJVTh3Oo+NLAguDOnLYu0vGUJxi7ngUh82ijQwD1ydk84sCgaEgIZDCczwO4OjU0m0ZRP5xWwgnGZ3fZr3LTIxXJXdaZKbhwDAiQ05xnoia5bZR8qxKj64tBQBhPb/umF0/vAZRLZBxD1jsGgu6C6dmCJdUjqwYVqR1NNujUumYZMWRSDiRYv5/6eEAL7IFAq/hPYR7X9krjMFbKUUGoMf0H8OF78I5gZIgEGYYN9AWduV764cKEXJ7IsfmrvsZM+JiZ4dhJ+c+/53O2TZua337/7T7Cc9aJaghLuNo8sZUEouKOkRmn5BTSNHtEALFjnjOhUi00FygT/ZTC7lOJP7E4v76+BPm932+ViQhqKA/4Hu7hSi6g3CItVw8YmWHbjUmdkRJxc4RUyOGhOY0107xoL2VBvpSrsm5C9j6d1IFIaU7d6Z70LMVaR5y3nAdNEYhEAG0PPCWeuZdbroiUs0qEc+KTlsvHK93B3qbnhN/EPEYSXpt7wYZwJrR7crGo3dCOw8p9m3GYpA8BGHKCJ06NpAoL6UwFzeL7yGXFqP6tTw1dpO+2lXLHYAJrH7AJigo68MYMimXh2OXyiBPC86qR2ap5O84qG/31elUPs+u7jKXHw9+2LX09v8rm+DB7hv+EB5XflGx8Ih2IseblYFnkWnm3viHW2KklMJ85jaFTuBUP5NDjPOTSAqTrjaKbhONlzK3aNq1cCTXr4aUf+3//fXvxL5ODTZgvcMtRolA94BCjAyr6JjnoxztIKaV//vmn8gd2F0plRBoLnN/DZ+K5QjXH6Z7qhM80P2aVZUKlWkNCLTQJ7b5YANESCOGLUgpJMX9PmYt///zn1mkUjSPzBx/wOdXcH0pusPq077idZ+mm/313NXRYkXoevQHUEmfbet16nNmeXwvoOjU93bdd+ngafU4UaOmf8c7uyeoGedLhm5U+Q0jqem4fPK8ckmWzQBvhpOfFM5tww2VUhe/lXdktDWOmccAIcGoI8CWwM89vXVfdhi36nrNQgZAze7qXk/tYfEzt8YlCbCQJ9H1ViCI9F77IOlBjDgbkTiovJ7pCNYNVLJqOzSZchAULWfmJAQXDd9PMjcF2yC3IWXw+nlZOnvH7LUk5esnjOFLrDtyyAMK1MHatu5CIrMfku20i4rdRQA4DIacwMFEF8mRQxmKjrFmXVUMjRQ7jBk+oZVfiv47jSK/vb80XMgQ56GUixu/7Xq4gkvRGL6NSwiIGfMjIYodCweDMJ/tKyf0gAbJg6ZGcciF6SPQBGD8rLwQDv2gyKzMFSuGrcKdA4+gphnFI/TCkM/ocmk8MxlVGm7vHOI5peS+aZ+nWugvPi9/H+6U8oSpgNMAtDTHUQ11h6cK6zgzqtgJ33NDDAZrjPGRCkZ0jkux/oOq4wz+MA/pV6Et3HObJjDy80R/GIbX48WKi4KGQTmrjWvboZHZ6Xtwl68/t5Knr3su7avRpbEEpZGxs9i1q+LeMWChR1Uh9x3mmNigh6AxoXKG0OKwMvs9tcYUdkWreMJgjZxuGq1/pcmYhSyIaOqe1sFhkRGcnpTZxKoM2iZSuQonBf9e1IbikyK0k+FlzwOrOKYI2JAnu0FdT6uTx5FfeOPx5DqLrPNMjtBI+BG1SI2NAaO85XbbU8AAE53Fq7gCczXNxXywPynGQJqWkTVU911hn3sec55le75eeqQI722IBy5/HIPEKiXkuQ/d0XWeBfzFF27ccida1JbARb1iP0HL9g89EmrbQMTwUkVOJCbyXapibeQoVf8cXzNAPQjQov1g8Dmt6PgQENrfgBM3Y9z2f6jJ/SJrGuokxTbUbAXg8HYxf5hh4Zjky5bR7iYVi8Ekf5TMBcH5oONyuVUyxsVmBP5e49ZXyFfEIFePZogQ8fVhWpmH/JBfFdYv3cem2Vk5imyXKzAsQgnG6u7ZDSCGx30a7wdhP0dcmX3ZnyyoyOqIMkD4rvSpi5jDWk4uKwf3SMpmrCWXjOI6pH4bUxkjhuq7U3ukWhoxgCQtQJt6OKmn4BBzWFhuc9/KuZaBBW/BFIFuaYUg/fvxIj8ej6IZD/N/1nQRbNPWa5IYZsxukaSaDj1W4qXDqAp9ynVPK5BIvI3DoHs7jVHClBmFxcgo1aZuKSsJ8x0U3zFJE8ejaajou58qmKPzWLVNiGKQx+1BJdBWzir7L02wyW5y3RoSzqwwpj3jfsLJlrt3lDeEDwjyZ3tRgi56/Fyo9IT93ys6RTLUZEPJf0Epuc56bgoWI7Y7Fid3tJ6LnIAMLHdh6mqf0eD5ibtYaTSbVfKsrk0hHd/0/ii4dd5iu61LrJy9SRuSHkML85buDOG7p3Br0F66uu2MK/xmkskaYJC8d2x5OXBfFcEqSLsUm8mAVGlAhJdZbVNycs8SlSRPSdRWy5vneoGscIC5h1ZXftJU7oX5vV+Ben2EI4g5DAp8fcTCJs2W2qJIVRL0vSPm+qqz5O93p9S4expQsz8czm0LEaf2ZDntdl+j7HEIsWDmMxJCN/BduDkAG6n03Q8CW1G8VsbvHUrru+57ey1taE9nJWsXh0XxkmVOFOAScnXna0jd1GFxnnlg+/PP7eD6fes7+jiMEtMhC2a3neebrMwyYgUMV0XWnKi/POTSaKZilS9O0Udtd0qYnUxSexJI1rV3LnSx0ZPJmug4R8prsqIj/7DjkDAkZS8ciF5w4FMo63q9O6OO2oP+QIZkZs2leEFcC9Gkks5ywlTkCAT3k70USkktQ8RR2Wkqm3qdKKprNtDuVPtys1M2UPFpE0MbDwZzmttKqA4nHbThOo5gMrIHP79A0jSIhuBEAEtZlVbkGKOOeYJ/ViLLiKfuaYuqwb7s2gMt1c47gUCF6JWWgL5a1sAqCU5hl0Y1KYBA09+Ha1o3Sq5xoPAQ0H579p6HVWfK62XnesPsmcSlmGwhWSndlBOEiLEJ3XFj1Ge0Lw9YjBxAgQa5EGQZK4iGWXjZ5Ki6fB+QEIZCSUVHKnfmUdWMKicOOo6JUczMQVu/xbGjwOQDmaS70h8Yy6I3vxUaTrNZYzLh26IDb1mqG41NtLIUEZkxjRdCUGnDbc6wdnsxmH0SKGDMP2AosNGBvR6T6PpNRq/L0usXDc8siN3ZwQIRNU5zpLxEncULpuxz/7O+Aw3pdM5kRJgeH76f3mTyW0YNUTZ9pxmlalQF+l4bKIUx3V+e6/8wPgfCXMf7ScJLEdhynnBUF8Qbe/mlpOk1TWrdVrnzU78SZ8XO8xOHnKW4hvFuZuLoYzPNK+LuUIqL7B3NAwqC+xNNte5kt0Whe15XWZZXO3QMnOaVl4W9zCTYKGYlQwtlYn5NiPAQ4VXEcYY7C/1/9SXwvNethpCcxXcxMjv2Q2w2blGbXp+BMqHm2yow0VPQ2/h3fmR7k9XqpPJ3GSaid929oedj87/ciaNbfdwaOsheXZ4ms61oiFqL/VP7MWQ6c1hV8wGqcmPCX3JkC95DPRtMbL/j7PltwncIn4S1voKuyqPcoBPoFbiPqe0905ZTh2nSomAZMBgtRazO5pk7FRAFkpnKBD9iUMg/BlpixYbDMdc5zoZThOULakwOiSQq8PEWdh3aagwjGK4m4GI4LybsLsZGSwz254IhBWJSUNRC8/+axvG6rNofyJ/uhulHo/TS1tj7VkSm59zeWSxmHGNFrpAvzuz2Czz0Jtn1Pd8C1bRekwwBmNCtKtxwY8RXgc5Ha5QDUvu3qz/IzpES4k+SzfLivr69y7d5F58sDpsxx0wNOBso2MVX3IvzJ3kd1bqCQAyzs2RChA8FX9rOZ5cSmocfHl4fA/ARHR5p7d2nh9GDm8OnQ4beYy4kJOHVjt9frpecDdYUNS9QXcx9eNBtDJnz7kQ7IfcF743SEkUsJRPPOrYA8YN/3yiSb50YmoWeKsyBzaVL6EP4eG1GO9yZb1pwhPgOfmXIHagpADM+GxDE/JDnZNaMymFv57TAy9j3r1c8zu/FcxWQiU2e6sDwdxSZgU3661PhQ2qM/tm3L1qOM9+Vi0rRVzUmDpAFQTHY9YdbVciBfqufaNs2PWXl7EBJTnJB+w8iDCoVe12WT4uuqThyfJnujyZWrMrEtTi2OFiGOQkz0aT/pfq9EMLBhvfn2G4tbDiMG/6zcnp82Q4o8uJOm1Xe61ZdBlUAPzk2uqGR8to6jotL4ombRUdd7b8lQUjd8k6pDjk3L96OcwseKCT15hJjIqWy7S3KYJxcjtf30pfIA0U+bKC3+vs8gznmk1vIsQa6QaGgYaJmDyHTxhFYAqInJ6POapsm+WHwAR4p8IUk81GVcnPpc9jOx81kgeUHfZWEep9JZZd9vjVPbZqju+XikIzQY0xzs4ftOS7xoyGQePs8i4AQGktVCb4If1mRKDJ8J4zPlToTEFi4P5SQ8J9R/x14WIn1MNqCAUHcL0uz7Pr2XtxwAM7o0puM85cGLYEyUb/hJbVNNrZ3a7ujM4/FI3z+/0/zIvcjz8aw8at3ggJJ4Wwstpw/gYwjH9ROHRxaqpUABdSMyo+85r/x9JOVtSqnbpJirSJSUBAU3KZeX7t7yv//7v1kLc16VGMsjwd2qNAVc6wcjA1fKX5kyDGOVh86hwDp2TwP14O5f5FwlFwpxVV7mfcs16pkYsgqK2o+TquIf3VcF9fEgc4lwVu4kfOlBV2tti+8WkeD/oxlh51OA2UBSYwpm76xOGZndxbUeSx01skFKxCvWPWqz4Knkh3hiL81oCUCNZjLKre/v7wqH9z4OTpZ/72meKhugr6+vXOp1ZfaAuMvRL6bNPLNCVxmr8J5xHDUNd2IoTT83tR+iVAZo6x1l9OQAzSuipwEZ1Akfh4jQsnivKoNlpp5UZuOV7Dn2fMcBR5ZhrEiqzrrgQGD+AzTeNE1OmILW4CcGJ20l4DcUhzqRjcUNJAPodRP/31WF0zgpPdYRFP9z6Eacus0wjmuRKazSdqGVhCUoqjXJQfuafu8UC9EXboOEQ7/i5DVnOh/nkZ7PpxpCj3bON0iX+mhkU5OE83vyFc/hMiapmz9gP8qNVsHbgAitxSDHv+P2ADK+U0a7Xu9XsI/3NATDWCVGMIFRMlImIyHm8FPMQvgSE8RDNiOlIpNw+h02WpE/ZP8x/b74HtywMIkzQJRkwNd3Xejk86E3TZOql3VdxSrg9vz7n7/TNE3p8XjkEUFw9L5f31XQj6ySrmxQ0gWM3hKO6PCZx+F6hC4vBYM2dq5rk13LLjbqWZwQvZdw7YlmHWEmTZPtKIezjGHTAmkWImAvq0rVlnfZGLBiD7PyBEBg2g5BEdqzw9brtmrTLe+CPsmYLcoAR7d8aj+OWXy1LIsSrHguPj2Xg2IwT8HsyWH0ElXG0zgdxkBRGvyAYwur4NbP4wBSuRrBnMM4yEWEZ4tYC/jUEUfmYe93Linfy1uACJWE62by+8xUewa7xEY0bMjryv7Q8Twe85zuO3JIYjALXOuMC2WrGyN7XVYdFvue07uIGGdTXfH7eiPFNr/98fvt3XxVUqB3MMcJN6V2V4xPNq4sNK3Zfr/e6h2yK+Ge/ahS8UZFX/1eSrZDCcYE8SraZ3GV2jAKiBocJM6NnCnZ5CW8b6mzDehaEa59BFIiG+IxFTT6zzkCWg/llwdLuB/6KvsDTN4pLueRXQd5kSz+aZzStocw7DxU/+N/LIIiC+W8rGltqmEbbAX+vuyF9uK0iFXofRd3yK7tZMUklnbK5R4SWpcs8/sgmfqN3Xc5C8UHuJTGvB/KMgdBlveSpnky1nmSqbbHG7jlUYoN5c04COw0T78c7pSuMnxwrYMIfFGKOFLEDifSjKbm+/u7KmUokbBUkYHAtisewae7bk3KSfNe3qU+tSFh07Yp2cxDdp5xynLzzPMsI2PKDRpgNvvuMKpNW90Uz/MIt20TcIDmQSGhx1FlngPD4sXEIiV5F2o80WQsQOpxT2qap1mWorp5Y0rtoisQJ2cpu5ftp8IQaJ2y7fF86IAidcsTbrd9E7EURJNFLQeWs9yebFKfW2DywEZjzYxDlH3mBjkOY5FAx3MZp7FyjkxNKfN85kQFAfjCsNQpS6lJ6fX9qvTtfJfvn9/lYP3zr79uJshypxvHX6SfCPbBiQWrxsnjqU8eq4zDIVc0py4bg2ZSDVe4XKS4bnWqxOndNo0iw9CDu4dw33dpj0WoyOHrSlNs/iZYnsdRTm4GhnxnT9MVvG2ABMiVi8l8ONp2+bST72/wulzu65vKOUT8HhgC3MQ8H7wDWgEVRe/ftE1FZeFUBG71TU8vV4KGWnGUKNP0O0HoolTllqeEA9AA6ndbIZksMD/qO5O1biklDrwIEd33CjBwdWdFdYlbXv5rIWUQS0HmhUk9MdZMn2m/rFsuCKdVtc7Xkf/pcVQpQzxIZT9UCMigyaNTVLiV8EESFNsVFi4vwZt5mJpArlx3ZBNusQF9c7RtW7hMUUcmI+4VRmz5DJW0NppzLwXUTwUYINXccWqC7i9Gk+LzkFTWJ+BOwXC6Cim7QNPMPDgsPEccpKZwpnIdPo3ZfE6uh01RUKoJDRWmH0ay07kuuftzY9Cz0fut2ypRlc9W6EWcGe08JxAtShmGvMwwWHu+1j7LMflWXYU+z3M6j1OHLZ+1AClnRb0hdQAne24yjOqomiToa5vcg1ShnPFCfHCWTeFGTXSFp9vp5r0KRD5qePn3zrNyF5wvg67bOTdYlDZNNkV+v98lGN6IkLxk9Mj0JW3TpM5epOLZAmUpZtUm3glqNvQDZgWaIkcWO8bUd7pFRFyXNY3jUNAW7FgtJrtrswPL/JgL4c5CMLnWnYvGLGHbNkVbIzfNf+7SqY+PlZtNODfsvm4ZU3s5CdrV9Z1OWmY/LF6sg3TIdX1Fz5G3c5g/QwYtScBJsQPOq8q9TEoD0X7BXEAn4uihH2Bu6cPnBuZXBERURleQZZFQ+MwEjT+Hh0eLV006DuYMpIQDQwG+ymL3JszLBuq7vitufm5yDfLkzZmf3NxepJVCJWfzXdeV5nnW76Ge15V75QbeQQRt9KBscGqzodhsQ2xChnzOF0Ls7yYGlF+PZ4YPe3Tolv13Xqceuqctcb3rmRnF/uvrS7cvzTBIEhEJQM/ZXbFYxVLrO73e9SaeRFUdDm1bWbFy0PhcxRm8PCNHEHmO45BBCGBtFtsAKhon+mhqy90WLLeDGMhk1FtoEDczVlFkushO6iOs6DMBwEGZDNbsEtE5g3zbtpyTThOGptglkwqjuYsNDLwd/F/Z0RI43VdFQRGy0XaVTsSnovy5cRgVJE9dy4t2nTKCHng2nm5FvwFunmJCrAYUh5DQHvPd5ACIPYwlH0HUo5amdCzw66WeibkQDTfBNFLPmfkFumxc0yvxlOXTY5LgKrwMC48pRbY97okIwtiE8zyV6bUZ3GngGnpxCb7CAAF+HGRIvLUej9zQj9MoDwMW4L7vGVQJsIb39V6WtEd2Yl7UeWPsH55imnJ3rdBLbjBVKOdZATGa8u8ljOe8Ts093FrKraYAEuYomb3XUf8jTr/VXikl1Zw6fWJBIwpy93V3K3RUAG236tO+0+L5b5ZAoAxQGuT8Qahk19eMX/ORuq4rbcamnaYpJuN35ZiH1aknFtEMO1Tp7NreZyux4KVkNKTI3UG47bC2ZEE6M4HySTZIzkuKpttrc5gNHDJ6mSblFaSryLMsI3Axkvd7yipsi4GG61Qk7iLKzGLrPHPFCYsEDjmliEafQ5QqBFZya3wpLy/VT+xF0+I5jG4GDofME3Up9fBUc/O9nOA1Vn4GLv5LKaXm//37/24JVmx6Di/HG3i6/k+OjOfmYWrA/KBpmvT6fqUf//rxyyRbUK9df16uuY7A9cxAtI4GoWSDi5NtJfv0Nl6RJ1flUxvUpBVlGgDBa16ImZno14fHVKbGuMUPn8FvRQ3arrOKMnadCkpH/t7QD7JuXZYlPZ9PwZ/c5vwMGncSb93i1e00aV6da4e9qmtePs3FmZuc55n2Yy9SbLNHknVQeDjzv4mgY4bhGYDeTzrJ0sty5mPZTKEYrH89v3RbuKXpOI6SDjTGpgDdcnqMbwLAAJ6j99ktta0jANu2pSM+qE+cEe9X5mKGdnF1SyQfPrsev+YDRmehgkiwOVxn4lQVn4565rgzVYGPdwacTMGjHCqs0it1lCGPOT3muco6caq2M37bcJdsXaIZtAp3HISYSS0sePPYqx7MNfzUxLxkmmN/1pro951sVHmGbt7AVJmfrZ7Gbmy/PaEa8RydtIoADbmD54oDRhSTv/j5NmV3mj//5bb02AUyIHl2VBzqObqMPvH553nWe/F/Dk0JKr/bivKZ53nWzcr6d8T2PM/U/N9//n1zinNleWmEhT+WMJQ/fl37FTUOY/r+/k7Pr2f1Qt3seN/37K0b8JybGXzGAItqHWUNE1jQFVAkWKYV2hGUh1//Oc4jTViXPsu1HqfyP//8I50MpZwW57qKI6WUXW6ooTS2bGZRMYiG6zuxX0GvhLt3NSWHxQO50t0b6ev4ecTCTdMk90Ru39IsD4KvmUA75aeC98OlMvPHLHBIvKccsoQ/824n8h09mYRaQX9xYMAPVrnyT5MyBj0dAC2PH5ie7MWB+n6/a2fM2LSP+SF2hrt78t/n86lN6LFyzX9+/+1290DpGUAK4urp+k4ceScvek1a9BsZ7XnMj8oozLXroDAwKZ07xW73E1HprG3zy+nrSFr/aYVjDN7aVvPUJmkiRzC7GJbB2L5lKgon0DROapYxzcby05Nt3WFDaVdNW9GoPZYZyFkG3+NQLQIFgsZAjv/rPmNoeOhHMGmjaZdXwHWnI+K5h2FI7+VdHAuNNCpn9a5P67rIY/g09rerRiGJfmbA0DBzE7ia1A86eSWH+YRLcfk+lILw/z4/L4ihP3tVHPHMXP7teifGGe6zlVLKdHenlruZMKcdE1KvF+WUbQ2rD6XSndLP759VbgRMYcwN5OMUi2hdVxl/QZ7b1q3iQE3jVJkLuI9vJkYGye2DxMftSB/UBGlPFvrvdxZp2ULp+po+TpwC0CkkQL4XNJN1Keq7+7pVC0N7wa8LCyJ5Akevw+cGrdqPXdAnrvKkVw39oJSvT+M4AJVKC57uimTK5nFlqVOJmrZJ0zyn1/udTmZP8Twy1f8KCv4sMig+XtBr6BeLlrytAAkQOFkpRZrtdRY3EvdWZp7BZ+D9k/PhN/onmkjf5iUez0jpYlFZZMvcjzpfJnAxmEM05MYM0L1JooVm7dcWqE2VZ2FXqo/1uTGej6cGfZLyWm77dV8yuq6yzWNTg5Bw+nESZ3rIVpH2SGt1J/lM++6EcoF4nMYwcOvPcRrFlZKKMnhllGZu8wkFvB/6amPwPDwIVNy2iBnjxsCC02PlWNzk9mG0ANHz/XpruHhHDyX2LyUivUsoMDlhCe/02h0WAcm23rNdd3lnKpubjxDR4Ipx0MpFpx+ENHE4CHoNyJg1hoaG90t40nkUmbUn/1K+6jlYTBzP4vV6VV5h8e7yB3iGzyof4vl86gr2Zvi+rvTjxw9l30lP7bakqQiwJDdtsskBpgVciw7dyZ09ft7z+VRsl5MmXYU29EMVcNlFc47+WUgRVqHXrRiAOZpyFhXX8XWXWUW2gOnk0vf8eoqeD3CxH3ut2YjZSiUljRJrmqdis2/eT1h28h23bcuy3dBjaFDbF/TuMc9ynoQBoCFpzHLkmhg3TA7RWdN9X+m+r9QHNwqGA15iTkh0l/0tjDxc7OYgSpU0HAuQWYXHvJEehbyYmQSzFvk+46jYdxUzmJuDjeAeA/SMDUrY+P+TM8km02yuK3SjzCrPlUGoDvPDY8il6yquGE4LmQvYVU2gJkMrsTa7tvKSkhT3umQY7DcKG2WassVLpnw3WsT+oNioSk4KE4J0J6UXefY7G1cZKNdZbVL+3KefMHoE5ZzE9NftMN2N0k+jLM3dS0Kw5Ya7c70jfx450fd9mqe5kgYwUabP6I3nBYjhaboMxXJw5q1hJM9jDSDmv/WVcLEcBi2RaWXw+36/K//fSp4dz1ScNaqSkPayIPd9lwskfCklb5ni77NH4r8gfG752pkunfQCgoX4vlQIaEfEADGwaNu2rEkXZm4v4fF4lGzBYE7CJIVS/nq9ZC7ggigPjPEXv61bjkmzXGyuW14QvQU3GS/WDdkcKtaAshzGFRvUERM3slMzb3i8P/jKWpTvFuBDBfkyXJSA6A6NQpKTXy7NrojVblSaaJNABzHPX5+XoHWZpklZI2o0U5m4y5EjdBKZF3eIwZxp+vnnbOsq/tNF43scmTKDafjQp5Qs6Tj6G+/9VDpduYYHwvZ3tK6rTCz2Y6+VoZ6IGzeDE2I/RXNd26nEhVflIwPvqdzmiE3rE//KBTQ1ad+37NNsXnByVkRTIZ1FbJRi5Wh+UHHVYTbgU1130RanHq1FcPM5nWjgPh3I/WcpObetQ1F4AIWSndmtv9wCRl/mFqGsg27Q971o+97bOLMXYMHzUTxS+brOdJ6HXNabtk2D5QqmptHJ1lmvhhkBqkRttDul+77kXPJ4POLG22TADew7TmPqwhiBQCHNim76iVQNY3Po0Cbq0B6Lcjd3FJgJyBbSnXRi8wzVLIcFqDuaeM4KnsquTvQeEEqKa1bczokeTy6NXV/ChIxPJ0mvRZYfe6a4sFa49Ss6ftuGlDdVOvfm75//3F77aVIdDdO+GQfpLmHzRIYxeNO1Gio1hmZOHeA/25bFN55q5JvCa3dXOEoXHf/bTwBOks9TB9oJBMdpHNNxZJ7XPM9aIJ2dHLzgOxbmp0s9t6krAfPv7FI/DGZT1IbktZNZMv0HEgGfaXjc8hWx2zmCLtSc25bm+VEM4mLTneEN5WIiz1DJC7wXJw11Zh8LqorDCyrOFqWnp25xi3y64BSY/BB87f0obGIBOcG1E9Xf0gB8dsOCdxmFjxYGu4W5YfdtV0/ipEYXxTHr82Hztm0qvZ0823qfgB6BXPOjOk02lUXOt3HqgBwDLefbNRssWJohn/oKcrMGzMl1rkpz/ykm/f77fU4Cqc2dUDxn0Psat8907YWbJbjDH6zYccpCLcHCOpHzIj+DJ9aZ5xO1ubOZiXEoBNFbQ7cUlHAMqItz+qFyzWcelKv8zP04xHQWudLCLiUUu+5aotsWlxaXWAPb88/3j8g+9yVzyg70f6oS/jzqSvcSQ2/uP9M/myfszvMsdrEnBPh7doqMU3KcN+eHzL7vqfnz779uEBKGheM4ykzOT+PPk4HYXU5V0AKuQLD/ruvSusQON5Nlcqx9l9PTeCPl+dXwfcTojQEmti6cTOd1pqHv0xY3oCxE7RrmZanEi1w6kQTjloSDJgO9mH+4AIyTuPg1lfyMaZz0OZ0P5sxgMHpuRqTHbiHUd724Qo95lk2Syw/UdzRNdq/sigyYspDP0nddaoi0Dm9gj5Hm3cnfyrT9LCrd/CG6gnu2bqsm1DwXABrPK/GQIx8YY43KGkJy64FG4kvZGMFnef65GRLy/DHq6Ic+vV4vhTRB6Yeu1IKzD7Zz+cu8LOpWx4h94g1Uhj+Uh12CLHnPIOgzXt5jfqhhfr1elekCijHvKa6gv8BYdZ0At1vejEcle013nFTxOZ1VC3X/ukuGCE7llIvqS5pUYfDuPOmBPQyfOOmu80pz0F7cxr8wlHNjzMuf4pZx+Lg3Vq30MG2nf37sexqDxbwfu2pvRVuEs2CK8CBQQO8jyQF0f2Px7MyZEcRpXVYBEMu6aBPDIyPRy8skJ3hSmehWjBvqOI+cLRIDR+XJp6byYlPepIXuCKK3Qx2aEbasoK9Qkeiv2NzbtqWWdKB13UQ448SFOMeDwNOJnc6JlJqkDLsSd9Bq+swDlV75TtX8hGmqMj/8FOlK76NBXgzOaKypWfdjV0n3+n5FQHz+5/M0a/IMUsaM5zgO+eiyEGgamcTu2y7zCNcvexY6p7RiGQADIj9xGIcCp0filM9PWhCkxOYvnCgcOmiir1jIr/crx0m/3+n753fq4jDg5ISaQQARG/wID1/q720tA1hnVKNjYZZyp1s3Aac0pdm+F3rIJ1tWfrgpcuEtmYtb3EEXIhnE6DBLJTJe8HlGmw5I4GyQdVvFRMg9U/+LeTgcOtAx+R+nJk/SHdp0dIWFKdvHrrgQwiLlqpQL/MdJJIeUJulLO1eJHG6GQ17newPGS/cbyJsv/rnfNMuypKZt0zSOSiFyyBCuVzZ76CslJZt3WzcNmNwtJN0pzVMpMWS9uR+V3aWr17wZdiYrwh8ZngUk6kYPmFNz0nFLMdD1aGnAD6FkR3Gg/JQZ9JiV98UUUKE8oadwirgo9m1tiu2MjNO8lEGLkFWTKAZVp+0KNcXRo/8WIy7INhUHE2ZMDFAdQGAGws2JaYhnvPC8kYQ7s6Ft24xivd/vQuQzoU5Ftgv3DcUQnyXYEroFO9AHS5zWemkx8u+7Pn2/vitekDfF6b7TGjcO8k1Hsij13FVEN0lc0biwMKcg28LNp/ctU6LHYaxCe5RyajapSsHqSokjN/zoIehN8IHFipMMejmEXFflsIiir+s7UUVwZcGI2gl2TN9lak2iVttUaJwcHLuSZoUVqksKXD/v4is1uKnMFUjq9eYexKgxGgs9CmRTb8zv61ZJym3i9HqfZbkWfRon3fBDP6jc9cEia8zRLn6Ge3D5LcfPlsVRoIWtN8LHcahMQdYoVZmhHeu6pnEa5eFKgIufIlyPzvqcownKrNBT1jFt2wrnl/+qTeBHmyfQiHlq7uv10suh10C2qYdMrPF/eehd10mg5ClTfpsJLh0H+X3N01xlqaQm6eRhAenfpTpx6fF41K75QU9pUiPDCiBqn7u01lTz71zF+N8MODhRpbVeSxQb+g6gaofinUbCQeZezvzvZVmkpZjGSfJhZR3aZ6GEApyRjZHJEXyxD8NQnDdT0afDEvbnqmi+JlW6HCjwlPb+nKQRSY1uHFjbx3lkPQiTc2/Aq6iAiCrgFGZo6ORF/vNp+f8pEaXkAK1yNaH6EZu+w1QFwaBZBiTo2q7EKRjbWLVo2wnOdOiaz+Z6hM8JfWX6YJb83nt4biIIjpP9XHLskKRzkXzGwG0AWAJlXQxrkTiTWAbcXHzG9/udVYimKXGEp6J748kVdHoWnbuO+N/9b+WUG5D/Ej6qucylaLNlWTRs5ruTq8gNyrPx5+1u9ayh5V1i9hz0WJalVETRE7rnGT+nbbKw6nPepnXmjEcf1GkxRwMq7D/8qVwU5HnUn161XOPufXQch0JCqZ/lkBJsU8qK6vT84InJTLutkR0fwDELSU1mfF7X9cuL/lQrVnoG2zAeTu/oiDsx+lzHOU6UeW6led1X1f+RGOwZ7N5MiqFgvDlnnrrtp0+kKYdlFGHaHQ3frruaAbhmg8GaSyNkdPcR6uk6foz6LuOcHfshqQSLMgfdTJUxHZ9RZh7jWA2IeR9UFyopP7Ixr484B/+MMKD5Hf5d9M7+7z//vj8FS/wChnkuFvISRbW3TUN9Eop2gqgEPpQPhYB23SLG2b7MFx7zQ6cbX/jxeKiEQXHHA+Szu1SVhpEmm0XoCbv0DOu2VkKjZVlUYkjQ/2FXypzCQ2DcGJssQuY0ftv5BL/6mWbyDX8IzpGLzVAWwnxg2o9oic/FbIcF+H6/09fXlwJLKTGZSKP4pKfSIRreBA61MhvhfaIMZAMixf60lUJeS7wf8zLvbz5NHNxgw3lxLoFwpSxlsdSG8Z6REGjQaKG2TdOk1qOoqEeJ96qmilbGuC4AurIrC3mZTCc9tpkBITl3oAeuDuTveX903ZkOAw1m6AfV9n3Xa7CkmYfprh1dw3bT/3mVVLXt+t+wVaVYM0GSu90junFvJZ4ntjkOdfot86nDcQWdG8g5MVIIlAEo+77n+UZTtBlsTsoe12Ig2qLJ91x5FqbLqimH3X/XzSD4nN/f3yrH6OvQ9bgLJbc2zHBg9+fX85cyGbST50w/4dw6xVxYVqWL/Jo2pw2T4cisZ9vzs9m3Yhjot37vEVce9H5eZ/r6+pKdfaZT9On9eucPM5TINCER152OY5csE7z8OHN9iRv58/lMr9dLN1KFJEQ5BZTHRnN/WyakXu60XZ6WPubcS21pK3XzVRZGk4qpNCe3/xnmKf6g9PvuS8AFmwW145mKqQGLfhzGKn1Xsuahr/hd6P7dB8ojBbi5/PNAF5e2ImBgHWCxUZwwql5o3cQxw2sYY+7DfI0ZmOnvh4FeczXpPosZntjcbUHNgImdqSwaiA2Uj6tQkYZ+qA41p4PwLHWDNPkwUxqtLWoGkF3XVSIyNhI3r18OgCpNbsaK1MIbIC+xOFmGflB+OQseCxivdakJMWvzIQ9BjA4HoqN2mgYP1wECFoH7xjppsXLTsHgG1fHWhHvPhHiIz+eZEu6+IgaADZv8lvS61qFsFjVZ8v2QkaouXFYckIDpzCR3nmcpNj270bXTlDb+4j2JyuknHEIgQR45xiBTjXyYOri7f0UxsgbdKUEQEplKO7IGqVX2UEMd1QaY4gvcPzsoH+7ysBw+aUisORjG7hPmji6U89xEHlE9hQeyNqKHvLPbqmFP21SbRxnXFhkMWpA/dKd0Hm+0soAlOyfSpEF4pF6HjoHhACcOpDX/st6z0NwROHMchwZ83GA12+CuSJNNaqR/AT72gZlo4tFkbuumchQXSffvleNga9ScplUU3HXdFbVeBsvoEra9gqDd4O7Ysy69mvoaquOT58rTKwiBGj6aZ5RTvwnoYVNAquy6ghbSWLNugHTneZaRhdC4JtVlbpRIyKEVzhQHFI6Z3otCl2GeIqVo2KM6yfHYMwDUdq3MDTnU3Atapf+x61ne952+3y+FPp3HmVogRw2F2k5wbmWPEmYK/VAilJ1O/dkAya3D8kdYVJ4669Ntt39smza9Xq86G92wcq5N0lL7vs8BKzH9neapopG7CMa14HLrICfR+hdmM/Qfuo0CxvXNjVqPgaW/lBLBMFXwpcPG/DxPZGL457egBo3mE8wJ6g79kkEHDYibclkWeXV9bhK956boPvhdPhX3De23E5Qkv30+B6ncHrwb2dUGDMzw0E3RNdU3EEN9zIenLjT3bd0U9/c5tHZUi/4X90bKZh0w/qJ4oOigeWBAtm5v37Vdej6elXRx2zY5/PmU1mcCd7oldFHjmEpGe9d38mV1aoPTF+4r85OAh4dhEAuVTUgjLgOEaOAxFWCxNCkzT1mInIpe3yMvxS3EkRhfiLCLYd5yusGF2vZNt9knmU6BM+chAzSPfOPmxEPZE1+57aRjj9/NjEM38FmXwsDMNOxQTqDJuwMjm280F3YOVn+PDDy54delSKDh8mFO/vX1VUrxiGcgcAjUkAEkHC7/j5u8eezfMGb4dtuzxsOjs1UVhESbjMRxHNPz61n6kTsOoP/8/tvNTpZxQTh/n+eZvp5fMg+j8+cXOJWDX+J186d8Fd8iJt1ehsl7CgKkmX65w4hrVDjt5nkW6kbyEyetvzwv+TSXCcqDD+w+oUM5fduCdGWcx1E7d4jvyW0LCOEzCv/zLF4fDHpMNugVGpeKeWDadFjUKA7RWxNz5wcdzwKyJQCCBoXbXpXIXqJ+JksppNNuyXEYVZoykONGwaqHjeDDYveoYmjKOAGo2mdf3OJkEFIdIO31sQQsDoi2yAEANlxe3Pzx15/3vu3KnvDmlGQesVL7XgJ7D+90/FklU3Bejg8Ttc9bKOdjXGlASxxoEbpqhcJEf+Qokm64mNC6Km5dluwAuKx6mH61u1ev3wj7vmsKjYDMcX+VJGHzj2S367sc6nlfFaeMn8OpDVpDGersBZmokbab7gqscMSvI5bbctU9Dk4sgLtwyzzJNTeodzic3PUisrkMTb1bPznsTF9A1aEhW7wXxHcQW/ER4316jqWcUo4cgNRZf+XWrUzbH49Her1eaRyG1BqipvyZ40hj8Ku4LT1yQ6zdpuRNypmfMtLhw0/uvJP7OJ3ZhVgFwdEZTNUmYdJRMrIhrkloH3LU6zyz+u66K5jxuu80DoWa7vJPj4DzibIzAEbEQYaG+OzBh5huPuYuKopy2C1kPtzw0RJQz3PyO74vkzybNFPmOS3G3Tl8cSuSm/L0vitfJ08g9hvFbxXPqnfZM2Go6c43MM4ynjeZUob30WSwsFwl6iZ+jkL2Qy/kbt/24hDflOqC3sGZCTps45BViRV/5vF8FHYzh4ExxDm4z+NQaM4ns8KhdBdR0Udt25b2uEWbf//2n5sPizu5J8TCcj2vU25+UCJY+MoKj5JCGd5NHs5s6ya68WQ7mom3UwucZOauKNd1pa+vr7Rvu2p1Tgqc5x0x4aS5zKG+aZr09fzSzTdNOU3XnTW813JAgIFk0zYKmJFYLIyS1XP1fVrjmXhJxhwIaNPNsb2XmKYpn4wfvRcHDGnBTgb1z1sF2sQiXJYl/fj6IUYD8xueF6c5Rm4ug+iHXn2oZ6m4FY+bj7u3ARp8+hgfJTQWyFr58JoEnPkUNxrcOnpURUNwONjn5HlgcK3cybtQZjiw/XaCPr/tW75BhEBENDDXGYvGjYHf77fy8jTAg6DYlJqaEymrzTLz1YPkHeIDVTiOIy3vRQgVDT4N6rquqkN9ysoirppyj04wNw9HYFy77T5XbpXJBnY4m0OEng3fJg+LcZ6UZghtU0VFeA2PzWbXZiQMG0z3JIO68nljC0ljURkq5ojctm8VjYLy6/pI5WI+4TR4+k/PtHQGQNbeNJUktjIctFPaZ1tVaOdd09Gd0sSzl/eV2eV69cDPd48xyluoRd4jS/ceBu1aR7EXmt9+//0Gg/ZIg6oPMbMtmnnfgT5wcwNs2bFYzf3JPeLqRQy0b7uGin6NQzWQdiS4RzSvxArwYj/nMJzUlYPKdSm/gjReamncOLgZPIaAqxq5plPtpU8xowgXcjlVRXmDAau6iQWLSQiQ0X5g3fp8wf/uNE6VWR2bwm8k97n1tFsfpN1hNiET6iidfE507Ed1Y4BycaD55vBhMGAMNBh3kvEN5L3jp0zBvcu8bNrWLedAIt+1m8oNN1ivWmcxM/J32dIsu566arY+hmfeWDkb1M2/HA50bpIPlUiAOs4jvZe3Pvz8mCsVnkcbqPk1kzuf8AIVg5vD6/Jr32vQzuDcilIRsC2JtXx+n09wy3ELOpLjPchnUhW9Q8WGPc6KJOoo2WFR2GLnGhDg+fb8DHxreV9e1rhLCIci4IiXLOdxSJODq77D9dyW/p3ZWC6EcuSOW5p34x5VHLZeNuOFDEuc0tjZt0M/1JarMQvhvcIC9rmMCJnGQmDo6xvuPM8M8wLxUbfJo9SubSeqZV/YhwY1/kDEp0l3RXnw+t6pCqBSbdMW3hJmw/isniUDQn1KuqtTRzOTYRTS5mjSbiZoDkfrwUb6LWGQTFf5udM46fP5qcsAbN3WX80tQgZbUcxtYNaYmdw/P3/qlAVJcVNxMkLIYqQUpiwY+kG1N/OgaRzTZqWnOxMKobMkWbyhHGYVRWc/ihl3KEtdD0N/5RNrDgYm2zLhCLM7FIx8X92yuOaHkTjxeu7N62YLd6B59MqYOPThsQvxkzXt5a4zs0HGEFh1XVdCPH1CqZo7rPV9mutcHzyaaNLh47iuvQlI8pM56xkUHg3gCkM2C6cXJRayUk5phmTEEDsK5YiQZ1Q4Twc8HjgUeaw/k2VdxFOSQi9o5Px5z5vwCfenp9c4jTogUOPx2diATgTlcIA8yK1Os00jrOxz3CLNq9eTojjIaNLZHPJphv4R/aX3PNxgOuEtmxKyIjcXxgeYeSzLIjYtm8NLUJpsR55u8wtzbcwvdrIRyOqHARSV/dirG89lFY4ICibvjMmcB3hJYYYsxL7vM8KT7vR6vwTRcWXdhsGP4ygndi9n5Pj34dfbNJn75LR5R5s4jXiB7/dbQZM/v3+qOa5yLVKqeEmiTpCqFDnYLv/ETZ0TGjKmp67u4R/lt4q4YzHkmqdZKao6PfuhigDgn9M7aBocMKWXeG6I7ZtGBstNDgaFfQwDeT922fh4iUfZRLmZUkqv90uHFLkjj8cjTeMkKFnO99uuTEC3htWmiak83loypIt/BkmSflPl5XVXNKRhGAQP+62PnzBVDM/Hc2VoD9CtnNcpwwli+ZiuMxMRMmZ5m9zuosrnU3+v5greuPCg+AHgxD40cmiUetiHY5JHxlTT62vn3HB9c3LSuHLTOKrlBguUU24hSgnF6YltDNoRFqtTIL6+vnSaYZw3fPj5ehQbJw5zDQ6Z48h9lZvVfc49XD7s9qh+5X/men8yD9h4juD5s6jg0vidDr+LAczwbdv1s+hLvQxz2Pjr60ub4zQZtShDXaGPI1YC5ZynWbmPHGTQ7z0B4NNI7tPpke9RJf5GOcjN7c+K9eOlISMLtwJyA5FWiTyhusJQgBcoDXToFXTi35d24nVdCh9xghoPn0WHTc5xHFKsUe5ANSDvwnMpvAn2ZlY//7zS53/IDVnXXAIpFiGQLqdKk7vhMlnPgT/P6xf9hjNnh6GUK5xs4zgqNMcBBkAEiZOMGNekpqKiYAPqlv/Y5rCpWCSgQg6gUC6tSwkBBQVkMW7bJsDjTrcM1URGDar6OIyChc/zTD//+Rnmbqc2AKZ/FVCT7pTSrcYZ3pWMIIZRnDEOQnybXedP3/jfpOHVLCXdyhIRcHFeFeLlLcXQD5qmO5WJJC9lFLrNil+D13mmwaxlHvMj3elO39/fOk2cZetw3qfb4HVeMo0GVnMKg5/8d4ThtOFQzknpzF934KOEEBHPLGw+lXl8Fj/VlEnRFKWaZkJNqlzinT7CgsQ4GdBCsORxVpEJnxoaTBbwiHIqhAuGnG7hvmB8Tn6vI27YGkH34CRmeIuBgpMhmfMQOMrGx+Dg8/cgZ4W7xxjg+XwWAmRQVgAYCh1oVT/pg0JOcd4nv2caxnQYEOBafVdNAjAMw6CgWB8tOAeOMCUJpgzx2/c9N+nLsojpqbo36nNKjMfjISLcbgjCONQ70PlZGgLGCdH1XXrMj0q1WLngLUW+2QIzQ+DrymmdA2qOqqxi+lzUZacczZ0m4SUhC5Ic7h//+iEmrMiE6a6C7VmYPuDSMCoVUdCyLIJvs+tgMbzzIBhMDFiIUOY/tSI+2/ml3DMLIInBlrUSQ9GklvlEiTRzisxxHum0nHcWJ3JVFzhp2HpfamzdXZ4+kb4EoESeA5G25TJpn80gz0ZKsB27TOaq+O0ALTh0x2EsvWYqtw02U0zkvS+krPL31HVdatnt+GHhpepEuXVd0/Je4oXukeOXDFsuzahPN6ssjri+rvuSZajfGtVEHkQs+hC+hPdIpErh1I40FQfFx+NZmyeYJ9WBN2scCJws67oqSRXXEQ+2/8wP4SUsyyIDAI+P8DwVd5R0RMjdYdzB3Gcy9DoygDivytXQQROnmLD40I04U3U/jjRHWYbZAguGzcAB5u8HvRB9lwwm7GYBDXOgAaTp/X6ntqmtXblpXA3q5aJvGs+xcX0IPwu9EQzrihmR7uoA57NP41S9k0yRCbQMjfI8z+n5fGa/U5xHIjiR4UvGsnt5p15BeGvMyFqT95S5R4L2QgvOz6eerMiDsWhBhDzM3r2KQI7c50iWmsQ/R7JS22S2sGs8Lps+k8foLFU2Cf2WO5TzsMW4ZYGmQj2fpilyMpo0DH06LeZLZt4RH3Cnws8CUncaidsTjdMogzpHcjiccALBWZCQHY/J5pDIC/JQQBHDxb7rsul3LDrmVNLHmNLT3WA4kfdtr4Rooscfxej8oFyL2ds4xne3crKLMvs4I2gpesTst9xUBFt3ZIRpAEAgD+Xo56gO2Cxt16b38v7lELiRZ//4+iFjYjj3tyUasbCUDntkOeLyXtJ1ZQdyCWviFxR/rL66tqgL3aTaPYocZ+clQGHBpBgTgGVdKvqH15YsFiSunu19mYKRkoRm1lVz1dDvKCYRcj85dt2qlFO+iW+hWUuOTw4SoEzswgpIfUZwgXiWblHqiGFjoAnJrsxkiE72Gcxn5gbMADIQYRtIOfqBlFERIBhzZ0sQKJweKyPrrWQNcuv5FJ8b+rBZlnJYUpPDWGOdUDHw2WW08cEioEJxtaRr7z0ubl3X9OPHj89EWxFp921Pj/mRMwpBHD6ba6dPs4h5OWDM/gG8fp7mqZrIVoPIVJAS4E00DrfBoU7FdxiTL+kesz7wpFGkzODa9am+OwWSeoR3rMOKzir+zBdxSLBygj+KE4sYquGWwUab5klWQZz4msEcp2DXru9Ekf9Uf7LZvHQTY1alTx2XrTnCMKZlXXL0dizwT8vYTwMFfIld7zE/Zj1XJtDutOjI0TgMkd9YgBUMB13opECjaOw1FA3EDMaAk1aRjvtm4T9wrlzHRPqv9zOOjpUM94/UnU/TYm+6FPoefkgVpSCC7oEJ3U1QV5/tYh7cuq5pGgtlwF8MNG0/zYpjX1MFqTjETH2KM+OnEtATeLWIw4uVU95PKWeh8nN4afwzSVsNonbTNx0ifVc5pXDNO2GQkhSIFZaBkzd54X6r+W3atuW7eq0uZ5mtQL8MPJ1L598ZlM+5YRyI7osF9K18P3OTyYGjKfVtV4EPIHBOWsQfF+2/f3cNE6MMp29Z1zVrQIyp6wirO+/kjVXY3mTBu6sK1U7zz8+f931nrJ+X/V7eclLkVHg+nzUfxybEFdEualEyMMDIMVdQfvqdqhORsEpsNZ2e7qZphKRM81TKH2vi/TaT8q1p0uv9rrhZfpsBUTrcqOTUfU99X8od9AJ914tqA7WDoBcM3Nwni7ITdZ78bom162urf/hDxe5zT8dxRl8zpGVdI9I3VebjjmShTbnNWdH7EGVIXlcWT0Vj67D4MGQyIFJmBxvIM2yatlIywg6/r0L9AXKFWwfs7PD7tub36jkyOFx6H8Xz9JHEgGqUQfd1a3CLFxYHuZMvQW+bttFal+XVMKTm9z9+v7GhUbJQk93JnQEJme8zIg1nRM+P48rkAaWU5A+liOeuRK7lL9qmLZRgpLL6DII/65RzcOzn17NCsbw2JjnrtFvJsW7QJxrz+77VlCPbzC/e3FCCSySt+DhUMyFKSD+5eKHY9UucRlrSNNb6CRsS+vCV5+GoXCXvbQuRM88umhzEY04ybqbdd51Sd30O4bcnJTiokE//ZXAX/ZA7ixCr4WpKdN+eZc97hJ7iRNUzAledQo9wzs3GU5Mi5m9Ug813deEU+S0Si113Os+c8+gVicq/3ESeSjXC0LcyZ4uu3xWAlCK4RnAad21h2DoNvTF7eg3owgHjvbzTKx4mAZjrtmpi7HSDru0qevOdbp0OCvS5CyVh2/eUoHz0Q1X2iJUawETfZcUjaVIXCJ37JwUq9HjmgenX15dUbhpa7Vsp0+JlMxBlSo8RWtM2wRPLe0dBROFESELSnXI0GAQ8ShRvUtU32hxl2/e0rEvVzDsNJRnnSbLYQKVcpnAep7h4bjD3er0yyBGf8bxOlcWQIl3h6CaA1W3fRvlJaZnyjAiDuHEYhEZ+f3/nfx/WoZTGqUnpvSxidfA8Ho+HlLE+i+IAbuJQw0jOiafN//v3/91+UnwaDvCXoLC7y4fLY/26Zw6gMEzELF2XNnMF/OQXubLPcX6ueVizrknW1R4zEb++weD5PGTn0dBSJvlC0FT9vqrYABfkuGjn2I80P+Zf1IOcjst7SY9nplBP01QFFPlkvu+61LRt+vnz5y9OKq7u9GfmGwQRFcxrEDE3AXSR0acnsXIbw4NAqF2AGxowBm8Le9JPVadTPEC0oNy4NSqltmhCTZK1qd/qHIyP8D/w1DJnJXimi89J3M+YeRXP32dM7nfMWjrPM7VMHcUr6gcNpBjPH+dRhc/4UEsJRhbVhTu384iw7Zet5Z3LiHEYlchUcuxSTEWbNE+zECsP3ZRbd9S/+HF9xrgxxYU86HrzT16OyouYGD+fz5IUBarWtGURdl16PB+VCbUv4PM8c+xc4PEcMm7CIKtVyxhBdkuYDrcegT1DnxOx/vXjh7ho6Bt4DwIfIm7MESw3u9BpbjR0Sm0OIG/cqS6u69I7YK1Qmk7jVOKoA22iTOq7ThqY7+9vBXW2bStTEG5PnpNLcJkh9V1+Bs/HM2uTznwDztOU2kYpq5kLN44V/UazLLNrkgvnB0OjRWDjjuPDGI6BcQpAIoN05w6IDIX8FsLC/lPy6E2w09w936PrujTHadFGc+rCKGr5fqgzxkFcsPFnY3gTqAl0an5xduT/L13JXpw7HOp0FupoQffSIVwZ24cFgB7BhVsuPOMGEPEuaP2UkMu6qAfMtPQhaDineFX0P5meb2ZuER4jcVbQ5V2774AF8lnPMfSpsysGcXPhnfBzXKPO55K8OswsbkuOcuUjjAPPR/cb//XKQjio976BfbbF+smldRkiMzdZlqWwmNvuv0bt8Xf+/wCjjT4cCmHRmwAAAABJRU5ErkJggg==);
    }

    #help-button {
        background-image: url(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAADIAAAAwCAYAAABT9ym6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQrAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAACDFJREFUeNrcmm1MU1kax/+3vJSyYIvQ9MWFSRcMEzfK7qxNqUoiNprwDSGo4SV+1WQSQ7I28cN8URM/uBFjoDoTQzJJLQkMLNEhiyHOsLLyupNFqB8MtDvDKC3eEVoK7YXe9u6Xc93bTl/uLbDJ+iQn6b1tz3l+93nOc57znEtxHIePQWT4SCQ7/gZFUZn0QwHIApBDWi7pO1vwsKIAWNK2AYRJiwCQ7BbxnpS9wwfBK68AUAhACWAfgAIA+QQoh/w2TACCADYArAPwAwgACAmgdsciElwylyi8H4C2qKiotLW19bjZbC47ePCgTqvVqlUqlVKhUPwGAEKh0KbP5/N7vV56YWHBMzExsWS321+sra39DMALYJUAbhPrSTeRsIlwoRwAKgAVAGobGhq+6Onp+dbtdrs4ieJ2u109PT3fNjQ0fAGglvSpImNQkvSWAEIByAOgAXDUbDZ/7nA4hrxer4fboXi9Xo/D4Rgym82fAzhKxshLBZMpCEXmQSmAU1ar9Uun0/mK22VxOp2vrFbrlwBOkbEUyWAyAeEhPgFQ19XV1UfT9Dtuj4Sm6XddXV19AOrImAlhpILw7lQKoK67u3swGAxucnsswWBws7u7e5DAlCZyM6kgOcRfT3V2dn7zv4AQwnR2dn5D3EwjCOOSQWQkghitVutXe+lOqdzMarV+BcBIdJElA0m1juQCUFdXV1e3tbWdKCkpUacKaTRNY25uDvPz85ifn0c4HMb6+jo2Njag1+uhVCpx+PBhNDY2ori4WNTSUFJSom5razvx/Pnz+cnJSR8AhrRfT+R4dyIpShaAIgBHHj169Ofm5ua6dGuMyWQSt5LKZLBYLGhvbxcFRFEUHA7H31paWv4CYA7AGoBIvD7JksYcAMX19fU1tbW1n3Ech2g0mrKJlWg0ipGREVy8eBE0Taftl+M41NbWflZfX18DoDh+rqRKUfhwq2tqajJpNBoN32E6USgUOHnyJKqqqqDX67Fv3z6sr6/jxYsXePz4MUKhUIwr3r17F9evX08LrtFoNE1NTabBwcG/A3gHYCs+0cxOkgjuU6lUZSaT6VOx6cuNGzdQU1MDuVz+q++MRiOOHTuGK1euxNwfGxtDJBKBTJZ+N2EymT5VqVRlPp/v3yTRZNO5Vg4AVUtLy3GDwWCIjw7JmsViQW5uLoRuGIlEPnw2Go0oLy+PGWhrawsMw4jq32AwGFpaWo4LcjGIAVGaTKayeGVStUgkApZlwbIsIpHIh//xnxM9ebVaDblcLqrvaDQKk8lURrYKOWLmiBxAYUVFhU44N9K5Vrrv379/D5fLFXOvsbERYrfa0WgUFRUVOrLvkYsByQFQoNVqi4VzY6d7+4cPH8ZEt8rKSpw/f150vxzHQavVFpM9UI5YELlSqVTuFsjY2BiGhoZiXOrWrVuQyWSiQzfHcVAqlUpiDVEgWQByFQpFvhAiUxCPx4Pbt2/HQNy7dw8lJSVgWVZcQYCiwHEcFAoFv33OEr3VZVk2ZlHKxCqBQABXr15FIBAAAKhUKnR0dECj0SAYDKbtjy+EUBQFmUyWMkwn+iYKgA0Gg6EdVFUAAHfu3MHy8vKH1OTmzZvQ6/XY3t6W9FB4HYhObKI9fSIQFsC2z+fz72Ryj4+PY3Jy8sP12bNncejQIckQQiE6bccvhqlAgh6PZ1VoWqny9OnTmOszZ84gHA5LhhDq4PF4Vkk5SRTINoCNxcVF707cyu12x1zrdDpJyWUioMXFRa+gZCQKxD81NfWGoqgYa0gBEyaIAJCbm5uRJfjPFEVhamrqDSnqiQfp6+ubdrlcS8KOdiKZzAvhuC6Xa6mvr286GUh2kjni9/v9S9PT0wsGg6FMqAgf09PJkydPYuAZhtmRNaanpxf8fv8SAWHFht9NAMsDAwM/rKys0LtllUytsbKyQg8MDPwAYJnoFhW7IG4B+GV4eHh8dHT0TxcuXLDw6bkYq2xubqKuri7m3vDwsOQoJZPJQFEURkdH54aHh8cB/EJ0E30+whIT/mSz2b5zOp0L/BPaSUiWAsE3p9O5YLPZvgPwUzK3SgXCkWqFd3Z2dsput8/QNL26lzCJIGiaXrXb7TOzs7NTpGLPJDtLSbXHZMkZxo82m62/t7d3kmGY0F7AJIJgGCbU29s7abPZ+gH8SHRJmmUmKwcJM+ECAL8F8IeOjo6Lzc3NJ/Ly8hSJUnxhX/F7962trZQAQhCGYUIOh+Mf7e3tXwOYBfCGLISRTE+s+AjmAZDd3t7+NcMw4XPnzlWr1er9qdL7RAEh3nrJ3Km3t3fy2rVrDgBOMvZmusOfdBbhy0PZ5EjtAIDKy5cvn21tbTUeOXKkItnmKxVgMpC5ublFu90+c//+/b8CeA3grcCluFQLrBgQ4UlVAQA1gN9VVVUZL126VGuxWH6v0+nU8dYRC0KSQfrZs2evHjx48P3Lly9nALgB0MSdwokmeKYgQssoSDlVB+CT06dPmxoaGv5oNpvLy8vLS8WkI4K04+eJiQnXwMDAv0ZGRqZIiPWQsmgokSV2A4SHER6EFhEL6QsLCw80NjYeNRqNByorK9U6nW5/UVFRYX5+voLfFK2trQU8Hs/q69ev6ZmZmbf9/f3/DAQCb8mKTRMA4YEoJzZ3kwrCw/Dn6nJyDF1ICmdFpO5UQCyX6Hg6RJT1E8V9pHIYJKs2f+7OSUlCMwGJt44M/31JIE/QeAjhCwM8DCNo/MsD0XRW2CuQeAvxUFmCaypBxsArG4lTXlKev9tvPkCgRJQozgrgUv1esvKS1pH/V/lo3g76zwAKbYlrhpIPhwAAAABJRU5ErkJggg==);
    }

    #help-button:active {
        background-image: url(data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAADIAAAAwCAYAAABT9ym6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAKT2lDQ1BQaG90b3Nob3AgSUNDIHByb2ZpbGUAAHjanVNnVFPpFj333vRCS4iAlEtvUhUIIFJCi4AUkSYqIQkQSoghodkVUcERRUUEG8igiAOOjoCMFVEsDIoK2AfkIaKOg6OIisr74Xuja9a89+bN/rXXPues852zzwfACAyWSDNRNYAMqUIeEeCDx8TG4eQuQIEKJHAAEAizZCFz/SMBAPh+PDwrIsAHvgABeNMLCADATZvAMByH/w/qQplcAYCEAcB0kThLCIAUAEB6jkKmAEBGAYCdmCZTAKAEAGDLY2LjAFAtAGAnf+bTAICd+Jl7AQBblCEVAaCRACATZYhEAGg7AKzPVopFAFgwABRmS8Q5ANgtADBJV2ZIALC3AMDOEAuyAAgMADBRiIUpAAR7AGDIIyN4AISZABRG8lc88SuuEOcqAAB4mbI8uSQ5RYFbCC1xB1dXLh4ozkkXKxQ2YQJhmkAuwnmZGTKBNA/g88wAAKCRFRHgg/P9eM4Ors7ONo62Dl8t6r8G/yJiYuP+5c+rcEAAAOF0ftH+LC+zGoA7BoBt/qIl7gRoXgugdfeLZrIPQLUAoOnaV/Nw+H48PEWhkLnZ2eXk5NhKxEJbYcpXff5nwl/AV/1s+X48/Pf14L7iJIEyXYFHBPjgwsz0TKUcz5IJhGLc5o9H/LcL//wd0yLESWK5WCoU41EScY5EmozzMqUiiUKSKcUl0v9k4t8s+wM+3zUAsGo+AXuRLahdYwP2SycQWHTA4vcAAPK7b8HUKAgDgGiD4c93/+8//UegJQCAZkmScQAAXkQkLlTKsz/HCAAARKCBKrBBG/TBGCzABhzBBdzBC/xgNoRCJMTCQhBCCmSAHHJgKayCQiiGzbAdKmAv1EAdNMBRaIaTcA4uwlW4Dj1wD/phCJ7BKLyBCQRByAgTYSHaiAFiilgjjggXmYX4IcFIBBKLJCDJiBRRIkuRNUgxUopUIFVIHfI9cgI5h1xGupE7yAAygvyGvEcxlIGyUT3UDLVDuag3GoRGogvQZHQxmo8WoJvQcrQaPYw2oefQq2gP2o8+Q8cwwOgYBzPEbDAuxsNCsTgsCZNjy7EirAyrxhqwVqwDu4n1Y8+xdwQSgUXACTYEd0IgYR5BSFhMWE7YSKggHCQ0EdoJNwkDhFHCJyKTqEu0JroR+cQYYjIxh1hILCPWEo8TLxB7iEPENyQSiUMyJ7mQAkmxpFTSEtJG0m5SI+ksqZs0SBojk8naZGuyBzmULCAryIXkneTD5DPkG+Qh8lsKnWJAcaT4U+IoUspqShnlEOU05QZlmDJBVaOaUt2ooVQRNY9aQq2htlKvUYeoEzR1mjnNgxZJS6WtopXTGmgXaPdpr+h0uhHdlR5Ol9BX0svpR+iX6AP0dwwNhhWDx4hnKBmbGAcYZxl3GK+YTKYZ04sZx1QwNzHrmOeZD5lvVVgqtip8FZHKCpVKlSaVGyovVKmqpqreqgtV81XLVI+pXlN9rkZVM1PjqQnUlqtVqp1Q61MbU2epO6iHqmeob1Q/pH5Z/YkGWcNMw09DpFGgsV/jvMYgC2MZs3gsIWsNq4Z1gTXEJrHN2Xx2KruY/R27iz2qqaE5QzNKM1ezUvOUZj8H45hx+Jx0TgnnKKeX836K3hTvKeIpG6Y0TLkxZVxrqpaXllirSKtRq0frvTau7aedpr1Fu1n7gQ5Bx0onXCdHZ4/OBZ3nU9lT3acKpxZNPTr1ri6qa6UbobtEd79up+6Ynr5egJ5Mb6feeb3n+hx9L/1U/W36p/VHDFgGswwkBtsMzhg8xTVxbzwdL8fb8VFDXcNAQ6VhlWGX4YSRudE8o9VGjUYPjGnGXOMk423GbcajJgYmISZLTepN7ppSTbmmKaY7TDtMx83MzaLN1pk1mz0x1zLnm+eb15vft2BaeFostqi2uGVJsuRaplnutrxuhVo5WaVYVVpds0atna0l1rutu6cRp7lOk06rntZnw7Dxtsm2qbcZsOXYBtuutm22fWFnYhdnt8Wuw+6TvZN9un2N/T0HDYfZDqsdWh1+c7RyFDpWOt6azpzuP33F9JbpL2dYzxDP2DPjthPLKcRpnVOb00dnF2e5c4PziIuJS4LLLpc+Lpsbxt3IveRKdPVxXeF60vWdm7Obwu2o26/uNu5p7ofcn8w0nymeWTNz0MPIQ+BR5dE/C5+VMGvfrH5PQ0+BZ7XnIy9jL5FXrdewt6V3qvdh7xc+9j5yn+M+4zw33jLeWV/MN8C3yLfLT8Nvnl+F30N/I/9k/3r/0QCngCUBZwOJgUGBWwL7+Hp8Ib+OPzrbZfay2e1BjKC5QRVBj4KtguXBrSFoyOyQrSH355jOkc5pDoVQfujW0Adh5mGLw34MJ4WHhVeGP45wiFga0TGXNXfR3ENz30T6RJZE3ptnMU85ry1KNSo+qi5qPNo3ujS6P8YuZlnM1VidWElsSxw5LiquNm5svt/87fOH4p3iC+N7F5gvyF1weaHOwvSFpxapLhIsOpZATIhOOJTwQRAqqBaMJfITdyWOCnnCHcJnIi/RNtGI2ENcKh5O8kgqTXqS7JG8NXkkxTOlLOW5hCepkLxMDUzdmzqeFpp2IG0yPTq9MYOSkZBxQqohTZO2Z+pn5mZ2y6xlhbL+xW6Lty8elQfJa7OQrAVZLQq2QqboVFoo1yoHsmdlV2a/zYnKOZarnivN7cyzytuQN5zvn//tEsIS4ZK2pYZLVy0dWOa9rGo5sjxxedsK4xUFK4ZWBqw8uIq2Km3VT6vtV5eufr0mek1rgV7ByoLBtQFr6wtVCuWFfevc1+1dT1gvWd+1YfqGnRs+FYmKrhTbF5cVf9go3HjlG4dvyr+Z3JS0qavEuWTPZtJm6ebeLZ5bDpaql+aXDm4N2dq0Dd9WtO319kXbL5fNKNu7g7ZDuaO/PLi8ZafJzs07P1SkVPRU+lQ27tLdtWHX+G7R7ht7vPY07NXbW7z3/T7JvttVAVVN1WbVZftJ+7P3P66Jqun4lvttXa1ObXHtxwPSA/0HIw6217nU1R3SPVRSj9Yr60cOxx++/p3vdy0NNg1VjZzG4iNwRHnk6fcJ3/ceDTradox7rOEH0x92HWcdL2pCmvKaRptTmvtbYlu6T8w+0dbq3nr8R9sfD5w0PFl5SvNUyWna6YLTk2fyz4ydlZ19fi753GDborZ752PO32oPb++6EHTh0kX/i+c7vDvOXPK4dPKy2+UTV7hXmq86X23qdOo8/pPTT8e7nLuarrlca7nuer21e2b36RueN87d9L158Rb/1tWeOT3dvfN6b/fF9/XfFt1+cif9zsu72Xcn7q28T7xf9EDtQdlD3YfVP1v+3Njv3H9qwHeg89HcR/cGhYPP/pH1jw9DBY+Zj8uGDYbrnjg+OTniP3L96fynQ89kzyaeF/6i/suuFxYvfvjV69fO0ZjRoZfyl5O/bXyl/erA6xmv28bCxh6+yXgzMV70VvvtwXfcdx3vo98PT+R8IH8o/2j5sfVT0Kf7kxmTk/8EA5jz/GMzLdsAAAAgY0hSTQAAeiUAAICDAAD5/wAAgOkAAHUwAADqYAAAOpgAABdvkl/FRgAACGtJREFUeNrsml9MG9kVh39jMNgB28TGZtPUrpcmlGyqxriNAgQ2qqolIEPAUZTuA1JR96E8JS+NgqIkD47yENGXvKWKUkGMKlXRxkLRKBYrbWWFWrAUMNuWBGip15ANssG7/jO2x9iePnAntYmNxzaJqlWvdAVjzJ3z3XPuOWfOGYrjOHwXhgjfkVFe6gIURQEABaAMgJjMCrJ2edpmpQAkyIwD2CYzye2DWVClrEFRFC+8FIAMgAKAHEA1gAMESEy+vk0AIgDCAIIAAgBCAKIAtjmOS75TEIqiRETIagBKAO8pFAqt2Ww+bTQadXq9/pBarVbL5XKFRCKpAoBYLMYEg8GAz+fzud3uV3Nzcx6bzfaXQCCwBmADgJ8AxjmOS71VEGrHjsoBVAGoBaDt7OxsM5lMpwwGwzGtVltfyM3X1tZWXS7Xc5qmp+12+ySANQCbABgAiUJMTjAIgagk5qM1Go3NAwMDXa2trcba2tr3SrHvzc3NDafTOTcyMvJ0bm5uigAFALBCYQSBEAgJ0cLRwcHBX54/f76toaHhg/30PMvLy4uPHz+evHfv3p8ArBDtxITA5AVJg9AA+ODWrVu/NplMZ5RKpfptuFG/3++jadpx48aNPwBYBOAVArMnSJo5qQH8eHh4+Dc9PT0fSSSSA28zJsRisciTJ08+u3Llyu8B/B2AL5+Z5QuI5eRMHLVYLJ+8CwgAkEgkB3p6ej6yWCyfADhKZCgvKrITF1sFQDc4OPhxd3f3h+8CIh2mu7v7w8HBwY8B6ABUEZkKjuwVANRNTU3NZrO5Ld+Z8Pv9WF5extLSEpaXl5FIJBAOhxGJRKDRaFBdXY2GhgacPXsWNTU1gmCUSqXabDa3TU9P/21+fv5bADEyhZ0RErEPAvjJ3bt3f9vb29uVzylcvHhRWHInEqG5uRkDAwOCgCiKwvj4+NPLly//DsCXAL7JlgHkUpUYgKqjo6O9paXFyHEcUqnUnlPoSKVScDqdGBoagt/vz7sux3FoaWkxdnR0tANQpaU8e5sW8VRSAIdMJtOp2traOn7BfEMqlaKlpQXHjx9HXV0dZDIZQqEQZmZmMDExgWg0mmGKo6OjuHTpUl7w2traOpPJdGpiYsIBwEtR1BseLNsZKQMgl8vlOoPB0MhxnCCIq1evorm5GRUVFW/8rampCSdPnsT169czPp+dnUUqlYJIlNt58vc2GAyNcrlcFwwG/00SzUQ+0xIDqOnr6zut1Wrf5xfigXLN9vZ2iMVixONxRKNRMAyDcDgMhmHAsiwMBgP0en3GjeLxOFiW3XNd/t5arfb9vr6+0wBqsplXLhCFwWDQ5bPf9MkwDAKBABiGQSwWQzwex/b2NuLxOCKRCMLh8Bs7r1KpUFFRIfgeBoNBR2KKWIj7rQQg0+v1h3bvyl4jHo/nSwzhdrszPuvu7ha0Nv8dvV5/iDz3VAoBEQOoVqvVqkJA8o1Hjx5leLcjR46gp6cHkUhE0P9zHAe1Wq0iz0BioSCVMplMsV8gs7OzcDgcGSZ17do1JJNJwetyHAeZTKYg2hAEUgagQiKRHNh90IsZPp8PDx48yIC4ffs2ampqEAwGBdcFOI4DSZEqiIzCUpRkMpkRlIrRCsMwGB4eBsMwwI5Ph8VigUqleh0MBRQ2QFEURCLRnm46219SABJREr34xYoZIyMj8Hq9r1OToaEhaDQaBIPBgrIBXgYiU4LImBckASAeDAYDpRzu+fl5LCwsvL7u6upCQ0MDgsEgksniiiVEpvjuYLgXSMTr9frTVVvomJyczLg+c+ZMURDpMni9Xj8pJwkCiQMIu93ujVLMan19/Y3gl0gkSioEut3uDb5kJBQk4HK51ndroxAwlmWz7myhmkj/ncgUKAiEpukvPB6Ph1+oFO3wXrAYLfD39Xg8Hpqmv8gFUp7jjARCoZDH5XKtaLVaXbrr5X16vvHw4cMM+K2traK1QVEUXC7XSigU8hCQ/GeElCsZAF/b7fZZn8/n2y+tFKsNn8/ns9vtswC+BsBkK6nmCogsgE2Hw+Gcmpr66blz537BPyUK0Uo0GsWFCxcyPrt//37BXkokEoGiKExNTX3pcDicpGDHFlJFSRAVfmW1Wj9fWlpa4XeoFJdcCAQ/l5aWVqxW6+cAvsplVjlByGNkDMDG4uLitM1mm9na2vILhSkGMhvE1taW32azzSwuLk6Tin3OiuNeBboE6WG4rVbrpzRNT7EsG30bmskGwbJslKbpKavV+ikAN5ElUWzJtIzk/98HYLh58+avent72yorK6XZUvx0z6ZUKjPWyua1dm9GOsT4+PikxWIZBeACsA4gvFcjKF/rjfdgrwCUWyyWUZZlt00mU7NKpVLmSu+Fmlwuc6JpeurOnTt/JHXfV0SG1H5U48ux01I7DOBH/f39ZrPZfLKxsfFINo3slfJni9j8zxcvXvzTZrPNjI2N2QAsAXjJm1RJ1fhdMGJiZmoA9ceOHTvZ39//89bW1uMajUZdCojX6/U5nc5/jI2N/fn58+czAFZJBT6Mnd5i6f2RLJqRknLqIQA/aG9vP9XZ2dlkNBp/qNPptIUcco/HszY3N/cvu90+/+zZs2niYl8B+AY7DdLEvnasdsGkN0IPEg19r6qq6nBXV9fPTpw4cbi+vl6t0WiUCoVCJpVKpfxDUSAQCHm9Xv/q6qpvYWHh5dOnT//KMMxLErF9BIDPblNvpYe4C4bvq1dipw0tI4Wzg6TuVE00l609HSXCBojg35LKYYRE7SQJZQUJVnSfPU07Ivz3JQFJ2uQh0l8Y4GFiaZN/eSBVqBb2BSSLhniosrTr3X6YIwJzZOdT/HWpbz/sB0jG5a6ZNQNKn/v1Ug/1/7eD/sfGfwYADCvG9Jtuf60AAAAASUVORK5CYII=);
    }
}

    </STYLE>

    <TITLE>Failed to open page</TITLE>

</HEAD>

<BODY>
<div class="error-container">
<div class="icon" role="img" alt="Safari Icon"></div>

<div class="text-container">
<!-- main title here, repeated 3 times -->
<P aria-hidden="true" class="error-title error-text-engraving">You are not connected to the Internet <A id="help-button"></a></P>
<P aria-hidden="true" class="error-title error-text">You are not connected to the Internet <A id="help-button"></a></P>
<P class="error-title error-text-inner-shadow">You are not connected to the Internet <A aria-label="Help" role="button" id="help-button" class="" HREF='open-help-anchor:ibrwa007'></a></P>
</div>
<div class="text-container">
<!-- error message here, repeated 3 times -->
<P class="error-message error-text-engraving">This page can’t be displayed because your computer is currently offline</P>
<P aria-hidden="true" class="error-message error-text">This page can’t be displayed because your computer is currently offline</P>
<P aria-hidden="true" class="error-message error-text-inner-shadow">This page can’t be displayed because your computer is currently offline</P>
</div>
</div>

<div class="suggestion-container">
<div class="text-container">
<!-- LOCALIZERS: localize the prompt (repeated 3 times) and the button title. -->
<p class="suggestion-prompt error-text-engraving"><span class="reading-list-glasses" alt="Safari Reading List Icon" role="img"></span>Reading List articles are available for viewing while you are offline.</p>
<p aria-hidden="true" class="suggestion-prompt error-text"><span class="reading-list-glasses" alt="Safari Reading List Icon" role="img"></span>Reading List articles are available for viewing while you are offline.</p>
<p aria-hidden="true" class="suggestion-prompt error-text-inner-shadow"><span class="reading-list-glasses" alt="Safari Reading List Icon" role="img"></span>Reading List articles are available for viewing while you are offline.</p>
</div>
<form class="suggestion-form" method=GET action='show-reading-list:'><input type=submit value='Show Reading List'></form>
</div>
</BODY>

</HTML>
"
// from http://www.webtoolkit.info/javascript-base64.html
var Base64={_keyStr:"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",encode:function(c){var a="";var k,h,f,j,g,e,d;var b=0;c=Base64._utf8_encode(c);while(b<c.length){k=c.charCodeAt(b++);h=c.charCodeAt(b++);f=c.charCodeAt(b++);j=k>>2;g=((k&3)<<4)|(h>>4);e=((h&15)<<2)|(f>>6);d=f&63;if(isNaN(h)){e=d=64}else{if(isNaN(f)){d=64}}a=a+this._keyStr.charAt(j)+this._keyStr.charAt(g)+this._keyStr.charAt(e)+this._keyStr.charAt(d)}return a},decode:function(c){var a="";var k,h,f;var j,g,e,d;var b=0;c=c.replace(/[^A-Za-z0-9\+\/\=]/g,"");while(b<c.length){j=this._keyStr.indexOf(c.charAt(b++));g=this._keyStr.indexOf(c.charAt(b++));e=this._keyStr.indexOf(c.charAt(b++));d=this._keyStr.indexOf(c.charAt(b++));k=(j<<2)|(g>>4);h=((g&15)<<4)|(e>>2);f=((e&3)<<6)|d;a=a+String.fromCharCode(k);if(e!=64){a=a+String.fromCharCode(h)}if(d!=64){a=a+String.fromCharCode(f)}}a=Base64._utf8_decode(a);return a},_utf8_encode:function(b){b=b.replace(/\r\n/g,"\n");var a="";for(var e=0;e<b.length;e++){var d=b.charCodeAt(e);if(d<128){a+=String.fromCharCode(d)}else{if((d>127)&&(d<2048)){a+=String.fromCharCode((d>>6)|192);a+=String.fromCharCode((d&63)|128)}else{a+=String.fromCharCode((d>>12)|224);a+=String.fromCharCode(((d>>6)&63)|128);a+=String.fromCharCode((d&63)|128)}}}return a},_utf8_decode:function(a){var b="";var d=0;var e=c1=c2=0;while(d<a.length){e=a.charCodeAt(d);if(e<128){b+=String.fromCharCode(e);d++}else{if((e>191)&&(e<224)){c2=a.charCodeAt(d+1);b+=String.fromCharCode(((e&31)<<6)|(c2&63));d+=2}else{c2=a.charCodeAt(d+1);c3=a.charCodeAt(d+2);b+=String.fromCharCode(((e&15)<<12)|((c2&63)<<6)|(c3&63));d+=3}}}return b}};
function swap(browser) {
console.log(browser)
var code
if (browser === 'Chrome') {
code = chrome
} else if (browser === 'Safari') {
code = safari
} else if (browser === 'Firefox') {
code = firefox
} else if (browser === 'Palemoon') {
code = palemoon
} else if (navigator.userAgent.indexOf('MSIE') === -1 && navigator.appVersion.indexOf('Trident/') !== -1) {
code = ie11
}
document.getElementsByTagName("html")[0].innerHTML = Base64.decode(code)
}
swap(BrowserDetect.browser)
</script>
</html>