From 0a486ac032f33485d0a756b883d24ff406752968 Mon Sep 17 00:00:00 2001 From: David Banas Date: Tue, 12 Dec 2023 05:36:00 -0500 Subject: [PATCH] 3 add dual dirac model tail fitting (#133) * PyBERT jitter analysis improvements. Rj has been converted to dual Dirac, but Pj is still based on spectral separation. * First pull request for dual Dirac jitter decomposition. Fixes #3. * [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci * Added Jupyter notebook for testing new dual Dirac code. * Semi-functional checkpoint, to preserve code changes made so far. * Experiment w/ getting code alignment back. I turned of the `black` hook in `.pre-commit-config.yaml`, to see if it was the one undoing my attempts at code alignment, and restored that alignment in the `pybert.utility.calc_jitter()` function. * Removed white-space elimination by `black`. Replaced "qt>=5" in `pyproject.toml`. Brought back threshold plotting for jitter spectrums. Added a utility function for making bathtub curves. Added dual-Dirac calculations for Pj/Rj. * Commented out `isort` portion of pre-commit config. file. * Fixed broken DFE adaptation plotting. * Updated PyAMI commit number. * Restored original fix to DFE plotting breakage. * Reverted name change: thresh => rel_thresh => thresh. * OnJitterDecomposition notebook. --------- Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com> --- .pre-commit-config.yaml | 18 +- PyAMI | 2 +- PyBERT.sublime-project | 8 - misc/OnJitterDecomposition.ipynb | 1247 ++++++++++++++++++++++++++++ misc/scikit-rf/S-param Check.ipynb | 262 +++--- pyproject.toml | 1 + src/pybert/gui/plot.py | 54 +- src/pybert/gui/view.py | 16 +- src/pybert/models/bert.py | 296 +++---- src/pybert/pybert.py | 160 ++-- src/pybert/utility.py | 430 ++++++---- 11 files changed, 1883 insertions(+), 611 deletions(-) delete mode 100644 PyBERT.sublime-project create mode 100644 misc/OnJitterDecomposition.ipynb diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 91d0dbd..d636e2a 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,13 +1,13 @@ repos: - - repo: https://github.com/psf/black - rev: 23.11.0 - hooks: - - id: black - - repo: https://github.com/pycqa/isort - rev: 5.13.1 - hooks: - - id: isort - args: ["--profile", "black", "--filter-files"] + # - repo: https://github.com/psf/black + # rev: 23.11.0 + # hooks: + # - id: black + # - repo: https://github.com/pycqa/isort + # rev: 5.13.1 + # hooks: + # - id: isort + # args: ["--profile", "black", "--filter-files"] - repo: https://github.com/pre-commit/pre-commit-hooks rev: v4.5.0 hooks: diff --git a/PyAMI b/PyAMI index e070028..aa402ee 160000 --- a/PyAMI +++ b/PyAMI @@ -1 +1 @@ -Subproject commit e070028d94e38b3818f74799a33bd0f6ab1b563a +Subproject commit aa402ee8d8b626d9b98b71e186c04329ae9118d6 diff --git a/PyBERT.sublime-project b/PyBERT.sublime-project deleted file mode 100644 index 5bd2f13..0000000 --- a/PyBERT.sublime-project +++ /dev/null @@ -1,8 +0,0 @@ -{ - "folders": - [ - { - "path": "." - } - ], -} diff --git a/misc/OnJitterDecomposition.ipynb b/misc/OnJitterDecomposition.ipynb new file mode 100644 index 0000000..95c4888 --- /dev/null +++ b/misc/OnJitterDecomposition.ipynb @@ -0,0 +1,1247 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "fa848431", + "metadata": {}, + "source": [ + "# On Jitter Decomposition\n", + "\n", + "Original author: David Banas \n", + "Original data: August 19, 2023\n", + "\n", + "Copyright © 2023 David Banas; all rights reserved World wide." + ] + }, + { + "cell_type": "markdown", + "id": "f1d118c1", + "metadata": { + "toc": true + }, + "source": [ + "

Table of Contents

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "28da1bd1", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "This [Jupyter notebook](https://jupyter.org) demonstrates the importance of performing proper _decomposition_ of the total jitter observed in a received signal when hoping to accurately estimate the _bit error ratio_ (BER) of a serial communication link from simulation.\n", + "\n", + "I use a tool of my own authoring: [PyBERT](https://github.com/capn-freako/PyBERT/wiki), throughout the Python code.\n", + "To install PyBERT into the virtual environment you are using for this work, just follow [the _Instant Gratification_ instructions](https://github.com/capn-freako/PyBERT/wiki/instant_gratification).\n", + "Do note, however, that until the new code gets merged into the main branch you'll need to be working from [this development branch](https://github.com/capn-freako/PyBERT/tree/3-add-dual-dirac-model-tail-fitting).\n" + ] + }, + { + "cell_type": "markdown", + "id": "fa35068d", + "metadata": {}, + "source": [ + "### Jitter Component Definitions\n", + "\n", + "Total jitter is, typically, broken down as follows:\n", + "\n", + "```\n", + " Total\n", + " / \\\n", + "Correlated Uncorrelated\n", + " / \\ / \\\n", + " ISI DCD Pj Rj\n", + "```\n", + "\n", + "where the categories _Correlated_ and _Uncorrelated_ refer to the transmitted signal, and:\n", + "\n", + "ISI\n", + ": Inter-symbol interference refers to the energy that \"bleeds\" out from one unit interval into the adjacent ones, due to the finite bandwidth of the channel.\n", + "\n", + "DCD\n", + ": Duty cycle distortion refers to unequal widths of \"1\"s and \"0\"s in the data stream, due to asymmetries in the drive electronics.\n", + "\n", + "Pj\n", + ": Periodic jitter is induced by some source, typically a clock, unrelated to the transmitted data stream.\n", + "\n", + "Rj\n", + ": The so-called \"random\" jitter is assumed to be white and unbounded.\n", + "Neither assumption is correct, but they make the math much easier and don't introduce errors into the result that are too egregious.\n", + "\n", + "Typically, the random jitter: _Rj_, is the most important component to estimate accurately when attempting to meaningfully quote the performance of well designed links." + ] + }, + { + "cell_type": "markdown", + "id": "a645173d", + "metadata": {}, + "source": [ + "
\n", + " Note: There is a newer vogue, now in fashion, for how to think about jitter decomposition.\n", + " It amounts to first separating out the Rj, under the assumption that it is truly unbounded and uniquely so.\n", + " Then what I've labeled \"Rj\" is replaced by \"BUJ\" (bounded uncorrelated jitter).\n", + " I believe that splitting the \"white\" uncorrelated noise into bounded and unbounded categories is a false dichotomy.\n", + " And I've written an article on why I believe this.\n", + " I'll stick with the above decomposition map until someone can change my mind on this.\n", + "
" + ] + }, + { + "cell_type": "markdown", + "id": "827e79aa", + "metadata": {}, + "source": [ + "**Note:** PyBERT has just recently undergone a modification to its algorithm for separating _Pj_ and _Rj_.\n", + "We have (finally) introduced the \"dual Dirac\" method for separating these two quantities into a development branch of the PyBERT source code, which now awaits expert review before it is merged into the main development branch.\n", + "So, this notebook is really performing two functions:\n", + "\n", + "1. Demonstrating the importance of jitter separation to accurately estimating low BER, and\n", + "\n", + "1. Sanity checking the new PyBERT \"dual Dirac\" jitter separation code.\n", + "\n", + "Along the way we'll bump into a few surprises.\n", + "And we'll do our best to poke and prod at those in engineering fashion, to prompt further charting quests into this fascinating land of _jitter_.\n", + "It's an interesting journey and I hope you'll come along. :)" + ] + }, + { + "cell_type": "markdown", + "id": "45940f81", + "metadata": {}, + "source": [ + "### BER Estimation/Extrapolation\n", + "\n", + "Perhaps, you're wondering:\n", + "\n", + "> Why do we need to do anything fancy?\n", + "Why not just observe the link operating for 5N bits and, if we don't see any errors, declare that we have a 1/N BER, or better, with >99% confidence?\n", + "The math will back us up on that, after all.\n", + "\n", + "True, but let's think about how long that would take, given reasonable figures for bit rate and desired BER.\n", + "As an example, let's assume we're operating at 10 Gbps and wish to declare 1e-12 BER.\n", + "That yields an observation time:\n", + "\n", + "$$\n", + "\\tau_{obs.} = \\frac{5 * 10^{12} \\, \\text{bits}}{10 \\, \\text{Gbps}} = 500 \\, \\text{sec.} = 8.33 \\, \\text{min.}\n", + "$$\n", + "\n", + "Well, that certainly seems reasonable.\n", + "\n", + "Yes, but the calculation above refers to a lab measurement of some hypothetical hardware in operation.\n", + "What about _simulating_ that link before it's been fabricated?\n", + "\n", + "_PyBERT_'s best observed performance to date (on a M2 Mac) is about 8 Msmpls/min.\n", + "And we, typically, desire 32 samples/bit for good jitter estimation.\n", + "That yields a simulation bit rate: $\\frac{8 \\, \\text{Msmpls/min.}}{32 \\, \\text{smpls/bit}} = 250 \\, \\text{kbpm}$ and an observation time:\n", + "\n", + "$$\n", + "\\tau_{obs.} = \\frac{5 * 10^{12} \\, \\text{bits}}{250 \\, \\text{kbpm}} = 20 \\, \\text{Mmin.} = 13,860 \\, \\text{days}!\n", + "$$\n", + "\n", + "Clearly, a different approach is required when simulating.\n", + "This alternate approach amounts to presuming that the _tail_ (_not_ the entire distribution) of our _data independent_ jitter distribution is _Gaussian_, and extrapolating it out to the desired confidence interval for the target BER.\n", + "If that left you mystified, don't worry; we'll be diving into the details shortly." + ] + }, + { + "cell_type": "markdown", + "id": "df05c515", + "metadata": {}, + "source": [ + "## Sanity Checking the New Jitter Analysis in _PyBERT_\n", + "\n", + "We'll be using PyBERT's new \"dual Dirac\" jitter analysis and decomposition routines throughout this work.\n", + "So, let's play with them a bit and satisfy ourselves that they give reasonable results." + ] + }, + { + "cell_type": "markdown", + "id": "3e9469ca", + "metadata": {}, + "source": [ + "
\n", + " Note: For more details on using PyBERT as a library, as opposed to\n", + " a stand-alone program (its more typical use mode), visit\n", + " this notebook.
\n", + " Note: The notebook referenced above predates certain changes to the PyBERT API and will not run \"out-of-the-box\".\n", + " However, it will provide the general idea of how to use PyBERT as a library, as\n", + " opposed to a stand-alone application.\n", + "
\n", + " " + ] + }, + { + "cell_type": "markdown", + "id": "4443fde5", + "metadata": {}, + "source": [ + "### Imports and Paths\n", + "\n", + "First, we'll get everything we need imported and report the search paths Python is using, in case we need them for any debugging." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "0101dd69", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:45:28.574620Z", + "start_time": "2023-09-04T14:45:27.316103Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python executable: /Users/dbanas/miniconda3/envs/pybert/bin/python\n", + "Python exec_prefix: /Users/dbanas/miniconda3/envs/pybert\n", + "Python prefix: /Users/dbanas/miniconda3/envs/pybert\n", + "Python import search path:\n", + "['/Users/dbanas/prj/PyBERT/misc',\n", + " '/Users/dbanas/miniconda3/envs/pybert/lib/python39.zip',\n", + " '/Users/dbanas/miniconda3/envs/pybert/lib/python3.9',\n", + " '/Users/dbanas/miniconda3/envs/pybert/lib/python3.9/lib-dynload',\n", + " '',\n", + " '/Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages',\n", + " '/Users/dbanas/prj/PyBERT/src',\n", + " '/Users/dbanas/prj/PyBERT/PyAMI/src']\n", + "PyBERT version: 4.1.1\n", + "\tat: /Users/dbanas/prj/PyBERT/src/pybert/__init__.py\n", + "NumPy version: 1.23.5\n", + "\tat: /Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages/numpy/__init__.py\n", + "SciPy version: 1.11.1\n", + "\tat: /Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages/scipy/__init__.py\n", + "SciKit-RF version: 0.26.0\n", + "\tat: /Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages/skrf/__init__.py\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "\n", + "import sys\n", + "import pprint\n", + "\n", + "print(f\"Python executable: {sys.executable}\")\n", + "print(f\"Python exec_prefix: {sys.exec_prefix}\")\n", + "print(f\"Python prefix: {sys.prefix}\")\n", + "print(\"Python import search path:\")\n", + "pprint.pp(sys.path)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import scipy as sp\n", + "import scipy.signal as sig\n", + "import skrf as rf\n", + "\n", + "import pybert as pb\n", + "\n", + "from pybert.pybert import PyBERT\n", + "from pybert.models.bert import my_run_simulation\n", + "from pybert.utility import calc_eye, find_crossings, calc_jitter, gaus_pdf\n", + "print(f\"PyBERT version: {pb.__version__}\")\n", + "print(f\"\\tat: {pb.__file__}\")\n", + "\n", + "print(f\"NumPy version: {np.__version__}\")\n", + "print(f\"\\tat: {np.__file__}\")\n", + "\n", + "print(f\"SciPy version: {sp.__version__}\")\n", + "print(f\"\\tat: {sp.__file__}\")\n", + "\n", + "print(f\"SciKit-RF version: {rf.__version__}\")\n", + "print(f\"\\tat: {rf.__file__}\")\n", + "\n", + "plt.rcParams['figure.figsize'] = [9, 6]\n" + ] + }, + { + "cell_type": "markdown", + "id": "faa1023b", + "metadata": {}, + "source": [ + "### PyBERT Instantiation & Initialization\n", + "\n", + "Now, we'll get our PyBERT instance loaded and initialized." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "57476dcf", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:45:34.523876Z", + "start_time": "2023-09-04T14:45:28.575782Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "PyBERT Console Log\n", + "\n", + "[2023-09-04 10:45:28.578490]: PyBERT: Started.\n", + "[2023-09-04 10:45:28.578502]: PyBERT: System: Darwin 21.6.0\n", + "[2023-09-04 10:45:28.578505]: PyBERT: Python Version: 3.9.16\n", + "[2023-09-04 10:45:28.578508]: PyBERT: PyBERT Version: 4.1.1\n", + "[2023-09-04 10:45:28.578509]: PyBERT: PyAMI Version: 4.1.0\n", + "[2023-09-04 10:45:28.578513]: PyBERT: GUI Toolkit: qt4\n", + "[2023-09-04 10:45:28.578515]: PyBERT: Kiva Backend: image\n", + "\n", + "UI: 100.0 ps\n", + "Nspb: 32\n", + "Channel length: 0.5 m\n", + "Channel ISI: 42.514375283512265 ps\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Instantiate a PyBERT object and change any defaults as required.\n", + "myPyBERT = PyBERT(run_simulation=False, # Need to adjust some properties first.\n", + " gui=False) # Don't run stand-alone; we're in a notebook.\n", + "# myPyBERT.debug = True # Uncomment to debug.\n", + "# myPyBERT.l_ch = 0.1 # The default (1 m) channel length causes an error.\n", + "# myPyBERT.pn_freq = 10 # (MHz)\n", + "# myPyBERT.nbits = 15000\n", + "# myPyBERT.eye_bits = 10160 # 254 * 40\n", + "\n", + "# Run the simulation and print out the resultant log for sanity checking.\n", + "my_run_simulation(myPyBERT,\n", + " initial_run=True, # PyBERT does some \"housekeeping\" the first time through, which shouldn't be repeated.\n", + " update_plots=False) # We'll do our own plotting, here in this notebook.\n", + "print(myPyBERT.console_log)\n", + "\n", + "# Grab some resultant data needed below.\n", + "ui = myPyBERT.ui # unit interval\n", + "nspb = myPyBERT.nspb # samples per bit\n", + "t = myPyBERT.t # simulation time vector\n", + "Ts = t[1] # simulation sample interval\n", + "nbits = myPyBERT.nbits # number of bits simulated\n", + "eye_bits = myPyBERT.eye_bits # number of bits to use for eye plotting.\n", + "eye_uis = myPyBERT.eye_uis # number of UIs to use for eye plotting.\n", + "ch_s = myPyBERT.chnl_s # channel step response\n", + "\n", + "print(f\"UI: {ui*1e12:5.1f} ps\")\n", + "print(f\"Nspb: {nspb}\")\n", + "print(f\"Channel length: {myPyBERT.l_ch} m\")\n", + "print(f\"Channel ISI: {myPyBERT.isi_chnl*1e12} ps\")\n", + "\n", + "plt.plot(t[:len(ch_s)]*1e12, ch_s)\n", + "plt.title(\"Channel Step Response - Default Settings\")\n", + "plt.xlabel(\"Time (ps)\")\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "7edc3f06", + "metadata": {}, + "source": [ + "### Sanity Check of PyBERT Jitter Analysis\n", + "\n", + "Now, let's make sure the PyBERT jitter analysis behaves in a reasonable way.\n", + "We'll do that by varying the:\n", + "\n", + "1. channel length (Should affect ISI.),\n", + "1. periodic noise level (Should affect _Pj_.), and\n", + "1. random noise level (Should affect _Rj_.).\n", + "\n", + "For consistency, we'll look at the jitter in the _Rx input_, as that is the first point in the signal flow where _Pj_ and _Rj_ are introduced.\n", + "\n", + "**Note:** We don't concern ourselves with DCD, because the PyBERT native Tx model doesn't include any output drive asymmetry.\n", + "(You can model this sort of asymmetry, using IBIS-AMI models, instead of PyBERT's native model.)" + ] + }, + { + "cell_type": "markdown", + "id": "697267e1", + "metadata": {}, + "source": [ + "#### Channel Length Variation (ISI)\n", + "\n", + "Here, we'll vary the channel length, to see its effect on the 3 jitter components.\n", + "We'll also plot the spectrum of the _total_ and _data independent_ jitter, which will enable us to do some sanity checking of our decomposition/analysis algorithm." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "f7c28f3c", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:45:46.596241Z", + "start_time": "2023-09-04T14:45:34.524750Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel length: 0.1 m; ISI: 4.0 ps; Pj: 0.0 ps; Rj: 0.0 ps.\n", + "Channel length: 0.2 m; ISI: 8.9 ps; Pj: 0.0 ps; Rj: 0.0 ps.\n", + "Channel length: 0.5 m; ISI: 33.5 ps; Pj: 0.0 ps; Rj: 0.0 ps.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.pn_mag = 0\n", + "myPyBERT.rn = 0\n", + "for l_ch in [0.1, 0.2, 0.5]:\n", + " myPyBERT.l_ch = l_ch\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " print(f\"Channel length: {l_ch:3.1f} m; ISI: {myPyBERT.isi_tx*1e12:5.1f} ps; Pj: {myPyBERT.pj_tx*1e12:5.1f} ps; Rj: {myPyBERT.rj_tx*1e12:5.1f} ps.\")\n", + " plt.semilogx(myPyBERT.f_MHz[:len(myPyBERT.jitter_spectrum_tx)], 20*np.log10(np.abs(myPyBERT.jitter_spectrum_tx)), label=f\"ChLen={l_ch:3.1}-Total\")\n", + " plt.semilogx(myPyBERT.f_MHz[:len(myPyBERT.jitter_ind_spectrum_tx)], 20*np.log10(np.abs(myPyBERT.jitter_ind_spectrum_tx)), label=f\"ChLen={l_ch:3.1}-Independent\")\n", + "plt.title(\"Jitter Spectrum vs. Channel Length (m)\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.ylabel(\"|H(f)| (dB)\")\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "65e06623", + "metadata": {}, + "source": [ + "All is as we expect:\n", + "\n", + "1. ISI increases monotonically with channel length.\n", + "\n", + "1. Pj is unaffected by channel length when no periodic noise exists.\n", + "\n", + "1. Rj is unaffected by channel length when no random noise exists.\n", + "\n", + "1. The jitter spectrum baseline rises with channel length and the total jitter has more spectral energy than just the data independent portion.\n", + "\n", + "1. The harmonics of the bit pattern repetition frequency (approx. 80 MHz in this case) are dramatically diminished in the data independent case, due to the separation of data dependent and data independent jitter, via averaging.\n", + "Where we do see them, they are spaced half the pattern repetition frequency (approx. 40 MHz) apart, due to the way we do TIE averaging.\n", + "(We're forced to double the pattern, to cope with the needs of the duobinary and PAM-4 modulation schemes.)\n" + ] + }, + { + "cell_type": "markdown", + "id": "3e14949c", + "metadata": {}, + "source": [ + "#### Periodic Noise Variation\n", + "\n", + "Here, we vary the amount of periodic noise added to the signal and see its effects on jitter analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e29c72f9", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:46:01.764363Z", + "start_time": "2023-09-04T14:45:46.597773Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Periodic noise: 0.0 V; ISI: 8.9 ps; Pj: 0.0 ps; Rj: 0.0 ps.\n", + "Periodic noise: 0.1 V; ISI: 9.1 ps; Pj: 5.1 ps; Rj: 1.4 ps.\n", + "Periodic noise: 0.2 V; ISI: 9.4 ps; Pj: 11.2 ps; Rj: 1.3 ps.\n", + "Periodic noise: 0.3 V; ISI: 9.8 ps; Pj: 17.3 ps; Rj: 1.0 ps.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.l_ch = 0.2 # (m)\n", + "\n", + "for pn_mag in [0.0, 0.1, 0.2, 0.3]:\n", + " myPyBERT.pn_mag = pn_mag\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " print(f\"Periodic noise: {pn_mag:3.1f} V; ISI: {myPyBERT.isi_tx*1e12:5.1f} ps; Pj: {myPyBERT.pj_tx*1e12:5.1f} ps; Rj: {myPyBERT.rj_tx*1e12:5.1f} ps.\")\n", + " plt.plot(myPyBERT.f/1e6, np.abs(np.fft.fft(myPyBERT.rx_in))[:len(myPyBERT.f)], label=f\"Pn={pn_mag}\")\n", + "\n", + "plt.title(\"Rx Input Signal Spectrum vs. Periodic Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.text(80, 20100, \"PRBS repetition frequency and second harmonic\")\n", + "plt.text(15, 23000, \"Periodic noise - fundamental\")\n", + "plt.text(30, 8000, \"Periodic noise - 3rd harmonic\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1ec27721", + "metadata": {}, + "source": [ + "Note the following in the plot above:\n", + "\n", + "1. There is no variation with _Pn_ in the magnitude of the spikes at approximately 80 and 160 MHz.\n", + "That's because they represent the PRBS pattern repetition frequency, which is unaffected by periodic noise.\n", + "\n", + "1. In the remaining spikes, the spectral energy varies as expected: increasing w/ increasing values of _Pn_.\n", + "\n", + "1. Only the odd harmonics are present (i.e. - 10, 30, 50, etc. MHz), because the periodic noise is only a slight modification of a square wave.\n", + "\n", + "Alright, the _signal_ spectrum looks correct; let's look at the _jitter_ spectrum." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "48eb4dc1", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:46:16.848478Z", + "start_time": "2023-09-04T14:46:01.765194Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/pf/9gjf96y54f55tdz0vt0wq4kh0000gn/T/ipykernel_1812/894700243.py:3: RuntimeWarning: divide by zero encountered in log10\n", + " return 20*np.log10(np.abs(x))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def dB(x):\n", + " \"Return magnitude of input vector in dB.\"\n", + " return 20*np.log10(np.abs(x))\n", + "\n", + "for (pn_mag, clr) in [(0.0, 'r'), (0.1, 'g'), (0.2, 'b'), (0.3, 'k')]:\n", + " myPyBERT.pn_mag = pn_mag\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " f_MHz = myPyBERT.f_MHz[:len(myPyBERT.jitter_spectrum_tx)]\n", + " plt.figure(1)\n", + " plt.plot(f_MHz, dB(myPyBERT.jitter_spectrum_tx), clr, label=f\"Pn={pn_mag}\")\n", + " plt.figure(2)\n", + " plt.plot(f_MHz, dB(myPyBERT.jitter_ind_spectrum_tx), clr, label=f\"Pn={pn_mag}\")\n", + " plt.plot(f_MHz, dB(myPyBERT.thresh_tx), clr+'--')\n", + "\n", + "plt.figure(1)\n", + "plt.title(\"Rx Input Total Jitter Spectrum vs. Periodic Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "plt.figure(2)\n", + "plt.title(\"Rx Input Data Independent Jitter Spectrum vs. Periodic Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "f4d386a4", + "metadata": {}, + "source": [ + "The spikes approximately 10 MHz to either side of the second harmonic of the pattern repetition frequency (i.e - approx. 160 MHz) are interesting.\n", + "They look like modulation products of the 10 MHz periodic noise fundamental on the second harmonic \"carrier\".\n", + "But, there's no explicit _mixing_ occurring in this portion of the PyBERT code.\n", + "The relationship between vertical noise and jitter is nonlinear.\n", + "I wonder if we're triggering that nonlinear behavior sufficiently to produce modulation.\n", + "I wouldn't have guessed so.\n", + "\n", + "Where are the odd harmonics of the Pn frequency?!\n", + "I guess that actually makes sense, as the periodic additive noise (because it's very nearly a square wave) shifts the signal up and down.\n", + "But, the affect on jitter of an upward lift and a downward push are the same: both lengthen one half cycle while shortening the other.\n", + "That would explain why we see a spike at 20 MHz (twice the periodic noise frequency).\n", + "But, why is its magnitude so low and where are its harmonics?\n", + "\n", + "Before moving on, let's test our modulation theory, by just changing the frequency of the periodic noise from 10 to 15 MHz, leaving everything else unchanged." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "290d0d90", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:46:20.669016Z", + "start_time": "2023-09-04T14:46:16.849419Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.pn_freq = 15\n", + "my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + "\n", + "f_MHz = myPyBERT.f_MHz[:len(myPyBERT.jitter_spectrum_tx)]\n", + "plt.subplot(211)\n", + "plt.plot(f_MHz, dB(myPyBERT.jitter_spectrum_tx), 'k')\n", + "plt.subplot(212)\n", + "plt.plot(f_MHz, dB(myPyBERT.jitter_spectrum_tx), 'k')\n", + "\n", + "plt.subplot(211)\n", + "plt.title(\"Rx Input Total Jitter Spectrum - Pn = 0.3\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.grid()\n", + "\n", + "plt.subplot(212)\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.text(150, -174, \"PRBS Repetition Freq. - 2nd Harm.\")\n", + "plt.text(141, -180, \"-15 MHz Mod. Prod.\")\n", + "plt.text(170, -180, \"+15 MHz Mod. Prod.\")\n", + "plt.axis(xmin=140, xmax=180, ymin=-200, ymax=-170)\n", + "plt.grid()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "e15a3e3e", + "metadata": {}, + "source": [ + "Okay, it definitely appears to be modulation of the PRBS repetition frequency second harmonic by the periodic noise source.\n", + "Interesting!" + ] + }, + { + "cell_type": "markdown", + "id": "e9a45258", + "metadata": {}, + "source": [ + "#### Random Noise Variation\n", + "\n", + "Here, we vary the amount of random noise added to the signal and see its effects on jitter analysis." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "71df9f48", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:46:36.185522Z", + "start_time": "2023-09-04T14:46:20.669833Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Random noise: 0.0 V; ISI: 33.5 ps; Pj: 0.0 ps; Rj: 0.0 ps.\n", + "Random noise: 0.1 V; ISI: 33.5 ps; Pj: 0.0 ps; Rj: 1.6 ps.\n", + "Random noise: 0.2 V; ISI: 34.5 ps; Pj: 0.0 ps; Rj: 2.6 ps.\n", + "Random noise: 0.3 V; ISI: 34.3 ps; Pj: 0.0 ps; Rj: 3.8 ps.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.l_ch = 0.5 # (m)\n", + "myPyBERT.pn_mag = 0\n", + "myPyBERT.pn_freq = 10\n", + "myPyBERT.thresh = 6\n", + "\n", + "for rn in [0.0, 0.1, 0.2, 0.3]:\n", + " myPyBERT.rn = rn\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " print(f\"Random noise: {rn:3.1f} V; ISI: {myPyBERT.isi_tx*1e12:5.1f} ps; Pj: {myPyBERT.pj_tx*1e12:5.1f} ps; Rj: {myPyBERT.rj_tx*1e12:5.1f} ps.\")\n", + " plt.plot(myPyBERT.f/1e6, np.abs(np.fft.fft(myPyBERT.rx_in))[:len(myPyBERT.f)], label=f\"Rn={rn}\")\n", + "\n", + "plt.title(\"Rx Input Signal Spectrum vs. Random Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.text(82, 900, \"PRBS repetition frequency and 2nd harmonic\")\n", + "plt.axis(xmin=0, xmax=200, ymin=0, ymax=1000)\n", + "plt.legend()\n", + "plt.grid()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "0c2a6846", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:46:51.570811Z", + "start_time": "2023-09-04T14:46:36.186415Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/pf/9gjf96y54f55tdz0vt0wq4kh0000gn/T/ipykernel_1812/894700243.py:3: RuntimeWarning: divide by zero encountered in log10\n", + " return 20*np.log10(np.abs(x))\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for (rn, clr) in [(0.0, 'r'), (0.1, 'g'), (0.2, 'b'), (0.3, 'k')]:\n", + " myPyBERT.rn = rn\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " f_MHz = myPyBERT.f_MHz[:len(myPyBERT.jitter_spectrum_tx)]\n", + " plt.figure(1)\n", + " plt.plot(f_MHz, dB(myPyBERT.jitter_spectrum_tx), clr, label=f\"Rn={rn}\")\n", + " plt.figure(2)\n", + " plt.plot(f_MHz, dB(myPyBERT.jitter_ind_spectrum_tx), clr, label=f\"Rn={rn}\")\n", + " plt.plot(f_MHz, dB(myPyBERT.thresh_tx), clr+'--')\n", + "\n", + "plt.figure(1)\n", + "plt.title(\"Rx Input Total Jitter Spectrum vs. Random Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "plt.figure(2)\n", + "plt.title(\"Rx Input Data Independent Jitter Spectrum vs. Random Noise\")\n", + "plt.xlabel(\"Frequency (MHz)\")\n", + "plt.axis(xmin=0, xmax=200)\n", + "plt.legend()\n", + "plt.grid()\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "52c230aa", + "metadata": {}, + "source": [ + "Where are those large spikes at half the pattern repetition frequency coming from?\n", + "Clearly it's got something to do w/ my doubling of the effective pattern length before averaging, but what?" + ] + }, + { + "cell_type": "markdown", + "id": "919b1a65", + "metadata": {}, + "source": [ + "### Post-DFE Jitter\n", + "\n", + "Let's check the jitter at the end of the signal processing chain, after the DFE, as we sweep the channel length.\n", + "\n", + "We'll print the Rx input and post-CTLE jitter numbers, as well, so we can see what affect each step in the signal processing chain has on the various jitter components.\n", + "\n", + "This time, we'll include some periodic and random noise, so we can see how increasing the channel length exaggerates the periodic and random jitter even though the magnitude of those noise sources remains constant.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "adbe2b14", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:47:03.371707Z", + "start_time": "2023-09-04T14:46:51.571744Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel length: 0.1 m\n", + "\tStage\t\tISI (ps)\tPj (ps)\t\tRj (ps)\n", + "\t-------------------------------------------------------\n", + "\tRx In\t\t 5.7\t\t 0.0\t\t 2.8\n", + "\tCTLE Out\t 4.8\t\t 0.0\t\t 2.8\n", + "\tDFE Out\t\t 4.9\t\t 0.0\t\t 2.7\n", + "\n", + "Channel length: 0.2 m\n", + "\tStage\t\tISI (ps)\tPj (ps)\t\tRj (ps)\n", + "\t-------------------------------------------------------\n", + "\tRx In\t\t 9.9\t\t 1.0\t\t 3.1\n", + "\tCTLE Out\t 8.6\t\t 1.0\t\t 3.1\n", + "\tDFE Out\t\t 6.7\t\t 0.0\t\t 3.0\n", + "\n", + "Channel length: 0.5 m\n", + "\tStage\t\tISI (ps)\tPj (ps)\t\tRj (ps)\n", + "\t-------------------------------------------------------\n", + "\tRx In\t\t 35.4\t\t 10.2\t\t 1.0\n", + "\tCTLE Out\t 32.2\t\t 9.2\t\t 1.0\n", + "\tDFE Out\t\t 12.1\t\t 0.0\t\t 4.9\n", + "\n" + ] + } + ], + "source": [ + "myPyBERT.pn_mag = 0.1\n", + "myPyBERT.rn = 0.3\n", + "for l_ch in [0.1, 0.2, 0.5]:\n", + " myPyBERT.l_ch = l_ch\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " print(f\"Channel length: {l_ch:3.1f} m\")\n", + " print(\"\\tStage\\t\\tISI (ps)\\tPj (ps)\\t\\tRj (ps)\")\n", + " print(\"\\t-------------------------------------------------------\")\n", + " print(f\"\\tRx In\\t\\t{myPyBERT.isi_tx*1e12:5.1f}\\t\\t{myPyBERT.pj_tx*1e12:5.1f}\\t\\t{myPyBERT.rj_tx*1e12:5.1f}\")\n", + " print(f\"\\tCTLE Out\\t{myPyBERT.isi_ctle*1e12:5.1f}\\t\\t{myPyBERT.pj_ctle*1e12:5.1f}\\t\\t{myPyBERT.rj_ctle*1e12:5.1f}\")\n", + " print(f\"\\tDFE Out\\t\\t{myPyBERT.isi_dfe*1e12:5.1f}\\t\\t{myPyBERT.pj_dfe*1e12:5.1f}\\t\\t{myPyBERT.rj_dfe*1e12:5.1f}\")\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "94a5adca", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-05T10:34:01.763235Z", + "start_time": "2023-09-05T10:33:52.045757Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.pn_freq = 10\n", + "myPyBERT.pn_mag = 0.1\n", + "myPyBERT.rn = 0.3\n", + "myPyBERT.l_ch = 0.5\n", + "for sum_ideal in [True, False]:\n", + " myPyBERT.sum_ideal = sum_ideal\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " plt.plot(np.diff(np.sign(np.diff(myPyBERT.jitter_ext_dfe))), label=f\"Ideal = {sum_ideal}\")\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "8383f441", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-05T10:30:38.184742Z", + "start_time": "2023-09-05T10:30:05.271293Z" + }, + "scrolled": false + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "myPyBERT.pn_mag = 0.1\n", + "myPyBERT.rn = 0.3\n", + "myPyBERT.l_ch = 0.5\n", + "myPyBERT.sum_ideal = False\n", + "pjs = []\n", + "pn_freqs = [1, 2, 5, 10, 20, 50]\n", + "for pn_freq in pn_freqs:\n", + " myPyBERT.pn_freq = pn_freq\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " pjs.append(myPyBERT.pj_dfe*1e12)\n", + "plt.plot(pn_freqs, pjs)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "78d1ba7a", + "metadata": {}, + "source": [ + "Several things are evident from the data above:\n", + "\n", + "1. Increasing the channel length increases the periodic and random jitter, even though the magnitudes of the periodic and random noise sources remain constant.\n", + "\n", + " - This makes sense, since the degree of mapping from vertical noise to jitter is inversely proportional to the slope of the signal transition edges and a longer channel tends to reduce that slope, due to its lower bandwidth.\n", + " \n", + "1. The DFE is a powerful ally in reducing all jitter components, particularly for longer channels." + ] + }, + { + "cell_type": "markdown", + "id": "3e0830a7", + "metadata": {}, + "source": [ + "### Curve Fitter Estimates of Pj\n", + "\n", + "Just out of curiosity, I want to look at how the curve fitter estimates of _Pj_ compare to what I'm actually reporting, which is just the measurement of the separation between the two peaks in the smoothed histogram of the data independent jitter.\n", + "\n", + "The curve fitter returns both the standard deviation and the mean of the Gaussian PDF that best fits the data.\n", + "And the difference between the two means _should_ be equal to Pj (i.e. - to our measurement of peak separation).\n", + "\n", + "As above, all numbers are given in units of ps.\n", + "\n", + "**Note:** The `dd_soltn` tuple is being passed back through a temporary debugging channel created specifically to aid in transitioning to dual Dirac Pj/Rj estimation.\n", + "For that reason, it may only apply to one point in the signal processing flow at a time (i.e. - channel, Tx, CTLE, or DFE)." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3ed28ba5", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:47:48.472341Z", + "start_time": "2023-09-04T14:47:36.755082Z" + }, + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel length: 0.1 m\n", + "\tStage\t\tPj_meas.\tPj_est.\n", + "\t---------------------------------------\n", + "\tTx\t\t 0.0\t\t 1.2\n", + "\n", + "Channel length: 0.2 m\n", + "\tStage\t\tPj_meas.\tPj_est.\n", + "\t---------------------------------------\n", + "\tTx\t\t 1.0\t\t 1.9\n", + "\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages/scipy/optimize/_minpack_py.py:488: RuntimeWarning: overflow encountered in matmul\n", + " cov_x = invR @ invR.T\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Channel length: 0.5 m\n", + "\tStage\t\tPj_meas.\tPj_est.\n", + "\t---------------------------------------\n", + "\tTx\t\t 10.2\t\t 0.0\n", + "\n" + ] + } + ], + "source": [ + "for l_ch in [0.1, 0.2, 0.5]:\n", + " myPyBERT.l_ch = l_ch\n", + " my_run_simulation(myPyBERT, initial_run=False, update_plots=False)\n", + " mu_pos, sigma_pos, err_pos, mu_neg, sigma_neg, err_neg = myPyBERT.dd_soltn\n", + " print(f\"Channel length: {l_ch:3.1f} m\")\n", + " print(\"\\tStage\\t\\tPj_meas.\\tPj_est.\")\n", + " print(\"\\t---------------------------------------\")\n", + " print(f\"\\tTx\\t\\t{myPyBERT.pj_tx*1e12:5.1f}\\t\\t{(mu_pos - mu_neg)*1e12:5.1f}\")\n", + " print(\"\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "5443d6ce", + "metadata": {}, + "source": [ + "Hmmm, something's not right.\n", + "Let's look at the actual jitter distribution..." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "5226f183", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-04T14:48:02.081483Z", + "start_time": "2023-09-04T14:48:01.970029Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(myPyBERT.tie_ind_tx, bins=100, histtype=\"step\", density=True, label=\"Raw\")\n", + "plt.plot(myPyBERT.centers, myPyBERT.hist_ind_smooth, label=\"Smoothed\")\n", + "plt.title(\"Histogram of Rx Input Data-Independent Jitter\")\n", + "plt.xlabel(\"Jitter (s)\")\n", + "plt.grid()\n", + "plt.legend()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "1aab7cf1", + "metadata": {}, + "source": [ + "The smoothed histogram agrees with the _Pj_meas._ number, which is what I'm reporting in PyBERT, now.\n", + "I guess the curve fit to the bottom half of the tail can't really be expected to accurately locate the peaks, since the curve isn't Gaussian in that region (i.e. - near the peaks), due to the \"pollution\" of the distribution by the periodic jitter there." + ] + }, + { + "cell_type": "markdown", + "id": "ff0cefd8", + "metadata": {}, + "source": [ + "## Concluding Remarks\n", + "\n", + "1. In general, the new \"dual Dirac\" algorithm for Pj/Rj separation seems to be performing correctly.\n", + "However, I'll wait for expert review of the new code, before merging it into the main development branch.\n", + "\n", + "1. The modulation effect on the second harmonic of the PRBS repetition frequency by the periodic noise is very interesting.\n", + "It's not completely unexpected, since the mapping from vertical perturbation to jitter is _not_ completely linear.\n", + "And this non-linearity gets more pronounced with increasing vertical disturbance.\n", + "So, it makes sense that it is showing up most noticeably for greatest periodic noise magnitude.\n", + "\n", + "1. The strong spectral spikes at half the PRBS pattern repetition frequency in the data independent jitter spectrum for the zero noise case are also very interestng.\n", + "They clearly are related to the pattern doubling I'm doing before averaging (to accomodate _duobinary_ and PAM-4 modulation schemes), but how exactly?\n", + "Obviously, they require a pristine zero noise environment in order to manifest.\n", + "So, they aren't affecting our results materially.\n", + "Still, though, rather interesting." + ] + }, + { + "cell_type": "markdown", + "id": "8f1948b0", + "metadata": {}, + "source": [ + "## Appendix A - Gaussian Sigma vs. RMS\n", + "\n", + "It is well known that the _variance_ of a zero-mean Gaussian random process is equal to the _average power_ of that same process.\n", + "For a zero mean voltage noise process (actually, _any_ square law process) with Gaussian distribution this implies that the _standard deviation_ of that process is equal to the _root mean square_ (RMS) value of the process.\n", + "And this approach to estimating the standard deviation in the random jitter of a serial data stream appears to be more accurate than the tail fitting of the _dual Dirac_ approach, according to Ransom Stephens.\n", + "(See the last paragraph on p.5 of [1].)\n", + "\n", + "Here, we just confirm this assertion, using a simple Python simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "id": "2b62935f", + "metadata": { + "ExecuteTime": { + "end_time": "2023-09-23T19:43:53.584604Z", + "start_time": "2023-09-23T19:43:53.547842Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sigma: 0.01; RMS: 0.01\n", + "sigma: 0.02; RMS: 0.02\n", + "sigma: 0.05; RMS: 0.05\n", + "sigma: 0.10; RMS: 0.10\n", + "sigma: 0.20; RMS: 0.20\n", + "sigma: 0.50; RMS: 0.50\n" + ] + } + ], + "source": [ + "from scipy.stats import norm\n", + "\n", + "for sigma in [0.01, 0.02, 0.05, 0.1, 0.2, 0.5]:\n", + " r = norm(scale=sigma).rvs(size=100000)\n", + " print(f\"sigma: {sigma:4.2f}; RMS: {np.std(r):4.2f}\")\n" + ] + }, + { + "cell_type": "markdown", + "id": "e4ff64a5", + "metadata": {}, + "source": [ + "And, indeed, the assertion is confirmed." + ] + }, + { + "cell_type": "markdown", + "id": "3e65e1a9", + "metadata": {}, + "source": [ + "## References\n", + "\n", + "1. [Stephens, R., _Jitter Analysis: The dual-Dirac Model, RJ/DJ, and Q-Scale_, Agilent white paper, 2004](https://www.keysight.com/us/en/assets/7018-01309/white-papers/5989-3206.pdf)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4c58961c", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.16" + }, + "toc": { + "base_numbering": 1, + "nav_menu": {}, + "number_sections": true, + "sideBar": true, + "skip_h1_title": true, + "title_cell": "Table of Contents", + "title_sidebar": "Contents", + "toc_cell": true, + "toc_position": { + "height": "calc(100% - 180px)", + "left": "10px", + "top": "150px", + "width": "272.255432px" + }, + "toc_section_display": true, + "toc_window_display": true + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/misc/scikit-rf/S-param Check.ipynb b/misc/scikit-rf/S-param Check.ipynb index ce24655..9d862a8 100644 --- a/misc/scikit-rf/S-param Check.ipynb +++ b/misc/scikit-rf/S-param Check.ipynb @@ -33,13 +33,18 @@ }, { "cell_type": "code", - "execution_count": 27, - "metadata": {}, + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:24:39.194486Z", + "start_time": "2023-08-03T01:24:38.686398Z" + } + }, "outputs": [ { "data": { "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -85,42 +90,39 @@ }, { "cell_type": "code", - "execution_count": 3, - "metadata": {}, + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:24:45.820744Z", + "start_time": "2023-08-03T01:24:45.643904Z" + } + }, "outputs": [ { - "name": "stderr", + "name": "stdout", "output_type": "stream", "text": [ - "/home/david/miniconda3/lib/python3.8/site-packages/numpy/core/_asarray.py:102: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - "/home/david/miniconda3/lib/python3.8/site-packages/numpy/core/_asarray.py:102: ComplexWarning: Casting complex values to real discards the imaginary part\n", - " return array(a, dtype, copy=False, order=order)\n", - ":45: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " plt.subplot(121)\n", - ":52: MatplotlibDeprecationWarning: Adding an axes using the same arguments as a previous axes currently reuses the earlier instance. In a future version, a new instance will always be created and returned. Meanwhile, this warning can be suppressed, and the future behavior ensured, by passing a unique label to each axes instance.\n", - " plt.subplot(122)\n" + "Channel Passive \n", + "_____________________\n", + " via True \n" ] }, { - "name": "stdout", + "name": "stderr", "output_type": "stream", "text": [ - "Channel Passive \n", - "_____________________\n", - " se False \n" + "/Users/dbanas/miniconda3/envs/pybert/lib/python3.9/site-packages/matplotlib/cbook/__init__.py:1335: ComplexWarning: Casting complex values to real discards the imaginary part\n", + " return np.asarray(x, float)\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -131,7 +133,7 @@ "# chnls.append(('ch2', rf.Network('../channels/802.3bj_COM_Cisco/kochuparambil_3bj_02_0913/Beth_shortReflective_THRU.s4p')))\n", "# chnls.append(('ch5', rf.Network('../channels/shanbhag_01_0511/TEC_Whisper27in_THRU_G14G15.s4p')))\n", "# chnls.append(('se', rf.Network('../Support/DoriItzhaki/tx_se.s4p')))\n", - "chnls.append(('se', rf.Network('/tools/synopsys/dw/xsr/database/model_files/tx_typ.s4p')))\n", + "chnls.append(('via', rf.Network('/Users/dbanas/Documents/Keysight/CustomerSupport/Fortinet/Via_Void_36.5_LinSweep.s4p')))\n", "\n", "# Create diagonal mask, for checking passivity, below.\n", "n = chnls[0][1]\n", @@ -188,21 +190,23 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:24:55.057192Z", + "start_time": "2023-08-03T01:24:54.849614Z" + }, "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSsAAALACAYAAAB7FifqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABleklEQVR4nO3debxXdZ0/8NeXy+Wyg4hsirjllpXmFrYAlrjMaLk1jWVSWlONU+pMtk0FTWb1a3EabXEsl7JlrLRJTaGSMrfIZUotcsEVEFEEAYUL9/v743SBKxf4fuHe+/3ee5/Px+M8zvme7znn+/5e4R59+f6cT6lcLpcDAAAAAFBjfWpdAAAAAABAIqwEAAAAAOqEsBIAAAAAqAvCSgAAAACgLggrAQAAAIC6IKwEAAAAAOqCsBIAAAAAqAvCSgAAAACgLggrAQAAAIC6IKwEAGCr3HHHHTn++OOz8847p6mpKaNHj87EiRPzr//6r+uOmTx5ckqlUkqlUvr06ZMhQ4Zkjz32yMknn5wf//jHaWlp2ei6u+yyS5tzhg0bln322SfvfOc7M3PmzI2Onz179rrjS6VS/vCHP6x776c//Wn+8R//MXvssUcGDBiQXXbZJW9/+9vzwAMPVPQdn3jiiZx11lmZNGlShg8fnlKplMsuu6zdY/fff/91Nfz93/99RdcHAKAtYSUAAFW77rrrcthhh2XZsmX54he/mJkzZ+Y///M/89rXvjY/+tGP2hy722675bbbbsutt96aa665Jh/96Efzwgsv5OSTT87kyZOzdOnSja7/2te+dt05P/nJT3LmmWdm3rx5OfLII3PSSSelubl5o3Muuuii3Hbbbdlnn33W7fvCF76QlStX5hOf+ERuuOGGfPazn83dd9+dV7/61bnvvvu2+D0ffPDBXHnllenXr1+OOeaYzR773e9+N7fddlvGjBmzxesCANC+UrlcLte6CAAAupdJkyblySefzF/+8pf07du3zXstLS3p06f4f+KTJ0/O4sWLc++99250jUsvvTTvfve789a3vrVNwLnLLrtkv/32y7XXXrvROdOnT8+MGTNy7rnn5gtf+EKSorNyypQpuemmmzJ58uQ2xy9atCijRo1qs2/+/PnZZZdd8s53vjOXXHLJZr/nht/lD3/4Qw4++OBceumlmTZt2ibP2Vz9AABsns5KAACq9swzz2TkyJEbBZVJ1oV7W/Kud70rxxxzTK666qo8+uijFZ0zffr0vPzlL8+FF16YF198cYvHvzSoTJJx48Zlp512yuOPP77F8yv9LgAAdAz/9gUAQNUmTpyYO+64Ix/84Adzxx13tDssuxLHHXdcyuVybr755orPOfbYY7Ny5co2z6asxsMPP5xHH300L3/5y7fqfAAAOo+wEgCAqn3+85/P6173uvzXf/1XXvOa12TQoEF57Wtfm89//vNZvnx5xdeZMGFCkmJodmee02rNmjU5/fTTM3jw4Jx99tlVnw8AQOcSVgIAULXtt98+N998c+bMmZPPf/7zefOb35y//vWv+djHPpZXvOIVWbx4cUXX2ZrHp2/tI9fL5XJOP/303Hzzzbniiisyfvz4rboOAACdR1gJAMBWO+igg/KRj3wkV111VebPn5+zzz47jzzySL74xS9WdH7rsyrHjRtX8WduzTnlcjlnnHFGvve97+Wyyy7Lm9/85orPBQCg6wgrAQDoEI2Njfn0pz+dJO3O/t2e//3f/02pVMob3vCGio4vl8v5+c9/nkGDBuWggw6q+Jwzzjgjl156aS655JK84x3vqOg8AAC6nrASAICqLViwoN39f/7zn5NU1vV46aWX5he/+EX+8R//MTvvvHNFnztjxozcf//9+dCHPpT+/ftv8fhyuZz3vOc9ufTSS/Otb30r73rXuyr6HAAAaqNvrQsAAKD7OfLII7PTTjvl2GOPzd57752Wlpbcc889+fKXv5zBgwfnQx/60LpjX3jhhdx+++3rth9++OFcc801ufbaazNp0qR885vf3Oj6zz333LpzVqxYkblz5+aHP/xhbr755rz1rW/NjBkzKqrzgx/8YL797W/n3e9+d17xilesu2aSNDU15YADDlj3evr06ZkxY0ZuuummTJ48ed3+H//4x0mKWcST5A9/+EMGDx6cJDnppJMqqgMAgMoIKwEAqNq///u/52c/+1m++tWvZsGCBVm1alXGjh2bN73pTfnYxz6WffbZZ92xDz/8cCZOnJgkGTRoUEaPHp1Xv/rVueqqq3LCCSekT5+NB/vccsstmThxYkqlUgYNGpQdd9wxhxxySP793/89U6dOrbjOn//850mS73znO/nOd77T5r0JEybkkUceWfd6+fLlKZVKGTNmTJvjTj755DavL7roolx00UVJtn6yHwAA2iesBACgam9961vz1re+dYvHzZ49u+prbxggVmPt2rVZs2ZN+vZd/6+41Vzrt7/9bU488cTsvffebfZXGkiuXbtWeAkAsI08sxIAgB7hTW96UxobG/OHP/yh6nOXLVuW//u//8tnPvOZrf78Aw88MI2NjetmKwcAoHqlsv/9CwBAN/b8889n7ty5617vu+++GThwYJfXcf/992flypVJkuHDh2ePPfbo8hoAALo7YSUAAAAAUBcMAwcAAAAA6oKwEgAAAACoC8JKAAAAAKAu9K11Ad1BS0tL5s+fnyFDhqRUKtW6HAAAAADoVsrlcp5//vmMGzcuffpsun9SWFmB+fPnZ/z48bUuAwAAAAC6tccffzw77bTTJt8XVlZgyJAhSYof5tChQ2tcDQDUVnNzc2bOnJmpU6emsbGx1uUAQM25NwJs2bJlyzJ+/Ph1OdumCCsr0Dr0e+jQocJKAHq95ubmDBw4MEOHDvUfZAAQ90aAamzpEYsm2AEAAAAA6oKwEgAAAACoC8JKAAAAAKAueGYlAAAAAGyFtWvXprm5udZl1IXGxsY0NDRs83WElQAAAABQhXK5nIULF+a5556rdSl1Zfjw4RkzZswWJ9HZHGElAAAAAFShNagcNWpUBg4cuE3hXE9QLpezcuXKLFq0KEkyduzYrb6WsBIAAAAAKrR27dp1QeX2229f63LqxoABA5IkixYtyqhRo7Z6SLgJdgAAAACgQq3PqBw4cGCNK6k/rT+TbXmOp7ASAAAAAKrU24d+t6cjfibCSgAAAACgLggrAQAAAKCXmz59evbff/9alyGsBAAAAIDe7t/+7d/yq1/9qtZlmA0cAAAAAHq7wYMHZ/DgwbUuQ2clAAAAAPR03/rWt7LjjjumpaWlzf7jjjsup5122kbDwOfMmZMjjjgiI0eOzLBhwzJp0qTcddddnV6nsBIAAAAAtla5nKxYUZulXK64zJNPPjmLFy/OTTfdtG7fkiVLcuONN+btb3/7Rsc///zzOe2003LzzTfn9ttvz8te9rIcc8wxef755zvkx7YphoEDAAAAwNZauTKp1fDp5cuTQYMqOnTEiBE56qij8v3vfz9vfOMbkyRXXXVVRowYkTe+8Y259dZb2xx/+OGHt3n9rW99K9ttt11+85vf5O///u87pv526KwEAAAAgF7g7W9/e37yk59k1apVSZIrr7wyb3vb29LQ0LDRsYsWLcr73ve+7Lnnnhk2bFiGDRuW5cuX57HHHuvUGnVWAgAAAMDWGjiw6HCs1WdX4dhjj01LS0uuu+66HHzwwbn55pvzla98pd1jp02blqeffjoXXHBBJkyYkKampkycODGrV6/uiMo3SVgJAAAAAFurVKp4KHatDRgwICeccEKuvPLKPPjgg9lzzz1z4IEHtnvszTffnK9//es55phjkiSPP/54Fi9e3Ok1CisBAAAAoJd4+9vfnmOPPTb33Xdf3vGOd2zyuD322CPf/e53c9BBB2XZsmX58Ic/nAEDBnR6fd3ymZVf//rXs+uuu6Z///458MADc/PNN2/2+N/85jc58MAD079//+y222755je/2UWVAgAAAED9OPzwwzNixIjMnTs3p5xyyiaP+853vpMlS5bkgAMOyKmnnpoPfvCDGTVqVKfX1+06K3/0ox/lrLPOyte//vW89rWvzbe+9a0cffTRuf/++7PzzjtvdPy8efNyzDHH5D3veU++973v5ZZbbskHPvCB7LDDDjnxxBNr8A0AAAAAoDYaGhoyf/78jfZPnz4906dPX/f6gAMOyJw5c9occ9JJJ3V2ed2vs/IrX/lKTj/99JxxxhnZZ599csEFF2T8+PH5xje+0e7x3/zmN7PzzjvnggsuyD777JMzzjgj7373u/OlL32piysHAAAAADanW3VWrl69OnfeeWc++tGPttk/derU3Hrrre2ec9ttt2Xq1Klt9h155JH59re/nebm5jQ2Nm50zqpVq9ZN4Z4ky5YtS5I0Nzenubl5W78GAHRrrfdC90QAKLg3Qu/S3NyccrmclpaWtLS01LqcutLS0pJyuZzm5uY0NDS0ea/S35HdKqxcvHhx1q5dm9GjR7fZP3r06CxcuLDdcxYuXNju8WvWrMnixYszduzYjc45//zzM2PGjI32N++1V5r7bNCMWi5vdEypnX3t6uBz271epeeuO6E4o9y63fq6mu3S+k+t6ry/fWa5o66xwXeq+rwqrrHJ87ZwjYrOa+caVZ/Xes5WXGPdeRtu9+mz7nts+M/8pfuqXrf+verTZ/3nvHTdkZ/Xeq3Nfd7f1hVdZ8N/TtCLzJo1q9YlAEBdcW+E3qFv374ZM2ZMli9fntWrV9e6nLqyevXqvPDCC/ntb3+bNWvWtHlv5cqVFV2jW4WVrUovCQbK5fJG+7Z0fHv7W33sYx/LOeecs+71smXLMn78+Ax85pkM3NqigR6t/LfwM521TrZ4XLmLPmdz63JDQ/F6w6V1X+uxG+7b1OtN7Gtz/dbrVXjulj6z/NLjq6xts9fvYYF2c3NzZs2alSOOOKLdEQoA0Nu4N0Lv8uKLL+bxxx/P4MGD079//1qXU1defPHFDBgwIG94wxs2+tm0jlzekm4VVo4cOTINDQ0bdVEuWrRoo+7JVmPGjGn3+L59+2b77bdv95ympqY0NTVt/MZNNyWDB7fd195/gHbHfeXy+q7L1u1tXer1WvVcWz1/z9alpaVnrrdRqVxO1q7d5utsUw01/XS2qJKQs6GhsqWaYzt66dMnfZLs8uc/p9/8+enbr1+Xf367+3tYIAxA99TY2CishF5g7dq1KZVKKZVK6bPhCFzW/Vza+31Y6e/HbhVW9uvXLwceeGBmzZqV448/ft3+WbNm5c1vfnO750ycODE///nP2+ybOXNmDjrooOpvIq9+dTJ0aNV1A91ATw9ju2Ld3rJ2befv66rPaW9fNUF36zk9QEOSV9W6iJfq0yfp27dYGhrWb7902dx73eHcxsa2S+s+gS0AQJdpzZNWrlyZAQMG1Lia+tI61Htb/sdNtwork+Scc87JqaeemoMOOigTJ07MxRdfnMceeyzve9/7khRDuJ988slcccUVSZL3ve99ufDCC3POOefkPe95T2677bZ8+9vfzg9+8INafg2g3mzwHEuoWHtB7dYGqmvXVrdszTkdtLQ0N2fh/PkZs8MO6dPaVdzZy5aC4ZaWZPXqYumtXhpkvjTQ3NyypWM64hqVHtParSt8BQDqVENDQ4YPH55FixYlSQYOHLjZxxP2BuVyOStXrsyiRYsyfPjwjSbXqUa3Cyv/4R/+Ic8880w+85nPZMGCBdlvv/1y/fXXZ8KECUmSBQsW5LHHHlt3/K677prrr78+Z599di666KKMGzcuX/va13LiiSfW6isA0FOUSuuHIfcia5ubM+f663PMMcekT1cNddswFG0vqF2zZv36pdvtLZt7f1vO7exrNzcXS3s29153UyoVoWVTU7HuqKWjr9fYKFQFgF5qzJgxSbIusKQwfPjwdT+brVUql6sZw9Y7LVu2LMOGDcvSpUsz1DBwAHq55ubmXP+3sNJzuWqgNbhtDSc3DDE3tWzpmI64xrYc050fkdDUtH7p33/j7fb2dca24BRqyr0Req+1a9emuaf8D+Nt1NjYuNmOykrztW7XWQkA0KuVSuufYdlTnpHU0lKElqtXr19v7bJq1badv6XrvfT/869aVSy1VipVFpz271/8uWldXvq60n0bvu7rPykA6L0aGhq2acgzG/NvFgAA1FafPuuDtXrW2tW6YZC54fLii23Xnb29YRdHuVzsf/HFrv+5tAbnWxN8DhyYDBrU/rq9ff5jEAB6PGElAABUYsOu1oEDa11N0ZFabVj6wgvr1xsu1e7bsJt0zZrk+eeLpbM1NW06yNxcyFnpe/37G04PADUmrAQAgO6oT5/1HYpdraVlfSfn1gafL7yQrFxZLCtWbLy94b7W4fetweuSJZ3zvRoaksGDi2XIkPXbL329qe323uvXr3NqBYAeSlgJAABUp0+f9d2Ina11iHt7QebmQs5qjlm9uvistWuTpUuLpaM0NlYWeA4blgwdWiztbQ8bpvMTgF5BWAkAANSvUml9B+n223fOZ6xZUwSXK1Yky5cXQ9qXL9/89paOax0q39xcdIJ2RDdo376bDjMr2R42LBk+vAhQAaBOCSsBAIDerW/fIsgbNqzjrtncXFn42fp66dJk2bJieen2888XHaZr1iTPPlss22LQoCK03G679esNtze3b9Ag3Z0AdCphJQAAQEdrbCwCvuHDt/1aLS1F8NlekFnNduskSK1dpE8+WX0tfftuOszcfvtNL9ttVzw+AAC2QFgJAABQz/r0KZ5rOWRIsuOOW3+d1mdyPvfc+qHprdvt7Xvp9po1xbJ4cbFU+x222679IHPkyE2HnE1NW/99AeiWhJUAAAC9QUNDMmJEsVSrXC4mI9pUwLlkSTE8/ZlniiDzmWfWL88/X3SHtr6uxrBhyahR7S+jR7d9rXsToEcQVgIAALB5pVLxvMpBg5Kddqru3NWriyDzpSFm69Le/mefLQLO1tnZH3hgy5/T0JDssMPGIWZrsDl2bDJuXLHefnvBJkCdElYCAADQefr1S8aMKZZKtbQUnZtPP50sWpQ89VSxbm956qni2LVrk4ULi2VLGhuLesaNWx9gbrgWagLUjLASAACA+tKnz/oh63vtteXjV69eH2y+NMhsXS9YkMyfXxzX3Jw8/nixbM5LQ82ddkp23rlYxo8v1tWEsABskbASAACA7q1fv2LyoUomIFq9uggv589fH2BuuF1tqNm3b/ruuGNeO2hQGn74w2SXXdYHma2h5vDhxVB6ALZIWAkAAEDv0a9fESCOH7/5414aaj75ZPLEE8ljjxXL448Xr9esSenRRzMySe6/v/1rDR5cBJe77prstlvbZdddi2eBApBEWAkAAAAbqyTUXLs2WbAga+bNy93/+7959fbbp2H+/LaB5uLFyfLlRZC5qTBz9Oj2g8w99iiGn+vKBHoRYSUAAABsjYaGZKedUh49OvOffTb7H3NMGhob2x6zcmURWj76aDJvXvLww22X554rOjifeiq5/faNP2PQoGTPPdcve+21fnvYsC75mgBdSVgJAAAAnWXgwCJg3NREQUuWtB9iPvRQ8sgjyYoVyd13F8tLjRq1Przca69k332Tl7+8GHJuFnOgmxJWAgAAQK1st12xvPrVG7+3enURXP71r8Uyd+767YUL1896fvPNbc8bNCjZZ58iuNxw2XlnQ8qBuiesBAAAgHrUr1+y997F8lLLliUPPLA+xPzLX5L77iu2V6xI/vCHYtnQ4MFFiLnffsn++xfLq15lODlQV4SVAAAA0N0MHZoceGCxbKi5OXnwwSK4vP/+Yt0aYi5fnsyZUywb2nXX9eFl6zJ+vC5MoCaElQAAANBTNDYW3ZP77NN2f3Nz0Yl5333JH/+Y/N//FctjjxXPzJw3L7n66vXHb7ddEVoedFBy8MHFMmGCABPodMJKAAAA6OkaG4sJePbdNzn55PX7n322CC3vuWf9cv/9xcQ/N91ULK122GF9cNm6jBrVxV8E6OmElQAAANBbjRiRTJlSLK1WrSoCy7vvXj9s/I9/TJ5+Orn++mJptfPOySGHJIcdViwHHFA8axNgKwkrAQAAgPWamorQ8YADkne/u9j34otFB2ZreDlnTjGpz2OPFcuPf1wc179/EV6+9rXrA8wRI2r3XYBuR1gJAAAAbF7//smhhxZLq2XLkjvvTO64I7nlluTWW4th5b/9bbG02mefIrx8/euLDs7x47u+fqDbEFYCAAAA1Rs6tO0Q8nK5mHW8Nbi85Zbi9Z//XCyXXFIct/vuyeTJxXmTJyc77lirbwDUIWElAAAAsO1KpWTvvYvl9NOLfYsXJ7fdlvzud8ns2UUn5kMPFcu3v10c87KXtQ0vx46t0RcA6oGwEgAAAOgcI0cmxx5bLEkxdPx3vytmGZ89O7nrruSBB4rlv/+7OGavvZIjjkiOPLIILwcPrlX1QA0IKwEAAICuMXRocswxxZIkzz2X3HxzEVzedFNyzz3F0PG5c5MLL0waG5PXva4ILo88MnnVq4oOTqDHElYCAAAAtTF8eNvOy2efLYLLmTOTG29MHnmkCDFvuin56EeT0aOTqVOL4PKII5JRo2pYPNAZhJUAAABAfRgxIjnhhGIpl4vh4TfeWCw33ZQ89VTy3e8WS5IcfPD6sFPXJfQIfWpdAAAAAMBGSqVkzz2Tf/mX5Npri67LX/86+chHkv33L46ZMyf51KeSAw5Idt45ef/7k+uvT158saalA1tPWAkAAADUv6amYsbwz38+ufvuZP785JJLkje/ORk4MHniieSb30z+7u+S7bcv9l9ySbJgQa0rB6ogrAQAAAC6n7Fjk9NPT665Jlm8OLnuuuR970t22ilZuTL53/9N3vOeZNy45JBDks9+Nrn//mJ4OVC3hJUAAABA9zZgQDHD+De+kTz2WNF5+ZnPFM+0TIrh4p/8ZPLylyd7711M1nPHHUlLS23rBjYirAQAAAB6jlKpeKblJz+Z/P73xXDxiy8uwsx+/ZK//jX5wheS17ymeM7lmWcmv/pV0txc68qBCCsBAACAnmzs2GI4+HXXJU8/nfzwh8lb35oMHpw8+WRy0UXJm96UjBmTTJuW/OxnyQsv1Lpq6LWElQAAAEDvMHRo8g//kPzoR0Vwee21xXMvR44sZhu//PLkLW8pXp90UnLllclzz9W6auhVhJUAAABA79O/fzFzeOuM4bNnJx/6UDE0fOXK5Cc/Sd7xjmTUqOSoo5JvfStZuLDWVUOPJ6wEAAAAere+fZNJk5ILLkgeeSS5887kE59I9t23eJbljTcWM42PG5e89rXJ//t/yQMP1Lpq6JGElQAAAACtSqXk1a9OPvvZ5L77krlzk89/PjnkkKRcTm69NTn33GTPPYvZxT/xiWK2cTOLQ4cQVgIAAABsyp57Jh/5SHLHHckTTyRf/3oydWrRjXn//cnnPlcEmTvvnPzzPyezZiWrV9e6aui2hJUAAAAAldhxx+T97y+GhT/9dDEBz8knr59ZvDXI3GGH5Pjji5nG//rXoiMTqEjfWhcAAAAA0O0MH56cckqxvPhi8utfJ9dck/zsZ8miRcX2NdcUx44fn7zpTcmUKcnhhxehJ9AunZUAAAAA26J//+SYY5KLL07mzy+GjJ93XhFO9uuXPP54cumlyTvfWQwXf/Obk5kzPecS2iGsBAAAAOgoDQ3FMyw//vGi23LJkmLY+LnnFvtbWpL//d/kyCOT3XdPPvOZYgZyIImwEgAAAKDzDBxYPMfyC18oOi7//OfkQx9Khg0rQspPfzrZddfkgAOST33KzOL0esJKAAAAgK6y997JBRcUw8W/973iGZalUnLPPcl//EfRfbnjjskZZyT/8z/J4sW1rhi6lLASAAAAoKsNHJi8/e3Jr36VPPVUctllyYknFjOLL1yYfPvbyT/8QzJqVHLggclHPpL88pfJCy/UunLoVGYDBwAAAKilHXZITjutWFatSn7zm+SGG5JZs5J7703uuqtYvvjFYjKf170umTQpef3ri07MAQNq/Q2gwwgrAQAAAOpFU1PxjMupU4vXCxYU3Ze//GURXs6fX2z/8pfF+42NyUEHFcHl61+fHHZYMmJE7eqHbSSsBAAAAKhXY8cm73hHsZTLyV/+UoSXN99cLAsWJLfdVixf/GJxzl57JQcfvH7Zf3/dl3QbwkoAAACA7qBUSvbZp1jOPLMILx9+OPnd79aHl3/9azJ3brF873vFeX37Jvvttz68PPDA4nW/frX9PtAOYSUAAABAd1QqJbvvXiynnVbse/rpZM6ctsuiRcVs4/fck/z3fxfH9euXvOIVRXDZuuy3XzEMHWpIWAkAAADQU+ywQ3LMMcWSFN2XTzzRNry8665kyZLkzjuLpVVjYxFgvvrV6wPMV7yimNQHuoiwEgAAAKCnKpWS8eOL5YQTin3lcvLII+vDytbl2WfXzzx+ySXFsa1DyA88MHnDG5LDD0922qlmX4eeT1gJAAAA0JuUSsmuuxbLSScV+8rl5NFH1weXd91VrBcvXj+E/NvfLo7dc88itPy7v0uOOMLQcTqUsBIAAACgtyuVkl12KZYTTyz2lcvJ448XoeUddyQ33ZT84Q/FJD5//WvyzW8mQ4Ykf//3xTnHHGPWcbaZsBIAAACAjZVKyc47F8vxxxf7li5NfvObZObM5Oqrk/nzkx/8oFi22y55xzuS97yneNYlbIU+tS4AAAAAgG5i2LDkuOOSCy8sui5vvTX5138tnom5ZEnyX/+VvPKVyZQpyQ03FN2ZUAVhJQAAAADV69MnmTgx+dKXknnzkl/8ohgO3rdvMnt2cvTRyf77J9deK7SkYsJKAAAAALZNQ0Ny1FHJj3+cPPxwcs45yeDByR//mBx7bPE8y3nzal0l3YCwEgAAAICOM3588uUvJ489lnzkI0ljYzEk/JWvTC65RJclmyWsBAAAAKDjbbdd8vnPJ/fdl7z+9cny5cXkO6eemqxcWevqqFPCSgAAAAA6z8teltx0U/KFLxTDxa+8Mnnd64qZxOElhJUAAAAAdK6GhuTcc5Nf/SrZYYfk7ruLwPLBB2tdGXVGWAkAAABA15g0KbnjjmSPPYoJd173uuT//q/WVVFHhJUAAAAAdJ1dd01+97vkVa9KnnoqmTy5mDUcIqwEAAAAoKuNHp3Mnp1MnJg891wydaoh4SQRVgIAAABQC8OHJ9ddl7zylUWH5RFHJE8+WeuqqDFhJQAAAAC1sd12ycyZxTMsH3kkOfroZPnyWldFDQkrAQAAAKid0aOTWbOK9Z/+lJx6atLSUuuqqBFhJQAAAAC1tcsuyTXXJE1Nxfo//qPGBVEr3SqsXLJkSU499dQMGzYsw4YNy6mnnprnnntus+dMmzYtpVKpzfKa17ymawoGAAAAoDKveU1y8cXF9owZya9/Xdt6qIluFVaecsopueeee3LDDTfkhhtuyD333JNTTz11i+cdddRRWbBgwbrl+uuv74JqAQAAAKjKO9+ZnH56Ui4nb397smhRrSuii/WtdQGV+vOf/5wbbrght99+ew499NAkyX//939n4sSJmTt3bvbaa69NntvU1JQxY8Z0VakAAAAAbK2vfS257bbk/vuTD3wg+fGPa10RXajbhJW33XZbhg0bti6oTJLXvOY1GTZsWG699dbNhpWzZ8/OqFGjMnz48EyaNCnnnXdeRo0atcnjV61alVWrVq17vWzZsiRJc3NzmpubO+DbAED31XovdE8EgIJ7I3SwxsbkssvS97DDUvrJT7LmBz9I+aSTal0V26jS35HdJqxcuHBhuwHjqFGjsnDhwk2ed/TRR+fkk0/OhAkTMm/evHzyk5/M4YcfnjvvvDNNTU3tnnP++ednxowZG+2fOXNmBg4cuPVfAgB6kFmzZtW6BACoK+6N0LH2PuGE7PU//5O1739/frVmTZqHDq11SWyDlStXVnRczcPK6dOntxsMbmjOnDlJklKptNF75XK53f2t/uEf/mHd9n777ZeDDjooEyZMyHXXXZcTTjih3XM+9rGP5Zxzzln3etmyZRk/fnymTp2aof5iANDLNTc3Z9asWTniiCPS2NhY63IAoObcG6GTvOlNKd97b5ruvz9H3nprWr72tVpXxDZoHbm8JTUPK88888y87W1v2+wxu+yyS/74xz/mqaee2ui9p59+OqNHj67488aOHZsJEybkgQce2OQxTU1N7XZdNjY2uvEAwN+4LwJAW+6N0MEaG5OLLkqmTEnDxRen4f3vT175ylpXxVaq9PdjzcPKkSNHZuTIkVs8buLEiVm6dGl+//vf55BDDkmS3HHHHVm6dGkOO+ywij/vmWeeyeOPP56xY8dudc0AAAAAdIHJk5OTTiom2fnQh5Jf/zrZzAhbur8+tS6gUvvss0+OOuqovOc978ntt9+e22+/Pe95z3vy93//920m19l7771z9dVXJ0mWL1+ef/u3f8ttt92WRx55JLNnz86xxx6bkSNH5vjjj6/VVwEAAACgUl/6UtLUlMyenXg2bI/XbcLKJLnyyivzile8IlOnTs3UqVPzyle+Mt/97nfbHDN37twsXbo0SdLQ0JA//elPefOb35w999wzp512Wvbcc8/cdtttGTJkSC2+AgAAAADVmDAh+cAHiu1///ekXK5tPXSqmg8Dr8aIESPyve99b7PHlDf4AztgwIDceOONnV0WAAAAAJ3pox9NvvWtZM6c5Oc/T447rtYV0Um6VWclAAAAAL3QqFHFMyuTZMYM3ZU9mLASAAAAgPp3zjnJgAHJXXcVz6+kRxJWAgAAAFD/Ro5M3vWuYvv//b/a1kKnEVYCAAAA0D2cfXZSKiW/+EVy7721roZOIKwEAAAAoHvYY4/khBOK7QsvrG0tdAphJQAAAADdxz//c7G+8srk+edrWwsdTlgJAAAAQPcxeXKy557J8uXJD35Q62roYMJKAAAAALqPUil573uL7W99q7a10OGElQAAAAB0L6edlvTrl9x1V3L33bWuhg4krAQAAACgexk5MjnuuGL7yitrWwsdSlgJAAAAQPfz9rcX6x/8IFm7tra10GGElQAAAAB0P0cfnQwfnsyfn8yeXetq6CDCSgAAAAC6n6am5OSTi21DwXsMYSUAAAAA3VPrUPCf/jRZvbq2tdAhhJUAAAAAdE+ve10yalSydKmh4D2EsBIAAACA7qmhIXnzm4vtq6+ubS10CGElAAAAAN3XCScU65/9LGlpqW0tbDNhJQAAAADd1+GHJ0OHJgsWJHfcUetq2EbCSgAAAAC6r379kr/7u2L7mmtqWgrbTlgJAAAAQPd27LHF+he/qG0dbDNhJQAAAADd29SpSamU/OlPyZNP1roatoGwEgAAAIDubfvtk0MOKbZvuKG2tbBNhJUAAAAAdH9HH12shZXdmrASAAAAgO7vqKOK9axZyZo1ta2FrSasBAAAAKD7O+igYjj40qXJHXfUuhq2krASAAAAgO6voSE5/PBi+6abalsLW01YCQAAAEDPMHlysRZWdlvCSgAAAAB6hilTivWttyarVtW2FraKsBIAAACAnmHvvZMxY5IXX0xuv73W1bAVhJUAAAAA9AylkqHg3ZywEgAAAICeo3Uo+OzZNS2DrSOsBAAAAKDnaO2svP12z63shoSVAAAAAPQcL3tZssMORVB59921roYqCSsBAAAA6DlKpeSww4rtW26pbS1UTVgJAAAAQM/SGlbeemtt66BqwkoAAAAAepYNOyvL5drWQlWElQAAAAD0LAcdlDQ2Jk89lcybV+tqqIKwEgAAAICepX//5MADi23PrexWhJUAAAAA9DytQ8Fvu622dVAVYSUAAAAAPc8hhxTrOXNqWwdVEVYCAAAA0PMcfHCx/r//S1atqm0tVExYCQAAAEDPs+uuyYgRSXNz8qc/1boaKiSsBAAAAKDnKZWKWcETQ8G7EWElAAAAAD1T61DwP/yhtnVQMWElAAAAAD1Ta1ips7LbEFYCAAAA0DO1hpX33ZesWFHbWqiIsBIAAACAnmncuGTs2KSlpZgVnLonrAQAAACg5zrggGJ9zz01LYPKCCsBAAAA6Ln2379Y66zsFoSVAAAAAPRcrWGlzspuQVgJAAAAQM/VGlb+8Y/JmjU1LYUtE1YCAAAA0HPtvnsyaFDy4ovJAw/Uuhq2QFgJAAAAQM/Vp0/yylcW24aC1z1hJQAAAAA9m+dWdhvCSgAAAAB6NmFltyGsBAAAAKBne9WrivWf/lTbOtgiYSUAAAAAPdu++xbrBQuSZ5+tbS1slrASAAAAgJ5tyJBkwoRi+777alsLmyWsBAAAAKDn22+/Yn3vvbWtg80SVgIAAADQ87385cVaZ2VdE1YCAAAA0PPprOwWhJUAAAAA9HytnZX33puUy7WthU0SVgIAAADQ8+2zT1IqJc88kyxaVOtq2ARhJQAAAAA934AByR57FNuGgtctYSUAAAAAvYNJduqesBIAAACA3mHvvYv13Lm1rYNNElYCAAAA0DvstVexFlbWLWElAAAAAL2DsLLuCSsBAAAA6B1aw8onnkhWrKhtLbRLWAkAAABA7zBiRDJyZLH917/WthbaJawEAAAAoPcwFLyuCSsBAAAA6D2ElXVNWAkAAABA77HnnsVaWFmXhJUAAAAA9B46K+tatworzzvvvBx22GEZOHBghg8fXtE55XI506dPz7hx4zJgwIBMnjw59913X+cWCgAAAEB9ag0r//rXpFyubS1spFuFlatXr87JJ5+c97///RWf88UvfjFf+cpXcuGFF2bOnDkZM2ZMjjjiiDz//POdWCkAAAAAdWn33ZOGhmT58mT+/FpXw0t0q7ByxowZOfvss/OKV7yiouPL5XIuuOCCfOITn8gJJ5yQ/fbbL5dffnlWrlyZ73//+51cLQAAAAB1p1+/ZNddi21DwetOtworqzVv3rwsXLgwU6dOXbevqakpkyZNyq233lrDygAAAACoGc+trFt9a11AZ1q4cGGSZPTo0W32jx49Oo8++ugmz1u1alVWrVq17vWyZcuSJM3NzWlubu6ESgGg+2i9F7onAkDBvRG6nz4ve1kakqz9y1/S4u9ul6j0d2TNw8rp06dnxowZmz1mzpw5Oeigg7b6M0qlUpvX5XJ5o30bOv/889utaebMmRk4cOBW1wEAPcmsWbNqXQIA1BX3Rug+Jqxalf2TLP7d73L79dfXupxeYeXKlRUdV/Ow8swzz8zb3va2zR6zyy67bNW1x4wZk6TosBw7duy6/YsWLdqo23JDH/vYx3LOOeese71s2bKMHz8+U6dOzdChQ7eqFgDoKZqbmzNr1qwcccQRaWxsrHU5AFBz7o3Q/ZQGDUq+8Y2MWro0xxxzTK3L6RVaRy5vSc3DypEjR2bkyJGdcu1dd901Y8aMyaxZs3LAAQckKWYU/81vfpMvfOELmzyvqakpTU1NG+1vbGx04wGAv3FfBIC23BuhG/nbMytLjz6axj59itnB6VSV/n7sVhPsPPbYY7nnnnvy2GOPZe3atbnnnntyzz33ZPny5euO2XvvvXP11VcnKYZ/n3XWWfnc5z6Xq6++Ovfee2+mTZuWgQMH5pRTTqnV1wAAAACglsaNK2YFX7MmefzxWlfDBmreWVmNT33qU7n88svXvW7tlrzpppsyefLkJMncuXOzdOnSdcece+65eeGFF/KBD3wgS5YsyaGHHpqZM2dmyJAhXVo7AAAAAHWioSHZZZfkr39NHn642KYudKuw8rLLLstll1222WPK5XKb16VSKdOnT8/06dM7rzAAAAAAupfdd18fVh5+eK2r4W+61TBwAAAAAOgQu+1WrB9+uLZ10IawEgAAAIDepzWsfOih2tZBG8JKAAAAAHofnZV1SVgJAAAAQO8jrKxLwkoAAAAAep/WsPLZZ5PnnqtpKawnrAQAAACg9xk8OBk1qtjWXVk3hJUAAAAA9E6GgtcdYSUAAAAAvZOwsu4IKwEAAADonYSVdUdYCQAAAEDvtPvuxfqhh2pbB+sIKwEAAADonXRW1h1hJQAAAAC9U2tY+eijyZo1ta2FJMJKAAAAAHqrceOSpqZk7drkscdqXQ0RVgIAAADQW/Xpk0yYUGw/+mhtayGJsBIAAACA3mznnYu1zsq6IKwEAAAAoPcSVtYVYSUAAAAAvZewsq4IKwEAAADovYSVdUVYCQAAAEDv1TrBjrCyLggrAQAAAOi9NuysLJdrWwvCSgAAAAB6sZ12KtYrVybPPFPbWhBWAgAAANCL9e+fjB5dbBsKXnPCSgAAAAB6N5Ps1A1hJQAAAAC9m0l26oawEgAAAIDeTWdl3RBWAgAAANC7CSvrhrASAAAAgN6tNax89NHa1oGwEgAAAIBeTmdl3RBWAgAAANC7tU6ws3BhsmpVbWvp5YSVAAAAAPRu22+fDBhQbD/xRG1r6eWElQAAAAD0bqWSoeB1QlgJAAAAAMLKuiCsBAAAAAAzgtcFYSUAAAAA7LRTsX7yydrW0csJKwEAAABgxx2L9fz5ta2jlxNWAgAAAMC4ccVaZ2VNCSsBAAAAoLWzUlhZU8JKAAAAAGgNKxctSlavrm0tvZiwEgAAAAC23z5pbCy2Fy6sbS29mLASAAAAAPr08dzKOiCsBAAAAIDEcyvrgLASAAAAABJhZR0QVgIAAABAYhh4HRBWAgAAAECyvrNy/vza1tGLCSsBAAAAIDEMvA4IKwEAAAAgEVbWAWElAAAAACRtn1lZLte2ll5KWAkAAAAAyfrOypUrk2XLaltLLyWsBAAAAIAkGTgwGT682DYUvCaElQAAAADQynMra0pYCQAAAACtNnxuJV1OWAkAAAAArVo7K+fPr20dvZSwEgAAAABaGQZeU8JKAAAAAGglrKwpYSUAAAAAtPLMypoSVgIAAABAq9awcuHC2tbRSwkrAQAAAKDVmDHF+qmnkpaW2tbSCwkrAQAAAKDVqFHFurk5WbKktrX0QsJKAAAAAGjV1JSMGFFsGwre5YSVAAAAALCh1qHgwsouJ6wEAAAAgA0JK2tGWAkAAAAAG2oNKxcsqG0dvdA2hZWrVq3qqDoAAAAAoD6MHVusdVZ2uarCyhtvvDHTpk3L7rvvnsbGxgwcODBDhgzJpEmTct5552X+/PmdVScAAAAAdA3DwGumorDymmuuyV577ZXTTjstffr0yYc//OH89Kc/zY033phvf/vbmTRpUn75y19mt912y/ve9748/fTTnV03AAAAAHQOYWXN9K3koM997nP50pe+lL/7u79Lnz4b55tvfetbkyRPPvlk/vM//zNXXHFF/vVf/7VjKwUAAACAriCsrJmKwsrf//73FV1sxx13zBe/+MVtKggAAAAAakpYWTNmAwcAAACADbWGlc88k6xeXdtaepmqwsoHHnggP/nJTzJv3rwkyXXXXZc3vOENOfjgg3PeeeelXC53SpEAAAAA0GVGjEgaG4vtp56qbS29TMVh5dVXX5199903p5xySvbZZ59cccUVOfHEEzNo0KCMHj0606dPNwQcAAAAgO6vT59k9Ohi21DwLlVxWHneeefl3HPPzYsvvphvfOMbed/73pfPf/7z+cUvfpFrr702F110US677LJOLBUAAAAAuojnVtZExWHl3Llz8+53vzulUimnnXZaVq9enTe96U3r3p86dWoeffTRTikSAAAAALqUsLImKg4rV6xYkSFDhhQn9emTAQMGZODAgeveHzBgQFatWtXxFQIAAABAVxNW1kTFYWWpVEqpVNrkawAAAADoMYSVNdG30gPL5XL23HPPdQHl8uXLc8ABB6RPnz7r3gcAAACAHmHs2GItrOxSFYeVl156aWfWUZHzzjsv1113Xe65557069cvzz333BbPmTZtWi6//PI2+w499NDcfvvtnVQlAAAAAN1ea2flggW1raOXqTisPO200zqzjoqsXr06J598ciZOnJhvf/vbFZ931FFHtQlb+/Xr1xnlAQAAANBTGAZeExWHlfVgxowZSZLLLrusqvOampoypvUPGAAAAABsyYZhZbmcmLulS1QUVm633XYVT6bz7LPPblNBnWH27NkZNWpUhg8fnkmTJuW8887LqFGjNnn8qlWr2sxsvmzZsiRJc3NzmpubO71eAKhnrfdC90QAKLg3Qg+1/fZpTJIXXkjzM88kw4bVuqJurdLfkRWFlRdccMG67WeeeSaf/exnc+SRR2bixIlJkttuuy033nhjPvnJT1ZfaSc7+uijc/LJJ2fChAmZN29ePvnJT+bwww/PnXfemaampnbPOf/889d1cW5o5syZGThwYGeXDADdwqxZs2pdAgDUFfdG6Hn+rn//9H3xxfzmqquyYty4WpfTra1cubKi40rlKqfxPvHEEzNlypSceeaZbfZfeOGF+eUvf5lrrrmmmstl+vTp7QaDG5ozZ04OOuigda8vu+yynHXWWRVNsPNSCxYsyIQJE/LDH/4wJ5xwQrvHtNdZOX78+CxevDhDhw6t+jMBoCdpbm7OrFmzcsQRR6SxsbHW5QBAzbk3Qs/Vd++9U3r44ayZPTvlww6rdTnd2rJlyzJy5MgsXbp0s/la1c+svPHGG/OFL3xho/1HHnlkPvrRj1Z7uZx55pl529vettljdtlll6qvuyljx47NhAkT8sADD2zymKampna7LhsbG914AOBv3BcBoC33RuiBRo9OHn44fZ99NvH3e5tU+vux6rBy++23z9VXX50Pf/jDbfZfc8012X777au9XEaOHJmRI0dWfd7WeuaZZ/L4449n7NixXfaZAAAAAHRDrXOeLFpU2zp6karDyhkzZuT000/P7Nmz1z2z8vbbb88NN9yQSy65pMML3NBjjz2WZ599No899ljWrl2be+65J0myxx57ZPDgwUmSvffeO+eff36OP/74LF++PNOnT8+JJ56YsWPH5pFHHsnHP/7xjBw5Mscff3yn1goAAABANyes7HJVh5XTpk3LPvvsk6997Wv56U9/mnK5nH333Te33HJLDj300M6ocZ1PfepTufzyy9e9PuCAA5IkN910UyZPnpwkmTt3bpYuXZokaWhoyJ/+9KdcccUVee655zJ27NhMmTIlP/rRjzJkyJBOrRUAAACAbk5Y2eWqDiuT5NBDD82VV17Z0bVs0WWXXZbLLrtss8dsOF/QgAEDcuONN3ZyVQAAAAD0SMLKLtenkoNWrFhR1UWrPR4AAAAA6o6wsstVFFbuscce+dznPpf58+dv8phyuZxZs2bl6KOPzte+9rUOKxAAAAAAamL06GL91FO1raMXqWgY+OzZs/Pv//7vmTFjRvbff/8cdNBBGTduXPr3758lS5bk/vvvz2233ZbGxsZ87GMfy3vf+97OrhsAAAAAOpfOyi5XUVi511575aqrrsoTTzyRq666Kr/97W9z66235oUXXsjIkSNzwAEH5L//+79zzDHHpE+fipo1AQAAAKC+tYaVzzyTrFmT9N2q6V+oQlU/4Z122ilnn312zj777M6qBwAAAADqw4gRSZ8+SUtLsnhxMmZMrSvq8bRBAgAAAEB7GhqSkSOLbUPBu4SwEgAAAAA2xXMru5SwEgAAAAA2RVjZpYSVAAAAALApo0cXa2FllxBWAgAAAMCmtHZWPvVUbevoJYSVAAAAALApO+xQrJ9+urZ19BJ9KzloypQpKZVKVV982rRpeec731n1eQAAAABQF7bfvlg/+2xt6+glKgorp02btlUXf9WrXrVV5wEAAABAXRgxolg/80xt6+glKgorTzvttM6uAwAAAADqT2tnpbCyS3hmJQAAAABsirCyS3VYWPn444/n3e9+d0ddDgAAAABqr3UY+LPPJuVybWvpBTosrHz22Wdz+eWXd9TlAAAAAKD2WjsrV69OVqyobS29QEXPrEyS//3f/93s+w8//PA2FwMAAAAAdWXgwKSpKVm1qhgKPnhwrSvq0SoOK9/ylrekVCqlvJl211Kp1CFFAQAAAEBdKJWKoeALFhRDwSdMqHVFPVrFw8DHjh2bn/zkJ2lpaWl3ueuuuzqzTgAAAACoDZPsdJmKw8oDDzxws4HklrouAQAAAKBbap1kR1jZ6SoeBv7hD384KzbzENE99tgjN910U4cUBQAAAAB1Q2dll6k4rHz961+/2fcHDRqUSZMmbXNBAAAAAFBXWsPKZ5+tbR29QMXDwAEAAACgVzIMvMtUFVYuWLAg3/ve93L99ddn9erVbd5bsWJFPvOZz3RocQAAAABQc4aBd5mKw8o5c+Zk3333zT//8z/npJNOyn777Zf77rtv3fvLly/PjBkzOqVIAAAAAKgZYWWXqTis/PjHP54TTjghS5YsyVNPPZUjjjgikyZNyt13392Z9QEAAABAbbUOA/fMyk5X8QQ7d955Zy666KL06dMnQ4YMyUUXXZQJEybkjW98Y2688cbsvPPOnVknAAAAANSGzsouU3FYmSQvvvhim9fnnntu+vTpk6lTp+Y73/lOhxYGAAAAAHVBWNllKg4r99tvv9x666155Stf2Wb/v/3bv6VcLucf//EfO7w4AAAAAKi51mHgS5YkLS1Jn6rmrKYKFf9k3/nOd+aWW25p970Pf/jD+cxnPmMoOAAAAAA9T2tnZbmcPPdcTUvp6SoOK88444x897vf3eT75557bubNm9chRQEAAABA3ejXL+nfv9hetqy2tfRwelYBAAAAYEuGDi3WwspOVdEzKw844ICUSqWKLnjXXXdtU0EAAAAAUHeGDk0WLRJWdrKKwsq3vOUt67ZffPHFfP3rX8++++6biRMnJkluv/323HffffnABz7QKUUCAAAAQE3prOwSFYWVn/70p9dtn3HGGfngBz+Y//iP/9jomMcff7xjqwMAAACAeiCs7BJVP7Pyqquuyjvf+c6N9r/jHe/IT37ykw4pCgAAAADqirCyS1QdVg4YMCC/+93vNtr/u9/9Lv1bZ0UCAAAAgJ5EWNklKhoGvqGzzjor73//+3PnnXfmNa95TZLimZXf+c538qlPfarDCwQAAACAmmsNK59/vrZ19HBVh5Uf/ehHs9tuu+U///M/8/3vfz9Jss8+++Syyy7LW9/61g4vEAAAAABqTmdll6g6rEySt771rYJJAAAAAHoPYWWXqPqZlQAAAADQ6wgru0RFnZXbbbddSqVSRRd89tlnt6kgAAAAAKg7wsouUVFYecEFF6zbfuaZZ/LZz342Rx55ZCZOnJgkue2223LjjTfmk5/8ZKcUCQAAAAA1JazsEhWFlaeddtq67RNPPDGf+cxncuaZZ67b98EPfjAXXnhhfvnLX+bss8/u+CoBAAAAoJaGDCnWwspOVfUzK2+88cYcddRRG+0/8sgj88tf/rJDigIAAACAujJwYLF+4YXa1tHDVR1Wbr/99rn66qs32n/NNddk++2375CiAAAAAKCutIaVK1fWto4erqJh4BuaMWNGTj/99MyePXvdMytvv/323HDDDbnkkks6vEAAAAAAqLkBA4q1zspOVXVYOW3atOyzzz752te+lp/+9Kcpl8vZd999c8stt+TQQw/tjBoBAAAAoLZ0VnaJqsPKJDn00ENz5ZVXdnQtAAAAAFCfWsPKNWuS5uaksbG29fRQFYeVLS0taWlpSd++60956qmn8s1vfjMrVqzIcccdl9e97nWdUiQAAAAA1FRrWJkU3ZXDhtWulh6s4rDy9NNPT2NjYy6++OIkyfPPP5+DDz44L774YsaOHZuvfvWr+dnPfpZjjjmm04oFAAAAgJro1y/p0ydpaRFWdqKKZwO/5ZZbctJJJ617fcUVV2TNmjV54IEH8n//938555xz8v/+3//rlCIBAAAAoKZKJc+t7AIVh5VPPvlkXvayl617/atf/Sonnnhihv0tRT7ttNNy3333dXyFAAAAAFAPzAje6SoOK/v3758XNvgHcfvtt+c1r3lNm/eXL1/esdUBAAAAQL3QWdnpKg4rX/WqV+W73/1ukuTmm2/OU089lcMPP3zd+w899FDGjRvX8RUCAAAAQD0QVna6iifY+eQnP5ljjjkm//M//5MFCxZk2rRpGTt27Lr3r7766rz2ta/tlCIBAAAAoOaElZ2u4rByypQpufPOOzNr1qyMGTMmJ598cpv3999//xxyyCEdXiAAAAAA1AVhZaerOKxMkn333Tf77rtvu++9973v7ZCCAAAAAKAutYaVJtjpNBU/sxIAAAAAerXW2cB1Vnaaijord91115RKpaovftZZZ+WDH/xg1ecBAAAAQN0xDLzTVRRWXnbZZVt18V122WWrzgMAAACAuiOs7HQVhZWTJk3q7DoAAAAAoL4JKzudZ1YCAAAAQCU8s7LTCSsBAAAAoBJNTcV69era1tGDCSsBAAAAoBLCyk4nrAQAAACASvTrV6xXraptHT2YsBIAAAAAKtEaVuqs7DTCSgAAAACohLCy0wkrAQAAAKASnlnZ6YSVAAAAAFAJz6zsdMJKAAAAAKiEYeCdTlgJAAAAAJUwDLzTCSsBAAAAoBKGgXe6bhNWPvLIIzn99NOz6667ZsCAAdl9993z6U9/Oqu3kGSXy+VMnz4948aNy4ABAzJ58uTcd999XVQ1AAAAAD2GYeCdrtuElX/5y1/S0tKSb33rW7nvvvvy1a9+Nd/85jfz8Y9/fLPnffGLX8xXvvKVXHjhhZkzZ07GjBmTI444Is8//3wXVQ4AAABAj2AYeKfrW+sCKnXUUUflqKOOWvd6t912y9y5c/ONb3wjX/rSl9o9p1wu54ILLsgnPvGJnHDCCUmSyy+/PKNHj873v//9/NM//VOX1A4AAABAD2AYeKfrNmFle5YuXZoRI0Zs8v158+Zl4cKFmTp16rp9TU1NmTRpUm699dZNhpWrVq3Kqg3+0C1btixJ0tzcnObm5g6qHgC6p9Z7oXsiABTcG6EXKZXSmKS8enXW+DtflUp/R3bbsPKhhx7Kf/3Xf+XLX/7yJo9ZuHBhkmT06NFt9o8ePTqPPvroJs87//zzM2PGjI32z5w5MwMHDtzKigGgZ5k1a1atSwCAuuLeCD3f4McfzxuTNK9YkV9cf32ty+lWVq5cWdFxNQ8rp0+f3m4wuKE5c+bkoIMOWvd6/vz5Oeqoo3LyySfnjDPO2OJnlEqlNq/L5fJG+zb0sY99LOecc86618uWLcv48eMzderUDB06dIufBwA9WXNzc2bNmpUjjjgijY2NtS4HAGrOvRF6kYcfTpI0lss55phjalxM99I6cnlLah5WnnnmmXnb29622WN22WWXddvz58/PlClTMnHixFx88cWbPW/MmDFJig7LsWPHrtu/aNGijbotN9TU1JSm1gembqCxsdGNBwD+xn0RANpyb4ReYNCgJElp1Sp/36tU6c+r5mHlyJEjM3LkyIqOffLJJzNlypQceOCBufTSS9Onz+YnM991110zZsyYzJo1KwcccECSZPXq1fnNb36TL3zhC9tcOwAAAAC9SOsEO83NSbmcbGbkLltn82lfHZk/f34mT56c8ePH50tf+lKefvrpLFy4cN1zKVvtvffeufrqq5MUw7/POuusfO5zn8vVV1+de++9N9OmTcvAgQNzyimn1OJrAAAAANBdbTgS1wQ7naLmnZWVmjlzZh588ME8+OCD2Wmnndq8Vy6X123PnTs3S5cuXff63HPPzQsvvJAPfOADWbJkSQ499NDMnDkzQ4YM6bLaAQAAAOgBWjsrk2TVqrav6RDdJqycNm1apk2btsXjNgwuk6K7cvr06Zk+fXrnFAYAAABA77BhOLl6de3q6MG6zTBwAAAAAKiphoZiSYSVnURYCQAAAACVau2uFFZ2CmElAAAAAFSqNaxctaq2dfRQwkoAAAAAqFTrjOA6KzuFsBIAAAAAKmUYeKcSVgIAAABApQwD71TCSgAAAAColM7KTiWsBAAAAIBKeWZlpxJWAgAAAEClDAPvVMJKAAAAAKhU377Feu3a2tbRQwkrAQAAAKBSrWHlmjW1raOHElYCAAAAQKWElZ1KWAkAAAAAlRJWdiphJQAAAABUSljZqYSVAAAAAFCphoZiLazsFMJKAAAAAKiUzspOJawEAAAAgEq1hpVr19a2jh5KWAkAAAAAldJZ2amElQAAAABQKWFlpxJWAgAAAEClhJWdSlgJAAAAAJUSVnYqYSUAAAAAVKqhoVhvKqycNy+58cakpaXraupBhJUAAAAAUKnNdVa++GLyhjckRx2VvOtdXVtXDyGsBAAAAIBKtYaVa9du/N53v5s88USxfcUVycMPd11dPYSwEgAAAAAqtbnOyl/9qu3rK6/s/Hp6GGElAAAAAFRqc2Hl/fcX6ze/uVi/NLxki4SVAAAAAFCpTYWVa9Ykc+cW2//0T8X6979Pmpu7rrYeQFgJAAAAAJXaVFj58MPJ6tXJwIHJ1KnJdtslL7yQ3HNPl5fYnQkrAQAAAKBSmworH3igWO+5Z9LQkBxySPH6rru6rrYeQFgJAAAAAJVqaCjWLw0rFy0q1mPGFOtXvrJY/+lPXVNXDyGsBAAAAIBKbaqz8umni/WoUcX6Fa8o1sLKqggrAQAAAKBSrWHl2rVt97eGlTvsUKw3DCvL5a6prQcQVgIAAABApbbUWdkaVu69d1IqJUuWrH+PLRJWAgAAAEClNhVWtj6zsjWs7N8/2XHHYvvhh7umth5AWAkAAAAAlar0mZVJsvvuxfqhhzq/rh5CWAkAAAAAlap0GHgirNwKwkoAAAAAqFRDQ7He0jDwRFi5FYSVAAAAAFCp9jorV69OXnih2B4+fP1+YWXVhJUAAAAAUKnWsHLt2vX7VqxYvz148PptYWXVhJUAAAAAUKn2Oitbw8p+/YqlVWtYuXBh20CTTRJWAgAAAECl2gsrly8v1oMGtT12u+2KJUkefrjza+sBhJUAAAAAUKnNhZUbDgFvZSh4VYSVAAAAAFCpasPK3XYr1vPmdW5dPYSwEgAAAAAqVW1YOX58sX7yyc6tq4cQVgIAAABApRoainV7E+y89JmVSbLTTsX6iSc6t64eQlgJAAAAAJWqtrOyNax8/PHOrauHEFYCAAAAQKVaw8q1a9fvqySs1FlZEWElAAAAAFRqazsr589vG3DSLmElAAAAAFSq2rByzJikT5/i+EWLOr++bk5YCQAAAACVai+s3NwEO337JuPGFduGgm+RsBIAAAAAKlVtZ2XiuZVVEFYCAAAAQKUaGor11oSVZgTfImElAAAAAFRqc8PABw5s/xydlRUTVgIAAABApVrDyg1n9n7xxWLdv3/75wgrKyasBAAAAIBKtddZuXp1sW5qav8cw8ArJqwEAAAAgEq1hpUtLcWSJKtWFetNhZWts4EvXNi5tfUAwkoAAAAAqFRrWJmsHwreGlb269f+OWPGFGth5RYJKwEAAACgUq2zgSfrh4JvaRh4a1i5fPn6mcNpl7ASAAAAACrVZ4M4rdJh4IMHr58p/KmnOq+2HkBYCQAAAACV2rCz8qVh5aaGgZdKhoJXSFgJAAAAAJXasLOy9ZmVWxoGnggrKySsBAAAAIBKba6zUli5zYSVAAAAAFCpzXVWbmoYeCKsrJCwEgAAAAAqVSqt325pScrl6jorTbCzWcJKAAAAAKhG61DwlpakuXn9fsPAt5mwEgAAAACq0ToUfO3a9UPAE8PAO4CwEgAAAACqsWFnZesQ8ERnZQcQVgIAAABANTbsrGwNKxsa2s4U/lIbhpXlcufW140JKwEAAACgGq1hZUtLZTOBJ8moUcW6uTlZsqTzauvmhJUAAAAAUI32hoFvbgh46/vbbVdsGwq+ScJKAAAAAKhGe8PAtxRWJskOOxTrp5/unLp6AGElAAAAAFRjw87KSoeBJ8LKCggrAQAAAKAaGz6zUmdlhxJWAgAAAEA1DAPvNN0mrHzkkUdy+umnZ9ddd82AAQOy++6759Of/nRWt7babsK0adNSKpXaLK95zWu6qGoAAAAAehzDwDtN31oXUKm//OUvaWlpybe+9a3sscceuffee/Oe97wnK1asyJe+9KXNnnvUUUfl0ksvXfe6XyV/eAAAAACgPTorO023CSuPOuqoHHXUUete77bbbpk7d26+8Y1vbDGsbGpqypgxYzq7RAAAAAB6gw07K4WVHarbhJXtWbp0aUaMGLHF42bPnp1Ro0Zl+PDhmTRpUs4777yMGjVqk8evWrUqq1r/oCVZtmxZkqS5uTnNzc3bXjgAdGOt90L3RAAouDdC79O3T5+UkqxZvTpZuTJ9k7Q0NmbtFn4PlLbbLn2TlJ9+Omt62e+MSn9Hdtuw8qGHHsp//dd/5ctf/vJmjzv66KNz8sknZ8KECZk3b14++clP5vDDD8+dd96Zpk0k3ueff35mzJix0f6ZM2dm4MCBHVI/AHR3s2bNqnUJAFBX3Buh93jjCy9kcJLbfve7DH7iiRyQZNFzz+WO66/f7HnDHnook5OseuKJ3LiFY3ualStXVnRcqVwulzu5ls2aPn16u8HghubMmZODDjpo3ev58+dn0qRJmTRpUi655JKqPm/BggWZMGFCfvjDH+aEE05o95j2OivHjx+fxYsXZ+jQoVV9HgD0NM3NzZk1a1aOOOKINDY21rocAKg590boffrut19Kf/1r1vz61ynde28aPvjBtBx/fNb+6EebP/Hxx9O4++4pNzZmzfLlSanUNQXXgWXLlmXkyJFZunTpZvO1mndWnnnmmXnb29622WN22WWXddvz58/PlClTMnHixFx88cVVf97YsWMzYcKEPPDAA5s8pqmpqd2uy8bGRjceAPgb90UAaMu9EXqRvz2zsm+pVDy3Mkmffv3SZ0u/A8aNS5KUmpvTuHJlMnx4Z1ZZVyr9/VjzsHLkyJEZOXJkRcc++eSTmTJlSg488MBceuml6dM681IVnnnmmTz++OMZO3Zs1ecCAAAAwLrZwFtaihnBk6SSMK5//2Tw4GT58mKSnV4UVlaq+rSvRubPn5/Jkydn/Pjx+dKXvpSnn346CxcuzMKFC9sct/fee+fqq69Okixfvjz/9m//lttuuy2PPPJIZs+enWOPPTYjR47M8ccfX4uvAQAAAEB3t+Fs4GvWFNt9K+wJNCP4ZtW8s7JSM2fOzIMPPpgHH3wwO+20U5v3Nnzs5ty5c7N06dIkSUNDQ/70pz/liiuuyHPPPZexY8dmypQp+dGPfpQhQ4Z0af0AAAAA9BCtnZVr125dWDlvnrByE7pNWDlt2rRMmzZti8dtGFwOGDAgN954YydWBQAAAECvo7Oy03SbYeAAAAAAUBe2tbMyEVZugrASAAAAAKqx4QQ71YaVrRNNL17c8XX1AMJKAAAAAKjGtgwDHzGiWC9Z0vF19QDCSgAAAACoxrYMA99++2L9zDMdX1cPIKwEAAAAgGp0RGfls892fF09gLASAAAAAKqxLZ2VwsrNElYCAAAAQDXam2CntdtyS4SVmyWsBAAAAIBqdNQw8HK542vr5oSVAAAAAFCNDYeBr11bbFc7wc7q1cmKFR1fWzcnrAQAAACAamxLZ+XAgUm/fsW2oeAbEVYCAAAAQDW2ZYKdUslzKzdDWAkAAAAA1Whvgp1Kw8pEWLkZwkoAAAAAqMa2DANP1j+3Uli5EWElAAAAAFRjW4aBJ+s7K595pmPr6gGElQAAAABQjW3trDQMfJOElQAAAABQjY7qrBRWbkRYCQAAAADVMMFOpxFWAgAAAEA1TLDTaYSVAAAAAFCN9oaBtwaYldBZuUnCSgAAAACoRkcNAzcb+EaElQAAAABQjdYuyq2dYGe77Yr1kiUdW1cPIKwEAAAAgGps2Fm5dm2xXU1YOXx4sV66tEPL6gmElQAAAABQjW2dYKc1rFyxImlu7tDSujthJQAAAABUo70JdqoJK4cOXb+tu7INYSUAAAAAVGNbJ9jp2zcZPLjYFla2IawEAAAAgGps6wQ7yfqh4M8911FV9QjCSgAAAACoxrZ2VibJsGHFWljZhrASAAAAAKqxrRPsJDorN0FYCQAAAADV2NYJdpL1YaVnVrYhrAQAAACAahgG3mmElQAAAABQjfYm2GndVynDwNslrAQAAACAanRkZ6Vh4G0IKwEAAACgGht2Vq5dW2ybYKdDCCsBAAAAoBqtnZXNzev3CSs7hLASAAAAAKrRGlauXr1+n2HgHUJYCQAAAADVaB0GvmrV+n06KzuEsBIAAAAAqtERnZXCynYJKwEAAACgGq2dlYaBdzhhJQAAAABUo7WzsnUYeKm0fl+lWjsrly5NWlo6rLTuTlgJAAAAANV46TDwarsqk/VhZbmcPP98h5TVEwgrAQAAAKAaL51gZ2vCyv79k379im1DwdcRVgIAAABANTqiszJZ3125ZMk2l9RTCCsBAAAAoBovDStbOy2rNXRosV62bNtr6iGElQAAAABQjdZwsrm57etqDRlSrD2zch1hJQAAAABUo7WzsjWsrHYm8FbCyo0IKwEAAACgGjorO42wEgAAAACq0VHPrGwNK5cv3/aaeghhJQAAAABU46XDwHVWdhhhJQAAAABUwzDwTiOsBAAAAIBqmGCn0wgrAQAAAKAarZ2Ua9a0fV0tYeVGhJUAAAAAUI2XdlIKKzuMsBIAAAAAqiGs7DTCSgAAAACoxkvDSWFlhxFWAgAAAEA1XtpZaYKdDiOsBAAAAIBq6KzsNMJKAAAAAKiGZ1Z2GmElAAAAAFSjo8PK5cuTcnnbauohhJUAAAAAUI2OGgY+eHCxLpeTFSu2raYeQlgJAAAAANXoqAl2Bg1KSqVi21DwJMJKAAAAAKhOR3VWlkrruyuFlUmElQAAAABQnY56ZmVikp2XEFYCAAAAQDWElZ1GWAkAAAAA1eioYeBJ2xnBEVYCAAAAQFU6aoKdRGflSwgrAQAAAKAahoF3GmElAAAAAFSjM4aBCyuTCCsBAAAAoDo6KzuNsBIAAAAAqqGzstMIKwEAAACgGh05wc6gQcV6xYqtv0YPIqwEAAAAgGp05DDwgQOL9cqVW3+NHkRYCQAAAADV6Mhh4Dor2xBWAgAAAEA1OrKzUljZhrASAAAAAKrx0nDSMys7TLcKK4877rjsvPPO6d+/f8aOHZtTTz018+fP3+w55XI506dPz7hx4zJgwIBMnjw59913XxdVDAAAAECPo7Oy03SrsHLKlCn5n//5n8ydOzc/+clP8tBDD+Wkk07a7Dlf/OIX85WvfCUXXnhh5syZkzFjxuSII47I86aDBwAAAGBrdEZYaYKdJEnfWhdQjbPPPnvd9oQJE/LRj340b3nLW9Lc3JzGxsaNji+Xy7ngggvyiU98IieccEKS5PLLL8/o0aPz/e9/P//0T//UZbUDAAAA0EN05AQ7rbOB66xM0s06Kzf07LPP5sorr8xhhx3WblCZJPPmzcvChQszderUdfuampoyadKk3HrrrV1VKgAAAAA9iWHgnaZbdVYmyUc+8pFceOGFWblyZV7zmtfk2muv3eSxCxcuTJKMHj26zf7Ro0fn0Ucf3eR5q1atyqpVq9a9XrZsWZKkubk5zc3N21I+AHR7rfdC90QAKLg3Qi/U0pINW+fWJmnZ2t8B/fqlMUl5xYqs6cG/Ryr9HVnzsHL69OmZMWPGZo+ZM2dODjrooCTJhz/84Zx++ul59NFHM2PGjLzzne/Mtddem1KptMnzX/peuVze7PHnn39+uzXNnDkzA1tbcwGgl5s1a1atSwCAuuLeCL1H3xdeyN9t8PrhRx7J/ddfv1XXaly2LMckKa1enV/8/Ocpb0uXZh1bWeEzOUvlcrncybVs1uLFi7N48eLNHrPLLrukf//+G+1/4oknMn78+Nx6662ZOHHiRu8//PDD2X333XPXXXflgAMOWLf/zW9+c4YPH57LL7+83c9rr7Ny/PjxWbx4cYYOHVrpVwOAHqm5uTmzZs3KEUccsclHsQBAb+LeCL3QihVp3G67dS/XfuQjafmP/9i6a734Yhr/ljc1L16c9NDsadmyZRk5cmSWLl262Xyt5p2VI0eOzMiRI7fq3NacdcNgcUO77rprxowZk1mzZq0LK1evXp3f/OY3+cIXvrDJ6zY1NaWpqWmj/Y2NjW48APA37osA0JZ7I/QiL2mqa+jXLw1b+/e/b9+kVErK5TSuXp300N8jlf5+7DYT7Pz+97/PhRdemHvuuSePPvpobrrpppxyyinZfffd23RV7r333rn66quTFMO/zzrrrHzuc5/L1VdfnXvvvTfTpk3LwIEDc8opp9TqqwAAAADQnXXkBDulkkl2NlDzzspKDRgwID/96U/z6U9/OitWrMjYsWNz1FFH5Yc//GGbLsi5c+dm6dKl616fe+65eeGFF/KBD3wgS5YsyaGHHpqZM2dmyJAhtfgaAAAAAHR3Lw0nXxpeVmvQoGT5cmFlulFY+YpXvCK//vWvt3jcSx/BWSqVMn369EyfPr2TKgMAAACgV+nIzspEZ+UGuk1YCQAAAAB1oVRq+3pbw8pZs4pnV44Zs23X6QGElQAAAABQrYaGZO3a9dvbYrfdtr2eHqLbTLADAAAAAHVjw6Hg2xpWso6wEgAAAACqtWFAua0T7LCOnyQAAAAAVEtnZacQVgIAAABAtYSVnUJYCQAAAADV2jCgFFZ2GGElAAAAAFRLZ2WnEFYCAAAAQLU2DCtNsNNh/CQBAAAAoFqGgXcKYSUAAAAAVMsw8E4hrAQAAACAaums7BTCSgAAAACols7KTiGsBAAAAIBqmWCnU/hJAgAAAEC1DAPvFMJKAAAAAKiWYeCdQlgJAAAAANXSWdkphJUAAAAAUC2dlZ1CWAkAAAAA1TLBTqfwkwQAAACAahkG3imElQAAAABQLcPAO4WwEgAAAACqpbOyUwgrAQAAAKBaOis7hbASAAAAAKolrOwUwkoAAAAAqNaGAeWAAbWro4cRVgIAAABAtTbsrBw4sHZ19DDCSgAAAACo1oZhpc7KDiOsBAAAAIBqrV27fltnZYcRVgIAAABAtVatWr+ts7LDCCsBAAAAoFobhpX9+tWujh5GWAkAAAAA1dowrCyValdHDyOsBAAAAIBqbRhW0mGElQAAAABQLWFlpxBWAgAAAEC1hJWdQlgJAAAAANUSVnYKYSUAAAAAVEtY2SmElQAAAABQrbVra11BjySsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAqNb55xfrSy+tbR09jLASAAAAAKr10Y8mzz6bTJtW60p6FGElAAAAAGyN7bardQU9jrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqQt9aF9AdlMvlJMmyZctqXAkA1F5zc3NWrlyZZcuWpbGxsdblAEDNuTcCbFlrrtaas22KsLICzz//fJJk/PjxNa4EAAAAALqv559/PsOGDdvk+6XyluJM0tLSkvnz52fIkCEplUq1Loc6c/DBB2fOnDm1LqNb6+k/w+74/eqt5lrV05Wf25mf1dHXXrZsWcaPH5/HH388Q4cO7bDr0rPU2++R7qY3/Py623est3rdG+vr2u6NVKLefo90N73h59fdvmO19ZbL5Tz//PMZN25c+vTZ9JMpdVZWoE+fPtlpp51qXQZ1qqGhwb+QbKOe/jPsjt+v3mquVT1d+bmd+Vmdde2hQ4fW1Z8T6ku9/R7pbnrDz6+7fcd6q9e9sT6v7d7I5tTb75Hupjf8/Lrbd9yaejfXUdnKBDuwjf75n/+51iV0ez39Z9gdv1+91Vyrerryczvzs+rtnye9gz9326Y3/Py623est3rdG+v32rAp/txtm97w8+tu37Gz6jUMHACoyrJlyzJs2LAsXbq0W/2fXwDoLO6NAB1HZyUAUJWmpqZ8+tOfTlNTU61LAYC64N4I0HF0VgIAAAAAdUFnJQAAAABQF4SVAAAAAEBdEFYCAAAAAHVBWAkAAAAA1AVhJQAAAABQF4SVAECH+dKXvpSXv/zl2W+//fK9732v1uUAQE0cf/zx2W677XLSSSe12X/ttddmr732yste9rJccsklNaoOoL6VyuVyudZFAADd35/+9KecdtppufXWW5Mkb3zjG3Pddddl+PDhtS0MALrYTTfdlOXLl+fyyy/Pj3/84yTJmjVrsu++++amm27K0KFD8+pXvzp33HFHRowYUeNqAeqLzkoAoEP8+c9/zmGHHZb+/funf//+2X///XPDDTfUuiwA6HJTpkzJkCFD2uz7/e9/n5e//OXZcccdM2TIkBxzzDG58cYba1QhQP0SVgIASZLf/va3OfbYYzNu3LiUSqVcc801Gx3z9a9/Pbvuumv69++fAw88MDfffPO69/bbb7/cdNNNee655/Lcc8/l17/+dZ588sku/AYAsO229X64KfPnz8+OO+647vVOO+3kPgnQDmElAJAkWbFiRV71qlflwgsvbPf9H/3oRznrrLPyiU98InfffXde//rX5+ijj85jjz2WJNl3333zwQ9+MIcffniOP/74HHzwwenbt29XfgUA2Gbbej/clPaewFYqlTqkZoCeRFgJACRJjj766Hz2s5/NCSec0O77X/nKV3L66afnjDPOyD777JMLLrgg48ePzze+8Y11x/zTP/1T7rrrrtx0003p169f9thjj64qHwA6REfcD9uz4447tumkfOKJJzJ27NgOrR2gJxBWAgBbtHr16tx5552ZOnVqm/1Tp05dN6FOkixatChJMnfu3Pz+97/PkUce2aV1AkBnqvR+2J5DDjkk9957b5588sk8//zzuf76690nAdphbBYAsEWLFy/O2rVrM3r06Db7R48enYULF657/Za3vCXPPfdcBg0alEsvvdQwcAB6lErvh0ceeWTuuuuurFixIjvttFOuvvrqHHzwwfnyl7+cKVOmpKWlJeeee2623377rv4KAHXPf0EAABV76bO1yuVym31b6ioBgJ5gS/fDTc3yfdxxx+W4447r1NoAujvDwAGALRo5cmQaGhradI0kxbDvl3aXAEBP5X4I0PmElQDAFvXr1y8HHnhgZs2a1Wb/rFmzcthhh9WoKgDoWu6HAJ3PMHAAIEmyfPnyPPjgg+tez5s3L/fcc09GjBiRnXfeOeecc05OPfXUHHTQQZk4cWIuvvjiPPbYY3nf+95Xw6oBoGO5HwLUVqlcLpdrXQQAUHuzZ8/OlClTNtp/2mmn5bLLLkuSfP3rX88Xv/jFLFiwIPvtt1+++tWv5g1veEMXVwoAncf9EKC2hJUAAAAAQF3wzEoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAqKlyuZz3vve9GTFiREqlUu65555NHnvqqafmc5/7XId+/qJFi7LDDjvkySef7NDrAgBQPWElAAA1dcMNN+Syyy7LtddemwULFmS//fZr97g//vGPue666/Iv//Iv6/ZNnjw5Z5111kbHXnbZZRk+fHhFnz9q1Kiceuqp+fSnP7015QMA0IGElQAA1NRDDz2UsWPH5rDDDsuYMWPSt2/fdo+78MILc/LJJ2fIkCEdXsO73vWuXHnllVmyZEmHXxsAgMoJKwEAqJlp06blX/7lX/LYY4+lVCpll112afe4lpaWXHXVVTnuuOO26nN22WWXlEqljZZWr3jFKzJmzJhcffXVW3V9AAA6Rvv/2xoAALrAf/7nf2b33XfPxRdfnDlz5qShoaHd4/74xz/mueeey0EHHbRVnzNnzpysXbs2SbJ27dqcdNJJaWxsbHPMIYcckptvvjnvfve7t+ozAADYdsJKAABqZtiwYRkyZEgaGhoyZsyYTR73yCOPpKGhIaNGjdrova9//eu55JJL2uxbs2ZN+vfvv+71DjvssG77Qx/6UBYsWJA5c+a0OWfHHXfM3XffvbVfBQCADiCsBACg7r3wwgtpampqM3S71dvf/vZ84hOfaLPvpz/9abuzhl988cX59re/nVtuuaVNgJkkAwYMyMqVKzu2cAAAqiKsBACg7o0cOTIrV67M6tWr069fvzbvDRs2LHvssUebfe11YM6ePTv/8i//kh/84Ad51atetdH7zz777EYBJgAAXcsEOwAA1L39998/SXL//fdv1fkPPvhgTjzxxHz84x/PCSec0O4x9957bw444ICtLREAgA4grAQAoO7tsMMOefWrX53f/e53VZ/7wgsv5Nhjj83++++f9773vVm4cOG6pdXKlStz5513ZurUqR1ZNgAAVRJWAgDQLbz3ve/NlVdeWfV5Tz31VP7yl7/k17/+dcaNG5exY8euW1r97Gc/y84775zXv/71HVkyAABVKpXL5XKtiwAAgC158cUXs9dee+WHP/xhJk6c2KHXPuSQQ3LWWWfllFNO6dDrAgBQHZ2VAAB0C/37988VV1yRxYsXd+h1Fy1alJNOOin/+I//2KHXBQCgejorAQAAAIC6oLMSAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgLwkoAAAAAoC4IKwEAAACAuiCsBAAAAADqgrASAAAAAKgL/x+/nwn+vyG/+wAAAABJRU5ErkJggg==", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -219,7 +223,7 @@ "plt.ylabel(\"|Sdd21| (dB)\")\n", "plt.grid()\n", "plt.legend(loc='upper right')\n", - "plt.axis(ymin=-40)\n", + "#plt.axis(ymin=-40)\n", "plt.show()" ] }, @@ -235,8 +239,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 14, "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T11:23:36.886209Z", + "start_time": "2023-08-03T11:23:36.491882Z" + }, "scrolled": false }, "outputs": [ @@ -244,44 +252,38 @@ "name": "stdout", "output_type": "stream", "text": [ - "se ref. frequencies: 0.0-100.0 GHz, 5001 pts\n", - "se frequencies: 0.0001-100.0 GHz, 1000000 pts\n" + "via ref. frequencies: 0.0-40.0 GHz, 300 pts\n", + "via frequencies: 0.13377926421405-39.8662207357869 GHz, 298 pts\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" }, { "data": { - "image/png": "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\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -301,7 +303,9 @@ "\n", "for (lbl, _), sdd_21, clr in zip(chnls, sdd_21s, clrs):\n", " # Testing/comparing one-line solution, using scikit-rf.\n", - " sdd_21_ref = sdd_21.extrapolate_to_dc().windowed()\n", + " #sdd_21_ref = sdd_21.extrapolate_to_dc().windowed()\n", + " #sdd_21_ref = sdd_21.extrapolate_to_dc()\n", + " sdd_21_ref = sdd_21.windowed()\n", " Href = sdd_21_ref.s[:,0,0]\n", " fref = sdd_21_ref.f\n", " Fref = rf.Frequency.from_f(fref / 1e9) ## skrf.Frequency.from_f() expects its argument to be in units of GHz.\n", @@ -310,7 +314,7 @@ " # if(fref[0] != 0): # Add the d.c. point, if necessary.\n", " # Hrefp = np.pad(Hrefp, (1,0), 'constant', constant_values=1.0) # Presume d.c. value = 1.\n", " href = np.fft.irfft(Href)\n", - " href /= np.abs(href.sum()) # Equivalent to assuming that step response settles at 1.\n", + " #href /= np.abs(href.sum()) # Equivalent to assuming that step response settles at 1.\n", "\n", " # Form frequency vector.\n", " f = sdd_21.f\n", @@ -318,19 +322,21 @@ " if(fmin == 0): # Correct, if d.c. point was included in original data.\n", " fmin = f[1]\n", " fmax = f[-1]\n", - " f = np.arange(fmin, fmax + fmin, fmin)\n", + " # f = np.arange(fmin, fmax + fmin, fmin)\n", + " f = np.arange(fmin, fmax, fmin)\n", " F = rf.Frequency.from_f(f / 1e9) ## skrf.Frequency.from_f() expects its argument to be in units of GHz.\n", " print(\"{} frequencies: {}\".format(lbl, F))\n", "\n", " # Form impulse response from frequency response.\n", - " sdd_21 = sdd_21.interpolate_from_f(F)\n", + " # sdd_21 = sdd_21.interpolate_from_f(F)\n", + " sdd_21 = sdd_21.interpolate(F)\n", " H = sdd_21.s[:,0,0]\n", " # H = np.concatenate((H, np.conj(np.flip(H[:-1], 0)))) # Forming the vector that fft() would've outputted.\n", " Hp = H.copy()\n", - " Hp = np.pad(Hp, (1,0), 'constant', constant_values=1.0) # Presume d.c. value = 1.\n", + " Hp = np.pad(Hp, (1,0), 'constant', constant_values=0.0) # Presume d.c. value = 1.\n", " # h = np.real(np.fft.ifft(H))\n", " h = np.fft.irfft(Hp)\n", - " h /= np.abs(h.sum()) # Equivalent to assuming that step response settles at 1.\n", + " # h /= np.abs(h.sum()) # Equivalent to assuming that step response settles at 1.\n", " \n", " # Form step response from impulse response.\n", " s = np.cumsum(h)\n", @@ -411,21 +417,23 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 8, "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:42:18.104948Z", + "start_time": "2023-08-03T01:42:17.957338Z" + }, "scrolled": false }, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABSgAAAK7CAYAAADxxGHrAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAChh0lEQVR4nOzdd3wUdf7H8femEEJJ6KF3pCWhShWwAYKKqCg27Of507tT0fPkzu6d7fTEcrbTO049ARGFU1HAgqAgitJ7rwlNSCCB1Pn98bnJZAkqKJtJMq/n4zGP7Hd2dvY7u7Ob3fd+Zr4hx3EcAQAAAAAAAIAPovzuAAAAAAAAAIDgIqAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAACoQObPn6/zzz9fTZs2VVxcnJKSktS7d2/dfvvtYcs9//zzGjdunD+d/J9QKBQ2JSQkqE+fPho/fryv/QIAAEDpCjmO4/jdCQAAAPxyH3zwgYYNG6ZTTz1Vv/rVr9SgQQOlpaVpwYIFmjBhgrZt21a0bHJysurUqaNZs2b51t9QKKQRI0bo9ttvl+M42rhxox5++GEtX75c//nPf3TZZZf51jcAAACUHgJKAACACmLAgAHavn27Vq1apZiYmLDrCgsLFRXlHTxTVgLKm2++Wc8991zRvM2bN6t58+bq37+/Pv/8c9/6BgAAgNLDId4AAAAVxN69e1WnTp0S4aSksHCyefPmWr58uT7//POiw6ubN29edH1mZqbuuOMOtWjRQpUqVVKjRo106623KisrK2ydoVBIv/nNb/TSSy/ppJNOUlxcnDp06KAJEyb87G1o1qyZ6tatq507d4bNP9Y+TZo0ST179lRiYqKqVKmili1b6tprry26ftasWQqFQnrjjTc0evRo1a9fX/Hx8RowYIAWLlxYoj///e9/1bt3b1WpUkXVq1fXwIEDNW/evLBl7r//foVCIS1fvlyXXnqpEhMTlZSUpGuvvVYZGRnH1b/j2VYAAICKouSnVwAAAJRLvXv31iuvvKLf/e53uvzyy9W1a1fFxsaWWO7dd9/ViBEjlJiYqOeff16SFBcXJ0nKzs7WgAEDtG3bNv3xj39Uamqqli9frnvvvVdLly7Vxx9/rFAoVLSu//73v/rss8/04IMPqmrVqnr++ed16aWXKiYmRiNGjDjubcjIyND333+vXr16Fc071j7NmzdPI0eO1MiRI3X//fercuXK2rx5sz799NMS9/PHP/5RXbt21SuvvKKMjAzdf//9OvXUU7Vw4UK1bNlSkvTmm2/q8ssv16BBgzR+/Hjl5OTo8ccf16mnnqpPPvlEp5xyStg6L7zwQo0cOVLXXXedli5dqjFjxkiS/vnPf0rSMfXveB9/AACACsEBAABAhbBnzx7nlFNOcSQ5kpzY2FinT58+ziOPPOIcOHAgbNmOHTs6AwYMKLGORx55xImKinK++eabsPlvv/22I8mZNm1a0TxJTnx8vJOenl40Lz8/32nXrp3TunXrn+yvJOemm25y8vLynNzcXGfNmjXOsGHDnOrVqzsLFiw47j498cQTjiRn//79P3ifn332mSPJ6dq1q1NYWFg0f9OmTU5sbKxz/fXXO47jOAUFBU7Dhg2dlJQUp6CgoGi5AwcOOPXq1XP69OlTNO++++5zJDmPP/542H3ddNNNTuXKlYvu51j6dzyPPwAAQEXBId4AAAAVRO3atTVnzhx98803evTRR3XeeedpzZo1GjNmjFJSUrRnz56fXMf777+v5ORkde7cWfn5+UXT4MGDFQqFSpyz8owzzlBSUlJROzo6WiNHjtS6devCBuX5Ic8//7xiY2NVqVIlnXTSSfrwww81fvx4devW7bj7dPLJJ0uSLr74Yr311lvavn37D97vZZddFlaJ2KxZM/Xp00efffaZJGn16tXasWOHRo0aFXZ4fLVq1XThhRfqq6++UnZ2dtg6hw0bFtZOTU3V4cOHtWvXrmPu3/E+/gAAABUBASUAAEAF0717d/3hD3/QpEmTtGPHDt12223atGmTHn/88Z+87c6dO7VkyRLFxsaGTdWrV5fjOCVCzvr165dYhztv7969P3l/F198sb755hvNnTtXL730kqpXr65LLrlEa9euPe4+9e/fX1OmTFF+fr6uvPJKNW7cWMnJyRo/fvwP9vHIeW6f3b8NGjQosVzDhg1VWFioffv2hc2vXbt2WNs9bP7QoUPH3L/jffwBAAAqAs5BCQAAUIHFxsbqvvvu01NPPaVly5b95PJ16tRRfHx80XkTj3Z9cenp6SWWcecdGdgdTd26ddW9e3dJdg7N9u3ba8CAAbrtttv0/vvvH3efzjvvPJ133nnKycnRV199pUceeUSXXXaZmjdvrt69e/9kv90+u3/T0tJKLLdjxw5FRUWpZs2aP7l9R/qp/h3v4w8AAFAREFACAABUEGlpaUet+Fu5cqUkq/xzxcXFFVX2FXfOOefo4YcfVu3atdWiRYufvM9PPvlEO3fuLDrMu6CgQBMnTlSrVq3UuHHj496Gfv366corr9S///1vzZs3T7179z7uPkm2fQMGDFCNGjU0ffp0LVy4MCygHD9+vEaPHl10mPfmzZs1d+5cXXnllZKktm3bqlGjRnrzzTd1xx13FC2XlZWlyZMnF43s/XP9UP9+zrYCAACUdwSUAAAAFcTgwYPVuHFjnXvuuWrXrp0KCwu1aNEiPfnkk6pWrZpuueWWomVTUlI0YcIETZw4US1btlTlypWVkpKiW2+9VZMnT1b//v112223KTU1VYWFhdqyZYtmzJih22+/XT179ixaT506dXT66afrnnvuKRrFe9WqVZowYcLP3o6HHnpIEydO1D333KOPP/74mPt07733atu2bTrjjDPUuHFj7d+/X08//bRiY2M1YMCAsPvYtWuXzj//fP3qV79SRkaG7rvvPlWuXLlo5O2oqCg9/vjjuvzyy3XOOefo17/+tXJycvTXv/5V+/fv16OPPnrc23Us/Tvexx8AAKAiIKAEAACoIO6++25NnTpVTz31lNLS0pSTk6MGDRrozDPP1JgxY9S+ffuiZR944AGlpaXpV7/6lQ4cOKBmzZpp06ZNqlq1qubMmaNHH31UL7/8sjZu3Kj4+Hg1bdpUZ555ppo3bx52n8OGDVPHjh119913a8uWLWrVqpX+85//aOTIkT97O5o0aaLf/va3+utf/6rZs2erf//+x9Snnj17asGCBfrDH/6g3bt3q0aNGurevbs+/fRTdezYMew+Hn74YX3zzTe65pprlJmZqR49emjChAlq1apV0TKXXXaZqlatqkceeUQjR45UdHS0evXqpc8++0x9+vQ57u06lv4d7+MPAABQEYQcx3H87gQAAADKn1AopJtvvlnPPfec3105ZrNmzdJpp52mSZMmacSIEX53BwAAAGIUbwAAAAAAAAA+IqAEAAAAAAAA4BsO8QYAAAAAAADgGyooAQAAAAAAAPiGgBIAAAAAAACAbwgoAQAAAAAAAPgmxu8OlEWFhYXasWOHqlevrlAo5Hd3AAAAAAAAgHLFcRwdOHBADRs2VFTUj9dIElAexY4dO9SkSRO/uwEAAAAAAACUa1u3blXjxo1/dBkCyqOoXr26JHsAExISfO5NZOTl5WnGjBkaNGiQYmNj/e4OKhD2LUQK+xYihX0LkcK+hUhh30KksG8hUti3gikzM1NNmjQpytl+DAHlUbiHdSckJFTogLJKlSpKSEjgzQEnFPsWIoV9C5HCvoVIYd9CpLBvIVLYtxAp7FvBdiynT2SQHAAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaAEAAAAAAAA4BsCSgAAAAAAAAC+IaCE58ABaeFCv3sBAAAAAACAACGghOe3v5W6dpX+8hdr//Of0kMPSYcO+dsvAAAAAAAAVFgxfncAZci//21/775buvBCaccO6d57pXfflf7v/6QvvpBiY6VOnaTUVGnAAH/7CwAAAAAAgHKPgBKebt2kb7+V4uKkOnWkyy6T7rnHDvu+4YbwZU87Tfr0U6994YVSYqJUt66UlCT17m3rq1SpdLcBAAAAAAAA5QoBJTy5ufb3vfcsoKxTR9qyRbr1ViktzULJqChpyRKroHRlZlqVpeOUXGfVqtLAgXa9a+1aqVUrWxcAAAAAAAACjYASnsOH7W98vDevSRNp8uQfv11srPT229KyZdL+/dLGjdKcOdLevVJWltS0qbfsgQNS+/ZSQoLUpo3UoIGFnb17SyedZPdH1SUAAAAAAEBgEFDCk5Njf+Piju928fHSBRfY5CostIAyI0OqVs2bv3q1VLmytG+f9PXXNm/qVO/6G2+UXnjBLh86JE2bJqWkWMVldPTxbxMAAAAAAADKNAJKeL74QsrODq94/Lmioux8lHXrhs/v3t2qLJcsscPHt26VvvnGzn25caOFka7ly6URI+xy5cpWeZmSIiUn29S9e8n1AwAAAAAAoFwhoISnSZPSuZ+YGKlrV5uKcxypoMBrHz5sA+2sWGHVlAsX2uR68klp9Gi7vHWrVWK64WWdOpHfDgAAAAAAAPxiBJQoO0IhCy9dp5wiLVhgoeXGjXaOy+JTp07esl9+Kf32t147KckLK5OTpcGDSy+ABQAAAAAAwDEjoIRxHOnOO+1Q6rvustG3y4roaKl1a5uGDz/6MrVrS8OGWXC5YYO0c6dNn3xi10+d6gWUX30VXm3Zrt3xn3cTAAAAAAAAJwQBJUxurvTEE3b59tv97cvPMXCgTZJ08KC0cqW0dKlXbZma6i378cfSo4967ehoG1HcDSyvu05q3Lh0+w8AAAAAABBQBJQw7gjeUvmvJqxWTTr5ZJuOpkcPGy3cDS/375dWrbLp7bdtYB43oHzjDWnGDAs4e/Swc2KWpepSAAAAAACAco6AEqYiBZQ/ZdAgmyQ7tH3HjvBzW550krfsxx9Lr7/utUMhqUULr9ry97+XatQo1e4DAAAAAABUJASUMIcP29/YWCkqyt++lKZQSGrUyKbBg0tef801UqtWNnr4/PkWZm7YYNN770l33+0t++c/W8DphpcpKRZmBunxBAAAAAAAOE4ElDBuBWXlyv72o6wZMMAm165d0vLlFkSmp0vx8d51H31ko4lPnOjNq1rVwsrUVOmFF+x8lwAAAAAAAChCQAnjVlBW9MO7f6l69Ww67bSS1z3wgPTtt96h4itWSFlZXuVl8XBy1Chp714LLlNS7G/btlKlSqW3LQAAAAAAAGUAASUMFZS/3Bln2OTKz5fWrrXRxA8dCl92xgyrxvzwQ29eTIzUrp3Uv7/097+XTp8BAAAAAAB8RkAJ06GDBWk4cWJipPbtbSrOcaR335WWLLFp6VL7m5lplZd164Yv36WLVL26V2mZkmKHjScklN62AAAAAAAARAgBJUx8vIVeiLxQSOrTxyaX40hbt1pYWfww78xMadEiuzxnTvh6mjeXLr5Yeuwxb15BAee5BAAAAAAA5QoBJVAWhEJS06Y2FVe1qrR4cXil5dKl0vbt0qZN0r593rI5OVLt2lKbNuHVlikpUoMGdh8AAAAAAABlDAElzIoV0qRJUqtW0hVX+N0buKKjLWhMTQ2f//33FlTWrOnNW7nSBuVZtMirunTVri3ddpv0pz9Zu7DQzotZtWokew8AAAAAAPCTCChhliyR7r/fRqcmoCz7atWSBgwIn5eaKq1fH15puXSptGaNjRgeU+zlvnatnRuzZcvwasvUVAupOUwcAAAAAACUEgJKmMOH7S+jeJdfUVEWOLZsKZ13njf/0CGrrqxXz5u3cqWd93L9epumTPGui4+X/vY36cYbvdtnZ1sVJgAAAAAAwAlGQAmTk2N/4+L87QdOvPh4qWvX8HnDh0u7dpWstly2zALJ4mHmp59K55wjNWzoHW7uTm3bhg/qAwAAAAAAcJwIKGHcCkoCyuCoW1c6/XSbXAUF0oYNUlKSN2/jRvu7Y4dNH33kXRcbK739tjRsmLX37rWRxx0n8v0HAAAAAAAVAgEljFtBySHewRYdbaOAF/eb30hXXWXVlUuWhE+ZmVLz5t6yr7+u2Ntu09AqVRTdubOd1zI5WerUySouExNLc2sAAAAAAEA5QEAJQwUlfkz16lLv3ja5HEfaskVq1Mibt3u3nOhoxWZnS3Pn2lTcN99I3bvb5U2bpLw8O2cmg/IAAAAAABBYBJQwDJKD4xUKSc2ahc/7y1+UP2aMvnj1VfWrWVMxq1bZuS0XL5a2bZPatfOWffJJ6bnnpCpVpI4dw0cTT0mxQ9ABAAAAAECFR0AJc/PNdh7B4oOjAD9HXJwymzeXM3SonaPSlZEhVavmtXNyLBDPzrbKym++CV/Pnj3eyOHffmtVlu3bU+ULAAAAAEAFQ0AJ06hR+KG6wIl25PknX35ZeuEFad06bxRxd0Txw4e9cFKS/vQnafp0CynbtvVGEXerLps0sYpOAAAAAABQ7hBQAvCPGzi2bSuNGOHNz80NXy4hQapZU9q3T1qxwqYJE+y6xESb75oxw86ZmZxsfwEAAAAAQJlGQAnz3/9Ka9dKp58udenid28QdJUqhbffessG5dm+3au0dKst69YNr568+WarypSkFi3Cqy07dy45SjkAAAAAAPAVASXMG29IkyZJzz5LQImyKRSSGje2acgQb77jeJcLCqSTTrLzWu7YIW3caNPUqXZ9t27SggXe8q+9ZutjUB4AAAAAAHxDQAnDKN4or4pXT0ZHSx98YJf37i1ZbXnyyd6yubnSdddJ+fnWrl8/vNry5JNtUB4AAAAAABBRBJQwOTn2lxGSUVHUri2deqpNR5ORIZ17roWX69dL6ek2zZhh119yiTR+vF0uLJT++lc7r2VKCoPyAAAAAABwAhFQwlBBiaCpW1d65x27fPCgtHx5eLVl797eshs2SHfd5bUTE8OrLfv3p9oSAAAAAICfiYAShgpKBFm1alLPnjYdTWGhdNllFl6uWmXVl3Pm2CRJf/qT9Oc/2+Xdu+1crm542bq1HXoOAAAAAACOKsrPO589e7bOPfdcNWzYUKFQSFOmTPnR5WfNmqVQKFRiWrVqVdhykydPVocOHRQXF6cOHTro3XffjeBWVBBUUAI/7KSTpP/8xyors7KkxYul11+Xfv976ayzwqstv/tOeugh6aKLpHbtpOrV7XyW110njR0rrVnj22YAAAAAAFAW+VpBmZWVpU6dOumaa67RhRdeeMy3W716tRISEoradYuNvjtv3jyNHDlSDz30kM4//3y9++67uvjii/XFF1+o5w9VR4EKSuBYVarkHd59NHXqWBi5ZIm0bJl06JCNHO6OHl6zpgWeki3zxhtetWW7drwGAQAAAACB42tAOWTIEA0ZMuS4b1evXj3VqFHjqNeNHTtWAwcO1JgxYyRJY8aM0eeff66xY8dqvDvgBUp67TU7bPWHQhcAx6ZbN+mVV+xyQYGdv7L4uS27d/eWnT3bBt9xxcRYSOkGlpdcIjVvXqrdBwAAAACgtJXLc1B26dJFhw8fVocOHXT33XfrtNNOK7pu3rx5uu2228KWHzx4sMaOHfuD68vJyVGOW0EoKTMzU5KUl5envLy8E9v5MsLdrqLt69y5+JWl3yFUGCX2raBr3tymYcO8ef97bEIdOij0f/+n0NKlCi1bptD+/VZ1uWyZJCm/Vy85jRrZstOnK/TRR3JSUqTkZDkdO0pVq5butviMfQuRwr6FSGHfQqSwbyFS2LcQKexbwXQ8z3fIcRwngn05ZqFQSO+++66GDx/+g8usXr1as2fPVrdu3ZSTk6PXX39dL774ombNmqX+/ftLkipVqqRx48bpsssuK7rdm2++qWuuuSYshCzu/vvv1wMPPFBi/ptvvqkqVar8sg0DgGPhOKq8Z48SN29WwqZNSti8WYtvvFH5/wshk199Va3ee89bPBRSVv36ymzWTJnNmmnjkCHK/YHKcgAAAAAASlt2drYuu+wyZWRkhJ2q8WjKVQVl27Zt1bZt26J27969tXXrVj3xxBNFAaVkYWdxjuOUmFfcmDFjNHr06KJ2ZmammjRpokGDBv3kA1he5eXlaebMmRo4cKBiY2MV9cILUkyMCi+91EY0Bn6mI/ct/HyDil0OVaqkgtatvWrL9HRVS0tTtbQ0NfzqK7V64gkpKUmSFPWPfyj03XdyUlLkJCfLSU6WatXyZyNOIPYtRAr7FiKFfQuRwr6FSGHfQqSwbwWTe4TysShXAeXR9OrVS2+88UZRu379+kpPTw9bZteuXUr63xf3o4mLi1PcUQamiI2NrfAvnKJtvO02qbBQ0eefb4N4AL9QEF4/pWrIEJtcu3bZOS2XLJHWr1ds48beddOmSR98EH77xo3tvJapqdJ990nx8aXT7whg30KksG8hUti3ECnsW4gU9i1ECvtWsBzPc13uA8qFCxeqQYMGRe3evXtr5syZYeehnDFjhvr06eNH98qH/HypsNAuM4IwUD7UqyedcYZNR7rpJjuvrDswz6ZN0rZtNs2ZIz38sLfsXXdJO3Z4A/Okpkr160s/UnUOAAAAAMCJ5GtAefDgQa1bt66ovXHjRi1atEi1atVS06ZNNWbMGG3fvl2vvfaaJBuhu3nz5urYsaNyc3P1xhtvaPLkyZo8eXLROm655Rb1799fjz32mM477zxNnTpVH3/8sb744otS375y4/Bh73Llyv71A8CJMXSoTa6MDBt4Z8kS6cABKSrKu27qVGnVqvDb16ljQWX37tJjj5VOnwEAAAAAgeVrQLlgwYKwEbjd80BeddVVGjdunNLS0rRly5ai63Nzc3XHHXdo+/btio+PV8eOHfXBBx9oaLEv4n369NGECRN0991365577lGrVq00ceJE9ezZs/Q2rLwpPngQFZRAxZOYKPXta9OR/vpXadEir9pyzRppzx7p00+l778PDyhHjLBws3i1ZbNm4YEnAAAAAADHydeA8tRTT9WPDSI+bty4sPadd96pO++88yfXO2LECI0YMeKXdi843IAyOtomAMFxzjk2uQ4dklassMCy+A8W+fnSe+9JubnSpEne/OrVpeRkafBgO7clAAAAAADHqdyfgxIngHuIN4d3A4iPl7p1s+lI771nwaVbbblihR0yPm+e1KiRt5zjSJ06Sc2be5WWqalSmzZSDP92AAAAAADh+KYIr4KSw7sB/JCYGGnQIJtceXl2SPiSJVJSkjd/yxYLMJcutVDTFRcndeggjRolFRvIDAAAAAAQbASUkJo0kT780KqeAOBYxcZKHTvaVFxSkvT55+HVlkuXSllZ0sKFdji4a9cur8Ky+Lkt27enqhsAAAAAAoKAElK1atJZZ/ndCwAVReXKUv/+NrkKC6WNGy2wbN3am79kibRzpzRzpk2u6GjppJOkO++Urr7aWwc/pAAAAABAhUNACQCIvKgoqVUrm4rr21eaPz+82nLJEhtBfOVKqaCgaNHQV19p6OWXK7prVzvHpVttmZxsg/UAAAAAAMolAkrY+eJmzpQaNJCGDvW7NwCCJD5e6tHDJpfjSDt2WFiZklI0O7RsmWKys6UvvrCpuBYtpGee8UYkz821Kszo6FLYCAAAAADAL0FACTsn3PXXS716EVAC8F8oZKOCFx8ZXFLh1Vdrdn6++iUmKmbFCq/acscOO3y8eBXlhAnSjTdadWXxc1umpEh16pTyBgEAAAAAfgwBJRjFG0D5UKmSMps3lzN0qA3Q49q718LKbt28ecuWSYcOSd98Y1NxDRtKU6ZIJ59s7QMH7P2vUqWIbwIAAAAAoCQCSkiHD9tfRswFUB7Vri2demr4vEcescrwI89tuWGDVVwWr858/HHp0Udt5PDi1ZapqRZmhkKlujkAAAAAEDQElKCCEkDF444CftJJ0ogR3vwDB6Tly+2cu661a6X8fAsxly4NX0/NmhZsNm5s7fR0O5S8atXIbwMAAAAABAQBJaigBBAc1avb+XaLGz/eqiiPrLZcvdp+wCkeZo4ebee3bN26ZLVlixY2WjkAAAAA4LgQUIIKSgDBFgpJTZva5I4CLtmPN5s3h48Evn27jTK+dq1Nkyd719WoIe3eLcX871/r2rU2IE/NmqWyGQAAAABQXhFQggpKADiaypWltm3D533+ubRzp1dl6f5dvlxq0sQLJyXpssukBQts/pHVliedFD7QDwAAAAAEGAEl7Pxs7dpJzZr53RMAKPuSkmw680xvXn6+VU+6HEfKyrLLW7fa9MEH3vVt20qrVnntb76xIDMpiUF5AAAAAAQOASUsnGzXzu9eAED5FRMTfq7KUEhasULav19atiy82nLpUhsx3OU40uDB0r59Ut26JastO3SQ4uNLfZMAAAAAoLQQUAIAECk1akinnGKTy3FsNHHX/v1SvXpSRoZVYX7yiU2uwYOljz7y2h9+aAFns2ZUWwIAAACoEAgoIX31lQ0E0blzyfOtAQBOrFBISkjw2jVr2uHe2dlWdVm82nLxYquidO3ZIw0dapcTEqzSsni1ZUpK+LoBAAAAoBwgoIT04ovSv/8tPfqo9Ic/+N0bAAimKlWk7t1tcjmOlJfntXfvljp1siAzM1P68kubXDfdJP3973Y5O1t6/30LLlu3Dh/ABwAAAADKEL6tQCoosL98eQWAsiUUkipV8trt20uLFllouXp1eLXlkiXh1ZbLlkkjR9rlypWljh3Dqy27drXqTQAAAADwGYkUpMJC+xsV5W8/AADHJjZWSk62qTjH8S7n5Eg9e1qAmZ0tffutTa6nnpJuvdUub99u571MTbUQNC4u4psAAAAAAC4CShBQAkBFUXzQnH797BzDhYXShg0lqy07dfKWnTVLuuoquxwdbecjdistU1Ol3r2lWrVKdVMAAAAABAcBJQgoAaAii4qyc1C2bi1dcMHRl6lWTRowwILLffvsHJcrVkgTJtj1//2vdO65dnnxYmn+fAsuk5PttgAAAADwCxBQgoASAILuvPNschw73PvHzm05dap0331eu1Wr8GrLM89kJHEAAAAAx4WAEgSUAAATCkmNG9s0dOjRl2nRQho82ILLtDRp/Xqb3n3Xrl+50gsop0+3wXzc8JLDxAEAAAAcBQElpN/+Vho2zAZTAADgx4waZZMk7d7tVVsuXWrhZOvW3rJvvGGTq1Gj8GrL88+X4uNLt/8AAAAAyhwCSkinnup3DwAA5VHdutIZZ9h0NH36SAcOWIi5caMdPr59u/Thh1a1n5XlLfuvf0l790opKRZe1q8fPugPAAAAgAqLgBIAAETG//2fTZKUmSktW+ad1zIjQ6pc2Vv25Zdt1HFXnTrh1ZZXX01gCQAAAFRQBJSw0Vh375Y6dZKaNPG7NwCAiighwSoq+/Q5+vUXXWT/g5YuldaskfbskT791KamTaVrrvGWffBBq8B0qy2bNye8BAAAAMoxAkpI998vffSRNG6cdNVVfvcGABBEo0d7lw8dklas8Kotq1b1rnMc6dlnLcB0Va/uhZV9+njnyAQAAABQLhBQglG8AQBlS3y81K2bTUcqKJD+8AertFyyxILMAwekuXNtWrs2PKC89lobnMcNMNu0kaKjS29bAAAAAPwkAkoQUAIAyo+YGOmOO7x2Xp4dEu5WW7Zq5V23f78NvlNc5cpSx44WVp51lnTxxaXSbQAAAAA/jIASBJQAgPIrNtYCx44dpUsvDb8uFJKeecaCy6VLbcrOlr791qZKlYoCyqicHEWfc44Fl261Zfv2UlycDxsFAAAABAsBJQgoAQAVU2Ki9Nvfeu3CQmnDBq/aslevoquqb92qqBkzpBkzvOWjo6V27SysvOwy6ZxzSrHzAAAAQHAQUIKAEgAQDFFRUuvWNl1wQdhVh+vUUf4LLyhm+XKrtFy82A4RX77cpq5dvYByzRrphhvCqy2Tk8MH8wEAAABwzAgo4QWUDBoAAAionBo15Fx2mR0yLtlo4du3e9WWAwd6Cy9cKH3+uU2uUMjOf5maKv3ud9KAAaW7AQAAAEA5RkAJ6fbb7dC1zp397gkAAGVDKCQ1bmzT0KHh1/XtK/373965LZcskdLTpXXrbCo+ivj06dJ991lw6VZcpqRItWqV7vYAAAAAZRgBJaThw/3uAQAA5UfjxtKVV4bP27XLCyt79vTmL1ggzZ9v05HrSE2V/vIXfiAEAABA4BFQAgAA/FL16klnnGFTcVdeKbVp4x0qvnSptGmTtG2bTY895i373HPSq6+GV1umpkpJSVbRCQAAAFRQBJSQvv5aOnhQ6tRJql3b794AAFBxNGli08UXe/MyMqRly2wgnrZtvfkLFkiLFtlUXN26FlT+61+2LsnOkUloCQAAgAqCgBLS//2f9N130ocfSmed5XdvAACo2BIT7TyWffuGz3/oIen888OrLdeskXbvlj79NPy8lbfcIs2c6VVbuhWXzZoRXAIAAKDcIaCEN4p3VJS//QAAIMjcasvzzvPmZWdLK1ZI69dLVat68xculFatsumtt7z5CQkWVH7yiRQXZ/Py86UYPvIBAACg7OLTKggoAQAoq6pUkbp3t6m4t97yKi3dassVK6TMTDvHpRtOStLZZ0tr15Y8t2Xr1lJ0dKluDgAAAHA0BJQgoAQAoLxp0MCmwYO9eXl50urVdkh4cUuWSOnp0saN0tSp3vz4eOmUU6QZM7x5WVnhlZoAAABAKSCgBAElAAAVQWyslJxccv6yZVZhWbzaculS6dAhKTc3fNnUVJt/5Lkt27ULr8oEAAAATiACSkgFBfaXgBIAgIqndm3p1FNtchUUSBs2WMWkKyvLDg8vLJTS0qTp073rYmKkiy6S3nzTm7drl40wzqA8AAAA+IUIKEEFJQAAQRMdLbVpEz6valUpI8MqLpcskRYv9qot9++382G6cnKkRo1sUJ4jqy07duQwcQAAABwXAkpId90lff+91Ly53z0BAAB+qlZN6tXLJpfjSNu2eUdcSFZ96Tj2+WHWLJtcoZB0yy3SU09Zu6DAKjNbtODHUAAAABwVASWka6/1uwcAAKCsCoWkJk3C57VvLx08KK1cWXI08Z07pfr1vWXXr5fatrWqSncEcbfaMiVFqlmzdLcHAAAAZQ4BJQAAAI5f5cpSly42Fbdzp52z0rV5sw2wk5UlffWVTcU99ph05512+eBBacsW6aSTwtcBAACACo1PfpC++07Ky7ORPzlnFAAA+CWSksLbAwda8Lh2bclqy82bpZYtvWXnzJGGDrVAs0OHkue3PHLdAAAAqBAIKCENGyZt3y59+63UtavfvQEAABVNTIwdFt6+vTRypDd//36pUiWvvXu3nQfz4EFp4UKbinvzTenSS+1yWppNHTpYNScAAADKLQJKMIo3AADwR40a4e0rr5SuuMIG1Tmy2nLtWgs4XZMm2WA80dF2SHjxasvUVDtvZihUmlsDAACAn4mAEgSUAACg7IiKssO+W7aUhg/35mdlhVdK5uRItWrZSOIrV9o0caJ3/dy5Uu/ednnVKmnfPjudTfXqpbIZAAAAOHYElCCgBAAAZd+R58n+/e+lO+6ww7yLV1suWSKtXm1hpOv556Vnn7XLLVuGn9cyNVVq3ZrPQQAAAD4ioAQBJQAAKJ9CIalhQ5vOOsubn5cnxcZ67fh4W2bHDmnDBpumTPGu37lTqlfPLn/5pZSba8Fl7dqlshkAAABBR0AJAkoAAFCxFA8nJemxx2zas8fOZ1m82nLvXi+clKS//EX68EO73LBhyWrLlBTObQkAAHCCEVCCgBIAAARDnTrSaafZ5HKc8GWaNLHDwDdssIrLHTukjz6y6xISbORx15Qpdl7M1FSpQQOCSwAAgJ+JgBLSH/8oHTrEYUwAACB4jgwVX3rJ/h44IC1bFj6SeEJC+PJ33mmji0v2Oap4tWWXLvYXAAAAP4mAEvbhGgAAAJ7q1W0UcHck8CMVFkrdu0sxMTYoz9690mef2SRZQDl/vrf8iy9K9etbgNm8OUeuAAAAFENACQAAAByvqCjpzTft8qFD0sqV4dWWxUcRz8uTfvc7+ytJ1ap557RMTZV69pS6dSv9bQAAACgjCChhH6JDIalt25InlQcAAMCPi4+Xuna1qTg3kDxwQLrsMgsvly+XDh6U5s2zSZIuvliaONEuFxZK998vdexo4WWbNlalCQAAUIHxaQf2i31enrRtm9Sokd+9AQAAqFhq1ZLGjbPLeXl23sriI4kPGOAtu2mT9NBDXjsuzgsrU1NtgJ/OnUux8wAAAJFHQAlG8QYAACgtsbFShw42XXJJyetDIemGG7xDxbOypO++s0mywQ3dgHL3bunRR73wsn17G1UcAACgnCGgBAElAABAWdGihTeSeGGhtHFjeLXlKad4yy5cKP3tb147OtpO2eMGlsOGWfUlAABAGUdAGXSOY5NEQAkAAFCWREVJrVrZdP75Ja+vX98G31myRFq8WNq3T1qxwqYJE+x6N6BcskR6+WUvvExOtsF6AAAAygACyqBzw0mJgBIAAKA8SU2Vnn7aLjuOtGNH+EjiPXp4y37xhfT3v4ffvlUrL7AcNcraAAAAPiCgDDr38G7JznkEAACA8icUssEOGzWShgwpeX23btKdd3oB5o4d0vr1Nr37rnTGGV5A+cEHNs8NL1NSpNq1S3d7AABAoBBQBl3xgJIKSgAAgIqpZ0+bXHv2WJWlG1impHjXffKJ9Oqr4bdv1MgLLG+91Q4fBwAAOEEIKIMuKkr6wx/ssCBGfQQAAAiGOnWk006z6UjDh9v5Kd3wcuNGaft2mz78ULrlFm/ZF16Q5s71wsvUVAsvOTIHAAAcB19L5mbPnq1zzz1XDRs2VCgU0pQpU350+XfeeUcDBw5U3bp1lZCQoN69e2v69Olhy4wbN06hUKjEdPjw4QhuSTkWEyM9+qj02GMElAAAAJD695cefFCaMkXasEHKyJC+/NLCyNtuC6+e/PBD6Y037PDxs86SGjaU6tWzQ8Zvu03KyvJtMwAAQPnhawVlVlaWOnXqpGuuuUYXXnjhTy4/e/ZsDRw4UA8//LBq1Kihf/3rXzr33HM1f/58denSpWi5hIQErV69Ouy2lQnfAAAAgOOXkCD16WPTkW69VerVy6u2XL3aDh//9FNp/nzpySe9ZX//e2nTpvBqy2bNOM0QAADwN6AcMmSIhhztJN4/YOzYsWHthx9+WFOnTtV7770XFlCGQiHV57w4x6agQNqyxQ7DadGCw3EAAABw7E4/3SbXoUPSypUWVu7bFx4+fvCBXff229686tXt/Jfdu3sjkgMAgMAp1+egLCws1IEDB1SrVq2w+QcPHlSzZs1UUFCgzp0766GHHgoLMI+Uk5OjnJyconZmZqYkKS8vT3l5eZHpvM/c7cr7/nvFtm5tl7OypNhYP7uFCqBo36qgrx34h30LkcK+hUgJ5L4VE2OBozvoTrFtDz31lEKLFyu0dKlCS5dKK1cqdOCANHeunAMHlF9s2egLLpAcR05yspyUFDkpKVKbNrZ+BHPfQqlg30KksG8F0/E83yHHcZwI9uWYhUIhvfvuuxo+fPgx3+avf/2rHn30Ua1cuVL16tWTJH311Vdat26dUlJSlJmZqaefflrTpk3T4sWL1aZNm6Ou5/7779cDDzxQYv6bb76pKlWq/KztKS9iDxzQ0FGjJElTJ0+WoqN97hEAAACCIJSfr2o7dihh0yY5UVHaccopNr+gQGdfeqmic3PDli+IjdWBJk20q2tXrbziCj+6DAAAjkN2drYuu+wyZWRkKCEh4UeXLbcB5fjx43X99ddr6tSpOvPMM39wucLCQnXt2lX9+/fXM888c9RljlZB2aRJE+3Zs+cnH8DyKi8vTzNnztTALl1UpVkzm5eTwyHe+MWK9q2BAxVLRS5OIPYtRAr7FiKFfetnKihQaO5cq7JctswqLpctU+h/A+4Unn++CiZOtGUdRzEpKXKaNbNqy/9VXKp9eykuzseNiCz2LUQK+xYihX0rmDIzM1WnTp1jCijL5TESEydO1HXXXadJkyb9aDgpSVFRUTr55JO1du3aH1wmLi5OcUf5ABMbG1vhXzixxSomYytV8rEnqGiC8PqBP9i3ECnsW4gU9q3jFBtb8tyWhYXSxo3SkiWKqlVLUe7juXmztGaNQmvWSDNnestHR0vt2klXXmkjjLscp0L9IM++hUhh30KksG8Fy/E81+UuoBw/fryuvfZajR8/XmefffZPLu84jhYtWqQU9zw4CFdYaH8ZPREAAABlVVSU1KqVTcU1aCB99ZUNyrN0qTea+L590vLl0t693rK7d0snneSNIJ6SYn+Tk6Vq1Up3ewAAQBhfA8qDBw9q3bp1Re2NGzdq0aJFqlWrlpo2baoxY8Zo+/bteu211yRZOHnllVfq6aefVq9evZSeni5Jio+PV2JioiTpgQceUK9evdSmTRtlZmbqmWee0aJFi/T3v/+99DewPCCgBAAAQHlVqZLUs6dNLseRtm+3oLJpU2/+0qXS/v3S7Nk2FdeqlXTXXdL111ubz8gAAJQqXwPKBQsW6LTTTitqjx49WpJ01VVXady4cUpLS9OWLVuKrn/ppZeUn5+vm2++WTfffHPRfHd5Sdq/f79uuOEGpaenKzExUV26dNHs2bPVo0eP0tmo8oYPXwAAAKhIQiGpcWObijvlFGnRopLVlmlp0vr14cvOny+deaZXZVn8b61apbYpAAAEha8B5amnnqofG6PHDR1ds2bN+sl1PvXUU3rqqad+Yc8CpGpV6be/JaAEAABAxVapktSpk03F7d5tgWW7dt68JUuk7GwLKufPD1++cWPp2Wcld3DPnBz7LM051QAA+NnK3TkocYLVrCn9wOjmAAAAQIVXt274gDySdN110oABXpWlW3G5aZO0bZv0v9NLSZLeesuW79DBq7R0p/r1K9SgPAAARAoBJQAAAAAUFxNjFZXt2kkXX+zNz8iQli0Lr8JcsULKy5MWL7apuDp1pPfek3r18m5fqZIUHx/5bQAAoBwhoAy6/Hwb3TA62n49BgAAAHB0iYlS377h8x5+WPr1r0tWW65ZI+3ZIzVq5C37t79Jf/6zN5p48YrLZs2otgQABBYBZdCtX28fjGrWlL7/3u/eAAAAAOVLKCQ1b27TsGHe/EOHrLqy+GA9GzbYIJWrVtn01lvedQkJVp3ZpIm1d+yQqlWz+QAAVHAElEHHKN4AAADAiRcfL3XrFj7vtdekxx8vWW3pHibesKG37O9/L735pgWfR6u2BACgAiGgDDo3oORwEgAAACCyQiGpQQObBg/25uflSZs322mXXLt22d9Nm2z673+LroqpVk2hceO8ZVevlmrXtnNeAgBQDhFQBh0VlAAAAIC/YmOl1q3D582caadgcqssi/9t0kROTLGvclddJc2fb8HnkdWW7dpJcXGluz0AABwnAsqgI6AEAAAAyqZataQBA2xyFRYqPy1NWrDA2o5j57uUpLQ0m6ZP95Zv08YG7HF99ZWdF7NRI46iAgCUGQSUQUdACQAAAJQfUVFSvXpeOxSSFi+WDh60QXaKV1suWSJ16OAt6zjS2WdbZWbNml6VpVtxmZwsVa1a+tsEAAg8Asqgcxz7S0AJAAAAlF/Vqkm9etnkchwpK8trZ2baYeAZGdK+fdLnn9vkGjhQmjHDa3/wgR0i3qIF3xcAABFFQBl0tWpJ114r1ajhd08AAAAAnEihkAWXrsREq7LMyZFWriw5mnhqqrfs999L55xjl6tW9aosi5/fku8QAIAThIAy6Jo3l1591e9eAAAAACgtcXFS5842FZeX513evVvq2lVavtyqML/6yibX//2f9PzzdvnQIWnKFAstTzrJBv0BAOA4EFACAAAAAMKDxbZtpW+/lfLzpbVrS57bsni15bJl0mWX2eVKley8l8WrLbt1k2rXLt1tAQCUKwSUQZefb794xsRIVar43RsAAAAAZUlMjNS+vU0jR3rz3XPZS1JurtSnjwWXBw9KixbZ5HrySWn0aLu8fbs0c6YFlx06SJUrl8ZWAADKOALKgAt99ZV0+un2C+mqVX53BwAAAEB5EAp5l/v2lb78UioslDZvLllt2amTt+zs2dI119jl6Gg7JLx4tWWfPlRbAkAAEVAGXWGh/WVUPgAAAAC/RFSUjfjdooV03nlHX6Z6dem006TFi20gnpUrbZo40a6fOlUaNswuL15s571MTZWSk+22AIAKiYAy6AgoAQAAAJSWc86xyXGktDQLId1qy6VLw89t+d//Svfe67Vbtgyvthw40EYmBwCUewSUQUdACQAAAKC0hUJSw4Y2DRly9GVatJDOOsvCyx07pA0bbJoyxa5fvtwLKGfMsFNWuQEmh4kDQLlCQBl0BJQAAAAAyqIrrrBJkvbsCa+0XLFCatPGW/Y//5Fee81rN2oUXm15wQVSfHzp9h8AcMwIKIOOgBIAAABAWVenjp278rTTjn59795SRoYFmBs32mjh27dLH35o33XOP99bdtw4afduCy5TU6X69cMH/QEAlDoCyqAjoAQAAABQ3t14o02SlJkpLVvmVVvu2ydVqeIt+49/SHPneu06dbywMjVVuvpqAksAKGUElAHnJCVJI0fa+V0AAAAAoLxLSJD69LHpaEaMkBo3tgBzzRo7fPzTT21q0kS65hpv2QcftLDSDS+bNaO4AwAigIAy6Lp0kSZM8LsXAAAAAFA6brvNu3zokJ3PcskSm4pXWkrSc8/Z4eCu6tW981r27i1deWXp9BkAKjgCSgAAAABAMMXHS9262XSkggLpD3/wwssVK6QDB+zw8LlzpdWrwwPKa6+VGjTwqi3btJFi+MoNAMeCd8ugKyy0f7xRUZxnBQAAAABc0dHS7bd77bw8OyTcDSxbtvSuy8iQ/vWv8NvHxUkdO1pYedZZdmotAMBREVAGXOjdd6VLL5X69ZNmz/a7OwAAAABQNsXGWuDYsaN9hyouFLLDwd3wculSKStL+u47m2JjvYDy8GFp2DDvUPHUVKl9e6ly5dLfJgAoIwgog45RvAEAAADgl0lIkG6+2WsXFkobN3qBZY8e3nUrVkgzZ9rkio6W2ra10PKyyyzABIAAIaAMOgJKAAAAADixoqKkVq1sOv/88OsaN5ZeecWCy8WLrdry++8tuFyxQura1Qso162zc1u6lZapqVJyslStWulvEwBEEAFl0BFQAgAAAEDpqVdPuu46r+040o4d3qHhgwZ51333nTRnjk3FtWplYeXvfiedemqpdBsAIomAMugIKAEAAADAP6GQ1KiRTUOGhF/Xt6/0+uveoeJLlkhpadL69TZdcYW37MyZ0j33hFdbpqRINWuW7vYAwM9AQBl0BJQAAAAAUDY1ahQeQkrS7t1WablkidSrlzd/wQJp/nybimvSxMLKP/9Z6tw54l0GgJ+DgDLoHMf+ElACAAAAQNlXt650+uk2FXfFFXbod/Fqy82bpa1bbXr4YW/Z55+XXn65ZLVl7dqluy0A8D8ElEHXqJF07rlSt25+9wQAAAAA8HM1aWLTxRd78zIyvHNbtmvnzV+wwAboWbw4bBUxdeqoT4MGNhBPq1Y203HsMHQAiCACyoBzzjhDOussv7sBAAAAADjREhOlfv1sKu7BB6Xhw8OrLdeuVWjPHtXds0d5tWp5y956q/TRR+GVlqmpUvPmHIkH4IQhoAQAAAAAIEgaN7Zp2DBv3qFDyluyRIvefludq1Xz5i9aJK1ZY9Pbb3vzq1WzsPKTT6T4eJuXlyfFxpbKJgCoWAgoAQAAAAAIuvh4qWtX7UhPV+fi8996K7zSculSafly6eBBO8elG05KdvqwVavCz22Zmiq1bi3FED8A+GG8QwRc1MsvS6NHSxdeKL35pt/dAQAAAACUJUlJ0sCBNrny8qS1a6Vdu8KXXbJESkuz4PK997z5lStLfftKH3/szcvKkqpWjWzfAZQbBJRBl58v5ebaXwAAAAAAfkpsrNShg03FLV9uFZZHVlxmZ1uoWVynTjb/yJHE27WT4uJKb1sAlAkElEFXWGh/o6P97QcAAAAAoHyrWVPq398mV2GhtGGDVUy6srOljRvturQ0afp077qYGGnECGn8eG/ezp1SvXqMJg5UYASUQecGlIy+BgAAAAA40aKi7ByUxVWpImVkSMuWlay23L8//LyWubk2oE/16t4I4m61ZXKyDdYDoNwjoAw6AkoAAAAAQGmrVk3q1csml+NI27ZJBQXevI0bbf6+fdLs2TYV99vfSs88Y5cLC6X166WWLTlKEChnCCiDjoASAAAAAFAWhEJSkybh89q2tcPDV60qWW2ZliY1aOAtu2GDdNJJVqGZnFxyNPGaNUt3ewAcMwLKoCOgBAAAAACUZXFxNqhOp07h83fvDv8uu3mzjRienS19/bVNxT3yiHTXXXb54EFpyxYLNGOIRgC/8SoMOKdJE+n006X27f3uCgAAAAAAx65u3fD2GWdY8LhunVdpuXix/d28WWrVylv2iy+kIUMs/OzQwTu/pfs3KYlBeYBSREAZcM7IkdIVV/jdDQAAAAAAfrnoaDssvG1b6aKLvPkZGVJsrNfevdvOg3nwoLRwoU3FvfGGdPnldjktzc6N2bGjHT4O4IQjoAQAAAAAABVbYmJ4e9QoCyA3brTzWS5d6lVdrltnVZWuyZNtMJ5QyEYkP/Lcls2bc9o04BcioIS9Eb/0knT33VL9+n73BgAAAACAyIuKssO+W7WShg/35mdn26HfrtxcO5x8925p7VqbJk/2rp8zRzrlFLu8apX0/fd2qHj16qWyGUBFQEAZcFGPPy49+KC94bZsKY0e7XeXAAAAAADwz5GHcY8ebdPOneGjiC9eLK1caWGk68UXpaeftsstWtjAPm6lZUqKVWBSbQmUQEAZdFlZFk5K0oED/vYFAAAAAICyKilJGjjQJld+fvgo4PHxUqNG0vbtdvj4xo3SlCne9enpth5J+vJL6fBhCy7r1SuVTQDKKgLKoCss9C4fPuxfPwAAAAAAKG9ijohVHnnEpr17vSpLdzTxPXu8cFKSHn5YmjbNLicleSOIu1OnTlRbIjAIKIOOgBIAAAAAgBOrdm3p1FNtcjlO+DLNmtkh3+vX2+HjO3dKH39s11WrZiOPu6ZMsfNiduokNWhgA/YAFQgBZdARUAIAAAAAEHlHhorPP29/s7Kk5cvDKy6rVg2vnvzDH6Q1a+xy7dreOS1TU6XOnaVu3UplE4BIIaAMuuK/4BBQAgAAAABQuqpWlXr0sOloHEfq3l2KjpZWr7bDxz/7zCbJAsqFC73l//53O6dlaqpVaEZHR3wTgF+KgDLoqKAEAAAAAKDsCoWk//zHLh86JK1YYdWWS5datWVysrdsXp6NOO4Ohhsfb9d36mRTr14WdgJlDAFl0DVpItWsKe3bR0AJAAAAAEBZFh9vh3P/0CHdWVnSFVdYeLlsmQWa33xjkySNGCFNmmSXHUd64AGpQwc7XLxNm5KD/gClhD0v4Ap/+1tFz54tTZ1KQAkAAAAAQHlWo4b06qt2uaDABuApPpJ48UF7Nm2ygNIVFye1b29hZUqKdPrpnNsSpYaAEt5h3gSUAAAAAABUDNHR0kkn2XTRRUdf5vrrvWrLrCxp0SKbJOmuu7yAcs8e6aGH7DDxzp2t6rJy5VLYCAQFASUIKAEAAAAACJoWLaR//MMuFxZaRaV7bsulS6V+/bxlFy6UnnnGa0dHS+3a2UA8ycnSsGHh58IEjhMBZcBF3X239Mkn1iCgBAAAAAAgeKKipJYtbTrvvJLXN2gg3XqrHSa+eLH0/ffS8uU2SVL9+l5AuWSJjSTuVlumptrh48CPIKAMuuKD4xBQAgAAAACAIyUnS089ZZcdR9q+3YJK9/Dwk0/2lv3yS+nll712KKSYVq10ct26ilqwQLrqKql169LtP8o8AsqACxUUeI2cHP86AgAAAAAAyr5QSGrc2Kazzy55fffu0pgxdi7LxYulHTsUWrdODdetk+bNkwYO9ALK996zUcU7d7apUyepdu1S3BiUFQSUQeeef1KighIAAAAAAPwyJ58cXlG5e7fyFyzQyrffVsfCQkUVP1fl559Lr79uk6tJEwsqk5OlW26xw8dR4RFQBh0BJQAAAAAAiJS6deWceaY25Oaq3dChioqN9a678EIpMdEbPXzDBmnrVpvef1/67W+9ZZ99Vpo926u27NLFzo0ZCpXu9iAiCCiDjoASAAAAAAD4oXdvm1yZmTbIzqJF0tq1FkC6PvlEmjpVevttb17duhZUduggPfywFB9fal3HiUVAGXRHBpSOw68PAAAAAACg9CUkSKecYtORfv97m79okbRwobRqlbR7tzRjhvTFF9KTT3rL/u530saNdj7M7t2lk06SmjeXildvokwhoAw4p1EjqUoVKTvbwsm8PKlSJb+7BQAAAAAA4Onb1ybXoUM2ivjixVJGhhQV5V332Wc2uvj773vz4uKkbt0s5HzssdLrN44JAWXAFf7lL4r+8ktp7lybcfgwASUAAAAAACjb4uOlHj1sOtLf/27B5ddfW8Xl+vUWaM6dK2VlhQeUQ4ZYsVaXLhaAtmsnNWvG4eKljIASVjnpOnzYSqoBAAAAAADKo/79bXI5jrRunfTVV+HLOY40a5ZlIZ98Ij3xhM0PhaTUVOnyy+3QckQcASUYKAcAAAAAAFRcoZDUpo1NxTmONHOmtGaNVVvOn2/VlgcOWAVmu3bhy558sp0mr21b6fTTreoyKUmqUYPxPH6hqJ9eJHJmz56tc889Vw0bNlQoFNKUKVN+8jaff/65unXrpsqVK6tly5Z68cUXSywzefJkdejQQXFxcerQoYPefffdCPS+Yoi69VZ70bkIKAEAAAAAQBBERdk5Ka+9VnrxRRt8JyND2rFDmjRJuuoqb9kVK6Rvv5XmzJFeeUW67DKpfXupVi0bgMetvsTP4mtAmZWVpU6dOum55547puU3btyooUOHql+/flq4cKH++Mc/6ne/+50mT55ctMy8efM0cuRIjRo1SosXL9aoUaN08cUXa/78+ZHajHIttG1beChJQAkAAAAAAIIqFJIaNJBGjLDzU7qaNbNwcvx46fbbpa5dpcREu27LlvA8JT3dqjX79pXOPVd6/nlpwwYbdTwnp3S3p5zw9RDvIUOGaEjxJ/snvPjii2ratKnGjh0rSWrfvr0WLFigJ554QhdeeKEkaezYsRo4cKDGjBkjSRozZow+//xzjR07VuPHjz/h21DuFT+8WyKgBAAAAAAAOFK1alZtKUmXXOLNz8qy4LJtW2/eBx/YOS/XrbP2kaOJv/CCdM01ke9zOVKuzkE5b948DRo0KGze4MGD9eqrryovL0+xsbGaN2+ebrvtthLLuKHm0eTk5CinWIKdmZkpScrLy1NeXt6J24AyxN0up6AgbH7+wYNyKug2o3S4+1ZFfe3AP+xbiBT2LUQK+xYihX0LkcK+hUip0PtWpUrSGWfYZXf7hg9XqFEjKTNTofXrFXrnHYUWLVIoP1/KyVG+4wQiezme57tcBZTp6elKSkoKm5eUlKT8/Hzt2bNHDRo0+MFl0tPTf3C9jzzyiB544IES82fMmKEqVaqcmM6XUXt27lTxR+vr2bO1+8AB3/qDimPmzJl+dwEVFPsWIoV9C5HCvoVIYd9CpLBvIVICt2/FxUkdOtgkacjll6tSVpZmHzigA9Om+dy5yMvOzj7mZctVQClJoSNGRXIcp8T8oy1z5LzixowZo9GjRxe1MzMz1aRJEw0aNEgJCQknottlTl5enmbOnKk6tWqFze+Rmipn6FCfeoWKwN23Bg4cqNjYWL+7gwqEfQuRwr6FSGHfQqSwbyFS2LcQKexbkvLyFJuVJUnqd9FFUt26Pnco8twjlI9FuQoo69evX6IScteuXYqJiVHt2rV/dJkjqyqLi4uLU1xcXIn5sbGxFf6Fc2RsG5OfL1XwbUbpCMLrB/5g30KksG8hUti3ECnsW4gU9i1ESqD3rb177W8opNikJCk62t/+lILjea59HcX7ePXu3btEOfCMGTPUvXv3oo3+oWX69OlTav0sV+rXDw8kGSQHAAAAAADgxNq92/7Wrh2IcPJ4+RpQHjx4UIsWLdKiRYskSRs3btSiRYu0ZcsWSXbo9ZVXXlm0/I033qjNmzdr9OjRWrlypf75z3/q1Vdf1R133FG0zC233KIZM2boscce06pVq/TYY4/p448/1q233lqam1ZuFPzzn1KLFt6Mw4elHTukuXP96xQAAAAAAEBF4gaUder4248yyteAcsGCBerSpYu6dOkiSRo9erS6dOmie++9V5KUlpZWFFZKUosWLTRt2jTNmjVLnTt31kMPPaRnnnlGF154YdEyffr00YQJE/Svf/1LqampGjdunCZOnKiePXuW7saVJ4WF3uXDh6WLL5b69pVWrPCvTwAAAAAAABXFnj32NwDnnvw5fD0H5amnnlo0yM3RjBs3rsS8AQMG6LvvvvvR9Y4YMUIjRoz4pd0LjiMDynXr7PKSJUUjTQEAAAAAAOA4vP669Mgj0jvveBWUBJRHVa4GycGJF/2rX0nbtnkzDh+W9u+3y5s2+dElAAAAAACA8u/VV6WVK6X335cOHrR5HOJ9VOVqkBxEwJo1Um6u1963T8rJscubN/vTJwAAAAAAgPLm8GHp6aeltDRrr1ljf7du5RDvn0BAGXTFD++WvBeRRAUlAAAAAADAj1m4UEpPt8tPPy3deqv0xz9KBw54GcuWLRzi/RMIKIPuyIDSfVFJXkD53nvS9One/D17vKpLx5G++04qKLB2Rob07bfesvv3S7t2neheAwAAAAAARF5enncqPEn6z3/s0G1JWrRI6t5dOu88a8+ZY3+/+UZau9a7zdatjOL9Ewgog+7HKig3b7bA8vzzpXPPlb7/3gbOadRIuvpqW+bZZ6Vu3aRHH7X2tdfai/PDDy207NVLat/eQsp9+6SuXaVf/9qWzcyU7rxTWrrU60uxUdsBAAAAAAB+lrw873LxakbJCqvcw69zcqS//lVavNja8+ZJp59ulZGSdOWVUv361t6yRbriCun666VVq2zwm8JC6euvLT+ZP99us2qVl3VIHOJ9DAgoAy7kVj66ir9gDx2Spk2zoDEvT/r0U2n8eKuenDTJqiXfeMOWfeMNCxzfe8/ab74pzZ0rrV5tweY770gTJ9oL+uWXpfXrpYcftjeBUaOsEvP3v5eaNfN+iXjxRQtCMzOtvWyZ9wbi9u9HRoEPC18PHLB+SHabzz6zPkg2//HHvXV/+610++3S9u3W/u9/pQcftHNJOI701lsWwLrr+uIL743GXd+P9evnOnTI+8VFkjZu9CpeHcd+ocnIsHZ+vj3W+fnWzssLf2794jheta1kz9GRITkAAACAsuXI7zfF244T/pn+yM/4BQXhy7vfUdzbFg+RCgrCr8/LC//+UPw7oONI2dnhtz10yGvn5ISPt3DwoLcux7ECGnddBQXhFXKHDnkDmkj2PevwYa+9a5e3roIC+67lris7O/x72/ffh697+3av3wUF9r3U3easLPue565r1y7ve6kkbdjgffcsKLDvyG4/Dx60gM1d144d0vLl3roWLrTQzL3txx/bMpJ955461fvuvXGjtd11zZ0rzZzpfZ976y07klKybXvpJeubZBnAM89437+nT5eee07KzVWooEBRzz9v+YHj2ON01122bsm+i//6115Q+Npr0lVX2WOQmyvdcosFg9nZFhSecYb0hz/Yuj74QGrVyu5bsnyhdm3LIg4elHr0kFq0sO/N8+db++ST7bn785+teOq88+x5/vWvLTO49VbbngkTbH967jnLRFzvvONlA5L0r3+FPz9TpnjX7drlDVBMQHlUIceJRJJSvmVmZioxMVEZGRlKSEjwuzsRkZeXp2nTpmnYvfcqtGTJDy84ZIj3grvhBumrr6yKUrJzK9xyi7fsX/4i/elPdrlmTftV4dlnrX366fbmNnu2te+6S/rnP73Dv8eNk371K/sHVLu29Prr0tln2xvN+edLl10mjRwpRUXZm9+ePdI990gdO0oPPWQjYk2YYMsOHy49+aQXNDZrZn9zcuzNauFC6fnnpapV7X7+/Gd7c61bV3rlFft1JCNDSk62N7Wrr7Z+jBghpaRI991nfX70UWnFCnvTrF3b7vPtt60v/ftb8Dppkr2hDRxob5YzZ9o/u/797Q32yy+lWrWkfv1sXXPnSp072/VvvWW/uFxwgZSaKj32mP0TveUWexyefFKKi7P+z5ljb37161uY+tJLtv1du9rj+vjj9k/moots3vPP2xvv5Zfbtr3/vj1nZ5xhb/4LF0rNm0vt2llZ+tatVglbt649VllZ9oZeWGjPadWq0uDB0rp1cj7+WPvq1lXiZZcp+uOPbZvOOEMaMMCe802bpEsuseflxRdtv7j+evtn+OabUlKS9Wv5cgvFU1Ls8Zg/30Lkbt3stgsW2G06d5ZiY+2xio2VOnSw52/NGqlePalNG9v2jRultm2lJk3strt3S717S9Wq2f04jjRokD3GH39sj+XgwfZP/8svpU6dpD59pM8/t3WfcorUsqX0ySd2f/37S5Uq2bKVK9s/u337bDuSkqwf27bZY9msmc3bsMG2oWVLu40bkrdta/90V6+256VdO7vtmjW2H7VqZdu7bZttf7169trMzrZtkuxXvypVpJ497XW2eLFVPycn24egjRutT40a2QeV/fulk06S4uPtOXccu5/cXHvOqleXGje2Dxppadb/unVtf9m3T2ra1B7LDRvsNm3a2D/lNWusH23bSnv32rrr17d1b9pkj0erVjZv9Wp7LNu2tcdj1SopFLJ+HT4sZ/167cvPV41OnRS1f7/1o25dm9LTbRsaNLD727HD9q2GDW1bduyw56dhQ/vBIj3dHtukJGnnTutbgwZSjRrWp6wse55iY+2xioqyDzSHDll1eUKC7Ut791o/6tUr2Y+qVb1+NGhg/UhPt37UrWvr2rvXHreaNe12mZn2nlC1qr3P5eTYuqOi7HkMhazPOTnWrlrV1rV/v62rdm3bht27bTuTkuyx3LnTno+kJHvd7tpl/ahTx+tH9epSYqL14eBBu1ylij2/ubnWx6gou69QyO4nL8+es8qV7THJyrLbVqtmfcvIsPXXrGn39/33dv+1atnf77+3x7hWLdt/MzLsdgkJ1v+sLLtcubJdl5dn/QqFrJ9RUdbv/HxbPi7Obn/4sN1vfLzNy862bahWTYqOtj46jrUdR4UHDmjfgQOq2bixonJzbfnKle322dn2eFetan3NyrL7q1bN+nHwoPWjalWbn51ty8XH230ePmx9qFTJLufn27qjomy9jmPt6Gjv/6n7Ra+w0J4396/j2O2io8P/SiWXLSy0/rnLFJ/cdRef3HWHQuF/Hceb3OWKC4VK/nUvu9vyY39/TPH1HKufWu8vuf5n3LbQcZSRkaHEhARF/dj2/NS63efjaM/lkc+744TvI+7l/HzbB2NibJ/My7N9tFIl22fd/TM+3m6TnW3rqlLFCwGio+36vDx7jVWqZO3Dh21/jo+3eVlZ1p+qVb3XSShkr5uCAmtXqmTrLv56jY+32+bk2LIxMfbaLiy09wLHsdd+bKy99nNy7Pr4eFv+4EHrZ/Xq9rrKzLS+1qhh93+871+HD9v7V2zs0d+/KlWy6w8dsnVXrWrvURkZtr4aNaxv339vj3Xt2vZc7Nljf+vWtW3Yu9cei1q1rM/799ttq1e322Zn27KVKtn7d2GhCuvW1b49e1QrP1+huDi7PivL1p2YaP36/nvrS926tl07d9r91a9vj0N6uj2nDRrYNqSn22NRr57ddu9e+z9Ro4bd9uBB+z8aF2efQRzHPkfk59vngSpVbF0ZGbZ87dp23zt32voaNrRt2rbN+tGkifVjyxZ7rps2tW3Yts3us2FD+3+2a5f1uXZt+x994IAtW7myF+S0bGmP8caNdh9Nm9p9bttm//saNLDLe/bY//fERPs8dPiw1Lq19WPdOnuMW7e2bdi40ba/eXPbvu3bbb316tltMzLs8058vBf6tGtnj+WaNXYfbdrY9m/caJ+jmjSxz0o7d9rnm5o17TvAoUP2vSYUss+elStb+/vvbd3169vyGzfa55A2bezxWb7c/k8nJ9vjv2iRraNzZ3sslyyxxy052R671au9z5LLl9vnlJQU285vv5UOH1Zht276fvdu1d64UaGqVe3ouJ077bNkkyb2vWTlSnsMOna0x+frr60fJ59s/Zg3z/bx3r3tcVqwwO6jRw97nFessG3o2NHCorQ0qUsX2845c2z/6NvX3i/mzrXXVv/+tu2LF9tj2aOH9XnzZltPmzb2OT0jw+63alVp1izbx08/3Z77+fPt8TjtNHus1q2zz3fdu1sYtWePfddo1EiaMcPeJ04/3fozZ45t21ln2XPifsY//XS7n7Q0e/5TUy0oy8qy7wvVqtm6oqKkc86x5+Hbb+21ds45tt6tW22bTj3VQsEDB+zxaNHC2gUFdr8HD1pxTKVK9t30669tG2rVsmBtyhR7Hlq3tiMZJ060bejb114XH31k+8eIEfYcuvva5ZdbUc7u3bZ/n3uufU/OzbV9p107+54rWT6wZ489b6GQfVeeMcNeH1Wr2nfpf/3LXluNG9vj89pr9j+xZ0/tzc5WXbeqcORI24aNG21dN95oucChQ9bfSy6R/vEPW7ZVK/s++v771h440B4397V35ZXWRzf4ve46r/CpenX7PuqGhR062H7h9uOss+w5dAPos86yx8rVv7+XY1SpYq+D1au9frmFT5L33cIVF+cNQlzcli22ngA4nnyNgPIoghRQnvv004qaNeuHPxjHxnq/aNWubR9UXO4HMFd8fPgvVpUqeb9YFf+SI9mHkOK/jEVHh/8y5n7oBgAAAAAgKEKh8O/nxdtHfk8+sn3k9+ri37uPvK74d30p/Pu7ZOGlG9q5P3q5yx/53b9qVQtlXe6PRkdpO1WqKJST4/XlyFyhRo3witOaNS14dfsYE+MFkbVqeZWaUsnMonjb/YHKXZf7w7z72B55v0f2q/g2xcZ6PwxKJfONn3LokD2+AXA8+VpMKfUJZVTB9OmKSkryXqRHKv6G5b6w3Reu+2Jt2tR+AXDfoNq3t19kcnPtRef+QifZr1Nr1nil45dcYr/suG9OY8ZIjzxiL/T69aXRo63UWrJfWNq0sYrBKlWsKnDhQvtlpFcv6eab7Zeezz6zMvB+/azaMS1NeuABW+c999ivGP/6l1XrTZ1qb3gTJkj/93/2i2abNlb5ecEF9sY3ZIj9qnTFFdaPhx6yN+g//cl++XrjDauie/pp+3Xl/vttm+bOtV9f+ve3X3p27rRfbqpXt19gYmPtup07bdkWLexXs9mz7de900+3ir2//91+3Rk92n5lGT3afoV59ln71egPf7BfjV9+2aoun3nGqk8feMAeow8+kH7zG2nYMOmJJ+zX8WuusV93/vMfezO94AJ7PmfPtl9jTz7Zfo1cvdoej6ZN7ZfOPXvsF9kqVayPjmOVkfv2WRViUpLyzzpLq954Qx127lRUz572+E2YYL/gDh9uvwa++KKt69prbV2vvmp/r7vO9qX//te26bzz7BfGBQvs18zUVLvftDSrBK1Vy379zM+3X3/z8mzfS0y0X5nT0+0XrebN7fFdscJ+Pe/SxX7R/+IL+0d62mm2f3z8sf1zHTLEtv+zz+wXyDPPtPv97jvb1zp1sud8+3bb/jp17Fe3wkL7hTInx/pcs6b1edcuqxx0fznfssXmtWxpfV23zm7Tpo09pmvW2GunfXt73a1ebb/8t21ry27YYL/8NW1q97Nnj/2KXK2a7UuS7TtZWfbrZu3a9vht22aPQYsWtl1r19ov523bWl/XrLEPIW3a2D/wDRvsQ0Dz5vbPeNs2e8wbNLD9dtcu26aaNe3xOnjQXu+xsbauqKjwatBatex5SUuz56VZM9uGdetsfW3b2vvLqlXWj3btbFvWrJHi45XftKkWzp6trnXqKLpuXa+yYvdue79ITLTnPCvLrouJse2LirJ2bq61q1Wz5ffts22oV88eox077L2taVPbHzdvtn2qRQt7bjdtsuelWTN7D9u2zW7XoIGtZ/durwpzxw7b7oYN7fFw+1G/vvVj1y67jzp1vFNQ1Kxp7w/79tk2HFEto3r17O/OndYPt1pm9267T/cD2P79tqxbLXPokPUrOtoen6goe/3n5tpt3aqdgwe9qp1q1eyyW/0YG2v9Kiy0tuPY9bGx9rgfPmyPSdWqtg1u9WNiovV1/367v1q1bN/6/nvrR61a9hjv22cfdBMT7XHLzLT31ypV7PLhw3ZdbKyty3GsXbyaqlo1u4+sLK/68dAhu61b/Zid7VU/SrbN0dHKj4vTd19/ra5t2yqmalW7bU6OLV+liq0vK+voVZhVq3rrio215d3qsrg475fznBxbT0yMXS4osPuRrI9HnnLlaJWS7hcU9wNx8erHI5d1fxgsvpx7uyOrKt3KviMrJd0qzOJVlcUrJI9WFVn88tGqK4/2t7ij/WB6tMMKf6wa8Yeu+zm3+bnX/W9+fn6+vvnmG5188smKiYn5+es78rl0pyMrKt1K3KNV4LqVk4WFts9VqmSTewiku3+6+2OVKrau7Gxbd3y83fZoVcKVK9u6Dh2yeVWr2rqysuw2/6tWVlaWzXdfJz/0eq1UyV5T+fn2nlK8ajohweZnZtptq1Wz22Zl2W3j4+09KCfH3idiYuwzTmGhtaXw96+cHK96u1o17/2rRo3je/+qUcP6nJFh63XfR7Oz7f05Ntb+XxcW2vt3YaG1K1Wy67Ozbd2JiTa5VfW1a9vj5VbVJyVJoZDyd+zQd4sXq+tZZymmoMDez6tWtf8rGRm2rtq17fHbs8e2KSnJ7i893Z6PBg3sud6xw7YhKcm2Ydcue6+vXdtuu2+f/f+qVs3+h7uVUaGQfRaKibGKs+xsW1dioi2/d6/1KynJ1rdjhz2+TZrYvrhli/WjWTN7LLdssW1o3Ni2f/t2+39Wr571ee9euy4hwf5HHz5s/6NDIavAio219sGDdn2tWnZf6enW7yZN7PHZtMkeI/cIlnXrbL9o3dqe63Xr7D5atrT+b95s29eokV3eudM+79So4X12cj+zrFpl29aunW3DunXW/5Yt7XP7li3hR47s32+f9+LjrZpNsoq1Q4fs+1PNmnZ9Wpp9bmve3KY1a+zx7NDBnqfFi23/6NTJHtPFi22dnTvbNixbZo9d+/beZ8n27W3e4sX22HbtKlWpovyvvtLSpUuVfM01is3Jsc/ideva5+dNm6xfbdvaZ7rFi227unWzZebNs8ejVy/rx7x5tt/06WP9XbDAnqOuXe37zapVtt6WLe0opD17rOrQrX6MirLP6fv22ef2+vXt+9OKFfa5vFMn+6z95ZfWt379bL+eMcMew0GD7P1ixgx7vgYPtm2fPdu2v18/++y8ZIndb/v2doqzXbukoUOtH1On2r41fLg99x9+aJ8VzznHqv++/NIqNvv0se8w69fbd7GmTe070OHD9j320CE7uq5OHenSS+0+P/rItuGcc+w727ff2veQrl2lf//b7u/yy60f//qXvX6vv962dcIE+8x+1VV2CPXHH9t3lsGD7bvVmjV225Yt7ci7rCzpjjvs9fHXv9p+dPvt9ri+/LJ9b732Wrv84Yf23bpvXzs6b/16+1u1qn33rF7dju5butS++55yiv39xz/svm+4wSor77jDKkSffFJq106FV1+tzO3bVfXttxW7d699J01Otu/w48ZJ995r37mffNK2c/Jku5+LLrJt27rVqiTj4uwxq1bN1j9hgn33bd/entsRI6yaduhQO3Kwa1d7T/z97+25Ov98e60995w9fy++aO8jH31kj9n69baN779v+4hk+/y119r2S/Ycf/+9V1n5q1/ZetzPLAMHeoetS7Zfuqdcq1YtMOHkcXNQQkZGhiPJycjI8LsrEZObm+tMmTLFyc3NdZzExOIHcJWcoqIcp0cPr33vvY5Tu7bXfucd73LNmo4zebLXPu88x3nkEa/93HOOc/31djkUcpxNmxxn2DBr9+vnOIWFjnPhhY4THe04//2vdfbvf3ece+5xnNxca3/7reNs2+ZtzIEDdjtXfn745cxMr71uneNs3eo+CI7zn//YPMdxnC1bHOcvf7G/juM4X33lOH/+s63fcRxn5kzHeftt776+/jq8HxkZ4f2IlMJCxyko8NqHDoXf7+HDJZcvRWH7FnACsW8hUti3ECnsW4gU9i1ECvsWIqXEvnXk99Ti3+Mdx3Gys4vf2HH27fPa6emOs3+/t54FCxzn4EFrHzzoOFOm2Pdkx7H84OmnHScnx9pPP+04Dz9st9u713GGDrUcwHEc5/33HScmxnGeeMLaw4dbVvHii46zc6ddJznOpEm2Hjfn+OILx+nc2WtPmuRdDoUc59JLvXbz5r/ocSxvjidfo4ISRz+UumVL7yS37drZrwxff23tc8+1Xylff92qg4YPt+q1pUvtl4SzzvJ+CR8+3H51+OMf7Vf9iy6yX2Jef91+2WjWTBo71n5xu/NO++Vi/Hj7Fa9+fbu/m24K71vXruFttxLGVfw8XtHR9uuHq1Ur73JsrJ3b0tWkifXT1bOnTa4zzwy/n5NPDm+X1ukAjjy/15G/vsTFlVweAAAAAICy4sjvqcW/x0vekSaSfXevUcNrJyWFr6dbN69dtaodiefq2jU8Q/jd77zLtWpZ9arr7LOtGtk9x/drr9mRdGecYffz3HNWkXzeeVbhetddVhXbs6cdDblokWUbZ5/tHVLfrJlVu7oYIOcHRfndAfgr+oorws8V4erc2bvcrZu9wEIhC/HcgVeio+1EtqGQhYsNG9qhxO7h1xdfbIFkq1bSu+9aiXS9erbuXbusjFuyMv9XXrHDBCR783HDSQAAAAAAgNIQVSwmq17dCpXcMPXXv7ZTrcXG2ikSFi60w8RjYqwAKxSy8DI+3g4LlyznaNrUWycB5Q+igjLgQt9+e/QKys6dpXfescvdu1uF5Cef2LkToqKsKjIry86DIdm5ItxzNEoWVP7mN167+C8YUulVGwIAAAAAAJxobggp2ZGimzZZUZZk50d1R6wvPmJ3nTql2sXyhIAy6H5opOzUVO+yWy592mnhyxx5KDEAAAAAAEAQFa+U/PWvbcCdK68MP+0cFZQ/iIAy6H4ooGzQQBo1yl5Q3buXbp8AAAAAAADKq1NP9cbxOHjQm09A+YMIKIPuhwLKGjXshLAAAAAAAAD4eapVk2rWlPbt4xDvH8EgOUH3QwFlzZql2w8AAAAAAICKqEUL+9uggb/9KMOooAy6goKjz69Ro1S7AQAAAAAAUCE98YT00Uc2KjiOioAy6KpUKTmvalUpNrb0+wIAAAAAAFDRnHZayYGHEYZDvAMuf/nykjM5vBsAAAAAAAClhIAy6I52DkoO7wYAAAAAAEApIaAMOscpOY8KSgAAAAAAAJQSAsqAi77kEq/hno+SCkoAAAAAAACUEgLKgAvNmuU14uPtLxWUAAAAAAAAKCUElEFX/ByUVFACAAAAAACglBFQBt3RAkoqKAEAAAAAAFBKCCiDjoASAAAAAAAAPiKgDLriAWXVqvaXQ7wBAAAAAABQSmL87gB8VjygvO46KT9fGjjQv/4AAAAAAAAgUKigDLqoYrvAVVdJ8+ZJDRv61x8AAAAAAAAECgFlwOVv3GgXQiGbAAAAAAAAgFJEQBl07iHehJMAAAAAAADwAQFl0LkBZRS7AgAAAAAAAEofqVSAhfLzFX3DDdYgoAQAAAAAAIAPSKUCLFRQoKiZM61BQAkAAAAAAAAfkEoFWMhxvAYBJQAAAAAAAHxAKhVgBJQAAAAAAADwG6lUkLkD5EgElAAAAAAAAPAFqVSAUUEJAAAAAAAAv5FKBRkVlAAAAAAAAPAZqVSAhVVQhkL+dQQAAAAAAACBRUAZYLkJCcqbP98aVFACAAAAAADAB6RSQRYKSdHRdpmAEgAAAAAAAD4glQo69zyUBJQAAAAAAADwQYzfHYB/YjMzFf3CC9YgoAQAAAAAAIAPSKUCLObwYUVNn24NAkoAAAAAAAD4gFQqwMJG8SagBAAAAAAAgA9IpYLMPf+kREAJAAAAAAAAX5BKBRgVlAAAAAAAAPAbqVSAhQWUoZB/HQEAAAAAAEBg/aKAMicn50T1A37gEG8AAAAAAAD47LhSqenTp+vqq69Wq1atFBsbqypVqqh69eoaMGCA/vKXv2jHjh2R6icigEO8AQAAAAAA4LdjSqWmTJmitm3b6qqrrlJUVJR+//vf65133tH06dP16quvasCAAfr444/VsmVL3Xjjjdq9e3ek+40T4ECjRsqfPNkaBJQAAAAAAADwQcyxLPTwww/riSee0Nlnn62oowRZF198sSRp+/btevrpp/Xaa6/p9ttvP7E9xYkXHS1VrmyXCSgBAAAAAADgg2MKKL/++utjWlmjRo30+OOP/6IOoZS556EkoAQAAAAAAIAPjjmVuvXWW7Vs2bJI9gWlLH7nToWeecYaBJQAAAAAAADwwTGnUh999JE6deqkHj166OWXX1ZmZmYk+4VSEJeRoeiPPrIGASUAAAAAAAB8cMyp1KpVqzR79mylpKTojjvuUMOGDXXllVdq9uzZkewfIihsFO9QyL+OAAAAAAAAILCOq2yub9++evXVV5Wenq5nn31WmzZt0qmnnqo2bdro0Ucf1Y4dOyLVT0RC8YCSCkoAAAAAAAD44GelUlWqVNE111yj2bNna+3atbr44ov1+OOPq3nz5ie4e4ikkDtAjkRACQAAAAAAAF/8olQqKytLn3/+uT7//HPt379frVq1OlH9QmmgghIAAAAAAAA++1mp1OzZs3XNNdeofv36uuWWW3TSSSdpzpw5Wrly5YnuHyIoREAJAAAAAAAAn8Uc64Lbtm3Tv//9b40bN07r169Xz5499dRTT+mSSy5RtWrVItlHRAgBJQAAAAAAAPx2zAFl8+bNVbt2bY0aNUrXXXed2rdvH8l+oRR8366d8p97TjG/+Q0BJQAAAAAAAHxxzAHlW2+9pWHDhikm5phvgjKuMDZWqlHDGgSUAAAAAAAA8MExpVJZWVm64IILjjmczMrK+kWdQilyR/ImoAQAAAAAAIAPjimVat26tR5++GHt2LHjB5dxHEczZ87UkCFD9Mwzz5ywDiJyqm/dqqg33rBGKORvZwAAAAAAABBIx1QSOWvWLN1999164IEH1LlzZ3Xv3l0NGzZU5cqVtW/fPq1YsULz5s1TbGysxowZoxtuuCHS/cYJUCU9XVEzZliDCkoAAAAAAAD44JgCyrZt22rSpEnatm2bJk2apNmzZ2vu3Lk6dOiQ6tSpoy5duugf//iHhg4dqiiCrnKDUbwBAAAAAADgt+NKpRo3bqzbbrtN7777rhYuXKhVq1bpiy++0LPPPqtzzjnnZ4WTzz//vFq0aKHKlSurW7dumjNnzg8ue/XVVysUCpWYOnbsWLTMuHHjjrrM4cOHj7tvFZ57/kmJgBIAAAAAAAC+8DWVmjhxom699Vb96U9/0sKFC9WvXz8NGTJEW7ZsOeryTz/9tNLS0oqmrVu3qlatWrrooovClktISAhbLi0tTZUrVy6NTSpXqKAEAAAAAACA33xNpf72t7/puuuu0/XXX6/27dtr7NixatKkiV544YWjLp+YmKj69esXTQsWLNC+fft0zTXXhC0XCoXClqtfv35pbE75Q0AJAAAAAAAAnx3TOSgjITc3V99++63uuuuusPmDBg3S3Llzj2kdr776qs4880w1a9YsbP7BgwfVrFkzFRQUqHPnznrooYfUpUuXH1xPTk6OcnJyitqZmZmSpLy8POXl5R3rJpUreXl5ChU7xLtQUkEF3VaULvc1U1FfO/AP+xYihX0LkcK+hUhh30KksG8hUti3gul4nm/fAso9e/aooKBASUlJYfOTkpKUnp7+k7dPS0vThx9+qDfffDNsfrt27TRu3DilpKQoMzNTTz/9tPr27avFixerTZs2R13XI488ogceeKDE/BkzZqhKlSrHsVXlS6NiFZTpu3bpm2nTfOwNKpqZM2f63QVUUOxbiBT2LUQK+xYihX0LkcK+hUhh3wqW7OzsY17Wt4DSFQqFwtqO45SYdzTjxo1TjRo1NHz48LD5vXr1Uq9evYraffv2VdeuXfXss8/qmWeeOeq6xowZo9GjRxe1MzMz1aRJEw0aNEgJCQnHsTXlR15enj7LzlbumDGq9Mgjqt+woYYOHep3t1AB5OXlaebMmRo4cKBiY2P97g4qEPYtRAr7FiKFfQuRwr6FSGHfQqSwbwWTe4TysfhZAeXWrVu1adMmZWdnq27duurYsaPi4uKOax116tRRdHR0iWrJXbt2laiqPJLjOPrnP/+pUaNGqVKlSj+6bFRUlE4++WStXbv2B5eJi4s7av9jY2Mr9Asnv0oVRf/vsY6KjlZUBd5WlL6K/vqBf9i3ECnsW4gU9i1ECvsWIoV9C5HCvhUsx/NcH/PIKJs3b9aYMWPUvHlzNW/eXAMGDNCQIUPUvXt3JSYmauDAgZo0aZIKi53X8MdUqlRJ3bp1K1HeO3PmTPXp0+dHb/v5559r3bp1uu66637yfhzH0aJFi9SgQYNj6lfguM8Xg+QAAAAAAADAB8eUSt1yyy1KSUnR2rVr9eCDD2r58uXKyMhQbm6u0tPTNW3aNJ1yyim65557lJqaqm+++eaY7nz06NF65ZVX9M9//lMrV67Ubbfdpi1btujGG2+UZIdeX3nllSVu9+qrr6pnz55KTk4ucd0DDzyg6dOna8OGDVq0aJGuu+46LVq0qGid8CSuW6fQBx9Yg4ASAAAAAAAAPjimQ7wrVaqk9evXq27duiWuq1evnk4//XSdfvrpuu+++zRt2jRt3rxZJ5988k+ud+TIkdq7d68efPBBpaWlKTk5WdOmTSsalTstLU1btmwJu01GRoYmT56sp59++qjr3L9/v2644Qalp6crMTFRXbp00ezZs9WjR49j2dRASdy4UVGffGINAkoAAAAAAAD44JgCyr/+9a/HvMLjHWjlpptu0k033XTU68aNG1diXmJi4o+OAvTUU0/pqaeeOq4+QASUAAAAAAAA8MVxp1Knn3669u/fX2J+ZmamTj/99BPRJ5SSUPHzhRJQAgAAAAAAwAfHnUrNmjVLubm5JeYfPnxYc+bMOSGdQukIOY7XIKAEAAAAAACAD47pEG9JWrJkSdHlFStWKD09vahdUFCgjz76SI0aNTqxvUNkUUEJAAAAAAAAnx1zQNm5c2eFQiGFQqGjHsodHx+vZ5999oR2DpEVVkEZCvnXEQAAAAAAAATWMQeUGzdulOM4atmypb7++uuwEb0rVaqkevXqKTo6OiKdRGRwiDcAAAAAAAD8dswBZbNmzSRJhcUPC0a5tq1fP3UIhRT9j38QUAIAAAAAAMAXx5RKzZs375hXmJWVpeXLl//sDqH05CYmSvXqWYOAEgAAAAAAAD44plTqyiuv1MCBA/XWW2/p4MGDR11mxYoV+uMf/6jWrVvru+++O6GdRAS5FbEElAAAAAAAAPDBMR3ivWLFCr300ku69957dfnll+ukk05Sw4YNVblyZe3bt0+rVq1SVlaWLrjgAs2cOVPJycmR7jdOgJqrVik0d641CCgBAAAAAADgg2MKKGNjY/Wb3/xGv/nNb/Tdd99pzpw52rRpkw4dOqROnTrptttu02mnnaZatWpFur84geosW6aozz+3BgElAAAAAAAAfHDMg+S4unbtqq5du0aiLyhljOINAAAAAAAAvx13KnXo0CFlZ2cXtTdv3qyxY8dq+vTpJ7RjKAXFR2QnoAQAAAAAAIAPjjuVOu+88/Taa69Jkvbv368ePXroySef1PDhw/XCCy+c8A4icsIqKEMh/zoCAAAAAACAwDrugPK7775Tv379JElvv/226tevr82bN+u1117TM888c8I7iAjiEG8AAAAAAAD47LhTqezsbFWvXl2SNGPGDF1wwQWKiopSr169tHnz5hPeQUROiEO8AQAAAAAA4LPjTqVat26tKVOmaOvWrZo+fboGDRokSdq1a5cSEhJOeAcROQSUAAAAAAAA8Ntxp1L33nuv7rjjDjVv3lw9e/ZU7969JVk1ZZcuXU54BxE5mwYPVuHw4dYgoAQAAAAAAIAPYo73BiNGjNApp5yitLQ0derUqWj+GWecofPPP/+Edg6RdahePTn161uDgBIAAAAAAAA+OO6AUpLq16+v+m6w9T89evQ4IR1CKXMP8yagBAAAAAAAgA9IpQKs9tKlCi1ZYg0CSgAAAAAAAPiAVCrAGn71laK++soaBJQAAAAAAADwAalUgIWN4h0K+dcRAAAAAAAABBYBZZA5jneZCkoAAAAAAAD4gFQqwEIFBV6DgBIAAAAAAAA+IJUKsLBDvAkoAQAAAAAA4ANSqQALcYg3AAAAAAAAfEYqFWBUUAIAAAAAAMBvpFIBtnb4cBX262cNAkoAAAAAAAD4gFQqwA40by7Vq2cNAkoAAAAAAAD4gFQq6NzDvEMhf/sBAAAAAACAQCKgDLC6ixZJGzdagwpKAAAAAAAA+IBUKsCaf/SRohYtsgYBJQAAAAAAAHxAKhVgjOINAAAAAAAAv5FKBRgBJQAAAAAAAPxGKhVgBJQAAAAAAADwG6lUgBFQAgAAAAAAwG+kUkHmON5lAkoAAAAAAAD4gFQqwKigBAAAAAAAgN9IpQJs1aWXqjA52RqhkL+dAQAAAAAAQCARUAbY9x06SLVrW4MKSgAAAAAAAPiAVCro3MO8CSgBAAAAAADgA1KpAKv33XcK7dxpDQJKAAAAAAAA+CDG7w7AP+3efFOhdeusQUAJAAAAAAAAH5BKBRijeAMAAAAAAMBvpFIBRkAJAAAAAAAAv5FKBZnjeJcJKAEAAAAAAOADUqkAC6ugDIX86wgAAAAAAAACi4AywEJUUAIAAAAAAMBnpFIBxjkoAQAAAAAA4DdSqQBbfvXVcho3tgYBJQAAAAAAAHxAKhVg6T16SImJ1iCgBAAAAAAAgA9IpYLOPcybgBIAAAAAAAA+IJUKsHrffSdlZlqDgBIAAAAAAAA+iPG7A/BPl2efVWjfPmsQUAIAAAAAAMAHpFIBxijeAAAAAAAA8BupVJAVDyhDIf/6AQAAAAAAgMAioAwwKigBAAAAAADgN1KpAAs5jtcgoAQAAAAAAIAPSKUCjApKAAAAAAAA+I1UKsgIKAEAAAAAAOAzUqkAW3rDDXISEqxBQAkAAAAAAAAfkEoF2JYzz5Ti461BQAkAAAAAAAAfkEoFnXuYNwElAAAAAAAAfEAqFVSOo7qLFkk5OdYmoAQAAAAAAIAPYvzuAHxSWKg+99/vtUMh37oCAAAAAACA4KJsLqiKj+AtUUEJAAAAAAAAX5BKBVVBQXibgBIAAAAAAAA+IJUKKgJKAAAAAAAAlAGkUkHFId4AAAAAAAAoA3xPpZ5//nm1aNFClStXVrdu3TRnzpwfXHbWrFkKhUIlplWrVoUtN3nyZHXo0EFxcXHq0KGD3n333UhvRvlDBSUAAAAAAADKAF9TqYkTJ+rWW2/Vn/70Jy1cuFD9+vXTkCFDtGXLlh+93erVq5WWllY0tWnTpui6efPmaeTIkRo1apQWL16sUaNG6eKLL9b8+fMjvTnlCxWUAAAAAAAAKAN8TaX+9re/6brrrtP111+v9u3ba+zYsWrSpIleeOGFH71dvXr1VL9+/aIpOjq66LqxY8dq4MCBGjNmjNq1a6cxY8bojDPO0NixYyO8NeVMfLyWXnutHDeYJKAEAAAAAACAD2L8uuPc3Fx9++23uuuuu8LmDxo0SHPnzv3R23bp0kWHDx9Whw4ddPfdd+u0004rum7evHm67bbbwpYfPHjwjwaUOTk5ysnJKWpnZmZKkvLy8pSXl3esm1Su5MXEaMOwYUoeN87a+flSBd1WlC73NVNRXzvwD/sWIoV9C5HCvoVIYd9CpLBvIVLYt4LpeJ5v3wLKPXv2qKCgQElJSWHzk5KSlJ6eftTbNGjQQC+//LK6deumnJwcvf766zrjjDM0a9Ys9e/fX5KUnp5+XOuUpEceeUQPPPBAifkzZsxQlSpVjnfTypXQ/w71/uSzz5RTo4a/nUGFMnPmTL+7gAqKfQuRwr6FSGHfQqSwbyFS2LcQKexbwZKdnX3My/oWULpCoVBY23GcEvNcbdu2Vdu2bYvavXv31tatW/XEE08UBZTHu05JGjNmjEaPHl3UzszMVJMmTTRo0CAlJCQc1/aUF3kHD+rbF18sap8xcKBUt66PPUJFkZeXp5kzZ2rgwIGKjY31uzuoQNi3ECnsW4gU9i1ECvsWIoV9C5HCvhVM7hHKx8K3gLJOnTqKjo4uUdm4a9euEhWQP6ZXr1564403itr169c/7nXGxcUpLi6uxPzY2NiK+8LZu1f9/vjHomZsXJxUUbcVvqjQrx/4in0LkcK+hUhh30KksG8hUti3ECnsW8FyPM+1byOjVKpUSd26dStR3jtz5kz16dPnmNezcOFCNWjQoKjdu3fvEuucMWPGca0zEBjFGwAAAAAAAGWAr4d4jx49WqNGjVL37t3Vu3dvvfzyy9qyZYtuvPFGSXbo9fbt2/Xaa69JshG6mzdvro4dOyo3N1dvvPGGJk+erMmTJxet85ZbblH//v312GOP6bzzztPUqVP18ccf64svvvBlG8usgoLwNgElAAAAAAAAfOBrQDly5Ejt3btXDz74oNLS0pScnKxp06apWbNmkqS0tDRt2bKlaPnc3Fzdcccd2r59u+Lj49WxY0d98MEHGjp0aNEyffr00YQJE3T33XfrnnvuUatWrTRx4kT17Nmz1LevTKOCEgAAAAAAAGWA74Pk3HTTTbrpppuOet24cePC2nfeeafuvPPOn1zniBEjNGLEiBPRvYqLCkoAAAAAAACUAaRSQUVACQAAAAAAgDKAVCqojjzEOxTypx8AAAAAAAAINALKoEpK0uqLLvLaVFACAAAAAADAB6RSQZWUpPXDhnltAkoAAAAAAAD4gFQqyBzHu0xACQAAAAAAAB+QSgXVwYNK2LTJa3MOSgAAAAAAAPiAgDKgQkuW6JR77/1fI0RACQAAAAAAAF8QUAZVQYF3mcO7AQAAAAAA4BOSqaAqLPQuE1ACAAAAAADAJyRTQUUFJQAAAAAAAMoAkqmgKl5ByfknAQAAAAAA4BMCyqCighIAAAAAAABlAMlUUHEOSgAAAAAAAJQBJFMB5bRsqY2DB1uDgBIAAAAAAAA+IZkKqrZttX7YMLtMQAkAAAAAAACfkEwFWMhx7AIBJQAAAAAAAHxCMhVUmZmqkp5ulwkoAQAAAAAA4BOSqYAKffSRev/5z9YgoAQAAAAAAIBPSKaCqqDAuxwK+dcPAAAAAAAABBoBZVAVFnqXqaAEAAAAAACAT0imgqp4BSUBJQAAAAAAAHxCMhVU7gjeEgElAAAAAAAAfEMyFVRUUAIAAAAAAKAMIJkKKs5BCQAAAAAAgDKAZCqoOnbUtr597TIBJQAAAAAAAHxCMhVQTu/e2njOOdYgoAQAAAAAAIBPSKaCzD3Mm4ASAAAAAAAAPiGZCqoDBxSXmWmXQyF/+wIAAAAAAIDAIqAMqKhXXlGPxx77X4PdAAAAAAAAAP4gmQqqggLvMgElAAAAAAAAfEIyFVQElAAAAAAAACgDSKaCyh0gRyKgBAAAAAAAgG9IpoKKCkoAAAAAAACUASRTQUUFJQAAAAAAAMoAkqmgooISAAAAAAAAZQDJVEA5XbtqZ6dO1giF/O0MAAAAAAAAAouAMqCc887TpiFDrEEFJQAAAAAAAHxCMhVgIcexCwSUAAAAAAAA8AnJVFBlZyv60CG7TEAJAAAAAAAAn5BMBVTUvfeq2zPP/K/BbgAAAAAAAAB/kEwFFaN4AwAAAAAAoAwgmQqqwkLvMgElAAAAAAAAfEIyFVRUUAIAAAAAAKAMIJkKqBABJQAAAAAAAMoAkqmgKn6IdyjkXz8AAAAAAAAQaASUQUUFJQAAAAAAAMoAkqmAcnr21Pdt2liDgBIAAAAAAAA+IZkKqMJf/UqbBw2yBgElAAAAAAAAfEIyFWAh9zyUBJQAAAAAAADwCclUUOXlKZSfb5cJKAEAAAAAAOCTGL87AH9EjxqlTu+8Yw0CSgAAAAAAAPiEZCqoGMUbAAAAAAAAZQDJVFC555+UCCgBAAAAAADgG5KpoCpeQRkK+dcPAAAAAAAABBoBZVBRQQkAAAAAAIAygGQqqAgoAQAAAAAAUAaQTAUVg+QAAAAAAACgDCCZCiinVy9lNm5sDQJKAAAAAAAA+IRkKqAK77tP20491RoElAAAAAAAAPAJyVSAhRzHLhBQAgAAAAAAwCckU0HmDpRDQAkAAAAAAACfxPjdAfgjesAAtZ0/3xqhkL+dAQAAAAAAQGBROhdUeXmKooISAAAAAAAAPiOZCqhQQYHXIKAEAAAAAACAT0imgsqtnpQIKAEAAAAAAOAbkqmgKl5BGRvrXz8AAAAAAAAQaASUQVW8gjI62r9+AAAAAAAAINAIKIOqeAVlDIO5AwAAAAAAwB8ElAHl9O6tQ7VrW4OAEgAAAAAAAD7xPaB8/vnn1aJFC1WuXFndunXTnDlzfnDZd955RwMHDlTdunWVkJCg3r17a/r06WHLjBs3TqFQqMR0+PDhSG9KuVLw8stK797dGgSUAAAAAAAA8ImvAeXEiRN166236k9/+pMWLlyofv36aciQIdqyZctRl589e7YGDhyoadOm6dtvv9Vpp52mc889VwsXLgxbLiEhQWlpaWFT5cqVS2OTypUo9zBvzkEJAAAAAAAAn/haOve3v/1N1113na6//npJ0tixYzV9+nS98MILeuSRR0osP3bs2LD2ww8/rKlTp+q9995Tly5diuaHQiHVr18/on2vCELuQDlUUAIAAAAAAMAnviVTubm5+vbbb3XXXXeFzR80aJDmzp17TOsoLCzUgQMHVKtWrbD5Bw8eVLNmzVRQUKDOnTvroYceCgswj5STk6OcnJyidmZmpiQpLy9PeXl5x7pJ5Up0SooarVsnSSoIhVRYQbcTpc99zVTU1w78w76FSGHfQqSwbyFS2LcQKexbiBT2rWA6nufbt4Byz549KigoUFJSUtj8pKQkpaenH9M6nnzySWVlZeniiy8umteuXTuNGzdOKSkpyszM1NNPP62+fftq8eLFatOmzVHX88gjj+iBBx4oMX/GjBmqUqXKcWxV+TF41y5V/t8h3ivWrNGGadN87hEqmpkzZ/rdBVRQ7FuIFPYtRAr7FiKFfQuRwr6FSGHfCpbs7OxjXtb3Y3tDoVBY23GcEvOOZvz48br//vs1depU1atXr2h+r1691KtXr6J237591bVrVz377LN65plnjrquMWPGaPTo0UXtzMxMNWnSRIMGDVJCQsLxblK5EFPssO4OKSlqN3Soj71BRZKXl6eZM2dq4MCBio2N9bs7qEDYtxAp7FuIFPYtRAr7FiKFfQuRwr4VTO4RysfCt4CyTp06io6OLlEtuWvXrhJVlUeaOHGirrvuOk2aNElnnnnmjy4bFRWlk08+WWvXrv3BZeLi4hQXF1difmxsbIV94Tju+SclRcfFKbqCbif8U5FfP/AX+xYihX0LkcK+hUhh30KksG8hUti3guV4nmvfRvGuVKmSunXrVqK8d+bMmerTp88P3m78+PG6+uqr9eabb+rss8/+yftxHEeLFi1SgwYNfnGfK5RiASWD5AAAAAAAAMAvviZTo0eP1qhRo9S9e3f17t1bL7/8srZs2aIbb7xRkh16vX37dr322muSLJy88sor9fTTT6tXr15F1Zfx8fFKTEyUJD3wwAPq1auX2rRpo8zMTD3zzDNatGiR/v73v/uzkWXV/84/KYmAEgAAAAAAAL7xNZkaOXKk9u7dqwcffFBpaWlKTk7WtGnT1KxZM0lSWlqatmzZUrT8Sy+9pPz8fN188826+eabi+ZfddVVGjdunCRp//79uuGGG5Senq7ExER16dJFs2fPVo8ePUp128q84gFldLR//QAAAAAAAECg+V46d9NNN+mmm2466nVu6OiaNWvWT67vqaee0lNPPXUCelaxOT17Kv+rrxSbnU0FJQAAAAAAAHzj2zko4a+Cjz5SRosW1iCgBAAAAAAAgE8IKAMs5B7mTUAJAAAAAAAAnxBQBliUG1ByDkoAAAAAAAD4hNK5IHIcxTRtqsTdu61NBSUAAAAAAAB8QjIVRI6jUHq6Qm6bgBIAAAAAAAA+4RDvIHIP7XYRUAIAAAAAAMAnBJRBdGRAyTkoAQAAAAAA4BMCyiAqLAxvU0EJAAAAAAAAnxBQBhGHeAMAAAAAAKCMIKAMIiooAQAAAAAAUEYQUAZRKCSnUycVuuee5ByUAAAAAAAA8AkBZRAlJCj/m2+UV7WqtamgBADg/9u7/+is6vsO4J+HJATCL4v8HoigsGGtggmj4KwVBggV8KioEyiMKuMUR5FDN9FNkbmynbUWOgdCj9XhsNoeJ7rWFrFaxAktolSmHagVAzUIOCrBqITk2R+QVBpQFJ7cJPf1Oicnz735Pvd+bvgmh/PO534vAACQEAFlimVqbvUWUAIAAACQEAFlimVqHpYjoAQAAAAgIQLKNNq5M/L79Yv8998/tG0NSgAAAAASonUujQ4ciMxrr0W2ZlsHJQAAAAAJ0UGZRjW3dtcQUAIAAACQEAFlGh0OKDM12wJKAAAAABIioEyjmqd317AGJQAAAAAJEVCmkVu8AQAAAGggBJRp9IcdlAJKAAAAABIioEyjgoLI9u79+20BJQAAAAAJEVCmUd++cfCZZ36/bQ1KAAAAABIioEyrgwcjIiKbyUQ0Mw0AAAAASIZkKq1qHpTj9m4AAAAAEiSgTKNf/SryR4489FpACQAAAECCBJRptH9/ZLZuPfRaQAkAAABAggSUaVRd/fvXHpADAAAAQIIElGlUs/5khA5KAAAAABIloEyjD3dQCigBAAAASJCAMo10UAIAAADQQAgo08galAAAAAA0EALKNGrePLIdOhx6rYMSAAAAgAQJKNPoooui6gc/OPRaByUAAAAACRJQptXBg4c+66AEAAAAIEECyrSqCSh1UAIAAACQIAFlGj35ZDS74YZDr3VQAgAAAJAgAWUa7d4dzbZsiYiIrIASAAAAgAQJKNOouvr3rwWUAAAAACRIQJlGVVW/f20NSgAAAAASJKBMIx2UAAAAADQQAso0+nAHpYASAAAAgAQJKNNIByUAAAAADYSAMo0KCiLbsuWh181MAQAAAACSI51Koy9/Oaq+9a1Dr3VQAgAAAJAgAWVKZQ4ePPRCQAkAAABAggSUaSWgBAAAAKABEFCmVU1AmZeXbB0AAAAApJqAMq10UAIAAADQAAgo06qq6tBnASUAAAAACRJQptXhDsqsgBIAAACABAko08oalAAAAAA0AALKtLIGJQAAAAANgIAyraxBCQAAAEADIKBMq5qA0i3eAAAAACRIQJlW1qAEAAAAoAEQUKaVNSgBAAAAaAAElGllDUoAAAAAGgABZUpldFACAAAA0AAIKNPKGpQAAAAANAACyrTSQQkAAABAAyCgTCtrUAIAAADQAAgo00oHJQAAAAANgIAyrQSUAAAAADQAAsq0OhxQZj0kBwAAAIAECSjTqrr60GcdlAAAAAAkSECZVjW3eOugBAAAACBBAsq0sgYlAAAAAA2AgDKtdFACAAAA0AAkHlAuXrw4evXqFS1atIji4uJYu3btR45fs2ZNFBcXR4sWLaJ3795x11131Rnz0EMPxVlnnRWFhYVx1llnxcMPP5yr8huvqqpDn3VQAgAAAJCgRAPKBx98MGbNmhU333xzvPDCC3HBBRfEqFGjorS09KjjX3/99Rg9enRccMEF8cILL8RNN90UM2fOjIceeqh2zLp16+Kqq66KSZMmxa9+9auYNGlSXHnllfGLX/yivi6rcXCLNwAAAAANQKIB5R133BFf+cpX4tprr41+/frFwoULo0ePHrFkyZKjjr/rrrvitNNOi4ULF0a/fv3i2muvjalTp8Y3v/nN2jELFy6M4cOHx9y5c+NP/uRPYu7cuTFs2LBYuHBhPV1VIyGgBAAAAKABSCydOnDgQGzcuDFuvPHGI/aPGDEinn322aO+Z926dTFixIgj9o0cOTLuvvvuqKysjIKCgli3bl3ccMMNdcZ8VED5wQcfxAcffFC7vW/fvoiIqKysjMrKyk9yWY1G3uHrOpjNRraJXiPJqPmZaao/OyTH3CJXzC1yxdwiV8wtcsXcIlfMrXT6JP/eiQWUe/bsiaqqqujcufMR+zt37hw7d+486nt27tx51PEHDx6MPXv2RNeuXY855ljHjIhYsGBB3HbbbXX2P/7441FUVHS8l9SoXPTOO9E2Ijb+6lexJ5tNuhyaoNWrVyddAk2UuUWumFvkirlFrphb5Iq5Ra6YW+lSUVFx3GMTv783k8kcsZ3NZuvs+7jxf7j/kx5z7ty5MXv27Nrtffv2RY8ePWLEiBHRtm3bj7+IRijvb/82IiKKBw2KvIsuSrgampLKyspYvXp1DB8+PAoKCpIuhybE3CJXzC1yxdwiV8wtcsXcIlfMrXSquUP5eCQWUHbo0CHy8vLqdDbu2rWrTgdkjS5duhx1fH5+fpx66qkfOeZYx4yIKCwsjMLCwjr7CwoKmuwPTvbwU7zzW7SI/CZ6jSSrKf/8kCxzi1wxt8gVc4tcMbfIFXOLXDG30uWT/Fsn9pCc5s2bR3FxcZ323tWrV8eQIUOO+p7BgwfXGf/4449HSUlJ7UUfa8yxjplaNQ/JyctLtg4AAAAAUi3RW7xnz54dkyZNipKSkhg8eHAsW7YsSktLY/r06RFx6Nbr3/72t7F8+fKIiJg+fXrceeedMXv27Ljuuuti3bp1cffdd8f3v//92mN+7Wtfiy984Qvxz//8zzFu3Lh45JFH4oknnohnnnkmkWtssA53UGY9xRsAAACABCWaTl111VXx9ttvx/z586OsrCzOPvvseOyxx6Jnz54REVFWVhalpaW143v16hWPPfZY3HDDDfFv//Zv0a1bt/jOd74Tl19+ee2YIUOGxAMPPBB/93d/F3//938fZ5xxRjz44IMxaNCger++Bk0HJQAAAAANQOLtc1/96lfjq1/96lG/du+999bZd+GFF8bzzz//kce84oor4oorrjgZ5TVdNQGlDkoAAAAAEpTYGpQkTAclAAAAAA2AgDKtDq9BqYMSAAAAgCQJKNPKLd4AAAAANAACyrQSUAIAAADQAAgo08oalAAAAAA0AALKNMpmI1Ndfei1DkoAAAAAEiSgTKOaB+RECCgBAAAASJR0Ko1qbu+OEFACAAAAjV5VVVVUVlYmXUbqFBQURN5JWD5QOpVGHw4orUEJAAAANGL79++PHTt2RDabTbqU1MlkMtG9e/do3br1CR1HQJlGOigBAACAJqCqqip27NgRRUVF0bFjx8hkMkmXlBrZbDZ2794dO3bsiD59+pxQJ6V0Ko2sQQkAAAA0AZWVlZHNZqNjx47RsmXLpMtJnY4dO8a2bduisrLyhAJKD8lJo8MdlNlMJqKZKQAAAAA0bjonk3Gyvu/SqTSqCSiFkwAAAAAkTEKVRjUBpQfkAAAAAJAwAWUaHV6DUgclAAAAQMMyb9686N+/f9JlxM6dO2P48OHRqlWrOOWUU3J6LglVGh3uoKzWQQkAAADQoMyZMyd+9rOfJV1GfPvb346ysrLYtGlTbN26Nafn8gjnNPrQGpSWkAUAAABoOFq3bh2tW7fO2fErKyujoKDgY8e99tprUVxcHH369MlZLTV0UKaRNSgBAACApuzdd4/98f77xz/2vfeOb+wnsHTp0vijP/qjqK6uPmL/2LFjY/LkyXVu8d6wYUMMHz48OnToEO3atYsLL7wwnn/++eM+XyaTibvuuivGjRsXrVq1ittvvz0iIv7rv/4riouLo0WLFtG7d++47bbb4uDhzOj000+Phx56KJYvXx6ZTCamTJnyia7xkxJQplHNGpQCSgAAAKApat362B+XX37k2E6djj121Kgjx55++tHHfQLjx4+PPXv2xFNPPVW7b+/evbFq1aqYMGFCnfHl5eUxefLkWLt2baxfvz769OkTo0ePjvLy8uM+56233hrjxo2LzZs3x9SpU2PVqlUxceLEmDlzZrz88suxdOnSuPfee+Mf//EfI+JQKHrxxRfHlVdeGWVlZbFo0aJPdI2flFu80+hDt3gDAAAAUH/at28fF198cdx///0xbNiwiIj44Q9/GO3bt49hw4bFs88+e8T4oUOHHrG9dOnS+MxnPhNr1qyJSy655LjOec0118TUqVNrtydNmhQ33nhjTJ48OSIievfuHf/wD/8Qf/M3fxO33nprdOzYMQoLC6Nly5bRpUuXE7nc4yKgTCMPyQEAAACasv37j/21P8xDdu069tg/bO7atu1Tl/RhEyZMiGnTpsXixYujsLAwVqxYEVdffXXkHSWr2bVrV9xyyy3x5JNPxltvvRVVVVVRUVERpaWlx32+kpKSI7Y3btwYGzZsqO2YjIioqqqK999/PyoqKqKoqOjTX9ynIKBMo8MBZZ0fMgAAAICmoFWr5Md+hDFjxkR1dXX8+Mc/joEDB8batWvjjjvuOOrYKVOmxO7du2PhwoXRs2fPKCwsjMGDB8eBAwc+QdlH1l1dXR233XZbXHbZZXXGtmjR4pNdzEkgoEyjw2tQ6qAEAAAAqH8tW7aMyy67LFasWBGvvvpq9O3bN4qLi486du3atbF48eIYPXp0RERs37499uzZc0LnP++882LLli1x5plnntBxThYBZRp5ijcAAABAoiZMmBBjxoyJl156KSZOnHjMcWeeeWbcd999UVJSEvv27Yuvf/3r0bJlyxM69y233BKXXHJJ9OjRI8aPHx/NmjWLF198MTZv3lz7lO/65B7fNPKQHAAAAIBEDR06NNq3bx9btmyJa6655pjjvve978XevXtjwIABMWnSpJg5c2Z06tTphM49cuTI+NGPfhSrV6+OgQMHxuc///m44447omfPnid03E9LB2Ua6aAEAAAASFReXl68+eabdfbPmzcv5s2bV7s9YMCA2LBhwxFjrrjiiuM+TzabPer+kSNHxsiRI4/5vpUrVx73OU6UFro0OrwGpQ5KAAAAAJImoUqjwx2UHpIDAAAA0HitWLEiWrdufdSPz372s0mXd9zc4p1GbvEGAAAAaPTGjh0bgwYNOurXCgoK6rmaT09AmUYekgMAAADQ6LVp0ybatGmTdBknTEKVRjVrUOqgBAAAACBhAso00kEJAAAAQAMhoUoja1ACAAAA0EAIKNOoc+eoPv/8KO/RI+lKAAAAAEg5AWUajRsXVU89Fb+eODHpSgAAAABIOQElAAAAADQQ8+bNi/79+yddRr0SUAIAAABAAzFnzpz42c9+lnQZ9So/6QIAAAAAgENat24drVu3TrqMeiWgBAAAAKBpyGYjKiqSOXdRUUQm87HDli5dGvPnz4/t27dHs2a/v7l57Nix8ZnPfCZ69eoVK1eujE2bNkVExIYNG+Kmm26KF154ISorK6N///7x7W9/O84777xcXUm9c4s3AAAAAE1DRUVE69bJfBxnMDp+/PjYs2dPPPXUU7X79u7dG6tWrYoJEybUGV9eXh6TJ0+OtWvXxvr166NPnz4xevToKC8vP2nftqQJKAEAAACgnrRv3z4uvvjiuP/++2v3/fCHP4z27dvHsGHD6owfOnRoTJw4Mfr16xf9+vWLpUuXRkVFRaxZs6Y+y84pt3gDAAAA0DQUFUXs35/cuY/ThAkTYtq0abF48eIoLCyMFStWxNVXXx15eXl1xu7atStuueWWePLJJ+Ott96KqqqqqKioiNLS0pNZfaIElAAAAAA0DZlMRKtWSVfxscaMGRPV1dXx4x//OAYOHBhr166NO+6446hjp0yZErt3746FCxdGz549o7CwMAYPHhwHDhyo56pzR0AJAAAAAPWoZcuWcdlll8WKFSvi1Vdfjb59+0ZxcfFRx65duzYWL14co0ePjoiI7du3x549e+qz3JwTUAIAAABAPZswYUKMGTMmXnrppZg4ceIxx5155plx3333RUlJSezbty++/vWvR8uWLeux0tzzkBwAAAAAqGdDhw6N9u3bx5YtW+Kaa6455rjvfe97sXfv3hgwYEBMmjQpZs6cGZ06darHSnNPByUAAAAA1LO8vLx488036+yfN29ezJs3r3Z7wIABsWHDhiPGXHHFFbkur17poAQAAAAAEiOgBAAAAAASI6AEAAAAABIjoAQAAAAAEiOgBAAAAKBRy2azSZeQSifr+y6gBAAAAKBRysvLi4iIAwcOJFxJOtV832v+HT6t/JNRDAAAAADUt/z8/CgqKordu3dHQUFBNGumF6++VFdXx+7du6OoqCjy808sYhRQAgAAANAoZTKZ6Nq1a7z++uvxxhtvJF1O6jRr1ixOO+20yGQyJ3QcASUAAAAAjVbz5s2jT58+bvNOQPPmzU9K16qAEgAAAIBGrVmzZtGiRYuky+BTcmM+AAAAAJAYASUAAAAAkBgBJQAAAACQGGtQHkU2m42IiH379iVcSe5UVlZGRUVF7Nu3LwoKCpIuhybE3CJXzC1yxdwiV8wtcsXcIlfMLXLF3EqnmlytJmf7KALKoygvL4+IiB49eiRcCQAAAAA0XuXl5dGuXbuPHJPJHk+MmTLV1dXx5ptvRps2bSKTySRdTk7s27cvevToEdu3b4+2bdsmXQ5NiLlFrphb5Iq5Ra6YW+SKuUWumFvkirmVTtlsNsrLy6Nbt27RrNlHrzKpg/IomjVrFt27d0+6jHrRtm1bvxzICXOLXDG3yBVzi1wxt8gVc4tcMbfIFXMrfT6uc7KGh+QAAAAAAIkRUAIAAAAAiRFQplRhYWHceuutUVhYmHQpNDHmFrlibpEr5ha5Ym6RK+YWuWJukSvmFh/HQ3IAAAAAgMTooAQAAAAAEiOgBAAAAAASI6AEAAAAABIjoAQAAAAAEiOgTKHFixdHr169okWLFlFcXBxr165NuiSagKeffjrGjBkT3bp1i0wmEytXrky6JJqABQsWxMCBA6NNmzbRqVOnuPTSS2PLli1Jl0UTsGTJkjjnnHOibdu20bZt2xg8eHD85Cc/SbosmqAFCxZEJpOJWbNmJV0KTcC8efMik8kc8dGlS5eky6KJ+O1vfxsTJ06MU089NYqKiqJ///6xcePGpMuikTv99NPr/N7KZDIxY8aMpEujgRFQpsyDDz4Ys2bNiptvvjleeOGFuOCCC2LUqFFRWlqadGk0cu+++26ce+65ceeddyZdCk3ImjVrYsaMGbF+/fpYvXp1HDx4MEaMGBHvvvtu0qXRyHXv3j3+6Z/+KZ577rl47rnnYujQoTFu3Lh46aWXki6NJmTDhg2xbNmyOOecc5IuhSbks5/9bJSVldV+bN68OemSaAL27t0b559/fhQUFMRPfvKTePnll+Nb3/pWnHLKKUmXRiO3YcOGI35nrV69OiIixo8fn3BlNDSZbDabTboI6s+gQYPivPPOiyVLltTu69evX1x66aWxYMGCBCujKclkMvHwww/HpZdemnQpNDG7d++OTp06xZo1a+ILX/hC0uXQxLRv3z7+5V/+Jb7yla8kXQpNwP79++O8886LxYsXx+233x79+/ePhQsXJl0Wjdy8efNi5cqVsWnTpqRLoYm58cYb47//+7/dXUfOzZo1K370ox/FK6+8EplMJulyaEB0UKbIgQMHYuPGjTFixIgj9o8YMSKeffbZhKoCOH7vvPNORBwKkuBkqaqqigceeCDefffdGDx4cNLl0ETMmDEjvvSlL8Wf//mfJ10KTcwrr7wS3bp1i169esXVV18dv/nNb5IuiSbg0UcfjZKSkhg/fnx06tQpBgwYEN/97neTLosm5sCBA/Ef//EfMXXqVOEkdQgoU2TPnj1RVVUVnTt3PmJ/586dY+fOnQlVBXB8stlszJ49O/7sz/4szj777KTLoQnYvHlztG7dOgoLC2P69Onx8MMPx1lnnZV0WTQBDzzwQDz//PPuTuGkGzRoUCxfvjxWrVoV3/3ud2Pnzp0xZMiQePvtt5MujUbuN7/5TSxZsiT69OkTq1atiunTp8fMmTNj+fLlSZdGE7Jy5cr43e9+F1OmTEm6FBqg/KQLoP794V8qstmsv14ADd71118fL774YjzzzDNJl0IT8cd//MexadOm+N3vfhcPPfRQTJ48OdasWSOk5IRs3749vva1r8Xjjz8eLVq0SLocmphRo0bVvv7c5z4XgwcPjjPOOCP+/d//PWbPnp1gZTR21dXVUVJSEt/4xjciImLAgAHx0ksvxZIlS+LLX/5ywtXRVNx9990xatSo6NatW9Kl0ADpoEyRDh06RF5eXp1uyV27dtXpqgRoSP76r/86Hn300Xjqqaeie/fuSZdDE9G8efM488wzo6SkJBYsWBDnnntuLFq0KOmyaOQ2btwYu3btiuLi4sjPz4/8/PxYs2ZNfOc734n8/PyoqqpKukSakFatWsXnPve5eOWVV5IuhUaua9eudf5A169fPw9T5aR544034oknnohrr7026VJooASUKdK8efMoLi6ufWpWjdWrV8eQIUMSqgrg2LLZbFx//fXxn//5n/Hkk09Gr169ki6JJiybzcYHH3yQdBk0csOGDYvNmzfHpk2baj9KSkpiwoQJsWnTpsjLy0u6RJqQDz74IH79619H165dky6FRu7888+PLVu2HLFv69at0bNnz4Qqoqm55557olOnTvGlL30p6VJooNzinTKzZ8+OSZMmRUlJSQwePDiWLVsWpaWlMX369KRLo5Hbv39/vPrqq7Xbr7/+emzatCnat28fp512WoKV0ZjNmDEj7r///njkkUeiTZs2tR3g7dq1i5YtWyZcHY3ZTTfdFKNGjYoePXpEeXl5PPDAA/Hzn/88fvrTnyZdGo1cmzZt6qyT26pVqzj11FOtn8sJmzNnTowZMyZOO+202LVrV9x+++2xb9++mDx5ctKl0cjdcMMNMWTIkPjGN74RV155Zfzyl7+MZcuWxbJly5IujSaguro67rnnnpg8eXLk54uhODozI2WuuuqqePvtt2P+/PlRVlYWZ599djz22GP+MsYJe+655+Kiiy6q3a5ZB2ny5Mlx7733JlQVjd2SJUsiIuKLX/ziEfvvuecei2tzQt56662YNGlSlJWVRbt27eKcc86Jn/70pzF8+PCkSwM4ph07dsRf/MVfxJ49e6Jjx47x+c9/PtavX+//8pywgQMHxsMPPxxz586N+fPnR69evWLhwoUxYcKEpEujCXjiiSeitLQ0pk6dmnQpNGCZbDabTboIAAAAACCdrEEJAAAAACRGQAkAAAAAJEZACQAAAAAkRkAJAAAAACRGQAkAAAAAJEZACQAAAAAkRkAJAAAAACRGQAkAAAAAJEZACQBAg7Zly5bo0qVLlJeXn5Tj3XnnnTF27NiTciwAAE6cgBIAgHr3xS9+MWbNmnVcY2+++eaYMWNGtGnT5qSc+7rrrosNGzbEM888c1KOBwDAiRFQAgDQYO3YsSMeffTR+Mu//MuTdszCwsK45ppr4l//9V9P2jEBAPj0BJQAANSrKVOmxJo1a2LRokWRyWQik8nEtm3bjjr2Bz/4QZx77rnRvXv32n333ntvnHLKKbFq1aro169ftG7dOi6++OIoKyurHfPzn/88/vRP/zRatWoVp5xySpx//vnxxhtv1H597NixsXLlynjvvfdydp0AABwfASUAAPVq0aJFMXjw4LjuuuuirKwsysrKokePHkcd+/TTT0dJSUmd/RUVFfHNb34z7rvvvnj66aejtLQ05syZExERBw8ejEsvvTQuvPDCePHFF2PdunUxbdq0yGQyte8vKSmJysrK+OUvf5mbiwQA4LjlJ10AAADp0q5du2jevHkUFRVFly5dPnLstm3bori4uM7+ysrKuOuuu+KMM86IiIjrr78+5s+fHxER+/bti3feeScuueSS2q/369fviPfXdFZu27YtLrzwwpNxWQAAfEo6KAEAaLDee++9aNGiRZ39RUVFteFjRETXrl1j165dERHRvn37mDJlSowcOTLGjBkTixYtOuL27xotW7aMioqK3BUPAMBxEVACANBgdejQIfbu3Vtnf0FBwRHbmUwmstls7fY999wT69atiyFDhsSDDz4Yffv2jfXr1x/xnv/7v/+Ljh075qZwAACOm4ASAIB617x586iqqvrYcQMGDIiXX375U51jwIABMXfu3Hj22Wfj7LPPjvvvv7/2a6+99lq8//77MWDAgE91bAAATh4BJQAA9e7000+PX/ziF7Ft27bYs2dPVFdXH3XcyJEjY926dccVZtZ4/fXXY+7cubFu3bp444034vHHH4+tW7cesQ7l2rVro3fv3kfcJg4AQDIElAAA1Ls5c+ZEXl5enHXWWdGxY8coLS096rjRo0dHQUFBPPHEE8d97KKiovjf//3fuPzyy6Nv374xbdq0uP766+Ov/uqvasd8//vfj+uuu+6ErwMAgBOXyX54sR4AAGhgFi9eHI888kisWrXqpBzvf/7nf2LYsGGxdevWaNeu3Uk5JgAAn15+0gUAAMBHmTZtWuzduzfKy8ujTZs2J3y8N998M5YvXy6cBABoIHRQAgAAAACJsQYlAAAAAJAYASUAAAAAkBgBJQAAAACQGAElAAAAAJAYASUAAAAAkBgBJQAAAACQGAElAAAAAJAYASUAAAAAkBgBJQAAAACQmP8H2p6qe+/I2m8AAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -453,8 +461,13 @@ }, { "cell_type": "code", - "execution_count": 7, - "metadata": {}, + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:43:13.965110Z", + "start_time": "2023-08-03T01:43:13.956531Z" + } + }, "outputs": [], "source": [ "# Save the step responses.\n", @@ -467,19 +480,22 @@ }, { "cell_type": "code", - "execution_count": 8, - "metadata": {}, + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:43:19.171824Z", + "start_time": "2023-08-03T01:43:18.984738Z" + } + }, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7UAAAH0CAYAAADiwgrVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABDuUlEQVR4nO3deXxU9b3/8fcnARIg7GDYNwWsoCJEra3WICpoFZdWf7R2UVuprdalF1st3by93tba3VKVtmq99kq9uOGOS1MtIhYUFcUFt4ooIntYk/D5/fGdNEOSyUJm5syZvJ6Pxzwmc75nznySfDLJO+ec7zF3FwAAAAAAcVQQdQEAAAAAAOwtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAxJCZuZltNbOrMrDtIjOrNLMqM/uvdG8fAIB0ItQCAJBmZnakmT1lZpvMbL2ZLTSzQ83sbDOrSQTGSjN7y8xuMrPRSc8dngisteusMbP7zOy4Rl7qYHeflXjeaDO7x8zWJl7zYTMb00SNZyZq3GZmFclj7r7T3Usk/SVNXxIAADKGUAsAQBqZWXdJ90m6VlJvSYMkXSlpZ2KVRYnA2EPSsZK2S1pqZuPqbapnYr2DJT0i6S4zO7uJl+4pab6kMZJKJT0j6Z4m1l8v6deSftrCTw0AgJxEqAUAIL1GS5K73+buNe6+3d0XuPsLySslxt5w929I+rukHzW2MXf/wN1/kxi/2swa/d3t7s+4+5/cfb27V0n6laQxZtYnxfqPuvvtklbv5ecJAEBOINQCAJBer0mqMbM/m9kJZtarBc+5U9JRLVhnH4U9sS3xKUkfuPu6Fq4PAEAsEWoBAEgjd98s6UhJLukPktaa2XwzK23iaasVDlVuSu0e1ebWk5kNljRb0rearxgAgHgj1AIAkGbuvsLdz3b3wZLGSRqocP5qKoMUznFtyqDEfZPrmVk/SQsk/d7db2tZxQAAxBehFgCADHL3VyTdrBBuUzlN0pPNbOo0SR9KejXVColDnRdImu/uab/UDwAAuahD1AUAAJBPzGx/SZ+W9Fd3X2VmQyR9TtLT9dYrlDRU4RDhcklHpNheqaQzJP1Q0sXuvjvFet0lPSxpobtf3sh4uaS/ubslvX5Hhb8FCsysWFJNYpIpAABigz21AACk1xZJh0tabGZbFcLsckn/kRg/wswqJW2WVCGpu6RD3f3FetvZmHj+i5JOlHSGu9/YxOueJulQSeckXeO20syGJsaHSFqUtP4XFS4ndJ3CJFXbFc4BBgAgVszdo64BAAC0kpntULj27W/d/fstWP+Pkv7P3R9uwbpFktYo7Mn9mbtf2dZ6AQDIFEItAAAAACC2OPwYAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEVt5cp7Zv374+fPjwqMtIaevWreratWvUZSBH0R9Ihd5AKvQGUqE30BT6A6nEoTeWLl36kbv3q788b0Lt8OHDtWTJkqjLSKmiokLl5eVRl4EcRX8gFXoDqdAbSIXeQFPoD6QSh94ws3caW87hxwAAAACA2CLUAgAAAABii1ALAAAAAIitvDmnFgAAAADirqqqSqtWrdKOHTuy+ro9evTQihUrsvqaqRQXF2vw4MHq2LFji9Yn1AIAAABAjli1apW6deum4cOHy8yy9rpbtmxRt27dsvZ6qbi71q1bp1WrVmnEiBEteg6HHwMAAABAjtixY4f69OmT1UCbS8xMffr0adWeakItAAAAAOSQ9hpoa7X28yfUAgAAAABiK2fPqTWzqZJ+I6lQ0h/d/acRlwQAAADES1WVtGVLuFVWqvvLL0s1NWF58m3bNumNN6RNm6Tt28OyXbuksWOlUaOkDRuk224Ly6qqpJ07w3a+9z3pzDOlJUukU04Jy3ftCjdJmjdPOvVU6aGHpJNPrqursFAqKpLuvluaNElasECaOVMqLg7Lu3eXevaUfvSj8PorVkgLF0q9ekl9+kgDBkgDB0o5cA4o9s4rr7yi6dOny8w0b9487bvvvnu9rZwMtWZWKGm2pOMkrZL0TzOb7+4vR1sZAAAAkGXuIZR+9NGet7VrGy7bsEHavDmsv3VrCKBJJqS7trPOCreePSUzqaQkBM2SEqlHD+ntt6Vnnw1B9NvfrntedXUIwIMGhcddu0r77Sft2BFC9Zo10quvhnUk6W9/ky64oOHrv/yy9LGPSXfdJd1xR9jGqFF19717p/szRitUV1erQ4fGI+fdd9+tU045RVdeeWWbXycnQ62kwyStdPc3JcnM5ko6RRKhFgAAAPG2Y4e0bl3joTQ5rNber1tXt+ezvsJCaZ99pL59Q8Crqdlz/PDDpc99LuwBvewy7SguVnH//mGPZ+/e0uTJ0jHHSLt3S//8Z9hO9+5S585hj2mnTiFU1+7d3batbs9v7W3jRunDD8NtzZpw/9prIVw/9lhdLT16hAA6bly4jR0blknSJz8Zbqmce27Y07thQ/i6vP9+uA0ZEsY/+EB68knpf/831Ftr48bwGg8+KL33nnTIIeG1i4pa+11rN7Zu3aozzzxTq1atUk1Njb7//e9rv/3207e+9S1VVlaqb9++uvnmmzVgwIBGn19eXq5PfOITWrhwoaZNm6by8vIGz33uuef061//WoWFhXriiSf0t7/9rU0152qoHSTp3aTHqyQdHlEtAAAAQOOqqqT16+vCZ2MhtTagfvhhWGfr1tTb69Ah7PHcvTsEycGDpW99K4TN//qvENKksGezb1/pjDOka64Jy37wA6lLl7C89jZ8eNiGJH3ta3q6okLl5eWNv/a4cWn6oiRs3Ci99Vbd7c03Q/C+6y7pj3+sW2/IEOnjHw+3ww+XJkwIoTpZcXFYrzbE1vf1r4fbjh3hdVaulP71r7rQfMst0ty54eMOHaQDD5SOO066+ur0fs6Z0Nj368wzpW98I/yT4cQTG46ffXa4ffSR9NnP7jlWUdHkyz300EMaOHCg7r//fknSpk2bdMIJJ+iee+5Rv3799Ne//lWzZs3SjTfemHIbGzdu1N///ndVVVXp6KOPbvS5559/vkpKSjRz5swm62mJXA21jU135Q1WMpshaYYklZaWqqKZb1CUKisrc7o+RIv+QCr0BlKhN5AKvbGX3FWwY4c6VFaqQ2WlOm7eHG6bNtXdah9v3Bhumzerw7ZtqTdZUKDdHTtq64gRqurRQ902b1aneoF226BBWn7VVarq0UP7zp6tovXrVdWjh6p69NCunj21bfhwrT36aElS59/8RjWdO6uqRw95p051G6n9fh9zzJ4FVFeHcLdy5b8XRdIfvXuH28SJ4bG7Om7YoK5vv62SN95Qt1deUfcnn1Tn//s/SdLuDh20+YADtGHCBG0oK9OW/feXFxa27jW7dw8hvfZzPe88FZ90krqtXKmS119X95dflj/+uF5IjI+5+mpVl5Ro3Sc/qU0HHtj610ujHj16aMuWLf9+3Ln+3ndJ1Tt2qGrLFmnbtkbHq3bsUPWWLbLKShXXG9+etO1kNTU12rJli0aMGKFHHnlEl156qaZOnaqePXtq+fLlmjx58r/XKy0t3aPG+ts5+eSTtWXLFr388sspn7tz50517Ngx5XZ27NjR4l7N1VC7SlLyv2EGS1pdfyV3nyNpjiSVlZV5yv865YCKpv4rhnaP/kAq9AZSoTeQSrvsjaqqsPezsnLP25YtYeKjjRvrbhs2hL2l69eH26ZNYe/exo0hBKbStatUUBBeZ/fuuuVFRdIvfxn2il53XZjMqE8fqW9f2T77qHDffdV9zpyw7r33htfp00fq10/q21dd+vbVYbWTHZ16aia+OnvI6f5Ys0ZavFgFCxeq52OPqeef/6wRN98cAurxx0unny59+tPhcTq4q9wsHK78i19I8+dryLx54dDsE0+UvvrVxveSZtiKFSvULXkCrCefbLBOB0nFUjh/OcW4Uoynmlpry5Yt6tatmyZMmKBnn31WDzzwgH784x/ruOOO09ixY7Vo0aIW1V9YWKh+/fqpW7du6tKlS8rnFhUVqaioaM/PNUlxcbEOOeSQFr1mrobaf0oaZWYjJL0nabqkz0dbEgAAAJrlHkJmdXXdLLnbt4fgmHxrbFltEK2sDOFx27Zw37Fj3XmoH34Yltc+f+fOpsNoso4dG0ycJCmcr9m/v7RoUZiQqHbCo+7dQ8D5xz/CYay33RbOO+3RI4TYRHjVsceG7Zx2Wt3hw41Jnv0XDZWWStOmhZsUvt+PPx5mRr733jCTcqdO4Tzg00+XPvOZ8P3ZW7XfJ7Ow/cpK6ZFHpPnzpfvuC+fflpeH5S++GA6PbgfXj129erV69+6tL3zhCyopKdGcOXO0du1aLVq0SEcccYSqqqr02muvaezYsc1ua8yYMXv93NbIyVDr7tVmdqGkhxUu6XOju78UcVkAACAuaie22b274S3V8lRjNTV1oWn37jBhT3V1WJ481rFjGN+6NaxTO757d/hDuHPn8PH69XuO19SEINStWxh///268drX79QpHL65e3c4N7G6um6spibsRezTR9q9W2MXLgzrJn8uPXqEZdXVYUbZ2uXudePdu4eg+Oabe9ZWUxPO0ywqCiHyww/33HZNTZisqDbMNnIoZJsNHBjC4/bt0uuvNxw//3xp9OgQPO67L3ytu3atm4H3F7+QxoyRFi8OIamkJIz36BFm7T3mmHDOZmVl2F7Xro2Hl899LtxS6dgxLZ8uEvr0CecMn3FG6Kunnw7n4955p3TeedKFF4bLCJ19djg/NsUsuy1WUhL+MXHaaXX/lJHC6335y9LBB0sXXRR6oP45v3nkxRdf1GWXXaaCggJ17NhR1113nTp06KCLLrpImzZtUnV1tS655JIWBdNOnTpp3rx5e/Xc1jD3BqeqxlLZPvv4ks98Jn0bTPPXZf2SJepdf9a6wkLpsMPCx6+/Hk7kTtaxo1RWFj5+5ZXwSzBZcXH4D5IkvfRSmGEuWdeu0kEHhY9feKHhpATdutVNCPDcc+EXRbKePcMMdZK0dGnDWff69Am/QKTwS6L+L7HSUmnffcPXsrHDFQYMCJMX1NRIzzzTcHzw4DAZwK5d4dpn9Q0bFn7Jbd8e6q9v5MjwX9fKyvD51zdqVDj0Z/NmafnyhuNjxoQ/ADZsCNdGq692xr6PPgoz/NV30EHhe7BmTbjuW32HHBLeEFev1raXX1aXLl32HJ84MfwB8e674Sbt2ZeHHx566O23pdUNjs6Xjjgi/EJ+441QQ7KCgvDfRinUvnbtnuMdO0qHHho+TtV7ExIXBXjppXDoVrIuXcIbvxS+9rV/JNSqPc9Farz3evWq670lS0IPJH/uffu2rPck6amn1MDAgaH3qqvD8+urnYiiqd4bNKhh79XWuO++oYatW6Xnn2/4/OZ6b//9/9172599Vp2Li/ccb0nvlZSk7r3x4//de3r77YbjZWXhD+jk3kt22GHhD4fk3kv+/tT23ptvhtkokxUWht6Vwvteqt5z37ve69q16d5r7n2vsd5L1lzv7bNPXe8tWtTwd0lt79XUNN57ye97S5c2HE9639u5eLGKks+pk5p+33MPtfXuHXrvlVfq6qu9HzEi9M6mTeH7W3986NDwPdi0ac/vfe34oEHhe7h5c+jP+s8vLQ3vP5WVYRv1x2svvVG7F67+169r1z1DZf3xgoI9DwttT8zCz1dBQeOz5BYXh/43C6G0vt69Q+9IYSKf+vbfP9x27Ah7zQoKwq32NY86Kky8s2mTdM89YXmHDuG+Y8ewh3LChNAXtXvbOnUK70VduoRLwowfH94zFiwI3+suXULdxcXSkUeG983168PkP7XLi4rqAmpBQVq/pPkqpw8/bin3cJmgW26R/vKXsEe3f3/pK18Jk0XVXiYoXTZvlm6/Xbr22vDe2qeP9LWvSd//fujDNFuxYoU+Vvu7KItqDz/OFY19HcxsqbuX1V83f0Jtx46+JN3XoUrj4QU1GzeqsP4vGbPwB5BUdz5HsoKC8AYuhfMvaq/TVauwMPyBZVb3X99kHTuGHzop/LDXP9ym9r++UvglU//QneLiukM6av8rm6xz5xB8pfDHc/0/JLp0qZtx7oMPGv7xUXtYj3v4r3R93brV/de6fiiTwnNLSkLdjf2C7tEj/JKrqmr4h7MUPrfOncPXrf4/FKTwtSsurjvcqb6+fcMv0+3bG/7hLYXvbceO4Y+zDRsajvfvH37hV1bKN25sODvagAHhe7xlS8N/WEjhDdss9E5jJ9jXznS4YUPDf2iY1b3hr18fakxWWBj+cJbC16b+H/4dOoT6pPC1rd+7nTrV/XH0wQcNe7OoKPxxK4Xvff3e7Ny5rvdXr67rzdqfydqZHaUQuhrrrdre/te/1EC3buH77954aKv9z31NjbRqVcPxXr1C/1VXh8sD1NenT3iNXbsa/4dDv36hN3fsaLy3+/ULn+P27dr9wQcqqP+HWv/+oTe3bm28twcMCF/jLVsa791Bg8L3aNOmxnt36NDQA7XnntU3bFh4f6o9F61W7fdnxIhw/9FHDXvTLIQ6KdReP3QWFobXl8LXpn5vduxYN/Pl++837M2iorrefu+9hu+bnTvX9fa77zbsvS5d6nr3nXcavu917VrXu2+91bD3unev693G/qHQs2foD/cQ+uurvcRG7d64+vr2DduoqlLNW2+psP5EJv36hRp27my8dwcMCP29fXvdz0by77oRI8L2t2xpWJ+ZdMAB4fnr1oWJZ8z2PHzvkEPC63/wQd147ZhZ+GdaSUn42ic/v/Z29NHhe/Tmm3Wvnzx+/PGhd199NXx9an82au9PPjl8vHx5+Pxqg5dZ6J1p08LjZ58N/ZE83qVL3fMXLw6fg1ndOt261Y3//e+hv2tDnVn4vp5wQlj22GPh5yc5+JWWhkNUCwqkhx8OvZ0c/AYODMGt9vlVVXVjHTqE8YkTw/g//hF6KHm8f/9wXU5JS264QWWHH173+gUFob7S0tBb77yz51jt51dSEsY3b2443rFjeC3EXl6E2mS7dkn33y/ddFPYS19QEGb7veiiun+ypot7+Pn/7W/De8jTT4ftV1WldS89oTZon6G2rMyXNLZHJUfk3RsI0or+QCr0BlKhN5AKvYGm5HV/vPWWNHt2uFzQpk3hH2nf+16Y9Cnd58Lu2hX+ybZuXTjK4LzzpMsuS8thyXEJtRdccIEWLly4x7KLL75Y55xzTlrqaU2o5TgNAAAAAPE3YoT085+HI1Vmzw5H9Jx0UjjK4c4703t6Qu3pH9u2hdNmfvjDcPrKHXek/TTGXDV79mwtW7Zsj1u6Am1rEWoBAAAA5I+SEukb3whzN9x4Yzil4jOfCXNGPPZYel9ryJAQmCsqwukXn/1s2DNc/9QsZBShFgAAAED+6dhROuecMOHnLbeEQ4WPPTaEzhdfTO9rHX10OF//N78JQTcDE0ghNUItAAAAgPzVoYP0xS+GSeauuSbMTn/wwWGm5MYmRGzL61x0kTRnTnj88sshVDc2oSfSilALAAAAIP8VF0szZ4bZ6b/5zRA+x4wJe3EzcR7sokVh24ce2vilspA2hFoAAAAA7Ufv3uEw4aVLw/W7v/xlqbw87MlNp698pe4SX5/4hPT44+ndPv6NUAsAAACg/Rk/Xlq4UPrDH8I5tuPHh7CbzlmSy8ulZ56RBg+Wpk6VnngifdvOkK1bt+rTn/60Dj74YI0bN05//etftXTpUh199NGaOHGipkyZovfffz/qMvdAqAUAAADQPhUUSF/9qvTSS2ESqUsukY45JlzzNl2GDpX+8Q/p0kulww9P33Yz5KGHHtLAgQP1/PPPa/ny5Zo6daq++c1vat68eVq6dKnOPfdczZo1K+oy99Ah6gIAAAAAIFIDBkjz50s33yxdfLF04IHStddKZ58tmbV9+z17SldfHT5evz6E3GnTmn/eJZdIy5a1/fWTjR8v/frXKYcPPPBAzZw5U9/5znd00kknqVevXlq+fLmOO+44SVJNTY0GDBiQ3praiD21AAAAAGAWZitevlw67DDp3HOlL31JqqxM7+v86EfSaaeFEJ2DRo8eraVLl+rAAw/UFVdcoTvuuENjx47VsmXLtGzZMr344otasGBB1GXugT21AAAAAFBr6FDpkUekq66SrrwynBN7++3hMkDp8NOfhpmRzzpLevppaezY1Os2sUc1U1avXq3evXvrC1/4gkpKSjRnzhytXbtWixYt0hFHHKGqqiq99tprGttU3VlGqAUAAACAZIWF0g9+IH3qU9LnPx/Ohb32Wum889q+7S5dpLvvlsrKwiHIzzwj9enT9u2myYsvvqjLLrtMBQUF6tixo6677jp16NBBF110kTZt2qTq6mpdcsklhFoAAAAAyHnl5eGc1i98QZoxI1wG6Le/lTp1att2Bw2S7rpLOvrocA7vrbemo9q0mDJliqZMmdJg+RM5PHMz59QCAAAAQCr77CM9+KD0ne9IN9wgTZ4srVnT9u1+/OPSnXdKP/9527fVzhFqAQAAAKAphYXhXNjbbgt7a8vKpCVL2r7dT39a6t8/XBt3w4a2b6+dItQCAAAAQEtMny4tXBiub3vUUdK8eW3fprt08snSGWeEj9FqhFoAAAAAaKlDDgl7aSdMCEH05z9vWxg1k048UXrsMWnuXEmSt/Nw29rPn1ALAAAAAK3Rr18IoWecIV12mXTBBVJ19d5v7/zzQ0i+/HIVd+qkdevWtdtg6+5at26diouLW/wcZj8GAAAAgNYqLg57VkeOlK6+WnrnHemvf5VKSlq/rcJC6ZprpMmTNfi++7Rq2jStXbs2/TU3YceOHa0KkplUXFyswYMHt3h9Qi0AAAAA7I2CgjCB1IgRYW/t0UeHmZL32af12zrmGGnqVHW8+WaNuOiicFhyFlVUVOiQQw7J6mumC4cfAwAAAEBbfO1r0vz50ooVYQKpd97Zu+3cdJO0eHHWA23cEWoBAAAAoK1OPFFasCBcw/bII0PAba3+/aVOnaSqKmnXrvTXmKcItQAAAACQDkceKT3xRAilRx0lPfNM67exapU0fLj0l7+kvbx8RagFAAAAgHQ56KBwLdvu3cN5so8+2rrnDxok9e4t/fa3XLe2hQi1AAAAAJBO++4bgu3IkdJJJ0kPPdTy55pJF10kLVsm/eMfGSsxnxBqAQAAACDdBgyQKiqkAw6QTjklzIrcUmedFfb0/uEPGSsvnxBqAQAAACATevcOhx+PGyedeqr0wAMte16XLtL06dK8edLmzRktMR8QagEAAAAgU3r3lh55JATb005rebC99FLp7rulrl0zWl4+INQCAAAAQCYl77E97bQQcpuz//7S8cdLhYWZry/mCLUAAAAAkGm9eoVgu//+IdguWdL8c959V/rOd6T33st8fTFGqAUAAACAbOjVK8yE3K+fdMIJ0muvNb3+tm3Sz34m3XFHduqLKUItAAAAAGTLgAHSggXh0j3HHy+tXp163TFjpAMPlG6/PXv1xRChFgAAAACyadSoMGHUunXhcj/bt6de94wzwjVvOQQ5JUItAAAAAGRbWZl0663h3NrzzpPcG1/v1FPDfUtnTW6HCLUAAAAAEIVTTpF+/GPpL3+Rfv7zxtcZNy4cgrxxY1ZLi5MOURcAAAAAAO3WrFnSCy9Il18uHXGEdOSRe46bSc8/H+7RKPbUAgAAAEBUzKQ//UkaMUL6/Oel9esbX0eSqqqyW1tMEGoBAAAAIErduklz50rvv9/4+bXu0qGHSpddFk19OY5QCwAAAABRKyuTfvIT6c47pVtu2XPMTOrZU3rssUhKy3WEWgAAAADIBd/6lvTJT4b7Dz/cc2zyZGn5cmnNmmhqy2GEWgAAAADIBQUF0pw5UmWldMkle45NnhzuH38862XlupwLtWb2IzN7z8yWJW4nRl0TAAAAAGTFAQdI3/2udNtte16bdsIEqUcPDkFuRM6F2oRfufv4xI2rDAMAAABoPy6/XPrYx6RvflPauTMsKyyUfvhD6UT2+dWXq6EWAAAAANqnoiLp17+W3nxTuvbauuWXXiqdfnpkZeWqXA21F5rZC2Z2o5n1iroYAAAAAMiq448Pe2V//GNp7dqwzF167TXprbeirS3HmNe/BlI2XtTsUUn9GxmaJelpSR9Jckk/ljTA3c9NsZ0ZkmZIUmlp6cS5c+dmpuA0qKysVElJSdRlIEfRH0iF3kAq9AZSoTfQFPojXrq8844OPfdcrTr9dL1xwQWy6modefLJev+EE7TyoovS+lpx6I1JkyYtdfey+ssjCbUtZWbDJd3n7uOaW7esrMyXLFmS+aL2UkVFhcrLy6MuAzmK/kAq9AZSoTeQCr2BptAfMXTOOdLcudIbb0gDB4ZZkDdskJ59Nq0vE4feMLNGQ23OHX5sZgOSHp4maXlUtQAAAABApL7/fam6WvrJT8LjT35Sev55acuWaOvKITkXaiX9zMxeNLMXJE2SdGnUBQEAAABAJEaODHtr58yR3n1XOvJIafduafHiqCvLGTkXat39i+5+oLsf5O7T3P39qGsCAAAAgMjMmhUmibrqKunjH5fMpEWLoq4qZ+RcqAUAAAAAJBk2TPrKV6Qbb5S2bpUeekiaMSPqqnIGoRYAAAAAct3MmVJNjfTb34bL/ZSWRl1RziDUAgAAAECu23df6fTTpeuuk155RfrFL6Q1a6KuKicQagEAAAAgDmbOlDZtkq6/Pnz81FNRV5QTCLUAAAAAEAeHHy4ddZR0551SYaH0z39GXVFOINQCAAAAQFzMnBku7TN4MKE2gVALAAAAAHFx0knSmDFSZaW0ZEm41E87R6gFAAAAgLgoKJD+4z+kdeukzZul99+PuqLIEWoBAAAAIE6++EWpX79waZ+BA6OuJnKEWgAAAACIk+Ji6cILpYceklasiLqayBFqAQAAACBuvv51qUOHsNe2nSPUAgAAAEDc9OsnDRkiLV0qrVkTdTWRItQCAAAAQByddFK4/9Wvoq0jYoRaAAAAAIijyZPD/fXXS9u2RVtLhAi1AAAAABBHBx8c7jdtkm65JdpaIkSoBQAAAIA4GjZM2m+/cG7tL38p7d4ddUWRINQCAAAAQByZSa+/Lv3sZ+H+3nujrigShFoAAAAAiLPPflYaOlT6xS+iriQShFoAAAAAiKsFC6Tx46Wzz5aefFJavDjqirKOUAsAAAAAcdWpk/TSS9Ihh0h9+kg/+EHUFWUdoRYAAAAA4uqAA8L9229Ll18e9tw+8USkJWUboRYAAAAA4qpfv7CHdsUK6YILpAEDpFmzJPeoK8saQi0AAAAAxJVZ2Fv78stS587S974n/eMf0v33R11Z1hBqAQAAACDOTjwxTBYlSV/9qrT//tLFF0vbt0daVrYQagEAAAAgzi6/XLr22vBxp07S7NnSm29KV18dbV1ZQqgFAAAAgLhzl6qrw8fHHCNNny795CfS889HW1cWEGoBAAAAIM7WrZN695ZuuKFu2W9+E5ZNny5t2xZdbVlAqAUAAACAOOvdO+ypffnlumX77CPdeqv06qvS176W17MhE2oBAAAAIM6SZ0BONnmydOWVIdx+//vR1JYFHaIuAAAAAADQRmPGSAsWNFz+ve9J774rXXWVtHt3uDfLfn0ZxJ5aAAAAAIi70aOl1aulyso9l5tJv/+9NGNGmDjqzDOl9eujqTFDCLUAAAAAEHeTJklXXCFVVTUc69BBuv76cImfu++Wxo2T5sxpfN0YItQCAAAAQNx9/OPSf/+31KtX4+Nm0re/LS1eLA0bFiaPGjxYuvRSacECFWzfnt1604hQCwAAAAD5YPNmac2apteZMEF66inpwQelI4+UZs+WpkzRxK9/PTs1ZgATRQEAAABAPhg7NhyGfMstTa9nJk2dGm6VldLChXpr8WKNy06VaUeoBQAAAIB8MHq09NprrXtOSYk0ZYo+KirKTE1ZwOHHAAAAAJAPRo+WXn896iqyjlALAAAAAPlg9OhwuZ5166KuJKsItQAAAACQD0aNCvetPQQ55gi1AAAAAJAPysrCbMbDhkVdSVYxURQAAAAA5IP+/aVvfCPqKrKOPbUAAAAAkC9WrpSWLIm6iqxiTy0AAAAA5IuLL5ZWr5aeey7qSrKGPbUAAAAAkC9GjQqX9XGPupKsiSzUmtkZZvaSme02s7J6Y1eY2Uoze9XMpkRVIwAAAADEyujR0tatYW9tOxHlntrlkk6X9ETyQjM7QNJ0SWMlTZX0ezMrzH55AAAAABAz++0X7t98M9o6siiyUOvuK9z91UaGTpE01913uvtbklZKOiy71QEAAABADI0cGe7bUajNxYmiBkl6OunxqsQyAAAAAEBThg2T5s+XDj006kqyxjyDJxCb2aOS+jcyNMvd70msUyFpprsvSTyeLWmRu9+aePwnSQ+4+x2NbH+GpBmSVFpaOnHu3LkZ+TzSobKyUiUlJVGXgRxFfyAVegOp0BtIhd5AU+gPpBKH3pg0adJSdy+rvzyje2rd/di9eNoqSUOSHg+W1OhZzu4+R9IcSSorK/Py8vK9eLnsqKioUC7Xh2jRH0iF3kAq9AZSoTfQFPqjnXjmGWnVKun001v8lDj3Ri5e0me+pOlmVmRmIySNkvRMxDUBAAAAQDzccIN0wQVRV5E1UV7S5zQzWyXpCEn3m9nDkuTuL0m6XdLLkh6SdIG710RVJwAAAADEysiR0gcfSNu2RV1JVkQ2UZS73yXprhRjV0m6KrsVAQAAAEAeqJ0B+e23pQMOiLSUbMjFw48BAAAAAHurnV3Wh1ALAAAAAPmknYXaXLxOLQAAAABgb/XtKz33nLTfflFXkhWEWgAAAADIJ2bS+PFRV5E1HH4MAAAAAPnmkUekX/0q6iqyglALAAAAAPnmwQelWbMk96gryThCLQAAAADkm5Ejpe3bpTVroq4k4wi1AAAAAJBv2tEMyIRaAAAAAMg3hFoAAAAAQGwNHx7u33kn0jKygUv6AAAAAEC+KS6W1q2TevWKupKMI9QCAAAAQD7q3TvqCrKCw48BAAAAIB/NmyddcknUVWQcoRYAAAAA8tFzz0m/+51UXR11JRlFqAUAAACAfDRsmFRTI61eHXUlGUWoBQAAAIB8NGxYuM/zGZAJtQAAAACQjwi1AAAAAIDYGjpU6tJF2rIl6koyikv6AAAAAEA+6tJFqqyUzKKuJKPYUwsAAAAA+SrPA61EqAUAAACA/DV7tvSlL0VdRUYRagEAAAAgX735pjRvnuQedSUZQ6gFAAAAgHw1bJi0fbv00UdRV5IxhFoAAAAAyFft4LI+hFoAAAAAyFeEWgAAAABAbA0bJo0ZE3UVGcV1agEAAAAgX/XqJb3yStRVZBR7agEAAAAAsUWoBQAAAIB89t3vSqecEnUVGUOoBQAAAIB8tnGj9OSTUVeRMYRaAAAAAMhnw4ZJGzZIW7ZEXUlGEGoBAAAAIJ/l+WV9CLUAAAAAkM9qQ+2//hVtHRlCqAUAAACAfDZypDR5stS5c9SVZATXqQUAAACAfFZaKj36aNRVZAx7agEAAAAAsUWoBQAAAIB8d9ZZ0pQpUVeREYRaAAAAAMh3ZtLrr0ddRUYQagEAAAAg3w0eLK1aJe3eHXUlaUeoBQAAAIB8N2SIVFUlffhh1JWkHaEWAAAAAPLd4MHhftWqaOvIAEItAAAAAOS7j31MOvtsqWvXqCtJO65TCwAAAAD5bvRo6aaboq4iI9hTCwAAAADtgbu0fXvUVaRdZKHWzM4ws5fMbLeZlSUtH25m281sWeJ2fVQ1AgAAAEDeGDdOOvfcqKtIuygPP14u6XRJNzQy9oa7j89uOQAAAACQx/r1Y6KodHL3Fe7+alSvDwAAAADtypAh0rvvRl1F2uXqObUjzOw5M/u7mR0VdTEAAAAAEHuDB0vvvSfV1ERdSVqZu2du42aPSurfyNAsd78nsU6FpJnuviTxuEhSibuvM7OJku6WNNbdNzey/RmSZkhSaWnpxLlz52bk80iHyspKlZSURF0GchT9gVToDaRCbyAVegNNoT/at4F3363Rv/mNnpo3T7v69NljLA69MWnSpKXuXlZ/eUbPqXX3Y/fiOTsl7Ux8vNTM3pA0WtKSRtadI2mOJJWVlXl5eXmb6s2kiooK5XJ9iBb9gVToDaRCbyAVegNNoT/auZ49pR499IlPfSqcX5skzr2Rc9epNbN+kta7e42ZjZQ0StKbEZcFAAAAAPE2fny45ZkoL+lzmpmtknSEpPvN7OHE0KckvWBmz0uaJ+l8d18fVZ0AAAAAkBfcpbVrpY8+irqStIpy9uO73H2wuxe5e6m7T0ksv8Pdx7r7we4+wd3vjapGAAAAAMgrQ4dKP/1p1FWkVa7OfgwAAAAASCezMANynl2rllALAAAAAO3F4MF5d61aQi0AAAAAtBdDhrCnFgAAAAAQU0OGSO+9J9XURF1J2uTcJX0AAAAAABly6qnS8OEh1BYWRl1NWhBqAQAAAKC9OPTQcMsjHH4MAAAAAO1FVZX07LPS6tVRV5I2hFoAAAAAaC82b5YmTpRuvz3qStKGUAsAAAAA7UXv3lLnznl1WR9CLQAAAAC0F2bhWrV5dFkfQi0AAAAAtCd5dq3aZmc/NrPBkqZLOkrSQEnbJS2XdL+kB919d0YrBAAAAACkz5Ah0uOPR11F2jQZas3sJkmDJN0n6WpJH0oqljRa0lRJs8zscnd/ItOFAgAAAADS4MILpc9/Puoq0qa5PbW/cPfljSxfLulOM+skaWj6ywIAAAAAZERZWdQVpFWT59SmCLTJ47vcfWV6SwIAAAAAZMymTdI990jvvx91JWnRZKg1s1FmdrOZ/dLMBpvZg2a21cyeN7NDs1UkAAAAACBN3nlHOvVUaeHCqCtJi+ZmP75J0lOSVktaLOlGSX0kzZT0u8yWBgAAAABIu8GDw32eXKu2uVBb4u5z3P3nkra7+/+5+w53f0RSURbqAwAAAACkU69eUpcu7SbUJl+uZ3MTYwAAAACAODALe2vz5Fq1zc1+vL+ZvSDJJO2b+FiJxyMzWhkAAAAAIDOGDMmbPbXNhdqPZaUKAAAAAED2/OpXUlF+nFHaZKh193eyVQgAAAAAIEsOPDDqCtKmuUv6bDGzzalu2SoSAAAAAJBGb78tzZ4trV8fdSVt1tye2m6SZGb/KekDSf+jcD7tWZK6Zbw6AAAAAED6rVghXXihNGGCdMQRUVfTJs3Nflxrirv/3t23uPtmd79O0mcyWRgAAAAAIENqr1WbBzMgtzTU1pjZWWZWaGYFZnaWpJpMFgYAAAAAyJDaUJsHMyC3NNR+XtKZktYkbmcklgEAAAAA4qZnT6lr17zYU9vcJX0kSe7+tqRTMlsKAAAAACArzMLe2jzYU9tkqDWz70n6vbs3OiWWmR0jqYu735eJ4gAAAAAAGfLww1KvXlFX0WbN7al9UdK9ZrZD0rOS1koqljRK0nhJj0r670wWCAAAAADIgGHDoq4gLZo8p9bd73H3T0o6X9JLkgolbZZ0q6TD3P1Sd1+b+TIBAAAAAGm1eLF0+eVSdXXUlbRJS8+pfV3S6xmuBQAAAACQLc8/L119tXTBBVFX0iYtnf0YAAAAAJBPhgwJ9zGfAZlQCwAAAADtUZ5cq5ZQCwAAAADtUe2e2piH2uYu6fOpFm7nbXf/VxrqAQAAAABkQ48eUteu0gcfRF1JmzQ3UdQ5LdzOXZIItQAAAAAQF2Yh0JaUSBUVUVez15oMte7e0lALAAAAAIibkpKoK2izvT6n1sz2T2chAAAAAIAsu/NO6fzzo66iTdoyUdSCtFUBAAAAAMi+5culG26Q7doVdSV7rbmJon6bakhSz7RXAwAAAADInqFDJUlFa9dGXMjea8lEUf8haWcjY59LfzkAAAAAgKxJXNanOI9D7T8lLXf3p+oPmNmPMlIRAAAAACA7avfUrlkTcSF7r7lzaj8raVljA+4+oi0vbGbXmNkrZvaCmd1lZj2Txq4ws5Vm9qqZTWnL6wAAAAAAUhg8WOreXYU7Gzs4Nx6aDLXuvt7dt2XotR+RNM7dD5L0mqQrJMnMDpA0XdJYSVMl/d7MCjNUAwAAAAC0X507S5s2afW0aVFXsteaDLVm1t3MfmJm/2Nmn6839vu2vLC7L3D36sTDpyUNTnx8iqS57r7T3d+StFLSYW15LQAAAABAfmru8OObFGY6vkPSdDO7w8yKEmMfT2Md50p6MPHxIEnvJo2tSiwDAAAAAGAP5u6pB82Wufv4pMezJJ0oaZqkR9x9QpMbN3tUUv9Ghma5+z1J2yyTdLq7u5nNlrTI3W9NjP9J0gPufkcj258haYYklZaWTpw7d25T5USqsrJSJSUlUZeBHEV/IBV6A6nQG0iF3kBT6A+kEofemDRp0lJ3L6u/vLnZj4vMrMDdd0uSu19lZqskPSGp2c/Y3Y9tatzMvizpJEmTvS5dr5I0JGm1wZJWp9j+HElzJKmsrMzLy8ubKykyFRUVyuX6EC36A6nQG0iF3kAq9AaaQn8glTj3RnOHH98r6ZjkBe7+Z4Vr1+5qywub2VRJ35E0rd5kVPMVDnUuMrMRkkZJeqYtrwUAAAAAyE9N7ql192+nWP6QQthsi99JKpL0iJlJ0tPufr67v2Rmt0t6WVK1pAvcvaaNrwUAAAAAyENNhloz+1ZT4+7+y719YXffr4mxqyRdtbfbBgAAAAC0D82dU9stcT9G0qEKhwZL0skK59UCAAAAABCZ5g4/vlKSzGyBpAnuviXx+EeS/i/j1QEAAAAA0ITmJoqqNVR7Tgy1S9LwtFcDAAAAAEArNHf4ca3/kfSMmd0lySWdJumWjFUFAAAAAEALtCjUJq5P+6CkoxKLznH35zJXFgAAAAAAzWtu9uPeSQ/fTtz+Pebu6zNTFgAAAAAAzWtuT+1ShcONTeG82g2Jj3tK+pekEZksDgAAAACApjQ5UZS7j3D3kZIelnSyu/d19z6STpJ0ZzYKBAAAAAAglZbOfnyouz9Q+8DdH5R0dGZKAgAAAACgZVo6+/FHZvY9SbcqHI78BUnrMlYVAAAAAAAt0NI9tZ+T1E/SXZLulrRPYhkAAAAAAJFp6SV91ku6WJLMrJekje7umSwMAAAAAIDmNLmn1sx+YGb7Jz4uMrPHJa2UtMbMjs1GgQAAAAAApNLc4cf/T9KriY+/nFh/H4VJov47g3UBAAAAANCs5kLtrqTDjKdIus3da9x9hVo+yRQAAAAAABnRXKjdaWbjzKyfpEmSFiSNdclcWQAAAAAANK+5va2XSJqnMPPxr9z9LUkysxMlPZfZ0gAAAAAAaFqTodbdn5a0fyPLH5D0QKaKAgAAAACgJZoMtWY2tIXb2ejum9NQDwAAAAAALdbc4cd/bsE2XNLNkm5pczUAAAAAALRCc4cfT8pWIQAAAAAAtFZzsx8DAAAAAJCzCLUAAAAAgNgi1AIAAAAAYotQCwAAAACILUItAAAAACC2CLUAAAAAgNgi1AIAAAAAYotQCwAAAACILUItAAAAACC2CLUAAAAAgNgi1AIAAAAAYotQCwAAAACILUItAAAAACC2CLUAAAAAgNgi1AIAAAAAYotQCwAAAACILUItAAAAACC2CLUAAAAAgNgi1AIAAAAAYotQCwAAAACILUItAAAAACC2CLUAAAAAgNgi1AIAAAAAYiuyUGtm15jZK2b2gpndZWY9E8uHm9l2M1uWuF0fVY0AAAAAgNwW5Z7aRySNc/eDJL0m6YqksTfcfXzidn405QEAAAAAcl1kodbdF7h7deLh05IGR1ULAAAAACCecuWc2nMlPZj0eISZPWdmfzezo6IqCgAAAACQ28zdM7dxs0cl9W9kaJa735NYZ5akMkmnu7ubWZGkEndfZ2YTJd0taay7b25k+zMkzZCk0tLSiXPnzs3QZ9J2lZWVKikpiboM5Cj6A6nQG0iF3kAq9AaaQn8glTj0xqRJk5a6e1n95RkNtc0xsy9LOl/SZHfflmKdCkkz3X1JU9sqKyvzJUuaXCVSFRUVKi8vj7oM5Cj6A6nQG0iF3kAq9AaaQn8glTj0hpk1GmqjnP14qqTvSJqWHGjNrJ+ZFSY+HilplKQ3o6kSAAAAAJDLOkT42r+TVCTpETOTpKcTMx1/StJ/mlm1pBpJ57v7+ujKBAAAAADkqshCrbvvl2L5HZLuyHI5AAAAAIAYypXZjwEAAAAAaDVCLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGKLUAsAAAAAiC1CLQAAAAAgtgi1AAAAAIDYItQCAAAAAGIrslBrZj82sxfMbJmZLTCzgUljV5jZSjN71cymRFUjAAAAACC3Rbmn9hp3P8jdx0u6T9IPJMnMDpA0XdJYSVMl/d7MCiOrEgAAAACQsyILte6+OelhV0me+PgUSXPdfae7vyVppaTDsl0fAAAAACD3dYjyxc3sKklfkrRJ0qTE4kGSnk5abVViGQAAAAAAezB3b36tvd242aOS+jcyNMvd70la7wpJxe7+QzObLWmRu9+aGPuTpAfc/Y5Gtj9D0gxJKi0tnTh37txMfBppUVlZqZKSkqjLQI6iP5AKvYFU6A2kQm+gKfQHUolDb0yaNGmpu5fVX57RPbXufmwLV/1fSfdL+qHCntkhSWODJa1Osf05kuZIUllZmZeXl+91rZlWUVGhXK4P0aI/kAq9gVToDaRCb6Ap9AdSiXNvRDn78aikh9MkvZL4eL6k6WZWZGYjJI2S9Ey26wMAAAAA5L4oz6n9qZmNkbRb0juSzpckd3/JzG6X9LKkakkXuHtNdGUCAAAAAHJVZKHW3T/TxNhVkq7KYjkAAAAAgBiK8jq1AAAAAAC0CaEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGxFFmrN7Mdm9oKZLTOzBWY2MLF8uJltTyxfZmbXR1UjAAAAACC3Rbmn9hp3P8jdx0u6T9IPksbecPfxidv50ZQHAAAAAMh1kYVad9+c9LCrJI+qFgAAAABAPHWI8sXN7CpJX5K0SdKkpKERZvacpM2SvufuT0ZRHwAAAAAgt5l75naQmtmjkvo3MjTL3e9JWu8KScXu/kMzK5JU4u7rzGyipLslja23Z7f2eTMkzZCk0tLSiXPnzs3Ep5EWlZWVKikpiboM5Cj6A6nQG0iF3kAq9AaaQn8glTj0xqRJk5a6e1n95RkNtS1lZsMk3e/u4xoZq5A0092XNLWNsrIyX7KkyVUiVVFRofLy8qjLQI6iP5AKvYFU6A2kQm+gKfQHUolDb5hZo6E2ytmPRyU9nCbplcTyfmZWmPh4pKRRkt7MfoUAAAAAgFwX5Tm1PzWzMZJ2S3pHUu0sx5+S9J9mVi2pRtL57r4+ohoBAAAAADksslDr7p9JsfwOSXdkuRwAAAAAQAxFeZ1aAAAAAADahFALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2Io81JrZTDNzM+ubtOwKM1tpZq+a2ZQo6wMAAAAA5K4OUb64mQ2RdJykfyUtO0DSdEljJQ2U9KiZjXb3mmiqBAAAAADkqqj31P5K0rcledKyUyTNdfed7v6WpJWSDouiOAAAAABAboss1JrZNEnvufvz9YYGSXo36fGqxDIAAAAAAPaQ0cOPzexRSf0bGZol6buSjm/saY0s80aWycxmSJqReFhpZq+2oKwekja1cZ2mxlON9ZX0UbPVRaslX5uot78322jNczLZH009L9f7g97gvaMpmeyPqHqjNc+jN1Jr7+8d6ViP3ohu+/xeiQa9QW80ZVijS9096zdJB0r6UNLbiVu1wnm1/SVdIemKpHUflnREGl97TlvXaWo81ZikJVF8rdP9tYl6+3uzjdY8J5P90Uzf5HR/0Bu8d0TVH1H1RmueR29E0xtR9kc6e2Nvv//0Rrx7o6Xrtsf3DnqD3tibWySHH7v7i+6+j7sPd/fhCocYT3D3DyTNlzTdzIrMbISkUZKeSePL35uGdZoab8n2c1Wma0/H9vdmG615Tib7g97I7Pbj3ButrSXXZLL2qHqjNc+jN1Jr7+8d6ViP3ohu+/xeiQa9QW+0miVSebRFmL0tqczdP0o8niXpXIU9uJe4+4MRlpcWZrbE3cuirgO5if5AKvQGUqE3kAq9gabQH0glzr0R6SV9aiX21iY/vkrSVdFUkzFzoi4AOY3+QCr0BlKhN5AKvYGm0B9IJba9kRN7agEAAAAA2BtRX6cWAAAAAIC9RqgFAAAAAMQWoRYAAAAAEFuE2oiYWbmZPWlm15tZedT1IHeYWYGZXWVm15rZl6OuB7nFzI5KvG/80cyeiroe5A4zG2pm883sRjO7POp6kDvM7AAzu93MrjOzz0ZdD6JnZiPN7E9mNi9pWVcz+7OZ/cHMzoqyPkQrRX80WJZLCLVplPhD4kMzW15v+VQze9XMVib9oeGSKiUVK1ynF3mslb1xiqRBkqpEb7QLrekPd3/S3c+XdJ+kP0dRL7Knle8doyXd7+7nSjog68Uiq1rZGydIutbdvy7pS1kvFlnRyt8lb7r7V+pt4nRJ89z9PEnTslQ2sqSt/ZGiZ3IGoTa9bpY0NXmBmRVKmq3wC+UASZ8zswMkPenuJ0j6jqQrs1wnsu9mtbw3xkha5O7fkvT1LNeJaNyslvdHrc9Lui1bBSIyN6vlvfGcpOlm9rikv2W5TmTfzWp5b/yPQm9cI6lPlutE9tys1v8uSTZY0ruJj2syVCOic7Pa1h85jVCbRu7+hKT19RYfJmll4r8buyTNlXSKu+9OjG+QVJTFMhGB1vSGwt7ZDYl1+KXSDrSyP2RmQyVtcvfN2a0U2dbK3jhH0g/d/RhJn85upci2Vv7N8aG7XyDpckkfZblUZElrf5c0YpVCsJXICHknDf2R02jYzBukuv96SeENY5CZnW5mNyj89/R3kVSGqDXaG5LulDTFzK6V9EQUhSEnpOoPSfqKpJuyXhFyRareeEjSRWZ2vaS3I6gL0Uv1N8dwM5sj6RZJ10RSGaKSqif6JN4rDjGzKxJjd0r6jJldJ+neLNeJaLS4P1L0TM7oEHUB7YA1sszd/U6FNw+0X6l6Y5tCaEH71mh/SJK7/zDLtSC3pHrvWC6JSYDat1S98bakGVmuBbkhVU+sk3R+vYVbFY74QPvRmv5osCyXsKc281ZJGpL0eLCk1RHVgtxCb6Ap9AdSoTeQCr2B+ugJNCVv+oNQm3n/lDTKzEaYWSdJ0yXNj7gm5AZ6A02hP5AKvYFU6A3UR0+gKXnTH4TaNDKz2yQtkjTGzFaZ2VfcvVrShZIelrRC0u3u/lKUdSL76A00hf5AKvQGUqE3UB89gabke3+Yu0ddAwAAAAAAe4U9tQAAAACA2CLUAgAAAABii1ALAAAAAIgtQi0AAAAAILYItQAAAACA2CLUAgAAAABii1ALAEAOMLOLzGyFmf2lkbFDzOyPiY/PNrPf1RuvMLOyJrY918xGpb9qAACiR6gFACA3fEPSie5+ViNj35V0bRu2fZ2kb7fh+QAA5CxCLQAAETOz6yWNlDTfzC6tN9ZN0kHu/nwLtjPNzJYlbq+a2VuJoSclHWtmHdJePAAAEeOXGwAAEXP3881sqqRJ7v5RveEyScvrLft/ZnZk0uP9EtuZL2m+JJnZ7ZL+nli+28xWSjpY0tIMfAoAAESGPbUAAOS2AZLW1lv2V3cfX3uTtCR50My+LWm7u89OWvyhpIEZrRQAgAiwpxYAgNy2XVJxS1c2s8mSzpD0qXpDxYltAQCQV9hTCwBAbluhxOHFzTGzYZJ+L+lMd68fYEdLeinNtQEAEDn21AIAkMPc/RUz62Fm3dx9SzOrny2pj6S7zEySVrv7iWZWqnA48vsZLhcAgKwzd4+6BgAA0ITEjMhb3P2PbXj+Znf/U3orAwAgehx+DABA7rtO0s42PH+jpD+npxQAAHILe2oBAAAAALHFnloAAAAAQGwRagEAAAAAsUWoBQAAAADEFqEWAAAAABBbhFoAAAAAQGwRagEAAAAAsfX/AZcEbChQBYOTAAAAAElFTkSuQmCC\n", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -523,29 +539,14 @@ }, { "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(0.9931206775030963+0j)\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:21:13.552537Z", + "start_time": "2023-08-03T01:21:13.552532Z" } - ], + }, + "outputs": [], "source": [ "tfilename = \"../Channels/ODSA_BOW_20mm_Organic/osda_bow_04_models/osda_bow_04_A_Layer1.s10p\"\n", "\n", @@ -569,22 +570,14 @@ }, { "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:21:13.553132Z", + "start_time": "2023-08-03T01:21:13.553123Z" } - ], + }, + "outputs": [], "source": [ "tfilenames = []\n", "#tfilenames.append(('ch1', \"../Channels/deembedded_Diff_1_Assembly_1_Interposer_24.s4p\"))\n", @@ -601,22 +594,14 @@ }, { "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:21:13.553588Z", + "start_time": "2023-08-03T01:21:13.553581Z" } - ], + }, + "outputs": [], "source": [ "ntwk = rf.Network(\"../Support/DoriItzhaki/tx_se.s4p\")\n", "for m in range(4):\n", @@ -627,8 +612,13 @@ }, { "cell_type": "code", - "execution_count": 23, - "metadata": {}, + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:21:13.554122Z", + "start_time": "2023-08-03T01:21:13.554117Z" + } + }, "outputs": [], "source": [ "rf.one_port_2_two_port(subnet).write_touchstone()" @@ -636,20 +626,14 @@ }, { "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(1201, 1, 1)" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2023-08-03T01:21:13.554987Z", + "start_time": "2023-08-03T01:21:13.554981Z" } - ], + }, + "outputs": [], "source": [ "subnet.s.shape" ] @@ -665,7 +649,7 @@ "metadata": { "anaconda-cloud": {}, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -679,7 +663,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.9.16" }, "toc": { "base_numbering": 1, diff --git a/pyproject.toml b/pyproject.toml index ab305b9..33b0752 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -18,6 +18,7 @@ dependencies = [ "PyIBIS-AMI>=4.1.2", "pyside2", "pyyaml>=6", + "qt>=5", "scikit-rf>=0.24.1", ] keywords=["bert", "communication", "simulator"] diff --git a/src/pybert/gui/plot.py b/src/pybert/gui/plot.py index 9725029..4b07b51 100644 --- a/src/pybert/gui/plot.py +++ b/src/pybert/gui/plot.py @@ -420,38 +420,38 @@ def make_plots(self, n_dfe_taps): # - Jitter Distributions tab plot_jitter_dist_chnl = Plot(plotdata, padding_left=75) - plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_chnl"), type="line", color="blue", name="Measured") - plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_ext_chnl"), type="line", color="red", name="Extrapolated") + plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_chnl"), type="line", color="blue", name="Total") + plot_jitter_dist_chnl.plot(("jitter_bins", "jitter_ext_chnl"), type="line", color="red", name="Data-Ind.") plot_jitter_dist_chnl.title = post_chnl_str plot_jitter_dist_chnl.index_axis.title = "Time (ps)" - plot_jitter_dist_chnl.value_axis.title = "Count" + plot_jitter_dist_chnl.value_axis.title = "PDF" plot_jitter_dist_chnl.legend.visible = True plot_jitter_dist_chnl.legend.align = "ur" plot_jitter_dist_tx = Plot(plotdata, padding_left=75) - plot_jitter_dist_tx.plot(("jitter_bins", "jitter_tx"), type="line", color="blue", name="Measured") - plot_jitter_dist_tx.plot(("jitter_bins", "jitter_ext_tx"), type="line", color="red", name="Extrapolated") + plot_jitter_dist_tx.plot(("jitter_bins", "jitter_tx"), type="line", color="blue", name="Total") + plot_jitter_dist_tx.plot(("jitter_bins", "jitter_ext_tx"), type="line", color="red", name="Data-Ind.") plot_jitter_dist_tx.title = post_tx_str plot_jitter_dist_tx.index_axis.title = "Time (ps)" - plot_jitter_dist_tx.value_axis.title = "Count" + plot_jitter_dist_tx.value_axis.title = "PDF" plot_jitter_dist_tx.legend.visible = True plot_jitter_dist_tx.legend.align = "ur" plot_jitter_dist_ctle = Plot(plotdata, padding_left=75) - plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ctle"), type="line", color="blue", name="Measured") - plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ext_ctle"), type="line", color="red", name="Extrapolated") + plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ctle"), type="line", color="blue", name="Total") + plot_jitter_dist_ctle.plot(("jitter_bins", "jitter_ext_ctle"), type="line", color="red", name="Data-Ind.") plot_jitter_dist_ctle.title = post_ctle_str plot_jitter_dist_ctle.index_axis.title = "Time (ps)" - plot_jitter_dist_ctle.value_axis.title = "Count" + plot_jitter_dist_ctle.value_axis.title = "PDF" plot_jitter_dist_ctle.legend.visible = True plot_jitter_dist_ctle.legend.align = "ur" plot_jitter_dist_dfe = Plot(plotdata, padding_left=75) - plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_dfe"), type="line", color="blue", name="Measured") - plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_ext_dfe"), type="line", color="red", name="Extrapolated") + plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_dfe"), type="line", color="blue", name="Total") + plot_jitter_dist_dfe.plot(("jitter_bins", "jitter_ext_dfe"), type="line", color="red", name="Data-Ind.") plot_jitter_dist_dfe.title = post_dfe_str plot_jitter_dist_dfe.index_axis.title = "Time (ps)" - plot_jitter_dist_dfe.value_axis.title = "Count" + plot_jitter_dist_dfe.value_axis.title = "PDF" plot_jitter_dist_dfe.legend.visible = True plot_jitter_dist_dfe.legend.align = "ur" @@ -464,11 +464,9 @@ def make_plots(self, n_dfe_taps): # - Jitter Spectrums tab plot_jitter_spec_chnl = Plot(plotdata) - plot_jitter_spec_chnl.plot(("f_MHz", "jitter_spectrum_chnl"), type="line", color="blue", name="Total") - plot_jitter_spec_chnl.plot( - ("f_MHz", "jitter_ind_spectrum_chnl"), type="line", color="red", name="Data Independent" - ) - plot_jitter_spec_chnl.plot(("f_MHz", "thresh_chnl"), type="line", color="magenta", name="Pj Threshold") + plot_jitter_spec_chnl.plot(("f_MHz", "jitter_spectrum_chnl"), type="line", color="blue", name="Total") + plot_jitter_spec_chnl.plot(("f_MHz", "jitter_ind_spectrum_chnl"), type="line", color="red", name="Data Independent") + plot_jitter_spec_chnl.plot(("f_MHz", "thresh_chnl"), type="line", color="magenta", name="Pj Threshold") plot_jitter_spec_chnl.title = post_chnl_str plot_jitter_spec_chnl.index_axis.title = "Frequency (MHz)" plot_jitter_spec_chnl.value_axis.title = "|FFT(TIE)| (dBui)" @@ -481,9 +479,9 @@ def make_plots(self, n_dfe_taps): plot_jitter_spec_chnl.legend.align = "lr" plot_jitter_spec_tx = Plot(plotdata) - plot_jitter_spec_tx.plot(("f_MHz", "jitter_spectrum_tx"), type="line", color="blue", name="Total") - plot_jitter_spec_tx.plot(("f_MHz", "jitter_ind_spectrum_tx"), type="line", color="red", name="Data Independent") - plot_jitter_spec_tx.plot(("f_MHz", "thresh_tx"), type="line", color="magenta", name="Pj Threshold") + plot_jitter_spec_tx.plot(("f_MHz", "jitter_spectrum_tx"), type="line", color="blue", name="Total") + plot_jitter_spec_tx.plot(("f_MHz", "jitter_ind_spectrum_tx"), type="line", color="red", name="Data Independent") + plot_jitter_spec_tx.plot(("f_MHz", "thresh_tx"), type="line", color="magenta", name="Pj Threshold") plot_jitter_spec_tx.title = post_tx_str plot_jitter_spec_tx.index_axis.title = "Frequency (MHz)" plot_jitter_spec_tx.value_axis.title = "|FFT(TIE)| (dBui)" @@ -495,11 +493,9 @@ def make_plots(self, n_dfe_taps): plot_jitter_spec_chnl.value_range = plot_jitter_spec_tx.value_range plot_jitter_spec_ctle = Plot(plotdata) - plot_jitter_spec_ctle.plot(("f_MHz", "jitter_spectrum_ctle"), type="line", color="blue", name="Total") - plot_jitter_spec_ctle.plot( - ("f_MHz", "jitter_ind_spectrum_ctle"), type="line", color="red", name="Data Independent" - ) - plot_jitter_spec_ctle.plot(("f_MHz", "thresh_ctle"), type="line", color="magenta", name="Pj Threshold") + plot_jitter_spec_ctle.plot(("f_MHz", "jitter_spectrum_ctle"), type="line", color="blue", name="Total") + plot_jitter_spec_ctle.plot(("f_MHz", "jitter_ind_spectrum_ctle"), type="line", color="red", name="Data Independent") + plot_jitter_spec_ctle.plot(("f_MHz", "thresh_ctle"), type="line", color="magenta", name="Pj Threshold") plot_jitter_spec_ctle.title = post_ctle_str plot_jitter_spec_ctle.index_axis.title = "Frequency (MHz)" plot_jitter_spec_ctle.value_axis.title = "|FFT(TIE)| (dBui)" @@ -509,11 +505,9 @@ def make_plots(self, n_dfe_taps): plot_jitter_spec_ctle.value_range = plot_jitter_spec_tx.value_range plot_jitter_spec_dfe = Plot(plotdata) - plot_jitter_spec_dfe.plot(("f_MHz_dfe", "jitter_spectrum_dfe"), type="line", color="blue", name="Total") - plot_jitter_spec_dfe.plot( - ("f_MHz_dfe", "jitter_ind_spectrum_dfe"), type="line", color="red", name="Data Independent" - ) - plot_jitter_spec_dfe.plot(("f_MHz_dfe", "thresh_dfe"), type="line", color="magenta", name="Pj Threshold") + plot_jitter_spec_dfe.plot(("f_MHz_dfe", "jitter_spectrum_dfe"), type="line", color="blue", name="Total") + plot_jitter_spec_dfe.plot(("f_MHz_dfe", "jitter_ind_spectrum_dfe"), type="line", color="red", name="Data Independent") + plot_jitter_spec_dfe.plot(("f_MHz_dfe", "thresh_dfe"), type="line", color="magenta", name="Pj Threshold") plot_jitter_spec_dfe.title = post_dfe_str plot_jitter_spec_dfe.index_axis.title = "Frequency (MHz)" plot_jitter_spec_dfe.value_axis.title = "|FFT(TIE)| (dBui)" diff --git a/src/pybert/gui/view.py b/src/pybert/gui/view.py index 2d75d16..bf16945 100644 --- a/src/pybert/gui/view.py +++ b/src/pybert/gui/view.py @@ -78,7 +78,6 @@ name="pattern", label="Pattern", tooltip="pattern to use to construct bit stream", - # editor=TextEditor(auto_set=False, enter_set=True, evaluate=int), ), Item( name="seed", @@ -104,16 +103,16 @@ show_border=True, ), VGroup( - Item( - name="thresh", - label="Pj Threshold (sigma)", - tooltip="Threshold for identifying periodic jitter spectral elements. (sigma)", - ), Item( name="impulse_length", label="Impulse Response Length (ns)", tooltip="Manual impulse response length override", ), + Item( + name="thresh", + label="Pj Threshold (sigma)", + tooltip="Threshold for identifying periodic jitter spectral elements. (sigma)", + ), Item(name="debug", label="Debug", tooltip="Enable to log extra information to console."), label="Analysis Parameters", show_border=True, @@ -181,8 +180,6 @@ label="Use file", ), spring, - # Item(name="padded", label="Zero-padded", enabled_when="use_ch_file == True"), - # Item(name="windowed", label="Windowed", enabled_when="use_ch_file == True"), ), ), HGroup( @@ -356,7 +353,6 @@ reorderable=False, sortable=False, selection_mode="cell", - # auto_size=True, rows=4, ), show_label=False, @@ -771,7 +767,5 @@ buttons=NoButtons, statusbar="status_str", title="PyBERT", - # width=0.95, - # height=0.9, icon=ImageResource("icon.png"), ) diff --git a/src/pybert/models/bert.py b/src/pybert/models/bert.py index ddd7332..f4a56a3 100644 --- a/src/pybert/models/bert.py +++ b/src/pybert/models/bert.py @@ -45,16 +45,16 @@ find_crossings, getwave_step_resp, import_channel, + make_bathtub, make_ctle, safe_log10, trim_impulse, ) from pyibisami.ami.model import AMIModel, AMIModelInitializer -DEBUG = False +DEBUG = False MIN_BATHTUB_VAL = 1.0e-18 - -gFc = 1.0e6 # Corner frequency of high-pass filter used to model capacitive coupling of periodic noise. +gFc = 1.0e6 # Corner frequency of high-pass filter used to model capacitive coupling of periodic noise. def my_run_sweeps(self, is_thread_stopped: Optional[Callable[[], bool]] = None): @@ -193,6 +193,20 @@ def _check_sim_status(): ideal_xings = find_crossings(t, x, decision_scaler, mod_type=mod_type) self.ideal_xings = ideal_xings + # - Generate the uncorrelated periodic noise. (Assume capacitive coupling.) + # - Generate the ideal rectangular aggressor waveform. + pn_period = 1.0 / pn_freq + pn_samps = int(pn_period / Ts + 0.5) + pn = zeros(pn_samps) + pn[pn_samps // 2 :] = pn_mag + self.pn_period = pn_period + self.pn_samps = pn_samps + pn = resize(pn, len(x)) + # - High pass filter it. (Simulating capacitive coupling.) + (b, a) = iirfilter(2, gFc / (fs / 2), btype="highpass") + pn = lfilter(b, a, pn)[: len(pn)] + self.pn = pn + # Calculate the channel output. # # Note: We're not using 'self.ideal_signal', because we rely on the system response to @@ -202,7 +216,11 @@ def _check_sim_status(): chnl_h = self.calc_chnl_h() _calc_chnl_time = clock() - split_time split_time = clock() - chnl_out = convolve(self.x, chnl_h)[: len(t)] + # - Add the uncorrelated periodic and random noise to the Tx output. + x = self.x + x += pn + x += normal(scale=rn, size=(len(x),)) + chnl_out = convolve(x, chnl_h)[: len(t)] _conv_chnl_time = clock() - split_time if self.debug: self.log(f"Channel calculation time: {_calc_chnl_time}") @@ -302,17 +320,6 @@ def _check_sim_status(): tx_H = fft(temp) tx_H *= tx_s[-1] / abs(tx_H[0]) - # - Generate the uncorrelated periodic noise. (Assume capacitive coupling.) - # - Generate the ideal rectangular aggressor waveform. - pn_period = 1.0 / pn_freq - pn_samps = int(pn_period / Ts + 0.5) - pn = zeros(pn_samps) - pn[pn_samps // 2 :] = pn_mag - pn = resize(pn, len(tx_out)) - # - High pass filter it. (Simulating capacitive coupling.) - (b, a) = iirfilter(2, gFc / (fs / 2), btype="highpass") - pn = lfilter(b, a, pn)[: len(pn)] - # - Add the uncorrelated periodic and random noise to the Tx output. tx_out += pn tx_out += normal(scale=rn, size=(len(tx_out),)) @@ -470,42 +477,17 @@ def _check_sim_status(): _check_sim_status() - # Generate the output from, and the incremental/cumulative impulse/step/frequency responses of, the DFE. + # DFE output and incremental/cumulative impulse/step/frequency responses. try: if self.use_dfe: - dfe = DFE( - n_taps, - gain, - delta_t, - alpha, - ui, - nspui, - decision_scaler, - mod_type, - n_ave=n_ave, - n_lock_ave=n_lock_ave, - rel_lock_tol=rel_lock_tol, - lock_sustain=lock_sustain, - bandwidth=bandwidth, - ideal=self.sum_ideal, - ) + _gain = gain + _ideal=self.sum_ideal else: - dfe = DFE( - n_taps, - 0.0, - delta_t, - alpha, - ui, - nspui, - decision_scaler, - mod_type, - n_ave=n_ave, - n_lock_ave=n_lock_ave, - rel_lock_tol=rel_lock_tol, - lock_sustain=lock_sustain, - bandwidth=bandwidth, - ideal=True, - ) + _gain = 0.0 + _ideal=True + dfe = DFE( n_taps, _gain, delta_t, alpha, ui, nspui, decision_scaler, mod_type + , n_ave=n_ave, n_lock_ave=n_lock_ave, rel_lock_tol=rel_lock_tol + , lock_sustain=lock_sustain, bandwidth=bandwidth, ideal=_ideal ) (dfe_out, tap_weights, ui_ests, clocks, lockeds, clock_times, bits_out) = dfe.run(t, ctle_out) dfe_out = array(dfe_out) dfe_out.resize(len(t)) @@ -583,22 +565,44 @@ def _check_sim_status(): # - in the duo-binary case, the XOR pre-coding can invert every other pattern rep., and # - in the PAM-4 case, the bits are taken in pairs to form the symbols and we start w/ an odd # of bits. # So, while it isn't strictly necessary, doubling it in the NRZ case as well provides a certain consistency. + pattern_len = (pow(2, max(pattern)) - 1) * 2 + len_x_m1 = len(x) - 1 + xing_min_t = (nui - eye_uis) * ui + + def eye_xings(xings, ofst=0): + """ + Return crossings from that portion of the signal used to generate the eye. + + Args: + xings([float]): List of crossings. + + KeywordArgs: + ofst(float): Time offset to be subtracted from all crossings. + + Returns: + [float]: Selected crossings, offset and eye-start corrected. + """ + _xings = array(xings) - ofst + return _xings[where(_xings > xing_min_t)] - xing_min_t + try: - pattern_len = (pow(2, max(pattern)) - 1) * 2 + # - ideal + ideal_xings_jit = eye_xings(ideal_xings) # - channel output - len_x_m1 = len(x) - 1 - actual_xings = find_crossings(t, chnl_out, decision_scaler, mod_type=mod_type) ofst = (argmax(sig.correlate(chnl_out, x)) - len_x_m1) * Ts - actual_xings -= ofst + actual_xings = find_crossings(t, chnl_out, decision_scaler, mod_type=mod_type) + actual_xings_jit = eye_xings(actual_xings, ofst) ( - _, + tie, t_jitter, isi, dcd, pj, rj, - _, + pjDD, + rjDD, + tie_ind, thresh, jitter_spectrum, jitter_ind_spectrum, @@ -606,12 +610,14 @@ def _check_sim_status(): hist, hist_synth, bin_centers, - ) = calc_jitter(ui, nui, pattern_len, ideal_xings, actual_xings, rel_thresh) - self.t_jitter = t_jitter - self.isi_chnl = isi - self.dcd_chnl = dcd - self.pj_chnl = pj - self.rj_chnl = rj + ) = calc_jitter(ui, eye_uis, pattern_len, ideal_xings_jit, actual_xings_jit, rel_thresh) + self.t_jitter = t_jitter + self.isi_chnl = isi + self.dcd_chnl = dcd + self.pj_chnl = pj + self.rj_chnl = rj + self.pjDD_chnl = pjDD + self.rjDD_chnl = rjDD self.thresh_chnl = thresh self.jitter_chnl = hist self.jitter_ext_chnl = hist_synth @@ -619,19 +625,24 @@ def _check_sim_status(): self.jitter_spectrum_chnl = jitter_spectrum self.jitter_ind_spectrum_chnl = jitter_ind_spectrum self.f_MHz = array(spectrum_freqs) * 1.0e-6 + self.ofst_chnl = ofst + self.tie_chnl = tie + self.tie_ind_chnl = tie_ind # - Tx output - actual_xings = find_crossings(t, rx_in, decision_scaler, mod_type=mod_type) ofst = (argmax(sig.correlate(rx_in, x)) - len_x_m1) * Ts - actual_xings -= ofst + actual_xings = find_crossings(t, rx_in, decision_scaler, mod_type=mod_type) + actual_xings_jit = eye_xings(actual_xings, ofst) ( - _, + tie, t_jitter, isi, dcd, pj, rj, - _, + pjDD, + rjDD, + tie_ind, thresh, jitter_spectrum, jitter_ind_spectrum, @@ -639,29 +650,38 @@ def _check_sim_status(): hist, hist_synth, bin_centers, - ) = calc_jitter(ui, nui, pattern_len, ideal_xings, actual_xings, rel_thresh) - self.isi_tx = isi - self.dcd_tx = dcd - self.pj_tx = pj - self.rj_tx = rj + ) = calc_jitter(ui, eye_uis, pattern_len, ideal_xings_jit, actual_xings_jit, rel_thresh, dbg_obj=self) + self.isi_tx = isi + self.dcd_tx = dcd + self.pj_tx = pj + self.rj_tx = rj + self.pjDD_tx = pjDD + self.rjDD_tx = rjDD self.thresh_tx = thresh self.jitter_tx = hist self.jitter_ext_tx = hist_synth + self.jitter_centers_tx = bin_centers self.jitter_spectrum_tx = jitter_spectrum self.jitter_ind_spectrum_tx = jitter_ind_spectrum + self.jitter_freqs_tx = spectrum_freqs + self.t_jitter_tx = t_jitter + self.tie_tx = tie + self.tie_ind_tx = tie_ind # - CTLE output - actual_xings = find_crossings(t, ctle_out, decision_scaler, mod_type=mod_type) ofst = (argmax(sig.correlate(ctle_out, x)) - len_x_m1) * Ts - actual_xings -= ofst + actual_xings = find_crossings(t, ctle_out, decision_scaler, mod_type=mod_type) + actual_xings_jit = eye_xings(actual_xings, ofst) ( - jitter, + tie, t_jitter, isi, dcd, pj, rj, - jitter_ext, + pjDD, + rjDD, + tie_ind, thresh, jitter_spectrum, jitter_ind_spectrum, @@ -669,34 +689,35 @@ def _check_sim_status(): hist, hist_synth, bin_centers, - ) = calc_jitter(ui, nui, pattern_len, ideal_xings, actual_xings, rel_thresh) - self.isi_ctle = isi - self.dcd_ctle = dcd - self.pj_ctle = pj - self.rj_ctle = rj + ) = calc_jitter(ui, eye_uis, pattern_len, ideal_xings_jit, actual_xings_jit, rel_thresh) + self.isi_ctle = isi + self.dcd_ctle = dcd + self.pj_ctle = pj + self.rj_ctle = rj + self.pjDD_ctle = pjDD + self.rjDD_ctle = rjDD self.thresh_ctle = thresh self.jitter_ctle = hist self.jitter_ext_ctle = hist_synth self.jitter_spectrum_ctle = jitter_spectrum self.jitter_ind_spectrum_ctle = jitter_ind_spectrum + self.tie_ctle = tie + self.tie_ind_ctle = tie_ind # - DFE output - ignore_until = (nui - eye_uis) * ui - ideal_xings = array(list(filter(lambda x: x >= ignore_until, ideal_xings))) - ideal_xings -= ignore_until - actual_xings = find_crossings(t, dfe_out, decision_scaler, mod_type=mod_type) ofst = (argmax(sig.correlate(dfe_out, x)) - len_x_m1) * Ts - actual_xings -= ofst - actual_xings = array(list(filter(lambda x: x >= ignore_until, actual_xings))) - actual_xings -= ignore_until + actual_xings = find_crossings(t, dfe_out, decision_scaler, mod_type=mod_type) + actual_xings_jit = eye_xings(actual_xings, ofst) ( - jitter, + tie, t_jitter, isi, dcd, pj, rj, - jitter_ext, + pjDD, + rjDD, + tie_ind, thresh, jitter_spectrum, jitter_ind_spectrum, @@ -704,16 +725,20 @@ def _check_sim_status(): hist, hist_synth, bin_centers, - ) = calc_jitter(ui, eye_uis, pattern_len, ideal_xings, actual_xings, rel_thresh) - self.isi_dfe = isi - self.dcd_dfe = dcd - self.pj_dfe = pj - self.rj_dfe = rj + ) = calc_jitter(ui, eye_uis, pattern_len, ideal_xings_jit, actual_xings_jit, rel_thresh) + self.isi_dfe = isi + self.dcd_dfe = dcd + self.pj_dfe = pj + self.rj_dfe = rj + self.pjDD_dfe = pjDD + self.rjDD_dfe = rjDD self.thresh_dfe = thresh self.jitter_dfe = hist self.jitter_ext_dfe = hist_synth self.jitter_spectrum_dfe = jitter_spectrum self.jitter_ind_spectrum_dfe = jitter_ind_spectrum + self.tie_dfe = tie + self.tie_ind_dfe = tie_ind self.f_MHz_dfe = array(spectrum_freqs) * 1.0e-6 dfe_spec = self.jitter_spectrum_dfe self.jitter_rejection_ratio = zeros(len(dfe_spec)) @@ -777,7 +802,7 @@ def update_results(self): tap_weights = transpose(array(self.adaptation)) i = 1 for tap_weight in tap_weights: - self.plotdata.set_data("tap%d_weights" % i, tap_weight) + self.plotdata.set_data(f"tap{i}_weights", tap_weight) i += 1 self.plotdata.set_data("tap_weight_index", list(range(len(tap_weight)))) if self._old_n_taps != n_taps: @@ -868,36 +893,34 @@ def update_results(self): self.plotdata.set_data("dfe_out_H", 20.0 * safe_log10(abs(self.dfe_out_H[1:len_f_GHz]))) # Jitter distributions - jitter_ext_chnl = self.jitter_ext_chnl # These are used, again, in bathtub curve generation, below. - jitter_ext_tx = self.jitter_ext_tx - jitter_ext_ctle = self.jitter_ext_ctle - jitter_ext_dfe = self.jitter_ext_dfe - self.plotdata.set_data("jitter_bins", array(self.jitter_bins) * 1.0e12) - self.plotdata.set_data("jitter_chnl", self.jitter_chnl) - self.plotdata.set_data("jitter_ext_chnl", jitter_ext_chnl) - self.plotdata.set_data("jitter_tx", self.jitter_tx) - self.plotdata.set_data("jitter_ext_tx", jitter_ext_tx) - self.plotdata.set_data("jitter_ctle", self.jitter_ctle) - self.plotdata.set_data("jitter_ext_ctle", jitter_ext_ctle) - self.plotdata.set_data("jitter_dfe", self.jitter_dfe) - self.plotdata.set_data("jitter_ext_dfe", jitter_ext_dfe) + jitter_chnl = self.jitter_chnl # These are used again in bathtub curve generation, below. + jitter_tx = self.jitter_tx + jitter_ctle = self.jitter_ctle + jitter_dfe = self.jitter_dfe + jitter_bins = self.jitter_bins + jitter_dt = jitter_bins[1] - jitter_bins[0] + self.plotdata.set_data("jitter_bins", array(self.jitter_bins) * 1e12) + self.plotdata.set_data("jitter_chnl", jitter_chnl * 1e-12) # PDF (/ps) + self.plotdata.set_data("jitter_ext_chnl", self.jitter_ext_chnl * 1e-12) + self.plotdata.set_data("jitter_tx", jitter_tx * 1e-12) + self.plotdata.set_data("jitter_ext_tx", self.jitter_ext_tx * 1e-12) + self.plotdata.set_data("jitter_ctle", jitter_ctle * 1e-12) + self.plotdata.set_data("jitter_ext_ctle", self.jitter_ext_ctle * 1e-12) + self.plotdata.set_data("jitter_dfe", jitter_dfe * 1e-12) + self.plotdata.set_data("jitter_ext_dfe", self.jitter_ext_dfe * 1e-12) # Jitter spectrums log10_ui = safe_log10(ui) self.plotdata.set_data("f_MHz", self.f_MHz[1:]) self.plotdata.set_data("f_MHz_dfe", self.f_MHz_dfe[1:]) self.plotdata.set_data("jitter_spectrum_chnl", 10.0 * (safe_log10(self.jitter_spectrum_chnl[1:]) - log10_ui)) - self.plotdata.set_data( - "jitter_ind_spectrum_chnl", 10.0 * (safe_log10(self.jitter_ind_spectrum_chnl[1:]) - log10_ui) - ) + self.plotdata.set_data("jitter_ind_spectrum_chnl", 10.0 * (safe_log10(self.jitter_ind_spectrum_chnl[1:]) - log10_ui)) self.plotdata.set_data("thresh_chnl", 10.0 * (safe_log10(self.thresh_chnl[1:]) - log10_ui)) self.plotdata.set_data("jitter_spectrum_tx", 10.0 * (safe_log10(self.jitter_spectrum_tx[1:]) - log10_ui)) self.plotdata.set_data("jitter_ind_spectrum_tx", 10.0 * (safe_log10(self.jitter_ind_spectrum_tx[1:]) - log10_ui)) self.plotdata.set_data("thresh_tx", 10.0 * (safe_log10(self.thresh_tx[1:]) - log10_ui)) self.plotdata.set_data("jitter_spectrum_ctle", 10.0 * (safe_log10(self.jitter_spectrum_ctle[1:]) - log10_ui)) - self.plotdata.set_data( - "jitter_ind_spectrum_ctle", 10.0 * (safe_log10(self.jitter_ind_spectrum_ctle[1:]) - log10_ui) - ) + self.plotdata.set_data("jitter_ind_spectrum_ctle", 10.0 * (safe_log10(self.jitter_ind_spectrum_ctle[1:]) - log10_ui)) self.plotdata.set_data("thresh_ctle", 10.0 * (safe_log10(self.thresh_ctle[1:]) - log10_ui)) self.plotdata.set_data("jitter_spectrum_dfe", 10.0 * (safe_log10(self.jitter_spectrum_dfe[1:]) - log10_ui)) self.plotdata.set_data("jitter_ind_spectrum_dfe", 10.0 * (safe_log10(self.jitter_ind_spectrum_dfe[1:]) - log10_ui)) @@ -905,43 +928,22 @@ def update_results(self): self.plotdata.set_data("jitter_rejection_ratio", self.jitter_rejection_ratio[1:]) # Bathtubs - half_len = len(jitter_ext_chnl) // 2 - # - Channel - bathtub_chnl = list(cumsum(jitter_ext_chnl[-1 : -(half_len + 1) : -1])) - bathtub_chnl.reverse() - bathtub_chnl = array(bathtub_chnl + list(cumsum(jitter_ext_chnl[: half_len + 1]))) - bathtub_chnl = where( - bathtub_chnl < MIN_BATHTUB_VAL, - 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_chnl)), - bathtub_chnl, - ) # To avoid Chaco log scale plot wierdness. + bathtub_chnl, (ext_start_chnl, ext_end_chnl) = make_bathtub( + jitter_bins, jitter_chnl, min_val=0.1*MIN_BATHTUB_VAL, + rj=self.rj_chnl, extrap=True) + bathtub_tx, (ext_start_tx, ext_end_tx) = make_bathtub( + jitter_bins, jitter_tx, min_val=0.1*MIN_BATHTUB_VAL, + rj=self.rj_tx, extrap=True) + bathtub_ctle, (ext_start_ctle, ext_end_ctle) = make_bathtub( + jitter_bins, jitter_ctle, min_val=0.1*MIN_BATHTUB_VAL, + rj=self.rj_ctle, extrap=True) + bathtub_dfe, (ext_start_dfe, ext_end_dfe) = make_bathtub( + jitter_bins, jitter_dfe, min_val=0.1*MIN_BATHTUB_VAL, + rj=self.rj_dfe, extrap=True) self.plotdata.set_data("bathtub_chnl", safe_log10(bathtub_chnl)) - # - Tx - bathtub_tx = list(cumsum(jitter_ext_tx[-1 : -(half_len + 1) : -1])) - bathtub_tx.reverse() - bathtub_tx = array(bathtub_tx + list(cumsum(jitter_ext_tx[: half_len + 1]))) - bathtub_tx = where( - bathtub_tx < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_tx)), bathtub_tx - ) # To avoid Chaco log scale plot wierdness. - self.plotdata.set_data("bathtub_tx", safe_log10(bathtub_tx)) - # - CTLE - bathtub_ctle = list(cumsum(jitter_ext_ctle[-1 : -(half_len + 1) : -1])) - bathtub_ctle.reverse() - bathtub_ctle = array(bathtub_ctle + list(cumsum(jitter_ext_ctle[: half_len + 1]))) - bathtub_ctle = where( - bathtub_ctle < MIN_BATHTUB_VAL, - 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_ctle)), - bathtub_ctle, - ) # To avoid Chaco log scale plot wierdness. + self.plotdata.set_data("bathtub_tx", safe_log10(bathtub_tx)) self.plotdata.set_data("bathtub_ctle", safe_log10(bathtub_ctle)) - # - DFE - bathtub_dfe = list(cumsum(jitter_ext_dfe[-1 : -(half_len + 1) : -1])) - bathtub_dfe.reverse() - bathtub_dfe = array(bathtub_dfe + list(cumsum(jitter_ext_dfe[: half_len + 1]))) - bathtub_dfe = where( - bathtub_dfe < MIN_BATHTUB_VAL, 0.1 * MIN_BATHTUB_VAL * ones(len(bathtub_dfe)), bathtub_dfe - ) # To avoid Chaco log scale plot wierdness. - self.plotdata.set_data("bathtub_dfe", safe_log10(bathtub_dfe)) + self.plotdata.set_data("bathtub_dfe", safe_log10(bathtub_dfe)) # Eyes width = 2 * samps_per_ui diff --git a/src/pybert/pybert.py b/src/pybert/pybert.py index 9e9ba63..719f675 100755 --- a/src/pybert/pybert.py +++ b/src/pybert/pybert.py @@ -74,60 +74,12 @@ from pyibisami.ibis.file import IBISModel gDebugStatus = False -gMaxCTLEPeak = 20.0 # max. allowed CTLE peaking (dB) (when optimizing, only) -gMaxCTLEFreq = 20.0 # max. allowed CTLE peak frequency (GHz) (when optimizing, only) - -# Default model parameters - Modify these to customize the default simulation. -# - Simulation Control -gBitRate = 10 # (Gbps) -gNbits = 8000 # number of bits to run -gPatLen = 127 # repeating bit pattern length -gNspb = 32 # samples per bit -gNumAve = 1 # Number of bit error samples to average, when sweeping. -# - Channel Control -# - parameters for Howard Johnson's "Metallic Transmission Model" -# - (See "High Speed Signal Propagation", Sec. 3.1.) -# - ToDo: These are the values for 24 guage twisted copper pair; need to add other options. -gRdc = 0.1876 # Ohms/m -gw0 = 10.0e6 # 10 MHz is recommended in Ch. 8 of his second book, in which UTP is described in detail. -gR0 = 1.452 # skin-effect resistance (Ohms/m)log -gTheta0 = 0.02 # loss tangent -gZ0 = 100.0 # characteristic impedance in LC region (Ohms) -gv0 = 0.67 # relative propagation velocity (c) -gl_ch = 1.0 # cable length (m) -gRn = ( - 0.001 # standard deviation of Gaussian random noise (V) (Applied at end of channel, so as to appear white to Rx.) -) -# - Tx -gVod = 1.0 # output drive strength (Vp) -gRs = 100 # differential source impedance (Ohms) -gCout = 0.50 # parasitic output capacitance (pF) (Assumed to exist at both 'P' and 'N' nodes.) -gPnMag = 0.001 # magnitude of periodic noise (V) -gPnFreq = 0.437 # frequency of periodic noise (MHz) -# - Rx -gRin = 100 # differential input resistance -gCin = 0.50 # parasitic input capacitance (pF) (Assumed to exist at both 'P' and 'N' nodes.) -gCac = 1.0 # a.c. coupling capacitance (uF) (Assumed to exist at both 'P' and 'N' nodes.) -gBW = 12.0 # Rx signal path bandwidth, assuming no CTLE action. (GHz) -gUseDfe = True # Include DFE when running simulation. -gDfeIdeal = True # DFE ideal summing node selector -gPeakFreq = 5.0 # CTLE peaking frequency (GHz) -gPeakMag = 1.7 # CTLE peaking magnitude (dB) -gCTLEOffset = 0.0 # CTLE d.c. offset (dB) -# - DFE -gDecisionScaler = 0.5 -gNtaps = 5 -gGain = 0.5 -gNave = 100 -gDfeBW = 12.0 # DFE summing node bandwidth (GHz) -# - CDR -gDeltaT = 0.1 # (ps) -gAlpha = 0.01 -gNLockAve = 500 # number of UI used to average CDR locked status. -gRelLockTol = 0.1 # relative lock tolerance of CDR. -gLockSustain = 500 -# - Analysis -gThresh = 6 # threshold for identifying periodic jitter spectral elements (sigma) +gUseDfe = True # Include DFE when running simulation. +gMaxCTLEPeak = 20.0 # max. allowed CTLE peaking (dB) (when optimizing, only) +gPeakFreq = 5.0 # CTLE peaking frequency (GHz) +gPeakMag = 1.7 # CTLE peaking magnitude (dB) +gCTLEOffset = 0.0 # CTLE d.c. offset (dB) +gNtaps = 5 class PyBERT(HasTraits): @@ -141,8 +93,9 @@ class PyBERT(HasTraits): # Independent variables # - Simulation Control - bit_rate = Range(low=0.1, high=120.0, value=gBitRate) #: (Gbps) - nbits = Range(low=1000, high=10000000, value=gNbits) #: Number of bits to simulate. + bit_rate = Range(low=0.1, high=120.0, value=10.0) #: (Gbps) + nbits = Range(low=1000, high=10000000, value=15000) #: Number of bits to simulate. + eye_bits = Int(10160) #: Number of bits used to form eye. pattern = Map( { "PRBS-7": [7, 6], @@ -152,14 +105,14 @@ class PyBERT(HasTraits): default_value="PRBS-7", ) seed = Int(1) # LFSR seed. 0 means regenerate bits, using a new random seed, each run. - nspb = Range(low=2, high=256, value=gNspb) #: Signal vector samples per bit. - eye_bits = Int(gNbits // 5) #: # of bits used to form eye. (Default = last 20%) - mod_type = List([0]) #: 0 = NRZ; 1 = Duo-binary; 2 = PAM-4 - num_sweeps = Int(1) #: Number of sweeps to run. - sweep_num = Int(1) - sweep_aves = Int(gNumAve) - do_sweep = Bool(False) #: Run sweeps? (Default = False) - debug = Bool(False) #: Send log messages to terminal, as well as console, when True. (Default = False) + nspb = Range(low=2, high=256, value=32) #: Signal vector samples per bit. + mod_type = List([0]) #: 0 = NRZ; 1 = Duo-binary; 2 = PAM-4 + num_sweeps = Int(1) #: Number of sweeps to run. + sweep_num = Int(1) + sweep_aves = Int(1) + do_sweep = Bool(False) #: Run sweeps? (Default = False) + debug = Bool(False) #: Send log messages to terminal, as well as console, when True. (Default = False) + thresh = Float(3.0) #: Spectral threshold for identifying periodic components (sigma). (Default = 3.0) # - Channel Control ch_file = File( @@ -168,13 +121,13 @@ class PyBERT(HasTraits): use_ch_file = Bool(False) #: Import channel description from file? (Default = False) f_step = Float(10) #: Frequency step to use when constructing H(f). (Default = 10 MHz) impulse_length = Float(0.0) #: Impulse response length. (Determined automatically, when 0.) - Rdc = Float(gRdc) #: Channel d.c. resistance (Ohms/m). - w0 = Float(gw0) #: Channel transition frequency (rads./s). - R0 = Float(gR0) #: Channel skin effect resistance (Ohms/m). - Theta0 = Float(gTheta0) #: Channel loss tangent (unitless). - Z0 = Float(gZ0) #: Channel characteristic impedance, in LC region (Ohms). - v0 = Float(gv0) #: Channel relative propagation velocity (c). - l_ch = Float(gl_ch) #: Channel length (m). + Rdc = Float(0.1876) #: Channel d.c. resistance (Ohms/m). + w0 = Float(10e6) #: Channel transition frequency (rads./s). + R0 = Float(1.452) #: Channel skin effect resistance (Ohms/m). + Theta0 = Float(0.02) #: Channel loss tangent (unitless). + Z0 = Float(100) #: Channel characteristic impedance, in LC region (Ohms). + v0 = Float(0.67) #: Channel relative propagation velocity (c). + l_ch = Float(0.5) #: Channel length (m). # - EQ Tune tx_tap_tuners = List( @@ -185,7 +138,7 @@ class PyBERT(HasTraits): TxTapTuner(name="Post-tap3", enabled=False, min_val=-0.2, max_val=0.2, value=0.0), ] ) #: EQ optimizer list of TxTapTuner objects. - rx_bw_tune = Float(gBW) #: EQ optimizer CTLE bandwidth (GHz). + rx_bw_tune = Float(12.0) #: EQ optimizer CTLE bandwidth (GHz). peak_freq_tune = Float(gPeakFreq) #: EQ optimizer CTLE peaking freq. (GHz). peak_mag_tune = Float(gPeakMag) #: EQ optimizer CTLE peaking mag. (dB). max_mag_tune = Float(20) #: EQ optimizer CTLE peaking mag. (dB). @@ -199,12 +152,12 @@ class PyBERT(HasTraits): coopt_thread = Instance(CoOptThread) #: EQ co-optimization thread. # - Tx - vod = Float(gVod) #: Tx differential output voltage (V) - rs = Float(gRs) #: Tx source impedance (Ohms) - cout = Range(low=0.001, high=1000, value=gCout) #: Tx parasitic output capacitance (pF) - pn_mag = Float(gPnMag) #: Periodic noise magnitude (V). - pn_freq = Float(gPnFreq) #: Periodic noise frequency (MHz). - rn = Float(gRn) #: Standard deviation of Gaussian random noise (V). + vod = Float(1.0) #: Tx differential output voltage (V) + rs = Float(100) #: Tx source impedance (Ohms) + cout = Range(low=0.001, high=1000, value=0.5) #: Tx parasitic output capacitance (pF) + pn_mag = Float(0.1) #: Periodic noise magnitude (V). + pn_freq = Float(11) #: Periodic noise frequency (MHz). + rn = Float(0.1) #: Standard deviation of Gaussian random noise (V). tx_taps = List( [ TxTapTuner(name="Pre-tap", enabled=True, min_val=-0.2, max_val=0.2, value=-0.066), @@ -234,12 +187,12 @@ class PyBERT(HasTraits): tx_use_ibis = Bool(False) #: (Bool) # - Rx - rin = Float(gRin) #: Rx input impedance (Ohm) - cin = Float(gCin) #: Rx parasitic input capacitance (pF) - cac = Float(gCac) #: Rx a.c. coupling capacitance (uF) + rin = Float(100) #: Rx input impedance (Ohm) + cin = Float(0.5) #: Rx parasitic input capacitance (pF) + cac = Float(1.0) #: Rx a.c. coupling capacitance (uF) use_ctle_file = Bool(False) #: For importing CTLE impulse/step response directly. ctle_file = File("", entries=5, filter=["*.csv"]) #: CTLE response file (when use_ctle_file = True). - rx_bw = Float(gBW) #: CTLE bandwidth (GHz). + rx_bw = Float(12.0) #: CTLE bandwidth (GHz). peak_freq = Float(gPeakFreq) #: CTLE peaking frequency (GHz) peak_mag = Float(gPeakMag) #: CTLE peaking magnitude (dB) ctle_offset = Float(gCTLEOffset) #: CTLE d.c. offset (dB) @@ -260,23 +213,20 @@ class PyBERT(HasTraits): # - DFE use_dfe = Bool(gUseDfe) #: True = use a DFE (Bool). - sum_ideal = Bool(gDfeIdeal) #: True = use an ideal (i.e. - infinite bandwidth) summing node (Bool). - decision_scaler = Float(gDecisionScaler) #: DFE slicer output voltage (V). - gain = Float(gGain) #: DFE error gain (unitless). - n_ave = Float(gNave) #: DFE # of averages to take, before making tap corrections. + sum_ideal = Bool(True) #: True = use an ideal (i.e. - infinite bandwidth) summing node (Bool). + decision_scaler = Float(0.5) #: DFE slicer output voltage (V). + gain = Float(0.5) #: DFE error gain (unitless). + n_ave = Float(100) #: DFE # of averages to take, before making tap corrections. n_taps = Int(gNtaps) #: DFE # of taps. _old_n_taps = n_taps - sum_bw = Float(gDfeBW) #: DFE summing node bandwidth (Used when sum_ideal=False.) (GHz). + sum_bw = Float(12.0) #: DFE summing node bandwidth (Used when sum_ideal=False.) (GHz). # - CDR - delta_t = Float(gDeltaT) #: CDR proportional branch magnitude (ps). - alpha = Float(gAlpha) #: CDR integral branch magnitude (unitless). - n_lock_ave = Int(gNLockAve) #: CDR # of averages to take in determining lock. - rel_lock_tol = Float(gRelLockTol) #: CDR relative tolerance to use in determining lock. - lock_sustain = Int(gLockSustain) #: CDR hysteresis to use in determining lock. - - # - Analysis - thresh = Int(gThresh) #: Threshold for identifying periodic jitter components (sigma). + delta_t = Float(0.1) #: CDR proportional branch magnitude (ps). + alpha = Float(0.01) #: CDR integral branch magnitude (unitless). + n_lock_ave = Int(500) #: CDR # of averages to take in determining lock. + rel_lock_tol = Float(0.1) #: CDR relative tolerance to use in determining lock. + lock_sustain = Int(500) #: CDR hysteresis to use in determining lock. # Misc. cfg_file = File("", entries=5, filter=["*.pybert_cfg"]) #: PyBERT configuration data storage file (File). @@ -974,12 +924,6 @@ def _get_sweep_info(self): for item in sweep_results: info_str += ' \n' info_str += str(item) - # info_str += " %+06.3f%+06.3f%d%d\n" % ( - # item[0], - # item[1], - # item[2], - # item[3], - # ) info_str += " \n" info_str += " \n" @@ -988,24 +932,26 @@ def _get_sweep_info(self): @cached_property def _get_status_str(self): - status_str = "%-20s | Perf. (Msmpls./min.): %4.1f" % ( + status_str = "%-20s | Perf. (Msmpls./min.): %4.1f" % ( self.status, self.total_perf * 60.0e-6, ) - dly_str = f" | ChnlDly (ns): {self.chnl_dly * 1000000000.0:5.3f}" - err_str = f" | BitErrs: {int(self.bit_errs)}" - pwr_str = f" | TxPwr (W): {self.rel_power:4.2f}" + dly_str = f" | ChnlDly (ns): {self.chnl_dly * 1000000000.0:5.3f}" + err_str = f" | BitErrs: {int(self.bit_errs)}" + pwr_str = f" | TxPwr (mW): {self.rel_power * 1e3:3.0f}" status_str += dly_str + err_str + pwr_str try: - jit_str = " | Jitter (ps): ISI=%6.3f DCD=%6.3f Pj=%6.3f Rj=%6.3f" % ( + jit_str = " | Jitter (ps): ISI=%6.1f DCD=%6.1f Pj=%6.1f (%6.1f) Rj=%6.1f (%6.1f)" % ( self.isi_dfe * 1.0e12, self.dcd_dfe * 1.0e12, self.pj_dfe * 1.0e12, + self.pjDD_dfe * 1.0e12, self.rj_dfe * 1.0e12, + self.rjDD_dfe * 1.0e12, ) except: - jit_str = " | (Jitter not available.)" + jit_str = " | (Jitter not available.)" status_str += jit_str diff --git a/src/pybert/utility.py b/src/pybert/utility.py index 61400ec..1f59134 100644 --- a/src/pybert/utility.py +++ b/src/pybert/utility.py @@ -10,59 +10,57 @@ import os.path import pkgutil import re -from cmath import phase, rect -from functools import reduce - import numpy as np -import skrf as rf -from numpy import ( - array, - concatenate, - convolve, - cumsum, - diff, - histogram, - insert, - log10, - mean, - ones, - pi, - power, - real, - reshape, - resize, - sign, - sort, - sqrt, - where, - zeros, +import skrf as rf +from cmath import phase, rect +from functools import reduce +from numpy import ( + append, argmax, array, concatenate, convolve, cumsum, diff, + histogram, insert, log, log10, maximum, mean, ones, + pi, power, real, reshape, resize, sign, + sort, sqrt, where, zeros, ) -from numpy.fft import fft, ifft -from scipy.linalg import inv -from scipy.signal import freqs, invres -from scipy.stats import norm - -debug = False +from numpy.fft import fft, ifft, fftshift +from scipy.interpolate import UnivariateSpline, interp1d +from scipy.linalg import inv +from scipy.optimize import curve_fit +from scipy.signal import freqs, invres +from scipy.stats import norm + +debug = False gDebugOptimize = False -gMaxCTLEPeak = 20 # max. allowed CTLE peaking (dB) (when optimizing, only) +gMaxCTLEPeak = 20 # max. allowed CTLE peaking (dB) (when optimizing, only) def moving_average(a, n=3): """Calculates a sliding average over the input vector. + Uses a weighted averaging kernel, to preserve singularity + of peak location in input data. + Args: a([float]): Input vector to be averaged. - n(int): Width of averaging window, in vector samples. (Optional; - default = 3.) + n(int): Width of averaging window, in vector samples. + Odd numbers work best. + (Optional; default = 3.) Returns: [float]: the moving average of the input vector, leaving the input vector unchanged. - """ - ret = cumsum(a, dtype=float) - ret[n:] = ret[n:] - ret[:-n] - return insert(ret[n - 1 :], 0, ret[n - 1] * ones(n - 1)) / n + Notes: + 1. The odd code is intended to "protect" the first/last elements + of the input vector from the averaging process. + In PyBERT those elements "collect" the missed edges when + assembling the TIE. + Because of this non-standard use, those bins shouldn't be + included in averaging. + """ + rect = ones((n+1)//2) + krnl = convolve(rect, rect) + krnl = krnl / krnl.sum() + res = convolve(a[1:-1], krnl, mode='same') + return array([a[0]] + list(res) + [a[-1]]) def find_crossing_times( @@ -236,59 +234,66 @@ def find_crossings( return sort(concatenate(xings)) -def calc_jitter(ui, nui, pattern_len, ideal_xings, actual_xings, rel_thresh=6, num_bins=99, zero_mean=True): - """Calculate the jitter in a set of actual zero crossings, given the ideal - crossings and unit interval. +def gaus_pdf(x, mu, sigma): + """ + Gaussian probability density function. + """ + sqrt_2pi = np.sqrt(2 * np.pi) + return np.exp(-0.5 * ((x - mu) / sigma) ** 2) / (sigma * sqrt_2pi) - Inputs: - - ui : The nominal unit interval. - - nui : The number of unit intervals spanned by the input signal. - - pattern_len : The number of unit intervals, before input symbol stream repeats. - - ideal_xings : The ideal zero crossing locations of the edges. - - actual_xings : The actual zero crossing locations of the edges. - - rel_thresh : (optional) The threshold for determining periodic jitter spectral components (sigma). - - num_bins : (optional) The number of bins to use, when forming histograms. - - zero_mean : (optional) Force the mean jitter to zero, when True. +def calc_jitter( + ui, nui, pattern_len, ideal_xings, actual_xings, + rel_thresh=3.0, num_bins=100, zero_mean=True, dbg_obj=None, smooth_width=5 +): + """ + Calculate the jitter in a set of actual zero crossings, + given the ideal crossings and unit interval. - Outputs: + Args: + ui(float): The nominal unit interval. + nui(int): The number of unit intervals spanned by the input signal. + pattern_len(int): The number of unit intervals, before input symbol stream repeats. + ideal_xings([float]): The ideal zero crossing locations of the edges. + actual_xings([float]): The actual zero crossing locations of the edges. - - jitter : The total jitter. - - t_jitter : The times (taken from 'ideal_xings') corresponding to the returned jitter values. - - isi : The peak to peak jitter due to intersymbol interference. - - dcd : The peak to peak jitter due to duty cycle distortion. - - pj : The peak to peak jitter due to uncorrelated periodic sources. - - rj : The standard deviation of the jitter due to uncorrelated unbounded random sources. - - tie_ind : The data independent jitter. - - thresh : Threshold for determining periodic components. - - jitter_spectrum : The spectral magnitude of the total jitter. - - tie_ind_spectrum : The spectral magnitude of the data independent jitter. - - spectrum_freqs : The frequencies corresponding to the spectrum components. - - hist : The histogram of the actual jitter. - - hist_synth : The histogram of the extrapolated jitter. - - bin_centers : The bin center values for both histograms. + KeywordArgs: + rel_thresh(float): The threshold for determining periodic jitter spectral components (sigma). + (Default: 3.0) + num_bins(int): The number of bins to use, when forming histograms. + (Default: 99) + zero_mean(bool): Force the mean jitter to zero, when True. + (Default: True) + dbg_obj(object): Object for stashing debugging info. + (Default: None) + smooth_width(int): Width of smoothing window to use when calculating moving averages. + (Default: 5) + + Returns: + ( [real]: The total jitter. + , [real]: The times (taken from 'ideal_xings') corresponding to the returned jitter values. + , real: The peak to peak jitter due to intersymbol interference (ISI). + , real: The peak to peak jitter due to duty cycle distortion (DCD). + , real: The peak to peak jitter due to uncorrelated periodic sources (Pj). + , real: The standard deviation of the jitter due to uncorrelated unbounded random sources (Rj). + , [real]: The data independent jitter. + , [real]: Threshold for determining periodic components. + , [real]: The spectral magnitude of the total jitter. + , [real]: The spectral magnitude of the data independent jitter. + , [real]: The frequencies corresponding to the spectrum components. + , [real]: The smoothed histogram of the total jitter. + , [real]: The smoothed histogram of the data-independent jitter. + , [real]: The bin center values for both histograms. + ) + + Raises: + ValueError: If input checking fails, or curve fitting goes awry. + AssertionError: If less than one full pattern given as input, or an odd number of crossings per pattern was detected. Notes: 1. The actual crossings should arrive pre-aligned to the ideal crossings. And both should start near zero time. """ - - def my_hist(x): - """Calculates the probability mass function (PMF) of the input vector, - enforcing an output range of [-UI/2, +UI/2], sweeping everything in. - - [-UI, -UI/2] into the first bin, and everything in [UI/2, UI] - into the last bin. - """ - hist, bin_edges = histogram( - x, [-ui] + [-ui / 2.0 + i * ui / (num_bins - 2) for i in range(num_bins - 1)] + [ui] - ) - bin_centers = ( - [-ui / 2.0] + [mean([bin_edges[i + 1], bin_edges[i + 2]]) for i in range(len(bin_edges) - 3)] + [ui / 2.0] - ) - - return (array(list(map(float, hist))) / sum(hist), bin_centers) - # Check inputs. if not ideal_xings.all(): raise ValueError("calc_jitter(): zero length ideal crossings vector received!") @@ -323,7 +328,7 @@ def my_hist(x): if i == len(actual_xings): # We've exhausted the list of actual crossings; we're done. break if actual_xings[i] > max_t: # Means the xing we're looking for didn't occur, in the actual signal. - jitter.append(3.0 * ui / 4.0) # Pad the jitter w/ alternating +/- 3UI/4. + jitter.append( 3.0 * ui / 4.0) # Pad the jitter w/ alternating +/- 3UI/4. jitter.append(-3.0 * ui / 4.0) # (Will get pulled into [-UI/2, UI/2], later. skip_next_ideal_xing = True # If we missed one, we missed two. else: # Noise may produce several crossings. @@ -346,89 +351,151 @@ def my_hist(x): # Do the jitter decomposition. # - Separate the rising and falling edges, shaped appropriately for averaging over the pattern period. - tie_risings = jitter.take(list(range(0, len(jitter), 2))) + tie_risings = jitter.take(list(range(0, len(jitter), 2))) tie_fallings = jitter.take(list(range(1, len(jitter), 2))) tie_risings.resize(num_patterns * xings_per_pattern // 2, refcheck=False) tie_fallings.resize(num_patterns * xings_per_pattern // 2, refcheck=False) - tie_risings = reshape(tie_risings, (num_patterns, xings_per_pattern // 2)) + tie_risings = reshape(tie_risings, (num_patterns, xings_per_pattern // 2)) tie_fallings = reshape(tie_fallings, (num_patterns, xings_per_pattern // 2)) # - Use averaging to remove the uncorrelated components, before calculating data dependent components. - try: - tie_risings_ave = tie_risings.mean(axis=0) - tie_fallings_ave = tie_fallings.mean(axis=0) - isi = max(tie_risings_ave.ptp(), tie_fallings_ave.ptp()) - except: - print("xings_per_pattern:", xings_per_pattern) - print("len(ideal_xings):", len(ideal_xings)) - raise + tie_risings_ave = tie_risings.mean(axis=0) + tie_fallings_ave = tie_fallings.mean(axis=0) + isi = max(tie_risings_ave.ptp(), tie_fallings_ave.ptp()) isi = min(isi, ui) # Cap the ISI at the unit interval. dcd = abs(mean(tie_risings_ave) - mean(tie_fallings_ave)) # - Subtract the data dependent jitter from the original TIE track, in order to yield the data independent jitter. - tie_ave = sum(list(zip(tie_risings_ave, tie_fallings_ave)), ()) - tie_ave = resize(tie_ave, len(jitter)) + _jitter = jitter.copy() + _jitter.resize(num_patterns * xings_per_pattern) + tie_ave = resize(reshape(_jitter, (num_patterns, xings_per_pattern)).mean(axis=0), len(jitter)) tie_ind = jitter - tie_ave - - # - Use spectral analysis to help isolate the periodic components of the data independent jitter. - # -- Calculate the total jitter spectrum, for display purposes only. - # --- Make vector uniformly sampled in time, via zero padding where necessary. - # --- (It's necessary to keep track of those elements in the resultant vector, which aren't paddings; hence, 'valid_ix'.) - x, valid_ix = make_uniform(t_jitter, jitter, ui, nui) - y = fft(x) - jitter_spectrum = abs(y[: len(y) // 2]) / sqrt(len(jitter)) # Normalized, in order to make power correct. - f0 = 1.0 / (ui * nui) - spectrum_freqs = [i * f0 for i in range(len(y) // 2)] - - # -- Use the data independent jitter spectrum for our calculations. - tie_ind_uniform, valid_ix = make_uniform(t_jitter, tie_ind, ui, nui) - - # --- Normalized, in order to make power correct, since we grab Rj from the freq. domain. - # --- (I'm using the length of the vector before zero padding, because zero padding doesn't add energy.) - # --- (This has the effect of making our final Rj estimate more conservative.) - y = fft(tie_ind_uniform) / sqrt(len(tie_ind)) + if zero_mean: + tie_ind -= mean(tie_ind) + + # - Calculate the total and data-independent jitter spectrums, for display purposes only. + # -- Calculate the relevant time/frequency vectors. + osf = 1 # jitter oversampling factor + t0 = ui / osf # jitter sampling period + t = np.array([n * t0 for n in range(nui * osf)]) # jitter samples time vector + f0 = 1.0 / (ui * nui) # jitter samples fundamental frequency + f = [n * f0 for n in range(len(t) // 2)] # [0:f0:fNyquist) + f = np.array(f + [1 / (2 * t0)] + list(-1 * np.flip(np.array(f[1:])))) # [0:f0:fN) ++ [fN:-f0:0) + half_len = len(f) // 2 # for spectrum plotting convenience + + # -- Make TIE vector uniformly sampled in time, via interpolation, for use as input to `fft()`. + # spl = UnivariateSpline(t_jitter, jitter) # Way of the future, but does funny things. :( + spl = interp1d(t_jitter, jitter, bounds_error=False, fill_value="extrapolate") + tie_interp = spl(t) + y = fft(tie_interp) + jitter_spectrum = abs(y[:half_len]) + jitter_freqs = f[:half_len] + + # -- Repeat for data-independent jitter. + spl = interp1d(t_jitter, tie_ind, bounds_error=False, fill_value="extrapolate") + tie_ind_interp = spl(t) + y = fft(tie_ind_interp) y_mag = abs(y) - y_mean = moving_average(y_mag, n=len(y_mag) // 10) - y_var = moving_average((y_mag - y_mean) ** 2, n=len(y_mag) // 10) - y_sigma = sqrt(y_var) - thresh = y_mean + rel_thresh * y_sigma - y_per = where(y_mag > thresh, y, zeros(len(y))) # Periodic components are those lying above the threshold. - y_rnd = where(y_mag > thresh, zeros(len(y)), y) # Random components are those lying below. - y_rnd = abs(y_rnd) - rj = sqrt(mean((y_rnd - mean(y_rnd)) ** 2)) - tie_per = real(ifft(y_per)).take(valid_ix) * sqrt(len(tie_ind)) # Restoring shape of vector to its original, - pj = tie_per.ptp() # non-uniformly sampled state. - - # --- Save the spectrum, for display purposes. - tie_ind_spectrum = y_mag[: len(y_mag) // 2] - - # - Reassemble the jitter, excluding the Rj. - # -- Here, we see why it was necessary to keep track of the non-padded elements with 'valid_ix': - # -- It was so that we could add the average and periodic components back together, - # -- maintaining correct alignment between them. - if len(tie_per) > len(tie_ave): - tie_per = tie_per[: len(tie_ave)] - if len(tie_per) < len(tie_ave): - tie_ave = tie_ave[: len(tie_per)] - jitter_synth = tie_ave + tie_per - - # - Calculate the histogram of original, for comparison. - hist, bin_centers = my_hist(jitter) - - # - Calculate the histogram of everything, except Rj. - hist_synth, bin_centers = my_hist(jitter_synth) - - # - Extrapolate the tails by convolving w/ complete Gaussian. - rv = norm(loc=0.0, scale=rj) - rj_pdf = rv.pdf(bin_centers) - rj_pmf = rj_pdf / sum(rj_pdf) - hist_synth = convolve(hist_synth, rj_pmf) - tail_len = (len(bin_centers) - 1) // 2 - hist_synth = ( - [sum(hist_synth[: tail_len + 1])] - + list(hist_synth[tail_len + 1 : len(hist_synth) - tail_len - 1]) - + [sum(hist_synth[len(hist_synth) - tail_len - 1 :])] - ) + tie_ind_spectrum = y_mag[:half_len] + + # -- Perform spectral extraction of Pj from the data independent jitter, + # -- using a threshold based on a moving average to identify the periodic components. + win_width = 100 + y_mean = moving_average(y_mag, n=win_width) + y_var = moving_average((y_mag - y_mean) ** 2, n=win_width) + y_sigma = sqrt(y_var) + thresh = y_mean + rel_thresh * y_sigma + y_per = where(y_mag > thresh, y, zeros(len(y))) # Periodic components are those lying above the threshold. + y_rnd = where(y_mag > thresh, zeros(len(y)), y) # Random components are those lying below. + tie_per = real(ifft(y_per)) + pj = tie_per.ptp() + tie_rnd = real(ifft(y_rnd)) + rj = np.sqrt(np.mean((tie_rnd - tie_rnd.mean())**2)) + + # -- Do dual Dirac fitting of the data-independent jitter histogram, to determine Pj/Rj. + # --- Generate a smoothed version of the TIE histogram, for better peak identification. + # --- (Have to work in ps when curve fitting, or `curve_fit()` blows up.) + use_my_hist = True # False will yield misleading jitter distribution plots! + + def my_hist(x, density=False): + """ + Calculates the probability *mass* function (PMF) of the input vector + (or, the probability *density* function (PDF) if so directed), + enforcing an output range of [-UI/2, +UI/2], sweeping everything in + [-UI, -UI/2] into the first bin, and everything in [UI/2, UI] + into the last bin. + """ + bin_edges = array([-ui] + [-ui / 2.0 + i * ui / (num_bins - 2) for i in range(num_bins - 1)] + [ui]) + bin_centers = [-ui/2] + list((bin_edges[1:-2] + bin_edges[2:-1]) / 2) + [ui/2] + hist, _ = histogram(x, bin_edges) + hist = hist / hist.sum() # PMF + if density: + hist /= diff(bin_edges) + return (hist, bin_centers) + + if use_my_hist: + hist_ind, centers = my_hist(tie_ind, density=True) + hist_tot, _ = my_hist(jitter, density=True) + centers = array(centers) + else: + hist_ind, edges = histogram(tie_ind, bins=num_bins, density=True) + hist_tot, _ = histogram(jitter, bins=num_bins, density=True) + centers = (edges[:-1] + edges[1:]) / 2 + hist_ind_smooth = array(moving_average(hist_ind, n=smooth_width)) + hist_tot_smooth = array(moving_average(hist_tot, n=smooth_width)) + hist_dd = hist_tot_smooth + # Trying to avoid any residual peak at zero, which can confuse the algorithm: + center_ix = (num_bins-1)/2 # May be fractional. + peak_ixs = array(list(filter( lambda x: abs(x - center_ix) > 1 + , where(diff(sign(diff(hist_dd))) < 0)[0] + 1 ))) + neg_peak_ixs = list(filter(lambda x: x < center_ix, peak_ixs)) + if len(neg_peak_ixs): + neg_peak_loc = neg_peak_ixs[argmax(hist_dd[neg_peak_ixs])] + else: + neg_peak_loc = int(center_ix) + pos_peak_ixs = list(filter(lambda x: x > center_ix, peak_ixs)) + if len(pos_peak_ixs): + pos_peak_loc = pos_peak_ixs[argmax(hist_dd[pos_peak_ixs])] + else: + pos_peak_loc = int(center_ix) + pjDD = (centers[pos_peak_loc] - centers[neg_peak_loc]) + + # --- Stash debugging info if an object was provided. + if dbg_obj: + dbg_obj.hist_ind_smooth = hist_ind_smooth + dbg_obj.centers = centers + dbg_obj.hist_ind = hist_ind + dbg_obj.peak_ixs = peak_ixs + dbg_obj.neg_peak_ixs = neg_peak_ixs + dbg_obj.pos_peak_ixs = pos_peak_ixs + + # --- Fit the tails and average the results, to determine Rj. + pos_max = hist_dd[pos_peak_loc] + neg_max = hist_dd[neg_peak_loc] + pos_tail_ix = where(hist_dd[pos_peak_loc:] < pos_max / 2)[0] + pos_peak_loc + neg_tail_ix = where(hist_dd[:neg_peak_loc] < neg_max / 2)[0] + dd_soltn = [] + try: + popt, pcov = curve_fit(gaus_pdf, centers[pos_tail_ix]*1e12, hist_dd[pos_tail_ix]*1e-12) + mu_pos, sigma_pos = popt + mu_pos *= 1e-12 # back to (s) + sigma_pos *= 1e-12 + err_pos = np.sqrt(np.diag(pcov)) * 1e-12 + dd_soltn = [mu_pos, sigma_pos, err_pos] + except: + sigma_pos = 0 + try: + popt, pcov = curve_fit(gaus_pdf, centers[neg_tail_ix]*1e12, hist_dd[neg_tail_ix]*1e-12) + mu_neg, sigma_neg = popt + mu_neg *= 1e-12 # back to (s) + sigma_neg *= 1e-12 + err_neg = np.sqrt(np.diag(pcov)) * 1e-12 + dd_soltn += [mu_neg, sigma_neg, err_neg] + except: + sigma_neg = 0 + rjDD = (sigma_pos + sigma_neg) / 2 + if dbg_obj: + dbg_obj.dd_soltn = dd_soltn return ( jitter, @@ -437,14 +504,18 @@ def my_hist(x): dcd, pj, rj, + pjDD, + rjDD, tie_ind, - thresh[: len(thresh) // 2], + thresh[:half_len], jitter_spectrum, tie_ind_spectrum, - spectrum_freqs, - hist, - hist_synth, - bin_centers, + jitter_freqs, + # hist_tot, + hist_tot_smooth, + # hist_ind, + hist_ind_smooth, + centers, # Returning just one requires `use_my_hist` True. ) @@ -1249,3 +1320,44 @@ def getwave_step_resp(ami_model): tmp, _ = ami_model.getWave(tmp) tx_s = np.append(tx_s, tmp) return tx_s - tx_s[0] + + +def make_bathtub(centers, jit_pdf, min_val=0, rj=0, extrap=False): + """Generate the "bathtub" curve associated with a particular jitter PDF. + + Args: + centers([real]): List of uniformly spaced bin centers (s). + jit_pdf([real]): PDF of jitter. + + KeywordArgs: + min_val(real): Minimum value allowed in returned bathtub vector. + Default: 0 + rj(real): Standard deviation of Gaussian PDF characterizing random jitter. + Default: 0 + extrap(bool): Extrapolate bathtub tails, using `rj`, if True. + Default: True + + Returns: + ([real], (int,int)): A pair consisting of: + - the vector of probabilities forming the bathtub curve, and + - a pair consisting of the beginning/end indices of the extrapolated region. + """ + half_len = len(jit_pdf) // 2 + dt = centers[1] - centers[0] # Bins assumed to be uniformly spaced! + zero_locs = where(fftshift(jit_pdf) == 0)[0] + ext_first = min(zero_locs) + ext_last = max(zero_locs) + if extrap: + sqrt_2pi = sqrt(2*pi) + ix_r = ext_first + half_len - 1 + mu_r = centers[ix_r] - sqrt(2) * rj * sqrt(-log(rj * sqrt_2pi * jit_pdf[ix_r])) + ix_l = ext_last - half_len + 1 + mu_l = centers[ix_l] + sqrt(2) * rj * sqrt(-log(rj * sqrt_2pi * jit_pdf[ix_l])) + jit_pdf = append( append( gaus_pdf(centers[:ix_l], mu_l, rj) + , jit_pdf[ix_l:ix_r+1]) + , gaus_pdf(centers[ix_r+1:], mu_r, rj)) + bathtub = list(cumsum(jit_pdf[-1 : -(half_len+1) : -1])) + bathtub.reverse() + bathtub = array(bathtub + list(cumsum(jit_pdf[: half_len+1]))) * 2*dt + bathtub = where(bathtub < min_val, min_val * ones(len(bathtub)), bathtub) + return (bathtub, (ext_first,ext_last))