confidenceway-kit 0.0.0-stage → 0.3.0

package/README.md

@@ -1,3 +1,35 @@
-# Temporary Holding Version
+# confidenceway-kit
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Password-protected installer for **six ConfidenceWay engineering agents and ten skills**, supporting **Kiro, Cursor, and VS Code GitHub Copilot** on Windows and macOS.
+
+## Install or update
+
+**Windows PowerShell or Git Bash:**
+
+```powershell
+npx.cmd --yes confidenceway-kit@latest
+```
+
+**macOS/Linux Terminal:**
+
+```bash
+npx --yes confidenceway-kit@latest
+```
+
+Enter the company passphrase when asked. The default installs all three editor profiles **globally**, with no changes to the open app/project. A maintainer may have to approve distribution before giving you the passphrase.
+
+To install only one profile, add `--editor=kiro`, `--editor=cursor` or `--editor=vscode`.
+
+To verify installed versions without typing the password, add `--status`. Re-running after a new release updates installed files and backs up changed files.
+
+## Use in your editor
+
+- **Kiro:** Chat agent selector → **GLOBAL**.
+- **Cursor:** Agent chat → `/backend-engineer` or request delegation to a named subagent. Roles appear as Cursor **subagents**, not the Kiro dropdown.
+- **VS Code:** **GitHub Copilot Chat** (enabled and signed in) → agent selector → select a custom ConfidenceWay agent. VS Code without an AI agent harness will not run them.
+
+Locations: `~/.kiro/{agents,skills}`, `~/.cursor/{agents,skills}`, `~/.copilot/{agents,skills}`. Original private GitHub repositories are not required for end users.
+
+## Security
+
+The public npm package contains an **encrypted payload**, not source Git history or unencrypted rules. **Once installed, the instructions are readable on the employee's device.** A shared passphrase is not a per-user permission system. This package must not contain credentials or proprietary source code. Node.js 18+ and npm are required. Any AI model usage or editor subscription is separate from the free installer.

package/bin/confidenceway-kit.js

@@ -0,0 +1,56 @@
+#!/usr/bin/env node
+'use strict';
+const fs=require('node:fs');const os=require('node:os');const path=require('node:path');
+const {decrypt}=require('../lib/core');
+const {parseEditors,installEditors,editorStatus}=require('../lib/editors');
+const pkg=require('../package.json');
+const args=process.argv.slice(2);
+if(args.some(s=>['--help','-h','help'].includes(s))){
+ console.log('ConfidenceWay Kit — 6 agents and 10 skills for Kiro, Cursor, and VS Code Copilot');
+ console.log('  (no arguments)                Install/update all 3 editors (default)');
+ console.log('  --editor=kiro|cursor|vscode    Install/update one editor');
+ console.log('  --editor=cursor,vscode        Install/update selected editors');
+ console.log('  --dry-run                     Preview only');
+ console.log('  --status                      Check installed versions and local changes');
+ console.log('  --version                     Print package version');
+ process.exit(0);
+}
+if(args.some(s=>['--version','-v'].includes(s))){console.log(pkg.version);process.exit(0);}
+let editors;try{
+ const picks=args.filter(s=>s.startsWith('--editor='));
+ if(picks.length>1)throw Error('Use --editor once');
+ editors=parseEditors(picks.length?picks[0].slice('--editor='.length):'all');
+ const known=new Set(['setup','--dry-run','--status','status',...picks]);
+ for(const a of args)if(!known.has(a))throw Error('Unknown option: '+a);
+}catch(e){console.error('ERROR:',e.message);process.exit(1);}
+if(args.includes('--status')||args.includes('status')){
+ for(const editor of editors){
+  const state=editorStatus(editor);
+  console.log(editor+': '+(state?`v${state.version}; missing ${state.missing.length}; locally changed ${state.modified.length}`:'not installed'));
+ }
+ process.exit(0);
+}
+function promptSecret(question){return new Promise((resolve,reject)=>{
+ const input=process.stdin;
+ if(!input.isTTY||typeof input.setRawMode!=='function')return reject(Error('Open an interactive terminal in Kiro, VS Code, Cursor, PowerShell, Git Bash or macOS Terminal.'));
+ process.stdout.write(question);let s='';input.setRawMode(true);input.resume();input.setEncoding('utf8');
+ function end(err){input.off('data',onData);input.setRawMode(false);input.pause();process.stdout.write('\n');err?reject(err):resolve(s);}
+ function onData(chunk){for(const ch of chunk){if(ch==='\r'||ch==='\n')return end();if(ch==='\u0003')return end(Error('Cancelled'));if(ch==='\u007f'||ch==='\b')s=s.slice(0,-1);else if(ch>=' ')s+=ch;}}
+ input.on('data',onData);
+});}
+(async()=>{
+ const payload=path.join(__dirname,'..','payload.enc');
+ if(!fs.existsSync(payload))throw Error('Release not prepared. Ask the maintainer to publish a prepared package.');
+ const pass=await promptSecret('Company passphrase (hidden): ');
+ const data=decrypt(pass,JSON.parse(fs.readFileSync(payload,'utf8')));
+ const dry=args.includes('--dry-run');
+ const results=installEditors(data,editors,os.homedir(),dry);
+ console.log(`${dry?'PREVIEW':'INSTALLED'} — ConfidenceWay Kit v${data.version}`);
+ for(const r of results){
+  console.log(`${r.editor}: agents 6, skills 10; changed ${r.changed}, unchanged ${r.unchanged}, backed up ${r.backups}`);
+  if(r.backupRoot)console.log(' Backup:',r.backupRoot);
+  if(r.legacyCollisions?.length)console.log(' Kiro legacy .md agent definitions: '+r.legacyCollisions.join(', '));
+ }
+ console.log('No application project files changed. Restart the editor and open its AI agent interface.');
+ console.log('Kiro: GLOBAL agent picker | Cursor: main Agent → /agent-name | VS Code: GitHub Copilot Chat → agent picker.');
+})().catch(e=>{console.error('ERROR:',e.message);process.exitCode=1;});

package/lib/core.js

@@ -0,0 +1,116 @@
+'use strict';
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+const crypto = require('node:crypto');
+
+const EXPECTED_AGENTS = ['backend-engineer','frontend-engineer','mobile-engineer','product-designer','qa-engineer','security-engineer'];
+const EXPECTED_SKILLS = ['cw-backend-node-aws','cw-frontend-angular','cw-frontend-f2','cw-frontend-general','cw-frontend-widget','cw-governance','cw-mobile-expo','cw-product-discovery','cw-qa-review','cw-security'];
+const expected = new Set([...EXPECTED_AGENTS.map(n=>`agents/${n}.json`), ...EXPECTED_SKILLS.map(n=>`skills/${n}/SKILL.md`)]);
+const sha256 = (bytes)=>crypto.createHash('sha256').update(bytes).digest('hex');
+function pathsafe(rel){return typeof rel==='string' && expected.has(rel) && !rel.includes('\\') && !rel.includes('..');}
+function validateRelease(data){
+ if (!data || typeof data!=='object'||!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[0-9A-Za-z.]+)?$/.test(data.version||'')) throw Error('Invalid release version');
+ if (!Array.isArray(data.files)||data.files.length!==expected.size)throw Error(`Release must contain ${expected.size} approved files`);
+ const seen=new Set(), decoded=[];
+ for (const f of data.files){
+  if (!f||!pathsafe(f.path)||seen.has(f.path))throw Error('Unexpected or duplicate release file: '+String(f?.path));
+  seen.add(f.path);
+  if (typeof f.content!=='string'||!/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(f.content))throw Error('Invalid encoded contents: '+f.path);
+  const bytes=Buffer.from(f.content,'base64');
+  if(!bytes.length||bytes.length>1024*1024)throw Error('Invalid content size: '+f.path);
+  const txt=bytes.toString('utf8');
+  if(f.path.startsWith('agents/')){
+   let agent;try{agent=JSON.parse(txt);}catch{throw Error('Agent is not JSON: '+f.path);}
+   const name=path.posix.basename(f.path,'.json');
+   if(agent.name!==name||!agent.description||!agent.prompt||!Array.isArray(agent.tools)||!agent.tools.includes('read')||!Array.isArray(agent.resources)||!agent.resources.length)throw Error('Invalid agent: '+name);
+   for(const r of agent.resources){if(typeof r!=='string'||!r.startsWith('skill://~/.kiro/skills/')||!r.endsWith('/SKILL.md')||!expected.has(r.replace('skill://~/.kiro/','')))throw Error('Unknown skill reference: '+r);}
+  } else {
+   const name=f.path.split('/')[1];
+   if (!txt.startsWith(`---\nname: ${name}\ndescription: `)||!txt.includes('\n---\n'))throw Error('Invalid skill frontmatter: '+f.path);
+  }
+  decoded.push({rel:f.path,bytes,digest:sha256(bytes)});
+ }
+ for(const rel of expected){if(!seen.has(rel))throw Error('Missing file: '+rel);}
+ return decoded;
+}
+function decrypt(pass, env){
+ if (typeof pass!=='string'||!pass)throw Error('Company passphrase is required');
+ if (!env||env.format!==1||env.kdf!=='scrypt'||env.algorithm!=='aes-256-gcm'||env.N!==32768||env.r!==8||env.p!==1)throw Error('Unsupported release encryption');
+ for (const k of ['salt','iv','tag','ciphertext'])if(typeof env[k]!=='string')throw Error('Malformed encrypted release');
+ const salt=Buffer.from(env.salt,'base64'),iv=Buffer.from(env.iv,'base64'),tag=Buffer.from(env.tag,'base64');
+ if(salt.length!==16||iv.length!==12||tag.length!==16||env.ciphertext.length>8*1024*1024)throw Error('Invalid encryption envelope');
+ let plain;
+ try{
+  const key=crypto.scryptSync(pass,salt,32,{N:32768,r:8,p:1,maxmem:64*1024*1024});
+  const decipher=crypto.createDecipheriv('aes-256-gcm',key,iv);decipher.setAuthTag(tag);
+  plain=Buffer.concat([decipher.update(Buffer.from(env.ciphertext,'base64')),decipher.final()]);
+ }catch{throw Error('Incorrect password or corrupted package');}
+ let data;try{data=JSON.parse(plain.toString('utf8'));}catch{throw Error('Release JSON could not be read');}
+ validateRelease(data);return data;
+}
+function encrypt(data,pass){
+ validateRelease(data);
+ if(typeof pass!=='string'||pass.length<16)throw Error('Use a passphrase of at least 16 characters');
+ const salt=crypto.randomBytes(16),iv=crypto.randomBytes(12);
+ const key=crypto.scryptSync(pass,salt,32,{N:32768,r:8,p:1,maxmem:64*1024*1024});
+ const cipher=crypto.createCipheriv('aes-256-gcm',key,iv);
+ const ciphertext=Buffer.concat([cipher.update(JSON.stringify(data),'utf8'),cipher.final()]);
+ return {format:1,kdf:'scrypt',N:32768,r:8,p:1,algorithm:'aes-256-gcm',salt:salt.toString('base64'),iv:iv.toString('base64'),tag:cipher.getAuthTag().toString('base64'),ciphertext:ciphertext.toString('base64')};
+}
+function assertNoSymlink(root,target){
+ const rel=path.relative(root,target);
+ if(rel.startsWith('..')||path.isAbsolute(rel))throw Error('Destination outside Kiro directory');
+ let p=root;
+ if(fs.existsSync(p)&&fs.lstatSync(p).isSymbolicLink())throw Error('Refusing symbolic link at '+p);
+ for(const item of rel.split(path.sep).filter(Boolean)){
+  p=path.join(p,item);
+  if(fs.existsSync(p)&&fs.lstatSync(p).isSymbolicLink())throw Error('Refusing symbolic link at '+p);
+ }
+}
+function install(data,home=os.homedir(),dryRun=false){
+ const files=validateRelease(data),kiro=path.join(home,'.kiro');
+ const when=new Date().toISOString().replace(/[:.]/g,'-')+'-'+process.pid;
+ const backupRoot=path.join(kiro,'confidenceway-kit','backups',when);
+ const plan=files.map(f=>{
+  const dest=path.join(kiro,...f.rel.split('/'));
+  assertNoSymlink(kiro,dest);
+  const existed=fs.existsSync(dest);
+  const equal=existed&&sha256(fs.readFileSync(dest))===f.digest;
+  return {...f,dest,existed,equal};
+ });
+ const changed=plan.filter(f=>!f.equal),backups=changed.filter(f=>f.existed).length;
+ const legacyCollisions=EXPECTED_AGENTS.filter(n=>fs.existsSync(path.join(kiro,'agents',n+'.md')));
+ if(!dryRun){
+  fs.mkdirSync(kiro,{recursive:true});
+  for(const f of changed){
+   if(f.existed){
+    const backup=path.join(backupRoot,...f.rel.split('/'));
+    fs.mkdirSync(path.dirname(backup),{recursive:true});
+    fs.copyFileSync(f.dest,backup);
+   }
+   fs.mkdirSync(path.dirname(f.dest),{recursive:true});
+   const tmp=f.dest+'.cw-temp-'+process.pid;
+   try{fs.writeFileSync(tmp,f.bytes,{flag:'wx'});fs.renameSync(tmp,f.dest);}catch(err){try{fs.unlinkSync(tmp);}catch{}throw err;}
+  }
+  const marker=path.join(kiro,'confidenceway-kit','installed.json');
+  assertNoSymlink(kiro,marker);
+  fs.mkdirSync(path.dirname(marker),{recursive:true});
+  const info={version:data.version,installedAt:new Date().toISOString(),managedFiles:Object.fromEntries(files.map(f=>[f.rel,f.digest]))};
+  fs.writeFileSync(marker,JSON.stringify(info,null,2)+'\n');
+ }
+ return {version:data.version,changed:changed.length,unchanged:plan.length-changed.length,backups,backupRoot:backups?backupRoot:null,legacyCollisions};
+}
+function status(home=os.homedir()){
+ const root=path.join(home,'.kiro'),file=path.join(root,'confidenceway-kit','installed.json');
+ if(!fs.existsSync(file))return null;
+ const marker=JSON.parse(fs.readFileSync(file,'utf8'));let missing=[],modified=[];
+ for(const [rel,digest]of Object.entries(marker.managedFiles||{})){
+  if(!pathsafe(rel))continue;
+  const target=path.join(root,...rel.split('/'));
+  if(!fs.existsSync(target))missing.push(rel);
+  else if(sha256(fs.readFileSync(target))!==digest)modified.push(rel);
+ }
+ return {...marker,missing,modified};
+}
+module.exports={EXPECTED_AGENTS,EXPECTED_SKILLS,validateRelease,decrypt,encrypt,install,status};

package/lib/editors.js

@@ -0,0 +1,129 @@
+'use strict';
+// ConfidenceWay Kit's editor adapters. Canonical release remains 6 Kiro JSON agents
+// + 10 portable Agent Skills. These adapters do not read or change project files.
+const fs=require('node:fs');
+const os=require('node:os');
+const path=require('node:path');
+const crypto=require('node:crypto');
+const {validateRelease,EXPECTED_AGENTS,EXPECTED_SKILLS,install:installKiro,status:statusKiro}=require('./core');
+const EDITORS=['kiro','cursor','vscode'];
+const digest=b=>crypto.createHash('sha256').update(b).digest('hex');
+const list=arr=>'['+arr.map(s=>JSON.stringify(s)).join(', ')+']';
+const yamlValue=value=>JSON.stringify(value);
+function parseEditors(value){
+  if(!value || value==='all')return [...EDITORS];
+  const editors=value.split(',').map(s=>s.trim()).filter(Boolean);
+  if(!editors.length||editors.some(x=>!EDITORS.includes(x))||new Set(editors).size!==editors.length){
+    throw Error('Choose --editor=all|kiro|cursor|vscode (or comma-separated names)');
+  }
+  return editors;
+}
+function skillNames(agent){
+ return [...new Set(agent.resources.map(r=>{
+  const match=r.match(/^skill:\/\/~\/\.kiro\/skills\/([a-z0-9-]+)\/SKILL\.md$/);
+  if(!match||!EXPECTED_SKILLS.includes(match[1]))throw Error('Unsupported skill reference in '+agent.name);
+  return match[1];
+ }))];
+}
+function makeAgentMarkdown(agent,editor){
+ const names=skillNames(agent), readOnly=!agent.tools.includes('write');
+ const yaml=editor==='cursor'
+  ? ['---',`name: ${agent.name}`,`description: ${yamlValue(agent.description)}`,'model: inherit',...(readOnly?['readonly: true']:[]),'---']
+  : ['---',`name: ${agent.name}`,`description: ${yamlValue(agent.description)}`,
+    `tools: ${list(readOnly?['read','search']:['read','search','edit','execute'])}`,'---'];
+ const skillRoot=editor==='cursor'?'~/.cursor/skills':'~/.copilot/skills';
+ const note=editor==='cursor'
+  ? 'Cursor calls this role a **subagent**. Invoke it using `/'+agent.name+'` or ask the main Agent to delegate to it.'
+  : 'Select this custom agent in the VS Code Chat agent picker with the **GitHub Copilot** harness.';
+ const lines=[...yaml,'',`# ConfidenceWay ${agent.name}`,'',agent.prompt.trim(),'','## Relevant ConfidenceWay skills','',
+  'The following skills are installed on this machine. Discover and read **only those relevant to the current task and project profile**; they are candidate guidance, not automatically approved company policy.',
+  ...names.map(n=>`- \`${n}\` — \`${skillRoot}/${n}/SKILL.md\``),'',
+  'If a specialized profile does not match the opened project, do not apply it. When context is uncertain, verify the project type first.',
+  readOnly?'**Read-only role:** do not edit files or execute commands.':'**Implementation role:** inspect relevant files first and request human confirmation before edits, running commands, publishing or deployments. Editor permissions also apply.',
+  '',note,''];
+ return lines.join('\n');
+}
+function renderEditorFiles(data,editor){
+ if(editor==='kiro')throw Error('Kiro is installed by its native installer');
+ const files=validateRelease(data);
+ const out=[];
+ for(const f of files){
+  if(f.rel.startsWith('agents/')){
+   const agent=JSON.parse(f.bytes.toString('utf8'));
+   const ext=editor==='cursor'?'.md':'.agent.md';
+   const rel=`agents/${agent.name}${ext}`;
+   out.push({rel,bytes:Buffer.from(makeAgentMarkdown(agent,editor),'utf8')});
+  }else{
+   out.push({rel:f.rel,bytes:f.bytes});
+  }
+ }
+ return out.map(f=>({...f,hash:digest(f.bytes)}));
+}
+function assertSafe(base,target){
+ const rel=path.relative(base,target);
+ if(rel.startsWith('..')||path.isAbsolute(rel))throw Error('Refusing destination outside editor configuration');
+ let next=base;
+ if(fs.existsSync(next)&&fs.lstatSync(next).isSymbolicLink())throw Error('Refusing a symbolic-link destination: '+next);
+ for(const bit of rel.split(path.sep).filter(Boolean)){
+  next=path.join(next,bit);
+  if(fs.existsSync(next)&&fs.lstatSync(next).isSymbolicLink())throw Error('Refusing a symbolic-link destination: '+next);
+ }
+}
+function managedPath(home,editor){return path.join(home,'.confidenceway-kit',`${editor}.json`);}
+function installEditor(data,editor,home=os.homedir(),dryRun=false){
+ if(!['cursor','vscode'].includes(editor))throw Error('Unsupported editor: '+editor);
+ const root=path.join(home,editor==='cursor'?'.cursor':'.copilot');
+ const files=renderEditorFiles(data,editor);
+ const run=new Date().toISOString().replace(/[:.]/g,'-')+'-'+process.pid;
+ const backupDir=path.join(home,'.confidenceway-kit','backups',editor,run);
+ const plan=files.map(f=>{
+  const dest=path.join(root,...f.rel.split('/'));
+  assertSafe(root,dest);
+  const existed=fs.existsSync(dest);
+  const unchanged=existed&&digest(fs.readFileSync(dest))===f.hash;
+  return {...f,dest,existed,unchanged};
+ });
+ const changes=plan.filter(f=>!f.unchanged);
+ const backups=changes.filter(f=>f.existed).length;
+ if(!dryRun){
+  fs.mkdirSync(root,{recursive:true});
+  for(const f of changes){
+   if(f.existed){
+    const old=path.join(backupDir,...f.rel.split('/'));
+    fs.mkdirSync(path.dirname(old),{recursive:true});
+    fs.copyFileSync(f.dest,old);
+   }
+   fs.mkdirSync(path.dirname(f.dest),{recursive:true});
+   const tmp=f.dest+'.cw-temp-'+process.pid;
+   try{fs.writeFileSync(tmp,f.bytes,{flag:'wx'});fs.renameSync(tmp,f.dest);}catch(err){try{fs.unlinkSync(tmp);}catch{}throw err;}
+  }
+  const marker=managedPath(home,editor);
+  assertSafe(path.join(home,'.confidenceway-kit'),marker);
+  fs.mkdirSync(path.dirname(marker),{recursive:true});
+  const manifest={version:data.version,editor,installedAt:new Date().toISOString(),managedFiles:Object.fromEntries(files.map(f=>[f.rel,f.hash]))};
+  fs.writeFileSync(marker,JSON.stringify(manifest,null,2)+'\n');
+ }
+ return {version:data.version,changed:changes.length,unchanged:plan.length-changes.length,backups,backupRoot:backups?backupDir:null};
+}
+function installEditors(data,editors=parseEditors('all'),home=os.homedir(),dryRun=false){
+ validateRelease(data);
+ return editors.map(editor=>({editor,...(editor==='kiro'?installKiro(data,home,dryRun):installEditor(data,editor,home,dryRun))}));
+}
+function editorStatus(editor,home=os.homedir()){
+ if(editor==='kiro')return statusKiro(home);
+ if(!['vscode','cursor'].includes(editor))throw Error('Unknown editor');
+ const file=managedPath(home,editor);
+ if(!fs.existsSync(file))return null;
+ const state=JSON.parse(fs.readFileSync(file,'utf8'));
+ const root=path.join(home,editor==='cursor'?'.cursor':'.copilot');
+ const missing=[],modified=[];
+ for(const [rel,hash]of Object.entries(state.managedFiles||{})){
+  if(!/^agents\/[a-z0-9-]+\.(?:agent\.)?md$/.test(rel)&&!/^skills\/[a-z0-9-]+\/SKILL\.md$/.test(rel))continue;
+  const dest=path.join(root,...rel.split('/'));
+  assertSafe(root,dest);
+  if(!fs.existsSync(dest))missing.push(rel);
+  else if(digest(fs.readFileSync(dest))!==hash)modified.push(rel);
+ }
+ return {...state,missing,modified};
+}
+module.exports={EDITORS,parseEditors,renderEditorFiles,installEditors,editorStatus};

package/package.json

@@ -1,6 +1,27 @@
 {
   "name": "confidenceway-kit",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.3.0",
+  "description": "Password-protected engineering agents and skills for Kiro, Cursor, and VS Code GitHub Copilot",
+  "type": "commonjs",
+  "bin": {
+    "confidenceway-kit": "bin/confidenceway-kit.js"
+  },
+  "files": [
+    "bin/",
+    "lib/",
+    "payload.enc",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "UNLICENSED",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "prepack": "node ../maintainer/check-package.js",
+    "prepublishOnly": "node ../maintainer/check-package.js"
+  }
+}

package/payload.enc

