From 5e773a0ec188f58d01301d7eed8d92d7181d9fc4 Mon Sep 17 00:00:00 2001
From: "github-actions[bot]" <github-actions[bot]@users.noreply.github.com>
Date: Mon, 26 Jan 2026 23:58:15 +0000
Subject: [PATCH] docs: update rustfava documentation

---
 public/rustfava/docs/deployment/index.html    | 251 +++++-
 public/rustfava/docs/index.html               | 166 +++-
 public/rustfava/docs/screenshot.png           | Bin 0 -> 238100 bytes
 public/rustfava/docs/search/search_index.json |   2 +-
 public/rustfava/docs/sitemap.xml              |  16 +-
 public/rustfava/docs/sitemap.xml.gz           | Bin 240 -> 250 bytes
 public/rustfava/docs/upstream-sync/index.html | 819 ++++++++++++++++++
 public/rustfava/docs/usage/index.html         | 232 ++++-
 8 files changed, 1427 insertions(+), 59 deletions(-)
 create mode 100644 public/rustfava/docs/screenshot.png
 create mode 100644 public/rustfava/docs/upstream-sync/index.html

diff --git a/public/rustfava/docs/deployment/index.html b/public/rustfava/docs/deployment/index.html
index 1017d94..9b00574 100644
--- a/public/rustfava/docs/deployment/index.html
+++ b/public/rustfava/docs/deployment/index.html
@@ -428,10 +428,93 @@
     <ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
       
         <li class="md-nav__item">
-  <a href="#apache-with-reverse-proxy" class="md-nav__link">
+  <a href="#desktop-app" class="md-nav__link">
     <span class="md-ellipsis">
       
-        Apache with reverse proxy
+        Desktop App
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Docker
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#systemd-service" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Systemd Service
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#reverse-proxy" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Reverse Proxy
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Reverse Proxy">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#apache" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Apache
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#nginx" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Nginx
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#caddy" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Caddy
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#security-considerations" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Security Considerations
       
     </span>
   </a>
@@ -500,10 +583,93 @@
     <ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
       
         <li class="md-nav__item">
-  <a href="#apache-with-reverse-proxy" class="md-nav__link">
+  <a href="#desktop-app" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Desktop App
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Docker
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#systemd-service" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Systemd Service
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#reverse-proxy" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Reverse Proxy
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Reverse Proxy">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#apache" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Apache
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#nginx" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Nginx
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#caddy" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Caddy
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#security-considerations" class="md-nav__link">
     <span class="md-ellipsis">
       
-        Apache with reverse proxy
+        Security Considerations
       
     </span>
   </a>
@@ -531,29 +697,66 @@
 
 
 <h1 id="deployment">Deployment<a class="headerlink" href="#deployment" title="Permanent link">&para;</a></h1>
-<p>There are a number of deployment options for persistently running rustfava on
-the Web, depending on your Web server and WSGI deployment choices. Below you
-can find some examples.</p>
-<h2 id="apache-with-reverse-proxy">Apache with reverse proxy<a class="headerlink" href="#apache-with-reverse-proxy" title="Permanent link">&para;</a></h2>
-<p>Apache configuration:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a><span class="nb">ProxyPass</span><span class="w"> </span><span class="s2">&quot;/rustfava&quot;</span><span class="w"> </span><span class="s2">&quot;http://localhost:5000/rustfava&quot;</span>
+<p>There are several ways to deploy rustfava depending on your needs.</p>
+<h2 id="desktop-app">Desktop App<a class="headerlink" href="#desktop-app" title="Permanent link">&para;</a></h2>
+<p>For personal use, the <a href="https://github.com/rustledger/rustfava/releases">desktop app</a> is the simplest option. It runs entirely locally with no server setup required.</p>
+<h2 id="docker">Docker<a class="headerlink" href="#docker" title="Permanent link">&para;</a></h2>
+<p>For server deployments, Docker is recommended:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>docker<span class="w"> </span>run<span class="w"> </span>-p<span class="w"> </span><span class="m">5000</span>:5000<span class="w"> </span>-v<span class="w"> </span>/path/to/ledger:/data<span class="w"> </span>ghcr.io/rustledger/rustfava<span class="w"> </span>/data/main.beancount
+</code></pre></div>
+<p>For advanced Docker configurations (authentication, HTTPS, docker-compose), see the <a href="../contrib/docker/README.md">Docker deployment guide</a>.</p>
+<h2 id="systemd-service">Systemd Service<a class="headerlink" href="#systemd-service" title="Permanent link">&para;</a></h2>
+<p>To run rustfava as a system service on Linux:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a><span class="c1"># /etc/systemd/system/rustfava.service</span>
+<a id="__codelineno-1-2" name="__codelineno-1-2" href="#__codelineno-1-2"></a><span class="k">[Unit]</span>
+<a id="__codelineno-1-3" name="__codelineno-1-3" href="#__codelineno-1-3"></a><span class="na">Description</span><span class="o">=</span><span class="s">rustfava Web UI for Beancount</span>
+<a id="__codelineno-1-4" name="__codelineno-1-4" href="#__codelineno-1-4"></a><span class="na">After</span><span class="o">=</span><span class="s">network.target</span>
+<a id="__codelineno-1-5" name="__codelineno-1-5" href="#__codelineno-1-5"></a>
+<a id="__codelineno-1-6" name="__codelineno-1-6" href="#__codelineno-1-6"></a><span class="k">[Service]</span>
+<a id="__codelineno-1-7" name="__codelineno-1-7" href="#__codelineno-1-7"></a><span class="na">Type</span><span class="o">=</span><span class="s">simple</span>
+<a id="__codelineno-1-8" name="__codelineno-1-8" href="#__codelineno-1-8"></a><span class="na">ExecStart</span><span class="o">=</span><span class="s">/usr/bin/rustfava --host 127.0.0.1 --port 5000 /path/to/main.beancount</span>
+<a id="__codelineno-1-9" name="__codelineno-1-9" href="#__codelineno-1-9"></a><span class="na">User</span><span class="o">=</span><span class="s">your-user</span>
+<a id="__codelineno-1-10" name="__codelineno-1-10" href="#__codelineno-1-10"></a><span class="na">Restart</span><span class="o">=</span><span class="s">on-failure</span>
+<a id="__codelineno-1-11" name="__codelineno-1-11" href="#__codelineno-1-11"></a>
+<a id="__codelineno-1-12" name="__codelineno-1-12" href="#__codelineno-1-12"></a><span class="k">[Install]</span>
+<a id="__codelineno-1-13" name="__codelineno-1-13" href="#__codelineno-1-13"></a><span class="na">WantedBy</span><span class="o">=</span><span class="s">multi-user.target</span>
+</code></pre></div>
+<p>Then:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a>sudo<span class="w"> </span>systemctl<span class="w"> </span><span class="nb">enable</span><span class="w"> </span>rustfava
+<a id="__codelineno-2-2" name="__codelineno-2-2" href="#__codelineno-2-2"></a>sudo<span class="w"> </span>systemctl<span class="w"> </span>start<span class="w"> </span>rustfava
+</code></pre></div>
+<h2 id="reverse-proxy">Reverse Proxy<a class="headerlink" href="#reverse-proxy" title="Permanent link">&para;</a></h2>
+<h3 id="apache">Apache<a class="headerlink" href="#apache" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-3-1" name="__codelineno-3-1" href="#__codelineno-3-1"></a><span class="nb">ProxyPass</span><span class="w"> </span><span class="s2">&quot;/rustfava&quot;</span><span class="w"> </span><span class="s2">&quot;http://localhost:5000/rustfava&quot;</span>
+<a id="__codelineno-3-2" name="__codelineno-3-2" href="#__codelineno-3-2"></a><span class="nb">ProxyPassReverse</span><span class="w"> </span><span class="s2">&quot;/rustfava&quot;</span><span class="w"> </span><span class="s2">&quot;http://localhost:5000/rustfava&quot;</span>
+</code></pre></div>
+<p>Run rustfava with the <code>--prefix</code> option:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-4-1" name="__codelineno-4-1" href="#__codelineno-4-1"></a>rustfava<span class="w"> </span>--prefix<span class="w"> </span>/rustfava<span class="w"> </span>/path/to/main.beancount
 </code></pre></div>
-<p>The above will make rustfava accessible at the <code>/rustfava</code> URL and proxy requests
-arriving there to a locally running rustfava. To make rustfava work properly in
-that context, you should run it using the <code>--prefix</code> command line option, like
-this:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a>rustfava<span class="w"> </span>--prefix<span class="w"> </span>/rustfava<span class="w"> </span>/path/to/your/main.beancount
+<h3 id="nginx">Nginx<a class="headerlink" href="#nginx" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-5-1" name="__codelineno-5-1" href="#__codelineno-5-1"></a><span class="k">location</span><span class="w"> </span><span class="s">/rustfava/</span><span class="w"> </span><span class="p">{</span>
+<a id="__codelineno-5-2" name="__codelineno-5-2" href="#__codelineno-5-2"></a><span class="w">    </span><span class="kn">proxy_pass</span><span class="w"> </span><span class="s">http://127.0.0.1:5000/rustfava/</span><span class="p">;</span>
+<a id="__codelineno-5-3" name="__codelineno-5-3" href="#__codelineno-5-3"></a><span class="w">    </span><span class="kn">proxy_set_header</span><span class="w"> </span><span class="s">Host</span><span class="w"> </span><span class="nv">$host</span><span class="p">;</span>
+<a id="__codelineno-5-4" name="__codelineno-5-4" href="#__codelineno-5-4"></a><span class="w">    </span><span class="kn">proxy_set_header</span><span class="w"> </span><span class="s">X-Real-IP</span><span class="w"> </span><span class="nv">$remote_addr</span><span class="p">;</span>
+<a id="__codelineno-5-5" name="__codelineno-5-5" href="#__codelineno-5-5"></a><span class="w">    </span><span class="kn">proxy_set_header</span><span class="w"> </span><span class="s">X-Forwarded-For</span><span class="w"> </span><span class="nv">$proxy_add_x_forwarded_for</span><span class="p">;</span>
+<a id="__codelineno-5-6" name="__codelineno-5-6" href="#__codelineno-5-6"></a><span class="w">    </span><span class="kn">proxy_set_header</span><span class="w"> </span><span class="s">X-Forwarded-Proto</span><span class="w"> </span><span class="nv">$scheme</span><span class="p">;</span>
+<a id="__codelineno-5-7" name="__codelineno-5-7" href="#__codelineno-5-7"></a><span class="p">}</span>
 </code></pre></div>
-<p>To have rustfava run automatically at boot and manageable as a system service
-you might want to define a systemd unit file for it, for example:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a><span class="k">[Unit]</span>
-<a id="__codelineno-2-2" name="__codelineno-2-2" href="#__codelineno-2-2"></a><span class="na">Description</span><span class="o">=</span><span class="s">Rustfava Web UI for Beancount</span>
-<a id="__codelineno-2-3" name="__codelineno-2-3" href="#__codelineno-2-3"></a>
-<a id="__codelineno-2-4" name="__codelineno-2-4" href="#__codelineno-2-4"></a><span class="k">[Service]</span>
-<a id="__codelineno-2-5" name="__codelineno-2-5" href="#__codelineno-2-5"></a><span class="na">Type</span><span class="o">=</span><span class="s">simple</span>
-<a id="__codelineno-2-6" name="__codelineno-2-6" href="#__codelineno-2-6"></a><span class="na">ExecStart</span><span class="o">=</span><span class="s">/usr/bin/rustfava --host localhost --port 5000 --prefix /rustfava /path/to/your/main.beancount</span>
-<a id="__codelineno-2-7" name="__codelineno-2-7" href="#__codelineno-2-7"></a><span class="na">User</span><span class="o">=</span><span class="s">your-user</span>
+<h3 id="caddy">Caddy<a class="headerlink" href="#caddy" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-6-1" name="__codelineno-6-1" href="#__codelineno-6-1"></a>your-domain.com {
+<a id="__codelineno-6-2" name="__codelineno-6-2" href="#__codelineno-6-2"></a>    reverse_proxy localhost:5000
+<a id="__codelineno-6-3" name="__codelineno-6-3" href="#__codelineno-6-3"></a>}
 </code></pre></div>
+<p>Caddy automatically handles HTTPS with Let's Encrypt.</p>
+<h2 id="security-considerations">Security Considerations<a class="headerlink" href="#security-considerations" title="Permanent link">&para;</a></h2>
+<p>When exposing rustfava to the internet:</p>
+<ol>
+<li><strong>Use HTTPS</strong> - Never expose plain HTTP to the public internet</li>
+<li><strong>Add authentication</strong> - Use a reverse proxy with OAuth2 or basic auth</li>
+<li><strong>Restrict access</strong> - Use firewall rules to limit access to trusted IPs</li>
+<li><strong>Keep updated</strong> - Regularly update rustfava for security patches</li>
+</ol>
+<p>See <a href="../SECURITY.md">SECURITY.md</a> for more security best practices.</p>
 
 
 
diff --git a/public/rustfava/docs/index.html b/public/rustfava/docs/index.html
index bd0ecfe..603bd67 100644
--- a/public/rustfava/docs/index.html
+++ b/public/rustfava/docs/index.html
@@ -267,6 +267,24 @@
         
       
       
+        <label class="md-nav__link md-nav__link--active" for="__toc">
+          
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Home
+  
+
+    
+  </span>
+  
+  
+
+          <span class="md-nav__icon md-icon"></span>
+        </label>
+      
       <a href="." class="md-nav__link md-nav__link--active">
         
   
@@ -284,6 +302,75 @@
 
       </a>
       
+        
+
+<nav class="md-nav md-nav--secondary" aria-label="Table of contents">
+  
+  
+  
+    
+  
+  
+    <label class="md-nav__title" for="__toc">
+      <span class="md-nav__icon md-icon"></span>
+      Table of contents
+    </label>
+    <ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
+      
+        <li class="md-nav__item">
+  <a href="#quick-start" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Quick Start
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Quick Start">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#desktop-app-recommended" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Desktop App (Recommended)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#command-line" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Command Line
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Docker
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+    </ul>
+  
+</nav>
+      
     </li>
   
 
@@ -443,6 +530,64 @@
     
   
   
+    <label class="md-nav__title" for="__toc">
+      <span class="md-nav__icon md-icon"></span>
+      Table of contents
+    </label>
+    <ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
+      
+        <li class="md-nav__item">
+  <a href="#quick-start" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Quick Start
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Quick Start">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#desktop-app-recommended" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Desktop App (Recommended)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#command-line" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Command Line
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Docker
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+    </ul>
+  
 </nav>
                   </div>
                 </div>
@@ -462,21 +607,26 @@
 
 
 <h1 id="welcome-to-rustfava">Welcome to rustfava!<a class="headerlink" href="#welcome-to-rustfava" title="Permanent link">&para;</a></h1>
-<p>Rustfava is a web interface for double-entry bookkeeping, powered by
+<p>rustfava is a web interface for double-entry bookkeeping, powered by
 <a href="https://github.com/rustledger/rustledger">rustledger</a>, a Rust-based parser for
-the Beancount file format compiled to WebAssembly for fast in-browser
-processing.</p>
-<p>Rustfava is a fork of <a href="https://beancount.github.io/fava/">Fava</a> that replaces
+the Beancount file format compiled to WebAssembly for fast processing.</p>
+<p>rustfava is a fork of <a href="https://beancount.github.io/fava/">Fava</a> that replaces
 the Python Beancount parser with rustledger for improved performance. Your
 existing Beancount files are fully compatible.</p>
-<p><img alt="Rustfava Screenshot" src="https://i.imgbox.com/rfb9I7Zw.png" /></p>
+<p><img alt="rustfava dashboard" src="screenshot.png" /></p>
 <p>If you are new to rustfava or Beancount-format files, begin with the
 <a href="usage/">Getting Started</a> guide.</p>
-<p>This is enough to get you up and running:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>uv<span class="w"> </span>pip<span class="w"> </span>install<span class="w"> </span>rustfava
+<h2 id="quick-start">Quick Start<a class="headerlink" href="#quick-start" title="Permanent link">&para;</a></h2>
+<h3 id="desktop-app-recommended">Desktop App (Recommended)<a class="headerlink" href="#desktop-app-recommended" title="Permanent link">&para;</a></h3>
+<p>Download the desktop app from <a href="https://github.com/rustledger/rustfava/releases">GitHub Releases</a> - no installation required, just double-click to run.</p>
+<h3 id="command-line">Command Line<a class="headerlink" href="#command-line" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>uv<span class="w"> </span>tool<span class="w"> </span>install<span class="w"> </span>rustfava
 <a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a>rustfava<span class="w"> </span>ledger.beancount
 </code></pre></div>
-<p>and visit the web interface at <a href="http://localhost:5000">http://localhost:5000</a>.</p>
+<p>Then visit <a href="http://localhost:5000">http://localhost:5000</a>.</p>
+<h3 id="docker">Docker<a class="headerlink" href="#docker" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a>docker<span class="w"> </span>run<span class="w"> </span>-p<span class="w"> </span><span class="m">5000</span>:5000<span class="w"> </span>-v<span class="w"> </span>/path/to/ledger:/data<span class="w"> </span>ghcr.io/rustledger/rustfava<span class="w"> </span>/data/main.beancount
+</code></pre></div>
 
 
 
diff --git a/public/rustfava/docs/screenshot.png b/public/rustfava/docs/screenshot.png
new file mode 100644
index 0000000000000000000000000000000000000000..3314105da87dbc13f38894ee177134c1d1170c05
GIT binary patch
literal 238100
zcmY(qbyyo)+lL#ZxCD1?a47B$0fIY};_jt56xRlKEiT2Oc=5JKk>c(x7TjG=_BrQz
z_x=`tglovmu+}`bp5HxD8fpsI7~~iL003JN0@eZmkiP-|h*4;W@FSodg<tRwT1$wQ
zDgf}25da7d2LSHjhk|zj08cIeVBZV?5Xl4pNIvAWYl^}DfMTJn00zAL^Hb1OmID7K
zKoKmh<Fj-a;GIL&pA@7!{(Izen43JaG8!FF(aOoKNwMVz=?9TzSmQVu6Xp2b*MRGB
zbf)jY+-Bbege^lrAmm|TM}6}POy23M2TL#gj)yP3o!H3*Jv2ebeaq;pv%0g!u3sA}
z*BaOX$gj|_{yT8I3)ZZ+9=e?k^mJ#rYz(A4PSuc$sEN&>+;)euNdJy7S)39HM%wE~
z+j3V(@L<5p_YiRb0MAGR`zI(cOj5=S$7@vyxgVu~8x8wEH^348Iv!*`pMdHt(w9eq
z=lK%sb&7=dO3!TkJ1rI8tBMDv@6_Y`dW9kXjvs}HhzQc^#fgak01FqUD2D+3Pm{@?
z-=C2HqCQykABw0^OvcO2^uHyFXe&m!^RyKFdv3^&LKH-LdRok9Bq#s@9SukeK|E4H
zW&nwi@*F;{q5x!ysOM-s$+J*j5TyE|2$<+c8Z6a*Hn4+dYW4WI{x?V+GD*jl&Eld6
zZv5xnF#+LrbiHbhKy(D?$IOV3ka<xZyPKWVu~^N0C6ZSFwZ1kNZnhM5b%tR}HL)EK
z`-r^N03{!n&*w0l$u5-tZzyHfTp!i{?i;%4l=(5bjj?zgZ!<rNglI|ZC3gc1Vg8ES
zArm3BDi`6UPs_#p`Y;{?<waWJhQmfTeOAxPVWS?Iesjh1DM$Yl?OS2b|EBz-;OBxT
z3O+4ufpz^`M&m3+UA?sVW>3D>rsEMJ5mFv2_OGYy$q-zdXfGIaX~G%LYbVN!JQBR+
zo~LHx!1}3-z&h{5#$B~dCItqA`qQtUmi_PAA@Jptoe)C7bBbAv*CtNT*GZkXnIanH
z@WbU3{IG5tt9jE8naGlkUQIWe(AhDIx6|*@RLjxVpPAQ-m+G6l9+<n13|(Hk18Ixf
znf*IH_ym^&qyVF_M{0~!BfPy1mGYpCy~u!NBf)WY(XUrP+FgDn@Sun!lQ~0*b(B?m
z<2lzLCBsJFL8bhhZv5%f&yXFCQRfc-WBPYcyK3owtrRJ&7j*$0Me5Gq@y&XyU72>;
z5Sa0^i+h*YLBq?}gO31EkyFd4QVGwH6*-=04;ZrL-c#!UcHTY>U9NAn*A|%nof%=A
z@IO2F=NBQd5Ifgn_!2=g)pQvMvf`bpV18Hz`jPgqm+e0HMFF;~-+d|eVB)Rl`)+*`
zJ>F`Yrh^@FTqpK#&asO>^08e1k3+Zs0Z73{wPeAi)3e-6YjbnpzCzK(MmATz&(4@j
zV?YGdjqVdswW98iAlIOv>7CH!u?a?=FaO8LlMoRB;JKCduC4$VMqLA4gOdjdJiODf
zF>Wd8QCiGl6k*tpmzo+%;>Jz*GBrdHM+#(p|G!s2MK0P&r+U>|T-hl>t?s!L-q&#`
zjYvB;3qcWES7w;n&Z;!(Zf@>MDzu&g|91lMD!`)c_Qkom)$}8s^m%;OjgYf>dwfLN
z*NF6RM>xr_tz;jucXl~#b9@&?PWtbl9HJeljz4^sDeMx{K3Z_iN0t6r3#7xt#D@sq
zP%)XLSF#c=x!(~ZPixP7|9AX>pt>D<dQg6KVoIsq>Yl$VmEMqsCL#b4ZrV;3>ff?w
zjkI<IQYVoOll^-yQp&%yfWht02+Uc7K)?wO9wGqv8gVR2s5IFcEM{uQTT%4?yXF7;
z;et(D1S7(ThzE=9EpQ({81EH<CuXfvp-h`Bh^*g^0Cwkc|6PMMe5o<x`OyIj^bt4z
zV^jgN3F{e@;DV}HYhl2ayC53XH9vaTH@d5@#1D_f2}Bi^I@g_y$#~?m7Dv?nXR`N}
zkJlxD@GcqK@BJP~v)}3C#P($fwN=348sY|*4(t{nW(!s-8O=!~>CTC4D{$O$J;)*T
zw|-$2aF|JaPl}aQdJ>7{5FLp*fqs^b#4u?Ip^GU|2X<K)_Q+8_`c89*{$0Gr+|-@+
zkg{Gjm;43+A+IerjaJ1&j1&Y97<yFm>mZTNi$k`oN~gPH$QG3~0_ka)O*v&)WAA{)
zbfO1a4qOl6p{I#tER<^YO6HGiA|`dMn=~g9&W{<uDn0HmC{w(gFO|%ePO)Q{DC1)w
ziy9MgN_g5i3K40L?=sQOd8imIk`U90FLJY#Y?YzPOKQXp{=I~_=T$MZ-*qfE7Le~p
z+(>3&Tc&xaLeb1(CowEcFEe4zcuA$h$DNCmLJ7KUbvsKHX}S#o`H0$!f%!V}N)j<+
z!TcH?i1IvH9$Q&W8DC&uH52+}eaT}?@Y)-ar6bqgWak>~Tve=!LkLF@!wsmi1%k$5
z+6$ERP?xl56y4BBxecJM0UMcC(+a~b>h{7{C_^+ERzDlXFj2`n>+KVK7TUcPmW_O+
zHAlMGDouW|(ptUf56pOw{*;nd<b@2QS{QzkwZU(T)doFgLjQ4806gCJQ7$uLOi$tS
zSM|;oQ7I_oYbypaWBGB~v-!6DOg)g&s!6q4^)s2U#VDM@)*@n>3MrDCF|eDMtJUB$
zOWr3C&QFPayH~zDVQ#tL5J|0bX^Q+2r7b?0jzw@k5%G0Amj|Al8+m(Qa{p29nh4^8
zJ0PhuMM<}q&}%{fLXT(qMnXwKb6;IGepZ+$gE*2dO;go;^U!?(Qye>TN<$X?wbY+$
zWN_%%2~aEJuPthb4C0$Du_t%Kk}wE*i(fq#M5REZrn15SY?wQysqTJEPriSslB^gt
z2Gl8Oq36)pb=4b6O-2G@Amj5R>!uij`ItgbP~+@A8`1i)dSj(9Msa-7vIb3QoWl;F
zW#PTbr#MPN(!Pu-)x}l-H$U{|(zk>Pvw~ro2|u&hipG!Lg0-k>n9sn$N~`wroBXzA
zg)t(zX;M-XN8b(~QN0H4aYXn!<bAkyKjj*5rdwmvaEsw3oGiEYlr~4uAt8@n*^Flg
zj0xN7>+7ebSyTINO$I$5)Puz)+vMmyUXVVbkotAM>X3;Smq%Q+7s&qXy}O6XAFq+T
zl{=MM_IQi$dK9kjkjExd(_z6T2c{HeD~dFI`$8&(xQ+F(Bl$}#c&S6~7t$0?$?h%9
zwk*D@rhQ}<<PP$sxG}V_n`@$F8e|v+Nmp)}0H;TW6DZ**C)3iF^e~0a5S1F?X>3=p
zP<;`SiV`bvyF6fCkm$o&^?Ich1|9rri<&uRDs(jpo5{xW?9RD)JVjoZ$OXODXD%-!
zpo@MJ--J>wa!5=-eko&KK%&|Abs8Un?G4=kqgxYhyQjWK!vB>D_A}qjlSXWd_BaPd
zm`1zDNmXVjPdlC`nJuJBe|_4e6om|nol85|e70NS8rCr!<)0m2Ll=)9oF2Mg3DvR~
zuBaJL7f~?TW`*olxTq<p%D)QHrPbmutvHy-&D3eokin9^Vp_jJhtf5&k6d(pXTJ=f
z0gzh$5FiV`CAEYOl5X~iuOk7#O_>qFuUZp_tRx<?Uh;Ttuf1PjenC$MPu5ut{%=f8
z^>6ORgS-Y}_xx^-M{V5UHRz9c(oRAI=jAVNZdXtNBMt4ShpwCu5$i!<5&<j+^}5n|
z5!Ks8^*&MPCizl;Ux)kcOtnvLImxA^OI+o+XMAu0%t`CZKtZ$z2<I8Xr)9s!Ju~44
zOt&n;N+U!yOB)H9YGYnhFY;rM|7O>ljF!YGJItZZ%!19~VLG9xA5R{embwPk>ZfnP
z5-((F)C9-kRj$*^wWZnWM_Gh$-H6)}bfUfj0?FttGJXN0F2;fsM25nYjDfTkg&KB_
zj>;hX3Z3X+Ab0+FbE|iWRt1=TawK$GP<xLS01ZB@{lc@sKdEx0;eeqUmk^pNHo2H|
zsphHql%bSHH6#eE^pdvxtSO<*5;%NBiTp9~^6|^PAymsH5~n&JfeoDkit{502fN@X
zXy5h~p<KRxIV))IeW6M*D>3R&i0(Rv(i8%7FC%TYGVipg$FPWJnojB&XFH%tP-jAD
z6e4CVqA)O_koNru<arj{v_RCS5VxkTT&mUL48y#eOP_0KX!y<^`)dO^b!0nWy)iRQ
ztrQPF6Tj|^Q5)xFwX$izpF0x;zfaD~EzZ_FS^N9@OG`_`(a|c5DQabywW6+5eP^4$
z`1$!?9$`H`J6X2I^9=CdmjvM&@LzXvc5ZfF_Hz2=wQ(lIlsB>yssTc@;UOEyH2iRJ
z=U=Gt!9tCG?LeMs2UvD0i)Ht1ym(HB?P4K~?1Y{uTvMw>!_Z7RY*sq44?(LnBAjWP
z<q709X#v*dTt82>c%y!Jc;S$X%sctjb87yojJEyl&(d?d8lC_uT{7%!d(|TIkqi_a
zC46K`2D-o*qbCS|5q=2KStIiRo6_OT$`Yh*PEpdFrwM}mlRC6ADVR$t8XDo>-CR>s
z#*nU7mJ(%Uidz63*UYY3Fl@W)HZ?SKe>}TrbzbgvhmHA&<#BE~IyfXq25yYyih7@{
zO&cH-w(T0b>^&lye=s(i{lc3zq!MxRz{@zU%rMe&^6uE3M9x7y%Vy%mi_q<rv5Yry
zsgGTxsFaB7=uqf2N(If1yzYiZ310H;N))18^@#+bYft>IcimPZ+k7S5?{<H=#SFh<
zc!&Gyor?RGW?4ZB%5?snytU<o8Qti7+60m88nbc=$LqU1KHaS6LnX-INsu4@#6(X2
z-R~s5vV$z-Euk@zp3^%5HKFG*(UY}C+i_Hh(`UgopNl(~>1{$nz>FuR>C2K}I=g|0
z=hBQ}&t-pm`x4E|Z4gc1ZPMLELdQ;aRhdeb#j>8Z_Qmzla?out&HVgq&`rmBWqG+-
ztfz+u?Z%w*vWd@ge^p(ew@5ByQF^-G*wabS%ct$_?F=I~S2;O3o-8{DhmTjY{WoiV
z>n+a9wqrSG5uAbD4MpcwrguwI^Cn2a@Vh;%z$7*wp7p!$n+4b3`d-cI=emy>5D}&Q
zh^y;7-#0yO^LDW;b{3`Uzq`Mu)FGV1bGA;@FikH$RvkttDEJ^%A#jz}8E-Z85IWdV
zaMknoQ#ZbB7gBNqZ_Z=a@D;0c7IRlSKE1+ft{i@eyM=Tb5+XfMr2k(t;Mi35A%><~
z5FeS;C2-WZAb)g9YCAr*eLBL9Y3m<D;B}m1A8CQQOM&~E9p~P!wsZ6eXjgu$*rl_O
z$dG&v-;{h<&o^oGI->G^d>$3lkEam4Za=6Mznakwyc;nUKOZbU19$54MEh(&cOTyC
z&fe}1b63rA+S{*^BrtH;AZR#_1a`R3A2ph?<Q^39qt!&tOybaT2qQ_GVfP&)L_H^W
z2yc^&jGDFW(_we1AfiU$ml82X2pAJact8@H>BqCD_i9L#+=ucI5KrR4yveuU)Tch#
zMJg(0BOz7B5+?mAP?}YGG*?>Xs8eM~OOdl>n&VdHyYd{0f(GnXYflyIam9ZmPW7qS
zzN#AD3<Y@-G~>!DEh#0FG6++N2;&uk_Sr*!!Gl3|_P+9)HlKyBAD3Ia4;PY#tmLt1
zj@#d}6L02FE>jCs2lhenT8?Js<^s3bTGjHz?ylzbDHnQr8Y=hCM>so9>TXV!J6hY?
zN~^1XyB@~JI|(dLPOYp=POeQ&We-^aX!FNCJ*<S!rqv~#FLx&$=c?=39j7!?Bp(0b
zs%CQiRW`jpPv<ZcSz1oW4_Yy>&A;1E?#Ei}+}u&k6}gHaF<I%fcc;%1I%?8Zh^K6R
zzbZ1)5HGS{p5VXLyEzc|Fs$F5J`N+ZM7?=?H=tB`>^mI$UgOG=Hjet^FeG)y$fG1p
z#}J>e*)oYa3o;O<cFL+F9NtnmrH+a9l+>qW((^%{Oh@w=bJ&x;jh=1lOkSZQxnL|G
zdAVJyRoO?1+AV`5j71pZ6$sH;i{uvtL)zc|U!Ix?=-X4lCe(@DGztd9Rr%{`c+N7V
zPAENeK6&0VnhF8O?)i#kydf3};rWkS*Krhr{WU(e)}rz{()8zu3oTuau(5vS^c=4x
z``CJ>JRi5`$4xcSqbBQ-440K}lP%8X>^cIjhdhrs*~!<^dr_=g_`WF~A|YJHbz<Cu
z7tIjL)$}H3Lh&pezbLgT3h2gsYRbDkIp$GM{gt<JwG&sCZM1_lQqm=Ox=Sg1+1$ay
zn`j@?W4oJ+d#<9H<;}?ui)=D=bTH_n=pZfa8^+RaED8kqw<+Z6=ImwIiV6eQ8zJwh
zwh#DHa?)h5LsOF{t`O_f%GXWa;-jTC^``9_CY8u4rg0z!b;5jW4|MhQpAKy$gSON9
z0Uk4&DdOX7gcv#QU|PiaE3t9+)t|eQ#qzPF^}ZK7E&&gs2Xoc0{%O<j@$(Dv9p1s?
z#7pjpzu)nS<@=r|+n~FVuB-+XckSsfs-InYo|tM6)&d{K^Mao5eCX@Vdk6d_)N@EM
zjun}5eGY0&bHx4TW-7Gv0<PO&c|qnsLSJDLvzJ#@jPAJo8p}QKeU9Pmo>^PVQ!4Gb
z8+C!X`O=#(6RHVsr*a1DVY=`9&f>G*XxJVR)s6yZ>s=H8$o;UvxYYZo@mnm@=TFLS
zdT3`$ivop{q1yJIN+MVlpqO*CLSDBdlQfu_Y~Ko{P6ar3sb_+$u*nIlZ#KB_T17{{
z!K!T9;QiBpU(&V2#A#mGHG)dk?;`ENvg%eDX)-$W<iX37cbc!)3T8ZMPidmOY#DUZ
zlrlw%y}-!9F5P!Ka9`o|yROz&6E1BmC6mdg&c#!r?0u{OTNya1%l3-jtSKNf<@;~M
z?oD$nn{@l%t$MF^*-zVySfC!YYPdA~nU!YZ+pp(b42USbK#KVIn?oOZ{uGI_i|&@6
zrN)wr0~w|%xVgrEBp{5SE#)vMsZXL#daX+ZW|biYuCe{)m`D)OqS~2sRg`B1vt&)v
zyS}=7m?d<T&+d0iN=?{FD4lhY>TB%&a%gvsF888o3%cKo0&xb!sUNN+LX(HKQq(1`
zI@VYJ3aJ?yE`M{~41MM{_WNKvt-0Ldb+}M(dy}WApxS<PV7l7wxm;`9LBjE_$#s(v
z@Edjkro<B;AK!MXfBW0BOQsO$f#PW_m@)p^lGpZk=WY=uqYA01p5A~kDqy)KY+{2~
zUD9v0c|Mj()aE*8(eL^&i`Ujmwl}X-IRi2H#IMn2wEgra=0F0Csa`tzdk@Nv&dwYm
zT!CwR2Jy-g=6t>EVTLZ<X{$`gz8tTE{`uH)P`0ClY0z{Db1$^LPqWo&@>bC@^nRqU
z?T1{Eygh1gVEV;gmC%HZPQc!@Z}l@b%T)W##kbjU2VGwkA1M-UyG{#(!%@NY#~-+X
zry;m2KKm7AURV1i$DyCJ^yp^XUQ6{|9n4GKthit7P>EXfL0ekp<YI_x-q!zYaAK}~
zM_9+HS+`4b^(E6-MG>PkyE9s)3G3~Cv6K-bo$t5Zjb|hE+^zu@zUn$&(~0sbX>1Iz
zvo_06*u1YAx_)v~{F^BXMRHcWAu)&Fp?z^Gnj-v@v5?P;;Az4L$5e2-3iuPP5*|Su
zG5=c~`aNbKP$S?-_Sq^IGt~{0VS(PPsidyxkm4o=w5Au?WOB_hIG0lWflz^>?Qm|=
zddX_F(CpaiEL!2Qbnz6H??t;IVf)*S@{>?2mF@hoc>cprlDeREKiko4e(&QIZ8b&X
zfUAz6%gy}99l;*!-}@iY7h9Yc_5K`S2U^7vVH`(c68qoHaas-Yygc8qadus5$;tH-
z=^MRY762@@G`i1^+2;8k4^X%WT`yP$tXGwn`#j%~=+(Sa1^l9P|6S7>$epJ2^spXd
z@^No_f4_2sv!{B*0b8v8V>n`0E(3m1gE)Gn>t()TW$onKDIvKcl1g<C0qxvk$Vm_V
zwUC_sv1?Hd&dg`V@<CnlPrGakZ9MafQM4Oqaxi+;u_S$yOQhU{ne}<46xAuHw>jY|
zrd%sCgN!?drn=~G9D3icny-mM^zF6Fb92MOuNLV;<e5TsSkqJ(Lro!pOPXqxH=NQm
z_G9*IoxY|IOZsK%`SECji656VKsBmq2Wx8?bQXnw;;H%fFL~7xep$xFVb{Ms>?0uQ
zyxSRWcAOVcJN(m{luDMpU|k={KiS-@N8Z2HTVy3bI4G$|)UNgCb(VZmOV&ihi8v-}
z9?NcSiiTAAn#-?aeds`SV=Iv<CuhAJb|`a=<0w+Tkz=rj<$*S7u=z<p*O$_-ECrcN
zic%tY$}!9ZvTuP9;>c}iqy(}xCEIJLl~aicGz><Uc>JwM&C$)dYEvnZFo{(il3gjg
zPC`(5FV+65IM`RJ|B-fWgau=r_#!O+lIX&aW+258G#R7OEEUq2#tcQh?^Xxj`LA7c
z`iM!G{|twj`uy#C#iXN?`jF$kURTcS;$-*O$0T8(shOly)_vK}nd7}CsxH2rDtde?
zj@!KmCUmzL9UX;t`$S7Qd@x}IOllu2>LViuPM*ha^87cVa91uv4r)8*JdFWTkt;BG
zVL4oyVbb~GZ$<oOQ&W@Jb00yQ|5!scJllxGPftvo=EBdMRu{ke$2*rC>xN+N4Q*k6
zoXSd~ptj(<_Tk3B{0>k|)ynHFg1xdD<&C^9;1?8@=yvA3hR*NO2Hgv`<%QAhK4NY!
zv=Gz+b*(9&v&Ioik#!oggK!(O(`&X`5zS$={UgV0wR#C}X75iBS0>-Jzz<_5Ew&)o
zo0+BV-aE?v^U@h%xC!B-q(dWv^`N_LYvr1+Ioo%OJVdB;fXMeN4GX;EVvSZqjxEkK
zkD%(^59PjYyY19?q`m$Uf?kK2XPb3b0h0OSugzNhG{5kH`mj2%5CX<&gx&hE1&xB>
zF^Aot;d0S7U-WvRtt>xqNmX$5w#xL$rZ+M!-TCU#<h`l+-kBe47*j2*#R;UO?p|*k
z-en5nzT`GC^`I7%OA}+BP!%Zy29#Fpy~fjg?ZK9|&xm;DA@y-?=4L<1XO=d49j%D+
z7Shg^7}<=ZMU0<-jew@BgW<ePn_t0)Gj~u*OI2fpkQ6x#h$FyKBr~xXfFdOaxM2|r
z6hd&r$+?n>%<-$VV3h21j8UtCBG9cs{HHfJf{ynmX*1J&V)wBKp58nWHWQgXux8Yr
zv>E%c8iS6OnwpyK?q?(#pBMOZ7JI+)t>8!Ofp708?1#nipmy`8$k{4=!xnMtVZ!AW
z_+AeMxy?x+W8|(oXwf=DEnmWUB%MR@dFTjDs!y~r00`gr$%50;(r6wM5=;VSJ4oIb
z?Y6&%*=9p6>KBI7s#@N!3IzW2+3=tKG8$uQoD2bBMEpEn?La7KXgJ@5pXFHBwbL|4
z@rvA#ULu)R%8tmOo&vKE<~cLRs{|t{$E=c3qe?a}7%oI1_v?!PN|Hjt&u2ByfxJ<~
zf{w85tSKXYl3kYiymbzpQ_D-#a!NU{vKnmlD?Oi|Oe`uJ>YdT-!Y}k5YL%SvV+^lC
zL=0g<EZyKdV~Med6~R7@&Qdb4WfN9&91vC{H9Bj9Z*Ba3yn^ZL>iXu9WLkl@gs$P6
zTT|msFkL0{PU3_qFnF-x(DPvKpDmvy@#`@>JhJ5`*A#1mfX|;4Gc|Yx5q?~BB^Aq$
z<%#>9Z7_JRdfv2q9?aL7jtfifl@KI|I7}@yJ324ZM_FAxs;9aZb8IRDov5`I8KbtK
zl|}Wt49OJRd}(Yy^1ukvn$;zGqAI_E(fAM<-|P}Ufr@V_m+A6>8rpek9+WZ#h3u&^
zI8zIu=UAZmu@GKJ;Kw=5v*C~^e|vah5)h{Sm=`tJh-psI_}E9|S&T2%rvIDEgTCJw
znd`n|%l4Z^zG=zfmksm5c?Nt;IT2rG<LAO3s2W$-iRG%AO~{ux%^+t;F&3rbv{G2m
zz-GM_&z_I~g7m!FOJn}iI;y141r+bKTieR2_sjOw$eWtl%4lIVclV3PD++j3*aZ(E
zXFi>Ug@5z>jvrP}j-mY)&PPY^Ew5=nz|%KZOW0U$hsWO3$;%&w-wpUtCDsOmZ`q0c
zJkK`PpRVKC);+hgZ1d_JW-EKvf?k^Eji~&qL*3n+;AzrWIh{RAz?l`$dA;QLaC6c~
z#Y7y#@$Pc?B+&a8Jo&lK8Q9huwVl`9tOp(O&!?u9l36xvF#FEPv1n)S%WQ}geyxR^
zZ;?z8&?Cx-zd+T#OS^@XcLSPM323p~pnax<_NZ|w3BiB;I6A}vq?n$+j5E>ddY51z
zDe>vjq^G-_75rEe59kJ|Mk4O9?z+SzM?tT@Oi*m|lN9`_QhG%#qSht@*o*78DPw-e
zcEg*VDE_AY4k0*LXtAXWZamBHJ2-CJ$A3uEy<ct_ZRsb@{-Qy6M~)V3Q0;oMW~?qb
zeIYZ_Qe9h#y!a+c)4u{4V6}X`qxw1MwwH!qK;Zp)HxdxuHVA~}dW+wzTr9V`G&+4I
z37Uf>qp(ZZTCi$osbu(d3%Z{_dQ>_sk6BB2_ipADI%&%wHi54aBSCC5<tj!q-1Qz!
zAaInBGIiA+Q(}oASe1X0(<<7b=(4d=x*|!r+#~q}0VJfDVN|F@9$6d6pR{vSQcu8a
zU9#H%R94T&ru}Fi@<pMO&jdefJ)6Gx4kOl!#EXG#SS|mlBsTB}3~COxc!efcL67fN
zfsqBQ@2-_dQ{$(yTj~jtY*164yy(2YZ&xueu#}bcQ~0&OZRx!1u+q_5TH4=I9UVPv
z#cFTBo-raQz<1w$B7}qBTdS{asBNMbk9B_c6YiDT6*JJkz3AnIh4sb7NNE1Y38dWg
z)CutKTe-KLZ4S`&4n%exQ5|8C!NhXa=I7_}zCS-b7`}TKdX(%wCXD;u$<A&Nb`IYH
z%k@PL48+IdL_%h8)ut=VPToOH<ld9YQF@4ZAfb&8B00ozXoYC#1VAbsVk~goPDbvD
z^O7pFtD0DX2Uz5S;tRS?Filv0XOLm-((Ln9^~pJ*FWK_8<*-_RklJ@rUP`+!&A6{X
z@Q7xLL4)LU<mro1kF>ClXvK2uuPs@IA%PF;2Xfa>*!~LDa7UWO6F0IiW2~LHuV0A4
zL4uJfV>Co7c$dU;HhjObo^8H+YNcHgPnl;#CbVVlsgykYNeF4E@9m-zXzD^4u9(oJ
z;-6oo>4%yev81*~IO<6%)a(;u2ltWTxV?%a$3cAJ4bZt@WDVQP*-;dAeS`mcZ)+cI
z4c~;`G`kL&Pv%3m00&M^no#i0L@-TEadh(7_e%;Ju$z92n5ns?tS=H#fbr^8bg1E<
zoaJ<9QB>`Bz)6m8c_+g0mIitf8MxgRE`|b3$G+6C900qO+V8!6{I!4#Tq!IAF}$0A
z9t~!I)bA+n7z6+!F~+O)8_Rmq#<!<iZ`lV(F`<9_x(z=d{HUi|ZV^$4287?qgt$xk
z=+sdtOC&*cOkaGvt!(rCholVi52nq{I?95*ZXKo4<rm!<DzOQ&?@QQK(j<)tNnT;A
zJC-!hxfIKl+EtniD=-;VliNZql|3BNU`pX{42Fo=FCS{BM8u->rRR!+`Ib<@xtjS7
zR9J=_p(bgb_f5$zsrMqn4zIZ@)Q-m@v1?DR<F4;*3Y6XgLvg3o%WJ7SDhFwsl((3=
z(89RVvicHqyJdRpKLyeu5MrzIIvX=J^Cz#R&Lb<-!~^jJE{V6_73_C!Og(O_fF_og
zl*_#U_WO)VBR}|?ljHfz-7^~A8~##dCc}?%#Q*prGyIN6)wCI8D}HGfLLPQ#i<OT&
ziZ8_)i=Q>i^_3`Fi76_Eo;W<wA(1|f%|dxJ$H8@gT)Gb#Ral#@Z}aSX(ZQluDl{i^
zQ;PjIQHwrH>ic(v5z?4`3xKg{Oi|dAQdoxtFzn5zH<s*aDhM*Ch0s4YZ^h=Gnyh%x
z(Q>@^I1!gysFp)&HwMNI^>Bg-Pkb#|(UB>IPNCMNA77=vv%$ysC_1E@?zTCh5+~tf
zgt>`f{iHSX`1Xz+{DVw!U!z1-I_r#@AEw<$SN_g|&=KIvhN{WR4w)?$E2_F=Pic};
z3*snu%+S|+j^Q(0@KbCmphuaAasZ1+7GI`v-V^NCh?e7!CP&|Yy$oDEeqWG`qsp>7
zMs@U_;<bLTTU7AZ8jY-!74_1RBbI|%Pl^yB`$h6Xued*+nht1Jb?onD%YGNk?qMvf
zwtndlLeLRDIBzD2@ZS1d)zCy<M8a;5fsP?!Uev^n>_;Nvz^GNV6sJ*7gQu&GDSp7_
znPcPDIq-f`pS6G{-n?`eZJQ0>?r{QJs_h1H`!)08bsLtlo-^%27UZ1`OP$`7E7s7s
z;c%!H6)G^?8J%9C!LCrTnYo-thyfc*mI4bp?4&fvsWFfX+QA_9bixSGu^Z=53#Y3P
z0;9H7wmQqxi85aXzQg@67L&j7)TAbh*ZZs#aM#IZTmCB!_|#Xhc?ODG!>2bc{5_JK
z5xjqh*F}UE@-`lH559bp8;w5WIH1SwQGmyq!HHU)tra{FPryQ?*Pwk+63i+dRY(r#
z|01_*kD)s!QBgSwf)-UpAgA7PUxj@y=LY5aQ%)ktR+OjpFpo%RGE|;VsV1#!nEYiZ
zQ@3xnFI=<LBC?ap)a0n}N}td$C}h;vKJPUIQ3E*aS$WW8B~@tfkb`ylRJva9crfwz
z*TYD>{SeS*!b<4ZX#ZjqjUjE5T>8pr(zKW@F#G5T^(IO|9#lY0FvEnia7tZ<62RG#
zBBZcAvV5LCvQaueMo|QR|LN^6ziDbLSF8regglW#yF`KbjL<45xv~T8QL#%1LD?7_
zaa;=Y#Q$mR=5^Gr`Qrj{Uv5k)iL)vGBi&g9p*$IWb$9Y%$uG}PNzcz*qym7#zO(}L
z82c(hLyW&!Ci97TI$F044#Vtn_}Jq1ao?jghBN8*EA5$OOXWoduL<S2qw6LYy=88t
z6{E`!rf8nay8EK!u_rkQ&xG*>jwLaZ-aZkF6QyZsi#a6^=?kUoYD8YHQS0h6^9S2u
z5XSBB$Y`eSISv<$g@AO36hyf9@h<-4Z=oQ{72+zA2}Q45Wqmu`s%VoU-`w+yE@oz@
z0_kGDH!rnU7XA=iJK6SD(MnOJG+fol{d2*tc6u4%9tb(ji!mzIW|_u})WwnUCHeYR
zIq#Kx(8xqE%6l%&uG*wq1zS3e2cz)Pa}<Y|qu>wmV+TsFee6-+ZEJ83gQZT`H4$U>
z3H6xmMKu~EY1wA;9a9wzk%Zv*lcvp&O+c5U)EHKn67$o=HQfq(J1SRj3A4FZ5r}Jl
z{cC*?LDIUAhNk~hhf>QQzMF6O_yI~^=&nzWNT1Y;L`La|zfWB7VlN$}mc6EuNWx0E
zvONzIfrY$d9cp>^v-S(Td-!pm92g%v)3O7srInKmz`@>>(}f}hK1TC-v)YGdj~D*P
zV!!Ow*&V-<^#{kK?t(u}55~;D`xRGu(j7H?MEDdMVxb>^_Z>P9-lm_S*0Rsj9@2Pd
zE5oX1sdC{8Pv&!|n50GD111(p;xmzdjkm-7c1{CypkYNaX<SlFVc?raK@EH6`;f3d
zu7TV3+NJ=Mi;_}#&h%9}d+JZz+l!5f>l95}K3crVDF~mBjUfmrOo_b4rpX;(X<DQy
zmpdc%s`itVE7r_1e=mEo4FgiLh@b|Rde}=ef<L2!zgYwdM}~AhLs7fmgA2)?ATRk$
zoHlGl@=r^M#MLFo_rUu!C3izGkMeyZLfUWTxBKiUE`_cI`DA;i+6_e9!Dois?kI`x
zg__h#%Qwh$e=Ad%ym)gDC8F$eB>%vTbL_SX1$SW;i&>eK4c*__QKB(Y#5S6_f^I&X
zBJF9L0XAix$e3_eC}mH`XFgb$9Lqg{JcHaglyLBI>Ki7K*eRic>4&mW9!^xiY1i*5
zSoL=DZ<7VSL#N4@r?3er{sikWU)qw&3Iit8{!SZ(KG*5wn{XicDd|<lBNRH@8=eB$
z?a<L}7}$5eGfH9av)W0ZqI&osWsaAU?G{U4!{ocX6DuK+I~+nlwpU?)pu$b#lZ5#a
zW>5Z?!CVGGdNRkkrO)EX%2bN>&g9D9-2U8?Q<5_qn<5=|X$RhyG^t!ZBkR)N>DdSG
za{Wn0tNcS}SB1%LA5ZG)l9)3<pG%9%>aEXLjNq#lM5ugrf^=N?9g0~p9-j1GI_?ve
z*8pmI>K9Q6zA<~|{aux8Y>2AitiAkPkhpdzAGS%B<2YLdjfGHoNHYYPth1{joS6YT
z+@244&*sw|H;;pTz>w~-raiyLD+M>(U%_bld;H;HAMYuFSk<Vm1?ScGS?>HAoK$aD
z3x{&E#fr(se<W|UHRU`^WtyYyQ*S>_;kG#?`#5Q;ieiWcVmkykS(W)ndfx=r&YP9>
zY|vF=?Y&T-mbjrjJU#v>Kc?v1rcU%EL!@X9cY2x1;neKWFkGtsq>>GyVZ`d<+22UM
zjG=hKOMkW!#F~kM>a6g5b&`Y}^`UH8JWc1GH#~pS=dvgQ+bbEa=hmDo?%7h*{FozU
zp9;oN9CDFl2*JS>^+JOvJaq%;^TPQkl%w+me7LtZ#O*bDg+3uI)BKFyPY!b{T&J1h
zYeG>hf1p92$OiwCc2=Jq*PoCARp2Z}<4*Zq^*;MRjcz}6qW1nR-o7-Xp>gXb7xO)V
z72jJX;>Pjxh2$+2RK^$H(53>PCyg!<axl@$`DjNmmDUhGF;clnrF#Ok<+sBMn7PxX
zRe2}IBgxBCg*AT;1!v5%YKto2IN+{@bTqBxK?Joly94b5>!x^qrRE3FAK51ls9eo!
z!Z5Q%;svAM{LKE#_;gr}|B*EHYwuoAQu&MReKJ)q9}qW5Qfz<2A{7@=bAcTkvXPv!
z#j<fDkydN8pRa1@=7uUS)~;ExMGkt;k_Y{=Gw<(%p8t^im0rH2<e4!dl+tg=28`HX
zx9^<GoWIqW`gFIWHza~xjHRfE+Ll}h?b941DIMn&9x~`jqL4G-&vnU6n-hWFi(BI<
z7OszFCx50(Yl%|0-~TYQ{wA$n93koSM}VY?IykxN;q?N8sW7QJX=u0BaA^3CVlKJ6
zaRh^okPQs-2@2GW*S(*<Gp0(Ke|45&o<)Ir#KiMZ4RfM0)8G#=vI|RGr`MwwAIA{N
zp*$3;DL0}kPe71713-xB1@S2U<w&|)uiKosoMg6rE}OOOKd0_&u)gs9aY!kW^#9uP
z$>67Ve;V>3uHznCbVvg_T{L-Ylf#o_HBO6a`OEK+pM?$R=0GPIa3bkvr|<m>|DuH7
zzyJ9V%EkV1f|hUY|Im<zSd&`vWc1u%D;L+w|4@XaogBenEN(H#!Za-yU}xvVPUsd(
z7B=ypOa6hP(i3B}fh~Mg`Ps%WkL-c?fSK9ZyKXifn*Sn$Sn<pSCnU*3giIzz$_s+l
zO>lK#FyYx5^dEQ?POsuX2ir&zenBrbj(GyGW!7(^{0Zp(1159%I0n1tyN7bI)zwMc
zsr(=GwG{~D{(8ZO_49{pzC8bGu6kGyGE!=jthf%}0s5HlZrYE*FvIpb={{K=Dm(@<
zOE4H5TR#!?pZRvKa)D9k@J@CI5de6!h<J-F*npf1A2A%joj)}m)h}U{-HnI9LJc$&
zN&uck{ae?US)(_<{;9b0{=p}~^mv(}ITx~1)%+PF2I<>EUg{}{(1yio=VfT-sLkft
zH+zudzZftVA^cwbn^CTt1BS%1VEV7lRrRhXhl`C03Di$zl21|4+V1=Pot+&8ngG5e
z2<5pD9ZW1`Xl8!?2A$w|rH$?LsF%E92V!vRiW|IH_xT@o0j?Vw`}}>?^RP;Vjg1ZG
zb-2^Vx9#oxE`XD89Z^K20p3M9q5fzVm_Q}!wcZ`j+}x~he09A3@{B9$ee6LAJ4GM*
z544IUj<QN?6>HtNIF!Qla`N&F${5*!3xlkjoPN87pKgwp1<il@0RH5RXYu-tAB*FP
zU*3G5*eC13z^D2YOCMVwA0HoqNwVg(JWozR5wMO6XI){YPy6$0KAUlHekg#Oo-*js
zf4K!SLdMtkuE}1TAj;=WM#tm%i0$v3=ckjW?-xeFbi-6~ef|<bN6qu`G?LG~G|zTs
zxI6<(%gYI($KOu;Vassom<i#-{pB9K5hbeK`e{fx=SFoM`^~ONXfH?O{J-{EAW8a&
zMu!LZFxI$uSQqs4Iq2nKU0Tc9&(BZb^Ak++Wr+0RpKdY9icG8X)Y_UfIMzH-+hO?{
zNI?ho_#-ua(|r>L7pVs<>i--)Tpz(7{SUjS&_RlkZMQpri6jWSVaucB%SDe{8zr8u
zj!rBUuR#7d?Bb4YWE_jV6)r`d&l$Sp!j;&K{uu2F9gUUSc<&rIKe04hHQz@Nl@M^a
zNkv5^JzRUx9w9@=%n9x@vp1UGTuJD+fCChPZ!!}4b7*ri$6-m_zgm9$JF!25zy9PO
zipGgq#U8=?L~x2JBu$H%a17oz(kzx=^@Zh5yw;Her&}9)Oh#PnjK=imP>Fg!KNWuR
zJ`w@l#m!7ie1)@5a1-`0M?ai;%kFj7Pcoh>+S=811aFRS<`|}Lw;#i8XiW0u@t-H?
z4vRPacADxT;trRV8`ux(g1UnCrb>sb+`byN0h2a`;QYdBtIJ76Szd$BnFZif%w=mZ
z39dMQgXQ^!X&hN+7~lVre6}CY6OWKFhfAF#CO*;u0pc+K$s##*$tM+o&*CSY7X$HB
z4{%?ofTP|^P4<H8{?ku4FGqK<e09bY!L{3GB-CtbpFbh*UoZZ5E&4S)iKT<T?^|Le
zaof0#F{w-Jf7{%-YGMmLoq1ThS)*|2G>5y)KO#s|g?7*VtRb9m5*w$uSGVxMCdDJO
z#KJS44}iCR1A4Jf4BH&G;T`TbZCgd?1Wey*M}+IDszf(qr`cGCTj5BI>*kmE_-i<u
zut5Wd!{9ydPmDjwNW<a&SH}_HJeDJ@t2^6$(orkwvL*&FYQN+k^Ho*7g7-WPOic1d
zZJ5+@e3qR}Da1csZuBd|`{*ApMg`$c9I@!sQqy(Rd9emZO+x*~g<)`+P&mt7scahF
z56s(Kxbx5BzVOBWUjPkzO)Z=Ka1(;t`C@$1KGi@9c!r|}F820&gI*p%)OciY8=Wpw
z7d@!vmAq*ihYPD0@kftOC%7;7^F8mrozD2dK_lj{aB!*$qr_Fk%P{O>aKb{*&+h@Q
z9=5f&?-a$ndE8SE3S1AkF-UI?e7awDc|pfh0FS#HzRSjQy*XYrY;mIEw&;U{1gYaB
z_)*`i4P<%GzcW5Q^d{u^&KW3B@!Owm^uv|AaDw=CxY`YGkrPCPAGC9DaCDy#{Fv1@
zot>DtO-k^ex#*0KKinBLeBZXc6ZCwM?^5kk+*ND|H=(#VKiKcAi`&hFIBN0shK8c<
zZi)PHPJ@OSS4sk^e{+Qordc_b3?krdgVkQ8Zk0v75dGm=*K$jO<zTzyVKAWkL_Ld#
zKX)t#K5h7dQq%9awW%=j+WaO3htnM{koB>`HMj`l4lmJo?BG1uj{DtWqpe@w&Heed
zuC8v2v&+I)^Mg6(mLp_-pI8Hc*>cOKP^>v?8b<deSE`p2J2B?(9!$>8KX5RIRQ%)b
z*eu@Xlb681?Ivc?hUxvnoSd9Ayf#fI7vugrJxH?kU%q^4XmESHJ*(^Kwt&UwUckoJ
zTLK=SNw1G@S5Mx5`x^;o5?QprPzrr8gYzD%!cG4n_!amf`DAW~+3F;oZ#OG+FaToX
ztw$!VyogeL9wOVmCf*dkJw%><VscU@m!}@IkBi?t4yUmpJupGfOQ-kzB~ZmB<nu?Y
z$qpRPU%im=!6-LW^anCwzT-WoKjTh%%x_QsGUafsb9{?=?qbeT*}Awp{wo|0j~B4*
z&;&MkFicNRhc9DUTiei07l&bsN|xK@p#ksm@>2SnfFn4v0!wAlW>n2?f}dja#unp0
z??|nYlOl$l7HlV~FtV|-CJ%uCO)V|g+^oQ0_oXgBLD=(n&~r>=r1+54)J?$pjdq0x
zkMPVo6IT2CFIpAfMX-OSiFzHDS68cm@ZtKYYYzMoIxTz{zX&^FyGDks+&s}e+n{)O
zZX0wvwH>s>W6zj<S$?<A*+xrC%X<on_HMbPaS{RNrN^{7fBuvqS__R*0|NtlgSl*e
z#{|*$Yj8hp3wZbkOoA&7ZhwDjAM888Gp*)GL+rx8r9&q_7qY4~&cH9|;0>J3hIKBe
zY=EP{kImL26cjgsd&;Jn+?Mj5o>vR?mhjbI8A?fTGxmncI>TS8DTB`&K88pB8Pj{0
zJENalofbd#V$aXd&A}%*QunPBj;|gVM&t_Kcdt)QY8wADu*F}vKxhr}f-Y+fZrhbr
zb=?kIP`nsoj`M(?4s4avtY1z7H@5`paL3C!@g4W<jl{01smXQ!odb8zg_a{)B7rm|
z8t;`(eN$t~n0~!lBYw+)*!K2&YzhIaCnl-?yv2rsE}O~|jV7HjwkFAQ*q{X@gOgdS
zOH=3YRJ=Q#|2*T}eQ|_@iUV&->abqH4|qJ?U&U`?kr_jo)06_vQ}WTUH0i&xAI$eW
zj}oYhox%0hd$_iALi4oyY0=2**EJP|;QK?2ZaT|Yw2iY{IGo@=w`luM+2G!`Li2q3
zE5kHUI86!LV3msgzWe4B9!>(T4cPQL&z2lVHqLxbCw&25+2#LP@xMKiS|)m4|HM$Q
zMe7Ke!pceqxSPTkJ!ex0ZYpph^PlSF>1v)g>o<I<#m5hJcNf~+%c6k)7CxQU!4)dj
zJjTa&Yq3KY(-jS0(mlZ@<6ljJOoQQB7+$L62)pamnXFDs0R8b-FFN6>d3st#jZeTU
zywObV*ZJdh#vN~n-QC*!4Ge5{ev`o?hO@IXg@6-Wiy&<fGE5XRFg2BQ-@zInrN?YA
z!CQo9q<VLl8hvFQjez@3tiQwyTys~=;wi1EafUM@ujOMi#eC1tw?`TmamFt`!JkpU
z{iTOUv(w@^Jm2G<c@u_t6=M?TeDyx*CSub=)(z@DnV*?a`7Ce+#}J#En-M|{KfqIs
zko^>RpnA2#yUw&n;#RE-=F4k4_S=dFuC$#6tT$8(yYKkGW84ATgulzr|E1JF5JY_6
zp)IJ#$G&~fI)T<><-X+K4T%Lco-YLy;Rr%7c<n<R<M}HC2xpyzVP`&+0E`GkdK52A
zdbct6HZhol<!{%V?~#;Bx7{>NW_$Mi{hMb6j^!|4_=(IsSnTC**>`+R3N;`geCR>|
zHVh6{W7YF7#5oB#8t9Gh|1hJ2lhu}30ARfa^S4@MaEtRVi~8@U@_olYPzB)?DHx4-
z<bVI|_dkOnziBDyWn;MEc(b3^Te{Hik7)QTNXo?>!nPCdn+}x7KRUABdVuq3Dlk`r
zwsV+LhVmp)ruTeD>BxeDCHVf~^QZPayw4ppJ}js{Qdh~s3rjyw0BxEQ$_4+q)&Gk4
z)ASz`a%<7fQ4++^^ZUZ^mFR=J`Md$$x;i^b5mAklopaagyVcCle`B?aIF~Hq|8h1G
zQdlcftn`214m>4By?T`L$0aO{#Ye!)R7?K%Toe=+?91|32bTL+{Ad?%T;F5K{GTf!
z0taC$QJ-!E_Z)#OZLSH+s6G4&s5H}e`Qpy~c`u4`12(5ITiJQIW!=R%LCX0|H<X!U
zamm~_cY@*A-M2)vfmB!BLYH^_(|Ds$<W1?gq2vMUg8EdT{KdrIr~$=F{{1`3+(K5<
zICHGm8^q{UBa7<Y_aL*+6GSAVrEg85g&Px)Ba)MT?l98{m474Dr4O@MoGeUcR1dv1
zCS-Ih$M>Bw(-G!{3{c)rS-g?Mo<!=3K&odRA|ioUYYbHt$)TpXrJHh2h7U*RwTmh~
z*e5a8&d?Q%x)f}<Q^}`&$PPEB9X6LrA*Usxd>S?WB)px>Mki#KVER+8pldzJCqJzk
z)83Ab+1>=dQhrL3uthgyKnC)~h#igA#1&o9^SP#tgn6j+#XpfcCAAfD{R_fmm3X{a
zz9a#%l_4zW-$tj=u_dK?RaI;PF&vFf6)VS~D72g?5eTno4o1hD+%!oxB=!1m=m<O?
z`#|rtwk}SCKgg@7C?z+a=uk$tCziGubty90Q?C%u5tY%lFfc)hMZA5QoLWL}aZUHl
zs-a|xP^q0o0kXk?Oy2;6*n%u@laGm$dy34w@ISqZ8Va523B8OfbeCp{(oiazSe8~H
z_BAw`DwYCuBi6gdX!>Xs#e=FDU{?5bj1U85nV@7PyE9GspP#Z<BBrc$D{&Zj6MX~`
z<JP%jBi&w=>X?dTgFH?^-2ITR^hue-{PLl!!c!{>_Yee!LH0dtL)(j4Iw5F=)F-+$
zqZ&dJtx45q`c!IMsb&JjRIL3y!%}v~W5h!31K~`G97f;NFHWJ6)YGPR41RXU^KM!x
z1OD5b3}@}o-zawg&@aiE*BxW%2Gio8d3)fQRTbwI{kanTo8iW$v3*NPCv0Fj+O{lL
zkrxM?y2CGI#!QXa4LR0NZuzACzR&U`sNnY3aSdjF)AypF@L{Q4esNQBk<1Bci%F!4
zo8suUo^f{YIBqFXWE>C~7rYk@B@RX2L3XHa*t(+?FSyLgh6<GnzDkVD+iJ(U6yw(L
zNYtt=&iROMoG@hovC>cru`nU3fmc{=<Vu;S{gqODn1nH5T57VsVI{9oiLf;-kF!Bj
zzOSSD^%Tk?-lfs%l@tbP4WM7m;y{Qp>@Y#I3t-CfnYa>H!gMH?yjW96Ca$#Q6+>7d
zJ=tVX^%%K*CGEELIY;%ax6T>Xz9Ml&Q(U}2$}Teg2Z@R`=oF9u<65;eReFJuV!u)2
zxL*XOLxraiZv=}i>GdnXH&lI+McgUjI^S1jgBsxV;-r8U#x&aJ%@(c#Z0Lk7hTzcq
z5sp$Wqae1_$M-BDdH9@?#JOwSu@VIe1i*uKd^M5)NHi;V!o44^R)L4SX16TF828|A
zvE8CbIdE??R%d`XdbSiypgEZa!odrdzXl)s;{+SO=u<xu`gT0T#_8Obk4u*S0^G0s
zEM+kSoyIV)#|H-o^r*jGx|9EjPWz?MPBZllSt5^Oi65Pkm>yXQi`oS1T;~0xGLR`)
zF_OG}F<gSIWD@@_Rg-l@i6Q1=)+?n^?MK|$F(QTz4rNBX{fLPx-`9K@bbQfJIT;d`
z%Gc(W)_g>zbfUSl(m&iate+!rOn8ezr-&x!Lo`D)(@|dG@kR|oLVt^hvA;7NHT%M>
z!HH`YZNblM!$rk1ja3(ME*!0ZxiPOeW47BNV~;k)oIdvEi#p#7DUnhHd2xw;K}#Re
zx^C#i(6oE%JLS8MsR)q%QnrB_(At{-JCi=!LF5px(iZfF;)w|SW2%_-N<L*;CP5`>
zidgDox9EjWb(J}?MsD~|KD7IU==|0C1@0ZwJT?j*TDo=r2KR`Uh~d~ilTjg`6rL{2
zfhlLJ3E#G~WK6YHYdZ6Gbpp5gM=gU+hTW3B0-vV-4r6p!PqHW3u5QcaqS>YTW3n#F
zp72{HbZwJNuqLFW7eZ<+IXwhJ2=O-Zy)1-Y*GMGEddB#_j@{x)UQSeEdskt;#s8|X
zxfu8qTlG4vFtQ4y9LLAZSg~2eMH2P};=m|*@Qn`S#ST5#*s8{~VAP=|OS>CLx(u5-
zK?%(Yy&f`AP@_8xDbIKl!}?H(jLV`lWP&Kmiq57v0@OT`&74VeFnH}dkmgv{+eM#I
zZ<C~^(-0<qL<)7ZV^Q(hUcqEV)w8b^PgUZx6U~z{6xQIAU7FKJj_{Yr7`^Mp1wg;x
z?irFG=N+`Y63m125xC0j=c*0ruxR3QFtVi23TmfO5S7Q{i7;`MCRKOJG2x(e33@)s
z7RJ9zqT%6-Fe$rK)>3%meZ&@4<%T$1N2janz|0%`$6_dutfCmH+ySoPjTfOtCl4^d
zIGC55Wb8wy+;CJAI!Y`Q^6g6KPVSWeO(Q~bmVh7j34Alqa2L%SD`j#lb~0g%bEDMr
zH#~S(SCUHk6$FC}am=68?Be@20OlJ7(}&S~h+}TA4Bb}i!kMJmF^5-Gr&$wE1?+d3
z@dfuM>RZ!BS)|7K0Uzb@>`=?4D+yASq!djE2@F2@@`(#2DK&d4ZGsYH>`^Rs7c{D+
z?(;uJZZu*$FxiH@wcjOtBhNwf22p!=qgMR8`>K;4DvS~@j{lYz6_Fla^Udc`*g0xS
zyx;!=IYGw0a%Z2K2MCjG{k*2);vBgm0FBx?kV>rNE={$lU!6!Abv_i9^j}OR(l|Rp
z(K2D!(uC51iV9jJ^F>u95(?%BdXcMQ9a>z!K`Oq2qI)$5sa#)84lE&N1%iSQIdoi!
zBw##cDldf{xj>MoM^gS&dPzn6Prd)ADSb+Uhq9bbali6iBoJYp@t}5{5~<W0X>exf
zT^L3X9c}>)F((a`2w~I!Jqt}aM@bpH&g@7$PPuVNVLPdOv?U+7Lb)jFk&&boo1v!y
z30H%F6vZo|lN3h+KLu(GLo=0BR4f|0Wrs=%2rBv_L7z87o%~3=1f*)&AU~mLvTLz1
zk736-lu9M4ga|bfxJacNb*59Sl!^=1K*NLs!QeyF&PgRup^^o<y9v`$C<OUjo|`n$
zw;%HP9QS>N*+2rB6!C6x%ey}RlkbtC9$(PtXj=S6Ior$SwzN6{Qa!(qdt0Y{0)#0J
z2s^<SAKXK`xlma1Bob8ZN~lMIrN=NfkRWv7l!b^O$O;2-L2u|wL(S<>YfW>r?9;WY
zxLXy8>zqR^`A7|5<U!!lYHLA2tKx_2cteX{fe{B5dblBJV=&M=4Ujgi^qcR2K!Z_~
z(*tN9^d--fbQ{uN<xqtt@=WQkrgAW$V~~h;q{Ir;=%#}LC5hrjP$UT8X!cH%bm`L(
zIte{dTy#xhJD;Qv4DEKKqm(3^P^{8Hu(*9>U*c0JZtnroCl?PA#ht)V^`mHgHPt3a
z{Z>j@lY7Idh@UY^qdOEZlE|WlA}W#Crztt8$jwDbC!SD(qgc3f+=y~L)6f04-|Cbp
z-ba9dzUTX%ZvumFLl7s=b+IQCp;%d9nBtHpjp(?vi?7Fsx=iz>lGC0%??N;}iKmJ*
zh9?ipbYCOywFnwp0*ZHcxydJ5I}#TgNS>_keI(TpfdpnS3Fs^uiKt%%h4pQdCtHGs
zI}pVFj!^PK*f@(>G4w0~+RchV!zHPlMW`q#z0Ugm6^ogf#5SQw;Ydy}I?eqg0;S)W
zMDv+ZE0jPlPXY9F4(N4IfFf0fQho?!HWGM(<bf~E`g0v?v)H4gv*MCrkbtBTN}^af
zD8uqPf?T|~ptsE_MUn)u{bFw&hUqc=suL1Vv$zl-)DJ@1@$;SnC1UkHLPud|j1tN{
zL>HhmNG?ekRqp1Y+nmU!tdxjQ_5i_wL3DwrMFofjQ&Pns4`3+cd#GVUqPFjt#QSw5
zJ%-YC7l6qI)b(6WoD&Cww;zZ|*g!~Bn=5hE6#q`r#?vCE@28L`!*r3JDOVpl89S)q
zXX@i56L~{L2}_z;vN}Nzj1uY*Rf3gZiWENtH1b;eJX6k`%2X2+v#|~jOU?u!w&;`(
zSC*HM;5o|NPGy8jUoIqLBbAj%MG;gHXDY?E&pC{=wTj$25-pj0fk3bjlGTiq)KomG
zVpCZ&6-~eDRT;KYs!dHO{Wx-cq8X(`je|Rgk9zX1HmLnH5+odITD<y2eZ|^R9w?(I
z4jm9wFhZDtgsOEUl^j7)XAxxuU8uEFLcKTijz&_HyW~n(!hxhghtRu7&(~J04N&?c
zhVd|JOhGeZESkQKmLOHqxX9R+)UV3tMXLN>$%@Ne1}LufkI2AGr~!3Gb2uSV0MkS}
z^+A0^f~4+7l6rhWDzQ4j_ega?ByO1qV#jT$F4L4u{oHg>83sr*okC04CAqSaE&@u?
z);Sr6{#BWPCkoj~dbAYpG0I?6R1*a>f{MzGkW`EfQH~cR&M6W#bOC7`Qm6J(vNWWM
z?SP=NLem8hTCvtAxmS`RuG8E?A_AyqBBI_=9#n*q%bnc7(CqK3GXNB*YmyF0nRZpI
z4^bmASjRs_8jd^?-zBlobc|Sec7~j!pbBcq<Kd!uFny~V^sdA(v69?KDtC!IU?r(>
zE$!rq8a8tuE|qwtqYgu7OGQBijk4ZMv#MVwBUh4Fk41@^Al?d#$5!l!)M;s>WKPW+
zQB_75S~wHhqz%FjlbQ*op^GSKg;mV+r0UV2B#XZHrwdH>#3RaR;+*S$3?tIThY1kT
zvaCaC$`<DjXdZcWjwAZ1JD_b}fmA%?qNQwE7Rf8GjHZSv1<}bq)QhHh8qhCS&@4`n
zl*dT4ihhGZk!n*W8|(NKBB@spKb%x8izJ2bN<PFWCz4RhS!ZJ?AzCg{4j|2*6?v32
zv$B;b*`POBlFF>Ir;DTss_2NXS+q>5)()Vjc;!~2X4}BfA(4t*K|}OH89=iOk<yW;
z!w)FUK0tvU?sLWs^*KiB0xB`{LX!{Wm2!QqEG^tkg3z2!H3WqDfJm$^M1m>VR+MqG
z(147lRZLP9ff_6=;Wwq9QK@4|MOFQsqL`EWP*0-PMBJ<F#VX=t=$%)o4DW+<X-MGi
ziPW@-1pimAh;%yAQCJeGNYA6HJBDT$P;WzLeP?&XHjZ%|+qNz3iyh0dj-c5gqUU)B
z4m7#0cW7)v3R7x=U4b|!PHMhHX-$;eDnO0w0+8Adk@6&?meT2n5=pyYqoAD{2&{3<
zs0Br-!;BP6>oX})gFBr*8Tvahs@6rbtz`-2;1Yt!vr0&1q)Cobl5#|ejVcj9k)&wu
zoqf)Tp;bEAJH993BGj`+LY*~o6EW&}i==T6xt0hG;(>G#Ny`8F&00%v9B7KXyn{%|
zr<2ekrKmHK*GEY>AyQ77h%HH+6o+E2#xQwDflH-WZ=kC4XQWI;9c4lqHSM7ZIH<Au
zp}eQFcWbJ|61;~bbs0dveNv)fXm*NHzBj66DAF(_V0bL4g)fNrK2oK9qSz%3s%l2i
zOA?8sMWg14fVe##N?AgbL52b^gS?Nc6ihK_&|tovk7LZTEX%SO>wI$0e+PfX-d9={
z>$Y%M7lKDXS6HlPWUSXUUBA1Y_l>W9=6&yZSD{b{K8#^mtj~?X(|q60WYRzS-d8U;
z@2rlFY%JzjjLD~fVLx_HE%*~tKBQ|RJ?Cp#7Gv1+g3u=i*5Jqy!*2P&bz{ej<ec|;
zomArwj`b+5&rYV&iByt;Kcj{gmTyQB@y00bVPzCZ-gOXF4nm!BIDMBb>AhFqPytnK
zy;6swc&jKL3~A_S5HynvZAPl!4uk}`vQYyI7#5W+EqzGeAQ7>aD7ObR<V&=s`duiM
z`B$2jsxqvNVVOUod_NLsB>AkB;e|*-A-a+@o=|K@>BJmRr2%w00O>SI)-UQVek^HA
zJqU7NMb;E*q~2-rf2bZn@qtWdtx2OIR1^o(Uslr2;2>3YpS;73er6g9W+AF>lBB{y
z#C}C6_K1n(1vUEONTOuW+YhUZnxaav6n88G6$8k55>?fzkt!D?D<!$5m=jRN>Y5&Q
zQN^j~N@W=Zh~t*UD<!GyjZ{wy+9k@N3!z`TsJ+~_mbB}gfe^91y`zxN13@eiPp6VT
z=Leda9otT&k^qp+=5o1QSy=`VTU*;a*99VG+nG$7F-Amf?d=FiL~cHBIZjzwCYR6W
z+OxngolZNBO+;;N?ZNBZd>$<;ok`o4MV!w+?id2_ea;xVuGie$PQDM!%4AZuZFeV#
z5|LxuCoVYd%~fmN)_r?Dk1>``r@B6`h^?({Ucm)~cp{NZCWy%M{f^c)?)yMs$DH6|
z-}hTv+Z@MnU6*^F9gC&YselMX)Y97K7hFKFV@@iWWQ_T~-`w0nzK@ob$)qjIBBJKz
z7RPZCi8ufh3T`%+%cN6?*xcM=+qUa@+;#0(tgI}P&lhTIYrgTd&s}--O{<nIO;y*&
zVlidbD-n_JGt2H?LgF0y^Cij9pd9sm>Gaui-9lmMD=)=jaguWnin|8ucPs?GPA8!S
zc#=kKqG6yk3zWhX2Wod=(cJLlxp^oU52^g7C~ZJO(s^N&U0lA4h;EeEQ^|<~s@#3h
z=<Xwro5^#8qDq<0o}^z!AN5=t%GIEnAWFM96l)KXu2*RT*5}D$4u>dIEv8Z^x#T8_
zC~-@N&iY)6dKRGQM%1g!EWTK-Gj#-n1do;2qJ5YU1wkzmD^*R6E$>$$@q_3mr^v~U
zVRENbkIIb+1#gKeUl=AADDEl=(i{O4Ph2imlH7!1U8-!*ReTposU*ocM5!f!B`H7@
zIAuso965{XyjLe$7^?6!eUv(oG!d06bNz0AAkC>(QcUxR0#fp#wr^UqscCQ6>Pt}T
zaYW>L-nr+TcJhhy5%KvK{{7e!&sA4fe)xmeuV26Ek$*hFn04}r$1Obd#6SG`-u?TV
zuDI;{*|Vm_<MB<Kw%z~Wqit>Nobz{Geqo{DdY*sU!Ub=<vHH%xJTQ08jEgQfH=ir~
z<-P|uZ`qbe#IL>jGT-ytIyx4fa>9-syYGMC(T2voh}hnd&E*P=VLo4|sj2?J4cCkw
zJ)&{%{(JBH`_5f^5{dXhn-HM2wJqj2*WPgb3G?T^{>G{Y|NgH+!6gFD{VOlOVD2%q
zJkNjXnHOIE_Y%vtYO1TQyZZ786UH*emMwqdp@$y>fa>b158v{>6>qGbFn;XBiDO@1
zvFf3RA0r~q^Bu>&?yAeCPd}P-zHIrMPd@!ZHk+-kuDbcgYe$Y8zJ158zufy!Q&USa
znfU03Zdkc`-SaOjVvJ3nHu>DMPy6GYf6ZodAN}wR>o;s3HDdU*sgqxSW7Xdt{6{*S
zy!4`XSeA9ujn`d#(K{Z0;<@Ku__y39B+jSLKBl9iWBuxtv3P=W9{}bazo2o??k$@(
zI*!w?DoPRy41sOi+~*2`360*!+dPKq5sYH#i8P~pKZ_Jz5N(GNqM`P2v(GQ0eN?CY
zny8OCgq^*VN>;K8O63@;4N>DXDWbXNzKa?SX-YG9bqp{GkAZeNtNgIrLnI>u^*Ypn
zV84`1lcbR=5U-u&yesd@AkhZO0q77)q7wDlMklseEdH9u0v(w`saY#gaiOapdcM?b
zrz~;Lfj}-KWLM4wrR|862z`jAr&6-kq@CRg;#_6YyHTPiHRD>KYIq2O`Zt}rk5Ic;
zGh8n(X)e|+k?Kbz$8;qxNdn;1+Xluc>=Y`4qW0jD?N3?4U4kIXrzs&dMm(fJQP_~A
zkJYJCQS!f%2}4;ZlAgpU=4(l2wjDltjHVM2u~2Y7@gFyR>OViY?DaP-#%_B5HUItj
z+wS<oJ$1F!pZdfH-+AG++ji{y$q#Q^vv$Mw?Ym~qnDXIUuJ7o`ws&+~c>X!Z&71Ry
zPu=Re-nnO=_Re$9ShIG0q2OM3_2tLRnK5qc=yWPIankrR&p7#-_kE<LrS*~v-*NhB
zC%wL6Wm8l0Raaho`e`TL^r25THMLlbSr&6$Z_Joczy0M8MvfT1;*C|8T=dS1&OiG-
zH+*dGz5`tqhR6_I*S+C=S8dv~C6~{?_qr>mO_}_a+rAF~U;NxBZoK~LWv{=PNvCdj
z@4G(wi7z~G-$R#O^v+vude7!9+bqkv`rVg|9yRiNKl;C;CQbO*M?cWf-mzonZpPTn
zH(pm!UiQmh|0$hLe)pSSy!e81mb|tinM}-@Ic?D^OOwgOpMH1y`0-<wEM0NsWfxp@
z{y8_?{K?kV)(?O1`n&$}z!OhAYuWacqbGg(lOKBM;m17ByXpPcCKHKm+jjuqP4B<9
zqP*<?{pL@O<1ofzF((m^Tb3oa<`B^*>gZ^nJO2dV_cpCtYdg-|`6rARJ$l2sHLRa`
zq($2KV8{^xI1mv4VRtAJp|hkABl=^Co9T&^8mWroMZPGdc}8Jz4}BG&G*>j;`8sJl
zB}cSSZ=aCVcj+JaNN?wmyTtSxk&#A1zmmy8+lEI$#+2wE%2e3m^&+X61kyi&;E(}f
z^*@@YYS8$Tem-ZUH3Dfi0qW)K$qhM-c-$fF$S{ga??R*Wa>GMsQ8Z(fpi-6cQ!fhA
z6!qhl65h~>&dGzQsNqb}jM#|c;hGLLiMB*l=t*t>D|HA)IWKD3HgeM|bVd>lBbt$N
zSwVY`Mm;%_3#?pY=;WkGeit#7W|)XnbCidjLuU;UGqF*?2Fm7P65UcfDa{rV)Q{L8
z2$B@!<<mNSXh3z1j+}~O-4TmiY?++soq!o**<5bs^eG>{<-NCl^?!bG`!50LvtRn}
zPki*INB{BUZQuU!yt%W#`Ss84+TD=P7e4-9w_299Y4f)0uK#EzljcOHoOJxxzx?Tw
zPCV|P4?oTrYiQi}p7(!z_wI(Tf91bF`LUaC{NShVyz{<`FFEg5|M$IFGp9ZI)bp<E
zc64-n@yp+N@x?`FoN>xMcm2QPk2~h?4?l*CA)xQNx7>JLWktopvo71QaYNPck&iuk
z_jT7?{_XGmw4%H$h>3CH@p!CZPs0a3^r<bIxBbUQZv4V$KmOyN{(9Qf$sc(CH8<Y!
zUyt1XcL4m!&;IA;8?SrfsplX5#}m)K@Nyy^=R~)B;JWLsx$KX3-j~befN1g3*FX8`
zuN-J<`o&Mbd-<j3-+ueAuDR;ccVBtY2S57RzdiVmR4Q3hQ?;j|@uv4*J8jzJi!QtV
zmBq_WK5_no_x<*&D=+%lFYf5*$QBAN00udz?QI>r3(Hrm`rt=D)7skh=R0n{;JmYb
z_KQ32zW2d*U2);<Kl|+qPd$;W8WxXB!-GVYWo=lqnm9k^xD$x;>e{+dW5+)G_`jMC
z9EcnqROvO(^L*bAtUuyJM4a<{J_i^WhhW(@LnhqGl!0=k<cr+fIw?uTPXKW<H=PK8
zrb8O_)By^L^))qx&Xy?(z?N_V&`i>kB>aGeHWckiI{9ysAC)$wa(C3RrFHy&AbpM|
z^)!2CXu1_8Oj}ySTeHFh1X2@e^F!59fV3N;=m=NTT2mdpp}ZILtT+%?a+Y?`1Pvdy
zq!WpbjzVpt1q8Q4#1mvFZBbPsh#F(o&rB0J5V1&VLIY?L6J04a7{<(!0K2kxg-#BI
z+?YgdjjE#uG_AW(0+P1RRH@rZCBJgw=%gv4)VP8$rK-t_py5!{cP`6ywJ6jaDNu}2
zvb0cpb63tfR1u--A*g4ihw7qIvmP{3Mm5OodES)C6U)jnGiOZs&JVufx!$Nz!|Q6R
zYiny(uUY@GPk!ld_x|>z6X#!h{YM)c_oY%v+p@m!*^i(1&NG{uT5`EuDw!NJdL;N>
zEatqnY{j-sTVtu@maW^jY}@hT%ddcCZQs7Lt*t$oOmNQQ@%ZxBS1x(&^@^&>#Y<PL
zUAy5O=bZlchyH~CoVXK@&zd!j6TjuA_hd4e{reAOGU;(+M*;LGog=U;>*;4-+P-~P
zDxH4fspmiQsgIm`^6{B;+G6aC(@t7=%7Q|^Fk-~;>C-0H*VQHx@o#<o^Rs47-M9Y$
zB2-kA*Hl;K^94j)^y<>4mKHacU$uJOw5gN9vKAbF?7H<E|M9P<;)ysBH8kvXJ%94#
ziEpl4yLid+s>+JROO~x%wQl_Qu?UD5n6Ur=M8Fse{>>O$^y<?6`wuY2R<GG`+QJ3#
zSS+ZttgNg^R@J9cNze0?>*mB_8`iF2mUYURXScSrJp0(cnwk!jk}N9G=7`+)>V^%k
zA2xz>9$cMFred-9oO#EypiK_Z_HA3*TU(GZMc^gm`Ksa*$=<A!mk8oi7Ev9x^6;nW
z$<w*4*a@x7bCAUSH1}+!dplAMiDb*sG_6si970F4D+#X5X4Lm7%Fk+`Q4FR@kP_|^
ziG%VvpnaSTE#rZrO<fdV0aYXuic+CK<&##jXy_bC+f34rQAp00I^hM>D8&htdQ{mk
znu+Kr4gl&K!}_Lgq~MRJMLX(++T<_Qw^4PHN=T}il}BxmZbqc7X64qP{tEUd?^@?Y
z6mcY?x=M+=Q<8sJf*MgiwzxhYv`sHm>G0y+R#Fd4da-dViADR*45+sem!O~J6|JF*
z2!bsss?yU`3zD2+)F{1<D4w>Ac74)trSo(g$926oSFQCu&$gW{TeshL|0DbNH(8dI
z$)p{}_B_w?e9N-hJ34Op*v)62amvR(`K8rsHdI!Y-}T3z+m;PLL<9sZ<{+YD+r-JS
z9jmi9X{R-Z2!%p{6WO-yd0swWNF)+HN1lksckOCey=FsIRRs}!`@6TlxoS-+nJg3v
z2MI%v%NGzaXjJ2RULujOESAd^Hg4SNdah$TTefb$<Bxx7X>I+^H@`4qME(13{?ARD
zx1DnG@jv*VuXIkD2mx)&Dp*#~w<hQmn#<*V-;c-R5cCVp<t=8p1-HBJsO!222ndMa
z`91(3qHS5-OGrcv(Y9>>Kn9NEFq`>4CnBHwK|-dMWDzmO(q&~G?d`trXUfZ(nhrq!
zLA^PJD3war)(`6r655Vq*>>Hq5!hwxHtgBmMuZ1v7^coN<2=P`9i-J?p^_gepCUh*
zq^W~uV{x5?IuM7dl+H!Dp;El-C^aUQy5B1UhLNh+CEjsRxg>QgLrJ2G{=`Fdbf}4<
zOtb@WUmqP_C4s?7;@Y05*(v%5N~K3%Kavcp<X8w3ThUH0k77wSSIshArDvB^5faI+
zFAo%;>Z~JA6$XJ(q1oaUR00U4w#v|iBvwY^WtDqX<egDTBcLHtU!ccM@-$tHPPC|X
z%O#ulAh5oaDTtBg0ui?@$qugc#+Jsbq@jEyu{#hr$3@SPs4Qicketq-a+K(}?{yq8
zN>@|~nG~Y)5{7w>B*Lp%6jOpof<Q-!ev#+ymY{ou24Tdrpk-NGw(UT~mX_8(|L(T{
zaj@*lx?0Y8RaM20zW24IudV3l$bReVpS|ev8+LBqcI@0)OP0R=@cj=1z*X;kcYR%L
z!F2(UbK*h9ArYs8{|-_Ri2x8?*PA_S+L%!zH>_N9^z7+JA3f<0f4&zGgYcAFa5rw+
zGWVF7kNo3_mWG`Gww1|LR#Y&C^>uZLM10HE?F8U+fBtdDB$J8eJq@QXJh3d3S@i1C
zX;UVrQppu>u6q87#{gmwi>J%WlJWSM(Ia1c`PJv1cpU8XNuU0R#Te(jD>X7OVksCM
z`TnXk>n^|S{5i9xzx3iFI}uN(Qbe?4=dSb5JF~8~X6M#z<Bpm*Y0~%?Uw+l|{CvJJ
zX7mWi7s$3xK54%12N5>xo;d(;PMik~T8J@5oN`SE7_(wAb)b)Pf7Y?bjh}ebvycC?
zwtm=xQ%`^S*{64G+v;d^DAfcJS+>1(^M*|u)^?ePbkb>O74rF)pL;r<NDy%Vux*=J
z77&GSr+#&^NOVQKs`TGTDyBl8DK`s2l>rOVUv&I!ks8t{3-?Pa`4deCq{>l8L8FxZ
zl2%<1<~=2C1+5IbMUV%LQmfE*@TBS{uhSwT^m=7>mOMjPvsy+nB+~n<+-yd@BMWIW
zn`G{&oi3})5mMSGCA93*Nv0)@v_KL!YVY%K%>XHA1Xq=XZ90*2kgi%WBk8pEL4gjD
z6aj|T^nzZ2ALupM1St_TQzW2&8-ac=HxO_RNPSYuT1urLl%TOiJ2+^kHG)*d$$2uA
z0wN7YVZY10SD@iZ2kn!FjylrWo>1dIL7I0hk!T$!PN?qHk1<B#u@VwJBn+d&;Z)R!
zD0+}k&{T$Lr2BVYPLxQ*mn?n#Zx8<Ce}8z}sV5)5eaG%Ov!`dXxsQMHOJDl@e~uk9
z^7;>aysf?CiGSSvqwjt7z3>0nKmPUf?LYd)|NGrfo10tCf9IKrM8dIc07@p}3^A}8
z9LG+lQiw<djA1&RvTX|iT-O~wy#D*&{qn1emtB78d3*Qnd*->9op>yfOvK}H0Q}W&
z@BH%}KYijKfBDD1o=PO*#~(NMjz8Y>hd<r>qwjrn=8UPAzUxK+uq^Au1;_pP`(N9(
zeb<fGU-j&BFK^khy`f?6lTSZ?&!2z!m-`;tw{QQ63+69d{>B$>{r2lCR$c$zcjt2X
zy4vbfPg%ei3xbpBbjooY0sw+o%uXf}P9lEqUmw2c{BwW%s~_L{*N4)nWMyT=m%skK
zzd!Q$2X46Lo;!c}@S~4kbiuiWy!*gI|8!mV@h6}A_(yL7f_OZB_F1P|7PD;&5mM=7
z%yEJRjmKiiWWsUmEnBzea{2%K*v&^zp7`qGWv{=nN}l}5eShZMV<#Ow<@qNc-@k9)
zf&Kdc;Dl38TlB(nJGX7M``Kl*x4vMOWm$GNKOiDwEFO<{_dz}QE@iJj%?|1M2gH&u
z(7axh99Y79<wYZrj%A@|P{}qH)x8uoyrc71$yTA6Rwp?gDGeTd15&<ED2uN|hvrC?
zrOHH8`B6-naV^@|NF}hS-E}~de<aZ=%}*epM!ZEc1s4Srlke^%rKh|YQZvt)G>Z31
zJ2#7(`0FbKiSa-x)&f<E0f=*nL8^b`+E`9ueT9G;XLrym?vlroHTz_Op7R32h}<WB
z63NU4m1!gowt$|>64~}jHzMdwL_fZ*Stn0L8S)a=)vOTFFCq}#Si&u&ZQ)3SR9<}`
z|6Rvmjv5pdd2;1)3VMoyG_(*%({w`>n!Mas#lV&mOE|GOCthDO%5mZc+L|~}uaCI{
z`kwC=3X+f41wBz-c<Ggvme%Q0j~+8-R6bvL=;6l>G&i4n)@eWg<?sLf%94COzj^ca
z8Plh%TD|VyuPn{w^3$hHPNkA}-}AuM?K_t(e`D>2En~-x-nxC)lGk3hEjvi~eEPYU
za=Bb8m8_|*df}y4ckOPt=G~WU+qUzCmtH;N^piGj+WO7!{O|e=n;pj<J!-_NRqIx*
zS-*RC!;3G!I(%5&(UT`tRaLH8yWt;?J=NUYa@3^p*<9|KXI|o*j~qVi;YS~j#bU=E
zGwX$yUit11e%99B;kxcq&%8)P)22=yJ#xf>rsjYC>#0qfw=G-#W;_;~HDhX9Tl+76
z{U_ITpLy=3e7-PzSpCb3mTca<l>qAMYO}fAOD`{OZ*PC$#YN@inQ2pxuCA_p<IOco
zmb|`m*X~yrFCRZ{^wg=7w{G3>rLTT>#ha^>iNxx)>j7Zel*x_z_TP8^!|m<ar=NW>
zm&=bDIeh7BD>iJ{#2Blqt7&WN`1hhEd-omKv2)j?N#l>1J!8|Rtt(frb!=O<xQLmu
zvW;uk?Af(57LOz1-iAHC@8xs3wzd|=EWOPQY{zjNM<zDCWuAyejv43s-p*}XE!zq=
zJ2g95gGypC%Eiim>)(q-|0(gbf%tZvTXZNd*^P>CK{4r~Qbs~9&D>PUyHNXqI;(~n
zFH$ath!aq}+^C`|hA|RqNJ{bZQ7jjle2%JaA38Gvy$+L_bBwy^q`^ffSgBB1#^__y
zk)x9N8O3AMd~bg=Oen?rBb!l`o_wuQ@K=-;0w`5kB<0*6%^8{qirTYK>Yqp=6UqiU
z-y{G5uj+U+BWb5dIz%qZ`ddQ@T1Y9;QOyaZM9XuDi#bhm3)Ux~a_5SA;OW1Vp|)a?
z=s-=z3td^cJfa>Wp<pin=~{RH7a}K~Nv6|@^xpkD^M$N!Imj3S6be~PWh#^Da?kf>
zOrD=gm2KFy+2ej^pA!TiK!$}}p}nn5{x$Q!Cd}pXj4|kn2&L00*L8iL$Kx>oa9xjx
z$6_(gc|Ko21kMQ%Y}>XN3%=eC0G4F|K+tS6sG}ny-{*`m0J`H>KWc63xZyn?OjTF;
zzRxTx9*YGZ07OK~Vu+Z_<$dlmWWjSB$BD%p*Y$|VacltaeBbwd?sG&WAjfuW+v+m~
z&bei=WHM1GxUT0hM4xlpvKd3mvJlbpJjPh}#hg>{5ZCoww}8k92m#~q7-KA#%W+P~
zkT@~Mg6|^wzVEtTKnKQHP-7^1G63ZB1p*@K9I%rAecwYs%eFhMGDP2X0WqMk4u~j`
zN+y%Zt|x@CU2pdZ5iMAFhMUj-`-NxYiFn8dCyGTyv$=>|ib#9kg6K`6<>S%xsA*<v
zlrRAOy#%E>Kk`tdsBRMk{6HnmqNLn+Asgr{oP0kn&OecNfB?PSUD+!FBBl=Zhr$E$
zWI6N8rCzk4%H|3>><uNcVpJj3=Q_>5mY@?r)jbG`_!GpPHk34sw3<|s;tdU-f~o{S
z^q(Tx*XdY`s>EX*VMmQ9mS*b?&=@30LuCE5LzGIjKhK0xcMy<{M8Ez*e<woit)Yay
zK)(P_dB)JEr2gpw_0C--cU^{(%wy0<Y#xvbk$#E^MC?VR-v>+l97ObdZ&+1*U1i<s
zb&FeC_r+sLW?4wk*1BK(9YTm^!3W<t$Yj#p5g|n6oLgNDR{$XB;1YB?Nu?59Mha3_
zy_{`X-LDM{q~Q1N?k~R2D=RDF@i-)t$z;O!d8bv`_3&UM$z-BCNwNF+j$;8}=SXbZ
zvF)DZ3a;rh1pwfj0(-J&psQ;-2eU32W0uwZBD-gSU-08Wo2rX40ASm;<Jg){27qKT
z(KiEA3d?q|=fy;}6HFw!1oYfpq<MOXxO>NT-}5Yssk?W8>I9?Natb3h)zq(^mzUq@
zq#(+l587wk;sNLs*Y){PSrLvJO9mRrLOSMR@o_|_@&Tj^3Q^8aqP#&6XJLubSw*c}
zbOu~JJSFu&T=gV*i_V@TKME*|VL;k{ML+vaa^jch4SD`#F%jf>R+>AYvNs(?StF$$
zmiGeDNm>hS8b@K}b09UVNZdvOR84V|=4A=V&yoZ}i3wMHpvQ>XPqVy7*%3rJ3%M+l
zs{4rO)uhS`fGEdP&CJ!%MVDU?s&<qaq4K6vAW$i!?Eoc>6@e(lX`1P{ATHchs*b2u
zkfb)dpV?j|th=0rA{~lA?;4C^<ZI?sL-fB=SPHk2!AN^NvhNT^XPR!iuKPbF|L9?)
zkWem)p2isa?HzZ!o|lNngRYyQ&*}R9L7$f%e1qtveWp-6TG8-|X4m%y!H}Xox#vT4
zmqhV{o-P1suaqKI+q8ZS^o&d@C0TOX5Oo@mbc_sb+94NL&Au8a*hG~vCDE|;J8epy
zNqRbt#CvM!>qtzQ5`vt{!apSwqIfyv?f!I5R4ApJoJ0~;uI~|~D3@uTz?41rblku?
zp%{qn1yBw(^a2t`x=63bUFi5r*ts!cIi+%qGy@1qZX}I<9we=A>`&%`WK^I!laXq8
zpi*=oE?tvwwTLnU3*|)QL0V0_Q7(NTEy|KBB@*+Jriz1-m|xEMs39QwQVe3}h0fGS
zwPf<(mC`W^syb2#(*VUzIuxr``N%=g@&Hu=8>!Y*-V+X0b>N_<#7I>bA}{>zGq#>r
zQW(W_>^IGHp5i7$sM@AcuUuB^vlBEp`mrP+;+^+AfB@xPUzs-;e4>lBk6@o*mJL9q
z1OZ6eaTuf;QyHBAsrt|{33T>go!lo)wH3NUXyzKB>Le7ZEab;Z$y_AeCO|qQWs6bC
z!co{}rf+TPSh=EM=$v$Q`t(3akz~z3MM{a$Kg`J;=gKY`@-kPDGPAx!i!>F4xpI_C
zpzItA(pN)Cy?-Kc4oT^(8Q=x6p$i)3qC|UWE-r*gH0bd>scu&$!ij2lP~+IDq=`~s
z^^;bV0;}_53FQ@_k(D6XjO0_6Tdf#<QlOC#q3MQG>e5JV9Sk!YAi8}kF(5UMKsr5y
zl?|&<pj4F-1Y%<~>PSG<P8q~)|CDrAg2amw$@i_yM8mMoUi$S)8aAQcXD1L2A5>LV
z06<V}XmDtt%=Q#DlF>gqiu!Ge?kzTHqE=z)xMoW`G)pWx(DR*3bcAv<7ClYw{uE{7
zfZ&{`)OtEQ97NfnMUO2l9HcqCo)1*Aaa3*x?OnOg?<n<XkY42^==m~24*~kCUo38<
z5%QI|qI9Z@Q92%-qo>5e5!oS<gA0hWIyGxhDWsd17C*~#5J;6=pec-@EGoZC*$+0V
z&`B0i-ozEe8a0wTPpMB(s<JdypHB5-=xUONrixlRL{g@b>q81-Y)~mo5vPgvZV64~
zuaIXS=;Yk$I9w!7MkRkjbgM?^@IZR=f-p^v(bZ82!;tV;==G%9KJ=Z)O8pbn-3%H8
z(LCYkWS<p*DgKU!mo*3gzV91ra7fY9*3$2-2VotM<X#zx&lUA_UmpijB-;a23P_&t
zCK(Bc1z0CpRB|J#rUrU_*hKjx6lGGNM;sJzmvZ-2(p+bD5Vlc8?Qlq84hYa|tcqa+
z3k_bOnA=fs?onnJgZQrEDM$uDValP;T_{y1APzN%S}cNw{U17J5^ELEI5o;e3AH`?
z5+y@XG?>UQQ*!IhKD-y|4ARjLC=GE)(hWl8F*Nc(5xsJ#&H3^}o_w<afrTmQx=B6$
zCuti9V)hnIAym(R#%h9e$wJSUk#+>p?vDcP3gXp~*l#2~8|Wn3$=|4HSYnt=f%fY{
z<sCFww79KnsQN;c9*{6(=$03WJ)(9v7yT#ckq%VuJkT4YyyK{j`VCc>rCC_TmM|9S
zQqrS*53qi5p~2e$J<lH`RxzMT2!SY@hsZUHQS1cGKFE^8VxQT`6;tS2LQfJ=4X5IM
zfTH)JcmO2c5{i$}q_G8J5f4PII}g25-UeM6&H@$vAxfDX^kzI%b!!CGWHn2`MN5p*
zy-m_3RcWmDadk`BRZ@2ff(jPN+UbX~^_N@JEkk)EmAG0+!wDr)jG>GK(z{UgG!)Dl
zBQiFq4p>Ts24UJmsbl*Pkfe(!S45J(lK5aJ`a*;JV5hVD^xsE75pzLNL(fEV=7thV
z5{fT5fD9Vt$Dw)*Ri>R}yO(%^^es0O>wii5tFl&8vVu|XqOhouvPmxpJTDYRsE7e5
zwPfk+5t5w+i!`n12_=~5B$hSQP`^t5l#XHn)j770i&mep0YGLDh6vbU7ArJ3B%m+}
zDWP0Y^J6R$H6izIN`i`^wi9YtjFD;x<r6`@la@&P6kkw+w@j41*5@wC5xEa}HQU2z
z{@7>ASoCjA7J?{FIC%s>WZt8ST#@!m5nF~<llQ!gq&9<`z2$Mm(4dXPABh^%k<*8?
zgCv>?LCFaeF?+TImoP{V=v2g1C^r1$50QA6s7MErnEx?~=Ylj&At(r9$h}S=&I(g{
z8%2#DLdQ=k@+!|{p;^rsk(l!L76&0oKz0;pQIM{(zT-wy{VM;e-;KFAdWm64Oi@q6
zO2Y=l#s-8Pia;-D9GXRiVUi-Dr{=bcDn%`!e6h<+Zcd|K#(t<vPLsPxrQATn`K7~(
zs3Aun*ycj}%|wDu#E-&Gck%;_0Jhech=>ya2ZOg6h^SXVps445v3gSW-j!Fs=oI)V
z^QlmJhKN*$UBcI3O31DRfq|z#RAp&3NT&u7BUdP`?+RTPkvfytnaHajb!Y<Ou_>8K
zPBBoWGU^n(DfvW_BMQ=HNXm*|5WfNi8MgA$zDRYg`YWYeph)be$+z-#hoU+b&0Z!Y
zxK2=yu&9#O(15Ur{>n~Kk};#Wy^W|{KI!#Z3{{vCR?)0D(BVc>Nw-8}>#%{ORt@!h
z0h+&{o}*KeV~MK5zY^M+N>+hXpT5wqh!)urC>3GUC}c&IvQ;YZs4+Kvl@*EdD7GO%
zAQTc!r7Yvu=?A8t;U%vSmMctUJFz|*6~cTI%3}a%^yuotFc_8~rqdlQ%JIWivk?HZ
ztVAl&86lKc|AVw!BS?ewnhPeeG$e!3X~iRv5M}Qpxj2E8FO{9UB)ft{F;Nt<2p>z9
zV;^i7sw2{()>Wa6C`s>Wp*mNhA~l<afgUC0>Q5wrI@@7?Oa;)Mf`|=5+l0uU3}OYO
zte=)t36cgeL42-N&Rw$Zp}iI&HBHeGb`U5coxalghvP_$E#Emn(Bwd(ob_vRB>m_>
zFYS<2+ET=65T$>qT(QWH{*fB!g$f#p)lSq{lf=0u(pMrap|ksl{1I|4jl}0Vk1Ez$
zA~BT93yJe%OUsT49Y*oKSu7Ev_D-mwqvUJ=;)al#cB6=Mipixs@`)r@ryUNc{7Mp?
zEFS}@>^;;ljYQOzua~@Eh`v^rH`5XcBTD}hRE$S@8-!@1*UVX!$epr<3~F$Ts4N1d
z>kHDDhmKYhtq5okR&>e|AE9j}8xbeVwo-Ol!TS2p?{OUIMT0k_e%?EPXZ-;gVZ`we
zkx&s!Iv}C6GDNPUF{0;8-uPHV4OERp-eXOvi6Z6LC}S6(y#at!E6Jm3nt@ZDObn5m
zIds-K2V7F|p4@XRrx>aVnIu#do!6C4N6-#eY8HM-WV{4Yqv|vUy|V=MV{ZCorE(>v
zQ*Np>EKAc5lAtJv`2hu`M>;X*(A*)-*r0@}pkeYs808_d`&r0=It_SBW|hz*l#;tZ
z`UwOm%8%8Frpn_aO67xL;wHZ`l0_jm|01m;O7#gzg&M@157L$%q#+KVv1FQFEoGVp
zXzO;(gn3kH<4{VHhOPsRJzA+!M6q0Dd|tF&N|ICL9Ts#%9>R#Jq$;R<2NEhN&1rcS
z6$nIw^qeVr&ShJZ_4|HQjv{Jy)XQAL-g&90m!=vzRi(5jwU7SorRDbMC|MK>n10Yw
zS?i^gfzT2udDKyJ)}aRrkj83I>WM)qF-aqkRm|j|nh|Q`tBATOg48BaW)PwF-XJO=
zAXU|(l8yV+KS+XXl42DJWt7^pxGGXpYePxL=uiitrc7x@{&ftD&?efT+6g3mag^~)
z5_h=PkyaEtTtS*8fnkyks;WiO6Tss4q6UZPC~y=oOrPJC3Qc0(h-yecdfJwp0+p#Z
zSd>90DMgmVyCl1|GJuIH_n&BELb1CI#6jKA9RyXOztCNV1im@B8U$^ZuBiVRsEjnF
z>_8Y<L}?Ly3|EP32BRF=L#N-TP?I!bn;^C;L=hO!KD<eMc_=7mK`9MM6);rpry$M-
z59Kiwte}X!K|p!QhJs=d0I4<rf$|h30-!2g5yE19@^~qT533S_i&jLkosr7LPl8=o
z;?k9(uR(aQWDF@>uZffzb=hyBx`P+ZM}Argy$khf$wXr-K0<}=i(Ej{;<ILPl?CY8
z>!{KfAQ-A7fdo|5BOu<)<T+rWgyOw#CvowsBvlN<($cuNJr_xR1XQHKc@aAmYgmbW
zD@lC;sg?(^qqKN<p+%3N;nAV6g^*|Dio6~?Y%c++9bUZp#U@!#vWuioo*V_@T~n05
zhvFv`KTV=5KuiZv<q<{70Ow&`Ezcz*y+cN*Hc)2ugvzz3P^ZtZi}gPj?9-tVK>~Y#
zs}gLK1neFO^`?CBmM==KgD}|#0g;Q1a2}>rP(Yv1C8OSx742m@>7d25mD`-5EJ|S~
z3?B9nt||sbu}%xs43b1L$sQ*^yh51xQy5!@E@&U=;6-Yjif-&f8PpCyQCOT7q@iO`
zG>nUR2E;pyJo3;-+(4RI!o~YFh~*SC^acn{tti+uMHfi6KP-|;(5PzwX`VTStu+sO
zH5V*_B-kaglS6$vJnR6YEXF2{om%3WFW!Z@R60bDRhB@@6L7fTcahgVRBIKVY(rni
zRR=$mss+)qiVnj;(jSC33GHhTIyPe*5PQ5%WYKD-CM%&+djooZl{kh)4?(^163L5{
zJq+|CT5`WENFz&1SD$j3bn-0+aE(wEXBK(ENvf1ddyPc=phE<mqS+FDmoI3^%OP0^
z(1=-Kbb{#QIx3$QsTqvsb3&J!q`p;9Ii#Q;vy*%ElucG7dxks=sBBX~QZ`WbPLS(c
zo$_zcF3;8%oTxITsR}?UN+6Xc<$o%Z*s0&sK|Q6ab0*f@!sIe8sqNP(-qS2}1o2{t
z#)GP~Z3t5xpvsD(DC3D*MW#<5kn$erkwU~3C2VS-w+HDEwq!*OrA`wxlqX0{%}Ddr
zOc5dtilH74pqSN5)0U;3w>7s6(3`vDdYu)~H-+Rzfl?w+FFPshX^6-W7$SwesE<L2
zvHCGQdVPn1fq{X6fq{X6fq{X+;Rz1Fh&T^1_4-B#HzY<E&}OCjo}z=oB4wpLWI!&X
zK`@6&oZ#G_SBp}oHJ>R@49Dp2QVtaa4<YRzhhWJ_+!IZ6z%)1>mHs?G(!Kq8{*Xb!
zy(LJQz5;=_uDeW<ZhHhxnFLN$<wS-|^B<mzei)8_@HFaSwJ!R)>oA$l;Jt1@PJ=z4
z2K_i74FS3Ozx0RC@|7^nNRJvo8$n;`mHg5H)T;wU*v^X)$U}QdZcjCIP|@9e4ML6<
zN2~X@=OFqaQj#;SEQ&8d;7K~p!8qRx)Ov^NEKy=;3HQqXR2u7(HdiQDO%nOmVGNyY
zIUP2LDpw#*0fFdd1ButV|N2Nd7@gIOL}w6GLzY0^{%b%GR|5}{Du`-Z>Qkvd%vQ2o
zL|S*vx9fW)l(MGDGazj~AQ~iS6Rl)!DS5O}U!i24NV^QEZb9jq>YvO&Tv?$>#u9Xe
zvaJ^Au_X-X2$jpNuj(P9wvRdt%|o3sfl`!-JAk5BvIyu9a{!kZG)!gEwtkg+7L_z9
z$-z~}BGBYdi0C*NY&UMy(2nNuzJ$SRot+pEphbu%PZ^~i{~yEOMB3^`d1GjyG?nDe
zA=MZlVh_PcQmXtbX&=|*KXR!M>aQ1-L_Lg70i7x9^cNz%N9hcVt2&M7gG+l<MSWm#
zMSnlbL`s+)spO6#-crKgb!JT^(LvN}qPUMi|5X8%bR(7YE{O=B-o484M_Tv6U`Wjy
zH5D?CxQkIquPf$f6o`hXo0Fzg_8E_6OB{(RD?vFxM50CF1S*N=N&1bHNLov0`-{X3
zA|@Y@1f0^;NI&;45!33oVU^EC-XaW3B2?(Qqxc}&f6dcRP`}?LZ-mvKNog)9gtcLm
z+$Fb5^;sPUZWT1iu9WLYX9nuuV2Y_Kq@Eq+k%MhyE1!QPCTsO`%p_=qJ_N5mqRBqk
z6Tv|y^<ZSLmHb%j_jC?9r{P<jx8El7I@~BjsxOX-UW)x5n5GJP3+$>G@iNh(46*i$
z^qheT1s@UWVgUDr!PwK^=9>Zy^2V)ypdApA(Tv3n8O;ytIs$fhFrqoWlpvY(_94XJ
z)A=nAEGc!<;K*fZvw}k-R);MEm_;$uG%zrH)jhAnVQPmpc|``{q1{f*QAUS#4im<D
z3oMq|Sq)9zddt_J5?=!&zi(C0;rgyV$?cLy(NN8u`aPYfV>k@;52-$Zccf2~25w+9
zICG?aKU0U3Nsj>z|7F!7SNH~DN4k2ba71ioM^^K_xA|fj7z`y2iE<c_mmbdIY*elh
zpHkTx4@p8`q@H>5R65iUQX-N}90n~dS?6BOhaAeTwgT#5^o2N_r&$_n4gI4+A3IRh
zE0I#lvDCL5@&!d9XGf|bG&pkB-oRi$U{2cuNE1WJ0jIg)&$kZ-Y@rd6yI%c>;Uh<m
z^n4!=*>nasbU*+WV|(`O*}Zcov+eHlA0kYdI>ojfA~M1wp&nzby}fPI#!Wp)hun2X
zj~`!CTkCnAp`O7J%GfO}En7Bk*1W|Sga!r%U{2em(&X?lRNmSv*#9qC8N59~jImfe
zj;`A~T=td%W6ZLwF6KWdHICyrPAn`$V9<+t`Mh0hx7)TIi^UM}EzCIvZ)wK1Y&(LL
zXADAvLj^L2JcA=2ZyBB(*snql20bZyXSovYH5dXm8|qhb&fmgD5fSyyiKU)@3Sc--
zLOlQs{%;?fkci&eoMZ6TW^6<haBsL0F0IR`X<=v3e;hvFBrq_LfCl;c!{mV_f8J)u
zfQRT_gTrJI4Fohb@vHt(4^haOhPDPrID1F9SU*BYKmf=90SL9fwH|!;`7oC#<2*Jn
z++rYF+(YiUIQ$=Iq~750g;_ZR0|Nsk^bA5GU=}b2egU|416D+^VgLZX2Zyzn#q=;Z
zf^ayev>6=fI2?)w2kQB6a}7p=)8_7Q9;AT*bR}>ZzA`W{2nF?{%P0|8Hs)IFZLhJ`
zJ?OhdS749&lOFdmo2P5MQM0LhICzD_+a`ptNy!On6z*ZTE@rWgtcef!2!~+GhyU{j
zg9vn_8AV5g$eT@MD0qY3UKK8esSFGZBoL~IUIt;9)+AsS=2~K}KWOdW0%%1lXt5gC
z+l}k;voGNlqky|_Ays9*)@2sUO#Cn$q4DFukx&iz)(}q#I~gT>Sn-B&2pZ^+%e2NY
zc$*;Fhw16yse=62s>kj9TgXX97Z}8j1F<*%kw5m`6wd(pN05d>1O((qUW2J2qA=?U
z`BIPXUaE+8IBZdeU<?6S2#(x#Wk*V$<Y6HiM>qzgkn-)o-X(vQ+F(e5Z`1WKOjrV&
z7@N@G?SODTXVM!8n9W-DumfAkjstNZiugYcc8s+(vi)0tS(>tjh^+Vj4hg}y&;48>
z(h(jJdJg+7+@1;%{etUf3x2M^eSVN=9`|zv>RV{q{htF&5sNX$Vi7rH$X11dmsyN)
zPQL4LkJ~*)%MdN5#UzZO#ZXhE2Wi0tV;HdKzhy<`2o!EJ<s%d3EIW{-Ir7a&!w-i5
z*rVm5+0_gVTRsi_)fQh(Km>@GZ$<9uNdg96z36L15wTp0uRT)kdOcd#5CDQ>4Y74a
zMCIwknA-A9dzw0OE@~Ww5rBIfx~(Gwuq}(R!HF>rdPD_LR(rucfAp}bigcpj`MdVF
zw&h%gz=<l$Qp2m#+xE7!XA6uW^<usO9y20%Z5`nGkchLmefS065CJ$5Z_CEYlU0?O
z_I#mjZ!5%Y=GdITFSy|Q5O<ixB!ed+KkEV~NI1QvVCW>Ga|}cf?;eB6M=~&oEJ=eY
zHHW`E9*#A`p<f&z0+$m*U`Mc9H^Rt_1i)AT0Du5VL_t&$;ZSX$M|4!K5AzU#>k|S5
z&Qp(5cVM7D(<A}_G9SP&7&t_3D$|?IRlLX;b6vMkD8%D&+qOC9%6AJ`pC*i~uF52X
z?}Q?P=kv8Y_vH#cV?(5~EQVft;fk}4`R#vRKIdaUdwtDzmWp#}dsRf>J|A9FHnO^m
z2nZ-&@V4)3ZEfkmm^}z%9CT}tdmIp%g?(tw5dDIC^ZE0?d;K|a$961s$5YEb{C|%C
z0OZ{pE}HY5>(4&zi+3z~eG^N?{a!>HSZffu>wWmLlV^;rzwf1$&n(+u#hp%8?fmo#
z5>dA`jsT1y0#fj`St8Mo(Dh-Wfa@6|Cn8SR^|>P6!{re~vjf|i_x6M!0{1DMj9qu`
zylYRJHEUe`t^;j%J-_0Cf3JCSOG7+n&z&-A((tOMS8U$7ua#NY`QA=T{NP&>G3SJt
z<LfKakG-~`xjn}i29BEI_jV1N5Rf4f5a$G4G4`Ti2U)DZyXK7m7(Bf5<4Z&Y!QWDG
z=cG9k%Tn>jUR&Rh_lAH24Gs~Eoj<sm_3h0$hwK9?lIvXF*M*G$w#7zPCUdUe+)+5v
z4&spyNu0>{$v#9$O+L|)n@#0$>gn-!EH=6-nREI6_PlMeic~CH@bWH4?AJ7tF$(~4
zt{>?xV@4W8#lYAqh}hoIQD0X#eE9IKTemegHzkwFsP$68iI_b9wrkJ0Y{9gK=5~uQ
z$FVl=IdH*kcjmGMLMw<s1}A1B>JgI!0AQ?F0UHrm3<GT+{D}ZKCqxMDD!vSRcm!>W
z0db#G;M)m=Ik0dn)@ed?58h&ox8~meuDQ3qd*Pm@HjA-D%--7A{Ed5`d*G#2%w|Mg
zrUg-On(wqp5Fi+H@81D{h!{fv<eYb#C;_^T`v3?Qb`FMNFhL%Sr)R}lPm7)i01w9O
z0LVfX42&@r{KgC3`_4J`ym?36^0S9q+jGof)b(D!;7%A-`@Q#{`_L<EzIE^O<LWAX
z&V9};ivfUbq0hPB6(;Sppaet{@RC+nI79%?zv-M~k3D+Ko~E{EUR}!_oANGL3;-bS
z0s=S=bF9Fxz&Ym~1@Ji_fNg_gS&aF;e+*1_3}Vzi2ipSA_dOph28kFHJSez;*csCc
zOg`7+1rGuai#vVoXQIzue)6r?oLR^ho_S-_nA(bOy!YI5=1e;Mzy4o&Mfz`_yQ(6c
zIO%i0*|~WSR;GQIgXaO~KmZIO=GczqwdLx^mOuD~tD8G=^H*$!Yyr}VzVA&qj4>kO
zo)4Z6wgtZLyFOS5@fdhMFSq~z@t9>>oCp!P@AJG1oC9MJvzcuX0p}d@KG+rzL2!%X
zI0?sX%Z?dYbN}bA+T76e*lQao@3KT}FsmVrO>zj)AIh7BE162vZ{i=(oHG<e7oj#2
zkJ%P=9RLu~_58NHH$;7PT$9oF|D+KV5D6tk1*AJSLJ1WCX^;{|N;_)Q06{51rD1@C
zAl;)oMs9R>O>%TIe*1ju_vf?Mo_p_e<9*I~pL6bUG1=YQh&GVKdN96>0af*1dG0Tg
zV$6?MpL`%IX<;V%5ixB|o+oWg_Ac=Y)t1cjABTyom3wtxNX0gD4VRoKapTZCmVM<w
zjb?OAr}Mq>P45AlG+TqL=wL}N$K3_QoZ2=MPweUSL3OFiVoT)<rW(Wc3Sh>SDYC)R
zc{5ip<0<u>cWg$z;byZHrI@-Bw6(uwBN;V>k$~Q>Wp<fDxu2mvc)8-czcTyrsT{+x
z<<~L>776X6gl`jjCiRM8WI-pbjJ&n@s1f+Vpi97Z5;)ojAGm=pyVKutdxO>G8JE@g
zEA3eDn(GwdX>uD&T0x91FGe^v*MZm~WlPX?7}43gtV|HcMNGf~@z;;S3Tq`)fPwOQ
z^@gQVJL9?4G*u@gCn_AkPhu*ZRnpIRu|_LxT8<At;rtlp{PCF-J>VQl#n<gvI9Z;=
zy*$-hds8P5towAe(EGHo<*2zb;Pa>~L+N6jzh*2;Wm6-Q?w6lve^fG<&=OO=P)_~R
zZx3QA%<ElXExdTrhM}$ur*(@)&_(rnf!F~^0uFftz-$E=!2s+--049#EExu+Q4f^Q
zQapYpO5_v%gyVOHAfR%{X6^(q?8&!xM4K1Yymp??hU<C?idUyDXE8F>PY7!%`@Fp+
zDN%}g78KZ(w(vGnbfF8x=Et@pkTtFE)>BSZi@c+lt~}kfP+KZa0oa8yNR^hpMyE;n
zb?gxer<x)@7C0GE@qK7=yb<Ux_nTD9d%z$Fmj*lftD^i*2M5(8_fQB-?B@CNJQQ5K
zr1>dUuIBT$S|Ngl`s{qn?F4^X6I~Ykuh+D=G?^-`I!dn0&BUEX!umDfTRymq4AXKC
z&DeFrW{f6_0c`j>+o4ap5Fsg7Yp1T`fEfKpuq5|K``|2HZWcnpcC-GprTMn2;xd8>
zo!+pmVB84w*npF7DitkVAT?P-1GhbQOY_xPMJ=Xw4mx6meUZ%x-^`2}ip%o@yvH9^
zb|aZ70Gg@N0qS}-yD0xUM~j(r3kFs%cXgw~@5T41nksVt@KZ#6XVdZ@+uxF`5r4;G
z>bnOIXYyn_?-1=rM*nSI>9jvc^2b#2PPjN#(MDq~Itu#*<O2G%o)*-INr39TZ*u3a
z?vytd>?DzQOzcc0YDgtA%RgV9!cXDNObQDaIhG~|X><~vwX_{fFLR#6jnAIlKa_KD
zeMX=*6?A_b<u&!bcmMjmPzX`%R{y6Fa)P&AJMe8t)<$%DVd`0Pt#iyagyJWyw_FYX
zh7U7<Ir5IeM_J<A`x9ucL*UlMszo<=dGZ3zIhm-*WK`!j+Z->O>eQ(aAf?!bQTS+_
zHqFi4dLrd<^8lE+bkO?8*-J01mKFIM$lAK91i1f-fZKb{W`OIk&PCY9_}@h*;{cm^
zgC#P^bZ|NcAKP&my$lx~Uw@M)jv*2L+Le0RT;{B~<gv>^;3HT1TIL8jDKK48S}vaG
zTIB3}hbXVGFc29Y$Y(_yW8B1h3YJ)fn`o3^y<+Q^+`gvWasnn->1AsLq|q6mdKt`B
zsnc|#yQ9*+)P<75(9!Z(bsuFLB8eL!WvEI~zI0;g%i-$J3a@dB6b@8S*(n*V-lhc*
z3D8Y)W#|au(swWi9ZH`TW`;({J$p5Kp-XNRjF)rYUhegq;|>pyXxP8ZmRZF7!a}#9
zeWBW&*y{DW=+c?DPSRzJhLmA)ZtMAz0&r+Qn$4`<vcEIDBj9E@GQ+rTy|4wg5;1BE
z`^R!L5}ssTt~dL*#b;79)oYhDxDb`(KiHm(Uzfuz9oze*1HeY_T{Nrzi5gbsByJO2
zgLSw$Ow$xxETixX=o6-u_umYs68HdFc2kWhE}X){_8?w*I^78TLtUu=lqQdO`(w@P
zwyI)tqwz`k2KWN6AhcwSweM`m8ts|?hkCckdhuCvn8#pP!N4vX5Z3p1W>@yimlzvN
zJc`?1Azsh-2CE^d*!(WS|KNkxPS<G68xO~{#MgyqXBJa#Q0C^|HWw-i%v#2{QDc;^
z-*k7jif)>)?+R`r`nK-&50atOV?|ifJV~nlbbAsm47I98Zg%Mzx7@a>-Mgp0iX8J_
zFBr{@DPDz}nKj+0!2$}N8USK4Jm%JnOFx`n$OA7%A_f^NVSb~sj4P_JQ?I4tOf`Bw
zxbPk>(O};Dw7hyf-<rt_c6t_r0p0EinnSma%ZbsjgIP&|*{Z9{4B!&YbQE;Aj>_!w
z2+TY{8?h9ycc|kG^mV2lF=@8fOx&Crl=@d6pv>tuTW!miBoYDf-uOPaSc|DcIGS1Q
zJON<*7S^=zHN%SM+AT*a6o~MVvO9B`kUetM7@z%#ZL`I)N{%!}$wm@@fV|rbv3Uz*
zcJGF6eRI+8dWBaboyJ{@XYD92VA;#X*{SwO$H1iV<A;5)MCw(asU{4&fN49DcN->W
zlerC1E<~VM<@u7|Syk5YYT&bktID&t3h<Gu*{Y@|H!T~+l}HV?|Hx-n$;PjKRQ%iJ
z&mBr}ICH8hcSD4-f`ZkPZstgc-Coa~mkv5tnz&1jhmC4zxs5$^V?*{+Qs#gQwnPEr
z7XLjMZso`TejQqf`X`5K#vJq825g>9rb%pnlQbV%_*wiyZQ-b{(A=nLJw)?nt2RIT
z_Hx=QhDBe!Ifnjf@|VZt?RgNW;ncjwbwhFiGQsOmqsgRWkf3o<aur<{yP^JA*ushh
z0G9(_D=#({Hi0B<4A(Q{J-YHmxz5vVrzd8dzGE+jZ%PH`UAyx|ao4@P2`&quMjp`$
z#9cs%k<@mT;KBhLhV6FIK)}%f%V=(Xu~dw$TRrH)-nQN7&q?Rp^Hvwy;;+D8Te#qR
z4z|nLD2r9UuuE_O0Thx$AlD)Fk_hbL{I6=pBk5`Sqi`~I=W>hnUVo=L8an&0wS{$r
z0L}?(lZ?k7D&c{5yy1PZ8tO88mwuXRsMYH*Zn-spaB4hP8Vl(Rug*czAW(y{74r}>
z^|ylZ)!bsbi=a20+ooJA{!!#|^QoUNiV)EK(Opl**_gks9ftsd$pBAzbV|@v?hmE3
z)H$7n9UXg(=%WkX?P7cKz~z0qj^@TC(%ZQ!r+@o&IhTp3?Cl0wEi5=VG^(6nSBFkl
z#R3_=dOT+Tq6r_kW?2oS8yX};NP`_jdXuVa#Ict^mYQu5a*eT}lzv}1fNrj(aH_c1
z!*1O~aa#)hX|uXMxx5tjMi~~DE$$r`v@s=8H*faPObtPu6#A5Rl%K`fVd0(#45@GX
zssDk|q^yr&S2M!o+qS_UOKWnZ<rLh5%6*MrDTCYDIJ-|<ICVPAV?CUZB~;Q=Oq#So
z9sqF7iio4FEJ8HO=5p>{;3rMswQ;1hqahDIr2~z*S1dh=>EQWASzazq3XmHvJ0zkJ
z!xy9ZUBai8?)u^L9=<bnmU->iGw)Xp2}e(N9oAi>xd$cg>Xov7Q{$YG2lBfOdtYz8
zScf&=%#PX&+B?}RcV1y{w=1msX~UIXEVnIPkWrTN(R|Tu*LV*1ru=aO*}TkFo$%XD
z84YUV5|lgW%+F>sZM+X`k%`402l=y&1Z4+A%XZFY&En^Dmdds>RsBTM#*Z@wrE>lq
zdpE{RsdA9%UbNrQS9|aluH5P-xw89q=>|gpa5an9fXie537UJ%{Ko`XocoMx?3KS-
zB3@4>+Gnk!RT4&CUXTjb9_-YiOXn{8>eDi6?b@iEfed^*X;PEZ<~++&)LtXtEmR69
zGhe&`Y)(;&+eE%=Jkm+TfUwxok{4>-d${9x<U3aK>6g|#7RD1RC$bra&2I0UF48jU
zEv-z6AI@0~$ORn!b7?s%IyljT!K?@4epcW59?A0Zj5se8=kqjd<B`R6ZdkBn0rA<P
zqkVI=FZMtedWl1uo}j=nJ~mwm29vwjOR|`oWqCoh=ax$s9Xz5Gw$Y_8Gzl;OA+PrR
zI$Bi#7yDx!W4G~MQJ03(0ld-9Z`QJ!>ossS7oWFwccI11xWxu3$8mX8=)h)-2%>$$
zP7~-<JhO1V(pOBjzk&GL(o(T8{CrzQFEIn?M5%>UBH}=n;}%r~8f}&b@U}73<0e|u
z#JwG#=tb{NhYb}3aw&Nu=iZERQDRtCi}mG9i=ui!u&sYH4H>Z2klV|y5sz7$?`#2m
z$HGHDZ+Gap%-s%)thc?=Z^z|LZsuFAu^o{K&T}UR6q>c(ZBe!fF2Fr`SU~?SmC#r7
zy36BOo9J(j=}!oj_6r8$Zz1R!+@U*%jXCr%%KZ9hys+8VOU?MoUbH)J^?v6L))cl^
zyDYxgj7iRxJ8tokYucHE>d0NAR$EVGVtM%{5_tJ$Yh~$UZkD>euGeA{Ghidfhkat5
zX$%HVS4+E8^>Sy@{<vt^y!X|sAN;_2tD9n&-*v4fZUruQvv=}cmf;<f*94s03s`*}
z+u}n6xL;*0e|Ypw?yz4qE$L?dEDhvoI4Fq?uxaO)zc?E0UlexfBSj@sq-z3Ni^@Id
zByrd;=GQl1xdUF!w2Pi!9t{3BG54-g(MjSsIGD3N2w}V+j2%m+#X|Q^^4Tsn@gxQ0
zILU&oWj};{d;;TldTs&p_PJ<B-+Wq6FpX86H1}yA!-Dol7;g6&Mds>jE^g#;+h=Uv
zj~pe2US$7lu{}cQPI4A@^SQ%>#I!|UyJRZXkFEkSZj%^AC0>kM3?ySz7+i=Px4O%!
zDK$|JcG&n{n*2UB8C1WOBs>o3){QCbWtJ_m(KeN)fx^EUJkv;eFN@$5^|xAYJP>!A
zmAQ6G{jJy$77-V^Gnl4sP0mG!H(f~ozU$IR(Ute`?#ijJNX{<c>#PWYwCB{n=-}lX
zOBiI)Npt0!ZHKOYvWY5S)`^t~c)7c_yskL2TlF)3)uBJE=j1$OrXu@Wd;?sxbMt9o
zbjEv0YwwGYnStOpC!4jqLJ~zB<V54i-lj$?uOE(~meMuTH5Dn6@hx^w+W2XN;eFy=
zPWrLYq#JHdoXfO&e=ND){beyvOa>PD;X-EKwY!1j8aaf$-kk{Jzd0&jLn=X&H2Z;E
zUV*#cR#=3a_$Dpa`1jJmhkkNU!;3hJb$BaAH#Qv2W}f=*t-!0!nTlGl#YnlTE~iuE
zb4LmMbmUxCgnL+1aE^a3dQIn-9zKiwubF&gmJXMxs8~7x4H{8oYOa!M=o%zQIs5Gv
z4eNmmN0Cwaa-JsDPQn^uxjZ0$rS;mB0lZR;j4obQ>gbC->K^ZO>JDd)WD(7+m!Lh9
z&XA~BnQ|M?F3>*eo_NP%b_W2rbNBevmQyc0zWFGd2NPY4;1`pf`{CyNuhi2%=8#;2
z)!zTJ+4bd%qI#KKQ*X~Frri)H22=Ot>=?O`7!iG<&c^MS!qP@;C6*-6eeR;q6b(Gs
znu%xf3^>r#^xtl>^~b(qXgoWf&bS_IF*9l&exY`=wXEE7xgDwaP<VOD050a_?sT#7
zy}>kt5F_uszkYjlG)kKn1A?4(7JpY~@LzRyfkj%E$D~WPaKzdzOm1Dm!<yaDkd}ZY
z>-|P2-&C0U5ix~rl<&E@8sAsN3hsxEw3zR8hn<^j7kD!dw;KDgT(U;O4|{_NIN7sB
zVC^lV)kz^$y%ke2^83+vQRZf7&9i56^rfX_VI(lQ)1XAgY5cSavv^4=HFSDXA0d8w
zRvyy`!STB|`#X1SU~o;383`9}ks}^xe@w1UZcLM{1NirQR%66+0d|3cpGAH50z2>O
zX)UwR=y2O00K}c=uL?BnYEsD^Jhpn!tHd`uhl@YU@Er(Q&VwC9W6X>Q0ZeDi=fi`T
z#f!O!D>nc5u+Pv*Oxj&e%w-fYLT2MG>&(s(%x}ddhF^U`j}I>Aj6cnR`-N9#Ng@TF
z-Bb0(x7TsA3E)j{_EwE{sPphvg5xqM4;^qmUft4o^r+{VM!HOH3CH~C%a36{ycXU1
zqP#Lhj{30I>!nnUlw|#qyLC4SN6xUd`0CVC!(PMTycdCCtqA(kSz$NB@jqPe<`)y@
zn_BczWM}$`)|Cbj2_>_*>V}NLJqM$@;)AJPaNjSto@eM3&>cXt$Kuhg_lh{T8g6~l
zy4U>>4^MZ7u<0g<wd#9n`pzKxt$$1?>Ak*Kd`jbC!S8<uC74C;;|w)RL@2$l&Ba%j
zxf4fI4}4<h`(%wZ6KtnF7zLNLzxc{xUc2gM=ZJIW@a%dsiiU%hNvSxGN|4lde){6L
z0*=tSK+j9~8@8779I9sU0`In`AC5}1xz_Gv5zu_oT*?2Hs;S;)J=J)1+*(jz@qC51
zFi6;L(|a?=zLF~%AIYjkC671`QZ8(P&L`Ie!_bi~d$V({Tlu0Wpv_^#ci9#<>`~od
z1I)<SZ7^R{GgWxcI9cgO@xfA-_!;Q1uU*H6eW`xeSN<Xu24!9J_+8vwPXK@~<3*wr
zOJMVDYyY;n(N*l}+;>|v$i6SBBIVGeEwU@k)_n08Z}5;$U)QHy<;5`ljFA2A;04tE
ziCbyVaN6abJDH2X>zZ#nN$QtY%f$EpmGy=I;rZ@U0u#ocY65%-uiUtLGiK-2#kfPr
znH!*!UjET!ZDw<G%gyDhty5da<h0uf&hs^P;MD;wJ#fLOgQp~t#i6^WVDM^YamtOI
zu2M5q#Lvq5v;QlH0h@1?MvTYej9SS9^$WODzl9?_P*GK3_=E8POue5h-T)9<Hk8AR
zs_4o_HI+HXAfYlgwx%u{e+vq9uR~9KKS1`Twg&K$!AsoMxUyv1P0)@baOtwK(w~s#
zPMw^21(c0T#`m&knXY%dA;o-t%=<Eq#$`{ctTO+p1)If->^qE>a~2XE>`)ObUe?@!
z2DMri<!6`qUEx-_#+sV_VXq*l@@YKUU&-Drb)In$mhw2<cN<UcPB3X(-3+O`Q9xD{
zU-_e)zJhoUfElGz0l)dNC?*40yhw>A+)X`2s55E(jGlIaN`^7-IrV$d6S;jrc)&O}
zsu~u44f=u;tc6YLt<6zKpo|P}-J6j53jV7Z&hbQ~)An?A1BF0_Wb;IM*%i6JQs+rs
zmn$+T+UaUm)!@&D=HFSZiE@1Zr-Zx4rwEUSjTUshv7F<RxwK47#&}7IH#gK!Ec)qH
zjI)iUPTtC&Eln@_nI0q9>@waPd+yYx%=1s5HcH~L{PODro^avODG!bP_Pyk7sf(TT
zz@Lrc?;|=YvOoe2hm_^$#Iu%wTfLU6ZF#O}HZOc_Cfu$IjJMo}`uEYO6InAFPbAR+
z)1zgJr|~sd!q3sTa_{AVgN$a&<&H@G8(jW+l16R1B&_=!Z4T}GmvU%I`oT6Tzn>nM
zD$HI+eN=M0F+uX$Q=-*7U|qkons6lCpPvPvfJ)=AVI_R**KDaq*vS_*?c!(;2-F(4
zUOM_xY#{Z$xX{&dBKSpip`70nuE)j(W(gX4xwNwlGIPhw{$Mp#HHnO9S@5TRLFs_L
zmPtp=?j7=ug3}rsdC0hZbl2ySj5pmHQa%rJR>qUp5}gAuczyP<v5X}>Aqt-?jjFcT
z89$MIVjNgu<sd<&7~m=5d2paJfweowE2c)uDZ&Hvz<19#G+C?d(Ls2AML71^BrITk
z;xu|EI9qk`w)8m>_1b45LTj?3!rCcI!=47g;)VO+hVA9jG}P?u&%nY+g1|#vKl2zg
z<pUZiPtIipYBF_XvF=<s|4s)NS*!ibzYmLNXla{~9GY<@Aw&ts&(~3Z2Z~O-GT+w_
zaC!T5<>HBu3}J_MQ%ylqwLu|Q*Uw2_{@v6g;R>a7tb*ugpZaw!`~tjmWUU^A>jD$`
z#}e{5WBxijpiAcKsQR>rei}DJsQ^($0$-9?p82hr3bIoG*6zy9=yTF+f6{ujx?Koh
zcQ$6L`$sfu`LwW)ap~_?MM}jQs)=8ba<HQK#F$C&x;u?wQ2w$J8jDUBUB>H#u#@4j
z7qd*U!m`{0+?w4_9`!TKJyQLCJz&knpCt12iPbM*z-K-R=0e~jQb6}_j`*oWSDWZ!
zLO{$B6AH+=VW@hq)G}&ZF9$5lwFH?wdP1Yt%?#l7mIK87Sqb_&*nq=3I}c9cSy<}&
z>EESE+AEnV%h(v>DH@CT&0q{+8N#HkoL@ek%=rmNn5=ca6u^*@ccl00Z@wj0nJLOQ
zys+3DpYsmBABu0HhSxvrr0qk>CdIgB#^;tHp9H;)CKt!Y6p5yT*{<{XENmZW@HnGc
zb=EK9+>73|Z@vwc_Cq7!+;lbl4^Vw+>c!GtwmQhElz}bNK{sT<>n;g#gte*svSG2b
z<fF<0?Sta0S=qa01D1nElZY}2+Qr!fhkhu11&H5ha<!vBR#8VE_`3beGlfn(SLxUm
zDXYJ5@`Z|QHj0?dzHHh;`z5_H`srn(s1JSRbZ++qzO^r>^F!I+?phAj-f`-tenMAS
zsD03gK{M<1hChg2pBgA<<k&EQtu9Q!F|wc{5rU6l#n2iM_D&m$a2F59z4(QW*8c-`
zg4RgHPPzT=ID*!Q(;Y|M;~rr2hTE=`50Be(M9k{HU$hfF4mXKufYWMm(m?n&Xz5@f
zp-(nIFmq$pJE<~vr6&c|q!huY%kjM-PSO%b;SYox%K0b9wEhZeI?pc(7Xhc!y()=a
zbgl0OZuQfOCwtE!RuJ*g({g!A0~#_D@L@dwV@+{N#d&wPEB4;$zlL!P8_AzTDA`*V
zo(^ija!g^<ZH*Wk1mT8Ow!)Wk=~@50zP{d!O*}Wzz!QUb8)72^$1(%?C>$oO&!M6;
zcV>zv1<bxA;K)d{eQ*}AVaftM(`oT_9E@%<Z`e5YV)fM>a+Lhhp)^2}r64j&PRd6D
z4-Ph1@L=J{S<ztkBwi#1AS-<K?gFUo3WuxL>GHkz?c3z#>W&qR?=#9W{^3wiSUhXl
z&*PFTnZL81@4$e%Jc70O>bx3dOE-%qqucDf&Q>AGxaV!X8*MO&jWXKFtATs<lIzGr
zkYG)|MKS+(yU7qvR!7)f>Kdny0C@106$b!W@<OxPhGGtr0Hz7*G8B55q2mSQ$NHqB
zb=*knFY`&};lZa!kcS{RDMFUIN`7}iMw*zW(fPy67<-bORi)PaBL`;2ikq1PWg^;d
zdgF1=`MZHAtS|1wlyrt2nD+I4z+FZfDt%TpBDP3q14ML%w1s5TaG=5vWAOYhQYG}Y
zBC=#j^#0KF+xtFMpYJtqQoH)1WAqe;#KzB5b>sa{wnq8CvSO}gWIV;Ip^C;cA5D}#
zmY<p|@8u;d-t6GL?8)Akypkjd=c%rvylbc7t>2?mfIzhB{le>Aq=0n5*3_aL;vDb8
zzC2gvqAbm)tZ<d}4e=0Xh{WIPz=o&YP8>8U`StgquXJYdF4`54OoR51bK3WWP%1h!
z^`k6J_akW}iN`)MdU0fG?J`YSke)-!R@Cg@Wda8#Er&vmWE8A*pH$R7jCT3*qP}Ca
zOl+eh6Z7-+NM<&~HHE6tJLpkIebvVysxM(uq^ad6_lkXIKYK1l{K|Y5_n1t9i0(hu
zAfCT+5DAaSiLEN`)8)f_jucLWqzV&NF$#6IdaxdQ)G!*h$&E}`vQQ7NKHT0?xu3S+
zzOenpT1f&Nb+RS;7WB=xGwmRp@9WhJ#KqC2;?V}kx$?`yfAjbYx#anYA~Vt9v_e+1
z_p7|t{FOeEK_}0or;A)RtUl6yp!B~VkY~)6S{XV4H%N_UvqK}DCWcbLVW4PxSE1&1
zdvE1Kyp`+w;WK{RilqkqmfNRQ0~zmquRH4-`&A9{^!Gk_`a2twS%BnehPE!5y~~Q|
zJHW{C9A@9q1&MCi7!|oZ5dZYB-ewMX+-jvEMFxmJLmcf(u6p~|bhA`DE`raPDagHD
z+h2aDY^Zx-{LwU{W9t=A;~`x0n)O!dbBq4xsh9TDeME7PKHpZ$qzEp8P{tS}fB)7u
z)*VW5;ck&$Z>GGx^eiAY;QSXchE;S^73RB~fG2f&phvLtD=q;!2nx@7*aj@uXv$y7
zNa=$iqy(pq=5zKZS{OS*6@kaBHWUKq%qFD>K4QSthsyaqMKlHw2QgJRy~1y_lcAPO
zK5{5S7<*c4Gx_%rz@`%AitzqL8oC*mow^_mJN#=7Lc~En)Ib&+n%xZYgz8v@n57F&
zS61`p&PGz@8@7!AJ<nMFT~;V3YHZ4d5fa^d2?-saeJluvxvMLGT5Q&L<?CtqXiPc-
ziQfzvq&A`QgBe=O#D=-dK>&X8LO>}RZ+Jrh2fk#|;woK}9P#k(xFw}@UNGhh2C^ek
zrPLtEVglmWm%5{%+Wb*=LX*|(xF@!sJvOkBg6Kyy*nq6W?%Q2HZXo282z5c*FUd0Z
z+4?Fa3i4>Bd19wIA=<6u)7SVsc7q-xN)s1z2hY`X!aNkSyoKR-mNiow!X~<qG;r`c
zY3m8&EAlJS87QV%zpAMCDn;|EoyDo{<^B_D3ZsRipB@QQZfG{y#!n8fXaRRHngX*^
zW9fyZC9k_=v!P*2KFl9vqSGZWrrvZUI!zr6o6G$&ZdjeGi$$gTR&BfeyQ>HZG-(TU
zv{*+p1v<_yY(Sb1^KOb+6rWDlg6rxCz?m7vd3#VP`q|Mjgad3l1aEWrZ|@<^XMeow
z^jmS8b#`)=-}_4gfcq?toP;SP>y#`hmMHWlrQk@kr1gs<7Ez00u+*YMnh-fk=xfK1
z#Z=xu7QmNwO(=XAEzz96${$vg5W&m9qHRKjS8AUAuL{A!1h1#`4Y%fh42QUvtSD7m
zhfly$dC!F-tJmiaLv&K#I669>__c6YF!-_hz38({I`igSc12N8i|Mol<8f5hPUn$V
zQ3x1Mje{p`IfGLMLcnes^NY1x&K?U##uQ<#(sgpSZIj+HVzsQ*nE9o`4;nFq79Z0t
z;9fFXL4GJuMlgJ2qNu^~3YXLs#_lY-HE3WsFh-;}8dMRo3pteb@?V%rDSm^*>)kSU
z1B^=`l%xiXKWT}>i=Oi8>_V}BPVUKJtljcBV*$ZM+g=Z^;oBHf*ujSXJ$|FeOe`&F
zMOkTeC|R>6aYmxC#()hARB+j_qhCj}bfMZG=Bv&r*UZ@w&e)DSy*|f}zMhgm46%NP
z9pgi30R}thsM=C6cMI9zQG6-|uk8<(8}1)y&TctY%v5s44i1$UEr~|W7YD`)&mPqw
zdmT*)bENNxrSy?mJQ1ScCxH`kSw>k5+2${r31`q^;#`Zo=iYShyyMttF!T5CN-UMR
z$)`)jZRb(l+{BC5n0j^BW~(|m+Ytof8Hu2Xv8d$LQYrh#B9w9~z2SZVu6zNBPdVPJ
z1Q?h^hFMB9crF)NDHnV)9LJO9ZZ10gyxU$190~ljfqZGM>>GS$Ee`1B4YY~pA-+{%
zq|9naK3nZ^j^!B<*S=KDEIlW_%Aeczc;2`{y!=u32BGX32;tZv8=d-jlo(lQRg{ak
zeq{jvAm3QeZ}6|D0sM()XY1X`zZAh{hbKaXe2)mfwk7!n#13KL!bFoTSD}&xynW61
zNC$BK`M>&zZFC0O@)RW4Xk?&=3#VY1BF`)0Ioedy{Dfw})wzQV@fz9c!BnTk_)-}Y
z3UnH04^EXm96C85Z~5l70omgF$~iOptC&YEx+MQ~;`4@kNqf7w7}Lh1*&;F}Rt$ZI
z``jI*kL5+TBkHC-J})Xo3NC#*&86P3cfH!mfQV33`g|k3`c0F`^a^j<H=IiF%FEGo
zw#oQ^R|1Ts6*3b|I7TWuoW^^|0+uEUHDnLYvjsuW%NRMIpXdt;-WovJHX4}gW4OMa
zH|T@5uQZ;OWi_cn_%_^~ON9fZJd8HiAcuaeUPXx$j>hF~XGP>s<-NLk0YXr#6G1um
z<+Y#VKy$Jz*EJucI?K&m%>wMqcEMw%h`i%dKg_Qms`~w}^Cx@Q;mLP|b+yfrb?<q&
zj%tQy_fCC;yYE7A>FYseW7v)n(!{4-7r>~eL*m9|urG7y?7<0L856cm7xq0tHK|QF
zr-9tYV5W_&h@v+gg#i~oDY)*Hehr>frrok+JS6-??Yg1>q^UHn!E<L0+d)Q>EnqVb
z<pL4fTig{I<h7^N!%+V+GA)ayGeBBv-vy1SUf;wAkH{RIXVVI&zDv1X&TLa7zBkiF
z@+z>yLfKX5qS6Y7T;bL7fKZE;^D6<pa}fO9j4v@6hSUM%xbLK2BnB*}=CtrCu>V5s
z%%kjr=mJ4`kHfM8_oz_|f8FQ7NnI*>e<ZL@{?<CHzxaL4r>neRz5%*=eOxmEzx^H6
zrw6p+RmbC5L=iJb_E$ltcwTe!DKFQA4c;<`@FAKr|8TP4Sx`$u<&|1D@#4Dng$ZU3
z30sP%JikuX!;P{FRdhL_7$j+%O_6NK_!~{47zi4J=af0e<Nr`aIuSp8liW3g_#tdX
z*-+6d^Zii<?JK-$-R;C{ywBgM6`%j+#2Qd$@3M{OXYnlTBXeWVt>F$8{an8cK1y`z
zJrZ5>bhx2`1VRR6t+bw=;HcW>#fMl`P#r*Yk6WGMfs-{?YbnvCzu_dg6HgP@S1742
z@TzsH82rhN`pak>tI<`QG&tgxhxhQIeZM<hL<b`oec&nvc^XNEi4knaGo);18d4L(
z9e4%gkInaz!|-6atP(U{jZ)S7V-u7A7P(sy(m`!p;fy-Tqb#)Rt-G52EZqOeZjjC|
zU?k@fPeS8$t~7UD|B-S$jk7SZgQt#iWB$T{MV8CM9lXEFle#qEy7Cnw>yY-6AFFuS
zOV&}<eFh%iJf9v_jV^c_{~Ruw7o7wwg0n%*OMyjRKSmtLj48@$(ro8Zae;o#KhT)$
zxchgRBf_G)a$}fqeP=HBv)1Z@y^hegxbmYIO=Ozj&BY7A`Kh^i?RBSp%gxmDM8EBl
z|LFV<lW@1){7UMBI?0;mqp3Fr>A)LAyfLk?Z1QU<dP0KkGM?CX-DyjI!jnwX-w=)T
zQ&$pWi==7IZhOBu^y?&a;Z_r4oTnzp^3U;sMZ1oUK8M@btJYnr`J?j@G!7T;(sWj|
zE`K=`bn2)q<2DK5#eEc>TrE;XK{#xXmIp2VIGz|C9-F)slna}&AC|)9r3h|a_Ez5a
zmW2y{>&|tD-aJT@$ytyT@XfskKtuNH^)s?yq9ld4Ie!(1wc9HAdl9Vt3A?J%6>F0L
z*XI{T71nAA@z&OF2cD5>6TK1Qpe9mSqhxliWtK#}^P0Ru&h73#UvkF&xVmclHaDBL
zxd}8i9oH+>eW=`WlI#IHTjCF{M0oq0^>#}xNFR=yJ6~cni$KTb8IviVtS(alWv9#I
z6t@l?vmbQcC`vg-vU?y`5UbQQN^p!9^Ua~A`E@^4QKQQ=GpekP_hchTC#I$T3d?zW
z8hKWF-cxXqu%x}E>A%|Rk7Qz}4}jd}Po6U0!ZJ**Y_Z1WrHG4S!n}frte_!UgfjP<
z6?&9GIjy8h70`N+m%4DXmf}!z-Jkbo0(N+VxwXBKFr&Ud^Ig<t8Zi$c0zRn7dO{Hx
zST1=VzW25cjoVd)VN*44EN>8K+@$F3Vejl24#QT}HQJ?xK?-6o*SCG+Cn!lET*^eu
zcRt?CemhIEv%<KKsXT<&P)^hTKoFC*E>$rB9)|4vUH~ky1)R)`^{q5GCmn6HT(h!2
zeGa=GDS`QZ>OY*0-K)3ooTtKxtr==>wOnR=Pd!Ty{J}CuhbV4sbF7KG-%1^sooOg$
zW!%_QcNEidHm7-e9Mp2&$`7k`w(l(evFdQ;un6+woQ?gHHCk*+Rr29@sUURZEYuoF
zo8N+)?*77+8n}#>Xu4uxt6i55aA9%9*)E#5SX})ibul{blMfhK+4(ci#fM@u6h3p|
ziet%l@pYRlk11+C9To(Uh4J2=o#FOdGJLm6<*!@tfrxDLm12)80B)-#;D!YdE1Zdv
zGLXOR<&!+_2X{%_ETo8fh%oG(Fu8`4ua9WuypP(?_>#M*oshlWhr<kBAK-U96CZL*
zA<3etTc>+BP%OwT1HqJoYk5D8^w*`hRJIn#k{E^2g$A<w_g<C(ae7UpdaP;EhUgbN
zD<@CHhSHA@k{;H;d_(Fms&f8i&bd9k&k%!|*c9R8c;~IRyje@f0csqyj0@QO?fsl|
z!v{}-y=Nf)p{|?t?<lYH6O_|Vb0$+<St2RA6<W&^yw#xtG&`=~M9#lap@83@b@FJ{
zlzK5OWkoXTl}8y*C%kgJ(mxdngeR!LbGWD^Jzw0TeDXdP#bQ49t7oTpo6L`%T0xB?
z_R#9Lq?5YUuadQ}<}AXKG@X75&IA>a<_KHAphOgoHoa1(nsY9Ww-OXZ_951pW0f5B
zpafPWZAL>ur(A@{slmQOp0Bv}JTSG#zSd#j(53szL#Cbn4*E;<osUQvhWWMaj9Pt#
zkRx5Z61pnyzNF_T4wRw6jEiQyPCr=v!2NdjQAqZnTV&;nb>h6)SfufTCu#$a%;OHm
z)9a)A+TZg%d)y$Rnp%$^Rbk{)i&QStx?LqTt*LaA53U8`$vr*Jgu_denWa)-Q67r;
z+?p84JpV50MbNxN{xg}<`dab5J&l@KxDou~ZHBX^fB>J1daZUWztCo1O-#+Z!YK99
zF#D|Bk|@q0r3TF!%~Bq?F8%W?R2=3lU3phr1%W|<j?)_j%7IN0?dm@!`QmpF&rK&M
z-|85Ts6$7lqN3emVje#HmL00y3l&XN;s`Ab<?`Y7`J#U}RdNTi;9p?wM@_)(SvJ+3
zK=~Z_G9)GC@hk#=hp<k*F5CDcj@Rgnx|xjT2RU9Ssi#UpkeBw>S`X_xq<)WGDuIz}
z5m^b|hjyk+w3GlFb#C71ubydkV<{Wz1!1APxu~(A(ZR}se$jOE*(u@XM%T~K;kNpO
zXeF67LyBBoarb8$;vRsH9#9Jpqn&x$@5v=&AYRPv7FvEk6LxV@-hCR8WoN23S^m{?
zM*@OO>02THL#+CEX4|+S@Z(G9@>&Fbr5u1B=kHQSWQ?_yhO{+{_)<*F9&+Qemz)lc
zmoFtoQXnNc6)X;(9!6SI2RSk(ixaGxq`AkHoC$h#3|7FpRYQLxJ`=5n^TxA|6mqb)
z)~|fCO8(GN7e-KgDv0o6c5wBl8vu!N#pyj%iOXG8XBkX;LjWkw)8u9{F!>#>A>jeH
z-%^SseZ<QjF#vyW<A%Uk>GaUAhyDa{r2sx^D-VZ^OqI~ydt`98tt8oG^9@}H3s+Y7
zdT1<fM9zrn_AH?$5b#^Pivu+mzFy6rcF)Pp$`RH188wwYllxKCw)=dfZ{=TaE=ot8
z1@PWfODw<fhv>veJpN03Q13<CjHD94k@Cm!VlJPR-zc6d>8P6OsM>3}qjC;WIlfEo
zkt04EAr*aDJwGo`yQ7Kh?uHh{%mHD8S@y-I`57(swwMEw$&+jv451{dVRgp7IQ$rG
z2KDOCl<7{=FR(GO_b}q)ehGDR$F~x#w4q=c2|j?v@(_2hAenMTa!%q3e*LGtgDSUg
z+p__P&G}azPEA*z!e)*-ehy`&6vPyLc(26>JyTi*yX?yAPWDNSzLiFt_<EVtY^A&?
z-347#syD>vE;bz1GugbGs={=_<Xil^cHT%1rX35$w2*&D?B;-#Iroak@|rJt9onXP
zdUcM*7DmW_KEfviMJ>YW*BMeh*_`ckv<(s&G>ZA;M(O1jhV)IS(?R9H)!uoo$212i
zy>!G+u0EPNI2haoytP~=)gLgeEX)1FdlET$+6bvyIJvIK`d375y&FD|Sx--pB%WE6
zCG@$fys5dG0>Bl=5O9jZcP8i`fE-p`oJo95s$Y@VV~H*B;fG@n&C-5-{aISl`bkM?
z_iDAEkV`#fO$~Y~s(SN|A94%CV3yX1!A9dlp>hkIj1GTGOJzMG!p%TT9A=`okNYb~
z#~bfOz0@FzB0equEq>tW#z<2Cc%de+O|uBe$~9$lf5eJ1hvRF~yfE6|WY3nPJ)KE#
z;xb*BJ_Z@XEC)CCm^sVS$S~6~+PuQOACw*fN}hRxj^U7g5HTtKGHh05j#H^RkQ$nj
zZ!UN#h>WpzG4_KX9-SB~7J)NjJ@20ZezzLD+*hU+m)Vzeag!+Fo_m1qGz|wRTWlvx
zuX<%TgTq7%?wZTb{k!DpX)HadikOP(YoEL??xTI@BRj`S&CKANP{$X*{M<OYfegdL
z?&a<f-bw=kfGuNZ?-HMo($lR?iJ)O4zGwQVzcbK+;!M#rklGvn$T63|RB5lCx}-43
z!t}J;anCTkS?O_C(Yp@!w|k&d=f=XW@{TCTv)7%oBy?oOdr#gyRtl5cVd17G2ps!O
zMnr)x%hGEVEE;n2Y9!`8I}zZ}??*k_u8ipXt`r!Ah+Mn;Egs?s08Emqw?2}ghd!WA
z9;_~HHCQ6+PM#oo#6|>8008*u&LdQr<2@(m#jwM-H<{J2vslT6InrTjc9A?uRvGAn
z9K0Kbo>XC1ZT~qnQHk><9WhN+o<iS(4kbL(>BO7oRk3*O1A?DD^hFpVPcJCV6RV(+
z-(n<P?*7zxSSNeUv;RC~X9w_mY3?b&kboGQE)FEuCKm55cK##J@hQLcC<wsJE0k;<
zO$?YZV5bY=qn}c#mt+48_K<HkSn3a`yVs8V!rQjho4QT7Hb=MC_F#a1DDBS^UZ<ft
zs;{;*p@5kaMf)=1nvh?2P1vLek?oEWjzPgsv-I!cJ<c_;{8C_^a}nNgS$$2}xBCr|
zL#7^4ClYt>gzPK{HJv`=p1%nIQ}X>ZR`~iij-*uey9R(V$;qREM^A?A16hiKs{)a^
zhq3Pz{cB<c#oJ+RFUdmAG9p?N(&EJ{6I8viQE*o>f7Qs+WnkEo)OutX$*d*(&S{me
zL@B*3+&;hZ`R;B4;v>EiCqEtcd@3obM8x>sQ=ue;5S?$bxO!PpX+cT4nEfwcqJp<k
z>^BAP=mMq>V|9l>&;~zsbgrCgY#ayA{n^THx~`WKr?LFIZ(M%!reu;5+Yv;2uMWH=
z`s<`l{n4$nBud&CFEC5FkK<;HX6b9m?h>_c#)noGM3{lbew;pIb9`EhWO!mofQjOL
zZ2k~mq1mJAMLM1Pw;AnTmV##OSTzb8-EK4axf}tf$nE~%%DW*aqc6nYvp?+E>iAL}
z)zzxfBjX&U#G!a!#f2Ef!gNLQVqD2CvIwRISh8TMOy#8^tuS_vrh}W>w0%nFrtbD0
z8wM@tB;jW#_@7dnn;?o&>6M1qvv|~rS33*EE5x3_LpQbG{OnRIvaN!5X@rc0@@n2T
z2yVNfdl)S{QPFTm<%9R9YA-ok@B0BcVx;QxWWKCe-3+n=w(BDQPJ(&7_$ZC)%su5l
zxY`h_^4_@<tO{_qm6}RbB%&|B(yibhqEYPTM*7l$qt?f`sHUf%+JfS3PH;1^Js;yG
z&JQ-1J<on`Q4<^yaxzxFY@4uYK|JN?mR9jT1<}KOna{1?d(0t*Hk)f?jR@4|zY~C>
zVZpqR;+jjk_q4*%MO<5i?y?HIa;r$Gtg;}V=w-s+U6nA)7(o+`kHMI0C8aTJonq-d
znKwW5x*tV)PLdFmm3^P~e72Mj$m+0`F7~7*2h>6BD+6;?JEQewMx;ENb=9hUD6>E}
zbh`<J6E;5F?i|p$@QBWA&de+orfk7)g@-hT!542`q$l96H_K{YsEc&(#N|36KiKHg
zX>dmqD0CaRu(@o$hF)#U`u$PXH>L3wQ-^+gEaRX5O@yLPfa;Nm@jgp+@w}NPDKBp6
z1+`mu%4%|g(#8XMn6L5=^N&6p71<#KZ|=>!sD$qxvx|Jr>Ok9Tcn8Wo+Jt;Zy_E$8
zTwIx{DAg^GT-NVVnoJNF`nfnAVXu*~z79-^uIBjxhY|NJAHc=IHzN5yrazZk-K73j
z!F{QDk;z6duk5-m@{mFcebbg%h=2Zx8e;Kh*%O`Z)S7_Av>WuYd*5~a+m`g9(%s7)
z-J$8`9WR#_tMT`G_-)f1VK)?BRwKXm@W~a|iId#cRh(kRY+n48RqEw;l-zfb#=Fe>
zoj(!t>&<}@E`QZR)N-Dh-nm)kpkIC|nf0jYD=#^!Ogi2E-#gO#(yBa8BzFU&1ii)(
z8@avII_W#M*a7O<U(VZ0!rNETB1#5Z{Kyo-Gd3utwq`*QP5yHGQ`AD^?>_>}d6C`W
z39DA206QxtmL7$=hXVS4bQHFQ)8bXHRGx4=y!L)|b)YjC)N3Mv4<WHayW4gA`C_EN
zbhtDUw_FNrn$znEExD83FJfXLq$J=fMgk49qZnX$_KF<b_H)>Rb*-G3DgXD6)aRno
zX4E7uY@U0wwd?369XfRdLE^UrFNO~1ZeIr{{CnQ}Vt->^dHKQ6=Xd6W;Mj-Yo(|7w
z3ffVodn6r3wLTLGHX>rxpM)3%v{cw~o(d6e;k-_HRpWB)Q~P5rLek!AtM<<;V=JSZ
z+Ug%`U4<wDJh!&5eFDD-aB_dx(lp9d<GeqbHlWO?^=iuOF(paI$0XvW<!g)MZ#F}Z
z1y=rvGM1Qi)(I*St?T4WrNRX3$$wj@K300hb+`2}o@B6a_@mJ3x^^Ll4m#20kLjh8
z*ON-GljF5WHtd|Mv};$bx;W#ZBIP!Z($E7yPju88-OJx}Kl%(Ly`fEo10ut&ZqjV?
zSa_3<*gUSC>JbEZ{&ouvb>|xOO!RPC1A&t~B^fEdLfF6hTQBLGe?KS3B#@N8zMUu0
z!59E+LY-<&NOCtL41h^4Y@%j6_ej2ECMxPJTZV+gW1w_sNWPo5xmk*`kR@7qQ^G)$
zp{PHZUX1W4;t_#W{c&i)7BD@?0P*DGqN{%QKex{6Nf!O{IS&UR6VG|yGC{nH^Ho$Y
zt>7}lllxcw{oJ=-d8-@D?p{cmqTDMB8##qbjR)Ef+I3IDu<fmBAhTY%-ETZI@upkl
z!T0pk!g`YOUv;d@^27gZ-@mqaALN=NC?TpVz-X|=bM!J{`*W#+=-fNe<dnu*N*VKI
zVrYa#r(N-%IPE@OPa{nwr4Ljq`<idVd!kadO~&)$S=WGZ`fo3B@pBML1J4#t?N2>l
z0y@U1&7i4i1_P;drA2x#5qvfXaYo8SitgOY!@#h>BLo8B4NOmbFQ)G@dxV=%A$mdg
zc|qqbfdYq&=P`Hml;vr`Y`6kZv4=AixsS%HSN;&lQ5S9AV8RcJDi-4xpzCdA=gEfP
z!mhY=ZT`sQLrRh_%hzu41La>BXlV#fmU;@U&rc?>Zy#S2IvqPH1qB%*=GtyW9-ZCY
z<%iawejMu%a%5pH0603C5YpV_Go7!nV4tNSM)w_f3~3tZ=DJS~k)Ku?Ad(c|yT212
znLgPMtFPOM@O<NDJvpn_^iUN4H2?+&N3$h+i+|Z7Ng2F%2F`||Nli;o9$b$Ti(q0h
zv!Ft_z$3L`iq%0HH0+e*{ypY5+S$;dX&uJdjsb?k*{IhxkBB^350w%PS?-DYX7}=M
zT*Z|SRxWFA>l%b7iE$1u;Ez&#$n-N2#u5#IL<SktVq!LC&ytm)p8lBZ6863e1?c)R
z-%{OPR^;$su|{AF6w{wwCKeI-qLk^yV%EKQ(#I;9hyQfJBg|g{UR@+`#Hh%#rDYuM
zE;Bd)Muu)MJ9Hj68!DNM7x0!xE=sS`Rm_&bzcMPL8X7AV!ErTe)b&fDec0#X12t6N
z1qz|Z`)ZJ?`yZ$}2992HbsWu)+k0QI#nL~rxmm*}s2)o{X}Mmi`<3-Xg*Pq3k?I7L
zURbVzwS*)cQlxF?{q!8GET;N4k`V!+vpu$<yQte|9d1hejW}zcvR@)bb46)*rDP-{
zxp{4+psf^UqC&qMDMfw3B4(&>w4rL|27ynp0Sr<(gHV>8#FvPJ>&e#F-)=9MtQl(Q
z1S}02!?2?k&Hk?LMj%Z@BtyV|jniE?EK!9<WhNIq!XXvmi-xW%XV7*F$$L+r!Q1Ap
zMUS@$iptR!C6DX};l9JK1BIqqZ5aH1KNffqmA^oz6YKt>IyYIRB>nz7a2lVPoOKHy
zt8L&>(M>}I)7ZNW1E<>-8Hk5?oaH|7Y?4~TX*M&E`iF{XPvaMZrPpI4V)QS*bD~HH
z2#)KYqh{_~n)TT{2C9AG`YNrFSRpTJg>drl^nCC$JOP-i?q7$&9B$n+&|3ugTDXz*
z`#oNn%;b9TC7=4sW)lNOF<bNKElVS&+9Xl;kLmG1RGPP2vZuIGzMj~J0*XFY1z>yt
z!4o>`$FJ3tJlkad8II%hZko9WP*Ad$G7EN=!*~S!()Lk^k&*<E8}DEwVbRsPc<De!
z_o1^48RwpaSamOPSz76}H;C~I0|5S#*C}NtsVgN$psoJrwJ&Y1!wSR-JtTDZFDXK%
zwx>j0wl9XgZJ3;Yeofn0&q`+n&8LT!Vb}nVX1V|Oo#juYcN9CQe~~k#a;<IV2xHHS
zU-cGBxtHt%;os%*o@PVpYgwAXO%RgffrR0|#CV+i??HBy{mXvx43O2Tc=z6J0^nOF
zp%MTzb#h}x2VxHm%F>m$UV7jC_lBq|6MxwUR|okE4Z>#hz2l%S>y3+=Vup9hxjLkd
zbuQ_?p|qKa)NOfx{&%zgY5h2}rI#BM753_M-$<Wz6Zw8IgI302O$9g^4>A}Q5|B0C
za3ibp{2iu>;p5~Ok~SfFz<vrWaS5K1Ocitg?jbAM1<@4*gR@TXkoG_0HITa@dWqLe
z1M3ZT7`clm3j~=N9W8#_Nsg7e>IeNGxu}p$Rul}p!&6h4CmpAM2q&;WoncNN$-if3
z{(GO9=N81^u1X;7YePn@_`=!;@qeS0;=1Y30JO4i2|QjAJr@5FlBq7cS=4f0^dMbu
zbB7^{yTi85f2xi}<D-p?Z30S<N^D?&F;eS)=f6z|7zNGzzt)6I{xAj&{nsw|uYZ(i
zM=99-XHWe1{|#QKu#5fQ)7QedVX}}ZrnD7p0L_n+>%^0b!#PQ_{ovm;UH^ZblvUPX
zg$X&&KVSW#rl3*0cy_as!Og6o(nnhSUdpyEHjb$H{S*UVsX~Mw13&Uu{{KeiO4F;x
zuJmkETBp<_S3twrS36H8=m<AymCeS!eUI$5PpjnE6}0F4a5~5JhoJA_)3=-<rFHQP
zdcQK<G@G|sVWfVOtdeTF8tQD`EPh_p>g;#y77J3G^~Q3j8c9B!z}{lN9HJHinc}TN
z=`vHgHg8I`e(?TZ_aAE+*KBLUp85N(h==mZx3?23J+9*1j7@wZ|0*EYK!;Spto}+(
zk}mAc+MnM3ABj%{=lMAZek82<;-9_V_(*3!V*A{0k3^-Ritm3h=*I=@V<{3E6LYxU
zb|>QF(q4`_zweD6Dq2@|2w(ubextBcH~(Dl)d*>~J11R==d0!7431*_&m?a><!98s
z{F*07O?U>W;JVqtEXa`mIx#&I0TDd;nV_h>*09z9_&cA&o&4S%!$tsj!PZI^^1tWg
z%ks*Pyk2gOU&rn;cNEqdhOM#SpB(XaRD&iO`KZoQF6&jdkIaB<wLPy-CBz(OYYq8c
z=77aWGgztUu8+b-+DzKq0rR=Q%+L0CHaAVIM=sxku2t;@vmd5|#A;YoXD%-w20z!K
z#2=LD7g<v3D9J>=N#>n3!v`tepjqYn3sNSoJLFM2u<vwnhO4%H2|DFW@()e@B=6?!
z5W*5?ZnQsPF8`fi%k%iG60%1Q#$>mfMz8KVU%x-D_ci4HaGF_~<0+T1P^qQ+j^FSz
zn_z*iDSx<=X3xZEk73&&Rd0e$R?$pJdaU$*uJ0$Wwvj8NBEBX}{4vhpr}49<{i4)%
z3TI+xXmvxZ?8Fyr#cQp$L#o=mv(Q|#{>TCm)f&!4BQ_&f-!^qNm2NfpeXryW;|H_p
zO5JF>xrP6K61vl`O;g!9gh&E^{{dNO9L&QQQ_96EZ^wrQ{wUYn2nZ<#aC#mgBe0jR
zrnL)Y9;fvl^`ey$LGS&}FxE$JT5#`&Qx;>2&#5m2TxpElZ8!a4nY2zaEP^*niTHF+
zW$b_={R=*`GicQ-nOHKx#_a#c)O&za{l4+zhsey%$d>G~vk51JkiE$W+1WdLlR}Z5
znU$S+k|Jd9dF+#U>~Rjx|MB@=|KIQTzUsOZ&Uv5b{XF-5zsB?2=Sf5UC1)3Rl;ftZ
z-0e@FuNAeL)d^Hl?B?0nTss%Mz9+DkJ*zhA1*ZDs9>*p}liX_d;;n?E_Xm<QDH14e
zd(`^^Da^Y_LLueGmWI~ees*|ppPUCovF1G*^Yfk@@5x@gzTR`ttfeyxpIc7a@#!WS
zL-?@ARoXmo2*VSw&#c>)Hro6C?2<b<ZQJvsPTlwO4!MuJclJh_teXPcEPJnJpXY!3
zqK4#eMri68)Hzi?1YhhN2rp1d3FE<89(<U~bx(Fyj#9e!e`5v>uHY6G8AL@5cA<-i
z!W<7WeB&vOsy0fTw;Cx3TPOVmKez4i!1V42q=0E=B_=}~a+H#UfDu4uhp4JAu6|AS
z^!i|N)ttm8-N9_Cw?D4^m$W7|<b8cQ_q9ELEy#l6Y1(N2FED%F^mv%@UqQ&89(@0I
za#ncOPGOi;@a+nvxH}a1(0eSJ*Y4rj5QFOO%qNN330LtIvFvZ0149fm3g-8A-4Gra
ztc37mdDK&%D^}i$eT|*e0Z#kF%fBg=sapw;nsaHAU9Si2u8OULyHdW&orekoovVrl
zBG`^tPqM=#(xg(G`e<(aNl!X~yA_+$=d_M~&Eom2`71qSxO`#ZVqQ$;;vbZdx?0UC
zD65djxCegjH`R?iSaDBz>SL@YJc?(2rh$A=DHPrG?xO<dC_=jM|B2CDO8jILWGs}a
zTkLXO_kTn0k;T;O31Ky_i!r^-$0z#j$?+(zN04)CirHqFmhHnp!;eTk*<L9R{C5{8
z%AY8oN>vEE&%AlB9GBuge6N0^h|;iLyv;IEIEWi^ppvrnT8Vc&pgXx{e2-=fZP8GU
zpsu>KpNZ}my*`F<G)njFkg-_jV?T%XCG&M~Hm-!T;1K;*LB$a7k{Ob)ST8H2J=<U5
zA?M{s@5>d~-XeGFw6Z1plXXWq#hp6NVH1_u18$+8b^R8Emy6tXf;LI->R^bRyiz~_
z-0d^cdTqu;+PK@9N=pop;odl8M&iZK=y&t}`}hWuQ1$VlAQsAUrS*(qo$yIA_wvI(
zQHHCnA4-OJc=&WxmnRUu$uZ&xGcz;gWTv|cTFHZNV~RDhjdgWB{q)qdvZ8LT+ubNn
z^h}-IT;ubP&Ds$$eEpJMTe{ZPUu=z_R8Y!cHeI<htfoA|G`aNE?3nL*#%TY|vZnfP
zJz7QV-F)#0w}ikZp63LR7DepW&y7=#WAVvC-G?*ZLGbCu%v(%KDXGb@$k}eWcsXLo
zLh)6ET^{(js_*)TMiQ#{OH$&E$~=-x38YcEC3H4D_dHt6AaIL5#Sy9M<d;xSGCGn0
z^<8}U0C`n+P7hN@20ReiMg7!cCVfqf|5oJP?aFsVX<Ivi%O;_`y6<zq!|KNx{qqol
zPZ;wPdw6(Z3n%j(5pu2dU@Ev<0k<%4x7h3Jhe$#QzHg&xs23M*$a{VHoa)Bj!JE()
zRUW%n$2$7xT|R|Ycjvh!85TGWGxQ05f1`8d$%GLlV5n<v2fG@rys4n>rbT4MkO>-G
z);Z6)XZ5$I#r|n@UKE?f#)cHsTMOx8_tEzsFcDKOCtSD-3uf~CiyebNGwVV4G5+xW
zPo$H~Q<uIB@1WO1YWOUw9Df>xzm`7`@p$_BOo@eXz_6et)3%>`jhc&KA&Bi=Dn8_`
z2sd-YL;9q1XRo%xS()bedJqp-d?ke-?7Jqb#YgtBCav_JmPRO;9_k-Zv)sYw;=^Xy
zoS}SmOY6-xSd}CD73-EWg%8L=)43Sl%i{Nx%TW;B&AY3*XE<cNF0KDn$LwuFDx3BK
z?i6ADUJkqgXV9y5p;F3HZ_@W9+N<RQjUH>$A0Jjz71a}eZ9N{|zWX$9RSHK+@&7Ar
zz7syFe4<wTfG*U{a-D25=bH@_0N?F$9mQ!)x4wdtb%Td9E5v_2w9>&yg=-U!n&YTg
z%PqD>_xfp-$F=nj?U3<u;daN0coax$gL5JO5**nJzA^E7?A>vm{j&j_b~wpG$ul!~
z`o}=h;=Fn#phN4R%oUQNXEX-(^Y->z%740>TJSAaL}-vmHHC=n&d-ez3M%T0j4B$K
z$zcbK;p`%}w@T@SNY(Z_bKw~*%A5A>6UP^lHUCbBwsfNh*`d8SkRAUknjaB9Z+tpy
z&pw9iU{GFYodAni(*T1DMGV{Aw$b-@f&3yK%@$4Y$^}M~i;+0Zz=3kP@r$2LI<4kh
z=wUbwUjTCyksfgR*I97#4-my=Fk+3y{P|L3F9E%mVL75r^_b<C#g)TmbcfL1k=(&&
zjhImakh~u(`s2{8)@T#!w#2mM;Y5bdr$21q8PUJ!tqyq3+44BppfS7ii4-7*Zh(6n
zE><Yy`LD82vg2-#y~gVn<KG+kgiL`UetP{99s#!XheoP`jjJ*~pAsI<*D9v(+K=9~
zok(AQmvn1bqIS`m^6TtYn@+$Jf5?&;)6q659!E;BTBU^#gcbx@@W=LNdSyeev*wmf
zD?IRL`NBZfx1=V|_RITc=ic=UENmdN&OYB17pT(7UM!PIea0qq*Y!kW7mIDizfY#+
z4(%6pwuaT_zavd4@q3xeKV7BMC2DcsrF{0(+}R3ThS`h>Za{6-D&cNa<n1lt8H%pW
zJ@A(rP@e`*m&+=jHy<_X%WPWX#Ly?oTKLFu^BGS*58rqv*C&HlEmyG*lV5zjMaRhv
ziXz=MItfnx-R#*fA9jCy*YE)~O|Oq$t&GS1o#D*F&x`0cui(6YXd(7un-hB@n~!V~
z=Iec4Cu?{)h%Ha;;&EJ}x`G!%U7l{!4t|C9+8l0WDgAFU|9S$!wlUKqvMt4L5aRd}
z-sLNQ6spzMQP{>tMQFBH(tlWeyIUwj9f-~_MW3RgqL0=MELPG?px5SAoQ{#v%+Tne
zP~?q5M3>wX5EqUQ{k!$mm@Aw1l*x_0?j?nT9Mh(_yi<g+43zCI;m4?-zbh-faz0Ye
zD|D0nI2xtp<|0uhDthl>_b3)>r8<dK3gV9ZJ0H0&1;M4Pd3NsKKXKnCw23@Rj<k9^
zO-Uq+`}QAHYx=E9hnfooWH|QrC<|m$*We6SbxR#Pn~N~MP}wCelJKqj6ZXv)9M7Ko
zCCq2s%Vpk7`OH>%lZ3EoLd}!r>rb`0oT%ec4!J%+pwy4pH*b*{zkI?XR@5$HOyWTZ
zQL&?7Z{PF$1bLFZr||L%BX*@1N0L7N!xFJ_Q;5|*r$b`;z>dl=vu8_*=?s13EeN|=
z_A{0y!&1w?7R1Ke#l^+t-W>lSz-4W0ED=F>|4zltm0m8H`(z~8<OBip*PL;KPPvZ*
z%-!8bCj6q_#YB)XGBV<kGVLIAUv($Y{r>&?<0{?HmX;P_yFnaIf;#w6t{f)LoyX&F
ztrz^4O?Dp(_k*7$G{Jn7pWpT|&k0Ac?;Kjw_iMHlL<$RSD?lsTRz~T57wM2N&fZII
zlJx%Mo`e(Y`}vQQqJ4A*C2M6Uel|7~r}8cSF23Z5OQpe??F($|(S;5@z7mrxq7E#`
z6Me1OD^ALpAugwSg*>mN7~IIj8ZvB(&7ID+#Y=qpN;2$IS>E%-*cdIW(A$+Srup>c
zpX7<o7I2cj)zFQwHX;?_(;m;(*tch)en=8H2Vsj(C;t1oNo_Pt8;3aOu5J(#w^<B3
z?=FRR#M^FDng0iCb`@4X5oaSv_pCO}q?gUN;KCghdE$HP9t-YC-%|-8Z5VIt+wpg`
z`&zJ#S8rofPR(-z5=Wae@>%P|p!(5$KbFKu^dJ8JxK&um>$O0ZT$o~Lc%l&H(U1St
z^~<W^>+99G4uq)t4v)0nO!!wfw{(^_3KM@drZfnwxnnKt;*Za;V}4F7&>dESXWHkL
zHn62fuh@I@>ohcMTH08OHup`IUO#<H<7%WngGu=G10BK?tQw|;RN`yvyB)*CL!l&x
z5HlbExH*d+nyTGWRo+0YAfD7kOW&bOP2BuMk}%3>kJaH{%3}{0(x-J&GDDrGh}Jq^
zs}$b6cBzUZlaf>$wkJ@Wyf{yit(T@=oTi<1q{StY71w7zT>U00qkKNT?l+xb?-d2$
zn{Rg&-6ncWNdO6Dg?Pen-PVNOFNxQ*2`r-?9{i1gW`})ykT!VU0)H+a_yl5uA5%Is
zHfQ52!Fb-Mqx##b#*KY+bY6PY4z#w1f2@+4kCQ}LEeWj<aw!BCHS(#cW|(-h)$&PE
zy`hNxh1+{8>nUBxvL5qQq-CA42r=lvl?u9Gc}<y-%APMJiY?k3r6c^p_bQH&1JIa%
z=njNm=h|jV6~b?Zh}JqmklU8y1D%MtgPR%`m2tyXIv#W2ev;H)%x|j<^;{z<gC%18
zMuNIGFUT%L42B8U=A2Fg;X|*!TU>j@b41|3*>2g(JBr_KNm21U*)jpY+bQZe8PWA}
z$_uZubUu~Nx-+SGyG6Ti$5yqB1rfgZ3C&6Fms65zMcgo%q0XVg`JLtSdEU(9{{{`h
z#%19!v-?4_RXc!!JoX81cECPfv^XABU@uv(K|DuV+kT{I(;yRG$4bRefc<_zfYp4^
zwzV2&zft1dsc+J2LEj^{Ziu{Eku-tb0P)7<86O=}Ezh7=XsVFbHg2_CWdp)5p4tq(
zuSohaE$yO1E^FT>L9o(G<X$_n16`t?!B)hO^yHISi+yDf9EMX=7Meebmz=ez^I;}Z
zS*!fM|D<0-1mUE>jB>)L5?`xOs<ytaeg`s$l!}H1uN@ykYhAVd$WQ=tI*0tjNRDv)
zcFW$PJV9<8X8FfL1<-hONuJa9s%*kyk$bJkj+4o`zCKk6L=GYw6uxC8IkT-ku1jPY
zg6SG1h{0?$8ivVWzFfis=M-;bB{Rz{1LvJ)uK!l=9s0+7#`XUcnf<@j*Fzl_W@b*#
zSCe<=n?06)M&@4Z*a>eYOsYDz`}L<M(u=iZs8^lxzniRrU8Bz05HhPhn%|t&RQ=Gq
zK5hGRH0A*(6F-D>xbMb7uP=u%m;1|Ia+k}bM1+LeW#eEPVfMR7F^G`so_xjVSARcU
zMDhpbfBCXX4?kD3vx~Mhs@hJX7uySGz8tQ15LI;)`{1{hVu74%Is>o8Z){=$J8MT8
zr>ChFUGI}({t!sOQ5#}1L+B+ux$oY)vr$pqT3l;>i>Q<BCg-`?q0%2`SGN7>3jxS>
z(9AO3_M)Th>U2)bX?lO-v+Hd(qjz&|;+O0EAs5YvoPfP%#Ov3uuct65>p?%B>^LZ!
z-PWM=;h+0<gX0oOA5@F<tIe;ZU`Lw+pW&#}CKw}0^xWJWv+q*q@AztTpTV^(*9M;K
zekXXt>mxaghcpxHXi#dZ!ichM`E+mLY^QEWL_{QT?LM<v!)v{OfX`(5j*k6A{B7TS
zkmh6MAZsschqLl%RvBqsVOm38xKH2yrFh2-11AcwnDax;Hm`P|7M~)oHh5V?Db*>p
zmgX43$*i8pm%hfXB#3z@%n~OtnOa-=o9;=I3IQ=)*N*KETI+@POl<a*^5pK`1LrGH
zrLba4RxVl;!5On$%Niwbaqer)r_PHxhnS$%>z>9bp{VAJ-q~X9rtP4=vbyEhQ(4({
z{1*+AV<nmvH7iQ}ATiI*HagEu>Xc|qO-`zAa#9cs`gzAoe0$huyp6-ZQc+00lR-^G
zW0d~KoXqL>#^T*Tq~GGsOr2}%Zlf+wWkVyM``Vw8Cio(?Q;MB!+I)jNOQ?;QU0v9W
zpQx&7-K*U!2@lY%)9v4Ir{#dhYNA-ALcW2yUxr6cnn&2zPXhU<ZhBWfz6A0Y(o7*&
zCsXwI?nRIp9dI{og=NY^2b+=Tr%!)3!8=aD6IElUNO$g<?(OdU`DVQ@O>Ck5Fp|dH
z_iVuoB4FE>>b1S+U~lhxI%601Y9KDY`Qq=SUn6<A<79==+~j17Z9g?DRGcA4;APmi
z3YP2&b5;-_t#CULro1aocM_g$l09*3@pyT%(p%(Uak5Z_#rB4;V^eE&Losol0;RAk
z9uwTfpWO@T&Bsx=cmJ8Y_~!5@)glBx0--K(7FK5wnEq?%jWsNn)><JU@qqy7G}(sU
zyO~Z{+_sY0Bpq2`6?4iS^ty(iVI<75JK`kA5iiS1xkwfI$WqAK3JQMKR@jT6GKK;h
zztpXw;TTzKr{4Duz&zJRC9S4@ObbDx;Zngn=f|64a;G)P8s%jd8)C2wsf(7XfCaCq
zpe>!;TIabV>8XAe%V*CHqL~A=o?UE}SKr?Fa^TxmS$T!pt`6C$=?R4Un4Lw@S80}v
zacX2OWesIZMGHQ582weIQ_^vD`gqXq*|Xl<;DdPMvfRrx&N5w8=Ec-><5Or+(Sy$0
zF9kN@<Kq?b-LzWXzo!5@O3@3*h^}QRWZRKPF4{C8V6HP9FZ}Sfky%IJ1^B!K-JcMC
zp(J%}ZI@q|uRbBspT%4U^>z1y*eOPgJqF9ael_=9z5r9AsI6^<GWYx(A$v9xavmL`
zrAol6Uulese^k}{>hk-+z{3G3RV-9hO|4GHTwY%O>C?#6H;Zk4xtG5<bImY2la+IQ
z{rxT-7aN9r-l*eEaChDN2sun->UE~5W5;n3f6&#oMaXt#)6eB^67ZWU<|BSgUTPIj
z;`ROqF&CMU!=fJVD8AF-+RQjZTD}fTg@dgbJss6AjNH|{s~%CTYT{vj+MGhNEH)3S
z?5DkP)ci-i<jMWC@w|l~TK9+^$ZVnr@vUC=uT%){@|Mxs;p7#OL|1(KEj1P_egDc7
zwjIOb_1tgAS8c^7_;@m6<&Sdu^Q+AgSL2EFK(tDo8&m~fO#lF#ZsjQGk|6_@a20d>
zbVotLcC@1YI5k}v1ve>eS6y|)p#BT4qJ-a8KJ)H9n`0$#KfCDF>7$JSUM?=nglyTM
zuZ^cREcE!S*x^6I!mx*q0^y{;EXs7bsNQ60u~X#821!~6A{S+vi^H{5d)%=l`p&NA
z!J%O`bKWAxH-Yr=xR`or6-YoPGDAT}17eE#WY*G#YB&f-Y{C2AN+}fF28A<-5%ca0
zY<)ID0+W)Zd2iz4<2f}dG}tNXUJXe4?nBs=*iw2wa2loGjsIPk8v0E4bOnusRoB!U
zG{J&W1od@vD5-=?aaf_2%Xf9dQb)ZR=4!E}xch5C&U1YIIxa4*ep0(nkjk`vGTl~B
zS2wCFzu5z^1BVSAUB*&!-ld^wt?F;aS1*m>692r~QuY2l5qW(I!Y|=Sg`I-doPf1p
z<lkDaPQ=oP{rFkX=<He0X1|*_U&J39q0U2fN5+3D&U3flKAB+Pa}U2q`(actYBudD
zIT{nVe;aa-g)<L<>c8G>CXyyvS0TZNECn#7;8@<TVPY(Hm&ysKKzP_P$&giB&KY+5
zGI4&5&NSlT>2qz_EVjJe>tbJ|UH1O{iiwMn*Uof}X}|i=QC*El7{TwOwx2(L#!{Bw
z<f}g3&sH_lgV|Dw`R|;iRJq}2nz@n<A()OJ^yzHl709Z%JQYt&2^wGPS9gd~5rR&;
z-Qvnj37T__Q{dcbyP=$_sz<C5+ON@4b2MhH_M?T*Kp{}}^=qaWGSk3fVa-q0`nyf<
z`;QjEe&Bm*A0PQ4vUhV3m4@!C5eJkVhiNc)gQEc#)oh(zlWnXP7Xv<M&pO(;tIM<A
zQuVE3XFgS(LnB9g`J!Xe6NGIIP=sKvuVS9y7;hW$HTs`acGkZa#X6B5a?b+U*av*C
zO!s}wp7%kJoZ~iIk&}aig!j($a#wVJf4}Tmvm6%}m%Woy7O4NeyRR~Z>>M;WPW{c4
zDeuUa{q(i)xXzhsJb$vKq9V&=1q5|*U(h0!Vy4Yc7%^YVSEMVHAsKvWsH}{>z5-qe
z-o2LXy(Z9hB8wfc)=_GBI5^xT=``v*iI)e}Nv^Y=_*VG{pPbuo;U-duWS8vwcdw4e
z#M-}AUo+=SUrdmiV^WHA#ya?tqk=CdYheC?(Wxy0R+!bRsgASRSZ+;!Z5Yzzvve7b
za+xTLEUH=W!3#tXe6~>J3LP$1VWO3Ns`oQ37rmLj+hg)}NvHhP^;H0Mw{Wnt$s6OR
zopYQfw_OyN9W@vh{kGgx><fnGB?F9~?(AOO2|-`~X10)hxLY3g>1e?q`Er0#ihDhH
zrOJ`XTyXcK>$ydXU8h}eo5X54Kg{l>^eT<`N|}!)X7m1>vW@|CEdp%$4`Y<_-h;#V
z8AzCA{B`m38%*1LHw&J|Gx@C<R904=fy4nlmiGA>0ZuOb{McDC@LYh#>SDCWW8?30
z_7zaxfzG|H-t9ySVRX0qbDqXmwO^yQ3w6^Um<Q~hC`O}{qtA-KhE!?q%jpc1a6AqF
zBmQbPGanF9%MIX!5CD2WefOItWNv(1<mJx@ukFcfad#`wETcptI~cv&G_}|<NkPq4
z-{jMFzT&D=Ha^`Kp;~sZ+M~t|j*9l)t}OpDQkr_W@!3F6U!VH{vi(eEuE~{jJPN{6
zWLjetiMY^|yYdvuSj%FT3+8)Q^zo6|W1l^SqExcUIagSFz*#HA4V>U&?z7<4fs{(B
z3&C7ZPEHo7ee}<Py&A}zot+h1^tC1?Qh@%X$baW?Xyg3y<x2+#2M-SqTif*-Yh~-2
zPh`^B`Xlz96AzozD{{Ds_={%i9dw*`pAG(&Ih)`1e?+FMug_JK<F{c1Y1wU@V@nxc
z>-_-M9jN)X!*824IvIi2eDPv=<V(+EXa5HQ?0TxrZ`KDuS%v=1ADq%_6G6s|p6&sI
z(&~3)5_-?FexQ(m@!(H7CG+>|^IP$p56pV8;T<?}r2;lVS50UiCWn=mCKf*?jFSdi
z=A0~9h*M4i|D6RjJ+}R3ffsyB#vo@sQ@)zvICCk07By7|5$Bo4=coOO9o-VYKL7jh
zPxo|NE}6_wIq0rlQSmqJHWthDzf3XLU?U@=ssS02aepb`zqu-Y{#o|=AR2aDgpsiu
z+<7wHpQHE9Ns1ztii(Os#((^5J(XK0UpcY3;n72GMzN~CqqYhzTu6c-{EUc*s6;cD
zi9xxZ&k>m;^F+kDn;3p(_xIBaef<_!crZl9dG>f~YbzX&bZ4PejP}BKJ2SIvU|;|+
z{13Ug38K43>~-;p$kRqwyAxZ{dtN?^ep6tuP4q-H&S*d0g0QVB{IaUSC881Nrl+T`
zE7DR;`)B|j!*O{jOF3X!bc)pvq~)3l-pC1eN0OzbrGb#<Y;TYMm;}T^>$y`ke&>Xq
z)jGSOR~0?)8$-|qWS7JF;faZfAxB~%=#=C@&&%_J;i(si&T}<}`KfPuk{Ca5YJ%}%
zI>s-(5iTAPX5u^7ocQ*8v~C9<_tIlvLvYCeC0t_$9Q0m)bjRiRqp}lpN5dw@WtxZ@
zb1_MI7IKufjyb;k$OJz?_zbpsYZI`yM}O2rf0=uQK`Q&qUm*b$DKmS1Kx~(QFQk37
za4X(5%lx1@*Tq3<>>xu=7}@GQiq~<qwG!fcs-iO`Cf7m**-+=Z-cbH{Y14l&fkDkN
zcevNr3apiPG%Dlg=n9t;y0-akAeg@IVS<)g5Z>A5uvQX<N&cqnK%|(3(V^zh)rITg
z#m`xZi3j9bYtP!>oJL$s{O-pbG&43hTcC$e_!;dDQJO<C$Khh;64T<DKAM)kbjY||
zarc!VWGe<h&qw_HNC}6qgqNppqbB|L=9}-_xsxn?Se~Aqp2lmSx@nO5k>8?Y1+2lK
z;}K=Bs8`U}bFQx2HN@CcUH~S)8G9~v6IA4`bD06u3z_(;S7WHoGjr5}2eFKy<j@_;
zg)Oxs+coh!JP=84;`1XT2P^UXvWI`FnL;iP4i68(G<aPZ%W^MqAWLHVH;qLgKn9=|
zjKqPR{~lrnKLfI44yRQ1#Svl(Toc(!za;7qg=3q~KbuQ<6jwDg?AG)!Nx851T0+5O
z=He=?0tdwU%z7=Tuv^VFu8JFPgKFZTMTb*=dL{U1e?o8JO;$8lR#foaORO^X>aVfx
z2|lgMt+s%5G&f%i=PS~SbwuFPKX#%uaS(Vb%tRPDm{oQp4g31ql#7bz(IZ*6r99i2
z&KAeb(W0@}uR-L<P-YIQ2a&R>buaF>mFlyXv1K~N063w=V1B6{HCDgl($hBpO06pA
z4F+WbXKvu=ktqZ}{fnmb!7r1~@Ju;O=KImnCt|doIV~+?HHH<nwLBks)pMjJ?maB6
zmJ^O5;*7#q#k}5jFM8(IP4@;GMca6hF*vUInE94_zDzdBiS!ma<949mpxpAM<Ffs<
zW@p{C1c#+XB0upL?C7tL`kLdT+^;Tp4D$S%_#BtKV<shs>qyTD&_OI=pztq&T@1K#
zJkLCy3b~rHK#f{Vj*r`r2HNey(%wUs#JvX-f8jRydwO0;J+cm6z=hzm8XFsflwV^%
z(qOy|o{ZSz$Jr7(C8A~k*KK<G!$E0thBQ#+H~l_*Bt7SCDn@De<2DDLyrgOwDEHR;
zKk}P2dj5{P3$Cv{PD-j0AiMAf9}HdZAv@aqPqr*Ds44X6Zk@Bqw#)YOehNjStyguD
zrTq*=<FgHpAgIAEw+vv$x~7+K%oV6(Z0A5@3lDhE*#c<oB#pTwIzkNjFa!*L#3Lto
znJXK#<%mI5w|ega3ZVgmz+4{nFkk!fQTG!rh8kr50A?IXxl#<%jn~AKk1RCxdOUd%
z)vbo7Kk(K6C<K0TjBqs*sKL>8>H7d3PC1paz#3VcecU;H=&+94_%5?Jl^PPB{OB`k
z<r-zt;e8HOL{OS&vP+IVwtJ=-j4GyswZ1`>036Wq!Fef0)T4*l@tJs7b=C{NTG0ll
zS9&5&A^Rw9I*SnN)zI|f^Xevs5H!^B*GAA_IP0rG(E!us+(p^5GlPLFvHX7vI=h_#
z9+*w<__}q`^_Ob)VKaJ>c_MbDK^R_5<l>>mZtSE@kR2+j%=YY2h3sOM?^fa$sGV6w
z*7gKdR{!+=<&l)n-q*5>(_ux@1rKEV4b*!r8&DWVWNzT&f3~*(wAz7zhmE^r@_hO#
zg@A4XI)agbPjN*>+t;tE+-YV%2R;c3`$}l!>W?ih>YJMCYHJtROb!uJU?BoQ2m#SL
zLpI1*D1-QK7)a5QQc~T?xmu>CYkn^53@;PN9R_D^O5eSOxy75y+)!8CZjfQ{VzC`P
zx+%g&-+CRc-8WiWTYGp&$*CbCdUHLm%;1T@S2v8U-+om~L{Qn_Jg49WHwYD;The`C
z9k@}E@%;I7Fz4cXRzZcKSu_gxcvX%MvCx8+7Jt;S10eE2&D?98>z^a09wObvueOv6
zv=lLLiHhnQXqHx0X>d?hRz6I(C17=$%aQU~1O>aJqh@1M6QF`l4J-0mS^%=>@%Bb8
zwu3q(Dd{vS3S}=sF?~RhqRlf+Myi2oYroo^oJ=q7=74|19VrE1iIDXMX}|9sFMLMX
zFbR^-=GK<e>(}=v(X9|{?0A{x?PFd%`uj;*(6@Q9PVsVRmxaZ#-5u;4CSq~K%R1=_
zUS&_B#1YZ^PBAaiBBNA}!YaSH|C3I5kaaXTSOsP4rM<tU_Z;_2QB93thWe?L^qt||
zAfh+Y9xW~#fJO}5YreC}nSj}`lRau43ffb%K)u)Iar;isz(J+}3EOU&(Ppud%+}!e
z07|`FNO+9)*U8C7OA7(A@<yixRBUpH)yl6}0P_}`TrHH9mHG6=efF}TY!YBBfBsb9
zUcbCJvIxGgg`Y8UQjtXGBP@Lc(9?}zd^)N_uC~){LBkx_Wj~BKvP+&@9I?B*J0yK{
zoO{`u%ODqgIRy)57dyRe4NiD3)-D5h$+VOI(@0^ev-56vR3H9hDW9EbcOb3s2QDXv
z9DiX3w5BjctauW5v{@(HQy?#e3F;dgH(GZ7MC8KX{!#H^J{&9~qxdQ5ceq9xydSQ@
zUTf1kIs~HoraFpK?&4WvOPJzB`h&2#y!&zYtZoGNqdVjRo%f{1LeT$`LQG+Hi{}MB
zvOfJj%;p`JyhAJyHgRel<GHXPv`+t?k-)(&Wo6^P6i!<GZUufOdq})gl4Z<hDjr02
zEbHKDR?X@|0!ZB5$R3)=lGLX#e|W*Sfmq9<WhJ(I22?IPeJVwQR&!S0D1$StShtIA
z-C@3*f>WnHb<H+ADTiB3tfMf;=YyDwov%{W8T+Tb`pRzDmc*f4R`KD9X0FUGo;-w^
zt)rwtn8c9pt|KAAo@JKj81v~f%p?*^ww{IR)6cBRf*6mSgdU54-HCzEm7oxZ1Hd-8
zWfF4HZ?V=9LYJp4Io(LI2+KO^?(Wv*X#hpEOu%V{X>)B&&GO$2;Rg>Mbm}~ui&OfN
zZoA;t^?vC^V&e1Ws-Lm=<f+=#uxn!w8^jsRK^@S3wut@!Qb(ra2Hbnj89drv8zCw}
zN5((zN>k%{TAg}oB79d9r_$boaL~G*ZUT6)%TYD{J3aJU`!7_V=ZN%D=!-Mt80)OI
zEJhHl62-^O&dr7qVJ8b2VYoVwyhRV=Z+U)JeO>9?lN8Yf4$K_vTK=}(3~m4ycf>~M
z0#LFQhBa2Zvkfud0Wf)J(ul*$HF)s}{f8i36U2tIWF{H!1+RFTN2auVQdoKQ_4VcD
z{q9*wNhEWP;iqZZPru-X-qCkEAFIW&R^NUSFyB7iPv`|@|Nf1S_ngD$IeP@47XVk9
z#4MMe$D*&N=e6-S!%{+0-;tAzEUUL3gQP#J&eZFrdw*N)+s5Eum^6&vZPPQQOM_Te
zMA`5!7TnWh((G5pY1q7YLHxleuM=j(e(tnPr=cgAnKZh~n76O9aTfr5Z%<F0I%k1o
zoSx!a+({lTbKW3yHrk|)<{<XwYgP|>m~(|}RpsSFwF&VHwdtmwv%l9VnRM$0k(r$K
z__mOpiQ{%>cr@VY^pj}{sR<*Km}K7UOpjEM()YM0F-fen>|LEL@JCG7SVwDrt*r$i
zakg<cn#uosF#!IhAxF~dH6OK<-=WRZr%yo?1?!yS!?Pmo&PN85!?ja|btR9;1=CcW
z7g|o{;MYi8BI^0J*LshSpYCTmynZeDX3bulp?Bcxq$Cv~qoijkAf&1a8gk)l#l=x}
zIez|Q#RgNAt#<R@-NB;+b79rgG+=iHezl-kZQgFIiUFK34ulO5@~PT@lsIa06KA(w
z;xNYL%x`UJ$q77+1yNHyOPqVUpPdc<F?6aSl87cp+HVC=qt;e9t~ZNV5Xy`FJkOJ3
zxufpOX|yYYnMhe-g~*EPb4YK3X7=X#Sf5;t)vU$kD|8Di=ulX0VN3O4!|gkO>nr9X
z%z5*{Tyi;V6o;yITI?}Xsk7QOI{M@EOR2>ajg~ia2a^pUSHGTz9If@if~|hTr88b@
z7MU6`dC)4Vwz$kHGX&Bt^WMo(_bkp`bl>t-v$~F0nIQVgY%II`LC*gu2j;i+K`v0o
z;m}4O>uH_}H+F;>-n~Wi5Pj9f;h0?D(ezDie^;3I1TqxYPHgR7m^uoTFO3EHad$2x
z4*<Mc?9bUbXHLmAdenn{(u*Lp^}4Ti4}A7{Zf)Hab!P}~ZUCB>dTcs$G_T8Za+HhN
z!IL|`CJj07LI$5nf#-R(Q;0p&b#?_-yme1fT6#L5*!YazbY%#8$zAkfq*4D|L6#0P
zn_6`Cti)nrN(PnibpRZ_*PTd@82Bs(NOeIf{BS)TFE3GY@V*1Pj;_hStx{A9YYW)8
zthLN$SWH3{JAjRgfRe*7Jx!w|+(LNMlVf$Zu`*S)WQ?^Z_P13mG)&MN<+)HDd{WMQ
z^-md(gyH+ehF;nY<NfxZUk<|0x})^Z?QB_4$BQ#$2-)@lwlfHBpiNCp%~KQz=Y90(
zKzhi_49XD^)3Yj%_wQh57LF{_?(<r3vcD5{?aqho)7pU~Vm;kmFwoZr8KBT!#DD3B
z{9upazdITfRdA1ui}sV3@oJTfoft&r7v&*OH?%@I-b;Z{HyksMX~ZO#Th7Rb>lpu#
z9K|9|gXR~Whgx1qM#0@wlFXuyzYWk@m+5ZJ*yTDnJI6!W6!2N0OX8kWRX!lrp8UuW
zE*IF@+A;-!F$|Yz14wq)XE0b@oyYcMr3Yg0svL$Yr+000*c#6)0-BZ&{0d-YqO4B0
z&VE(3^73-z_tjJI$T~qsQD%w2KaJUopM)XXQ`K^AmLcC9XlwvH%8~HcNKt0$Ws2BN
zXPTQ$Vw7s!%kctn7v$nbKF98ajC`$gPz}Q|*GSl9TJ_~sQ^&~wH^9<hG{=gco0(<j
zqQ*-AMnPp}X5umVT7uBoc|LUV=dT2EMvSfdldTcJ-k?YhL}WAGFzr2w^tsu6x9+Zw
zY07!6{aK!`pr(Rq=15=sxewEqup`gs%z2row~-aCuneTQZ3{UHLWwhYh#Xs$c{}P)
z%6-f}sl^p2(^2dEm<8TyCqPo{{fea|Wt7x4(mMgwr)HM8I}mpO8h``6)5BxT%xB?b
zW+>Pj6p^B1#WMRp&|qVD;NcnpWF<=?$qX<YIy(OqG9c@KSsF}Cnt8KL;^nbh)LLIF
zjjrqY%4}=Z=QcP03r4Y_%eBO@rfhp>=jT{YUQD+jXP<#s6v2n}mRvcaJYKHu^(*n6
z1pYY4i0fim`%xwVGtBuk%wZkY`bxw7*|>oub*)Cj1G%f!CKr&P`I*0yNMHOK)Iqif
zA0ifEzI~~+$#AcMXxHpJVORd>-uK_GW=visF<V@2PSmAqR=WjFAloFdb-NYreo#Yb
zmY;`<dTb=|`ybiYm596{HfnQI-OQbrZ7O9EX%-=b5RXtWkQI$m#@!DIgcsNnl{0p}
zuZm!*%e%xUz7Iyh6M&nk@o`-}y@#gX-3E7NK>OKHVfD!`OHkr4B?ts3XR&^A#J+R9
zOedK^0w`b`&U1|o4Gjv(i`Dh@d{iVzcu3y2Z#SGjpp8J*9~>=GLo+54=&DCXM%voi
z-c(g$uIAR()*u1w|8rv(vfImwiz6&IamH=lkOt(SdHugxH}M_x_4Ff-TYmf$vFh2z
zz<fAqak+wkp(gm5gO0^Ooej!Gebr~&@o{lrV)OFw)cO#xK6YI+)zWesk~ssR+#Rqp
zj)2}PE`9}o;%ZNF>qh1UxCym%zB`c$ATpGemVVzXrU%+U%a>Ts>Oc`Y>HX&d{|*Y;
zSPSgsLv4*Zkaj{DAmG>t&CJj96?w{3fBPno{R|0~%fX6c3AitP{YJoupPrrqJgpEj
z|CGe~lVhE}wziPNXyMAr$`khPoZ0@zl;n|J%cG-0gMMmiYSKC154!L6+7xtj<ah{f
zDDW%dXkIz>yH8CeE#1j3V}^O{SPdxLdamSfUYSO(wZ5ZduMlI%N1e=B$gt^+fAaTf
zIEU<?Gnrs(QL8g8VqL>@+jW0xrqeHI8T$(Vu76_^NYvUBO5gpZPS>DqlXCq9=^)gx
z78jsIIsmUVWf39+S{-rrJz+uvh5BkKob-AGAxC;+3~Pm7B_YwV(Aui1Jw;|zo;DAF
zE+UUFFYV-rq%XT$SI!oEV3U3Bpe)Wc0VnM|NgB$*B2%buXb3)Qg`2hep8!Vycp%!n
z<DFg6<{`TcC=|+6)L{Spbb})T^pOF{raV<!)y!j{jZtb*A_%4H7J>W`dW%zY@{xJq
z0_Jik8Ft!G9R!>PsCni<jb~-4{wuMZWP%_IX!q`%Y71rP%G8-lW+#E*JQal6EO|AQ
z;|262x$AT5nYdcM^0Kl`Dfq?U)<iktZwBQ~DWkOSK46s`9UMqFRCl<|3=BRZ{9@D{
zCnhF9263LNs;<U>wu2s+t21Uv&*{cpkcsdRZE4!_&94Ttnn5PZy*jo7vKabsy+3jZ
z*;cnI2D@mmy`iQ%mZKizqURBT7LrLvpiaC#ZQ?ghUzoVt#E13?M))Y?Yq6zVqNZSt
zAT}?JpFe2k61p+plCwbulNxRgr@<VgJgCyeO`3N93i^%BkPv%Mc}cf#9|P9z*xqA>
zG^FE%o}M)D;Ix^!<z?SN`mYaj$rfVGI6o&tTqUI&DwcSWX8%x<%Y7e7M80>p{8N_-
zLrRSvizOp3R~tN-0!mKjK9dYo@La}AAux*r!V+DW;1dCHtL>Bxn7>sIb4AX{kCk3L
z`j*Gc&fY~)6*=$l#ibTf%%xm^>g2*iUwbI;S7W>}$#Cg=nrOJ+`Y@~w)6$YO4(^1~
zHP=we^%5fu6I<_{gmO${>|z`dNtnN1jT|hLoUZL)GuPcI9QD47gzuITqO{-a&d#N!
zraR|K>e2fSrE3>!Z!S4+`&E%Gbcg03inO`A4W*gjun-K;9l*#t7!?4fYr??7*~JB*
zLio=}A^`9KQoEt`7Tvl|Zc5WZP<y|3jJo%0<&BxoOs%akFDKR3&OhIi34^iCW1!xq
zKQuYL##_u)eE?oUHu&;8&^ne9l=4XAe*xGJATz3ih9uf&ch>LU@UkFP0d~kL6b0s^
zd=wBF7TW`=n_mU9Q!D^t59qy%M>%I8s#t*}*STeeKQcOc`BxZ#1NT(`Qp!bbg*L5~
zlYxv<T~Tq2qOY>}ZlAw&d82AfP6GI7Y$oFlq-AYY)(XHVg62vMe2zmoGGKXvbIQ!;
z&#kN#yDY07975f4REx0J*FYMt*>#rsCcC|}W0T<C-Q=`L@g}Pk+0uU&1pf$VL;Oc7
zC1XZn!ByLW-E@lZj{&E9&C955WGnLeCL}jD7HV@>whl3Xq2(@God$&f&~Z`VbL0fL
z1hJ)*R?7H+g#$YtRm(x-kdE;Ho<QzYW4FXLGZ<08oeXog@o}barQMQ;{7{j17dPfg
z%M$i@CUS4vNlrzvhxIQZD~^qkH<!2)?z?Apqno<=t?#W}8KEEg`Aiyj_FAWcjy}Vk
z932Nv+DBaB4+69vzQcbLvUO&wpUV8{DR-K)Ns3AYK1Hl=-o2`_3~zW4@@knhgeuv`
z{ZZ`*`QUqF82>HTchGU`dpRN5q?*5#@59I;F@k_5&HVhi=j-b2$>|vTITCBGv_n&|
z;hYo4jvw|?RD@VhI6k~k#ch>R-Be+BGHTQY1SdpmSdXuN#T4>x8(5RNYb!$M2s;h+
zR3(xqclMjB;_(%Tg%a5c$kLGk!w&}}RePO|NAqwc5FJR|2ZYgGF@L>;JCG*n4<c~i
z>Dh*pVMD?NNVAB#1->;58_zX%(GoG}t;?FJJ}q>fTh4N*6t3zg!y8PN*R!uA6O4(!
z_g#1*lc6UnCy#Mv>8rdM?ki$d?zzUg4Tc!52sg82LF(8Dx>fLAok?LbBTshAQZ-6+
zwEI}<lm3$sSn%^=W5<Y?RB1GoHal5lyPu%%#bkZ6_23XKG9!SRx)q7CDLKhQtHxC~
z!`|5vOy;<SzEp8D;2Fh%yi|6J;?{iqJWSX`z~XgTY)k=byhxEL0fbc<2PL`5O+^e*
z*?#xXsk2o(hb%$ZGibr_0N>JM1HYS&2YbpOhc}c}i2XV4jr~Ao8QW@l!$H#s8`s*w
zqUMJ;70bO^oSym;X#;F#1!WcJPbQzG*n*Z_(K<vL70sOnA3A6{sXnfe7;ES&>=azt
zE!x#iKe>M|jL$nPjEsO2@756h-L$(v9tZ*zf!|7OPb68otz%`lXgHZZSyS)Pd~h(7
zEX9NTA8WYsEy$|rGY6w|XQ>>-ZSs=(Nyx8e{2h~g&Yv&IczL&HZT4T2-NcKf&TDdh
z;2C>iYAUVU;5LXQz!mJ`(x9)cIv8n7z^w;+>hw*imX99Gbm;!5eC2H8!-#!p3)Nf?
zrmQG}$gDh$@DuZQVso_wT=uE*!rio>vXBC;fni>&fPorfvt<<;H2TI)q>zHUqL}AD
zkYi0aX<hZXSB5Xs%aB&YV)#xyM}IAC7t282r%no9w1lrJ*;|mi{$@)da{`clhX<Um
zH77_OwBzxF0=NlE?PA0|sJ3c^CjX@&$78HCQbos~;))rEduBo>c)4u{-64x^g;m*7
zlQTF9Y!u!XHHqt-<|98t$seAOHyp?H+fk)yNCdh$N-u6rzwDNvU|(^*fC?x>hmNXY
zdr`nZ^QFC=5yHS(?>JQj692%Nt$+%)g^Yq{e2fBqKgGgNcCRyfoV9{8w-WtK_YE{f
z%hbxk5L=j~`@Hb1pg8s2KX;qipe!H$W{PfuioTXF9)EQ680cd2b#|`o6lM3sNXVt(
zO)<6i8OUQjPxFmVs32>y3g8d`CjWo=zzWDD<1a!HyXG0c?6|dWnxt6g;TkNKL-U61
zjW?d~ort*LTlc>w#9$+{LlbTHi)`g5>F**cdK#tNP~(iBMd_P@md0)^3zHFHu{f4U
z+Uv^<4eY7n<a+2OX`?!jwnyoS#PsUVLfJF2^XfWHJo=f`*}y_#eDi~S5bL|PkbqWG
z^q<!(&u-Hl%`Xncyc^Ko3x;YLbe?sZ@T94(>qo9mU&W2-m~WzklLh9tKTg~jd_Ph_
zfAHOgR8^a5VnKv#{)mt(5)YDjhx7`h9E9Ra+ybX_kf*rggw^w6wOFuffAF;3Us3pF
zGm96oRGYvl{0M?g$>;k(U{I)|&zF!+^||(m*V^r+XS)|XXrFg_Y?j27n~Q%7WnyDG
z*qPbcC?G-+Ie%|qGe^1zsIhS1@_)A!Wo}b!n1n9iiC{N#omVsvdg}s8ED8|Sz=Q#U
zLp&i7Ije8RZKB)%7WJu(%hi=OBw2bLI0&gB@2p?b#<;1L>GEVWC=)Sd2dHY{rwkl@
z3V0cs^KG;F4$azQF8mih`KV|4^0v3PnY+ne;Qa1=CHnoXAkL4a3d_@e7Vc`~tiz5{
z#A#5PnU8H`uan@d+U=SO@ps#YB25~!M2+X%ZhM*Ad$MSW{U0ASO75rpiCgD&F|1u1
z?hN;`+v?UjnjtMBV5r&D8tVz!?>?BsF=szvITog4RHF8O%u}DF^kvy?twiq1NP4ls
zZMgvWQd`T)+=2ge+3kB?9)O^#Ws;J!MX5&7jiGz-f=uyumDtEFP`l2~p=7R78te>v
z|Nd2cz1KtASYOXoge?ex^!N2K_U!HK{IwA>=4Gp>sHo=~nVihgD2XHsjW7HWf$Bi-
zX|k_q%ABOy8Ub$TAusQkF}VZ$D8~Nh`9VSrP$4VuRQek^b@d&dS5_{N-YJ{`rlI~?
zKv)Q6c!G%zOfUer0159Fymdyn%z9V5fw{S0$&Fo8nz@9b&ck9aSJ5mzd!zOz@o{3?
zN8TT~!UM~4GM_i{a?vvG!xg8k!KH<@-MM~tCwv(UTMtI2`sq$}EJ%&Bf<=ih7{1)>
z7wE!e>nS%n>xYVt20<WiA<v-ly5<N&CBdkfn=_``0&IsJ6>$HMdFT^|s@#@nIt##A
zm%bN1JT2n_L9ai2$CJ-_Yvv<?SIImlgZqB2Y}1*|&V2lWhaX*}M<p*R=-&lVB$;db
z$z)~IV#}+6*`=heXj0h4#%CkUhnd2`;L+e=8b_GHk=8-R&^Fz*yw0G}Ll)~UvnJw}
z(YILfrFGIiPHLX%J$L?&8l@XHcRY=1;d{3aRD2pfQ((r-2LWa`kTejg{{1@2NAo^x
zxCYOoS8gX_5|AfggoW+4wzjvYs?1Dub$43!?ugBQ19n_p9y3!@Qws~sv~}`hF)=*n
zxA@w9cX?e*o8JJ7<Bbd&eEI83@-;_>`rs$Qqs0JZ8BkBa#mz0@zVd4|S#A#<%th4#
zWKUp40FON48?YH#h&+BQz5nADU?m7}P(TO;@&aY(S9bg)15?xEZu)BHxl?bj{Q~$3
zANCX0N5=R9&xq2O5l|EYMoji<d@N4a&+j*IOkTT*|D|<waR~;pbU5BZ2<GZP*T6?s
z^aX$LVB~jT<wzZ!GHVhyCJS;{RVuJdUJhi&Eo7DL+IJDW*~Qf9CgDE#UE7cEo;_{y
zpZf-G8GO&N8K0P#Y=e7GZ%`p@i}Y|=5uihPrm?h~0C8V!%F83@PL9F%B~-y_*Ne#P
zZ_WYNmyRyL3Z@ARnI|W9Bn;wYgpt5Lb@ds3xdHwT-Iyu?9?k?U7?V#MO=7{w9Ncgs
zm;+|aLAixYtz~DJ-_ZuH(loG2_%I-p<xnGP{Oz7ycf<ft2CQo(ptylE6v!rjlY@^}
zLF5LYz6#j$0RwV%-XnKCJJpe{@(VaJH5R}0uAAa43jwwjvC16ci#nzQybKv`gFY@U
z?xyDkpanZWyLR{ihnJqdo_~%Hde@PzD+JwC9fF>NGs(Hk18^oKDVff1@i+)oj|2{Z
z8yVJQZg#TL#0NEA#*8@+NqxUPC3glM@0obwUze`L7{N`$Ps#ywHv<a9)0V8E1|K&e
zF5oW{qMPyx7d};@1v?SGJ!|CK4)e2}qG`P!cj=-?oaJo@px1=)P?p3Iu-k<4#-mWe
zs(O#i+dc`Vy9=kNP`wdpPN)IP9QaIr$J0n9eb6ZR&nTEs<0*Lp+^tPbO+dM8t)eH4
zeAo}h_ZpxAfEOI*PEU7T=Nf_MWj-ls@axUhH&|7LdxW5&xr;!3^*ik41iVu-7<gdz
z78Mhd1AZ~(BnE;@l6K%>0^Z1=E4m?%`zb1X)Sm^dyMa;(=)7qB18Css&J95Z%$Go9
z1dpq_s>;RL*$k|Q7cXA8VH@Hzo!{#fZ4lr7^?1K@Ip%cJ?VqDt%vcmh!P}dHk@&VE
zbCjg{O95i`sq#M)KeVuyXLe}?@vGje7Y84GRyHv)0lL81jY<6s_8*OR24X_vM7b+4
zH1*odzgs2SG@bea^*jSCneSL1pg&kh<lQVu{pX|cS!;up!}2^p>0*<Bd!0mUomDqF
zItm;d#_7YEBuvs&zvhXR#Mu0E&cGUjolJfPCh(yBPP`ijJeUC?Q!P_IT6vf|E1#v3
zgl)IR`})5AAiUVm@2W9;DbDbShsV6#U(}i*hJ<07nZfgKgE6x?r$lRPk5NQ>9sH>h
z<^T2xEvt4_xDZFhhyDqG-Y)*s=uFTF=)!}&)>fDAFP|A1Z36AS(K!GOD8VA<xsWrT
z5ImV^o!CD&X32tvCiwO7*pT$uyvOg~PXVVyLvEx=7BjEd0>KZpzWUMQ@;CvDO)3aA
z9&*_eLfF|bnQ-vqj>{=a1>!>9X>_602hd~lz?BA=q|o?~Ei4GF;*?jzq^s-P>G7DR
z@|PD6(rit@HkXN!FUqi!O4r*jmc$Y1wh~FVo@k@0wsDoIqw$g&w0tzMM*kN7pW_-{
z8m_$*n&oZ8?UU^G_45N@w*M3<$5O=p)?P&W#fxV9k)OcCVqgDOusGFQAwMpzZ*r2l
zOqWkzOSEb$YTK1oE;vx+-m)oVO^F2uYWYVR4hOzAMxXf_r<q!?Ck+^9Vd%Y9Aj!8O
zJI<=igZfkMD+A`MULQ~z;Y3N09E6^MrfJ<qBlv_(jg5mDlqQW%e$LL$c6Q2MClSGK
z-rrQ%9`KGUP)k;pm#cAn02%RXrA)Icydzu62ki4eHiHc&8adK}&a?Ht(j7j?#V7Bx
zL>vHVqsmSJc;SSDmrx>U^zyzS=_6P5|Ls8(Fzx=7=p4R`4bB%-37sjN<e`X_K3@tq
zrnLSZf(gAd<QmgMIV5}Z7tF@1NPcxW|Kop0Lvj{6Iy!*pJKtX}?(Y6?9-|k1a)Y-v
zTc;M<|IIpr<2NsXPaSA#tP}*iMYRPi@=Z)b6f0nRl4sU%`&kDb-Q&k1OyX`!17h$P
zC>yYjA!ZvuQRqB>PGQy5@!o?e*{7kYsoJDT13z9+I`DiSylZtTHnfjmy-buG3*iJr
zk%XFP=HTh0wvCOAFUrYKwiKWaf-C~GPy<!D3{_d!GVYC4y}IqN59C~b5N&VviZC+n
zDrP-p+DQ4i*vDY5ORy7gU{obYS@z%Rjq1N66fg_faQos=8;_+#7}qtTP_~wpp~g01
zXn>Yy%MfNmKVzAuG-Yy{BZ<s%S{v|{Cig|21j$jyOK6mqmv^0A0`3ywr^?;q4x~Dv
zjD2Z-YTkP1@-JT$9T^jqZn=u&Yk|P2!W~Hl;&!$M9@bvNWDRJ4Q~{i8Ki-a=T>;5`
zt`US*o;1RrZnvJe32CX)#s6mLNzv|Jb%!jOx(zBUYw=_dYEaxBBDBiBZ}svet91n+
zVfVQU8}x5Blr52OdV)<Lm7?U}A1tS+VdoI)4ChqTkC#P%X^A2gfQj#w!hh*;nF8{^
zJ(4}6Pd{WF;wR1v=Ox96H1#kB7L@K~XU-g{#>M+fw^*3rkca{Xh?GhC6Fq5mOtEIJ
zxwiJ3|MvF(Z>OY9ct4)0$AD<k>e@M0v*}!aZ3VD(j89FOq~DDQ{2$6Xw=Z_X*14ul
zI<x$g$_zIQw)#L#l3-t!Tv}vcD*L6>vu`=vWc5J5heUWVg@xQzswB$I?c=AIB|jIA
z4<saetOd5QdFD=Y8b#VbY4UhE<1Lx}D#3kFW=O3>Si!Bo7VsHM!b<olszqUt10X~u
z2!hRj-rnA~b0rX2M^LtBg||Kmhw^2ru!m`Eh->WGFK4;$0h1X>WAjW5jNoUzym3P|
zWO-?wva_@0gTor3HtD}9V%cA0-3Ydt2^y0V6S$D9qnA^Lu2NZI4rEb?!}0&Ze%Dh)
zVWRJqp;6?=+h4=qzMXr^0HN*rA@*y6n@p&?wo1!`paa(S^#Rvl9+On~is|0-tcR8u
zW-?LIZnPoO24NHdEAvrUOdFE8ux$QbZ!mtLc){Ll>>m}WcfWfQxDf9sglpuc4WNQZ
zu6c3r{%Mdw-e~`;F1iy;3LW0LKbR&<qVn*MO>XpUxSdCi=KZ8v(*MdI%kP&g5S)V1
zG1uOW_R=)JFQhnFF$Y=(jDm~v<MR_UeiQd31-nhB23pkqj?T}IPE2^s=n=7TeCQ4R
zO;;-17C6Vtl#HNyhfm&MVT>-W{i5PetVT=x!42`uD$wb{Ey2vs(XW5!AnULNPyRoq
z&N3{@u<P1G56vJ5A`$~4-Q6*CNO!k%cXtcY-AH#xmvl->tAI!=2nZ;Cm(N?@KYz?I
z;LUx-UVEKu_Xd2wck6#f_4NZgrO33w-GiWJkZBPq@8f6Q{MAE)ES}Ms?>G?u_1-NY
z%aib&kZ&x1PS=)(<QTm70i20e&<Psso&gi~<DxDjbOb2`?3_#$z3B9wur@{~9}Ky|
zOtT?W4vzLNILF8E(YVjQ6a*-Vr7c{oD9jBgd`XW+VQ3Bicua8Zt169@vR=HdrGh~?
zW|etx)Beo*86R>oVMF$Eo*4TkdK!=Uvn!4A&V(j%{Kmi;8^bhqF#F0pxFbsj6YaN;
za$i+-GYz_OE|dLFHW8~x%zRI2w2oRuPW><a&WoqF&1C1kl=h;*qAD&vJG-3}`F~QQ
zZr*X|Bqn{kgNgh(QLkUq261%%eZ&mIokQ9ATJHn~%}fOHUf|swd`s<pCn=ox{fk-L
z%>SN4gY2}W-T`?XubwBt2QP68q7kFonp2(|77^nA`8EE1T{1oiC*kaxRzPWr-FIOd
zo_=9N$Qb)5O5%UrKfve43l(2*AI0RY?FF984VwM+IE*oqG5bHtH)`ZN+K_NhLEhWr
zIo|+Rhpl15$%;A@Y!w-)|L;Q+;6uNM)NmG~4`T414C!q-41J?5X{n@S3;F8!Gsru^
z@BbpJa568=I2FPJDXNlrryCz1@LXD4&Aa<$4!Xy_8-7Wip!ENLZw%@XY>FZ##)ns$
z(!wETC)!OQ{7)YOF{;~lOZjS$qhV?G@TV2`1<Tb;0>_j8OY{2kL_v<grq^DM=NTL?
zISF92BZ$3wQHun3QCm1D#7A2kb2$p`i$XbRVYpu6NdzA*1M1Ru`AaKNg)<3wDhu3y
zx{+KfKXES;B6C?AQP2M0@U<wWP*9L_yfNtdi$Lt$l&6Jau@j)dKD3|KGRq>8b~l4}
z{($1T-C+%mdd|dBvLg6jrcwYy%;i-*lC<2HXDCnO{FTaKt@qgC<I8oNX6kZ)hbbs4
z&w$H#RU3s%fb0C+aBcPn7ZuFQlWi09Ixn(O8de>P521<n|E`VyxmZW$E%#mYP(@`o
z1ucAPeYFU>x{T#G9wF_Ho%R0+5lzMkQYl0^0Dp40yjgeud0j=MkCkQZL9@TdX=|(h
z&PoTE-l@a#idL$-{JwxoH_H@!0kn^SIa;wCFwEp_v`7%-yS_Xg|Lf{p=b+1(j+hvZ
zX^yZNg(qvWQew*1PM#PF<C}M4nQ37br^``MKhhk2yz&tcFxlenzyrbv_q>aa{WFg!
z(|*%R#%Hk~8vf_CbBQc%>q~z9=+>&Ktjq&2dJ0u~E!JT7<>lrE&aXfBH{JF28=%7#
zGrzoib=458Y(FEQp>W@~TKaQ0$pYgLDCSj~ughd(05;HQIta9K05VRJ_5)iH;7Wr*
zT?xL7K&?ms0Wd<xjTovxv3wO22t?sfu__EZf*=nYGOv&3$ykm+Of@%ui9WwqXM~t1
zpjBPjiiWy7>1pq{?S9NoQ18>hW5oEno?qZSksKpDhuu0T5w8pMWk3?G(UeL=MoUu9
zU6!S#$XV`B=6auPegHOEJ#8nF7bUjbWO&hSD<nZe@Bg#ugFo84GF1gnPfsJcY?mx#
zvum8Egei`oQ*!2Wf9hDQ`t9|@w@Z*M-~;Mczy(?9)o9lVdY$+v&uCKD0!mfC(bUYq
zU<15ISlIEvcx0rnJxVGRc=QucF)>|QQZdOjd~gtfps0AM@ls@Yds`IzK4N#JVmYFL
z>tAPbK^sgEv=;#swsUiHE~cvEO~%d#6M40;2aFZ6aM<b<==p8T&x<2K1D2A{$<RV$
zG3@rTZ3P$r?3|pw<}sC5%w=)7kK!P-4GjFh%~S8(0EaNQ^R_VcdvHa?rxab%ardms
z<}uFu?J^6DA{}<i)kc6e`Sm3p)OJRIIUQ|mzg`0U5+uk!n$M}*Q5jT9bgBOt$XlKx
zY;_Tea&NS{tgn}`#Wsk5f9_(nnEsgbKWnevja3iVte!ItP?k_?RIr%oB0l9|PwDsG
z{X;+=1CBx1XZ~g%TtGX)3IOHbn0eE2Lw|8o6Tm$;n~yTy7WiGH>ljabfU1eT<xFTA
zSf6iywtC6=M8{sl({856_YyoL9_Q^IVkYeXPy>s49ufVdEorN-s><fDkdX=m7ehnP
zERF92;3G&t)z;Py`X+@BsJbIyZvcg0E~q;}*Kx)}u-E6umw&)Ku#aaabUUmq00~Dq
zm-qB@G^J?3FBisiAiKU6x!uz+=y38R7h>D^(8Re*{z}m20bJIid4W*&LMdy0e%@5?
z@j(FK=fUIsIV&V23ixYE0k^&BY{BxMpkc455ckgs`Onn{8uDO`@}+A6zx6-A1P>3m
z&MNe$rK^WNtRw{g_n|PXHH#*yvdlzKpm;J~U_4xGE@@jHJKkK|5O``2{8r7imYe_r
zBhUtBB2ZWH3D2Q~h~51@AYs=1buq<;Pj)H7AFQjZ`)dH@oJ4XuPrzbhrOyB6EEWNG
z?)h;C6lb9Afu3#fwN0=na0-FGtQG!SOlsr6t7X9JQm48CNZ>aBWq^^B;p*y2U19Y5
zJ^<Cg?gDy%cmJy0k`nmbCD;^NK)rGv{P!L#?e^XKZE!L7y0APA{(Iw{rVeQYFBd3g
zaHMRchaU)K&kjAZ7O0Zod%G^w@L6AQLjWF?Ub|(M;$%?410E2(q3i2lZ!iE|Z<YM&
z{X88_%_VS!@$y<)&M)AwKtC{K)YIZ|`cNVb>MW5)&KZ$NTOmBdgh#FabL0*`m%dKh
zMDzdheOTq^UvZIHJvTSSjOPFXDsO24MpRT|<1Udds%{|E0gquN4_F*c?d`nYS35cc
zRHIqPT^M*LnF<VbK>h(+>Iu-V0LfC<wV&~0cND2;_hX=jcsUTWZjTI{S(sSRAk?*=
z!Uo_?fb}Cwq$)`hwGbvx($q@y2aq$+!XhRA0i0Oa7AbOj*e1U$Krt#UU?coE9{iWw
zX6J%a6Ew&8zlDxEgv4EL$cCfjA-1|nKvNSn<#8Aa#3IkVIIY?7Daa*=QIhwZV(I94
zxU&bF5i@;^-PT4tsRdebvW*@{#TZz_$T_6`uV+y2k*5B`=l22(8lC;xSeg<>o60ci
zhk_3;N^{%l+R&~y>;zV{(b0+xr*57Yr7SJjm3%w|#+5yNw$%;Xd+p9U4=+r94S`Y)
z)M+W8Cd+bvn5<CFYjWMKCV29*tb_-cF!4oxy9lPQ_xNHTH~?qJ8kmksACdkCM?8Vr
zBI|hkUmBQ`lM_H1y+L#I+#kGoE@_-zryTIM&jOTj!%*MgzIi|whi}Ep(Y~3mBp-7%
z(qSm~9QE8%rB9QijUXsEz;Ke=SYM}8s`ScBR_|S=kh=f}ALuydQFBvSNIBXPAQ|fV
z`+>V*JuF_zX^|i_dkz<!3qQ-3>aSmKQSK)x%m{v^P+Hw%8v|qeXIU=j!S>1u_SElz
zs{)v9F5W+SshiPeKH>%-%{UHJ$eeq+dZ!x+3{3(J<*Fo2oxw;~m*4Yf={(>-h^_x(
zvNoIRyz{`gPOHcSUV?xF&)fSW%;mo~CJ(;n1%X`F)22Ygk*vBmq(fuCm;>A`C^;@k
zm_LFo?vtOU0?70cIB@Q}tvK)n%3f&ZhfC)nMGL=OG&k-^0dMjb6t7oT3p)XnBUP*l
zHe4yG;e7AyY&lw>1Nn?S^9F5ThuJ&<u!x_RfVMkWrDn_E!0+|E0){`w?!Ob$MNLoe
zj5pSm=ye9C$2OG~*M&CDx}FL*+?+00l#3qT?<A57NrJF3RuFH(Y1bz6979B|B$Aym
zF#L0M7DgGO9CAO0f-09`^)+-VvKV#9jHQ!+gDjChX|d(qSXfvk0leEZUWTSPnWkLW
z@8?Hg;1Ih=dCi}sp{F(S<lkAOBYbx6c6GE2%2A*wixfj8plZN>3tTR~eI_Dipf|8f
z3Bn~b89lq|owmCCt3f}o=0%jG3a~r!lOKKiM$f=t)Nxh-jw4<ko}h2x_!PR0{S_6X
z?WZ7R&T;2~*M^yl1&XRND@}D+zId2v>~|<~?)#FK9Mc0R?^g{bzWeFmb^Qfa+7LJ|
zfgS@qX}9b44X(4XrhDouw@J7@87(mf{fkgF6BD)wAO!<O5Gd!Cz)FzI+q?eZL$-=d
z>q;~}B_jiap2sQh{1$%f_GUZy4O|RBykYBm2V4i8pIzSH^o9yiDulBw7rksn<I<QU
z#tVbzkuGTD(S~5uHi$#Bn$)uOIZ0X5k>bDkRvmJ6f1Q@9y6g3YHrbwce_nhm2W<&=
zAGwL3CK0YUY(Q^SnaMxUN<>NL!Y6=8Ww@65Z(C(2q+qgPyP*!Hw35K6!_@7-oe%8A
zB6LN58|{uPEOmL_8xOsgv;Um+x*1nr;`^1$)gQf37WQnuzTdfj03HwW7fbW1e}R`~
zx=>7v9M9%TTJk$kXTg>XvT5M9uU@S+e!c~wBGNot(8FaqUjq;=f&hgK4vA3!8V-FP
zFA(u(WaI_;63+=^3qfe=KmQY$_NK$vdk3ED%PjV7*E|4sg3Z6Po+;wnw{IT-(ZiYD
z>SzNFTCfX&4?PbP>Grn&hk4x3dO!HDHSYt;vm3}+ZT6W2+Qti137b{Zq;A`D1X$F-
z11*UFIts;W=gnVm)IKu@`>Bi>0KQ+hI~sI22OHS4M9k}hAQbzACIsBrBv=Oe;UyUY
z@$zUQJ!OMLr>pNw%#*68spHDhVx7=-n@xu?fhzL%!}}Ecjxx@Iv)xcqB*?=D$F2BH
z4n>@BAeX?>%3M=HwkgZv6H3ybeSR?^Eu$H#B^lG4-{Yd?3*`mAbxC37vexDzh9e81
zs>k)^tIr>^SUR1lu)+>{m?%WOBHpT7TYS5)o&FzRhsb|?9d=@JwEouD?of6_@<bWR
z@t}AKxUsi8+62l~s54MU{6pN7=t|SDey5<O%tR8@ANv&m_e>;#UiSP=;Hqa!{){U*
zH8VtA!HP3md|TX7VM3LjXiwsw>XfdYt&{^LA47taYx0w4fIOt9c+n^{3reH7(Ndw*
zl_1YyS7WM~d`#l~rw@9ma$dJHR_{si|DzO<d=)lcnX)emfA-79i5Hz>oVEm<<vZ@V
z8;|&Ang0F_at;z^X*n1VLn%l6TrPa}F`!7q!QDd0uY8C=qyG2!kv#quZ_{h>k6d6{
z>r4C-fwg_zX^&9Fn3lY!9ENKwbMwk~*sDtVw<&rHiy^&9<KfizUv91`cGesOhVpRw
z-*ktr7-_s6d$C-ko?JsAiCD0@-)Y;>Ph@wIzJVZC?eD&!oE|%kd5|^RTf+&5>Yej`
zHS9DC3dXuGVz8!MFDx)I7OH6q?vD@F{qU)=h<<V)mmJf9TTcD{bDoS;ge|uMDq?Gv
z0t?F=(fbw)<luyv!1TDu(B2OSQ~?6;v(y-7<gi)YeeI>=1|Ds1fz$HooF)_&PmJs#
zhW7z4iCLyp4Kkk-LC~bDHj74TTgg0yMe!mcX5{1~Me;u?po@s7&2+Ql3!k%2xFjA~
z&~EkdkIolja~C%K@%JwXeKJ2RrC&UHGU8r`28$85<4QMtwuLE<VhhQ*#3djV8Ga5W
zblrLS^TkNy2OL9OIa3BlhI}64;etbQA~y{&ojals{ln_DeXi~95JNE=|CnTs)4OLj
zcz!bxU+n5jYl@#jsKQn%8G!Zyu{|;#e!}`l#xshb>rdO>LsitTbdTAbf=Yj`Sh*S`
zjBw;tw(z~!7`gq2wQ~l<$D6PdBW_Ks&S1Q|nR(Uibl#&u?^}7<VULx`CvK>tjV5h5
zPxg<H?s+?2-6?tqD;{Q~t<>qGl-;)y!Z0}=@>x<+$K-Xbb$-QB*5SzCcyoO0O}9BZ
zh;t6abf^$+F?7x>@*j~vM*qfmTdTxP{YdAt%B>bU5`;=(7C|umTc<Q*k5eYkv(dz-
zgWfm7NlY=v<A;Lx!@^s4k(=MF#Z4Qx_LTBZ{WhDd`*B#0A5zCN-?%%$amk`qM=%p<
zeK5lzZ;Idv_-tPhTW`nwytc$YeyIbtBaX%hFw~kys{Qo{eU{ZHEiU5Z_!8_PEX_Gq
z2q6K=PjN<eYh)dHK6XRQpD^gX%4hD!>bPHtUplMWCQx`^FGaDX6#UWSJ|h1*bE~{_
z*&`louc!S<2?~j!2a@g}X1LE!2_?x<U6%@vhp<S{u=#d!f)g;EAiQBc)Tu9yhzfUj
zmWB4U9F@WJx!|Sijp<)y{t|*F{SFH;&PUXH)ufHdB4Qu!y|@g5bza_cL6UMp{5*z;
zJkVC|XO>lQ!>@kTI6O#EO*TE_GxSOjWe*H;`=Gj-;P!i-zFBYqC&9QZ;*yH8U<?xq
zD^CM;TE2*X`>`Kj=0KYX4^?=oS*PAmPg~pT=eMS<?j5THHlr?wqa}t!W#!zRb%(X<
zH_sK<H#Tx}azN6E;RBAgfC!cfxvqq@nJ-TWBF#%{RO63v19Uvwcf?RZ8Lce2twgG~
zlmsG<!ap9cmn9T{tK%f5N|uJV8LM`7W36oaPX7)9QxIUsqJ$9kGpa10yA{pq^`fDd
z_Rdz|WTKP`oW_&T;oRwZtz*01$GqR2s<;N~O%Ff~HvNtr=fwH}ISTrg&b}b+hG5XM
zcezFfT=gBcx*S0jb#$bXnVD$<pj6<?1Mc3ZBrN)^{x?qLX$PI<<yN3$EDFLW{$56)
zB2ZEHimx$zW7)+a@RoNyZ>W*KkVTF~;{QQOg|ILF%G9(+f_xA^55*COAbCBF&yDM9
zHWQz|WG`jsbD@WDnpXP%<u%Ms6?c)0=n4$J(!IMOCD54dXCf)@(%#I<5y|y6t}jR?
z_>lRW&ABy~Oy2Or$|WjZCDb=Tcs^^F8G(6$^7757?q0JgnD4<)_@}({%HP*fZdbRG
zo6Xb<macy20kT_WXJ_STB~kS?==c7auLJKlguHryw!R7~GbXacrImusc1L^ArULp7
zAUR9rH`;rhwyJ?z3NSBAlvGO%nJ98yIcyWyF-clpi04y6&X%6>mbbV(6>QnB$Y8KG
zabu!phtZD^Z1Oq||Da`;rl&Or%s&V;h>$tGcyK-r%4)kL9Zj+d!I4X-7+WQ-o3cua
z^!Z^~^7mMU7|GN~R4#}SKUowcPShxuk^XlmH~Kt}x>q)#RhlaEXpmW5PQ9L6Pud8k
zE_8?<QCT8uN$#U)0;qsgCJI$EQz!cD3le_oxo<oXrKidk>x!eaRb~bL<PW=13NF8{
zYe-Bual*U+5ei(CpfP0h!FCT2<39t%h}_7>KIbVi07NV;$ki1F@2WRYRV_**%oriP
z4E&p6;PlUwz|_!VzTs8Bqcbbr$}hPIuoN7CQ~RCZ#dHm;5D~psP~foSc(lM+h*x)|
zx)sgejktbBTC#hn%3tR3DVhJcw9LPe`0=QM!aIw*f%5rM0+FhCEGelOVzduoZ`8XM
zFqliU4ewACV<2$`?{Dd4R*Ifd>fLX~o79ZYyKC|jQp3r<k!Arajkdl*h9mk3u?TX&
zGt5ZKw>7^9gxR0Qkcvya@@-1Ob{)A!LPh<0pN~BFk|UeiQbdg4)o8haCP92ghTZX-
z*!MAVf!<pFI@z~}KL|dgo))X3$CwqOh@lQ-(KE7sr4KPuNB*4rbT3o$d_f;bQ29)d
zZCyARRp#zA{90?oC=H!-!~OMvlJ8HevJ|4zo=R2ZC(a*A?12gq^m~``WufRPzyyFA
zqUr9=1%n-mA6X=Tw6F~?{)75sc!_o#R8B*}Z2Be;jC+A%A(r$<c8#9pPgusG6ycR@
z*x=(45=bznpB$ZhcL*9`W3h$ek|vex5xJSp&krC-Uxuw@hG9dal0DLMW6eyWuh#Ma
zCR$%FjIy{mk4COFQV>1b#ViidIYJ<=UlpG;;Ans_QJc3mElh26&=7`n)`pWDS6q+i
z?a3cqbJ9Ozhl?|0W_${y>_5RnAf$v+Wx^;w5>DyG(X-2@E#VMok^c-@mA@b+o#Rv|
zBi-p>?_0w-w71)TEeh+?Upm3c-liL<+S+3Z@_m6=eCuXhTU%Zu?qDtVHFbF5C}|1M
zBvE#}@n$kfIPxeaM}gA#tcs&S=73@-gdoklkMA3*WCoR}8!-(2uHe8A`ccP&3Ux_;
zY}a*V4J~h9r`O`6?t#!+lQVk>HUsXE9Cw6|yyMFxKhp#O8bLK*y%lPhbZLqUzfu_x
zE<kJ(xebsOfqi;?exBX;A`JxtPg67Pe6zEqy4vl>mk|JJq|zxny>j}X|1Vw5B+zpt
zZa+WY2vl>2Z)wwj`>vtv<eEKOLwQib@p<~WVrbdr(<Z692pNutl%JnOuv0G58&vJ-
ztSGOzu9bF&CfW2PwY}&37cc8WHy`04OxISjyC%f$L~n$@{4O~+;Y93Y<`6Yf6{-Cl
zLeGzo5Vgmypj8#?n1G6hRQeWZ6Ux08@owZ}VlX>YoX&(0;__f!=wZO+OcYJ*I)Ve#
z;PY6juXb+G-11j5E|XEbxSeH3qw-KM4%OveHMmGxuE-w14@Gb6&CT9^zW2;;W5wRz
zebx47Wka3Iy5#%-PxnjSi&Wy{LfGjk?S(2o!R7v^eH-T2kyI8Sz*0Mh<AnEUpr8O9
zDyPn{lQ|GG+Kf-|O>J6J>bX!Hmx|ny7?BOHn&s_zTcV>jOirzgw)Iyp7jty#Sw5~@
zDls7j?{dNVGP8qd$*3e^M@Qd&>T`lweZ&O6U7g5kW*`3e<pM!LbShrxO{T;nqOgzS
zk&h8S1M7I$RT8W;#Np-%1R!bb@R4NDWJe1TZGWwwmeygAyW&m5bd|^<_tI-04uT#W
zISj>)6Gk+o7$k^1gW8?=Z7qjt)!+*x%Uf>ko8Pr-MS+lzi({07RO|p5>t79_Orm}B
z^pUNwNG;)DPag_=7lVu|kkpZpo-PKQQyEshcSkipd;%VR-yV7#0WA%9=sfX-zdwL(
zEAWI|U$-B{J_5OouirUYAJpe3G|kq}0*e>uQ22p!0z|(c6tXuyz*4AD5QS-PiDgf0
zIM)Ns85#x$TV?9dJ%3bR7_~jJSV+RLm4_qfp5OEeuOP|ojbL#-FAskOq2Ju37k0Mf
zq=pl441SeqgT9Tq(K8AAUL{V)zj#YAZ6Sq4dRqrc;h>G2;I|4O`(#DLJPYF}+@+5>
ze8XsUwNv_Bob`{Y4MsABt8w}TmO1XFlVo{O!yjDN$3mXXMGxFR0;VHeA~dGI=fu4l
zRbwJc7Dg`8_T_%ei7a^`uCbH6hsYtI-$9BW7shYdfCmOICZ!%YVZ-Ju(O=mje=!uA
zl{3JC1&%U#tg?6%c~>9FFQESjJ8_U@B~2=F_dI|2bd|b!;cLXWd*Ej$F}vyW^^=SX
z(vvSSBND9YT8~1S9zK*4NYkCRb|kf$htCKhk6V_VU)e>w<xS$i#I5<Ctz7!iod!u|
zFl@}~Ov2B)!trPb;r)r!v~P+Vo1c-t(+Z{E{7J=hZnhF~{@HYcGD2y?ivmSErCDkv
zO<GH3X+h!U-Fw6WQJkKqzrNffPE?U*%O`LoYju%8NDFS{!s5`EL234j{JfTYk8$T^
z6~yO89rg8{XY@$yqe4PpmSRGpCOODy4lP$_&PTTt;SnEr;x4j>GuJ%qSue`|?n^cY
zA<cPxf-A$H*yY5+pe!rHfdXZ6ID~4pCg?8SW$Trr9?gdLanO?@x95IXS!Z=xxRsR$
zt+(U$5H;e*xaK~u$2nOQ%Viv1gvO}*5vNxPT%z|~LG|{&OLR9;H=MRJp@NwatTa}u
z-&mw&g;Dl%<;g#v9`q7}c2UNJC9i`I>*IKNhSUk#gWs9`za!Pby#*-ooaA`m3_*Z+
zsXupDO<`f0j4b7I0z2O~-TThZx4I7ioxDZI`^P>m%NoX4EnIk&LL3TxXMO9-j41Ia
z8vwz#OM`OJ3lp%Xm_QxvYGi--gyCt1Q+||x*jgb+dvR2glE|jPEx4eU9<Y-mI%3>`
zF5F)jj~-<!c5Qh#FW*`RQ_?~}LiB^X0`HqMXr7qZWM<|Jz<gStU%p&_iS)I}TNd?I
zu!}?(S1bS55BjL4_BBK$uT=l=M#CVN-%w&ej52TkU)CIUif*QiE)+Vwu;u0928u`z
zbeU$BIEeb;n=ju_kF6PBe!aGWf6Cy$F#o+*r4e?pXmzD`Gjf^SAkN^HcYS|;$;g<U
zwxod~r@x`H_r18}YA*4&qcZA1jP!50;OIdFo@)iFnQ=F=x)-xvP8LUZVGs^TlQnoa
zQY>k4f6wLse}>goYrISHxLCb&!fpzSZz;34Pkw_&a~}o?K`ub<?tZzaWJMT(gY2A8
ziH9uYTV7*z>@anmK3NBGYGTb7J@U^^Ig6zVOVib_6}>QihGkYC%MV-QJzK-?55mfW
zF>ztef2jWG{f9~g$Nao?c>YK`FRAe<0n$Mo-}Xs*#+5zur-Zla&z+sks)!n41#`3u
zNsC<$&t12JEn+U^PGiSoEof9yIg~1Tj_VV5-1)j#_a@(utKNY~geB3Su#*(~SlEWM
z?pNZ+H|dzMq#cAmzIeCqbC`y&TyqjW*{g1CqZ?J5`t5O!fS5gx|C4Zj^9VYanG-&{
z*hyG|6$!y0{vFeK7W2q5!HRR@a4{Fm`vB9fU;61s509|*t2evSBp80A8=(L7_<0H^
zq;~8PMX0r0eMpZsD`LGp^|GGYe&A^#$A`5if<X>@x2VXdED~>#0w=3~b|*$Yv8B8q
zZG?~&5viMP$?S#B>h-*$tE#E#?oM=>T+rX}+LfaG_ZQshmP*jCkt_R_xH?tfYyF;v
z={tnm%<wY${JdL33L+P?8}#eZ+q0iko<YmW(c&>u{6d2;y9v`JlGoh%mq!ba`~%IC
zuqN%5zP1nfYI3;G##Xkp03MM5vFA$x0(Q#M{`pKQ@5HzN!x^D<lr6p*C52b0Pe|}!
zpuUF;o8CftoT(&B0xZ_3?B>{l{xaHpHgww}$2W}#o2poOj~|4aP2R6NY;TRJJM^1v
z?Vgc*>_AY5f*HCt7dJX4PlTK(cRCcZFyI_rF&EDg_;tzDiT2lq(*0l$Jn&J9xC^<8
zK${9`(g-TbJoiGiG^D)h-GH%hsa&IIO%S{hO=vA^Gq7Ze;?_(I`OCmCGmerqS8ky5
zff-ATIN7}V!_MOD?aGfd?M}GsNAq*_RWYV)30`;#X((-@Li!z7u(!-n5OQ(&$$j-9
zdlAoq8F}7f?<;A)YjW~WgLw>30(~DjJ4B?!NNw?i{Om9BOvM%wHnAzkgoDxK!DXL+
z2)`^tl4Wj^`lBp^B>C7T*+$N;ywbW_qrC!Q<HnMQgm$@+`j!s^J3GY-xtZB8K%<kZ
zGfa4`W|C%RSY<T>@n<SWAS;vjF~>>&Cz>L)sJ)DFqsD;ot92-OR&<GM0cDDk99d%s
zCuOCuscfC0Sx8K6GQVH*nU=Y>vGcP~&ApHv8=3PY@z}CUZdq-=l`jin<t-jv=VgwV
zH<lW^c=PNRR*`g0@trqwV~x1_H(0C)QnxR2mV~lNMO@7+<fv}3bFS<44eKmMYbF#w
zm!1l*Nh<9%(NX1eIhfmi;GX;?;Pe#JaZ1ReYyY&4{^G<Wfo8YTzYYdVCY=)liJ>k<
zB?Nc1a|ZbwN~tUAH}4Bc^?tPNatHpTIeTxH*32iv0mGbfvLpX{dcIfc3Ww)*r%r}&
zjdSFn)m2d`IJ>6BU1VW|eG^i{kT|&eh&n6IL@Q0BV;Q<ai@3x%OD!)Kf#G$xR7<H0
z&Tj4YdviOB2(YWvdXtqGprecjFJPrGyU87k@`NCZu<n+<djBUL0+ILM#p;#cPj1-=
z)7PjKKa1ac-hw7n9OpAnzf|KZfxJN9TO;h{M1gEpf5NeJ<2#lkb~7?~w`&+hPqHm`
zP!zVA1)Uhqmu3~051%BFv;^^QF)=aCaC7G!LijICKiY{+{J>PSsBemu&grf?UiMH9
z19sFezSBWCRA?vOTf_GB1#}}GNy;Qm7C~Pq+mvV$d}^Mk$_Yq&DTgG>3JR^hDw1T0
z^N=~Pzg8B3>^XJNz&_C9y@Z9(EupTRYAY8pjJ-a93gs+m>YD~$Tu-RUR+6`+uMoxS
zzV7$6-Y8B=o>?A$>rnq}gDJVs633rUmjDt1o9q5n#7&PWfQ3N|kuK6Kz(lqkAnM>!
z*q@a~l#$+W6xMP^q>cK=6L!qlxpNWv<GzjMQY!mR>3WWns5)DAR!VcpnYh|qLPRgK
z)dc5OMSaI6#4|XanF*B>PgsB{FNuILsM_~osgUV0Lv56rAIA-sjwaQcH1gz)Q&Zeb
zt0<N<I`5!$_1^eema}pu7PE&8Pe-UbJ`=gU*by;<BZ`7vaKBpWc1u9A_-Mfyhsbd^
z?R}9VBWjB&_sAAka11#T(mH$JD*@$2^7^%|)!P(SbdTn^-~C!v{E}<Tx+2wBA3jWR
z`WQNq!xf85%SCgFf{JQu@0_@~FPCC3s7&TC*im!W5xQSYLWL;)gRG#a9%$GKxzleJ
zjtDLAo;E+1OWZj;$g87*$NyL~9&^8qMTSDC0%ro1J9&!a{CaNUQYzw18HVsE1M-<H
z2;iCPpR*3)<Hy<9Jl<-W@06ZfZqTQS-=6tDDyEa16p4$~f0TISP>sGsFultB78eC3
zKsm_6pAIohsYAN^HX%>{2}@=|*A5p-itW13y=33;x=M_5H1)~oWjYt8szP$mYcs`{
z7Pq2|JUQkX9V&2}upy4@b~b+*3r>aM`yghtbgExSaJed(%!v<%0$;T}GR}mQWJR-R
zQjDpZzMmAD#XuRugJPj%9x-~0*rT49Y<zgsa9g;F@DA0g?W-s16bvJ7__tIo>C?f#
zY5c~GJ{iyDBtp59;|&Mt@t@!1zGe4@PcaG5LX-tpd!y;*MTD4qZyd_y?DD%e>SN0m
z6kgkzTaEir;p`JVlNHFNQuiLYt~R9KDSg(fhi1MdBiU>5nr1)0Qd0ZSi`C<)hQM_%
zf{L`=D!{-mf~Gcv;$Af~mNtgllH}uHF~u2tE|>rk#j(`Tib^CCnzPSh<zxH&!w>2)
zQ^F9MiWH9y%(WPQBqYmud2>1QBsK(Xp&sk{tv193Zs51Io!k-~&HXXVr*8_|5}Lzl
zRN!HCjYAFlMP6R>4oY<Hn;1S&-BQSi@4{W0&Q$60j?bkZFSP3SX}z#@xzD&opo*H?
zDCaZ{X%mAJFWPINfqPP}M>K>PN5K8(TSrJxgkB+Wvtl`ynbtoU8DQNB-<uNuL25fD
z=lYq8>HJ3=BI#V9Zzaxc*&^vBeCMnhlQ{${+PCL58rDIULTX0Z-=|Tu^k{#kqtcN@
z1YIjP+681QPF_4s=rMM@sIw#~<C@oz$9j^v-~AvB|B@F$tn_JZ1$hcSDytO)S0!ug
zp6GUL3?q>g?UY_1$~gS7PrsO4Lv4wyp-?dGIM}0K^ET11Z%}P*(38!d0K)@wm<rj<
zi`Yv=&GM4~-^n)fY4FUzvHRj2?_yEMBlC`E;c`tgv(HlaB0pCQazT*&5&taY@CzsQ
zm1thQP|=&Yp#4ay#@mx+E8J_Velg%DoA|aiB`zMgy|VV_huTuH%+dhSwOuoq-?7MF
zEf7iVf==!)%}cw-55HfOu;cyMb#lY9f7LDnQ63PmEff?gKe%zlF8C@Z`m^PBy7Z~3
z_QT-WZc=HX-YeV7@BkyE>mEe2J)}hKAT^C{S;t!uRsGR^E<du|-mBJyB3%<#`r(+n
zIt!U(4N1tLc;j{^1I;I#kG3xraptcvq<o0d<Hd18uhMItz)^;TuPk~e+)nh+kYGc$
z4nmkANRgyhi|eqkVIK9q;#DYlvUJ8p+NiO={HHLE3P0wzmz&RyMP-*RFP;~vt+k^s
z$MxQsh5SzE`}4G>`{~bXrl|Ka9lI0Bq;E!zAMwIXON0F3QkKl#t5|w-@kp{dC|d`o
zRrgD*Nfq6Ma0EF{q^?*fJGr&5_o|bB5CV&6_G6t79a-;CxlPg6-y%obkz`#RDDE#D
zNu?X$A?k7@&8%B|%tGu--*`hWF5d9ccLe#j6b8S=vYSKJT3Mc6=%s$tP5C?`F(-N7
z2vfjr!J(v5cGWNfn(%7nxGs|vx%s4WyhZ2LGo`Z5Ze&zT&4@22y{_|u_(@$$fHZI&
z%Lf514K+fJdc2TVb#3UQ>`!f3b(zr=-v<@Ci=m=NL&}Kuw<%8IUOfw#K)x~s>F)GI
zWb}MPjp#hMB5(IkA=b65PgA>DQR|NZG|8W273(1MuAZs9)zJVN8Uu8v0vkZqZj68Y
zH8}}{UnROnSy_1fST0L(0jQ>W6Lqq=tAFlhJHiAc=}HB=0!$81B*kGVv~#PzHkq%)
zCmI`G&kRJ9Osy8kzKV0RSLe>T_VX;up||{Dsbk1E>2H0Neobt*mA^4?H?5&>Vvf=L
z1TL3ML66UHfOvx%;^aT~yNr39mVVbhqsEgKj@>3!{Y-X{%4K#nRf|x#X8fsZGlCX%
zHEw;kAUD-OdGB`p5)(GoI7o1juk6m4kyb%2!UZc@;P%){FvCHmg|jUGE$kJ;eRI;a
zfHLSl+k3-uMggP9PGKTsYC@rfhDj4bCKyZJ5$Qc`Yh6-T)T%yer%-;m@q0e&mBYHj
z!!&;Ogi;+vqMm1_gI}4NB6GT~v{rV-_}4JFGy$yyA(|7t`IM3+9cPNa4|8A7%~|ik
z^y`Bu|31X~%NRL2taqpbQ2d+Yn|%M-&KrjvGrspas4z3OZaxgU8-&-c10i(;d(oFG
zCDhhpMCkWC@ja;Ndo*>sM{t}diSx<N+P{i-yv$d<y%0!0GkPtG)q>clF39)g&<K5|
zR5BmYJyC6$&S#AYfwbqZzbB#Af`s<c=PU+DiNhLKgvR*Ib;cPQbMpxi6M;VaKWB}w
z2KkY*2I^;ZNIy0xG%ZAym>`v-Tg~%hAQ8ERw*+ZAG-_L#HK3SgFS-mzl`(lO`^S$A
zo6P%fAgdgxjCxXVVvh(b!Nidd4xTgGChNDLUzr9dBV+<hj?YGX8@re2rn%I1Yu|Q1
z)s0xQu>LYo;ckR24Z-;yy6xA`>j}lgrVnHn_7%#69Ua<PJe85Qu3xsh0T3Tw-w#}C
zBm#S|i1ZI><$K%}>>(VZkPvq~s+U)Y19AweL~?ivs)T7BE^?~XV*>j&{tl+Jqs+oc
zGjYUiynwf!z10#_R|bo;A}2;@CCwnv?(7WqE}ncgH;qPm5Bvm>;v)d8iX-uvt=hgf
z(_nOm4d~*7v{cY|LJ9$70O;$~fqw`7xmrwocm3ma@E0&)<PP{Y+EzTmg?icPL{zv~
zw;T0Px^Mk^V#HBqke*q0zJ=Xmrp8YqD!*R0zENe?CoWCkoY!d<;vK^5DK;Yi2o;Zc
zr8CcQ3FXSrYqiPT;=Uz8IYKKrGFSc0o|1xQu7<Q|nC%UPp!%@mJR)nL#!19V%i$A7
zjc8o++-gnxtP~+XY1apG_Wd!XDOJ^)zNjJW6vm1!@P_yjyCjB1<p`Cg7)tS^a$&Qv
zwBk^@Db2SS^|m-M)-}CbTEgxNS*8-(>2Z(5(M?G^LobjAwmL^?i72_;ifsyFP~q0w
z>K%l!Hwt@bs%8TeE8S_gW@%8g`D7KYvdJPrlnKeTZ}Qde<{6|>X|<Bq1tjrqF<QUB
zF`J6KM5A?{GA{9ajzwU1UbdWKZdMS2ipb9AG9iT_4CnMi;AmOW`^6W%(37OY?c3-Q
zc12SQ$DXHeIV3Wsy$7I0FyjiGi)}*bwmMFf%X0qG7}QTW#U0xg#cv+R*0zl=Kcc(b
zq^Qfu=V|CfWu$>i5P0w%Y*Rkjk5UnaZVJ<gb^6Nt@=}yTYiJ04>U_?QlaZ@dmmr-D
zP@@;?LcSQ9){0F9Rfat`@(a7d-x<G8z5H_#jxR!wykc$gXMJ_H=RpwuaMbWX*76r5
zpNn1j^_u*>G7$qAIbbvdh8gManf_ZoHsc<To2~PU?cg&ocH+e5uYL|4#O2G1L3jRa
zCK&brvR>JknSb9k{2c|{Xqx&;S3|)5R73BzK9IPuzvbMzD0^c<!i984x7{{y_l*!r
zZ}ytTwgEDFW7Ol*WZV$XUZS!He7GRM=)+CE*xyl*6<PH!buxG6YXkW8fZ_8l6oZ1Q
z1e;{mzVvdGcxnoRmv`mu{+&}fkGF=TO_rTQNR@6HF*{n`)s9+XoIoDBZHX#V#Agxl
zEb1jh_hoxh`Ym+mdqtS8>zF&+(-I4(x2$c?Ee1IJVI`AUk)1!NaH4lBDePE(X^Bjk
z&u}NKNe7BLU2YNIFj6kf9g*d)Lc<NCZl`3~ohOWBo=EdJa~=Jbiqk4IlD)Dhfn>u_
zWz{Yjf9K>rPSHLIMOVXqj7e0rDYR&FB(hfaL1ji3Sz0|_OXj(zOZkLX-OpZpV*2@D
zK6j!|UrJmflYE&8Mknbb1e}ndou^%U3q7-D^lzsL1W3lIf~&viA+RR=y9?fh$>Si`
z5)jsKYu8aT%Q{cC2RCI{pCKNDp$u^p>ks|(#5KliP3WRN>~j82%rZHS$=}ImbllKb
zFz`^#YJE^^P=*Lc1(TLH)3bq=reJ)zF()now;T(sDLtx%P7@N43ldq!vMr^=VQSsj
zkwl&P*5DvfrO3QN*alLkzSc9h8aC&8)46>0&V~Y8_ysYPF$|(;t7kQC6|Rb@)}C7`
zZCc_%e(CVrw>=mkQ)aH#1tDBue{W*cOQrXe&qAPCH|}+;9BDNlJj<O5xpG>8_jB9x
z$xJamw03`4EiEWL1WSVH2il8Hn|Z9SIE<gDhO?6!-`91*wlU=VUr6#x*LFN-A%wxK
z^zNEo|5+FlyNwn5lPU%ptJBWEN1cD4_Fr`bo!<mG2L@VLS&ax_L$>d&TR?zKvGAGq
z-gwHtz{SpkzWYh0hL~|MLJ2sO?jqTK|L_K5Rf2zkF(|J=SP~dw;`<o9Zc8_PH->K)
z|7--`JO2R-WWE0v$={c-wIodM1x$+*Gw<6dh4W1V(e7fyscBbovESc^*?PW{06&4-
z?0#}F;^(*0*L^=1=KAiI8$hV?!|Kgu;GDYqA!wBcf5!;^p4)$$i!bc*_x92`B&6*O
zBzamAN&hqP@;;`WZb|gD-cN6Ywj^k=oP`L!dGQeurCVl;7nwsu&4ukg!tD*Se*8H=
zE0T;{%ttMvhBaM6S2v=r@oINJ@m48Mqj*SC0>RBN-D=NdFI%@KjY{;Y26F&ggBVJ1
z7G8W&saZCV^yY7R=bg2LN(W1UtnNEOv@BByBcB`gYh#$1S>>C9T<6EwZ!<K6w!M%c
zJ(S6naUq<F5B)Ml?$}<xHucr4pWCb|m_EEI#o&PM?I+PVh@gK$lCIfCjlOudZ0u@<
z1v!X7V=E7$51bDV;LC1OSdmsidi<GOvC6cjSuUw>3MIDgohHXLMr|ghBk`;G0+AM%
z^ek(W>Eh3)u;~T(18xYNp$+zIiwhFmHJZqjzzk`wJVysMVJ3?~*8YYf?^CE7%GPgO
zX2WNrCS`MlG{-#Ap(mFia&0mPokV*Ms$r=o!D{uWh(<UzPHVeqf4l^BaX8WwH^NWk
zMB`HLg{zCk487dF>f*K-{=EG0=HMeWel9DtQEtm^V0o==?&MLJhTM}Gw2YcYdlM!h
z41EcfFr`ESI%z8IqI7m0Ud)RY<2xIAyyG6UWWC?w2ADb{4KtCZJu5Fwb*1KYn$mxY
z7t-AKa96-pO$%^{%-9GOy|_E!z8Zxkk7PeYm5CtLwj2C0$QaK+tqz(v(ojjhx0;OP
zWk3;us5@4%zssPv8FZz*Dw^(MMxN$-Nh#UWw5Ba2`y}7VkmH^mXXk!f_Mb)4rZ7+j
z_3v)*@7I5SQU2Wphj(rL!+U|uw|-wIN><i|w=@~978J$q!5lHEI?rBXjAW9(7b74N
zASru?|F2A)wuXYIP%lUc{R(0L6smwt_!4xpUYEqk&WyXDU(7r<8?J8uQcuryzTvbG
z8nd!46^%y;g2TXv{J#}P3+2x)z6_r6H)&W+!~`+MMABPM2jd@T5Uov3Y7MLYy~ae+
z3RTnA=OE28Y#`v&-XvT?{$-!6Le)rld4guCS|MV0oY=Hf&BWMgR9~mdkib0omWrDq
zOCruTnIeLSg(q_;p$e-Jo!Yt}lSHbiVnc?nc7o6}l)|ENcYlAsT-U$8eQEwqrpI(4
z`5DPnue*&)OVg5rdgZGFqVd?;*o>cFB=i;1*d!TH<NQn?KhB_S>{2j$L0yqVLSiSv
z6jFfA=WQ*HykvblAWSsBGNQ(<s6>`1(~>QtuT>&Wfe}x|t4DxSB;+o&0v#dX%gi90
zLg>aKr(7ytMIE8}mEae9Y4RoR?^`=)KKIg!VEmy*<VM-<hN=#yl6%+KI6vL0rd90%
z6Hye=BpXtB+6;>k;l$R}BxU8xz1^>VLqxj`4o)Q<59Buey3Wm7Eh1f74~Eq+Re!ef
z6Kz#`q=AJm@LRb<J0epyS1Egm@qi$F(qxFZMA;Q!o~c|kBaxr5jb3#XE+AgGHEY)J
zWC~z0VmeT|1OdzH+_4fCdNF<ciJ9-K58ZM)Wg#~`t)$HFn5PwdUEzd9Mw%ZDjd_u@
zx~vF`F$2iQXfo&L3B@5Hex-dq%*9noNDyeNtH_uhLsh6A(Wiw4^-6MvT1g~Rd^M^2
zG!`%=$1N<L^cgc7o4rOha_o<ISIe$gT0@+DYV%K>Yr5ZfCn7Y9Wn5j9p=s?#2VAV5
z&wSOyr)I3%MyviLZT9q#k|!y%RG25E>5=iYk&Y<NSd(j|A|s}mU;7lHqO-(+$Je;Y
zEkR5%-o}gZHHWv4(&+t{T7_)u7CnLCbZ80A5$spu4?zm+R)+VqQy^GMH3iurkQANk
z)1s@HnFI^=A)_?vEsFqFuV>#PijGRwPx3fso?L0CwPLR;I;W-K;fk>n7v}1Q`K4*=
z7Wv|gBcd3$7}>lsK^9h4eayzmre)_oa<UB8GL}Xa83h9>Wi>9I%;)pV??VU(6|V-~
zt)vMmAvR*(b>gI~DdWHCCG#b-e!H0R)HeT2*vi9C(5hg8T>A4<=UN)|y2nBXUA^0b
z;Y_}+9~yI4*q2}E`~U`WYXVd?B7DDkA4eQy0$7O8IWS9s5gLCVSYD_&)H(yahJ8w%
znXbb@BUfixJI|({kvC;W>i*HE1I^oNqNeZv_-^f*tM2~$ZeVm4@V(%%z`<Lzf@J$b
zI0W4+u%^QCMZYgM1OmTv?}thfTz{DBtbqL=ALl1ezDW5W)On&8l}JEWd|R=)(N7x5
z%L_lsX1lHE@iDHf7gsbV<uCJ)u(;a(sf?PBXZ9`4n>74N{>x6Exc1VNdK~Ub;kp#b
z_E#-W*9Mc(+usJUTT;R8uWmbqM-bX|LOYe`j#pjQ`IX4@fPv#1@naV==@5jX!pd4T
z5f#F|t`L{utfynPnvppK!Yo;f{B+6iSuK-f_4^{^Ou>WN%W6inTAQgXgsMYk=4GvV
zUa{wjCTfT&;vkRz<7S$Zww;hfggo7s-nPe)jA{e%x@qI+$|lDG6oM<+#b32-g;w;c
zeYzzf2ff}-86}t7LiR?|q0$l4u6qk8dTdh)MepL&tTOUjX62<f&8#u=m@N<08T&M)
zpw#L!<=JhP@6>BvB3zR4&vkZ)Q|)xc3G!}M^re^4GDg@N-V3Td$07|+UT1FVeBHLt
zx{WR5!2eW;^(#83lpK*ju3kKGrUL4U-?@lNflB9qpiSNLS|ud$$~BLw)u~DJVy`qS
z1|j?W(m0pgY4f}#|K5=FG^vQt7pWC1`U8_h<9RwO6a=}*BpUMs15F`QwKYl~1K#sG
zdbG7X4_6ghA16F!)<UpKp&q{%bb}{FK8e!HoBo0z_qWflvc|tIH}!Ct`gH{kfe!Ur
z86?<;)-;EKuUd`eSc2?i&A0}wDP92sjcrYH+CI-NRb3>^V_Q6T47~9ir8lim+k@h{
zX%6z*l8VebUOr|&(p@RxM$vKVL0Y#umTzixi)MQ6F<Y#NUx|181C8c$j&iLhf*k`b
zpg5{MfK;v!quTs5mTJPx_9=H5n(i~AA&1m%7MrFE^^`h;?-Q^M^W$Q}z$k<c|5j@f
z(Kanivh(xQe77Mx#BXjok0uxpnq#h{sK>|lzOhL**48#g#`d(~mV|J^2{jqas9Ut~
zK=)aZhvG31<=3|ZB09vtJq_d~)%+XH8KsSSlWNe;KH>GT4}>A@9PM(hIxHV!TCY4;
zN%T6i2+(6_>+9?5Y%;4mzIyZf+rNOCmDSaa)9X-_sg-pw!<q8odt^9<j#Kxkw!LFZ
zXHRG6p-5`UzwdtCdmfkxvQhl5syVFRZA@<}zL~kUZpg%e;9KD!m#-?WpDOcK*hMs^
z>M3ZZ@$kEIn{q$KOy`U}2N?Xc7AHEC!?W*g$bxQm&P{2&P@^r55kAQDNyM+okutJ3
zdQIXhK+I<=UvSP9C--*CzJsrBC7oUWQj}m@NE*S<83?1D%X0KyKb<~`Ba+KgJgRWA
z=UEy-n9McrNu?WaZ*I;nGtAF6Gf!FnaB0|ZbZ+mhBJh~R9a6PdD4k~&wAUJ>!jaHe
zu<sBOG04W~TA@qyk*546Kapde^3k^WT~p^oXcZat=82vXl@d)ZaRo7zWM*e;u2cJl
z8L<r)h~S6fR8W`WYJGFZg)88^s5$jA&|(gde!tYILOxsK|E4VW)JrQ=`aSnm8Z(=(
zd>|&80*&v1fBv<#5EmKKZB8!<Lc`r@4Wk|P9X^Lt)_S7XMoT>z^+~y?a#%n(fkL)h
zOxDjgUfrj4)j1p!@Rd&C;!O0UVqv~XF7K{<FQG+ZhEI72iFYUE1vllCzAm(cP>qf?
zCxe>m(J?`z%!;cYQg$xODsRfRoHk4;Ldw~vGS*)7IS@Yb;MxGs&9O$)>MbNh&zus|
zhoL<`Sv92Dqh$*(tQwuVT}Z{REiz5{OFa97oGpvZ*0y!`Gc-HAPy6&!8P6x*(V~Tp
z=d_)Absy~>pqq723_?BxetRa3Dyfv}(b79%tdl?>nd6$l@~JV`=<{pjg;TGM-2CbY
zG?=;nP~C`13zGmERLjo5X8qK6y0`$>KUcOAH*E(IO^`}hS)1=r@7$h<Usj?#o!zpc
z!jkhi#i?V%sbfMD=P-_bR%P5eWayh>J;#!LU!Wr^)<+d>MM8-;6O!ITw90%Nx$D`T
z^vT3l{q){jPA^{FG^+dip_&%Yb8q==h2NA~DC*)wziMylTvIE~sD45(^7LjMBRnEq
zNpiPuZTq7`M;o8pBLoyf;cJv6`>c^vOlPV(!_ie2;8y+iQe@A1E@wd?SRk0VI>YJz
zc?b;@?c1PeLbjmr`IlQ0@O_4lZSOT-CEJ_gk2p7;zuXOLtn}LZ`nGMEw_OjOg<^(L
z5y22~rE>OdD7qhvoQ{H)?k7ZRKg)b~+P<_14EzJYP+u@=x3;aJKgiFq?#iJ5YGY3H
zzRsrLb_L9`{Lz2!{g*Waj5PgvcV!P^t#`zJVf4Fy8VLPIP9iGXf^PRS!`TCls!Ses
z#U4sIIOyPT>Cyrpeg<MhTxHHp5`lcm=gQIe0k4lAl_1EP)IxCS_nI7L>I_I_QF!<f
zS4*$MR0_(UM5S<+$)!|lewB<t#3d7@5NfGBnYnK!NKw}mu;OkYrnGnyWWa<ft&q~7
zfCPunE4MAFO1O#?Sn5UcR2L6b6RF0;EuAFzK4}z3qZkjpiit@kdLzk5>Rh6#rlR#c
zLN^6Dj(+ZwmadX5Av8^0pr5fi%~ujpnU`WKpOOAivJ^%wVXjz|R#Gioq(;h)aHqHP
zsAU<IJ04xq%vueTA`ae5Ms6uY(*g$=DuVVol4-sKG2{uVD)vuQcciM7F1k$QGQm%9
zi6|OVYMEG=)FH{Rj(QoQGA&I!j&3bIruw`1--_A!XceZRPq+^onW1q+R3nJAUB<)}
z8mgFxP8FK+$~PRz*mE%$am#<+u(h$F8Kxjl6L6BVFS)Bv594q<Q4xNPYgC`4N5-Ol
z#?8q4o+3`JrKz|JUR!D8jzupW@ew-yi5}_s%_mwYv{FuMFEmKcOZk&a5g|icA!cG%
zTp$`Vu@Ot0Ppe+4E;}MHG?Eb+yOJpBLQf$W9WpIY#E1`#moyyRF0soDb4D)HeCmH7
zrzL$nDB2CDrji&;j73f^#1%j*BOD;3s$@xGA<xrK*LsZ19IaQEamz`Thoy%s8;GSD
zV^uu4A7$O<Ss0Dn=`!QQk$73nEJ2N^8z7|}4U>S%lxp8<#UdC{F;kM$BxzN#Fh^<D
z;W1f-+ZVi$^psb;6Ya2}L(WX^H>z<xHg#8kX?-@<w)1croNQI4efJMWySwXJxm&a8
z|8w)Oy>l=7_Zy|rI~OyM%zrM41Th1lu(c?#Au4XVaUl|PiBG*R)aS(hh69cD{_oG7
zzc<JB_F%-GU}H}J(9`ZdfJCu>b7H|T*)A|-H=eDJ6gBksrg^v6PR>B5klD0YmH^K1
zL1FL%AoSL=T5M*0&i|gwJp_ZHZFSnmQzj3f3b=^Gb{0ISH!%TH$ZaZM$xQ%2KAFxW
zK@f0SW3sWi8E|c|1Hkro9HDJ`dg0?Mt7_RD{?Sk>)5_LG$>*w1%A?4t8L#C{*f6Ci
zs?RWjWao+8z01zTYUDau9Y2Xw>3{Fn8a6sf)k3X)nHSvpx{BAW<3<h5i~`xAV~`);
zTe1H-AYLqddi9MjRE|b7S(Y^*f4WH@Vk$_wLen~O9hCzOSZ&cf6Xo;~MEVYoMCSbQ
zrgV4QYltsi<NtAVmT^t}Z5$pWoPd<1ATf|GX(S{@ONTI|rMtU9MhZ%ION}1gARW>T
zg3_flQqTE6Z+w9t=RAz#@7(wIdtK%So?1rMfhyE)N+}xU^_zRz?lnA_406o7Mj+-!
zft@e2`AW}~-o4S%RZFN0&HD01yo&;!PlSmrCGPE>l9#JBuVV&=bB@F}v-}tsXWo#!
zq}+Wf?=G_t*w$SizWJ_C(z#h{dm(Rddj}0K$p%kMK&^U~nR}_GP1-nb9(Q|?XO<$D
z*$_RL+>ucICJgA%KfAOkk0>2Shi0R?bE%zl6e)@%*u-`}h`q;2CyejHAlEhLm2fey
zRi@U{9=@C)7|M|SlA8$pLaR9Lply=dpfkb~v9yN9`YRP)E)k68G#Vz5Lbsyg-d6m8
z?|+C+@e8-v`sc?>_fa2tgZt3kb|XFEYk=?j5x64)bS_DP`sJgycfEmufZU54x5}Uu
zsJ&anOfCVOwtpx0YbXC<yHB?OB8=5c5)^a|2)B(qTUWVpW%_&{JacY6=io>Z&>cXx
zd(A7S?geC2|9?($+jaVK&iTR1)w_8wQ?Bp7(JEj8sBdX0Qyl9k6QEmZptx`NdRYB*
zqoH%$Qg`@}Yt={#N+=8@&<#bfK|s4-TM<*z3CKU=ka7OD$2!y91eBunb8y>}dtida
zTm<@gzNhIeH%vKvZ$3DJX1G_GZn=?2L+G$;b}uR?nWB<eep}k(Ky5D;i*}jMA%ZY>
zG>5Q<-PG)cd$RDG&;ICCT@Ay{sME>mR?PZvWqMW=B-ikMdRY92a}Iess17GJgU7dJ
zyxr;Rr7wYUFxgizTHZMOw8Np00k^luvwGa!mA?H}JYxwpjfX86)`Yk4svmRmupc;x
zHs$d}NqA7=XYxf#NiSRV4J6Nzer8FMEhMsfSvkk=bjYXuvU%cOvbDVwHEs@o+67bF
zUju74Cinr+t7m)9Nohvl?CMI7Pt@_Z-@AypkpRRn!8Hp<{|RvM&T>$585tQs`xQp~
zX#;4yKln5*ivjYBIXFvuDD&b<Lj5YuU~MR4L^V#GlTPws$9kHpCU;}?X*+3xpQZUv
z5*@{@+l)>g_7`_I81Bxef-ANM_D1ymjwDAHmvgng(w|IvXh{vdGbTN<KSjF&I@U3*
z<$vTm#(6c_t-hvhBsle+CvVv+39kADNK+@fJyVFuE9~E;Ug}m}Mp@VV$b5h4mM7F*
z?>k=U%l%P4Y$~PAwWp1Djl!4SKvUK{G(N4D+vnkCCkMDk@hRh6`Qr9cndNE`Sj7kw
zKXUY@8j{DcV}sbq$$9RCx!{!W4ETZQ34J3U%){zta7^+N={t8~5>Mb5G|Ucn``(^?
zk<GE@ai-9x|1RipIJT2W%w)aT!2T-T%a__aBb~GPy<IEKU27w8S0qewvDJMlyV84<
zXsuj#ZVepU8zXbP5up6k>SXUuP$Fhs{nJT|XTSbOI}?I&(M19}1tJ)`oNuvZ)X7g7
zii4Q?iwP2rsMXAgui^?T&QU-W%I}gvK<LWOSD-p(RQ*mH+keBe@ulOmbDdaQ+ZJPh
zWgDu`#>(vQNyGdamTd89)#2WquPx~@%}XbE<dUJf?xh1OGnxG%ox+uL*=2GmqrvoT
zncI5tPD9)CF+a<;EiC(?A9ZhKvCDs+9+@8IDLL(|^K1Rl?DY{5F1Q@BZ2B6}LP*#n
zMK2j7$u!G8f+ZoDdPTc|X5&HrskLij_48?sXX1rn!U=M#DZug_No8aA{w1q|OT=ij
z;8^HqWj0^M2+ASxrnj!g3hsltzrKm3)iuelv~sYmIeh$F?C(2({v=47nfv;Q>+gKe
z@mk>8Slju_4J=k2dY6rn)_Txy`7jx^xT@wJ^7FHbeSi2N53_wKqyATB=L1ql#OF{K
zkNTipu%AlAqe7=#&$fX1UmugW_n)7V@9jc83WiR{7hKgB-&YOjr;%KmC%I^<pst>q
z{(W@9{y1S+=~gw`aIe{NOXj&$zM9Ukmpw3W*-OzB;UK$0BUW7{$+$ATOr^qpedJ<=
zL;J$RWa-(IL+Y~!1z(e?XLeH89?*V~UmW6mc16!w`M+dVF+1RC^BF~4t>Uh55;eV-
zW(~MqImt{R0EUdJf&Zof>*d4RRY%JEShy{Ki~L*j**_*tB<q;0^V$*xKjO`~iP3lg
z0@TV}o~`ZD5%?6(Kk5}13m#F-PN<4u?aX~^dam)_W?K`)nEKBg0&-;>*lY+yHgt=4
zaZ+*WZaW$N^i$P{glJ%}m%QOp*?b(k?inUth@hwT{8wpXkpFSSabJ$QY|Hm2o?+_9
z-#UJQaN;n#%CV)^yIzfQ3FcK~^k>7!O7BoK_DT;%?!^zZAN3iVMsrSid9R3eawXQ7
zt)e5OyM{TMoeObfRmEN<zE^KB4nbpN>{=!8u*<;kK*JS<k#JTYfvicL9kM<ZdHp(f
zr6jD@aP15TOkK4Z9?r=;yTRm>FO;<IQh$Zal^WjOmqdwCj_<iG_6xm4#V)Z$;T7St
zo=Q|=Uqw9es9kA1_`$oYPm)>pg&)z1g%c|F4?B}A&BBpzt1RG_^kik-2DGyR@N59I
z$!XS!pQqKl_X%+S>m}oCyP2&DxM>W$rTLHF$i~J7+c$a`3A_PRFqgnq?tWXab7-{P
z@T3M9IQ4Nb{kPMISq$qL9lbB^DroR1_~gLe!_NKzd4dPRnGlLmKdmB>to-pdOD0vX
z_;T^3Tipv$<!}_wU@}cY_q>kP%Pe|cx@W#J%B41AI~9ds;gb#~(dhR@okp|Fw4fe#
zsQ0(S?hEBlWJteKZI&)*OdXCt=IL6(hpZ<JKfn9QmM(0>Q#3Fx1z}dRV!|w_`@cj3
zhWhxCf_LjtZOzxBVEr%Pw2+`FvQXAW_JoH3W$V;W;lj<E8qJ+E3i6|O8UH?f*R?La
z8TFQ?q7vX59AlvJs~VL?TeSIlhBD<p8V(=pah_2e)&D!DjF#&1O`_{Vt757CO<eKO
z$n{L0O4tL1W|F}ZQ^WMST)R``W>f{HOfCk?w7|UX=%|)^zh51B7-rK?Q)5u_MoqZ3
zzUXCmZsufEc;_~&e%Xp?VIcDe=~RUF(|Fr?if>OY&2s^%N<a`d<hk!hqqbIB>@7Y^
zS;-Q4G=i1QAd`(@alxS~Y0+yus^|keEmCQeeljk}#<kHY*O+<kl<8T4Yxx8Or$Fli
zYwuiyi_r%*4P&E$XU9K^Efoehb4=IORGmgh{gPTy<E=52L7xJqyE%wVs#5-2zXF!w
zDfp`EL_3peM={EQ??rSppg<fUL%IXU%Q%r^HMmiS-;l58#eNbnagk%ON4Eb0zTAG5
z4J;l6RGD8!y(0XMYC85K4iC$PSTmr9AlM1QP1+5kQI#*qjP2{^rXegat@7C)!evkw
zNUqp`^SiIH&V&+u7%hh7vzvoTGM07DlH|Ybb(vhexnnkc+DTcpQQtY}Y>N2vsZ;fU
zc653?VpGV%o>;p8Bupbmn0z<te}oBLO1)w3S|Tr4PCIxbXa0iLlq2o{<x^O$9wZ}G
zgqZmahrw8)Y+t`IN_z66nK`C-^r<j@D!knghwr@}8{M0t*w>oD<pi&ze!)4A!|1}8
z#HB0(c|kg5I_0HN7wr&<H92RkCX)*;BzO}ul)Gfs7F7n0&LzfIFID>c8iOG!ze#6W
z)~v`{Oo?Mo(<T)Y6K1PjHUCRjy9Jvb%n}!(Hs#DKg+b-Sfo*%?L#&}~7NnP`u@-Ha
zmk<+q20@_UD<k#lv&=u+`f4Qm?#hI*A#{i!4dAbD(~=@MXM|w27bsmRp+R~}467o#
zf!zdLp;Q@`1GzEj{ux=lpNUGRZvG_ui8Lx`vRJ1|+klmh`<fQ=v1dBjll^mkiOw%?
zX4?GzKEG-gnKHvFHtm~qtF|!7_=a|upEzUpsgm9hlr<mg83@We#t0$*xZA(0`5puG
zOQ>v~0r=n%=1Dv+wQgAa`Ll8m6!dfGJmJr`EP&VvZ!b2}yja@epXX<nPY-5m&cNVx
zLvau8yBC$S=mLL=P-X8KG#<weSz9V$1&c6AylNeAandIUr7fAYVV%;R=F;^>#?pdg
z^RK>GsuT1(S7=CRXMtr2>E3x{5l=47*tnCFl_?#ab>aRj=f>X2>k^Nl3a^2TI-B)t
zg*v5_9^AJ4d%2V*==JvMhZm(1eh-K5`@@^Yi2y0s&I&MJ2j&Ei|3wmj(~KZ)C{WLn
zfgzYX(S9FEoOYb4FgQ|#AcQReHJhsV{drF3<&tfzYyrVn0vPT)0vR2aX%#;aHa)AG
z&%sZ7xN$xGI;r;6RTWv%+pwcS&`&0VirNBLsiE9m9W9ilTX%8AiFgIfxV^*M@fxxj
zL)YYB9>i-#++JZ^se(k1;Yo3%r|uvL4-BmK*-WXl(iERI$jUK<_U(C*U1x0&H2pI;
zE>T?_#E)O;L~{H%o5~&2BRmRRL&CUV9$GN;x0s5Iwg5!0losMtuXisQgfOnh>*eNa
z(fA!pAT3eE#NK$9A5M-TNiLh0zmG*nNN4hxlkdb*)We<GON()W5_pNj{+&$#C+Lg_
z%S21YSgt2-<wRAa4SrrA9fU9;2qV<yk4Sw5A%VtHpx>M;mI7~J|GkMM9!f8D0gn{H
zPhsA}UGc_#J(Rwzku!}1wiodljret;?&sbyPD~PI)1&VgFJ900Yy1Y5r(v_tqz0&%
zV^w~1?`{gHL4qeu$j2@52un*X>FGX6?%s)FnUI&E#g2HJfEBmE`pUJC?i#_RL`}!r
z3w(qXn3o0<7Dn8yo2e!NLva89B5u8k8V%N+H$4^Iw>zeI!5>wR7cwjw1d^v>ex}p)
zEUwFM2(n9u8^Zm&8MlXGrxrvMZX)zql6e>dZQDah_<<b)KVXj0(p@C~(^pu}^buMZ
z+(RT0{*D;9WGy$iQZTB%VH^cb=uM6GA}vgfTDl+!mFms>O^x0p*PUD@3CRwUrD5*j
zD|)C0ftZ7`2VKdr$WKMF@)%(uk-sPJ$|%C=#!LvJc={o6JbE~+N-?iZh{wCpeZ@av
z<)JQj90)piSsmBIvJ?GNy_fw~+fVTHsm7Zv>LL**-V?q6f>#Ch_I6R}eU;(fh0k~k
zchs9z2jcI*!<HUk#nIJWSXlx7amtz&T+sjUYQWak(0j{#XQi6{70Bmg{!P}w!NE~D
z<`;4bXD_j&fIVs7I)M2E=e6LuvCw&g2es+*u$bm6aB2TcOGM|pZi8x>W6jTsrlKoe
z8>lqNnrNG7qbVA%6-sufYHVqVa{gV$ut{h--*VCWWd3=EkYGK}CppQvBSRyDSkyK)
zrtly%SVI6kBz0jbH}@TgnAt<Y7KutOY=L6>jN4m5F$&_n+?;%aB)*Q-0>Ml(j!MN~
zkK|YF3|jrX@7A#91O;?<azRRVZeJF&-3>%|?oKl^8R~$ENLB?8z8i8G@=j!{@1~}1
z*n4H+umN7a$mg+Y%A9|}pzNdI@R77ei$FaL@Q>@4Bh|_kiT{l9oADg@jK2!^5{hQ-
zF-)(ABUflEV8MOOaT>~XLTk>%409H)b-w=YD8mFWEVZyBWu^^bX+mXK2_nzDI-oo#
zFE5>BNMio^-D2s6Bsl2oU8!i)D=5f18ChwlYTKg7!$V-gb&-(~U&!{AP>NW-<!E-!
zhDvLxqT>bHx{yciq_SL!At3~}-J8GF2Z?IPw$_dXkJsdt%!|Zqi5d}_RK3Y6oQ21h
zv6Fy^H!S9hUTQ{2V|kr=EUnsARW{_SDHD0jUHx`=VKHd;{3+VVdr7H*0AN*DcR;Mo
zrhJZTU54f;$?t}H{s_bV%BN?L^%a~IN2<56()WU7ChrQ^Pt>$5Wh(}AB&Yi>+BLk3
z3KE_A8OB5#KG!@ut8E~I;X+*<XBJf#yZo+L2`ewC?#*I-Ir0Eil21&_IA^(Pg@$h-
zw24Nj7RC@@W^aa?#ZxBffr6v4QD=Dl!EXo&vRsjKHd}8rq~`1D37b{kK&?CAq(sN=
zt>sAVEb<MTu#337MpL+f0<ixfh*#5Cw|A_lbg(KYB*KIZGGj?9_t3LQ5YG(z%){+t
zT_Qc-p)J=qx9WVIiKclhH(px%U|=wtQ27q+z)|_lv!P7SW;Z$zgn+PR?cWl-YPLWj
zi9gNW$e7(&E$?(L#PW~$37iqs6~b;^)wl%L4z6Ux46EFE*IHZ`ll4wr?`UlHfaB%+
zg06>Wur>+}*(bGvEpfwmYnLkMHALT33#Q_{jLB%$2RH~4Xd%EZ=Nbs%JXve~mi^Bw
zoe_9`?*s<W_eYLzZwqMd{{Wsx!sM;3?P=9c4?q_;;kW(%?fstWTY$d}K>V-Ja@8G0
z&&C|ZZ-B|o=JOnYmHt>kgFznkmXOf8C|w-^DNBt(q>3n=Ud0%^g49s&mcrhN=}#0w
zKuF6GDWM7ljOf9sN5e8J+;{|CmL4iC@yj!@P&8BZsCZTZ;ARBn8)o1C4idYd0b?+H
z3wo|K&0HNTKu8Ev_F;iME6smRVCzqvBoVlzNUT<futH@p#*KL5D7^GU&MS_|pzT|t
zlzrt3_e87tF;7K`x|@ng!|W5l{N}h0ctYh+d;(StcWovX@J<v2rf7>zpsuaAuZB%9
zxm}@OZJ^gz#|+g-V(9`(#H0H@8Jb*th~L%n7Q(KI3B$iQNLVD~F=&H+4YUOj=vd5m
z*XM`Pk|>xXf;qtXK~yFC;0&B#s0Q^=a4mP(q6ylT#7Iz8Zn~sALwZTx`2ugPgfa^;
z6sm#o!M+q8tU!6Z57p-ir)<zJ5e$`of>0sUcEOGZW7x48%%|gkN5C~2?i#wzrT*B=
zQm{fa_>Ha!wK7wM206yGd#I}^$5-$xL|SfmzFi*VCU2_0Ow^cfk=hcsLoH|!8YL;p
zT*O+(Mn_1&kd>>HXWW5KL>}G3g+Zcg3vmd?)thgv_-LMoejd+;R?4iWqQHQ9BCyt)
zD67&$K=<3?1y>Pe{+e1zP?`5%X4R-J9#emsR@r#&c|EluD)3$owb^V0m^K6iD=S+U
zF^ZJb#S>+v;)R4FCUz>Vprw$dEyB3P!~2fqi)?Z%%*b3~4`kpcOa*NnJ@z+0rWCwm
z7o4Bgv8qpv$Ui%Vh#0aHzLCLZW;oIwngRw)TD=9;P|VXZkLP<UxYVa?*3bg0{-;W^
z1$itt2ymvbbBqMe&*UFIPMEX|PtmGqcUYBRtZ99P@_86bmu!5|0iI}5dpPsUvzd!M
zv@3M1XQYl9I8W_wafiyjuFHc`k)?diUYV2oPWuCa4?2yAb00C=qY<vokI0L)|N8B~
z!ycfRlgS5&i2#W<BTMDm^q$}SL0|yDue$@Z7d~4_?_*y7mv{sI6H)~f4uIg8Y`_^1
zj!#5DKtkInhDG`5A-7zG8(81Wjeg3D$8%m9Y<`kVD_Ur<&g1?q*W;d1wj>CnAg}m4
z-pCX=EE)=lUhg=Ig@H!e2w(&II11g+^PVwgZ27Y`x&Tu7#cv&n+-Z-npd`9bhEDl{
ztC@X;&8AeIrB@Sne1y>@WfaP^wB+hyjK6A9{TcX4Y;d=GbVj}v_eq(W@BoKv*0Vso
z^3Xx3w@@Q7jr6IsRc7-X8*t=y8ssV!`qrP&mX);6u+X5(4Ur@))FJ$$rA$Le7gUL&
z!}R2;s;{e%50)jk6Kd-3VVM20^-*GV<|Z;sVaS<w#}q^eLjQrQ4VDNMDus~8HvGbh
zTP}+xA%qaV2-6FA{^dc#HVnSK;tN8P3#g;P<X9r-oQBWvwWE%vLxZT+M4gQex+^&x
zNHG)*>>T5L72+EY$oLKXi|t5wQ}zcibcLP$siOBWK*4-l43wV<pwRB76g0xx7}b@j
zYp#bS<k#1n$i0L0w!5sIO6yozTH-%oOnMw}u*7zP&R)Tt1g<XnIVQ6tDS|Ne_r~Tv
zF^J%g<RQ$NkWrsdaq|{Loiv_;#*;=^f~J91^&TYEC((e5v_ol02Bp3$1iue@`*)C^
zgeZ5E7fB0&6qgq2L}i#OWXc#!I=!UU2NB&?Soqp0ZO2R1W-1W+R1O=*SL*&w$R`Dv
z)ZkKkRqDn-Am9izA$;%R@3aGyJZ$Vq+B)M=JsLn!G&UkQ=_v@RIKp@%oX-tOC0w72
z1ol%Zg=;1^nHph~2UTr~c4e%{w(9WeX(fZr8mm^D(M-z3q-26vVU*J66^~8FfS|hk
z`6mPk$hT)zIeXcymEcvG=u|JNEt98;Azwl$`KKzH;Jse7yxt6Lsh{Y<=?XvXZE?Ye
zuEQmV$MpJ7hPQE=?3by3^^+UaWt$%S`RM@u>??3O)jIu6bw|Aw5QS0{CC>fh$_^B-
zVj5L?V&t<|1km#=5mqrZbK;M8XNsjN-~Mx4zA$6_^%K$+l0_`S^6a&W?00G@&Fl|-
z%x(V7gc&PXlsEBEBx$|`EZ$`yD4=yAL5BdG_Pj|?f>^`UT<mWeS7t@e3*C<ow4GN!
z6ka<Ec`VW8(<SBXlDKY9;sBRz(sW`8ToMC=8!a8eClIbK>bY)(^*fX3zQ5%uloM~A
zcV4g-x2Opy^fed5K<bFKazokDA}D5jq(2IKYHCJm9BVwO>{Pcem{8sI41~=gcOkK8
z8m7iZbbRA|sv9o}MIs~4C|CQ0Ul@cJIrvTRj9a$_L-cH$K5Rj075SoigxNPmD}QRY
zRDP`hRWllsxJ;CEoRG4q;9wK-e04{0G|A}p)j}P&M`|q-)2rIqn(Zs1(W2QAPwND|
zIMG8f5!KW$Bv{}l33HNCq64Ux5^6CRPbycm@y7;fiH#E$cKiPc=hZ>V;2$M|hPcl0
zs9XOysW<*Er|)aAe`?63nnB<6BcV58a^~t~Om1ok>CUz=>s)`tr~4o3-QZ91by<(Q
zM2JC{ViK-Yd}^XB|GHk+Aj<CV;DzUf9o>Xc5X3i)_u-4NZ-*H?GLo72^n3jVLOwJt
z2ON|cI!-$GRr>R|SY9r>yG~r^jT)C6nDVDKQNB6Nh)lmbNIR(-+SNyZFdm{!1f_Z5
zrQ#4fF|di9rM<^jTZ0t-BrTQO2!xk+=1aW)h5=^%=D+MD<u9k~Pz{v|!QNKaYYry*
z5{Ci|op`uKZW1=sh4^S#PsLuU_RQF_M<^0&9L|b9i2;2TZD=^}o6sRTC`lA}SH3zP
zo&AQ^2bWJ<LWZ%UXwSDn3omMLE<qifPZ;=D>db0x^pN>kgx<dM^-g(8pzIm@Z2rnz
z<l}}C)4vFoI6P`XfCw^Vo%qu}^SB8q+0>}~rypvjeN-c?Q|o?bkEP|n|ExomBvi!P
zChfBAc6?OW<=ycOPA~T(9VBGKh$(Q)L?*ICO$_pi14P8^pYQA>Ca*>JoCZw~!`TNz
z8iQ!(j6m(L48b4zk1pm}4Jz1s_d)roV^oIydDafxaV09EE|J~|@utLLI~Ok)w6=AR
zB(|0G5W<)~b9A|f7Sq_Ie>k&@Awd$W#6byi_7z>ctX-q_tMYaklKv&snVSDbawI_q
z!a9F9nih46u64&S65tsl!y%#=OAslk7rYQNd*Ufh>~8Jyoi}M5vXLaFf@aD#;@CnK
zm>XXV`PAN}Z?)h(`*dc0hl7BAh_W$XKqm~+wat$1J*B)<+)0km|Ll(Z-gD1G>t0i*
za7--Gxa5Ng!fbCTxajiVSKG(-#7PLJ6>a=mJJ1PB8xdqpg}?YkOFAimec|U}@nAQ)
zY5sf5l#uJ}G?6w4(d+wr+#DfxO3?mQ@&$1l``!meG;Dd=jhEY2A@pT<1%g)ms?<#o
z=ofQ#@P|LIw(xgu*D!@!Jm&A;A1}Yte36L>CStXJ&&4MG%8Ko;#DfmU{+trNU`Q^+
zBWYkL!+t_{kpW9m)@X#((V(-@w$5~;QEGo-^qLIAE1N@FxFul6fb3*nS0pT*I6*hV
z7I_x(7JX6KobZ_B2WY#*fNFJZC%B_83c(0hdY&;pJ+BO^{~1xmzD`Na`2rnEMDG8O
zDB#JCUfC19%k8g=ua%>49%PuP%9qael+vzWV07e9Cr#3<w_V)7Uu#S#{%%92T%XOD
zC&tvImu2uBbiZvI5oZV=Y~!+cE7R|H<#*NU>Y<E*H6&m0TV0L{yFxCTODdfnLais*
z$uQuXiO1y#HC1cRuC#f3pZ$tG^UXLFDLN?3t{p*}>vc1@G~5mxO=R~B42AZ;19`v)
z0-?-b8bP@j`#gx&;UI7bRH`kIfXXqp=7^;!JUC1k_Inpui;~LD^f(ne^DXlr5M610
zr^ADDMW0ir;Tc<#x)V#@+dA|cU;pmSnJoQ1BFEgaeaD0%wCl%0#)Wa%FR}cyme%ee
z42+ga+b&Eq5QE0j&+R({ISk@_I#d2yUIp0mBMX50P*e9|yj5aFd%^jw2Mr9AZem7<
z8x7gc_7;vZdpUeZC`FFWxr#m~Yiu&G7D?0Mq}La@v%2B=7q(M-N0R27M@wrXtc%Uf
zRvcpk-H6+{nO8vYn~}@bjI_mRndA)_xU>AB$Bjy$W=>8Tuenv!ib*ie`%Usni#5oN
z6Lk3S1Pn1n5Xin%7Inf+uxQU3&T7^TF;2i6$u+vB?PJ1WJvW?~fP}9F`0^1DXp9ok
z;)j#7AV{6fo9@bPlOmOHp57F2^iX*F`&Vl+f1k_yjjoZ8j)#uL`hgUEN;U+T&c6zR
zNTa`qCU~=<t`RyI5@yj+0s>?6_<ZBxdi97&AUwW}{p=a_T*Nc$ppW!DQ8RrQRNMYu
z+ruvFzLu}I`Hf6@ox_X3IKocyXUY(U>+IQZBS^~goqi&HQuq+n$E1$I5ym&+qHdqD
zgPzQ#E{eB~C(P3-YOyC^s&Vr~)T^<E@O;ykZ(BLGZ9FsGd`UX}hS@9YSF;G(`DBB6
zV&Lmt_cz}<g;m?#6^Wd(LOe(?(5Ga$gy=KV=;g@XXdBbyc%FZ1aCvF&Yl`#3zamiu
zu`@z3&i|yhMCYTtqoj9+erWZt#K|;?xN+eVF%WYRDm%Qe{;St2r*d~zs_N}hk&~k~
zQY&z3b9wCx`jZkxT`Q+(P?M77E;mb{{K`XB>k<z|Lk{PgW=|XfQ9g$e;wF|WrGKiT
zr)3xVA}2b;mwV36Zl}0E4lY-Q*S7q6UE)jwA(FH`R1TJcU(bviKXsl~{;hC6`8ub5
z$~eWn$wvA&MAWF-yt>10e5$?+m%SCyYPJ?v^<#mHre3LkiRNjpWL=W!6CRAdReu^V
zQB3zH-lNgBzk`XfY=8GN-}r;UR=qM1@AfpF|FhBEoyL{wD&2o7gOe1RGXkz0Bx&6^
z)x;H^vTIpH3%>nd&~TExKt&VpTbt(06^Xt_I@Mg$5L-rh{=Jh2DOM9>6KS=suoK8`
zOOfQ~a)Wx?I$ooJoR}$Ui@rQzlJ;O0oKKPfVM2mH(GSt$OEaA0$siKir=(OzB_AEf
zk9hnz+RX5zCTUm3XHtn$Yv*X*)Vl!dMU!Ta`=yJ6d6YnJ^+t6SXp@;QEPPGF%#rzD
zaFpZP@t5|D&g1L?5AuQK=j?MiygzoGG(Tl%W8v<0W_Rk|@pC0qBHlE2E;rm$T6}PK
z9{Fr<-!_&?YT|iyO0nb&8h9-j>EX3F5Sdf+Ps6iTr8$rIS~%|StC5bR=Ji6RpH1XR
z9~fr6K&PYfsmFQQzT@^y8rxYOf-5aF!WgX?t|{JoLi81C{-{?Iyva2T4)BO&<<@FS
zo`3F-^5N&0M6`>wn-nHSh=%9=FI3Hzx-actBZ)0o)Ig2Tw#EvB4(Tx+SjAVFu-nA?
z=j@q`qyMB|-OXsK{+FFIG%{k!mo4}U2+-c%9@d$V3j?<uDv_{7k)4>Qr#i^B+qUWa
z*Rr<sJ)>*BRjBb=zDEtDayIj3yXW|`^2y6|TMvk3OVZTR-<*Cmlgr^Macj$Ck<oX_
z=CD*j4;qipgPsY9Fg;3o=o}nsy4`kiR&e5bo|Ix_jnYBQjp7Pk{ejkzTFZ|iAE`zP
zBlJO#A0@&&#KC$;5B)9i@Ab<Nb~3@jMLpw#K7Cng#{KJhA9YUH!v&-9O&c{jRHZMy
zA1L`@UAGjX+?{P9SG;Wr5dAu~ag<j6&GTMwkK$Sl?klH&7G5x+71{Lhz`_@BU{OrD
z0m-YoB<fA`L|h?(^R_!y+O>&=r!fA;KGJFaev<ALU-keG;p%?>!Y*Zc!{t9+4@g%F
zm7uP%$yp~Rv*m{8)84eo(*xALhtoL^=Q$61Ilw_1pWyG`ft>3@%eTOg^WT52bC(g0
zC-{{BM<3|P{)bjS-<<>i*yeiM?T!K&fVYe(;SJDp1$d;0l0`e}H*ULkH#qp>*YU0@
zEN=oIdiwiY5LAHYY<IE%Xl=QT{}R|a=_n387Mo7CZ+<EJ!dXPb^}6By#pvCd+}dqd
zC_e3`>xBQw#k?w|S=-fx&pj|G+6D4g0G>SOcFk2b14wffG_Ls^0Lhq+zp;*1$p2Ko
zI6GV)+OCT=SaEw<RE0ld91rRDKV<_esjKnAi`@sUFQ#HFi`fV5{%~RFmdXX^Pt}7F
z@jh$vJQXc!AT&fhJnGkwJFV1wODsb#M{IsT@&rs~I9MpAJ{>;VI5*<s(7HR!2PWK1
zkX3%JqS57JsLC;_O`(B5YHHP=!WslQ8nrK8Ch&-_RpU^J7Qx|tzqMokaz$5r@gfJO
z@dJGicWtNHkaU;--|r_sCw^(r5)80nC%p?^>Qb3+PHbdas`q4PCoiz}gTqdWmj8<6
z-T&ssI^gHM{MNQnHr6!lUR^iXvtUZ;{t~0CZ~*Jft!0godi%v#kpyA#-x8OB%JY`x
zabd!}?=M-KUqa?Fo|3-kPi4unhUKn0cPz9UbA`DBsim8Dt)bU87wqfz)u;iRArH}W
zslt%GCxVWQBJ>kNm}+13N+h%KKZrLh_#79C<Xto9X^Uwkq?Kj(GhHlaf8u?IU#C@2
z6RQ7@B=QRv3EM>Er*{Q-W<^0@#81tERXaJbfsje#RvPjupggxQNH1pST^^{~Ndzq|
z6hq|KBD?f<seBsMvD`abqyF){*=h)-alQBBZQuq_ieCRW$J?y%=df<w=dk8V?BV+P
z+lRlOPdXnTRQ)!8J#HG^bpk1Jz$TErejPjUa2EJ50Sp(t09nF)R_B?KgPonw&fAMp
z)rU!%`^o=;4FJ{tYW<or@cut?;7P|V@S&l3`){`Z5S9i8{M-B1eg)JJ`=kMW#oLF^
zk9MuDA9r?(HH{LF)|z`eb^bNkEvlME7<m>vA*9>z>^RHnjri<$XhzfOwwI3*7&)xE
z8<y+kzB_&2ad*&pdGJlOGXN++0^8f2|9m%qL3CgpXf}#H-WhrAd@c0c>_Y-SDFZlM
zZQM_V>y+V{G5uB}jdm3D_j7Q4<&_*lxoIMk`IhyzgSfyyI9IPKA)jA`Eex$ZUMNi<
z8>iCx(N*;JtNAY<Z-zWOuac7-wxe`YaPn@p_XHn@=8d{Ig!PR5;DEOz@Xw#q$D`6K
zOz(&}mtV1gH!Bkl=UhgP81<OuMciDt#~5?B6XI?=j^b_u<d_7nT^|CkPp>N7TlJ%U
zSxwPlQn~VCKc3J89wryHT)f(S^vTV68+h^f_xw!Xay0T?o`mUYgoD^!;LZ1|e*vO(
zKRR?uA8%T@9u}1>>5+|wdrrqM6@$Aj4Ms2;VCv~NLCf-OS|9eE+C|cU3_-&JC&i#q
zlE-MlQ5T1T)+SmH``PEV)|)idmnU*-pOCl&u%GykyN7Jw1ZdYhM4}Iu0&7+M?-tOn
zIEqWTq%z2*Q>xA%-ac-hd$ivc@1pHo4{j_4-UvE=h7NCd-#!5;5tmwa_-{>gI_vGd
ztd%e_Cgeul{f^KH*ej5mn!&FFyOhvgp3*%0YEDrt*54{s(X)AQzT*=2JxHKWaMiH;
z?7-LIoOc@$=;n|ymZi0%Q9_(nL$Zw4KbYz><eOVm8h9!l5pa_d=jK}}k5*K@>iqa{
zX1UgO$jafa%AkX-d7_K`>D#2h0IAmbPrKDB7*-bf4#5HkZ6BkaEz=nujRTIDTCP)$
zgWWwxPJrs!q==Bank?JqXx2Y6qXbUJZ-z418d>y)pPuY{-W_wLf7gwAwyCE@RT1zw
zlVNn-jp*Y|fs=Ad<t%KQd1hWy()?+!Sa1>S{FC*FKY<GH!;4weXqE_oepdFqUB4de
zX&><WLh_FXonqFv?xMfbTjz~_QtapK4j394lJDfYDo}l1`maWPEwkGD&WEY3ss}Bn
z<q`cGc7la}cZuB^7O&3`CUUlz7$0{&-!J*5thwq(Rzr!?FKtuCAD2(;=&PaTqzlb%
zk}g*U4%Q~d&yyLE?dPmMT&@N?j@;=#$Dj2i?7ntIl2%nzv;osjP)VYO;wuH0t^HYP
zHa2x)J=<x%5$pYS)#=1Ev_GZa#DQG<!^Gpw<L~yzlZV#FUx4@bKZk;)b^6?aJLvA)
z<9Uup>ni$_WWWQA2aU?#1qzbDz98^Ru{E(wf&IF=h<IkKZm2$^({U}dW@?~(yy5GU
z^{a;GfNuD6E&J8er=~d+z(Vlh{v`0^V!Fzx-RA;8H9YOz1;DdFBERKq9B|eja6(TH
z$;e3G{^`bV19sPQOKmvc<9{V-D6&EMZI22Qr{FBg^jgeXV8uP_M9HAG@8MX)>4Z>e
z3?zz(^D>4W2DOHD+mD53y9&h*w4r7!zF^9J)ll5qdk92h0A8gixT&OrWMd<I>1YJ!
zXa<jx<4y9Gkk?<A7+}d@k@hMipM{t<cp>$<(uF)5^@Uwn+r<YCzQV-07f&tsUd%H2
z@4a&gQF8WLK9yQKFomJ@WxMCShAFayP%v#UV7iE!7F^VP{|CGQ(@?L8T7q<5q`;Rc
zIKsjs=Y$I-j|MYEpu6hVZFpJz*cJyx)>lT*B}^$!OqC%@5_O<SF1CbfPs<mDUBe2K
zbQDdJTJ)r};DlozBJ-WG53NvAiY%GkmB8<5kR13Ds-gWj{0Nh|sZnz-4N?sIH-<GZ
z9~IP$o9GQn>=Bw`d(t~JYC;GJy?btxJWuiTOfNbkiS66Asgu>Kcbc5((k2pm{ZWZi
z6&7j|AeZ|B)OJYHcPYtSd}@ddzrhC%-WgNv=w~cN=ZEhcF*M-HYC)p?{I1t(sSF>m
zjxlx^aNl*j)UQ5R&@eGp<>ZQp(2=rL!ZI<osyiZPL7tN)Z8T3&7X)dP%vAIt1B{?W
zw}=AG5%HucMHb}(QouA2=3IzRgT0&;g7K6&+@vI=i#e$@ZL#<MvRQjkn~tT(+5^AW
z?^{2l^=l1gg`1Ii=`gq)?Vl*ErXbt<rCBW<Nn^`>G_lXaL`dQuH*yXD5&d}t0_DL_
zy4W3rGBp_E{!acfV(yn)`|<F#i?Wak8tgnbHcsb-MKfn|ggurdY*wm{oJ|A!sq??H
zje0X2g5ZTd6F0XZ&*@E#v!q?-QSJM8N#P}l>4hMICnK@DgQi1Nrg;*#3?nIdGo$*+
z!}uf6R%kxh+^wnBnAGgAXc@!vJhhB)`GhH$rWPqFi<-D8f%*{cY{J2f_@u=w7*9o4
zZ0>}bB4o=a2i!}`i}PL5!#otYSdlXVOcgrJB!v>7$yT<`>)-$6-iBFY_u_m*SiStv
z?6dRsCWl$UJi5StZWKJ~%IG;N$SP<w+zmq{3M?(zA)fqd_nae~1jU;o7@}d!&<md<
z;KZkwe1G5hcm)Hn0Q46=W+o<t5*4WbR(pbif@nX($qfHHXi|RK02(jJ0Kne&2*tC0
zSp6vw=fIh%>QI;FIQl{xCDtECe7pk*2}%pxAPd+43N7}H%O>PllJO}xpG;D}eFht+
z7dcZ!BN$}>EuPW81+M$wOmFYUJv+X3iW5^nQBAsauvi~|o;|j!oB4x_?J141)X7ya
z_i2Dhp7=q+FChnkj3BC1iQ+9n77ZYq)vwo+Kq!TH<0?s9JZ_mCjl_wZtYK$o=M&@P
z<ouC%dB6;HCg$K0OzBxr8ls&ElSqVHis7^EwMm%1WSzAWc={^Nwl32&He8lh9~<Wd
z_csZoVWT0Wc|kW44dO@seaym@ZZO)NNlz|OBU&kX7#_<ffD~YK6?gq0iiAw^2)>Bj
zGVlDMo9baMN%%B0SFacZhHrmoHVz*3*5CE&1DBr3&wQ|fd#IC-ZQcXIUps*UC?)~=
z!7sSj*;>-Z3OT4dTz%$)1Lvn;4I5T`D`ZM?GT4%2YCJ)ofZM5I(rVDnm?v@*IIqv)
z9JYLwM5KN<As^Cu^2F3EZ}KB$d|AB~7Zr<G`y*5IP}UX*6a-R$NopYkd`cI!<kco!
zqTBSX*hjD9XKYXwbrfWG;v$6-#`ff&xWf&C5u{|KZ?HpaU&osh$<(-N4hLZ7>NxUc
zG&Si?I7<E6m+2#)wi6%=b#kdgB%%(f$j~Mb5}=gibh>3YQb78(QoA9|FEm)S&i=&@
z-|B{Qd#EV~hU9{s01AsYuhs=pMM2yp^otuZkenV^aHdf;pD|Kh&8=-LDFHTPT-3%u
zfIvv|o!o_|&j>+Q*4B}|+;N*MN|-?5x_!=$bJi^ZoNB&OA~)Ur4I`h~P9Q_E;B`0o
z&Tn<2qM6N2sGOvNIh`!w6O&Xu50y_>m=wh1z<0x9ntjd`mYS~l;?rcR!{U&dJW+%*
zNA?f&X8!0{pY}z&ejt`Z$lX7xrdPK3fkz8z4h35rQu<Sq^G2wJ**XX4Vtjb*Dt^ux
zwHb*z_x-{TROIb6lE6>`Yh<zZ{no%7U@<QgW|*_p$n^Gj)rg>tx{Ah${`tBy^PN~j
zzEubqVcKrZ*M$S@aIM2Jc`Ot4Yy^0JbK@3=D_{~(#)iLg?A;8YbNRi=e3@o;FtCCG
z>qeUyI?UOq<IQmkmkYEs&rqdU!0;--=W`@1wBVp@jFe>3)Eb@gG4M=`Eoxh%&TC{}
z)7T_W70oC++0Qt{!j<I}1na(JpeV@7#N_qs7UpVUOdHe^J2jABY)O+bk=KmlAWq=M
z{RUyr*R4|X)`wPb2f1Ja5_g3Ny>`Q#{`b;J+BZM3Bt8Zj*bcJ8nb1SIpJ-`ir;w&F
zj|P?Gw+D>|n3?^O4RO#CfViGbELAM;0Y76ryo8bR1Q<9tu?!0LxkwKO>}`B{XjmZ%
z$nIFDV@du2{75J`hb=F3EAzmk6;25g^8e?SZqc~zJkX8)1c<+k1LmeNlrWYTuWOC;
zYCZi{!^zk#8^6HH#@S|U1sz6^Vbv8dHlX|OG4s7`7DMEfVOXSAda+_D3WXAiixpUP
zAWO*fgtD_ki3a|r>O%<IJr54rXD?7=-_0|F2uAelP=d=y9X1XKD;?uFfA<(`&!I;v
za*j2(Q18v2wKT>=fIV^+r9(2qN!P%;d_WDAIxX_@U!(Q%_ivwtJ4RJoO0cJZAka&n
zb|66#V=G-j1~W#J{+&q=g}rr2K`=ut?aNV$%&Waw6r6U8D+_igxcbJ&F_vn*c}NK4
z`x`eRx*o&EWw?R6NxX;y<Alq}Dv;$686j3@!Joe28)J3^X|xzY!FG0b|4Fswq{}-J
zkvU}KRh5+*k>FiXGmejhP#C9xB#~78I0{~#Y{0cQwz&>y$aHM^=U!3o!sqo$w^n1K
zLSc~7`J;NB_pjnIuQa{8ghhS^V<Ue*t+73_Aox6+gv&JUO<V5OssTGt;8GyUtO!Cg
zO^A(+1ztvr#NoX+?%SDuk|l4FM+c-m3Z7oAVcVE_C7{JEU1aiYTF)Lir>r*1a1762
z82Whq5-k;&m$uIua%luXzRq~Ign2n(KjccZwl}x5kk(zS_4WnOnI@Y9Arh+Z0h=qR
zN`+qWZ<ut(6G)WKX6^XthTccV#$_N&qmwJ)K)}go17d^e9?mg?VTlY1w(i=Lql{WQ
z)DIRDz%JePC|07B2$N`CsVBHAZhO?=_tB+=t-HM*Kw^{b;v4Btexvch55X+KuA@v(
z=X0WOi=1_+T0T(W<bP~mb!gNXQOw|0z8?<8OpxZ*bBO(M@T$C=!=84e_O-_tFQom-
z7D!wvR29}jd?QtT&?bY4YD0fhq*m9|Ou~<LE5rxOX?))SRnPr>8|0>p8X@vk`*F>9
z7<GJ`@35?I-G050yvaC^h=I9Y<B|=gqP9D#aP4J$TS)r{E{+iSES1Jt_=V)}a5m*-
z*M|86mDk6?u#c{01+#EvH-2nx`3iK)RV@$q@kTiEbtnO0yL+@iFI8IUXcefbqobjr
zWzA6Z$AEJv4<^KSNC@+kZ-)Ck0>+oDZ%jvEVo|44o<#S}I!d!1KWealTh`Vc<>f@5
zccM2d?1zYFikBzIo!$dJ6Vny_qtk8z3!@ElIyE1ZV!}EykY4Mbok&%5CC(4$=jQa0
zsPS%T(DVcn$Tip?i)E5z21}!%!kG~jHGCXUMujOGl*Si61*UPb;Jm402OABuMdXZu
zFvc_jtG1?jQqNw-dAB_$la%l)Us@tN>^#l(O*CwaQ8OfLycsnI7g1Om3+4T-!kBa!
zr>FC-*1N>@rKY}ygrZ4pb3@0cc4FeOU?_(mDWk#3p|g@rBBEvWIE~kG{r)%tAYSe7
zmqBRW25bUImI=`_B!j|fsvTe*Fnl4S-l1)s%&1T`YvT`)xTIlb?+7q%^hQPz%su@W
zwzjrpoSA_q^q&bzzgA^^Fj}|b+keh@8sG+5$!pg3tJA6w&TM^9^SF2O<vtym{;DeO
zJt21G2grLr=;~I_{bwF|98wMN0c5v8e0HZN{0yiHJUm<lI$i(CV*;82fCK?}u4$df
z2@KT(?zp_byG!`&*EDS%_;|aHAMyoVH`RND2c7VEIWhF=&(9(XKFOhOCTEMqAo;bl
z*tF7X1&g&ZA)E7d%{skP!Sfu;YZ-ru*THFQCTL5w<kA3!E8a3$Q=-9eUqCC|Z))@J
z;M98TVjVWGBU<JwutqWHHz!)QfjeVY&uA?sI0{#u8_sIiKJ#EWNJ`22V@I?SgwYRX
zU-oxQGw|d)y40W@_2#O@9(X!pCnPecZ}pd!%w~sp;nV5L`X3wO!6L^`#JNF#Ffdci
z**b>xs#Jp)Pd5GzBuL)OlWsPJj=k6kwqIZj?Bd`!>+oS&5x?EHif$jwi8EKK{Y>Wb
zEFH^UX8z@FPVLm%Hhros8HLvJyXd&{r)nB{ZK%6pmBL(raydR7oWH*LO#0=Ayf=a=
zRcQmHLEMh3ekNsI*!YDKSZg6Yf_QEM?=|(%@0%lhB>t6eiTXOteHvyk`y+tazFcRU
z1_swYll<uQazU!GIuYMtqx&U#<J6fxjl!tZ)^Phn{WNy<S(6YxwPVH!2kE^_WkLf%
z=0nZ1X_xpYM;4ESv6L2mlUuS+dp7x1`u!Llx>(V?H>_j}dY?nT5-+ff_&CPb5a#tu
zMTG?E%p5^@A-!XGmH5@Xp-$L;o<jW(^w(Q%k3H|lPwvKz?!M!|&Ijo~x80qN0FfUQ
zEu_k@9bPpLxGwO4Jfrw|-azbY#Zo?HfTy+d@XzScw)0G+)Aivl{Pv{t1UMbv&oySN
z0}@rfia3%4p#8n|K45EFVe0m7=dGhl^}x}9xVhtT+o&Te)owOrWz)f%euE!U0GJXO
zak;(8!uQ{m9z6vTdad>K^=)l;V?Zzoz-G+=thk~7UJPhY+S(%N<>LIdc{^Jg8ZLp4
zb1DR2*LiIXC;f*w%8Q_m`n3R$-ZCXy!9#oY4Q<Z;DH*?;)rQVVTF_zd5ggkwI57Fv
z=$0;Aij8i_s0VrJF7jua>TNz`7A5xMS6s+<-A|P(4yDx`isX1}^jq$Be^~(I(69~z
zbMhp*gQiQC<Eu?Ph?ZpV&kp059u*P2_h_*1S)yc{c)Xk*Dj^#IIy$mV+BqBmz3OPo
zVtG52-kh#T`_LoeTlMW_7QSbX@N?n?YB^8+U3g{>ag)LH>`@8d(5qI*+lWxvT}<Vs
zX$8xUZ|er_HgXF`)_ggP3)`W(0e4wA>|i1&oth*Y0Qk=536ObfRe$j`I_YbblZY61
zis-RKi&HJTW5kz^i$vWw4Ngv3i?wyfc)GS4qt2wh_~BG0iMTw)m)};IoR+Dp5hD9L
zZzfZH^@~vVguHYZ%OyT5q=S?@hi$AdIq&uwkMufI#yC)dl26JXj_C`-iL*b@{@wET
zRd=0_^N$xP0e{J8{MQSDUq?qP#mfGg4>+3dc(|zgFKlmgGyEPHfA+?Xq~v&Sr#+!=
zdh5t^4a_{=Dt|S)4#%f@8*m3;1+qmvb!>q<xoWm(lDS^Ck4?;fUH`zFlt5vHFM?}A
zjxh-@x41`#@m7b}s>v>YFMvJ7H$LL{rm|`2%J7cg$3uZ;^rK4QDWcN#SoPtz>gjyv
zc@Y<8@KBv>`<2n-zxiJ7(G5%aQh+2-4y~=J2{>L6POC`G2`*z43Ea&v8Kica8fW`Z
zgl*nXQrk`;ALGjVCtKeBBJ$ru_S25lx~)SFO@~M7%#-p6;x2!`FeHt_Wjul45IG2M
z0s}YWE7;{13;pexHqRQ--436H>|ZCE;?;{Y9{GL0{I*}}$WqH=z4cDRbw1*SgE|^d
znAD>0O==A8;Q026StaK?IfM<kDXM{+F%Zx6mFqnc`!#mc{(VsM=m-k3`J2GaK{)lM
zk3>^eq1<7vx#w^V8mo5UNAsKzc>yoKxS0r~2G!4vjEww;vzs&<sGozbe#;5?S8jBV
z4W*p|X2wUf0EYl{8VaCIfVuTZQo<Z#RL?wMX}bzI3B+^#`2@`t5CM%G8a@0s;R@5V
z(Pn!(iO03z>#3%lZSVMb)L)L`V(nHkWeVy>0M)fU3z?vL!hWKhQx|P1+ec-vjfK8<
zToCuQJ;!hARb)`DZHW51plG`M2DQvA6A~@WGOl}i8}CqI7iEA~aej&yF>FAOS%#gP
zpCcG}lFlmf*p!~!(m;m6+${3Zu@dc<5$)TEgYh^~A9gD--M5M0kA&bqJR$3u-@^Rk
z&4SceF_ylr_W0)|9wIFbu#OPJPrm}fsc^-*`*@|ygCW8$A20va*;o!zY@dWr>g>VU
z&q!P9Fn<waAF|jERTi^wdT>1-jzSgCdyo(kFW@vU@NT@|qh1`HsvLn}$soYs+{llD
z?dIQLYfeTnv@7B{cFTDLXNn^M(NJQk3iwZM#=qdf>_swyK?#t$?r#oPx>Rcd2QF@C
zeqz)wDhp*ea_+xM3N0k_491Fk!JVCfPWd|rySJKrXN;+I*3D3MH#6|=FO&E~<Y%K!
zk0X)whlbZaBGfBq=<P12Gt~a2qqhl^tL0A7x6*qSAMnsgl?RXtpUqxiUUkh!A!Mu|
zFKm(w4vN(GV-FeTUE~fpP{GOS_@y@%n(~oF(e@ca`XD8Y0)~sF-$iTkXAD=dyYO=y
zEv7?S+K`~}k)c_XVZaBHoDk-zZq7Z{=W$ETI1R4y=VR=9diwQ&<Xtt5U&jz-RymQV
z69t^>0M+rlV2%O@H6bQUn9sPP@Z3sOX?kEc7=nG9EPz*17U{IcZ6R)dOpxXj{gYaT
z2V0<DN36l))V^oR$z@RCO(K}kIrpVzKyzvY9wd7)`bty^VL~{O9qxJd2O$xT`vCnh
z=b*wEUgCsdnNwc7st5lvA*{nKf=E7GeGNDMw91{7Pt*zp(QR-#F_Jq?4`f3pIu@Sl
zFe@(p%(R;wU`~*<Fg2RpbTC-<f0Wr!dr1y%CDmgmD?gDDdas^lKu7|}{94&uCuzSo
zy15V46cpPY*>_+QcHv~LI@v1ZD;jt(sKNUP#xq!XZZ4Rc$ht*YJlkGgmSy?MVpv&P
zZ~L!D2m1%Vl2ERv#3f_5th#!6<M`5+z=ASNWdDK*%w3Ym*AD{uj*CPlwWuX40q@Ar
zE;<I%p9-)iS5E@2THAqoLA(3T`l{Hi*0LkMCb7r!g%uCh#RJSo(TMZE!`G<Uu~<HJ
zUAwEGFlGtYwGaY~J|9c}(wCypQTJ!V8|yL&Eh`E<oyXWOiQAlb>yKu}YUZeJIh<WQ
zkn^rvU?qa^dh$6KYoox}a=^Kecw=O#9ILRi-pAK!!4i~e+EyRA$&(GXlejEt%-3$(
zwk}08Ug>OBI$o{__2&|SA=}kIb-lX7C|NqaQ06%Ev}jKg9bSzy&$?4+nQ)`gVoY4u
z*{;qs=dVkLNf*s)R#}O^4G3tbF850`5P6{ni~hZL#W(0_PKchn^H&mwR%-vc$TnPO
z0NvBI1h+1mO9c@$>e4*Dw-AHPm<-()P6=fj|MgaSMZRt%OGPILX||CK%;}vCWuib9
z`5C12FEq}SQ!~UesIm{#C*qD%a7`ia?d6F_clv*nR9+PBq=rXhnJC|S2yl7k1*Oh>
zj~pqU^<vA6{vQCFL1exHniK<E>TGrk-WCxFwC-A~a*uL#B}+)HB*~b^Oybo0#Lbn`
z)sMK)+4atP+AAMhKuCtne35NJ^ukv<ow65CB5Tu}fvfUBziWr_i+A~;=GhPR3p4w$
zp6VAwcpm>U0*lFfoOwHpFo^&QWgej-T2+yMSi}o^9-;BFfM<qz(K!&ndU?IohO)}@
zA`3z0n2e&TQwxA11i*{!b|=eKR&HSkAtlZRO6MNls%c|dsnpwo>C)E&B4P`#R2(c2
zI5^-T7;a5&%quVq(HvS!L<kWfJinfmt}Y^q{Ca|fRJE8U_qS?N=Qnx)8<}@Q_2NYq
z!|Zx5o6mMd02Xz2-EE|aqLE?EA~h4lrY^v9<WBunxP|A(M3qOzEzBnwIfmy4M<Jqb
zed`%!HpXmc4eoT#U2h`JK#tk^ow9c`-_*=D^y7~q!RE=LLu-HR*Qt-`MXjav&5Xuc
z$rF+nJ!hT_g7fO7Ya2b6m7UGl&S22Z2`kJ9C?E<=+t!>IFH%rd>?BHjfH==J00AuP
z)imlk!g74fkWv`QyjRRN)Y{a{q;$JNq|BvGU_R$Kq3&d%NZ<<z5nh-uOuep*&M;b5
z9EHb3r6Y4fAnzRQK+W^`B8p7n>#IrRrDPBq(uuE8ZVY4fiNP?gFqN*tg21E&;<*hB
z&)9X4I4NuvXp+>!oKQ8u3Mu7AE3NmO844E*JBc!1n<w&yd0V_-p>`LS?~wu$s(|rF
zQr+Rwx3ncZx54eq4HM1<K*ZHd6zhoRF^5EvPW{4K+HmZP7eSVYWns`hrrPm=fEn|p
zb|=S=D_&U|CR0c>@2zd!G~W!5q?8PkqXa~e+T_U3X=)0hA$1g0gfjABp$Mvw=*rw(
zlsv{)(t0NwPn0GkfM^b%0E<Lg12kS+wT?@D&osGKq7~`+G@&AOX5B`55X2S$00yaP
zSW9Hy`=tm(9k;M)sbCO-00g8FgZXaQM(NB)XV+b^WvhsUn%dc%t`-m>6*dk((1;d_
z5kk*?vDRespP1cTS1551ue;@>;KdUF#h7r7D4b6Z1WI4-BtN}+-IaUa8KtgtvN@ei
z2wv2NjmK07i+Bhfhx1G;ppY19XVxKg!%*HZj;R9`RSgp6L106=n?)OGSTqO)#Q7j`
z!E~4F_TVmJDPE6`ZNg@$0hmCdbeF=pqr`%Xt63xUS<xw=kUFdY)m%~lgw%F%D~+um
z`D<9jNz`+5-m(CMF$8@?aj(DKlJ_AIP@$7>*3|`R7Wg@ouKlIE#J(h?@9U^kL%2h`
zsM1v9d=&)2Q2lMeep~)&Z?h=3z>KKWRie_&b4uk6<{m_})~0Eyh@v<y2#It$oxD}O
zF-Amsy<QG1G}dsUD5pw=OAEJA+8Hwl5fL$*w}?m>nkg@*T(U6`(Lt8$fvVSR1n@u|
zYO)GhM*bu(Z1jSq8s?=0)pekwxECBvD5X;JEjXgCP<6L35MsvOE#A6#`;)2d;efCr
z9O&@e)srbZs`mVY@RAs1j%$<OFNbXvy)g|^ul75`SLR^ppn2VL;yey2(Q<{Wh(N_C
z^H?rcq)m%K&~)Vpp(ouV;Q0hc#F6gSZ%tiVxCDrZI2~qs0fgt`R}pBWekJh<jW$b^
zP{t90#yR}=EJg(zK03AOEDNH~pPxZ$np;-Q9eeZw*Da4h<O@j1;!)47kF3NQEM*W-
zE}r?nD2W7K=FSw*n?BZ=@jQB77D*x4aAvNhBBErT&Thz{B5QPIiM3Z0&tYRAfM>7c
z1BZ@2+{=cV5Lr0TA-B#IdAO3)3YiNMM;sPQT396F@S2!8H%kO4jN)Ug6Dr5Y5Q)jm
zl`kg(lu9F!1y}Uoh-gu%pvZhdClMgQWkJJvPJUm#2vaCHw+Ba32sfeG0W~rR1q2{P
zor%UdE+m*|2rrU8jNX;{+^Rrm{xoj^5ca|>>}5n)FYHC;54#CPRxMdhM&}EFNA$`P
znK`ax0)nW#EM>kqme#?b+*}MGfFR;A=+JT>Ph?0F5uiB1Xzmh%OyVxb=^!nlIE$~Y
zw56{H1odI1mle8VQUjR~={n4HaY13P!-Zpygl@dkDG~XX{+!w8(YZ=`kcBNq#}D4$
zwY`!bQz_ZJ%GK+DrQePcQ*$s04rM+Y`7xPwShK1D)o)n>fFK!#>*3KJb#r*#;R%x{
z)0weZ!r~J<RjHs>D$p>1#x2!14$B?iIyT{apfX!vM@(X7?gZp>^!kh=1h@NM*g<q|
zYD8`~MT1pSJ$FuxJzvb;4@7j%-G1Bc_doE!+FI*}Km3vRj)<5!2!aoO@Pmy;<1hd6
zXK%iFK`Hg<qmSNl%Pl8Qo;-Q-WDYztHV7dRc-=wA0hL`WM3j-nNpkG~4jKX0A>2?)
ziKI9>u!V>^++`U0@~UV+fJ^`nJy2^Lc7Bv2!R({j5}bb-q?~}Xqv;WZF+Q+x`x66Y
zJ*rI<k&W;EJDR}a+=)X|gq4n>xCuHOB(wkvhbBfHu`rY&u(t*2&)fPs(l2&>pfZNy
z{gNBbzL~L}(pMa}m@&^T5MhXykKOgrB<o_)DS&_i8{hlfl)J@t6d<IY%Y5_B#*zES
zOybZ){^DQSJms}23kZt}nzuY!m{a;Gqb4#Zzb(R5PgdyPFQYe8)5#naz`7AJaS@Q2
zLrw|N39rY;77yH+xpa7C5fLzPXYKl6OQCW;vI?^1U1J(sM9_qpig8Zg9JkF<Z}G0o
zc87TQB7lfJpY;T&58+*GIk5f61d_$urFnvVhJ_fZ59+;*4V?Ej%n*2LI`+k-u!yJ7
zN-+DR+eWX7IOkI5(xOwqfv~qQLQa>R>p?_FyjLp^1koZF(gj602x_=`3B=FAt_0jw
z@kMhWfgYBdmk?rthRQs!lg%PT>)onp9yoZvA9-6qL`a$5#-+*R&Yh@11aN@s@zF#_
zT!@h}aBAX2FW{U$0Zw$?9ex<oHWbVu1hni@(sLTG0N1EqQ%e?XIm<n`N*&zsp)yGX
zrL<BS3dQ-JQ7JQO7F5}-EnQVxtKX8kq}Vt}5%scOPk<_$19_<%bg<D;%MRUGT1QXK
zLDXDkm`#n2yeDV%LKUUg(SkkqBC|sXWC{Y!Rui-Mb-e^D?~$y>CENtcT-xDDl?6M1
z4H8u5)eNpEcFe_s&(QH%J2(0Ziikqeq@jHGB~p|2@b=&>dHObDTQ^>^QtHYMLS8l{
z5YjNIv9_xPMFhvbcJz_um3O5!8Funw;e~i9yn22z!+8e{dk{q&1@Ykr1M!nxr@Atc
z;*20(%wpWQ_vn=Q6s4CpI<H?rL;+^!*f}V9##n$09%H!4hn~TX+x9}3dLYeey|As(
zwWCt|iEqbgZW5WcwqhT7m>rtiVx2f`^2x=(4ARZ|bqipaNo=iIUxd|(x!aLjgDWd5
zpZwIPUVQPzd+xa>j%)w<KYv3h^4>rB<dX*u9JqAp(y#s6ul?J9`@h|O`|a<2?|WZ*
z>E)-M`eo<*>C>mi<AjL9tb@jZ6Ymd`JedIp@plvvOaBq4k_gcQGC;9vjS(0JPGIqA
z?eNl_9|^PWDE~@0(Ba0F*PO^ydvFQ@iNLT#I`1neWIzXiFuVr<dr<)oocfc(A~Gzv
zFMLtyTR3%TX46Ti3nVp_y97|6fEH3%fBrk6vOeAHuI5^GNP$#$yw8aA*fAi5g%y|A
zU;N+@$bh0F55_@*3yPJ+*P<nT@l|0zz35%05q8MOh>rbwua#sy>f_wxF%}^tB8@Y9
z){jF*m*(_N>A2B2q|!Da4Nc-Wh_#Nn5aHbU7~Falp&COOB~<fe;R*l&Z<vLv3%B*M
z?uY^+MAS<=8O{@MK)}pfsx2Qpd|xl?6iwndsGBRViU?74=eP*zV0q<T;|3u}s3VW_
z6#F5dFmt$Y@Rs)`S#O9Z!NNubSJp42emtNp{j48kKrXKX`&bwG{nG2k;l-7Ar8X_p
z5_2tF&=+5l+$|#0Rx~DAg-aa@`(VKzd?2qz#!**s=AhQ0@4)z#W#o^RG4QBS)^3hM
zfl6s2JxuG$%^^UN$;Q)#yay@67?j(hh*8GqfJ=ZP9OzJy+TvW!w{h&ql)+Jyp-yYd
znT>~=H2@buJ29<bam5HS2v*8yS_E|LT(G!!`2JpBVEYs>I=s%{rXr0E=9vaJ(SNfO
zIdJSfwXos2R7YA1>hakh&R0Q)AdIxQcr>(y_?U<y)yvv`E=L0bdiJ<*^w{lBCbnDl
zVZ~SB2P~rILILx_8{IYUoo7EnfnxUJMVJ6_8X)4fZts-zHGot~H(_M)q{+ks!d9bz
zW%kQ=21o7(pAIpn1=y%CyLNg?=c=Jl=2B2hGZpNgh9X3IY4MoqL#YiZ;1_Gls7$}K
zatF0LBXI>}c0OD<aO^#uWP=7gFCt3mc5ls!Y}u!A>a|)BDRF6h=z*o?aa$<RW#K5O
zg}u&z0uy&#=_AS(<0IvR5g3Gpv7Em!wU|e+Ec7zvqJRj(zC$Klc^4Pby97ilv)($-
zo{1Tei;Y8tx$lOPiSI0!cs-YOY?8X6a0#<V9c1jrNLK2cRHi_`qh;y7Ni<MX(2q!?
zOkN}MPkV2c;@ket<Ej=wA>1h}Dl+H4@Po})-c)f|cYbNJ>r!7Vb|FQ&o4$o$WyTFc
z77=C~2S+NJLz6#9;gzEBb9uvH!X(3KFT%86rDz2Wie6+3gR}6SK4WjE*NXnp$!Vw7
zabtP$f+Ix8B0(nKJgI56FbJXSTbgWl$HP{x(-r0Z4CmZ!x82rit$yumUp;^RfscLc
zsUQfv_hA?wJ$mfRU;f`OT)1$@9e18MaqF$O-umjRuYUEbUpapK*uxJ$bn@hD<Im6R
z*&{%MLZFmJHwi&N7D4vjStc_=f<a{Oz}vdGSo%0IFfcG80p-1CMqmX>i6&7rs-h+m
zr9q4L>>U<$At8GQ>=lYC-@OPx2{5x~78VPb3c3Q`2MZb?FCgBrcPxI0!p9;kM8FzE
zVKL<;{}y3p2KGRX0!LilM9dLD*gHli1q=`NUf3%TRo0^dpio%YGcz-Tb`(0|!tIKY
zLXSqg?`Me&YJdrVy$5CmqCluLClH7Td-fnwGxd5<zFo0j2p0k}-dSeHqxK}gp2ceg
zqEJ*Jivm$Jh!SCD_MQbTYKMA^jS)$N*;^(pWgZars&5yU1V)1hi}y~EvNqk^TutoI
z&IA^*S>kMpBHmjNEk$@t*(&bPM<ikan}AKAkSdlRF5;Z9V?U1Hn7a~YN)(~@UaRQH
z@}1qZOQZTR)}&jVYu<bIj!{V&$7Ks|D<XRK5h}E{y?!+tovgsZ5Tuf2!pz{Hc<aY)
zDS#|2p26A?-DG&NP$bNKDVVqu<4gy?AczPvuWerM6{Ex=L@Lb^h2*_eLkb{}05cQY
z2s19<i~9PIoo5C?&eF8kw*8<J0tgEmLG+Gu!VasTN6OVBG9uGpTJB#pnOQu0q+nt3
z4k?|0xt-bYK;BtV0Sk}xfM;fpAc%~GZZeFJ0}^`g1Eaz7^|edofVL>oY1$1?dz&es
zkrXh9XW_w8v7kB;5Ji~TdqlO-+pxJl7~PgRv1u>s343P8T;i+zNeLN|i|$E8K*;x>
zi6zP%a>FZ`^!ZV-urDcX66~v7<a}*dxOe6Nn)w15h*5hqGP++fk@2W<?TP|L#$)eA
z7)cPAhE+`c94^jhMM2Nt7(B!9GR!QN!85RTOiqfo-fg7-(0fLpEb~b=h&<=zwWu=Z
zA)i+HArEXTup{~MyxwW0B|DQtlV&y*?|G~-%MSE_2s4WX%209PU5vTPMF(O<CTetr
zw(6fw%#1>WAt4W!iXez2Lcq-4vbW=UV0PyK1Y}`mHYyH-MRaMg^xfz%G<9Z&dFXLK
zRYYL#5u73q<gwVchy=(Bdlqrdw$?A__uJyJl_p(w4ng`VOZtk6y=V4<k~3DRTAXsp
zV?a>Ow>Pfz(oVsH14NW%T?II%vQRMBHcY@Mg@mZw9|A1my+<GtKrc`zK0py<A%VVI
zr<mH4t6Y@vX$1g<QMfM!pn&?=0fieSBA^JfV;-?93Ua@f0x*G$D9}$^=KShH905fh
zgiDsV0nmVH93?(hG{OWyLXXB8BPiokMPwSN0TGKTLv0K90Y=KucmeUgB(QxRa10ZK
zWkCYL98%e%fD)8qFgMo|l4}yj?1yIo5-@vjo%ar5qA5DF&m6NL@O>BWx&MdvW!4tk
zP7qQz?R?9B+lyD8WJ)k;n?W=uEYo~r+#rmi2qaG_k%9#?7LglSLDFw!0%bc53VKw^
zkOPBz(RiGz*cftF-f7VRIZjsDa?T;ojJ<PA6AjltOxGKFNygIDMm;qOag5=E%P7J%
zK9x*aybQp)#~|EGLBg`RJhVI!i>0h0NOWUtLJ^6gXmzz^jP7=O2%xog&P7o~`PEkI
zwe_`Tb190Vt5>f^QPgg?S5{VvT?)MSwOZ}L2Omz-%|i$8{(-+_p@-v@LU`igN6hg+
zt5IAL0US%S7W_C|F=IVNMKn?Tt_PkBR}?yXbonprCC_CXJSMlG9(&@Wne7fxumAuE
zpy&C-vHCiz6ls*WiGTo^p-0~P-ebMqV(rkzQq9Gh848dnYQx~-op*egKOO{)q3*yO
zHy=SSEw`8w2xznlVNdaal_#EfTtjyF*d1>Kp4C{=y#T<S?|#qn?TbV~(K}#S?p+MJ
zDojgY?;r>%<Gb#9*Awwdq>Veg{AL6`P=(wZR0M0y+9Mx)!nt0N0y$w<Zdq7kmBKg$
zoKg?J=RHezzUxr)j@NXeQHu8kAr3tAv6YYh;wQqO!37F<k%lH0FRZh6<*Tq|GE2*k
zf9Qk4Y5mUIE;S<W5XbAU@YZ*~cj49rQf6ql5JKYR-UH!=Xb)rO8zh2vyz5<0)K}_Z
zef{9VsaSkKql<`$B3N5ldh|mdb}lJWp#ObrLHrDrjm%kn@z!tHv+PS*G9aK>U4PGg
z2jBJI7#yKr<fb4o-*)kAWHT;wlf%O8DzjaE>(Lj|H=IvO2`z|D*$3YDfn)7kh{lyR
ziU)Qup<4zmOPF;0#-Vt<!QK}fsRBy7)#C?0@Z>MzG$XA@fl009*)BAWy#Uuok-5Pw
zT(LRy;Db*d%#@le7#46TmTC@5`q}#|IC1=3P5U4yo*_tN!{~v>K5$$2PE`PJL<H~T
z;2q|q(_`C(0E~3|L(9#B-CDhQtr;bOWz7YFWuw#Hkpmz8=r0=+PrAq#mt2~OXYhsP
zW*G!w^uZ5(fPH%K(CyFj<%#+$QCaKAgAYD=FjW*3dBA%(xXggwx{`lU1d<d_oVe|Y
zCvH_*wQf1^<GS-+a6nrDP~g@ZhCcJ_M|&-#5iD?C%2+$zvPsMNQr#jVFv9~6KD2be
zEiN89*HBuE6q_OlD&^hr!%uwpDW%5iv=JZ(ZDzrjpHD2rarFLQIGAO<`mMKo&tLMK
z08(*R3DmKNAAaHpj%}86c=V8Cabpz7pYgWa?tJ|5+m*uXaPyQ(Y-q6%b|OmFm%{ga
z;7MoOSX5aE&ccaXU6P3Bpjf<{_kVf!yWe~3Z7z<MPDfU&t`zRABCH9*JB~dePm!9E
z<%>QO;OTZDlFvG|+i&}Rv?)4)VRoblA~|-qzW2S$w=XFbj1yK^*g{!l6@fz#Fg?6{
zwx-yd;uTvdY9Ctu(1(9%QeOc8u){*NLRn^!+12WYE-rx9uE?<rQm4-KCq9Ue9RoCF
z*+lK#17}`Y=(d??S~LK?&w{&dIlV~Y%_u2YfRIwp$KLbq=Iu>VW<0<k4t)mGVhg#-
z(mHM}$FJ&y$rUL;BpZvt2cP(*DI4Osw{-hPyN=FFp;w0>pyT&G_I}>nTt583>x)4j
zrnSfenxeb!dcr)Vi&B69PGBie7-NFK3X10z%JG9ojy?WC25#SR_%9mHN2M?o0y|c>
zzVER^>xZy#aOWpC-o2!{B6hs-jQ~7w&wZ>9nYeMWp;{(m<;pyeb`Lc__{1-cQvd-n
zrrI)%O)CH%!(gHLzQ<g9<M7dYUZk$*biCa$(#pN}J+bi1y2!2w;24%eg&`&=tO|MI
z0*tpEzxB2c86in-Kl)97p23dT4?%mpy5xGl{of+naf5&{sISMJH9wqlNCC!oKlpAr
ze3vp|vRuDfBky%lX}66uZol>M4}WY@vcR)iJcMNmh#(5A)SCxC_zOPmtsJ@c$GQt_
zC(blH_VB|`9)WR9=midj3PMa!M3wf6;m+IdxbulvLbY(>{e18N<P1h#UICGm?L78@
zA3K*IDj2)riwq-1<7c-B5hY3T^2;x$X?nxLJi2UoV6)jI+>bW1?~EHXM7Z5<%Wm4K
z>}((+vuLe{*;&k-rfD44`e>p8S}E(C_dd`3BqCn`Bh9^ZS(cr9<6O4cy1<J+tXW73
zA(w%tj#`)H^l31ovTs2oo1I!Y{vST^57`7*zFx5jZaMV_hfaUTBfR-ws*W!~)+-)Y
zptQ8Q*|{^2bf5^_Cm@KQKWG2=yKZXGHbv!KcIkjS9rd6VfG-r}u*aJ6Nz0u)g|#IR
zU($dA|K!vwBwoh*&VvWcP(jwa(75}BMhdn!5k*0_w(4I$jV3HF6)p=u_v37Oe3_{0
zg>-QK-5qRn!KQ^+mVnY=v+Tlo=&Xa%#c2WIU!Af4UvZPw-~^DM@;1A2OY}-T14A$j
zI3NHs#38@FZl_TI1^$QEUYcyolpD+$YRP(U9KHHYcoQT=7>jr+T5rke(_q5lMN$C1
za?U;dd^(i^9#zU-MGMy-^=5&@VadkOXnSt$+&M`LJTO$)>|j>L7b4h{jt6gia6w#J
zHV6fEuyO8^fAKjsQF#Ugkqf;|#eTYQl9JxW+Fj|74=zfoN<4rhS$F-)MSJNq>R@cM
zKo~|TG!s(lov$sv_{f@22vR(lSyZI6%kh~rP|Q9WQNWLOaFPNpgCqFjk+^R(7M+A9
zz@M(-snZZl;xq`jbY{8+64>P89h+)7uhT95Ng(0u%?q-69tso?B$f7lwEVI23x6NI
zA01|WCndh?>OWgL^$H)l?accvEIRORlock7q3~)iJ9P@9MrpGI0O5@@3CiF$R>~Sd
z4*_J!8GZN%3vRpwQA7ewo7d^oX($RT00^Fc!~OIp$qb^Ba|)2YcYmvUAjK>#X+lzv
zbe3Lu(OkbICKzL_@BFC!Le`Oq+9Cw-qQ&x?2eQ|m00^n%P!)zi$<;2OJ`F)UP62@b
z?M!bv%D<q80K1#7AAZj_j@2<k8B<wE!Hd__6oJJz&)XmUMRx`VDDM$SpMOt+^&Z%?
z6mif-(w@8U26S3LV=4<To=>0t^K9B?0gDmusd4byM;HSTE;f1<3Zc_o>%M*(bxFGp
z$meGEIUt3-&6CZ$|1(`8?f}scati>3Fury%ID1-xf*u(5m1Vp2;kx!78!RcYRHOhJ
zo%MX{_0u@^_&X6;Z`A>N>4QX}lA?txtitg6E9aU&`6`)lNK6E|)N5b&PG+eWXaDl}
z<uA}FbV(`SQUpzKaAPezc~YVp@R*D+_;lt{*<-YD?tK|H8JsUsKoPUIXU+gjSTrts
z{XM_DN>30ZWvE9|oILQxpGVg({meA~-3bf*6#2o$o!Qm+mXlYGo;>BF8kVI%NZij}
zoO+=mK<xooet6Gn&s;#ric8JY5Ld2WiY9pg(7);Y*QYCOEkw>^ym;;j3kwY1mz=$Z
z{c6`up#XrO`!^?f8oMHZ5e?mqH{;u0Toy?(Kq`4qmG+%gpWm{eOo8*_UYt$=1*klt
zv){k}a_9K%l=)H0ln9WbPN(_BFGlMvP^B70K}<OPS++S9amFyAXAEm^e6Wr6($z)8
zV~9Sz?q7escn}PQ%l*N03J{=Xg0%ZaaO}qi5Udm;>it4}zkUr)or177rU~V|*q{7l
z>ZzpwwL@mVd5^81SYex#HcJ_|<}RN*D_L(^YK*|_tn$1uyDRmz+V?T;Y!-oe;T+!?
zH^q<}wR?!Tx_bS=haL*T@UFY=O4AeoAA0DaGiT0N>u$N_M5og^cKrBvzx&;VM&t0I
zLqzKM@#CjYpDt>a9H(?`<5Ktf<@&*Uj~=~`yX#O$8O^WJSFT>}z5Xf|&lMs}lPq&<
zrVe2Yqe2A%5eTBo8*O{xyhB(??84$PPTH8azQ`MBnkZYle))~pWy~N1fPMnhbSWf6
zaH&f1NU&g*Z<9jCps-hs<&AFAI`f)ZT#<=8x&Tg9fBgiTw9~k=yRvjl2G^ir*hGXc
zpFf?waT+IX*a9H4dp!{d5UqHuH*b}!TQCS2gE(DpT{(M-lg-lYYRjeO6p*YJnB^n&
zLliGS0iy!gQ)9Vp<=UB7)#9N^3d|;~5RvrS&7N%@yI<07*(rbkaQXbH<jku$c5Tg<
zIwK1a5s(?p^#%lu=521k0{{Tb6xNbUZ(MxiG^bsdg66+P!X){$(+CdTa_D|v#=j8}
z6~yh0KWV@Cf{qu2dCUpkR%#~Z6)D$QyM3d5VDW@c+CU@g9hJ^Du3mZbjoyXRWWs4@
zGtOEou%}?{K035`^cQ^68B#!)Rn)k4?!w7)r*MJ+wx$3ean`G=0}lnazyzoa1@XyC
zSFWFVMMZTPy9feqg#m&jX?MAsEG-?Aq+6f>qYmx0H!fc|?XF!wQ|QHqL`i4u&PUt9
z(!eS%gdBvgTwC2de;%wlqT;Z5f(to#z@BQ0o$Lo!&YV<@rm!CqR{)Z!h42W7C~2p5
z^pQh{?jM&OW)&}7x$?hs&b~HoXF{IaJ!`Z2HH*s~JZeq|mjo7c!0k(`ufCLCJ%=VN
z+^`Wq+Ne0^;mN`V0&$tn@ObSIHI~HtVG*7%Q&ivdbnWcPDN6;I3F(P|MBG_hT<ac)
zj|%lB;uU!9@}=(Uui&IH060@+^(nwBscRg(gL@mJvp^V4WH;6>pFhLx)k&2Ff`T}G
zvjBvhZuAb<j;h*%_(Gizvx*n4_xy#kCskOV2DUj{50J8**0FcFhY!Brr`=KWP!S~M
z)6OfGE?+)ZdD?tgwM-gIw{cMqFjH9Xy?N%%v!_r86$KW>W--@R>PJnz$ptJl@m?=1
z@ukb1pFXc^OXE@i*e05p=#C^=@6bBmvG5+wl7h=skQArgGiOd+Iro|h>*Len7I-BH
z!Wga{rZ8&WB3UwiY_+akI(G`jQt1#eOIw-mMN0st#Eqmt)TK+8&E@l*!*^{45hxAC
z%0~83Te!B-;<G2YzA$0CZiV0?gkrM;n{asP-JEP9s-fxuQrv4_JAeM#8>c6aEtIX4
zwg^M8c06jD<}Kwr22)h;!CzjTq(Fb#**u_>@2uC4t{!e2k+3-?utK!DdcA%2Bu4cK
zm9-rOvSeu;4%O}#EFW9i`1ZNA*Iwq;i=g!QZ3u{G9NdBk!f3*y;Zjh(y5zU4wuRNR
zCvnVj+m-@EKIt@8)(*2_=20<no?@re>h;ylvnN%&AXO>gY?x%V=m2A(N*{!DkiqK3
z3+FlQRJvmfnOZ4@H_#%S1uFB-cxP-iM8p_#=FFJ~AAIod{@wp7j^nR?{m<h#{?w;_
z<zM})fAzu(FFg6=laIXjkvGo0aryFP=iDbg@rmF5?cYk0^hZDXkuheB>5U13AT(M-
zAG)QOYAb+ZjPYTFMK@bsB@hH!Jc}z9`+|tD3zQ0ikWdsM34_QmiYUS)OaMU;inytL
za%RbZAPR{#hCom}2p5W)8QE*1AdDyofz{6CN{~dX)`Y?!K2MYyWnzm2I)E_3vb%k|
zX;DA`Ng<9c6@-yJ0hk~Z&Oqs%Pb)|Q-WWr`BwWG_5JvWjFbE?GL+}+T-~*);f$#vq
zXK<qv0Wc=uF&@}<T0~(+9Z>FB98`7YO9f#>41&;u$7vXAv*}7otkFiMzz?wiqt+^}
zQCyoahd|ACw;?HV0Vxvk09?lNVH7qd@IlT4I|r*k5Rb<6*NKJIq5v=<1wn{Pm($X>
zofR3p(Hg~#0Yjq*iql#LVMNn5Yiq)aIHib$8F&bXAi^k~Kmrp|5SA!FgzSx0C=R(8
zA<Xj@#26ifp%_B|C`^-5kh5zL0{e<fwMHu(p-m083j~3+)<F<qP-V0FIC|a$QP?=Z
zIsl|0bSaw9_1YAKDz2j*&&Az>uK-a9wJ`t;eJqDzpBM&Vg&2etmkI!+*an)2h(Ia9
zQU#kJ<~)E^c_7!%h$tR~aabEId3h8BLBK&cRb_2KSz*#90Pr9T#WW4^AYLgI1QAuF
z0FojbC{2O@RPc1<{n!zVR(;m0iY_Ben6Is%2Y^95A_QTC+EjD>A_{^rrr&i>M(3q~
z2L?2TYITZhQv5~)kgZvZ7+j=G-P8qCF#`pacAf)LHjFD%Km<)d0LTmjNLU#iTM~rf
zc)SG>0W<=zBlg7#IsqZ^#+V=oGNYA<2p6e`BA(eO9R!gNLS(K+SYSm;*PB9A@?$E^
z0Gdd`s!AI`1cLmI!BD`gLSYi03oKN%6G$l=Xsz<g!06=6@pTxq((~v6L;(&-)yS|i
zP%Pgh<4CJ8hPVdGOtvvsvc<8*XaWU5;(6khrHFzctiDuIVq>ijP%K(cri`|c(kP-Z
zgsMD1s1Si2vIpYPQOHCfK@fOxNb~h$yrJ<q4eyM1##|#0?tSS?UpjK+NT<`ee*JnF
zhX4NG|ADpHYp=b!y1E+2(dEmR5%K!<>tFoh7n{xI)vH%~y`I*3oXbUqJ?keRhVu4q
z{eKI3TtGN4h>;1v9>E-Rpnv@p7{lhnL23_+$W%}t*-}KMoV8f|LHf8FGI?OjHiAD`
zZV4cz|8&xyweqyk$IO{PzRZJ=GRL%~&6@m(6sO(!QnB=zDR^cw7X`}cY9*ZM0S~~8
z)xr)aFzY)-1O{jM&X+1OJ3ph((hTL>%yv==MT(Wm$NE?(B9h}4RBe`(&x_kJbj4N{
z<s20$Nx^W=0tG~{FT>^7<G?&A^2`Kl^<zqXJy3nAv-%(nfPWb(O)Epn3bPmXFoYox
zfxKCqOy>dF0l)UiGKN<*>_JkM0{NUd*3JNZWeBL2f8RXQ!m!yhmNnr3-E_7d*Z~E`
zG5-fB%`y+Wmejx)%JWDM$XpbVvYILj-aJ(8OZv17l|GIvbN|0(uG;q4%26v>c$hdY
zA}F2*JW!DWIC{DfRM9|zV}HM<tgHWcC`H!<4x*9yT9`e1z%rgBdtk?dQ@iRFeDIV5
zfgQ1f7xn`w;5jKUpu&(Jh8zo3$3V9Z;e3ZD%V1`ytg;3Z_f?Vz3^Hy}1o~IBd`_->
za1Ryxl$*vpN&r!E)Fc%S(iRFBaw06=iGc7t6c`}$Ksj9*%OY^IXJ5W!5WX|!A4KGw
zJA3vl5gB8gbJwq5S4wHEuV25$%*Gf*B*M+j&9${Pt@RXZaF&eiGE_Z=NwRZIH0L+$
z*^p^S18<3O^R5<e>^Hp)axCyI_;qiEMo`5E#uC)XP03V6w6;CmuX!3czB7KF?23in
zx%p2B^R?gEHzmLTH3#=!T<de#2qDHpY&io~YVML793dtSSs3@6XZy*hyP)d+UMldd
zacPkp(;Z-#<DDCe@2Hq}48nKD?lb^m5CkwNqR#C-5z$)1z>g&YN-3q3?7;no6F=O%
z&py%Ma!=-jw*m$5EoiUaxbZfq!oFD^@f|MQ1;KVtJbVXm;BBo2wr7x=N4^;(QsJS4
z_X4R=hXm=DzPI$3*1e;t{l#{+&KsbLa4%+%8@s|ir-|&@LW?odEgDe1jmEAF!pUOC
z9R`1JkgoPtA=5--#&^c_O&=xDOr{6SO~8F1Jnq>vBfWAH$A<PrOXKv@1^0TXdok?|
zmfd$ul$(`;0ym~YA9ugd@k{0&-GhqJJiG}Wbc<Q#9mmsKe(aKKaj%aq@rXz$f`t<s
zg^*>pHXZKqv+tM4;XX&;_gi2Q-m%^GYv{Q-7ZI5`%d#OGD5dkb(6%46)&hVr<}G1m
zF|%_n&whM|V_=3ok9luT8D>+Le)ZnxugsxYWQ)$gJDX%sJ~6BtklmxP3P4_UQ0yNC
zu-i0ofhlEVy9WO4r|_3R!TbBPi^m^Qcbo#dT<X**b~o)`4Z*#clqK%xQ|9%-c}u;#
zj)`Uo?2bL&1Ia4h`y{V++WnrC?m*ZtpqYP41Rw>Z3Xpv$ec+Z|WsCLed9WmHyLtY8
ztsuxaQ|vAhG2X@ftvTMgF6>qhj2Bhs6=}QN6X}<BmASPHid0=<k%pi${mMtmQFi7Q
z0~{2|l{=Oe8`W1|=-`eb!}L=ev_jeaWqfLy?5@;Hzw~f)b;%*S-Vv>R8goVn5z#qU
zuh&2N(U076{J0>lwOT*?;g50<k?~fW6Kw__d+af5v!DFrr@2kI#rub!n)-&~>q9$a
zi&w^89R55+9GJ9NoO6c`9eVe>AO6WtescZ#YM%G_cIFrnNz)Vn!Y~}$R_9z01Vogx
zN0wP*wALCC7Z(?kB(c_RYZJ;u*65tFKloV8xX8pzIP9S=LPR~r>oWJ;*kB46+2aUU
zj72eJLIQ%-Z8!lif{RS-sf2!lC<1G{Fx_fG3;k(F_}!$aC%6j0b5U3UE_xy+;bL{Z
zC?+Q;eT36$>lA>1rM9`rS$DD*rBY@WT>Do-_TC1kpa6t|i=LPXqySooWEodSgpeuv
zVm4>x0vnA9mw;jdrqwy^7gXLw?e!95AAqo@%o$X@${s|_yQUE{Zmvq&8zT0J2r5Ha
zg31i=Fseb|Am9R%8WUInViLjDyv(Hl1JCRkv0U*uYSX?ePJid(_ck2}b*5U5Dq3tz
zuc#;L`mQG4s)N8>Gm;Xa?k4m)xd$h|TmmUbyM$_7W$jo58ccyFW*T+n6(Fxrur;4d
zAs85F*ReK^L>-`A`d{{3TI(aFUASd=vO;V4j&j)hF^@rrh~E1~qyAgJ^;?GzANlc*
zf1G96J@?!T0AKv#my9vqJLfzR<+xtP=;CL4z21jD^ubnZ?fc*VK^}Iq)-rScenc=P
z7|TMmHp^p9B21)}%9%s5tpEBDza-1jiB~ch#51+lq!fra=Ma&I0ATEAW`;qIXb=R}
z+QWwr|H`lY%9%4~E?&G8$MM^lU2>Y-dFP$X{Kgw^Fz5FGaLye$a%6dV`OP=q>~uQb
z^U~7Nv7<+?udZIXa%Ev*;gg^G)VH5~_Wb$tV?8If(<wvLx;fU`|4#r^7wthK4Ew_{
zffi76d$Ca<5{f`G3|mA90BBLIU6j>mfSPCqH_Yr35ET6Xv-jswavay4FnVu9WM-{h
z)!o=hKqQETB)IPzxQOCvYBMd$Pogx7&&>Gq*z-K+%{SlpulLtG@0>UDy|F!SY|H+}
zS}a?OB~lW_RRjoeCkPNEh#ka^#@c(=l3T=me?(Pvbya3nWp#C9%iqDlsjkY5jJ$F0
zjkpnasUDVe36ofgxN4vPaSA_oX-is0kR;AY5Y;w-hyVofsjkjkbQ1>ftktJLG?z6y
zEoJOHb}8r>6EF>2f~b=M#eh4+1B-aJmf_l_QUbUZu4ySC$w`!J`$UnYfCP#@E7vGQ
zO7TQyWET5|DdPQ@kSKAwULPSEE*T@#r4TTHByj<P>byn?6em%pZWN)u#{$fgp-9$c
z8P)QNV}JzIwZLM<sUb#h#p}Z8CK6bHjRISlw(vY72_=E`gC)V8A+W$D7^AajH%Z(A
zp~$Z*ZKpVJm%2PV*AsV&xFTN715{bMAn`6O*YIb}K6)exJlVK(0RdtvRt$54E>8%3
z-@os^^;ceb<zN2g|Jbu<j}Ri6Oq!-4gz$ZT>Cz<+Jn%p!la*3_{PDJrKmMeaP{cHi
zuYdiS#ful`a=Cx|Z~x8PZ@;r|-@etWSKo8bJ*iaE^St-p|3Eib8GZu85MTJh!<R2#
z&KbAu@*8h#I)41PPEvCJ{ST~KwF-cShK4q7d_zk4&_fTcUbPw-o;-PK<Hn7S<E&qQ
z-`cfn8RNsl!*9Ly*2u_+X_{a9(ibNtCf|7D4I=u|m%cPPIk92G#(X~iJHPYf(21d?
zOP1#I{l||V`^|4&zw*i}AAR%@-}is#cb;0cYR{%kztslhCB-Fm?@M>zefNR|3zNyj
z(W6H<ZQ3M+a9wxx>ecJlub-Nly6L8yo`3%NY&QGUQ(r6=3z<yjH^2GK=;&BBo8^p4
zDO0Jm?|Z?gtf-e1GxMs{BEO^Rs=7i%YNo?vWBIsfDzKKL8Jd~}RhJ$*s_v_{P$?5e
zb<NH)@fjf~fJO>n$eDQOT}47@aGHhb+|u2(ivV1J5YSw*md=-uj0y)}PaEyvKJ1EL
zJ7$&MHygD@O;{~QN>|{l#L^MeDl>KyRD@8KR@LZzMBVvgSJNqCbA2sRiYj%(yPzq8
z@)<HCk!6TjIbHxF#SBXo#zD!hcnfR#s=>>>nnR;|Z`6uUP@~HocEtmAmsebkYPKtO
zKkZ_Vu9+7pXw#cHiqW3S7Q17upc$3`L3P=c8Y5M+pJL-(UC{=K2mytaLg^!`Z8i~d
zLB1QUqTNhXRTea<tXU0YwG=7Uds)oFbH2`zYbI5@_wcH6jDG#5RTg!z9*n@Q*!#7{
zg<>(VZum*5bUJnIx@-6D-FNu#;r{;qY&MIGd7iJ7N+y%v{N}TZ7A@YgWlNzj_4TiR
z{pzdN+O}QuBz)(ccSlFZPMtda`s*7`ojSF2>C$JP{boLw`{0AkN~v#u``fEmud4Gc
zBmk6B9XxPw>(;HymM#0rSH5hTrt7-v*Wdrd6OSJ{bZGzn{X!U0%DeBm`>Cg%8ai=e
z&z`+PaNqatzWeSkfB7pzLnl7|_~YxZzy51q`#r-D0JQe%tFO4?3T>mVS+i!viWO2y
zA;ir$-~9Q9K0h=xbnxK8haZ0Uh8u1;e*D-cpKJ%9EnBv1-TG0pgX^UL$8l`iE|<%`
zFF*O@lb`<dC$GQ0;p(fe&StYxN&vX)uDd?_?6dEG|NBI+a^+QP*Ir#Nm;Ux||MuX)
zLpR)TgOrkpY{y=|e*MD_e_r1*Q}ye30i{SOl0>TVPbpGLDOvHPr#iGVlp3OA8m!FP
zbBSg)+YYrm!o^%CR*i^;szU+lk*J9V9dxx)539NS*t9QN)b7p<mBe6$OVkAkDnzJ-
zPR#gMJ@Jh=Sd}=ja5ka3YFQBmi`ti}j5b^|7%QaF$h_52WJoozF7i;dE>#K9ULR%#
z(1r*s%owevqM%`VAf&EaZI0=NTdT#;R3N+7#VmGCftt=DB1MX(HKA69prBf%FR~t}
zDuKW}#*y`4t*#aYD?q4q6e6@-t+J<ULrPMTlwbWPN%=t4ikaOg*ESXP0HRI?5LAtI
z=DZeByVOZf$ZEDyOD-A>>Z%up>VT+h001E|?@f~-L?vo%#ov$vsj@>rb-C-N?`ack
zKcj#n;q){{(}hE$Nmo6SLq$&Or-<o@<>+ihfjg_UG&nWQ-i63QV*<Roz4PkC7Hu)0
zKj>W{L_nnKKR~P%k&ZfX*CG-zY(W&UtJ9?oTk=Sx&epgP+Hf9qvnrf-L_Q(ZzL%C|
zWi#1hM~^C{1_t_{dg`f6CR-{M|N5{0=EfUuShQ&2fBmoj?Z}ZMTeogmwrtsb_uaQ^
z*KVbBauId(=+RQCR45b<95`SY=B>Bhl1^v-zyJNe51$?0y=V8I{g*$x`KFuq?b}~_
zoa?$TyzoLMlOZC*FuwGqFD4QR*L5Fw;QoypH$MOT^T}jVN|ni^@4EBOty{PL^rt^f
zB$7lblgZq5*Ihez?s(ya7aYeSpszpk%<{{ZA3A)<u^rcS^iF_n+pg<YbL4n$z4i9X
zFTb*I;lexbynX4?C6kj=r%s(Df}x?~Cr+G5r_+~$1z5kZ<D6fA-St)?!5AAG8#{RL
zfaiG&7cLkc9w`<}h?q{NlgZTB*cj)0a&lt%^2?F&;o%X(5aZ+H3l}croO`afcJ0;6
zmMz`5aU&5mWNl@PA?F4`x>S;-GBQ?;bFLg=6_C4(GsbHs7$GvoYa4RSI)gD}oHGpd
zTtGm^7%+~EN7!jXL}IM+TnhS~F~&G!1U!mdF<`94UIRnMIA@$i@uJcPt}UBoj2MeZ
z0S1gS#zGn;#7bYIoxLC<##yVbB4eB}7G<{$fe<-svER-(1I`emQlQ2I;e*9kv<*zg
zsTB{P<|~ZI1B4LVRjjZx;}IDE01!d8q<|i(I)R<N6d)pJjBBZ%)&q=jj;+~-Gh{6A
zNS7+ja>jYIt!!k#IU)<&r>-z7iyTQ;)p;{0r%&Is%Ho`1L@7WnTMSl(0#OG`vv{~{
zA=BW|96yPGi!_Mz#JF<G(;A)>3fFNx!G+HlMk^VI1jHC`K>?;I5UHzrEU=XnRP;bp
z9zYfBfj|I=JnEdK-%z#c3Dffy;}OsF8E}p)_(%mSJP?_+h>$UcfpO>rfG}g~uf3pb
zGt)874P+@|s93d*xb{6DuCP>L0S=Ll^bn!lbE7M507B$E#0!P=BBKT4g$XQGR8~l<
z3^~_4pdwL#IOoXF_egrE>YZi*m13MxWR69>!V9NPO<*H+RnIT1h05aH2rMF3817@i
z7>8z#?F>rIE{Re^bm=lmL_|u<`_xq7_19m&_10VOxZ@5Yy8QCx<KyFw<7Bg0rPSH8
z!z)%SPp8x6a+!0k%hu_M!m=#J*y6>DC&tH1#Zo?>cN}MIY%G;d)f)^#@ZbBrr*FFH
zrgGU%CX=4$D<ua92a?I;(9lpiold1vwrvj#4CHdTlP6Cm5{Ya!?RkDOnat&KpM3I(
zVHlQWjgE{GQGTFb9XwDIC#;B;o`4a6ilt&Il`;%NDIy}qm=Fd47>3z4{_Ua!GPYpR
z!b~Q^8E1^`+qZYgk|lTCamU7u8-3r?>kO?AtDki$1VUtp6^A0F)E#%+@#?Fu3=Ius
zGMO5e6Oj-ioyjIprgHg=l~W3_Hggl{^Lsm!H3tUJOxEO|ka5o`_2oizCM8qpfq?-J
z$x2uOdo4s<@c#aOaxI8x43O`Ne4cX#Gt+eHoy%k*F*rEL(*2dnr=2(JCerD2*ea(l
z*O%xYK*Nfn0kuKM4bu$BTuQ`+$oKb?Z9+tYki4YXmusHmH3clos#3s@L;>ZPi9|AN
znb+6XXATUYk%&eCQYcJa9uphmQ%M-2Ki^MYGFmz~WaK8SzAOa=N)SOZl^h%xKr0<>
zx?)@<cruY}W>*40WVu`}X%C>VB2&Pyj3x@`4Hwfi2m1SgiRyDY=K<U7>kFA3Af3+O
zzyO-5XkA4lH<3srf;LBqF_z2aeJZ0cYDWl!$en~2zE79U_T>f!slT5K4l@Jr5P^sc
z(;OHWWU0RB0&Ar*nSi=02t<@gr`f<DS`jG#03=PbS!E#*)KS2U)GSF)<nq<@X^nco
zG|hp5frwoNU|d-&l}rb86#xJ-nG7EotXJ9{Q$S@5GnHAWM4{$13!qR~B5^j~*Cz!<
zU0;%tJe9+ySZqC5iDY76=KRt*1=8tsvmVe^eP6cE>L2Ki0;XvM=>al?=<gpu9$jF4
z*U056=}8*&fTDCdEe8f!A`28z3cO@0D6xVzxcd6~65T0nGa&>IYL++`0|Nuqn1X2s
zW9GSMO;ewQ&&*5;fSAwcxhy3zeObj3m>!{;2yn@~WC|)2P*F8u!b(tcazw4P`}&fl
z=o2?7G!l#j%t}OH80J9#K<&6R()^OjX2b4Cr_)eT+7yujPR>lF%dT>#!ySPLI7o#m
z-!IWcCL$VygofFi#Id@@s0nPut~ypSn+=?`03n;rivG5muz}_X0Hi$AG6UTuIOqNO
ze)1x&GXVflN;x?>F`qVJWP?!ieW_F)9UUDU90UN{ws-E_)!#pG(@i%4fbV-ccWAX*
zgK%B9KE0$KV5O8!N#c2)Fa!~4PeQ{GQYz4^1BRti>E3(qx&QwAfBy65cJAD{diCnx
z`@N@$!1sLsV2n#CrIfz!d!DC{vwYu|Qt3oBN=ef+^s_kU0N^?fBGW!O0O)zHl(N1;
zC1;uisUcyhQi?9U{Gx~`eShPI4YhaA<?^5Z{KN0P_ulsH+xz<ZQmIt2SacjGolciZ
zrF1&IckjOb{{96E28+dFDwQgiOHxWe*tKit_19m2=+NO(si+s|P)$%YF)>jb8>2!2
z8YXP5@{kIJ!sOT(x18yu)5w@>JBeIKNgXVgOJieWK2p|ko7Vw=D1A9TK0$5~Sd`6X
zWaK+0CI^)gGh-3-BEYuov9U4XGm?H3Iy31Mu~Zri*=wAdnktWvp<zYoDgqH8>+?Je
zNOgnKmlNaT$}RvGoi~fflvhq>rxpg=E$BGT*w|=f3NR+i1<SU>3dBxLO%=z+qOGnF
zK`At>eqSaK6*Zi?p!EHTiE-tYBk=$tlWr-UD=ew(VPnHH%jNRe*ceZG6h)OI<9=x(
z>DamEWh(%Ynw*-n$Hvhxqw#=}Xe9cjp9oqFyRJJnK8{>KOXs)dX32AsnW@Dg&n%US
zV`F37awBDl*Mv>jPA(vc5-O!8CnwzTu^A>YW6UlUOQo<j3xz2f8v~IY^kwx(pf(c$
zL-bsCY<yI>ilP{VT41SI9Bf{a5g=l*R2&~4<q0<m4`^2?m2urnBLxT$f+^6+VELZO
z(u;_i!(+4$&e(YL!D8Gmjf-+=pt-An08lIzC&tIP=@3PxK-TqA$f(X?kO&!~FXhDK
zge;6jQdxiq(&rv5A!=S?BcfwFW0AWG$hcn|=cUqMkRBkSslrroe2iNTMP1Sn^?6<@
zKo6kr`{Uzdb$cS6^MISM1{UhL)|urk5wTP%jgOD<q>L&B$}JmZJ0CQVKr}TqRUR8-
zW|AVBL(EL}OKAoDDy1ABA8QOUM?}x@Tn~b@91u-TOyJmPrdU|ekfxw&yOzuL_}C~<
zMWX;9l4qwJ2M~jH+-P!Y${rt!W)kaZ%S<k!fE3_};Ct@)_;}Q~G(Epip|CLIzEY_)
zHZ~SfW$CT4a>}vIR9-SMo&Sc23BxXoPmYg!6MBk?G;JwnSPP^wXAWp(jp24DuuR%T
zRVXY7<~k}A3X|hqPyosIGOio6bU`KM#KgFAOVQSuRa^ikgp4uAadz(9`P5TS-F(Z<
zJ3if!$z<~RoIdf}v17;m_us$rs+AvZ{&2~XB`a61+`M^nu~<x})3v0O0F+21bU}h6
zM~*)D;Dgs*d(F0OAFsW7?UJQSKmOzsr7D$1bo$D2xx8)Lw#muK2OfAp2*DT|8yi1+
z_Us*Z+`ePS4$j$<B}>M~$4{I%al;KazV+7Ih`4z1qVe&GW5<rITeoiG#y6&>Ca=H#
zI>&KNoHz*pM36`%ecxNY{PIPM7M?zRT63_HQV#$T=*Tw&kWw0kVHiSi&KPSBfxGCD
zOeCP1P4tN;o>;J8Fqup~{P4qj_wIfA>8Ia)_ucp3|KPs+?oFlA=}hLpfzR^!{I%C!
z`}@ED`&V9h<!^ucTSQDHQyV|taOa(OKK9sS&p-bh&CDX}`@S~ggEbX_w)si;(}Ic&
zeP8bjRQ1G6L6XY%eIF@Iq6kPzU->>Tie?V^K9dqcs`x3TJkJB)k8BWDGu#G3`qKA(
zhJqr^D@2GaP`l~EE54M<myzl+A~NOq()Yu{Tu71U`H?BWnDl)W{&t!N81pIW%!;9<
zVu--^WfwdkJ>L)419~rv{D`Y7Mt%z(Ad<fC`#wV+kphyTtOlIar*H?I5yAI;r0K6Z
zmjXY0d@BOW{m2HP7s>-QMZuts0*o==SF#n`c)rhkKhS|$FWP*~uF(dIN#B=2w`f%)
zrRD)Y!rDSFC`jtfN(!pz<!e0v(RhG-pNF%nChQFD+9A7oz6vLrlG68l;(iw<F_Eg|
z?w`(4K~*V`zVAmXC5s5sC*Kd$0D7;%_kCg!*_DwW!UI^Rw7a4}NCXj91`8ot;)|-l
z%CKijr996k!;iczqE!|K`(sP#d%n-3D{aPoB5K~p)YhHv`vC@F%jv_H5`AB_Qrgn1
z2&{}sSVbz#y;Dl9w4+a3%nzBiDoQ)*31JI%t?)n>DyxnMNGVdXF3oBs1X@!7qY5l3
z7J8)CwZMid?b>9~1qHN%ol(xGQE5kBXV&vI%p<yV88r;!-FM&X?;rTRr=NcGkw*Y9
zo6YRnwMz(b;K0E*Hf<zbby$<_+a4n&M}veg6d2tlC5-M70>VpoC@ly|J3_ikYLs*e
zNOyOGph$~BNGS5%{yzTV*bdmUC+_>Y&g+bTYrnUh7kMx6@bCco^fB<1cdXu-wN?SG
zBfIh!!yoi>>hISs*UiqGa}oxzSG89Ro0o&wWYV>u9nxuedb@Q)=AEVoSHDkj@714?
zf6agCtLsuq%I#Q>sZ&56+6BSC$B(<N7nZvI{=U7EyLEtz%E|(B<=ZU)?f)JW@BI1d
z&%N7~^AFYq|LlkUW!>Ej0%(cj)ydF~r@y7;kDbT=(cin5jB?v(+W~j{pXA#g_oSED
zLT!Z#%#(yxDy@vv+3bbr=R_i`7$rTw^p7NiLlmDRCA&SL?UL~Q`d$_qp@CO%cb7MO
zx!v!3os9}f-*jpH_m11Y!^6WP$sAaYJ)sd@{>P$g9@=@*SD$0LIzLBqgHtgPhEJAN
zay9wzsgAa``}%v2ozZvR1e}vRO{HEe`tJ?q_v+u>60WX8tN2319ycDU?U^6HU-?DL
zqFmOg?-lO8wDye?_Hmyl>ll5a$2o1%V6K-RmVUsBdw5A$qz~!s)pMpor?7wULIg9P
zK=4GK7&2`%aI@4`uZX%5y^A}CM|?0s`9xNq9!f~vC6jkJ#JtXewatV#^@lG<zAYLk
zSuBREs$!kR;^(im<{REC({5L2WM4b@`puukyVAb2@rhhZE1zC=ontzNrr=$V^F!)x
zGsLm8oFGc)N&V5+Gx_Pj*SVb0-PO7r8nNy;Gy#0IUis!z)NO(UO&wp_zMX<~0i@28
zkdjhNUoKyQmGdmS>+Ew(yYIKVbab4l>iA^LJZpA6N)s$1T3(=gEh=JbHTyPSuAg^w
z^L0;d?bpv{Gd^)i$@3M5w`vHN>b^)T#)rONA8uZ)QFEuYSGRyTU9j36n3aH~^X6R_
zuw5HV$L^k<PB>}<3ed}cuTXOvvGgT#XoGELe!lMepNUN~kAYMLbU{G@C5JWvt7dY?
z&960}y*`}Ui)Vc3Oc3VfPG?_kaQzWz1i&0Cci<l@<R{pB;E9}6gmRaE$&9Ma4kRY`
z_m?qd+5aJ$f_@J*xuQ#)+;6{7PPRH_fn(8gPKSkhk>=b3M>}1hnB(Op1<E&lhO2u)
zjSC_ZEPAEBZM*`F6$?9VHT%VxB`?bQjtWN%ruf4T)MJl7a+qq}JFKNpHXtw1zPCYQ
zYD@p-<9(lQf(<T$LrdxQeF2{z%Z?F~PSwW2aLSj>Oa~=DaP&C1I1l5VmG(_5y?Xev
z=ws+^Fmy&k(08!XoZK>wKtpDU$E(Mv3OB9ICA}?3>(KJivq=f*lYXYS)+TPwli7%X
zi`|)Tnb;v1Noy*2H&Krx%)B9ElErhYJEY^q1r)NkUhmAe`QGpQf14NdHc`kzdy>Vm
z>B-!7%$ZLcEqt}krnDKGG78x-fYG7S$(8c?GE9!tWKRa87-gin_uuhMVE`rLL%@>;
zQ$T<Eln72gBv^0Y^0FTgcJfK|<|<P^4COxbQ%AUL8mH~}e_X73a&F%F{ng0`$7<fA
z{<^w405j8)H$C}^D^Tl&H`jPLq(}Ca{b@(&ylv%;iO!yY3YytZq}psXisHk3`Fzk-
z6Wtz>%TUrwk2se<q=M!){b<2g8M3Tj-7jPkRp(`wRJ!iJiz@9sbSg%TTwCau8&oCQ
zAI%65yFGOzD)zOxxmb7_?sWHjlYrGZO)Y5bI_f;Fv^qbZU$NhSYhis@`t|d?*N)7&
zi<>Q-m4B0r?@kRo8?2!(V#wh)GIpIFLfhR}j-?Z{ClMU`-A7#99I4-jTUA5Wz?I$g
z{Yy5DPUUU=-_uquN`C}vo{Y`vAP$<G{O27j9*Cf|GMb!iu+l^Ah1}piwYR2aexd~l
zZU3oYu~;6H4d7I~Z7!Zn@66ez>?KkP>u=Be|G!Y??#Hu=9d@klsnGDapFH9`LpmGv
z3Ih6tv3lmfA0dDLVj=9F<Ji|YRJ5v1!nS*DS2Az|;!lTN&ZKQC>1c7i2E5-42`a~G
z;K11*#Wt6T-<mDm09!vfNy)2EukRf`*GAj~zT5)8PTC5A%end9Bh1N^OzzJQ057n!
zvjc-|L(KkYD)+_r&F>O%D0LN^$)M70kC++q?6a48I$n!Q8rJfY*r*{ic@aK(M_4(Q
z2#+W26J1q-OR$m4&{$ySE3iz0h1BFBhqw9n5d3fasnK9ED+jP&@0I$o>ek)E2qM~-
z-(PHcG47>3asMg(_`2SVug1LnpD!SxKWX!}G%=Uw+~KwFV@s6@k&j_a|IyxAJ|%j$
zWbG2A+>H(zFtY2FdJyFIG}3$xx!hh*F+=Sz^}yVlsxF(<=J${?PwJwYc)$eoQTWh`
z`1*w7g5EpKGo=U44u0M<o19PQ6_IbK_K{v&j0EyaLTg^V&D?zAuiF(ioO{!{l#N!G
zk6oIXdk8sx<peT$NGQL3-zV5|bjrtN_ABF^RHp+e4vm$&2<zvFy0_d}t=X(GyuCy;
z1k>Bnz$?4ii2L)G5q+1XYWllU|8b>OzyBP)J@i__;lMipY%(CM<RjQ~e*E}h_}JXe
zboVEC@Ad0=riZ=@hL1fagDm*W-v0onWTn|H`}^-mt9gzCRyZn}vyp}QfSYPz;T9EZ
z5ThxV`oz>Ql~qX{L9J#&S?1iwoA<;&mvaJj)UR}XLtjo{=!y2e$u=TQR!5-9jQ8e<
zLs0XPXB9+*oTy^c^+(8PDr6A^f^b}^gk#XUdiM!o2o%+csuorRmnl;l;aa%2;_Wgn
zE}B3!;seuR8ms4tEhYu!Rvb^I1i-#8Kal-~q5@i2sH}VCqJ~dS;D!?X@OGme(XCke
zciYr&@VyTVFumNzhQk%`(_lD?7h@agdz@mvR$hsR*~sia)SRDJCsU>}-k_#gCBbq0
z@^11$Gt+my$5bF*T3x<aUTKn0ry}e?2#(vxPTU?LVseg4<y1>mVYEY%S{Q6t;cUog
zh=_124zAGGyx-ew$Y<Ju%z4kfq@RFI1Pz8qkYjhQ@@Y5&I_LA?UVnK+^mv_VUE{v<
zW2gpKEYu*E(9k>8FxR$V;&W9yQ>p)C$BZRx_HvmnIQHh4&x{4WM@;@AmF64_E<SvY
zo<b<;>+AoUxn+sEh=D4=dEwAj$O8;F47lv*@barkt+_BsBRG(@P8$;%h~OYBGvzPP
zSDk^@-+irFYw5Hsif~W*?bMU~(uNh5>;wo)_QXlZBaviX{r%w#hjg!2n-GR*oN@za
zOUr4+dLHfsSWe9UFfU8#&_8T!o77j*HkDQzC67a*Y(1YnODM%xz0!+(ljveMn<-E=
zn|{=Qhc~SX@#*wcfk3}RI^h|dvVS)F^85FQAe(-7LzNldkNz}OlPF|5)w6M1A^OEc
z*XAiYx>#i_q%L8^gYf*4TsbI3<Zj4)1LcO(9`*az*PJXv4=5f1)Q*u3$<1U}3!zWH
zlc$QKA1s(Rwv+S=LdY$IORNDBmJboZ1UR-?yWQOo0p=>Pj@^*X&hC3rEV(1#6@Yhr
zjaGGsC#vF2uEhQ{<NK~pA0eqoCUJ*9m()ch`}l}~F+A|UXEXT-5#0Y_U0dah2zo=y
zxlBli5)ORSR!BksmWY4m(J7)8lmCbk4igwWz51{uA3_R>_Nn0=^194wq-ExA_m*XU
z57gGolqXePoWuyTy`mZE(}OK9UwpJUIWIr}F+&Hw>Z%tg992k2!gvP1StuaKLQ{-<
zk?;F6EBOCN7YhVA{_8vw8=E}4O0U~74GO1-q}#uT!wM&={GJumx@(AlCIGBUMnGUV
zd4&@d9ITp`t67pYq@bT)!|$MExEd@^I8nR>f3`{y3LsZV{h=2Z_K37!zX<CV4W$2X
zVBVNDJUc?35cVK>q#BW+YK#oWlJ36tY(+{I&Q_y>>w+8T!G}st%jwGa9H!u({Yjd%
zXSL-JPS)194XGN(jY2|0#m?w$t^)rPqJ58MuPxR!j{S+pJna%2o?1r8qm&FCQnzd9
zQFxs&@#|+u&;A@u!r8<Y;aWfa*pUzWiE6e4niIoAMR;m*RQ)r2+SgTAHYc8*b&8iS
z*7NadX9ac0*E^u=y_v|ClSi&K%U!f`<Kg2kfqvC>MQHHyW5;hWW<+4_W5QuOo+ARW
zKqF8*M?Y3i7y;c|Kb7uyEe1x=jx&X(5!ZL;C_!vO+;K)VZU1uu`MkZAxQR0Ng}7m}
zA)k#}_url0m*ZaF#}G40!*`^rJ(=X0Bghj1AGf-n^OmGTuN&pBXPezvbI?Z`2Gz+w
zfWZjek`L3+qX_Z~{yT}>7--A$l#<|M$R7E7hD2$6^Oh?bsJuL)y$GToxBdHNMzMe1
z(K0!p?W-3+;neRJDpEWd)6MYdVgT$bHSYD!xxnLq5A*aPDK^{Z>m;?cL=+sap1U;*
ziia$PaAC5tl^_U=+r!~PbhilEb1SlQnW<(bWoaP#NOIAj9>>P{(pJ4E!RZvq{ETsv
zY$ISAi9Mv(V-upzHRK`T$2t2Uri^ju?88<jR?lhMCoBjg2_^cja&)9&TSPA(o0(-(
zznbBBP85N91s@&}eKI)a|GM27Ss>5z93Ia2Lm;XMM7Hfa&%i^exW-(^BMpdd5|Q}j
zFfM32*F5aU`I+>Be>W#r{P-_fOZ7`@-nN9Qv=kX<Ih9y;O|W|6@iONd$0Ks&iTRK9
ztv+((<^|Kx?l=H?zN~hhVN;Xow#?BWlzEVrAykra`l1A-FM6dpTuZRwLq3_?&!&iK
z>CWRq_}hzv_byR*s9?0Tc-t%<1f|-ePXSFx!UDUer5pHmwM1N8?-(%0s)#;L3%yk{
z<!xiQ2z1m)r$(@lh=)Z#&MjOoxck&>&6h3;%`TYmy?ok-T{2ElZz)qAvb>6A#W(E;
z69Pjk_X0&xcGqhP`@c9^U7t0TRt91sG@A=7;Eg{T2|8K^>_}?#Z-ZVxrBdx{eyq^`
zQejIJjb7d!uUpMgL=G+kE0~uj$!{t2#Inz&Ym9jUk6or*SL*Gi@?@6&Yj^kb^!(JT
z^t9_{5-=P(e?+_nGnY7*>Q;L&a7U(Smjb`l^WWbsZo9F`KKvYHIJYlARk%JJu<ogK
zBQEDQYCg6u7^d{;%o?6<>Oj%oJqEYC*${$?NEWqht*2(lL!GK0+qe=tobo-xC<@K8
zg(jAn;-w<Q(@2PYCL0;6)}G;=Q%f|u<5_NO8(FMcs)!uUAg-^6B^Gm~M$huWx2d9_
z|7DJ1EN>Z+Q>Sgk@~sJ{>$MwYo-2GbMB`vuhnfC?nICyty2cK{%MUc+qDg%ct&BBT
zY~EYXbbmY?5_d#Hgv%$Gq!t_d8&m$0|9O0vYO2PLXWcMymlq)m95JF<UOZo#K1T%>
zxq~t5y6*QZ!H%e{6$8GAa*m<8m;q=ym6H$VPBz&x9UO8WqmD^>!Xsd%1r~h!^qgls
zb#4qXxM^I7^1C9qiDFSV3Uw^1NJbv^<HDWg5Dp50{pBnuEChO8m3kI*55geI8VWb$
zOV7b0^zOzUy{JU0J^dseU&ql=jTiHKKw;2Fu%Bb&-)R+4bn+{y4^H8K02O0QhJz4z
z1Fow9sOO^@ZGs?D<t;1(G@$x156$~hbRo);>sW$-?zyUIvqpq<$ZswwT-9reEC)p#
zgk7DnZ7;eJH9wcel?q*=MsG=I7wE#GRg$5$qr495mKZIhZ>t#(RmOuNJ$b|~_X9(S
z6*&eqU|q1ng5-a0qv}^>z-3j??e_3%LG_WZ8dlBM7qW1%+(T?g>L|vu4yNYxm~#t3
z{XRab%pU^dUZ=2niO6VX`fw1t^<EpS%_m^mD<y_0a8okiO8sD67elGQ&U5UvqKVaU
z8OsM?OI)^K{4>wsubz+RXbMkcrcN8ZI2V7)Q6L^@U<y6eXL9aV*zR8ibc!N{twJ>=
zoUiYNz6{M2)9E`l50<(_$;Fw<mi6W7PU90_$v($X+{Zo+ShnIgvY-jed&seNXVvGm
z;I98i@E|Y_t+e}1`)qi&e)X?*x(j^btDQ_+);$6B<H^v_5P-6q-H*F&;vUA`y9Zi6
ze49VrA=sdAXApP)@U86#Ri1LxcK%I1R&bC`i1<iGaeirf{6!#579Ae_b}WL}uUFYN
zHsmj@9fCOaaf}0wcJ;8NLoB&cf~{>V-BZ>-l?o7LJ<|HdM|1&O@!fQ6g9&x2yD-(k
z1S^S_XOo5c!ITc@f`{yt>Y<!-gcMMrMNLS~2(}(VUOE;ck!)VX)G9F8w@gh=uQ&)G
zlHiD+5b}H)Dw+kBdFb-zQ00*0GQ-Lf`K@P$3{|DUMogdhc!?8*X@;?d3GM~eqU!`g
zFo%xHMe>*!Dn8r*i#U~?5V0^^x*$-&*yPx_)Sv8A<tJ$ML=#1paL3=T4JPQPBT6%d
z_U^agLK3_NpTCEPkLoIwKn#CzWsS(|GHGrsI6`AsU&0LJ+>}mIED1i%z9ul%HzCIa
z3*r?tr2S1@%24oP5c&w$jB$DZW5>lAPH5Ptk`IrbCCzSb%X&{vX9J;=HZwLnm?7>>
zt4M0}{FHbeY+oh7oblg=Ql=GoRB!~hTTY%;QD%R?1W~SqGbM4nnA<@*6`n8;im)yz
zF(f#nR@d0PQh16Q+#8OjWo@U)#gbmN#6Ryld)aa1I(cxa=(UOXZJP_@V!L%k>aR#1
z;S|CY2<jZBn0b={_EytK?6&?sM6e`<LIKhZEZ{Fbz0OWW<#-`mo#q%~>&nZ^3kq17
zKg8zycDyauA+YECwkwK!Fqv-ZMu`+JbPz)qFuggvZ<x7J9#*PC-tQX|2uB|#=cjYe
z|MDq}R=`KbtU5brl&IE8G_@2hHj$KTxJ{R=lzlL?!gB5)Q=&@5n>Wcq59cUVIruqK
z{EiD?YV_LdFqjAwb=JBcJ#Nf&=aDU9|HjhCS7(VTpE;>1jJ%}!eemjrvU#jgyJVF8
zU)og2vU4T8OU^3hqV$l+r>BPL@L0LiabsnXQNz3zGUH8p-&OKIat?Rr%nup%Y>fp~
zzC*ZfuhWCu;4Th16qzlnJm|t?d6oD=aZ%LW)pyeEAMfC|{$QVUrr3%|c&Cq(Ojn>-
z@Kw|31@7VDXf=0=pS9ZL8jGLzu-Zmtf6-{g$FizgwAd{~o`ZDf!{>m~Tm_d`hc`|)
zd(!?&Lsqqdt1*a)@7sLL{htk0q9l0zVu^4B-wmQ?TnZEhr#}4L5bnBp)U5;d2)NB&
z^4Ep9^t<g;bc)YIQpPhldd+n=l={6=U}bGsDj}~HUrAapMYpzKo0`Ex<4%A7t-H>d
zN__J`<{uVeo%8T=;OD4`sn>}VA74s~<JU5~2cPRHX@v+9b6-nZKjaJ}Z&;W7lzw?*
zQ;`P}SMfO)83nD!Q=bojj-9Q?+3Gy^q99BZCnc9<=i*xm;$v6tV;I)ncztE7T@cc3
zOOz_1?6&@s&eZAiF=Ctz_JZS+A-ePo%W?kn{tx0$(GD4Od)$*MgE`-22Py;xAHa`k
z`=sZo6pdq&j>!}GW_#pbk0ltzvlDV1f3#`l81hI#fld}mfYsgXma8`?Kn!`tsG>eX
zC#*Fm5DRwU-Q_x)<m6-pbb?g&&vB2q_XkNYCoaQ(1cJ01yt-ZVjx_tV5`0q7ng;Fh
z4VGrt*cTAw#xK8ba@FG%S{4C&@$oA1tkmtUO3vJ+&VBG%pz#XQNaq8rGM!&vS8V7a
zo3a1tSs!Smef`++VsA1R{d~=>rN*Qoz|nCZj828M{$=`Q<>W9jGye+O6qz_xn(G(-
zg{iLGV?SSF{AnoNfR~gtdAw~S8Bb36?;_Aj-+fnaFh}1~we<R!&+!s=r(yGa0NrKX
zPFvm;yStUz*Y-$eG-H+MKPxcMH22%coUoSz!=#@-J<JyeJ#zk~chryZ-GU=@2TL&+
z(Y~v0JB)kyZMoj=D4Lqv{rxB9C7)DO_0jI>mCw;)M0#b9*x<ME(HP-qQmbha$Z|9#
z*FiShl?vN@_Bz$#T-l!(g47em<G0LjvQ58}vnb4qAlt6Vn}c%8DAuuN3Y(*u%)?+!
zCa!a9&T{R#*1XvR!yh8Bk|?KFMj3n%xK*uEP?I$u?Ck!|A}jZ?Dsy53{F+6KqYoTs
z29tloyAdAM_}$f;(7@Y@p<emO6+gP^A)n(!ps7)je*VO7zXFpIi|W*X0|mPl_!GCk
z2cZ@ZUnshMiCL^%&a$Z^qA8nr`{_4|&U~Qp)8KXQvyQcdLcZ4g;~&;%HqoR{<@Xh6
z;muD^W@R|{rG8JCz5P8gTTy`Sn*DI*%v`qmn|YBDEi-lW{X3wrrmi)+C8KBvaghe<
zCTTtkhVPo)H`@G9cR|)KpdqrSs^60d_yT4gBRki!7p>F)@kb#et^R2S9VT-&I$pF?
z>*>7+2lT-56hca*lDb-iy57V_N^lA)x@41qp{=SIRj<Uy00)Q%A$&nhY1+K1Jl@_@
z4Pg@W_@PspJffWQj0RvYxa#CS>y><(oAqaL2I?bdDi&Q70%hd~OHAPs!iA(5APce|
zWhue+<q-y0=9rZqkdUM#gZ;q-RB?*J12z;SmC%I-4F)<WtQd8yJ1E>PCO8c7Kusqk
z5yP_XXO6&7jdGgf%G(+;6EIdET8jP%M)8I+rohXo^ttY1GeQ!Q)O~uYQ{8oIQAX;B
zsKl(Q6uYOaxX9v^q{L!*7bohEBvtByLb$qWE1@UgMRVQYV1q3QD=kY5vfDA@;G8J(
z13@_#F1(Ig6=SRM@m)nFXLyyWb<=&e$-w*M21+cbI=_l%&k3x~8>ut#6GndICD`-O
zCqmKrRN>x+b4bJj=RMUj+nB>3HwnfNDzya?+zM%!lv{aq3GWtRFf`dHbT?$b9bSRE
z#*zRB@8&Cka9{`*`hIP36b<{mjXRb9+2K-ERXftkxGCkl-=k`?T>J1SJlQ>s!`z&~
zeEQ4Fl|o?>xu%Z4jL@)228Ye5U9lIf9U<roaDBmi6|yy7K8H^lm^QV?-}R>+u=D`T
zB6s`8YsXVERU6=Gn;QQJQ9Gyp5N}tG<dMrx5#lhxZ~ot|&o9Vw=~f#LNLY~_*OsxE
zIr`o7<dOS&Uf=J)l15TS?K4ud_z2z%n^~3W_W*DvEp^zwfjP+vM_6)OI(dYXHt}Zw
zs#$_(F+1qKR-!f=kpL^fu*ig~#oJ+9Rka)sn=us@_2dVY$YuHBBt+VTKw??VS}ZH0
zz=jpvGM4DkBd%1zv=Q4Bh*rpAjm4(nPBfB>>3yOyxKq#0?fluX)fbbi9~Eb3*{SC{
znOe;$bESs5re#KT3z$?C4aPboDp+|;TJC<#?~J@Nfz3!?#14&|#nH>;$yCSXt0w5K
zA9ocSqsUzKUTE&if+oEac<nrB%#};ALQLqgnnyC5p~Y6Hdmr#jM8cp1^7n}oC+uC|
z5I6d!Su2A))#4<pB<lys0M2BurP2<eCsQzB7uITs!iNRZ)q6|1wVAMwJ8e@Z61l%7
z(iTb`w{J+$_NsnOcZ86aH$%Hxq;UxAGF8?VHolRztVP0CDhGWUq6l$?kX)|b(C9U`
zgrrD;Gt=5n&XEAFVbG?DSaJ4Q5aCWbi}k)sj{Q_9JaNQ6Gt;@j`rTV|a#*JAtWZ@+
zHW!o5{bVN5wP*LR5-1d4x_yFoummPSHc33Q5PAI&IpfqLRJ3=Ai47~1JTonG!gfZ}
zX!WbBz4BmCiczm~vtn6AqhPX<FmAEb-SUIqsW4^85;?)7a3(P!+v+M-V&IZGhSk_9
zELGLEA&4gviyHF|{l#;Pcvl&zS|Wl=F-Plduwhb=`6UMzmWCDvR}agiuP?)al!*M&
z7m}b|Y9f}c8d=6OfxY4y0nO!~fQ?WFggxx`!xBtYKXs*vSV(*}Q4CR3eiXEm;~<o&
zOxVc4Z>#B<s><GHwoVa+ROWVD__lMzP=kU%X`Xh&z*pOINKldtRDi&#*ll{GEi(p*
zLylpwh>#ImAy-76>I2~wo`%`!UKZE7grT%kmBs|2jzIlpw<(7vG4hWL==qz3wW2!t
zxnrt2(ZgQ{4gEQ3wefeSR>qb%3OCyQ0PUNAoG2pH$#lo_3J`7YGBMpG%UvY{bpG3F
zQ;e5(F>K~kdeFGeSVSw?V^@L{e#nG`-`&4=`L$sxaI;2^`92&;75Rf3;T-yqA4i-x
z+3+dS4VH95!e;iX)ru~-pN=d|7pG5vDpR)wpYnZ=z$xGTx8YVeFRDQhqGsP#<fCXM
zy2r>8%}M`^P+?+L63U1f-@v0(3JR=kVnt(u8CawcvE_$}tfo#6q!Nl?rt<H(Am#SB
zfTlZLKAp&nuz?j^e{_pA3>Okg)F+T()u<Xko$sSoAOOSeNaX&YV!1V5-XiHqYj5mc
zHe6Zn(oKrDXXYpR>{e(#R%I|K%!9c(ojqJPvL{?Gn=RXqktG8PAE%Q?7R6z$4r)G@
zW3#fGxLbDEFM`XNA&kAJf<y(7!=&4KVU~9}V?p?}=Z;rTUw=W;?x;Yo*gU<By;4gV
zfhiq5BHoL+xsBpONxjsXYjqqP5l4(jaDlxEAk@X@l6R4cR6y4b2@MkWZIwKVzT095
zm8?|9vd@Y=)x}J-I%PO!QG1mQOuF^)C8CH;x(|#~&1VGc>B4!NpH#e!61JkV66}i=
z>=T(5$hXp{FV77C%~GZly4L#?tw0y)l<#D)nC|1AP1PJ)IgMl`l7K$Y!kUwJ*Y;~N
z@eq%pfwSCE40rtr+glePsa|Occp)#xAchN}Rs}(Q7FdO>;UXmVcMWVF=ct8jsXZ>R
z3J>_kO4uha<D%n-N6$rL^p`;o<ajpDlIFelH?(x9bs6)KhQnAwh@}T-q^$`Gh;0Hs
zy9<6hmsTbuVSA<+2T1_O3Nb!aw%krwxDJ5~XFSCrO~a#I7ts_Mw<HW#bB}=b1VG3m
zV3t{PFXE_@=!+7e#T?({HwNjKk_^cy2%F|=|7N5LqU`r=Ls;GmkYJP81nB2ize}};
zHW>*|WWSC)bSFzPa{V#$NEd}Aaq2YF*tEJ=$SpJ8r66-S!oz>`!$->dyQ_!Elhc}u
zZJ+BiCrnD3=3FCTL^*I;xEuKhr}=pO#rF;{>XZz+9*?GeyVl?^1<;}vAmw>BQ<&}k
z!Nbzh^6F%Vt*=jAZLIMhJK*8B_d$Vyfm3-KB~FVK`l<*b%+JsJoLXAEims+FSYXs8
zgxf_$(urBJqYkl>&Dq0RPod+)oSf+~Hbq6u3X>k!q5JS4Nio@y9Jr7+dCpG8i8*Cb
zOje-SnXB8{ul;@WkA&iTA>{PQzESDXM2hx3fNcamK$s%YYyeF_KlS22uRwM<7Xq~P
z#pZy$I+*fA+m3@4zvgj<%|mm&;IR{fUOo~_0ZJWhEox<z%*<F-tby>R?sS5D$AEr<
zU@UcuxcE2REyalGaw$tqDU9ak7dz?)a*FM23aw^<__(7MU*S;9gzDzkD*o!ZHD8jF
zm6O2}|3=VC2}CB3Yx4XELgqZef<n%upL%=8dXVbXYp@CJtdyU9so%0FFy@Jii#rLY
z95Ey&$LOoC_$FY*tCx>N-Er`4jDr#oXPR@-#8_1Uir>hL-j~dXPS<HFWN>iaQCw^s
zIwe-Z7_hxKX|fE3$oG#M%BZHL(o)7-`Jff_u}Z=DDLEM#&y<HU1VRjk9O%jdr+Vj6
za92+kdB~8@P$8*Ng!#~fXSq`?7Zo2Bk&R8!dVP_;{EkdZVP~y&J*4=1e0==xfjYE0
zgW6Ru#!gG98h@<$cxFb=9g{y&)tLH%g7&4ACRGekb`v)QFy6FiR8%r|yeCalLpzW+
z)k{3M=&h^2fNZ#p*AshgbEHHK*Y8Yj#7o1uw_^nefDGW|btP9DJsw1(M-kaOC-T$1
zxl~%(+B8GTnVDY`@Ed1ziZc#)rsH}-<`$P72i{?P3yFwj063oC5C|!Z`su;Qbda58
zO59`b+iJiJ{vYCPna!Ru635^_$!!U=s<6&^)2q?`FSh=>{TnYc%Mg~!8mWZqNxy&u
z(3`j-wF5q0i@C!|70M)6lG;q-Lp`v{tO60*NfVAE!HN-2P}kDber{7VtRxchV1U>~
zjgrj3$V3}F&@^%`I#})bC4?~rnYeT?YC`>gxA7<CEF!7Y^!+aDvu6h;3ge%Z3TLsh
zwSSa3(M09HdGRS^#fm6bg--eK+3Swz`Q(od^r97|&jLQL*ZUj+pWnfRpvzCM0S!?{
z=KLXQRQ%)e51=IbbN&7HZ>Df5FwU1067n3_lf9^V8Z_p!-tsXZS@1s|>erERPd7&0
z0lQuCHK{t{h(4FqCKmTNMu!N`#&vKeq!U-sW`~?!XfQzmmoSkPdoWlqww?-au;O7T
z)vVzp9b5F)pEt33H%B-!Eeat7c}r;Iu&GiIn@tu$A|jY~-;}A+k*a%<%96OfAQ);}
zsYHVqwEqF|RmQR=HW~gP6=q)4e<d(TM>NJBjE;56i&MpdMDm2=tLn=?Z2{mCj4+(Q
zm8=+YWc<$kk7<L}dETPJ^nfL~4c+G^CCG50zWiGWf!<oS8$xqEeaJ)iG_7})mTAZC
zwZ^ZxxbNaB7}6}<Rf>#Nie^Px)AiP@iW`b+@F)znj#@VE$=tVuVQOGvZN>2~nh12U
zQw2Ws8HU(Z;n1+DVl9d@q&*<Ta^d18B+G{mntF)aRA#*<aoAUJ6bup|rd@Wz9iu}W
zN=w&>;<DJT_Qr8`E08wcsZ|bvZKlIQ4Bc>=R~HVk<T*Or`miCyiArX62TRt&y?HXc
zwepFaFrlt3%~WbN%ZD${cwXk}G>Q?Fs}%1~OUF_9s>&SmitU`{ys6>&)%IeK;{01~
zn%(hQ`$hjWY%kE-I#lpq;2)5tF8RCyk(R}?;E`8@)Vlo!Vcx?#o)HQ?KIW5GWBeUo
zBqjlEx#_}*?x40PZr(kg-cMZWA?jhFJ}sM~@FkAo!@EsccYWr`qL&{#W^;xIvzYFv
z=N3n<c24q$JM=PdGzDI0j~V{jEnhg&PlxNcWri2(Hy=O4Qaa-GStL1BAS}zBBqLfr
z%xfu&34tF5KR{TYsi>H;eAe}mrkb~L&t<}OZ2my&A71`&W7Z4dNc(Fx)jpFAsyo*1
z{FEXQKR;VM+?Sa&)xychhJN_X@g;Rz_It%w)qVvBR~15@-FKTTtdaZ-^10Rca8!OW
zl#o^>;)-uZDQ%{V!@TN9P?w*19$RpKiy?=BY$1=MH&d~YoP6(tF6TZOM3*bIG5h^d
z+m5G+O2z)o*r!iclahNm=;(pMkD3eiUjlQ&hD7o9A|6=xzi;$-xhoLk@r}G;z)Z7G
z(9otogU#CtHaYvCK6&;qAp3J5W#HlEf)vTOvbDPRkjkD>?23~7kLt6(^0ZAx?Aw0s
ze-S)S$C6i!p2?ig*!<KM9$awNiX7kdw~y2auK4*<BbKf%w%_0l`F3HCtF)aU=VNV#
zM<odvyQ_(b-+!Y<NsF1=kG+;inmbrfg?e8%G$KH66mkglKavw6cHc5?;Urq#{%`P9
znd2;KVwY|M5pr63udaCL4|S2^cuQ^nHUNTg!vw-=J62hoc?i|!SGQQ<6ps)VL7Nvr
z78Z$PI}}mcpnZ0b`EGVQVZMRx{;SLXnb?CgVEJ1jD}wMY{42xXv!J(pc1vIB_7HrW
zdD3rr-kxIk>-u&FqLxSBGW7RSuqhK07}Z(fS*@Mi>24L!YH0rK5W8?&?h?pq&3l~p
z{WqD+*;Q#?fVvh3i}K+6Z3!Uf?PiOY=E49q%<U(+Kb!Y}Pr&Ad%TVO`@w|KG(0C2h
z0_ULwEOX+M)!zPkc4M*&RBKc+NBvxahA;wECsEW(SGX+!=mB|q2XZn~*;!ehj4HRS
zjx*L{_1+6Tr)Kx9F|e*%X|=0}*ymRCV>;k82lt~rW`cd#`-B@9*xIUJoKA?}w!gY~
z9TXI#j@Y~ag33|3>!Md(&ps(^UXW)tGfGdf!E+BEBYZ&eBCmN{qfszvaNy>t^!HKj
znh(2KE_60=+pd5c3217u9vIc^2$XuzOXCJ!tl?AX+;uQSb+cDR$V|DEIq2d}e1kmu
zODi{D<Pva4rsOK{<<0eZ%X&aIY|gMWXw#x2;2ba)8XbRHPmlow?H_Nb%Xxuo^MW$!
z3pi0i5)uGSti1B-{+m8pk;WHDxV646BR;g~LHr35y37|xKIR4xN<KWCyW#VTw25d`
z`4><_g~L`M4HS#L5kx*oYVe&lcd1-vIyy@*BwJ7ktUhY1CR(7pj|55=0pcP9uGZ?9
z;ZeKafUpdh+8j2HbcHoFQ>TBxSY>P{C8<riZO<PGEZqSCwNTV$@t-7>h=!-u?P01q
z2{Ey88s;7rgf{)8FJWpT{rvfxLbCtpZBV0~ot+$S|KtYBcG*v4f#BT7hygk;fXlTV
zee1dn0fOmeoA?J5Q2-*8KA)!rLJGjO>H(M>U_FB?d1ot7cJp&W!m4*Mu2v`_GB-hl
zFx!&ju}b_-|D;qX`ESz>+$YUwz4mB{C$lY9KVXX)VRR<_`&!ociXrBQ_gvTP&q)2A
z#W2r1qJkR&GTqTM3YROs#Q+!6dq+ZvJbm4*{kkCLukRn_4tG%@+*N0?uL{<6982T)
zR%=?g=D$3(mn)jO7e5xa;Ow6~;LcgzzJs&o`JAIcsnH{UlK=Q~guuxxuEV*Q)rEKS
z<Y7}c+`IG+KMk7nIUn6M&Xfn^kVkP!^|tx}B^KzsfEz~LlcybTyu`%B{sKQOMwx(c
z!ODTutIjSky8maf53aq8=a>CZ+%QVYWC%<6<+j|_wt2hn&0%_%8MsOGbz}f(@)tlR
zcRX9;Wv}-^r0h@Wr!$4A3%RloNH9bV`N%-&pRW**qESYLryS0gC%<*wd<p30GS~Y>
z=>4`yAU@w{^U>g~vKua&>in`L9o8!fJ(t()%~J=Xb=k0U>8GIFZZ+GCfAyzmC*9)Z
zp1GgbWRuo&5C!n{W7E;X=7($i+iNnTn*Vagc2txjU;PNX7r4W1(F)>C<H<<K6Zcwy
z+MX>c{Crk}|3DgZuEUCg{pW0AAzvZ;lmx4s#v{tWt#RW44wr)Z6X-&YY-ydIQdP~J
zF0$1Rq~!z-rm0y{Rqiux@Vd$D2P~M?gnV^Kv}&-CpJN-89O+84D)Nrgy20Q;<2e%(
zT&dsm#KD%PY+6NW8w)bsBJb#I5v^?qRmxShnD3blC!rp65*65R#dlQ{rdA<(`DS`9
zttEf=;lj6(i4TNL@VsTkUerS)*V*daIKzj`x&W**{a}86E=Yk(fJQf&lF74KD8ZJS
z;S5o=S@;HyI^`}Q7#dv9a&6*5ktdn&pEQ=^bKfOv%p>ZnpMGbA%k{2Eo_8|>)E|fi
zqg&+L_uSiS3QpV*nz~4#rYCLQMfj#Q=(03-fr@8Mi@ehde-!3N8mWVRioMR*qvM|O
zk;57mhy{=;-;-udb)Nz1$NNS1mwdi;T;#oGzWxJv!Qvt!XZ@5qFSoNdFSEP;9)a!4
zEr1(C+;<7Y<w;W)w>O)w#M6&{A3lEN7Z?Z)h9NRlGa?Ik6CP;L#K+fMu1vk`^xPQ*
z%kklyjvu4Mvn>$#;K`nR)%CaLw#jj(7tqxMPIo7EPzRYHGWb)3#qny>i{n*Msn|DV
zUbNGsM{1V+0TeQ=6c5XaqmH9xeDC~Yp|@<lY_~JXIR#?JZ-A`=j4G#OfAdaWf!^*&
zLK`rVO6N+PsG}poQ#om3G}3q;*-}zcmK#*)a{l|K&%OnGdn5kw|0x0DSvt<x;b@?{
zh#ZL^IO>4)3TWEX%?Upcx?diyS9;$e81RhoSVZ=^%3oE(u@hAC8H5yIz0*5-Sx$oz
z;#&FyVaCN;j|NldGd#=Vpm=xL8>d=ClKm5`V7O-?RjkDJ8N>cK1JRm^{KVuZ0S)=V
zR?jATBNg;5@yNXMwSe3yR-h`HpjRL&(2^XHuc^1)p`3-iw=P1=t_k9<AdDo*uWPwk
zoDt|jY;?ZF-N;{SH5_5~mV+5qbi+uI<B(W+r&kH`&w3ben<;&jY)8NF7&D8uCpqP3
z6yO7_gpyG>7GG7|GOJfWRcWO4O>Ftr9vq5wXOcu%3KxRD568~mefE65DUjF;4_9gn
zOF^I)pNKw2);Kt}$Vtrgc){=SkLu?TE~Qvb)hf0^RvcwRli*@qI^``(EEoW3-nesG
zI{K1qf%Yj9s0Zcy1>PIMghYsWp?bRkw&7G<wZ)}l?#1$nBmO^L!l49KNF%_Yil)bd
zqk^B_g%kn+sWMSGxOX=|hGtx#cctkCA&hg-#8|M(Jw=Q~H^wO@p};Cbcck(W(?v>=
zRpVAjHIC6~ux*Z_Wi5Rn438eqlU&VG6j$Nb09x2+hdWxtO|Z{Z(CtnSNuMPgj=M{-
z@T}E8lpyJIT17>Law-Z4gc4QmExeE{abkfd3K4JbW<UMd^kNCDRH9nj|AYzKa(}lC
z-#vaS<zp(&i!p2SUI7c=)zs~uhAG*#@BV**tnTg9#ba$3uHU?>$h<wE?_F#6Jw6NC
zY#xgWw=-D;ptbC!<!K1^+c&YqYt3F8K1*O+F@O32U~X!yHvoiVM*(7Xa?3uQo(8V3
z6-nfIMT}){-fB2R9dTTF)b`CT-F$Ir=>i16oB8jg9#xzB0VX1<yuY<f-%J&WF4pSI
zvY|%!+?+3U{91jgtgI}QsmWUhBNrTOD35*Q&Xo&=yZSy>R&_w}yj2l4p)^n!G=G;e
z5$Q;*&Q5U^IEgKwB`j}3=`s1+Gia227-%Rvxv%SojThe3xf4WDq@|AS`L~f7;MhPC
z5?$_7jtF2fM{LK<NJ+S}jBug0C9ItNzQ;#L`ZV#HSW`m6CIp_J9>C{BPFtnNzQ|uC
za^_R?)>ByBsFn)D->R^Y``F`J5%wItuNyQ5O5O8w#8h`#HniHxewNBRNf9Rs2~VFA
z=4SG+-x-ykQx|FA#uBhyaa|nUnHDITtYoQ_kG}&IAZAM+v$4}#lf+Gs9vim}O~nKF
zdT1c&gu#3hZfl7zKbhs@!TKN*iyd8K;j>_yv}82`hio%houHtFh!?rta7dyR-IZC~
z1FytNKY8W2M0E_dQwc)8)eOljA5>yZH^D`O6)c!GVIP#KNbVM-HcPo8izG&c+ul{?
zOLs8hl4@5FN+kZu1u33&iXF!`jo>V*N31XN(1O}UhcLRN9-^j}cc|D8kx{iZF_IOx
zd3it(%Z&}xn)%G~{hCrXUpy1DaUpOkx<^or&=@nm*XwAB88)@4Vf(~S<0kJEei{g6
zPVJe%8B7SxgrBu4WkEAzS5jw{*$|;`#AQ78o|QaOMUQ*wFyO&ND>02EE9uAE|H&q5
z<G1A;b$qYp4E|!0=5!zuJwY{W-#FV`sL#?P@SNi@0XT6=zHZ2BO-;<4Rcx~6gHs^d
zovMdEHh~Zet}Su&D6_-w@FXZ${bbi@ZyVfKw@gF~sbc0r0&xiryzjP8hkN0ssB3F$
z&SO61c%fMykuIRlHAm?9sR&=)cKv<n?Tu7#b>Hxrl0J=XrtoTA|J3&y)B{d;2drmK
zKX`K)MnM(kua^YI0g>=N#ht<R{2(R;WKckEEkz_N8j`r;djKA-C!kPUBVF$V`Z*wF
z-2_QsiHS4+978U^sJH9(;+3?Z;1y7sgIy%}H0w11-qn+4ZK=DCc|Ln4(LR6WczMJR
zmF@+6{T+>tbL#@--*xw*&&JTbSKw9zh9vZN?_T@8x_k|E+}RV_+S=4H1A(&N{r|JD
z*yMN{2#Vh4pz?05&K}z#j0jCh672LjQW4(_JdL7MEGjB$IynQJN;z3sBSwa_Wc?WO
zat{~A5J%5?0ZF0psxxmH3ZysF(jn2$if-$25h0;NRy#(HwGX87X8`(>Dp|MgpJTnh
zDT)x}q&6VEQ|At~1hOaF=gZGRY>{5W2!(P9y22d}4i1f?q7C|RlO>HuY`8GJYXCi!
zH4@GEeosKO<f!ZL5DN*2OcBQuGyEq)$YN7(CNQ@1l9(B^-XrCS<TOsCWjU}c?9R9H
z1|p|u;^~V&b#;0`KKm9XHQ?>*iLg91g^{acX7`5)bfk(4nItYTKf}!@#p}4CoT%+>
z%3u4cBFyqQ4`x))e#=f4L&ybyeT#~U3fz73&@LfYQ-_b#-`=W1KuoBY=izE1k<bAZ
z@7g3T&$=ELkb8ZLiz_S>j-t2mEjQ+jY?71|J%}e3PGhcoW|P}Z0VzCcV`F23^CCt`
z<GxjJX_AOB*}$+A0ZrAWh;7}IvtBS?s5%VojAuj6Vt^133WGA0^Gx-Bfy4U;f5T=x
zHfCnX-B+l729EQ`ouZubJ!(ZF>I6hZWhq)sv_fQ;wAd=>#aMx6`?t-u%}Xnu!w_tQ
zg@p4Ra+i7<x<d126=mf@KAc34E{VbDh#q#CU`Vv1C%Ar6y%Pq0RNWAn;JokgadFCW
ztjLp%@RcszH4UHK2M}9hP8v{lDvcJQe`k#HMxi9{HA<GD0l_Mojcr|1xd=ioob11;
z6R!27s0fQAJa4;=PlS>L3q3eEv^=cp>+Jk!Zlyi1SsjCVOeKHvwb;l+xJBUX+hl(~
zQnF%paW^5;tSp6KwmNU`4fu3YZM$`Tt+Mj+2v*VBn267+w9uF`vxiP=L66#b)yseW
z6nq*e^7$_IqyH&pMI6N5JvM2!iI0sF5U%JJa-#h*KOYM4_4)bv{(S<SWgtGG?DhBk
zkD4TO#){*-NgeUek0%Xf#5R#}6cD!!XuV55bc%B#5_`>VOP68jl%!|__T-sNRg8h*
z9p^LyUFsSO1>{uvKOJ4eX5g<8j<+m@7Pr?+K-(&)<poMNU@$QP+P_XfKmt95#m%YQ
z?RWKsK*S5XRUZ$wW@&R*w-X-^OI4Yv_7HTrf%+=}EwAq%Wq@PR%U>%Fpb7i+^`kjg
zYUj-{pl<$p__XtC(I#F-N<xAYM=tPk`p1udR;Ifaw@0sJBqT0ZU1|g)Bb@-nW2}Ch
zKk!rHtG|1%+_yXpNg5p!iR*jpav=8oj-qZeNpTjIylCa<6cm@U7#7N4A)`mzF;%x_
zUogCC`y>U$lQs7tZePif_7e;dU9WXXm0uE!no-zL)q7s{<hVQ<j%NcyEP8ULz%c{`
z420qO)KmzA8SIW#Tss64;X=cHIU$k!*_BQ?DU_K_MN04YWnCspK3cvhW*bG-JQDq=
z4P!Go8%8aSaAXQjEaD7Fai&x(gX4WMPz=k*c=il?L@fv$r_q+VbIMcE=x8rk);e;%
ztMYwQ{iGy}^GOBI0yXX`(vh3y_`IpRqWRIGUaFWpcdF9Da0j2le@`rGs91|49qLF^
z9L5~w_M@TsTy-&YgV>3wVz5N(f~1Hne3)_Z%VzU5Z~j`tK|)OxwP;mD2Os)=%`|(F
zymyFU>KT5ONIXiN+^j;Wp*@DRviP%Atj8ps&FaBh!7n*0zW)D=sy2hBfFJ_seEfm^
zfMlH4kF7_Ok`Ul9V#_5e1%8C;U)}@(eV}oj^#G6)0i6pu7WrY!9ic(z*7XEIqyg&V
z^X)g)M}I+4Wm9gDmy>0S1`5I_O^4NBHc3WC7XRiAfIFyy$*(?r%Fxr$ohKeEYc}do
z;q=~JTTwi15-+R5NbCV0`j_8Y_tN++zO_z<gyE;6YC5kEmzS4;&IaHk|5k61&Ny`n
zDxrS{W`H9Q2yRWF78KDsee;H)w4~(UC<mwxpQIhMx!>#?T$Y<RS7h=vFUvk)Yi7;0
zZ$VQHE+XhX+8R1=mC5)Af6=cwmoIUuHyoQTY`kgq3w3Mgf8^5@28RW&ehKO0GtLhy
z&b=<55&OAT5_rtT=B&~e9I(Vfc*m5ZW`NIYtZ71MRlxLk#XcbR$$u0<?`nd+p<-8g
zjF_fOKhidJ5x7z2IYWW+|0raTkKi3*`sBi-tkQQ0>E7srQm7ntoxf_&rPwdg`+9%n
zS%SU?2%^(2F3PoU&X&!7HF(#}G@(kEOYdx^w^@_I<IPOZNy)pE+GRaw*XZ?Uj_m|K
z{v$;&$P-4gc{=`z?q-L|Xs!<i$34S%R&K!g0y9Q@c#jIPbne}o;rG$s;b0cC`S(|g
z1}4eQWJ>1Z6wJi#M*9Dl?m4P{a<N<l@|tM7o}Vu)bzTne|2=s7_h5hDvCep!21>r@
ze1{_OC_tSYo&=xriK2otgAT8R;pw&b?d~R^$Q)wQ|Kmv=1w@X2<`s%S{c-{d>{IEM
z-IQgbaalW}^Unvlu|(s!=c<4cp{W^5M)r0AKN9i-2uVFAwdSN>{<%zKQz7oNjJ?AO
zuC4Z4*@0F8;=YR;pxHe%{wVX}7hTWH>~WR%;RC}xZwbDfYg_M+jhb$ffi&H<rA_LZ
zelKTzCh=k>uZU3Dk>zXn`coDWQmryVPiI{J^Gy3Lp~ASvi_6EjlC}3O&o3)t@-5$-
z<N@ya*Fqv2;9tKmiD=?8ae=MUha1y+h#wEB785IeU9Q_+t}6m~U|Ui@u!iiq==dHN
z8=FxgDJps%cJEK0T{<ryn|)nr03H*OR-8&tfN;Nm8aP$~d<~ckFv-1iefI1J&{;wf
zG)uf^*MMUw2L^>mRArQV`RB#v?{6y&4wO;-`}_MKf|#tY&jB9~PdiWIr`+w{Er0qL
z_Vho?ou(R@)AUzY>9^aj{=|d(osk@D)L@Ux65_OMF%x@R>eYaVoavQoZYfmA@ye~x
z&^Io1ooNRB7C^;e3I;K#q-N&x^EA6$IYbaYy%`S9cORb#FV;_jd{UO<k7&a`41IqV
zckO*=$vej5C;9{fCFdKQ|2!QfC?+T<D<xG(G{<ILXPlKIU3U8=hq4?DZn%`BOg@md
z7^*W#dFyf%iW1vAe|`y6!mF-yOia|hkbGdaAQYJsgDS6#Po)DkNQ|<9stBK*(bU_|
zYny)oR`Bxj2kYSSyg`T{RcQR1RABy9N_D3vY!Yv3WaJ~yTctgR#|(~7ehYv7y_i0b
zL2LH8p`I@db8FaziY{EdL+tpNoIJGR6~&Az9G2jnk%DR}zJpACYR~a`q1Q-cuNvp{
zVKeOmKbxA(!_WrPJzHI$d=`Z0abe*?uWM9M7<0L-xt{!|1hkge0hUt3H|Geb0j*>W
z6{k;U4s7WCCG7hhGYJ?g_Ok4qXjw!>RT-U4&SUM63I`P<r3dr8@tSiLRawrjRoi~9
zMkRNK34U3hKR#e%$IKt-mje3Q^#H%D-9u6bP4%nOx3__=uHzyu)EWUOea~NW4rCl#
zyIklAj+RrIO>ruUa2Ac4zjuSQ>E6Ae+r!bkpJA7XTDT^ZFMgkD87ay@Z)p!zUD#_^
zM2*)bobv4?5@cGIU?{z{UX4VEP&T~Ni|M9=hdHY|7z7WurL{{^E)i*v^&f2zsgq@>
zxtFM3`DEHZ5T4jKWVAmCCPh_6ELiixylJdi#_?qG4QUA9J=uUlhC$k5puM0aln*vN
z&_+bH%~*?Cnhc}mKxzm%;p}$wv%eizj$xS=c&DMhI1Lpw7bwEbUF|>pKx+}`(HBV)
z$x0Psv)1|jaXiioi862I#_4GT%Qw;86MrQir=s_N%fg+XT5VqVe099RRYy#nI=ACR
zT5&yiLSt~yq&X<WTr?Vwp?rZ(Ir*BUrGy->9p$+2L+}p|dyOi-NOhPZFyOF`+@T$W
znVh{rC=7O#e;T>D$JJuCWN4mjqkg6BHxdn_N0hJEpL}&XO{Mb0QvYu`=3UI3RWhId
z&4L%L$9+^p*ptjm_=BV98klhM<o-`|1c^fh^nm+dfj$JOo|v>zN~74Qb1!GTrPai4
zrSuneeRZ#euD|c6EhBq7dtG@%-uShC-|!{wr>?L%QM#fRm{8sGo=gOzs#mJcmVyGu
znnLdVzOSJP<YVQAk#FenPNe}#i$vNg>)tHpzi6+fBR?oz5tkh+*)=ny06MChn;Z3V
zK<WSek}n;Q+CaTraTvY*dsgHPkk4xYj~v1XZ>dvY8|t=l@~K?Ew0DT8J>Y^)&{U9{
zCFxB2&q-HgagNeXdoWK{G6%vwWAaDh&F!fL-p8_ap%|kWla`8%Ova5rfA)7RaC}n(
z@%{U+ZIEpQYf-efA52MH19)R|eh+xqRucJmyX%YeqsiZt)9Gvf{6Y5j-lJsxq_e_Q
z-%5f6YkOzsTl}{-8}|~=vMIkkbck1`S$0m>zTJJQ-8C6Xk*6r$%uVk3Nh?S8583St
zI$Yy<q0QV5)$u^VNm|PR{MQ`6y_?iJcom9C6e4mIb?X*2@R`_CGm{e!E<Xpv#GP#&
zz-gEy(7sFpbG@-SY%T(a7fq9v?RPIa=xQr0%B(WPHv&(?$fPfUYeC1^Y>fEF=W}3x
zA(98~l|Z`*fvA@Q3sYcuS&DL+^0Ih&MZMOX&SP$El6KUV<JIq<dH)C0<pMRdK9j22
ziutiu|E*19^n!gdTx6upl}1kzqZ?oL?awq!?Hbc}Z>kpWUGbwYoUue8uOZK0_C>sp
zp)Y(9$7>(}If{rNqxPL)@$6$_@|<KO{Yph?zl0w@%KMr!IG3Mle=CtzKIXK)kyd$#
z-<k=D<Ro^u+#gB5#YZgMZ`hB^lXo{8_2=tnME}RZxG?a4M7?!fRNEIfJe0HyAt7BV
z-6>sC(jY0_A|Q>V5<>`5(xrriC|ycOONmH}DB+MQE&VL+?|q-g&;7#-IGovY&faUS
zZ<SeS6V<-{rsegSdwB7r;mZ2A<<B>Fq(~4&sbD<&rR-~4@Cho_IqPsC^a5Jeov}M$
zq5Q_3&!lGW-!{M>wC?Xa`Qu?q+kU*0-X1i_0|pzvvenBUHAC$q#s@txn9O2`GW%Fp
zj~>{!#;Q1_P=@esh$BaoE6}*F6?4am&8SEi9I}XU_`jxR-L36cB)mFm^HQPfBR`q<
z#Ab7b@Ke7-$r;k3qgBJOM{6%vKYp{TF1;`2U-h+nv&EE{`8T~7xnQ_a217<q_*~BG
z%I1QOAbf*o{BIoGT*hwY_3>RhTWk(2jBApK`rcWs%_x38c%i*}hSxuYO|Ya_bz6Wc
zse7LO%;zOW%WF2${XL?`%jc4JPPlXT+NToP(lkpbdCl<<@zqI5NdOfbCEZ~VxyzcV
zd4p^c>})R^+i53DOQ6X{P*YQj2kaCri9_Ldzux5<`s3jlRDYIU!y<p)?<S<y<i2u$
zduyUo5QXsIrOO+|&HYk6{LK)*C2wkB-O64zuA9V*CBchz$!lUF&Nk1r?#edZpv|bE
z^uD-OY@qjDJNyh{6AvxZT(0mB@Af*(@t00TZae<6@Kb8{;M}hNHt_pA^Xt0s)0P6)
z=sAY@J!%?sjHc>iX}`?2j?abi(_M)7T371HxvIL7gS`_*I$Rrgy{UL42>0~#Szi9B
zFz5B#9d1N&4AwM2vAVZ59>rYuhZk<^h#ztt)Z-l1G`97^LMY(dq=IwrLeus$uzqk5
z%ry0-v6$vx$XDaf962D>mBaUpcwlKn#M{xrgbNeE*3`j!_Z!EqC44E{`|$&lq`#&T
z;iKFg39H2<hC$s^flG5#)qf~dg*EEY`y&Z#X#sSzTEox@VdGJL$dWP=Q8sDLn@&yL
z?Udw<Cl@v({LCR(Q^_0!eg!MWW2afqlN_^~&36UfmdLSK^H7_22qtk9&}mGu5*Nzl
zi!>o#_5JEul|~MD4YirS`_0-9%3pDm1Lv$2GpiVUj8A>zPy%_Q=-^wg-Z`vd++1_~
zQmRPZ#5b32_Ac!BM1qPq3zHPpUpLg*DgWYAc(N{zXxf0NEG22!t(4)#A567hNO34t
z)hz0-(T1@6hzCY6;{ytZA_uiVmZ?P4us1u)V9k{)RQz0vRsvOIQn^|nBDS9#bf}RM
zBw0-*vCCA^w{gKn@cM^_w$~XSN?6(K>5=e18Z5Ib513^^L}hFYvR?tuo}$mH*A<}Q
zfBF=QIHWeBU)ry`rUZ38JrO%>dSPMIkYg;}?Y`aG=T~-|65>r^>@{*pdx&H-8(9oZ
znp8Q(e_nzn3`$+GTH)A^+^Vg~)>&9sPbcu6Bov2vrcuD=wVB|3gZOetr*(r&K2GdM
z{QlwL$v4FtFW*F{6<UiJQoMa5K=$<MQ}LU+Z_!EKYV4&qZkqkF*%Xiz#=9-i>6#jO
zfBO0K@(l{(;BberqZxC$GLf8g+hT^%q?YbeI63kj|3+WKN1NjnK9d{WMM2Lm<NZ2E
z^TvZY6}voi`X$h+efKU+$y!T-UNQ<igN&-)Kboqt&{OYLZ+bs+$CQ&&Lm$V87t3b+
zJ0qrUvw0q;rl-D^E3VS7S>GGNEFV2{KYmS(e!eS(un2HIE=H;zg;eVpJj6GSC~`x+
z4w~YRRaa*!&%fgR#C+7Jq@)BpgN=2F3w3Kg+2etQu=}sCPn19<m_~>re2QoGJ`D*z
z{Zba|#YO^&sOPF`?Z(`kt%#gEufiN}YOw1OIJ~H1(UV(l{%&BcZlwgia$5?Ye7cs4
z%z3E@aUA}6atwNrDD7<8HB<EZH@InEBls3?v_?vrW~Sb%#nhUd++#DqMUnZpB-_4!
zv&QYVHLbOM>riP4lWyu4ce{JVi2lP<g~E<&rMGr@1#fJz)NZX|CXVaLA?)T>;OoJt
z&kxu&@Ba#7td=LhLr|0fB2G!5nL&ydr`qP4rL0GWQYBsV)^f+*k$S6>vB*HGTqIX!
zB{7`o&UG`V!HtRl$3ex_h(z<gx?Jw2^$na<Slt?91TU}sXw|L?alxZO{3-lpdr%#w
z55gP(^Hz`Mn#O`ljy2b~QK8NQq9P@`yrsu7R<HWPz87#%##QQs)evLz3z?8$Fu~j{
z@*_n$wHk@j-HdH13xx)O+p@Z4<~6V|{<<7tB?juE!|x)BiqKG9ye=#<wK8e`_Su0r
z!DyCJc{~F3iOW%n<Y|xyg>JR+9-*lfGbRoy<8M*w72zQq0+jg_NMI{N<oyL+>J_*%
zjFG30<%w%H@K$_2t|7GbK-YNYC?Dq}*tHoMDxlFTIoTy5A|hZplLX=z$FY~nW!}fj
z11Z{4+e+2O-<oav(%Vm0U}SsRvQc&7vFm_PbrgL2{&WZI&QAJSEiXs3#I}+gvZN9T
zW(|Y*qr|tr?U|2OyQ#eYZHLHoZLJdeaFbu3<|NO3t|7W8%yS%5&j%+LMT7sNWNZ2p
zhpn-(G9FLA*MN_%@sK*E?YMJi+A?KIgm3c$YEk9e9&*m<!DShln0CZwOG=;irREwk
zpY*HUpt(u$P2DN$u6~CmLX58OMFM>q<|iJnQCpQKnH)MYLj{O?9W5^rDZVp@XU`+0
zTM}I7R{AMW0ymGZq`3-B5$mhumEwrn92?nvs%B?y<POWk<kF;gu_2jY;Sg0WqJbLX
z-M~Z3HC4IJiAr95R4d=4%Hcp0@%}+Nj<%e)@7<#iFJE=G9-^+@Vz+b&)armk@t#Gp
zj9Pn}3Lbw|(1Iu3R6}(FX6{~EP`WwQFm`S7{#&)8CT9-22DdxEIhVdP1TPR~Z*p-~
zXgT|7Vz3uK80misRmIYDo9!Jb50rpoU`I8WvT3R+BC0mL3+rMiSg#D(8P(`5RYUX%
zw#Rq_ts|JLP9^<h*%ZI}V$cEg2@|n!=r;GuNkxiLab@<)ZWzV$@&(^3#j0vBVeE5=
zZ7DzyROs3#EgC(^ct=nB>KCPr`Rqz+>X15y>!+>gZ|QdFgHq)kE(HH%tio=-)l&a6
zBf8_%aD`OhsZPeXoM!K`N`cP}gYmq-g9-vmZSE^tKBiSfS@irJbq<fNVhj#>xi8^T
zaA=q4U#s;u0tp^B<O;CCf+6(xz>PO?V5Qz<-34RNzklDMkAU#|y>6|M>)!q5rE%@U
zOSxEYY5v3f3~JDX6HisOie_pySLu(g)+a|528E?*xDZe!RR?zAKYeK3-{cXMsI?iW
z(d@Io=<VB7of0qb`9ji&3-wwYi=7a+QPMH-`Cdu3VeHM?-~FBr855E{^od-8$S7GK
zUz<bs0WXYfg79PBr5t7zNsqB&oK5|co4z;F&_e}b{O{q_JU_msu<F2RKKR;pXk45u
z|4f5I+ip_`H-L)5D*k!of_(pTX4`%|oAfcSH&M?qY<W}&E68YlYH6B0?r3A<SN_#V
z!RweNVgP?=TONnIQT^0dFBg*%KYZjr^1;-IHE}-q8p5j?B{w#GEyn9Fz2B)p7e4dz
zMc?Z|=>ocMYb42x5!hq{IZ4{(j~+>WKw?}k$dT`Dri{P?M}VAHJEaF7M&ImdhO;}|
z*d#w`MiM14C4W-rF@1B7lMb1NsnpLu)DfnhLPXPhqJWNJz+1woyn0VqIt)cXZL_vo
z`iUp$&qz*#rsF@n3bxGrF>*ViE}9I1sQ7yRm&oUZzd4nQ5RbTeQm)8RCfy52dydaC
z5ZTG!(!ptk(#Msl8)e8Ut3lDkeEIya*I49>_{T4i5zK=rDXj}x)zq(V3IC>2@pflj
z$C#{(lzxg!tw`yahJ#X#Wv09uvaFR;NTWg3Lr#MplJD*5X`>d$HF+LLt4KYdDCiPo
zG4;X4lXdv+$(sdI$28hk)%2Uncl&QiGm$CKNqVDDWHAv-;_Wb%j*-KAXfg>iO9WGr
zYS8f-kQrsi?!@JxKU{o&Z2niF@ZH)oF`_O!J;twEnAb^0%f_}|mB}k}Tj$R2oz-Ty
zQHe{YN&j;)^NY~@*HdjPdlq`7Q7!hS;Mmo^x<4=YOAmr|{%v-BCVY8A=>{eudFQKZ
zD0#;<><(%*zO0g}gKipW-+$2;5}O2+xtLqWVaW6i8Fx82C;abN)VOj`&!2u<{e>=^
zu}>CAmU(1bqBeftDqO%`n?CgXg8o2oNHaP1zObILe!knxVfq4*jZvy^IE_)A1J~Zi
zB$7~*>$4hP-sro)wXNW{3*+>2v}A{gi3Bc3U$C=zvKPL49p{vDRh;QMi4G6GveR#)
z;m6fPd5nPth7HK_PnLEJat3)`i;)-PA9;r5a+TaD<Y`}QJ$Z|w@UZos8(h&paWsC2
z2n>f_5QoyjiZl%!Q7KTs8z7$=W2WYCBkqoj^k2VF3V&A8LjG6l;SF7LcX|C-5C(02
zr|65fKWr3>T2@`+8<5YQh?;qas7}Yk*?Kiu{djA!TFr2uvOY3!E#q!mrh}xPp-Lea
zf3J`F6{R}viV_{o@yZK?p>*YVtl&u2s|Yk1He$K8@Tj%=B-x1V!{4O!mUd35-&Gq9
zF?Oi@c&Uq9$R*59x);xgmMY|Yx11gWep9rt)F{t3de9pe-eNCWf2&U>Bw(-0Qn-y9
z;{1|L>?#LyHr79q8nb-CFmO4hH6T#!?fp?4PPr+0JE6E_tMU_mXnK5Pf5}1H?dsiU
z1x14WmEMiNhp9eaw>=MFx^Fv#&%&OTnO}FS*2U;f(}WBb_5<3rZyB|778xr)t=%{1
zgxO{@`AmvSw0-hv`>QUb#7H}=2bvr-ICFsi+#7btki_(53Y~?yTV`yN6TRg56RgN<
z-d*>e7voAcQC-2Dix2wyU7uitHY0PHgZ$kHZX$&c@r!;$uWP3Uwio|rR6oumdfqr6
zOPlmLu`G)>!rFFE6X&7tE1Q!bdrRmjlRGM+!fiTcgU6xM=HffG`QoHDo~_axd{^FV
zhNA-%@J1wtgejy)_0=a5-th+A$iA08#(SqR;T-*h(_1SqFu_#(ZIeK+a$K`{hJFO0
z=Y0l>S-C$nd8tn{#C0e!H2Qr1+L=nOv=s0uJe+nUN!b%<z_<18x+nMPkkGbYJgJ=U
zJiUnG=poNh02SF|`DVUe*LV$jYl_WoCZhV(OVv{D&tZNdW(V>l)v?=*&rQ8LpWq}c
zfzaS!e+9_oz0efp$^>V5{R&_}=Lq~dIR_|X=j;sPQFJG+wZ<ulqj~O(==Zs_BK8^A
z@5-DxZfPtWnxR8b!3dz^hIzDY=J#axpeeoNgSyAxUd*peUGQ#By$)Xxut9P-uzl+D
z4L%SH)%iJh+(F-ay68_;-7R2a{+f(*uXy!91%a6I0m0(VAaAQVhtKBp7|hiLdlBB@
zJ2Z|_$4u1@%&S?yCPveM+9`sim~QiR>z2sY_cvZs6ZIA*SNVIrhhIA82m6A%$)(!y
za&A5(G<v#vM;1~$Zsq<STzLefri7(i#h2n@$kBM%S2{=Er%WWZtklan`*KQ|Ss?bp
z&2MY8*<M+xYGabD7pWV}9vBQCUAzEG4|OB=#-y41e0%7{zkf|gmWZNlY(~~g?K#r{
z;j^*Fc{ZAo>=(<9cV!VsCUk#yv1&TCK=~@1wOLae>Sd#$=Rczv0^b44S(91zd^?eZ
zQHDDL%pxHkglMq5$-bqkV)#m*CsEfs?m-`mDWALJ!grtIrRp`f(MJ7jVIXBs!Dr!2
zQzsfzXRGUs>X#bzvcN@f4^k-Hv`|8Drn`-L@eF>!O#>@QDgPf}Pda+}6Mj}!KV}@;
z_Zve`a$z|gYJ&l=_y)lx8dLj78kQ#DnKIZqnHY(z;HRnEbFkZftI>2z*K$puu?rvJ
z&ip;X+}dR>{n9~{kQvn1y{*4ncEL506n)x>%ec9*F$Y4ROOwO5cJUzO4z4hIBk8%g
z49547{Fgrtfe`sJ!Lx^FHyr0B)*o`ugW&$!NctIVEc=-aPTpt`)zU{Sj7L!pf_vzH
z(-OVK&mL;wk!EhpHqQH=kZVhwS6F^{XFnMI!u~QL#l}XVH2pnf1MD81#*p9i-I~P-
zQy-Y9n1V6}JQRU;nJX@^w^n)^xR13i6NccFc?yy|WcAy(?jV+fnx<{Nyh3yQ-`_5h
zNF)g`j+)JZC!0v$_cN!p%4^2{a@;YYROdSN8+dXVC1r`(58IAPKncYl<*%b&Msln<
zZr=EC9td=gnoq&)HDlNTf?R$Av=Xv6)&N{3Zt$sFN^BJ91?(2QQlb6R=beK!%FoHM
z0;up0@M?jn(bso*?Izrm6>SM$pKvER`FGxZP`{+lu>yjS^XAbvz{XQR!AJwF$bbH<
zO_V<P2h$p`!z)Q`S$SawuX^&$3vQ=flKDr2!{EGmSA9+V;7jqKQKfM;@K2w+#J-7n
zB3?_h7GHE9BMvvdF_VwYo8OrFF<#zHTO4}B%<h2KwBM=@IHR~w)E}5bG_GdgkaRx@
z!H5ry`x0twh`C#cizsw+a<(U>x*d6t^?NImEw71>$lFUvt0;p1A(+0w^#B5vP1NOW
z;RhFl${0PAJ=ql7JvxV6-vyu*LQAp@_%_$VA$;2l2(HA$^p5dwA+Kp-%6vTkk2YK7
z{>IeB-)PxWko&)Y=N^!9fIYa<GzMSrwjQrnl$H<x`5VSo@WEIdz&j4e^IHO1&)MEM
z*rTrG%!giJ$)2rg!&>%8T;whUtb<*F_@m|ia>EKr9@DzVhYvaIMYAv6pDz(7=*|xg
z56R1L2q{5+)m-JZRX_C|I5V(*!-pTTVf*t7J@f;APatjqre1QHuoJ296GDAv0jC8e
zP5}J!H^$YA&FGNtkD1qR@z>mD&PplP=8+~Lg<o=zDEs|j*ga%ico??PM<Z!^E05Ih
z<dsmHJA-@x%=hO>w?f1fusg58+Qb-e=4vejOj+Q{oDA)nj|*>LT}=b^y&lD+k1{CX
zi%Tp{NmV%vE12iJb>zx1QLiw0v6;XKNcmUctW)nq^vIc2Aw$AnGCOq<g3WL8Wt8<r
z_3Nnp4mvz;&KY$pH4b)k9Ij0ct29$rnkeaW7IrY_B4H{_<{`j0nxuZcXxkC6g7GFV
z?Fp#s3P)r;Wj;qjFz$eX<Oi$HC-4RYdn0}**-@*M8MJ_nEUf1q8khqx9c<pHx*d9P
zc;S9>@MmG?XLQ>iLgxFy`}Johhi5+-&ws*Wc-CWi+Oxd;HS}2f!Wr1i@a!6@<1=4n
zl-WxG><&gLX9tb#XSMlfyRL7~eyx>;9>Pa=3?WX>z+d@j8SE&|w;3-;NiTkood1CP
z;v3i%z)j#gD(%<)Z!zvIaQJpsxX%A2UIY)<R-5w@cFLaZ>5m+>|D(FtDV04N083uY
zao`tvnitzi=7uaM-GMRp-#E)tmi*C+(u=+J1?YKzk?~<E;daRB5@Y+`m%%tHzTX=g
z70ROPQ~67p$-=G|Ul=rUwdlRUsN5XppkLCf(BKyXDxIwwSL&$LorAeQR`K~#0blru
zic_soHr3D7i%}HlCvb3nztjtW^8(NTAlKq+1xc^JrDeYSL&=mIE)DqjNFW0J@)}Z~
zpoxeNFly$b4N{VOu6hGJ{4|ReBY)sv*lC(v@&RjAZlwG?lDZz_A9ol;&9lSJm5pyC
zhdtmenLjEdB!Zs2Z9615Z<j$!T{OOCF2hIeoMG4*MLo>jQH&pBSL4iMEP+xh9#0(|
z#wF<%zr!7d`XrPRqqJ*kdGF_-9Z(G&RcuBA5J>^QQKULpQFsX0Do3qin^42ad0dz~
z+~ajjR@+zNs~?DRl@ST7ywXTdg&EU`V@L?;hjavjhz9*}_q3dkS*;9qMj*g<KE)l)
zkw{Tz2O#nuXW9$Pw$rZRYzZ{z+Y}Z1h?&i&qyu)AAxyAl=0UT$Lp%nOMV*6$LF#pC
z@)tgelB*0-{Ssbu(I{12OBpdBufQE5M5@LC{paq#CGEZaeK-a*)tf<lY9|Ou3!);1
zuQR{S#tIR!rl~XA{1@vo(L%9$5+ajt+2kQFlOOsk)3L~4%^UXpD)_`3fs_C04nu%}
z*?Tw~zCJUoryDw3^NVK3#R|=OO1G+%vkSLAgQU0W1#HjzWlVzH>4R{nwE!#t<MU!5
zluG!~^&J)?RhrEeloryJ)WvM5Ri+8`S0CFJdpuC&nVD_md8|dT-BE{TR-+eI6$v%T
zQC<>qCpn4CGH%{aDVrDRq^f(I{%av-cAK{|{_IHueb%6E?#*AB8;-iTbjTZKZ?0X_
z-N2ZT=)i3KtZRvfa8-Xrzl59+FU=Oa+Af@>qeRytYT-73p7**_TcM14xvGlgC&L`M
zm!ZHgKj1ofU{o#iN$m8xTA_$u`I2M3d()I@F|MZG&F-&)I|+EE>8yksnqRdVehOo*
zR-#0GKN3l^JU~xH->2DE`+&xHtu_DkX!kb##`j0(%_vcKdGw^xXZu$4!m#KN6OoVk
zS9}GFDGo})W^*l$FD8<~mh11ifeEL8*P8(j9+jDn@dC^d8-b{P>Z$YSc<bOYOlE8&
z=7`Tep%~#|-ouy{(h6pYs16CV`6{b3G~iO7pP9G56xm=8j@t;7RPhAF1q?~HgD>DQ
zUK5!ze+-me>66Vy-_7Z5pu#Jt(<GahdMzOpG0`owkBB&A#c!IZkis62uFn2CYbFN-
z??rs+JZ1-%CNeWM#X7f&^vZlTs<Lykq=Nqah2kf8CGFlD$oX?}Qsqd~WCO-xBM>It
z3;FBq2aN`^d}$2TDQ{}@R0|k!v)F`9lTpO=K&ZyUfN|Pq{hxVS%g)!j407Zd=6JQ^
z6Dv{~^O5(Fa=muV&wU>ZV-4S;Ak-%(AMytO;$5q{=jL-8*#t*GA=G=-F#?`fD|%(-
zS5H0|bAN$U23zURUg0Yto>I<Ygq4#$#+;CEfsTYtTS%m%$V^?**Nct@6RBIMb4yFp
zV>~yST)~^(0`tup6{28ZKuth|G#@z<$)fX60^NeF^Ve4gyt9RzoLaw)D<_)w)w3vE
z+e&j@Mk)VQs9H^$JjTlOZ%Uxoyk~dcLtSR!J7ce2784U=SYZVB_1IVvfun(@po`ov
z^(0zVXC|<6+C6R9!meSfsj4-oCl;6^NEkoH(e-8KKyXQx;N4em`Jh56giNAwVHZPU
zZ`#?P<fQa{Jn4gyiLbQ+OnK9#N9h@4PC$=!gY1QKmIB_mu*DP%CjCNov!{Umwh+8t
zRthwu#!{_ZK_XUE{%uE3m(MSl8*K+2%ATS}V!lq~w{jMvzJh(5M)4PrKE?H4ItRlE
z^WpqB>ij&2cdF64D+>CBP2kae`uFc2pnM;x85tO4f{*tgmaG<>+n_vH3Aq1Z4TxGf
zLcJebMxG0d&^V5d6WGRYJ3BkqJlSu+;%C@MCB*C(_p~TW{wV(3tAuc<TfFaSq^9Rc
z7n-v~m+zeyb}zNN;g3`SJMKv=FXnggp5LGB96vew5l)R(C1hfGr^6su$+;Eq1H-OA
zAdX1Pl$kV+%lIINkUGlM3i~s6SiG+0(Jlk1@Um+mvkG)Z%`Ow=7h9nxT_m#KSg_kc
zonz_$a|*z=-;8G`vd5E+ZS_#*K#InX?wFMPkQPO}PMV5qwERShtyfuIT4zX-$H-XN
z#gmgd4hi#ExIZU+c)bJ(B#8&W7Sop5#>S+Mg7U)e12{K=kHz1gU9W6yFOxC7n%m$b
z=P~Ag{R~@ao{3<jueTSu4Hnaqur=Rd48}&x9?*j21r*8c2lb9SM<G)_Rlpqsl0p(*
zUdXW@?8ZWplD>0q8uKK)T6DOhGS;RuAK&zK74zjN^!g+)+wnrL?cd_t;Dv<-(CcsI
zyR=(Q`9O9iHbMafxd-f-nl6c!BS%0(t8B!FqTppJfgYoh-1Kp$P|ABfteGql%F&+8
z$MID(6<fwW9%}IcG+YH*kLtz)bnHrJqcc2zsW{A8Ao(!)7RPROP;zFLO9}Ex$su=V
zC4N5f^-lEZz=;^K1!;<k8lHfZ)am@6^Rvrr29WF(e+6H6=t(Za77}Go`!4$#C`Tkh
zf}ECmiNV^EKVH97yYygdyrCNs5y)eTs!T(`C?2S^UHqTyAxvaGC50TAS6W)2qZw>)
z8#($rQ~UVfw~@L)6x6Vfs*Rg|M$s1O!QVf@#6CsU7=B*%xHJ@;wni`OVhGp!R<||`
zx*+<22B;8XV(__=#65SGA;I$FR^vjRs_|{#pg?fwf=b>wdl}kTc%ob<D~;6YWrF-4
zJ<=oH`d*7JhjbPbR;^r_Gf-ntmXyFaZP8^t-e!2DF}yS~7t8Ti-r9SO4-qmeDSF3k
zZ`;dcm6vno8Z2gBu$D(X6dd)!n7xTg04w%@1mh^Mk0*sjHV*3z@kbrANIcDPI(qt(
zqtVc+R~W$yQznWsXWl0xxwq@e3YM<KIDyp^{D*~L?uMvVOayGW29P$$g@CpN3==Q*
zv@fs`Wd`ezV|XWl4kOG?5MYV~F!NrerSA(qTDceDpNm(t=d*^{#h<_+eGKsymgpD(
zBCI5k8p0pO^S{xE4hh^2=+J(^(_s)x-L<{F4F>vxy~xgnE$9eL+Ml2UqO1|0x%k?-
zBf|0YIF<N`<dt$w9!{q=yy9u$|7nV5%DtJbL+dj;G+q+&bhvU$@yvc0GyZNT2r;jA
zpR@_sz?*(`ZSmSd<kLwtdsFcQGE%%wj3&_++!cC7Bf>oNa^_rSQz`IebboU(Eyc(3
z9%`dkC;c_t1P5ear;xTnnj$Q@FI3twfuWy!lHlcrA^Kk7Cf}FlvdIdAV(L`1!+qVj
zg9j6XH@vEEYA4``tHgUn?%KReBxLAAd7iUSj=-f*dow6f{|%le3q58{Dlf@cFFKI)
zW^lcizxKXudlqe^{D?O3pG&4iDWiqRgOb~#=_9bGiZ*=s@y+<Dq_#FssCMm#Qoh&h
zxaGysxw4Z9jxXUw1My$^<4RsmCPwacb5#@Kez@x#n_G>DJe8P=SES#=m=h3GDO9|<
zV0+Jo!hv^0|2ptJe6A5(hI}Omz4Ag;Z2;eYwt*O!16);2koD^_`X#_-%RiHvRfYTh
ze@h4Vi|=ZT{B+8!pZLbc;~J$x-#5Cr7VA<iB(3Z>hF6U1!vCCrzvduNVzK_?mpmR8
znbJH&j2)gq2yp0@t7R)Rvqh;fN{cW{fZPlZ3$b^4I)9@0;KFyqckSoId}%;=eX1<=
zrjHw$^5Y4{M$f8l>vVIoTy2Gpdv5eCNqLqJG9zpjLISPiP0iOaw=fA1QPx2}2@|FM
z{ZNFhMua6W4;uCs_=T-i6>mK)4&g95{Ycfu53UM>JdKxSeHB_@q$u@;JsgNDJXi6{
z?owU9Pit1gqma|_3sV92Y2^0uqrCWQR?01^BBvEEQi?~S>cl=ccT!PTG1=@r*>Q`I
zob04J{AYW6tScZZT0qO#FTuZncxK7u1XIC_=qH^C1@%~B9l5ve3Q0@wryx<<{b#>e
z?%icIpL%lzd$G#mHuRj$kaDSHXEF($Cg?cay7+xQ7wEab&_YpBvEBdtsI={0F}w*l
z%%4+mC<FQzvC;CjE%1F|d~{pft-7nsx+}>oH8z3!5R}%@YnBQu<z7P%UI<8vHHfQb
zVKJ<hT*Q!`dJ4QTWo#$5>(Ni~o?&AoXEDF?>J`OS*Y%%wH5|j@oWznYk#e5PH@(l#
zD1}@yU&qiZqPV4|KACw1n?Q|&=W)R=b7%5f2IYpjU=hb5cP()?=dWD<KRrV%Tg{^?
z{?S%Cn>L280avfZJN?v2E!_)wpVjh==S-rtpM3mi%S-4HuvQ^rbUrxPM2=48@c|^`
z4B6F0Sx+|vgBu1YOkhSOv(wKC8OrX|ie3E41Kt0+l_XO<&HL)OM<USye%}J3(E-__
zZi_i09`Ef<1T%&23T^Idj%%_d52?%ftlUAxGn-BdyEzC(UWQbEQo`hzRHDLs&ha-A
zX)SgCCx#H|TfWigF})lby7%KJ?~*qNE7lbRSefN+=s7!R5pJ40-?Sr2b*4sEN!m#B
zi$N=;8LJ-qCoD;T_?5hKU(>387zdkB=C1(?0`hl(*Oel2u)@;d_atWyNK9dc#WOof
zZDMj+<MXMRTW#8WcfFxQwAW3K#E5jtq||0hikohh#grvy!XypIyR+N$V-3hHv&bjD
z4)=?iTBGa=#rsMlr{xbN)t-$vxYx=mZJljwJa`EeQdR~vZih{^l?kP-rh2C84fpn~
z2H00GSxS(bO2upLv9pX{j6xxG)MEk(8C8=^n;)&v(k^6VWr1OQ{a%q$w}iGa{;zcM
z7&dG=G9#`hc3+%I)`=A!;=Ry}Y+`+GZ<6WVt9{vjMq=2hhdD<)Bw!;~(=7G;Jw+)X
zsYtL{tq&1HPjl)?gT%6FGjQ)QEA--UnHpuR1M{w$A%ix2CHClreUyDm16j<FW-<K|
zi_({!gLbdQ$9KZ*=2yuPm>fSf?T&Z)|C!Tb0SQErT7i$*A%_f!fDk^>0anUvcIhcB
zRR*e$cv5-xs5OI6>CW*SjJY*>>I?br<%mD3Mt$CVbAu?>VzZFZp@>(R_E)CLgSe{2
z%|-mjSBin{^|=1pJ+3(vDhde&6KnQxrA4b~$^fKCAZfVL)gdE1zjcvd<mh80M0)fV
zrz)ThzX$(;U<tSrhaeYp*xtagfFo5U?p4>B#?5pV(W4L+1bEzN#m9S8Xc}sefv3Qh
zaqu{Im{2MN3eqvq7!45JqN#YX%h=ykSE||im9ZxBwt$2#HNCaNqb#W82QkJ8#O=6|
z7&AHfD=Y{>hjfBSn~e4BoSZ#dxVbPl(t87{#Zl8gge!4NK$|mJP-kl%^dL;N%W>d>
zNk>YT?YTe}t~3G+a6IXpmR01inXc2)UemYjR^GJwV)luZe<dwNOCtJpR^2-Tmj^-L
zXc;?QJpWMZMiBmzK<MX`raC2#1Q4R%P%Eb9`Pq==-`TM>%oQRXYj7)0O@$105*h!6
z-S;pPgDwf8OJ&a<w>zc}g6Xk&y~{-VS>wf|@NoM5z!-t6Vc;m}K)o1_%W%4;9s0$%
zPUj|Lhmi{|7fBzDSbb{or)!?Ck0Qf9`Pa9|ov`)<aE{~)U|BH>p(y_bP;)$ZCFzph
z9awM}5j|<zY68y@wS;`etxBYHfmO(20cSjlCrvKL@u3z4M#M&VtnyROPx*vcNkj_q
z)C73BnZh6TcZs}Ja)Zqm%)RSz)?S;%4jUf2+{n4gL3dqJMpX22<HutLlV?D!qpVMT
z$8Qv;y3NU+%#2d<-IoI0g^bKY>R+yJ+XR7g4(AOZma2GNyWeh{efBXboH0i(y_c6V
zqFR2Pi`zx%r4>(&HpcH(@L#(cs`(`D3jOtndc}qj{rBD@?8McPwafgm{WVGPu_iS#
zlg*-fpS3N#%Z^CB+DKoK;A<4?4F`jC73QFX%qn-djBLsbX4^w$FR4SRp%A<@BEiCN
z+gB5h^baLi&;AD>KrP}aQ=s_N<9iNumwMx2H`&uX(J#u`JpI#LA4kUT)3Xo=Y*8ej
zB)N6)FeVHHa=c#C@!0S<eHI@6-kjXH{LFu0T>+bvL%9euA#n*Wf;!xW!JRkPHin%g
za{O`9#D^tgtIHy<BAgHx9ZK}`i1I}2Bw^TMrX%2u#+cRAn(T(O1{UAd#w(9MRK}&p
zP*EZgc##9-_+L5Hu7~8E82AYAsy4)AE}DPI7qZ4ITO(UZYl;@X&jm;Iw)&>R6DNsy
zHwROtuPcJWBXevDlJ`crTg0*p+9nGa>dB{PbCM}sS*yD0E9^I*Sh>*SFpOExd)n4*
z6GR$@7lx1COd8|i;~eemwe!3+s82l?0d~H!at04)=x-OAKW@2_`$ES~h${`Ubzr%6
zuk#Rn6eZ+iN&a$Ao$oNl%gBq6NWs|U#mL=)hC)AUs#oYEgcY?2Ro`m~hhIDa1CiC!
z_VEE#6)2)EIVFzbjh1+UabYecrPMEebW<RX;72i~42WOGBQ)JrrQ&L~@fOX9rI}oP
zL8T(&&-=OGF)HR8>g=;kx47)G;Ug}QHrp;>9-yw1jgYhG=M58a@hU)F1opSsl72L~
z4VOUMd&q<Td42-tLFx|BbwJE<Y3D?&h%`({bct3lxT^qJQZWYe+ezgnctRw!;R2QP
za)xHM6O)*Xy3QD+X)I^*W^bT;@)FFv%(E|F)6|)(j=#(3WjMC0(-ns-)^pxo?1{14
z*(=j;`vWGPVEU1&UJSSeSrRW##_)kf@V-6tkJ4VhG)3nQS6?MU^5Nr~T10D1T~;lm
zNjvgtSpsx;N-a$f>hAYOb>ZMqTp<v$lUqu&k7p7{)Gi#!Y!bAmvI`J&BEm}&kqCjc
zUs_bIe8%Sy@pi;4a;Px%5rBul57_~A_hIlK(3v(vJs0|~i}CkD`+_j>!eJ2`EN$v#
zp^k}Q@z28zi((G4<YXuATF#kxPvDwQn#3$w_39ZeP}<9|iYby7&6%D+<>H)GlB%w*
zUCL=4Ps%anL)>MczD{=&b!l*6`U21&ch3>&(G*C2#0X1R;-B<*H{%hAU)xVNt~gZk
zKqWCyM`V)5_7XtCBKamODs$ci8dh(~GXQ$bj21ye0>{852nfl3kiqU3v><kO1LW$N
z89DvvlgJ;lfnTv^l|&UDqT*vJ8J|x{Q=#yh5ljz;^uye4(`)?0i4uPr5U+|-KBXJa
zXI)~hA*$x?L#1^V%lWWi>dBSg*j9=V>O$G%T!8T5+otJ^F_k>WrO*YW={eGmePO<J
zv2J-bc!`Z%fZ=?8+n>Yz6>!)YgFrX`yu(i1Y+x%(Ge@A0VBkFi%05wXabwOj2%wq(
z&;>?eVle9-zmy?)cytO`hB|<AbM|+CTbQ#$z-7nz*@=78_La^{NmtJ3CG+_VP>dd`
z(BRX5p1sB}4BxEoyI1udqNUomdrP!s=MzwXFf}<}2k{NeW)>i}jF9hi9n?4%i<YN@
zX<YXL^9~(D4;<S;%_MvB-~wDue4vyk8v{^E^uaX0jLe8c>8H(!xp4)&m-h+9rg+N<
zM=WBqS{#whRfJIb8*uhW%pHt1D92IVPB;NFz8XjS$$a}14!#5$vVfy#s~X)-Ap36Q
zG7u3s+1ubXp;NS3a|u;mCEB|jjl@?+9fT9Q?+pEI<<lrd^_M*JR6;zuIf}UxxS}98
zy<?B>bKdHo4EN|u9G`c;00+rQkbAJ#BTmxvj-F3X`CfOR)m33cA%BK*vid|0=5yHH
zhLmzs?#1uYvnVwg<4%$a_9hPiR^UsA?jmUn*)SXBHL3A;TJ4@{J9yk|{t)yTkVt>L
zNR_`Mb*aswr!)TxXiu#Hr`z;9>z>$a14?A1Fo>#wrkArg;zzor@65JsUz%QtvqkXm
z#DLvmZsS7pS;E}KMEmhQh|ddx!6pFfV+#R01Ak7p7FZVH?Y9CC3vdui^ZNC2$Gjuc
zYGcS|bQjHT2AtwMe3USR*{<$mxcHLZc6td{(TYBRt~;j|zP`3P_UbaPO#1Nq?x5wV
z9*1eGubXH#Jq^vzoYC!p?{qVn;ilD7&&cqZ0UveCy1|l=n0T4AF80l1>5Kg!_n>*5
zQ#JAwhO7j(n~m-B2E6ISU0_W1AJ_(}!#DRoWO@B={=P0!aj()C#!Bw1ia%&*oWhh?
zwsMX)JN(WecsmX?r0L0}`^PXoUchdgG-g^e&@LWBQD>V1$=ch4Zx=5x$zpcx<s=r7
z!F!e%(j}G&tp0cP3|9T%gk>{WG?jWs_|3=feu>YnChe`K+n_*);V-&GXY<J~GC;;=
z>onrs&l3WWm{Op>9ZDA)h-RBq+Z@f-yIw5vo!eZTpT$>$@B`)sSeKb%urs9(*tPBE
z{>hQ>a)6`<rPRR{(7ULwPaQ~UhZ?D?S+<=YZ!iY^m1jvZ4p{jFWVlU$YoVTg+xk0@
zxqGokW3tL(SNme`6^uN#7TVq6DFY9_x!?1T5mt6~%OKag&cJZL#%>KHX1v%7?V$_Z
z-4XVgP=4lmK_-;y*yqnNV1jW0PrvaCky^p~e)#SRcf3Y;uhP~_aA=NFTfX=A6wFkz
zLvbgmI+5IGhJOqj)TOd_DN#10YhUdB(PXydI1$1i5rdR8RnHH+F)H4+`R=WbY2J91
zT3+3XWJyzRuBz|}<hMwDa7vc+Sc@Z_FvQ}e0Vn8xf0#MP+l~S`Lsh=NDP`}=8vohM
z)Koen^<VO826$XpCb58xJuMvm+In6E*x31_v{%T;t7&(0K3{a-{9et2A<Hz#epi(T
zrS=u4$N+{}^%FZ%1tUy3_l@=S|IszP_OH5kA=w<a)HImR2V%RGn%n`qpaof<^{;@#
zYK~v0Glv~QMnGU}Y6>^3?T_J~+_nz~CY&a`;4EE){OChJ<)dFlVJq2>1S^Uz{>cTu
z1#qA$j<KJ!ACb76U~6#fCl!p)rKqw+{K)Z|{|Gw-I8j{6pCQcKjnRD$xCnXZ2{-QH
zQQiB}hL3L~drfF4P5A)g_j=fYe!6V@Xu1J#cvjX|`N0jLL8l{joSCX@MX5bD0@+(!
zlyL)guo-F;Bdq>>{{XqhTYzFcnERD8m5imv0S*Iha}L}JS1=Xqs<zm6n144q&8<{d
zd#3FzMOwj`&xMyX15<s922!J26jnjzy@5<HNi!p9N<asEHh!y$oBO$YxhUiMO<tSO
z!shU*+otZf4P>9w>z8U&-N@2*MM{ncUeB^pDc$p?D{T)AyQGdo$vPCNqs~zrWSLb`
zrr&>yJ(3^Mu`7kCqld|au^K;-hbGm{#bPoVmQ_$v0{77>w<-!m+sXG<5Ej>P*P1uP
zq>iY)5=xpR*PVNQDHS7&>4qUX?7DwoSKDjZn3UfBN1js+_xp$x8`0vvgg|59mtR3_
zY4Y6>yi`{ah*^Jf1;l3<-hKlJv&0#Q1&d%)=nrQHec$(nttFUNW-fr4Q9B@OqHf1L
zm?e5;U|#8e>11^<y#!~)uFy-27^zWLlO&dR+C<U|hiA^FBk#@BA@EmFN@rVvAC`$C
zUSKpu(4e<?PkP~ANF^@Zr~cunyeXUg%@dh_GNj!JaRR*DZF!@8K6&<a=cT5Fcso*5
zVO8zt$9EWxKK>eJq>Ssq!X-(5N&B!V1h#0<gTc&u9uC3HM@OFvyFl#G4poUP&^&tL
zC}$hCS{NKb#&FW+2M+lVRh?RsT#HwtkMlX+&c0hh7K$anyWzZne?UGiEaTU6tyDYL
zNPP}F?c_D@3@HMbCQ4vO@@r>hkiJjad-cci^77fC?4|44)z`xA*Nfubmkc)?n=6w|
zszi8&9BgK~&B+Mfb%jDqsScu-?q-YTN_hSH(TUae2kdfodZ;YTp-rE2Zx8;_;rPPd
z?fYpbyd)54VBg8syg}br=IC9?l2uUm9>=G~v|D`23GO)_WRkUp*irdQ)V>`2Z#{!k
zA)XC8l2yelf+ph4xaoSN_{yVTaCqWIaGTaS!O)uT!yfe5*P+jaQYT=u`VM55!PfX`
zWe4_>EY0GB&H37+E|UC^<27Jqpm&?$Lg8H7h76p`4F|yXqCI%DwSGUr18uAyHmL-9
zR?mirG!tn9l2t%vE}@(k+!h2%FwO&l&{%&z9y)$)_6edg>wz3cJs`H1mR7RoeHZ?#
zpFy$;V{I>39dllE!0%|rhgCwH9wEuT4MlDS!iNDPof3@n^ne|4MKDK910oC4;|OGw
zH3T#hBH&goRE!4h!Keg~NPXrLWzUU)W&!(s2v5I9!oang4Y8z4WOCdqmvhS9`CgR3
zZB*577Upi??OeuTdGMwtgV0^-(J~&(QVu@z_W<<PQeWaFAO;pA3vI!X3i8mZ9Z&Fu
zHhcArbar-b$80O&lF&r?U)pWWw~A$||DLb)gYvgnPasJ(M=D_5@#1t8Oi#cnsdn_>
z;uIaJSLT%U3+ChiX|D$4SyMx@#qY6KeZbJ+Etc~C`vVl=f|(F~F<fS#M@kd*Z*N>X
zIx5Qh&Bx(vF)-C2x_XsCR>ph%>wvcGnYTwL=9H(*$z}(5AB!4rUN4sK%n_<nMSI=%
zP8KLxLd5h7bES2==KIX6cJc2yDt*;zMggbGJnP2g4ES=;ec3i)&r?Szbx_L&AAf~_
z%{tjq<VRs*goOq|!V$KOZ;kGZET%8YczBgml)#)RRZp;2bNmuB_y7bfb&hf2=;%?G
zL2DbEOQV1iXX+@=<GnS=#~Bxvpn^I7*gXKHsDV{}+k3U(yi%KjgkJJBpH)1gY{=&7
z80)bO0#511)V9k29xt>OM{&sHQ2E}xHSblj>^E&!^94g2jB>U4>d$L>4*&m4zPxtv
z=+&JFB%&_PYUPi57>(ft=D6^_iH^l44Mv!~$t+b}mR<7N1NQwZShiA`6zUunDRTG3
z5e2g`<OZV!E@<83)?-2<McUVCOtynHNUpQ7;INU{>!V7b+O7X2<$ZT|`ZlLv=l{1x
z|68mC$}7xKbee{3&Te-j&m?zG)URfgaH(;)w6(2$#&>eKv0d`2{8-jiO}*NFwA$j-
zF1jgWI4Mi*EmnQ~+I>r5Fbh-VDDDy$`GCHib31_{@&7jYq_5~Px!SFBExs<wRkmFT
zoSX3TIQnbyjdr?GD;}}_V~RIErfMs3hMISJd{Q!UNnD3V^|hj;ep#w0;XaO@S}_QG
zE_DQV$IaW%+s@BJws@qpE9vu*z5j2JFm^TkW<+?Dk?XyIh6;BAcmDMcwe4iLg$P*-
zT~BO9qXtiDr0d@opqc{rv-%hw!;R<n{`}az3ZO6mtor!7fkSx!be#1TsuJhm^WA()
zaH;@P5!g3ykoVr+_k!oQ&$Eu!gWDfIo>gKS%dr0~o2~Ea-zEp%<PvZ3XSRc~d`3!=
z!MWo}<-!{$ZK+>8bHHp8n$-Ab&o<&~z=4nofZ2VLi@zj*ZJE6H2S3%Sjd_o*eQ=*U
zKWV?P%tJ3c8hn$t0R~?+9{?)_?5wfW0FwzvN&HNknd5U?x93<PfE~n6op<!ENf+SN
ziN2n?2A9<2WGKhI3`|1;^xw*oI4{-Jb)vsH=`JXP@5t=fLH*P_Ly_uiBg&SR*GVxT
z5zO*@=jh~5D1WZjQCsN0zdr|g%^c<qfTRLvzXV$Do!!6}XuR?OQU*lpo`ugfw7I$j
zzqkj4<piH@_kqVLC&f5PfqI8E#c$pCRF>x|m_yhch5<g92+S_Mc#h&!miXPQUX*9j
z6N+#>0-8+xWHLm_K7u7l4<scl*EYi8T{zrw(T&l0D}XT6ETyJGdW2|;d?flvsWSL2
z&GpawnGORn<YLq;m+Y7OAMT;Qm%Ft_c;yCDkOo`+dX%}p@kfkE@iNyc4`9V{VT2rq
zh=fFa;C^|wd)t7I^pp>2l4q|(ik|5U9Jw4JCE)cc0zK)d3%G-Ox}0fQ4Oe2s(GZ@w
zKpS2Hc3HWaE)V{_CZkM#nWfK_MCNeyYsZg*Iz82Gy8mi;1-pk&#M87HuW*#+VxkbF
z;XC+T<o~^ihti1tAjtL1o>EXkpqkCUFBdd*h_}i?=97AvLSezz(_wRq9HffmyDaH<
zwb6Oe_1Lsp9L(>Vf};5*Gzkbwjosydf&&;Jj2zY8)}!Roiw>nifx-%1{~6pAC*(Jy
z&i|5JcubT}%ryi@pz_d}C5E>ssBQDm8$m)nkDRTn3abCIvXC}I3MH@Y*yE6c?zD?D
zZT{yT@iQGA)wcCyti8&_n!%^P3>n=BCb6jhyYNSF8y8a`nJ^~2F-XDo4Bfok(qWkM
zkheDyv)Cz*&@Y-M!umXixGLuB_SU?{F<s-r=1Y@{;IHl<B~2KGB(nE}YPDa@vKQ^`
z<Mw7$UE{#^v(V=7nctrxCfY02TeGS5xHvn!olpzsAkdHY8s;8CSL*|T>Nj2*NY;CH
z^}?z9*0TM)u|0Uaro;kV_lorfJabIw5|&Pp%&?221#F~Y^@}-<QB_MPGW;s2{WUDS
zBm~$Z-=ahjqAdDs&BZg?>rN5Km56tpA_C<)^;g#kTWfan3+BumY{ymBiH2J$-u#Jd
zCSuL``DsXkk%ory<GZcP0^rg3u$bj`^C(zJ?q1&G=AJm{AfORIGkU*0<P6l0GMDta
zi;K-OM-PiTFACxuel_&{>@fS7{EiKA{d3rNGhK?6yHlF?yzlxP4te+Gij502{&{@(
zCpfg^MEOwjPW-2emU8wqZjM+AjzGdY+8;^3WA&YE?VhRrSVblv@bs9HEN{Jj>eZmu
zI5m>yx?-y7uAMly)#AUcpsZZnW5a-E`ovG9fO?(fb!+D9T`gtV$Qry1Ej&ayrQR*R
zR&2TF)=XDGC|r2wCRw*U#q}!+L<)GUN{%=bpHdT(X0E%}bg#8ERQkUectF@}hL|id
z<jkADfBPTZ!nY-&JXwW7*=#f02xDCex~qLc^&%;8ig+S-p905Q_^z$Vi>BK`M6b#@
z2WwiYgoqR$ji*o?EdOwt;qUcrwMZ^1twrkHq9BM=FsZbvEJCkO`tyf0@<&V~1I-G{
zKX)vp_FRpKD(PjX>SkYQ5SzlmdYC5$Xtw~~m2aa?BtPjGo%FstdJ&4x{BCs&>|<=C
z$=@%yeyws$I-JepRu}*B;~mGndyk}Mf>3K@^pOfc2TDD{R48nx*Cf47P%AZYg(Gz>
zQ!#byD8M&=MEcRy-|6GnPMy2n8#6|nlj;&)>85{QT^H>mciqVTcUENiziTZVV$E18
z-Fx^-K8hptroe82;8HlU_xRuNmmQ&E=c@`~+e1(5hiFcTMzYM1V=?M$wO7kpelTIh
zw8a1K1v0txhZ0sdpX{(C{E8&C-y3kss@k~DFjtd^?DDMrFw1s5wQ6I@VEBlFV6+(5
z(RcdvI<4g<>DybeFK^*VOZW*#AQbkb$ZNTU`^V+YtdbfL#(M|85y;-&mu^^`_+@kj
zJaX*JZWv@Ki^UHx@R$c{M#uF8??fVPA2jx{-?))n!-9HJ_<Vc~bxpgP^_l|qPg|pI
zCp%I+=H6G)%n{s_aV2Z9EO$cLr!tM!rN#E08QdfC7pI&*?XvJZP0A1kMgf$#lRj>N
zw9LH-1uJU!@a2C{6-szk;t(n8;>a7<apgr>J7x9mp0ZTlroqZ8p^cJnSmPbB4inI!
z$XxQTiLJw<?c{$~QbyOu_pv2~Vai8w+&~^lSwR<;1v=n{3^TbYkuHAm1hWW*Far}q
zLwFaD;{IC5^@hFdN3xJrEfzatB+v5DU7eVixWi&i7Q7_!&5xIWIYL#p2&RGWkJm}_
zM;)o7ZV`yNe?JB)yFUclUVUE4ANxdr5*x#oX)w8JgRU>>VHdS(a(4}P(i%|y>G%ed
zCtQFR9UA!i+fi25^;YSt3PrbSN}TbS^YT@2{U5qw$$nzN4&psx2(6S){Ps}$&Yj0Y
z_dk`X(8FoyP-}S4{e93;GWQ_zB~{CDZRqc?au-P0Ff?=pAg#dpSo1+Sp9!H;){C4R
zb7NxzGqc+1D+p%{WnDtTbau8PkPv2QzO?3Uske?77_7+_b9Z)nO@e(&)WzLUDmO)3
zF=48!t9$RBD|K&N{Z(;3o`P~y6_r2}lNlh;BW)=2>B4Hb!Ql$JrH??#Rk3a6siAzn
zySuBWr+5AOb(B`qbRMR%E+^N$^77*!oxv#sb<^K*if}~TW|w!5e$TgFJo-Q^5TR;#
z&0<P5^&IUrWgO{2X|mbRW%8m}_Vg#o!^Z5TX`NdJ1_s?Vntpy_2)U{K)6*b4>pORF
zyZFK5IW94g@j66&Q~wZ8u+J>k(15JxrNu=(eSI)r15+h#%E1<&jW6TlgP+t5mDkp`
z@FNu@BqU&sl2nT-Dl~KrB1$+Ja!ei_Im#&IchcXyk{u9WpcL_Z;g44{osb7*WL60~
zJNqS<97YX=I;+iZvbd4`T>N5UjZICfz<w?-9})0ciu;Bc`x3fAHa52J&0f)(Pbm!v
znXp+&W6%<Y6ToV4uAT9=u#}p>wfcHD41Kh-vr|%{QaV0RvuX2~z}rGYRdwjorxw3I
z3^R7s{dt&dYI?T}QZqAsU|`%MiclqdE><xAu-yyoE1Y%s(k0wOJfhl~x))GDxcP&4
z5Uive?Cgdwih(9Q`@l19%OVU(5Z%?&(*rImK&q%SeZ!Y|A{?QEj9{Fy_by4&<-d|u
zayvHxYLLaY`p1WPFgiXTY(M3DJLOt!3|$s5cz%mE*1h-I+lOymc`Bbh90=$LoP0Og
z*udIodTHB~+riA7?#W*mg{E;2!gs`o%nb~<V@rPL{T|M4+=S)}NtB@kH03|z+OqVu
zgg-fArBnDyADm{=%XWo{jT#6Am0>du)^wMjDgiSfQ<JDGL$hR>f+`MsQHM8{MInCX
z!3~0+FI^ydy3h0Ftr~7uQ8Q`>Qd2x;1)|Yix;|5G%G#Otcz#GyKNA+*AqSzsnz%PO
z-WE5niDeHfF`GZo#^~aIc}tL}RvZ_x<|&Wtr_T6ExM%+W1MFzxdOq%cT*Plhx?$|_
zc1*uBuDpEQMN<JH*nQsv?oZtC<Van7Nb*V)j1{0%_Jl*WPzR6M|Lpi#RMau_ex;?Q
zB*etmsHo<)4rXU(4Y}?a8ooK|;R^u<-&3%Rf*E9ceZ66_U6l3W;)Bb94kF@W<>H?#
z%nJ@np|=Af<huLCfxCA8`ERh6cXnQb=I-^|x0j)caLa-T7dU{-k@Y=`Mbr9uhmd6F
zqZd7u_g3ik?5@$-cJcSq_>;!Ub}>ze@rzQr5ylfg>7mwSF2Q*x&}-uw@tWeFJSDf_
zQW)tqY+Igpc=?zt*p!9T*kFdPilr3YY2zB6anwP=YV9e56L(<2e;_LS@`CplLSvWJ
zxWxT0M_cEz^RjqVQIXxsCqpiyRKh3x!opwY=4x$}o2xdiUAu<$^eIDPYf+JLa?$c~
z5izakJ8oJkM{Ny_aUWvlUtp68gqRw(qaYc1By|)sp+z^*%W`!yGqZqzo+^vhfIRny
z4}ttqgE@Mapo4}Ek$>#sA?lao^^;0hN)L~8MzP(g%Y|9V6j<$JQAnN<lptg_{X9~3
zBuAxTArSINCUbM%@kCji=jbElYl(q$w#gpbA8UqKywl<nLdpD}E>Zqz4b%KcRXFI)
zEj3!pt)Xu|N;rOEs=1P>#-I#U!1=!A#Sag0*g2?s`Qu^jAAD;PkdP=YDEI+;Q+auo
zrb8ZjcV~A1``}x%7jJr;H8p}?foQM>k2yl+gPg7H^YxbVBXmA|?uJH2;B1CIKYI-0
z3IhuJyl=L@#HJYY7JK5+ft{rsbAx4^&zWzkeHqRsW*hm;5@b#jg?|ML&I)rWF6-*f
z*a2$1D_Fn^juUld@8XA*E7b8PeMlF36~BxB_qS#qwWOYgXD{T~U|C5ZRfg2QcPqt?
zx_4uLzS+yq^AiSHx3#|=s4-gO_+JuHk4NTcm6nvn@np$Sys&R=krcUmleCnokj~1a
zp{$I9f`DhX@uyVc>owZY*$)BJ{O>L^43eDw;T4XIj9ku>=3A~QOixZaP^;XcFfiQz
zS8dCXm~Kz=!ag9c*0}$-w$#YaXgohdL)Ij`E`FK(Kj4H0<m}-FkPrJ`oB{W;zM)~~
zeb_d+W7nw7y!UrMl8=4bL7zCEFKx$B-*bpsC(gVgA}suFa}^Ui<9SBJ|Do&8<Dve)
z@L_ypX<}$dj8Yj*mW+%gsk8|hyCjClUY2CfzVBoiWnbQwEMv<^c4f&Dk|ZQaWM8ur
z?&EX+e&754=bp#=pWY9~Yk5A;^PKBk*LD688MN+MJosgxC9cdb_g01Bkni?3czCwy
z5t2&Iy-n)rl*SErG(M#vI7wnvdJ%{o;?WLjhI(FAl_2FvM8Va3su8AiTA8zck6U;?
z`#E~&SO*n6MBr1J^Vcr-ovm6!p%^8GGF<POY?Ltdz_#%$g2v~VS!4JnQu+HKDjsA%
zKBoC@nK&Gg>EUBy9_4%!q36~oYRbrBjl-lQ7os;}Kh(s;H_F#S_P(Q}^4E+QP<&-z
zjd_wJRJ5(#KjHoR{T}-!zKB+k$?Y9=ywYL}lBr)&R?(cZPK1>$L<coBH5IptO!%#j
zINiO>aqZbCQ&VCa4cz36?Y(npmKRntI~lwmm|I~ZPL;QrvcWmZ#`gPiBvUYS8Jgfu
zY@!}*Ea(>%MO9Z<%WBkuXv)cHt!A<A+3xr9+FI#?J_ymo2pX7_5Uh}g3P1-C*g_2>
z!o!t#S=$M#$Avz^nds*39?!wvM&*u_<p~gHa$mu3y9a3~FKa#^tS9yEU+L@n#Z+O)
z9V#2*c1&pc{TT5`)=@%>j+Pd=EMSxQe3*<W-I3O83MEs(Pe2CIIJz|O&B3c7h>t%;
zTubX>qH^||(!1_oZiu!(tVG=8E@Ey%1~=ipfLL-|jhrt>=9Q&f@Ypy{Wsps2$trQy
z>Z6vG(fHKWT{8`MoRlNLi0~PI9r`VG%r$L{&_ZU%4kZ%{WRO@{CTY7r1DMY|bUi<$
zOZ7`A=kx7X&*ch);fUFKtTH|3*xP>ph_#`OqlC-h(qc?2`gzcser|rxUD|gZC*vc5
zv^e%#L}G#UJ?0KC8y5pwhIBuK%gFb}p$zo|BedP26rE)|dmo7;9Pp6+-k%K!nF>F}
zM#aar2~`&hg$0Q6HMnqCLnc*BVHCW989qyx;ev#UASH!i32alN;-CM?V#ApK+w6DJ
zC*$Ci`b5d{_7rL}xgrcB+6jEAQp-*}9b$=6a(yzqhcmTe%}Bj(rqs3B1Eueyn(`<)
z=NWx?zSlCnrB@iv^*+jmiqMkd+V};E&(zaxRBKES4|1ILa(GA}{Z$l>*fM~Yvx6yd
z#i!b8c-TUv*MA8yM!0hD#vn;RSaHVClF!&Q%*c%={&7hQje%g<L;#7uq?i~Rk}ib%
z?Aa87fY{DJ$7}4N1eDTW9t48Gfby5s$i6a~P2d)>uk|U7Nl0n8^E+WjW2ju`j`k6a
zN`3KS{G1Y%iIEX}N;OENnCR%wU%s%h1j}i3c6EWCNLO1MUdM&_j%i2XhX(gaRbrPf
zSJfPRlFbJF{9f(u(hd*nOLud!<DH~{vwRAQi?F)}^_l+}PA@GXyBz>qDlRM}BnyLZ
z&Bnqal&ks1_6q9Juj(V|4JzqN0<82`xmn(!$BxSAXlP(N6b0DDQ2w=F+cQgwXU79M
zYkr%FCEhQ7Q01}382;h6a}6{^yG8OS6h&oa$1D02N_K8;$;fLg25HM(Vb&4%<40|6
z?LTz^SwBaS_cH~QYRBm>K(=RQW}dBPKzx=^>37o73PtxzfC@WvC_4Y9v-78!zJis%
zfB*U3Bw*g?;NgM=g@yYhx@On@O25mYoEH=v9K{HVlsqUkmb(QLGXm&xd#j@F$e5X(
zYh5-dNiLi?gmBdFmv}PyNgp!MuCC|O-LutcWHQxUMN2~i9NbSw-9ZPyRlF2_7%A#p
z^8nTKB3_%FogL&<e>m9-^=d9$x+Eej-1W!)!nk2Xb#bg{bb5LTh0=Y;e%44VR71<D
zoqP_;rL$*Qs7`3?y$5%xRC_ad`RdlO7#yUCPS6vrs&e)9xq(LF`1pz*zN5iTZR`{j
z6vPV)!7u>9rq?zV4jI?z(K26(K72R_ac4Y+KUP<)ssVG%NmSQ9Vj2AZp(kDEI4wpb
zAM*7PNP>Uq>)toV42;>G4LE=PJR>7xP;l@?6(KzSL7BOVhm2pxbVOt^y@Hcdd6)S~
zE-vi(YtwE(H#rjGku`h8;&71B$B!T37h}m}{R_GH4#>}~`iqoQlvXN-srcONZ0iB_
z`J<cuzCK;%1r!SWWSrS$4C;ciCsYI3+1Y>p+Q)aC>kzXG;n9CuHps#)JuuWewy_iH
z=|d;d*4er0B28u|5{aZ58+`)<10FPz?vQhh=U9sh${#$GTJ2uGeEH|karB{*{u)E~
z5dsRz6aZYmeEIU`jbp`-%5Q~Z`tb=D6%`d}eSPp9rmW32Q4h;4wMZncR;o?KNyKZ9
zt-p{ZL%I!0E0x~AD=Q#c`m^i;^}oD)3)CO>_V)k0Zjh98eS{4qli?mxRQXBESO-sI
z{Fl&6x)I#q|1T(Nw>Hx!C--68$p@`ln&|=7p_z~Es~$90t3P-!=XeF~TS=+o?+Oz{
z%u_6_ex9c=3>QR19=<JnT~ZRYx>p$nRsk&x7AbJya5XuvUR4d-km7p3eEC+Q7oVCs
zzp^Eh5#7b1tzQS}FWjToZcs|fkH$tBmEJmo?#2fv8!;<>>KYoXD7u44as~^s0Y@0k
z5EH}t_kl@-gM$OyR%&wcNhBS7(FbGwvK&fwwyf4gC>kV_p-c6sT=#ayQp@wctu3YS
zFh;1upc>=M&ANy{+zes9P2fjPxI~pb)Zj%mVFP#&VQh)6wdUMIM%=B}T$cWO_3F5Z
z@(VP~T9rFamywY%3Y|eR?ug$_19MQW17T8u!ve0WdnGLM-%#s*j#V`el0pGBFMp6x
z^toctXFw`+*aQwXN0l4y>)ah;)WSCEs>?!8t{Us|i`?$T3(cgBMkNGkGoM2FyF+_A
z>Z*`Xhqa`8ok4D|Akweh^oxY>xpQV9HY4N2E-R?0JdaYdl>#-yoVu2it*tF6BcPaq
z-5tn-RLuo{aA6XO1m`j(^WOdYr*C+rn33c(IL#>+z8nGqgUI>wpt^Toonmc2catmx
zTX?!U4V~^o^H#UWpd^0tqlmsP8pQzb$Ju&h8PZ6A^q@7ru&^*c^ejcnF0<P0wyJ7z
z|LhZMk4l&`Q(yn{=T95`ho8?LmZ@}e($eg0`uQ`huuwU-mw4BjnT2Jh+6Hrl#MpqD
z93MaA<D`GXaq9DdK!ZyCQ&n{tB5sZI!WHQChaK-wQdD%(FDNP!yl`GsNv+0ZnYRP~
z<Jv~^MoA{se)xMi<fRbcf?4Y9VeC;_noVr`i`dvK3Z>)Ecd$5UT^U_E@;|g=*rvOq
zYj$?ApfC^ejH>{WLgKu=vopV53A2_U!Gnxi@aol?`n37Q#fPw7awdYhC&OhMo1fZd
zWLUUaT7Lgtt_3oiw}aLY5z&ne4On7Wb8BlXI}@sjg_)UrnOo*DcsR!>;4XZse>$?~
zz1u$m;phCdYjrg>?!Y2}HdaAio({}FXtjg4^RcT-|DD%xYR$9bB!dLan^gPs#Kfv+
zi)qEh#h*U0X!XrGUq!sPskp=YrLFC?K$vsQDTF|nU(@Jk31Q$qh>JTsew;_KEE4$p
z{Q2{p_4#-1i#9f@7h3IUX?Fo1A*!jJ!Aw27!VQ|#r7aK0=$aL%h%<+&7ouOhcw^C<
zGcjRa(04v8v*VAdqT-3vV^(gfuPZAn;jHoX^#!1)`NId#{oO>U+^@=W`}IK*w*a*x
zRFm-1Bqf%>XyOOeOv(7Jv4bWPNmK8&7}^AW=5!N5_e^=QPCf70v%5f2q)_+(X*hST
z>OnDlIn<hP&-1WfO!EaqMEY%_9Im7eJ)2wF_K-||0xY)ja;KA*?w<_$WcLGz9=*N2
z--m|GNI%Q1CZSt$$oIY9%Ybp>NVSs{3>ht+h4?GoeH4YFJE;2Q?X8i1pGQWHwmhJ5
zu(xmbu!sJ*_rD5nAt7OX2=6K?T|vwzA=0_YZ$qbDB{RROs(o>zg9?}p02o@@+7*O5
zhe}6F^z~jQC4KAZxh^f85*>YWt`3<2PKN>NFs2~K;(kHjw4);V1({4vPVR>q({0VN
zY|!J+Oy98kx}&or-??+JJ9b*0&t84I*!Bs=?fhyex6-aNh{_ZI6405`Tzrx%ftOKq
zX%8!GJiYgQax9!{hDU96iteXP4%=KRJr+I9{Xf8HZOem;iwm~&CXfuDE&gQ2a&vPJ
zK=&6opP+k7NlqT>?H%sxn_k&+)E}vSl3bO$v0kJX{;2;?VM3^kRF#1&_q~?i`3S;9
zt<pMki`!Jpt6f7v02=pJH^L6beY))5F9jT1`5`-Q&QMtdg1f^W&)-4Cn;=IAzBLTC
zxFu5L4fiCf`3;z_e<%^TLB{1%EK7CZ5bav29k#jQIT0~3dDU%os;y1I+&rh_&vmbV
znB{~;2n$nFNCtnQI1x1kg<n#i7B}>(9giR?q1^`bW$&H&P{3?xB4`lQLJWg*)dOE2
zZyNdEyx-o9kDE4qwz9OeU-=7s^e2)-z+e!Ul1PY4`rg~?0EXXAC%=gZ3oLE@o9s?M
zN_Qy8=s~TEC|f9A?|!9K|EGX}0Lc3etX|gF-)3fJMnpt_q!fzf`&vabh^guv0SZo#
zr4?B!jMu>m5MvZ%se^@J$}j<@4DJPe&cEL8!FV-+88G%o!2Wz;HfUTL7az~h$H#H}
zcwhg)2e1VAKx$HuoBIgfbC%LQs`1ozNXILIkBz7g@+o?7f_d*Z>;gg>VF!n)tE=nN
zr@#PmhowyGd(&z*Yje{jw*8*E`c28tZgoEw>#zP<*`hNL5NL~vQZpp2!^(87*##<K
znQqaD=Z3zM)5XNy0*Yeu;?mMmBdXyL7PdcI463QEy<PCa1rE8`kwx$;cY*j$8vNVP
z;QR02zm>`E8!k&ewQVB$)qv04z56A7cQ73$%oi3G!V_s}X@S*i*1-tZHPqKv?lgN}
zOAE+%qqb7|s<}8~SSG$R(5Q(J78V9E@~K!Nl^Q2;@gi{5>R#I>wvM%b{CLHAuCjMp
z%57CZMp;{Xa%+VX6SVA73mWSq!A;ZC)1je6dV2b#90MuuVygY0iLT_USFgg8PM(>u
z941i9;vuE`*4HN(_Iufdqwucmgdc=W?#KgW#aZ!{k-g1U*zQ418BClaGIYxW_4$Sb
z7l`lb0(1!c`SZ#|VyW&EAT7e_cHq^a!q*Fp)o(?5C9~B$VO#X{8w)?zc03JAo~4K^
zH0D?0J0RhKt9rM;d*^giZdut1Op)pa+a6Y95Q-MgeqUNrkmBZ`tIvC#S5a}mml~@C
zZwNAnkf3n+p!Ma;gAidkFQilqJ&}`>yJYiYb0T@{PSj~F_H#FGJnUafTR2T?@^0jv
z`X2=Df;Yghe0-4ID@ud{+5%T8r>pxN$R$wEii?Q>!s-N~(BHf+lb@c*X~=5e1qI)>
zeh}8XKk(y+2Vm=~s}YTjW^mA0Jh1==dXa$F<>hh*Sh64F4d=sZ5vdHJHR@hod$8>Y
znDYWU-v<Y)ph^J88pmhPCdW-5R@tusx&vXKo$lxC8c3rB1EO2UE<4R+k1R%omq7#i
z9RIme6wG()gOGe+d+*1Sa_yN-A4Ln*B$fIJG8#axD~5&#drA#2@@CG-@v@TQ;xFh|
z8{J+L@me+lfioyoAEoaKZvP|q*zf(@vXuhR{tYlNYOY-u5?X=opQV+R5G?Apwpy62
zNhI3o>L%ekAUl%O>jdiqN>P!S1znP0Lc5=68f6FrbKl~)&Tb!TlFoT#9Kq^`?`RIe
zVumq{h>%_798VJ(aa53R^Rve?Jc+sOQ$D$U#~+bnjDxh3i)r}(RV!rik$uP4+@KFS
z{No1-(bnCe$sTAl0Ny-afO-Lp)T~aBymu2S9Z160*ViK=P(*U4IRI^$0+kPnfp7Br
z%Ho>aVTNr;9YH;sl%9UWd)Z?0m`X2|3N$`#6_qCjHU=IZwK*1K_RG7&&%n1q3mya9
zl@Z3KVrOJ;KB}oHYnj$1%>)A}*0-S{C9;EM(#MtBLIITjm8(}-WyW3SW@gxAjUeGV
zn3{1Ysx<^?D<>HEpwV(NEK?OvXthIU{QY}8M#0q7wAoZlE*sfF4Z|}X8u|HCRWh1@
z8X6fngJJ--kKK5i)%^k|nr&pvrF4NXzSt@ID_!Pg?WXouQn_2rCrzOg@mTG-18Jbu
z<GiQvv9N%`_xy6~Eo3P^IUzyEp#FDHmSowWEaVRqBaH9O|8jG$R;Opz)O6TXEDqP?
zR=Z`@+7_82unICU!!^&|K?(x}+x>#T$|%s8%)tr1wME~v{C<VIg9?0M+bjB}m)i-D
zrkHj&!rpEBd$`rkx#rqccOn!Dpj!a1=vyhDIqnUMw)pYD{Q*D=2RAz>=WO*SLSAm}
zWLDI5%coBtmYJ6uVKN1vLp%?L%ScvnK~oGLq&twBl`dxtTF2o+C+X!hTyNRd470R`
z2!ss~l=;d&7z^X^-|J0U!4;6xOPLkvTWpm?kwI#yXlcE4#6-B-N=23pTEohlnVK>r
zMFJWlRYjpdQj{q$Q=RrAAt51JU0wY(j0fm9xLQr%Z!k3@h>B`xm}+S~kvu6$a4jh!
zl~uob_2<AD^#c>9rKL^fgN3rmPwT6zY?p5u9RBm?k9n-C;eR8R<$+DCvF+n)+b(H~
zv$JQfB2l+F<uu*gTK*pIc<8y-cQEMD)I>1xD6GPfnr9mtR#rAPHkOtER8b2(fGn?F
z{6J7hD7@I3?WDGmQAVKv)X1?!RB)4d8IjEE$FsV+3aFS<S$CU)nxdk$mDR%pJz_gS
zKv?+Hi4#!6naj&FG!Zbg??yJJbJGo~?8~WCnO+GE_L}Ny;CrbxFUCt~8yg$L`gM1Q
z=9K9T>@xl(uBvFBwcBBwpur9iZpv0l#>Cx@lV_afR4gq+VioKD)?-b%qkJ`w;H3CD
zG-Smlr++CV@2ivlWYxmLg-8>uESfjSNKxq{R9wB&I^&^Na*n-I>vxD^-PsK|+e+`6
zys$ZNRy0jQ0G&dTKP>ejzBfch`eeuGzp#7Ka$Ap_;yFd~P%-{nTU&5sD=R7STOwo>
z;>@C2X|X&k={;w;;)Y61cA#J5=H`Zi>>()QHfV2nG;iwnyQVG9&+o#dOd#M54i7`+
zSA%%yi<TMwEG{k{8ygGhAoSV9#KoDLLS%7r8oV*KI5y~;1la&3j(m-FywFza0NHR}
zCs$W*4?NdG%7|4(T$h5F2XsovVn@u)giD9!nOx7D5?mSc{k0^ueDk-enVC7jIIinE
zWzA(ib610rF~4ZCuJa#ywzJ-KU^&+u`V_-pW+qHZ5IU5d(^Hk2W5L~;PvLkJ4p}dx
zA6i=a{3mA&S1-zQs6!nC5EVo)Id-L{_b7h^0$c{VV~aS+I8U&R2dO3{Kc7_n#*l{J
z$`?b67=@J%U<kd2dSB0cvq6cP20PhJYDVk?V_<k#7<BDK3~K+gNGguv<C72RaZ06o
z9@1i1=`gu4neM%?<_0CY!sqYw^vk}=3JS_<-LHqnAX^F9YMfo+3L3Sq(uo^$y^cnr
zP^jkXi`6-h>R7p$X6NUJ;wdMBe9_Ge=A<}l@w2x(X4g`rx8|Sas+yUa;>Ud$MUPJ9
zY5HVD&2KfA`W;dtzXAIbVweN~==j??M@;?mj0~yzfdjN=q$+^1z)|V<*qDPol{4pp
ztico8&Q`_#i*(qQo9rr2=AWP&4Fy8bFf<Z5WY}4Z;e5oO%vWn5Vv#(R(_8w_8e{UF
zs{H8DB;1kLiurA5*7!Lc$EF#FWdamsGyGQg!i7iyNo0nt6rRX7sKk+aRDleMJ{*?c
zz9*gF6-D!^(cDfEX>;M}FU-qxypoDL-QMWP85SPi@#zyt)#20L*2!aM1}mC!-q+`h
z$xXjz*nINhPh*NEAerBAkp>p58Hpw141-hvVY{|~68GZZ;|SGWV4Xip>x*>hMclw<
zo^nW$K8}r4mUCWQydWosffw^K&#-eRXjQyaT=-#qZB~{E_UYOEo<v74#N=w%>d1{h
zV;jx)=3>vw#9G?8?AZ^F4W^65x0=Lpdc@qn-d3y9zxMn0Z$rZ7;3IFw;M?4-G&fNn
z@Bz_g-U+m&cy};((7(|CQYhZlU}|~+>N{hM<h5(VlPg=hG{)S$PG`l%tstCpw|@9A
z$oZd9z-BOx|COnk8NL6lvcWl9DR>6VwBeZuta6ANTCQho*%p8DVn!_SrjgMo)Mb%p
zZY-?0o@FI!^g&f`fG)hB+&}xA`Db!+a>t5?y}ejVi(g-eg1hV`hS&JRh&Rw3jSX$H
zGakZ~DF43dIJUhO`H2PL)A2`9NeQ~C0CBmv&}H-#(PR9<7jJNWSyB(CD90$c(40^p
zYWO#(dwcJP9fx7oIz`{$wi_B~(!1lK*cVH5NqdChK!Ah3QG}%wCFjW?^_;NqJmepe
zsHVx4#7^_%uB4QdM!VXfdERz?(H8Tvs@JchjRpb&WHavzD`NprMh#m_f`i&W$h@^n
z9$*VL(K3-H#5p=Dvv21-fXI-s%|p`&0LHM)&E5JpZzR$t+v7~`s>GRTX*t#WXkN7x
zOWfUiFXK+vrt9V9bv?9rdTm=L?p&O5_=iJS=$69^!ZovZ$m>7-uXwh`c~LT1cqDb3
z1v_plHRoJ2Xst>lE^m2|aWV2Hq;IopcH96@72QACl2!I9@JI{K31ZA2ouFIb>5<)m
zi3_#dOv-uk{f!_r%&+XR2HY>WC@LB{CRH&+kL59nJH_&dzz$t>IH`@)1=vYGR=lRi
zOX})UCpQ5{HYDggc+hG0V`(Yc2=hVi1I8p-n8l=%hg~J}zuD>!#+O$=X28Pk@9VSU
zo?Nd42$?HLP(Wv9Z97CRuok`Rbz?C8G$-esuav+m2m*$gs%5+XbGJ8F?c@N@cc#`-
zBsN4{q6ax>_!c4=<g0Jryt#?Ic3REZnWcj&DA?Y7^@K?$6(#z<Sf?}-YW;?K+KVc%
z+l(-LY%%aI(Y#E9=4FXS2~Y~^_qU6k=@2Vb8Xu}yg!uIC`ufF|gt-cd#LmRTM0Dd#
zo}1&)E=bCWdnpXeiWz`y+OYCO?t2lUiN}|uk75;w#6MDTdCd%`^=CEMUsYDR{Q3A1
zIN89&es{wV<7TNCHfSxGtO9SgXHzeXmy?6zyS1e8nVgA+`~=6NSTFJ+2L8u_D_`o>
zI`avsxWskKmAlga9CJIBgmwjDtkaG+<7DENlaloS=LDllS`CR?A()`EqyAXBQQHLk
zUyG#sckd>}$M=8#4rOu=R1D?U-R|AJ`xl6?w%p!pGsk}`9}ksfms3?z(yMtJ)_lUo
z+8WpJgY(`RJe7|hBV@BdvLlH`y40nCPeXVnPgoB4w?Gp=D2O4x;}usmu46m~w}1v^
zwJh>LNoAA(a<T{Yj*#0>Ucb((sj+f#NtnD$Ee$YA0Hn1@zvh!oRE^!3JOT3{;iMpQ
z(`TobV>(Tr{TmD)J!&l;u6gZC>&t`qucX8qp4Ip``@4}~(F-CauXT&6s;UA51HpFj
zo%8$*96n`KD!^y3<LPgGm3VGiB8bQTc#Y+f8R+X99vOLOSfNZnRojmKPP^v*(_>Zz
zjPc!fpsJ@q(E9s>8ZU@q33-l%jm`Hu_ikU>9YD(XI_?5;4GCNCC|L7FwT@N6g*s^V
z?(H5%`_IhIdRzwz1{p^ro0jTO3JQeIpSPAA0*WK2`G5K<y*z%XrXatDosC6p?WapS
zv}D`?pG!CT**hH3H0(WfZhLK(-nS%Apd>Hv0Hg$53-TN&#6J%Y_x1FAT7ldicc`~Z
z?-Eogd+S3_gPSs-2*ke`L?jMIr)t2}2BHV%A>Tuh;*^w>z)|B=vhc!8xhC$TuH)&F
zSzSd-ODMu2RKe|}sy=%1MBm0{0dz&}1Z9;jW-&V)-zu<`!6p*Kd^`bATHpB_gTHzC
zW+sxCj@7TOt`3UJ;G^%(BmHn48R~6|EAi~{(XUIPNdi+E*WKy>vs`zP21e&oYwH7I
zy-Xeeg^L^FsFMe4s83>Tug)D(@y||U(0T_DkV&0^9EgqYaN6B2pP8AVQol4eXTzoh
zwjb<q*q~6yjI8YJLS_5($&=wyliaRvp9ePI6PCcBH_p^-%d;LPua?!<k1nLvfG@~q
zx7XiezMK~x)+@8~^R8dLas^%&=m$OjhkqR>U>i1M-V;J9Zup~Nxog1P+_fk7kEy7t
zI$uf6P{)}3m#=Fov5O&~Ody|t+ae{BU`drbIROED_}%_{HTeEv0w5IaN;lYIBvhcW
zauPQ7%#3c^_Dy;DZP0800VT4Q6Oajbz<_HUsJ7zbymq%QBC&%eL|vc4=wgF9OPK5S
ztHB@k^_r8Du&^+o!;N+i001Ol3^73ps^GN5R|?G~nw?PeXwGe9X!7j)_dYnKJCU_~
zNWYQA!w9LAPkja7q)w@l;#|{4D(#L1*uo|M4{w@=)*8Hz3xdM43k#<~2PqX<E5#E4
z$#hp&m#<IyL`s4xOL7s+@J%VU>If@Po~Vqjp*MVD9+#ImuAg9pS6^aJLZ#T*Y&^=X
z{G_efIkVbc5{hP%>lwAh|GV`R(*nAbcsvOlCq2&-$-_32u0JPN?6~<mAX@Q`1}d97
z;JEoN-1Or~Qs!;{0OXKEzKB+B4&#0V!UsW=y>-v-$dMz!=cFv@;LYVU%t&vC=9}B(
zzc>iLnK6k_;bX;`<MY^lOMSB}Ux3KEQ})P=_}8Tljer6P!@z2ZFbu#H^eJ`%d;^Ra
zQry_s82v3CS1AMncS28q{kLm_O+^P4%5Bb^cx35|``X&^FNJ{!6xB3J=w5->Dw`jR
zJAy!Sa&oc+hX(eViXC)DX23j=%xh<72bn<g8Gp1GN+?W5fZY!b@Gt`L!)Buq#mD-D
zhDuAoifZ&jGwZlhgtD^oSEu2{jaVW<CPbF&kJL|V$rw={AZ<=IVE~pp5j479$<>S=
z;vvp}Co6Pu4jnW+A0%AnpL5=UqI3DzsQ=0SlJLxg=xFF^m(G}=6c`0H*s-`1EI#O@
zE{?QGsmMMF$P@&_xH&ob!+2fkcmhxzNwT8sj4>e|9N~Rq%Xu?0FK7`r!+{emX7}j0
zoJQOqFpM-rL0&+V3?%0*$B3q)O*-vr2dyWh;*2mvG7;^XDRcOcZ=PpDvzI@bY@4ca
z)Q?^YC946%lL`ig?RWco?r~<s2e$-yjR;pFLPzj+q0q%J{ij48-`EjlfTO<W2W|EO
zL(5&9pQwUD2>%IA7wOU=87sQq5|7{N`1vBH9aVb4>$l7NdHpXoHa2KC#XQYc2@xJ%
zJQ^T#E4H2e%$dcNtu{X%#Cywfwr+>C$zyD6hkOkQm=Mv6BL7ujn+PTE_JZ(A550FU
z4xX{XNO7~UYQBT|Jrt~PsGpb+z%%2%lw{DixDhOag|$&JRA*2EO~t(At_cO4ABN#p
zwg8jkv5OWoWrLX%#?sN1+W#ms5M=>F0RgNPkk|(JsJthnQYT$wEmrk;<Z$UDhp`7Q
zRibNbIa&^W4~1X}KI_MmN2y-Y{POPaM<G;`*IHkEkWoSxXz=DXc36#Zf{iPFeU{io
zpgMM$n~;LcF7y7lr&T^QFD>FCo#lXK)8OT1Ve-qH{VuZ}<znO4^7(7!xL;-VkM)Ua
z!}nb)d_lnCZt!ux8>pWCJZ`N}v5pX-FJd5Sz!Qi@yf&6|_4ZEhod!^Vjy=*%nk;97
zxVcKpn$#o6x*Sf6uu6(-ktVh+n+hGOGW<GeOLIScF6#L=RjoeYP^u(f@_sgR&k=h=
zH+706o5y-C*d><j5jmk>S`wvfsq$@@)80cP!VWs-tz%G}<Fq1eqIveo=Vi46vy#Jz
z-H`?E*0J)mtinsVU}IOBVIiBboAJi<T!M!Q=89bc*9N=nQJ$C2Pu$FGY9X{uRMTH!
z04ML()=ASzX^$nJLT0uP*Cjg#23EqeEW|UL5HdcW9h-Qz9r31@2@72Oj7Cyy`9=BI
z$gJ#E6Q?R-E5g+l!w{p}V&Lq1gDJ=e(&@Rmlsi$n?JK9Bi>UFer8aGPmyX~3DomKc
zaP0=IUZ4Iwm28(nh%l!_usD5TDNX#rk;Bb1S`Gy!bY_SWhSck9!y@RHw53lwEp&OD
zue!at$gw$5I&g~#iwcwheijTY-vb*5JO@+$2Pu+h(<2&$!n!7YiG%074TJ-C_p2lt
zQIvlF^Qrnl(aSy|=PbTdp<Co7UYj|-$N#IoaY;~IDDd@hLnqbb5f1n5fLxozEsL80
z7;?c(pgJ;iik~c$q;F{bV-L;2`}RU<rtOcIV`_9T6#Ls))MRDj*+`T2^{9Ns(?b1e
zI=!5ktO{)@Q%u$r7Ei&$?<KAs-|1@3HMwtMh`r=zglTs2n0S>+Tr(*td#`6`yqqa?
zRx`9A|AepXDL2+X2x7&ltEimC&+*C(s^XX&u6A+GAf|mm9$LVQ^W^C!oUSkN%5=WN
zv3)uA=Y3`F7=6)2E(YA=CFP*i&OeAii9rd*QQ2<a#A?1zznV#@*Pr&K77~`GDGX`F
zmg2SaUJMlmQxSp9&4yINva##R+moGY4-%9GYL}bQQfk(|TzhY9dCJ~%t#2wxBFuG4
z1|=JrB!C}Os^{_O?)Sud-rMi{nQCW=e_sydcUu?yYiy@Mj;=QSBF1z+wC3837=O>S
z%C39^k>&;0DYj^DI4W*~>2y}m)LODg2o>7WeEZZoPwn4k@S}$8WQN@De=o%nGRlT8
zY<eU(tfmIid%E#+IfQqY`m*@Tv7AEOLw+{8nL+FGk>(1@OEzs11W(Vmj+p=I-(J=2
z?KMp~T((gg=x|Ncjl+qY1EmOP8Q@eBH@nrE?n!p@PwyW#IW8=ne5m_!;4f>nh_%pH
z;X?nvA7W=TlUII){uG~a<kNINm*vCmq%+r^k9Ml1Jew8z-`5=cpzBs5C)22e?isHy
zC5X-zHMg*{>0f&7`8u@?6CP>H%-|K_@BQE3Xx@5{aWp%uOX{V6c7-qU10T_SZslJ5
ziTHa@WQsdmc{^Je`k<Jjc9O^DOdJNPHe~hwc!&x`^^#5zpZNbjSLLjH51DTL`E0OJ
zgc*r3urWhjfo$5u(|((o6i3YL%zvX8QHt-tEvDpHoRqu=Vg4{~{!4R>RT5u^*j6W@
z6C64Z+AZW%i!hl_w*s4bgVGcG=tnylX&-q6Ca%)|pL@&b3``uyrqD$&BS!(!10aeK
zu`n}J?Y&=*BXWel0vsDUP^P8<X8i3I8MD=0=8z6sK3!beszo4bhSOpaebKZ&ihpBT
zPNzV%l$hwczvn5Zp%bT~q^7O)Qs-FfbU;t%1R}z~^ty5XCrK@awBOy+B`eLV7;!xA
z|8*IDRdg?X(I<jRAz!Q*@ftD~W%4`7uAqe%Bx3}b9~3rlF}6|>=)3F}*<x_SI2=iX
z9hre^hcx6)RJ~2P4p7~?SNPSucJ_C@_s)>wcmjayWb!!abf_!<4M$I3$rcDZpmpx=
zgF!b~aWh4lh_(b7DX>*l%6@s)l2%NavHosE*;YMMXg1MuTlxvl=X`1X$=7x<=4t=^
z|6ehzEK2jLrfw-uKy~quwH+k7buP<|01g4&2%0}hIVGer^O5>GjDJ(`L*eu1x51Br
zktrT}G=tW5Njbx{gSOB`hrk9+>O+X1ZaYQLDLC+KhmLr5_9~<k-<&+5!4EM_EK!*y
z7*LGaSFc_{tKFPy{psGsQ%kE^$c-IWr)F7#v);Z9G9%qWuP+S8r`F-PS)io8R3X86
zLFh-VYpg&R{6tQU^W(?p41W18-`?s7)uUeKhr79@8d!)$f&b5flUIHhjBe3Mk?#Y@
zGeBMII52+zH~aTbI?fCVD(*<usMZxw!bUt_SSbGX?M_ez<V67L>}<QK@GXO1cw0vY
z5Sd`<G!8s|y7<`2N}C-<e?0+f5efyz&%Zy;e}e|`ro24&)vJRZ)ZpM{35o34ZJ0iA
z`0!y=lYpS0F4gqN;O$Ki%N6PCK^wGn#lzY8zM}m{7|~#ek#~1@S5&mTb<5WXBOdZ_
zTVkfS_bI)Hn{iS2z2n*c=jD_cez_K~WT)3#`DPA-l_!q_K05O`<M#d*j8g`3s$Rw7
z59`W7XbE=w1)c?<p|wu4&H&p!dC~<i);Z$GkGg+H_IJFyKYhCF3G&<RppPG4mX}{V
zbt={GJ**vpFe8k!y9d++;MQvo9kzl#Xja!6Jau-4ubJ5xNvA=)#tU^YUiRury7=mq
z8Q}OLFoD6aROh(d1z};}nf!x3`|QjNh<paEjlmF)a7J$~r}|J@ubQTBdZwYoQSATO
z7l{{-9hbpm9rGg|M@2BlnE@p2wbk*E{rK^h@$m=NGKpMV>7IL4eU`rH#4e74K8nS6
z^0~pjlLac7NbGMZ78CzT`tT1Z>>Hgzj&Ql&dq|pq=&?#5&dl~dtp#g*utK%6wuWaA
z2ht{@EVAXphjuDA3uus#x1cFi=5UB+zb&N6vb+>ei=CRCtpkhe!)IzicM%EgU09Pb
zo}uE81Nbd%#E;S*+nIIv+?BU|CqsSW406<i?oXz4Mohy$x*J*e;>iD^_yc7UpXG#!
zov0CJR+czEQ%!@AL>&~7%*>a7zXcR{uxY*HS7T`XIO)Whr~73$cHWOIr(9mCYq!>Y
zYb_WmZ-Pk(2;k~ar6IH+v81>gTjOJpSp5E-Ib5@0YHkj5NxYjGS}?QKqN0NI0SB`~
zGiDJ80pgcj?`_R>vb8-t!0kur-k(YzcPb!Hm-IKE?+&w2O^i=SFMDot5XV<&TXg!J
zKsu!<t*M|o%w_GE`#I7DrP7O*5!YLU^W_DX==5nBDbKGeO$0oL5{Z=f!5D-mredU`
z`@oRY=dYR(WeCgU<KxT8&i(-%{I_pg7FUjBV!8yo38)sGUWo{r7SlZ=9ef<bGr(#N
z#7@BF($Ud@ZcB@g5r#I35(5O)_b^E1*|XLUgZ2&%W~2$%TkP~@gXDzhfp6<m;I2~t
zY|+NZh;`fOxbU_JXe~c+eI!X~9lJ(9hAMMW&D9iO|Huv3Wgeb2zoguN0Xv4+c3G8c
zH{9;P;E%Gwf0>SSEd%CdP&3_Of%kHUuN?imovkqHL?KTA!Z2+TjP2X(f3z*VhGB`Y
z7u?s~)4PviQFMobSx)J`^YT>bdL9}1$v>FoI6FHqZ)6)YpoN)~^u3{>;pY2&*u_^;
zi#1158-bXs(fbt`c;Iy5{Op-H5{M1@RrYdPeL!{z|M0Ku-6o0W*A56gxS%^5G`R)S
zAz@wBgRA-Mw-Pm?D%|MLU%!48l$?g>8iWRp1kgMN38)|=zP8Q*6|!d4hflVLf2Dj_
zmf%e1oaKeh(|Llt!!Is=AO{6grV?|G_;9g!=SW#zXjZ?+crSn8gqC5ouA=MSDZ9-j
zBmI7u{!tb<!U`Pdxc%LC`zsR@IRJ1CSijB7Jr3U|&5UXd=N2)v#_>I}Px(*&!7;pr
zONtgVmYp#;IXUULoG<#IOZTW-QsQeF{w&e{=~EGzw#gNUfG}|9%q;<=3_Px+BwZr;
z6iYCUc<tIX>26o)G@xI}X?R@shUp4J^Uhbe`C>_AKu${fzkVg4fauuNbe6kyZGC-h
zZOsS;^_>0%PMN&&awwG?xci5PJwXcvGWy(J;Q5-8s=apIR8*J)#@OEp5aj>3Z#R3|
zs*XrA0hw6_2-8yBIsVD;Xc);_0$8jO&;tPBX~k#;E|GlTNPR`2gpE}KUh_`ExiL^$
zhwoIoX~{<*GU>$Cfn|B)B9dxa290-U*MIpUBisq86UYAtg;63;8DIJ-&g7v{Cr=CP
z->c79OlSc+$G6%c!052L#vS-wGzcge5vnOtMi^kiBQxsjz0xKxN6y1%YKo_IbJur$
zo#htVlvMAu<Lv24i|{eyiX022d*^xZ&ucOY?16CdVgq#I=n*s3Ui06be&>E%;g*>K
zddAusGr};=%q1-tt&*qvhSyf+`o?7?E$Q5+?@fjGUyxJlF|a#aGLy3iE#isS$=3oz
z6z3IQrL8f%&i@^$eCFrve&&E*_Y^M<BA3OUOQ^V?)>GquvNBEE6#bfBlbJja!XQFd
zU98!}0~_bz0RJgO?l#$s6la!oSL%Go<;XGD(+Fz}M&_}k-ur|EbCNyoa?shD!&o|e
zhmkc;fb6XRUWB2e2{Z)|cx0^rBZfADIny+9mrhOtSE6e_m~f+AH1<m1?^fXe7t595
z)%M*9jaPKNKSN|PYV$hJpZ=xHlJ-PaHo{Jdo3Hl{Q0qSquWtCE>(N1A{gGn<`4DK&
z06ujiV0dbJC+im5o;&JKx_bQ(4a+2;!aw7>K;8q^y`Ve-GP-M;_q6ck>SCCo2?WA|
zva;B*%11q{rqUf$<+y~_=X8kovQ94&zQTh&6DkYF;o^PYYB)RCROi=W5&TRv*IGOB
zB}KruMQ7miz+(F|(R5~M`A*R+Z#ET?^_?j-xJ#ZE!?}|R3tSE*13Py*#BGjqU*F?W
zt+TLA*_kT5dq+9z(siq;8ebWbE!s|YB0nIMBg5|4RV^+4wJ*5%FHZWs5~R3`D(?R<
zQhgT>`uerYEy*y%Wp{t;DY(!<$2_R=p0Yy;KlQ&kUCbEpEYI=h1_7h?bL9rBMaAWK
z;2jYrev<Cpd-HVUdgi3;$u2?!0Njf|s?L6=l-AwM%$fgL7d%!u_}wA%TJh|*PV{^r
zQ-He03m76@qFerD@hE!t$?2=m+@_`;H^C!+3zcvKmfqX)of`|pCk>5dV31v#HVG7s
zGqV7;6Hum(rKNH?H8bIyQM9w$Q*9adWf=p-9C9>}oP|lE8V%vQUU%dB?f6xt8C2I@
z-IgMbx_{GSTxR-W$Nn+X2XhW$>E3q9zT0H6zO0gHqB1z^t7>SJW(sH=<4&9)Cte6x
z0(Tq8x2d@2nllGx6#c*h^<LBd-+%p2>(-ogb#?D`<233sg9-<%$f17^e9vu$-8L3>
zfl{i$-cFAV01&(T<43ZY>%@vlglH21h%Dd+b|jyE)9CMRg3aZg2(Fzj*<r!;9ir1j
zC_mddQ^-qQUAHDbd8&OZ1ABbHZG}WdV;*Y)8S22pMox}iW58HA{a6S32^aZv=;Rh~
zg$L%H52k^2w72Ky<pD6NOwDQ)A(3B_$zna6@o%)AJbB(_4lga0LJ@!ZsEGi!d`sXs
z7PEhV`DV69)a+F@s#&K$ex5^_mJpUM5OLD4&@BRT$U&RAt&I?1yY=_ajjeVyP;}%_
zfMo&}3}A9+;I!6~Hz8fzkbB}N#st{|v5b+4shusT9S20c(!t;ID=N2;plcAm{xdB$
z_L|Lf;txNwLHB2iRl`6yuIT#spu|EKp!J@tl2+ZcR%UI2xkfsr$XE#TWZiB=ZBB~d
zF3!Vc4=e(g#cN{L*QGo*wc<{_!-(39D{q^stfi=KkA@!S-%npnf{ik|BxZKA@tC!n
zZCIOVX_bJn$>cBo{CGpvnQw(}*&B0h=okb4ny@*U9SrG;(T>V~^-3@d2Gq>-S$+9(
zH}tuT2D_NArq;_&GX1TAif0ey<@vm%&z)!iBCRyEBEfqbR1hG**aPQ#o3g>Smdj#F
zd};PLX6w}?aQ+>Gf+Hz88Acndz<jyFw{PRjNC-st3V{8<vrC#^xEi1iBtj35e+glM
zZ7NvV(i2K=?lmjlk{F-5q#>m8^?oSYU-UkE;P{P*g=t=XvP(}Xzr3C~JbIXm4NV2p
zOSdd6+M!lqVqyyQ(gEQsbXel!FU3*Yc*00;q<a)&YIvF-C&|~t%LChI0M-nZC!vnh
z()#iso0@$l6l<4K#v2el=~~i1^zGYykhFy5a0OYP+W-<lSa{iRmHXsq(_!d@GY9%{
zx84fL`~>!=(d1~cXiXxq#fc{WglkzuAN$#f;3PJyyN<}1{91~oNtaEuc`K%X!iX>h
zEqZ&8yG0V{13sII0oy1Z^%`_IP?^1a`4WlM?}zeNS4*qh!<DOhCHqm<bB<H{*)HQ3
zOi{Aw;mos_#wRE5tX&}8#}RpNU;56Pl+#W<1U!DOT%S^Wf#po<)e47|zih{jJ+i^!
zDAu5H(LfUY?*v=DIZ)s}JcMAEJGXJ}Y_x=nb)&FKFUsW2xJfq)_r_dw61hHMtBiQQ
z#{Q3DZm-?WdePydXCy9O;tD#w#&+0bMzp7g&=Qs@@8BbMRQ=vd+~o+C+{dn&Gtb_P
zv}43kCf4Z4co|b^t0dLpd;!LCy}JTT$JXTpaA}PTmqeYXviVhCeI0GL5nXseeExJL
z+0E<6Bk40;avADg%59zCIs&a2&~k(Q;_Zl1oScM8FxoPy9>fqcGt8)_$OsgS&FzO%
z1%O-z*~d`egYXvyPhk={jyVKpQlLQ$FXb#YX@6mH5A+uz7}OJ}f6L3wdUI5uomJ(w
zHdF7p1AHD9tfLe+zpBScMtaaj3TK|$-5uG#7N9PX2&BKS{X;vDHj1KZpf3gtQs|&|
zQ!Jrd-R=e?A}1#&Ah=S^0?o^&ffNR!Bz(t->UwCfg@q{|h|_C4wy3?+coC73!aUQ<
zlI)Dbm3E$nhMzyLt(~NRaM;spg!)RU&fuxOzUSay>fE`(rl#BQ!coCzlX8Gn1-xt~
zKQt-`s*o!Z5|D}?aW|1nhQ$m77l{dFfvM`Ap`qCLcx^qs4m+s->>oYScH9<1f{$CW
zxR^K=QCH^)UCUUrb{lBy)x(a+dYwnWUe72fSOF<BJ-rhA@8a3-;Nt}}J+-udan_zA
zZ!9#;?{oO81MknuiYWliDop<iN|}JB3{dhLMS%VXMrr72YYz<!3=9pyE&gq8ZqCSP
zNSytdlmlT(@6uCy?mMetz}kd}1#XNP<>lp|h0M+#2OQyTYikLqt_Au%dT%4fDxqN8
z-oEntiXI#!u+Rd4K2_^DO&wVTtvyie9lZB%-nvykY~#I}R|KjA3I*7;P#=behl7Dg
zZf?!nw->ls;7L6hP=6v8I%+%qy}SS{>$qFNYb_%$Poe+0y3_&Z0`mIIJsJeipgga?
zYZ^t<H4so5?2z-pTY%;O&>VsBqUj+1e&ByflQ^SGAZL2;0EKm|xdty}b!Qjd2%Qf!
zJ@vo;crYjs2XG-rVcrUFQZtY;Ha7#F)?ZfTV1i)YUtAOxrS|yAll+2$vufNuRIpKq
zj*DBLui$TsDdE2UV`xZETW{$5ckmJT`QpXB;3ih#b<`D^cwFeJ0&IIl#jv4yU^m~_
z0$zQ=@bECI33C1eA$xZAAs;<mUFZqw#0`V|z{ci60O(z&w%4p03_n{-o{@4fv^4}O
zoG=!9Aj<&`Ff{I@yCJRK0aC2&nV(cMtA;NS9<(1#K0kS}`nu2=?LvyBrly0YCOEC}
zKDn!3Cn_Sc0VYRazz}TUDyLa~j9=AyxH@o>UZod0kL+@=1>L~bA(W*Oj@pzIYs5_@
zB`baXA__(5eqr0EPh1#`PMzEFfY(qmy?RA210`f7obW+rjw&F~RW;E(_P*ty#VYc!
zfeH@spI;VegJf*@^gBrC|Hpv`=%qye-32*bH1_6L7DSCu&PExjeECbyLsGmJ&v^Z#
zj!B40&3i86FLC&BvD0=IFdokD5D5I6C2n5dYxA=jq=jK{{>W*djnRH#nLx9AxAJKS
zI-tN?l>_cD+}%Y2VF{!>`4qS5FMl9{gz02@5sYpr+<na(&^Y?Kc$&MFgpY&vI&7M(
zl9Cc2fC4-QEmFu-h8N%6&;uR=WCNB-&ZCW6X=y+A_IwYx*kJa@@5>p-fuEn7JD8IR
zPs?NL3m}JAhbS>Gy^Jk&sx1E`UDN`J9aLM8=%}fxMh2YiU}OS8$((J(k4n4SWT5CV
zF~*&~=Js{k-k{R9!Lqz=YeEmY1(cj~IGpwOH$BF0K?8VML}Zcw#+JAs8!!b9o+#LN
z5Xmo+lD5G{cGIICe5)D#Y+=fMUOux)=Spq6_4<xyb31e-!!tks{22oz{WE9M6B2wx
z0Ura-3=*rQ<-G7ii&XX3{B{$ZL!cA`0VW42juZ!EGGOsP8_K!^X~2Q-g-Eo})0+)s
zniOsMzhfyQSbmg4QwY!la2Vlj246u<b~#WFuE}cMYa)Pd!bB{QU9P>WLr9?QD1$$~
zgN20!xIPuFUEc`2VL1>%;8R%%p5Z{Op!bEgv&n-LPuS@Y$Zab0*gpVs6!>Kiz=0Rc
zt6ple9OvK&Y8nM?DD7dEx8>!qAqN3<fsu*R2b|i%LTjKJ19KhT*HGD`XRx`YxUV}-
zsVge}1vt!gbIEtmxM2XgiwDQZIpQ{O9$5WgC0uE>gWf&ZYSen~?}2^FJvq_ju55Wz
zTsDrsX4pn-6&r9rxu~EZ)@%@Dhak9$jvn~&6^HZ_2&3Y)?;Y3+Y=Db11l^9VuF!2$
zz+0?`>QjvpVAa%^62Ac>q}E_DQG6u0Y4q*eb;!_fNvF7`>A^w)%K%`MK-&EB#S89>
z+gw55Z3EY0Z?A}BgLFvO;64XSAkpmzDK51A*@W!wY0(yE_kS(VlR@NAzrP1I9D`tr
zA9~yorYk|JzP()ym?&C?NQT#1Za0<#H}&<BM4>_5K?2|Gp$(*UI};~pSOSf3RQo8D
zTII#X-zHZUhbp>lDwJZ{Aa%V|IAXi|{UCbJ%sdCbntM+78L@N-K;*z~1vn<U`1=S$
zZEc|HYS`Hk*U58QLfX!bZwe^JQBfmx?(tpb*PbolyO|E4<Sz4AGc%BLLOuvbq~h(S
zE=c~N3Ic{b_=5o22iYK~H+FXSv>#prXAex!HT&_4>D}%#<L$swuNf|GvnLIP?d}`}
zK}PB|_qRZ5g1TnZ)@AmaFr5DIm*!y2(%mxTVlYw86=eS?GZy$7{V7hTLQT2|Yxg6j
zbZd&=%SGeA0vq;^QBl67?WWaEE9NANX*e#U&fH)a%{w{{I|+2L-RU=uVu8Ki2nK%c
z|29hj(TFJRpS8PkYI*rc&n)`S9rh1EVGjR5g=G@L?z)<HQKSTcfM3{xNpSFJc3by1
z&y?ubY|pnpr2!Y0y{?geKn76-OK>UfZ%##7S+rQ75uk3zo4J~r%3eZ6_0QT@0UvZy
z{c5IvKE)Y~D&cHY7kFddmGtJ#8z9dBhiPqX<6ymVw_cRI9)Jc0!?VYar+_LBd|Gn$
zyUp-)*cGs`4j~v02Vc;yAIET!YMhHc7(+;;7SF<Nf&@3n2#{KA0B96|o95{`4B;>_
zCUNlRx&m4@0v?H<i925?4Y+lHkZ5jhZuQOTW^=$z!sq_}hx(~q)WTt#lEOkM5GcZt
zB-+9eZU*L+z+u5gJ^}2eBtQRRvI=C<DheS-0~=3A9Y*|GarL}@2H|6*6V>VfIu@{F
zfG`1cmat5W$_69W+Q!D9+|mrx1l^Mz-5s;@^QTUq9(BFW&S;D>e;MJsiRNG*hX{Vv
zkH^v3S-;lhRvd)v>wq(tfKsRiJUBQ-3~;5EjiaAI95ysGv~zeHSip)(9bm|zX;9xd
z?|ex@0uyBL@L>g5=zRTpj}*t;1YV7nFbmh-{-6YflqSTWh+-+gUR+evCy_cf0MD9=
zcOPqUsu=Rz-Cj%ITg?R}j42jm{Hq%q<!|03bmf$O&c|SJVSFXscMNWzWx_v*NlOF0
zkbI7G@H%*bUk@f!kPrrG=+}X)BrU?biE!XJ4l%2xB^c)XIy<IZ_tfoQ%gLEYN#RCj
zbo}}1be1i&^1%h_5e|gy`rHPz0zmJRUtG+mC*Qt-YI^hbEyJO`l$5!*>u-T9%HZFy
zuwWBs7AkJ}Amxe8&_LVoh~DW<h-I`i`@4rXfaBF>_aJ4s9-N;ba|I0-Ag(ICns@KQ
z@#~c}A+N80ip%2av$;z2BW?D<&uh?GfUOSS5BumVTz!B4Z6wgWq$0%=y8t46u5uKl
zOzpbzU^fLEWz?xVp$im?8Q|;y4g(3OzWzMCS8%UTOW8Ds$41S3Q19_7zch5x)fxj&
z`#>TUD1-68vA^P-4#wAv7Y`hpVDstgry@lme}K4MYyXE*JnQvte`m4V(aEV4uV-Lz
zAuKa9Pr4gym^OC6##=7{bL$th{6Mx0$dA8hy~E_E?X{DThoPIMs!uZp)>PL(lGJvH
zStVT|1218q7)XdC%I#-snDS}SH_WXSTu!+db%p;pmHlHQ!X(a2CgU@ViTn3#e_;e}
zS|}_`6!Js!vWba_y@&h#`^iQaq!AC=aIhx;jqkAgVN%5$!a}-#e?5J#*V_;6=2<`T
zZ=ymq7X+@daev;v1!+l2TpVB6@1@sGxFj@mes$vhz*fr10Xl|4<7p&JzC+v$K!fB3
zVT1RcOF0j%jiBN?yda&B<@-@>lb~#@sAvyaR;wM(>TQk%U<bEvHwF0?-M5kg&kx?^
zBS$cX0sm1bXhhm1Hh|0y81<YTuZAUXkq5240B2}3y~G`fkUn3U<vyuUPs$u1pvD}p
zfWwTEqSEEG*}17Dw`&KMOR*^_5j5*tp4s=Vr=P(Bdm9YD2n?XeWT(G{R#*)$wXVn-
zd>KL$X035d&dvj^gwTmQ#m&9sRtNG^$V~z4X&#I+a)}(vV!deo^DVvuID)XMlO|n%
zXF(nE{-(F~v;MT<8t;vo5r7T|D7t8C4lp1=Hrh&=f=jzb1W5l>RJH&hV1Z(ooh4W&
zPK&*dfFgz=4|T5`awWaSyKk>P1CadR?7KZ7VDv$C4^Oh7&m1hU+-8NTqzf2SqVh!W
z(UU;gHE{j&5|RM$9EQ^1J{cE)CjQN~IMGTq3FqYVo%C<`1p=Lq9YQGDn&H#w-K|u7
z6O1acF4ci?r#wh}M^KZIRv-949rzLgwGh>WmSe?Ay`_!zM-x!IKg&$jlJG*A0&LGE
zl2-h!lbmYwQ&aT;XqtN|1SC-?w=&eDrKm7_v*XJHE!Iwgf(E;mmNMTlKcwM*7P|I#
zAq?A83|UKtXXXin^;sSRmD)1W&j&p-y)fZweBvbn5ys1ONR8noUI@ryI(L{Oy3Cn6
z#LUdh0OCR*Vu_%mGB+>0%DQ16X9g0-uRT53Fk>F{P2>?j+x<O%IHtL#ryqKOJdlx$
z6NT##Ya;N)f_5e>6Y0l;^c%FM<mJJ(tTHmxU=I!sRv<qDQYlF?Q5kISu0@a9!g(SN
z0UTno6C?(Z<6S#_w0k8nkp!cEybVb}oJsEndfT(Lk1w0GAMS2-@B5D|zJmiDQhO(k
zSLz%*B6TuSf|?)LQ_rKO3mv8ZeKl)R(-xTtzm<VUh78U?RS&8$Fzlw}$RHi{O)xoG
zS!3S2CElS?6+&T_7&kzWlTL;%v0kN@K>3eVLMIyb*Cou@O`iV*7~8#lXj)8I@u1ml
zwMbHx1b23&b+gf)v8Bpdf76pcE8V+js3yWEWYqhawfg7`cr=ySod2f)LcFgoK1;_H
zq+y!aR(0lukkko9em-q*Een>(08i+9S{ISNKpm#A{W&J1AZCj^bmQAs=_4n5fBg6d
z5w(EgJo=9wLFl0R@w8Dpd4g`Ch+{q&S&7a8TfVVOO=FZ}YCuH;0zo$Rl5sF%(>{wv
zzIo<oY9>rnQo4gIFTeI%O0|FO#S7qe-_H14h|)wiD#(KU-U&TE!{c(GSnoEVW>;02
zff5laxUkG<C34%fAR_{*z#@raf$@PJ78r9kTT5CcSz_ct!lU~H6Px6hcNNC%=<Dml
ze76!XDF9ds=D&8q*owfM{1}DtaFP0GTxj8)scI<mL2&{|Lfp%jPD{UT1sT2DS-7gf
z-bMrVeVbFp5yBkeqPx)8IUqI0mq<NZkmj;5FN6MU1Wo9OI0p-7q@2-*QWKu<hM1^{
z$TMYh<VXUayz{w_9#&Qz>+@It+Jg}i+wAPgOchYp_s`Onb+Vjr@I*7qD9PhVFAXu0
zCm!F?>MK<jn$vmNh4V!U$~k6Va~4EkLCz$Oasb^33_M6yHdoO!xqYU~V;tI7P`1Yk
z972-fp3CxrfbE-8*Ss@;-v_f)H28JM-LzQQw>IQ%C`+s#S6YZA-qXU~Jrog@eP#Ps
z|JNUnEiFMyH3XjH06gr~jO<1lftq3@H{A=`;|iLOlQ<Xy59U`xewF$AcT-9IiBMU<
zBUSj0J-=`}1215ZBal^Q_T^Xl*dDD~Mn>0zYsn?M0gipoWk>?iTL6*p{CcP10KYEr
z^K=O%$><l@a{c)61InPEKMmr{3h&SAJicXGnvlg%F`xu#Zf@_ib4}>Z)Z-I6!|#I{
z?0$fZ72Z2VOX!KD5W-NUFUeL4nv#tx(k%>L*14;X6BOgjp#P$@SC-^Rwy?1-zAX0c
zs}n626RH5|MW7s5C32xN;qOO|!9cFK3;IcEX~hDHfTak8>FW<8u}z!U_LGrBtdui}
zKp^~IY`u9nm2KGey(&qiEJIqAIiZq}dCbaKA&HR493f<`s0^89hzt=GMJZG=lnj}N
zBvX>iL}i{?-@fkWd*A2#<Fnm=+_j0d)^%Oyc^=2H@4x+0{%441q}cX{fS<*y%&r{V
zW`5}smtyHBVOIj7-X$;nINfz`Z(a>dCE+j32-m8^AEA#2L&cn=M2w5SzhegjzH$W<
z-bb?Tm$=A*)l-87OC;0m^xd!m5gB3gJ<8wn3!m58y|qWfskpcs{u#DRssi9td0$ZX
zpOpI@0);-V1JBGzBtJwT)A*GEtFLQqJ^bBmoL8fqG+A;lIyyw8si6Va4wJVQ@t4{8
z$AAE_drQy2a4aa-;03Sp6SGl~gLm92xb}5#YqUOPV`Fpk<_E4I{p`1ynbr0Z5C=ts
zg+0qkymwEa-o?(&&fPr%l6tS1jMlN!T3S37!I#B%R;!cAce>15+%BS0{S*~6=w5sx
z?e%B7KjY(@3CcWCFsrNRz_?sjUk`PyaFvx+JwSg-SIl)sRH_5bMu{7hh?|vudEJg>
zi`)}pv3oz!Tzw)nC53}<90h*!2u`wnQqW2sI2HGw$oIwSE{kbm`KV2L#P6b}yooPg
z9%UWEsfw-o!b^BX#E|siUR;0j)MlmQK{)ccOR@QsMw*c-f?hsiycywoQH^f%#trfH
zF!*JT7qyOYMUL3N;Zx_>?++MDkd+4U7b<9MeLc^fOZ%>uqb`IqL*rR9$N-g<n9J$t
zfE@~1c%C4`&K>A29}Jmrkv_tDIQZ|r?xvQ(uY56>gsAJaRaK#LGmKUYotdw%FW?4k
zcG&R;y%dCmwBm;D+_{5L=$}7-Chn7befy95b+L&<;Pgtp9(Yn~p0y&@qSiOytX4MA
zy`BHVw{wLDCd0P-*-%<5Erj*9AB^Q>@Bd(3(9KO|t8V-8KG&_j{p(jI|9b)<|5Goo
z6ql|Pr=^*Nwz&YZgBWZ>eVpN;2)X(XWp!t+h2&L<u)rf55ZZX0F1VhJl$0E`b_!}?
z@YTCYDGR>q3%-<vycY(7!`ce#260w2jP))S`nx|lV{Taaq_wki7R_9Y)mHMG6@8s3
zAGzp`B_Fu(Qa_J54753SF8_ONc5q`4bOId-f<ozPeJO;Ti5YON#>26LO%MYmC1KL*
zu6`ktlFr^<oFAHJtn&j-zg39|X4i%1>R9uPU_CD9xAt~6X%|b>rE*8%n}fIY`LkNG
zUK_eTsI=vUn*O>MqwesG*gyQjqWU9WJ3|;%wj+_WKWefzhJWFo;^cYXrSp{>(~XkV
z!48#nZ|~JSwVc^kJq2f=aA!-))bhToG^@8UI0-X@W?ht3^KL$5)Hy%e+mWyAliKV%
z+>iirsEW?1lOZr<9u~dIN@E5DEF7z)y^1red<jhYIWO=y+#ycM`L3@@CpGGyJ4a0`
zD(@pbfB90@^Ve~Y^YIzaN&6uC!sU`Vc(AbW=@6EB*3coSV!)MO>T32Gb}eeKZUqfz
zd3l+5hc)#6K+w%y5S~N~5Xq?ZYa1G1-$kdMfkT0`XHV3Vnz?aFgiRDX_Q<4+(B2LF
zxSXfB{}{wO4{`1!dIp-|qg6g<oKCOk{q3FC%y4vnG)Bi!wCD9U6P*73FwE~_qob+$
zbV^Ih+7O-SYp+UuW=9k$Uc3k=&7j7$1sJkuTDU6+hTyQnS9S?AM`|w%H4uIbfQR3q
zpt%1aOtt@zeZC<u6AzL3x!JGm_U(1_n9!eTf_JVF7Ectle_Um1o2n8H`=cNDQs4Xo
z3r(4M?!A6zwyPo+4C3ZI<!qX6l-e}stgdd1v%=1y?Q?w^d1#ov;m%n-W&Tbc;DL03
zbO9s5I1$P7mT!#=BgE<btPJ5X5DY;%1i|-tN~`a3GjB`H(#*(3q4V~vm19qL`Umay
zhf`*8O*ZKKZ-}~9p&~}RtEx)%M2DJcApAEEDNBkJL#neGy+gqezTzHaqjceV2Yo5L
zHew<>{T;si-as;UoE1<ovckfjsJv8eZJA(9onCj@W5&iEtbq+1o{>ZKE@+Q})R0P<
z%~W{RVJX^M(gkSV8+1~mqx+9@5ji;(g}?N+x2wjz8NG6cY<T8>0d$|8OZGZ%x+LgW
zP~p6l``18fCd0tikyrHB<f2aVrMK*as$pge_Y;AWXcK8`GiZEm>*{L3F8B3o7L^MK
z*aHU}o2v{vZ#q}P%-ezjz*-9m3UFQu$q>CuEb93i7snc3zw7!<!#K<+upYZz9Fb}o
znEC<l)W{5EC_b=_A9;C1u6Yx|SjgtWg{0npHl(UPlI_*240kJt<?Ze5FyK=SXaxn;
z8QVMDdK?Sl<KzEpF&bT)?izE&4~d#^2O<j1gi3Q^Ik_Jl9oe=<yiB&>u@v{5IN^uU
z&d$3hTEC%i=YTnD3P|Q3rM{{5DfD+wz+0-7$xJ3qu0Xi(!Q`m_mjUO6*;#OT!kn*M
zp}K2&|6PT}{pHKxBZtT}15<*gAAi_kCi2$89u;nQSlB(*?KB&CPkaY40^e;$(#p(#
z`A0{9<@eYaIycd+V}o8=9pO=oYQDal!I#Ed3h^oIQfYVlkeyxs$KAu-eSQJPhcX;G
z?pACdoMCxdT6)#f6BJZ2F)1mjQI|rP7l6NrEU>Y*jv@&INcVg)n3><wFrraf$#@4!
zX#xSmhy&ewEqp=VL8Xol0`Gc|H8Dd{LIEX5zn71tW#^b{k+Gu^OGs!40^j9DMR5&p
ztbG^P)ZG&pb>MmK^IG)c<Wiv5L26gz=p<UV7{&0GQja;NrltZcU>xvYq@MHeARZ10
zgH!6++tOFfoRgB0k{v(Z-xlH6!}0gepB*$C(H@UKYWf$4$?b<W0k5)j!`XQrw<7KZ
z!#JQSw$RcFS7GQe<ifZgr>cp6|8S|xF1;=+?E1G58AfmV!TW7~zF(MLX>V^&k7m`O
zF+QfkHw6VAmX_~*AC=}mJ`wlyzt2;#HgLpA3M-fE#f7CC7?7E~>KJncNtsSZLt_la
z!xEEMW~8pJE|f$c(BAv<<&u5V)~}2>jPfX*;dA#FtjEdY$*YP!CxEY8E*{YMjRw}9
zJsSwrK2d=O&Bk@ye`vh|itAEnWOSh-jcVvcXBl&jAlBbbQbonZ8cd(j;GAX~D{AlU
zRg{9;Xx{rKo=AmMT*mkB-o4Auzm~jwa^p^{!p=wsLW7xE{P5ih5uE8nMdfgfg@u2)
z6zb^}dgYgm%yIkU{<x`-S|L(m-z9pnqxqri?roc|T)Bc6$>uykzkA(7c8-qIOE++h
z(IVp7qkvaEK7LJ#t#UjK?nh70&ha^SS67-lWq_xC|DFgdV6Gr@uri0jjZpxb96e5)
zkoWqER?tJO%;pgg9MI3*rX&8Gte&<?_x~@zx@~=>q?Rdj{QKAbx7PXMgFZC$J3gso
z6C+M3i0D|$4{?;*9Hyz=m?99O?A}_Yowh0vW>pu5vv1!XD?>j0jqZZ;sCnAm{05|=
z&pnhYwLDmDDf;<01240YSS8PG<6e7->fbI=>i&zdsv}XB*SSTs8Q=Oh4Ag$ib6((?
z8Awh}rY1LXQl>ch8=pda9khgM?DFPX8>aSvMPjt!(Q4<)*TDdY>PSWG-^{h})$L*B
z&wEzE%0Ia0tVn_OsiA*&@m94thrbXw2_rZ*K?Ta{v2@{>!^$2SQ7fw3RriKJk&Vpo
zinU4@kP_9n&l_xMv0sz7o(T`63Kb{$<{9r(Pq8BUF?O`OF$zdK@d|}UiozOu^Gsp}
zdYRW992{^xNRrMt>iLy1C@c~zR#$o{3XsMnGlSNVTUZV^+7{&x0S7cTl6J?(e#Bs_
zbbam>E`^E?3(ajYH+w(kQ-XzBZ!(_P@y0T0v>i9z@%RW^_rzcxA?$A-Z}@6wG6&h7
zBv}6e#UG9|3;%leA7M+%-#`$K6T8E?oqm7Jnd2?Fd;jcZV*DoTszlsCAZ;?_2!C<H
zIAHT_8`9bBcz5R6ycM;UqG)sf>Gl029Hy<X^uX91&$VDZ2&#=zvPYc1Q6r7B#+R@9
zu5<^pL!_TBz?;cg_)#E)a9k6>?9g@{bpCa?lr41+Jij!X8y+F15naQq#6g^93*W(i
z+wyJl8!Pkb8@x<QuPAe+KXD5JMFE4|z_!ye>|uXBX?UBr?AfIJ5F(zAImw@%aP`kr
zFeviwi+<cFYP+GvaDdi#_LvA`%;B(oo-Os!bBuZ6F@dC~XMDuC#Kgpf3b}+17JMia
zB00^J1e=k9l!Sj-^Rv-UJ|p_-q;>{3J&b(r!Ms1r{H()io^DO|pNpy?(o4ac6J~!D
zwrxGl$T@dcv9{q}gx9vA>VVVHH4O}5jbpVDk1kI#g?`@K6Rg%mrepMY;k-c$M?%7-
zAC5ffhHJ049IZ+^JU{zv+Xey`?Y(DuciH5+zwFd`CG8JTBeytD>J+JRLDY!JMeS_p
zXsTtE#v8S;T&@RPY)3HNiI5k}dKz~4kd72CHy%P>CT`~T%YHEy>Kf^vFI8{MR(-|5
z9roekgiWBCAnRdL_;|(4>SY~^>v3X1=>k-=$WFG2(b4x#QyW{fNr7M@ofBY5EX=>m
z5}kL|So5)ndQe4Xx<FPIN~cR<Ais3^?RIz*yo2L{E*;=A!AtfW9p#pl(W1(wgI+14
z-2+wpq{gD>H*kbW%wgPh*;uV|r=qC7g<8$~O`i;Yb>%KA=*M5a8!?V1gScjX_W<M-
zFOPrnogOSm%!q2jeyGP{wKMSfWz*`N=Lt>|t!mzPFZZ-u4LULRem?Su*X)dxl89}6
zL-OVGs<L9<`+3A@l(<xlFfYFtzL#IMY8RJLSLau)Wid^eN%dycSK4otwpp1mWfP<M
zyJ&K6o93+f&zuACBF*#f{fD}%V$iyko(?mTc0A&n&L`1kZ+rHkLw{LJ3deQFi4j|C
z>sIaW8AZR|leGkAX6HV42K}4~jt|*P9-Z<G+T;Fpf2zTFf>_HrNa=ZbuuXpgv+-4>
zylBxFFd$8b;u>a$!j`PX=xb|gCXx5ViWMemK6r;h#mA&JLg;#>@M&QZjm2%7)V%#w
z?7}h8%zo|yEWE?!OtS%(O?^rg-<b}#Gq#4^&h#RsdOoi`x!HQ!Q|o(HQO=AU_D%)@
zZ{G!*wtuZ+<u6ihZVSl!LfU<fRy{gw2Rk{4Q!=jco<_KNrQ3#II=Vk%t3TZPwdaXU
za_z#g(t6kPpGf;FC*=wz_l7{KNm7<yGhy+WJ)%J@he3g!Rzo8_z{|WWCF3Ete^JI}
zJ@NM9MK%9Xe`vCwWy#3Non}&x7!P`0H*X$3pXp2H_OE<67mzIlk?EEUy1Sx3t<H70
z($9);)*U<=z`sJD(Rp1`WMIX0&#&Fj99;H_(`#Q&3FeQu^4i%>B<00(z7KO^H$}Y(
z&Qp&zr9k)_zPst=74F!$2Lk+w`Y8^zAV}M4l@ev{R1Q46?0&tLc2$@4LDn5e)z}97
z>ip#+U#DpvI>P5@xbH)yrP`g^vy!)*Ww>t`uOywDGIUz*d+)9Njn+o*$I?p<jfwi8
z^y7YYP{$W4-3k4o{<%4J^rw3C>O+Z|$WBJffBm6f8A%rKZ`$(WW0c14sJiz^^q_^3
z)oLs4{SBASX@_psw!WBLWkQ>|PDqy_CO@JttM*}+?^DyaoBUQKL%fjmV3YOrwIzt$
zPN=7yN!fO>L!*iIJ4^FUCLt!m>*H(+yRWI;dmFj?>3%N%vP-uNp4cwvAZx~)DPZ#8
zev5MHn-4rU)AMypE|m0~%>2GZYUEvl-sa&m+RK5k_GoXewK{o`K1Cc}5_S<uQsC3W
zrFfA(hVNY_MUr@vC;!ao-k2QVoYalos=as|K7s8!vvxo*v9#f-CjK}aAMjC_mb0Va
z*ZbZST}D11Qs#z;)?FjpSDzRM<*x-(9clk#w(<EDFctgYS@_yy^~{%BP7V5X&KKtR
zsy1&vCe+G2CnM+P^=ZO4{r`NoKrE-H&VukK=Q^$%3X(L(wsRkw`QST~-ErhgEc^eu
zcg&`v9qm$W)|`x45)2sHHT)`njhxA-6^eLXDggQV|NOKB>4{Tk?mmkmDptszPULmw
z+eS)m+*u)=wD`>I-v9Zgw1&j^MlxL)%k|~qfpT4A@8y-ggF@nKWlppK|Mxuz#Afz)
z9rACfd`=n|Ay(h`cAr^6Ho*2P?_8^mUNW7}ZwujY(f>8YrKA)Vhhd2(>xf@Xue&SK
zE*8!!H7vE0@F>e}_Qgolh~2W(!x<+xx!#3a%=3r)5BenXEsut6J24Z6gL&Pl)2>SH
zJm=P_j)qeWV$;5dI;DFxbk3<n)ut*BG1G7lpSK$Oimv@r3@1_kQmc>8T?)%RYKa*d
zXKBdF=PGTw*_0){_0uFRJZQCcU9|rDG@@|v@^<a^LguRrgN(OCUK<Fe3w)8@fDfxA
z7RSe#B|e`>k$2R;J-eihH-7YhZY^aj;T*Srj6=*y84E2ptiez|tS!40<!mBIMc~K>
z_1-q5^x>UWNdcORKu^>iw~u3vDNOGtqDlvt%IALz@B~C%<?<(zr@8H<!?NBH$rZxG
zU)Xf6HgUR^FLluO4gB#-U6zPRRZpb56jseCTumn?*NkDJ3^#7n*mwr2#9LRBPAa0#
zmugOwPB2;5u22qeI?LQ@(LD%Pnj@SrFN_O;g<|$8O&wXnc^A1t$D?@(w*a-^t<4J)
zxkdDu`V9N?q}*NN_ae7bP$r-fF*at)Jz$rp`bH^bWKZB`@cHQppJ1k;CXZ-;=x|PX
zt3*QPWac7MbDm{PGTHSXs(6Q=B})*W?$|L0Xz@BvYTDs3i(ew6F^FprILg@?<Z+0C
zbcG=+tET>k4_g}nK5m8UUibWYMN!dmjD&>QszvC(f4F|WYkElQE_0eracagGwol<C
zO?0Y2?1dW}($<yi(&g-d>Qd)I<NNn_LHa-B1@{F;)Ml415iM@~`m{k$kI@{QANcxa
z0G8bv^5yiBl9_kl$Hz{2M{Rt(C)|9bq9zJx2!O=ikBbwNP@sW!lOSxKXf7n7p+3;`
zf1kOdj7~YaH)dH1px4J7CnUYrl8Hu1Cl>RH|HfTz*}1tQ;^OzE0?aqrSUwpU8QJ1j
zhF64}2gWLD&i2|mL?MWtMR{XV;;ADROjRep&=1WSKX~vU{4;g6wS_lV^tp&(;U>r8
z)0?hcsoqQ5=l|uXZqJ^k#k$AOvi6F<ITXSJN@{&H3mE3*hUY3C|KAswZ{0waYFTog
zpm>ryS?D(0`T|w|=jpO7|Hc74uKK62tls(togY{L$A1*gR8nS;o4SFpk<L;DCqbP-
zP^VOMN=$kmt2v|#fJfXi<dP~i<sikzv3KvXBBhyPVr-1Apk9wKIc*Xh{NJuJFZIV;
zi^C%R-bzk=@W|;m!$5yTf5L%`)XGY5TMi$FN-4@pT2WEEbrxJuXib9Cr9j^M`n4{v
zVZfdIKbBnTdX>P=Y^=)9JLMPiw9AjM-=9}Q#&^A>W88xDq$W=wL_;GOA}6qNNSgwc
zNc#p|mHX4VDzC`_IJGCjM$<Z`hhxO0m_VRPw6eVAQYI!21e!Ss$_jshH35txGt&0c
zePuDWw|+SvAj+)|F&`zhzPYv7Wd}!*VS%FqFB4kOI)k9AqujjkvK>PZ#T%WlrnGIM
z-lPZoq*lMk`{0G<buKavQ9J{PO&MPjGvL2L>%fWaE^#A_`oKZ$sQ5%;ZdRqUICoNR
z@3jE7M^}n+_Q_Rm0L<RTFm7ZC%%F`8x2nlu5xPYwc^^`zMJEkS*kjT@36El&f}$Oe
zTX5(h8HBDCx~XFc%6BVjohMk*E_1nYK0RY{GX0M8*HjK>9*eu5eYAIl1$^<-b!8^}
zy4$43vKe-s37#t$zKiaDw(6T!yj5=9g@TtmdSpcStUB91e`2tJp9lsEm>NUncs|GE
zHbL-Wkyz0JgM~fSmvV`oK%}`nBBiH?HV>pE@rj9FAun~YdfMZN3>q^7zP+>#<-;|Z
zja(wVQC7cV9H%SyY55TRPa|yW`pSMo{g@bCi5F@&*VfRjQC>g?PvIww3wM+)B9@zD
zK8sFgX4vL#yj^mNz9MLNqKuR;xDuO`dr-UAuTz-dKgiB{b7;IsNhYXd`q1ISsORC%
zzdwVIop^Y1!+pw8uEdNzRSbJRKb}rCs8PpCbll4esG*lHUpAYr=iegTSKV<cUswp^
z_~>XvGqD@$ct-3ak))>n6pS2Arg-3Sql}lX?#^tz53q8^QA@=%u1O+UC2rq7AdG&*
zVvY<UCPW{5_KZ=*gn+zYC<3t>wfhbvom9$5rohgyC6Blk@#>q2*LAD^?n+j8MxRpl
zl#h}!>O<tgI6{X7vPT-wCq@(cT~Dv6AEd6$eUR&y_nkR)YCDw}6@TQY#U5(zPf-rW
zBrGg~LtZ92gAg&^zU_kmie0SMM-A`ncrjK~KV*OPA1dJABt_OhvnNk8j~p=oA|~q)
zt{@g>`U(V=B_!D98UTi{fq)Ez*w~#63{hK^ChDBO-M^f!-6Ga*0sjEg8N<S}I<dpU
zeE#<`Y*94c5l|@cHEo^y_6>kM)y=0sz66FMXB^aA%+PtglIn*XuU?IRLU*6?-*3*y
zfD-#0i)La5#0B``p>eyYt*u?q{Ragz=@JdpC?Xnd>#IYGvKbd4L-tcHqe@NTcdO4M
zkZH`M*sL*MA6ts|U5ZEJ4&bpl??3Lvz5jNrOkvo~R=trx3M>Sw6;j~l8Q2u#hN!-k
z#+n+S!8!)e%~7I*8tC^o4|+eMa<kz1N?lQ*g<lqp%-0AhPVIux%;sS`DsB<swndwN
ztSLgP|AeeVwQjr)wiv%fbLg##jB|h-hX{(~Rahw33~8JscH@P=@(QVtmr9C@zb*2v
zK%O|tIuk7|BX4iCX2|4z;O4e%4@IjT{hQzuTO8U(XuC|Jl9H%z?`{P(c0MkSDkDZe
z4K1|8A;5Ac#l>N$LT(SktZK~5E2YDYom<(O!0WS*9A-93r-UUevgkJn9K*!B{vU9j
zRN5Bxv_4Li9EGSeo^5c~PRs)U{1*d4tP1=r+va9x;gyD*y00Oj6~q!*St<+_kv3CP
z^MEbF=L(PE=8ZmwD5=*wlr(ko^WyLis{xCepT|FhLa#U{=P!o-A=KnGe4**VL$d*1
zHSqmy_cmWEay%VNA;A)x-W?O>7ns%<x@zNA@kOjh*j2C9Krbn+Y9sfo_XnW-?Jt@6
zlTt<ufm@bCbFuPe%lI7Au@2a6sve*(Wc%Uq;|gK=hykgHRxv2-dW7ktYwsD~@bnB~
zV^F{RWodr8^3u<_hTyIJBiz#5RS(P_w719MZ3miJPx9(+=MI>5Nf!vovK>6;e_T(`
z|6aNP5KVz;oU-$8|7+sE)Yph6k`r@eALalE&+QLdlZo%zWk6m*Io}hQ7QQ4Wg6@77
zgu@<gZlDC<I61x?_wqu=i|4oj4Rh1w6iboT@at0<%$y%TDiCh9*})QE0r6Y?5Im(h
zg7qYeV)>6HB|pq_F@nS(;k_}CP1xm2Oj6~4a@d4sKQCn5dH1=IdRoa1yw+#imQM41
z^#=o4gkHvH)j*1kRi(u`pK%E|=<YxGkwWCrzKW_2Q^g{?wmN8Yb*3oEc#&qENCHEP
zGFAE-t;Gx5W#pq{-qG6Dre|b?j1|#1s|C)^-tS+(c69}a2q!dvt%dINq^BJ2w)?zW
zEkF!9Z(`#3_PeE__vEkJ6@ABp3=y`0#1*5Lkm%z;S$64{?Vuvl<}y3+P`)zjx0PKl
zi0OL{vEcMT?+@RvrRerMgetlF8b;(mGgS6jf1Yh0?L5OuQ)Vg3xOq3X@_HDD@cQCq
z%S4USrq@J*!V@Ql8}HHb55@(}@v(ah8ecNhCo1o?xJ5Q>_*Ct2E~XUHq&<7!OS^yn
zFeLp1f<o%iy|G9GOBvDRi>V&?J2s}Nt<A46@<t@p<`q&N{*ypcCi_m%r3r+vRlgIH
zyvCOF@L^BqqLZg5kU*d!Aa|_hw2-W<T1Pl!DBu&rJP%W9`ui&jLZP2;Ec|5GVWHxx
zC6Yv{-~`5VcuG@a%KJl6&IxsSWt@zOOxcS1uL)RSz_ag@`k0p|dhp;@vihL!?0M1R
z`K1yprnX~ad@<@nlo|gT3Z9QAPo7lW4JQzESiDlMI5^xU4h{}WNJ=v7+<Efspmjwf
zW;}sPML9<dqXW3?9B!U7(pP=Qf@m9yYAp<b5Iq%W1`)B<TcaH(kn)DC!HcS@h;wLj
z`*UzeF)5ZMH7;swY7s=Vfq|ISitwz6KKgU<&rj>c_$dCZ?^LvLSsmCR*Fq~%%zj&u
zO}_bEb?^qo>hp((g{5X1{7C~{i-~9P#$vac)k#H+kB%ba=yS+4=C}pj7_ed{y8EU`
z*m5j^80-&k1u3wtsv#_PWK)$CkivR;>8}|JQqKqgdeLYN5Nw|ld<zK0n3ijH222?r
z21e&>)i?{ot4<1xdic=ct<h1F_n65Dsti6>Gp%oE0CgiOXFMwl`O&J;JT1Enu*c*D
zM{RAD<)L5#gV0~tv~<p$!zzyl6s>TjhPY$toT@yGw?_=)?pr0C3?BLJOscNtN0imr
z-Y5!vg+G~FBidd+yMAa}z@4pIr!f2AB_j_2+no4Y@gSwopH-m2Bi(9fXu$Lv3g7vK
zg#dC{hpDf;tn3QbHr_LhXfFd$4ePW~02;p8ZLGmHz&Nqm_|a+o{qvr{Rm_%oW^j@%
zM?$;q*ZWxpUBm6w?2$H3jfHvv3cp$E>Q9PIPBTPGR|toPYaTiBG9h6PhV*b9tifmi
zLI6h$Bf@j(D?WXDx>}7yofgT?&h1GP^xQw6(1{Ssb0;)mY1LrNyL)GX$)AXLNx5pA
z<hB!Tm5pX7eO-ZTJ1gtKX}+R)?X;2?VU06Y`yeEDaCEeFxEUK2WnySph_GwGEHO=r
zkiB_sy|u?rkv34|r-xq+<?`%#I<v4y-Y|70a?psUur)`1SHDz552Ul5l8>jV4CCCS
zRCzT-lNz;;QVfMz%~_ht*O;{E^0)G}YNXWGB$1<%vV9~Oy!+nQMO-1SPVBps{7!?@
zbKB6<J0;RVj|qmRyiMFF69Uu5We5arkT|+pTW2t<$4B7i>UvM|OJ|`JK-eVuXg0Ms
z8matr+!*&bCkrH=)3Y+v*TK<)MTv-%psqa}2fh#7;{Cg(bhk1j-K5lAo^5N4upd<l
z=O^;1lOWbi3Yeb0vm;D|7IBA7!s;DvbZU>oNP#;E%5*>hU~mT`?>?%d$iX33izkq(
zagbt*vr70Y;?u<CACxSaa5^!AillSFs$FZ342LJO>D;{B02Is`u<58zlq6=fefvhU
zaRZf+irdYs^Vw!k6a7t$9Gbfo_vYB=S^V;+d>Sy5;OCGS3!bTB*`Q-{bGK9ut@hL#
z1rtrVg6W1u6Ku?k8@SK0d>)^J=@NoL%?>d8b#+@oJu!@f(9s3N;^2cK2eFQB-l&wm
z<#&<R*>i9XJjt|ib#)z0RNYlRvUMx{uzNAaWjIblvIp5nmp$bFZ>z`ujQ<+}h@%0H
zGUmG?K^JQx`Iv!9>Dz1~mOx8OE62eQY`l%|=|Rr2uE5b_yr-X54``jzeA_)Bt{Dlz
zrgpQF6k9a!(D3lk@KAUirBWF~`NI^qiwGArFnEA9^ykl<tV8!H&CEO$$jr61{{f;5
zn4Y-iZWU^PQrYp>1qJZ~??n_DXZ>6j{Z={MXd$i_tjC}nny>hJm2~vTQ_6qK)*7}*
z9UvYjS=_jDX>W5&HS@o4hVRlX9@BR@Q;Z*V$sL%v7QWPZTFRCsVdT=j<P2eyOhdQL
z9{j(Q$F}p4c({`qQ7&RW@0EgAZ~E~@A+H8iO*>u_G*Gs-BG-J39wHyv8;imkW=5u_
zYE1jito2Esh`R~_|3`=Jc1T8PH!9_Ky~wHqCzl@c=NtftAf+hy>789#N`ZnoU0_;H
zyGVmY6YNnzSt+T`#b15+>yz~-rQ@~-+<}D*W_%VE6`jlb@rjDiSAg<)l$(2MvJYd+
zFLwFMB|odG_#z-Q>W4ZNdQAErySFGNWj!33DKl`koQE5WsI0?swWp}9vs3+=mYi=8
zt<ON!912@@>1iV_qHx0Lq8z-r1m)1NKY!ra@frx1+;W$8-0lj*yqnEVuZN=V{zVC;
z-Gx%06J}=I6|bXt!L88HJ27}`>9?-IyYw3x?l~2G#%~>M$Y-bL@=Xu9&}h9mSTU-2
zY;&_f*(RU84)!6T1BUU$hR|gR9sZOjWvQ;2nQfYk=E^#_C0do&G}P6(7=MrEpG+$u
z5<?;F0c(;khD1+`rMWg60vK#>kaopct@-#u4zSfE8XDr{WO~9Gy|<;lpZ>T<DJ#Ts
zK3{Q-u)tle@iQnV2O!E|A4ig^wY4>ph^WVq$ulM<KD<nS|6$V4hj1;uUD2T%ElMnF
zqp^QF@qX=YWe--TOZ(3ShS{#Ud|Az9?7s;HOwk|9?cSb2`>f>5MrB~Wj~;Edmw*5i
zI(p>Dt!k^Q8^CN{pVzXm(O(!-XmRmfgh#gDF_v!~dooQ?n^3seu_v&$zCPc`A)43C
z%|oT!EMll8aPq&(#5J>3T1x6cQc||SNt7QI!U)$R?UR@PP<cY?@ZrPa;(F0f{{Br-
z=M5vG-6BH&7!zq@n(xmC6>oh3xi1#vzU2Ag<ww2$OYXZv_WXOwFeL1wQB~}xrEt+>
z_ftfxvu|g%ZB6Z8k8ym$)^W)*@6plbznWpxi|}L{PO;HS^qO#21eOU0jcg`xe|n(q
zi#O+S()Fs0hT|zM-rU1u`zZtNoK=uW^>3`4ks}Ly-~S{ZDs?F>9ZNb!5vFMQ)E4>=
zyk_#!4;u*P3_%}u>(QZ>Jbg=fNRh1m%PWYOVzeG}6m{|TjFpUN3UQ-eTg|*n#6XaG
zWSuX8FxG0Y#2J2E;=+>R2Xc*;yWFkFyL$s>eh5A0<mebmA#3jSJ(M!{+_OnCrIXxZ
zAUZkKd?`=(*h~)FSzlC5L;fWzP+<n~#e5=#S@|A#<=^><7ex5k*8?9jR}Ff$5Q0=`
zISUs2Tv^BXl!R~R9$9OlDIM&+oT_?)u95@IZxizkqFU<%wnM)55?2pVc9R!w9~@My
zdi+qFkK#)lYc^buJWt0@8}9W^?j3`0dzM7#_FuL~Wk#~)RBoDI*}$*MSjJ{2qjIqC
z+wM&C4EM#*GAGU6)aKu?{oZq#1M}CJ#Ko4^W;0ubGS09voLevb(r|iRJ0Ww;u%5zs
zY<+^kS-P*)WW+W{*f&>|b37wAw0}uAcZ$XIti%7OtsSsA>K;wR5IJnk{N4EnPF1I0
z-AXllnDM^tSfh$k+y8c`M0Huu1lDam$(|g4s%iGo(zhp*{(tUxmTQ%FowEqr^DXEv
z_y5wSjs@IIjM3;!_7dFDvehEJq@kSICGUjIwZAtk#lv1!`<u(9d~lYK)MeRhLEuK{
zj)sPcNZVF)n*OILUq_$th}dM1#HHjy3iPTvz}EIy{aHId+qMx>AxpD%+{(f2ihbWb
ztv~yb_6gPlKfPNsJ#8FLJ7lwJ@Fy$XoO&ionT=0Bld{>O@4?vOlkn3CzRy-O1)WA0
zZ|pomkLHj@!i9pS7IF~cnstc&X9N(C`~G^hLah#Sf29Q<>rK~N8wre+%2)TSu}{mr
z8ee{Yre~(zeeiE{hH1KZ%7jAem_Kpj#cCiort7$)!=`;#BPoo*$|<qh!?km_u&w8e
zSCw>o9*kY`vghJ0G#(?~RBa3u;X7sjCdyR7{1}^7`^qO_`tSc@H*d!lRpj-2)pu;g
zV<&&!wc-T9dMG`*a<7e)uD+s-IlT`$w1qn?L!Z~yT{_~x_wCe-)j%^b%?i>rwrb(i
zZ*a&Mh2ikDSTT<@J@*s4BEkAyyN1vzUL1WK$+ok4c2AqyL&cHgpObr3$CJfIXl_JH
z$RzsESjgGF?<>4boL*WjyEGZBdVbr`k{>>hm@a!Tc3guL_S09WtE->UJ3^xWqUux2
z!5J|CJ@L6M$Af@^zE6qWEPHFS5=I2)))k=u4~mSGq_6n5(E8uE##tdhimmBkQh>0;
z1sXB>{RhN1?=#T5{~yyDEpBwE*nmiNDO^+FR7To3JW;PYlJ4IRAR<Er8VWO#`P3;i
zSd3m`ZyIxDYLie<;NXTgBR>wY_h%6q78Qj9He8SOLpSbN98NJXlB+P1f29&_`*oMr
zHQu)qn2T&1vQ2X|kKL?5wq-se(42tb46}>u@h4ezIgk!QmJR26OiZKo3{2t>u1Ckj
z7{;v>_^w!7xNsdV-DaP8&hOtjMCfDU;)WMiD2vsKMaDvOeNaur#=k<S8xG{CMdfcU
zy9$$_1@pkHrTY(5!}j)ebqx(Pgcqiz5bGf%Yig@PjP~PB`4izzU*+bQudcqo33i!c
zb5^84?Cza1W>3$gj4`Vw-J*`0bW$!K<f!LRjGG~pw@_4l0||sj0wJ}QKyI%9*Oloc
zRRRP73V=1}`$7dm>d(IrevLzG#iO#aGSl_xcut>1GdsKAIPGA6)6;9q(A-B2<?>x0
z@m+6CRp`#M8vpwAl(=RLFATh|5dFfr-p9E<JC=#+yG`s5BG_SL{1M~+MZPC=XA}3<
z{)VIME8Ok6ED9gnCbv}CZL2ogr(p8MD@Q&c@AxCxy#lc|%l<8VR1)CHSX)8=+^Xjq
z$4Vo~a{BOgAoGM*1J5-F>I^3!*3Jmjh|<##$j@wzPMylmp>9mr;+{W$j*2Tb7V2sU
z@6Z(;)wy!@Dpcv&SM2OOQy>e%>E$eziv}(l!X=V*hLUFL*OhDQz4sS2LWW}t&gt#4
z@MBBM`u!jzDAi`{V5~}g<)XpB$1S>dn-XU;gU1bZ9X6ycwNED8oiL(1BCU5_tF`>t
zi*NRaPer7@QM0}tHMXVV$q?K5$77V_rOyXrcc%u3KCwAK;lJr=<M}+3#Y$J>e)acR
zwOuUR_1BwUt65)owOeOBKSs`@l0<sDq3MM*7i3uJA~hq<M-I?I>KkY#5K`xy47Upx
zLIa6B&X<v50f4m9Nx!m3W+b-iu_CR?P0DoTHpNSB-|QtR#asItBE0NrE+;|(`v!LP
z{I1hHN+0IGx7-b9z=>;f>OA#CPTS1uk1lYalK$iL=y)32Fb-Bt;@*7AV|xW6UzkM&
zc@^a_cS&j8$wp+^@cUxzxiw{VZvHr%<rM{+j6*;@qtmjtLU`a~umcW2k5e_CR=I8S
zKhx@3L87cN%f^?y<S1?8?bSXhX3S68{z?;CWK}V~`O4{gL0v6-qdrFHE4~x2X+UoZ
z_$&eMhnFp)Q#PMF@}$H#-9w4R+<H3I?190-m$rNTosxe<d^k7D&m$0&9C^Pv|9-db
zMVq}*E2{|~g>yFwFKgQSDf>QDUDsY-vzPVwiA|lpzR7Qu|7e-bAxhWQ3X5+?UHR^f
z#<wuETza5*gF}`O_L*--06Ha${)?Do;dY~=fnQg+>h^J{u~DM*prx6?z*V@@pLj{|
z)LC98_@=c5f3{Zby*d2r0Z-XhN(AdJZZTLSXN<{Y(693zXd)D0)7qxaPeDqvbJ}Tg
zy7cJ!9Ra#$1esc}`gx^nK`iqT*3eqZy}N{nv>Sa4^||~J5vvmw4yX|(_T2uKhVKks
zNF?d$u)ONnca!;^K^=rHLh)COzo~^eD=DEdg<xy#8=<J6bXcmMNX{;;W@R0x+ogg8
z9R2apo7EqjQ~8PIi=ML8Q!UG0A3k2Lyr#nfVYaHO>N&jw2e3Ce7Q_VJA^tAvTUb#K
z*{`RE7X-1+RU!;>e%V=e`G%T&*MvzJ^5(wk*3e=3>{t+*j<ntb8Yq#C)pTOvBTynj
zMwl+p@{gZ<5)l%a<1)2%+2cjM{~$(%3$D@nY%$UZ>1fhL-qbGkAvKVJXv;vQMTaTF
zw{@?;r=*7?LK&}zIpE0?UjH+^Oj9dhTyXm%CbJMeK$FNVLWF=+astxuqD~L`!q~t?
zH!xUAjd*C(sb$4a-kPovt33Tobx1m)m7kY)QjT+50KnO~@z1jAoQ)w*&C1H12E6n?
zbfl#r-@j1XL5aehM<>zE%gO>!;2Hl#%wn5obmZ&)EiiALdHe?5YW^MSSc;XeRgq>&
z?j<CQIZ35|K0ya#xav@;8A+j+VH(0b%(Q~1kqz~rG48){p*1gMpkF!WAdwC&PJ<=w
zpW78uwd02P>wFPp`Gy0NqVHMbMFJrR!x$A+URRTi3gc8FuKG|6zJ9D8RP<Val_vVd
z?Gko0h<Iy9W*C>Wz2m-pAD`Pu$T&FCz^%g8xW46+U^`@cj5N2;p*3tmRCjnhz(C;I
zMxH%VBisP0tm{Q2G;3;~lJ%GutargM4fazhr(d6-6mQSDcsRryKsSw(+;rqwt37ly
zr}=bMRJ@=hN1T`xoA<EAUIpDku`!AAsS`Wk<6ibz>F%Yvkuk}!x3yjRbJcfb#_KTy
zB0Hb3)P?ShnnO8yR7mJH@wmSbpbjhZ4$-nUAmw2arj;4ve{#J)^e8%2hH<iB6rf#~
zl|}Mf^t^uR%6RG8R3vEtJ2rgpuQ8dnhh-bq-<o1%@4@haf$qPgs}ac3ij@04_%J@<
z{u1mGzVlrp4i1r?DXGIz)g(@t*^|!BQ61w4bnp4DRd6Qn+(LK_dI4JV@Q%@6|M#~i
zG+szG{#fcY3m3M9vMq|iq4@!1?uY?|jzWA+{<cpeI_~Jv?hn`h-R1OAXH%__o3K$_
z*;8c@%^PRc<G4`G>5K65bOCfn;cu`o)M|ZuRXZ8LRSQG?);CxuU<>BKvnuV}udJrF
za_*mc9&HIVTc+ECaBI`;Pg54vTWGfgov6#uOp<W?LB~DqDTn;FYclLHzm0fzx@&0E
zQe*W<1}p*Uya)|fq^xewyk?2aR5Zx07532agn?w32%O8P(FlCu`bI{}p{A?p;53*S
z=!mVYj`%LYMu9hsh#qXu+P=%JaD**mvVyV@FS)t4mb<DM_GhFUycS&fdHo-ZQdn@}
ztYl?mn;yyoCtvmQ1S)qy#k>Hbg}rD3m0WgX$tC?>vZC)gB0-c*{`3@k04}uiuHQ2g
zWSzl1sdnyr334B?wP(M2bqr5pQYZX(fMIL`bBI0Fcis@oB>jF7k+GVn^O#-|K4Ef+
zS@UgTR@OUnl_h*L(gCI44XZYW@9W64=cB{mOG886dse(yegpXiEY=wDqq9Z41`_d)
zAI9l+8wm*WsYlKRzb03zrU!Wu-9wDrAZU)Ws_2`<)$E`1*0?ToL4UFC@T=A7_)<)<
zxt~xW$}6Fzi`(Odc%tBO<lXsHus$mb-{v{_YeULz`V)#?)0UVZItvRPInq-~fer&5
zSUIme5S6@_N<mY?ySE_l^i56;RA0Y-J$Ti$)MpK&4@Q55Qp#ek1;9pv^_qt$u(tr1
z1U9lNla&gOS!(kFKrGPwBc5d*iU8;0o<Rq|g?#beF8i{}xL%(7Ee>AhQE&mJBP<N(
zkFNLIz&POud@v2Sh{zP~Lk0wdy?FHspG;SQudkAig2<ttc*2osM3+W|ufRJtGLtLV
zjj`q5AJRaMh-w$})u3TUf9HV!lcy>J50#6Fp?B2WDWo*tP+}y*3XmvKREIO_DRS^e
z0**K|W>9{>_W}V6iX9luUcOw5(N=&_%V+5R`Ez<}1Dq6yqopHeJmnxGzhuwX($eBQ
z)&IG!4)`p9h5bd2Uw#+7d&G{{zgcEhAbFCXEk^ypfPrRfB)jbJyr*Mt(XPoA6`ka2
ze}9}cqVIA*gcG#aeRXjPj9@I!z!FP8Y(k@gK&YOAKS;`b;tG&?Ovr>F{5o2?8vP8B
zaI2q9S5>+nOQ`4ob!3W!+NM9<xc`m_2zai|N#0N}MQgjuzFq7k`u`&{(YsH)IQ8|n
z-j&t$;~pLz%;(pItL}X2Exfi+{7)+?{w6Qe214f_XJm*>Pxko%|70~XSTZv&%kiq<
z-MeA61R~LPer=%_<IE0wiSa~^DAi*ON_5#-?U+|A-7tx%WgFnxp#4y$=NlD~l3|;b
zg}}k+XqUm7Y@BjG0FHxOJd#6xIoovYdmjl-Sv27$F+Kx|c;Qd?^~K4)(OL8U^&M0u
z&bFOwQj2Q~HVBXL9elfA4IY>7-gV%g&?LsQhh^|1f=GN;{uG!3lF_^Nx4<&N-8dW;
zZkjYWjHw503HxU`Sw=JCrWB(NH$6RWW%_y<wx(Xn`u+-G4E^ydkrKus=SkphfM)^O
zEyX<`u)u2BQdjkHI~SR>$^XH56KVV02h@7xP)PK{hwPlGs3j#Zb+j9|du9AF8WULz
z2N^(mkStvb7py-vbsy5X)_UKI9cU$!$>nffpv8)1Zn3Vff@-tyL*QM+NK#^wB4y$j
z52ZGJm%lJmuzlz2+XIX9^X}8jT#kFe?w~$UoRr0@Lh;8A90+)yM5e<kqleY4e>W%m
zdLPlYM!;)Mj*y}v<!wg<Cf%Uryac^_wB<3TrHzf6F+$rhsoumX=Xs{}4TJAgDI`{r
zCCgc@WA^s;ROLV=j0(s!zhjWgtC8sAFqKf}n=;ars@MzLL#~1A#dzL>hhBj702Ce?
z%fY>k4>IMiua_@jUL2JEY#haJQ4S6lZ1T%Sy1Fxk*K7(Ly4`1~7|3i>ENxhb*ri<t
zhZ`^8S?YmK3n~QPsnD`B0#Z60(R1xcFlN9b4}*VTVA87+m(iN24xgE%UK+pKNbCjt
zcd^GK^Ivc2!ZJ1Aq$-K(dFB_--WympL)O+_P+T8S1VypujqSiypP7B>c}%@N@!e}H
zkqT$^Kn>W1b$&a|D!jtxBqUWI*uTGG%$0TbZbk3eATb92+-Xi88ja`pEf12DSEs5u
zPesS#&WesE>nln}6a!C%L|RO=aN{nOZSkGQO(es#Rq^Sn8l%P?0$D1HSf1c^1nK4=
z#Z6W)z(`VS2_4ZYbi!LSTa|TS;W}EnG`uhG%vy^YC(x4Nr!Nar@kvX)loemfj3Q+Q
zWY60BQW3>q%3z;e?7Pdk-oLx_vaRg~0^OZ6rlu79!>ABOhjlDMlv!=c>|Mq6mXR6x
zmRGxPjivvRGh~yS8G0Uk+svsUUa^y2q)M<JC#<X5H)J7eoB9#+MoDJZqchf&niE0h
zm=^hCd&l~?Lb3T*T5(u5M^@)exfcJXEz%?3j*nPN)<#TxIvw&vKu6jjuevK`Y1rrA
z&4nh<;ij7(eK?v+yyhE{u&7209x_NjAQGdQSG&`4BusTb+aP^%vPYJ;FN@PMfq&B|
zpUR(90jADp7mMxm+OhyH{q^e;wkoto$u-vb2hwF!9_zg77++WcB_{1uw&>n)Fc>1M
zF-v@A`yHn-E`P`<*{b-pl7mzqV~~-WoILvXueCjr>#lzPMupO!xqMJoPBs+zR1p#L
z7;y`?2yr?x1uNss4Tsp$jWD+dM_4tOR#vvKvJS6Y?Tt__2f?0$$o#VMq5Ijr^t6Wi
z{nEG$ekK8~cIa?6mZU(D^x2)h`~7K8aHlqp%z5v*c}@=q;9JBL>1*Eyrb=d-oRx^^
z3G9LadrXIA2%bNVNGv>53Dw)TN6f0<+P!eQc*WLsYN>=@JH@qlHx@xX6BCp3rkMhV
zLa(`xef<on3;GD4QQ{`c+(lP5{SzgXrL-0u5Gm-v<X)z`m2t&B8l++&mTh|a`Xbel
zI2<ABH3jIS4<F>Y|GfJ7Mc`2^-9}S=eHob0U>%Z>n8!`SuDA|p$i&X`5%srk^$xjU
zfhc|PENfzHtVOKRpq`fg1#`nHwa0Q-akUTK7kQ3m@NQf+ugSpCDJT%G@>l`ydS>N@
z!u&lV>JuboImTb98J`nwSEFN8vBe<=JMOgS4@fest@&6(naL2Zfn=bt_{$I7{KMyk
zFlNCdjX=PO`QTFomPdXz$1Y@O@Zjp@XWG{%EjW)Ha)Cn@YmK?J_cEp`XayC!_hj0h
z5{igY|296iyo%SbF!h`1!4*<>8nS!HM#zV=zkK<<&!68}e)3PnN*X9#xu$w;pmL_{
zh97Nc%JU~O!|9F#CL>s%B;lq@=$yfTW;?m_XG#<$JL~(mZ!A02aI}+;tiFk0(`Y6<
z&W{D_+1c4mUM;LHU7MLfP(uo`FdGK>w^M95wuDjgzwl4IQs!^D{B30Bp`vfZ(4`Kl
z-=wK2=Qx)W{IzjFg0gJouJ_JtJ4h=ParE$E2nap^<BLf+mJ2u@8vR`l9X`oLByn)~
zj6L;rmU)Q&qFGMh_=er#ReE|G>Jtu3tL6D!&(pQe^V{D%6Shpp9aGDz!Bp)$5n^t;
zn<m!l{+W}?I;Tq>7)w81$(wU`;R}@WPj&NT`g!nXfqBCx`d(x9d^)l~$i|v_2bR4`
zR`eiALm?xrev6B)AuV~t>uyC0j>hl>PxY(B*MEMY%jJ*zMMZ^jl7$-K02)Zb5!tG@
z=r00^i7)UGt4PNmOp3%<Ni&5T9bt_aFwgBom^QzLIe?egfKQ#O*GgHv^(Tr!Zt_-6
z%;EDn6FtQp_V1GA5{@h#x+dQXbR!Zqi>d80Ak{bua8B=rO~}&LHn`PLR9xH*q^#tW
zUE?%Q#h8M56GMp6yjul>e_+Gk4`(Vye=;}i>|M|O@}leWWB7|5826R5=VV$yfS3Cb
zI&K!4shYn1D+_;Otd_vP!m^AOR(w2ir@rRpRj5TE1`vfIo-8sQM9`Tw*5G2KdiDn&
zvr)hjwezmL*XfuGK_WszLPoAfVX$-T%A*FgPrWzR*ROI0zSi8`5f9m86f~ZlPX$mu
zwNzGmss<LbY3?{)qpBz^q$S63mx##CHpc?QG6>sY{zKhvOG|xGWk6#Mr~R1LzF6rU
zDKc)$cqrd>O+ZahQ6Yp*s}s?@7z&6!r^}A+IS@zvD7;o>Bys7|2?DpJiB7{iW-~Ur
z#e^>#xhE!mFaPOXXV-{!?EPEp)CY8<9vsZ?pt~|%`yG#u1-WauXQBIk@}$x{_gjag
ztHXDH#(t^ww)3WYI5^%JyiCkE7%~kQA!-7AGyb)cT%-t(|ENqE>2L^BgfiPswTv(3
zSy_NR9nLybUzgvkASo|DG_$mC@9zT|&?D0!&r;t+$1(Z|4uEjYt_@6!S)b2=HVHtH
zE#y%wet28%i@v{ZZ^3q2T~!TJ87Cdh)t=v0ve0*J*~wAz@8ilj&6UZ9gsCa#h=IDg
zdML4VbXuUCcx7DJKjjIH^ag^sc-zdiYg#t7h{N_?o<%dkzCiZtwoeWF>c?EY<^F<)
z#xCoDnf?)`V5Hn$f*0zrwY5!BVj>JtaD?`|lz<?({WH^Q>e{`DD5Znp)mC(v!d?Kl
zG9xpS3hBmGLgx9$j~8%1W@o?R9EAqZb}pBb0I^q1CIF7u_<a{Vd>8ahQ?FcxSNBCf
zC7SoMdCS<?^T5DB21U92CbNF?+y~VI0mNO7{$6Sdh6mbTE$^{l14;zTACw|tjG7T*
z6{qzMUYfG_s{e7h<2s3J_^<Dwm$d?o<lomdH*TU;`18eW4LpPJ@EuuMu-;Wcd%;d3
zLAlv6N6q(>^)PafD7YSVUyW|ZjzaU?#hMx?%>FGR<yq-ym#;1ymGwF-FQ0^bitv4s
zokD*XmOM>5QSxBBL|xkc{i~>mv__DlM3TqE53i-^`{<Q#;qZKfvmtA!h|Mg1J_gI~
zK0Y6FbE5_V&Ik;;%A5~K)*4R7EqdU<Qwxj7FC84f#7Q{LB_$)1KE4bb1gy+A7yjhD
zcmY;`vDn_m>JoE@OGTQ{co#O`jJSBiJj}1`%hbSCwZ}SSSo}M<{E<HmAol8ynP%US
zf9p*nb0Eu{*ViwZ{d%hG(j#nPBzlN)z+npg49h<WPbJ3!7N8X0^=p(#24CDlz(ai=
z03rh?H%`udk)H=3N+R46*&TWJid_~1n-pY0<u~?3cgH;<G1DE<&xRQl@sOpyrS;-3
z1oA%35V_G7%{8z%QGqlVDM`s}W^>V`d}jOLl*9X<iHx@&^<AphPinNwEm`?nylK-W
z(m+<0UCM5ZjKKgzBx-Sy#14A;*ZY;vy7&5f(RuWhdlg)FhMyi#a)sG1X$;NDU~Sw;
zA3R$reewLc1ARGHKi#?=zA<#cld`tJP;88aNv`=yqKv30nU0;q9nTo&^~Jt30<H*Y
zA=k9O>~{QF;)VYoE~)PKr}8knhlhVP`>r387V^cxR}R(C=%~P*Gacf^J@0IqIjE>6
zS|Sf!b#*lks)!o}AE6OAa|sCvlM*MhU74Hfvo@Z5ZYesJxRcv+vTV!BvSaR|Ub?`u
ztajv<7j#!wRT*9APPzWK(1~{f%6fwrst2FqR5jvd=Iw0<W+r$Ns~#U`*bBNZ>g(&{
z6c5gx*N30&@7}F<uk|@~_BqvrxWL+C7}4C^3`gyz)RiA2l=Xk5<L=j$m13<5pFDBx
zU0-W$J(g?m!#ZDyPGp!x<#|??jMJ}QlaoPNhe(g#$np(P^pnJqFxb|{F6DH|(o>2x
za{I>S90KcZR)7hiP{0$NJ-#<|M_ec+pYrM#MJsdWl<9JMmw9fNJ?9Olyn=$=7RDwf
zW)ex)uV3BC5D7_vhnxF+Ptj*1kCDTth0<dO-eXttl=}(B44a(O<d-r(JY@L8#6t$%
zlLy<}F2?Oj>AjV0qNS&odh~Msg@4i3!8*O;b03k!*U;?tR^{JCW=Dx9!?M8wpDx}n
zzx2JC^{2F5O$aSL%e#55<b(t(p=}K}6wTt1o?1Ty|8(|?7t0TOm;N|O-B_Nr#ghHA
z1X7n>7dsH|YGkC}-qUk!U^(2XSMH5P_0IS!m%Y6c<r7j<6`lJ(STHEUEuvI#T}S7e
zff#FKeNWFz@iuWNeyStnjW1j{kEsN3yV$GkyWgR7&wKxVF-nc&$dQ98Y(L*#0XfF}
zrB&{~=$Je*9njD<B^{2vA1_|iduvfWf1$veT9SM@ao2Y~-<N}v^Qyg__xjQZV>vot
z-!GnJ%G(r@VT<jGty=dakv!#@+;xG8jPmuS`+fy!>7{Dl)oS)Xe{kaao@a&3MbIB#
zpgq;~0&E_IR1a@&8P-q`YWMly19oL*>Eqg;s~zp_MLmuxI#|`WEU!?8Us1mQTR_$M
zWyoU#K@796R<I+%?13gJl1)1K1&8H3nc!?=&DQd?du`@k<BbKKV@lDd^In`G?=s9a
z61-Y^vt&UZ4sE$=6`m;a<H^^jM%ATm{8^skPw~8A?LCZo$U5Ipr!BCGww4!`rsq$e
zszg_|x3eZSW{lI2)#)@V_hi-=11*pDi7)+ZH&mdJ3d_%`2hadC+w-7v&z%ve7+$X*
z92Q6R3BSI*vhmcRNx)6?qbpO_CQ`eug%tw9iT3Vjk<ZxI1DUN||8<iJp$cuhAkkam
zOwD!C)I{8o8}@%ZP&VAErZ@k*z190_+#7~}6wRBJE~Q-Jh#UcjDyMlw)@6|Hfd9bz
z+}vDd{-3BpN3rx_$tg!<I|kG+N=FOV`4OuuL|E<nWqX&pFN=8()-W3C_dD;gSVbY2
zdlO#$S7~WJ^}~%hY25dOO#jMr4L{e-d~g`s#c1mKSSsieR9iW2n}b5`pyw*AFAk{e
zRKww|yu5sH(4P&^)Ae^b<GBX*&dyWV^*j(cYi(n*OAo^vl*eHdaCfe|y9b`lvdwC=
zF1=a&uXL?|BB7}0afz~SY4tE?JTc?IVrkBJ8g)(#X_=dy9c~B123A9TgG)}?ZSK>9
z8u3@?2%oNzd709d_UzB;r?gz2#dwrKaW$x80B1^%2mF>mDAZd19vyv#hApqImsdbV
z-xo1<a^;UPMl!?z0#{_4XRs;ZKk!CZ=GoOE*=M}5R~1}3JIoX&o!?bytkS-9CqbZo
z8-0NI#d`j}wnUo~aaXp|DXs5j)rkJGm-nOiwqPQ`dv`_n&jc8zxf%pnzczd=Halwf
z>A2Z(It&09UDSLo-HtFcKI*O`DI?QAvxKeq_}Sk$jzb*b`tZ}x4F)iN_4V7oeOpEQ
zM<a&<p}SE0cJ9-3OTW*T)_wB`NuQnnDJXR4kkBD_nb4Q|7a$@u?LA_sj~xXM17fXT
zy6=lD#7P4FH&&lUbCC{7v8Lw6>vE3Pl#0J}-2T=v8m(?*f$iT6_4Hl}xR{!z_Bf7z
z@XF6D&MYiUU|0Ujlx;JggUP`Kt3S=(D@2dx9v78KBOH$yNN)+M7ytJ2X9N*COf0PT
z@9Uwcnh>ixZQdy$tb|;q+z%ff5`VkwkbZc;y|{6}UH4>WW+vdkPi>2E)-gQG6LOa4
z9Y@O?upVgHBZoC({{eqYeo%I*r1yP#UHbU(38H5~_e<N~<>fcfFXd%2F?i7X&Ox@S
z^WV%!3AahqZQH_;T!YoBx8sRfK7HFwJM*mSaYW(O$jW}XeX}2!7IYSxt*92Wv$Cx-
zY{WF*8Ub}jBuk~-WvOvVZmS%{5<)#kt+@XKixp=g^&1j<!zIMTFqpkT?TA=Ji)^Bm
zVBwtkAi=zkj$2!9$`X%Vr0?p0lT@;khf#llb$+^l;03Oyu_FPu*M0K4-k@~@d2)Ui
z-j}GbFmb0^zjNWcjH>aejRaneuWlO&LCQRIJh)lMzJj6v8p;O~&X@~Y4`rl<zcfp=
zNq(H#QPAC(6XJSNGNA!BozT$j;Lo#FJF`iOh(LwfW(U39E@T)BfT<CZ4wWsR1@f#|
zqsA?Gt$7AGtDR$+hNY^VVd6n7g@eOOB2Vb&J0dvwr#v8SiOmbU^J2IE85%}zOJ_6Z
z@wk`7bl_ss)BDrYc?!BW5g@08PB)F^z3~b3BP}Hkm^(6)LqZ?Ia)=8oxSfT&a(oWN
zDV+b&D29qKM#IS1_>0?3A4hzI@~ojp1qJQDe{1A19<HEhd=>gs#1=mQvTT_0W7C!2
z9qtpI&P#Pxw|66L8m=eA8ikT^4#75jQ7AquOFvr^<7R<sGuB5zZB>iDTtr+Q222$`
z0t~WGGRMy<z>=2<ZE$>1lMj~FLM(K?ZBj}wEdKd<?qNLTf{*bdu3X2*=k6_(YhBZG
zDVMu;>Qk)gKh6C+NQ<$zmi`~A&O4myKm7m4h+~u!k|Z2^W@eOmQg*UQ_N-);J(J4F
zmKlmDhs=g8o2-zPmAyCF&i6i_-|xD<*S9~qu1a;h$LsaF@B8_DJQp}`YW2fkPP^g$
zR_ci@v?YpLn7~{KMDIN^G_+rpA{omeH!=YC1ImTeR0cEe#caied`S5cxLWZsCx_a=
z+(D3;nOTsB=b$&SX2o65wALTe;qIub7qP?@8}20ArGL)N^*f0e<j|^e%iEjlyu4z1
z@ZEpeIKCIkC<B<-Tv3Gj6xSH1X<F_(+jKFYwPfOYS{HQOVSR_fY1Qv99t{aB{E*BA
zcR{)f7n!d=1@8VbEUnN1Vxp&yzVM<p)e#)Db7EydNn!A)mG~V+0+`mzFP%*(ics~{
zOOi7Rcu`Q-TdAz&>)lTRHeLlho!eOi<h5Gt@3FDIfdPEcW61BmzY*gpEqm=6BxpH~
zEseqM{fvlo-2dpa5|fvr)^AXTgA5cLu5cfiu0P$FY14tX02B~c6V+&M$>-i#)X|jr
zYBk?AXy&u}b<h+BPxRA3U52j2mFu1hQ!m1)WOjamC31g1i3JI(C^UUXp&1K%GIU?d
z$`;_I?xtRNlO0h{|3tc$R_p?#B?W~{OQwzu3=VqC{_M9)_p*KHsvZ9U2)XP2dzFCl
z?a0`OI$em8aC4(N3p$;_n^af+9UR9f??dys?k<2Bv4B0!{g}>l<;v=E<qMQQ6pQMy
zp_fEUvo183RaPFsO=rG*8JKz1T>4pgzKoRgWg~qnAW;jRKLEQYK0N~3Rd@_<ELr&e
zZYx_9xK}1B+#UgT<jR#an1Aq<4ogc(35$qyWX8xqb{bT>f;Ib@EXd&Kwzf97cEK)1
zpGUr#ReImj(~D}kAuH?;c>K`N&AGV*u;XOFl#pLv4rA}&(6PvWFz~(RnuJ7)2%pd?
z?g!Ccz+AGO<9OKtG+l}G^kB+!bONWdDCw=%<6~c#O#z=b%Kw-xfz|^)kA&km<CRM?
z&VS`?Y-XX|PrawV=g5-C*0KWVx#NRv3JUx!Ky`0JP`$KZIt&nDBT;ugc`mpAyxpMS
zt*o1B><3^;!or&-wQa#o3w1z9!Lrr#G(h@lasS@mB!xS*4@@wo8}9MiLf5Wwgy9=A
zaDrg+Uiby?=F$E%WLzce%OUtX8`5Pe@f$sW-KZf6;CNwS=snyXDc2pS+@X;9=P3<G
zqD=1bny~=f2^D;ld5|c*V!94-+_rYMUg_;!xMYDg^3p58l9Ats9bjMqGXbBa+>a2q
zN$?KZXD~pax?h0i?7)GRNz22d8|qLJ64G;5t}pC*1Bx1WMOi&Vjg9OSY1g619~q%Q
z43*kNjX5&Y)6aM@u{F}B!?GGB^KYo5V+FR00jHw|1$mw`id>U`PM${C>d1|Csx;_2
zU*>oCkmndNkg;)<A+kW5a&Ac>Ww7+PqF5k1ehD=>@z$^HhZCVTn~qhmv?Epa-%zd$
z-3v|DBGrHo2NYE%_ife~dolNozweLM1AaJ&r%8Lo%GhlZEj?U@O~+3|heqX$n@J%S
z3;uIsJG&N8W5e88wKev@l9i^IpKnsxke0ZJF){oE6{<+^E>scH`QS+sm8mWgDx@JK
z2t?h^(lX(KLpv<7oGRYX5{BynWN=AIPoUUC4Q{?YC%_r^03c3qX0^}8O;)2hG2D#j
z)MEFOyM13?Qmx+l+0IXP!BD(&O7bc_vdDoMg{hsGcczuW9dE14?Dwh(9-R1V(L&P}
zKAJ0hD-(yGC#Jk6;Y|m2S1h}ibUOG_{BWm4ot*;o(}2eD;~5k}1oj>ryjaYAP&n9L
z@al{LJrLdekJDfb;rQpb1`nK62d$03IyUQiMb6(B3MHuAe~ICj4~w=e(V6#QZtm_(
zQm({^Pmc}<0XZbkvH|vtTUkAx(xA>8F5dc`8wYm#%C(Uz<SzivOhi!IW?fHT`l%F-
zBGTP(3?)-QF$EmEV0Jw3<EeMnQe7^ijg9-zbpx5&knkontkTlcL9Y@XzNV21c>@mx
z=$3!~o`HGt@Z!cA(=K<muHC5!tVJ=!7wPwRo;~;iEoW%{+?@O++AZ7ugb}k}|00FM
zG7^CZM5rh#=x)Ps1sveC<S;VA)f}yfrV8NYdF!8zJD$Bg^WI{B86u2nIgkX|J12XZ
z(r`F7JKRb{BfdNB`9bL{-A$7T8i8d^>4O=Ank~J^2I#a^jSaSFuK*hz#{bpO9rX5I
zf)8%95_7F%dAn0x6N+LEbyjpRWTSP#c=({d&_80nd~ZTdc*V8YPql9c20M~W;lQhg
zoAi8DXK(x&3f(BuB)9upCoD586aP|sSC0peTrMr9e2J;Zp#V7a&JmG*-fn4z-<`gv
z$VoN9lhJ9H|1?IBXfg|!K=ysy)Kn0=ihnH*K8)YO`&TswofA`%YrBIJ<~8vv3GNma
z{ve%S{U`L?7i`2IKjL?jqxIU_&!5j?_J8ITijbaeZWcqg{1F^2QziBmf{&*XYhSl-
zsvpZSMFEWudJL2xh5VTa(Xn^A@fb}I;Ycy<9r-#GN<BGL*Rkq@Wd`aO5b4V>MYUO5
zw$VF{mW}`Z&9Bm%8^_hj*~b<ojR`5>UV_vd#)y|ZUxEA$yI46SAz*@q{lTly+|r_`
zb^mFlvGGXF?q??>{(%=S4uD(VUQ*?MN+mGB8rM|t;GR-<dSq8YjIrI+=E7L%mCnfQ
z)-0*;&)l~tc&ZKsA3b0%^ASO7*eTvKltEgk#6m|>w3AZx0m#Orne3RlUuazHP>AGG
zWxQKKOEeiNRH>~-W^kTjd~rB!U*7ozKP9!BZQ;)!9~t>O^M)Njhr)bOkPuPgi-l9d
zE#kAU8u%T6;mxo1hC8g-P@3@^2ZrwnqnVZ#;5=yv3X`ua0u6s@`Lg3^nXr^p-6+=J
z3=D-r$>{SK>b6ASeX;)Tnc7JgahoO~LtS&hS&~>G<hE6evSbev=4oC(XJ{t&L7jPY
zaxEvN7UV<g=~2A8>5<wRY6#X_A}fHu8&YHSnvx#Sv}+V%d7IxhSlCIdmGGCEB&YRv
zK!mCTIP81u#n5u4(c-bzVYk^p=cXm6HqNG!qs$(AETz#0k}&QtK+<cit>mQS46nK?
zpq|&syYqx=1GTyTq0N8||0O4GT1Ysgy_Igab*vrxsKce>94}K8M+rF@=*ledz=DX`
zYZmqRgSHyzK;Wgd7SU48>M@jNvbxj_xbyC9d=xH_gI(`Cx=$6~`wWDm$Eo4rX;|J@
zm>1gt!RG}r9Yjb1V%@$SPtP-bw)|->TQg()$$=_p7kz1!(l;MQuJx`VbKMyB-R5wa
z+(!I!Q873ja?kWQaG$<D&l+EnCt;Mp0}-K8jP5G2)bpRLx34#M4@XcL(g{jMmX53j
z#|FwF66?}$FrI^$Yu?*Po-kLyeZnYhtjg<&t1BTtY2lrXfV_T&sFq7gHc!m@o~B=1
zaZk<s1Pu2vQIVV(XGu@fkfuy^b~Uls<O&pK$YWg`XLrekF_Ja1Jp*S&XX<tVXQ0>V
zAP#9k_F@d7!BUZ$8v$?^M3Qw5<V0mU8*v~&tn^dc0BIYiinb8Fb=|#^jQ|A{sNzUY
zyGxJmi!)PS9|vlpXWG1%R%~Vrl4ku9E=rL#zcv^`YV-B;+N?<sjg~#LuUmeAWtOnp
zRt-Q>2=+hS?p~>#2?;nNWN6Nx_LNnQ-G-Bk4GM)UNkYxhLC&ododc|;O$Ceh{Mx_0
zZ079#?WPwh`f4}I=KP%3f+lZL1|m7<?;nqI731V0{VDlW!HZ0D1=c2n=<ElSK?z-7
zmBU~0o%1W7Ta;VF6`F;2M<GHG*(i(5pD1)IStuDP5}iVb2xO!}S8NAsx00czvttHy
zTU~SqKNYZ<5+l#+k;Jo_8ZMotVY#Oi1EY&4aGZbR&?rLp)FfrrD&F(w+S!Yjq_X2z
zH}g8yjo1-$cU!O;t0I*gCcAIXbeZnHy)=}6s94`~_3;e?#7cbheqS{$(%^htnvZs9
z^k^afEKS<aZ7<HPg7@iPo?LU$%Xk;Cbdd}ls`f>%{E|_z`iad_U!$0^v|U45QnI<t
zuk~x>!A1wQOi}TpxTo6^r>r%SDtebf=gcRRrsa;FU>`+Kqw50+v26%Uh!>Uz^&~zz
zyVmk5T3Fj8D~0g<%eQ4;;+A;>kqG5$XDlg;i`ccPF=ChQ7U|-8Bj3^J5ujL2??d$F
zhZKz4S(ew5b$>H52v2dv6v5_;n8&xqgM$AihT`ljCEN0R^me9+iBt++fz0dDUbyaQ
z#$W2(Rh3G?Kp#Goqa;pqWO&6lb$DuA@3cEQ6vrh(oxK4$6Q&n&N=SB%*j;3>$5l$t
zNQzhW6$K5NCg!n})cssPFGg~5aDCuQBU`L~AOJxXXCy0bq7x3D9vsnHo>Q|8L2)Q@
z^Jc|Idp6$h`P8n}U;D$5vtPF{Jg4M3B5=u!1^>A%$90D(QTl#QDi~idQgL5U#rFST
zUFUA$Or1&|m_DDId7hQu#}0t)XzU}@lN>A^;{8-I8rxxd9N(!)l%dYfrGJKp%q>=s
zCGMiup9Leb?h5PLZM`$SYchFVhoP^MRc)QPPWA`x&{^iJ4r24a9iZg;w$*1e;x$#B
zDwn(*!xWGPUTYlx7H0%GGYAbd==J$^0%+!A_10~%&Z~i_oQ(hk+GGw#d$*Mg@uMx^
zK(J?#fM5BZ81j6=&&$7muxeS-BHn)>L1mI$d=bkaFg348VaKEW+)-faRT2?OTW>P|
zR#n#hs28*o(&2BoX!RCUDN(Gt*B-?LGCaK*oQq{q5P8#oGnf`v#T12kotwj2XN|Qd
zuDI%xL(oqE3f%on*RFf&Qx;7U-G`P%g=QXWN5$U*Z4%T>{tO#w+<O_9l6B+gNpQ*P
z#oXfzvdg)<fs{w}EkbXXr*L_p3Fe_*TR3&a_L`_szSHi<2;9WGy4fFTKJxU57gQHo
z1gPkE4@T4Oih1dmS-hsOeQbZKVYdBO3*j=7&XwOqo|)V6k;cM*rMa!C*qBjpG}))(
z982%?Bv$Fvq~{yk`}b<vHgUT865GulbDGCAzn&IXz2D@+sc>Tv@y+uuU*RSLrmxsU
zm>p<ZstEM!VINruo*H@1Fo+wC_~Qba=Wo9=FZu06PGuHxXWV^fMdFQwcVU&xzc?I)
zcE?CNL+vqh(-sNh(~=qe$z-j8v`#b)W%92dGB@coj$TT4o0_Ll)wTGY<NhT4K=6-5
zSgS{r{ef<*UBiIf=pz#1qS+dy)$D5(Ihbagl>gLR@<GgHMnU#`%aEK#yH{D$)ymOD
z_Ro^?aP_sXk}6LU&5FLRt?c&&Fdl8<7Nu~ipfNQ#>mABK)4qh}dVSi5JHI5S<o4Nq
zd9q^uR6y&(_}bHqlm3p>fR9SYpKJHzJeA5<(xZPecq$F=YvKgEUkrA9H90GIypD0n
zE@(t#Tge?p#l+;zRTR7w#AOUw->RZdW2E=l?EdnpcB^#|);^<flHy^y1sSP>a2z@J
zwV;fXlxZ4t@5P^*;?b#}C;RqZYK?Mu6F$cU<R52P7<s4=oT06YGP+UbTbNjRzDPcj
zpzorYm6L_*3y&B}k7KSi+1Z$!#wiQ42Msx~FAHK1yGrIdV?RsIq~E45+*vg4wWijH
z`MLD`#O~<y*b5gy^>Z(PDV$DqC#UeFHkxG@7f>U+F*uRpcT}nPW?A;Ac5`5A1UJj)
zhdWR!@xd-G2SjS<V|k*dHToY<%N<e`)Sj@-`$diX@i=?B`<=^w(@gcBw7{FeM;1=I
zR<+L+w>xng`<-$=j0i)QnMaB-5x<s5DCwd39f*4PP?~NhUi|4Bk<*FaR_^gHs!L(L
zpBZ~4SvS7>?#X->@G)HnSTh^B%nrK~UZ#h=s?pxwVLn4D=-E~MnwU&JSg{YT`g%?6
z{@bODLcgV`5Nfz_3^g0;blp`?rzhm3cWO_Id~x%SKi>$UCW=>{-KF3P__LQNsQ8hT
zkLi%S|944sw-JMnBW|#8_oQi_Ghox~OGt+O!?F3(jLjFDsR92yC(L|Ju@3wrM~qH<
zxjt(X-i1uH2N~%M$IP|MmF|`Y6~CfM&e98+zeBJf(f9s2&w8#6^2C_Lj$fNFFgJ}F
z2s+DYj5$zV*U;h4MsCMd+eya}1)?+}&+8>G-MCD3fU3_+B_P<|3GXcPO`I5*Rd%pN
zx=IKB(j9yFV07hl!)$6h3mYKoe8g7#p~8N<?tscazl>|Q$m8^cIptBMdjG0os8x^1
z(Z2~LuEXCyGU*K82CTm-@lkcx)YfQ<)o|9A@;<jve0On;OLb5B)=bEgqlT*Lrz+1L
z{0Jm~E+=8U_UnVin(c5azd&vHSSG18ezH?$@<~?58D1(FQ*OD9gOrcB4|BP4^|qvq
z_n$8P+u;k)!PVo?v<4bAI~mCrxD|&2wx18}1WqMy-uLX(?XMqE6F8d+YhxqDn^(0D
zu@23)mAMrW_T<#+b<eizjO})mg~a=#IQVAv7dlXlzPr=4kJiiN#5{#%mqqlx-&?B8
z&52+2`}S!bp=H@MruiU7-a50;zWwGKrJ8fxyAz(wcOTA7Uo(d}D5mZ~3MU_VwxZr|
z&-<rtBF%iG?8Kbz;uSSvu@j^FV_Y$B(&=K8g${PVBG4alw>tiED0#`uH5m>`$hi_(
zsEhhNBSa8Tvj<DfZEA*g8K(uJWauzeA&NAd3<><vG+#rQLv35DY{ZhkOVJR-un1xz
z?M``>QRpcIv7&)g>2uMM#uD#&KTS-BLh!MKoT2vF%ZauBJ>o8b$Ol;Iv4HoVO3rTw
zF_LwZ7hsZRa`DNzjagZOr>|NY1scNxso6ukr5P@jHyb(hv=yx+zhvxYZ7LE7w2W*O
z4ix%EYY}(WVto8-;zN-$EYhw5H9{{X)3piFikXe7+L>&1Gg5oxdb3+M&8`lge3(jh
zKUrmVxixziC2&>-<8nqZiF>nk=oa>8!^DZi8!DXsY>(4`%%0Qy_{nL<Wn6m^tMLE3
zilLe2Ukz#XgpE7s@;GQ;#QVP8d(=)ww$0r}P1IYzOnRA@hO;s5?1qsc2RWyNAkOK>
zwSdbOjxH<uetV`$w;HV1m9%h#TuIy-<X>*_u<UdRs*UHX;a(u~(1MMOPEVGKQSWpU
z+3vB+$0yyr-!?^VUPmlx`cGXU7(p?4i|5_U9bFq$p7$u1dqW@Fg>k!k_a_c?#`V?X
zC8;~Bs)<>xlZY+}ng94f5~Lj{w4S^|Rc`n8>*I#RaWWsf^$pytn!GBRo(-=O83&4$
z94&qWzY2`nnH7sU7I^O)_Z6O=6(1%D)_t>U7{cu`Zi<Odno2{v1}`lQg$K}8ouH{Z
zb#;QLRM}GqD1y~^&d}bi-(u7@NejR=HHpee40?E+F0bp!?JCj89Z?{Ejoz3@_1_KH
z_-1Jm>S9Z3_pN2_<*VAGLN8;Lewtdd?U{Ab!>-_0g{*bN+`=#W@h{pIv4M%6k)H9o
zi_f2Xsc9TG7o~4v^XCHU5<(hM88Rg<bO>G3;y-Wc#<sRSAQ<tv^5t2S_TQh(f5~k|
z#}b0LZy{T5o-UqJBwe&46+~a<xWY9T%}szLc!$~!xoEV^GRMNjV*2_H74cEG9^>gf
z2Y2GFpuhR1(kG(b2L^der|wUu#I-EHb|2@iFZmQ-x;S;KH9UGa3ll<2c6GK`KICEy
z3(vUG-f&_b(}BCgz=e#<#U7BQuzvPm#x-|uA`(gmWNhh;0`DYwSIMm}-J<<(@2z6@
zU6ZG13J&dazEiIbze5nwqS=*h_MKd0&$Dv>OI^=c9k)OQB2bKBiL#zR{8C6_2yct+
zODxmL<1Q`n<3vGSrW4yvoq&bPe~!M6Nz_vdQVR=5$W7m-m_ky=G|o+B`wdH9mlD`@
zWH)=wTy0-v`^W9|UhZl0=MGUeR=tIkA|Rvg-|aohm~`kepSaYeO)0D?cFSG!(CO_b
z*yQ`BEd*9dJyv&3WD1lBuVozc{rdZ2XcXzh$BC_4v2(o7z#wGKa=CX4#~<)hTXuI>
zQv}yN6VVLljZoI^Cz;&HOauj*BU_9i0t=A_f4$P1+BykM1~1$?PfTEyk6ohClt!!c
zwhPw2RsI!o-%pnEN<l-*)iigPh|1P0YPv<mBPb1F#_Gy<@s^Ppmuu)KyuM~XjSpS;
zj=+3SdR|<99-E7@xVDgRkqd!Fp#`QAFShV-peBni;`~-iao^SsaHI$p5&ymhioU|*
zvr`9$aJJALw0e>ihuboUr$(0V*C#PiC<Nygw9Ge$Fun+3Q{|VHQ=Q=!ADN#xk`*_~
zV>&UBp?imAWGc5U5`x>9&%E+byH6~kgSWV+#QJVqsw3-<?*$Lo$F_Ap*hX1j%xUXs
za5FK}BYM<}_33Ra%;QyYv~$%z+zs@iz8blU-3(!%x*1GhQiuC$e|NJ>|H=_b|FuT7
znB3E*J~<DEKQ|6~&0;;DPR?jDn)tL+`C3fP2M|0xYgw~YJaJy_VSR%^j@c2;B2I&h
zpAy$l``PE;gqZ)LoVH2Con0EeXGuC$rMfx<qQ++{Z1!jofrLw=2g;k@vJAxzd^9_&
zPHQDg{kF_bvHykxbdEY|2d1@TrnXJJpA-HVe%r5kitg77*&K>GwQ{g+4N*K<rn1_n
z9KFT984!rN)A^+J+e>S|3t)y6OCV*vQESq)s!(^FQPL4?&VjS59hW(!LIkE(_&i)<
zfR4`hb*cNh_q|V_o8`JP&i&K@4)B)rL?2!Uc#|g$@(Wj2Z8ERioU%*6#Aw4X?7o44
zgop@r#O({W4w@xuKs5r26<oR&uYw1L$D~B<gTvd{Web}%cHb(UGIQBj8~MSmAL5*k
z%(1AXk7eaGjXUiuib~w8E~JFWMB1kgRST}K5>I$|dOj6c^(gXis8VhczKgf#rS9af
z6mIn7(cFwJ7f>^Ny|!>d?cNZN(zq2wEUY<o9)XyNNIUI|(p0uQ)Rb6rfu9+~G(?lt
z&nW@Y=vkndo?hfM5{*v;qD!A2&dK7&POKAwQX4Fe&hzC{d!)T0)~dN})>B@xjOVz5
z)$zPPYfVD}1$@e&NaBE4r?vP<zCJ>pn>H4FJrFqJW&+w<{xL}WfX+}wfm*C}v7u0N
z@GtNih6cxdb{j}aI_(;5ZN{OSQSt~h2MGRnEFLTnpyRdKLv;JRPaE3Pw+l6E4<&}I
z**1~#NY)OKRwD9fds`_7G?#pEuOo-z8+5&L3BsgrmR^zGm9hUCc3D|WA!Nss-trtm
zS?p3cUE^j2V^&3l^>@p^gLE0ujXN2Rqto!Sn0*STN=_y#DViOH<PNKMVT35-9B7Va
zvcAfB0NvR>u_FGS3l}eh$I^!?V&0?bxgYD3sOGY(WO8#3`P@4d46_uXXAfp4X4ZrD
z7r4oZ5Wx+Tp3;%15<`CV&F1~uCQCAWn7V3gn`N;xBWLjKtn=<knj5&cp^J}gI{(EU
z#)yS3CN@eCqcO<YIFBF|U<Flg)Kfs)8m1!1_u!Z+$;(^LPBhJof0)AAF46*&Pi@sR
z3V>VjudOXD-QLc?9h;r>n}K64we#P}dH^%xhYMpIlT|T2n@l%F5I3PJ5?yTgy8kBf
zJfIng2Q0qv5F$MzF9tV~+)erv%^&4J|M%YW=eGHLX!3fW99~6rbG4Sdb?J|Mvl}+g
z;38T^E-@ewWYq6yS%QfvpGFV{4w(zI`KVmW-_pI$invWk5`XtvS7s7J?>pGd28fVg
z7XpFrt8+56$Y6fDI4riXY75&k%^3`hYy39{11J}%s~g8KZV9DXFK+0=&$uDhFQSQ9
zAt^oOy4w;hI&b(qhMO+j&0~)dW&thWG+0^5XF(PluE40y<9Zq%AIr^we2*W_ef_$s
zB<Bso1G1nW1wQ!HagTLbJw4?6Ol~|)>E_J>u=5`@H8nwZ`UOhc#N=f3Nyf<}Re+?7
z416ift?*OUWcApF$uj53so_%Q$GSpqR*o~U*G<kZQSzH@phFN^*0x4ro%-@mvANON
z#WwzPZ^4`oJt+B1p3d7vRd0%_pYsYM%q<7aQ`@)nS&J_g+mk4Ag^`>O8gk~|fBIu+
z;q2%Iq0<SlWzDqqfVfmdCHNP7AR9-=J1F8?T7UkGL|uV#c@w(|M9^<Fg<l*x`3p_!
z-e14y$<L_0<w(40ChM{0fc?_AMm{ofBOUa_cwc||+qdS&xYn2~P(;XiZ{E_=Awa+^
z%dmT{6E0fR(UB9^J`TpqRE$G~k1FmwRS^M!{y!Lz$!;gxW%jfR`fpO047Rton|V&Y
zz$eXSWo3b^`p5g5uWl<rN1U6N7e82saN9vmM#sk#;N1Z`CBP<6_i(2ZO1E!wXXEq#
z_Izq3K&}P)c9>g2#MEO;%gnD|`yD`><h2bj<VyF|>+UP`**m2fCk~)UB4ze1a+;7;
zK*2!zCQnn+4H#EiS+Su%eE+^T@L3k|sbO-c+UGk++g4V1uU@Ty+;=lGc(koWV08E)
zKmWeoo72<NnwpXL0xjY1v|n7=lDb_pb1LgDSrptAzAV69@bU7>*o@l5Z?1#Av`f<k
zvnH^`(YF$NPS!Vp&GH`q9A172Hc!9Jri<q>jLn(cHQQ@9bmHOw$h3UHcAO1a@3Wpp
zf91+~V)TKn#HD!c^l6w85I=KraCn=N!WwM&`5T0*KsK{cBwH}pG4ilj))-|UpGwff
z*@Xxgf0I7h>HBymqr!JlB={2uPU*rGkm{Uq>?$h*bXE}hnN<9`$r7?w<PLkHAj1lr
zA51<gJpe=~F4l6dG8BAVGKkRmm!-HQN6rEspYH7M^#y#W?e+vVKDD`q?!}T>W!JVZ
zg`!q81MD{$#LR!lUzHDmKqa_c7Zgx6JK2IV#~TfD`*l=e;I2sPmfr3F$EGR7iS_ns
zzm@{r)8;<R3p`ea4&pM7t?lh$?6ilEexGHyXK1LraDnEpq$6~ytwwu$rNzZ>^MEc3
zWOp!m?lGhV+P9vbfx$&`67Z;!kQ`pZtuHNk{~NZ0ycZv6AgC(%_!#3Id`armBaf($
znbC@PNie8%HT}1&6i}cPKK-o&;j0>8%>tw$(`hZ8hA<kEq(O}V9)A!3ff@YkJ<yth
zY80R-^}kc_x>ulI4=y*+2h8%BEdrP-BO@a<H7g#}79Cw()ELMQ7KhYgkTOaC8v<|^
zQ(6Yz{gHtioriVdQbZGb8}KimfrJ2zBhAxW7i;&yBKgyh{~u`7VX=7~5%IGGLKOLt
zZN-{@Q#f0eNFQ|@QAr5h=F>QMlS7<tq}Pl5{uo~%d&ukjZ~-F`h}4*Q!lY$oyWER8
zCMdzJsbkH-6eW7IQ;`F&e(y-P3ww8)XV!BZsIT`6@P?6jP*-8GvFwY@5z9z4M)^PR
z8_ed?!9h4HnSQBO8dNSsM9-b74-zKU_YSJSatgdie1xZ)p2@@4{Oujt#F!sd8mJ(U
zv-M^J6nk)>fA00NyC#AlJ5CN4a8yuDAvIpsBnpKQ7dS~ktRVYj4*nu&cG%dmUgI96
z4D|Gz4{rvx?H8+~$jnU3!tREvf5XBU^PR;QKrF0))VWosI13>_=I?6D%Z+Hy+|p`q
z=i{eq$J0h}6JK&iR^2nMyJ5?7A%f9lP%6^r?=w<}2m{&2wf`JdvheWzC%AV@19~?;
zw@Pvv7f*;ts5*-d+Vni$npNwuhr8`~V({$#dqJTk<ye?`;K_?*EWsuG;HJQ0c@<EG
zq@V^p0m^Ga!kcSiVjw|X^_e&t2j`HFxA#@E8tEH1!i6K7EISUr<ma!{Rr>_&OohW7
z@g_34bM6%=62OTY#=3l63Unr5(ljzL0f)>0{L_i;dS+&FVq%_4zj<u;ABm?9I`PJJ
z`98fOY&(!$Y<xkDbJ$0y+%)Cj2w$|D!{|5GZ!cLM35R`CR4{1jVAEJyN||n%xDzj&
zssT&M85D1cFNBQ0cyY^Jp`Bmn+!gN-ZCCgWu#fQD1%ZB38h1PogEdf}0(aS0c710@
zta}@k85!9H+-+cNu1y5ItEmBd@uv?T;M+MKEjM5ZRzGQtj|1k0vXRknWZDfLH1GkD
zr8n*)5sLH{kkGpgFEJWpm6c^QH9Be~AH1IY{5kBzl(fX@^IqwNaDG@=u(!AOoKN#e
z5{7@|5@tg*!>ifytD(REd?v<#`7-XX>gsBUjxsy=nOJCAInX!eH(CDzOk(`UIFL)i
zZyUV5GY>lan>YQqY2PL#na|$1ejSXYhet=Cgdh6#3liEP$_fl@k<0<9UYA8qHF-FK
zsWGamZ(;vt2~LQY6mBNV2}9L~&~#2E2pD^%Ghe!7S}SN@B5z2)eusnj$r<Y{^b;JU
z2*#rTuKe^mhl*uFS;r)lBy(SZ83XdmoCgqpW?T9o1&Ba3U<8Aw7W33(u*y_WG_^<U
z3OX3&J^Lmx!~ak;;GbOpe33s$p>Nw`7O&F~=FrRxX!ob-2VRpP{$QPMxNDGdFx|}L
z0G*<Vr$z6a!T13&ep10g*}>EM!^6pmX8y@dT+bnOG!gXADIln0y==9zdkAptG5H_N
z;Z2|&#v5Bs{*q24f>9|H++?h@<VsmFM5O1WK>!5L=pJ}W{!}Wz-UNL(Kiy-ebr937
zuB=qJ?vnQjgJ^zB8sfHqEV<?`=njUpy*;bfD0nlZRl>`Eld0x*+B!XO%%L4xbx*iU
z0N9*|ekNnzYjz(4?J(jtZZ<m+#Ik)%cL7X!Bj(vxL9^$?Bx_9cIIw|%N*Yd}ncO8w
znYQ8mmS1aj|Bb+c0^Tn#SfK&Q`0C|L%%n3n?U!K(nK2n~^3c%4Eyl9(KbzjDug3_{
zL+DycQW7{FYuuLUvK0q+K@b4~C!t?*!otE5H!2_Kcz}g6?vegh0C_?tA9Y^;!00Fx
zGa^>+)hzDAX6V2Cy#^9-r(6zTW)DD0S{k;&n{<wkpT2IHekT9!%a?f0MauB7@SE?W
zu~_vx8j4j4$hMNVA>ZSETMpQLqKQRu@?_InVUTF=dS~%X{i!WCI8jtrpFAUF+FvrL
zIZUfPiX2%rjU`)mj*IvcF)))@wt4E9=St1s@EhM%5ea%Mv+214dMEzp=P=w-MO@iC
zkkBOUwKW5!`2omXKr6rrWWeXosAN4engB`dySAMHGQQ-Ll(3d*P+M60Bu}j4swZ$V
zkops<sJ&<Y?FC@U05k$nDE#W#BqA#tDGW(?#l=0=A`tL*P3-p*Y2X%5IZM*s>Tv_}
zN1f|8)1oiW@4hYv4IKWw#;FKtd{73~wtY~14KLV%1laU|7E#~Yx&j3L&vX>RE28+e
zF^k+=xq!8uMIF#8xAtiU*ut61-;qf{NLF?r;7Gj1#mdSm#{NT9Rpz?>1pGO?4O=$?
zj=mRr`nE)_YRc@!56)NnuinFUGiB4FVRp~S#RV2qh^D_1nOR)y5?oZUe0KLNXK8M3
zIgsSTF76Lt6Q-stZ)rU>0rplX<5@r)Pf0rZ`r>ID$pw#g-FESzjwI2W0aaxSc*#UY
z!0ExQy(usbci3(pIuX$@G!yb#mN)>WL<z9?#<2f~-pT@r)~=fyP@F6ukO_l6l!rPL
z%(4K?SX_KydmM%jKY61vGev*-$}JQ)_aTU0^#Npm*VhM)K!mMq%){r}@~yr8Abkds
z47`46%qI&<**4j5peO4NW6y6(7OJNCoAQAlDb77(j8*+LwEN%nBOMx>g=4hfeaQe=
z%Rme{R#Q#;OnuPJC}DVZy0tZgC4{c@1&R<YuNKI^;y!hCtLtV6BGAa)EaxpFgR2x{
zB)rL<(vDFh5h!Zn_qn-{$N1CoD=Y|tSNY*P08^v6kff++DHtk(ou!!!XgMaYA`!D*
zU2xy|_2YPA7Cjd4{rk6C1GgCddr-DGMcUjofW{ImI@Us`-A@fb<}TfB{8?O22iyp0
zO?MPfQ=4ThNNK^~1`7pRxJIy{%9v7NHb55#h9-DXD+)f^l&h=Ext0S#2qdY;{u9T?
zjF^z=vbltW;bEiFHeFNG$xTnlB?foDBqPu*!RkfY;sT#38CO~<7v2O%PxiR@eTFA}
zml+v7ry~Zxg8>m@NcV4V;DTQk6@_`G%XzHb2gtfX?V+Cgo)Iw7z_ALaW={4w_&Q+X
z0!1C9+3-8$K|-RUSHfHH)dSp+K~tZI`7@<$jV^B|)&oF*#_Tl{^XJdK@Fs12{eOJ{
zr#z(#Uk&-`pTuhizw3WEE6E==wcRa8g@%Ki)8ofin3!ze`zN%;=cgEF_0N%vL^>j<
zue5O`VO==!R}JFQ&F_%6X%2NR_hhvodyX7;RXF>4td!u0ILah}FhBa228JzAUNzH$
z<HO$Fy?GUc=8(SHJ2doka|&`Iz{MsjcLR*sBH2Wo!6BKR;KhSt#2JniPSv}%(o8M%
zdIp1lFE|G4<0>p%x0O*%AejdxF2JnQKy9?05inUkpI+@XO%ho2`SWAQ<6G*_qqlOe
zGPf=8<lz%mBMkup9+=Po;K3X)6$-n*GJA>Er7(~j8(MT&5P47pM}xw#!v*wbrdqVH
zeT##1R8Edd1**MYL{NVHeeMJLC9ppF-%8-(;^NMRstkltD}TO1<R%EB;N+bF*6g@Y
z*>D<=r{mAGV5`HY>h;*uTHOb8<IvE46mFjix(FZ@ryuO^he*ZymHsEN1|EV=dFOb$
z8)7QoXv0&yw09(UzYNra3+G_QFZ^Dx4(GJD3ux8@FnXi{9hI1Hd57Wez{Z_=@*P+U
zjKI_ir-<ww$i#zxzk~NB$06jpW#(Yv5d|NcX`w;v2LNHM2dw)5PC7=}u<r}FU821%
zxH5Wx$QXVAmPDh^6hIjV2VVaf985u04RH=yv{^k1P_383@gLI)-P6%uzgWV0XJ(FW
z-n^P%xE(pzw6r1Q93f&M+wD3~<gQt-{&g<D>+gsE<|@HoF3<el`F-kl<n1kP^%|<R
z35deb=#z{DU-atI((&=USs+SXQxo*4=h}_rAop{4co(h&5ppbi&8+&E@0M1HvKbOg
zFw&4|=}ZfG^sbC8n4!+Dt`e~-`e|i$S1_r8z%Z_D#<kr4c$)c&tnYq#w||26(jJ(N
zNLetOp7#?j=yPp%*qL7DcfE`VoG$Z#MJsjUcn);00Cmf2cD}r?`=e}7+<9=0E*RQ|
zM|;c*OH1|iPz>Q6G5qa8ETB%qgZqHwI9lUp3|ZWZ*@=YD5Zx5()qClgt$6QH&LRp=
z0In=76b$cX!f-Q0j92s<Xlr|)9G-2)jr{oool0NX+A&9HH-Yssd>Bf&!>MpNysPg?
zw~P|cS(2MvcdAIy@v~+8?fG|_abzkRIC_eQCs4!>^!G#D<_x_59NAB0_(&a>hVL5>
z7L_fG*Brf{iY<A<<)7OsoTOC5Ft_`Wo4lQ~8xOqeNcjRgH2z!ls685k<qnQbk<-+c
zP#Jf$MK`^%c(82rBA*wD4#zcEu0X~NQd)E+#wL0GAh?GoPHkAJ@0;@*n{|dyagO;E
zpI#L#Pv<=hTJ*p38LDj#yse-^Oot~M;2Cg6VmwzU#~VXHbom@K<RJMP5c|S83m_o+
zP*!HB_tjZ)=d!Z3o|a^~9eQkPQxX%R;^9DLsd|f!H1)BmLn?GV5rLl4cL-+7tEBgh
z{)*kUNVpw@N^$t}T=?TM!^kv@(YO%^Ya?4NXTv<hMlHI3fyvb9U_*O?Z>B65!fw8>
zdjDCk@rPd_+UQGoUfEDC)|K0OBY-GF@vbU7Mur_ExLO~UV2Iy1k4eJJN_;-TVl7`M
z%dm-lQ>W7=hUoV6;m0D|HxuR*V%c98<GKDD(itu4B#f_UT=WtSaAAz!7+)nv=VEz-
z0qKrFZ1Y-gb@85NeBf1|!l6oz&yjWC{9g^$PrL?;?f+=7+CL}1d+iRVz-mz`@pIYn
z<#vYn3<*QhA>$yHqI06zyvh|dCVC*SN85|1@|c7nTi$XGJ0_yo3~uKd^>4c^ll9Hy
z3%*N_2zQ9%KO6K^?qdRU8Q^rah~{TLgFrYu()^HReq@j^-|<>hvz^gokY-*$PjAw-
z>?^UDhRxSvO`-SatSBe1D2Sc64Q$KH|I_#ci8i5o6cO{^h;{`aN}=6P+GHpBH>s>X
zl3ihGmV6&>*=rzs%#4XHJ4=ix`pc8IUyFU1dn|VlL_Jf7BS2iP$CbO))T%OBRi|WR
z;7<2yYs<=7iKo<Ob)IkkqRnQ?W=HR{m#o>+5XO-bA&TmKp9;*SE?U=POeg3Yv{GVU
z1QnDk;n$0e%aOA;l!*1$6c40HFLm7QWA!@frhUfJ&ZS=+yMJxB{Jd5({wTRsrz%UO
zKeVlt!nh<_?z^=8woC#(Pt$JTi2ZdUB*a~&LP0e6X&D>VW3#AKF{ipfUQSkE%vrT}
z;BFDtZ$Cvkjr#Ap{Z~lB=6`Lfz%WTj?#J2kB6aGj0n^L(P3jIWlTcuZujcU$?lt}9
zwYVO1i8T{n#lcbVzj^#t{g|uN(5KcxHCNp*<?jjJC33B&hf7mmSTr%t-?i`ldh;#o
z(Ly3xhGE~@Vwm55(atJtT!vNj`ent__z3>sgHZ#FIsW-<C8MM~4bTjEYfeZKBd5Ve
zG5P1oyN^k){kJ$t?tkXGU%6@@re=YDz}{QN78FF(kzaiv*5oX<nl#IoTk=k&`A~R+
zOp$dtvS9hP_SZ@!Yr3{!maUJJ{3Is-(AV~BpK0>LKkpQx&Lg~!`$*M6>iU>1g%#DS
znb|Y>Q+;#Uby6*t{5XZ!M&%qYQ6EPJcOZW}Vd?POzBbX%26@m|xy&zqp~VHvMoIo2
zZ(8ZCkY`x~{sf|$B~uTgh8--QwLj@R{~UL@Y|z|g`|N4J_s}Xv-ahyQXOZZt9C}d|
zLUec<5h6RU6D3Dxc<HjONziCYLq|R>=U`u4gm-`*U0Bs^N(_C(ZDIvQq}^5MS98V%
zLpD?<Qem3B?MJooiZf5gMQc0#6tPVTw^Wm+_5_NFa-+7`X;HPbTt;Nh(S^CeF5Q=@
z^Oea+!dTu9mr@$f9knUGG&)MX$C7+bC|mHU6r;f(5oepuWbSX+i$b&TifLFbCO>Fu
z_P#YVFWn-sOBb1w^?0r=!S;S{EJwSqa`x?<BWNvTBkMZCDL}@r)zOK&r8On_-!~c<
zjR{#R%K7rzo`b8qj!Gv{)bQZRotFsxf*pQ!mU7FKNYM{hty9(p`Nb{TIo5wC{xs1s
zd}PUHa`oE>rJx6bFYRB_*>b7nRC98D)L3cadt_Yve1`E#lD36wr;yUYm%iyPr^SV$
z!$Q6QLxqia)6ob047$#_mpjQTw2(c2h|BaCFi696pOl>oN!Lf@IK^E)MzGi{kQap6
z21L&`^)H@PAXpEI=vAtJdQTx`eg?`XP$#Pa=tFTZv;n<QHL-4WNlSKZQ)1&X0TPXF
zv<8!4jyX#p>R$Ea=TN5)V|{~VjD2gYxdCG=#^GQ1ZIibP$1~(b;+_pJ{dT)@BP}Hd
z3NH@U!sq9bL)1%alXQ~0S?|{!*L*FJw=f75bLtV!FdK}L<_%V_tKW7{70|h46xr@7
zO`&G@=-0!qVVU;u;O|j8tf{~tMtEWpmpqRPyHKsFes4niUiY8-i9cDLw0H%XQadii
z`r94@+;FCG=aHjO9QR-x<=G&y60<+Aykf8J{wyv+BlynLQ$8liCG=u?!m|3Wx}ZFf
zcEOrQxO%MSWr}1gZxDhoFu}KHk=(-TVChZ0W>^=hAewAYGGcI6yNpR-f}|+ycjY_1
zuk-AGW9Quy2+gG~Q9zk%&4{EN6=iAc7*5Dxwn<5I6Nw<qm^U_{OB_FIlPGj@z4NZf
z#~}n-<KEv#uX&@DK3z>ZxmBirz2PgRO&uE%1wVqq*Ds6HWr_Uf_4KyI*QIpwBsdA@
z^_ai7ym_XMuOjB-k7m>JHOgG{Y<P$$oT#R8E3d5kHr>SO3kug4zl)Y7B;<P|2LG@{
z&vPQSoqFz7CU_Jk>MlRRhK4s=`UeOxM4Wk!4)MaocAN5P&@9GgOmWqX??;NepB(8v
z>ovLl>>OPV`)E>3_ukG|l3#C*YF!wFoTFlrT$)EKZ_H@SjF@aGNZ4DlczNIT=8{b=
zCOJF0eJM$r>a4>tq2}rEUtGqwI+JDW<Y@S~vU;EHV_(ZZD`Y@y6Oq#YsPIu`V1$`%
z%`iIXtJ*8I-YcVs!NwrDs(<U&#eB5}s}lczjU-eTiK|dE3v3tH5Yr(*p69sjpod>W
zm5J{3i}B|LFN9^9=g&}sC+Z)H)=@F#m(Iks{F|A4LSYYLhaVC+J<}U+ekwDj{<@Wy
zH2G{?UxYCmQSGFm+l>TsGcVchosW7BLNrz#85Xt=HUF*qV?vU1OAns%_VFF;h|$=P
zXB+-;w@oGstu645T^#gX!Zq?}vs9D{D9DSwc}U(U-8gEJVyvr^TYza)FjZ!w!6@q)
z4bt-8lRYnfhr~bbE_Z+_QQtVXqwQabON`AS(^4ixj4hkeA7}Z_<O{K$@lt-tpQq0B
zzJS8a0THOT={s<@fq^xo-mNwLGXK}H3uEu<q$!VI-h@=@K0`~1^m&?d0-^Ky;Ir!x
z1S5rxDm7Vva5Llgr-b^nFNV#Etf|_3Kt)e)^+n{4ShlWS|L^$+@39YEuk&cp(m3cR
z*kF|ZtdCm>kr!p4gM(Pu+numjSH{F+2!g;UXI62Cg<=gqqA>6$I<KpPgy+0ueXI;u
z$nm4Myq`1}+FS4AEnlB`){POuCv=8o7WqZ=B=7Qhz06OMcBn$4rMtPPXj)tx@{N?J
zYdJ|SqT@YVy?=I88@@i({PiG8J5!On$B5k+`zUAW-x8PqgwN(z`3WUul!T!s^1PPi
zT*|+&tO>*Yzb!GF#(8oCXuS(M8m~S-PTbo{y~mCaCVkyd{LJT!$)KK|#tK`T-QUKV
z=&CT9Q8s4%W_qn&t|FF=+}%=*pV4GztqEFumFbnAJ$a!`n4CspLWdHi@L_C$4zj%%
z_Q9VqA)`CwU$mVE_9@@=ynUg~8cDa+<i<m0a3=rcn(8O}A3q97xwFA73ge8}Hd;zz
z0C-HhBu_(&1;%nP%x!P+0PO0jxlkbLPx+IN{SVm`Nf8fImNq>BD}z8Fr-A7NL@0hb
zW+wMD&+%cSgTQ<QGavi_OkOAvff}_Z6nUu<J~B)mUDN&$*5`HWlIb0GXFzb+i$Pin
zy@!X##fvv=q-3R~8Ii=YSKA2CU;b;7veLEP)`}k=H|11)kOFYhf$?$ogDr@MNp@AI
zZ33iY>2Q6$TBGGAd<o{MDo^u$h)i*DDIQ#QD}PDWa~=~6v|*U6K$>I=K93Hq*!`ua
zXd4DuGBPmKa`X3hbnvAlY)wz?1V5Do{G6OTytyg-+9gL-SMT$uPYWw6FzJHPdS?O{
zOpn~n`04UKeFD4vv{$+|ijoAbL1qs(n=Huia&ybdJk8Bnn4(I<pMzggLsR3xR~9^!
z)=O(^(957CK8_E9=449B!`Cj{v|wQdw*q4e_`{&wVG9OW4MbSAOn3e6icq>&7<<FC
zmRMyVbG5}YoCqe_rvEzZwE`B?KU(%ZKONUWrEtFs?W?~MbrBf{k+tuv4~(O8=<Zyl
z67JV~Uxr<&n-4m%YiKZdZ*A)BCsi3%(ERvu<wLpckI#%hevPIww|7V+S?iI-z_1cL
zrm^fgLiCK6E`_#OK{H^a|4;8dEu;6?KSM(cnIoM~-u{<92=vY%7BF1I^k|v%m6%aH
zOwqr8|G$9~bi2Tw3J<D)fB>MQdh8vXorUPa{YxApDShh$y%eU-#Ar|Pf1dPGh&n>B
z92ioJlObCDiBRY-AL325>FX86L~m)Oq^9D#a?or9%!}P}kn{9~mmW)e`L>=>)3f=H
z)KtHo)1bf15;;BO;%svNwYC<maC5O?$A*-+b5xy+boVy%;HXv5v%bY+z_u9zWxsuE
zyxIrA4A26BR=e0Lv;<ZchpUQ;%teyD(joCLyk#1d`SK-6<yaRGGF(Wh7>f)AfNwGF
zbqZe#{^5+4>D9Gyybu2U`}c<Y%`R`TShx&ePt$c;*QlN7re_Pjn=lKmJMhO1fdNxr
zsN*S1u=MtdXs3n%bo{MFHl^jR$#i~+1gCN1+L+I%qX%$&*N)t&sG@=!)V^w|LR?4R
z%dy9-rSe1gSp|m*0I_XL&me>V<nn+4l164_eB9TEil?C;tbYHuTQwj|9+@36WQ);-
zr>fhkE_QUl0@%0nG2Qzi*bgBT;m0!~ID*c)5+GQJp_%%-zy!e0li<l#iJfshYm<4|
z$`Q|=0a8q6@lZ^Il9&ebl`Bp3YOy;_g8s!dH40k4Vg3l@8Clu%yW2T;V)5BJKYzl+
zcnq?4u3kmRLrN|*I{;uBurm1ye(_nqJzZuGAox^NmB86SD97&9U#tNr^fNFJgY7yv
znq6h$aNv7R4&bDKCzYL@ZFcl$5Pk`bj(;n|C&$|vUx!yRxmPQk40NolU|x<{P%}Gq
zHF{vgO$)Ejc%_FEJ2kYoRlm?!@gp(POlIBDpqX&Fzr?_<$W?JW)PJ5?mE}eeM%hi{
zslLZ?+eCQRL)E9nA4te!_qL3;*H3h;S4b3-mKgMG<U^UFsP$eVFu?=}U7e>=s_~LN
zwD^e>LfP%jCl~x5qcom5=L!WzKMaE}y>{o?8M4?VAkJ(yEc`}H?cdPLC4WckBCR!@
z(9HB`I-#kw_P3Qn$l99?2lI&I3>xCo!IPCb!{9NCfXNpZRaI3l-13J3HE_Xz5l4o`
zchI~SHe%RhGrq$N5qIh*T3Sl6y=?+A<^3kXd!J#<3Xr0Ba~C67Es%V?DfDf6_>~X=
z_W*j+AScg}+5bBZ`kGjm(5|jX7~|{d(bytm*|k({jKt4*W{AM)RZG1ahyD;8l3>}h
zvQchFEA>)13KfLlR(0^o;N$M#gfS(!I|C+aPVmU6^<8f_6Bvvhm3PbTJzoz9c=+%h
z%2PGB;L!@>4@X}P6<!`58*#Oj1X}cmM+^w_hC=bg*i8PWP@|~y=z{N!w`=!>e?R>3
z<Kvaw8?5+-PR;JX2u$0b1qL`fZ$Mkc*2-!clp9Gd=AfVe`2s~;+iO7A#hAQGll4m}
zu9=#O6)+ahknz#i>u+w(0oP>J{!}=`yK)N(;u_?R8vsCrM?wd&pfCVl5Ec`Ygk-xg
z%Mx#A7#Un0+-Pi6obuwli{M6sF(15^f*ftZ!j`e7Mn*;kgE@HU+r_J<+yXo&adHQ7
zFoCT;`8TqcloZ<hD8(C|KxlFU^ZlEZ1;l@X4Gji=(td}!{B+Q4$rnQFCd@{4rB}P}
zV%b#~TU25{aH~Rc?zhLrfWyuJEV+e)13baFQHW`N`N{;s_+(NgaMN<9R_mRqM|+yG
zn~ia>te6-Ynx_oub;jA)Kr0TwDZq`HfC%jO<{N+OV8(S)T3T8OS(aGrVFqqHATlD7
zC(L)@*Ly&qizfT($*5bWKre80RmOEDq|??1yubtqK)rWHACw<VJ259-z|UlW?2Auh
zgGf|V{o}{0@xLHi5nfDS;9dcNT1bmc3FCUOHZNaE4%W8x0RCSfHse!sg_`etEdBCD
zchD_zT1=x7@K_^GwKn3ZQNX0_5bXwuLRV*J_CJp-1%X=^g4$B<))62>3to)&d8ne&
zxQk!t$fe#m-7_qq);J%=7xw)M#aWZr8dNFE;$TH!jXQ}fAZ6h?^wDh2IYbBN{JCR1
zauw`A@tzz1UiIV>$cN@ujP-uu5a}`aT}_2psPz&N7Yz~8{9UHoum9x$K`pRZZh`BJ
zGc2KfEK6JFcKe@t=<IG}7pa%hB@S=<1#Rn{X6*{j;5GJsk&V#ij~3BM5uf<moj^kc
z#8hrt(BK@dA9vOMfm22KlX)2OF?;^4`yN$$avDklNYg!k+}?Mm5phX?oV=O{z%>Ha
zlXbH7Ca5-UxbMKiyS=@bD1PIP+|I9?fE$PTs2nxMLHzQFk%RjY5Yjvkwz5IYHV=D4
zzy@hR5fCgO5pe8=4k1ykqx>V|(3Mup;(LEfSW~Bq`YmlfvT8u6;IP9#m|3avl%DT*
zt5<(ZfN=1DR0AM|L1tYaO%3bi&}*~$&)U3Bx4bUe9&;3WNc?>`cc-`YtSmYG<&V#z
zsP=k`0LUOkmQrvt#M;Qc9CkSx2!cMq8!8pi){%V>5jogD2<$j8fhx*y#tlC#bzuyE
z6i9P!F=44tVY{#QvU>Ix77QVQ8$g>^u0XewT2YuO%0N#~LR=hBccAZ55qW0w{R?0@
z;NT)^cPBivan0pPi2#g6%*@P8OgNI&)ofiW3KpSZO5>>&%dXKU!?Zq@BUI^nM_w!b
zgLpjvSzrf-;Jvw{me)$(97kTF80hhFr)1%rNCHf&(F!ogVe$(>&3a&arlll-u>s`V
zm|QgwV-Vou>vyXz&3okN?r!T{0SGPNl_yNYg}xM@5v{GQr6naHaYIy8M_U_M0l~rm
zZaISx6BCP!iaI*+SBkMRH%DM}wY4)Jc;|Fkb{KsYS3t2~=)zy9JZ~R+ku=SM!AB^7
z<_P&75eUL3^*eV=E1m+C<xcE}9UtfvVl?{LVnBJ2+qX!Jy2{TlG)8#zjRk32ddbT7
zbo9WUf1s}~&bg<`IPk7Pe<n6(H7ejydxO~sIHA5vANOC;Ja#v-qU!njhD2PAF5Q9O
z%g5;C;%QoWjdA!3^=qpUW=GqA`I55Z6Zqp@c90s-cH^g;l<ni;$<a+@LVot1Tpx@^
z1@y!gi$lu4mCk-YeKLI!N13|PWfFBQ-~>0v-{dWAi5>ZU+7e*!WfuLutZHlMyQk8n
zb#ABqsoIO}mv=lHb%&=$cO~syXq~)1?V6oLl-Hzw+R|nz%XTJusX9Y*ZhukIPlygg
zaJkFD(~!B*5Tne3`jMn_O(S7iKm1lKyRGrs?!kYf2#}&MVw6#5GP?5~TyMVQheN&x
z^YkKrIVcfDyQPm-opA2P#;I6rN{*hsuI1~lv>VXaU)uEsEfgHZ5(K~f9UCE}^re=k
zI3+?LoO${rVlrf>efY0ZHixv(3qR75KOZdp3KbMjT{*S|)ECeiP^S?GJp(4oV+Y^2
z^Tq6BjLj)nKp5`~&&%Bq61oe(r>Up^Ce{KD-X!YXdV%VVh{I4Hu<{6W<T>-GYWOQC
zO<s4U4pRI^Q86BQRg^h|MczKm>vp0op`wFx#3u)mHDS>#Bw=F?a}}vs76kdyl_vAI
zIPH|lyuXXIBIYjmoaeXkjMVs^@l}&5F)695$f`{4FzWS{72ki!c357%`MG)j-MqxC
z7$HR@2K&?1O|KuQWk3!o$m4B6o9J}f_DmL?IVOlx;l1jP!k~!bV}UpF`Znv;!CzKU
zviimbd(WADnbGQGUJJkKz`8$aF$n4|4j@E=D7M>L#O68;3v$*ozr4I{(i1Noadq7S
z<i9@c(zdstS;bEB#|%fuhp<Iox^kt)d$)v}9C7zs!FfWYBYO-_wsbep6D@)lN)pG8
zN2_ukAcH)mYwWuHQhh4g`FIQNmv7Y_afK9&I1I>CdQ{$jZrVKsX;R;T`rMU%5;E_F
z_=M%%8~gs`=-X$GY>xSEGs!1&lr57by}h3N1AqP;?oUVIAPynqHX9&HP(fQIz2-sy
zSOhMECIr37^|(PG<6YI>-N+4T11&8k@-urY<9;&>J!U6ci4_HJ;w7bkNBR?DW7Z~0
z?e@}TfB<n0Qv_JnS%#m$m*UC3ep`9QOO@=MS~@lT&B`%gQoUvwEpf}sYy}29<10W)
z-7`*&s`c~r9BOib0&s6QO15NVHIv)C<C|$1idHcls@Xgkk<MjBNgw)v;1dEhf$R=L
z=F>oC1(;bkhiKQk1ZB2Pnio}7z201!4H&RNHb0a{6|l0*l{Lj&-W{W&)w{NceJ#YL
zbd!Q@5dF^Ht1lR7p->|J`0DThI1?HQ)Z`5UuinJoL?U`nb8{0Xr=vG;=8uQVce^Lv
z{Cud_9Y3EH;F56|O1Ej8^8NA2w#Vbn5!Qx8f_^k1#d@ve(ZB?FTvV594<F@L-Pu$Z
zui2>8k-EN*I}wm!n#*tU=C^({rt*fKoq_9rxO(fjsKWN$cSr{i7&@eL=x$UPKpN>z
z>6R{$R=OD&Qd(L-kOo0|=uSntg#l?f>pkcE_I~&NZ+-Z%)~vOjxbO8m*ZsW^Fbw;M
zPIe!OSb0=px1`Q&<3h+K&yO=hVMahH{YQt%?Va(>OPRM3Ml*xpNJwc(NA*Qv-$y_~
z0eGnV^29gdF0<@;1VSG$VATMu7K?J>r^oxH#_%5INO1xT5G35p46ri;ydBPIo}_JB
zbMt5e5*|H0Ijxk<KXM-dbSxT!#dR+QunXGMNFTiQWd-y}dg5WY;C`w<F4IQh<Sl9a
zjFd?Q7#91hJYoo2Un9PBJ55x9Hj*mBxRxADmZ1r2IAwtl>tWEjzx52%5L}4`Gs!=R
zrq9WW`7!IDw&r7DujR4y^Kp~#cl|XmuQUc6j-xF&@RR0b<>C+8WPmIfh!dR6E%vqz
z)*W13gD<8Ooe#4Cc0|g8nLnDTt!*_Ku0D=A&Y1D-H|^i>Y40eV_vkm#e!>!uKib;B
zi)PE7IUK#AF!ed3wjmK-Z!m~aQwv-w&kPARu04EuPyI&_1dcK+)?~~kAd2#n(n%;w
z%O8_6HZdX9ivn39|ARS+%g+f9^+As)T)bRg+4$_zM6p84YF<ad_-|{!5lA+D+MfgC
z<@L);T^+9#K+VCbTm*tr*Hl*&WFxxYZ<5PMmwI~!y4komt^8f1;4|ObU*cApFZ^EE
z0&{8pUG%$waKb#Ei-j_#y%Q~gL2rh(zmz=a3_<vEmLu^;dQ0^orn6)T!fh1le|L?O
zPa#bQIJs>D=#-_|X^-OrJ*`w|4+XCoP}H&P#`h}MhL7_ypc82m4S{mW&+NS-qC)?4
zD4$${@gylaRUW*-Pk@OI*oD;T8qJWMPxG0VMPA?k13vkfKPH)Wcms<R%}s4Dh%;X2
zy@(U%AWexV%+i3AEgs@M&Jc!hj(Rdswzx0U0%`ktOF)p@`|)G^SDQ|z^RSeb>STn(
zx0jTxq<q}BZ_fPH=3yII)zeE7ehk3hsw7!#nub4WBo9(N{n*=}0!#5{DbpB3-eG9v
z6)goMt&l{I8jCY2z8RTCzGLA$#B`Ko*>{KpPvYQ4772O9WfO3eMx)bOCW%odRNeih
zPgN^xU1~jj_@$6EC<ktkQnA}z?Xyk`)2t5Z(KFSS1+iDz1lqlzN%4u*4S(a|>J<2b
zG)9gkK2iOl@9G~wTdlN5?W|p$`oQ(N9_CFNu<drAcgYyCE6sthEZx38dy3@~D?D!j
zwox#+ygUoZ0DZ2@rh|BTiVORnt-<f;n6qO8tUQk3?pEZCVGbaW5)LeuoTi;;&b_Mo
z;D_DHkBNUwf`QD!&&dfDy+^ptTE0CN`TY{)&lpOH4!JHPPSZn|7@}Ca$|~)8_J)@~
zP>PPgF*LJSz~WKwaY)^PC*fmwSc-{?DK=bNkNL!_Zq$QHRiU!zP%?Q_#lcBFv0o%S
zIgutOX=(YiIGg&6TfWncHulVtL3m%ARGk&FKRKE3E*zK|sQa%XAAjc1?Mpr#Og|L6
zMgRV}^Yg5c_Worc!xjU(d8hBF$Ps`o#bX@OGL`&~OcexisMOciKH;u;w>jn)UYNxY
zo86U742J1pNcPiN{K?xqHS6}kV7@>$PBee@&Aa*Yj-RFgVWuk#dD{QGq50R}QQSH2
zp&u$ROH)?)$8^Y&%$tUKukdP!`fH(Th|Kdob8JwkopZ|Yn+1`Y(!&>NOUpkOa_mVp
zcSuJ)XyPzlfdP0*pDJAh(uWN8nIvyhf*dPx57Qcn>(KTJr=OAt#!=eQ(-&mjFYEP?
zRVY2Ct9mlx6<qX3JEozkC{B<ujXal8a0Y3711L<du&?}2WP6yd+36Uf8N$_8iXEv{
zAA5SEbX3qV+iG=S0t1p$9EH*oXkZf8vdDwBM2QYk>J&{tESzs$r9Gz$X4v5e$t-w-
z&^}7Q4M1L5!Mbz0m_!4HGa@o*LHVT*Z3DgTY|DKZEu<@|dSqtoU|DkrgQ3%7EMySa
z-3NoP0L3SJ1(!UyemA=oAX)cj*UEw<5={bY9l^};U&<UI-%I@iNx$SpM==8SlG0B=
zlRmVXAjV1Wygr&kf{y@@W)ZxXJ$|HNbTNJ*77qcApK52R(y@}lqWPyq@L@kXRskam
zQ`|RQ_6SM*Fbyy(CVT3UY|mdQ(Kv52dmJT0C3mwKfsaJ;*=4Y3LuR9QwD3;%il+k*
zSujJPypG5`UE*feHZvY;68{^yVK(9c|KRUcDB}nStjKwEUk@4zVRW+%P!aKo5l)98
z>nZsmD3BFUW#XJnvS<;*#*D;>1c4w-Afiv{P_1b3&{nc2oI=SeOf5Y$h-@N&w}5@F
z1z<LqnN>iE0Mj5S5`vOhfKD+E{xqt@{?A6NBxYf4qv=nszeJdYMV0XsIN>0ol1Mf`
z3*f!WG*5nlXu<&g3=XH^CqSzKp28_qy-(Y}P5VZ?8G2P=@q((XsIu}h0bg&fNiH~(
ziSd6CUfPWrX!Z{0E;=w_<TAoUw&}q*CF<3!E)+PPtSg<0N_;D1EF{zKILjrv^Au6%
z90Uvhnt}c71~lHBeEX5Vc+>TDxd8)dGjTd91`RV?yO6E#bPLIS51XHCZePKMY@&tb
zRe8GalX(%B?43D(1Lg;~O$@oGB(z?`8p<tg(*)<SL56GBQW$Mc5Rx@h5iY^kl*u;e
z==wxFKH9<Ya;;8F-1t8{^<%c;iS|P@Tr42l&|Fe+w|+$f>B3O-FW%iUGu>}`dOD2+
zU9`%%;YarYb6v^7&(}9Z{fZvhvz`r|lVNnrq98Cmy+i70yhz6)$2tgyAl?V>s7_`x
zk8I^U-?z4vMM-|<wWOa=Nvy_`>Lb*p-#cE)8I+g{6B7ZuUj{NWRKB}578OJsjgK7%
zT*?!U?-NR#uV<c@vyA<d#+#acUV_tW8<4MP?eIZ#OYgNO8KO+R?EMt-+3%5;+xcNv
z{^?#JCmP1R>GTcvxr;NN<QglXbA%hISbA^+08%KX$|fc^DqM_uD?8HGO$qxHCLMO3
z)sLli{o}Rczv~!uwL9?6gZWM`KZ*jk_{|A?GD9-Ndg|H#uPOMCxZo2*H91%aiw7#t
zjntgL9_8ZSFKE(Fei(cjwQv!&B}(yELxZ@w9r3@F2u~@m@fE1kru2wZQiIV@B;xRq
zQVxv;<_4LpLN;97QO=aEzfBz-qVB5+R~sVU5&wOrAw~lte!3*&XMnCHB{Bho$z_TL
zr>nUYGCik+%G-lyIG>zWrb1k*ukGa1|5JhfKN5(Z?67kVc|3AFp{-pEXWc$D8I)Rn
zfS)Uy)%$|bLuY1FllFN>S?B+K0-);_FTsuU-hNs22;ZPcF3i8gV0(~yq_F&MVR**O
zeVvei#ofYy6t?^C`{PeWgFY5LBWExBB^~rtv%-1l-PdG_bN}>h5BQt6_)Vnwu@K5O
z+5ggIJSC0JMc;60BH=N7-SS@9b1aphBj|J$V`UZ=_w4`r&&Yd`NN@ZQ<@*4ily_Kk
z;01PqUJ*(Q^3{<h2{N}5d1ZrFnF7){|B<i$&x0frYBEMGRI{sbr26U0wYhaJP}}tS
zU`KIOFSc2f$M9E=o>JvU{`VscJ^9>o?o50*kJUn?M_Mhkk`-Nc`1Az^9#jFpPwW4<
zbFl6;7uCgU;VZ7F5zc_J?4j3hi=uo53o5M`c??b3Q8a`O(c%AnZ79Sc?{qh>0Ad#`
zWW6o?_{xT?4p)!3SHwHyIav+Hhrv(((_a5+xcLuH(XHHM+2sxbvfAI(rgE)^FXf=4
zYIrP;jq(d^rya0gYOpf$&;B1h1WLn!ZiR-X>@Z(&?jQ7U+oXr4*P#FPyVdiT0*0mZ
zB44Ba`-X-{5bCcStpa<GCWu3ZUgu?56mBta@;~CDu#nUAE%4a+)C0QOk23##4u3L!
z>pL(Cj)R&+)W~`czdln$x$|(}uN;!MoHR(L@IJ0Y3p)Kz0{|@%7M`rAN!5nNni@xD
zW0B2FXhpYSld6@h((uPS;w`Pk*ln1pihTBk`+vV&${`Xi%wCs)e5}&^ZZTud>>|2I
z2^U32c(<!s#EC{m08}L`C7}0zb#UMS>rK;#<XWxIpCssQ0<y{Y2kr4<%Fq`UKO{If
zb-9{u;t9u4e#oEv?^A9pqhzw=a-mAf{)8Z*m*t3T14DY;^y(9hQ^)TY{1^XM&seSe
z$ru^>(D&Z#VfU!%yZ58A&eI(et0LX^Cjl{EIQL^I4&G#zhcKCK__Saf#qVr0XARzc
zcvkq|t*Va($Q3X_Wf`3M;7C%C`i!t%6c|lK)(U+?g@e$JOaGG$*ea2*_DIfdGM80f
zAJ({_I`c1K$ISly@rPFY0LM15|0Qbr&jH{FT*1kTS(a9niUq?(`~10<Et0gh4+BSp
z4q5yZiu_67mOdX>dvEZ58!asX1#SNQ@`h~uFyr0I{|74hpNny!p-tilnDEFi=-Bq^
zu@ytSXiQn9?3(9IMKvQG|M~6?dWTswbf%m}^vZbM=UZ@O`>9jmM!Y+E$-(p0xk?*C
z%?bPO2IR&dMz^|+j~GU0#0-5UCu_FAXe!D-wk@2sbGmOHc2jm3!O)Gn0M0IR(~g#~
z3%vYIT`i9a#-3+gnIi30$%f5E)@@bxdfOttUiM_v!mC)O^_s#m>TGiKIWEgx`IQW~
zkCBB&Tpy|8-K?<B%UR9J=F1)=k<uMYau}tF;GsX4YGY-Hio8d|>I2mmLc%kc#Z=i(
zyzqII#8ibY#cD!$)EDB8Mlo$D_oPS5d2($(=?v!>hm8NVx8Os-<;FcGyaskmr7E7X
z7c6B>++!M*J8NL4MyVi_FonM8Bs&k!RHH<t;)<!*)bdT!?O2J%f}pbN$0e<7LeRIF
z%B7$oz1Pdb@X|ZPa`JAhs#F8RDNeH}JZJYD&1eE7@$toLwx_5p_N4`_@$E*Z7+ZSv
z<bd`_1lMrdmzzJxBNFC2w$#!l1|c~m)hccwh|SKhV+^8^1$vJJHMsHepZ2}hXvPur
z(n?OWFVi4SMxaaF*vOhj**%ci*b0JVKt5(^m}ou1>A&@TD3~INPsvGPY{yXEmm`A|
z0zZcY4rSY7!sq!Q;TJF_(|XPGKvucdrV~&_F12kIuVbqWAkQBmWH7^rR_v$+`NA_^
z3Gt23vP%$>Gelr!up0?_kfbM4*jtUfMF>`mg(8;Jm+Sh-gv9antgr|01qr>`P9g;9
zNi`*xcUCbhKe*W;U<gXCk&&|RDh>7s|6#o_?_n1Q>^F8VJ?uET4?ceN5|>hzop+z|
z7D6jE8LB9kO!t|yA+*j&+RAlIu!)Jw@SUnDA|8qOV3fagWM}-ZF?Jbh`?u)nT=>%&
zN}FFS!hQRgHsDaWms6=I-&E?>fIZPSK|O*QkqEmNW`!9MN;9s!3=4u!5QI(8QkIcF
zyeeYzRdxn{hcUb!z8qX~2T>vKB}Y1>Yzl-NC7z9#rrLEiDYxTl?o{Li!^@`G0o2(A
zT5Izq_w3NLPS#Hqc`CyvLtmt3kZK^C<R{bPGRcCUphAb^@&U<-98;ujaI<_Q(|nnk
z`jR_LNCd~ulGaGy7Cr{HTU3#$eSq>9L?T)hUpT*PXK0IMFYfS*%t*sTSK=7o`Z!p+
z&rzz%RxI&Gf4wRh9`NA~S)MAKbQ&w1g(AdqqFSh7QR7-KX?U8ASPM=6BZ@dsJ0=|K
zi4aT)Ekg`ab%Q+}lc&$|vJs??K`FL(<*kzWrfj2KS<R;vijTTXHWIm0-WX4`ueI2w
zr=EH-v%5Buf~agLvwhHkXRmsNW|z+*Y+!Hofe2~OICHP>I=)`xL^ve<o1t{mk?SKO
zC%sgFKglOgc`UW`En8yB!*se`7WUEvy|BB!O5=Hg$e+zz_&q=B?G{Q1Ir;tQ`1R;b
z<LZx@r$=0^XcfDj*>R*5_nfLZR`ZTBLKMZVqS4%=$#&bN6^Fd4_KtQ9_VzmnO1`1Z
zT$RQ|<1!<BuM~9hmj1r#D63jqg_$Y*5;f5*XUNR>x3AB`Z)#@V*=ex#NMAS_iSlKM
zag8=Swc=&NIL{$ove*6RA|1qfll=UcX{^_{kp_Og`!~unNiB_$BrOappGkjgV^+)X
zz<+?3@lTAbxib2K?rGaJaV;MIWB01UlH@U#O};xTbtY<>b#zLi{D6Mzw~BBkKaQ7P
zsx6uA^tw%;K-yQh%IB{O^$c=t=_1~^Wz2kIn%Fz-ywhJ&XO|t?R4i*zng__?_l0_s
z=ivxew5*d17>VC>M~;>QD<WMNp%E)#K&8eB*PjdzsQdA?k-#oXfuHuLQqa+;vT*js
zKPkL^hYyZ8f)gakhkMB=iLt=Clx<JOJ6oNyuyId(OwYA*o8O*G?$4*qgT8wY>SPx#
z@e@wlN=VqY<`4aF_ad+uXXZ9Nq!|+I6H->eqLmX=Hs$Y=*`0l6Z{hvc_9mBJopvmD
zcV9a5+1SW~%np!Oy%-OWDaTTYxS{#%fGxlrhp@=!`le~q#s+GAO6#~2pf@>?z8{bu
z<b0mXJ-a77u>?cal9ZXO-H>8a5pdpo;ZD}W!ae`;Vr+S=odL3r&&ajV!n->UJu=f(
zy4E&ULhZFxu4uN^NV3kL=cJ6NZH(+1wUBY!&{)y&4EILOP^(RM+=vW)F|oPTByX=!
zL+61`{^rtgt*~D@8Y|-<_Q{`Nld6$<U!$)2D*Hs6eCM~f(T-eYAb$ZKdiG^c-tDFI
zMD&uvi>v@)S$)oJ7e;ll-wfMeCDfnRvEf6{{0%`@RikM5<9t?dQE!GcXMwE(Ub)=z
zIhG><N-JqgTCgntz@gSCQ>QM+cihG*!jU7jpN#V{m~l5HWrruIg!nB!H}4(ICnG7C
z&^Pj(`t;O_%ruXhWm<<YT4V)c*sG%KQflO}2VZd2-_G5{Sj4i7mb~HdyYOKtLw6T<
z2{d|Hcp`!g+1!I-cOTz>q9g9~x3ZBQWJy=WcjpqeKVHvI=(VcXZ#n-jyt;F|;j!1$
zx7Fx2BTfA~at#f!5Hv1B$>l+T3Cpt9C4xbC!XA=YMyF^FIWYi%iBBi!1RDfMF}~jK
zG9lMHIzH!#y*7R6(8j|~U&uwWZB=`j)(wB>Dm=VIVcarq?^-kBrkqou%#cZ(u_G2H
zxHh*f^uy@nMzDfv;jRAoxeEF7*T#4BSq0%$3_?lV3Bwu*N0mHTKR=UkJ})D4Z&(}#
z48B;#E~mKPn8S07v#Pp<BP_<2p{<q5QN}bj)BbhG)4_9E4DCKL2U;SJI$D)V1!+^Z
z0zW?mK<7Ox?bGTI@SG=rMj%x!NI=O?D8uVT=!G1djXY2mH`Y5uWfmt5#DHANa$!3>
zYz;x9x}4y;4;0Kj->8J|hA@Kl2|UUc97VG=VK`HGrkea8eYh}}m`Hm~C2#a3LAc)P
z?LuaaCS+yXRmynub_jMygni)r6N9U`1fkN%y`x>$$}$siu4T<Vc=||z4iBH8J4uy6
zFlVNcSlSGi=X`a+M})euKHW65G(Ghq_nmE1x~7WbKs!!W!HxvG--wMmyqxoyjd;(b
z=|TY4W1AH^V`RXY8B7V-{CxEvk}r9}0Khb0Ax;`xKsl;Z%-J;>R;N$Xu&4$`QCu^X
zlkC*6m_`&>4s?^fy*8}!kXcUP+<kB;WHL3@M{iudC?7Y@qDK=v)@HyUnOH9l=dG0e
z(1bgEgV~EL|Mo7+bKI`{ub5A?qdt>8E^+ds;LwaAy4|rITYkp8GKZ=uRk9$tuuvRQ
z-agAmTyPGA`YkH)RNv|Y7?YpNLvU<Z*Y-W!1eEMUU2bNCxJVB0oZ!A<USd~<FIefL
zy^xCgL=~O;K$+J(wp833+M7|tkNPn_sOF4sE^Nd`HYE8RSXhC;g!O>Ze4Az)Vbj+u
z#MwRqWrtX-x-+vK)hUgdY}+JlWdMkzG#1#b0zADcq4G2OB=7W|#;6Vak&t+$aT^gY
zS9VCPPT-uJ*qdFZ1@megQ{(2P?^i8D15BU-8s}17Z%XcC_LlQ>Og~&!Rd6!0bSh}W
zStsN<)J-H;<$B(Kk%+Apy>k-azB7`J_}*Gskv@5$#&K+y0uXYvRlIqQsj$6rhiwYe
zVUb8XJbCCGEMFV&2^$y_K6X)SqBWecm6RWHsqe8db0$|`_WX$hNLzL+Z5b#8tlCO5
z0dykj<)CV+#8@0hm0miFENNz$Ex9{$78g>M{Dqp(Gq=$DgUHZ>NJy&dap)=ma~1`Q
zIfR38ya8|`lPm1W`y|*Jl_DjI)>dmBFEnHTK?gAc@~MuZ-)HOvCrb@JGi4`<wI^dH
z-&}$6%I4bl?_AQ&`b*8H)^4b{GYxU{^a$xC^v%srsA(XWRu$5rkndZEUu~e3+JKks
z#Uis@1V&}$7Af9oSSOU{ezf)Q;|&#AiCzY&%?+YI6JuvN47Vv}qNo~#HLsJr<oDuu
z_-EJ?(rW-}3p;P+{&+(+G{X$lv3AgJ&hKXYm%WB<$&2Lz@2*u3PJxHMtr13sm~X$s
zvRkV}<+|Va^Y6T7&3ba#@Hxt{ZRK+lzW%>0o@k*S*g;s-H=%ME16~ubnlRo9Vq|DD
z*ETjc)gC~-({Wz8KYD7sJ%~nv9XK4DF4cZ}zR2?^;n5sf^^++*OC5e&1`qw&o!&%I
zyN3~}8XN(s)vn;lV@~brx}cF&p8=pz@>7xg2kQ-;ZOw(1Z37$L2ifFF{cviTOwNzP
z_~9{5R)IPzQkbTIB)6@sv~rJAk5EmLRu&gJV5)4?3aA2Vze}ZKRZ&k)t^!s_Oru~%
z5L~%qby;e#1M^IX3*$7mJM{@)Ky+r#;HN`l#{dPzg`K5+WfhL_y>apIj6C(H_^{Ga
zGRY|sbyd2H5(5UtKvffpUU6aqt4OQLCUzz52A&!6a8|%Q+Q1<j=+BrC#@V^Xnyz}I
zbe4j_PVW;liE1vRC2j5F(s{O}Y;6^ZMEAqJSOw<TB8GT<k0RC)P>Z%r_^?niu~Yr>
zkwSmHgEv+%(X2>k%i_{}t7G7sRhMROZ+D#Qca=q7tjydnQdqpaOoGHoXGIc9@mhpd
zNQ77fR=Fq)Jo|{#0sw)qID(I_T8fVtrpD%FFfreM699aEg>&gkn%1*?KaW0aGdDIj
z*E2i4Y$Jm4*IQ;zL=HFfj09xK-%GVE0cvx^x~iFyu;D^eL+r@%hk=_Vs_0)MP6pg)
zFePWj%zir*FYg<II&KgNinE@C$1i~Oxh(N>tJ~p%1jW+bb>*}t=qk};8~iynXNFIi
z(rqb1A=)Zxc5%Zle_QRzBtA&cF=C==rc-9RmJfSqTTJ2GE5|Hs7KWZnPv{RF#6oR*
zb0&6m^h%qXyV{!n4m4FoLb@l|2RFHI7$-a^y&@s%Gg<l+)`@ybP(WZ94S9uJCV>s1
zqz76~_3LUKJ9?b6UwOlzXrwYA@q9(_ej9+Ehh0GAi8Nyc1QBC?cJDkR9KY|@i%@7h
zUv~jDv_$t*FOy|Syh2Cvg_Ee2e+o6Sb`LiVQ^v*3&J3osq+1*IHb}2%hCQ?k>VZ+w
z-!p7y^_#-%D2=lGWct-GhhMbtdxgD2xBqS`b|UQjQ+DTb1b<Z>+YkV$3nAl09-$D+
z53q>6t@vV9ls~%X&A)AuRc?EXb42ITrcJM@)}?lxuGNkRR>RuAo&G2*I=@~1mwrUq
zqiI5~6EmCNXBVtJLDJ|E+fj~~+ATt4V2<i?)|021+bunK*_92}jBm<)!BEC*jYW+(
zfe&D96^<!1kXl_hzg@eu&3jgmKweClqgr(zxUrFK>LT`lx@xSff-@4bQ97#y#6g;B
zN9s?cGD;k_SF?Txg&?a)26PalNDGwJ5)S&!Z=k0mCi+`2heu&Nwc<<w90pZh@jXUl
zQ_}n3^AkH}<3c|{7{Elm@q*d4yp4R(0&I~WT*#|Xs`7nOs~@+3IcPfi$gOG?HX+Zb
zs62aQbqR4{Iz)vdF8m`ucKRDSv2VT?S8LJounq?9D*|*GMtMqWvjx_)it3Ix?|rlP
zBDG~W3PJqe)!0=B*(3Qsg+lNdbH&jxzRaHgaA8!&4|S+mh=j~bfEWg{_9UGpKp<-Z
zMjBk~SEd;0+Tc%J_Y3mfhE0*lk>35*tBcbI)Gf3)QU0=@BAwa>27ob4#3rAqwo|z*
zS?8BRT!fLQiJsY|0T%*7kTc-cIMvWagf2rQ4=NnkX%6eknNp%;+=BW7I2DWQJzZhq
z@05<&`4Aa?^8-uRC!3u*O6y9Jgyd3v0H=WtAvXI)LADeZJGUVl{i&>B|C@YlDGoyI
zIT*}{bV&&&_R6h2ROlZ+uRQ2)HHrr49($5l>0<znUQj?1xkVL50W@kEZ-ALBCgZHI
z_7=AXJRP6#F9ujx56h*Q`NvMahBq5b=#*1b8IFww!es2F1j#H}&Xjs%fSG{}5@VI8
zppr=KHeq@wh-N3tvKQ|SYyx4}h!o&Ppo4g)BGCbjbumfao@99PQ~`P@Q8>8Xj^B9S
zMTUq;xiR`OZmftEPZJjs4q?g@p<Jg@l#%U~N#FDr#R)LC6cdiz<1(CyWx-3|1gZow
zkBFeQ3HCGbkT&U!Ola}`vUXticAX9k$E^NfY3ntqoo+9fM8#X(8Y?ZZoUf`6G^Gqf
zw`T?lAt9bL<xbg+C8iBo6g#_^vWBi2uThQpN;$qvgK$J!t7a@D@OBAs>P6<hyepj8
z1@@v=Q%N&FNBgXtqB?`_YaCe4d)9-=t1h?h*wN7d5Z_qiM7O1%xHQ0uc`12p?ky%F
z=I3^hpNCj)b-rq<GN{&fHcgZ|QV;>i3Vi02v>voUTlMF$vCkIj);iuNXdCP6*E${y
zeQ{nmd9Gov%uRl{caU9>2bkbiIIsYG0>6`W0NWJ-q2B8bJ|3~1&%bEijLIE6e?C$3
zF!YUWUvShTZAVgjOWGvjDFHEm-#&XgqvDGx4$l#ogf)xJspIlG8MPDlOp0Xr8}<oi
zaU^wy)M%?{oR)fiVM60Xf||!c<LC;)PU#=a^MHHgg_=Zywd4D_o!qAkYm8C_Hy|%W
zZ?EZ(iT9()Gj$xQ-bG)XrSJ0ap!~6x;|O?Zo^UrSp-__NL1ZMNzc6<kzVr|)`<~dP
zOcpb0^!R2{v_Q4*X)t?a7E9W&4ISMPV2u`;oZWW2d|T!qEG;O^FzQjMleV-vJ8e~O
z+?n4WQ%|G-cNGni^E&KZRdba~D|3tp7Gq6oZLN`8@L7<dpGgB3El$oF>mJ3+_ZHWN
zIS7Xny#h<As@RvYv7}YB)>wajgx5NSLq(dJlUlGzCCtr@^cE%~8E~T_to!6VrN{AL
zszLVkjk<8_;y$^;PzynX$+G10{QmRUN(UA}|GToruci?Bf<ZGaJ=%*q>{~Z}tc1oA
z@4MiuJLx#OEA#<VGixtf01O4)EavT=7~M(+9wxSu8ua~W_Q%B!f7KugkoOM}5F=;R
zXKzw6!ponWJatg6y7N2frpts4%^{IV15@p($ywrrNVABC$|4YmTi;pED`(CL@46GX
zr!zyOmaeIh8Ofi!1L|yD1rPkcip(2r18i|~^HWVmS~d&6TovH$ZSCCpRh3Ykv`yfq
z7=PIL4S7n_B{liF0d^kxIh~(}Bz{wauY+lib6kDzuJ`_|BEODpe0FyMT46yq1JYSp
zwtfPo-fIsNP(=Hb{)gu0;xr&vQc)R^9~ORbaLx@FZ<t86>l$rfO}%MaZwr{S^A&FT
z>e2CqUrgw^MD1Z43nG`**8HkS!zXTTd2-dMX&D3U=VxabJzY@fl8d8*Ta&Ttl!MKz
zh@rN=8y~0J@#^gAyo97Q<j;+y=;h)Of%**F;NWVUSGuO6mWMPQDnObxM|ALwK-!Xv
zfXVHho2c-&#H5xj|EEl|oj!y2N61yAZh)<ioDSZAICacZ!oLP{vrDuJv}-wfdU-k7
zpKG0aD6d>rB!K%96PlY|x8>u+PS;3G;zf=z#Y>5~BJybnvCu&vMGuc)Yt_e^XVMd5
zO<xf_`U)w7AI#9Y3B9t=o%~2|q)!Zm*`i^ta@Mwb_=Vn9zIJv_=pfCNNkcueDyM_3
z#psF6!pP>YeomFK5YDP<V7ww|Xvr1o+iKTcnvVi4L!`+&gAWJFcvgbx{FEILm6bv|
zn?OwKzmWikl{qW0vbyHwKn9p=!$Kzpe`GP0d%5|l=#c{BU~*k=i#tKF*qS-weL-DU
z{qUP6!u1o@$k}<ZW!l8BF7vb{?VpQ);kB^YGkTAk4my}puudFQ`ONTZTiN^fzJZ?a
zzSdXNbW|>P^1pl`S?z2bV4G3gB2FHoJ2x98SD3PaCPDsW^c;sZlH$kw-`Y38ltWER
zONIL}98z@9c6*R53HtPN7eV=KURNC=pSE;Fy@vscPOT_z9kcU`3=f;yD0E<1U7k|#
z4*nqmCUS8D>=p<J*L_JPoS$U_<w7(`2?T^ua<VGQ&Vy{~dW<mJ?F<s@zBoKo4XqjQ
z3J?`Bh+!NRM{BQ~T1T3ROt=AZVq7gDDO?ID9$FI=ZU#t4e>M5VC8dYH>fqE4@}e(G
zwU2Ug?%I{J4=OT-MnV+p8w>081eH(vqhhA4%oZ?ZE1g|DNu|&V(@2Wr@Vw*~fHrbT
zEK-8%>KM=yM7{cOOQwfL`k!fI6=>bzv&F?|F3LZsj>*;K4Q`%<56srgaw(ch$t63@
ziHPAC%Sl3xqrLT`t3bQ*a$_k;>#5I6Z-81KfEZsu`HY8`qo$(jBY3U*^wUD8xajXU
z*%LJD5X;LtKkqozUK3-ocjIZCrGUZf)x%ZDjq^`&?`sF6007)mS-Gx7!rt`}D3Jm(
z!*GT-$TM^c9g|0-{Ywg5tcmyj*_$^X>4U;|0pQ=a)5W=_3VVmQJ*QWCy818v{ObBo
zq!#^8A%$XrKPPoUd{W{I;L38=X*5X-b7BDGuPPQGKb`(;pE!AYu?|=&O*ia@Js~q{
zmO7#tG;0sMS)Lm;0j}HSmD#%tZ*CNxp;K9C-hKacXhvIj240X<?7NK8&({)b)Z{##
zV%MnzWr-vkmv!01`Xg9>DEyPlPa-isKs?)NI4{K#jkhCbJkPD;U#PoL>>r{++2M=!
z@kiuK1c3`gKKgw`a3Ef%zfGRoz%P+cL^CoYaNzZeQ{xhA(z}5$1`TB9da&V&G^<IO
zoa4l&Bt5>$hncaxp5;y)T(bRjude2Zt>}<t6#PU`@fmt+3;ht1y;0Ln&j^geDEd)u
z;Zn1Q5X9{XCnd{7s=YR>`3rB>Fk4Vaa~w^)gS<-HWG>w%Gkb1=h6yf=tvsk)zP)KR
zO5AK-^9!+6KmOedU{=g>z6q+s?61g?8$=7Cl|y-JfbH(A@YtKCv+!RYe6gvzx<@wZ
zax}a^g=JwPlRfaCNkLYDPPq_(JzM&<v&tmBq&}rkNqiNUkJHuCr-6@`w%dVEKPmp)
zK|!pgwi|CX;Q*mGvYtUD9D0s^>cbcK{G=fkV5wvquN*$hu`g$TQ$GZ!y&@x%5>a<O
zK5}w#Gt0_3;~w{tCS>@se5~IdQNbgx+#nSTEu~=xM!&e~2+$pA6ckoY+q+vzynXFP
zv~*Y3=ZX*8hF$iTJJj{Ih!z0u2=L$xz=OAa*f}4mT-xVAdL5gsMG_Y*Fpt*Xv?7Mj
zru?~==cl41+}^o}|GGMpo`|0s;i~NY&M+0z`MIT{)GTrE;e~sUfnSh868B&you9#k
zJ}_a5Q+{0neqBR-2GXl1(p2vd$sM4^lZP`p!Ufo?1)C@RJUm(ax@3L?yv7ZvlZ#`q
zZb3m_vtjj`NwZ?_#?pQa@O3w^BdV?g1oMuDSZz+_o!b1G%A)udY;mN|r3)71Jp4<*
zibmw*?3O<_HJLoeFI0cgRR2xunU(<y>A`Xb&^$>=1W)c?B=)(SNW|vlM+K<s(I)=h
znfEO^#6vZLH<;{kdb64qjI>8k;WmQb{CuC>cU8m)D5PL1U$juXso(28LT)X-W%zZ~
zLIH$~e99|s-YleD<k^q^ghyQ<F92psra>%O?z+!RzzW>xNEM56>|jyq5>3*e;)f@4
z-z^8r#_Zyv_Aq4~nwDW<pvX^6omE``X4Y-KQJfEfY^z-m5fu||8Xr?rfEAw9NX6x{
zw$&QB{vCjef;Lu>-qxxn>cPd_gAwn6;>sM#XF#Tio(`n=Vxr&VnXHn6WYg73ZOPKj
zy0VaZb3VXymZIdZGa=fzRCGwq2Trv)Z(YmUlniRdEfPPVjvg!q+Ix&VZm`o3sQuCT
z>CkMPW4zKy_pOqXJWfGpu0Dk^DX89h#x6*!zN~_+v9+*X0aDt!RMGaKj7Q2B)d9qE
zvxP-norO=%*$iO(1fE2u-Ps>m{Z1=i1MV7}sL@pzVL(tuh4cTWj_ohX0}eZWaq~Dk
zIRZRSL{1)4q$P5{&8^-rruL&8<FL*C!BW}ba<nsu30Rki+7zz~s_&{OEva7J=dP)!
z@#7mOQ5n;B=BB2i{f{IZ7>6osX|*IdV^fo>Dqs)3@ozqVz1^39m6RZ>t{Q6{$AH#a
zNAjws(oPa|@#hle3zM^p)4;liPMekrrq;pHdXXdWV-V2f`dpuIY0O$0v9Y-kK2dfy
zO`W@on~S4?UenON%jp3Q<~ty<N-X-l(@bE-UIf&Ru@Ao5u`ACpmQqm}6#=})b%L!M
z$J`1K*-%eO6Dd)mJaAEq&n{4LD=6{;SOb!mEs@+`{kmjiEGi+2OSIfz{mnrT4HTQl
zs%D~r#>45GjU-ozSu+PRoWjH9`+FBJ6MLfo1t=wufo;5XaQU%)*^;TY?Kp1+uO(<h
zPZf#e_9TL7PB>#kSZ)Wz>;+2GeKX`HJXz_sJ#6kW>CEKKCB()6Z_Kqnn-RyrMbjh$
z7VzBiH$R%mWmhI95WGBJOcQDHsjQSQPVrk0w6?O!-;KKayZTa8GVuI?B)n%~b`Ary
z9(>1>PjT>!`tTXG`&vhZQ)MNO#3nCtqSNpGSQ8ozadUO2kO%S`HV8O9BlEEB<TB9M
zcx62AAz8a^K9uJWqjR@l^!;TH>eWm8{MuR7LlJ1Zwn<KTfZktgw@R}m$<tYs#Q07f
zabc9E9saSh^Hr990m2b;CeUSfDNBt?&=PxtM~c<zgQcw_;ml2r_fB`T<vJX}u;7C9
zdSlZXH#`&a{Mf*fPV{p?ZFp{TT@|j)M1N-R`p(kwJ8Y)MxxA!A>XJiJq!Tos)!U0a
zyyq$7<@{z+c8Iq_)>LzWHW1M7p3?!7(koAH(b*6#>X;uzQ}c<uU@HX$GT8Ne0#__I
zFbU)Z{arpH*clNJ5S11aqQ$-SJ6@6!o)mj7K=&uW@94cIL_TNDO4NjH;FY(T7auQ>
zEM>y=;*(l{DQ`*%$eyy)cBH2IIp%y|92;0@j9cbegx3#9#OIENww4x~FOP8U!L>Nl
zHrd>G>U4jUgvvhPi}GU;AlK0h0!a0!C?gfH7o!y}CV4yqU7Sj)vLK?$`S9bdyLx;A
z0PB{muC7gx?*#__H#c*W+=6~eYa|*7hf$Tt!muQ{)RIsazFFKC@uE&~X7+?<#eJ>i
zz{qq`x2egRr1x`25wSLqldEz7!^iK^#fwzR$4rMb;LqQhxBQSlK>*~L6%6D5Wni;(
zXmk;<N@=Yn81Ve0b)UnGoo0|R9tbiNWCE9@k&}n!ln34YsPM)MM$k~taSqL3W;#40
zJw1S&f_%pwNUH4Y*~av_Ch)w3bSO7ityS%$l=got?p=Sz(_~O8iyb-WzcB)R8tfFG
zTu=oswORY|Q|_I%7ajtg+x_&2j{1oCmY9>XiXjr!C<F@c@4p#a@m+QiwO0lb<jw_N
zl02ERzx}y1NjK7NSHGnP&+Hmme_f4@ar@wUQG$RnW{MrV#ZbQS3H*z-NQkj3Fze&g
z(VH#cOa++BPzF&@tez-<pc7{x7~nX`O~SKx1pr82iWOJjMncIGmX8wwL;zGJKw<7;
z>-v6GP1SkuIyw%bt!pYRdJql?Sc^MTnzgCN#P|mUYQ+>GN-!yz6qeRg%y+=oR9o}E
z+ig4`$WU5GCo}xH#8>aD4U0*!0)cv4+M3<0+&-WmpaMQTaj%MfBZyD|YFAA$3N1AS
zjdtwHh{Az|#MJ%an2o~s(UuCfP0gh4*yx~FAD`^nmlMI-{~mEweWs>v*@kjrgD@k)
z&PNWI%29vE4r96bc##=!z4Q!&L;^yB3&6hHM^spp2RViu(}+v`Pbd5cBhTTX!6k+P
zGf^C>5frKk<riG!0~Q5_O-%vB*!hh=H>a|;veC_F=TPlWl?RhD7A!R9cO6&HzjO~7
z5hp1i1e}x|TN_I*d{0FbQYa{PMmRb1SW5wnZFG<oFAXjl$f$%+QA>*(h%#@E0bWCz
zqqn~dpg3$r0M5g4x#KrW2(1N6MFYZK2N!R^;T;zUD$i}34b|*a8GiBARRcLpIND24
z&!Gn)u%M)Ltk4gE8HCVJ#f+Umc{y?r`IsO~^!E#v1!Yd@$z}6@>o*u-IH8&gmm>$%
zX-m?Q(m!}9B-_7<(<sngF%5c<YJ;G?P+|i7%b(Led3%9gCc9bAUpg9I>5<mi6KVc3
zH+674%*v)j-AQ{$*flMS=;>|wdnj|5gia~h_<w#$gWGT0T3q!E21HCOv<~0>j#_6h
zBd&~xV@2cFqmihjcjgmE7qj`nPgF;_fYt-V!=BGfvlk<=$c;_2=sSY(m~5JsR7be%
z%GhAvKiP<mX}rb_&-zmIdV4*dkI}CF^>C$nw5khQB@+fXAklvLJ{%1|N6!eG!C8kd
zde$FIn%$&=4<eimcy-#&bNr04A>pF!7)+Cm0eBOrwpzlAD}`Pw;DcD4Cb8d|JWg-H
zC-Tp4U^sXbK`UZ^Uj<?ToqaSG2^iU`66A!UM<!3~Vt@>J^d;!Z0qcSF#o2ckDT+lY
z4*ZmF#c4cE?Y@18+GCxEph`i^nr(kERO!kW)yl21Bpj71Ba{1$<97;Q8u@%0{;4KV
z6QfH`B-U<Z_QF2z-4VZzg=sk<6e(wl^qw784*N<Hu>(x%`?EQ(lN!EByBdyimuqLw
z?Fpo{ZU&xMIMC(CG8`gbyQ=w0IVC$Y$nfUb{N+F6cMdhp&cF#JO_8FPn%1qMP*YsI
zKb3OeE$_PLBRVg9Ii@C-JVzu+@0<U6(kvPAg`xXQeVY=2ymQpghZmk9Ur#tSPN?z5
z(AOKLYjYx4iVo8?!Jljd6?z#}J`cMjDlk_TMHi7Ky~1IvchF5`0Ruf%=XV2(a!j1_
zu+0Dsu%;X*ponu8NWOVS**mlYJr7((wtv9#QIfyv$wCFJHqNBwG`lQ_tetwbW8d<S
za}A<^Z&oCNlZIg6jX=BvInOJI0%nShpe$zRi2`79ismALiB|%$Ow=J&AXR`}7z%SL
zv#IM~ytnXBuCNiTsH7&qVoAe6S3;Zg!RJ=+3xlvQ$)JN%n7AqdcAPv%0)W`4j0MV2
z8081SajB6KwQaTeoBk@pzwf!@mZ_5zVrt`3W4HqvJVMc<A%h+r3?R^e;>Tw>D?qM7
z#`;1)6c7=?GYk&e=)l(!iOg+u1Xw_)pkZsH!}%zI^q~2V<twmsY;O9w%DrLvC}XZE
z<t>yhX--7gK-a(;Ii{w899MH{BTpK{lx2yOXJ*Xl1j8^v(F)9f9&i&_Ra)2_pc%x2
zNs||cp3_VexoFB@Y5n%^D(ecnbhdJPrA69aEKZDr0aj2(2kpr#Qp!b(Cz4<i$^4=|
z0y4v&55Hs;fRa>#yAHY_EnrucI?*y7hjq#U(>gK0iAVj$HcdFbRde#C*z=o5_fyr7
zO_kJpCP5Uf&l#IS%vE9IT+NGD&u2P?+C|C#*-`#;=m~uk>*IH^-XQ#d|LhM%-<SGz
z#FX!$la>>0O&qB^d0cg%f!&9fTUBpjs{M3Rmd%3J>%v}DTpw(cQBkFMn6>)^8C4Vq
zK8*44rB4s>=L?hYU^^JW<BQIQE9RWVf`8&g^fc%3KNa7-e0V;vG_+?}HTOH0{^XRo
z_vrpN^5|XFT&f^(@0(o5ngKSpChZ!1FHa|9jwL5i+Ch;eE|)<p%<j1cGexd7X(u(a
zwl{*gU$Y0}J*<{Igc+DN;|1)N$kB<z^p{b_aNBQU!suv%VDy(y-wpa?=<?L<!&QwB
zV=5dcoE5YTYts{o1$RxI0T_joXp-y7(yC!Wo<(j}hxh4K$QYG@wt0SDj)m!2hd!x-
z>01)<k>seZx+Y&51I{@oQKG2^*Ch?zK1!(<ZcvWVZIxelTBL2YhfUdKY1=Afpt7<$
z{(<Pd&r{&OPgCMF1zETERqZMxdB<Z3e(qF#^}`j%gwH^h$i^9iok&QD&x7SlF#1Zv
z&(0fLs{ky}!p}}}7_^2Q;EuPwD_xSFHx?RK<K_~)NP0eyjHmia>(`wrSf17Phr|=~
z5B`QPE#q5DwNclUAlE@rkI`sDUIWSou0~X@5Yy+=Qw1x^kBQo98VP-p)~gLi#l_gx
zK*t?yb{#~R82-*pD+BHd8au$wXV&S#^{0bBmS)gZB&RGW?9{Q;Y#~Dn92#G*UGdJ_
z8)~b|nGpkxg$;5z)?obfQ?=zN-h9>Pu}UK9nF<tf*nHlZO8LS)o)r(<oSI~#%fXu>
z;5*`h^ACtqXnz>cUVgYD!LvfOym%4N@39I12J|$rg7OvFAbMbu*Q@^jT#f-g=JVOw
z+6aB;*xt|PFYl8=F6p^P(U~w=iq2w`nP4`?qvF}Ev|`IR*V3-PnGb$<mZ<k(g1mRD
z>ZlV2y6?mumr<P|w-f(vrl(_Z_)BT(c`4|hD-~=_eWlo%AV#ob;x$ATlJ4`E<&CD*
zmX&`}zWLfEU6>)!M>GM)94Z)NGP|W=;Dxd(zUwA(M*O@;Ph$M;lv0k7Zs=Y)sCtgs
z<QwAko*pzJOPKZPnsv;?V&rwco>co9gU^eJRJVyOCgtbKgwm?@yPH%WkzL{Qf;zaY
zrM_y$(diUrHmWMG3ove&lG8rGf1j-w2>Y|~ji`OiG19Dh2%T>;typXhez*E7J|_}a
zo?e1w80x90Do+|!_=TG{GWL1k?=;$FN0i3<kDoHmjcY!>T(yozbR3w1S3E{D4t8#X
zw&FwM`<zG>N(DD_b4vJ}ljtQAO=v6Ex=`v>OXtCS;E1L{!Xl_myrX)2y=N)Rl~I<%
z=oxil@8p&AKo${0x;~qs5?Da=#m)I{6Es$wqPL+4I$J{ftt36ZNE2*j<cqq7YK+R(
zN0u~A<F<K9{~(#BW9;uI1jjEHi_nS?(68P_*sicWd5RvduIBp?+eRLpuFIL)+uZ!^
z#nI`Bcx`)&=jFkrNyvT9qb+RNh7@;H6s{7USc;bL8A!%{NW65LO``r7H(DjvS6pY&
z3HtHSc|2f6OBB(w8}BtBv8(;cIL&rRMTKeYc`g*!bwx{sgM(|1nn_2cP(Tp^(c1j;
z=U-=cy=&(0d(j>CX8nO9pL0%Yv1V>(`yl5K_XUsDoBr)*-%juUg*+w=t7b;@5X$}B
z(h`2-WRFgyIWpAXI?&>H)sHH7x9H}~;QH2m`zr1I8A=CJQybu}H~5xfPa5;_*3A?C
zrCWP6VQNE-eM>Zf4Rq)?zW?%4Qb3|;?(9qpg4x@UsbBm2VSnRxWg#Br{&+M&L}l&r
z?#+Rv`^R*+;BV8njK(!=6sA?;mvLXXsg!FnY*$pc4qSTu8NW1!G|j7U+AI#ISm*Bl
zlJCG`<d$daQz9{fyDn2d%Q3VFQI%KWq<ZC?M5n|-C08?SimPUU@KD{hL;2geZER1x
z<{8a5F<mzdxjSFdLBAbyf7Hrl<XHbTOZ27vuOM0|o97xaL!_1E62UHPBu$%2Ft#K<
zU%G>@)FwLnYb%!j#V>cW!5aLe)!X|~U~Hp|S--tAtb5j8wBYojD`a9-5RzhRq;eRw
ztye0{q+yXC@c37~R6h@q6LPyXHE{P07Jd5oo3FjG8-lhc`m9jnU_%_CTA?dA;56C*
zk&T?bJ^;w7%F6Pxx=kct#JyOJ{vlvGBut_q-%A`XK&3o@SQ@T1(N=M)`N)$KT9Tf9
z@$Y2(HDSnC*N<vMq(3IQuAM^sc881ajQ9C~(&WvKU~<ca+9&AIHo6t~XrbvTg)*f~
zz<k5xAevARfVv*~qb;ATjcbMQ7PphPdt09S0(ikHZp89h?&Z&zh+*Qjhu;$Ae#+Ub
zP2~N61de@RBZdd3T2}IXkBMe%18UbrPan<*LoQDrk3()I9v!_<7;H4`uV%J$y900T
zN07*u|3*Uq<h?+5%k|pndxK|m)3+@4q#%Bqx2fUq{*6>n4}>V@Q<V%>R>`Xm7C=z=
zditcVj~Q?-`gdOC?iTW1(Qy+Oon76sO<FXRV4*<sQ90K@C{7?Z!6Mw;F065Sz(`JB
z#q!y<Ms{ZT(d#lcxZ=<_qUm(@C5LSOht=T+?IY~0_D6ezSYjqdjwW}Cy*9PsQA~+y
zRtcS?3$=u_eEWjbpF)O=XhWX5WwY1y(uKDBdXf`~=sFb7OHZimGQvwDoj+ap!QeU0
zJD=+_iHL)uxC)xy=9}S-9Gm3#!Z;*o=o^PblBU6}5umhrrq}g4N}`(Vt>*Uin)0(M
z>Kf`#y6CT8G}Qh$I+i{fdTVb#%9F7}kxBc_`(d6!W%yO`IMtJDag6r{gjf{qQYMLq
z>$mqBrN*?>)aG5jea*+lu3(~^G3)O&Jy)&2W-{$Reo!Qb8_*8wY2zowkB#$zRWZBj
z(!bK$2caVL50-0I<_ZfB0Nu}T?F!TRl9W7T|IpsznMZM6Y;vTn9%qwNji^ZQ&7pfY
zAx4P1AN$kr+wcE=pF1^)df$w!B3D;W#^DPtx8{cf_I{O30DmhbCWb>Ep#D%&(b7LF
z$jxf=4zL?{$fsw$dLr#3HX**UY+8`p=6yL(qunYkC|dv3Q{7N>s)A`^2vQ71@7YKp
zD%XYeEVV`zrVw%1{tAjOgcO-poSe8&ITF5prCfd>|D%)?^t0oAfUPeY#MiGGlcH;v
zUgRL5FYs5;5QJ)+hkNdWA{(Dsc6L|8w{J6ge?lQkw<}^KX*xQYyavv4RSRx(A_UA-
zR1yhzU7bw=F9ZUPcXmrX18ls#Z<g^FeEyR+IQV<N_gLb|7+@=_l<Q*~9vNE9GU3D-
zZ4;DwDJWT%j*DKvh-;OQkVrp&C^_$J9SouRU?n4uQsvrq^6`CNZ(O6yQ6(qmg;H(a
z#O!*l;>D|`J3F-KKg>hLK{4f@sYMz!x2);v;P3nXZ2E$%h7`g-u<)~sioT#jP^kM`
zqbn&h$M&Bg2UmZa?Sq7~Gi54;QqTT|n$9&^-XCXEQyUxKn{vK6%gHq@|H)Wt?YZ*%
z_H8Fq-$_m`v&`OZH`BLSOp0|*L!5>Qq6AFqDn1TF9yE>mX79wu17zi!U3s|c(w&<|
zg&O;qi=}etKPV1Fy3!vVFT*<<J1dke9*<B?HTut}^GysrM_Ip_cKM?I<{0qN{ktAS
zEZx+fok0OuVN+oW&~c^@E~n~o*2ax--hNPdeIUc&2oPa*$l+_+0ow;YH9#^}AcO{r
z_u7mJKHfP7u1ZUnZ(&+bYwuulF@mHak^U2G-2p7C62iIz-m!2W_TBkyd)jU<k9n2~
z3QCH8Yx#jmPep5D+}if{`a7!pB~Oicm2RaLgm~)zeLen{w>3^a(Dj<*6>_JmNz+Vk
zVeFc@t=Ur5Onc6z<=+QQuR2cxc#0ncZE~KSa%GGhT((@^^s|mjP`q)xG;R_tX=0n+
zOiKes3g_JNNYk^APoBs^j!s-G5P1a_#vB==n>v}m<4{@Ca%Ni?=XVLN45Qzk)jk<m
z9N)2PGB)XaKkB<0Q=!USym=SY-nC%b6}ZNeK@JDnqVLI*AnjLzxb{2bl}*b>_pl~o
z5xIf10~+>sEU~>#P5L$Sk+!Am)L*zwz+8WF1aUReIY4`cU@GgdQ;{SBPPyXdW6Uru
z8WKX*qp1&M3R4gCAuU%Qf1aM4KvFzNHK3Yt+A0&M$X|ztr;m3bcXi!2|0di*Jf5J5
zzI3^Vmd-C<JtX4rfzhcH7XPh!IN?9^l+@z%@y9dSP$~eaJgP)j5d3bSzw_n&*!7R=
z?(57)C;Onghju@>Eo0I2^0g?XvC4}WKH;6D7d{w9=a{UAJ^|WWdBjIhBi^GcI$G>8
zMae~$t$Q6i^FeP%K_SPWR0VVr7&Hj}W6X#Mv*8GYp-US|v(p|%k(laul>WpzRe~V(
zId&Qio<PQ%JD(RwBU6@;1d<^GZ^qpxN0-aq%j4d<8n~s0`%(EqVeFTElb;Mo%5ULa
zdTEOq6BR=h5Bci8*(X=|B?3Ez^m`dAqW1YFL%WMV_tA++T;6#)`30G9L`9c)y9mfI
zsB4jW4m`WOUEchEy1LG|rk-XUiu4XjFG1<O_aY)C6eXx2AT@xLfPjE>5X69?_mY4@
zK*S)@iv*;EYUsVGGywtW5DeV>?|a{SfA9TvzMP$%GrMzUpJ!&4Qo`!funhXl-fL%{
zjPovl>F(R+RpBuUwm{Fj`cAOE@MYVu@Tl{xq)&U1<;G#?saBOw(oc~4HfY&DQu8Mf
zd&iaR#32lSjGaummH0h1l^`}Xcq3uOxe}%^&%e|@X`>TzwnB`?9F_^mib^RdCqWG)
z0*QiSHeOG}a|{i7i?l)@-AK{Ifvhc+_DiIZq0@s;d+j0TnlyK?v*Sg4_U$1TL>DVE
z=4;=!FuMSO6MKD){xcq7YdZSOi9lG|#bH|;iP;J{!BGJ(s@rSZJT$80l=I~T0Uo?}
z(=4DvGn^~0k7Gqr_@$*k;f7>bHu0C*X%vDAR&If%aDYYp5B!CSiNv(qIy=A4*;^ZK
z8=JQHXbU#Nmy?+W-ocvuUPFVOw6qBj_idf@G_c?I)J(9%U4Y&n{3UW)eaSA0|5ePs
zg+A7-h*^$~bl7VV|JP(%3i>6gv9(Q1QX)~XMAZ*>8Wg;Qi3}vHLm|K4TSV=9Cn>lM
zF&FL|5Wa8TV`R_ygu}^*qPSlN>S}uOU|yU+{LZ(24or&DIcVB?88v^t4Dt&Jbo1HY
zDA&mvyq;kX7Hd8kCnN4J|B$HQ0tFwM`~t~+Z1>StPwlpf@0I7z#`yy7<JgEp!ckV<
zIm#6~<J5L}a!iYzxoG^9^N473X`RSFvFY;Z%*=9F2d$`}l@o+-`_&;~5z)2?y>kMu
z?ZU@oGP64eyBE;D%?dqP9X+-!y61qLowK{D-d|c}r`P=CXU(2H0@4Y2aW$7TjA^;x
z9;<6?ttHO(@9bQCK~Y5DsfJ+N{^icpYkC)-hagU=dlEt=Fh5Ltqk@ta;ka>`mzPib
z?+<(TV1Qt~SJO@Bl|QmHT^bI{*E>Tm@U8?$UytLteTyzHrDi6~o)#u*?;p!YUGOsV
zs&KWo+S0xmqzr4_-dkcCy&yJBuCgayel}c$Ui|y}P3tnjCn`8BY@1As^^r(croo{6
zlud0;Jy<^7&1Q@80tMdO^^N52f4VbDkfq}3l|yF75G7o7O>(QWV=j0}c=(lq8g!_f
zq$JVOv|l-VB4$)oXIdjR3J~AS(DkmiNnLniylB@P8sX*>Q@6Cdyf}-muKsdxxwB1J
zgkop9S0{)*Gi8_9IrngUa$BYR)6j1p=&p}1*A0j$33FNpTb|;icGiRZI%?9T#U-Nq
z)R0%6dOsZ%iDz{&^^z)qQAbWZ)eL$5&+f~c4KX7YM5tG3DQN5|6%a8E)CBJ2WNo(j
zN7`qs6XATkC{CzBMMcs{3T>w}(Ny2e0Qls9X$rZ({Sz(f%*_9-uFBMp_v@#5x_2b|
z6HYuwP4nqk+qXr!1|jQ0FQ21{Mj`%2Cb^3i3A@3d{-S9<e%`6H&+NlfKH(=li_3p~
z4!ek}wZl$IjMD=>l>7+H4A=+{b`SIS#Lw$oykXqlv)8oM5Yq@Ts1voSwAnU@Xlyn0
z`g`ghSo)xX`8LN{j$5|d4Idu9DMp5%4A4-KmURM*_HyyGJ>vYJ=OWnG>{tgTRqDPp
zraWQO0DYXj7lK_bejwh8N(X-k3^yfDcCpRg2|=ExZMT3bWa*ek1D~J+naCH5i20tR
z%cnfkuJF8Hx1EUnDfccw#=zg8`k!IQsX0HM;X~DphMhBvA@!VNJX+>XJ@;>`h)cQl
z2Z##pRW^5^Np9cD(@f;a$~*OpD(HG+pO9J<vi#|M$6;Q&r_dAoVFi)A2;4{Y)J?jD
z+N+T$7<*yA3N5?YaCuoUAj~|Jf9x=5?7RhGY<@oN^IeMKyn%bYx?)|1Snb;swITU1
zG;%%TDlhVh3Z=9Fb%lz6T5D2qmh?mMqKM1M48v2i5EV;#=|n+*ZoHm#S@BEo01rN9
z&kJq3rd47ENDBcQFf#-14Azv$-V#8uxeNt@$XCOpuxB~#_~TZUcJHVerfk=(8|uj}
z<Q%<X#+-RM^9^_OF?+yw3F~_CRVysIOlP{?9PHVsQuw=P2V-kJYm*nJk-pDuu(__Y
z*dj|~kKd_Sv(Y%dW+5x%>*U%S?<{A&N%d%d9tmO$SOjyt(uYtp$G`oosc-QV#O5#k
zPL^C?Mf}Dqpn#~@t7`AwQJZTR-$WY!uiu24^5hgu^da*M?3#3>s7&ZQ{7{r8V%XN&
zhLel)N!U@xnJ)F<m<{)Fe+?9!31$I&BNrFz5+$Zo24l`oMpI60h-F%V9D6!~^9}81
z_}#<ud&yk%gAH&iDS&l0N=fWGC)b$GZ1N!IVFW*Omu#-BwY{A^f#7g;ZzYpE#l&Oz
z)RctSw#b!uk~QJ%Hxd-|fT|@k3DVsWyEz}Ex?#a~4XM)Dq$#gXbZ8M7vRyTj=)giS
z)olsr;~VUPf3yaJoO!vMcV+<JFZf6W<OQL#|GZ5qxRqKomG8H!YX1EKE{6+YGjJnP
z45^=G>EL(484Ynll7n9L-t)=tp8BnQn8N3<4@(XzC#b`movC6w9;A~C^d`l2n~u1+
zA5a@n4O&Og?`tH}lHdNty|>ULf6JxtjVKLs8ZC2tOoBdrECArMgb8?7-MGJ-<T_hc
z%q5twO^#s%BySry&FrTI*{LLUio(_XiP*`}*BVJ(#b72oD#fCNCRaHkO5o+==dm@m
zMzru=3rdv6%o`|3<8)V^9Dr7oR}538`r8x_+{lJ{q0J_C(K49ueQ$KggseRg4*<sP
zsM>4`{Na?J_Zu3an=Oa}2|;^*z%MZFw#v-LLeTlC{7g9DKGmD(%*?V#0RTBB_+rqZ
zKEL-9Qim9NBB$lU6Xb9l85ZO)(7^5#a~hB}8<qJ0{I~&KFKE`Va)zYT?aKvv3<gOK
zK9Z;DiuS9jSN43hpY`2TU!Kj5*uwMdt?S*}R8$}_R%tKT@*mL*2637aQ9835Lg+ds
zJ?lr`FS1?pfVSCYSbjvugEIx!c}|z)ZE+MGyZYdK(z;Sah%nukoO_o~7Yx<d3u$ku
zYR{!y*E1_dv1Ql$A6B`x+S+nEaTJbHhdqr&wC6%p%Rh{r!tQowAk(JexlB2t--hAT
z?zs7H7CzvbY+3Oco#k6B(%`2nfxtPZ1I-|?N!jj(H#+r26J@g7k0D`^_Nfec_~Y|i
zUo~+inL=kL64UDyC}r#WOeYyK<dl<g+OKf%elhj2o~h^c;sIv&zD=qfCt?l)R?`jw
z(r>Kx-AwoJ-n8n(-3&Mt`gmG!x6I)cy``7l>L&F`?Hk~!_>oB<VN2v012*t7nLemr
zo+IMqh`kSzz#jM{OZSTWR?}LOPh|+txD5{z3?Z5mq(~W*9B4Vs4KVWh-3>}pPQL-@
zmb*DaUG>Hn&*_5lZ=UoH955|NKgC|8DE91ZsU`rt+L@TCjU?z1#Vq7wTxoeQUTo8}
zCzj#CPSG8aKjiNV#5mJ(fZO6z$NPi8DR64u?~^#m<b^k6sA2*qi6V3N^36MAb8KIB
zhYZ{qhQp`yg^SAwd2)bfCZBg>VEky<IeceWJ-IF)quE;LA4tSiHs?yLe{BtLK;};n
z4g@?AP6}>NUdcar#?n5q69cj-pt}Pe*iY!6cZjSdh7Uw1p#HF8B@pttGl2*nJ+6Q8
z<EP}&L|!A#y*JR<lIg6B3{fhugT42D8v>sYk`B5xoU*hmtXBKdMgan~q-aQpQ&-ph
zOV8{fPn~FF*=&<VygeP*AVx9QGqTd(t*Sb*pj2n}lV65L*WI~3nL6QlZ{>LjDy6@|
z>;!OMJSzz^VO%@W5B0)UWob`xX7pg$CV$<pnHAP`SD&)?K~FAp9-sylbe1l3))69M
zdCyI|%57dVv@x*=xEP!&PZi@10(}E&uW1xCb}^;Cee|S~XD??Qp;$MuTYdR=&^LVe
zB4kHyqf>KgDSE`othB<#+<QDB9=Cp%NJX3MEJA;8xLKI<$RwD;4*KOSTHogKd)96<
zr|No5UWV{^8kPTAz1it=dVVCmd$!3Mu9&D`S^y)`8m|ovmab|VE`HFnHyFdi-!VP<
zaMK56kY6W^UOhWnSQsOsVlUj?D>oA2sLSuFkOX4x8r`6o*B>Da`<Nf?J6yc~1P8QC
zlOfoV;eg*32_<G25BH6p&D7Yxj)0>;R?TQZ#cIb)!-^)R3)9esu_FV8Zwa~i^RiEJ
z`ox~D7h>7o>Wo{^OLumR?fIWdEb7(tC*wzL4x0wc7D9D(8p=!)d98QiB2A;7-OeH1
zc$<gmYm&JnWAA--&`v_xQpM$+vbtyQU>Vc=B!~5^I<30Z<#N0M;+BZ`*m}z>5jf1}
zKale*-xhmEws}s0taH3AP3&~muVF-bZRRPFFQztso-)pkcYh)-kUicjBBPdE+tv)s
z(j4`iQ`WOw+dF&j^wIq}NL78DME?PpAqD>M!zB6}J^Hy}^MI0$);8lE+nv2CUW9*e
zVO`KBH}Q6OU%l_4hC9RSaj7=JBCj~WzebK?6t|NJ8rv!phYWacX*tjyb^6qr=VYJ>
zF*1!XqAItFQ)J#w2ASkB8JWGw+WkqQn{Qyyo0)EyWUx^q;G!eEe}ZIOWmc0%)gU!v
zz;|A!gI|j9uu{FR6Su0g%qg?&O>#gI-e*DJy)-~p*t3NhVk|>5cnz-P-yXP{U0MIu
z0`P}$14$$MYU0WBb=#q1NJ>?g+OtbZ<iyn{ib0`_Njm!>4Sz0C*&jvcmExz@h8FWm
zH}0)<ehoLf#k)GAWJMMRbHb#ZNbcs8<4<PcH}kHq4%dQn^Iu-e;NEE*33vM>yBvn6
z;U3g+$=lAI)dzuChQ!%M_Z|(D3JnpELqc7V@@uPhzmU{!vdhE3=44H`dc9cO%<Qoi
z;|4ZBGnTB4obo3%LZ(Gt@MJyFIFqbx#_`6AR{yIPCynRl{k>4&9f;(&#-GmP7=+ey
z0iegD^{pf4p3jl#Dc(%`XH9<AI;wJG5q3gw81XbVz;@nuXif?lI{nfWiU68WX@ji4
zLP*d07&2bVXW&4lMzYx=wLZh`vZg#P;IZ#Wo}2ALS9B#<>DK4I_<pszkH3HQ5ziTq
z4mrX;1U%;6fyi+V^0^_!H6GisGq*jGpdy=cUD<KTQb4u-4Nt+ptsG(%+3dHcyTPm^
zHt#1aT+ZZ2IL=>IcP_jcUGXRe4%Fp%VE}wSB$byC>aD~*`D5QR5Ef0kY^WKcwZ5z3
zmPc9Jv=+kgr@5|%#5;CllkM2-F#%AUE^*R&eP3{uZ)k3n?6s`xNkFuycHdmsq7=ik
zcZHVB1DO#(eoEu~mcO-W0TK7={T~&7wJ#a;<!-h<l91Q{?q$ApIvAqUTp~HBSoc<Z
za_}o;n}j-cC$h$2-!)okXPUu)aF5+>U(l#&L@lKNUr~Xb2&=m_FTCE`r7n`wrQMrV
zCm~1aDm-e7_xYCjL$)`JqR9#sm*cYAZ@OvvDa_49)M)dE;Wg?5IVQ-919RdXbB6)t
zY_!027lDmt;jYV88ns-50k4be=Kk`9JO>n{NKB^jPgw#>6i$kf8ZPmJzK?^{?YUAd
z<K}HnV^fMl^qiVdRc0Fi04vR`-bv^e>-AGvZr7Zdb+qHi33ThkaK<L<J)Je5U&$sW
zHF2CR`9WWN0apN>naImZ^&_FxjZ&W(55IS$^CAvs?>&6{O!wRF%UgCl4}ylmRoxA;
zX-8klJ`~*yfq-i;aT^7d$e%`_rMsrMW*v_4ZrTWcM+7C_>gnez{&inAR#Riu5xS!=
zYliA;xZ38iFb00^whKXj&0t2#41lQD64)EP;lW0!9`U&-L8~(UxV}m2+|(gBoKU5Q
zqpha}mXcg1lC^!18Kk~tG^RywruL0AcZHzE=?HREgY2YX8Uk>y12Fs<2$77S&~}><
zfE5{;KsnWDj%QkhywjHX(0F%8Y}<RSWCA}X&&oqg`zBe@sG2W5h3)Q;R1hCZ1fj`P
zH)h_C$Sw3YSwnnlwB7!s&cG{tjU)f6m*%Zy4Rl(SvXTF1Ow@uW??ca<lXKP3d9Z<a
zI)I;j%=m~+D@9rLPdZDXlZG0f&c&h#vAKg|d$WLf(AJBN30wMsh^TCTu%6GU`R|R5
zh;tGo*Bn4i{Gc{$Xv?1Owdn70L)EngZb}vv%iTJBy{PlceUZaZI!hr(Q<SLD3%-jy
z@;;{y&W>p|7V?2x0ix@eEv)^d{xDw7xv1^cN1^!DE{?Ds8^<dJ3bk-9xx7^WWUhew
zY^$mLvXoM5oEGatt7!$})WYSxhAk{GwHbfDoP)x6r6Db{To>~L2Pwq6jmR82OKJ+r
zP<LF=;lkv4IqI*ph`X4krG{1yqen5YJb>DCz2#Z5hKA9T5zNtQ;q<-oPQyd%FNg2>
z+21AUUa5HHhU4Aisn$jIOnp*ob)`$W02xN=<-X6_moCK)Z>ZePr;3@3j~5XZmKvP9
z{1bY(81Vbx7y?(oa>`>l1ma_QdCMUh(gI)+Av)3(%|8W(NfGnXlko-vSu`tl8B?J8
zH&&$1Ea=h47m{nN{TEU>5$Qe>1x`gC6alBQ^Ya-sw%w5q3)5!)QCfQ|=R?M*dm~AO
z3dU;5Tlb!<rb#;s5O5)vuPfM125QS*V1g)-x~BHq0k{y{ZTjk_C=mvFG8V7{n$F;b
zF+4GS92gExZ0S&0DZettA<hznU*ki5v!Ze3O9JOPZq>%Sr$+eJ$7?YTSy!(&dqK!|
zWg((Fdv8u~3NB>Bz}4@S5zs=CYys3&W`62Ak=N;cn_B*wY;T}YreAG1FTnrDf@FDN
zP|ehndS{p_I|>v+Bom)P9+))mpPb{cUXYK6V144ZS;a!x0G%COp3piwUJ`Ot=A-mE
zgswiCO<q}9O+!v=qvg8b!Iv_4rz~Bk=orXS#-pk{WMtLCj9>fYZ!TR1{1_rnQI?gl
zr+wSaf<yAnFOhMVP~oH3m$hn6kIq{$U^OSb^}1V2F>MXqv$%3PDUTJ@gyP<;Q{Puk
zpi`fgmB!|$+{yXU#@j{ZlBkAj)D>0WGK7D4ks>g+gwdFA544o!{%DwmqpSgWt{WN!
zmQO%w=G7IXb9(&*BAU?$_s!MGy5a~~&DYW|Gt<*j(x<6v?DqUwAT-0q!>k48Hl{*-
z&#RC+8qOfR*>90b`xeo{qDmJGyg0Rf8`$e&Y^NT8%lJi8gM%SU=l8Ne1KBZ=(wAej
zm1VW3NQrdZ-NVwRA-ivdM@5&Nw-SU7*`l>WtXP_bzfnUL#qRHh#4ZTZtZ82g<h>G>
z;z5nw6Hd_UB*~Y4SQgMzxMgR~RrWC=X9KH~a!?e|HkSqF*l2*xC$F@)Hm-`J7)~35
zl_U4_4a>IdDg6>HgiRAn0P5-stW04sf`WOS2tNt^K2^Yu4@OOMhKsjdQ&IkLMUo@R
z?So>OgcO@0*-P*T<p+61ZA3DW0g!(bk`7~Gx&whjp*vq98h7je!n-Z6qW2lE)+=>m
zNUzbbiQX6Bex+zx+_B8=EaPkmynbhSe%?lB=Hgj+QwqQiW_kCLLq2}zN>+MUlxcLr
z7!udfB*s5GN%{;3Ve>(^&n-U=UI0~qD<2qom&Zxod|Q3)#b)4Aa=rHkdMZuq?Tac>
zGsh1L@4tOxJSMbR#!B8V{vW}zR5Yk6-Iy!N+vK`71ASh6N-0}0%XD9ai;bDXTYjqN
zJB#%(<;u}uDL%~o(XUrdgn`7+Sz{ot$ygHs77tckj-2m9t32fTkjL-r#59u4@L%$|
zdlm(j4{eaXTQQM;H(rYWqu;;f{SmolDf5!ZADEMCRqFcV)K;)wY-xU2>LaHJLr0BZ
zQJ0Ub#^uJxp5&bDBb71sx}?r@CTr>2s(@#57z7MdA)2n=t*Wz_p$GgwCGHn@6y5mA
zr0bHpz3;B;1{zhs5_7AduXL%RNt1R`<p6@RAYj@%bJ-t;zq)iXn7-B!OMf{%&DiDc
zkJwN~3S^C1(L$^LZHoV%DvOd5Ib>*t;_+{#f$AOkL@LqZK}4p)1XRgH>=&AKoz!!T
zE^oU<?~lUV_l^)qUZ%z1VO`nLpPql2^MBMm%Xlqz+xKHEj~SQ~LN|Kr`ZYkzXYD>F
z5?uwX#;i=10XlG3@a3XF{Lp79BBy?z6*0PmSK$yO!ZiXgS|F)jnpxR@Ov@Z-j_v1g
zDfBC0duKsz=5~KYJ`q6GSqhT_#_1Q=ufuOflYWn;dT)H{F0MafLo01J?F7rz_$3=~
z--+$~Hpe{0|5p?TNRppP=2^um_od45ZNG$389lW#&~N~FI>KY7xYGP6=2i<v-!msD
zjvAJAcGuLA!$iq93cUn>sf1P=T6mBHgj_k|Kot%0w*R*Azl_~7!oaG?9BUv3hsFvA
zjbs)AN|;Fj)GmChaIZ1b3<^i8J_|2$M}02lv|I}+jp#U0U2=i3<dp}N*G;HYgXO3a
zk8gWZINcI*`C`5HA7AxXNABrQnqvePi{HV0Z0c=WLw&a`Ca!O3fcpTZv?(s73RV<j
zotT@GY2eJ_Bc9fr)SmcgKW%k&O>J$1(jSHW4yGnlF&q5+yke+p8xbgVssCM`|2$kd
z#Oz!lnj-R}dggfU+cEGN$Lc}!VR2Mk#$MNSRW;?m=E7)a3&i97q`GEUjPw_m$-0$W
zYh@W#8y;3=LI*uJ(!a)#T~Yx^65h{xo?{$tvHz!l@n2&TKjY+iOPp+DI;}0caSDLa
cdVIS~(!s8A^D(im6#y{4Yp!3V=lJr!03wl82><{9

literal 0
HcmV?d00001

diff --git a/public/rustfava/docs/search/search_index.json b/public/rustfava/docs/search/search_index.json
index e8f197e..d7c11ab 100644
--- a/public/rustfava/docs/search/search_index.json
+++ b/public/rustfava/docs/search/search_index.json
@@ -1 +1 @@
-{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"],"fields":{"title":{"boost":1000.0},"text":{"boost":1.0},"tags":{"boost":1000000.0}}},"docs":[{"location":"","title":"Welcome to rustfava!","text":"<p>Rustfava is a web interface for double-entry bookkeeping, powered by rustledger, a Rust-based parser for the Beancount file format compiled to WebAssembly for fast in-browser processing.</p> <p>Rustfava is a fork of Fava that replaces the Python Beancount parser with rustledger for improved performance. Your existing Beancount files are fully compatible.</p> <p></p> <p>If you are new to rustfava or Beancount-format files, begin with the Getting Started guide.</p> <p>This is enough to get you up and running:</p> <pre><code>uv pip install rustfava\nrustfava ledger.beancount\n</code></pre> <p>and visit the web interface at http://localhost:5000.</p>"},{"location":"api/","title":"API Reference","text":"<p>Note</p> <p>There's no stability guarantee as this is just for internal purposes currently.</p>"},{"location":"api/#core-modules","title":"Core Modules","text":""},{"location":"api/#rustfava.core","title":"<code>rustfava.core</code>","text":"<p>This module provides the data required by Fava's reports.</p>"},{"location":"api/#rustfava.core.EntryNotFoundForHashError","title":"<code>EntryNotFoundForHashError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Entry not found for hash.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class EntryNotFoundForHashError(RustfavaAPIError):\n    \"\"\"Entry not found for hash.\"\"\"\n\n    def __init__(self, entry_hash: str) -&gt; None:\n        super().__init__(f'No entry found for hash \"{entry_hash}\"')\n</code></pre>"},{"location":"api/#rustfava.core.StatementNotFoundError","title":"<code>StatementNotFoundError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Statement not found.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class StatementNotFoundError(RustfavaAPIError):\n    \"\"\"Statement not found.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"Statement not found.\")\n</code></pre>"},{"location":"api/#rustfava.core.StatementMetadataInvalidError","title":"<code>StatementMetadataInvalidError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Statement metadata not found or invalid.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class StatementMetadataInvalidError(RustfavaAPIError):\n    \"\"\"Statement metadata not found or invalid.\"\"\"\n\n    def __init__(self, key: str) -&gt; None:\n        super().__init__(\n            f\"Statement path at key '{key}' missing or not a string.\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.JournalPage","title":"<code>JournalPage</code>  <code>dataclass</code>","text":"<p>A page of journal entries.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>@dataclass(frozen=True)\nclass JournalPage:\n    \"\"\"A page of journal entries.\"\"\"\n\n    entries: Sequence[tuple[int, Directive]]\n    total_pages: int\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger","title":"<code>FilteredLedger</code>","text":"<p>Filtered Beancount ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class FilteredLedger:\n    \"\"\"Filtered Beancount ledger.\"\"\"\n\n    __slots__ = (\n        \"__dict__\",  # for the cached_property decorator\n        \"_date_first\",\n        \"_date_last\",\n        \"_pages\",\n        \"date_range\",\n        \"entries\",\n        \"ledger\",\n    )\n    _date_first: date | None\n    _date_last: date | None\n\n    def __init__(\n        self,\n        ledger: RustfavaLedger,\n        *,\n        account: str | None = None,\n        filter: str | None = None,  # noqa: A002\n        time: str | None = None,\n    ) -&gt; None:\n        \"\"\"Create a filtered view of a ledger.\n\n        Args:\n            ledger: The ledger to filter.\n            account: The account filter.\n            filter: The advanced filter.\n            time: The time filter.\n        \"\"\"\n        self.ledger = ledger\n        self.date_range: DateRange | None = None\n        self._pages: (\n            tuple[\n                int,\n                Literal[\"asc\", \"desc\"],\n                list[Sequence[tuple[int, Directive]]],\n            ]\n            | None\n        ) = None\n\n        entries = ledger.all_entries\n        if account:\n            entries = AccountFilter(account).apply(entries)\n        if filter and filter.strip():\n            entries = AdvancedFilter(filter.strip()).apply(entries)\n        if time:\n            time_filter = TimeFilter(ledger.options, ledger.fava_options, time)\n            entries = time_filter.apply(entries)\n            self.date_range = time_filter.date_range\n        self.entries = entries\n\n        if self.date_range:\n            self._date_first = self.date_range.begin\n            self._date_last = self.date_range.end\n            return\n\n        self._date_first = None\n        self._date_last = None\n        for entry in self.entries:\n            if isinstance(entry, Transaction):\n                self._date_first = entry.date\n                break\n        for entry in reversed(self.entries):\n            if isinstance(entry, (Transaction, Price)):\n                self._date_last = entry.date + timedelta(1)\n                break\n\n    @property\n    def end_date(self) -&gt; date | None:\n        \"\"\"The date to use for prices.\"\"\"\n        date_range = self.date_range\n        if date_range:\n            return date_range.end_inclusive\n        return None\n\n    @cached_property\n    def entries_with_all_prices(self) -&gt; Sequence[Directive]:\n        \"\"\"The filtered entries, with all prices added back in for queries.\"\"\"\n        entries = [*self.entries, *self.ledger.all_entries_by_type.Price]\n        entries.sort(key=_incomplete_sortkey)\n        return entries\n\n    @cached_property\n    def entries_without_prices(self) -&gt; Sequence[Directive]:\n        \"\"\"The filtered entries, without prices for journals.\"\"\"\n        return [e for e in self.entries if not isinstance(e, Price)]\n\n    @cached_property\n    def root_tree(self) -&gt; Tree:\n        \"\"\"A root tree.\"\"\"\n        return Tree(self.entries)\n\n    @cached_property\n    def root_tree_closed(self) -&gt; Tree:\n        \"\"\"A root tree for the balance sheet.\"\"\"\n        tree = Tree(self.entries)\n        tree.cap(self.ledger.options, self.ledger.fava_options.unrealized)\n        return tree\n\n    def interval_ranges(self, interval: Interval) -&gt; Sequence[DateRange]:\n        \"\"\"Yield date ranges corresponding to interval boundaries.\n\n        Args:\n            interval: The interval to yield ranges for.\n        \"\"\"\n        if not self._date_first or not self._date_last:\n            return []\n        complete = not self.date_range\n        return dateranges(\n            self._date_first, self._date_last, interval, complete=complete\n        )\n\n    def prices(self, base: str, quote: str) -&gt; Sequence[tuple[date, Decimal]]:\n        \"\"\"List all prices for a pair of commodities.\n\n        Args:\n            base: The price base.\n            quote: The price quote.\n        \"\"\"\n        all_prices = self.ledger.prices.get_all_prices((base, quote))\n        if all_prices is None:\n            return []\n\n        date_range = self.date_range\n        if date_range:\n            return [\n                price_point\n                for price_point in all_prices\n                if date_range.begin &lt;= price_point[0] &lt; date_range.end\n            ]\n        return all_prices\n\n    def account_is_closed(self, account_name: str) -&gt; bool:\n        \"\"\"Check if the account is closed.\n\n        Args:\n            account_name: An account name.\n\n        Returns:\n            True if the account is closed before the end date of the current\n            time filter.\n        \"\"\"\n        date_range = self.date_range\n        close_date = self.ledger.accounts[account_name].close_date\n        if close_date is None:\n            return False\n        return close_date &lt; date_range.end if date_range else True\n\n    def paginate_journal(\n        self,\n        page: int,\n        per_page: int = 1000,\n        order: Literal[\"asc\", \"desc\"] = \"desc\",\n    ) -&gt; JournalPage | None:\n        \"\"\"Get entries for a journal page with pagination info.\n\n        Args:\n            page: Page number (1-indexed).\n            order: Datewise order to sort in\n            per_page: Number of entries per page.\n\n        Returns:\n            A JournalPage, containing a list of entries as (global_index,\n            directive) tuples in reverse chronological order and the total\n            number of pages.\n        \"\"\"\n        if (\n            self._pages is None\n            or self._pages[0] != per_page\n            or self._pages[1] != order\n        ):\n            pages: list[Sequence[tuple[int, Directive]]] = []\n            enumerated = list(enumerate(self.entries_without_prices))\n            entries = (\n                iter(enumerated) if order == \"asc\" else reversed(enumerated)\n            )\n            while batch := tuple(islice(entries, per_page)):\n                pages.append(batch)\n            if not pages:\n                pages.append([])\n            self._pages = (per_page, order, pages)\n        _per_pages, _order, pages = self._pages\n        total = len(pages)\n        if page &gt; total:\n            return None\n        return JournalPage(pages[page - 1], total)\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.end_date","title":"<code>end_date</code>  <code>property</code>","text":"<p>The date to use for prices.</p>"},{"location":"api/#rustfava.core.FilteredLedger.entries_with_all_prices","title":"<code>entries_with_all_prices</code>  <code>cached</code> <code>property</code>","text":"<p>The filtered entries, with all prices added back in for queries.</p>"},{"location":"api/#rustfava.core.FilteredLedger.entries_without_prices","title":"<code>entries_without_prices</code>  <code>cached</code> <code>property</code>","text":"<p>The filtered entries, without prices for journals.</p>"},{"location":"api/#rustfava.core.FilteredLedger.root_tree","title":"<code>root_tree</code>  <code>cached</code> <code>property</code>","text":"<p>A root tree.</p>"},{"location":"api/#rustfava.core.FilteredLedger.root_tree_closed","title":"<code>root_tree_closed</code>  <code>cached</code> <code>property</code>","text":"<p>A root tree for the balance sheet.</p>"},{"location":"api/#rustfava.core.FilteredLedger.__init__","title":"<code>__init__(ledger, *, account=None, filter=None, time=None)</code>","text":"<p>Create a filtered view of a ledger.</p> <p>Parameters:</p> Name Type Description Default <code>ledger</code> <code>RustfavaLedger</code> <p>The ledger to filter.</p> required <code>account</code> <code>str | None</code> <p>The account filter.</p> <code>None</code> <code>filter</code> <code>str | None</code> <p>The advanced filter.</p> <code>None</code> <code>time</code> <code>str | None</code> <p>The time filter.</p> <code>None</code> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def __init__(\n    self,\n    ledger: RustfavaLedger,\n    *,\n    account: str | None = None,\n    filter: str | None = None,  # noqa: A002\n    time: str | None = None,\n) -&gt; None:\n    \"\"\"Create a filtered view of a ledger.\n\n    Args:\n        ledger: The ledger to filter.\n        account: The account filter.\n        filter: The advanced filter.\n        time: The time filter.\n    \"\"\"\n    self.ledger = ledger\n    self.date_range: DateRange | None = None\n    self._pages: (\n        tuple[\n            int,\n            Literal[\"asc\", \"desc\"],\n            list[Sequence[tuple[int, Directive]]],\n        ]\n        | None\n    ) = None\n\n    entries = ledger.all_entries\n    if account:\n        entries = AccountFilter(account).apply(entries)\n    if filter and filter.strip():\n        entries = AdvancedFilter(filter.strip()).apply(entries)\n    if time:\n        time_filter = TimeFilter(ledger.options, ledger.fava_options, time)\n        entries = time_filter.apply(entries)\n        self.date_range = time_filter.date_range\n    self.entries = entries\n\n    if self.date_range:\n        self._date_first = self.date_range.begin\n        self._date_last = self.date_range.end\n        return\n\n    self._date_first = None\n    self._date_last = None\n    for entry in self.entries:\n        if isinstance(entry, Transaction):\n            self._date_first = entry.date\n            break\n    for entry in reversed(self.entries):\n        if isinstance(entry, (Transaction, Price)):\n            self._date_last = entry.date + timedelta(1)\n            break\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.interval_ranges","title":"<code>interval_ranges(interval)</code>","text":"<p>Yield date ranges corresponding to interval boundaries.</p> <p>Parameters:</p> Name Type Description Default <code>interval</code> <code>Interval</code> <p>The interval to yield ranges for.</p> required Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def interval_ranges(self, interval: Interval) -&gt; Sequence[DateRange]:\n    \"\"\"Yield date ranges corresponding to interval boundaries.\n\n    Args:\n        interval: The interval to yield ranges for.\n    \"\"\"\n    if not self._date_first or not self._date_last:\n        return []\n    complete = not self.date_range\n    return dateranges(\n        self._date_first, self._date_last, interval, complete=complete\n    )\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.prices","title":"<code>prices(base, quote)</code>","text":"<p>List all prices for a pair of commodities.</p> <p>Parameters:</p> Name Type Description Default <code>base</code> <code>str</code> <p>The price base.</p> required <code>quote</code> <code>str</code> <p>The price quote.</p> required Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def prices(self, base: str, quote: str) -&gt; Sequence[tuple[date, Decimal]]:\n    \"\"\"List all prices for a pair of commodities.\n\n    Args:\n        base: The price base.\n        quote: The price quote.\n    \"\"\"\n    all_prices = self.ledger.prices.get_all_prices((base, quote))\n    if all_prices is None:\n        return []\n\n    date_range = self.date_range\n    if date_range:\n        return [\n            price_point\n            for price_point in all_prices\n            if date_range.begin &lt;= price_point[0] &lt; date_range.end\n        ]\n    return all_prices\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.account_is_closed","title":"<code>account_is_closed(account_name)</code>","text":"<p>Check if the account is closed.</p> <p>Parameters:</p> Name Type Description Default <code>account_name</code> <code>str</code> <p>An account name.</p> required <p>Returns:</p> Type Description <code>bool</code> <p>True if the account is closed before the end date of the current</p> <code>bool</code> <p>time filter.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def account_is_closed(self, account_name: str) -&gt; bool:\n    \"\"\"Check if the account is closed.\n\n    Args:\n        account_name: An account name.\n\n    Returns:\n        True if the account is closed before the end date of the current\n        time filter.\n    \"\"\"\n    date_range = self.date_range\n    close_date = self.ledger.accounts[account_name].close_date\n    if close_date is None:\n        return False\n    return close_date &lt; date_range.end if date_range else True\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.paginate_journal","title":"<code>paginate_journal(page, per_page=1000, order='desc')</code>","text":"<p>Get entries for a journal page with pagination info.</p> <p>Parameters:</p> Name Type Description Default <code>page</code> <code>int</code> <p>Page number (1-indexed).</p> required <code>order</code> <code>Literal['asc', 'desc']</code> <p>Datewise order to sort in</p> <code>'desc'</code> <code>per_page</code> <code>int</code> <p>Number of entries per page.</p> <code>1000</code> <p>Returns:</p> Type Description <code>JournalPage | None</code> <p>A JournalPage, containing a list of entries as (global_index,</p> <code>JournalPage | None</code> <p>directive) tuples in reverse chronological order and the total</p> <code>JournalPage | None</code> <p>number of pages.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def paginate_journal(\n    self,\n    page: int,\n    per_page: int = 1000,\n    order: Literal[\"asc\", \"desc\"] = \"desc\",\n) -&gt; JournalPage | None:\n    \"\"\"Get entries for a journal page with pagination info.\n\n    Args:\n        page: Page number (1-indexed).\n        order: Datewise order to sort in\n        per_page: Number of entries per page.\n\n    Returns:\n        A JournalPage, containing a list of entries as (global_index,\n        directive) tuples in reverse chronological order and the total\n        number of pages.\n    \"\"\"\n    if (\n        self._pages is None\n        or self._pages[0] != per_page\n        or self._pages[1] != order\n    ):\n        pages: list[Sequence[tuple[int, Directive]]] = []\n        enumerated = list(enumerate(self.entries_without_prices))\n        entries = (\n            iter(enumerated) if order == \"asc\" else reversed(enumerated)\n        )\n        while batch := tuple(islice(entries, per_page)):\n            pages.append(batch)\n        if not pages:\n            pages.append([])\n        self._pages = (per_page, order, pages)\n    _per_pages, _order, pages = self._pages\n    total = len(pages)\n    if page &gt; total:\n        return None\n    return JournalPage(pages[page - 1], total)\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger","title":"<code>RustfavaLedger</code>","text":"<p>Interface for a Beancount ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class RustfavaLedger:\n    \"\"\"Interface for a Beancount ledger.\"\"\"\n\n    __slots__ = (\n        \"_is_encrypted\",\n        \"accounts\",\n        \"accounts\",\n        \"all_entries\",\n        \"all_entries_by_type\",\n        \"attributes\",\n        \"beancount_file_path\",\n        \"budgets\",\n        \"charts\",\n        \"commodities\",\n        \"extensions\",\n        \"fava_options\",\n        \"fava_options_errors\",\n        \"file\",\n        \"format_decimal\",\n        \"get_entry\",\n        \"get_filtered\",\n        \"ingest\",\n        \"load_errors\",\n        \"misc\",\n        \"options\",\n        \"prices\",\n        \"query_shell\",\n        \"watcher\",\n    )\n\n    #: List of all (unfiltered) entries.\n    all_entries: Sequence[Directive]\n\n    #: A list of all errors reported by Beancount.\n    load_errors: Sequence[BeancountError]\n\n    #: The Beancount options map.\n    options: BeancountOptions\n\n    #: A dict with all of Fava's option values.\n    fava_options: RustfavaOptions\n\n    #: A list of all errors from parsing the custom options.\n    fava_options_errors: Sequence[BeancountError]\n\n    #: The price map.\n    prices: RustfavaPriceMap\n\n    #: Dict of list of all (unfiltered) entries by type.\n    all_entries_by_type: EntriesByType\n\n    #: A :class:`.AccountDict` module - details about the accounts.\n    accounts: AccountDict\n\n    #: An :class:`AttributesModule` instance.\n    attributes: AttributesModule\n\n    #: A :class:`.BudgetModule` instance.\n    budgets: BudgetModule\n\n    #: A :class:`.ChartModule` instance.\n    charts: ChartModule\n\n    #: A :class:`.CommoditiesModule` instance.\n    commodities: CommoditiesModule\n\n    #: A :class:`.ExtensionModule` instance.\n    extensions: ExtensionModule\n\n    #: A :class:`.FileModule` instance.\n    file: FileModule\n\n    #: A :class:`.DecimalFormatModule` instance.\n    format_decimal: DecimalFormatModule\n\n    #: A :class:`.IngestModule` instance.\n    ingest: IngestModule\n\n    #: A :class:`.FavaMisc` instance.\n    misc: FavaMisc\n\n    #: A :class:`.QueryShell` instance.\n    query_shell: QueryShell\n\n    def __init__(self, path: str, *, poll_watcher: bool = False) -&gt; None:\n        \"\"\"Create an interface for a Beancount ledger.\n\n        Arguments:\n            path: Path to the main Beancount file.\n            poll_watcher: Whether to use the polling file watcher.\n        \"\"\"\n        #: The path to the main Beancount file.\n        self.beancount_file_path = path\n        self._is_encrypted = is_encrypted_file(path)\n        self.get_filtered = lru_cache(maxsize=16)(self._get_filtered)\n        self.get_entry = lru_cache(maxsize=16)(self._get_entry)\n\n        self.accounts = AccountDict(self)\n        self.attributes = AttributesModule(self)\n        self.budgets = BudgetModule(self)\n        self.charts = ChartModule(self)\n        self.commodities = CommoditiesModule(self)\n        self.extensions = ExtensionModule(self)\n        self.file = FileModule(self)\n        self.format_decimal = DecimalFormatModule(self)\n        self.ingest = IngestModule(self)\n        self.misc = FavaMisc(self)\n        self.query_shell = QueryShell(self)\n\n        self.watcher = WatchfilesWatcher() if not poll_watcher else Watcher()\n\n        self.load_file()\n\n    def load_file(self) -&gt; None:\n        \"\"\"Load the main file and all included files and set attributes.\"\"\"\n        self.all_entries, self.load_errors, self.options = load_uncached(\n            self.beancount_file_path,\n            is_encrypted=self._is_encrypted,\n        )\n        self.get_filtered.cache_clear()\n        self.get_entry.cache_clear()\n\n        self.all_entries_by_type = group_entries_by_type(self.all_entries)\n        self.prices = RustfavaPriceMap(self.all_entries_by_type.Price)\n\n        self.fava_options, self.fava_options_errors = parse_options(\n            self.all_entries_by_type.Custom,\n        )\n\n        if self._is_encrypted:  # pragma: no cover\n            pass\n        else:\n            self.watcher.update(*self.paths_to_watch())\n\n        # Call load_file of all modules.\n        self.accounts.load_file()\n        self.attributes.load_file()\n        self.budgets.load_file()\n        self.charts.load_file()\n        self.commodities.load_file()\n        self.extensions.load_file()\n        self.file.load_file()\n        self.format_decimal.load_file()\n        self.misc.load_file()\n        self.query_shell.load_file()\n        self.ingest.load_file()\n\n        self.extensions.after_load_file()\n\n    def _get_filtered(\n        self,\n        account: str | None = None,\n        filter: str | None = None,  # noqa: A002\n        time: str | None = None,\n    ) -&gt; FilteredLedger:\n        \"\"\"Filter the ledger.\n\n        Args:\n            account: The account filter.\n            filter: The advanced filter.\n            time: The time filter.\n        \"\"\"\n        return FilteredLedger(\n            ledger=self, account=account, filter=filter, time=time\n        )\n\n    @property\n    def mtime(self) -&gt; int:\n        \"\"\"The timestamp to the latest change of the underlying files.\"\"\"\n        return self.watcher.last_checked\n\n    @property\n    def errors(self) -&gt; Sequence[BeancountError]:\n        \"\"\"The errors that the Beancount loading plus Fava module errors.\"\"\"\n        return [\n            *self.load_errors,\n            *self.fava_options_errors,\n            *self.budgets.errors,\n            *self.extensions.errors,\n            *self.misc.errors,\n            *self.ingest.errors,\n        ]\n\n    @property\n    def root_accounts(self) -&gt; tuple[str, str, str, str, str]:\n        \"\"\"The five root accounts.\"\"\"\n        options = self.options\n        return (\n            options[\"name_assets\"],\n            options[\"name_liabilities\"],\n            options[\"name_equity\"],\n            options[\"name_income\"],\n            options[\"name_expenses\"],\n        )\n\n    def join_path(self, *args: str) -&gt; Path:\n        \"\"\"Path relative to the directory of the ledger.\"\"\"\n        return Path(self.beancount_file_path).parent.joinpath(*args).resolve()\n\n    def paths_to_watch(self) -&gt; tuple[Sequence[Path], Sequence[Path]]:\n        \"\"\"Get paths to included files and document directories.\n\n        Returns:\n            A tuple (files, directories).\n        \"\"\"\n        files = [Path(i) for i in self.options[\"include\"]]\n        if self.ingest.module_path:\n            files.append(self.ingest.module_path)\n        return (\n            files,\n            [\n                self.join_path(path, account)\n                for account in self.root_accounts\n                for path in self.options[\"documents\"]\n            ],\n        )\n\n    def changed(self) -&gt; bool:\n        \"\"\"Check if the file needs to be reloaded.\n\n        Returns:\n            True if a change in one of the included files or a change in a\n            document folder was detected and the file has been reloaded.\n        \"\"\"\n        # We can't reload an encrypted file, so act like it never changes.\n        if self._is_encrypted:  # pragma: no cover\n            return False\n        changed = self.watcher.check()\n        if changed:\n            self.load_file()\n        return changed\n\n    def interval_balances(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        account_name: str,\n        *,\n        accumulate: bool = False,\n    ) -&gt; tuple[Sequence[Tree], Sequence[DateRange]]:\n        \"\"\"Balances by interval.\n\n        Arguments:\n            filtered: The currently filtered ledger.\n            interval: An interval.\n            account_name: An account name.\n            accumulate: A boolean, ``True`` if the balances for an interval\n                should include all entries up to the end of the interval.\n\n        Returns:\n            A pair of a list of Tree instances and the intervals.\n        \"\"\"\n        min_accounts = [\n            account\n            for account in self.accounts\n            if account.startswith(account_name)\n        ]\n\n        interval_ranges = list(reversed(filtered.interval_ranges(interval)))\n        interval_balances = [\n            Tree(\n                slice_entry_dates(\n                    filtered.entries,\n                    date.min if accumulate else date_range.begin,\n                    date_range.end,\n                ),\n                min_accounts,\n            )\n            for date_range in interval_ranges\n        ]\n\n        return interval_balances, interval_ranges\n\n    @listify\n    def account_journal(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: str | Conversion,\n        *,\n        with_children: bool,\n    ) -&gt; Iterable[\n        tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]\n    ]:\n        \"\"\"Journal for an account.\n\n        Args:\n            filtered: The currently filtered ledger.\n            account_name: An account name.\n            conversion: The conversion to use.\n            with_children: Whether to include postings of subaccounts of\n                           the account.\n\n        Yields:\n            Tuples of ``(index, entry, change, balance)``.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        relevant_account = account_tester(\n            account_name, with_children=with_children\n        )\n\n        prices = self.prices\n        balance = CounterInventory()\n        for index, entry in enumerate(filtered.entries_without_prices):\n            change = CounterInventory()\n            entry_is_relevant = False\n            postings = getattr(entry, \"postings\", None)\n            if postings is not None:\n                for posting in postings:\n                    if relevant_account(posting.account):\n                        entry_is_relevant = True\n                        balance.add_position(posting)\n                        change.add_position(posting)\n            elif any(relevant_account(a) for a in get_entry_accounts(entry)):\n                entry_is_relevant = True\n\n            if entry_is_relevant:\n                yield (\n                    index,\n                    entry,\n                    conv.apply(change, prices, entry.date),\n                    conv.apply(balance, prices, entry.date),\n                )\n\n    def _get_entry(self, entry_hash: str) -&gt; Directive:\n        \"\"\"Find an entry.\n\n        Arguments:\n            entry_hash: Hash of the entry.\n\n        Returns:\n            The entry with the given hash.\n\n        Raises:\n            EntryNotFoundForHashError: If there is no entry for the given hash.\n        \"\"\"\n        try:\n            return next(\n                entry\n                for entry in self.all_entries\n                if entry_hash == hash_entry(entry)\n            )\n        except StopIteration as exc:\n            raise EntryNotFoundForHashError(entry_hash) from exc\n\n    def context(\n        self,\n        entry_hash: str,\n    ) -&gt; tuple[\n        Directive,\n        Mapping[str, Sequence[str]] | None,\n        Mapping[str, Sequence[str]] | None,\n    ]:\n        \"\"\"Context for an entry.\n\n        Arguments:\n            entry_hash: Hash of entry.\n\n        Returns:\n            A tuple ``(entry, before, after, source_slice, sha256sum)`` of the\n            (unique) entry with the given ``entry_hash``. If the entry is a\n            Balance or Transaction then ``before`` and ``after`` contain\n            the balances before and after the entry of the affected accounts.\n        \"\"\"\n        entry = self.get_entry(entry_hash)\n\n        if not isinstance(entry, (Balance, Transaction)):\n            return entry, None, None\n\n        entry_accounts = get_entry_accounts(entry)\n        balances = {account: CounterInventory() for account in entry_accounts}\n        for entry_ in takewhile(lambda e: e is not entry, self.all_entries):\n            if isinstance(entry_, Transaction):\n                for posting in entry_.postings:\n                    balance = balances.get(posting.account, None)\n                    if balance is not None:\n                        balance.add_position(posting)\n\n        def visualise(inv: CounterInventory) -&gt; Sequence[str]:\n            return inv.to_strings()\n\n        before = {acc: visualise(inv) for acc, inv in balances.items()}\n\n        if isinstance(entry, Balance):\n            return entry, before, None\n\n        for posting in entry.postings:\n            balances[posting.account].add_position(posting)\n        after = {acc: visualise(inv) for acc, inv in balances.items()}\n        return entry, before, after\n\n    def commodity_pairs(self) -&gt; Sequence[tuple[str, str]]:\n        \"\"\"List pairs of commodities.\n\n        Returns:\n            A list of pairs of commodities. Pairs of operating currencies will\n            be given in both directions not just in the one found in file.\n        \"\"\"\n        return self.prices.commodity_pairs(self.options[\"operating_currency\"])\n\n    def statement_path(self, entry_hash: str, metadata_key: str) -&gt; str:\n        \"\"\"Get the path for a statement found in the specified entry.\n\n        The entry that we look up should contain a path to a document (absolute\n        or relative to the filename of the entry) or just its basename. We go\n        through all documents and match on the full path or if one of the\n        documents with a matching account has a matching file basename.\n\n        Arguments:\n            entry_hash: Hash of the entry containing the path in its metadata.\n            metadata_key: The key that the path should be in.\n\n        Returns:\n            The filename of the matching document entry.\n\n        Raises:\n            StatementMetadataInvalidError: If the metadata at the given key is\n                                           invalid.\n            StatementNotFoundError: If no matching document is found.\n        \"\"\"\n        entry = self.get_entry(entry_hash)\n        value = entry.meta.get(metadata_key, None)\n        if not isinstance(value, str):\n            raise StatementMetadataInvalidError(metadata_key)\n\n        accounts = set(get_entry_accounts(entry))\n        filename, _ = get_position(entry)\n        full_path = (Path(filename).parent / value).resolve()\n        for document in self.all_entries_by_type.Document:\n            document_path = Path(document.filename)\n            if document_path == full_path:\n                return document.filename\n            if document.account in accounts and document_path.name == value:\n                return document.filename\n\n        raise StatementNotFoundError\n\n    group_entries_by_type = staticmethod(group_entries_by_type)\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.mtime","title":"<code>mtime</code>  <code>property</code>","text":"<p>The timestamp to the latest change of the underlying files.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.errors","title":"<code>errors</code>  <code>property</code>","text":"<p>The errors that the Beancount loading plus Fava module errors.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.root_accounts","title":"<code>root_accounts</code>  <code>property</code>","text":"<p>The five root accounts.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.__init__","title":"<code>__init__(path, *, poll_watcher=False)</code>","text":"<p>Create an interface for a Beancount ledger.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>str</code> <p>Path to the main Beancount file.</p> required <code>poll_watcher</code> <code>bool</code> <p>Whether to use the polling file watcher.</p> <code>False</code> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def __init__(self, path: str, *, poll_watcher: bool = False) -&gt; None:\n    \"\"\"Create an interface for a Beancount ledger.\n\n    Arguments:\n        path: Path to the main Beancount file.\n        poll_watcher: Whether to use the polling file watcher.\n    \"\"\"\n    #: The path to the main Beancount file.\n    self.beancount_file_path = path\n    self._is_encrypted = is_encrypted_file(path)\n    self.get_filtered = lru_cache(maxsize=16)(self._get_filtered)\n    self.get_entry = lru_cache(maxsize=16)(self._get_entry)\n\n    self.accounts = AccountDict(self)\n    self.attributes = AttributesModule(self)\n    self.budgets = BudgetModule(self)\n    self.charts = ChartModule(self)\n    self.commodities = CommoditiesModule(self)\n    self.extensions = ExtensionModule(self)\n    self.file = FileModule(self)\n    self.format_decimal = DecimalFormatModule(self)\n    self.ingest = IngestModule(self)\n    self.misc = FavaMisc(self)\n    self.query_shell = QueryShell(self)\n\n    self.watcher = WatchfilesWatcher() if not poll_watcher else Watcher()\n\n    self.load_file()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.load_file","title":"<code>load_file()</code>","text":"<p>Load the main file and all included files and set attributes.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def load_file(self) -&gt; None:\n    \"\"\"Load the main file and all included files and set attributes.\"\"\"\n    self.all_entries, self.load_errors, self.options = load_uncached(\n        self.beancount_file_path,\n        is_encrypted=self._is_encrypted,\n    )\n    self.get_filtered.cache_clear()\n    self.get_entry.cache_clear()\n\n    self.all_entries_by_type = group_entries_by_type(self.all_entries)\n    self.prices = RustfavaPriceMap(self.all_entries_by_type.Price)\n\n    self.fava_options, self.fava_options_errors = parse_options(\n        self.all_entries_by_type.Custom,\n    )\n\n    if self._is_encrypted:  # pragma: no cover\n        pass\n    else:\n        self.watcher.update(*self.paths_to_watch())\n\n    # Call load_file of all modules.\n    self.accounts.load_file()\n    self.attributes.load_file()\n    self.budgets.load_file()\n    self.charts.load_file()\n    self.commodities.load_file()\n    self.extensions.load_file()\n    self.file.load_file()\n    self.format_decimal.load_file()\n    self.misc.load_file()\n    self.query_shell.load_file()\n    self.ingest.load_file()\n\n    self.extensions.after_load_file()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.join_path","title":"<code>join_path(*args)</code>","text":"<p>Path relative to the directory of the ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def join_path(self, *args: str) -&gt; Path:\n    \"\"\"Path relative to the directory of the ledger.\"\"\"\n    return Path(self.beancount_file_path).parent.joinpath(*args).resolve()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.paths_to_watch","title":"<code>paths_to_watch()</code>","text":"<p>Get paths to included files and document directories.</p> <p>Returns:</p> Type Description <code>tuple[Sequence[Path], Sequence[Path]]</code> <p>A tuple (files, directories).</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def paths_to_watch(self) -&gt; tuple[Sequence[Path], Sequence[Path]]:\n    \"\"\"Get paths to included files and document directories.\n\n    Returns:\n        A tuple (files, directories).\n    \"\"\"\n    files = [Path(i) for i in self.options[\"include\"]]\n    if self.ingest.module_path:\n        files.append(self.ingest.module_path)\n    return (\n        files,\n        [\n            self.join_path(path, account)\n            for account in self.root_accounts\n            for path in self.options[\"documents\"]\n        ],\n    )\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.changed","title":"<code>changed()</code>","text":"<p>Check if the file needs to be reloaded.</p> <p>Returns:</p> Type Description <code>bool</code> <p>True if a change in one of the included files or a change in a</p> <code>bool</code> <p>document folder was detected and the file has been reloaded.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def changed(self) -&gt; bool:\n    \"\"\"Check if the file needs to be reloaded.\n\n    Returns:\n        True if a change in one of the included files or a change in a\n        document folder was detected and the file has been reloaded.\n    \"\"\"\n    # We can't reload an encrypted file, so act like it never changes.\n    if self._is_encrypted:  # pragma: no cover\n        return False\n    changed = self.watcher.check()\n    if changed:\n        self.load_file()\n    return changed\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.interval_balances","title":"<code>interval_balances(filtered, interval, account_name, *, accumulate=False)</code>","text":"<p>Balances by interval.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The currently filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>An interval.</p> required <code>account_name</code> <code>str</code> <p>An account name.</p> required <code>accumulate</code> <code>bool</code> <p>A boolean, <code>True</code> if the balances for an interval should include all entries up to the end of the interval.</p> <code>False</code> <p>Returns:</p> Type Description <code>tuple[Sequence[Tree], Sequence[DateRange]]</code> <p>A pair of a list of Tree instances and the intervals.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def interval_balances(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    account_name: str,\n    *,\n    accumulate: bool = False,\n) -&gt; tuple[Sequence[Tree], Sequence[DateRange]]:\n    \"\"\"Balances by interval.\n\n    Arguments:\n        filtered: The currently filtered ledger.\n        interval: An interval.\n        account_name: An account name.\n        accumulate: A boolean, ``True`` if the balances for an interval\n            should include all entries up to the end of the interval.\n\n    Returns:\n        A pair of a list of Tree instances and the intervals.\n    \"\"\"\n    min_accounts = [\n        account\n        for account in self.accounts\n        if account.startswith(account_name)\n    ]\n\n    interval_ranges = list(reversed(filtered.interval_ranges(interval)))\n    interval_balances = [\n        Tree(\n            slice_entry_dates(\n                filtered.entries,\n                date.min if accumulate else date_range.begin,\n                date_range.end,\n            ),\n            min_accounts,\n        )\n        for date_range in interval_ranges\n    ]\n\n    return interval_balances, interval_ranges\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.account_journal","title":"<code>account_journal(filtered, account_name, conversion, *, with_children)</code>","text":"<p>Journal for an account.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The currently filtered ledger.</p> required <code>account_name</code> <code>str</code> <p>An account name.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <code>with_children</code> <code>bool</code> <p>Whether to include postings of subaccounts of            the account.</p> required <p>Yields:</p> Type Description <code>Iterable[tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]]</code> <p>Tuples of <code>(index, entry, change, balance)</code>.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>@listify\ndef account_journal(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: str | Conversion,\n    *,\n    with_children: bool,\n) -&gt; Iterable[\n    tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]\n]:\n    \"\"\"Journal for an account.\n\n    Args:\n        filtered: The currently filtered ledger.\n        account_name: An account name.\n        conversion: The conversion to use.\n        with_children: Whether to include postings of subaccounts of\n                       the account.\n\n    Yields:\n        Tuples of ``(index, entry, change, balance)``.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    relevant_account = account_tester(\n        account_name, with_children=with_children\n    )\n\n    prices = self.prices\n    balance = CounterInventory()\n    for index, entry in enumerate(filtered.entries_without_prices):\n        change = CounterInventory()\n        entry_is_relevant = False\n        postings = getattr(entry, \"postings\", None)\n        if postings is not None:\n            for posting in postings:\n                if relevant_account(posting.account):\n                    entry_is_relevant = True\n                    balance.add_position(posting)\n                    change.add_position(posting)\n        elif any(relevant_account(a) for a in get_entry_accounts(entry)):\n            entry_is_relevant = True\n\n        if entry_is_relevant:\n            yield (\n                index,\n                entry,\n                conv.apply(change, prices, entry.date),\n                conv.apply(balance, prices, entry.date),\n            )\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.context","title":"<code>context(entry_hash)</code>","text":"<p>Context for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of entry.</p> required <p>Returns:</p> Type Description <code>Directive</code> <p>A tuple <code>(entry, before, after, source_slice, sha256sum)</code> of the</p> <code>Mapping[str, Sequence[str]] | None</code> <p>(unique) entry with the given <code>entry_hash</code>. If the entry is a</p> <code>Mapping[str, Sequence[str]] | None</code> <p>Balance or Transaction then <code>before</code> and <code>after</code> contain</p> <code>tuple[Directive, Mapping[str, Sequence[str]] | None, Mapping[str, Sequence[str]] | None]</code> <p>the balances before and after the entry of the affected accounts.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def context(\n    self,\n    entry_hash: str,\n) -&gt; tuple[\n    Directive,\n    Mapping[str, Sequence[str]] | None,\n    Mapping[str, Sequence[str]] | None,\n]:\n    \"\"\"Context for an entry.\n\n    Arguments:\n        entry_hash: Hash of entry.\n\n    Returns:\n        A tuple ``(entry, before, after, source_slice, sha256sum)`` of the\n        (unique) entry with the given ``entry_hash``. If the entry is a\n        Balance or Transaction then ``before`` and ``after`` contain\n        the balances before and after the entry of the affected accounts.\n    \"\"\"\n    entry = self.get_entry(entry_hash)\n\n    if not isinstance(entry, (Balance, Transaction)):\n        return entry, None, None\n\n    entry_accounts = get_entry_accounts(entry)\n    balances = {account: CounterInventory() for account in entry_accounts}\n    for entry_ in takewhile(lambda e: e is not entry, self.all_entries):\n        if isinstance(entry_, Transaction):\n            for posting in entry_.postings:\n                balance = balances.get(posting.account, None)\n                if balance is not None:\n                    balance.add_position(posting)\n\n    def visualise(inv: CounterInventory) -&gt; Sequence[str]:\n        return inv.to_strings()\n\n    before = {acc: visualise(inv) for acc, inv in balances.items()}\n\n    if isinstance(entry, Balance):\n        return entry, before, None\n\n    for posting in entry.postings:\n        balances[posting.account].add_position(posting)\n    after = {acc: visualise(inv) for acc, inv in balances.items()}\n    return entry, before, after\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.commodity_pairs","title":"<code>commodity_pairs()</code>","text":"<p>List pairs of commodities.</p> <p>Returns:</p> Type Description <code>Sequence[tuple[str, str]]</code> <p>A list of pairs of commodities. Pairs of operating currencies will</p> <code>Sequence[tuple[str, str]]</code> <p>be given in both directions not just in the one found in file.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def commodity_pairs(self) -&gt; Sequence[tuple[str, str]]:\n    \"\"\"List pairs of commodities.\n\n    Returns:\n        A list of pairs of commodities. Pairs of operating currencies will\n        be given in both directions not just in the one found in file.\n    \"\"\"\n    return self.prices.commodity_pairs(self.options[\"operating_currency\"])\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.statement_path","title":"<code>statement_path(entry_hash, metadata_key)</code>","text":"<p>Get the path for a statement found in the specified entry.</p> <p>The entry that we look up should contain a path to a document (absolute or relative to the filename of the entry) or just its basename. We go through all documents and match on the full path or if one of the documents with a matching account has a matching file basename.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of the entry containing the path in its metadata.</p> required <code>metadata_key</code> <code>str</code> <p>The key that the path should be in.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The filename of the matching document entry.</p> <p>Raises:</p> Type Description <code>StatementMetadataInvalidError</code> <p>If the metadata at the given key is                            invalid.</p> <code>StatementNotFoundError</code> <p>If no matching document is found.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def statement_path(self, entry_hash: str, metadata_key: str) -&gt; str:\n    \"\"\"Get the path for a statement found in the specified entry.\n\n    The entry that we look up should contain a path to a document (absolute\n    or relative to the filename of the entry) or just its basename. We go\n    through all documents and match on the full path or if one of the\n    documents with a matching account has a matching file basename.\n\n    Arguments:\n        entry_hash: Hash of the entry containing the path in its metadata.\n        metadata_key: The key that the path should be in.\n\n    Returns:\n        The filename of the matching document entry.\n\n    Raises:\n        StatementMetadataInvalidError: If the metadata at the given key is\n                                       invalid.\n        StatementNotFoundError: If no matching document is found.\n    \"\"\"\n    entry = self.get_entry(entry_hash)\n    value = entry.meta.get(metadata_key, None)\n    if not isinstance(value, str):\n        raise StatementMetadataInvalidError(metadata_key)\n\n    accounts = set(get_entry_accounts(entry))\n    filename, _ = get_position(entry)\n    full_path = (Path(filename).parent / value).resolve()\n    for document in self.all_entries_by_type.Document:\n        document_path = Path(document.filename)\n        if document_path == full_path:\n            return document.filename\n        if document.account in accounts and document_path.name == value:\n            return document.filename\n\n    raise StatementNotFoundError\n</code></pre>"},{"location":"api/#rustfava.core.accounts","title":"<code>accounts</code>","text":"<p>Account close date and metadata.</p>"},{"location":"api/#rustfava.core.accounts.LastEntry","title":"<code>LastEntry</code>  <code>dataclass</code>","text":"<p>Date and hash of the last entry for an account.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>@dataclass(frozen=True)\nclass LastEntry:\n    \"\"\"Date and hash of the last entry for an account.\"\"\"\n\n    #: The entry date.\n    date: datetime.date\n\n    #: The entry hash.\n    entry_hash: str\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountData","title":"<code>AccountData</code>  <code>dataclass</code>","text":"<p>Holds information about an account.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>@dataclass\nclass AccountData:\n    \"\"\"Holds information about an account.\"\"\"\n\n    #: The date on which this account is closed (or datetime.date.max).\n    close_date: datetime.date | None = None\n\n    #: The metadata of the Open entry of this account.\n    meta: Meta = field(default_factory=dict)\n\n    #: Uptodate status. Is only computed if the account has a\n    #: \"fava-uptodate-indication\" meta attribute.\n    uptodate_status: Literal[\"green\", \"yellow\", \"red\"] | None = None\n\n    #: Balance directive if this account has an uptodate status.\n    balance_string: str | None = None\n\n    #: The last entry of the account (unless it is a close Entry)\n    last_entry: LastEntry | None = None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict","title":"<code>AccountDict</code>","text":"<p>               Bases: <code>FavaModule</code>, <code>dict[str, AccountData]</code></p> <p>Account info dictionary.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>class AccountDict(FavaModule, dict[str, AccountData]):\n    \"\"\"Account info dictionary.\"\"\"\n\n    EMPTY = AccountData()\n\n    def __missing__(self, key: str) -&gt; AccountData:\n        return self.EMPTY\n\n    def setdefault(\n        self,\n        key: str,\n        _: AccountData | None = None,\n    ) -&gt; AccountData:\n        \"\"\"Get the account of the given name, insert one if it is missing.\"\"\"\n        if key not in self:\n            self[key] = AccountData()\n        return self[key]\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.clear()\n        entries_by_account = group_entries_by_account(self.ledger.all_entries)\n        tree = Tree(self.ledger.all_entries)\n        for open_entry in self.ledger.all_entries_by_type.Open:\n            meta = open_entry.meta\n            account_data = self.setdefault(open_entry.account)\n            account_data.meta = meta\n\n            txn_postings = entries_by_account[open_entry.account]\n            last = get_last_entry(txn_postings)\n            if last is not None and not isinstance(last, Close):\n                account_data.last_entry = LastEntry(\n                    date=last.date,\n                    entry_hash=hash_entry(last),\n                )\n            if meta.get(\"fava-uptodate-indication\"):\n                account_data.uptodate_status = uptodate_status(txn_postings)\n                if account_data.uptodate_status != \"green\":\n                    account_data.balance_string = balance_string(\n                        tree.get(open_entry.account),\n                    )\n        for close in self.ledger.all_entries_by_type.Close:\n            self.setdefault(close.account).close_date = close.date\n\n    def all_balance_directives(self) -&gt; str:\n        \"\"\"Balance directives for all accounts.\"\"\"\n        return \"\".join(\n            account_details.balance_string\n            for account_details in self.values()\n            if account_details.balance_string\n        )\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict.setdefault","title":"<code>setdefault(key, _=None)</code>","text":"<p>Get the account of the given name, insert one if it is missing.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def setdefault(\n    self,\n    key: str,\n    _: AccountData | None = None,\n) -&gt; AccountData:\n    \"\"\"Get the account of the given name, insert one if it is missing.\"\"\"\n    if key not in self:\n        self[key] = AccountData()\n    return self[key]\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict.all_balance_directives","title":"<code>all_balance_directives()</code>","text":"<p>Balance directives for all accounts.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def all_balance_directives(self) -&gt; str:\n    \"\"\"Balance directives for all accounts.\"\"\"\n    return \"\".join(\n        account_details.balance_string\n        for account_details in self.values()\n        if account_details.balance_string\n    )\n</code></pre>"},{"location":"api/#rustfava.core.accounts.get_last_entry","title":"<code>get_last_entry(txn_postings)</code>","text":"<p>Last entry.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def get_last_entry(\n    txn_postings: Sequence[Directive | TransactionPosting],\n) -&gt; Directive | None:\n    \"\"\"Last entry.\"\"\"\n    for txn_posting in reversed(txn_postings):\n        if isinstance(txn_posting, TransactionPosting):\n            transaction = txn_posting.transaction\n            if transaction.flag != FLAG_UNREALIZED:\n                return transaction\n        else:\n            return txn_posting\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.uptodate_status","title":"<code>uptodate_status(txn_postings)</code>","text":"<p>Status of the last balance or transaction.</p> <p>Parameters:</p> Name Type Description Default <code>txn_postings</code> <code>Sequence[Directive | TransactionPosting]</code> <p>The TransactionPosting for the account.</p> required <p>Returns:</p> Type Description <code>Literal['green', 'yellow', 'red'] | None</code> <p>A status string for the last balance or transaction of the account.</p> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'green':  A balance check that passed.</li> </ul> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'red':    A balance check that failed.</li> </ul> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'yellow': Not a balance check.</li> </ul> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def uptodate_status(\n    txn_postings: Sequence[Directive | TransactionPosting],\n) -&gt; Literal[\"green\", \"yellow\", \"red\"] | None:\n    \"\"\"Status of the last balance or transaction.\n\n    Args:\n        txn_postings: The TransactionPosting for the account.\n\n    Returns:\n        A status string for the last balance or transaction of the account.\n\n        - 'green':  A balance check that passed.\n        - 'red':    A balance check that failed.\n        - 'yellow': Not a balance check.\n    \"\"\"\n    for txn_posting in reversed(txn_postings):\n        if isinstance(txn_posting, Balance):\n            return \"red\" if txn_posting.diff_amount else \"green\"\n        if (\n            isinstance(txn_posting, TransactionPosting)\n            and txn_posting.transaction.flag != FLAG_UNREALIZED\n        ):\n            return \"yellow\"\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.balance_string","title":"<code>balance_string(tree_node)</code>","text":"<p>Balance directive for the given account for today.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def balance_string(tree_node: TreeNode) -&gt; str:\n    \"\"\"Balance directive for the given account for today.\"\"\"\n    account = tree_node.name\n    today = str(local_today())\n    res = \"\"\n    for currency, number in UNITS.apply(tree_node.balance).items():\n        res += f\"{today} balance {account:&lt;28} {number:&gt;15} {currency}\\n\"\n    return res\n</code></pre>"},{"location":"api/#rustfava.core.attributes","title":"<code>attributes</code>","text":"<p>Attributes for auto-completion.</p>"},{"location":"api/#rustfava.core.attributes.AttributesModule","title":"<code>AttributesModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Some attributes of the ledger (mostly for auto-completion).</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>class AttributesModule(FavaModule):\n    \"\"\"Some attributes of the ledger (mostly for auto-completion).\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.accounts: Sequence[str] = []\n        self.currencies: Sequence[str] = []\n        self.payees: Sequence[str] = []\n        self.links: Sequence[str] = []\n        self.tags: Sequence[str] = []\n        self.years: Sequence[str] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        all_entries = self.ledger.all_entries\n\n        all_links = set()\n        all_tags = set()\n        for entry in all_entries:\n            links = getattr(entry, \"links\", None)\n            if links is not None:\n                all_links.update(links)\n            tags = getattr(entry, \"tags\", None)\n            if tags is not None:\n                all_tags.update(tags)\n        self.links = sorted(all_links)\n        self.tags = sorted(all_tags)\n\n        self.years = get_active_years(\n            all_entries,\n            self.ledger.fava_options.fiscal_year_end,\n        )\n\n        account_ranker = ExponentialDecayRanker(\n            sorted(self.ledger.accounts.keys()),\n        )\n        currency_ranker = ExponentialDecayRanker()\n        payee_ranker = ExponentialDecayRanker()\n\n        for txn in self.ledger.all_entries_by_type.Transaction:\n            if txn.payee:\n                payee_ranker.update(txn.payee, txn.date)\n            for posting in txn.postings:\n                account_ranker.update(posting.account, txn.date)\n                # Skip postings with missing units (can happen with parse errors)\n                if posting.units is not None:\n                    currency_ranker.update(posting.units.currency, txn.date)\n                if posting.cost and posting.cost.currency is not None:\n                    currency_ranker.update(posting.cost.currency, txn.date)\n\n        self.accounts = account_ranker.sort()\n        self.currencies = currency_ranker.sort()\n        self.payees = payee_ranker.sort()\n\n    def payee_accounts(self, payee: str) -&gt; Sequence[str]:\n        \"\"\"Rank accounts for the given payee.\"\"\"\n        account_ranker = ExponentialDecayRanker(self.accounts)\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in transactions:\n            if txn.payee == payee:\n                for posting in txn.postings:\n                    account_ranker.update(posting.account, txn.date)\n        return account_ranker.sort()\n\n    def payee_transaction(self, payee: str) -&gt; Transaction | None:\n        \"\"\"Get the last transaction for a payee.\"\"\"\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in reversed(transactions):\n            if txn.payee == payee:\n                return txn\n        return None\n\n    def narration_transaction(self, narration: str) -&gt; Transaction | None:\n        \"\"\"Get the last transaction for a narration.\"\"\"\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in reversed(transactions):\n            if txn.narration == narration:\n                return txn\n        return None\n\n    @property\n    def narrations(self) -&gt; Sequence[str]:\n        \"\"\"Get the narrations of all transactions.\"\"\"\n        narration_ranker = ExponentialDecayRanker()\n        for txn in self.ledger.all_entries_by_type.Transaction:\n            if txn.narration:\n                narration_ranker.update(txn.narration, txn.date)\n        return narration_ranker.sort()\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.narrations","title":"<code>narrations</code>  <code>property</code>","text":"<p>Get the narrations of all transactions.</p>"},{"location":"api/#rustfava.core.attributes.AttributesModule.payee_accounts","title":"<code>payee_accounts(payee)</code>","text":"<p>Rank accounts for the given payee.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def payee_accounts(self, payee: str) -&gt; Sequence[str]:\n    \"\"\"Rank accounts for the given payee.\"\"\"\n    account_ranker = ExponentialDecayRanker(self.accounts)\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in transactions:\n        if txn.payee == payee:\n            for posting in txn.postings:\n                account_ranker.update(posting.account, txn.date)\n    return account_ranker.sort()\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.payee_transaction","title":"<code>payee_transaction(payee)</code>","text":"<p>Get the last transaction for a payee.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def payee_transaction(self, payee: str) -&gt; Transaction | None:\n    \"\"\"Get the last transaction for a payee.\"\"\"\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in reversed(transactions):\n        if txn.payee == payee:\n            return txn\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.narration_transaction","title":"<code>narration_transaction(narration)</code>","text":"<p>Get the last transaction for a narration.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def narration_transaction(self, narration: str) -&gt; Transaction | None:\n    \"\"\"Get the last transaction for a narration.\"\"\"\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in reversed(transactions):\n        if txn.narration == narration:\n            return txn\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.attributes.get_active_years","title":"<code>get_active_years(entries, fye)</code>","text":"<p>Return active years, with support for fiscal years.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>Beancount entries</p> required <code>fye</code> <code>FiscalYearEnd</code> <p>fiscal year end</p> required <p>Returns:</p> Type Description <code>list[str]</code> <p>A reverse sorted list of years or fiscal years that occur in the</p> <code>list[str]</code> <p>entries.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def get_active_years(\n    entries: Sequence[Directive],\n    fye: FiscalYearEnd,\n) -&gt; list[str]:\n    \"\"\"Return active years, with support for fiscal years.\n\n    Args:\n        entries: Beancount entries\n        fye: fiscal year end\n\n    Returns:\n        A reverse sorted list of years or fiscal years that occur in the\n        entries.\n    \"\"\"\n    years = []\n    if fye == END_OF_YEAR:\n        prev_year = None\n        for entry in entries:\n            year = entry.date.year\n            if year != prev_year:\n                prev_year = year\n                years.append(year)\n        return [f\"{year}\" for year in reversed(years)]\n    month = fye.month\n    day = fye.day\n    prev_year = None\n    for entry in entries:\n        date = entry.date\n        year = (\n            entry.date.year + 1\n            if date.month &gt; month or (date.month == month and date.day &gt; day)\n            else entry.date.year\n        )\n        if year != prev_year:\n            prev_year = year\n            years.append(year)\n    return [f\"FY{year}\" for year in reversed(years)]\n</code></pre>"},{"location":"api/#rustfava.core.budgets","title":"<code>budgets</code>","text":"<p>Parsing and computing budgets.</p>"},{"location":"api/#rustfava.core.budgets.BudgetDict","title":"<code>BudgetDict = dict[str, list[Budget]]</code>  <code>module-attribute</code>","text":"<p>A map of account names to lists of budget entries.</p>"},{"location":"api/#rustfava.core.budgets.Budget","title":"<code>Budget</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>A budget entry.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class Budget(NamedTuple):\n    \"\"\"A budget entry.\"\"\"\n\n    account: str\n    date_start: datetime.date\n    period: Interval\n    number: Decimal\n    currency: str\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetError","title":"<code>BudgetError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>Error with a budget.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class BudgetError(BeancountError):\n    \"\"\"Error with a budget.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule","title":"<code>BudgetModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Parses budget entries.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class BudgetModule(FavaModule):\n    \"\"\"Parses budget entries.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._budget_entries: BudgetDict = {}\n        self.errors: Sequence[BudgetError] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self._budget_entries, self.errors = parse_budgets(\n            self.ledger.all_entries_by_type.Custom,\n        )\n\n    def calculate(\n        self,\n        account: str,\n        begin_date: datetime.date,\n        end_date: datetime.date,\n    ) -&gt; Mapping[str, Decimal]:\n        \"\"\"Calculate the budget for an account in an interval.\"\"\"\n        return calculate_budget(\n            self._budget_entries,\n            account,\n            begin_date,\n            end_date,\n        )\n\n    def calculate_children(\n        self,\n        account: str,\n        begin_date: datetime.date,\n        end_date: datetime.date,\n    ) -&gt; Mapping[str, Decimal]:\n        \"\"\"Calculate the budget for an account including its children.\"\"\"\n        return calculate_budget_children(\n            self._budget_entries,\n            account,\n            begin_date,\n            end_date,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule.calculate","title":"<code>calculate(account, begin_date, end_date)</code>","text":"<p>Calculate the budget for an account in an interval.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate(\n    self,\n    account: str,\n    begin_date: datetime.date,\n    end_date: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate the budget for an account in an interval.\"\"\"\n    return calculate_budget(\n        self._budget_entries,\n        account,\n        begin_date,\n        end_date,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule.calculate_children","title":"<code>calculate_children(account, begin_date, end_date)</code>","text":"<p>Calculate the budget for an account including its children.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_children(\n    self,\n    account: str,\n    begin_date: datetime.date,\n    end_date: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate the budget for an account including its children.\"\"\"\n    return calculate_budget_children(\n        self._budget_entries,\n        account,\n        begin_date,\n        end_date,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.parse_budgets","title":"<code>parse_budgets(custom_entries)</code>","text":"<p>Parse budget directives from custom entries.</p> <p>Parameters:</p> Name Type Description Default <code>custom_entries</code> <code>Sequence[Custom]</code> <p>the Custom entries to parse budgets from.</p> required <p>Returns:</p> Type Description <code>tuple[BudgetDict, Sequence[BudgetError]]</code> <p>A dict of accounts to lists of budgets.</p> Example <p>2015-04-09 custom \"budget\" Expenses:Books \"monthly\" 20.00 EUR</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def parse_budgets(\n    custom_entries: Sequence[Custom],\n) -&gt; tuple[BudgetDict, Sequence[BudgetError]]:\n    \"\"\"Parse budget directives from custom entries.\n\n    Args:\n        custom_entries: the Custom entries to parse budgets from.\n\n    Returns:\n        A dict of accounts to lists of budgets.\n\n    Example:\n        2015-04-09 custom \"budget\" Expenses:Books \"monthly\" 20.00 EUR\n    \"\"\"\n    budgets: BudgetDict = defaultdict(list)\n    errors = []\n\n    for entry in (entry for entry in custom_entries if entry.type == \"budget\"):\n        try:\n            interval = INTERVALS.get(str(entry.values[1].value).lower())\n            if not interval:\n                errors.append(\n                    BudgetError(\n                        entry.meta,\n                        \"Invalid interval for budget entry\",\n                        entry,\n                    ),\n                )\n                continue\n            budget = Budget(\n                entry.values[0].value,\n                entry.date,\n                interval,\n                entry.values[2].value.number,\n                entry.values[2].value.currency,\n            )\n            budgets[budget.account].append(budget)\n        except (IndexError, TypeError):\n            errors.append(\n                BudgetError(entry.meta, \"Failed to parse budget entry\", entry),\n            )\n\n    return budgets, errors\n</code></pre>"},{"location":"api/#rustfava.core.budgets.calculate_budget","title":"<code>calculate_budget(budgets, account, date_from, date_to)</code>","text":"<p>Calculate budget for an account.</p> <p>Parameters:</p> Name Type Description Default <code>budgets</code> <code>BudgetDict</code> <p>A list of :class:<code>Budget</code> entries.</p> required <code>account</code> <code>str</code> <p>An account name.</p> required <code>date_from</code> <code>date</code> <p>Starting date.</p> required <code>date_to</code> <code>date</code> <p>End date (exclusive).</p> required <p>Returns:</p> Type Description <code>Mapping[str, Decimal]</code> <p>A dictionary of currency to Decimal with the budget for the</p> <code>Mapping[str, Decimal]</code> <p>specified account and period.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_budget(\n    budgets: BudgetDict,\n    account: str,\n    date_from: datetime.date,\n    date_to: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate budget for an account.\n\n    Args:\n        budgets: A list of :class:`Budget` entries.\n        account: An account name.\n        date_from: Starting date.\n        date_to: End date (exclusive).\n\n    Returns:\n        A dictionary of currency to Decimal with the budget for the\n        specified account and period.\n    \"\"\"\n    budget_list = budgets.get(account, None)\n    if budget_list is None:\n        return {}\n\n    currency_dict: dict[str, Decimal] = defaultdict(Decimal)\n\n    for day in days_in_daterange(date_from, date_to):\n        matches = _matching_budgets(budget_list, day)\n        for budget in matches.values():\n            days_in_period = budget.period.number_of_days(day)\n            currency_dict[budget.currency] += budget.number / days_in_period\n    return dict(currency_dict)\n</code></pre>"},{"location":"api/#rustfava.core.budgets.calculate_budget_children","title":"<code>calculate_budget_children(budgets, account, date_from, date_to)</code>","text":"<p>Calculate budget for an account including budgets of its children.</p> <p>Parameters:</p> Name Type Description Default <code>budgets</code> <code>BudgetDict</code> <p>A list of :class:<code>Budget</code> entries.</p> required <code>account</code> <code>str</code> <p>An account name.</p> required <code>date_from</code> <code>date</code> <p>Starting date.</p> required <code>date_to</code> <code>date</code> <p>End date (exclusive).</p> required <p>Returns:</p> Type Description <code>Mapping[str, Decimal]</code> <p>A dictionary of currency to Decimal with the budget for the</p> <code>Mapping[str, Decimal]</code> <p>specified account and period.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_budget_children(\n    budgets: BudgetDict,\n    account: str,\n    date_from: datetime.date,\n    date_to: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate budget for an account including budgets of its children.\n\n    Args:\n        budgets: A list of :class:`Budget` entries.\n        account: An account name.\n        date_from: Starting date.\n        date_to: End date (exclusive).\n\n    Returns:\n        A dictionary of currency to Decimal with the budget for the\n        specified account and period.\n    \"\"\"\n    currency_dict: dict[str, Decimal] = Counter()  # type: ignore[assignment]\n\n    for child in budgets:\n        if child.startswith(account):\n            currency_dict.update(\n                calculate_budget(budgets, child, date_from, date_to),\n            )\n    return dict(currency_dict)\n</code></pre>"},{"location":"api/#rustfava.core.charts","title":"<code>charts</code>","text":"<p>Provide data suitable for rustfava's charts.</p>"},{"location":"api/#rustfava.core.charts.RustfavaJSONProvider","title":"<code>RustfavaJSONProvider</code>","text":"<p>               Bases: <code>JSONProvider</code></p> <p>Use custom JSON encoder and decoder.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>class RustfavaJSONProvider(JSONProvider):\n    \"\"\"Use custom JSON encoder and decoder.\"\"\"\n\n    def dumps(self, obj: Any, **_kwargs: Any) -&gt; str:  # noqa: D102\n        return json.dumps(\n            obj, sort_keys=True, separators=(\",\", \":\"), default=_json_default\n        )\n\n    def loads(self, s: str | bytes, **_kwargs: Any) -&gt; Any:  # noqa: D102\n        return json.loads(s)\n</code></pre>"},{"location":"api/#rustfava.core.charts.DateAndBalance","title":"<code>DateAndBalance</code>  <code>dataclass</code>","text":"<p>Balance at a date.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@dataclass(frozen=True)\nclass DateAndBalance:\n    \"\"\"Balance at a date.\"\"\"\n\n    date: date\n    balance: SimpleCounterInventory\n</code></pre>"},{"location":"api/#rustfava.core.charts.DateAndBalanceWithBudget","title":"<code>DateAndBalanceWithBudget</code>  <code>dataclass</code>","text":"<p>Balance at a date with a budget.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@dataclass(frozen=True)\nclass DateAndBalanceWithBudget:\n    \"\"\"Balance at a date with a budget.\"\"\"\n\n    date: date\n    balance: SimpleCounterInventory\n    account_balances: Mapping[str, SimpleCounterInventory]\n    budgets: Mapping[str, Decimal]\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule","title":"<code>ChartModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Return data for the various charts in rustfava.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>class ChartModule(FavaModule):\n    \"\"\"Return data for the various charts in rustfava.\"\"\"\n\n    def hierarchy(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: Conversion,\n    ) -&gt; SerialisedTreeNode:\n        \"\"\"Render an account tree.\"\"\"\n        tree = filtered.root_tree\n        return tree.get(account_name).serialise(\n            conversion, self.ledger.prices, filtered.end_date\n        )\n\n    @listify\n    def interval_totals(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        accounts: str | tuple[str, ...],\n        conversion: str | Conversion,\n        *,\n        invert: bool = False,\n    ) -&gt; Iterable[DateAndBalanceWithBudget]:\n        \"\"\"Render totals for account (or accounts) in the intervals.\n\n        Args:\n            filtered: The filtered ledger.\n            interval: An interval.\n            accounts: A single account (str) or a tuple of accounts.\n            conversion: The conversion to use.\n            invert: invert all numbers.\n\n        Yields:\n            The balances and budgets for the intervals.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        prices = self.ledger.prices\n\n        # limit the bar charts to 100 intervals\n        intervals = filtered.interval_ranges(interval)[-100:]\n\n        for date_range in intervals:\n            inventory = CounterInventory()\n            entries = slice_entry_dates(\n                filtered.entries, date_range.begin, date_range.end\n            )\n            account_inventories: dict[str, CounterInventory] = defaultdict(\n                CounterInventory,\n            )\n            for entry in entries:\n                for posting in getattr(entry, \"postings\", []):\n                    if posting.account.startswith(accounts):\n                        account_inventories[posting.account].add_position(\n                            posting,\n                        )\n                        inventory.add_position(posting)\n            balance = conv.apply(\n                inventory,\n                prices,\n                date_range.end_inclusive,\n            )\n            account_balances = {\n                account: conv.apply(\n                    acct_value,\n                    prices,\n                    date_range.end_inclusive,\n                )\n                for account, acct_value in account_inventories.items()\n            }\n            budgets = (\n                self.ledger.budgets.calculate_children(\n                    accounts,\n                    date_range.begin,\n                    date_range.end,\n                )\n                if isinstance(accounts, str)\n                else {}\n            )\n\n            if invert:\n                balance = -balance\n                budgets = {k: -v for k, v in budgets.items()}\n                account_balances = {k: -v for k, v in account_balances.items()}\n\n            yield DateAndBalanceWithBudget(\n                date_range.end_inclusive,\n                balance,\n                account_balances,\n                budgets,\n            )\n\n    @listify\n    def linechart(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: str | Conversion,\n    ) -&gt; Iterable[DateAndBalance]:\n        \"\"\"Get the balance of an account as a line chart.\n\n        Args:\n            filtered: The filtered ledger.\n            account_name: A string.\n            conversion: The conversion to use.\n\n        Yields:\n            Dicts for all dates on which the balance of the given\n            account has changed containing the balance (in units) of the\n            account at that date.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n\n        def _balances() -&gt; Iterable[tuple[date, CounterInventory]]:\n            last_date = None\n            running_balance = CounterInventory()\n            is_child_account = account_tester(account_name, with_children=True)\n\n            for entry in filtered.entries:\n                for posting in getattr(entry, \"postings\", []):\n                    if is_child_account(posting.account):\n                        new_date = entry.date\n                        if last_date is not None and new_date &gt; last_date:\n                            yield (last_date, running_balance)\n                        running_balance.add_position(posting)\n                        last_date = new_date\n\n            if last_date is not None:\n                yield (last_date, running_balance)\n\n        # When the balance for a commodity just went to zero, it will be\n        # missing from the 'balance' so keep track of currencies that last had\n        # a balance.\n        last_currencies = None\n        prices = self.ledger.prices\n\n        for d, running_bal in _balances():\n            balance = conv.apply(running_bal, prices, d)\n            currencies = set(balance.keys())\n            if last_currencies:\n                for currency in last_currencies - currencies:\n                    balance[currency] = ZERO\n            last_currencies = currencies\n            yield DateAndBalance(d, balance)\n\n    @listify\n    def net_worth(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        conversion: str | Conversion,\n    ) -&gt; Iterable[DateAndBalance]:\n        \"\"\"Compute net worth.\n\n        Args:\n            filtered: The filtered ledger.\n            interval: A string for the interval.\n            conversion: The conversion to use.\n\n        Yields:\n            Dicts for all ends of the given interval containing the\n            net worth (Assets + Liabilities) separately converted to all\n            operating currencies.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        transactions = (\n            entry\n            for entry in filtered.entries\n            if (\n                isinstance(entry, Transaction)\n                and entry.flag != FLAG_UNREALIZED\n            )\n        )\n\n        types = (\n            self.ledger.options[\"name_assets\"],\n            self.ledger.options[\"name_liabilities\"],\n        )\n\n        txn = next(transactions, None)\n        inventory = CounterInventory()\n\n        prices = self.ledger.prices\n        for date_range in filtered.interval_ranges(interval):\n            while txn and txn.date &lt; date_range.end:\n                for posting in txn.postings:\n                    if posting.account.startswith(types):\n                        inventory.add_position(posting)\n                txn = next(transactions, None)\n            yield DateAndBalance(\n                date_range.end_inclusive,\n                conv.apply(\n                    inventory,\n                    prices,\n                    date_range.end_inclusive,\n                ),\n            )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.hierarchy","title":"<code>hierarchy(filtered, account_name, conversion)</code>","text":"<p>Render an account tree.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def hierarchy(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: Conversion,\n) -&gt; SerialisedTreeNode:\n    \"\"\"Render an account tree.\"\"\"\n    tree = filtered.root_tree\n    return tree.get(account_name).serialise(\n        conversion, self.ledger.prices, filtered.end_date\n    )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.interval_totals","title":"<code>interval_totals(filtered, interval, accounts, conversion, *, invert=False)</code>","text":"<p>Render totals for account (or accounts) in the intervals.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>An interval.</p> required <code>accounts</code> <code>str | tuple[str, ...]</code> <p>A single account (str) or a tuple of accounts.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <code>invert</code> <code>bool</code> <p>invert all numbers.</p> <code>False</code> <p>Yields:</p> Type Description <code>Iterable[DateAndBalanceWithBudget]</code> <p>The balances and budgets for the intervals.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef interval_totals(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    accounts: str | tuple[str, ...],\n    conversion: str | Conversion,\n    *,\n    invert: bool = False,\n) -&gt; Iterable[DateAndBalanceWithBudget]:\n    \"\"\"Render totals for account (or accounts) in the intervals.\n\n    Args:\n        filtered: The filtered ledger.\n        interval: An interval.\n        accounts: A single account (str) or a tuple of accounts.\n        conversion: The conversion to use.\n        invert: invert all numbers.\n\n    Yields:\n        The balances and budgets for the intervals.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    prices = self.ledger.prices\n\n    # limit the bar charts to 100 intervals\n    intervals = filtered.interval_ranges(interval)[-100:]\n\n    for date_range in intervals:\n        inventory = CounterInventory()\n        entries = slice_entry_dates(\n            filtered.entries, date_range.begin, date_range.end\n        )\n        account_inventories: dict[str, CounterInventory] = defaultdict(\n            CounterInventory,\n        )\n        for entry in entries:\n            for posting in getattr(entry, \"postings\", []):\n                if posting.account.startswith(accounts):\n                    account_inventories[posting.account].add_position(\n                        posting,\n                    )\n                    inventory.add_position(posting)\n        balance = conv.apply(\n            inventory,\n            prices,\n            date_range.end_inclusive,\n        )\n        account_balances = {\n            account: conv.apply(\n                acct_value,\n                prices,\n                date_range.end_inclusive,\n            )\n            for account, acct_value in account_inventories.items()\n        }\n        budgets = (\n            self.ledger.budgets.calculate_children(\n                accounts,\n                date_range.begin,\n                date_range.end,\n            )\n            if isinstance(accounts, str)\n            else {}\n        )\n\n        if invert:\n            balance = -balance\n            budgets = {k: -v for k, v in budgets.items()}\n            account_balances = {k: -v for k, v in account_balances.items()}\n\n        yield DateAndBalanceWithBudget(\n            date_range.end_inclusive,\n            balance,\n            account_balances,\n            budgets,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.linechart","title":"<code>linechart(filtered, account_name, conversion)</code>","text":"<p>Get the balance of an account as a line chart.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>account_name</code> <code>str</code> <p>A string.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <p>Yields:</p> Type Description <code>Iterable[DateAndBalance]</code> <p>Dicts for all dates on which the balance of the given</p> <code>Iterable[DateAndBalance]</code> <p>account has changed containing the balance (in units) of the</p> <code>Iterable[DateAndBalance]</code> <p>account at that date.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef linechart(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: str | Conversion,\n) -&gt; Iterable[DateAndBalance]:\n    \"\"\"Get the balance of an account as a line chart.\n\n    Args:\n        filtered: The filtered ledger.\n        account_name: A string.\n        conversion: The conversion to use.\n\n    Yields:\n        Dicts for all dates on which the balance of the given\n        account has changed containing the balance (in units) of the\n        account at that date.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n\n    def _balances() -&gt; Iterable[tuple[date, CounterInventory]]:\n        last_date = None\n        running_balance = CounterInventory()\n        is_child_account = account_tester(account_name, with_children=True)\n\n        for entry in filtered.entries:\n            for posting in getattr(entry, \"postings\", []):\n                if is_child_account(posting.account):\n                    new_date = entry.date\n                    if last_date is not None and new_date &gt; last_date:\n                        yield (last_date, running_balance)\n                    running_balance.add_position(posting)\n                    last_date = new_date\n\n        if last_date is not None:\n            yield (last_date, running_balance)\n\n    # When the balance for a commodity just went to zero, it will be\n    # missing from the 'balance' so keep track of currencies that last had\n    # a balance.\n    last_currencies = None\n    prices = self.ledger.prices\n\n    for d, running_bal in _balances():\n        balance = conv.apply(running_bal, prices, d)\n        currencies = set(balance.keys())\n        if last_currencies:\n            for currency in last_currencies - currencies:\n                balance[currency] = ZERO\n        last_currencies = currencies\n        yield DateAndBalance(d, balance)\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.net_worth","title":"<code>net_worth(filtered, interval, conversion)</code>","text":"<p>Compute net worth.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>A string for the interval.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <p>Yields:</p> Type Description <code>Iterable[DateAndBalance]</code> <p>Dicts for all ends of the given interval containing the</p> <code>Iterable[DateAndBalance]</code> <p>net worth (Assets + Liabilities) separately converted to all</p> <code>Iterable[DateAndBalance]</code> <p>operating currencies.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef net_worth(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    conversion: str | Conversion,\n) -&gt; Iterable[DateAndBalance]:\n    \"\"\"Compute net worth.\n\n    Args:\n        filtered: The filtered ledger.\n        interval: A string for the interval.\n        conversion: The conversion to use.\n\n    Yields:\n        Dicts for all ends of the given interval containing the\n        net worth (Assets + Liabilities) separately converted to all\n        operating currencies.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    transactions = (\n        entry\n        for entry in filtered.entries\n        if (\n            isinstance(entry, Transaction)\n            and entry.flag != FLAG_UNREALIZED\n        )\n    )\n\n    types = (\n        self.ledger.options[\"name_assets\"],\n        self.ledger.options[\"name_liabilities\"],\n    )\n\n    txn = next(transactions, None)\n    inventory = CounterInventory()\n\n    prices = self.ledger.prices\n    for date_range in filtered.interval_ranges(interval):\n        while txn and txn.date &lt; date_range.end:\n            for posting in txn.postings:\n                if posting.account.startswith(types):\n                    inventory.add_position(posting)\n            txn = next(transactions, None)\n        yield DateAndBalance(\n            date_range.end_inclusive,\n            conv.apply(\n                inventory,\n                prices,\n                date_range.end_inclusive,\n            ),\n        )\n</code></pre>"},{"location":"api/#rustfava.core.charts.dumps","title":"<code>dumps(obj, **_kwargs)</code>","text":"<p>Dump as a JSON string.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def dumps(obj: Any, **_kwargs: Any) -&gt; str:\n    \"\"\"Dump as a JSON string.\"\"\"\n    return json.dumps(\n        obj, sort_keys=True, separators=(\",\", \":\"), default=_json_default\n    )\n</code></pre>"},{"location":"api/#rustfava.core.charts.loads","title":"<code>loads(s)</code>","text":"<p>Load a JSON string.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def loads(s: str | bytes) -&gt; Any:\n    \"\"\"Load a JSON string.\"\"\"\n    return json.loads(s)\n</code></pre>"},{"location":"api/#rustfava.core.commodities","title":"<code>commodities</code>","text":"<p>Attributes for auto-completion.</p>"},{"location":"api/#rustfava.core.commodities.CommoditiesModule","title":"<code>CommoditiesModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Details about the currencies and commodities.</p> Source code in <code>src/rustfava/core/commodities.py</code> <pre><code>class CommoditiesModule(FavaModule):\n    \"\"\"Details about the currencies and commodities.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.names: dict[str, str] = {}\n        self.precisions: dict[str, int] = {}\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.names = {}\n        self.precisions = {}\n        for commodity in self.ledger.all_entries_by_type.Commodity:\n            name = commodity.meta.get(\"name\")\n            if name:\n                self.names[commodity.currency] = str(name)\n            precision = commodity.meta.get(\"precision\")\n            if isinstance(precision, (str, int, Decimal)):\n                with suppress(ValueError):\n                    self.precisions[commodity.currency] = int(precision)\n\n    def name(self, commodity: str) -&gt; str:\n        \"\"\"Get the name of a commodity (or the commodity itself if not set).\"\"\"\n        return self.names.get(commodity, commodity)\n</code></pre>"},{"location":"api/#rustfava.core.commodities.CommoditiesModule.name","title":"<code>name(commodity)</code>","text":"<p>Get the name of a commodity (or the commodity itself if not set).</p> Source code in <code>src/rustfava/core/commodities.py</code> <pre><code>def name(self, commodity: str) -&gt; str:\n    \"\"\"Get the name of a commodity (or the commodity itself if not set).\"\"\"\n    return self.names.get(commodity, commodity)\n</code></pre>"},{"location":"api/#rustfava.core.conversion","title":"<code>conversion</code>","text":"<p>Commodity conversion helpers for Fava.</p> <p>All functions in this module will be automatically added as template filters.</p>"},{"location":"api/#rustfava.core.conversion.Conversion","title":"<code>Conversion</code>","text":"<p>               Bases: <code>ABC</code></p> <p>A conversion.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>class Conversion(ABC):\n    \"\"\"A conversion.\"\"\"\n\n    @abstractmethod\n    def apply(\n        self,\n        inventory: CounterInventory,\n        prices: RustfavaPriceMap,\n        date: datetime.date | None = None,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Apply the conversion to an inventory (CounterInventory).\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.conversion.Conversion.apply","title":"<code>apply(inventory, prices, date=None)</code>  <code>abstractmethod</code>","text":"<p>Apply the conversion to an inventory (CounterInventory).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>@abstractmethod\ndef apply(\n    self,\n    inventory: CounterInventory,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Apply the conversion to an inventory (CounterInventory).\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.conversion.get_cost","title":"<code>get_cost(pos)</code>","text":"<p>Return the total cost of a Position.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def get_cost(pos: Position) -&gt; Amount:\n    \"\"\"Return the total cost of a Position.\"\"\"\n    cost_ = pos.cost\n    return (\n        _Amount(cost_.number * pos.units.number, cost_.currency)\n        if cost_ is not None\n        else pos.units\n    )\n</code></pre>"},{"location":"api/#rustfava.core.conversion.get_market_value","title":"<code>get_market_value(pos, prices, date=None)</code>","text":"<p>Get the market value of a Position.</p> <p>This differs from the convert.get_value function in Beancount by returning the cost value if no price can be found.</p> <p>Parameters:</p> Name Type Description Default <code>pos</code> <code>Position</code> <p>A Position.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>A rustfavaPriceMap</p> required <code>date</code> <code>date | None</code> <p>A datetime.date instance to evaluate the value at, or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>Amount</code> <p>An Amount, with value converted or if the conversion failed just the</p> <code>Amount</code> <p>cost value (or the units if the position has no cost).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def get_market_value(\n    pos: Position,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; Amount:\n    \"\"\"Get the market value of a Position.\n\n    This differs from the convert.get_value function in Beancount by returning\n    the cost value if no price can be found.\n\n    Args:\n        pos: A Position.\n        prices: A rustfavaPriceMap\n        date: A datetime.date instance to evaluate the value at, or None.\n\n    Returns:\n        An Amount, with value converted or if the conversion failed just the\n        cost value (or the units if the position has no cost).\n    \"\"\"\n    units_ = pos.units\n    cost_ = pos.cost\n\n    if cost_ is not None:\n        value_currency = cost_.currency\n        base_quote = (units_.currency, value_currency)\n        price_number = prices.get_price(base_quote, date)\n        if price_number is not None:\n            return _Amount(\n                units_.number * price_number,\n                value_currency,\n            )\n        return _Amount(units_.number * cost_.number, value_currency)\n    return units_\n</code></pre>"},{"location":"api/#rustfava.core.conversion.convert_position","title":"<code>convert_position(pos, target_currency, prices, date=None)</code>","text":"<p>Get the value of a Position in a particular currency.</p> <p>Parameters:</p> Name Type Description Default <code>pos</code> <code>Position</code> <p>A Position.</p> required <code>target_currency</code> <code>str</code> <p>The target currency to convert to.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>A rustfavaPriceMap</p> required <code>date</code> <code>date | None</code> <p>A datetime.date instance to evaluate the value at, or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>Amount</code> <p>An Amount, with value converted or if the conversion failed just the</p> <code>Amount</code> <p>cost value (or the units if the position has no cost).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def convert_position(\n    pos: Position,\n    target_currency: str,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; Amount:\n    \"\"\"Get the value of a Position in a particular currency.\n\n    Args:\n        pos: A Position.\n        target_currency: The target currency to convert to.\n        prices: A rustfavaPriceMap\n        date: A datetime.date instance to evaluate the value at, or None.\n\n    Returns:\n        An Amount, with value converted or if the conversion failed just the\n        cost value (or the units if the position has no cost).\n    \"\"\"\n    units_ = pos.units\n\n    # try the direct conversion\n    base_quote = (units_.currency, target_currency)\n    price_number = prices.get_price(base_quote, date)\n    if price_number is not None:\n        return _Amount(units_.number * price_number, target_currency)\n\n    cost_ = pos.cost\n    if cost_ is not None:\n        cost_currency = cost_.currency\n        if cost_currency != target_currency:\n            base_quote1 = (units_.currency, cost_currency)\n            rate1 = prices.get_price(base_quote1, date)\n            if rate1 is not None:\n                base_quote2 = (cost_currency, target_currency)\n                rate2 = prices.get_price(base_quote2, date)\n                if rate2 is not None:\n                    return _Amount(\n                        units_.number * rate1 * rate2,\n                        target_currency,\n                    )\n    return units_\n</code></pre>"},{"location":"api/#rustfava.core.conversion.conversion_from_str","title":"<code>conversion_from_str(value)</code>","text":"<p>Parse a conversion string.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def conversion_from_str(value: str | Conversion) -&gt; Conversion:\n    \"\"\"Parse a conversion string.\"\"\"\n    if not isinstance(value, str):\n        return value\n    if value == \"at_cost\":\n        return AT_COST\n    if value == \"at_value\":\n        return AT_VALUE\n    if value == \"units\":\n        return UNITS\n\n    return _CurrencyConversion(value)\n</code></pre>"},{"location":"api/#rustfava.core.conversion.cost_or_value","title":"<code>cost_or_value(inventory, conversion, prices, date=None)</code>","text":"<p>Get the cost or value of an inventory.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def cost_or_value(\n    inventory: CounterInventory,\n    conversion: str | Conversion,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Get the cost or value of an inventory.\"\"\"\n    conversion = conversion_from_str(conversion)\n    return conversion.apply(inventory, prices, date)\n</code></pre>"},{"location":"api/#rustfava.core.documents","title":"<code>documents</code>","text":"<p>Document path related helpers.</p>"},{"location":"api/#rustfava.core.documents.NotADocumentsFolderError","title":"<code>NotADocumentsFolderError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Not a documents folder.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>class NotADocumentsFolderError(RustfavaAPIError):\n    \"\"\"Not a documents folder.\"\"\"\n\n    def __init__(self, folder: str) -&gt; None:\n        super().__init__(f\"Not a documents folder: {folder}.\")\n</code></pre>"},{"location":"api/#rustfava.core.documents.NotAValidAccountError","title":"<code>NotAValidAccountError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Not a valid account.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>class NotAValidAccountError(RustfavaAPIError):\n    \"\"\"Not a valid account.\"\"\"\n\n    def __init__(self, account: str) -&gt; None:\n        super().__init__(f\"Not a valid account: '{account}'\")\n</code></pre>"},{"location":"api/#rustfava.core.documents.is_document_or_import_file","title":"<code>is_document_or_import_file(filename, ledger)</code>","text":"<p>Check whether the filename is a document or in an import directory.</p> <p>This is a security validation function that prevents path traversal.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The filename to check.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>bool</code> <p>Whether this is one of the documents or a path in an import dir.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>def is_document_or_import_file(filename: str, ledger: RustfavaLedger) -&gt; bool:\n    \"\"\"Check whether the filename is a document or in an import directory.\n\n    This is a security validation function that prevents path traversal.\n\n    Args:\n        filename: The filename to check.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        Whether this is one of the documents or a path in an import dir.\n    \"\"\"\n    # Check if it's an exact match for a known document\n    if any(\n        filename == d.filename for d in ledger.all_entries_by_type.Document\n    ):\n        return True\n    # Check if resolved path is within an import directory (prevents path traversal)\n    file_path = Path(filename).resolve()\n    for import_dir in ledger.fava_options.import_dirs:\n        resolved_dir = ledger.join_path(import_dir).resolve()\n        if file_path.is_relative_to(resolved_dir):\n            return True\n    return False\n</code></pre>"},{"location":"api/#rustfava.core.documents.filepath_in_document_folder","title":"<code>filepath_in_document_folder(documents_folder, account, filename, ledger)</code>","text":"<p>File path for a document in the folder for an account.</p> <p>Parameters:</p> Name Type Description Default <code>documents_folder</code> <code>str</code> <p>The documents folder.</p> required <code>account</code> <code>str</code> <p>The account to choose the subfolder for.</p> required <code>filename</code> <code>str</code> <p>The filename of the document.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>Path</code> <p>The path that the document should be saved at.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>def filepath_in_document_folder(\n    documents_folder: str,\n    account: str,\n    filename: str,\n    ledger: RustfavaLedger,\n) -&gt; Path:\n    \"\"\"File path for a document in the folder for an account.\n\n    Args:\n        documents_folder: The documents folder.\n        account: The account to choose the subfolder for.\n        filename: The filename of the document.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        The path that the document should be saved at.\n    \"\"\"\n    if documents_folder not in ledger.options[\"documents\"]:\n        raise NotADocumentsFolderError(documents_folder)\n\n    if account not in ledger.attributes.accounts:\n        raise NotAValidAccountError(account)\n\n    filename = filename.replace(sep, \" \")\n    if altsep:  # pragma: no cover\n        filename = filename.replace(altsep, \" \")\n\n    return ledger.join_path(\n        documents_folder,\n        *account.split(\":\"),\n        filename,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.extensions","title":"<code>extensions</code>","text":"<p>Fava extensions.</p>"},{"location":"api/#rustfava.core.extensions.ExtensionDetails","title":"<code>ExtensionDetails</code>  <code>dataclass</code>","text":"<p>The information about an extension that is needed for the frontend.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>@dataclass\nclass ExtensionDetails:\n    \"\"\"The information about an extension that is needed for the frontend.\"\"\"\n\n    name: str\n    report_title: str | None\n    has_js_module: bool\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule","title":"<code>ExtensionModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Fava extensions.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>class ExtensionModule(FavaModule):\n    \"\"\"Fava extensions.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._instances: dict[str, RustfavaExtensionBase] = {}\n        self._loaded_extensions: set[type[RustfavaExtensionBase]] = set()\n        self.errors: list[RustfavaExtensionError] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.errors = []\n\n        custom_entries = self.ledger.all_entries_by_type.Custom\n\n        seen = set()\n        for entry in (e for e in custom_entries if e.type == \"fava-extension\"):\n            extension = entry.values[0].value\n            if extension in seen:  # pragma: no cover\n                self.errors.append(\n                    RustfavaExtensionError(\n                        entry.meta, f\"Duplicate extension '{extension}'\", entry\n                    )\n                )\n                continue\n\n            seen.add(extension)\n            extensions, errors = find_extensions(\n                Path(self.ledger.beancount_file_path).parent,\n                extension,\n            )\n            self.errors.extend(errors)\n\n            for cls in extensions:\n                ext_config = (\n                    entry.values[1].value if len(entry.values) &gt; 1 else None\n                )\n                if cls not in self._loaded_extensions:\n                    self._loaded_extensions.add(cls)\n                    try:\n                        ext = cls(self.ledger, ext_config)\n                        self._instances[ext.name] = ext\n                    except ExtensionConfigError as error:  # pragma: no cover\n                        self.errors.append(\n                            RustfavaExtensionError(entry.meta, str(error), entry)\n                        )\n\n    @property\n    def _exts(self) -&gt; Iterable[RustfavaExtensionBase]:\n        return self._instances.values()\n\n    @property\n    def extension_details(self) -&gt; Sequence[ExtensionDetails]:\n        \"\"\"Extension information to provide to the Frontend.\"\"\"\n        return [\n            ExtensionDetails(ext.name, ext.report_title, ext.has_js_module)\n            for ext in self._exts\n        ]\n\n    def get_extension(self, name: str) -&gt; RustfavaExtensionBase | None:\n        \"\"\"Get the extension with the given name.\"\"\"\n        return self._instances.get(name, None)\n\n    def after_load_file(self) -&gt; None:\n        \"\"\"Run all `after_load_file` hooks.\"\"\"\n        for ext in self._exts:\n            ext.after_load_file()\n\n    def before_request(self) -&gt; None:\n        \"\"\"Run all `before_request` hooks.\"\"\"\n        for ext in self._exts:\n            ext.before_request()\n\n    def after_entry_modified(self, entry: Directive, new_lines: str) -&gt; None:\n        \"\"\"Run all `after_entry_modified` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_entry_modified(entry, new_lines)\n\n    def after_insert_entry(self, entry: Directive) -&gt; None:\n        \"\"\"Run all `after_insert_entry` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_insert_entry(entry)\n\n    def after_delete_entry(self, entry: Directive) -&gt; None:\n        \"\"\"Run all `after_delete_entry` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_delete_entry(entry)\n\n    def after_insert_metadata(\n        self,\n        entry: Directive,\n        key: str,\n        value: str,\n    ) -&gt; None:\n        \"\"\"Run all `after_insert_metadata` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_insert_metadata(entry, key, value)\n\n    def after_write_source(self, path: str, source: str) -&gt; None:\n        \"\"\"Run all `after_write_source` hooks.\"\"\"\n        for ext in self._exts:\n            ext.after_write_source(path, source)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.extension_details","title":"<code>extension_details</code>  <code>property</code>","text":"<p>Extension information to provide to the Frontend.</p>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.get_extension","title":"<code>get_extension(name)</code>","text":"<p>Get the extension with the given name.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def get_extension(self, name: str) -&gt; RustfavaExtensionBase | None:\n    \"\"\"Get the extension with the given name.\"\"\"\n    return self._instances.get(name, None)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_load_file","title":"<code>after_load_file()</code>","text":"<p>Run all <code>after_load_file</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_load_file(self) -&gt; None:\n    \"\"\"Run all `after_load_file` hooks.\"\"\"\n    for ext in self._exts:\n        ext.after_load_file()\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.before_request","title":"<code>before_request()</code>","text":"<p>Run all <code>before_request</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def before_request(self) -&gt; None:\n    \"\"\"Run all `before_request` hooks.\"\"\"\n    for ext in self._exts:\n        ext.before_request()\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_entry_modified","title":"<code>after_entry_modified(entry, new_lines)</code>","text":"<p>Run all <code>after_entry_modified</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_entry_modified(self, entry: Directive, new_lines: str) -&gt; None:\n    \"\"\"Run all `after_entry_modified` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_entry_modified(entry, new_lines)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_insert_entry","title":"<code>after_insert_entry(entry)</code>","text":"<p>Run all <code>after_insert_entry</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_insert_entry(self, entry: Directive) -&gt; None:\n    \"\"\"Run all `after_insert_entry` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_insert_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_delete_entry","title":"<code>after_delete_entry(entry)</code>","text":"<p>Run all <code>after_delete_entry</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_delete_entry(self, entry: Directive) -&gt; None:\n    \"\"\"Run all `after_delete_entry` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_delete_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_insert_metadata","title":"<code>after_insert_metadata(entry, key, value)</code>","text":"<p>Run all <code>after_insert_metadata</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_insert_metadata(\n    self,\n    entry: Directive,\n    key: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Run all `after_insert_metadata` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_insert_metadata(entry, key, value)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_write_source","title":"<code>after_write_source(path, source)</code>","text":"<p>Run all <code>after_write_source</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_write_source(self, path: str, source: str) -&gt; None:\n    \"\"\"Run all `after_write_source` hooks.\"\"\"\n    for ext in self._exts:\n        ext.after_write_source(path, source)\n</code></pre>"},{"location":"api/#rustfava.core.fava_options","title":"<code>fava_options</code>","text":"<p>rustfava's options.</p> <p>Options for rustfava can be specified through Custom entries in the Beancount file. This module contains a list of possible options, the defaults and the code for parsing the options.</p>"},{"location":"api/#rustfava.core.fava_options.OptionError","title":"<code>OptionError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>An error for one of the rustfava options.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>class OptionError(BeancountError):\n    \"\"\"An error for one of the rustfava options.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.InsertEntryOption","title":"<code>InsertEntryOption</code>  <code>dataclass</code>","text":"<p>Insert option.</p> <p>An option that determines where entries for matching accounts should be inserted.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>@dataclass(frozen=True)\nclass InsertEntryOption:\n    \"\"\"Insert option.\n\n    An option that determines where entries for matching accounts should be\n    inserted.\n    \"\"\"\n\n    date: datetime.date\n    re: Pattern[str]\n    filename: str\n    lineno: int\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions","title":"<code>RustfavaOptions</code>  <code>dataclass</code>","text":"<p>Options for rustfava that can be set in the Beancount file.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>@dataclass\nclass RustfavaOptions:\n    \"\"\"Options for rustfava that can be set in the Beancount file.\"\"\"\n\n    account_journal_include_children: bool = True\n    auto_reload: bool = False\n    collapse_pattern: Sequence[Pattern[str]] = field(default_factory=list)\n    conversion_currencies: tuple[str, ...] = ()\n    currency_column: int = 61\n    default_file: str | None = None\n    default_page: str = \"income_statement/\"\n    fiscal_year_end: FiscalYearEnd = END_OF_YEAR\n    import_config: str | None = None\n    import_dirs: Sequence[str] = field(default_factory=list)\n    indent: int = 2\n    insert_entry: Sequence[InsertEntryOption] = field(default_factory=list)\n    invert_gains_losses_colors: bool = False\n    invert_income_liabilities_equity: bool = False\n    language: str | None = None\n    locale: str | None = None\n    show_accounts_with_zero_balance: bool = True\n    show_accounts_with_zero_transactions: bool = True\n    show_closed_accounts: bool = False\n    sidebar_show_queries: int = 5\n    unrealized: str = \"Unrealized\"\n    upcoming_events: int = 7\n    uptodate_indicator_grey_lookback_days: int = 60\n    use_external_editor: bool = False\n\n    def set_collapse_pattern(self, value: str) -&gt; None:\n        \"\"\"Set the collapse_pattern option.\"\"\"\n        try:\n            pattern = re.compile(value)\n        except re.error as err:\n            raise NotARegularExpressionError(value) from err\n        # It's typed as Sequence so that it's not externally mutated\n        self.collapse_pattern.append(pattern)  # type: ignore[attr-defined]\n\n    def set_default_file(self, value: str, filename: str) -&gt; None:\n        \"\"\"Set the default_file option.\"\"\"\n        self.default_file = (\n            str((Path(filename).parent / value).absolute())\n            if value\n            else filename\n        )\n\n    def set_fiscal_year_end(self, value: str) -&gt; None:\n        \"\"\"Set the fiscal_year_end option.\"\"\"\n        fye = parse_fye_string(value)\n        if fye is None:\n            raise InvalidFiscalYearEndOptionError(value)\n        self.fiscal_year_end = fye\n\n    def set_import_dirs(self, value: str) -&gt; None:\n        \"\"\"Add an import directory.\"\"\"\n        # It's typed as Sequence so that it's not externally mutated\n        self.import_dirs.append(value)  # type: ignore[attr-defined]\n\n    def set_insert_entry(\n        self, value: str, date: datetime.date, filename: str, lineno: int\n    ) -&gt; None:\n        \"\"\"Set the insert_entry option.\"\"\"\n        try:\n            pattern = re.compile(value)\n        except re.error as err:\n            raise NotARegularExpressionError(value) from err\n        opt = InsertEntryOption(date, pattern, filename, lineno)\n        # It's typed as Sequence so that it's not externally mutated\n        self.insert_entry.append(opt)  # type: ignore[attr-defined]\n\n    def set_language(self, value: str) -&gt; None:\n        \"\"\"Set the locale option.\"\"\"\n        try:\n            locale = Locale.parse(value)\n            if (\n                not locale.language == \"en\"\n                and get_translations(locale) is None\n            ):\n                raise UnsupportedLanguageOptionError(value)\n            self.language = value\n        except UnknownLocaleError as err:\n            raise UnknownLocaleOptionError(value) from err\n\n    def set_locale(self, value: str) -&gt; None:\n        \"\"\"Set the locale option.\"\"\"\n        try:\n            Locale.parse(value)\n            self.locale = value\n        except UnknownLocaleError as err:\n            raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_collapse_pattern","title":"<code>set_collapse_pattern(value)</code>","text":"<p>Set the collapse_pattern option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_collapse_pattern(self, value: str) -&gt; None:\n    \"\"\"Set the collapse_pattern option.\"\"\"\n    try:\n        pattern = re.compile(value)\n    except re.error as err:\n        raise NotARegularExpressionError(value) from err\n    # It's typed as Sequence so that it's not externally mutated\n    self.collapse_pattern.append(pattern)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_default_file","title":"<code>set_default_file(value, filename)</code>","text":"<p>Set the default_file option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_default_file(self, value: str, filename: str) -&gt; None:\n    \"\"\"Set the default_file option.\"\"\"\n    self.default_file = (\n        str((Path(filename).parent / value).absolute())\n        if value\n        else filename\n    )\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_fiscal_year_end","title":"<code>set_fiscal_year_end(value)</code>","text":"<p>Set the fiscal_year_end option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_fiscal_year_end(self, value: str) -&gt; None:\n    \"\"\"Set the fiscal_year_end option.\"\"\"\n    fye = parse_fye_string(value)\n    if fye is None:\n        raise InvalidFiscalYearEndOptionError(value)\n    self.fiscal_year_end = fye\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_import_dirs","title":"<code>set_import_dirs(value)</code>","text":"<p>Add an import directory.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_import_dirs(self, value: str) -&gt; None:\n    \"\"\"Add an import directory.\"\"\"\n    # It's typed as Sequence so that it's not externally mutated\n    self.import_dirs.append(value)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_insert_entry","title":"<code>set_insert_entry(value, date, filename, lineno)</code>","text":"<p>Set the insert_entry option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_insert_entry(\n    self, value: str, date: datetime.date, filename: str, lineno: int\n) -&gt; None:\n    \"\"\"Set the insert_entry option.\"\"\"\n    try:\n        pattern = re.compile(value)\n    except re.error as err:\n        raise NotARegularExpressionError(value) from err\n    opt = InsertEntryOption(date, pattern, filename, lineno)\n    # It's typed as Sequence so that it's not externally mutated\n    self.insert_entry.append(opt)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_language","title":"<code>set_language(value)</code>","text":"<p>Set the locale option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_language(self, value: str) -&gt; None:\n    \"\"\"Set the locale option.\"\"\"\n    try:\n        locale = Locale.parse(value)\n        if (\n            not locale.language == \"en\"\n            and get_translations(locale) is None\n        ):\n            raise UnsupportedLanguageOptionError(value)\n        self.language = value\n    except UnknownLocaleError as err:\n        raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_locale","title":"<code>set_locale(value)</code>","text":"<p>Set the locale option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_locale(self, value: str) -&gt; None:\n    \"\"\"Set the locale option.\"\"\"\n    try:\n        Locale.parse(value)\n        self.locale = value\n    except UnknownLocaleError as err:\n        raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.parse_option_custom_entry","title":"<code>parse_option_custom_entry(entry, options)</code>","text":"<p>Parse a single custom fava-option entry and set option accordingly.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def parse_option_custom_entry(  # noqa: PLR0912\n    entry: Custom,\n    options: RustfavaOptions,\n) -&gt; None:\n    \"\"\"Parse a single custom fava-option entry and set option accordingly.\"\"\"\n    key = str(entry.values[0].value).replace(\"-\", \"_\")\n    if key not in All_OPTS:\n        raise UnknownOptionError(key)\n\n    value = entry.values[1].value if len(entry.values) &gt; 1 else \"\"\n    if not isinstance(value, str):\n        raise NotAStringOptionError(key)\n    filename, lineno = get_position(entry)\n\n    if key == \"collapse_pattern\":\n        options.set_collapse_pattern(value)\n    elif key == \"default_file\":\n        options.set_default_file(value, filename)\n    elif key == \"fiscal_year_end\":\n        options.set_fiscal_year_end(value)\n    elif key == \"import_dirs\":\n        options.set_import_dirs(value)\n    elif key == \"insert_entry\":\n        options.set_insert_entry(value, entry.date, filename, lineno)\n    elif key == \"language\":\n        options.set_language(value)\n    elif key == \"locale\":\n        options.set_locale(value)\n    elif key in STR_OPTS:\n        setattr(options, key, value)\n    elif key in BOOL_OPTS:\n        setattr(options, key, value.lower() == \"true\")\n    elif key in INT_OPTS:\n        setattr(options, key, int(value))\n    else:  # key in TUPLE_OPTS\n        setattr(options, key, tuple(value.strip().split(\" \")))\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.parse_options","title":"<code>parse_options(custom_entries)</code>","text":"<p>Parse custom entries for rustfava options.</p> <p>The format for option entries is the following::</p> <pre><code>2016-04-01 custom \"fava-option\" \"[name]\" \"[value]\"\n</code></pre> <p>Parameters:</p> Name Type Description Default <code>custom_entries</code> <code>Sequence[Custom]</code> <p>A list of Custom entries.</p> required <p>Returns:</p> Type Description <code>RustfavaOptions</code> <p>A tuple (options, errors) where options is a dictionary of all options</p> <code>list[OptionError]</code> <p>to values, and errors contains possible parsing errors.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def parse_options(\n    custom_entries: Sequence[Custom],\n) -&gt; tuple[RustfavaOptions, list[OptionError]]:\n    \"\"\"Parse custom entries for rustfava options.\n\n    The format for option entries is the following::\n\n        2016-04-01 custom \"fava-option\" \"[name]\" \"[value]\"\n\n    Args:\n        custom_entries: A list of Custom entries.\n\n    Returns:\n        A tuple (options, errors) where options is a dictionary of all options\n        to values, and errors contains possible parsing errors.\n    \"\"\"\n    options = RustfavaOptions()\n    errors = []\n\n    for entry in (e for e in custom_entries if e.type == \"fava-option\"):\n        try:\n            if not entry.values:\n                raise MissingOptionError\n            parse_option_custom_entry(entry, options)\n        except (IndexError, TypeError, ValueError) as err:\n            msg = f\"Failed to parse fava-option entry: {err!s}\"\n            errors.append(OptionError(entry.meta, msg, entry))\n\n    return options, errors\n</code></pre>"},{"location":"api/#rustfava.core.file","title":"<code>file</code>","text":"<p>Reading/writing Beancount files.</p>"},{"location":"api/#rustfava.core.file.NonSourceFileError","title":"<code>NonSourceFileError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Trying to read a non-source file.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class NonSourceFileError(RustfavaAPIError):\n    \"\"\"Trying to read a non-source file.\"\"\"\n\n    def __init__(self, path: Path) -&gt; None:\n        super().__init__(f\"Trying to read a non-source file at '{path}'\")\n</code></pre>"},{"location":"api/#rustfava.core.file.ExternallyChangedError","title":"<code>ExternallyChangedError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The file changed externally.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class ExternallyChangedError(RustfavaAPIError):\n    \"\"\"The file changed externally.\"\"\"\n\n    def __init__(self, path: Path) -&gt; None:\n        super().__init__(f\"The file at '{path}' changed externally.\")\n</code></pre>"},{"location":"api/#rustfava.core.file.GeneratedEntryError","title":"<code>GeneratedEntryError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class GeneratedEntryError(RustfavaAPIError):\n    \"\"\"The entry is generated and cannot be edited.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"The entry is generated and cannot be edited.\")\n</code></pre>"},{"location":"api/#rustfava.core.file.InvalidUnicodeError","title":"<code>InvalidUnicodeError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The source file contains invalid unicode.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class InvalidUnicodeError(RustfavaAPIError):\n    \"\"\"The source file contains invalid unicode.\"\"\"\n\n    def __init__(self, reason: str) -&gt; None:\n        super().__init__(\n            f\"The source file contains invalid unicode: {reason}.\",\n        )\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule","title":"<code>FileModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Functions related to reading/writing to Beancount files.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class FileModule(FavaModule):\n    \"\"\"Functions related to reading/writing to Beancount files.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._lock = threading.Lock()\n\n    def get_source(self, path: Path) -&gt; tuple[str, str]:\n        \"\"\"Get source files.\n\n        Args:\n            path: The path of the file.\n\n        Returns:\n            A string with the file contents and the `sha256sum` of the file.\n\n        Raises:\n            NonSourceFileError: If the file is not one of the source files.\n            InvalidUnicodeError: If the file contains invalid unicode.\n        \"\"\"\n        if str(path) not in self.ledger.options[\"include\"]:\n            raise NonSourceFileError(path)\n\n        try:\n            source = path.read_text(\"utf-8\")\n        except UnicodeDecodeError as exc:\n            raise InvalidUnicodeError(str(exc)) from exc\n\n        return source, _sha256_str(source)\n\n    def set_source(self, path: Path, source: str, sha256sum: str) -&gt; str:\n        \"\"\"Write to source file.\n\n        Args:\n            path: The path of the file.\n            source: A string with the file contents.\n            sha256sum: Hash of the file.\n\n        Returns:\n            The `sha256sum` of the updated file.\n\n        Raises:\n            NonSourceFileError: If the file is not one of the source files.\n            InvalidUnicodeError: If the file contains invalid unicode.\n            ExternallyChangedError: If the file was changed externally.\n        \"\"\"\n        with self._lock:\n            _, original_sha256sum = self.get_source(path)\n            if original_sha256sum != sha256sum:\n                raise ExternallyChangedError(path)\n\n            newline = _file_newline_character(path)\n            with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n                file.write(source)\n            self.ledger.watcher.notify(path)\n\n            self.ledger.extensions.after_write_source(str(path), source)\n            self.ledger.load_file()\n\n            return _sha256_str(source)\n\n    def insert_metadata(\n        self,\n        entry_hash: str,\n        basekey: str,\n        value: str,\n    ) -&gt; None:\n        \"\"\"Insert metadata into a file at lineno.\n\n        Also, prevent duplicate keys.\n\n        Args:\n            entry_hash: Hash of an entry.\n            basekey: Key to insert metadata for.\n            value: Metadate value to insert.\n        \"\"\"\n        with self._lock:\n            self.ledger.changed()\n            entry = self.ledger.get_entry(entry_hash)\n            key = next_key(basekey, entry.meta)\n            indent = self.ledger.fava_options.indent\n            path, lineno = _get_position(entry)\n            insert_metadata_in_file(path, lineno, indent, key, value)\n            self.ledger.watcher.notify(path)\n            self.ledger.extensions.after_insert_metadata(entry, key, value)\n\n    def save_entry_slice(\n        self,\n        entry_hash: str,\n        source_slice: str,\n        sha256sum: str,\n    ) -&gt; str:\n        \"\"\"Save slice of the source file for an entry.\n\n        Args:\n            entry_hash: Hash of an entry.\n            source_slice: The lines that the entry should be replaced with.\n            sha256sum: The sha256sum of the current lines of the entry.\n\n        Returns:\n            The `sha256sum` of the new lines of the entry.\n\n        Raises:\n            RustfavaAPIError: If the entry is not found or the file changed.\n        \"\"\"\n        with self._lock:\n            entry = self.ledger.get_entry(entry_hash)\n            new_sha256sum = save_entry_slice(entry, source_slice, sha256sum)\n            self.ledger.watcher.notify(Path(get_position(entry)[0]))\n            self.ledger.extensions.after_entry_modified(entry, source_slice)\n            return new_sha256sum\n\n    def delete_entry_slice(self, entry_hash: str, sha256sum: str) -&gt; None:\n        \"\"\"Delete slice of the source file for an entry.\n\n        Args:\n            entry_hash: Hash of an entry.\n            sha256sum: The sha256sum of the current lines of the entry.\n\n        Raises:\n            RustfavaAPIError: If the entry is not found or the file changed.\n        \"\"\"\n        with self._lock:\n            entry = self.ledger.get_entry(entry_hash)\n            delete_entry_slice(entry, sha256sum)\n            self.ledger.watcher.notify(Path(get_position(entry)[0]))\n            self.ledger.extensions.after_delete_entry(entry)\n\n    def insert_entries(self, entries: Sequence[Directive]) -&gt; None:\n        \"\"\"Insert entries.\n\n        Args:\n            entries: A list of entries.\n        \"\"\"\n        with self._lock:\n            self.ledger.changed()\n            fava_options = self.ledger.fava_options\n            for entry in sorted(entries, key=_incomplete_sortkey):\n                path, updated_insert_options = insert_entry(\n                    entry,\n                    (\n                        self.ledger.fava_options.default_file\n                        or self.ledger.beancount_file_path\n                    ),\n                    insert_options=fava_options.insert_entry,\n                    currency_column=fava_options.currency_column,\n                    indent=fava_options.indent,\n                )\n                self.ledger.watcher.notify(path)\n                self.ledger.fava_options.insert_entry = updated_insert_options\n                self.ledger.extensions.after_insert_entry(entry)\n\n    def render_entries(self, entries: Sequence[Directive]) -&gt; Iterable[Markup]:\n        \"\"\"Return entries in Beancount format.\n\n        Only renders :class:`.Balance` and :class:`.Transaction`.\n\n        Args:\n            entries: A list of entries.\n\n        Yields:\n            The entries rendered in Beancount format.\n        \"\"\"\n        indent = self.ledger.fava_options.indent\n        for entry in entries:\n            if isinstance(entry, (Balance, Transaction)):\n                if (\n                    isinstance(entry, Transaction)\n                    and entry.flag in _EXCL_FLAGS\n                ):\n                    continue\n                try:\n                    yield Markup(get_entry_slice(entry)[0] + \"\\n\")  # noqa: S704\n                except (KeyError, FileNotFoundError):\n                    yield Markup(  # noqa: S704\n                        to_string(\n                            entry,\n                            self.ledger.fava_options.currency_column,\n                            indent,\n                        ),\n                    )\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.get_source","title":"<code>get_source(path)</code>","text":"<p>Get source files.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>Path</code> <p>The path of the file.</p> required <p>Returns:</p> Type Description <code>tuple[str, str]</code> <p>A string with the file contents and the <code>sha256sum</code> of the file.</p> <p>Raises:</p> Type Description <code>NonSourceFileError</code> <p>If the file is not one of the source files.</p> <code>InvalidUnicodeError</code> <p>If the file contains invalid unicode.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def get_source(self, path: Path) -&gt; tuple[str, str]:\n    \"\"\"Get source files.\n\n    Args:\n        path: The path of the file.\n\n    Returns:\n        A string with the file contents and the `sha256sum` of the file.\n\n    Raises:\n        NonSourceFileError: If the file is not one of the source files.\n        InvalidUnicodeError: If the file contains invalid unicode.\n    \"\"\"\n    if str(path) not in self.ledger.options[\"include\"]:\n        raise NonSourceFileError(path)\n\n    try:\n        source = path.read_text(\"utf-8\")\n    except UnicodeDecodeError as exc:\n        raise InvalidUnicodeError(str(exc)) from exc\n\n    return source, _sha256_str(source)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.set_source","title":"<code>set_source(path, source, sha256sum)</code>","text":"<p>Write to source file.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>Path</code> <p>The path of the file.</p> required <code>source</code> <code>str</code> <p>A string with the file contents.</p> required <code>sha256sum</code> <code>str</code> <p>Hash of the file.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the updated file.</p> <p>Raises:</p> Type Description <code>NonSourceFileError</code> <p>If the file is not one of the source files.</p> <code>InvalidUnicodeError</code> <p>If the file contains invalid unicode.</p> <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def set_source(self, path: Path, source: str, sha256sum: str) -&gt; str:\n    \"\"\"Write to source file.\n\n    Args:\n        path: The path of the file.\n        source: A string with the file contents.\n        sha256sum: Hash of the file.\n\n    Returns:\n        The `sha256sum` of the updated file.\n\n    Raises:\n        NonSourceFileError: If the file is not one of the source files.\n        InvalidUnicodeError: If the file contains invalid unicode.\n        ExternallyChangedError: If the file was changed externally.\n    \"\"\"\n    with self._lock:\n        _, original_sha256sum = self.get_source(path)\n        if original_sha256sum != sha256sum:\n            raise ExternallyChangedError(path)\n\n        newline = _file_newline_character(path)\n        with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n            file.write(source)\n        self.ledger.watcher.notify(path)\n\n        self.ledger.extensions.after_write_source(str(path), source)\n        self.ledger.load_file()\n\n        return _sha256_str(source)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.insert_metadata","title":"<code>insert_metadata(entry_hash, basekey, value)</code>","text":"<p>Insert metadata into a file at lineno.</p> <p>Also, prevent duplicate keys.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>basekey</code> <code>str</code> <p>Key to insert metadata for.</p> required <code>value</code> <code>str</code> <p>Metadate value to insert.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_metadata(\n    self,\n    entry_hash: str,\n    basekey: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Insert metadata into a file at lineno.\n\n    Also, prevent duplicate keys.\n\n    Args:\n        entry_hash: Hash of an entry.\n        basekey: Key to insert metadata for.\n        value: Metadate value to insert.\n    \"\"\"\n    with self._lock:\n        self.ledger.changed()\n        entry = self.ledger.get_entry(entry_hash)\n        key = next_key(basekey, entry.meta)\n        indent = self.ledger.fava_options.indent\n        path, lineno = _get_position(entry)\n        insert_metadata_in_file(path, lineno, indent, key, value)\n        self.ledger.watcher.notify(path)\n        self.ledger.extensions.after_insert_metadata(entry, key, value)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.save_entry_slice","title":"<code>save_entry_slice(entry_hash, source_slice, sha256sum)</code>","text":"<p>Save slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>source_slice</code> <code>str</code> <p>The lines that the entry should be replaced with.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the new lines of the entry.</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the entry is not found or the file changed.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def save_entry_slice(\n    self,\n    entry_hash: str,\n    source_slice: str,\n    sha256sum: str,\n) -&gt; str:\n    \"\"\"Save slice of the source file for an entry.\n\n    Args:\n        entry_hash: Hash of an entry.\n        source_slice: The lines that the entry should be replaced with.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Returns:\n        The `sha256sum` of the new lines of the entry.\n\n    Raises:\n        RustfavaAPIError: If the entry is not found or the file changed.\n    \"\"\"\n    with self._lock:\n        entry = self.ledger.get_entry(entry_hash)\n        new_sha256sum = save_entry_slice(entry, source_slice, sha256sum)\n        self.ledger.watcher.notify(Path(get_position(entry)[0]))\n        self.ledger.extensions.after_entry_modified(entry, source_slice)\n        return new_sha256sum\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.delete_entry_slice","title":"<code>delete_entry_slice(entry_hash, sha256sum)</code>","text":"<p>Delete slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the entry is not found or the file changed.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def delete_entry_slice(self, entry_hash: str, sha256sum: str) -&gt; None:\n    \"\"\"Delete slice of the source file for an entry.\n\n    Args:\n        entry_hash: Hash of an entry.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Raises:\n        RustfavaAPIError: If the entry is not found or the file changed.\n    \"\"\"\n    with self._lock:\n        entry = self.ledger.get_entry(entry_hash)\n        delete_entry_slice(entry, sha256sum)\n        self.ledger.watcher.notify(Path(get_position(entry)[0]))\n        self.ledger.extensions.after_delete_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.insert_entries","title":"<code>insert_entries(entries)</code>","text":"<p>Insert entries.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_entries(self, entries: Sequence[Directive]) -&gt; None:\n    \"\"\"Insert entries.\n\n    Args:\n        entries: A list of entries.\n    \"\"\"\n    with self._lock:\n        self.ledger.changed()\n        fava_options = self.ledger.fava_options\n        for entry in sorted(entries, key=_incomplete_sortkey):\n            path, updated_insert_options = insert_entry(\n                entry,\n                (\n                    self.ledger.fava_options.default_file\n                    or self.ledger.beancount_file_path\n                ),\n                insert_options=fava_options.insert_entry,\n                currency_column=fava_options.currency_column,\n                indent=fava_options.indent,\n            )\n            self.ledger.watcher.notify(path)\n            self.ledger.fava_options.insert_entry = updated_insert_options\n            self.ledger.extensions.after_insert_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.render_entries","title":"<code>render_entries(entries)</code>","text":"<p>Return entries in Beancount format.</p> <p>Only renders :class:<code>.Balance</code> and :class:<code>.Transaction</code>.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required <p>Yields:</p> Type Description <code>Iterable[Markup]</code> <p>The entries rendered in Beancount format.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def render_entries(self, entries: Sequence[Directive]) -&gt; Iterable[Markup]:\n    \"\"\"Return entries in Beancount format.\n\n    Only renders :class:`.Balance` and :class:`.Transaction`.\n\n    Args:\n        entries: A list of entries.\n\n    Yields:\n        The entries rendered in Beancount format.\n    \"\"\"\n    indent = self.ledger.fava_options.indent\n    for entry in entries:\n        if isinstance(entry, (Balance, Transaction)):\n            if (\n                isinstance(entry, Transaction)\n                and entry.flag in _EXCL_FLAGS\n            ):\n                continue\n            try:\n                yield Markup(get_entry_slice(entry)[0] + \"\\n\")  # noqa: S704\n            except (KeyError, FileNotFoundError):\n                yield Markup(  # noqa: S704\n                    to_string(\n                        entry,\n                        self.ledger.fava_options.currency_column,\n                        indent,\n                    ),\n                )\n</code></pre>"},{"location":"api/#rustfava.core.file.insert_metadata_in_file","title":"<code>insert_metadata_in_file(path, lineno, indent, key, value)</code>","text":"<p>Insert the specified metadata in the file below lineno.</p> <p>Takes the whitespace in front of the line that lineno into account.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_metadata_in_file(\n    path: Path,\n    lineno: int,\n    indent: int,\n    key: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Insert the specified metadata in the file below lineno.\n\n    Takes the whitespace in front of the line that lineno into account.\n    \"\"\"\n    with path.open(encoding=\"utf-8\") as file:\n        contents = file.readlines()\n\n    contents.insert(lineno, f'{\" \" * indent}{key}: \"{value}\"\\n')\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.write(\"\".join(contents))\n</code></pre>"},{"location":"api/#rustfava.core.file.find_entry_lines","title":"<code>find_entry_lines(lines, lineno)</code>","text":"<p>Lines of entry starting at lineno.</p> <p>Parameters:</p> Name Type Description Default <code>lines</code> <code>Sequence[str]</code> <p>A list of lines.</p> required <code>lineno</code> <code>int</code> <p>The 0-based line-index to start at.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def find_entry_lines(lines: Sequence[str], lineno: int) -&gt; Sequence[str]:\n    \"\"\"Lines of entry starting at lineno.\n\n    Args:\n        lines: A list of lines.\n        lineno: The 0-based line-index to start at.\n    \"\"\"\n    entry_lines = [lines[lineno]]\n    while True:\n        lineno += 1\n        try:\n            line = lines[lineno]\n        except IndexError:\n            return entry_lines\n        if not line.strip() or re.match(r\"\\S\", line[0]):\n            return entry_lines\n        entry_lines.append(line)\n</code></pre>"},{"location":"api/#rustfava.core.file.get_entry_slice","title":"<code>get_entry_slice(entry)</code>","text":"<p>Get slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>A string containing the lines of the entry and the <code>sha256sum</code> of</p> <code>str</code> <p>these lines.</p> <p>Raises:</p> Type Description <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def get_entry_slice(entry: Directive) -&gt; tuple[str, str]:\n    \"\"\"Get slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n\n    Returns:\n        A string containing the lines of the entry and the `sha256sum` of\n        these lines.\n\n    Raises:\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    entry_lines = find_entry_lines(lines, lineno - 1)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n\n    return entry_source, _sha256_str(entry_source)\n</code></pre>"},{"location":"api/#rustfava.core.file.save_entry_slice","title":"<code>save_entry_slice(entry, source_slice, sha256sum)</code>","text":"<p>Save slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>source_slice</code> <code>str</code> <p>The lines that the entry should be replaced with.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the new lines of the entry.</p> <p>Raises:</p> Type Description <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def save_entry_slice(\n    entry: Directive,\n    source_slice: str,\n    sha256sum: str,\n) -&gt; str:\n    \"\"\"Save slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n        source_slice: The lines that the entry should be replaced with.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Returns:\n        The `sha256sum` of the new lines of the entry.\n\n    Raises:\n        ExternallyChangedError: If the file was changed externally.\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    first_entry_line = lineno - 1\n    entry_lines = find_entry_lines(lines, first_entry_line)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n    if _sha256_str(entry_source) != sha256sum:\n        raise ExternallyChangedError(path)\n\n    lines = [\n        *lines[:first_entry_line],\n        source_slice + \"\\n\",\n        *lines[first_entry_line + len(entry_lines) :],\n    ]\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(lines)\n\n    return _sha256_str(source_slice)\n</code></pre>"},{"location":"api/#rustfava.core.file.delete_entry_slice","title":"<code>delete_entry_slice(entry, sha256sum)</code>","text":"<p>Delete slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Raises:</p> Type Description <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def delete_entry_slice(\n    entry: Directive,\n    sha256sum: str,\n) -&gt; None:\n    \"\"\"Delete slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Raises:\n        ExternallyChangedError: If the file was changed externally.\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    first_entry_line = lineno - 1\n    entry_lines = find_entry_lines(lines, first_entry_line)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n    if _sha256_str(entry_source) != sha256sum:\n        raise ExternallyChangedError(path)\n\n    # Also delete the whitespace following this entry\n    last_entry_line = first_entry_line + len(entry_lines)\n    while True:\n        try:\n            line = lines[last_entry_line]\n        except IndexError:\n            break\n        if line.strip():  # pragma: no cover\n            break\n        last_entry_line += 1  # pragma: no cover\n    lines = lines[:first_entry_line] + lines[last_entry_line:]\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(lines)\n</code></pre>"},{"location":"api/#rustfava.core.file.insert_entry","title":"<code>insert_entry(entry, default_filename, insert_options, currency_column, indent)</code>","text":"<p>Insert an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>default_filename</code> <code>str</code> <p>The default file to insert into if no option matches.</p> required <code>insert_options</code> <code>Sequence[InsertEntryOption]</code> <p>Insert options.</p> required <code>currency_column</code> <code>int</code> <p>The column to align currencies at.</p> required <code>indent</code> <code>int</code> <p>Number of indent spaces.</p> required <p>Returns:</p> Type Description <code>tuple[Path, Sequence[InsertEntryOption]]</code> <p>A changed path and list of updated insert options.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_entry(\n    entry: Directive,\n    default_filename: str,\n    insert_options: Sequence[InsertEntryOption],\n    currency_column: int,\n    indent: int,\n) -&gt; tuple[Path, Sequence[InsertEntryOption]]:\n    \"\"\"Insert an entry.\n\n    Args:\n        entry: An entry.\n        default_filename: The default file to insert into if no option matches.\n        insert_options: Insert options.\n        currency_column: The column to align currencies at.\n        indent: Number of indent spaces.\n\n    Returns:\n        A changed path and list of updated insert options.\n    \"\"\"\n    filename, lineno = find_insert_position(\n        entry,\n        insert_options,\n        default_filename,\n    )\n    content = to_string(entry, currency_column, indent)\n\n    path = Path(filename)\n    with path.open(encoding=\"utf-8\") as file:\n        contents = file.readlines()\n\n    if lineno is None:\n        # Appending\n        contents += \"\\n\" + content\n    else:\n        contents.insert(lineno, content + \"\\n\")\n\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(contents)\n\n    if lineno is None:\n        return (path, insert_options)\n\n    added_lines = content.count(\"\\n\") + 1\n    return (\n        path,\n        [\n            (\n                replace(option, lineno=option.lineno + added_lines)\n                if option.filename == filename and option.lineno &gt; lineno\n                else option\n            )\n            for option in insert_options\n        ],\n    )\n</code></pre>"},{"location":"api/#rustfava.core.file.find_insert_position","title":"<code>find_insert_position(entry, insert_options, default_filename)</code>","text":"<p>Find insert position for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>insert_options</code> <code>Sequence[InsertEntryOption]</code> <p>A list of InsertOption.</p> required <code>default_filename</code> <code>str</code> <p>The default file to insert into if no option matches.</p> required <p>Returns:</p> Type Description <code>tuple[str, int | None]</code> <p>A tuple of the filename and the line number.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def find_insert_position(\n    entry: Directive,\n    insert_options: Sequence[InsertEntryOption],\n    default_filename: str,\n) -&gt; tuple[str, int | None]:\n    \"\"\"Find insert position for an entry.\n\n    Args:\n        entry: An entry.\n        insert_options: A list of InsertOption.\n        default_filename: The default file to insert into if no option matches.\n\n    Returns:\n        A tuple of the filename and the line number.\n    \"\"\"\n    # Get the list of accounts that should be considered for the entry.\n    # For transactions, we want the reversed list of posting accounts.\n    accounts = get_entry_accounts(entry)\n\n    # Make no assumptions about the order of insert_options entries and instead\n    # sort them ourselves (by descending dates)\n    insert_options = sorted(\n        insert_options,\n        key=attrgetter(\"date\"),\n        reverse=True,\n    )\n\n    for account in accounts:\n        for insert_option in insert_options:\n            # Only consider InsertOptions before the entry date.\n            if insert_option.date &gt;= entry.date:\n                continue\n            if insert_option.re.match(account):\n                return (insert_option.filename, insert_option.lineno - 1)\n\n    return (default_filename, None)\n</code></pre>"},{"location":"api/#rustfava.core.filters","title":"<code>filters</code>","text":"<p>Entry filters.</p>"},{"location":"api/#rustfava.core.filters.FilterError","title":"<code>FilterError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Filter exception.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterError(RustfavaAPIError):\n    \"\"\"Filter exception.\"\"\"\n\n    def __init__(self, filter_type: str, message: str) -&gt; None:\n        super().__init__(message)\n        self.filter_type = filter_type\n\n    def __str__(self) -&gt; str:\n        return self.message\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterParseError","title":"<code>FilterParseError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Filter parse error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterParseError(FilterError):\n    \"\"\"Filter parse error.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"filter\", \"Failed to parse filter: \")\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterIllegalCharError","title":"<code>FilterIllegalCharError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Filter illegal char error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterIllegalCharError(FilterError):\n    \"\"\"Filter illegal char error.\"\"\"\n\n    def __init__(self, char: str) -&gt; None:\n        super().__init__(\n            \"filter\",\n            f'Illegal character \"{char}\" in filter.',\n        )\n</code></pre>"},{"location":"api/#rustfava.core.filters.TimeFilterParseError","title":"<code>TimeFilterParseError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Time filter parse error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class TimeFilterParseError(FilterError):\n    \"\"\"Time filter parse error.\"\"\"\n\n    def __init__(self, value: str) -&gt; None:\n        super().__init__(\"time\", f\"Failed to parse date: {value}\")\n</code></pre>"},{"location":"api/#rustfava.core.filters.Token","title":"<code>Token</code>","text":"<p>A token having a certain type and value.</p> <p>The lexer attribute only exists since PLY writes to it in case of a parser error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class Token:\n    \"\"\"A token having a certain type and value.\n\n    The lexer attribute only exists since PLY writes to it in case of a parser\n    error.\n    \"\"\"\n\n    __slots__ = (\"lexer\", \"type\", \"value\")\n\n    def __init__(self, type_: str, value: str) -&gt; None:\n        self.type = type_\n        self.value = value\n\n    def __repr__(self) -&gt; str:  # pragma: no cover\n        return f\"Token({self.type}, {self.value})\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxLexer","title":"<code>FilterSyntaxLexer</code>","text":"<p>Lexer for Fava's filter syntax.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterSyntaxLexer:\n    \"\"\"Lexer for Fava's filter syntax.\"\"\"\n\n    tokens = (\n        \"ANY\",\n        \"ALL\",\n        \"CMP_OP\",\n        \"EQ_OP\",\n        \"KEY\",\n        \"LINK\",\n        \"NUMBER\",\n        \"STRING\",\n        \"TAG\",\n    )\n\n    RULES = (\n        (\"LINK\", r\"\\^[A-Za-z0-9\\-_/.]+\"),\n        (\"TAG\", r\"\\#[A-Za-z0-9\\-_/.]+\"),\n        (\"ALL\", r\"all\\(\"),\n        (\"ANY\", r\"any\\(\"),\n        (\"KEY\", r\"[a-z][a-zA-Z0-9\\-_]+(?=\\s*(:|=|&gt;=|&lt;=|&lt;|&gt;))\"),\n        (\"EQ_OP\", r\":\"),\n        (\"CMP_OP\", r\"(=|&gt;=|&lt;=|&lt;|&gt;)\"),\n        (\"NUMBER\", r\"\\d*\\.?\\d+\"),\n        (\"STRING\", r\"\"\"\\w[-\\w]*|\"[^\"]*\"|'[^']*'\"\"\"),\n    )\n\n    regex = re.compile(\n        \"|\".join((f\"(?P&lt;{name}&gt;{rule})\" for name, rule in RULES)),\n    )\n\n    def LINK(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value[1:]\n\n    def TAG(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value[1:]\n\n    def KEY(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def ALL(self, token: str, _: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, token\n\n    def ANY(self, token: str, _: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, token\n\n    def EQ_OP(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def CMP_OP(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def NUMBER(self, token: str, value: str) -&gt; tuple[str, Decimal]:  # noqa: N802\n        return token, Decimal(value)\n\n    def STRING(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        if value[0] in {'\"', \"'\"}:\n            return token, value[1:-1]\n        return token, value\n\n    def lex(self, data: str) -&gt; Iterable[Token]:\n        \"\"\"A generator yielding all tokens in a given line.\n\n        Arguments:\n            data: A string, the line to lex.\n\n        Yields:\n            All Tokens in the line.\n        \"\"\"\n        ignore = \" \\t\"\n        literals = \"-,()\"\n        regex = self.regex.match\n\n        pos = 0\n        length = len(data)\n        while pos &lt; length:\n            char = data[pos]\n            if char in ignore:\n                pos += 1\n                continue\n            match = regex(data, pos)\n            if match:\n                value = match.group()\n                pos += len(value)\n                token = match.lastgroup\n                if token is None:  # pragma: no cover\n                    msg = \"Internal Error\"\n                    raise ValueError(msg)\n                func: Callable[[str, str], tuple[str, str]] = getattr(\n                    self,\n                    token,\n                )\n                ret = func(token, value)\n                yield Token(*ret)\n            elif char in literals:\n                yield Token(char, char)\n                pos += 1\n            else:\n                raise FilterIllegalCharError(char)\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxLexer.lex","title":"<code>lex(data)</code>","text":"<p>A generator yielding all tokens in a given line.</p> <p>Parameters:</p> Name Type Description Default <code>data</code> <code>str</code> <p>A string, the line to lex.</p> required <p>Yields:</p> Type Description <code>Iterable[Token]</code> <p>All Tokens in the line.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def lex(self, data: str) -&gt; Iterable[Token]:\n    \"\"\"A generator yielding all tokens in a given line.\n\n    Arguments:\n        data: A string, the line to lex.\n\n    Yields:\n        All Tokens in the line.\n    \"\"\"\n    ignore = \" \\t\"\n    literals = \"-,()\"\n    regex = self.regex.match\n\n    pos = 0\n    length = len(data)\n    while pos &lt; length:\n        char = data[pos]\n        if char in ignore:\n            pos += 1\n            continue\n        match = regex(data, pos)\n        if match:\n            value = match.group()\n            pos += len(value)\n            token = match.lastgroup\n            if token is None:  # pragma: no cover\n                msg = \"Internal Error\"\n                raise ValueError(msg)\n            func: Callable[[str, str], tuple[str, str]] = getattr(\n                self,\n                token,\n            )\n            ret = func(token, value)\n            yield Token(*ret)\n        elif char in literals:\n            yield Token(char, char)\n            pos += 1\n        else:\n            raise FilterIllegalCharError(char)\n</code></pre>"},{"location":"api/#rustfava.core.filters.Match","title":"<code>Match</code>","text":"<p>Match a string.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class Match:\n    \"\"\"Match a string.\"\"\"\n\n    __slots__ = (\"match\",)\n\n    match: Callable[[str], bool]\n\n    def __init__(self, search: str) -&gt; None:\n        try:\n            match = re.compile(search, re.IGNORECASE).search\n            self.match = lambda s: bool(match(s))\n        except re.error:\n            self.match = lambda s: s == search\n\n    def __call__(self, obj: Any) -&gt; bool:\n        return self.match(str(obj))\n</code></pre>"},{"location":"api/#rustfava.core.filters.MatchAmount","title":"<code>MatchAmount</code>","text":"<p>Matches an amount.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class MatchAmount:\n    \"\"\"Matches an amount.\"\"\"\n\n    __slots__ = (\"match\",)\n\n    match: Callable[[Decimal], bool]\n\n    def __init__(self, op: str, value: Decimal) -&gt; None:\n        if op == \"=\":\n            self.match = lambda x: x == value\n        elif op == \"&gt;=\":\n            self.match = lambda x: x &gt;= value\n        elif op == \"&lt;=\":\n            self.match = lambda x: x &lt;= value\n        elif op == \"&gt;\":\n            self.match = lambda x: x &gt; value\n        else:  # op == \"&lt;\":\n            self.match = lambda x: x &lt; value\n\n    def __call__(self, obj: Any) -&gt; bool:\n        # Compare to the absolute value to simplify this filter.\n        number = getattr(obj, \"number\", None)\n        return self.match(abs(number)) if number is not None else False\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser","title":"<code>FilterSyntaxParser</code>","text":"Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterSyntaxParser:\n    precedence = ((\"left\", \"AND\"), (\"right\", \"UMINUS\"))\n    tokens = FilterSyntaxLexer.tokens\n\n    def p_error(self, _: Any) -&gt; None:\n        raise FilterParseError\n\n    def p_filter(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        filter : expr\n        \"\"\"\n        p[0] = p[1]\n\n    def p_expr(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : simple_expr\n        \"\"\"\n        p[0] = p[1]\n\n    def p_expr_all(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : ALL expr ')'\n        \"\"\"\n        expr = p[2]\n\n        def _match_postings(entry: Directive) -&gt; bool:\n            return all(\n                expr(posting) for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _match_postings\n\n    def p_expr_any(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : ANY expr ')'\n        \"\"\"\n        expr = p[2]\n\n        def _match_postings(entry: Directive) -&gt; bool:\n            return any(\n                expr(posting) for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _match_postings\n\n    def p_expr_parentheses(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : '(' expr ')'\n        \"\"\"\n        p[0] = p[2]\n\n    def p_expr_and(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : expr expr %prec AND\n        \"\"\"\n        left, right = p[1], p[2]\n\n        def _and(entry: Directive) -&gt; bool:\n            return left(entry) and right(entry)  # type: ignore[no-any-return]\n\n        p[0] = _and\n\n    def p_expr_or(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : expr ',' expr\n        \"\"\"\n        left, right = p[1], p[3]\n\n        def _or(entry: Directive) -&gt; bool:\n            return left(entry) or right(entry)  # type: ignore[no-any-return]\n\n        p[0] = _or\n\n    def p_expr_negated(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : '-' expr %prec UMINUS\n        \"\"\"\n        func = p[2]\n\n        def _neg(entry: Directive) -&gt; bool:\n            return not func(entry)\n\n        p[0] = _neg\n\n    def p_simple_expr_TAG(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : TAG\n        \"\"\"\n        tag = p[1]\n\n        def _tag(entry: Directive) -&gt; bool:\n            tags = getattr(entry, \"tags\", None)\n            return (tag in tags) if tags is not None else False\n\n        p[0] = _tag\n\n    def p_simple_expr_LINK(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : LINK\n        \"\"\"\n        link = p[1]\n\n        def _link(entry: Directive) -&gt; bool:\n            links = getattr(entry, \"links\", None)\n            return (link in links) if links is not None else False\n\n        p[0] = _link\n\n    def p_simple_expr_STRING(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : STRING\n        \"\"\"\n        string = p[1]\n        match = Match(string)\n\n        def _string(entry: Directive) -&gt; bool:\n            for name in (\"narration\", \"payee\", \"comment\"):\n                value = getattr(entry, name, \"\")\n                if value and match(value):\n                    return True\n            return False\n\n        p[0] = _string\n\n    def p_simple_expr_key(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        simple_expr : KEY EQ_OP STRING\n                    | KEY CMP_OP NUMBER\n        \"\"\"\n        key, op, value = p[1], p[2], p[3]\n        match: Match | MatchAmount = (\n            Match(value) if op == \":\" else MatchAmount(op, value)\n        )\n\n        def _key(entry: Directive) -&gt; bool:\n            if hasattr(entry, key):\n                return match(getattr(entry, key) or \"\")\n            if entry.meta is not None and key in entry.meta:\n                return match(entry.meta.get(key))\n            return False\n\n        p[0] = _key\n\n    def p_simple_expr_units(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        simple_expr : CMP_OP NUMBER\n        \"\"\"\n        op, value = p[1], p[2]\n        match = MatchAmount(op, value)\n\n        def _range(entry: Directive) -&gt; bool:\n            return any(\n                match(posting.units)\n                for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _range\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_filter","title":"<code>p_filter(p)</code>","text":"<p>filter : expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_filter(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    filter : expr\n    \"\"\"\n    p[0] = p[1]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr","title":"<code>p_expr(p)</code>","text":"<p>expr : simple_expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : simple_expr\n    \"\"\"\n    p[0] = p[1]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_all","title":"<code>p_expr_all(p)</code>","text":"<p>expr : ALL expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_all(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : ALL expr ')'\n    \"\"\"\n    expr = p[2]\n\n    def _match_postings(entry: Directive) -&gt; bool:\n        return all(\n            expr(posting) for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _match_postings\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_any","title":"<code>p_expr_any(p)</code>","text":"<p>expr : ANY expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_any(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : ANY expr ')'\n    \"\"\"\n    expr = p[2]\n\n    def _match_postings(entry: Directive) -&gt; bool:\n        return any(\n            expr(posting) for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _match_postings\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_parentheses","title":"<code>p_expr_parentheses(p)</code>","text":"<p>expr : '(' expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_parentheses(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : '(' expr ')'\n    \"\"\"\n    p[0] = p[2]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_and","title":"<code>p_expr_and(p)</code>","text":"<p>expr : expr expr %prec AND</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_and(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : expr expr %prec AND\n    \"\"\"\n    left, right = p[1], p[2]\n\n    def _and(entry: Directive) -&gt; bool:\n        return left(entry) and right(entry)  # type: ignore[no-any-return]\n\n    p[0] = _and\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_or","title":"<code>p_expr_or(p)</code>","text":"<p>expr : expr ',' expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_or(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : expr ',' expr\n    \"\"\"\n    left, right = p[1], p[3]\n\n    def _or(entry: Directive) -&gt; bool:\n        return left(entry) or right(entry)  # type: ignore[no-any-return]\n\n    p[0] = _or\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_negated","title":"<code>p_expr_negated(p)</code>","text":"<p>expr : '-' expr %prec UMINUS</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_negated(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : '-' expr %prec UMINUS\n    \"\"\"\n    func = p[2]\n\n    def _neg(entry: Directive) -&gt; bool:\n        return not func(entry)\n\n    p[0] = _neg\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_TAG","title":"<code>p_simple_expr_TAG(p)</code>","text":"<p>simple_expr : TAG</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_TAG(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : TAG\n    \"\"\"\n    tag = p[1]\n\n    def _tag(entry: Directive) -&gt; bool:\n        tags = getattr(entry, \"tags\", None)\n        return (tag in tags) if tags is not None else False\n\n    p[0] = _tag\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_LINK","title":"<code>p_simple_expr_LINK(p)</code>","text":"<p>simple_expr : LINK</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_LINK(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : LINK\n    \"\"\"\n    link = p[1]\n\n    def _link(entry: Directive) -&gt; bool:\n        links = getattr(entry, \"links\", None)\n        return (link in links) if links is not None else False\n\n    p[0] = _link\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_STRING","title":"<code>p_simple_expr_STRING(p)</code>","text":"<p>simple_expr : STRING</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_STRING(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : STRING\n    \"\"\"\n    string = p[1]\n    match = Match(string)\n\n    def _string(entry: Directive) -&gt; bool:\n        for name in (\"narration\", \"payee\", \"comment\"):\n            value = getattr(entry, name, \"\")\n            if value and match(value):\n                return True\n        return False\n\n    p[0] = _string\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_key","title":"<code>p_simple_expr_key(p)</code>","text":"KEY EQ_OP STRING <p>| KEY CMP_OP NUMBER</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_key(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    simple_expr : KEY EQ_OP STRING\n                | KEY CMP_OP NUMBER\n    \"\"\"\n    key, op, value = p[1], p[2], p[3]\n    match: Match | MatchAmount = (\n        Match(value) if op == \":\" else MatchAmount(op, value)\n    )\n\n    def _key(entry: Directive) -&gt; bool:\n        if hasattr(entry, key):\n            return match(getattr(entry, key) or \"\")\n        if entry.meta is not None and key in entry.meta:\n            return match(entry.meta.get(key))\n        return False\n\n    p[0] = _key\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_units","title":"<code>p_simple_expr_units(p)</code>","text":"<p>simple_expr : CMP_OP NUMBER</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_units(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    simple_expr : CMP_OP NUMBER\n    \"\"\"\n    op, value = p[1], p[2]\n    match = MatchAmount(op, value)\n\n    def _range(entry: Directive) -&gt; bool:\n        return any(\n            match(posting.units)\n            for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _range\n</code></pre>"},{"location":"api/#rustfava.core.filters.EntryFilter","title":"<code>EntryFilter</code>","text":"<p>               Bases: <code>ABC</code></p> <p>Filters a list of entries.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class EntryFilter(ABC):\n    \"\"\"Filters a list of entries.\"\"\"\n\n    @abstractmethod\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        \"\"\"Filter a list of directives.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.EntryFilter.apply","title":"<code>apply(entries)</code>  <code>abstractmethod</code>","text":"<p>Filter a list of directives.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>@abstractmethod\ndef apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n    \"\"\"Filter a list of directives.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.TimeFilter","title":"<code>TimeFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by dates.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class TimeFilter(EntryFilter):\n    \"\"\"Filter by dates.\"\"\"\n\n    __slots__ = (\"date_range\",)\n\n    def __init__(\n        self,\n        options: BeancountOptions,\n        fava_options: RustfavaOptions,\n        value: str,\n    ) -&gt; None:\n        del options  # unused\n        begin, end = parse_date(value, fava_options.fiscal_year_end)\n        if not begin or not end:\n            raise TimeFilterParseError(value)\n        self.date_range = DateRange(begin, end)\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        from rustfava.rustledger.engine import RustledgerEngine\n        from rustfava.rustledger.types import directives_from_json\n        from rustfava.rustledger.types import directives_to_json\n\n        # Use native rustledger clamp_entries\n        engine = RustledgerEngine.get_instance()\n        entries_json = directives_to_json(list(entries))\n        result = engine.clamp_entries(\n            entries_json,\n            str(self.date_range.begin),\n            str(self.date_range.end),\n        )\n        return directives_from_json(result.get(\"entries\", []))\n</code></pre>"},{"location":"api/#rustfava.core.filters.AdvancedFilter","title":"<code>AdvancedFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by tags and links and keys.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class AdvancedFilter(EntryFilter):\n    \"\"\"Filter by tags and links and keys.\"\"\"\n\n    __slots__ = (\"_include\",)\n\n    def __init__(self, value: str) -&gt; None:\n        try:\n            tokens = LEXER.lex(value)\n            self._include = PARSE(\n                lexer=\"NONE\",\n                tokenfunc=lambda toks=tokens: next(toks, None),  # ty:ignore[invalid-argument-type]\n            )\n        except FilterError as exception:\n            exception.message += value\n            raise\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        include = self._include\n        return [entry for entry in entries if include(entry)]\n</code></pre>"},{"location":"api/#rustfava.core.filters.AccountFilter","title":"<code>AccountFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by account.</p> <p>The filter string can either be a regular expression or a parent account.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class AccountFilter(EntryFilter):\n    \"\"\"Filter by account.\n\n    The filter string can either be a regular expression or a parent account.\n    \"\"\"\n\n    __slots__ = (\"_match\", \"_value\")\n\n    def __init__(self, value: str) -&gt; None:\n        self._value = value\n        self._match = Match(value)\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        value = self._value\n        if not value:\n            return entries\n        match = self._match\n        return [\n            entry\n            for entry in entries\n            if any(\n                _has_component(name, value) or match(name)\n                for name in get_entry_accounts(entry)\n            )\n        ]\n</code></pre>"},{"location":"api/#rustfava.core.group_entries","title":"<code>group_entries</code>","text":"<p>Entries grouped by type.</p>"},{"location":"api/#rustfava.core.group_entries.EntriesByType","title":"<code>EntriesByType</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>Entries grouped by type.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>class EntriesByType(NamedTuple):\n    \"\"\"Entries grouped by type.\"\"\"\n\n    Balance: Sequence[abc.Balance]\n    Close: Sequence[abc.Close]\n    Commodity: Sequence[abc.Commodity]\n    Custom: Sequence[abc.Custom]\n    Document: Sequence[abc.Document]\n    Event: Sequence[abc.Event]\n    Note: Sequence[abc.Note]\n    Open: Sequence[abc.Open]\n    Pad: Sequence[abc.Pad]\n    Price: Sequence[abc.Price]\n    Query: Sequence[abc.Query]\n    Transaction: Sequence[abc.Transaction]\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.TransactionPosting","title":"<code>TransactionPosting</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>Pair of a transaction and a posting.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>class TransactionPosting(NamedTuple):\n    \"\"\"Pair of a transaction and a posting.\"\"\"\n\n    transaction: abc.Transaction\n    posting: abc.Posting\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.group_entries_by_type","title":"<code>group_entries_by_type(entries)</code>","text":"<p>Group entries by type.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries to group.</p> required <p>Returns:</p> Type Description <code>EntriesByType</code> <p>A namedtuple containing the grouped lists of entries.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>def group_entries_by_type(entries: Sequence[abc.Directive]) -&gt; EntriesByType:\n    \"\"\"Group entries by type.\n\n    Arguments:\n        entries: A list of entries to group.\n\n    Returns:\n        A namedtuple containing the grouped lists of entries.\n    \"\"\"\n    entries_by_type = EntriesByType(\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n    )\n    for entry in entries:\n        # Handle both beancount types (e.g., \"Transaction\") and\n        # rustledger types (e.g., \"RLTransaction\")\n        type_name = entry.__class__.__name__\n        if type_name.startswith(\"RL\"):\n            type_name = type_name[2:]  # Strip \"RL\" prefix\n        getattr(entries_by_type, type_name).append(entry)\n    return entries_by_type\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.group_entries_by_account","title":"<code>group_entries_by_account(entries)</code>","text":"<p>Group entries by account.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required <p>Returns:</p> Type Description <code>Mapping[str, Sequence[Directive | TransactionPosting]]</code> <p>A dict mapping account names to their entries.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>def group_entries_by_account(\n    entries: Sequence[abc.Directive],\n) -&gt; Mapping[str, Sequence[abc.Directive | TransactionPosting]]:\n    \"\"\"Group entries by account.\n\n    Arguments:\n        entries: A list of entries.\n\n    Returns:\n        A dict mapping account names to their entries.\n    \"\"\"\n    res: dict[str, list[abc.Directive | TransactionPosting]] = defaultdict(\n        list,\n    )\n\n    for entry in entries:\n        if isinstance(entry, abc.Transaction):\n            for posting in entry.postings:\n                res[posting.account].append(TransactionPosting(entry, posting))\n        else:\n            for account in get_entry_accounts(entry):\n                res[account].append(entry)\n\n    return dict(sorted(res.items()))\n</code></pre>"},{"location":"api/#rustfava.core.ingest","title":"<code>ingest</code>","text":"<p>Ingest helper functions.</p>"},{"location":"api/#rustfava.core.ingest.IngestError","title":"<code>IngestError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>An error with one of the importers.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class IngestError(BeancountError):\n    \"\"\"An error with one of the importers.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterMethodCallError","title":"<code>ImporterMethodCallError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Error calling one of the importer methods.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterMethodCallError(RustfavaAPIError):\n    \"\"\"Error calling one of the importer methods.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\n            f\"Error calling method on importer:\\n\\n{traceback.format_exc()}\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterInvalidTypeError","title":"<code>ImporterInvalidTypeError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>One of the importer methods returned an unexpected type.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterInvalidTypeError(RustfavaAPIError):\n    \"\"\"One of the importer methods returned an unexpected type.\"\"\"\n\n    def __init__(self, attr: str, expected: type[Any], actual: Any) -&gt; None:\n        super().__init__(\n            f\"Got unexpected type from importer as {attr}:\"\n            f\" expected {expected!s}, got {type(actual)!s}:\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterExtractError","title":"<code>ImporterExtractError</code>","text":"<p>               Bases: <code>ImporterMethodCallError</code></p> <p>Error calling extract for importer.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterExtractError(ImporterMethodCallError):\n    \"\"\"Error calling extract for importer.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.MissingImporterConfigError","title":"<code>MissingImporterConfigError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Missing import-config option.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class MissingImporterConfigError(RustfavaAPIError):\n    \"\"\"Missing import-config option.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"Missing import-config option\")\n</code></pre>"},{"location":"api/#rustfava.core.ingest.MissingImporterDirsError","title":"<code>MissingImporterDirsError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>You need to set at least one imports-dir.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class MissingImporterDirsError(RustfavaAPIError):\n    \"\"\"You need to set at least one imports-dir.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"You need to set at least one imports-dir.\")\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImportConfigLoadError","title":"<code>ImportConfigLoadError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Error on loading the import config.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImportConfigLoadError(RustfavaAPIError):\n    \"\"\"Error on loading the import config.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.FileImportInfo","title":"<code>FileImportInfo</code>  <code>dataclass</code>","text":"<p>Info about one file/importer combination.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@dataclass(frozen=True)\nclass FileImportInfo:\n    \"\"\"Info about one file/importer combination.\"\"\"\n\n    importer_name: str\n    account: str\n    date: datetime.date\n    name: str\n</code></pre>"},{"location":"api/#rustfava.core.ingest.FileImporters","title":"<code>FileImporters</code>  <code>dataclass</code>","text":"<p>Importers for a file.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@dataclass(frozen=True)\nclass FileImporters:\n    \"\"\"Importers for a file.\"\"\"\n\n    name: str\n    basename: str\n    importers: list[FileImportInfo]\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter","title":"<code>WrappedImporter</code>","text":"<p>A wrapper to safely call importer methods.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class WrappedImporter:\n    \"\"\"A wrapper to safely call importer methods.\"\"\"\n\n    importer: BeanImporterProtocol | Importer\n\n    def __init__(self, importer: BeanImporterProtocol | Importer) -&gt; None:\n        self.importer = importer\n\n    @property\n    @_catch_any\n    def name(self) -&gt; str:\n        \"\"\"Get the name of the importer.\"\"\"\n        importer = self.importer\n        name = (\n            importer.name\n            if isinstance(importer, Importer)\n            else importer.name()\n        )\n        return _assert_type(\"name\", name, str)\n\n    @_catch_any\n    def identify(self: WrappedImporter, path: Path) -&gt; bool:\n        \"\"\"Whether the importer is matching the file.\"\"\"\n        importer = self.importer\n        matches = (\n            importer.identify(str(path))\n            if isinstance(importer, Importer)\n            else importer.identify(get_cached_file(path))\n        )\n        return _assert_type(\"identify\", matches, bool)\n\n    @_catch_any\n    def file_import_info(self, path: Path) -&gt; FileImportInfo:\n        \"\"\"Generate info about a file with an importer.\"\"\"\n        importer = self.importer\n        if isinstance(importer, Importer):\n            str_path = str(path)\n            account = importer.account(str_path)\n            date = importer.date(str_path)\n            filename = importer.filename(str_path)\n        else:\n            file = get_cached_file(path)\n            account = importer.file_account(file)\n            date = importer.file_date(file)\n            filename = importer.file_name(file)\n\n        return FileImportInfo(\n            self.name,\n            _assert_type(\"account\", account or \"\", str),\n            _assert_type(\"date\", date or local_today(), datetime.date),\n            _assert_type(\"filename\", filename or path.name, str),\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.name","title":"<code>name</code>  <code>property</code>","text":"<p>Get the name of the importer.</p>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.identify","title":"<code>identify(path)</code>","text":"<p>Whether the importer is matching the file.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@_catch_any\ndef identify(self: WrappedImporter, path: Path) -&gt; bool:\n    \"\"\"Whether the importer is matching the file.\"\"\"\n    importer = self.importer\n    matches = (\n        importer.identify(str(path))\n        if isinstance(importer, Importer)\n        else importer.identify(get_cached_file(path))\n    )\n    return _assert_type(\"identify\", matches, bool)\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.file_import_info","title":"<code>file_import_info(path)</code>","text":"<p>Generate info about a file with an importer.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@_catch_any\ndef file_import_info(self, path: Path) -&gt; FileImportInfo:\n    \"\"\"Generate info about a file with an importer.\"\"\"\n    importer = self.importer\n    if isinstance(importer, Importer):\n        str_path = str(path)\n        account = importer.account(str_path)\n        date = importer.date(str_path)\n        filename = importer.filename(str_path)\n    else:\n        file = get_cached_file(path)\n        account = importer.file_account(file)\n        date = importer.file_date(file)\n        filename = importer.file_name(file)\n\n    return FileImportInfo(\n        self.name,\n        _assert_type(\"account\", account or \"\", str),\n        _assert_type(\"date\", date or local_today(), datetime.date),\n        _assert_type(\"filename\", filename or path.name, str),\n    )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule","title":"<code>IngestModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Exposes ingest functionality.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class IngestModule(FavaModule):\n    \"\"\"Exposes ingest functionality.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.importers: Mapping[str, WrappedImporter] = {}\n        self.hooks: Hooks = []\n        self.mtime: int | None = None\n        self.errors: list[IngestError] = []\n\n    @property\n    def module_path(self) -&gt; Path | None:\n        \"\"\"The path to the importer configuration.\"\"\"\n        config_path = self.ledger.fava_options.import_config\n        if not config_path:\n            return None\n        return self.ledger.join_path(config_path)\n\n    def _error(self, msg: str) -&gt; None:\n        self.errors.append(\n            IngestError(\n                {\"filename\": str(self.module_path), \"lineno\": 0},\n                msg,\n                None,\n            ),\n        )\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.errors = []\n        module_path = self.module_path\n        if module_path is None:\n            return\n\n        if not module_path.exists():\n            self._error(\"Import config does not exist\")\n            return\n\n        new_mtime = module_path.stat().st_mtime_ns\n        if new_mtime == self.mtime:\n            return\n\n        try:\n            self.importers, self.hooks = load_import_config(module_path)\n            self.mtime = new_mtime\n        except RustfavaAPIError as error:  # pragma: no cover\n            msg = f\"Error in import config '{module_path}': {error!s}\"\n            self._error(msg)\n\n    def import_data(self) -&gt; list[FileImporters]:\n        \"\"\"Identify files and importers that can be imported.\n\n        Returns:\n            A list of :class:`.FileImportInfo`.\n        \"\"\"\n        if not self.importers:\n            return []\n\n        importers = list(self.importers.values())\n\n        ret: list[FileImporters] = []\n        for directory in self.ledger.fava_options.import_dirs:\n            full_path = self.ledger.join_path(directory)\n            ret.extend(find_imports(importers, full_path))\n\n        return ret\n\n    def extract(self, filename: str, importer_name: str) -&gt; list[Directive]:\n        \"\"\"Extract entries from filename with the specified importer.\n\n        Args:\n            filename: The full path to a file.\n            importer_name: The name of an importer that matched the file.\n\n        Returns:\n            A list of new imported entries.\n        \"\"\"\n        if not self.module_path:\n            raise MissingImporterConfigError\n\n        # reload (if changed)\n        self.load_file()\n\n        try:\n            path = Path(filename)\n            importer = self.importers[importer_name]\n            new_entries = extract_from_file(\n                importer,\n                path,\n                existing_entries=self.ledger.all_entries,\n            )\n        except Exception as exc:\n            raise ImporterExtractError from exc\n\n        for hook_fn in self.hooks:\n            annotations = get_annotations(hook_fn)\n            if any(\"Importer\" in a for a in annotations.values()):\n                importer_info = importer.file_import_info(path)\n                new_entries_list: HookOutput = [\n                    (\n                        filename,\n                        new_entries,\n                        importer_info.account,\n                        importer.importer,\n                    )\n                ]\n            else:\n                new_entries_list = [(filename, new_entries)]\n\n            new_entries_list = hook_fn(\n                new_entries_list,\n                self.ledger.all_entries,\n            )\n\n            new_entries = new_entries_list[0][1]\n\n        return new_entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule.module_path","title":"<code>module_path</code>  <code>property</code>","text":"<p>The path to the importer configuration.</p>"},{"location":"api/#rustfava.core.ingest.IngestModule.import_data","title":"<code>import_data()</code>","text":"<p>Identify files and importers that can be imported.</p> <p>Returns:</p> Type Description <code>list[FileImporters]</code> <p>A list of :class:<code>.FileImportInfo</code>.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def import_data(self) -&gt; list[FileImporters]:\n    \"\"\"Identify files and importers that can be imported.\n\n    Returns:\n        A list of :class:`.FileImportInfo`.\n    \"\"\"\n    if not self.importers:\n        return []\n\n    importers = list(self.importers.values())\n\n    ret: list[FileImporters] = []\n    for directory in self.ledger.fava_options.import_dirs:\n        full_path = self.ledger.join_path(directory)\n        ret.extend(find_imports(importers, full_path))\n\n    return ret\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule.extract","title":"<code>extract(filename, importer_name)</code>","text":"<p>Extract entries from filename with the specified importer.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The full path to a file.</p> required <code>importer_name</code> <code>str</code> <p>The name of an importer that matched the file.</p> required <p>Returns:</p> Type Description <code>list[Directive]</code> <p>A list of new imported entries.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def extract(self, filename: str, importer_name: str) -&gt; list[Directive]:\n    \"\"\"Extract entries from filename with the specified importer.\n\n    Args:\n        filename: The full path to a file.\n        importer_name: The name of an importer that matched the file.\n\n    Returns:\n        A list of new imported entries.\n    \"\"\"\n    if not self.module_path:\n        raise MissingImporterConfigError\n\n    # reload (if changed)\n    self.load_file()\n\n    try:\n        path = Path(filename)\n        importer = self.importers[importer_name]\n        new_entries = extract_from_file(\n            importer,\n            path,\n            existing_entries=self.ledger.all_entries,\n        )\n    except Exception as exc:\n        raise ImporterExtractError from exc\n\n    for hook_fn in self.hooks:\n        annotations = get_annotations(hook_fn)\n        if any(\"Importer\" in a for a in annotations.values()):\n            importer_info = importer.file_import_info(path)\n            new_entries_list: HookOutput = [\n                (\n                    filename,\n                    new_entries,\n                    importer_info.account,\n                    importer.importer,\n                )\n            ]\n        else:\n            new_entries_list = [(filename, new_entries)]\n\n        new_entries_list = hook_fn(\n            new_entries_list,\n            self.ledger.all_entries,\n        )\n\n        new_entries = new_entries_list[0][1]\n\n    return new_entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.walk_dir","title":"<code>walk_dir(directory)</code>","text":"<p>Walk through all files in dir.</p> <p>Ignores common dot-directories like .git, .cache. .venv, see IGNORE_DIRS.</p> <p>Parameters:</p> Name Type Description Default <code>directory</code> <code>Path</code> <p>The directory to start in.</p> required <p>Yields:</p> Type Description <code>Iterable[Path]</code> <p>All full paths under directory, ignoring some directories.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def walk_dir(directory: Path) -&gt; Iterable[Path]:\n    \"\"\"Walk through all files in dir.\n\n    Ignores common dot-directories like .git, .cache. .venv, see IGNORE_DIRS.\n\n    Args:\n        directory: The directory to start in.\n\n    Yields:\n        All full paths under directory, ignoring some directories.\n    \"\"\"\n    for root, dirs, filenames in os.walk(directory):\n        dirs[:] = sorted(d for d in dirs if d not in IGNORE_DIRS)\n        root_path = Path(root)\n        for filename in sorted(filenames):\n            yield root_path / filename\n</code></pre>"},{"location":"api/#rustfava.core.ingest.get_cached_file","title":"<code>get_cached_file(path)</code>","text":"<p>Get a cached FileMemo.</p> <p>This checks the file's mtime before getting it from the Cache. In addition to using the beangulp cache.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def get_cached_file(path: Path) -&gt; FileMemo:\n    \"\"\"Get a cached FileMemo.\n\n    This checks the file's mtime before getting it from the Cache.\n    In addition to using the beangulp cache.\n    \"\"\"\n    mtime = path.stat().st_mtime_ns\n    filename = str(path)\n    cached = _CACHE.get(path)\n    if cached:\n        mtime_cached, memo_cached = cached\n        if mtime &lt;= mtime_cached:  # pragma: no cover\n            return memo_cached\n    memo: FileMemo = cache._FileMemo(filename)  # noqa: SLF001\n    cache._CACHE[filename] = memo  # noqa: SLF001\n    _CACHE[path] = (mtime, memo)\n    return memo\n</code></pre>"},{"location":"api/#rustfava.core.ingest.find_imports","title":"<code>find_imports(config, directory)</code>","text":"<p>Pair files and matching importers.</p> <p>Yields:</p> Type Description <code>Iterable[FileImporters]</code> <p>For each file in directory, a pair of its filename and the matching</p> <code>Iterable[FileImporters]</code> <p>importers.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def find_imports(\n    config: Sequence[WrappedImporter], directory: Path\n) -&gt; Iterable[FileImporters]:\n    \"\"\"Pair files and matching importers.\n\n    Yields:\n        For each file in directory, a pair of its filename and the matching\n        importers.\n    \"\"\"\n    for path in walk_dir(directory):\n        stat = path.stat()\n        if stat.st_size &gt; _FILE_TOO_LARGE_THRESHOLD:  # pragma: no cover\n            continue\n\n        importers = [\n            importer.file_import_info(path)\n            for importer in config\n            if importer.identify(path)\n        ]\n        yield FileImporters(\n            name=str(path), basename=path.name, importers=importers\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.extract_from_file","title":"<code>extract_from_file(wrapped_importer, path, existing_entries)</code>","text":"<p>Import entries from a document.</p> <p>Parameters:</p> Name Type Description Default <code>wrapped_importer</code> <code>WrappedImporter</code> <p>The importer instance to handle the document.</p> required <code>path</code> <code>Path</code> <p>Filesystem path to the document.</p> required <code>existing_entries</code> <code>Sequence[Directive]</code> <p>Existing entries.</p> required <p>Returns:</p> Type Description <code>list[Directive]</code> <p>The list of imported entries.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def extract_from_file(\n    wrapped_importer: WrappedImporter,\n    path: Path,\n    existing_entries: Sequence[Directive],\n) -&gt; list[Directive]:\n    \"\"\"Import entries from a document.\n\n    Args:\n      wrapped_importer: The importer instance to handle the document.\n      path: Filesystem path to the document.\n      existing_entries: Existing entries.\n\n    Returns:\n      The list of imported entries.\n    \"\"\"\n    filename = str(path)\n    importer = wrapped_importer.importer\n    if isinstance(importer, Importer):\n        entries = importer.extract(filename, existing=existing_entries)\n    else:\n        file = get_cached_file(path)\n        entries = (\n            importer.extract(file, existing_entries=existing_entries)\n            if \"existing_entries\" in signature(importer.extract).parameters\n            else importer.extract(file)\n        ) or []\n\n    if hasattr(importer, \"sort\"):\n        importer.sort(entries)\n    else:\n        entries.sort(key=_incomplete_sortkey)\n    if isinstance(importer, Importer):\n        importer.deduplicate(entries, existing=existing_entries)\n    return entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.load_import_config","title":"<code>load_import_config(module_path)</code>","text":"<p>Load the given import config and extract importers and hooks.</p> <p>Parameters:</p> Name Type Description Default <code>module_path</code> <code>Path</code> <p>Path to the import config.</p> required <p>Returns:</p> Type Description <code>tuple[Mapping[str, WrappedImporter], Hooks]</code> <p>A pair of the importers (by name) and the list of hooks.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def load_import_config(\n    module_path: Path,\n) -&gt; tuple[Mapping[str, WrappedImporter], Hooks]:\n    \"\"\"Load the given import config and extract importers and hooks.\n\n    Args:\n        module_path: Path to the import config.\n\n    Returns:\n        A pair of the importers (by name) and the list of hooks.\n    \"\"\"\n    try:\n        mod = run_path(str(module_path))\n    except Exception as error:  # pragma: no cover\n        message = traceback.format_exc()\n        raise ImportConfigLoadError(message) from error\n\n    if \"CONFIG\" not in mod:\n        msg = \"CONFIG is missing\"\n        raise ImportConfigLoadError(msg)\n    if not isinstance(mod[\"CONFIG\"], list):  # pragma: no cover\n        msg = \"CONFIG is not a list\"\n        raise ImportConfigLoadError(msg)\n\n    config = mod[\"CONFIG\"]\n    hooks = DEFAULT_HOOKS\n    if \"HOOKS\" in mod:  # pragma: no cover\n        hooks = mod[\"HOOKS\"]\n        if not isinstance(hooks, list) or not all(\n            callable(fn) for fn in hooks\n        ):\n            msg = \"HOOKS is not a list of callables\"\n            raise ImportConfigLoadError(msg)\n    importers = {}\n    for importer in config:\n        if not isinstance(\n            importer, (BeanImporterProtocol, Importer)\n        ):  # pragma: no cover\n            name = importer.__class__.__name__\n            msg = (\n                f\"Importer class '{name}' in '{module_path}' does \"\n                \"not satisfy importer protocol\"\n            )\n            raise ImportConfigLoadError(msg)\n        wrapped_importer = WrappedImporter(importer)\n        if wrapped_importer.name in importers:\n            msg = f\"Duplicate importer name found: {wrapped_importer.name}\"\n            raise ImportConfigLoadError(msg)\n        importers[wrapped_importer.name] = wrapped_importer\n    return importers, hooks\n</code></pre>"},{"location":"api/#rustfava.core.ingest.filepath_in_primary_imports_folder","title":"<code>filepath_in_primary_imports_folder(filename, ledger)</code>","text":"<p>File path for a document to upload to the primary import folder.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The filename of the document.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>Path</code> <p>The path that the document should be saved at.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def filepath_in_primary_imports_folder(\n    filename: str,\n    ledger: RustfavaLedger,\n) -&gt; Path:\n    \"\"\"File path for a document to upload to the primary import folder.\n\n    Args:\n        filename: The filename of the document.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        The path that the document should be saved at.\n    \"\"\"\n    primary_imports_folder = next(iter(ledger.fava_options.import_dirs), None)\n    if primary_imports_folder is None:\n        raise MissingImporterDirsError\n\n    filename = filename.replace(sep, \" \")\n    if altsep:  # pragma: no cover\n        filename = filename.replace(altsep, \" \")\n\n    return ledger.join_path(primary_imports_folder, filename)\n</code></pre>"},{"location":"api/#rustfava.core.inventory","title":"<code>inventory</code>","text":"<p>Alternative implementation of Beancount's Inventory.</p>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory","title":"<code>SimpleCounterInventory</code>","text":"<p>               Bases: <code>dict[str, Decimal]</code></p> <p>A simple inventory mapping just strings to numbers.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>class SimpleCounterInventory(dict[str, Decimal]):\n    \"\"\"A simple inventory mapping just strings to numbers.\"\"\"\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the inventory is empty.\"\"\"\n        return not bool(self)\n\n    def add(self, key: str, number: Decimal) -&gt; None:\n        \"\"\"Add a number to key.\"\"\"\n        new_num = number + self.get(key, ZERO)\n        if new_num == ZERO:\n            self.pop(key, None)\n        else:\n            self[key] = new_num\n\n    def __iter__(self) -&gt; Iterator[str]:\n        raise NotImplementedError\n\n    def __neg__(self) -&gt; SimpleCounterInventory:\n        return SimpleCounterInventory({key: -num for key, num in self.items()})\n\n    def reduce(\n        self,\n        reducer: Callable[Concatenate[Position, P], Amount],\n        *args: P.args,\n        **_kwargs: P.kwargs,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Reduce inventory.\"\"\"\n        counter = SimpleCounterInventory()\n        for currency, number in self.items():\n            pos = _Position(_Amount(number, currency), None)\n            amount = reducer(pos, *args)  # type: ignore[call-arg]\n            counter.add(amount.currency, amount.number)\n        return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.is_empty","title":"<code>is_empty()</code>","text":"<p>Check if the inventory is empty.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def is_empty(self) -&gt; bool:\n    \"\"\"Check if the inventory is empty.\"\"\"\n    return not bool(self)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.add","title":"<code>add(key, number)</code>","text":"<p>Add a number to key.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add(self, key: str, number: Decimal) -&gt; None:\n    \"\"\"Add a number to key.\"\"\"\n    new_num = number + self.get(key, ZERO)\n    if new_num == ZERO:\n        self.pop(key, None)\n    else:\n        self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.reduce","title":"<code>reduce(reducer, *args, **_kwargs)</code>","text":"<p>Reduce inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def reduce(\n    self,\n    reducer: Callable[Concatenate[Position, P], Amount],\n    *args: P.args,\n    **_kwargs: P.kwargs,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Reduce inventory.\"\"\"\n    counter = SimpleCounterInventory()\n    for currency, number in self.items():\n        pos = _Position(_Amount(number, currency), None)\n        amount = reducer(pos, *args)  # type: ignore[call-arg]\n        counter.add(amount.currency, amount.number)\n    return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory","title":"<code>CounterInventory</code>","text":"<p>               Bases: <code>dict[InventoryKey, Decimal]</code></p> <p>A lightweight inventory.</p> <p>This is intended as a faster alternative to Beancount's Inventory class. Due to not using a list, for inventories with a lot of different positions, inserting is much faster.</p> <p>The keys should be tuples <code>(currency, cost)</code>.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>class CounterInventory(dict[InventoryKey, Decimal]):\n    \"\"\"A lightweight inventory.\n\n    This is intended as a faster alternative to Beancount's Inventory class.\n    Due to not using a list, for inventories with a lot of different positions,\n    inserting is much faster.\n\n    The keys should be tuples ``(currency, cost)``.\n    \"\"\"\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the inventory is empty.\"\"\"\n        return not bool(self)\n\n    def add(self, key: InventoryKey, number: Decimal) -&gt; None:\n        \"\"\"Add a number to key.\"\"\"\n        new_num = number + self.get(key, ZERO)\n        if new_num == ZERO:\n            self.pop(key, None)\n        else:\n            self[key] = new_num\n\n    def __iter__(self) -&gt; Iterator[InventoryKey]:\n        raise NotImplementedError\n\n    def to_strings(self) -&gt; list[str]:\n        \"\"\"Print as a list of strings (e.g. for snapshot tests).\"\"\"\n        strings = []\n        for (currency, cost), number in self.items():\n            if cost is None:\n                strings.append(f\"{number} {currency}\")\n            else:\n                cost_str = cost_to_string(cost)\n                strings.append(f\"{number} {currency} {{{cost_str}}}\")\n        return strings\n\n    def reduce(\n        self,\n        reducer: Callable[Concatenate[Position, P], Amount],\n        *args: P.args,\n        **_kwargs: P.kwargs,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Reduce inventory.\n\n        Note that this returns a simple :class:`CounterInventory` with just\n        currencies as keys.\n        \"\"\"\n        counter = SimpleCounterInventory()\n        for (currency, cost), number in self.items():\n            pos = _Position(_Amount(number, currency), cost)\n            amount = reducer(pos, *args)  # type: ignore[call-arg]\n            counter.add(amount.currency, amount.number)\n        return counter\n\n    def add_amount(self, amount: Amount, cost: Cost | None = None) -&gt; None:\n        \"\"\"Add an Amount to the inventory.\"\"\"\n        key = (amount.currency, cost)\n        self.add(key, amount.number)\n\n    def add_position(self, pos: Position) -&gt; None:\n        \"\"\"Add a Position or Posting to the inventory.\"\"\"\n        # Skip positions with missing units (can happen with parse errors)\n        if pos.units is None:\n            return\n        self.add_amount(pos.units, pos.cost)\n\n    def __neg__(self) -&gt; CounterInventory:\n        return CounterInventory({key: -num for key, num in self.items()})\n\n    def __add__(self, other: CounterInventory) -&gt; CounterInventory:\n        counter = CounterInventory(self)\n        counter.add_inventory(other)\n        return counter\n\n    def add_inventory(self, counter: CounterInventory) -&gt; None:\n        \"\"\"Add another :class:`CounterInventory`.\"\"\"\n        if not self:\n            self.update(counter)\n        else:\n            self_get = self.get\n            for key, num in counter.items():\n                new_num = num + self_get(key, ZERO)\n                if new_num == ZERO:\n                    self.pop(key, None)\n                else:\n                    self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.is_empty","title":"<code>is_empty()</code>","text":"<p>Check if the inventory is empty.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def is_empty(self) -&gt; bool:\n    \"\"\"Check if the inventory is empty.\"\"\"\n    return not bool(self)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add","title":"<code>add(key, number)</code>","text":"<p>Add a number to key.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add(self, key: InventoryKey, number: Decimal) -&gt; None:\n    \"\"\"Add a number to key.\"\"\"\n    new_num = number + self.get(key, ZERO)\n    if new_num == ZERO:\n        self.pop(key, None)\n    else:\n        self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.to_strings","title":"<code>to_strings()</code>","text":"<p>Print as a list of strings (e.g. for snapshot tests).</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def to_strings(self) -&gt; list[str]:\n    \"\"\"Print as a list of strings (e.g. for snapshot tests).\"\"\"\n    strings = []\n    for (currency, cost), number in self.items():\n        if cost is None:\n            strings.append(f\"{number} {currency}\")\n        else:\n            cost_str = cost_to_string(cost)\n            strings.append(f\"{number} {currency} {{{cost_str}}}\")\n    return strings\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.reduce","title":"<code>reduce(reducer, *args, **_kwargs)</code>","text":"<p>Reduce inventory.</p> <p>Note that this returns a simple :class:<code>CounterInventory</code> with just currencies as keys.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def reduce(\n    self,\n    reducer: Callable[Concatenate[Position, P], Amount],\n    *args: P.args,\n    **_kwargs: P.kwargs,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Reduce inventory.\n\n    Note that this returns a simple :class:`CounterInventory` with just\n    currencies as keys.\n    \"\"\"\n    counter = SimpleCounterInventory()\n    for (currency, cost), number in self.items():\n        pos = _Position(_Amount(number, currency), cost)\n        amount = reducer(pos, *args)  # type: ignore[call-arg]\n        counter.add(amount.currency, amount.number)\n    return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_amount","title":"<code>add_amount(amount, cost=None)</code>","text":"<p>Add an Amount to the inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_amount(self, amount: Amount, cost: Cost | None = None) -&gt; None:\n    \"\"\"Add an Amount to the inventory.\"\"\"\n    key = (amount.currency, cost)\n    self.add(key, amount.number)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_position","title":"<code>add_position(pos)</code>","text":"<p>Add a Position or Posting to the inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_position(self, pos: Position) -&gt; None:\n    \"\"\"Add a Position or Posting to the inventory.\"\"\"\n    # Skip positions with missing units (can happen with parse errors)\n    if pos.units is None:\n        return\n    self.add_amount(pos.units, pos.cost)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_inventory","title":"<code>add_inventory(counter)</code>","text":"<p>Add another :class:<code>CounterInventory</code>.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_inventory(self, counter: CounterInventory) -&gt; None:\n    \"\"\"Add another :class:`CounterInventory`.\"\"\"\n    if not self:\n        self.update(counter)\n    else:\n        self_get = self.get\n        for key, num in counter.items():\n            new_num = num + self_get(key, ZERO)\n            if new_num == ZERO:\n                self.pop(key, None)\n            else:\n                self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.misc","title":"<code>misc</code>","text":"<p>Some miscellaneous reports.</p>"},{"location":"api/#rustfava.core.misc.FavaError","title":"<code>FavaError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>Generic Fava-specific error.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>class FavaError(BeancountError):\n    \"\"\"Generic Fava-specific error.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.misc.FavaMisc","title":"<code>FavaMisc</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Provides access to some miscellaneous reports.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>class FavaMisc(FavaModule):\n    \"\"\"Provides access to some miscellaneous reports.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        #: User-chosen links to show in the sidebar.\n        self.sidebar_links: SidebarLinks = []\n        #: Upcoming events in the next few days.\n        self.upcoming_events: Sequence[Event] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        custom_entries = self.ledger.all_entries_by_type.Custom\n        self.sidebar_links = sidebar_links(custom_entries)\n\n        self.upcoming_events = upcoming_events(\n            self.ledger.all_entries_by_type.Event,\n            self.ledger.fava_options.upcoming_events,\n        )\n\n    @property\n    def errors(self) -&gt; Sequence[FavaError]:\n        \"\"\"An error if no operating currency is set.\"\"\"\n        return (\n            []\n            if self.ledger.options[\"operating_currency\"]\n            else [NO_OPERATING_CURRENCY_ERROR]\n        )\n</code></pre>"},{"location":"api/#rustfava.core.misc.FavaMisc.errors","title":"<code>errors</code>  <code>property</code>","text":"<p>An error if no operating currency is set.</p>"},{"location":"api/#rustfava.core.misc.sidebar_links","title":"<code>sidebar_links(custom_entries)</code>","text":"<p>Parse custom entries for links.</p> <p>They have the following format:</p> <p>2016-04-01 custom \"fava-sidebar-link\" \"2014\" \"/income_statement/?time=2014\"</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>def sidebar_links(custom_entries: Sequence[Custom]) -&gt; SidebarLinks:\n    \"\"\"Parse custom entries for links.\n\n    They have the following format:\n\n    2016-04-01 custom \"fava-sidebar-link\" \"2014\" \"/income_statement/?time=2014\"\n    \"\"\"\n    sidebar_link_entries = [\n        entry for entry in custom_entries if entry.type == \"fava-sidebar-link\"\n    ]\n    return [\n        (entry.values[0].value, entry.values[1].value)\n        for entry in sidebar_link_entries\n    ]\n</code></pre>"},{"location":"api/#rustfava.core.misc.upcoming_events","title":"<code>upcoming_events(events, max_delta)</code>","text":"<p>Parse entries for upcoming events.</p> <p>Parameters:</p> Name Type Description Default <code>events</code> <code>Sequence[Event]</code> <p>A list of events.</p> required <code>max_delta</code> <code>int</code> <p>Number of days that should be considered.</p> required <p>Returns:</p> Type Description <code>Sequence[Event]</code> <p>A list of the Events in entries that are less than <code>max_delta</code> days</p> <code>Sequence[Event]</code> <p>away.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>def upcoming_events(\n    events: Sequence[Event], max_delta: int\n) -&gt; Sequence[Event]:\n    \"\"\"Parse entries for upcoming events.\n\n    Args:\n        events: A list of events.\n        max_delta: Number of days that should be considered.\n\n    Returns:\n        A list of the Events in entries that are less than `max_delta` days\n        away.\n    \"\"\"\n    today = local_today()\n    upcoming = []\n\n    for event in events:\n        delta = event.date - today\n        if delta.days &gt;= 0 and delta.days &lt; max_delta:\n            upcoming.append(event)\n\n    return upcoming\n</code></pre>"},{"location":"api/#rustfava.core.misc.align","title":"<code>align(string, currency_column)</code>","text":"<p>Align currencies in one column.</p> Source code in <code>src/rustfava/beans/str.py</code> <pre><code>def align(string: str, currency_column: int) -&gt; str:\n    \"\"\"Align currencies in one column.\"\"\"\n    output = io.StringIO()\n    for line in string.splitlines():\n        match = ALIGN_RE.match(line)\n        if match:\n            prefix, number, rest = match.groups()\n            num_of_spaces = currency_column - len(prefix) - len(number) - 4\n            spaces = \" \" * num_of_spaces\n            output.write(prefix + spaces + \"  \" + number + \" \" + rest)\n        else:\n            output.write(line)\n        output.write(\"\\n\")\n\n    return output.getvalue()\n</code></pre>"},{"location":"api/#rustfava.core.module_base","title":"<code>module_base</code>","text":"<p>Base class for the \"modules\" of rustfavaLedger.</p>"},{"location":"api/#rustfava.core.module_base.FavaModule","title":"<code>FavaModule</code>","text":"<p>Base class for the \"modules\" of rustfavaLedger.</p> Source code in <code>src/rustfava/core/module_base.py</code> <pre><code>class FavaModule:\n    \"\"\"Base class for the \"modules\" of rustfavaLedger.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        self.ledger = ledger\n\n    def load_file(self) -&gt; None:\n        \"\"\"Run when the file has been (re)loaded.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.module_base.FavaModule.load_file","title":"<code>load_file()</code>","text":"<p>Run when the file has been (re)loaded.</p> Source code in <code>src/rustfava/core/module_base.py</code> <pre><code>def load_file(self) -&gt; None:\n    \"\"\"Run when the file has been (re)loaded.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.number","title":"<code>number</code>","text":"<p>Formatting numbers.</p>"},{"location":"api/#rustfava.core.number.DecimalFormatModule","title":"<code>DecimalFormatModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Formatting numbers.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>class DecimalFormatModule(FavaModule):\n    \"\"\"Formatting numbers.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._locale: Locale | None = None\n        self._formatters: dict[str, Formatter] = {}\n        self._default_pattern = get_locale_format(None, 2)\n        self.precisions: dict[str, int] = {}\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        locale = None\n\n        locale_option = self.ledger.fava_options.locale\n        if (\n            self.ledger.options[\"render_commas\"] and not locale_option\n        ):  # pragma: no cover\n            locale_option = \"en\"\n            self.ledger.fava_options.locale = locale_option\n\n        if locale_option:\n            locale = Locale.parse(locale_option)\n\n        dcontext = self.ledger.options[\"dcontext\"]\n        precisions: dict[str, int] = {}\n\n        # Both beancount's DisplayContext and RLDisplayContext have ccontexts\n        for currency, ccontext in dcontext.ccontexts.items():\n            prec = ccontext.get_fractional(None)\n            if prec is not None:\n                precisions[currency] = prec\n\n        precisions.update(self.ledger.commodities.precisions)\n\n        self._locale = locale\n        self._default_pattern = get_locale_format(locale, 2)\n        self._formatters = {\n            currency: get_locale_format(locale, prec)\n            for currency, prec in precisions.items()\n        }\n        self.precisions = precisions\n\n    def __call__(self, value: Decimal, currency: str | None = None) -&gt; str:\n        \"\"\"Format a decimal to the right number of decimal digits with locale.\n\n        Arguments:\n            value: A decimal number.\n            currency: A currency string or None.\n\n        Returns:\n            A string, the formatted decimal.\n        \"\"\"\n        if currency is None:\n            return self._default_pattern(value)\n        return self._formatters.get(currency, self._default_pattern)(value)\n</code></pre>"},{"location":"api/#rustfava.core.number.DecimalFormatModule.__call__","title":"<code>__call__(value, currency=None)</code>","text":"<p>Format a decimal to the right number of decimal digits with locale.</p> <p>Parameters:</p> Name Type Description Default <code>value</code> <code>Decimal</code> <p>A decimal number.</p> required <code>currency</code> <code>str | None</code> <p>A currency string or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>str</code> <p>A string, the formatted decimal.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>def __call__(self, value: Decimal, currency: str | None = None) -&gt; str:\n    \"\"\"Format a decimal to the right number of decimal digits with locale.\n\n    Arguments:\n        value: A decimal number.\n        currency: A currency string or None.\n\n    Returns:\n        A string, the formatted decimal.\n    \"\"\"\n    if currency is None:\n        return self._default_pattern(value)\n    return self._formatters.get(currency, self._default_pattern)(value)\n</code></pre>"},{"location":"api/#rustfava.core.number.get_locale_format","title":"<code>get_locale_format(locale, precision)</code>","text":"<p>Obtain formatting pattern for the given locale and precision.</p> <p>Parameters:</p> Name Type Description Default <code>locale</code> <code>Locale | None</code> <p>An optional locale.</p> required <code>precision</code> <code>int</code> <p>The precision.</p> required <p>Returns:</p> Type Description <code>Formatter</code> <p>A function that renders Decimals to strings as desired.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>def get_locale_format(locale: Locale | None, precision: int) -&gt; Formatter:\n    \"\"\"Obtain formatting pattern for the given locale and precision.\n\n    Arguments:\n        locale: An optional locale.\n        precision: The precision.\n\n    Returns:\n        A function that renders Decimals to strings as desired.\n    \"\"\"\n    # Set a maximum precision of 14, half the default precision of Decimal\n    precision = min(precision, 14)\n    if locale is None:\n        fmt_string = \"{:.\" + str(precision) + \"f}\"\n\n        def fmt(num: Decimal) -&gt; str:\n            return fmt_string.format(num)\n\n        return fmt\n\n    pattern = copy.copy(locale.decimal_formats.get(None))\n    if not pattern:  # pragma: no cover\n        msg = \"Expected Locale to have a decimal format pattern\"\n        raise ValueError(msg)\n    pattern.frac_prec = (precision, precision)\n\n    def locale_fmt(num: Decimal) -&gt; str:\n        return pattern.apply(num, locale)  # type: ignore[no-any-return]\n\n    return locale_fmt\n</code></pre>"},{"location":"api/#rustfava.core.query","title":"<code>query</code>","text":"<p>Query result types.</p>"},{"location":"api/#rustfava.core.query.QueryResultTable","title":"<code>QueryResultTable</code>  <code>dataclass</code>","text":"<p>Table query result.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass QueryResultTable:\n    \"\"\"Table query result.\"\"\"\n\n    types: list[BaseColumn]\n    rows: list[tuple[SerialisedQueryRowValue, ...]]\n    t: Literal[\"table\"] = \"table\"\n</code></pre>"},{"location":"api/#rustfava.core.query.QueryResultText","title":"<code>QueryResultText</code>  <code>dataclass</code>","text":"<p>Text query result.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass QueryResultText:\n    \"\"\"Text query result.\"\"\"\n\n    contents: str\n    t: Literal[\"string\"] = \"string\"\n</code></pre>"},{"location":"api/#rustfava.core.query.BaseColumn","title":"<code>BaseColumn</code>  <code>dataclass</code>","text":"<p>A query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass BaseColumn:\n    \"\"\"A query column.\"\"\"\n\n    name: str\n    dtype: str\n\n    @staticmethod\n    def serialise(\n        val: QueryRowValue,\n    ) -&gt; SerialisedQueryRowValue:\n        \"\"\"Serialiseable version of the column value.\"\"\"\n        return val  # type: ignore[no-any-return]\n</code></pre>"},{"location":"api/#rustfava.core.query.BaseColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialiseable version of the column value.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(\n    val: QueryRowValue,\n) -&gt; SerialisedQueryRowValue:\n    \"\"\"Serialiseable version of the column value.\"\"\"\n    return val  # type: ignore[no-any-return]\n</code></pre>"},{"location":"api/#rustfava.core.query.BoolColumn","title":"<code>BoolColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A boolean query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass BoolColumn(BaseColumn):\n    \"\"\"A boolean query column.\"\"\"\n\n    dtype: str = \"bool\"\n</code></pre>"},{"location":"api/#rustfava.core.query.DecimalColumn","title":"<code>DecimalColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A Decimal query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass DecimalColumn(BaseColumn):\n    \"\"\"A Decimal query column.\"\"\"\n\n    dtype: str = \"Decimal\"\n</code></pre>"},{"location":"api/#rustfava.core.query.IntColumn","title":"<code>IntColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A int query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass IntColumn(BaseColumn):\n    \"\"\"A int query column.\"\"\"\n\n    dtype: str = \"int\"\n</code></pre>"},{"location":"api/#rustfava.core.query.StrColumn","title":"<code>StrColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A str query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass StrColumn(BaseColumn):\n    \"\"\"A str query column.\"\"\"\n\n    dtype: str = \"str\"\n</code></pre>"},{"location":"api/#rustfava.core.query.DateColumn","title":"<code>DateColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A date query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass DateColumn(BaseColumn):\n    \"\"\"A date query column.\"\"\"\n\n    dtype: str = \"date\"\n</code></pre>"},{"location":"api/#rustfava.core.query.PositionColumn","title":"<code>PositionColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A Position query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass PositionColumn(BaseColumn):\n    \"\"\"A Position query column.\"\"\"\n\n    dtype: str = \"Position\"\n</code></pre>"},{"location":"api/#rustfava.core.query.SetColumn","title":"<code>SetColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A set query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass SetColumn(BaseColumn):\n    \"\"\"A set query column.\"\"\"\n\n    dtype: str = \"set\"\n</code></pre>"},{"location":"api/#rustfava.core.query.AmountColumn","title":"<code>AmountColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An amount query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass AmountColumn(BaseColumn):\n    \"\"\"An amount query column.\"\"\"\n\n    dtype: str = \"Amount\"\n</code></pre>"},{"location":"api/#rustfava.core.query.ObjectColumn","title":"<code>ObjectColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An object query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass ObjectColumn(BaseColumn):\n    \"\"\"An object query column.\"\"\"\n\n    dtype: str = \"object\"\n\n    @staticmethod\n    def serialise(val: object) -&gt; str:\n        \"\"\"Serialise an object of unknown type to a string.\"\"\"\n        return str(val)\n</code></pre>"},{"location":"api/#rustfava.core.query.ObjectColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialise an object of unknown type to a string.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(val: object) -&gt; str:\n    \"\"\"Serialise an object of unknown type to a string.\"\"\"\n    return str(val)\n</code></pre>"},{"location":"api/#rustfava.core.query.InventoryColumn","title":"<code>InventoryColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An inventory query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass InventoryColumn(BaseColumn):\n    \"\"\"An inventory query column.\"\"\"\n\n    dtype: str = \"Inventory\"\n\n    @staticmethod\n    def serialise(\n        val: dict[str, Decimal] | None,\n    ) -&gt; SimpleCounterInventory | None:\n        \"\"\"Serialise an inventory.\n\n        Rustledger returns inventory as a dict of currency -&gt; Decimal.\n        \"\"\"\n        if val is None:\n            return None\n        # Rustledger already converts to {currency: Decimal} format\n        if isinstance(val, dict):\n            from rustfava.core.inventory import SimpleCounterInventory\n            return SimpleCounterInventory(val)\n        # Fallback for beancount Inventory type (for backwards compat)\n        return UNITS.apply_inventory(val) if val is not None else None\n</code></pre>"},{"location":"api/#rustfava.core.query.InventoryColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialise an inventory.</p> <p>Rustledger returns inventory as a dict of currency -&gt; Decimal.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(\n    val: dict[str, Decimal] | None,\n) -&gt; SimpleCounterInventory | None:\n    \"\"\"Serialise an inventory.\n\n    Rustledger returns inventory as a dict of currency -&gt; Decimal.\n    \"\"\"\n    if val is None:\n        return None\n    # Rustledger already converts to {currency: Decimal} format\n    if isinstance(val, dict):\n        from rustfava.core.inventory import SimpleCounterInventory\n        return SimpleCounterInventory(val)\n    # Fallback for beancount Inventory type (for backwards compat)\n    return UNITS.apply_inventory(val) if val is not None else None\n</code></pre>"},{"location":"api/#rustfava.core.query_shell","title":"<code>query_shell</code>","text":"<p>For running BQL queries in Fava.</p>"},{"location":"api/#rustfava.core.query_shell.FavaShellError","title":"<code>FavaShellError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>An error in the Fava BQL shell, will be turned into a string.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class FavaShellError(RustfavaAPIError):\n    \"\"\"An error in the Fava BQL shell, will be turned into a string.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryNotFoundError","title":"<code>QueryNotFoundError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query '{name}' not found.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryNotFoundError(FavaShellError):\n    \"\"\"Query '{name}' not found.\"\"\"\n\n    def __init__(self, name: str) -&gt; None:\n        super().__init__(f\"Query '{name}' not found.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.TooManyRunArgsError","title":"<code>TooManyRunArgsError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Too many args to run: '{args}'.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class TooManyRunArgsError(FavaShellError):\n    \"\"\"Too many args to run: '{args}'.\"\"\"\n\n    def __init__(self, args: str) -&gt; None:\n        super().__init__(f\"Too many args to run: '{args}'.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryCompilationError","title":"<code>QueryCompilationError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query compilation error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryCompilationError(FavaShellError):\n    \"\"\"Query compilation error.\"\"\"\n\n    def __init__(self, err: CompilationError) -&gt; None:\n        super().__init__(f\"Query compilation error: {err!s}.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryParseError","title":"<code>QueryParseError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query parse error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryParseError(FavaShellError):\n    \"\"\"Query parse error.\"\"\"\n\n    def __init__(self, err: ParseError) -&gt; None:\n        super().__init__(f\"Query parse error: {err!s}.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.NonExportableQueryError","title":"<code>NonExportableQueryError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Only queries that return a table can be printed to a file.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class NonExportableQueryError(FavaShellError):\n    \"\"\"Only queries that return a table can be printed to a file.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\n            \"Only queries that return a table can be printed to a file.\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.FavaQueryRunner","title":"<code>FavaQueryRunner</code>","text":"<p>Runs BQL queries using rustledger.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class FavaQueryRunner:\n    \"\"\"Runs BQL queries using rustledger.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        self.ledger = ledger\n\n    def run(\n        self, entries: Sequence[Directive], query: str\n    ) -&gt; RLCursor | str:\n        \"\"\"Run a query, returning cursor or text result.\"\"\"\n        # Get the source from the ledger for queries\n        source = getattr(self.ledger, \"_source\", None)\n\n        # Create connection\n        conn = connect(\n            \"rustledger:\",\n            entries=entries,\n            errors=self.ledger.errors,\n            options=self.ledger.options,\n        )\n\n        if source:\n            conn.set_source(source)\n\n        # Parse the query to handle special commands\n        query = query.strip()\n        query_lower = query.lower()\n\n        # Handle noop commands (return fixed text)\n        noop_doc = \"Doesn't do anything in rustfava's query shell.\"\n        if query_lower in (\".exit\", \".quit\", \"exit\", \"quit\"):\n            return noop_doc\n\n        # Handle .run or run command\n        if query_lower.startswith((\".run\", \"run\")):\n            # Check if it's just \"run\" or \".run\" (list queries) or \"run name\"\n            if query_lower in (\"run\", \".run\") or query_lower.startswith((\"run \", \".run \")):\n                return self._handle_run(query, conn)\n\n        # Handle help commands - return text\n        if query_lower.startswith((\".help\", \"help\")):\n            # \".help exit\" or \".help &lt;command&gt;\" returns noop doc\n            if \" \" in query_lower:\n                return noop_doc\n            return self._help_text()\n\n        # Handle .explain - return placeholder\n        if query_lower.startswith((\".explain\", \"explain\")):\n            return f\"EXPLAIN: {query}\"\n\n        # Handle SELECT/BALANCES/JOURNAL queries\n        try:\n            return conn.execute(query)\n        except ParseError as exc:\n            raise QueryParseError(exc) from exc\n        except CompilationError as exc:\n            raise QueryCompilationError(exc) from exc\n\n    def _handle_run(self, query: str, conn: RLConnection) -&gt; RLCursor | str:\n        \"\"\"Handle .run command to execute stored queries.\"\"\"\n        queries = self.ledger.all_entries_by_type.Query\n\n        # Parse the run command\n        parts = shlex.split(query)\n        if len(parts) == 1:\n            # Just \"run\" - list available queries\n            return \"\\n\".join(q.name for q in queries)\n\n        if len(parts) &gt; 2:\n            raise TooManyRunArgsError(query)\n\n        name = parts[1].rstrip(\";\")\n        query_obj = next((q for q in queries if q.name == name), None)\n        if query_obj is None:\n            raise QueryNotFoundError(name)\n\n        try:\n            return conn.execute(query_obj.query_string)\n        except ParseError as exc:\n            raise QueryParseError(exc) from exc\n        except CompilationError as exc:\n            raise QueryCompilationError(exc) from exc\n\n    def _help_text(self) -&gt; str:\n        \"\"\"Return help text for the query shell.\"\"\"\n        return \"\"\"Fava Query Shell\n\nCommands:\n  SELECT ...     Run a BQL SELECT query\n  run &lt;name&gt;     Run a stored query by name\n  run            List all stored queries\n  help           Show this help message\n\nExample queries:\n  SELECT account, sum(position) GROUP BY account\n  SELECT date, narration, position WHERE account ~ \"Expenses\"\n\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.FavaQueryRunner.run","title":"<code>run(entries, query)</code>","text":"<p>Run a query, returning cursor or text result.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def run(\n    self, entries: Sequence[Directive], query: str\n) -&gt; RLCursor | str:\n    \"\"\"Run a query, returning cursor or text result.\"\"\"\n    # Get the source from the ledger for queries\n    source = getattr(self.ledger, \"_source\", None)\n\n    # Create connection\n    conn = connect(\n        \"rustledger:\",\n        entries=entries,\n        errors=self.ledger.errors,\n        options=self.ledger.options,\n    )\n\n    if source:\n        conn.set_source(source)\n\n    # Parse the query to handle special commands\n    query = query.strip()\n    query_lower = query.lower()\n\n    # Handle noop commands (return fixed text)\n    noop_doc = \"Doesn't do anything in rustfava's query shell.\"\n    if query_lower in (\".exit\", \".quit\", \"exit\", \"quit\"):\n        return noop_doc\n\n    # Handle .run or run command\n    if query_lower.startswith((\".run\", \"run\")):\n        # Check if it's just \"run\" or \".run\" (list queries) or \"run name\"\n        if query_lower in (\"run\", \".run\") or query_lower.startswith((\"run \", \".run \")):\n            return self._handle_run(query, conn)\n\n    # Handle help commands - return text\n    if query_lower.startswith((\".help\", \"help\")):\n        # \".help exit\" or \".help &lt;command&gt;\" returns noop doc\n        if \" \" in query_lower:\n            return noop_doc\n        return self._help_text()\n\n    # Handle .explain - return placeholder\n    if query_lower.startswith((\".explain\", \"explain\")):\n        return f\"EXPLAIN: {query}\"\n\n    # Handle SELECT/BALANCES/JOURNAL queries\n    try:\n        return conn.execute(query)\n    except ParseError as exc:\n        raise QueryParseError(exc) from exc\n    except CompilationError as exc:\n        raise QueryCompilationError(exc) from exc\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell","title":"<code>QueryShell</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>A Fava module to run BQL queries.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryShell(FavaModule):\n    \"\"\"A Fava module to run BQL queries.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.runner = FavaQueryRunner(ledger)\n\n    def execute_query_serialised(\n        self, entries: Sequence[Directive], query: str\n    ) -&gt; QueryResultTable | QueryResultText:\n        \"\"\"Run a query and returns its serialised result.\n\n        Arguments:\n            entries: The entries to run the query on.\n            query: A query string.\n\n        Returns:\n            Either a table or a text result (depending on the query).\n\n        Raises:\n            RustfavaAPIError: If the query response is an error.\n        \"\"\"\n        res = self.runner.run(entries, query)\n        return (\n            QueryResultText(res) if isinstance(res, str) else _serialise(res)\n        )\n\n    def query_to_file(\n        self,\n        entries: Sequence[Directive],\n        query_string: str,\n        result_format: str,\n    ) -&gt; tuple[str, io.BytesIO]:\n        \"\"\"Get query result as file.\n\n        Arguments:\n            entries: The entries to run the query on.\n            query_string: A string, the query to run.\n            result_format: The file format to save to.\n\n        Returns:\n            A tuple (name, data), where name is either 'query_result' or the\n            name of a custom query if the query string is 'run name_of_query'.\n            ``data`` contains the file contents.\n\n        Raises:\n            RustfavaAPIError: If the result format is not supported or the\n            query failed.\n        \"\"\"\n        name = \"query_result\"\n\n        if query_string.lower().startswith((\".run\", \"run \")):\n            parts = shlex.split(query_string)\n            if len(parts) &gt; 2:\n                raise TooManyRunArgsError(query_string)\n            if len(parts) == 2:\n                name = parts[1].rstrip(\";\")\n                queries = self.ledger.all_entries_by_type.Query\n                query_obj = next((q for q in queries if q.name == name), None)\n                if query_obj is None:\n                    raise QueryNotFoundError(name)\n                query_string = query_obj.query_string\n\n        res = self.runner.run(entries, query_string)\n        if isinstance(res, str):\n            raise NonExportableQueryError\n\n        rrows = res.fetchall()\n        rtypes = res.description\n\n        # Convert rows to exportable format\n        rows = _numberify_rows(rrows, rtypes)\n\n        if result_format == \"csv\":\n            data = to_csv(list(rtypes), rows)\n        else:\n            if not HAVE_EXCEL:  # pragma: no cover\n                msg = \"Result format not supported.\"\n                raise RustfavaAPIError(msg)\n            data = to_excel(list(rtypes), rows, result_format, query_string)\n        return name, data\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell.execute_query_serialised","title":"<code>execute_query_serialised(entries, query)</code>","text":"<p>Run a query and returns its serialised result.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>The entries to run the query on.</p> required <code>query</code> <code>str</code> <p>A query string.</p> required <p>Returns:</p> Type Description <code>QueryResultTable | QueryResultText</code> <p>Either a table or a text result (depending on the query).</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the query response is an error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def execute_query_serialised(\n    self, entries: Sequence[Directive], query: str\n) -&gt; QueryResultTable | QueryResultText:\n    \"\"\"Run a query and returns its serialised result.\n\n    Arguments:\n        entries: The entries to run the query on.\n        query: A query string.\n\n    Returns:\n        Either a table or a text result (depending on the query).\n\n    Raises:\n        RustfavaAPIError: If the query response is an error.\n    \"\"\"\n    res = self.runner.run(entries, query)\n    return (\n        QueryResultText(res) if isinstance(res, str) else _serialise(res)\n    )\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell.query_to_file","title":"<code>query_to_file(entries, query_string, result_format)</code>","text":"<p>Get query result as file.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>The entries to run the query on.</p> required <code>query_string</code> <code>str</code> <p>A string, the query to run.</p> required <code>result_format</code> <code>str</code> <p>The file format to save to.</p> required <p>Returns:</p> Type Description <code>str</code> <p>A tuple (name, data), where name is either 'query_result' or the</p> <code>BytesIO</code> <p>name of a custom query if the query string is 'run name_of_query'.</p> <code>tuple[str, BytesIO]</code> <p><code>data</code> contains the file contents.</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the result format is not supported or the</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def query_to_file(\n    self,\n    entries: Sequence[Directive],\n    query_string: str,\n    result_format: str,\n) -&gt; tuple[str, io.BytesIO]:\n    \"\"\"Get query result as file.\n\n    Arguments:\n        entries: The entries to run the query on.\n        query_string: A string, the query to run.\n        result_format: The file format to save to.\n\n    Returns:\n        A tuple (name, data), where name is either 'query_result' or the\n        name of a custom query if the query string is 'run name_of_query'.\n        ``data`` contains the file contents.\n\n    Raises:\n        RustfavaAPIError: If the result format is not supported or the\n        query failed.\n    \"\"\"\n    name = \"query_result\"\n\n    if query_string.lower().startswith((\".run\", \"run \")):\n        parts = shlex.split(query_string)\n        if len(parts) &gt; 2:\n            raise TooManyRunArgsError(query_string)\n        if len(parts) == 2:\n            name = parts[1].rstrip(\";\")\n            queries = self.ledger.all_entries_by_type.Query\n            query_obj = next((q for q in queries if q.name == name), None)\n            if query_obj is None:\n                raise QueryNotFoundError(name)\n            query_string = query_obj.query_string\n\n    res = self.runner.run(entries, query_string)\n    if isinstance(res, str):\n        raise NonExportableQueryError\n\n    rrows = res.fetchall()\n    rtypes = res.description\n\n    # Convert rows to exportable format\n    rows = _numberify_rows(rrows, rtypes)\n\n    if result_format == \"csv\":\n        data = to_csv(list(rtypes), rows)\n    else:\n        if not HAVE_EXCEL:  # pragma: no cover\n            msg = \"Result format not supported.\"\n            raise RustfavaAPIError(msg)\n        data = to_excel(list(rtypes), rows, result_format, query_string)\n    return name, data\n</code></pre>"},{"location":"api/#rustfava.core.tree","title":"<code>tree</code>","text":"<p>Account balance trees.</p>"},{"location":"api/#rustfava.core.tree.SerialisedTreeNode","title":"<code>SerialisedTreeNode</code>  <code>dataclass</code>","text":"<p>A serialised TreeNode.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>@dataclass(frozen=True)\nclass SerialisedTreeNode:\n    \"\"\"A serialised TreeNode.\"\"\"\n\n    account: str\n    balance: SimpleCounterInventory\n    balance_children: SimpleCounterInventory\n    children: Sequence[SerialisedTreeNode]\n    has_txns: bool\n    cost: SimpleCounterInventory | None = None\n    cost_children: SimpleCounterInventory | None = None\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode","title":"<code>TreeNode</code>","text":"<p>A node in the account tree.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>class TreeNode:\n    \"\"\"A node in the account tree.\"\"\"\n\n    __slots__ = (\"balance\", \"balance_children\", \"children\", \"has_txns\", \"name\")\n\n    def __init__(self, name: str) -&gt; None:\n        #: Account name.\n        self.name: str = name\n        #: A list of :class:`.TreeNode`, its children.\n        self.children: list[TreeNode] = []\n        #: The cumulative account balance.\n        self.balance_children = CounterInventory()\n        #: The account balance.\n        self.balance = CounterInventory()\n        #: Whether the account has any transactions.\n        self.has_txns = False\n\n    def serialise(\n        self,\n        conversion: Conversion,\n        prices: RustfavaPriceMap,\n        end: datetime.date | None,\n        *,\n        with_cost: bool = False,\n    ) -&gt; SerialisedTreeNode:\n        \"\"\"Serialise the account.\n\n        Args:\n            conversion: The conversion to use.\n            prices: The price map to use.\n            end: A date to use for cost conversions.\n            with_cost: Additionally convert to cost.\n        \"\"\"\n        children = [\n            child.serialise(conversion, prices, end, with_cost=with_cost)\n            for child in sorted(self.children, key=attrgetter(\"name\"))\n        ]\n        return (\n            SerialisedTreeNode(\n                self.name,\n                conversion.apply(self.balance, prices, end),\n                conversion.apply(self.balance_children, prices, end),\n                children,\n                self.has_txns,\n                AT_COST.apply(self.balance),\n                AT_COST.apply(self.balance_children),\n            )\n            if with_cost\n            else SerialisedTreeNode(\n                self.name,\n                conversion.apply(self.balance, prices, end),\n                conversion.apply(self.balance_children, prices, end),\n                children,\n                self.has_txns,\n            )\n        )\n\n    def serialise_with_context(self) -&gt; SerialisedTreeNode:\n        \"\"\"Serialise, getting all parameters from Flask context.\"\"\"\n        return self.serialise(\n            g.conv,\n            g.ledger.prices,\n            g.filtered.end_date,\n            with_cost=g.conv == AT_VALUE,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode.serialise","title":"<code>serialise(conversion, prices, end, *, with_cost=False)</code>","text":"<p>Serialise the account.</p> <p>Parameters:</p> Name Type Description Default <code>conversion</code> <code>Conversion</code> <p>The conversion to use.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>The price map to use.</p> required <code>end</code> <code>date | None</code> <p>A date to use for cost conversions.</p> required <code>with_cost</code> <code>bool</code> <p>Additionally convert to cost.</p> <code>False</code> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def serialise(\n    self,\n    conversion: Conversion,\n    prices: RustfavaPriceMap,\n    end: datetime.date | None,\n    *,\n    with_cost: bool = False,\n) -&gt; SerialisedTreeNode:\n    \"\"\"Serialise the account.\n\n    Args:\n        conversion: The conversion to use.\n        prices: The price map to use.\n        end: A date to use for cost conversions.\n        with_cost: Additionally convert to cost.\n    \"\"\"\n    children = [\n        child.serialise(conversion, prices, end, with_cost=with_cost)\n        for child in sorted(self.children, key=attrgetter(\"name\"))\n    ]\n    return (\n        SerialisedTreeNode(\n            self.name,\n            conversion.apply(self.balance, prices, end),\n            conversion.apply(self.balance_children, prices, end),\n            children,\n            self.has_txns,\n            AT_COST.apply(self.balance),\n            AT_COST.apply(self.balance_children),\n        )\n        if with_cost\n        else SerialisedTreeNode(\n            self.name,\n            conversion.apply(self.balance, prices, end),\n            conversion.apply(self.balance_children, prices, end),\n            children,\n            self.has_txns,\n        )\n    )\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode.serialise_with_context","title":"<code>serialise_with_context()</code>","text":"<p>Serialise, getting all parameters from Flask context.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def serialise_with_context(self) -&gt; SerialisedTreeNode:\n    \"\"\"Serialise, getting all parameters from Flask context.\"\"\"\n    return self.serialise(\n        g.conv,\n        g.ledger.prices,\n        g.filtered.end_date,\n        with_cost=g.conv == AT_VALUE,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree","title":"<code>Tree</code>","text":"<p>               Bases: <code>dict[str, TreeNode]</code></p> <p>Account tree.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Iterable[Directive | Directive] | None</code> <p>A list of entries to compute balances from.</p> <code>None</code> <code>create_accounts</code> <code>list[str] | None</code> <p>A list of accounts that the tree should contain.</p> <code>None</code> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>class Tree(dict[str, TreeNode]):\n    \"\"\"Account tree.\n\n    Args:\n        entries: A list of entries to compute balances from.\n        create_accounts: A list of accounts that the tree should contain.\n    \"\"\"\n\n    def __init__(\n        self,\n        entries: Iterable[Directive | data.Directive] | None = None,\n        create_accounts: list[str] | None = None,\n    ) -&gt; None:\n        super().__init__(self)\n        self.get(\"\", insert=True)\n        if create_accounts:\n            for account in create_accounts:\n                self.get(account, insert=True)\n        if entries:\n            account_balances: dict[str, CounterInventory]\n            account_balances = defaultdict(CounterInventory)\n            for entry in entries:\n                if isinstance(entry, Open):\n                    self.get(entry.account, insert=True)\n                for posting in getattr(entry, \"postings\", []):\n                    account_balances[posting.account].add_position(posting)\n\n            for name, balance in sorted(account_balances.items()):\n                self.insert(name, balance)\n\n    @property\n    def accounts(self) -&gt; list[str]:\n        \"\"\"The accounts in this tree.\"\"\"\n        return sorted(self.keys())\n\n    def ancestors(self, name: str) -&gt; Iterable[TreeNode]:\n        \"\"\"Ancestors of an account.\n\n        Args:\n            name: An account name.\n\n        Yields:\n            The ancestors of the given account from the bottom up.\n        \"\"\"\n        while name:\n            name = account_parent(name) or \"\"\n            yield self.get(name)\n\n    def insert(self, name: str, balance: CounterInventory) -&gt; None:\n        \"\"\"Insert account with a balance.\n\n        Insert account and update its balance and the balances of its\n        ancestors.\n\n        Args:\n            name: An account name.\n            balance: The balance of the account.\n        \"\"\"\n        node = self.get(name, insert=True)\n        node.balance.add_inventory(balance)\n        node.balance_children.add_inventory(balance)\n        node.has_txns = True\n        for parent_node in self.ancestors(name):\n            parent_node.balance_children.add_inventory(balance)\n\n    def get(  # type: ignore[override]\n        self,\n        name: str,\n        *,\n        insert: bool = False,\n    ) -&gt; TreeNode:\n        \"\"\"Get an account.\n\n        Args:\n            name: An account name.\n            insert: If True, insert the name into the tree if it does not\n                exist.\n\n        Returns:\n            TreeNode: The account of that name or an empty account if the\n            account is not in the tree.\n        \"\"\"\n        try:\n            return self[name]\n        except KeyError:\n            node = TreeNode(name)\n            if insert:\n                if name:\n                    parent = self.get(account_parent(name) or \"\", insert=True)\n                    parent.children.append(node)\n                self[name] = node\n            return node\n\n    def net_profit(\n        self,\n        options: BeancountOptions,\n        account_name: str,\n    ) -&gt; TreeNode:\n        \"\"\"Calculate the net profit.\n\n        Args:\n            options: The Beancount options.\n            account_name: The name to use for the account containing the net\n                profit.\n        \"\"\"\n        income = self.get(options[\"name_income\"])\n        expenses = self.get(options[\"name_expenses\"])\n\n        net_profit = Tree()\n        net_profit.insert(\n            account_name,\n            income.balance_children + expenses.balance_children,\n        )\n\n        return net_profit.get(account_name)\n\n    def cap(self, options: BeancountOptions, unrealized_account: str) -&gt; None:\n        \"\"\"Transfer Income and Expenses, add conversions and unrealized gains.\n\n        Args:\n            options: The Beancount options.\n            unrealized_account: The name of the account to post unrealized\n                gains to (as a subaccount of Equity).\n        \"\"\"\n        equity = options[\"name_equity\"]\n        conversions = CounterInventory(\n            {\n                (currency, None): -number\n                for currency, number in AT_COST.apply(\n                    self.get(\"\").balance_children\n                ).items()\n            },\n        )\n\n        # Add conversions\n        self.insert(\n            equity + \":\" + options[\"account_current_conversions\"],\n            conversions,\n        )\n\n        # Insert unrealized gains.\n        self.insert(\n            equity + \":\" + unrealized_account,\n            -self.get(\"\").balance_children,\n        )\n\n        # Transfer Income and Expenses\n        self.insert(\n            equity + \":\" + options[\"account_current_earnings\"],\n            self.get(options[\"name_income\"]).balance_children,\n        )\n        self.insert(\n            equity + \":\" + options[\"account_current_earnings\"],\n            self.get(options[\"name_expenses\"]).balance_children,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.accounts","title":"<code>accounts</code>  <code>property</code>","text":"<p>The accounts in this tree.</p>"},{"location":"api/#rustfava.core.tree.Tree.ancestors","title":"<code>ancestors(name)</code>","text":"<p>Ancestors of an account.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <p>Yields:</p> Type Description <code>Iterable[TreeNode]</code> <p>The ancestors of the given account from the bottom up.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def ancestors(self, name: str) -&gt; Iterable[TreeNode]:\n    \"\"\"Ancestors of an account.\n\n    Args:\n        name: An account name.\n\n    Yields:\n        The ancestors of the given account from the bottom up.\n    \"\"\"\n    while name:\n        name = account_parent(name) or \"\"\n        yield self.get(name)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.insert","title":"<code>insert(name, balance)</code>","text":"<p>Insert account with a balance.</p> <p>Insert account and update its balance and the balances of its ancestors.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <code>balance</code> <code>CounterInventory</code> <p>The balance of the account.</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def insert(self, name: str, balance: CounterInventory) -&gt; None:\n    \"\"\"Insert account with a balance.\n\n    Insert account and update its balance and the balances of its\n    ancestors.\n\n    Args:\n        name: An account name.\n        balance: The balance of the account.\n    \"\"\"\n    node = self.get(name, insert=True)\n    node.balance.add_inventory(balance)\n    node.balance_children.add_inventory(balance)\n    node.has_txns = True\n    for parent_node in self.ancestors(name):\n        parent_node.balance_children.add_inventory(balance)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.get","title":"<code>get(name, *, insert=False)</code>","text":"<p>Get an account.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <code>insert</code> <code>bool</code> <p>If True, insert the name into the tree if it does not exist.</p> <code>False</code> <p>Returns:</p> Name Type Description <code>TreeNode</code> <code>TreeNode</code> <p>The account of that name or an empty account if the</p> <code>TreeNode</code> <p>account is not in the tree.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def get(  # type: ignore[override]\n    self,\n    name: str,\n    *,\n    insert: bool = False,\n) -&gt; TreeNode:\n    \"\"\"Get an account.\n\n    Args:\n        name: An account name.\n        insert: If True, insert the name into the tree if it does not\n            exist.\n\n    Returns:\n        TreeNode: The account of that name or an empty account if the\n        account is not in the tree.\n    \"\"\"\n    try:\n        return self[name]\n    except KeyError:\n        node = TreeNode(name)\n        if insert:\n            if name:\n                parent = self.get(account_parent(name) or \"\", insert=True)\n                parent.children.append(node)\n            self[name] = node\n        return node\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.net_profit","title":"<code>net_profit(options, account_name)</code>","text":"<p>Calculate the net profit.</p> <p>Parameters:</p> Name Type Description Default <code>options</code> <code>BeancountOptions</code> <p>The Beancount options.</p> required <code>account_name</code> <code>str</code> <p>The name to use for the account containing the net profit.</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def net_profit(\n    self,\n    options: BeancountOptions,\n    account_name: str,\n) -&gt; TreeNode:\n    \"\"\"Calculate the net profit.\n\n    Args:\n        options: The Beancount options.\n        account_name: The name to use for the account containing the net\n            profit.\n    \"\"\"\n    income = self.get(options[\"name_income\"])\n    expenses = self.get(options[\"name_expenses\"])\n\n    net_profit = Tree()\n    net_profit.insert(\n        account_name,\n        income.balance_children + expenses.balance_children,\n    )\n\n    return net_profit.get(account_name)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.cap","title":"<code>cap(options, unrealized_account)</code>","text":"<p>Transfer Income and Expenses, add conversions and unrealized gains.</p> <p>Parameters:</p> Name Type Description Default <code>options</code> <code>BeancountOptions</code> <p>The Beancount options.</p> required <code>unrealized_account</code> <code>str</code> <p>The name of the account to post unrealized gains to (as a subaccount of Equity).</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def cap(self, options: BeancountOptions, unrealized_account: str) -&gt; None:\n    \"\"\"Transfer Income and Expenses, add conversions and unrealized gains.\n\n    Args:\n        options: The Beancount options.\n        unrealized_account: The name of the account to post unrealized\n            gains to (as a subaccount of Equity).\n    \"\"\"\n    equity = options[\"name_equity\"]\n    conversions = CounterInventory(\n        {\n            (currency, None): -number\n            for currency, number in AT_COST.apply(\n                self.get(\"\").balance_children\n            ).items()\n        },\n    )\n\n    # Add conversions\n    self.insert(\n        equity + \":\" + options[\"account_current_conversions\"],\n        conversions,\n    )\n\n    # Insert unrealized gains.\n    self.insert(\n        equity + \":\" + unrealized_account,\n        -self.get(\"\").balance_children,\n    )\n\n    # Transfer Income and Expenses\n    self.insert(\n        equity + \":\" + options[\"account_current_earnings\"],\n        self.get(options[\"name_income\"]).balance_children,\n    )\n    self.insert(\n        equity + \":\" + options[\"account_current_earnings\"],\n        self.get(options[\"name_expenses\"]).balance_children,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.watcher","title":"<code>watcher</code>","text":"<p>A simple file and folder watcher.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase","title":"<code>WatcherBase</code>","text":"<p>               Bases: <code>ABC</code></p> <p>ABC for rustfava ledger file watchers.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class WatcherBase(abc.ABC):\n    \"\"\"ABC for rustfava ledger file watchers.\"\"\"\n\n    last_checked: int\n    \"\"\"Timestamp of the latest change noticed by the file watcher.\"\"\"\n\n    last_notified: int\n    \"\"\"Timestamp of the latest change that the watcher was notified of.\"\"\"\n\n    @abc.abstractmethod\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\n\n        Args:\n            files: A list of file paths.\n            folders: A list of paths to folders.\n        \"\"\"\n\n    def check(self) -&gt; bool:\n        \"\"\"Check for changes.\n\n        Returns:\n            `True` if there was a file change in one of the files or folders,\n            `False` otherwise.\n        \"\"\"\n        latest_mtime = max(self._get_latest_mtime(), self.last_notified)\n        has_higher_mtime = latest_mtime &gt; self.last_checked\n        if has_higher_mtime:\n            self.last_checked = latest_mtime\n        return has_higher_mtime\n\n    def notify(self, path: Path) -&gt; None:\n        \"\"\"Notify the watcher of a change to a path.\"\"\"\n        try:\n            change_mtime = Path(path).stat().st_mtime_ns\n        except FileNotFoundError:\n            change_mtime = max(self.last_notified, self.last_checked) + 1\n        self.last_notified = max(self.last_notified, change_mtime)\n\n    @abc.abstractmethod\n    def _get_latest_mtime(self) -&gt; int:\n        \"\"\"Get the latest change mtime.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.last_checked","title":"<code>last_checked</code>  <code>instance-attribute</code>","text":"<p>Timestamp of the latest change noticed by the file watcher.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase.last_notified","title":"<code>last_notified</code>  <code>instance-attribute</code>","text":"<p>Timestamp of the latest change that the watcher was notified of.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase.update","title":"<code>update(files, folders)</code>  <code>abstractmethod</code>","text":"<p>Update the folders/files to watch.</p> <p>Parameters:</p> Name Type Description Default <code>files</code> <code>Iterable[Path]</code> <p>A list of file paths.</p> required <code>folders</code> <code>Iterable[Path]</code> <p>A list of paths to folders.</p> required Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>@abc.abstractmethod\ndef update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\n\n    Args:\n        files: A list of file paths.\n        folders: A list of paths to folders.\n    \"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.check","title":"<code>check()</code>","text":"<p>Check for changes.</p> <p>Returns:</p> Type Description <code>bool</code> <p><code>True</code> if there was a file change in one of the files or folders,</p> <code>bool</code> <p><code>False</code> otherwise.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def check(self) -&gt; bool:\n    \"\"\"Check for changes.\n\n    Returns:\n        `True` if there was a file change in one of the files or folders,\n        `False` otherwise.\n    \"\"\"\n    latest_mtime = max(self._get_latest_mtime(), self.last_notified)\n    has_higher_mtime = latest_mtime &gt; self.last_checked\n    if has_higher_mtime:\n        self.last_checked = latest_mtime\n    return has_higher_mtime\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.notify","title":"<code>notify(path)</code>","text":"<p>Notify the watcher of a change to a path.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def notify(self, path: Path) -&gt; None:\n    \"\"\"Notify the watcher of a change to a path.\"\"\"\n    try:\n        change_mtime = Path(path).stat().st_mtime_ns\n    except FileNotFoundError:\n        change_mtime = max(self.last_notified, self.last_checked) + 1\n    self.last_notified = max(self.last_notified, change_mtime)\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatchfilesWatcher","title":"<code>WatchfilesWatcher</code>","text":"<p>               Bases: <code>WatcherBase</code></p> <p>A file and folder watcher using the watchfiles library.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class WatchfilesWatcher(WatcherBase):\n    \"\"\"A file and folder watcher using the watchfiles library.\"\"\"\n\n    def __init__(self) -&gt; None:\n        self.last_checked = 0\n        self.last_notified = 0\n        self._paths: tuple[set[Path], set[Path]] | None = None\n        self._watchers: tuple[_WatchfilesThread, _WatchfilesThread] | None = (\n            None\n        )\n\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\"\"\"\n        files_set = {p.absolute() for p in files if p.exists()}\n        folders_set = {p.absolute() for p in folders if p.is_dir()}\n        new_paths = (files_set, folders_set)\n        if self._watchers and new_paths == self._paths:\n            self.check()\n            return\n        self._paths = new_paths\n        if self._watchers:\n            self._watchers[0].stop()\n            self._watchers[1].stop()\n        self._watchers = (\n            _FilesWatchfilesThread(files_set, self.last_checked),\n            _WatchfilesThread(folders_set, self.last_checked, recursive=True),\n        )\n        self._watchers[0].start()\n        self._watchers[1].start()\n        self.check()\n\n    def __enter__(self) -&gt; None:\n        pass\n\n    def __exit__(\n        self,\n        exc_type: type[BaseException] | None,\n        exc_value: BaseException | None,\n        traceback: types.TracebackType | None,\n    ) -&gt; None:\n        if self._watchers:\n            self._watchers[0].stop()\n            self._watchers[1].stop()\n\n    def _get_latest_mtime(self) -&gt; int:\n        return (\n            max(self._watchers[0].mtime, self._watchers[1].mtime)\n            if self._watchers\n            else 0\n        )\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatchfilesWatcher.update","title":"<code>update(files, folders)</code>","text":"<p>Update the folders/files to watch.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\"\"\"\n    files_set = {p.absolute() for p in files if p.exists()}\n    folders_set = {p.absolute() for p in folders if p.is_dir()}\n    new_paths = (files_set, folders_set)\n    if self._watchers and new_paths == self._paths:\n        self.check()\n        return\n    self._paths = new_paths\n    if self._watchers:\n        self._watchers[0].stop()\n        self._watchers[1].stop()\n    self._watchers = (\n        _FilesWatchfilesThread(files_set, self.last_checked),\n        _WatchfilesThread(folders_set, self.last_checked, recursive=True),\n    )\n    self._watchers[0].start()\n    self._watchers[1].start()\n    self.check()\n</code></pre>"},{"location":"api/#rustfava.core.watcher.Watcher","title":"<code>Watcher</code>","text":"<p>               Bases: <code>WatcherBase</code></p> <p>A simple file and folder watcher.</p> <p>For folders, only checks mtime of the folder and all subdirectories. So a file change won't be noticed, but only new/deleted files.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class Watcher(WatcherBase):\n    \"\"\"A simple file and folder watcher.\n\n    For folders, only checks mtime of the folder and all subdirectories.\n    So a file change won't be noticed, but only new/deleted files.\n    \"\"\"\n\n    def __init__(self) -&gt; None:\n        self.last_checked = 0\n        self.last_notified = 0\n        self._files: Sequence[Path] = []\n        self._folders: Sequence[Path] = []\n\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\"\"\"\n        self._files = list(files)\n        self._folders = list(folders)\n        self.check()\n\n    def _mtimes(self) -&gt; Iterable[int]:\n        for path in self._files:\n            try:\n                yield path.stat().st_mtime_ns\n            except FileNotFoundError:\n                yield max(self.last_notified, self.last_checked) + 1\n        for path in self._folders:\n            for dirpath, _, _ in walk(path):\n                yield Path(dirpath).stat().st_mtime_ns\n\n    def _get_latest_mtime(self) -&gt; int:\n        return max(self._mtimes())\n</code></pre>"},{"location":"api/#rustfava.core.watcher.Watcher.update","title":"<code>update(files, folders)</code>","text":"<p>Update the folders/files to watch.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\"\"\"\n    self._files = list(files)\n    self._folders = list(folders)\n    self.check()\n</code></pre>"},{"location":"api/#application","title":"Application","text":""},{"location":"api/#rustfava.application","title":"<code>rustfava.application</code>","text":"<p>rustfava's main WSGI application.</p> <p>you can use <code>create_app</code> to create a rustfava WSGI app for a given list of files. To start a simple server::</p> <pre><code>from rustfava.application import create_app\n\napp = create_app(['/path/to/file.beancount'])\napp.run('localhost', 5000)\n</code></pre>"},{"location":"api/#rustfava.application.static_url","title":"<code>static_url(filename)</code>","text":"<p>Return a static url with an mtime query string for cache busting.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def static_url(filename: str) -&gt; str:\n    \"\"\"Return a static url with an mtime query string for cache busting.\"\"\"\n    file_path = Path(__file__).parent / \"static\" / filename\n    try:\n        mtime = str(int(file_path.stat().st_mtime))\n    except FileNotFoundError:\n        mtime = \"0\"\n    return url_for(\"static\", filename=filename, mtime=mtime)\n</code></pre>"},{"location":"api/#rustfava.application.url_for","title":"<code>url_for(endpoint, **values)</code>","text":"<p>Wrap flask.url_for using a cache.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def url_for(endpoint: str, **values: str) -&gt; str:\n    \"\"\"Wrap flask.url_for using a cache.\"\"\"\n    _inject_filters(endpoint, values)\n    return _cached_url_for(endpoint, **values)\n</code></pre>"},{"location":"api/#rustfava.application.translations","title":"<code>translations()</code>","text":"<p>Get translations catalog.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def translations() -&gt; dict[str, str]:\n    \"\"\"Get translations catalog.\"\"\"\n    catalog = get_translations()._catalog  # noqa: SLF001\n    return {k: v for k, v in catalog.items() if isinstance(k, str) and k}\n</code></pre>"},{"location":"api/#rustfava.application.create_app","title":"<code>create_app(files, *, load=False, incognito=False, read_only=False, poll_watcher=False)</code>","text":"<p>Create a rustfava Flask application.</p> <p>Parameters:</p> Name Type Description Default <code>files</code> <code>Iterable[Path | str]</code> <p>The list of Beancount files (paths).</p> required <code>load</code> <code>bool</code> <p>Whether to load the Beancount files directly.</p> <code>False</code> <code>incognito</code> <code>bool</code> <p>Whether to run in incognito mode.</p> <code>False</code> <code>read_only</code> <code>bool</code> <p>Whether to run in read-only mode.</p> <code>False</code> <code>poll_watcher</code> <code>bool</code> <p>Whether to use old poll watcher</p> <code>False</code> Source code in <code>src/rustfava/application.py</code> <pre><code>def create_app(\n    files: Iterable[Path | str],\n    *,\n    load: bool = False,\n    incognito: bool = False,\n    read_only: bool = False,\n    poll_watcher: bool = False,\n) -&gt; Flask:\n    \"\"\"Create a rustfava Flask application.\n\n    Arguments:\n        files: The list of Beancount files (paths).\n        load: Whether to load the Beancount files directly.\n        incognito: Whether to run in incognito mode.\n        read_only: Whether to run in read-only mode.\n        poll_watcher: Whether to use old poll watcher\n    \"\"\"\n    fava_app = Flask(\"rustfava\")\n    fava_app.register_blueprint(json_api, url_prefix=\"/&lt;bfile&gt;/api\")\n    fava_app.json = RustfavaJSONProvider(fava_app)\n    fava_app.app_ctx_globals_class = Context  # type: ignore[assignment]\n    _setup_template_config(fava_app, incognito=incognito)\n    _setup_babel(fava_app)\n    _setup_filters(fava_app, read_only=read_only)\n    _setup_routes(fava_app)\n\n    fava_app.config[\"HAVE_EXCEL\"] = HAVE_EXCEL\n    fava_app.config[\"BEANCOUNT_FILES\"] = [str(f) for f in files]\n    fava_app.config[\"INCOGNITO\"] = incognito\n    fava_app.config[\"LEDGERS\"] = _LedgerSlugLoader(\n        fava_app, load=load, poll_watcher=poll_watcher\n    )\n\n    return fava_app\n</code></pre>"},{"location":"api/#cli","title":"CLI","text":""},{"location":"api/#rustfava.cli","title":"<code>rustfava.cli</code>","text":"<p>The command-line interface for rustfava.</p>"},{"location":"api/#rustfava.cli.main","title":"<code>main(*, filenames=(), port=5000, host='localhost', prefix=None, incognito=False, read_only=False, debug=False, profile=False, profile_dir=None, poll_watcher=False)</code>","text":"<p>Start Rustfava for FILENAMES on http://:. <p>If the <code>BEANCOUNT_FILE</code> environment variable is set, Rustfava will use the files (delimited by ';' on Windows and ':' on POSIX) given there in addition to FILENAMES.</p> <p>Note you can also specify command-line options via environment variables with the <code>RUSTFAVA_</code> prefix. For example, <code>--host=0.0.0.0</code> is equivalent to setting the environment variable <code>RUSTFAVA_HOST=0.0.0.0</code>.</p> Source code in <code>src/rustfava/cli.py</code> <pre><code>@click.command(context_settings={\"auto_envvar_prefix\": \"RUSTFAVA\"})\n@click.argument(\n    \"filenames\",\n    nargs=-1,\n    type=click.Path(exists=True, dir_okay=False, resolve_path=True),\n)\n@click.option(\n    \"-p\",\n    \"--port\",\n    type=int,\n    default=5000,\n    show_default=True,\n    metavar=\"&lt;port&gt;\",\n    help=\"The port to listen on.\",\n)\n@click.option(\n    \"-H\",\n    \"--host\",\n    type=str,\n    default=\"localhost\",\n    show_default=True,\n    metavar=\"&lt;host&gt;\",\n    help=\"The host to listen on.\",\n)\n@click.option(\"--prefix\", type=str, help=\"Set an URL prefix.\")\n@click.option(\n    \"--incognito\",\n    is_flag=True,\n    help=\"Run in incognito mode and obscure all numbers.\",\n)\n@click.option(\n    \"--read-only\",\n    is_flag=True,\n    help=\"Run in read-only mode, disable any change through rustfava.\",\n)\n@click.option(\"-d\", \"--debug\", is_flag=True, help=\"Turn on debugging.\")\n@click.option(\n    \"--profile\",\n    is_flag=True,\n    help=\"Turn on profiling. Implies --debug.\",\n)\n@click.option(\n    \"--profile-dir\",\n    type=click.Path(),\n    help=\"Output directory for profiling data.\",\n)\n@click.option(\n    \"--poll-watcher\", is_flag=True, help=\"Use old polling-based watcher.\"\n)\n@click.version_option(package_name=\"rustfava\")\ndef main(  # noqa: PLR0913\n    *,\n    filenames: tuple[str, ...] = (),\n    port: int = 5000,\n    host: str = \"localhost\",\n    prefix: str | None = None,\n    incognito: bool = False,\n    read_only: bool = False,\n    debug: bool = False,\n    profile: bool = False,\n    profile_dir: str | None = None,\n    poll_watcher: bool = False,\n) -&gt; None:  # pragma: no cover\n    \"\"\"Start Rustfava for FILENAMES on http://&lt;host&gt;:&lt;port&gt;.\n\n    If the `BEANCOUNT_FILE` environment variable is set, Rustfava will use the\n    files (delimited by ';' on Windows and ':' on POSIX) given there in\n    addition to FILENAMES.\n\n    Note you can also specify command-line options via environment variables\n    with the `RUSTFAVA_` prefix. For example, `--host=0.0.0.0` is equivalent to\n    setting the environment variable `RUSTFAVA_HOST=0.0.0.0`.\n    \"\"\"\n    all_filenames = _add_env_filenames(filenames)\n\n    if not all_filenames:\n        raise NoFileSpecifiedError\n\n    from rustfava.application import create_app\n\n    app = create_app(\n        all_filenames,\n        incognito=incognito,\n        read_only=read_only,\n        poll_watcher=poll_watcher,\n    )\n\n    if prefix:\n        from werkzeug.middleware.dispatcher import DispatcherMiddleware\n\n        from rustfava.util import simple_wsgi\n\n        app.wsgi_app = DispatcherMiddleware(  # type: ignore[method-assign]\n            simple_wsgi,\n            {prefix: app.wsgi_app},\n        )\n\n    # ensure that cheroot does not use IP6 for localhost\n    host = \"127.0.0.1\" if host == \"localhost\" else host\n    # Debug mode if profiling is active\n    debug = debug or profile\n\n    click.secho(f\"Starting Fava on http://{host}:{port}\", fg=\"green\")\n    if not debug:\n        from cheroot.wsgi import Server\n\n        server = Server((host, port), app)\n        try:\n            server.start()\n        except KeyboardInterrupt:\n            click.echo(\"Keyboard interrupt received: stopping Fava\", err=True)\n            server.stop()\n        except OSError as error:\n            if \"No socket could be created\" in str(error):\n                raise AddressInUse(port) from error\n            raise click.Abort from error\n    else:\n        from werkzeug.middleware.profiler import ProfilerMiddleware\n\n        from rustfava.util import setup_debug_logging\n\n        setup_debug_logging()\n        if profile:\n            app.wsgi_app = ProfilerMiddleware(  # type: ignore[method-assign]\n                app.wsgi_app,\n                restrictions=(30,),\n                profile_dir=profile_dir or None,\n            )\n\n        app.jinja_env.auto_reload = True\n        try:\n            app.run(host, port, debug)\n        except OSError as error:\n            if error.errno == errno.EADDRINUSE:\n                raise AddressInUse(port) from error\n            raise\n</code></pre>"},{"location":"changelog/","title":"Changelog","text":""},{"location":"changelog/#rustfava-2025","title":"Rustfava (2025)","text":"<p>This is a fork of Fava that replaces the Python Beancount parser and beanquery with rustledger, a Rust-based implementation of the Beancount format compiled to WebAssembly.</p> <p>Key changes from Fava:</p> <ul> <li>No Beancount dependency: Rustfava uses rustledger for parsing, so you   don't need to install Python's beancount package. Your existing Beancount   files are fully compatible.</li> <li>Query support: BQL queries are now handled by rustledger's built-in query   engine instead of beanquery. The query syntax remains largely compatible.</li> <li>Optional beancount compatibility: If you need to use Beancount plugins or   the import system, install with <code>uv pip install rustfava[beancount-compat]</code>.</li> </ul>"},{"location":"changelog/#v130-2024-12-29","title":"v1.30 (2024-12-29)","text":"<p>Note: This entry describes the original Fava release. Rustfava is based on this version with the rustledger integration.</p> <p>Under the hood, this also upgrades Svelte (the framework used for the frontend parts) to version 5.</p>"},{"location":"changelog/#v129-2024-10-09","title":"v1.29 (2024-10-09)","text":"<p>With this release, query results are now rendered in the frontend. The templates for HTML rendering are still available but extension authors are encouraged to switch, see the statistics report for an example how this can be done. This release adds CSS styles for dark-mode. Numerical comparisons on the units, price or cost are now possible in rustfava filters. As the watchfiles based watcher might not work correctly in some setups with network file systems, you can switch to the (slower) polling based watcher as well. The <code>default-file</code> option, if set, is now considered instead of the \"main\" file when inserting an entry.</p>"},{"location":"changelog/#v128-2024-07-07","title":"v1.28 (2024-07-07)","text":"<p>This release accumulates a couple of minor fixes and improvements. Under the hood, the file change detection is now powered by watchfiles instead of polling, which is more performant.</p>"},{"location":"changelog/#v127-2024-01-06","title":"v1.27 (2024-01-06)","text":"<p>It is now possible to convert to a sequence of currencies. Posting metadata is now supported in the entry forms. The editor should now be a bit more performant as the previous parses will be reused better. For compatibility with extensions using them, the Javascript and CSS for the \"old\" account trees has been re-added.</p>"},{"location":"changelog/#v126-2023-09-04","title":"v1.26 (2023-09-04)","text":"<p>This release brings various improvements to the charts, like allowing the toggling of currencies by clicking on their names in the chart legend. The account balance trees in rustfava are now rendered in the frontend, fixing some minor bugs in the process and easing maintenance. rustfava extensions can now also provide their own endpoints.</p>"},{"location":"changelog/#v125-2023-07-17","title":"v1.25 (2023-07-17)","text":"<p>With this release, extensions can now ship Javascript code to run in the frontend. The editor in rustfava now uses a tree-sitter grammar to obtain a full parsed syntax tree, which makes editor functionality more maintainable and should improve the autocompletion. The Flask WSGI app is now created using the application factory pattern - users who use the rustfava WSGI app directly should switch from <code>rustfava.application.app</code> to the <code>create_app</code> function in <code>rustfava.application</code>. This release also drops support for Python 3.7 and contains a couple of minor fixes and changes, in particular various styling fixes.</p>"},{"location":"changelog/#v124-2023-02-21","title":"v1.24 (2023-02-21)","text":"<p>With this release, the rendering of some report like the documents report has been moved completely to the frontend, which should be slightly more perfomant and easier to maintain. This release also contains a couple of minor fixes and changes.</p>"},{"location":"changelog/#v123-2022-10-15","title":"v1.23 (2022-10-15)","text":"<p>This release accumulates a couple of minor fixes and changes.</p>"},{"location":"changelog/#v122-2022-07-03","title":"v1.22 (2022-07-03)","text":"<p>This release brings stacked bar charts, which are a great way to visualise income broken down per account per month for example. The inferred display precision for currencies is now also used in the frontend and can be overwritten with commodity metadata.</p> <p>The <code>journal-show</code>, <code>journal-show-document</code>, and <code>journal-show-transaction</code> rustfava-options have been removed. The types of entries that to show in the journal are now automatically stored in the browser of the user (in localStorage).</p> <p>As usual, this release also includes a couple of bug fixes and minor improvements. To avoid some race conditions and improve perfomance, the per-file Ledger class is not filtered anymore in-place but rather the filtered data is generated per request - some extensions might have to adjust for this and use <code>g.filtered</code> instead of <code>ledger</code> for some attributes.</p>"},{"location":"changelog/#v121-2022-02-06","title":"v1.21 (2022-02-06)","text":"<p>This release of rustfava drops support for Python 3.6. It mainly consists of various small improvements and fixes.</p>"},{"location":"changelog/#v1201-2021-09-22","title":"v1.20.1 (2021-09-22)","text":"<p>Bugfix release to fix loading of translations for the browser-rendered frontend parts.</p>"},{"location":"changelog/#v120-2021-09-19","title":"v1.20 (2021-09-19)","text":"<p>In this release, the document page now shows counts in the account tree and allows collapsing of accounts in the tree. Parts of the charts in the future are now desaturated. This release contains a couple of bug fixes as usual.</p>"},{"location":"changelog/#v119-2021-05-18","title":"v1.19 (2021-05-18)","text":"<p>The <code>conversion</code> and <code>interval</code> options have been removed. Their functionality can be achieved with the new <code>default-page</code> option. The editor components have been completely reworked, include autocompletion in more places and are now based on version 6 of CodeMirror. An option <code>invert-income-liabilities-equity</code> has been added to invert the numbers of those accounts on the income statement and the balance sheet. This release also adds a Bulgarian translation and features various smaller improvements and fixes as usual.</p>"},{"location":"changelog/#v118-2021-01-16","title":"v1.18 (2021-01-16)","text":"<p>This release contains couple of small improvements and various bug fixes.</p>"},{"location":"changelog/#v117-2020-11-15","title":"v1.17 (2020-11-15)","text":"<p>This release adds a document preview to the import page, as well as support for Python 3.9. It also fixes a couple of bugs.</p>"},{"location":"changelog/#v116-2020-10-18","title":"v1.16 (2020-10-18)","text":"<p>This release brings area charts as an alternative option to view the various line charts in rustfava and a Catalan translation for rustfava. There is also now an option to set the indentation of inserted Beancount entries. As usual this release also includes various minor fixes and improvements.</p>"},{"location":"changelog/#v115-2020-05-30","title":"v1.15 (2020-05-30)","text":"<p>This release accumulates various minor fixes and improvements, for example the setting of filters from payees and metadata in the Journal report.</p>"},{"location":"changelog/#v114-2020-02-16","title":"v1.14 (2020-02-16)","text":"<p>This is mainly a bugfix release to fix compatibility with one of the main dependencies (werkzeug). Also, a <code>default-conversion</code> option was added, which allows setting a default conversion.</p>"},{"location":"changelog/#v113-2020-02-01","title":"v1.13 (2020-02-01)","text":"<p>Rustfava can now display charts for BQL queries - if they have exactly two columns with the first being a date or string and the second an inventory, then a line chart or treemap chart is shown on the query page.</p>"},{"location":"changelog/#v112-2019-12-03","title":"v1.12 (2019-12-03)","text":"<p>Apart from plenty of bug fixes, this release mainly contains improvements to the forms to add transactions: postings can now be dragged and the full cost syntax of Beancount should supported.</p>"},{"location":"changelog/#v111-2019-08-20","title":"v1.11 (2019-08-20)","text":"<p>The import page of rustfava has been reworked - it now supports moving files to the documents folder and the import process should be a bit more interactive. This release also contains various fixes and a new <code>collapse-pattern</code> option to collapse accounts in account trees based on regular expressions (and replaces the use of the <code>rustfava-collapse-account</code> metadata entry).</p> <p>Other changes:</p> <ul> <li>Command line flags can be specified by setting environment variables.</li> <li>A Taiwanese translation has been added.</li> </ul>"},{"location":"changelog/#v110-2019-01-31","title":"v1.10 (2019-01-31)","text":"<p>This release contains mostly smaller changes and fixes. In particular, the net worth chart will now follow the selected conversion.</p>"},{"location":"changelog/#v19-2018-10-08","title":"v1.9 (2018-10-08)","text":"<p>In this release, the click behaviour has been updated to allow filtering for payees. The entry input forms now allow inputting prices and costs. As always, bugs have been fixed.</p>"},{"location":"changelog/#v18-2018-07-25","title":"v1.8 (2018-07-25)","text":"<p>The journal design has been updated and should now have a clearer structure. Starting with this version, there will not be any more GUI releases of rustfava. The GUI broke frequently and does not seem to worth the maintenance burden.</p> <p>Other changes:</p> <ul> <li>When downloading documents, the original filename will be used.</li> <li><code>any()</code> and <code>all()</code> functions have been added to the filter syntax to allow   filtering entries by properties of their postings.</li> <li>As always, bugs have been fixed.</li> </ul>"},{"location":"changelog/#v17-2018-03-09","title":"v1.7 (2018-03-09)","text":"<p>The entry filters have been reworked in this release and should now support for more flexible filtering of the entries. See the help page on how the new syntax works. Also, when completing the payee in the transaction form, the postings of the last transaction for this payee will be auto-filled.</p> <p>Other changes:</p> <ul> <li>The rustfava-option to hide the charts has been removed. This is now tracked in   the page URL.</li> <li>As always, bugs have been fixed.</li> </ul>"},{"location":"changelog/#v16-2017-10-06","title":"v1.6 (2017-10-06)","text":"<p>This is a release with various small changes and mainly some speed improvements to the Balance Sheet and the net worth calculation. Also, if 'At Value' is selected, the current unrealized gain is shown in parentheses in the Balance Sheet.</p> <p>Other changes:</p> <ul> <li>The currently filtered entries can now be exported from the Journal page.</li> <li>The CLI now has a <code>--version</code> flag.</li> </ul>"},{"location":"changelog/#v15-2017-07-23","title":"v1.5 (2017-07-23)","text":"<p>Rustfava now has an interface to edit single entries. Clicking on the entry date in the Journal will open an overlay that shows the entry context and allows editing just the lines of that entry.</p> <p>Other changes:</p> <ul> <li>The source editor now has a menu that gives access to editor commands like   \"fold all\".</li> <li>Entries with matching tags or links can now be excluded with <code>-#tag</code>.</li> <li>The keyboard shortcuts are now displayed in-place.</li> <li>The <code>incognito</code> option has been removed and replaced with a <code>--incognito</code>   command line switch.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v14-2017-05-14","title":"v1.4 (2017-05-14)","text":"<p>Rustfava now provides an interface for Beancount's import system that allows you to import transactions from your bank for example.</p> <p>Rustfava can now show your balances at market value or convert them to a single currency if your file contains the necessary price information.</p> <p>We now also provide a compiled GUI version of rustfava for Linux and macOS. This version might still be a bit buggy so any feedback/help on it is very welcome.</p> <p>Other changes:</p> <ul> <li>The <code>insert-entry</code> option can be used to control where transactions are   inserted.</li> <li>The transaction form now accepts tags and links in the narration field.</li> <li>Budgets are now accumulated over all children where appropriate.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v13-2017-03-15","title":"v1.3 (2017-03-15)","text":"<p>The translations of rustfava are on POEditor.com, which has helped us get translations in five more languages: Chinese (simplified), Dutch, French, Portuguese, and Spanish. A big thank you to the new translators!</p> <p>The transaction form has been improved, it now supports adding metadata and the suggestions will be ranked by how often and recently they occur (using exponential decay).</p> <p>The Query page supports all commands of the <code>bean-query</code> shell and shares its history of recently used queries.</p> <p>Rustfava has gained a basic extension mechanism. Extensions allow you to run hooks at various points, e.g., after adding a transaction. They are specified using the <code>extensions</code> option and for an example, see the <code>rustfava.ext.auto_commit</code> extension.</p> <p>Other changes:</p> <ul> <li>The default sort order in journals has been reversed so that the most recent   entries come first.</li> <li>The new <code>incognito</code> option can be used to obscure all numbers.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v12-2016-12-25","title":"v1.2 (2016-12-25)","text":"<p>You can now add transactions from within rustfava. The form supports autocompletion for most fields.</p> <p>Rustfava will now show a little bubble in the sidebar for the number of events in the next week. This can be configured with the <code>upcoming-events</code> option.</p> <p>Other changes:</p> <ul> <li>The payee filter can filter by regular expression.</li> <li>The tag filter can filter for links, too.</li> <li>There's a nice spinning indicator during asynchronous page loads.</li> <li>The Journal shows little indicators for metadata.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v11-2016-11-19","title":"v1.1 (2016-11-19)","text":"<p>You can now upload documents by dropping them onto transactions, which will also add the file path as <code>statement</code> metadata to the transaction. rustfava also ships with a plugin to link these transactions with the generated documents. See the help pages for details.</p> <p>This is the first release for which we provide compiled binaries (for macOS and Linux). These do not have any dependencies and can simply be executed from the terminal.</p> <p>Other changes:</p> <ul> <li>The bar charts on account pages now also show budgets.</li> <li>The Journal can now be sorted by date, flag and narration.</li> <li>Rustfava now has a Russian translation.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v10-2016-10-19","title":"v1.0 (2016-10-19)","text":"<p>This is a major new release that includes too many improvements and changes to list. Some highlights:</p> <ul> <li>The layout has been tweaked and we use some nicer fonts.</li> <li>Rustfava looks and works much better on smaller screens.</li> <li>Rustfava loads most pages asynchronously, so navigating rustfava is much faster and   responsive.</li> </ul> <p>rustfava's configuration is not read from a configuration file anymore but can rather be specified using custom entries in the Beancount file. Some options have also been removed or renamed, so check rustfava's help page on the available options when upgrading from v0.3.0.</p> <p>There have been many changes under the hood to improve rustfava's codebase and a lot of bugs have been squashed.</p>"},{"location":"changelog/#v030-2016-03-24","title":"v0.3.0 (2016-03-24)","text":""},{"location":"changelog/#additions","title":"Additions","text":"<ul> <li>Support for switching between multiple beancount files.</li> <li>New sunburst charts.</li> <li>Add \"Clear filter\" button when filters are active.</li> <li>Simple budgeting functionality in the Account view. See help pages on how to   use budgets.</li> <li>German translation.</li> <li>The Beancount is now being reloaded when it is saved in the Source Editor.</li> <li>New Journal filter controls.</li> <li>Tree-tables are now displayed in a hierarchical way.</li> </ul>"},{"location":"changelog/#changes","title":"Changes","text":"<ul> <li>All charts are now rendered with d3.js.</li> <li>The title of a page is now shown in the header to save screen space.</li> <li>Changed shortcut for Journal from <code>g g</code> to <code>g j</code> as the Journal was   renamed from \"General Journal\" to \"Journal\".</li> </ul>"},{"location":"changelog/#new-configuration-options","title":"New configuration options","text":"<ul> <li><code>language</code>: The language to use. Valid languages are <code>\"en\"</code> and <code>\"de\"</code>   (default: <code>\"en\"</code>).</li> <li><code>treemaps-show-negative-numbers</code> was removed.</li> </ul>"},{"location":"changelog/#fixes","title":"Fixes","text":"<ul> <li>Commodity prices are now filtered when a Time filter is enabled.</li> <li>Some improvements to the help pages.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v026-2016-03-20","title":"v0.2.6 (2016-03-20)","text":""},{"location":"changelog/#additions_1","title":"Additions","text":"<ul> <li>There are now more interval options available for charts and the account   balances report. The interval can be selected from a dropdown next to the   charts.</li> <li>Show metadata for postings in the Journal.</li> <li>The editor now supports org-mode style folding.</li> <li>Show colored dots for all the postings of a transaction in the Journal   report. This way flagged postings can be quickly spotted.</li> <li>Add keyboard shortcuts for save to source editor.</li> </ul>"},{"location":"changelog/#changes_1","title":"Changes","text":"<ul> <li>Use beancount's DisplayContext to determine the correct precision at which to   render numbers.</li> <li>Improve the way that query results are serialized to XLS etc.</li> <li>Show inverse rates for pairs of operating currencies on the commodities   report.</li> <li>Use Click for the CLI and check if beancount file exists on startup.</li> <li>Hide closed accounts in tree tables. Also see new configuration option below.</li> </ul>"},{"location":"changelog/#new-configuration-options_1","title":"New configuration options","text":"<ul> <li><code>editor-strip-trailing-whitespace</code> to enable trimming of trailing   whitespace in the Source editor (default: \"false\").</li> <li><code>show-closed-accounts</code> to show closed accounts in tree tables, for example   on the balance sheet (default: \"false\").</li> <li><code>show-accounts-with-zero-balance</code> to show accounts with a balance of zero   in tree tables (default: \"true\").</li> <li><code>show-accounts-with-zero-transactions</code> to show accounts with no   transactions in tree tables (default: \"true\").</li> </ul>"},{"location":"changelog/#fixes_1","title":"Fixes","text":"<ul> <li>Fixed a bug where the months would be off by one for the interval reports.</li> <li>Fix the net worth report for more than one currency.</li> <li>Some improvements to the help pages.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v025-2016-02-28","title":"v0.2.5 (2016-02-28)","text":"<p>Bump release to remove unused draft code.</p>"},{"location":"changelog/#v024-2016-02-18","title":"v0.2.4 (2016-02-18)","text":""},{"location":"changelog/#additions_2","title":"Additions","text":"<ul> <li>Added missing Holdings views compared to <code>bean-web</code>.</li> <li>Custom queries are now shown in sidebar.</li> <li>The user settings file is now editable in the Source editor.</li> <li>Added second theme.</li> <li>Added Help pages.</li> <li>Query results can now be downloaded as CSV, XLS, XLSX and ODS.</li> <li>Documents can now be uploaded by dragging and dropping files over an Account   name on the Account page and all tree-tables.</li> <li>Journal can now be filtered by transaction type.</li> </ul>"},{"location":"changelog/#changes_2","title":"Changes","text":"<ul> <li>The uptodate-indicator is now shown everywhere by default, but only enabled   for accounts that have the metadata <code>rustfava-uptodate-indication: \"True\"</code> set   on their <code>open</code>-directives.</li> <li>Speedier Journal rendering.</li> <li>Only basenames will be shown for documents in the Journal.</li> <li>Slightly reordered the sidebar menu.</li> <li>Minor UI tweaks.</li> </ul>"},{"location":"changelog/#new-configuration-options_2","title":"New configuration options","text":"<ul> <li><code>sidebar-show-queries</code>: The maximum number of custom queries to show in the   sidebar (default: 5).</li> <li><code>theme</code>: The theme to use. Valid themes are <code>\"default\"</code> and <code>\"alternative\"</code>   (default: <code>\"default\"</code>).</li> <li><code>editor-print-margin-column</code>: Set the column for the print margin in the   Source editor (default: 60).</li> <li><code>uptodate-indicator-show-everywhere</code> (default: \"true\"). See Changes above.</li> </ul>"},{"location":"changelog/#removed-configuration-options","title":"Removed configuration options","text":"<ul> <li><code>uptodate-indicator-exclude-accounts</code>, see Changes above.</li> </ul>"},{"location":"changelog/#fixes_2","title":"Fixes","text":"<ul> <li>Fixed Net worth calculation.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v023-2016-02-15","title":"v0.2.3 (2016-02-15)","text":"<p>Bumped version to communicate that installing via <code>pip install</code> now works, all requirements included.</p>"},{"location":"changelog/#earlier-versions","title":"Earlier Versions","text":"<p>It was not possible to install any of the earlier versions only using <code>pip</code> and you may consult the git log for earlier changes. The first commit in the git repository was on December 4th, 2015.</p>"},{"location":"deployment/","title":"Deployment","text":"<p>There are a number of deployment options for persistently running rustfava on the Web, depending on your Web server and WSGI deployment choices. Below you can find some examples.</p>"},{"location":"deployment/#apache-with-reverse-proxy","title":"Apache with reverse proxy","text":"<p>Apache configuration:</p> <pre><code>ProxyPass \"/rustfava\" \"http://localhost:5000/rustfava\"\n</code></pre> <p>The above will make rustfava accessible at the <code>/rustfava</code> URL and proxy requests arriving there to a locally running rustfava. To make rustfava work properly in that context, you should run it using the <code>--prefix</code> command line option, like this:</p> <pre><code>rustfava --prefix /rustfava /path/to/your/main.beancount\n</code></pre> <p>To have rustfava run automatically at boot and manageable as a system service you might want to define a systemd unit file for it, for example:</p> <pre><code>[Unit]\nDescription=Rustfava Web UI for Beancount\n\n[Service]\nType=simple\nExecStart=/usr/bin/rustfava --host localhost --port 5000 --prefix /rustfava /path/to/your/main.beancount\nUser=your-user\n</code></pre>"},{"location":"development/","title":"Development","text":""},{"location":"development/#setting-up-a-development-environment","title":"Setting up a development environment","text":"<p>If you want to hack on rustfava or run the latest development version, make sure you have recent enough versions of the following installed (ideally with your system package manager):</p> <ul> <li>Python 3.13+ - as rustfava is written in Python</li> <li>Bun - to build the frontend</li> <li>just - to run various build / lint / test targets</li> <li>uv - to install the development environment and run scripts</li> </ul> <p>Then this will get you up and running:</p> <pre><code>git clone https://github.com/rustledger/rustfava.git\ncd rustfava\n# setup a virtual environment (at .venv) and install rustfava and development\n# dependencies into it:\njust dev\n</code></pre> <p>You can start rustfava in the virtual environment as usual by running <code>rustfava</code>. Running in debug mode with <code>rustfava --debug</code> is useful for development.</p> <p>You can run the tests with <code>just test</code> and the linters by running <code>just lint</code>. Run <code>just --list</code> to see all available recipes. After any changes to the Javascript code, you will need to re-build the frontend, which you can do by running <code>just frontend</code>. If you are working on the frontend code, running <code>bun run dev</code> in the <code>frontend</code> folder will watch for file changes and rebuild the Javascript bundle continuously.</p> <p>Contributions are very welcome, just open a PR on GitHub.</p> <p>Rustfava is released under the MIT License.</p>"},{"location":"usage/","title":"Getting Started","text":"<p>If you're new to Beancount-format files or double-entry accounting in general, we recommend Command-line Accounting in Context, a motivational document written by Martin Blais, the creator of the Beancount format.</p> <p>To learn how to create your ledger file, refer to Getting Started with Beancount guide. There is extensive documentation for the Beancount file format at the Beancount Documentation page.</p>"},{"location":"usage/#installation","title":"Installation","text":"<p>Rustfava runs on macOS, Linux, and Windows. You will need Python 3 and uv.</p> <p>Then you can install rustfava or update your existing installation by running:</p> <pre><code>uv pip install --upgrade rustfava\n</code></pre> <p>Rustfava uses rustledger, a Rust-based parser compiled to WebAssembly, to parse your Beancount files. No separate Beancount installation is required.</p> <p>If you want to export query results to Microsoft Excel or LibreOffice Calc, use the following command to install the optional dependencies for this feature:</p> <pre><code>uv pip install --upgrade rustfava[excel]\n</code></pre>"},{"location":"usage/#starting-rustfava","title":"Starting Rustfava","text":"<p>After installing rustfava, you can start it by running:</p> <pre><code>rustfava ledger.beancount\n</code></pre> <p>pointing it to your Beancount file -- and visit the web interface at http://localhost:5000.</p> <p>There are some command-line options available, run <code>rustfava --help</code> for an overview.</p> <p>For more information on rustfava's features, refer to the help pages that are available through rustfava's web-interface. Rustfava comes with Gmail-style keyboard shortcuts; press <code>?</code> to show an overview.</p>"}]}
\ No newline at end of file
+{"config":{"lang":["en"],"separator":"[\\s\\-]+","pipeline":["stopWordFilter"],"fields":{"title":{"boost":1000.0},"text":{"boost":1.0},"tags":{"boost":1000000.0}}},"docs":[{"location":"","title":"Welcome to rustfava!","text":"<p>rustfava is a web interface for double-entry bookkeeping, powered by rustledger, a Rust-based parser for the Beancount file format compiled to WebAssembly for fast processing.</p> <p>rustfava is a fork of Fava that replaces the Python Beancount parser with rustledger for improved performance. Your existing Beancount files are fully compatible.</p> <p></p> <p>If you are new to rustfava or Beancount-format files, begin with the Getting Started guide.</p>"},{"location":"#quick-start","title":"Quick Start","text":""},{"location":"#desktop-app-recommended","title":"Desktop App (Recommended)","text":"<p>Download the desktop app from GitHub Releases - no installation required, just double-click to run.</p>"},{"location":"#command-line","title":"Command Line","text":"<pre><code>uv tool install rustfava\nrustfava ledger.beancount\n</code></pre> <p>Then visit http://localhost:5000.</p>"},{"location":"#docker","title":"Docker","text":"<pre><code>docker run -p 5000:5000 -v /path/to/ledger:/data ghcr.io/rustledger/rustfava /data/main.beancount\n</code></pre>"},{"location":"api/","title":"API Reference","text":"<p>Note</p> <p>There's no stability guarantee as this is just for internal purposes currently.</p>"},{"location":"api/#core-modules","title":"Core Modules","text":""},{"location":"api/#rustfava.core","title":"<code>rustfava.core</code>","text":"<p>This module provides the data required by Fava's reports.</p>"},{"location":"api/#rustfava.core.EntryNotFoundForHashError","title":"<code>EntryNotFoundForHashError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Entry not found for hash.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class EntryNotFoundForHashError(RustfavaAPIError):\n    \"\"\"Entry not found for hash.\"\"\"\n\n    def __init__(self, entry_hash: str) -&gt; None:\n        super().__init__(f'No entry found for hash \"{entry_hash}\"')\n</code></pre>"},{"location":"api/#rustfava.core.StatementNotFoundError","title":"<code>StatementNotFoundError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Statement not found.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class StatementNotFoundError(RustfavaAPIError):\n    \"\"\"Statement not found.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"Statement not found.\")\n</code></pre>"},{"location":"api/#rustfava.core.StatementMetadataInvalidError","title":"<code>StatementMetadataInvalidError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Statement metadata not found or invalid.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class StatementMetadataInvalidError(RustfavaAPIError):\n    \"\"\"Statement metadata not found or invalid.\"\"\"\n\n    def __init__(self, key: str) -&gt; None:\n        super().__init__(\n            f\"Statement path at key '{key}' missing or not a string.\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.JournalPage","title":"<code>JournalPage</code>  <code>dataclass</code>","text":"<p>A page of journal entries.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>@dataclass(frozen=True)\nclass JournalPage:\n    \"\"\"A page of journal entries.\"\"\"\n\n    entries: Sequence[tuple[int, Directive]]\n    total_pages: int\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger","title":"<code>FilteredLedger</code>","text":"<p>Filtered Beancount ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class FilteredLedger:\n    \"\"\"Filtered Beancount ledger.\"\"\"\n\n    __slots__ = (\n        \"__dict__\",  # for the cached_property decorator\n        \"_date_first\",\n        \"_date_last\",\n        \"_pages\",\n        \"date_range\",\n        \"entries\",\n        \"ledger\",\n    )\n    _date_first: date | None\n    _date_last: date | None\n\n    def __init__(\n        self,\n        ledger: RustfavaLedger,\n        *,\n        account: str | None = None,\n        filter: str | None = None,  # noqa: A002\n        time: str | None = None,\n    ) -&gt; None:\n        \"\"\"Create a filtered view of a ledger.\n\n        Args:\n            ledger: The ledger to filter.\n            account: The account filter.\n            filter: The advanced filter.\n            time: The time filter.\n        \"\"\"\n        self.ledger = ledger\n        self.date_range: DateRange | None = None\n        self._pages: (\n            tuple[\n                int,\n                Literal[\"asc\", \"desc\"],\n                list[Sequence[tuple[int, Directive]]],\n            ]\n            | None\n        ) = None\n\n        entries = ledger.all_entries\n        if account:\n            entries = AccountFilter(account).apply(entries)\n        if filter and filter.strip():\n            entries = AdvancedFilter(filter.strip()).apply(entries)\n        if time:\n            time_filter = TimeFilter(ledger.options, ledger.fava_options, time)\n            entries = time_filter.apply(entries)\n            self.date_range = time_filter.date_range\n        self.entries = entries\n\n        if self.date_range:\n            self._date_first = self.date_range.begin\n            self._date_last = self.date_range.end\n            return\n\n        self._date_first = None\n        self._date_last = None\n        for entry in self.entries:\n            if isinstance(entry, Transaction):\n                self._date_first = entry.date\n                break\n        for entry in reversed(self.entries):\n            if isinstance(entry, (Transaction, Price)):\n                self._date_last = entry.date + timedelta(1)\n                break\n\n    @property\n    def end_date(self) -&gt; date | None:\n        \"\"\"The date to use for prices.\"\"\"\n        date_range = self.date_range\n        if date_range:\n            return date_range.end_inclusive\n        return None\n\n    @cached_property\n    def entries_with_all_prices(self) -&gt; Sequence[Directive]:\n        \"\"\"The filtered entries, with all prices added back in for queries.\"\"\"\n        entries = [*self.entries, *self.ledger.all_entries_by_type.Price]\n        entries.sort(key=_incomplete_sortkey)\n        return entries\n\n    @cached_property\n    def entries_without_prices(self) -&gt; Sequence[Directive]:\n        \"\"\"The filtered entries, without prices for journals.\"\"\"\n        return [e for e in self.entries if not isinstance(e, Price)]\n\n    @cached_property\n    def root_tree(self) -&gt; Tree:\n        \"\"\"A root tree.\"\"\"\n        return Tree(self.entries)\n\n    @cached_property\n    def root_tree_closed(self) -&gt; Tree:\n        \"\"\"A root tree for the balance sheet.\"\"\"\n        tree = Tree(self.entries)\n        tree.cap(self.ledger.options, self.ledger.fava_options.unrealized)\n        return tree\n\n    def interval_ranges(self, interval: Interval) -&gt; Sequence[DateRange]:\n        \"\"\"Yield date ranges corresponding to interval boundaries.\n\n        Args:\n            interval: The interval to yield ranges for.\n        \"\"\"\n        if not self._date_first or not self._date_last:\n            return []\n        complete = not self.date_range\n        return dateranges(\n            self._date_first, self._date_last, interval, complete=complete\n        )\n\n    def prices(self, base: str, quote: str) -&gt; Sequence[tuple[date, Decimal]]:\n        \"\"\"List all prices for a pair of commodities.\n\n        Args:\n            base: The price base.\n            quote: The price quote.\n        \"\"\"\n        all_prices = self.ledger.prices.get_all_prices((base, quote))\n        if all_prices is None:\n            return []\n\n        date_range = self.date_range\n        if date_range:\n            return [\n                price_point\n                for price_point in all_prices\n                if date_range.begin &lt;= price_point[0] &lt; date_range.end\n            ]\n        return all_prices\n\n    def account_is_closed(self, account_name: str) -&gt; bool:\n        \"\"\"Check if the account is closed.\n\n        Args:\n            account_name: An account name.\n\n        Returns:\n            True if the account is closed before the end date of the current\n            time filter.\n        \"\"\"\n        date_range = self.date_range\n        close_date = self.ledger.accounts[account_name].close_date\n        if close_date is None:\n            return False\n        return close_date &lt; date_range.end if date_range else True\n\n    def paginate_journal(\n        self,\n        page: int,\n        per_page: int = 1000,\n        order: Literal[\"asc\", \"desc\"] = \"desc\",\n    ) -&gt; JournalPage | None:\n        \"\"\"Get entries for a journal page with pagination info.\n\n        Args:\n            page: Page number (1-indexed).\n            order: Datewise order to sort in\n            per_page: Number of entries per page.\n\n        Returns:\n            A JournalPage, containing a list of entries as (global_index,\n            directive) tuples in reverse chronological order and the total\n            number of pages.\n        \"\"\"\n        if (\n            self._pages is None\n            or self._pages[0] != per_page\n            or self._pages[1] != order\n        ):\n            pages: list[Sequence[tuple[int, Directive]]] = []\n            enumerated = list(enumerate(self.entries_without_prices))\n            entries = (\n                iter(enumerated) if order == \"asc\" else reversed(enumerated)\n            )\n            while batch := tuple(islice(entries, per_page)):\n                pages.append(batch)\n            if not pages:\n                pages.append([])\n            self._pages = (per_page, order, pages)\n        _per_pages, _order, pages = self._pages\n        total = len(pages)\n        if page &gt; total:\n            return None\n        return JournalPage(pages[page - 1], total)\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.end_date","title":"<code>end_date</code>  <code>property</code>","text":"<p>The date to use for prices.</p>"},{"location":"api/#rustfava.core.FilteredLedger.entries_with_all_prices","title":"<code>entries_with_all_prices</code>  <code>cached</code> <code>property</code>","text":"<p>The filtered entries, with all prices added back in for queries.</p>"},{"location":"api/#rustfava.core.FilteredLedger.entries_without_prices","title":"<code>entries_without_prices</code>  <code>cached</code> <code>property</code>","text":"<p>The filtered entries, without prices for journals.</p>"},{"location":"api/#rustfava.core.FilteredLedger.root_tree","title":"<code>root_tree</code>  <code>cached</code> <code>property</code>","text":"<p>A root tree.</p>"},{"location":"api/#rustfava.core.FilteredLedger.root_tree_closed","title":"<code>root_tree_closed</code>  <code>cached</code> <code>property</code>","text":"<p>A root tree for the balance sheet.</p>"},{"location":"api/#rustfava.core.FilteredLedger.__init__","title":"<code>__init__(ledger, *, account=None, filter=None, time=None)</code>","text":"<p>Create a filtered view of a ledger.</p> <p>Parameters:</p> Name Type Description Default <code>ledger</code> <code>RustfavaLedger</code> <p>The ledger to filter.</p> required <code>account</code> <code>str | None</code> <p>The account filter.</p> <code>None</code> <code>filter</code> <code>str | None</code> <p>The advanced filter.</p> <code>None</code> <code>time</code> <code>str | None</code> <p>The time filter.</p> <code>None</code> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def __init__(\n    self,\n    ledger: RustfavaLedger,\n    *,\n    account: str | None = None,\n    filter: str | None = None,  # noqa: A002\n    time: str | None = None,\n) -&gt; None:\n    \"\"\"Create a filtered view of a ledger.\n\n    Args:\n        ledger: The ledger to filter.\n        account: The account filter.\n        filter: The advanced filter.\n        time: The time filter.\n    \"\"\"\n    self.ledger = ledger\n    self.date_range: DateRange | None = None\n    self._pages: (\n        tuple[\n            int,\n            Literal[\"asc\", \"desc\"],\n            list[Sequence[tuple[int, Directive]]],\n        ]\n        | None\n    ) = None\n\n    entries = ledger.all_entries\n    if account:\n        entries = AccountFilter(account).apply(entries)\n    if filter and filter.strip():\n        entries = AdvancedFilter(filter.strip()).apply(entries)\n    if time:\n        time_filter = TimeFilter(ledger.options, ledger.fava_options, time)\n        entries = time_filter.apply(entries)\n        self.date_range = time_filter.date_range\n    self.entries = entries\n\n    if self.date_range:\n        self._date_first = self.date_range.begin\n        self._date_last = self.date_range.end\n        return\n\n    self._date_first = None\n    self._date_last = None\n    for entry in self.entries:\n        if isinstance(entry, Transaction):\n            self._date_first = entry.date\n            break\n    for entry in reversed(self.entries):\n        if isinstance(entry, (Transaction, Price)):\n            self._date_last = entry.date + timedelta(1)\n            break\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.interval_ranges","title":"<code>interval_ranges(interval)</code>","text":"<p>Yield date ranges corresponding to interval boundaries.</p> <p>Parameters:</p> Name Type Description Default <code>interval</code> <code>Interval</code> <p>The interval to yield ranges for.</p> required Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def interval_ranges(self, interval: Interval) -&gt; Sequence[DateRange]:\n    \"\"\"Yield date ranges corresponding to interval boundaries.\n\n    Args:\n        interval: The interval to yield ranges for.\n    \"\"\"\n    if not self._date_first or not self._date_last:\n        return []\n    complete = not self.date_range\n    return dateranges(\n        self._date_first, self._date_last, interval, complete=complete\n    )\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.prices","title":"<code>prices(base, quote)</code>","text":"<p>List all prices for a pair of commodities.</p> <p>Parameters:</p> Name Type Description Default <code>base</code> <code>str</code> <p>The price base.</p> required <code>quote</code> <code>str</code> <p>The price quote.</p> required Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def prices(self, base: str, quote: str) -&gt; Sequence[tuple[date, Decimal]]:\n    \"\"\"List all prices for a pair of commodities.\n\n    Args:\n        base: The price base.\n        quote: The price quote.\n    \"\"\"\n    all_prices = self.ledger.prices.get_all_prices((base, quote))\n    if all_prices is None:\n        return []\n\n    date_range = self.date_range\n    if date_range:\n        return [\n            price_point\n            for price_point in all_prices\n            if date_range.begin &lt;= price_point[0] &lt; date_range.end\n        ]\n    return all_prices\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.account_is_closed","title":"<code>account_is_closed(account_name)</code>","text":"<p>Check if the account is closed.</p> <p>Parameters:</p> Name Type Description Default <code>account_name</code> <code>str</code> <p>An account name.</p> required <p>Returns:</p> Type Description <code>bool</code> <p>True if the account is closed before the end date of the current</p> <code>bool</code> <p>time filter.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def account_is_closed(self, account_name: str) -&gt; bool:\n    \"\"\"Check if the account is closed.\n\n    Args:\n        account_name: An account name.\n\n    Returns:\n        True if the account is closed before the end date of the current\n        time filter.\n    \"\"\"\n    date_range = self.date_range\n    close_date = self.ledger.accounts[account_name].close_date\n    if close_date is None:\n        return False\n    return close_date &lt; date_range.end if date_range else True\n</code></pre>"},{"location":"api/#rustfava.core.FilteredLedger.paginate_journal","title":"<code>paginate_journal(page, per_page=1000, order='desc')</code>","text":"<p>Get entries for a journal page with pagination info.</p> <p>Parameters:</p> Name Type Description Default <code>page</code> <code>int</code> <p>Page number (1-indexed).</p> required <code>order</code> <code>Literal['asc', 'desc']</code> <p>Datewise order to sort in</p> <code>'desc'</code> <code>per_page</code> <code>int</code> <p>Number of entries per page.</p> <code>1000</code> <p>Returns:</p> Type Description <code>JournalPage | None</code> <p>A JournalPage, containing a list of entries as (global_index,</p> <code>JournalPage | None</code> <p>directive) tuples in reverse chronological order and the total</p> <code>JournalPage | None</code> <p>number of pages.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def paginate_journal(\n    self,\n    page: int,\n    per_page: int = 1000,\n    order: Literal[\"asc\", \"desc\"] = \"desc\",\n) -&gt; JournalPage | None:\n    \"\"\"Get entries for a journal page with pagination info.\n\n    Args:\n        page: Page number (1-indexed).\n        order: Datewise order to sort in\n        per_page: Number of entries per page.\n\n    Returns:\n        A JournalPage, containing a list of entries as (global_index,\n        directive) tuples in reverse chronological order and the total\n        number of pages.\n    \"\"\"\n    if (\n        self._pages is None\n        or self._pages[0] != per_page\n        or self._pages[1] != order\n    ):\n        pages: list[Sequence[tuple[int, Directive]]] = []\n        enumerated = list(enumerate(self.entries_without_prices))\n        entries = (\n            iter(enumerated) if order == \"asc\" else reversed(enumerated)\n        )\n        while batch := tuple(islice(entries, per_page)):\n            pages.append(batch)\n        if not pages:\n            pages.append([])\n        self._pages = (per_page, order, pages)\n    _per_pages, _order, pages = self._pages\n    total = len(pages)\n    if page &gt; total:\n        return None\n    return JournalPage(pages[page - 1], total)\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger","title":"<code>RustfavaLedger</code>","text":"<p>Interface for a Beancount ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>class RustfavaLedger:\n    \"\"\"Interface for a Beancount ledger.\"\"\"\n\n    __slots__ = (\n        \"_is_encrypted\",\n        \"accounts\",\n        \"accounts\",\n        \"all_entries\",\n        \"all_entries_by_type\",\n        \"attributes\",\n        \"beancount_file_path\",\n        \"budgets\",\n        \"charts\",\n        \"commodities\",\n        \"extensions\",\n        \"fava_options\",\n        \"fava_options_errors\",\n        \"file\",\n        \"format_decimal\",\n        \"get_entry\",\n        \"get_filtered\",\n        \"ingest\",\n        \"load_errors\",\n        \"misc\",\n        \"options\",\n        \"prices\",\n        \"query_shell\",\n        \"watcher\",\n    )\n\n    #: List of all (unfiltered) entries.\n    all_entries: Sequence[Directive]\n\n    #: A list of all errors reported by Beancount.\n    load_errors: Sequence[BeancountError]\n\n    #: The Beancount options map.\n    options: BeancountOptions\n\n    #: A dict with all of Fava's option values.\n    fava_options: RustfavaOptions\n\n    #: A list of all errors from parsing the custom options.\n    fava_options_errors: Sequence[BeancountError]\n\n    #: The price map.\n    prices: RustfavaPriceMap\n\n    #: Dict of list of all (unfiltered) entries by type.\n    all_entries_by_type: EntriesByType\n\n    #: A :class:`.AccountDict` module - details about the accounts.\n    accounts: AccountDict\n\n    #: An :class:`AttributesModule` instance.\n    attributes: AttributesModule\n\n    #: A :class:`.BudgetModule` instance.\n    budgets: BudgetModule\n\n    #: A :class:`.ChartModule` instance.\n    charts: ChartModule\n\n    #: A :class:`.CommoditiesModule` instance.\n    commodities: CommoditiesModule\n\n    #: A :class:`.ExtensionModule` instance.\n    extensions: ExtensionModule\n\n    #: A :class:`.FileModule` instance.\n    file: FileModule\n\n    #: A :class:`.DecimalFormatModule` instance.\n    format_decimal: DecimalFormatModule\n\n    #: A :class:`.IngestModule` instance.\n    ingest: IngestModule\n\n    #: A :class:`.FavaMisc` instance.\n    misc: FavaMisc\n\n    #: A :class:`.QueryShell` instance.\n    query_shell: QueryShell\n\n    def __init__(self, path: str, *, poll_watcher: bool = False) -&gt; None:\n        \"\"\"Create an interface for a Beancount ledger.\n\n        Arguments:\n            path: Path to the main Beancount file.\n            poll_watcher: Whether to use the polling file watcher.\n        \"\"\"\n        #: The path to the main Beancount file.\n        self.beancount_file_path = path\n        self._is_encrypted = is_encrypted_file(path)\n        self.get_filtered = lru_cache(maxsize=16)(self._get_filtered)\n        self.get_entry = lru_cache(maxsize=16)(self._get_entry)\n\n        self.accounts = AccountDict(self)\n        self.attributes = AttributesModule(self)\n        self.budgets = BudgetModule(self)\n        self.charts = ChartModule(self)\n        self.commodities = CommoditiesModule(self)\n        self.extensions = ExtensionModule(self)\n        self.file = FileModule(self)\n        self.format_decimal = DecimalFormatModule(self)\n        self.ingest = IngestModule(self)\n        self.misc = FavaMisc(self)\n        self.query_shell = QueryShell(self)\n\n        self.watcher = WatchfilesWatcher() if not poll_watcher else Watcher()\n\n        self.load_file()\n\n    def load_file(self) -&gt; None:\n        \"\"\"Load the main file and all included files and set attributes.\"\"\"\n        self.all_entries, self.load_errors, self.options = load_uncached(\n            self.beancount_file_path,\n            is_encrypted=self._is_encrypted,\n        )\n        self.get_filtered.cache_clear()\n        self.get_entry.cache_clear()\n\n        self.all_entries_by_type = group_entries_by_type(self.all_entries)\n        self.prices = RustfavaPriceMap(self.all_entries_by_type.Price)\n\n        self.fava_options, self.fava_options_errors = parse_options(\n            self.all_entries_by_type.Custom,\n        )\n\n        if self._is_encrypted:  # pragma: no cover\n            pass\n        else:\n            self.watcher.update(*self.paths_to_watch())\n\n        # Call load_file of all modules.\n        self.accounts.load_file()\n        self.attributes.load_file()\n        self.budgets.load_file()\n        self.charts.load_file()\n        self.commodities.load_file()\n        self.extensions.load_file()\n        self.file.load_file()\n        self.format_decimal.load_file()\n        self.misc.load_file()\n        self.query_shell.load_file()\n        self.ingest.load_file()\n\n        self.extensions.after_load_file()\n\n    def _get_filtered(\n        self,\n        account: str | None = None,\n        filter: str | None = None,  # noqa: A002\n        time: str | None = None,\n    ) -&gt; FilteredLedger:\n        \"\"\"Filter the ledger.\n\n        Args:\n            account: The account filter.\n            filter: The advanced filter.\n            time: The time filter.\n        \"\"\"\n        return FilteredLedger(\n            ledger=self, account=account, filter=filter, time=time\n        )\n\n    @property\n    def mtime(self) -&gt; int:\n        \"\"\"The timestamp to the latest change of the underlying files.\"\"\"\n        return self.watcher.last_checked\n\n    @property\n    def errors(self) -&gt; Sequence[BeancountError]:\n        \"\"\"The errors that the Beancount loading plus Fava module errors.\"\"\"\n        return [\n            *self.load_errors,\n            *self.fava_options_errors,\n            *self.budgets.errors,\n            *self.extensions.errors,\n            *self.misc.errors,\n            *self.ingest.errors,\n        ]\n\n    @property\n    def root_accounts(self) -&gt; tuple[str, str, str, str, str]:\n        \"\"\"The five root accounts.\"\"\"\n        options = self.options\n        return (\n            options[\"name_assets\"],\n            options[\"name_liabilities\"],\n            options[\"name_equity\"],\n            options[\"name_income\"],\n            options[\"name_expenses\"],\n        )\n\n    def join_path(self, *args: str) -&gt; Path:\n        \"\"\"Path relative to the directory of the ledger.\"\"\"\n        return Path(self.beancount_file_path).parent.joinpath(*args).resolve()\n\n    def paths_to_watch(self) -&gt; tuple[Sequence[Path], Sequence[Path]]:\n        \"\"\"Get paths to included files and document directories.\n\n        Returns:\n            A tuple (files, directories).\n        \"\"\"\n        files = [Path(i) for i in self.options[\"include\"]]\n        if self.ingest.module_path:\n            files.append(self.ingest.module_path)\n        return (\n            files,\n            [\n                self.join_path(path, account)\n                for account in self.root_accounts\n                for path in self.options[\"documents\"]\n            ],\n        )\n\n    def changed(self) -&gt; bool:\n        \"\"\"Check if the file needs to be reloaded.\n\n        Returns:\n            True if a change in one of the included files or a change in a\n            document folder was detected and the file has been reloaded.\n        \"\"\"\n        # We can't reload an encrypted file, so act like it never changes.\n        if self._is_encrypted:  # pragma: no cover\n            return False\n        changed = self.watcher.check()\n        if changed:\n            self.load_file()\n        return changed\n\n    def interval_balances(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        account_name: str,\n        *,\n        accumulate: bool = False,\n    ) -&gt; tuple[Sequence[Tree], Sequence[DateRange]]:\n        \"\"\"Balances by interval.\n\n        Arguments:\n            filtered: The currently filtered ledger.\n            interval: An interval.\n            account_name: An account name.\n            accumulate: A boolean, ``True`` if the balances for an interval\n                should include all entries up to the end of the interval.\n\n        Returns:\n            A pair of a list of Tree instances and the intervals.\n        \"\"\"\n        min_accounts = [\n            account\n            for account in self.accounts\n            if account.startswith(account_name)\n        ]\n\n        interval_ranges = list(reversed(filtered.interval_ranges(interval)))\n        interval_balances = [\n            Tree(\n                slice_entry_dates(\n                    filtered.entries,\n                    date.min if accumulate else date_range.begin,\n                    date_range.end,\n                ),\n                min_accounts,\n            )\n            for date_range in interval_ranges\n        ]\n\n        return interval_balances, interval_ranges\n\n    @listify\n    def account_journal(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: str | Conversion,\n        *,\n        with_children: bool,\n    ) -&gt; Iterable[\n        tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]\n    ]:\n        \"\"\"Journal for an account.\n\n        Args:\n            filtered: The currently filtered ledger.\n            account_name: An account name.\n            conversion: The conversion to use.\n            with_children: Whether to include postings of subaccounts of\n                           the account.\n\n        Yields:\n            Tuples of ``(index, entry, change, balance)``.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        relevant_account = account_tester(\n            account_name, with_children=with_children\n        )\n\n        prices = self.prices\n        balance = CounterInventory()\n        for index, entry in enumerate(filtered.entries_without_prices):\n            change = CounterInventory()\n            entry_is_relevant = False\n            postings = getattr(entry, \"postings\", None)\n            if postings is not None:\n                for posting in postings:\n                    if relevant_account(posting.account):\n                        entry_is_relevant = True\n                        balance.add_position(posting)\n                        change.add_position(posting)\n            elif any(relevant_account(a) for a in get_entry_accounts(entry)):\n                entry_is_relevant = True\n\n            if entry_is_relevant:\n                yield (\n                    index,\n                    entry,\n                    conv.apply(change, prices, entry.date),\n                    conv.apply(balance, prices, entry.date),\n                )\n\n    def _get_entry(self, entry_hash: str) -&gt; Directive:\n        \"\"\"Find an entry.\n\n        Arguments:\n            entry_hash: Hash of the entry.\n\n        Returns:\n            The entry with the given hash.\n\n        Raises:\n            EntryNotFoundForHashError: If there is no entry for the given hash.\n        \"\"\"\n        try:\n            return next(\n                entry\n                for entry in self.all_entries\n                if entry_hash == hash_entry(entry)\n            )\n        except StopIteration as exc:\n            raise EntryNotFoundForHashError(entry_hash) from exc\n\n    def context(\n        self,\n        entry_hash: str,\n    ) -&gt; tuple[\n        Directive,\n        Mapping[str, Sequence[str]] | None,\n        Mapping[str, Sequence[str]] | None,\n    ]:\n        \"\"\"Context for an entry.\n\n        Arguments:\n            entry_hash: Hash of entry.\n\n        Returns:\n            A tuple ``(entry, before, after, source_slice, sha256sum)`` of the\n            (unique) entry with the given ``entry_hash``. If the entry is a\n            Balance or Transaction then ``before`` and ``after`` contain\n            the balances before and after the entry of the affected accounts.\n        \"\"\"\n        entry = self.get_entry(entry_hash)\n\n        if not isinstance(entry, (Balance, Transaction)):\n            return entry, None, None\n\n        entry_accounts = get_entry_accounts(entry)\n        balances = {account: CounterInventory() for account in entry_accounts}\n        for entry_ in takewhile(lambda e: e is not entry, self.all_entries):\n            if isinstance(entry_, Transaction):\n                for posting in entry_.postings:\n                    balance = balances.get(posting.account, None)\n                    if balance is not None:\n                        balance.add_position(posting)\n\n        def visualise(inv: CounterInventory) -&gt; Sequence[str]:\n            return inv.to_strings()\n\n        before = {acc: visualise(inv) for acc, inv in balances.items()}\n\n        if isinstance(entry, Balance):\n            return entry, before, None\n\n        for posting in entry.postings:\n            balances[posting.account].add_position(posting)\n        after = {acc: visualise(inv) for acc, inv in balances.items()}\n        return entry, before, after\n\n    def commodity_pairs(self) -&gt; Sequence[tuple[str, str]]:\n        \"\"\"List pairs of commodities.\n\n        Returns:\n            A list of pairs of commodities. Pairs of operating currencies will\n            be given in both directions not just in the one found in file.\n        \"\"\"\n        return self.prices.commodity_pairs(self.options[\"operating_currency\"])\n\n    def statement_path(self, entry_hash: str, metadata_key: str) -&gt; str:\n        \"\"\"Get the path for a statement found in the specified entry.\n\n        The entry that we look up should contain a path to a document (absolute\n        or relative to the filename of the entry) or just its basename. We go\n        through all documents and match on the full path or if one of the\n        documents with a matching account has a matching file basename.\n\n        Arguments:\n            entry_hash: Hash of the entry containing the path in its metadata.\n            metadata_key: The key that the path should be in.\n\n        Returns:\n            The filename of the matching document entry.\n\n        Raises:\n            StatementMetadataInvalidError: If the metadata at the given key is\n                                           invalid.\n            StatementNotFoundError: If no matching document is found.\n        \"\"\"\n        entry = self.get_entry(entry_hash)\n        value = entry.meta.get(metadata_key, None)\n        if not isinstance(value, str):\n            raise StatementMetadataInvalidError(metadata_key)\n\n        accounts = set(get_entry_accounts(entry))\n        filename, _ = get_position(entry)\n        full_path = (Path(filename).parent / value).resolve()\n        for document in self.all_entries_by_type.Document:\n            document_path = Path(document.filename)\n            if document_path == full_path:\n                return document.filename\n            if document.account in accounts and document_path.name == value:\n                return document.filename\n\n        raise StatementNotFoundError\n\n    group_entries_by_type = staticmethod(group_entries_by_type)\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.mtime","title":"<code>mtime</code>  <code>property</code>","text":"<p>The timestamp to the latest change of the underlying files.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.errors","title":"<code>errors</code>  <code>property</code>","text":"<p>The errors that the Beancount loading plus Fava module errors.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.root_accounts","title":"<code>root_accounts</code>  <code>property</code>","text":"<p>The five root accounts.</p>"},{"location":"api/#rustfava.core.RustfavaLedger.__init__","title":"<code>__init__(path, *, poll_watcher=False)</code>","text":"<p>Create an interface for a Beancount ledger.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>str</code> <p>Path to the main Beancount file.</p> required <code>poll_watcher</code> <code>bool</code> <p>Whether to use the polling file watcher.</p> <code>False</code> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def __init__(self, path: str, *, poll_watcher: bool = False) -&gt; None:\n    \"\"\"Create an interface for a Beancount ledger.\n\n    Arguments:\n        path: Path to the main Beancount file.\n        poll_watcher: Whether to use the polling file watcher.\n    \"\"\"\n    #: The path to the main Beancount file.\n    self.beancount_file_path = path\n    self._is_encrypted = is_encrypted_file(path)\n    self.get_filtered = lru_cache(maxsize=16)(self._get_filtered)\n    self.get_entry = lru_cache(maxsize=16)(self._get_entry)\n\n    self.accounts = AccountDict(self)\n    self.attributes = AttributesModule(self)\n    self.budgets = BudgetModule(self)\n    self.charts = ChartModule(self)\n    self.commodities = CommoditiesModule(self)\n    self.extensions = ExtensionModule(self)\n    self.file = FileModule(self)\n    self.format_decimal = DecimalFormatModule(self)\n    self.ingest = IngestModule(self)\n    self.misc = FavaMisc(self)\n    self.query_shell = QueryShell(self)\n\n    self.watcher = WatchfilesWatcher() if not poll_watcher else Watcher()\n\n    self.load_file()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.load_file","title":"<code>load_file()</code>","text":"<p>Load the main file and all included files and set attributes.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def load_file(self) -&gt; None:\n    \"\"\"Load the main file and all included files and set attributes.\"\"\"\n    self.all_entries, self.load_errors, self.options = load_uncached(\n        self.beancount_file_path,\n        is_encrypted=self._is_encrypted,\n    )\n    self.get_filtered.cache_clear()\n    self.get_entry.cache_clear()\n\n    self.all_entries_by_type = group_entries_by_type(self.all_entries)\n    self.prices = RustfavaPriceMap(self.all_entries_by_type.Price)\n\n    self.fava_options, self.fava_options_errors = parse_options(\n        self.all_entries_by_type.Custom,\n    )\n\n    if self._is_encrypted:  # pragma: no cover\n        pass\n    else:\n        self.watcher.update(*self.paths_to_watch())\n\n    # Call load_file of all modules.\n    self.accounts.load_file()\n    self.attributes.load_file()\n    self.budgets.load_file()\n    self.charts.load_file()\n    self.commodities.load_file()\n    self.extensions.load_file()\n    self.file.load_file()\n    self.format_decimal.load_file()\n    self.misc.load_file()\n    self.query_shell.load_file()\n    self.ingest.load_file()\n\n    self.extensions.after_load_file()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.join_path","title":"<code>join_path(*args)</code>","text":"<p>Path relative to the directory of the ledger.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def join_path(self, *args: str) -&gt; Path:\n    \"\"\"Path relative to the directory of the ledger.\"\"\"\n    return Path(self.beancount_file_path).parent.joinpath(*args).resolve()\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.paths_to_watch","title":"<code>paths_to_watch()</code>","text":"<p>Get paths to included files and document directories.</p> <p>Returns:</p> Type Description <code>tuple[Sequence[Path], Sequence[Path]]</code> <p>A tuple (files, directories).</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def paths_to_watch(self) -&gt; tuple[Sequence[Path], Sequence[Path]]:\n    \"\"\"Get paths to included files and document directories.\n\n    Returns:\n        A tuple (files, directories).\n    \"\"\"\n    files = [Path(i) for i in self.options[\"include\"]]\n    if self.ingest.module_path:\n        files.append(self.ingest.module_path)\n    return (\n        files,\n        [\n            self.join_path(path, account)\n            for account in self.root_accounts\n            for path in self.options[\"documents\"]\n        ],\n    )\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.changed","title":"<code>changed()</code>","text":"<p>Check if the file needs to be reloaded.</p> <p>Returns:</p> Type Description <code>bool</code> <p>True if a change in one of the included files or a change in a</p> <code>bool</code> <p>document folder was detected and the file has been reloaded.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def changed(self) -&gt; bool:\n    \"\"\"Check if the file needs to be reloaded.\n\n    Returns:\n        True if a change in one of the included files or a change in a\n        document folder was detected and the file has been reloaded.\n    \"\"\"\n    # We can't reload an encrypted file, so act like it never changes.\n    if self._is_encrypted:  # pragma: no cover\n        return False\n    changed = self.watcher.check()\n    if changed:\n        self.load_file()\n    return changed\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.interval_balances","title":"<code>interval_balances(filtered, interval, account_name, *, accumulate=False)</code>","text":"<p>Balances by interval.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The currently filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>An interval.</p> required <code>account_name</code> <code>str</code> <p>An account name.</p> required <code>accumulate</code> <code>bool</code> <p>A boolean, <code>True</code> if the balances for an interval should include all entries up to the end of the interval.</p> <code>False</code> <p>Returns:</p> Type Description <code>tuple[Sequence[Tree], Sequence[DateRange]]</code> <p>A pair of a list of Tree instances and the intervals.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def interval_balances(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    account_name: str,\n    *,\n    accumulate: bool = False,\n) -&gt; tuple[Sequence[Tree], Sequence[DateRange]]:\n    \"\"\"Balances by interval.\n\n    Arguments:\n        filtered: The currently filtered ledger.\n        interval: An interval.\n        account_name: An account name.\n        accumulate: A boolean, ``True`` if the balances for an interval\n            should include all entries up to the end of the interval.\n\n    Returns:\n        A pair of a list of Tree instances and the intervals.\n    \"\"\"\n    min_accounts = [\n        account\n        for account in self.accounts\n        if account.startswith(account_name)\n    ]\n\n    interval_ranges = list(reversed(filtered.interval_ranges(interval)))\n    interval_balances = [\n        Tree(\n            slice_entry_dates(\n                filtered.entries,\n                date.min if accumulate else date_range.begin,\n                date_range.end,\n            ),\n            min_accounts,\n        )\n        for date_range in interval_ranges\n    ]\n\n    return interval_balances, interval_ranges\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.account_journal","title":"<code>account_journal(filtered, account_name, conversion, *, with_children)</code>","text":"<p>Journal for an account.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The currently filtered ledger.</p> required <code>account_name</code> <code>str</code> <p>An account name.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <code>with_children</code> <code>bool</code> <p>Whether to include postings of subaccounts of            the account.</p> required <p>Yields:</p> Type Description <code>Iterable[tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]]</code> <p>Tuples of <code>(index, entry, change, balance)</code>.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>@listify\ndef account_journal(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: str | Conversion,\n    *,\n    with_children: bool,\n) -&gt; Iterable[\n    tuple[int, Directive, SimpleCounterInventory, SimpleCounterInventory]\n]:\n    \"\"\"Journal for an account.\n\n    Args:\n        filtered: The currently filtered ledger.\n        account_name: An account name.\n        conversion: The conversion to use.\n        with_children: Whether to include postings of subaccounts of\n                       the account.\n\n    Yields:\n        Tuples of ``(index, entry, change, balance)``.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    relevant_account = account_tester(\n        account_name, with_children=with_children\n    )\n\n    prices = self.prices\n    balance = CounterInventory()\n    for index, entry in enumerate(filtered.entries_without_prices):\n        change = CounterInventory()\n        entry_is_relevant = False\n        postings = getattr(entry, \"postings\", None)\n        if postings is not None:\n            for posting in postings:\n                if relevant_account(posting.account):\n                    entry_is_relevant = True\n                    balance.add_position(posting)\n                    change.add_position(posting)\n        elif any(relevant_account(a) for a in get_entry_accounts(entry)):\n            entry_is_relevant = True\n\n        if entry_is_relevant:\n            yield (\n                index,\n                entry,\n                conv.apply(change, prices, entry.date),\n                conv.apply(balance, prices, entry.date),\n            )\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.context","title":"<code>context(entry_hash)</code>","text":"<p>Context for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of entry.</p> required <p>Returns:</p> Type Description <code>Directive</code> <p>A tuple <code>(entry, before, after, source_slice, sha256sum)</code> of the</p> <code>Mapping[str, Sequence[str]] | None</code> <p>(unique) entry with the given <code>entry_hash</code>. If the entry is a</p> <code>Mapping[str, Sequence[str]] | None</code> <p>Balance or Transaction then <code>before</code> and <code>after</code> contain</p> <code>tuple[Directive, Mapping[str, Sequence[str]] | None, Mapping[str, Sequence[str]] | None]</code> <p>the balances before and after the entry of the affected accounts.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def context(\n    self,\n    entry_hash: str,\n) -&gt; tuple[\n    Directive,\n    Mapping[str, Sequence[str]] | None,\n    Mapping[str, Sequence[str]] | None,\n]:\n    \"\"\"Context for an entry.\n\n    Arguments:\n        entry_hash: Hash of entry.\n\n    Returns:\n        A tuple ``(entry, before, after, source_slice, sha256sum)`` of the\n        (unique) entry with the given ``entry_hash``. If the entry is a\n        Balance or Transaction then ``before`` and ``after`` contain\n        the balances before and after the entry of the affected accounts.\n    \"\"\"\n    entry = self.get_entry(entry_hash)\n\n    if not isinstance(entry, (Balance, Transaction)):\n        return entry, None, None\n\n    entry_accounts = get_entry_accounts(entry)\n    balances = {account: CounterInventory() for account in entry_accounts}\n    for entry_ in takewhile(lambda e: e is not entry, self.all_entries):\n        if isinstance(entry_, Transaction):\n            for posting in entry_.postings:\n                balance = balances.get(posting.account, None)\n                if balance is not None:\n                    balance.add_position(posting)\n\n    def visualise(inv: CounterInventory) -&gt; Sequence[str]:\n        return inv.to_strings()\n\n    before = {acc: visualise(inv) for acc, inv in balances.items()}\n\n    if isinstance(entry, Balance):\n        return entry, before, None\n\n    for posting in entry.postings:\n        balances[posting.account].add_position(posting)\n    after = {acc: visualise(inv) for acc, inv in balances.items()}\n    return entry, before, after\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.commodity_pairs","title":"<code>commodity_pairs()</code>","text":"<p>List pairs of commodities.</p> <p>Returns:</p> Type Description <code>Sequence[tuple[str, str]]</code> <p>A list of pairs of commodities. Pairs of operating currencies will</p> <code>Sequence[tuple[str, str]]</code> <p>be given in both directions not just in the one found in file.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def commodity_pairs(self) -&gt; Sequence[tuple[str, str]]:\n    \"\"\"List pairs of commodities.\n\n    Returns:\n        A list of pairs of commodities. Pairs of operating currencies will\n        be given in both directions not just in the one found in file.\n    \"\"\"\n    return self.prices.commodity_pairs(self.options[\"operating_currency\"])\n</code></pre>"},{"location":"api/#rustfava.core.RustfavaLedger.statement_path","title":"<code>statement_path(entry_hash, metadata_key)</code>","text":"<p>Get the path for a statement found in the specified entry.</p> <p>The entry that we look up should contain a path to a document (absolute or relative to the filename of the entry) or just its basename. We go through all documents and match on the full path or if one of the documents with a matching account has a matching file basename.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of the entry containing the path in its metadata.</p> required <code>metadata_key</code> <code>str</code> <p>The key that the path should be in.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The filename of the matching document entry.</p> <p>Raises:</p> Type Description <code>StatementMetadataInvalidError</code> <p>If the metadata at the given key is                            invalid.</p> <code>StatementNotFoundError</code> <p>If no matching document is found.</p> Source code in <code>src/rustfava/core/__init__.py</code> <pre><code>def statement_path(self, entry_hash: str, metadata_key: str) -&gt; str:\n    \"\"\"Get the path for a statement found in the specified entry.\n\n    The entry that we look up should contain a path to a document (absolute\n    or relative to the filename of the entry) or just its basename. We go\n    through all documents and match on the full path or if one of the\n    documents with a matching account has a matching file basename.\n\n    Arguments:\n        entry_hash: Hash of the entry containing the path in its metadata.\n        metadata_key: The key that the path should be in.\n\n    Returns:\n        The filename of the matching document entry.\n\n    Raises:\n        StatementMetadataInvalidError: If the metadata at the given key is\n                                       invalid.\n        StatementNotFoundError: If no matching document is found.\n    \"\"\"\n    entry = self.get_entry(entry_hash)\n    value = entry.meta.get(metadata_key, None)\n    if not isinstance(value, str):\n        raise StatementMetadataInvalidError(metadata_key)\n\n    accounts = set(get_entry_accounts(entry))\n    filename, _ = get_position(entry)\n    full_path = (Path(filename).parent / value).resolve()\n    for document in self.all_entries_by_type.Document:\n        document_path = Path(document.filename)\n        if document_path == full_path:\n            return document.filename\n        if document.account in accounts and document_path.name == value:\n            return document.filename\n\n    raise StatementNotFoundError\n</code></pre>"},{"location":"api/#rustfava.core.accounts","title":"<code>accounts</code>","text":"<p>Account close date and metadata.</p>"},{"location":"api/#rustfava.core.accounts.LastEntry","title":"<code>LastEntry</code>  <code>dataclass</code>","text":"<p>Date and hash of the last entry for an account.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>@dataclass(frozen=True)\nclass LastEntry:\n    \"\"\"Date and hash of the last entry for an account.\"\"\"\n\n    #: The entry date.\n    date: datetime.date\n\n    #: The entry hash.\n    entry_hash: str\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountData","title":"<code>AccountData</code>  <code>dataclass</code>","text":"<p>Holds information about an account.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>@dataclass\nclass AccountData:\n    \"\"\"Holds information about an account.\"\"\"\n\n    #: The date on which this account is closed (or datetime.date.max).\n    close_date: datetime.date | None = None\n\n    #: The metadata of the Open entry of this account.\n    meta: Meta = field(default_factory=dict)\n\n    #: Uptodate status. Is only computed if the account has a\n    #: \"fava-uptodate-indication\" meta attribute.\n    uptodate_status: Literal[\"green\", \"yellow\", \"red\"] | None = None\n\n    #: Balance directive if this account has an uptodate status.\n    balance_string: str | None = None\n\n    #: The last entry of the account (unless it is a close Entry)\n    last_entry: LastEntry | None = None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict","title":"<code>AccountDict</code>","text":"<p>               Bases: <code>FavaModule</code>, <code>dict[str, AccountData]</code></p> <p>Account info dictionary.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>class AccountDict(FavaModule, dict[str, AccountData]):\n    \"\"\"Account info dictionary.\"\"\"\n\n    EMPTY = AccountData()\n\n    def __missing__(self, key: str) -&gt; AccountData:\n        return self.EMPTY\n\n    def setdefault(\n        self,\n        key: str,\n        _: AccountData | None = None,\n    ) -&gt; AccountData:\n        \"\"\"Get the account of the given name, insert one if it is missing.\"\"\"\n        if key not in self:\n            self[key] = AccountData()\n        return self[key]\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.clear()\n        entries_by_account = group_entries_by_account(self.ledger.all_entries)\n        tree = Tree(self.ledger.all_entries)\n        for open_entry in self.ledger.all_entries_by_type.Open:\n            meta = open_entry.meta\n            account_data = self.setdefault(open_entry.account)\n            account_data.meta = meta\n\n            txn_postings = entries_by_account[open_entry.account]\n            last = get_last_entry(txn_postings)\n            if last is not None and not isinstance(last, Close):\n                account_data.last_entry = LastEntry(\n                    date=last.date,\n                    entry_hash=hash_entry(last),\n                )\n            if meta.get(\"fava-uptodate-indication\"):\n                account_data.uptodate_status = uptodate_status(txn_postings)\n                if account_data.uptodate_status != \"green\":\n                    account_data.balance_string = balance_string(\n                        tree.get(open_entry.account),\n                    )\n        for close in self.ledger.all_entries_by_type.Close:\n            self.setdefault(close.account).close_date = close.date\n\n    def all_balance_directives(self) -&gt; str:\n        \"\"\"Balance directives for all accounts.\"\"\"\n        return \"\".join(\n            account_details.balance_string\n            for account_details in self.values()\n            if account_details.balance_string\n        )\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict.setdefault","title":"<code>setdefault(key, _=None)</code>","text":"<p>Get the account of the given name, insert one if it is missing.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def setdefault(\n    self,\n    key: str,\n    _: AccountData | None = None,\n) -&gt; AccountData:\n    \"\"\"Get the account of the given name, insert one if it is missing.\"\"\"\n    if key not in self:\n        self[key] = AccountData()\n    return self[key]\n</code></pre>"},{"location":"api/#rustfava.core.accounts.AccountDict.all_balance_directives","title":"<code>all_balance_directives()</code>","text":"<p>Balance directives for all accounts.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def all_balance_directives(self) -&gt; str:\n    \"\"\"Balance directives for all accounts.\"\"\"\n    return \"\".join(\n        account_details.balance_string\n        for account_details in self.values()\n        if account_details.balance_string\n    )\n</code></pre>"},{"location":"api/#rustfava.core.accounts.get_last_entry","title":"<code>get_last_entry(txn_postings)</code>","text":"<p>Last entry.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def get_last_entry(\n    txn_postings: Sequence[Directive | TransactionPosting],\n) -&gt; Directive | None:\n    \"\"\"Last entry.\"\"\"\n    for txn_posting in reversed(txn_postings):\n        if isinstance(txn_posting, TransactionPosting):\n            transaction = txn_posting.transaction\n            if transaction.flag != FLAG_UNREALIZED:\n                return transaction\n        else:\n            return txn_posting\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.uptodate_status","title":"<code>uptodate_status(txn_postings)</code>","text":"<p>Status of the last balance or transaction.</p> <p>Parameters:</p> Name Type Description Default <code>txn_postings</code> <code>Sequence[Directive | TransactionPosting]</code> <p>The TransactionPosting for the account.</p> required <p>Returns:</p> Type Description <code>Literal['green', 'yellow', 'red'] | None</code> <p>A status string for the last balance or transaction of the account.</p> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'green':  A balance check that passed.</li> </ul> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'red':    A balance check that failed.</li> </ul> <code>Literal['green', 'yellow', 'red'] | None</code> <ul> <li>'yellow': Not a balance check.</li> </ul> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def uptodate_status(\n    txn_postings: Sequence[Directive | TransactionPosting],\n) -&gt; Literal[\"green\", \"yellow\", \"red\"] | None:\n    \"\"\"Status of the last balance or transaction.\n\n    Args:\n        txn_postings: The TransactionPosting for the account.\n\n    Returns:\n        A status string for the last balance or transaction of the account.\n\n        - 'green':  A balance check that passed.\n        - 'red':    A balance check that failed.\n        - 'yellow': Not a balance check.\n    \"\"\"\n    for txn_posting in reversed(txn_postings):\n        if isinstance(txn_posting, Balance):\n            return \"red\" if txn_posting.diff_amount else \"green\"\n        if (\n            isinstance(txn_posting, TransactionPosting)\n            and txn_posting.transaction.flag != FLAG_UNREALIZED\n        ):\n            return \"yellow\"\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.accounts.balance_string","title":"<code>balance_string(tree_node)</code>","text":"<p>Balance directive for the given account for today.</p> Source code in <code>src/rustfava/core/accounts.py</code> <pre><code>def balance_string(tree_node: TreeNode) -&gt; str:\n    \"\"\"Balance directive for the given account for today.\"\"\"\n    account = tree_node.name\n    today = str(local_today())\n    res = \"\"\n    for currency, number in UNITS.apply(tree_node.balance).items():\n        res += f\"{today} balance {account:&lt;28} {number:&gt;15} {currency}\\n\"\n    return res\n</code></pre>"},{"location":"api/#rustfava.core.attributes","title":"<code>attributes</code>","text":"<p>Attributes for auto-completion.</p>"},{"location":"api/#rustfava.core.attributes.AttributesModule","title":"<code>AttributesModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Some attributes of the ledger (mostly for auto-completion).</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>class AttributesModule(FavaModule):\n    \"\"\"Some attributes of the ledger (mostly for auto-completion).\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.accounts: Sequence[str] = []\n        self.currencies: Sequence[str] = []\n        self.payees: Sequence[str] = []\n        self.links: Sequence[str] = []\n        self.tags: Sequence[str] = []\n        self.years: Sequence[str] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        all_entries = self.ledger.all_entries\n\n        all_links = set()\n        all_tags = set()\n        for entry in all_entries:\n            links = getattr(entry, \"links\", None)\n            if links is not None:\n                all_links.update(links)\n            tags = getattr(entry, \"tags\", None)\n            if tags is not None:\n                all_tags.update(tags)\n        self.links = sorted(all_links)\n        self.tags = sorted(all_tags)\n\n        self.years = get_active_years(\n            all_entries,\n            self.ledger.fava_options.fiscal_year_end,\n        )\n\n        account_ranker = ExponentialDecayRanker(\n            sorted(self.ledger.accounts.keys()),\n        )\n        currency_ranker = ExponentialDecayRanker()\n        payee_ranker = ExponentialDecayRanker()\n\n        for txn in self.ledger.all_entries_by_type.Transaction:\n            if txn.payee:\n                payee_ranker.update(txn.payee, txn.date)\n            for posting in txn.postings:\n                account_ranker.update(posting.account, txn.date)\n                # Skip postings with missing units (can happen with parse errors)\n                if posting.units is not None:\n                    currency_ranker.update(posting.units.currency, txn.date)\n                if posting.cost and posting.cost.currency is not None:\n                    currency_ranker.update(posting.cost.currency, txn.date)\n\n        self.accounts = account_ranker.sort()\n        self.currencies = currency_ranker.sort()\n        self.payees = payee_ranker.sort()\n\n    def payee_accounts(self, payee: str) -&gt; Sequence[str]:\n        \"\"\"Rank accounts for the given payee.\"\"\"\n        account_ranker = ExponentialDecayRanker(self.accounts)\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in transactions:\n            if txn.payee == payee:\n                for posting in txn.postings:\n                    account_ranker.update(posting.account, txn.date)\n        return account_ranker.sort()\n\n    def payee_transaction(self, payee: str) -&gt; Transaction | None:\n        \"\"\"Get the last transaction for a payee.\"\"\"\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in reversed(transactions):\n            if txn.payee == payee:\n                return txn\n        return None\n\n    def narration_transaction(self, narration: str) -&gt; Transaction | None:\n        \"\"\"Get the last transaction for a narration.\"\"\"\n        transactions = self.ledger.all_entries_by_type.Transaction\n        for txn in reversed(transactions):\n            if txn.narration == narration:\n                return txn\n        return None\n\n    @property\n    def narrations(self) -&gt; Sequence[str]:\n        \"\"\"Get the narrations of all transactions.\"\"\"\n        narration_ranker = ExponentialDecayRanker()\n        for txn in self.ledger.all_entries_by_type.Transaction:\n            if txn.narration:\n                narration_ranker.update(txn.narration, txn.date)\n        return narration_ranker.sort()\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.narrations","title":"<code>narrations</code>  <code>property</code>","text":"<p>Get the narrations of all transactions.</p>"},{"location":"api/#rustfava.core.attributes.AttributesModule.payee_accounts","title":"<code>payee_accounts(payee)</code>","text":"<p>Rank accounts for the given payee.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def payee_accounts(self, payee: str) -&gt; Sequence[str]:\n    \"\"\"Rank accounts for the given payee.\"\"\"\n    account_ranker = ExponentialDecayRanker(self.accounts)\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in transactions:\n        if txn.payee == payee:\n            for posting in txn.postings:\n                account_ranker.update(posting.account, txn.date)\n    return account_ranker.sort()\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.payee_transaction","title":"<code>payee_transaction(payee)</code>","text":"<p>Get the last transaction for a payee.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def payee_transaction(self, payee: str) -&gt; Transaction | None:\n    \"\"\"Get the last transaction for a payee.\"\"\"\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in reversed(transactions):\n        if txn.payee == payee:\n            return txn\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.attributes.AttributesModule.narration_transaction","title":"<code>narration_transaction(narration)</code>","text":"<p>Get the last transaction for a narration.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def narration_transaction(self, narration: str) -&gt; Transaction | None:\n    \"\"\"Get the last transaction for a narration.\"\"\"\n    transactions = self.ledger.all_entries_by_type.Transaction\n    for txn in reversed(transactions):\n        if txn.narration == narration:\n            return txn\n    return None\n</code></pre>"},{"location":"api/#rustfava.core.attributes.get_active_years","title":"<code>get_active_years(entries, fye)</code>","text":"<p>Return active years, with support for fiscal years.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>Beancount entries</p> required <code>fye</code> <code>FiscalYearEnd</code> <p>fiscal year end</p> required <p>Returns:</p> Type Description <code>list[str]</code> <p>A reverse sorted list of years or fiscal years that occur in the</p> <code>list[str]</code> <p>entries.</p> Source code in <code>src/rustfava/core/attributes.py</code> <pre><code>def get_active_years(\n    entries: Sequence[Directive],\n    fye: FiscalYearEnd,\n) -&gt; list[str]:\n    \"\"\"Return active years, with support for fiscal years.\n\n    Args:\n        entries: Beancount entries\n        fye: fiscal year end\n\n    Returns:\n        A reverse sorted list of years or fiscal years that occur in the\n        entries.\n    \"\"\"\n    years = []\n    if fye == END_OF_YEAR:\n        prev_year = None\n        for entry in entries:\n            year = entry.date.year\n            if year != prev_year:\n                prev_year = year\n                years.append(year)\n        return [f\"{year}\" for year in reversed(years)]\n    month = fye.month\n    day = fye.day\n    prev_year = None\n    for entry in entries:\n        date = entry.date\n        year = (\n            entry.date.year + 1\n            if date.month &gt; month or (date.month == month and date.day &gt; day)\n            else entry.date.year\n        )\n        if year != prev_year:\n            prev_year = year\n            years.append(year)\n    return [f\"FY{year}\" for year in reversed(years)]\n</code></pre>"},{"location":"api/#rustfava.core.budgets","title":"<code>budgets</code>","text":"<p>Parsing and computing budgets.</p>"},{"location":"api/#rustfava.core.budgets.BudgetDict","title":"<code>BudgetDict = dict[str, list[Budget]]</code>  <code>module-attribute</code>","text":"<p>A map of account names to lists of budget entries.</p>"},{"location":"api/#rustfava.core.budgets.Budget","title":"<code>Budget</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>A budget entry.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class Budget(NamedTuple):\n    \"\"\"A budget entry.\"\"\"\n\n    account: str\n    date_start: datetime.date\n    period: Interval\n    number: Decimal\n    currency: str\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetError","title":"<code>BudgetError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>Error with a budget.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class BudgetError(BeancountError):\n    \"\"\"Error with a budget.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule","title":"<code>BudgetModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Parses budget entries.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>class BudgetModule(FavaModule):\n    \"\"\"Parses budget entries.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._budget_entries: BudgetDict = {}\n        self.errors: Sequence[BudgetError] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self._budget_entries, self.errors = parse_budgets(\n            self.ledger.all_entries_by_type.Custom,\n        )\n\n    def calculate(\n        self,\n        account: str,\n        begin_date: datetime.date,\n        end_date: datetime.date,\n    ) -&gt; Mapping[str, Decimal]:\n        \"\"\"Calculate the budget for an account in an interval.\"\"\"\n        return calculate_budget(\n            self._budget_entries,\n            account,\n            begin_date,\n            end_date,\n        )\n\n    def calculate_children(\n        self,\n        account: str,\n        begin_date: datetime.date,\n        end_date: datetime.date,\n    ) -&gt; Mapping[str, Decimal]:\n        \"\"\"Calculate the budget for an account including its children.\"\"\"\n        return calculate_budget_children(\n            self._budget_entries,\n            account,\n            begin_date,\n            end_date,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule.calculate","title":"<code>calculate(account, begin_date, end_date)</code>","text":"<p>Calculate the budget for an account in an interval.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate(\n    self,\n    account: str,\n    begin_date: datetime.date,\n    end_date: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate the budget for an account in an interval.\"\"\"\n    return calculate_budget(\n        self._budget_entries,\n        account,\n        begin_date,\n        end_date,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.BudgetModule.calculate_children","title":"<code>calculate_children(account, begin_date, end_date)</code>","text":"<p>Calculate the budget for an account including its children.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_children(\n    self,\n    account: str,\n    begin_date: datetime.date,\n    end_date: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate the budget for an account including its children.\"\"\"\n    return calculate_budget_children(\n        self._budget_entries,\n        account,\n        begin_date,\n        end_date,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.budgets.parse_budgets","title":"<code>parse_budgets(custom_entries)</code>","text":"<p>Parse budget directives from custom entries.</p> <p>Parameters:</p> Name Type Description Default <code>custom_entries</code> <code>Sequence[Custom]</code> <p>the Custom entries to parse budgets from.</p> required <p>Returns:</p> Type Description <code>tuple[BudgetDict, Sequence[BudgetError]]</code> <p>A dict of accounts to lists of budgets.</p> Example <p>2015-04-09 custom \"budget\" Expenses:Books \"monthly\" 20.00 EUR</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def parse_budgets(\n    custom_entries: Sequence[Custom],\n) -&gt; tuple[BudgetDict, Sequence[BudgetError]]:\n    \"\"\"Parse budget directives from custom entries.\n\n    Args:\n        custom_entries: the Custom entries to parse budgets from.\n\n    Returns:\n        A dict of accounts to lists of budgets.\n\n    Example:\n        2015-04-09 custom \"budget\" Expenses:Books \"monthly\" 20.00 EUR\n    \"\"\"\n    budgets: BudgetDict = defaultdict(list)\n    errors = []\n\n    for entry in (entry for entry in custom_entries if entry.type == \"budget\"):\n        try:\n            interval = INTERVALS.get(str(entry.values[1].value).lower())\n            if not interval:\n                errors.append(\n                    BudgetError(\n                        entry.meta,\n                        \"Invalid interval for budget entry\",\n                        entry,\n                    ),\n                )\n                continue\n            budget = Budget(\n                entry.values[0].value,\n                entry.date,\n                interval,\n                entry.values[2].value.number,\n                entry.values[2].value.currency,\n            )\n            budgets[budget.account].append(budget)\n        except (IndexError, TypeError):\n            errors.append(\n                BudgetError(entry.meta, \"Failed to parse budget entry\", entry),\n            )\n\n    return budgets, errors\n</code></pre>"},{"location":"api/#rustfava.core.budgets.calculate_budget","title":"<code>calculate_budget(budgets, account, date_from, date_to)</code>","text":"<p>Calculate budget for an account.</p> <p>Parameters:</p> Name Type Description Default <code>budgets</code> <code>BudgetDict</code> <p>A list of :class:<code>Budget</code> entries.</p> required <code>account</code> <code>str</code> <p>An account name.</p> required <code>date_from</code> <code>date</code> <p>Starting date.</p> required <code>date_to</code> <code>date</code> <p>End date (exclusive).</p> required <p>Returns:</p> Type Description <code>Mapping[str, Decimal]</code> <p>A dictionary of currency to Decimal with the budget for the</p> <code>Mapping[str, Decimal]</code> <p>specified account and period.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_budget(\n    budgets: BudgetDict,\n    account: str,\n    date_from: datetime.date,\n    date_to: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate budget for an account.\n\n    Args:\n        budgets: A list of :class:`Budget` entries.\n        account: An account name.\n        date_from: Starting date.\n        date_to: End date (exclusive).\n\n    Returns:\n        A dictionary of currency to Decimal with the budget for the\n        specified account and period.\n    \"\"\"\n    budget_list = budgets.get(account, None)\n    if budget_list is None:\n        return {}\n\n    currency_dict: dict[str, Decimal] = defaultdict(Decimal)\n\n    for day in days_in_daterange(date_from, date_to):\n        matches = _matching_budgets(budget_list, day)\n        for budget in matches.values():\n            days_in_period = budget.period.number_of_days(day)\n            currency_dict[budget.currency] += budget.number / days_in_period\n    return dict(currency_dict)\n</code></pre>"},{"location":"api/#rustfava.core.budgets.calculate_budget_children","title":"<code>calculate_budget_children(budgets, account, date_from, date_to)</code>","text":"<p>Calculate budget for an account including budgets of its children.</p> <p>Parameters:</p> Name Type Description Default <code>budgets</code> <code>BudgetDict</code> <p>A list of :class:<code>Budget</code> entries.</p> required <code>account</code> <code>str</code> <p>An account name.</p> required <code>date_from</code> <code>date</code> <p>Starting date.</p> required <code>date_to</code> <code>date</code> <p>End date (exclusive).</p> required <p>Returns:</p> Type Description <code>Mapping[str, Decimal]</code> <p>A dictionary of currency to Decimal with the budget for the</p> <code>Mapping[str, Decimal]</code> <p>specified account and period.</p> Source code in <code>src/rustfava/core/budgets.py</code> <pre><code>def calculate_budget_children(\n    budgets: BudgetDict,\n    account: str,\n    date_from: datetime.date,\n    date_to: datetime.date,\n) -&gt; Mapping[str, Decimal]:\n    \"\"\"Calculate budget for an account including budgets of its children.\n\n    Args:\n        budgets: A list of :class:`Budget` entries.\n        account: An account name.\n        date_from: Starting date.\n        date_to: End date (exclusive).\n\n    Returns:\n        A dictionary of currency to Decimal with the budget for the\n        specified account and period.\n    \"\"\"\n    currency_dict: dict[str, Decimal] = Counter()  # type: ignore[assignment]\n\n    for child in budgets:\n        if child.startswith(account):\n            currency_dict.update(\n                calculate_budget(budgets, child, date_from, date_to),\n            )\n    return dict(currency_dict)\n</code></pre>"},{"location":"api/#rustfava.core.charts","title":"<code>charts</code>","text":"<p>Provide data suitable for rustfava's charts.</p>"},{"location":"api/#rustfava.core.charts.RustfavaJSONProvider","title":"<code>RustfavaJSONProvider</code>","text":"<p>               Bases: <code>JSONProvider</code></p> <p>Use custom JSON encoder and decoder.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>class RustfavaJSONProvider(JSONProvider):\n    \"\"\"Use custom JSON encoder and decoder.\"\"\"\n\n    def dumps(self, obj: Any, **_kwargs: Any) -&gt; str:  # noqa: D102\n        return json.dumps(\n            obj, sort_keys=True, separators=(\",\", \":\"), default=_json_default\n        )\n\n    def loads(self, s: str | bytes, **_kwargs: Any) -&gt; Any:  # noqa: D102\n        return json.loads(s)\n</code></pre>"},{"location":"api/#rustfava.core.charts.DateAndBalance","title":"<code>DateAndBalance</code>  <code>dataclass</code>","text":"<p>Balance at a date.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@dataclass(frozen=True)\nclass DateAndBalance:\n    \"\"\"Balance at a date.\"\"\"\n\n    date: date\n    balance: SimpleCounterInventory\n</code></pre>"},{"location":"api/#rustfava.core.charts.DateAndBalanceWithBudget","title":"<code>DateAndBalanceWithBudget</code>  <code>dataclass</code>","text":"<p>Balance at a date with a budget.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@dataclass(frozen=True)\nclass DateAndBalanceWithBudget:\n    \"\"\"Balance at a date with a budget.\"\"\"\n\n    date: date\n    balance: SimpleCounterInventory\n    account_balances: Mapping[str, SimpleCounterInventory]\n    budgets: Mapping[str, Decimal]\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule","title":"<code>ChartModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Return data for the various charts in rustfava.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>class ChartModule(FavaModule):\n    \"\"\"Return data for the various charts in rustfava.\"\"\"\n\n    def hierarchy(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: Conversion,\n    ) -&gt; SerialisedTreeNode:\n        \"\"\"Render an account tree.\"\"\"\n        tree = filtered.root_tree\n        return tree.get(account_name).serialise(\n            conversion, self.ledger.prices, filtered.end_date\n        )\n\n    @listify\n    def interval_totals(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        accounts: str | tuple[str, ...],\n        conversion: str | Conversion,\n        *,\n        invert: bool = False,\n    ) -&gt; Iterable[DateAndBalanceWithBudget]:\n        \"\"\"Render totals for account (or accounts) in the intervals.\n\n        Args:\n            filtered: The filtered ledger.\n            interval: An interval.\n            accounts: A single account (str) or a tuple of accounts.\n            conversion: The conversion to use.\n            invert: invert all numbers.\n\n        Yields:\n            The balances and budgets for the intervals.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        prices = self.ledger.prices\n\n        # limit the bar charts to 100 intervals\n        intervals = filtered.interval_ranges(interval)[-100:]\n\n        for date_range in intervals:\n            inventory = CounterInventory()\n            entries = slice_entry_dates(\n                filtered.entries, date_range.begin, date_range.end\n            )\n            account_inventories: dict[str, CounterInventory] = defaultdict(\n                CounterInventory,\n            )\n            for entry in entries:\n                for posting in getattr(entry, \"postings\", []):\n                    if posting.account.startswith(accounts):\n                        account_inventories[posting.account].add_position(\n                            posting,\n                        )\n                        inventory.add_position(posting)\n            balance = conv.apply(\n                inventory,\n                prices,\n                date_range.end_inclusive,\n            )\n            account_balances = {\n                account: conv.apply(\n                    acct_value,\n                    prices,\n                    date_range.end_inclusive,\n                )\n                for account, acct_value in account_inventories.items()\n            }\n            budgets = (\n                self.ledger.budgets.calculate_children(\n                    accounts,\n                    date_range.begin,\n                    date_range.end,\n                )\n                if isinstance(accounts, str)\n                else {}\n            )\n\n            if invert:\n                balance = -balance\n                budgets = {k: -v for k, v in budgets.items()}\n                account_balances = {k: -v for k, v in account_balances.items()}\n\n            yield DateAndBalanceWithBudget(\n                date_range.end_inclusive,\n                balance,\n                account_balances,\n                budgets,\n            )\n\n    @listify\n    def linechart(\n        self,\n        filtered: FilteredLedger,\n        account_name: str,\n        conversion: str | Conversion,\n    ) -&gt; Iterable[DateAndBalance]:\n        \"\"\"Get the balance of an account as a line chart.\n\n        Args:\n            filtered: The filtered ledger.\n            account_name: A string.\n            conversion: The conversion to use.\n\n        Yields:\n            Dicts for all dates on which the balance of the given\n            account has changed containing the balance (in units) of the\n            account at that date.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n\n        def _balances() -&gt; Iterable[tuple[date, CounterInventory]]:\n            last_date = None\n            running_balance = CounterInventory()\n            is_child_account = account_tester(account_name, with_children=True)\n\n            for entry in filtered.entries:\n                for posting in getattr(entry, \"postings\", []):\n                    if is_child_account(posting.account):\n                        new_date = entry.date\n                        if last_date is not None and new_date &gt; last_date:\n                            yield (last_date, running_balance)\n                        running_balance.add_position(posting)\n                        last_date = new_date\n\n            if last_date is not None:\n                yield (last_date, running_balance)\n\n        # When the balance for a commodity just went to zero, it will be\n        # missing from the 'balance' so keep track of currencies that last had\n        # a balance.\n        last_currencies = None\n        prices = self.ledger.prices\n\n        for d, running_bal in _balances():\n            balance = conv.apply(running_bal, prices, d)\n            currencies = set(balance.keys())\n            if last_currencies:\n                for currency in last_currencies - currencies:\n                    balance[currency] = ZERO\n            last_currencies = currencies\n            yield DateAndBalance(d, balance)\n\n    @listify\n    def net_worth(\n        self,\n        filtered: FilteredLedger,\n        interval: Interval,\n        conversion: str | Conversion,\n    ) -&gt; Iterable[DateAndBalance]:\n        \"\"\"Compute net worth.\n\n        Args:\n            filtered: The filtered ledger.\n            interval: A string for the interval.\n            conversion: The conversion to use.\n\n        Yields:\n            Dicts for all ends of the given interval containing the\n            net worth (Assets + Liabilities) separately converted to all\n            operating currencies.\n        \"\"\"\n        conv = conversion_from_str(conversion)\n        transactions = (\n            entry\n            for entry in filtered.entries\n            if (\n                isinstance(entry, Transaction)\n                and entry.flag != FLAG_UNREALIZED\n            )\n        )\n\n        types = (\n            self.ledger.options[\"name_assets\"],\n            self.ledger.options[\"name_liabilities\"],\n        )\n\n        txn = next(transactions, None)\n        inventory = CounterInventory()\n\n        prices = self.ledger.prices\n        for date_range in filtered.interval_ranges(interval):\n            while txn and txn.date &lt; date_range.end:\n                for posting in txn.postings:\n                    if posting.account.startswith(types):\n                        inventory.add_position(posting)\n                txn = next(transactions, None)\n            yield DateAndBalance(\n                date_range.end_inclusive,\n                conv.apply(\n                    inventory,\n                    prices,\n                    date_range.end_inclusive,\n                ),\n            )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.hierarchy","title":"<code>hierarchy(filtered, account_name, conversion)</code>","text":"<p>Render an account tree.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def hierarchy(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: Conversion,\n) -&gt; SerialisedTreeNode:\n    \"\"\"Render an account tree.\"\"\"\n    tree = filtered.root_tree\n    return tree.get(account_name).serialise(\n        conversion, self.ledger.prices, filtered.end_date\n    )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.interval_totals","title":"<code>interval_totals(filtered, interval, accounts, conversion, *, invert=False)</code>","text":"<p>Render totals for account (or accounts) in the intervals.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>An interval.</p> required <code>accounts</code> <code>str | tuple[str, ...]</code> <p>A single account (str) or a tuple of accounts.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <code>invert</code> <code>bool</code> <p>invert all numbers.</p> <code>False</code> <p>Yields:</p> Type Description <code>Iterable[DateAndBalanceWithBudget]</code> <p>The balances and budgets for the intervals.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef interval_totals(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    accounts: str | tuple[str, ...],\n    conversion: str | Conversion,\n    *,\n    invert: bool = False,\n) -&gt; Iterable[DateAndBalanceWithBudget]:\n    \"\"\"Render totals for account (or accounts) in the intervals.\n\n    Args:\n        filtered: The filtered ledger.\n        interval: An interval.\n        accounts: A single account (str) or a tuple of accounts.\n        conversion: The conversion to use.\n        invert: invert all numbers.\n\n    Yields:\n        The balances and budgets for the intervals.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    prices = self.ledger.prices\n\n    # limit the bar charts to 100 intervals\n    intervals = filtered.interval_ranges(interval)[-100:]\n\n    for date_range in intervals:\n        inventory = CounterInventory()\n        entries = slice_entry_dates(\n            filtered.entries, date_range.begin, date_range.end\n        )\n        account_inventories: dict[str, CounterInventory] = defaultdict(\n            CounterInventory,\n        )\n        for entry in entries:\n            for posting in getattr(entry, \"postings\", []):\n                if posting.account.startswith(accounts):\n                    account_inventories[posting.account].add_position(\n                        posting,\n                    )\n                    inventory.add_position(posting)\n        balance = conv.apply(\n            inventory,\n            prices,\n            date_range.end_inclusive,\n        )\n        account_balances = {\n            account: conv.apply(\n                acct_value,\n                prices,\n                date_range.end_inclusive,\n            )\n            for account, acct_value in account_inventories.items()\n        }\n        budgets = (\n            self.ledger.budgets.calculate_children(\n                accounts,\n                date_range.begin,\n                date_range.end,\n            )\n            if isinstance(accounts, str)\n            else {}\n        )\n\n        if invert:\n            balance = -balance\n            budgets = {k: -v for k, v in budgets.items()}\n            account_balances = {k: -v for k, v in account_balances.items()}\n\n        yield DateAndBalanceWithBudget(\n            date_range.end_inclusive,\n            balance,\n            account_balances,\n            budgets,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.linechart","title":"<code>linechart(filtered, account_name, conversion)</code>","text":"<p>Get the balance of an account as a line chart.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>account_name</code> <code>str</code> <p>A string.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <p>Yields:</p> Type Description <code>Iterable[DateAndBalance]</code> <p>Dicts for all dates on which the balance of the given</p> <code>Iterable[DateAndBalance]</code> <p>account has changed containing the balance (in units) of the</p> <code>Iterable[DateAndBalance]</code> <p>account at that date.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef linechart(\n    self,\n    filtered: FilteredLedger,\n    account_name: str,\n    conversion: str | Conversion,\n) -&gt; Iterable[DateAndBalance]:\n    \"\"\"Get the balance of an account as a line chart.\n\n    Args:\n        filtered: The filtered ledger.\n        account_name: A string.\n        conversion: The conversion to use.\n\n    Yields:\n        Dicts for all dates on which the balance of the given\n        account has changed containing the balance (in units) of the\n        account at that date.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n\n    def _balances() -&gt; Iterable[tuple[date, CounterInventory]]:\n        last_date = None\n        running_balance = CounterInventory()\n        is_child_account = account_tester(account_name, with_children=True)\n\n        for entry in filtered.entries:\n            for posting in getattr(entry, \"postings\", []):\n                if is_child_account(posting.account):\n                    new_date = entry.date\n                    if last_date is not None and new_date &gt; last_date:\n                        yield (last_date, running_balance)\n                    running_balance.add_position(posting)\n                    last_date = new_date\n\n        if last_date is not None:\n            yield (last_date, running_balance)\n\n    # When the balance for a commodity just went to zero, it will be\n    # missing from the 'balance' so keep track of currencies that last had\n    # a balance.\n    last_currencies = None\n    prices = self.ledger.prices\n\n    for d, running_bal in _balances():\n        balance = conv.apply(running_bal, prices, d)\n        currencies = set(balance.keys())\n        if last_currencies:\n            for currency in last_currencies - currencies:\n                balance[currency] = ZERO\n        last_currencies = currencies\n        yield DateAndBalance(d, balance)\n</code></pre>"},{"location":"api/#rustfava.core.charts.ChartModule.net_worth","title":"<code>net_worth(filtered, interval, conversion)</code>","text":"<p>Compute net worth.</p> <p>Parameters:</p> Name Type Description Default <code>filtered</code> <code>FilteredLedger</code> <p>The filtered ledger.</p> required <code>interval</code> <code>Interval</code> <p>A string for the interval.</p> required <code>conversion</code> <code>str | Conversion</code> <p>The conversion to use.</p> required <p>Yields:</p> Type Description <code>Iterable[DateAndBalance]</code> <p>Dicts for all ends of the given interval containing the</p> <code>Iterable[DateAndBalance]</code> <p>net worth (Assets + Liabilities) separately converted to all</p> <code>Iterable[DateAndBalance]</code> <p>operating currencies.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>@listify\ndef net_worth(\n    self,\n    filtered: FilteredLedger,\n    interval: Interval,\n    conversion: str | Conversion,\n) -&gt; Iterable[DateAndBalance]:\n    \"\"\"Compute net worth.\n\n    Args:\n        filtered: The filtered ledger.\n        interval: A string for the interval.\n        conversion: The conversion to use.\n\n    Yields:\n        Dicts for all ends of the given interval containing the\n        net worth (Assets + Liabilities) separately converted to all\n        operating currencies.\n    \"\"\"\n    conv = conversion_from_str(conversion)\n    transactions = (\n        entry\n        for entry in filtered.entries\n        if (\n            isinstance(entry, Transaction)\n            and entry.flag != FLAG_UNREALIZED\n        )\n    )\n\n    types = (\n        self.ledger.options[\"name_assets\"],\n        self.ledger.options[\"name_liabilities\"],\n    )\n\n    txn = next(transactions, None)\n    inventory = CounterInventory()\n\n    prices = self.ledger.prices\n    for date_range in filtered.interval_ranges(interval):\n        while txn and txn.date &lt; date_range.end:\n            for posting in txn.postings:\n                if posting.account.startswith(types):\n                    inventory.add_position(posting)\n            txn = next(transactions, None)\n        yield DateAndBalance(\n            date_range.end_inclusive,\n            conv.apply(\n                inventory,\n                prices,\n                date_range.end_inclusive,\n            ),\n        )\n</code></pre>"},{"location":"api/#rustfava.core.charts.dumps","title":"<code>dumps(obj, **_kwargs)</code>","text":"<p>Dump as a JSON string.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def dumps(obj: Any, **_kwargs: Any) -&gt; str:\n    \"\"\"Dump as a JSON string.\"\"\"\n    return json.dumps(\n        obj, sort_keys=True, separators=(\",\", \":\"), default=_json_default\n    )\n</code></pre>"},{"location":"api/#rustfava.core.charts.loads","title":"<code>loads(s)</code>","text":"<p>Load a JSON string.</p> Source code in <code>src/rustfava/core/charts.py</code> <pre><code>def loads(s: str | bytes) -&gt; Any:\n    \"\"\"Load a JSON string.\"\"\"\n    return json.loads(s)\n</code></pre>"},{"location":"api/#rustfava.core.commodities","title":"<code>commodities</code>","text":"<p>Attributes for auto-completion.</p>"},{"location":"api/#rustfava.core.commodities.CommoditiesModule","title":"<code>CommoditiesModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Details about the currencies and commodities.</p> Source code in <code>src/rustfava/core/commodities.py</code> <pre><code>class CommoditiesModule(FavaModule):\n    \"\"\"Details about the currencies and commodities.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.names: dict[str, str] = {}\n        self.precisions: dict[str, int] = {}\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.names = {}\n        self.precisions = {}\n        for commodity in self.ledger.all_entries_by_type.Commodity:\n            name = commodity.meta.get(\"name\")\n            if name:\n                self.names[commodity.currency] = str(name)\n            precision = commodity.meta.get(\"precision\")\n            if isinstance(precision, (str, int, Decimal)):\n                with suppress(ValueError):\n                    self.precisions[commodity.currency] = int(precision)\n\n    def name(self, commodity: str) -&gt; str:\n        \"\"\"Get the name of a commodity (or the commodity itself if not set).\"\"\"\n        return self.names.get(commodity, commodity)\n</code></pre>"},{"location":"api/#rustfava.core.commodities.CommoditiesModule.name","title":"<code>name(commodity)</code>","text":"<p>Get the name of a commodity (or the commodity itself if not set).</p> Source code in <code>src/rustfava/core/commodities.py</code> <pre><code>def name(self, commodity: str) -&gt; str:\n    \"\"\"Get the name of a commodity (or the commodity itself if not set).\"\"\"\n    return self.names.get(commodity, commodity)\n</code></pre>"},{"location":"api/#rustfava.core.conversion","title":"<code>conversion</code>","text":"<p>Commodity conversion helpers for Fava.</p> <p>All functions in this module will be automatically added as template filters.</p>"},{"location":"api/#rustfava.core.conversion.Conversion","title":"<code>Conversion</code>","text":"<p>               Bases: <code>ABC</code></p> <p>A conversion.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>class Conversion(ABC):\n    \"\"\"A conversion.\"\"\"\n\n    @abstractmethod\n    def apply(\n        self,\n        inventory: CounterInventory,\n        prices: RustfavaPriceMap,\n        date: datetime.date | None = None,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Apply the conversion to an inventory (CounterInventory).\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.conversion.Conversion.apply","title":"<code>apply(inventory, prices, date=None)</code>  <code>abstractmethod</code>","text":"<p>Apply the conversion to an inventory (CounterInventory).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>@abstractmethod\ndef apply(\n    self,\n    inventory: CounterInventory,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Apply the conversion to an inventory (CounterInventory).\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.conversion.get_cost","title":"<code>get_cost(pos)</code>","text":"<p>Return the total cost of a Position.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def get_cost(pos: Position) -&gt; Amount:\n    \"\"\"Return the total cost of a Position.\"\"\"\n    cost_ = pos.cost\n    return (\n        _Amount(cost_.number * pos.units.number, cost_.currency)\n        if cost_ is not None\n        else pos.units\n    )\n</code></pre>"},{"location":"api/#rustfava.core.conversion.get_market_value","title":"<code>get_market_value(pos, prices, date=None)</code>","text":"<p>Get the market value of a Position.</p> <p>This differs from the convert.get_value function in Beancount by returning the cost value if no price can be found.</p> <p>Parameters:</p> Name Type Description Default <code>pos</code> <code>Position</code> <p>A Position.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>A rustfavaPriceMap</p> required <code>date</code> <code>date | None</code> <p>A datetime.date instance to evaluate the value at, or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>Amount</code> <p>An Amount, with value converted or if the conversion failed just the</p> <code>Amount</code> <p>cost value (or the units if the position has no cost).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def get_market_value(\n    pos: Position,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; Amount:\n    \"\"\"Get the market value of a Position.\n\n    This differs from the convert.get_value function in Beancount by returning\n    the cost value if no price can be found.\n\n    Args:\n        pos: A Position.\n        prices: A rustfavaPriceMap\n        date: A datetime.date instance to evaluate the value at, or None.\n\n    Returns:\n        An Amount, with value converted or if the conversion failed just the\n        cost value (or the units if the position has no cost).\n    \"\"\"\n    units_ = pos.units\n    cost_ = pos.cost\n\n    if cost_ is not None:\n        value_currency = cost_.currency\n        base_quote = (units_.currency, value_currency)\n        price_number = prices.get_price(base_quote, date)\n        if price_number is not None:\n            return _Amount(\n                units_.number * price_number,\n                value_currency,\n            )\n        return _Amount(units_.number * cost_.number, value_currency)\n    return units_\n</code></pre>"},{"location":"api/#rustfava.core.conversion.convert_position","title":"<code>convert_position(pos, target_currency, prices, date=None)</code>","text":"<p>Get the value of a Position in a particular currency.</p> <p>Parameters:</p> Name Type Description Default <code>pos</code> <code>Position</code> <p>A Position.</p> required <code>target_currency</code> <code>str</code> <p>The target currency to convert to.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>A rustfavaPriceMap</p> required <code>date</code> <code>date | None</code> <p>A datetime.date instance to evaluate the value at, or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>Amount</code> <p>An Amount, with value converted or if the conversion failed just the</p> <code>Amount</code> <p>cost value (or the units if the position has no cost).</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def convert_position(\n    pos: Position,\n    target_currency: str,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; Amount:\n    \"\"\"Get the value of a Position in a particular currency.\n\n    Args:\n        pos: A Position.\n        target_currency: The target currency to convert to.\n        prices: A rustfavaPriceMap\n        date: A datetime.date instance to evaluate the value at, or None.\n\n    Returns:\n        An Amount, with value converted or if the conversion failed just the\n        cost value (or the units if the position has no cost).\n    \"\"\"\n    units_ = pos.units\n\n    # try the direct conversion\n    base_quote = (units_.currency, target_currency)\n    price_number = prices.get_price(base_quote, date)\n    if price_number is not None:\n        return _Amount(units_.number * price_number, target_currency)\n\n    cost_ = pos.cost\n    if cost_ is not None:\n        cost_currency = cost_.currency\n        if cost_currency != target_currency:\n            base_quote1 = (units_.currency, cost_currency)\n            rate1 = prices.get_price(base_quote1, date)\n            if rate1 is not None:\n                base_quote2 = (cost_currency, target_currency)\n                rate2 = prices.get_price(base_quote2, date)\n                if rate2 is not None:\n                    return _Amount(\n                        units_.number * rate1 * rate2,\n                        target_currency,\n                    )\n    return units_\n</code></pre>"},{"location":"api/#rustfava.core.conversion.conversion_from_str","title":"<code>conversion_from_str(value)</code>","text":"<p>Parse a conversion string.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def conversion_from_str(value: str | Conversion) -&gt; Conversion:\n    \"\"\"Parse a conversion string.\"\"\"\n    if not isinstance(value, str):\n        return value\n    if value == \"at_cost\":\n        return AT_COST\n    if value == \"at_value\":\n        return AT_VALUE\n    if value == \"units\":\n        return UNITS\n\n    return _CurrencyConversion(value)\n</code></pre>"},{"location":"api/#rustfava.core.conversion.cost_or_value","title":"<code>cost_or_value(inventory, conversion, prices, date=None)</code>","text":"<p>Get the cost or value of an inventory.</p> Source code in <code>src/rustfava/core/conversion.py</code> <pre><code>def cost_or_value(\n    inventory: CounterInventory,\n    conversion: str | Conversion,\n    prices: RustfavaPriceMap,\n    date: datetime.date | None = None,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Get the cost or value of an inventory.\"\"\"\n    conversion = conversion_from_str(conversion)\n    return conversion.apply(inventory, prices, date)\n</code></pre>"},{"location":"api/#rustfava.core.documents","title":"<code>documents</code>","text":"<p>Document path related helpers.</p>"},{"location":"api/#rustfava.core.documents.NotADocumentsFolderError","title":"<code>NotADocumentsFolderError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Not a documents folder.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>class NotADocumentsFolderError(RustfavaAPIError):\n    \"\"\"Not a documents folder.\"\"\"\n\n    def __init__(self, folder: str) -&gt; None:\n        super().__init__(f\"Not a documents folder: {folder}.\")\n</code></pre>"},{"location":"api/#rustfava.core.documents.NotAValidAccountError","title":"<code>NotAValidAccountError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Not a valid account.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>class NotAValidAccountError(RustfavaAPIError):\n    \"\"\"Not a valid account.\"\"\"\n\n    def __init__(self, account: str) -&gt; None:\n        super().__init__(f\"Not a valid account: '{account}'\")\n</code></pre>"},{"location":"api/#rustfava.core.documents.is_document_or_import_file","title":"<code>is_document_or_import_file(filename, ledger)</code>","text":"<p>Check whether the filename is a document or in an import directory.</p> <p>This is a security validation function that prevents path traversal.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The filename to check.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>bool</code> <p>Whether this is one of the documents or a path in an import dir.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>def is_document_or_import_file(filename: str, ledger: RustfavaLedger) -&gt; bool:\n    \"\"\"Check whether the filename is a document or in an import directory.\n\n    This is a security validation function that prevents path traversal.\n\n    Args:\n        filename: The filename to check.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        Whether this is one of the documents or a path in an import dir.\n    \"\"\"\n    # Check if it's an exact match for a known document\n    if any(\n        filename == d.filename for d in ledger.all_entries_by_type.Document\n    ):\n        return True\n    # Check if resolved path is within an import directory (prevents path traversal)\n    file_path = Path(filename).resolve()\n    for import_dir in ledger.fava_options.import_dirs:\n        resolved_dir = ledger.join_path(import_dir).resolve()\n        if file_path.is_relative_to(resolved_dir):\n            return True\n    return False\n</code></pre>"},{"location":"api/#rustfava.core.documents.filepath_in_document_folder","title":"<code>filepath_in_document_folder(documents_folder, account, filename, ledger)</code>","text":"<p>File path for a document in the folder for an account.</p> <p>Parameters:</p> Name Type Description Default <code>documents_folder</code> <code>str</code> <p>The documents folder.</p> required <code>account</code> <code>str</code> <p>The account to choose the subfolder for.</p> required <code>filename</code> <code>str</code> <p>The filename of the document.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>Path</code> <p>The path that the document should be saved at.</p> Source code in <code>src/rustfava/core/documents.py</code> <pre><code>def filepath_in_document_folder(\n    documents_folder: str,\n    account: str,\n    filename: str,\n    ledger: RustfavaLedger,\n) -&gt; Path:\n    \"\"\"File path for a document in the folder for an account.\n\n    Args:\n        documents_folder: The documents folder.\n        account: The account to choose the subfolder for.\n        filename: The filename of the document.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        The path that the document should be saved at.\n    \"\"\"\n    if documents_folder not in ledger.options[\"documents\"]:\n        raise NotADocumentsFolderError(documents_folder)\n\n    if account not in ledger.attributes.accounts:\n        raise NotAValidAccountError(account)\n\n    filename = filename.replace(sep, \" \")\n    if altsep:  # pragma: no cover\n        filename = filename.replace(altsep, \" \")\n\n    return ledger.join_path(\n        documents_folder,\n        *account.split(\":\"),\n        filename,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.extensions","title":"<code>extensions</code>","text":"<p>Fava extensions.</p>"},{"location":"api/#rustfava.core.extensions.ExtensionDetails","title":"<code>ExtensionDetails</code>  <code>dataclass</code>","text":"<p>The information about an extension that is needed for the frontend.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>@dataclass\nclass ExtensionDetails:\n    \"\"\"The information about an extension that is needed for the frontend.\"\"\"\n\n    name: str\n    report_title: str | None\n    has_js_module: bool\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule","title":"<code>ExtensionModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Fava extensions.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>class ExtensionModule(FavaModule):\n    \"\"\"Fava extensions.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._instances: dict[str, RustfavaExtensionBase] = {}\n        self._loaded_extensions: set[type[RustfavaExtensionBase]] = set()\n        self.errors: list[RustfavaExtensionError] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.errors = []\n\n        custom_entries = self.ledger.all_entries_by_type.Custom\n\n        seen = set()\n        for entry in (e for e in custom_entries if e.type == \"fava-extension\"):\n            extension = entry.values[0].value\n            if extension in seen:  # pragma: no cover\n                self.errors.append(\n                    RustfavaExtensionError(\n                        entry.meta, f\"Duplicate extension '{extension}'\", entry\n                    )\n                )\n                continue\n\n            seen.add(extension)\n            extensions, errors = find_extensions(\n                Path(self.ledger.beancount_file_path).parent,\n                extension,\n            )\n            self.errors.extend(errors)\n\n            for cls in extensions:\n                ext_config = (\n                    entry.values[1].value if len(entry.values) &gt; 1 else None\n                )\n                if cls not in self._loaded_extensions:\n                    self._loaded_extensions.add(cls)\n                    try:\n                        ext = cls(self.ledger, ext_config)\n                        self._instances[ext.name] = ext\n                    except ExtensionConfigError as error:  # pragma: no cover\n                        self.errors.append(\n                            RustfavaExtensionError(entry.meta, str(error), entry)\n                        )\n\n    @property\n    def _exts(self) -&gt; Iterable[RustfavaExtensionBase]:\n        return self._instances.values()\n\n    @property\n    def extension_details(self) -&gt; Sequence[ExtensionDetails]:\n        \"\"\"Extension information to provide to the Frontend.\"\"\"\n        return [\n            ExtensionDetails(ext.name, ext.report_title, ext.has_js_module)\n            for ext in self._exts\n        ]\n\n    def get_extension(self, name: str) -&gt; RustfavaExtensionBase | None:\n        \"\"\"Get the extension with the given name.\"\"\"\n        return self._instances.get(name, None)\n\n    def after_load_file(self) -&gt; None:\n        \"\"\"Run all `after_load_file` hooks.\"\"\"\n        for ext in self._exts:\n            ext.after_load_file()\n\n    def before_request(self) -&gt; None:\n        \"\"\"Run all `before_request` hooks.\"\"\"\n        for ext in self._exts:\n            ext.before_request()\n\n    def after_entry_modified(self, entry: Directive, new_lines: str) -&gt; None:\n        \"\"\"Run all `after_entry_modified` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_entry_modified(entry, new_lines)\n\n    def after_insert_entry(self, entry: Directive) -&gt; None:\n        \"\"\"Run all `after_insert_entry` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_insert_entry(entry)\n\n    def after_delete_entry(self, entry: Directive) -&gt; None:\n        \"\"\"Run all `after_delete_entry` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_delete_entry(entry)\n\n    def after_insert_metadata(\n        self,\n        entry: Directive,\n        key: str,\n        value: str,\n    ) -&gt; None:\n        \"\"\"Run all `after_insert_metadata` hooks.\"\"\"\n        for ext in self._exts:  # pragma: no cover\n            ext.after_insert_metadata(entry, key, value)\n\n    def after_write_source(self, path: str, source: str) -&gt; None:\n        \"\"\"Run all `after_write_source` hooks.\"\"\"\n        for ext in self._exts:\n            ext.after_write_source(path, source)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.extension_details","title":"<code>extension_details</code>  <code>property</code>","text":"<p>Extension information to provide to the Frontend.</p>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.get_extension","title":"<code>get_extension(name)</code>","text":"<p>Get the extension with the given name.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def get_extension(self, name: str) -&gt; RustfavaExtensionBase | None:\n    \"\"\"Get the extension with the given name.\"\"\"\n    return self._instances.get(name, None)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_load_file","title":"<code>after_load_file()</code>","text":"<p>Run all <code>after_load_file</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_load_file(self) -&gt; None:\n    \"\"\"Run all `after_load_file` hooks.\"\"\"\n    for ext in self._exts:\n        ext.after_load_file()\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.before_request","title":"<code>before_request()</code>","text":"<p>Run all <code>before_request</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def before_request(self) -&gt; None:\n    \"\"\"Run all `before_request` hooks.\"\"\"\n    for ext in self._exts:\n        ext.before_request()\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_entry_modified","title":"<code>after_entry_modified(entry, new_lines)</code>","text":"<p>Run all <code>after_entry_modified</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_entry_modified(self, entry: Directive, new_lines: str) -&gt; None:\n    \"\"\"Run all `after_entry_modified` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_entry_modified(entry, new_lines)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_insert_entry","title":"<code>after_insert_entry(entry)</code>","text":"<p>Run all <code>after_insert_entry</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_insert_entry(self, entry: Directive) -&gt; None:\n    \"\"\"Run all `after_insert_entry` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_insert_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_delete_entry","title":"<code>after_delete_entry(entry)</code>","text":"<p>Run all <code>after_delete_entry</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_delete_entry(self, entry: Directive) -&gt; None:\n    \"\"\"Run all `after_delete_entry` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_delete_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_insert_metadata","title":"<code>after_insert_metadata(entry, key, value)</code>","text":"<p>Run all <code>after_insert_metadata</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_insert_metadata(\n    self,\n    entry: Directive,\n    key: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Run all `after_insert_metadata` hooks.\"\"\"\n    for ext in self._exts:  # pragma: no cover\n        ext.after_insert_metadata(entry, key, value)\n</code></pre>"},{"location":"api/#rustfava.core.extensions.ExtensionModule.after_write_source","title":"<code>after_write_source(path, source)</code>","text":"<p>Run all <code>after_write_source</code> hooks.</p> Source code in <code>src/rustfava/core/extensions.py</code> <pre><code>def after_write_source(self, path: str, source: str) -&gt; None:\n    \"\"\"Run all `after_write_source` hooks.\"\"\"\n    for ext in self._exts:\n        ext.after_write_source(path, source)\n</code></pre>"},{"location":"api/#rustfava.core.fava_options","title":"<code>fava_options</code>","text":"<p>rustfava's options.</p> <p>Options for rustfava can be specified through Custom entries in the Beancount file. This module contains a list of possible options, the defaults and the code for parsing the options.</p>"},{"location":"api/#rustfava.core.fava_options.OptionError","title":"<code>OptionError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>An error for one of the rustfava options.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>class OptionError(BeancountError):\n    \"\"\"An error for one of the rustfava options.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.InsertEntryOption","title":"<code>InsertEntryOption</code>  <code>dataclass</code>","text":"<p>Insert option.</p> <p>An option that determines where entries for matching accounts should be inserted.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>@dataclass(frozen=True)\nclass InsertEntryOption:\n    \"\"\"Insert option.\n\n    An option that determines where entries for matching accounts should be\n    inserted.\n    \"\"\"\n\n    date: datetime.date\n    re: Pattern[str]\n    filename: str\n    lineno: int\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions","title":"<code>RustfavaOptions</code>  <code>dataclass</code>","text":"<p>Options for rustfava that can be set in the Beancount file.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>@dataclass\nclass RustfavaOptions:\n    \"\"\"Options for rustfava that can be set in the Beancount file.\"\"\"\n\n    account_journal_include_children: bool = True\n    auto_reload: bool = False\n    collapse_pattern: Sequence[Pattern[str]] = field(default_factory=list)\n    conversion_currencies: tuple[str, ...] = ()\n    currency_column: int = 61\n    default_file: str | None = None\n    default_page: str = \"income_statement/\"\n    fiscal_year_end: FiscalYearEnd = END_OF_YEAR\n    import_config: str | None = None\n    import_dirs: Sequence[str] = field(default_factory=list)\n    indent: int = 2\n    insert_entry: Sequence[InsertEntryOption] = field(default_factory=list)\n    invert_gains_losses_colors: bool = False\n    invert_income_liabilities_equity: bool = False\n    language: str | None = None\n    locale: str | None = None\n    show_accounts_with_zero_balance: bool = True\n    show_accounts_with_zero_transactions: bool = True\n    show_closed_accounts: bool = False\n    sidebar_show_queries: int = 5\n    unrealized: str = \"Unrealized\"\n    upcoming_events: int = 7\n    uptodate_indicator_grey_lookback_days: int = 60\n    use_external_editor: bool = False\n\n    def set_collapse_pattern(self, value: str) -&gt; None:\n        \"\"\"Set the collapse_pattern option.\"\"\"\n        try:\n            pattern = re.compile(value)\n        except re.error as err:\n            raise NotARegularExpressionError(value) from err\n        # It's typed as Sequence so that it's not externally mutated\n        self.collapse_pattern.append(pattern)  # type: ignore[attr-defined]\n\n    def set_default_file(self, value: str, filename: str) -&gt; None:\n        \"\"\"Set the default_file option.\"\"\"\n        self.default_file = (\n            str((Path(filename).parent / value).absolute())\n            if value\n            else filename\n        )\n\n    def set_fiscal_year_end(self, value: str) -&gt; None:\n        \"\"\"Set the fiscal_year_end option.\"\"\"\n        fye = parse_fye_string(value)\n        if fye is None:\n            raise InvalidFiscalYearEndOptionError(value)\n        self.fiscal_year_end = fye\n\n    def set_import_dirs(self, value: str) -&gt; None:\n        \"\"\"Add an import directory.\"\"\"\n        # It's typed as Sequence so that it's not externally mutated\n        self.import_dirs.append(value)  # type: ignore[attr-defined]\n\n    def set_insert_entry(\n        self, value: str, date: datetime.date, filename: str, lineno: int\n    ) -&gt; None:\n        \"\"\"Set the insert_entry option.\"\"\"\n        try:\n            pattern = re.compile(value)\n        except re.error as err:\n            raise NotARegularExpressionError(value) from err\n        opt = InsertEntryOption(date, pattern, filename, lineno)\n        # It's typed as Sequence so that it's not externally mutated\n        self.insert_entry.append(opt)  # type: ignore[attr-defined]\n\n    def set_language(self, value: str) -&gt; None:\n        \"\"\"Set the locale option.\"\"\"\n        try:\n            locale = Locale.parse(value)\n            if (\n                not locale.language == \"en\"\n                and get_translations(locale) is None\n            ):\n                raise UnsupportedLanguageOptionError(value)\n            self.language = value\n        except UnknownLocaleError as err:\n            raise UnknownLocaleOptionError(value) from err\n\n    def set_locale(self, value: str) -&gt; None:\n        \"\"\"Set the locale option.\"\"\"\n        try:\n            Locale.parse(value)\n            self.locale = value\n        except UnknownLocaleError as err:\n            raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_collapse_pattern","title":"<code>set_collapse_pattern(value)</code>","text":"<p>Set the collapse_pattern option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_collapse_pattern(self, value: str) -&gt; None:\n    \"\"\"Set the collapse_pattern option.\"\"\"\n    try:\n        pattern = re.compile(value)\n    except re.error as err:\n        raise NotARegularExpressionError(value) from err\n    # It's typed as Sequence so that it's not externally mutated\n    self.collapse_pattern.append(pattern)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_default_file","title":"<code>set_default_file(value, filename)</code>","text":"<p>Set the default_file option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_default_file(self, value: str, filename: str) -&gt; None:\n    \"\"\"Set the default_file option.\"\"\"\n    self.default_file = (\n        str((Path(filename).parent / value).absolute())\n        if value\n        else filename\n    )\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_fiscal_year_end","title":"<code>set_fiscal_year_end(value)</code>","text":"<p>Set the fiscal_year_end option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_fiscal_year_end(self, value: str) -&gt; None:\n    \"\"\"Set the fiscal_year_end option.\"\"\"\n    fye = parse_fye_string(value)\n    if fye is None:\n        raise InvalidFiscalYearEndOptionError(value)\n    self.fiscal_year_end = fye\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_import_dirs","title":"<code>set_import_dirs(value)</code>","text":"<p>Add an import directory.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_import_dirs(self, value: str) -&gt; None:\n    \"\"\"Add an import directory.\"\"\"\n    # It's typed as Sequence so that it's not externally mutated\n    self.import_dirs.append(value)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_insert_entry","title":"<code>set_insert_entry(value, date, filename, lineno)</code>","text":"<p>Set the insert_entry option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_insert_entry(\n    self, value: str, date: datetime.date, filename: str, lineno: int\n) -&gt; None:\n    \"\"\"Set the insert_entry option.\"\"\"\n    try:\n        pattern = re.compile(value)\n    except re.error as err:\n        raise NotARegularExpressionError(value) from err\n    opt = InsertEntryOption(date, pattern, filename, lineno)\n    # It's typed as Sequence so that it's not externally mutated\n    self.insert_entry.append(opt)  # type: ignore[attr-defined]\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_language","title":"<code>set_language(value)</code>","text":"<p>Set the locale option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_language(self, value: str) -&gt; None:\n    \"\"\"Set the locale option.\"\"\"\n    try:\n        locale = Locale.parse(value)\n        if (\n            not locale.language == \"en\"\n            and get_translations(locale) is None\n        ):\n            raise UnsupportedLanguageOptionError(value)\n        self.language = value\n    except UnknownLocaleError as err:\n        raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.RustfavaOptions.set_locale","title":"<code>set_locale(value)</code>","text":"<p>Set the locale option.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def set_locale(self, value: str) -&gt; None:\n    \"\"\"Set the locale option.\"\"\"\n    try:\n        Locale.parse(value)\n        self.locale = value\n    except UnknownLocaleError as err:\n        raise UnknownLocaleOptionError(value) from err\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.parse_option_custom_entry","title":"<code>parse_option_custom_entry(entry, options)</code>","text":"<p>Parse a single custom fava-option entry and set option accordingly.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def parse_option_custom_entry(  # noqa: PLR0912\n    entry: Custom,\n    options: RustfavaOptions,\n) -&gt; None:\n    \"\"\"Parse a single custom fava-option entry and set option accordingly.\"\"\"\n    key = str(entry.values[0].value).replace(\"-\", \"_\")\n    if key not in All_OPTS:\n        raise UnknownOptionError(key)\n\n    value = entry.values[1].value if len(entry.values) &gt; 1 else \"\"\n    if not isinstance(value, str):\n        raise NotAStringOptionError(key)\n    filename, lineno = get_position(entry)\n\n    if key == \"collapse_pattern\":\n        options.set_collapse_pattern(value)\n    elif key == \"default_file\":\n        options.set_default_file(value, filename)\n    elif key == \"fiscal_year_end\":\n        options.set_fiscal_year_end(value)\n    elif key == \"import_dirs\":\n        options.set_import_dirs(value)\n    elif key == \"insert_entry\":\n        options.set_insert_entry(value, entry.date, filename, lineno)\n    elif key == \"language\":\n        options.set_language(value)\n    elif key == \"locale\":\n        options.set_locale(value)\n    elif key in STR_OPTS:\n        setattr(options, key, value)\n    elif key in BOOL_OPTS:\n        setattr(options, key, value.lower() == \"true\")\n    elif key in INT_OPTS:\n        setattr(options, key, int(value))\n    else:  # key in TUPLE_OPTS\n        setattr(options, key, tuple(value.strip().split(\" \")))\n</code></pre>"},{"location":"api/#rustfava.core.fava_options.parse_options","title":"<code>parse_options(custom_entries)</code>","text":"<p>Parse custom entries for rustfava options.</p> <p>The format for option entries is the following::</p> <pre><code>2016-04-01 custom \"fava-option\" \"[name]\" \"[value]\"\n</code></pre> <p>Parameters:</p> Name Type Description Default <code>custom_entries</code> <code>Sequence[Custom]</code> <p>A list of Custom entries.</p> required <p>Returns:</p> Type Description <code>RustfavaOptions</code> <p>A tuple (options, errors) where options is a dictionary of all options</p> <code>list[OptionError]</code> <p>to values, and errors contains possible parsing errors.</p> Source code in <code>src/rustfava/core/fava_options.py</code> <pre><code>def parse_options(\n    custom_entries: Sequence[Custom],\n) -&gt; tuple[RustfavaOptions, list[OptionError]]:\n    \"\"\"Parse custom entries for rustfava options.\n\n    The format for option entries is the following::\n\n        2016-04-01 custom \"fava-option\" \"[name]\" \"[value]\"\n\n    Args:\n        custom_entries: A list of Custom entries.\n\n    Returns:\n        A tuple (options, errors) where options is a dictionary of all options\n        to values, and errors contains possible parsing errors.\n    \"\"\"\n    options = RustfavaOptions()\n    errors = []\n\n    for entry in (e for e in custom_entries if e.type == \"fava-option\"):\n        try:\n            if not entry.values:\n                raise MissingOptionError\n            parse_option_custom_entry(entry, options)\n        except (IndexError, TypeError, ValueError) as err:\n            msg = f\"Failed to parse fava-option entry: {err!s}\"\n            errors.append(OptionError(entry.meta, msg, entry))\n\n    return options, errors\n</code></pre>"},{"location":"api/#rustfava.core.file","title":"<code>file</code>","text":"<p>Reading/writing Beancount files.</p>"},{"location":"api/#rustfava.core.file.NonSourceFileError","title":"<code>NonSourceFileError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Trying to read a non-source file.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class NonSourceFileError(RustfavaAPIError):\n    \"\"\"Trying to read a non-source file.\"\"\"\n\n    def __init__(self, path: Path) -&gt; None:\n        super().__init__(f\"Trying to read a non-source file at '{path}'\")\n</code></pre>"},{"location":"api/#rustfava.core.file.ExternallyChangedError","title":"<code>ExternallyChangedError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The file changed externally.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class ExternallyChangedError(RustfavaAPIError):\n    \"\"\"The file changed externally.\"\"\"\n\n    def __init__(self, path: Path) -&gt; None:\n        super().__init__(f\"The file at '{path}' changed externally.\")\n</code></pre>"},{"location":"api/#rustfava.core.file.GeneratedEntryError","title":"<code>GeneratedEntryError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class GeneratedEntryError(RustfavaAPIError):\n    \"\"\"The entry is generated and cannot be edited.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"The entry is generated and cannot be edited.\")\n</code></pre>"},{"location":"api/#rustfava.core.file.InvalidUnicodeError","title":"<code>InvalidUnicodeError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>The source file contains invalid unicode.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class InvalidUnicodeError(RustfavaAPIError):\n    \"\"\"The source file contains invalid unicode.\"\"\"\n\n    def __init__(self, reason: str) -&gt; None:\n        super().__init__(\n            f\"The source file contains invalid unicode: {reason}.\",\n        )\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule","title":"<code>FileModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Functions related to reading/writing to Beancount files.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>class FileModule(FavaModule):\n    \"\"\"Functions related to reading/writing to Beancount files.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._lock = threading.Lock()\n\n    def get_source(self, path: Path) -&gt; tuple[str, str]:\n        \"\"\"Get source files.\n\n        Args:\n            path: The path of the file.\n\n        Returns:\n            A string with the file contents and the `sha256sum` of the file.\n\n        Raises:\n            NonSourceFileError: If the file is not one of the source files.\n            InvalidUnicodeError: If the file contains invalid unicode.\n        \"\"\"\n        if str(path) not in self.ledger.options[\"include\"]:\n            raise NonSourceFileError(path)\n\n        try:\n            source = path.read_text(\"utf-8\")\n        except UnicodeDecodeError as exc:\n            raise InvalidUnicodeError(str(exc)) from exc\n\n        return source, _sha256_str(source)\n\n    def set_source(self, path: Path, source: str, sha256sum: str) -&gt; str:\n        \"\"\"Write to source file.\n\n        Args:\n            path: The path of the file.\n            source: A string with the file contents.\n            sha256sum: Hash of the file.\n\n        Returns:\n            The `sha256sum` of the updated file.\n\n        Raises:\n            NonSourceFileError: If the file is not one of the source files.\n            InvalidUnicodeError: If the file contains invalid unicode.\n            ExternallyChangedError: If the file was changed externally.\n        \"\"\"\n        with self._lock:\n            _, original_sha256sum = self.get_source(path)\n            if original_sha256sum != sha256sum:\n                raise ExternallyChangedError(path)\n\n            newline = _file_newline_character(path)\n            with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n                file.write(source)\n            self.ledger.watcher.notify(path)\n\n            self.ledger.extensions.after_write_source(str(path), source)\n            self.ledger.load_file()\n\n            return _sha256_str(source)\n\n    def insert_metadata(\n        self,\n        entry_hash: str,\n        basekey: str,\n        value: str,\n    ) -&gt; None:\n        \"\"\"Insert metadata into a file at lineno.\n\n        Also, prevent duplicate keys.\n\n        Args:\n            entry_hash: Hash of an entry.\n            basekey: Key to insert metadata for.\n            value: Metadate value to insert.\n        \"\"\"\n        with self._lock:\n            self.ledger.changed()\n            entry = self.ledger.get_entry(entry_hash)\n            key = next_key(basekey, entry.meta)\n            indent = self.ledger.fava_options.indent\n            path, lineno = _get_position(entry)\n            insert_metadata_in_file(path, lineno, indent, key, value)\n            self.ledger.watcher.notify(path)\n            self.ledger.extensions.after_insert_metadata(entry, key, value)\n\n    def save_entry_slice(\n        self,\n        entry_hash: str,\n        source_slice: str,\n        sha256sum: str,\n    ) -&gt; str:\n        \"\"\"Save slice of the source file for an entry.\n\n        Args:\n            entry_hash: Hash of an entry.\n            source_slice: The lines that the entry should be replaced with.\n            sha256sum: The sha256sum of the current lines of the entry.\n\n        Returns:\n            The `sha256sum` of the new lines of the entry.\n\n        Raises:\n            RustfavaAPIError: If the entry is not found or the file changed.\n        \"\"\"\n        with self._lock:\n            entry = self.ledger.get_entry(entry_hash)\n            new_sha256sum = save_entry_slice(entry, source_slice, sha256sum)\n            self.ledger.watcher.notify(Path(get_position(entry)[0]))\n            self.ledger.extensions.after_entry_modified(entry, source_slice)\n            return new_sha256sum\n\n    def delete_entry_slice(self, entry_hash: str, sha256sum: str) -&gt; None:\n        \"\"\"Delete slice of the source file for an entry.\n\n        Args:\n            entry_hash: Hash of an entry.\n            sha256sum: The sha256sum of the current lines of the entry.\n\n        Raises:\n            RustfavaAPIError: If the entry is not found or the file changed.\n        \"\"\"\n        with self._lock:\n            entry = self.ledger.get_entry(entry_hash)\n            delete_entry_slice(entry, sha256sum)\n            self.ledger.watcher.notify(Path(get_position(entry)[0]))\n            self.ledger.extensions.after_delete_entry(entry)\n\n    def insert_entries(self, entries: Sequence[Directive]) -&gt; None:\n        \"\"\"Insert entries.\n\n        Args:\n            entries: A list of entries.\n        \"\"\"\n        with self._lock:\n            self.ledger.changed()\n            fava_options = self.ledger.fava_options\n            for entry in sorted(entries, key=_incomplete_sortkey):\n                path, updated_insert_options = insert_entry(\n                    entry,\n                    (\n                        self.ledger.fava_options.default_file\n                        or self.ledger.beancount_file_path\n                    ),\n                    insert_options=fava_options.insert_entry,\n                    currency_column=fava_options.currency_column,\n                    indent=fava_options.indent,\n                )\n                self.ledger.watcher.notify(path)\n                self.ledger.fava_options.insert_entry = updated_insert_options\n                self.ledger.extensions.after_insert_entry(entry)\n\n    def render_entries(self, entries: Sequence[Directive]) -&gt; Iterable[Markup]:\n        \"\"\"Return entries in Beancount format.\n\n        Only renders :class:`.Balance` and :class:`.Transaction`.\n\n        Args:\n            entries: A list of entries.\n\n        Yields:\n            The entries rendered in Beancount format.\n        \"\"\"\n        indent = self.ledger.fava_options.indent\n        for entry in entries:\n            if isinstance(entry, (Balance, Transaction)):\n                if (\n                    isinstance(entry, Transaction)\n                    and entry.flag in _EXCL_FLAGS\n                ):\n                    continue\n                try:\n                    yield Markup(get_entry_slice(entry)[0] + \"\\n\")  # noqa: S704\n                except (KeyError, FileNotFoundError):\n                    yield Markup(  # noqa: S704\n                        to_string(\n                            entry,\n                            self.ledger.fava_options.currency_column,\n                            indent,\n                        ),\n                    )\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.get_source","title":"<code>get_source(path)</code>","text":"<p>Get source files.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>Path</code> <p>The path of the file.</p> required <p>Returns:</p> Type Description <code>tuple[str, str]</code> <p>A string with the file contents and the <code>sha256sum</code> of the file.</p> <p>Raises:</p> Type Description <code>NonSourceFileError</code> <p>If the file is not one of the source files.</p> <code>InvalidUnicodeError</code> <p>If the file contains invalid unicode.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def get_source(self, path: Path) -&gt; tuple[str, str]:\n    \"\"\"Get source files.\n\n    Args:\n        path: The path of the file.\n\n    Returns:\n        A string with the file contents and the `sha256sum` of the file.\n\n    Raises:\n        NonSourceFileError: If the file is not one of the source files.\n        InvalidUnicodeError: If the file contains invalid unicode.\n    \"\"\"\n    if str(path) not in self.ledger.options[\"include\"]:\n        raise NonSourceFileError(path)\n\n    try:\n        source = path.read_text(\"utf-8\")\n    except UnicodeDecodeError as exc:\n        raise InvalidUnicodeError(str(exc)) from exc\n\n    return source, _sha256_str(source)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.set_source","title":"<code>set_source(path, source, sha256sum)</code>","text":"<p>Write to source file.</p> <p>Parameters:</p> Name Type Description Default <code>path</code> <code>Path</code> <p>The path of the file.</p> required <code>source</code> <code>str</code> <p>A string with the file contents.</p> required <code>sha256sum</code> <code>str</code> <p>Hash of the file.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the updated file.</p> <p>Raises:</p> Type Description <code>NonSourceFileError</code> <p>If the file is not one of the source files.</p> <code>InvalidUnicodeError</code> <p>If the file contains invalid unicode.</p> <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def set_source(self, path: Path, source: str, sha256sum: str) -&gt; str:\n    \"\"\"Write to source file.\n\n    Args:\n        path: The path of the file.\n        source: A string with the file contents.\n        sha256sum: Hash of the file.\n\n    Returns:\n        The `sha256sum` of the updated file.\n\n    Raises:\n        NonSourceFileError: If the file is not one of the source files.\n        InvalidUnicodeError: If the file contains invalid unicode.\n        ExternallyChangedError: If the file was changed externally.\n    \"\"\"\n    with self._lock:\n        _, original_sha256sum = self.get_source(path)\n        if original_sha256sum != sha256sum:\n            raise ExternallyChangedError(path)\n\n        newline = _file_newline_character(path)\n        with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n            file.write(source)\n        self.ledger.watcher.notify(path)\n\n        self.ledger.extensions.after_write_source(str(path), source)\n        self.ledger.load_file()\n\n        return _sha256_str(source)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.insert_metadata","title":"<code>insert_metadata(entry_hash, basekey, value)</code>","text":"<p>Insert metadata into a file at lineno.</p> <p>Also, prevent duplicate keys.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>basekey</code> <code>str</code> <p>Key to insert metadata for.</p> required <code>value</code> <code>str</code> <p>Metadate value to insert.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_metadata(\n    self,\n    entry_hash: str,\n    basekey: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Insert metadata into a file at lineno.\n\n    Also, prevent duplicate keys.\n\n    Args:\n        entry_hash: Hash of an entry.\n        basekey: Key to insert metadata for.\n        value: Metadate value to insert.\n    \"\"\"\n    with self._lock:\n        self.ledger.changed()\n        entry = self.ledger.get_entry(entry_hash)\n        key = next_key(basekey, entry.meta)\n        indent = self.ledger.fava_options.indent\n        path, lineno = _get_position(entry)\n        insert_metadata_in_file(path, lineno, indent, key, value)\n        self.ledger.watcher.notify(path)\n        self.ledger.extensions.after_insert_metadata(entry, key, value)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.save_entry_slice","title":"<code>save_entry_slice(entry_hash, source_slice, sha256sum)</code>","text":"<p>Save slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>source_slice</code> <code>str</code> <p>The lines that the entry should be replaced with.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the new lines of the entry.</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the entry is not found or the file changed.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def save_entry_slice(\n    self,\n    entry_hash: str,\n    source_slice: str,\n    sha256sum: str,\n) -&gt; str:\n    \"\"\"Save slice of the source file for an entry.\n\n    Args:\n        entry_hash: Hash of an entry.\n        source_slice: The lines that the entry should be replaced with.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Returns:\n        The `sha256sum` of the new lines of the entry.\n\n    Raises:\n        RustfavaAPIError: If the entry is not found or the file changed.\n    \"\"\"\n    with self._lock:\n        entry = self.ledger.get_entry(entry_hash)\n        new_sha256sum = save_entry_slice(entry, source_slice, sha256sum)\n        self.ledger.watcher.notify(Path(get_position(entry)[0]))\n        self.ledger.extensions.after_entry_modified(entry, source_slice)\n        return new_sha256sum\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.delete_entry_slice","title":"<code>delete_entry_slice(entry_hash, sha256sum)</code>","text":"<p>Delete slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry_hash</code> <code>str</code> <p>Hash of an entry.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the entry is not found or the file changed.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def delete_entry_slice(self, entry_hash: str, sha256sum: str) -&gt; None:\n    \"\"\"Delete slice of the source file for an entry.\n\n    Args:\n        entry_hash: Hash of an entry.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Raises:\n        RustfavaAPIError: If the entry is not found or the file changed.\n    \"\"\"\n    with self._lock:\n        entry = self.ledger.get_entry(entry_hash)\n        delete_entry_slice(entry, sha256sum)\n        self.ledger.watcher.notify(Path(get_position(entry)[0]))\n        self.ledger.extensions.after_delete_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.insert_entries","title":"<code>insert_entries(entries)</code>","text":"<p>Insert entries.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_entries(self, entries: Sequence[Directive]) -&gt; None:\n    \"\"\"Insert entries.\n\n    Args:\n        entries: A list of entries.\n    \"\"\"\n    with self._lock:\n        self.ledger.changed()\n        fava_options = self.ledger.fava_options\n        for entry in sorted(entries, key=_incomplete_sortkey):\n            path, updated_insert_options = insert_entry(\n                entry,\n                (\n                    self.ledger.fava_options.default_file\n                    or self.ledger.beancount_file_path\n                ),\n                insert_options=fava_options.insert_entry,\n                currency_column=fava_options.currency_column,\n                indent=fava_options.indent,\n            )\n            self.ledger.watcher.notify(path)\n            self.ledger.fava_options.insert_entry = updated_insert_options\n            self.ledger.extensions.after_insert_entry(entry)\n</code></pre>"},{"location":"api/#rustfava.core.file.FileModule.render_entries","title":"<code>render_entries(entries)</code>","text":"<p>Return entries in Beancount format.</p> <p>Only renders :class:<code>.Balance</code> and :class:<code>.Transaction</code>.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required <p>Yields:</p> Type Description <code>Iterable[Markup]</code> <p>The entries rendered in Beancount format.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def render_entries(self, entries: Sequence[Directive]) -&gt; Iterable[Markup]:\n    \"\"\"Return entries in Beancount format.\n\n    Only renders :class:`.Balance` and :class:`.Transaction`.\n\n    Args:\n        entries: A list of entries.\n\n    Yields:\n        The entries rendered in Beancount format.\n    \"\"\"\n    indent = self.ledger.fava_options.indent\n    for entry in entries:\n        if isinstance(entry, (Balance, Transaction)):\n            if (\n                isinstance(entry, Transaction)\n                and entry.flag in _EXCL_FLAGS\n            ):\n                continue\n            try:\n                yield Markup(get_entry_slice(entry)[0] + \"\\n\")  # noqa: S704\n            except (KeyError, FileNotFoundError):\n                yield Markup(  # noqa: S704\n                    to_string(\n                        entry,\n                        self.ledger.fava_options.currency_column,\n                        indent,\n                    ),\n                )\n</code></pre>"},{"location":"api/#rustfava.core.file.insert_metadata_in_file","title":"<code>insert_metadata_in_file(path, lineno, indent, key, value)</code>","text":"<p>Insert the specified metadata in the file below lineno.</p> <p>Takes the whitespace in front of the line that lineno into account.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_metadata_in_file(\n    path: Path,\n    lineno: int,\n    indent: int,\n    key: str,\n    value: str,\n) -&gt; None:\n    \"\"\"Insert the specified metadata in the file below lineno.\n\n    Takes the whitespace in front of the line that lineno into account.\n    \"\"\"\n    with path.open(encoding=\"utf-8\") as file:\n        contents = file.readlines()\n\n    contents.insert(lineno, f'{\" \" * indent}{key}: \"{value}\"\\n')\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.write(\"\".join(contents))\n</code></pre>"},{"location":"api/#rustfava.core.file.find_entry_lines","title":"<code>find_entry_lines(lines, lineno)</code>","text":"<p>Lines of entry starting at lineno.</p> <p>Parameters:</p> Name Type Description Default <code>lines</code> <code>Sequence[str]</code> <p>A list of lines.</p> required <code>lineno</code> <code>int</code> <p>The 0-based line-index to start at.</p> required Source code in <code>src/rustfava/core/file.py</code> <pre><code>def find_entry_lines(lines: Sequence[str], lineno: int) -&gt; Sequence[str]:\n    \"\"\"Lines of entry starting at lineno.\n\n    Args:\n        lines: A list of lines.\n        lineno: The 0-based line-index to start at.\n    \"\"\"\n    entry_lines = [lines[lineno]]\n    while True:\n        lineno += 1\n        try:\n            line = lines[lineno]\n        except IndexError:\n            return entry_lines\n        if not line.strip() or re.match(r\"\\S\", line[0]):\n            return entry_lines\n        entry_lines.append(line)\n</code></pre>"},{"location":"api/#rustfava.core.file.get_entry_slice","title":"<code>get_entry_slice(entry)</code>","text":"<p>Get slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>A string containing the lines of the entry and the <code>sha256sum</code> of</p> <code>str</code> <p>these lines.</p> <p>Raises:</p> Type Description <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def get_entry_slice(entry: Directive) -&gt; tuple[str, str]:\n    \"\"\"Get slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n\n    Returns:\n        A string containing the lines of the entry and the `sha256sum` of\n        these lines.\n\n    Raises:\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    entry_lines = find_entry_lines(lines, lineno - 1)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n\n    return entry_source, _sha256_str(entry_source)\n</code></pre>"},{"location":"api/#rustfava.core.file.save_entry_slice","title":"<code>save_entry_slice(entry, source_slice, sha256sum)</code>","text":"<p>Save slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>source_slice</code> <code>str</code> <p>The lines that the entry should be replaced with.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Returns:</p> Type Description <code>str</code> <p>The <code>sha256sum</code> of the new lines of the entry.</p> <p>Raises:</p> Type Description <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def save_entry_slice(\n    entry: Directive,\n    source_slice: str,\n    sha256sum: str,\n) -&gt; str:\n    \"\"\"Save slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n        source_slice: The lines that the entry should be replaced with.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Returns:\n        The `sha256sum` of the new lines of the entry.\n\n    Raises:\n        ExternallyChangedError: If the file was changed externally.\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    first_entry_line = lineno - 1\n    entry_lines = find_entry_lines(lines, first_entry_line)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n    if _sha256_str(entry_source) != sha256sum:\n        raise ExternallyChangedError(path)\n\n    lines = [\n        *lines[:first_entry_line],\n        source_slice + \"\\n\",\n        *lines[first_entry_line + len(entry_lines) :],\n    ]\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(lines)\n\n    return _sha256_str(source_slice)\n</code></pre>"},{"location":"api/#rustfava.core.file.delete_entry_slice","title":"<code>delete_entry_slice(entry, sha256sum)</code>","text":"<p>Delete slice of the source file for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>sha256sum</code> <code>str</code> <p>The sha256sum of the current lines of the entry.</p> required <p>Raises:</p> Type Description <code>ExternallyChangedError</code> <p>If the file was changed externally.</p> <code>GeneratedEntryError</code> <p>If the entry is generated and cannot be edited.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def delete_entry_slice(\n    entry: Directive,\n    sha256sum: str,\n) -&gt; None:\n    \"\"\"Delete slice of the source file for an entry.\n\n    Args:\n        entry: An entry.\n        sha256sum: The sha256sum of the current lines of the entry.\n\n    Raises:\n        ExternallyChangedError: If the file was changed externally.\n        GeneratedEntryError: If the entry is generated and cannot be edited.\n    \"\"\"\n    path, lineno = _get_position(entry)\n    with path.open(encoding=\"utf-8\") as file:\n        lines = file.readlines()\n\n    first_entry_line = lineno - 1\n    entry_lines = find_entry_lines(lines, first_entry_line)\n    entry_source = \"\".join(entry_lines).rstrip(\"\\n\")\n    if _sha256_str(entry_source) != sha256sum:\n        raise ExternallyChangedError(path)\n\n    # Also delete the whitespace following this entry\n    last_entry_line = first_entry_line + len(entry_lines)\n    while True:\n        try:\n            line = lines[last_entry_line]\n        except IndexError:\n            break\n        if line.strip():  # pragma: no cover\n            break\n        last_entry_line += 1  # pragma: no cover\n    lines = lines[:first_entry_line] + lines[last_entry_line:]\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(lines)\n</code></pre>"},{"location":"api/#rustfava.core.file.insert_entry","title":"<code>insert_entry(entry, default_filename, insert_options, currency_column, indent)</code>","text":"<p>Insert an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>default_filename</code> <code>str</code> <p>The default file to insert into if no option matches.</p> required <code>insert_options</code> <code>Sequence[InsertEntryOption]</code> <p>Insert options.</p> required <code>currency_column</code> <code>int</code> <p>The column to align currencies at.</p> required <code>indent</code> <code>int</code> <p>Number of indent spaces.</p> required <p>Returns:</p> Type Description <code>tuple[Path, Sequence[InsertEntryOption]]</code> <p>A changed path and list of updated insert options.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def insert_entry(\n    entry: Directive,\n    default_filename: str,\n    insert_options: Sequence[InsertEntryOption],\n    currency_column: int,\n    indent: int,\n) -&gt; tuple[Path, Sequence[InsertEntryOption]]:\n    \"\"\"Insert an entry.\n\n    Args:\n        entry: An entry.\n        default_filename: The default file to insert into if no option matches.\n        insert_options: Insert options.\n        currency_column: The column to align currencies at.\n        indent: Number of indent spaces.\n\n    Returns:\n        A changed path and list of updated insert options.\n    \"\"\"\n    filename, lineno = find_insert_position(\n        entry,\n        insert_options,\n        default_filename,\n    )\n    content = to_string(entry, currency_column, indent)\n\n    path = Path(filename)\n    with path.open(encoding=\"utf-8\") as file:\n        contents = file.readlines()\n\n    if lineno is None:\n        # Appending\n        contents += \"\\n\" + content\n    else:\n        contents.insert(lineno, content + \"\\n\")\n\n    newline = _file_newline_character(path)\n    with path.open(\"w\", encoding=\"utf-8\", newline=newline) as file:\n        file.writelines(contents)\n\n    if lineno is None:\n        return (path, insert_options)\n\n    added_lines = content.count(\"\\n\") + 1\n    return (\n        path,\n        [\n            (\n                replace(option, lineno=option.lineno + added_lines)\n                if option.filename == filename and option.lineno &gt; lineno\n                else option\n            )\n            for option in insert_options\n        ],\n    )\n</code></pre>"},{"location":"api/#rustfava.core.file.find_insert_position","title":"<code>find_insert_position(entry, insert_options, default_filename)</code>","text":"<p>Find insert position for an entry.</p> <p>Parameters:</p> Name Type Description Default <code>entry</code> <code>Directive</code> <p>An entry.</p> required <code>insert_options</code> <code>Sequence[InsertEntryOption]</code> <p>A list of InsertOption.</p> required <code>default_filename</code> <code>str</code> <p>The default file to insert into if no option matches.</p> required <p>Returns:</p> Type Description <code>tuple[str, int | None]</code> <p>A tuple of the filename and the line number.</p> Source code in <code>src/rustfava/core/file.py</code> <pre><code>def find_insert_position(\n    entry: Directive,\n    insert_options: Sequence[InsertEntryOption],\n    default_filename: str,\n) -&gt; tuple[str, int | None]:\n    \"\"\"Find insert position for an entry.\n\n    Args:\n        entry: An entry.\n        insert_options: A list of InsertOption.\n        default_filename: The default file to insert into if no option matches.\n\n    Returns:\n        A tuple of the filename and the line number.\n    \"\"\"\n    # Get the list of accounts that should be considered for the entry.\n    # For transactions, we want the reversed list of posting accounts.\n    accounts = get_entry_accounts(entry)\n\n    # Make no assumptions about the order of insert_options entries and instead\n    # sort them ourselves (by descending dates)\n    insert_options = sorted(\n        insert_options,\n        key=attrgetter(\"date\"),\n        reverse=True,\n    )\n\n    for account in accounts:\n        for insert_option in insert_options:\n            # Only consider InsertOptions before the entry date.\n            if insert_option.date &gt;= entry.date:\n                continue\n            if insert_option.re.match(account):\n                return (insert_option.filename, insert_option.lineno - 1)\n\n    return (default_filename, None)\n</code></pre>"},{"location":"api/#rustfava.core.filters","title":"<code>filters</code>","text":"<p>Entry filters.</p>"},{"location":"api/#rustfava.core.filters.FilterError","title":"<code>FilterError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Filter exception.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterError(RustfavaAPIError):\n    \"\"\"Filter exception.\"\"\"\n\n    def __init__(self, filter_type: str, message: str) -&gt; None:\n        super().__init__(message)\n        self.filter_type = filter_type\n\n    def __str__(self) -&gt; str:\n        return self.message\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterParseError","title":"<code>FilterParseError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Filter parse error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterParseError(FilterError):\n    \"\"\"Filter parse error.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"filter\", \"Failed to parse filter: \")\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterIllegalCharError","title":"<code>FilterIllegalCharError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Filter illegal char error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterIllegalCharError(FilterError):\n    \"\"\"Filter illegal char error.\"\"\"\n\n    def __init__(self, char: str) -&gt; None:\n        super().__init__(\n            \"filter\",\n            f'Illegal character \"{char}\" in filter.',\n        )\n</code></pre>"},{"location":"api/#rustfava.core.filters.TimeFilterParseError","title":"<code>TimeFilterParseError</code>","text":"<p>               Bases: <code>FilterError</code></p> <p>Time filter parse error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class TimeFilterParseError(FilterError):\n    \"\"\"Time filter parse error.\"\"\"\n\n    def __init__(self, value: str) -&gt; None:\n        super().__init__(\"time\", f\"Failed to parse date: {value}\")\n</code></pre>"},{"location":"api/#rustfava.core.filters.Token","title":"<code>Token</code>","text":"<p>A token having a certain type and value.</p> <p>The lexer attribute only exists since PLY writes to it in case of a parser error.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class Token:\n    \"\"\"A token having a certain type and value.\n\n    The lexer attribute only exists since PLY writes to it in case of a parser\n    error.\n    \"\"\"\n\n    __slots__ = (\"lexer\", \"type\", \"value\")\n\n    def __init__(self, type_: str, value: str) -&gt; None:\n        self.type = type_\n        self.value = value\n\n    def __repr__(self) -&gt; str:  # pragma: no cover\n        return f\"Token({self.type}, {self.value})\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxLexer","title":"<code>FilterSyntaxLexer</code>","text":"<p>Lexer for Fava's filter syntax.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterSyntaxLexer:\n    \"\"\"Lexer for Fava's filter syntax.\"\"\"\n\n    tokens = (\n        \"ANY\",\n        \"ALL\",\n        \"CMP_OP\",\n        \"EQ_OP\",\n        \"KEY\",\n        \"LINK\",\n        \"NUMBER\",\n        \"STRING\",\n        \"TAG\",\n    )\n\n    RULES = (\n        (\"LINK\", r\"\\^[A-Za-z0-9\\-_/.]+\"),\n        (\"TAG\", r\"\\#[A-Za-z0-9\\-_/.]+\"),\n        (\"ALL\", r\"all\\(\"),\n        (\"ANY\", r\"any\\(\"),\n        (\"KEY\", r\"[a-z][a-zA-Z0-9\\-_]+(?=\\s*(:|=|&gt;=|&lt;=|&lt;|&gt;))\"),\n        (\"EQ_OP\", r\":\"),\n        (\"CMP_OP\", r\"(=|&gt;=|&lt;=|&lt;|&gt;)\"),\n        (\"NUMBER\", r\"\\d*\\.?\\d+\"),\n        (\"STRING\", r\"\"\"\\w[-\\w]*|\"[^\"]*\"|'[^']*'\"\"\"),\n    )\n\n    regex = re.compile(\n        \"|\".join((f\"(?P&lt;{name}&gt;{rule})\" for name, rule in RULES)),\n    )\n\n    def LINK(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value[1:]\n\n    def TAG(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value[1:]\n\n    def KEY(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def ALL(self, token: str, _: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, token\n\n    def ANY(self, token: str, _: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, token\n\n    def EQ_OP(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def CMP_OP(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        return token, value\n\n    def NUMBER(self, token: str, value: str) -&gt; tuple[str, Decimal]:  # noqa: N802\n        return token, Decimal(value)\n\n    def STRING(self, token: str, value: str) -&gt; tuple[str, str]:  # noqa: N802\n        if value[0] in {'\"', \"'\"}:\n            return token, value[1:-1]\n        return token, value\n\n    def lex(self, data: str) -&gt; Iterable[Token]:\n        \"\"\"A generator yielding all tokens in a given line.\n\n        Arguments:\n            data: A string, the line to lex.\n\n        Yields:\n            All Tokens in the line.\n        \"\"\"\n        ignore = \" \\t\"\n        literals = \"-,()\"\n        regex = self.regex.match\n\n        pos = 0\n        length = len(data)\n        while pos &lt; length:\n            char = data[pos]\n            if char in ignore:\n                pos += 1\n                continue\n            match = regex(data, pos)\n            if match:\n                value = match.group()\n                pos += len(value)\n                token = match.lastgroup\n                if token is None:  # pragma: no cover\n                    msg = \"Internal Error\"\n                    raise ValueError(msg)\n                func: Callable[[str, str], tuple[str, str]] = getattr(\n                    self,\n                    token,\n                )\n                ret = func(token, value)\n                yield Token(*ret)\n            elif char in literals:\n                yield Token(char, char)\n                pos += 1\n            else:\n                raise FilterIllegalCharError(char)\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxLexer.lex","title":"<code>lex(data)</code>","text":"<p>A generator yielding all tokens in a given line.</p> <p>Parameters:</p> Name Type Description Default <code>data</code> <code>str</code> <p>A string, the line to lex.</p> required <p>Yields:</p> Type Description <code>Iterable[Token]</code> <p>All Tokens in the line.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def lex(self, data: str) -&gt; Iterable[Token]:\n    \"\"\"A generator yielding all tokens in a given line.\n\n    Arguments:\n        data: A string, the line to lex.\n\n    Yields:\n        All Tokens in the line.\n    \"\"\"\n    ignore = \" \\t\"\n    literals = \"-,()\"\n    regex = self.regex.match\n\n    pos = 0\n    length = len(data)\n    while pos &lt; length:\n        char = data[pos]\n        if char in ignore:\n            pos += 1\n            continue\n        match = regex(data, pos)\n        if match:\n            value = match.group()\n            pos += len(value)\n            token = match.lastgroup\n            if token is None:  # pragma: no cover\n                msg = \"Internal Error\"\n                raise ValueError(msg)\n            func: Callable[[str, str], tuple[str, str]] = getattr(\n                self,\n                token,\n            )\n            ret = func(token, value)\n            yield Token(*ret)\n        elif char in literals:\n            yield Token(char, char)\n            pos += 1\n        else:\n            raise FilterIllegalCharError(char)\n</code></pre>"},{"location":"api/#rustfava.core.filters.Match","title":"<code>Match</code>","text":"<p>Match a string.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class Match:\n    \"\"\"Match a string.\"\"\"\n\n    __slots__ = (\"match\",)\n\n    match: Callable[[str], bool]\n\n    def __init__(self, search: str) -&gt; None:\n        try:\n            match = re.compile(search, re.IGNORECASE).search\n            self.match = lambda s: bool(match(s))\n        except re.error:\n            self.match = lambda s: s == search\n\n    def __call__(self, obj: Any) -&gt; bool:\n        return self.match(str(obj))\n</code></pre>"},{"location":"api/#rustfava.core.filters.MatchAmount","title":"<code>MatchAmount</code>","text":"<p>Matches an amount.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class MatchAmount:\n    \"\"\"Matches an amount.\"\"\"\n\n    __slots__ = (\"match\",)\n\n    match: Callable[[Decimal], bool]\n\n    def __init__(self, op: str, value: Decimal) -&gt; None:\n        if op == \"=\":\n            self.match = lambda x: x == value\n        elif op == \"&gt;=\":\n            self.match = lambda x: x &gt;= value\n        elif op == \"&lt;=\":\n            self.match = lambda x: x &lt;= value\n        elif op == \"&gt;\":\n            self.match = lambda x: x &gt; value\n        else:  # op == \"&lt;\":\n            self.match = lambda x: x &lt; value\n\n    def __call__(self, obj: Any) -&gt; bool:\n        # Compare to the absolute value to simplify this filter.\n        number = getattr(obj, \"number\", None)\n        return self.match(abs(number)) if number is not None else False\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser","title":"<code>FilterSyntaxParser</code>","text":"Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class FilterSyntaxParser:\n    precedence = ((\"left\", \"AND\"), (\"right\", \"UMINUS\"))\n    tokens = FilterSyntaxLexer.tokens\n\n    def p_error(self, _: Any) -&gt; None:\n        raise FilterParseError\n\n    def p_filter(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        filter : expr\n        \"\"\"\n        p[0] = p[1]\n\n    def p_expr(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : simple_expr\n        \"\"\"\n        p[0] = p[1]\n\n    def p_expr_all(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : ALL expr ')'\n        \"\"\"\n        expr = p[2]\n\n        def _match_postings(entry: Directive) -&gt; bool:\n            return all(\n                expr(posting) for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _match_postings\n\n    def p_expr_any(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : ANY expr ')'\n        \"\"\"\n        expr = p[2]\n\n        def _match_postings(entry: Directive) -&gt; bool:\n            return any(\n                expr(posting) for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _match_postings\n\n    def p_expr_parentheses(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : '(' expr ')'\n        \"\"\"\n        p[0] = p[2]\n\n    def p_expr_and(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : expr expr %prec AND\n        \"\"\"\n        left, right = p[1], p[2]\n\n        def _and(entry: Directive) -&gt; bool:\n            return left(entry) and right(entry)  # type: ignore[no-any-return]\n\n        p[0] = _and\n\n    def p_expr_or(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : expr ',' expr\n        \"\"\"\n        left, right = p[1], p[3]\n\n        def _or(entry: Directive) -&gt; bool:\n            return left(entry) or right(entry)  # type: ignore[no-any-return]\n\n        p[0] = _or\n\n    def p_expr_negated(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        expr : '-' expr %prec UMINUS\n        \"\"\"\n        func = p[2]\n\n        def _neg(entry: Directive) -&gt; bool:\n            return not func(entry)\n\n        p[0] = _neg\n\n    def p_simple_expr_TAG(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : TAG\n        \"\"\"\n        tag = p[1]\n\n        def _tag(entry: Directive) -&gt; bool:\n            tags = getattr(entry, \"tags\", None)\n            return (tag in tags) if tags is not None else False\n\n        p[0] = _tag\n\n    def p_simple_expr_LINK(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : LINK\n        \"\"\"\n        link = p[1]\n\n        def _link(entry: Directive) -&gt; bool:\n            links = getattr(entry, \"links\", None)\n            return (link in links) if links is not None else False\n\n        p[0] = _link\n\n    def p_simple_expr_STRING(self, p: list[Any]) -&gt; None:  # noqa: N802\n        \"\"\"\n        simple_expr : STRING\n        \"\"\"\n        string = p[1]\n        match = Match(string)\n\n        def _string(entry: Directive) -&gt; bool:\n            for name in (\"narration\", \"payee\", \"comment\"):\n                value = getattr(entry, name, \"\")\n                if value and match(value):\n                    return True\n            return False\n\n        p[0] = _string\n\n    def p_simple_expr_key(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        simple_expr : KEY EQ_OP STRING\n                    | KEY CMP_OP NUMBER\n        \"\"\"\n        key, op, value = p[1], p[2], p[3]\n        match: Match | MatchAmount = (\n            Match(value) if op == \":\" else MatchAmount(op, value)\n        )\n\n        def _key(entry: Directive) -&gt; bool:\n            if hasattr(entry, key):\n                return match(getattr(entry, key) or \"\")\n            if entry.meta is not None and key in entry.meta:\n                return match(entry.meta.get(key))\n            return False\n\n        p[0] = _key\n\n    def p_simple_expr_units(self, p: list[Any]) -&gt; None:\n        \"\"\"\n        simple_expr : CMP_OP NUMBER\n        \"\"\"\n        op, value = p[1], p[2]\n        match = MatchAmount(op, value)\n\n        def _range(entry: Directive) -&gt; bool:\n            return any(\n                match(posting.units)\n                for posting in getattr(entry, \"postings\", [])\n            )\n\n        p[0] = _range\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_filter","title":"<code>p_filter(p)</code>","text":"<p>filter : expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_filter(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    filter : expr\n    \"\"\"\n    p[0] = p[1]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr","title":"<code>p_expr(p)</code>","text":"<p>expr : simple_expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : simple_expr\n    \"\"\"\n    p[0] = p[1]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_all","title":"<code>p_expr_all(p)</code>","text":"<p>expr : ALL expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_all(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : ALL expr ')'\n    \"\"\"\n    expr = p[2]\n\n    def _match_postings(entry: Directive) -&gt; bool:\n        return all(\n            expr(posting) for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _match_postings\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_any","title":"<code>p_expr_any(p)</code>","text":"<p>expr : ANY expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_any(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : ANY expr ')'\n    \"\"\"\n    expr = p[2]\n\n    def _match_postings(entry: Directive) -&gt; bool:\n        return any(\n            expr(posting) for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _match_postings\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_parentheses","title":"<code>p_expr_parentheses(p)</code>","text":"<p>expr : '(' expr ')'</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_parentheses(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : '(' expr ')'\n    \"\"\"\n    p[0] = p[2]\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_and","title":"<code>p_expr_and(p)</code>","text":"<p>expr : expr expr %prec AND</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_and(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : expr expr %prec AND\n    \"\"\"\n    left, right = p[1], p[2]\n\n    def _and(entry: Directive) -&gt; bool:\n        return left(entry) and right(entry)  # type: ignore[no-any-return]\n\n    p[0] = _and\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_or","title":"<code>p_expr_or(p)</code>","text":"<p>expr : expr ',' expr</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_or(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : expr ',' expr\n    \"\"\"\n    left, right = p[1], p[3]\n\n    def _or(entry: Directive) -&gt; bool:\n        return left(entry) or right(entry)  # type: ignore[no-any-return]\n\n    p[0] = _or\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_expr_negated","title":"<code>p_expr_negated(p)</code>","text":"<p>expr : '-' expr %prec UMINUS</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_expr_negated(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    expr : '-' expr %prec UMINUS\n    \"\"\"\n    func = p[2]\n\n    def _neg(entry: Directive) -&gt; bool:\n        return not func(entry)\n\n    p[0] = _neg\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_TAG","title":"<code>p_simple_expr_TAG(p)</code>","text":"<p>simple_expr : TAG</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_TAG(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : TAG\n    \"\"\"\n    tag = p[1]\n\n    def _tag(entry: Directive) -&gt; bool:\n        tags = getattr(entry, \"tags\", None)\n        return (tag in tags) if tags is not None else False\n\n    p[0] = _tag\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_LINK","title":"<code>p_simple_expr_LINK(p)</code>","text":"<p>simple_expr : LINK</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_LINK(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : LINK\n    \"\"\"\n    link = p[1]\n\n    def _link(entry: Directive) -&gt; bool:\n        links = getattr(entry, \"links\", None)\n        return (link in links) if links is not None else False\n\n    p[0] = _link\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_STRING","title":"<code>p_simple_expr_STRING(p)</code>","text":"<p>simple_expr : STRING</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_STRING(self, p: list[Any]) -&gt; None:  # noqa: N802\n    \"\"\"\n    simple_expr : STRING\n    \"\"\"\n    string = p[1]\n    match = Match(string)\n\n    def _string(entry: Directive) -&gt; bool:\n        for name in (\"narration\", \"payee\", \"comment\"):\n            value = getattr(entry, name, \"\")\n            if value and match(value):\n                return True\n        return False\n\n    p[0] = _string\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_key","title":"<code>p_simple_expr_key(p)</code>","text":"KEY EQ_OP STRING <p>| KEY CMP_OP NUMBER</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_key(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    simple_expr : KEY EQ_OP STRING\n                | KEY CMP_OP NUMBER\n    \"\"\"\n    key, op, value = p[1], p[2], p[3]\n    match: Match | MatchAmount = (\n        Match(value) if op == \":\" else MatchAmount(op, value)\n    )\n\n    def _key(entry: Directive) -&gt; bool:\n        if hasattr(entry, key):\n            return match(getattr(entry, key) or \"\")\n        if entry.meta is not None and key in entry.meta:\n            return match(entry.meta.get(key))\n        return False\n\n    p[0] = _key\n</code></pre>"},{"location":"api/#rustfava.core.filters.FilterSyntaxParser.p_simple_expr_units","title":"<code>p_simple_expr_units(p)</code>","text":"<p>simple_expr : CMP_OP NUMBER</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>def p_simple_expr_units(self, p: list[Any]) -&gt; None:\n    \"\"\"\n    simple_expr : CMP_OP NUMBER\n    \"\"\"\n    op, value = p[1], p[2]\n    match = MatchAmount(op, value)\n\n    def _range(entry: Directive) -&gt; bool:\n        return any(\n            match(posting.units)\n            for posting in getattr(entry, \"postings\", [])\n        )\n\n    p[0] = _range\n</code></pre>"},{"location":"api/#rustfava.core.filters.EntryFilter","title":"<code>EntryFilter</code>","text":"<p>               Bases: <code>ABC</code></p> <p>Filters a list of entries.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class EntryFilter(ABC):\n    \"\"\"Filters a list of entries.\"\"\"\n\n    @abstractmethod\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        \"\"\"Filter a list of directives.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.EntryFilter.apply","title":"<code>apply(entries)</code>  <code>abstractmethod</code>","text":"<p>Filter a list of directives.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>@abstractmethod\ndef apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n    \"\"\"Filter a list of directives.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.filters.TimeFilter","title":"<code>TimeFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by dates.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class TimeFilter(EntryFilter):\n    \"\"\"Filter by dates.\"\"\"\n\n    __slots__ = (\"date_range\",)\n\n    def __init__(\n        self,\n        options: BeancountOptions,\n        fava_options: RustfavaOptions,\n        value: str,\n    ) -&gt; None:\n        del options  # unused\n        begin, end = parse_date(value, fava_options.fiscal_year_end)\n        if not begin or not end:\n            raise TimeFilterParseError(value)\n        self.date_range = DateRange(begin, end)\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        from rustfava.rustledger.engine import RustledgerEngine\n        from rustfava.rustledger.types import directives_from_json\n        from rustfava.rustledger.types import directives_to_json\n\n        # Use native rustledger clamp_entries\n        engine = RustledgerEngine.get_instance()\n        entries_json = directives_to_json(list(entries))\n        result = engine.clamp_entries(\n            entries_json,\n            str(self.date_range.begin),\n            str(self.date_range.end),\n        )\n        return directives_from_json(result.get(\"entries\", []))\n</code></pre>"},{"location":"api/#rustfava.core.filters.AdvancedFilter","title":"<code>AdvancedFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by tags and links and keys.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class AdvancedFilter(EntryFilter):\n    \"\"\"Filter by tags and links and keys.\"\"\"\n\n    __slots__ = (\"_include\",)\n\n    def __init__(self, value: str) -&gt; None:\n        try:\n            tokens = LEXER.lex(value)\n            self._include = PARSE(\n                lexer=\"NONE\",\n                tokenfunc=lambda toks=tokens: next(toks, None),  # ty:ignore[invalid-argument-type]\n            )\n        except FilterError as exception:\n            exception.message += value\n            raise\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        include = self._include\n        return [entry for entry in entries if include(entry)]\n</code></pre>"},{"location":"api/#rustfava.core.filters.AccountFilter","title":"<code>AccountFilter</code>","text":"<p>               Bases: <code>EntryFilter</code></p> <p>Filter by account.</p> <p>The filter string can either be a regular expression or a parent account.</p> Source code in <code>src/rustfava/core/filters.py</code> <pre><code>class AccountFilter(EntryFilter):\n    \"\"\"Filter by account.\n\n    The filter string can either be a regular expression or a parent account.\n    \"\"\"\n\n    __slots__ = (\"_match\", \"_value\")\n\n    def __init__(self, value: str) -&gt; None:\n        self._value = value\n        self._match = Match(value)\n\n    def apply(self, entries: Sequence[Directive]) -&gt; Sequence[Directive]:\n        value = self._value\n        if not value:\n            return entries\n        match = self._match\n        return [\n            entry\n            for entry in entries\n            if any(\n                _has_component(name, value) or match(name)\n                for name in get_entry_accounts(entry)\n            )\n        ]\n</code></pre>"},{"location":"api/#rustfava.core.group_entries","title":"<code>group_entries</code>","text":"<p>Entries grouped by type.</p>"},{"location":"api/#rustfava.core.group_entries.EntriesByType","title":"<code>EntriesByType</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>Entries grouped by type.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>class EntriesByType(NamedTuple):\n    \"\"\"Entries grouped by type.\"\"\"\n\n    Balance: Sequence[abc.Balance]\n    Close: Sequence[abc.Close]\n    Commodity: Sequence[abc.Commodity]\n    Custom: Sequence[abc.Custom]\n    Document: Sequence[abc.Document]\n    Event: Sequence[abc.Event]\n    Note: Sequence[abc.Note]\n    Open: Sequence[abc.Open]\n    Pad: Sequence[abc.Pad]\n    Price: Sequence[abc.Price]\n    Query: Sequence[abc.Query]\n    Transaction: Sequence[abc.Transaction]\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.TransactionPosting","title":"<code>TransactionPosting</code>","text":"<p>               Bases: <code>NamedTuple</code></p> <p>Pair of a transaction and a posting.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>class TransactionPosting(NamedTuple):\n    \"\"\"Pair of a transaction and a posting.\"\"\"\n\n    transaction: abc.Transaction\n    posting: abc.Posting\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.group_entries_by_type","title":"<code>group_entries_by_type(entries)</code>","text":"<p>Group entries by type.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries to group.</p> required <p>Returns:</p> Type Description <code>EntriesByType</code> <p>A namedtuple containing the grouped lists of entries.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>def group_entries_by_type(entries: Sequence[abc.Directive]) -&gt; EntriesByType:\n    \"\"\"Group entries by type.\n\n    Arguments:\n        entries: A list of entries to group.\n\n    Returns:\n        A namedtuple containing the grouped lists of entries.\n    \"\"\"\n    entries_by_type = EntriesByType(\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n        [],\n    )\n    for entry in entries:\n        # Handle both beancount types (e.g., \"Transaction\") and\n        # rustledger types (e.g., \"RLTransaction\")\n        type_name = entry.__class__.__name__\n        if type_name.startswith(\"RL\"):\n            type_name = type_name[2:]  # Strip \"RL\" prefix\n        getattr(entries_by_type, type_name).append(entry)\n    return entries_by_type\n</code></pre>"},{"location":"api/#rustfava.core.group_entries.group_entries_by_account","title":"<code>group_entries_by_account(entries)</code>","text":"<p>Group entries by account.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>A list of entries.</p> required <p>Returns:</p> Type Description <code>Mapping[str, Sequence[Directive | TransactionPosting]]</code> <p>A dict mapping account names to their entries.</p> Source code in <code>src/rustfava/core/group_entries.py</code> <pre><code>def group_entries_by_account(\n    entries: Sequence[abc.Directive],\n) -&gt; Mapping[str, Sequence[abc.Directive | TransactionPosting]]:\n    \"\"\"Group entries by account.\n\n    Arguments:\n        entries: A list of entries.\n\n    Returns:\n        A dict mapping account names to their entries.\n    \"\"\"\n    res: dict[str, list[abc.Directive | TransactionPosting]] = defaultdict(\n        list,\n    )\n\n    for entry in entries:\n        if isinstance(entry, abc.Transaction):\n            for posting in entry.postings:\n                res[posting.account].append(TransactionPosting(entry, posting))\n        else:\n            for account in get_entry_accounts(entry):\n                res[account].append(entry)\n\n    return dict(sorted(res.items()))\n</code></pre>"},{"location":"api/#rustfava.core.ingest","title":"<code>ingest</code>","text":"<p>Ingest helper functions.</p>"},{"location":"api/#rustfava.core.ingest.IngestError","title":"<code>IngestError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>An error with one of the importers.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class IngestError(BeancountError):\n    \"\"\"An error with one of the importers.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterMethodCallError","title":"<code>ImporterMethodCallError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Error calling one of the importer methods.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterMethodCallError(RustfavaAPIError):\n    \"\"\"Error calling one of the importer methods.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\n            f\"Error calling method on importer:\\n\\n{traceback.format_exc()}\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterInvalidTypeError","title":"<code>ImporterInvalidTypeError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>One of the importer methods returned an unexpected type.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterInvalidTypeError(RustfavaAPIError):\n    \"\"\"One of the importer methods returned an unexpected type.\"\"\"\n\n    def __init__(self, attr: str, expected: type[Any], actual: Any) -&gt; None:\n        super().__init__(\n            f\"Got unexpected type from importer as {attr}:\"\n            f\" expected {expected!s}, got {type(actual)!s}:\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImporterExtractError","title":"<code>ImporterExtractError</code>","text":"<p>               Bases: <code>ImporterMethodCallError</code></p> <p>Error calling extract for importer.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImporterExtractError(ImporterMethodCallError):\n    \"\"\"Error calling extract for importer.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.MissingImporterConfigError","title":"<code>MissingImporterConfigError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Missing import-config option.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class MissingImporterConfigError(RustfavaAPIError):\n    \"\"\"Missing import-config option.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"Missing import-config option\")\n</code></pre>"},{"location":"api/#rustfava.core.ingest.MissingImporterDirsError","title":"<code>MissingImporterDirsError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>You need to set at least one imports-dir.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class MissingImporterDirsError(RustfavaAPIError):\n    \"\"\"You need to set at least one imports-dir.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\"You need to set at least one imports-dir.\")\n</code></pre>"},{"location":"api/#rustfava.core.ingest.ImportConfigLoadError","title":"<code>ImportConfigLoadError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>Error on loading the import config.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class ImportConfigLoadError(RustfavaAPIError):\n    \"\"\"Error on loading the import config.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.ingest.FileImportInfo","title":"<code>FileImportInfo</code>  <code>dataclass</code>","text":"<p>Info about one file/importer combination.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@dataclass(frozen=True)\nclass FileImportInfo:\n    \"\"\"Info about one file/importer combination.\"\"\"\n\n    importer_name: str\n    account: str\n    date: datetime.date\n    name: str\n</code></pre>"},{"location":"api/#rustfava.core.ingest.FileImporters","title":"<code>FileImporters</code>  <code>dataclass</code>","text":"<p>Importers for a file.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@dataclass(frozen=True)\nclass FileImporters:\n    \"\"\"Importers for a file.\"\"\"\n\n    name: str\n    basename: str\n    importers: list[FileImportInfo]\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter","title":"<code>WrappedImporter</code>","text":"<p>A wrapper to safely call importer methods.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class WrappedImporter:\n    \"\"\"A wrapper to safely call importer methods.\"\"\"\n\n    importer: BeanImporterProtocol | Importer\n\n    def __init__(self, importer: BeanImporterProtocol | Importer) -&gt; None:\n        self.importer = importer\n\n    @property\n    @_catch_any\n    def name(self) -&gt; str:\n        \"\"\"Get the name of the importer.\"\"\"\n        importer = self.importer\n        name = (\n            importer.name\n            if isinstance(importer, Importer)\n            else importer.name()\n        )\n        return _assert_type(\"name\", name, str)\n\n    @_catch_any\n    def identify(self: WrappedImporter, path: Path) -&gt; bool:\n        \"\"\"Whether the importer is matching the file.\"\"\"\n        importer = self.importer\n        matches = (\n            importer.identify(str(path))\n            if isinstance(importer, Importer)\n            else importer.identify(get_cached_file(path))\n        )\n        return _assert_type(\"identify\", matches, bool)\n\n    @_catch_any\n    def file_import_info(self, path: Path) -&gt; FileImportInfo:\n        \"\"\"Generate info about a file with an importer.\"\"\"\n        importer = self.importer\n        if isinstance(importer, Importer):\n            str_path = str(path)\n            account = importer.account(str_path)\n            date = importer.date(str_path)\n            filename = importer.filename(str_path)\n        else:\n            file = get_cached_file(path)\n            account = importer.file_account(file)\n            date = importer.file_date(file)\n            filename = importer.file_name(file)\n\n        return FileImportInfo(\n            self.name,\n            _assert_type(\"account\", account or \"\", str),\n            _assert_type(\"date\", date or local_today(), datetime.date),\n            _assert_type(\"filename\", filename or path.name, str),\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.name","title":"<code>name</code>  <code>property</code>","text":"<p>Get the name of the importer.</p>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.identify","title":"<code>identify(path)</code>","text":"<p>Whether the importer is matching the file.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@_catch_any\ndef identify(self: WrappedImporter, path: Path) -&gt; bool:\n    \"\"\"Whether the importer is matching the file.\"\"\"\n    importer = self.importer\n    matches = (\n        importer.identify(str(path))\n        if isinstance(importer, Importer)\n        else importer.identify(get_cached_file(path))\n    )\n    return _assert_type(\"identify\", matches, bool)\n</code></pre>"},{"location":"api/#rustfava.core.ingest.WrappedImporter.file_import_info","title":"<code>file_import_info(path)</code>","text":"<p>Generate info about a file with an importer.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>@_catch_any\ndef file_import_info(self, path: Path) -&gt; FileImportInfo:\n    \"\"\"Generate info about a file with an importer.\"\"\"\n    importer = self.importer\n    if isinstance(importer, Importer):\n        str_path = str(path)\n        account = importer.account(str_path)\n        date = importer.date(str_path)\n        filename = importer.filename(str_path)\n    else:\n        file = get_cached_file(path)\n        account = importer.file_account(file)\n        date = importer.file_date(file)\n        filename = importer.file_name(file)\n\n    return FileImportInfo(\n        self.name,\n        _assert_type(\"account\", account or \"\", str),\n        _assert_type(\"date\", date or local_today(), datetime.date),\n        _assert_type(\"filename\", filename or path.name, str),\n    )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule","title":"<code>IngestModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Exposes ingest functionality.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>class IngestModule(FavaModule):\n    \"\"\"Exposes ingest functionality.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.importers: Mapping[str, WrappedImporter] = {}\n        self.hooks: Hooks = []\n        self.mtime: int | None = None\n        self.errors: list[IngestError] = []\n\n    @property\n    def module_path(self) -&gt; Path | None:\n        \"\"\"The path to the importer configuration.\"\"\"\n        config_path = self.ledger.fava_options.import_config\n        if not config_path:\n            return None\n        return self.ledger.join_path(config_path)\n\n    def _error(self, msg: str) -&gt; None:\n        self.errors.append(\n            IngestError(\n                {\"filename\": str(self.module_path), \"lineno\": 0},\n                msg,\n                None,\n            ),\n        )\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        self.errors = []\n        module_path = self.module_path\n        if module_path is None:\n            return\n\n        if not module_path.exists():\n            self._error(\"Import config does not exist\")\n            return\n\n        new_mtime = module_path.stat().st_mtime_ns\n        if new_mtime == self.mtime:\n            return\n\n        try:\n            self.importers, self.hooks = load_import_config(module_path)\n            self.mtime = new_mtime\n        except RustfavaAPIError as error:  # pragma: no cover\n            msg = f\"Error in import config '{module_path}': {error!s}\"\n            self._error(msg)\n\n    def import_data(self) -&gt; list[FileImporters]:\n        \"\"\"Identify files and importers that can be imported.\n\n        Returns:\n            A list of :class:`.FileImportInfo`.\n        \"\"\"\n        if not self.importers:\n            return []\n\n        importers = list(self.importers.values())\n\n        ret: list[FileImporters] = []\n        for directory in self.ledger.fava_options.import_dirs:\n            full_path = self.ledger.join_path(directory)\n            ret.extend(find_imports(importers, full_path))\n\n        return ret\n\n    def extract(self, filename: str, importer_name: str) -&gt; list[Directive]:\n        \"\"\"Extract entries from filename with the specified importer.\n\n        Args:\n            filename: The full path to a file.\n            importer_name: The name of an importer that matched the file.\n\n        Returns:\n            A list of new imported entries.\n        \"\"\"\n        if not self.module_path:\n            raise MissingImporterConfigError\n\n        # reload (if changed)\n        self.load_file()\n\n        try:\n            path = Path(filename)\n            importer = self.importers[importer_name]\n            new_entries = extract_from_file(\n                importer,\n                path,\n                existing_entries=self.ledger.all_entries,\n            )\n        except Exception as exc:\n            raise ImporterExtractError from exc\n\n        for hook_fn in self.hooks:\n            annotations = get_annotations(hook_fn)\n            if any(\"Importer\" in a for a in annotations.values()):\n                importer_info = importer.file_import_info(path)\n                new_entries_list: HookOutput = [\n                    (\n                        filename,\n                        new_entries,\n                        importer_info.account,\n                        importer.importer,\n                    )\n                ]\n            else:\n                new_entries_list = [(filename, new_entries)]\n\n            new_entries_list = hook_fn(\n                new_entries_list,\n                self.ledger.all_entries,\n            )\n\n            new_entries = new_entries_list[0][1]\n\n        return new_entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule.module_path","title":"<code>module_path</code>  <code>property</code>","text":"<p>The path to the importer configuration.</p>"},{"location":"api/#rustfava.core.ingest.IngestModule.import_data","title":"<code>import_data()</code>","text":"<p>Identify files and importers that can be imported.</p> <p>Returns:</p> Type Description <code>list[FileImporters]</code> <p>A list of :class:<code>.FileImportInfo</code>.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def import_data(self) -&gt; list[FileImporters]:\n    \"\"\"Identify files and importers that can be imported.\n\n    Returns:\n        A list of :class:`.FileImportInfo`.\n    \"\"\"\n    if not self.importers:\n        return []\n\n    importers = list(self.importers.values())\n\n    ret: list[FileImporters] = []\n    for directory in self.ledger.fava_options.import_dirs:\n        full_path = self.ledger.join_path(directory)\n        ret.extend(find_imports(importers, full_path))\n\n    return ret\n</code></pre>"},{"location":"api/#rustfava.core.ingest.IngestModule.extract","title":"<code>extract(filename, importer_name)</code>","text":"<p>Extract entries from filename with the specified importer.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The full path to a file.</p> required <code>importer_name</code> <code>str</code> <p>The name of an importer that matched the file.</p> required <p>Returns:</p> Type Description <code>list[Directive]</code> <p>A list of new imported entries.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def extract(self, filename: str, importer_name: str) -&gt; list[Directive]:\n    \"\"\"Extract entries from filename with the specified importer.\n\n    Args:\n        filename: The full path to a file.\n        importer_name: The name of an importer that matched the file.\n\n    Returns:\n        A list of new imported entries.\n    \"\"\"\n    if not self.module_path:\n        raise MissingImporterConfigError\n\n    # reload (if changed)\n    self.load_file()\n\n    try:\n        path = Path(filename)\n        importer = self.importers[importer_name]\n        new_entries = extract_from_file(\n            importer,\n            path,\n            existing_entries=self.ledger.all_entries,\n        )\n    except Exception as exc:\n        raise ImporterExtractError from exc\n\n    for hook_fn in self.hooks:\n        annotations = get_annotations(hook_fn)\n        if any(\"Importer\" in a for a in annotations.values()):\n            importer_info = importer.file_import_info(path)\n            new_entries_list: HookOutput = [\n                (\n                    filename,\n                    new_entries,\n                    importer_info.account,\n                    importer.importer,\n                )\n            ]\n        else:\n            new_entries_list = [(filename, new_entries)]\n\n        new_entries_list = hook_fn(\n            new_entries_list,\n            self.ledger.all_entries,\n        )\n\n        new_entries = new_entries_list[0][1]\n\n    return new_entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.walk_dir","title":"<code>walk_dir(directory)</code>","text":"<p>Walk through all files in dir.</p> <p>Ignores common dot-directories like .git, .cache. .venv, see IGNORE_DIRS.</p> <p>Parameters:</p> Name Type Description Default <code>directory</code> <code>Path</code> <p>The directory to start in.</p> required <p>Yields:</p> Type Description <code>Iterable[Path]</code> <p>All full paths under directory, ignoring some directories.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def walk_dir(directory: Path) -&gt; Iterable[Path]:\n    \"\"\"Walk through all files in dir.\n\n    Ignores common dot-directories like .git, .cache. .venv, see IGNORE_DIRS.\n\n    Args:\n        directory: The directory to start in.\n\n    Yields:\n        All full paths under directory, ignoring some directories.\n    \"\"\"\n    for root, dirs, filenames in os.walk(directory):\n        dirs[:] = sorted(d for d in dirs if d not in IGNORE_DIRS)\n        root_path = Path(root)\n        for filename in sorted(filenames):\n            yield root_path / filename\n</code></pre>"},{"location":"api/#rustfava.core.ingest.get_cached_file","title":"<code>get_cached_file(path)</code>","text":"<p>Get a cached FileMemo.</p> <p>This checks the file's mtime before getting it from the Cache. In addition to using the beangulp cache.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def get_cached_file(path: Path) -&gt; FileMemo:\n    \"\"\"Get a cached FileMemo.\n\n    This checks the file's mtime before getting it from the Cache.\n    In addition to using the beangulp cache.\n    \"\"\"\n    mtime = path.stat().st_mtime_ns\n    filename = str(path)\n    cached = _CACHE.get(path)\n    if cached:\n        mtime_cached, memo_cached = cached\n        if mtime &lt;= mtime_cached:  # pragma: no cover\n            return memo_cached\n    memo: FileMemo = cache._FileMemo(filename)  # noqa: SLF001\n    cache._CACHE[filename] = memo  # noqa: SLF001\n    _CACHE[path] = (mtime, memo)\n    return memo\n</code></pre>"},{"location":"api/#rustfava.core.ingest.find_imports","title":"<code>find_imports(config, directory)</code>","text":"<p>Pair files and matching importers.</p> <p>Yields:</p> Type Description <code>Iterable[FileImporters]</code> <p>For each file in directory, a pair of its filename and the matching</p> <code>Iterable[FileImporters]</code> <p>importers.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def find_imports(\n    config: Sequence[WrappedImporter], directory: Path\n) -&gt; Iterable[FileImporters]:\n    \"\"\"Pair files and matching importers.\n\n    Yields:\n        For each file in directory, a pair of its filename and the matching\n        importers.\n    \"\"\"\n    for path in walk_dir(directory):\n        stat = path.stat()\n        if stat.st_size &gt; _FILE_TOO_LARGE_THRESHOLD:  # pragma: no cover\n            continue\n\n        importers = [\n            importer.file_import_info(path)\n            for importer in config\n            if importer.identify(path)\n        ]\n        yield FileImporters(\n            name=str(path), basename=path.name, importers=importers\n        )\n</code></pre>"},{"location":"api/#rustfava.core.ingest.extract_from_file","title":"<code>extract_from_file(wrapped_importer, path, existing_entries)</code>","text":"<p>Import entries from a document.</p> <p>Parameters:</p> Name Type Description Default <code>wrapped_importer</code> <code>WrappedImporter</code> <p>The importer instance to handle the document.</p> required <code>path</code> <code>Path</code> <p>Filesystem path to the document.</p> required <code>existing_entries</code> <code>Sequence[Directive]</code> <p>Existing entries.</p> required <p>Returns:</p> Type Description <code>list[Directive]</code> <p>The list of imported entries.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def extract_from_file(\n    wrapped_importer: WrappedImporter,\n    path: Path,\n    existing_entries: Sequence[Directive],\n) -&gt; list[Directive]:\n    \"\"\"Import entries from a document.\n\n    Args:\n      wrapped_importer: The importer instance to handle the document.\n      path: Filesystem path to the document.\n      existing_entries: Existing entries.\n\n    Returns:\n      The list of imported entries.\n    \"\"\"\n    filename = str(path)\n    importer = wrapped_importer.importer\n    if isinstance(importer, Importer):\n        entries = importer.extract(filename, existing=existing_entries)\n    else:\n        file = get_cached_file(path)\n        entries = (\n            importer.extract(file, existing_entries=existing_entries)\n            if \"existing_entries\" in signature(importer.extract).parameters\n            else importer.extract(file)\n        ) or []\n\n    if hasattr(importer, \"sort\"):\n        importer.sort(entries)\n    else:\n        entries.sort(key=_incomplete_sortkey)\n    if isinstance(importer, Importer):\n        importer.deduplicate(entries, existing=existing_entries)\n    return entries\n</code></pre>"},{"location":"api/#rustfava.core.ingest.load_import_config","title":"<code>load_import_config(module_path)</code>","text":"<p>Load the given import config and extract importers and hooks.</p> <p>Parameters:</p> Name Type Description Default <code>module_path</code> <code>Path</code> <p>Path to the import config.</p> required <p>Returns:</p> Type Description <code>tuple[Mapping[str, WrappedImporter], Hooks]</code> <p>A pair of the importers (by name) and the list of hooks.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def load_import_config(\n    module_path: Path,\n) -&gt; tuple[Mapping[str, WrappedImporter], Hooks]:\n    \"\"\"Load the given import config and extract importers and hooks.\n\n    Args:\n        module_path: Path to the import config.\n\n    Returns:\n        A pair of the importers (by name) and the list of hooks.\n    \"\"\"\n    try:\n        mod = run_path(str(module_path))\n    except Exception as error:  # pragma: no cover\n        message = traceback.format_exc()\n        raise ImportConfigLoadError(message) from error\n\n    if \"CONFIG\" not in mod:\n        msg = \"CONFIG is missing\"\n        raise ImportConfigLoadError(msg)\n    if not isinstance(mod[\"CONFIG\"], list):  # pragma: no cover\n        msg = \"CONFIG is not a list\"\n        raise ImportConfigLoadError(msg)\n\n    config = mod[\"CONFIG\"]\n    hooks = DEFAULT_HOOKS\n    if \"HOOKS\" in mod:  # pragma: no cover\n        hooks = mod[\"HOOKS\"]\n        if not isinstance(hooks, list) or not all(\n            callable(fn) for fn in hooks\n        ):\n            msg = \"HOOKS is not a list of callables\"\n            raise ImportConfigLoadError(msg)\n    importers = {}\n    for importer in config:\n        if not isinstance(\n            importer, (BeanImporterProtocol, Importer)\n        ):  # pragma: no cover\n            name = importer.__class__.__name__\n            msg = (\n                f\"Importer class '{name}' in '{module_path}' does \"\n                \"not satisfy importer protocol\"\n            )\n            raise ImportConfigLoadError(msg)\n        wrapped_importer = WrappedImporter(importer)\n        if wrapped_importer.name in importers:\n            msg = f\"Duplicate importer name found: {wrapped_importer.name}\"\n            raise ImportConfigLoadError(msg)\n        importers[wrapped_importer.name] = wrapped_importer\n    return importers, hooks\n</code></pre>"},{"location":"api/#rustfava.core.ingest.filepath_in_primary_imports_folder","title":"<code>filepath_in_primary_imports_folder(filename, ledger)</code>","text":"<p>File path for a document to upload to the primary import folder.</p> <p>Parameters:</p> Name Type Description Default <code>filename</code> <code>str</code> <p>The filename of the document.</p> required <code>ledger</code> <code>RustfavaLedger</code> <p>The RustfavaLedger.</p> required <p>Returns:</p> Type Description <code>Path</code> <p>The path that the document should be saved at.</p> Source code in <code>src/rustfava/core/ingest.py</code> <pre><code>def filepath_in_primary_imports_folder(\n    filename: str,\n    ledger: RustfavaLedger,\n) -&gt; Path:\n    \"\"\"File path for a document to upload to the primary import folder.\n\n    Args:\n        filename: The filename of the document.\n        ledger: The RustfavaLedger.\n\n    Returns:\n        The path that the document should be saved at.\n    \"\"\"\n    primary_imports_folder = next(iter(ledger.fava_options.import_dirs), None)\n    if primary_imports_folder is None:\n        raise MissingImporterDirsError\n\n    filename = filename.replace(sep, \" \")\n    if altsep:  # pragma: no cover\n        filename = filename.replace(altsep, \" \")\n\n    return ledger.join_path(primary_imports_folder, filename)\n</code></pre>"},{"location":"api/#rustfava.core.inventory","title":"<code>inventory</code>","text":"<p>Alternative implementation of Beancount's Inventory.</p>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory","title":"<code>SimpleCounterInventory</code>","text":"<p>               Bases: <code>dict[str, Decimal]</code></p> <p>A simple inventory mapping just strings to numbers.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>class SimpleCounterInventory(dict[str, Decimal]):\n    \"\"\"A simple inventory mapping just strings to numbers.\"\"\"\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the inventory is empty.\"\"\"\n        return not bool(self)\n\n    def add(self, key: str, number: Decimal) -&gt; None:\n        \"\"\"Add a number to key.\"\"\"\n        new_num = number + self.get(key, ZERO)\n        if new_num == ZERO:\n            self.pop(key, None)\n        else:\n            self[key] = new_num\n\n    def __iter__(self) -&gt; Iterator[str]:\n        raise NotImplementedError\n\n    def __neg__(self) -&gt; SimpleCounterInventory:\n        return SimpleCounterInventory({key: -num for key, num in self.items()})\n\n    def reduce(\n        self,\n        reducer: Callable[Concatenate[Position, P], Amount],\n        *args: P.args,\n        **_kwargs: P.kwargs,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Reduce inventory.\"\"\"\n        counter = SimpleCounterInventory()\n        for currency, number in self.items():\n            pos = _Position(_Amount(number, currency), None)\n            amount = reducer(pos, *args)  # type: ignore[call-arg]\n            counter.add(amount.currency, amount.number)\n        return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.is_empty","title":"<code>is_empty()</code>","text":"<p>Check if the inventory is empty.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def is_empty(self) -&gt; bool:\n    \"\"\"Check if the inventory is empty.\"\"\"\n    return not bool(self)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.add","title":"<code>add(key, number)</code>","text":"<p>Add a number to key.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add(self, key: str, number: Decimal) -&gt; None:\n    \"\"\"Add a number to key.\"\"\"\n    new_num = number + self.get(key, ZERO)\n    if new_num == ZERO:\n        self.pop(key, None)\n    else:\n        self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.SimpleCounterInventory.reduce","title":"<code>reduce(reducer, *args, **_kwargs)</code>","text":"<p>Reduce inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def reduce(\n    self,\n    reducer: Callable[Concatenate[Position, P], Amount],\n    *args: P.args,\n    **_kwargs: P.kwargs,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Reduce inventory.\"\"\"\n    counter = SimpleCounterInventory()\n    for currency, number in self.items():\n        pos = _Position(_Amount(number, currency), None)\n        amount = reducer(pos, *args)  # type: ignore[call-arg]\n        counter.add(amount.currency, amount.number)\n    return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory","title":"<code>CounterInventory</code>","text":"<p>               Bases: <code>dict[InventoryKey, Decimal]</code></p> <p>A lightweight inventory.</p> <p>This is intended as a faster alternative to Beancount's Inventory class. Due to not using a list, for inventories with a lot of different positions, inserting is much faster.</p> <p>The keys should be tuples <code>(currency, cost)</code>.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>class CounterInventory(dict[InventoryKey, Decimal]):\n    \"\"\"A lightweight inventory.\n\n    This is intended as a faster alternative to Beancount's Inventory class.\n    Due to not using a list, for inventories with a lot of different positions,\n    inserting is much faster.\n\n    The keys should be tuples ``(currency, cost)``.\n    \"\"\"\n\n    def is_empty(self) -&gt; bool:\n        \"\"\"Check if the inventory is empty.\"\"\"\n        return not bool(self)\n\n    def add(self, key: InventoryKey, number: Decimal) -&gt; None:\n        \"\"\"Add a number to key.\"\"\"\n        new_num = number + self.get(key, ZERO)\n        if new_num == ZERO:\n            self.pop(key, None)\n        else:\n            self[key] = new_num\n\n    def __iter__(self) -&gt; Iterator[InventoryKey]:\n        raise NotImplementedError\n\n    def to_strings(self) -&gt; list[str]:\n        \"\"\"Print as a list of strings (e.g. for snapshot tests).\"\"\"\n        strings = []\n        for (currency, cost), number in self.items():\n            if cost is None:\n                strings.append(f\"{number} {currency}\")\n            else:\n                cost_str = cost_to_string(cost)\n                strings.append(f\"{number} {currency} {{{cost_str}}}\")\n        return strings\n\n    def reduce(\n        self,\n        reducer: Callable[Concatenate[Position, P], Amount],\n        *args: P.args,\n        **_kwargs: P.kwargs,\n    ) -&gt; SimpleCounterInventory:\n        \"\"\"Reduce inventory.\n\n        Note that this returns a simple :class:`CounterInventory` with just\n        currencies as keys.\n        \"\"\"\n        counter = SimpleCounterInventory()\n        for (currency, cost), number in self.items():\n            pos = _Position(_Amount(number, currency), cost)\n            amount = reducer(pos, *args)  # type: ignore[call-arg]\n            counter.add(amount.currency, amount.number)\n        return counter\n\n    def add_amount(self, amount: Amount, cost: Cost | None = None) -&gt; None:\n        \"\"\"Add an Amount to the inventory.\"\"\"\n        key = (amount.currency, cost)\n        self.add(key, amount.number)\n\n    def add_position(self, pos: Position) -&gt; None:\n        \"\"\"Add a Position or Posting to the inventory.\"\"\"\n        # Skip positions with missing units (can happen with parse errors)\n        if pos.units is None:\n            return\n        self.add_amount(pos.units, pos.cost)\n\n    def __neg__(self) -&gt; CounterInventory:\n        return CounterInventory({key: -num for key, num in self.items()})\n\n    def __add__(self, other: CounterInventory) -&gt; CounterInventory:\n        counter = CounterInventory(self)\n        counter.add_inventory(other)\n        return counter\n\n    def add_inventory(self, counter: CounterInventory) -&gt; None:\n        \"\"\"Add another :class:`CounterInventory`.\"\"\"\n        if not self:\n            self.update(counter)\n        else:\n            self_get = self.get\n            for key, num in counter.items():\n                new_num = num + self_get(key, ZERO)\n                if new_num == ZERO:\n                    self.pop(key, None)\n                else:\n                    self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.is_empty","title":"<code>is_empty()</code>","text":"<p>Check if the inventory is empty.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def is_empty(self) -&gt; bool:\n    \"\"\"Check if the inventory is empty.\"\"\"\n    return not bool(self)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add","title":"<code>add(key, number)</code>","text":"<p>Add a number to key.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add(self, key: InventoryKey, number: Decimal) -&gt; None:\n    \"\"\"Add a number to key.\"\"\"\n    new_num = number + self.get(key, ZERO)\n    if new_num == ZERO:\n        self.pop(key, None)\n    else:\n        self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.to_strings","title":"<code>to_strings()</code>","text":"<p>Print as a list of strings (e.g. for snapshot tests).</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def to_strings(self) -&gt; list[str]:\n    \"\"\"Print as a list of strings (e.g. for snapshot tests).\"\"\"\n    strings = []\n    for (currency, cost), number in self.items():\n        if cost is None:\n            strings.append(f\"{number} {currency}\")\n        else:\n            cost_str = cost_to_string(cost)\n            strings.append(f\"{number} {currency} {{{cost_str}}}\")\n    return strings\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.reduce","title":"<code>reduce(reducer, *args, **_kwargs)</code>","text":"<p>Reduce inventory.</p> <p>Note that this returns a simple :class:<code>CounterInventory</code> with just currencies as keys.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def reduce(\n    self,\n    reducer: Callable[Concatenate[Position, P], Amount],\n    *args: P.args,\n    **_kwargs: P.kwargs,\n) -&gt; SimpleCounterInventory:\n    \"\"\"Reduce inventory.\n\n    Note that this returns a simple :class:`CounterInventory` with just\n    currencies as keys.\n    \"\"\"\n    counter = SimpleCounterInventory()\n    for (currency, cost), number in self.items():\n        pos = _Position(_Amount(number, currency), cost)\n        amount = reducer(pos, *args)  # type: ignore[call-arg]\n        counter.add(amount.currency, amount.number)\n    return counter\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_amount","title":"<code>add_amount(amount, cost=None)</code>","text":"<p>Add an Amount to the inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_amount(self, amount: Amount, cost: Cost | None = None) -&gt; None:\n    \"\"\"Add an Amount to the inventory.\"\"\"\n    key = (amount.currency, cost)\n    self.add(key, amount.number)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_position","title":"<code>add_position(pos)</code>","text":"<p>Add a Position or Posting to the inventory.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_position(self, pos: Position) -&gt; None:\n    \"\"\"Add a Position or Posting to the inventory.\"\"\"\n    # Skip positions with missing units (can happen with parse errors)\n    if pos.units is None:\n        return\n    self.add_amount(pos.units, pos.cost)\n</code></pre>"},{"location":"api/#rustfava.core.inventory.CounterInventory.add_inventory","title":"<code>add_inventory(counter)</code>","text":"<p>Add another :class:<code>CounterInventory</code>.</p> Source code in <code>src/rustfava/core/inventory.py</code> <pre><code>def add_inventory(self, counter: CounterInventory) -&gt; None:\n    \"\"\"Add another :class:`CounterInventory`.\"\"\"\n    if not self:\n        self.update(counter)\n    else:\n        self_get = self.get\n        for key, num in counter.items():\n            new_num = num + self_get(key, ZERO)\n            if new_num == ZERO:\n                self.pop(key, None)\n            else:\n                self[key] = new_num\n</code></pre>"},{"location":"api/#rustfava.core.misc","title":"<code>misc</code>","text":"<p>Some miscellaneous reports.</p>"},{"location":"api/#rustfava.core.misc.FavaError","title":"<code>FavaError</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BeancountError</code></p> <p>Generic Fava-specific error.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>class FavaError(BeancountError):\n    \"\"\"Generic Fava-specific error.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.misc.FavaMisc","title":"<code>FavaMisc</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Provides access to some miscellaneous reports.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>class FavaMisc(FavaModule):\n    \"\"\"Provides access to some miscellaneous reports.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        #: User-chosen links to show in the sidebar.\n        self.sidebar_links: SidebarLinks = []\n        #: Upcoming events in the next few days.\n        self.upcoming_events: Sequence[Event] = []\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        custom_entries = self.ledger.all_entries_by_type.Custom\n        self.sidebar_links = sidebar_links(custom_entries)\n\n        self.upcoming_events = upcoming_events(\n            self.ledger.all_entries_by_type.Event,\n            self.ledger.fava_options.upcoming_events,\n        )\n\n    @property\n    def errors(self) -&gt; Sequence[FavaError]:\n        \"\"\"An error if no operating currency is set.\"\"\"\n        return (\n            []\n            if self.ledger.options[\"operating_currency\"]\n            else [NO_OPERATING_CURRENCY_ERROR]\n        )\n</code></pre>"},{"location":"api/#rustfava.core.misc.FavaMisc.errors","title":"<code>errors</code>  <code>property</code>","text":"<p>An error if no operating currency is set.</p>"},{"location":"api/#rustfava.core.misc.sidebar_links","title":"<code>sidebar_links(custom_entries)</code>","text":"<p>Parse custom entries for links.</p> <p>They have the following format:</p> <p>2016-04-01 custom \"fava-sidebar-link\" \"2014\" \"/income_statement/?time=2014\"</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>def sidebar_links(custom_entries: Sequence[Custom]) -&gt; SidebarLinks:\n    \"\"\"Parse custom entries for links.\n\n    They have the following format:\n\n    2016-04-01 custom \"fava-sidebar-link\" \"2014\" \"/income_statement/?time=2014\"\n    \"\"\"\n    sidebar_link_entries = [\n        entry for entry in custom_entries if entry.type == \"fava-sidebar-link\"\n    ]\n    return [\n        (entry.values[0].value, entry.values[1].value)\n        for entry in sidebar_link_entries\n    ]\n</code></pre>"},{"location":"api/#rustfava.core.misc.upcoming_events","title":"<code>upcoming_events(events, max_delta)</code>","text":"<p>Parse entries for upcoming events.</p> <p>Parameters:</p> Name Type Description Default <code>events</code> <code>Sequence[Event]</code> <p>A list of events.</p> required <code>max_delta</code> <code>int</code> <p>Number of days that should be considered.</p> required <p>Returns:</p> Type Description <code>Sequence[Event]</code> <p>A list of the Events in entries that are less than <code>max_delta</code> days</p> <code>Sequence[Event]</code> <p>away.</p> Source code in <code>src/rustfava/core/misc.py</code> <pre><code>def upcoming_events(\n    events: Sequence[Event], max_delta: int\n) -&gt; Sequence[Event]:\n    \"\"\"Parse entries for upcoming events.\n\n    Args:\n        events: A list of events.\n        max_delta: Number of days that should be considered.\n\n    Returns:\n        A list of the Events in entries that are less than `max_delta` days\n        away.\n    \"\"\"\n    today = local_today()\n    upcoming = []\n\n    for event in events:\n        delta = event.date - today\n        if delta.days &gt;= 0 and delta.days &lt; max_delta:\n            upcoming.append(event)\n\n    return upcoming\n</code></pre>"},{"location":"api/#rustfava.core.misc.align","title":"<code>align(string, currency_column)</code>","text":"<p>Align currencies in one column.</p> Source code in <code>src/rustfava/beans/str.py</code> <pre><code>def align(string: str, currency_column: int) -&gt; str:\n    \"\"\"Align currencies in one column.\"\"\"\n    output = io.StringIO()\n    for line in string.splitlines():\n        match = ALIGN_RE.match(line)\n        if match:\n            prefix, number, rest = match.groups()\n            num_of_spaces = currency_column - len(prefix) - len(number) - 4\n            spaces = \" \" * num_of_spaces\n            output.write(prefix + spaces + \"  \" + number + \" \" + rest)\n        else:\n            output.write(line)\n        output.write(\"\\n\")\n\n    return output.getvalue()\n</code></pre>"},{"location":"api/#rustfava.core.module_base","title":"<code>module_base</code>","text":"<p>Base class for the \"modules\" of rustfavaLedger.</p>"},{"location":"api/#rustfava.core.module_base.FavaModule","title":"<code>FavaModule</code>","text":"<p>Base class for the \"modules\" of rustfavaLedger.</p> Source code in <code>src/rustfava/core/module_base.py</code> <pre><code>class FavaModule:\n    \"\"\"Base class for the \"modules\" of rustfavaLedger.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        self.ledger = ledger\n\n    def load_file(self) -&gt; None:\n        \"\"\"Run when the file has been (re)loaded.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.module_base.FavaModule.load_file","title":"<code>load_file()</code>","text":"<p>Run when the file has been (re)loaded.</p> Source code in <code>src/rustfava/core/module_base.py</code> <pre><code>def load_file(self) -&gt; None:\n    \"\"\"Run when the file has been (re)loaded.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.number","title":"<code>number</code>","text":"<p>Formatting numbers.</p>"},{"location":"api/#rustfava.core.number.DecimalFormatModule","title":"<code>DecimalFormatModule</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>Formatting numbers.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>class DecimalFormatModule(FavaModule):\n    \"\"\"Formatting numbers.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self._locale: Locale | None = None\n        self._formatters: dict[str, Formatter] = {}\n        self._default_pattern = get_locale_format(None, 2)\n        self.precisions: dict[str, int] = {}\n\n    def load_file(self) -&gt; None:  # noqa: D102\n        locale = None\n\n        locale_option = self.ledger.fava_options.locale\n        if (\n            self.ledger.options[\"render_commas\"] and not locale_option\n        ):  # pragma: no cover\n            locale_option = \"en\"\n            self.ledger.fava_options.locale = locale_option\n\n        if locale_option:\n            locale = Locale.parse(locale_option)\n\n        dcontext = self.ledger.options[\"dcontext\"]\n        precisions: dict[str, int] = {}\n\n        # Both beancount's DisplayContext and RLDisplayContext have ccontexts\n        for currency, ccontext in dcontext.ccontexts.items():\n            prec = ccontext.get_fractional(None)\n            if prec is not None:\n                precisions[currency] = prec\n\n        precisions.update(self.ledger.commodities.precisions)\n\n        self._locale = locale\n        self._default_pattern = get_locale_format(locale, 2)\n        self._formatters = {\n            currency: get_locale_format(locale, prec)\n            for currency, prec in precisions.items()\n        }\n        self.precisions = precisions\n\n    def __call__(self, value: Decimal, currency: str | None = None) -&gt; str:\n        \"\"\"Format a decimal to the right number of decimal digits with locale.\n\n        Arguments:\n            value: A decimal number.\n            currency: A currency string or None.\n\n        Returns:\n            A string, the formatted decimal.\n        \"\"\"\n        if currency is None:\n            return self._default_pattern(value)\n        return self._formatters.get(currency, self._default_pattern)(value)\n</code></pre>"},{"location":"api/#rustfava.core.number.DecimalFormatModule.__call__","title":"<code>__call__(value, currency=None)</code>","text":"<p>Format a decimal to the right number of decimal digits with locale.</p> <p>Parameters:</p> Name Type Description Default <code>value</code> <code>Decimal</code> <p>A decimal number.</p> required <code>currency</code> <code>str | None</code> <p>A currency string or None.</p> <code>None</code> <p>Returns:</p> Type Description <code>str</code> <p>A string, the formatted decimal.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>def __call__(self, value: Decimal, currency: str | None = None) -&gt; str:\n    \"\"\"Format a decimal to the right number of decimal digits with locale.\n\n    Arguments:\n        value: A decimal number.\n        currency: A currency string or None.\n\n    Returns:\n        A string, the formatted decimal.\n    \"\"\"\n    if currency is None:\n        return self._default_pattern(value)\n    return self._formatters.get(currency, self._default_pattern)(value)\n</code></pre>"},{"location":"api/#rustfava.core.number.get_locale_format","title":"<code>get_locale_format(locale, precision)</code>","text":"<p>Obtain formatting pattern for the given locale and precision.</p> <p>Parameters:</p> Name Type Description Default <code>locale</code> <code>Locale | None</code> <p>An optional locale.</p> required <code>precision</code> <code>int</code> <p>The precision.</p> required <p>Returns:</p> Type Description <code>Formatter</code> <p>A function that renders Decimals to strings as desired.</p> Source code in <code>src/rustfava/core/number.py</code> <pre><code>def get_locale_format(locale: Locale | None, precision: int) -&gt; Formatter:\n    \"\"\"Obtain formatting pattern for the given locale and precision.\n\n    Arguments:\n        locale: An optional locale.\n        precision: The precision.\n\n    Returns:\n        A function that renders Decimals to strings as desired.\n    \"\"\"\n    # Set a maximum precision of 14, half the default precision of Decimal\n    precision = min(precision, 14)\n    if locale is None:\n        fmt_string = \"{:.\" + str(precision) + \"f}\"\n\n        def fmt(num: Decimal) -&gt; str:\n            return fmt_string.format(num)\n\n        return fmt\n\n    pattern = copy.copy(locale.decimal_formats.get(None))\n    if not pattern:  # pragma: no cover\n        msg = \"Expected Locale to have a decimal format pattern\"\n        raise ValueError(msg)\n    pattern.frac_prec = (precision, precision)\n\n    def locale_fmt(num: Decimal) -&gt; str:\n        return pattern.apply(num, locale)  # type: ignore[no-any-return]\n\n    return locale_fmt\n</code></pre>"},{"location":"api/#rustfava.core.query","title":"<code>query</code>","text":"<p>Query result types.</p>"},{"location":"api/#rustfava.core.query.QueryResultTable","title":"<code>QueryResultTable</code>  <code>dataclass</code>","text":"<p>Table query result.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass QueryResultTable:\n    \"\"\"Table query result.\"\"\"\n\n    types: list[BaseColumn]\n    rows: list[tuple[SerialisedQueryRowValue, ...]]\n    t: Literal[\"table\"] = \"table\"\n</code></pre>"},{"location":"api/#rustfava.core.query.QueryResultText","title":"<code>QueryResultText</code>  <code>dataclass</code>","text":"<p>Text query result.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass QueryResultText:\n    \"\"\"Text query result.\"\"\"\n\n    contents: str\n    t: Literal[\"string\"] = \"string\"\n</code></pre>"},{"location":"api/#rustfava.core.query.BaseColumn","title":"<code>BaseColumn</code>  <code>dataclass</code>","text":"<p>A query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass BaseColumn:\n    \"\"\"A query column.\"\"\"\n\n    name: str\n    dtype: str\n\n    @staticmethod\n    def serialise(\n        val: QueryRowValue,\n    ) -&gt; SerialisedQueryRowValue:\n        \"\"\"Serialiseable version of the column value.\"\"\"\n        return val  # type: ignore[no-any-return]\n</code></pre>"},{"location":"api/#rustfava.core.query.BaseColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialiseable version of the column value.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(\n    val: QueryRowValue,\n) -&gt; SerialisedQueryRowValue:\n    \"\"\"Serialiseable version of the column value.\"\"\"\n    return val  # type: ignore[no-any-return]\n</code></pre>"},{"location":"api/#rustfava.core.query.BoolColumn","title":"<code>BoolColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A boolean query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass BoolColumn(BaseColumn):\n    \"\"\"A boolean query column.\"\"\"\n\n    dtype: str = \"bool\"\n</code></pre>"},{"location":"api/#rustfava.core.query.DecimalColumn","title":"<code>DecimalColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A Decimal query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass DecimalColumn(BaseColumn):\n    \"\"\"A Decimal query column.\"\"\"\n\n    dtype: str = \"Decimal\"\n</code></pre>"},{"location":"api/#rustfava.core.query.IntColumn","title":"<code>IntColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A int query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass IntColumn(BaseColumn):\n    \"\"\"A int query column.\"\"\"\n\n    dtype: str = \"int\"\n</code></pre>"},{"location":"api/#rustfava.core.query.StrColumn","title":"<code>StrColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A str query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass StrColumn(BaseColumn):\n    \"\"\"A str query column.\"\"\"\n\n    dtype: str = \"str\"\n</code></pre>"},{"location":"api/#rustfava.core.query.DateColumn","title":"<code>DateColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A date query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass DateColumn(BaseColumn):\n    \"\"\"A date query column.\"\"\"\n\n    dtype: str = \"date\"\n</code></pre>"},{"location":"api/#rustfava.core.query.PositionColumn","title":"<code>PositionColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A Position query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass PositionColumn(BaseColumn):\n    \"\"\"A Position query column.\"\"\"\n\n    dtype: str = \"Position\"\n</code></pre>"},{"location":"api/#rustfava.core.query.SetColumn","title":"<code>SetColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>A set query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass SetColumn(BaseColumn):\n    \"\"\"A set query column.\"\"\"\n\n    dtype: str = \"set\"\n</code></pre>"},{"location":"api/#rustfava.core.query.AmountColumn","title":"<code>AmountColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An amount query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass AmountColumn(BaseColumn):\n    \"\"\"An amount query column.\"\"\"\n\n    dtype: str = \"Amount\"\n</code></pre>"},{"location":"api/#rustfava.core.query.ObjectColumn","title":"<code>ObjectColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An object query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass ObjectColumn(BaseColumn):\n    \"\"\"An object query column.\"\"\"\n\n    dtype: str = \"object\"\n\n    @staticmethod\n    def serialise(val: object) -&gt; str:\n        \"\"\"Serialise an object of unknown type to a string.\"\"\"\n        return str(val)\n</code></pre>"},{"location":"api/#rustfava.core.query.ObjectColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialise an object of unknown type to a string.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(val: object) -&gt; str:\n    \"\"\"Serialise an object of unknown type to a string.\"\"\"\n    return str(val)\n</code></pre>"},{"location":"api/#rustfava.core.query.InventoryColumn","title":"<code>InventoryColumn</code>  <code>dataclass</code>","text":"<p>               Bases: <code>BaseColumn</code></p> <p>An inventory query column.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@dataclass(frozen=True)\nclass InventoryColumn(BaseColumn):\n    \"\"\"An inventory query column.\"\"\"\n\n    dtype: str = \"Inventory\"\n\n    @staticmethod\n    def serialise(\n        val: dict[str, Decimal] | None,\n    ) -&gt; SimpleCounterInventory | None:\n        \"\"\"Serialise an inventory.\n\n        Rustledger returns inventory as a dict of currency -&gt; Decimal.\n        \"\"\"\n        if val is None:\n            return None\n        # Rustledger already converts to {currency: Decimal} format\n        if isinstance(val, dict):\n            from rustfava.core.inventory import SimpleCounterInventory\n            return SimpleCounterInventory(val)\n        # Fallback for beancount Inventory type (for backwards compat)\n        return UNITS.apply_inventory(val) if val is not None else None\n</code></pre>"},{"location":"api/#rustfava.core.query.InventoryColumn.serialise","title":"<code>serialise(val)</code>  <code>staticmethod</code>","text":"<p>Serialise an inventory.</p> <p>Rustledger returns inventory as a dict of currency -&gt; Decimal.</p> Source code in <code>src/rustfava/core/query.py</code> <pre><code>@staticmethod\ndef serialise(\n    val: dict[str, Decimal] | None,\n) -&gt; SimpleCounterInventory | None:\n    \"\"\"Serialise an inventory.\n\n    Rustledger returns inventory as a dict of currency -&gt; Decimal.\n    \"\"\"\n    if val is None:\n        return None\n    # Rustledger already converts to {currency: Decimal} format\n    if isinstance(val, dict):\n        from rustfava.core.inventory import SimpleCounterInventory\n        return SimpleCounterInventory(val)\n    # Fallback for beancount Inventory type (for backwards compat)\n    return UNITS.apply_inventory(val) if val is not None else None\n</code></pre>"},{"location":"api/#rustfava.core.query_shell","title":"<code>query_shell</code>","text":"<p>For running BQL queries in Fava.</p>"},{"location":"api/#rustfava.core.query_shell.FavaShellError","title":"<code>FavaShellError</code>","text":"<p>               Bases: <code>RustfavaAPIError</code></p> <p>An error in the Fava BQL shell, will be turned into a string.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class FavaShellError(RustfavaAPIError):\n    \"\"\"An error in the Fava BQL shell, will be turned into a string.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryNotFoundError","title":"<code>QueryNotFoundError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query '{name}' not found.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryNotFoundError(FavaShellError):\n    \"\"\"Query '{name}' not found.\"\"\"\n\n    def __init__(self, name: str) -&gt; None:\n        super().__init__(f\"Query '{name}' not found.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.TooManyRunArgsError","title":"<code>TooManyRunArgsError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Too many args to run: '{args}'.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class TooManyRunArgsError(FavaShellError):\n    \"\"\"Too many args to run: '{args}'.\"\"\"\n\n    def __init__(self, args: str) -&gt; None:\n        super().__init__(f\"Too many args to run: '{args}'.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryCompilationError","title":"<code>QueryCompilationError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query compilation error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryCompilationError(FavaShellError):\n    \"\"\"Query compilation error.\"\"\"\n\n    def __init__(self, err: CompilationError) -&gt; None:\n        super().__init__(f\"Query compilation error: {err!s}.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryParseError","title":"<code>QueryParseError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Query parse error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryParseError(FavaShellError):\n    \"\"\"Query parse error.\"\"\"\n\n    def __init__(self, err: ParseError) -&gt; None:\n        super().__init__(f\"Query parse error: {err!s}.\")\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.NonExportableQueryError","title":"<code>NonExportableQueryError</code>","text":"<p>               Bases: <code>FavaShellError</code></p> <p>Only queries that return a table can be printed to a file.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class NonExportableQueryError(FavaShellError):\n    \"\"\"Only queries that return a table can be printed to a file.\"\"\"\n\n    def __init__(self) -&gt; None:\n        super().__init__(\n            \"Only queries that return a table can be printed to a file.\"\n        )\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.FavaQueryRunner","title":"<code>FavaQueryRunner</code>","text":"<p>Runs BQL queries using rustledger.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class FavaQueryRunner:\n    \"\"\"Runs BQL queries using rustledger.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        self.ledger = ledger\n\n    def run(\n        self, entries: Sequence[Directive], query: str\n    ) -&gt; RLCursor | str:\n        \"\"\"Run a query, returning cursor or text result.\"\"\"\n        # Get the source from the ledger for queries\n        source = getattr(self.ledger, \"_source\", None)\n\n        # Create connection\n        conn = connect(\n            \"rustledger:\",\n            entries=entries,\n            errors=self.ledger.errors,\n            options=self.ledger.options,\n        )\n\n        if source:\n            conn.set_source(source)\n\n        # Parse the query to handle special commands\n        query = query.strip()\n        query_lower = query.lower()\n\n        # Handle noop commands (return fixed text)\n        noop_doc = \"Doesn't do anything in rustfava's query shell.\"\n        if query_lower in (\".exit\", \".quit\", \"exit\", \"quit\"):\n            return noop_doc\n\n        # Handle .run or run command\n        if query_lower.startswith((\".run\", \"run\")):\n            # Check if it's just \"run\" or \".run\" (list queries) or \"run name\"\n            if query_lower in (\"run\", \".run\") or query_lower.startswith((\"run \", \".run \")):\n                return self._handle_run(query, conn)\n\n        # Handle help commands - return text\n        if query_lower.startswith((\".help\", \"help\")):\n            # \".help exit\" or \".help &lt;command&gt;\" returns noop doc\n            if \" \" in query_lower:\n                return noop_doc\n            return self._help_text()\n\n        # Handle .explain - return placeholder\n        if query_lower.startswith((\".explain\", \"explain\")):\n            return f\"EXPLAIN: {query}\"\n\n        # Handle SELECT/BALANCES/JOURNAL queries\n        try:\n            return conn.execute(query)\n        except ParseError as exc:\n            raise QueryParseError(exc) from exc\n        except CompilationError as exc:\n            raise QueryCompilationError(exc) from exc\n\n    def _handle_run(self, query: str, conn: RLConnection) -&gt; RLCursor | str:\n        \"\"\"Handle .run command to execute stored queries.\"\"\"\n        queries = self.ledger.all_entries_by_type.Query\n\n        # Parse the run command\n        parts = shlex.split(query)\n        if len(parts) == 1:\n            # Just \"run\" - list available queries\n            return \"\\n\".join(q.name for q in queries)\n\n        if len(parts) &gt; 2:\n            raise TooManyRunArgsError(query)\n\n        name = parts[1].rstrip(\";\")\n        query_obj = next((q for q in queries if q.name == name), None)\n        if query_obj is None:\n            raise QueryNotFoundError(name)\n\n        try:\n            return conn.execute(query_obj.query_string)\n        except ParseError as exc:\n            raise QueryParseError(exc) from exc\n        except CompilationError as exc:\n            raise QueryCompilationError(exc) from exc\n\n    def _help_text(self) -&gt; str:\n        \"\"\"Return help text for the query shell.\"\"\"\n        return \"\"\"Fava Query Shell\n\nCommands:\n  SELECT ...     Run a BQL SELECT query\n  run &lt;name&gt;     Run a stored query by name\n  run            List all stored queries\n  help           Show this help message\n\nExample queries:\n  SELECT account, sum(position) GROUP BY account\n  SELECT date, narration, position WHERE account ~ \"Expenses\"\n\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.FavaQueryRunner.run","title":"<code>run(entries, query)</code>","text":"<p>Run a query, returning cursor or text result.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def run(\n    self, entries: Sequence[Directive], query: str\n) -&gt; RLCursor | str:\n    \"\"\"Run a query, returning cursor or text result.\"\"\"\n    # Get the source from the ledger for queries\n    source = getattr(self.ledger, \"_source\", None)\n\n    # Create connection\n    conn = connect(\n        \"rustledger:\",\n        entries=entries,\n        errors=self.ledger.errors,\n        options=self.ledger.options,\n    )\n\n    if source:\n        conn.set_source(source)\n\n    # Parse the query to handle special commands\n    query = query.strip()\n    query_lower = query.lower()\n\n    # Handle noop commands (return fixed text)\n    noop_doc = \"Doesn't do anything in rustfava's query shell.\"\n    if query_lower in (\".exit\", \".quit\", \"exit\", \"quit\"):\n        return noop_doc\n\n    # Handle .run or run command\n    if query_lower.startswith((\".run\", \"run\")):\n        # Check if it's just \"run\" or \".run\" (list queries) or \"run name\"\n        if query_lower in (\"run\", \".run\") or query_lower.startswith((\"run \", \".run \")):\n            return self._handle_run(query, conn)\n\n    # Handle help commands - return text\n    if query_lower.startswith((\".help\", \"help\")):\n        # \".help exit\" or \".help &lt;command&gt;\" returns noop doc\n        if \" \" in query_lower:\n            return noop_doc\n        return self._help_text()\n\n    # Handle .explain - return placeholder\n    if query_lower.startswith((\".explain\", \"explain\")):\n        return f\"EXPLAIN: {query}\"\n\n    # Handle SELECT/BALANCES/JOURNAL queries\n    try:\n        return conn.execute(query)\n    except ParseError as exc:\n        raise QueryParseError(exc) from exc\n    except CompilationError as exc:\n        raise QueryCompilationError(exc) from exc\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell","title":"<code>QueryShell</code>","text":"<p>               Bases: <code>FavaModule</code></p> <p>A Fava module to run BQL queries.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>class QueryShell(FavaModule):\n    \"\"\"A Fava module to run BQL queries.\"\"\"\n\n    def __init__(self, ledger: RustfavaLedger) -&gt; None:\n        super().__init__(ledger)\n        self.runner = FavaQueryRunner(ledger)\n\n    def execute_query_serialised(\n        self, entries: Sequence[Directive], query: str\n    ) -&gt; QueryResultTable | QueryResultText:\n        \"\"\"Run a query and returns its serialised result.\n\n        Arguments:\n            entries: The entries to run the query on.\n            query: A query string.\n\n        Returns:\n            Either a table or a text result (depending on the query).\n\n        Raises:\n            RustfavaAPIError: If the query response is an error.\n        \"\"\"\n        res = self.runner.run(entries, query)\n        return (\n            QueryResultText(res) if isinstance(res, str) else _serialise(res)\n        )\n\n    def query_to_file(\n        self,\n        entries: Sequence[Directive],\n        query_string: str,\n        result_format: str,\n    ) -&gt; tuple[str, io.BytesIO]:\n        \"\"\"Get query result as file.\n\n        Arguments:\n            entries: The entries to run the query on.\n            query_string: A string, the query to run.\n            result_format: The file format to save to.\n\n        Returns:\n            A tuple (name, data), where name is either 'query_result' or the\n            name of a custom query if the query string is 'run name_of_query'.\n            ``data`` contains the file contents.\n\n        Raises:\n            RustfavaAPIError: If the result format is not supported or the\n            query failed.\n        \"\"\"\n        name = \"query_result\"\n\n        if query_string.lower().startswith((\".run\", \"run \")):\n            parts = shlex.split(query_string)\n            if len(parts) &gt; 2:\n                raise TooManyRunArgsError(query_string)\n            if len(parts) == 2:\n                name = parts[1].rstrip(\";\")\n                queries = self.ledger.all_entries_by_type.Query\n                query_obj = next((q for q in queries if q.name == name), None)\n                if query_obj is None:\n                    raise QueryNotFoundError(name)\n                query_string = query_obj.query_string\n\n        res = self.runner.run(entries, query_string)\n        if isinstance(res, str):\n            raise NonExportableQueryError\n\n        rrows = res.fetchall()\n        rtypes = res.description\n\n        # Convert rows to exportable format\n        rows = _numberify_rows(rrows, rtypes)\n\n        if result_format == \"csv\":\n            data = to_csv(list(rtypes), rows)\n        else:\n            if not HAVE_EXCEL:  # pragma: no cover\n                msg = \"Result format not supported.\"\n                raise RustfavaAPIError(msg)\n            data = to_excel(list(rtypes), rows, result_format, query_string)\n        return name, data\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell.execute_query_serialised","title":"<code>execute_query_serialised(entries, query)</code>","text":"<p>Run a query and returns its serialised result.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>The entries to run the query on.</p> required <code>query</code> <code>str</code> <p>A query string.</p> required <p>Returns:</p> Type Description <code>QueryResultTable | QueryResultText</code> <p>Either a table or a text result (depending on the query).</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the query response is an error.</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def execute_query_serialised(\n    self, entries: Sequence[Directive], query: str\n) -&gt; QueryResultTable | QueryResultText:\n    \"\"\"Run a query and returns its serialised result.\n\n    Arguments:\n        entries: The entries to run the query on.\n        query: A query string.\n\n    Returns:\n        Either a table or a text result (depending on the query).\n\n    Raises:\n        RustfavaAPIError: If the query response is an error.\n    \"\"\"\n    res = self.runner.run(entries, query)\n    return (\n        QueryResultText(res) if isinstance(res, str) else _serialise(res)\n    )\n</code></pre>"},{"location":"api/#rustfava.core.query_shell.QueryShell.query_to_file","title":"<code>query_to_file(entries, query_string, result_format)</code>","text":"<p>Get query result as file.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Sequence[Directive]</code> <p>The entries to run the query on.</p> required <code>query_string</code> <code>str</code> <p>A string, the query to run.</p> required <code>result_format</code> <code>str</code> <p>The file format to save to.</p> required <p>Returns:</p> Type Description <code>str</code> <p>A tuple (name, data), where name is either 'query_result' or the</p> <code>BytesIO</code> <p>name of a custom query if the query string is 'run name_of_query'.</p> <code>tuple[str, BytesIO]</code> <p><code>data</code> contains the file contents.</p> <p>Raises:</p> Type Description <code>RustfavaAPIError</code> <p>If the result format is not supported or the</p> Source code in <code>src/rustfava/core/query_shell.py</code> <pre><code>def query_to_file(\n    self,\n    entries: Sequence[Directive],\n    query_string: str,\n    result_format: str,\n) -&gt; tuple[str, io.BytesIO]:\n    \"\"\"Get query result as file.\n\n    Arguments:\n        entries: The entries to run the query on.\n        query_string: A string, the query to run.\n        result_format: The file format to save to.\n\n    Returns:\n        A tuple (name, data), where name is either 'query_result' or the\n        name of a custom query if the query string is 'run name_of_query'.\n        ``data`` contains the file contents.\n\n    Raises:\n        RustfavaAPIError: If the result format is not supported or the\n        query failed.\n    \"\"\"\n    name = \"query_result\"\n\n    if query_string.lower().startswith((\".run\", \"run \")):\n        parts = shlex.split(query_string)\n        if len(parts) &gt; 2:\n            raise TooManyRunArgsError(query_string)\n        if len(parts) == 2:\n            name = parts[1].rstrip(\";\")\n            queries = self.ledger.all_entries_by_type.Query\n            query_obj = next((q for q in queries if q.name == name), None)\n            if query_obj is None:\n                raise QueryNotFoundError(name)\n            query_string = query_obj.query_string\n\n    res = self.runner.run(entries, query_string)\n    if isinstance(res, str):\n        raise NonExportableQueryError\n\n    rrows = res.fetchall()\n    rtypes = res.description\n\n    # Convert rows to exportable format\n    rows = _numberify_rows(rrows, rtypes)\n\n    if result_format == \"csv\":\n        data = to_csv(list(rtypes), rows)\n    else:\n        if not HAVE_EXCEL:  # pragma: no cover\n            msg = \"Result format not supported.\"\n            raise RustfavaAPIError(msg)\n        data = to_excel(list(rtypes), rows, result_format, query_string)\n    return name, data\n</code></pre>"},{"location":"api/#rustfava.core.tree","title":"<code>tree</code>","text":"<p>Account balance trees.</p>"},{"location":"api/#rustfava.core.tree.SerialisedTreeNode","title":"<code>SerialisedTreeNode</code>  <code>dataclass</code>","text":"<p>A serialised TreeNode.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>@dataclass(frozen=True)\nclass SerialisedTreeNode:\n    \"\"\"A serialised TreeNode.\"\"\"\n\n    account: str\n    balance: SimpleCounterInventory\n    balance_children: SimpleCounterInventory\n    children: Sequence[SerialisedTreeNode]\n    has_txns: bool\n    cost: SimpleCounterInventory | None = None\n    cost_children: SimpleCounterInventory | None = None\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode","title":"<code>TreeNode</code>","text":"<p>A node in the account tree.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>class TreeNode:\n    \"\"\"A node in the account tree.\"\"\"\n\n    __slots__ = (\"balance\", \"balance_children\", \"children\", \"has_txns\", \"name\")\n\n    def __init__(self, name: str) -&gt; None:\n        #: Account name.\n        self.name: str = name\n        #: A list of :class:`.TreeNode`, its children.\n        self.children: list[TreeNode] = []\n        #: The cumulative account balance.\n        self.balance_children = CounterInventory()\n        #: The account balance.\n        self.balance = CounterInventory()\n        #: Whether the account has any transactions.\n        self.has_txns = False\n\n    def serialise(\n        self,\n        conversion: Conversion,\n        prices: RustfavaPriceMap,\n        end: datetime.date | None,\n        *,\n        with_cost: bool = False,\n    ) -&gt; SerialisedTreeNode:\n        \"\"\"Serialise the account.\n\n        Args:\n            conversion: The conversion to use.\n            prices: The price map to use.\n            end: A date to use for cost conversions.\n            with_cost: Additionally convert to cost.\n        \"\"\"\n        children = [\n            child.serialise(conversion, prices, end, with_cost=with_cost)\n            for child in sorted(self.children, key=attrgetter(\"name\"))\n        ]\n        return (\n            SerialisedTreeNode(\n                self.name,\n                conversion.apply(self.balance, prices, end),\n                conversion.apply(self.balance_children, prices, end),\n                children,\n                self.has_txns,\n                AT_COST.apply(self.balance),\n                AT_COST.apply(self.balance_children),\n            )\n            if with_cost\n            else SerialisedTreeNode(\n                self.name,\n                conversion.apply(self.balance, prices, end),\n                conversion.apply(self.balance_children, prices, end),\n                children,\n                self.has_txns,\n            )\n        )\n\n    def serialise_with_context(self) -&gt; SerialisedTreeNode:\n        \"\"\"Serialise, getting all parameters from Flask context.\"\"\"\n        return self.serialise(\n            g.conv,\n            g.ledger.prices,\n            g.filtered.end_date,\n            with_cost=g.conv == AT_VALUE,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode.serialise","title":"<code>serialise(conversion, prices, end, *, with_cost=False)</code>","text":"<p>Serialise the account.</p> <p>Parameters:</p> Name Type Description Default <code>conversion</code> <code>Conversion</code> <p>The conversion to use.</p> required <code>prices</code> <code>RustfavaPriceMap</code> <p>The price map to use.</p> required <code>end</code> <code>date | None</code> <p>A date to use for cost conversions.</p> required <code>with_cost</code> <code>bool</code> <p>Additionally convert to cost.</p> <code>False</code> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def serialise(\n    self,\n    conversion: Conversion,\n    prices: RustfavaPriceMap,\n    end: datetime.date | None,\n    *,\n    with_cost: bool = False,\n) -&gt; SerialisedTreeNode:\n    \"\"\"Serialise the account.\n\n    Args:\n        conversion: The conversion to use.\n        prices: The price map to use.\n        end: A date to use for cost conversions.\n        with_cost: Additionally convert to cost.\n    \"\"\"\n    children = [\n        child.serialise(conversion, prices, end, with_cost=with_cost)\n        for child in sorted(self.children, key=attrgetter(\"name\"))\n    ]\n    return (\n        SerialisedTreeNode(\n            self.name,\n            conversion.apply(self.balance, prices, end),\n            conversion.apply(self.balance_children, prices, end),\n            children,\n            self.has_txns,\n            AT_COST.apply(self.balance),\n            AT_COST.apply(self.balance_children),\n        )\n        if with_cost\n        else SerialisedTreeNode(\n            self.name,\n            conversion.apply(self.balance, prices, end),\n            conversion.apply(self.balance_children, prices, end),\n            children,\n            self.has_txns,\n        )\n    )\n</code></pre>"},{"location":"api/#rustfava.core.tree.TreeNode.serialise_with_context","title":"<code>serialise_with_context()</code>","text":"<p>Serialise, getting all parameters from Flask context.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def serialise_with_context(self) -&gt; SerialisedTreeNode:\n    \"\"\"Serialise, getting all parameters from Flask context.\"\"\"\n    return self.serialise(\n        g.conv,\n        g.ledger.prices,\n        g.filtered.end_date,\n        with_cost=g.conv == AT_VALUE,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree","title":"<code>Tree</code>","text":"<p>               Bases: <code>dict[str, TreeNode]</code></p> <p>Account tree.</p> <p>Parameters:</p> Name Type Description Default <code>entries</code> <code>Iterable[Directive | Directive] | None</code> <p>A list of entries to compute balances from.</p> <code>None</code> <code>create_accounts</code> <code>list[str] | None</code> <p>A list of accounts that the tree should contain.</p> <code>None</code> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>class Tree(dict[str, TreeNode]):\n    \"\"\"Account tree.\n\n    Args:\n        entries: A list of entries to compute balances from.\n        create_accounts: A list of accounts that the tree should contain.\n    \"\"\"\n\n    def __init__(\n        self,\n        entries: Iterable[Directive | data.Directive] | None = None,\n        create_accounts: list[str] | None = None,\n    ) -&gt; None:\n        super().__init__(self)\n        self.get(\"\", insert=True)\n        if create_accounts:\n            for account in create_accounts:\n                self.get(account, insert=True)\n        if entries:\n            account_balances: dict[str, CounterInventory]\n            account_balances = defaultdict(CounterInventory)\n            for entry in entries:\n                if isinstance(entry, Open):\n                    self.get(entry.account, insert=True)\n                for posting in getattr(entry, \"postings\", []):\n                    account_balances[posting.account].add_position(posting)\n\n            for name, balance in sorted(account_balances.items()):\n                self.insert(name, balance)\n\n    @property\n    def accounts(self) -&gt; list[str]:\n        \"\"\"The accounts in this tree.\"\"\"\n        return sorted(self.keys())\n\n    def ancestors(self, name: str) -&gt; Iterable[TreeNode]:\n        \"\"\"Ancestors of an account.\n\n        Args:\n            name: An account name.\n\n        Yields:\n            The ancestors of the given account from the bottom up.\n        \"\"\"\n        while name:\n            name = account_parent(name) or \"\"\n            yield self.get(name)\n\n    def insert(self, name: str, balance: CounterInventory) -&gt; None:\n        \"\"\"Insert account with a balance.\n\n        Insert account and update its balance and the balances of its\n        ancestors.\n\n        Args:\n            name: An account name.\n            balance: The balance of the account.\n        \"\"\"\n        node = self.get(name, insert=True)\n        node.balance.add_inventory(balance)\n        node.balance_children.add_inventory(balance)\n        node.has_txns = True\n        for parent_node in self.ancestors(name):\n            parent_node.balance_children.add_inventory(balance)\n\n    def get(  # type: ignore[override]\n        self,\n        name: str,\n        *,\n        insert: bool = False,\n    ) -&gt; TreeNode:\n        \"\"\"Get an account.\n\n        Args:\n            name: An account name.\n            insert: If True, insert the name into the tree if it does not\n                exist.\n\n        Returns:\n            TreeNode: The account of that name or an empty account if the\n            account is not in the tree.\n        \"\"\"\n        try:\n            return self[name]\n        except KeyError:\n            node = TreeNode(name)\n            if insert:\n                if name:\n                    parent = self.get(account_parent(name) or \"\", insert=True)\n                    parent.children.append(node)\n                self[name] = node\n            return node\n\n    def net_profit(\n        self,\n        options: BeancountOptions,\n        account_name: str,\n    ) -&gt; TreeNode:\n        \"\"\"Calculate the net profit.\n\n        Args:\n            options: The Beancount options.\n            account_name: The name to use for the account containing the net\n                profit.\n        \"\"\"\n        income = self.get(options[\"name_income\"])\n        expenses = self.get(options[\"name_expenses\"])\n\n        net_profit = Tree()\n        net_profit.insert(\n            account_name,\n            income.balance_children + expenses.balance_children,\n        )\n\n        return net_profit.get(account_name)\n\n    def cap(self, options: BeancountOptions, unrealized_account: str) -&gt; None:\n        \"\"\"Transfer Income and Expenses, add conversions and unrealized gains.\n\n        Args:\n            options: The Beancount options.\n            unrealized_account: The name of the account to post unrealized\n                gains to (as a subaccount of Equity).\n        \"\"\"\n        equity = options[\"name_equity\"]\n        conversions = CounterInventory(\n            {\n                (currency, None): -number\n                for currency, number in AT_COST.apply(\n                    self.get(\"\").balance_children\n                ).items()\n            },\n        )\n\n        # Add conversions\n        self.insert(\n            equity + \":\" + options[\"account_current_conversions\"],\n            conversions,\n        )\n\n        # Insert unrealized gains.\n        self.insert(\n            equity + \":\" + unrealized_account,\n            -self.get(\"\").balance_children,\n        )\n\n        # Transfer Income and Expenses\n        self.insert(\n            equity + \":\" + options[\"account_current_earnings\"],\n            self.get(options[\"name_income\"]).balance_children,\n        )\n        self.insert(\n            equity + \":\" + options[\"account_current_earnings\"],\n            self.get(options[\"name_expenses\"]).balance_children,\n        )\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.accounts","title":"<code>accounts</code>  <code>property</code>","text":"<p>The accounts in this tree.</p>"},{"location":"api/#rustfava.core.tree.Tree.ancestors","title":"<code>ancestors(name)</code>","text":"<p>Ancestors of an account.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <p>Yields:</p> Type Description <code>Iterable[TreeNode]</code> <p>The ancestors of the given account from the bottom up.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def ancestors(self, name: str) -&gt; Iterable[TreeNode]:\n    \"\"\"Ancestors of an account.\n\n    Args:\n        name: An account name.\n\n    Yields:\n        The ancestors of the given account from the bottom up.\n    \"\"\"\n    while name:\n        name = account_parent(name) or \"\"\n        yield self.get(name)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.insert","title":"<code>insert(name, balance)</code>","text":"<p>Insert account with a balance.</p> <p>Insert account and update its balance and the balances of its ancestors.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <code>balance</code> <code>CounterInventory</code> <p>The balance of the account.</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def insert(self, name: str, balance: CounterInventory) -&gt; None:\n    \"\"\"Insert account with a balance.\n\n    Insert account and update its balance and the balances of its\n    ancestors.\n\n    Args:\n        name: An account name.\n        balance: The balance of the account.\n    \"\"\"\n    node = self.get(name, insert=True)\n    node.balance.add_inventory(balance)\n    node.balance_children.add_inventory(balance)\n    node.has_txns = True\n    for parent_node in self.ancestors(name):\n        parent_node.balance_children.add_inventory(balance)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.get","title":"<code>get(name, *, insert=False)</code>","text":"<p>Get an account.</p> <p>Parameters:</p> Name Type Description Default <code>name</code> <code>str</code> <p>An account name.</p> required <code>insert</code> <code>bool</code> <p>If True, insert the name into the tree if it does not exist.</p> <code>False</code> <p>Returns:</p> Name Type Description <code>TreeNode</code> <code>TreeNode</code> <p>The account of that name or an empty account if the</p> <code>TreeNode</code> <p>account is not in the tree.</p> Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def get(  # type: ignore[override]\n    self,\n    name: str,\n    *,\n    insert: bool = False,\n) -&gt; TreeNode:\n    \"\"\"Get an account.\n\n    Args:\n        name: An account name.\n        insert: If True, insert the name into the tree if it does not\n            exist.\n\n    Returns:\n        TreeNode: The account of that name or an empty account if the\n        account is not in the tree.\n    \"\"\"\n    try:\n        return self[name]\n    except KeyError:\n        node = TreeNode(name)\n        if insert:\n            if name:\n                parent = self.get(account_parent(name) or \"\", insert=True)\n                parent.children.append(node)\n            self[name] = node\n        return node\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.net_profit","title":"<code>net_profit(options, account_name)</code>","text":"<p>Calculate the net profit.</p> <p>Parameters:</p> Name Type Description Default <code>options</code> <code>BeancountOptions</code> <p>The Beancount options.</p> required <code>account_name</code> <code>str</code> <p>The name to use for the account containing the net profit.</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def net_profit(\n    self,\n    options: BeancountOptions,\n    account_name: str,\n) -&gt; TreeNode:\n    \"\"\"Calculate the net profit.\n\n    Args:\n        options: The Beancount options.\n        account_name: The name to use for the account containing the net\n            profit.\n    \"\"\"\n    income = self.get(options[\"name_income\"])\n    expenses = self.get(options[\"name_expenses\"])\n\n    net_profit = Tree()\n    net_profit.insert(\n        account_name,\n        income.balance_children + expenses.balance_children,\n    )\n\n    return net_profit.get(account_name)\n</code></pre>"},{"location":"api/#rustfava.core.tree.Tree.cap","title":"<code>cap(options, unrealized_account)</code>","text":"<p>Transfer Income and Expenses, add conversions and unrealized gains.</p> <p>Parameters:</p> Name Type Description Default <code>options</code> <code>BeancountOptions</code> <p>The Beancount options.</p> required <code>unrealized_account</code> <code>str</code> <p>The name of the account to post unrealized gains to (as a subaccount of Equity).</p> required Source code in <code>src/rustfava/core/tree.py</code> <pre><code>def cap(self, options: BeancountOptions, unrealized_account: str) -&gt; None:\n    \"\"\"Transfer Income and Expenses, add conversions and unrealized gains.\n\n    Args:\n        options: The Beancount options.\n        unrealized_account: The name of the account to post unrealized\n            gains to (as a subaccount of Equity).\n    \"\"\"\n    equity = options[\"name_equity\"]\n    conversions = CounterInventory(\n        {\n            (currency, None): -number\n            for currency, number in AT_COST.apply(\n                self.get(\"\").balance_children\n            ).items()\n        },\n    )\n\n    # Add conversions\n    self.insert(\n        equity + \":\" + options[\"account_current_conversions\"],\n        conversions,\n    )\n\n    # Insert unrealized gains.\n    self.insert(\n        equity + \":\" + unrealized_account,\n        -self.get(\"\").balance_children,\n    )\n\n    # Transfer Income and Expenses\n    self.insert(\n        equity + \":\" + options[\"account_current_earnings\"],\n        self.get(options[\"name_income\"]).balance_children,\n    )\n    self.insert(\n        equity + \":\" + options[\"account_current_earnings\"],\n        self.get(options[\"name_expenses\"]).balance_children,\n    )\n</code></pre>"},{"location":"api/#rustfava.core.watcher","title":"<code>watcher</code>","text":"<p>A simple file and folder watcher.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase","title":"<code>WatcherBase</code>","text":"<p>               Bases: <code>ABC</code></p> <p>ABC for rustfava ledger file watchers.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class WatcherBase(abc.ABC):\n    \"\"\"ABC for rustfava ledger file watchers.\"\"\"\n\n    last_checked: int\n    \"\"\"Timestamp of the latest change noticed by the file watcher.\"\"\"\n\n    last_notified: int\n    \"\"\"Timestamp of the latest change that the watcher was notified of.\"\"\"\n\n    @abc.abstractmethod\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\n\n        Args:\n            files: A list of file paths.\n            folders: A list of paths to folders.\n        \"\"\"\n\n    def check(self) -&gt; bool:\n        \"\"\"Check for changes.\n\n        Returns:\n            `True` if there was a file change in one of the files or folders,\n            `False` otherwise.\n        \"\"\"\n        latest_mtime = max(self._get_latest_mtime(), self.last_notified)\n        has_higher_mtime = latest_mtime &gt; self.last_checked\n        if has_higher_mtime:\n            self.last_checked = latest_mtime\n        return has_higher_mtime\n\n    def notify(self, path: Path) -&gt; None:\n        \"\"\"Notify the watcher of a change to a path.\"\"\"\n        try:\n            change_mtime = Path(path).stat().st_mtime_ns\n        except FileNotFoundError:\n            change_mtime = max(self.last_notified, self.last_checked) + 1\n        self.last_notified = max(self.last_notified, change_mtime)\n\n    @abc.abstractmethod\n    def _get_latest_mtime(self) -&gt; int:\n        \"\"\"Get the latest change mtime.\"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.last_checked","title":"<code>last_checked</code>  <code>instance-attribute</code>","text":"<p>Timestamp of the latest change noticed by the file watcher.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase.last_notified","title":"<code>last_notified</code>  <code>instance-attribute</code>","text":"<p>Timestamp of the latest change that the watcher was notified of.</p>"},{"location":"api/#rustfava.core.watcher.WatcherBase.update","title":"<code>update(files, folders)</code>  <code>abstractmethod</code>","text":"<p>Update the folders/files to watch.</p> <p>Parameters:</p> Name Type Description Default <code>files</code> <code>Iterable[Path]</code> <p>A list of file paths.</p> required <code>folders</code> <code>Iterable[Path]</code> <p>A list of paths to folders.</p> required Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>@abc.abstractmethod\ndef update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\n\n    Args:\n        files: A list of file paths.\n        folders: A list of paths to folders.\n    \"\"\"\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.check","title":"<code>check()</code>","text":"<p>Check for changes.</p> <p>Returns:</p> Type Description <code>bool</code> <p><code>True</code> if there was a file change in one of the files or folders,</p> <code>bool</code> <p><code>False</code> otherwise.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def check(self) -&gt; bool:\n    \"\"\"Check for changes.\n\n    Returns:\n        `True` if there was a file change in one of the files or folders,\n        `False` otherwise.\n    \"\"\"\n    latest_mtime = max(self._get_latest_mtime(), self.last_notified)\n    has_higher_mtime = latest_mtime &gt; self.last_checked\n    if has_higher_mtime:\n        self.last_checked = latest_mtime\n    return has_higher_mtime\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatcherBase.notify","title":"<code>notify(path)</code>","text":"<p>Notify the watcher of a change to a path.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def notify(self, path: Path) -&gt; None:\n    \"\"\"Notify the watcher of a change to a path.\"\"\"\n    try:\n        change_mtime = Path(path).stat().st_mtime_ns\n    except FileNotFoundError:\n        change_mtime = max(self.last_notified, self.last_checked) + 1\n    self.last_notified = max(self.last_notified, change_mtime)\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatchfilesWatcher","title":"<code>WatchfilesWatcher</code>","text":"<p>               Bases: <code>WatcherBase</code></p> <p>A file and folder watcher using the watchfiles library.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class WatchfilesWatcher(WatcherBase):\n    \"\"\"A file and folder watcher using the watchfiles library.\"\"\"\n\n    def __init__(self) -&gt; None:\n        self.last_checked = 0\n        self.last_notified = 0\n        self._paths: tuple[set[Path], set[Path]] | None = None\n        self._watchers: tuple[_WatchfilesThread, _WatchfilesThread] | None = (\n            None\n        )\n\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\"\"\"\n        files_set = {p.absolute() for p in files if p.exists()}\n        folders_set = {p.absolute() for p in folders if p.is_dir()}\n        new_paths = (files_set, folders_set)\n        if self._watchers and new_paths == self._paths:\n            self.check()\n            return\n        self._paths = new_paths\n        if self._watchers:\n            self._watchers[0].stop()\n            self._watchers[1].stop()\n        self._watchers = (\n            _FilesWatchfilesThread(files_set, self.last_checked),\n            _WatchfilesThread(folders_set, self.last_checked, recursive=True),\n        )\n        self._watchers[0].start()\n        self._watchers[1].start()\n        self.check()\n\n    def __enter__(self) -&gt; None:\n        pass\n\n    def __exit__(\n        self,\n        exc_type: type[BaseException] | None,\n        exc_value: BaseException | None,\n        traceback: types.TracebackType | None,\n    ) -&gt; None:\n        if self._watchers:\n            self._watchers[0].stop()\n            self._watchers[1].stop()\n\n    def _get_latest_mtime(self) -&gt; int:\n        return (\n            max(self._watchers[0].mtime, self._watchers[1].mtime)\n            if self._watchers\n            else 0\n        )\n</code></pre>"},{"location":"api/#rustfava.core.watcher.WatchfilesWatcher.update","title":"<code>update(files, folders)</code>","text":"<p>Update the folders/files to watch.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\"\"\"\n    files_set = {p.absolute() for p in files if p.exists()}\n    folders_set = {p.absolute() for p in folders if p.is_dir()}\n    new_paths = (files_set, folders_set)\n    if self._watchers and new_paths == self._paths:\n        self.check()\n        return\n    self._paths = new_paths\n    if self._watchers:\n        self._watchers[0].stop()\n        self._watchers[1].stop()\n    self._watchers = (\n        _FilesWatchfilesThread(files_set, self.last_checked),\n        _WatchfilesThread(folders_set, self.last_checked, recursive=True),\n    )\n    self._watchers[0].start()\n    self._watchers[1].start()\n    self.check()\n</code></pre>"},{"location":"api/#rustfava.core.watcher.Watcher","title":"<code>Watcher</code>","text":"<p>               Bases: <code>WatcherBase</code></p> <p>A simple file and folder watcher.</p> <p>For folders, only checks mtime of the folder and all subdirectories. So a file change won't be noticed, but only new/deleted files.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>class Watcher(WatcherBase):\n    \"\"\"A simple file and folder watcher.\n\n    For folders, only checks mtime of the folder and all subdirectories.\n    So a file change won't be noticed, but only new/deleted files.\n    \"\"\"\n\n    def __init__(self) -&gt; None:\n        self.last_checked = 0\n        self.last_notified = 0\n        self._files: Sequence[Path] = []\n        self._folders: Sequence[Path] = []\n\n    def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n        \"\"\"Update the folders/files to watch.\"\"\"\n        self._files = list(files)\n        self._folders = list(folders)\n        self.check()\n\n    def _mtimes(self) -&gt; Iterable[int]:\n        for path in self._files:\n            try:\n                yield path.stat().st_mtime_ns\n            except FileNotFoundError:\n                yield max(self.last_notified, self.last_checked) + 1\n        for path in self._folders:\n            for dirpath, _, _ in walk(path):\n                yield Path(dirpath).stat().st_mtime_ns\n\n    def _get_latest_mtime(self) -&gt; int:\n        return max(self._mtimes())\n</code></pre>"},{"location":"api/#rustfava.core.watcher.Watcher.update","title":"<code>update(files, folders)</code>","text":"<p>Update the folders/files to watch.</p> Source code in <code>src/rustfava/core/watcher.py</code> <pre><code>def update(self, files: Iterable[Path], folders: Iterable[Path]) -&gt; None:\n    \"\"\"Update the folders/files to watch.\"\"\"\n    self._files = list(files)\n    self._folders = list(folders)\n    self.check()\n</code></pre>"},{"location":"api/#application","title":"Application","text":""},{"location":"api/#rustfava.application","title":"<code>rustfava.application</code>","text":"<p>rustfava's main WSGI application.</p> <p>you can use <code>create_app</code> to create a rustfava WSGI app for a given list of files. To start a simple server::</p> <pre><code>from rustfava.application import create_app\n\napp = create_app(['/path/to/file.beancount'])\napp.run('localhost', 5000)\n</code></pre>"},{"location":"api/#rustfava.application.static_url","title":"<code>static_url(filename)</code>","text":"<p>Return a static url with an mtime query string for cache busting.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def static_url(filename: str) -&gt; str:\n    \"\"\"Return a static url with an mtime query string for cache busting.\"\"\"\n    file_path = Path(__file__).parent / \"static\" / filename\n    try:\n        mtime = str(int(file_path.stat().st_mtime))\n    except FileNotFoundError:\n        mtime = \"0\"\n    return url_for(\"static\", filename=filename, mtime=mtime)\n</code></pre>"},{"location":"api/#rustfava.application.url_for","title":"<code>url_for(endpoint, **values)</code>","text":"<p>Wrap flask.url_for using a cache.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def url_for(endpoint: str, **values: str) -&gt; str:\n    \"\"\"Wrap flask.url_for using a cache.\"\"\"\n    _inject_filters(endpoint, values)\n    return _cached_url_for(endpoint, **values)\n</code></pre>"},{"location":"api/#rustfava.application.translations","title":"<code>translations()</code>","text":"<p>Get translations catalog.</p> Source code in <code>src/rustfava/application.py</code> <pre><code>def translations() -&gt; dict[str, str]:\n    \"\"\"Get translations catalog.\"\"\"\n    catalog = get_translations()._catalog  # noqa: SLF001\n    return {k: v for k, v in catalog.items() if isinstance(k, str) and k}\n</code></pre>"},{"location":"api/#rustfava.application.create_app","title":"<code>create_app(files, *, load=False, incognito=False, read_only=False, poll_watcher=False)</code>","text":"<p>Create a rustfava Flask application.</p> <p>Parameters:</p> Name Type Description Default <code>files</code> <code>Iterable[Path | str]</code> <p>The list of Beancount files (paths).</p> required <code>load</code> <code>bool</code> <p>Whether to load the Beancount files directly.</p> <code>False</code> <code>incognito</code> <code>bool</code> <p>Whether to run in incognito mode.</p> <code>False</code> <code>read_only</code> <code>bool</code> <p>Whether to run in read-only mode.</p> <code>False</code> <code>poll_watcher</code> <code>bool</code> <p>Whether to use old poll watcher</p> <code>False</code> Source code in <code>src/rustfava/application.py</code> <pre><code>def create_app(\n    files: Iterable[Path | str],\n    *,\n    load: bool = False,\n    incognito: bool = False,\n    read_only: bool = False,\n    poll_watcher: bool = False,\n) -&gt; Flask:\n    \"\"\"Create a rustfava Flask application.\n\n    Arguments:\n        files: The list of Beancount files (paths).\n        load: Whether to load the Beancount files directly.\n        incognito: Whether to run in incognito mode.\n        read_only: Whether to run in read-only mode.\n        poll_watcher: Whether to use old poll watcher\n    \"\"\"\n    fava_app = Flask(\"rustfava\")\n    fava_app.register_blueprint(json_api, url_prefix=\"/&lt;bfile&gt;/api\")\n    fava_app.json = RustfavaJSONProvider(fava_app)\n    fava_app.app_ctx_globals_class = Context  # type: ignore[assignment]\n    _setup_template_config(fava_app, incognito=incognito)\n    _setup_babel(fava_app)\n    _setup_filters(fava_app, read_only=read_only)\n    _setup_routes(fava_app)\n\n    fava_app.config[\"HAVE_EXCEL\"] = HAVE_EXCEL\n    fava_app.config[\"BEANCOUNT_FILES\"] = [str(f) for f in files]\n    fava_app.config[\"INCOGNITO\"] = incognito\n    fava_app.config[\"LEDGERS\"] = _LedgerSlugLoader(\n        fava_app, load=load, poll_watcher=poll_watcher\n    )\n\n    return fava_app\n</code></pre>"},{"location":"api/#cli","title":"CLI","text":""},{"location":"api/#rustfava.cli","title":"<code>rustfava.cli</code>","text":"<p>The command-line interface for rustfava.</p>"},{"location":"api/#rustfava.cli.main","title":"<code>main(*, filenames=(), port=5000, host='localhost', prefix=None, incognito=False, read_only=False, debug=False, profile=False, profile_dir=None, poll_watcher=False)</code>","text":"<p>Start Rustfava for FILENAMES on http://:. <p>If the <code>BEANCOUNT_FILE</code> environment variable is set, Rustfava will use the files (delimited by ';' on Windows and ':' on POSIX) given there in addition to FILENAMES.</p> <p>Note you can also specify command-line options via environment variables with the <code>RUSTFAVA_</code> prefix. For example, <code>--host=0.0.0.0</code> is equivalent to setting the environment variable <code>RUSTFAVA_HOST=0.0.0.0</code>.</p> Source code in <code>src/rustfava/cli.py</code> <pre><code>@click.command(context_settings={\"auto_envvar_prefix\": \"RUSTFAVA\"})\n@click.argument(\n    \"filenames\",\n    nargs=-1,\n    type=click.Path(exists=True, dir_okay=False, resolve_path=True),\n)\n@click.option(\n    \"-p\",\n    \"--port\",\n    type=int,\n    default=5000,\n    show_default=True,\n    metavar=\"&lt;port&gt;\",\n    help=\"The port to listen on.\",\n)\n@click.option(\n    \"-H\",\n    \"--host\",\n    type=str,\n    default=\"localhost\",\n    show_default=True,\n    metavar=\"&lt;host&gt;\",\n    help=\"The host to listen on.\",\n)\n@click.option(\"--prefix\", type=str, help=\"Set an URL prefix.\")\n@click.option(\n    \"--incognito\",\n    is_flag=True,\n    help=\"Run in incognito mode and obscure all numbers.\",\n)\n@click.option(\n    \"--read-only\",\n    is_flag=True,\n    help=\"Run in read-only mode, disable any change through rustfava.\",\n)\n@click.option(\"-d\", \"--debug\", is_flag=True, help=\"Turn on debugging.\")\n@click.option(\n    \"--profile\",\n    is_flag=True,\n    help=\"Turn on profiling. Implies --debug.\",\n)\n@click.option(\n    \"--profile-dir\",\n    type=click.Path(),\n    help=\"Output directory for profiling data.\",\n)\n@click.option(\n    \"--poll-watcher\", is_flag=True, help=\"Use old polling-based watcher.\"\n)\n@click.version_option(package_name=\"rustfava\")\ndef main(  # noqa: PLR0913\n    *,\n    filenames: tuple[str, ...] = (),\n    port: int = 5000,\n    host: str = \"localhost\",\n    prefix: str | None = None,\n    incognito: bool = False,\n    read_only: bool = False,\n    debug: bool = False,\n    profile: bool = False,\n    profile_dir: str | None = None,\n    poll_watcher: bool = False,\n) -&gt; None:  # pragma: no cover\n    \"\"\"Start Rustfava for FILENAMES on http://&lt;host&gt;:&lt;port&gt;.\n\n    If the `BEANCOUNT_FILE` environment variable is set, Rustfava will use the\n    files (delimited by ';' on Windows and ':' on POSIX) given there in\n    addition to FILENAMES.\n\n    Note you can also specify command-line options via environment variables\n    with the `RUSTFAVA_` prefix. For example, `--host=0.0.0.0` is equivalent to\n    setting the environment variable `RUSTFAVA_HOST=0.0.0.0`.\n    \"\"\"\n    all_filenames = _add_env_filenames(filenames)\n\n    if not all_filenames:\n        raise NoFileSpecifiedError\n\n    from rustfava.application import create_app\n\n    app = create_app(\n        all_filenames,\n        incognito=incognito,\n        read_only=read_only,\n        poll_watcher=poll_watcher,\n    )\n\n    if prefix:\n        from werkzeug.middleware.dispatcher import DispatcherMiddleware\n\n        from rustfava.util import simple_wsgi\n\n        app.wsgi_app = DispatcherMiddleware(  # type: ignore[method-assign]\n            simple_wsgi,\n            {prefix: app.wsgi_app},\n        )\n\n    # ensure that cheroot does not use IP6 for localhost\n    host = \"127.0.0.1\" if host == \"localhost\" else host\n    # Debug mode if profiling is active\n    debug = debug or profile\n\n    click.secho(f\"Starting Fava on http://{host}:{port}\", fg=\"green\")\n    if not debug:\n        from cheroot.wsgi import Server\n\n        server = Server((host, port), app)\n        try:\n            server.start()\n        except KeyboardInterrupt:\n            click.echo(\"Keyboard interrupt received: stopping Fava\", err=True)\n            server.stop()\n        except OSError as error:\n            if \"No socket could be created\" in str(error):\n                raise AddressInUse(port) from error\n            raise click.Abort from error\n    else:\n        from werkzeug.middleware.profiler import ProfilerMiddleware\n\n        from rustfava.util import setup_debug_logging\n\n        setup_debug_logging()\n        if profile:\n            app.wsgi_app = ProfilerMiddleware(  # type: ignore[method-assign]\n                app.wsgi_app,\n                restrictions=(30,),\n                profile_dir=profile_dir or None,\n            )\n\n        app.jinja_env.auto_reload = True\n        try:\n            app.run(host, port, debug)\n        except OSError as error:\n            if error.errno == errno.EADDRINUSE:\n                raise AddressInUse(port) from error\n            raise\n</code></pre>"},{"location":"changelog/","title":"Changelog","text":""},{"location":"changelog/#rustfava-2025","title":"Rustfava (2025)","text":"<p>This is a fork of Fava that replaces the Python Beancount parser and beanquery with rustledger, a Rust-based implementation of the Beancount format compiled to WebAssembly.</p> <p>Key changes from Fava:</p> <ul> <li>No Beancount dependency: Rustfava uses rustledger for parsing, so you   don't need to install Python's beancount package. Your existing Beancount   files are fully compatible.</li> <li>Query support: BQL queries are now handled by rustledger's built-in query   engine instead of beanquery. The query syntax remains largely compatible.</li> <li>Optional beancount compatibility: If you need to use Beancount plugins or   the import system, install with <code>uv pip install rustfava[beancount-compat]</code>.</li> </ul>"},{"location":"changelog/#v130-2024-12-29","title":"v1.30 (2024-12-29)","text":"<p>Note: This entry describes the original Fava release. Rustfava is based on this version with the rustledger integration.</p> <p>Under the hood, this also upgrades Svelte (the framework used for the frontend parts) to version 5.</p>"},{"location":"changelog/#v129-2024-10-09","title":"v1.29 (2024-10-09)","text":"<p>With this release, query results are now rendered in the frontend. The templates for HTML rendering are still available but extension authors are encouraged to switch, see the statistics report for an example how this can be done. This release adds CSS styles for dark-mode. Numerical comparisons on the units, price or cost are now possible in rustfava filters. As the watchfiles based watcher might not work correctly in some setups with network file systems, you can switch to the (slower) polling based watcher as well. The <code>default-file</code> option, if set, is now considered instead of the \"main\" file when inserting an entry.</p>"},{"location":"changelog/#v128-2024-07-07","title":"v1.28 (2024-07-07)","text":"<p>This release accumulates a couple of minor fixes and improvements. Under the hood, the file change detection is now powered by watchfiles instead of polling, which is more performant.</p>"},{"location":"changelog/#v127-2024-01-06","title":"v1.27 (2024-01-06)","text":"<p>It is now possible to convert to a sequence of currencies. Posting metadata is now supported in the entry forms. The editor should now be a bit more performant as the previous parses will be reused better. For compatibility with extensions using them, the Javascript and CSS for the \"old\" account trees has been re-added.</p>"},{"location":"changelog/#v126-2023-09-04","title":"v1.26 (2023-09-04)","text":"<p>This release brings various improvements to the charts, like allowing the toggling of currencies by clicking on their names in the chart legend. The account balance trees in rustfava are now rendered in the frontend, fixing some minor bugs in the process and easing maintenance. rustfava extensions can now also provide their own endpoints.</p>"},{"location":"changelog/#v125-2023-07-17","title":"v1.25 (2023-07-17)","text":"<p>With this release, extensions can now ship Javascript code to run in the frontend. The editor in rustfava now uses a tree-sitter grammar to obtain a full parsed syntax tree, which makes editor functionality more maintainable and should improve the autocompletion. The Flask WSGI app is now created using the application factory pattern - users who use the rustfava WSGI app directly should switch from <code>rustfava.application.app</code> to the <code>create_app</code> function in <code>rustfava.application</code>. This release also drops support for Python 3.7 and contains a couple of minor fixes and changes, in particular various styling fixes.</p>"},{"location":"changelog/#v124-2023-02-21","title":"v1.24 (2023-02-21)","text":"<p>With this release, the rendering of some report like the documents report has been moved completely to the frontend, which should be slightly more perfomant and easier to maintain. This release also contains a couple of minor fixes and changes.</p>"},{"location":"changelog/#v123-2022-10-15","title":"v1.23 (2022-10-15)","text":"<p>This release accumulates a couple of minor fixes and changes.</p>"},{"location":"changelog/#v122-2022-07-03","title":"v1.22 (2022-07-03)","text":"<p>This release brings stacked bar charts, which are a great way to visualise income broken down per account per month for example. The inferred display precision for currencies is now also used in the frontend and can be overwritten with commodity metadata.</p> <p>The <code>journal-show</code>, <code>journal-show-document</code>, and <code>journal-show-transaction</code> rustfava-options have been removed. The types of entries that to show in the journal are now automatically stored in the browser of the user (in localStorage).</p> <p>As usual, this release also includes a couple of bug fixes and minor improvements. To avoid some race conditions and improve perfomance, the per-file Ledger class is not filtered anymore in-place but rather the filtered data is generated per request - some extensions might have to adjust for this and use <code>g.filtered</code> instead of <code>ledger</code> for some attributes.</p>"},{"location":"changelog/#v121-2022-02-06","title":"v1.21 (2022-02-06)","text":"<p>This release of rustfava drops support for Python 3.6. It mainly consists of various small improvements and fixes.</p>"},{"location":"changelog/#v1201-2021-09-22","title":"v1.20.1 (2021-09-22)","text":"<p>Bugfix release to fix loading of translations for the browser-rendered frontend parts.</p>"},{"location":"changelog/#v120-2021-09-19","title":"v1.20 (2021-09-19)","text":"<p>In this release, the document page now shows counts in the account tree and allows collapsing of accounts in the tree. Parts of the charts in the future are now desaturated. This release contains a couple of bug fixes as usual.</p>"},{"location":"changelog/#v119-2021-05-18","title":"v1.19 (2021-05-18)","text":"<p>The <code>conversion</code> and <code>interval</code> options have been removed. Their functionality can be achieved with the new <code>default-page</code> option. The editor components have been completely reworked, include autocompletion in more places and are now based on version 6 of CodeMirror. An option <code>invert-income-liabilities-equity</code> has been added to invert the numbers of those accounts on the income statement and the balance sheet. This release also adds a Bulgarian translation and features various smaller improvements and fixes as usual.</p>"},{"location":"changelog/#v118-2021-01-16","title":"v1.18 (2021-01-16)","text":"<p>This release contains couple of small improvements and various bug fixes.</p>"},{"location":"changelog/#v117-2020-11-15","title":"v1.17 (2020-11-15)","text":"<p>This release adds a document preview to the import page, as well as support for Python 3.9. It also fixes a couple of bugs.</p>"},{"location":"changelog/#v116-2020-10-18","title":"v1.16 (2020-10-18)","text":"<p>This release brings area charts as an alternative option to view the various line charts in rustfava and a Catalan translation for rustfava. There is also now an option to set the indentation of inserted Beancount entries. As usual this release also includes various minor fixes and improvements.</p>"},{"location":"changelog/#v115-2020-05-30","title":"v1.15 (2020-05-30)","text":"<p>This release accumulates various minor fixes and improvements, for example the setting of filters from payees and metadata in the Journal report.</p>"},{"location":"changelog/#v114-2020-02-16","title":"v1.14 (2020-02-16)","text":"<p>This is mainly a bugfix release to fix compatibility with one of the main dependencies (werkzeug). Also, a <code>default-conversion</code> option was added, which allows setting a default conversion.</p>"},{"location":"changelog/#v113-2020-02-01","title":"v1.13 (2020-02-01)","text":"<p>Rustfava can now display charts for BQL queries - if they have exactly two columns with the first being a date or string and the second an inventory, then a line chart or treemap chart is shown on the query page.</p>"},{"location":"changelog/#v112-2019-12-03","title":"v1.12 (2019-12-03)","text":"<p>Apart from plenty of bug fixes, this release mainly contains improvements to the forms to add transactions: postings can now be dragged and the full cost syntax of Beancount should supported.</p>"},{"location":"changelog/#v111-2019-08-20","title":"v1.11 (2019-08-20)","text":"<p>The import page of rustfava has been reworked - it now supports moving files to the documents folder and the import process should be a bit more interactive. This release also contains various fixes and a new <code>collapse-pattern</code> option to collapse accounts in account trees based on regular expressions (and replaces the use of the <code>rustfava-collapse-account</code> metadata entry).</p> <p>Other changes:</p> <ul> <li>Command line flags can be specified by setting environment variables.</li> <li>A Taiwanese translation has been added.</li> </ul>"},{"location":"changelog/#v110-2019-01-31","title":"v1.10 (2019-01-31)","text":"<p>This release contains mostly smaller changes and fixes. In particular, the net worth chart will now follow the selected conversion.</p>"},{"location":"changelog/#v19-2018-10-08","title":"v1.9 (2018-10-08)","text":"<p>In this release, the click behaviour has been updated to allow filtering for payees. The entry input forms now allow inputting prices and costs. As always, bugs have been fixed.</p>"},{"location":"changelog/#v18-2018-07-25","title":"v1.8 (2018-07-25)","text":"<p>The journal design has been updated and should now have a clearer structure. Starting with this version, there will not be any more GUI releases of rustfava. The GUI broke frequently and does not seem to worth the maintenance burden.</p> <p>Other changes:</p> <ul> <li>When downloading documents, the original filename will be used.</li> <li><code>any()</code> and <code>all()</code> functions have been added to the filter syntax to allow   filtering entries by properties of their postings.</li> <li>As always, bugs have been fixed.</li> </ul>"},{"location":"changelog/#v17-2018-03-09","title":"v1.7 (2018-03-09)","text":"<p>The entry filters have been reworked in this release and should now support for more flexible filtering of the entries. See the help page on how the new syntax works. Also, when completing the payee in the transaction form, the postings of the last transaction for this payee will be auto-filled.</p> <p>Other changes:</p> <ul> <li>The rustfava-option to hide the charts has been removed. This is now tracked in   the page URL.</li> <li>As always, bugs have been fixed.</li> </ul>"},{"location":"changelog/#v16-2017-10-06","title":"v1.6 (2017-10-06)","text":"<p>This is a release with various small changes and mainly some speed improvements to the Balance Sheet and the net worth calculation. Also, if 'At Value' is selected, the current unrealized gain is shown in parentheses in the Balance Sheet.</p> <p>Other changes:</p> <ul> <li>The currently filtered entries can now be exported from the Journal page.</li> <li>The CLI now has a <code>--version</code> flag.</li> </ul>"},{"location":"changelog/#v15-2017-07-23","title":"v1.5 (2017-07-23)","text":"<p>Rustfava now has an interface to edit single entries. Clicking on the entry date in the Journal will open an overlay that shows the entry context and allows editing just the lines of that entry.</p> <p>Other changes:</p> <ul> <li>The source editor now has a menu that gives access to editor commands like   \"fold all\".</li> <li>Entries with matching tags or links can now be excluded with <code>-#tag</code>.</li> <li>The keyboard shortcuts are now displayed in-place.</li> <li>The <code>incognito</code> option has been removed and replaced with a <code>--incognito</code>   command line switch.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v14-2017-05-14","title":"v1.4 (2017-05-14)","text":"<p>Rustfava now provides an interface for Beancount's import system that allows you to import transactions from your bank for example.</p> <p>Rustfava can now show your balances at market value or convert them to a single currency if your file contains the necessary price information.</p> <p>We now also provide a compiled GUI version of rustfava for Linux and macOS. This version might still be a bit buggy so any feedback/help on it is very welcome.</p> <p>Other changes:</p> <ul> <li>The <code>insert-entry</code> option can be used to control where transactions are   inserted.</li> <li>The transaction form now accepts tags and links in the narration field.</li> <li>Budgets are now accumulated over all children where appropriate.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v13-2017-03-15","title":"v1.3 (2017-03-15)","text":"<p>The translations of rustfava are on POEditor.com, which has helped us get translations in five more languages: Chinese (simplified), Dutch, French, Portuguese, and Spanish. A big thank you to the new translators!</p> <p>The transaction form has been improved, it now supports adding metadata and the suggestions will be ranked by how often and recently they occur (using exponential decay).</p> <p>The Query page supports all commands of the <code>bean-query</code> shell and shares its history of recently used queries.</p> <p>Rustfava has gained a basic extension mechanism. Extensions allow you to run hooks at various points, e.g., after adding a transaction. They are specified using the <code>extensions</code> option and for an example, see the <code>rustfava.ext.auto_commit</code> extension.</p> <p>Other changes:</p> <ul> <li>The default sort order in journals has been reversed so that the most recent   entries come first.</li> <li>The new <code>incognito</code> option can be used to obscure all numbers.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v12-2016-12-25","title":"v1.2 (2016-12-25)","text":"<p>You can now add transactions from within rustfava. The form supports autocompletion for most fields.</p> <p>Rustfava will now show a little bubble in the sidebar for the number of events in the next week. This can be configured with the <code>upcoming-events</code> option.</p> <p>Other changes:</p> <ul> <li>The payee filter can filter by regular expression.</li> <li>The tag filter can filter for links, too.</li> <li>There's a nice spinning indicator during asynchronous page loads.</li> <li>The Journal shows little indicators for metadata.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v11-2016-11-19","title":"v1.1 (2016-11-19)","text":"<p>You can now upload documents by dropping them onto transactions, which will also add the file path as <code>statement</code> metadata to the transaction. rustfava also ships with a plugin to link these transactions with the generated documents. See the help pages for details.</p> <p>This is the first release for which we provide compiled binaries (for macOS and Linux). These do not have any dependencies and can simply be executed from the terminal.</p> <p>Other changes:</p> <ul> <li>The bar charts on account pages now also show budgets.</li> <li>The Journal can now be sorted by date, flag and narration.</li> <li>Rustfava now has a Russian translation.</li> <li>As always, several bugs have been fixed.</li> </ul>"},{"location":"changelog/#v10-2016-10-19","title":"v1.0 (2016-10-19)","text":"<p>This is a major new release that includes too many improvements and changes to list. Some highlights:</p> <ul> <li>The layout has been tweaked and we use some nicer fonts.</li> <li>Rustfava looks and works much better on smaller screens.</li> <li>Rustfava loads most pages asynchronously, so navigating rustfava is much faster and   responsive.</li> </ul> <p>rustfava's configuration is not read from a configuration file anymore but can rather be specified using custom entries in the Beancount file. Some options have also been removed or renamed, so check rustfava's help page on the available options when upgrading from v0.3.0.</p> <p>There have been many changes under the hood to improve rustfava's codebase and a lot of bugs have been squashed.</p>"},{"location":"changelog/#v030-2016-03-24","title":"v0.3.0 (2016-03-24)","text":""},{"location":"changelog/#additions","title":"Additions","text":"<ul> <li>Support for switching between multiple beancount files.</li> <li>New sunburst charts.</li> <li>Add \"Clear filter\" button when filters are active.</li> <li>Simple budgeting functionality in the Account view. See help pages on how to   use budgets.</li> <li>German translation.</li> <li>The Beancount is now being reloaded when it is saved in the Source Editor.</li> <li>New Journal filter controls.</li> <li>Tree-tables are now displayed in a hierarchical way.</li> </ul>"},{"location":"changelog/#changes","title":"Changes","text":"<ul> <li>All charts are now rendered with d3.js.</li> <li>The title of a page is now shown in the header to save screen space.</li> <li>Changed shortcut for Journal from <code>g g</code> to <code>g j</code> as the Journal was   renamed from \"General Journal\" to \"Journal\".</li> </ul>"},{"location":"changelog/#new-configuration-options","title":"New configuration options","text":"<ul> <li><code>language</code>: The language to use. Valid languages are <code>\"en\"</code> and <code>\"de\"</code>   (default: <code>\"en\"</code>).</li> <li><code>treemaps-show-negative-numbers</code> was removed.</li> </ul>"},{"location":"changelog/#fixes","title":"Fixes","text":"<ul> <li>Commodity prices are now filtered when a Time filter is enabled.</li> <li>Some improvements to the help pages.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v026-2016-03-20","title":"v0.2.6 (2016-03-20)","text":""},{"location":"changelog/#additions_1","title":"Additions","text":"<ul> <li>There are now more interval options available for charts and the account   balances report. The interval can be selected from a dropdown next to the   charts.</li> <li>Show metadata for postings in the Journal.</li> <li>The editor now supports org-mode style folding.</li> <li>Show colored dots for all the postings of a transaction in the Journal   report. This way flagged postings can be quickly spotted.</li> <li>Add keyboard shortcuts for save to source editor.</li> </ul>"},{"location":"changelog/#changes_1","title":"Changes","text":"<ul> <li>Use beancount's DisplayContext to determine the correct precision at which to   render numbers.</li> <li>Improve the way that query results are serialized to XLS etc.</li> <li>Show inverse rates for pairs of operating currencies on the commodities   report.</li> <li>Use Click for the CLI and check if beancount file exists on startup.</li> <li>Hide closed accounts in tree tables. Also see new configuration option below.</li> </ul>"},{"location":"changelog/#new-configuration-options_1","title":"New configuration options","text":"<ul> <li><code>editor-strip-trailing-whitespace</code> to enable trimming of trailing   whitespace in the Source editor (default: \"false\").</li> <li><code>show-closed-accounts</code> to show closed accounts in tree tables, for example   on the balance sheet (default: \"false\").</li> <li><code>show-accounts-with-zero-balance</code> to show accounts with a balance of zero   in tree tables (default: \"true\").</li> <li><code>show-accounts-with-zero-transactions</code> to show accounts with no   transactions in tree tables (default: \"true\").</li> </ul>"},{"location":"changelog/#fixes_1","title":"Fixes","text":"<ul> <li>Fixed a bug where the months would be off by one for the interval reports.</li> <li>Fix the net worth report for more than one currency.</li> <li>Some improvements to the help pages.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v025-2016-02-28","title":"v0.2.5 (2016-02-28)","text":"<p>Bump release to remove unused draft code.</p>"},{"location":"changelog/#v024-2016-02-18","title":"v0.2.4 (2016-02-18)","text":""},{"location":"changelog/#additions_2","title":"Additions","text":"<ul> <li>Added missing Holdings views compared to <code>bean-web</code>.</li> <li>Custom queries are now shown in sidebar.</li> <li>The user settings file is now editable in the Source editor.</li> <li>Added second theme.</li> <li>Added Help pages.</li> <li>Query results can now be downloaded as CSV, XLS, XLSX and ODS.</li> <li>Documents can now be uploaded by dragging and dropping files over an Account   name on the Account page and all tree-tables.</li> <li>Journal can now be filtered by transaction type.</li> </ul>"},{"location":"changelog/#changes_2","title":"Changes","text":"<ul> <li>The uptodate-indicator is now shown everywhere by default, but only enabled   for accounts that have the metadata <code>rustfava-uptodate-indication: \"True\"</code> set   on their <code>open</code>-directives.</li> <li>Speedier Journal rendering.</li> <li>Only basenames will be shown for documents in the Journal.</li> <li>Slightly reordered the sidebar menu.</li> <li>Minor UI tweaks.</li> </ul>"},{"location":"changelog/#new-configuration-options_2","title":"New configuration options","text":"<ul> <li><code>sidebar-show-queries</code>: The maximum number of custom queries to show in the   sidebar (default: 5).</li> <li><code>theme</code>: The theme to use. Valid themes are <code>\"default\"</code> and <code>\"alternative\"</code>   (default: <code>\"default\"</code>).</li> <li><code>editor-print-margin-column</code>: Set the column for the print margin in the   Source editor (default: 60).</li> <li><code>uptodate-indicator-show-everywhere</code> (default: \"true\"). See Changes above.</li> </ul>"},{"location":"changelog/#removed-configuration-options","title":"Removed configuration options","text":"<ul> <li><code>uptodate-indicator-exclude-accounts</code>, see Changes above.</li> </ul>"},{"location":"changelog/#fixes_2","title":"Fixes","text":"<ul> <li>Fixed Net worth calculation.</li> <li>Many small bug fixes.</li> </ul>"},{"location":"changelog/#v023-2016-02-15","title":"v0.2.3 (2016-02-15)","text":"<p>Bumped version to communicate that installing via <code>pip install</code> now works, all requirements included.</p>"},{"location":"changelog/#earlier-versions","title":"Earlier Versions","text":"<p>It was not possible to install any of the earlier versions only using <code>pip</code> and you may consult the git log for earlier changes. The first commit in the git repository was on December 4th, 2015.</p>"},{"location":"deployment/","title":"Deployment","text":"<p>There are several ways to deploy rustfava depending on your needs.</p>"},{"location":"deployment/#desktop-app","title":"Desktop App","text":"<p>For personal use, the desktop app is the simplest option. It runs entirely locally with no server setup required.</p>"},{"location":"deployment/#docker","title":"Docker","text":"<p>For server deployments, Docker is recommended:</p> <pre><code>docker run -p 5000:5000 -v /path/to/ledger:/data ghcr.io/rustledger/rustfava /data/main.beancount\n</code></pre> <p>For advanced Docker configurations (authentication, HTTPS, docker-compose), see the Docker deployment guide.</p>"},{"location":"deployment/#systemd-service","title":"Systemd Service","text":"<p>To run rustfava as a system service on Linux:</p> <pre><code># /etc/systemd/system/rustfava.service\n[Unit]\nDescription=rustfava Web UI for Beancount\nAfter=network.target\n\n[Service]\nType=simple\nExecStart=/usr/bin/rustfava --host 127.0.0.1 --port 5000 /path/to/main.beancount\nUser=your-user\nRestart=on-failure\n\n[Install]\nWantedBy=multi-user.target\n</code></pre> <p>Then:</p> <pre><code>sudo systemctl enable rustfava\nsudo systemctl start rustfava\n</code></pre>"},{"location":"deployment/#reverse-proxy","title":"Reverse Proxy","text":""},{"location":"deployment/#apache","title":"Apache","text":"<pre><code>ProxyPass \"/rustfava\" \"http://localhost:5000/rustfava\"\nProxyPassReverse \"/rustfava\" \"http://localhost:5000/rustfava\"\n</code></pre> <p>Run rustfava with the <code>--prefix</code> option:</p> <pre><code>rustfava --prefix /rustfava /path/to/main.beancount\n</code></pre>"},{"location":"deployment/#nginx","title":"Nginx","text":"<pre><code>location /rustfava/ {\n    proxy_pass http://127.0.0.1:5000/rustfava/;\n    proxy_set_header Host $host;\n    proxy_set_header X-Real-IP $remote_addr;\n    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n    proxy_set_header X-Forwarded-Proto $scheme;\n}\n</code></pre>"},{"location":"deployment/#caddy","title":"Caddy","text":"<pre><code>your-domain.com {\n    reverse_proxy localhost:5000\n}\n</code></pre> <p>Caddy automatically handles HTTPS with Let's Encrypt.</p>"},{"location":"deployment/#security-considerations","title":"Security Considerations","text":"<p>When exposing rustfava to the internet:</p> <ol> <li>Use HTTPS - Never expose plain HTTP to the public internet</li> <li>Add authentication - Use a reverse proxy with OAuth2 or basic auth</li> <li>Restrict access - Use firewall rules to limit access to trusted IPs</li> <li>Keep updated - Regularly update rustfava for security patches</li> </ol> <p>See SECURITY.md for more security best practices.</p>"},{"location":"development/","title":"Development","text":""},{"location":"development/#setting-up-a-development-environment","title":"Setting up a development environment","text":"<p>If you want to hack on rustfava or run the latest development version, make sure you have recent enough versions of the following installed (ideally with your system package manager):</p> <ul> <li>Python 3.13+ - as rustfava is written in Python</li> <li>Bun - to build the frontend</li> <li>just - to run various build / lint / test targets</li> <li>uv - to install the development environment and run scripts</li> </ul> <p>Then this will get you up and running:</p> <pre><code>git clone https://github.com/rustledger/rustfava.git\ncd rustfava\n# setup a virtual environment (at .venv) and install rustfava and development\n# dependencies into it:\njust dev\n</code></pre> <p>You can start rustfava in the virtual environment as usual by running <code>rustfava</code>. Running in debug mode with <code>rustfava --debug</code> is useful for development.</p> <p>You can run the tests with <code>just test</code> and the linters by running <code>just lint</code>. Run <code>just --list</code> to see all available recipes. After any changes to the Javascript code, you will need to re-build the frontend, which you can do by running <code>just frontend</code>. If you are working on the frontend code, running <code>bun run dev</code> in the <code>frontend</code> folder will watch for file changes and rebuild the Javascript bundle continuously.</p> <p>Contributions are very welcome, just open a PR on GitHub.</p> <p>Rustfava is released under the MIT License.</p>"},{"location":"upstream-sync/","title":"Syncing with Upstream Fava","text":"<p>rustfava is a fork of Fava that replaces the beancount parser with rustledger. This document describes how to sync relevant changes from upstream.</p>"},{"location":"upstream-sync/#background","title":"Background","text":"<p>The fork diverges significantly from upstream in the backend:</p> Component Fava rustfava Parser Python beancount rustledger (WASM) Core modules <code>fava/core/</code>, <code>fava/beans/</code> <code>rustfava/rustledger/</code> Package manager npm bun <p>The frontend is largely unchanged and can usually accept upstream patches.</p>"},{"location":"upstream-sync/#checking-for-upstream-changes","title":"Checking for Upstream Changes","text":"<pre><code># Fetch upstream\ngit fetch upstream\n\n# Find the common ancestor (fork point)\ngit merge-base main upstream/main\n\n# Count commits since fork\ngit rev-list --count $(git merge-base main upstream/main)..upstream/main\n\n# List upstream commits since fork\ngit log --oneline $(git merge-base main upstream/main)..upstream/main\n</code></pre>"},{"location":"upstream-sync/#categorizing-commits","title":"Categorizing Commits","text":"<p>Review each upstream commit and categorize:</p>"},{"location":"upstream-sync/#safe-to-cherry-pick","title":"Safe to cherry-pick","text":"<ul> <li>Frontend changes (<code>frontend/src/</code>) - UI, routing, components</li> <li>Documentation (<code>docs/</code>, <code>*.md</code>)</li> <li>Templates (<code>src/fava/templates/</code>)</li> <li>Static assets (<code>src/fava/static/</code>)</li> <li>Extension API (if not touching core)</li> </ul>"},{"location":"upstream-sync/#requires-review","title":"Requires review","text":"<ul> <li>Tests - may reference beancount-specific behavior</li> <li>API endpoints - check if they depend on beancount types</li> </ul>"},{"location":"upstream-sync/#cannot-cherry-pick","title":"Cannot cherry-pick","text":"<ul> <li>Core modules - <code>src/fava/core/</code>, <code>src/fava/beans/</code></li> <li>Beancount imports - anything importing from <code>beancount.*</code></li> <li>Inventory/position logic - replaced by rustledger</li> </ul>"},{"location":"upstream-sync/#cherry-pick-workflow","title":"Cherry-Pick Workflow","text":"<pre><code># 1. Create a sync branch\ngit checkout main\ngit pull origin main\ngit checkout -b sync/upstream-YYYY-MM\n\n# 2. Cherry-pick safe commits (oldest first)\ngit cherry-pick &lt;commit-hash&gt;\n\n# 3. If conflicts occur, resolve them:\n#    - For package-lock.json conflicts: git rm frontend/package-lock.json\n#    - For renamed files (fava -&gt; rustfava): update paths\n#    - For deleted files: skip the commit with git cherry-pick --skip\n\n# 4. Update lockfile if package.json changed\nnix develop --command bash -c \"cd frontend &amp;&amp; bun install\"\ngit add frontend/bun.lock\ngit commit -m \"chore: update bun.lock for upstream sync\"\n\n# 5. Test the build\nnix develop --command bash -c \"cd frontend &amp;&amp; bun run build\"\nnix develop --command bash -c \"just test\"\n\n# 6. Push and create PR\ngit push -u origin sync/upstream-YYYY-MM\ngh pr create --title \"chore: sync upstream fava changes (Month YYYY)\"\n</code></pre>"},{"location":"upstream-sync/#common-conflicts","title":"Common Conflicts","text":""},{"location":"upstream-sync/#package-lockjson","title":"package-lock.json","text":"<p>rustfava uses bun instead of npm. Remove the conflicting file:</p> <pre><code>git rm frontend/package-lock.json\ngit cherry-pick --continue\n</code></pre>"},{"location":"upstream-sync/#file-renames-fava-rustfava","title":"File renames (fava -&gt; rustfava)","text":"<p>Upstream references <code>src/fava/</code> but rustfava uses <code>src/rustfava/</code>. The cherry-pick usually handles this via directory mapping, but manual fixes may be needed.</p>"},{"location":"upstream-sync/#deleted-core-files","title":"Deleted core files","text":"<p>If upstream modifies files that rustfava deleted (like <code>core/inventory.py</code>), skip the commit:</p> <pre><code>git cherry-pick --skip\n</code></pre>"},{"location":"upstream-sync/#after-syncing","title":"After Syncing","text":"<ol> <li>Run the test suite: <code>just test</code></li> <li>Build the frontend: <code>just frontend</code></li> <li>Manual testing: Start the app and verify functionality</li> <li>Update this doc: Note the last sync date and any new patterns</li> </ol>"},{"location":"upstream-sync/#sync-history","title":"Sync History","text":"Date PR Commits Notes 2026-01-25 #22 2 Extension types, router improvements"},{"location":"upstream-sync/#upstream-monitoring","title":"Upstream Monitoring","text":"<p>Consider setting up notifications for upstream releases:</p> <ol> <li>Watch the beancount/fava repository</li> <li>Review the Fava changelog periodically</li> <li>Sync quarterly or when significant features are added</li> </ol>"},{"location":"usage/","title":"Getting Started","text":"<p>If you're new to Beancount-format files or double-entry accounting in general, we recommend Command-line Accounting in Context, a motivational document written by Martin Blais, the creator of the Beancount format.</p> <p>To learn how to create your ledger file, refer to Getting Started with Beancount guide. There is extensive documentation for the Beancount file format at the Beancount Documentation page.</p>"},{"location":"usage/#installation","title":"Installation","text":""},{"location":"usage/#option-1-desktop-app-recommended","title":"Option 1: Desktop App (Recommended)","text":"<p>Download the desktop app from GitHub Releases:</p> Platform Download macOS <code>rustfava_x.x.x_aarch64.dmg</code> Windows <code>rustfava_x.x.x_x64-setup.exe</code> Linux <code>rustfava_x.x.x_amd64.AppImage</code> <p>Double-click to launch, then open your <code>.beancount</code> file. No Python or other dependencies required.</p>"},{"location":"usage/#option-2-command-line-pypi","title":"Option 2: Command Line (PyPI)","text":"<p>rustfava runs on macOS, Linux, and Windows. You will need Python 3.13+ and uv.</p> <pre><code>uv tool install rustfava\n</code></pre> <p>Or to install into a virtual environment:</p> <pre><code>uv pip install rustfava\n</code></pre> <p>rustfava uses rustledger, a Rust-based parser compiled to WebAssembly, to parse your Beancount files. No separate Beancount installation is required.</p> <p>To export query results to Microsoft Excel or LibreOffice Calc:</p> <pre><code>uv tool install rustfava[excel]\n</code></pre>"},{"location":"usage/#option-3-docker","title":"Option 3: Docker","text":"<pre><code>docker run -p 5000:5000 -v /path/to/ledger:/data ghcr.io/rustledger/rustfava /data/main.beancount\n</code></pre> <p>See Docker deployment for advanced options.</p>"},{"location":"usage/#starting-rustfava","title":"Starting rustfava","text":""},{"location":"usage/#desktop-app","title":"Desktop App","text":"<ol> <li>Launch the app</li> <li>Click \"Open File\" or use File \u2192 Open</li> <li>Select your <code>.beancount</code> file</li> </ol>"},{"location":"usage/#command-line","title":"Command Line","text":"<pre><code>rustfava ledger.beancount\n</code></pre> <p>Then visit http://localhost:5000.</p> <p>Run <code>rustfava --help</code> for available options.</p>"},{"location":"usage/#using-rustfava","title":"Using rustfava","text":"<p>For more information on rustfava's features, refer to the help pages available through rustfava's web interface. rustfava comes with Gmail-style keyboard shortcuts; press <code>?</code> to show an overview.</p>"}]}
\ No newline at end of file
diff --git a/public/rustfava/docs/sitemap.xml b/public/rustfava/docs/sitemap.xml
index 4001337..576c65b 100644
--- a/public/rustfava/docs/sitemap.xml
+++ b/public/rustfava/docs/sitemap.xml
@@ -2,26 +2,30 @@
 <urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
     </url>
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/api/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
     </url>
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/changelog/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
     </url>
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/deployment/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
     </url>
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/development/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
+    </url>
+    <url>
+         <loc>https://rustledger.github.io/rustfava/docs/upstream-sync/</loc>
+         <lastmod>2026-01-26</lastmod>
     </url>
     <url>
          <loc>https://rustledger.github.io/rustfava/docs/usage/</loc>
-         <lastmod>2026-01-25</lastmod>
+         <lastmod>2026-01-26</lastmod>
     </url>
 </urlset>
\ No newline at end of file
diff --git a/public/rustfava/docs/sitemap.xml.gz b/public/rustfava/docs/sitemap.xml.gz
index 76c7579b028fe2f35af325deebb9a820343c3473..6dda17a432a35458da49669ed86074afbd405ab0 100644
GIT binary patch
literal 250
zcmV<W00sXaiwFpSu6Ahx|8r?{Wo=<_E_iKh0L7C{Zo?oDh4(py#opj}5jB-fc0ECR
z00L8t#Ge>!H@6RVqN?j=!E9ijX5RaR#Blj>wpk#d34SC;+K~pl49a*tlCRH?_KjTl
zVVILe$W0mcIFc#n_|Dk6t`toMCnD02G($O+2H8_&9X%6%Xi9AckK0~@4U%szSZvaa
z*@DuLs5W_;uhfKH{1%H~DoA7l+ZO)r3(PJk-go_}?T&4KDkD$r5y*ZMU(6QKRLz%@
z@EUB;RVfri8*UDKu8gsir-;=#=7>3ga4p`vtV@DI!~Y5PqkL_C2eZv^=?Vk@0I{=m
AJ^%m!

literal 240
zcmV<M01y8kiwFn+U3F;!|8r?{Wo=<_E_iKh0L4?mZo?o9z4t33?twJYs%=W>tzWQx
z00oaA5sWZNw!a@qtE%Vi5MOLR+3!7Ba(Dh7eKkWOhoNUj-mnUSM&p9*+2_Zler0EQ
z=%(Zea#e-{^=!yFz6-G|3n!OhRFOC)D@YHeA#n#q!{3-ZR3%n|TeU^!QOlKu3Qd|Q
zdoUIfw=NIUl{?(PFEuM+P?PAyy70WOD354l+q9>;Io9n<8M$LOLGe)hr?!f2SA9LG
qV8Nr^)rEoR@n?jPceXK?Q^ehUOr$LQ-NBa1L&;wXn8ay-0{{RFL2+IH

diff --git a/public/rustfava/docs/upstream-sync/index.html b/public/rustfava/docs/upstream-sync/index.html
new file mode 100644
index 0000000..7244b61
--- /dev/null
+++ b/public/rustfava/docs/upstream-sync/index.html
@@ -0,0 +1,819 @@
+
+<!doctype html>
+<html lang="en" class="no-js">
+  <head>
+    
+      <meta charset="utf-8">
+      <meta name="viewport" content="width=device-width,initial-scale=1">
+      
+        <meta name="description" content="Web interface for rustledger, a Rust-based Beancount parser">
+      
+      
+      
+        <link rel="canonical" href="https://rustledger.github.io/rustfava/docs/upstream-sync/">
+      
+      
+      
+      
+        
+      
+      
+      <link rel="icon" href="../assets/images/favicon.png">
+      <meta name="generator" content="mkdocs-1.6.1, mkdocs-material-9.7.1">
+    
+    
+      
+        <title>Syncing with Upstream Fava - Rustfava</title>
+      
+    
+    
+      <link rel="stylesheet" href="../assets/stylesheets/main.484c7ddc.min.css">
+      
+        
+        <link rel="stylesheet" href="../assets/stylesheets/palette.ab4e12ef.min.css">
+      
+      
+
+
+    
+    
+      
+    
+    
+      
+        
+        
+        <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+        <link rel="stylesheet" href="https://fonts.googleapis.com/css?family=Roboto:300,300i,400,400i,700,700i%7CRoboto+Mono:400,400i,700,700i&display=fallback">
+        <style>:root{--md-text-font:"Roboto";--md-code-font:"Roboto Mono"}</style>
+      
+    
+    
+      <link rel="stylesheet" href="../assets/_mkdocstrings.css">
+    
+    <script>__md_scope=new URL("..",location),__md_hash=e=>[...e].reduce(((e,_)=>(e<<5)-e+_.charCodeAt(0)),0),__md_get=(e,_=localStorage,t=__md_scope)=>JSON.parse(_.getItem(t.pathname+"."+e)),__md_set=(e,_,t=localStorage,a=__md_scope)=>{try{t.setItem(a.pathname+"."+e,JSON.stringify(_))}catch(e){}}</script>
+    
+      
+
+    
+    
+  </head>
+  
+  
+    
+    
+      
+    
+    
+    
+    
+    <body dir="ltr" data-md-color-scheme="default" data-md-color-primary="teal" data-md-color-accent="teal">
+  
+    
+    <input class="md-toggle" data-md-toggle="drawer" type="checkbox" id="__drawer" autocomplete="off">
+    <input class="md-toggle" data-md-toggle="search" type="checkbox" id="__search" autocomplete="off">
+    <label class="md-overlay" for="__drawer"></label>
+    <div data-md-component="skip">
+      
+        
+        <a href="#syncing-with-upstream-fava" class="md-skip">
+          Skip to content
+        </a>
+      
+    </div>
+    <div data-md-component="announce">
+      
+    </div>
+    
+    
+      
+
+  
+
+<header class="md-header md-header--shadow" data-md-component="header">
+  <nav class="md-header__inner md-grid" aria-label="Header">
+    <a href=".." title="Rustfava" class="md-header__button md-logo" aria-label="Rustfava" data-md-component="logo">
+      
+  <img src="../logo.svg" alt="logo">
+
+    </a>
+    <label class="md-header__button md-icon" for="__drawer">
+      
+      <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M3 6h18v2H3zm0 5h18v2H3zm0 5h18v2H3z"/></svg>
+    </label>
+    <div class="md-header__title" data-md-component="header-title">
+      <div class="md-header__ellipsis">
+        <div class="md-header__topic">
+          <span class="md-ellipsis">
+            Rustfava
+          </span>
+        </div>
+        <div class="md-header__topic" data-md-component="header-topic">
+          <span class="md-ellipsis">
+            
+              Syncing with Upstream Fava
+            
+          </span>
+        </div>
+      </div>
+    </div>
+    
+      
+        <form class="md-header__option" data-md-component="palette">
+  
+    
+    
+    
+    <input class="md-option" data-md-color-media="" data-md-color-scheme="default" data-md-color-primary="teal" data-md-color-accent="teal"  aria-label="Switch to dark mode"  type="radio" name="__palette" id="__palette_0">
+    
+      <label class="md-header__button md-icon" title="Switch to dark mode" for="__palette_1" hidden>
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 8a4 4 0 0 0-4 4 4 4 0 0 0 4 4 4 4 0 0 0 4-4 4 4 0 0 0-4-4m0 10a6 6 0 0 1-6-6 6 6 0 0 1 6-6 6 6 0 0 1 6 6 6 6 0 0 1-6 6m8-9.31V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12z"/></svg>
+      </label>
+    
+  
+    
+    
+    
+    <input class="md-option" data-md-color-media="" data-md-color-scheme="slate" data-md-color-primary="teal" data-md-color-accent="teal"  aria-label="Switch to light mode"  type="radio" name="__palette" id="__palette_1">
+    
+      <label class="md-header__button md-icon" title="Switch to light mode" for="__palette_0" hidden>
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M12 18c-.89 0-1.74-.2-2.5-.55C11.56 16.5 13 14.42 13 12s-1.44-4.5-3.5-5.45C10.26 6.2 11.11 6 12 6a6 6 0 0 1 6 6 6 6 0 0 1-6 6m8-9.31V4h-4.69L12 .69 8.69 4H4v4.69L.69 12 4 15.31V20h4.69L12 23.31 15.31 20H20v-4.69L23.31 12z"/></svg>
+      </label>
+    
+  
+</form>
+      
+    
+    
+      <script>var palette=__md_get("__palette");if(palette&&palette.color){if("(prefers-color-scheme)"===palette.color.media){var media=matchMedia("(prefers-color-scheme: light)"),input=document.querySelector(media.matches?"[data-md-color-media='(prefers-color-scheme: light)']":"[data-md-color-media='(prefers-color-scheme: dark)']");palette.color.media=input.getAttribute("data-md-color-media"),palette.color.scheme=input.getAttribute("data-md-color-scheme"),palette.color.primary=input.getAttribute("data-md-color-primary"),palette.color.accent=input.getAttribute("data-md-color-accent")}for(var[key,value]of Object.entries(palette.color))document.body.setAttribute("data-md-color-"+key,value)}</script>
+    
+    
+    
+      
+      
+        <label class="md-header__button md-icon" for="__search">
+          
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M9.5 3A6.5 6.5 0 0 1 16 9.5c0 1.61-.59 3.09-1.56 4.23l.27.27h.79l5 5-1.5 1.5-5-5v-.79l-.27-.27A6.52 6.52 0 0 1 9.5 16 6.5 6.5 0 0 1 3 9.5 6.5 6.5 0 0 1 9.5 3m0 2C7 5 5 7 5 9.5S7 14 9.5 14 14 12 14 9.5 12 5 9.5 5"/></svg>
+        </label>
+        <div class="md-search" data-md-component="search" role="dialog">
+  <label class="md-search__overlay" for="__search"></label>
+  <div class="md-search__inner" role="search">
+    <form class="md-search__form" name="search">
+      <input type="text" class="md-search__input" name="query" aria-label="Search" placeholder="Search" autocapitalize="off" autocorrect="off" autocomplete="off" spellcheck="false" data-md-component="search-query" required>
+      <label class="md-search__icon md-icon" for="__search">
+        
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M9.5 3A6.5 6.5 0 0 1 16 9.5c0 1.61-.59 3.09-1.56 4.23l.27.27h.79l5 5-1.5 1.5-5-5v-.79l-.27-.27A6.52 6.52 0 0 1 9.5 16 6.5 6.5 0 0 1 3 9.5 6.5 6.5 0 0 1 9.5 3m0 2C7 5 5 7 5 9.5S7 14 9.5 14 14 12 14 9.5 12 5 9.5 5"/></svg>
+        
+        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M20 11v2H8l5.5 5.5-1.42 1.42L4.16 12l7.92-7.92L13.5 5.5 8 11z"/></svg>
+      </label>
+      <nav class="md-search__options" aria-label="Search">
+        
+        <button type="reset" class="md-search__icon md-icon" title="Clear" aria-label="Clear" tabindex="-1">
+          
+          <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><path d="M19 6.41 17.59 5 12 10.59 6.41 5 5 6.41 10.59 12 5 17.59 6.41 19 12 13.41 17.59 19 19 17.59 13.41 12z"/></svg>
+        </button>
+      </nav>
+      
+    </form>
+    <div class="md-search__output">
+      <div class="md-search__scrollwrap" tabindex="0" data-md-scrollfix>
+        <div class="md-search-result" data-md-component="search-result">
+          <div class="md-search-result__meta">
+            Initializing search
+          </div>
+          <ol class="md-search-result__list" role="presentation"></ol>
+        </div>
+      </div>
+    </div>
+  </div>
+</div>
+      
+    
+    
+      <div class="md-header__source">
+        <a href="https://github.com/rustledger/rustfava" title="Go to repository" class="md-source" data-md-component="source">
+  <div class="md-source__icon md-icon">
+    
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2025 Fonticons, Inc.--><path d="M439.6 236.1 244 40.5c-5.4-5.5-12.8-8.5-20.4-8.5s-15 3-20.4 8.4L162.5 81l51.5 51.5c27.1-9.1 52.7 16.8 43.4 43.7l49.7 49.7c34.2-11.8 61.2 31 35.5 56.7-26.5 26.5-70.2-2.9-56-37.3L240.3 199v121.9c25.3 12.5 22.3 41.8 9.1 55-6.4 6.4-15.2 10.1-24.3 10.1s-17.8-3.6-24.3-10.1c-17.6-17.6-11.1-46.9 11.2-56v-123c-20.8-8.5-24.6-30.7-18.6-45L142.6 101 8.5 235.1C3 240.6 0 247.9 0 255.5s3 15 8.5 20.4l195.6 195.7c5.4 5.4 12.7 8.4 20.4 8.4s15-3 20.4-8.4l194.7-194.7c5.4-5.4 8.4-12.8 8.4-20.4s-3-15-8.4-20.4"/></svg>
+  </div>
+  <div class="md-source__repository">
+    rustledger/rustfava
+  </div>
+</a>
+      </div>
+    
+  </nav>
+  
+</header>
+    
+    <div class="md-container" data-md-component="container">
+      
+      
+        
+          
+        
+      
+      <main class="md-main" data-md-component="main">
+        <div class="md-main__inner md-grid">
+          
+            
+              
+              <div class="md-sidebar md-sidebar--primary" data-md-component="sidebar" data-md-type="navigation" >
+                <div class="md-sidebar__scrollwrap">
+                  <div class="md-sidebar__inner">
+                    
+
+
+
+<nav class="md-nav md-nav--primary" aria-label="Navigation" data-md-level="0">
+  <label class="md-nav__title" for="__drawer">
+    <a href=".." title="Rustfava" class="md-nav__button md-logo" aria-label="Rustfava" data-md-component="logo">
+      
+  <img src="../logo.svg" alt="logo">
+
+    </a>
+    Rustfava
+  </label>
+  
+    <div class="md-nav__source">
+      <a href="https://github.com/rustledger/rustfava" title="Go to repository" class="md-source" data-md-component="source">
+  <div class="md-source__icon md-icon">
+    
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512"><!--! Font Awesome Free 7.1.0 by @fontawesome - https://fontawesome.com License - https://fontawesome.com/license/free (Icons: CC BY 4.0, Fonts: SIL OFL 1.1, Code: MIT License) Copyright 2025 Fonticons, Inc.--><path d="M439.6 236.1 244 40.5c-5.4-5.5-12.8-8.5-20.4-8.5s-15 3-20.4 8.4L162.5 81l51.5 51.5c27.1-9.1 52.7 16.8 43.4 43.7l49.7 49.7c34.2-11.8 61.2 31 35.5 56.7-26.5 26.5-70.2-2.9-56-37.3L240.3 199v121.9c25.3 12.5 22.3 41.8 9.1 55-6.4 6.4-15.2 10.1-24.3 10.1s-17.8-3.6-24.3-10.1c-17.6-17.6-11.1-46.9 11.2-56v-123c-20.8-8.5-24.6-30.7-18.6-45L142.6 101 8.5 235.1C3 240.6 0 247.9 0 255.5s3 15 8.5 20.4l195.6 195.7c5.4 5.4 12.7 8.4 20.4 8.4s15-3 20.4-8.4l194.7-194.7c5.4-5.4 8.4-12.8 8.4-20.4s-3-15-8.4-20.4"/></svg>
+  </div>
+  <div class="md-source__repository">
+    rustledger/rustfava
+  </div>
+</a>
+    </div>
+  
+  <ul class="md-nav__list" data-md-scrollfix>
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href=".." class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Home
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href="../usage/" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Getting Started
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href="../changelog/" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Changelog
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href="../development/" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Development
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href="../deployment/" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    Deployment
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+      
+      
+  
+  
+  
+  
+    <li class="md-nav__item">
+      <a href="../api/" class="md-nav__link">
+        
+  
+  
+  <span class="md-ellipsis">
+    
+  
+    API Reference
+  
+
+    
+  </span>
+  
+  
+
+      </a>
+    </li>
+  
+
+    
+  </ul>
+</nav>
+                  </div>
+                </div>
+              </div>
+            
+            
+              
+              <div class="md-sidebar md-sidebar--secondary" data-md-component="sidebar" data-md-type="toc" >
+                <div class="md-sidebar__scrollwrap">
+                  <div class="md-sidebar__inner">
+                    
+
+<nav class="md-nav md-nav--secondary" aria-label="Table of contents">
+  
+  
+  
+    
+  
+  
+    <label class="md-nav__title" for="__toc">
+      <span class="md-nav__icon md-icon"></span>
+      Table of contents
+    </label>
+    <ul class="md-nav__list" data-md-component="toc" data-md-scrollfix>
+      
+        <li class="md-nav__item">
+  <a href="#background" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Background
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#checking-for-upstream-changes" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Checking for Upstream Changes
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#categorizing-commits" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Categorizing Commits
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Categorizing Commits">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#safe-to-cherry-pick" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Safe to cherry-pick
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#requires-review" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Requires review
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#cannot-cherry-pick" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Cannot cherry-pick
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#cherry-pick-workflow" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Cherry-Pick Workflow
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#common-conflicts" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Common Conflicts
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Common Conflicts">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#package-lockjson" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        package-lock.json
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#file-renames-fava-rustfava" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        File renames (fava -&gt; rustfava)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#deleted-core-files" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Deleted core files
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#after-syncing" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        After Syncing
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#sync-history" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Sync History
+      
+    </span>
+  </a>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#upstream-monitoring" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Upstream Monitoring
+      
+    </span>
+  </a>
+  
+</li>
+      
+    </ul>
+  
+</nav>
+                  </div>
+                </div>
+              </div>
+            
+          
+          
+            <div class="md-content" data-md-component="content">
+              
+              <article class="md-content__inner md-typeset">
+                
+                  
+
+
+  
+  
+
+
+<h1 id="syncing-with-upstream-fava">Syncing with Upstream Fava<a class="headerlink" href="#syncing-with-upstream-fava" title="Permanent link">&para;</a></h1>
+<p>rustfava is a fork of <a href="https://github.com/beancount/fava">Fava</a> that replaces the beancount parser with <a href="https://github.com/rustledger/rustledger">rustledger</a>. This document describes how to sync relevant changes from upstream.</p>
+<h2 id="background">Background<a class="headerlink" href="#background" title="Permanent link">&para;</a></h2>
+<p>The fork diverges significantly from upstream in the backend:</p>
+<table>
+<thead>
+<tr>
+<th>Component</th>
+<th>Fava</th>
+<th>rustfava</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>Parser</td>
+<td>Python beancount</td>
+<td>rustledger (WASM)</td>
+</tr>
+<tr>
+<td>Core modules</td>
+<td><code>fava/core/</code>, <code>fava/beans/</code></td>
+<td><code>rustfava/rustledger/</code></td>
+</tr>
+<tr>
+<td>Package manager</td>
+<td>npm</td>
+<td>bun</td>
+</tr>
+</tbody>
+</table>
+<p>The frontend is largely unchanged and can usually accept upstream patches.</p>
+<h2 id="checking-for-upstream-changes">Checking for Upstream Changes<a class="headerlink" href="#checking-for-upstream-changes" title="Permanent link">&para;</a></h2>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a><span class="c1"># Fetch upstream</span>
+<a id="__codelineno-0-2" name="__codelineno-0-2" href="#__codelineno-0-2"></a>git<span class="w"> </span>fetch<span class="w"> </span>upstream
+<a id="__codelineno-0-3" name="__codelineno-0-3" href="#__codelineno-0-3"></a>
+<a id="__codelineno-0-4" name="__codelineno-0-4" href="#__codelineno-0-4"></a><span class="c1"># Find the common ancestor (fork point)</span>
+<a id="__codelineno-0-5" name="__codelineno-0-5" href="#__codelineno-0-5"></a>git<span class="w"> </span>merge-base<span class="w"> </span>main<span class="w"> </span>upstream/main
+<a id="__codelineno-0-6" name="__codelineno-0-6" href="#__codelineno-0-6"></a>
+<a id="__codelineno-0-7" name="__codelineno-0-7" href="#__codelineno-0-7"></a><span class="c1"># Count commits since fork</span>
+<a id="__codelineno-0-8" name="__codelineno-0-8" href="#__codelineno-0-8"></a>git<span class="w"> </span>rev-list<span class="w"> </span>--count<span class="w"> </span><span class="k">$(</span>git<span class="w"> </span>merge-base<span class="w"> </span>main<span class="w"> </span>upstream/main<span class="k">)</span>..upstream/main
+<a id="__codelineno-0-9" name="__codelineno-0-9" href="#__codelineno-0-9"></a>
+<a id="__codelineno-0-10" name="__codelineno-0-10" href="#__codelineno-0-10"></a><span class="c1"># List upstream commits since fork</span>
+<a id="__codelineno-0-11" name="__codelineno-0-11" href="#__codelineno-0-11"></a>git<span class="w"> </span>log<span class="w"> </span>--oneline<span class="w"> </span><span class="k">$(</span>git<span class="w"> </span>merge-base<span class="w"> </span>main<span class="w"> </span>upstream/main<span class="k">)</span>..upstream/main
+</code></pre></div>
+<h2 id="categorizing-commits">Categorizing Commits<a class="headerlink" href="#categorizing-commits" title="Permanent link">&para;</a></h2>
+<p>Review each upstream commit and categorize:</p>
+<h3 id="safe-to-cherry-pick">Safe to cherry-pick<a class="headerlink" href="#safe-to-cherry-pick" title="Permanent link">&para;</a></h3>
+<ul>
+<li><strong>Frontend changes</strong> (<code>frontend/src/</code>) - UI, routing, components</li>
+<li><strong>Documentation</strong> (<code>docs/</code>, <code>*.md</code>)</li>
+<li><strong>Templates</strong> (<code>src/fava/templates/</code>)</li>
+<li><strong>Static assets</strong> (<code>src/fava/static/</code>)</li>
+<li><strong>Extension API</strong> (if not touching core)</li>
+</ul>
+<h3 id="requires-review">Requires review<a class="headerlink" href="#requires-review" title="Permanent link">&para;</a></h3>
+<ul>
+<li><strong>Tests</strong> - may reference beancount-specific behavior</li>
+<li><strong>API endpoints</strong> - check if they depend on beancount types</li>
+</ul>
+<h3 id="cannot-cherry-pick">Cannot cherry-pick<a class="headerlink" href="#cannot-cherry-pick" title="Permanent link">&para;</a></h3>
+<ul>
+<li><strong>Core modules</strong> - <code>src/fava/core/</code>, <code>src/fava/beans/</code></li>
+<li><strong>Beancount imports</strong> - anything importing from <code>beancount.*</code></li>
+<li><strong>Inventory/position logic</strong> - replaced by rustledger</li>
+</ul>
+<h2 id="cherry-pick-workflow">Cherry-Pick Workflow<a class="headerlink" href="#cherry-pick-workflow" title="Permanent link">&para;</a></h2>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a><span class="c1"># 1. Create a sync branch</span>
+<a id="__codelineno-1-2" name="__codelineno-1-2" href="#__codelineno-1-2"></a>git<span class="w"> </span>checkout<span class="w"> </span>main
+<a id="__codelineno-1-3" name="__codelineno-1-3" href="#__codelineno-1-3"></a>git<span class="w"> </span>pull<span class="w"> </span>origin<span class="w"> </span>main
+<a id="__codelineno-1-4" name="__codelineno-1-4" href="#__codelineno-1-4"></a>git<span class="w"> </span>checkout<span class="w"> </span>-b<span class="w"> </span>sync/upstream-YYYY-MM
+<a id="__codelineno-1-5" name="__codelineno-1-5" href="#__codelineno-1-5"></a>
+<a id="__codelineno-1-6" name="__codelineno-1-6" href="#__codelineno-1-6"></a><span class="c1"># 2. Cherry-pick safe commits (oldest first)</span>
+<a id="__codelineno-1-7" name="__codelineno-1-7" href="#__codelineno-1-7"></a>git<span class="w"> </span>cherry-pick<span class="w"> </span>&lt;commit-hash&gt;
+<a id="__codelineno-1-8" name="__codelineno-1-8" href="#__codelineno-1-8"></a>
+<a id="__codelineno-1-9" name="__codelineno-1-9" href="#__codelineno-1-9"></a><span class="c1"># 3. If conflicts occur, resolve them:</span>
+<a id="__codelineno-1-10" name="__codelineno-1-10" href="#__codelineno-1-10"></a><span class="c1">#    - For package-lock.json conflicts: git rm frontend/package-lock.json</span>
+<a id="__codelineno-1-11" name="__codelineno-1-11" href="#__codelineno-1-11"></a><span class="c1">#    - For renamed files (fava -&gt; rustfava): update paths</span>
+<a id="__codelineno-1-12" name="__codelineno-1-12" href="#__codelineno-1-12"></a><span class="c1">#    - For deleted files: skip the commit with git cherry-pick --skip</span>
+<a id="__codelineno-1-13" name="__codelineno-1-13" href="#__codelineno-1-13"></a>
+<a id="__codelineno-1-14" name="__codelineno-1-14" href="#__codelineno-1-14"></a><span class="c1"># 4. Update lockfile if package.json changed</span>
+<a id="__codelineno-1-15" name="__codelineno-1-15" href="#__codelineno-1-15"></a>nix<span class="w"> </span>develop<span class="w"> </span>--command<span class="w"> </span>bash<span class="w"> </span>-c<span class="w"> </span><span class="s2">&quot;cd frontend &amp;&amp; bun install&quot;</span>
+<a id="__codelineno-1-16" name="__codelineno-1-16" href="#__codelineno-1-16"></a>git<span class="w"> </span>add<span class="w"> </span>frontend/bun.lock
+<a id="__codelineno-1-17" name="__codelineno-1-17" href="#__codelineno-1-17"></a>git<span class="w"> </span>commit<span class="w"> </span>-m<span class="w"> </span><span class="s2">&quot;chore: update bun.lock for upstream sync&quot;</span>
+<a id="__codelineno-1-18" name="__codelineno-1-18" href="#__codelineno-1-18"></a>
+<a id="__codelineno-1-19" name="__codelineno-1-19" href="#__codelineno-1-19"></a><span class="c1"># 5. Test the build</span>
+<a id="__codelineno-1-20" name="__codelineno-1-20" href="#__codelineno-1-20"></a>nix<span class="w"> </span>develop<span class="w"> </span>--command<span class="w"> </span>bash<span class="w"> </span>-c<span class="w"> </span><span class="s2">&quot;cd frontend &amp;&amp; bun run build&quot;</span>
+<a id="__codelineno-1-21" name="__codelineno-1-21" href="#__codelineno-1-21"></a>nix<span class="w"> </span>develop<span class="w"> </span>--command<span class="w"> </span>bash<span class="w"> </span>-c<span class="w"> </span><span class="s2">&quot;just test&quot;</span>
+<a id="__codelineno-1-22" name="__codelineno-1-22" href="#__codelineno-1-22"></a>
+<a id="__codelineno-1-23" name="__codelineno-1-23" href="#__codelineno-1-23"></a><span class="c1"># 6. Push and create PR</span>
+<a id="__codelineno-1-24" name="__codelineno-1-24" href="#__codelineno-1-24"></a>git<span class="w"> </span>push<span class="w"> </span>-u<span class="w"> </span>origin<span class="w"> </span>sync/upstream-YYYY-MM
+<a id="__codelineno-1-25" name="__codelineno-1-25" href="#__codelineno-1-25"></a>gh<span class="w"> </span>pr<span class="w"> </span>create<span class="w"> </span>--title<span class="w"> </span><span class="s2">&quot;chore: sync upstream fava changes (Month YYYY)&quot;</span>
+</code></pre></div>
+<h2 id="common-conflicts">Common Conflicts<a class="headerlink" href="#common-conflicts" title="Permanent link">&para;</a></h2>
+<h3 id="package-lockjson">package-lock.json<a class="headerlink" href="#package-lockjson" title="Permanent link">&para;</a></h3>
+<p>rustfava uses bun instead of npm. Remove the conflicting file:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a>git<span class="w"> </span>rm<span class="w"> </span>frontend/package-lock.json
+<a id="__codelineno-2-2" name="__codelineno-2-2" href="#__codelineno-2-2"></a>git<span class="w"> </span>cherry-pick<span class="w"> </span>--continue
+</code></pre></div>
+<h3 id="file-renames-fava-rustfava">File renames (fava -&gt; rustfava)<a class="headerlink" href="#file-renames-fava-rustfava" title="Permanent link">&para;</a></h3>
+<p>Upstream references <code>src/fava/</code> but rustfava uses <code>src/rustfava/</code>. The cherry-pick usually handles this via directory mapping, but manual fixes may be needed.</p>
+<h3 id="deleted-core-files">Deleted core files<a class="headerlink" href="#deleted-core-files" title="Permanent link">&para;</a></h3>
+<p>If upstream modifies files that rustfava deleted (like <code>core/inventory.py</code>), skip the commit:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-3-1" name="__codelineno-3-1" href="#__codelineno-3-1"></a>git<span class="w"> </span>cherry-pick<span class="w"> </span>--skip
+</code></pre></div>
+<h2 id="after-syncing">After Syncing<a class="headerlink" href="#after-syncing" title="Permanent link">&para;</a></h2>
+<ol>
+<li><strong>Run the test suite</strong>: <code>just test</code></li>
+<li><strong>Build the frontend</strong>: <code>just frontend</code></li>
+<li><strong>Manual testing</strong>: Start the app and verify functionality</li>
+<li><strong>Update this doc</strong>: Note the last sync date and any new patterns</li>
+</ol>
+<h2 id="sync-history">Sync History<a class="headerlink" href="#sync-history" title="Permanent link">&para;</a></h2>
+<table>
+<thead>
+<tr>
+<th>Date</th>
+<th>PR</th>
+<th>Commits</th>
+<th>Notes</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td>2026-01-25</td>
+<td>#22</td>
+<td>2</td>
+<td>Extension types, router improvements</td>
+</tr>
+</tbody>
+</table>
+<h2 id="upstream-monitoring">Upstream Monitoring<a class="headerlink" href="#upstream-monitoring" title="Permanent link">&para;</a></h2>
+<p>Consider setting up notifications for upstream releases:</p>
+<ol>
+<li>Watch the <a href="https://github.com/beancount/fava">beancount/fava</a> repository</li>
+<li>Review the <a href="https://github.com/beancount/fava/blob/main/CHANGELOG.md">Fava changelog</a> periodically</li>
+<li>Sync quarterly or when significant features are added</li>
+</ol>
+
+
+
+
+
+
+
+
+
+
+
+
+                
+              </article>
+            </div>
+          
+          
+<script>var target=document.getElementById(location.hash.slice(1));target&&target.name&&(target.checked=target.name.startsWith("__tabbed_"))</script>
+        </div>
+        
+      </main>
+      
+        <footer class="md-footer">
+  
+  <div class="md-footer-meta md-typeset">
+    <div class="md-footer-meta__inner md-grid">
+      <div class="md-copyright">
+  
+  
+    Made with
+    <a href="https://squidfunk.github.io/mkdocs-material/" target="_blank" rel="noopener">
+      Material for MkDocs
+    </a>
+  
+</div>
+      
+    </div>
+  </div>
+</footer>
+      
+    </div>
+    <div class="md-dialog" data-md-component="dialog">
+      <div class="md-dialog__inner md-typeset"></div>
+    </div>
+    
+    
+    
+      
+      
+      <script id="__config" type="application/json">{"annotate": null, "base": "..", "features": ["navigation.sections", "navigation.expand", "content.code.copy"], "search": "../assets/javascripts/workers/search.2c215733.min.js", "tags": null, "translations": {"clipboard.copied": "Copied to clipboard", "clipboard.copy": "Copy to clipboard", "search.result.more.one": "1 more on this page", "search.result.more.other": "# more on this page", "search.result.none": "No matching documents", "search.result.one": "1 matching document", "search.result.other": "# matching documents", "search.result.placeholder": "Type to start searching", "search.result.term.missing": "Missing", "select.version": "Select version"}, "version": null}</script>
+    
+    
+      <script src="../assets/javascripts/bundle.79ae519e.min.js"></script>
+      
+    
+  </body>
+</html>
\ No newline at end of file
diff --git a/public/rustfava/docs/usage/index.html b/public/rustfava/docs/usage/index.html
index 1cd0ec6..df929e1 100644
--- a/public/rustfava/docs/usage/index.html
+++ b/public/rustfava/docs/usage/index.html
@@ -355,13 +355,91 @@
     </span>
   </a>
   
+    <nav class="md-nav" aria-label="Installation">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#option-1-desktop-app-recommended" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 1: Desktop App (Recommended)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#option-2-command-line-pypi" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 2: Command Line (PyPI)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#option-3-docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 3: Docker
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
 </li>
       
         <li class="md-nav__item">
   <a href="#starting-rustfava" class="md-nav__link">
     <span class="md-ellipsis">
       
-        Starting Rustfava
+        Starting rustfava
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Starting rustfava">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#desktop-app" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Desktop App
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#command-line" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Command Line
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#using-rustfava" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Using rustfava
       
     </span>
   </a>
@@ -519,13 +597,91 @@
     </span>
   </a>
   
+    <nav class="md-nav" aria-label="Installation">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#option-1-desktop-app-recommended" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 1: Desktop App (Recommended)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#option-2-command-line-pypi" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 2: Command Line (PyPI)
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#option-3-docker" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Option 3: Docker
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
 </li>
       
         <li class="md-nav__item">
   <a href="#starting-rustfava" class="md-nav__link">
     <span class="md-ellipsis">
       
-        Starting Rustfava
+        Starting rustfava
+      
+    </span>
+  </a>
+  
+    <nav class="md-nav" aria-label="Starting rustfava">
+      <ul class="md-nav__list">
+        
+          <li class="md-nav__item">
+  <a href="#desktop-app" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Desktop App
+      
+    </span>
+  </a>
+  
+</li>
+        
+          <li class="md-nav__item">
+  <a href="#command-line" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Command Line
+      
+    </span>
+  </a>
+  
+</li>
+        
+      </ul>
+    </nav>
+  
+</li>
+      
+        <li class="md-nav__item">
+  <a href="#using-rustfava" class="md-nav__link">
+    <span class="md-ellipsis">
+      
+        Using rustfava
       
     </span>
   </a>
@@ -563,30 +719,66 @@ <h1 id="getting-started">Getting Started<a class="headerlink" href="#getting-sta
 <a href="https://docs.google.com/document/d/1RaondTJCS_IUPBHFNdT8oqFKJjVJDsfsn6JEjBG04eA">Beancount Documentation</a>
 page.</p>
 <h2 id="installation">Installation<a class="headerlink" href="#installation" title="Permanent link">&para;</a></h2>
-<p>Rustfava runs on macOS, Linux, and Windows. You will need
-<a href="https://www.python.org/downloads/">Python 3</a> and
+<h3 id="option-1-desktop-app-recommended">Option 1: Desktop App (Recommended)<a class="headerlink" href="#option-1-desktop-app-recommended" title="Permanent link">&para;</a></h3>
+<p>Download the desktop app from <a href="https://github.com/rustledger/rustfava/releases">GitHub Releases</a>:</p>
+<table>
+<thead>
+<tr>
+<th>Platform</th>
+<th>Download</th>
+</tr>
+</thead>
+<tbody>
+<tr>
+<td><strong>macOS</strong></td>
+<td><code>rustfava_x.x.x_aarch64.dmg</code></td>
+</tr>
+<tr>
+<td><strong>Windows</strong></td>
+<td><code>rustfava_x.x.x_x64-setup.exe</code></td>
+</tr>
+<tr>
+<td><strong>Linux</strong></td>
+<td><code>rustfava_x.x.x_amd64.AppImage</code></td>
+</tr>
+</tbody>
+</table>
+<p>Double-click to launch, then open your <code>.beancount</code> file. No Python or other dependencies required.</p>
+<h3 id="option-2-command-line-pypi">Option 2: Command Line (PyPI)<a class="headerlink" href="#option-2-command-line-pypi" title="Permanent link">&para;</a></h3>
+<p>rustfava runs on macOS, Linux, and Windows. You will need
+<a href="https://www.python.org/downloads/">Python 3.13+</a> and
 <a href="https://docs.astral.sh/uv/">uv</a>.</p>
-<p>Then you can install rustfava or update your existing installation by running:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>uv<span class="w"> </span>pip<span class="w"> </span>install<span class="w"> </span>--upgrade<span class="w"> </span>rustfava
+<div class="highlight"><pre><span></span><code><a id="__codelineno-0-1" name="__codelineno-0-1" href="#__codelineno-0-1"></a>uv<span class="w"> </span>tool<span class="w"> </span>install<span class="w"> </span>rustfava
+</code></pre></div>
+<p>Or to install into a virtual environment:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a>uv<span class="w"> </span>pip<span class="w"> </span>install<span class="w"> </span>rustfava
 </code></pre></div>
-<p>Rustfava uses <a href="https://github.com/rustledger/rustledger">rustledger</a>, a
+<p>rustfava uses <a href="https://github.com/rustledger/rustledger">rustledger</a>, a
 Rust-based parser compiled to WebAssembly, to parse your Beancount files. No
 separate Beancount installation is required.</p>
-<p>If you want to export query results to Microsoft Excel or LibreOffice Calc, use
-the following command to install the optional dependencies for this feature:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-1-1" name="__codelineno-1-1" href="#__codelineno-1-1"></a>uv<span class="w"> </span>pip<span class="w"> </span>install<span class="w"> </span>--upgrade<span class="w"> </span>rustfava<span class="o">[</span>excel<span class="o">]</span>
+<p>To export query results to Microsoft Excel or LibreOffice Calc:</p>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a>uv<span class="w"> </span>tool<span class="w"> </span>install<span class="w"> </span>rustfava<span class="o">[</span>excel<span class="o">]</span>
+</code></pre></div>
+<h3 id="option-3-docker">Option 3: Docker<a class="headerlink" href="#option-3-docker" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-3-1" name="__codelineno-3-1" href="#__codelineno-3-1"></a>docker<span class="w"> </span>run<span class="w"> </span>-p<span class="w"> </span><span class="m">5000</span>:5000<span class="w"> </span>-v<span class="w"> </span>/path/to/ledger:/data<span class="w"> </span>ghcr.io/rustledger/rustfava<span class="w"> </span>/data/main.beancount
 </code></pre></div>
-<h2 id="starting-rustfava">Starting Rustfava<a class="headerlink" href="#starting-rustfava" title="Permanent link">&para;</a></h2>
-<p>After installing rustfava, you can start it by running:</p>
-<div class="highlight"><pre><span></span><code><a id="__codelineno-2-1" name="__codelineno-2-1" href="#__codelineno-2-1"></a>rustfava<span class="w"> </span>ledger.beancount
+<p>See <a href="../contrib/docker/README.md">Docker deployment</a> for advanced options.</p>
+<h2 id="starting-rustfava">Starting rustfava<a class="headerlink" href="#starting-rustfava" title="Permanent link">&para;</a></h2>
+<h3 id="desktop-app">Desktop App<a class="headerlink" href="#desktop-app" title="Permanent link">&para;</a></h3>
+<ol>
+<li>Launch the app</li>
+<li>Click "Open File" or use File → Open</li>
+<li>Select your <code>.beancount</code> file</li>
+</ol>
+<h3 id="command-line">Command Line<a class="headerlink" href="#command-line" title="Permanent link">&para;</a></h3>
+<div class="highlight"><pre><span></span><code><a id="__codelineno-4-1" name="__codelineno-4-1" href="#__codelineno-4-1"></a>rustfava<span class="w"> </span>ledger.beancount
 </code></pre></div>
-<p>pointing it to your Beancount file -- and visit the web interface at
-<a href="http://localhost:5000">http://localhost:5000</a>.</p>
-<p>There are some command-line options available, run <code>rustfava --help</code> for an
-overview.</p>
-<p>For more information on rustfava's features, refer to the help pages that are
-available through rustfava's web-interface. Rustfava comes with Gmail-style
-keyboard shortcuts; press <code>?</code> to show an overview.</p>
+<p>Then visit <a href="http://localhost:5000">http://localhost:5000</a>.</p>
+<p>Run <code>rustfava --help</code> for available options.</p>
+<h2 id="using-rustfava">Using rustfava<a class="headerlink" href="#using-rustfava" title="Permanent link">&para;</a></h2>
+<p>For more information on rustfava's features, refer to the help pages available
+through rustfava's web interface. rustfava comes with Gmail-style keyboard
+shortcuts; press <code>?</code> to show an overview.</p>