From 1180da8d1185ab45685cbb5262f40be42992152b Mon Sep 17 00:00:00 2001 From: dalun Date: Fri, 8 Sep 2023 23:12:13 +0000 Subject: [PATCH 1/9] fix multidomain missing logic --- src/web/snippet/acme.html | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/web/snippet/acme.html b/src/web/snippet/acme.html index be1a8f9..2a8e1a8 100644 --- a/src/web/snippet/acme.html +++ b/src/web/snippet/acme.html @@ -334,8 +334,9 @@

Generate New Certificate

//Invalid settings. Force the filename to be same as domain //if there are only 1 domain filename = domains; - }else{ - parent.msgbox("Filename cannot be empty for certs containing multiple domains.") + }else if (filename == "" && domains.includes(",")){ + parent.msgbox("Filename cannot be empty for certs containing multiple domains.", false, 5000); + $("#obtainButton").removeClass("loading").removeClass("disabled"); return; } From 507c2ab46880a71778d40dc4f5be9642fbce5c64 Mon Sep 17 00:00:00 2001 From: Toby Chui Date: Sat, 9 Sep 2023 12:28:24 +0800 Subject: [PATCH 2/9] Updated 2.6.7 init --- src/acme.go | 2 +- src/main.go | 4 +- src/mod/acme/acme.go | 9 +++- src/mod/acme/ca.go | 1 - src/web/components/webserv.html | 75 +++++++++++++++++++++++++++++++++ src/web/index.html | 6 +++ src/web/snippet/acme.html | 5 ++- 7 files changed, 94 insertions(+), 8 deletions(-) create mode 100644 src/web/components/webserv.html diff --git a/src/acme.go b/src/acme.go index 72e5883..27553e8 100644 --- a/src/acme.go +++ b/src/acme.go @@ -38,7 +38,7 @@ func initACME() *acme.ACMEHandler { port = getRandomPort(30000) } - return acme.NewACME("https://acme-staging-v02.api.letsencrypt.org/directory", strconv.Itoa(port)) + return acme.NewACME("https://acme-v02.api.letsencrypt.org/directory", strconv.Itoa(port)) } // create the special routing rule for ACME diff --git a/src/main.go b/src/main.go index edff546..797dfc1 100644 --- a/src/main.go +++ b/src/main.go @@ -43,9 +43,9 @@ var acmeAutoRenewInterval = flag.Int("autorenew", 86400, "ACME auto TLS/SSL cert var enableHighSpeedGeoIPLookup = flag.Bool("fastgeoip", false, "Enable high speed geoip lookup, require 1GB extra memory (Not recommend for low end devices)") var ( name = "Zoraxy" - version = "2.6.6" + version = "2.6.7" nodeUUID = "generic" - development = false //Set this to false to use embedded web fs + development = true //Set this to false to use embedded web fs bootTime = time.Now().Unix() /* diff --git a/src/mod/acme/acme.go b/src/mod/acme/acme.go index d82cf05..a127a3b 100644 --- a/src/mod/acme/acme.go +++ b/src/mod/acme/acme.go @@ -303,18 +303,23 @@ func (a *ACMEHandler) HandleRenewCertificate(w http.ResponseWriter, r *http.Requ ca, err := utils.PostPara(r, "ca") if err != nil { - log.Println("CA not set. Using default") + log.Println("[INFO] CA not set. Using default") ca, caUrl = "", "" } if ca == "custom" { caUrl, err = utils.PostPara(r, "caURL") if err != nil { - log.Println("Custom CA set but no URL provide, Using default") + log.Println("[INFO] Custom CA set but no URL provide, Using default") ca, caUrl = "", "" } } + if ca == "" { + //default. Use Let's Encrypt + ca = "Let's Encrypt" + } + var skipTLS bool if skipTLSString, err := utils.PostPara(r, "skipTLS"); err != nil { diff --git a/src/mod/acme/ca.go b/src/mod/acme/ca.go index e2a9b96..205771e 100644 --- a/src/mod/acme/ca.go +++ b/src/mod/acme/ca.go @@ -32,7 +32,6 @@ func init() { } caDef = runtimeCaDef - } // Get the CA ACME server endpoint and error if not found diff --git a/src/web/components/webserv.html b/src/web/components/webserv.html new file mode 100644 index 0000000..fcd8637 --- /dev/null +++ b/src/web/components/webserv.html @@ -0,0 +1,75 @@ +
+
+

Static Web Server

+

A simple static web server that serve html css and js files

+
+
+

Web Server Settings

+
+
+
+ + +
+
+
+
+ + + If this folder do not contains any index files, list the directory of this folder. +
+
+
+ + + + The web server root folder can only be changed via startup flags of zoraxy for security reasons. + See the -webserv flag for more details. + +
+
+ + + Use http://127.0.0.1:8081 in proxy rules to access the web server +
+
+
+
+
+
+ + How to access the static web server? +
+
+ There are three ways to access the static web server.
+
+
+ If you are using Zoraxy as your gateway reverse proxy server, + you can add a new subdomain proxy rule that points to + http://127.0.0.1:8081 +
+
+ If you are using Zoraxy under another reverse proxy server, + add http://127.0.0.1:8081 to the config of your upper layer reverse proxy server's config file. +
+
+ Directly access the web server via http://{zoraxy_host_ip}:8081 (Not recommended) +
+
+
+ +
+
+
+ +
+ + + +
\ No newline at end of file diff --git a/src/web/index.html b/src/web/index.html index 19760bf..d95acef 100644 --- a/src/web/index.html +++ b/src/web/index.html @@ -69,6 +69,9 @@ TCP Proxy
Others
+ + Static Web Server + Uptime Monitor @@ -117,6 +120,9 @@
+ +
+
diff --git a/src/web/snippet/acme.html b/src/web/snippet/acme.html index be1a8f9..d9131ce 100644 --- a/src/web/snippet/acme.html +++ b/src/web/snippet/acme.html @@ -124,7 +124,7 @@

Generate New Certificate

- +
First time setting up HTTPS?
Try out our wizard @@ -323,7 +323,8 @@

Generate New Certificate

var filename = $("#filenameInput").val(); var email = $("#caRegisterEmail").val(); if (email == ""){ - parent.msgbox("ACME renew email is not set") + parent.msgbox("ACME renew email is not set", false) + $("#obtainButton").removeClass("loading").removeClass("disabled"); return; } if (filename.trim() == "" && !domains.includes(",")){ From a692ec818d935aa335c956c093027d602ccfc6ea Mon Sep 17 00:00:00 2001 From: Toby Chui Date: Tue, 12 Sep 2023 16:41:52 +0800 Subject: [PATCH 3/9] Static web server - Fixed arm64 build bug in Make file - Added wip static web server --- src/Makefile | 3 +- src/main.go | 4 + src/mod/webserv/handler.go | 9 +++ src/mod/webserv/middleware.go | 41 ++++++++++ src/mod/webserv/utils.go | 18 +++++ src/mod/webserv/webserv.go | 137 ++++++++++++++++++++++++++++++++++ src/start.go | 16 ++++ 7 files changed, 227 insertions(+), 1 deletion(-) create mode 100644 src/mod/webserv/handler.go create mode 100644 src/mod/webserv/middleware.go create mode 100644 src/mod/webserv/utils.go create mode 100644 src/mod/webserv/webserv.go diff --git a/src/Makefile b/src/Makefile index c5dbbc2..e82e24e 100644 --- a/src/Makefile +++ b/src/Makefile @@ -19,7 +19,8 @@ clean: $(PLATFORMS): @echo "Building $(os)/$(arch)" - GOROOT_FINAL=Git/ GOOS=$(os) GOARCH=$(arch) GOARM=6 go build -o './dist/zoraxy_$(os)_$(arch)' -ldflags "-s -w" -trimpath + GOROOT_FINAL=Git/ GOOS=$(os) GOARCH=$(arch) $(if $(filter linux/arm,$(os)/$(arch)),GOARM=6,) go build -o './dist/zoraxy_$(os)_$(arch)' -ldflags "-s -w" -trimpath +# GOROOT_FINAL=Git/ GOOS=$(os) GOARCH=$(arch) GOARM=6 go build -o './dist/zoraxy_$(os)_$(arch)' -ldflags "-s -w" -trimpath fixwindows: diff --git a/src/main.go b/src/main.go index 797dfc1..efe933c 100644 --- a/src/main.go +++ b/src/main.go @@ -30,6 +30,7 @@ import ( "imuslab.com/zoraxy/mod/tlscert" "imuslab.com/zoraxy/mod/uptime" "imuslab.com/zoraxy/mod/utils" + "imuslab.com/zoraxy/mod/webserv" ) // General flags @@ -41,6 +42,8 @@ var ztAuthToken = flag.String("ztauth", "", "ZeroTier authtoken for the local no var ztAPIPort = flag.Int("ztport", 9993, "ZeroTier controller API port") var acmeAutoRenewInterval = flag.Int("autorenew", 86400, "ACME auto TLS/SSL certificate renew check interval (seconds)") var enableHighSpeedGeoIPLookup = flag.Bool("fastgeoip", false, "Enable high speed geoip lookup, require 1GB extra memory (Not recommend for low end devices)") +var staticWebServerRoot = flag.String("webroot", "./www", "Static web server root folder. Only allow chnage in start paramters") + var ( name = "Zoraxy" version = "2.6.7" @@ -73,6 +76,7 @@ var ( tcpProxyManager *tcpprox.Manager //TCP Proxy Manager acmeHandler *acme.ACMEHandler //Handler for ACME Certificate renew acmeAutoRenewer *acme.AutoRenewer //Handler for ACME auto renew ticking + staticWebServer *webserv.WebServer //Static web server for hosting simple stuffs //Helper modules EmailSender *email.Sender //Email sender that handle email sending diff --git a/src/mod/webserv/handler.go b/src/mod/webserv/handler.go new file mode 100644 index 0000000..0a4eba6 --- /dev/null +++ b/src/mod/webserv/handler.go @@ -0,0 +1,9 @@ +package webserv + +/* + Handler.go + + Handler for web server options change + web server is directly listening to the TCP port + handlers in this script are for setting change only +*/ diff --git a/src/mod/webserv/middleware.go b/src/mod/webserv/middleware.go new file mode 100644 index 0000000..1dade78 --- /dev/null +++ b/src/mod/webserv/middleware.go @@ -0,0 +1,41 @@ +package webserv + +import ( + "net/http" + "path/filepath" + "strings" + + "imuslab.com/zoraxy/mod/utils" +) + +// Convert a request path (e.g. /index.html) into physical path on disk +func (ws *WebServer) resolveFileDiskPath(requestPath string) string { + fileDiskpath := filepath.Join(ws.option.WebRoot, "html", requestPath) + + //Force convert it to slash even if the host OS is on Windows + fileDiskpath = filepath.Clean(fileDiskpath) + fileDiskpath = strings.ReplaceAll(fileDiskpath, "\\", "/") + return fileDiskpath + +} + +// File server middleware to handle directory listing (and future expansion) +func (ws *WebServer) fsMiddleware(h http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + if ws.option.EnableDirectoryListing { + if strings.HasSuffix(r.URL.Path, "/") { + //This is a folder. Let check if index exists + if utils.FileExists(filepath.Join(ws.resolveFileDiskPath(r.URL.Path), "index.html")) { + + } else if utils.FileExists(filepath.Join(ws.resolveFileDiskPath(r.URL.Path), "index.htm")) { + + } else { + http.NotFound(w, r) + return + } + } + } + + h.ServeHTTP(w, r) + }) +} diff --git a/src/mod/webserv/utils.go b/src/mod/webserv/utils.go new file mode 100644 index 0000000..856ac1a --- /dev/null +++ b/src/mod/webserv/utils.go @@ -0,0 +1,18 @@ +package webserv + +import ( + "net" +) + +// IsPortInUse checks if a port is in use. +func IsPortInUse(port string) bool { + listener, err := net.Listen("tcp", "localhost:"+port) + if err != nil { + // If there was an error, the port is in use. + return true + } + defer listener.Close() + + // No error means the port is available. + return false +} diff --git a/src/mod/webserv/webserv.go b/src/mod/webserv/webserv.go new file mode 100644 index 0000000..6548d92 --- /dev/null +++ b/src/mod/webserv/webserv.go @@ -0,0 +1,137 @@ +package webserv + +import ( + "errors" + "fmt" + "log" + "net/http" + "os" + "path/filepath" + "sync" + + "imuslab.com/zoraxy/mod/utils" +) + +/* + Static Web Server package + + This module host a static web server +*/ + +type WebServerOptions struct { + Port string //Port for listening + EnableDirectoryListing bool //Enable listing of directory + WebRoot string //Folder for stroing the static web folders +} +type WebServer struct { + mux *http.ServeMux + server *http.Server + option *WebServerOptions + isRunning bool + mu sync.Mutex +} + +// NewWebServer creates a new WebServer instance. +func NewWebServer(options *WebServerOptions) *WebServer { + if !utils.FileExists(options.WebRoot) { + //Web root folder not exists. Create one + os.MkdirAll(filepath.Join(options.WebRoot, "html"), 0775) + os.MkdirAll(filepath.Join(options.WebRoot, "templates"), 0775) + } + return &WebServer{ + mux: http.NewServeMux(), + option: options, + isRunning: false, + mu: sync.Mutex{}, + } +} + +// ChangePort changes the server's port. +func (ws *WebServer) ChangePort(port string) error { + ws.mu.Lock() + defer ws.mu.Unlock() + + if ws.isRunning { + if err := ws.Stop(); err != nil { + return err + } + } + + ws.option.Port = port + ws.server.Addr = ":" + port + + return nil +} + +// Start starts the web server. +func (ws *WebServer) Start() error { + ws.mu.Lock() + defer ws.mu.Unlock() + + //Check if server already running + if ws.isRunning { + return fmt.Errorf("web server is already running") + } + + //Check if the port is usable + if IsPortInUse(ws.option.Port) { + return errors.New("Port already in use or access denied by host OS") + } + + //Dispose the old mux and create a new one + ws.mux = http.NewServeMux() + + //Create a static web server + fs := http.FileServer(http.Dir(filepath.Join(ws.option.WebRoot, "html"))) + ws.mux.Handle("/", ws.fsMiddleware(fs)) + + ws.server = &http.Server{ + Addr: ":" + ws.option.Port, + Handler: ws.mux, + } + + go func() { + if err := ws.server.ListenAndServe(); err != nil { + if err != http.ErrServerClosed { + fmt.Printf("Web server error: %v\n", err) + } + } + }() + + log.Println("Static Web Server started. Listeing on :" + ws.option.Port) + ws.isRunning = true + + return nil +} + +// Stop stops the web server. +func (ws *WebServer) Stop() error { + ws.mu.Lock() + defer ws.mu.Unlock() + + if !ws.isRunning { + return fmt.Errorf("web server is not running") + } + + if err := ws.server.Close(); err != nil { + return err + } + + ws.isRunning = false + + return nil +} + +// UpdateDirectoryListing enables or disables directory listing. +func (ws *WebServer) UpdateDirectoryListing(enable bool) { + ws.mu.Lock() + defer ws.mu.Unlock() + + ws.option.EnableDirectoryListing = enable + +} + +// Close stops the web server without returning an error. +func (ws *WebServer) Close() { + ws.Stop() +} diff --git a/src/start.go b/src/start.go index 3da18e6..483d9d2 100644 --- a/src/start.go +++ b/src/start.go @@ -22,6 +22,7 @@ import ( "imuslab.com/zoraxy/mod/statistic/analytic" "imuslab.com/zoraxy/mod/tcpprox" "imuslab.com/zoraxy/mod/tlscert" + "imuslab.com/zoraxy/mod/webserv" ) /* @@ -208,6 +209,21 @@ func startupSequence() { if err != nil { log.Fatal(err) } + + /* + Static Web Server + + Start the static web server + */ + + staticWebServer = webserv.NewWebServer(&webserv.WebServerOptions{ + Port: "8081", + WebRoot: *staticWebServerRoot, + EnableDirectoryListing: true, + }) + + //TODO: Connect UI element to static web server + staticWebServer.Start() } // This sequence start after everything is initialized From c6c523e005803c02b8c678ca01f4e13dabccd0b4 Mon Sep 17 00:00:00 2001 From: dalun Date: Wed, 13 Sep 2023 00:32:48 +0000 Subject: [PATCH 4/9] prevent out of range when check issuer exist --- src/mod/acme/autorenew.go | 14 -------------- src/mod/acme/utils.go | 5 +++++ 2 files changed, 5 insertions(+), 14 deletions(-) diff --git a/src/mod/acme/autorenew.go b/src/mod/acme/autorenew.go index 13872fd..a608729 100644 --- a/src/mod/acme/autorenew.go +++ b/src/mod/acme/autorenew.go @@ -280,12 +280,6 @@ func (a *AutoRenewer) CheckAndRenewCertificates() ([]string, error) { } if CertExpireSoon(certBytes) || CertIsExpired(certBytes) { //This cert is expired - CAName, err := ExtractIssuerName(certBytes) - if err != nil { - //Maybe self signed. Ignore this - log.Println("Unable to extract issuer name for cert " + file.Name()) - continue - } DNSName, err := ExtractDomains(certBytes) if err != nil { @@ -296,7 +290,6 @@ func (a *AutoRenewer) CheckAndRenewCertificates() ([]string, error) { expiredCertList = append(expiredCertList, &ExpiredCerts{ Filepath: filepath.Join(certFolder, file.Name()), - CA: CAName, Domains: DNSName, }) } @@ -315,12 +308,6 @@ func (a *AutoRenewer) CheckAndRenewCertificates() ([]string, error) { } if CertExpireSoon(certBytes) || CertIsExpired(certBytes) { //This cert is expired - CAName, err := ExtractIssuerName(certBytes) - if err != nil { - //Maybe self signed. Ignore this - log.Println("Unable to extract issuer name for cert " + file.Name()) - continue - } DNSName, err := ExtractDomains(certBytes) if err != nil { @@ -331,7 +318,6 @@ func (a *AutoRenewer) CheckAndRenewCertificates() ([]string, error) { expiredCertList = append(expiredCertList, &ExpiredCerts{ Filepath: filepath.Join(certFolder, file.Name()), - CA: CAName, Domains: DNSName, }) } diff --git a/src/mod/acme/utils.go b/src/mod/acme/utils.go index 40d873d..1638044 100644 --- a/src/mod/acme/utils.go +++ b/src/mod/acme/utils.go @@ -53,6 +53,11 @@ func ExtractIssuerName(certBytes []byte) (string, error) { return "", fmt.Errorf("failed to parse certificate: %v", err) } + // Check if exist incase some acme server didn't have org section + if len(cert.Issuer.Organization) == 0 { + return "", fmt.Errorf("cert didn't have org section exist") + } + // Extract the issuer name issuer := cert.Issuer.Organization[0] From 8a5004e8288b9d9e3fddd300039755e7545a1f26 Mon Sep 17 00:00:00 2001 From: dalun Date: Wed, 13 Sep 2023 04:27:11 +0000 Subject: [PATCH 5/9] handle buypass issuer not match --- src/mod/acme/ca.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/mod/acme/ca.go b/src/mod/acme/ca.go index 205771e..87f9fc4 100644 --- a/src/mod/acme/ca.go +++ b/src/mod/acme/ca.go @@ -10,6 +10,7 @@ import ( "encoding/json" "errors" "log" + "strings" ) // CA Defination, load from embeded json when startup @@ -36,9 +37,15 @@ func init() { // Get the CA ACME server endpoint and error if not found func loadCAApiServerFromName(caName string) (string, error) { + // handle BuyPass cert org section (Buypass AS-983163327) + if strings.HasPrefix(caName, "Buypass AS") { + caName = "Buypass" + } + val, ok := caDef.Production[caName] if !ok { return "", errors.New("This CA is not supported") } + return val, nil } From 95892802fd05abae5540022a60d482d5a16816ea Mon Sep 17 00:00:00 2001 From: dalun Date: Wed, 13 Sep 2023 04:28:33 +0000 Subject: [PATCH 6/9] use issuer org as failover for json file not exist --- src/mod/acme/autorenew.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) diff --git a/src/mod/acme/autorenew.go b/src/mod/acme/autorenew.go index a608729..b5f1596 100644 --- a/src/mod/acme/autorenew.go +++ b/src/mod/acme/autorenew.go @@ -40,7 +40,6 @@ type AutoRenewer struct { type ExpiredCerts struct { Domains []string Filepath string - CA string } // Create an auto renew agent, require config filepath and auto scan & renew interval (seconds) @@ -347,8 +346,14 @@ func (a *AutoRenewer) renewExpiredDomains(certs []*ExpiredCerts) ([]string, erro certInfoFilename := fmt.Sprintf("%s/%s.json", filepath.Dir(expiredCert.Filepath), certName) certInfo, err := loadCertInfoJSON(certInfoFilename) if err != nil { - log.Printf("Renew %s certificate error, can't get the ACME detail for cert: %v, using default ACME", certName, err) - certInfo = &CertificateInfoJSON{} + log.Printf("Renew %s certificate error, can't get the ACME detail for cert: %v, trying org section as ca", certName, err) + + if CAName, extractErr := ExtractIssuerNameFromPEM(expiredCert.Filepath); extractErr != nil { + log.Printf("extract issuer name for cert error: %v, using default ca", extractErr) + certInfo = &CertificateInfoJSON{} + } else { + certInfo = &CertificateInfoJSON{AcmeName: CAName} + } } _, err = a.AcmeHandler.ObtainCert(expiredCert.Domains, certName, a.RenewerConfig.Email, certInfo.AcmeName, certInfo.AcmeUrl, certInfo.SkipTLS) From b63a0fc24659054027c064c77796a6b7e049b516 Mon Sep 17 00:00:00 2001 From: Toby Chui Date: Thu, 14 Sep 2023 16:15:40 +0800 Subject: [PATCH 7/9] Added static web server and black / whitelist template - Added static web server - Added static web server default index - Added embeded templates to blacklist / whitelist - Added wip Web Directory Manager Place the templates at ./www/templates/blacklist.html or whitelist.html to replace the build in embedded template for access control 403 error - --- src/acme.go | 4 +- src/api.go | 20 + src/main.go | 1 + src/mod/dynamicproxy/Server.go | 9 +- src/mod/dynamicproxy/templates/forbidden.html | 55 + src/mod/dynamicproxy/typedef.go | 10 + src/mod/utils/utils.go | 17 + src/mod/webserv/handler.go | 79 + src/mod/webserv/middleware.go | 2 +- src/mod/webserv/templates/index.html | 61 + src/mod/webserv/webserv.go | 71 +- src/reverseproxy.go | 1 + src/start.go | 9 +- src/web/components/webserv.html | 111 +- src/web/tools/fs.css | 1388 +++++++ src/web/tools/fs.html | 1156 ++++++ src/web/tools/img/arrow-left.svg | 8 + src/web/tools/img/arrow-right.svg | 8 + src/web/tools/img/eq.svg | 8 + src/web/tools/img/file.svg | 3442 +++++++++++++++++ src/web/tools/img/folder.svg | 12 + src/web/tools/img/icon.svg | 11 + src/web/tools/img/network.svg | 18 + src/web/tools/img/opr/copy.svg | 24 + src/web/tools/img/opr/delete.svg | 8 + src/web/tools/img/opr/download.svg | 154 + src/web/tools/img/opr/new_folder.svg | 15 + src/web/tools/img/opr/open.svg | 16 + src/web/tools/img/opr/paste.svg | 102 + src/web/tools/img/opr/share.svg | 11 + src/web/tools/img/opr/upload.svg | 171 + src/web/tools/img/wifi.svg | 13 + src/web/tools/img/zoom-in.svg | 1 + src/web/tools/img/zoom-out.svg | 1 + 34 files changed, 6991 insertions(+), 26 deletions(-) create mode 100644 src/mod/dynamicproxy/templates/forbidden.html create mode 100644 src/mod/webserv/templates/index.html create mode 100644 src/web/tools/fs.css create mode 100644 src/web/tools/fs.html create mode 100644 src/web/tools/img/arrow-left.svg create mode 100644 src/web/tools/img/arrow-right.svg create mode 100644 src/web/tools/img/eq.svg create mode 100644 src/web/tools/img/file.svg create mode 100644 src/web/tools/img/folder.svg create mode 100644 src/web/tools/img/icon.svg create mode 100644 src/web/tools/img/network.svg create mode 100644 src/web/tools/img/opr/copy.svg create mode 100644 src/web/tools/img/opr/delete.svg create mode 100644 src/web/tools/img/opr/download.svg create mode 100644 src/web/tools/img/opr/new_folder.svg create mode 100644 src/web/tools/img/opr/open.svg create mode 100644 src/web/tools/img/opr/paste.svg create mode 100644 src/web/tools/img/opr/share.svg create mode 100644 src/web/tools/img/opr/upload.svg create mode 100644 src/web/tools/img/wifi.svg create mode 100644 src/web/tools/img/zoom-in.svg create mode 100644 src/web/tools/img/zoom-out.svg diff --git a/src/acme.go b/src/acme.go index 27553e8..8778384 100644 --- a/src/acme.go +++ b/src/acme.go @@ -2,7 +2,7 @@ package main import ( "fmt" - "io/ioutil" + "io" "log" "math/rand" "net/http" @@ -65,7 +65,7 @@ func acmeRegisterSpecialRoutingRule() { return } - resBody, err := ioutil.ReadAll(res.Body) + resBody, err := io.ReadAll(res.Body) defer res.Body.Close() if err != nil { fmt.Printf("error reading: %s\n", err) diff --git a/src/api.go b/src/api.go index 8faea65..7f4952b 100644 --- a/src/api.go +++ b/src/api.go @@ -169,6 +169,26 @@ func initAPIs() { authRouter.HandleFunc("/api/acme/autoRenew/renewNow", acmeAutoRenewer.HandleRenewNow) authRouter.HandleFunc("/api/acme/wizard", acmewizard.HandleGuidedStepCheck) //ACME Wizard + //Static Web Server + authRouter.HandleFunc("/api/webserv/status", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/webserv/start", staticWebServer.HandleStartServer) + authRouter.HandleFunc("/api/webserv/stop", staticWebServer.HandleStopServer) + authRouter.HandleFunc("/api/webserv/setPort", staticWebServer.HandlePortChange) + authRouter.HandleFunc("/api/webserv/setDirList", staticWebServer.SetEnableDirectoryListing) + if *allowWebFileManager { + //Web Directory Manager file operation functions + /* + authRouter.HandleFunc("/api/fs/list", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/upload", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/download", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/newFolder", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/copy", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/move", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/properties", staticWebServer.HandleGetStatus) + authRouter.HandleFunc("/api/fs/del", staticWebServer.HandleGetStatus) + */ + } + //Others http.HandleFunc("/api/info/x", HandleZoraxyInfo) authRouter.HandleFunc("/api/info/geoip", HandleGeoIpLookup) diff --git a/src/main.go b/src/main.go index efe933c..1dce6ea 100644 --- a/src/main.go +++ b/src/main.go @@ -43,6 +43,7 @@ var ztAPIPort = flag.Int("ztport", 9993, "ZeroTier controller API port") var acmeAutoRenewInterval = flag.Int("autorenew", 86400, "ACME auto TLS/SSL certificate renew check interval (seconds)") var enableHighSpeedGeoIPLookup = flag.Bool("fastgeoip", false, "Enable high speed geoip lookup, require 1GB extra memory (Not recommend for low end devices)") var staticWebServerRoot = flag.String("webroot", "./www", "Static web server root folder. Only allow chnage in start paramters") +var allowWebFileManager = flag.Bool("webfm", true, "Enable web file manager for static web server root folder") var ( name = "Zoraxy" diff --git a/src/mod/dynamicproxy/Server.go b/src/mod/dynamicproxy/Server.go index 1fa4793..c446277 100644 --- a/src/mod/dynamicproxy/Server.go +++ b/src/mod/dynamicproxy/Server.go @@ -7,6 +7,7 @@ import ( "net/http" "net/url" "os" + "path/filepath" "strings" "imuslab.com/zoraxy/mod/geodb" @@ -192,9 +193,9 @@ func (h *ProxyHandler) handleAccessRouting(w http.ResponseWriter, r *http.Reques if h.Parent.Option.GeodbStore.IsBlacklisted(clientIpAddr) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.WriteHeader(http.StatusForbidden) - template, err := os.ReadFile("./web/forbidden.html") + template, err := os.ReadFile(filepath.Join(h.Parent.Option.WebDirectory, "templates/blacklist.html")) if err != nil { - w.Write([]byte("403 - Forbidden")) + w.Write(page_forbidden) } else { w.Write(template) } @@ -206,9 +207,9 @@ func (h *ProxyHandler) handleAccessRouting(w http.ResponseWriter, r *http.Reques if !h.Parent.Option.GeodbStore.IsWhitelisted(clientIpAddr) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.WriteHeader(http.StatusForbidden) - template, err := os.ReadFile("./web/forbidden.html") + template, err := os.ReadFile(filepath.Join(h.Parent.Option.WebDirectory, "templates/whitelist.html")) if err != nil { - w.Write([]byte("403 - Forbidden")) + w.Write(page_forbidden) } else { w.Write(template) } diff --git a/src/mod/dynamicproxy/templates/forbidden.html b/src/mod/dynamicproxy/templates/forbidden.html new file mode 100644 index 0000000..5c3f6e2 --- /dev/null +++ b/src/mod/dynamicproxy/templates/forbidden.html @@ -0,0 +1,55 @@ + + + + + + + + + Forbidden + + + +
+

+
+

403 - Forbidden

+
+

You do not have permission to view this directory or page.
+ This might cause by the region limit setting of this site.

+
+
+ Request time:
+ Request URI: +
+
+
+ + + \ No newline at end of file diff --git a/src/mod/dynamicproxy/typedef.go b/src/mod/dynamicproxy/typedef.go index 218bae5..2372f04 100644 --- a/src/mod/dynamicproxy/typedef.go +++ b/src/mod/dynamicproxy/typedef.go @@ -1,6 +1,7 @@ package dynamicproxy import ( + _ "embed" "net" "net/http" "sync" @@ -31,6 +32,7 @@ type RouterOption struct { RedirectRuleTable *redirection.RuleTable GeodbStore *geodb.Store //GeoIP blacklist and whitelist StatisticCollector *statistic.Collector + WebDirectory string //The static web server directory containing the templates folder } type Router struct { @@ -123,3 +125,11 @@ type SubdOptions struct { BasicAuthCredentials []*BasicAuthCredentials BasicAuthExceptionRules []*BasicAuthExceptionRule } + +/* +Web Templates +*/ +var ( + //go:embed templates/forbidden.html + page_forbidden []byte +) diff --git a/src/mod/utils/utils.go b/src/mod/utils/utils.go index bd21c8b..9af3ebc 100644 --- a/src/mod/utils/utils.go +++ b/src/mod/utils/utils.go @@ -5,6 +5,7 @@ import ( "log" "net/http" "os" + "strconv" "strings" "time" ) @@ -76,6 +77,22 @@ func PostBool(r *http.Request, key string) (bool, error) { return false, errors.New("invalid boolean given") } +// Get POST paramter as int +func PostInt(r *http.Request, key string) (int, error) { + x, err := PostPara(r, key) + if err != nil { + return 0, err + } + + x = strings.TrimSpace(x) + rx, err := strconv.Atoi(x) + if err != nil { + return 0, err + } + + return rx, nil +} + func FileExists(filename string) bool { _, err := os.Stat(filename) if os.IsNotExist(err) { diff --git a/src/mod/webserv/handler.go b/src/mod/webserv/handler.go index 0a4eba6..5db1837 100644 --- a/src/mod/webserv/handler.go +++ b/src/mod/webserv/handler.go @@ -1,5 +1,13 @@ package webserv +import ( + "encoding/json" + "net/http" + "strconv" + + "imuslab.com/zoraxy/mod/utils" +) + /* Handler.go @@ -7,3 +15,74 @@ package webserv web server is directly listening to the TCP port handlers in this script are for setting change only */ + +type StaticWebServerStatus struct { + ListeningPort int + EnableDirectoryListing bool + WebRoot string + Running bool + EnableWebDirManager bool +} + +// Handle getting current static web server status +func (ws *WebServer) HandleGetStatus(w http.ResponseWriter, r *http.Request) { + listeningPortInt, _ := strconv.Atoi(ws.option.Port) + currentStatus := StaticWebServerStatus{ + ListeningPort: listeningPortInt, + EnableDirectoryListing: ws.option.EnableDirectoryListing, + WebRoot: ws.option.WebRoot, + Running: ws.isRunning, + EnableWebDirManager: ws.option.EnableWebDirManager, + } + + js, _ := json.Marshal(currentStatus) + utils.SendJSONResponse(w, string(js)) +} + +// Handle request for starting the static web server +func (ws *WebServer) HandleStartServer(w http.ResponseWriter, r *http.Request) { + err := ws.Start() + if err != nil { + utils.SendErrorResponse(w, err.Error()) + return + } + utils.SendOK(w) +} + +// Handle request for stopping the static web server +func (ws *WebServer) HandleStopServer(w http.ResponseWriter, r *http.Request) { + err := ws.Stop() + if err != nil { + utils.SendErrorResponse(w, err.Error()) + return + } + utils.SendOK(w) +} + +// Handle change server listening port request +func (ws *WebServer) HandlePortChange(w http.ResponseWriter, r *http.Request) { + newPort, err := utils.PostInt(r, "port") + if err != nil { + utils.SendErrorResponse(w, "invalid port number given") + return + } + + err = ws.ChangePort(strconv.Itoa(newPort)) + if err != nil { + utils.SendErrorResponse(w, err.Error()) + return + } + utils.SendOK(w) +} + +// Change enable directory listing settings +func (ws *WebServer) SetEnableDirectoryListing(w http.ResponseWriter, r *http.Request) { + enableList, err := utils.PostBool(r, "enable") + if err != nil { + utils.SendErrorResponse(w, "invalid setting given") + return + } + + ws.option.EnableDirectoryListing = enableList + utils.SendOK(w) +} diff --git a/src/mod/webserv/middleware.go b/src/mod/webserv/middleware.go index 1dade78..ed03037 100644 --- a/src/mod/webserv/middleware.go +++ b/src/mod/webserv/middleware.go @@ -22,7 +22,7 @@ func (ws *WebServer) resolveFileDiskPath(requestPath string) string { // File server middleware to handle directory listing (and future expansion) func (ws *WebServer) fsMiddleware(h http.Handler) http.Handler { return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - if ws.option.EnableDirectoryListing { + if !ws.option.EnableDirectoryListing { if strings.HasSuffix(r.URL.Path, "/") { //This is a folder. Let check if index exists if utils.FileExists(filepath.Join(ws.resolveFileDiskPath(r.URL.Path), "index.html")) { diff --git a/src/mod/webserv/templates/index.html b/src/mod/webserv/templates/index.html new file mode 100644 index 0000000..8716959 --- /dev/null +++ b/src/mod/webserv/templates/index.html @@ -0,0 +1,61 @@ + + + Hello Zoraxy + + + +
+
+

Welcome to Zoraxy Static Web Server!

+
+
+

If you see this page, that means your static web server is running.
+ By default, all the html files are stored under ./web/html/ + relative to the zoraxy runtime directory.
+ You can upload your html files to your web directory via the Web Directory Manager. +

+

+ For online documentation, please refer to zoraxy.arozos.com or the project wiki.
+ Thank you for using Zoraxy! +

+
+ +
+ + \ No newline at end of file diff --git a/src/mod/webserv/webserv.go b/src/mod/webserv/webserv.go index 6548d92..542810c 100644 --- a/src/mod/webserv/webserv.go +++ b/src/mod/webserv/webserv.go @@ -1,6 +1,8 @@ package webserv import ( + "embed" + _ "embed" "errors" "fmt" "log" @@ -9,6 +11,7 @@ import ( "path/filepath" "sync" + "imuslab.com/zoraxy/mod/database" "imuslab.com/zoraxy/mod/utils" ) @@ -18,11 +21,17 @@ import ( This module host a static web server */ +//go:embed templates/* +var templates embed.FS + type WebServerOptions struct { - Port string //Port for listening - EnableDirectoryListing bool //Enable listing of directory - WebRoot string //Folder for stroing the static web folders + Port string //Port for listening + EnableDirectoryListing bool //Enable listing of directory + WebRoot string //Folder for stroing the static web folders + EnableWebDirManager bool //Enable web file manager to handle files in web directory + Sysdb *database.Database //Database for storing configs } + type WebServer struct { mux *http.ServeMux server *http.Server @@ -31,13 +40,23 @@ type WebServer struct { mu sync.Mutex } -// NewWebServer creates a new WebServer instance. +// NewWebServer creates a new WebServer instance. One instance only func NewWebServer(options *WebServerOptions) *WebServer { if !utils.FileExists(options.WebRoot) { - //Web root folder not exists. Create one + //Web root folder not exists. Create one with default templates os.MkdirAll(filepath.Join(options.WebRoot, "html"), 0775) os.MkdirAll(filepath.Join(options.WebRoot, "templates"), 0775) + indexTemplate, err := templates.ReadFile("templates/index.html") + if err != nil { + log.Println("Failed to read static wev server template file: ", err.Error()) + } else { + os.WriteFile(filepath.Join(options.WebRoot, "html", "index.html"), indexTemplate, 0775) + } + } + + //Create new table to store the config + options.Sysdb.NewTable("webserv") return &WebServer{ mux: http.NewServeMux(), option: options, @@ -46,11 +65,31 @@ func NewWebServer(options *WebServerOptions) *WebServer { } } +// Restore the configuration to previous config +func (ws *WebServer) RestorePreviousState() { + //Set the port + port := ws.option.Port + ws.option.Sysdb.Read("webserv", "port", &port) + ws.option.Port = port + + //Set the enable directory list + enableDirList := ws.option.EnableDirectoryListing + ws.option.Sysdb.Read("webserv", "dirlist", &enableDirList) + ws.option.EnableDirectoryListing = enableDirList + + //Check the running state + webservRunning := false + ws.option.Sysdb.Read("webserv", "enabled", &webservRunning) + if webservRunning { + ws.Start() + } else { + ws.Stop() + } + +} + // ChangePort changes the server's port. func (ws *WebServer) ChangePort(port string) error { - ws.mu.Lock() - defer ws.mu.Unlock() - if ws.isRunning { if err := ws.Stop(); err != nil { return err @@ -60,6 +99,13 @@ func (ws *WebServer) ChangePort(port string) error { ws.option.Port = port ws.server.Addr = ":" + port + err := ws.Start() + if err != nil { + return err + } + + ws.option.Sysdb.Write("webserv", "port", port) + return nil } @@ -100,7 +146,7 @@ func (ws *WebServer) Start() error { log.Println("Static Web Server started. Listeing on :" + ws.option.Port) ws.isRunning = true - + ws.option.Sysdb.Write("webserv", "enabled", true) return nil } @@ -118,17 +164,14 @@ func (ws *WebServer) Stop() error { } ws.isRunning = false - + ws.option.Sysdb.Write("webserv", "enabled", false) return nil } // UpdateDirectoryListing enables or disables directory listing. func (ws *WebServer) UpdateDirectoryListing(enable bool) { - ws.mu.Lock() - defer ws.mu.Unlock() - ws.option.EnableDirectoryListing = enable - + ws.option.Sysdb.Write("webserv", "dirlist", enable) } // Close stops the web server without returning an error. diff --git a/src/reverseproxy.go b/src/reverseproxy.go index e45953a..43c66de 100644 --- a/src/reverseproxy.go +++ b/src/reverseproxy.go @@ -64,6 +64,7 @@ func ReverseProxtInit() { RedirectRuleTable: redirectTable, GeodbStore: geodbStore, StatisticCollector: statisticCollector, + WebDirectory: *staticWebServerRoot, }) if err != nil { log.Println(err.Error()) diff --git a/src/start.go b/src/start.go index 483d9d2..a0a1b3a 100644 --- a/src/start.go +++ b/src/start.go @@ -217,13 +217,14 @@ func startupSequence() { */ staticWebServer = webserv.NewWebServer(&webserv.WebServerOptions{ - Port: "8081", + Sysdb: sysdb, + Port: "8081", //Default Port WebRoot: *staticWebServerRoot, EnableDirectoryListing: true, + EnableWebDirManager: *allowWebFileManager, }) - - //TODO: Connect UI element to static web server - staticWebServer.Start() + //Restore the web server to previous shutdown state + staticWebServer.RestorePreviousState() } // This sequence start after everything is initialized diff --git a/src/web/components/webserv.html b/src/web/components/webserv.html index fcd8637..e8ac76f 100644 --- a/src/web/components/webserv.html +++ b/src/web/components/webserv.html @@ -4,6 +4,16 @@

Static Web Server

A simple static web server that serve html css and js files

+
+

+ +
+ Running +
Listening on :8081
+
+

+
+

Web Server Settings

@@ -29,10 +39,11 @@

Web Server Settings

- + Use http://127.0.0.1:8081 in proxy rules to access the web server
+ Changes are saved automatically
@@ -63,10 +74,108 @@

Web Server Settings

+
+

Web Directory Manager

+

Manage your files inside your web directory

+
+ + If you do not want to enable web access to your web directory, you can disable this feature with -webfm=false startup paramter + + + + + + + + + + + + +
+
+
+ +
+
+ +
+
+
+
+
+ + +
+

+ No File Selected +
Select a file to view file properties
+

+ + + + +
+ +
+
+
+
+
+
+
Uploading Files
+
+
+
+ + + + + \ No newline at end of file diff --git a/src/web/tools/img/arrow-left.svg b/src/web/tools/img/arrow-left.svg new file mode 100644 index 0000000..9d557f9 --- /dev/null +++ b/src/web/tools/img/arrow-left.svg @@ -0,0 +1,8 @@ + + + + + + diff --git a/src/web/tools/img/arrow-right.svg b/src/web/tools/img/arrow-right.svg new file mode 100644 index 0000000..e64c7c1 --- /dev/null +++ b/src/web/tools/img/arrow-right.svg @@ -0,0 +1,8 @@ + + + + + + diff --git a/src/web/tools/img/eq.svg b/src/web/tools/img/eq.svg new file mode 100644 index 0000000..548adfd --- /dev/null +++ b/src/web/tools/img/eq.svg @@ -0,0 +1,8 @@ + + + + + + diff --git a/src/web/tools/img/file.svg b/src/web/tools/img/file.svg new file mode 100644 index 0000000..e84a95e --- /dev/null +++ b/src/web/tools/img/file.svg @@ -0,0 +1,3442 @@ + + + + + + + + + + +]> + + + + + + + + + + + + + + + + + + + + + eJzsvcuOJsmVJrYvoN4htGiAHEwG3c3Mb5QwQFx7KDXZBMnuJtE1KCSzktU5nZVZyMoqDmchSBAE +TENaaABBmNFGWvRCLUCbWWgxkp5G6IveQuf7zsXc/Pc/4o/MJJvsjnBUVqaHX8zNjp37+c7v/Sc/ +/PGTi89e//z5k3zenX380e/93tWb50/fvn7z3TOePvvey5dff/X2DU5960ffPuvH8w5XXXxv/tSu +/OPnb7568frVd/k7/e0t7v/WT17//FffPvvWt3HmJy/evnwu537x4uXz86+++fzb8Sq59frpW/nd +9J1++k7qUn/W99/t57OL7/Oap6++efrVVy/+9XO8IM8ZJy9ff/3qsxevPr98/a++e5aWsyd9N58t +8v804Nf//MWPnn+1f818Po6TX3f9+tnXXzx/9faHb14/e/7VV1evX75+89V3z65+9fTV2feffi6/ +eXr2s+cvX77+5dnly6fP/nx9z618yFffvf7uJ5+/fvn01eefPH3z+l+//uqTXz7/+Scvvvj8k69+ +9dXb5198ws/98tXncufF94ZPcZPMzRdP3571iVN18b0+fXr59YuXn/3g6y9+/lymbZwTz+dPOZ4/ ++koGImPC33l++vR7X8ipHz9/+1a+TobLGb/6/s/+i/VnyGTZ8a0//Zv/7v/+27/4N3/zv/37v/3L +//h3f/Ef/sW3/flvXn/5xdM3f45nyPSk+Qz/dfbbnzz/4suXsjCcv7GcD2dP+Gf9q18oH8WLnqSc +z8eu68+elKE/H5ZlPMuj/yXp7+ymOvXPv3nx/JffPfvB61fPbZYu3rz9sa53KV2nf9qvfvT1y+dv +/ujVi7cy5pHnFp2m77/+7PlLWef6iNuXTzk7PPr6p13xk6dvPn/+Vujk9cuv35J853iLLMUfPP3V +c9BCspf84ZfPX/3k9R9zqDJVWWj0bDxLZezPlr6cCbniBYO8o5/inX39056Mx+Ah/vgJH/F7P5T1 +/MM3Lz5/8eq7T1JJMn1jZ2v9+29efFaXekpns/7BTzmfV/8t/p+NWL7/7dvn2JZOZlffXxFNd/79 +H+PdN68+u3r9BZbiK+6s5zIKIaSXrz+339Z/8HfyiK+/tK/hiU9l5X745sUrPPjjj36gv5s//eHL +r+WXv//m9ddffu/VL15//NG3lJ/88fNnwjNkeT87+8Of/0v5h3CIT9JUvpE/+k/SmOW/8iv+I/eT +/DJuOH/64stv3/N0+eg3z8/0t3Iv/yn//wX+f8r9189/IduzPkDPfpKGLKNJ8v/x+xjsn+Bvn+Su +4B+f5CS/GZP8f5Bbbl598/zl6y+fnz199dnZnzx98+Up7/2h8JCnb874i9Vry/QzfVMvU1Pw2iL/ +KOm+MfzBi2/kmU9lUU56uZDilzLLvInXbAZyxwWrX530qqdv/0x46fNXn321+sxJxl4G+Rb5L5eT +Pk6fccorf/yrL37++uWLr75YvRDPkpelqQOhyS/iohM/4u3zN6/+8JV+zZuvv/qzs5+8fv1y/UWk +Xh18D5IesJjyUd0nebh3+YR76cN/90YTFx8ZyfC1PFmGozOvw/rHM5yrpy9fvvj8zdMv/+zFs/0R +Delz7PRP8ljqSB42oiMvOWmvPCMx7Q+NI0q6aWQkDxzV4aN/Jwdku+3s5rMXIpWOsMs7r/nxL5++ +ffZnZ3/w4udvnr558fweHgbK+sWLV5/JQH/89Yu3zxvilS8bIRJ+Cvb5X+q35g5cWe66Xd1V3zF8 +KiJ9LbKfPLlbmKfu7PLV+pLff/P0sxeiLogy/0evXj39QgT553bqrJeX7J0VZaWcXX728Ud/+vFH +/9nHH11NPEYegx2FR+aRePQ8Oj0ub3nc8LjmcWXH5ccfXeLngsfCY7Zj4jHyGHgUOzKPxKPn0elx +cXtx+/FH8ucNj2seV3boS/Rn4THbMfEYeQw8Co+shzwx8eh5dDiWWztueFzzuOJhn6GvWPRn5jHZ +IZrjMsohavg/46zKW/D0js+75jMueNeEq5ay5CUt/Xw738zX85VMzoU8bp6neZyHucx5TnM/d9Pt +dDNdy/LIrMoHLdM8TdM4DVOZ8iQ8curG2/FmvJalu5RPXcZ5nMZxHMYy5lF46dgNt8PNcC1LeimT +sAzzMA3jMAxlkDkY0tAPXbktN+ValvtSJmgpc5nKWIZSiqg2pS9dvs03+VoI4VImbhGbb8pjHnLJ +WayIPnfpNt2kayERGaNM6ZJmUSFG4Z0lyR5Pfer62/6mvxbyuZTJlo/up37sh770osX1fd91t91N +dw2ywjJ08tmdDLyTV3/8USe3wxTQWe3WP/3ukXaPvHsUeWLZOYbdY9w9pvaQJ+rf5t1j2T0udg/b +AvLEy+a42j2ud4+bvUOeeIuDsypz25/93qeXb5QZXMq+Wq6mIGNsj4QNo5e2V1/3smq3ctxcXV/h +5zLuW7gJR248boWdJwj/6c6FJGWpaUB1g1C3m2kj7LdlPs99GXE97KNPT7z88is8eZr7Icnvz8c8 +Dd0UZiAvHdP5kvq8evJJl9uTZQcPIy/tpjFtLu3l99O0fvIpl+uT534ZOxiQ41hkm7WXdqtn3nMh +nnZ5XYWMy4mTZUe3Lzy6rfSQ/bw95oNj2jnGnUPYkTxxaI6yc+SDI+0c9iNPrD87DEP3wuY43DWr +XSUL5X8/3IeXO8fh3t5wAHniQs53eEwHxx4XOuBWRzjbHhc85Ja701S5r29yWWwMGjIMUgxyTCXZ +BYUjpBnkmUo0yDSVaj0/C5INso3STQ7hFiLjIOEg41TKQc6ppEskGkg7yDtIPJV5lxTxkHuQfCr7 +IP1U/qWPPyJhQQpCDqokvKLqAWkIeagSETKRUlGOpHKRkhGyUaXjFRUVGaPISEhJlZOQlCorIS0p +LykxVWZeU4G6pMqxmOyE9FT5CQkqMvTjj0jCHSWpytJrqlyXVFEWk6iQqSpVIVdVsvZcLEhXyFeV +sCJjheIvbB9OJmsH2ze+LzqTujdGxU6lS9Cc0pTSTDI5vJLE8onptpdH3N7c3FzfXIkieCFq0yyL +OspEl5t8k2RY3fXt9c319fWVqIgXolDNsuDj9XBdZHKSiQ8KjxA9M3XRgdontM6Oeib0y0vqkzM1 +yIE6I3TFjrrhNbXBi7XYOVUHMwo+QQsT+rz8sFqY6GD5w2phooNdflgtTNY+b7SwU/jFAw554ns+ +4Xf+iR/kZ6Mff9Ancu1Xql8jaish3MZxszqu47iK4zIO6pjkWTgWp7KH7/i797vIK9vxwcPwc2PH +tR1XdqiJe2GHG4czj8mO0Y5BD3kiRcZtjp1yRDobZ32wfK57b7sesotVN3K9STUq1bVcD1P9TOfZ +Z19XQ1fH10vWT554a6+yVfZvEk55M9+K5O9lLrPM6SCzO8ksLzLblzLr1zL7tyJMaDjIqgyyOpOs +0iKrdSmrdi2rdysCp5fVzJfCX2RtR1njWdb6Qtb8KtYHs+pzPMUxxxEme6zTha0bDl9JX1nR22K1 +b7j2t7FOh/vzFBvyqOUoT9zYjc16wfBZxcL2TZ1jF6ih0C1LGaD/D+PcZ4aahjL1sF86WKUZN54X +vXVO5yKx5pX58E6365shLxCZPJ/yLGKEF3ZJxFy5ywZ6yF32hdMgUg5DFCE2Zwxx7Gf+petSKf2+ +YfSg297bTCr7ZlL5trxjbSZ1HUkqk0RGugcWmvhXNNJvheJ67rLMLTxy0y7cple2NW+5FZOI84KA +uYj2UUT8LKL+gn6zKxH/N+mWlNmLUpBFOYA+K+asqAtQPy9EeYBCei2qhOhvQq89ldYsaoY8UdSN +UdQOqLYLvWWXoo6IpiaKifA0oWTwlUQVuVBdhto8UYVe6GODWn0las41VW3ZXLJ7O/Ih6K7Qe6Ex +DyN+oKxDaYfXDCo8VHl4IK95QMXHnocmqjwMGrCwVejPNAoGHnzMpD+0Nswfp/4/8zdO5uGksYHj +Jg4ZY3CVreV1YMU2Tqg1k2iZwdpZ1LqCWmdPOHPkidWB4+YmzdDgRv7jvNjN3rLL9IXZhJk9b5i/ +s/9DEVDFwFoU3Kg4hzjAseKHawVg/ZObozTHUA+j4PaYDo5591j2Dnmi//3ivmPXoVjX9dix71xc +iQgqy3cf+4L/qAOyESWnOiXvdFWGi/LUY9+VuTrkifdec6cD9OAwh8iJ1x5Zyw+m/L7Xz++yWfIb +f+JWrRXGlcQMLyJkRmHvs5jnF2KmX72rEkrP9K4aSiU0VNDL68sb0SA7YYpJRGa5GkQ4TVfz1XJ1 +cXV5dXV1fXUjmmV3LSO+TtdZxOQggmu6nq+X64vry+ur6+vrm+tbYeX9TbrJN0VE4igiZ75Zbi5u +Lm+ubq6dbim/q/Sustslt8ptSm2T2ZTYJq2XkNQ3KqUZ2FEZrfJ5oWy+olxWiZwoiwfK4ZkS+JKy +94YyF9I2U8aOlKsLg0+XlKA3lJQnr0rszVN28qk85H6O8zD+dpwrnsRX7zAifp375jfK0bb78ub6 +hOMBP/LEvZ/bdz/kibd7nv31EY7sgfxjJA+ZyEdm8pKF/OSCPOWSfOWKvOWa/OXGbE9V6HqLlTFa +xjCzhpw1/DyS/0w0hGcaw4sFrjWIfUWOdE2uhOOWvKkjf5JDzJREPpXJq4qFzzWUPtF4nldOh6mx +MFobI5vGuLUxbrY2htsXwaEezqOOcCnhUJ3ZEke51Eqq96Zlu+10YD0137b9sqvWepKvKRvbqf2u +B3NfsZwa/rv3XcfNf9iiOZ8jFLC2Y4/8Xk1jeQtM9l6GALNWBkvrVuz4sG3Tci7TMawjp6ffpG8R +Hl5gR8+FVyb5RcQYe/lt7pF+LAxwbec/4CZ7S+kT3AKpR4Q0T+OA/w3jsrlLGN76NQ+4672N/HHf +yB8RC82tkZ+ESEchzwshzRshyiQEOQoxXggZ3ggJJiG+kYR3KUR3S4JD/BaEdgkiExIDgQ0gLiEs +bBohLFk7EBVICgSl2wSiXAU5xLgKcRXhLsBNfFfRvaNQPUyd2ipUIjbDsxdKVahVrlgNwaQWcrtL +ZgpdM3vo1tSsnllGomp9/BHVrYH5SFC5ZnLdCypel0wzuKb6dUPnHqxmtVkTFTGoYoXq2KC+hGsZ +IxWzmcrZolxWk5au+ahr/XG5RWeh2eFuBSc7sh4iXIodgx1jHO5dmFfHEsfF6rishzwRSuH6uE+c +7oq9tXDbiLv+ziPdf8gT8f/8AQ71k5fwmH+w4/GJ+7//Zy2HmkSAXsrWuQ0eNYnAvDQu1YsUHFZ8 +6oaiMZNTTRSJEIgiDoVD9RSHKgxVxKsYdCHoIrCaH1vjozE9xNTYGB8Hpseh8VHNj8rHnJMVqnej +qXVLcLQrV+FCeUumtK3VtaqorZQ04XlbBc2VsxL8bqWYWfqgcr5L435XZEC6+YUvGx/sjBf2lnWZ +LAez2DEEZ1TuqMdsh+mnGKZw0YvgmZfBOa+Cf/qxZjm39dgkkvU0dFf+QXLb9sgHRw== + + + OXIMesgTh51jPOmY9g5y+vuO+SGHPPFB13+gJy4POeSJD7r+t/GJO+mBMIDXmYLLME0ZWp9o3Tl7 +Gh00WtVeNxriCVdDM9RitPGsz2elqsvt2bjufJq2Eaft+ffWNud9bXN+DCk9hpQeQ0qPIaXHkNJj +SOndgisfxO38O/fEx5DSY0jpMaR00r75jXK0dwopPeA48sSrdz/kie9x93s/8fKUg37EBx5NGMwD +YTUYVgNiHhKrYbGLqI304NhVmHQ38kR3e942obIuFMaqPlllpgXNPGw2WA2nBc+E19YQ2uxDuLho +QmmXUR963YTUbiJFtKueGzHW+vDg1BBbjsrUoQm1jW4ARE3rsvLu0MNj9a+X4XgxV3NMt6enrrw9 +Tb6w60eu2V+aTXftWjw3a28Brxza+mg23hw6uYxlZe3dmLbt2nUO/Xk0u282Tfcywn2UICsLENUq +eWUHqjxxW7Bag9UerBahSpiBVTMrm5Dhs2oXqsRpLcOysQyXsAyv3DJc2YWiMe/YhYvJJLcJb0wy +qTWYmnBjtatby/p+27oGU822Flns83ws5Hi/dG7ks8zXjoReyecHS2iZr10ZveN7PVlGPzwn/Dce +Is3D+TI8MEJq95wcIJ2Hc1nP9LAAqd/kb2GMc0JwszsvZWKN6pzK3QHSB9z13i6rZd9ltcBllVYu +q/myOa5OOO70kloxwvHj9thxTF9kUeP+se8hAMHvHcUPlp3UY9g9xt1j2jlkz8kT54Nj7+di57hs +jyOG7qFqeHcxxIGrYeViOF4uv2/E75TAWxn8frH7Tevgapxc1c3Vr31L6upi0UxelRVvXF5RPrPv +9FoOnF4Qt4eOr43ba9fhdejqipDdBoyihaFQAAoCT7CgUQucEofXkdK9MPfSihvF8IrC3CGKHNOq +KNdLci+i1NGLHb3csRY8suRRxMcFCbaWPa4LH9eljy0ERdkUP0b5I0XctCqubUsgjxZBrsEo2iJI +iuF1GeQ7wVGsyiAPYAzKmBJBA85HzP5YS3emcxlZaYpUTrlauf/YzQvLcnr54H6IMMa0F/M44eL3 +5fVpH1Um9dtkGHrDRxYDD0yUyCwJTtwKHQuDb2mR6c8VS4Qvqa8vLBSeWSw80XuvwUINHmaWDifb +Xl0gUNywkPjaQpyXLCe+YEnxYsJkA3PDRJMjIDdHAW4uj4Db0CiQqT0N3Kav4DY81uA2DbyNGDwV +4mYLcuMwN1MYSUMDdrMCvKmGlmF6rIBvGvCb25qpsorOXa2OtfzgcIRHrYFx1vA4frQyrJVyW1l4 +KDMPpeueHN6X2lWubz1DR3UDAzS4+1Dd4/TjBF1HnniKRtQel3cdBxrXAw6XP7vl+O9RmhsSbb8c +/7Agvy3JXxflt2X5tTDfS/Nrcb6X53uB/rKCiwiwiCqvPv6IIccWKGIyuVVhIvqAibhZya9LbjyH +iDApJhKtBExE38BErIEiHCpiXkFFjDS1Ay6Ckk5knRjiDhhx04BGXDbAEfMKPGKksV8CQiJT44gS +bsCLNcXb65LtVal2A/PSwrlsQFtMw1oDtGyAWHYAV6pmtwOqIiLxGIzKXe7aO8BSTFM9tRh7HzCl +AUN4sNv21+hk7bZ51LlJGFinDOw5Nqpr4yCbGtRiyQM53EjuRKrpA9WBVHOry8Z1ZI4joejWddSv +kglKOI40QOHpBI3jaJVSQNeR7OO182jtPlo7kNYupL3kgqE6kkTXXacYHEkyWDuWNM1gJ8nAUgyE +e+0nGdT0gkgtWCUV9JYIl+iS0YMsZxaKpmY/EHpnpKtmortGf1wouxJxaI27zAppJ0/cs5z3beNd +K3hr+Rpc3nFb98H2bWghBzbujov6riO0Hnniw3Kcbu47Vg7xBx97YG1t3LBjVl6NG24jh9vYIaOH +Adh2DKWhRjJXCA37scyjEG/71o5YKXtGzClXm2esGyeW+k9z38/jyhuY8rmwohmXr1xip1zuAG+5 +n+A4E4YzlCkMqZQOAQfuv/Z9ba487NpccloeHv61jut4D+6QYT+ehjmkHtmD9cS3DWcN8N40nnei +rax9s0ev4QwTXKL5tayBaAlL84gjl7zvfO6DNpStt7I7LcFuP71up5ZKJOZ+xdE7h+ZPqaN6WGie +0ujA7X9SmtphktrU+PY2KWqYRQPSO0xPW3vs1mlpx8FtzCNnMELHoG3W/re1561NLRsiKKarVpPG +IhXsnZK97kzz0uNosteJqV2HyVwBQnRnAtdDkrQsUeK3OWXqfZIgPlhaxd0BrVaKHP7q5DDWRnqe +dsN7s9B9N6Cc/nBMdLcclRmZ97LQnWhutq0yrkyfZRNdr7F1N4GqEcSREe/0IphLLZr1qHrjut8Q +42Ho5HADb7dlEyCxnKfD8EgTFjlxI747kd9p/n4Iohf1D+WcvdZ4ioQjCU/zMZo/7fr3Jvm0T/Kp +gcSVN/fdMCxcgqaIKUowdXnWhTC1UPFAx69ZwHobnVzjNDSPkeP4rR/sePgTA8rvYZ7CeyE74c09 +HTodnsEV5J+C/SnEn0L7KaSfAvnBiaDQpgpuqvCm15Z+dUFTbLbYhihYLATNBnbaR1Tj2iBPHfR0 +jjjGljl8sJ+HP/FgqxrpQvFeJuF9LJ4RBXS+G5L7IXcZtFvcMcz9CEE1i2LfDes7DgG6H3KXvaeb +JkJ6i3Y7aDFQFr473g3X/ZC7/D1jIYjelISZjwpuJyePQdSdcvn7sqt9m3F4rCJ6rCJ6rCJ6rCJ6 +rCLaHI9VRL8Bk/h394mPVUSPVUSnHI9VRL9ZjvZYRfRYRfRYRfRYRfRYRfRYRfT3UkU0jOdT6ceH +hWD8psc6osY5tR9UGvomzwHNTq6PHDcnHQfYd6tmJ/tuhL0KjbUToboPzGFgUePpwDGgcuoymOOV +oWdpFuftik32kTFHVikss7LLkQllLctUpqkbfs0214yzyaKzVmbuULvPpTYZQ3CWYEwh2IKyzMou +53CgrRmls4dDgLddBiGG1oZFOIvdbSB4+nHQkDBcU4f+tW1S+cWOq2rHXWV0erz+Z0tbhzkIQ+N+ +mplBMh9Q0paOWipKQUXFKGioFCRUdUhD17s0VCloiDxMz8S8DAqS9VkJ33SEhi4aGrpZi90QuS5w +L1hf1FBR0MD7/Ry0jJQntm7MfODQbN2abbXYTr2YPPF+B+f1YY7K8SwV4he3WSqV01TKuNyoXzeN +CtavaUJooKGJA4o4pIc7VbEiCqNTwwEtlI16cQc3WfMSoYGWm9z+Bpxr724inxo3fTeH7HHX62kZ +PjvOzwNHyJFmxLstiHdbDssTN1WZTV1md2Qn7u+5YdUadrXbDiOYQlvLAoWoZPmKwr/k0lMRm+dh +zEfzZh52o7XCkuEw9aAD8eP/4yCKXihiUxb1Dymn60ZYJ9/z3urUfp6jnL5PnXqQ+nSoNq26A+6p +TVulqY2w7KpL7Gq5FnT3qkuNbbnD1lhs8J6irmVu7OW5FnXzjqi7vVvUmWV5rVHGjz8KhWltUW0S +NHdtqiNWFQvrDjzS76RS7fV03ihPjfA7rjjdFeXb0FhQ1nGVadyIxHvUJXliFYzHFKajVLRHQ8RE +TgdUNDZUtKdy7wtJoSOhrLW34jqs8bWobCnJ7fKgpZaShLLGlfpt1PROatWBEnWoPskT71eeDmno +WJm9UAoL7XfUpmNK04pCKn3MK1/VhUU7TlSZ7lGYaIQJhznOV7alTEe5ypoahA4qV9mnhdyqTYeU +YL6qFHQwHKeDd9KfTo0b3BGrPlEZOoxB3636HI/3rhQdeeK+ovPOgBOrIsjjUBP7tH/EXAiJfZ/B +cDJ/tKzajWviUL0aZegLU6PmpZRZ/zL3zL7EVjialvzAG09Ur5D6WR6oXsU976te7eM0z1CuhjbB +6oP+nIDV8mHDeY9PfHzi4xN/Y09sQkielumhoxo22oaMjtSc1VCRsPg2kWMbLKrhopttCuYmAdMC +baLobv3FO8rrJgnzznpr+o/Lut56lYxZ0zG3CZnrmut1WmabmOmpmZ6c6emZnqA5R5z6YpOmWRM1 +qRztpGveTOv+5Hela24zBmXyP/4oKrjXddztMRw9xsNDnjhuqr9POe74IWrUqT878GSHhzzxpOtO +P/5xP/Ggxc/dTcgG2R61uU8iL/DWPtj/2P3FAsXY8zBNvK2PtyG7iDZkfZgd6saoxsY6GGxuC+6g +NtJTA8HHk+jWTosIBms4+OOPLPnDm/esW/d4Y7LrVdOebcOebbMeMQOsWc+mUY8lXNQWPbU9z7o1 +z7otj7XksYY8bSuetgXPtvXOXrOdVXOdWvyzqiTaNtC5r/nNfpOWi93j8o7jav+QJ27PveePPPH6 +gTlc9xzyxA+cNfa79MRt4diq687+X7VSSDhBQUbAkOeO6AfzJKZXvrMlzwNu2nTmGfrzTjb/Xnse +/1Xt0TMO8puxP4cNfpaL2J5D2bTr2b1k84RJHiw61FnqznNapr0nbC/5TfYJmvO+/Zm3FbhbAK5V +Yd2mrK4W1QVRqD/w4h1BElvfweDrvILTLefT0q+Lr+66ynJy7Io70CfuuOaB0/43f/Xv/t//6r/+ +//6v/waTXf+xtfHvKoR4hyKJdc1+1FDel/y9Sv0+JfGblYuW+h3FpHvt2I4dx5q7rY61hNorUH3f +apTNIU+8ExrBP/Oe3LOTc/Y970z22F7OfuDlxPTe35tufdzbA0+eeHh2tUR/HzXB9xUZHT18kt6l +sEC00jv6SD+8rGA/YfGghtiriL2O2CuJJ1YSey1xZpSS9cRRUYyaYk/GFs0w6ornHdTUY5ipV6sK +Y6sx3lvwU3/+3h0fu8c7EOQG7m5b13o8+3Yf6s7wHRh5dI96aVJvVlGkOyJI6xg13S+RA11WiVme +3jeuYo71mI8fwWMuTcW+MWbfWf/izFqfEr2KJ6v5WVa9iEGSuDG6C1sX4doheN29l1iZt+Z7cd+H +YsR5on4cl3EIt6xNRpvjSEPju392wZg1G/acAYc5r9WAjUJ653Veq84wwpSLXjU29ebzfD6NZf3I +Uy73J7PKfCAW2fks/K2pMB/P5yEvzaNPuT4q0g2DrEXQms87EWttLfpdFxpYF95X699Z2t8kUB/8 +9oFq1t/++/+HmtW/hZpV/7HJUyHjvTbghsVAG4YAbOgMrOHKgBpmA2koBs/QGTTDlcMyUCITlIGQ +0j2hpG8IIX1J4Oh5F/z2+jj8rWgC9wLg3gVscQhrwQTYO4AtDPJ2CHD2LsBuFeq2grIbJhyq3zeo +cNPDcOECiN1g2IWTbYDYj8Gwb0DYj0KwC9GdBMK+zfPvj+z0vV8GaT8IneYBRP13f/m//91f/Ie/ +/su/+tu/+o+g6+bfDXLfOcoGz4tj+O1ZTwyZcqtBWCPhXuHityzt7uuUOcQ1+/AUu79+6Lf/n//t +3/wv/+Nf//f/k2xj+ei/+Z//zd/8u/+Vk7D7C3lPrrOR1n/0dSKO/0ZvO/P/4qth9A== + + + pQWg+qDeNWTQvdcaFFF7nZinfSow/XMvPK/LZ9MiNn1/x6OP37L/hmXYhTi646p7lkbOfPqD169+ ++ObFq7cvXn3+5Ml6yda/+fijH3zJ32X93Q+fvn37/M0rrOa//Yu//j/+By6f/u2sL6MY2dN41vfz +ubCgs2HJ5/0y5bM8iegYka2JPXSh//vpL/H/r/Ufve2sn/5K//2fy9//pZz9pXzN2ffP/vRfdGef +fcy7fkTHib/Kn3z2BU4fvPDsD5rTPrA/aJ6xf7Z9xCv88Z2LN2+vXzx7++L1q6dvfnX2XXXhfOfy +9euXZ9+6+J7Nzac3n714+/rNp5dPn/25zOCnP3nx8vmnP3r+7O23z/4p7vhP8cfq0//QIEPdyZHO +/pyDTqjUEVWhn6dz4aX2hRmqiYx5TueTyIgzUQ7PO7Fcz/qpyG9EG8AZsZfms34s52PKZ1d646Q3 +ymWiEwxnQ0Ed0tTrowCiI8xeHtXJjaKSiHDxG0U/AfhqPw/nZRaVCC8Q3VRGJlRbcjed/bFemM8h +FeRCea8w57ODT/gZrvsFL+57/VWSxye8XT+vT/C7JTmdztMsoxv66XwCz5IhiPrRyZlUzrNo8XKm +nMPKs3Gm/nxElq4IG9GHZAWHhIdNie+Ahi1nRh1iKgXYQ4PfOpzLkuNCWfwC0Fd52SKijQ/rO0wX +BiRPk7eO52mKt2I9RGVcX9iLVrbgy+SpBdOFAjJZj1SAR9aNfmfyGZCBj52MLi/nAyDK8KlZ12hG +ayl8vFyzzOnsGW8de5ulvpz3yKERK/YcNshZ6gZhLqO8dZR5Ja9finyzDFzfKjQx4c5O5j/PsuiD +zE0ni566SecPhCFSW87IGk1icNhLZZd0RRYq9SPKu4CMu8joUs+FEFqQBT9Y1atmxUXpIJfoyugL +3snDpllIZABYbgIDK0qOvYxM5qbwjJLRKLQgqosNqMsyjgHkKptGtKWzssh0zdjnINVUZjkjiyHk +I2dkghYf0NAl2fEJtC+f2I+4UBYLYFT9uMi3zJOcWaBdC92PQJeS9eGtZUlCK8Kp+3GQ4QkdiDZ0 +PuZu4cPkBhmH/CVPk57hZrNb5feDLKI8XxZJCFPUqPME9Fo8TEgW4+h0ltDzZXACLbJFoe7xdBl7 +eYVsvSRKopzpFeuuYOB4ez/Iavi2Fw1QrAJRvzG/BXODO7sFZwoopMMohNjhB40z9lLMjaxqj80C +Wiky7oU7HJQ6JTxs1OFmDLAOdwQCsgylZJQHCjV2vdoofZn0LwfkwDsvf648dR/Y+IlwrCKrncAp +4akXJRjGz1SEhZsIeSJawyKbTJg43pKxhcQqQqr+5ed4+JOUhRKEszyRr86iDMsOkdWQi58MZDVJ +fjPKfltkL57NnWwoKKtnPyW9Psmid8vUy6+e9ELh4GvT4RMS6h/PZ1FusSNlqAW7+JJ0K/fJAGRD +PpF1midQ+t4A5Mmi2WMARUhYiP7yIQOQJ8gajVOGaiGUPC+dv/8XKnbggtwXad9Znzj7zg9evxXp +9frNZ7Ic/7QGWo5O9Hd+9Pzpy+8/ffvmxb/C1Wffurr4nqsfP/nF6zdf6O9cGork/Oz1z59/evG9 +5VMZzI/f/krEZR3BVmhCRv70s0or6T1oxf9UwvApGc++9e2zn/4J/vpPvtbvvdbf87Ixyf7JwnN7 +UHCXTPWQ6Rc2C4IWPjpM8nsxwERQiAIhW3ru5f+jbB8s+NlkcpYkP4pATuCywgtyJ2MbwVjAueW+ +NJVyNsqGHmbZ2aLGjHMy+RGXyX4eRzHLR+DPzUBEF8oT2c8BUHSiHnd2iYX7cpanjfm8S3i8SArh +agnhEG5WEUayfUUKwjMhW93HKdeLnDkDTxMt4gwDX5LwoinJVMtt0yQUn/h+ua4ol5YBk1hFtxCG +O52N83KeR/A+2RSTTIYwMd4u5Jrn2cTUOGeVQSJHxJiUq0TAwdY9E44iJrGMHtIB8lg2gzBNk4xj +wUboCqZ44VWiC8k2wdSJ5SyDFqHMSRJZfQ5fnb1PhsfHLwNHK89QUSzjEIYni1mKag4yWbPQld8m +jC53XOJpxG8T2K1sSJEJuYzyoIQYJqhiURml98l+HaB7LZPfJ/u4DBOmvANjHRHfEn6MAeTFdYZR +BG2ByAODxeBFCziXt4smMeFrhSL5kl6YVsLdehfk59T3eJYt0KiiXiZV+I+QHAT4MuQ4oZMpmo5e +H5fN+rmgmIzQrJ+YOlUJ7D4/q1qfrBIcR3P9t7wt49tg9My5zglmYDKVh/xrFqk0E6U/1xMjBPNs +WkCcBVOcRdJj1F0pUGeF6kV9wOtzmnvQZZdL8qnMOsGDKIkLyDdD6YUanM4LdmuBjiBSb5R/D6X3 +Fc/n+IdQn0guXCXEDgVjgIKGj8uDLpFQYk5DqlNS8gIpLSo5Jk62JHAx5ba5Exn0M2ct0A9Kp7o9 +hyC/FgktEwZqgkEKshQpunSyXvpwuPkmmTI5K8u8cGf2vbB+ub/D5pGJT9jQot5OaRwr48kiKqCq +QQeRTal6qJwYey67cRacmCbfKthaMlKNwIIq5k71bdGiZ4gs8LlJbAjRc2QzBfsQzQXcQua9DLio +0xkUyp9hfeHb8iiDTrNqLLahhXl2MmSZGt33omkMaKmQsUyiwmHrkH9mLMlgKghWs4yyvKJ8y1AG +Pl7u5+TKzE1ke8IY5DGcKuONmHlRRgpN9MJtn8FLMUkd3obX50EfswTF9xD2QmLQd8iThBhly4OY +MxZw7Dq9YMmrFRgWaH3goB0a/GE7C8ufoc+LDElg4X1WTV/GMSwxKZhYGXqnM9mzr0ICC5Inj8LY +VIOUT/GtJUwTnB02CiZjWEbcIt9QMKcYbjeAndiaXLnVLNKGn7rgPfJg2n+gcIiTOAHzCVaTDs7P +6gAG4YQL+Htv6xbGeOev6VX8xAUiMbjh7QH+z+YtcdYHM0AvH4XD22gHmJxg1Jtvsn/FpwvRC7NI +dWpgDScaJDF/YhsardocD9C1ccKWAE+hVGmWibd1QpG+mvjUBFPa11v4jQ66JQsZeg+W5tQjSot9 +m5HXICsz4nVrIhyw22UUQas0axdhLk7NMOG4RRqihwlL5u87YwB3QeqK7x2xxoT/dEu7xTgKzLDv +RPgPBvB536t4cgcW02zpQaQPbDPf+KIJqflhnGGAIQpbaM0+BpFoM0wqZzJD36kMcjaEx05pGFtu +NQjpT7mUYGrwMHQi7oPtwYoVDjy1zBGXidafnIUOkNiw6p3H4tuorzSseIB46GUQzrEHV0Ccp8MA +pzHgnN/mclKpZ/JhEP1jmaA2mRT5Rp9e1KZwYYMlnwdQmIkjff80tkILCzoLJbpoG+S3I+11k32g +524kv1mJyGGEI0CG6JJ0gLoDtuayNk40IjnOuuSGd2KB9HPZjv1C5a3RADCKDF5vegImZdz551rX +8JOukYBUZbuk0FnwrUns+Fa1waumeVhdJtu+gy/JdaQBSjo2T6tLiawXRXKsOheMO66Uq2QDFgeT +22huGBd1flfwBsbmRI12FZAuHDKeRlXE+AfYx65RwkuEL3aVU1bZJONaMxUZdQ7881BgcVnXy5Sb +hgsKo2RpFeHBVBDXl+HrExukd4V6SCBs2cqN2j2kTh/u2jl8M/xc19/h+0AkqVXzi3x8l+CUMGMA +rh6yHDcXwByGSVhIY1TAeUCflpke2OX0ULhtoqxvmloTBr7EpYNJbJYOfIZ0nrotBK4yLrm0JhM8 +jpwrt6xwX7/IjnDbC04/qimNiRaXuSUHriI8ZwlbD58HHtdYhPg6sCq3G+mMxKyGaUmzH8QTNqi9 +T6Yzw7iR98zw9nIEECULlGJ2s5J17DAkkZuls/ks0Afg6oEtJg+nS2gaAUMuCznnHrql8JARzish +TzGhw0m0KG/ou1Hdg8rO5VYQ9kLG2WWIdxgngIoK/jrDCsX2WmYwiY6IUrN+JVjtN/oC2dlzKXwv +xVuhNgsrB45IzEsB14RjVT35o7u+/LqEoLtIz3hUgogg7/d3Cjenr/FZO7jcq8OxfoVYF0Mnd/xM +pZJ9Kxxii5giZ3U+cCvi6HXi8FZZNZ84n+EMN2aC99IWoS9gy5wSWyycySCFZ0FWM/11eAf4aSy8 +UOos9t6KQmTAiKJWClFSgtDnFBixwQ+3lFSCJHthPBMYZ6wXKbcfIKWpXRhxw6VXRLbVTQCHYQcf +absL4NDtwFN8O/VgKhnb3rcdHLfUsOLOiG3IYIez2MFw6eSuTHWn9yIqu1KlPvlBP+ANRd2N5Bjw +tE7dUhlLDy1NhKg7lY0B9cLgueLBo3qsD3Zx8LIeHQzGwafIeR5OzwguBFvswU7BVZx7wgOcqmvd +mSy+Ct5558Lwn854U+XWou7I+/2VztRBIJQSwffhBaapGPKhFwHBAJEJiCX8r8u85LMQNHTaioxa +SSRYr+E7d8FFmuedLtuwBONMKWwyEKOgUXflcQvKSjijF3xFiNMeDhgw7hC7NLQWH62LZ5AfddOQ +4D30gQUmuUv6OPPMJS81gnqh6Qxw9Wc0hqgnEDnr+la1gP8/wxEQ+kk943oM9gAZQUwR9R1QPO3J +UIl66IMFdBtnRnhLctnoTqAQEmxoYYzTTdDiXFsD6dLQDk1BJ30GFwfXcr0PZzTa4/ohth5dAldu +OlCPRERv7CDhXNVE4IQiIVRSRAdFmZ/qLFGn6xdGP6qCi5cuiJorq3RFGNuIBpqryr2wTNJ2qNQ4 +gwIg58amevcLfLpnoZrLOVmgeaXCI6rV1Yigq/pC/eq0cWMAJxiJC6MBZ7opNF83LsSOksHChRr2 +B0x9hI7CTEmpY5zvqkoEGDN9UekT5o4Mch7tM9UqwrV96FBhPcmDySzcvkJMj6Zs2GEY7diFIeb2 +WupgJ8IYdpNOxInGDcP0Y4Awz6HumYmIC/sOW9etSJ00qAxubfJhQwQh3ShFgDFnSH63W3sZJzV2 +N28pEMBDw+KnGYx4HiNrYSkzlIdoVljUYJ3CFvuqt5slbsK92ubQBma+1Sx4BE3pqTLN3Sz9hJgF +yCKcAfgw7MDwGfTTtJ5fdy2AdNWIC59EBwaArRZnQJ1dMJ847WMJd0eSqadDKhwiKYtKMISy6o6T +uLD6W/xh9Uzz1no6hue+nPoJ7vPZfis9Qz4j4TmKSXP3Uju57oPyNTAPVaxS+LHa5Qx/V113d4kF +bYTrbEtE5mJzYgsfXNBj+Opawg2fXlB4uP1iF5hzsN0s4UKMXRVexth54Y1st2h4LWMvV8embffq +/2zYQvWTOv+onlRnMeFwbVhR9cs6ywrXbbC1cPG2/C9cwcEo3VnsrDRcyi3LDc9z8OZwThv3Dhd2 +y+TD1R3SwJ3hLi/CZR5y5arxrLv8CQd8yKlv9AXmqA+B5q78kHnh8W+FYwQGQopG7CAkbcQYWpEc +sYiQ3RGuCPlezzSKQD3tGoMHSEKpiDhKq31EuCXUlAjI7J1Zqzyr06YaRQwotKeIFQ== + + + tWpWxJTqhR52Cp2txqca5U6DWK4BRowrlMSIhbXaZMTMQu2MsFqophF+W2uwEaQLTTfieKENR7yv +1ZojLhjqdUQOQwWvIcZGV49QZCj1Eax0tT9imq15ELFPNyMiOhqWhgdRW4skYq1hung0NqybCNq2 +ZlDEdt1ciuhvWFQRJV4bXhFLDvssws1hw0VYujX2InwdVmFEuN1wjEB4a2DW69wSjZh6WKsRe2/N +2ojRh/lb4/huIdeAf2NKj5A7mOqwuTkOiiS3y8GCdToaA36E4jENc7X0RZqcy+Zbqjdggn1Ks7Nx +G8jV58CKqv4FigM16c0HMYro5DYJZ4V9q/A7LqF7NcbZxFu4P5RVLpMKoPCTTFSwoSaaK2WSd1FV +aTwu9TL3zNRHufemvtPdPM/awbk/qH6FO440Ruqfq+6lOh/uf6oT1ziq6gy7RytWwZ1esVqNbyxW +1V1odeHdy3aYEsJXMtHmdz7BxnPeL/8M/9pLt0F5cc2LPymxpmtTakakQsJQM2rSjBohANUURKCN +kHMjaqu5tCIxeops4VozWaOf0TUTBil02K8uRI4bZIU8i96LEZ7alFsCrlchYwqpBvEg5JLCfqpv +9DNGvz60uDCGDxmEJM2Dz3ykkvuo5HNV9WUCZ1rjizLxLzani9r51ZKCX3ep/4bCzivUKDu4bNQI +z+pBccbe+CyMI56GI4Ep0/KohQaAEBqTruvDZdnHFO42EbiFNnq90IdfH7b9zmePBHISgaDzxJp1 +wGWU53Gqe2+Qac8jDGDfn3AaDfSdNhsZqcEZka84jazighhWcAXkAE9T2mzk1XXGY+qznA3Vlzb8 +qo4uLowvcOa3/shHxnEi4/D9Oqt1/kVzNiNWN6/YRh5VgYoTSJzAFS3bqJfZfq0P8g1s73vW8inI +EpQ0VF5gFRvBpyYx6CKEW3mLX+afEw/afN8jv7ibLmDKJwbdGkUjzWa821ka1kgh6WEpIu8eXq9M +400Wgzqf6gsdgv69Xqi2KqJnGnQczGHWd1pFsVHk5VYL0HlqGaQP2gT1yIyBiIDrSw1EUeQ5QrvV +B4MSEljAODPTIITtCT+aGt+DmiJIE7A7e4tgIJNHnY+iyGckW6GOiCHwxYMGSInqIwIj3E298HCb +QNkFfQ70IJZRuVel4xGelGWpso+O7Hqh6Fk0xuJZVnG0eec8mhsqBgeHC30b8QGIDOm41l+K0wNj +Uj4jg6hyHV9hk4ZnMTWinV3cybyNWIZh9kopXypEqbTko1nTAUYm3Iex+AN8S3TROIHEMBpCYiCJ +KZNOcajL0SCPEeXAlKKumlwWftleFk/qkcIxrD4cmseweHAkRgb1g4krMXrEemdEW+MzG1Oqzgek +WbHsGZ0zlAT1zI/1yUXgFek6dquNRay80s26fLpOHSJ8kHy+oMugvmS70RYe/kcQXaUNoWmNDTsN +yc7il9mNSmoLKm3ItI0YEcRtihRRGDeVynv5mnqVkX99jm+T9nWxn3xYsed85L41m++rO9jnoe5y +n6vKDpo5rXzDJ7/yFl+gyoRaozi4lS955WhOFnUcDf1UHul0dshGt9z22TH2vlfwc8je7y3tgfOk +ZEIgdGfxjycTKvBm1Ljhj3N8i9bS/MOqhPm1SMx/8kePc3NsbgaWlaIQ1Qs7Vb9EBvIoXBOVoplp +lyMURARfwd1nKPOjyI1uKoyrdVFqOyVWc9XQILKJWF0qZzRz0mOWKctGXipLhk6KYHS2Ckzw99zN +0DqzpefSKcoKVgQInLFOsDgwErkuITgOOTB7ESfL/chr+dIibGL0AsGB5YDCIlLBrUhYmrz2FTWk +4AXDOImE7zMLeleZamOxW5H6gmpaFqYyhoWclgHRbk80SaI2lHFapTn0Ppg5a/oJ/XGIn6KWE2km +SUuGF/U+6o0IQ6Bsmdcx/VXGrbWvyHRmPsDBkl5VIrqrLDHRVdmdLcQBXNg36ElsASF+1Akj92yH +bSksQ9efPUF6UCf60ZNh0HDtE/tdIhezyu1pge4Av77WJOKahM6RcltCFig+6Y5HgDOjRrtHbbTW +BNYh9Mj7WO4dAQzWXgTH5TuNgI/oUJA6zB+qKvG+2f7tKUvco5WTDVvG2XHdn6sUFk0AmnVjz3ST +7lI4LFinAZViUd9kN9FwnLS6Hv6Rbgn9lTHrRZVTWZ9CtYeJMNBLRYkoNBiYAwsdFw+1Oye9gXou +0uFhm6qpkYrXgTDQiEEMJUorcJlGUdxpgvB912lO5rjwlW5WZK02DquCxQ+r6zr/znhWr3r49qWd +WRE2NkSK1cvroxeON8wc7for4R4eTZvX2UDWN7PQYsaEZfc6h83UIuOXobhYA1RwMxlJVwnsWSvh +106e1VWzhiHqk2QPMgGpvrK3PIeQCTo2Km6AE4jxQ3nDfq3fKQpgGaPaIiYEyh2zzmPK5EJKtzq3 +vYXf6txyEZCvsNCZ6gvVwQubVw4XKMndPKwyXnTl64VOHfVhTkabtzq11eE5RdZPcMptvzVIPCYl +tkFMXOyXZobrxvKlWG09W67tDq2uu6Oa1Q6kyPe++vRHz798/vTt88/AjbbcZ6kcghXLiVBdDJSu +wRYggylsA2wBWGeBswDACjUbGpwFnNbEGsdZgHDk7wNnQf6zbIUGZwHSXYMljrMA4A25PVWcBT6s +MGS8xllIZVKvWeAspDJoprLDLCRAV8ACaVAWMJSBQRxHWUjDoIkeDrKQELHm9DQoCwkReiajOspC +wpBmlqIZykKa4NWfWpAFMXIsyukgC7hxHAEw4ZAKafDwdgOygG/omKPkIAu41dIHDGQhoTqBw21Q +FtJgpB4oC0TdoPHpKAuHhHCiPnO8dP5UrYYwC6OhLAhBPFGMgsEwCqBjTDOqaDr5VoVZyJ2rNAPA +Ocl4n4imli1utvOIsRsSMspkeZOwFYN3UZVCcRZ6w1ko+yOYkZ7UjYazAFZ4+bARCA0XrcowoIU0 +/uNTad4baeEQ/wjZbcqN1vhHSI7T0gwHQEpISFTnuQEgMbuNnGOFf4Q8NUVFcgAkpLKRJwUAEjIH +mbfRACAxw43FFQ6AhFfSSmgBkGDLJe5cB0A6+IYKgISdyV+1AEiwzWh3BABSgsIAD1kAICGESPyl +FgApMcW3DBUAKTGeAB7rAEiINXKILQAScYRgEQUAEnMG4SkJXCPkKVri6hoAiQuC6VxdOGuWtQMg +YV4gV1ubCs+zCTD8I4RjKUwc/ggpgzQlWvgjMHadI4c/6pE9kvIK/qgXS1T9ig38EXKLyI0d/giy +oyATMuCPQBYFzLyFP8IQkAgV6EcwLoXop4p+dLikVdjjhbpmja8A+VrCXaqrAGlYHXKNw1WAL7EE +0JWrACKamXzhK0Aa1jxgmt1XwLw4RcRa+wr6AanVoCz3FVDygqGErwCisiCJr/EVcEOp88F8BbiT +PsHwFSDjispo6yvoXaqFr0DTHUEm7ivo4bpOZdz4Cpg4xlvdV8BVhAM6fAW4VX0Wja9Ac5ttMPAV +QIVhiYH7CkBLg+6uta8AW32mH8B9BUihY1lD+AoOl/Q9fAWnghcd+grUyu4bK3uB8wf++K2rgBeh +FdLZk7zIJtYEzaOP0PpmbMMRPnTDLzpwFtwzhNZX8MAh6CM+sK/gt8o3+WtyFexhF/VzJCSssYvI +7POwKjBNjGsh6c1qUClToD82largDpCwXs4KETSMaYiCV3BV1g80dbFxmZfPQqJpmrkV2GI3drii +qcPFfQayouFAMGXyPC/opUSAfdbU/YK7QgB5dTC+jlLQyocpujSBeFVkTPGFf3ktMpgIEQK8Whmm +RoF7tilqJpuCZeq1z0mURlo4Xh2N+RbjoG+LqKFVdB1gcrTUWsxHLYXwWmykxnOW2pJtypCiaYvI +7cVzuOW99BvZT5o2vCoQh7DVgJrVkYNX4navM1eZOpRNPXpwWq9bB0ul0uSV7T3/UlJbAI/H0xvh +dfLg/xQdXklP6QJ9oa24hzHG3GyvzIfluIws29DafTyaxRVNiT/GpYvqlyGwOBOwxgx+P9EgCtSz +qrIhn511Q/5vFKZANDbYBZwWUK5DHCBXG7TlGAj+7wYpwU86ngL1SZ4wxAW8nKy3AWbAB3OGHb8B +tQ8LOJcBPDDfO8+5hYFgJYX6qLzuqVgxpeFJYOm4SA14EY13ZHobOAXEL/00DXgR5o31GY50wUEU +4gsqFgbS2hT6aw2ZgTw56hKOrAGmUhAbMOiNBP8e9nQD0EHWg6pix/HAJmfswZE+oEHRO9MAgoCz +ZJCR44ZAniPC68AiUD60AG4FP4IxmA5CjBI8e0DM1UFM8G1ESW2gTjDB/Qq8iKUriNA6ZAqIFAy0 +AVbBarL20vFX8HDKKEdoSY512gC5KPMbc+C9sE4JGc6OCEO1BnZsAxxDvwiIzOBloCCyVMbxZ+js +YBB9DVMDRwZDO45m0yPMhQa7jneD4hIqhQ0sDmmag1fwHN5GJc3QdbDjrdg3IHio78LB5zg9odw6 +kk8/OCDUGvCnpxtpGBwWSKtpZMEcNyhONPBCcVaHQJ+N5vAop1GU4HF0ECN4byiI4gI4Dxj71gf4 +P9u3+NkYTAHYpLzWR4u9RPCS9puM+OLTQbuI9cXkIF9GHVx1BlFPRZL1aYZPHCd8HVDeAPHSrpbc +xhK3WFT8WnZjrDrEHMa8IQ6tRAsSAvAAv8xoDJWBxAVcUyIS75Ea4fRKZlrRuGDTdSKIGqqfs864 +7w34lFlT6LuH7t5Fcc1WmwwDwNT6VgR2LMtDba9SeqVxA0e2WNjWQctEduXgCmTSY8s5wNohNgIc +LaNvVXCfqSOP2yCs6ZQEDtug2R4B1AamLq9p0dzE8IWOY0xzslI2Z6rUBTa4cQsr84I9965vBANH +HitxDNZQRVAd6TlwaYB0FnjkG6iiZdZSYJcsnqnooofvnjbySVauJ5qKSTExtVlWEWIuJS0Na6Uh +MlW6ivfXQ7MhJJ9LVT/Ryl4/GxIagghiLkS4rBnVtFbSIy+4ohJhOsisDv7dKBV+NnQPxClyXmkn +KIIbUSHYKDFwbsKnE5fBRz8rLqRqQ1bZtlGaUlEPRChXMMKwSqF+dYNObqulYa/ACg5lDpMCQznU +PUSryFpatbAfdBZdfYRmgw929RLKKTwdjRIqE5tKBdlcrGDQFFmouepTaPRd1zNcLUZGBPxOpjbP +Vl/d6Naiy/LJgU806mcGPFHRbdIo8kOnKdgBTjRpDDGgTEXpymljNYxFq4scFHVUx5WbHqStDSyR +sDV+nRsxU2HEKPBZixZqN6bQNOnUuMEEHzTMMreoRND3Wzgiv6biyorUWar1xu+YywaeVgYjykgY +gvIhXMcwFcE21I3aFD/B0cKMQC+SwttLrkBEwK/upi0OkT4zYIj6c82As5KtbFGYDQYRqiEZNrQS +MHLlwSrEkFNDb3CDPzSOHoF0+CG4EpGB36IP9Z6VZ+Vr1EXBirzCrWsje/F7xxzyBw== + + + BOSQv6dBHIrheGlejLrBG7IPq2hD/uVeDBgT1GIN2TRWpCFbugAassVoyxRtxaKaMZbUCx7r0jeV +kUEiUUFpNFSLLI3SNsWYRo9RtOkEG3WdRtVt+WdcZVWivjVqHaltoLbe1HZZlKX6LozKVduqbXmr +7uZaBGu7PcpkjSVsQIWMcUTVrXOWCilk/GeDKGRcKsp8nY15IbDzurZe2BmilxU7w4zC48pYmwpl +Z79RyWzsOWqdnYe3NdHO6aN2OmRB1FdXobGuww7ZEuXaIX6ipDvEVFv7HeIsisRD4nkdeQjGptY8 +5GcUpYeIjcL1EMVthXuI7NWFJtWjXH51Zl1XvzptBfiuRaxOmLLRFvOHUhJV/6G3BDBAPdMgCNTT +DjXgmlKgEYRC1cIWhOIV+AahmgUGgilwLVSCa3kBqeBqYIAuhLbYogiFUukoDqF7tihCoaM6KoTp +sIEaYXpuCy7hynBAUKiqXDEqTKHeYFmY2l0hLyyNxTExTHffQGeofl+Bg1z/DxAOMxJarA6zIwLR +w+0MB/0Ia6QBBwmbxTBEwqgJmJEwflo8kjCSArjEzajANnFjq8VAMYssgFLcYgsslTDsWtCVsP8C +ncUtRMdvCTuyxXlxczPwYMIgDcyYMFxbcJmwbwOFpprAjlMThnILZxMGdcDehM3tyDhhmrf4OWHB +B9BONf0djKeeaVB76mkfS3gVVkE+8zu0WEHhn6gXhlsjHhZn2rfG6Rieu0zqJ7hrZfutniflc+JO +mjpt7srZzG+4fGIh3ClUF8udR5tVdSdTXX73Q1UScX/VhpTcrxUk546vSpTuINtQrzvSgszD1xY7 +IXxy7YYJ311srHDvxd5zL+Bmj7qzsG5mdyfadq9Ox4YrVOekc4/qvnQGE17Ohg2FL9SZVXhLg5+F +V7Vle+F9De4YDlrnn+HHbdlsuHuDHYdH2Ph1+I1brh7+5WD+4YJ26RCe6hYzKBzaIW3c791iBoV/ +vIovd6GHhAtXeysJwyMfAjOc9lWounN/I309CFDFtIUJqiD3E63A97OhGHhQoioPHrzYaBke46jq +iEdB9s40qk097TqQB16qnuQBmo1C5YGceqHHeqp2FkGhVo3z4FFoex5eqgqhh6E2mqOHq6qK6RGt +qoZG6KtRVy1AFlpthNCq5muRtlZBjoBcKNIRsgtVu8b2GpU8YoChu0eU0LX7CCa2RkAEHd1WiLBk +WBMRvmytjghzhnUSkdAwYCJi2ho6EVh1e8gjr2EwRYB2bVZFGDdsr4j0hnkWEeHWiovIcVh7EVx2 +ezBi0K3ZWK9z69Kj2WF/RtC7tVMjOB72bA2gu8lbI+2NaQzZOyHFJWxoDoNCyc1sMmHORmONJ9bK +Dqla7YkeIbAeN+wT3EGKe7C2/5HvOk15BUpMgaA2urkSwHS1zV8DGoQFpB/CHRNM9FlWiMnklBiK +tiNzP0eiUl3BlxOkOJHh1u6SuMrdKfVB7nGJFzZ4QTEu99/U8TdwQfGh6gyqM+G+ojpljU+pzq37 +nmL+3TkV69S4sGI93dFVl9w9YYdZGHzlY93+iXBB2PMN+JRlTnZeF2GIGUjMMwwNQ9UANSQyxQZ+ +A8p0JvxtXFh6w4h0LI9EHr/F4FhdZ9gg9VmOH1Jf2gCN1NHFhfEFjlpy8KWPhHIS8Edv0I4tYFA9 +azA/1ZpSIKD4d4sXdHiZIUqvHhRn1sg99bRD/EDWZOr+DgNUH97gBUGvmWYjAbvQRl+ftfnIZ4/E +cQpxIFBH1XHNPQA3rFgQDtY1GzB04HnBidT3m108YINOKzQwlHksIJIACxoV06Ut64qrvFLNnxOA +Zf66DbCZjcrPxrid6W2/7pFjnMgxfKuuoYLirCP8xG51DKA40UAF7Vyme7U+x/buGrgnThq8z4oH +qDVR+dMaJ2jFU/wy/5Z40ObjHjnF3UQB631c4Xt94V4DNdftbM/a9qmvoC2wvEeaaw26C2zoniaa +o8DA0LE4oSHFwNDt0xbuE54qi7B5ChdK1qJgloKBVuUyb3Bs6lgc8Aa3Kk6qY+KovQ1PSwOegyeO +a5QgWESsZQ0gHhTEaUCgQezBaXW1O7IPbSQnXsU4CypuUIJwWts31At78wPVh/XalnvzVuT+0PkU +wwMwNx0a8QkI/OjImk/NXroXc4IiMn2HzxvKJ4hO304w7hhW64A+3/QjxFolmC4OpFoXVQbP+tO6 ++PIqdYAEgcQoWkpip/J5TXLEghmqfIFrXz3+a9SVw8viSY7fUl/ZAL3UsTkiTB2/o8bUD22MqDoj +jkPjc+ZINXVqG0ibOhTHvqnr5Pg4saANjk4svKPtVNpwQJ5KRA1yT1CbI/wEQToGUBDuGiko6Duu +8i0Qz4mt0r4v9lQMzLZdDN13Z/uFsYtjJmKnx2wFS2inNXhHzH/wl1gh50PtSga/iiUPnhZkEcNo +6Se4ZBDaASPdsNtnx9j7rxknaAEAMPzHjzhBjzhBH1LFbEE7sMWmacob9WLsDGBP8SDgMtVuOI4Y +oVX7FDBraImedeDEjjMMip7mRV9hKliUx/jVGs6CRe1MKnTYC/rEK2YHImvG39fwGbjKnJhmvUAF +NaA+w+KoQn6N2QGNltWWq+uyf2U8q2ji5Pal2SS6j623lkUxeLgy2Qmi+Uh4aNjIKCaD5XplWM1X +ASDEPG8nFjHWZJnSugIIQjAHwNYIFZ+sRl5bW6urDASiPsmBIuorG0SJOjaHnqjjd3iK+p0NjkWd +EAe8qFPWB1KAz22DnlEXwWE26kI5FEdd0Aazo658vdCpoz7MyWjzViO2GF3QY3xB0G37qU7fMSWx +BWLaYq+08xubKhaibjtfrO32rCb0rxGyoyJPDaP6BjZgYgo8sazAxNiSAf16A0wMSZqBDxFoYpPM +VkaftkATQ7yNLaYCTYyqRsW5cTSxEeUKaQUmNmZrZRxgYuPSvNPRxJAHo1CZjiaGRmGEzQ00saGs +u78GmtgQtzqaGDQLwu0EmtiIgL3DWVQ0MSglI7JuAk0MhaUEcAw0MWB0REF4RRNDzgCRlwNODLqR +9ltzPDGkAKUYcOCJ4cJhnld4YswCwmIdrOpVFTbviCfGBnZIjgAaRJ46tH2jNrWFEztAE9vF4Zrz +oO0ZGzAxwKrBvcmo8fEHjGdPCuAuhRDLtMUS20KJ7b8e5lgRKr58h9fzATKzQuon1wZ/6wny/UTx +FUH+nR+L7vDq87NvXV5ePHv29Rc/ev32KS62zXoiPsexBfkHUUZ8CMyBnnG06jJshgqrDYASgGGT +KaP0A8Y4tLmcHNoVcEAwlTNM6z769OVJ70zWa7sYviwfBRwN9MbTdsLdvALswe5izC/DzGEjORiO +2JNZ2L7cMCsyBwBACQyTkfvErXrwERWaA71Cs7KsWdPnDVQ+aZpJYk4C+6lPGlInE2TbVQR1uN/R +ba4PeKrIDUJSYY+WhfAX9wQnQpUPSj6TgdcA12dM0bAVZvqYyNryjGbcyKSD+YpnEf8wWxNKiogx +3on1ILeP65ydIspOZGDY51iPljsNRLvB9wN6CQwazULZ9ggfOuBEsRoZFPAnCA71hsNM5BTNyRox +o4doRogcTf/QtRHSitw0d5Dpw1x5ONMZkAXUAYoR6E5kpuhilICYBqAIJNMn5IEjyKwvFTGtoVzg +EvfAq4R5ywA+3OPo73u4pFWo7xXKR0cX2c7n0zz3hqznzYEy6nHgRIoGQlm0GTpbo9NQFhZF4CrN +8PSWRBlaGXvkedsi3IpHeXejLATAjsF6Y1yWZ5W00Skpoz9u19eOStgH/eRqUrRewsZC5qk3Z8oZ +GWr9XHs4ZXQKXQLb15s9ZeBrAOUo+kFlrzCIxlEZgffBu4BZf6ncoXkhOmt5C6rcGXF6q6q0WANe +faW3tMLpHiUC3vQqdwAUwWd7d6yM5BBk+eorvYsWvqqfOZHWaSvDxYIqaO/IlZFuUGJmvXVXRoYQ +G/l4e69ckOvdTbUPWAaSFpiY3WoNw7jsbFPoTcXw0oGttaz3WMa0I79E7/QeZXkY/U7rY4ZFSKDW +aHiGYQxTtPPyzmgZSab4DO2clofemg96f7UM9agupzdiA+l1SO2IZm05WV5cdHWLMzq53v5tdaG1 +iMvIlkElSz2D5Bdk3NitcRqWgzXJY77U6ox1sMvgJ6Ons3qnO1C8WDtj7ZGXWS7azaszdLZGF7o4 +3c/KXKIFH4XJONVWfZnlB4sXXXpPv8zcR/Su8r5/mWkaQKfwBoHYeGP2ikhvJAiZk9lZynsN5r7z +qk9rSggBNoiGXOeIzQsz2ssi1Se6HOLWZRm865U1Q0yLtRePfokZMErs1OeNFXGGc6Sv8P6LuQO6 +3aTN0ZiJk5EEzqaE0cwRnsa+7yvLYp9apPfqndYWMjGbBu23vH8kzswBtlUbTaKHxcy6R29GiezH +EQ2YomnlJDsdkVK71btbzoiookIyOmDOyKDMadUqEzl+UMiNE3hLTQJigmVE202AVaJDcPTn5Efl ++NRo5MmCSW1TybgBZpwCzluCQo6FqIzOobhshkES3UX5Ata4ehtSPmqK0Xq/UshBZgFFS1Nh2rah +vfcpREJdmGiSmpELz3aF3kg1o6ExKomi4yr457R6qzZmRcosJ9cat04mMaO9K9FIa0tJbwO7dNqm +W9vEJiYsl6F2k83oW5PrQK3tLLg/lcLamnYRJYolU3FmLuv+l3HaR1Ib4oZBG72W0Bh5jt4P0WK3 +Wr7ehjceFmeat9bTPrxo/hufEF2Ct9/qZBqTEh2HfdaiM3Ezu7WFsa9CbXPs6xT9kNvljMbJse7R +XDloI7owb4jIuzUHtUVH50qR3vq5Jd3oER00Hn2kYx/UhtPNhonO1LGvavdq23rR5brdorUdtu/l +2jHb93ttrd0whmjB7Qykdul2JlO7eTfcqLb9drZVW4M7a4se4i0PjGbjwSyjH3kw1Nq4vGG80eE8 +OHT0QA8uHs3SW3YfXdVDLkTj9ZAd0aE9ZIxNsHVyD2EULd9Dan2j77De8CHeon98iMBoNN+KyuhI +HzI1utaH3I329q2AHmAAlWUMQT5AByO7dFlfzzRKQT3t2gOsErpQQ8Ng2xQql40mgrEo7IirLJil +cf/EWvuJs64lgao1lcQ1KXy5IVCsVS68kpns9UKk2CMdPfQ3uNnYaLNV9ETnUF9baIQwyHQFXWUc +gMjA+W50SwxPLWxXQsNhFooqbTmwr1ajxXcwSzo0X5iL/HhXjgeEXJHe22rRA5CFScOubuPCDv3R +QiUHDaoca3T3wRQiV/Fh+E+FGTZmBQxwf2Vo9425MMDFzze4XTEgo54QgGZ6FIRymWvfmCgFSYEo +JgpTRqwOhRgJcweMhXc0VhGsT7ocw3oCc2BVSFhYykGnaWOKwcWwdFDW3GaDLyHcKpAVPVw6uWyM +P3gidN7MSMR99POFHQmHAPWl1uCsF6pdCm7UJyyeW674ykQ9ZW3h4it7AiuZJUxPBQ== + + + V92t5WEwzM8wq+2NkyKs5snB0TEGCqcB/gW4qpHo3WFUiJKn0QEDRmUROJtKD7ApAFWAAcIrCfur +wFIdiR81K2SNLuds7DATYBp8kVKBcDyjaQn9ovUOGG/Jaaz8mSC0mYjS0BKQGYpdw08F51H4AJQT +0SsI5RFB8jJZeVum5AaMCnBUUMGQJ7Ry6m1X1Qvp1QD4UzwMLY3YIyreOi9E1XnWjm7pTJ2Iz0Dz +3SWZs6t+L2u2gKUUc4JIArZfnTy8NHnxRJ1lqGDgerESBUC7FAq+YoUZKZNvBl/aAuXWPVq6/KKL +0ZNT6YTVU+HnD4KCV4EzYDSHyDExwZ00C9Jm5kDfdxIu8OFlKixG5LhzHFeboQBsZPD6h3odFOcR +sWnfWAWcJq13YEF4bUgrpx83akF5BsSp7+WSOlPNfNMXDDuFQujcoSDNM2HzOgcpqBtZqLAYpynM +g/FyrGBJBcG0XszBYFsi8rGdg7sVwhIs/qHOBXF6IQiPMcoCFtvPK45aRGMkK9ZXOuvFZwHr+8yZ +M6ayy+gCE0wcgCRTTK5ze1DIxC3oEqH0UO2FUkN0FIgO6EomOlTEcOEndtQxKVS6pPBVVVwJsVLJ +M3Hlcg1Uz1td9mEVZvancyGJYaz6Rrg0LSzLoiA2iVtQyzlQkXDRvCCtJ97qMpwfRn+vy/nCmqF5 +qgpBnHnmopmaQ73QlAtMCUt16olRPaCNDlKgPLKdgmsz9YyrPYWNC0IBdf0IVK86o+tQhdgAQFeK +M9yV87JRtkAkhN8Pxa1gKVFnHxoeaJc7IhQJnXU2CYCe7uoizgxsAOh6ZUGdHGKYV26RUAEtCAmg +c5LrqEUUHwqGUGYLQtZ9qFuu9RaAclDrdfW4sOGAkJ5yS9ejC1wDtBlc15a9oGheoZQXVLcBoco4 +smnvOM1tHhp+GYoJYzcFygitt/ItWgxlsMTvsCpwhnBbYX7gDGMbdqvZKQURTrI8t2UK4qpUXd3o +EQrX5MerKhfAoaesep4bUAULV+xDaWiVEbuyOKm6RVYQKSXPcKutjMUix27e8Zt8Z7kRWBA5RZ8r +txMx2/Oc52pQ4klzyqGtmOWJC9MM6nLrlC+g7uBmLB8WYG5h74LDCbvTBikqm1DFxSly45liAQZ2 +uBhoZWPHMbMzLPGSF438hMlehqSYWKHf07Yv42iz6/Z/wV8IEuSOgoJeF2VaRfTpUCgoryxLjd/j +w9jwIZwTBVx51YDTPnSw7ex+jjL2WutYz0y9Bppah0iMJLwrBbhRXJlol4vqaMBp2VvNXxMXhk8n +HlbPNG+tp2N47kmqn+Aup/ZL6ZeK6QjHlc+Y+7faiTUvWMy/eclihcKZ1i5leN3qmrtnLugiXHhb +AjJfX1Ba+AODGsNx2JJteBiDvsMLGXvAnJXtVgmfZuypcHv6tgv36Hpzhhc19nB4WmOfh0u2ZQjh +uw3OEf7dYC7hCG65UHiMg12FVzlYWrifW94Xfupgku7KDj4aLu81uw3PeHDl8J4H5w43e8viwx8f +ssBd9iEuwrUfcuWqiQGEAIpgQUiqb/QVFlUIkeaBBxd6EZ9ohWMEMkKKRrAjJG1ERVqRHNGTkN0R +YQn5Xs80ikA97RqDh3VCqYjwT6t9RJwo1JSIJe2caVSe1WlTjSKCFdpThLpaNStiYvVCj5uFzlYD +bI1yp2G4UAEjThdqYgT0Wn0yIn+heNbooCunEUVslNiINoa2GxHJ0IgjdNlqzhHjDBU74qChhteA +aaOvR2A1FPsIvobuH1Ha1kiIcG5YExHxdYPDA8OtXRIBZDNfPMIc9k0EoltDKCLWYTFFVDusqgh/ +t+ZXxMnDTotIuptyEXFvTb6IzIdtGNH7sB8jzN8amvVCM0gjYSBs1sgsaI3bSEEII7imKbidXPMZ +GoN69Fy3sLw5DMolt87Bh3U2GjN+hOqB1Myw98dlPpf9t1SfwAQblR6zxnkwopUGUbDdy0ChQMPe +PREjoIQgT8JlYd+arbDOfRvjbGg77gNRXonubwrwab6Sifo17DL3p0x50eLq1vFSL3QPTX2Ye3Hq +S93d86wdnfuF6me4A0nDufG97mmqc+LeqDp5jduqzrL7t2IlwgcWS9b4ymJpw6dWl9/9bod5L3zp +Y6ngidAE42iNwoKmNG8IahJj8xM4KDgKlBquLrY5ZPdkrfL8hK7ZjHowAHv6ZWjhiNQIoAmJ8jGC +QcPp2tBwvQogGqxm9ucAiJY5CvE+P2Mk7OOKC+vYF6XDw498JJKTioxprs20ydG5MFlW2eq0SASa +dW5QyQa12HecGXmJGmc71xkCY31UnLBXPgs7iacnQGZZk1X2Bi1wYNHVEk+f0OkqStcXYEbCVK8X ++vjrw7Yf+uyRQk6ikFQ2rAO+I8KExPYbgH0KZTG2KHxHA2NazV4eOsOZidOFvU7hEnXGIGLifJrS +di+vLlQ+U59ljKi+c82v6tj8sjp843zNJz4yjhMZh21XZDDAHP2iPbskFqTWfJhlVDVqdWbhJS3f +WF1nG7Y+yk/YG581nCrNaK6QxrPgBmI7qpFRH45Mit7rZIO/rC6Mj4qHbT7zkWvcTR6w7LWBSKtu +oCyNaWN+mpY2GkzkmRiB6gjLTJLFekyBi94hVNvrhWq7wjbSQGRRFxpQv5nJ3Gr1cqfF7DzxDfA4 +bDCCvBv6HRA5Z64u3Kq9I/rXsSC1h64CoG7BOMxwIsKzpsb4QLtkiS7BI/o4MoTNTCQ6I0WrR3/B +DLRqbXWuGSdLt1Kj0fVZXfJdUkseBMqy69LJ2NBUsApAFCaMEefGFqGLNS7EREzrZ1n/0M07UfgE +t5QPDTlFzIeNwSNKpKNafyVOE+I8ZmPAMvIFNmF4FoFg2pkdCDXWjXUJhtmLK3yZELEinF27nqjH +IrCprzuKwFi+HqQRo2hIiDEl+POC1pDKrxk9To8Dm450K9vLgjEHF8bDYL3P/erTp0Gfbi/1wVEH +QaJLjB+uZbC0+M7GoKoTQjDNQZ3jOmlwWi7zuJpdwtR6E84Yymgdc+pCoWSM6Xi+ojC66Fu2O33p +6cOdtOO8EsfYabTYaQjlG/26BT2LC4asiT9BjRl+HSa3OdkiPaMbIvXK6Xt1oe2B1cN8s7QvjT1l +Y6vbzofv27P9zLqNfT7qVvc5qzyhmdvKPHwRKoPxhaqcqDWRg2PZylem5sRRh9FQUWWTTm07rPSA +5z47xuU/KFzBmFdwBfIP1MBlbY87TUhaw/Q/4hU84hW899wg2YTpe4O551Tb7OCqgkkAXBTAgiPX +hEh0yCgjrCjOaFVdWtQBZoYI8EnhoYKPHU5s2BeENEHS2tBbWkrnNROrbI0uKRJ1Ru04uu6UZdA7 +kFrJ7KeCSCBEHnIy6a81GwYJjnBiE/U0wdgpJgF6y3BFGDAjJo4z3RzWT68gtUgd1DD9XLT3Fp+F +VikFTXGZ9okwj9+IsjcybQQE0TMItjPxTJGAKUIGcTD6aJHyOEcJJIJhjPBhclnJiBu7JWlpDJPY +kXPFsHycsXfKiDQFDqEA5BtN1os5E+8FLvVJQRjAdOtXohXUkjVvk5DDQ9dr2JSZf/10dkAJV5X0 +7qpevr8d/GrzCN9HMI7wCN7mOGVE5/qzCWwtA8QYRfzQVeB2B/PTaJqcklnuFQ3NWhyLMEDTBSA1 +JyaSEY2/vV/MnGzh1idlJtWW6G+M3Aw6vOFtJ1rz4cuhO3XoNYOcepGU3tz4lJfL/YiNTYn3TwoO +9EE7Gx+b39+eiuT7KeSBoCoIzVENai0hBhahVU0e+CVq0qIOTjrzofQk9EOHU4QN40Lp0Rq5udey +5MV6t2VkZ5ABwqhGJB4qMre73TkprggVYOabi2Gr+hL8sF7MQhB1PJ1B/MhfsICM+V3QmQAyHuEN +gFFU7W4B1EW38spZ00C/rvPv9Cf1Cja2faOBmNehIc9UfcU+fOEUoib32+8EQxppEPiEgKUwd93n +jJUZmMR2bpERwqrQWAT8PpdSF2pgjcy89UytLpysijkeBlwuOMNXb7XEibC/dHTsH4+8xPgCdFZi +jXF8quiOY3SLrHMCxZA57jFvU9K8pDrBSDaYp2k1wVyI0Xxuda3GsfX3Qr9mvUck0Ojax3VOHfVR +Tkabdzq91cE5TdYPcOJtvzSoPKYkNkJMW90x6/mtW8sXYrX9bLEOtmn1AP4awVVyrzh9qXPfGQpV +mHUN2JwOSTYoDlFwNKS5j6iuQ54FPhNMqvYfhHBkHBkYPswhwvoopn3vhuOo2UoACKppRpm9S9hp +YNDGPZnZTA7hnrOKWuvW1a1fCsgbjiUjRwULORgyAEGIWN47YsV4BjUQ3i4WF8p3ZSIn6bZAXglB +EZOl72TkgShSUdFkXvvU3m7NnVW08hMN116NLIIzTgqdy+wTvRVVBjoYMfT6rNoZc0kUJB9WVp40 +BgV8JMI22K2WLcwLRy0qXGa0hUDBQcfKpdWCnqiU/LohVSb0Np0yejACywCMZg2pAr40IBWjB+zD +8QfAtCsT4jzMJDgdU2X1fti9MHwv3+H9fIBwwR5JCI+YKr8OTBWkpCiEd8OT4GbUFgnBkxbrR1p5 +kjD8Mo7zlifBGtEGUc6TpuydQ5wpwfmhHe8apsQ0h6msmBKaqLF3dTCl2VqGbJgSxScb+DlTmuFA +sXcoU0JXU31rw5RwYdePK6YEqcgmMcGUYOkpw2iY0mKOvcqU0L+E2HHBlBhJGOcNU6JbVQdjTAlJ +OGyJ5zyJ6SwE3m54UumiP4vyJGSiyY4plScdrup7MKaqx7NOz/T4LV96csCYdrf1qJb1li/xbrHS +sWwLCmbhuTz2AKQPP8mYd81kM1tpy5jufn/Llx70fn3A3x9funtB/mGwJdExCB+b6ClfzPEDUURQ +RODrsNxP02qBcsSIQdG8WjYwZ2nzGP18ketfWFG+KAxboQfCHS6a3iv7vsvmlInmy8zLdUybjO7j +yDVmW06UZU5MeMPDRhZqdkwdNF8KEhwTS/g1oRr5fCUrpsbE5MHZ2pITOKqMcWevQFSdZk8Duk6r +32XfwImDseoMASGvTOGCsUamLDBnpjTacysUBdK/kbS7OIQCuGvvsEeouEtI2yR4EQwP3MpGIwkt +reD3IaYegq52Itw+7DMCGMCFhR7OUgHS1CPnWgapo2XpbIx2GrVJEwEEC3PstQOFPL/vWbCwJYT3 +9vs8CbepbB0gU0Gu7/i6ExH0sOtRSSCje6Lek0E0FrhPoPtMSNCkd2hGiBkMRRnakMCDmar3pJ9m +71y284hRzKqZychpmAAlB8VfmQq9P0IsT1hI109HRpC1D6AMAanW8qmXDxyCSFjAXaJT/DyxyWv+ +UE6g+yb7t4dbvb8b6ACeDuAVHewiOJsXwAKowYf2UcyJkwVW4AQ0ZkLnPlRvs9VpRnY2EdKI3e17 +FIADeqtcSG6haBsovMXDyqwwB4p21M8aHLVbB22xpv5ltjBHLjlxWRZw66IIdWBNPQ== + + + ALbxsoQOVYffURHqCG/B3wlPZEdEbYEEZqL4T4algA8xiKtR+3LRWcAm5NHqapkNOwaLAC2O2Byo +J8HjlSFmGx2YDQrdr3yq2XMZ9i6BWDFDTEccO+1RBlaqeEYQ7FFjztWY0/o6M0mZOpu5TgbcDmdH +9Vdx2vTTsX3wRf1ogGtIpuXyoJcyg8HYYovlkcAiDYuVWCmEHQB2O4rrE39TLCkyWWefMIPVJ4LN +pH8papHChCXWPxwKXE5ayEO0loLogDsLjv2BzTsR6M0M2GZNvTpczatmpVki0MpkCBHtpekyGWk1 +VFdDJjPRhtCBjUzGHWwyGjKZj6aZbSIZOKeYz0YgA5yG2Q4hkIGu1y8G5UaBzCctqbQCGfIoASvQ +BTJwebKigJhABiwfa3xagYyBaCm7SmSAIM5sg+wSGVfo/DQSGYBAA1xVIZEBBKu9kl0ipzJoWmMr +kYEPO6S0ksi4VRfKBLACQCKMsJbI+AZG0UMiJ3peMEEmkQFtq6NtJDLgYgvhaFQiJ6QuLJS/JpEP +yeADRWLuDT5rKGbqVSLLXrVwxmiiLENWz4UlCC6QhxKxmKmDNoYS9ydinKGbrHbX3TwioVRD0aLF +ckLWAKTmOh4DQaxdfZfdEQydxvhMIJcakTlxCPKM0TpdmECGofIhozK/JTHj37A8Zp0YvX2NPC45 +eYzV5HGh3T+NVR6jtgv2zEYeF3gS6FV2eVzQlFgRY00eo6xSMXMaeQzlLA9EqTV5zEJNwm808rgk +OL0Nzpby+PA7qjwuxAvA7xp5jIo+opaHPC5sV9v3VR6zdo8ytBHKqLdjZWYI5VI6tsp0mYyyVx1h +I5MxzKEKZBYiEQXHJS3K2wwdcy2RuR5Tbi40h0yIZEyK5QGtRTKeaF9vIhnrYZBjJpILMmsSP3wl +kllSxAkKkbyMljHkIhlCgzPWimS4fAhM6SIZ5Xds7RkiGf40A+lci2SsgYYpXCSjJo3INS6RD9ez +SuRw88QktM47uvSJ2OPOO8bXETUL5x3BfKqS6M47kADqOMN3Rx8/ygXDd8fcJ+97FK475mXNDPbl +FfoNdVp33SnFhU7rrjvAKs1p6qvrDq8YxqlU1x0iRNPgSV3husOgZqxluO4wJQuRgdx1h8ez2LJ1 +3YE+M2Fl3HXH7C90PgjXHV7fjV044Mx1h7dqdaW57hRdqFu57jKkf5fC6WeuO17I5XXfHUbHJTxc +1Pf23d0vWcN39mTrvXuy6/0S0hBWJEpD674TuSYUNKTWf3bwCNb/jzM6UeAZW//dk40D78gQkAgJ +Xe7yXYagj1DIlH90ovWDYrCHcYhm8UwKao3cfi6WiOpGLlp3F/ryw8j1bOXWyOWFS07VyOXD6LNz +IxetxplQ2Rq5aOyk6U9u5PazCqvWxkUDZKYVHXzFjonboyQRgfbWxEW0gsmtYeJqbIL6Q884CLX8 +1sTFXeR2YeLy8VD3w8btk0XIWxsXjn/COLqNi842LLcMG5dxm8lf6jbu6joPuxJrKq1s3DZkEDYu +hsteH2HjsvnLYqCBtHHRqmUs3v41jFy0TklqeJqRyx5eM1PRzMrtwcDdCAkjVySiFfy5kcsuYZnK +lBm56KMyzF5oFEYuuq4YeK8ZuQhc0fI5WM4qUfcA2JFbr+jApVcBYlqjqCIDNELhYwq0gUbdg0wI ++ucWrR+HP2/S9rw1k7AwsA7cfPYhI/Jar/NA24M15sDnY5dzWD1TZOfFhd1iMG4EzkDcCGgo3WLI +IJzUudfGenZrUqUW24qA/0R/wMgTW5BrnTzyXNA5nEkbdqPpWokZEwSz6FXhS12v2CL4Uni6e+Yr +eg0WfPHa0VxsxQzRDxyTjn3sJyNQeLq1W7q6Uv1Dx87WFzoAINkKICfZmw21zT0/vRi1zwuhF/Wl +aI2IjZdQFLEQgCYbCm+y9MLiTXxSNrSmK9ec1IvPzk7AfUiTUnsKIDTAsHFzMj3FkX6hZ3Ju2Dob +agTUBFZN460K8UmNkv3aZ/V3mCpiakZKk99a1GRIyA2B/5xNA2CSokNRwGlAzSDSj9yuLnjoP1Sd +EpIS0YiG6hWbOcC5HLWTTIsi1GSPgQ8slVfGhIwdorKh7h4b3U+YopxtpeOyQb8cE8LCjjiDLtVU +a5/5RrLTZrbgneo7qWc61RGxEWiexBQJ85LPQik61FBAeSjwNtClltUJDGOEp0JfGqehfaKChrIG +TaEgSwiDuhTlMv3CxkZVy1PzHDAPyHcBWAPT7XFGgVeAkQExjy1FsjZaEPbPxMvZehnBBkzabjAp +9J+2mkR6bD/X6WEj0R5RERaasMAeAWB41CDWfqYXjoprIeqO2avEIqE0nLSBIywmjc+ivn/xVyBB +hoFtJEF1iA7BWQHxP5mZAQOEuW7gvTnqLrDjiY+HHorCiBVXjB07enbRIDDNqOhqPBO5Y2BHo2xK +drPKcJkBVoNJZuDdiguCZljM5ZFnzJ33Ey6Dh+YHhwQsns4kzyiQCNjc4LU9kCayN8MGxoUYS5kC +Q5lFZ9l66PVKewSUrN034WTM3kyJmBxsfDY6alY2MJseID/EEGL3MkTvAbOBfPOweIl2gZVJAUSI +bD2+Y+FbF60s5MOQhaDSEjU2JEI43jpm84mCgGwJoSTLtp4m632C2FSsDWyiGZ6EHnl0zHln1yw0 +IQOKWL8ovoUKYwALzT5N2ID2HZ2B7uJWngEG0MCk086azzo4SzUVk96pAC2R1DF1lgQPaBJ0XAF/ +rmnimVFR6DH4i74UmQyYkkHx0uIEanjgPLA5srPRLUO+nJ1na/obUk4ninaW9Fiy2+wJKH7dsCgO +UX1UnGlfGadjaHAhY/li8Aj9JmSBtV8ZiXcxHQUJ9yQjnzJ5unZJbacWILhK5L4GxQyZuk5ExO0O +FnRImldRVx5OGqrEQR0AdywHVDQCmQ4MNcgN/pGypkhkuaBVa0u5/WwN453EqagqV7FtoP72IW32 +CyHEwaR8X8GzwgTP2HvwT7AOrN2kHAon3XczMYjHZag7Hk+fUCnRsgbUFS9pmioLAaI6nejBZgDF +TzdNy48Si+qgQjnjSrO5xYO5AYy9sAlkwwURhiCqSrBL6KFMJQqWinFME97a8F5cuCDjKpg0i6Wp +vjsfJ/Q67OqG3wP6mRpryIXsqlDIDijbRL4KIWMTXEypD2kE/HBUx7nU+kZfIVsQORMm2zJho4wA +uRt0EFPeCEkstTaHdmmKShVSe0hcVqqg2LGRzPCq0WtWJTgoGazShXw90SgDcdqVBjj7RuyS0CsI +ug6dcqOAALQc8qRqKjJBGgfZObNWe+J06EdIP02A+wkdiimqc7dsdC2W4MD1Wi9ElSOpx9U2ZOMy +EtSqd2WyZl2hB8oruHxVV0RiHOa7VSqx42hau/IZabWhn9KQY1ZGq8jmRYs7qsaLd3FKXCsGtyBI +Zqs+wzlAN23o2UyLBtxx6OIgQMqwVmnPrg6Fdg+bn62mwwKAoUxPc2MpYBvxFWFRILKobgW3OhJA +BGGCt+YJwmNwNoUZw1ge3Ihh6mA30wXd2kTYzT1atoXtxAglsgzDvlIGCtOhMcTARdHyzMw1dnNw +h4p2cEMh9ZQ3hh9bN1D2u4XI9hCg7bAi4TigvtSam/VCt0sx/JkhV7ddwSsZm22NXAZ/4VkIa5jB +FHbmcIuZZcGkLDetbcBZgXsTWtPO1rhChRN8DaXXdhk0+3GG+K86u/AjMPIJSYJ8L0RI6X9L2akC +tir2OqiX77HQJyrT8MRskFoqF3Ari6ySdiVicCABdjIvIRcWaymUkQkPfgI2DBA6fis8+t/oOxAv +gkDEboTLOFHfhiRhCCApGWtKGzyH4xzBYL+Qng1riaoPG6wOuL5VZCAj78/a4aHd3kjS8e9gRt1i +7q76wWiux0SsmBQEVNiYKWYPb01ewleneTQo4roUKJyHZVnXDNltXYlt6Is7WX+WSgBD0ea/lVIQ +Aa8JuEFS8AtxCoLsRG5pr6Ogz4X5VEuVqkrIxAYoy2pXAGlmSnm1KyZgtfpb64WzoRbHFkPDEqIg ++FaERzJHB/rYshg4g0axpwlAB9U09r6I2TG7TliZBFAV6FYIRiKLmaGjBMfBKGpnnmBNbICSNE+P +nTjSYJvamRxY7BLpB84MISgKwnrBMCFISYPBWKGAzBHYqhwYEO+lqDJmrSGzEkpl50zEdOkTbB8p +HXnRRpkqGpBpgkYtIUPYFQPKn93qwmbSIpgqj7AQIbOY4OEqXRVuo7XxCPGH8q4J4jrkJPIhh1Be +Q6ACHnbWWhaVuagXY0QrhDNhYuOdIcTnrAkeIejR0GOYx6VqBHHGlAlTHVYXutaBQmbi9tUziJql +ZaOHgB0s7AESSk0949oPTM0xFiXUJCR/IGRSNSlkdhJuIc4wHjqmjcqFvcSgaahvjJATkdDVPBAJ +cWdDnVDrpy+Gy+A6I85o9pMrlyTEqAsOLRT+a2rKoadiQ1IwhD6bGaDvhzpNmrGFvimsZnYNGbeS +Vn6mF5oqLR9rlqCr23h96uaqleNEwbyG3qGDQuoHtnio+NiSuk3cFtASpMiQc6OBZe2ZO8wMi5wM +gzksEJwZHWw1LBV0vB20SalZM9kj/GH2oPSLcfarKha4UNnytNyGYnU5mwmarQW6ZcDTVt+MMiy6 +Mgw33OjSh/4XFh4/aYm8PDcFcaGmZ5i1qIxjZVQyQJ/7SMsz6xPrMi5MZDQLlW8olj3HPol4lKM7 +ub0Lkl0SITXdJObyDHM1nSEPgNtqprOZ2GDv1HTcCmdiW+pyNdcxI4T6fOZmhXalQz/iedLSeT1T +vPzTnQRspTQMq9o/ehNwaw/04/A44MMXTra7JkCIq6k1Fwaus7QA83IAU4Ddg+sZNMVegv3EaR9L ++FYiY8BcMJnpcE597qmJq8yVU5/jJ9r3+dkYl/uO6tjdybT5xkhTiMkwG7LOlzu2NhPrHrC6Au4l +q6vk7rTNcrrfra67++aCNMKH15JQOPuC1NwhGOQYnsOGasPDGMQdXsjYAOGubHdK+DV9R4XrM/Zc ++EjbzRnO1NjF4XCNne6O2ZYjhAPXOUf4eIO5hDO45ULhNQ52FZ7lYGnhgm5YX7iqg0WGOzvYaPi9 +W37r/vHgy+FCD94drvaWyYdP3oVBuO2rvHD/fgiWqyYQEBIoAgYhqrSnk0YVQqJF3CGkXgQoWvEY +kYyQoxHtqLLWoyKtUI7wSUjviLCEhK+xmUYVqKdDZ4iwTugVEf9pFZAIFLmmUoNJh2catWd12vQj +j2CFCuWBro2q5QGxqmpFzCz0tgiutQpeROFcE6yROlMWa0SvUSpr5C+0z4gOuoIaUcRGka3hxkmz +EPWjTRWOqGWrMtfwpuvWNQTq+neNla719BpTdX2+xl1d54/4bGscRCA3rIgI9oalEVHhxiKJ6HFY +LhFhdtvGA9GtCVQD1m4r1aC221M1+t0YXjVI7hZaBNLDiIuIe2vtRWg+rMIavnfLsQ== + + + xvkbE7Ne6LZoTRpwe7VmFzSGbU1DcAu4piq4lVxzGhpzunhdfNjdHAflktvmZMOcj8aIL+xlNQzV +2kexmLCEsXoECuxTS7GvngMADhGDIlwM+DA6JcINAQHGfrvurgjmrEm57tdAOw7ZhaU6QJRRor0O +27O6p6RQvYZl5t4UNBZiVlLrdqkXun+mPsx9OPWt7ux51g7PvULxGe490nhufK67meqUuCsqpq5x +WdUpdt9WXQb3f9X1ahxldWHdo1YX371uh5kvfOsjCuqJEOzoxdMhPhEk9YXzPyoMCQ1OEznKRIdM +EvoYtS0OspbBhf2MbbJOE2frhaj/oASVRxhaF4A+4QBr6bheuKiiVh8m3CvBKVXf6meMVGx0cV39 +gEXdiIdf+kgp91HK52qKjVrYS+A6oBJ9sTmdtbVNmFXs68YsejsBJR9XPHPTrr2MXtgyrJ5Uz9gr +n7nBpKdLtkLCyIMWEciOEfF0cDZYImFOGphLXOfDj2cdfOezRwI5iUCASUpVsuEh0HEJTxtbMDG6 +CreOb1Oo2WwY2m7nRMB1FKTFhSjrhskTvAGCl83ONjGIeqFxm/ow50j1rQ3rqsOLC+snGBs8/NZH +LnIakfjeRaYD7fYv2tNowcBsCs+PAUyUtoexE8jUmCNOfniZbd/Vk/yMv/JZw7iQSkEtKbhDDy8L +MzX86egTlSIC7NymXle/yp918J2PXOQeIA0Y+AzLtSqIaHY07uM0DW8E6BFnLDAfgJO30MIDBgP0 +QXOPZfVyJK6KAu1YYHJwx9qkKBetok8QP43heaIQCoCRu4QzKjmQ0JKt0pX1O0YcPhb0vWU3CNjR +MBkRBWW4VK1z1NeipndwtH88UYMcTE9KWktEbIpBo+bAiGNUATW9U/RFhEuOThRYZrTtQaIpEw9D +BjdUSgZzK1Pkp8BqSVaDrJcV9RnVJ6EBEuCiN68EbBrsgjo25Et5dTFHD3gTHVXzlYODd8R00Nbj +K3zKRitX2swteg4zhSEWYbByi7pQMHDho9+sKLy5xO+IpUfzRfpvnDpiGC0VCd3Ny7wmNyIrjSuR +gwgAAwNxJgI0mwvjYcWadda3QiWJpmh1dNBLmAMTXwC/88xGVf6pjalV5yTDzcpZ8nkD7m5nBWw6 +wewm7WkbdTAoFDGPvi6WGP+Mq9VVRQ/ZuQYWfPXp28V4g0LkVq06DFJCaDB6VlaaS4b/UskSHmMi +Bjj5dlYMGIxYqTyui50Qz4ot077Ut1YMLjZffEDs0vZLYzvHlMSW91kL1tDObvCQWIbgM7FUwZDa +NQ3OFYsfzC0IJIbRUlKwSye5Q5Z6yHufHeP2HxSevQxnFZ5d/vFEoX3haJ7myfKaHuHZH+HZ31/9 +PF5i31YDRol9VANGiX1UA9YS+6YaMErsoxowSuyjGjBK7NtqwCixj2rAKLFvqgGjwt6rAQ+/YqfA +vq0GjAL7qAaMAvuoBowC+7YkMArsoyTQC+yjIjAq7NuKQK2wj3LAqLCPOr+osG/rAaPCfnWhQx56 +QWBU2LcFgVFhHwWBUWEfBYFRYd8WBEaJfS0I9BL7WhDoNfZtQaCX2EdBYJTYR0FglNi3BYFRYh8F +gV5i7/WAhwt61Sy2wo8l+KbrYjsOXW9NNysOHUJv2rjZcOiQd0/vrzmFDYeuJxyMtaMnDh2oVPvE +Og5d7wEnc+EZDl2PfAx0bQ4cOiTT8lsChg65EssYLnbDoeuS2mKBQ9fPlt0dOHR4OLeZ3ak4dEis +5gJVJDo8a5xXQHSdSUrzmzsQHbF9EK0NIDpUkLL+MIDoehBE7PgAoutHFbIViK73jvWBROdn7FaH +osM+QZ5AhaJDjwZC9QUWHVpT1wEHFh2UnGVZo9Eh+TUN6eyQHK4qh30vNLoGH22nDcG2C0GguG2h +6ETEz52yzwMkuj0UuB0cuifLgkbGKCtY4dCtuhDsvjxQ6JBVNIk+eoBCd+frDYNO+I08wXrkfFgM +umNT/NtTl//ekDf/P3t/s3vPkqXnYXMDuoczlAw0lRmRn56Rx7REuwUTNCFLMIxC+3SJKkvd1WgW +u8FrEAxNNfINCPDAY9+ODOgulM+7PiLWzl1f7GMQBgqNRp3f+mfunTszMmLF+nifoc1Upqsh0RXT +1ZDoiukqJbrqdJUSXTldhURXzlYu0VXnqpToyrkqJbpirhoKXWWuSomumKtSoivnqpToqnNVSnTl +ZDVEunyyGhpdZbIaGl0xWQ2NrpishkZXmayGRldMVkOjK6amIdJVJquh0hWT1VDpislqyHSVyWrI +dMVkNYS6YrJ6D4Z/8GT1xyBTDs1Vx6SR9SnSJb1JTVbH8aHSxSocCln9eH2Ca3SR30Cg/DB6QNHo +Wm222r59uwS6jjXmquP8EOj6Pd8e8lzPWPC5amt/gqb8kVMVsvlVtig5CEO2KDgIQ7YoOAgfskXB +QRhFiF4BnqpFWRtZVIuCgjBUi4KCMFSLgoLwoVoUFIShWhQUhKFaFBSED9WioCAM1aItJSdDtSgo +CB+qRUFBGKpFQUGYsnVe0V5Vi5KCkKpFSUFI2aKkIFTZoqQgpGxRYhBStqg8zz9wovkdGITfq877 +Viz6s+9iPwES+JAschIBqns7eC7tV37HRzyOydEpxrmegfiJQvizTxbCb7mEKln0x16CPuLnlSz6 +/x953n+IZtEHn4nK2gURxpoTIfanohyyoCZURzRBXUiwx2gXRd+OQCmHPCdOYU9rcGJ/IMEiJUoV +GO+uHU5olDJdSqueM7MuerMoqOLgnuKyiOm+TU3uy211GlIP8zOjbWn3XCwzgF5K3J7H5xtFA3Rx +PW/81A6vvfN03OE/ND6KJmU1btfv1ESBY5UXRw+aFZH49ZMg3O/r83fiAm2eF7AbggujpoO8ac9n +nbqN9e4+S4yK/sZjYJKmknM8Kf5JHm7JHE8HsqHppgtoH8ZKos6E8a1WVZ0rg10dYV8p+eYvQCBQ +tc/5UykI3Hv+1LglhIbVBZu3TXr9Tgm1+7ttxqsa91eqNOThRWGKR0UAaD9GBrcpDnPlMIpHn8fl +8MjPynFUvzMHXF5cjsn8ATl46y/NUZ63JN+EvG3jlZlvb7xZ+RTGyxdP6vWWjrCMQrKfZCX6aW1P +Q6qGeJhea7Ybqt87Vf5/q6FdTTmSuOXH0MRrjrqi+iHsSF++dqvsQNTKvj7jzar5db+Jn2xOpFKq +LMUfVjWAqKsMB8R0G0Z7ZFOPP3uXzRrP5i/dzCXhQMnIcuq1+1fcR7f4mW2NcHfO0ERIWQneMT/1 +sufCLTlW9e4/q2BTwfLzBvdoxkdEwk49aLggxiTCljdcXlYi0GybppLJM4KsSAsccTHPQkxMyaUF +VG56ukibor7sv5aWF3ztrn/MgcxP9LlvO7s/fj3P8P1U/wHOxT8MZbLOJJDnSqyv7bn9uxW8FC3E +VRgZiryfT/5t53OT/qyvvNMqOP6dJJPf9vXkrraMt/wxX2/nP/d1P/PL/wQy+Vl9j2+Ccqug3u6y +PztIZy7xtJ6xFO447yhNLILEbkQrlNF85vDNuz4ltm7hAFoZm5Xbaa5HN0CVnNZ3ZpouRFrVXpZK +u+MwNge7ZLd2Vyhtq7KuJG6tWP+5PHF080zDltDhtyrGoJlRGzNKHNoabXvM6Hd2QDdLEbNvWdhh +8COtoohKeFLJ/Mj18ubOM/qcVEQtIPuymcgwi5FiB6obY9LSUmGNeJeBxe07O8sq/07oycPI50a+ +F6XFRb97jVYcwvab52qfySmkb0BGbaYc4v1uXUoSKEq4pitC6nFrtezoK3CVbmnldSvXVydyRzyC +PnLvelhYE+xql8A58tQltcb+fzH13l1aFOhVSFKaOP6zlsdU7DO0tI51JuEVUeq0+kpB87JKXb1y +z6Z0zOLWsUhPML+CtUPLjrrjDpJrCmNt5gr1fKKrVr7FNp7LcpiylbXBNT5sM/0Z65oKiwWWae+z +Jx0HIgZzudjHsR5tsoC7ov/kp3iJ3Hy4Js/JEnu3yXKctsSqrfno93SbhJt8Rr1aXNbbW9W2xTCj +aWBwEjC17wzrikeyX0oPmrQFg/2wMjrrBaMVi9atvLt201dX30aKQ7UBWNR4w9Knakx1sqSuPmaj +Za6UP5AZu6OZ7xmKz+xhz9TbTZ9hvz4jxW8RrZTqRnTGtLRJhPFcaRrcvZOZe2ld3/dtGie6mG0x +odDngiyvZWhTepq5R/aC8Dvl+SmIy9vbTquFkibCKZ90cef8xh0PSR1NWioUBQphpx6mQSqZBK3+ +REbJ3plGRIgTMSm5egKJIdqlANCf1ja9EHtBI8YKU+EA3Bmu7eEjkerdPIKqjlLxGZgz+KnqPZJS +aIu6We67UTNumzNwX2x3AW71Vkx80TysX9Tjh/KsDYPxbPJBBPEFWu0k/YrTyPRpTtTtbTY+y27e +uIN2F94aU4YV7fMVcstwotRIxodlxxPupaFIlueHLux/gXKLUUfWWC/0vgWupE0PZt28RoTmSEHM +V8XJ1Md+WLkaiVgDeyPVMb6V8a/fcd12e3WqhfGZzXBK9zNa3DbD/A5vW+nBe9FdGq61qK+b/YJN +kBS0mcb93U5TQGMdWPWl+2FxGlrE1aIzLNdmMSq73jTHtfDjrZxqOP1eBIuXqjXAv3WLvUAcSDLd +ZFjiw9JSvzXNeXnMuuqnz5+wMXOv7fVbY7TmTaEVTj1Acd8I65FP/ri/SOLpzHwQz9LtIz8eVjt8 +LatPlXEgdYp8/Ntm8dUcIc9Uaj/gYyjRZz8POdr57IfGsFxOa1qt4/ferUU0xzmiY/679SacXiVc +35jLu3PzzVqZhbQj9ZdvpZ1RpWv1JeUyuN/5MtMuapQWf9+v7gpvZVrAd0f4PqcPmsH6NMEQcejH +50SkEsCzjwlLG551zGioBl77x8TH9kl9YTFBsolsbtAcihNCN2mdaw/v8co5+YzO75i2Uevfro/Z +/XbBhVgE1nB+xkLxrEqm6R8rit1Ndh4y59JDr6SIT7FGqTMPh+ySFLivZep21VDzp6NrOD9XRdpp +FQrK5fMZmku/12mJbRHnrmvx6lr9sWTjbmlazFU9LXX1T3N6CW2xhsXhSNBMJzeyehzNVcbTM3ku +0pggXyzFzUlz+kOItUk9PX0musfVaV6dq9a9mT8P7KhMcnPTU6Pf1iuUJ4+ubQ7TStePvlY9vXQP +KXfU/a5+JG+XJMzS4WxeCDKcUprSJeJevdeVtM/Rh5uLu6XfHo7wvYeyx+wwX65mEW41KuzGXnDP +e11cOqu66OH1hCd/c+P7Pnx9kuQSeCl7AmDk+vjYO+zHaDBnd0F4zTpy5k0IUp5qVI7NyrMMWmoq +9jOq024f254DqjrfFrsjBLluT/xoA6WJ8fzYZp2O5M3tGAW7FJ7bdo0yoV2q7/Om7vRm9tj7naHc +H7vDa5cHVDeReZRtNZmRlEmLvShVNNLAKVtW5MKo6MmtLfKRerax+2WyMbJdbJPtqQ== + + + LYMhvJynXeVmmbvGEsvMqmTWjjh+aE97UQNGK3h7fnizemrVEsftZUz2JSKcal9bvF4f3QxN7r7B +Ymk9mw0xrlG18/bjDleqUCj4ub0C6hwRaH9mFNdvcMAM0WBT4fMNlmgqquOtdPo84HI1sPwIZM+o +cMxvet6KbfWdQF7PM8S19OdlX16DoX1A/LibHS0FUPHr1fm+TjdJYLc1BZPtVt7dJq6414KgMKfH +E1EBIM/6pxg3aJMgvkBKKx/stVmn2BgA1z7FKnOgXMhDPd8XQ4mM+UqEN0YcogcjBREDEz2Dx8E7 +c3hzHjqXPrqRh9DMVUY3+ibteO54vCQqtmzTuySRlSwQ9/cNmYT7eXrxPiLRoavwt3aDJtf2MW70 +bkuHBW2YePupobpucyY0R/Dtz5jzWxlTCfVpbT2fO+6TDVIqXKvPSJsOjEqQmLew3s+CGRMbBZIa +XDH/SRlhi26rmCYlPIPYYMyj3LiFKpox3z5DYmTpY15mGJy8TD5xbyA6GIQxvYOGX+5Qb4lVQI+X +WTgXCrRIpPI8VhRkFVKCciw9jGg71Zcn7vt1HNM6xlXoJuZipAVvk8ujdcwXRUpP912LvS+e9zrV +K+ciq5+1OsVDC/EmsjcM9Vix0/JTLJ5a2qcDffnnlqi5YbKwWd6ODz/BZGf6/kP4HJPBfZMNoaQj +Hd9wYhjh5tOFo7PJp1r6ZMF9X6/7wyNSvTTtP+FcUdIsUZN0whiwKurw2+veGi9NeybOH9Kjw7Kj +kuuOHyIiW4rThnuoUurHOQ//kTJfzevpZ9K1fqzpDIVDSp221GzSc5XABxVqFgsJF5caX+3E3Al+ +XgCToXVPGQGRpYfEZvjTWPU+h8ctkQ7WznDMVcU73HJTbUAQUGe5f2/lxI9T5bsA/h4JXN8qbNKc +eW5R7CUo1lVdXGw5NhQcszvHNyaIS8jrip3L9vzHstkvM31+5CDvzUdl7IMoNta0kFslqo0tlxV7 +Kv2QeIVi57VxvY8/E3sz7ux1Uc3gWzg+52rhKPlGj6Pa9fyI2Anqs1ngc8eoD3rejPB3fWspGYNG +2sl3n7QHmJMdu1TN8dl2F7tZdQegN5UbXnQNnvd4HTtjSb0ga/ZTOPbaQqO7oZua22zqiVewerkf +pzhZ6vP+3vm+fSMBjTpvbO35WbtudMQAKP/P2xqhgk2lSus2ogwULKtFaVionWRxrXGHvJIMYlAm +3XkmGe3YCDz2SMJnWGQcGKGT8WFpqd+a5ry8CNiMnxCRnfpLPQA0bkjEiPKeRSzp495G0Gk8hAhM +jQcVEayPJxqhrvHoIxw2hkfEzT6GUQTYxniLINwYkhGt+xi7EdbLQZ6hv3wPMkZYX5cMJuZrlfHG +ePEiLFnezghejpfY45v5nmcctM4HGTDNeSODqjm1ZPS1zkARpc2JKgO5OZdlxLdOeRkazpkxw8c5 +eWaceZ5iMxydE3GGrHOuzth2ndMzCJ5TfwbKc3HIiHquIj+W0PtYbiJGn+vS30VQWcH8sYBFwD+W +uEwM1JUwMwi5YGaWYSyqkY74WH0jbTGWac9sjIU8DHXBD2s6BpFKGc5D5Fw+vIxIzgx3JBI4XyzV +tRnm8IEibTT8pMgvfThUkYgaB0ayanhnmdWqblykv4a7Fymy4RJGLu3Dd4yk23AyMzGXjmhm8KrH +6pm+9GwzGTi8X08aVic5k4vpTGcCMt3tkaksbnlmNNN/z6xnuviZHq1bgcyj5pYhU62xqciUbN17 +ZO7WdyiZ3c0tTGaB61Yn08W5JYqMcm6aMvNcN1eZos49WCaxY5eWye66l8ukeO75MnGe28LMsNft +4zjQN5mRqs9daKb06241c/+5qx31AbHxHYUEZYMMzsEkGmMnravQyhSbbc3EuhllT95UO7y3sXen +6M4KomN7j56ASe6VKICEaAS9jWiBlgXt1COgwNRrqn4Rd8jJXeGFCE/Qpi3igwcxTDufkWG1Yh7r +ELp8v0c0hOC5kW9L1CSPi7DK+KiIvOQ3RoDmp3JhEccZPyDiPaabn7804kLjbkTkaNy2EmEa9zci +UfkMMlaVD6uEtPKhZuRrPPiIjb1LTfSlfxJM+QMV3HjzJe+bA8pKdaCZKBl+0nuiBO7m4d1zo1lO +g7+p/sMN9sz6GbICfhjl+6pFYPGWgNphrY4fQ3gch+oEiaL8KJqbu7gV8ZVh8UEcl5YHjsu/bSi+ +f+efxskfpLykTZu86OelPpuXcg1rFzl8bKr2O9LMaTl0iPkrX467DXE0PioN/o0/xV7JzJTzblR6 +biTtZNkNOzQ+/XnsAxXEhvIMwU4/0C9/fNbHr/zpT6PjDxkdKJaohKrMHs9dNdpBvH2Hb2DyBaWl +SCmm8iLTVygV+7DSgiRcSswJ2xFCRfNbPA6zKSY/x+eg/LZ5psprcuO4aJ/xXr/tTzPGHzhj+JtK +wQC787+q1punMb2sgkXgPE2WW4fUKWM6zl7W8Un+t3/fT/MMRWvw4yQcP+QsoEZgFTPlJ1O4sIbS +VM4r04H5i/LDPn7jn+aL3z022MyryLZMFEQRrJowzOyurbdPItDdCpsO1aOqgTs05OkFUD8ZB9pm +FYkNyx1uFjs7NulgVDdeehqWdIsCs2fjZl2YVLhofUCwWFWxaGevoXs2LoUSGoUH9tObfQhzKJim +/fdmdGTl9P3UzQokVO2j6GI3hY1OUmiVKKAVfFDllN4zZou7h2YMo1aMcfSYrAM9lz1Jm+85jg+P +Yo8DVw8MjQ9bnX5Qv3VzVnpcHDrfqjzNy9ee9bo/fyZhGFVH5P149subfUPcM0SrpPVfby5Yon16 +Bp1g/bFPz6mxhVna5wPtrrqSz73TvLzNQyMvoo4hFLqMxhqDDUCdSmpyQGr7qOYzt2S65ePA/DC6 +bpBnGd+K37FlrUxenryPyxj19guIKzOj5S8tW6lxS9T2QtmK3zQClTfx47y3CgeHlv24EmKhSijm +g0KTXBVv8UTZbSmk7KfGo1fgFv2UHBz0FK/7NIiO3ZZOH0Q+2ig/Ue1NjkhajlU4kkNX+LM9q59i +jI8D4z0YH5YvTP3WfK/i6uLNy+uPN/Tjh+arnHckX/e8azkv1NubE0g+h5xk8knFZFSfaM5Z8eRz +WsvBkVdRR1FOlDnc3pPp56T702+b5X9Webaj/zDk2Z4//uy8r8VU586TsjGSXX+SZ/uTPNv/D+TZ +CI0ahpWsEWuhxTMIVKOcoqJIVcUvffT3qNQOCRXFwjr6mNl5RJzQ0DpNmWrkY+zV5qMudbls3oOy +wNGLRkfOXFRlzlph6lQOvqT2c1+uy9TZkIexBiGUPcgIvX/FkGdrgvWdpj174Ix6xOa0EK5psQgr +2xzmQv+loJjr7q2GKCSwOmcIV+Ub9HJu5EIA464ChPIdJBGkCWOtl+2ZU+LmcAukZ43ukcKuxHAp +luKzLodtO0bFywJ/zAfyDMbpuOjkBHVx76bwJa3N0hfJ59nPJ+54Cha7GLJM+JgulPJFxgr9HZVI +24qNfoxu0EVK53QoriQ5qbC+1Ha0eqnf0qxU1pMWKF9ae4fV4lI4BD2E0umONgajwmk9vqh4aGq1 +NmAFcDfLBzq9E64WbcOv5/ljedbKrLMOKuRsz/oZoeeputFn5KhovLvaPaovpBps9KBJytd7aI4u +SRyU9fDOENLv6PYxQndd3sY1eLnyhLoVFszxL89vMpCD9c8g5KPfwYcpOIezcSXbW6lwvVar9ew2 +JRINHKrKackEUQH9GJbErZKU1joOA+qSSvNuSDs+6FgM9GB3pwvaFvFmF1sSfwtNFQankbvYAq7R +KK162mu86Ed4RKAqd1dLPo5mtc5qgGjSRJHs/zU1Q0uuyQLaZLVEhPGEcZdrsFlbtF2s1PDyYp85 +R57f7mhn4vQSiVS1qaDPn2PgxzGr/vuQZAudoBWdIIF5LoIluGPMdiHKdjzDQOT2Z4JgRuWRvD/h +WHaKx/Bv/uxxtcnbkrP/nbJs5QIu5NifPfpzAbT5P5/zT/6oCzivU4x1fQIJ3Xv7kyzbH6t19ClA +grN7nmf/3O4fYONvc0gVfEPK0iCHl9ePomJpikXwwa5l0huwjkt2cJeJ6Kve+ZnNpfUgzYBTXMHN +3vvcQEvDQns8NTVQdcOGAM3F6Ihapc1JUUPK+3CcZxktrEhg6DgWKz2+zinGzTb52pcp3mxM5zyu +x6+MT6Iool+vb+y+1xqXthrtaFw9GqSSrKg/k/QJQatxP7bFuyPijkE90i2sd7af3mScjwDYIEV6 +4zGxRsl9KrHQ6cDT1uzxYedmXT3Tt3o9UEYY7Ookw0BNbf4CynS1puZPfZblA23t/Kl2T06Xih33 +DQk+Dhw3+NwseJA32B7E4QHl8ayOo2Yy2D+qkyiDgvbs87gYHeOjYhh9fKcPt7y2HJF5/Tl06w+N +IZ43JF+CvGnjbSl3N1+rfAzj1YtH9XpHh9/xW7cc6w//8T/59a//22cu+mf//C9+85tf/u1f/+Kf +/etf/Itf/s0v/+I3v/xL5qXPeWgSMfmtn0pv14pioqbE+cP/6V/+6je//ttf/MtfPXPd//lXf/mb +/9o//jn0nz0T2PvIf/63v/y7X/3y73/x46//23/9H8U26HXNfvD/9ld/9Rz4N7/65b/+xf/hl//2 +9x7+57/8r37zi1/99S/+d3/767/+ze89+l/++m8+D/b+yut3/87/9Je/+lf/9W/+0B/6L3799/FD +iU08y/Rv+/B//G9+8+v/09/8xU+/+ut/9Yv//I8/5T/9vb+Yo/+Tv/3138elL7/1c7nx//yXf/vT +swhNd377bb+V//mL/9tza56H9W9/8ee//ukPOYlB+ZtfMc5+8S//7d/88reOy3/6/PWP/1n/xT/9 +67/0T3DDP/nlv/rVX7vpf/PDf/g//4//w//3//H//p/+P//9//w//r/+p//nf/cf/Qf/q5dJZSgr +MMeVyKOCU2wHsAj1+lhsufzH9j//xd/zv/8m1mvb/f4X/9b+/t8///1/f6x//8O6/PCf/fB/+b8u +P/zlf6Cz/kXu2uZPDpGvjy/84c+LOa/sz8uH/BZz/ZC//iOmBX8K/+QvfvpvGD0a2Y979Jof9OP/ +134L/o+2qX82M8+09vz/ZX6FCa9TFH3QNHdYl8VfhfWZa4d1s/3miWE72i3Dvj6r3X1ok/CTnXbj +S68q7N7v27oIVnVl0Uxo/S/gHxUr7Vb6Z6dS+UlzxkrIUphKLNttFs3jdoyC2CQX40RqESkjpsxR +FWNIkffLDjOiAnub9bSP2rLTkcqpZ605tDSLjgFd9W7qvThMDJwoP4s3TZ5r8i7pxaOHms8V6vXZ +HC8dSSgU2Fdblu/jNp9kJA/kmOBza/lSJzRew6HV6rRNjqGfUfF59j/Cg+tipQXZibpjBlOrZa3t +RjW6Dg93SpcUizZzeereTjvVVb5Erm6yqGfS1shu3xollCyIzxJ2yqFU1SMr33ooVQ== + + + h8+lzsi+7C3+ttNgqTI24iDhwVR2vZgS72TZrJ7RThzm03eNbP220/XarbeUfa5+tVv8O2+2sZOZ +S1sOfdjuNBqJVF0mCNDWhM1jXpU8enyJVb9KAOkup0JjVG5L65ZQUkVsniptDeLoEvNkU9zpIsYC +2xPL3nFXd6/T8zOFej/kpZiXRS+tO++GKk/DZWWXfqJbJdmunkIa/QmfEJASZQVKdSPvEha/uygj +S94rDuRdWygvR5iWENaw1AeTZuovV8mM+rtJ5wkDnnzA6mgAWWzA74oi+dtJEKyrUGm1hgcqN//O +ro3UhOYJWiicou6v4vP79E4xmhZKVNttLVX+sx7ztdipz+O9rYd42d2ySf+VBoDbvlW5Eh80cJV4 +S3uzaIiYO/dueTITWkEBVmknN9iZQlG3yUz9Zt/RiSMK6YXMS86QUYcqa19tIlVfD/XOXANT7XGb +oczIY9vselCStdcgI16Cs2mTNuR3PZTd1dA2eu7u1QaC2gjVRmB8injJZdt4Imhvq9oTC9FDLIYL +per/Uj8ETKIrTz381lMZ1NWrQqPVbqcqLIalLyoqv60UxE69AVvzG06XQdtIim7MteSF1IdJ2bi0 +knhfr+ScU7GwWLWAKnm3G13vbpPQDhxkQ4y82exLa6p/JSMOtTiibF1fGZPGttmbj+W5dYfN2wSf +8tTn4die89b6h1DEtrnFbrYIDSZyobJSP5WqYtY7xuBFZS6yGZdtkHf0IN7Pc+wZaI3Q203uEprq +X4X1WYSIgHr5Nocp4Ht5ffRJmIkw4GWs+5/ivPWmSvry5g9pGZ6rGSiEJ0G233Zej951ul8ky6DZ +36q0l0v7TMc7qLtIC4QZ7LSVICyhvjhMaW3Cb6urYT2PrrEyw2nv0UyDdb2ZBKRavOkwjZauOWNV +xvy+gZMRWT5jbqTGHbfFlIztMK23j+E+vVDg7CyedEit+X27DTT0AiQO9Yy8frDw3TYKVAx/rada +mZdExEtBHHfUexdoxFxV8G2SmWnYkYM7w+9I6zMOozPg2On3Pi3wrzmgWbO/DP59HbrbOR1GhP3U +B2nOHYZFKUo/zY3gzk4762RoEEMWFANNlVtdRGWmIpROWcOzlz/V4NzMAwFQs91m0GVLjfM8xnn7 +Ic54dDtB6jn0t9y4BW9LiGkLdvszuO2Wc1XwT4C8PM9w029haAwDBQ7j2blV+n/druratkZ53KFG +AMQKCMWFwZ2/BbL9NQ5rZI+e30vyGFXFNOzez+znufW5m4vo5LiKKwWT3dunGosj95dy2ex2p6Go +0ZjV/bawFDEU8z5RDb4y2972++w82uTX527v64DGt6YJx2Inm7Rpb33ydYRGOVZ5ZgglMHFQCdqX +53L23eS9adh6Bvr6g/bPSduhEYdaDrpDxT05EOp85nYMGq2HuM67DBS153kXSyyfZt1UlNs3GcQP +l4Hyw8sAEH7a9sx9z7uDXPp6W0fkxTgg70Ik6DUDjvVwJ5XAdIZaBfUZFqPGg2WSAWKEm7OjHdwv +zXqqAthxEBjJJAFyJGFdCc9i5e3d5XCQPHNJ2d2KrDXtyo/1846cMuWo6Lxms6wKUPTJW7dZFkCP +n8d9p9cFd4bue1IRi/TYTBF+l3KxlDVs9+H1nOqGI+ptmDrOa/e55bSzA9rWi/m8G1eg27FKsRPw +ASNJhqY/ieLrTxyWKCUfZ+H68aMOKUUwu3Z7UXf/mAPdj82akPJmaiu4O6hhV6vP8xZREAKlJQ2e +N8rfJiMZQLpc903AvFvdu+po2tvmG6Gw2Jn0xsvpzQMXFg3rSz9uFD6WZ749aA1e7Xn+aAGVizyW +JIQeh5zXffOlnYmTDPTjStAG1obFvpL+ikb0OA9EIId7Q9fes/8bBvTXr3aNeyrr82tVs7TTtNSF +LrDeZ35NO8gqusHOo97gYMGJw2jz2hBVYHK4JgNau2vL88KKcM7G8gAP4ZlUSJ9RXbVL0EVi9WbI +e3qw7I7DnsmSHRR15nQt7WR+NDsR382nqHwQA/+wHmwZGCICaeoe3xZPoIx9H8/wtrADVt3PlVfj +WZgx0H6HQXM5H9Rib8xlbY//rrFFEcFOe9XVtVIqEWijY7/T4Oc1Grj36TCm0lNLzPO+HpOBpXfN +7wvrYs22+8orwFxlcxbf/7hEVxrsNKQVeOHzsHbYJpA9IG9cGqiyyq1/Wk82qs8by8ffeKmnu3E7 +OJ52bmnIx74u4yi2A9v2TDTASsZfLKct8vlp5b3Tk1oWu7ftGauU5u0r2XFqDNzg10gaebLycmzL +ZrMpGeedxDE5cMv6+xvEUkd5+G4ODIZjU0Ga/9R+mxciPF70EmO99lsvgr9AN9oebBvNIdYRxynD +uefX8VgpX179x3XiDM8UapIGz2lQxp+JPf721/Wyjec46rYHSbiIFPgwbFb7kBO8Wdni+Togz2v1 +pZSvO5u6dw365udt9rZg1cRFq66CY7c0yfl7u1U1Y83YeZreqbaY06rTTko2FnP07Nex4izmivmc +u5pH01ZLDLGAyqNZHdo7DKvp5v8U66w5PiSONpvR1/7cfGlJAx9haVTIIS3jORzPX+PAjgihZPbM +63i2cxaPaqsV5NlcTTnOtUnhWi4Z88FyP2vW5f78TqCSj75mB187rPY8wbAKlcdqQf+o9rxhKC96 +WmkIFq2Vvm2Cc5TenShsXA2Ros6Mv/d0vgiT4ZhEHx0kvWcD+7yLDmimCV5OMImv3PLhoylCvNOs +a03fbelH/G3yT8hT8NLEQawGJxe52JqJZ/k4kw0ZoOQ3ych7LCOBBxmY8v0dMsPmhqg9xtov2j12 +q7uSgVuAwcRdbjRSJCooeXk/j2JbF/aSWAk7Srnhuwmh4C5xS2AzXvlt3QI1COV3Oe/dJvxz9xu+ ++GaZgGXZGl1Aa7GyWcBwrs+7czr8QZsnBpSYOrFjxCqfiKDr5gofemcAGKr/n/O6dbIsBH39vIsW +WU243o0O3qxJjsoAgk2dd8913vby/xi7jvY8foqlYGxt9oo/A+U0TzQNt6s2+I7RrSvfu+J84Vve +ikzftmmj719hkbYbAsi+kBkSZ1iUSp3JkL/pLuefNKgpb+a9JTWs2LtH1m/bm6v8GQELLF2hoh5O +PpP63q1EerlDuwPzvnuyWZxL5vXFlVRWE0jRbcbwXH08DkBCm6rZu3XabqjzHd2Kt4UwQmzhmdG9 +nHuJoDPmZxOzu7nbgRa0IkqyShtisZCcPuyOniWZuyfk7V5q08S83IxtqE+XG4phTUooq5Pmb1Se +NtPtskDp6h7EsEDLzshxmum2uRUyYAW7TsndbJKAWG0bGQbfLy0W/s7D4N49CywDxkJBYXgmXpu+ +/cQwr0vo6+BIr7pUo8WyMysWvz0kagikjwPVOL2qsN9CdWlh/oUwN+6smUMIgLpr1jYCbdruLbbp +4vboPRk/8yK+is9uYiKLxxGXENQi1s4dkyXD+dvh06M+8fDv2BWmXBxzKguOtCTHUpcAs/zke9ZG +YWpDTIjDeCja5YbBx55P03mYyjMI6t4mwpIGuz8Ze00zLsKdX8CbA+hYCnIH9VN6sd3yU0R7tacc +B3LVhJb5URlp1MaQopYtYGBEJBX1vI0WrFDm+fyHNkDI64SB2UaCIBkENTOIX0O6aq+meCoDikIK +Vln1T2xbomsbaJZm5qXZgc9QjUYLaRc1zzRRTskwzlN9HiF9KEUrXPbL1IuUktKp8rKwjNjjfltQ +Sw0TwhwjUGNJOkeaDQsSQ8eR71iYz804xFKP6dLudpldlB5Opsww/BSzbTvvazpOug2nqawYdHpY +lkyZDeOxWSaCnGXfmKb5IaR/mBzProTWPSWENPiUxcwD2fwpoO8tJURnn7u8+g/KRUyRvd3MalyS +ReHvMwSeOFVT5unSFnmqvUCn++VYDrlmQuzu9q3nrR+6GyM05wQ/1dk9aHlYuo2in+UoFhdX8VPD +rNCJvqP7Msh+5bgMXa2YUFr8BlNNvs4HPt7ts3IbVdukNZhqTqteUvbRXpd185wtk9nRTQPGUj1q +giEEh9t6eOdaitpynE25BHZM22/1FJzWP5y3hbnp2IbFo5qbj94wSx6D8J1yFYuEM9NyW77HTw2z +gKLS0SB671lh5T3Y092HpRbXEScG17damtiyIcviN41SXOmGYlnFzz6nHarMVkt1elO45GqZtfbT +/DT9UmVpsJRY/314A5EUnIjR+3XslhKbLGhNRg5uWBcxv7uyProdUgQl0D3/7Ze62ZQ+HXZYNp/Y +kwKjy+6DikA7N8IeJw1/Kj8I85/HB1oqMIIickbbZSL22sVOlsMilcNrlRkJPS3edBfodSMcrpeD +mrvtPocll3NLxOeBV1RH8B/SxElLTCq+coQZDNQmvT/iJ82a/0WlJejqd6mp38tXju6hN+joxHSJ +SLEpYO5V5o1IyOO2ukeUsr0E2Wx+R0MC4XDOvOU58n6RPfgvIyTTGyUM7NEX4ga2A7T1T6nWnVzy +LtG8c8rJ7vsWblwcyCZL9Si0QaBTkRZWTyI3dmZYmagIcZKBZJGhukEgJJTTDovX5cRA9PnZ/F/K +q1yKdomuSx7I9oKv+PQIXVv/UVToKK1r/TZztZI2l+tq/Wv3smeiN8KRqodnfHEgEW4spmXGznN3 +DNi0kaAmkDifeu4Ulll4G1nJYIQ+juEPPAIrxWmEyTMQjFnJUjbhFoZqlkKRC6IfvAqW6ZYpHqht +8G3mQ/E/lB83e1ao1ygUZ8n903K9fibQ5Ft1BmqG3FGd0kJJwxUlpkR1vWSBCSSqfokJPmPIJqAb +UcadOPtGZxE9CYin7XgM9+06YGeo5RNz7notT9yCH4j/KJzJ3xbWxUvbFdl5/mmJDDNmJfZWceou +O84y6Zf26ruKT6kvQK5yyQGImZSKzAD5FJS5/KNuZjcsilPLkgkU5TI0Iz+DV2WsCn3JhSTLr3QA +fhnjBaGkHuOQaJAqMe7LShGIV2lH3tSnQxxV+oO74dR6z6s9LIxFj5AaEHem/UOCcKrRkGG5XB1w +T022ffc0MVfS9ELyq7ppoqmkVo10uqrVVBMzBNc1CVLJRYBEwpJ+3KkgFYXCJ/H+W1mTdZy5sMNf +BWi47HE+C41ZVOstiyoDHks/jinud1/HBMoh02L+KPxmC411n9hUWtHzh15WNaJyciK8CLueIhWd +1p+zkw47WL4oc28ZozwXe+eb1pXVTj2pqaAvTLhi7q51nh0WLcs8lHYhTWF0RVMvqy2hf0xvWd8s +5cfzlDjgj5HIuAkFNbAL5AV20QSkHrZYc93f2YGLVa9g3pbnk3mpboV5sSBCvKsXi542Tr3WDBDf +NhfaJzJZtDtCfIvt32SR2tm6TNEEZUcWby48FO1dvOaPLQvNKJxp5SSqxIsqE7pgbg0vUI2LIvbd +4jSs1koCMVOiwYerKRHdXCStwXh1b5Yp1maPkEx+zc5jev9OwKMu8Xx2s7+XgJd1nA== + + + XvFjiQpC+URYNyfPMsWdCvwdqoXnPikRTAYbObN98/whfsiRyafVcwzdfGgMN8Uk8laInW+rhdjE +sh7pStXCSfblVvECRx38faLwyt8KwWHIEitNsYx7ibkToEV/j8DnrvfScif7eel6lC316XuxwJLu +vxJap2UGng+6qD5g3ldxUySqPeexWUkSVk0w7PDZYlMmh68rw/NyYZiSqrhiZ1dmayetL8Nt33fQ +tKnzCIOoCT0qY3BsdgKBof/KhcunI21uuaGPZ/fjzz5KcHxPUjL4Uurw/6swH1rsAUJaPcxtV6sD +JbRAHOa6TB1d4M6f4lRzaqVhSB0jFgLrWJS86FlPhej5ni4G7rRilS1i5Cz2EYhToIDgGI9A4cH9 +yJKMZhFiFmjdO/ZL5g0y30op4/ly0kGsK0PrE/OqFRqzmCaU9NxypDevCuQYAdM269MZZ8pNQGYe +FWt9hXZtN7qpImLuzIGXWVL0kEKThRY3JnD/oasX8wrQRG0Hwn/K+ODhb1kUhvakdhjn4fvAdvsO +Cl9U2pISM23SbjnSVSX4b9cLql6lSZG250CrRCMRRFZrFT4gkyDU7WjBYbtPm6WCq9oHAihfPC57 +qFoNDyZHOaGH+/CyPhHFuTzbf2BReY8qPDfzWFSJM0IiIl9i3rvp0VpsT14SF4xFNb24Scs1nboo +SIzHYzLPeK3NrkNat5tlB3QVa4aNaKzttM7RUayqc+36hT3r2vEqgKHPRhVry6jaLkVyq5C89+4B +S21k6e7eTRB404YVgMS6jxNVbBAqWTwWKxnEZ8AtJeRrW33yZHfPmNFidUCShxYIg9GhLR9ywYRD +GuVxCi+4wLgnE4jkM0T23Qs+8a+tBNQndz7dtpiUUa29j6zO84g262czLMM+SmRVy4xGqYoMUSt/ +pux7pGgaZUq838p+Kni1GNTplAwtBSwq3ESt9Mrtbo/Ij+Xd7Tibjpo581hsa8eWIQvmyA7qXqp3 +tf9g9+wyMEOzJBg5Tm896HvWfDZPH3FtJtIDcGoR0+EyFtlr8vz5l3FJ5rBWNd8q2vzMoGX/JGmE +xbrIWFL7ZbDxrsZdqyccQVFZN4R3u0uAUri7ayqwEh0Mx3mZIafXLvm+btb4eC1xfJA1+t1Zv6ji +XTuPlBYr/7YOisy9afEw+Bce1C15VhNC8NNQTJcsjV0ERZVynvV2WlHndkiS2KDwGQ+idJfIuGkj +XVZ+huHSzH7Z+rK1KWaL9Txvs6rz8L6s/GwLKVMMl2Is5tH6JL5aeW4/zV+Qbu4ivpJ1YZJ70/6y +uUx2zojKDFMaZHrrUL+FHWRPaWV5BwoC21SBQM5FLyjbBuMC8CIucqOMRqONH24UE3Cm8Z6ZQHsW +fLSQZFcN3hEoiMNqQykhPu4pdaOYGxw9cTOUuDtUx6o8HFEWsmbw30e5L5GuSzLFOFPWcmtfd9oT +fx6l9rUqH96mUkz5esy6Eu1eqDd4noEKyq9TkVPVxVzdwPD+kq5W7XoZd5pYrap3FEleTYFLVbsH +GeosHSQwxHRC3lmcFOYfXHRJ4hL3JqLLzulwbaifIqC7kAANK1d1M35V5nSYGLaWu6NM1Fh57yik +XF0LXEXIeK5CKyDcwdhRICgzb+tuG9Oju6r4SqLiEqVHZx0WXmBFHwNs9XpRfrPWPrwsBalWh8BQ +dEQ0nMx0v/PXeZ5MSkd6CF4LxRbIOC6HctAUeq5zVPQ2CUmJXGymba8CLctPPlep+rp9m2IIrBpy +NUjLKH/dvXeADbCQCygvMHSoNs2KLdUwMMLOwzdTPQorTkdosLqQ3WOTnoESrl17YZw0KUGgFMjs +ffuOkalWG3KcnDvbNaIEeLcSWU3IBDQI5Urd6fLLpPg2k2yyssNShJ257LrMwyNUIl1dAon42EAB +qFDL85bLmFbeLX5atBMDFTQmRq0Dpn4UvMFNsQEXBkHeihC3hBVOa7dSINJVuuw0ATK6ys9Us9BV +6suCQOTgMg6ZcubEbcevOzyGQpeEhLaoUiHnRC6HUKAEoVXrSVDmyla0ZnssiYnc1oTdyBMQKDtc +g00eM4ZtOcZ5m8VLD1PbbhZd4nNM/6vZ3H+Z8vB0lpIsjwdNRdfhZbnSfm+mmLbu6su2iImdJ3eK +5oNbQV0JfXRJxVvmvCtxSFyQHpHsI9ttP3TQwejfdhAjJCYscCFyqAzIXUWO0dmn/rmTd/hkM8q9 +1Yov7fBu3faNR4Du3hqcRj5Mtcpk5a28hhpPReepceJFw4e5Lc99F2/K52RQVNoxEK7is9ipmXT+ +5q8Qrl9mpfbVJilhmNSlQNaPiU1QKzb85kCTE1kui7v+mH6Yuv1Wb/vCAbdkO6IFzLl/Fw64pYq7 +F23zwpt7yWAT4mzzhZakg/JU9h3FLMX+Lfp9MIhT4VVlZsm+IMzaBFJ7rAl6i/guFvUnESNTsnRT +9G360oPpgKiyQXdUw02QkMG4qATk9C3xdllI88dYYrctugc1vx6RXbPwf9cir8JjgTVGdZliFM0y +wZZ/3b2UCovcWgUpqPRTAdk5TrRaZ8qkmqhTt+WwThfq3xSl0I5tmQts6B7UPogiLzUykRtSFCuy +Wjgu1+lagIMsIHaONaCuSgmRgrJxufu6jULDpv0IjZbZdhVdl9vuRU/37YUDhCNXBXdWq8OEeSad +CM8aHeb/SgVSFfgjN9GNRUK19m0BjMs6CDxxsHtPGGneVYGZ3fMXFDEr8MWpCiOuPpH5qZuFgmRW +LIgUlWJ/WPSnSsL0Z9aEUYR7SioL4s69WrBRdbq8L5aDILJuu4/Vmmj81Bblj6sXOlO8c3iJjQIw +WOjBkmGPHmasC7dSEV4i79xKxVb4KIuArVYbq+/MIlOlY29DrVk7CU6/GrNXc9g36fJu3uSYLWRE +Pfi05x2/pSOEsqPq5XvzdBTlEhrGpDPZaviw3b0+RLJn3U61eLp6gtRDgOV5Q8SpTvcEyWt2sfcZ +ZZe7x170M9Ta+MybCviYAx9OGwuv3fBoMLmiqXmNKBMSj4SdwctJLc2/9IgqJ7wAFuuzjW3nhvAQ +9aAnzhV1PeP9PHfbe2C1OyKLMcisYmA+USVUeaa9tqoTUiMfQ7+5hakYiyWCsFzpGhk9q2mZsL6u +w70X7rfNuYi56cPIjqWemqpTNa+3ZiuFrkNxtuYkLAbDYcm+zYAT/nb3SLquCo+o18CKre4oJ4L6 +c6o6atmmOnMVD8tNUx3bZsE/VcVshsTTQnCxim19TLfqZT8vC21t0e3DuNRqhsP8zMfUkowCYCah +S9unbsHj5+KeUXYtkcfW/dg0eiRMm9Fdky8gqKmcJyVRu8r5IgOEPKGmCyx7hsuXyzOcmPkuy4Hf +blG+Y7ksPo9F85tPQCt5+QNKoVc5s/WErHl7SohUJk/2cu9iitBfqjpWB5san+j8ozhZaVccS+Ut +qcfbo/poZ/VQUJFvBj9Cok4eHeWll1Jkp08r7BiPbE1gM61GSQp3UZIl4K9d0ioasCqqdy+OYWLN +CgYqvE9eP7wOS+tsni1FqJwdOl96KKij5uqYDVRGr9fwMWtvpG4jLWuLa/nqehVDw4KnPrKBKu0C +t9MPyzcuTDiruMz3ZqcqOCue0Zl5k92CVUQayIqrV+EyvLQtTtSs84rcp60bnoOKnOESLRVqq6G+ +n/0pWTgyOVYEE7oT41TFx3ozD31XJFAVuLQhYrhidV2tG+zHuLnmvqjDQhKlR6hieK+B0twauARH +r0BCkQxsKjNTC8i+qf3JHAJWcArn6PY4NtOFGD15qs5X6ZX0d9ldScqqWaxUHXN0XNhTJ4+UoV46 +oqy+lnwP4WRut2oX+Y5mrVWWbcB/zanLethMyVg6GxjMZ9hj/G09Pmmdylp3NWK6RvhiJ1rlimnu +WRvdwiZV2lJb1iSoJIa3lnpH1Ycoz3a5KjKhb7WtaE3Ui5RDHji9PnA3whfvhlVG7BZMJkNrzgeR +6Cws3CXAIMbGbShDPkuOEMpa525ZO5vtcWZbENTMbEZG95+bcbP+r1XNf5cNett2cCBbVnUjUg0g +if8WEz5pa3OjhJZR89Tps5iIbCRZTw99sVz36Cwljy0tiHPzbjIeMToN9EDoXaRXiL6qcymu3GUC +BTS9q2zjWX3lqZA/wP1nNtfaX+pcVZukzgWq9KiP3SzhTtmTeMFIszENkyRYws21pIQ62qR3SimU +tR3f9pb8l+GRqMCB4lY1Q1/N4nbMiEazvG18EU+/srCZHy8tlsXbMPTtlJDz1nUTq9HscFglj0d1 +LvdyPcxBVMcmqctCdOqqRjP2tof1Y2S35IDSE2BqdKipoUhq+/JXYPrnj33/dqXlf5dPK8JGjlyy +//tv7I+q96Q6hsbUtbjI21+F2V6nMKtqQS8i7eOnVRTYpKc++FzW1f79rP8kJGle39UkdWp02hS9 +RARhzopi7RchRaY1ssgYaHUgeqnVT0ec1miTMRp9WjdcuM01wg70ZtHD1c5TMTWGO3ZddOmxWyBW +1LzbStq41AP1ZjlE4vgt+2BB8OF1IIHO9zMlqMw1GrYpZ1OZIHPamYVW+27KL+p2wzlRUSkIxNVv +0bFbWAtxpDIdaLWUZJKXuRxSRPEmVSnQ4wkuhgDI06zqbvGvk9QxcZ1o97YGI33dGNM7lcSEJJj6 +1JB8WGkZ4R/e813Ff/ZGy2Cn0alzLcO6a0PB+317M3kaNgND+3lhXX3SeuamZ3ogocE88cOuxrF9 +jb/tLPKw+5pGrknxPmFXGDWnC0PQfJ3ldRipulNb+2IzctPOxlWdMchLUAwjC8BOV86RbIq6ZQ+L +IKkMlNUI/UNtfKYC450icqUuvBDk9C3Aph6s6e9lrsMKK94gDW+7BBKRf7Y89o5QzHGdZsimdQK9 +N9kXtx7y8JqySAoApKHc/7SSF1HvJZIeW1cugE4d7v9zz7QlaJFR5amtm14lG/G0SKz0qDmWz6qg +bhU2/CABcCkeLOiMKVRPvx1/93tZjcIdjxbjqu2NlE927Uh2HaQcA4blehZNDD1QpAybZxe/CfGt +2i9KFXFTmF4gAlMwpvqSMLhL7yVSeRgehFrTHTGrlstLjm+bxMJkti1CM5QjFgtTMVkSX37Pqr9v +2YBkvz6e4B9d+aTw2q7GTgv2WgUsJbebtDZsTSY4p0gfy98qUY3Vt19l9SW5RoMPjbRqL1Pvq+TN +Ix+3elORiyHleRa9vOV1K4Z6WkOupT3wIdWWcpu+9k8RVmyXdL0thkPBhTSC6EqWuMa2mW7P5vWy +Ho4MxRYyvad16KlbVDpjzYC7FxlxxDyWPTv2TnOM6JMQoh0DWRWhHomIdsswU1m/RN6OFA0xJIzM +WFQNqp33uTT1tF0mzLTvc+J0c1ENooG7BUzNb1pMqv715H782ceIsqnW17JYp4CNDhJtVsSxOMSZ +A/WYT6+CwLJqD3Z6kDbjo6uKl85gUxMx7R5atVjOEQX/WJbMYp6hJijqJx0PFzFv1Q== + + + 9PhuG9Urrx0p+2/JDAn87WYWY9OROy8rX2JHoeQq1Ub7mZsRzJL4QkX/Ih5B2yaDDott5hk9VH3K +MtQkWGTkBFGAqipKtoYSceNAVOdl2S/7sKNnvFIpe+LlV5SaUlRALmfVj1a/v4tHgEQenX27xE3Y +O1I+r4hR26wAk02R+HRhUJItZ7S0ej2BZBEUleWtUuyzZ6jZLT/Fjva0nVEeGCmF3RYD/W1F5VNt +X1jppyJWbj9pMclgm7R79OnsvUyimxfVo9VydOtZsPCZND90DRFUphT/zIgKG8C2OS1e+ipq4ZUQ +4Kaw+t4jtq0UV4ZF9BpLs7u5SykfieoXftfSimUu8Rhm6gBUtUhiR8KLfbGIJbfb6uLC4mPXtXTG +gcTWLrUTn8I0DANhmm1EoMMsaSN2w9ROqodXEk+7tZP0FMO8QjeaU60ejQop3SQidRqoedsI2Smk +t3lBk82tt2W/lelRSxMaror+4sDqvQVcpy5kkoFnzsrEg1W/ZXXyqxIeVmS4qe+vW05EygzUVe3Z +7XvcHjKA8qSGWTyKyxVDrYEOjT7TNqAldvSk3pYpl1lCVUeq1i0WC7BjliPkR3OvqYq13XolFPs+ +F08cHZ4SfE+hP/9STlrbKkKPbvF1L38CWnRpfjBw8RVSeUylylvfLtKFRWLdljWle0Btlpj7agKs +2jzp1M375Wwhj7qHPDUnb5GbOfPwGf/Z+BkqzjQrlYTLzLAqBFZbVRAsoMDJ6vko1aEEGjlgL+I8 +Jm0UNtkmn3EwbZxWtbBE5d5F3oOKGp8NmmXA/HLpw7osu6g4niwKyxAgMgQcxTirySSOHafMan5C +MOxUwyBBNjtzZanQlxrNq1nIy6/3tj3uujmnhifTLQLYLHYzLG2eMs2sRNZiKuwUBUkuCqaF1QJb +jFR/2jhVSPnMQwhu4/1Q6KU8Ru9eHqp+5JZaEZcrCS+RjaHa71kvUAvsm4kyKLcZBvu6kHgIK82W +Lt1JvBVVkNtFVtX+HwMgjNK/I49JIY0Sftqyq5yqRXXuvIm3IszNOo8Wde0TCVSby+4SZMNCGr9l +KmmYF+/v7yHjSpL9kBbEEUINbsnbqpK4cSANA1KxNY/gsJIpzYbNQmkebYoAO6FOlRKsoVxDTFQF +O+tpUqKbg9IyTuVxyu6aEWSaLLXePb9MxEQZZ04dQpmKgXcbYyu1Km2JSoDV+9k1UMg2hMV/6GZN ++TILn9gOz0Rvqp1os2W3vI2fmmaiddwRIuz2lqw+RaKys+3XsPj10lHcy4GLiVywM0ZJLA0qjBz1 +YG5lnCvrv5oyEgW15nNSJ39sbVhyLDRdWh6IVJuKD4jfUcU8LCzwo7d3i6wMoj1WjXxESfdufRDc +XdV5psUvdw192DgwOiFssg05zt1ViUeTqvQ4T6ciNL1pVOi5xmsT54EmXuXSDxfDzDNNy4APVNUP +seTL+aNalHWMLWabtdb76x2C4Of5j1w99DZJQ7xVYxTezZ+dLNHi2C/Xukmzyss06VO2Q1nxZNks +PeKnppmuIFVMmqtIitHKXxE9wJ2kOvcYC1LzNwuzxIqRBAn53X3TikTPTfeOvjZqXpvHLEWE3k47 +UMsFweebmVu/dLWC9jWjMV0VmVovVeRtPGapClIQv1p5VlpY+WKfM8zqj4CXpRiFNhLei9yF/rqn +7uTxaNoR3c3n7SLJkpq63DFaNoveWU/CFs4XPWKqdlIcDb8NcVn1uVPexNaEhcM/fpk2K9qISmQj +DyQoYlUw3ffhaanTQ5oleiTlkDaqSIR/M1ECrmP1SpsfYxNqO8n1MBo6ypbKsT/faYomZB6xoAVz +BODOtKNcuELatpG8TsPfhSNrL1eYKTdZqQFWWw2LL01T97GaFL6yC+4+nz7VyrydfuDe3XKG5QzL +lSU5roVmtTuL5b8X7qpU+QmqyGIlIi60nKeqh5NqktUOU2IFwy71t8etX+x+SBDTTlu30Pe+DAbH +TtAWkJa7K4810D18lI2fpV6bg6mwqDLeDrxvWWy8Edm/pjPtRUK29aZCYLZ0k5jrIUR0Wn2I71Nv +F+5oqvhTAzv5StJjiFETmrfaFcSgIk2HAIye3XqYmDAW21qqJf6aLZSVZLGpmU9JRtk2anFlCxS3 +CfhLuUUCgvTZRCOHapG61ABdO9J7k6UwT+E64sy814jf3ykLhdt0KvBqIo2S3yaodsQGhdWACoxl +0vfFaO2BfBguEGsBOyBlFboZdIelmJ/1zNLieV4vZMIkN8a0QzczgRvp5l6+hJzS3o9X9zqtMlHW +3Q7bKIM6ndmziYD8fDIflEWqsprW4qn6Ek6jAi8UPPXBLuk5+WmsY4QezlAyXDZXGnDNABlYXO65 +gDoPU+GJ6rW10FnnnSuq2w7Y/vad3ekFhX4QIZarhfySTy6yCAI09qFuvW7XDDqbxXfw21cJ1fGS +PU63DEdWUXW7d3kYd4k0NcueJtAwhAzVuJmnJYJViExI7GRhoMRD/krkLqzrbvp50rTaratrO72d +/DaBBrbieCpq3suiK58PMRIxk2HVQUo46G+io7Tz3UMS/bTXlTYg+VTX4hANdYA2ixDYFjws/sh9 +Ws7jeLKqb6MGSvuBsOiuDDV5t6LjoKCzvgD1umb9kfSAI1XXJvFX6qEUXwyrBXdviVNZBPbyTSV1 +NneuJ8TINYAWz/EqwKsKuNw4hSWUcTMuLDCGwgsS6rlt07fHNoaEO0vr0af6Jawmn9FdjA+E+OqH +afRslotTn8QAEWw+Q5BJJUaLgRVemToVJG5ei90txpNPUOGFXfOQ7l63QLSyWvE3tyvjvG4jD36r +pu72tXiPua95sdY+tZPtViN0p1U1n3jqzPF7m/6+bZbLSJes0QpFbErygYRXccqY5Q715dxTzkwj +bFMzkx/2TAYquWWNaZoMV+t01A/Zs7iOctrDrNqZ3NarTQiV2KNOE3d2M6JZnqZtqvpv6ABEW2Gx +22TNc9JQ4Odt80YTWqTO2/+RN8oLMrP8I8l+59/nvHuSdRsSuio/VZ7UJjCF79Te7QZf67xmP45C ++ZdQP5IUqi8iBEAxyu7FIrbUqa5RL6QnHyliZH8hRdTVgsny4nCmrsDicpjmy81kABUDle/CA929 +qopuGxnOKTyuhToP27w4VXmYqw/D5kUlfl5Yu7X4qHiHMqLNRVz0fepsejyHOU5tvW9RPEwUV0LD +rhkvg7pU1jkDj5V7xW/em+mhuH7NEWFy1YyRycd9yjizdEI3b1tUsdOlGEbkB8OAJEkKD6T1cnWR +SGKhtsjSt0v8bTL4ec0m5HHYYpUKpNekhwvxSY2MzW6APTys3vAnHcQ/j0+TWrtCIHQu4SQeyidr +R5p/i3aQUXkzrk6xooRPvkMq2DJhKGOzjKWW8oJFGwSPTVrZhBnuMR34NsWtqPaq8ZCQt5QLHCXE +lkI3Qk1/gVHeNi/M3TePBlO/LUGF5slC3lYK4NRP1/cRPtMkTBgWERf13iJFupkWjtU5td0oSmym +1W6+WiUzkVfWGOqObgKqYciQp7woN9IOY3KXJKsFN7pCKHO1wIudl2auGQAy7T+uHnhYDT3tpgJM +iDLZo3BLzVPNddoI2gF4vNU7sXt3+zsQ/fMHu63c6XfUPP3xH+kc2MqxW5xDe/wBJMg/mC/5/cD/ +7C9+9dcGCfz1fyUC3X/yt7/+N3/zO5CU34q0fheE7rNqC+j1G0qHtUDpMBQoXZMy8geUruH/FChd +s/zYBKWD7v4FSge8ukLpZClQOjvmA0qnzytQOiwVSoflC5SuAYUpULom6uoMpRPN+hNK19ja6joc +Sve8+hVK15Q1e0HpWgocBpSu0VVfoHSIEX2B0mGuUDosR9smKB2W51Z8QulkLlA6WfZtgtLpw7ZW +oXQtpeQCSge8/tnpJZSOXPULSrdeZ4HSEaerULrJMrPPJrND6ZB6epbqCUpH9OoLlO5xeT+gdFxa +hdKtNw7L+Qmlk3ltE5ROlgKlw/IFSoe5QOkwVCgdlmdx/4TSWX3ADKVDz6tA6YZhhtKlNaB0/PIK +pSNu9wVKZ2qhM5RuVXvnDKUblvpg0mxQOgKGFUrHM/8CpUMDpELppPZxfTDpZCxMOlkKk07R3UWi +eDOTTubznph0WCqTzgolXkw6lG4qk25VhHhm0hE+fTPp2hqaPWFusNpnJh0T5JtJJ+vMpMPw3LbB +pHtNyGPd9DqtTpTzzaTr9OgXJl1vvTLpunRYK5OuR8l3MulkKUy6rpLoF5OuU0tTmHRYKpMOyxcm +XcfbL0y63q4PJl1/5uAvTLou/bGJSdfVRDcz6XpvbyadjIVJJ0th0mH5wqTr6gmZmXRYKpMOyxcm +XW/nB5OuS3ppYtK9n+eP+cg7hfUvJh3WwqTTYTOTDsObSYe1MOkwFCbdM5d/YdI18fYGk66pfnJi +0jXpJH4y6RrFJjOTjnWzMOkajLf1+GDSYV3vazDpZJiZdK0vX5h0WJ8d3mDSYShMOhleTLomCtU5 +mHSNVOXMpGsUEH0y6Rrij+s+mHTNxIwHky4NhUk3rJ6Ga8GQCtic5oAXk44ppjDpmthEx2DSDcPE +pEujM+n0W2YmXaPU6sWka32vTDoZ+j6YdDrvxaRrkgqYmHRNJJjBpOPvN5Ou9VaZdE3lpROTbhhm +Jl1ag0nHxxcmHT7dm0nXUG2amXSNUPjMpEtDYdKlNZh0TSp2E5Ou7ecXJl1T6H1i0jWKo2cmXWOj +9GLSNfIIM5PuGTGVSdfu7QuTDmth0jXWk5lJ15flC5MOa2HSYShMui6l6k8mHdbCpJNhZtLJ8Mmk +a8pfTEw6pprCpHvNgGM9pKbmzaQjIVqYdBQPFSYdokpvJh3WwqSTGNPMpJNm04tJJ+vMpNN5M5NO +n/xi0rG3Lkw6NvKFSUey982k4+cUJh3nFSad9t4vJp027TOTznbxyaTTny8mnawzk06GmUmnb/tk +0vGTC5OOqy5MujTMTLo0BpOOwEJl0nX0Wd5Muq7VdGbSdbo0ZyZd7+cXJh2HFSadkMaFSScO9ptJ +J1xxYdJxKwqTLg2FSZfWYNJJe2Zm0vWQ3C1Mut7vyqTrZLNnJl0aCpNuWJ1J19nUzkw6INNvJh1X +UZh0fV8rk066Li8mnawzk06GmUnX9/aFSYe1MOkwFCZdVzndJ5OOyypMOqGwZyadjY5PJl3f9sqk +M9b2xKQbhhlVNaweUO/q+BxMOr7/zaRjGBUmnQjYM5MuDYVJl9Zg0nU1nExMOuHGX0w6HvvMpGM7 +MJh0+Vdh0qU1mHR8SGHSAY5/M+k6cYSZScfLUZh0pi1UmXQSIZqZdBgKk66f7QuTToHKmUmHoTDp +dMQnk46IZ2HSdTW/Tkw6NIJeTDoUrQqTjpm7MOmGYWbSDasz6ZgUC5OOr3sz6XQRM5MOw8ykk5LR +i0ln1olJp9NmJp39uk8mHatMYdKxgBYm3TDMTLq0BpOuazs9M+mkuvhm0uk5FCadVA== + + + tGYmHSpabyad1KdmJh3zQWHSdeJvLyaddlgzk45tTmHSpaG+6GENJl2nrmZm0vV1/8Kk68tZmXR9 +6ZVJ1wPMXJh0+Ggzk64pkvHBpHv2EYVJ97jelUmHZ/li0sk4M+nMMDHpzPDJpMNamHQyzEw6GV5M +umeNr0w6DDOTjr9fTLrGvD4z6RqyUjOTjk3Qm0nXQkQrmHQYCpNOm6cXkw5rYdKZYWLS6TziM4VJ +11BrnJl0TXJsE5OO2PKbSceuY2bSER4vTLo0FCZdWpNJx92rTLp2rl+YdE1CxTOTrtECUJh0zwV9 +Y9Jhrkw6LJVJ19T28GLSYS5MOgwzk04HvJl0TaJ4M5OuibQwM+kazaRvJh3myqTDUpl0j0vwjUkn +c2HS6dSZSadPfzPp+BmFSdcYzIVJNyyFSZfmYNI1rWATk65d2xcmXbt7ZdIxkRQmXRoqk26Yg0nH +1qsQ6BqVC28mXaMQojDp7D7OTLphKUy6yexMuha1us6k0+95M+lkLkw6LJVJh+ULkw5zZdLJUph0 +sryZdJgLk46rLUy6dm1fmHQ5TedhzFYzky4NlUk3zMGksy+YmXRsm78w6Yj2ViadopmFSUek8c2k +IyI5M+kUypyZdGmoTLphNiZdh8w8M+mITHxh0mGuTDoslUnXUiisMOkwVyadLIVJp1PfTLp2tw8m +HTeyMumGpTDphjmYdLwZlUnXzvMLk86W4plJR9inMukmy2DSDWPgo5qK8WcmHZPjFyadBl9h0vHW +FSZd0w7gxaTDXJl0shQmnU59M+lkLky6JiX6mUmH5QuTjqurTLpGRq8w6SbLzKQb5mDStfP4YNIR +RfvCpGv7+cGkIzhdmHSNff+bSdckmTkz6fBJKpOOEOObSde244NJ17btg0nXUqi+MOlaOz+YdGSY +K5NussxMumEOJl2zNNhg0vGlbyadktqFSYflXJaJSSfLm0knc2HS6cMKk06/9M2kI7RfmXTE6I91 +mZh0k2Vi0k1WY9I1ZX0GbI5A94tJ1yiEKky61u/KpGv9+sakw/yFSddMCbcNJp2c0cKkmywzk26Y +g0nXCM4WJh0TzRcmHct5ZdKxE6lMumEpTLphDiYdM3ll0hF0fTPpSMhVJh0RqcKkIxLyhUlHkK0y +6TjzC5OOkExl0qEtXJl0yAR/YdKp0bMw6UynaWbSpaUw6dLqTDp1O01MOglIv5h0avGcmXS0XxYm +3Ss+PULXfxCTrkdPZWXS9XX/YNLpwMKk66qafTHpOl37hUnHhrky6XgEX5h0MhcmHZbKpMPyhUmn +h1qYdFgKk06huDeTjuFUmHSd9Elh0hHV/cKkIyZYmXT9aB9Mun7c35h0xJxnJh3xn8qkI2TyhUmH +uTDpdNzMpMPwhUknc2HSKShTmHRYvjDplMsoTDqr4puYdJ1/eTPpRMCYmXTEqyqTTm3XLyadCAWF +SUcbd2HSdSWIX0w6+rork06/ambScbPfTDqshUmHoTLppDv/ZtIpeFeYdLIUJp0sbyYd5sqkU3d5 +YdJxh74w6YiNFSadSBqFSQej9QuTjobPyqQTbqMw6bi7byYdwbbKpEMHvTDpmDm/MOm6WuhnJh3x +uC9MOsyVScdLVZl0XWKTLyYd5sqkk6Uw6WR5M+mUHZmZdFxGZdJx5hcm3bMafDDpuuqwZyYdM+Wb +SWfz58Sk0xRbmHTv2XlM7z8zk84SFZ9MOqa4mUnXA3gSTLp+bm8mHcbCpMNQmHQyvJh0sk5MOjtq +MOn4+82k0xQ7M+m6opYTk65LVPOTScc8X5h0WqdmJh3z/ptJp9VgZtJ1lTJPTDoZXkw6rIVJJ8PM +pNN5LyYdjk1h0vWtVybd69n9+LOPEhzfL0w6zMe5T0w6ecjbNjHpsGzX+cmkk1lObTDpZFHNazDp +9GHHeX8w6eROFyYd9S6FSUew9AuTrik/NjPp2C8VJh2VOpJoq0w6zOt2T0w6lfQUJp2OWfYPJl1r +1weTTl+xXBOTDktf708mHYUmlUln28CZSUe89wuTjpqRyqQjiF6YdE2a2i8mHcH/yqRrkbZPJh1b +hi9MOvbjlUmn4Gph0ilO+2bSEXqoTLqWTOxg0jUxbl5MOoVECpMOS2XSyfJm0mGuTDpZJiadfdSL +ScfFVSYdt60w6RTAeDPpCCZVJp0CljOTroma88mk48TCpOOxVCYdId8vTDoCFpVJp9ExM+nIinxh +0jVyroVJRxipMun49C9MOoZbZdLxYZVJ10hiv5l0XExl0il4NTPp+NIvTDqZZyadDIVJh+XNpGtH +r0w6u2czkw7LFyYdF1uZdE0qJROT7j15/vzLOI7am0nXxPTug0mH2zMz6TjgzaSTdWbSYVAxfzDp +MBxEJwuTDuuF9mAw6WSYmXQY7uU+K5OuCTM/Mema4FxbMukaHtS9fjDpVCI9M+koqtx3wq7GpCPy +82bSYZ2ZdE0SzROTToa73ZVJh1USo8GkwyB512DSyUBxaGHSESNa9/VOJh3LV2HSkXt7M+mYEQuT +jpLYwqSjAO/FpCPnUph0hKkLk65p4/fJpGMWmpl07V4rk07T1ItJR+qmMOmU6puYdGQp30w6Rbpm +Jl0DCrccyaTjUb6ZdIozzky6prrfiUlHRPTNpFMbzsSkI1ZbmHQ4Bm8mHacVJh0TVmHSKaL7YtJh +LUw6rqow6WR4Mela6PoEk87Om5h0fPKbSdcClh5MuqbodTLpmlqBPpl0mn1nJl0Tln1i0jWBlD6Z +dMxvnbc8mHSqJX4m9GTSMcKZ32cmnaKiM5OuCTZxDCYdV/lm0rFqFCYd2eXCpCMt/WbSqYZhZtJx +XmHS4Tm9mXRce2HSNUF/22DSMdW+mHTsnAuTThPyzKRrbf3CpJN1ZtLJcKyDSddUyb5/MOmwFiYd +l1mYdBguPy03SzSNFSbdKkWJJZl06rZ6Menkls5MulWlvttg0hHieTPpFASYmXRssAuTjnjA0tsH +k07W8x5MOgyNPEEw6TDIYy5MuiZ99cGk4+/nogaTzgwfTDqd1e7BpGtiqfXBpFO31n5+MOkItMxM +Ojy/iy19MOlWJQ4/mHSEegqTrql6dGLSKTbxYtJZ+9xg0nFvC5OuKW39yaRT1GRfJiZdS6XYYNLh +w3xh0qn2YGbSNcJVM5OuSRf9k0nHAlOZdMr6FSadOdAvJl0L1mEy6XDAvzDpOL8y6XjhK5Ounfc3 +Jl016xU/o9/HmXQtqsoqk07mwqSTpTDpsHxh0mGuTLqmGu6ZSYflC5OOJbYy6VSXUJh0LPJfmHQy +FyYdlsKkw/Bm0mGtTDplu2cmHYYvTDr8j8qkw1KZdDguX5h0TSyeiUlHCqow6ah6ezPp1IRWmHQU +ElQmXe/bNyYdOaLKpJtyE86ko1r7C5OuCzU0M+lkKUw6nfpm0mGuTDosE5OOP78w6SjCrUw6hYwK +k67TC/Nm0mGuTLoukNPMpMPyZtJhLUw63crCpJPlxaTrSsdOTDqSe5VJ18XO/WDSqSSyMOkYL5VJ +p3KJN5OuKfo/M+k4tTLpuhqTP5l03WS5BpOOhsTKpOvr/Y1J19vywaTj1Mqk6zAG30y6jkJaYdLx +2yuTjnrQN5MOa2XSmWVi0pUTB5NO5sKkw1KZdFi+MOl6aF4lk64vQSkKJh2v7BcmnapTC5NO11GY +dF3k5BeTTj2aM5NOvQaFSUe/5otJx6xQmHTMQ4VJR8ndm0mnHc3MpGvR7RNMuu5Sa4VJp0loYtLx +rs5MOvWKvJl0MhcmHZbKpOsSQn0x6dRWUph0lgOfmXSyvJl0tBcUJh31/oVJp1Tmi0lnEfqJSafG +p5lJR+buC5NOcpmFSTcEmJ1JJw79m0lHarEy6Qj4VyadoY9fTDrjJM9MOmUQZiYdX/qFSacy+sKk +U7dRYdLpet9MOmX6CpNOlsKk06lvJh1anIVJp16FmUnXg7JTmHR97x9MOmurmZl0ZHK+MOl0amHS +dUUCJyYdPOovTDoupTLpuly6mUmnNPebSddFCJuZdPStVCYd3R5vJp2q8wuTjsuoTDo6Lr4w6brg +NzOTjts9M+nUdvZm0lkP28Skw1CZdFi+MOkwz0w6NWUVJp0sbyad0umFSWd5tplJp7aVF5OOH1+Z +dLwbhUlHhvYLky453Mmk47MKk46L+MKkM/MHk47Uf2XSMegrk07diG8mHWnryqSTxnJh0m3L9oVJ +Rx67MOn0iGcmHYP5zaTj5ShMuq5hODHpmM3fTDrVJk1MOupeC5OOdf/FpKMWqjDpumbrTyYdHklh +0pENLkw6jngz6fCRC5OuqUJgYtJR+Pli0rV9rUw6ojqFSaeu6k8mHZmrwqRTuGJi0r0C0z9/7Pvf +K5NOdQxvJp3qGAqTTlULM5NOhjeTrqv9e2LSMToLk47eyjeTDmth0skwM+nsiE8mnT5tZtJhKEw6 +DG8mXd/uYNL1/apMOmblN5OOBaIw6ZgSCpOOcrY3kw5XoTDpqH0pTDpe/DeTThUxE5NOZS4zkw7D +m0kn68ykk2Fm0umDXkw6iAKFSUe13syk22iteTHpJMEmGc44TBuKYzDphmFmog2rM+mk4c/m2HFz +4iUc42//tsWkn+Ig2s1mJp2kuT+ZdDLOTDoZZiYdhjeTDmth0m2IVs1Muk0+/AeTDh3xmUkHmmFm +0o2/ZyZdWoNJh9Y9QufBpEOZX6GJwqSTPL8FNMyKlr7C4MGkS0O9/2ENJp3RB1oy6bj/KuuemXTC +IFCSFFA6CAXyJgqUTlY0EoJKJwP+m1Pp+FtLz0ylk3Fdk0onggbb66DSYZC/Uah0DBxFiYJKx2Mr +VDpBNl5UOtbvQqWTDzFT6dR0+abSyVyodFgqle49r/6+hePfmUqnANuLSteUtp+odITnCpVOC+uL +Sqf02kylk2Gm0um8F5UO60ylUxR1ptKpXetFpVO8cabSUXJRqHQUa7ypdKh+FCqdWu9mKp1a5V5U +OllnKp0MM5VOpRyfVDqSNBOVTq2EE5VOOZwXlY4Kh5lKxxMoVLrXk/vxZx8jyqe+qXT00VYqnQ4s +VDosX6h0MhcqnWKmhUrX5Ne+qHREYCqVrhN4KVQ6dK++UOnUx1yodCzHlUrHnuILlU7mQqXrUq2e +qXRYvlDp1H5fqHTa0xYqXQ/V8kql08a/UOnYU1QqHZubL1S6LmnVmUpHTWCh0qWhUOmG1SsKJIxQ +qHT9yGDzTKXrSsvMVDrVJU5UOvv7k0qX1qDS2U+aqXTMql+odDIXKp0shUqH5QuVTlvAQqXrx1mp +dJJufVPpul7jmUrHHr9S6SbLXOQxzEGl40srlY7b/YVKJ7GNQqVTdG2m0g1DodINc1DpVD1ZqHR9 +C03+QqXj1EqlU6yuUOm6Ih0vKh3xyEKlIyJcqXSEfr9Q6RQRLlQ6becKlU5ZkTeVTuZCpcNSqXRY +vlDpFLQtVDpZCpXOjnlR6QhYVyodod5KpXtPoT//Uk5i+wuVjrL0QqVr6/lBpaOb7Q== + + + C5UOc6XSNblcM5Wutf6NSifzTKXTmYVKp09/U+msRmCi0jX13s9Uuibq14tKxza7UunI/1cqXUvE +ZqHSqdSmUOlkKVQ6K8d5UelkLlQ6WWYqnb70TaWj3qdS6XgylUo3LIVKZ+aZStfMdQ/kHNXAn1Q6 +lSENKp2k0WYqHaWTX6h00pgoVDrV+01UOopm3lS6FHnIw9r5QaUzyweVLo1BpVMpTaHSUar0hUpn +ZZgzlQ4/rFLphqVQ6SazU+naETquAZujYvQLla5ZpOuaD1w/qHQqmnpR6WQtVDpZCpUOy5tK1xR2 +nal0TfHUmUqH5QuVTkGumUonjb5CpbOB8qLSNamOz1Q67kil0k2WGTs1mZ1Kp2rbQqWjBPALlU6d +wYVKJyHHmUqXhkKlS2tQ6fiCQqVjZH+h0jEWKpWODUal0g1LodKZeabSUaRRqXRNTYEvKh1l7ZVK +16IXIql0EuR8U+mkyDlT6STAWah0auN9U+kwVyodlkql0zFvKl3r2weVTs0LhUrX2v6NSsfEV6l0 +KjArVLrJMlPpJrOodHxUpdLxnV+odLqUQqXDUql0srypdGaeqXSyFCqd/dIXla5J5Hem0rEaVyrd +ZJmpdMMcVLqmGMVMpWvimryodHo0hUpnMskzlY5axC9UOl6aSqWTvGyh0rFwfKHSaSNaqHQUs1Qq +3bDU6SHNQaVr9/6PKpXOZAleVDoTc5qpdGhbzlQ6EvRfqHSmHjVT6SJ9Xal0OLKVStclijFT6Wib ++kKlM/NMpTPLTKUzy4tKh59dqXSyFCqdLG8qnVLlE5WOvyuVDrf+RaWj3qZS6fp+flDpJDf3ptJh +rlQ6LJVKp83hi0onccdCpSsWdevrzDeVjtRBodLRwj5T6QjOv6h0bKMqlQ5LpdINS6HSmXmi0nFj +C5VO2i0vKp2qkSYqXe9bpdKhrP2m0mEtVDoJcM9UOtrMX1Q6jIVKh6FQ6XTEi0onXZuZSkcir1Dp +KPJ5U+mwFiodhkKlw/Cm0sk6Uel02kyl0we/qHRdu9+JSkcrYqHSyfCi0uVhSaXrWugSOCcF9U8q +XSfEP1HpmEoqlS4thUqX1qDSsUUsVDqJQbyodJT/FCqd7tJMpUtDodINq1PpCIkVKl2P7MVMpZNx +ptL1dSlUOrbin1Q6bIVKJ8NEpdPfLyodH12odFxipdL19fpGpctpOY9DeaJQ6dJSqHRpDSqdfcGg +0nWVp3xQ6aiIKlQ6C+4OKh1B8S9UOmLOlUqnAG+h0qWlUOnMOlHpVKA6U+keD+0LlQ5rodJhmKl0 ++vtFpcNaqHQyzFS6Lv7mJ5WOJzhT6frSC5Uu/p6pdGELKp0S+jOVruOtvah0WmFnKp2qPicq3fh7 +ptKlNZqhuoTxJiods9ybSqcRNlPpmAwKlY6A8ptKh7VQ6WSYqHQ67UWlk3Wm0mEoVDoMbyodVzWo +dGqMn6h04++ZSmfWiUqnAtSJSqfw3YtKR/HHTKWT9u9Mpetqmvyk0kl7d6bS4UIUKh3RzTeVru9n +odIpBjpT6VRX9aLSER4vVDrEGQqVLg2FSjesTqVT+c5MpdP3fVLplLufqXQYCpVOhheVTtaZSqcP +mqh0WTVWqHTEmQuVTuVOM5VuGGYq3bA6la5HEitwcwS231Q6lZHNVDrC/IVK11X88Emlk/VFpePT +CpVOTuJEpcu/ZypdGINK19WkMlPpmDBmKp3Kb0WlY4NQqHRm+KTSpTWodBJknKl0bCneVLp2HpVK +RwlRodKpo+5FpSPIUKh06r79pNLR4lWodMTUZiodlUdvKh0hz5lKR0NModKloVLphjmodBIlKVQ6 +Gk6/UOnUPjVT6Z4t6weV7h2I/vmD3X+i0v3DqXRnt+ruAqWjwoqZMozUA94GSlJy7nT8wUykO71I +JYF0l5dbJY/udiG7iqODsy0GV9DoBN7G1wsYnY7od2HR3WooGSS629uOEkQnL/i4Pjh0F8ABb6JS +rARlpqagnpcDS8jh3j8wdIckjY+BodsPK2cPCt3mxRkVQmeChn0w6MRvWc+BoMNR2u7jg0DXT5sP +E0DHeo6zG/g5apLPvX3Q57C2sw/4HIa9n4M9x+ds61HQc5uHVJM8R/KLmJkz5dDkIDY0c+fYly33 +ldi53XzbQZ1LQ2GbpTWZc1Rd34MkR9Fk+wTO4eowjvKgy0I4SZujc+I4P1hzGGngTtScWLjbNUhz +YG9bOz9Ac1QvSb0kQHPtsK1ucuYYKv1YPzBzzZWrkjKHT7ZHgpURPgwzZS6tQZlruzXoDHacq61V +xhwaK+s+seiWwZZbPm78kjS5Jd6taCv0Go0PltyhEPIgyVGMdO+fKLlmmviDJNfiZQqQHMWf6ydG +jt5vl78wily34MaAyHWTV/9gyN1Wq5UIuRawwSDD9WbdiJUgp4g/Yz6s6L7s55b8OFrrczYLKNPZ +rUs06HHSFDrPhMd9zptjdfNqKt55ifxXdpwejB5BsOOUV7/XLdlxGlfUl87wOBkJFiY8zoZfuwY8 +zkZ22z7gcbwBqlxOeJy9Kds14HHKZy7t/IDHqVURZzjhcZTNKC+Y8Djpey2n5U0HPE4J2GXfBz1O +I3xv56DHkaNT+WPBx8mqTw58nCzbOuhxGOzmFXocZj2dpMdhUdok6XEqGdr800dKjCy99rlJj1sl +krTvAx/3fqQ/jqeOj6vs8oyPw2ohf8fH6TAeWuDjMJik80SPk+q7ktcOFEn5pqDHqd3X5sKhJrEK +jDfR41bVOW5JhcMB1Bta4HEEmmj5CSMJdbXgOzpOHSUoAc7kOJTikNEOcJyU49g1OTcOCYb7qtQ4 +UrPMlwGNU0aAHaIz4+Qp0u8zEyXoVECpOIhxZBEJ7wQw7jgjljSCWugyqp/GcXFSNVpaYpvi7wKL +S6MnxwzttCUDjjee5aKQ4o7bKBNhRIMJGfLgxOXfEyYubE6J4wfcazLiqHsSentGxB2hquqEOP72 +Dnt12XES11r4cIf3zAb27HDRmMDD0RHDbFDocHqDKBJ2OBxqWYijBBsu/57RcGEMMhx7S3UGOvHt +jLszc+HoqKO7NowoxePmBRUu/i5QuDAGE47+bBVUOxLuVs9MBcKpmB5EkPPgCFJ2k2iwvz2eUWhw +RHfXFU/P9/XqTWXTGjQ4SawykxcanFIWuEtBg9NiSD170OBYh4zRPtPgsOrRhsgeBiA4SYNbpRF9 +VhgcRjV3BQxOBt7mgMHJIKD9LGa6Km/Qj6TBMXcobBo0uNeENlY4allUx1locCQiJd0RNDiKdhSB +CRocckZqPyo0OKwrrfpBg5MMksQRnAYntSST7JlocLLaFGgyB5zWbNKUvKE+mDm1wODY0kq8PmBw +7J+tJNNhcORYLQQ4w+Ca+jPPZMFJEhSJ2kRQLi5TUVhw2iqzxQ8WnAzkRIIGJwMfUGhwsiYKTn+p +KN9RcDKwy5pRcPxg7cECBcc160YHCi4NMwoujYGCYzd/yUMKwhvpXNuRFBQc+WvN/uNA0l6LenSd +BUcJVyMwV1hwHKeO6mDBCSWshToQb8JPn2o1nVlwa/Ssppl7oaEeLLg0FBZcWoMFJ80Xde865G2V +1K20tadkAHJ01tMbh5Ee23qi4OLvQoJLo4PgVL/B2UF4WzUp7lcFwXEJij7mYZf11IXkubRUVtuB +Dg6crFqsnAMnmvdtuDjlllbp7bVWOXBYtdMPDhwGvRXBgcOgubtw4KS22wyQKg6c6NMM+gC82dDY +t8qBo8R6v6ajRLc+7sTADcNMhxpWj2DL5WXmCcAb36+GxMKBYwjJpcnDbhdOCA5cGgoHLq3BgRNl +Au8xCG/yh5F6mjFwPHO5vHkUj4OnJg5c/lU4cGkNDhyfYiJXDnhTmYvk+qdCR4ksb8O4Sotm60mB +Mw0gkrETBk66P6v1Bvn+b3c1VcfAYZCrUTBwigxS7hgYOAxS1Q4MnI5Qqn4WYVtWkyoODBy6R1L+ +C8AbsjzKLBcOnPSX6ffOo/ZwYF0IMQ0zBm5YHQPHhHhaK4kJqa6L6SYWClxTm48qaGzKksG48FK2 +knaQZsEJAmdGtqEOgdNZwnQ5BM5+GyvNDIFjddFqFBA41k35MAGBG4YZApfWgMA1bYifdzfj4pI5 +pEa9QuD0FIjmplmyVSqAcF/j9t1HYcBJ7Ql3LhhwzAWa5QPuBlhEn1wYcNom4WnkYcgsNteR0tY1 +DPUtD2sw4FRjiHsbDDj2XZq8CgNO1dq4I8GAWyUxbJQBeeerQMjnXRlwijdwOxzvJrGUpa+FASfB +CN6YOGhZLLMQDLh7t+TXjICT7TyTAKe/9ysBcLeT2gr/jVQ5+cHAv93h2zv9jb/VaDrD327/xGC/ +SQ73PgP9htSudloT+S1W+QC/SWj2PpP7dvgmt2DfTKYqoW+Ht34F841tEOOnIN8O93yC+HZ44CKA +b5zEKCy8t9OjwIF7Yz1kKxu0N4l6PTNJgb1drs4esDdWQ17kYL3F3wX1FsYkvd0xzAP0Jq6VQhiF +9MYQ0AY5SW+4InvEo23oPtOhXs5KesNs62WQ3qQptnkhmXnwaiXwyuGhzY5ZxepBepOah67OUW86 +Il6voUSlmomu2mRHvUlr7HCZaKHeVNuytw/S26qW3An0hsECTAF6o4RKTnsFvcnc/QPtXq577Ics +v6sPl5NZQG/8CJuiHfR23wPxplbJGe5GRYarpK9akZ77F7w2Sadta6W6SWWnDagbMwNhgyilib8r +0i2tQXRbRbd3+pyULrhckwQsSDfG0n25mLcdyK1R8CuQbsNSkG6T2ZFuiAZpoXKkm37MqrbSGekm +MzvqRLphseheIN2wbMvVPpBuSoMoqhxIN0uM+MsgpJss+MMV6YYZ/yOIbtIyVoeAo9pWlZhcRyW6 +5aSbhyG6pAyOE93SUIluwxxEN/uCY+K3MeLX3Ktnj4D6lrY2H0iAsbs2TUb/tL0rShdECQlEOtBN +0UWqEQPoloYKdBtmA7pZ6FGMLAO6SVKNJbMC3VT4qucWQDdJqp1xoJ6kqWy1D6CbFNNsunCgm8kw +n/cAupk+m9rMZqAbs51CUAl0U9Wspbsc6DYsBeg2zAF0473ofRucNt4hlbFVoJutq8woYQbp086B +c8u/B8wtTEFdon9Uc0sA2nicSj5XkpsGnfKAeSBVd/S8JcpNr6e5+jPKDbNv6BzlJsvucDeFXnTq +4rvhgXKzF/7YBsoNiwJmiXKTLtQduLdEuXF5fmpM5kRnlc4KlNtkmVFuwxwoN/TCbKELQtvt8ZxK +crsXw0uk9dpMwiY4bmzZFcMuGDeak5X0DIrbGfmWgLihiYMXVxhuYqrcPyTBje3xsh6DyyZRdyWK +Z36blB/3PqyhJpP0tmGY4W1pDXYb6Qq89mS3sQ27D2sbyuYOEsGacYPcRmEyW5UEtx0uOVa5bVh1 +qwLbJpLI4ow2eWy+n6/QNolHHtcPyWyjzi/k75XqGIaJ2DaMBmxjetOgDhSb1ERngw== + + + OV+LTdlpFSR8JradHoytwDaEkpWhL7w2VQMv9jYqdnFEsilobcMww9rSGqy2ywOD2eEgicFNbQZz +zwNTneU98sAtagcC1TYsBdU2zIFqY/xIAjtRbQwxvz0Tqk1paYXGAtVGwEh6TclqE0TBSB0zq00z +i6buYLVxqmAIldVG2ETl5slqo0dGO7VEsAkRtd8fqLYWu9NxnOSL5DB5UiEtBdWWVke1qQWIedhR +bdJV5poKqk19jxSUBqqNnkSVDwaq7RU8HnHlPwjVpj0gvnhFta1bRAsD1aYDu1oGHdUmhVlN0AXV +puF4qunMUW3MsnoHE9XGE7AylYJqk3lbB6lNGgLEZZLUhkV7zkpq0yPVZBqkNizKVgWpTcEyd14G +qI2xJM80SW2gTdZ2DlDbs4b9UBltxOsUgk9GGyIDyvokow0WmfT0K6ONYLCFOY3RRmxGocZktBHR +UHCoMtowW5WHM9p03OXIE4mSUpusDH5htMksSQnvQ1fIxBLYjmjDovBxRbQpwaDJNxBtVtJ2HIlo +a4u3fFZEm4AQWv+D0UYwSXvnZLSpCVn9mDOjTYr9jOtAtNHTrErUQLQ1ZWH3+wPRRpOzlUsEok2/ +yqK3zmjjZptbUiBtmCW+mJQ2LApdJ6VNSuzy4AulTaE1Hm5S2mRhaUlKmyzamRRKG2ZF35LSpm5r +OZlBaeMe2ZRWKG0Er6w0IzBtgkuc4tE5pg1sqYSiK6aNDki974lpE4Fi3a6BaeMOa+BVThvxMO0t +ktPWtFGiqNs5bTw1gxEVThsLiFGbgtNGyMx0XgqnDbOpiQenjauXimpy2kzzY7k+OG2S+VCSPzht +slgYzjltshzHB6ZNiQuBf4PTxmVo4gpMGyda4UbBtNFs6XOGY9pUdKI1MzBtmka0YSicNps8+z5A +bZpgbQpxUNt7bh6T+88MarNMwrJWUBvDSzosDmrTK8g+P0BtbfHc3gxqayEeHKA2DAqDBKhNBoJi +BdQmK29nkNrssH1PVBsG4maF1KaJlqEfpDaekepygtRmNT7XWkltzPOa34PUpmWK4H2Q2lYJXJmC +4ngNTEQBZSInta3qR76uJLXJQBa4kNpUWXb2BLXp79u+TqA2nUZwo4Da8GokoRagNq5bDl3wtV7P +7seffZQQ/7z7B6YN1dhTCtWu6KeyIsk2O6SNMCo/uTLaDq99TkQbhqPfg9CmiqVz+wC04T0rwhh8 +Nlb4CJ/xwoNvseT7TGcjacWOIOFsCFfJ+3M226Fmx/sDzSY913sbZDbeysthaiq007jZPsFsh2t2 +JJeNj1+uQWU7kB+9+weU7bgM0pNMtvOM0exINl3t+gFkQ2ZfG4jgsd2ueRo4NiJvFlQtODaJjesy +A8e2Rt48cWxsC5SBrTg2qbFrYQkcmwKg2tsFjk3BVEVCC45NIa7DC+X0zq6Gg14Hjo3IhV6aimNT +QOO+roFjw2JxucCxydI+aWxqaVMcN2hssijEazQ2nachUmhskpFjAxIwNm6ahTUdxqYQhD66wNhU +7Hw73c32H/TUa3/qMDaNYe1EZxib1M01FQWNjadiJXhBYyMgKO+nwNjQhOxt+yFZbLdjqALFdnlD +bSWxyWnptm3XZv7uXtEaHLb7iIrGGcPGEoy8TFLY8GyixlRlviSQF8luzwy26/aC5kCw3e5pJIKN +qlFVPxYC2x3xGgew8TdzYvLXVFd6V/pa1JYGfE33yOFuSq7jg2xeYz865S5P4CR57TzMAwnw2udk ++PMvyoSWWHcKdU3Q6t4TukYFphLSDl2jmM2r8kbcEiNedCDXKIOjhD2IazSlEbArwDVEQHiLg7cm +wcxrS9wa8Sl8syLEJX76eSZsTdApauuNtYYXdK+totaoJWZrEt1ELI27BNhsmd+sP6Jw1qiTlcSn +D3CpDp9bYtb4+25bpawd+DFXT8ga/VU7EqCe4lS/1fPFBbEGo3FftySsnc1RvA5Yuz7QapJdl2qH +o9VSWz7Qamrdp3hpSuqT+9ArF2Q14sUSVgqymgqrucgZrCZChUewVJevhsczuWpGRDhb5aopF6d+ +OeeqKbFmLAklvdg9nB9UNcJRV0umGlMTkhqOVJO6NJrWM1HtcJcsgGqna94GT43dI9GTglOjm4T0 +itPU2MbxlgZM7XL5+sJSI27DxBAotaubdG+Q1AQZ364KUiP5iXsfRmZpFtHAqPE3U2ShqJkMzZYQ +tdMUUwOhhoong6MQ1C6nXQVAja5plY4aQA3cwW5Bz8FPu7y8MvBpAogvR9LTRPwhoDvD02B28sYG +O43iWoJxISBG4/W57AWdRnTyNoCf4skiIhwtwWlXswWncNPY03JVgU0jmabHH9g0JcCWs1LTlPW/ +WkLTOMsqERyadh2WbCzMNJoueXaBTBOStiUwbfOt8cxL26Iy1nFpQS0LWtpuF1dYaftmFQiBSuPv +ww5SapwVVTPYDEojtEX0LjhpRO2YWPILKRtte8WkbVK/S0haXyy664y05kHJgkhDMWI32eTb5ECf +B93PBKR1a94ueLTusYugozGb4nMEHI0FoxutbLDRMKpu2olCHeGcpSUZrV/mtRYwmiZz2HMORkPi +uz0rZnDR9Pe6Vy4aJ7XrTCwaOa6l3UlFI926i+Y9QdGo+Vkkmm1MNBaIfSKiWdVTIaLBdeHnBRCN +AuDbFgxNfUh4EYIsODR1dB174tAo/WclDhqa1oJWWWgifgvV6ig0qZP6PkiL3XXb8K4gNOXmlzM5 +aHIoGIHBQZOXpNdi5qApQatYQ3DQlDJjbkoOmrmu2wcGzeh656CgCUKkvWihoClbr/xqUNB4gc2/ +CwrauvpqWClo1SxpvzUbVxyDtkZdVcWgyaxIaGDQZNG6GRg0uW6WTpgxaHIWee0Sg7aqevnuA4OG +xWoiCwaNFVFahIlBUy5fu5nAoKleRSHIgkGTWUFqp6BhUE1RUNAw6GbNEDQxwZqX8lqWmgzxNlPQ +sJzWUTRT0PAVlMJJChoWCxFFrggf4zpF5pgpaGq1tCZIo6Apka1B6RQ0aXIaEG6ioMX+ISFoEgK0 +MjSHoGnDuHp/zICgaaujgHVA0Kaov0PQKFO2Ap8CQVvFtmnngKDJsq2DgaYz9/MDgYbVAg5OQMMg +h8AIaPxpsZZCQCO+bdutIKApFmOb4Ijw0+9h24CZgIbZav9cwWAVNcgLUqwzChXh7UVAw7yoWysQ +aHYjVaGzRmjptEh+QaBpzx5FIW23YKOq4ROBlqKAMwJNFYHn0QYCTbkQlYkHAk0FBhrDBYG2Krq+ +3gOBJtEpfVUg0IT2YRUqCDRpTrJLCASasDUKdQQCTQqhCq0UBJr0hu2OR1dF6BUmAo15QJHJQkCT +1qcVBV1jJsvNn3XNogxhJYgTAQ2rFR1EENMsKsF3ga5y5kCgyax3NhBokjezedYRaFgs0VIQaKsE +lpyUaWnz7l5JItB4X+3DCgJNxZma1AOBpuvQ4AkEmvVLb/0DgaYQtSUzDYGmInsrTrqjAKdZ4G5G +oDElqHQ2EGjST1bNoyPQFNnjORYEmjYfdJQEAm2NFpdAoK3S9Tr3ykDTFCS32SFovK4SiAwKmtok +VMZTKGgyK54fFDQsbWKg8bdFyWYEmropbj/PFjGllu91INBkic8eAkJEwJTvDgQaoSJ1HgQCTZlC +nmxBoFns++qJQFO3D2tjINBIjFlasCDQpM2oZSsQaK722xKBJuy5Xp+CQCN1Z61/uU1F61l+RCDQ +lMZR2Kgg0AzLu98DgabIPE5ttJPwpbadLQg0lZDrPQwEmrpstKYFAs0w7Xf7QKApPaWnHQg0S1gt +10Cg6VTd9oJAIz21uxiCiWNy3YzYQKCtBnXpFYG2XpGQCwSa+jBU3B4INHIkVlNSEGg6Ve9CINCk +zKmFwRFoHkj+oRLQuBLzXIKA1uTMnfcgoCmJHAVGCUAjy6aAVQLQlPiULxAANGUvrS5nJqCpNv1O +dX+iq7BvNN0EAY3smD30QkBrmivObRDQuNuq9XMCmpqrrLV5JqCZ6snqC8KxW1uWeQx7jr87PmpG +oGG20K8h0NSLZHFMR6DJ4s7NIKApW63YchDQLIFltQoKNqthQyviDEDjt2voBf9MOWvVGzj/jMyn +PI+CP3PkswMB1MXHwFTdZ/DPuASb6gv/TGaVFxcCWsua2SCgMeZtuxEENLXgnZKcmAloZITlQwUA +TXK+msMCgCbwvel/DLElEsSUDgf+TM+XeHvgz5QiwVUo+DOTOz3PxJ8pLI+XEvgz5nGt+7UolHof +Ve5bq5ZoC7j6gT9jzVfJRuGfsTNRFiBL0YRcX+7KP1NZEfHz4J9pO3BtiT9b1ce6HhV/Jq17iYE4 +/gy/UF8e+DMmDiaGmX52Zfm6hSzOmJ2cfSaI3rFX9hna4HiegT4j/qAsqqPPPoPDP3/4+d8r+UyV +Ac2BZoN8psqA2NqaNsztYekgn8lw+pnTak6Tc2LPGJW6rYE9Ux2O4gRzrlHy/NRNBvbM9PrvK7Fn +dsRxVuyZPo1lPrBnGOTkBvZsVSOI6QAM7Nl6udYAVVK3NxgF94y5WFvTwj1jWZCrEdwzJgJF8qI1 +mdowhUoL9wz/QNGa4J5RTaI7HtwzXvjd2r7rLGCBfcOeqWzkMFqWsmMYVM9XsGeyqoLNQ8AyEKQJ +7Jk+yHBqE+6oSWdxS+pZa16nFTyzpnj0flfsmTS+ZuxZ0yZiwp4Nw4zdGlbHnkkkfsKeSZD/E3vG +BDpjz9rmOraBPZP2MzHtGXsmo0hijj2TgZU1sGcY8AwK9axJrn5Zk3rWqJvEfQ7qGQZtVQr2rEmB +z4QKrKyiu9/v3LPx98w9S2twz5pyRoN7hvb7m3smAfiZe4Zae+GepaE+gLAG98z07Qf3rJlISOWe +SWh/5p6hgf/mnsk6c89kmLhn/P3insk4cc/EaJi5Zxje3DNGTuGe8eCUMAqgmTAOmv/3D+E5ZSXi +qMV3N4E9U5vh5d00Q6ZK5t2RZsKeYVFgKqhn7zn19y0a/87UM8XTFEafqWfaPrBKBvWMba1Ce0E9 +03pqbeTzsitNoZ7QM/2t9LBDz3SaHL0ZeobVwpUGPVPIVCWprkmhCKjihDP0zBLDpi1qkZvlcoa9 +Q89WlZy1q0LP2MxrrxbQM0V0VYHk0DM1jTHwCvRMVv45oGcybMZGs2DS4kneQj1T7xAvvGPP1F2E +Ux/cMyVhNueiZT6TXb22LM494xmYx+Tcs9ez+/HnHyVkO60NZOaeUTZwW8WEc890oJ70mZpa7kVV +7hnmNZQRbLMu+dYwqJVniXb4GXvGPsyCyYE9w4OWl540M8KqXqcx77rVuttnPprKWiVmFNgzdhJW +41KwZzIrxBjYMywadok9w6LaoYo9U7u5fKDAnmkfq5sT2LNmstjtA3umzb6KhQN7phpIJeMCe8ae +RhuNij1bb09PJvaMAjsP5Tn3bFgK+Gwye4ZfUgDywwJoprnpuH6o4DP2sucZSBXMKg== + + + 87M8gpHPzNBdPmpwfNIc7LO2xJ492GdtiTaXwj77X9h7k5xZmuTKcitvBYRpZ804pjWqDSQSUZzX +IMH1p98jIqoqbg6QYD4UK4Ecxf9umLn7Z4020tyDTJ16sM9QGICCfSbF/oDEPmP7V7vJbilyeATZ +2WcYhFq4c2efVV7m4QkIi6WcXrEW7LNN2UsulhzsM33p0E5sIs10wWkESugz/CXYus3jFFNjZHb0 +2RIS+mzJgT6jHvFyYz5i7upQmi6Mk3xmReTdrNrMG0zxOZ7VuGja+1k/XiKfKeJgnfWBPmOj73Fu +vzJuQZnJZ0SCKZcK8hk7OYLNQT4jE4Kwg89Qi0PNrHxbPYK3u1Raw5maLqylfwefEaq97TgLU7Qw +XHPsmR1xlD8ZewZtZ3jNsFUynp4rCurZewD9+1N5j0LLBD3rsaMJ6NkIi7dgng23oMrIs+FWx5N4 +xlrrvP5M4NmI5tnEO8N7xQdt3R6ddrb2Z9LOhtsqJtYZGf5iE4k+k9TCeBbpDJAUQ/wOOsOsiipJ +55ypQysq46jGMWRj/ZMpZ4otkJ8KyJmEy9FlhPyHr2cy4kwqXUNBOBsRcQ/Cmb7vsc9ZfDO9Yn8m +22wcFredaLMpJLIZ6rW4ZkqIa11pzLIrAp+LaqYiIEVkTaL84iqTafY8VvuYiGYyTiBlHb78txdG +BKlMXkAKxiSeWVgYhHgeYSXpNLMz3Dx3mtkUg2am6haydwEzu+8obt335pQy9rpQZsSXifkEymwp +CWW2yY4ye+5op3RAma6VORHsILPbc+NTVUE9LeSBMbsd45MxZndEyYNidrvzSjDM7uaelolhJpSv +RQIdYaY+JcuLO8FM0Q/SxQlgdkc22fll9xlJfIeV8UR4bmnRy1Rnb0UBDi8TZCEIXla4MIWdTbRU +T1IqMm5mr57f+yyv6K7L3DI4va0s9fI+x4ktm0LClk01sGW3e/lMGtnjUIBMLSPRcHtD4SxmsIaP +oJYtJVHLTC7mMeyeXjVqnx1GJjsNS4vv0LLrCmNSV6MrYCLLzmm9uRPLzmazsPPKMJp3X1F89iBa +3NHdHZdUWAsa9QNWpvo1vi1YZWeLGWhHlZ1uGB2gstOdFCenTG2/3KuEKRtuyjLV0bwpOiBlS9gZ +ZUsFUTbcjWsSymQBTHNWApTpNzxWWk7zvGrUwuEVOpkEltkJToZ6m+0rm64RRQiBJuOPK1bfvchk +1FucdlGofe5W5jexZPPfO5QsxECSDe9em0238gQj4J+ac3UDwqiKrabqL832yHFk2uvwuO0wMqGv +FbQOFBl08ONegDG1W9nn7iAydoYWdHVZlQZeihIj2FTSy77kAJHp3YlaDjhk1lPvhiCLQ2aGQq0v +DtksU5okMmzObSm2k8jMw8g9FyxgEEnkjCIjl7WrKvwoxa1lmS7VFmTuaolEZnINuV9+oBs923SB +coZyz8oY8+OaIDIEynEDRIZipRo7iIx8NeO+k8jowWBADxIZTgdco8Qi41VhxRksMvokOTVYZJie +mRPPziIreJC4EYi91I8nIieLjP2a/vQdRYa3YPGmXFBkSbGnQid6Q/UikZXHp/YgkWl8sIy9o8jo +QL8cNBkoMvoyuHmBIpNiO71AkS0lochM/iz8nrmtcXuGQJHhOnJbwelCkVEWpGVxsMjK6V24wSJj +wB22mFksMqlEB4JFhp2zsclsz6BhnlqInUUm9W59osh4+7QnCRQZB+gKJxQZhixaCAWKrHD8dU0U +mTa4zA8JRSaVPV2gyLBjV0FSoMjwSdCKIKHIULVGCxYZ55V7Wkjywe4pua2zNEl9XpcgkbHHoRa5 +Re/zYRNIIpHNwyaJrDCNuaGQO3TblnRDkWnGtrI+P0jFnncJ4yAfXVASimyqgSLTaoOYSzDGMDso +ZyaRYZihSzePcouJAJHFvxOHbIqOISvYoX7ua2DISmQTdgwZ4vFMCpktE8cTFDLWlbo+O4ZMohv6 +mpF8dwP4wJAhKF6ZMGT6bN7VwJBZZvusCy+mBZt5ce0UsjUkz+POqIgMDNlUEoZsqoEhsy/oQSFj +ua1XO2HIaC9UvC9UvldbMseQKUptm76EIYM+xsMTGDICrsUj7LZcCiVhyExtbWLIqBDVSjkwZBak +uu+MIaPZC3OIME6QBW3xw24zIiE9ljBk2JO0Pilk/Fuze1DIaOJ6jGa2KGS6gez3nUKmq8fLGxiy +KewcsikGiMxifJoHnTAGmIGiqR1ExgRLlDEOU/GlMchtJpj/3kFkU41eIYWKKDYLwtjs70wgMh4y +FdfMw1T6AVfZQWTFrQgTh8yYGufEkPHvZn+ttfbpLBw5dg4ZanXKGCUOFPcrm+8cMkOViJG0c8j0 +o+y82OCTD3QO2fr3ziEztW0urgQVzjERY0TT6F/eQWTWV3lth93+NwWJTKtzlrWJRIb7q4qfg0Rm +vfClTRKZYo2s4xKJTIcxXDqJjIjkUyZhjPImuXIlEJkC1tyOeVjxItEAkU0hgciW6iAy6mi6ZbOJ +bvN9erkTiYxsurbqQSKTcDqwrJnTtGKT484kMlRdqyCR8UH6gECRzfKthCLDfqFaRow1IIVHGj4D +RbaEHUW2VEeR1UgtBWNMceYk+IrqtkE5VMXdKR8IFJma+63Nb0eRoerqJhSZPk0jZpDIWCKCfXMU +2RJ2FtlUA0amrRGrh+WlqqdS649jTbZ878Fa0AOHXjCFcF+ZRjbVoJHhJUh/fonF52PXItHIaM5Q +JCxoZDI7wDUgZr3DatESi+zpNhAHiuxxx+iEItOkoL1JkMhuLykOxthnDWneoTuITAFrllAuqvfX +EWTsiXb4GBfDsWNtmtw5dax7qXuGjqkZqbqvWLdbyZIriGOvIPDfjzP/H+DY/zpwrFMmqMSfZv2J +HJMMuW/KUj7v/WWwPNpqVb5eVKvLqiIeO9VzqhCjXuGJXx4DUwqiymvb1S160MJ2bOyx3lTHDT+z +2NyM0h9TyMDbMQJyqrT4iROLge8l0vrUqRK67TAWSB2bmss+aiHIujaIIirWCI90qCwqNFHh182f +rgXsn3qPjUHWldrrxk9nQd2YzqCuXuxVmhq/RTEUWXhRyJrqMVSIIrQwy37BL7kHBhmFQ1a8MEi0 +tg1ERhPObbKRyOSINYza6iyyYqhEKTuMrBgjELyr0cg044BIHYEjU3Fvs2+dbFpcm9VUrbbkwjfA +sxGUVlvOP2C/D32Q/dtOE1hJD0ccpN3LreWWRl9aD6dSywbH2uTu+GjlRroap+tpFcSCmhb7q8+N +TCZG6ehlk/XTYDg2bKH0H9ofi1YtdOtyWkUW8FcykW6UJoyVWov0jEqpghOjTNNbyUpLSSXlKAEe +Zovuo8Zm+jLc8WKU6dddgpND2ja+Zzdgr6xlgZRNYeyQslDVriNPR/3lrYmnTDuHOLsUPMs4PhS/ +uspu17IdqAjYwUz7uCHAUtKNmfKhmpvP/evxbjpdR/f85CKqSHniy0Rpr+LM8+YpWdlgaxTDek6A +GWphnDiNYIZir+JpXSytY+JlRNAFMUO+DzvVENiQOIYrit5K+fx0+9bVVNtUAtaoJHqs6bmROhOv +SKMTJLPzhKc9BTvz1lxdN7nTq3AJgtK9AlKW13OIDH4Qshi8jKWyN5Niv4LN12NKHpjXBOq1Ul1h +DXvQxsY062r54MaoTU6R/v5gRGQPgyxaO3ZgdoEneFCa8OuN/bdYvLTbqy9XleHa90l57mp3cCHN ++n3a5Zdsa1V5gJdhp1JxIKWJZsqpE2nWn2JcaZ5MbTY6VnhwkN2RuctV5BA7OJpabATGA+xkHMXb +rKv1YTQbiHB67FowVhuBJ9AM8aT5uVhsFIWBQ6sivf2dUKZeMY3dk2gmuQnTK/I20VspcIpR7GIr +dalHUKfOHFl/qFG4+XGsWT/H/Isuoe4eQLP3/fzHvOVd9cZ6wzE0m0QzyZ+ZyEt6FPXhwDtKerRr +lwK6eRqa/TNO/azOvb5IJQEdD4aruCJqEgaYj586865dZA1n2+K+02VveKN03/Vo18GrG4qdWWRb +RklKHGj27ZcDZvSQPrItuyxTfy3WtnKmz2OWw5gDocAkVzQRJoxApM9tnbCrRb+xCbks/odPpxQm +YRTau6W0+niR1xweFPHSs6cyFduyUPh9Yf/kZa/F6M7a1cwQWpfZTzmtjotYcofQeJwOtGCpMZVr +Q58tWYsThYy72BUD/85upWYMD5qMpuLfKqtZFdWuA/UZl30Yg/JSRFaqc9021UFGiT9Ljw3Whcrc +d+1VH+wNaxrNVGfeOzJZPJR22oHETTmVP0A1knOXLhmgMawMBRU6dXC2XbcFH+2ht336CmQ33kRV +nenXXdxAhR/U2FDcsncptW54tE1+rPxG30GxdqUgR7EGtkfHpvhqUbESFY/NA5Ww0Hq0wv5TaedU +yr2h0jZ5GCyt4+7u1BWiN139ldYNdG3ENJ36OdisCe0qKbalh3VdN1ngl8dNICc3ras3rKicWi+e +dqFdFSNq+tWBBBi6nMm6g1UWOk0yyzoKizXidM1Eh+pb1durfXiXTcfTzEZ20dMkUy8tmcIrKZ+1 +qPUU2CN9YlsxTJkENcn34ca0FHehMGRUp/yiaIfBKjisXDotE6p/K94GrWHqPh2+A3DoPYquSXVY +u74VBi6O2lBAgfHpcT/7MVT85h0k1IkMKvFPU1bjqeTPPttlvfCD5Uu34k3ivMMwYzaAL5oacgy8 +rHw4tfpwjQshH9+bD9fTBnFQFUFO7XR4FHFcII2XBy4GJqQWZ1m1A/rLPq9+N2NOzRQ6FYD6HLOG +or0jaD4TrCZ5XNW6SKwoWUq1fxNV1L+Lt3YushrycWw2pyit+as9/KNOoWvxVT22y2s7Tcy//M58 +Ru7K6EeL8FLoTLvW32nqcF+KocIcVm5KnBImlCESY1godiqTddsPVJE3QOPLw+Cqnj7V6TDujbGm +4z6LoJsFHdUmQ3+N1g5VPf9UUmuPdSm4HIp9qbxY1Uy4DuzNNpsV6rJYXFNp14ZZW7LMQB6CssqW +U5zqDDT9TZ9PLkuxUw9W5892oNIqXcauKgeu966okH66mS1ZO0lt+QdFyhqIVIBIsZmG2EujWijz +Ap+a1LcDVZ1x20iBc/nA1vYxp9mFXUO2WbJZFA2FB6d6K7AUC2PUtpHXBpa0l7kD2xXWWnMoTixF +8UwpNifow6Y5kX5er7c/dKrhGtri3s0mYVL/9tSMZyl+KnZ0Yz9QY/FlUxbli5uym4csWb0J2s8P +dUwfZiDMYKef8VmG3UuxMyuB6Wc7UNtl7UP1FViGbcpum7/k5gbb+o5H6+TafRE51FtbaUIaG4xN +TwRLmlC1J+ldw63ambd/aq6eOLYlq0GcGyh/x3pb/QGlJgP0ozJBofiPxU50k/Ua9cPdtnHwGgIC +N8shTCrboHH6NKtpVkxSzu4d7vZ3qzmUNY+Omb5lku/x2Cvjb9tjjWEWVr/s1Ju+pw== + + + oywbt4F1QTfOov2hDVuUk5WnoUdJlNxL8Df8ti3xdtxjd9gMuvVsTCUQkXOqcNmJNRpTWfRpdcs8 +rS+9ajG700Vp47dAE5fMsKd4OV4jOI02hM5i/D43UpvJ1UzzWUBzpizJpVgjCn8pP+zaYG2atlhD +6SJhAKzZmTUUpET6+6aiRorJa9vkYpWyg43/ZbYpB6Th02IjIawbcyqzEIc16mG7W8mrjaZVi5sV +QGixPx0yjr+7gSwN9ii054OV6LA9xlCskE8P5Z9zZ19rX7J2YsRz9MDZ7nwqaWBYsuL3eDbKmU3B +xNrdQqWrDO7UVKxKuElu6wrssQICOKGdN7XS5DHDDlB9dizHW9vgbR2vO401shbXGo34Szun8G+2 +HD381YrDzKfkYaBhJtbS9rOYtS7SiXBDZZBFVcQEhenDXzVTeijBQJBMb15V6Jh8I5VkuiBSuJaV +tpMHZeHcukhbD72pNbJtSn4e9mF0ncp2jSukArJ7fmfzWJNe4saGovnkIQ9JbsLhu/3a7g3t1uGD +0eV32zZGylVotPQyRXZ5euCkLMKbZFuDKYfTLzuVN6vixFVNOQk0qT5tOhh1Udf6sFGbZU3XPKwo +b2XNqu5SJcbY0epFmbQ37YmqZk7lUfGJM3CjuiKdq7Qp90Z6WDI1Z7Klq7fPzre3OPZ227xBgfT8 +ztYtaKBYnp2Jvc1ZCTLaYw/TTUZwx7kx3yRXywOcVuQspRH4OmLLoWlhfB5eTp3uUJKH4iP2iYXj +NOU2wc60s4Z6c9wIy3ara0XWFQuXCfFJdETFvLqljxsdf36fJgNTFvNN8mdbNVxudiAbBilA37rI +PiyssbB/pnUrrJET2a4lEGyh5LWF0F/eH1/1SpjQN/0ZDPn1MeeGjsee1ui3r0qWoob1GQtfcjQo +dOa/2xqiMdvreG5okxuKb98Oi+mvA08YRIOnxmJbUzmfjQe35MtrXbUXvPR+qMpPth9drURJ8Wuk +rYje+3WgLqbWwnJFN4vbqfSNB7dkEdO1C+xqPWaxCatI+8/D9n+6SKshDvnWhlYV2XR3Q69UDYkU +OrmVQ+Cy0RxTt1Nt/Lzc5RGFyPdVzBgEhWW7auMm2U2yLcnD/Uu/92bQk1OsDtStsc13KP4Qxlg+ +D8Qdl3D1aVi4pXCVZlB5ylphPPM7FBt43H1H2/nCyjWUf0YYm+3tOlBhWsLmlPF5CNW2p/LymBYg +irUOe8QuktNEaS+tv9l7qZl9KtfY0HBLVpBInfC37RSJFevJUvmPZuaGfUIsaiTfRLclH9UO/Dyz +fiD3dFTPpCnctFks1xhVqqHhUG6Sl81Sbpyq9RDKiqbKe1KzblMzjdBwupaWhCzu2LOUem+OxktW +nYnyI3pFmiYe5WtAvnUt/TSAhvDPGHvrJXfOeRy2xErQda/xX0q7ZkpwE4tlWpSTbV2DtihE+Eir +e7CRsDu3hBdPoLK060CVHWjM1hcUDzh/rnLxP2hObCpauIbJuCyiENoPrzZOJVfZywaIQ9aLpNQE +a3wpp1Z0lkYb9q3Xw59eN0BcH0ecepjvVVfKknRiOw0QtxR1W9U1roRcTjNu6TII1aSoxDLkNwX7 +CFVNxS+wLGzKfmChF+EhZ4dztEIOJCktxhzrFW0FLSd9WUaxF09lKQloYUK9AVo0KjE7OXEdYOQz +OBNSHKFTUoyHMwUU4v8MOH0pHoft8fS63OgIKs3yMKLFbcq5eVIsuXrZVbM0n2W9yelon/icljot +K8rNWtnS4JbpOQ6/aHVYugZF6y0y0HPzi8yl09/PLHPQ/HqinBZsV9qhWSZ/YeOUqHhkFyEZcy5l +G/x3VMv3bcqxPOiXWqx2spHR4nJQsqwo/f5v/6ndRvbtsJNqBX24RW7JSuihUqJgouM6LeK9L/n/ +ig+0VGeEYFimVmWvmkPZN6VtKLElDzcf7Yoe87p9Jg8ruVBvaFc+MpQ5r1uhwTzwjuqP/himaykx +qPjkEbKqQilTE+2DgRtIuSZKwRu5SsezAHJKNlqNRakWblYcTNsGjb1kFRVp+SxifX00+XEK8DG+ +VzUjiR+nMx+tI6tqPiY/btBLoJiA9vpqnR9G+rYpkFTyaPI21JomFN/G9ljUxYFhfFIvR8UvZYyN +ILdkepo/G3Y6sm7LgxAt+3z4ze9SrHAODgMDLS3TNado2h2UDWtqPpz8/Q6er8D6f4gjx5ZUSZlG +xGnMXLYHRCXT48eBir5LoXxGCjlFlLW7UNG94ouNxJeusszabEdwm5W17gQVR7qciyOHzPrh6RHn +qp74ebzVRkrVkGnLkxWDBAnwmHwScRRjpdstU885UT+rYegbSU5PFSU9R7eOwKFsD/NlcQS1Iste +mdE3nJwikKUWG4co2RvKD3WREVo1nNwQU/Yh5d83nJzi3s1eWq0O/iiYRAhV/7a4stZrgwT92HBy +AxtgUv4DnBzHWbHAYGsvwcoo4D3Mx1DyQT3GsB4Cojq3fxQ8OSmEylFmhoc0CwNzdxsaYmnHZTUL +neyE/l49L1FwPWNOKjhp6jNUvcWwdn4NLY+tihQOIkTb5KrW5q89LR7WlNJSgeZQRbai+yrCIR5E +7luz21k2ntwYngDXL7E6a/1Vqo7BBJC0xm1rGO2KJ01OatONUpegYHID6yg/jiamAV1RRUrj3mrV +iQRq/y+ZOjKU+pgCTA6F4gct9yZMTvLDFVc+gbifljAsS9U8aZG15utXLXYnTG7Q3lioOIIlNwzs +1KgHgiU3Tty2b+qxFkvus1X2dz5cz3TqRdnI7UbEurrq8WtynJgMLYXq2JGoBgc7kqE4geIaDf+U +kwGU1KTu50LJKQb8VMrfqnllK55XlJpsgJ0CJSeZGp1GO+ZTeakehY9RhJKTYssQnTpRcpJtecYn +arCQQmWddqjazqGc50BZIQaSM3oVLvfS0s+w0kbtXOgmrY9XzOjBmyy5UeV6qseLiInCwODoqi2a +ja2i7TtruntDydn42VFtUXtXHz10nArA3qPzGt7/MknOciJkCo4NJacx7iJQqNUF9zey1tXpAaN7 +UlOZo0mTG7gtD1e1npbyqGYGRUFNlBY5py2TWqxMrXoww44zMzkzg9AWgmCdlBm+ZbDVG0Bumzwk +8U7m2mG2Lxrux3Xb71pUOQ36hJ5qdZYTsxbJB8FccXc6upVzzfS6p1i6F8FJts6OZhWoUrDsRKnK +Vsrbb8XktUi7mqXYaNhDefxbaezjVGIlygJt7hCqNhtGpDX8HeUM/GXdSk3f9/Qff/3x0cL4UhZI +a60FmWu0mmqGV9G8yuhYQfODdaDyQlL6LYvau26cOWQteittYtqPS1G0XgrZkRa1ZPXe7TlYbhPZ +vCPkjm+4h+0IJGhS150gmLjYSWTnVPWqpIIunvZTrBabA0xUklSVe9KEs4BzkgtTt2R6J0hzsdAu +XhUJh/JEWMi5ZnUMJtOP0awZcKBAnZPSlIJGmdg5Vc58xpqLkd3/0OLFzLK2usAvHT6Hagcw0XMd +ToJ2IJQOaJ+Ij+llxanaAnXtlZW0afEk/TOyCPZ71bRMCVbUFjQCw6rCo4Wy2sJmwee0X2/MRBoW +BJ8jFMs+UZ30h0dxTyr1+tgedIUmntNLGmm91c+z/YkU5REVG+m6IyyWZnsFIZPnsbUR9sidHlCt +WVk+6QdLoaYZfNa9nXoQUobqXu3Az3Rkv0MbWD7qsMLKRZ/rQLC0hQYgquIXMx+5uA8aDAhw2Gff +G35Owab+HF5+Cz1mnL7RJTAuFEw3/0PtuiZ+TidSOq1NubISui1eLuk+DwoQWyigHhscSQEN6pm0 +Voc/x9PBlrC6lyUcX8IP50ag68Ah9IgoYc6dF1TLyl99wNen2xZUlWETQqfH7XOLOuEShlp92CwR +ppa74w+oueJ+Ng6dfkyl2uq+LMNKcEvjKg4tKpYS5kuFg+qDWNAWZIvOPobFksBwdD3O6mmHb/2u +Z0UCOuwO1TyoW0APLtdMQ48ES6Ydanix1ovVMakfa6mn25sIVU7ISkYtDXQgvAbPvz+/awXHrEWp +6sTSqfmBnRVOFOpk04rocSttbKF1SI/CyRU4Re6aBotTQKTQ0lDpuNCIrYtPQU0p2ygrmXAtcnyH +zXcBs5cyyzWXaVqD/nXb3pd+LykPdRYy99f68K6exTrGZsBKvTjpF2oGNOSow0Rr7GpJPypaO3kh +cRtnEY/kgTnf430CMlOinE7KzVh/+4xzPFuYV/J1PS7r6ZJi5XSHJ3lRqH05ns3uUZElCpZVDMZy +ohte47E6Mn2ZMnhsSLHwngwyDZXkoOkEZRL7rFXbBQ71NONOlRd+NkGDWzDLIPrZY1XnfgCKcd/t +sEUXxSndmrUHRZiLaKdBir0OyzoqHe+oMGyevdU4RnWsCqzPZ8sCEbXTX+psJ363lfSS2RP64ArG +8yqEPoYX8Bxuyd3kTGNf2u1h+Nxj9sU1XN/8xsQSUcMzVEQqonVjtL2iAVHIIR6scWycO1qWKP3V +TpFq0O71Rt3JSFpFUMysIoBFu9OZNvg0t4vW+HZpqc/Klzi6IsTaglU8NWeCg952OdeH3I2V4KfS +GiqF5VFLgzs8hmKra0NPcqoquprbSOjjebRQJgBPiyQ2upLZ8Xei4rfZQHPi6TVfmlnWE1iiZFYX +gGlT/eKEv0QVO/1XnI2f+2wsPA2Oloxr3upKrTXXt7kxmN4Ect6tLyAeUVe+gfoCMSWhr15WbGbp +0HJ6+aCAOHNo6ICeQI27w6zy2fbYqLFLZacdpJqeLO1sZ/kZJRW3u/HbZq1FvQezNEUKRyRh7w2Q +14GR6AKcblzb5CXBPDB8V6pR24KaWjA9s/VllkdXKxlmdKeqUIFjGJB3/F6w9LMWXzIbOSL6ID1v +73RRtFqlT41WAAqezw2aJ/kgYKmHQI+vfq8FWKWo2EeKclKcuar4hTcmoKcbATxP/inkZh18SRcb +wU9F0yZAj+WufUO3CopGFTSTTHWInqIW5O4VN1x/6elxmwrxWLsFldMo36UDjaUHhrHZiLTR9CSz +YSpuVSWlKk1RiyNTpLAiR1lMPWGzPFhrUD3h5Kg91GeB1UOpCBtXjxNpOL+drHd6tTI1R8ot0xQ3 +9CCREIgnv+FI6kajWr01nCROuyIk8xsZTOPSLMaeok2281JL9ePfeSpOiYm8XkoCJMRo65lIe+Qt +ee8NtSfXWXbFMqsz2F4xJ229CIu3R/iG4pHr8oIgJaD4Q1WppbdSayZ7Y1RUt63eYnS/DBTcFTfj +s5Tzp/NUvEt7166NuqdJywY4LipJj+HLF/BFml+NWzsI5S/sHis/HrjbG+205LcyAG0/J3dP55O8 +ph6Fin0MQ3URgY7B5PU5vJW+cfeyjD9Aj+6qbti9HuVxpswuLMlsO2V6wujeI9QM9EfpYIXrSN9K +WX0NaivTmKEAt+EwKXLXI6pH86BE5fLMk57eid3TlN179GsyJJ8z33eZE5NWDtRhNw== + + + fC9mgZxkPRWSLSM8vPpLCgtpQa6LOhbbxvaSOqyl8rKoNPn37ocplijB4pft2guA1K/JzkuVabSN +QcUpW55N6yHIA7NH1P5QjS2WjrpJUikpxvMlgdn/wj+ssruZ3D1a/qzPtXpZ1vN4KYPYM4XIUrEK +0ypjgAneU9aqR80VL+WWJjnMhF+l64+FTMbGbFGdMx14kml9RWHkvYe9SJyqiCabjxX51KNBCOp2 +H2AptjaRwj+tck3/nJVrqje+qNOWvwhuJUfzmuQ70iFqKmK/c90be08ylZySrcRb5MrTq38I+Uih +1U3CZO9JPTSCEmxWEkCXkrjaNV1Vihf+XvdC7w0SxNphqnKFbkHaJW76yNkUqPaTslHaSmezHuUF +F0lIGDB6Xqx54HH3Swo4qOeRsdRE73USERoFbyci61TbdlDMCRJCijp7znNj73XtI4nk4eZI5eiw +eE+FGkIrqfhlqj5TP+GsSu6ame2SRzfOPSI9GpGtu1gMvN67R0QX5pfKKtX0AvG46trq4pekmtaL +JdnVtzdU5tLsbWRrxzVB6QhWxbCfuOB7yCyFKF+ia1JPZ3VFg7EUa+CQMuF7HZALlU+n98mdscSR +NTqjrgyc+LB7bAgrymttZHcYMb+DunIRtYieaQFmmceywffoiSURfJstDi0XVgh2RomT+qUuK9ua +9D0NDNZ11p0LobHIa1ovt11QCxGTlbJ8E8DHPqlSHzwsptajOYolNLOa8mlafhC6m2E3PHxsa9Ys +hC0jv2bFpZZkh0rYeYwWgg+ZmP7V7ApJ+eyHBorlpbReYeSQMrk99Ns8fipTmiXoH1fIwhy3pwyu +3T9LzRUXphDniMptzFxOI3+QqlKKlZs82gbis5zBbTXU9APSLkZj5RjWpaqkonUJnPcGBRiaTRTW +1IiBef2AIVasHNb405cPM6ocmCg+ZT2tGfJxB2dlIGzPpTWzFheqY7eabwXCZ42FatcvrN8vNyIi +p8HOQ+1zCgfoW0+LKx0bi49eAXsrD6d6Q9W9vEDPmr4uq+xAmV52ZCFZ9ioF2E7LhR6MQIKhKInP +qewvr2Nj8Q2gzXqlmRnxgH38+Q1UMwX5vDMqcZg4vlGPGPeimYRmI22V5C9tbAsv1ZnuH+tUvtX6 +TpUNVDySquEOJGTU22dcqB/B49NvsSWNFplYfLPMuy3yT0cFWXg9wRRuTSCfcpWVYjiaX2TuKoij +LRKqlfcN2L/mzrEaGmk9IAOp5JgCzvoZjEDUyeC2ruUPRiBkMWejDkwiTxIS1NYVp8hS31Gt98z7 +53eSqPX7VVTcTiR0W0LGMyhbQT5JyqzClWzBcMl2IvU1fEEr1nQIKUfK4vGR7SfcXh4zu7Qc4G3e +FQTg6dShQV+/fkLbRUwlOq4rCrZeu2ZK5aqFtJVAZkGiD19IvoENhrIvxWEf+ixca8joDUsnMjRI +WUQ+k02cPD5VJtAX1+iTvO25txIsEJiCww/vwtBdXzw+ZdVZWumBs+zedflwpklZQL5xRZRNM/h0 +HVOeHUsOKFg02ekm45fRHO0wsNl1qN++xLvNJkLxLNzdBs9itWmBjYFGd1sTpLJcCqmsE4O79Ed1 +utQFKBpi7ml6D+lrvjc2n2q3Ln6ctu9yJOyM4MXymIvOpwULtRjaZpIrVebagoWKxdAToYCznjaF +IhcqSMto66/VgoUOEwoa1PlEBYFWHfrdND1pNpo+tR2HmNtOJWqiiNFjPU7DoVtaaz6GUlqsvoZz +5DDrOywWCX1AHiq2qX+Hzf9+aP6/FNhH/UWVsZ52NhPYR/0Fe/KQqbYgRC8M12WVEIyGEraJn057 +mhCaMRf0zFL1qmfWRu8jAg8tYRUEzrkJCVYz20VR7wYhU+ZHjrm8n2hGe/hEssXa4zEWKTjMZqh5 +6nmAjdUiR8qE943idhqa8qu3m9XmvsEaucl2Vib/2U7cTl+jKBignzEM//asvviBS2+1btJF8NOy +Ap8eLADkYqAaHrsHn6HELtk5PGJ2XF8Dh82smFx5xQ7NzpjedlOsrUD+YKuvVzJVhKpnuP1UCxId +0VmvD2NYOq7tWR+nRgciWMWZlmfzYeIx//GhDqJ48RfO7/OK6nM2ebAvIQVwevP+UsoGlFuy1pGM +c5ieQ1w9cVEdtNGNMgU7UYbpoyxVv80ji4dh/XSIRfAV9p6lg1KpKIQNfNh4XoeTig3NeF22yJCy +UkuSPV7YzXN1YFdSrIkeut9gX9DtzFlJPbQxOsxvw2pcrthYFHODXQKs21kysuRqjYBDvRKnOUMa +4EXFWed9uTKtAqiAIGnk8gm6uVoerJuLdSjppiy5NsP8Ddmx9GbpCvUq6aZ8LqLtNSbob9BZai+e +vRqKZBT69s6N9DeMOIVqwLUHg11LJICReTCLtta+yfpDLbaFwsRmsOMZdhi5ECnHralYysT96an6 +DFSd99hK3mTzSHmxxiZZN6pQzupnQvENg9eGrQNb93W10E8Pqzy1yhTDJi47OGTbgjwG/ZNiwVKN +twp0vwfmf2/m+U9T/wjn2dN6bdi/Tl1Ct8ykuYjK8+KJeVRbOGbpBy/QNJ0rSUj3t7qR6bmjefi2 +/mRPLRZrsgK2Pel/kgmaIh/WskQ6AoHsjHrYlIlAmQBA4pzmBFQsfKTqkmKd48XC1CpMwZ/J6ON1 +M2px+53TIIC0JZrxjXOP6SOkBEAV9BMDiMz6S+4RisCgkAGq7sVK8UqzMxcIUCklwliVQJg1Wyq4 +o3/Ty9Fu8+JCWanh7g4o+mkyRdJtsQWa2hSoLXnd0X/89YeHZDEtP1rNTxigepEf6lea+7BzIAZi +zQtApBSt5FAmDBD5oYjy8jA4kBSP8VpI6YxeCEhnMyt7uZGkCrfMeQkwHg0jvs3vkHmvthSf/x8L +1ExZk7tZCHY3U9c2hnyx8lSLBoiMs9tZjQYohWcQd0GiCMYKKqYsew81q7LPgMfezQ3B/Pt0IPxH +SqFu+7CF8yDeQK33iPLbDoXucZc9rBXcx6O1sTU/alAZFIzVy+LSKo20otRqMMApkA6cg91UvXgC +MwqqVOU4cXpnvu/An40FOMgQtWc/MHIbxoa1f1uh/VbZONXLDE/tT9JDU5wsovHWWphU47aNrt0b +DephaAwUrZsaNiz8Bo9u054wQYDsOms32cxvrKTtNEUxleZBdiuWmuEYXmbdghL22zCTVRmmv+uo +SdlrWpas6gYqNrWoZPP3OMpDl9uabJ8d7oHXCTY580DGarosOiTAJZS+kQA3+TZkBoWj17BNuacA +mqWyMTydKECdaqV41Y3oiRPyoM7LRnCl2j59oQAVFK2XXRLr9lJElkLs4jRExZ9Z8lNSNlGAhKUp +XdNziSWutozUV2pdyvbVeMAWyFksQGTiFDJ+pKlYs/HtZrHWW3g+3luoU8tq230svY+M49gZZoUy +CaMygGOOM5xn545WFXHKxCu3TAhe6wgyWNVzk+8h9O/P8Uq+nzaoHhsPUIX6pg5bLrY7HBI165BY +f9xuTcoiAkq2DlTJeK9q+cWzxITlrYTM7S1qNuapc/DWco4zTx/xwQLy6T2SfytVTTlDsVlFRg8N +iwI9Dy3QAveI+tW2GdFoB0/EvQEkuqzM4oiiReiAqhKy0aA8Gx6Q4iGuBHUht5WMeSzosbSEFRgV +c8dcW1lkuNkyMrropcR3ysYHTRV8KYW5UiYkUCVM7J8bJQRUuHWr3tIISrhoKipnXkOmyWTULqMf +NVvjXzgCVKuDtg2k/due1Fo8buwH1ccXQ9puklL5XFFzB6Bdu06fjduMpLVEtcSQRgTtpcXkbd18 +LMi0TsW+cjpjhKx2VNs+X5fRA0053S4hngMXG9aGyquqFmiwuKgGHVH1ldcn7xECK0Pt1pQFvUOr +MnOeqO4btxRZ3E+wzZIPZyv2Fka+gsydeGecYWzRNjREt9DavR1Y6De2Bl0gglSBMWI/G0QQlU47 +DbfUNpQrHhiH/0rBSFbCjJZ3Ar6EMA/32CCSS6r/8Hy3YjJkwMux26QSf2/2qIkliOUilQkgiA/z +IcHWbyr+h3YzL0BWEkRXxDPjhzE7NqVujLFNPs0Vn2pje1luHykVYlYx3lT892qSa+nAw0xBtKOW +zdsUiBCt0jZTcSOmCqG4F9UdS8+q+qFelzKfhUpDyzxQddok3RQiVB33VJjnV/dz96wQlt9Wj31G +UXu1fpBOt+RdluI/t4Q7cBwY/SA25nZrYbaVivr6Z4oJ91Wm9WZ2IlithsMvuAfanOneamWjC0rG +8IEP7O7Sau7gKjynHOu5oiqjbIBBVa9a35T6HWvz5o2LhrbTpqEmmDT3DiW6P9vthkFTpiyOsX84 +lGtTysYZXLIgJ1YNaitGgO+U/MoWAkP0c0MN8lN4syRjV/3UZb4MbRCFdbyaHesq8a3e4w99XOOL +FLNYPw04aH9psZL+RRxsGDzrxVe3hExnNCnjAKmWgGLlY6GQjIztzpLpEFH7GIEM9hPerd2e4rmN +3NZNrcQZ/d/X4zbZev/ENWJ9dHSLBFpXRuAH9dJQU8hlVysJhsK04I3LdiiaPOzjQ/nnDDHgxj8P +PEdU5Ry+N59KHh5CxoZ84LFSV1ULDEKzbSB/eW0MQvPFohGoGYNQpqSKIT6HEQhVLHBgw68E/iQQ +mheXW3tAFowc+hT+Ldaz9nKFPDAN0R+hYjzNweoge85iMIRFIDS5hdwvP3A0V65QrlDuWSLknnNW +S3RYEv7QVYXLoHgLipWslA1BSLZeM4aqW4odRiZHAgRCre4Pux6LP6jqH3d4H8YfHNVLqHQpfZMV +MYen71uUFlX2TzeCjhTrCuDA50GxyLOsY+7tTF4kqQAIk9LMzq+FcVPfCITKTWBtogR8JV8s/5GH +1JysyBX0t0qa+5oAQu2muHd6XDCNlmKey1aLk5S+AQhNvsxjy7ZTh5t/yK+LVALuNkwdsgWeDELK +o5o5Mbqrp7duK1zKeCdrdV5u+bQtCqFkb3S8zDYTD3Zz/oz9imYFfboOmf7NUr1z8jJMlxSrzMHu +uJliF1sZnVWgDU9Sr5rcprBv0+0xd7jL2FQqP3Kbs2vjEUq2wknkYQd2yrRkQ0kB/H15xFQfNutq +kd36EiQhZ5Z7LMNVPj0sWLfFGztjkq3hJ3n0cGhwowUUUqPnXhe+DlRVDLXoTIDWk+g++1brbf/2 +jd/lBrR+kCpj7xoOVj7omHL2jUy4ZPVSYLmkqhAKfhUULVgCiv+poi2Uc9Z7Nb+O80BdMMpyRvfh +dSn3boA0Zbl26X4rcnZhFqsSFBY0MzeiUvVj/0PND6xa61u/vBmfmid+rqMmdMQ0mb580ERVeA2l +2GEkMxAIqqou/Fmm+Ze/1ucZHK3DeCsqU4FC2O9oCgnFHwOvgZrHycKD7JwS+WwcpsIFWtSBkFWX +ReSaryBl+Fg3KXU0xf49Q3yq4zK4TcgWGX7M88sit7d7magsaDILFbe2CPLlWWdiww== + + + lO/NrdZUwud4BpVBqShjYig11deyWayx8REyjsbkdmx1V5LNkUS9xHgfqp2uxIE8Vd1zgTSKLHhF +D9fEw+CFKJiVK7EBB+HuUVp+bPhC3VLrnNImTGZbVDlZLJtc2hSOvviFIZKofygPfGwiL7QCM2hW +qzebir/UzbEFIVPDeuJietMLtQTtDibEcMqzg2zgRKiRWuEuOHJqeB4Yzp5buo6nDze1eaBcWQ/P +zhHbV3iallH7m8asGFSZ8OkyW5zH+uAlUKvHmbA7n7LhDJG14y2sBNVP+RRLFKBQU/H5D7JdKGvb +qmyOnVr/xS0JgBQ+FO4sAZDE2o4h980WmQJb3XScqJXWoje7PEvx+dMbFOZx2Pcf1rzDsDRoRe3u +kzzBhhgq00qinhMyobJnwaiuFM91y82e5aGWaZNtOKq3AdP+QTD8NFYHTfbiFlItRjsSyrWF4G0V +MA/sUYhL0ke1bFMp54Y43OTDOqGoTKKW+HAHHb71sb62miLi3k0YBdMCymAmfThfAIXenePeCwfa +6aVJugCjmiNNeAidEZU3j4Tj3kiHimubrevhDaKUdN3FEuqeqpxK3WCHmzzc5WWm0GCCP1b3lRU/ +tfqwvg48vOBCRj0YHFPFcVsX5kIeIkc/5WIe6hOx9K+EXWSur4XpaVlvtsEhALWe1MOp3o5PG/Tt +lGVJrIGGdFGJe0wJcjVBWxOCo3J5pgrElGcbR3yLFHIp3t8p20zG6UBZaUNj14WmyoAf9h5VyjKJ +tXa14hWzqtIhfakFO2aNtCkGAVFhDhvR1eEuix0aoHGLLRsEUT1ysLyqdvR0/Rcv7lYYGCKnHBSt +Bufe8uQKwNrSzVW1CrlN6eVExKmoon9xEaeswQk64jWNHp3Wrm5fGCbaNC4+Ii1n1S31ACQK5k5T +SXWjgXdg/O8H3/8PI/F/nZGoqrEfjESKyRIjkZLIxEisGF5/MxL1AmRGonp+MyNRi+EfjESFqzMj +ESUxEu2YL0Yin5cYiVIyI9EW4C9GohbwmZGoVzAzEvVuvRiJePXQzOCMRA0aiZFYyeS9GIl1+VE6 +I9G4QTsjkdXYm5EoOTMSWSHUvjES6fO+xjcjETkxElFG3xiJfFivmZFYw/lvMhI1kX72mZORCMbl +m5FY7isxEjXAZ0biUhKKb5Odkag608+8vjESwWm9GYkspxIjERhCYiQW9Z6c1zcjEbnUjZGIkhiJ +Un4wEiUnRqKEzEiU8lkBfDMSoZglRiIrwJ2RuISdkTjVYCTqL8+MRM2HPxiJBUDvzki0eXZnJG5K +ujFTNkYiBcGJkah7/oORWGRvlhiJRfYT9xciETEhElESIrHcwJDHFyIR+Xo2RKKUjEgs9/ELkagi +p4xILISrd0SilixvRGItzxcisYJ93xCJ2CK8EYnICZFo3lH3hkh8j8tr/vTCMo0fPxCJ3LWESKSS +YEck8hh+IRJb1L5PRKI9rDsi0V6FFyJR70xGJNrLtSMSSeC+EYm0iCZEouqEMiIRi7c3IpGM845I +5G1IiEQlI1+IRMSESERJiEQpPxCJkjMiUUpGJFIi9UYkqiohIxIbblgbIvF9P/8xbznpzDciUXJG +JHJgQiRK+YFIBAiQEIlm1rUjEum1fiMSKxTIDZFYKf/cEYlaav5AJBJAS4hETaMZkVhp4jm/EYmS +y3NviESUhEjESeONSJT82SJuiMRKVmRHJKK8EYlyqjuOayEScZtLiETVtr4RiYpK3WVsiES2AAmR +uCk7InHJgUisk0sW5EOGhzciUSNQRiTq19X73BCJS9kRiZtqiET+rIRIhAv4RiTiVJMQiShtbIhE +Tn0jEiVnRGIFFbQhEiX8QCRSFZwQibgUJkTiUhIicZMdkajvyIhErQF/IBJph0yIxCogQUIkLiUh +EjfZEYmqB8mIRIxJ3ojESqfDjkgkkpsQiZolfiASFRTPiET6jhMiETPfNyKRJFBCJDILJ0SiZr4f +iETJGZEoJSMSG9bkL0Si5IxIREmIRJQXIrGSitkRiRqmMiLxPYquSVUFQz8QicrzZkSiaqMyIlEm +WT8QiZIzIhF/rYRIxIjrjUhETohETk2IRD7+jUjUlj0jEhUiyIhEpbN/IBIbnbg7IhFn2oRIZF// +RiQSEUiIRIsRLEQi/34jEpETIhElIRL5zhciUX9/RiTq92dE4lJ2ROJSA5Go+EVGJCqT/gORqNKB +jEiU2WJCJKqG7gciUcdlRCIY74RIhP3+RiQ2a1beEIm6IhmRuJSESFxyIBIxB0qIxBYezBmRKD/E +jEhU6V9GJC4lIRKXHIhE6mgSIlHFDz8QifoxGZHYRvlCJOK380YkIidEIkpCJLZRfyESJWdEopSM +SJTyA5GINXRCJMKET4hEe2peiEQVwGdEonHnd0TipuwktCVHLoBF+o5I1M/4gUjUM5YRiTDhEyJx +U3ZE4pIDkQgmJSESWce/EYl6IhIikc3JQiSufyZE4pIDkagPyohEypHeiER8whMisWFjtCMSzRbq +C5GIg1RCJErJiEQpPxCJBFATIlFKRiRyzAuRqGBsRiTKTysjEuXt9EYk4iaeEImaATIicSkJkbjJ +jkjUmJoRifrSH4hEfktCJEpJiESsqN6IRJN3RCJnJkSi/aUvRKKmrYxI1OycEYlLSYjETXZEYmPj +vyESMet8IRK5MTsiEYu0hEhsFPK+EIn4iSVEokaQjEgUQucHIpGdYEIkaieWEYlLyQPDlAORSMlo +QiS2Mn4hEqnCT4jEdrQvRGKbxPKESCTKsiMS8eN5IRJxItkRiZo0MyIRDNcLkYiaEImm7IhEU16I +RGocEiIRJSESUd6IROpVEiJRSkIkSngjEm1dsSMSwQomRCL3541IrNMnLRCJNHEmRCK7vDcikZqE +hEg0ZUckciqBpoRIxCohIRLVZJkRiWY090Ikak+UEIkK92dE4qbsiMQlByKx4r+9IxJhwb0QiXps +MiJRK6OMSJTnyw9EouSMSMTuLiESK80lL0Si5IRIxFZmQyRywBuRSFFMQiTigZcQiVQzvRGJkjMi +UUpGJKqc7gciETkhEjl1RyTy6W9Eov6MhEhUPVBGJC4lIRKXHIjEyvy3IxIx+nsjEvGESohEDTUZ +kbiUhEhcciAStRdMQET9JT8QiXrMMiLRLuaOSNyUHZG45EAk1qiHDkQif9IbkYicEIlSMiJRyg9E +IhmphEi0HNWOSER5IxIlZ0Qirt8JkVjv/guRuMbyeaDcwhIicSkJkbjkQCTad+yIRL0VPxCJNLsl +RCJh2oRIxPbmjUhUrDUhEonSJkTiUhIiccmGSLQY7oZIxBLwjUikVDohErEETIjEGh5xGZGI419C +JJpx+Y5INH/BFyJRg2JGJFJnnRCJS0mIxCUHIlGvSEYk6nV6IxJtyt4RiYpPZUTiUjZE4iY6zUwp +2YxI1J39gUjkCUyIRGqId0Qi7+sbkSg5IxJREiKRU9+IRBsBdkSilIxIxM3sjUjUr8uIRFVKZ0Ti +UhIiccmBSJTnXUYk6in+gUjU054RiXotEiJRk/kPRKLkjEjUHJ8RiQqJvhGJtZ9fiERCpwmRWCcX +ISESa72+EInmgLQjEjdlRyQuORCJiuUmRKK+9I1IJGmfEIlY7B7HhkhEeSMSkRMi0Wg9OyKRv/SN +SGRBmhCJ1ICWY0MkbsqGSFyqIxIrGa3FPsQg5xuRSAgoIRK12kuIRC0IfyAS8Q9/IxKtorzUhUhk +mZoQiZuyIxKXHIhEbToyIhEbzTciUQNiRiTS2JwQiUtJiMQlByJRj1RGJOqxeyMSKR1IiETFwRIi +ETbJG5HIwJMQiTrzByJRYZ+MSFTrVUYkgmR7IxKb7Zm3A817a0ckLiUhEpfsiESay3ZEIvbib0Qi +rbUJkai+14xIfAfPV2D9P4RIbNHJmhGJrYwvRCIHJkQidspvRCIPZkIkajDOiETdiR+IROSESMSq +IiESpfxAJHJvEyJRSkIkEvV7IxL1VCVEotBBGZHIZPdGJCoCmRGJcrTIiEShAH8gEhX33hGJCiZl +RKJiLj8QiZITIpHjdkSihB+IROSESCSqkxCJUn4gEkmzJESiFSxuiMSmjdUbkQh1ZUckKvKVEYl0 +vL8QiRAvEiJRHfQJkdjIfb8QiWqpz4hE/qodkaiL/UYkSk2IRAkZkQih4I1IJBKYEIkoCZGI8kYk +Ss6IRBr7EyJRV+gHIlGRtYRIhNaSEIkiB/9AJKrJNiMSIbokRKKu7huRqFBdRiQ2tlgbIlE37Aci +UVNJRiQqnvcDkSg5IxL14zMi0cxlXohE/GQSIhElIRJR3ohEkjM7IlE/IyMSdeYPRKL6eTMikWKf +hEhkIHkhEm383BCJDLEJkfgendfw/pcRiZYTeSES9XQlRGJbMJ07WBD9ByKxmVv2hkiUkhGJKG9E +IvKOSLTjNkSihB+IRAbbhEjUvcqIRKuyeiESNehnRCKzVkIkNlzXXohE8+7YEYmNBvgdkYjyRiRS +DJgQiSgJkcipb0SiVj0Zkag/ISMS3/f0H3/98SEg+0YkSj6vsSESWUH3viESie7e1zciERnfu0Ak +olDzG4hEPuy8ni9EIsvthEhUXDUhEkEjvRGJlezcjkjUfiohEvVkYKqXEYk8MAo7TUQitUsJkWgP +1fhCJKImRCJfcdwbIlFKK883IlF1MBmRaNvEHZGIU+kbkagQYUYkKryUEIkK8/1AJGLGnxCJNWoL +JiJRW4ofiER4BQmRSCg2IRKJ6r4RiYTTEiKxToR7IBIVG/mBSCRkkhCJUjIiEeWNSKR9MiESUTZE +on3UC5GI92FCJOqyJUQiAY43IpEy94RIJLK5IxJ5rF+IRPz/d0SibktGJBJ8fCMSFdDIiESejh2R +qJTKD0RiZamzIxIVZsqIRIJ+b0SiHreMSKS7PCESgZO9EYn6MRmRSHBrRyRS8ftGJCLviESEhEi0 +ouBvRKIXBp8TkWjXbEckSvmBSNSPzYhElRMmROJ78Pz78zuetG9EIhVso22IRBrfdkQidYVvRCJy +QiRSlzj6hkiERaUYZkYkYgiLOWQgEs0idkck0m13PNcXIlHVSxmRSD1T7wuRSEPeU74RidSLJ0Qi +s+1Qw7UjEhUo+oFIBBe1IxLxGE+IRJSnPl+IRMlmGBuIRNyZzcHXk7wo9/mNSNTsXUZ5FiJRs1pG +JCqD9wORCNQgIRKN3bAjEnGneCESlbjJiETFuDMikeL6NyIRMMyOSKy04+6IRCORvBCJJBsTIpHc +4Y5IVCrzByKRcFlCJKp85TrOhUg0D/cXIpF4ZUIkmr3DjkhUbPUHIpGOpR2RqLhvRiRSFfZGJOrM +jEjUJ2dEIhHiNyKRLHBCJOrXZUQiyhuRWMOYaSIS7dQdkaiP/4FI1F+YEYm4BGyIREgkb0QiVywh +ErlYCZFYIXS9EIkaHBtjQyASqbW+64ZIxHKAMvINkUjUNSESK+iSc0Mk6uf+QCSCLg== + + + TIhEZRUzIpFM4BuRSElFQiTq1IxI1ArsByIRF/aESKzQrOuGSKRK+IVIpDIzIRKNUbgjEilefyMS +kRMiEeUsGyJRSmHRnhCJVLAnRCKByoRIlHLHmauK/3i+EIkawooC64FIpND2jUjUwJYRiTgKHH1D +JGqQ+IFIpGwyIRIZ5hMikTmu1W9EIjL9TIFIlFKVppiIRCmsyDMi0eacDZEo4fPjNkSiKd+IRE6s +z4ZIrAe74Q2RSE/cuL4RiVRp7YhEdXzdbWyIxEIG8xuRqIKpjEjUd2ZEoqbfH4hE61XcEIk0oyRE +ok1cL0SiPrCPY0Mk1nALnohErZl+IBKpjNgRiayXEiKRFeEbkUj+OyESyUMmRKIt2V+IxDqZnIFI +hE/2RiRSFZEQiRocMiKxXs8vRGKWGQqu6K5yRGKN8riMSEROiESUhEhkhfpGJLIyTojESpH7jkiU +8gORqCk7IxKpmEiIREqG3ohE5IRIlJIQiRLeiESIgQmRSP59RyRK+IFI1KomIxKlZESi1kM/EIl0 +F++IRKoEdkQiTrkvRKJvmzZEIsacCZHIZvmNSGSTlxCJW5rEEYkqXf+BSGyArnZEIkpCJHLqG5Eo +OSMSpWyIRP3zByJRuYCMSCRQlRCJMrH9gUiUnBGJDY7YjkjE4PuFSJSaEIlcyoRIRHkhEolY7IhE +7WYzItHy/l+IRKo6EyKR5FFCJFLA8UYkVhIROyIRG7iESATz9UYkYgObEIlArBIiEfPeNyIRK/CE +SHQP0Q2RqNHgByIRH96ESNRfnxGJyuC9EYlSMyLRlA2RmE5ciETkhEjEcjAhEqX8QCS26W4WiESc +CRIiUS/tD0Qi5bUJkcjvSIhEMwl4IRKJ6e+IRFouEiJR/bFvRKIGhoxIxNw8IRIJeL4RieyTEiKx +RnPURCS2abe3IxIZjXZEot7ahEiki+aNSEROiEQpGZEo5QcikX6bhEi0BP2OSER5IxIVCsyIRIXM +MiKRFOsbkWg5gx2RSLtYQiQqqfgDkYh7akIkTlvuQCQqA/oDkaisZ0YkKgOREYkG7H4hEg3vvSMS +yWkkRKK+9QcikV6BhEikIyshEvnBb0Qi6b2ESLSE345I5NQ3IlH5vYxIpDsjIRLbBDklRKIC6BmR +aM1GOyJReaYfiEROTYhE/HN3RKIH2b8RifotGZHYWObtiESy8G9EonKVGZFI6jghEskAvxCJtB4k +RKJ+RkYkKsX4A5HYGD52RKKu+I5IpD/vjUi0fr8NkSghIxKl/EAkSt4RifSsJUQiyhuRSLY/IRIt +B7gjEunUeSES9cdnRCJp/x2RqATyD0Ti5MZPRKI+KyES9SN+IBJN/pMRic1KljdEop77jEikf/ON +SFRWPSMSsd1OiMR+9F+IROXZMyKRm5wQiaSR3ohENycuC5FIwiIhEjW6/0AkUki1IxLBpCREopYE +b0Sidi8ZkahX5wcikZqthEhk25AQiY2W6RciEVZFQiRq+ZgRibqIPxCJzJIJkahrkxGJtLG/EInK +qmVEIqGPHZH4Dpv//dD8fykikfqLNyKR+ouESKTaYkckIrwRiY1O+x2RqGc2IxIpd3ojEmFuJEQi +SkIk2jEvRCKfmBCJUjIisdHp80Iktv5MRCKFOgmRqJH7ByJRs0hGJGrgyIhEVeX9QCRqWZERiarh +yYhEjRA/EInU9uyIRCp2EiJRyg9EInJCJKIkRCIf9kYkikqREYntOTMisRN/fyESMdHjCZkHsi85 +N0Tipuw0viUHIhEchAHbjH0IfePcBP/Ow91l4zCapXdEIk7vL0QiakIkoiREopQfiMReji9EYldN +a0IkSnkjEjummOdCJPYjNhaOSFxCQiRucrgKk3QrC5Eo6ANhj4xIBP2gKW/KAjVYbD4QiUvJN2XK +gUg0ukVdiMRu3jlfiERAG93TX7wbgmBYlCMxEpGxrghIIsp5LUiiBJ/GNkgiarGOP2xsgLVoHz8h +iVJYxWRIop4rC1MGJFG3M0MSIbq8IYlaGWRIIsuTBEmkX/UNSUROkEQpGZL4Hpr/vbnnPw1JJKD3 +hiSyWUmQRO2pMySRefoNSTQPrh2SiJIgiZz6hiRKTpBEorcJkkgs9g1JtFz8DklULDdDEivFgi9I +oqIKGZJIkDlBEukkfEMSkRMkESVBEilfeUES6RrbIIn0le2QRLJOb0iiggwJkqjbkiGJ7zv6j7/+ +8JAufkMSVb6RIYkcmCCJUn5AEpETJJHgbYIkSvkBSdRGMEMStYLPkESFe39AEmkMT5BE6pITJFEb +mR+QROQESZSSIYlSfkASMTpIkES20gmS2MIjP0MSiTgkSCJ1rAmSqB3VD0hiw2R3hySqODJBEqeQ +IIlL9fIJ7CgSJJEB6w1J1EY6QxKp0Nwgifbvb0jiUh2SaH/SDkls5/ULkoicIIkoCZIo5QckkX1n +giS288qQRJx735DExsu8QxIVWMiQxE3Zq1qWHJBEfWmGJOpy/4Ak4naSIIkE93ZI4hISJHGTnepB +6WiCJML9eUMSrQNghyQSKUyQRG03f0ASFe5IkESiDAmS2NgrviCJBKYTJJFNY4Ikkp55QxKREySR +ttAESZTyA5JI7DhBElESJNGOeUESgXIlSCI9TAmS+B5C//4cr8n7ByRRa7sESTQvmx2SWGv7BUnE +kydBEvHkSZBEqn7ekETzBtogiZyZIIl8+huSaAUNGySRYo0ESazQ516QRPNk2yGJKlPIkMQ6ia8J +kkh8I0ESURIk0WIgL0gicoIkouyQRL70DUnEgydBEnVnMiRxKhmSaPIOSSS1v0ESa4/g7AZJpL5q +gyRaRcoOSVQ0+gckEYuOBEmk3HGHJGol/AOSuLwx5oHyIEmQRFPODEkMcUISqQZKkEQ6796QRCtE +3SGJhMUTJHEpCZK45IAk8rMTJJFr94YkGqJmhyQqYJUhidSBvSCJqAmSiJIgiVLekER9Q4YkSsmQ +RCk/IIlE03ZIoiVYdkiiPS0vSKIqLjIkUVckQxI3ZaegbbJDEqk3TpBE1eX9gCTSO50gibh17pDE +KSRIYqgTkqgvSJBEPdw/IIkkTRIkUduODEmcSoYkmrxDEm1rt0MSsW15QxJV2J8hiTU6QiYkkTK9 +NyQR/9UdkojZaoIkGhTnBUmEjJMgiRQIJkgix7whibX1L0gi7RsJkqhI2Q9Iou1+dkgihXEJkrgp +OyRxyQZJ1EdlSGLFyfsFSeSnJEgilX8JkojyhiSavEMSURIk0f7SFySRnWWCJBJwSZDEpSRI4pID +klgJZOyQRCzx3pBEbk2CJJpR9g5JBEX2hiTqpcmQRCyFEyQR/NMbksiGNEESVXORIYlLycNDyBOS +qBctQxLNuOEFSTRnrB2SSNFWXZBEYAdvSKK5ce2QxMiiZ0gi6bsESVQBTIYkqofsByTR5B2SaMoO +STTlBUnUcjtDElESJBHlDUkkX79BEmnFSZBEzDS+IYm8QAmSSGdtgiTi8PeGJDYsb3ZIopQMSWSP ++IIk4ryZIIlJwc+AM9+QRG2YEyRRQ8cOScTD4BuSSG9OgiRKyZDETdkhiSbvkEQcThIkEX+bNySR +Aqkdktha/4IkMi6/IYmSMyQRF/YESdTb9YYkSs2QRN7CBEnkmDckESOgBElsnLFDErXN/gFJlJwh +ibAXEiQRB443JBF5hyRyZoIk8ulvSKL+jAxJZLOVIIkob0jiOjAgiY0JsAT/0Nb8X5BETfo7JBF6 +SoIkLiVBEpcckEStWTIkESeNNyQRh5YESXQnk7EgiZuyQxKXHJDEhrnwDklsMzuyQxJREyTR1qEb +JJG16zckUWKGJKLskESENyRRn58hiZb33yGJWgn+gCTOKqh5nLqpEyRxKQmSuOSAJNpXbJBEFvcv +SCKNqgmSaJHhDZKoEPsPSCJsxARJJDacIIlLSZBEk3dIIhW2CZJoIbUXJJFGwQRJlJIgiQhvSCIG +OQmSiJIgifT/vSGJuqUJkqhrmSCJU9ghiSFOSKIFJndIItSWNySRCTpBEqli3SGJS0iQxCnPHjJF +uTIk0TuHry9IIk9fgiRSNZMgic1sOb8hiUbi2SGJKDskkTPfkETkBEnEPSlBEg169IIk6tdtkEQs +CHZI4hQyJNHkHZJIie0OSSQw+IYkWs/uvR03yhckUfuBH5BELJUTJNG8GXZIoqKnPyCJOjBBEomy +Jkgi9WJvSKJC8BmS2K7nC5K4lARJ3GSHJFKblCCJfOsLkkjVQYIkSsmQRJQ3JBE5QRL5sB2SOCvj +MiQRe5AESaSoK0ESN2WHJG6yQxLbTKEF+1DR9B+QRCrmEiRR2YUMSZQJxQ9IIvIbkqhPzJBEFqY7 +JDGEDEmcakAStTdLkESAXQmSyJrbIYlagWZIoikvSOKSA5KIcWaCJAJtekMSaZRJkERN5hmSSKPi +G5KoFU+GJNIC/YIkMsskSKJCewmSqDKrH5BEOst2SKKSsRmSuJQESVxyQBLrMa0eHZJIY9UbkkjT +2Q5J1G3PkMR3YPzvB9//94Ek/n/OPryal7En9KGKcak0CJWKdCdxkQZUsTgtXDv3UMskc7x17KFK +/WnUC+rh4176GXqovo9j2Bqd6nsg82zzHXn4RPnsRjx8aKL5M3mHEOd9pQ/uUA64wAgS7VA7ze6N +Y8RjVOxIa3SUO1++ec+wwxPD6XPBDsdksRjrcDpyJdSh2Uq2P5N0GI0DE3SonRN1molz2C4b/Sbm +EHpHX5BDbdVYJiXGodR6tYU4lDDatQiHbOjKmQCHfa5pnG8ok5qzWKMbgR0Lqu10wxo0FIcbDm9L +mWzDEDJBb6qTbKiq8mfxCpW7rN9YQ/34XraDbgsTTaahUDmnZY42r2AFgaolhSzeflqaY/IMA7yT +cYZYBR1Wam0eGKftnyfNUK4F7SyrU83nDm+5CZah1uEjcrn2hIewswynGizDOrwpaRIKLzO7yyRD +OdlMpyKpxyIYHl8X/vgTzMIj3q1opTzcPCoTC0+rCpi8Qr3BZL4TsLAa1mDxCmu8TIErVA1r+YYV +KmbhJiPGKnTkyEIVNvfCz6TCx4rGJqiQiHE3018zjazWgZk5hSNIIqGe0Z7ulMKreUdqghReLdzy +nVGo/i5qhAJR+Bo+1+TlVV2lP85pSITCIh8CbkMQCss4nf7nhMIyvEJ2RxQiWlDSy7VQiLwEorBQ +jF37F6KwqMLmPspCFEphYTsRhVLaUa8vRGHREp0lcSAKy1ksBTkRhZ/503pUMqKwnDUs1ZxRWE6v ++ZqMwqJ1ZnX44IQUop4ebSF2itKtldcApZgZDlMWo1Ayt2cyCqWQnpmMQinW3pgYheX0bfFkFJYR +XZsBKXzf0n+su968nzBDCiWTW5iQQg60NnyHFBYPY2RGoVTy5ZNRKIX16mQUlmYVaBlRWKbDRTAK +C9WXfZEHi8oPeF0TolC1f7hChyrHwFHqAhSe4vyM+4tPeLrB+cQTYuUny5OgE8rK7w== + + + ub/YhEoJawydaEJtMq6rLTKhhFb7F5hQ3RmykQ4u4fC+pIklPD03mKiEMj0sBAscSihCjGaiyfda +wo4knGoQCS/vxZ+cQQ0GeNknHuH5GDZkqnLCwi8+aIRT2GGESzQWof6Wx8ulVQygMqxnuOHPHLHO +27oAJodQQrgQ0HYY/XaZQih0hObTCdODxTNc0AoMS9DL6YUzgs2LRtmKIwhVNFdAozmBcAoJQLhU +5w9qA2rhd6cKXlfAG3f6oIA1GA6FqjUbxgHBHpxCQg8u1cmDCqgAzQjw4HMYzyJhBx/f3k3qoJzr +mttcmHBaWCQzBwvlS9wujwgUdW2R5Q3mYKmXF0Ak5mCBAtN9z40tR/XC/ckc/MzWYVK3MwclG3wy +TBELPtSX1cfw0Ba8vq8/GTkolf63iRxEYQwI5CAK5gaJOVjIbDSLFNIjVTBEwevDmYPvQXFNk1ha +UA+UmIN6W7BGmcxBlRoR0ZnMQWIQ7WxfzEHJpZS2mIMYVun2T+YgIRJNkZk5iOwDqXlF6Mzqoy8W +lXy6RueMHNSDBZVgIgeJNx39WshB3glthzJykEYtNxThkwmhPeezRiQ2yfbW7sRBtteKDUziIAoe +RsEcRImLsJiDyH8mcJB/6i5P4CCK2d9swEH7WMe1Mmvp11vVTgAHl7IDB5cawEHFAm4WYcERFKaM +TU8GDk5i1zpQTE/8TYI4qJmhniBFd+JgiT71SRyEik2hRoAEbVK7ri/iIMTrChnJZV0SXoVJHFxK +Ig4uOYiDeO1gzhMgwYKlscq7EnGwqCAZju88UECZ3hZwcAqJNzjVwA2K8mXpjqAIlusKoOyOG9Qv +Id65DoSNaWFVrO6xrmE8S7RBZJsCnTZYwtBi0gbL7f3jmTYo2UIMQRsEX8aLE7TBglPAY8csuyf9 +OnPMCtogdHVsHQIiaI/M6H8ybVC8snHvxwFwP216YouwKTtTbMkRUxeZnfFqQgT1M2j1zLRBPV/G +eZ4HyiOFMvqgDW7KThtcctAGC+0uehiDIgjOXquOBBvU42B4jnnciJ4KaIPrn4k2uOSgDeqTuNwT +IqgYrE7IsEGlLjQ1r8M0yh29LdbgNANMsEG8mIq3UfmOdJiP7oQNMpUMZ79tFnIKRI6nL9igFJzW +J2yQY+w/dpc97Ws1bU3YoALQ+D5OiKCGXxLpmTbIoKkJfB03fDkdsMGlJNjgJjtskPHcu2zMTbcc +Zp6ZWYPMBM9zLtagzQ2aq5w1iKeTxsaEGjS11oUa5EQ2joEatL+Tn7WjBkn9MWsGalCvDaumiRpc +SkINbrKjBitbd9kJerieFZTq9hNqkNuigHKo5OWua5EGtZZnd5RJg9hy3dzPEn/wiMnCAYJqWbYP +T6RBtnNaz6wD223hlkkaXEoeFaYcpMGiyh5w30EaLKq91biXSYOlH14HHaTBggO10ynYMhTA35c5 ++y3SYKGEepjRnIa9QvjESeiTNFgON7Keh6mYiNRHkAafYSm8BBpEvEL8bEEQxv1nYgYRWggBydCa +Cc/GgAyyiHqsYY8SFQnW5bsjBoXx4NUNwuAzUTIGGFSVkdlWb3zB+/FVROAFZbllWHi3YT59l57h +gmYw9meiBZWAo4UuyILar7EKS2DBM1ZawRVEOEwg/abziA0lqqBWLPjJBFRQk+2JGaMzBUVKYfxJ +SMHbV/ATKaiplvc+iIJL2IGCUw2eIEVbmn4DJ1i0zGRmSDxBPRzs8SdP8PN2Wlvf5Al+TrOXOPME +JRv1N3iCUqx0LniC5QiAR+IJSqbSP3iCEphVAyjIEQH7XH5iBbvYx9BpROvLZ33kxmIOFCwKz1Bm +uPMECxvqsXCCElgYT5xgKadvHBJOELn5B9q1LOEy5zhBPpw1bcIJFnZCxzVxgs+zQILP84UQfJ4F +DyzMZ1RtOxOwKCrRyxc7sNTTDK3nYfLxolD8joCTCwkcONXgBhbScA46xKCkVLd9zODAotKJ253g +7UBdH8XzJjhwU3Zw4JIDHFi0CHm82EkO7vw9hVLSHRyIfJdzgQOlELGc4EApnUuWwIElfP0nOBAl +CJuAA1FYfSdwoGTW1sEN1M+9rcPCcYCFSpuAt64z58g8D1RFADUWwQ1cSuIGLjm4gfYd57lwgNqT +08yXuYEKLttOch6oyGlzb6EZ1rRNZjIoUfxz8HRZwpbA6TX6wgYuJWEDl2zYwNJ9nApsoCIgZsmQ +sIGSbyLOgQ2Ucl5xIHc02goyNlCyDx6ODUS5L4cEKpHFqVrbZGxgqcPCZxMbqEt5RFENvkJLSdjA +JQc2UC9Iw7jCaYCleC11xgba/KuaiZCFjKrXggbGvzdk4JSc7aXSH4pkAgOokfCyIqKdF8iTB/Vr +HqjqRGhDAQxU+NeJ5TswULL5WAQwEGU4QpCwEKeS/kvAQGRDPvk6vZRwIQpgoBTjKiVgoH6en+rA +wKJUIOm6AAYuJQEDlxzAwHI87loWHMDHw0yZF/gcwZZ29e5uQeS0wHvWze2wQHV6W1LXWYGX55Mm +KlDDKdXGOykQZM/zZ3ICtR8/ik1+4B9AA5Am3CmB5xHPqqvjdAugYAQuYUcETjUIgUrF4M4XhEAG +27NkQKAS3aW0xQdUlWdU2JApOd12INMBT7f1mXDA0yOdkw3I8OnAvYUGPLtVK00yoNCOAVEgjbOE +jQs4RccCaoSjdDmAf+f1JdiC7LCRe6qA7Xcu4BWo8oQFvIpthjIVULZv7bgWFFDLS6sedybgEnYk +4FSDCIhHHVY33iVSwoQ/941oviaXsw7sURsRQMClJCDgkgMIqDEaa/QJBFSk1i7PDgRUas+KEQII +qDCV0XSCCKhwyBHlUosIqACcdYQFEVCnOlJjJwJqg0fF/iQCajfKBm+C/uSMTBVRAgLSSGrLsjgO +pykKUSJsMJUEBFyyAwGtwvayxATG8mpe52clICBtpGeznb6VBsubn1VSAAHfke0V9f4PAQHZOZbj ++QIClu7xygkE5ECKHQMIKIUUXgYCFpkDXLTqOxAQGy9b0jsQUDfCYOcJCIjcy+IBlrCDnTxA26Nf +7YsHyJ2FshA8QCmk3oIHSFzOlzELB6hHipXq5AEq5FKqU7z0DJXr+CIBElrRknKSAAnxd+cJQQIk +rKRlfSYBUpNo7yokQAV6zIkiSIA4e4ynf5EALfVx1EkC5Ljb+TkEJhUup1AhkQCRj2uBAIm5WI7e +QYBEeW8nSK20C7kP8+/0siMryjvPCQLUg0gDRgYBGiqEslUnAWKCTi9/kABp64Z6tpMAATuAcnMQ +IEXBVp9rIbFKgnk8XyBAnP5pZgkQIH8VDmFBAsSTiZ+VUIDYPlEEESxA8hEaNiYLkJwFDUyJBUic +Ds5YsABR6tMWC3AmQDILEKd7LnqwAM3BH8eNFt8ahrWJBUiwhQqUgAFi9Xfx1zsMUIEMPMAzDFBB +JHvfAwYIu4QCjYAB4voEEy3RAMnK0tUVNECySUDLnAaowdMrbncaoKK0hGsnDRA+CfS8RAOUTFhn +0gDJ5tEsEDRAqhtYciQaIHUJLL6CBjhrHCYNEOU8v2CA5E0IBwQNUD+DoETAAEkHUpuSYIDirhhD +NGCAherrWhYMsMCFohp1pwHa4NnGwgEywDKEBA7wPTavwf0v4wAtaXGULxygBjqsbQIHWJ5IKAcO +cNqVJRygVE8qBB3quCxAMnGAKBY823GAyIxTwQO0A4cpZgBxXBZhSzxAhlyIYcEDVJ7ArPGDB6jx +Hre8zAPUoG/cnuABMmmRHwgeoNJ/1CVlHqBkZ9I4D7CEjdfkAaIob515gAWHRUMuEDZAePxLwQFy +JhGQhAPUkgePu4kD1F/Acm/iAN/39B9//fGROfDTvmCA8pKAyRMsQEqq2rNQgJoV+MMTCVBqO64F +ApRwtmdxAKnWuvoXBlCra+KRQQHU1B/BNo0ECtebLcvOALw9ZDsRgAwcmP0aAVDlZ6M+XwBA+Q/3 +py/+n/73dmQfhYb636N/4//O4muGoP/p/z3uxf6TXp72hf47byM+TfKfBjNqewP8R26mfGH/hFZg +gxHUv6gAC+hfUZKLpqsE/VNA335mQP9KJPcn9E/bBjOiTtC/An/FDcCB/hEuZe8X0D9Cr+YjtNuZ +lKjxn9C/YlDysqB/imzw6mToHwEP2loD+ifFGmID+odSv5l/Uq2rNZh/KNYZDfOP83hEEvNPvw30 +ciD/dNEIGQXyjxCFffSO/CvUCzlDkP2Jgny2f3XkX1G2lp3qjvzTiUYpDeaf7oqXHzrzT+3uLIsS +8k+VIrh3B/FPDwZbPgf+3eF/mnh/j/elTNzf07yiN2h/jw83GfanubkNs9LmB6tNLWpsKXNW/ppp +IJH+hGmgxClAf48vQSboTyXBx3V/cf6eGUs1zJ/+zbAYlD/VDI8nM/6e0y5dIP64Ro4QJMVPgbD3 +GKx2wjuSP8H3U0kgIVvH+30Phn9/tlZbKpWxie0HNF0PfqD9xB20FLij/bq38meyn1SW2AH2I43f +rJuOFWv3CvKM9eueJJlUvz581op4AhuQx79vup91XxJNpB/EMspOjOin9+kp9Qvop8Jq8h/RQzXk +3ESq33B+8tw+ncm3aH6nG7JOmh+u0ldfMD8JT+1fLD/1Rl93Wyg/dZkNliGeRKXtjO/fQX7ig47S +F8fvcpPIifG7vwF+GvbYVU6An6pnsdSZAD/V6tneZassUALFl2HO71Ow2Q2unN9X2Ob1PxnfpwGH +7Ung+4qDuSa9jyGJ9Vmi9xX8suq16H1k6qxV1Oh992VJr8TuU0zrrovcp83OcVoaWfdcSagbV/Od +23fGSi6wfVqak5MJap9ecOIwCdqnxhvKY53Z9wSLJZB96vuluDIR+xQFYhiJcubbLa0nr08x2tKN +oLVwfeIoUXQSqnx/yIQGrE/C6VY8a1Q2eyBbC/PGcp4dRV5c7qs8q4nTd3tSaWL6bq8QDUwfyJfD +luuL0ndHhWlA+u7iEalg9EGI4lfuiD5hZXnPg9Cn4mM6IsLqTRaY12GsvAnoo+3eSZIErMFmnLZz +5/+5q9faJTqfepxBCAacT8lhezYCzqe8MinOxOajCOGuC81XjiiQCDTffUaGcyfzqWuVmxpgvkA/ +B5avP2E1tVH5+qwadiifRmWD4jmTb/ivTES+ET2hAeSTcPphZOeVUTOw6Y7jUy6eaGHQ+EQZZKsS +ML6hrFk1AuDqY+nVkmyB4mvhBxYvfMRCE4hPBh/DLbMtIasaiGbVrO4ZYQnvBOFrHi+ZDD7VmWDa +Fgg+VbE0p+EtAp9UKzn3mj6tKK10x/l77bZVccbvNW95nvg9Pcm1W52UrVZvH/4TfU/n1fta8D0l +2o76LPYexclX/ULvadUD8TPIe+puscp15+5ZFVfm7glxATA3sHvaRT9OZmAM1RNLHDRB92ifOy2G +Yzm+7jvPYO41vKy/iHsw7XXtAriH8azvu5hP78dfg4Tbo3IAjJ3R9oruPWUaQdsrdQ== + + + +rrttD1NMTZMBW2PJB4jW9D2bLHcv2B7TzhoBWtPS23LnCfWXsH13NlUVql+eGnvZO2V4hNtZu1l +mRaNMtuEHLZXokAsw/aQCcoGbA+FaG7A9go9Cqe1Ly7YnmTjEQVsr1De/Rh+D8deKdYqlmB7JYwm +J2yPKgPLnbl5sqZ5SpAzbA951MXak0AZVLD2JPQy3TfXacNa/hy1R86676w9KRYeTKy90jypNFl7 +Ujxa5dkrLV1uMEmJtVc0glimx1h7yjfxdAVrT3VrzVz1NtYezWsg+hy1p3IAS/8Hak8VfUZvT6g9 +pYNs/RuovS0B4ag91Wwb3Tqh9gpB0Xot1B5KL4u0x5nj+gLtSbUQh1eeSrA1BZw9/ZMIT+bsUR9I +hXJw9ogAUY0bnD2BUvjNmbMn2czF3TMCoMrptTIEVKRYu1bi7Ek+GCwDtGcXkqqhO4Jalxe97qC9 +EtUqAdpTGs+6BAK0V0AJN2+MnB1nt62PJmiv4FrVywLtUfJAAUwC7ZXqaIEJ2tOp3OwJ2it0JB/3 +F2jv82GWfJmgPbUxsh6foD11J5qZTgLtFdi+vS3Qnk71rKPHj4rQifoZibNXlPajECk4e/rj54aT +TmVVdNJykTh7JQohJmfPFBhsbryWzlygPWSWNgHak4Lr2wTtSbG+hQTaKzhkOZOVVH5p087iiIbb +4R+WQHtUl9qw7gsnfgfJmADtFUjSvX2B9ujsJMHqoD16Daxw6oyiIA8WJtCeRgXrsgrQngYir+10 +0J4q5myeSqA9tjSV8ljvly/RETRBewXLNpbYO2mPschW3o7a04trhvzB2qOB5II8u7P2kAmYB2tP +St1Ie/o31NsE2qPN5PHzbD4j7/2UBdpDic9edk9qLCAZP0F7KvE3f+EA7ZHB5CYn0J5F4++2QHs1 +Wm8naE85O6uQT6A9HDjpoQrQnls71wnao1+IYSaB9lidnW7eaA6zqr5iXRGgPXpXKHlOoD2DRI9n +gfYMclPvBdqrEL+I7+ygPerk7bU8YifSvKw/QHv8YGDlCbRHio9mnADtGXTiuBdoj1PZGybQHhYw +hKwCtEdnAs9vgPbK4wGTDNqDiWHjXvRRqBWAEscA7ZXbK18yaI9T+dZnNrQ+VikRoL1C3vz+4uzp +p9hqJjh7lQXe9SzOHjnuKIOamD1Fp8yIKjB7tEXY+sAxe4bjOscXZ4/C+2fiHJqFHMzDMjh7ijpw +4zNnD6CJVU05Zw+6EaVhxtmjCc1awHfOntnKFGexnsPDRGTgy3wGH/+oBNqTbAFoA+3RqkU0NUB7 +KL7gWZw9kuklHMMYdEiu3QuzR48KPeY7Zk9/uxUROmVPLwehqqDsKTF7X+ZSsSB7Th53AgRVn4pI +nRAAnbKnn8C4kCl7yLiPJs6eAn6U+E7Onh57K2oKzh5Ni5QCJM4elfe9LMwexs28wYHZs2a/9kXZ +q+F2HJA97jDNdG02b3bvrEqQPb0cFNpPyJ7WhbZ8CciexnVbD+QaVu2VrBPBIHsqamUbMCF7Wg5Y +A0ui7KkgiqzEpOypIMo7lXfKXqGcfxh+yzKQ/baQXkD2dAhPWobsaf1sHaUB2dNOjZ8wIXsEJZm3 +dsbe3b0KPzLkVyzPgrAHv/EcX4Q9mWmSGgrAnmIZLI4DsPcKXf/96Ph/KV+PgG11bN7i61HRENR5 +ZC4Ab4bz9RAuP3Ob7zVgL7genmI0wwZcT31PFl5IcD3JxhQKuB4KPtEB17NjTu+jWTXde00IA5AU +i/oGXE8KldMZrlfuMILQyvLxDqtJ19N4bf3Uia5XKdM+LWltC3aZstDcEB3gpMztP3a6nl4zK0AI +uh7hN+5A0PUIs/gSII8XNps6XI8KmNPRayT0+NvYeiS4HvIZRQ+3n0rCa8L1+DAn922UrIqbpvl+ +O4HyidEhWu81fsX7vuB6mK8luF5lL7LD9TZl57gtOeB6YAR2uB7UhhdcT0Nvguvpt3m00OF6OIQT +at/heqiU5wVcD8U8lxyuRxDrtCKrleUheMt6P9h6itlbGCrYelJs+5PgenojvEvW6XoWx/ZGRGvF +CiHR9TbZ7WjleZfoeko4/KDrwQxIdD02n4mut5R8V6YcdD3DImx0PahyL7oeK/NE12P1/qbrISe6 +HspO16ND/kXXQ93pelA+El0Px+I3XU8PVqbr6Yaat2FA88yn9ih/Ml0PE4pxbcdpWcIlDbgeHZq3 +NxYtIzLk4eA84HrmjFAXW+89LP97885/mq1H/M6e152tV4AxNVv0Mbsr/me5vWDrMT3Tw5/YeqTw +eltoPQRtHSZajzO1lMxoPclESQOtR6j2GvdC69HjRYAyofWIa4bDrAWNDo8eTbSeCkBItGa0nhxJ +bGcYaD169MzRxddV9NTxRCa0HjLrrkDroXRn8Fk464i0dmLrKSdkwSuH69F8SPg86HqkjXrw92bG +thzu9hF0Pd0YW5oFXe99T//x9x8f5QrpkEl0vUJO0S3LqfrmQCMPeM0FCmmTRNcrkWycdD3CtVPA +o+XwGHSC6yn4Y1HtgOuVHvztYObJqMtKVBJcjxVi2yl8GlTN0i7getq+kNfNcD1kbMkCrieFp3DC +9aR4aekO16Oxn+1FwPXYPpMSCrheNW/1+gXXI8pAZizgejVoOxOup0fefHoTXI9Bn6qsgOup0tDL +PJ2ut5SE19vkGhZb1WHAgc0rj0e6E14Ps9oriD105B0zoWF8PROau4YtWtSSryiV8EDBJOxp0LUO +oETYQ6Z2Pwh7KBqVJmFPiv0BibDHnrP2ulBx9XBjtCDsYftq3To7Ya/ySg/PhFgQJ5hxQdjblL3G +ZMlB2NOXDvZ+Ac5jk3Jsgj+/vllcx2HJTt+CAfaWkAB7m+w5VYoxr42vp7LTNg04J19PZ1rdW/D1 +iA7yrMZF007TWhUTX69goF/sVtMxpYB0oY3ML4Eiz6z7M1+PgDSVYsHXY79ICWPw9UjJ0Pm84/VQ +i6PzKBCSQvh54vVK8+q8jNcjYnzXRddD8I9ifLEjjvIF11OwnF7EYOspyGxJq2DrvQfQvz/Hd68x +zWi93oNB7mi9Ec5+QdYbbiaWwXrj9CbN4OoxAp3XwuoN7y/OVL0I1gZUT6fhwR9MveGOmomoRzlC +qROoR4ZjPIunB6eM2tAdp9cfd+UPmt5oHsYKmJ6BQeufzNJTBsgAFo7Sk3A5II/MAzU/R0A1YuMa +7eiToycBy9Lg6On7HqeCToqeotB/JkFveMB4AvRCyPw81GvR8zQdmesSXLwr4q0bO+8OIJxpCpez +1gly3vNYc3zi5j3evDhZDir06js2T4FaYj+JmjedH0I9D988BTPvdD/XxMwLcTLzVKAzrnsh8+47 +ynv3jT/Fmb0uYJ7WWlYfEcC8pSRg3pIDmPfc0XDqGDwsIM6NixeX8zKSp6sUetZrwfLuKH5IsLzb +g/STlXc3fyh87r7dlCyT8lRnYFFIB+XhjlMNeEK2WvEV0tcJk0f4vD6TkndH30og8XgsaBvfGXnq +O6BIIRB5InMEJ45c9xJ2AtZSnY93ezJ0Uu+UncaENtHxwEK3slR8g/xJwJNsCgmOF+qE493hnhTM +O3XL0XKR2Hi67eYlFLL2DdR3TDbeVDIbz+TSFxtPRR5e/e3IO/kIUS+T0HgCfvVdjd6ICcY73bgq +c/HOZpOxx4nBC7irLHaJ6vKliykx8eTSSytSIPFk0Gvf5kS8s0X1xA7EO90yPHB4SrldZ7DvPucP +hy5kGN5wZ5upKvDHqB0ovCXsJLypGghvRB1VcPCGW85kDJ5+w1MWBE8GHuHvCwNPAqvthMBDvfsi +4A33qp4APP64Ur/4d9gHn9fC33VLc0/4Xfw7oe9CDPAdIYb2rLbk4X4iuX1ZN4Bms6DeyWKZiSyg +d3J45XHbkXdCrR/XAt4Bpz/uhbFTJxqfm3B37BCxZA9Z9S1eGuMWDUtJL/uUJ+6u1HvWlkC7M9cB +905ZtDtzZyIj77Q7GWKaKWPw7gqBmH598e7ME8pdKSyWELnsDLzTAjOpKkQx9lPw7pQ7wOIu8+5M +riH3yw90q2/LXKCcodyzUseaPCfuDqEBXnLHfBQrHdlxdyTNGfeddyeBrMrk3RX8ip7xRbxTJY5F +HoN4pz2aTcpBvMNnzpyLduKdZMvABvFOiiVBg3jHtq3fGXiH8WPxfmWAd0nhqeBEbzlfvDuzDR3X +5N2phd2aRR14p1C81bRswDvtbqzrLoB3UszdN4B3m7ID70xW7HDM7Y07WEzgHc4st1fKLuAdlUpW +PXGFsaQ3KU/inay6rV83Ee8kezOfE+/w9HYEnm0hNNxbA/1OvJN8tyDoaTFzuqHpBN5xCBc7Ae9w +sCELEcA7ZfXcqMyBdyoEsrqtBLyTbPWLAbyTQqnxBN5JsShmAt4hs5QL4h2nlns5fvLp4QG6Lb40 +cymSHry7Qp3CcS7eHQp5ysS7WwcG764wvbknk/u2Ww31BrwrCuaTKfGDVJh6l/Be8lHHlAS8W3IA +77SvIygzOXY4RZTzi3eneiG7jPM4XS8eR8fdLWGn3U01YHeKZBE4mrC7MrMVO+wO9XgW66507zgP +1p120NaiusPupFLUEqw7hOKH8T0ohDkT7E5fYO90wO4KzvtnXRA77e65XIl1t+qQ5nHn4bmBgN0t +JcHulhywO/sKS5bQQN28Dj3D7lRNZXSTkInVWhzevY0VFzYa6w67UyTZYroBuyNWWzxgb6VwU0mw +O5Nb+zNhd5S4srML2F1RKwh9twl2J9n8NgJ2J8UctR12h0B6LsHuJFv2yFl3CKTggnVXoIE6N2+x +7nRHrSfVWXe6lvaSB+xuKTvtbqoTd0cZAJGVoNgVrenKU75wd8zPOOHPAy/f4AfubgkJdzfl2WKl +oJN5CgbFTmOjx9N23B0PIDZg80Dxu8lIBO5OAWPqNBPtTupTzgW7K2EhMWl3nMhjkmh3yDVIdhRp +jMs7PYN2J4XsU6bd6cf5qaLdmW8mZtxGu5tCpt2Z3HZnXqIV51gYO+J01h6+4+5UUWKtAfNAeQs/ +7mRhI9MdYc7Eu8PUF3+64N1pYWK0kODd6e+wBWLi3elAG2+dd0fM0w1jPNddzRMt4+7ozTPfzziw +REFs4O6WknB3m+y4O4qEuifgzf5Z32o5vp13Rx0AvZPBu8PPJsB4zWzHFQcd5jmyZfOPWed3R4Na +dXfBAN7NErUMvKPFo3pmjtUm5VUgaQN4tyk78G6THXhXZ2IrOHbmDrwrvoC7w6rdZdKADKgBvMOQ +/vFKnwW8Q6ZsIwHv6L9z8BmTCstSuwEOvJtKJt4tOZB3qiA0774wx1XHlJY5E3lHOTB1qhpKq1eS +TOadKfc2mNhZUw7mHZ6PDNdBPNK2xi5NYt6VI0qGg3knFwoqvQJ5pwU75jmJeKdFOaN6AO/UDcyC +MQHvVIgMmCJ4d3dUWQfH7rzN/zXj7mSqa+s2V0mPO+iOlpcdcUdoxOF2bfoR+r6oOw== + + + GyOj7dTCVd0CDn7VQ5/l5Nq9gtJ/P+79vw/W7v/+1//3X//7//jX/+e/fc7wr/z/Cf+uUyv52S93 +rSMmAE8yuMgpS/kMCBcKeTop4/NAo0wGXlclgSpIupaJNCpaouzzH+OxF7mrRuT47B264iETg9cV +4dVyuqvnQzM8ymcLikKJgB3zeZykRD0snzc+706n+6Q2vgGMKIpe5I6V0GUftWh4XWXfAnr2iNN0 +mEB0gB9WldyV8P384aNuOLyuVGPXVw5buTfmv89k3rXf0KugHnxxM/t1b0A8WRlRP9Nvr24Ui9Xu +AdYGIPGK1Th1gQM3Jh7dSbfJBsUrQuYMFMfiFWNzStm5eMVIlJIdjKfyuVFRnIyneshm3zqhymLM +CvDctRAofIOKrz9DeafbiMz1Zxqo8W87TXwvHg4/qLOG/txSYtl4Ykzl3jhtSxZ2lJJm5YQ+F/Wj +RBn1wK5xLMW/81HabpP108CF6seb/9iJE9DnGDlMT3NcZPGqJRNyR/msVD/KsGdUShVfG2W6FUtW +mkwqKVAJgFh7tGVJGZ/HwZSJy7NqgSH5cuOLswMp1c81Xl4IumuLlzfV2+w39Zd/Btrzz9BMT0WE +moc+m6Cl+NXVHKRY7DxQoTjRTbuMpRoUvlDyjZnypcogIpT2bl7OcdI9P7mI17GR9GQ8Uvvtb6eS +p1iMfKbIrij1ZOmhquOwA9l0axN/FZs19xA6PmpHWTw95PuwU43l3onMuKIwstVNPPatqxVZhjql +6S3Fj1ivAam80W10Ip+hTblucQh25q0Zu25yBwd+yXTCijs1RB5riAxKFbLQ0IylsqCTYr+C7dxj +Sh6Y1wTqRV0aQB570OqG1uO2cWNUzqGUg/6jiHatuy43XZ7DR8nVthiY0rqykpTXH82f1s9zLoWN +pL0Ln5dGyiLr6aXh8ktmMWtv17BTqYCQ0sTM5dRJ1tNbDgd9HF6E3bEr1I983EVbr/NnY9vsU2cn +bMen7WQcxX+O1+EzkjHmYMrZtYasNgJPrh4iUwLNiHxlDBxaFent78RU9fho7J5gvU5HiuY0Fa8z +CapzRNRsFLvYCll8HkFOncm6/gAWuvlxrGL1kusSdiwH+PO+7+c/5i3vQtLqDdegsbh6kj8zkZcY +Kb7EgXeUGCkMIAWcOCVGE6wn+bNo93onlShIOQYjWDWwXser9PFTZwZYrwoNvJqVZYTUB4Waw6YQ +bY06bo0+Hy2yXlcVityS14Hmu28ZEOo6m2h1mqkp/1oweCVvn8fcoc2niXSu8kfNPTLaQ+2BtQgv +e4PG3uSyKgMsVaUwCaOQzpPS6uNFZ3N4gKGlnK6Ma1jnCn0Jpb3Zk9FVenjjejVWpK7Ld6mo/0YN +vgpqd7NQNos/fACWohTwJO1t8m2R6y5CydBt1uui+hmGB01GU/FvVd8ef848kDiEfRiD8qb0xdvb +1Epqiz+Lx0bWHqoi6NrOPlglPmk0k++Tko9qGVU6EaWddiCBWk7lD2CtEzv6jrNBN5lYYacuz0D2 +tuA7VCh026evQHqz3rDLfh1usBSsap6+3V15U56NvbdkeWJrD6TvoPKcn6nQhBaB5bMNWoqvFhVI +6/d2oIL0Wo822JN6v6cS5Cc/dcrVEHwdZz1VNlweM+pyctU4pCXWovB1UgOn2UfaVVItNg/rvG7a +ZhUtIe62gfi6Uh4F74phoQqtYqu6oXUgEYgukzjNF/yOCeKTzLJOBzLiMAsfSjur6Vlbc818nxei +8FYsEJ9karwlUwgm5bMWtdfHHukT69dhyiTxSb6Pxz8RXrQUhozHjedRVCfCKjh8crp8tBuuHN36 +qDRM3TwjMlOp3Ua4PIquSXVgM854+GwgvqEYA+OTrJW0YhpDxXi3DZwUrAwtNnjetd6cD5rkUorL +euEHy5dua2YCyIOlULUBfIH4kGPgZeXDqdWHa8wh+Xgt1xmup0floKddoyJLpM8Zg8jwsOUlMYyh +/nBtybSyWUUM+ss+r35ndCZyqlPr416ow/6E5m+y6jomim/g5acsvbwF9KChVPu3gpH8W2uhhpvB +rC2QrGUlFq+a7lG0keLVHv5RpyjKUiaLT38/O81GeY7fmc/IXRn9aJqeSlfMNB6ypVbHLA957rNy +6+6YOGRFw14rFDsVCG7bD1QJupYM8ipUxGOoovvUoq6ODcWn4z4LmJtXlbKXoT4U1g5ASD7v5FCF ++aWHPhT7UvnlqqNyHdibbzbxJD6fTVHIfjqNTbnJvU7T0GhK27NAuC1For+pnvLLC8VOPTCwe7YD +la3vWLy4WcFSFDiexnJL1k5SW/5B0bQGooiPDQ2xl0a1UOYFPpnU14EKld42UmAyP7Ae5sOODceH +bLPkYbE0FB6cx1uipRDGkLJwfJKJdyBzhVXpNzTxS1GYc1Dqd9gxy+FJP6/X2x86FZMNIeDvZpMw +NQj21IxnKX6qotLqaF0Haiy+bMqinHJTdleVTe4W9WeRzqKh2GCnn/FZht1LsTMr0etnO1DhdO1D +9RX4sy3l2QkHU+6RCNN3PKyTiy8iWcdX7dZDmU8Ei/VQ2Zx0BSTU073+yVw9cXxLVlqfGyirTS73 +8FqaAS6UXfC1lYiOirPrJus1+nybj8cqhBpyttRq43wWg03i5zPNDpwVk5RTS/pGmYn+bpoHGcif +zRpO8j0ee2X8bXuszU0KC3SOOS9TpmvewMtBs5cMwflDaQemzMkhtp/v+xeqeULwN/y2LfF23ON3 +GBN1PRtLuTce35KHl/JoTLVF3/B5Wl961WLOswvIx2/hzRqeTZQyDjzDG4ZkEjqLcbX6rUkGWW+g +3MOaf8W4DgsgsNK0v5Qf1jcin6YtW0N9LhL2zJqdbQ3FsubeFTV2TCLfkhXfVmR8sPFnU2B1PZpz +iY2EsG7MqSBAHMZ+/DIPfBY3Qya9TMQQ7mJ/OqgFwRTWUcwaQY4H69Vqe4yhqCqfHso/586+1r5k +7cSI57Qov11KGhimrK2AOWdqsCaYWNxZRvvLeuoz1AMwkXwKXLIj7LBBtPNW5v7SMvdwinfHxkb/ +FzCf2KMSZWFr8BTyqZ34i14tF/7NlqOHv1pxmNm3PAw0zMRa2n5myMrubjL5UG2QddteU87mSg+l +hxKoCsl0E2rLQIISZTArPFZKg1K0D3mejcz3+UZ99IlMNk7KaXOAVU5JaHaFjv/J3rv03JYk53lz +AvwPZ2gPml55WbchdSTDso9lgrBgA4bRoJslsQ1VN0E2Rfjfe79PRGRm7LVPVZMqgBOCQLO+96zb +XpfMyLg9E85ndgVenG7Rma66OltQ3P4QtljtR0+NsYK7mhzLkrWMkXKW1k05bnu05qjd9oXRJxkb +TDLZqKZsphAzZFccTUqUG62dulpg9t1GbcyaTpM7eXnBfb7mLrnKm1a0/JZB6tOaqOrNKN5WT/7+ +4+ZmFbOGF2VfaBxT7t7vWXfTggxKKtIKs9O93mIHE9bXafdcbElie9L156g4Ge21b7d937g1BqxP +Mt4F/B/KtpbS5PhCYclBw+PmHpHRNkvyLv+IHbGwnaZc3CRaWbfbb7dYAqMfWVeqVNdrdnhjig60 +Qo9UfhWZuK/r02RgyoT1SX4tq3aXm23IgkEKtL6+b+5k1MEGrQ8ZL7GWB9xL7XpqMNESQr+83271 +Shi0Pv0MhvyX8UBWcqcTodZ73a2SqagEZvjCp6xuEcrh6sx/l96B09oRyjfKIncovnzb3Kc/NjzA +Re28NebbGoqyf0au6pR7N0NVa8Gz2S+m94l+yZ0Uv0caIxUfmBuSYV9wYJn3cSplYfhNuXkrob4f +NiXqLnTWn5ut/3iJR4Ee8lXt3WblKwXfKIq82lI6t41inbrsyvjJEQ8/x47nW13L5M1Bkdmu124y +/CRjkuvqzAITH0uDHgOnNtSjYfE9FH8JfSyfGyrLndCWupgI4jeVXpYspSnLwrjHOfQRye0gF52+ +isJnFMpvwo3N8nZuKDetuc3P6UJleSq/4myAIl+r+XPpmeVe2lP/wdqLyFEovS4UvykrL3N3H657 +kJWjIvcJM7Neuknxk3zxBCVv1TZ8vbO+Ic9UCpG0406drquPKtSFa2agCMqnX0Ju7Cp7CGV6U/fb +HHKa4qH46V7aKvDytkVTufelk/SQtSwlzV6fSNPEg02vnHZ9TudZp/CbGHvreV/LdrSBluFZvNhg +KqqWjB1DlJ+eSEunfEEXqZbqJ2tjeWGJ/rUl4MUbSJR2bKh8Ohag3fKm+V53FqnXwvKT/Pp1JtN+ +EkVLFim0sGNXDaBSJsvPRoDDQhPY+J3u/rLqtciRi0jKefND74Xlp6vzXU9rANbl3VY4USEYWH5D +6eAP5rgSsrKiL87RfFLUGui4LCSEq2oofoOV6F3WDQtFETcxO3Un0mReK1PYveC8Ot1JiUl3iyj2 +EqGsyxOV5BI1o/EuE+nXAXzq/qtfkQrau0H5bJYE7yDT6DXg9Km4H7bH2+tyozRJFpriMBsL41CU +Gj66aizy7aVa9MX3qDcxnY3e2xY6LdPLDb7awuAW6dk2v2l3tXANCvbWXZbFLzK3Tr+fWUYHY+BS +mqA52+WPaBbJn4Q/DFJ1uJBsHcru06/jClbCVM6JA1hUS8RsRLS4HeRIy0u//u2X2n1kn5sdlq2g +6iU8t9vuL5UCBYPy1ylZ733K3+KAFuoMFwxmamUdf9qSeChaoU/c25TV9oFZXDmxfG6tecqFalW7 +4pGhjHmdRIO54eXZH1rzg1IbyhhUfPIIWdmlijbqleoM3CDpNVGeze+SEjWC9UfuAH4/Af3kbpYf +jGXDuVlUUZ6WlxHr9tFA/THwML6rKkqoP+15Y0eqWchA/cnt06ose631Vcr/GnM8QUCZ8JrH9sbM +tU/Fl7E9jLrYMDq2aCKjQ9NU5E0c9JQp0+DtdQ/lDdY002DMa0XcNWe4r3AMDjvdw1T4pzlF0+6u +AL2sKfkBWT8+nefTsf5Hsf5YkhZisX1h/Uk2h+jtbUbZUN53KaTPdFKKeTn7urrQiyn/Yifwpbus +TE9bEezW+FtPwjOOysL6Q8Z+EBjH/FzVAz8yRvjFhbx5VxYfpJLnNeKC4MHjSPzPHplq4PH6WQ5D +WWh/equU0qN0CkoTd1V/Ml+KlK3G50x2lqtRFuSfPJClFhuHSNnb6dWjkA10M76sw6KnzNED+Se/ +d7OPVtbBFzmTcKHqb/Mry16TS0uXPZF/kolRStaSh+0sWcAINBJIo5AwkX/IG75ZL1TAq3P5oWD+ +ScFVjjIiPIRZSrPJluxMfGkyJklkIDqhHagj70tJifxJSjiRp4Z8C3m+WLbrvmAVyR2Ei1YOn4H8 +2/fD/GF8j0rT3JXOLe++/Oj4g4h960HXa2H+7bsHwHUl5Gfzq9qFk59+orrZ2DBaFQ/in9SmB0Vz +a7ktaYPl21FNtUPA3LrtOSsZ5QnU+h/X533Z43zNN6YA/EPh1tV9Af5Jvrnjtdp3pg== + + + yA9m6a6eG+ZZaza+yY01gX87dZbmpof3txtjqzGqwfvbFbA7ir2Xk/e3qyGpvvmdlvnFdj1JG+ne +oVl3V8WGBKIG10yuOlYkO2VLuGgvS6DZ6edy8MAITep5TtzfThsBuUT16iggIX9eUWhSL8nE/Ukm +Rwd/pYAxuvhb7mMU4f74OTJD2HXg/iQzGNoRNVhI0VpGCss5lMNdndPFQHBGn0LzVmC6DFIb9R8U +hGpPy5hRtHjw/vaqmVmv1+YNhUn2wYOjwKniUAwksumU1DBwfzZ+WuKNGbUaYm302K1u/Tk6z+H9 +F6b9WUwEk+VcaH96u84Tt+ZGI2s+P6LWt/fU2XsENTXyj7JgmlDvrsqelnKTM4PpogWOlBYxpyWS +Whg1ND/izLDtDkssoDmFel5rzYQy3LcMtieeyOZxSKVFk8UgK1PDr2VZXXZdE/anQR/XU+NpqLRa +sxbBh9u7TmkaIJ1rhNc9xNItCwt599w/MlBJWpERjFKV3ni3NfArI+1sFmKjVBDl9rNSU8iuVzdl +7VahbLPdcm+g/e3W9MZs08NCU+/P9Osv/vrgkFUUSLbW5P01al41w9OqsJjTlwtmQ4qm5d29ZFLI +CzSQf8gYvRSh8fBu89ZLITrSRi5ZX9uFYG7j2dzD5S4rINx2OBJUnKEnYVlXg19FdE7LLV24bp7W +U1iLDMQ3iRAiKnSbcSb8jzeGuVuyjHySlxRvkGJpkbxVB8LE/6HKgJBsjazu3ZZ1UiAASmmKQaMM +BKASYV6DjQ1L/kuLJS5qQyCAnQsv5lmYGMAOQaKevDC2UBQyU0ssvWtaA3Uam3fZ4GUBASqMYNer +9RY5WJFcoA0tDY+KzeqR5wEC1IK9MRXJHyAQIL7Y+7BIq5UuyK2rVD1sm/Gm4087PKeR8l9dni1Q +SrMGzh3YUDdbZoIA8Znct30JNInuFJ3W4vaTLliKHKAYUKNJtOQNA4ussGobvuYjuw5PPCC0wFUM +EqAu7mWH7QSf8cjpthF51HPQaICHw469LyhAEt3vzdJDwfng2jzILz7Mcwy8iBXtNVGA2pE1NeA+ +2cYqHiVf8vKOE3gf8QVc5wKdkkeDhCa8flqd8HZoTUjyqtZjwJbxP7SFBtixdbQYu27Pdq2nJyZf +PuLj9WNEuvoCBNTr9npEHX8JY60ONnKESebu9DCUq1He0sEE1MXUgl/TScl4t/TbaVi0WW7vTtZq +X4E2yLhnu5GhEGw8cs6rZQXj0zqmK8Azgw9U+RDsnjH2HAabkPIa0632YhZf6mIt9rR7BWKn04uW +M7gaPZyVRs9ffoJXHplNW0ddCIGksO3de2JAjlYqLTmA1Tpjk1gYmZPTc4rcdcDTQQAkJqqmoVFy +4VmDx3m5MoZZyfhrkeMcNuHpYCTjm4vMzzq6uDXAapctfq3ZnBKaSLQQ66DbQtlC3Mr9HKsQEsYV +f7GkgcNmaoxs4Z1VzStPUVdgSMUjkxcoeadC4/BCAXXdJ59OCthwKXTAOo/Fzyv5lLe2BUVYiuXT +nR7lRSH55TyWFpSavslYVjYY9oSmNUxlEsmY3xTRJnvrKAs8UEOlxabpMabPY5dXCzStNxjV6ve1 +Ctp5BCMPoh9eVUBUu3vk7yJnTxVyyk7pVgtuyaITH6gvlMUOdh2pjlekGG4evtU4RnqsMqyPewkD +4bajJsbYV0APLaeX0J7WMmeAuGcm9LZ7Bs/pPciVv+IntWbLmG1aGPdoQ+cPxm1EDAHAlEpRIy6k +9dVFzKxZBg+j0AAJUrNEIQrgegtzkHDU8UuTllotm1nut8kS1J6W0nV7ry8d+ZStj+mLI10uYq3B +dIUTJ0gYWAHWIXeDRviu8n2jkM1wp8EdMEUx89ogoOxKStdpPSx0eHu17nOhCuoXstIlsxtDi+5T +l7207HiYxwLf63wDi+fMcgOYNnWzbi/norBUV3HgaqdpzD1+aUTjNi+CJdna7u9uGZ/6J4LeW5lw +QdyuJCTSM0eeG0i4p2WbWTy0HJY/qHTs6aDoILBkeEULXIUVeW20YiDvlFDgRo50WfLPyKnQK9ij +y5h2tYSP6r3OuzHSTia4yRjUr2C5TT4xLU3VsIV5oPqylDRhvJoymO5R+1IiF+62nGFGd9IK5Tmm +Oc/l10tK8kzGl0zKBy59DYdSZDFKIUtPiuUG0vhy2+euGx5LnQwUmDyVLJc4PfmnShe2TZYqn/Ow +iCAPgm5S9AAplrGiTGAybc37uS/QQTo82RmKpVA00qB3myAMOyi3hYL3Uhbw4OGOG41wRh7UMK+A +F9MS6EHNcZafWVf2oGTWcioO4TmoXZ7iFFKMPnhWs8hRJn6QOcdVes0KtUfyoY4FfxClIiz8QXbU +M1XCEM3MjpGufFuHYaridrUCi3b8tqvStEid0mJGD4juFIfdEaL5jRDmxQs+KYTKmGLppU/G6jCU +KU6Zh+Y8uiupESKJZXdLIEJVK1rMxXrxqRpF9oU+BCcRFmv8bakr0UlcBySlW2sEywhSqivhArnk +9FXKZrIvRll1i/XmoztJI6ctKy0TheRCZp0e31pfeIQEwDXAYb5T/WGM45tj4XUwk717fsgAEmL5 +UWC5e6WdjmF5AGKcDSIhaRFEr09Pb9fgYAYtOLZixqJdx1UWImGWNRSYcrggAzvy40wZZViSGYBV +ms7o3t3XjEI5mCxU4rdSZmGDLGONGYRrCByT5e6RHrocS7FVuN7eASTUlN17FGwyJB8j4NetJxQ5 +Q7hqaZgxMuRoklktOG0h4d3Tv6RgSO8yOOXz3BbmmdTdaiq7uaUJwHffTM5ECebA3PqaAXR0mwc6 +kUDcAD08ah5okz0ES2EUidoPBb2k9Q/sv93SBHi/Lp/9VSxC9YpSgY9R5RaFrjJsWbMp241cBnFS +Cq6lYimmss4mkpBFXiRd8VHOOIn6a6tnjHLXb3wmSogY1BotJK0ETwkRBW/Q7rEUBgDWt92rtfe6 +QAkl44NCxgelqDR+SCn8aalre12ohAoGnDuE8N2anOCpIil5j3iIqopY72j5P6iEkknllGw53mIt +HJ7+g89HSum2Vp5UQqmbbiXe5s0cFDjWOJQ534pl/nLOkTdLhPi2JXXdLaJ6VWrhd1sUWOC/e13p +qNaTn0VHOzej3hA9onqAxky7hSN5jbGEB5SwE4nQKNhPXycexVNO1NFH3XI7xeD66oWBHc2uu7Vf +s4p9Tx3dzd/DELRTS6qRW+vyvi1QQi2+bYnZoxznikryHq6tq5gTXPkSs0mE4rGWWrU7YVW/fix1 +acWkEN6JSdbL8oWqdxOhQPP6WqjPclmKpzGsO04oITKmEPlLlE3KsVBd0WAsxSo4gk7ouxZLMNVU +YYVyh5s4uuM26moCvb38aoK8yK+1kf2wuYLr2OlvsNmG1iaAtfq1QAlx6hMJ3q2LDjUXOFkBpOxW +0b0RVa73hBJqYCAT2gw6Eu26+xzJ1vF0OJsNRB8YUELWSTQRUPBTPrUe1VGY0MxqapalcVl5LqMU +itHosqVZMx+2WgpaQopH2SGcdV6jSSREPtx5xR2SUnemmQhM0ci2uTIgRRTc3L4rU5pF6G9XCMPQ +hse3mW255Ao8ma9ajdRtqlEODAOLVclm5iHXbYESWtDAFyoUBFIvdp22KKNMVVFFYqrkDg5Kwa7Z +pHpCEt30d3qOFsuHNXr36cOMUgcGlFBhT6ohbZmtyLZYKhgXaiwq44I4GP4zecJHkoVCoicfo7ye +hJy6R3K7lR01znrgV1Li3YASUizAV6m+glpjUZLFPKcNrerrtNQOlNE5j/geWWnttM72FvFjBDot +BZtdrePIuUAJFeAzf1mr0Y329vc3WNZk5PPNqP3tgBLKg+7jXlSTUG1EbqxzTxVoslydaP8xd+Ws +8lLJlt/xR14+dm41nOw73/CkEupazKRRmhM9xzHzLnP9U1JBGJ43WJlbA0u4w4gjQ6VbW11ixxgJ +mtWV30cIuFt7jlnRSO0BGWKKjsnhrMuwEeiO9u/KtePJK741HM47w4dHCXFq645bluVlfXzlbGct +ngirVvBnTQJodyLB7Igr3kG1L7Qj7UsarmTLiJVsO1qCjU7QilUdQvaRMqmEhPtpGXEd1m7TgoCX +Na/AAU+pDvOkrn4Q7xtN1XZUuITE/cncuMylrQiyGSTy212zqXGP1KJmHZ90LIyjazMuoS7ChgaB +lAeX0GQTB5Vwt5zlA5m+WnrvbTGiDbXKpYCTIgOtOAeVUGF1M620YCO8d54+nGmkFpZwP93Lxgw+ +OpMp0G49OZT4T5Vd371hxuaYUMJI9F3ZejLxLusTQUcgcktAZFabFlgYaHQ3myDl5ZJJdYX78rAc +HhIDtLJnMSKTgMY2Kp4eXEKtXs5tPzwfcLOPyYu428IlJGnrwoNwWLCUZYO1JjhsVdupmdZiVU7+ +0RZd35gV2MpgocRECRv4a0kh0BMRno2qJ81Go2MusySr2Ajm696Yb2yv5hekjv0278FkEyqqhqmq +piM0bcT1obCwGin2zT0byW3+y7vm/0XphCRgVI1pmrMGnZAEDD6DkEm34AvVAHpazNFGQyHG5sRP +qT1VCA5/0Ttraa/qa8XovQ3HQ+I8iORz7ZZnScNfFBVv4DJlfmSb0wuKhreHI7ZqDnYbi+RoxK18 +e+x5p9Snust9AAqVzcgaY7MkH4sxb96/WCO3pXdp4TT4hJpFzEZRCqguQwMHObujMH6nRXC1ctLJ +J5RZQaMenHtqY6AkHp6BfD92y47dPWZnfxs4mFmRI2VHi2wESn2P3fIqpUxAITJphAJBX76rO4mi +tF4H07CEMt71/ZCrQh4sZeFT6X00HyYO64S+43/3D38CCndLWVzknXUJIYDm1ftDEWB1wJAWefdx +DiQrbrxGa9adOrq9DMF2VLhoL1PdqZaWZxFAhl6qM7p3yI86cgel0pQEQvJm43mlWZeaxuyM56cZ +GVJmaEmy+wuLtXDdldRK3wLyXTWfASvvtudIpd71NLbD418K8Z6+sCDsJSN0Cn3NNhuyym9UCbgT +dKsMcUac0U0/rtOV0StAyQU3QSOXD8X7SW0Q3lrrjUVZH8qU7834hLtSW3qzcIWKlXaa5/haY/AJ +9TRLtw/PPg3FhAqFe23BE+6GwLJsZvm1EY7LAglwbW7aU1tt36ATohZbQtHFZmfFs9tmxEKkbJem +YimDTqi3qu6U9xXPedNrIvOHsUnNG5Upt1tqz700eZRdgCdlbti629ViUd1YeWqyXSyXYvaDQ7Yl +yGF4QinmLNV4K0f3c2D+uZnnn80nxJ1nb2tf+IQsVXq3yCSzvFbU1gXocK48szRFmnuazmnB1az6 +mFAfCq189hahxWJVVlImoFAyTlNkj5tbOGL35ip4YolESBmAQovE08zIuYTy5BYrHb/MTd3JFWz2 +TU9AoXwK3n+nGaAQFzM5Y3SWq7Y0ug6CMvcCKESu1Wrn8cCg7B6NZCQheaXZnpNPSA== + + + 0RiBgBsXFWVlwjLob4o5oJdUV2ZouEcLFDkld3N0mIGmMZLckscT/fqLvzwEi63mpy90QiVv3OSv +bN75nQ316M0TrLWtwj+y5FAGnRD5JouyuxtcrtvmPl5zKR1eDIEyiSBndJKUoUA1yCXnOxUjvszv +wIfPNhWf/2931IRMWnLzrGsyt7SMKZZVey94QmRauymhFBAVnc+LWUfmRdCLRCqslNnfQ9WqFFOQ +xtqtHQJ2ARuKQ4OieA+HH2AR/A0ke9fIv+1g8W68tDjutZ46rLNbXaofNajsOBDvbn5p5UaSlaqV +GMCxIbQFTjjU05Mn6EaBe/g83Anbhs/7WOCEWkZb7ujc0GMbpzFt7W/Lc11SG4fareOp/aTNmtnZ +mN6ihkmB02V07V5pAIKpWT2HeSTow8I1hHf7uhYyIavO2k227jcUO9MV8sK/r8vwPnfXQibc+Zh3 +a75nlqpWKThG9Lto+ziUlNOyyJunbMq9y+LvcKiIbrdVeh0rZoRmJ8QnxoawZCmzKKAJp6DoT5+u +8CHvxu4gc5RqZxp27ZZY10Yj1MEmtAKA3Voc2k2Sn3C/1tsGbbHaOn2yCeXsIHJ/RbkX4V55bWUM +892yUtysumyyCXFLW+pa8564WjKyzJVdyvJVwZn7MkfOhBMi46fQHlQVqyr08m6xVlyoyhnc/tq1 +zLrd28P7p2MqUGzZ380BYdtsR7SeHStayrwtoRs+ISVMNIe4PTb5HEJ/+Tlek7dlw9JjLwCFsuxs +qK1mLlorm2op7NYj9vZ+a6y56rmU/1kJKgzf4v199C6xa/daQub2PXI2xq5j8IYiecNPuCLUZ92D +8I1YNHCEqklnKDargD9U4IPCD6UhHc0yBzx/dVs60VhLNrmzlPOjuaYBEfOkRXCFJFXbaHAsvEK8 +G+WyMCfOQxR8QfJKgTDDA1KsPeZcyiKT73IdxixE2W1PmIWclJiilEEtpAWPNYCtRi7Uk2nmdjzM +XTSVYx0yTT67h9arpQvt1qlKAS98RDYQ2t/2piq7Cr+xb0Q+ymn+dwiG8kVbewDqtetotHF5J+kW +gSElO2otrVVz69bIwiKtodgpR2uMkGlBYj3AunEMTTm8X0K8ByHS23C30Aedogiw7iSLxYo9eQgs +DbV7JLa749xaT9zeOG4q6no/aDpTprSXxtw1ymw3g0hw76yzxbZgJXRvyQCcGxZKoa1CF5whWWCM +2MeCM0TFv6+1JLkNxdsDafqwXCPRqBkzz4VoqDOY70bLVZpsqEaNUL8UZlX5ZHgu2nX2ScX/3uxV +K+RueH0OXk6q/nlbdNBQ/Id2715wOn1Fd8Qi48rp1De7KPdCO5sysddmYR7vzbz7SPky0sjyHIpf +L3SttOHmXUFu6/M2hbrgDYeKK4OHYM2olEBipqeS9I9epzLehcqljQ3VLZCgm1yEyuOeynkufEOT +FRVSz2/Lxz48qV19aUq3pDHyW4fil1u8PfDYMApCbMztVsNslsp9LXW8tF9lWr+tnwi9VqPFLwwI +ikeI7d/XwjmUbB0fdMDubVq9PfhlczPb2Jx2LajDvnlPeAoeQSGqeuOkoq3ZNCQ/Gc/OlCj/tNXP +XadMWhxjf3Uy2FQARIwm2VPWx8iyCYtxh0ZPyq/6QsjEV/bhMeelGjUSzfoxkPcX3ZfhHqJgxysv +tM4U32puUYwl2fEohHhUEXD35r+0WEr/ZB+ysmTaLMXgh7hbztMiY8XSx0IRY2Usdxb5suhIw5Gh +9USUa9MRz2rsUl03uRJHFICft/fJVp2HasOxj7S2YhKmKiNAiPpoqlWPXoZCpKMwNXi12wpFk4cd +PpTfDBfDcddlw2OPrJzT1+ZDycPDkJX6t1drxzOyWq7DA7KFXLLeFxqiNcZq1rACGiIpW5VI7WnN +XxT49I6ok4Vozbi8tweMw4ihD+G/hj1rH1fISn8phR/RbA5WCdl9FKMhTBaiyS3kfvqGe3PlDOUM +5RopQlf0Yb8spRfF7uplTY5QSFk5rgWGSLReM4ayW4ptRiRHAixEemnY/ZgkRD4ga/FejYRIYS07 +7mOR5T4HcsvT+s87rBRD7EihKsA21CK1NXvfyI25lj3N/FIWqFCISWnWz69F56aysBC1YLbeJorh +Ey9WYciNY0S9yGlhwEJYDOwIEZbTn536m9BAsJy+wlRNBz03p1IWFKLJpzXZsuXUFt0/1HJdoQTa +21gDx2tBIZIe1awVo7f19NptuUsZ7xiXaXgo4uMgIUr2SsdufTNpwm6tP2O9olmhmX01GzhL9dLJ +brgvvkJrm+nsI7axdUBfUIj0ASJVQCkv9G9jjyty6E9rdOF9zvqCQpRsiZPIu23YSdNSH0oS4NWA +g2lVBxt5tcje+xISInuWa58dVzl69GBdjDdNbrgltmgoqRuNbV680wIKSUR1zQufGyorhlx0JkAr +SvRG+7ZAtr994Xd6B1rfSJmxV40WVj7oeA+qsqAQp1yb91wSOYx1tcbZQtKCwuMyyVGOke/V/D6O +Da2Ryf7FLNCyr8q+dkAaMowWVjvK2Lmtz5gZNBEbYWmwrT/UWoQ5/9XsUBld1bpcYLte1tJqRFok +2qAp9fAGOSAeqgczEAhq60O+Z9f80z9rffa26tocuCKn613NErQleyj+Gvj4PbZTMTWJeeBwy7Uo +3KCJHQiZQOEWpyBkeFg5qYz75oUJw8VHnarFCF02z/BtTb/Mc3v5UlS+9oFD1DLLCDTdo874hknf +G0utoUSj4+FUNpaKllj0ElR+LcU/Vyx8cKmRCXAueVeUCVpLktObH6q3c4kNL3PGWSyQQpFJr+gx +nJzGQ0ShW7niQIAQVP1nqeXnwkPUI7XKKS3Cuq2fmvuyiaUNQVie4SoOcb+sAao5JnfDXfugWb1P +cSj+UTfnFoRMDutBG1MqCRZBq4MBQ1zkcIIq747ya+USybDzwuFzKvPto0np2FA5M5tH5/Dtd+vK +uftv2kfGoNKED5dZ4txeCK/0v3szAR+ElElDRNaKVzKtTmietPlts5wKoEf89mtdtiqBw3a9/8x7 +EhAJxR9fF+Es63IMuS99kUmwvc0oZuzDMWjl83WBIVrF7rVsVy4rg5VDiGFJ6wGSEWmUPFiIdFSm +lORyZqu1ZigWUrZYdz3MPKRlzmAhakPLRbmsJSNeVhrwyjcjxiHZYpQqopyLC95gDGPD7om4FvRR +tGMqbYEhTlmBRlVCkZmkHClCvCTf6ay31bXV5BH3asJImG6Hd+o9HTCAQrBMcfOZONAO786gG7BX +a0kTTYSO8MpbkwQlIQwUIt1BDCXiBaKkdBFm07reQpVDuRcU4pR1e2nzMkNozYq75E3Piu9abVhf +Ntws4UL1nnh71YPCa0aPBYWIHPWUE4WoI1pPf9wu3tdqPyzqzTJ4CErpHiTEoXbnp2lthoUSPYkB +dtHAYtTcyeauJsgCtYSVvVgWiCn3Mo74Eink12tr9Z3qm8k4HSwrmE3cF4oqg4NImQx5IdflTmk1 +6LAGF4eHL2Ww314WN0mIsngY0eGedDx1m9mj5VpQiMwywLy0oqfqv3hyt9zAtxeE3hSLhDIcsGa6 +uapgrPcp7Y5EHIoy+icYccganMAjntHpUYn4h1f7AjHRBDABiZScVe+pByFRWHnsxdsbDTwd47+8 +8/1fIYn/7ZDE16rlEyRRcoYkVnLXV0hipeP1OyRRKNAMSayqC0iQRLHBP0ASq8pEEiQRJUESbZs3 +SCLHS5BEKRmSaDzyByRRNPMMSRSONEMSBRp9QBLFqj+4DockCp6aIImVSN4DklhnQ0qHJFZKDlZI +ImzqJyRRcoYkwkuufZ+QRCmvW3G+QRKREyQRZe91QhI5WK8lQRLraP0XkERRhV/rTKt42/qXovYp +75DEcgVB0zeiBnSFJC7KyuKbckASixYEXeueYB+K0PwBkghcOkESdWkZkljE3jlOiwvN7sPIpXrN +XeFXtTdIYoHm84AkFhoQmUosVkKGJEp5WQDHrH/zPfc3SCI87BWSOIQESZyqQxL1yzMksYDdekAS +hRzPkEQDDq+QxKnkBzNkgySWM3qRBCSx0K3/AUksMh0TJLHIkrm+ZEYiYmIkoiRGYlGDig1v5spI +RD5v25U1r5TMSCzX9omRWAgProzEgrt6ZSQK1/xkJNYSPZRCrkDkF0aiRsgPjETkxEiU8rpxdTIS +n+PynD89sawJZP1kJDY1QkiMxFZbZiQ2eudmRmKL3PfBSERJjMRGMviDkdiU45MYiVIyI1HKB0ai +mMqZkdjq9cZIbPX4xEhsNIuzmkJa9jVZZYmR2Fp9MhIREyMRJTESG80UH4xEyZmRKCUzEqV8YCS2 +er4xEhvtsDyLX4zE5/P8Oh55245PjETJmZHIhomR2LbjEyNRcmYkSsmMxLbtnxiJlQ4bCyOxkv65 +MhLF4P7ASBQAPDMSNY1mRuLrkYg19M5IlFzua2EkoiRGYlVHwScjUfJribgwEqVkRiLKk5FYVSiy +nZORWOvxxkisrX9gJFb1YCz7wkiEhp4YiVNJjMRF9oBhHWCyQB8yPDwZiRqBMiNRV1evY2EkLsrC +SFxUYyTysxIjsSpF7MlIlJwZiShtXxiJ1YoB3xmJkjMjscIKWhiJlZalD0ZibfWNkSgmfWYkLsrK +SJxyMBJ1jsxIlA34gZFYxdVJjMQqGzExEqeSGImL7IzEKudPYiQKYv+BkVipdFgZiVWN9hIjsZIy +/GAkVvKtVkZiVZFZYiTWO9oSJUZihVqzMhKrWr8kRmLbtk+MRMmZkdjom70yEhu9yR+MRMmZkYiS +GIkoD0ZiJRSzMhIr/VtWRuJzFJ2TKh04noxEfUiZkajcqMxIxGnyZCRKzoxE+mslRiI+nScjETkx +Etk1MRI5/JORqPcrMxLxkCVGIp/Ik5FIYVliJOL1S4xE1vVPRiIegcRINB/Bl8FI5O8nIxE5MRJR +EiORcz4YiXbklZGo68+MxKEkRuJUg5Eo/0VmJIqs9oGR6JCxdUNhSFdGoiaQD4zE1ssbIxGOd2Ik +2hz4YCTC6E6MRN2RzEicSmIkDnkwEmkOlBiJLZowZ0ZiUw51YiQ2IXASI3EqiZE45WAkCk2WGYmq +J/zASNTFZEZi28sbI5F+O09GInJiJKIkRmLb6ydGouTMSAS6lhiJUj4wEnV5mZEIFD4xEu2teTAS +RVnLjEQDz6+MxEVZUWiL7LEAAeUTI1GX8YGRqHcsMxKBwidG4lQSI3HIg5HYqNJZGYmiun1gJOqN +SIxErUkWRuL4MzMSpxyMRB0oMxLlOv7ASFTIJTMSGewSI9HaQr0xEukglRiJUjIjkRnlyUjEgZoY +iVIyI5FtHoxE/ZEZiXKcZ0aixuAnI5FxMzES6Y6VGImLsjISpxyMRAb1xEjUST8wErmWxEi0GWJh +JNKK6slINHllJLJnYiTaL30wEglaJkaiPpzMSJxKYiROORiJjYX/wkjElnowEnkwKw== + + + I5GIYmIkyu7/wEikn1hiJFIwnRiJqrX+wEhkJZgYiVqJZUbiVPLAEPJgJDYlJSVGYiv7J0Zi2843 +RmLb2hsjsQWyPDMSK9nfCyOx4n95ZyRW2kQsjMSqPKjESJRp+2QkoiZGoikrI9GUByNRcmYkoiRG +IsqTkVgFIkmMRCmJkSjhyUis+/HGSKzqG5YYiVqqfWAk1tEnLRiJUjIjkVXek5EoOTMSTVkZieyK +oykxEqusmcRIrJqHEyNRnvIPjEStiRIjUe7+zEhclJWROOVgJFZS0VZGYj3LB0aiXpvMSHzZL2+M +xNc1fWIkSs6MRCmZkVgpLnkwEiUnRqKElZHIBk9GYqUz4spIrC/7KTMSq1w+T0ZiZTG+MhKlZEbi +y9T4xEhEToxEdl0ZiRz9yUisLJcWRuLLmn1jJE4lMRKnHIzEyvy3MhKrfB1PRmK92xsjUUNNZiRO +JTESpxyMxErMcSEiVhlYT0ZiVZpIYiTazVwZiYuyMhKnHIzEGvnQwUjkJz0ZiciJkSglMxKlfGAk +1ru9MRJREiMR5clIlJwZibrezEisV1QZJEbiGMvnhkp/SIzEqSRG4pSDkWjnWBmJWs5/YCTKjZ0Z +ibhpEyNRLtQPjET5WhMjES9tYiROJTESp2yMxCYU+cpIlPvkAyNRcmYkSsmMxDp6xCVGouTMSERJ +jER2fTIS613fGIm6l5mROJXESBzyYCTqE8mMxHqeHxiJNmWvjET5pzIjcSoLI3GIA2emkGxmJGqo +/MBI5A1MjER9fomRKIfzB0ai5MxIREmMRHZ9MhKREyOxkvG0MhKlfGAk6uoyI7EqYpkYiUPJjMQp +ByOxnscbI1HOvg+MRLkPMyNR7vbESKxyOTwZiZIzI7H2CGUFI1Eu0ScjsfbjjZGI6zQxEuvgIiRG +Yq3nGyNREfTMSJxKYiQusjMS5dRNjMTKIPzOSCRonxiJUs5tWxiJKE9GInJiJHKwxEjklz4ZiQpU +ZEaiog1H2RZG4qIsjMRFNUZiJaL1ZcAP5aV/MBKrEsESI1HRiMRIVErDB0ai5A+MRB2w0wIkXDCY +qYmROJTMSJxyMBKruvYlRmI9z0+MRM3rmZGohUtmJA4lMxKnHIxEjeSZkShn8JORqGBjZiTKD5YY +ifK0fGAkysGXGYna8wMjUQvHzEjUMjczEtUq+gMjkeLaxEi03lsrI3EqiZE4ZWckWtbxwkikvfiT +kUhpbWIkQitIjMSn83w61v8oRmIblayJkdjK/sZIZMPESJTygZHY1DAhMRJpbJYYiXoSHxiJyImR +2KxD7sJItNX/g5HIs02MRCmJkYjX78lI1FuVGIny52RGYmsjVWNlJOK9SYxEggmJkYjn6slIJF1z +YSTKmZQZiTQ9eTISLciyMBLZbmUk4pV/MhKREyMRr05iJOJMfjISCbMkRqIlLC6MRL2QHxiJBlFZ +GIl0h0+MRCreH4xEiBeJkUjC9MpIbMS+H4xEGAiJkcivWhmJNKt6MBJph7UyEgl6JEaixTwfjEQ8 +gYmRiJIYiR5leWckAgBIjEQDG6yMRN2hD4xEXDkrI5EGiImRKN/IB0aiPFSZkQjRJTES6YX1YCQS +C06MRCJWKyNRA+gHRqJ8wJmRCLTlyUiUnBmJxAwTI5GkiycjkWSJxEi0zIuVkYjyZCQSnFkZibqM +zEgk6vhkJIpGkxmJjaz0lZHYoGW9MxJt/FwYiQyxiZH4HJ3n8P4LMxItJvJgJGqMS4zENmA6wUj0 +Fm5vjESpmZEoJTMSUZ6MROSVkWjbLYxEohJPRiKDbWIkKgaRGYka7j8wEjXoZ0Yis1ZiJGoa+MBI +ZHZIjMRGAfzKSER5MhIbTSdXRiJKYiSy65ORKKsnMxL1EzIj8flMv/7ir48M4w+MRMnHuS+MRCzo +3hdGopSXYfzOSETG6A1GIgo5v8FI5GDHeb8xEjG3EyNROT2JkSj/6gdGYiU6tzISK4PIykhUThJd +9TIjUXLp98JIJHkpMRLZZtvfGImoiZHIKbZrYSRKaeV+ZyQqdSYzEm2duDIS694+MRKV/5IZiZWU +tYWRWBVdezISFUbIjMQayQWDkag1xQdGYgVXszIS8cUmRiJu3ScjsVIUsTIS64C4ByNRzpEPjER8 +JomRKCUzElGejETJmZGIsjAS7VAPRqIuLjMSddsSIxEPx5ORWElcWhmJuDZXRmJVpPjBSNSOiZGo +x5IZifIQf2AkyqORGYm8HSsjUTGVD4zEqjBvYiTKz5QZifVonxiJet0yI1EHy4zEqiD6k5Goi8mM +RLxbKyNRJ/3ASKxHy4xEhMRIlPJkJEpNjES7ZysjsZLr/GAk6mIzI1H5hImR+Bw9f/kJvqrA98lI +rODn28JIrCI4roxEbfKBkYicGImV7IK+MBKlHOf5zkisfGN1YSSiJEZiZd1yn18yI7Hqq0uMxAoD +rk9GYtUXd5d3RiIJ44mRqGTSfT8cnqXPQ53Mn4xEyYmRWGnWvTISUe7qyvDzSraOscFIlOItfD3K +i0J6bGIkyrVUdm6vMxI1rWVGokJ4HxiJGiozI1EZwpmRqPzCJyNRkZvMSJSTOzMSKwvGByNRg1Ri +JFajny2MRMaxJyOx0pdsZSQSPFwZiQp+fmAk4i9LjMSqBdR2TEainvEHRiIOy8RIlJMtMxLlXP3A +SKRkaWUkyvGbGYkyIz4wErVnZiRqfMuMRFzET0ai5MxI1NVlRiLKk5FYozPTYCTarisjUYf/wEiU +lZQZiVXG2MJIrAB3HoxExu3ESNShMiOxguh6MBI1ODYASMFIJNn6qgsjUV+C9VxfGIm4XRMjscIu +ORZGoi73AyNRE09mJCqgnRmJCoV/YCSSU5EYido1MxJlgX1gJOpXZEZiNRtzYSRq1H4yElXDlhmJ +jO6JkVhr+cRIRE6MRJSjLIxEKUVWe2YkSs6MRF1vZiRKuWLPmca/3W+MxMLib5uMRKrYnozEovYr +iZFYSIPuCyOx3NcnRuLr9G+MxKp8msRIrErXafWdkYh83gsjUUpVnGIwEqVgkWdGYqVX/8JIlPC6 +uIWRaMo7I5Ed670wEquChFtbGIkUxe3nOyNRhV+JkaiSr6vtCyOxEMJ8ZySqkC8zEnXOzEiUOfCB +kWjFigsjUbc7MxK1yQdGog7Y921hJNZoFzwYibKZPjASSY1YGYlVb0ViJFZ66z8YiZq0MiORQGRi +JJrJ/mAk1oByDkaiTP4PjMRKt/qVkajBITMS6xn4q8RIzDJDwRnlVc5IrJEflxmJyImRiJIYifW8 +PzESJWdGYiXLfWUkSvnASKzWIXRhJJIykRiJshw+MBKREyNRSmIkSngyEqs1FlwYiQTgV0aihA+M +xErjlpWRKCUzEmUPfWAkVo0tKyNRUbHESFTa3pORSM1fYiQqtyEzEpXS+IGRqLBVZiTOOEkwEpW7 +/oGR2PDbroxElMRIZNcnI1FyZiRKWRiJ+vMDI5EUycRIxFOVGImC3HxgJErOjERoOImRKOXJSJSa +GIncysRIRHkwEhsR4oWRqHhjZiQ2KNBvjETSOhMjsdJybGUkksHxZCRWIhErI1G7ZkZioxb8wUhs +pb4xElUBmhmJKuz8wEhsYJlXRqJ2zYzEJurlk5HYFKBMjET9+sxIVFLrk5HYtuuNkWjKwkhMO05G +InJiJErJjEQpHxiJbbQ3C0Zi24KRFYxEfbQfGInk1yZGIteRGIkNCPiDkUhR7MpIpOYiMRJVIPtk +JGpgyIxEjUWZkajEwA+MRNZJiZFYozpqMBLb6Le3MhIZjVZGor7axEikjObJSEROjEQpmZEo5QMj +kYKbxEi0CP3KSER5MhJVXZEZiSp0yIxEYqxPRqIFDVZGYrOq5YWRqKjiB0Yi7VMTI3H05Q5GIrVT +T0YiFltiJMpiy4xEI3Y/GInG914ZicYnWhmJDVjbg5FIsUBiJFKSlRiJXPCTkUgYMjESjRiyMhLZ +9clIpH9PYiRSnpEYiS1ITpmRCNAkMRKt2mhlJLa9fGIksmtiJDb8kQsjsRHffzASdS2Zkdgw81ZG +ImH4JyNRHrHMSKQ6JDESjaX2zkik9iAxEnUZmZEoT8YHRiI4msRIhEy1MBIp0HsyEq3gb2Ek4nJK +jESaRj0ZiZJXRiJFa4mRiPJkJBLuT4xECwKujERKdR6MRP34zEjU95EYiYogf2AkDnD8YCTqWImR +qIv4wEg0+UtmJMq5mBmJeu8zI5ECzicjkZKDxEik73ZiJFrd44OR2Kxb9cJI5CEnRiIuvScjUR9I +ZiTKOsyMRI3uHxiJZFKtjEQl6mZGokyCJyNRyVuZkajkrQ+MxEb5wspIVOg6MxK1zQdGoszozEjU +ki0zEpWw+oGRqDTLzEiUxygzEqljfzASFVXLjERcHysj8ek2/+Vd8/+ijEQ8wk9GIgkYiZHIDVgZ +iQhPRmKj1H5lJNIcLjESVQb2gZEoOTMSURIj0bZ5MBI5YmIkSsmMRCkfGImt34ORSNvJxEjUyP2B +kdhIQF8ZiRo4MiORKP+TkaivLTMScdolRiLulycjkS93ZSSSspMYify2JyMROTESURIjkYM9GYkq +DsuMRIB4KyORcezJSKSLnnVnjQ1ZlxwLI3EqCce3yM5IhAdhxDaDH4LfOBbBz7k5oCw2UwFeYiTS +6v3BSERNjESUxEjEt/VkJOL7TYxEhQIyI1HKk5GoLyIxEs0ZvjASF2FlJE45GInqXbgdZTISFcho +Vuq6MhJhP0TqFTLrUDznwUhclPRQhhyMRMNb1MlIhA7IXVwZiRjp1GgGJBFDHuskQRKRz7NMSiIK +FqFTEukacHn/7UFJRC1lUhKhtbCOD0oinaexYhIlUe+VuSmDkqjHmSmJ1m/4QUmkN0eiJGKeJEoi +BatPSiJyoiRaw4iVkvgcmn9u7vlnUxJx6D0piRWs1kpJlEMwUxKZp5+URMKEiZKIkiiJ7PqkJEpO +lES8t4mSSBnbk5KIpzNREiurgZWSqNSUD5RE9WrJlEQqExMlkVLCJyUROVESURIlkfSVByVRQaWV +kki95UpJJOr0pCTW88iURD2WTEl8PtGvv/jLQ7j4SUmsxChXSiIbJkqilA+UxGqhy4WSiPM2URKl +fKAkyhGUKYkNaslKSVS/sw+URMzEREnUqJopiVrIfKAkIidKopRMSZTygZJIp4NESWQpnSiJLZrk +Z0oiHodESWyGTVooiXrhP1ASGfUTJVHZkYmSOIWVkjjUoCTSjyJREtsxvN4rJZGew4mSSIrmQkm0 +v98piVN1SqL9pJWSqPH2AyUROVESURIlUcoHSiLrzkRJbMeZKYm07n1SEhsf80pJpCF6oiROJWW1 +LLJTEnXSTElkjfKkJNLuJFESce6tlMQpJEriIjvWg9zRRElsPSAQiZKoXTMlEU9hoiRqufmBktjA +ICyURDmmMyVRHugPlEQc04mSyKIxURIJzzwpiciJkiglUxIbTcUelER8x4mSiJIoiQ== + + + ts2Dkii/eaYkyuOcKYnPIfSXn+MVfv9ASXxZ35mSWMv5RklUpd8HSqLkTEmsjEMrJVHKB0oi8kpJ +ZM9ESeToT0qiJTQslEQldGVKYgU/96Akag2fKYlKU8iUxDqQr4mSSPpQoiSiJEqipRg9KInIiZKI +slISOemTkqgkpkxJ1JPJlMSpJEqiySslUZlOKyVRqdAPSiL5VQslkQ53iZKozNEPlER6dCRKIumO +KyVRmT8fKImzOcbYsJ5vlERT3iiJQwxKItlAiZKo/KsPlERLRF0pibLKMiVxKomSOOWgJKoTdqYk +VppkPCiJureZklhJUl0pieSBPSiJqImSiJIoiVKelESdIVMSKz2GVkqilA+URLxpKyWRrouJkmhv +y4OSqDy4TEnUHcmUxEVZMWhTDkoi+caJkqhkxw+URIqnEyWRdp0rJXEKKyVxqEFJ1AkSJVEv9wdK +ot6FTEnUsiNTEqeSKIkmr5REJY1kSqLu7gdKohL7MyWxRknIoCTSgPVJSaQB60pJpNtqoiRS6fyk +JErOlEQpmZLINk9KYm39jZJI/UaiJNa6f6IkavzLlEQS4xIlcSqJkrjIUBJ1qExJ1Dk/UBK5lERJ +lJIpiShPSqLJKyURJVES7Zc+KImVHs8rJVGTcqYkTiVREhfZKYkVR8ZKSay1f6Ik8mgSJdE6Za+U +RGVTfqAk6qPJlER6CidKoiaPD5REFqSJkqjkmkxJnEoeHoYclMR673+WKYnWueFBSbTWWCslUX1J +V0piw+3zoCRaO66VkhhR9ExJlD2bKYlKgMmURMUrPlASTV4piaaslERTHpREmduZkoiSKIkoT0oi +8fqFkqi/MyVR1v2Dkqj8n0xJ1IIwUxJp8fekJErOlEQpmZLIGvFBSaT1ZqIkJoWGBuz5pCRa69aF +kqgq/5WSKLf/g5Ko1VSmJErJlMRFWSmJJq+URN3ZTEmkwc2TkkiC1EpJbK2/URLVXf0DJVFypiTS +hj1RElWK/6QkSs2URCmZksg2T0oinYASJVGRxExJVALSB0qi5ExJlJIpiVI+UBKRV0oieyZKIkd/ +UhL1MzIlsZEgsVISUZ6UxLlhUBIbE+AAINJY/52S2BQ4WCiJGmIyJXEqiZI45aAkag2ZKYm00nhS +EpWolCmJ3LBESVyUlZI45aAkynOWKYktoiOJkoiaKImtbJmSqFX7g5IoMVMSUVZKIsKTkqjjZ0pi +K+2NkiiPwgdK4hi/x3b1fKMkTiVREqcclEQ7xUJJ1Mr+SUlUJlemJJpneKEkysX+gZIov3WmJOIb +TpTEqSRKoskrJZEM20RJbCppeVISJWdKopRESUR4UhIlZ0oiSqIkNjiyD0qiHmmiJOpeJkriEFZK +4hCDkkj2QaIkNtl6T0oiE3SiJJLFulISp5AoiYscTlBljydKokbHD5RE3r5ESdTQkSmJck9/oCRK +zpRElJWSyJ5PSiJyoiRKyZREKR8oibq6hZJID4KVkjiFREk0eaUkkmK7UhJxDD4picpjSZREWjsn +SiL1bE9KIj2VEyVRpkmmJOpXfKAkasNEScTLmiiJ5Is9KYnUHyZKIsUWiZK4KCslccpBSSQ3KVES +OeuDkkjWQaIk0vEnURJRnpRE5ERJ5GArJXFkxmVKIsUmiZJIUleiJC7KSkmcclAS2wyhOfzQWjM/ +KIlkzCVKIhHHREkECvCkJCI/KYkUEyZKIobpSkkcQqIkDjUoicpbTJREDTSZkkgSslMStTTJlERT +HpTEKQclkc6ZiZKoBc0HSmI9jzdKorKlMiWRQsUnJVFujkxJpAT6QUlUlVymJMq1lyiJSrP6QEmU +AzZRElUslCmJU0mUxCkHJVF1UpmSqHrfD5REis5WSmJVQWGiJD4d47+88/1fKYn/7ZTE0/u4ZEii +vuLrWNSzWbb4QCQqA0hZ8YmQKMOKTJsAJFJwqLhP8BFV7Cpva8YjCva27fekI4KjZyXqcES2aHdi +I95U20wyImx6B6cDRtSbV47rjYt4KXnGK8xw3GigBVwfedFKDNAqP2MRD1pTHxOLuB+W4B9URAJ3 +Tt+aUERrQNkmE7F7146BRJTNrITOTERspw2TA4ioImrZyYFDFN/p3OsbDVFqPduEIcKLaudkIeo4 +vRwJhdjdzhgkRFW8HKUE41AtUrZ+Jg6iFoS8AY5B3J0vPiiIQ0isvVAnA1Hp5/ckGypNtL4DENX3 +C0x2bHSZP2nQD0VqPs439qFE1csP9CE8535N8qFiMrWeb+DD6pPxAB++BBbag3uo9gbqUJWxh2Li +Xnud1EN9PnsEffWGDyFRD6fq1EO5Odq2sgxPa4uXmYeEyPeFjbhN1uH2duO3QTfc/NsKuKHcCaW1 +d7ahJ50NsqEKL+/9HW1YDYAwyYY1PqYAGyrZtbxjDZuKgMtCNWzmYplQQ+fXvDENb8suG0hDXMua +n4JU2KqVamaiIeEHvfOhHrdnHTrPUO7EOZwFAAwnY2mTZkhn9fOcMMPH8DlnOU//KrJs7N1ZWYZF +DQt4DMEyLPthnMBgGRZ63B57ghki9vOcMEOUq14TZljI2q79DWZYImN7wAylYAEPmKGUttXzDWZY +di9dGTDDchSLVQ6Y4WuitWKWDDMsdHXb90kzLLKe9npOmmGRQVodUzhwhqgH1STuZEXpZdIMJXDz +Ms1QMo9n0AylEMcZNEMppLFlmmE5POti0AwLjav2feIMn4/063zqqgSg8DDhDCUThBg4QzbEsxY4 +Qymzp164VqQSWB80Qym2QA6a4eubwOGRYYYFXuNKMyzVitgHo7AoTwF3ZIIZKklQxVBDVW/BvdSJ +Mjw0yO/XG8lQPf7UCn2ADGn6d/fJMTws0TRTDKlW2M8JMdRqhLVmMAwPD1ZlhKHKONRwOgiGinRa +AZMDDJWGxFpi5ReqsyYVR4EvFNARP2WQwIaQ4IVT9TCe8cL6l0EkPJ33lsmFRwBGQpXv/6JVp3ML +p7BgC6do1EL9ltvzqpU1cLgbIyMLIe80w+dR7Ckh2hVQn6j9uOrEKxRk4qCWxLF7h7cLGLhCBUMA +oCZaIR8aTTUdVnh445rBKpzCiiocapAKtVI1P73zBxVL193KnEJN5HtvU1VbPwqwglI4hAQpnKoz +CmUN4f8KROFNydGXDCikymC3FEBuy71bN91xn9QeEf9JohMWRbgKj8tdB6V4OHjQCUs93WGY6ISS +sbUGnbDIS0tpUNAJS4tVdqITSrYK32ifWFqQk4JOWOgKfn7JcEKpFMoNOCEKY0DACVFwUSQ6YSEE +0sylSDGVxh0cvINO+BwU5zSpRJ3DxreVTlgBHJQ66YTKSTLXT9AJ1Z7KC7pWOmGlW1xpk05IZysr +FXU6IS2wAIIlOiGyD6TWVEJ7Vh99aWbJ0SEIJjihVsrwCwacUCtz72vqcEJFkb336Qon1A+7vPMI +R9ae1dB3wVPdbv9qE5uQdTg9N4NNiEKkJ+iEKIFonHRC5Gia220rfI+BJkS5byu8GGhC/XrrGBpo +Ql09936gCYeS0IRTDTShnAYXRlgQB4u8kSx6EpqwXJ7mMDeMvnaDTVjIAJIjJLEJtSEF7YNNCD8b +SyCQgzDXT6y6lU0IG7uCuHZZt8RWfMEmnEpiEw55sAlpykPNdCAHC82PlRSf2ITljFLqsaHQM719 +GWjCISQy4VADTFi0jAVuGLzBwpi6X18ymFBXYo7RsSEUTfO/0hSfHjeMZ4lLiGxToHMJIdrfDjAk +glZiHM5cQsm4GAaXUIpRPYNLWKjCvW2b2RdKV0drrcElhMNOa+7ADdors/ep+N0lfLVsB+r9sOmJ +JcKirPSxRXbnuxjujFcDN1gob9jbVPx6L7Oi5ob36EXtXMKpJC7hkAeXsFAXI4s3eIOA72VNJyyh +Xgczu8d2+2HFF8YlHH9mLuGUg0uoI9ntDtxgUejtbm9YwiJ/Rl9UfUDWUiWohNbBad8zlpCmTcXD +Ab4i3b3jbmAJKzwwp8QtvebksdzvPrGEUujJPrCEbGPZDGs7PvU3Y9oKLKFaWNEgcuAG1U7JIu6J +S1iLe6bndrs/4MASLsqKJZxyYAk1np5ejmN9d8tmXTYzlbBSN3Ufk0qIgkvBqYQ0f4LvukIJTa11 +QgnZkcyCgBLa7+SyViihpiszmgJKqEnZrKaAEk4lQQmnHFDCytJd37v79emOuZFD0dd3wRu7hUpP +Mm/UYyaN6jSZfxOTkP5dVMUHk1Cjh3NsHTVYTu+vmpmELOcoKh0bCjlVoz0Yi+yh5FEh5MEkLEoB +wpsXTMKiJN2d6rqVSVj6Zuu6wSQsFP86x4IlQ6Fj/3m/MQllEBZsf4cNFtwnbdIHzTezHf5dxWYc +pVmiC1Pw7QWgCUmIeIb4WoIg7NeXASREaCEETkNt5hQeHTjC21sSDRqhhNKtpm/CCDXikQ4ULEIl +8NuwbyhCXa3dl4VESLHXdUwQ4XnHgsH7NR+xSk8YQutENiGEitSVek8GocxQvV8ZQXi4pTUIhPFm +DACh9sM3lPiDpzeeGfhBTbZHLZM+eHn7kAwfJLEdlpzDBzXVWqmlswensKIHhxrkQSUc4bkP8GDR +VMLMkMiDejlY4w/yYFH5dXjY7eVWvUE7zjfyYKGm4bgmeVAKOXaDPFgo2PDE7IkFkExJQJAHJTCr +BnqQLbjRCT1Y5PKU936gB8vmHcgGerAUyzjI5MFC5fQCHpSAYTzAg6V4z58MHkRufkC7l9pV65kA +D3JwbNoEHtSPYFQP8OB9T+QglaorbPC+J2awMJ8pbBD0wCJfcC9vlMFSD3Obj82a+TxGPtIQEmJw +qEEY1HqOzLtBDizKiNAbnhGDRTkWl/eMtw11f+TPG4jBRVkRg1MOxGCp3jEtEIP8noLvdUUMImvd +PxCDUvBYDsSglM4tS4hByQyHAzGIcm1lIgZRZH1nxKBkq912wqAul9rtAQ4spORcC0rQf6mPzHPD +zaNTgzA4lUQYnHIQBu0cx8IT1Jqcqr9MGCzM7HXdUJ7T5k2IhluTRWbuZCL/Jy5WBwziOD1pSuSA +wakkwOCUDTBYVCXDes8Bg/KAWH16AgxKvnh+ARiUcpyxIU+0eHJOBgxKtsEjAIMo13lPwCC7yrbJ +gMFSd3OfDcCgbqUt5QIwOJUEGBzyAAzqA1EywuAGluKdOzNg0OZfmuW7fJunf+AF4+8FLujSoIDR +Z0yDcgADNRISYM9kQd484pxjw+IdtQdaUO5f3ueMFpTMezjQgii7wwZxC7Hrdl9vaEHk4+gTLSgF +D99AC0ph9ZzRgro839XRgkWhwEaJnKMFh5LRglMOtGDZbp/2ghh4u5spkwXvzSy+oV7dehUFV1De +gnocb1hBeWEsqOtUwTPiSQEVVPMjjL6VKXhafucgCmo9vpVjcgJhCNDmdOUJHlu8q66qYz8tP4Im +OIQEE5yqswTlOJPBP1iCWtrdR8koQQW6GXmDJKiMnW2rEyQoAZspcQSlcqsCI6gDMQ== + + + OAVFkGR1R/NNiODRLa1pMAQFgQzaAmGcKSwEwSkaQFAjXLn3iQaklewqmEG2+cgdqsrA+0oQPIu/ +OgkgSC+0dr/xA9XVo23nxAdqgKpUvTk9MIQMDxxqsAMVC+BzinISjSHkZuUCE83XxHLmht1zIwY6 +cCgZHTjlQAdqjKaH+kAHylNrt2dFByq0Z365QAfKTWWNuYIdKHfIZtUgKztQDjgbuoMdqF1hb2R2 +oFwzpPYPdqB6L7PAG0hAtVAmVyChA6k4NbMstqMlFYkojg6cSkIHTtnRgVRcXacFJuhAr67bVBwk +dCD1pqTiBjqwVi+oHujAp2d7er3/KHQgK0cZ6BkdWHr4KwMdWKLH30AHSiGEl9GBReH1k0I/Rwdq +TXyYSe/oQD0Iz8ZZ0YHIvUxyoASLxQQ5sFAqfrY3ciBPljE1yIFSCL0FORC/nJsxExyoVwpLdZAD +C4WT5wQHlnN7YwbKO2jdj4IZqP7nRKwGM7CqbYPM+swMlEO62bcKM1COHtybgxkolwj+pswMrFHq +EMxAtrsctENjWqV2K1EhMwOR4dF4CwB8Lhajd2SgFDzYGRlI7ENj8EAGWvbecQxkYNXMrIV8RgYC +IcEMCGZghbYg0l0wA6n/lvs0MQMhQCjxKZCBKicnPzeQgZUA836/IQNVX06YeSAD+VX6vgYzUDfb +rJMEDZRMv81BDZSC43xQA+nZf8CHWqmB+On0cAc1EEUzzKAGomilkqmBknHkDWoghe6yNQc1UPeI +kS1TA+X6Ikw2sIEATE5+vWMDRdOlWXjGBqrqlO99YAOBnJCgEdhA3WFevMwNlDeNdcbgBtboxBTc +QA2eBA0zN7DwUezX5AbK5UarncwNlIxbZ3AD9WHRQ3dwA6VgcmRuoGRGwsENRNEKZXADUY7jDRtI +3ERD5+AG6jI0cA1sYIEnp28yYQPLdduYMbCBhTTtWiY2UKMkrqLMDbTBs+0THMgAa0OIgwOfY/Mc +3H9hcKAFLbbyBg7UQEcPnAAHljsCygEOrFsEHFdwoFSPNQRGajvNQTLAgShynmVwIDJo0yAH2oa7 +gwIpwd+su1omBzLkns1iSoQJFewjC2mQAzXe01YvkwNLAH4GOZBJi/hAkAMV/iMvKZMDJZPyNMiB +5QjCapADUeggksiBkkG2BjgQ4faTAg5kT3p2J3CgTB6a4Q1woH6BWYVBe3s+06+/+OujPNW7vWED +1T/4pHm5d24kpYqO3g4NVEqVfnhmBkrF0A1koISj3ZMYSLbW2d+AgbKu8UcGL1BTfzjbNBKoZ5/u +fqYFahmFMzdggeosJjNssAJlKez1fkMFyp7od5+kwMMjxgMUqC22/g4KPIoZDYMTqMNv16QEqiS2 +3O0NEnhcxoYajEAt+w6K6R0ReB02ZSZA4O29twcfkNXscQw84MuWMB9sxgPKo2+XGXjAEtH9gQfU +uoGocMYDatFNXsvAA+Iv1eJv4AHxve61veEB5WDAkBp4wGL88jLxgHJt8O1kPCAej/u6Jh5QCg68 +gQdEqe90wBL1r4MOiCKPsNMB2e+8zzc6oK5NFteAA+qm4TMKOCA+Cjv0CgeUp4iCrwEHlJePBWzA +AYvKYm2pusABtaMlIwQdUE/F8g+DDqjCeBb2CQ6oxo6t9skG1IvRaRVhaEAOiBdhJQOSON6uCQbU +fEYuaXAB7xhvEhZQk3Pb70kFFFYhkmzJc5b7YKMJ+8oEpDn2dU0k4O02yEACqnCG1M9EBLzDmepA +QP1NLCR4gOKe7XemAd6H3zqHAXKPHDZIjP/2OtGMArwi+hMkQPq69DZAgO+j4S8/XXdPjc0UQOga +XsBvSeXNJ8yAAAqgGvmH07kpFSx3IADlU9+b1d1hsqqo76TuawUAqmX1Vlz1w9u0Ffg/BanBPqc+ +af1wlHLA/2CbkXdi7D/iqsWyumZ/VmVWk08W1VYqadyVzOngvyMazCXun1KiarHe1bzx9J8+vbW6 +LAwJd3VhOF8P2TyX1cvxCik7bKfLq0dRKVDj/CvyTyTRvVjmK3bAWZ0lHcC/6x31p2HPQr6B+lP6 +rDMIHPWnZD2A5yvpTxEUs8OC9CdvM62wBumvlNM76K6gPw04rE8C9FcoKY2CNI28GpLIJk2cP8Vi +rPAwOH+E6qyo1Dh/6tZ3vlP+TmsIMRh/KtGl0a0j/vbblrGZ8He4KTcAfzomQZng+yn7VI6YjPdT +5Q3FFk73U57PRfKUw/3kl2I8TGy/y3OHB9rvatHJ2cl+ctJquspgPxGXtFIYqly4lonkWD8KKrtz +FceobI2EzBjmi2U/24rA+OU4mEz0U+Lc4ahtLEyhRrjlDvRTxzF5EzLP7/IU04HzU965uaSc5gdL +Sh9ggvnp9dZ3Plh+yj6+gPt5Uzg1yzy3PaP8Tsf1DZLf6eveAfK7vH1S5vgJh2IgDMf4KTpsnSEC +46fAMjHORPEjC4H4pUP8tKNlSATE7zo8xJkYfqfbIAPhR55LnQC/7uvvxO/rZ6SMOb5PozKJd0Hv +2+0qM7tv754ZEeg+CYdvRnie1Jh+vYH7lFSDuzC4fbvbDgPbp869aquTsX2dPodfBrSvbeZUDmZf +dWdoRvapFcjuzbVva/76egmalQZ7dwmrsU+4vuYOk0Hra55TMGB9in825+ZNVp9UyzmvkQoqUl+d +pL52mVWcQX14L2C6OKhP7eIrhes1clF9+E+cPu1XL5uCrEOPwj71npQ+RX/303CmE9IHpoZyBWf0 +yXix1HUn9HkaVyL06e3TTx2AvublM4PP15s5QjOej/o5BVECzyearOb9QedrdL1+Y/N1vVjyIASa +7/T04UHmu27/DBKYj9QBfVXO5StyTZGnEVy+Qj/3q75x+TTFMEwNLh9RvE67QOfymbHc37B8hoE8 +J5VPpraFzhOVT3tbyDeofPrYzaIMKl8pPtFmKl+W9XWbQpmNY/lKZIhlLB8y42hg+VD05AaWT4oF +PxOWTzJFAgPLV8jvvtvE8kmxWrGE5dMMS0vKgeUjzcCCZ95mWdM8OcgZy4csP2FQ+SSQBxVUPgm9 +jD6dc7fdav4cykfQuq9UvoJTtF9vVL5CedpZJ5VPirurPHwl0+U6ocKsVL6iEYRQj1P5FHCyt8up +fEpcawYoXKh8VK+RAuRQPuUDWPw/oHyFrljyvyUon+JB2L8DyjcjEAHlK+SuX+0NyleizfiA8qH0 +Mpl87Lmfb0g+qfg4gsgnAZvCiHz6ExdPJvIp1ZYF3iDy4QIiHTeIfIVyZNnPicgnmeywAPIVeol5 +sgweFSnMIZnIJ3mjOC6QfHYjSSHaw6t1WlQhIfkK8VZ9jY7kUxyPMoGB5CtAh9uRkHxkNco+Gkg+ +vSyWNB9IPnIeCBQmJF/B01/uieTTrpakEUi+EsVfGclXuue3DySf6hixxweSr7CY04I4IfkKFODe +JpJPu5pxEEi+IsiiLiMR+QppcnoKQeTTjx8LTkqVC8g92akrkU8qmRCDyGcKtDZv0Zb2nEg+ZEyb +QPJJoT/cQPKVIPFlJF8hfcfprcTyS3PTZSD59MXawRKSj/RSG9Ydycd17FTVO5KvcLdYNa9IPko7 +ibA6ko9iA9yXgeRTmSfewoTk06jg0A5H8mkgMs9eIPmUMmdTQULysaShkj2QfCVKggaSrzRvw5KZ +fIxFZnk7lE8f7mXpcT0C2AGzSFQ+ZDoWBJVPSl2YfPq7ne0NyUedye372XxG4PsuE8lXgjKSkXyq +LCAaP5B8yvGnDmMg+Qhh8pATks/c8VebSD6KpC4eg9eRKGhHyDIj+ejVSZg0kHzeBLoOJJ9CjDbM +JCSfwopYkQPJJ98+K6aB5AMQjeMqIfkMJ73fE8lHsIAVZiD5anGCRUbykSjPZxlIPkqRmOQCyccF +4+FISL4az3wg+VBsBPK6Zna1Bhcrkk+dQM1lFUi+GsnEA8lXDBzU3pB8JZpdDyQfNSksXCJcrxCO +pb4kJB+7ctZA8imYRapEIPkE77bpdiXy6VLMmgkiX8XAO+9J5CPIHXlQA8inKCBuswHkU9WK2QcB +5FOBh1m+ichH5v09wA/y8cqAZgAKIp9qK+zBJyJfBdyjTz+IfLrhlpVoRD6q0HB2JSKfNaAp+0Ty +VVr3bnUi+aT4oVYkn2TLIDUkH7Va5k11JB+KGzyTyEc0nVYHQeSz6No1gXwUqTBLrkA+/XbLK3Qe +nz4Oy4dwHp8is1gjCcfnjPJ74vh0JNJUB49Pl2DjQuLxIdPBJBH5FPknx3cQ+fTa2yIkiHxULZJs +n4h8ilhjVwWQjxbP1trFgXy1mS8s8/gUwaaPROD4eMK0eggcn95l81QmHJ8+DjLtB45PdqGZL4Hj +K3Qcu6/3JFZlJ1kpguH4lNXKMmDg+GQOkFuSeXzKiCIqMXh8yojyUuWVxydrhUyHweNTRJgufoHj +K7RbKscbjk/2s5WUBo5PKzVzogaOj86BNNdbaXxXt9F+wPhOH7QGiw/S47G/sfgODw0NFJ98GQCr +A8X3cF3/8t7xf1ESHykN1QF7k8RHSgOvf8gkMPBtOokP4fQ9l/leUeGJ4dO7ammigeFT9aW7F9Zw +qGToQwPDh9JuUzA9bJvDC2lmUnf4PAaGT4p5fQPDJ4XU6YzhU8GerSxkft/udhscPo3XljKVOHya +O8wwCQ6fhguchqMEXDlueGozh0+2hHt+nMOntBiewODwaWTYveI+jxfMpoHhIwXmcEgbAT0p5Chm +DB8yKXmB4UNp+z0xfBzMGX8LT6vSd7NPCp+S+Xx0cLpepfR4X8B8tith9BXDV1mLrBi+qSTi2yJ7 +FRbAgRXDB9/hgeGr2NwLhk/XZt7CwPDRS5xWFCuGD5W+GoHhQ9n5VY7hkyLDIlP4pFoeRVD4qjxG +1OcHhU8Ky5+M4VP/cyuTDQ6foBKsJoLDtwgrh2/KweFTo/7E4RNX4AOHD7pA4vCJBZA5fIuSnsqQ +g8NnAIWFw6en8uTwwXJIHD5xFj5w+JAThw9l5fBJeHL4UFcOHzyQxOGT8oHDpxcrc/j0QHdrDHtH +f0EvhskcPtkDFkSJ7WSWYM8Eho8Szcsri2YnMuTdEXtg+KTgGA0K33NY/rl5559N4cN/Z+/rSuGT +N5W+I4PCV4rH9gaFj+nZ+pWneZxKqzYhfAh0qQ8IH3vKlMwQPsl4SQPCh6uWwvyA8FHkRWAhQfjw +a0YvWnMabf4fA8KnBBBrLJQgfGpJYm1qA8JHkR4JWAHhK/FGZggfMv1PA8KH0p3WZ+6sLcLaicKn +mNBmnn7D8FF92I99cvgIG/Ug9Y2IrXIorN2Hc/j0YMw0Cw7f85l+/eVfHwVzrURm5fCpBJfK18Hh +Y0M9/cHhQ5GZljl8kvlYB4cPd+0QaNKy2VSfMXxy/nhJj2c7FOVAUBEWdD116vIUlXW5TzF0W3l9 +mt3paTcwfFq+lNMReRPDh0xfssDwSbGIXGD4Kt1Hlc6ZMHxU9lOaEBg+ls+ltYnhqw== + + + 1oW9vmH48DKQQR0YvhoBxIHh00LqsK5kK4av0MYVJpVj+JRqaHmeweFblBXEN+Ug8dGBAcdwAPYY +tI7rDcSnBbRlY4ZMxqNVshqJz4S2v6H4FtlTJeoWjoJg8WnQtRKgxOJDJnk/WHwoOCOCxSfFfkBi +8bHmrL1OqFylAFgLM2fx0SDW+rStLL7KJ733yeKTS8F8IsHim0rKMVlkZ/HppDtrv0Ds6YZTJJVQ +fHT4ICwxtpNLjx6ljuKbQkLxLbKzI8jGPBcSX4neWJnEpz1x6Q8SH95Bgtlx07TStFrFROKTN9TK +twPFJ4e0/KmDxCfPM3Z/JvHhkLZMMSfxsV5kjRskPkIyCCuID7U4ZI8EISnmfg4QnxRcFRnEh8f4 +qpPDh+CHYnyxLbbyhuGTs5xixKDwyclsrXqCwvccQH/5Ob5HkmmC8Gl5TYlBQPh2f4yDwbd7N7GM +4FOwhCrNIPBhjR3nBPDtXmCc+XtSY9DW49Fu+iYHfW83+zGz90hHKHWg94hw7Pck75FjR27oCt7r +tzvWg7unnneRFEiukSFE6xt1TxGgcvUJ3ZNwOkqPyAM5P9v9htzbA6IdxD0J1trUiXs6313eeHvq +0TFZe/tmDuOB2htCIu2hnpOzp2p7a7sEQe8Mf+tC2bs8dc41ucvxggdjTxNmfSfsRaudQX24PMFo +cPO0TiJqmvh6o/VDqMfm1Z9B1zuioetK1xti0PWUoEM0MeB6V6zD08KfZM5eJ1pPtpZ1Vwi03lQS +Wm/Kgda7r6g4dWCeRlubzVawnmYZsiVDpdtXPSdWTzlYDHAJq3eFkz6oepe1txlMPXqAHvsbU09V +tLhhAqmnyDJx+iDq0VR4u9+AerjP6z14epcXrgx4Hq+FVhyJpodrjyQFh+mJ4RFEOWLdU1hZWUMN +kp688tbv1/l4MlXJe0scPQDSrUxVtcVhGdCUbAorRm+ogdG7vH3SoOOJL6THkyl6euyk5A+5FM/v +GBS9qSSKXok+9YOipyQPy/4OOJ7qZBX4yBA9HaavahRHDITeEZ2rEkHvsGBT8PMAEXhbWfolHl5s +kel5rOupUXaYl/oPW19pZ+cdLSaiFZ13WM/wAc5TFcN5BCVPV3vZs8rYvN1b2wxVaz5G7YDmDSEx +86YKMm/35miDmCf/K4VrCZina7jLxOXt12zwCy1PAtZ2guWhXn2y8iQUF0Dl8eNKfSPl0T/4OCco +r1sWysDkxd8JkjdER+ThYpCpH3XJIiLQJj3VLx9nVJs5H+/0bjMDj3dulnqa4HiiTWznROOBsd+u +CbxTKRrHTWA8VojyKwxZ+S2eGuNgvKmkj33KAcYr9Rq5JXDxrO2AN0+ZXDxrz0TNi3Px1BHTStGD +jFeaW2SZjGdNobwtBb6EEcvOaDwZmEkth1OiBhlPRVL0uMtkPJNryP30Db3Xt0UuUI5QrpGpYz25 +BhgPgUy5AOOhkDqSwHgEzRn3nYwngajKIOPJ2iaZN7PxlIljmQbBxtMazeaCYOPRaM5aF61sPMne +HsTZeFIIgg42XvEWUwmNR+fH4gXLoPGSwlvBjl5zPsl4hZZXpBtZzpdq2HmnAo0nV7zltCxoPK1u +7OEFGk+KLfgCjbcoKxrPZPkO61jeRAuLQOPRmuXyTNmJxiNTybInenSW9CrlwcZTr24+68zGk+zV +fM7Go6m3w/JsCaHhnizQxMaTfLVg7cmY0YhvvRsdjccmUNYSGo8WNgTtozRIUT0SsgcaT4lANlsk +NF7ZvYZvoPGkkGo80HiFwtntfkPjIWO1BRuPXcs1W35y9GgCuhhfmrn0DQUZT8WIltkd5eIoZPMk +Mt7cMMh4henNmzJ543ZbsS5ovCJnPi1QfaPmj2Kg8aaS0HhTDjSe1nUGqwjiHa0iSPFfyXjKF7Lb +OLbbrYJtgPGmsHLxhhpYPHmycBwNLF6JaEXC4qFu96Tile4l50HF0wqaRXzC4kllwAwqHkLxzTgP +CuHlhMXTCeybDiyerpWGvgN3p9U9tytR8ebYPbY7Nk+PCyzeVBIWb8qBxbNT9EHF00obz2vG4imb +ynyEIeOrxQ/vWDz5vG2pmLB48iQbhySweCWajo4F0lQSFs/k1iYWjxRXSmUCi1c0tFnh7YrFk+wN +NxyLJ8Vy2R2Lh0B4LmHxJNtI4lQ8BPpkBxWvwA11wt6k4umJGtbOqXi6l3zkA4s3lZWLN9UA45EG +sIOXdd5dASR3lzcwHvMzTXbHhgqEHjTTtDZ1U0hgvEUOnySVYxqmg3ensdFpLysYjxeQXpljQ+XP +EpEIMJ4cxgy/iYsn9S7HxOIhNP/p5Muxo16TzMVDrsG8I0lDRg+O++DiSbHoU+Li6eJ8VzWntsaZ +dOM2Lt4UEhfP5La25sVbcexfBvAOP53Vh69gvHJGacDYUE5YsH9BxlPuVbFih5WMR1dfuowHGU+G +yWYcPCfjyZeJgZjJeNrQEkOcjIfP87YqdWLdpG1t9fySwXhyilvT/7Fh8YTYAcZblBWMN+UA45Ek +1D0Ajxuds979nYxHHgBMuCDjVbrvO0KvWd9x+UH3642Mh8y9CzIeB4OuF2i8kaKW0XhyM1uT0UDj +kV5F8CvQeIuyovGmHGi8OgNbniIo53ZW3IC7bGgfstz9ZEEMNJ76LHhF5YrGQyZtI6HxdERaygcZ +D7PUyISOxptKYuNNOeB4JZgkozuuPkbaNETxGunAZC40W6BYJknQ8Uy5lsHE9hpy0PFo+shwHcij +QlTIK8UmHa9snjI86HjRRXzA8WSwk4iX2HhqXkTxSLgcVBuJOZrQeGruA+kpyHhXZFkH8U7dSSnY +SGA8htl92YzsWUfikS69wvBYrTkGr0VDwqDgdYdjZAieSriq94DrVAn9meU8ejX9wyn9y/u9/xWA +91MXopW1+Ib/w1/+8FfpNDrs7//u1//7b//LD7/+P37713/4Gz/8a9N//7s/fNjyL/7uh//62x/+ +8XVd/+Xvv3/1vvG//e2P+gG//eHvf/2//PD//ezm3374T3/49es3/49/9/vf/cStiWv+/d8+Nn59 +3z/5E/+nH377n//mD3/sb/zL3//j+I3bdw+sH/kXP/zdb3743R+WX9m/d3D9v7/6f17XwpP99vvf +LDs9H+q/e/315/++/frf/e6v/TgIu4Rf/4ff/+4vXm/yH14v869+5fq/+eE/v27K8i9/+if/4W/5 +t8v+7d/83T/8/d+MY/13/+GHf/zif72s4f/+T7cvf/6nf/J6yf/xT//kH/Qf/1b/s2YQbl/+59d/ +/b8v7R+/9C//65f/6//evvz1a7f/8y//9E9+dW2nm3wX9VgamH/Muv6LQslv0strFvgkjb2/feeo +L/13fon/m/5H/1eU8fg6gIp8t10hi+rpVz+a3szWmPq3d/0IaR7igzT3/k9v/6Q2aZeBW9KBQ38/ +YfGckfdTfFefx3k/tQogyvU4s8uPE1cLsD9O8B19HuZxXu8z8zix6+9n3rwt9+MM39PncV6nfo1x +4+P4B94NtUQnwIF7XmbSj++6c6LsXbq9uc9P6H6cb985ftyE7fIkxfdTL3o6BaCP6yf1dOrn8Z83 +QZm/JHZpe+/0Oo/v13Maufpx3qnnn6yy0k+3Yur51ilvdzueumz6S00Jbm8R5rryENRoYtNi9JzH +PywBBX2Tw8JFJb0g4nQ3ka5YiJ4OavIpn+rrv25LT7AHuzUF7jZaz5jmbfhtQ+93oNdus3Rw9sIm +M9EieDoZAR0TSY/hpNWL7k0n7ZBfSajKT1fturxk2a9LEVK2jOroX9nPFM0a/VBPW/tlR93jdPI+ ++n20zrzk+Zjjw15Zurij416TKBdovU3E825P6GUw1i9+7w+c1K4f+2XXcKlk1Y4gCyou+OguYlNy +VncPmPxSOYA7sey6MGttL3nA7EdQAsJJT2/NZjq1z/YaybK328A6wd5FPSkTSXnjRYx0gl/Nlwu9 +bt3enNOC/a//2iwY41vep7a87tHHwo78Wo/p2i4v0/e73vjFZAf53VW9BhemLb1LnN0HlgzociOY +tu2l+SXoX03EocPF4sIfB3hNeKf9YrJH7GyVJkUSqST1gUo+H8SgncZdpzWI2lPc83RXPB+q40ys +hx3W/eW/ibeBjjR2jrhgZed0f9HxOtlIcNiNVDKGWvJ8jRGOpv689fgBfATqFvJCJxlPomdP2wd7 +H6eLW9EXqy8somG/4hbSdJcjXOoA8e07Y6GNnZuPlTcdEv1+Eyr/cdzv3b6dzZydMQdogN4ipdPe +A9ryI26ecR3vh2gWeuT4yX3AqqX7xloT+ketsQfx8kx602kuZb/Ob7f8V7u/5OQN2qnINbI3/2rX +fOTnvfs3RXKTvzSxv/wTH2/Cb2Juuz2MZb9HF/HjmCbtRae14hnD6SFPsm0cN+02ELp9oF6SaiNk +fZl7Npzi/xtH8IF33HZxi/Z4O/o+PktvvmFbaPSxb/i1InXxqKG91gQ+oUQ9lX/XtVWfaPwL9gRl +f3XvuIK3u2A3SMvN/+hm9csUz0b1H2Vs93dbu3z587/9pxrb9zCLz7Cz72Fn+3+5UX1+lPQ/357H ++inrulazfi+ylWucedWrFaAtp/kk+d7fvnPUYWpCinp9v+8nXPR89M3CrT+hp1M/jz+t3Mtf4bdT +L3o6BXTi9jz1oqdTP48/T13N7H2ceurpFFuMJd/X86kfxx9m7b0Pi3c99aqvp9iibe5P6OupPxx/ +WtTuSX4/9aLnU7TFUv2sp1M/jz9PXYaxnU9dFiN8OYVyAofR/lnPp34c/2nM/9OHlP/4u9/91Y8/ +/PWX43044eP9J44ovQrF/cX/n35+V3TSA6KI395EYpXN1ulj949i7P6dgYWDVnJ5qfUyXLSfix43 +yC/78YtvuxmbhRhLiHFV6iNw41013drYsLHql+JsSrTTYdvLrv3y6RK+2tvRhYihsuX1L76y+HHo +FdamuinK/vU7dHimco248LfvHOfbOMUVrQ74p63HKU7LsUG/jm6Xr4gFCNHupWF2UvJdEYl4fo2L +OSGncDEvc2leJMUN3Wr3zh663Nah38cVZzSmhQ5CxP3jNc87Jkvp9rt+bMf4OXJtmAdaUQL/Oe5Q +90e0ny5SrG5HuK2i0vVdSafoRyuxMQ1eEGUruEiGCaI1tzdZOZKuvn62a3e9Qzxi/7ffsP68fOgf +4yFSVeF7xI+bv7hdfue+e2lZHq/HEZA83m61txv3U9lnyHvrNZ7hbT0r7aTnxk06FGa5/Y6qmb0f +t/p2tbTbL0QJJWLZ2Kb+uJW3e8VBdxbony7s63LN++bvUdtaXLIO03aTwTl9G/JhR1dyzt396N07 +el1WRPLpuOtjua+417fyGX/ulNYGwEaBFkevV/dTUkTqv5JOjxyhGHvPN95qHKGO+2RJu/ZLxsv0 +dmnrVZ/jjJtyCMezPba+x9i3xWfRznHGdsXr6wg8au/39Vu5im9MM2t/18/N33XoSw== + + + H6/h6zIylftoPgIpODZGplvUhK6qSnIgxvhBJhmby2ge8uWvlKJ4Z/ERxFLYJB5+px7nm29UXT7T +Lu/sj6HTO9/eTIWoTNwuf9uvYt+5tKP4Ld0cUy692DxiG7cxFgJSOeLt1mfsV6HFrX2lytD/eGnr +Vb+ddFx1D5lSgm9j8/te328Xu2tF3R+/92Pmp+fj4W3NP8crxbvnL/d5zy/hOGOW0UL723cOMwek +5q1ZGCGUCf9j6K3HELaNAekgATgGqrMt+tth5hkcrmF3NBz56LR2kUw+gmmM+lgf91G7i3QemCbJ +1zjA2cg06jRIjI1fBoFfyOZfxeFEYS6ubGUe4K6X/8Zy9cMPAJbDh9LX+/HxN8xHtC//xFv0Y+hU +Wfu7fN5+IbXFj37d3vunrk7bxpvYzjN+SWtHvJ6n37XHJXxdHi/lBT5knm0+3o1W1WlAVslNzL7k +bplowW4+HeW2fI0jvMaCM4683fNN8IwqdP/U1Ojl7CHu7cvHa1sv+3WMYcL15a383kmtTSO6zEcT +e2khqqjNxf2KOcSySWLbO+6HhlU/ar3K46hvl7YOEDE3XFZzPQYI+qLMect//TaewH1+/5bExt03 +5g2Kw4aBV/cxqL1dw7y86MBGwb/18zb5uGPCvvt5xTBYTx/QzevKloIBodHEaAy6+36HwXqaEa5t +79tHf/LgP13Bb5Zb58mL+hcN0HNsbd1vCDbZGFzjlb+U1hQ3hG6sNiruLQZ0y+is1pd0fF6PM35b +n+Mdo/TlNdLf28W377e/lSQvf/vOcdZB8bxPf6BbO485KN7+ay3sYMNDi3d+PPvdjAYTj3uOGW4G +ku8cA+K2xRLpvmKUNIikiec+R0Qj3Nlhfc7qDsLgWmXLf/wB68c7ll+kr42fto2no9JR12p7/+zk +zwwbplzbOS9uKzUuLkbmttxjEoU+XcG8ttO7PNoPPMajPW2KNt2teyXuL6vL6wrxiquIMoTQt/bc ++LxctICPi3s8u3Pu/3Zl68tCHzJ7hWVyjTtqYD973++4pe3e/ThMVS6On9fqOoWSk2a6mnn5897H +L7x/7oWxUjA7W0yW5xaraYG7Pv6EdQK97xarxnb2OYHe2+Xz4l39cXsgy167rcakeLrZ6CXh42sg ++9+O4MPB7tUiTGf1iAn07RK+Lvd+u644tvfZCD1M8m23ta7EM27z1s/xOh/xYLfellv3svXi92k9 +H2JxA+E1aYyvJF/DH3N51g3S1i7xDKtlrvOp3PvPvBnW1Sx9EJEWvXpxfupz3XvM1USF/A6Njbe+ +/9zvk8ef90u9U7e7ze/1sjWsUqKLL4JPw2/QHqbbykRJU3eNDXVL/OoOI4aiK5xp2n2cMWedtf3c +9z4Ghz3Gs1U8XtaSi1oS2fzqxEWTyf8zW92Xl8dhcVbEXuKgxiWU9rID+zyAtS+0lZgPfepFe7qp +f7QeV3C6DSckfV9+g4FXOELxI6hrefXbSAcgE3GvIV7HtYxab8/h29C5CuW6x1dGU/bTRLr7fnzA +89lH2wvuvM7yY+gG+bSl8z6m4cPx7mME9edME3974fyTVA+gzb93prH5TP2l19dXajxTqpo5QruG ++GEMP4w66h/TXpcry7/k2zL6nS0O1OTdGKPfa/EStsbhaxMFzsv5Zqrtwwz0StUx+rEyRG/uolNe +/VVjJbj3GuuHMu2Us86fQ88lO91cbJC/Ya94HcuSs47pQUVE8xquIx7VdodBM5YeJNT/pD1jyPA0 +5avqdA4sJRZR350DxuVuV/zeWMRKu+MnHHfYiSzcxwGOexx4ukeSXrbtGAcZ1vdWPol9X458hAvI +8lxM3MOEY4UTT+2MRct+n8sRxqxcfATR2Yar7TjHDx5nUoR2uTnxwYTttC8fzMuiiVu+vqVluTl3 +7/F8VOfsGx+xbHp9qPVnLyEsztLP+RumD/HsP3cb58Y6R4h7+/B0Pj3i7w8odfyQdscAvbmP29/0 +jx9xchrdVmCkUsh9WUv47C99H74nPTHT6tGGePkB2giHSGbs16bLou1q7snrV7u/fLyA9dpw1diE +2fo9r63ZJKQZQE5AE90PIDdhWF5gtv0y6Hk6loTun+II85fUONtcrn7n121l918yXkJ19z78siiR +8y3dDpML/VjvTysxtbV9XTjWmPLOGH3qslit/Q6/4/B/vj7EPg9MtAKdbo0mUg5jV7EPx+Xb7c1m +m8/c7e7TaIvP2QHL30IneW5O9FO/T9/+NRv1qW9a/drVeKhMtttY0Vuu0PM60jrpCkuPwr7HOum0 +rJ4x389hi0Xqt+8cZ858l7Wdsi90RJYktzvmZgeTuwXSjzCXVcny7fNh4gSVLFirRGzW/P3H0A87 +g2KNKh/+Fvq+765vN3MjIkGK3XGOHw/8dZyzhE9Z/9RjOkc3x6ZqwlSB/i10tzhUyLZjsyDabKqD +WFjww5HHw1IdVx+D3T48O6rVHvFVCohMnGudal+WNPtBciDuLSbPi2bm8fQ0kX+bBx4T6HbHgV9L +7VjnyAb9eGnjVqmzl9knshF7cW8ZehjseHtNo8TSzM96HSGeseUVvjJk8zNge/bY1mg1lfrM43bR +vx/G4GsegNI527aPbd2FLkPXLPMPP2H9dR7FVQOkNl4+5bFZ1EaABg1n30LfzKhRKbSNIHQwu7pv +7KP8hyPPt095j/Hi9HO+8bclx6Bj538Lvfm9bpbXiLabq3H3qtKPBx4vn3eymEb3jyEbX9XmWrND +aAAznEbVnPOnc3b9ZRrLGx3h3t/cmzrbcKiE9fm4hPVz9NiW3A4j0KQveK7Juxn6EmPtrYKtO771 +Mi6ZFd3XceTh0z3M6kBsNcIyGKYfLmHeunOJiuIM/jF0Q0aax8A+L4ktwqXbWUKcJuhYxqjJUI0b +6lkF57H4PZibf/rWE3zpFnMzX5aOekXY+dxsRfL8CePeq11ZxSu6ezeIH4ferzHMEnZDNFNU4oWX +EvE6/fWkK/7XcQQbwhjAx7ZHbOsm44dLGFdHw4FYksGP/TF0a3SH7gcXd2TMbmexB6se5eGA3g63 +JVHH4sQ9AOx/hQvgsLDfhysY3vDT+x/bwxqBxrNYprI9FkVUTYxsl9OczJ8O8PXzccdkfG7mwzDT +Q1HvH4fuvsDbaoBdPMPhf7obSOIV0d7pJpF8hGl1uvf6ZFz1MCVY4Y+XMO+HQgiHO2u42T8O/Sxt +0UMMg3e8pyOCHuLXcYQ2juBuLolxstPHnccVfF0e1lwRlDLcFHpaY/Uc10b/tXClu9PoLCN9wQP5 +42lVGXW+8e3blrHimwd9u4D12ijSt0NvIyJ10gkzXoQ63qTXQsnfpNvXO9SMthg39lLnc7V2W7x2 +6owQG4cdcTVLxHhew3p5+0j3obPQuLw+B6vW4ja1Mw6z9/Izt67V4Ubdx33y7JHTCmx/+kM5Y1Mt +F/yiRi4Ow/zHXxAvLaAIXvzdZ4AfQ24bn730bgOMxGKLqxI/GLHe7hpTQczXOEA3f8/uSzsX3WlX +7U39dAXjxovKaNOouGIzRoO+7aHbOyfxsMWcUxFd3O84QtvDZGTjuDr6jcdhD7+6wwJId4lMFbQR +9n5e2hikVCZx+nXcMkd+DLnU4nr39/aeK1BZ8Pv9M+e8L3MGF5t6v30+oV2KqrU0s+8v8+vytUGR +Sfhj6LGm9a5u30IHdlJBb1azDnbH9GCBWRCAA7u1q3TLr985m8RmFT5s2Q6secTtjAl2i2QwQETN +BrZmLv1voZ9+3HramyOpVp842z5EyhtM7OHkk16P2JiJ2cS+hZ07rqy6v0nPRM7Hr3OhZr+iWpse +E8PfUK0z5/dWXm5kjdf/UAxiLK/mq3tupxtkhg3jqfY6rLQjLneMAyy6fKnoMPdx3O8t57Z6rV+F +xC0SN3UrtqO6aORGjIP5Q7ZwT6y3TYS3049KhogfgF75vPXnvc8jxOLRuZLfQqdQzT8IG3c4Xfxs +Zu04Hd4s3bS7LUc24DcvcL/jCNYqlMvwF1gtE/vmj4k4ka+s5KKJ1bRe4W8hexgCkMux+zGqGRS7 +v88SVc8X31C7znFgdRSML6a0I67i7Ht8Macf4YYcaD/YifAmF4uc7969wY7K3GiimqiY6F7b3Svd +xiV46Hyn4f7pG7f7jvdVBoiJHgPDp9CWH8FCaa68/Pacy+/Yt8tWgee4E828fibuRzy5a7wS2xlZ +jzgZYv+IiykjxmacMMBpoOv7HpGnqMdw1tN37s08WyK7+e1WjcLW4yzHcoQSfou62Te47dFTQtva +kG3t2o8rhofxTagvWSn+RjOP2MakUvoD86XxHqaGbkrb7nmE89pjBntdUdzZHsGB3UGqLlpamU5n +JiFiH+/NiH/R1OUsfhmHJTCwcY0P3gOtEmvMl8SLxwHKaW+uOm/6G+LobH9tdnsbvYuVHfXaY/RU +Axq/OfSGMcnThrkqf/OrMyW5YyMISLv2c4/RRW+riZTD2rPozX5CsbGVa73aMW7v930auwdkMQC6 +H8RTwdTDZQuXxtOPYvp5hSN6Nz8T/o+7u9cmhlN5SnxqUSrvfPU3p4pb2v0R5QwqX3OfgVyqJQ5S +r8sXCR57+QknUbM0WMnbHpfmaWi6tKF5pJDL7ec8wNYi7dbMWWm+wFOEtGxxVc2S0XXDjvOYB+gj +clqmR6rfzR8R1vyvfspRFtNKMSJl3N3qR31ZQnEPrjHIY12OI1yWsyIL865xBBoimVjv+BHWx5BX +R17xcYTDC1N0hDjbeJtezzzuorvGmdWs7Z7rFlznUxvOvt0HUkUH4gD9ih9LEeF8ji0MXo0A8/24 +YyIncd4twnuxs0/1QXL9igi7TulRAdUd7m7pUzku7RzTmryT5zBBz+F207LPN20+7hWjKbpYw3ph +OJ37W/B7LyPdXcXpw6mIjWDi4YOkftrht7JQsrn58NtLbBvzVzVnvIn9iHtDNs68hH77AQjWfhs6 +7cU5iGe1UTXa/cbv7h9UpWeJIerSpz2OXO8YSDDeJB7WvcxeiWZhRgHQ9n0MUeMAx0g9qBZ9NLHU +mMkpbTVxt1oYFhPz/h7Dq9BGrjBNeq8aD613Fz1lkVd93J19GQzvzTJW6A2w+yOGvutijwdEvt04 +AnUnNpzGfeyOvOWwhz+hbmfwAXnU3NxqSdt9HqzHyA9XUfEZdkPzxfxdwznIxubPVxG55XG9TtfH +evmukYqit68e4wB7LCa7rXQR73BpH+6ssCVYP4/wKal2+1vo+8jf6VeNdVzp86u3CpafWJHu8baG +A0q9Lo497Hozs9XFzlMJdYBt2X++lP2OC/A8H762Y1xVvV0cOTb3Zh4/u9bbfCLq2D7X+yU0BmE/ +/UivVXcyS3WdFjYbW+WYzAabBNXYbwwBc31GG7/NX9K99LGpW3AaGfxd2iyT07/JcQA4RvHi8el/ +C3231FrNFZ69qY2PMYxULOkCP3QYze1u88gkDPsnaAdQx7YxXOyWPyiy6BY34ejj5g== + + + XFdEovTmXiM7QxGtLez5fQaj7hJz9hU3TWPOHeIRZpV0Wgba6G1uaomshv1h2igrfurexpAxQtDX +EXkQ+rj904QmEWHlwxyA/z977/Zj2XXmh70L4P9wXgRQxlRr3S/DJ7I1EjTTlARRshmMB0SxukjW +qLqKru4WxXlzEl8mfkgQ2MYM4HsCRE5gJ05sJ3Fs/zXWZf6LrN93WWvtfYrsc1pDVZ/qY3mkU1/v +vfa6fOu7X6gMvgblEDrLAFGZEFy24jwFPPC+sGs6d0KLnkjd1W9YaMMHVc6wHNzDwEGqY055TNn1 +K0uBkAxsgqUKjonDATAsR6qTBN/DqlFdL3Ujg9iGMWy3EAShfUixFTnOM6L0EahNMsGHsE7wqpKu +Bj+hvmn0XQ3gQAMAa1eiS2cjJWryI4nVfgysqpRjuVv2UkzLtsdAFK7byeS+K8YAc5sNumFsbCyh +OxEdF+AUYNQlZNv9LRg3WSUxQuSKthgmXMssE1D7yRK3cS3oHV+IJcX3u+S5bC0DxZNEnEiW5rje +BWNESH1q7kGXr6KESjWYGE2jHxs27DUwzQQ3BohZSa1GZWJUJpUUtaGjqn0VrUS7NwtfKwrXHEY0 +aewaA1nwGUiVKJhXjEhL9I0T+ddyghUDs/A8q6YPGtarQuhTD/qgnpDKIOnGyedy38coR2y5lxcP +m/M0AsV4MlP3oT+cVbwKir2GbQ0yh+GMl3Y5TG3FFVMMJ5QItRUSbLg7KAsKpcuYRepcMp5Wp59T +ygpxnekDyo/GoERjhHujeL1I1lajlnLlSqiBQ3iK+ktUJTScP9L9LdxKgMNuc3/Y6GFKuu2tDhfA +qWuGRpaKVIJeHSmppC05idR7RVUO3PbuHB0X2zHyww9qqy5LSAu6aqUuboXh+Ugcj8nn4Ix6Uql2 +CvNe9SMlxWgAezIPmgVJgILtSW5wuQZlNyH1eSWrchyZjPsInMMUrRpEaFQRcW1Pfc49KpJmUPoA +sZtUDNvrZbrRdUXTqsteiaNl49PYhawHKRmf8MNL6lzt8SaonxujCHbUiVQGCGj6KkxPk6vQ/V2C +KiGg9EWYEVxlO2lCU4eRiZo43A0dv1zPKg4cn5d9z/QsbGWXEaQqMY0Qijgn/aSEq9qGJhScTE/q +fnVjDuLepPjn/jmOecIAkvmHeWloH4Wc9veVyBuOLn/U12Y1lC9Kzk0OXegzaicHUE24hu26fX+5 +dxDZEiQRMpPpV56tEhlg1S1hH0wXFVhYNeJGJGS424xaWVLmkGJyoanVpBtIaFijoYHUTuCRwlVA +kHaSDDQq6Ez+Pk39qhyr3wfmpvEczJ7Uo6yJoxQZrUBxDFEI39ganKvXWgwmqtAIuGQy1HGFjKoK +gazaQYDRKuJQGMqZjtCkQhnZR0mrrA865kigZ+X+6Px67EpQqlw5WgTB2gP90PVF0wqqyNQoeGxc +D0E3GrwvXiJEm6RRCKBwLQ32zEbJAivTptERMbDR+7koRx9hxBp3XzsMVlpfIBemxlhvzwnKoxgB +tlcSpVFwuscSTLn7knOKljm+J7SmgZQoYZ57rEPSh0dwPXV7OPlyt3XRvEEqRSYY5TSyWHOGAQw9 +iczVBfppgIhk1hBM43+tsoTb3PL6cOkPu+7DT5o5YMVtSl76Hujue7UCGlkDldSaQcBerUAEVlpE +0m+FLi5iG6KmxlJoKgNL1on5YPUOURssRqg404eeyK6ZI7jySXOimtipUxCfT6BudIP0cuM2SkSQ +VCl0vsx6ENX2rSlVU3MpfruPoMUCKht9HnV40KlRuQ+h9E5zZTURAU/21B4zZN7slOdRmFoKgyjr +0WdOxGFg0HTxThJ9vwHS0mdwLCFpyKWWOxSktx/fACEwQZuAUFzVYLthSguh1x51eOoogdN/pIw+ +dXbINeSY0TuNG+uH90WhZHEkazjOiIG4ZTRNtSkNfHZAJOWxzg9iW7gvA+/FxOGK2vwpIE2iTaQw +X+h59gzUGFLQrtrnVnvUdmI79AnL+j5r6RZEgDNQ5ChKu+8oBLjXkelCPFKVg1pOSfxH15DE3k6h +N0WB1Wh8KylpXWnpCRuUTtH1MQ3WqpzzxkBNOyMrRxVVUYKUAQy522K6bksfZOyGXtkPlAJfGOiN +hgGG7u+BZsttfKXChaq7Gs6I7hCiXCB3Sm8SuaW7lWAsWoJpYRrRjS8c9cBAKu3AI9ie9QF40P0B +lurDErJfWMY6mc0zkoMxBuhJ0Spv09d6ElJRi43tWSP04DDvdFLjrdMZiHmHsN3pCNshzPJw6sna +aqfKvVpCGcpq7qWDyiwCY4SsEdPUqY6Bsd/8oNYEpKn1ZMORev8lAdqNZipHq75Hfg8EVvUPsUwj +P870/SndTpU5toKBI7jRcxg2jVCU+aU69gcPa0K0mM/KFAepBSYKgnZ1BsSc+/vUC5D3V0oQlKKq +LWVqeDVmiupD2NR5FBqdZL0WVMD1hI2cuXTphCsHUAMTzbyIqUym01HDRtKbYXqVfMCqnj96UESp +ykpwH0DQFJTN6rNNnh61FdT2KhZhEjOHXdyQfZiX0IVoWMslYwkCZPQDrnl4lXkbA0vUaEuSUxgY +Yw92rt1cg84tRWM7NY29SplBOTe2EVSnQV3YsxF7Rw3GOykpXYhFNeIu9PZle41xIyFf3Fa+i7vY +4dy9DD3aCZgWo7pQqlxPbLFXR5LWTilcfKl7cbQ6RhWcRJcT3xO5mUHW+VpNYYU1P+gJplldfBRu +wtso+ZQ197oyhZP6H6qHrZceiSJmUiVWlYnFHlLrFP9NXOBhdz4GzXSjwH0GUureQpQDsGq9EJIV ++wi+S3MqZqI+rxllDqzCck9DhOB4pgOknp1D5allXuK7yd2bMepbSQ++4fYOXRqw6psdgfdp+N01 +2Lly/Z8+gBbesyN6IKkxUSoJUUCA1VSqEa5huYp4mHRHAJ1oG5X7jy9c2yRd1jSNEIpycLYOULRE +UN43xVtoJHkdVbkJTm0q5XPBy8Ox9hoqSWMwVJyuc7wdVeHXtC+uY0xA5TFVzawAigeOnhyhA55L +QfM2QAR4pPBhFupBRaEz9sp1jDnsRfQHBHCPIKhRJ6lyDKMMHKdMNROsRsSoLNtLIlKro56qTirw +Qx0hh6jWAC38Q4FEXk2+ORiNRIo9J1CSPykIque/aR4kP6wMsKKq4wi60jA6o1oaBV0lrWwh5TIo +bKsrf86P8Aq5YXKFcpQRNLOijOCGLC3LRd+oY4T2NZWGWU6nEbIyOyGCeFLDkMEg7TSHpGXCAlsa +AQNrlNuqsVel19XIUxol4uK0aEvuaS6mTiktkktCoYTVd9kg9RBKo6HU0reYYSOlnsInGRhdrxgU +OsWwptduq5p/j0BLig3mLWP/HmX1dDmAYqVkBDcpU8VMiT1q/CDzrgJvy/ZxkywimRcIcW1avaqw +jqOTrNcgcxDF2OM6fXd49IwahPSOogqO7aUE7KWscvfdO5smQ0npScoET1rAgzzNHV6KiqeSp+ps +nigthYgxUAKMiFDpxbB58sg7iZ3N6vIgUYKz1ACMajegFtkyQJlEbE2FQV/NpCJk3/Y6JesOGybg +zqqYQ9FMPW9Nq3VVdcM6Z3o9jV7exKHLS8/IKoMCAt4L3+Ro+8Ndr9GrhU5i2yUZm3LQs3eqpNk7 +57mFLleOI3HeuaBBJliC7QjhgrQHJURJPUy3jVEF05ADzLQLvcvU7is+VcCi2G0NR+j1gavRwiZJ +onRd5MB4GlXCrNDx0qkdlcpxjAGiRsahAs0jBRejC5aCN84lxDt3bzYzDAClslmd4leaOtVLAFRV +oB1ak3aVK7IdyHnTZbrC7aB5BG+mErgjy3hKnyBDb57gQahtZcLKwNjLSHEygqP2sWkmqg/7wE6x +VUp3Apil0lPVTHgC1ll/lgGcRuQOjYemVbSqBV12GcAprXZamwADqLwhJfX70mruaYXo/vFInx9F +fsgMTqCkHM5IPqt33JlP8FLjnJoMManxypQ9oomN0hIuNEVPGp0ZKfxjBKPEXYLOCBhy12rJsAOg +rZoNFa2ZRihFM6fI9vFI4RK5RsfZSaCnpFatdCLx8egb2Hlfrf2LtfuY6XKc8QjhQdB8Zslwcb7H +SJAuxRKVR6VJtQpTSRSZ8jAnVCkVAZhmSVeOTQGwcN8EBo4YWk/at9KDqM+ShMkyiJGknsK9TcQ9 +NQ8g0YKBeoDSs1UZTBAbGgOp+xTvbte36eGoKqwYsRvKz8o9B9kBGHqdpNirPgBOzJw/51lewcNV +5fimiQUB5l4srUtMwWpwA8mwhKfBsSeR8b86npXXUGYyh+Q+Aa+9h4m5MKFswNwlY+5HxE9mdS65 +XlMJGaOj1p1X3RXg3Jkv7ZkAu4AfJFo3RK53wVOArU8GjpMdS+PV0Wy3qyNS/o6eLCMaSL33XHZa +zWNSC1rEb/WcSbAthXVoPULS4XkEOIaNLi5FTlGgiEqVNzTfO96e22onkUK8PfyoSmdydQCzuq7h +duYYndIV6M7PKTu3Gx0y6xicEKX5sRKeHMOkfnl1yuBZaoskd1UDGzlRJc2XhR92RtmpCsAARk2W +GxEPHOJaJDxCImg4MFkzNVSFEx8/b3+3VJIv3WreDZnUTsSX3kNlO2yk/oSs0SscpqCZDkaILwWy +VA2y5tJMHD1R9FOx9BEM8zT+GiyVgtUibMnzjA/E07KGhomIR6U4NOy5dJkUsqzRIDA/hBgqYq4h +fIHzJ7lgrYbqRa6uxmXJNRFkGA+peK9zfX1yacuDnqPDbYZ4ChqSRX7N/r5kkEZpgs43a0R0cBVt +wMRBQsFt3cyAW1g1C0Q3OHQllCLFqt5Xb3sGlEvTCNLdgMKenXLuELkEM28aIq47jSlWY4yCkU0L +7X4rUojLiYBcggahVm7Oi9eadshXikkeFusfpdvHnm6/lRiv5C/KwxT0p9RWo1BqLUpUs2ZnWbSf +6wPYHqdP9OiRUmZlZT2xFPReCnlRdJrtvEVzAYmHdN4i9koKLg9dJqg9McCy5svAMmJQ2aUGBlmt +nseCbwpNwnE412XHMoUTS5wCgCPitQoKgaWHnpBrXR4jS7VbCuDjs/NZ66biFoj9CMzf6uKKnYQK +4SV0vdis5DPHv8ranI6qaeyWvV4yQlJJClMzrktMqaGVxkYl1l4AS5pnIhGLANqioUaD3kI2yhpw +pVUSfOR+0bw5scr73ulJUKybDBB7brPvqTZNChNfc4+jBIy4Pl+A0LkhJDm2K1AwvEjmcST3acKf +D+rZoll1wo5nNc1FzDvtUaUFliVTmYDQuDnokyYgmbtW+ugRMPcIbgE5tddQBOXAO68p+AR3KiVH +DcBWBg0p2Ws2y6ybUAKj3nZmj1A3+qDUR46B4nUhQtTZuR9Zz05rgJMaYjX7Rrmut1rdiahxZ03e +aXUnYiB+0rsql+2LVqNySe8quruCXYZZLaNcqn1co/UZ6XSK6m22px5Q6ubJ7SnuDA== + + + Nj0CmAiSjGp6DpKSCjMFkJshz0PTVKYrlQxoBT0yvTF1PV8JGqK7m8OYQnEaeitVCmkNVXMJVJP3 +ll2g/CSCIs7GInoakxUUN3y/WWLhdAYANZlTql33VYjNM0ry4COFN1Vew7wlhc5VVlBnhHRVKn5T +QkBP2HZ1KsBC2XaPFB6jsrbESTIASusfxHNztIpzpbMqPxWMxMMqwng2GfPDmmbD5JEfdFXJM8VL +ygBSJ5IPmTt5AJh67SyJXYI5gt5jXpfLZKYglCN4FIXFlV4/xGtVezxZnB59zT2pzfWyqpQey4jm +strvSNTsI4gfnFJ7u+HLJbUuccB80RGkOINEWPOTI0c599wBwFXm850SNGDsuCp9RAAUfYNohnNj +BGqgxyM3wqyH3AinxL+OMmkNOJHjzGjpopYLVvLwUEfQLH4RzvrIEnZBSR41DLh1Y/O17wtMUpqM +5Mj6wrDYxdemrEQBSq8hyrg2k6nLRr1hWS12foq/lkAqAKOG3Y8CnAD7LgBLADeZAYMOkKzcJESV +asWAGKofI7ieD1Uk/9d5brEql1xAUgKUTmPYEf0kmWs1A+e7KDmqKQEYOuUYSflYmhQG8NzSg4Gm +o7C4gWHzbLKAVoXofk3AtQoFNYvQz0mwFNWVMFF3wfbsENPrLDgISFrhYASLAj4SvShhQh4eSSpR +rJmux/57lnT6yJStx/vDQfoASggeXZqi1l8l2G5yGQIsFY5xmQXLLJda4vvJlTZpXlaF6pQGQbHq +PIjipHukcAn/mC/5UOyk1QoDNVMRh5j6FTVazRd6seThO/WwTrnjMJgnJbbdlwlo1wKkbxLXhOt0 +SkyeMMSPUgol9BEoIk+XlqVYXG8GRGo5H5pFaYKODqNsAjwSHPFNJehqHe4LLW/hwYrVU5FqL//h +pUIjSmZrkmvu8hX8Ij1jXxJiadROSbxYyRqQrDd8AVJH6wbXmhCYMj0ap8wisuEyULkp4by+Hjkh +ecEy4N1JvfhZqQpclXZ5SHVmuCM416xgFw8JI0ZLCRmq69yrKFgtcNFTrVTCQCUMq0pVjVPRi5hV +3AxGvOE9NjlOFQ22ZvCwF+WpGiRGqkTpVXnqlBteXNGwgpFXkkN39FsVLmNPLqdnaxbBu+eUQkjR +jNue5rw1hT67TLKX2vPg+nsy4Gqm89JVakT+B6mFr0ANYfNzKGfwakWV2MMM35/WsdfCx9szeDi1 +MOaQ/KKWcYiJTzrYq91Tsz4JqC4uOnoBxtH9LE9RrLGqYU/LIiG01Wk/lZ7p4pSaUfyUT2OE4hTe +EwgkXyFM9RfXS1iir/dTuHLvO0OKUVJj7eTQ9CRSboaFXXUgtTyqw3hr3Ie9q6/Rm2M4vp9lGwSs +9RqjYsYfSWkEDDUpk89auOCLSh9IDCQeVu++1LWXYXtVidUcHs71OnudHF/jKNcZgtYypHhBAUat +uaKG8C+m672YosYN2B6kA6AYoG+t63nbxHoNLqSsWVUdyBvzROGhy+iMKwBVJRqKwl+WYdclU+ll +gAFKL0IiRRW2J9Ave4LyoEEMaeq/VKdkAEpp6GkVuWhjyGKkyjSISa/9pl0KVmFPPa0CXiR9uGh/ +xjp1EOOiU7dMbcw6dbuoYaVptDlgrxbgLmr5cd+zZ1KWmvEJUqikmKSpq2Fig1bgzLy5T0LQSt7B +cJws+iSItdL0RM/tqc177XoLVNIa+l6LtTqw7sgwKTsAi3PmpIskRv2wjMcheA8rDNoBpQzvqua5 +jDjQ1dteiYpmM1KmjPpmbVTYav5jaaVH71d29vTK1CPvSHvTlR4fXzuOo4MG505REEhPPklEh9VL +oe1TCssc/LDUGtyewsOpZmLpQcO93wsyJ2KP4ZMC5ABK/nhmdVuAXJ6FsnBGSojVoinUbk6C+l2P +ySlqrdyawYwTUlUX6OLn+2dFFzUcwdPv3ygpH8MEXg3zaK61mYxgKUXX9TKlEg6kmb89o0uLdRnO +WRag1ZqfTtMnzZRQ7EaFAqQc9TlqSDhNQ7P+rOtJRMupPZyLqy7H7rMm6szwnoSj+iCeLZqE0+6x +FiaKaZqc69NIPaFKk05Rer+4L1zdIJo9M5HIYT80CRCgu98L6GczOaXJEv3oC8YZpxZ7LUDpJ/BE +4aqRorRcHyoPQ7LpufNIZU3aUqDnLqJ+Sg+CGX1D8MU60jWzPuw1LZP8LrdObZxa6Eqi1Ph4onAJ +v6RkYdfTO7nfBKzBEkSLzJ6kKbm9xh+Bcy+LtcjhWX1w3kHVbqUqU99B3w2o2lU6925W0Wk5PVqo +Vz2Y5JW+U6OoTK8LPUo021HHdWsODyehoErVKZGAulBQih5wqf2Ai1W7LyI/c60DvhpnyB0IF1aX +KwXD9hr33qmlbMpFGQXYxGxAWRhxmM+mNI5hIyWfFgOTT1pPQXIrkZlhe/nK5KZclOJUwCs26deo +gZCoUU7ntVrEw2l9q8H7+vTUNA0YoC5lau2WIv2dRZfrMfOUvaL2/MCFzghYei1I94WLk1LZfkqw +pDTaJwqv1nShaPjyR5uWyZ+2PUpv1BADa0sjNuJJh9fRPa/0T0iDeoRipqlB/YjoI5FdRsiajqMm +/+3P9aWiXqOUxgicYPSkw416Kslp8qjDu3O1cBYRBdiyagjThThMEaFbnZqgc3ehb39x7l9Rihqo +U1cNCW60jAlS73v7Ci1D4znF5dEXDDO+kLQea+D8oycKVl9r4MwxBqrlInDxIzGyiKknzJEmXzSC +5CBPjoCtKfBZNB2ubt78xub9v7b1++tvf7d88HtXj9+5ef70kx+cPnt2fnMl0HfOP764WsLf/PHV +1emT88cbAm8afGO/8YbZvA0l8f3P3vjac/ywG0P/ef9z/PX77dcfN9hnG2s2727+8I/M5nF75f0f +trW1Q06ot9j+F2YNy6QONck4E3fAH63gKACJDkmPFqPcDp3GuMKM2pcRAdZQCZnRjYmh3GHDNgNC +ljZ/AGX799uM/3iDyOo28bB5940TeHYQHUHfQfV+6e5cLOrUljDD25feo83AfoBP4hsRgeCIAGvn +joGbXPIH+Of2hTd4bZQm00ap7DN5oqtouk6a4Jc6utl8/8vH/8n2AcinyDjYhizIkxm7TlXzOni5 +45VDb9ZAmtLZ6ni0Pu5iVASvw222mIECZQRpGbV8uHCvweWwHbiawwzvE+7DLla23ISzrbvynA8A +EgCvdtotnAtlsE5jDjzsn55BY5YdOhY0jTeWPn17sU+Ax+Lj1sMOuWLLYTtwNYMZ3ifbh53WtF7+ +9j6tftPdf/zG19K0j893u3h0G/S+xcjSSPty4jAqxtMYWZgmeEDzokuCa9+otn7PEYZyzKZJCYVi +FdvLluuftIcqd/VkvAErQgn+BndcgGpx45H1gBiN/2p14xXOFMdWDoScB7HOset0fPGn/WIjTFdm +hkGp9Mc8fWulC+hY60P+knDAsTdrqvDF+/wTELhBDcA/UDR3kE/Z5sBee4JnlMgFEI4AxgY5HQAz +y/0EDNjFMz2oGEzkSZKidKkjJ0QoEko1LtWhFNJATxe5+1GqgfH3Iiwpt834C+8uKWhba6OTiGm5 +NguHSKphsTYL5gttY7U2HABVXFqtDSOTmMVr822VHU4ByvPqAMyQZufV3TLn/W/cl3H2COgH37u+ ++sHNxdWzi6uPT04EThx//pc3vva9T+nfrOF/fO+vfufbF5dtqDe+9s3+e/O77a/33330vevH5/T7 +Wxdnzy6ur05vPn/BP721efNnTy6v2j+etAneXHz4/Nn5029sfqc9+PbNzen6mbNPLi4f35xf0RNu +883vXj0b/4j/evb5p+f0j29aY77+jc03f3x1cdbg77Wxrz5ePvvT08vn8vBnF4+fffLlT0PsoYfb +dOTx3zmEpX1yfvHxJ892X5s+f1eLu/7wj8/Pnr1z/fzqcZvnO9c/23mlHxEutmefPd19uYuX7mrN +b3/3g7cvP/3k9AO782IvHrdHX7Q4PHRXa9oDRT/f/bg+P4gFvQBn5wX9rP940axfNQL77PnNh88v +z6/OznfeF355163pn7qb435g4s4L+/D06fm3b87/xvO2HXtg8+q1u1qq23mdV8+ffP/s2elPz/eg +sPM7d7XCq+v3nl08O3sBi58W+pQe/9HF5T4rXbx0V0vFtdx5mTfnT59f7iEc6PM7kqwvWoH9shXc +ztZmPn/+ox1JzzT1Lz+OOzmpi6udz+n60/Ob02fXN7uf1HjjIBDx4uoFRGgh1uDhu1rWe9fPb87O +v3Nz+uknF2d7rG+f5d35BXt4/eTT66cXz/a6X1/RZEhA33ke3/zW+Uebt47K6VE5/SoW91orp+Go +nB6V0wNRTj+6OW06x+X3ri+e3lf1dHdb0WFrp7uTnaN2etROj9rpUTs9aqdH7XTrfh2106N2etRO +76N2+l/+w3/9y3/3Nz/wR/X0qJ4eiHp69J3eF+20HLXTo3Z61E5/2yd1z7VTVuPI7H4PldQ9de+j +bnrUTY+66WppR930kHTT3aXho276Ci/otdBNXwPX6e4uxcNWTo+u06NyelROf+sndVROj8rpUTl9 +DZVTCPz/+d/9+h//g6/IGXWI4uT5TfvzNaCHv4WYiztZ3e6YfHP6+OL5HlKVPn/HRPHd65tPP7m+ +vP54d/n+SBVfjiqmI1U8UsV7QRV3x+QjVTxSxdswKJpNNHsawX+4j9FieuWubslravT/5f/4r375 +9//zL/6b//5X//affUUlPQ6R592cP7n+6e5Mr53m5V5nf3l3h25egKWzRRlVlPawJPPjd7WwHenO +tL4+ge/RKnZd5+q1u1rv1fXV7hh6enb2/Mnzy9M97CmLd+5qkXYPdH38fA+pkx6+q1XdnH96ebpH +QOXp48cXzy5eRJAWZ9ffuKs1nl5+dvr57od3c/702enNfm4AfuGuFvj008uLPW7g2enl2bvXL9Kk +5hWON+5qiRdXj88/urh6oRV2cY6fnp8++9Y+V3F65c7IzMa+5czGxvbfZtP+7632u/3vW+0fNjuv +nX7uIQTq83eqP51eXTzZhy18+RHdyenlPVyqj791/tOLU0xrH5/q/NZd4eiHly+6VH85TtVXf3Gk +fexqebnD+KOX8z4elJvuO6fPnz69OL1654Xn92qTkNfCD76/hfNQPOFn6i3+/vMXEL3XhkYeFh15 +KXf/q0ZEdreR/uQFprb5dPDsnRmLdl/RCwL4FisKdyjp776iF7iTFyvyB7GiPcj5T+6Qmp/eXDz7 +5Mn5sz1Y1eEy5fsanDaz5N1R9NB48ksJHq85bz5Eh9DLYfOBHfS75zcfn2NrXwE/Ok/mFZjI0aF/ +dOjvvOJXzKG/e7X8o0P/6NDfWtfRoX906B8d+keHvsz5vjv04c4/3d3CenTof/FJ3rlDnyRcuPSd +eWs/affoxD868V8RH86hGcOOTvzDtPvcFyf+7oa5xxcfffT86fnD66smc1ztccW2Xg== + + + vCu0/Pz88vL6s50XfImSSu2Bk7Pry328JOv37oyf784dnt981ETx95qwtYdotnzrzpSjPVnDnotc +vHRXa5QbdG+Z4L7rOxQ++CpEn7xqDOdoVfydg7Mq7sMJj6bFgzItxqNp8Wha/AKZ4GhaPJoW/zI1 +r7c+vjk/v3qrSUXnb7WlX3x8/dZPL64vz5+9dXP++K3rm9OrF0UvHG2Ody6/pd3NwueX7a/9LI7T +K3fGEsvuKzz9k4snz/epQd1fuGPz1bcuyBbzaK8q07/zVc6HNMBHImge8gVptOy1MTHZ18PG9PTT +87MmqN8cM2Ve3lbxyuOnnPHv/ezTpvjtY9/efvPOlrs759JJ72/O337zaIk6WqKOlqijJepoiTpa +onYSjI6WqKMl6u4WCrsTW6LELEUGqaMl6tAU7aMl6i/LEnV3otxX6fI/2tfGfN4Tpe0+GNhei7oz +9zXF/XUwpb3MGg8s/PVe1J7ZowrIsfbMq7+iA6k9s8eKjrVnXiXGvHeU6sEw5cuLZz84vXiRE+CA +OfJvrVvJkScf68Hde558rAd35MmvCE9+OVXr0Pjy/a0Ft7fk8Zrz5EOMs9gfiw/skI814G6ZyH2s +AWeD+frOSPzZxeN9/DHy+J1JQPss7ZPzvfwa/fm7WhxqvP3Df/SL//RvvqJ2bXeyqBO3x4nt3uYR +jx7Ekl5QnHBe0s92ZhGvGsV5gUZ4rPDy6ou4x2IoB2N8uv7oo6fnz168igPGxt0JyuM9eMbjO2Qa +9zJxYY9j2oMPPt6dEX5VpOL7dMUOmUi8HilPy0D73/3sk31CQ58++3yvFfPjd7VU2BDvczjKvSSQ +L5HqdNCZXcfErj3USGva/7tvunHcZ017K8d3pe/vs6g/2X1Rf3Lngs4Pri+O8b9fCdYc438P2KV5 +34Wtfdd3YJaeY4zRF57OMcboGGN0jDG6hwx5f5J+KMz4GPd75MkvdxyvGkt/Cc/NgZ3ySwUZvWrH +dN/D/Y6RYLdM5F5GgsX7Gwm2z9IOLRLsde1w+o9+/qt/+/fuUeybvX+xb/ss6Rj7dox9OwT96x53 +N7vnSuX9C+m7OX+8n1Pl0C7b/Qvtu94hWOwACci9DMg5Riy+sjTwo8vr68cSyPfh5enZT97aMOj6 +09Ozi2ef/655sI+sdUixffuVCT40ir/f6g6shN63gaKHfO3ueZzKbyBZHY6H7DUSH59+cvr4+rOH +XzVJOQRCeViq2r2IyXmd+lDvl0xx6D2CXo98mWMb6sPngMc21F8d83vV+E2698Xj/e6E90CLx79A +iThc1fdVqx5/j7ozHmWv+yd7vQ415e+lz+CYxPuC1b7GSbxHAe3wBbSjfHbM7t0Xce651+T+Z/fe +d0ns2N3nMAjJsbvPq5/le+zuc8zyfUUY87G7z8Fy5NciIPte8ORj5Y1XnycfK28cefIrwpNfj+4+ +95Yv3/ds/2Phjd8wCvigTvtYgOO+HtJXOplDxpaPbk7Pnp1efu/6Yg/FmF/fFWf6x+5kgQ/M7j64 +D0+fnn/75vxvPD+/Otsjf3L12p3JwLsrKlfPn3y/HftPz/codDG/c1dLvLp+79nFs7MXeEkXqWx4 +/EcXl/usdPHSXS31R89vPnx+2TBq92t5aMLja9A2Z9dTfLWZxJPTNtzudXQOiT3YjZH/3ParQ3Ze +O/3cg9bo83e1/u+0t5++OCLwgKnMSxDSAyMylND37g539NWmMq9HMaDXItH0NeDs96V6zvdfn/Tn +k901wUMpn/PbssrdzXkdC868smTjnsdw/gZU8XC8U3BuYImQkO8t0d9fwTkwQeReRI3YB3vksR2w +9D9fud1zWw/tzr0UYTmwa3df5H+c1fsfnd98++Lm/tqAXhkm8Kqd/rPTD/fYlEMy7LrN7u4w2oW/ +uqfldvHSHROjbz+/OvvhIVOh+4uHD/LGbF4vTPzOERNfSUy0rxtJfOdVCBEi/QxVCX50c3r19KM9 ++uS8grfjnpt9XjbN5JAsPrzGey3uv5ROc2D6570w+1D45NuXl78NTDxE9ewl7+uBofJhR/R+RRO5 +ly319mmAdWAt9cKxpd4XovGPD7Sl3r//j3/xL36+O9V95Vvq7YOjB9JSL+6+oteio97ji8vTPapf +HqKSdn8DlPYIMjiQutS/pUDAO/JZ7+HBPX188XwPFqjP37Vkfn3z6SfXl9cf784NXkEt8zWgifc3 +fmePAIIDoYlHSnikhHd1mfbtYXI4dGKfYOEDCe7e47QOhfbd23Cww4/ovveVAMweXOqwKwHsHkt7 +LATw5THDr0AhgHscJ7zH0g6Gwe3Bsw+Lw92PUgb7oNzBhHV8+IIqjYdMInZf2pFE3NmSdj+kHaLw +Fxz4bttOvb27u+zhJ6dXV+eX751fnp/tZTzcfvOuVvuCCPLZlfbSq91+847Z2rcunn56eXp2/uT8 +6tm7p58eMm+7x2V6RimezdZPu/i58/IPrVLPh7sbuA6Oye++tINh8nvILYelB9yTakN7dOo74Hzj +D3c3BR0c0dh9aQdDNPagg69HfupHN+fnf7K7OfqjixfFkq/iDC/vUKR5gewxW6PPP97nvOXxu1rY +7vRyWmKfw/doIbsudfXaXS356vpqdyQ9PTt7/uT5i0NSFuuc3rmrRcbdEfbxHjUR+OG7WtTNOWl/ +ux/e48cXzy5+us/R9Tfuao27izof3Vw/2YN+0tN3ho67K7rXe6i513e3otPLz04/3/2SNQHs2enN +fhIbv3BXC7y8uDo/3b3H+dnp5dm713ukBU1v3KmSdHp18WQf8v47X9VE7k+ZmrN7HLlU7l3k0h6n +dTC62V2rZsfIpS9WEu995NKxicn2Qo+xS6987NLZ/Y1d2mNph8Li9uHah8Xj7kfs0j4odzCxS2f3 +N3Zpj6UdScSdLWl37esYu7Re4jF26U7Z2jF26SC0ty8PWHodYpfO7m/s0h5LOxgmf4xderWJ5esR +u3R2f2OX9ljawRCNO49dOiAX2iGGYu2Ds4d1wC9Vf/JVO559wiGPx/NbP5572wfzWLz1loncx+Kt +b3/3g1//7Z//+r/9fz/Y06y5o9RyiDzxNags9rIl8Q/D+LuH8+F1qlt1JIsvQRbTkSweyeL9IIu7 +o/KRLB7J4m0Y9JqWjP+LP/8/fvGf/s0He4a/3mNWsHvIyiGbqj98oWnwgI3Vv6Ua3vfMxHs3VPfl +29YfGlbew3Kv+xCRQ5Ek9zimPfpzPN69QcdXRTL+UtMmDpGz/wa05sC4w71wQPzWFNaDO6mjM+Lw +1Mu92q0dWCc5f+wk94VofNhmgT1Thl7lcJ8Tu0fntQPpJbfPkl6LZnK7m4GPxptXVE0+Gm8ORkJ/ +jYw396/ixb003uxxTEfjzUFx9qPx5qBYw9F4czTe3B/jzetqBPjH/+iXf+vvHSMD9Czvf9WmY9Gm +rYUeizZ9uUHkWLTpFVnaweRd3nnRpleNsdycP7l+UYHmA60ZvwebONZW33mdx9rqX9VFvP+11fcR +8g6purp5kHcXyo/11VW6eZ3qq9/JEi+uHp9/dNF0+d3JSiND56fPvrUP2Zxe2VEI+mrMP69QIfn7 +UULzRSLwvchK29eefzClQvepf3pQpu+H108+vX76QqJ2tDj/BtbX/+3PfvkP//df/vyf/+r/+u8+ +2LNm2z22wu6+E39JIT6HGClyvGkvfdN21yLu+03bfSeON+3VuGlff/u71nzwe1eP+40jWATog+9d +X/2gjfKsDXRyIvB30Hhx/pc3vva9T3mcwP/43udPPry+bFP6xZ/+r7/+n/7mL3/+57/++Z9t/vqb +v/gH//RXf//nm7r5xd/9O7/607/z17/xjTfM5u03vmY273/2xteeYwPe/hR/WqkW+/7n+Ov3268/ +brDPNtZs3t384R+ZzeP24vs/bC8Ys6n1Qa01bp688bWT+e9H8jf91yN+dv49PXeFz3wf3+f/vPmH +v/x7//FXf/p328x/9T//h1//6f/5R9/AbJ62EXNtg9hCX6uWf1/qb2/oNz0z/27PtK989IIPPLD8 +iZTHJ/T19bD0zPx7x084/kSM4xP6+npYemb+veMnPH8i+PEJfX09LD0z/97xE4E/4e34hL6+Htbb +1e8dPxH5E3Y6bj8d9zysravfO34iCUaNL9jptOdR8/LnjuNnGn866emgx4hx8WvHoQsNbcfUxwGP +8Wxe/txx7Epju7Hxdsx7GtLV5c8+uiEioiTkJ9jK9hguKG1xew6/L/V3u1WX+sz8uz2j4/3whZTh +vfZYQ5nP3vhNvtVW/Vee70yJLH3N+QfZhIaMJT5IJgf+boOmilsAqMeXCVRsYlDIUUDJy7uxuM2Z +vhtKYGjSV50AMqFlg8TqygDpmzGWtH7QByeDJYE4G8c8+qsmy4DeyVf5qVhLWvwdShlvEShEeSPU +SgCvCwyVB3U1jVmGmnnVzhFCESgxyJbxqoLqtDcDGonM0MwDf9U6GS1a2QZrahhz9Y53ogH1wZj5 +QVOqLrrmPED9SGJ2qwdTjXzCDYVkr7MNslz80HfbUfCILngnD7rE33UNaRRUeDNdzn68GyIvt52i +fDeXIqDaFkegEgWzQvBjvdXyZBo2yXNVNz4axqzQ1uMHhN8MbaJx/RydKH2hOIaEbHlZ3hvbX43Z +etkCxsDwINnKo5m23QtQaDNPob/boXQbZDjjCRSqTCQk2k3MqNb+qs+OX3XJyTdcoONuPwxxCyw2 +ywcIpO8aF8PiwbZR2fFHdBXYTYHg6HSLS7I8PReMHG0xNclMvB5tJARtoBrGLcje8me90ZvZlsbD +eVdlJikmAcUyjja1/2JoqXo5i+G1BdMvRvJxgMY1CG79oKFr2oarod8+2T3frkO/fFk2wccsKBWS +5bV5vwUxeexUh7pi5auhb3J0Vb8a5IBwG/qMbZItJVLLFzfwu7YTunYUvCe2zW7sVJVdNiXqLU0y +nAl6l0uIPJxxabpAzvCcjXGCy/yr4CpZQVFTTRmgjpCWkGp+MMoBmcw70PA8pLhebniQq6CLL0Vw +uaTMpxHpYwtQaTjQ3xUo6FTYyGieqaMr1epng17mOmYcqlx6Ri5ahBHymKoPS3pBkHGDfFg815ad +HH82dYLeKKdyMTOuQfFJHiQSSweUdTgflOgtmOwZCQZ/5cdDV+liRmPrnfUri8fvJll3dj//bs+8 +tJjxct96KTEjCJfJjrfiyWL3Mi5EIwSXCm03iqGdWxUDlpj1mjAjASsFyNWJLBHZAjQoLcjeRAZF +51WWyRNoXHJfB1RnE3xcvx6sl08HL/SLuRnNpozZ+EKbi2kr2QBB4rXluoJgD/qbCnTK/XxJAjJC +RYLBXjRIE2mmVTjHq2ACRaDIswgpq5hAnFFBnVK56ge0bwDR0nZ0zvlxSCHdAjMmDCjPOlYBWZWy +fAARAGiwsQZ1YJUNaqvRFRMvAkg5zIDMZ96h7X9lxU1q5c+arIdGFB6Q6Ad99dFFhg== + + + +mL1OGQw2gxeVvQD1DGtDljH3ODL6uUCPr/8QqlZPtokvUneyQxMUYmQywKqvqxAiw0Y0BSV3cs+ +ldrJl5MTM27seslApsXxyO2bDzGTVKKgvgFE1NY4wHJBxo1oR3CpJFY+Q8S5A60gUcxRuZH3/PEY +kvKsKOhCAnCn2XSugFqW7xuJMT4KyAjjsUEWTSB91+aaVw86uxrM8TLwVT++6kJdzc6lrGtIsgZX +BJNpsV2yjEKYFvsSc9naw8D3eRvqfVocDASeFOX4Qpd05b6ZmZ3Hjg/MzsK4hTYZtwa5WTZVqGIh +hjNpgav4rLVrnFYRYEL+tgoXllcEoniN6/sFWcBPt043oaPxeL1fnP6NxsbT+q43KMQFpgkqwdSo +S1PRXiGLLejAJPteSY2YiFUDubRF1RrUJL+4XyrjLI5RuNvifjXRB5rUFhZkX7ZodIOSIraGFiuc +Twl/A4WQF9wBExJ2O7GRBi2uzOymb/3gSTNo8K4ZKjwOownzUkaIz1bl37MEGENcsFZIiG7Bf7Ff +soiJffe7tGDfDeqzXb3OGvckI+DGOWXf07mHWBdCR2ANdRZNcC3tLXuwlHceTRIfy3xd4mv70qUw +lbbwuwkdXfKaf7dnXlrie7lvvaRhqWCnkmnY63IX+Fg8UyiDbCkMsiouJ5hMCDTzqlQMvzuYWkpg +rgClLcgsh3WoKUX1LR3NkJq5+CxpVsP+IfMzPlnViJOAXFE2b1MYoI5AaX6wo6Sbn2VQAiZOH2mg +EteTabqPAbJNsw6i70xrm0B2vloDmvRVHU13FF/d2nnMzsTFETWQjWlxkLgb2Q/QgmUq8HIFTDlM +NIzkiWTbtQt2QB041haUiIJCmSiQAAmQ0g1iXADkNBEnEkgBrcr3mBI1EC9qCZrZ2YCKNq5cqoGS +VU7AJBYgN7Ti4uTVRCIJUzGZHxtMmYxj8go6W28MQXULfDXpFqgHyV0M6o2T+XSS6opzMsUJQVyK +MmJXoV2MVVaspHyA5q0Z0L6HjgwVi51mJX59JN66uDg5FlcWpxusmQ58EOh0C8pYx6hJR93l0qLo +MR5VBXQLWmJefF+NKX2ODRBMWC8FdgN9rKpFrRLvnXZmBi0UgA7tRKqS2YlORK0LlTgQQN7MGkBZ +nvG0CMUEiPbWr9FLFeklIsH6VsI2lExOizFD9Hb1ZdaYCbsmJSVYAXYNnvWqCblm0LwzA9q3UEcb ++9y/ujiQPj09t1BXlKMtNcS6xq1pAxa4Zcj8CNIFe88WdKJyKw44RAC7NvrEONiysl/8Dn6w4vl3 +jC8vArzct17S6NN0IwxdZ99Sg0IUBFBcSzCYw5QLUFD1JMEKSqDhWmpQBy0DUDXsx6qjZTXYR1JK +FNR5mLd+/aDR6alczwZcnUinMgXsj2bsVOgj6bmB1L00g4aHaYKG2F+1DPG61pANQyY3k3oKABU3 +E0CFJzzUuAGq0z4NqLiZ8JHMi7CdX5NpF5DhZlLhuEHVzYStM7x1pgu97NhQ0DieWlcPJtli9TIF +sb1hXcPL1KDV8aGplwmgyvNTLxM4oUx58jI1qM38EfUyqT4EkHiZwIEDvzt5maCrgIsCWlSpqbrx +6j5S14+C+F34iOS740Efshy3OJpgpRbknhxNcEP6KrvA6AhPpeXh1NHUQWV2NE1QdTTRcAQRlwC+ +SvtZZj8TpoczbVD1M4mvj0DiPoqswndQV2Xr8jlowZG/OpxlhRw6ALlZ5vI8F3UzQX6DAEIT8Xq2 +JOgBNNxMKvtgHUYvKQvzALnuEoAYQ6A4yU0kQQMoXiYYYRyvX51HQO5kB2jcglRWD7KKiOFq1xqT +7N3wMgU979K9TFARA++K91uQ4WWaoOplwmi6x1GdOKxU0B6XmUhVedCozNQWyyA7SB4JrgANLxN2 +VDbZdLk2exnOdNdlIZsqQC7NF8jznIeXqWZw6ZC78yiKuqKgfoHIF7x4sOkQMpwYaaL4VZfrje2G +Z9lBcTPFhmaCoupmmkCTm6lDq7qZojjVcB3FzRRF5KKrXMeU2ZICXiAychR7H0DiPproxcLPVMn5 +Pz0IS1UU1tIpesnK44afKYhflvhh1jsUdDivWtmS4Q4/E5g3Sz9OMHbhhmHiDEI2u2Es73ud3DCm +6iy6EGdyllnMwp4hBycxUnXDGLIa0Qp459yDWuwE4ndd0651i4cdx0nMweJ1ZZsqebq2sUYGHHpN +g+aoZ2blVWVLKnlOkGHFmYBi8cJYWTmB1W9mLxykTIuwQt/VztZAwljVGOdEA1SQvsqKrEL7+knj +pVvQrYHYK1+3oew1ViiDoldaHeXrLH8tyTyM1kK+1LTZQGRYByilNWQc+gRVPwxAVWhG1lNrnIen +PBlnnZwhoGLFdSInlm7pdSoRlKUjxnSyNHlirBdEH54Ym01dfKKBdKMWnhhn9cHuinFkBKKlqSum +gxaumAFVi5QzvIxhtbJF1rowb1klwsMVYwflU92KNq2DdPcqOb+XaOAlMoSEoEmFI/ZK0oOdvJye +TNCgneKLgUcu8G6rt8MP+WHyxTRoSvKg1Vgr5pEE0gihdsATaMRkyF6MB6MRnB7DRefk3eGN8V3o +GfPjADJaRZJVNCbsxnK730vltMXWFArDWW9jzspZF9AurvSzEcm2zJZMZdXDGwOzc5Tb04MLkqKr +emNm0IxfHToQkUnsAl3bgdhtvE7FLe+YGjcX14TDF5aXLIgisbxlDVrkTIc3Zlye7o5ph5fWNz6I +oD9xejEL0trUHaOQhTumA1Ui5FipiWbhm3LtFjKsM8Yt7lhbQrLLOwZHopuOdngc7RYaQPN3bk2s +w2B/C6g1IS44ANwEJS/YBHY6bfET+CyVFak7Rva+Tu6YAVq4Ijq02/CscrHhjrEUy7lknXCglrDg +sWJdm/hwkONasvF+meoymqK4Yhevw5EuyuoUspGT8vE5toNE4IX00XA1rGSU7FQPn+MploLPo0UE +zsIf09C8G0jUEILf3g6jyPy7PfPSxpiX+9ZLGWOiuMd9mkU/lSt9nkU/RF0BUwDtinwmlaSBhjOs +iVWFQfPtbARdHuzetUwqI0AdZxLROQUNBQioqtDu+DbFrV73ZNykj3RfOOEbzWZCYE/+RJq2YroP +uuR+HwZovjgD2m8Yh7MApNeQwkUaYHFbfY381XGtgzc843H52e+toKF6ugHsW0CaZju8VUQA7uIa +6iGPKpAhoLSAdKrnrSDDkjxWfnMio6SnA9RpbYcsSLJCVfTDYJYhecTjJZ7ugg94ijcBtDOMxuPk +wc5WmoZdB6jjGpkxFDrc3qAei9cLxfksPsKhLzSb2cVDtgJAe2hDpagmWpsGQHTQMkygQ9XBVkg3 +BaQ72NjbTjs/edgKWa4WRyR3cD7H7GMYoK69E2tYYwEbThoeLeJNKolb7dlFIE4tgjIq/DUN1kT+ +ugpXUcIkARrCX4OGIA+KtNZAJHwRyIhqbm2cQPqupfu8fLAISo/h2KBB3/WT7YCsoosJsnmJlpFk +GWw10fV2Axo5YJd706AUaLTcRyj8pt4CpbiO6XBik4IF4VX6g7ktZTnryerBcjUhBYt/cVxHFf9m +kJsNeApVXMRwcrsVY/FdX9aojQlav7gDiMHPcXFTkAzh7PqiwWISp+unu9Bxebw+7k//SDXZra99 +gzorI3ZDT2USmbr8N4EWuzCgSTaf3XMT6WozIcvvksQ1aC51cdHUGrQ4S2F2i4vWoHEbETKJu0ty +3aBk6NuCkgo/sYD2bZvDglFgOsJ7J47SoFE4ijCevvmDO82gwcZmqPC7KE7wiSs2ULDKzGdLmct2 +wWejBN9M3DhKpNKSmff7tGDmUYL1F6+za2KSGICFUZn5dO4cajPJIA1klZd3yzdZbNebsJR+Hm1b +xqybTlcNYyzHT6jRQFZYzjCk1OrcGtMaNAuBGoaUqrSkG1IGZDakdKj6UabRTOI9mj5LEZLdGqLz +MxT4xKsQwjbZQqyZWOQQsPP04BDZjV+9XmBmX36kX6zFbAoLQmPaXkLipsVNoGVUa4dq+G8fbcQI +K+daxBJzQtF0RprXsjjJHKxbX3IxKixv+QCSJVGBVRCZcLVrfpSdtgUlI4RCCWStoCkzGFYG5QrS +hRiat5cHeyoG62pA8S6WDVCcgm8GtGjAKivyC4GYldC15GydWV79IC7BhSBuyOKyvPpjaxaqXyoh +3QIl1800JnLYfFnQAy8cfUkPYO5JS3rgRRqgFWsQxQCNrZmhHb04nW7aaU1LWh6JF0PndHZq05lO +2A8JjEDjjq3RA8EMfGVLMsMYtcSZYddUfrOAUkTz4usshSzm6EhZXi/GCXcYi3bJ5tXWDNC8hwPa +r7IIXDiSosN55Q5+NrKSmr445L6KgQqWvCxr9GKfwxKTXNu9+dluIa9L3RF2+M7TlJSyc4GmaAYZ +zkaXwi4XNUBP2DWDxs7M0E7qdTTd5+mr03lM09ODg+1/RT6cCi0L5Jq2YIEdnmwuIF/wF29BF5Ru +wQbnmJVV2KqfcpT9lKNsp7zk+bf/DfKhX+5bv1HMiou3xKy4uBWz4uJWzIqLt8WsuLiOWXFxK2bF +xdtiVpYPGp3eMmbFxdtiVlzcillxcStmxcXbYlZcXMesuLiOWYGGVacAEI5ZcSM1WkNRXNyKWXHx +tpgVF7diVlxcx6yQQjlHflPMiotbMSsubsWsuHhbzMriwSRbvI5ZoWiJuI5ZcXErZsXFrZgVF2+L +WXFxK2bFxa2YFRdvi1lxcStmxcWtmBUXb4tZWTzIMSsubsWsuHhbzIqLWzErLm7FrLhwW8yKC+uY +FRfWMSsu3Baz4sJWzIoLWzErClrErEzPacyKC1sxK26RGy0xKy5sxay4sBWz4sJtMSvd4MUoRVgW +tmJWXLglZsWFrZgVF7ZiVhS0jFlZPMgxK90gOSyJLtwSs+LCVsyKC+uYFRdui1lxYStmxYWtmBW3 +ShXmmBUXtmJWIH7mHmpOQSku3Baz4sJWzIoLWzErLtwWs+LCVsyK81sxK87fFrOyeJB9mC5sxaws +16sxKy5sxay4sBWz4sJtMSsurmNWXNyKWXHxtpgVF7diVlzcillx8baYFRe3YlZc3IpZcfG2mBUX +t2JWXNyKWXFbudFLzZy2ckszV+jJ0Hzpai818yVVUF0aCLXSzEljSmvItmbuNG1+MdpaM3fhNs0c +0JVmTui51MwVtNTMFbrUzBevs2a++Ahr5uvZsC49TVsV7mlxE+gWzXzs1jTaSjNfbr1q5tMZqWa+ +OEnWzBW00MwVeLkCEhYtNHO1Ii018y1oVg670sxd3NLM1VS11MwBXWnmYG4rzZzsYVuaOaArzZyu +6VIzB2hbMyeJb6mZ01VbauYKOlttzS2a+RaUGVTc0szpy0vNnKa4pZnTWpaaOa14qZkvt2aGrjTz +aadVM18eiWrm09mpZj6dsGrmCpo18yV6iGYOUratma8fZWlxC5prXn1dpJe4pZmvFw== + + + Q5r5YtGscC+2ZoC2NXPa7KVmTkey1MxVrVlq5otD7qtYa+Zr9GLNfIlJqpauoVlE5bVmPn1ZdWSa +4loz7/xuKNwTds2gbc182sIx2lozX57HNL21Zj4drxuM+hbNfI0drIOrVLwF3dbMFbjMJllo5nYq +62Gnsh5zJY+F3vzSevnLfOklgxdSIJXIz1o5cIKEZN/VclChzJCgvrXEApOftfIolMx61cobJBEP +9ZyUyCD2YQmov0rxaYsH2ZNPo4mXhAVenUiXxKKXAUUrjyIsW9+18hk0tPIJGmJ/lUsVqlYuaiIg +k1auehWgopUDZBk0fJADVKd9GlDRyrEI0oi8auVRCqdYP2vl6taxvmvl2Dquu9eVbdECFaKvJorA +WjyXguGzVq08SgwJ1jW0ckD5VVXKu/XEd6UcIDn+SSmPEj6MDQ16POzJs74r5Q1UEw83KeVREkEB +JcGHnJK676prJ8349bNS3t0Z84NcDoU+wtQ6MS/CTIZOnpSK+a7PJsklxuaJTt5BbtbJJ6jq5Kkn +2KlSnjjRrgEmnbzNzrKa2HXy4czuunaSiG/rlh7YmvkQJuW98u2d7ApMLgEaOjlcj3y9ulIepTgZ +zcTL2WbD/zgr5VHUDCzE6B3VVNyulEfJiAZoKOVRxA9ARStHCAE727uyDeQuZYDGLeDIj+lB5RVd +K4dnM+s2Dxc5H7jrSjl8m8zvVCmfIUMpn6CqlGMw2WPRyfFNmdlCR+VKZ3Q8QTaFn7KDLEamVLNC +DmLMkT9dIYdzXMYy3caTeadnfRynzfEaXR+PUmHD2q5mJ02Nt7M+nvROzw+GkBh5VB9PYn5arjU1 +hi6Yovp4elCIzTaQ6uMTaNLHO9SrPp7E/ICrKPp4UunLM83UV0OQ6676eNJT8V3NnkjFpI+3fSEr +6fQg4isKk8HUaTnXISIWZcYVYAOW9V0fjxL/a33Xx9esdksfDxI0Yt0ykJAd7NYvAwkN77ufKr9J +PJiXTAM77DWr6huGTEF2LuXFFSDtXIurchrvqpQX1/xSaNdoSPZbvJ5IsrVzKS+uampXpbwk43ku +5dVZ0shfHqA5+HRAezWvFDvJt/rZKmxlruaVirAzNjLR2pwwglHOi2O2FdQ3QfBxUc0rxyj3exnN +rpR1hrKNzc6loJKQzKG/JxMmwt+VOFFrJ4OARmUNq8GALHRHhY5yXsKfpmpeyRieyKKcV7L6ao9w +FxlxLsml3pRlLKGJaXpwxGwLpxuxhFYwZYoltLpRi1hCzvOwc5kkTjixczGlDlrEEg6oxhKyDmbd +FEvIoeLWLWMJrRLiEUtoBvnrFgOKgbNuaWOpglJLPKhyPRehhFz5yq5qeinDmWp6uSqoELtZtssP +i5pe3hd5sJfh8kkY2SjVFUydQMOCLVsxPZjlQMdwXCTSrqp6daFnTJA9b3Yu66VxhsuyXkXltMXe +cAkQuy7dFN0twC6t9KMRuXau6iUUZFXWSzX5ybeWFF85r2EJmhGsQwcmqjY94auyhSVipxj96gak +jtj9nrCtd3nNuitvGUhoo5zpCCQcl6cHEpJisrrzsWP5ZH1XPWcKJOygRSDhgKpMqFs+BRJa4bRL +MbbtVV3cMvgL/fKWIRR2PnN915AjbYkJCLkNdU2v4+CCS2gWRjhCCS3zpcEpIpf/WbGUBlUG30MJ +Zfv9FEo4QIsoug7toYQ2miVfjCwWrhgoJmOFrfZQQsMq7+DHcLp0bX2+ZXyfVqW9OH1yeh0106zw +/ZF8ILu6TFKglKSFEMJqySypcIns5R6sxZ+tSEI3JO3hr3DiZJ1ww0ldngmDIK4rusz+CpdCWuAk +pHjBoG7EGpDZX9Ghw1/RRxv+iv7ZyUMwzU9dCU4Ci6d76qQI6fKWq2Njec3Vt7HgxVYKyUz+CpuE +DSz8FU1QjYtpw1ChVKP7KzpoIVEMqEoefbQhnliVgGYxxgYVbrq8wznQC6HIKLdYJGVyzPTylk/Q +hceCvYqkKMzmQSvYvIQyT/STSVl0Sy1hSyBKeCJyMJmUhU36yabcbVLDpjxAs015QIvmW3LJr4VQ +HKgS0Vp65oq5CzHblzzdaQaRd2gty/e9WViPq1qXllAnpp5hVObSgxNJcKpvLmhCg4a6pAlqy6Ul +q1V5gGar8oD2C1miCP3DrFyUlM9W5VJVwpezc+JhnU4YLsUwIUi/ZmGNHsg8J/SaPBZuhTIKDRQ0 +vwXNYkIdH+fmCospCqdYrSUGZWF9zVzqfLEzAzRv4YB2UsWFmehEig7XlcLhsoCE59Zn3JcxMIHL +SC3RCxYXcwt6cWrKGto17T6mMr/+XWPVFDwcFjBO6EJYxLLiI55QawaNfZmhsoFjtLHL/auL41D0 +6Kc2xIZ+tpYt0X7prujLX6BGlzcnd8UEXdC5BRd8tKh/iVDCUfF8KkLeXQiIO0BhL3UerP8++Q2K +YP4GH3zJkEImfoa2wvtuMWETbwcPvQpCUQczjKoRc/1FDfmiy4tCjRY4NXROUBMzaQSWql8YUgh0 +vA5zdZlkzOCmEvS3S6TxTOpReWy3NVAJ8hQNx+wQFSy5nC3BYuUBXXVV1LK2lDjBukRGxqkOHrl8 +Nq5HKD6uP8T5fYY0Azul1RHdM7AbOPXHl8zTrD0eUyCrzVDotG063NhcriOwdQrFW7s+r1x5L+Zz +5QzaDut7QUrIFmYkXuNtUFSpg7R0uRhhC0reSoXyTNn0DRrRuzVQNwmqoxeneDjmmVRwz0/7xkX5 +VhCi0ouNRJG/oCFtvI8W1UFU9+QDtFQdZHrVM5Br+w18sESBdWPZrCmgLqYTmim0Xy5CyMXrIsYR +CV9gONUvLLM5J/KItpfw5AtDFRt19zposQcdOsJCGIeIhmudBDaXEw0fC3GUT704IUeJZItzFNFJ +QN0qwmLXCg2UHpVKKnqPJmIla/Gwl1SxLSiFoK6h1fu0mBcMSqksZu8l2xTLhNrRzW8sY6A+o1UT +FdtlHkTZvRm02N0O5VAnHk4O2nZDcRU0mQ7Vqxg5Th8WZTl9xRHpRbTEsM6PFxjmNSZ3flvCBQYa +e3XmLtAdsjNvVhrFPZiNjsszINMODOAQ4VkMR/MG7TATonVr9Op1wOcDirJ30zFyfPoSvbyWwV2h +F+f6Grg//VT12HgBO7FW01YT9SxcYoUQq3gifbkauNn1S1zJvIGNyKJkzY/EP7FoLZpCzoAVPdWT +WlFOz+W9Z4KMbbMMs1GDZIIR3msWbbG4tQeVTu6Yw0XwqcCyUT2sw2buMsCdDWFE5uiDWYlVcc3X +fL/BgwVqfZ2ZU3qJqV/xWkjYNW3xWs+xE8sB2OuBD4XeB45qywBEYYDd9J6ZZ5kwWubwLwgPHK5J +ngbDR2QKra37Kta7kWU28/5yEqxp6oyDf6ffYcNsOfC96dQo8Yxi4pr5bPVmHpqCWicRQGws4xZJ +0cOMzqwdJbaMEm2yQBoqmdtlMwq1MtSpKMQV6UWdWLLHr2mvIN0sGO8oyfrNZ5uwefcN6U4aQ29d +ql0M38PfdF8bcETocO9S/cdF39P271M/0/dkPBv9sjdqk3Hmh+YJrL4/f3719dXHt7+9/vRtX/6S +fbK0T7axemn5CiGcjlrL0KtnqMS4/CVP0a8zlvxVjqB/Uyohz/Ofcq04+qM/P/3yOqqf3XrTCHaz +9aX2/EPSN9q/pGnufAlzPyUeV82MeYkCFH3SV91rA2hoS8886avW61hGxPaG1Z/pef5TV01/jOf7 +L32KfqkJeDFC2Gx9qa96l3vgWKV7HY92TwX0ILHg2zuQRLtEBf3akxn5l9tppu1sTwg14QH6cYLm +LPBheYQzHi1RbIl//bjpuRkTlmgyY9ASuZaY1+cnd0QRhqab5tXOuLNCnXmTlme6PIYZF5ZossSh +vs/03Hyay6OesWCJIEvs6fPbkxC8Foe3x70/pHPe+6rPNK0PtNg9M3Zvfc3lsNMk2gDAB7XAG8eP +0Oj9rwXzmJ6hE9cxCDHS/IJXvFmikpk/oX8tOMn8jJ0HmVcxMZTlymwZgIkSdnFKqaH1cfVQWO9R +UMzJC7SoixXUeQUdQfozhCB9EPprsUtGsIkvS3/fL77h52/0eYxnwmKQsN6l/WSLI6J8KaLsK4nc +R5x6OUnllp24ZfudX22/W6pKg/nN4804to2CayzdRuQZzxfoI8ywI9c28q3xcxuFFyi+mPlgjcvF +pPXerDHzFsRcb/ECTbbRaI1p28i4QNbFeQlH7AiyjUBrHNtGwwWaLub+EnLQERVelkbdJ6x5Kalq +e/Hbuz3RpFtI0o/f+NrXP/jm2zfPvnVx9uzi+ur05vPN7wJmNt985/r6cvPm29+18QcXPzu//MH5 +zUfnZ8/e+/zJh9eXv3d1+uHl+U/OP//G5nfweNx887tXz+hp/4PTZ8/Ob65+eP7xxdNnN6cY9kef +f3ouT9qa2TLofFunNRyF0PYbnuZv/vD89PLd02c3Fz/Ds4vx6nuXF2fn752dXl5cffydm4vHf9C/ +bre//ns/+/T65tn83WlB/SFaxXeeXzw+fyqPvYX/euNrdfPmNzbv/7X2R3vcfPB7V4953QwIH7zT +FneloDd/9bf+l//yH/71L//ln7Vz+sYbZvM2DvP9z9742nP6/3bz9qeC2NpCvP3z5/jr99uvP24w +tn1t/vCPzOZxG+B9YIJ7YE1ie64xNbP8LMCELGBT6H8jXWPA4avnH2CNicLRnYJO1u+ebH+BOapA +9f3xQ//JjJ/tDZ1Dh22NcOuH3vkQO/Pmj6+uTp+cP958fHP6+OK8nWJw36ANqlrs2fT/fufjNj8a +Ax2KyQfXboFDgfB2Ffs/nBQbLH+xWIsCEmHz/pPFq3mHV03Jbf42bd45m9+1qN/SbtJOn33nCQVR +PHDZmUY1v/yddjVLTFVeKshxjC/6jpe2ke/svz7rCzfRxPooOuOdd15ftLPm3qEdAo9RlngfrIMr +xxb/IsxBXZEU//KwzrWH80QZX1csLIyEJy/EwhNFw5PbdhsRhaia03a78teXiHiiR/WCtxOSR0uh +s0JF+wfVOaqEsdM3GaNOKAe6vvgtRFkEO96qldzIL3jLIDrcrjARGYbtmF/4TcoD9Gvquevu6GWb +Efm5Bp0xyzfaO3LN+E+a5EO5re3LqM1DIUgK0/89oX+JdQA6Dj2Ep42BkchF2OgwBI+4TfqrPXyy +/teT9esnt37kZGsuJ1vTnVbDkqzdfIvXKKj/ZLqQ44pt37Xtq/JwupNJJ7C4We3umf7r4biQClq/ +fes3tqayda2n1TxcrG34hDle8kFanHP738dtUipOqij4LRH32ySsQVMCg0sSjW8/ijONoZvNH6yx +xkFM3Lz7xn0njk9pL1UofmNrE5swf9sODPAOe/D1D15yF9qLe+/D1z94yZ34+gdXxCfevrq+4rV/ +ocLmdtCBzFepA/3rf/UX/+xf/fLf/PO/+P/+yVoHmikiKUEff5kmFLoiZEkRAjHnpA== + + + +pIQyyFOVsMZs6V344lS3a6A/UgqFYUs6WtCTDjBsAFrkMxSDpdpEM+JAevvPaQ7TlTthOKp4SVJ +hXtms0G2SfiIWkkZaQPtnJtQxc1zAOHUHMNJSwnmDsukDd1DKUIKjDYjTjFTDQ9Lj7mCIgnpAUc3 +Jcqv5PeQLYyacQBWT0UIH3j5nhbiNEgHpKTKJJ2jHhK9oYgu+mKITYRzEuqaMmfTocIibLMJjRkd +vURVBRGDlA3mkjdUEBMPZcsVE1BQoiB+J1tu5M6EmNuU5cjF1BDPSbFqOaGiXdmgZAsF6+TKpqb2 +lqO+5jhXCk5q9Bq6Ex2rf2ASh5M6LkxWAqcS0LlSvctIj0nJDxJRHUE4H8g9qJxaSxBX+1ZSJ5BC +baojJI/M4Z6FqpAWyD2FK9DMX0QxVQrYKmiNiBi5DGJOeNOQjMoRFioFZ5dfrB1omkhPkWdW0gDb +RnDnGc1IOMmFkfIhY1mlNbYN5DpsFsnkCN7JyJalF5ErCjKSEU8W5UVcBIQTtuPxzkudCgqJy+ZB +J0xLvGakD0iqhfCWoZUUsiOFKJ0C2zwy8tOoMywddeEEGbRidUCQ0qYMO+BDeqtQP4y2O1SLJTiJ +Zy4Ibm3HHzQDblo0vk9lVnLhHOagrRAzWqhlGmY5Q544MJEbqAP9MpU+AKxSu3mUoE92k51MHIAU +3Ga81a5Du2BtrGwkX4NAbXpJOybjB8o+4B8yItUaICZhfVHa4OH1Nqnk+WU80xAoOalLhv1HrDYu +jJUSm6lyRcpkQMgCv1Ob7BLLA/5KE6ctXolF6l62KeCGR23o1P5GtbAIiR2on1C2wdMrICPAd4Cw +f4jdskwlajYOf1MwH1MNfgfhjsD/5BgWcQ8yv2SqJ4CjLmBYWA1O3qKsDHRlp8k5KVGQgIXOE4Ay +V7DQEGR2EXQ0gqq3Q4tS3zc2ao1SJxFNYtoQWBiS4/BK5uSKiIC/2EbND3LAZ6LjmjZtLCZx0XIg +J7/EaYbRIEUU43JYMtrMmnnnAh2knA9XwwmOG8kl1ITB1kVPigAOhtpa0ZfpO7hwFJLdPhBcI+M5 +SD+UdnTBe0LBXEmqRckyzyjnuUYAtjci+TJr5dYk2cEAWOQVpcC1RfgtTmxKVHSYhub0y4Qg9AV2 +y53gq0KN1riMXOWaOuBpbWdiphYoRnpTRi3yAKWLThtHzL1cLNf+IcLopT2JQ39wDBtJzOXxG9EM +m+0vyqVNEifcSCqVDMSl7QXreaMateAqMigZhL0gAPXmQkg7n28jpFxTGjXG0FwQI1PuMxKRm+q2 +2fqU7IVHnkdDPMuR5dgJtLBAEkGDZW2hg0ID0ZP0TiXcKaI/IqUxO+YrhQKlAfNUKL9yynhE5Cu1 +ykC/vEa+hIjgnYAw7IaV2J1CjXoN4zI2kD4NEgluSA2HmT6dBKTM8khcIjB4PjnqnEj9HZHS0O5v +yJx7Sm9lThujfs7A8yangAeHRgm5hWYlEhJQASlYfqdylayAyjb4EuaFuOyQ+DoCQFVf2mgGRJnw +QcrNBO2pE6V8eBuO81TabaTKDNybm7lkLEyrI5UoIqKRYyISZwt4GeQosBHgIJJc8FJKXEgzatMc +ELEml7S/fSEhynNWdKMn1CyHXmoXD8JboxNUEC5xteVGlHwg6hT4XuG6RyPvIMjeNFiQBGgMAqxs +M2gCkCcA9ZiCzISwbHrLMIfKJIYx4SMKAjmKrjNoFXA5I9/TBd0JqqoAZkWUIzFpyk4SeRsgolxq +pnaKjBSRG7FklB2nu5u5KWVG0yd8mgAGnhfmLfQS6kK13Wl3I8bCZDYgupyGoQN3/HSmQuTyKcMF +wNpbgbKNgCYInG5DM1Y09KAsgvlbIXFlfRIGqSsnuQExcqIum5H3bf4S8BiycEY5ZepHGhhZaWBP +16Pk1XeEbAwC4LkfGMgl9zsmv3z2dE/p6lZOQwaIeiQ3AhMaTQDt5i4+hcfKgftJy32nCmZEu+tm +/K2n1F9q3FDQlRqntdsMxmGkzRgC7jPVtGz7L8QIhLwWxjwCNZWh4RDTL584KbYBeks7WBTaoEEE +Rx9YwEroZ0HjJi49nKTmlH4I3Buknl7yXKUM3NpQheQiYoln5nHiEreHxhM56ktUejBJhn5bNJVr +i+je5saKlLwy0SXaCPkGn2rnChnTkBQCYQSlUYjGJRIZqLBYSKxVQYQQVgv5En0mwbea1BEkvwbY +aRrpXH9DyH1fAyrfVE73pOI2DMuWaidb1rLANrmSXOWWDVDSMksuJ85Qikqi8s+eDLSU15dQNJk6 +Q6w+JTMAwqMciyAgJtBwlb6HI2WtgASP7KQNIjieZ7EgValMWAxXv8G7uLoQj6FtEfv0JB1TigU4 +Y2YNDToClVaEIkI6dEZ2ViaygQNuH7So0ZSljBW9IwUogOdU8i6j+lqm2TU6XAhApdOJhlm+hRl1 +6D09RNo3rhJoBZZEzUFXuyB4kbg0GGR/luCBuLAzthlbJDIHSBb8N9VxAwcFt8LfTeEivDBcMC5D +5KibhpHoQtb+SqEh4OoT/F1HJs42akErEdJ5qLYL/BfCWTQ7pWC+UKMdS2gFaMcufScKa5GmAU64 +MKwKKK2x/gp/+zlJ9Vy+D5cANPDJDLMsIzxqsHbRKRcKKhDytWKncY6RfEixtuNcRFZPYVECUndE +PQQozHxj6G5y+UU8IdgdrZSnCYZl3Gi002OjXaEQxycuiieoZyK2Po1OS22iHtc4UuUQL2XmAaAe +6X4USwKM0mQRgVK8iCCJjfkg/0FbELjMNQjbpyBucW8kKBXt0qImH+wXdO2AWbZKqhzoGOvwzmjz +RcuVcZyVchke5UfbJ+lYqQlnZE2bz5ULPFHvw7YI4EbRFrxIJXO901ZlFQQm5qr0uj1Es+H6mO3T +pL5a2HuINhtScfCKlwIK2JymEGys5eI2ANBsKuWROSKrxRg63yp9s33lHiqQFhRxbCOlkVwaLBUW +TkpENwruxS4rCsSvg0iFwN0HVZrEZ7Q65X0ggYwfIiLvqOUfAygf0BLJCTRucUx0LbCPBM7A8huK +X1A5qgDLVdk4TdkFVivXg5eHLV4QicnkkbiQbvDMG2FfM1T5U9YlzgvukAnBAJvfZFqyw9ANITW4 +SsNivWtiJORqRQ2r2uZ5Mqtwln3bRRLMTiwawhsW7CG30HtVWrvA2+mp3LyMimn6Qr0CtBtCgNIo +H6TiVoalHumLAbWzsDBFKApXFJWdjNgLJm0AeunLHtVxFbntORlSUPyVjI96AGf6MSiTELGqtBzh +dGnaFezGmCVYg5TYwe3gXl5VCwxXdlVjo9oHLUGk5WR6oLUtqnAXL51XTqgES2axw0rtbkIYIHZR +GRu3m/q1Uy4h3xzHFfETqU6EMdSppbB9S3QoLmHnyDild0OKpBdaHa4797HwUE1UciE+6fBv9FAv +zAl7MhMxNoPaxB05RFaUmqaJFXxA2P5gi1RIVaXtxGa+6zRPp5m7oCyVCSd3brI4NcMqYuXyzRFO +uy4ES/HUQFYTum1cO7hISRdIRVy/a/pg1GrqmBcOL0JWywywEEwAcVySq40U5XvRiwphKxsoMJKU +364i2vQPOsM940Xv4yqNEJ8o6TNGrU3vuecJniHJlLtViWE1s6yHEwyerD1VSpw0lBAfZJWkbA+p +14p6ZaXqLM6XEBv6laMXK77s2D7FjZFqlxwBrKR+efDNwHZ1vn5tfK7b0hS7yi3NkMzNW0MWwcJA +rsIHuxt9EFQcuhjZ/8lIhMA7xyYrsptTojK5rzHlrgE6aHtkzvTcLtVhSFFVISXRctqJRcsWWGlW +VFGHyJKwyDXD5kuRq0gPIBDU4QpqF/NQkdC7BDZzVbI0c0MSLyp/kyO5sXU76siSpn4RgZ0o2kMv +ZknDB3JiHxpAaoFDsTN2SKQwT1NNLlmhoDzdUU/7UKmIZOOllnYke6khBi0mB6dbWqm4GWQOsrCR +LwKkqF2CRLXMYGylWpbg09nLIVZp3p1Q7phsakXIP6wJVKYQzhCgBayTTm5+itLmPKk/ouFfoQb2 +iZp+ODbysdNnmmnDb07ZBvZYw49xu2cOjQnDItIWbb1wTuj0PP1KxScsXSh2PVRKp2Y7I3OSSpU2 +vN5EyYo2bCPFY2yehq+LFHu9iPBFGEFT2Kq4ojyUKGI0XgtRW5HJOo0q1L+qG7+4ugS6lZOI2iBS +mfEBt6yW1yCUQPIS0k3qsEPF0cKGVnKoWBhmcDJBih4u3oJ4jThlynW3xBXIWGaIW4Byqy3B0Ibb +1M0WQHwYo6lVBIznjbdvAlHDya5SYWSvqdtV0PQc3jxyz0VRO60WwAIgc8AWyZJ6ADC8WjgDcS3w +8Sayb4i34GTUINpoZZO8xHQB6347JGiWhJhwvKDaGaQKaoQnDNCBeJikm0hYD3FXOpo61K1pn07a +GRj1H6yUaqPjsrIoz2YUkDPa5iKFPlymQhAYNJeYVPagqtq93ilIHqgh/oHMsZYUcQ+UcfJOZY8G +/okNwoW9ju0D0WM7XeauMFSnLzBDoIrbEKsh2lvu/kEk0ekNd9JUad4Ix4YYp4VZ8TCswxDpuS+U +pWoBG60/IiIOFVcmGYkllYq+Dfjb2DwEI8wJ5y9iH/lUSb6QMnlkv4cQZ/3kzvNw8QhpbTeI1GTv +2NEJqZNuHkI6TWa3IAlAABTZQZjUIEx5J/21M9xiTcUL0NowZXinyJgKsUdnaNnIHNhNzM5o+njh +thXdb4ibi3tNghtU5bZj7a42pltZEgLeYWiuMAFDYUN+YGpUT6znAlgBTDux45s8dxGuXIgnhRDC +sTnasymCepcZNo8z9UbTJQAavymGp0xzh4k09h2EMJ9ghZZSdqjsRKbbLPVLKdipUeZGP/r8aK4w +KEsF3YryK+TekQKzRIRhwQ1y7RFPhlIIsH25UJngwgWeEE8AlyXKNbUtSY5raxCH4Jo9ZPDJ5IBC ++af2I1GVfupBAHtQ7voKNXBodC1B7+DDtOS6h4XQ+7F1EBdCEivOA7iT/YYYGUiuCbADtj/Z/w6v +KhloDEdK0OWgJllkjOQCnSiXX8g+w1dMy9pMph+DWDm4ZXPg0ABHjpnArpQ2W/Xng4fDzAifWTsI +2GVglarw+FcqIwSRoX1vo4ec4dJMrL0aYjDk/m+XszzgCiUsdhTQ3YBMFrIts3ubJIU251xYirNU +rgSWmAwDlVYrhWXGiVpN9V0bgEraWicW1QLNsoIKUtWU+ROJeT0My0hbyNxaLouEDwKNQkLTGxCE +oZnnwvcUfyOuAivHJQClSrMxzqEIUTtirALhIRCv4PiGYQoHIC9MX3DszAOIXnAsJ1EwhdtQjVx6 +nTx0eAF913DGoLXtn8hKATtdIk6hL8DenujAIVsH8VkWotkwKAM3EawASy6hnbSoZSMM7SQckO3M +AlFjBwS37dxh7CFhEj4SUZmDdG+C/52sd/qAs23tMCVBmUSUS+DrC30UTj94rws5/w== + + + SQFNUhQfRg66zOPuwkAFi10DNXEI+hqGTmKJ8hC3jWejLMfI+MQ+rCR16xHs3LAVf9cAIt6Ybszz +Tfc8mQQ/QTskH3mn4FBqWgRsjETYIQ02uVO+QRoNRLrUxvbS0RHihW3zb39T9GKknpT0RhRLumPR +Cm2jIdxEWMvaxKGdoiQRWdYdxbiRvswuR+Y+cJ63cwAhhkggC8E/R9cXQv48WEMjLRUtBAJtUulH +DitFls1yXFcKIhayprzhxsqw0VXiZQVxJrA/srmfTBaGz7qRD7bTNXwLKMRU8Ce6pXjoIEzf0PcC ++rSnICOyokKNhZfDgRGjfUS7e9gffIkRnaUMWOcTMXgqWOelypCa57xnlyLb9OizkdEIwlPlBTvE +IBW2r06ijM0UqAQQNaXA31CdvQgKFqKaCXyw7BhHgBqUAWw7jGOB7XGeutZmDvDHKS0/gg7AHnEr +mYgGoiGw57i4fR2W956XTiowxCggp5O2NVSZztFWUCSHM+yu5FcgSgEAKhLYAQmS1lAYhhlYmPAn +h/FoRxnKCvQkCHn4advcyNmPL6NIafubWsswHQlo2Mr15AkPqW8NFXAHHlZGCUiZjSPSK5mMoI5l +cYiUvvDJ+YCPVzLWwBBj2cPgMnXagjEFIgENxUZf0igYq2DoSCweQskF57ORBU/ozzgNG5nBI6DB +EPOoSSzMlcmlJSfuhnyRSO/LXFZSreaw43pGKgRCwAWcJKaN+to3YbLNggwcXgw3VvjoGdEFrlbh +UADO0rUgUfeE5mNIhKtkvoGponC0A/QkKuNGwXuOqJrGSBSyPuinZg0WdA5LRsyhR/ljRCRQHf9M +HkXyobEmNOl2sL9y+xvLzoYApYEj7ok2BA5ZgURpRJEMnjUrsnXR1WfrspVy/UrnYS0gSZ/XRCo6 +GZlIWgxS6pmk/8BRElGEdA1RAC2jGoJOQt6iVfOLVBRGLBOpYDD0xR4TJSoB3ImwkXczLDQMeFYa +z6QWHI4iHumlKu1eqMQjYsZxoQtbHgOCxyAsBjEPOScCkRrdcInhS0S0ATU4huMCzuQkOE7G0cim +rS6bUq4seJNVb0LlJtlbPqOHkpTwLQhhBVJYp3cIqoEuZIgkBhg5KzFsELN2WyqXc5soaqN/dICg +wXCMwxfm6QmSf9Yf4G9Dt0O8h946eNEkFKuBMqgk/i5MXjIodaMU1IsUxY8js28yY5H4kxrd2VB3 +qDZhS26ntFl/hD/94yl6WcJ2Vb+hRUlZ38wllnERnGGTFlVQhpCQxRhM8Q/EvkxUbY+0DVAtwixQ +IdAKn4dhdvGth+JqZumXFA94aJ4wTJ3s0sjWUg8ZCi2r05SS5LmQ8A7HatsLwCi+hxprQYoy4l5b +f+phT1L4wmxfDR43m7PrJ59eP796vHn6yemn55sn14/Pl4Hhv/2kYQgH6G2CXHSKYLIN1RAmD6rg +IQ59xdnDX2nk/P/9T37x//z7W/KGpzQRyQHbSgnRuHlOCp9C5zmHGGUWHXWfYxGCw3dhnxIzeUWI +cCQXj/q0Gi9vt1Oa7CWWvc5IyyqZat9HTlQgucEySaS+DDDOs5kgslXgjFh/CpIrREHP7RMk8J54 +aoHiCRASrHXGGymSCpiDYPOAQRAgTELpAHDzSDIG824yzpyRENNocWZCYijjwzURFUIVVT+vEBrb +zSBFjrsIJKigsGlBuG3shCTuStIUexqxp9RRh/ZOql9yV0xPMHIGwQ6EIDbohNQFD3EmCPSDQyj3 +nkcILyWbIIc8UyFkw1KSWtjazpPcSBQQb8E5QJUcjDYVhGXNw9GapeJpEdeWoXC0kNVuQ1G6J1Bg +KKoVnnRu12TZpMieFMvHSZFs4hlsM2e3pXZXgj+D7UMchl9FZSeHV5U+eRCvyPuOzaSuX4QC4i+h +oL8tTDyjRJ/bCcmbUH5xCt/YfPO9dp+vPt68+c47b5+dPX/yw+tnRB3kxr35B9Mj74FgvXN5fvW4 +XdFPpuv75jtf+NR3v6XPvP3o0a1PNYpy9smPrt85/+j6ZkUJLaRrwx5FauHxhPMeKApYvYwI5jHi +CyFzIIRX3q34QKuywnxMfhJ49eh6kQOY3Y9N66TE37bvbNTKUhQZGEIFuwt8GKi3UcC74TNFcLcn +TouPbWAARKQ7364mTHvkY1CAUmPCTWUAceVYK3Ias7Ga/DpnpB41uYziIyioFfkutkkdVroWQaJF +51ybuCHhGZIaLbVRBE0hRUjE1bYrmeIcoKfCZ+Yt9zk5I1OWZdED2cKUYQDjLdaVmU+ekB3MkJye +0N5IbleCy9Z68e9i74hAINxYkkAhx+IBcUpDMUWcIWJvuCdSu0o0MFoQGUZlctlQteXikl4tT9cG +Uq6tGtIsbXvaReKwOOnzlDgc+Iyt0WSZPiFBhoitVaEXUjCCdArCjOVqZSm2HWE7JRgEnERRzokb +K3poHKCgayTkm4WME2pxBTMOfC5PIMcFbtBFoTUw7YjCgE9SGA/sa54AkdMDzshg5qTtBLWtAoJw +baUM80AEanLMG+gcWtAyalZPnsZG+lBT10qY0wlQEVuHvbRQ7trfUAfOSOFtRDQjRoVCSQnnQVwD +GwcCYrUjIzV9BbvpwXvQYiaScmZhywBVQ9lkhBAAb2xi2fwM7M+Q64uYXcLNiBYNjLGdDudHHTch +FkLDlS4bhcMSsG1UDV+PCgjPx2OQ3JCIwsN8dsaWZo9YYCiRpGg5CtgiX0wslhETwRXU2UhqlZPv +BTpj5TgKutGW8uOL5T7IbVMCNZtHnKfWwcLOAa2orXSRvGk+FKy4slQofT8Rm+pj93gU8mw4doeQ +vb4IYnLCRlZ/pqXD5NUFYak0GnVGAEukIBnPbQY2WyjImAmbAum0ZBjQssEIRw50n9rJ2Q2JBZYv +AyxiIDk0TwuTmNYogi4smZrw/TkEtQcOqqA8NNxOE9NYFDDTovkcmeOdQygR0AkqvSFEZKJp4O+F +sd8wBuDIQKrhNgdiUaRNJQpIRlVHjYjIQ0Y+8DMyARPTh00GQRhwzMD20hZESTuRTbk2c3cBvCEk +kXY0UTlsx5XViUhSwAREgUqYGLVvsYEmWbFWis+FBJJhNsKHmNCEmgk1qar7GatDpJwjpYx2mXbO +08XhmHy46pCOj9G1dKxn5STSrJhmJnL1GbpKVLsf5J5yRLDf2vQnSz9G4H9iLx+dYZc+TsiMR3XM +K3dUPOOQWu7ViQigBCcQQg2c0CtLfbxgPqyCm05L5aPbORPlwnZgHAXZBTwScihZfoWDjJrw05Nj +EkkvyAOimteI/dqww9PAHVwkETGyqcM6mQs1luTC7+T9jbz7pLo4inYIch2h88I6HIjsI8ovCGo6 +kqk9tR0m6bgxH9B4Q6YZi/C7NgeK0+V2LpYsWXClUM4IdEGEBQGtEM4B/ydiFGGCiMr/AwJ1qW0j +QlYR1FwIXajBJ0RpxNbazC5+vIII/0yGUIo3c5QBR7ybpg4izwZTw6EZwpYpEhH7xi1EsKcww0Vt +dUHNvNnv3HuxBY5JhqRKKWbYOF/JXsrt57BxvqFoERuGYCY5+lAtnxuJIlidmJaGqmVJbAXdgjlf +ELONSe67JmupKm0IM7GtkW1CjahF4tyjDzYCpCAcgCVR6maBOuHEJ4oMuBPq+0iFDjKr5YTSslHk +XAWxxNbSfbFcr34LAxkxwTxr4EimCMc4lfxq2r3nUB+DQAXy6lZCMVAUcmTyNmuPKlgnk0RLWjj6 +wIHY5+mQUUG+ZwquhBplBScpAYO6ZCB4G0hAula76bD0YnmgP8gpg3Z2Rv6yZEm6sijdT6gG6k52 +n0TW5opgOe0axq80uhYJf2FRqojwsxKKhDRXSK9Af8FiVvQMEWtuoI52FEjbAH3nbN3G0MhPWbmv +sPBkbA0CqLjXCMQU0hMzO5BtsuQSJM83vQGHGCi74awvYtouENdmVzVOqhS6gqGytkyyGKJbrVhr +yYXAV8dKd0JYg0HxwJVNlO4ZULhZoGc+Q0y75iLyKLFx3AyS8WEk0vaHCfbOTAhMGZkkOnNH0ayx +nHBFWMZt1SDQ4qNwDCc+AMGIsogso2Q7sy3MY4SEoFgyZ/mRSvlEPRyO6bvH+Uk0CzNtTze9Sdlp +w757EfoQ8uWTOLs9MTLOu8Y3IB+RWdDxlSJZktEShlgYhkgIAs+E5uM5RYiUF+RoSk42Y5iFvFwp +qUGcCwjlN+xhhdMHJJuYTXIyNUo2Qwwe6B30Nct4yHiNkLm2x1TSUERFCjkUsYLby0Qp/kCxipUJ +YcP6uCEeq1GycBpm8lxIdyDVtSD7Sgs56iuIKPCq6JxIWqzS/wI7Z7heTKb2RCQmIOaboxUEM2PT +wGAystK5pk0UUne7QaYkIZYNtamwhTHaByVJnYTK3VE4bLgS0TTEhJl5YxHEzqPE1OACRTY5kLvn +hAQ6I+Gp1vKHyelM9gOxRlDeNId1FLQtR3hB1gh5cjVsoaBgJjwjWdMFKje8yOyVIeUsOCoDk410 +laVkSeI7cjhQqYWKBQgbiF2DV5nEf0wTcg98ErghhmKDSdZ2gpgwRMMRjagXCERcM4G6jpEmUpHb +Q4YfK1hGQaAUuED4Z5DFRqFglWQAyrQhfp1U8G2fI5sA1Y9A763K4gHJ2ZgCJRWUrsJDjaXYEpJ2 +qUIAHMiBVpVHZ2Vm2BTiKRySXJCwu0sX4QcUV6iND4nZYC8oIq50apTb8jaF4qA4lYMykBHcQGFL +pFyB4XB3FsVMtmcjSorNVUUzXLRQBubDqdHIWu9XR3pZIWgkc5A994yFfugKi6o0AaKnTl/0rFtR +ECy1NIvcQY6+UxOnBxtL9QYwF8edKCFTVEHXhgh2g+tCJWNoL1mjW+KgoCZITmTljFrQPaHEEJKK +MDNyD1qvmIjIJLayiCkIRlLBzUYmfBILCeJGyAlcOdSUOpKyyoBJPoiClzCliumQgsAbckHTRpKW +lUpYhQLxFS0dIsogicGNRU4ZqP+evQ0wGVT24FOkChuJa6os28KMo2wb5SAciHWj4ohIUG7IElEE +icFWUtpHJZEyENH30kyThH8nRyjyV+P1lHrDGe1UCYMNv9IOMarltzbprSoyk/dbY+aIw0E1zpTo +xDYViiun4lGhE0xuGNuQKlOdByBT9pX5keOIfcqSOIEVN+QuOFD4KMkYiU4Y2W+VtR1LtvTueYIx +1Y0ySxrTTUCIrN0AzDVKcHuEKwDBAmuPznNVkMJuuIqcuMi3r+k8zEoW6MdYeaLxBWSjhRD7hIGV +EtXJX2AlT6BglXAYcNMr8g+w/ZF8srJua1JVDqYOgspWb2vUQ5BYUKDgHNVjc2HaIBGlsDepnRt0 +gNpd5cJHQJ0PgdiUnyowJB+Qm4CXTXE35CfwbGSnTG5WzjMHjnL1pdDrmnMsJzkKCkVWW0r6ZcUJ +SiPZ/GmbyFVQRIQDuoyNhP7OGg17CsCDI90sstQgSKqdDoIU2U8ARDUahkoklSPTKA== + + + u5G9BJ5cLsT4IqdnkNOAsY18BOxBzZ6yqjIbTgtXqyMPAYUcqc+A9eQEC8eGPQZF/AOeRBWphRTp +PfqU71p5RKUy9haobyAy0XPksk9cjQa+gmC65bRJ6Vi2JwOuOAZgTYjMj7aw8Es9BFBBmxZbXuwh +eIFd/+2Pnp3f7OdNePvF3oThKmWHndXClpvPtguafaFD9aX8ib/+83/wq//hb//qn/7LX/ynf3Gr +V3G/OsQ4b3VDBQTTPGEY5RsqjACwqxAelroAOInt7DCyxlWksP7/7L1pdyPZcSD6Pvsc/gfu+5IL +MgFwx8oN3MGtuBUIgCSKIAACYEntD+/I9siWLGvkmSd7JB1Z9ryxZ6SZI4/H42P7Wda8HzOqqu5P +7y+8GxE3t5sLEiS7XZLrdDebzLx5l7hx48YejkfWhxj9hH1rveb4xoMUnV7SH9GjHD2K80sSHmHH +Ec3q2P6APHqMJ8YUc45HxkfYq7FOY2Dj75QHfHIBSWbD5pjF2AQdHe2AYPIXCmZSjRPEYjJoGkBg +EZLMchEr8FsmhrA7gl0JQpJZiDAHFVCocc3kxoz3iXT6CC4zLarxj8DDCGwKHb9h8pUruXGYBcoq +qcUcyTk/ofLLobLyceKyxOfeCbWcOBzuG3ZpPhETYRdd+Y41Own+hJpPQ00jxW7y1ofixsd6De8Z +O5ZCjXnAU2BVYtx/aAoFbVAcyhgDKVt77puo+tO+veDtqIfPfs2JypTX0ZPAUsDEHPPoicmvDSVk +8Mc6eDRrupH8GtNhqUrIId35qCOY1jL4Y1Dke3wdcsImTSt6JKSGoCkjObErH7UdY9ju31tPbLtv +30rXMwtphb5yVkZo+xteCNf+uRYxcV6P68Yj+DseMxAcI+ztT3gwnfFImJrxLAImMLNn6FiN6732 +BWk8wNO2bnzEsR7sV8Yj6DfKsRxNa9bfxlk2HjmgYj7BVRi98mUKsEm5oCXkmTbOh2eW6QM3g+9O +oYz5eMGzMY3pg4X9xnzKXjtue2qtzvre65njayuhMaPN2kee1PiLP/vJ+7/728+/94eiHGVkM+6c +w9gQohRCRlDuQmD8PeUHggBh41HOeoQKIjB25myfej60fVyziXeQslRHnxE49DJmg78j3QyaWKZA +Z8fzZsN+YlzQVJTHJ05hMAfp/zVMfnpCzXQwvoCLCSXCBHU/BWpD6JhEviBUhh4iosAlPEXaYFmh +/Iw6uS2q3PUJwmJR6yLzevdgQFc17mitUGJS9PDlegYKPjey0blWkyLHcwOK6IAX1Tk946Hs01Rg +HGxg6IyE2eEOyQCJiweygQNCpGiMnqhkbpe5QwIUXUH/+xSaG3T+jEIr0G0GlfAKOoCisUgCe6kk +G9/EyUkfYu15wiDKECJhHgm117UEWhlmuwI6rgFkgIXETPF34NAvYaydBGp6iLhEJ38J3S4gUxwY +IUEiopny6udRDLGAuHgMVKXMmWQ/A4cdDOLMwaOITuHzmPYZOophbA86nqjorENKMkymanYUQzCA +QxlGyEAaBtC+gVEP42GimBMMWkD6IYoVcq0jZy7cC6FhF6m2BPi80NXFcJDySkAeAXS9ACCitg9s +vREMHlAppQt67Ms8xBOj/dCBCsJ/wU8DdGPgJoRuHoeUZB8xWOV2DLTkYUUMrhKVjbMEiWwiFMjP +8Ah17NgI0vOiuljnobm9rjXQXscwAg5t8RH0qcUdBc85SmuK3tM50vyhCjyK/msKhjChOwoEAIPR +xHAFQfsB58tQ/09+AGiHoch+OpsK6MvB0ELmHgyySXHfgSglysc1gmI+otHxRbP+IVmmdJ5HQpXJ +5xLzYJquxyceS7M2OaYRgw1eqwbRkigWimKBwBMNQCFhxLJObmro6wU+BUrMyMIPLBFkT6W0GHGe +4SoFH5rNJPKXBCCiPZdmGceQrDgmz0JwgMeBwgOZ0ZIdi/BUVjwKnkEepyeRlYrMPuhUOEX2BOJY +VZ3nXpXQskt+1pjc1L3Ck0C0B3sjD6ECG2yE4lnQCBkj30005E1h1kSFnOhIRw4qdcIFfdogLOBt +hEHWuBJdoxhyzG1OpmGMLItjwj58oqs8QQX4n3BrWUzGHEaA6TGe9wVTp0S4DpiyGmlG/nph+sEI +wPrCRP4wTNQsJ2KlOEI7JPirqjydTIQcZKejmHYU8Z6HKE+hyZ6cGuOYjCiH85GQ2E1hHBTZehSe +0ErmzI7K3aXx9gI3Y1qIsW8RSskIXijsEqBNwAQbbggUEXRuQLmBKcC8iA7BYC8l3MH8i5QJkwcr +YWJ01pgcP+J4xlMIQc2AIGZsz9EzyvqG7qgaf6ZQinlzEgLsO+BlnFu1yQ2VymJDKhoFD5eOyXK5 +1Im5CcCKq/D4EMq5g6EdPNAJCAzma5clHmuHxmsgyhAtG9do/ynpHBhLpIjJccSR4sqmbVvnDj+Q +oh38yw7J14zM+xo69lGWBxCqo5h3BoM5IEsf+nDEML435bXIYOwFOyllo2AbE4+asWdRSrWFxkWy +7WFagimFD35CbB5GuKIBHHdZ5gHHrFmUXNYg0TQ3m1N2BZqjToZs4xIkMQIfxDC03IfpcrFmLuZN +ZPGKNE/sPGL60WnT3BfY2GG4hYki6hGeggedZRHBzfopsWlOmxkEISGFG3qdOCGUQOAMg0e2mc08 +zu9nCa3ClFkpig4ZFC+pomNLBBNkSGglpHB1wAAZFUR44/LcKegVDGYwyjINoAX2U8KIGJUnERSn +EczJeE/b1XOOGGOMIgKqZti6KV5LwlSenLy7wOYFXdcOCNuEm6saNGBaQwbFzLcD7KnKTbwq5DMC +Jjgux8xASRlLG0FkOXflZhAGb1YZk03xM4i2bQlrbESpEoXxHaZqcEOGUAA5iihGbkWQi7s3nkng +1xAhLEW2IwJmxgjZ3q0HapRnfEAuByiUZpTmAHswmNchvxaeOp24GDwMPKsyiLfgOhA1HfXQgYH0 +vtxfNEohFZhiwtDxAbViYMf8T8gWABcTJz/BQw63GDRRKMMPei3o4EzDk3LKPB9SjMeipbjbrArJ +PThJwiXBfFVMGCeCKtWJYjkGuDd8JxyzEKYprAQRhxfSkVEu0MgBAotySTxUFuibAhEdMoWeG7oc +wEnAA0zoCdIScHFwFYP4wYGEYWjQE/lZxyi7bhwvOM0TSoHHT0MH6l6ZpxO7p/OCCW0AuOgCCQgM +fBHIfFhqAXkNSSGNqGKSUMwWAc8wOxV6aymoDlZVnpYIGUZk3XlyN0WhM4z3WZzGisNFCEIuJEg/ +5OI7dwBQ4sR1oLOwzDPy8ANFfrHkNULDYzQUlG7mxWUQZZHV50mEYNkovEIRBUzmJ8DjJBBjICEn +HKYYR36AXgxFI1w2ejZilSS4qEB+kH2m4ZqrazXCkrm7GcqPIMNpRopLYArRr0Em30kM10Q/QJ7g +HNAJxRiNjwWJBiDKHXyJNJRm0K8lhmWeeWpJEGLREV/iaesh3I/OBd1zKYIGhgnFMKce5SQ0wBPl +ehUnvDogp0Tpd8F3VcJMrYid3HUrZtAo9DIHYRycFZH003pilJ+fuF8NdRAgIUUpDJfyPKH7IyYr +5U5oOkXlpZDlxPsQY+6j5HtHKcYw5RC55ylRnqEN/Q2JNY5j3Q7IGotexwavrEhU7eiQ+GeikdFp +fkVg5Qtyco3SlYa3grHwlBc0qqT2IZ+yGFdZYaRzJIa7F6HOyP0I3cqBl4Xkeej7Fp/m8NF4BmP0 +WFLB95lqPAFtB+wz/BmBsEkkPEF0AtYVjBGGRDm3j3lAlAisEryDIBwKqAaQEZV7Zscpskbhsjzk +iuQ1VCipDowfwaIcCrEa8DeSb2GpgdQcHJjgRpBlSptBES0oM4HjjoRl4SmnMvroaMh5ytymCo/w +kCro4UXhnFSuDlkB+JurzgHKwKJg5kHSIGDycfBj1SklDiYjBsJMqWcw0xaCCgNRgCEFxY2hgogb +28dmHiPJUVxMR+0QinWY11CLcxd13EkgSpB4HPhdgDQE2YJ24pD0HDL5PWKGDgzoiGJTghYPNAIv +LY3OLvqpRlH1glG2oE2BbI6GC6A4kU48rEufRik7nEo3D7WcU3VXRG0e5nkjUwiq/GTMXkGxjTLm +8kDBSyZXM9IAIq8gc1bC+ptk4yi6aGu9hmSBw0hIekAKwLwT05R5E2QU4CZ1rPYAmC9hyjvSt8kQ +yWWcyRzXwPZGuFwOF6FCcfnERERJ26QRS0NQR54VY+IiqMOiXCjgqEu5NJHgYC5HkgwhwYuMCc7j +mNcImBggfwqiKF6yIGxjPjTUW8Zc6tu3hEQODa9LBeyhJ45zTZCEdAHJchSJJgYMwMH30qJeo4LP +qVKkcEkFHVYVyD7E9Y4q5vLm8uQJBLNFZFI8gFc+Sf26IYtLXJ7TjTJ5EqZtJK0wOvpLlM5P5TiB +aiN4htoGcMOOIU8OVTYkxa3MRbRwaXwFnbBryUVAfgEuLsi5wFtEWiIq690KfYfOv4gEgmsw+cWM +NEshWdo8uVyZLGGO3hSRFYx/VMgB0qXAfYu4bFfxujTAHmpiThEiBMMIeLtGoNoSUgQIRcB5ADIr +Rt1gSqGBkU9QhCKHsbVYDwyeoawF+ayi/IFEsQJxUqqoqNnl9x6lkAT1IKWbmaZNnMIYJ0gtI+JS +ipDQgXM5H8R0rPQtxQ45teYuvbqofKfNIkkLXN+BZClIOblfPA8FIxUKMNY8dRFsFiZZxokocbc2 +nA60oDIXleouzTtRPQxcR3sUaBAgDxIqsYAiwVpdu9aJ8EM0Icq8Kg/A89lmV8c5b626S/ue81bR +O/X4b/Ey52BTqcIV3HqkO4DYPh3vOlPVgHSDMAJDnCnmB2lJlCtNJaq7eghrlKngdAQrVOIlHjHy +V0f4foNLcYxSmklU8UyETCDTA5ETqF4FLgyw/R79xGnCWMVHxahCOscRLjO6ZoaUT1hBjsIcKAcb +r5cUM7T8oBwDnu4QtwiLgWDIClZvhDSvEo8bBrzFRhLPVMsT94GaTadcEPxiEhbSCYPcNg80lugS +xY9jyl2VkmOTzt9w5j+hkKs4D1nDrKE5eKaQMAPP8GKWqOiISk+AKCDPBawfqEnxCi5ibhQFaQqo +TvE6hgJMMaokDkojBTkx/EhFBSYyvlEilBonTopZR5eHaFBONZXiXPhQKmYuQPU9TjuCiiKFi77o +Y27YMzTSthOvzy1eUQoR1rA+AkmPVHXPqKmLuUH4RzJX0vK4YpddCM6OaDwSrUtuE1TKa+NyHe4E +t0nCsAKJlgvRuuEyghRJNiRcjBpqekiiiio5oP4SKnk4WqJMaGhxeQUVDTOyqVh5mEMSUxzgzS0g +Fq5XxMCcN6KKYHnrsOGZpj7RHOhhVPO0vbksdG9xTTFFx3BaiZuXFCNmSEHmBaGj85T5casqsMJX +TDYbPeZhcXuLm+Q2zLmNd4KRrMi3nGxaKqVktzWD7H2kchfQothJZQ6iOXftMGJ5AQ== + + + ayhpo4YMFW6+bmx+hJKNKKQr5gea1m8UnZ6mVVE42VTMsF+4jHJk1BJtd277nmCISvlYq5w2rbeo +w5GogK8cJZt3DMvYGAkcsHAvqNq4thiDybkWxwwrpJLDOldzgHUFQ4gPce4U2ImxXzGy5BETAe0l +Ht8ao0QWWMdFNxQkUUpooKFaDA8qhehAPBGKba6N4ZpvLKGBRURBW6eRGw8ENqrcq0Eh3oCiktAG +g8FiGjfZwBM8XWTF5RdVZJrYa7RYoo0pwj1HplSuAjJtkrQADiDolvtTRLH62RSFqioeKyfjpwgg +NxBdsC7iVnIMRDzROJEzEo/FjBB+SpMTNSvKUKUc2nDKEAWEGNcDN0SE9KayEUWq8hLx8ETmg8W4 +3jluWmllCrVGoyaeV824dVy704m5B4zUuJnR0u9BDoQYN6FR8U2sGUGUARUkJ2QP1ijHG2ehYYmY +5UdFF4SI4wmlhudKPTLBYpIi+lCNcaTTyftL4zZTYDwjRnUeyF8g2VAIkZX3RJeJGwBFXI4IJzcs +RYgXyTYD8WBE8SIqWXoxZpgII3coQyMdPuFJXVG/jEDFVCIxOshOI/NbMrEJtmi3vdpl8SVkjBls +ECeQMcMWBCQcu3JtbEfrpcuaiwUhuT4FrcUYPUeFvoBfx4rabMaoLcfEoxonX9ysqRjZm3Tj0lGm +SUHkhxkeCOTCMScmprzw1bV4osbxCJW4MWJuIf1clHg+je5+l9W92PNbHsZ5l/letPEXyYbDYSPx +WtWGoQrlH00jrwLiizBFU4wTDZ7jAYCv8JxSTm/Dt0RaBJ9El9eiaGYvcruuwxjvttd7mfWvEczO +vSb8sGODG1tcfRXpfAieBB7eBqJTQsrbd0G0Nr8lY5XLKu2yXIv2bQ4cwcDuNsJ72upjnLeA8jgx +LHgEER06OszrlMk6ijUiFPMBsRFsX2PYF5dQIKMNcFASJlqne0nFpUo2mysWg4ig+xboPAj0pCSc +ooRnkZjn2Qx0dVIxyYfCc2zR7kbQXVOGSra63mt7oBL2kG0WVoU6YgIjPIwgbKNkicEnINBIlHRB +pSekH46SWTdlGw9rk2HUQpRr4sENR+LJI8giYYKaPiSO2BfaRACELXHvmmtzi/zmFf01RJ8Ol6cA +v0AEfwK3y4HgmMAJB+Y8B/MVnVUJ67QovA1atwG+dhqogF8XVCmHhJgKWcVRjxjhcvwhnR8Ng6wh +LUCMSFMUiwkYGpwo57IUS8oC1WUcpWaNSjpG0RMKdOwRzMroQp0wjjIoJ2hUVpFstlQgi3KQE0ON +iTdUNF2hWhmwAXMbqQZAo1wBD+yfRIiGSgPM7iFzs3iUa6ogFzy6nESx6KSGXeONgMm4IPMDpPrm +8lSUY4vKSz+CdRwoAbjyQtYReIBuF4aJjHu7od0ezGj8tkQhEk1teLUJAOZUx7kJrm0S95I7PmEO +cY3keHSEor+5ERZjphiy8ew53A0nBgltdENDInqX8IvF6YHiclER/Fj4GgwLCM9dKlFWU80cyrnn +5p1CWl6jL2I/o1RwAHzwNCRkcbwuI5APjfaC7JoqT8RGoJcxxy3w/XiNRXkiK5WU7i7U4JRKxB8X +hjnRMOWFq8LaOHMH9fE0ww1G4lUBIIF6lHsH2f1iOL2we864HGsEvxJOKwTnE5d7iuDDUiQfFo3b +VrlvQ5wKtmAlsKiRg5ZcYTRedgATm6hGQkyd0rthNbg4Xf+HnL2Q0F5M7lkxbrCHcl08ESNxgIY2 +m/g3OjUaz1QGeSmwfIzhSiViSUexxtOnxuVoIriBvCVez+4p4vIkEd0nSL7QMb2lkRYQ1oNsCuS7 +QM2BzpEoxnMO0aIl1BEBQeCKR0r6HeXZrsCiCze6biquQIDBgrY6Z/l0HlcBtRni5N2hoo6JF3zh +3DheaRpmRsWPNDQeUH4Nxb0lJGII+yZurLD3HH1xJVwXikpImVCRfyP4LHEPGsGxyeX6JOxlx9sl +wnO1RTnZuMdnvJqXpU6IoYkRrIe4QE9wO3fEtWXivhI2aCjqxbgEgegBqgOTFRYdd4gQCd49Lv8f +wUeIA5wOaYxCsTAfSoSKh3O1g0Rbgnpk2eBVCTuB9qMrJphVQAzCWoFalOuWGDMXxTStVGs0QsZ/ +8LpDngPNI4BGMcvGPWUkB40ZhSwjPAlejHLs97r2hl8DKqeoMZ6KhtSAcSTFMR6ZhNId/i1HqLS8 +MANS8AjTdC1EXC3X7qCmFGNTIoTtqH/GUmcS8aHIycpWzW2da6Qh6ocSczv8l0jZKvg4ubygvD2l +OPUwhFrSR8G5wHWLwArk6yWsqCODd2QEaT4aZeBOVsC3iUQ+QDr6W8YQNTCv4qmIc4s86a9lDWuS +xA0TLRBFLHkd544ZXj5TLr8ql+eV6J5VtOmFAZPjZJ8l64vCHVmgX+KsVEqFhYp9iWo5ArpH0dqv +06GmpLiA2RJJxxGzbKr1QKLiKS6IdSI4bvcvKMcL+k+DLoCzMrnlEUMHegDMHRnn9Wxw8iopIHmJ +c4lybMPfyFS4plW0L8aau7g6JwTQPEayJnokYoZfsg6CWUJTo2ZiPIjqiFMUR4SXwwDbE9ZYc/qv +vYUWooObw//N123M+/728ByL88MOfFMMzwuyXsBmAYLGyPJDgCChUMe85OiViK51RgGNKM9wHOEG +E91yhIhwGwdkjZawdAAJfEBflainw5zgUid63IlOeUVYiWKACvPDgZoGPD+Qc6NqCA4HtyL5xIk+ +cKKPnN2NLuX2tBNB+rYDUuvTHEikWLy3LMaasVLSmek8Y74HOEWIizsibhq64JBTkCxRerY49/aB +zGpwV4qeeUVcqcN5T/Ttczr/FdFDBnNIGxkdjaKamNmQoiLhEkXvXEJWtOmg4wEkQRTd8Mjpxump +J3ryCc5+tKcoesU4eQfOE/5vVCYFKxWcOSPlWwqLYcEpwlLsEvAyZGBGHkXHSs3gX0YG1pRrCwNj +hUQ/uXtb8S5UTqFLCZrawUYD14/hmBPhupeU5fdlWG/gb1D0GZMSJ4muLLZFCAsUQVAkfxnAh5jh +aadw108J72WMBgKYRnV+/wAVA9Fe52Kx4Mz3lhJaOtz9nM6Agrdgyg2rYFdQBeulkR0KSdY9OhuQ +nZQ948Z88oPBupGQXtXD+UJ00HB5cLjcPIpwBLljkIwyQq9muD6gylrGNJzcng0e/qRn1fgOY0d0 +1gUvBqT4gquD6Avh5S+hkPkcBRWkEgqWiiaDAGqtXeCiuwIyichUlYrSsvhHnmMxUgkDhmLxXsNB +VEJBBiv/Ck6GRdxRwRXRw1tRcEPDzwRfNZc3m8vlrYieVqRFVLliLcJV4/CAewMJHkf4lcstyeW4 +JPgQFdE/xelo5HJFcmEa7pKIjS50FTYJP9JRv4AuaFionNELnYz0eNRcXjf4kdMzx+W64+ng4+UH +5PYVEhw/isjCiv4hbh8S0dEEdW084bzxDB9wMFKwotMfgb4RfRbcfg2ikZ1zvoRUGreMWcW0jDz3 +bqM4iT6i7dxtX3eZ4bkPBGopIOY1ThZzWeJGNhKSXfZY+sxttXVbdgUzH7fHCtZAL4uh03ZBMrLL +xOFpCHHaSww1H0AQ+BxUu0c5CoJZAS9mtz3CMGS4zRZu04aHBcRlJ3FZUpw6cz4cglvhai6cJurZ +0bTl0jjzb0S1tKi3duq26SO2mCj6IcpYuAW8rEEWU40YO1HDSvsmqGE9FLVOPR19RYRT4wcNqvbq +qCslplDUWdE3gl5LVHwJyhpCf0Gh46Hyceoe6LTFUdUY5TFDqHUAwhDFuAXNLW3TV4JILsrsgliP +yhp3kJQzisoVXEQUyyFQV/GRW+oWJHOX/I5EUyGSCs+AWJmyou2BUypFYdEpuYqSrSDYIUl3RQwJ +EUVOGQpvKaeYJYphomiBfI1T+hCEE4H1LRIzDOhP4pDWazgWRrgNSORmi+RH62R4RYbYyQcSI+EI +PxHDUzwjWMQgFzEIxhEmg19IyGVAYq8oiQzmAzXqkVyHvnFl4BFT9DiZqaKZ9gtZL8o6lUY8wqAJ +HTpjJxmvWqhNgFIEqTBkTv/RhzxOqf0xp7pKLuRY/hKOHpi9MHYAj41G0it6ZZOeDOoTcAdNlTvY +6ajFx/Q8hhN/lJt8MJ0K1UeImcmpTMt9FGuxUyC7RJUkYNka4j5Gt5MlDUzHUK4Ak10xJAZiGuXS +c46UnOiEYdwY9CwakbF4mmJEh4HmEYtwgwUMLPk5JGzkbRbh8Ts5G1lVueBHz2KcqoOnosqf6SiP +GsDl7ZDoSYiCMeNjzl6ApzDgPM2GynTCFYt8Gj2k3yEPC/e6huXpvKQ3Mf0EB+IIIzyHNoGLwjqQ +8uoEfvC4IAUssjQy7aYFbmgbgSOOW0XVUICJwZB03FEViyxDO74tptU2wrcW0YNzsTBvIKaIQ6TD +RMYrSnug89CgKSxoofA4JJ0cSyS8Vgk8sG+U5l1XjKAwEZlzRoFnV047nvlMVtFJQNExJRBjdnFf +2L1P8RVk45LJlnBvPVGxQCBe85E4FY5B/LKgZjwhtjKKArDZKoKZMFWzG/MBH4nuRnoEd46KGVt4 +L8CpEcNtbZHxCGk5Tcl8ZszZ6EhYVdGQhGMUkYZazBj6nUtwUO+sM2vBwXiicooEKSJAEowYdk9z +ahGbD5xR8s9spfKjZ3RjPrDBwXgEoVoGf8krB8o8Ds8GCOMRXoM0J/OZMWmzJ2FdHBJENjthBrmq +QBInutgpgBiJIxwo5M5ztoagSecUhTHYxO3YnumcA7R/a7YzB8l5jUw4rvKaChErjgO4SbgejNOY +s1rByiOUry3CbSu2Rxq/8WwfGq0iVrSBOKKhUmHtYrjJMnpPUHJShYRPFZMcqETjeUOF1M1IXSR0 +AbQ/0ezfGA2MvnMe49E0QGyUKWoBjfpxnWf8MCglCCnWzWK0Bf1eTNaNUBaShR0PkXuWHd9bLc2h +ct4z4HNTjBOJjqgUagyxAOhBhNwscDc5e8sIr8RCRFzn6XPsz3j9LvvXRkNjmJzX2DnDSVzjjizs +uovI3Ec8TqRE5sqNnL2hwq2ddAHpWNVeeMikej3u/NxsycfJeYxtTknFGGaFL4mmRD7j4FclEZNh +tjNqFtEwEW4osZ6pHML2b412ig1s4rjmdCgfoKGOIbcXNQbSs2LDJqOdTLvOn0lY1M/+LMKZaue3 +1M4YI+cxLp8OmGtIBUrxOmQxj+NqDHfSnK2dyt1cCRJU+ND5DNVE9k+NZsYQOY9h+WxkzKuFEWmo +86ezRroyQ7GWs7UzxGU6KBHXQwmvSpyi9bHZ0Bgl5zGyQYYwrRnyu5TgDG2okiJTELxMnok5W0sQ +0mLGMZWNyBTnw2ic+G3rc6OhOU7Oa/AczzlB+g6jrBJaHQ3hg45azmoFaMp5J5Wzo45HpC63fWi0 +Ui26II5ozEOh9KZwr6H0SPZPYg1lHkuVszVUuG87jiIrPH7Z9kwzqKL5rdnOHCTnNQ== + + + ssmhxV+kvokGf19u1Ws7zUqtXandTE3x55ir1/6m57e2GvguRu92qo/s5/bVm3Kx3fNbo4lS/arc +m2w+tm57Nwu1wk252bvdLJWbY51e9tLbVKFardw0C43bSpE3zdfr1ZlerfdM1eQzJaqeMQ72TI1o +7P+RMyZp0e9R9l9EmXF3M9bLFjPq7Ex+cm/OflTshkawdaafKdB5RHlyx675heqSJtI1GKPsb12l +56pjfgyftmtQdAf7oO6Nnti30TNFUtjENPqd/V+BS5K/iuo4NxxChvnq3t3aOoSWEnTCJ8M6VyLU +mx6Fv2kKRj8l+lzohA0rqzAc/12B/4xPePZq5/AcbrZJsME1ADWbdlTC/mgLADpsQhp7prI2ijYz +1jvNzwM7Q87T8CWcLNeK4ei8/86fvv/DP4TfpF5UB/fyVPQo52EBXK1X702sXSablVa7WsbPc5Ur +RiQuU/uspXa5V3+sERhKl9lC7atdlQ+2worYSf3iFz959+P/Cystsb/h7GIdXgn/MwoYsP+C5/zE +8VUY/v3P/m/7DJgI2stEbLCg4lx4jvIvZXzX8rVe5+L5P1/i4P/P//ziz2yD84o08a9gaAHutHQY +eQoMfJpRceSrRVYv4gXze/et3//iR9//8A8/gj+U3pleo/gGNWNf9MozvcY/GE6NntioYpTQls5Y +A6jpOEMHsRdXZ1Q2s+qrMCZHg3/lpwPebw0ffvfnH37++4yCf/hfv3z3R38qrkS35g/TmPGbIf/9 +q90XT8pu7M23/+uv/vE773/+l5//8E+MRW2Vv2Z80xtx/inL7r9p0RIsmrYnaOlfAkrG6R3buf32 +Z9Vyq+e3ZjZq9a/V8C9g9bDgw1jvzBbbKqjHMJNgjODbsvl+JlW/bzAqX8pWqmxV+EnqtlCp9VIT +ekzlYWZ4m0lQiM8cVlqVqyp16tHJfrtQvOuqk2ShVSnap1GvlR4r7XBfM4a2d2an0Gx7drXfbtbv +yt3MRsFX1e0m/xR6tTPRDKL19l65WGecagnfUkMOWNb1HvnEYN1YyIgQg9KNUD1HQh+zDb8qFgrU +AhSqWMhc5TqTLl/3zvWytY7ahsNCG3O9OL9eJyBeZHdFaNLJ4oDZvr5uldtjuBTfLkbXqtXHVrtZ +aNeb0+WvsxnPEPqzD8oGajJeWQdOCtg6rcx+AX6PsVq6QlxjJHrCeC32EPkw9n8pAvzYCussX2k/ +cdtG12qtSqlsqyuZrrQa1cJn9OeY79bynfPdRiYDPm0jZaOsCr0g+Bqz9N1ocY+wMGZXuxyM3dif +BQGjoFGIMpa2pVqd+K/kK8BfwJCXA41ZBuegVc68Lde2SyXCGhjGglh3tT+hKeAJVOxSPCp2xYIL +dlEFKhvkzbl8LCgklnP78lDoN3D3ZSmwBOSL7P5vAJgiyouD6V+U6IYGTPfnhX2T+Xq5+AiToZfY +hTc7SfXD/pWxlJ84qU6c1PZj+2mslL1Coic/JTNEhwQDDNe17hkq6deBoXKWFfzETn3FF2qHAqif ++KlPOGTHIXvxY0986lD8+NcDn7QvkeH4zeY8O9Ro/8Sg82PyiT9/af789Iu/+OPPf/rzczt/vl+5 +b1Qt/pzvIv2DFalNfZYcoM/yWojMN5hNtVJrB07s3Xf/5/sf/u6773333d/8m97jX0/x4V9CjdzF +YXuijvhL1Lv/i9Co50Ds2SSGJLp8s1BrXdeb9y8jzamSdqaCcweT6FTgVS0xLSTE2saEuPGqZaia +98oF9rpVLFTLh5fZQpFNxBCa6NV9/W159XKn3XIqp5vl62q52D6mp5Ik9LRTbhYZhXfKX/guV6nx +0uCS0NeJMQJWHq893qfqjYqrbaFWqt9XfrvssYBVzwU06+1Cu3y5x+6cAl+3ysdoVGo79Yo1TWvF +h+aKxX7S5Ztmmc9KXPeqY90fARf3cdxJ7378f33+X/49Yym/+MVPvnTC730gwZGl1JuqN2vlZuul +VCygVQFHJwncf8IfSsXEKIaSj63urHe/npfYMxiMT5eaxXjbWLauefBPfHRXNOv9n3//3R/96fs/ +/TGjXJ+Y1d8QZjV4NV+hB8VvgOwODs4QBKCA3l5WNQgPhxgRJQpF/r4clQfd5dnH3/7tz3o3C627 +F7rIwTyiSOTDK3XBXcsm97fX4Sb/ykxJZNwAF7XbFwSO3XYEvtsS/F9thYdU1ABU/bpFzLHCWfA3 +tXYDH0RM9rtauf/XpQbTItz6EMFTpHw52rB/9Vf65//u2+9+/seXK/uf7vPfkPv846QMHNHGeu32 +H/rnVEIz3RTZ6qYUTcPUD+z+1DXIOqaf9za+Au7+owEVgIMg9Emo+Soo4H/65a9++eMvfvg37375 +Pz4RwU9E8DdYA59u1hu9+7eFUv1rnRhhW9PpQqXhxwgzhhcU8MsYFanoEC0ZeduFsMAZ3qtqrWQo +oYnhvao+cpU1OEIZjHKjUAzUA8nPJ5mtYrXp1Oo/tso7+7mkMSFjzsVWs2hw7TS923rzt/GJZspA +pULzztnobbnZdvbfKFR4zzrvmnYrc31dZruc+XqjwGhwsnxdb5Z7D8vNVgWCV0Kfm38FJPyL//aD +99/923f//L0v/ttfv/vJdz5xs7+phPzXQO8kh2eJBbT15I1tMu+/EBv8pdIP+cukH18ZBxB+z6E4 +GKbB6v1ktPiqLodf/N77H3zv04Xw6UL4DTVEGHeFn99tBG0SlNlYiVMuAEiTE/9yLRK/se4+oovO +y7v7SF+Bu0/kI3L3+YQwnxDmCQjz0dg8ldA2z68+JB0qy34FDPanizjERQzpz/hVDDlitRgGJ0Hd +jE9X8SfK+hFR1k8I8wlhfk2v4o/zJla/Ij3Xp2uYrmE5GpuOxaBwou9trNFljJWIoA4KlOsBwTge ++5Jd9T4R10/E9WOgSTJmYPtElj4S6UCOcemAynyomowpE6HUsfqJIH0iSP9KCNKnfB0fDUGKODgk +NaqoSJBUrGj/5RCkL10dpilfCX59PKhB/3yyNH8JlmZMNZyplWyJhjtnLN5hlJddarQ1O1eULgL+ +GT19/51//vDtb73/6Q8//OU/ff7tvz0HAB23IH+F603Pb+0UHbs7+uGHv2RvHC/QG270i1/8O/sL +07N4NLV5stH74e++6fzM8faLX/ye9VYW3374+79wvpUc3/7Zv7e/lZ1vP/8P33XOyvH2/d99xzkx +8JjAcifoG43tFtijzQW41E4W4lLvBvvVWgY2hJLmvC3DAmh0ssCebSzYG0Iy8bizYQy7FBtq1uKx +lQatYHhnM1Vzj8yeiSNPS8h5wzx5Q1iNuRarnWKH+oIi8VbCwNOao5nm1yzqbBfVfNphNXjcNBPc +MQK32dgCNwJb5XBkv1D7OK7cBKUqTIL/T5hH1AkkzPRuiCl8GpIxjYizbdThVwOdYksAvcfa7A1x +Zbid9oaysSDJGhxWvgnrOVnQHE1lSsWHP+xNCT0VaKxodgDI9olaiCxuqr2ZJvk0U+lsqJptt1Sr +T1Vz7hbN1r4os6kmYjMCQHEeI1i9IiCpZqw/YqEqzECBxhFn4wjf0GkOXGoegb4jmjEJzY7Z0zwV +ogVdzTyBuuSErWa01Wk6vD1MRsf2AI2IMPUIb2+fesRsbYO0vWSICWpzLlEB0qoxl5h97qo5l5gw +d2MadKAckNE1gzSozvZRvpu2tlHrkGoOCoFnJIb/t4Exak4larTmQXnsTvnf3/gddoF4J26z8322 +to4u3v/sB/j490J0YbV1dPH5X/5XdhO8+8ufffjZP4XoxdHc6kjgdj//+29SNDtdj+9/9K33P/iL +ML17fkfDBMU4iX6cRlv+5VNcQV0fGcRo9MPv/M0XP/q3IM3v3DiZATrCBglhOOLkJKDYezwe8Wga +F1tGWcNYzKNlTGypQ59Rj5ZRsaUGLb0mqrtaejTSxEaq32IiYkvFbzGq2FL2W4witpT8FiO7WkZ8 +RtesLX3/g3/7q3/6a2tLbWzcgkW/3exIVGRboppnO+O2c3TpYoNsfIEPV+C4PW2XF7853ZeXzsmd +BKHysvULfaZ7frWTtDhtk5/urihIrtKCeihmZrgeIRCsR8jQ0+NK1tYj5MOwXE177GG17nNKT0Xh +gSb0xIonskQvqVAddPV/wCR++Ccf/vj3P/z5z3hZoA9//fMv/uLn7//Hf+QL+vDN/8JwilFdYrSh +9Mvn/+l3mJTx+U9/0Hs2+u5P/vzD93/aG+99960/+PDtPzgbw2/+4Sfv/vHvcVV/9pP3f/e3n3/v +D8dclfL4BAIWw3cjXS8+3pdr7XShXcCqfMYDKsjnEAHxwfFmbqteKvu8nusd/fp9tcYaTBXa7Wbl +6rHNdV9Y8K9Z+Eq7eaFRbO2Kt5VqqVmu8VZGugDjNfxof9Yo89ejw7XW5dtCszVnyz5tb/u2UH00 +G8OLlk9DUAzxdnw2Leefv/agqtVr5TBQqtaLd+VSKDAZTSc/igVeVWolNmE5zCIZzuyX21u4mhAL +tTd/SaR4PlDkYKCEA0WlcFUthzoZYXb6XxwRuicKs2/DkwVo+3EgPKyz+Nhq1+8/AvL3paLobKsA +qWzhDmXnMDymfhXnZh9qN3xc8/nNOsqt6699BPj9a0DJW9VK8TeHjE+pChQF5+Zc30V/rVKCnFch +dp23/Chod8jF3ZYrN7ehyIvZ9KNYnhKJR6WOq/ss1MI++0jWFIvEYx2X9PVw9OcjWZIZ1Ou7nqt6 +m7EXufJ1e7tZYdJsqOW5P/poOAkkkfv1x2axnATniI+DlWA33Ecxj/tyu1BiPNYLTCb+7MkMlLii +JBTO2VrjI5P6JKvlcglw8dDWueHTlGrWG4lmuUDh0l63vngmY7IS7cUf2D96K+GCRvceq+WmA+GN +UXg5rE0jUQpb3Lt/+Ktf/fLH7777jXd//udQDmPmoFYpskUZC7WJmqZL1U5iz3ikxHqn4Ic1h71y +NV/fo+FpPjv1VgWmjq8Vc0pS+I9kkUystRLN9lW90Cyly9eFx6pTIja2wmiDYDQWfPqrf/z55//l +P73/yR+/+6f/fO5ecGJNlntN1RjjYR8bvdkq+MbVys3enWYZ0lvaoWIloEmsxXs3y63b3r1Cq11u +Vn67gG4Me+VWvYoeDfwTVXJ8sv3Ybjy2O31k7KHX/HKF2s1j4abcu1NvPDYM7BExRjWv+UahVLK6 +JZDeYzyBE8ytRr0ttitUKy37OnBSpUZlmj/UjJQ9dZ7bh7ZirTfx2K6biyyL3eKyjKPTe1erF+/q +DCg3zbq5IJ+2FQaoQrvcewUeJkaZN0freG+j0GCb16rcP1YLNpgqJkzjvegH2SgwwlH8jA1bKbHm +5jQ1JQJIbjYucMzqZausN3sVNvij7Zj4tAvbGbgR1sI2bpp6L13TVM2/qWyfZMe29jl0bGzNQdbV +mGo2NdA0Vai9LbT2LXjKjq3EQ9V8W+7Nl7/e7s2UKu3CVaVaaX9mbaWNhObrDYGC2g== + + + Xu4B72l/beazWqnWrwrVvXLjsdqyMECLxWPGhu2Um61GGQnwCtv/S6DVSasnYJSjPk2z1Xq9uWdC +QbFogthytc6wv15btTPJsubXOlWuVlOMPTBa+veLM9huFIoW2CK2LeMUDCjc7mMBYNubK78tVz32 +Q+q9NskdO4LVSq3c28JcE8a5H5Uj09K0ZLsO7xJr2cdq1dhvnjiLvfU4urqt/0KtXell0ylYJCUI +FPvehMNrxm2GSh2BhpyhE2a+W4GYlS0Uy4naTTUMTuAHK/aj7DsPbOqcSEdss2GmFgtcYebrbQc7 +4j/bpDeB8GxrYXvA8NjSMX7Ev/Fhpfw1hk2MSWkXakVT2pHjcm8sEpFdfI74/X67YHIMxkHUFTkS +cLzt2+O/9dBS3PmIFov69Yz7Y++6w6nlZVe9b21BINkvV1cLbXbQcvVioQp8SMvO3vi1ZvMsN9fS +jrb293lQ2MHQrktMVi73GRuQAlK/WS+ZgrXP2vN2oS7EnoFzvCclT6Ls5sUri30wBq5tw9qA7bZw +1q8vaLVTLdTK6ByLlxCgVacp4D4GfjelSVJHaDA2uAB/YHeHhVqldcsOhB2hA49vwARiepSdIjhK +HedAN2g3Y1vyxlqtVP56ttJstbs+vdYKaOftI0fjGutFlfWOvZj7B9eFg/CEn4nZh3siYUGwXy7W +ayX7yNF4VzBgTI4DAFE55PaRgOmxe+FnYa5fmIQfk9Aw2Lf623KzAb4Hxm0ei6gh981auWvjohbr +6Ri2iaLE1NsyBPb0Mt7Odmn4TbVYrTQY1womnK8zrvWGEVpL/T5j93kXKLHLJ94ikTk2D0PSXEt7 +SYWy0svknxUj1gMyjJKYGCgY0lcQFNXLusevkD92feUcS+7N7Ox3Pxh9FmK0ruXQ0dPNcqnyeG/r +6tzGOhoLDZKxnewjyJLANyaAb7QEPvueY48p2OwU3+w9x2a72m5ztnHfwehKfs3yFndpR09sQyLu +zCHhZVLES0fbbfHEdAYWbVR4aEHrTuCiPkPCixp3BpiznQ/EqFEHkFlyfK1uEZneSg2PMiiKPODL +hxcBHPZUz1ia4Zk39atp7KRQrRqyr9GftTeuL9hBaLIDIc7Nr+cOzVp3lcYVA8ydcA7Fdk0m1jVb +ZVhSs0NTJr5XLRZh1K0LEz8wFm9f1pwpxMOerNev1mrX9V4bK9kJ4n6zu6q07wtwt7joDxEte/vG +zf3d9BWwjfXr62lS+xssoW/7+0LzruVq7wV/Z/ePrTKje8iktgI+Kt5PGzdj8f6zoG2ztay3b81t +s5fSDdgY2MUyQtipq3UN02pXp0ukLkWcswYKHgC+4x/YVN1hPmqU7tnrai38vBql8N2Tx4n1iRdo +G40mbxe0vawRn4CBNLLiiTasod14G437NnNYQWPTEb92lXtGJqarjOUK27ZdN25WXVKnvdHbbNy0 +zSIa69jccRJGP3z/f3zxs2+++86ffPjpd9798/fe/fWPPvyvnwXvC3RVc1xF7uGKIhj9WzmgGNBZ +3S5CB3QntnMfRWiGquAOtLNUblVual7KZE/6fsVtfIF9Ysv6daUqipveV0aLKGR48u3cGPfaq83p +e0vC92vCJBvIqw+2gaAFQVPzrmYXV9GggFHFs3mzNF1vAsta8GA2xZbXjFUxKwBYNgexWYMbkQIR +Awe+mQ5GRt7I8LizhfeLzTDc3+ytY8O3HVbaKjaqxc8CiBc1KtZagWjNGrUrVYd1xGeVbMuqhUYI +cPCGQQvAe7NcA91SIJGGZi0zNrgjLmN7ouq2wxLmI3YK2pAfw5gMBIr5sQfsRgDOVSBUAbxBp0bF +Zr3RqQ0wjRXGQHVqB7IrZgcJPis0LqjurgrNVtCWOlkc230UonXbvq5Oje03UgjezDaTEK1td2Pn +xvaZeJ2s61p7ulTtQBGpUaN5Xa8FkkNo13q8Mk+p6rVbLbZch1HGq8lVBVjpoE1vTdfKNwWbI4FP +K5CeGN/Z6oBD0JDdS7UOvVVl6K9gLtCb8rGGrdsCk03KQdCCVuU26G1qbH4WPDz7E5pFvW6Drzem +nRoiy3YtNGu6JA7Ur3g1vfESTrwa8ivTZpPy2lurIZnbOjStVoKoCWsBxrWCU+j3aVlvFIMoDrZo +BW0/tig9moJLBx8L4dMOfAmTN1shbhFsdv1YKwahCzXiyhMTZTpcHfhRoVYznSG8hX5s1lHYYMKe +jaSMrhcahVpvioz5kiSzX5lIXuog8oHAaGcUvXhP1ghkNkt/65TUE0ZLu6xu199olnZvp/L1cnWn +3IQaSYZUn6wYEn1iP7W2FtPSZZguvo0sbQ+fTswfLYzMFY4n19Xh7ankcnPl/nb2pta3nu2bHB1J +VQrTrUH9YDWjD8wuH6wsbkaWZnNnI5vLzcdiNJtRNmNDciQyIEmt9Jv0zaQ0uDx3MT2+PD/ZaC23 +NpQZNszyXK6vabRabydvVndzy/OR8n6qsrBYTE9Pj9y4xsqVTtiA0XR2aDb6aqWdfnOejLyamkzc +13OtxNp++3ZiUR94zKYjg0fJN9WRIzZM+lpav/LsbTAav44e7p6eJfKp6UP/Ue3tZs+X5++y58uz +ren7ifTk0GN2dKV0zYZBeGVfX24/pq/Pj6LJ6nL1ePY6edtO3UZfyQ6IvB5OF+Xcw/L80sgRdcQm +3Upd3FzU2W/DD+m10lpfcir2ZjCxPzVQo0kcF0qPbJj4m9GJYqao7Y6mbiOXc/OJIXV4Irk1+Xpi +OTVykE2VH8cXD9cHbueKxcId/FaZyFznbmloWZopRJuVwdezlYv1UrI6tDQy1Zw4e0zk9ocfYAFj +y3PrtyobRp87PF9O1Ioj9xMLm3Mz0fuzhUo0OtO6VhPN4po8cTcrm10W0+utQwa56Eg5eqRKpdlK +aqbANlneXBidmiwnq9Gde1rDSW5oObU2P3CUmYxrkAImvXaqDyxGU/WLifnD0umscjVwjv0u1obY +khb18QHYllP9SN+tAagWk3dj+hRH0MNSTpLPBzbTM4X54WzfxKsmDKPDiwvsBZuwYaSr/rUI/jGx +mJ3nv80fZTaofWoy85p6U06UNYbBx9LE4mJmUkkv3Szwjo4W5udKb7YucDfNGbP+tpOaMQxrlVw3 +p3BuTUEeXdiDVuUIPtP6kulLBHe63FqK6K/0N8VEPv1mIn09s/GQKRRGBpP61cHu/Gr6cjGRvy22 +EzuDxc1EXlEBBRLR85MB9lHpVeb49dKjCSVCXge2XtxZvcWq081VY9NO6unr/UwJQcr6LYxNLA7M +HdEuQc9smMylPHGYjByvZ5ebzduDyOzm0RLuUkyrNHW2g+OTE8l6/EKEpnPpdtAboKLNha7YMHMT +C4+j2XRVTkrr2iz7sSJVqKNF/aq+PJdv9yfy6+1HNzSF3bSB3tj942YfPMsDTXuYriREUD3uxcvZ +0eHGWOpW33uVuZLmx9PlZnNSKu8szJkzIYiY4MitJC7XZcS5+anXWTiyG9PptTfRAqcCtKux/Yf7 +jcT2RXIzm7pej0nyxlUpmyrdnyAl9diHlWRVXziyOtfbuYVXydX8wIIwCTYMm0d5O71yN1RmY+3O +A7FRpevZo7p7vmK7Ivttsr3S6L+KxyfmIlsCTObWGHOdqrQqOpLOqdMdZWxgbdVa11x5dvienem9 +MUCyzYmF9Vfrxqg3Z4ymqeztUG58pX1Zuk/sv15Pz1QWRrPUwfXIqp7Ib9Zvlg/za4VsJrZ7zIaZ +n5AyZyZEGpnJ+paSHdZnj9nGP8YzxbuHYWMEPCjVApHp4dORHKOVCyOJvWpj3N5ut7DKSOFIJLp3 +Oz6d2DjZB7dUG0U3Glwu56PD26ncQ152XCHjw+nrxMiF40rYy2Yvx/pucSGMANfK7GhpV8JbAwWg +wZ3j5rF9Ps6u1ZV6ZjJfXGCA3D1iR/x4cGJxQVfxbWJ/crmWqlR2S7C4PmiST29srE5l5zPaGL7F +1dyM16h9fnN5KFldl6Zhv06tg6ofjkp9keXDq5nobmb6CEj3VnS3b7usXL5qLDP8lufUxPxUVt/P +KTvwY1cZG7xIySupXEK+ujiA1AHy5GhqSSpfzS7Bk0R0Z3UzD8/Y8Wgf55X0/fWJOvx661h7ePO4 +jl1C40Wz8T52AP0uwtt5bAJvl4C6Lkkbo6V1Nozyerx5r2T6VjflydvxLbl4urUpbcwt7en107Vr +vb48e6c1ZWVDnjzcqGjNS7nCxi9l1OHs8LEeu9jcVV7PLx0pY6fXt9K1snQS3VXlU3X4eOxcLu4V +D7EDNgzMcoOmygZm7fcql3p+9faUtdrIsxN0mtXr0eUq/7xvMBECSgKI2DA2KG0oyRt1+E3iMro7 +vn0vF5fnN9XheT0pXafnj/mfzfo2W+vIjnS9uXsa1V6Vj0140dBRbSq9g52bQy+zYfAd7GUaGmyx +sebzbJNf7cmTN62sOny0caImh6+31OHC5JEeu4yUonvXbwb1/NTZPsB6A5DhWmvO9Rf0+traNQPf +6o7W3Oy/5RN7/RpIJ/sjviqtP86/0vP63TGb76s19kxnm5E6mJendqf2GR6+UfkJjidqib3rmw12 +U240BMRP5A83atllWb5bGVq5ZDikjepIZ9kwdDIfd4fms5ft/PjynLTTN5E5PF41DuXUoI042kic +yP/Z2yG3Q6SY0ZIJJ9cpxxkntpHUR9hlNnbqyydG517lsgn1bnAd2RvnkiaQ74nV16VoZmryOpLe +WHqICMMkL8uJvdr+QWK/vXafmcjNjDrfVrPL8aGGwSztjVl8JY2wdpp/SGynkjvmXXGPgAFegK+Z +8ddwrTiXayOd0bniwV4iera+l15vjr+2+rA6SGir52uJjaPdV3xiB0N3K63tcpMNwy+znJ5kNOhs +2uSJpoN5orAMEXQVhXNzcF7eSF/vtvZnKjunjBfIPKSIi1CV/tNgNi8Uj8ewlA1jWx9JEMeJ7Wz6 +zdFlqvJGn5m7vh+6YXf2uMzAsvg6Gt0r1WGCUxa951fzfvXc3RVnl4Dl+DI4JoFdAub2y+CYDHZJ +H0dxBxAaWMX0zdTYEo2wqy6+ZjfP9kjqduIkNVNZXJjl++UElYPHumPYP5212HwH5HZW8VpjW8AG +VgdAPMoR7nMc5ZMJYpaGFwndrXOws1o9tJga5GjgvjGYGttU43fljRRbUmmCiXGL8fTKSfSaiRsZ +RVJWIptiv7t9Y2dezJcx6utdZKAOJlbY1ZBNK2OlDB1F5MPhcogTEbuYH77zO1/R7MX5+EA2U3t8 +rQzF72OIAvOTgzOnsWgxt57c3Vmm1Zzcb3EJ5vFkKLG7tX+YTY+VdvgLizjXh6Xo3ePVjpTbuGpY +IoAoVSmv7gZSt2d9sxOLK5eXiCXA2Szq59NsG6c3knebE4xj2bm2zu8siJMXyTtloc96YUo60mzp +virBjbYFAH/lK9ABQnuM/nJD016DiNtuTO9OLB0WHowR8tHluY2TfsYb3/Y5O99O7A== + + + r5TesL1ZaCrLB31xax8WRh+VMiDeNb1Yum094jbHdxl9pWEuCqyPfCtz2ZCvlucORqZt2gBFq/bP +XT/uvEnkDwonbITZqpQ9W1bZdFanTFotymjxarZ+bSENG8aJN7LZ1DzJ9t5CHmPVuhLxGMMwvidZ +0RPD6atIeR9PctAxts0EjvHNaXZspzqXTWuvlInFk/Nxk0Lbuwwhxtj6zdmOcTJ3eWuAdP0xPb1X +mlqe3XoD7KB5Z+X1/mwtxdUgDAunGg/1SnrmeG7ZAOlIeea2fPEaQNris1tJL3ByerSgweWvJO+3 +FzUHL7IFvEBy+1F9xcC918pMjOvXtivMwj7k1wcHHmLLs0cPlbnr1aub5dnj7JCtN6LfJJvEr/AK +n5880VexZzie1n3Om0qjTA5pF9k2vppLlxvbOeQx9IFcZACeKemN/Ga/NX70sJrLs5tvaTBzKdXO +09f59DUTxjYfE9py4jRT3Kli/ipgpCwGhqthbobuGIGN90dbM1uHiXxuGc5jfMo9/fnR5eZU/DGx +szdzPlu5iF2zjT8at7M8pjJlYYbhTW6csS1nB9nLudsZcVRl8eGe7fRN3/LDUrFsvYD9ekzErho3 +0/Lq4SR/xrY5lh98mMqO1uNj+AKHMd7JV7k1xerDvHJh0ltTyeq9dM3w5u6Vvji7fbI814jL7sXZ +20Vju/VxbGLyaR6tZkulqwd3R6+m0lL81QiTUfU7JvEW5GQ1NhCTlMmHyvLs9m6Vow8nNoRInIfm +uIRq2YXi8Sk7POnNxF5++cGNIAMtJuJutpZns0MFfUk/XkltpQ6XTLaRo8V8pXiaXivu7SQjR0rb +wdzy3b8Y6GOXibSbHV1fysVXz7JtziDTZiwwyVTa0Oc2BhPX6ZuB80h0tjGdYnxSZdzV1XW5DogH +qqH5scGhS8Dz+czVzKuGky2nucXyw4P72cuB4X22womzzMWbdhH1LW6QrrQzV8nx0dnNCfU0kc8P +E4m3UOBoac3sN8elcY4bOaIfxp9nPliyOpBNJc4Z77i8dpxNT+Y1Uzmi82FO43eJTD4Rje/dxCOv +k/dspUnJaiU0gXuhALLU2FRtMm+ybQsqE6OW7pbnFxtHyWpNGvYeppy8G2mvJyMn/QerC2eREcfx +8Fsr5/90ey+j02fJ6t3aFpNNMnUH0BiFXq7D/bgOmp0hdpLVASZBvIpbfczKsb6t7NjJTjuxcSKX +bKMubGyV0qX7+KRjYqOM4m/f3SApth/P3FT99a1mO86m0pbI78RW/U36Or5eTV+NV4biudfN+Wyi +WutH5Y+ANGjGmN1KzZylNzbmwRRBPJyyuz+VzcjXo9nZxF6/satHo+wiyM/oC9nEYlIfamjptULV +dQSU6s4YA9D5HhDW6fTGWn9KOEaA0JOPOyfZZal9yTa+dpXtG5+UmZx7AB/FFXaC1NfsPC7FbP2q +46NjJIBG89ELQ2+/PCQQTADCXHZ07R7UD/Hbs62BbHpncz871IgwOnNUvllWk68i1qHk3BH7zWK9 +0IKRiO4PpBLsv9Xl+anpMY9hoMnwCrLqC4tnrFVGdR+2gbtEZDR5kBltXZ0DTZFFeEmtyVe4D+wE +T534DLMPF0FSGbvOe/Yhj6yXQLDeSNRvt8ftolXQkfXCfgvTHAfAVDieouoT9ktJF/ZXzlaGVs5j +DGnuHm2N27nsOUOB5UHkT7iNRl/eTE9v384775tFfbKeHR+b1Bl3FBliksZyFY0tc+V48ZAbIPT1 +A/ta7bqKJSU7N9nvIeebmGa/yhul6+zoxkrcvtOIsrtnA/Cimti/alyTTKno/TfJ+/7YGxsDtbza +IK7Idt8Ywxyp84Xo3O72TmL/8UBxXzBaM712X2mxeyx5z2ZZ1bOvN4fi/lzB9uz8XmqzlBuwNtxg +BwVGIxavzxQzV/XVKW/cMNvlh4/OM4XXa/3J+4lhjzubDw2X9M7S1jHb7orNgCn0ZjuArrXCBXN9 +yTZydfyBseNrWzZK+qY5cpwdfmyUUXn/mGTyCBPIbaI7trofjTFyOp2pJt+82VlOr5V22+n10dEs +GILWSGWeqBbukWPKtIfX+oyh7XwtMrUOzkZgbjmH2xwoAfZNJnbHL9mdWbyX7cR5/bEtrZ2uzHsd +C8azFPOzWxdXALTs6wvlHjBNNY2Kr+wItVBOCpSXgDEk3Z2yu+J4NH093BjQ2xvthexldXrG1rhy +MXnDtqMFEkF09mJiH1ThE+LeqGM1lTEJkUIiMjJSj8tHGzOJ2EqrDQZUxuutFY6XW2PH/emN9fOH +dHn+ot+xaa8j7M6+bjAycgYXgT57tT3czedxJoCtrmYv2+dT2eWRct5pirBYNENo2BkGJeTC8tRt +jI05ubLyKpY/y1zlE0fpG224IlAyk4gZ9MskXXRn823J4I6gASZ1ezr/kE3sLEO229nN1mPdqU3U +9Qc5vpcupgp36fHKTDE6r2bKmVfXaxlTpYlN9tnZ38/CXVVIxKam+0FxskLX76K+8yqaf706k00/ +JjIANEYmdxknMjKVztYSm+xSzY8l7+bmpzjbInR5w4jd/mO+ZFmxHf3u9ie1sexMpjSbvnGSTt4g +P8AhzcF3kNir517riw9jd3bBmkF6ITkyn8tMnif72LfKvaXSRXix2/iswj4bX09fHZf32JlbBA3U +ysll4zUSTFM89IG+uUFcubjAyPlUdkBv7q4uMYZoiRHsjYekfU67o21AqXkA2sFOaYad2oPJ7JA8 +ygTs3b3J9HrfteRu35D1w4frBN4Q2aFcdNav88fs8KubWvq6fj6BWiZTc+sU2QzKn4yBVjm/8jjd +uEhsvBqLWSgAttCRTPGx/yK2varm4+rk+lz2cvJw1jEg7wVI53Y+U3dd5faOXqdubrMjYPyLefWR +2G7oK4n6Q2sGbN3b6fPKyYBtv4AUoOzJqMHseuFw0wKBQ97eZbzxZnZkZSi7em/KTUyCOhqcTq9P +DGj2oavtwUzxarIEUs0Sf3bfP4xajo2VS2Dk5h068vPo8tzF1GMin4peMsm0xATxmalCop4oZy1a +RR2po4m55bnzg2S0tpaX0+c350piv7o8Y3T1Oo73TYkdxMo8W7ODS81kh1dyDctHY7pvOH6o6+uV +Gz0/dfJKyfRNJWdua6XCYPzmqMkmuwox10k5Vek7HclMjBcf0tLgVA3vezB69aXGZSYy3PczYeDg +agU0rkOy+n8uWl5FCkT+9G43wBeu1ZvG1E3O8C1X5HfNdF2PyqqV4kToypbygVfQ20lne8+UqPy1 +M0VXz9kPnf0ngWtvnb4Rgwvt3dlCZJ4Sl1Sp3VVb7emiLSWH4VW1VrvrhVzcgjuVZ7gwZXnCcFdX +4FpcDKpssFZV0T/LBc3b+tdWKyWPEMD9wtvy5mO1XWlUywkheK0TCEZPbVUIe182Ggm2hm3lJWU/ +gvwEtfYOObXBlzv1asX0e/d06ewuHNjrcxnGN5LP2FYKGWjYwlKFBuWhqZTdGY+8utqs1+rF22b9 +vpyuf61GmWLd0breHUSgAyOsLMDL0QBbvlloNDq1xFmhb2HScv8OAoYZLhmiLeUzqwQGJBpts2xz +jspXkOHDOMxffOOH73/w39/9zR/02nHs3ff+87uf/+DD7/5Tr3XY3//pH/zqF3///oe/++FH/4Zw +kP377q9/9L+/8bvvfvFPn//8b979+Ke/+sfvvPvWf3j/e998/z9/51e//H8/fP+n73/+l9Rstvf9 +f/ird//rj7743X/z+X/+nXe//1167xj2wz/89PN//u/v/+v33//Hb/3vb/wO/fLFj7/BPvjwy79+ +982/Ysc7jRE/vR9+/u33//bfQ4WwP/g264ZCo/6/f/6j99/6U1zPj371j999/4/ffP9XP6Je2KTf +//gbbHzW+ItvfJ8tg807+AwZe8xGLDYrjU4RLI4N2evg1G5hBfl+M5IQYv/2yjeQNC4wgsAxjaQ9 +kKxz83xgZIR5VAs35bXg4Aijab5ZubfPOIgC7bcL7CpslkLPNmfFJCiKD2myjp5FC9Ygxi5xVX8b +MmSlA4k0pqDpnaaQZ184cyd1oqYeaZS8Ihbs2FRoVxxZu4Kwb6VZ+MyCy0bFzJUhBxLY/cerVrmd +rdfaexD5EgoAMFS49SOsD1pl9I/OC9FS/qSNYJa3pY8LAwCAcqFdzt8+3l/VCpWqgaidlpKyYjZs +YPOZYGCqrcCTRuG+cIJsCX1CousexSZ9thU6WNhG8NjFW+iCe7B94eAYujpZqXqt5IgT9AkLE4nL +UTk0sXXQATu+B6yNH/W1WpFdVOICfT7snLzNMzDKvP8xPjbLWBh2L3yt3rxLdgqN98FNnmQuOBYo +fPJL7xAcH/CGZbl8ebaQ+4PDpjBix7U93UHZdqFEAlcKsw24T2yZYEQ4h8lL2lXcjkD/INsQZiKx +HdyO95I3MQvebOfVEXavQyYBehrZWCuxi7lyXTETKnS3++FZNifInGcsmBNxQs2FOJFQJ8Rnu0II +V4lis35VaOcKn5WbTyNEFofIBG7WgpAtZUqbouC7f7hybCoYDNaFPWTfFSu2iEfFepWpsX13X/rs +TTqfFhYLze+vGLuNJ0rUdbC3kO12o9wU0ZK9AfbFdqnaZwxJcrZrOwV7wLHtJds6K11LxOoRa5o5 +Eu85BoNMgc4TYva5c3PtMRKKXphasFFwydC8U2LF2ha45jz0B7a6zUL1MdhnKksGazZe9vwWIoD9 +kXeA2cSi9jo6sXR4NSPNTGxOTSzdtlX4TYnM786q5otd8zd8Macu5dvJ9HV85W51YG+hkL6WThbN +t8rEwp5+2zfSyD/0Td6+Ad1n30RxeqxvUslu9U08zsp9Uwl1u2+oLGfg2Urf5Njy/rSaiz1OLO4M +38vjiYWG1pca24201MHQQ7NhvEaHoYf6Ji9LpzDWft/oamsS/jxhA8b7JhYXGkN8GLb0xcbYfIPB +ZP0+srT9elFaLewl+W+v15fYizQ4K03PtLQH9sd+w9XqspxqxbK1vDIaPxmUSsNyDRaybU2seda6 +ifG1rvQNR1pKaxP7ZZ3GVtSjuYFr9udKlQ3DPj9JG6vPtZrNudar5vnczrY0E9kfxfnaR12RzyLH +t7lJz1HPb5KrXqPSamIruvJmpg8H9hj1qnkxM3HkPepWcmzgoFHNeY3aGrjQkzgqYppruauLu9Ha +ofeokbHjibni9qbXqM3H17Oj40Pzfa+FUWEYGFjKSkvzPkDWBwZjc9dxn1FPzqRsPrnrudb+bGN2 +aLuyuUd741qutDJQz/mOOrKei2z6QfigeVZU1mHUMWtUGIZvbf+ROqS1R9iXkbpra2cHF43DMzIi +IFQkH12p4qjsVF1lnKOeN88Pr3A1zoGNUWcvtYPSzYznqBdT+S3fUaMz1/sjwqg4DA483zfWbM1O +tLxH3YleGGjsGrU1sngi+4yq3Y6NJMsrRNM8lhsZO5+Yn7vf8xy1P1vQBh70x02vUQ== + + + pezGblIYlYbhWzukxbQln1FPLqVsPZ/3HnVlcGE4V7498Bx1ZTcGXqt+QF4dnuqbvqVRM2d3Wfuo +8/1jrZHlSYTwuGvU1ct77WG8IbFRo0hntx2kU8qtbZ3zUU+mRgU0jmrT06+8R428Skq5+92o96hr +/UAFYrmTYswa2DbqdrW86jvqxvRDY9Jn1NMJaT/38GiN2oNx0+bAG+pFLptd6vMcNb9WWfMddX9T +z7/2GzUNCH0oXcS9l5ubGsiXLsfnPEc9vFho+Y56OFq+bFijAqY5Bt6UjqaWkj6jZiaOlmPNlOeo +rybzF76jsmHe9OdzSZ/lnunSeeH1hPeoWweVu9mhrUnPUS8uji+tUWFvnAPXy0ujN36jbkqvM7m0 +96jZA7n/uL275jUqG6bZ3Joa4ANfqWPC4ZmIj2dUGrXQ315xHJ6+2eajmpJg1EnXqNsLow8XmeNl +NupCk0x69oEnZusnk3zUu/i4MOrQ9Wk/Xe9K8kRecxKKPSmzdboCo04Jo7Jh2EW7NTVYU+d22MCp +tgjkTObNNI26NJqZFOjiSGmCkyd1cDa14SSK5YmF2NYpjDqDmCZe7/pQ/8LJ6iobdb1PGLVPSW7f +8lFnd6eFtb6pL2TuaNSlg1zOGhX3Zr6P/XhzW8eLljFXOyn7tJT2fZ8yW7vyefs43KeW7hvebyNj +7PAsamV+rXk1aDKM2Kz4vD3ZkTLz2xl66+IPXi1IuWVVwbdI7MXj+WpJyu0tRawGzrcJKVfa0P3e +pqTNvqOY11sEWuRVRtouru35fX4p7afu2j5vTyel/cOBPr+301J+eXPUAJpHA0066HuY9n473yc1 +H/ui/K2bVq5Khwd9C/QWjpuLpq1LhzdTS1YD59ucdDQYT/i93ZKO9EzK6y0B7XRHejUQPff7/I10 +fvxq3OftWVQ6f3M96fc2Ll0czKkm0NwNlqVL/TLu8/ayKU+Pb2g+bwujcvy1sukPtKsBOTl8kfX5 +/Gpf3tjtX/d5W6zLW3dKxR9opTH55M3GsPfn2kUtPzfffuX9Vmnt9I2MrW/hW2VkcXTV+TbRN726 +vGgAzUUIlXa1bz6y/sb2NjU1vmeX0UZL+YlkvbVFpIgkuMjkHpCnJMO+chKp0GJ8dfCNwafZhIfm +kjy0PNMeSWXzS9GT9KvsST79KjM/zZ5J2VRyuphKJWc2Juzy3euhKkxHpQFtQw+oIygtcjFqFUSh +U4sQzmzGaiPSzMLxI5yRU0Yrr+dNcXZgprJwNcbOUn+mFdud3XHQ3ma/MrKwM0V3CshBTj7NHBgJ +PIhCde9RIyfH/qP2Z0szXqNaYhQThWxE3z4q43qZKFTwG/V1wKgrU3Enn1YaHh6wlouygTmq6hg1 +tgqywZwx6krVAeH+Ufuokf1BHJUNgwMzqVGeti3XOSrKBj6j6gMgG5x5jxo5oX21jqcxsAHke8V3 +VJQNfEcF2aAkjIrnhg9c9louR6it3WP/UYHR8IUwcBmXNj5NXO6ua2sHZif5+PgbR/fZEO04LzAX +qsvIWS5cu7Edakd0Q8npNtJpqKhshzj7yETykdOUpcxB5o7ojAFc6+wvy5MH8qT549SS6Q0GCkDb +sB+s1xM16GPPpk9b3BmuwwSBVd9fttMoGH9dGxrCH7ClR3bumM6N7VCyGaVBPMxiK0FZtRhfOdhh +fw4P8R+FYxs3zXVsxglmjU/Tcua8hUyoahIb26QXM0P8x+RmnQBEsoRBnK01MDxMOWBoB31y5rac +HoIfIHgoI0vSWvC0zCaq95wmM5P0g4OUlDM2BSKpHwjwjyEAjz/4ClH29lzhTp+wQhNojkXijz1h +G8U9ZDz0Zqc9vHwcx7mTBirqpSUl1DJ32gde4faQSOfcRJfw8seIuUmvrlDR1RHtXTi/ctIIgV8W +ctmPp4hf0rXcfxIW+sGgtyP0s6AP8JJ8QQ9A6wgvJxWarruo0MlkwzGCuX5jO4xhOu9IBhayYuvD +nLSDCo0NI276Hs+TyXbwjJDU4w8OPtS1eoAvc3bYJxDxzseTRBuPxS3JG7mwi+MU2o0eJ1MDwYuj +H+Wd6WEyRXiCeWXnHtdlZzlUj3UN07q8cf4iI5Vbd0chlkTH07VlFgZZd4ZoNbKh+8rGsMDIO7Yq +jeqHF4DNpf/FLZXbBzAMxyAToUmC8eztqhXcm29XHAWcB1BuuA7glfIQYtW+p8+O0FlQOa0FbOjl +4whjAjcnTfI06oMbhaxy/pjcsLbUzkA5dhV+8OmTBtuNIGyFTnroQJDJ5CifE/thJ50TvnOTrlPT +pz7L3N714s6cO9wQFF2vIw+ubbmLNYMvvRBUyLjW2NKOW343lT836YGRKyKJhWvKEHG73eTSilwY +HFkNy1TZjV7uTb6L93WC18LVaIg5AQokX8XXvadlziiQ1zPnNBB0e1o7GOIyYSC9GwzkNgY6SQT2 +bezA63Wxh1K5cHlgGL1eoLc35UPfrsgg2U1vzgsm5MSs29PZ2/XIw/ELLRO4vZcD2vXs6KuXA5pA +3boGGteEGTqb9uKDIN0qyeMLX3rkyTlbk3XYb9iMbladl38Qr+t9Z6+CeWY1mKbZuW9PBoIt6a7/ +pY7nKhhRNroRp8d8dvNmVR2c28hxXeeTARRSMuQMlB+ALqdD6xv8VoPkIfjchNmqS3+pxpoJUujA +yXSgB6Fmoohc55PAEkgAcCacCpjy4+yD953VXmwFXH9ewiPaNo3FsWE4GpkeXTAtVIUbM3qzxuhB +IRN+BLf6w+Rszls1UQMSSEn8DsqbNS9exBIKw03LmFN7oCtSYLlauc7e2ouRgjdrbBikBs8BPF9h +e2LEd4VwbroBPDIQXWg+OJuPF4ETeZdG0215PPkm+wIrbN0qNq4znILUR3RnEtHK2UMwlnKghYJX +58PuBS9cplOMAnh1edgd8HKe9GnrpNtuz/t152H3Ec476qLUwdn+/lDKlEClw/16gCjoo8j1U6Ys +yaRR6KQw6KzIZYuTR5B0eov6oRenLh3mN4NhTZ6QAboQdTD+ID1XEbJOwxzWn70k8ZZ16hTwIgjS +6xlbtf7oJPDdKYmM+wZgo3WnLvHR7ax76Xa8EXrAWyXhZLOXZnfaAputLh0MifpH00u1M6ft2IfG +Rvc6NkHLQTOSg5Hck0v2AN+GdS/arLhe6sMQV2Njw3kvPvHcLB0sjD0T3RsbgGnChdiNGpuj++xu +n/MiFJeEq+moFgUMijyHFHBM23DdgE+CjXjzmYAB0ul9+fmwuQAg583X8V5ibK7FcrguvxE29MCI +zajLfkuxZ6P3nVctnj5P9cPx/nOsG3xdKzv31vXHiU2YG9C/N6eW1vfchNDSst5CnMKOFBoOj/zc +2wt2bmzUqxe3pbBzR+PdT8dlYceOJl5kXTYLqCBJd9nRVNiL0HSJ97kLsbfpZ1yrJtAMjnhszC12 +HudfxjxBxIb1JkhmT75+YGJuq1FnS6EvNEvDykxYxtTkOp1yvEDdmGijjQnUjT2bDcHeEXXjGig/ +9uL44CWo26Hb9P0M6nZY96Vu1u0Z1gbFeuueurkZKFBoq8+mAmDXH38JKuB2qAjoxVINeXcUhpx0 +ns70C1hxsSPnCbLL/jO39YkFBBrhkrcmzLlpE0E2JZsFckZgXEyWg7uS8SMDQtG46DPGnoXZjFAe +XSn2bs3XkB2SYzs+FCiuQ5nSrZ2D9RaS4hr+AoFE97ArhwqvU00SwUkjhNAdzGbjzjkdpvyJTceO +ghl/316s29Ps6LleFdSLU+z2NeR37KgrnyYEmt95xN6eoeS2LkeuIB5hd/HKhHg/FvpzIWSezrL3 +MTFQz78fz4L8IAxWPfT9yHrrzP17XY4emlvo7TncP99XuV97kWut0L/5Mtca6ygMX9t5Oi/hnIQd +ddDsmU59HTuSg+/H4MtRIDZy/9QT70fvy3F2dBIvR2GY2dEuhQwfR8MUm8lp2zraTvOq6JpluXb4 +0qPZUX+R1YKmeTw7mPCYLPEcJlig0NDb086518SsQ+6rfgiivE6g6SF207TiBopMbEMPQ4uzAULh +caDOu4PHnsecRLRwIHSIcyaIcUry+GRKuKZczhgh9NC+N9VJ0DXlco3rqBdgc7v11GB3dchMnc11 +arqD8BTWGwu6Eu0ATmLTjfkHeguDy+GUKUrypH+4G77D09GRI/SJ5ewbojefY3/V8vX0pWHsmNHR +/xLn5K9N9jxkEEfgoTGyLjhpJnvpidV8HzBub3H7dqV6WLhMD5QeM9n44PJFNr+4k7Fi+dgwLxPO +FxzL10NBS88P53OPao/lM6y4zw7nC47l68HQxRcI5zNQyzuWz7xvnhvOFxzL18NDF58dzuc1qhXL +1+Mduth9OF9wLF8PD118djhfcCyfneV4VjhfcCyf4XP77HA+DzcOWywfajleIpxPoFYG8eCxfAKf +1jGcz+kAHRCA5/SgCeN57x+M9BB2Th0UxGxanXzFN+shgraQpjmtAE92vD1NOxlj25y6VxDvjHTl +vx5gKTxNOxVSTwWVV5iP25XNIZQFxQN2dvkTLYUBvXXy8gpaoZ25DRHEF3qFAoJ6nZvQgL8MDly1 +zamnUyBmJ0VXwJwaAg/9pPi9cGTnIoPaRrsk/bQwru12CP8SuNY6uphknm3gs7nBXWSerd5iizsb +8Fqcy52nY9jdk/xLBISGsLunaZodS0qLKhk/MapT2F2X/iWepJPBxs/FpFspBbpKTZsi7lN6E+Io +rpS6wFZYGmZrb9wYH4p+XSmPISRjg4HqEPda6L8UXTU7mLKdnrM9zpjCjhGVYRVtoLZUghTEDo2K +j6LNqWsEJnjSqVFZAcBkBJeRpwf3BFx1jmA0m4LYNx4t1u7EY3QTU3jx2H3Ai8fhXfFiyIT4G/Do +sum4/GPkyr5BOJ5sdoDn/UqQ5/32nhUzGi6msJPnffiYQv9wEUN530VMoaD1DIURDjc4Z28dIny6 +mZjL4vGs3jqnMeimN3/bx1OAprzcMtVnAs2pL6aElw4nqptVZOR7AgPKQrG5q16hxMKZJ4tHl6F7 +3nTDtwNGe4SLwNUHnnO54zm/WfWVBwWf2xDyYHup40YafLXQQY8ZtNReGn5iH1YwmOSXx8Vajbnd +fmAJDuoN3iXO3K66DCsBQpFvsJ3/ubWoQEeIhFZE+GrVOwfsCfedDz8DS4p4LcnhpeoUwIJCCEbT +TTFS97x10/aFeo8ZtGTjMH0Qml2mXSk4bLJUjxDy6x2r50+A/MOyXM5JT+bT3qwFn32nlqMjqEKf +W18XJ8K0N2vd6YICIticViADD+yyZ0g86Byj556T4QnpnlZX2pugOQFKdXOtBYCqk/YGvVTDTas7 +7Y1jTq4sIwttUXsDYVHP1t4Qpt2vP9tdTB2cHR30lRsNYhNSqlh/ovbGUy9wv/5s7Q1bXGQ0wGUk +fDxcN9qbHt/QxfXHZ2tvIBhOFYNknxIrGFZ7w1EgKFbQX3sTPjoIzw0DUPcBQn6M9A== + + + jJuRpkivDqGxoRjpjWDXwJ6QEZKzux0czIIlB4faTl06iI48RwNkW5zTS9fLgzjU4sa68p7zvm82 +QjpDdApjM50heoJDFzuG+IWkuD0BeTkgxC9MRGvgCd7AS68nTABzB7cTHufnn1/LjtB+J1lwB2QE +c0Q0yLJnHTCCO451Nl08LzLPktYcwXndu+05PG5ckXlhrLgvEJkXhGkvGJn3Es6wISLzwjnDPjsy +j/PQYnDeM9bl6crY4wpdDOGE2H1kno+rlcGEvlRknp1Cu8LpXi4yj2I8/A0QLxSZ594bu9vgi0Xm ++UtrfnahlcP6SwT+w5XXISQxtOsl60oOyXWGcL1kvSkvQQUYzPdDGL38WQPucHnwEjwG9uLth9yd +sRg7corY4aYj6mywo2enAMBe7Icx2PO+I3ULTnAset6HcrFmXPriuHgeM2epYBjSYbRda77n8eT5 +yW4BaNcjnXK8hHeFHnnwPEHBNM3XFXrkobsAV29WPeXrLdFl/OKLpDrGjkLlwukg4mJHTzmPQi90 +rT3/PB4GX449nqnAfB27D105cTqlc5sQdDaCywRbocthCZ49TezucQfJFvr3fPMzh4Xh0YsGyR69 +aJDs0QsFyZ49vECQrNw/9TJBsqyjlwmShY6eHyQLvbxIkCyE0YVLdG33HfQNI2MHJSAVbHj/JdOd +B2iF+zxeNl9EDZYirfqpr//fCwXlGddaGF8h5zK7ku57ArNdv1hQniHfhBLwnx6U9yTZs/ugPE/l +/csH5QWpH14wKK+TPi2kBHfVCqBRjChwa5TgzBQUfeX0uQiZ/d6HT3MlTn5ySjjo6mEwlBIyhOIZ +emv7d9UlZ3MiplAOaZno8QqVh3C6EDagoMzDQNhnrDuwxyMWt3PUtTAnoYCNB1pwt+vg68KSrpOY +g8RjQHuR99G9wSiUWd/vY2xUrm8qNgWlw/rGN+bkvsn03lHf5OHFPpRbz/eN5xM6/LYDTVN9UxuX +mjRzfBfll9NC/c4+aUM/5SyhZ4sI45pbR9jdzoxkh7QjAK41Mli3l4l1ht2NXg3u3fkG+0XGzoLC +7i6mfEeVskl922dUfcCKzTIcLp3hWRdBYXd9mv+oKyvNE3NU1aNOoX8A3HzfeUBZud3lPduoQgm9 +uerBlp3lUMXYxuWj8YZfKNpJUNjdjeQ1ao9Zp/B81T/Yb+hu5vDKb9RCwKgr0qyT6xRjG2/WB3xH +7Tsb0A/8IDwZGOzXn10bFrYWzu0Ujo+/GUGBj6VQ7bYHyoIHsV/T/u2FvhBdNh8v74ZslymsWmBR +UZ9mHGL2+eSocMcG6Zw7+/e6mdud4XvRP1/Uwz45uKjR0a/TpWDxr+m17J+L2tOjy39aHUvU+NjP +RO3gC5TXM+dkc2gxaNoTdcNe5fWeqLbbGel/dnAmKYhP053ypQu+gwG13TzL6gWr7bqtrOe7Qn/7 +DdTC61RoJewKXdngnhwVG6rGSthpdSg/0cW5ka5zkbNQoLLbLTpU5cNz87KBfc/U2YQN7POSElxq +u+cH9lmLC5vP5kmBfV5aRP9z8+TAPvuMjag+u2HlhQL7vKgwDPPCgX1egEGLx8sG9nl11RMymUkX +gX1BnpAvGNjnZedxW3GfHdhnNrZF9XkbVp4V2Oelkunxym33vMA+L29xS5nyYoF9IXJ0vURgn1dU +HxdxXzKwz+tyMnU2LxfY5zUnbvp+ycA+r6g+y6PrxQL7vPaQNLcvGtjnYyx+6cC+EBErLxHY9xSg +PSGwLwBoLxnY90yghQ3sCxnp9dzAPq9wrx5b1PcLBfZ5ddBj1op4scA+L2OLn+f9MwL7vKL6fETc +5wT2eYWxeRpWnhfY5xXV53PfPCewzwscXlr1Zwb2eUX19XgGlD0rsM9rSZxV9+NXYVrPlxFnW3wY +R/jQaLoj39ExUI0C+kwZ0aQCT42+Ckc3LJbjxar4BbAcL1nFLwzLEQ5UHWsAO1CVwanHJ4b9vHXr +ny2/KzzA0IieDuHY4rT85tTh+nU5+AeV3HPatrqZk8NlBKYV+mB3mpNDCg1BbAJApXdBbHxFJnUw +fjfjFJnWRZHJ7djkqTNzy55e9f+6D54TXDC8/GxC8uvdFP/rSGyw/t+zF8eGebaXVYjif6H8odef +Xfyvh4eVBtf/e3bxvy6UkM8p/udSQnrW/wsfL+VT/K9HiMLzrv/XnfmJXRMDwqp7npCja+MlYzwa +Gy+Uk5wt7iWiiTZC+HcQhe4U0+fr4diFdzds/LOrBG0EexrbHWA6lu3z9wwJHR6HFfs6ONCFc1ID +6ETDIXRwvTGDFxgbdYvTEBTovvkMaa0rOxZo9buLL/NxtWJTjQTr0kO7WhkSwcu4WmFugudjGoN5 +GC+rMIGYL2BJwV7cWc8FFAjZUdd3oKfjGHT09KNo78WQc3sCA5hDlJvH3oKifS3SGTba90151BXt ++6bcwRo1Ez69IfQWqj6yn4eBk9iw3sZDETbbZeYLzf2aBc3gvbELm0HGKcbFuV22D23pfH3tnuG8 +tl3+KE8MjDl40eKOBy8XQnrgFULxBCpwWO+euXeLUViL7tk8BvYS7D7aTUcvkMaAOnpGhW+rlx6x +hmSXxYiEg+IXQvFEYzHjydznkT3zC6HoUnn/1Lp/omeKq/TfM0KaDl+y1neoun+dWfUXqfvXQ4GY +/qX/wof+BNX960LEfU7dP+e15lH674nrEg6jl84mbHRKF3X/esLVxX1S3b/Q6dtXzh5eJL4sMGKl +y2hfud9ftDRVQ6GjfeX+J9SXdylTAOZl/9Rh4QMxHaH3dh+orjsKr/zy13JgR8+P9j1CRAolrXXu +yD+3HbnsGDx0mOh7l9dO+CqCBtDEWCq31w6EbB0E32j+ajCB2LDVB8dSdRNIdWzZqjyvtYBYKi9o +slGvOmj7jPibMLFUIwu3IXwSPaV79/Fkvd2FOJ4hAqmOLRH/+bLnZTOEnG+XPX0I7OzodEA8cTiO +0aZ+YNPqHEvVBcd41fr/27uO5WSWLL3/I3gHQCBMURYQRghvJQRyIJDBIyQhgYSZO3cW/RizmuW8 +wDxUv8ekKZNVVBWF6cVETP8duuVIc/LkyZPH5KdojEQ14PFR8m6FbGu01gwuGcuxa95tjtkSyqd7 +5r1JZtrBp2qpiHY0MMzBUpN0e4hmk2O0Jk1De6bkXjVDXexaP/PJYKK2cajV0fJuQZtMTxmxnHer +TONk+HqmW6E4CNXlYiGsXChbEFTjoC9jbZhq+AD/pB3UkLmEKYY5lGfIBKsxlzx8pxqiiVeqHLnF +kncvyIl6EvTgsZGg6ZxCPKYPiJdwnhpm5i3WPcY4H5BKCJNbtYTWQNMZoQ7CbLUnsyzET15TKw6D +kxMR32r3hrWe8pfdoVGtI5N8wFr2Xm3lUOfILU/ex0aZedFy8tf1LfdVk5nn0+YDivECMpEvBMNa +uWKMqxnUenbiuvsWOkb5gK+gGrNExGXIuNZSoNc0rNUz9kbelVphb1QpgYxZrVWPYa2LZSPpMKwV +zpv0K/2gGtpxTOo4uhIHw5d7Gn1b+a6z/p5pvpNkmurTs5PfTqFV31pk+F3kPnHhhCk6LxmNOkoE +WXi/NywwxfXCeM2SVz6L0ZleqTcqj9JzfhuEmlV0sRtPUeP02haNZILKp1KHddtkUyEwGzfLasCn +ga9MWgjA4BXNzxCy6uXK60Vt6VpuLdidnvNbEWDI4YOquiGpdgvcMslD82vtAvunx5lGgtqUM4gt +cZXWcWaxhzoZK6CTWwPhrSYASjq54byxTngr4XKkHdqsWcZH9Ow6b86Nw2hFKm3G4apFl87hnp3C +BmLMnjuNgoVzdi1YbtuB1cG2MJlohZem+abbqhO8cBw3UZvWxursY08rHOMQSpiPqJrGtr3O7kYp +ibsYQQ2iVGFK4pYjSLcHxRR2ylvbtqspmMaAWbOnqUNR+E3n0ED43cbuFoVNv3jEnfQg6LQyGBay +9PvOa+1BXSpXxI4HdQF6mRz8r7LxkUQzs8BMoz9aXB2tTdJMSZHUQZM8O0ml21wDrCe0YYfkqLRV +pbOa0BZd6y0ntj0zvQZWjmJQ2mSYfzONGR/FYEFVV7Xp/URjVd8rL1FMSlSLf93zBSyDRm5F/dEf +Q72ooWl0sTVVyDJHLKygx1kvzRxIyKaX8mtW2n6Mb0C0rdlE1htGpvkcoTRTD+iuRDPJjNvIYlY7 +iw9JSbSqNtpk9Li9UhLl6bklH1H2EeyXkmg1H5FQB/dJSdQfw818xM1g2J1SEs03WYa+tV1TEjfF +nn4+omHMrbWURKv5iCqi7Z6SaDUf0WaQ6WVIkf2ABjd30julJFrNR9TdSdcb+v3aH6zQtjtI3T5g +hTa9JNnjgxWamB+OCVYoRw1tJdVBYIXE9PxXghWSDsl/IVihDR2hZ9isY4EVwmqOxFVmYIW2nfA9 +9wYr3DA/wGaNDWFH07g52zKWN9AObSKs2zFOtTJBO9wh2s4c8HDHU632BTzU69wxTrXSAB7uGwO1 +I+ChPm9KaIfmRkhLCYBW8qpsW061sgx4uDXf8ziAh+ZohxqG3h/w0DzcxPbHqh14C+Ch9YSyI8VE +6qEdbqw3+wIemnfOyMqxM+ChPpmPAn5CAh6ad8kmQlIYdcky4KHxDIZoh1uDYa0CHprPYGX1PBDw +0HwaK1kRBwIemq98hJ52GOChkvilZ03W7m/2Bjw03w9jV8QRAA9NUkn63e1h11YBD4+QkW8F8NA6 +TuFBgIdyKbpohyoD8SGAh+bJvKTKcRDgoTnaoW4sxz6Ah0aBdhjtUKrm0OyYB+uATgcBHpr4eYBa +oXLhHQJ4aB7irWe53QvwcGPuq9AO1WOze8rFWAI83K51HgXw0JoUOBjwMGmKdkjabA4CPNwxb21f +wENztMO9U0m0gId6KReKf3hraK9VwENzNZ+03B4EeGh+8giOID4C4KE52qE0b6ynQBkAHpr7rg3C +EnYHPNQdV/kI6YNUdRLw0LwUmwWcwsPO/0kqOIVHADw033HbLB8xsQl4aA2iUF/Y7At4qB9mIKEd +ahwr+wMeaplMjXa4t0zTAh6aKz9iNYcDHporPzj64QiAh5Qp2uEO1kFzwMOdcnH3BzzUlqIWxYYZ +K7sCHu4V0aUDeHhAqj7KkDwO4KE0H/XRDtHe8yiJV6Zoh8gIeQzAQ/MgKsM4m10BD81294hoR0u8 +MkE7tGbrVBNNF/Bwr73n7oCHOvKQQDs8QohibvNUbLOj9Q8DPNyavXocwEPzJN2NRXpfwENdaspo +hyZ62m6Ah5aMkIcDHu6o2ewLeKg3mooDyGYl5dcK4KEpW5CATocBHpqvFWoXHnR5bi4X45XJWiEu +ExthJGpzMFrWGnFWaxEGz0wmtnm8vyaJErIUKdN+NCYvMEA3OUUAqExk1IwkAspPkPOw+s5ZTiSp +VJSi2XTHucUiefeRZleJywwffbwXPElnHn0Fs7rK1MNNf+Fwv1CnDmg1cng65XcHcw== + + + 8ZmhzpO/MSpxftemHj6mc65Q+GS5wicd54pXt3muOP+oQqKVbmM0V63Uulz1+23C1b/G79z9dTDG +PVQ+mlxj+f7GNbnVF9fsXKy5R7rp5Z4CDR/3OnDWuU6n9cZ174Irrhdsebjetfd2sVgU2MXyZX6+ +WPOz5mLdjcKw66Uncgr1hLsVzDb10B+jcr1ci72lm69PE4f/1N26cUXPv7Lum/vS5en71O10xtia +9+Rr6K6EYqf1wWcrn/BLSYmOdeAnVOuhYcEwgJniAxQ2bs41HoHHN3NdcSKODUp5XS5hgmvVQWfb +IQIgU0RYjGf16AWIFQ9BojW59S/XS3R8i0WNpjTdJfsa8rWoRNCT5orZqyxXfBtecqV67Xt50jkb +wGRah1hh8rdAXURrzxxb7DpghiQUNlyhGeki/EOOrY8DmomlnkYqKMOe91ux0hKdU1YjmRI2CLwp +rE7jp/PpMpm6eHrP+e88C4f/9wT0of8bFVkW44YKFBSOLt6f489zH32Wh+3tps+rjgWierEgXEfB +1f0PH5hMkuCq+Yv29Gh/M3Uy6OdBV+x7xXFehkW3UPJ5xavPsR/8qOzDFb55fil4S4m3cS8Nb2nx +thoSCwCTfFUYTn9jqJpwhct8z6vLzNXj4ytXHlRaxa7v+YoPcLOe1NQrP5UPuNdFb7lS4QM590B+ +ESBfNPiR/IJRXsDIlMDkAtfJsckqUSHYFP1kRdqU4j4wGCc+buT1xqVnaUr+uMMXOvGE9KJIKy9Q +6DzqTanKYp2ILdU5aBamMPnYUkOAhfuBJFvFxDKA/IGfBMCfyAzcVmhJjKz9IjPcVBn0CaihtQS3 +dxzSOpcDHvwZwSctXG4w9TDD4yX4XIwPDSPHtisB+JYiWaBdZ1A1wWw0GD0fd3xvufezYj37FT2J +quPTZPhIXJraiqQx/oBy71gL5WoKld1EJuU2OKXcs8ZFPJdpnJ73cu+Rq5/MQ2b2CJaVakzIPvs7 +iHME37D1IfHBQ5AqNFtlUA0cqB453INqQB7BPpgtzDd4dsdAegVgYo4PX/WdTRpdgSG49+Or7FOw +DLWSNtD/ExV0hYYZscBgEoZfwR+5v8A0ajDwRCYeDGPUg16AwjNefNV35S7E5kz7gtycAaihkZJe +TELSRH0Kk70ZBFONIlQCe+Dd2ROdZ/uJ0/hk5mkUE4XQJ7G24ZWv1LoVzQT4z6nKsy1UEyRvrp6R +MQW0EjJgxo+vCi+XFL4iWr6aBNEzIdumCprmnD19l7/yb+7lQzqRaoUyVy3uBHzyGgZ6xC0WI6Ca +4OmH+xRNT7XGkCP1A0BNUkzKwk5HTCoyMte4nLSRjLRBBGYkJrXwyiwkxolX3F+BRUqcwfWxH08o +eeBhUvUXPJseIr6GOVRAMPVY6CPGg5KRwebushfz+Xg5hUHkZb8oA3knK+TpZwqIvYuANKpQQgK1 +CTzLMVBPa2ErA/jjEzcN4SKrMRxJYQlIfm4MLXqRDHnhroYhxVkyjjriJSVZMo1kBNSs7n7BbYXl +woOrFBKisDeEgP3JcfnLxJwDX9V5RfxhkwQeltKFnwd6EVxMahQaEaw2lToMXA1qeDXgSz9xGI9T +A38iTcjQud40MxZlWumOKBwwuWMN5Fzar94l6OtzpBKod7yhsuSqFmSsY6TBGh9dYwzv0/C8SOgi +6Jkzl3FKWtGyqTp2AhfgQwXYRARmx2ngo6Apg8q5UgXUNqQOCt5YO6ioxeiZ05lMlbiRe5ZfLC7m +flJTAOrl0lksuqWNB/qeGzvDrKaMVusmI5fx4SW0ZLR5w+wOx6Hwck4HT8+feSCj8gE4Sni7gZ4B +9mlCFsCPX5fdIPj5y1Li2+5KRf0Tj3KYh3xgBYTNjjlFtWlYv4azyrlxkgWQUZKbSMbE7hNnWoia +Y/jd5009v4KmhkrgBc9olHZpbNYORVlzhJbPp5Ke5mvZ0EkWsRMNNrek6QdmItGyPmi+xUcxlF8Z +52cDkIoq4nNMoO4kN+dLIT0+eQ+WDHuTyC/vZTq8kHRYP9dlOrTUdKAIIjwvggOJCGBbpBAh9zTq +ICJAdVB7skovsthKB7+LIEIq9zvfCGKHRBBrlQDSpWHZTgcMuoFqDUbqU5EIwpo3ZwbScssqc6Tl +mLMFTIdFtv2s0AHC078YMIPPTxDSnXD0FG7CnGalDOoQjsSrpy9g2A6LjaDNC5DGxrQM5sCp5ePI +6bnfiASssDaoRuHuTdYOBAzKsErNAKMSnYYdCaZvvV6xjH6qri6Dt9AIRE0UEq/fDkEq4+xEGZGl +s3SVU33H+pXvXLPg+Y10+M23sMFp3kM5zXcETmMPbQR/BE7zHYHT/BbKMC2AJjnNhFHIMrQdsUxN +E07jDhwRlpi3oBpDYpiWsZsUxMuatgz6wBFhGQ1f4cSYnViL3YO/JSOkXAZ3aEd4vQmCTEPWOyLs +2QhCh2aD2ydqOXRxnaNwGYtkOKhqhGC8JKgWaTNiCIFDGoFFp3AoawmMOVtYEZ2CFZXHbF0SOLUO +vc9kF3j1raC+DUosgFwyYOucXqKdrMb6XXxIxZ8Kiw7zlCmf1cq5/uTyExoYwopZA28K5TPN8PYh +WXr04r0J3HOCavC2k9ir1scz0YrXmtJCtzwKQEMAjbfpcF+ODBHivrzhRMYcj7RrBlfQnwtaHEK2 +HRgmlp5jI2QcmTU84h44nKbx7etyjDbHnqArkejhXf5bJz2RzYxeZJDBtkv1PluxMaIOwC2uvN9W +3gmeVDUpvSgyxIuOI9gVLaE/OaVCntiPl7K/cJmq+dW2zlLDKxtIa6SBtDQJyQbSGoOMGWCvnuaw +lbhMF+GErvF4Z1hO3cHbW9L0OphQkNNv0SGn6KuhKxIXN0+B6zke1SF9AefNLYtsIPwwVYG7xVux +3OFtA5ULT+VLnCDrJDyY0S3aLukQnIwPtIoFBF8qfQ6rOQ+mHlZ32S9m4s/cDN+q+auK417Z4Mtx +uDl1RLBeAFBW8JWLCVQotEAds9zb6oXc2Gx4deMal16fohNotrtfuz4KT6MbuAY88DLz9ITXdSct +GWg7QWmL/RBSqC/kU5GhNHyP2I4i5G9zUG48sqLNKPyIpcDgFSpBj7xk1HpEdrI5vArKVyFcRuH8 ++wzcPolFdoeID55Y6bdPnHzFqzhN6Akd2dL6FCSa2stPXeJEnX6GZfPlGd7fcT5XlBO+7t2FQMzX +SZ9zTRdFRH3KxhkJYEMyh53KsRSyjeeVsPMHT311SNdX8Kf9CNXhV16+Esjvrich+CykNAdKAalF +t8Ves53LU1FfsVi4bkZFy9bqO8yNB/EzJGJkefAEBVuEcOwgAws2IF60sYVTNvj6lViO8P2P+BWQ +X+C2veDGNyEvqMbLINuKbB30wMT7X+hsQd4VH7YsEs6W9pwRhVfa8YpEhhg1FEBHjyMbNfvRWjGY +Wz8CcQrJ76DrvHCpFxsaTDVrV9jmL/+BLxqidSEZ8SFBJdqhX0X/RfKCIoRe31n5Ac9yNDYuvi4H +0+yXc1bkA53IWBZnHLL/QePfSOOKgcxwjYiLE2OiPKYlkG7Q8DupY+mGrYmTECPKNCS6XGlWtFOW +6hzy6YC+TjJS4bIrRnT03obm/wCqQJQXInb0h71bf40X9cXH5GNmB8IOSAg2U+H5xmw0Ly7G44fx +v6/y8+H6ezxb2eN2NnOfq1Si4fx4OB+N7Vg6hnsKV9AiC4lOENJhrgqxxBIj/xYrTcsndxf9/BvX +ThK+E2RS8fw8/EJnKLSawgN/3Y5Ad/TsCAjFe4e3vAzA2zY2/CQvfjaj1LBQQ0Z6/0l+vMiuC9R1 +9VEj8pAeEus9lGAoTeExO75Ls8tJgi1nnq7yT8XmfZpdcXNkHhI96apkE3M3JrLPO3yJWshBs54m +PM0Ypg06XPko6wj40mn4+NJB3TprsIc1+CLloDPBkSNw3SpvuDvBQmbV3YnHZsPjeWx3J5qBmx7P +DXen4nCRJpU4o5Q+aKaV4ncBcwvOQEVlIJxGyQpLODkJ5tca7qGLqnThJ5ycRNWlXICc6B2y9lKF +ATQP+IVs6wUpTz4wxz/XyHqPp5xsuJcL76IQOPCsiLQqPxCM4yxiNxjbEcURO9UokB11ML43dRb7 +PmFIEbht8NjTiR2qN89B9vp+CpeqB4rQJbAjr11V3LM9qRrRMQWqseYqk4N0N1xlMSkMxMT1ZsNp +g5aLlCJFUJG+y+htLFoqpj3jh3xldOGQnKEtXtYNBI2O9NU9EZms3Q8Rrk2CyQZ17MsUJfagwYrc +P2hx/KBa8YGrZ15cmAYdIRmrCGC8Bn2k9Is3oxAqQxzf6R2N3Z0wMAnctiQH+PSZk646POHaJDTe +6ShIvIAaL+wNcuL2rn/dkgbxfWbJsYykgOytVv7gdU1xKK9aDDlvhiLLrDocX+LTcAnu89LVSHHK +DsXNweoztNGc8KpZ9PuS55Em7bwu9q7dyJGJcE9Pu8sId1miwlDjOBM1PugFteLIEqpxo7VCXA38 +r0XIAnBBaDkCzU4BSMjHlsNXe/KKQnQdv4ECtgwEa+rB4fv4Sjro2e0LFKwxvRPi/195+T+mvBAZ +18YOc8SPGwlW0mqP99/KSo1Yy1XohGV3563WRYM9njTpMh1Gr7QuU8fKu5TLuNlwmYb8JSZUznxr +3J2agLoEfa3YRjZdpmcnDnfWlZfKGKqCq1ABWZYogC+2SjwZ7JgVBQDgeGQlYT+SjQLSGCC7JRG7 +S8+av9Kz9oL9qM8oxTCAGE8hvRxS9iL6HMXgscT5953ijzRxRiJxhv1wyHwjnguvcsLxDCU74aBF +W+OPRNvWnf1wsjxQ7Oh72xnR4a+YDh2SCMhHLBLhiSQCaA4igk06rAKfVIrpkA4SdED2LZEOIVah +A2zOVCECjuw2IoLkq6dS8elMooPfrabDFhfcViJc4MCgrc5pY2bAYOpbPdNYudV3ysJYFJ/GsbuT +VxdKbT8qANvnLTHlRhm8k7LaCMlqulFG3Bs4rCM5hlamlk3BN9mlIyh6eYdYAZ3pGYit/IewNgyF +pDQF7Oqrh1GT9LaO9BM1pYDg8xcfVQXXo8Ag3Y5YpCZPuyo8KmDpLJWzFAnVAQ3yv8SnpeyvT/wU +orvIn7pDtXxv48CRwzgN4zYfwmnVEKMUYMxppmV00tzBnOZ59x7GadzMZ8RplsuoUoGtXEIWgHqh +4bROhDlkRGAgMKtXAOQ0q2WUqs7t81a/AJt4ZA3UBC0LQv1GdBh9asJG2BBUx9YRAarn1rlv1gjk +bfiJHzYiUOE1pyZeb8w6UqaLu82RjUacVXmkqh8wR8qpO2FLIxZJlicX6XJoxTQSRBmDjvuwJWEw +oSh5kTZth0kjfnhj1tI0gnRtku0YuiL0QWwxpC8YhZqk6NyyNJFlnOV0J7thI3RE5zBVSZG35Xqa +vL1tZMT8jjCP4m1pTcZPlHYMQ/kU1W3l1/1SNfd6GTuRQgKQp1HcduLA6MtvtRPEyw== + + + U9MIBMRqd6Rt5/VMsacpDiSwsf5ixCBl7Alqo4wEbN6R9uXirj3MeKQr3guteF5xFxyO+LFnFG+A +wxfY+wn69bxA8cnSz4qsvMXnNEHCnnfZ5nrlI1/EVn35BUW+qFKyX+uKJl+Qm212IxbZslN0J48o +lGn7OUV38ohiht7HKbqTRxSbHwJeI+elrj/UvEi98mx/DIo0cIXu6QeVbZ0WXaF7+kEl77ZVV+ie +flA4Nru4Qvf0g2JOs+4K3dMPKhrvLbtC9zQlIpm2gzVxT1OiFONi1Zq4pykRVLOTNXFPUyIyP+zi +CoUhEdDh2S3MRqSzEzx2g0f349X6B30S7mbHk49Ztf/3GCw3nJ1H/zjxXyRm54WoXQiHwU0YPqkO +bH+8//yv//zn//y3nffZqzA0qstmFqv8x3D1MZ/1F3/b4+hZ67raqOTtcbv4eRd8fm73glZxXfA9 +eOdDntYubGsX1p2x/eHtrb/gJfyrtO7mqz+EpHYXP77GD3//jON2oIU943bSvJ2GTl8mFoPuX9BW +eCW8Qk9wFN6fiQ+joZA9GowG8RX8B+jqzcdfXibzr/5s8vLSX8z/Y758eflrPHh5+fgGT5Z/L1fj +75eXN1Ax8zOb+KBm7q7Mhl/r0Ri2Jg5+L/5c/DX8Mfyt+FPpl7Y//xC7BOgvdihm9/rsrUfbn2pW +eYeGgqZ1RocnRgf+Fw4LGCHwf53BEXYbHMHC4HDi4NThH/xvCi/v5HsmGAP/C9mvMCvhp62/4d0l +uPq0h+1/2XnOfm1/fuXsIxt4CX4cO2P4swgYSC7MhO3fyoNQzF61/YmEwFMaDHAY3gX5zTv8w6q2 +JPBgQBQWZaIRVDwuULzfqODeaDjcN/3J+GHRBwMKBmOy7P/b2N6fzear/mr8A17ZJ4vxcjVfjO3L +9/lf8An8kfwDMPHqYCf0vyiNDlo= + + + diff --git a/src/web/tools/img/folder.svg b/src/web/tools/img/folder.svg new file mode 100644 index 0000000..fa93e24 --- /dev/null +++ b/src/web/tools/img/folder.svg @@ -0,0 +1,12 @@ + + + + + + + + + + + diff --git a/src/web/tools/img/icon.svg b/src/web/tools/img/icon.svg new file mode 100644 index 0000000..46e6582 --- /dev/null +++ b/src/web/tools/img/icon.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/src/web/tools/img/network.svg b/src/web/tools/img/network.svg new file mode 100644 index 0000000..fb47661 --- /dev/null +++ b/src/web/tools/img/network.svg @@ -0,0 +1,18 @@ + + + + + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/copy.svg b/src/web/tools/img/opr/copy.svg new file mode 100644 index 0000000..d93b7db --- /dev/null +++ b/src/web/tools/img/opr/copy.svg @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/delete.svg b/src/web/tools/img/opr/delete.svg new file mode 100644 index 0000000..dfa49b8 --- /dev/null +++ b/src/web/tools/img/opr/delete.svg @@ -0,0 +1,8 @@ + + + + + + diff --git a/src/web/tools/img/opr/download.svg b/src/web/tools/img/opr/download.svg new file mode 100644 index 0000000..ff832b8 --- /dev/null +++ b/src/web/tools/img/opr/download.svg @@ -0,0 +1,154 @@ + + + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/new_folder.svg b/src/web/tools/img/opr/new_folder.svg new file mode 100644 index 0000000..a8b6989 --- /dev/null +++ b/src/web/tools/img/opr/new_folder.svg @@ -0,0 +1,15 @@ + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/open.svg b/src/web/tools/img/opr/open.svg new file mode 100644 index 0000000..839d4d0 --- /dev/null +++ b/src/web/tools/img/opr/open.svg @@ -0,0 +1,16 @@ + + + + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/paste.svg b/src/web/tools/img/opr/paste.svg new file mode 100644 index 0000000..0805966 --- /dev/null +++ b/src/web/tools/img/opr/paste.svg @@ -0,0 +1,102 @@ + + + + + + + + + + + + + + + + + diff --git a/src/web/tools/img/opr/share.svg b/src/web/tools/img/opr/share.svg new file mode 100644 index 0000000..93e1b73 --- /dev/null +++ b/src/web/tools/img/opr/share.svg @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/src/web/tools/img/opr/upload.svg b/src/web/tools/img/opr/upload.svg new file mode 100644 index 0000000..b1554e8 --- /dev/null +++ b/src/web/tools/img/opr/upload.svg @@ -0,0 +1,171 @@ + + + + + + + + + + + + + + + diff --git a/src/web/tools/img/wifi.svg b/src/web/tools/img/wifi.svg new file mode 100644 index 0000000..3d1e078 --- /dev/null +++ b/src/web/tools/img/wifi.svg @@ -0,0 +1,13 @@ + + + + + + + + + diff --git a/src/web/tools/img/zoom-in.svg b/src/web/tools/img/zoom-in.svg new file mode 100644 index 0000000..c92f5df --- /dev/null +++ b/src/web/tools/img/zoom-in.svg @@ -0,0 +1 @@ + \ No newline at end of file diff --git a/src/web/tools/img/zoom-out.svg b/src/web/tools/img/zoom-out.svg new file mode 100644 index 0000000..7548dfc --- /dev/null +++ b/src/web/tools/img/zoom-out.svg @@ -0,0 +1 @@ + \ No newline at end of file From fd6ba5614315be552b86b7d27c78979083ea6c59 Mon Sep 17 00:00:00 2001 From: Toby Chui Date: Sun, 24 Sep 2023 23:44:48 +0800 Subject: [PATCH 8/9] Added web directory manager + Added web directory manager + Added dummy service expose proxy page + Moved ACME and renew to a new section in TLS management page --- src/api.go | 18 +- src/main.go | 2 +- src/mod/acme/acme.go | 5 +- src/mod/webserv/filemanager/filemanager.go | 406 +++++++++++++++++++++ src/mod/webserv/filemanager/utils.go | 156 ++++++++ src/mod/webserv/webserv.go | 23 +- src/web/components/cert.html | 31 +- src/web/components/rproot.html | 32 +- src/web/components/rules.html | 6 +- src/web/components/webserv.html | 67 +++- src/web/components/zgrok.html | 10 + src/web/index.html | 5 +- src/web/tools/fs.html | 205 +++-------- 13 files changed, 780 insertions(+), 186 deletions(-) create mode 100644 src/mod/webserv/filemanager/filemanager.go create mode 100644 src/mod/webserv/filemanager/utils.go create mode 100644 src/web/components/zgrok.html diff --git a/src/api.go b/src/api.go index 7f4952b..be55b9a 100644 --- a/src/api.go +++ b/src/api.go @@ -177,16 +177,14 @@ func initAPIs() { authRouter.HandleFunc("/api/webserv/setDirList", staticWebServer.SetEnableDirectoryListing) if *allowWebFileManager { //Web Directory Manager file operation functions - /* - authRouter.HandleFunc("/api/fs/list", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/upload", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/download", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/newFolder", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/copy", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/move", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/properties", staticWebServer.HandleGetStatus) - authRouter.HandleFunc("/api/fs/del", staticWebServer.HandleGetStatus) - */ + authRouter.HandleFunc("/api/fs/list", staticWebServer.FileManager.HandleList) + authRouter.HandleFunc("/api/fs/upload", staticWebServer.FileManager.HandleUpload) + authRouter.HandleFunc("/api/fs/download", staticWebServer.FileManager.HandleDownload) + authRouter.HandleFunc("/api/fs/newFolder", staticWebServer.FileManager.HandleNewFolder) + authRouter.HandleFunc("/api/fs/copy", staticWebServer.FileManager.HandleFileCopy) + authRouter.HandleFunc("/api/fs/move", staticWebServer.FileManager.HandleFileMove) + authRouter.HandleFunc("/api/fs/properties", staticWebServer.FileManager.HandleFileProperties) + authRouter.HandleFunc("/api/fs/del", staticWebServer.FileManager.HandleFileDelete) } //Others diff --git a/src/main.go b/src/main.go index 1dce6ea..4177a75 100644 --- a/src/main.go +++ b/src/main.go @@ -49,7 +49,7 @@ var ( name = "Zoraxy" version = "2.6.7" nodeUUID = "generic" - development = true //Set this to false to use embedded web fs + development = false //Set this to false to use embedded web fs bootTime = time.Now().Unix() /* diff --git a/src/mod/acme/acme.go b/src/mod/acme/acme.go index a127a3b..01e0783 100644 --- a/src/mod/acme/acme.go +++ b/src/mod/acme/acme.go @@ -10,7 +10,6 @@ import ( "encoding/json" "encoding/pem" "fmt" - "io/ioutil" "log" "net" "net/http" @@ -164,12 +163,12 @@ func (a *ACMEHandler) ObtainCert(domains []string, certificateName string, email // Each certificate comes back with the cert bytes, the bytes of the client's // private key, and a certificate URL. - err = ioutil.WriteFile("./conf/certs/"+certificateName+".crt", certificates.Certificate, 0777) + err = os.WriteFile("./conf/certs/"+certificateName+".crt", certificates.Certificate, 0777) if err != nil { log.Println(err) return false, err } - err = ioutil.WriteFile("./conf/certs/"+certificateName+".key", certificates.PrivateKey, 0777) + err = os.WriteFile("./conf/certs/"+certificateName+".key", certificates.PrivateKey, 0777) if err != nil { log.Println(err) return false, err diff --git a/src/mod/webserv/filemanager/filemanager.go b/src/mod/webserv/filemanager/filemanager.go new file mode 100644 index 0000000..8847553 --- /dev/null +++ b/src/mod/webserv/filemanager/filemanager.go @@ -0,0 +1,406 @@ +package filemanager + +import ( + "encoding/json" + "fmt" + "io" + "log" + "net/http" + "os" + "path/filepath" + "strings" + + "imuslab.com/zoraxy/mod/utils" +) + +/* + File Manager + + This is a simple package that handles file management + under the web server directory +*/ + +type FileManager struct { + Directory string +} + +// Create a new file manager with directory as root +func NewFileManager(directory string) *FileManager { + return &FileManager{ + Directory: directory, + } +} + +// Handle listing of a given directory +func (fm *FileManager) HandleList(w http.ResponseWriter, r *http.Request) { + directory, err := utils.GetPara(r, "dir") + if err != nil { + utils.SendErrorResponse(w, "invalid directory given") + return + } + + // Construct the absolute path to the target directory + targetDir := filepath.Join(fm.Directory, directory) + + // Open the target directory + dirEntries, err := os.ReadDir(targetDir) + if err != nil { + utils.SendErrorResponse(w, "unable to open directory") + return + } + + // Create a slice to hold the file information + var files []map[string]interface{} = []map[string]interface{}{} + + // Iterate through the directory entries + for _, dirEntry := range dirEntries { + fileInfo := make(map[string]interface{}) + fileInfo["filename"] = dirEntry.Name() + fileInfo["filepath"] = filepath.Join(directory, dirEntry.Name()) + fileInfo["isDir"] = dirEntry.IsDir() + + // Get file size and last modified time + finfo, err := dirEntry.Info() + if err != nil { + //unable to load its info. Skip this file + continue + } + fileInfo["lastModified"] = finfo.ModTime().Unix() + if !dirEntry.IsDir() { + // If it's a file, get its size + fileInfo["size"] = finfo.Size() + } else { + // If it's a directory, set size to 0 + fileInfo["size"] = 0 + } + + // Append file info to the list + files = append(files, fileInfo) + } + + // Serialize the file info slice to JSON + jsonData, err := json.Marshal(files) + if err != nil { + utils.SendErrorResponse(w, "unable to marshal JSON") + return + } + + // Set response headers and send the JSON response + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(jsonData) +} + +// Handle upload of a file (multi-part), 25MB max +func (fm *FileManager) HandleUpload(w http.ResponseWriter, r *http.Request) { + dir, err := utils.PostPara(r, "dir") + if err != nil { + log.Println("no dir given") + utils.SendErrorResponse(w, "invalid dir given") + return + } + + // Parse the multi-part form data + err = r.ParseMultipartForm(25 << 20) + if err != nil { + utils.SendErrorResponse(w, "unable to parse form data") + return + } + + // Get the uploaded file + file, fheader, err := r.FormFile("file") + if err != nil { + log.Println(err.Error()) + utils.SendErrorResponse(w, "unable to get uploaded file") + return + } + defer file.Close() + + // Specify the directory where you want to save the uploaded file + uploadDir := filepath.Join(fm.Directory, dir) + if !utils.FileExists(uploadDir) { + utils.SendErrorResponse(w, "upload target directory not exists") + return + } + + filename := sanitizeFilename(fheader.Filename) + if !isValidFilename(filename) { + utils.SendErrorResponse(w, "filename contain invalid or reserved characters") + return + } + + // Create the file on the server + filePath := filepath.Join(uploadDir, filepath.Base(filename)) + out, err := os.Create(filePath) + if err != nil { + utils.SendErrorResponse(w, "unable to create file on the server") + return + } + defer out.Close() + + // Copy the uploaded file to the server + _, err = io.Copy(out, file) + if err != nil { + utils.SendErrorResponse(w, "unable to copy file to server") + return + } + + // Respond with a success message or appropriate response + utils.SendOK(w) +} + +// Handle download of a selected file, serve with content dispose header +func (fm *FileManager) HandleDownload(w http.ResponseWriter, r *http.Request) { + filename, err := utils.GetPara(r, "file") + if err != nil { + utils.SendErrorResponse(w, "invalid filepath given") + return + } + + previewMode, _ := utils.GetPara(r, "preview") + if previewMode == "true" { + // Serve the file using http.ServeFile + filePath := filepath.Join(fm.Directory, filename) + http.ServeFile(w, r, filePath) + } else { + // Trigger a download with content disposition headers + filePath := filepath.Join(fm.Directory, filename) + w.Header().Set("Content-Disposition", "attachment; filename="+filepath.Base(filename)) + http.ServeFile(w, r, filePath) + } +} + +// HandleNewFolder creates a new folder in the specified directory +func (fm *FileManager) HandleNewFolder(w http.ResponseWriter, r *http.Request) { + // Parse the directory name from the request + dirName, err := utils.GetPara(r, "path") + if err != nil { + utils.SendErrorResponse(w, "invalid directory name") + return + } + + //Prevent path escape + dirName = strings.ReplaceAll(dirName, "\\", "/") + dirName = strings.ReplaceAll(dirName, "../", "") + + // Specify the directory where you want to create the new folder + newFolderPath := filepath.Join(fm.Directory, dirName) + + // Check if the folder already exists + if _, err := os.Stat(newFolderPath); os.IsNotExist(err) { + // Create the new folder + err := os.Mkdir(newFolderPath, os.ModePerm) + if err != nil { + utils.SendErrorResponse(w, "unable to create the new folder") + return + } + + // Respond with a success message or appropriate response + utils.SendOK(w) + } else { + // If the folder already exists, respond with an error + utils.SendErrorResponse(w, "folder already exists") + } +} + +// HandleFileCopy copies a file or directory from the source path to the destination path +func (fm *FileManager) HandleFileCopy(w http.ResponseWriter, r *http.Request) { + // Parse the source and destination paths from the request + srcPath, err := utils.PostPara(r, "srcpath") + if err != nil { + utils.SendErrorResponse(w, "invalid source path") + return + } + + destPath, err := utils.PostPara(r, "destpath") + if err != nil { + utils.SendErrorResponse(w, "invalid destination path") + return + } + + // Validate and sanitize the source and destination paths + srcPath = filepath.Clean(srcPath) + destPath = filepath.Clean(destPath) + + // Construct the absolute paths + absSrcPath := filepath.Join(fm.Directory, srcPath) + absDestPath := filepath.Join(fm.Directory, destPath) + + // Check if the source path exists + if _, err := os.Stat(absSrcPath); os.IsNotExist(err) { + utils.SendErrorResponse(w, "source path does not exist") + return + } + + // Check if the destination path exists + if _, err := os.Stat(absDestPath); os.IsNotExist(err) { + utils.SendErrorResponse(w, "destination path does not exist") + return + } + + //Join the name to create final paste filename + absDestPath = filepath.Join(absDestPath, filepath.Base(absSrcPath)) + //Reject opr if already exists + if utils.FileExists(absDestPath) { + utils.SendErrorResponse(w, "target already exists") + return + } + + // Perform the copy operation based on whether the source is a file or directory + if isDir(absSrcPath) { + // Recursive copy for directories + err := copyDirectory(absSrcPath, absDestPath) + if err != nil { + utils.SendErrorResponse(w, fmt.Sprintf("error copying directory: %v", err)) + return + } + } else { + // Copy a single file + err := copyFile(absSrcPath, absDestPath) + if err != nil { + utils.SendErrorResponse(w, fmt.Sprintf("error copying file: %v", err)) + return + } + } + + utils.SendOK(w) +} + +func (fm *FileManager) HandleFileMove(w http.ResponseWriter, r *http.Request) { + // Parse the source and destination paths from the request + srcPath, err := utils.GetPara(r, "srcpath") + if err != nil { + utils.SendErrorResponse(w, "invalid source path") + return + } + + destPath, err := utils.GetPara(r, "destpath") + if err != nil { + utils.SendErrorResponse(w, "invalid destination path") + return + } + + // Validate and sanitize the source and destination paths + srcPath = filepath.Clean(srcPath) + destPath = filepath.Clean(destPath) + + // Construct the absolute paths + absSrcPath := filepath.Join(fm.Directory, srcPath) + absDestPath := filepath.Join(fm.Directory, destPath) + + // Check if the source path exists + if _, err := os.Stat(absSrcPath); os.IsNotExist(err) { + utils.SendErrorResponse(w, "source path does not exist") + return + } + + // Check if the destination path exists + if _, err := os.Stat(absDestPath); !os.IsNotExist(err) { + utils.SendErrorResponse(w, "destination path already exists") + return + } + + // Rename the source to the destination + err = os.Rename(absSrcPath, absDestPath) + if err != nil { + utils.SendErrorResponse(w, fmt.Sprintf("error moving file/directory: %v", err)) + return + } + utils.SendOK(w) +} + +func (fm *FileManager) HandleFileProperties(w http.ResponseWriter, r *http.Request) { + // Parse the target file or directory path from the request + filePath, err := utils.GetPara(r, "file") + if err != nil { + utils.SendErrorResponse(w, "invalid file path") + return + } + + // Construct the absolute path to the target file or directory + absPath := filepath.Join(fm.Directory, filePath) + + // Check if the target path exists + _, err = os.Stat(absPath) + if err != nil { + utils.SendErrorResponse(w, "file or directory does not exist") + return + } + + // Initialize a map to hold file properties + fileProps := make(map[string]interface{}) + fileProps["filename"] = filepath.Base(absPath) + fileProps["filepath"] = filePath + fileProps["isDir"] = isDir(absPath) + + // Get file size and last modified time + finfo, err := os.Stat(absPath) + if err != nil { + utils.SendErrorResponse(w, "unable to retrieve file properties") + return + } + fileProps["lastModified"] = finfo.ModTime().Unix() + if !isDir(absPath) { + // If it's a file, get its size + fileProps["size"] = finfo.Size() + } else { + // If it's a directory, calculate its total size containing all child files and folders + totalSize, err := calculateDirectorySize(absPath) + if err != nil { + utils.SendErrorResponse(w, "unable to calculate directory size") + return + } + fileProps["size"] = totalSize + } + + // Count the number of sub-files and sub-folders + numSubFiles, numSubFolders, err := countSubFilesAndFolders(absPath) + if err != nil { + utils.SendErrorResponse(w, "unable to count sub-files and sub-folders") + return + } + fileProps["fileCounts"] = numSubFiles + fileProps["folderCounts"] = numSubFolders + + // Serialize the file properties to JSON + jsonData, err := json.Marshal(fileProps) + if err != nil { + utils.SendErrorResponse(w, "unable to marshal JSON") + return + } + + // Set response headers and send the JSON response + w.Header().Set("Content-Type", "application/json") + w.WriteHeader(http.StatusOK) + w.Write(jsonData) +} + +// HandleFileDelete deletes a file or directory +func (fm *FileManager) HandleFileDelete(w http.ResponseWriter, r *http.Request) { + // Parse the target file or directory path from the request + filePath, err := utils.PostPara(r, "target") + if err != nil { + utils.SendErrorResponse(w, "invalid file path") + return + } + + // Construct the absolute path to the target file or directory + absPath := filepath.Join(fm.Directory, filePath) + + // Check if the target path exists + _, err = os.Stat(absPath) + if err != nil { + utils.SendErrorResponse(w, "file or directory does not exist") + return + } + + // Delete the file or directory + err = os.RemoveAll(absPath) + if err != nil { + utils.SendErrorResponse(w, "error deleting file or directory") + return + } + + // Respond with a success message or appropriate response + utils.SendOK(w) +} diff --git a/src/mod/webserv/filemanager/utils.go b/src/mod/webserv/filemanager/utils.go new file mode 100644 index 0000000..bfa8333 --- /dev/null +++ b/src/mod/webserv/filemanager/utils.go @@ -0,0 +1,156 @@ +package filemanager + +import ( + "io" + "os" + "path/filepath" + "strings" +) + +// isValidFilename checks if a given filename is safe and valid. +func isValidFilename(filename string) bool { + // Define a list of disallowed characters and reserved names + disallowedChars := []string{"/", "\\", ":", "*", "?", "\"", "<", ">", "|"} // Add more if needed + reservedNames := []string{"CON", "PRN", "AUX", "NUL", "COM1", "COM2", "COM3", "COM4", "COM5", "COM6", "COM7", "COM8", "COM9", "LPT1", "LPT2", "LPT3", "LPT4", "LPT5", "LPT6", "LPT7", "LPT8", "LPT9"} // Add more if needed + + // Check for disallowed characters + for _, char := range disallowedChars { + if strings.Contains(filename, char) { + return false + } + } + + // Check for reserved names (case-insensitive) + lowerFilename := strings.ToUpper(filename) + for _, reserved := range reservedNames { + if lowerFilename == reserved { + return false + } + } + + // Check for empty filename + if filename == "" { + return false + } + + // The filename is considered valid + return true +} + +// sanitizeFilename sanitizes a given filename by removing disallowed characters. +func sanitizeFilename(filename string) string { + disallowedChars := []string{"/", "\\", ":", "*", "?", "\"", "<", ">", "|"} // Add more if needed + + // Replace disallowed characters with underscores + for _, char := range disallowedChars { + filename = strings.ReplaceAll(filename, char, "_") + } + + return filename +} + +// copyFile copies a single file from source to destination +func copyFile(srcPath, destPath string) error { + srcFile, err := os.Open(srcPath) + if err != nil { + return err + } + defer srcFile.Close() + + destFile, err := os.Create(destPath) + if err != nil { + return err + } + defer destFile.Close() + + _, err = io.Copy(destFile, srcFile) + if err != nil { + return err + } + + return nil +} + +// copyDirectory recursively copies a directory and its contents from source to destination +func copyDirectory(srcPath, destPath string) error { + // Create the destination directory + err := os.MkdirAll(destPath, os.ModePerm) + if err != nil { + return err + } + + entries, err := os.ReadDir(srcPath) + if err != nil { + return err + } + + for _, entry := range entries { + srcEntryPath := filepath.Join(srcPath, entry.Name()) + destEntryPath := filepath.Join(destPath, entry.Name()) + + if entry.IsDir() { + err := copyDirectory(srcEntryPath, destEntryPath) + if err != nil { + return err + } + } else { + err := copyFile(srcEntryPath, destEntryPath) + if err != nil { + return err + } + } + } + + return nil +} + +// isDir checks if the given path is a directory +func isDir(path string) bool { + fileInfo, err := os.Stat(path) + if err != nil { + return false + } + return fileInfo.IsDir() +} + +// calculateDirectorySize calculates the total size of a directory and its contents +func calculateDirectorySize(dirPath string) (int64, error) { + var totalSize int64 + err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + totalSize += info.Size() + return nil + }) + if err != nil { + return 0, err + } + return totalSize, nil +} + +// countSubFilesAndFolders counts the number of sub-files and sub-folders within a directory +func countSubFilesAndFolders(dirPath string) (int, int, error) { + var numSubFiles, numSubFolders int + + err := filepath.Walk(dirPath, func(path string, info os.FileInfo, err error) error { + if err != nil { + return err + } + + if info.IsDir() { + numSubFolders++ + } else { + numSubFiles++ + } + + return nil + }) + + if err != nil { + return 0, 0, err + } + + // Subtract 1 from numSubFolders to exclude the root directory itself + return numSubFiles, numSubFolders - 1, nil +} diff --git a/src/mod/webserv/webserv.go b/src/mod/webserv/webserv.go index 542810c..9eb7ee7 100644 --- a/src/mod/webserv/webserv.go +++ b/src/mod/webserv/webserv.go @@ -13,6 +13,7 @@ import ( "imuslab.com/zoraxy/mod/database" "imuslab.com/zoraxy/mod/utils" + "imuslab.com/zoraxy/mod/webserv/filemanager" ) /* @@ -33,6 +34,8 @@ type WebServerOptions struct { } type WebServer struct { + FileManager *filemanager.FileManager + mux *http.ServeMux server *http.Server option *WebServerOptions @@ -55,13 +58,21 @@ func NewWebServer(options *WebServerOptions) *WebServer { } + //Create a new file manager if it is enabled + var newDirManager *filemanager.FileManager + if options.EnableWebDirManager { + fm := filemanager.NewFileManager(filepath.Join(options.WebRoot, "/html")) + newDirManager = fm + } + //Create new table to store the config options.Sysdb.NewTable("webserv") return &WebServer{ - mux: http.NewServeMux(), - option: options, - isRunning: false, - mu: sync.Mutex{}, + mux: http.NewServeMux(), + FileManager: newDirManager, + option: options, + isRunning: false, + mu: sync.Mutex{}, } } @@ -90,6 +101,10 @@ func (ws *WebServer) RestorePreviousState() { // ChangePort changes the server's port. func (ws *WebServer) ChangePort(port string) error { + if IsPortInUse(port) { + return errors.New("Selected port is used by another process") + } + if ws.isRunning { if err := ws.Stop(); err != nil { return err diff --git a/src/web/components/cert.html b/src/web/components/cert.html index 5f4b75e..77cea78 100644 --- a/src/web/components/cert.html +++ b/src/web/components/cert.html @@ -77,7 +77,6 @@

Sub-domain Certificates

-

Sub-domain Certificates

@@ -85,11 +84,36 @@

Sub-domain Certificates

depending on your certificates coverage, you might need to setup them one by one (i.e. having two seperate certificate for a.example.com and b.example.com).
If you have a wildcard certificate that covers *.example.com, you can just enter example.com as server name in the form below to add a certificate.
+
+

Certificate Authority (CA) and Auto Renew (ACME)

+

Management features regarding CA and ACME

+

The default CA to use when create a new subdomain proxy endpoint with TLS certificate

+
+
+ +
+ +

+ +
Certificate Renew / Generation (ACME) Settings
+

This tool provide you a graphical interface to setup auto certificate renew on your (sub)domains. You can also manually generate a certificate if one of your domain do not have certificate.

+