@@ -0,0 +1 @@
+{"format":1,"kdf":"scrypt","N":32768,"r":8,"p":1,"algorithm":"aes-256-gcm","salt":"o3p90+8OYymUoJzE6JGC4Q==","iv":"WhxGatHx9FWymXFN","tag":"qzsrxI5ifiB21Wq3CX6RKQ==","ciphertext":"/BiIx0YsvLP2QjFnudE2F1RpKLnJod+qxPmXIxzot5UpQB6g7gSXq3mUr+x7yTRWjIaZmPTjH6y3poDn1PS0cmvNEYtINdj27bbvV42sOL0ffGuCs77om7NSFoA5x+nZEiK5RPodKypmRcFvEsB2p8IPK66eDLU4gRd4FQcFEYHJYamkX53bbzW5XDXmhfxjzG711psdz3TGsednT/2fWMFdcP9b37+5eFUE+i4RAhrk6la+4hmyISM1LNb17/Didqu8z/8OJyuF2y4ExwHPjUCnvAu45Mc4u7OcZOmdRes9IZ/MZu7yFgIhDk4S/J2Sq4TkdVNy3ty8EfJEC42zt8tp5DA4J+GqIxlV7T4tOAZU3FyZup+woHP3v9uJ80n9RkHsPsDPhYYxDEbKlyitJAwtbe8b8xlh0QhP/ZGsjYh66BG8X5k1IKogdloSk8adX2QWVIsPckpX9al5rERawSjJrNujSWwzgWKN8ovst2RLbHmZAi/y7i3GTVPA/rnVP7SYTM63wfRuyJ/I1WmOGxADmW52C4CEw0MlCEXQ+tLqEOihUjZ7vBnbFcMMLP2covqrq7lcp9mb9jxpm4PL7azeYexdr6BMVqu1XM2XGF5vBuHrFWGhlUQrjMxASZiS4uWjVTLtzJOPcYKTwaOMUKIShvvWtD63AZYH5bCxA2rh+dJY07aw6AOpQIGXhXkHeMA8jbmrF0mdK9II0FU5wzsif1/0ieKrAd1Nz3qyiyo45QLJSFynAZWZ8imk5XmpmGM5wp5wPlxh7qmFg2K3bJkQOOfqt8bP3B0BopEgOtjNGlkbDV7njHImIyaVrg60NXuKr3irHIqDZHjEzpDHsvq4gzh64V5Kq5UTegOZ04aHrWrKDEeqVtNOD03js6/RgIFw4QgNe3L0mFfA1wmwV4Q9htbR32OuxXMaKmQ/2JKK+CHe15y9Bwu8X9Qn3jQYz3U3DcRSfEe7Puc3HpJubVzloUaTxksrYqyGxaf1teD1oxzHBx53MHoPevWXv60pfHJXOgyeMensE3hgPv2swjGN25RX7MvixmcERArqBtP7W6PO0x6o5VOvHAPs6HJb8KOxjmf1F9jODGAxoe4eofUOb8zVWSeHyu8YzrSdMU3LBtpjJfawgtJ2ho/QLXKdRSrztXnATpNT1Ft720dpUQNGX7rx1Lq9L/6e/4GlW3voPtzjipGhnmZ7ssVwThOQE03DKY2gt0h+V2qK8scNSyDaMUf7407u7ekBApHrf44Q4Xy+cMfBPLkxqZCUBmTmEz7CXHJEyB6BqEL2txDWe9CxbGv+gXKVmrMPrls13vZ0AsjpJ/bTjduGuoJR+WWDEVs5Ejl9EJp57eop/QbixO7XYJ9Mn5h3oR46frgZXWFXJCLXwxR/fDkcETkG/hX1Feb8zEK6uKFAacp8gQLkiiO7eFLKF6u0wlc0ka7aT3n4QWP7m3Pl2DP864hbo0WIB+Bw4KsTyisUgQyGyCtQJu01wGJ/gFTz3RYiYuuwNAkK+alheK2zye8iBlmlvaex78y6w+ZkWieYAPdBZEXdNxz8WHdK12wlm+K47zZNCHX4CXstLFhn8etFOyXLma1z9ntrJo1b0Gy/LDYsmpKt2Y/qlDEj7b9kr3PDbpm8SlfH4TA3V9ncVrAmOlBm1/dvllEDgVgaYaQ9wZGA/PyyLif+y/mL2YxbtAvZvfrUjj9NmfdHLNTTPt88VtqksukqxtRXBhIIDP6ZAuLfCrDKZhjvj/zk9sNzr1ScoeNp+Lw45tR6IgtNeKgmCH8uFuqhz5DruaHXzVI9PoQEctRJ4fZFT2OPdQ/RWYWfMTjlh2qVfyidT0YGI+ZNrnT11qScChGMZviWskRCKXEPbdHbYzeQHSphLjYZiYIrqXtl7FBDgYCOmd4fml6SJJDk1gN2ImFILs9mC1hEyGxV8NFXKh5aZDf6d/mGzeGx+g5ivTPFNizXZFTCftCTNCL2lF/iobXISyVyhozkCk1yu6WhEI5/69JM+1jlWPpedpMuDNZjflUo7+YUzsYRjKWAAtUeSZ5JjIPp9SIEprh5EtnjtnySLwFRfr8En9NlpAEJmZQZCSBlhepQi0ojNSoZ89MzjG5eunpruIIg2970a4KG1peioin96dvdjbBklTFq9QHqIZfD9zNojYtl8OOAww7wJfbp+15tNBbov18VwIv9x/0AB+2AMk6m0djXTUbdRMQENYuUOI0h4xlQxSmSejQIqBeTLXSJlFPcYEXUo0p4Kj7lrc5BPZdoDmsBcGgLI4Rg4meOk7+Py1kJTFIPDvL5MuaJ0gw0jPtaqFvZLrYU9EpFsxBsuQ4wXLYI7B4Vb4s4P+lZab45+/MoJSQDplX+X2tgvYJtwPZ6zBb6WEgAufJ2Td9y6M86JXLAeLlg7bNbnZBX1d+2C17Ajmd5HORQUJFOn4EcHQO9ECJh6VMYmfd6+VSPURc6AdRCCRq4rPim4zQB7UUFB+t9pR2rhxsju3MWj7GG8+gez8HWMMxsYGilGxaxrf9RydUmK5cPBjhqwcDJPimHcOBJ2+6weXt120LYhVA5CcOqzcuCx8SeFU8xojQq+N/APZ02TMHDCunneTzYUAHUMNaCPnNJVIjEJyAZ12f/X2eRpQaUPxkpYM9d8lY8THg9q8XUP/rhr/LZvO+TyOrjcH8C2MBmNYrB+N7S2Zbk7O4PyP2B1Kxz14Z7n+Xxd2Ezgti5VMEkiXKlwDwZFzI9WVwxRgaXQ1kMK+IClJ8Wfu6vYcb999i02Y3EBvtheaGPExNnIQorPjXXYX2iiJ0bqEhDsE+kf3cQrGYhcBqSdtxDktG88+j6AqtbZ2Y9f4Z8289Pj9pqIOiStv3CBMz/9B+jjcaDJEeLVfK0riCqsAKKCsU1Nc+5XBNJGUo7+UwnXN2/mi+LdPyy3J5b+Lx8y33puJWm9GTJmjCexrDsHJqGG5ZQRxtsxOJKRFVQZfdp2n8SCIbFdNd3Qe3wSmhw6VUjW/ghUI2iZ3A2pqio4Qr+rJJid7yCMspMrw5+0LGqaWpNpYLgAt96JB883uuDAqWSwzTZnknm9/Ye1SD/+YxAhKDu+C8xOqQL39dsH9hFtiexpb1IPn575TQpQ2dQncjv/fjt83A0u1DHLo4Ouqh3jlAJ4lR7CY3ekgazWbTyIVpZVBbslHNrWj0H2pCf4tCgP5AngaQpesxKhl7by3jvnwQ8ctQ15cGPYh8F64ycyEqqwySSsxRmSawZj9ADXDUor2h/MCTmdxAImuH2KRhHXzjGn1ZTlt0WI7kZdf3BNLvTmi8+xybyQuYk9j7TRmA96enHJigM7zhji6oxNiG8+IOps566klNoza0xQtMjhfpPkqkq0HFlMyl7rYhw4RqqbXpuImc53yL0QYIqChNCFJM1jhLFYL1B6vTC4Z0bdQXvtj513O93BqetgCwO7TriG7ekQOO7Sg33T3YhaSnzUsmEooOJfjjTS752Rj/8KOCEiOafu2jrPmh9fA3W9J0oiLPI5qWEN58UaTPrqD4uVQm32Lq/hN7TIVFu4ZjlEfEjMkTvRNSTMi8GyW+IR704K9e6JJhgUpJSKBrargOob3T1BW7vTqxszZy8ShD5vmqYYClNNiIwnTU0TZCpCm+1MQT1cS8H6IcYLqY1yjKoeRNsNL/qi8tUxW285HKY8WZ/mMsD6s+DQm/WlfkhKNnDUtWqaDx7m2uUZgu+JfdUdXwSMBV2lU8yqj77/JAGGxPNGZrsqdhKnGnYGVq0jSaC2KCP+TirUdvc+QQYEZPcnMpy+KF2qNwWzO+ep4uYmQLmW9Q4WrRQkx09Vd4keTq3kw0PyrkQJoen4jGXlWTVSN7rC02//V3L9Zh+dGdo8karYUerh9AtsuhKpVFQIublbVBmLCxX0PNWWe9gbZcPViYU7Q4gztCI4tA5eZw7g2ZbZtQLV5RnOy+2Yq2vqGQuLj2aktpN4kVIDxv2hVKvEtlidXYePmd1sKJuIXqUD06JdmnjCXziZogScjFIZHH8t0EXSxUeN6DVUlVFSiTTD6jYjBd9UMouu7QHVdH7fOl9g/HMcIg/EY6bUYaxFKaIEGBhb/5pF/rWNYXQqYEKqsKJF15k7uA6BS9h166MvELv9IrZNVAbO9jV6IKPEAY4e3EP05PCzZP4ZPX8MOLcaX4TQUCrYG+2olbgTUt4P6hmQG/z1l7M+Jo7mgKEjKp3oospjYyxSfghbqJlESLfWUrXez+yJSZ4PTKXk0afxivvyzivTFsVVXK4jvP54YjRRfNcKHE3MKnf24z9pd5udYKq7q9Uu/A6Hzb0lHnoFR5xU/KIjrA4/opN/vV2YcvgaU+F/koRNQgpHSfvMdnqPVny9CAfMfvDgX4FVlnypbKlccL85pXigPicCcysm/+dGqGbWxy9GCHSr8i0ploBIh50MIU0V6EujMXkQGqHGpwhqELRKjuGptHh93rh3hJf5ZgwI/jGLLJ90JtJgXVLZ490WVE/zQlS8UxcqOo8EO5dOGwpT44qY9r2z6zkRQRvx/Zfu9PMTYJu8eixIiS1GsWQ5twTPUZ05yrY/I7WJFYllKUyMMwJBe23LiRz8w6jBG0MrfxQkh1B+UKMLY/aFIh+ac+v583EtyhtyY3lkqgvTXocqaJEuhHQAzp0yFU8bTsrfNC4gl8gVoLT+d9a+FdOTque+GaKxQtVmMxzWJpMNP7q4RUcZNk7BaJfddGawDDtFIiPxop1gT9SlAVSLzVtt+n0fp/O56zgmz6waYEhw00pBJLtFbajHw1Dqr84nJZ8RukY9Vhtw8b7R8XB8bw6bqyA610QkCMqN7LurfO1IlTgp6l4G0I/aDsBGmo3wM2DOvF1Gm6YX9hiRCWmYytSNFflJou2xK2XyAs22D3R9mzFQ5/VLwujRUoX3BFNQ4GH5ZH9OpUrrCHNXMf+d+DWKmkZL4vQmjB3Ud/OBDJ1O2W8nCsrkapg9ZhxOhM9H0kYJC8TxBRpIHqIhG3jAsBtTQA8vpgXRFXvFFLitBkP2WgN1ohuZ7yNJDoLkop1KDrlveXGZxK7/2vrS+p8uQlu7jN6GgJ3XtNZ8zsshdgiHE6zV+/EA1IEzuVmLlHrIfiEo8Rt5pvOyLq6YM6Qt6BGhh77CJPfPclhU0f8VHQ+SEeFZY+OruqHuVA2mBLjL8PF2zm1/bi2BNZstSbZv2WCtXQwejadNshUaJqqXfYfZxdQZtSXGtE2qF0gbxUZV7aawO091zvBaTfshrHuI7bBOTsaOEtoEcJhK70LEb7ZTdzgswlBQQr0hd7g2G+77CzBjFsjJyE1daCOoV80bVx0KOzmGRmhSvubsbjNKjuvncOi41sxUn6Mes92XcnpapS7D/L/gAZXprL1SVTzwCSblHJmp4ymF2tdmjmYP/Hbl/q8+2t7FtwwTVYW5KUKqehstgGK3GdzRVXfGWXv5vVjXe2DBD8Kb6fK8dqXVJ8UrpEPTnxzx1kugWU/Sx+X/8BLu2r4BG1FSZoCrYvrvtMVd57RqkeJhaZR0C1pmlAqSfN36GgCtR6vQ1QjAC18jONZUzIeqgF1pWZActXZJA0Lj4JUT6ERs8widjPbjg5I5LeROljE6YPA/3zvXuvG2dgH8Z7QG7hDocvVSCLWi5f+I2sLkzwIgOZHJ48qv0UZvZ/sEmWdDPlgAdjda/qey1lgBpCHxtTZVxqJURqqsOHA8HTTBR7TO8q79q7ERrWfBQtF3ScAmQzt5jRdmugRz10BLh7Ir1UPhBnkbbph4fj0x1NyqMxVGQQpBHokrEajsZxcB2+MAMy1vRKTCsH+ZygxhCqU62ov0xGUayZkcZXex7wqkXRBZt+Q1QXe8vIDyP1olKvGKrXSpF3VU1HLxoLkSg7ZJ296sP+A4QWLM+K82pRJRHSEDkJJ9aVhRnf6LGBrrWtWfnMfuyAvxvydf76xWfxJa+foAS+1Fbs8hGZNJw16WoaBTJXEaLTJ4ukbI1txzF+HjXsXr5TBd2juJCKVTCYWAXzLWaQruEbeJTleNcK1oaAfnVH8NSWWJwGMQsiPoBN475F42zjvO6rMF+xWVqB0aJozFLy/9rENHbdYyouMKanY2YkfIvQf8/0XY/rflFJAgz+e8vbTPlyQiuIj3G29GCw228CnSS2BArmzVUcwrozY08byVPv6FRjQzYEtCtE5XOzeo/eg3+Pga3x0oIp97G0C3vcjIeE4L+8LJ8ufvLcuWwHs/zejCbK1bgps97+sOrrFd0Yi6OSMjY4jZJQ3XO9TG7i6lq4IMw2eOo5cigEohdIRazBMcAeuc+5HMXQ1GUJnFasH0BmVEV/lGz6OKXVi/eZx/fUb0F95JWHuc/76f8c/Z3694uEEQTUeLjsLN2uafhGIj8rhLlgxN/vkxVXTGYxABEuK0Rp9R0Z7BJ6ex6TzsosiSRq6TwOJml+ZKo5HQ02bkKf3fvVLkOwSk4fbLxg6jI8M+mrfsU8oraCPWK4ccKuV3PLR2yHZ7t2DDp83EW/KlUc6iFebSOK8BMuIzKIJbvrhZZ0TiMjcmx5f63+xpitJMadP71ha6vK3WepL7gtKIeYZK6xMnpPaApL609YN+WU0KYlShnyGHd9mt0bMJOf4v/CVzniLvd+yjfAxQUt9DsoG+wF4+DeWj2AUzOIunt7fEH1XkdBRbSDHMoIse+JaZy3VX22d90VRe5j4QZlTphlrWoMIW1egzmnfYpOnpABIwPSyAZa73dIR4WCxcHVOeu4gSLcbezSJz2Ke4ptROUpPRV35G4dRbqh1/fsxcBlAt8y4agHS5otgY/bYf09aJqgMl/rumyag+WXqqdKs6A4HM7Zp1CJlxU8SX5885tecVujgo30KPDRBSxjDnnIGyICnXIUZs3TDqDo+ysUvw7G46ePR+g18wxEw5ZkT9G++ho7WPJqPYeGo7yksVXC6jOagv4cOjc5/mHgrfGz/iZFxm1ZgnT7S9649h6PE3oDBQO10Ybxicn5ucEmQUy+ZzalfiLDyWOn41mO0ofKtSaZ2mgdcZDsRg3ZOxblia5kggu/Z/UUrCST6FI6zyUYG6m+43Maia8laHRM94FJ6EuD90u+M9jf2b4wI5TQX9chHnW2TqOhpqiEIySG/M33UKfEuOrDMgkSsv8FJOEJU4r23GIUSq2Cbc+FYYxxcwYscG8DP2PFYKoHzxYjPFtT5ZpOqKNqpxDn2kS9Ydr5bDwSt0jRQySkSO/X1E1eIbJPmRfZGAIUK41YHQf6mBvckp31vpCywc2vhq5bvbnno7TDuaUQ6R5qGzifDlbjpVhqhv+kv7meRRfSDUO2g1diDYj+cwlNl2XJpa2VInGBup47splZP1aBmPSteFemZ7ov9+oi6eBi2MYml8/vJg31nKqebkjSG/CTWZ3bKiuk8kqCGKdJyprPJ47e+lY6Z5H0Rl7vtORcEAUHP2exRJI/HI0bo8ekhm4yzilJ5zc28U+WvA4P2jA/kYH/ewhjFQyJKx2IIKHAc678fmd88moaju5p1G1XMXT52eO+IBw4brERyaQn3yk9VpO8DIDEtHvrUDmIn6QzrEoNfFa2Qad6DVL/pNnbo7Q5gc49zqMm0CyDwnYrvWTNkZ6ZC/3cvwMOH03E4CShbgSmDV7BaCHJ4sgwR2oQVNOfT8Sj8bEc8MLmgMg/38tU3NXhZXICC93BPsFGJvBgD6iWrJ4v3lrvY1VxKk1izRhAJzjjekBPjYilrm/VWlxdj6pkRLZXp1VQ+Ic5XCeuLAkBmn3FjG1hszcANjRoDQwTk1dWhxm58FCkK1gxplKap+4tQKtmJr3V0oQCN3C3ATJ/p9t1SoOG2ggig0Hr03e7uZDEhjSr74GR2LtWcZJouK1tnLKRBVWrGH7of93qXXF0cDdUQjxYJvuGx/4NcSbDgZVrOnTQI1yK7OCJ6x4M9/LWyDSu6m88+5x9ScTxPTUTgqwIXIkEWf+mjsaB261pNrFmw+LCIcRRJKsEkaeHs/VLQF77UDNs9TmS6fPx8Vo7qcCp1sqtmSxK5naq8/Ht+Fpu5ujNdQuljWF78s1Ws5G8l0o00Z+QN6Hty2LRY7Y8x1tVCZeXwbNkHVI1p0NnBCxO3U2nTScX3k3fDVDjVWYltFYsCeHmAtRimlFYLRRxSqpihDTuyC7wEmGO1fUiCkJ+FSzA7bscszHdmwB+YlAGM8/Ls4JUSChO4LV2dWFVr/vAh43fYIUzmtAzxnXm0mkWgbQGuVu8jwts/7KB5KShxUzQS2yAwl774XjqW60Ngm6HVLSIz2UYXL/pgczhk/zk1rx+Qk7KNMrhtcMBORz1kKxjbb4jBaev+QxPSvN9m9MchgHGRWF9BjfNo4Z0lh9RgCNa/Kls+Z68aFyqNScOB0B7/QgvTIpH8veGgqt+Z2yJ0F6YrXGgEgY+scvyBci8wwaTXzM0pfc7imcvqzL3Si67Mu1SfYNxe+UOd6dFj3yAP6Pf5MkHNRUSTI1xSHxUUwvssCc3RpCg/fqYanCiyr8XP3kqJbBQ6kQQ6ATKp0a9xXjGhFqZaBmJibe5u1UlzURembd8Ycooz5J958ZolYDP1IQN/Ah7i/ResHuUxVW9WlUS2IkHdlhA11igSwswATjGSMr0DObT82jpEuXFSyEWG2lbaNYnvc1eRJ9ZddPL4QrNeraGY5ndYH3I0c0rHHw/qGnQAr/bTGdpFv8kPRQuvVW0OHb9jyL1NrytJFNZIzNkW1E9Q2PD0rnRbAICkvRQdBxaolrAZKk+X5QCm/z7aL5X203015GnaGOrTyS8Q06c4BVR/q3xootcMkoF+luLY45PsKscOTw7fn5Dwi02R0t6/ekBC8qMy4H0HjgCSAqkssrkgMjHyF4QuoY51XKbVjN22v9y3jw37DBh8DwZuWr+4m7v72wEgNZ4EiasjqnBSHkXUlqvEQzyFqHqjaWqYf9+R4c1gTHH7EMrXTanVPkUcqBaFNeD4kmm4fqIiOQcST+5JO2xZUfh2ADiSMvNYGK4u+D3nnSRHAOSHaamiptqJqpxm+XsEW/CaLdNkN4lPSxgCCjeMYlpjxTa5HAxNqyadHNvM1Tkm20bKU97WCK6pK78+ApsjJQfChu+J+EVF18SFZrvIl70au7kTPuMlWWC4Bj9v49Eod/7sGFPWOdo3ZPZBCGfmLc7ln09u/ovaEkoK/InfnvrjyX78cPKXH2lWpanHb5NFqyjx05daKTTOa1NGqHKuw9AYCdCO9QNi0iE9ZyrNV8LpZuztj4b+YE5iqabNk8WtbNuof55qaT+gDJh7MJDwpbo3/42HCh9hCsnSLPApDmGuKNW2oDJp3lFPcIVEN6n57cf+G7X4tO/hu7h2JBfkhAYOvt5923wWXq47zna6yVAaN5B1HIzIm1cnLwjdb0MtZBuut1UxTWGnJkyZPmm9ciX3ZVhXtnf0Pi8Ip109Gx708nXx2+/PTV1sjxBGdq4FXQx4u1OLBp8UeZuHCx3n/Fdnf7PSzpfVYxvX7lVQOFuYQujyM+OBpjRJc8nykrbM3gnjGGWe/UzrmL6km+wygiqD3JgQJ5O/fH21/XPo1aNgwpoM7i+nFs9VmGEWKoTzyKArCHGZDdaoQD1e7DMA+tEugSYPQAzBzB3431KU2zeak2awfsYZE+HR0glV+uqXeOUmq0VK6cZCj65IfnlDaPbnxvOknfgsU1pwE+T8E5MRyNjVEfyjWrNz0cL45QtCamhOIe/JZsi+pBQdlcvdK5dzwDzUJt7Rqo5+g9BAhuuoGUUNYTT/SBJH2DDTOSeW7dfo1KOLRuEpPt7xB9ur03GNvp3X0UR0fb0SMYW31oMSJLuj4Dj8sWpjRRWeSvLT/Jxd0p1xweFCG5scVS90rA+5tJxGfBKc03VGB0+Dk8LSpZ9S4imZHAOHpbYco0FsnUHxO7ItTb60Pyo30151Cm8crXlBj6k6cbcl152PCJrsmEXVLlsqKymFvFf1I/9sdux7ut5AfHV9l9DJYKWsoKhrCaqDcd+nJ4sTtOxop+u2rqMGkqknAg141lcypziOol/+qVuOipmyT11lHaUBobnndKpl30bXsjIEqSaz7DjqV4+wlkW+QeStepFZseYd5mRfBKyk8vyaNDhYeGZofp+0xpKXPk2UPYZAdV6WR7mjeRVd3f/zmw+ElrIURCCjwvYCoK64srj3FvQtqEcaNEpZtpAX4Got2tpOzkr8H548HXmJERDy2ytayhdD7OAVmxHhC+T6PEvBDt99sSRaa+c0v3U1kydtto6dkyUTQzCLRE30+O+BrIIzrdp7goYJjRS0usztESuyyDs5DQK81ZKq7G+yusrl4eCILPzU0Q9F0h5RI54PmH8R+xPaLjgprUDOxONu+e9j7jub+ywy+O3mTRtugHN3hairauHbB80d7JpEY4D9tQcEaASyi8UmWLR0DlxEZ25d3ud8vYVsQdjcUWesHRdcWtvhJ0SNLUXmYQ7IxWrXVPao09os4c7xRNOGb3C14sxwqBJzTQX8ztwapzog3ebb7tGNFLLqcOxcTOsKDFy/oQXi17FcUycAfZMFK8my3qfkFqbX6USfPDQzzmZWH8g51ADNIBpWtB7UU7DmARoXnnynvrmBH1XoJvogvyHW83f2eqI2IMXfxoRt3T6VGTSkqI6S0D9CUPoJLr6Ywnnl5TGTTyqwJkK88Kt2fD3gPplPt2rWboQqgnYWeghX/+jIIdN2GgpSxvXgrtRNNK1RAU7rrm952min2s8AxXJjpir1/sclKQXv89+TV1LTK+o5ppxZ1Yc2/KVFxyywyeB2OwQ+4B/ZERrkaGfkjkD9W/eQDxYcsDc1S953+m8hISnNUUmFgq8h7cK9gTG0Y1VI+micNvf3sAUD4Hto/8Es8dOVqkzvKpNoI7i5DByOS8OtmyzGmMHuP2Zc50RiT9x3iwBCPhTeWIPsw0gJUdW+42z9svOECsITA8YFhkZnikEeyY9FOHNoF//oqGmD6MNqTqIXowxYlYepreAJ2QnEI7S5DbzFMyWmLD98OzcUdvhmAKL4zqUE10BDmQqXnOpaisImCH1gW96ceck0g7J6lx6cSsh+rR8SKr5v0ocfU01nH7mAusR94874hzEycFZUjVR8pNjcgm0WYnAjVRN+Oi8zlQMAdDxKWdtRTPdG3dhSqfmwrmxKHZyZLXJYhfr1kvCIe/fnEcyN56JVBXa25n6BUJUolJrnrH78WLTGQZweRFeaKHjHA0ltsJKt21Xs+12cEXJ1Us7lhLW0ICO1UdkBVB8yYRhhPnbdU4tGq3ecB+If1C2v+9GQ0b0vcmLZceS1JXwg6TnR2QjAtvDlmEs/LML9XHN9VensL6k1f7LWZGDsQIxj6pXNAR5zR1ZLOUdvTaArZHUme7QYWYTiwM5y2Ik6KF0e1B7mbykqcXN8geQp607Rtmkbn8YsZ0QN1xm9FFWyHlSJTe3XKhXWxrUZIbwbd08XPemfCF17c1UX2+kAmts/+MmWIMl95XyEz1fMNsuJTllRybXU7d6TJ0cSVqkHs7z0P53CK8fsbgne1icLvAG79Smc2s9+Pxy/waam154nwhTW+3jIpJMryHQR7gGYsbTy0QAVHgCG3JCo0pxAh8KBUEMHn4nKBdZqMWpHqduPOu51+KaiMr+7w9YUu/5Mgz3O6xmYdz8hKpoYgp5L0v1oGOaAzqUUSufKuThRzc/KcQj3pTwqEK8ljGLdNiMGMpbIRHELjnW8qKshE/1NI2EoRKREVLtilIvMYk8mA2/24YKheM6uJsnDLuvtA9D5Kf8ilQgEVRnyuFTi1m4pekOMxVtVyojmw+WEbzbQF2lUp6OAMHt6UxCihhca+VcC+co574kBc/R2DAfLoGD9ygrxtJDe8PTS4C8ABndkvXnnfvPAOAHdP/WKCepneiA14Pcln/EjwQEaDoOap18cFea6nbfwKJH97gyN5jM5oksa+SR3ncrO7gEo2dg8wDCUt7a9ayoKkgC1ndmtXaEW75gbk/Z1dyIx6c7F/GnIBworryr3GPL/BFD0RTcYYt468lW1xHTu33GT8B4oLXqU8XE2LWA64dko6eiiPgZOP5VgrJnnvMuAtFQx8BrutXhGAHqCxLvMqSxJJOO2SSsksB5At21F03zXqsh8Xl2XIrJxRe8C7vSWs0v4Du4esSSQLPpe5ElcW140vp8Eh7TEyjGRS0pqRfm9BtuXp3y6VNOz0no6r8dK8r/9LhOaqgauGnqs4b2KpUBIyl5lf/XtdPrOTeQD0tGNJkkwzfLdYLf62ZvG9io90GaSDsLug0l9/ARgbc7Jg8O863LoXvL6TpE5UPPtvvUBUMYgWiIbmBdrPqvQIYSF90aUXDFe9myl5x5YP96QzAyfhmKpPCQ0ZuvCYbBbM6zqDTENsz/loblPz4Pd31WHzB4obf1CBbyzacZBAvqHAuNAnNpLdxPBxabNQb8Z1Ep6fVrDw8G0okI/jEDhot5ligVtSeNQEVxAB5OQLoVfSuX4Bze2KhZQIiegwr5s2voAcetoQK/wpQPMoAQnhKJFC8FA1B5NwRJcAeN1X4zuQSUHVOAAAllemr4i2p6vU36xFw7Y9iS2tksufwTs/lMvmjStNilZ8Llc90B8Am/UiElE7SnNKJ2SmeueuM+v2B3dEzJGcOOVvQEEK87MyvAat7VNgvAaN44B1waK6WRVQXU9Iexv96MzAAUmMbZOWbSk0M3A9h/QaUvPOQNU6d8fE8Z6c8NdIC8YT3rRb9YF90IcraE1ZoNRhiIf+FQpKIbS9UzIG/xIbsOUTbG8grbyH2hSBdtB8+aykOaYcwsNy50j2FBa2zFTgwey//fXeHTkmdBohCXLV+ZwY5YcJ0kM0zrEznAhl63x0RD8jwxHU8zHteOdOjp/4fNrKtY8dQQnnrVUqwoDGeTZRkVSNhvsyiysJ07nTk7cU0kRTh4kiVByw8azZ6bTT12vih2QJtwdATtugWXgumadWDb8c9ky0XGp5jwOQ7yFgBs8r9fR1TYhwXAV96wKJjnn15d7/ZYpZAch3jA5pkK69nYLJjez6giufmkGzSBMsdk2r15LCl0cw5ohtOCYaDdnl0mxn0vbNQG39htnzdKUmHT1jBlKDfA3y8JSDNsdlhpyCnNCjNF49R3YmvvATIEh3ZiFwig1I9lGZbRXg5RJrYL8h40bsCQFNbMrA0EHuO3r7ujfD1hDPchApy02MWsI4M+Gp9LNtiNn6aiQbrmzoBCxUQx4Tc7SyyU5bPBzoTvq23tRenxSr+318IJS99YmjFaWatkaCvsscMYpXH2SJICck39m66c5aeurY9a0nQvUKMEzvR5KH/jARar300wyVRrqn5+K6eJWTrP9jOeqou9wbS3sG5u38xnS8s6GoyXr6ohYX5GrbRz11bZXwlfdss6dcsGRbK5LGSPRhk9YrmCmqg5Mw/iNrfE+WlGZN9heUWS40+jnWBmsj1gy6xRdl84RgvOUBNVul1aEqDs9Ewv1vI46KaL9f31ninD+N3tac6aGlIJnE8RWyk55VF5GAscl5CZ17jUK+iAgTBW4k1rGGvNw1+/3p1gEMhmqMAJrATV8ZR/PRSQHwf3Flk7x2m2L7Y5gfioPxjnVo0ZXZy3PPSi37ZJ3HcEdJaYVTSx/lu34poxKl8L/PCjRiwpWsu20u3mHG+5OGsqyWPFDHbVOO/HjqfyB/W405sRLQz8YH8UkBn3UmGbQtA4XlVeVsSypftC9Qx6CBRK+SoAL/QMCxyWgVyOBVLZG+gjg5KCE+OL3UVWZ6s2hb7UKJMBSQhun2RnDvi3hlEph9rSczoq2jLE6HgxUigqZZBpZEiZ8URadh/i0y9Fp69RejIZVqCq4zDtvAoK+sdOQRjvIDWyGu4sVxFhHi4j46lsVTEf4mQ4tepJARsy5+SVvIBox18fjfTWfU1ijU3BmUwuHK4oT2M9fBmDKGNdwhzLa+LBfrQ/45O5k2imh7+LUMGkZSq7TxNcUE4vAEKpVTs7lvVx3+zIOwzsMU2HvwhqZ46ojRckfyaaeSSfL0fA9mh8+sT/Q4T1TYm6uDajIAYSFv+pabijAJp5Jh0SXI0BdB1lnzHq1V7wil6KWKkx0WaipUw7i++QPNUzHNuyj0A+qZx+xKVLYsTDMqH10IbHfwAV7RaTJCmGH3M3go+ZNmKJlFFne5bmOhrPNPRedd+tFyZUIRnHCE/C7eIyWsJ4v1gaoXftcjNhEtZlm71oDwK+Lko6Ob/6+M5qiIUiq3fgxI/J2AkaJwPr6+MyZb7fNrGcGMxG0ut2hDOV+tCoRexPIa8hXgTkDdacptd/57T6BysR5Bctam2hamcyDI7UXhYiUjpr34fhMOKfT2G0imRetX7VbRmBmNpYHMkQkM4RGcNJzg0tgMUFkGHTBo304q6/VGi+E92vHlTCcGgrJGC5nlul8ql7QDVwu06+pU3c17s0SjirzxTTF88vb322zG3jIECfj56wyV9zbJD+8nIai29rxu/oJPe2mCFYpcsva955x7aLcTDSrgyShZn7QXi/+wlhmz8e3jIlRdQh3I3uBldkUl8bX6cwRTg/B94VvDSCTHgGj8eZkgz3n3n2tVdgFbwhLa+aGA2GX1oLXfQDrYbds/fWBrmbPT/XbFyJNEOmM7RHqq01Sgg8cBlkvOxDN0JUdwjQpDszR5ISjBzISLFcRML4vBEtlLfA2Src8qh66kC9vcy4NcFu5K4tVJiNKWrPYAdHrEgqd9PDqO4YKUWZLxOOmmpSNH+EVvmcnv5dCXLc3Pdn1uLVJ415XMHMZPjYxHbRllIUsorHS88V7KBlYL5u0VNHtrTAk2tZiwz/MukYSkqw947b4O5ZnnXYdH8AjLZ8mZpaideCkuYxaCMTaYDSbAyYfYjSDVKTt8sx3lRWqYPgia3ZGtRcu/g7qZ480ye92K+gkInP+vgYSnhq7rVhfCitAenXsNrm+BQWAMOWcV/BEPmlMDCrAMpIAAC7/HSN8guI05VwqmalMkOgawbb5S3Z9l7lstI/tySZnFHbafumJd9NlG9X01vftxqPlAN1o31qpnuElEmeU9cSpFzXmtMFHxs6fs43eiamzpkplgIqTaUoqMuqIuFyDUapqbCG2nxCyg2uncHUfdIYVP3hDuUig2xio97X0VV9RVMytSR4E/KzBI0CxeK+kZ3EU2qdCr9s5RDEbGIIiQwOw85lCt5lpYVRpJZ0+pD5L7WWh93NdU5Pc6BMuGEfg0Cyf1QVvKsLIHdx2fIu4VEBMcLMw3mcZPTgYQlckWD8aylQfqve2w0IaljCvSjuT5iOtBKx9urH/26WzTUTndtPThBSEjrcjLmmZESClF96RSsaR+uQGJyFBIDP9UiVYFqI5CyPvJ0OfwKCn2a9p+yvClzKCyZFS6a6CIob+ciYIs7bFPuBj8dTRvm/PIEloZ/+zhLrM/b+5zSmIM7lFfOnlmLrsQKXwKEie7wDmJswhG8EC11RKRSu8eiNerAfIG2F2t+D8sADGEwKfwT5uUMHVUAO+pS2rbjWAWA8FyOvmxkSqqKsLhxxZeV8vopRacA2MS9CL5qsx7RIEFXaoflNvwimXcQ7dXO6NeDn7VqD9Ju3kawaJbkvurOpQcaXtnd7JISe4eChi3szmBOQm1KYYUzYO8HHlF56IWw4amSio3yNU1uqtBxGFYBkZ3SRNz6mX/DUBG51O4J2nbsacyVmsZiy4Q9xe2EBfxbgfe9SgKamaSNBCjBnz1YkUtucRkjkqHRpZeJF27eN8fn3HVf8OEFUVYvUVy5S1BLPrnTM1h7yL23hbHqKxLqvyvP+rPHPJJEZ0xlRVAPFXPvAYKckoQ/W5VDcavYin1W7kM6ZG4NUxzuLaMXwVkLHqniiVk6axhJuNCfeOisC0BLJw8GNFd4RcSXzBZ+jlD+hysJCsj6/rsDFFTlrp/XV86EAvO7t4gN2b7SBv6Gruu+xUQMeBWt7k4/nlu4JgD1JGuUItlNGEP/gcdqY4lTFg4yhkfBiI0mfPP+iAtUf4HSBFcSx4T/Ti+iO84DcW7HHUhul6JqSCacVcZt3v4/0F2alFoBs72DyIe8fZ1RP6KA8CvObZ2oD5N5kUEtYW6BWCVgdit3+yJDyNi8F/tZMmqgG4Ss9Bfha/GfkfJRTzPzndO0w88rNOed+Cd7bjXFXSAzXuVPLCYNn9t89ZZmgLHcuLAOuTEZoUBjXpK6ZxxMcX7xPdhH27FhpsC/DOByU3QHGvR0I91X42SGo4FpCBS7czUAWkzkIw8eKXfmw1O2fkStEU2/VYo1X2lkftPnaK4up5rmS6qmS2zJqzqkh+ZyN2Gqsev/dJ2kYBmNol41Y3lNaMZI1Y7waOenOrs6Ah4XRsnMoC9+Zrfum3dLIHoJ/G+uGjA3chDEz7fj5AIQp5hBx1iAmYJ+6iKlLL7y9gbYJMuoHAkNOF67NEIxHA+bwvpGbhdw9hbhjmN0FEhASvkdsg7qqeJ90hA6BHPBYz0R/KQ6PwqxSk0X5ouNfgwv4gMZrZMtj9vCPBhBtZ6w0ouwPoxNZU8J+qLMMZcYo7q5WEX26i6NDRz6E/FgJAMDhYMtq84of8Em6L61MMAdIT0oFI3SJIhOh2y8MdOQu2FaQaO8xK/Hs/3LX0JikT7enLjPcehQBCEMA8HQx+sf40Tp93sunCRRLvYKxkLjHGtUN/aXgpX0lADNq3N1DXE/FGu9AE0gMUvKM2+jmPG3sLAXaIGvU/6tnw7a0pZwUDHnI/6Tu9xHuWnD6VYeOOyApEQ4pNvGnJdugHJzQOoZOkgwahJlMh/3HD4jeT37tSsbZJX/nK8FitVtIeqy2tFqPPUQUPjv5mve6GtAYMX0VfMaOwR2qgB+mDv67WjGctiYZi6RiMLwo34OVgJcoTGbHW/ZhQit85H4RbYNQVco94CsMSYeSfL2iTz6P2/NRzO4P/bPsbWg7PMhF7KOpw1Kjz5uG/Xspv14mOZ8RdV3bqYJM6lrdn972AOXpPL4Q5613KyoxKd3xzZQ0kKiG0MSQf6x9DP2Gkyh5855v/fAUeaRPGXtv16WxiPDWt3CJ4lv0uxy0XsO4nUemsZLjBNnhIabxq1bduNqeTAigvl2e5ImihVx2wPCOQsp3btBiUB+h2X5ePWRB7f22R/ohUOEHsBcK0wZQe7Dh6snn+UkNqhMV/W5fapziB6a9BaWNjqjKvVKlphP8Ri222TmxtbCLC7VMxfR7xGd0GRy775BI9mdZJUWn8G+i51TETwTBULAJL0SCXSKyps84Hgo+SJpOiiT52xwfNDZLSEbGyqBe9UZtAgVPpo3hDvkjwY0wlbdCFQy+8CUCK1Met7IFpHF52SqJ1n+sNuTzJgvW2P95QmQye75PIpYN6lkSk/bVZEqq/Ph+ft745VxKlAfjErH1OxsP8g1XEbTC5tM+kpTJtgZyVJQYvtWSYpWl6AbSI0kOqxiNFi4acqHljBgjJl/c5suGC0OBgl34sVkK/IS2Sot+ynxveN+h3kdrYITl6S0dxGFr5+kiizi4FELAwCmjLzDGPS2Q8PsmRwxbG1rpCGRThjNt0jb/1FvXdVWj0ntthQZiYTC106w+h/gf3LutsN8qB22TCeQNMfucs/2iE1C9QFiPEyFbWXL2tl4IncRRrzjHpLZ93RwinBuMxVs1cSUrGN32XJExvqZ0wl8ITyxmMCEOnCL8alqrqzAT10RxHH64hX4OTBc0LOhhAnt3TUwh0h4jR4P/tvq0dvzn6lkADtgdB4fl0qZq5jsm7rjatnC8JGMSfSsM/O8K34hzfwZ2ErtBWMYr1gsqMwyElLw50PJLsL5EiUwHnD76CnEhu6pcpHt67NrWRyoxHDb9zryhLUoYolaGOstf/gEAf/WdPpMoz7q4zPIUe7mKcu1vyvrDqOZLPGZ5tJf0sE1tFdbNhFUJmxdBqKRRRGsuOaUB/QY1uX7IaKefFmtTnHAujPIztji6NSXthwJEYUCfxbFyQO/0m5Ene+eEwm4xfZb2E9yH/59SOKbNTqZulkzoxnH6C1/ojx1aTmh/2Sekz8VKYrm++r/ENONh5skyUUvGc0ZmIu7Er0AWTx23Vw6pln2L6+RmSkDIr/Tyxc6prPwBRuHjYsuWiQJDTCB4BMmxO0V2G+0Zxadceds7GGox4wTV8g6Wi+uoynK6zjD4s5EjPdru7m9u0V3+EUTtTEoPrxW6R+EHqOHQD5v/dWFaXFNO0mXm0MmFgdFnrjNp0EKESkOQOLiC9hUe9XM0gizwdm7pFEofmMEg1FR5fnSnYmpTzHGtN1Gt6xqhFg66++QIOU8kxGY4xOuk+CVrXAKCTUKD74efAvF570zYxi3QYyEus97rOUDXyI77Y862cFUh3Ct/623yTByLrWtRrRgzI5eWJ05r7oyySlLoUmeDanV0OdhIKc0xLk++AcCVebvPvOhhHhvIMVfm5cZHyOfXLINbpjq3rw4XHCrNZE6oKzwGLrk0D4PDSIVOMcbIqfGDoQO73eIXjUUxjcWq+70fGwPOH6VoADb1XFSTPLvhJQmyV++I5gebwEdzzdq2sTf957b7xeIPmRgzYfH5wXmh0bRj0MZydia3Kqgt4wqJ5gIr0Hyt4SjH9qefAG/VFiKlhefuAE31bTuAMKoZzJj7XXBBICDYEhX529zL1zSEM8YUhYgXu9na7HOMEvflz/Fmul96zZLTvJlZjRNXqcfu4FTa6FuuwLJ4rUdii6h5AlZ/zRK0ZI3aIimZ/mzJRJ7aVfvJ7rTIllH2Viwl2/ePh3vCBx9PEGdzzk95gfDKUwkPbnTIKT/1LDE2uL5j3o2VGl+CcuBDrJ69gj1TYvj/My/a12RnwEdt273dzJ72K5OVBh5OtccAT0d217ht1npWp6F31Wj1B+EVLXjkPslU0Y9GMenUZqAoITjU6t6/xlzi82KEGmsPY3E4SoLoeb0w5LZqx8ChFNkQ3wmICcKFTv1/T+tNERMFBwsq0VrgNFspC3nUFkwT60TMLRNU73mEjL33o6kdX4oHfIfKkyENkb6CavjeQtAlzCBV0nh3iJ2HtMHutZ4Lkte3qWBI1xxN7AmRtuhNi10aBc3F1rLvOG98bR1oLtJC1UCadZjDayx3Qw0bphXiQ3FNYxhnkAzAlq1t1ynP56/9kKTVe+q8JVXXQwgZwafcciz/ssRmPEW4rd1eEx1VrZ4iyCKQlcGvpfYNKnpa4aAk7wSW3jazCemteJE1Ksuz3qvYPf+wRKC+RO4+izUkE4luOhMazdVoSG7hehU8QO81JPUDFXWs80U18pVB1vc4hEwDmRlc4TQ1RO/rzfeFI8RPJUBab9veofXLM612Np9fGZQt8X+I2bz17fEUeHEziazc+vE2OJB6QK2Hz0madZLf10kCt+2/ikp/lMjUFl2dQk8gbGOnQmDnaLlFLyASK8n+vPi/K7l+Xj6F3owzb7ONHglQWAvMv/lEFyoPd5fqqmJPrnkzY9KZmAhjZD8YklLSJRkoC/jBj7ssInjeu+TwJyPIA25FbLRLNokwt06/D7ZrlgzNIOV/0H+LljGrhoUMaS5zK0WamHA9aeWkfXjBVo0olfI/RxtI5nMvVaY+lfUrBJ/ZZ/CyrjDZ8iU3Z6jpga60Gul10ywxKteEpgXe23nckJzdygMf2Hq8LP7mmG8A1NrO7qWiIpWsOga9jPD0pGMw73W8y4SLby4/xuMfwv0Oqsp7nsawONKnYpT6vSMHTkfGshVG+Tu21kIRvjzGMnbn8XFHC/UBKNG7dVWI74C+DvShH35P8mxf07JlfRO4DlX0zOq0MKArdIr1jlRFv1BQk9kbtJt5twQoG/XtXhQeISYHohUo8dIexQQY6qLIJ+FiJYw7o4/NnkcERabOPmdVbxcLXMUDoz+QR8xU/C5CU2q6XeBPepyVz+fyQgmX8vTDw0xCTyJBWjKXzfITA8PpaB9fwospjqOVUA410iwrOEWhYFNpwFfNRZ40ts6YvUNjUj6GY56Ba4FMw5d4jgVbFv8rl7DtRwSUa9KJXVxhQaFCLqvYr+E0AsiUexp6yd/iClMB0fcnzpkttmYcxVKkvLBhCBq0iyAUZoieSm/UkXG9zs2rE6vSdygNe0nAAv+f87cqSmitien6TAvH8OKxzL86oNpuFTH79bGvr0NB7mgAIfRai9fZfZdEn0sYPOw9lLhRO7jYIcyW8Nd4+6i0UIe1U500rAHA9uGi5amFxQIYs6RJN1R7urjrQQuCmZ4bTeIQgRG6htKVx04cHfHPO7s0Pxy8Ssymbm9vRgG91kyaEaVe6qWZ8vv+Tpt+1oEppMPKXtMjoCEK/XqEFKfCaJP9jsL6qaWLXq+P05L7g6cSXDvdZ+2XIhX//Xz1mWt95AD3zXr19lAJaidP0FIN/nBekEn0tQQ1PH8ZhI8GXyXRhTd4vT0M3FHHlaNMln+DuNS/DtUQs19RA6oGI84Scd+NyOko94lMKuNNUzUSnxohC2m3QH7mChto3BxnxYXp9bOkvoSt6WM+6M/4SkUA3fsL2ew6kbde/TGuXjO+2waKxBLRjQk6nCJExxDdCaiVJRJHlv+CHLzoaqQhOshp4RtEtipHbUqzhAQqI6oN2KHJ2/nbWHW2AXPpT2kUb0cuIFNFib7Q00SBa6iDugoyb0YHaFK0w0/Sa9dYoXbNbKX70SVjbry8wkMI/jv0/W4HsF7Zw06ufDdQQJHz9ByiAiX2QUp9GfNWRZJTwo9mqc3zlJS32G6EgBLTF75p/mi5Us1HwebXy2AL2cW4Bdqz/xVoP4rpf+WycceptitgPAe/pdEo4zYIxOqzdl2ZfcLppc5hYVi8JRWNTumLEMdUxEK/vINwiZFAPT30k4n6088dTNDP2zblHpJeAAtffgEN719Yuw7b1RxeqcJhHaKzdFTdv7oQ8ZA4kywn3fK4m9yRMqzYDVEmY2vJWUqjOIEcL4uW9ADQTH/q5fzDYOhj58uCx5Cal1FtKxjdK72bUANGYGgbCRGqpUxTj4Md2BGBXnUy1PgpBOwcg9x8U6SDVtA6H1daBxMXqGDFYcjIAULUG3563/7mIBUTPU9stmN945sBDSIS6bC65jcAha+u9xeoNELA8YHs/afUadH1sVHEwyGa7HDghxpUD1T8UygTUn3Sm4uRMQEePRDIu0j49r3Eh85qRxtDHVPbV0liIXVUddWq31OqrqDUYVbBgAoCbAtwaqZwh7hvfNggxpWRI8Maic9yzRIQoDBskGXrNKFsDpzONTG8FnueQYw0iY8ALny/1osRTP4+2hmTWa1WDkCd+mxvpeRDE+lSSRJXVubw7IQEOmd/hIiiUTu4KkIMG5MrZ+LcfcRVubTsDnpPz/s9Te2ypusKOcf9Wmi+Rw8n1LFy5ep+YhgqOcGaWvYrhv1cZDKYew/LmWJFeo7FlMbazEe7lT8gp+8vz1/O2XPCtzwD4iZXueNus8SDeU1C5PYntBsf7oh7oaVSyNH8PLAVjZzi4AXOwym0F98tDtXDaEfNHvrr9UhsZjUcG18wRwPjeZ4Vfd5qxCsUQxn8lbLD3rI4ODPOrY5s4d00SeR6sJ4838/QbBQxXeYLTnLmGzn+LZfOI93MQg8E1HXyBf/K6gPSnohqaJomRXRiHrCfGrEA2btq9+oYxb2Ov+PbwSr9qVdlP9AEkzU75Zz67DNpCvWZCRwPzIeMfxdXmtip6/B6qUKDISIICbml2M1bhdHLG8TheAqF3STKG2uA3E5KUO3XvfDBkXvhoBwqYssFjsJCYltw2wCNGli92egUhX6TQ8aoL7h67LjDC/a027Icih4SSOJPOez9JoiAbX6Y4Xq7BzkBE+MWVyxHaC6Y90YG7KC5dB7olHuJItCLUFGnNZhcA4Xsp2zN8iU3graAvl3fx+dZox0EzvMH2ykjan17uZWlIDL/IZCHjSQIhP1VJzO7HZs1McWEH/hzhHRgNixabIXx27fOZ+Ya0qq2MvQ/3EDiBqwqrtJbLlaeY/RNQdc8JQJVFuPxOsgm4CBlQqQfGFXYmCm4j5ScyAmLJchIgBMVgqUjqk5slL9tl5yZkHlXEqMea6DbU2800gHCq6ZOxIUDkFNzIBWTPaerJsREZHZYeAX7iViFbTKGSUw4wYkpX0W8ePCVQi/c14Oi0mbqm02IlV1/g4WjRwKa1dZMHqyxFjmcE9ZbVUkA0mckm1uYdEPC8zcuU76HqooDGwNinN8noKlzRJXVBOvrb2YwpycUfrnnj/+/dq1zIDeAeDO3LnWSkr9QhUiQAn0Fh+pBjIBXID7xS8cvvfzGqJWCRP1FQFJvTSONSLMo8x9/kDKdTNR4KdEbd7qD0V8YdBYvDiNM7mWJIstFxMzK4m6Jy9GMMJx/alTWsL3/cr+0NhN6cTHoBBuXae9oHZiUwXpZOykZdQoVETPhIAChYmGN7AokKX3daf3I6oNvvx4rxD988mFY3HjxD3H7t3fbcHkrafKNsRfhQRx9DMYsyFFjIM8DI5mQhTGRBCTgS9warNk8jKsiqVV9JsehAzRrqXrpoBSJJaTWvjC+X4NDjUQEKscL15QNMZ+SH0vjlhm2nDeDP+mw9CDw9JyGwC/z1tOG3WS1rpxGhKp3TkBuqTVasVDoxYDpNf9iFanJrfteMQbzAmxsw5PgwYWn6hjXbXuztIbYIQLIjIxBhkA9373XhvReemPrhSeTZdt7XbutJRNmOdlPV791Ex3UZlRLA/YAzfyj5cvn2sEdmuvyz/P5IZGa9r6vPrGrHPnfr6kdEG0br7SwxT/0yUpkzpYL7ZcG0znx3O9j3Y+nlBorQF3Bwh7Zg621Lui961JDlz9pMLsGnkccYEIghXp+fZ9oOVMhtHaNzStG99pDsBYr8FkVTqKp/rtDQaSCH5GylgH/BLrJeiq4xVi400Yd7yotKX8PjnNpU2JMZn38bgrxowgzpnI0eSQpnekw/m3GOdApsmEI+UF4kPX5XbEGSKzBvAiB3g3DVLYTFz0XaQbJYIcB9SsWQxftCuenmRz6QS5mLTiKbs36UOOzlfG6mKG+UqYEe5KYTaH5WlrsOxAAwc1VY8915X8Fe6hHhtMnzcKp90TfaeNsiVBBj2u046HNFmlMUD8XWh1p8SsFSA4/dW5TtD8QEb1SW9Exd+EHPxtZOHeoavmluxRvYyVHpUcW+zxp/b6V5BEOoZhBIu6blFwj1aCRtaFvdpIlH6F5gzUjvIseicqWISoYWByd1nH2tRcD4iEykObAHrtlpnZT270+PUIklyt7y98U6A5K2EWWWukmD3t51lwcpg0UFvo7RhshM/eplhcUxLI9CmIW5AwIaTMAC8I7WImXj6UTuGjQ1A1kOi7UYBhmPgcQiIzBfo4EntSN2cU9D7RB3fGilwHJcsAMKqa8o+TgE7Ch5PNOTAN+ZmVJFENz/mBIwli1P+VrUj2UDbEMTprnNMq+3Ce9afQt4dBSsC6DRVbA+Ce3oV3Iy1hZFDBDE85HjnMqEP0xQBV+xsjVZVFBWSSpbDaMwNKdNr5wYhAy8i6K4acfIxeE/ak1DxVA/Q0OJXIzLSoOVe3wZ4XaM6J+Hk/8+bvvhPTURaokkmre7ctl5uEDGFqoGb+aw06zV/jyD/8U/J/BauCP3iaTfMLm7tE6Su7oC2ZNWwQ+mmbQ3kY1skbcMY/en1s115VphFbRwivdgTuUqSd5DZ9P8BvkhW+Ta5QW90F87rYncMByfM9wsx+EBxnDB4Rt5qQiq1BbH9BHCWX1Rbqy9DePKdASh4+V/3ErD+tdUBIGuJE06Sr8lH0l8ctJ7u3IgxJlsQCknrttvxqGEHXvXpiEpBI+PATOgLVieyzeI6RoC0i6SiFaBY/OUAoneJfHos+gL/VCOPs/mzFwiG4wK2kbfL0Rq2e6GsPQY4ugMdsx/EWFF1AVDXZbWnzPf9NPOXsCEUA7CHYJ9wBU+NxMFDb072uhrBwJrbj7NxX9lFQVuGH4MS9OApX6nLIStG3FvEb732/i0DaZ4cjmc1/kbWgGFtvXHtY2xUDvX6L4pYco2CcVOQBJrdouAny3WTRiASJ8gdPn45GKvxu8YfIbAVPY1h0kXBF0ZVn8rFZm89s9s1dXZlcXvDkcNlzW0/ELJK4feV+/oRoAaDQViXt4jhVpeaaPU3rNSyCAGdraelHL/NX0JeZ58TCUUtKlTpGVY00ro/KjGhpVtoEwzLkWfepNwMTmcKMJTaCPUJWNNAbEZB7PuUDsm7e2QL9pH3Uj6D4x8nsYN6THXQd+17YV3g69gF/HyqSYjiO0nZx9giXd2IRUe62kKYT5/rhUkMH9tEowbe3yzeVs/7CCqu3OW1j5FYFfi84pXo2FLuGVV5sZLhfouA+iWcskxcv6P7iPHu7XSfOCtKkP+woN3HNyKWWC1x2INvZhgGv3BLtq0IQaesTQ4CH+M/EOdY3ziUIJAcuPYdhi5903F0p7EMEumA5eHyyvKyzn5LniK6ljgDfCOhJM/LYQgC6Gm11SBuABM3TwIXQdX7T6oyfrBr+aerh/mivir3tnFvmUoRmjhR6P/Iod15FJ1quwzjtjRzPYNNSvuDsJNgVcVZIdrCS289yaLpHeZLexHmQWMOrpESEsconXibfN9Ywd6gbMcf/B15SwcJ964GOZJKlSNnR/FkOSOpw3b2cBgF5ZvlEuVJA17nPFkUiN22HCBR+9BDQx3iHPOwruX+wWOiMi+mO8W+XorZRivIvBIgcdiPkSZxSkIXkAy0AiI9ahHFfbU6ZhqNpb1+r7p0DGrMMESAU0Kl4d/ILQfFef6YhtjtnmUwdPPothEtO2RSUDjKzAlVyQyO2PIgZ0HvFhd2ymhUQ1yjW5cVpRX0ZOWlgFdctYg0MIHlizmFr9gqNkEv6UgMh6jm4H98yQbzCoGdjF+y9poepWnHVrv0z2FD3A+Zgsuc+3qTjSoMh6m4g+WwmGG+kvWdLQne0AxBuM2R2NxcPa+3qF/NnVQwzZ+6xw/XjMtN4gFS4KKqzkggNGsBTvZfLJk713d4PpgomsgRGrOR2uttNIDKA9Cw3ZT35ntU6KXnwZgd7kVdjLhipyxSN626qI/lkrlJIyNGw0k4aaEfefmjikJ3c3JrnBJbt6biVfJ9sqLt/x+m/Etk08DzmmVHuW7JovX+Wigk7f82RjL12L6ck0yyfnJsozw9JvBJ+CgmL1cHpAXb/ANkADO4vWg+AbiTtmEJmizfK2XvtaqYBfqNOyNf0u448sAe97Po7eT5wWa9dxT0f3U9jRMWKTYQRXD9l0mRPfz+VCe43UbfWOLJakFQ7xhbuu4PF+Gs8fOLygBce0VTmfGAqZvUP3edLFU28I6e5uytvYwqXSRHx2uBD4huROMrwD/ifBCVuKfaG6Ddx8HpUZTAaQ+7C0vOzKV2EupNUjtpaX3TPOELIKc9CE5oW60vdCA8wBn6FXCchMCBmojSoe5mZ/Z2UkrW/4bvR2N5O5EFnq1SkXzhvuSPlXM77c+jlw4LPyEX33Ba3fQwzJDg35Xkv5YGHjAPALuD1hqY8Px70Q42iQHjC6t9ILSR6V6Bjl3fuP42H5np04Csdl2oTolWGgnrnWOgicoT7Q0IOh4NGyKNSU9XBY9JtQiZ1NVQpaHkhHeboxREgqZfmRe7rfm0qqNJx4Ic7UmIkUF9u4h10dKZeZ5/7sA+Acgu3oKBCpTZ3SaNclmqPZH5/47mfQtKlPV+Lr0Iq84w7VTZ5AY/vs2WnxNeRoo1reeQh2DMgwScizSi/W6ylqDbkRZ28tVZhdB/OFU4jx5o6FF7VrF0MViOBfI1gEG8T3asgRc7an4c4oazJ26w0PvhsSt7Lw6bJNfyR3KHz6DS8fAtG0bFoKLo0TNUcQmYZoO0FNpLXzCAYnMEQR2BepRz633BEfn+Sno3qwm/I5s+r4AjBSUY9RePG7nujGdD4YZbSJMdfRGXNoHyzcRo9Y0PVSm7d53zPwtm6Xo5/0lKaRMDQfp569QCvamvSZSxehNZ8alM4ht5SZuSKcaQhq2OApsK9Q2pFBGyQ+B0RZTq0Z41FYiHEEVp/vhY2JPQJ5ZY4MLVGSJG6NoFjvwAvfPvxFb3h5Acm5cZnXMyNy4L5IL5dUOxW6+kgRltjmp8jvWRSNmhfH15dKOgMkDD0BfPS71rHRjRJa4MowuMOname33jYbN8VJIif5d+EwZWy9Yge+XXIUPi4bxnAaWUf0/cbXrz2cwJ9a9+XsBZ9wVNrW8OB6aWe8XLSPCCAiQHUVtfuQ/IoNWrTCUJdb0/gnhru6Fo3UjBFAb1mkP9u0mR+vr4l3282mLs7o/asoeVtRerP5TXHsBAIbvbuiJqhp0pB4L3zkqy6gByrn9NzZ+3WH0/7qfXDMMTZfhRQzzwGPPZoRZulBkxkvHGBULR/22E7yN2+q++rMhD3KYO5TbLf6s7Bmk0uLA86B5xFVOJqVDSlnPuK/sFawo6L+CIoQUv5UW7pDZbvpz91EUIZ/UXEho1xWqRXJ3hLqFENMTYXB45MiWl2J1VKolJonsrE5Vq1IH7RHdSB3N7rm6CZ9e3YMrF11MMUAeWxkmL4va7YJd19a3t1IjMnDVQ9xyRcXIZ8jNCsei44bJXpfCaNCLn9JJQz/iBDcRwv8faTcGRtHlAOJ3HWC9xtzL3Qj7IktaQg5hqEiW42KQp6q8dM57jHSjjtIkXP5iV3zSOE+Xprfci9hZZKVKeIK3TuH19AdZefgiVEnQDZ/8Vdeaid5zko4dMxTlfWYsUnyo8vKOLm+lF41iN3ymWtZlPYQNuzs8YKLqmCvGQyRKP7ugvAcaVRR5NSKhq1wr78Td/VapN22iTtLI+vE7zFgyecYKwA35iOAewqq3dfbH4Y5j/4l8DYNNdUH/f+YYbHi5ekWQFfGTTeb8POQ5nr0EUtft6sFQ8Ztd6kiaa75mE8vlNTXwaLdx46+30bXAqRkN/KfO31+HK+iXwAaKfOL5KCXek7kuXfhtyIIhARvqbItOHh3KMsMqlv7XcTIULFZFLx/Dfml5h5erFUnLrmzDidF+NBvEVMKaj/pQ8fv6/GaTfFIfYti7Ommx/RDMm7F1uJrXtqNe2NmJSujJuNcQ/yf4v+H5OAJf8WZocYn5u+h7boC6Re0V0nonl3u13offN6f9ObgOLputW6vHi8/wsaZJGb+sRKHYwgKyLXb+2ZtBTO0tAlDBmthukO5pLNYqay3yfY3BZE/wZlXN2wDBeCUSvVmh6TJQHfiOAERhh53qDg3BwkOqtdCpp8Wz/UFIcyN1NKA8Wm59XVgky8s7tUB4K8bCrSOvhg4R21bRwCUZZI7iuGEnJR1oRXa7d5km+varWZcsyD9cCMnCHjRCJYe0R99eX26EVYFIHp53wsjzHbK5FANsYCqusaPyAME6X0GWkL1NcpQ1SIM9ew1jUxgvhemfDXeWkp9ipzXuILdc91N/p0dSDETXpzav8A6w7z0ZqhUQGX5vsOYxIC0ytrW3Z+yENFFbrROE2pba/897TdUDfyoARPB+GnZqi8w6rNcO75PP4dvc9uHPRb4cq4CNmgM5G1Kf71uWSOGtuUa/Y4+rXx2ScEqq0qkObQCMJSIUGz4QMBJJrfFdke3cOQBNHtjX1cWAwso5Sbiz+Nl5jWOcv/l9v+5PmCSxi5uQkkiN/R+jJo9GXSFrtaDzXlQUhsZBromGfwQg/Z7hS+T6UBiz1+AbE/gMDtwmLx+uLWQTybmH2L0pU833J6VBH8XUA+974kRwe7liaCRATNTIds/4yOA9BIUee2mJPPjr2DjP1lx1DufXUouCam4pTkFzUW8npvYA9MiD2gJUwkwY4JNzEQOFVbG96avFG4eBp4+lEaoxAizoYxDKVzDAwHrlX9YHnKUInaQD7KU3FWpwcr7ZmH77eNa4n6XLAOK3BorvjTyrBC4vNeA9J0Y/vjvVHiSu/FgAt4aoeSCmap3/HwxZUIzTkDkU7/pvMd5S9aWPDox5rCNCMg3wBZEtcfKrwzi3kaDeHtG1JGrRvrd1tW5dqg2ufO+EzSzoWBy30i3f+MIDrxS4pRdWvqhxPW+J+JdSKpTv7n4TPdMzpjH/vnO//S1kEMVTIlkVLlW+Dt33KG/iiFdOZ7b3DUvvESsuIfuRDxSOdC4cOtY9ysngJ3MgtfdKUGvYBM4cQSXZj/+1dxEogLA7jMm2oMCsFGmgHT9VfBhSLl5T+eBxpmio8BBXP/rnvH5ZuqOzv23/qfhzTA4ttagytG4NUxA5S/f2ZgzakCHDh/RoiqZcmOxbBQl5w5oiiHMTDnkAGW2hZvL40uebBqHAPQOYc5AWr6U7oOGW5wbL0XWm7AoqD+x6ihXPGh46MGqsvNfHJPELcp1qfNU393Dh97vdiOLkiJ2P7SKPJtWTADmgTsntQvZv5k+ptHp/nFUGvsoM+6NENYBIbu076s4ODHnP+yPDDEcvm/M09FBKsz5cLiPTBcblGjWDPjQsxbsLWoQZ0FEG2b72bz0Inns22iUpQtxt1xy5lt3v3S8rqlaSXYKzd7hTtKqCdx7IaC2U5sInDAuWWIdxRFo1g/zTnGwYs2zKw6myIZ2rMK5jL/oV7Fvh9u71N9fX1T2rV1SSZuqy3WB5WK+OsEUMdw+NtAvOyJiL7r/azORjENtEjpMOb5WIK1+yXJpgjITYKKH18G1Pr6fWWlNl8Kh4/bTiB1NjDHp5bw3EU0KL12L4jIUs4cd9/IbFsZPHj2etho/qD4YAmGjiS3r9eVwjou96yC3isbB1X3XGfaOimktRhJAhzVW7SpuDmKaqaokO4+VSnrK395y7KVRgZZhsn5Ihq6q0TcP7YX7Sxglr2M+Qnily+Xhq/zbcM6hEghr6Z55D7Fs3inzJtA4DKkAn4K5lULmVI29K0oZ4uUHi93I0vVBYmZGA106IIQCfM02QFehIECmWq/EM4M+WaFl0hvUupAjQvDoCI2P2nx/2w/EV4uV39X0vU7vYXH9ZQXW8bvrCkvFIr82GXbb5J5M3nRpLxdfyz+QWxa9tDVvtGKGQnRxecqfhfjNRruztU+dOfB/1xVM3JrFgQAYcKbPpsbnp+TnBzWkpFvt3dXidK0sErKo+jG6os/CmEdqmrunOEtyitOiBZtB4pEjf00qZv/uG+Xf4X591HgmfiKClK6fU1nJEWWf3WEjhrh7QhCXXgwpwj9dVE1O57hLfwBZ6b6NS+fWh4TE+ArSToodM8sT9OLCK4/7C9Q6Z5KVowUooWJ1YGSJLmotsUgFAS5hBRycC4ClHCypERkyM7pJdP8/773rcpQv0a2/7Tn/Jby+nG8CFZS50np2VVrjWoZOARi7bL5ayNGtqnT83RKYpV0b4H8tYgw8Vx2zmg8PbxgAm85mlWwGn+Xf0L6rzn1TpuT/sTmpe02Uvv5Bg8QMFhd0YlzCGTkV3AK5e8N/Pa8R40JxdD78gslCz5UR4BOXlA+tyXTwSGnayin9i84hFKK2z4FpAJ3JeU1xIAGZqHRnnp334yUkfvCBJVk3NyKbnv1Jj0CW8DJHZnYXEyduLR+OS2hsg0C+jQITnDnKTWq1my9cIaigFMRt5aXJ4yB0jSF9E5+18ugufdlVNj+ruimVqCfRIot8hqmpftdU1MxcJGoCTmUpctyRuN8kh+fGa9bMw0/L41mCLtszg65IRMFiQmCC6X79izN86QAKP/MCWh+XXyCKtd1sUQnDw++ptSzdbW0/evMg7iI37nbG5AxOhbIIAkgeZckFZJMepufAZGzZLQxIOgmAu46HAn0qP+cU4TjpcKckHxIPliBOytfgKkA3O9jZtXWfTrkmPzCD/N77llmbY3TfLPJUvfkECV7sRWp+zKbXyfnhcXYpFb7erbiiKpXMDzKKenG72dMmCxddTUBG8tDpYb7ZcDAovSE/khwsR26SreJQzDjU1il9VizbVK5yJv5iLAHb6WG74BaOafoSwDDRsA3OEW4eBhjp+j7NWXe5oC7Z4EOufqgsBzYr9M5JQQhP9xuqvW0Ahqvjgtm4JU4DZ26hLl+okviwZFAdfjCB7l63xpYv7Vq33DXS+/bUxbgHn6XFmUq562B9VMinXm2Rn/Zz+QM75WwHjhO4Px6Lwoc4vsu8T7L1qgmXbya9o6yjOKJ+MP0Lx5HLrYOvpNRDGdQ09mDw0hkpeoGVN6OjBXzwsvyeDKuJREDafAMgtRUr5Qi2+EFB8WIT31CnMAoDCFJMy49xrefK8Tf4WO4jmEDaU+QKy+S+JfHjOzvmUZRmPAGoTJ1oDjRpkOY3bjY0XwtUB7oGIIJ+D1eNu3qTzoeOFt1i2wQDMjwjILSnLUehRSickN+A7+SR7uN/93FjHD1G8eNPVbtQm4SYk2rng0zebn9EyGxCAIN0pQ+wgNtVUFOTVvVILn8S81Kui0WoV5gwR2m+pOyOYpW9sU208pPXnotfwVOjRrREMDzCXyyXp8M7YRbE6upyTWobd303yLzhvBEA2fTvZaJtonnFgIpiEtI9/5ymx+xOuCsCa5Xw4MvDc36W3p/acWHKKbPyX1sO1GhIgqo6Wv0+d1N/iul0bgzkPqCvwurjht8Rd2iMQfDCbR9rLzZGpDpdjrK1r7dS6CbgwAtwQJc9/IZhabzk9ZbRI0QT/p/Sp9xOTrRc05gYwggX3Nk0vYw3TzKuJIuOrDa0P/yHQIwHxERpZD+DG8nB6LEOM26+6m/Eqax9kP0PAqp1NVoraVKlA/wxh3vT7hShal6OcHe3LS1fILBTER8yk3nBFnrW7q1yGl/ZfZU1SCu/30j8//ctyyVD0OxEhWiCQspkms08Wk2A62rStmWvQ7uFgI8kPWeJIZGSaBCjKnVKUWOsxxqGaocPsVWyxuxfMia3djP7RzJRRgTU1grBaHz0tSJzLWbfVZmQYKnNeDU7SELykkWUMS6Yyfk1W7NZstpxf4o7dalbfkIUN2nlrtxDDk0A2hHXEWEJnLf4ZQck37Li5MG39HzG7CGHm1Y/q+y44D249jhmsM20OOvYohxiTNln3c5B+NjW+8CUUtU9pPcL2a1gYGKcxXtxfr0vGWRflOPzc3n+nayAstuzMfRafZdv18wtNtuJ5DJ7ZvLPMDov/Brh1t6jNWsCxmCW93B22NDBKYGnNlmfRlLFJvefrilqXAdGvdLKep2xgicP/aCybrgV/D5ZBYCc0jJO6MaDcYsBfNBWe3RiJ5gW4dQrDxzyL715wf5Ih2rXbg9OshNmo9vzE9OTpqOPfyD6kXGoqPWFXsPLJMH0WWS2DLuhoXqa+oIT0C7pKo9dUZ4dYH9KCrVrPEIQyGocIyh5H0rqaec9ZX1vChV0/lpjoLUvnSe2hvAthDp4qP7y6gc70+bbAV9qMC0nZH0TrKd/alM5cSW1VCoK/4pcKySqpz865TkdI9EhfrBspHDKwr+MO/wciKRJ1nzW67EfgPpg2JpWNJ9Csf/kYyiQION7nq6Goxguh7RonVL4awuEfdpXhpQ3zk0RMxCSp7y+09f8gWtUNhomRykWgMKb3QoYrfNW3l9PuifVEdObcTD00XzQvpZzLVJNzGjA5sgVcvVuuLapZIseilrfals8dHKwbjr210RMBoISzaar9k/l8CrOidhUAsYLIv6YkdSsXyxXjWEG1KN3RgurCq3jC0mo5/FzoT3LYDo0d5N+04RwyLnA4cv9QsNWHMmSY3NVFdzDzeNs48WYs3gzuD52eL6T7eDh4ly4QaCXlhyH3wjqNnk/yUEQuUEuCiTDGrJjH0UFPp7/DRbNeOcU9S7Gr2ISwBTWc8AOzKLrvbHy0BH4EGu/DW0eWrvTVIGctE3YgIelImU4lbFP9cKZqw6FPWxYrIR57Njp3Pq0lSlLO6haVpwH5HaT/AR/yotL8Gtv6W+DLjtMHjn+e5lOZLe7ZR21U2SlXjldb/zsZ+EV1wjvzaY5jzUC7G98AQ5wipvbnL52IupmXFDcN1yITehodI0Tpo6mENSr0ArdL2QVxjxYTTIgDrFwNrSQPycA9yyWgYVTdKB78aezLvXK+bd9Pe7dpIFUCS8Mkrc0ionoL3Q6VLQEqxKpwqGIuBjQ8f2aalQ3L+2HLNq8GL81/eA8HKldW2eICcXuoHGsBRrlW6DgjzGn6Au4PRghpkrq+k8gg2PueqgUbN/zo3ezHVUNNsVuN19vZR3nGUBVaWwl0pSinGb0siAq86z/nZbBvmpzsanxl8ZIOsAWiQ7UD/o2IO7CsdJjjXXWC6N5opK/9Bwbv8idp/CsWxKSkwN/boHvlMakj82EUgo5SAAMx95aSmQafF7w9WIMXSoW5GxMbZuKrnhpnx4beGs9MHns3q6xyzSExSSD9bVi2a8APs4MAMWJJ9TKbNy7iizUqfHtDjzW8aGOMXkqv24akB1ero7Sy3PBM9UfXGlQ7wT2q25H+cFeEPfiYS3jd1IdAwaVNTCdvRj05Jrqj9gADhde8lusSyHYGvuZi9tYplPqn3TLR3LwAa44Qh+6a/CRVojf825sLsxHxLxtdlrm1nm1oVxFVooo/tm8zmszEGHsWkqu2QwSBD3JdhfOtIpfaP7S5C950b2O6Qe8HMxACSv/xfMdIhmZLmI6Ms65YLoNOJS515iLYZb1zG3Qd9wH0vWAE49Xg4PH+deJPkwLpkOzjS+rAPnmarvebIi7HuVepAU4KrZCJYoBJLw7lH/2szUAh6d6nfS5XYfuyUBbwLARUpRNVHza0p0g/YbY3e/v6ziJoLqZERuRCxIMWt1QemN9B7SuIoqsH0j2vaU8r56igmO4z+SlMqP4f0F+1gBvRPOTzpjK1XbUoHGhYKMbmMjDZUOpCQ/7UD62sOU9OHjvggFNPEBRHOPYzJj0QW/T7ME83xfPOcNC89bSL/dczHoNvjnz0iHSVkjIebCw86TW6+fWC9FmwqNLu1wwxMPUP7/p2lliE3E8j54Zyth5hj20bqIGZdB85gg8COYGhFxvb72krF121elkXQ8PuEJyr5JSBQiPVie0Oi0FS79920GrJjZdNGa1TNhbGktKPUk2yrcUmCs2HPrMgKjXi4lxzLEFcAaJXpqGQLvQgwbK6alnPaZNGdDKEO2ROFD5hM79wBF5aRFMKMgRwoU3X8GbMrchQ3ZrwyaU84m/eQMcL+9XWjQX3GsgLHD8yP1TJfG9CuGiqeW2XpXiqvcN66YgTdciH+HIVRdvueUpsqlWC9QUWWf8xqYV0GWvnhapGuoDNZ1L70LZtuFp+3SiVyEDtaQuvDOs8Fm7Pc+YJJRZKGNt1WdVYAdRPZT6VMVlmS7UENegUSnr2dMREoPRf4x2c0f1uDz/muXACVO9JIFcvXMBLHxodum1cAVV3OJtf9aVn+KP8ebpivpIR/fwJrCXg00WKZSXw1f45u7zZmy4pIM8wuISFCWj0AkC5BKwLoMB+PLfRdkckUTEPtkvsQTXeSy3m/Pj33IDyTaJL+KnUq8JZmpDumw7sAgg6qnRFoXPrfWDhbSoEho69MMvS0MiMxZc4YZjq9s6ojiUTRq//6LQq2ggYKPNMSfoUM5v078K3FWMfKaD/0XK8gBiIxD3f1ZBhsmSLHF8Y/MpmBgs5aFjLJ/8wmP827RQyWMIrg9ENYCG4B1G1n4pGK+IvvpKyjVaDM5A5+FQLgWdYO+kYli7irob0C0lUbxuEh6aUossquvT7lpWBm2OBN3xd3JKD5XmjaNn7uHfNCO9KC93P+Wi/AJLwa7mVdYyjEBZ++s2pFQSc0z4tGw/OL34FmN62P0ex3HTG6YE7mFpaixHTwF0AInGNy2dKDEBfHKSk9BsIUGO1vA1JtIRkfM3y6/eLVNYoPU1kIIWZGr+jL0Nc2w+r5ixR7xpqzKaFGRwcVRc8zldo0RbpBM9L+pjIdhlFFETMBAEfezjGx2Iqam2aHmdzkz0f9V94x3JpRNeD0+c9mlb4axjKmuSUBRveXH1Wvbb6/safgXFUXTBm9mBZhbOYwASVuRQ560PF5DnT/o2dhw0oPUZrlRaQsMNVmEkklS8AXyzEc6bXFQC1lxJaV2oJ5BXPfPQ2RDwsDj1w/rNZ6n/LYIn4xB/J5ewwBakKT/a3K+/Jl0Rp6Gdu3GT+kh1RfSSYx91wiYZlHrxByBBytT0iZVrQ9PFuuxAkUO9jjMKcMfof4EjvaMPzKoCFWOacMzrairMxdwASxca9Al9fyfxKjJP400bREHS0TN3G0lMEM3CNzzfG73whPNoPCS629lUk2ER5mQVKSoCsGVTVuou+8/SVd2uTLVR2xwnrNaMEUruCgEJoCLWPgbrmMUcJTFiDHY0xztDh8QDYJiqQzV0qAgJxO6yeAmpXVpaZ82mu3AmAj8JaQwHVbZxrxJ3xHQEhhXzwj+ygNA0095RB9ACmsVmvrB0KFNb8myVTCx+mKbV5DZwjw3TQ9dTpYyqn/MYcUGzTuMDyC4lwlehLejJMQe9t2/yvyS74Rimkxp55dBWJARfV3NVya9RpXvsYgdNl9rX1dW5nYn2mgJV6K4TDUdddoKSHpbbh3jAB640/jWHJbAgJ6r2s6n72SzF8/5bercMSCOxX6LyCgTio7NKGrMMK4fomHe1CaQx5XP+JeBXubKoP1QYMHo/WHKwVc5SP6pBlkZofpCK55KPdNeV6pet5Bf4hAA+pOShLfstM2xcRZl44JyeQcfSA3f3ACG/hTeF8QWxwMP3opLQvT7m3sdSq4HFJJBYy4tUH0WO3sEmjqYyYGbbQusjI+DPtYAW/O+q6Snz6edivg7dy5XU8r/TFKFRuFXxpbMqIyi9v8gGgtgxSUI2NnRo9gHQPEWxOWtYn4igM3fZuAxgigHyhuvkFOGvn+N2ztlSqDre+7D5dnqdqJK7//qi/9rVedY6L2PlQU4JPas3XEIs667OZY02x+B/GlNA41lNZ9rdUiJ+0yStFo6eZ2/UQxxcNDfrhVHAoJmNmo4ccx9vy3/2A/bsXbYlMuzdm+Kg19TjLBSNum5H3P+33hKicNLuTQYH3whExLosmgXpJDwMw4MunnRSxXnieHrQKPI1pLyhwfRdpgHYso2WBizFYAsKNIkckImndLqWAOJGDmQvL5DVxfmVGeWn4BVNuhUwfRZQlHYnIXOwI0rCbolcZSZ81HbdIg1m7P4x96vTmvptAluBS1xQfh00mvkdj64dSeC16b/+pVVl3iwBBqq6VUyzK521Bzrg8VV7s7sj4bWUVI1EeH/3gSecyef2K3l2XUk7+m8Y9ZJfglwItxPGX84tmjdlIINMFCu0/5i90qSONty54beQcFkbb1J40Va01/rAWsznj/QJVBaIY4IfbQer/t+f80jk+F67xNukVrzys3bHzPQi/NhQPE0Cntt+RxvOoTyeYjXinb8JUCw46/sBKKLkc5YUwmWB8G5vgXWB1u2Z/phvtmKdsvD7+xvKeqnIv8p2Y8aWBaGxA6cOj7wqfx2yGo7rnGwI/7VyRjCu9d1utzPxQgBiunfGVex723Zpx/RB7HDo33gPv5HCHqmAC3unHL7HFFfeosu5S+stM6qUPLQHB29o4W3UwtSfXTkXNbNTAnRDdRs+QoUpjZnDigvt293BX9EKCaECukytCK8kJ7KJ0KEnoAPzdJemfER0gFgYbReVT+yv9l8uU7zbga7U1bf9dEV00NQLWknAptrlwf1+fe+JK6O6CbipTfffzh2yaCVsF82QV8/n/MlPzsh43NkOzjR8Sfn1M7n0HExjSj9ASJmMpJqv994uUL3tvORfnqBCqFdSjMVrT7p0gRfK7l9ybgOaPdG/0tTiQCyiYx/rPLsfcISlx+at7SwhWpAO8SN8pu4a/RhU4DiyNnhxHO/9ToRSlM7bJUvxRtr7f/dPMtEiKJ+ARw67JgKQ9Qf1z4uicmKxBXeeSnAPLkxPKzPsIzlEtlvRf4Wg0/zvKuW1EHZuqX/qTVJcHte4cjox8OCRMHqLJDtv88hUhKmzYdoqRiJytA4K6SmSs8gyB3IZZdp+KkGx9wGmHX+q0ltEWJqP38ubwviDLWo3jb7cbB9FcYyxEb6eJaWnoXWWGKXneWNnkOj5tvs+eP7bRXG1waaErKZ4B9ip4Bw6NiAgbN9/omDrCXAg3aOFrNYDBUV2nzJfPhLT8b5/fE1XR2tH1bfG3kLt+7mjVHPsf+7Ck5WgEGLnBRDm3/NbyBM7AxS7CBQupwegjHX89s1p8s3rMyxorAvXNj5EpzMsHg9WEhD58nIFaua5kZ5Ty4ZqzzvElEX8/n1OZV1M8XtJTv3goC6Wel1Mz6etsfL+m5/fDoxxiJBUHmYrao2XH8ypSP7vO6t2Wk4GMbySMuOvzkkR11ThFK1yw/fB3A2/8ad9mrKtRG4AWnQDoKey6ydJ5dEZ0xxTY4ii81MGVFeDR/y8zj1+MeHnT6/sluqxbwLsqY4N4o3qHXeRzLEFWb/ebmp/oI9undZOYn54nA/eKgRvGTSDVmMkRv1cpE7x0TvznndyZcZuMn6jfyNPbp+o8UaTVqPNGwkQBU9wmNnVUpP/Ei5BK/rrrYQ8QFKqJrvtAenuDradRy5SpywxMXpjjScxDIS7YeZwcRbcbxfPtrVakNKRLSMgg5eWPqWGS2VEH9CheyRKWmHIQw0CkuOjTfO7fXT0eWkiBwYsvoFJnZt/synuHXIcT1MWlbFUZhjdozv8+KnWsE8lrytORU6zJzNXVG8sRpbeMWtZsNJABWQyHH+bDjaf1ScW4W64SCcfDVnDf3isizvf+bDux2lyxA+lMcLMzOQ95crdSS+RNOJBGmYzodBeNFOtZd2jf6yOe4nimfuubzEx8AtsiAYxEtPqShhV8ALBCtyOjplQe8Tu90oHtnZtFCy6IqQH1D345hj5golQbZq2ASe5Xe0IMFiHfsT1RNfrlN9wDyMOMd5ORIeAew+RsDdCdJRujCnATjzih8XeXIwqpTUX3BCEeNWxKguaPlKjVYXqf5h1y+KHVaVHJcSZCri4V7WA9Ww6qRWoJ+CmbUOmmagmgBmRHxcpgmLtxAaqQNGTdB1rJ6HaVglPeu9V1B+7IIOw8+9tsyEfXZb1oCn6q1PA7IQvhI/jH1xh6bB3/anwSBRbaTz4tctv1iv9+vJdZ8LmiQ4wBIWc28QmARXj0d9oDNAyjz9xDO7yz2XY67odxFD2reN+cH78IwNNs146B6GzMbaAQVKDSB5/kYYZ5x+TsWXZutYT1RZOX7qy73UxyLDLejOZ9Yk3DRFPVpsvSmWXAstAJutVtH9WeNBoLSBQ+bxO6Ym65/2Ng8S2kHA/gHQIQv+FaZWHsgBpRLiiJ3eqENj2OQ9hdQX8gSdcoA3nTyma9SvvNRS4K54Reucucp48k+mtlJzqQAud7KJ3zoETEYWwwG34o2kRiwhfIYJhsv2LY77Yla+FKB6XwMCey3X1g6RaT17anxx1yIATpX/6qalsSpfuPTcSlkauHIywjBsm6kOUxBCnioQonWWvOQjYpLZL9KUld9Knb+CEFHI1U0azR+K9LjsqiqDZU8KFrh+srvXmxfTlTd4lNWmtf0yyDiygQgO+TaqXkmKMTG15zfnHNOz/uaZcn7PYxOUWDx51Z3FSyKXqUa4HDZZQM8zc5c4nIFJ9K8aDtuOGfKhnK/DIzNZVYkQk0jmM0IbxWdauSbwAZ095v/q0AqjrrcvTWqRqSkr1cESOuHkGVvWTq79b0esluJvSvS0eCRQo1UthrOGPgF0NmRlvTJt2G6piuYFYjl5oRCcjlEmXxwH5M8/ARZJJE+FgBcThj1MkkwJkQtHSrJgYOu08fif7WHjrc6u93Iq85nF7HJz05wGm8q2jnyXwDJfRP/IrECyRlnfY+CRJEELoSMI9XAwQaDbEnjXH/zQB1Kb4WVulGPXN9oRcMpq9KaCmhqOhqU6M4hRLwg5Uic9zTT0qiNyejP4wyfRhWhn19oLrdYrK9HmIRxmhqTXAcF804Br0+WJVaxLarcOwRDnfjbW4iCAHS2yX7rFvl40w7axN+pukQgidHMaUyc5Dui3q+7k9BNFz4J852jKNt/3vndSfG0pNoWKO/TLeYqqM6hfX6ObTS9BMv7q2MmfLtnSR3ISzTQpwMucEbUc7abo1SjiuRcRD1K0B9cA8/69eJAGDSbmqXPeAtiKPfGJ2bMzeq1aDXoMacAQA+nAt4ao79ttmI0E1hCJS9Hjn2P7sWjSvMzm/Gi098X4QOtJCeaNmPe5tSAlqJjajZY/WpVafHJYXOAdhwSBY8ht8gvVDcxXQCvIhUej/EcgRlNo0ha9mdYIk5yrQyFiauk1MMKI/Fz34DjocppWSyogp7ApvJIXG7h/MSYEsOv+rXqCp9Bk4zkriQNMlpUMNe9pCxE8dAoAoan1LT+F80bCxZzuE5AwiSurqzo5COosWRGjhoKCSngUWsXvHHzlbgVm7ToqV3ep6BBsgzZzYwz6or0jWiJyUltZ0+pPuUmgNHobVU9Hh26RZlz1nBw6jKLbGD6UcApdCDBYwC0KL53KUx6E63+MJWJfQkPm0KtawcWMg/bJuFVddvklii+ut205Clk39yjFGbU9+agiUSt6IsVtDL5p9XF9Ss/5yJUaol6hUiXXXl6b9/kP3muEtV80slis7wsppz84/zQ3EBx4DTnpS/1RLTy8cxqkmjHqU37UvF6Kyi+hE8KiGsGM020jnw5cG61QlACxXHukH4b3/c/ghGWpQw6i4+mL+7tD/ATGVb3e/vD85eia1TGxF+XZczAmlorDnHJzmMFeWrLuyrwW4exzABVz6B6MhfMW2SZ6yk9SIFyWX6pTYD8BEE7Un+zq+g5wSey/uISV3ZAc3OyImgo/71AsL4nb1PFXwpyKsNKbMRV8yKTHTUjujRt5uWR84+ifVDZSp9cCwEglBkhcL0jHz25owsgZTSkWR7Vn/E2gWnwdsRRHk4f0oiBJS85/DmzrNOqZ/07IKds/xTmnlaTKuQW2AzefsVuNk6RoQ6Gv++sI/GVelhFOLhrDYRyvf/3j2FQabVfJ67iDgBUTfVEABr+Cxrckx+wLy5hIuYw0vVg6t+4sK2JacmjmYHBd+U4u77qV2sFD7Pd9QawczDfL1uQWuX97U1JsD5566Fm8h0TrhrLmnYRd2NnbE9n2kRCI7yj925fwsgfsz/yc1RdstHBC/nQitbgikUFg4NA14QscXYI8VsqhrjkQkYdegwZR7EwEoZ+JxJVHrWdEKj5hd7eCa/WG8PhGO0FbTHPoZ2/W6sOUn+m/MjM0R9/J9wfoevPvAcce/9nxL0whHAJZfXCp56LJZPV468NqkVC551rSQr+JDctsAH1FvkFenBa1xlOs7vzzgzxeNW9MpwZ3JBU+3WWV8rdJm2pEVB5FBYebdszonm0pbl9HghBR+fU6SAEzOu2MAe4SXFVyC//iYqmfOtZ4jHAQ3SErZWRWfO33BgVKTPMnRBe6rvubg6zXpX6+YQoFgXhvjPSNkmAdyw5EyhxMNr7m1tuCuAU1i1I0NLnq91SyJ2svxliLGg8aBloSXT2EIoAx9y+snuTbQgYbfK01ctTRd2+9S0pmYgDXmkZrTvBMGY3/znuuftcxWmD77xpDMvYUxJDC/1NX4+N3PZHOBg+83I3VFT7CWNimO0owaWBSof3MXVAzPs5d3RgCeOlHDjncqOYG18uXy4uuc71n0hLHhOVnYtXP3TbjIrqHE5PFs5aIzjr/666PPWtoIapuvBmh9uGGnqqx5NdFUqqtMx66BR3fEdk3CErDxKS9aUUKI2+0CNtVRxkuuKa9K1TJ9AqW/+e4Jzk0xg+I7t/wFkVJNploZB2MwchisrQqBjDUcJUpiUWat7VUfJzhNealIHSrk3s39EW4h6lBcyczvX7Rr2iMf4a3XatFjtMtqWkXOLpOvHXvowbjmBJO9+Toa+Ww+OEypskBNT5IKYKka3VG8Aiqtatd+3KUbq6yHgGHYJq8BxxIwvSwvieCiiCF/Qnja8xxpryik/t3od2pWXAFwAaRar0BCdpBGe+oSKDyonsak9WEso+n7V+ca1SYJbeqKKLQ5FVQiWdTAM74LddMCTVsRPfwT2WiaPeUxe1gH0rVkO2LlTJSW4rgiKkYq+jVS1dzsg/I8m+Ssk5KjUFjHe6WKynlsxWA2XEEt0a5YSXNnu90Zyymzfz+0UH/Kc1MXX1cSW1hE3AX1KBX9eRhlLYf08r+pNI32OZ96sBYfYdsUZlop5E47Y9j9fV6yitHNMF+DmA/gxHK+DA7K/EeTe2a3hGQc0LBicSOiQHBD48crVfDXZpCsXGlCVUr8X/Oud2lI6GkOkqOsQM7vvBH7E085/SLFecg+9+IXtwlvu6tdWgEDkz5qXbOkDuK0uAr/PFXu9l8lfSgDPWqW+cY/zs9gABEGCwq4z4FAvfaqAkQr1bXSYPaBFyI7og8Htb2CEWM6rZw3IsxDfxLM4OQBN8NuUK1Y7IwUosNJvZz/sX4XpIxqAt81D56wytJ9TBU6TPS07P28103E6VG2X131twa09BDnFa6vQxrh/KZRYXPCS7b+bT7m7w7Mb4a3b2v45WofKZJ7nvUGjN/fvOmbeEeIDqUXltpvBIWj5A8z/j1Qkmj0txCkzQz3q84DOX1y1hf6nNMpI8aEw1G76BHFM3Wg8Bh6b7xF1Ca+7si2eVkWUfzHpQHV1L2AZYM6mJKL/f/3DrLowgE1NRiIjPF+k/uuQheJYFDB6c9J1+CJUyH7yXPt8Yumc+O+RQrfyuH0+iE8M9JkD2lGCpBHu1qPUeDnobLndCr8CKKdZZLUo9naDl/OI3YDM3+cuPKIgKUzrNbLPyfIXSI/qRfCpdEVhWQjw+/tliMFOHcL0D6EV/kMtftneLnBH4XoPngKanx+1flFKmYA7vqVmMRAjQ8xFGuBxmHsJljSjyZ0XLfbLTjXvoHhRjrg+KOD747Ih1ZhciDPiV0gkbsY3MxqPyt0PwnklCEmNu+JcB/TAk4jY+bY4s8/GjBwYVrfTcQZ9Jnk24v3icszxxPWZH7riH7bylAIaRHm9eGXKzIA2fidlOvCgKpEPOr/d3AQpmG/hYSNgF90UWZ00z2A65/yvK926FEJfNUmI/dyPlEP0oFomm3aCCdxed5yvgXg8/3dzFlmkHfCA99/P1xHKFKNeUoauSBKp92EqUDTdY//bAFbU1NuEZog0YQdbKNTjTPqw7b8tVeb/fkN1iMv0C+e1dvV9QY8Aj2NF1AhQQE8iBBz13TInsjZRZSQPAstIRJ4E21LIs2bshEQhsmXhTjEuILkNfEiEfzreziSeLPHPg5kSBScRl/KkEKev1crenb1Xz6iqlZfz6PJiRyzECyugj//0BTlvNyn1gtNAGQd381kn/NY4Yr/V5stb43N+vmnq85NbQc3EflYHOR8HEEBcMxZOti2HX494Bys1E4N8mYWcuOTW81muzWPle24ddQaAJ+wicM5aOFREjBVM204v8eJqL355unO/tDroHvcD77kuK+wFJVpemHf/Ab7RaHPHvbmPA8eD4aLFXwJeKIOn7FZQFsYwn+7VLxJ8zTZ82mmCvJsDK8na8JO0LO2OPK7sn+vyFpLXgIKLxQcGld9OTJSzrE8F50G0C7DmR0qJ+sAkCokL11M7Ynuees0d2BpBOmN7l0gieLH7rr/pmNbJYgkhSPd569z2UjEBAhazpUTszu52luS2Jog3mZ5r/dl8IaHK1N8zKF7A5rWtlMMEa0J6U7/uyq6oh0h0NZa4sgG1VOqi7rYGTRg68zETyP5uKKFqB/8PdDgFwy3EK7MDv/Jf5hwkcE964gMd/156FPOOVVZoU80JA+V1+9K3H18gfIVF1at1L2y2MHAa1QAWjuXHucoublYOYpWA23MoQyyaqLwcJNuJDx04pW2P+o2I7axcSzZQsxFDZ+zpIq/0jncngMeklDq3faty5vdUPBlqoUYeQyD7NqgxufUjWi3faVBn0OpUH5eYrGKxdyyGFDSJ5asOFBZevkRyjKbVnxpxWseFOEC9xRZTD8WlyCtO2rK0d8nNmJAPzPSQ3mVmrGi64RMWoRcYUdU0+/M9qwIdFbcvEG3xbpNlVLTsmqoboLLH3kVXTr0+RteNU2QO7HfO1/Wfuyuz9YtLKvjuBX5CmYPbSS2QHWPv5KP6A4LJCj3F2KtNrdo5DlI7UGC83TdHK92LEa16pmns0u43QYag1YIX1f7wKkVRLPjkKDtol/4Z2wRbmqUFNorqWbUFhV8IJi+hd0hnMAjjMoCdrCAtViN7qUFYYMaL7ws5Sk1HLN+iDq12l/3G/r14720GkJM564Tase7pvfFQjt2iiQOkRtToPGbBqpNoxVnJdsOxziooByGicmBxOXdtPcoa16QkofoE/uVfKdWV4I1Wb7p5BMyRPfETZqP4Py5S1eNxpHxhq1zdw9mA2V5Y5wg+0TNmEkjwo0/TQLuZf/a/9IGiaR8Cm8WuQP9ivo+4pPvFH7KxyQcNK5rCFwS2MUetaNzkezURzKYo5iQv5wzGvVHU3KsUnTwfYhDwuK7Ga10Uj6P8iobf7veYqV3tEeyfrJm5FbzbF0ihXMEXPE5HqNFujWwZpa7nqCPXv+JVnGRTtzs7kPBv3gXYgWl0jDEJuVuGasMyM5cIPwLmCPRJ/iCkEPZ219mObyySw0ZJJ+FDyhDr/+7S/vlIM6xBKcIcpEDpaHwTEJmcUaNMtNtN1OshH2q//y50s8bT9l5ogVaObenZggn7jNzNLDhAWl9SfgvVGuekkTfIzrR+tRZxmjuOmt2H2l8qDN6K1wjb7rGrPo1bNPobMH9FJmI7WMgrJxPT/nqmoQYn0jUOUOR5Z5WTVDXspREKNFl+IxZk8NA+8lGvOB0jIBKlpsHb6qjgaeRMGQl2l88/vNb3amafpV4A6vEQmXK7BNt7OvyD90tTEWOl+Sdd8GfiXr/W5CPpFpVNHxk0PtLgsgsA3/OJWlhj9GuHwD8iP0YodZFBDxjvhFh5pn0bJjtCW2QZ3PaQiPgX2uXg7z8WNQVg/m1rlRQNx89jHhOHeQYb4JH4n+0gmIAyzVItIYRJzJ8YFWS80yvBm/Exyg0D2p9FWoDEHlCt1/0Zv5qgBiGa/UDdLnrrvDS6lHt8iQfzyO2IYsPqcB/Ad1abadyUOWahYZbC9YnxuyFhpro55mN9XaYtSBBN/msK1vHciDuNLWm7adGAWONAQ5ETuxmblLcCNUo9WG0RCRO3foMQQGDETJdhMwP5zs0qJoJUtTMGgrz7ZVosN2XnJJ2UDjgp8uwz0Qc68aeIX1U8J31R0367lxceDD7qqImpWb9viVueahgHaVwz6JI6N1L0mDmavMtxYirlS7agdSZF5mpxk9K7O1PzNXEdrV5iJJQj+OCbq7kPSmIXIPAPZG68dUtYH13sGnO6iI4urdTtSo/Jtemvb0Ismt6WM6sYZe8iSpmV6sUQTYgz7oEBNOtadx0UGH9CN4Q3mmojN/Z0bDE4B58VY1Ru6b873jLq1J2oXYDjn0/0LfsQvSc0pG0iSvRG11KO0Rei9VvePEvW9ojXxK+1mvaYGxfdXFTuMgtoOB49H2V78ImSLMbxCEJxcowGh4AXvoBy3xpaZBBjnO4A4I5vCXaPq0Z9qnNxsfY1dPYhFaCgNWcOevFwNGxmZ/uaYXlPpzt68P+UX4kjTowFyR2aWJmybM7lSzX2gBkzV57R9EXl3UcsqgCzM9W/29Lxui5nmczTDtm/jnNB2HRgt8ayDvFRbVijoy7s118ZFjiw/L3VMMbLMmntDnKTukzralB+eMO3osQyoJPZmX8yWdV3oLPdQHvZQZy0SdzipFHra4m7XwGHOZtvEBrIUiAabAVvZHQ3Gnk+aBVjr3IYUPd2pFewuvET3taWh1dVwATagBs3xbwIHGz1tcgvujUW+sK5QMB8UwgPL8awr+TAxWg9ZxeD6cdkUGygRZT+AHjiUsSmqwsHW/IXR8emkIPmfbVpuUPVjF5AQUWg8NU41926JMtdgENIdTXJyEqprN30x5lcQ8tdZMhQm44+eZIKKZwekkaRxPhpNisRr6wtA9Hv0DyVZCxl8B3XJOzbYqaLJyO6YMLBNd7gbBFT2dTUkBPS5aLmvAZ4b7m/J1fTEGi7SSnWrAIt/5cnkUkxEUQYAX1VLy+UPYjnSvr+ZV65ptB7y8Rp/dB88q0IV7autGu30L0ysBUWibMqEdGUDbMRNI6zTXNKfoF2WW1BeIW02XZ8BH5MzkB70+GoiJB+xzy4DNxe53KPDJqI+T+/E5iuR2LpxNOVvY6tg+ccfOIJH18z947zKq9a9EeEUCSr17qtJF3a+Jkzt88XI3WVB5098/qJbz3khsqmh1PTkno441ZOvSXunlotF2gVf2OnncULk0G60oQmEjRv9WdIQv1geOY/wKVIvdFi0CgcjCp6TACoQjEVd+TvAopwDBA3b5HgbLa5p/Qwyuk5fxLGCv72qArcSg2pHZGoAP1ePNxfnnKskJlmRxW0sIKeCMOwL2J6ADMQrkFgBOplbST/UpUiw++w1TQGGU2ZF347xNzWMiGQzhjmpD+ew88nzEMZICJzBoWQJH+VPGZrFhJQoARArICwESTCdDU3nN5Ic8yEiewmEObZ35d7RwUfkFjgDb2O0MIPVH8iBAi4JwO9B/3uPTSg9hKajgvQcUoBxrUyGwFREzkMB7RW9pu/xjVieyDd9g/8E+jaOZwYDTpqoxDAI0qku6UgEtfvLfWYMLg+aVhJC349ASuMhShMh45l/mNbEoIdpLITy7KGpPpWGn3Lbs/gXnV+oT18tM5bDx5PCmitF5fpsZojTKfrCPPFIBNPXG5XMHtmmQML7je3/PZj+47HtIvG/PBUbA1GYsTGCsOLrR6D6b5pnT1vQ0hipUJoKbOVAILCzvVUbFptEFUedE++iTIGSzLZCU7uNwFY1vkEVo6sUjOdRGZktNWPC4rpm8Sst6E3UQqW1G3yvjQb7mTEwNQ/ZTue0VKRy2V7S5dTtmrbNa7qe9LHXI3+Yw5TVwWycTFif4TpOBNqEuUP8eOZ1zqP13Y2N2qSRUeQisB54ojoXIaRpgiYUgGlqsV7CRTvQoQ1juWrJjW5Ly2bxLtsp4W4HK9s/73ha3zmRX+uSrezL41fu8LfbEPOJBLayVNqxQdxkuUvxkD3AjcL2NlF4E/1KBDJW2+eZActraBn7aEhpUikqrbWaBjnAeovuySj/uvH+xoeagGg/Zq5AIeqxqRXiIhvz9SCOWn0KgDMhW9tdKDsT5ka/OHrLe4O9+Tu173tpF5Kycb5rtqwI68iPG4luyf8sDFPBhb1s+HnfPfOeQoEdJiLtYaKsaPXGrZDDdwVB6GesBLxPX+c268AH9qAegINSIDl/EGcXA8bslqMPXZzXix3d+zBlxgDUDPcxxmueZ1GiohHFOvqxgGqbWe21l+RFmsIN576K3XEq5j4d0z0AJQTp2rNCuY/Bt3nd5nACu0RdUTn2urknVzZQw5r8C7p8tO5O7OAOatjFrJPsymkG5/GsDwKDZX5aNuOmXFCz7JOeUEtf1yhAOOmydNz3Q9c5TuDNjTCWwfRjOR3Z/g6y3+9vK0kScIgOVUtK3S8z6IBVCs1kp5N8IanoYoysdCO/0oBBM9AsB6Lh8US0J2b/rHefe1NC0lAKzX2GFIibDoldk/+3k/XBYIVto0Z4dPHuq7c9ZvvhuBV/FDvocAEFVV+wStlBabu17218VVG+iH+DCp/6MjY/k8TgtKNfOWFFCMwFKLlEyEr7ISqJnATw6aRl5P8e5X5878IlJRCBeGpfiee5TPWTjDX9XHugC5HvRaxjVfEpAtu8gkj212Y/VwINmCqqvUnKfvahuVnbW7a7+hzSCi4+vBGZAMLy7ay8ftxJnkkD0V5wJXgKKdavMx2mRofG1rSUVDggeuRAgoX/21XZVTL+1X0LhaJkEu9nXzmDvYkFtlD/ESOxmY4lviAJkslPrxCDJ4AR4yUO0G3cvn2lJe3LnLPt4HU1o2sEoNNkUdlY6WBARVQORJQgNfOpDmq7it9RVOdZiEcuoN+34SPZHLpA2RmYT2I3xtI7ogZVDTSdLf7S3QjhCtI2msaNKq75alz0mBkp0HrdU0yMPcBLI3sXpO67fALozcbt+uQHSvwunGctTw329VCoGKrMU6q5Ja2zpUx6+HHwxUmYpSoFEOQrPiEKdSVnGqOeldjjb0VTjBBM3plBbQ8pJ3352JTXGW39rVU9Cjx4x03g9eRZh+EaWBhKA12ju9iPEkTFXZ4doTBGxx6aVn2NB7VYPavYcDgt5TcGCAj/NAFja6lnkUI1Jh7PEaZqvlLji2oNJxfpimfndZhNUQzKw1o0Lwd3VvXwPKiClSOBrhlRFHUtBdlwtz75Kt2lodZukMoRHq3R9mrxH9OvhhSHRxSB2oWnA6UwLexl/4kPvLU7T7GM1zUihDyx0MO7FPG8R0ZsV9csSWSuUBIbEDCiDFzEnKbqERgTK17c+7y1p5tbcZGNiZFBcjTdYtXCBrnB4rYleoQ2xmwzCvEI0zI+PaMYa6QSbOm306TfS3Hyk7zn1D3O+jnkRO/t+Lo2RPgy+Lc9qnUGZ6LrL1vqMDO9Bbup5qjU/kgv+bfNnxAPnGQPXw/vtsAWcaGjW2RfXZzt7JH7rAN9fyMA6R8Zr4k4mRO/zZhJyyIIfjPyT3oCKdNdAM02gP6IYMu09q43SmclFO+rW7H8Je8NU8ZAUmp/Ukz0KacUne8WnHqronyDSKKbAqXe4C5czDfzpcT5szQIaoSmr49vz4uGlLW/7g1lBisf7xbz9p3IeftrLyDMh6jbWMX4YwQPl2HpbbWhwwVSzmBr77rBE2ZpU1XN9Ntaf8bM85MVNWlJD+rIkphlESYWU/NcBND5IRIuNGODA1OwINkiFKmSkzlNQ7VaaOMYnWp8AEOuxrfjqzm3Lqdq1iHkLWtlbaxWWyrXN+wyujF2HhYl5H4cokrBwjbhuyx8FqdMX1KxyL266AlGEKAcFsCWp23B+guft/sxwGr6ysjUkqQ/EaF/BvYvGSZzGWlWlOVzdx8n0M/TVOJZ8knw7j52F41w86Kc4rk7nmnOF8unswbnapt1MmH9b5fewjvMQzLQoKtGaInlpIihHgWMntuB/A8t0DEA29+ukJSdCnpCFg79EMg3iT2pGm/OMH3IHZ/Ai1HJmocEHYUj9+l/W1t/lg/svuFLowf3TdMozONWv72nYPhkbs3mzLfQpuVlMx+vXD68dbcQMhctkIVjxpGFiqF+ef0wxggn1Qe/y1RmI/Tv5RoRUC+uDqQyKxJRIBpNl9HMWdcg+azh68b7NjaXGp202b+dVff/giV3BgH8cZ4OaQH1RFt6pjnmS/kvobsxCzw/TFz1aVH0DTE3nOZmfdf1SNWvn334amTwacB66hyNTXBE5b/zNr80FHUXiXhDNwJtHTjyYyl9puSBmvdJhffbmvLKOEwe9t3d4iEkiGzWRRf1DN561fZz9Yk5SnMm9eXYS0uk8FyUbLq8nwLJChaI4H+Txj2cGJUluvCJkQwed1pHPYgX3pMmZ7fi1Y3ywzFe+J58orZEsiRG2YjOS35KzmvL7aAlcVzhQkGtX/62BUEBDX6ePwwuutpYPsG7tgHpMy8XgUmRAmdz30u1Cy5F0RlK33nZp1ve85T2v2Dk/npfx7Ek9poq+V37cRLUVZEFufvZUhJpKqWvrrkTgRPoHp8aamDINOMkAnvrUTptiDDqKBzNmaIiI8uIMG9aZ32Vul+El853mpIvUOaeTpaNse4tUXQkfJIlWy96B+bYaMfMGzjdOxACU4K2yZdlf/6x+dAXS6l6wg1evGXpEj4blMLQxf0aUWWUkYDSyH2sBtnXxe1rKiPiBTVoeVEpLPPdaoA5Fb1Lm1HAuys6l+ykNatvGzetUU/CZUxTKACV9roTtZuP+IrrhyyYT/PSUEW2i9aBmbw9PCfjPd7su0ZHKjrufePDLN2XyGGEpNwjH69kKlRW9hWxo36irdsRviVIGnSffNOftbuAyIjyJNjykcrH4yiQsWxmUAeDJlcUoZ1jWeaWtuJTyBo45xeqY49dZ2ekwDf3QiKL4cMKm0/SMRuoweGp3JfLJsM7RoETjXVorIRNGGK4PehdsAJoSEAB4aamOg1GRFoDeoWUUT2RfjjzmmWx45YQkr5gL/tficTDxCDprtw4qlVK7IAaHlrUFD8CitQHPC1MASq6ILZVJtlA3asfJP6cUQ9IkgPxkm2ao0zBUhftpjiPHnuOG09IIb9beD/OVf+fEL/zVBJPqnSsXZ8oLdVXc6RUSpH7sfI5x2M1tQFrAaMLHG7+0AfZbkLigF78CJcJimwk+m511ciy6PpEuZkZDkAR/ifbT9wt/IWK2kZqEzf6P7qDUFpaxsUvyX07dfePZ0Xi3dg2gmlSArRRDvO7GFRxFKCPx/0rPIbZOZ/MB1tEBw5AYxO3PYhX5DANYPf7qvEY777xms3jAyx/3jxbAYpOyjubvTI9e6BGaEla4UgTalEeht8Cd/7NInRsIN67y4vTBlThMnGH5XmSXWWvrKLJw574g1sFrqtcjThJmT14efTFKztodP/qwUDXX/1lTHLvGiZ/83yMCTB9RqGwW3cWfsp7RxC50Q6bs4AQjZC2zKwdhme3rFul/9bTHKyhwN1mtXyQtZWXPoL0YSkf9k5sVSAAchUS/CpvrANZSr1PLq60HfO6BrbgplrvNFygO6btrQOBcOvdCeb0eRBzolbeFczy1G9aF8owFXMoNcFzZvDHeY0hZaWirMUDRHwcolsDhVpbu8aD1o9UUl4Z2NMVPnnsgWAStGsYKC+LHDedT7ev+voI8eo5TQkzkLN+AQbpCv3nXMXfalaWfQAUXiEsv39rj4AChtjIcrrjSiuZ3sS7VwbbiKydaRuT0vHJ710WoxBpFjyh1G4Ngp/KARSsF4kS12IphgwG978dsB5mPMuQesMxiz97GzuNj+ohO0bDdGdnEtIsrsXwwWqkdziOef+BzaG96y+q/oq1cefkjOPlLoFXrQ77CFnNxZKsfT0KNiKSdzGKPn30NK2FL3xhYzHze2keWJY4J1bCQ4m6RfQg40XRThxAXn+2907arR/bQ3eLsiOVhUPU8GSSoXWclgJJdsMhakcGw8MR/Apd0nJubMKsu49IEQJl1MiX+xkKqNH4OHZDl66auGcmAK7woh/QRdxXKb0fZNa5/dUWhaSr14/PX3102+acO+/1aR69ABLr6oCDcVX6eqJ7nbywwzB2uhoCP04tND3EGSpGZN25Vv//Gi6b1hhVwQH5ogHfm312YfSiXO+ERH0vwWOPmkur9upJAVcbChtPsrHhypWSPpl6JMZsJmcZ4oFFaoQbNWHvhNTB6szsOM6kv/xS0SdM+1dr4krGYrnFm5fH45HO1JhvcEmYzsL2/6mL7UJ/aW/yN/D4vjSEHTBKrE6nvi+eGhwEiqaT35rPMC7c0pYYpJ4fUvfnAyqSybwzDyk6Hor9VW6ZVwupv2IBBMrhS6Ki+qzTuO9x08ODwrzGTrjYs/zRKU21XC0AHsLyMmO/pbFbvg8JZbuS8V6qQt9Md69DFSqgFO/QRH5YrcbjR0hLDJ4ltvDaYOhndUgHtj7KEMSoUceRy+4rD98nWz8OTVt+G4zNitHMKR1IhMFVG7qAjNcJmi+qCCKQDrCE1FJ7Nka3ysnua4F4aOfvMzWWu9sSCNEERyuVz1dLPFOx5pnGvnDx52YUEY4/tRhWwhEgJjOjWdkYI0c4xZQ9UJAEfCXeTJMEi6i/aMyvW1jE12MDzTHyabW8urS4DKB2dtiCxRzJkZkRukCRIW00qLk0lnV1GU4oQvOMxRksnvI20g1w3RGR5Z2TrYBhcL+GnTazRzY11Nko/k0gwa+WSbULIb3X1diHO6wLYunPOq/QuA+yb4zWPuAL7eyBlrKmgBI0FQAt6Y0CRKV43ng/5zS9QevPn1JYg1hrlgyXbAMT6aME9WTgP+bTpUbhM391ZmUUQEx5aCM6loC4/zRf1dfKDrlBX60GV4cClGZNmjTMR7k7ZF63YJmsORpMn9Atq5zxHdHndSmCtSVnoHgmqtS4ITFjlDeBzRbNHb4Yu8CQcT1R4ig2+ZNlYvLbQseHgJfnkPEm6r2qzmvWotkGe6ZzPgoyTzUVC6fmKGeRkgqiWNpViP230XsGcvmSoPni0dHulDZ6L+W9cSbRYFTSXhxONapoRTmwQJoN6uyaCJ6Jjl3Q7Hek0lQ6St6xemhYx7HDCBdp/V2JbLXGhrp2RVSuF5zU6nW8ZAlnYru6Y6vbOJHqUqv48eH5ZO5R2ypiLUDy31BwCizWxTSRm8tGEN+XFUPBZ4qzJnEvH5bcBJo6pN5fkV+R6EnbMd8/2P4K7E16BjGgZ9Qvkn6KoTur9Tw599fkwx3ncvRTghRy0/PokmOdhBTb1/VeaTl4p2mzCpRw9Rty2X2JjIqi8ULD9lbdPWOS/juA2U+XQvMeiHfvnIRapG7cr4aeiWNF9tbff5i87o2B5EwCBqQMUuZcNtjQiPKzSNpVZPU7NW7mwgVbnojUolPFN+/oluSxlL4YO8Su67sDIh+SDU8uBIWlvXfXIlhrUs0WQNQN7UOzqjsjV6QR7m0szuSLxWXkGww5Ol+BGCZYtPrnesTzGgLnZ+Hw+5UE09KCAGdfl2c4UkH30XW5lbgzmAQp1Hp4BgyqUPi1aZfBNXhoCA8O/pBiV3+C89A18BifbMcdlw0oZmjcSqscuAOWS1aP/tCvyt3svGTY18OEcUBT652QujxmhJJ/8lNdJWs5kJLv3f4ELCtVpwgSrBNni3t+ImrAtJpu6dllfFMV/9Y1dBtjDrjfzdCivXb6HzLyUUdRWn1rnPS/R1B9ojJlzm84jqg/zZwVajwzXByqnhRffLyuB0vFixgYlr0ZKkcxFlbCsdBPYDo9RWgLbEf4FrIy+1a66DwvIhei9MKnQMfHpndyhlCLp+FopHjA+hrj4JyRG7qLnzwc7SoAPe+3VIiWo7qrVbGY8ZH72lMU51u03q7AxunHsstTVX8KBhG+A95lh5Ysp88IOAWvIOC+rQHKcJEKu663O69iPVOrPG3nBc9lMgDsybPqI424fY+wUluI+jXwtq9hcVP8sFV2DHLTGzSM3F0t4lyFqquGtJXsBk54VCsSVc0OfcR2y0tPy7QYNdPsNpuBaIQZk5SztsjNQNhut9owNUrjVJWPlz3fzPOx1jgBNuEfk9wBf93E92krZ1fr9bsoZeW/KOd8+mZhm4mQgddidrQuGtsktfoy9RvmR489OJekkdask2aI4PfsZTlR2k2nyRKUgE8aWFk2rHRm4yH9PsXUeqm7szJz+9Te7pS3qqCNxsw9Tnm7n10Qh50LwswnPFi9odDhNSOMeob+FmSFbk6Fp1BgkKRX5BDJHYmccAiuw4J6s6EIMvc2REWEQ5jbgDmq6zk6P439qx95GDWvCTRPSrXjSRA8XQz97mQs8nyk7scstnyrZL2/uKXu91eXlFRJF98JxxZGHtMnMsFP15sJ0lUjcbfniaWhu0iaheA+aDpSjuw6HR5ZKqJrUkuvHc8yfGuEbSrUROW6kdK5LwxAIIViE5KX0bFt2F8ksWUETKFgDR8JKEDoalN4jdvZiVxAfH4iBnt6hD64Hof8qYokKF++kRVqogzxNAl7kzavhnqgJPy6Eijpv/70yceJvm6HOuVbBUKKWgV6MQAt1H51DeQ/4sfKSqm1CW3cosAGnUOwqtBBo652gRidwSUVe4FZp4DEIkrMittenuajYz4f024jFRow0yjNAbAqR6pVYPdLiQONRJvbmDzdvkizRQtVuttahjomGPFPWtXfLBneE8Sx1CZCI8qT5YnaMs3WrwUG42seApqBmGCeM/y3XUxPzUK3Demu6bP/M/jlScPsGn484xnBRFMN60nCUCorp1BVy/5+R2xuks82IxaHOU5NCIbepCSWta3uATAS65cjQ1P8oEf1CGEbnVt97h6FTbEb/S7MJ0/s4UfDn3hSC+8z1Cy6CW9y7rKBjpBOh1+BKxQ/dJKcSFCXqB2PV/lrx4suY8Ji1+vc/dktCuifbKwKqw+JhGARRC/p0CNQ23m5ZCfaxnfhd5OlxetWpN2PPUctXFwxQ0bWUan611Lg02/KF3OsCkQMCA3553I799P5Uw+ict9802NBk3u8PT8KbIeUglka31aec4xWlMeBQ9CI0VgveM5dSWHiMViXaj5xKTDCmtA4jDfsKZIhmL8iaFlxqsv424Q1cYkOJyEzhH55xi5UkWuaw8yqsIIIyXVgXjKV8KlzWm8afUnUB2//z79KZxvAHvujljI3h1kKy/7sH5LCPFhYbOtozxDIBaUyp5onoz5nq5DpNEzWtrP2mVjNuM4TaY4JkdRS4v5WEZKDiRDhi59DY3C2Ng0AATJ3aCpEGsNafQbH99btMDS1UoEB3hkbeSHSTp7ILAmyyx8FMbUEYKOg+SeLZ21LfuPAyOOfzlf9mQc0qbfbdVId9oghoH1ECQDpmlGwb5umEPwYEKfqiqZLm3e83aLbS7IYC/xWs5YiSxd3U7cuvssnciHKdjk9SUi8xxFuKABpPzgbneVYho/GEiL2NACT/7/Q/cF3BErcFj9Lnl31+6FBZDh/5+tzGb2rtfuvyCOvv4YhLEZM9sfy12pVywVeAsKZWimviM/6kKtsrzY5h9nMAFrhKOZjuCvxGtQraaZDwTBCYh10TYrHCskThumkdVOBVTpU06de2ONT+GyteZVqt0Vsa+wNFqz6Bd4RO2QGmqCR0pSrWwAfr7D6q0fh/h4AhjyYEuTfZIw1UNGXi9E/Rjygzl4Fo7vb34cFU3CvGA2+8ZKUn2Q8Fvw0jwoMsf3hgocNCW/V8bjjtwlbNWlWqefMXlm6MoOUWIUqTn05LvlYrLxb6aEtl2lc16OcjpWHvW8TOMVJGez9N1zdaLTKgZOOFN5Hq6iAk/c8ssM0IhzJDiPTEnESxPvz5omoEECWz4rtG45pCeVVShbzXR7DHX5C3rGtqIFcCz6d8oYicGIgvq7sb3zHBH25rLsjORX9st8Tynb/O6TXoi28CiKKa4FENqBJK9K+nr71BRqT87hPADqIlR4RHtgcdEhGuKKQvibDgPy+8VCI1gNy3iFLy0jGAQARUI1Up/funmLuD8TERF5eABQY/UQk32zYrqYO2fFeO85PcuKZvZQ2OB+rDiilDOqW8YlJXiU/TRBP5j1I/Z9Mtd2HkHVpGTabEv1wjBo8IlOGZhFoLUYbcRt5zJBvxbIl/dwvu86NBPbO/VEUg3GOgYLiny5vnBjhCiBIuTgUbjsrcOcJas7nkVCKWNVG5wn0paNd/3ZEIhQWN0OrGAnqXvjxFOeomlrQTl/i13bpGa3dSLb0s5OF9d9SQHT4zDDAP1O3SS3IvyJDQNlpBz1xvr6YMoFpfgG8AFCY0ZC5jCIey9ka+cDYy32Hax6HYGM20gbS7EcotVNV7gD5Q4V224y6H3RC3MSTOOg5AtkD/A3NFsUU20rfVfxtZSQU5YtJjNOtfEOhS0gc8q8peHw9uiIsbfagFgRC+XxSuzn6k3sAa7fo9XZ5HNxrPXXIfLA94dA6cbmvphTB1T2m11+AO7EaEGtqjCQXMxPgM8KIHVlNhf73nqjPIw1vctv4kBZe9OR1RSbkIx2QDBoM6ZVDr1saXXqQNBlXCF4+xiUrwn2vo96s+fNv0NQLUxGbgdt5qbSEL9jiNB3ioQGdwVRwlc6tJdGMJ5uq3jXI/hRFGpuJ1xZV7IyQbjTsT9ClmP8L11rGac/DqFhIwn0+nRgWadTJ2mykSDZ2meqSS9Iy/+10jIqiqrSYV+WO8cFoW5ADgW6a/1xTjqucByGASjrbAejJn126fZqTMsNveBofbwI/LducghUE9LmL2BPhYmX46Z07SZPRK2N+y84r5+MudJyyeNlZtq9dzfTXtNX/w73h6G1An1ZywMWEezsRsSGJafGp1A/E8+YioRWRQGVWPlZC3onpZsC/RckJia9oFHPGnt2wXKl7Di57rD85MY94EyCcLs4pWJUuo2JpzcWHhc5EkaaLAXEcsbmE2jb51JgKkrN85LgkYzdGIeWIRQhxJuUoshAUxmGJhnAs/6Vb4vXRwswDjo9IE7B1VxsXWVd4BVxQYlDb4drwUyBneKfHCurear6gLmyJfwZdCFR2QbfoTLeJg2PGnWrR6WHC5hHDDqIBafiw1PIL8UM+55Q31lmry21Gv1qeEZWLuFzfIweY9I3cDgYwHqqhC0rS6Jv/WBiEL+s8ShnA4CdotOguk5b+Nlom8TZB+9Dds4Bp9Kni3BIlEpBtB/vX52YKAZAxWXclRNGFeIKSJrj/wgUF5SsT3riQsKyrkwzVWW1muxSVo+PgvYhAiuUUSAXKo18RvCcVAX3TiyUp1YgPcnLCbMcnw1fLTpuL3YtAPmZ+31GgBBHcpK3uyrZbFkmaPFRtty80Okr9U3AZoJNoalpXldE5/mq+1Oj8PYnGnLOcpWHuPqnbKYxen8ik2sUI/9f/wTd7bg0CUMaE5QhaCRT9F+cWUMncMW/s252WR0NEBlls5oQ4UdaKgBrHfxzBLJ1KY7tdZswf3i7yeYW9VuOE8qaG/Zdtg407QDysb8kSOsAFZCDzpXircBzDh3f7m9kn4d5rQf9W+6DIb6L65eU6es8CJfiSsJGnvTcgcA9erQWqxGUkWTlJcnvr/cOEnw9K0Sz491KbanxsOv4BTRjcEyHILuufL6B84QbK2p7WqSK2fq7s9sfkvuYynD4eH+mZ11hXtkl/+Ga96Vw+BXKPa7I+ouyZBFrkus6DbDGnr6KSSA/SXf8LMcxVh5VpDlkhyeHPnZZP+mii/uOlH0umADv9jIc7vcjT01MbbeKU08Y5IRzJKqGQUkmibPtsk5yufY7RZzEJ9fbtNBWez2g8nVDgKkdC9IYKPFTym4z/WbcbhKlj0nv5PQHnRfLhhkASjYNzs35b4CVqsx+xM4YcX7oSquKqxP6R6dMUj6wesLSsxWo6Xj+Vg/RNIYa4njAKicGj3DNY/jGJLqhM/YthBK6VZYlvBl1RpEglGXqQqe15lKh2oFsNWFLhRjPgzWX6FDe7yqROFYQno/wvKKmPSiDSH+u9XvwGKVO9jczJNNwKR9xCLAPtVPzSR2v4aATRR3pOD1j35WK4TkEFGgeompT2arhLzxWhDb33AAPkxi3OOa16jgeh83ety7HsQEXXPU8xT5aHjFto8B2vle0jmCTGCKvBS9P0xOtsPTxe3FPOu9xf4ShW35dgQOm9+hXPVu7L/76pbjHkxvrSAjE0BBM0nS5CA4KEoayounsuZv0bEhciBCqASsq9pl8eZ1YXQB2whgwDzoksjgl3NrN1VKuwuqmIZXXJJJxT+9QVksQ8tLWWefDM5OKSNS6w0QU3tFlnO9CJY38pONps6Z/iTT/IhTrTfKHGWwmBuchHGyBVIPNKH7lCa228WKZnPMfxtN4ld3ao3DOOb+YaLOtZGQGPsAQhe0613AlofqtkchoBkjIQ4fJ0ebNQxKLURJP7Otniy293cuTTB7NbKoJ8WQ6gxc4RW6n8E/5gb9rjkcRKo+q36U4Ed+IsFODi8rs0kCJaWAvxs3JWL+ONH5LEXDrjotUsRhMPlHy+VzgnjVlCVuWUIWpB32IEXaKcle2zkiMglfPlyaPp3bAzU430OgSZOJfYXAmnpy7+qw0GWg65BSFev3Oa4H9MAivd+kpYvYqMFNacj2/LoUH3a3raDD7UItwP0IJWgitc9hmPgqjLxH/+qlFWiLeGFryFF0KOvihCcJqRfdhmunLuqfjn/CfLto21Gf8Odzqi+m0/qBuXzZazGrDRwxOKqdV9sLRqffXdQ1tlOEIrxCs3Yo6yDL61BoHiyTzRE4NCrSRUT/xbXR1sS3ZmZ+qJvY+N+WSDW2uoLfixt29qdqCPX/T9WwhF1kJwdiSzMxqEZvJxvAd27LoopiFiuZpWadNMcJLr12t8YP5FPdW9eSaK9L4fA1iM71da8DCrxQHvPoiJ4qCHPtT3l5cPmGkMQ2LW4ImGbhkGVz05I8HOYr1tw7XhrbXxhfe3nZ1OZOoBSw4NNEtF8YIqmyZIxWKqmraKg6JSPtca7xYVFOsY/448rU6RlmceAfUqSxVrzjzv6lTTiLKAsxVLyDHZ2LkoeD2oGl1QF7hMIvUUdlJV5tDe89R+s4JM8MylFAdpqhEJ98FPmHdv2VinKAeeFNnmFoqKliyKDxLFo+NKUjkFinEVYurwwWMWrfyja+bD7+P5tk7LeRBsPoKglU6S3HcBc8ZlZ0XVKwYuAWvC8HBCC/21H3lR5JzdS5WGjSqhVWUWZ4d+lBM9nNkjv7oNKVQOMkmcd8w3dkDr2w9QnjgKnH1Wpx7oie/OSF+34K7AScRM4H37RE4tO5lFfx5MUdO5yGt4w9QkKw7RxrF6KWqrBUlBh9YweiCL7meVhpF7fOTS8G2izcFtpZa6ejz34zgTmX8xKxBtmkqwdiH2M5qBCOqcOOku4lndgWKTdh8LgI+XodVayZbkHKJJvtSHE6VM5ZsPaSf3JbNdA2FGTgh9r0DQVGbZ4aJiU6EFIJvaanNPwYTqvmbgZt0seTiDgBKKrb4qCark3MAzJA/fVDPvxNnAkbKFlD6rEY6ulNjr96UXAVfYYxV4cONQFZjrZjQjIVwP7fRgyhEEQPb+5lFT8YmJ1Chc/t3BdYqWXkuCQj2pBlkfBhuNS5zrC7xv7S/uGmGxKgwfCTE0GxZYqpHr8cXsDrXW2VcdYjthhp421dk45IpWv5op2Notbw+EfzXap31O60UNUCPzd8XsTTwGHg6Lgxn/7m02z7cveCYiY2pmrkcxs9HD7urzlZdvoUN5vZfNF8DKXGDuAs0bNlWVbZyQhYcgoG6yKuRdI4zQBGfioO6R3GCOujPjovdydsr+RFj7SuED6Z2Brsuci/bzhdmnIWaKK1v3/Wpk67T0XYm8xdsNcvhKMaeUOpqInQnUFIPJgaxiu9yNyF8hAeoZVR2azjm4HJOroevTmCywkQkco+EQnCrLS90OVNAZw0QOBDzMwj7ndqQDxwd2DwQEaiNOkUwU6VmL4vvFaR6qFyvEy1e25lD0R6E8pDMxei35ZC9sA/hyEZh+3NlfJMSFzo3RmJci8bgX8qjvrAEbrtxxj0VOkk2I2PbEvgg+FVBAUgKMJTH6fOfA2BUlaYhfKdoX+ealOYHMVpOLbgw479bXHJVShggF9ZaztZfRk4Tu8TsdqlsjXdNr09Tagv+cJrW2QnR74hzlLHBPhl1FG8JNPBjd/VmpVhImL5CvHij27fDlJD4iT7+x2v+bc9fu2PiRrIeAYa+2ynHRWDAngrvdclbMfQqgu8fKfopY/tuDrPu8wgsonuX+PJAgtXwSUZiNZ23Qt/tRTrBlax2uwG/NNlZ32sxpEvsI3xJCZwoXH5ZcGKfvf0M7xblvC562oErK73dxhEnunTrfbTFlRDuYNQM8O1ZnZu1OfkMAtvXvtuf36dL0wD3fX3hlnmXHA89UKBxvDlbW01ZZf/lbtimyqCTcWvY6qShYu6E0Cv4pBFqXrZNp6+ah52yp6wlh1oAN4HIhkOQB1hLi8CjM2yfhwcVotipMnwm/ljUd6Ud051NpkGftdFKBHNCeMlM6/ItG+41El0JOM3/5u4Y2rBUAxIE8KE5R774uGuefAHtUuCQjWgH+kolLcVQOE0o3xB4NjuRF1g4RiIYmBfR/QAw2Myetzi3zgLDlZzez3quaE1pVNmTQv827IK6HzUHP7xSHKhfZTXlY4foVgMsFPdV5g6/b8d0jLznHVEOe9dvcKoh5TXcmNAHE5kwuGK7T6paRJENGhKFGkX70nC6UYBclIj2oPu+mFpOUp7pmohHvctrJOfnYkL+X5Bd/HPqaAUKZMxN4vUlnWWlLTQZKLM60r+8TcpgRjBth1OBRpoetCl9it2E8N2FgqzHxmdXK8HVLbSxP+uSynoj60/xOG+24VkDvWlI9pLMy14GqNndx60Ae2I+ZLgYn72y7Nz2rL3oH5vAzLKj9D+Y9YxnCN6THK0H6O7HHtCZ7S1IfbJTguAFTE8zU+UHCEVkfR08bjPrL0fygyTQXiehrZ0yh21jpl2X62T9CVS94Oe8fXlxSXRuMO5vlfkixWahZsS/8qYnC2l6m65yeIOYhL+n52Ud5zWJg8kMsuFaIO/AVLFKARD1WbDMR2XE0PEuUfeM+iVSWO1csTNdw1SKFo3XbRHp7i7E481O0cPFDu9nXyzHN0HuelwFJ6PDRQWbujcOrVN52pB3pGIWLAJNM/jWFaGKWSIQwpfRx+Y7Z0YGIfnItcF2Cj0A48XKu4XSvsDsTvW3pI8+cNBhf9Q9uhv8MHWrbtpyeNJdCfXfvAttE6JyfT1NXrz+ppAtBZ5au+FeboX10ZJ+q3+pCHaG9BULvN19rJKeMwEgK54OuoCe7wKKOPWSZP2eHwLRtgdZREpXleo6mpLYFBeINeb/rDgLhW6kYFKNe/sYAe1roy7oOnaZjeF1Oq6NXWv2ZR8fgHxPlHYwzdhW4oXyXovxIyXpcLEDo2IGxIxFpC2v830XcCko9C0WWnxZ/Ex/G9qoK1U8JFVNgzQx4/hmKLsB0DAs4GGyK1bnSD5KfqflaMCsQSDFxJpyt8N7ApxLvZnhS5jUdORGuBORX4h3LfjmEgTkaECqMmig3Cb/cjubMwbH/7OKmVp5je2643hvIEeySK3OvVa+Vqv4ISGWkmPHt10yQhyZxwlaRiUla0K3lJ5pwSPJHSXlozF+AA0WMRCurcxcOFjs6xQwQNnM+qgWi1IG1XdLi7A8Tp3ICvd31e8Xj5toVnV47VYehzu9R0JbTGNWq2HLHDdHdwLdI+P8tCM2HzPYr1vuqq3+JG4kh/fq9/WnIuKsxa+enRhGTTFgNhTyoaS7NmWuljd9o2XrCVdZ9gj1ck3imi4lvGGbqimTx4UIUR/E8L8/g5fiVhLw+bt7YjWNPuKI9uE/w5dAimyLsikm7LxBZC160i1CLt/Lac5iJ/BTmnQHRdBC9UlmcZe9jIINOjLVqA60NMV4Q386xDs3H43t7GjI75VJzvBHQuFKoMA7t1CAg0koT3NNVuWi/13yOjDbMyXRVxjyYcPwzBy6jg+KmZtg45OsZ4SKr+eLNh+UC9dSYvbtNIugfPPuNTa6xojvm8yXAdtEqpkG3aGM5ePjGXrCcF56Ku6lSWAtNhL9EZUEcvhwvCndCc+Zu2qhTL6A60lbi1Ym6LWpNJQLPCCunLl8JsU//4B5BMce46I/dy1Qp1/LlBF6+yWEdE5ZyndIK8/B+HqkqEvg8JD8Rlv5Jj0M1ocP5qwaX9OZic30ek9qnwkmJtb3hSVUbd4DbLjN0Tq6NxAlpD/dm1tG5dAObC98eyBSPdQFw5AKZ+l7vWHX4RLs9W75P8UoDYoju6iZD53qfiftdK2HCVlL21mtPTdAnuLxBFteoWlSSM0sEHcvkQWlYWVrwizo+Ps2g7J0evkfS4ygorsewkVIEKswJHxmba9ohFylTuczE0/9hZ1eIWVZFKMOpHjBtiasi38YrLYy/NF7EKI6ENKTToteftbbZlux8B968XmH0UmfOF8KQWkWw75rOSN2ZBqeyXO9eH3yghocRvQ8kD9IVFNljjdti3Q0AeXGk4B4vBn109Od8ID8teYudbE/8h3a+I7c80liGSk8w5Mgs/RcgA1LTuWg3dAvKprCs7JUSPhUh/wtuZQBCLEP5n/cZ43Ua+mI6y/Bg5Kox+XMCJSo/0E4QuPNzs+UKhdrg9g9koXh/ruEdNP67/r69oLwRb9F11CyJOKR+rq2VvE06//bvJyi+qcWHxGVNHauyL0N1fJyp+UIDp5vFvyg9ST+p1WfuPH5bqfMqq3xpitQZJahW7NmjfJ/PZOSyflE7/N8i5EsarBbpiyiMJSfAPpSzLsDO0BUScbUo2e5p8xOUqDXVh5DYyL1KYJ+TJ0r9Kqu/VvrL5OZ/+E4Ii5gVIktDyGa5w9RHLgNKTHD1eTGqOoyAjHhpjHOg9+layLkbgPUe+By2Bz9NgfjIw9lKsrp33wO7C0weZaBrtPJfk4H/l78IF6FVkVdzlKGxIAiNuEIUHHI5pFBjXC5cR0niiKPx7cqVa3tEls/Hoct/Os+XM0IXfrvOqc8sonpLM7TgBnaFCFw9drLXm14SUpXiqGMmKzVQ5AbDH85BE91f5nvEfib4HBcUCyTos0k2ctBjP4DpmjUM66KBH8aP9YkSnRV4fMyVRd0IuvXioBzh4SdTMTBEAaIUHrDdLuGk+0YfpiYcCdVKq+3F+Eu1v2SULsnesmq9Tn+zSi8ptSfTuMkoWG26+hCOyzGyhdJbBnqI8FOmN3JpYmgbJZwhUD7MxekC3xs86faPfCFJsdKz3zqT8FnWJS58ggMc/4sZeEU5mFAGvSr12JHS1i1rmIgnZBlZ+JhkqgTLswJvExchhwHg8qdsqu9keR5OOFrgE/8X4k3vLE57hF9IM986RbjV2raYsG9UhRj7vBm+MQ5kGjgjBFOmQ2jARSCN7vnO42Jwo8JW65N5S8RZxFHf4sRXxfMU0Wir7oyDzf5tHpVKEQpH4uOU4Kn1jybDUQHRDmgtrcdwYD2PGPB+KD+DnWm9+3lfzhXi5qIn+QUothvBMjKq6hLyPjDArK9wTqhpQso2VwH4xdUM4ZOHrlQy2k4CEI0vZ652lQCU4+0aQA9wZKpj7xKXtbnahDbrTXXqzRPLCOqJRZXhtP0yPFeQZzZNd4K4PVAR4ujAaa3IwlgnIPdwgat7Q40NJnNjvT2wHcGztpkG+sSheDUAeBBWzswDz7sm8mf6fafNLmgcj2RaHM9XuByeP6zx4SCtUkNqS3xEcfNjEszh0sp1YqaBlgxsNC3m+zYeUaPkuz1UCdE4JrzgsxZM7E0JlNOIxx7Y2zFJNQzav0flvb8pK3CYwqOTULcsgCeULNLyNLESK6hi/4gHeoPEafisfGRGyXtN1O4Rydxf1FR+HUnrnWiV1c86YEGzOTv95fa8nMhn8mpJ54khsolCns0x38LV5BdRAPHL4Sgac1UQUnnl9p4VpbBTGSMoGxL0MgWi05xvTFMw5mDSvpflU+bZv32Vs46M1BfKBya5p/m8ibRhNWICJFjhF2PUpM6zJuds9cSLreJon/yuxZtfQntPG5VZeyeWO4L+KJSDbUubsjRspo9MLUvDPnhJjMclZAXKHwlytAAKK/7uEOhjnVZV8heaBJoHp5xcaYjjwoyLzwWAoRX8U3lFxZjmiayorKtr7id5zJDE+PCC1/z0bOyZHHSppr8Wg+C7xmfw2/s+6ZFzG2s4upXr2d/NLstmK6JDzHGjea2tS+fMSAUUKe+/UijaUornoAm2pdwZedxIqFg8ZfOatbZRuvpYwPr546Do94RaUwFv+ZU+rwmWFcc7BphMOIC2PGQcXbI2x2kZMEHgROivuqnX/7AryGB/eBGrZKAJVwfQ88lsTRZcVX/mleiQ7bgRMlV0+GLz5MlQ/Dj1a3fYYj/HbnrkMoNH6gpMZT/Fr9EP72x8kY3DIG+IAppWpkTqR8yufly16QNVShYQv2JWw7Y/TJlyzKtSxpWSDbPRuLcnxA0WBhtclo58QN9eC95fqO5qRQidLH+o57dBAgdXFuhU6SHVt+uWhzzJIqXTugwdCgsekvOGyidiKXisQ2+B+h7QKqTtRlHtPacn1lz8DLTguw1syN2I9EVzFrme9tnQ4glWGypPa4ePTMN/YDJRgKzbres0hfRpOGf32vDA9tIhO3r5QJjfxyiDkufhqIXUZ+1OdH6oV00+cn7NPOrbQ2G37BKtQPLvGDIYwjsaqMHKb7ycdrD21H+MZOvRK90EZ+wQX3u8fBEDmEbHipuCdsBdWkmvRGi1wdmWAyA4zuTJmOMffIZPATFlXv/LB3g9yzcqwG4FIfpoXpOeY8E6fXDDHJ3wu9UARI8XKMdT5ME8Og/CKIKbYya3RfVNy35JI+xX8DPLixnJ463C5KKkehn+z+RZe6O7+9Ix4u6mFy3Foce+K8sZmKcayRcsVjQT3dr/AlBYX44PCCJvfqErJonngcRecN/WFPpafbvRSdoYRiSNq3ovMHx29uTMrY5OYpbuYW9m/hqDCwv8FyGO2Qb86EwDSR7zi5jWdo4EVHtIfiSNUgjzGIjCr02aFOyf6rPYKvl/CiHn+4x9BPhIzzpJmEBdnlELJ8nsTWNmOTUgCEpVs5sbhdITRAE2C6Ta0SOa2Ln8ewcHrL94WXZjl4nKZKFYT4fHzgchhI32t1lZG65NO05hFirBjHSkpf9O89d7JPz/iavMrIb8EA7W1GwlTRWQOZKPeVn3OTincDjgsjklRmq0vyhcKZ2inbjwedAMyzemgcA7x3BFWP7QhYUFV3SABJcTL7Wd9D4PB3X/Cz1SEAbwOdlWqa1lRkEqzE5p8pQiFwWfuytyuOrQA+L3v/Gpwvij2mHys8M5v8lJLgnGQs+PuJqSFV9iFcgXadHjnIlvKpmy22l7NzMPiyrPn+RylAir6HDKfdOMhv7leU3Hi5vOodsahW6tVsFKdzHmfNUg5hWsgmekU2Ip4ToT5MmRLaWXHnDlbtpc8z5HTc10a3OSH0MeYNtE7sYFz1fXR+zHUzM/jxfmnYzlRbeTE9upqcHvOBxfffPEqiyKMZzv6iWbWcI1BBEz01wtS4sDJ+WT56SZUk3UIa1k7rtxmoLSyQ0hWMbqMv9j7TS+OuOjTgAGfoAIp1HYBWU93C2RxyVaN6BMULCpEI8LsxbyVcpLCD8bpd4sABF8EXWBIeBH86CZPlJ1P6apvufPAGg6LyUJzKoWaoZdhzLJnSsX2ScJwhzVNmavVfpL3xs/684dvNVV2ss8BH/JBIL8gvdtaMtAVCI0djteojIlAhJ8x8BhJMCc/EViBj4dKDb8HtJMYCi5SjhYijWM+Xt3qahSrQpm4P6ub+eCeT7E3DxosSdynuWkBG3FrwDZmiUU1b1LsKYK7UkseN0USkRtuwopMEkryiIcWSCwaMSI2l/uZ4mz3B7Pf/nZid52ezq4x9HSIKvIS8YEhVCFx763hRjvZI4HTDxIQ0GKdEwVFUh2CTRM98G8bDsZwAgGPRVYS9Kpy8qJ8DDPxUsCLETmNc7R5qveV3A662cqnbbsNE+GMPwgLlK7sGAXdIZfZODgWgOTGihtF4Un6gRRcjJX7uGmGuK/u48m1Iu/zfMlbw3U3J6QCF/5WRG9/HJfwfxwu13Ja/LtQ89tFoc1xN059k84Wzfy9NvjKpNT2ato3Z7jI9GGxUQYcSLUUv6gmQE4a3VTmtCDrWo7g4Y/xJNh6uMf2KR6MSmTdi6caAcgftUjQ74DH0ezewISEW5Se7d/RZHIK+xa7yHe6TN/y5DrMd8esjbJobFMeNE9K4+KxBZJCIAzBV7rCXPKn/JmZAIX+YoPS2O8TkMPfB5dlnrJ1X8MQSYeR1RgMM6KEvFO87DDq7qRAeszPg14OmDwcInrx8/gZS2+Z+olkgHVw434CoCnFHGWkWgJjN8LwWI50464ZB5lQm7ODdS95JUTuag/c2Tbg4pXeEse2iB1aoxZvcq/04WIhs6Bry17PbWGoaoFrGemqsWKIzcU6Uv3bQcJkf3rcCTCx5q4oZYYe6x6P2cENrJHRQ03cKq9pOskOJMfGF3C55TJvp3u2Y8pDMfeQMb8ofU/iTRsZNyW1freYRWBJk3hGmxSLgxOC0JL9igHljwFTP9usTUBwO/efv80Wt2KlCBgz8NxCIj5Xl2rgVzy7l3yxCpeMQ2CYQCa90n/MhUWI69eXnlGKaBzqnw3LNEhjaf44UfHqo8bS0KhGLU0qHmQEX0J7sRsvQ/ndRfA7cHmExcBr6EqdcqmGebHGjLYj/LXELHbYhVqZhsjKvq8BpTU++Eq+doCsfIQh7lKcsdPS/zIa0UxkvuDoplgOmpPURZebFKpdPuF1nYhP5xw6Tw1syH2fAOr/+qCCkc8FrLpQT72KlYeO6L2R8DmKiHL7uEuNwMPSX0c5QhmE7vL8MjER1HtU1PdPRl2wo+lPSTlFH605y7E6X0us6Pfl57aklX2n+oeERzXHbZQlY/i63wimXzy9iGm4SBVvJUG2ijQTJO7Cgfa0OuED4Paz/3gbTo8vKDxrR0PTXF2uajamNtuwIZ1cvOE8S0jCR/TNjYrE+7rzuPPglTbYImQN2YcUItY0iGiLFJ7e5IrFEL/Qb+8aahVVFntCnaqOGDm1MNA57kV9TclXvWx+/uxIRny5TvauLzNKqHqHnzFxyuIyWVQVSwoDRZx+YYBQAh0a60kUqmH8jHm70nOvj0TZR7tw9aHVubeNOvQWYkiIXqOiA3u92hhlAslbRiysFz9W+H+QEy+CgPISaEbJMxH2S6i47rtOjZ374Sc3ODoKjmY1kXfg1z3iA7cmHbJCY2yfX0dj8pNu3vLl+C/cVROUG7cBtotZcqF55JBOpJJWMjYU6lYKLoiWE/GdN7VEnp/DTze21e3ScNUd1Ktqt+mRAM+PzrsVf76Y7jfw33i0aINtNlMAeVlWOJrkJqXRNop/TkapZZ1XTqre6JMMWjkrUqTE/fddFBgwqD7wsiEwpZ79QiV7U29xCGuL5jL+4EZGJRz/Uae2WCXMlYFdJIHs3bHrzlGpSqHhb9hzV3f9VhWO871oYDaobjBPtUklYeVs+w4KgwArvkY64NnwG/aLJLMF+ImmdpTw5OaQAVf6+i3GVRDSZ3FTkoB3ju4rVdxJDj28BzJLsg+XbNImnyIhFu8bclmk5Yg4xoRojcO/au1GwnaHCWqjm6InoxDPF6WTAD5/K08Be9wmamwJdnglWGYkAt3R0G5ZGi6ajZBAztJavDxNUzOVjlOCtmvuQY0XmMZToRGPCU8jq6bDujPikS3rfxVOETSKZeZCPRTn3L8IFVKMShJCtunFe9Ch0DXBciP66fD0ZCLnwrGCPROo2+KbO2s9CS4TVdKwww+VnIADjD4iDgxca3in8wd4aV+7vvr1rZLyXSrnb1TKNJFrH+t3q3bgSnQ2ZcNiKJtBae1yDFO9UwtqaCEX1JQ1lTfzhf9ovwnlgQEh8QZZYybCpkTn451QbR89gMWMun4lrFgqqFPsC44mHQasq6Vs4kOfgdx5w8nTIS5unEF57tB5N56o4jilX9Tgl79nWmCB0OS+2lB9KoIUrghimybOtI4oUYFyszuviLN19SY1TPsS4Cuo7ikx7bDH69HhAAxI6KiAUPEBf6dKbXgtIPgK/rJTI2811zUYXNag7ACddMd/5tGt7wY9ApSJyjbdT+BKgOHWrxb9+G2hqiT0xqOh/jcx8KTiIwvnT97OVK3U8eCX7PApRurG5IDWbtPK6UnV1bqhY3vvos3BG7em1m2pDszMmhwJAgs5lFjSJfRTLd+7oOEg0CzYsKcjvgAb6TqSYEqYRkY7u7o4RoD8dZs0wlvIOOyTNgR0qCnESQaiUMyC8wz6zQnnMQKL8nbFzfLmZ8LnzHV9mfG3b/PXIpwEWXY3FB9tlIrVaO1vsS8Y88+BHUiJl7f4azN3I1Eq2W/yIDLbReVVX7w+tC+WoMS7WYZM3dWTdb497M9ihrq7QNcoKheT1M5bgQovEka6Xk5ZWbWOjX8ZbVZCpQFZb2io764bfZuw7AgOw6T5QxebAmZGiqJO3TuBFQFNbmkNx9RtRpb+vWY83p1TaJBK8UqOrjbJKvrCfyMaGRpxveokeXSOALoBYsD9MjJw9bEgOP2ta9v6F7T3jry5WuZd3l4X5EStluq0bydSu4b75dP4C/c1l+/eF7x1TQA4p41+ssEFzAoNLKfDCfYxEWPqHmY9NKWqnZXJ7gCrYIlxdkC5OfFn8Bt7gt6xkRyeZNzuqq52ELrKi2K3w1dJ/QMTddTF2gZmjHTQzBfg4ZtR82mRYYxb74pr9CXVfV1xVLJZ6Vx+Mz3GMsqIt2AfRFUBaVzp5fyLX01NiCURjFZm0UrS27C8+bBrK0XdcPjd/E0Z4gqSMKiH9uL9XE8+48Bf1F7o9/OFS+Mt79W5H13j96KSDKsTN2JV3/usff+S1pEv6tBG5lNeXmGVzb8K2fMYHoCmlQ4DaZcU7whXt7ku/Im3dZQcjJBV+Yhzsnpt6erlvslhBojdJ5NEq3lRdgz08EzCMUyFJ8qusvGYB10ZQFiImt+1D3yNKcwUHoWDQeylF+Y6eZ+qRjKwLumtp4OOBDkh/4s1n0LPLlKn/ao0MK3ITQIQHl29aS/4sopWcRJaR5Ekjuv4u4orP21joLdf7wKb50i6O1zZUjq+rIAoXUxdqY9HjoXN+r6LHf00tAu0sE9e2Bhw2IMsKh9TrjYY7+qCas1N8+zjKSC/7RrFbXmyT5yglrEQ2pOm6z60baHy/L95+1vFWQRUkjh/LubssUKcvL/AFR9nD/6GLA3ZCkoOhujnt/mfgwcyoWQh6CGj/+Yel7ijhO5uRLZk7z0jkEvByYXjGfdgBd4LqPHqo0QTBSrrCAvlooSoGXq7VW0kAvJpjSkt2GPzVNMWWSXbQGeQP30pI5ELSH2M9QnUpPpjjfXlXHo4ExXaKKi5eUQC0UDJl6sYxpNP0FnJl0T2RahW6iScU/rGoFNml0n44B8RrQgORVBq5NM+/zE32fewJ4YvGe3pR29EaBlWI4SClhBVz/3mJq+a4JggXB15opUQSElJG1l+XukLBvnBvh7FxSDwQChfsMMzTcHeSQIhpYHgfestjFdLEsOsSogYNDmjJ0iGh8YnVXplANtYmNbmXO/+MweegCWVKb8tkDop/P/gPAMUy1nPTUDYZBWq5xyidm5f1PwNNNbaD90mAw3O5ZOXLnLU/rX8vVZmMwhmKU5/t/KhGZTmRbb2F5uaagXdldaPk5Gk3Hk+/+gfmZSjFvCxbj0euBkYr0xZeN2narEFa75T+yVsrH9OP9bnZiPJMBdftdfAdp/MqAAploFAXA3iGRxTbQDrhn9qc48eK63+CVOcNlGeJdpIEso2iO/vapIver1Ds1S1ttHImFHNNbNa20W4icRzE4BiJ2cUZRBeMKl6go3x7ZVqRGN+Sw73jFHR9XWDSfUzGTzAHtHob6iha4ZY0FUWMD4BbRqCCgv8DM4MiZGBuz5ztVi8XseX7kEGvGffKYg+Vy9zu6OHagyi6wRKKqwB3LwiEhW/xbdRqvFz5QisLhr1X1wtAHULnAsPSTQ+RnMaUrHwdznsnzRwxwqYLBKoA/XGMjnHIhYJjL6cJDdrcxom5i0nQOtzP6xeBKc74n+h4jIwWkviJVx9Ul5meWQ61i1bO9wkZEiTXem6FNq+YEUWfNuIRHJk1MoPi7AgRcnYQfc7IYBTZq48GLXSIBE/ZecWsETFWxwo7axifFj9mzX1chlVa2mUxscw06YY6+fcTvexgBYRZV1NcvpJPlvJ35Y6Rsoju0+MBHVY4yXaye5u4nIfqsiQgPcNPAGsRRWFF+/LIDNZjPjrSxhFkLtB1mc5JdNY+kpbx1/1QoG7e+YNWuwW2mO3lyYvpn3NHXoFwoiju7a8fEJRTzHdEqcef1p61GyIJjDW33m9p361yhuCrcg5zuVQQSwVSfzghQfrK2+IiyEjDwHyyCTgKl3qKXMDYG0O5k/04o7Ltz/Yj/CClzt3GBRT9EdVpz9SQjViRPqNh5BSUdNjwticDotEvPYsdX4ywtl7Ax2oA9L+FJTiv5hvXhdKrsyby4cHYMdLZj5nQkwIrx/c53i2bO8y1GUj9m8B3uJb0kanMQtxifqIBCnpBKB0KyXu4FzxLQjWf/4orZ3lYNR7loOP4H43pgbs7OdxiQLYKk1ZUoHQEu46C6Lkl62eU5lIYGEy9fbUxJ6/viQzgyF8l1ElL8RPMiSQxjp/m1qkykNyWc4MTocER2C9vY4RV2OM92RukzdVSHOP5AkmaIwrUoLkXBZhGoXnZQBu7E4noWZ4WBrfgm/cVsBPi91GdO5YD5z4bX+ZKNgGyZ6H2mw+EinFmcTHC2VxznHmYZkfTGcyjz1XK3YuuFa0q1Jh5wjiIM8yKzXrKIREDmB04wcXZ/iC6m68MCryurH1upBDB3pTA2KqsXJs17UxDolDVEzlrtB1EbII1C41cY//G20KzLsJsyZCQgcXYQ1dxKCxoEbQ25OdK7mUOjir4juAckR8ubKNe6AqMbUbLSsXfrZ17BgNrkQUf+3DAUjMhEeDA9VTsVJe+u3QFy7JmQyNYcrYyS5cru9zrEXuYkpU7jad4mxiKgMbKljOnWCqG/6EPiBwYZOhe3yX4aRmSKxrTXzv1lGp2naJ/x47y321YPtfOebYun/9ZOMolwfteygj+5eL9DmCMqJglVVP/ACSx75ZAqI8c/NjeMhk1ghxRKu+zSJkxHvIhTZOtLu5bLx0MSqScRERoR315MK/xHyZLDgw2LtebBR0jnKhPSjdSjVhrYRt6IxDBdZxQTCaade3g0O375eqjvCqDEIZct+F0dxwIpBLGiW22akPUq/AdSrxaejeNItJHvgltZ3lbGDU3r7nIuT7CBASzcoeaEPmRUFOf8l3NEcQcvSuvJHS1/uwlWg2KZXtQt1W1nXgENCPUQ2hsWU64GnRCuCfQKDgJSdBBZ0l1rtRWMgJ5Ojx66yS2VyQf7xLEPtvXCyiAmP65O2ia/36yimfl155X7nIUzgoQOpDUTyigz5bNSinYRvgz1/WO8qX86RUHRIqrcyndZzaNJd5nd5tUAbdiqj08xtxm2g4OHRuK1G8x8oxxiCN/PMghNZTIzzQRZVMhLBWsZUcrsG/S4rAtHPovbELiu0iqts49AMyCY68EXGEHHyG/qfrb6gZyLGB0liaTMYyv6Mba3VYGRJKYx3if+7e/NAFD29gDgJlWiVPs2F/vCDZZzxwKVLRpL2G+QNf758KL4H0JSM1WsfChqb6+VIT2ogDCelRnSjaeVYzZ3bs3BXAcWOUlMFMZpjZ4fJAU6gVn44pr9BAxciSPDNBmdjK1LTE3eeZn0fWoYI5K9leH1uYKzrim9Oz02H9Oiumt9GBz2VA/jnUdrX1GLM0fGDobR1Pv8wWNe3XH/LJuxMoAU/cunuWO/vsNB/3mLKGRMbHXyrMnAnHZRhaOE0rp7jKBy556QThbdn0Y+AVINONg9Yq6SR7S0vStmGyn44H9gWrzrMz3SBUSrRKTbIcQ2CiUmyrFNk8bGDA+yHtjGA7xfoyb8s7cfesvwXVB9HkJGUreGlpgxpaKoOMts2jKb10uqdHEwbcxGtd8oAsT9o2iRi5g8XdajFpMDnX1RisBaj8D+P9yQ2xeTPwmxKOWBS3Upodp1GoZcs1nakxJ0Rd3vJlE8yUItcWKShnm/8V++N0k+QQ3928AgWpCzO1x8anBEp5soc3M/375L5MUKPtjHSPee82inUp3Ciq6jkcPyXPVSaDsWNvUYmPhmTmbmZX0xSeM2V6ZjqXYRY/aigpSgh8Rp3byIW0TXiTJ3TCKJ/XhnWN3XUq/iHLsvM5UlYFUAKI3DT4P7yllMhBymC7OqGtNGVRDAGkJeDeUeQiRET9LL5oOxDmM0PFHmrUtPulIKwaFWZeBrVwxS2LmHNfvb4KrKLcOelkPzZNorQ4mYMZPxx2l/rojby9ijNzwQQvVXKUvd+58dCBKMu/7Fo05lfsZHEo2CAUcl8BdXwEXrk4oS3vgA9Xy6WxqS4Qv/Q8UCqdn1GwpP15Cd6b9nBiFZhHQL8HFGG1jqShd1WIJ8/YvrSSUChkDIW2Yn7yIaKJBIALFHkM9SUbKC/9THfp56otYjCNRrvg1y1WeZOEZGIiwfeU9CjON5IC5ge6v76f05b8kWxjRqpUa434XGLiWViLhYWp+42TDwOL/z5xiypjVFrOaukt1LDHR0AT3g0Aby2XAWJwpAH+KZMs1+wdgefzLdrpbtdlaSUoryb5PbsXI0t8sDRCx8jnJSOotTeAt68aId88x4qzkcp0DQMPVz8rDafDw6jZuBJPlG8CcLY6RJdXZO6kzJ79S2bkWLALZqZgyCN6vRxykpzsptmVgbgu4f91gXwsxmuXnXKWjXBn47zWH2Cl6P3OLc9j+0xPPCORhyF9E1W4nUmJ3HZ+SpFUpbyIoOeHmUmUEzmCzkPYMpkyNjMBDQLNNs5Syg9gUIHuZfJx31f0uiik6n5m/h8vJ0jsuB0MnsBembh8h62H1CP5OQb1Vu3j8DK9ai5h59gKnr5sbgvPRlcLJFcrdea5AKnkVP0XyEzX/45fWs5af1hQP9mt9PB3aNrMNAbk5J0YNcZ5GNoNtOrmDXrm0Yt7/t4S9YEIzuuO8uwyoXTLAObipfhO/C0FGRA6SFk34BzR7TtpmUR9dwc6EV4xxmJ83YdcDR639G56+r56rUmEusgJWYQTmasF2IpcCck7Hn3rwLoaZTTPRY/hlLNkR11eCmCRgw3fPB0TRXaMTDjkdYJH7CfyJyws7UVkazczkmdt0rY3V5leHL5ULsPYq6mgbzibgwMMeu40Io9VFd/ZPCppWuzW1dFoUUdZnV9XRZtlph3cBZiQ7gaoKVzYjDQVyBrZMGJzjH6h43tnWJeOj8SwIDn3RNFwL3wkqW3razKtJRTXAgX1iIjnkrnS9E6HcXImNn4BmTFijwzV28N9W/OVL3mHKY0MX2OhlWTcWDVj3/KxrbzRCafJ2wFpgXDmo8k/m23TL9q1IDgqsE73vcGNecZDDQQVXshL9NoOrOmPEF0H1MAz3gCb/BUc/+oUrghqfNFXFhxnfIxTXkJPRNiYt9JFLdTx8e640jLQ/MyQCCDeQn6xSHQAtPqQpSznMB/+sGbcMAJSJE+uFK/tAdfnph1QMAfwN5FowJKAf0J+N6eDuOlhsb3periMtNVABrh4QmOACxo+2/Mpr9YhLd0WVlxebfKS7CRz4rhMGYwecUTYH0TB4ONUeAmn7uCquNc24AJmgznnptbVVj"}