pioarduino-node-helpers/dist/index.js

Collection of Node.JS helpers for PlatformIO fork pioarduino

!function(A,e){"object"==typeof exports&&"object"==typeof module?module.exports=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used")):"function"==typeof define&&define.amd?define("pioarduino-node-helpers",["global-agent","got","ws","jsonrpc-lite","tcp-port-used"],e):"object"==typeof exports?exports["pioarduino-node-helpers"]=e(require("global-agent"),require("got"),require("ws"),require("jsonrpc-lite"),require("tcp-port-used")):A["pioarduino-node-helpers"]=e(A["global-agent"],A.got,A.ws,A["jsonrpc-lite"],A["tcp-port-used"])}(global,(A,e,n,t,s)=>(()=>{"use strict";var r={317:A=>{A.exports=require("child_process")},303:e=>{e.exports=A},810:A=>{A.exports=e},852:A=>{A.exports=t},65:A=>{A.exports=s},2:A=>{A.exports=n}},i={};function f(A){var e=i[A];if(void 0!==e)return e.exports;var n=i[A]={exports:{}};return r[A](n,n.exports,f),n.exports}f.n=A=>{var e=A&&A.__esModule?()=>A.default:()=>A;return f.d(e,{a:e}),e},f.d=(A,e)=>{for(var n in e)f.o(e,n)&&!f.o(A,n)&&Object.defineProperty(A,n,{enumerable:!0,get:e[n]})},f.o=(A,e)=>Object.prototype.hasOwnProperty.call(A,e),f.r=A=>{"undefined"!=typeof Symbol&&Symbol.toStringTag&&Object.defineProperty(A,Symbol.toStringTag,{value:"Module"}),Object.defineProperty(A,"__esModule",{value:!0})};var o={};f.r(o),f.d(o,{core:()=>v,home:()=>P,installer:()=>GA,misc:()=>u,proc:()=>c,project:()=>ZA});var c={};f.r(c),f.d(c,{IS_WINDOWS:()=>g,extendOSEnvironPath:()=>D,getCommandOutput:()=>h,getSysType:()=>w,patchOSEnviron:()=>b,runCommand:()=>y,terminateCmdsInQueue:()=>j,whereIsProgram:()=>B});var v={};f.r(v),f.d(v,{getCacheDir:()=>R,getCoreDir:()=>m,getCorePythonCommandOutput:()=>T,getCorePythonExe:()=>M,getCoreState:()=>V,getEnvBinDir:()=>Q,getEnvDir:()=>W,getPIOCommandOutput:()=>Y,getTmpDir:()=>N,runPIOCommand:()=>F,setCoreState:()=>L});var u={};f.r(u),f.d(u,{PEPverToSemver:()=>k,arrayRemove:()=>J,disposeSubscriptions:()=>C,getErrorReportUrl:()=>K,loadJSON:()=>U,reportError:()=>S,sleep:()=>I});var P={};f.r(P),f.d(P,{constructServerUrl:()=>aA,ensureServerStarted:()=>gA,getFrontendUrl:()=>lA,getFrontendVersion:()=>XA,isServerStarted:()=>pA,showAtStartup:()=>jA,shutdownAllServers:()=>DA,shutdownServer:()=>bA});var d=f(303);const a=require("fs");var l=f.n(a);const X=require("path");var H=f.n(X);const{spawn:p}=f(317),g=process.platform.startsWith("win");function w(){const A=`${process.platform}_${process.arch}`;return{win32_x64:"windows_amd64",win32_x32:"windows_x86",win32_ia32:"windows_x86",darwin_x64:"darwin_x86_64",darwin_x32:"darwin_i686",darwin_arm64:"darwin_arm64",linux_x64:"linux_x86_64",linux_x32:"linux_i686",linux_arm:"linux_armv6l",linux_arm64:"linux_aarch64",freebsd_x64:"freebsd_amd64"}[A]||A}function b({caller:A,extraPath:e,extraVars:n}){process.env.PLATFORMIO_CALLER=A,"darwin"===process.platform&&(process.env.LC_ALL="en_US.UTF-8"),"atom"===A&&(process.env.PLATFORMIO_DISABLE_PROGRESSBAR="true"),n&&Object.keys(n).forEach(A=>process.env[A]=n[A]),process.env.PLATFORMIO_PATH=process.env.PATH,process.env.Path&&(process.env.PLATFORMIO_PATH?process.env.PLATFORMIO_PATH+=H().delimiter+process.env.Path:process.env.PLATFORMIO_PATH=process.env.Path),e&&D("PLATFORMIO_PATH",e.split(H().delimiter));const t=/\%([^\%]+)\%/g,s=[];for(;g;){const A=t.exec(process.env.PLATFORMIO_PATH);if(!A||s.includes(A[1]))break;s.push(A[1]),process.env.PLATFORMIO_PATH=process.env.PLATFORMIO_PATH.replace(A[0],process.env[A[1]]||"")}process.env.NO_PROXY="127.0.0.1"+(process.env.NO_PROXY?`,${process.env.NO_PROXY}`:""),(process.env.HTTP_PROXY||process.env.HTTPS_PROXY||process.env.ALL_PROXY)&&(process.env.GLOBAL_AGENT_ENVIRONMENT_VARIABLE_NAMESPACE="",(0,d.bootstrap)())}function D(A,e,n=!0){e.reverse().forEach(e=>{process.env[A].includes(e)||(process.env[A]=(n?[e,process.env[A]]:[process.env[A],e]).join(H().delimiter))})}const z=[];function j(){for(;z.length;){const A=z.pop()[2];A&&A(-1,void 0,new Error("Terminated by user"))}}function y(A,e,n=void 0,t={}){if((t=t||{})._id||(t._id=`${A}-${Math.random()}`),!(t.runInQueue&&(console.info("Put command in queue",A,e,t),z.push([A,e,n,t]),z.length>1)))return x(A,e,n,t)}function x(A,e,n,t){console.info("runCommand",A,e,t);const s=[],r=[];let i=!1;function f(A){if(i)return;if(t.runInQueue&&(function(A){const e=z.findIndex(e=>e[3]._id===A);e>-1&&z.splice(e,1)}(t._id),z.length>0&&x(...z.pop())),!n)return;i=!0;const e=s.join(""),f=r.join("");n(A,e,f)}t.spawnOptions=t.spawnOptions||{},t.projectDir&&(t.spawnOptions.cwd=t.projectDir);const o=Object.assign({},t.spawnOptions.env||process.env);process.env.PLATFORMIO_PATH&&(o.PATH=process.env.PLATFORMIO_PATH,o.Path=process.env.PLATFORMIO_PATH),t.spawnOptions.env=o;try{const n=p(A,e,t.spawnOptions);t.onProcCreated&&t.onProcCreated(n),n.stdout.on("data",A=>{s.push(A.toString()),t.onProcStdout&&t.onProcStdout(A)}),n.stderr.on("data",A=>{r.push(A.toString()),t.onProcStderr&&t.onProcStderr(A)}),n.on("close",f),n.on("error",A=>{r.push(A.toString()),f(-1)})}catch(A){r.push(A.toString()),f(-1)}}function h(A,e,n={}){return new Promise((t,s)=>{y(A,e,(A,e,n)=>{if(0===A)return t(e);{const A=new Error(e?`${n} -> ${e}`:n);return A.stderr=n,A.stdout=e,s(A)}},n)})}function B(A){const e=process.env.PLATFORMIO_PATH||process.env.PATH;for(const n of e.split(H().delimiter)){const e=H().normalize(H().join(n,A)).replace(/"/g,"");try{if(l().existsSync(e))return e}catch(A){}}return null}let O;function L(A){O=A}function V(){return O||{}}function m(){if(V().core_dir)return V().core_dir;let A=process.env.HOME||"~";g&&(process.env.USERPROFILE?A=process.env.USERPROFILE:process.env.HOMEPATH&&(A=H().join(process.env.HOMEDRIVE||"",process.env.HOMEPATH)));const e=process.env.PLATFORMIO_CORE_DIR||process.env.PLATFORMIO_HOME_DIR||H().join(A,".platformio");if(!g)return e;const n=H().parse(e),t=H().format({root:n.root,dir:n.root,base:".platformio",name:".platformio"});try{return l().accessSync(t),t}catch(A){}for(const A of e)if(A.charCodeAt(0)>127)return t;return e}function R(){if(V().cache_dir)return V().cache_dir;const A=H().join(m(),".cache");try{l().accessSync(A)}catch(e){l().mkdirSync(A,{recursive:!0})}return A}function N(){const A=H().join(R(),"tmp");try{l().accessSync(A)}catch(e){l().mkdirSync(A,{recursive:!0})}return A}function W(){return V().penv_dir?V().penv_dir:"PLATFORMIO_PENV_DIR"in process.env?process.env.PLATFORMIO_PENV_DIR:H().join(m(),"penv")}function Q(){return V().penv_bin_dir?V().penv_bin_dir:H().join(W(),g?"Scripts":"bin")}async function M(){const A=V().python_exe;if(!A)throw new Error("pioarduino Core is not installed");return A}async function T(A,e){return await h(await M(),A,e)}async function Y(A,e={}){const n=["-m","platformio"];return process.env.PLATFORMIO_CALLER&&n.push("-c",process.env.PLATFORMIO_CALLER),await T([...n,...A],e)}async function F(A,e,n={}){const t=["-m","platformio"];process.env.PLATFORMIO_CALLER&&t.push("-c",process.env.PLATFORMIO_CALLER),y(await M(),[...t,...A],e,n)}var E=f(810),G=f.n(E);const Z=require("os");var q=f.n(Z);function I(A){return new Promise(e=>setTimeout(e,A))}async function U(A){try{return await a.promises.access(A),JSON.parse(await a.promises.readFile(A,{encoding:"utf-8"}))}catch(A){return console.error(A),null}}function J(A,e){return A.splice(A.indexOf(e),1)}function C(A){for(;A.length;)A.pop().dispose()}function k(A){return A.replace(/(\.\d+)\.?(dev|a|b|rc|post)/,"$1-$2.")}async function S(A){const e=new URLSearchParams;e.set("v",1),e.set("tid","UA-1768265-13"),e.set("cid",function(){const A=()=>Math.floor(65536*(1+Math.random())).toString(16).substring(1);return`${A()}${A()}-${A()}-${A()}-${A()}-${A()}${A()}${A()}`}()),e.set("aid","node.helpers"),e.set("av","12.0.0"),e.set("an",`${q().type()}, ${q().release()}, ${q().arch()}`),e.set("t","exception"),e.set("exd",A.toString()),e.set("exf",1),process.env.PLATFORMIO_CALLER&&e.set("cd1",process.env.PLATFORMIO_CALLER),await G().post("https://www.google-analytics.com/collect",{body:e.toString(),timeout:2e3})}function K(A,e){const n=[["Multiple requests to rebuild the project","https://bit.ly/3mMTOgB"],["WindowsError: [Error 5]","https://bit.ly/3GTAtlG"],["[WinError 5]","https://bit.ly/3GTAtlG"],["[WinError 225]","https://bit.ly/3GTAtlG"],["Could not start PIO Home server: Error: timeout","https://bit.ly/2Yfl65C"],["`venv` module","https://bit.ly/3bK6zlH"],["after connection broken by","https://bit.ly/3q6StTV"],["subprocess.CalledProcessError","https://bit.ly/3EFlxWq"],["Can not find Python Interpreter","https://bit.ly/3wkz0Qv"],["platformio-ide.useBuiltinPIOCore","https://bit.ly/3AhJHHe"],["Could not start PIO Home server: Timeout error","https://bit.ly/3m2Tbl9"],["Could not create PIO Core Virtual Environment","https://bit.ly/43hNh04"],["Compatible pioarduino Core not found","https://bit.ly/43tNj4C"],["Could not find a version that satisfies the requirement","https://bit.ly/3TOcnBK"],["PIO IDE: v2.","https://bit.ly/3H70AHl"]];for(const A of n)if(e.includes(A[0]))return A[1];let t=`${process.env.PLATFORMIO_CALLER||"vscode"}-ide`;A.includes("Installation Manager")&&(t="core-installer");const s=new URLSearchParams;return s.set("title",A),s.set("body",e),s.set("labels","auto"),`https://github.com/pioarduino/pioarduino-${t}/issues/new?${s.toString()}`}var _=f(2),$=f.n(_);const AA=require("crypto");var eA=f.n(AA),nA=f(852),tA=f.n(nA),sA=f(65),rA=f.n(sA);const iA=30,fA=3600,oA=45e3,cA=45999,vA=eA().createHash("sha1").update(eA().randomBytes(512)).digest("hex");let uA="127.0.0.1",PA=0,dA=0;function aA({scheme:A="http",host:e,port:n,path:t,query:s,includeSID:r=!0}={}){let i=`${A}://${e||uA}:${n||PA}`;if(r&&(i+=`/session/${vA}`),i+=t||"/",s){const A=new URLSearchParams;Object.keys(s).forEach(e=>A.set(e,s[e])),i+=`?${A.toString()}`}return i}function lA(A){const e=(zA()||{}).storage||{},n={start:A.start||"/",theme:e.theme||A.theme,workspace:e.workspace||A.workspace};return Object.keys(n).forEach(A=>{[void 0,null].includes(n[A])&&delete n[A]}),aA({query:n})}async function XA(){try{return(await G()(aA({path:"/package.json"}),{timeout:1e3}).json()).version}catch(A){}}async function HA(A,e){return new Promise(n=>{rA().check(A,e).then(A=>n(A),()=>n(!1))})}async function pA(){return!!await HA(PA,uA)&&!!await XA()}async function gA(A={}){let e,n=0;for(;n<3;){try{return await wA(A)}catch(A){PA=0,e=A,console.warn(A)}n++}throw S(e),e}async function wA(A={}){return 0===PA&&(PA=A.port||await async function(){let A=0;for(;A<13;){const e=Math.floor(Math.random()*(cA-oA)+oA);if(!await HA(e,uA))return e;A++}return 0}()),A.host&&(uA=A.host),await pA()||await new Promise((A,e)=>{const n=setTimeout(()=>e(new Error("Could not start PIO Home server: Timeout error")),1e3*iA);let t="";F(["home","--port",PA,"--host",uA,"--session-id",vA,"--shutdown-timeout",fA,"--no-open"],(A,n,t)=>{if(0!==A)return PA=0,e(new Error(t))},{onProcStdout:e=>{t+=e.toString(),t.includes("PIO Home has been started")&&(clearTimeout(n),A(!0))}})}),A.onIDECommand&&async function(A){if(dA>0)return;const e=new($())(aA({scheme:"ws",path:"/wsrpc"}),{perMessageDeflate:!1});e.on("open",()=>{dA=1,e.send(JSON.stringify(tA().request(Math.random().toString(),"core.version")))}),e.on("close",()=>{dA=0}),e.on("message",async n=>{try{const t=tA().parse(n.toString());if("success"===t.type&&t.payload.result.method){const n=await A(t.payload.result.method,t.payload.result.params);e.send(JSON.stringify(tA().request(Math.random().toString(),"ide.on_command_result",[t.payload.result.id,n])))}else"error"===t.type&&console.error("Errored WS result: ",t.payload)}catch(A){console.error("Invalid RPC message: ",A)}e.send(JSON.stringify(tA().request(Math.random().toString(),"ide.listen_commands")))})}(A.onIDECommand),{host:uA,port:PA,sessionId:vA}}async function bA(){if(PA)try{await G().post(aA({path:"/__shutdown__"}),{timeout:1e3})}catch(A){}}async function DA(){let A=oA;for(;A<cA;){try{G()(aA({port:A,includeSID:!1,query:{__shutdown__:"1"}}),{timeout:1e3,throwHttpErrors:!1}).then(()=>{},()=>{})}catch(A){}A++}await I(2e3)}function zA(){try{return JSON.parse(l().readFileSync(H().join(m(),"homestate.json"),{encoding:"utf-8"}))}catch(A){}}function jA(A){const e=zA();return!e||!e.storage||!e.storage.showOnStartup||!(A in e.storage.showOnStartup)||e.storage.showOnStartup[A]}class yA{static generalTasks=[{name:"Build",args:["run"],multienv:!0},{name:"Upload",args:["run","--target","upload"],optionalArgs:["--upload-port"],multienv:!0},{name:"Monitor",args:["device","monitor"],optionalArgs:["--port"],multienv:!0},{name:"Upload and Monitor",args:["run","--target","upload","--target","monitor"],optionalArgs:["--upload-port","--monitor-port"],multienv:!0},{name:"Devices",args:["device","list"]},{name:"Clean",args:["run","--target","clean"],multienv:!0},{name:"Full Clean",description:"Clean a build environment and installed library dependencies",args:["run","--target","fullclean"],multienv:!0},{name:"List",args:["pkg","list"],group:"Dependencies",multienv:!0},{name:"Outdated",args:["pkg","outdated"],group:"Dependencies",multienv:!0},{name:"Update",args:["pkg","update"],group:"Dependencies",multienv:!0},{name:"Test",args:["test"],optionalArgs:["--upload-port","--test-port"],group:"Advanced",multienv:!0},{name:"Check",args:["check"],group:"Advanced",multienv:!0},{name:"Pre-Debug",description:"Build in debug mode",args:["debug"],group:"Advanced",multienv:!0},{name:"Verbose Build",args:["run","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Upload",args:["run","--verbose","--target","upload"],optionalArgs:["--upload-port"],group:"Advanced",multienv:!0},{name:"Verbose Test",args:["test","--verbose"],group:"Advanced",multienv:!0},{name:"Verbose Check",args:["check","--verbose"],group:"Advanced",multienv:!0},{name:"Compilation Database",description:"Generate compilation database `compile_commands.json`",args:["run","--target","compiledb"],group:"Advanced",multienv:!0},{name:"Remote Upload",args:["remote","run","--target","upload"],group:"Remote",multienv:!0},{name:"Remote Monitor",args:["remote","device","monitor"],group:"Remote"},{name:"Remote Devices",args:["remote","device","list"],group:"Remote"},{name:"Remote Test",args:["remote","test"],group:"Remote",multienv:!0},{name:"Upgrade pioarduino Core",args:["upgrade"],group:"Miscellaneous"}];constructor(A,e){this.projectDir=A,this.ide=e}async getDefaultTasks(){return yA.generalTasks.map(A=>{const e=new xA(A.name,A.args.slice(0),A.group);return e.description=A.description,e.multienv=!!A.multienv,e.optionalArgs=A.optionalArgs,e})}async fetchEnvTasks(A){const e=[],n=[];for(const t of yA.generalTasks){if(!t.multienv)continue;n.push(t.name);const s=new xA(t.name,[...t.args.slice(0),"--environment",A],t.group);s.description=t.description,s.multienv=!0,s.optionalArgs=t.optionalArgs,e.push(s)}const t=new xA("Rebuild IntelliSense Index",["project","init","--ide",this.ide,"--environment",A],"Miscellaneous");t.multienv=!0,e.push(t);try{for(const t of await this.fetchEnvTargets(A)){if(n.includes(t.title))continue;const s=new xA(t.title||t.name,["run","--target",t.name,"--environment",A],t.group);s.description=t.description,s.multienv=!0,e.push(s)}}catch(e){console.error(`Could not fetch project targets for '${A}' environment => ${e}`)}return e}async fetchEnvTargets(A){const e=`\nimport json\nimport os\nfrom platformio.public import load_build_metadata\n\nprint(json.dumps(load_build_metadata(os.getcwd(), '${A}', cache=True)["targets"]))\n  `,n=await T(["-c",e],{projectDir:this.projectDir,runInQueue:!0});return JSON.parse(n.trim())}}class xA{constructor(A,e,n="General"){this.name=A,this.args=e,this.group=n,this.description=void 0,this.multienv=!1,this.optionalArgs=void 0}isBuild(){return this.name.startsWith("Build")}isClean(){return this.name.startsWith("Clean")}isTest(){return this.name.startsWith("Test")}get coreTarget(){if("run"!==this.args[0])return this.args[0];const A=this.args.indexOf("--target");return-1!==A?this.args[A+1]:"build"}get coreEnv(){const A=this.args.indexOf("--environment");return-1!==A?this.args[A+1]:void 0}get id(){const A=this.coreEnv;return A?`${this.name} (${A})`:this.name}get title(){const A=this.coreEnv,e=this.description||this.name;return A?`${e} (${A})`:e}getCoreArgs(A={}){const e=this.args.slice(0);return this.optionalArgs&&A.port&&this.optionalArgs.filter(A=>A.endsWith("-port")).forEach(n=>{e.push(n),e.push(A.port)}),e}}class hA{static STATUS_CHECKING=0;static STATUS_INSTALLING=1;static STATUS_SUCCESSED=2;static STATUS_FAILED=3;constructor(A,e,n={}){this.stateStorage=A,this.onStatusChange=e,this.params=n,this._status=hA.STATUS_CHECKING}get name(){return"Stage"}get status(){return this._status}set status(A){this._status=A,this.onStatusChange()}get stateKey(){return this.name.toLocaleLowerCase().replace(/\s+/g,"-")}get state(){return this.stateStorage.getValue(this.stateKey)}set state(A){this.stateStorage.setValue(this.stateKey,A)}check(){throw new Error("Stage must implement a `check` method")}install(){throw new Error("Stage must implement an `install` method")}destroy(){}}class BA{constructor(A){this.projectDir=A,this._data=void 0}async read(){const A=await T(["-c",'\nimport json\nfrom platformio.public import ProjectConfig\n\nconfig = ProjectConfig()\nenvs = config.envs()\n\nprint(json.dumps(dict(\n  envs=envs,\n  default_envs=config.default_envs(),\n  default_env=config.get_default_env(),\n  env_platforms={env:config.get(f"env:{env}", "platform", default=None) for env in envs}\n)))\n'],{projectDir:this.projectDir});this._data=JSON.parse(A.trim())}envs(){return this._data.envs}defaultEnvs(){return this._data.default_envs}defaultEnv(){return this._data.default_env}getEnvPlatform(A){return this._data.env_platforms[A]}}class OA{static AUTO_REBUILD_DELAY=3;static FLOOD_TIME_WINDOW=600;static FLOOD_MAX_ATTEMPTS=30;constructor(A,e,n){this.projectDir=A,this.options=e,this.observer=n,this._rebuildTimeout=void 0,this._inProgress=!1,this._floodStartedAt=Date.now(),this._floodAttempts=0}dispose(){this._rebuildTimeout&&clearTimeout(this._rebuildTimeout)}requestRebuild(){if(Date.now()-this._floodStartedAt<1e3*OA.FLOOD_TIME_WINDOW?this._floodAttempts++:(this._floodAttempts=0,this._floodStartedAt=Date.now()),this._rebuildTimeout&&(clearTimeout(this._rebuildTimeout),this._rebuildTimeout=void 0),this._floodAttempts>=OA.FLOOD_MAX_ATTEMPTS){if(this._floodAttempts===OA.FLOOD_MAX_ATTEMPTS&&this.options.api.onDidNotifyError){const A=`Multiple requests to rebuild the project "${H().basename(this.projectDir)}" index have been received!\nAutomatic index rebuilding process has been terminated for ${OA.FLOOD_TIME_WINDOW/60} minutes.`;this.options.api.onDidNotifyError(A,new Error(A))}}else this._rebuildTimeout=setTimeout(this.rebuild.bind(this),1e3*OA.AUTO_REBUILD_DELAY)}rebuild(){if(!this._inProgress)return this.options.api.withIndexRebuildingProgress(this._rebuildWithProgress.bind(this))}async _rebuildWithProgress(A=void 0,e=void 0){A||(A=()=>{}),this._inProgress=!0,this.options.api.logOutputChannel&&this.options.api.logOutputChannel.clear();const n=(e,n=!1)=>{A(e.toString().trim()),this.options.api.logOutputChannel&&(this.options.api.logOutputChannel.append(e.toString()),n&&this.options.api.logOutputChannel.show(),n&&this.options.api.logOutputChannel.appendLine(""))};try{const A=["project","init","--ide",this.options.ide];this.observer.getSelectedEnv()&&A.push("--environment",this.observer.getSelectedEnv()),await Y(A,{projectDir:this.projectDir,runInQueue:!0,onProcCreated:A=>{e&&e.onCancellationRequested(()=>{n("Configuration process has been terminated!",!0),j(),A.kill()})},onProcStdout:A=>n(A),onProcStderr:A=>n(A,!0)})}catch(A){console.warn(A),e||e.isCancellationRequested||n(A,!0)}this._inProgress=!1}}class LA{static WATCH_DIRS_UPDATE_DELAY=1e4;constructor(A,e){this.projectDir=A,this.options=e,this.subscriptions=[],this.dirWatchSubscriptions=[],this._cache=new Map,this._config=void 0,this._indexer=void 0,this._projectTasks=new yA(this.projectDir,this.options.ide),this._updateDirWatchersTimeout=void 0,this._selectedEnv=void 0,this._apiConfigChangedTimeout=void 0,this.getSetting("autoRebuild")&&this.setupFSWatchers()}dispose(){C(this.dirWatchSubscriptions),C(this.subscriptions),this._updateDirWatchersTimeout&&clearTimeout(this._updateDirWatchersTimeout),this._indexer&&this._indexer.dispose(),this.resetCache()}activate(){console.info("Activating project",this.projectDir),this.rebuildIndex()}deactivate(){console.info("Deactivating project",this.projectDir)}getSetting(A){return(this.options.settings||{})[A]}resetCache(){this._cache.clear()}async getConfig(){return this._config||(this._config=new BA(this.projectDir),await this._config.read()),this._config}rebuildIndex({force:A=!1,delayed:e=!1}={}){if(A||this.getSetting("autoRebuild"))return this._indexer||(this._indexer=new OA(this.projectDir,this.options,this)),e?this._indexer.requestRebuild():this._indexer.rebuild()}async switchProjectEnv(A){(await this.getConfig()).envs().includes(A)||(A=void 0),this._selectedEnv=A}getSelectedEnv(){return this._selectedEnv}async revealActiveEnvironment(){return this._selectedEnv?this._selectedEnv:(await this.getConfig()).defaultEnv()}async getDefaultTasks(){return this._projectTasks.getDefaultTasks()}async getLoadedEnvTasks(A,e={preload:!1}){const n=`envTasks${A}`;return this._cache.has(n)?this._cache.get(n):e.preload||this.getSetting("autoPreloadEnvTasks")||this._selectedEnv===A||1===(await this.getConfig()).envs().length?await this.loadEnvTasks(A):void 0}async loadEnvTasks(A){const e=`envTasks${A}`;return this._cache.has(e)||(this._cache.set(e,[]),this._cache.set(e,await this.options.api.withTasksLoadingProgress(async()=>await this._projectTasks.fetchEnvTasks(A)))),this._cache.get(e)}onDidChangeProjectConfig(){this._config=void 0,this.resetCache(),this.requestUpdateDirWatchers(),(this.options.api||{}).onDidChangeProjectConfig&&this.options.api.onDidChangeProjectConfig(H().join(this.projectDir,"platformio.ini"))}onDidChangeLibDirs(){this.rebuildIndex({delayed:!0})}setupFSWatchers(){const A=this.options.api.createFileSystemWatcher(H().join(this.projectDir,"platformio.ini"));this.subscriptions.push(A,A.onDidCreate(()=>this.onDidChangeProjectConfig()),A.onDidChange(()=>this.onDidChangeProjectConfig())),this.requestUpdateDirWatchers()}requestUpdateDirWatchers(){this._updateDirWatchersTimeout&&clearTimeout(this._updateDirWatchersTimeout),this._updateDirWatchersTimeout=setTimeout(this.updateDirWatchers.bind(this),LA.WATCH_DIRS_UPDATE_DELAY)}async updateDirWatchers(){C(this.dirWatchSubscriptions);try{(await this.fetchLibDirs()).forEach(A=>{const e=this.options.api.createDirSystemWatcher(A);this.dirWatchSubscriptions.push(e,e.onDidCreate(()=>this.onDidChangeLibDirs()),e.onDidChange(()=>this.onDidChangeLibDirs()),e.onDidDelete(()=>this.onDidChangeLibDirs()))})}catch(A){console.warn(A)}}async fetchLibDirs(){const A=await T(["-c","\nimport json\nfrom platformio.public import get_project_watch_lib_dirs\nprint(json.dumps(get_project_watch_lib_dirs()))\n"],{projectDir:this.projectDir});return JSON.parse(A.trim())}}const VA='\n# Copyright (c) 2014-present PlatformIO <contact@platformio.org>\n#\n# Licensed under the Apache License, Version 2.0 (the "License");\n# you may not use this file except in compliance with the License.\n# You may obtain a copy of the License at\n#\n#    http://www.apache.org/licenses/LICENSE-2.0\n#\n# Unless required by applicable law or agreed to in writing, software\n# distributed under the License is distributed on an "AS IS" BASIS,\n# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n# See the License for the specific language governing permissions and\n# limitations under the License.\n\n# pylint:disable=bad-option-value,import-outside-toplevel\n\nimport os\nimport shutil\nimport sys\nimport tempfile\nfrom base64 import b64decode\n\nDEPENDENCIES = b"""\nUEsDBBQAAAAIAOxu0lp81guHiAoAAEMbAAATAAAAdXJsbGliMy9fX2luaXRfXy5wed1Z+2/byBH+XX/FlkFgKZWZh4v2IFRFnbNz8cGxjVhucQgCakUuJZ6XXIW7tKPr42/vN/vgQ5Evv9c5SOJyZnae38zuRVE0utmZjarY+8XihsliVfN6xx4Ls2FmUwueHWueC5aqqhKpKUC4VUoW1XrK8kIKPGnDdLPdqtpMWaNFzfK6EFUmd1PGq4yVqhajCPuM8lqVLEnyxjS1SBJWlMQEokoZTqL1aPSM3QrDMpHzRhom1XqNrdgGgiQkG8X4gyoyFl2pdjFXTZVF7JHXFWh1PPJyPXN41DsdfprdtvciMDr9wpb+5VUj5Xu3kTcgDq/E11RsndruRbLiWiQ9T3nCZPHLzXny9vrsl0CYKikdjQ5E5P73cLeoz4rUBMIHUeu+pLCQJJ6i243C0hf2Y/vmBm+mdu12f7FjT0he0tTSC6bg2tgOjHh3cX55djtlokpVJpISQSq2vDZJruoy44Z7blKm5BVfIz5eAG34wS1N2U2tvu7apy097StQC72Ff0Tgfwvnkg0f/bqzKDx5psYUEpxfGtFpXvJ7kWysa/WQzCDTPdFHeui/NUUpVNMKWbhHStDzSiN/UR0cRrnaKTQ8WW7hssyVzvVWVLe3l+x1jH9/BNNFDgbBjrSWRyiJrEHpFLo6Qvo/8ELyFZ4hj0tpBR9p8ORFBSsfBVOV3LGUY9PCiWkFdNzxCAbMRgx/IeG1HLkcZRd25byuVe1ItlzrkZBaeI6coQaJI76+Ob+C5sk/zj/eXlxfxdogvJqMGkfBqmgyY+wZOxO5qHTx4IXQX1uE9GPcLtNfhNACXk7YwxtnkAcNvecsJGVT16IyIIkGEvLogAv3HP+vAzb8of5PvCcquhVixjbGbPXs5cs1OJsVaql86ZVsvwutkUsvT169eRVNByK68o+vlPE2/NPZ31FO7C8h4eEDmiUXV++u2V/Z+PWU0X9P+rXmBSqhF8b/I9++ef3nH6Kew0ZJwhuUVY0WMWfRaZXVYsduUKDqgY25fYy39vHvesN/U49xJcwkAp8sUnhOOMYPFwtaaxETa338pG2ktMvOmdG3qOlDHg3Bub96e5ihB3btUg/y+hICgoU1i0ThwcNOeORZlmgDNeqE+lQn6ACOh1dZoQkfklCaYf1JCA8EfdwMa0OkDqsecMPjPlJjHVH1jTVeC3NpdR8nScVLBGsSwy7fZMe9hjuegG2EWYB9Y7eLmBQPQs5YURkEMcg/O3979xN2ZMd/a9duDSaZ0ov95Np/vBBfzcX1Z1dkNKDQ93sht3amqNmXpkjvUSjYnAYCzgZSaBahknH6xOxOi7yRxGjlZGLVuL1H9hlRbWp0e2IJgwvPDX068YWJB4o8Y4sNKrAUqISMVUJkmrZcoS4rSMGrJCmqwiRJvN3RG/jVSg9eRfGi1DFKOGlwVUU4H5ACArCSYThz1Q2pHD1gA422PL1Hljp9nH09/x6InyUMVs0Pe308oIq1MO+Qb9zABePA0K1Ez8dcp9SDJ5o9H9tA02b2qRRaQ7+JjiaTno79LPLbDF5jy0uS46QNXtlojaPTLIM3OHOpdmj6dPQz9hwVwYb21zbCgXhEk0Icx+xHKXjFmm2MRJbDcRIUp+j3vjBpnIbpmr0oG21eUKT5FuhNKjWVhM1sp5ojDAHwqqSBQNSG22TgNvI7yNMb1ciMxooVMNiG87GgWanASIGAY+DZ8Dqz+U2zus0p/ADm6zDNQEwpUthR6NK+12gBVUoTjyhjO6GjixRm55sdBHP5yHearRVTec5WuzDAx6N2INCYSqRwNo4jxwAf9rrontipN3++qBsxoREKUAIKcSO5Iazqts8UWfxAB5eVMI8Cme4hSU+ZVjRC3QuxhRO+q5h/P9TsiZ33NHRQtQ+345QbsVaYzejYIT553s+ok94OBJf+jQWuK1WJ7wKT28piE9IoFHZ3DuqzP2Fusa6AALA2aElmJGfn707vLhfJzfX1JfTsNbNxMNP71+GwA6kZ6qZ2LQC69J5euK+VyuCE7jDE/m3NxAb05WjyQshMzwanjUN0vi3N/FEu/oBI4PsT7Ukbfz7EtK2FVDyjE5rBDDSDRjgytYQUxakHb9sav0sH7CwIYn+PwuAwDD1tVweFJ6SWdUBDf+iYheMGaHKobPY5Thz5r1pVrQtOq92+SJtK+914mFandAREIyiowqeo9u2xhccQYB/bmF0YwgmUuh8Pj9dSrbhky2UvPZZL6IkTA2S59FsAgARy1iKQBpJkgok8h89ouARUEcxhiKMuxNNaAeQyYUGvSuE3aCF3lOB0xvINchHuAIbCAIoGiIlO+fikTvY+gtAOQEBrSKJWzdBpM4Vt6TDEU3t0kurRe2S5fPECia2gXnL/CLH3YveoAKa8XjclEkX7Xj/DOMXLUBXtZGsvWIZuZWPdpBvGNfvpfIFT8fUtfd7hQ5g0ngzEUU21skjhu4+XhM5ABcIk2/uDdFUNVbGl1zKfYcizuA4/u2mi4yRK7F7YQWCWSpwTZ0sU1HLaPq12Ruhld8ThFBtR2yOsygdML/d4GNCL23ujY1ncg3z1K6I31NVDwDfaunnVhvApxYeCAkZ0kgo7IVObgJ4puqxqqYI/gB4+Ihjo6uPTNeLamXqRH1NlHX/gJt24IO35GdW9DzM9bocMXm9XjmhfpDpmMGA4isFzCzIQOpWiBCof2GUPo77dxAqkaapEFkOSY7B72w3psiqjwsJKy33k5R1bb1N39Q4aatAC37fb4uimMMQVqZ1R3DTU0mskvOGmoeLPUGcnr3Dqxdm68/DJqxNa+Qt9/DCJ2TlHNAI7QQbKjKLDLbTuYgQ1NEGPtd1dBDnAt+NWBEGc2jfGYXTLiCNdXqzdHY9gVVOuUAsqD4T2FlICFxAugjZ7OLdduJUQ0v6/vinHvVb/gX+1zcAe45fdEOCV8s5cLinRADJjP5FMnD3u0urEdgoaboQAqZUX+669XMbsBrv/njrd/VdseZe+Eu14QddOx2sYVSE/KB9qJVtRCjMknArUpWsEO9Lonm/iltCpUFEWCzpAeDfCd86E3jWpIE9oN8eWHG3MGdeKWqERVspNs92Ojsvb+puoFcmuBOnnLNvz5zsuNRxqq69qY0mXaj5HMosttH8bEzol2auXrJVVlCVSCb1GIvlOpVbT0EqsG0IqsEGYqczaGugMczjgc7u97wxI4A4UIgvZSpZ3A8X3Yzpl1mQHujYQw7wPw0bfTXor0gIIDBykSNcFVSmpGW7kw7UoJYo9hSJLu1sqh8V2WCj5zh5h/AAzBlxjiFZVpietQr4rq/ybTB0Y5Yeh5VB9O/x8t0sAKn6+vb5yF1h3i3cO2MQT7SNIo/a6XEY/ejBcwPMRatFBYRsgLSywghDTpwTiUcq8JL1A3MryZ7fWs92prJvQ+wfIwfQdD+Zs+nODQ5dD8FSvUmDF3Lbwdsm107n76pZ925v77+7FXvea7z13hMMGNB8+Tns54fJ73iJw75XN5bn/7tWFC/jcf3cvyLdz+nBLdBihi9Wdjrf+aMbmcxaJUqd1sYUikcuQ9v+VYKNV3L0OV+VFReiXUMdNwjmKPQPofOEz9qdXr12ADlDhPPQ/UEsDBBQAAAAIAOxu0loG8s0x1AUAAMAVAAAbAAAAdXJsbGliMy9fYmFzZV9jb25uZWN0aW9uLnB55VdtTyM3EP6eX2HBhwLiUl2vqq6RqMoFrhcdR9ARejoh5JjdWWLh2Hu2F0jVH98Z70t2N5sQIZ3UqnwA1p43PzN+ZpxYM2ecJ5nPLHDO5Dw11jOhtfHCS6Ndr1es+UUq9V2vl5BKP/NS9SOjNUQkViryydeLU345Hn48nfDxxWQ0Pr+sa3g5B5P5Svzk9P3x1dmET0afTsdXk8PCQPFZ18ysKrWurOr1csF345Ov7KiIrX+lMZTr24UHd1iujcbXxX/HenGzXPZgxa2CXBrXnbc3vV4vUsI5dmHN02JodCLv9gqFczGHeJKlCvYHPYY/zimOAHh48gP66F9eng3zb/Y3OzcagljmgCfGPgoboxn6l8+8T92A3Rqjggh6BOv5zDiv0csgKKMNDAl/F/7PJEWsrt8L5eCmrpfgNtjUSk2BBJ3gvTwM/wwuxUzCOA0ZXXuiXTYZn4wH7DPMzQMwP5OOSc0S8WAsMwkT7BY8RlEIf5hMLpiFbxk4/6MtfDAlE4gWkUJ9K6J7chTkC0E+Bz8zcQi0sY75XS6mFpQRcY4vHavCKobIxNCxARqhjaodrkDf+VkhgEWclECGuhl+OB1+HJ3/kR+8qCtMYvgMVZdLl1tYEN5EZKkS6FdHLmTeCQeESQl3LpvnoNwbVjdmrzRZgJ8fLhGZ8pzMDcp4h2TgT2GvMb83K6LORPfguclTu6rUdSFvepUZqrkl7AH64Bt9VSvFna3Kcq/aCVhgopay+1QYI+280BGw2IDTPyCw3ljouOzzzHmsKawBZ9QDxP3Kzq3Cczn5FzRDcSajHIs4RhU6LVXvNYZ/SGI39XuXizfB6QKjui0VAHT3B0QybXNhhwoMaWFQ54gVG9LxB7AykRDXSnRpY2V/xQLmF3lZauk5bwLuQCWHjZUqic3lKpOFceRJ+tMUOmh+Vrlu8DBqriSvGdNWeekMoJlpFHn7+tef2ta3TiPq9/v9Fg7thHbG8VxyV5T22avfwtKAXDYz5zBcn+FVV98zdzMQMdjlpf8kUvqb4079bJOyi2ZAvYYaxhHboZ60s93hiq6/R4fZJFcw+3MI1BpCc6PsCK16MfGiLIHQ/b8XQLvsC7B7bR7ZgfBMgXD+AL0TZyOZYWuMIQVNTZ3h/ONnwIxFb9Qo8aNlKpEWqe4NS4XFros91GFVM2+I/ZxIgD2iulYLNhf2PhhTwpMxDa5lSjh2D4tHdPYqaKAR0A7HN7IxE9i4XSqQfGn9CVthjVXpp3Xho1mm7ysWOmJhvGjfjI5mjKITm7Uku5pzp+CmZr2isKnG7sCXbXhZj+1G3FXDytQ1Oqz/joSQ4ni1aOghcQfVeKlLMQ8ap9vZ2fkyw6rG/FEma1MyyLCKxXNrhY6ZhkesGswaLgBogvpBmsxhWnM3zdyNknwoK0MjQ4QVudFUmzM2nVKIuUeIp1NGbqZT9LBc5d7wQHfTaZsCyawEV3XmUA799um2Qal09jKg8GAC/3sAQqI0RSUt9AIRk3c4l+6FMxB+XlgshP0tIuvG4WUxUtZcFkXY8ZJMtQOV3uU9pYnehPJnAZ9b2uXoMhxNtcllWT5x45uhz65cbigmuphLZKnHPI7mTbLWIJkIS6HNiYzy6RVDzS0qsSAescV6aEqK5NA0SeXYFZiuyXRzhr2sDbGrc+0h+1cMtrtsSKWcyAh5lOXDVhRetEXDWdJqRI8obFaubLi1N1Qp89InWk133TOtFNviPVk7HV57R5U2PK4dRHA6i+s0X2zyWNrN+8KL1vHCE7nh/OySIHWIZiN8rD85z+a82KsPME058bSVXGt/GTUFcQLIlpTduJF1JbGhhJwWyW8lOpEKOgHAprp5M8VEUtttPrJrdfs/Hdhf//Lm7c//hYm9qoHuy94p/4KLv8nOGhLontDB4gWouX5O/lkC6UakgzU2CbYZZLPsGjZZe4ANFLJeZz2drNVZTy2FRotiVmqoTRWdnro4Za1gF7889+r8B1BLAwQUAAAACADsbtJaMC9j2XsTAACPQwAAFwAAAHVybGxpYjMvX2NvbGxlY3Rpb25zLnB53Vttb9tIkv7uX9FQPkiak7Vxdg+L9cLBOY4zDiaTGSSe7B0Mg26RLYtjiuTwxYomk/++T1V3k90kJdvBHu6wwWAskd3V1dX18lRVa1lkaxEEy7qqCxUEIl7nWVEJmaZZJas4S8uDA/Os2uZxenuwpBlhliQq5Pd2yk9FpAoVvY7DSo9Rab22L8/xeSZkXWX6XbUqlIxAzg748C4L77DU0iwzv/yfn8+Ds4vzsx/evv/++EDg3zPxDyVCmYosTbZ24s9FVmVgR2CqN0csVCjrUom4GpdCikjdqyTL1yqtDLVI5SqNVBpuwVoaibgU2LWQ9zJO5CJRQlaiqNMqXqs5T9GsM3/d5Q+6AwL1uVJp6Uroo0qWelyYyLIUF7L8XlUVLfWxKjDnB7UtJ5biVG+a/kVqKe7oXQkKU3H40grpbaUKWWXFVVkV18diPp8feJOC4FZVcaXWQcBzZ0TmWGA0U8FfM+kgCGSS4PxPxNXogwohpGT7S6misyytZJyqYjQTo4vLy58vcG6qoFMeXWPeMwGmiR11EPxwien2+PDkkywmIzwdTTHsk0xqZQZ+Ghz4SQ98rZayTioz9PXg0Nc09AAk46jl6WNWF6Fqh/+SQvhXLI8u5zN+asb9KHP6SzKckUiuvbcsYpzQVVXn+H8zyIwaDR4iFiDh6GMOPkKaEGEyISswxwpFC3K8VREYJruYYEMHdGZQGjJF6HkQQnmqog6rYFVVebDiDQQRdjBhInlWEWmZHIts8SvscXbA5zosmD/E+yxVenkYS1zGoC7TUE0aOjPhC8rRwULBQ6TtkvxCJTsJ+cJ1CD0Tb+oksYYlwpUK78igMpj+Ct+hcKBR0ncpzHQyTfU5J3u6V5B/JpZZQcMdqnld5FmpeCLpjiU8ExtYclnWWKxaSfJtW5cuLVrEt6tKlCuZG0t3dmw2EsqymuzUmFYu00cKxuqVJ5mP8Rqup4B3qzLL40wsHy2vVFiyWNyhOyi7p0nMEnaofpvwdhvUoBBXspRVVbgSHJEvHE3ZZw+9drzeqK/BLku7rLfPSal6hMiaGiMf9Jl2y98rfInDK/jCmYCfu27No+a1rUI1Awzbo9GI/yIm3MeRojCmI+dhKZdKkCc4TOI7rQW8pNis4nAl1vhCD0pR59AlJnJzs5afy/h3dXPD0YSGJnTCRbYhhZIbueUDTRRkc1iYHR3W5KR4wkJtszTqEjMx5ziXhVwL87iV1o/yc7wGEoDvW4A/6JqmDKGqNWsudB0iBbc+pSguST2BTdKwJXd+rwqwSaYAdadTZudwD1GATQMuHIHMmpk3Ny7FyT0FpClkgekhgp+K5kKc4cNChndGjJsYlgdlMgOaM+EPQbPGsT1OBwO1Z6kHW7mI2OAPb3uWAK3PxnGl1YR07Np4bp6VACYdW7TUhvk4jSvE+GavHOybb+7aCDdHz9tXT+YC8+mPpsDRpo0qvHKdQ/Gn84anqcfU3AoCdMwn/73LEMa4XzuEWp0/ccFnd0GSGEawyCjItkIbxEY4Nt4Vdu565g/qENakCAavFKvdTKxhlBRDKtJgegw0ad0yKyTwh0jAYesWN3G1atlqF6B/rMsn3c3N8yyfgLOpN7Yz6AoDrjGXSHjjjKvi587Oyx07nwm2imPa/cDZGisLDKeNUj60s2fi56ws4wXiGpPQEvoclxXJj5ckuY3BxtibWBVbn5Km9lbLGMM1lZIi1himmsE5bAqwhx3PrA1n6RgGvJLprfIgQ0uP9dEcXJ5lyVy8MrmDDEMFzsk78nLlKquTiE5e6XMfoLZPEzi04kRpclZXYhkXZTXvEekIGivPHqcXe3SDxewNVp9DlVcE4M+LIiuGJP2PlUobWUeZ0hkSC5234tiEPkbeEIEMAg4DBLU0IM9NVtwhM0oFfA3cK2DIDN/CpOascEPr+v4Cbvr5t++V/gFNJCqddOZMxUt/pb4cNOvQug3F3Ij0SesxIpCvxjqRhDJCP1Z8xgW5OQqAO6jSijMSYErUVxIT4U1aM+FgLGwwFhyMWS0o1O2gSfMW6jZO0w5Q1JozOKujcgPaRm8mADvVyRsJPDQ9cNzj6RKoDlwSt7Qmc06ON0sbq5pZZ66h6rYJ2iy5lisck8eMScs5+JB0e2HCP7Bg1kzXKnnikeu7UQ8VeFO9aBEBju6MFr6f3OcLLU87zdmVwwNb7bPfZxsab1hmRoEAHseniRxDBuMBD5y7S98giPfZB57vgGYZ4+TfZ9Xbda6Bn4rY7Uy8ZUe6pEH+kpw5lIfgGUNsfKhTQrs6PVoog4UJCs9HDRWHvRDqWLS8Pf6QnomzLN9CayEuVTBCJTfF0i2ttcY5xxPYN4P3/imXOOYE3qErwLl+O5nujelzzf2TFIIyO61gcKx6lb43e1hr/FoTwAKB2etjdi3IE4Ejb9OsUFd0QgXykuunaBTI9QTCC06nTTblVyGgEutPsdpMiJNu1tjJlPyZWmfqspYJy6YpKLQESFKc5MJbI5kU1SZDeI84K2aKMooKYACTm9ggAIdM7rgqWBcpRbDZCItACuQwVRzWyOZFKtc68DfphKSlrc5wvqFZKK2nDiXyT8nOEfrH1rBkFWwiLQ6WZ798+VJEV+P/PtS7PnyPxcb6QMZcczua6drbC/P3z2M98SLbKBCfkVptGNLC7pS2OuzFF+S45M2V7TaynIwULG3B73oRGygI/krLIXZG0QrMI5zjRWFHnlwWUNGNtImXDveLOk44+FPKutLZLS1RbJ2dwqR8ziZfRqejYzE6ogLlK/q0zLLR12k7ZY4TnGAQ3r/A/1weeqNe0aiFLEbtG7bgaM7btyZ71Sj2ZHw6nokxhPxiPJ05j1/RY7Ay8BT07dNrvbXL1svh8KGp69LmFOyBljJUsJ/fauhdJBY6TfdrB+L01ZnO6LXWJsBgtzEnKLVWqzTjalQki8icNunVQgFzxLANOliZVn/XB63VOIKxxaSLTJOsdCYynWoxF5SFQzE16NNYEDTnnTxZ1y3L487JDeSvOrLuGD+UbLIfMeOhGubTY+OfE+McP22I0IkX9tQfE/OaYnzXRfUW3LmOu4rxjmUjFhpjC7287gKgqqXtFxx1hsqc6EIZbZIeTsXJiXjhe2ZdiA44zTCfYcFD+WSnqunM456C7qJ0399TVY7e92PRoEAC+GENwAKYgnk8GWZy2pUtY9MdgWQyXHVrTqoTS0wdyqpjs9Jpqu2Hyqys/SqJDnXYzSVMYQ7ThD0QaDWHKNZ1UsU4Cz2YI0Jbn2XvB7eE5WBXlAtxrSEt4yq+B9rxy2J3G1ncutxEUaxdcZ8TciI5Y6eUPlIFLKzmdR7BpJvC3al5fnMjOrVECpklNJqcCElSXJgT0hPftHsRYJ2HYgOkBHt2Q7zQ6yQmHWE/w9Q+vDkTf33x5+dz0ULA3NY9yX9pL8MEG3I6KVeQH/GqZKhpdVdlaRiuf+EE5ebGqYJg5+UWm/7cFhBKLcxSB2azHQEPbDofw/ti30iStvXXRrTUgszjuXgDNh3KmpZLnbLgsoKcRQhwi4AsRao2oOOrMlgmOVONAgeJ2HVzw7QooUbmleUtXvF1z+yoWW9oJ/TSNKd0FDJsmm4UtoD/sKxVpJnJOE0kYdAFJwYd0tpQZmuDGha2iklVjybEtg68Y6/T7hCO0uOPqjo8y7K7WJkge8IhdXgwTvkwbAYv5O8nv9WfP/dHX41NK+UQrvK2Wo2pkDD+67g/7uP5paVogJZhYSYa8v1ZZ4b6O0NdzzT09xWVh7wVhStu+l4/HEX3dQNtNVd8953xKx1H/WA5163CfvlKKcKYNH5MWqARwaFBDG6ksifu5PadYqgXaMzwPe3JLlP5NqACiZ3pZ1p+O8ebyl37qD8N/HQdb3eOfj99sM7KB3hPTVvbh/e3/0zI+yyG5QBiwRH9CaOMi4hLAmxbEA8zRsoLBbenBHWHk3ixAwpwxGRSHXmR7+Ti4pwJqskogdtND49GOw+ZCmxI7TakE2QfV0wcm7l+sLDuXjpoyGuYsW+RbnwngD7/FYk5Za1XR8fXDxdphsWMofsX3ofFmO4joVgDjwbTYWdJct4djnagG8sZ9CvS1yV6Cmae8zeIeDTqC9+CL2PiDjFm2Xzx5Kt+a0SQUUa3RwhruV2o9goDo6WTR95uYNqe8Q1Rg/PoOw5PUPZh3+B5hQA4s7u2vj+iNLqfDCzrFGTMWl/u7Akei3sGInewieY0CSuuVXGrosn0K6HvL74V7pq8k0WPYkPrq3tOqXr0OZlNkBvWyqcP2RzB0zOpb6gW+teYHEf4E130MiCQMQaw6G1sqg5cXPCRtKl/lQOW1BTdfD3YMoalOVfPHZOP4jJEnvywF+l1qKxb4VZEq4D7Wi0EtdqlCbTsihaI000B45jPEeqqq/F91oApkBvQnYGJrkDpMh9j4Rk3c6iR0bbM2iYO+S9AxISqq1tnD9Rqc26YcRsuLtsGui4auAWWFs1mvDPdSSNAq/W506mRfFGPGypUvKNyWlQXuslqcoKZXpPRpKUNZEQNt3YDTl+OGw22R+Muagt1YHct57SZNNsxUu/c0zLTEzO14HZl5quMkd5sqUKNLatopuulti9i5CM4nVOVKhyR7kXDhDLHLdLtjNdo902WGZg7POqKa1KtYo4tbB17o7kc4hQo1l61+mrCVJpSlnC+Y93r3eyZYb/Vv4+HKnHfsDwzPxNE0VnYpvD07/8VnsLbgP29GWl8f/MephGwB/OwVbuVH5TKrRatwT15QSHvJCkv20teqJJu18CUltQ5xN9cN99bMzMLdD2kDwA0m7OGIy8cN2waAE+fuy2UmPuOECelk6YiTN9bmyk4hiMb1U1OXe6Mm9uFLSmw86e2rOG9pDS1qDjyMJfi5Yl40U0lrMvsYX52/IdHpmesP/4HY0z8ue/wMZw20Ly59kATLkg1ntzkBdqZf6ezq8FkrJt+Dfpyc4nMXiamxg3XSLivkeo7uORltdnoa2E66Let1dNI5p2mgp9dmpTeq2WYHj+bYVuzaho9sGvXyRsM0WQ+gyZpOvGcL4mX4qgD4bhVSLd9BxqE9G85MqKdikreKVahdQYNOiJdt9UwUK/1BbPJl2a1r1QUV+l05BFtdZthD13JxWAggg6nJ1iBtEB02nKOd2ACDySqjPKMcTdIz60D70hOyYXaeS3L3bumhoOdF3D3cvAvXn3glqsr5addD+1kBd196K6nhrsP78ANOd5FU7OBoUum9tWOC6b075m4vHj7UeC/9z9dilP+ScLH0zfn4tWH0/dnF52xb1ONZhYFZLfSZTRts9yLlOKGuLgRtLpY1FXzE4XmArMxftOrbCkzJZYy+QUCxBE3ciLd71QCyGOVRYAqt6mk337M6ccVUaZrdWVVL5dtabYlG3NAwcz6dkVfuMvJcDy2bX1drG0uWNv21Yz536hxQZ2oqkM3yjQ6giHrtampD6qnkOG7d/OhM2/VVnePHzpzHsuo3LHdvv5oPzxsCoNKxCP+y2gvoekkk1ETA6AoTWupk0g0NTznhxtPpOOk+cHrS5+q+IOeObRdMl59Z5ie/dWCpgNjbZ7M2x8vMJ3BdV2/r++CkD7TqH4ru0HUlKdEuk49F82stDXUdV5tNZG4vQNoUxmG6XM3zvSys2HkM1xw2puzYXkjKrLJIdEMXacjQXJ1fJHVafR3bz9cLmUfSgJ6Z8XZo2JS7avrg0HahrLDnEsWg4aqJWb0nnqJpr+WW/I49IfcEBIcsxyDp6Pj653bMLcxOzTXStEvF+qCsVKRcjDq9LvJpxCpG/17HociOLq+mQ/tx7Lj1B6Ai6nJwh1F7fsCfSe0rUbQ77M8vW0+f1B849M2CMpchfESWMxkiaaxYrIHJmuTPdqEKlvJGrcLWPX9+SXJ8uL89DVdMwXc4jkZN8L+dnT0fAaGNMQ7+s/5X+aDjBmOAsuR0wu/8gQzsu2H81TnOqPZ8Pt3YL6Wt2rn+yzkPHzXe4JtO+dy66P79nV8Cwl1n76j3yD8CFYh3Mh52ao9OQ1zANxSHJbE8I05Lu7oEb0Octn8TO+ZeCVDCghRqTPGKl7ESQyT5bWdLPGW7rdYyRsna1/A161lFa4g9OExMV0Jah89cum5bkH9Kgu7EP2Er0tH192g+17dbagMvBx9aQufQPDki4Pg6+QLV2R7lczp1+nIWaLtuHhVxwdvcHSDec9dY0M6ytvQ9Zi78P0WxXd+j4LY3WX4YaIbY04ZeOq/nHe221MhHtWu1iL7b7gzAnN/693NwiEbtacb5d616ea+jsD6pRcKHUGX3naNnB8dFi0xkzlYV9sPd15pleGSLxGjSf9SkUAaRLYvCzhWttHiSUJ5ikya7fJu97WpOqowfNnxMbctjbbtvC1Jmtma6OCtGrdXzCZvcGDzA7jA/CLEotZep8uZOyzH7i9HgwZrd2XrkGpkzGG8Q6rTBQuCOCv29Dt8+Xi/t6xzKqaUplSjq9PGuLgZFKeHeUJgpOZbI1mudVP8ceJQ0dUlU6W2V+c6ZZGhisj/bYfMv4rtJQS2oz3Y/eqQaaOlPoq9J+E7Wkf+1mgd2Zc9mf+7irxQJUF142s4NE07L59yInqGF/7/Fw9F317TpQbsnX7npJbI4uGo/u3P66FG8fAZDiIGc2j/BFBLAwQUAAAACADsbtJaPu2828AKAADLJgAAGwAAAHVybGxpYjMvX3JlcXVlc3RfbWV0aG9kcy5weeVa224byRF951c0mAeS2uH4IS8BASbQWnKswLrAohEsBIFszjTFtofTk7mI4u7633OqL3OnZG/sYJMlDJNsdldXVVedOl2jTap2bLncFHmRiuWSyV2i0pzxOFY5z6WKs8HAjn3MVMx4xpb0wQ3mh0TGD4MNiSnSKJJrP+FpJpwgjIk4UKEYmDn+cs0zsQxUHIuA5LuJy8VPN+fLH6/PfnITAxVFZk7mJr1dLG7eCh6K9EwGuZ24kZFIVJY3Jb25OH93dusxs/tyV0S5hGb5cqPSXchzblenIkuwQ6nwj1CPtnlvxweD5ZJHEVwzZ3fD9+JfhcjyS5FvVZgN7/Gr3u386vX12fnyw/t3dmPMNq7xP8Sw4G7A8LIjtyQkDsRdXiSRuMvy1GtO1iPrQy6y+/t7r770kif0/sIabwDFBkHEs4w1NZ5pYcPhUL+/VvGjiCXpwnbyScYMzmF6ncjYfqvIKZHYiRgRwWY7yJitcKIqEfGK7bRIj2VFsNXiEBszvVhPQij82SdPvi7P+kapaIXYCvX09lz69ZLH/EGkK3+gp9yk6lGG0GUttvxRQjlScMc/wW4WqN0O8QMvYILa6OBgqTHXKpeVm4Ui0IL2Wxls9Rpa4mZvpIhCEyokOVesyITV4TbB0o0MEAQHzwxZT/h2+dLGGAxZMZlpHTMRa1F2ivYmgkxvBK1SoQWZhSGD5/OtYAgfNiZ3kiv/fr7w2Nvz0zOPnZ2/O1+cT/xnd1+r8PCfbX9CIk7IL/TN+abISFCZPwzS9/v9lNJoWma3cXKpO6lwc30LA24+0H+ni9dvj6hfqmxPlccHhg9h7Xg8JnO2l1HEIqU+sSIh/UzEJUmqklTyXFSnR5pxgrCQTpGpWDiT+Fo9CpbvVRkeOGnsa4TVjLaqXsQylzySP4uUwXaOVSJFDhk79AjbajiyiUUvg09atIyDqAgFdM/hFujvjsNjRRwJZKfCpqmTQefCHiRSshQmnpJIBjKPDn6ZufpDLeaWzpg5+2VoQmXosSHih94oguj9+mZxcX11O/w8sPmwAexLGLhcjjMRbbzSkl6swX/37Fd2Rd6c67cJm/5Vf6hMJzm+M2ZemoXD/aW2rQWQcWOZV34z1sxox2oQa1ojFKuzWtVoKlfN+0qrqoXtwjHDlirCtEVa1KZVhWWtijjk6UErekzqycmnfanLaXwwv2hftivPjLE/sdM1hHHUOicg5RJBfaXyCwfNIjxPU5VW/tSB8tqiuHjKLRY0KwEUNyXT4vuwuRxxKVOm9jFblYjvIN+v5k6qY7Wx/V86VoNks0ax/+YhQESnfljHD9W6aPnlh1sudsWYXpfAIlTaJvS2665GEw1nfeinNqW01cp4CQdHpAuQanB+tTKHgXEAZGjBjl6LLcAY/ziKa40a6NlYClQl1SQ4kxYUCQ4t+Q6BnxPG7nhc8KjKoA2gOPfZRc4CHqOG6+2o2uyIrmUyLwzF9KgsRwJnQSBPlZ6KsMV4eqlEU0VAagiLWUhxSdCtAJiZrc8lpu+3ImZgHMBXZKPhJyhKpTDrz57i7R35TZfW6riBZwLOMS5QezqpCANR+6RqjrXFwiZBI9V6aEuLBNQqqcgDf9IRS2nUkLmwZAI+SkRKBbFR0lXcVU0nXkPIGUgySSAu4SiCk0CzoY3U5csROaQSudB+01y05jV6IQokSihfR7om1xe+aq0jL3NG3H4aSWSFWn8EiezqbYGgV3NzfJoJ1I0gz0B605ZQJBYnVVzLkO6GnYKvd5Sa4CLeyK4A0KrKmc6HZSSyD5lIp6cPgN2mey42UwKW6SXPg605bIwZsGEJVZ86U9C5S78nhiWHTWGwFIXCLQBZBtLnIjrA7iTigdBMi4ROywyyk7s2ayD8IhfDun/cXl8ZkPqweDNtccy60/1OzK5WQ9wWULDy6QIUfQiEMjoZ+gcEyURO22Ii0A/USAPIK9IPkxvyLMOyxhH6UbDuJRF7N6eOvTb15q7IFQlSZ1xLNrkxV2DgIy7HphKQ3WRKfbDpKFOvyZqeKq11cC55wPpHHuGz5sNr6MtGJHyktxnR5qMaD7V3GQqFHa7vdD9BtQfjzEAhm+X8eSuaCmOCCxrM6f5Or4rj1SnfoC2HNhgPA3uidOkaavTnyRgp7xN2piXv9D+JQzaeTCbPbddsAIztD5NjK+6a4XQPCd24aaqtT3Numhx+WOySbEwfkbyCXJ+rNJuPhx5R6tlwQv2FjDonPAuknL/hUSYmvon5nqMu8s30L88dzfOxVLGMuyHN1AbRh4YMG8hwtD6cnptCK0JFXqR2crcodq2w9/7OOCZ3Bw08z82bR4yWwmDG5EOM4n3H0wcdF/fHTnBu37uS66TLa7nUfRJR1k7H48aSI49aq61rW9PWsaFT3ynXeHKvi38TZW5S4W4n6luz4ibbLVX5bjS3RmOrYlLKohlY45fcFWVxU0QaQtvNIE0kOn0VU2j/l7jab+M8f0wq0xd/L5W4l8ob7tQp19EfwlmNZixuffe6EWMXDWdO2ufOclCMEHe3cZVOzWLQd8yYy35AFfvbkP1QNdfHZmpteR3nXMOlAWUnJ06N49jURMRvAE7fCZG+V6vm94ZzmjR/MdC1G7BtnPsn3ZNXq7bz5uQ06DBGQHAMguNg70qR2aaIg6prf/T5ysrqGFao1DAm4YdI8bC/nWE5oyYLPrt2zL1fCfPEyS+zodrZyS7Xjers72na08geNfeu3HVZdsDLXotuobm2hm470HMo3YPGvRV8gFBY5qMMB8RBInHvPVTpxDfCPmmg/jZw2jSDc7mj9opSPnsLgvxIFBm/7/iBrSHmkzvsShC4FPasMFlbfX1a5Nua+re4z6g0pycitp3Co3rIlfcKQn1Q8Vf6KkJhD9kZO706K0XRr2Sgfnzls1NWfjG9ozF9jyENt2oEgscuLy7PtTsnzEyDr9JmNJRTSITTz2dvqNfyxAnwZ7MmUbfPMoC1Hc422ig1muHyxNNRlziONkhLUhFTxjSVPvv5Uz7y2Mgevn6gZH8aTXpk4CSiUgb2qcnQWFtNmIBn8hAXmx4pZHBYE/OzFrOWcSnGjpVSukJaIuWOP4hXHxPx0Kt3rOhg7JYNa6tfjGtbnvvcAg6cI7JXP7HR5+/Z2l2NkDg2psPdyBSJ0oiwelLqmJjUD56tC2o10hM+sA0DIWsNcHKH4l4+DYSgdar2WbNpcaWAILpbiSK6WtmyghgnqpEVhABgGDrsRvX74ajebKg60oIpJOE+lTlm4mvAbcqallHm2qrhARZDuxRZr6ihZmqMTaFSnrm117CR+Aw9nHMI33oA52uG2BJaJb8W7vqr1eMi3SiplZZu7avn/P87+212nf6INLhtc4cytdQ21Mn5s0VPDJGhwXL9K11GCe41lDeRWj+Q7YmxLh9ra0F9kLKDZ4gIEapWhrnmIPwvUtCH0GjYENaiLe6PRvxgq5B8VVb8Hm4MR7pc1Q3CPCXTnXKwV0h78d6AYdMyopSo8dpOhXixX6ld82zP0uxvu5a6gelpgFIx4ZI+zQM9lveHHeGTTg/x+UB1zvAca1tqDjE//mc//Qa5jo4Lg3k3Nnt0rX/rtpqO6tavQucy9zXdMnoNX+S2wy4haDncxWm7v9g/x0XsvY9qY68L42bLtWn8pJsRz16Cv+oW+29QSwMEFAAAAAgA7G7SWr1jRxIGAQAA/wEAABMAAAB1cmxsaWIzL192ZXJzaW9uLnB5dZDRS8MwEMbf7684tocqxDIGeynsaVQdyhzaCVJK6LprjaZJSaKw/96srdhOzVPu+919X3JTLIUkrEiRyR0dcH9ES+6jcVpLe2WLGqZ40CpwWLzmqiLWV87kxTsKhZ9krNAKC62c0RKA81xKznGJ6YTzHnM+YTgofYKkTuylwbWjkwwgednGfHUbr+7WmxvveJ1LSyBKHIEI0J/S6BrdsRGqQlE32jhMTj7/wZ3yUdDS5/jxaf2w4cluex/7mHYubRtSoRxD60zGMAzDDMi/IPpzSu/fqHAA/S+i0xQMNnAu9DuIxkYwwudw6Ocjv5e/xGAeLsJZ8Nv+p6tTfH0xZ7hgOLuEL1BLAwQUAAAACADsbtJaSPexT9UrAAB1pgAAFQAAAHVybGxpYjMvY29ubmVjdGlvbi5wee19/XfbNpbo7/orWPllLU1lJnbSNNWOZtbjuFufOrY3dtrXzWZoSoRsrilSJSk7mjT7t+/9AEAABGUnk5k97+3o5MQSCVwAFxcX9wsX87JYBFE0X9WrUkRRkC6WRVkHcZ4XdVynRV71evJZEteiThdC/b6u62U4y1KR1+pRVlxdpfmV+llU6lupa1XF7EboCtVaF6mvSxEnRu16vTR+3cVlDj+r3hx7bLStuvzDxcXZQZHnYobdDuIqiOxHG2sevp+JpapoPwi2grz4NR4H3z97stsJ5LWoloAtcVLUr2Ecay7Io1VlEHvFqsYmzunFBT8AFM/lcMOLX84Oo4MfDg9+PDr513EvgA9BCkvZgNlr1ahRbFWnWVhVmZ7KiCCeHR6+jg4OX19Erw8vopdHBxeeOnUZ5xVVknXPz48v1LMejyiMZkWWMUYrsy8/wKhF+TKd1bIgImlPlViWxVTgwOlpRD97Ruvu6OKqEmUdXRPQaBmXFdKCUUHhUo3y5eH3+2+OL6KLo1eHp28uRnLc+qdCtQEC/9NTU0RVXZpv7+JUQ8fv0bwoIyTRXq8u12Mki4NisUwzkQR3aX2NyPojIVXRdpX16Pef4krAy8OyLMpggs9D9bMniMyCwRHVoWejYL+uy3S6qgX9HjIVQDWofFLkApsGahHjIL3Ki1K8BWTBtwVQ4ztucZbBI6vdAf7QND0ct2DkxU4pEjF/RwDwswQYPT3rU6gPU6/Xl0Vdfzp9+cs9Bc/K4v0aFuM8vUIyMH7e14Ii8tMl0xyubOeZAnErgE6MqupBFMkSQmFAk+6Axiu5hCQSngZ6wVR9xvRnPD+JFwI6UWQrhGa+EHcNyzGe04CN3+frqhYLbPBn5myj3tAgP70Cfzw6i3443H95+HpEP872/3R8KJ+cj4IGXyOkkMheU7+uRKWJeFok6wjofHa9ym+qXge7kAtvDj0S5bJMc2JXUftxFwBG6AxWSi2iVZll6fQpTmst3tc89LSK0mWcJLDmK35SIiZvYfaxDei28xjBy5kcqbUQ3ZXxMmL+aqOOerOI69l1dF1UdQ4zpfp2APDTeTqL5dIaBXY5izuUehLelLCSt2DtAS5gL9gplqPgTmyXwNAS3LFg70orYCHwVwQIp1rGMwHMPwAWMovzYKp6IJKw55AHLGrnSe9PZXEj8rN0KVQJ5wksS9hq4bnccMMrUR/DV1EOogg7EEXDXg8bjKbrqJpdC8DBJPjQR+7bHwcvnowC+l7Bj2fPnn7E4f18LXLqcAEDoL0Kh7Ra4r7PI7yNsxUx8RiYA+7vc5iiq1UWl4BHIAmRx/lMAKhBCjWA9GAuZ8CVIgIBAOZxmkF3hwpqiow3+K/nwQLo47oCPAGTFYTG2aoscXvFcmHv9eHB4QnsW/sXhzAOJYmE+GWw92Tvm1GwC/9gzNHB6cnF/tHJOX15fXoMe+n+a9j0oFopwhlz7EHZf/vnna+2/s+jf9r+3dfhn6PL3/7ryc538c5f9nf+/V0f4PSYhdoSxMCRKCRn7vf7ms8nAbCfMVUeXxpiQmjXvAyAveOmeJsmgGwgEVgdZYzLGbah1ayGOUaQ03h2A5JPUu1gz0EgmwIC63WQxWtRArrqOwGTVmTAowBIEuTiDr6dretrABTyZrAPNIptxllwI9Z3RZng7AGR1LCkghjwvcJ+w0TMiB+vkK7VDlThJNN86L6HDHWGnFRYsNJ8lq0SMeZ2d4LLy6pYlTMRycV+eTkOzkVN8PhNIN8EMO/WtLvNMTBc7FHBDFwBq5Zihms6kM9xAhDSKgekZGtcnlwxDI7msHp1DZGMsGAuNzzY++JVVjNGsgLYfsLi0eWlPXehLBm5/QnurtPZtcJCFSRpFU+R3mULJ/FVJrahgeyqKEFiWASDSkCDFwdn0cnpy8Pj/V9wFnZheeQZIsXGOy6gqbhOYZpjJJ33aznBQfA9YE+8jxfLTIwCkCXXxQpkkuoawcGinGYCGwl+FGIZ7GfpLay8nHgXwZWMSyFgJIEikEV6dV2TJDBWbYUh9CkRO9MMhj8eB0sitp4WG4IHYSv4OnjbVMHPQM7SOazZ89ODHw9BaNOPoh8PD8/2j49+OsRlPmpqvlMNn5bc4XgN0lpOfIXxL6zBBdM1DQfJAlfdYomrKYVdciDCq3AEs/323eXlMNQru2cQR4QsdaxE9QNc5T/F5Vtgfe+Av9j89i0z23ctSWuRVjPZ7a1x8FJ2sk0c0FPZbKgKQ+cUmkASeH16cRrBvGo8GYSEaIJxWJ23Z6A9DGPNsVjH0xCdnl0cnZ6c4xCbOfuEfvSMiYJBwD4DM1LylmKQN+zwuCqZ7HFHBmzMmg07VLKDLJeMQaIpUCb+Ps5ABfKCp2XiaSShRvhtV1NbzC9kKewr86ZMA2SuiZB4Z7xLswz3+stLFNMvLxkO1Y/aHf+NhXmW6bn7tKaq9C9ILCBhkahjcVCYtBUs8rewSYwCIjuGIova83vPfKqqVDe6jqtIDwvFROo2d5VLKBWtaaAlmhudieoVAMtItBoH0F/fS15OKGN6XvIysuoqcgbJPs1BJYsGmh4rkc0bvqBbbR65bUnENwV+13yVyuXYViKhRkvNbNp/0Dy1GrVnHF7vPn/64pkJ1p5TAvJbMLB45z0TrcsOUXbyMgMDTTztIPJ2dZnpmWWFsaXXeSoMg50/0M9xM6TVEuTUYdieQzVzE/xvZD3G2Zvgf/ZjOVETqbiFSmNQo5TvB/Lv0K5tz9nE/mkX1fM00d+aAkOLCkNnp5s4k2gXZu4yYax6XklEqxLyZ88u2bF6NW+0C7sLWbEgu1TH+t1YuGON+Qu317fFC/8FhgCEUq/1oseuDBAEERVUa2hKieD4+VdRgzQagEx6XRCDLsWiAJEnztcByNikgQRJUeNGE4N2nCfE9PW2wwojCeXf/9vLk7DB9VEeXIlclHE2QmuPuWWAtFfk27US/giY2ZhqhuQODXC+yrL1zq+rOONNKSlQjyIVckTyfH29qkhKXUv4sNGkpDoxdmAvumtEWOAE1wJIDQTEK4BTobpqgFTjleIpiUUFisWNLIhb+MKcrxL1bpKqUHIW70F0rhmnM4FyZGuc2B2l2CQG7n4o7gTAGtloJsOZjSfYZ0H+AVxl2M5L2KdKbWf5ZyhiYzAripvVUsJp9QX3Y42oIof/JIOgsvES35UpohNnulnQMIhSkJ5rwCfLraeBSsTljFuvyKgDwoR8xshvOgtyZhhc0JymKHOwUUCKqzconSMUkP9AqYfxI5pAHSlAlSEFCfQ0HoUBE/oFT2egelbcbYZsjm2QhgIkW5oZxh9iVY4MNYSqRj2lojFowPGsBrokvcGQn+JZWVSV1HTYBnJFIAFOJaCfKP0H0vJUSTHaXaGlqFdlLrlBklfEZMISVnS6HPRD1L+JA9DjipZzmwmMWOgi/uHZZcz2zpkjKB3zEmFcBoq/GET6M1o3qpVaKoRracJC5POa0T1utOR/JrM2FAPkY980QIaANblRXtUp6KBCLKoAiazIpZKCDZLkCnDKuERJeF5kWXEHO2Za+zFpoxD4J+HEkJNycUcbg8E3WUbnPxa+DjUdxMpxYc48dBzmAvhAIjLgBzgv6JBBfRu7pyGNeXrHaAptw/GPAy3qztY8u4HhGPWkRbF5YssN+BnY6BjJbRSWmLPxa9RJucDz1hENeF/vlg9Un5ttfuKRBew6jdggvQByaoB3C7L7AQcSNlqA+VTCZ3zmoTejHgViyOYL4bZiuZ462/BYxNsIt4Vu9Zn3DT8c8IUPum8fSWBLAhTVgoGcSi3EfTCn5OOw72BLDccdz+n54WZstSzyHQOBjn8fkz/HYooxWtUMShwHH8TH/j19g50gjFewqQ76phVQQumrSXJmjWm112KUMGPNmoaFJ0WoL6n9sKetsQq8gh0E/rIGA/91ajCmGDdhq3K/U/ZP57I8iRMglwxkBWWOHvpm8Cdkah0zN+8f5SQUST1dgideT0iCQcCM8eOvyo+jYLECTglaukiJ225jw9uw6fK3arvfsUiV3mLgn2eu0U0UFifyr6MY2JIvKgb0hacWUQNEozxWaT4vgt8Hg6ejYHd3FHw3xB4O6OfeMPj9pLPw3ih4OjTQuBVcxDew8xOFsrHu8Yz/bu0+efLdi+dqN4cFhPZm9lPg5DwNd3fD74jzw9e98GloQCV3wYoMac3aiLAVyXxpRyIJCT0KWoSCvQ35T9XAoo2K3Dnp8va53NzT5TiYrkGwJiqibzZpAL6m/XEf+5kueVtdvn3yLvhqAs/f9uHruEUscj3h++BrrPY1fH9nT7gsky57FtVumhq7oa3gUk70JYx8mSo7MmFz96nGcWMYVvWI/saPH18BqlZTdFY8tifsMTxapPXjJ8mzJ3vPnz3d++a73eTZ090X33zz/EWSPN2difnz+MnTZ7Nn0+/2nu868BFJD27j+Xw6e7775Nsn8yTem8+nL168+E58+614Ot17Np3Fz/aefRdPnyV2GzSVcnFoicNmAeoTvdr/v8dHJ+iYMTmkftxycoOwtQPw01wk71rQ1F6Ck39wenJyeHARPKrGj1ggfbwbPvmP8j/yfvAoGLQgA+faAX6xiOs2XPzw2rUJ1NKPQ5GjSXzQj6tZmvaHw1GrjVUOlLODY9jUhqFGt7fVYeuJ5DJol5XjbwNHRsjlpMCMC8YeAUMJU1BdqoEnNGAz5o2OhLBngA4wmPc/8JOPwHmp0Y+EfY2nDBXhnV3AVNeYFKhpn2q2y20Fr+Ib0gUD5EEgQaP6MRiCKgQcB5VfAITOK9yzliRVwxfswKqMr0TlAag0U5AoyPMJO08cLNAhieLbApShJbGuAK0/RhMeUMuiBmJOoSvrQMBqqmVPBYn10Ktqgd1cuqxQfVh2ZAT0w/8EDWugtpQ2KkAeV2jreVieDKyZMFBt/CEf5UALqSNpMGGxNeIfw0+khZYYrz4D5b4n3xG2VVUwC0PyynKHQgquiUDsqldAhve07G0F+DSCxy2AWAou/XOCF57+6O+YRvYsAz160EauxiNJIlLWbIsh5mfev6CVZWpPcxIsYTlgBz8GHyQCQtZ5h448aX78XYItG5165crDWdWHKN5A8HwZIorx8UCz2a+Vg8b3AYRmIh9gjWHwB82yu5vED2PK5OnHUP+iKI6L/ArkPaJU6pxnWRsto4SIpTa3tkUcrkproawSh6ffa2EDlxAvPbLbSDtC12cK6LnZiAzEKEqtki2NYLeRf1zJ1Q97E3Aiw0RMV8DMboF6/hA82QySwnAUQsfQC+weQCAe6+ETczQqZR0rVFOJWgiNmpVB5x4qeD5YFNoDaehLiEJ7T2Mx/+bbb2bfPt8DgWSWPIvj+ZO9F2Ka7O2BDPNsN342fTp78UAxxYj2fLG728LUvWLG7t9DzEiTPP6HlPEPKeMfUob9+ftIGdKJFt+xky1q1oelx1A78t3A2IM/V7L5pO2hWY/NQmz1+BN3F/5m7C//m2SwL7GZ4q4ju9OlHOuFohZSY8Bv0KKIwXLROvvn0Vx6Z7QRDL0OCxHnlXxhxbAAu1IhZSace5zLKH72nIYvTl+ewuaZvpctyyjYpBAV+i8TgQwXfQbNUHExCl/Dcoc2sE8DQ7MdhUpJkx/0f+qM505QGB/5V5s3pvnqAsOD0opcGvVdOhPBoMgxIHHKvuIkwFaGQbKiMFhYUBiHiXjERlODtW+RpMqWMO4xoju057QbiRhgM2j8/cNee547YnPaGGuFGtnRUW2XOhQlEk0agsT+NKBNVx1NFqBsk48+NXraBVONy4TnmH25VTt4QT5EZFvnMczdRbkSnoRPhp1hBF5sPgQBHRPR1ZCejYZ4uloxfWGvuUVcXIiq2KU9jkVTobrJCAR04IpelHmcri65Sb+ew07um2Y9NM1ePmtkDXP66wfmHQMSix05xhy5g/223ZDS5u/uTF7uv4WHwICdoMxFPA3Yj/Iyo0BWFcZu5NSUpwRKsUPB2Ep/zQSLn7AZw47OuKk8rFJuGVawjX7p4wetQj7W4Qf30GCjpsJ9AUdNSXP67itERzPuK6RdLTYVLFe1jFHo8qGxaOp40VZl5jypbtKljJEyo1GdAjEFy0ekmJA/ql3WH8Jg0vlWcEjRykkxQ4kFqGIqZjHqD6hSpHkCYicd2UTJ/4DPAHCMSSYW6p0BDcPJ6VgJnUW4EzLCiKOncXeUEVQgQKJ4AM2uNJiGBOkADUZGdh28CDkWZiBlfXMXoLqf7vB7xf2a0SFVXBQ1RTiB5lvTcGbXcRnP6ETCB271q/JjMJhTHE1MiwrI6wO1Hl6VxQqEPygxdB1/LQ4jmYGPeBqSGSGVjBrCmOhvIy8xTHwPe04vJM2yCC49ZFIyJ3oMfkcKcOVEw7RUDZBtyjJNxLsuIpN2tzhfD9IKlU880TO4HTFc3Ctug8nEPJZGusYtUgl3YejnoE3vlZ1AdtmIgkBDEx/ElIXCrLjD2kPlLm6dgHMaA1QuMZzGUMr626NgW2q3LWJCo0xYp3UmZItDV3UiZ+ig1e7wnUMsn0rEMqyIz5qZ6KSQIcAasrcq2P7QGtPHloeafm4Fl5IqLyUlYhwazHuMR7sDOp7Fx4AA/m1aZBS1eHx+pqLdZY+g1v7ZEXKHJJ3PBZ3G4XMwm44zcbCigI5PSeUnhaNS0WqzlJhTFmpiVgvoART6WXwZDzuOjdOpXzzswYgWpwOV7nkEM15a4HEiPgOZNxsFikFNKVar7ykkcqDOmS4VZSK/qq89hT27yVbwRh3lQ2rIgb453mi70gfT2XSnQvmwoJynluZEEwu7EJ45rJBrtM8qSVkmNHmLJfcr4cyjyGARivyT8dtmZJClDp7X8sBgJQ9hVFIdnFMIgzye0Torz5WL6X+iMRdXQhlKzfU1BwvTBpiizeAW+EGBwiroGplRmQIdgWOJ2XqWCaBL2HbytFqEZvd+FqBu3DJKjZ7Kc453gu2I6qSuIWBu6c0dA3Jx5BUXB5ZUU9RpnN3GV4L61R7YnCfkLoVWxC2e65xLnRi3eA44RGkUZYNaZGujrjv1tJRcbdYj0bmHQWymJ4FJi99EbpXeIrCYJ7iFWi+dRTRxftuF7bU0sX/aRf0rauJ/bEb8m1StNhuvLtvsRB8+OmwnuhFrfAHs9S8CMFcP5O5302x8uB3dICW2Q4o8cgPud/xoRz3qN5WpvbboSmFb8Le7JCkID5Z6HiLgeAUkH3qB32AGCnScEFUiNfLCjjHuVJREzGjrBrqFxTQY7tATecq9AYM7VALEDgsedU88cbvM0llaY6gjTvLOMU0y7XwFwmiInoFFACKaZWSzMY/SD/CntmwrfDQnRgh9+ufQgYpRrib40Om5TYLt0tZri/dckyxMexMOSo+XTF5FsI3bxTayBVzNFIh5HdcWu1Y7mzXh8LxPmUJAODCoTEpoBv20baOKkKQk2L9QYA4VmFHQl432TcGwEq6q/ZKn8k6e9othEcULXAGaEdMZjgwtREgw6GihE8BV4UByEMDbyIhjse9QkIMCyxS2LIXL20pNyo7Eug2QbZzYF3kUGQUcJNFtJJTtsIVNG5q7DNtoVB3xadwkRPvm5+FAfWbdUxMbV4XeYUqBflhcekrz3HYWx9AZcHsy7xuSRJOzELzM1izOq6tTztgw9q5in0m+m0fuA2xzpD5JogN7/EOLR54Ud0y8ahWoXQet4CjZyVP8d3g8mp2YZKai4ya0gJRH1Fz+fVgz5Q5IGXl9//p2x/AG6+5T3VEQXYlaH8pDqBFBNaMUvC5k12u8qUWrshN5C+NVrjjXmyAPsaQoJcW8vSCGakxwocJH5MEpSVNtFrmBzHBYVKap36YBkGNlS3wgXQMlaQ3PgAg+AXRxOFbE6gESV+hqUQfa+LQKeVvmeutsO4Glxk9Q/dSJhJfmnnWRor1fGwkIAhsKOuAQGuQGpr30q3q+88KzWrq2H/UxndeP3qP//tFUB19g1BLVHo4Yisehfc9yJNBc16SY1+IqLhNKzwBoVdvPnZTzJQHBTAFORyx1b5P2bYBQ3GaBftI7ofMV8Ko0BBODGO7flk18ULCrDGlwVe5I1v4rDZ9/UwX7nvNc+xnIfTnsOKxZseq5WMD+o3QWJYRxRBhipbIOt/Eyx0ODajK0BE1pVAo6GIPdIrnN2wuVkS7EL7ZM3HdyYLioH5KQKUCJwYWaUJsqeQCfVk0C28jTRwlGnkS73Qt3wyd4bpNjQ1BL9Dc4CMNwpIY4wb1tGDrHarADV0W5nryU3YHqOiOVRV91PLuh0IPJXufRZ9WupRQgsicsIzvnI5y+NbQK24VSMT/NRESUY6r7nWeEpfgi41bIwkUGLDryah76nWsTwoFl30hzSXllibIjeXxG0lZMp4cVZ0RGYXYpYIvCHWwqeCRWmSHIZIKVYfKna6t7HEYDO1uZsmJi9i7WVH8d8y40xaRAFRruoCVytMHU3qbFqmoG3JSFrzkwNJgtN4chdQltmUlooqEBYm41ce3agKrrYpUl5JsnHzOn28EtStE6PzfTPjWgG2yErMq0LUwG2Ha6n6aA/8ghsHIy09Kk41lkfeau287ZMmW1DSF+fza15KJ34GwspJeh3UmfK6U9fypwUOQWpGPdzXCwcTPNgLdH91tuGtcY9+Q8RaK10d0yEuKRcNryiNg4n1diAIF9LRccjFHJxaYASK1Inna0+/dgw5+K38BGBAdrYFvxbZEmwSwtZ5SWTCZwo6ltMPGAhJomOnhjLwUZw2d6y6muV3VS3OXBfJUzSUo6hmfA267TJfYPkw1ZiIHa8rBw5LHcoRFSLZw70TjvcNUgs1jTGe8/6hqR7sUEmSZSjhkP0VevQQbHabZQ6GeCD6B+t/9Ie9LNYzJuo7GWY92b33PgAg4X1VXrlOzAk5MxuFjL1HhDWsFLZwFmxVUo9+u2M8Y49YkdEVp5GqAp8lE1HAePqn47VBYtlXzgzTiUzL45c2WGhmHTcw4Z+tp+CEOl2OqJbf/Hj4HVxrRoJ2D14lHpUJZfU8+fSfw2hmj3dgHaXXJ3dVduqFdVC0LIz+2yMn6zXdjK/uiUjtgbPjHJHyg/QiDRbUXvUTGnCO0/9oeu1RmP4Ldb5OebjdDWLH+KRdqquMk8rVJB6H7dMxMd5myrvfts24wVy1zvJef7bPhda8DNwTO70Uxsor/5JEzphtdc00zSeG5kadyYpPEVpoGRCrGRupB4OocfqQSMZDth9q1YviFknJ8f91T/gY+CwMbBlQB6vFyPcU8YX1pOXidp6eWGFHMdyeSqzdnkdPZUddDbn7VnFlOe1aorq498HyVpeW+RuI51TiouSid1zbJG8tbN/aK0rWmeLlYLt4K3aPz+IUXbiWu7BqW4eIQ+OTyZ0mTIgwcod78ldQorvPNlLPpHYrK/JjHZg9JG/s3ylD1s/TRllfwiExk5i0DSzTH5p7K3ZNJ+1wVjM2kaGCfN1GhyU1lYIDLn8lglHD/g352j72YLrUIdvMFTbjODsDt8/+J3yt/LAezy93GhEfuVlFXGpos5iIgbh3wj1g8rhFsK