From 1c8f6fb41870f192eaacac3b36015023cdacedfc Mon Sep 17 00:00:00 2001 From: Basso Ricci Jacopo Date: Wed, 8 Apr 2026 10:11:20 +0200 Subject: [PATCH] =?UTF-8?q?Molto=20lavoro=20per=20negare=20il=20modello,?= =?UTF-8?q?=20ora=20si=20inizia=20con=20LaTeX=20perch=C3=A9=20altrimenti?= =?UTF-8?q?=20non=20finiamo?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 280 +- molla/compatibilita/comp1.ipynb | 46 +- molla/compatibilita/comp2.ipynb | 122 +- molla/dinamica/mollaDinamica1.ipynb | 210 +- molla/dinamica/mollaDinamica1Errore.ipynb | 2734 ++++++++++++++++++++ molla/dinamica/mollaDinamica1Lavoro.ipynb | 2734 ++++++++++++++++++++ molla/dinamica/mollaDinamica2.ipynb | 288 +-- molla/dinamica/mollaDinamica2Errore.ipynb | 2859 +++++++++++++++++++++ molla/dinamica/mollaDinamica2Lavoro.ipynb | 2859 +++++++++++++++++++++ molla/statica/mollaStatica1.ipynb | 92 +- molla/statica/mollaStatica1Errore.ipynb | 1075 ++++++++ molla/statica/mollaStatica2.ipynb | 74 +- molla/statica/mollaStatica2Errore.ipynb | 1056 ++++++++ 13 files changed, 14051 insertions(+), 378 deletions(-) create mode 100644 molla/dinamica/mollaDinamica1Errore.ipynb create mode 100644 molla/dinamica/mollaDinamica1Lavoro.ipynb create mode 100644 molla/dinamica/mollaDinamica2Errore.ipynb create mode 100644 molla/dinamica/mollaDinamica2Lavoro.ipynb create mode 100644 molla/statica/mollaStatica1Errore.ipynb create mode 100644 molla/statica/mollaStatica2Errore.ipynb diff --git a/.gitignore b/.gitignore index d7f19c8..a258c7b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,282 @@ # L'inzio di questo file è specifico per ogniuno di noi Funzioni\ matlab.txt prova* -test* \ No newline at end of file +test* + + +## Core latex/pdflatex auxiliary files: +*.aux +*.lof +*.log +*.lot +*.fls +*.out +*.toc +*.fmt +*.fot +*.cb +*.cb2 +.*.lb + +## Intermediate documents: +*.dvi +*.xdv +*-converted-to.* + +## Bibliography auxiliary files (bibtex/biblatex/biber): +*.bbl +*.bcf +*.blg +*-blx.aux +*-blx.bib +*.run.xml + +## Build tool auxiliary files: +*.fdb_latexmk +*.synctex +*.synctex(busy) +*.synctex.gz +*.synctex.gz(busy) +*.pdfsync + +## Build tool directories for auxiliary files +# latexrun +latex.out/ + +## Auxiliary and intermediate files from other packages: +# algorithms +*.alg +*.loa + +# achemso +acs-*.bib + +# amsthm +*.thm + +# beamer +*.nav +*.pre +*.snm +*.vrb + +# changes +*.soc + +# comment +*.cut + +# cprotect +*.cpt + +# elsarticle (documentclass of Elsevier journals) +*.spl + +# endnotes +*.ent + +# fixme +*.lox + +# feynmf/feynmp +*.mf +*.mp +*.t[1-9] +*.t[1-9][0-9] +*.tfm + +#(r)(e)ledmac/(r)(e)ledpar +*.end +*.?end +*.[1-9] +*.[1-9][0-9] +*.[1-9][0-9][0-9] +*.[1-9]R +*.[1-9][0-9]R +*.[1-9][0-9][0-9]R +*.eledsec[1-9] +*.eledsec[1-9]R +*.eledsec[1-9][0-9] +*.eledsec[1-9][0-9]R +*.eledsec[1-9][0-9][0-9] +*.eledsec[1-9][0-9][0-9]R + +# glossaries +*.acn +*.acr +*.glg +*.glo +*.gls +*.glsdefs +*.lzo +*.lzs + +# uncomment this for glossaries-extra (will ignore makeindex's style files!) +# *.ist + +# gnuplottex +*-gnuplottex-* + +# gregoriotex +*.gaux +*.glog +*.gtex + +# htlatex +*.4ct +*.4tc +*.idv +*.lg +*.trc +*.xref + +# hyperref +*.brf + +# knitr +*-concordance.tex +# TODO Uncomment the next line if you use knitr and want to ignore its generated tikz files +# *.tikz +*-tikzDictionary + +# listings +*.lol + +# luatexja-ruby +*.ltjruby + +# makeidx +*.idx +*.ilg +*.ind + +# minitoc +*.maf +*.mlf +*.mlt +*.mtc[0-9]* +*.slf[0-9]* +*.slt[0-9]* +*.stc[0-9]* + +# minted +_minted* +*.pyg + +# morewrites +*.mw + +# newpax +*.newpax + +# nomencl +*.nlg +*.nlo +*.nls + +# pax +*.pax + +# pdfpcnotes +*.pdfpc + +# sagetex +*.sagetex.sage +*.sagetex.py +*.sagetex.scmd + +# scrwfile +*.wrt + +# sympy +*.sout +*.sympy +sympy-plots-for-*.tex/ + +# pdfcomment +*.upa +*.upb + +# pythontex +*.pytxcode +pythontex-files-*/ + +# tcolorbox +*.listing + +# thmtools +*.loe + +# TikZ & PGF +*.dpth +*.md5 +*.auxlock + +# todonotes +*.tdo + +# vhistory +*.hst +*.ver + +# easy-todo +*.lod + +# xcolor +*.xcp + +# xmpincl +*.xmpi + +# xindy +*.xdy + +# xypic precompiled matrices and outlines +*.xyc +*.xyd + +# endfloat +*.ttt +*.fff + +# Latexian +TSWLatexianTemp* + +## Editors: +# WinEdt +*.bak +*.sav + +# Texpad +.texpadtmp + +# LyX +*.lyx~ + +# Kile +*.backup + +# gummi +.*.swp + +# KBibTeX +*~[0-9]* + +# TeXnicCenter +*.tps + +# auto folder when using emacs and auctex +./auto/* +*.el + +# expex forward references with \gathertags +*-tags.tex + +# standalone packages +*.sta + +# Makeindex log files +*.lpz + +# xwatermark package +*.xwm \ No newline at end of file diff --git a/molla/compatibilita/comp1.ipynb b/molla/compatibilita/comp1.ipynb index 659d9ad..1b86f4b 100644 --- a/molla/compatibilita/comp1.ipynb +++ b/molla/compatibilita/comp1.ipynb @@ -8,7 +8,7 @@ "## Valori statici (calibro)\n", "N = 10\n", "\n", - "A = 23.97 +- 0.16 " + "A = 23.98765 ± 0.18498" ] }, { @@ -19,7 +19,7 @@ "## Valori statici (sonar)\n", "N = 6\n", "\n", - "A = 23.46 +- 0.23\n" + "A = 23.41058 ± 0.22237" ] }, { @@ -30,12 +30,12 @@ "## Valori dinamici (sonar)\n", "N = 4\n", "\n", - "K nostro: 24.35 +- 0.25\n" + "KC= 24.3546921 ± 0.03539\n" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 1, "id": "b349ba73", "metadata": {}, "outputs": [], @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 2, "id": "a68eb302", "metadata": {}, "outputs": [ @@ -54,22 +54,22 @@ "name": "stdout", "output_type": "stream", "text": [ - "t = 1.751\n", - "p-value (two-tailed) = 10.1827 %\n" + "t = 1.951\n", + "p-value (two-tailed) = 7.1395 %\n" ] } ], "source": [ "# Valori statici (calibro)\n", "Nd = 10\n", - "Ad = 23.97\n", - "uAd = 0.16 * 3\n", + "Ad = 24.00\n", + "uAd = 0.18 * 3\n", "\n", "\n", "#Valori statici (sonar)\n", "Ns = 6\n", - "As = 23.46\n", - "uAs = 0.23 * 3\n", + "As = 23.41\n", + "uAs = 0.22 * 3\n", "\n", "#Nomi coerenti con Cannelli\n", "GdL = Nd + Ns - 2\n", @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 6, "id": "2746d086", "metadata": {}, "outputs": [ @@ -96,21 +96,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "t = -1.147\n", - "p-value (two-tailed) = 27.3612 %\n" + "t = -0.972\n", + "p-value (two-tailed) = 35.0452 %\n" ] } ], "source": [ "# Valori statici (calibro)\n", "Nd = 10\n", - "Ad = 23.97\n", - "uAd = 0.16 * 3\n", + "Ad = 24.00\n", + "uAd = 0.18 *3\n", "\n", "#Valori dinamici (sonar)\n", "Ns = 4\n", "As = 24.35\n", - "uAs = 0.25 * 3\n", + "uAs = 0.26 *3\n", "\n", "#Nomi coerenti con Cannelli\n", "GdL = Nd + Ns - 2\n", @@ -129,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 4, "id": "be0c6cc6", "metadata": {}, "outputs": [ @@ -137,21 +137,21 @@ "name": "stdout", "output_type": "stream", "text": [ - "t = -1.934\n", - "p-value (two-tailed) = 8.9234 %\n" + "t = -2.775\n", + "p-value (two-tailed) = 2.4092 %\n" ] } ], "source": [ "# Valori statici (sonar)\n", "Nd = 6\n", - "Ad = 23.46\n", - "uAd = 0.23 * 3\n", + "Ad = 23.41\n", + "uAd = 0.22 * 3\n", "\n", "#Valori dinamici (sonar)\n", "Ns = 4\n", "As = 24.35\n", - "uAs = 0.25 * 3\n", + "uAs = 0.03 * 3\n", "\n", "#Nomi coerenti con Cannelli\n", "GdL = Nd + Ns - 2\n", diff --git a/molla/compatibilita/comp2.ipynb b/molla/compatibilita/comp2.ipynb index 3ec4daf..6bb4dcf 100644 --- a/molla/compatibilita/comp2.ipynb +++ b/molla/compatibilita/comp2.ipynb @@ -2,29 +2,25 @@ "cells": [ { "cell_type": "markdown", - "id": "ba4e56bc", + "id": "3b66972b", "metadata": {}, "source": [ - "## Valori dinamici\n", - "N = 10\n", + "# Molla statica 1 Calibro\n", + "Ac = 3.20021 ± 0.00923\n", "\n", - "A = 3.21951 +- 0.00470 " - ] - }, - { - "cell_type": "markdown", - "id": "aaf30c1f", - "metadata": {}, - "source": [ - "## Valori statici\n", - "N = 6\n", + "# Molla statica 1 Sonar\n", + "Ac = 3.21962 ± 0.00633\n", "\n", - "A = 3.2002 +- 0.0092\n" + "# Molla dinamica 1 Sonar\n", + "KdC = 3.2792872 ± 0.00924\n", + "\n", + "# Molla dinamica 1 Cronometro\n", + "KdtC = 3.66092 ± 0.10078\n" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 2, "id": "b349ba73", "metadata": {}, "outputs": [], @@ -35,7 +31,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 3, "id": "a68eb302", "metadata": {}, "outputs": [ @@ -43,21 +39,103 @@ "name": "stdout", "output_type": "stream", "text": [ - "t = 5.774\n", - "p-value (two-tailed) = 0.0048 %\n" + "t = 3.807\n", + "p-value (two-tailed) = 0.1924 %\n" ] } ], "source": [ - "# Valori dimanici (sonar)\n", + "# Valori statici (sonar)\n", "Nd = 10\n", - "Ad = 3.220\n", - "uAd = 0.005\n", + "Ad = 3.220\n", + "uAd = 0.006\n", "\n", "#Valori statici (calibro)\n", "Ns = 6\n", "As = 3.200\n", - "uAs = 0.009\n", + "uAs = 0.015\n", + "\n", + "#Nomi coerenti con Cannelli\n", + "GdL = Nd + Ns - 2\n", + "\n", + "s2 = ( (Nd - 1) * uAd**2 + (Ns - 1) * uAs**2 ) / GdL\n", + "\n", + "sigma2 = ( s2 / Nd ) + ( s2 / Ns )\n", + "\n", + "t = ( Ad - As ) / np.sqrt( sigma2 )\n", + "\n", + "\n", + "p_value = 2 * (1 - student_t.cdf(abs(t), df=GdL))\n", + "print(f\"t = {t:.3f}\")\n", + "print(f\"p-value (two-tailed) = {p_value * 100:.4f} %\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "459b7f56", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = -5.278\n", + "p-value (two-tailed) = 0.0117 %\n" + ] + } + ], + "source": [ + "# Valori statici (sonar)\n", + "Nd = 10\n", + "Ad = 3.220\n", + "uAd = 0.006 * 3\n", + "\n", + "#Valori dinamici (sonar)\n", + "Ns = 6\n", + "As = 3.279\n", + "uAs = 0.009 * 3\n", + "\n", + "#Nomi coerenti con Cannelli\n", + "GdL = Nd + Ns - 2\n", + "\n", + "s2 = ( (Nd - 1) * uAd**2 + (Ns - 1) * uAs**2 ) / GdL\n", + "\n", + "sigma2 = ( s2 / Nd ) + ( s2 / Ns )\n", + "\n", + "t = ( Ad - As ) / np.sqrt( sigma2 )\n", + "\n", + "\n", + "p_value = 2 * (1 - student_t.cdf(abs(t), df=GdL))\n", + "print(f\"t = {t:.3f}\")\n", + "print(f\"p-value (two-tailed) = {p_value * 100:.4f} %\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5d82905f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "t = 0.701\n", + "p-value (two-tailed) = 49.4616 %\n" + ] + } + ], + "source": [ + "# Valori dinamici (sonar)\n", + "Nd = 10\n", + "Ad = 3.279\n", + "uAd = 0.09 *3\n", + "\n", + "#Valori statici (calibro)\n", + "Ns = 6\n", + "As = 3.200\n", + "uAs = 0.015 * 3\n", "\n", "#Nomi coerenti con Cannelli\n", "GdL = Nd + Ns - 2\n", diff --git a/molla/dinamica/mollaDinamica1.ipynb b/molla/dinamica/mollaDinamica1.ipynb index 0028e56..a48fd55 100644 --- a/molla/dinamica/mollaDinamica1.ipynb +++ b/molla/dinamica/mollaDinamica1.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 56, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 57, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 58, "id": "5494409f", "metadata": {}, "outputs": [ @@ -278,7 +278,7 @@ "3 243.1705 0.057276 11.4200 0.113137 NaN NaN " ] }, - "execution_count": 4, + "execution_count": 58, "metadata": {}, "output_type": "execute_result" } @@ -308,7 +308,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 59, "id": "976d5531", "metadata": {}, "outputs": [ @@ -362,7 +362,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 60, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -389,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 61, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 62, "id": "5be377eb", "metadata": {}, "outputs": [], @@ -465,7 +465,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 63, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -478,8 +478,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 1.044e+04\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): 5.50e-08\n", - "Time: 21:57:04 Log-Likelihood: -14.807\n", + "Date: lun, 06 apr 2026 Prob (F-statistic): 5.50e-08\n", + "Time: 10:22:59 Log-Likelihood: -14.807\n", "No. Observations: 6 AIC: 33.61\n", "Df Residuals: 4 BIC: 33.20\n", "Df Model: 1 \n", @@ -535,7 +535,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 64, "id": "8d795186", "metadata": {}, "outputs": [ @@ -601,7 +601,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 65, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -659,7 +659,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 66, "id": "6a910226", "metadata": {}, "outputs": [ @@ -735,7 +735,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 67, "id": "b49ec5a3", "metadata": {}, "outputs": [ @@ -804,7 +804,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 68, "id": "538ddb98", "metadata": {}, "outputs": [ @@ -863,7 +863,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 69, "id": "c7f54cf3", "metadata": {}, "outputs": [ @@ -946,7 +946,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 70, "id": "fc824066", "metadata": {}, "outputs": [ @@ -1020,7 +1020,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 71, "id": "1203e1a0", "metadata": {}, "outputs": [ @@ -1078,7 +1078,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 72, "id": "aaa95426", "metadata": {}, "outputs": [ @@ -1127,7 +1127,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 73, "id": "a9f2a9fc", "metadata": {}, "outputs": [], @@ -1179,7 +1179,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 74, "id": "c95874fb", "metadata": {}, "outputs": [ @@ -1246,7 +1246,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 75, "id": "95dde99f", "metadata": {}, "outputs": [ @@ -1268,7 +1268,7 @@ } ], "source": [ - "Meq = df.m + ( m_mol / 3 )\n", + "Meq = df.m # ( m_mol / 3 )\n", "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", "\n", "T2 = ( 2 * np.pi / df.w )**2\n", @@ -1290,7 +1290,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 76, "id": "8c9f5b44", "metadata": {}, "outputs": [ @@ -1298,15 +1298,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 23.081695\n", - "1 23.283699\n", - "2 23.402492\n", - "3 23.508497\n", + "0 22.038061\n", + "1 22.388529\n", + "2 22.618463\n", + "3 22.812293\n", "dtype: float64\n", - "0 0.005798\n", - "1 0.006535\n", - "2 0.002247\n", - "3 0.000662\n", + "0 0.005543\n", + "1 0.006287\n", + "2 0.002179\n", + "3 0.000658\n", "dtype: float64\n" ] } @@ -1327,7 +1327,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 77, "id": "0d899f17", "metadata": {}, "outputs": [ @@ -1335,8 +1335,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "K-medio: 23.49313065421719\n", - "sigmaC: 0.0006281179024013275\n" + "K-medio: 22.78251103059837\n", + "sigmaC: 0.000622923916689791\n" ] } ], @@ -1376,7 +1376,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 78, "id": "4b4c2682", "metadata": {}, "outputs": [], @@ -1403,7 +1403,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 79, "id": "90d191d5", "metadata": {}, "outputs": [ @@ -1416,8 +1416,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 4.713e+05\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): 2.12e-06\n", - "Time: 21:57:06 Log-Likelihood: 32.343\n", + "Date: lun, 06 apr 2026 Prob (F-statistic): 2.12e-06\n", + "Time: 10:23:01 Log-Likelihood: 32.343\n", "No. Observations: 4 AIC: -60.69\n", "Df Residuals: 2 BIC: -61.91\n", "Df Model: 1 \n", @@ -1425,13 +1425,13 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.0101 0.000 29.329 0.001 0.009 0.012\n", + "const 0.0184 0.000 55.553 0.000 0.017 0.020\n", "x 0.0016 2.36e-06 686.488 0.000 0.002 0.002\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 2.752\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.628\n", "Skew: -0.880 Prob(JB): 0.730\n", - "Kurtosis: 2.180 Cond. No. 948.\n", + "Kurtosis: 2.180 Cond. No. 883.\n", "==============================================================================\n", "\n", "Notes:\n", @@ -1439,10 +1439,10 @@ "\n", "RISULTATI REGRESSIONE:\n", "Adols = 0.00162 ± 0.00000\n", - "Bdols = 0.01007 ± 0.00034\n", + "Bdols = 0.01841 ± 0.00033\n", "R² = 1.00000\n", "Kdols = 24.35158 ± 0.03547\n", - "KBdols = 3.92000 ± 0.13366\n" + "KBdols = 2.14448 ± 0.03860\n" ] }, { @@ -1485,13 +1485,13 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 80, "id": "a0ba5c8d", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1547,7 +1547,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 81, "id": "3c7c05e6", "metadata": {}, "outputs": [ @@ -1603,7 +1603,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 82, "id": "698e3c48", "metadata": {}, "outputs": [ @@ -1613,11 +1613,11 @@ "text": [ "Ax + B : \n", "AdC = 0.00162 ± 0.00000\n", - "BdC = 0.01007 ± 0.00011\n", + "BdC = 0.01841 ± 0.00011\n", "cov_ABdC = -0.000000\n", "P(0,chi²)= 0.96181\n", "KdC = 24.34964 ± 0.00989\n", - "KBdC = 3.91877 ± 0.04363\n" + "KBdC = 2.14403 ± 0.01267\n" ] } ], @@ -1690,13 +1690,13 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 83, "id": "a0ab8534", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1759,7 +1759,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 84, "id": "12bb0479", "metadata": {}, "outputs": [ @@ -1816,7 +1816,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 85, "id": "385db415", "metadata": {}, "outputs": [ @@ -1825,13 +1825,13 @@ "output_type": "stream", "text": [ "AdY = 0.0016213 ± 0.0000007\n", - "BdY = 0.0100742 ± 0.0001122\n", - "cov_ABdY = -7.370190718014568e-11\n", + "BdY = 0.0184132 ± 0.0001088\n", + "cov_ABdY = -7.147083208880052e-11\n", "chi² = 6.53021\n", "chi² rid = 3.26511\n", "P(0, chi²)= 0.96181\n", "KdY = 24.34964 ± 0.00989\n", - "KBdY = 3.91877 ± 0.04363\n" + "KBdY = 2.14403 ± 0.01267\n" ] } ], @@ -1909,13 +1909,13 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 86, "id": "698bc57c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1986,7 +1986,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 87, "id": "fc32f9e6", "metadata": {}, "outputs": [ @@ -1995,28 +1995,28 @@ "output_type": "stream", "text": [ "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata K = 23.49313 ± 0.00063\n", + "Media pesata K = 22.78251 ± 0.00062\n", "\n", "RISULTATI REGRESSIONE OLS:\n", "Adols = 0.00162 ± 0.00000\n", - "Bdols = 0.01007 ± 0.00034\n", + "Bdols = 0.01841 ± 0.00033\n", "P(0,chi²)= 0.99987\n", "Kdols = 24.35158 ± 0.03547\n", - "KBdols = 3.92000 ± 0.13366\n", + "KBdols = 2.14448 ± 0.03860\n", "\n", "RISULTATI REGRESSIONE Carpi:\n", "AdC = 0.00162 ± 0.00000\n", - "BdC = 0.01007 ± 0.00011\n", + "BdC = 0.01841 ± 0.00011\n", "P(0,chi²)= 0.96181\n", "KdC = 24.34964 ± 0.00989\n", - "KBdC = 3.91877 ± 0.04363\n", + "KBdC = 2.14403 ± 0.01267\n", "\n", "RISULTATI REGRESSIONE York:\n", "Ady = 0.00162 ± 0.00000\n", - "Bdy = 0.01007 ± 0.00011\n", + "Bdy = 0.01841 ± 0.00011\n", "P(0,chi²)= 0.96181\n", "KdY = 24.34964 ± 0.00989\n", - "KBdY = 3.91877 ± 0.04363\n" + "KBdY = 2.14403 ± 0.01267\n" ] } ], @@ -2056,7 +2056,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 88, "id": "f4897de3", "metadata": {}, "outputs": [ @@ -2067,8 +2067,8 @@ "res_T = 0.001000\n", "res_T2 = 0.001080\n", "res_b = 0.004082\n", - "res_uAd = 0.000009\n", - "uKd_strum= 0.132923\n" + "res_uAd = 0.000010\n", + "uKd_strum= 0.131094\n" ] } ], @@ -2092,7 +2092,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 89, "id": "37d88464", "metadata": {}, "outputs": [], @@ -2141,7 +2141,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 90, "id": "9075e52d", "metadata": {}, "outputs": [ @@ -2150,24 +2150,24 @@ "output_type": "stream", "text": [ "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata Kd = 23.49313 ± 0.13292\n", + "Media pesata Kd = 22.78251 ± 0.13110\n", "\n", "RISULTATI OLS:\n", "Adols = 0.00162 ± 0.00001\n", - "Bdols = 0.01007 ± 0.00034\n", - "Kdols = 24.35158 ± 0.13757\n", + "Bdols = 0.01841 ± 0.00033\n", + "Kdols = 24.35158 ± 0.13581\n", "Chi² = 0.01897 | rid = 0.00949 | P = 0.00944\n", "\n", "RISULTATI Carpi:\n", "AdC = 0.00162 ± 0.00001\n", - "BdC = 0.01007 ± 0.00011\n", - "KdC = 24.34964 ± 0.13329\n", + "BdC = 0.01841 ± 0.00011\n", + "KdC = 24.34964 ± 0.13147\n", "Chi² = 0.02061 | rid = 0.01030 | P = 0.01025\n", "\n", "RISULTATI York:\n", "AdY = 0.00162 ± 0.00001\n", - "BdY = 0.01007 ± 0.00011\n", - "KdY = 24.34964 ± 0.13329\n", + "BdY = 0.01841 ± 0.00011\n", + "KdY = 24.34964 ± 0.13147\n", "Chi² = 0.02061 | rid = 0.01030 | P = 0.01025\n" ] } @@ -2205,7 +2205,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 91, "id": "0f407f81", "metadata": {}, "outputs": [ @@ -2244,7 +2244,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 92, "id": "99bc83a7", "metadata": {}, "outputs": [ @@ -2281,7 +2281,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 93, "id": "ae55d12a", "metadata": {}, "outputs": [ @@ -2297,9 +2297,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_299408/2995330097.py:10: RuntimeWarning: invalid value encountered in scalar divide\n", + "/tmp/ipykernel_386440/2995330097.py:10: RuntimeWarning: invalid value encountered in scalar divide\n", " media = num / den\n", - "/tmp/ipykernel_299408/2995330097.py:11: RuntimeWarning: divide by zero encountered in scalar divide\n", + "/tmp/ipykernel_386440/2995330097.py:11: RuntimeWarning: divide by zero encountered in scalar divide\n", " sigma = np.sqrt(1.0 / den)\n" ] } @@ -2322,7 +2322,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 94, "id": "75e94b0a", "metadata": {}, "outputs": [], @@ -2346,7 +2346,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 95, "id": "896388e2", "metadata": {}, "outputs": [ @@ -2359,8 +2359,8 @@ "Dep. Variable: y R-squared: nan\n", "Model: OLS Adj. R-squared: nan\n", "Method: Least Squares F-statistic: nan\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): nan\n", - "Time: 21:57:07 Log-Likelihood: nan\n", + "Date: lun, 06 apr 2026 Prob (F-statistic): nan\n", + "Time: 10:23:04 Log-Likelihood: nan\n", "No. Observations: 4 AIC: nan\n", "Df Residuals: 2 BIC: nan\n", "Df Model: 1 \n", @@ -2374,7 +2374,7 @@ "Omnibus: nan Durbin-Watson: nan\n", "Prob(Omnibus): nan Jarque-Bera (JB): nan\n", "Skew: nan Prob(JB): nan\n", - "Kurtosis: nan Cond. No. 948.\n", + "Kurtosis: nan Cond. No. 883.\n", "==============================================================================\n", "\n", "Notes:\n", @@ -2424,7 +2424,7 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 96, "id": "61e40e4c", "metadata": {}, "outputs": [ @@ -2466,7 +2466,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 97, "id": "354687ec", "metadata": {}, "outputs": [ @@ -2521,7 +2521,7 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 98, "id": "8d6cd1df", "metadata": {}, "outputs": [ @@ -2558,7 +2558,7 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 99, "id": "592c257c", "metadata": {}, "outputs": [ @@ -2600,7 +2600,7 @@ }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 100, "id": "12f276cc", "metadata": {}, "outputs": [ @@ -2650,7 +2650,7 @@ }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 101, "id": "d04ee20e", "metadata": {}, "outputs": [ @@ -2672,15 +2672,15 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_299408/788188722.py:16: RuntimeWarning: invalid value encountered in scalar divide\n", + "/tmp/ipykernel_386440/788188722.py:16: RuntimeWarning: invalid value encountered in scalar divide\n", " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", - "/tmp/ipykernel_299408/788188722.py:17: RuntimeWarning: invalid value encountered in scalar divide\n", + "/tmp/ipykernel_386440/788188722.py:17: RuntimeWarning: invalid value encountered in scalar divide\n", " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", - "/tmp/ipykernel_299408/788188722.py:27: RuntimeWarning: invalid value encountered in scalar divide\n", + "/tmp/ipykernel_386440/788188722.py:27: RuntimeWarning: invalid value encountered in scalar divide\n", " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", - "/tmp/ipykernel_299408/788188722.py:39: RuntimeWarning: divide by zero encountered in scalar divide\n", + "/tmp/ipykernel_386440/788188722.py:39: RuntimeWarning: divide by zero encountered in scalar divide\n", " sA = np.sqrt(1 / S)\n", - "/tmp/ipykernel_299408/788188722.py:40: RuntimeWarning: divide by zero encountered in scalar divide\n", + "/tmp/ipykernel_386440/788188722.py:40: RuntimeWarning: divide by zero encountered in scalar divide\n", " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n" ] } @@ -2706,7 +2706,7 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 102, "id": "e795e732", "metadata": {}, "outputs": [ @@ -2756,7 +2756,7 @@ }, { "cell_type": "code", - "execution_count": 49, + "execution_count": 103, "id": "46ef07bd", "metadata": {}, "outputs": [ @@ -2826,7 +2826,7 @@ }, { "cell_type": "code", - "execution_count": 50, + "execution_count": 104, "id": "dfcd391e", "metadata": {}, "outputs": [ @@ -2856,7 +2856,7 @@ }, { "cell_type": "code", - "execution_count": 51, + "execution_count": 105, "id": "b52fea3d", "metadata": {}, "outputs": [], @@ -2903,7 +2903,7 @@ }, { "cell_type": "code", - "execution_count": 52, + "execution_count": 106, "id": "0b1e4a1d", "metadata": {}, "outputs": [ diff --git a/molla/dinamica/mollaDinamica1Errore.ipynb b/molla/dinamica/mollaDinamica1Errore.ipynb new file mode 100644 index 0000000..1326933 --- /dev/null +++ b/molla/dinamica/mollaDinamica1Errore.ipynb @@ -0,0 +1,2734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 779, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.807\n", + "ug = 0.001\n", + "\n", + "m_mol = 29.89\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, + { + "cell_type": "code", + "execution_count": 780, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica1.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "\n", + "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", + "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 781, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1a1ua1w1uw1c1uc1a2ua2w2uw2c2uc2wuwmumcucauatut
0108.6100009.2100.02914.24590.0008268.1510.02010.6900.04014.24340.0009268.3260.02614.244650.001768108.6100000.002887268.23850.1237449.95001.046518NaNNaN
1128.63666710.0370.02513.19390.0007259.6050.0189.7440.02713.19130.0009259.7450.02013.192600.001838128.6366670.002887259.67500.0989959.89050.207182NaNNaN
2148.3800009.9300.03012.34690.0007251.5250.02111.4100.03012.34610.0006251.5420.02312.346500.000566148.3800000.002887251.53350.01202110.67001.046518NaNNaN
3168.53000011.3400.03011.63450.0005243.2110.02111.5000.03011.63440.0006243.1300.02111.634450.000071168.5300000.002887243.17050.05727611.42000.113137NaNNaN
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 a2 ua2 \\\n", + "0 108.610000 9.210 0.029 14.2459 0.0008 268.151 0.020 10.690 0.040 \n", + "1 128.636667 10.037 0.025 13.1939 0.0007 259.605 0.018 9.744 0.027 \n", + "2 148.380000 9.930 0.030 12.3469 0.0007 251.525 0.021 11.410 0.030 \n", + "3 168.530000 11.340 0.030 11.6345 0.0005 243.211 0.021 11.500 0.030 \n", + "\n", + " w2 uw2 c2 uc2 w uw m um \\\n", + "0 14.2434 0.0009 268.326 0.026 14.24465 0.001768 108.610000 0.002887 \n", + "1 13.1913 0.0009 259.745 0.020 13.19260 0.001838 128.636667 0.002887 \n", + "2 12.3461 0.0006 251.542 0.023 12.34650 0.000566 148.380000 0.002887 \n", + "3 11.6344 0.0006 243.130 0.021 11.63445 0.000071 168.530000 0.002887 \n", + "\n", + " c uc a ua t ut \n", + "0 268.2385 0.123744 9.9500 1.046518 NaN NaN \n", + "1 259.6750 0.098995 9.8905 0.207182 NaN NaN \n", + "2 251.5335 0.012021 10.6700 1.046518 NaN NaN \n", + "3 243.1705 0.057276 11.4200 0.113137 NaN NaN " + ] + }, + "execution_count": 781, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.width', None)\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, + { + "cell_type": "code", + "execution_count": 782, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n", + "6\n", + "############################################################\n", + "[ 8.5635 16.705 25.068 8.1415 16.5045 8.363 ]\n", + "[0.15846924 0.12432618 0.13635615 0.09972211 0.11437001 0.0585235 ]\n", + "############################################################\n", + "[-20.02666667 -39.77 -59.92 -19.74333333 -39.89333333\n", + " -20.15 ]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.c[x] - df.c[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uc[x]**2 + df.uc[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 783, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[22.93472529 23.34776354 23.44165629 23.78221089 23.70468175 23.62920603]\n", + "[0.42444376 0.17379748 0.12754214 0.29135079 0.16430027 0.16544183]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(K)\n", + "print(uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 784, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 23.52082621035826\n", + "sigmaC: 0.07342397251895814\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 785, + "id": "1d4c0ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.081650\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.2\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 786, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": np.sqrt(ueste**2 + uDx_strum**2),\n", + " \"y\": - F,\n", + " \"uy\": np.sqrt(uF**2 + uF_strum**2)\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 787, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 1.044e+04\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): 5.50e-08\n", + "Time: 17:02:50 Log-Likelihood: -14.807\n", + "No. Observations: 6 AIC: 33.61\n", + "Df Residuals: 4 BIC: 33.20\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.1355 3.495 0.039 0.971 -9.569 9.840\n", + "x 23.4652 0.230 102.161 0.000 22.827 24.103\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 0.555\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.395\n", + "Skew: -0.285 Prob(JB): 0.821\n", + "Kurtosis: 1.880 Cond. No. 37.4\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", + "R² = 0.99962\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 6 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 788, + "id": "8d795186", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 789, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 3.91693\n", + "GdL = 4\n", + "Chi² rid = 0.97923\n", + "P(0, chi²)= 0.58263\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.250317\n", + "1 0.360714\n", + "2 0.037755\n", + "3 0.653693\n", + "4 1.339556\n", + "5 0.274893\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "9f26f65e", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 790, + "id": "6a910226", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 23.4106 +- 0.2224\n", + "BC = 1.4233 +- 3.1272\n", + "cov_ABC = -0.632350\n", + "P(0, chi²)= 0.5436\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 791, + "id": "b49ec5a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 792, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 3.66772\n", + "GdL = 4\n", + "Chi² rid = 0.91693\n", + "P(0, chi²)= 0.54716\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.735332\n", + "1 0.503968\n", + "2 0.029958\n", + "3 0.281908\n", + "4 1.086900\n", + "5 0.029650\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 793, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 23.4182722 ± 0.2217067\n", + "BY = 1.3248937 ± 3.1178836\n", + "cov_ABY = -0.628605644189924\n", + "chi² = 3.66651\n", + "chi² rid = 0.91663\n", + "P(0, chi²)= 0.54698\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 794, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 795, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.52083 ± 0.07342\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", + "P(0, chi²)= 0.58263\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 23.41058 ± 0.22237\n", + "Bc = 1.42328 ± 3.12716\n", + "P(0, chi²)= 0.54716\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 23.41827 ± 0.22171\n", + "By = 1.32489 ± 3.11788\n", + "P(0, chi²)= 0.54698\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 796, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.000100\n", + "0 0.194561\n", + "1 0.226829\n", + "2 0.258983\n", + "3 0.291654\n", + "Name: w, dtype: float64\n", + "0 0.000101\n", + "1 0.000114\n", + "2 0.000105\n", + "3 0.000108\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Meq = df.m + ( m_mol * 0.38 )\n", + "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", + "\n", + "T2 = ( 2 * np.pi / df.w )**2\n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", + "res_b = 0.01 / np.sqrt(6) # riso bilancia\n", + "res_T = 0.0001 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = 2 * T * res_T\n", + "\n", + "res_uAd = np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2)\n", + "\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "# print(f\"res_T2 = {res_T2:.6f}\")\n", + "# print(f\"res_b = {res_b:.6f}\")\n", + "# print(f\"res_uAd = {res_uAd:.6f}\")\n", + "\n", + "uT2 = np.sqrt(uT2**2 + res_T2**2)\n", + "uMeq = np.sqrt(uMeq**2 + res_b**2)\n", + "\n", + "\n", + "print(T2)\n", + "print(uT2)" + ] + }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, + { + "cell_type": "code", + "execution_count": 797, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 24.342754\n", + "1 24.365364\n", + "2 24.349862\n", + "3 24.349744\n", + "dtype: float64\n", + "0 0.012642\n", + "1 0.012325\n", + "2 0.009869\n", + "3 0.009059\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 798, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 24.351452510052987\n", + "sigmaC: 0.0053229729724284785\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 799, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 800, + "id": "90d191d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 4.713e+05\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): 2.12e-06\n", + "Time: 17:02:51 Log-Likelihood: 32.343\n", + "No. Observations: 4 AIC: -60.69\n", + "Df Residuals: 2 BIC: -61.91\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -4.426e-06 0.000 -0.012 0.991 -0.002 0.002\n", + "x 0.0016 2.36e-06 686.488 0.000 0.002 0.002\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 2.752\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.628\n", + "Skew: -0.880 Prob(JB): 0.730\n", + "Kurtosis: 2.180 Cond. No. 1.03e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.03e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Adols = 0.00162 ± 0.00000\n", + "Bdols = -0.00000 ± 0.00036\n", + "R² = 1.00000\n", + "Kdols = 24.35158 ± 0.03547\n", + "KBdols = -8919.17465 ± 721171.83239\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 4 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 801, + "id": "a0ba5c8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", + "\n", + "plt.plot(\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 802, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 1.82343\n", + "GdL = 2\n", + "Chi² rid = 0.91171\n", + "P(0, chi²)= 0.59817\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.549870\n", + "1 1.167744\n", + "2 0.046649\n", + "3 0.059166\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 803, + "id": "698e3c48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AdC = 0.00162 ± 0.00000\n", + "BdC = 0.00003 ± 0.00036\n", + "cov_ABdC = -0.000000\n", + "P(0,chi²)= 0.59375\n", + "KdC = 24.35469 ± 0.03539\n", + "KBdC = 1201.54723 ± 13001.21079\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", + "print(\"Ax + B : \")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 804, + "id": "a0ab8534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 805, + "id": "12bb0479", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 1.80159\n", + "GdL = 2\n", + "Chi² rid = 0.90079\n", + "P(0, chi²)= 0.59375\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.382791\n", + "1 1.328500\n", + "2 0.031079\n", + "3 0.059218\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 806, + "id": "385db415", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AdY = 0.0016210 ± 0.0000024\n", + "BdY = 0.0000328 ± 0.0003555\n", + "cov_ABdY = -8.279596207327886e-10\n", + "chi² = 1.80159\n", + "chi² rid = 0.90079\n", + "P(0, chi²)= 0.59375\n", + "KdY = 24.35469 ± 0.03539\n", + "KBdY = 1201.80652 ± 13006.82292\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", + "\n", + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 807, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 808, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 24.35145 ± 0.00532\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.0016212 ± 0.00000\n", + "Bdols = -0.0000044 ± 0.00036\n", + "P(0,chi²)= 0.5981652\n", + "Kdols = 24.3515777 ± 0.03547\n", + "KBdols = -8919.1746464 ± 721171.83239\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.0016210 ± 0.00000\n", + "BdC = 0.0000329 ± 0.00036\n", + "P(0,chi²)= 0.5937530\n", + "KdC = 24.3546921 ± 0.03539\n", + "KBdC = 1201.54723 ± 13001.21079\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.00162 ± 0.00000\n", + "Bdy = 0.00003 ± 0.00036\n", + "P(0,chi²)= 0.59375\n", + "KdY = 24.35469 ± 0.03539\n", + "KBdY = 1201.80652 ± 13006.82292\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.7f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.7f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.7f}\")\n", + "print(f\"Kdols = {Kdols:.7f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.7f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.7f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.7f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.7f}\")\n", + "print(f\"KdC = {KdC:.7f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 809, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "Name: t, dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 810, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 811, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): nan\n", + "sigmaC (t): inf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_473293/2995330097.py:10: RuntimeWarning: invalid value encountered in scalar divide\n", + " media = num / den\n", + "/tmp/ipykernel_473293/2995330097.py:11: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sigma = np.sqrt(1.0 / den)\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 812, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 813, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: nan\n", + "Model: OLS Adj. R-squared: nan\n", + "Method: Least Squares F-statistic: nan\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): nan\n", + "Time: 17:02:52 Log-Likelihood: nan\n", + "No. Observations: 4 AIC: nan\n", + "Df Residuals: 2 BIC: nan\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const nan nan nan nan nan nan\n", + "x nan nan nan nan nan nan\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: nan\n", + "Prob(Omnibus): nan Jarque-Bera (JB): nan\n", + "Skew: nan Prob(JB): nan\n", + "Kurtosis: nan Cond. No. 1.03e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.03e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "R² = nan\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 4 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 814, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 815, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 816, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "cov_ABtC = nan\n", + "P(0,chi²)= nan\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 817, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 818, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 819, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "cov_ABtY = nan\n", + "chi² = 0.00000\n", + "chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_473293/788188722.py:16: RuntimeWarning: invalid value encountered in scalar divide\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + "/tmp/ipykernel_473293/788188722.py:17: RuntimeWarning: invalid value encountered in scalar divide\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "/tmp/ipykernel_473293/788188722.py:27: RuntimeWarning: invalid value encountered in scalar divide\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "/tmp/ipykernel_473293/788188722.py:39: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sA = np.sqrt(1 / S)\n", + "/tmp/ipykernel_473293/788188722.py:40: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 820, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 821, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± inf\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 822, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000500\n", + "res_t2 = nan\n", + "res_uAdt = nan\n", + "uKdt_strum = nan\n" + ] + } + ], + "source": [ + "res_t = 0.01 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 823, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 824, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± nan\n", + "\n", + "RISULTATI OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "Kdtols = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "KdtC = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI York:\n", + "AtY = nan ± nan\n", + "BtY = nan ± nan\n", + "KdtY = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/dinamica/mollaDinamica1Lavoro.ipynb b/molla/dinamica/mollaDinamica1Lavoro.ipynb new file mode 100644 index 0000000..0a26852 --- /dev/null +++ b/molla/dinamica/mollaDinamica1Lavoro.ipynb @@ -0,0 +1,2734 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.807\n", + "ug = 0.001\n", + "\n", + "m_mol = 29.89\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, + { + "cell_type": "code", + "execution_count": 233, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica1.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "\n", + "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", + "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 234, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1a1ua1w1uw1c1uc1a2ua2w2uw2c2uc2wuwmumcucauatut
0108.6100009.2100.02914.24590.0008268.1510.02010.6900.04014.24340.0009268.3260.02614.244650.001768108.6100000.002887268.23850.1237449.95001.046518NaNNaN
1128.63666710.0370.02513.19390.0007259.6050.0189.7440.02713.19130.0009259.7450.02013.192600.001838128.6366670.002887259.67500.0989959.89050.207182NaNNaN
2148.3800009.9300.03012.34690.0007251.5250.02111.4100.03012.34610.0006251.5420.02312.346500.000566148.3800000.002887251.53350.01202110.67001.046518NaNNaN
3168.53000011.3400.03011.63450.0005243.2110.02111.5000.03011.63440.0006243.1300.02111.634450.000071168.5300000.002887243.17050.05727611.42000.113137NaNNaN
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 a2 ua2 \\\n", + "0 108.610000 9.210 0.029 14.2459 0.0008 268.151 0.020 10.690 0.040 \n", + "1 128.636667 10.037 0.025 13.1939 0.0007 259.605 0.018 9.744 0.027 \n", + "2 148.380000 9.930 0.030 12.3469 0.0007 251.525 0.021 11.410 0.030 \n", + "3 168.530000 11.340 0.030 11.6345 0.0005 243.211 0.021 11.500 0.030 \n", + "\n", + " w2 uw2 c2 uc2 w uw m um \\\n", + "0 14.2434 0.0009 268.326 0.026 14.24465 0.001768 108.610000 0.002887 \n", + "1 13.1913 0.0009 259.745 0.020 13.19260 0.001838 128.636667 0.002887 \n", + "2 12.3461 0.0006 251.542 0.023 12.34650 0.000566 148.380000 0.002887 \n", + "3 11.6344 0.0006 243.130 0.021 11.63445 0.000071 168.530000 0.002887 \n", + "\n", + " c uc a ua t ut \n", + "0 268.2385 0.123744 9.9500 1.046518 NaN NaN \n", + "1 259.6750 0.098995 9.8905 0.207182 NaN NaN \n", + "2 251.5335 0.012021 10.6700 1.046518 NaN NaN \n", + "3 243.1705 0.057276 11.4200 0.113137 NaN NaN " + ] + }, + "execution_count": 234, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.width', None)\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, + { + "cell_type": "code", + "execution_count": 235, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n", + "6\n", + "############################################################\n", + "[ 8.5635 16.705 25.068 8.1415 16.5045 8.363 ]\n", + "[0.15846924 0.12432618 0.13635615 0.09972211 0.11437001 0.0585235 ]\n", + "############################################################\n", + "[-20.02666667 -39.77 -59.92 -19.74333333 -39.89333333\n", + " -20.15 ]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.c[x] - df.c[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uc[x]**2 + df.uc[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 236, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[22.93472529 23.34776354 23.44165629 23.78221089 23.70468175 23.62920603]\n", + "[0.42444376 0.17379748 0.12754214 0.29135079 0.16430027 0.16544183]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(K)\n", + "print(uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 237, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 23.52082621035826\n", + "sigmaC: 0.07342397251895814\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 238, + "id": "1d4c0ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.081650\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.2\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 239, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": np.sqrt(ueste**2 + uDx_strum**2),\n", + " \"y\": - F,\n", + " \"uy\": np.sqrt(uF**2 + uF_strum**2)\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 240, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 1.044e+04\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 5.50e-08\n", + "Time: 09:57:16 Log-Likelihood: -14.807\n", + "No. Observations: 6 AIC: 33.61\n", + "Df Residuals: 4 BIC: 33.20\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.1355 3.495 0.039 0.971 -9.569 9.840\n", + "x 23.4652 0.230 102.161 0.000 22.827 24.103\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 0.555\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.395\n", + "Skew: -0.285 Prob(JB): 0.821\n", + "Kurtosis: 1.880 Cond. No. 37.4\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", + "R² = 0.99962\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 6 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 241, + "id": "8d795186", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1wAAAIsCAYAAADmsKixAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkRtJREFUeJzt3Xd4FOXaBvB7drOBACn0jiRgApIAUelFKYIJKIIIqIAFUFRQ8KAUAQU5H4givUgAAUGlSFEIRRFBNGJDOiqEEkBqIAmpW+b7I2fXbHaTbHl3d3Zy/67rXMfszr55Z/bOkCf7zDuSLMsyiIiIiIiISDiNrydARERERESkViy4iIiIiIiIPIQFFxERERERkYew4CIiIiIiIvIQFlxEREREREQewoKLiIiIiIjIQ1hwEREREREReQgLLiIiIiIiIg9hwUVEREREROQhLLiIiEowaNAgDBo0yPL1xYsXERUVhU2bNvlwVo4ZN24cYmNjfT0NVYmKisL8+fN9PQ1V6ty5M8aNG+fraajKoEGD0LNnT19Pg6hUY8FFRA7btGkToqKicPToUV9PxS8cPHgQUVFR2Llzp93nWQwp1759+1hU2ZGdnY358+fj4MGDLo/x+++/Y/78+UhPTxc4MyIi5Qrw9QSIiPxN7dq1ceTIEQQE8BSqVvv27cPatWsxcuRIm+eOHDkCrVbrg1n5XnZ2NhYsWIARI0agVatWLo1x6NAhLFiwAL1790ZISIjVczt37oQkSSKmSkSkGPyEi4jISZIkoUyZMqX2l+7SrkyZMooptrOysnw9BaECAwOh0+l8PQ2vkGUZOTk5dp/Lzc2FyWRya3xvZsNgMCAvL89r34/I37DgIiLhrl69ivHjx6Nt27aIjo5Gjx49sHHjRpvtLl26hOHDh6N58+Zo06YN/u///g/ff/89oqKibFqW1q5diy5duqBp06bo27cvfv31V5trqwAgLy8P8+bNw0MPPYTo6Gg88MADmDlzpsO/DKxbtw5du3a1+j6FefoarrVr16JHjx6Ijo5G+/btMWXKFLvtVzt27ECfPn3QtGlTtGrVCmPGjMHVq1dLHP/kyZNo3bo1Bg0ahMzMTACOv2feYj7Gy5cvx8qVK9GpUyc0bdoUAwcOxF9//WW1rb0cAPktm507d7Y7pvl9jo6OxuOPP44jR45YvW7t2rUA8q/XMv/PzJFruMztpImJifjwww/Rrl07NG/eHMOHD8c///xjs/3hw4cxZMgQ3HfffWjWrBkGDhyI3377zWqb+fPnIyoqCqdPn8Z//vMftGjRAk899RSA/GufXnzxRRw8eNCSiUceecTyc7R792488sgjiImJQZ8+fXDixAmnj+HFixfRpk0bAMCCBQssx8V8LE6dOoVx48ahS5cuiImJQbt27TB+/HjcunXLah9mzpwJAOjSpYtljIsXL1r2w5FruEwmE1atWmXZp9atW2PIkCFW7c4GgwELFy60vM+dO3fGhx9+aHMuMB+7X3/9FX379kVMTAy6dOmCLVu2lDgP81xWrlyJHj16ICYmBm3btsXkyZORlpZm9/t8//33lvfo888/t2Rl+/btmD17Njp06IBmzZrhzp07ABz7OTe3J1+4cAHDhg1DbGwsxowZY7XNsWPHMGDAADRt2hSdO3fGZ599ZvV8Xl4e5s6diz59+uC+++5D8+bN8dRTT+Gnn36y2q7wz2bXrl0RExODM2fOOHS8iEojZfyJjohU48aNG+jXrx8kScLTTz+NSpUqYf/+/Xjrrbdw584dPPvsswDy//r6zDPP4Pr16xg8eDCqVKmCbdu22b025NNPP8XUqVNx//3349lnn8WlS5fwyiuvICQkBDVq1LBsZzKZ8NJLL+G3335Dv3790KBBA/z1119YtWoVzp07h0WLFhU79w0bNmDy5MmIjY3FM888g5SUFLz00ksIDQ1FzZo1XT4mmZmZSE1NtXncXhE4f/58LFiwAG3btsWTTz6Js2fP4rPPPsPRo0fx2WefWf76v2nTJowfPx4xMTF4/fXXcfPmTaxevRq///47tmzZYtOqZXbkyBEMHToU0dHRWLRoEcqWLevwe+YLW7ZsQWZmJp566ink5ubik08+wTPPPIOvvvoKVapUcWnMbdu2ITMzE/3794ckSVi2bBlGjhyJb775BjqdDv3798e1a9fwww8/WIoDVy1evBiSJGHYsGG4efMmVq1ahWeffRZbt25F2bJlAQBJSUkYNmwYoqOjMWLECEiShE2bNuGZZ57Bp59+iqZNm1qN+dprr+Guu+7C6NGjIcuy5fHz58/jP//5DwYMGIBHH30UK1aswPDhwzFlyhTMnj0bTz75JABg6dKlGDVqFHbu3AmNxvG/u1aqVAnvvPMO3nnnHTz00EN46KGHAMBSjP74449ISUlBnz59ULVqVfz9999Yv349Tp8+jfXr10OSJDz00EM4d+4ctm3bhvHjx6NixYqWsZ3x1ltvYdOmTejYsSP69u0Lo9GIX3/9FYcPH0ZMTAwAYOLEidi8eTO6d++O5557DkeOHMFHH32EM2fOYOHChVbjnT9/Hq+99hr69u2L3r1744svvsC4cePQpEkT3H333cXOZfLkydi8eTP69OmDQYMG4eLFi1i7di1OnDhh9TMLAGfPnsV//vMf9O/fH/369UN4eLjluUWLFkGn02HIkCHIy8uDTqdz6ufcYDBYivaxY8da8gUAaWlpeOGFFxAXF4cePXpgx44deOedd6DT6dC3b18AwJ07d7Bhwwb07NkTTzzxBDIzM7Fx40YMHToUGzZsQOPGja32e9OmTcjNzUW/fv0QGBiI0NBQp95DolJFJiJy0BdffCFHRkbKR44cKXKbCRMmyO3atZNTU1OtHh89erR83333ydnZ2bIsy/KKFSvkyMhI+euvv7Zsk5OTIz/88MNyZGSk/NNPP8myLMu5ublyy5Yt5ccff1zW6/WWbTdt2iRHRkbKAwcOtDy2ZcsWuVGjRvIvv/xi9b0/++wzOTIyUv7tt9+KnHdeXp7cpk0buVevXnJubq7l8XXr1tl8n5SUFDkyMlL+4osvihxPlmX5p59+kiMjI4v9X/PmzS3b37x5U27SpIn8/PPPy0aj0fL4mjVr5MjISHnjxo1Wc+3Zs6eck5Nj2W7v3r1yZGSkPHfuXMtjY8eOtXyPX3/9Vb733nvlF154wWofHX3PvMl8jJs2bSpfuXLF8vjhw4flyMhI+f/+7/8sjw0cONDq/TEbO3as3KlTJ5sxW7ZsKd++fdvy+DfffCNHRkbK3377reWxKVOmyJGRkXbnFhkZKc+bN6/Y+Zvf+w4dOsgZGRmWxxMTE+XIyEh51apVsizLsslkkrt16yY///zzsslksmyXnZ0td+7cWX7uuecsj82bN0+OjIyUX3/9dZvv16lTJzkyMlL+/fffLY99//33lmN46dIly+Off/651c+YLDt+DG/evFnk/tvLybZt2+TIyEirn8lly5bJkZGRckpKit39GDt2rM3jBSUlJcmRkZHyu+++a/Oc+RiePHlSjoyMlN966y2r52fMmCFHRkbKSUlJVt+z8Bxv3rwpR0dHyzNmzCh2Lr/88oscGRkpf/nll1aP79+/3+Zx8/fZv3+/1bbmrHTp0sXqGDr7cx4ZGSl/8MEHNnMcOHCgHBkZKa9YscLyWG5urtyrVy+5TZs2cl5enizLsmwwGKzOC7Isy2lpaXLbtm3l8ePHWx4z/xzde++98s2bN4s9PkSUjy2FRCSMLMvYvXs3OnfuDFmWkZqaavlf+/btkZGRgePHjwMAvv/+e1SvXh1dunSxvL5MmTLo16+f1ZjHjh3D7du30a9fP6vrZh555BGbv6ju3LkTDRo0QEREhNX3bt26NQAUu7LasWPHcPPmTQwYMACBgYGWx3v37o3g4GDXDwqAV155BR9//LHN/9q3b2+13Y8//gi9Xo/BgwdbffLwxBNPoEKFCti3b5/VXJ988kmUKVPGst2DDz6IiIgIfPfddzZz+OmnnzB06FC0adMG8+fPt+yjM++ZL3Tt2hXVq1e3fN20aVM0a9bMcixcER8fb5Wd+++/HwCQkpLi+kSL8Nhjj6FChQqWrx9++GFUrVrVMv+TJ0/i3LlzeOSRR3Dr1i3Lsc/KykKbNm3wyy+/2FzLM2DAALvfq2HDhlarXjZr1gwA0Lp1a9SqVcvmcdH7W/ATldzcXKSmplq+l8gM7d69G5IkYcSIETbPmRfcMB/f5557zur5559/3up5s4YNG1pyAOR/4hYeHl7iMdq5cyeCg4PRrl07q5+dJk2aoFy5cjbnnDp16qBDhw52x3rsscesjqErP+fmTzELCwgIQP/+/S1fBwYGon///rh586blvdFqtZbzgslkwu3bt2EwGBAdHW3TggoA3bp1c/qTSaLSii2FRCRMamoq0tPTsW7dOqxbt67IbYD867fq1atnsyJZvXr1rL6+fPmy3ccDAgJQu3Ztq8fOnz+PM2fOWK4zKezmzZtFzt38fe666y6rx3U6HerWrVvk6xwRGRmJtm3b2jz+5Zdf2p1DRESE1eOBgYGoW7cuLl26ZLVdwXYks4iICJtrf3Jzc/Hiiy+iSZMmmDNnjlXh6sx7Zs/t27eh1+uLfL44oaGhVsWtPYXfDwCoX78+duzY4dL3BGDTHmouvjyxTHnh+UuShLvuusvyXp47dw4AMHbs2CLHyMjIsCoQ69SpY3e7wvtl/kNBwbZbAJYCUPT+3r59GwsWLEBiYqLNz1pGRoaw73PhwgVUq1YNYWFhRW5z6dIlaDQam/NG1apVERISYjn+ZvZahkNDQ22uwyrs/PnzyMjIcPicU9R7Z+85Z3/OAwICbN5rs2rVqqFcuXJWj9WvXx9A/rFq3rw5AGDz5s1YsWIFzp49a/VzbW/exe0LEVljwUVEwpj/Ev/oo4+id+/edrcpuPiAJ75/ZGQkxo8fb/f5on4ZUbvAwEB07NgR3377Lb7//nt06tTJ8py779nIkSPx888/uzSv1atXu7y0uCOMRqPdx4taXVIucD2Ut5i/55tvvmlzjYxZ4V+UC37aUVBR++XO/hZ1DO0ZNWoUDh06hCFDhqBx48YoV64cTCYThg4d6pNjC8DhJeZdXXHUZDKhcuXK+OCDD+w+X/gToIKfYBVW3HOOCAwMdOqavMK2bt2KcePGoWvXrhgyZAgqV64MrVaLjz76yO4nfe7Ol6g0YcFFRMJUqlQJ5cuXh8lksvuJTkG1a9fG6dOnIcuy1S9FFy5csNrO3Ap14cIFS2sgkH+B+KVLl6yKgXr16uHUqVNo06aN0/fyMX+f8+fPW/21Wq/X4+LFi2jUqJFT47nCPIfk5GSrT9Xy8vJw8eJFyzE1b3f27Fmbv6yfPXvWqn0MyP+l84MPPsDLL7+M1157DQkJCZZCx5n3zJ6xY8e6/EmJI8f0/PnzNo+dO3fO6tPN0NBQu78Qmj8hcIWoe0EVnr8syzh//rwlt+b3uUKFCi4df1EcPYZFHZe0tDQkJSVh5MiRVq1+5k/wHBnDUfXq1cOBAwdw+/btIj/lql27NkwmE86fP48GDRpYHr9x4wbS09NtPh13Zy5JSUm49957hRcgzv6cF+fatWvIysqyKt7N7435WOzatQt169bFggULrN6jefPmuboLRPQ/vIaLiITRarXo3r07du3aZbN0N2Ddmta+fXtcvXoVe/bssTyWm5uL9evXW70mOjoaYWFhWL9+PQwGg+Xxr776yqbdJy4uDlevXrUZAwBycnKKvS9NdHQ0KlWqhM8//9xq9cDNmzd7pNXMnrZt20Kn0+GTTz6x+kRg48aNyMjIwAMPPGCZa+XKlW3mum/fPpw5cwYPPvigzdiBgYFYsGABYmJiMHz4cMsy6M68Z/ZER0ejbdu2Lv3PkVXNvvnmG6slsI8cOYLDhw+jY8eOlsfq1q2L5ORkq7meOnUKv//+e4njFyUoKAiA+213W7ZssSzvDeRf83P9+nXL/KOjo1GvXj2sWLHCskR/QSUdf1EcPYZFHZeiPiFatWqVzWPmMVxtM+zWrRtkWcaCBQtsnjP/3Jh/Vgp//48//tjqeXfFxcXBaDTaXQHVYDC4lR9Xfs6LYjAYrFqG8/LysG7dOlSqVAlNmjQB8O97WPDcc/jwYfzxxx8u7wMR5eMnXETktC+++ALff/+9zeODBw/Gf/7zHxw8eBD9+vXDE088gYYNGyItLQ3Hjx9HUlKSpf2sf//+WLNmDf7zn/9g8ODBqFq1Kr766itLu5T5L6yBgYEYOXIk3n33XTzzzDOIi4vDpUuXsGnTJpvrM3r16oUdO3bg7bffxsGDB3HvvffCaDQiOTkZO3fuxLJlyyxLRhem0+kwatQoTJ48Gc888wzi4+Nx8eJFbNq0ye1ruBxVqVIlvPjii1iwYAGGDh2Kzp074+zZs/j0008RExODRx991DLXMWPGYPz48Rg4cCB69OhhWS66du3aRS7jXrZsWXz00UcYPHgwhg0bhk8++QSRkZEOv2e+UK9ePTz55JN48sknkZeXh9WrVyMsLAxDhw61bNO3b1+sXLkSQ4YMQd++fXHz5k18/vnnaNiwod0ixhHmX0KnTZuG9u3bQ6vVokePHk6PExoaiqeeegp9+vSxLAt/1113WRaH0Wg0mDZtGoYNG4aePXuiT58+qF69Oq5evYqDBw+iQoUKWLJkiUv74AxHj2HZsmXRsGFD7NixA/Xr10dYWBjuvvtuREZGokWLFli2bBn0ej2qV6+OH374wXJ/rYLMx3b27NmIj4+HTqdDp06dbFoni9K6dWv06tULn3zyCc6fP48OHTrAZDLht99+Q6tWrTBw4EA0atQIvXv3xrp165Ceno4WLVrg6NGj2Lx5M7p27Wr1abk7WrZsif79++Ojjz7CyZMn0a5dO+h0Opw7dw47d+7EW2+9hYcfftilsV39ObenWrVqSEhIwKVLl1C/fn0kJibi5MmTePfddy3L1j/44IPYvXs3XnnlFTz44IO4ePGiJQNqu8E2kbex4CIipxW+YaZZnz59UKNGDWzYsAELFy7E119/jc8++wxhYWFo2LCh1Y04y5cvj1WrVmHatGlYvXo1ypUrh8ceewyxsbEYOXKk1XUqAwcOhCzL+Pjjj/Hee++hUaNGWLx4MaZNm2a1nUajwcKFC7Fy5Ups3boVX3/9NYKCglCnTh0MGjTI7sXnBfXv3x9GoxHLly/HzJkzERkZicWLF2Pu3LluHjHHjRw5EpUqVcKaNWswffp0hIaGol+/fnj99det7ufTp08flC1bFgkJCfjggw9Qrlw5dO3aFW+88UaR9+AC8lvXli9fjoEDB+L555/H2rVrcddddzn0nvnCY489Bo1Gg1WrVuHmzZto2rQpJk2ahGrVqlm2adCgAd577z3MmzcP06dPR8OGDTFz5kxs27bN5WKxW7duGDRoELZv344vv/wSsiy7VHANHz4cf/75J5YuXYrMzEy0adMGb7/9tuVTHgBo1aoV1q1bh0WLFmHNmjXIyspC1apV0bRpU6uV5TzJmWM4bdo0vPvuu5g+fTr0ej1GjBiByMhIzJo1C++++y4+/fRTyLKMdu3aISEhwWZVvqZNm+K1117D559/ju+//x4mkwl79uxxuOACgOnTpyMqKgobN27EzJkzERwcjOjoaKtVGqdNm4Y6depg8+bN+Oabb1ClShW8+OKLdlc3dMfUqVMRHR2Nzz//HLNnz4ZWq0Xt2rXx6KOP4t5773VrbFd/zgsLDQ3FjBkzMG3aNKxfvx5VqlTB5MmTrVaF7dOnD27cuIF169bhwIEDaNiwId5//33s3LnTp390IVIDSfbVlaxERHasXLkS06dPx/79+62WAy/MZDKhTZs2eOihhzBt2jQvzpC84eLFi+jSpQvefPNNDBkyxNfTcdrBgwcxePBgzJ071+VPOIiISB14DRcR+UxOTo7V17m5uVi3bh3q169vVWzl5ubarHK2ZcsW3L59Gy1btvTKXImIiIhcwZZCIvKZESNGoFatWmjUqBHu3LmDL7/8EsnJyTZLLP/xxx+YPn06Hn74YYSFheHEiRPYuHEjIiMj+ekBERERKRoLLiLymfbt22Pjxo346quvYDQa0bBhQ8uF9AXVrl0bNWrUwCeffIK0tDSEhoaiV69eGDNmTIk3ziUiIiLyJV7DRURERERE5CG8houIiIiIiMhDWHARERERERF5CK/hcsKhQ4cgy7LVvXCIiIiIiKj00ev1kCTJ6h6A9rDgcoIsyzZLUxMRERERUenjaF3AgssJOp0OsiwjOjoakiT5ejrkp2RZhl6vh06nY47IZcwRicIskQjMEYngbzk6evSoQ9vxGi4iIiIiIiIPYcFFRERERETkISy4iIiIiIiIPIQFFxERERERkYew4HKSP1zAR8rHWwuQCMwRicIskQjMEYmgxhxxlUIXlFR0GY1G6PV6L82GyD6dTgetVuvraZCH8I8/JAqzRCIwRySCWnOkyIJr8+bNWLVqFc6cOYNy5cohJiYGCxYsQNmyZQEA3377LebMmYOzZ8+iVq1aeOGFF/D4449bjZGXl4fZs2fjyy+/RGZmJmJjYzFp0iRERES4PT9Zlu0GQpZlXLlyBbdv33b7e5C6FZUh0cLCwlCjRg3VnsBKM1mWYTQaodVq+f6SW5glEoE5IhHUmiPFFVyLFy9GQkIChg8fjubNm+PWrVtISkqC0WgEAPz6668YMWIE+vbtiwkTJuCnn37CW2+9hfLly+Phhx+2jDNt2jQkJiZi3LhxqF69OpYsWYJnn30W27dvR3BwsMvzK+4GZ+Ziq1q1aihXrpyqgkLimG+gLUmSxzIiyzKysrJw7do1AEDNmjU98n3It0wmEz/FJCGYJRKBOSIR1JgjRRVcycnJWLBgARYtWoQHHnjA8nj37t0t/7148WI0bdoUU6dOBQC0bt0aKSkpmDdvnqXgunLlCjZu3Ii3334bffv2BQDExMSgU6dO+PzzzzFs2DDhczcajZZiq3LlysLHJ/XwRsEFAEFBQQCAa9euoVq1aqo7eRERERH5A0UtmrFp0ybUqVPHqtgqKC8vDwcPHrT6JAsA4uPjcebMGVy8eBEAcODAAZhMJqvtwsLC0K5dO+zfv98jczdfs1WuXDmPjE/kCnMeeU0hERERkW8oquA6fPgwIiMjsWjRIrRp0wbR0dEYMGAADh8+DAC4cOEC9Hq9zXVYDRo0AJD/CZn5/ytXrozQ0FCb7czbeArbCElJmEciIiIi31JUS+H169dx7Ngx/PXXX3j77bcRFBSEJUuW4Pnnn8fu3buRlpYGAAgJCbF6nflr8/Pp6el2r9MKCQmxbOMqSZKKvY7L3C5W+DXm55wd093XclzPjuuJ14rcV/N/23vMnXFFzleJc/KHcWVZhkajsfra13PiuP4xJ3/LkhLn5G/jemNO5hyZv1bbMfTn98afxi2cIyXMydnX2qOogst8of/cuXPRqFEjAECzZs3QuXNnrFmzBu3bt/fxDPMZDAarrwv/Q1VUwWV+3tnn7I3pzriFxy5swYIFWLhwoc3jDRs2xLZt2xAVFYU33ngDzz//PID8VSV1Oh169uxZYiHRuXNnPPDAA5g0aRIAYPz48Th27Bi2bdvm8nzdOQ7Fje3u8d2/fz9WrFiBY8eOQa/XIzw8HL1798ZTTz0FnU5neV83b96MCRMm4Mcff0TFihXtzufWrVtYsmQJ9u3bh3/++QcVKlRA/fr10a1bNzzzzDNFzsn8PQpm1mAw2Mw5ICAAkiTBZDJZFqgx02g0CAjIP1XYa03U6XSQJAlGoxEmk8nuuIXnUHBcWZaLHBeA3XG1Wi20Wq3dcSVJsrzW3r6an7O3r+6M684xDAwMLHJfSxrXfHx9cQxFj+vqMfTke1NcvovbV0fGBbx7DM3j2puTJP17TSnPEeo6R3j7GJpMJp4jHNhXfzxHePMYmv9f6ecIWXZs1WlFFVwhISEICwuzFFtA/rVX99xzD06fPo0ePXoAADIyMqxel56eDgCWFsKQkBDcuXPHZvz09HSbNkNXmN/8gsxvVsF/tOxx5TlH3kjR37Ns2bJYuXKl1WPmRRjWrVuHmjVrWl67efNmlCtXDo888ojDczY///LLLyM7O9vt+br62oKPiTyGK1aswMyZM/HQQw/hvffeQ7ly5bB//368//77OHjwIObPn2/5ZbngOPbmYzAY8NxzzyEjIwMvvPACIiIicP36dfz+++/47rvv8OyzzxY5J/OY5hMdAKv/Lkyj0Vj9AaEwezcjNH+vgidqe9sUdSPD4p5zZ1zA9X311LhA8Td0LG5fC49rLqbNJ3tfHENfvDdA8cdQafkualwzJRzDwllS2jHkOeJfzpwjCvLGMSyYIZHj2sNzhGPj+uMxNH+6Ze93IiWeIxz5HR1QWMHVsGFDXLhwwe5zubm5qFevHnQ6HZKTk9GhQwfLc+brsszXdkVERODGjRtIS0uzKrCSk5Pdvg+XvRAUVNJzRRFdSLgzriRJ0Gg0iI2Ntfua5s2b22xfVLFQ1Pc0P3/XXXe5PV93nyv8fF5eHgICAiwnDGfndOLECcyaNQu9e/fGjBkzLI+3adMGDRs2xIQJE7B27VoMGjSo2ONm/u9ffvkFf/75J9asWYMWLVpYnu/ZsydMJpPN97c3hqcKS1+/trSPazAYHMqpGvbVX8dV4pz8LUtKnJO/jeutORkMBsunFSLHFfWcEsdV4px8PW7hHClhTq68tiBFLZrRqVMn3L59GydPnrQ8duvWLRw/fhxNmjRBYGAgWrVqhV27dlm9LjExEQ0aNECdOnUAAO3bt4dGo8Hu3bst26SlpeHAgQPo2LGjd3ZGxaKiorB8+XIAwKBBg/Dzzz/ju+++Q1RUFKKiojB//nyHxxo3bhx69uxp+XrTpk2IiorCiRMnMHToUDRv3hzdunXDli1bbF773Xff4YknnkDTpk3RunVrvP3228jKyrI8n5WVhalTp6J79+6W1tTJkyfbfELauXNnTJ06FQkJCejUqROaNm1quXn1pk2b8MgjjyAmJgYdOnTA7NmzbT4qL+yTTz6BJEkYOXKkzXO9e/dG/fr1sXr1aoePkfm6w6pVq9o8V9xfkYiIiIjI9xT1CVfXrl0RExODV199FaNHj0aZMmWwdOlSBAYG4qmnngIAvPTSSxg8eDDeeecdxMXF4eDBg9i2bRtmz55tGadGjRro27cvZs6cCY1Gg+rVq+Ojjz5CcHAwBgwY4Kvd8zuFe1rt3fX77bffxhtvvIGyZcti7NixAPKPv7vGjBmDfv364bnnnsP69esxbtw4xMTEWFak3LlzJ0aPHo0+ffpg5MiRuH79OmbNmoX09HRLFnJycmA0GjF69GhUqlQJ//zzD5YsWYKXX34Zn3zyidX32717N+666y689dZb0Gg0KFeuHD7++GO8//77eOaZZzBu3DicOXPGUnCNGTOmyLn/8ssviIqKQu3atW2e02g0ePDBB7Fy5UpcvXrVoWPVuHFjaDQaTJw4Ea+88gruu+8+Sz8/ERERESmbogoujUaDpUuXYvr06Zg8eTL0ej3uv/9+rF271vLX/fvvvx/z58/HnDlzsHHjRtSqVQvTpk1DXFyc1VgTJ05E+fLlMWvWLGRmZuLee+/Fxx9/bHf1QrKVlZWFJk2aWD02c+ZM9OrVy+qxhg0bokKFCihXrpxNq6E7nn76aTz99NMAgNjYWOzbtw+7du3Cyy+/DFmWMXPmTMTHx+O///2v5TVVq1bFCy+8gJdffhl33303KlWqhClTplieNxgMqFOnDp566imcPXsW4eHhluf0ej0SEhIs9626c+cO5s2bh6FDh+L1118HALRr1w46nQ4zZszAkCFDULFiRbtzv3r1KqKioorct1q1agHIv0G3IwVX/fr1MW7cOLz//vt49tlnodPp0LRpU8TFxeHJJ58str+YiIiISOmys7Nx+vRpNGjQoMjfa8zbNGzY0LKugL9Q3G9qlSpVwvvvv1/sNl26dEGXLl2K3SYwMBBjx461fOoiijP9mgXpz12GKS2j5A0F04QGQ1e/ltOvK1u2LNasWWP1WN26dUVNq0QFV6QsV64catWqhStXrgAAzp49i0uXLmHChAlWn8K1bNkSGo0Gx44dw9133w0A2LJlC1auXInz589btRueO3fOquBq1aqV1U2rDx06hKysLDz88MNW36Nt27bIycnB33//jZYtW4rf8SI888wziI+Px7fffouff/4ZSUlJmDZtGnbv3o1Vq1axtbCUcvV8RFQYs0QiMEfkquzsbBw7dgy1atWyuf1T4W1q167Ngqs0cPaEYrx5GxdaPQkUWpLSK7Ra1D++BdrKYU69TKPRICYmxjNzckDhTyJ1Oh3y8vIA5F/XBwCvvPKK3df+888/AICvv/4aY8eORf/+/TF69GiEhYXh+vXreOWVV5Cbm2v1msqVK1t9bf4evXv3LvZ72FO9evVinzc/V7NmzSK3sadq1aro378/+vfvD71ej8mTJ2PTpk3Yu3dviX+AIPUpaWUlIkcxSyQCc0QimHOUeugvXL9wHTW73I+QCmV8PS23seDyAm3lMNQ7+JnPPuFytthSurCwMADA5MmT0bRpU5vnq1WrBiD/Oq/GjRtj6tSplud+/vlnu2MWLqLNq1suWLDAbtufeYEWe1q0aIGvvvoK//zzj01RJcsy9u3bh7p166J69epFjlESnU6HZ599Fps2bcKZM2dYcBEREZFfy87Oxp+//4EK6/ei7JZ9OFOnDj5J7oOe7eqjXNlAyLJc4sJlSsWCywWO3uSsIFfa+vyFTqez+cTIkyIiIlCjRg2kpKRYrvOyJycnx+avbV999ZVD3yM2NhZBQUG4cuUKHnroIafmN2jQIGzduhXz5s3D9OnTrZ7bunUrkpOTMXHiRIdzdPv2bVSoUMGmp/ncuXMA7K9eSOpnvlmjvfsCEjmDWSIRmCNyhyzLCNr/Byp89ykCc/X4o1UDnGh+F7RpJ/D1rpOQJAlBQUGoUKGCr6fqEhZcTip8t2nKL4C2bNmCb7/9FlWrVkW1atXc+vSmJJIkYdy4cRgzZgyysrLw4IMPIigoCJcvX8a+ffswevRohIeHo23btpg6dSoWLlxoWXgjKSnJoe8REhKCV199Fe+//z6uXLmCli1bQqvVIiUlBXv27MH8+fOL7B++5557MGbMGLz33nu4c+cO+vTpg7Jly+LAgQNYtWoVunTpgieffNLmdXv37kX58uWtHrv77rvx999/44MPPkDv3r3RtGlTBAQE4OTJk/joo49Qq1YtpwtCUg+ej0gUZolEYI7IFbknk3FnzPto+fMx5LSNwa3nH8Ph5HSk/JOBujWDEVfgE66jR4/6erouYcFFbhs2bBguXLiAsWPHIj09HSNGjLB7DyqR4uLiEBISgiVLllg+tapduzY6dOiAKlWqAAAGDBiAixcvYs2aNVi+fDnat2+PWbNmoV+/fg59j+effx7Vq1fHxx9/jDVr1iAgIAD16tXDgw8+WGKf+vPPP48GDRrg448/xpgxY6DX6xEeHo4333wTTz75pN1FLiZMmGDz2GuvvYbevXuje/fu2LNnD1atWoXc3FzUqFEDjzzyCF544QW//WsPERERlV6mjEykzlyBtIQvoKlbHadefgStXx2Cu4OD0TjXhKup2ahRuZzlGq7U1FScOHHCx7N2jSTzzxEOO3r0KGRZRkxMjM3H5Tk5OZalxsuWLeujGZI/kGXZ0k7o6bYL5lK9ZFmGXq+HTqdj+w65hVkiEZgjcpQsy7jzxde4+fZCmO5koeLrz8DU/yHs3vstunXrhuDgYLs5Sk1Nxa5du9C9e3dUqlTJR7O3Zv7EraSF5vgJFxEREREReVzuyWTcGPshcpIOo/wjD6LKuyMQULs6srOzER0dXexy70FBQSVuo1QsuJzEv9qQCMwRicAlmEkUZolEYI6oKAXbB3XhtVFzw4co92ALy/NBQUGIiYkp9jpA8zb+iAWXC/jLMrmD+SERmCMShVkiEZgjsqdw+2ClCcMQNrwfpED7xblac8SCywWuLAtPZFbwrzfMEblKlmWYTCZoNBrmiNzCLJEIzBEVZtU++GgnVJn6CgJqF7+KtVpzxILLSVxjhERg0U4iGI1GuyteEjmLWSIRmCMCSm4fLIkac8SCSzAWZKQkzCMRERF5g7Ptg6UJCy5BzBeKZmVl+eXqKaROWVlZAHghMxEREXmOK+2DpQkLLkG0Wi3CwsJw7do1AEC5cuXYMkZ2eeM+XLIsIysrC9euXUNYWBi0Wq1Hvg8RERGVXjbtgxtno9wD9/t6WorDgstJxf2CXKNGDQCwFF1ERfHWNVxhYWGWXJL6sJAmUZglEoE5Kj2s2wezUemtYQh7UUz7oBpzxILLBUX9oixJEmrWrIlq1apBr9d7eVZE1nQ6nSpPWpRPkiS+vyQEs0QiMEelR+6JM7gxbrZH2gfVmiMWXC4o6dMJrVaryrCQGN5oKST1Y45IFGaJRGCO1M+Yfge3Zq5A2rJNHmsfVGuOWHA5iau+kQgGg4ELWZDbmCMShVkiEZgjdZJlGXc27sbNdxYJbx+0R405YsFFREREREQ2ck+cwY2xs5Hz02GU79U5v32wVjVfT8vvsOAiIiIiIiILq/bBiDpcfdBNLLiIiIiIiMjr7YOlBQsuJ6npAj7yHeaIRGCOSBRmiURgjvybUtoH1ZgjFlwuUGMQyHskSVLdxaDkfcwRicIskQjMkf9SUvugWnPEgouIiIiIqJSxtA++vQimTLYPehILLheUdB8uouLIsgyDwYCAgADmiFzGHJEozBKJwBz5F6W0Dxam1hyx4HIS78NFIjBHJAJzRKIwSyQCc6R8Nu2DX8xGuY7KWn1QjTliwUVEREREpGI27YMTX0DYC0+wfdBLWHAREREREalU7vHTuDFujuLaB0sTFlxERERERCpjTL+DW++tQNpy5bYPlhYsuJykpgv4yHcCAvijR+5jjkgUZolEYI6UQZZl3NmwCzffWeyX7YNqzJH69sgLWHSROyRJYobIbcwRicIskQjMkTLkHj+dv/rgwSOo8FhnVJ7iX+2Das0RCy4XcFl4cocsyzCZTNBoNMwRuYw5IlGYJRKBOfItq/bBBv7bPqjWHLHgcpIal6ok7zMajdBoNL6eBvk55ohEYZZIBObI+/y9fdAeNeaIBRcRERERkZ/x9/bB0oQFFxERERGRnzCm38GtGcuRtmKzX7cPliYsuIiIiIiIFE6N7YOlBQsuJ6npAj7yHbX1JpNvMEckCrNEIjBHnlOa2gfVmCMWXC5g0UXukCRJlfeYIO9ijkgUZolEYI48w6Z9cNMclOtwn6+n5TFqzZH69sgLuCw8uaPgSpfMEbmKOSJRmCUSgTkSS5Zl3Fm/Czen5LcPVp70IkKH9VV9+6Bac8SCy0lcFp5E0Ov10OnUfdIkz2OOSBRmiURgjsTIPXYaN8aVjvZBe9SYIxZcREREREQ+ZkzL+PfmxQ3rqr59sDRhwUVERERE5CP/tg8ugikzB5UnDy8V7YOlCQsuIiIiIiIfsGof7N0lv32wZlVfT4sEY8FFRERERORFhdsHa22ei6D29/p6WuQhLLicJEmSqlZNIe+TJAmBgYG+ngb5OeaIRGGWSATmyDFsHyyeWnPEgouIiIiIyMNyj53GjbEfIufno2wfLGVYcLmA9+Eid8iyDKPRCK1WyxyRy5gjEoVZIhGYo6IZ0zL+vXkx2weLpdYcseByEu/DRSKYTCZotVpfT4P8HHNEojBLJAJzZM2qfTArB5Xffim/fVDHX7+Lo8Yc8R0nIiIiIhLIqn2wT1dUfudltg+WYiy4iIiIiIgEYPsg2cOCi4iIiIjIDbLJhIz1u5A6dTHbB8kGU+AkNV3AR74TEMAfPXIfc0SiMEskQmnNEdsHxVJjjtS3R17AoovcwXu5kQjMEYnCLJEIpTFHVu2Dd9dj+6AAas0RCy4XcFl4cocsyzCZTNBoNMwRuYw5IlGYJRKhNOWI7YOeo9YcMRlO4rLwJILRaIRGo/H1NMjPMUckCrNEIpSGHNm0D055BQE1qvh6Wqqixhyx4CIiIiIiKoZN++CWeQhqF+vraZGfYMFFRERERGQH2wdJBKaFiIiIiKiQ3KN/57cP/nKM7YPkFhZcTlLTBXzkO2rrTSbfYI5IFGaJRFBLjoxpGUidvgzpH29h+6APqCVHBbHgcgGLLnKHJEmqvMcEeRdzRKIwSySCGnIkm0zIWLcTN6cuhpydi8rvvITQoWwf9CY15Mge9e0RkR/grQVIBOaIRGGWSAR/zpFV++DjD+XfvJjtgz7hzzkqiqI+s9u0aROioqJs/vfBBx9YbbdhwwZ0794dMTExePTRR7F3716bsTIyMjBhwgS0bNkSsbGxePXVV3Ht2jW35yjLMpeGJ7fIsgy9Xs8ckVuYIxKFWSIR/DVHxrQMXB83Gxe7DoUx/Q5qbZmH6ksms9jyEX/NUUkU+QnXsmXLEBwcbPm6evXqlv/evn07Jk2ahOHDh6N169ZITEzEiBEjsHbtWjRv3tyy3ahRo3D69Gm88847KFOmDObMmYNhw4bhiy++UOVHlURERETkGLYPkjcpMlVNmjRBpUqV7D43b9489OjRA6NGjQIAtG7dGn/99RcWLlyIhIQEAMChQ4dw4MABLF++HO3btwcAhIeHIz4+Hrt370Z8fLxX9oOIiIiIlCX3yF+4Pm42ctk+SF6iqJbCkqSkpODcuXOIi4uzejw+Ph5JSUnIy8sDAOzfvx8hISFo166dZZuIiAg0btwY+/fv9+qciYiIiMj3LO2DDw2DKSOT7YPkNYr8hKtnz564desWatWqhX79+mHo0KHQarVITk4GkP9pVUENGjSAXq9HSkoKGjRogOTkZISHh9tccBcREWEZg4iIiIjUz6p9MCeP7YPkdYpKWtWqVTFy5Eg0a9YMkiTh22+/xZw5c3D16lVMnjwZaWlpAICQkBCr15m/Nj+fnp5udQ2YWWhoKI4dO+bWHCVJsnshX1GPm58DUOzznnotx1XeeyPLMnQ6nd/tq5KOIcfN37bg9ahKmBPH9Y85+VuWlDgnfxvXG3My58j8tVKOYe7Rv3Bj7Gzk/nocFR5/CJXefsnyiVbBbdX83vjTuIVzpIQ5OftaexRVcHXo0AEdOnSwfN2+fXuUKVMGq1atwvDhw304M2sGg8Hqa41GY/nHSq/X22wfGBgIADAajTCZTFbPBQQEQJIkmEwmGI1Gu+OaV2wpTKfTFTmuVquFVquFLMs285UkyfJag8FgExhPjevIvgK2x9BT45r3VZIkp/fVkXGBoo+hRqOx+766s6/m+dqbk6+OoXnc4o6hr/Jd3DH0Zr4BniOc2VdAOfn25DnCE8eQ5wjH9pXnCPf3VQnnCNPtDKS9/zHurP7K6ubFer3e5ljwHGE9rr058RxhO67JZIIsO7aEvaIKLnvi4uKwYsUKnDx5EqGhoQDyl3yvWrWqZZv09HQAsDwfEhKCK1eu2IyVlpZm2cYd5jffHvObYE/BIBem0WiKvLN2wTfe2XFLem1xKzZ6atzi9hUo/hiKHtf8Prqzr86+N+Yfbo1Gw2NYwnPujAu4vq++yrcz5whZlmE0Gi0ne54jPDOuL84Rjo4ral8LZ0lpx5DniH8p+fcIc44KjuOL90Y2mZCz8WvcfHcJ5Jw8VHr7JYQOfRyaQJ1b4wKl9xzh6XELHkONRmPJUcHftZV6jnCk2AL8oOAqKCIiAgCQnJxs+W/z1zqdDnXr1rVsl5SUZFN1nj17FpGRkW7NwTymvQNc0kEv7nlPvZbjenZcV19rMplsTiai5lRajiHHtW2HUcKcOK7y5+RvWVLinPxtXG/NqfDvSN6eryOrD5bW98afxrX3u7av5+TKawtS/CqFiYmJ0Gq1uOeee1C3bl3Ur18fO3futNmmTZs2lo/cO3bsiLS0NCQlJVm2OXv2LE6cOIGOHTt6df5ERERE5DnG2xm4PparD5JyKeoTriFDhqBVq1aIiooCAOzZswfr16/H4MGDLS2EI0eOxJgxY1CvXj20atUKiYmJOHLkCNasWWMZJzY2Fu3bt8eECRMwduxYlClTBrNnz0ZUVBS6devmk30jIiIiInFkkwkZn++wtA9WnvIyQoc8ztUHSXEUlcjw8HB88cUXuHLlCkwmE+rXr48JEyZg0KBBlm169uyJ7OxsJCQkYOnSpQgPD8eCBQsQGxtrNdacOXMwffp0TJ48GQaDAe3bt8fEiROL7cUkIiIiIuWzah/s+xAqv82bF5NySbIzaxqWckePHgUAREdHO9W3SVSQLMswmUxOXWxJVBhzRKIwSySCt3JkvJ2B1OnLkL5yC3SRd6HqjNEIahdb8gvJL/jb+chcG8TExBS7HT/ucYE/BICUS5KkIlfLIXIUc0SiMEskgqdzxPbB0kGt5yOm1AWOrrlPZI/5xn5FrXZJ5AjmiERhlkgET+Yo9/Cf+e2Dvx5n+6DKqfV8xILLSezAJBEMBkOx930gcgRzRKIwSySC6BwVbB8MjKpvuXkxqZsaz0csuIiIiIhIMdg+SGrD5BIRERGRIrB9kNSIBRcRERER+ZTxdgZS/y8B6au2sn2QVIcFl5PUdAEf+Q5zRCIwRyQKs0QiuJIj2WRCxmc7cPPdxZBz9ag85RWEDunD9sFSTI3nI6bZBWoMAnmPJEmquxiUvI85IlGYJRLBlRxZtQ8+0Q2VJ7/E9sFSTq3nIxZcREREROQ1lvbBlVsQ2CgctbbOR1Db5r6eFpHHsOByAe/DRe6QZRkGgwEBAQHMEbmMOSJRmCUSwZEc2bQPTh3B9kGyotbzERPuJN6Hi0RgjkgE5ohEYZZIhOJyxPZBcpQaz0csuIiIiIjII9g+SMSCi4iIiIgEY/sg0b+YeiIiIiISJvfwn7g+9kPk/naC7YNEYMHlNDVdwEe+o8YlT8n7mCMShVkiETSZObgxfT7SV25FYGO2D5Jr1Hg+YsHlAhZd5A7mh0RgjkgUZoncZdM++O5IhA7pDSmAv2aSc9R6PuJPggu4LDy5Q5ZlGI1GaLVa5ohcxhyRKMwSuaNg+2D5xx9C5Xdegq5GVV9Pi/yUWs9HLLicpMalKsn7TCYTtFqtr6dBfo45IlGYJXKW8VY6UqcnWNoHa26dh4D7myBAhe1g5F1qPB+x4CIiIiIih8gmEzI+TcTNaUuAPIOlfRBaLfR6va+nR6RILLiIiIiIqERWqw/2656/+mD1ygDYAURUHBZcRERERFSkwu2DXH2QyDksuJykpgv4yHfU1ptMvsEckSjMEtlTVPtgUasPMkckghpzxILLBSy6yB2SJKnyZELexRyRKMwS2VNc+6A9zBGJoNYcseByAZeFJ3fIsmzJEHNErmKOSBRmiQoy3kpH6v8tRfqqL/PbB79cgKA2zUp8HXNEIqg1Ryy4nMSLQkkEg8Ggyjupk3cxRyQKs0SyyYSMtdtxc9pHgL7k9kF7mCMSQY05YsFFREREVIo52z5IRM5hwUVERERUCrnaPkhEzmHBRURERFSKiGgfJCLH8SfLSWq6gI98hzkiEZgjEoVZKj082T7IHJEIaswRCy4XqDEI5D2SJKnuYlDyPuaIRGGWSgdPtw8yRySCWnPEgouIiIhIpWzaB6e9itDnH2P7IJEX8afNBbwPF7lDlmUYDAYEBAQwR+Qy5ohEYZbUK/fwn7j+5izk/n4SFfo9jMqTh3ts9UHmiERQa45YcDmJ9+EiEZgjEoE5IlGYJXWxah+8JwK1vlqIoNZNPf59mSMSQY05YsFFREREpAJsHyRSJv4EEhEREfm5nD9O4cbYD73SPkhEzmHBRUREROSnjKlpSP2/BKSv9m77IBE5jgWXk9R0AR/5TgDbO0gA5ohEYZb8T+H2wSr/fRUhz/m2fZA5IhHUmCP17ZEXsOgid0iSxAyR25gjEoVZ8j827YNvv4SAapV8OifmiERQa45YcLmAy8KTO2RZhslkgkajYY7IZcwRicIs+Q8ltw8yRySCWnPEgstJalyqkrzPaDRCo9H4ehrk55gjEoVZUrb89sFtuDltqWLaB+1hjkgENeZIWT+pRERERGRRsH0wuP/DqDTZ9+2DROQcFlxERERECmPdPtgAtbYtRFArZbQPEpFzWHARERERKYSlffDdjwCjSbHtg0TkOP70OklNF/CR76itN5l8gzkiUZglZfD39kHmiERQY45YcLmARRe5Q5IkVd5jgryLOSJRmCXfU0P7IHNEIqg1R+rbIy/gsvDkjoIrXTJH5CrmiERhlnxHTe2DzBGJoNYc+d9PtI9xWXgSQa/XQ6fT+Xoa5OeYIxKFWfK+nEMncWPsbOQe8s/2QXuYIxJBjTliwUVERETkJcbUNKT+dynSP/nKb9sHicg5LLiIiIiIPEw2mZCxZhtuTvtf++D/vYaQZ3v5ZfsgETmHP+VEREREHmTVPjggDpUmDff79kEichwLLiep6QI+8h3miERgjkgUZskzSlv7IHNEIqgxRyy4XKDGIJD3SJKkuotByfuYIxKFWRJPNhqRsXZ7qWofZI5IBLXmSL0/+URERERelnPoJG68+SFy/zjF9kEiAsCCyyW8Dxe5Q5ZlGAwGBAQEMEfkMuaIRGGWxDDevI2b/12KjDXbENikIWpvX4SyLWN8PS2vYY5IBLXmiAWXk3gfLhKBOSIRmCMShVlyXWlsHywKc0QiqDFHpe9sQERERCQA2weJyBEsuIiIiIicUNrbB4nIOSy4iIiIiBwgG41IX7MNqf9dWurbB4nIcTxDOElNF/CR7wTwH2cSgDkiUZilkuX8fiL/5sXm9sHJLyGgakVfT0tRmCMSQY05Ut8eeQGLLnKHJEnMELmNOSJRmKXisX3QMcwRiaDWHLHgcgGXhSd3yLIMk8kEjUbDHJHLmCMShVmyz6Z9cPqo/PZBrdbXU1Mk5ohEUGuOWHA5SY1LVZL3GY1GaDQaX0+D/BxzRKIwS9bYPuga5ohEUGOOFLs3mZmZ6NixI6KionD06FGr5zZs2IDu3bsjJiYGjz76KPbu3Wvz+oyMDEyYMAEtW7ZEbGwsXn31VVy7ds1b0yciIiI/Y7x5G9den4lLDw+HbDCi9vZFqDZ/AostInKLYguuRYsWwWg02jy+fft2TJo0CXFxcUhISEDz5s0xYsQI/PHHH1bbjRo1Cj/88APeeecdfPDBBzh79iyGDRsGg8HgpT0gIiIifyAbjUhbtRUX2jyNzK17UWX6KNT5JoHXahGREIpsKTxz5gw+/fRTjB07Fm+//bbVc/PmzUOPHj0watQoAEDr1q3x119/YeHChUhISAAAHDp0CAcOHMDy5cvRvn17AEB4eDji4+Oxe/duxMfHe3V/iIiISJlyfj+Rf/Piw38i+Mn4/JsX8xMtIhJIkZ9wTZs2DQMGDEB4eLjV4ykpKTh37hzi4uKsHo+Pj0dSUhLy8vIAAPv370dISAjatWtn2SYiIgKNGzfG/v373Zqbmi7gI99RW28y+QZzRKKUxixZtQ8aTaiduBjV5o1nseWG0pgjEk+NOVLcHu3cuRN//fUXXnnlFZvnkpOTAcCmEGvQoAH0ej1SUlIs24WHh9sURxEREZYx3MGii9whSRICAgKYI3ILc0SilLYsWbUPflmgfbBFtK+n5tdKW47IM9SaI0W1FGZnZ2PGjBkYPXo0KlSoYPN8WloaACAkJMTqcfPX5ufT09MRHBxs8/rQ0FAcO3bM7XmaTCabIEiSVOQKhuZti3veU6/luMp7b8y3FSjq9gJK3VclHUOO+++25nuWKGFOHNc/5uRvWXLntYWfM68+mGduH5z4IrT/+0Sr4LZKeW9EjeuNORU+fmo7hv783vjTuIVzpIQ5OftaexRVcC1evBiVK1fG448/7uupFEmWZej1eqtflDUajeWu2Hq93uY1gYGBAPKXuTSZTFbPmat4k8lks0iIeVzz9yxMp9MVOa5Wq4VWq4UsyzYLhUiSZHmtwWCwCYynxnVkXwHbY+ipcc37KkmS0/vqyLiA/WOo0WhgMpmg1WqFHkPzfO3NyVfH0DxuccfQV/ku7hh6M9+Aa+cIWZZhNBoRFBTEc4TKzhGeOoZFnSPM36dcuXIujesP5whjahrSpi9D5mc7oLunAWonLkbZFtHQ6/U2Y6vlHFFwXG+cI8zbBQQEFDtfniMcHxdQxjnC3XGdOYZGo9GSI0mSFP97hCw7dm9exRRcly5dwooVK7Bw4UJkZGQAALKysiz/n5mZidDQUAD5S75XrVrV8tr09HQAsDwfEhKCK1eu2HyPtLQ0yzbuMAejqOeKUjDIhWk0miJ7Vgu+8c6OW9JrzT8A3hy3uH0Fij+Gosc1v4/u7Kuz740sy5ZPSXkMfZdvd37mPPXeOHOOKPxXQJ4jPDOuL84Rjo4ral/t/eIkYlwzX54jYDIhe20iUv9vKSDLqDx9FEKeeRSa/+2jms8RBXnjHGHOUcFtlZBvT49bGs4Rnh634DE0v7bw79pK/T3CkWILUFDBdfHiRej1erzwwgs2zw0ePBjNmjXDrFmzAORfoxUREWF5Pjk5GTqdDnXr1gWQf61WUlKSTdV59uxZREZGuj1X80fl9h4v6XWuPOfOazmuZ8d1d06e2J/SdgxL87iF/zFSwpw4rvLn5G9ZcvW1Ob8dz7958eE/EfxUD1Sa+KLNghhK21elHUNnxzX/u2Z+TOnzVcK4SpyTr8ctnCMlzMmV1xakmIKrcePGWL16tdVjJ0+exPTp0zFlyhTExMSgbt26qF+/Pnbu3ImuXbtatktMTESbNm0sH2F37NgRixYtQlJSEtq2bQsgv9g6ceIEhg4d6r2dIiIiIrdkZ2fj9OnTaNiwIYKCgkp83njzNm5O+wgZa7YhMPpuS/sgEZGvKKbgCgkJQatWrew+16RJEzRp0gQAMHLkSIwZMwb16tVDq1atkJiYiCNHjmDNmjWW7WNjY9G+fXtMmDABY8eORZkyZTB79mxERUWhW7duXtkfIiIicl92djaOHTuG2rVrWwqugkWW+flaNWogb90upP43v30wdNoI/NOqEapENfDxHhBRaaeYgstRPXv2RHZ2NhISErB06VKEh4djwYIFiI2Ntdpuzpw5mD59OiZPngyDwYD27dtj4sSJxfZiOqKkNjCikpj7hZkjcgdzRKL4W5bS7+Tir7NXcOKPw6hduzYAoPy5q8h44g0Yj5+xtA+ma2Uc27ULtevVtfvJGInlbzkiZVJrjiTZmTUNS7mjR48CAGJiYnw8EyIiotIhNTUVW7ZsQaNGjaAJCMS2H87hnyupqBOcgU4xjVF53Tco9/UvQKNwGN4cjpqd7kNIhTJITU3Frl270L17d1SqVMnXu0FEKuRobeB3n3ApgaNLQBLZY17OW6vVMkfkMuaIRPGHLN24cQN79uwBAGiNMuqWMeHuPy6h2pJtAIBfO9+DY/d3wIXv/0Td05fRs119mAx5yM7O9uW0SxV/yBEpn1pzxILLSfxAkEQw34eLyB3MEYmi9CxVqVLF8gnXT+t/wv3bvkbNm6lIblIHv7WOQG5QIDSZZ1C/nASkAV/vOgkAKFOmjI9nXrooPUfkH9SYIxZcREREpGhBQUGIrFYTpgXrUHXtdhga3oU/BrRHw97d0DEzE3/88QcuZ4ch5Wou6tYMRtz/PuE6deqUr6dORMSCi4iIiJRLNhpR9cAxpE9aDQlAlfdeh+GR9sj75hvL/TfPnz+Pno92Qo6xDGpULme5huv8+fO+nTwREVhwERERkULl/HYcmWM+QPix0wjq3x3V3nkF2ioVkZqaatkmKCgI0dHRqFo5lKsREpEiseBykpou4CPfUVtvMvkGc0SiKC1Lxhu38m9evHY7AmNsb15sLrKCgoIQFBRkd4WwgtuQdygtR+Sf1JgjFlwuYNFF7pAkSZUnE/Iu5ohEUVKWZKMR6au/ROr/JQCyjCozX0fI4EchFZpfUUWWs9uQOErKEfkvteaIBZcLuCw8uUOWZUuGmCNyFXNEoiglSzm/Hsf1sR8i78hfCH66BypPfBHaKhV9Nh9yjlJyRP5NrTliweUkLgtPIhgMBuh0Ol9Pg/wcc0Si+DJLNu2DO5ag7P1NfDIXcg/PSSSCGnPEgouIiIi8ztH2QSIif8eCi4iIiLyK7YNEVJo4XXBdvHgRe/bswe+//44zZ87g1q1bkCQJFStWREREBO6991507tzZcm8MIiIiIuB/7YPvfoSMT7cjsGkk2weJqFRwuODau3cvVqxYgd9++w2yLKNevXqoU6cOIiMjIcsy0tPTcerUKezevRszZszAfffdhyFDhqBTp06enL/XqekCPvIdjUbj6ymQCjBHJIqnsyQbjUhf9SVS/28pIElsH1QpnpNIBDXmyKGCq1+/fjh16hS6dOmCOXPmoG3btqhQoYLdbe/cuYMffvgBu3btwqhRo9CoUSOsW7dO6KR9jUUXuUOSJAQEsJuX3MMckSiezhLbB0sHnpNIBLXmyKE9atWqFRYtWoQqVaqUuG2FChXQvXt3dO/eHdevX8fq1avdniQRERH5F7YPEhHlk2Suc+6wo0ePQpZlxMTE8FMucpksy9Dr9dDpdMwRuYw5IlFEZ6lw+2ClCcPYPlgK8JxEIvhbjo4ePQoAJd5kXX2f2REREZFPsH2QiMiWwwXX8ePHnR68SRO2DhAREakd2weJiIrmcMH1+OOPO/XRniRJOHHihEuTIiIiIuWzWX3w/f8gZNAjbB8kIirA4YJr+vTpJW6Tk5OD9evX4+TJk25NioiIiJQt55dj+e2DR/9G8MCe+e2DlcN8PS0iIsVxuODq3bt3kc/l5eXh888/R0JCAq5fv44WLVpg5MiRQiaoNP5wAR8pn06n8/UUSAWYIxLFmSyxfZCKwnMSiaDGHLm1aEZeXh4+++wzLFu2DNevX0fLli3x4YcfokWLFqLmp0gsusgdzA+JwByRKI5mie2DVByek0gEtebIpYIrLy8Pn376KZYvX47r16+jVatWpaLQMpNlWbWBIM+TZRlGoxFarZY5IpcxRySKI1li+yCVhOckEkGtOXKq4MrNzbV8onXjxg20atUKs2fPxv333++p+SkOb1tGIphMJmj5V2FyE3NEohSVJcP1W0h9dwkyPktEmWZRqL1zCcrex/ZBso/nJBJBjTlyuOBauXIlli1bhps3b6J169aYO3cu7rvvPk/OjYiIiHxANhqRvnIrUqcn5LcPfjAGIQN7sn2QiMgFDhdcM2bMgCRJaNy4MRo0aIAdO3Zgx44dxb5m4sSJbk+QiIiIvIftg0REYjnVUijLMk6cOOHQ/bUkSWLBRURE5CeM128hddpHbB8kIhLM4YLr1KlTnpyH31DTBXzkO2rrTSbfYI5IBNloROaqL3H7veVsHyS38JxEIqgxR24tC19asegid0iSpMqTCXkXc0QiWNoHj53Obx986wW2D5JLeE4iEdSaIxZcLuCy8OQOWZYtGWKOyFXMEbnDavXB5o1QK3Exyt53D7NELuM5iURQa45cLri2bt2KL774AhcvXkRaWprNcumSJOG3335ze4JKw2XhSQSDwaDKO6mTdzFH5Cx7qw8GP90DBpPJ11MjFeA5iURQY45cKrjef/99rFixAtWrV0d0dDSCg4NFz4uIiIgEyvn5KK6PnY2849btg7IsAyy4iIg8xqWCa8OGDXjwwQexcOFCaDQa0XMiIiIiQQq3D9beuQRl773H19MiIio1XG4pfOCBB1hsERERKZRV+6BGw9UHiYh8xKWK6cEHH1Tl9VmOUNMFfOQ7zBGJwBxRUXJ+PoqLXYfhxvg5KP9oJ9RLWovQZ3oVWWwxSyQCc0QiqDFHkuzCKhAZGRkYPnw4oqKi8Pjjj6NmzZp2P+0KCwsTMUfFOHr0KAAgJibGxzMhIiKyZbh+C6lTFyPj8x0o07wRqrw3mu2DREQe4mht4FJLYVBQEGJjY7F8+XJ89tlnRW538uRJV4YnIiIiJ8gGw//aB5cBWg2qznoDwU/3YPsgEZECuFRwTZ06FRs2bECzZs3QrFmzUrdKIe/DRe6QZRkGgwEBAQHMEbmMOSKzolYfdBSzRCIwRySCWnPkUsG1Y8cO9OrVCzNmzBA9H8XjfbhIBOaIRGCOSrfC7YPurD7ILJEIzBGJoMYcuVRwBQQEoFmzZqLnQkRERCVg+yARkX9xaZXCHj16YO/evaLnQkRERMXIPngkf/XBCXNR4bHOqPfTpwgZ/CiLLSIiBXPpE664uDhMmzYNL7zwgmWVQq2dk32TJk3cniAREVFpZ7iWmt8+uG5nfvvgro9QNraxr6dFREQOcKngevrppwHkr0L4/fff2zxvXlRCjasUqukCPvKdgACX7zlOZMEcqZ+32geZJRKBOSIR1Jgjl/Zo+vTpoufhV1h0kTskSWKGyG3MkfplHzyCG2NnI+/EGYQMegSV3noB2kqhwr8Ps0QiMEckglpz5FLB1bt3b9Hz8CtcFp7cIcsyTCYTNBoNc0QuY47Uy9vtg8wSicAckQhqzZH6PrPzMDUuVUneZzQaodG4tGYNkQVzpC6ywYD0j7cgdcZyr68+yCyRCMwRiaDGHDm0N5MnT0ZKSorTg1+4cAGTJ092+nVERESliWX1wbfmcfVBIiKVcegTrn/++QdxcXFo3bo14uPj0aZNG9SsWdPuthcvXkRSUhJ27NiBgwcPol27dkInTEREpBZcfZCISP0cKrgSEhLw22+/YcWKFZg8eTKMRiPCwsJQu3ZthIaGQpZlpKWl4eLFi0hPT4dWq0XHjh2xatUq3H///Z7eByIiIr/iy/ZBIiLyLoev4brvvvtw3333ITU1FXv37sUff/yB5ORkXLlyBQAQFhaGbt26oXnz5njwwQdRuXJlj03al9R0AR/5jr371hE5iznyT95afdAZzBKJwByRCGrMkSRzFQiHHT16FAAQExPj45kQEZG/sWofjG2MKu+NZvsgEZEfc7Q24CqFLuCy8OSOgn/jYI7IVcyR/7BpH/zwDQQ/3ROSQlbhYpZIBOaIRFBrjlhwOYkfCJIIer0eOp3O19MgP8ccKV/2T0dwY9yHyDuRjJDBj6LShGE+bx+0h1kiEZgjEkGNOWLBRUREJJjhWipuTlmMO+vz2wdr716Kss0b+XpaRETkAyy4iIiIBLG0D05fBgRoFdc+SERE3seCi4iISAB/aR8kIiLvYsHlJDVdwEe+wxyRCMyRMqihfZBZIhGYIxJBjTlyuMfhww8/xKlTpzw5F7+hxiCQ90iSBJ1OxxyRW5gj35MNBtxeuhEprZ9C1jdJqPrhm6i9c4lfFlvMErmLOSIR1JojhwuupUuX4u+//7Z8fevWLTRu3BhJSUkemRgREZFSZf90BBe7DsXNifNQ4fGuqJe0FiGDHuG1WkREZMOtlsLSukQ678NF7pBlGQaDAQEBAcwRuYw58g01tA8WxiyRCMwRiaDWHPEaLieV1iKTxGKOSATmyHtkgwFpK7bg1oxlgC4AVT98E8FP91DNJ1rMEonAHJEIaswRCy4iIqJiWK0++MyjqDSeqw8SEZHjnCq4Ll26hOPHjwMAMjIyAADnz59HSEiI3e2bNGni1GT27duHhIQEnD59Gnfu3EH16tXRtWtXjBgxAsHBwZbtvv32W8yZMwdnz55FrVq18MILL+Dxxx+3GisvLw+zZ8/Gl19+iczMTMTGxmLSpEmIiIhwak5ERFQ6WbUP3quO9kEiIvI+SXbwc7tGjRrZ9FIWdS2T+fGTJ086NZmtW7fizz//RLNmzRAWFoa///4b8+fPR5MmTbBixQoAwK+//orBgwejb9++iI+Px08//YQlS5Zgzpw5ePjhhy1jTZ48GYmJiRg3bhyqV6+OJUuWICUlBdu3b7cq3pxx9OhRyLKMmJgYVfWVknfJsgy9Xq/KVXjIe5gjzyncPlh54ouqah8sjFkiEZgjEsHfcnT06FEAQExMTLHbOfwJ1/Tp092bkQN69epl9XWrVq0QGBiISZMm4erVq6hevToWL16Mpk2bYurUqQCA1q1bIyUlBfPmzbMUXFeuXMHGjRvx9ttvo2/fvgDyD0SnTp3w+eefY9iwYS7P0R/efFK+gAB285L7mCPxspMO48b42f+2D054AdqK9rs41IRZIhGYIxJBjTlyeI969+7tyXkUKSwsDACg1+uRl5eHgwcPYsyYMVbbxMfHY9u2bbh48SLq1KmDAwcOwGQyWX3iFRYWhnbt2mH//v1uFVwAiy5yjyRJzBC5jTkSy3D1Jm5OXYw763eVuvZBZolEYI5IBLXmSJH9EUajEbm5uTh+/DgWLlyIzp07o06dOrhw4QL0er3NdVgNGjQAACQnJ1v+v3LlyggNDbXZzryNO9S4egp5jyzLMBqNzBG5hTkSw3Lz4jZPI+ubn/JvXrzD/25e7A5miURgjkgEteZIkZ/ZderUCVevXgUAdOjQAbNmzQIApKWlAYDNIh3mr83Pp6en271OKyQkxLKNq2RZthsCSZKKDIe5Ui/ueU+9luMq770xn0yK+guOUvdVSceQ4/57r5LAwEDFzMnfxs3+6TBujpuDvJPJCB78KCpNGGZpHzRvWxryrfQsKXFO/jauN+ZkzpFOpxM6rqfmq5RxlTgnX45bOEdKmJOzr7VHkQXX0qVLkZ2djdOnT2Px4sUYPnw4Pv74Y19Py0Kv11v9sqzRaCz9pnq93mZ78z9iRqMRJpPJ6jnzjd1MJhOMRqPVc+ZxzRcQFmYOo71xtVottFqtJbgFSZJkea3BYLAJjKfGdWRfAdtj6KlxzfsqSZLT++rIuID9Y6j534X3oo+heb725uSrY2get7hj6Kt8F3cMvZlvwLVzhLlwN/83zxGOj2u8lorb05Yi64uvERjbCLV3L0WZZlHQ6/UwFRrbF+cITx3Dos4RhQsuniPUcY4oOK43jmHB7Yqbrz+cIxwdFygd5wh3x3XmGBqNRss+SZKk+HOELNtfQLAwRRZcjRrlt3LExsYiJiYGvXr1wtdff42GDRsC+HdJerP09HQAsLQQhoSE4M6dOzbjpqen27QZuqK4lVMKVuSFFQxyYRqNxvKLeGEF33hnxy3ptcVdmOipcYvbV6D4Yyh6XPP76M6+OvveyLIMk8nEY+jAc+6MC7i+r756b5w5RxT8B4DnCMfGlUwmZH28BanvrYCkC0CV2W8i+Ml4aP73j65SzhGOjivqGNr7xUnEuGY8Rzg+LuC/v0eYc1RwWyXk29PjloZzhKfHLXgMza8t/Lu2Us8RjhRbgEILroKioqKg0+lw4cIFdO7cGTqdDsnJyejQoYNlG/N1WeZruyIiInDjxg2kpaVZFVjJyclC7sMlSfYv6CvpoBf3vKdey3E9O667c/LE/pS2Y1iaxy38j5ES5qTUcbOTDuffvPjkWYQ82yv/5sUFVh8s7flWcpaUOCd/G9dbczL/u2Z+TOnzVcK4SpyTr8ctnCMlzMmV1xakyEUzCjp8+DD0ej3q1KmDwMBAtGrVCrt27bLaJjExEQ0aNECdOnUAAO3bt4dGo8Hu3bst26SlpeHAgQPo2LGjW/Nx5uASFaW4v/4QOYo5Kpnh6k1cfWUaLj86AlLZMqi9eymqzvxPqVjq3RnMEonAHJEIasyRW59w6fV6JCcnIyMjw+6FYy1atHBqvBEjRiA6OhpRUVEoW7YsTp06heXLlyMqKgpdu3YFALz00ksYPHgw3nnnHcTFxeHgwYPYtm0bZs+ebRmnRo0a6Nu3L2bOnAmNRoPq1avjo48+QnBwMAYMGODOLgNg0UXukSRJlfeYIO9ijoonGwxIW74Zt95bDugCUHX2WAQ/Fa/amxe7g1kiEZgjEkGtOZJkZ5bY+B+TyYRZs2bh008/RU5OTpHbnTx50qlxly5disTERFy4cAGyLKN27dp46KGHMGTIEFSoUMGy3Z49ezBnzhycPXsWtWrVwgsvvGC5wbFZXl4eZs+eja1btyIzMxP33nsvJk6caFlC3hXmu0lHR0ez6CKXFb72hsgVzFHRSmofJGvMEonAHJEI/pYjc20QExNT7HYuFVyLFi3CvHnz0L9/f9x333148803MWbMGISEhODTTz+FJEl444030LZtW9dmr1BHjx6FLMuIiYnxixCQMplX0ylu8RWikjBHtgxXb+LmlEW4s2E3ytx3D6q+9zrKNIvy9bQUj1kiEZgjEsHfcuRoweVSb8XmzZsRFxeHKVOmWBavaNKkCfr164f169dDkiT89NNPrgxNRETkFNlgwO0l6/NvXvztQVSdPRa1Exez2CIiIkVwqeC6cuUKWrduDeDfey3k5eVZvn700UexdetWQVMkIiKyL/vHP3CxyxDcnLwAFfo+hHpJnyJkYE9eq0VERIrh0lVpYWFhyMrKAgCUL18eFSpUQEpKitU25ntjERERiVa4fbDO1wn8RIuIiBTJpYLrnnvusfQsAkCrVq2watUqNG7cGLIsY/Xq1YiK4j98REQklmwwIG3ZJtyauQII5OqDRESkfC79C9WvXz/k5eVZ2ghHjx6N9PR0DBw4EAMHDkRmZibGjRsndKJKUdLNaolKIkmS31wMSspVGnPE9kHPKI1ZIvGYIxJBrTlyaZVCezIyMnDw4EFotVrExsYiLCxMxLCK4uhKJEREJI7hyg3cnLqYqw8SEZGiOFobCLuzWHBwsOXmxGony7LqKm/yHlmWYTQaodVqmSNyWWnIkbl9MPW95ZDK6FB1zjgEPxnHT7QEKw1ZIs9jjkgEtebIpX+1unTpgv79+yM5Odnu89988w26dOni1sSUStAHglTKmUwmX0+BVEDNOcr+8Q9c7JzfPhj8RPf89sGne7DY8hA1Z4m8hzkiEdSYI5f+5bp06RKOHz+OJ554At98843N81lZWbh8+bLbkyMiotLFcOUGrr78Li73GgmpXFnU+ToBVWe+Dm3FEF9PjYiIyCUu/6lw/PjxaNGiBUaOHIk5c+YInBIREZU25psXXzDfvHjOON68mIiIVMHla7hCQkKwZMkSLFiwAIsWLcKJEycwa9YsBAcHi5wfERGpXPaPf+DGuNnIO3UWIc8+hkrjh/ITLSIiUg23m+FHjBiBJUuW4PDhw+jbty/+/vtvEfNSLDVdwEe+ExAgbL0aKsX8PUeGKzdw9aWp+e2D5YPYPuhD/p4lUgbmiERQY46EXH3csWNHbNy4EUFBQejXrx/27NkjYljFYtFF7pAkCRqNhjkit/hzjmS9AbeXrMtvH9z7c3774PZFbB/0EX/OEikHc0QiqDVHwpZ7qlu3LtatW4du3bph165dooZVJK5USO6QZRkmk4k5Irf4a47+vXnxQq4+qBD+miVSFuaIRFBrjlz6zG716tVo2LChzeNlypTBe++9h/j4eKSmpro9OSVSWwDINwwGA3Q6na+nQX7On3JkuHIDN6cswp2NX6PM/U1Q5+sEfqKlIP6UJVIu5ohEUGOOnC64srOzMWPGDDzxxBN48skn7W7zwAMPuD0xIiLyf7LegLTlXyD1vRX5Ny+eOw7BA3jzYiIiKj2cLriCgoJw8eJF1fVWEhGRWJbVB/889+/qg2FcyZaIiEoXl/7E2KFDBxw4cED0XIiISAWsVh+sUC5/9cH3RrPYIiKiUsmla7hefvllvPbaa3jjjTfQv39/1K1bF2XKlLHZLiwszN35KQ4/2SMRNGynIgGUliO2D/ovpWWJ/BNzRCKoMUcuFVw9evQAAJw+fRrbtm0rcruTJ0+6NiuFY9FF7pAkSZX3mCDvUlqOsn84hOvjZkP/13m2D/oZpWWJ/BNzRCKoNUcu7dErr7zCooPIDbIs82eI3KaEHFmtPtgiOn/1waaRPp0TOU8JWSL/xxyRCGrMkUsF18iRI0XPw2/IsqzKIJD3yLIMvV4PnU7HHJHLfJ0jq/bBsoFsH/Rjvs4SqQNzRCKoNUdCPrPLyckBAJQtW1bEcEREpGBsHyQiInKcywXX5cuXMX/+fOzbtw+3bt0CAFSsWBEPPPAARowYgdq1awubJBER+Z7hyg3cfGcR7nzB9kEiIiJHuVRwnTlzBk899RQyMjLQtm1bNGjQAACQnJyMrVu3Yu/evfj0008REREhdLJEROR9st6AtGUb89sHg8qg6rzxCO7/MNsHiYiIHOBSwTVr1ixoNBps3rwZUVFRVs/99ddfePbZZzFr1iwsXLhQyCSJiMg32D5IRETkHpcKrl9++QXPPfecTbEFAJGRkXj66aexcuVKd+emSGq6gI98R6fT+XoKpAKezBHbB0sXnpNIBOaIRFBjjlwquAwGQ7ELZAQFBcFgMLg8KaVj0UXuYH5IBE/liO2DpQ/PSSQCc0QiqDVHLv0L2rhxY2zYsAEZGRk2z925cwcbN27EPffc4/bklEqWZV9PgfyYLMswGAzMEbnFEznK/uEQUjo/j5vvLEbwgDjUS/oUIU/Gs9hSOZ6TSATmiERQa45cvg/XsGHDEBcXhz59+qB+/foAgLNnz2Lz5s24ffs2Jk+eLHKeiqG2AJBvmEwmaLVaX0+D/JyoHBmu3MDNtxfizqZv8tsHv1mGMjF3C5gh+Quek0gE5ohEUGOOXCq42rRpg6VLl2LmzJlYunSp1XONGzfG+++/j9atWwuZIBEReYasNyAtYSNSZ7J9kIiIyFNcvg9X27ZtsWXLFly/fh2XL18GANSqVQtVq1YVNjkiIvKM7B8O4frYD6H/+wJCnnsMlcZx9UEiIiJPcLjg+vDDDxEfH49GjRpZPV61alUWWUREfqJg+2DZFtGozvZBIiIij3K4b2Tp0qX4+++/LV/funULjRs3RlJSkkcmplRqXT2FvEttvcnkG87kSNYbcHvR57jQ+ilk7f8VVeeNR61tC1lsEQCek0gM5ohEUGOOXG4pBErvAhIsusgdkiSp8mRC3uVMjmzaB8cPhTaU7YOUj+ckEoE5IhHUmiO3Cq7SSpZlFl3kMlmWLRlijshVjuSI7YPkCJ6TSATmiERQa45YcDmptH6qR2IZDAZV3kmdvKuoHHH1QXIWz0kkAnNEIqgxR04VXJcuXcLx48cBwHLT4/PnzyMkJMTu9k2aNHFzekRE5Ay2DxIRESmLJDv4kU2jRo1sPtorqrXO/PjJkyfFzFIhjh49ClmWERMTo6qPOcm7ZFmGXq+HTqdjjshlhXNUuH2wynuvs32QHMJzEonAHJEI/pajo0ePAgBiYmKK3c7hT7imT5/u3oyIiEg4WW9A2rIv/m0fnD8Bwf26s32QiIhIIRwuuHr37u3JefgNf6i2SfmYIxIh98c/cGXifOj/voDQ53uj4rghbB8kl/CcRCIwRySCGnPERTNcoMYgkPdIkqS6i0HJuwz/XM9vH9y8h6sPktt4TiIRmCMSQa05YsFFROQnbFYfZPsgERGR4rHgcgHvw0XukGUZBoMBAQEBzBE5LPvA77g+bralfTBs7POQywcBzBC5ieckEoE5IhHUmiMWXE7ifbhIBOaIHGXVPtgyxtI+aF7JiUgEnpNIBOaIRFBjjlhwEREpkKw3IG3pBqS+/zE05cqi2oK3UKFfd1X9xY+IiKg0YMFFRKQwhdsHufogERGR/2LBRUSkEEW1DxIREZH/YsHlJLbzkAhqXPKUXOdq+yBzRKIwSyQCc0QiqDFHLLhcwKKL3MH8UEFW7YND+qDi2Ocdah9kjkgUZolEYI5IBLXmiAWXC7gsPLlDlmWYTCZoNBrmqBSzaR/csxxlohs6/HrmiERhlkgE5ohEUGuOWHA5SY1LVZL3GY1GaHiz2lJJ5OqDzBGJwiyRCMwRiaDGHLHgIiLykqzvf8ONcbOhP53iVPsgERER+S8WXEREHmb45zpuTl6AO1u+dal9kIiIiPwXCy4iIg+R8/S4vXQDbr2/EpryvHkxERFRacSCy0n8RYlE0Gq1vp4CeZg32geZIxKFWSIRmCMSQY05YsHlAhZd5A5JklR5MqF8Vu2DrZqi+p53PNI+yByRKMwSicAckQhqzRELLhdwWXhyhyzLlgwxR+ph3T4YhGoL30KFJzzXPsgckSjMEonAHJEIas0RCy4ncVl4EsFgMKjyTuqlVdb+X3Fj3Bzoz6QgdOjj+e2DIRU8/n2ZIxKFWSIRmCMSQY05YsFFROQiw+VruDF5ITK3/q99cKln2geJiIjIf7HgIiJykrfbB4mIiMh/seAiInKCr9oHiYiIyD9pfD2Bgnbs2IGXXnoJHTt2RPPmzdGrVy9s3LjR5rqpDRs2oHv37oiJicGjjz6KvXv32oyVkZGBCRMmoGXLloiNjcWrr76Ka9euuT1H/gWbRGCO/I/h8jVcGfo2/nl8NLSVQlHn2+Wo8t9XfVpsMUckCrNEIjBHJIIac6SogmvlypUICgrCuHHjsHjxYnTs2BGTJk3CwoULLdts374dkyZNQlxcHBISEtC8eXOMGDECf/zxh9VYo0aNwg8//IB33nkHH3zwAc6ePYthw4bBYDC4PU81BoG8R5Ik6HQ65shPyHl63Jq/FhfaDETOj3+g2sK3UOurBSjTxLfXajFHJAqzRCIwRySCWnMkyQpadi81NRWVKlWyemzSpElITEzEL7/8Ao1Gg+7duyM6OhqzZs2ybDNgwAAEBwcjISEBAHDo0CEMGDAAy5cvR/v27QEAycnJiI+Px4cffoj4+HiX5nf06FEAQExMjEuvJyL/wvZBIiIiKoqjtYGiPuEqXGwBQOPGjXHnzh1kZWUhJSUF586dQ1xcnNU28fHxSEpKQl5eHgBg//79CAkJQbt27SzbREREoHHjxti/f7/b81RQjUp+SJZl6PV65sgHsrOzcfToUWRnZxf7uBLbBwtjjkgUZolEYI5IBLXmSFEFlz2//fYbqlevjgoVKiA5ORkAEB4ebrVNgwYNoNfrkZKSAiD/06zw8HCbjyMjIiIsY7hKbQEg32COfCM7OxvHjh2zFFbmQuvWrVs4duwYstLSi2wfLKpY8yXmiERhlkgE5ohEUGOOFL1K4a+//orExESMHTsWAJCWlgYACAkJsdrO/LX5+fT0dAQHB9uMFxoaimPHjrk9L3tBkCSpyICYC7/invfUazmu8t4b82P+tq9KOoaujmu+gz0ApGXk4O9zV3Dij8No364tgk+lIH3OKJjO/4OQIb1R6c3nofnfJ1qyLCMrKwvHjh1D7dq1UbZsWa/Mt7jXFtwXZ1/rqTlxXP+Yk79lSYlz8rdxvTEnc47MX6vtGPrze+NP4xbOkRLm5Oxr7VFswXXlyhWMHj0arVq1wuDBg309HSt6vd7q0zONRoOAgADLc4UFBgYCAIxGI0wmk9VzAQEBkCQJJpMJRqPR6jnzuOaPVwsz34Xb3rharRZarRayLNssFGK+IBHIv5t34cB4alxH9hWwPYaeGte8r5IkOb2vjowL2D+GGk3+B8uij6F5vvbm5KtjaB63uGMoOt85OTk4f/48GjZsaBnfzNye/N3+7/H7WRNS/rmNezSXkbH+BzT+6Rjk5lGo+NViXKtaDRpZg+AC8yp4XEQfQ1fOEbIsW77mOUJd5whPHcOizhHm72POodrPEY7mu7hj6M18A/7xe0TB7YqbL88Rjo8LKOMc4e64zhxDo9Fo2SdJkhR/jpBl2aomKIoiC6709HQMGzYMYWFhmD9/vuUX1NDQUAD5S75XrVrVavuCz4eEhODKlSs246alpVm2cUdxq6eY3wR7Cga5MI1GY9nPwgq+8c6OW9JrzT8A3hy3uH0Fij+Gosc1v4/u7Kuz740syzCZTDyGDjznyrgZGRmWT6IqVqxo9dy5c+dw7do1XL58Gdo8GfGnzqPZL8kwBGqR1D0G0sPtcfLAcaT88xPq1gxGj7b1Ua6sDhUqVLD8YwB47r1x5hxR+K9/PEd4ZlxfnCMcHVfUvtr7xUnEuGZKO0cU5Oq++irfSv49wpyjgtsqId+eHrc0nCM8PW7BY2h+beHftZV6jnCk2AIUWHDl5OTgxRdfREZGBtatW2fVGhgREQEg/xot83+bv9bpdKhbt65lu6SkJJuq8+zZs4iMjHRrfpIkWf5n77mSXuvKc+68luN6dlxXX2v+i40n9qe0HMOinit8gk6/k4t/bmaiZuXylmNe+3Iamn97AiG3M/Fn07o40jIC+jIBwJm/oZUl1C8HIA34ZvdJSJKEChUqoGLFisjJyRE+X3deW/AfCaXMieMqf07+liUlzsnfxvXWnMy/JJsfU/p8lTCuEufk63EL50gJc3LltQUpquAyGAwYNWoUkpOTsXbtWlSvXt3q+bp166J+/frYuXMnunbtank8MTERbdq0sXyE3bFjRyxatAhJSUlo27YtgPxi68SJExg6dKjb83TmABMVVlKhRe7Lzs7GqVOnoAkIxLYfziHlnwzUrRmMB2to0H7nEdQ6cRHGmLtx/Z0n8E/mZbQMvwunTp3C3ZGN8P3x25bt49rVR7mygZZPuH744Qdf75oFc0SiMEskAnNEIqg1R4oquKZMmYK9e/di3LhxuHPnjtXNjO+55x4EBgZi5MiRGDNmDOrVq4dWrVohMTERR44cwZo1ayzbxsbGon379pgwYQLGjh2LMmXKYPbs2YiKikK3bt3cnqej/ZpE9phbCp35KJqcc+PGDezZswcAoDXKiChjQuO9F1Dn12QYdFocjGuG7rOnoIok4fyuXWjQoAGuX7+OFvffizZty+PKzSzUqFwOIRXKWMZMTU0tsiXBF5gjEoVZIhGYIxJBrTlSVMFl/uvxjBkzbJ7bs2cP6tSpg549eyI7OxsJCQlYunQpwsPDsWDBAsTGxlptP2fOHEyfPh2TJ0+GwWBA+/btMXHixGJ7MR3hzIokREUxGo3F9jiTe6pUqYJGjRpBExCI39bsx32J36JyejqyerZDcucYZGZnWp3Iy5Qpg+joaAQFBSEoqIxVoaVkzBGJwiyRCMwRiaDGHEkyKwiHHT16FLIsIyYmRlVVN3mXeTWd4hZfIdelpqZi165deKjZfTDMWoPML/dCjr0Hlf5vFCrd39jyfPfu3REUFITTp0+jYcOGCAoKKnbc7Oxsh7f1BuaIRGGWSATmiETwtxwdPXoUABATE1Psdor6hIuIyF1ynh41v/4daeNWQFu+HKotmogKfbvZPXEHBQWVeJJ0ZVsiIiIiMxZcRKQaWft+xZ2xs1Dn7GWUf64Xqk54Adr/3bzYLCgoyNI+SERERORpLLic5A8fb5Lyqa032dcMl6/hxqQFyPxyL8q2boYaK6ahzD0N7G6rpk+qmCMShVkiEZgjEkGNOWLB5QIWXeQOSZLcXryF8sl5etxesh63Zq2CpkIQqi2ehAqPP1QqfkaZIxKFWSIRmCMSQa05Ut8eeQGXhSd3FFynhjlyXda+X3Fj3Gzoz15C6LDHUenN56EJLu/raXkNc0SiMEskAnNEIqg1Ryy4nMRFHUkE8wo85DzDpau4MXmhpX2w+vKpRbYPqh1zRKIwSyQCc0QiqDFHLLiIyC/82z64EpoK5UpV+yARERH5LxZcRKR4Wd/9ghvj55Ta9kEiIiLyXyy4iEixDJeu5q8++NV3KNumdLcPEhERkX9iwUVEisP2QSIiIlILFlxOkiSJv/SRWyRJQmBgoK+noVhsH3QMc0SiMEskAnNEIqg1Ryy4iEgRbNoHV7yLMo0jfD0tIiIiIrew4HIB78NF7pBlGUajEVqtljnC/9oHF6/DrQ9XsX3QCcwRicIskQjMEYmg1hyx4HIS78NFIphMJmi1Wl9Pw+fYPuge5ohEYZZIBOaIRFBjjlhwEZHXsX2QiIiISgsWXETkNTbtg0smo0KfrqpqGyAiIiIqiAUXEXlF1t6f89sHz11G6At9UemN59g+SERERKrHgstJ/Es8iRAQUHp+9PQXr+LmpPnI3LYPZds2R/WPp7F9UJDSlCPyLGaJRGCOSAQ15kh9e+QFLLrIHaXlXm5ybl5+++Ds1Wwf9IDSkiPyPGaJRGCOSAS15ogFlwu4LDy5Q5ZlmEwmaDQa1eaI7YOeVxpyRN7BLJEIzBGJoNYcseByEpeFJxGMRiM0Go2vpyEc2we9S605Iu9jlkgE5ohEUGOOWHARkdus2geDy7N9kIiIiOh/WHARkVvYPkhERERUNBZcROQStg8SERERlYwFl5PYIkUi+HNvMtsHlcOfc0TKwiyRCMwRiaDGHLHgcgF/sSR3SJLkt/eYyNr7M26Mmw39+X/YPuhj/pwjUhZmiURgjkgEteZIfXtE5Af87dYCNu2DK//L9kEF8LcckXIxSyQCc0QiqDFHLLicJMuyKoNA3iPLMvR6PXQ6neJzZNM++NHbqNC7i+LnXRr4U45I2ZglEoE5IhHUmiMWXERkV9a3B/NXHzz/D0JffAKVxjzL9kEiIiIiJ7HgIiIr+otXcXPifGRuZ/sgERERkbtYcBERgP+1Dy76PL99MKQC2weJiIiIBGDBRURsHyQiIiLyEBZcTuJf+0kEnU7n6ykAKNQ+2C4WNVb9HwIbhft6WuQgpeSI/B+zRCIwRySCGnPEgssFLLrIHUrIj0374NK3UeExtg/6E75XJAqzRCIwRySCWnPEgssFXBae3CHLMoxGI7RarU9yZGkfvPAPQl94Iv/mxRXKeX0e5B5f54jUg1kiEZgjEkGtOWLB5SRZln09BVIBk8kErVbr1e/J9kH18UWOSJ2YJRKBOSIR1JgjFlxEKsf2QSIiIiLfYcFFpGJW7YMvPoFKY9g+SERERORNLLiIVMiqfbD9vaix+v8QGMX2QSIiIiJvY8HlJLZhkQie6k1m+2DporYed/IdZolEYI5IBDXmiAWXC/jLK7lDkiSPnEyy9hzEjQlsHywtPJUjKn2YJRKBOSIR1JojFlwu4LLw5A5Zli0ZEpEjfcoV3Jw0H5nb97N9sBQRnSMqvZglEoE5IhHUmiMWXE7isvAkgsFgcPtO6nJuHm4v/By35qyGJjSY7YOlkIgcEQHMEonBHJEIaswRCy4iP8T2QSIiIiL/wIKLyI+wfZCIiIjIv7DgIvIDhdsHqy99B+Uf68z2QSIiIiKFY8HlJP6CSyI4k6OsPf+7eXEK2wfJGs9HJAqzRCIwRySCGnPEgssFagwCeY8kSQ5dDKq/8E9++2Di9/ntg5+wfZD+5WiOiErCLJEIzBGJoNYcseAiUhi2DxIRERGpBwsuF/A+XOQOWZZhMBgQEBBgk6OC7YNhw/uh4n+eZfsg2VVcjoicwSyRCMwRiaDWHLHgchLvw0UiFM5RwfbBoA5sHyTH8HxEojBLJAJzRCKoMUcsuIh8yJSTi7SFn+PW3E/YPkhERESkQiy4iHwka89PuDlhHtsHiYiIiFSMBReRl+kv/IMbE+che+cPbB8kIiIiUjkWXE5iqxe5ytI+OGc1NGEhqLb0bVR4rAszRS5T49K55BvMEonAHJEIaswRCy4X8BdkclbmNz/h5oS5bB8kYXgeIlGYJRKBOSIR1JojFlwu4LLw5Cib1QfXTIfu7rtgNBohMUfkBlmWYTQaodVqmSNyC7NEIjBHJIJac8SCy0lqXKqSxCvcPlhw9UFZlmEymaDVan09TfJzzBGJwiyRCMwRiaDGHLHgIhIs85ufcGP8HBguXmH7IBEREVEpx4KLSBDz6oNZOw4gqMO9qLl2BgIj6/t6WkRERETkQyy4iNxk1T5YMRTVE6agfK9Oquo9JiIiIiLXsOByEn+JpoKs2gdf6o+Krz/jUPug2nqTyTeYIxKFWSIRmCMSQY050vh6AgWdP38ekydPRq9evXDPPfegZ8+edrfbsGEDunfvjpiYGDz66KPYu3evzTYZGRmYMGECWrZsidjYWLz66qu4du2akHmy6CL9hX/wz+DxuPLkG9DVrY66+1ai8uSXHCq2JElS3eo75H3MEYnCLJEIzBGJoNYcKarg+vvvv7Fv3z7cddddaNCggd1ttm/fjkmTJiEuLg4JCQlo3rw5RowYgT/++MNqu1GjRuGHH37AO++8gw8++ABnz57FsGHDYDAY3J4nVyosvUw5uUidtRIp7QYi948/UT1hCmp+Mcepa7XMqxQyR+QO5ohEYZZIBOaIRFBrjhTVUti5c2d07doVADBu3DgcO3bMZpt58+ahR48eGDVqFACgdevW+Ouvv7Bw4UIkJCQAAA4dOoQDBw5g+fLlaN++PQAgPDwc8fHx2L17N+Lj412eo9oCQI7L/DoJNybMdbp90B6DwaDKO6mTdzFHJAqzRCIwRySCGnOkqE+4NJrip5OSkoJz584hLi7O6vH4+HgkJSUhLy8PALB//36EhISgXbt2lm0iIiLQuHFj7N+/X/zESdUs7YNPvQldvRpOtQ8SERERUemmqE+4SpKcnAwg/9Oqgho0aAC9Xo+UlBQ0aNAAycnJCA8Pt+n/jIiIsIzhDnufcplvaGuPeR7FPe+p13Jc18c15eQibdHnuD3nE2gqhqLasiko/8iDlvFcnZP5MSXtqy/HVeKc/GFcWZatHlPCnDiuf8zJ37KkxDn527jemJM5R+av1XYM/fm98adxC+dICXNy9rX2+FXBlZaWBgAICQmxetz8tfn59PR0BAcH27w+NDTUbpuis/R6vVUxp9FoEBAQYHmusMDAQACA0WiEyWSyei4gIACSJMFkMsFoNFo9Zx5XlmW745o/brU3rlarhVarhSzLNtetSZJkea3BYLAJjKfGdWRfAdtj6KlxzfsqSZLNvmbvOYjbkxfAcPEqQof3R4VXn4KmfJBlnx0ZF7B/DM2f5Io+hub3xt6cfHEMC45rb199ne/ijqE38w24do6QZdnyNc8Rvsl3cfvqzjnCU8ewqHOE+fuYc8hzhDrOEQXH9cYxLLhdcfPlOcLxcQFlnCPcHdeZY2g0Gi37JEmS4s8RsvzvH+CL41cFl1KYg1HUc0UpGOTCNBpNkS2VBd94Z8ct6bXmHwBvjlvcvgLFH0PR45rfR/O+6i/8g5sT5yNr5wEEdbgPNde+B93ddxU5ZknztXcMzf8wqfUY2lPcvvoq3+78zHnqvXHmHFHwJM9zhOfGdTffRY1rpoRjWPgXBqUdQ54j/qXk3yPMOSq470rIt6fHLQ3nCE+PW/AYajQaq0Kr4DZKPEc4UmwBflZwhYaGAshf8r1q1aqWx9PT062eDwkJwZUrV2xen5aWZtnGVZIkFXtCK+m1rjznzms5rmPjyrl5uL3wM0v7YPVlU1H+0Qcd+kFy9vsWlyF3xnXkOSWOq8Q5+cO4kiRZ/oqslDlxXP+Yk79lSYlz8rdxvTGnwjkSNa7I55Q4rhLn5Mtx7eXI13Ny9bUFKWrRjJJEREQAgM11WMnJydDpdKhbt65lu7Nnz9p8BHj27FnLGERmmbt/REqHZ3Drg5UIHfYE6v24BhV6dXLqB4mIiIiIyB6/Krjq1q2L+vXrY+fOnVaPJyYmok2bNpaKuGPHjkhLS0NSUpJlm7Nnz+LEiRPo2LGj2/Nw5iI5Ui79+cv4Z9B4XHl6LHR31UTd/atQefJwj68+aO41Zo7IHcwRicIskQjMEYmg1hwpqqUwOzsb+/btAwBcunQJd+7csRRXLVu2RKVKlTBy5EiMGTMG9erVQ6tWrZCYmIgjR45gzZo1lnFiY2PRvn17TJgwAWPHjkWZMmUwe/ZsREVFoVu3bm7NUW0BKI1MObn/tg9WCnOqfVAU5ohEYI5IFGaJRGCOSAQ15kiSFbRXFy9eRJcuXew+t3r1arRq1QoAsGHDBiQkJODy5csIDw/H66+/jk6dOlltn5GRgenTp+Prr7+GwWBA+/btMXHiRFSvXt3l+R09ehSyLCMmJobtZn4qc/ePuPHWvP/dvHgAKr4+2Ov30zL/9aa4xVeISsIckSjMEonAHJEI/pajo0ePAgBiYmKK3U5RBZfSseDyX/rzl3HDvPrgA/ejyvRRCCxh9UFP8beTCSkTc0SiMEskAnNEIvhbjhwtuBTVUkgkmiknF7cXfIrbc9f4rH2QiIiIiEovFlxO4i/q/iO/fXAuDJeuIWx4f5+0DxaluPs6EDmKOSJRmCUSgTkiEdSYI/XtkRew6FK2wu2DNT+d6bP2QXvM95kgcgdzRKIwSyQCc0QiqDVHLLhcYL6bOimLTfvg8qko/4jy2gdlWYbJZHLqDuVEhTFHJAqzRCIwRySCWnPEgstJXGNEmazaB1/qj4qjldM+aI/RaIRG41e3wSMFYo5IFGaJRGCOSAQ15ogFF/k1/fnLuPHWPGTt+kGR7YNEREREVLqx4CK/ZMr+X/vgPGW3DxIRERFR6caCi/xO5u4f8m9e7Cftg0RERERUerHgchI/QfEdq/bBB1ug5mfvI7BhPV9PyyVq600m32COSBRmiURgjkgENeaIBZcLWHR5l9raByVJUuU9Jsi7mCMShVkiEZgjEkGtOVLfHnkBl4X3Hpv2wdefgaZ8kK+n5ZaCK10yR+Qq5ohEYZZIBOaIRFBrjlhwOYnLwnuH/txl3JiojvZBe/R6PXQ6na+nQX6OOSJRmCUSgTkiEdSYIxZcpCiW9sG5a6Cp7P/tg0RERERUurHgIsXI3P0DbkyYC8Pl66ppHyQiIiKi0o0FF/mcTfvg5x+oqn2QiIiIiEovFlxOYmubODbtgyveRfmeD5SKY1wa9pE8jzkiUZglEoE5IhHUmCMWXC5QYxC8rTS3D0qSpLqLQcn7mCMShVkiEZgjEkGtOWLBRV6lP3cZN96ai6zdP7J9kIiIiIhUjwWXC3gfLueZsnNxe/5a3J63Ftoqpat9sDBZlmEwGBAQEFAq95/EYI5IFGaJRGCOSAS15ogFl5N4Hy7nWbUPvjwAFUcPLjXtg0VhjkgE5ohEYZZIBOaIRFBjjlhwkcewfZCIiIiISjsWXCQc2weJiIiIiPKx4CKhMnf9gBtvsX2QiIiIiAhgweU0fkpjH9sHnRMQwB89ch9zRKIwSyQCc0QiqDFH6tsjL2DR9S+b9sGPp6F8j448RsWQJInHh9zGHJEozBKJwByRCGrNEQsuF3BZ+HxW7YOvPImKowaxfdABsizDZDJBo9EwR+Qy5ohEYZZIBOaIRFBrjlhwOUmNS1U6y6Z9cN0HCGzA9kFnGI1GaDQaX0+D/BxzRKIwSyQCc0QiqDFHLLjIYWwfJCIiIiJyDgsucgjbB4mIiIiInMeCi4qlP3spv33w6yS2DxIREREROYkFl5NKS/ucKTsXt+etwe35n0JbtSLbBwVTW28y+QZzRKIwSyQCc0QiqDFHLLhcoPaiI3PXD7gxYS4MV27k37yY7YNCSZKkyntMkHcxRyQKs0QiMEckglpzpL498gK1Lgtv0z64nu2DnlBwpUs15oi8gzkiUZglEoE5IhHUmiMWXE5S47LwbB/0Pr1eD51O5+tpkJ9jjkgUZolEYI5IBDXmiAVXKSbLMrJ2/YAbb81j+yARERERkQew4Cql9Gcv4caEOcj65icEdWrJ9kEiIiIiIg9gwVXK2LQPrvwvysd3YPsgEREREZEHsOAqJWzaB803Ly5X1tdTIyIiIiJSLRZcTpIkye8+DbJtH5yFwAZ1fT2tUkuSJOh0Or/LESkLc0SiMEskAnNEIqg1Ryy4VMyUlZPfPrjgM7YPKgzfAxKBOSJRmCUSgTkiEdSYIxZcLlD6fbhkWUbWzgO4MXE+2wcVSJZlGI1GaLVaReeIlI05IlGYJRKBOSIR1JojFlxOUvp9uPTJF/NvXsz2QUUzmUzQarW+ngb5OeaIRGGWSATmiERQY45YcKmEuX3w1vxPEVCtEtsHiYiIiIgUgAWXn2P7IBERERGRcrHg8mNsHyQiIiIiUjYWXE5SQose2wf9n9p6k8k3mCMShVkiEZgjEkGNOWLB5QJfFTaW9sG35sFw9SbbB/2UJEmqPJmQdzFHJAqzRCIwRySCWnPEgssFvlgWXp98ETcmzEXWnp8Q1LkVam74kO2DfkqWZUuG+KkkuYo5IlGYJRKBOSIR1JojFlxO8vay8IXbB2us+i/KxbF90N8ZDAbodDpfT4P8HHNEojBLJAJzRCKoMUcsuBSqcPtgxRFPIey1gWwfJCIiIiLyIyy4FIjtg0RERERE6sCCS0FMWTm4PXcNbi1g+yARERERkRqw4HKSJ4ofWZaRteP7/JsXs32wVNBoNL6eAqkAc0SiMEskAnNEIqgxRyy4XCCy6CrYPliuS2u2D5YCkiQhIIA/euQe5ohEYZZIBOaIRFBrjtS3R37Cqn2wemXUWP1/KPdwe7YPEhERERGpCAsuJxW8P4Crr2f7YOkmyzL0ej10Oh0LbHIZc0SiMEskAnNEIqg1Ryy4vIjtg0REREREpQsLLi9g+yARERERUenEgsuDbNoHRz6FsFfZPkhEREREVFqw4PKQvDMpuDFhLrK/PYhyXVqj1sbZ0EXU8fW0iIiIiIjIi1hwOamkNkBTVg5uzfkEtxd+xvZBKpJOp/P1FEgFmCMShVkiEZgjEkGNOVJ1wXXmzBlMmzYNhw4dQvny5dGrVy+MGjUKgYGBbo1rr3hi+yA5isU3icAckSjMEonAHJEIas2RaguutLQ0PPPMM6hfvz7mz5+Pq1evYsaMGcjJycHkyZPdGrvwsvBsHyRnyLIMo9EIrVar2hMLeR5zRKIwSyQCc0QiqDVHqi24Pv/8c2RmZmLBggUICwsDABiNRkyZMgUvvvgiqlev7tK4sixb/pvtg+Qqk8kErVbr62mQn2OOSBRmiURgjkgENeZI4+sJeMr+/fvRpk0bS7EFAHFxcTCZTPjhhx/cGluWZdzZvh8p7QYibdHnqDjyKdQ98AnKx3VgsUVERERERBaq/YQrOTkZjz/+uNVjISEhqFq1KpKTk10eV7p4DVf++2Z++2DX1qjyxRy2DxIRERERkV2qLbjS09MREhJi83hoaCjS0tJcGlOv1yNk6DRkVgqF/t3hyGobgxuZt4Cjt9ydLpUyha8DJHIFc0SiMEskAnNEIvhTjvLy8hyaq2oLLk+QJAnp2z5U5XKV5F3+ciIhZWOOSBRmiURgjkgEf8qRJEmlu+AKCQlBRkaGzeNpaWkIDQ11aczY2Fh3p0VERERERKWIahfNiIiIsLlWKyMjA9evX0dERISPZkVERERERKWJaguujh074scff0R6errlsZ07d0Kj0aBdu3Y+nBkREREREZUWklzwxlIqkpaWhh49eiA8PBwvvvii5cbHjzzyiNs3PiYiIiIiInKEagsuADhz5gzeffddHDp0COXLl0evXr0wevRoBAYG+npqRERERERUCqi64CIiIiIiIvIl1V7DRURERERE5GssuIiIiIiIiDyEBRcREREREZGHsOAiIiIiIiLyEBZcREREREREHsKCi4iIiIiIyENYcBEREREREXlIgK8n4A/OnDmDadOmWd1AedSoUbyBMjls06ZNGD9+vM3jw4YNw5gxY3wwI/IH58+fx/Lly3H48GH8/fffiIiIwLZt22y227BhA5YtW4bLly8jPDwco0ePRqdOnXwwY1IqR7I0aNAg/PzzzzavTUxMRIMGDbw1VVKoHTt24Msvv8Tx48eRnp6Ou+66C4MGDcLjjz8OSZIs2/F8RCVxJEtqOx+x4CpBWloannnmGdSvXx/z58/H1atXMWPGDOTk5GDy5Mm+nh75mWXLliE4ONjydfXq1X04G1K6v//+G/v27UOzZs1gMplg7z7127dvx6RJkzB8+HC0bt0aiYmJGDFiBNauXYvmzZt7f9KkSI5kCQDuvfdejB071uqxOnXqeGOKpHArV65E7dq1MW7cOFSsWBE//vgjJk2ahCtXrmDEiBEAeD4ixziSJUBd5yNJLuqsSwCAjz76CEuWLMHevXsRFhYGAFi3bh2mTJmCvXv38hdmcoj5E66kpCRUqlTJ19MhP2EymaDR5Hd+jxs3DseOHbP5VKJ79+6Ijo7GrFmzLI8NGDAAwcHBSEhI8Op8SbkcydKgQYNQrlw5fPTRR76YIilcamqqzb9fkyZNQmJiIn755RdoNBqej8ghjmRJbecjXsNVgv3796NNmzaWYgsA4uLiYDKZ8MMPP/huYkSkeuZfkIuSkpKCc+fOIS4uzurx+Ph4JCUlIS8vz5PTIz9SUpaISmLvj4WNGzfGnTt3kJWVxfMROaykLKkRz8AlSE5ORkREhNVjISEhqFq1KpKTk300K/JXPXv2ROPGjdGlSxd89NFHMBqNvp4S+THzOSg8PNzq8QYNGkCv1yMlJcUX0yI/9vPPP6N58+aIiYnBwIED8csvv/h6SqRgv/32G6pXr44KFSrwfERuKZglMzWdj3gNVwnS09MREhJi83hoaCjS0tJ8MCPyR1WrVsXIkSPRrFkzSJKEb7/9FnPmzMHVq1d5LSC5zHwOKnyOMn/NcxQ5o0WLFujVqxfq16+Pa9euYfny5XjuuefwySefIDY21tfTI4X59ddfkZiYaLnGhucjclXhLAHqOx+x4CLygg4dOqBDhw6Wr9u3b48yZcpg1apVGD58OKpVq+bD2RERAa+++qrV1w8++CB69uyJRYsW8fobsnLlyhWMHj0arVq1wuDBg309HfJjRWVJbecjthSWICQkBBkZGTaPp6WlITQ01AczIrWIi4uD0WjEyZMnfT0V8lPmc1Dhc1R6errV80SuKFeuHB544AEcP37c11MhBUlPT8ewYcMQFhaG+fPnW64P5PmInFVUluzx9/MRC64SRERE2FyrlZGRgevXr9tc20VE5E3mc1Dhc1RycjJ0Oh3q1q3ri2kRkUrl5OTgxRdfREZGhs1tTng+ImcUlyU1YsFVgo4dO+LHH3+0/IUGAHbu3AmNRoN27dr5cGbk7xITE6HVanHPPff4eirkp+rWrYv69etj586dVo8nJiaiTZs2vDk7uSUrKwvfffcdYmJifD0VUgCDwYBRo0YhOTkZy5Yts7ktDs9H5KiSsmSPv5+PeA1XCQYMGIBPPvkEr7zyCl588UVcvXoVM2fOxIABA3gPLnLYkCFD0KpVK0RFRQEA9uzZg/Xr12Pw4MGoWrWqj2dHSpWdnY19+/YBAC5duoQ7d+5Yfplp2bIlKlWqhJEjR2LMmDGoV68eWrVqhcTERBw5cgRr1qzx5dRJYUrKkvkXn4ceegi1a9fGtWvX8PHHH+P69euYO3euL6dOCmG+/+i4ceNw584d/PHHH5bn7rnnHgQGBvJ8RA4pKUtHjhxR3fmINz52wJkzZ/Duu+/i0KFDKF++PHr16oXRo0fzrzXksGnTpuH777/HlStXYDKZUL9+fTzxxBMYNGgQJEny9fRIoS5evIguXbrYfW716tVo1aoVAGDDhg1ISEjA5cuXER4ejtdffx2dOnXy5lRJ4UrKUo0aNTB16lT8+eefuH37NoKCghAbG4sRI0agadOmXp4tKVHnzp1x6dIlu8/t2bMHderUAcDzEZWspCwZjUbVnY9YcBEREREREXkIr+EiIiIiIiLyEBZcREREREREHsKCi4iIiIiIyENYcBEREREREXkICy4iIiIiIiIPYcFFRERERETkISy4iIiIiIiIPIQFFxERkR2ZmZlo06YNvvzyS19PxeLWrVto3rw59u3b5+upEBGRg1hwERGR31m7di2ioqLwxBNPeOx7rF69GuXLl0ePHj089j2cVbFiRfTt2xdz58719VSIiMhBLLiIiMjvfPXVV9DpdDhy5AjOnz8vfHy9Xo/Vq1fjiSeegFarFT6+O5588kkcP34cSUlJvp4KERE5gAUXERH5lZSUFBw6dAgvvfQSdDodvvrqK+Hf47vvvkNqairi4uKEj+2uBg0aIDIyEps3b/b1VIiIyAEsuIiIyK989dVX0Gq16N+/P9q2bWu34Jo3bx4aNWpk8ynQpEmTEB0djVOnThX7Pb755hvUrl0b9erVs3p83LhxiI2NxeXLl/Hiiy8iNjYWHTp0wNq1awEAf/75JwYPHozmzZujU6dONnPbtGkToqKi8Ouvv2LatGlo3bo17r//fkyePBl5eXlIT0/Hm2++iRYtWqBFixaYOXMmZFm2mV/btm2xd+9eu88REZGysOAiIiK/8tVXX+H+++9HlSpVEBcXh3PnzuHIkSNW27z00kto3Lgx3nrrLdy5cwcA8P3332P9+vV4+eWX0ahRo2K/x6FDh9CkSRO7zxmNRgwbNgw1atTAmDFjULt2bUydOhWbNm3C0KFDER0djTFjxqB8+fIYO3YsUlJSbMaYNm0azp07h5EjR6Jz585Yt24d5s6di+HDh8NoNGL06NG47777sHz5cmzdutXm9U2aNEF6ejr+/vtvRw8bERH5CAsuIiLyG8eOHUNycjLi4+MBAF27drXbVqjT6fDee+/h2rVrmDFjBtLT0/HWW28hOjoaL7zwQrHfw2Aw4MKFC6hTp47d53Nzc/Hoo49iypQpePrpp7F06VKULVsWEyZMwPjx4/Hmm29i4MCBmDdvHoxGI7Zs2WIzRuXKlZGQkICnn34aM2fORGxsLJYvX467774bs2bNwlNPPYWFCxeiRo0a+OKLL2xeX7duXQDA6dOnHTlsRETkQyy4iIjIb3z11VcICAhAt27dAADBwcHo0KEDEhMTYTQarbaNjIzEq6++ig0bNmDIkCG4desW3nvvPQQEBBT7PdLS0iDLMkJCQorcpuDqiCEhIQgPD0dQUJDVNV8REREICQmx+wlX3759IUmS5eumTZtClmX07dvX8phWq0V0dLTd15vnduvWrWL3hYiIfI8FFxER+QWj0Yjt27ejdevWqFSpkuXx+Ph43Lhxw+6qfUOGDEGjRo1w5MgRjBgxAg0bNnT4+xV1fVSZMmWsvj+QX/jVqFHDqogyP56enm4zRq1atWy2A4CaNWvaPJ6WllbkHAt/PyIiUh4WXERE5Bd++uknXL9+3WblwM6dO6Ns2bJ2F89ISUmxLBv/119/OfR9QkNDIUmS3UIJQJHLxBf1uL3CTaOx/89vUY8XZi7CKlas6ND2RETkOyy4iIjIL5jvvfXQQw9ZPV6+fHk88MAD+Prrr5GTk2N53GQyYdy4cahQoQKGDx+Obdu2Yffu3SV+n4CAANSrVw8XL14Uvg+imOfWoEEDH8+EiIhKwoKLiIgULycnB7t370bbtm0RGhpq8/zDDz+MzMxMfPvtt5bHPv74Yxw6dAhTp07Fa6+9htjYWLzzzjtITU0t8fs1b94cx44dE7oPIh0/fhzBwcG4++67fT0VIiIqQfFXDhMRESnAt99+i8zMTADA0qVLbZ7Pzs4GAHz55ZeIj4/HmTNnMHfuXPTp0wedO3cGAMyYMQOPPfYYpkyZgrlz5xb7/bp06YKtW7fi7NmzCA8PF7w37vvxxx/RqVMnXsNFROQHWHAREZHiffnllwCAffv2Yd++fUVud+DAAdy6dQtjx45FxYoVMWHCBMtz9evXx+uvv47//ve/SExMtCwtb0+nTp1QsWJF7NixAy+//LK4HRHgzJkz+Ouvv6z2jYiIlEuSeZt6IiIiGwsXLsSmTZuwe/fuIhfE8IX//ve/+PXXX7Fp0yZ+wkVE5Ad4DRcREZEdzz77LLKysrB9+3ZfT8Xi1q1b2LhxI0aNGsVii4jIT/ATLiIiIiIiIg/hJ1xEREREREQewoKLiIiIiIjIQ1hwEREREREReQgLLiIiIiIiIg9hwUVEREREROQhLLiIiIiIiIg8hAUXERERERGRh7DgIiIiIiIi8hAWXERERERERB7CgouIiIiIiMhDWHARERERERF5yP8DqS7uIY6XFpoAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 3.91693\n", + "GdL = 4\n", + "Chi² rid = 0.97923\n", + "P(0, chi²)= 0.58263\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.250317\n", + "1 0.360714\n", + "2 0.037755\n", + "3 0.653693\n", + "4 1.339556\n", + "5 0.274893\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "9f26f65e", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 243, + "id": "6a910226", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 23.4106 +- 0.2224\n", + "BC = 1.4233 +- 3.1272\n", + "cov_ABC = -0.632350\n", + "P(0, chi²)= 0.5436\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 244, + "id": "b49ec5a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 3.66772\n", + "GdL = 4\n", + "Chi² rid = 0.91693\n", + "P(0, chi²)= 0.54716\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.735332\n", + "1 0.503968\n", + "2 0.029958\n", + "3 0.281908\n", + "4 1.086900\n", + "5 0.029650\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 246, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 23.4182722 ± 0.2217067\n", + "BY = 1.3248937 ± 3.1178836\n", + "cov_ABY = -0.628605644189924\n", + "chi² = 3.66651\n", + "chi² rid = 0.91663\n", + "P(0, chi²)= 0.54698\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 247, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 248, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.52083 ± 0.07342\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 23.46517 ± 0.22969\n", + "Bols = 0.13548 ± 3.49525\n", + "P(0, chi²)= 0.58263\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 23.41058 ± 0.22237\n", + "Bc = 1.42328 ± 3.12716\n", + "P(0, chi²)= 0.54716\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 23.41827 ± 0.22171\n", + "By = 1.32489 ± 3.11788\n", + "P(0, chi²)= 0.54698\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.000800\n", + "0 0.194561\n", + "1 0.226829\n", + "2 0.258983\n", + "3 0.291654\n", + "Name: w, dtype: float64\n", + "0 0.000707\n", + "1 0.000765\n", + "2 0.000815\n", + "3 0.000864\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Meq = df.m + ( m_mol * 0.3333 )\n", + "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", + "\n", + "T2 = ( 2 * np.pi / df.w )**2\n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", + "res_b = 0.01 / np.sqrt(6) # riso bilancia\n", + "res_T = 0.0008 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = 2 * T * res_T\n", + "\n", + "res_uAd = np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2)\n", + "\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "# print(f\"res_T2 = {res_T2:.6f}\")\n", + "# print(f\"res_b = {res_b:.6f}\")\n", + "# print(f\"res_uAd = {res_uAd:.6f}\")\n", + "\n", + "uT2 = np.sqrt(uT2**2 + res_T2**2)\n", + "uMeq = np.sqrt(uMeq**2 + res_b**2)\n", + "\n", + "\n", + "print(T2)\n", + "print(uT2)" + ] + }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, + { + "cell_type": "code", + "execution_count": 250, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 24.059519\n", + "1 24.122421\n", + "2 24.137082\n", + "3 24.160799\n", + "dtype: float64\n", + "0 0.087485\n", + "1 0.081324\n", + "2 0.075925\n", + "3 0.071586\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 24.125209570730643\n", + "sigmaC: 0.0392090048263168\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 253, + "id": "90d191d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 4.713e+05\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 2.12e-06\n", + "Time: 09:57:17 Log-Likelihood: 32.343\n", + "No. Observations: 4 AIC: -60.69\n", + "Df Residuals: 2 BIC: -61.91\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0023 0.000 6.369 0.024 0.001 0.004\n", + "x 0.0016 2.36e-06 686.488 0.000 0.002 0.002\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 2.752\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.628\n", + "Skew: -0.880 Prob(JB): 0.730\n", + "Kurtosis: 2.180 Cond. No. 1.01e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.01e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Adols = 0.00162 ± 0.00000\n", + "Bdols = 0.00226 ± 0.00035\n", + "R² = 1.00000\n", + "Kdols = 24.35158 ± 0.03547\n", + "KBdols = 17.47973 ± 2.74463\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 4 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 254, + "id": "a0ba5c8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2EAAAIsCAYAAAB7vaE5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnnJJREFUeJzs3Xd4FGXbNvBztqT3EFJApCMICCoogugjogKPIgKCKIJUFfURRCkiHcFYCBCQXkS6UhUQrEizooAVCChFAmmbnmyZ7w+/5CWkkLKbuXbn/B3Hc7wvuzP3XrPnzrhXduYeRVVVFURERERERFQtDFoXQEREREREpCdswoiIiIiIiKoRmzAiIiIiIqJqxCaMiIiIiIioGrEJIyIiIiIiqkZswoiIiIiIiKoRmzAiIiIiIqJqxCaMiIiIiIioGrEJIyIiIiIiqkZswoiIiATo378/+vfvX/jvc+fOoUmTJti8ebOGVRERkSuwCSMiIlE2b96MJk2a4NixY1qX4hbOnTuH6dOn4/7778dNN92ELl26YN26dUWW+fPPPzFu3Djce++9aNWqFbp37449e/ZoVDEREZm0LoCIiIiKq1WrFo4ePQqTqez/VMfHx+Onn35C9+7dER4ejk8++QSTJ0+Gt7c3HnnkEQDAtGnTkJ2djb59+8LPzw8ffvghXnjhBaxcuRK33357dWwOERFdgU0YERGRQIqiwNvb+5rLPf7445gxYwaMRiMAoGfPnrj33nuxY8eOwiZs9OjRuOmmmwrXeeihh9CuXTt89NFHbMKIiDTA0xGJiMgtJSYmYty4cbjjjjvQvHlzdOvWDR988EGx5c6fP4+nn34arVq1Qrt27fD666/j66+/RpMmTfDNN98UWXbNmjXo1KkTWrZsiV69euH7778vdq0WAOTn52Pu3Lno3LkzmjdvjrvuuguxsbHIz88vV+0bNmzAvffeW+R1rlbea8JatGhR2IABgMlkgslkgtVqLXzsygYMALy8vGAwGIosQ0RE1Ye/hBERkdtJSkrCo48+CkVR8PjjjyMsLAz79u3Dq6++iszMTAwcOBAAkJ2djQEDBuDy5ct48sknUaNGDXz00UfFmi8AWLt2LaZOnYpbb70VAwcOxPnz5zFixAgEBQUhKiqqcDmHw4FnnnkGP/zwAx599FE0aNAAf/75J1atWoUzZ85gwYIFZda+adMmTJw4Ea1bt8aAAQNw9uxZPPPMMwgODkZ0dHSV35vVq1fj7NmzGDFiRKnLvPPOO8jLyyv8pYyIiKoXmzAiInI7s2fPht1ux44dOxAaGgoAeOyxxzBq1CjEx8ejb9++8PHxwYYNG3D27FnMnz8f9957LwCgb9++ePjhh4uMl5+fjzlz5qBFixZYtWpV4XVYTZo0wdixY4s0YTt27MDBgwexevVq3HrrrYWPN2rUCJMmTcKPP/6Im2++ucS6rVYrZs+ejaZNm+K9996Dl5cXAKBhw4Z47bXXqtyEbd++HTNmzEDfvn3Ro0ePEpdZtGgRVqxYgZdeegm33XZblV6PiIgqh6cjEhGRW1FVFXv27ME999wDVVWRkpJS+L8OHTogIyMDv/zyCwDg66+/RmRkJDp16lS4vre3Nx599NEiYx4/fhxpaWl49NFHi0yE8eCDDyI4OLjIsrt370aDBg1Qv379Iq9dcG1VSb+yXfk6ycnJ6Nu3b2EDBgA9evRAYGBg5d8UAKdOncL48ePRqVMnTJo0qcRlDh48iHfeeQf9+/fHsGHDqvR6RERUefwljIiI3EpKSgrS09OxYcMGbNiwodRlgH+vB6tTpw4URSnyfJ06dYr8+8KFCyU+bjKZUKtWrSKP/fXXXzh16hTatWtX4msnJyeXWnvB61x//fVFHjebzbjuuutKXa88du7cCavVikmTJsFgKPlvrNu3b4e/vz9eeeWVKr0WERFVDZswIiJyKw6HA8C/M/yVdspdkyZNXPr6jRs3xrhx40p8/spTF6tTWloaAKBmzZplLhMSElLkVzgiIqp+bMKIiMithIWFwd/fHw6HA3fccUeZy9aqVQsnT56EqqpFfg37+++/iywXExNT+PiVU7bbbDacP3++SFNXp04d/P7772jXrl2xX9iupeB1/vrrryK/pFmtVpw7dw433HBDhca70q233gpVVctc5q677kKzZs0q/RpEROQcvCaMiIjcitFoxP33349PPvkEf/75Z7HnC05FBIAOHTogMTERn332WeFjeXl52LhxY5F1mjdvjpCQEGzcuBE2m63w8R07dsBisRRZtkuXLkhMTCw2BgDk5uYiOzu71NqbN2+OsLAwrF+/vsh09lu2bEF6enoZW31tt9xyCx5//PEyl7nrrruKTUpCRETVj7+EERGRSB9++CG+/vrrYo8/+eSTeOmll/DNN9/g0UcfRe/evdGwYUNYLBb88ssvOHToEL799lsAQJ8+ffD+++/jpZdewpNPPomIiAjs2LGj8CbIBb9keXl54fnnn8e0adMwYMAAdOnSBefPn8fmzZuLXSfWvXt37Nq1C5MmTcI333yDm2++GXa7HQkJCdi9ezeWLl2KFi1alLhNZrMZL774IiZOnIgBAwaga9euOHfuHDZv3lzla8LeeecdbNmyBX/88Uepy4wZMwbnz5/H559/XqXXIiKiqmETRkREIq1bt67Exx955BFERUVh06ZNmD9/Pvbu3Yt169YhJCQEDRs2xOjRowuX9ff3x6pVqzB9+nS899578PPzw8MPP4zWrVvj+eefL2zGAOCJJ56AqqpYsWIF3njjDdxwww149913MX369CLLGQwGzJ8/HytXrsS2bduwd+9e+Pr6onbt2ujfvz/q1atX5nb16dMHdrsdy5YtQ2xsLBo3box3330Xc+bMqeI7RkRE7kJRr3UCORERkYdZuXIlZs6ciX379iEyMrLU5RwOB9q1a4fOnTtj+vTp1VghERF5Ml4TRkREHi03N7fIv/Py8rBhwwbUrVu3SAOWl5dXbGKLrVu3Ii0tDW3btq2WWomISB94OiIREXm05557DjExMbjhhhuQmZmJ7du3IyEhAW+99VaR5X766SfMnDkTDzzwAEJCQvDrr7/igw8+QOPGjfHAAw9oVD0REXkiNmFEROTROnTogA8++AA7duyA3W5Hw4YNMXv2bHTt2rXIcrVq1UJUVBRWr14Ni8WC4OBgdO/eHaNHj+Z9tYiIyKl4TRgREREREVE14jVhRERERERE1YhNGBERERERUTXiNWFVdOTIEaiqCrPZrHUpRERERESkIavVCkVR0Lp16zKXYxNWRaqqFpvSmIiIiIiI9Ke8fQGbsCoym81QVRXNmzeHoihal0NXUFUVVqsVZrOZ2QjDbGRjPnIxG9mYj1zMRi5Py+bYsWPlWo7XhBEREREREVUjNmFERERERETViE0YERERERFRNRLXhJ06dQpPPfUUWrVqhfbt2yM2Nhb5+fnXXG/06NG477770KpVK7Rp0waPP/449u/fX2y5jIwMjB8/Hm3btkXr1q3xwgsv4NKlS67YFCIiIiIiomJETcxhsVgwYMAA1K1bF/PmzUNiYiJmzZqF3NxcTJw4scx1rVYrBg4ciLp16yIvLw8ffPABhg0bhvfeew+33npr4XIvvvgiTp48icmTJ8Pb2xtxcXEYOnQoPvzwQ5hMlXs7POEiQk/FWwfIxWxkYz5yMRvZmI9czEYuPWYjqglbv349srKyEB8fj5CQEACA3W7HlClTMHz4cERGRpa67pw5c4r8u2PHjujUqRO2bdtW2IQdOXIE+/fvx7Jly9ChQwcAQL169dC1a1fs2bMHXbt2rXTt12rE7HY7rFZrpccncgaz2Qyj0ah1GfzDhXDMRy5mIxvzkYvZyKXXbEQ1Yfv27UO7du0KGzAA6NKlCyZNmoQDBw7gkUceKfdYRqMRgYGBRRqfffv2ISgoCO3bty98rH79+mjatCn27dtXpSZMVdUSP0SqquLixYtIS0ur9NhUeaXlomchISGIiorS9H1RVRV2ux1Go5H5CMR85GI2sjEfuZiNXHrNRlQTlpCQgJ49exZ5LCgoCBEREUhISLjm+gUhZmRkYPPmzfjrr78wderUIuPXq1evWMD169cv1/hlvW5pChqwmjVrws/PT1cfLq0V3EhbURS+7/j3/cjOzi68BjI6OlrTehwOh4hf5ahkzEcuZiMb85GL2cilx2xENWHp6ekICgoq9nhwcDAsFss11//ggw8wYcIEAICfnx9mz56N1q1bFxk/MDCwxPGPHz9ehcpLbsQcDgfS0tIQERGBsLCwIs8VNAWlNXCKopT5XFXW1cu4Bc+V1IC5st6qrOvqcX18fKCqKi5fvoyIiIjC6yC1yqak56W/h+4yblVrKikfqdvqbuNWtSZmI7OmK7O5cjmp9UqsidnIrcndsqlqTc4etySimrCq6tSpE2644QakpqZi9+7dePHFFxEfH4+77rrL5a9ttVqLfNk3GAyw2WwAAF9f31L/gwkUD7M8z13rC2xFx716bD2PW9bYzqi3Kus6Y9yCz2Nubi4CAgIAADabrdi6JpMJiqLA4XDAbrcXec5gMBQ2cCVd61hw13u73Q6Hw1HiuKqqlrjfmEymwudKGhdAieMajUYYjUaoqlq47135PhSsW9K2FjxX0rZWZdyqvIdeXl6lbmt5xnXWe1iQT3nfQ2dnU9n30JXZlPX5LmtbyzMu4PxsytrWgnFLqkmr9/DKY0Rp76HUY4TVai2Sjx6OEQXc4RhRXdlIOUYUcIdjxNXHNXc+Rqhq+S6FEdWEBQUFISMjo9jjFosFwcHB11w/LCys8Benjh07wmKx4M033yxswoKCgnDx4sVKj1+Wgg/LlQoCNBgMZYZRmefKE66zX1Mv4175mJSanDluwefxyp/9y5oZ1GAwwGAo/W4WJc1oVPBaVx68S1qmpP3myudKU55xS1PZbXXVuEDZs0KVta1Vqfda76HJZCo1n7K2VYtsgLLfQy0/3xUZt4CrsvGk91D6MaKkfDztGFHZ91DrY0R1ZKP1McJdj7NXZuPOx4jyfEcHhDVhJV2blZGRgcuXL6N+/foVHu/GG2/Evn37iox/6NChYh3q6dOn0bhx40rXXfAXlbIapso0U5K/yLvDuFfmfK1mq7pqkjBuSe+JFtkU/CXL2fuGO2cjZd2CL/ql5SNtW91t3KrWxGxk1lTwXGn5SKtXYk3MRm5N7paNM2pyxbpXEnWz5o4dO+LgwYNIT08vfGz37t0wGAxFZjQsrx9++AHXXXddkfEtFgsOHTpU+Njp06fx66+/omPHjlWqvSJvujuaN28emjRpUux///3vfwEATZo0wbJlywqX37x5M3bs2FGuse+5554iE6iMHTu2cNyquFZzrIV9+/Zh4MCBuPXWW3HTTTfh4YcfxnvvvVfsZ+/NmzejSZMmSElJKXWs1NRUvP7667jvvvvQokULtGvXDo899hhWrlzp4q2oOkVRdDcLkjthPnIxG9mYj1zMRi69ZiPql7C+ffti9erVGDFiBIYPH47ExETExsaib9++Re4RNmDAAFy4cAF79+4FAHz55ZfYunUr7r77bkRHR8NiseCjjz7C/v378c477xSu17p1a3To0AHjx4/HmDFj4O3tjdmzZ6NJkya47777qlR7ec//dGc+Pj5YtWpVsccAYMOGDYiJiSl8fMuWLfDz88ODDz5Y4dd59tlnkZ2dXbViUfT6KAnZLF++HG+88QY6d+6M2NhY+Pr6Yt++fYiNjcXhw4cRHx9f5s/1V7LZbBgwYAAyMjIwbNgw1K9fH0lJSfjxxx/xxRdfYODAga7dmCoquKZRWpNM/2I+cjEb2ZiPXMxGLr1mI6oJCw4OxqpVqzBt2jSMGDEC/v7+6NWrF0aOHFlkuasv8LvuuuuQn5+Pt99+G6mpqQgNDUWTJk2wevVqtG3btsi6cXFxmDlzJiZOnAibzYYOHTpgwoQJZZ7feS0VmQnFnRkMBrRq1arE50p7vDLq1KnjtLGc1Rzn5+fDZDKVu0m62q+//oq33noLPXr0wKxZswofb9euHRo2bIjx48djzZo16N+/f7nG+/bbb/HHH3/g/fffR5s2bQof79atW7ELTaWy2WxlnnNN2mI+cjEb2ZiPXMxGLj1mI6oJA4AGDRpc83Sq1atXF1tnwYIF5Ro/MDAQr7/+Ol5//fXKlkglaNKkCV555RUMHjwY/fv3x7ffflv4OAA899xzeP7558s11tixY3H8+HF89NFHAP49NW/cuHHYsmUL3nnnHXz//feoWbMmnn32WTz88MNF1v3yyy8xf/58/PHHH/Dz88N9992HMWPGwN/fHwCQnZ2Nt956CwcOHMDFixcRHh6ODh064OWXXy5y+4J77rmn8JfVtWvX4p9//sHBgwcRFhaGzZs3Y8WKFThz5gxCQkLwyCOP4IUXXijz/harV6+Goiglvgc9evTA4sWLsWrVqnI3YQW3bIiIiCj2XGUbRSIiIiKqHvy2RhVis9mK/K+kXwEnTZqEZs2a4eabb8aGDRuwYcMG9O7du8qvPXr0aHTo0AHz589H06ZNMXbsWJw6darw+d27d+OZZ55B48aNER8fj9GjR+PTTz8tvHccAOTm5sJut2PkyJFYsmQJ/ve//+G7777Ds88+W+z19uzZgy+//BKvvvoqFixYAD8/P6xYsQITJkxAhw4dsHDhQgwdOhTvvfceZs+eXWbt3333HZo0aYJatWoVe85gMOA///kPzp49i8TExHK9F02bNoXBYMCECRNw6NAh5Ofnl2s9IiIiItKeuF/CSK7s7GzceOONRR6LjY1F9+7dizzWsGFDBAQEwM/Pz6mnKT7++ON4/PHHAfx7fd9XX32FTz75BM8++yxUVUVsbCy6du2KGTNmAPj3VMSIiAgMHz4czz77LBo1aoSwsDBMmTKlcEybzYbatWujX79+OH36NOrVq1f4nNVqxZIlS+Dn5wcAyMzMxNy5czFkyBCMGjUKANC+fXuYzWbMmjULgwcPRmhoaIm1JyYmFv4qWJLo6GgAwMWLF4tc/1iaunXrYuzYsXjzzTcxcOBAmM1mtGzZEl26dMFjjz1WpdNriYiIiNxBSkoKDh8+jNtvv73wNlXugt/UnKAy1xxZz1yAw1L8nmjVwRAcCHPdmGsveBUfHx+8//77RR67cvZJV+vQoUPh/+/n54eYmJjC+76dPn0a58+fx/jx4wtnGlRVFW3atIHBYMDx48fRqFEjAMDWrVuxcuVK/PXXX0UmADlz5kyRJuy2224rbMAA4MiRI8jOzsYDDzxQZDbDO+64A7m5uThx4kSxaxBdacCAAejatSs+//xzfPvttzh06BCmT5+OPXv2YNWqVeJPS9TTxbfuiPnIxWxkYz5yMRu5KpuNxWLBr7/+iqZNm7IJ06uKfHjsyWn4+7bHAK0mUDAaUfeXrTCGh1RoNYPBgBYtWrimpnK48pot4N+b+hWchpeamgoAGDFiRInr/vPPPwCAvXv3YsyYMejTpw9GjhyJkJAQXL58GSNGjEBeXl6RdcLDw4v8u+A1evToUeZrlCQyMrLM5wuei4qKKnWZkkRERKBPnz7o06cPrFYrJk6ciM2bN+OLL75Ap06dKjRWdVKUsm+ESNpiPnIxG9mYj1zMRq6KZpOTk4OcnBwAQOLlZFitNiReTkZwcDAAwNfXF76+vi6p1ZnYhGnAGB6COt+s0/SXsIo2YNKFhIQAACZOnIiWLVsWe75mzZoA/r1urGnTpkXuS1YwicjVrm6sC3bu+Pj4Epul2rVrl1pfmzZtsGPHDvzzzz+Fpx4WUFUVX331Fa677rpynYpYGrPZjIEDB2Lz5s04deqU6CaMiIiIqDJOnjyJ48ePw2qz49LR08jztWHX3q/x5x+/w2wyonnz5pr+aFBebMKcpKJToVfmdEB3Yjabi/2y5Er169dHVFQUzp49W3jdWEn3ncjNzS3215by3lS6devW8PX1xcWLF9G5c+cK1de/f39s27YNc+fOxcyZM4s8t23bNiQkJOC1114r93hpaWkICAgodu3XmTNnAJQ8a6IkqqrCZrPBZDLx9BCBmI9czEY25iMXs5Grotk0bNgQUaoJSZMWwWv/D9jd4xb8GFoLD7Vqj3q1gt3iVzCATZhT6OU+YRVRv359bN26FZ9//jkiIiJQs2bNKv3Kcy2KomDs2LEYPXo0srOzcffdd8PX1xfnz5/HV199hVGjRqFevXq44447MHXqVMyfP79wco9Dhw6V6zWCgoLwwgsv4M0338TFixfRtm1bGI1GnD17Fp999hnmzZtX6o7frFkzjB49Gm+88QYyMzPxyCOPwMfHB/v378eqVavQqVMn9OvXr9h6X3zxReH0+gUaNWqEEydOFN53rGXLljCZTPjtt9+waNEixMTEVLhJ1AL3G9mYj1zMRjbmIxezkau82Thy8pD+znvIfHcjvIL88eVD9+JStIrooABEhLpH81WATRi5xNChQ/H3339jzJgxSE9Pr9B9wiqrS5cuCAoKwsKFCwt/3YqJicGdd96JGjVqAAD69u2Lc+fO4f3338eyZcvQoUMHvP3223j00UfL9RqDBg1CZGQkVqxYgffffx8mkwl16tTB3Xfffc3zmQcNGoQGDRpgxYoVGD16NKxWK+rVq4dXXnkF/fr1K3EijfHjxxd77H//+x969OiB+++/H5999hlWrVqFvLw8REVF4cEHH8SwYcMQEBBQru0hIiIikk5VVWR9vA/JE+Nh/ecy/rm7JS7cfyusuTkwXkpEtH8GDnz9BQC4zemIiso/C1TJsWPHoKoqWrRoUewn1Nzc3MJpz318fDSqUL9KOh2RZHwuVVWF1WqF2WxmNgIxH7mYjWzMRy5mI9e1ssn/8wySxs9Bzlffw6/T7QiYOBzWqH9nQjx37hx2796NBx54oPDafK0n5jh27BgAXLMR5C9hREREREQkiiMjCylvroBlyQcw1Y5E1Puz4HffHcUatebNm6N27dqcol6P+BcVuZiNXJwqWDbmIxezkY35yMVs5LoyG9XhQMbGT5AydSEcWdkIe3kQgp/tA4OPd7H1wsLC0LVr1+os1WnYhDkJv+zLw0zkYjayMR+5mI1szEcuZiPXldnk/fwHLo+LQ953x+Hf/R7UmPIsTLVcN7GbltiEOUlFp6gn17vyckdmI4uqqnA4HDAYDMxGIOYjF7ORjfnIxWzkUlUV1sspSJu1DBnvfwSvG+ohZssc+Ha4WevSXIpNmBNwbhO52BzLZbfbS5wRkmRgPnIxG9mYj1zMRh7VZoNl5TakzFoKRQXCp7+A4EEPQzF5fovi+VsoAJs0koSfRyIiItJazsGfkDQ+Dvm/JsC/7wOoMeFpmGq61+QaVcEmzIUKLjLMzs52m7t3k+fLzs4GwAuUiYiIqPrZ/rmM5MkLkLn5U3jf3BQxuxfC2LwhjDr7XsImzIWMRiNCQkJw6dIlAICfnx9PjatGvE9YUaqqIjs7G5cuXUJISAiMRqPWJREREZFOqHn5SFu4EanvvAeDvw8i5oxFYN8ugKLAarVqXV61YxPmBGV9wY+KigKAwkaMqhevCSsuJCSk8HOpJTaBsjEfuZiNbMxHLmajnay9h5A8YS6sf/2D4CGPIPSVQTAGBQD497uaHrNhE+YkpX3RVxQF0dHRqFmzpi67fJLFbDaLONApiiKiDioZ85GL2cjGfORiNtqwJpxD0mvzkL3nIHzvvBlRq16H1w31iiyj12zYhDnJtX5xMRqNuvyAaYmnI8rFbGRjPnIxG9mYj1zMpno5snKQGrcaaQvWw1QzDJHLpsL/wbtLfO/1mg2bMCfgbHNy2Ww2TkAhFLORjfnIxWxkYz5yMRvXU1UVWVs/R9LkBXAkpyH0+X4IeeEJGPx8ylxPj9mwCSMiIiIioirJ+/UUksbPQe6BI/Dr0gE1pj4Pc90YrcsSi00YERERERFVij0tA6lvLINlxVaY68YgesNb8LvnNq3LEo9NGBERERERVYjqcCBjzcdInrEIam4+wiYMQ8iw3lC89HVaYWWxCXMCPV1E6G6YjVzMRjbmIxezkY35yMVsnCf3h1+QNDYOeT/9joDe9yF84jMwRdWo9Hh6zIZNmJPo8cMjnaIourvI010wG9mYj1zMRjbmIxezcQ7bpRSkTFuIjPW74NW8EWI+mg/f21pWaUy9ZsMmjIiIiIiISqVabbAs+xCpsSsAkxE13nwJQf0fhMLbL1UamzAnudZ9wqj6qaoKm80Gk8nEbIRhNrIxH7mYjWzMRy5mU3nZ+75H0vg5sJ74G0EDHkLY2CEwhgU7bXy9ZsMmzAl4nzC5mI1czEY25iMXs5GN+cjFbCrGevYikifGI+ujr+DTtgUi9y6Bd8vGLnktPWbDJoyIiIiIiAAAjpw8pM1fi7S5a2AICkDNd19DQM/OuvqVqjqwCSMiIiIi0jlVVZG9ez+SXpsH24XLCHn6UYSOGgBDgJ/WpXkkNmFERERERDqWf/JvJI2fg5wvvoXvPbchev1b8GpYR+uyPBqbMCfgz7NymUz8iEvFbGRjPnIxG9mYj1zMpjhHZjZS316JtEWbYIqJQNTqmfC7v321f7fVYzb622IXYSMmj6IozEUoZiMb85GL2cjGfORiNkWpqorMD/Ygecq7cKRnIuylgQge0RcGH+9qr0Wv2bAJcxJOUS+PqqpwOBwwGAzMRhhmIxvzkYvZyMZ85GI2/yfv6J9IGheH3G+Pwf+h/yB8ygiYa0dqVo9es2ET5gR6nFbTXdjtdhgMBq3LoBIwG9mYj1zMRjbmI5fes7GnWJAycwnSV22HuUldRG+Og9+dt2hdFgB9ZsMmjIiIiIjIQ6l2O9Lf246UmUsBmx3h055H8KAeUMxsA7TEd5+IiIiIyAPlHD6KpHFxyD9+AoH9uiFswnCYIkK1LovAJoyIiIiIyKPYLiYhecoCZH6wF96tm6LW7oXwueVGrcuiK7AJcwI9XUTobvR2frE7YTayMR+5mI1szEcuPWSj5luRtmgjUt9eBcXXGxGzxyCwX1cowrddD9lcjU2Yk7ARk0dRFF3ed8IdMBvZmI9czEY25iOXHrLJ/uwbJL06B9YzFxA8qAdCxwyCMThQ67KuSQ/ZlER/W+winKJenitnrWQ2sjAb2ZiPXMxGNuYjlydnYz1zAUmvzUP27v3wad8akcunwbtZA63LKjdPzqYsbMKcgFPUy2W1WmE2m7Uug0rAbGRjPnIxG9mYj1yelo0jOxdpc95H2vx1MISHIHLJFPh3/49bNjKelk15sAkjIiIiInITqqoia/uXSJ4UD9vlVISMeAyh/3sCBn9frUujCmATRkRERETkBvJ/P43L4+KQu/9H+N3fHjHTnoe5Xi2ty6JKYBNGRERERCSY3ZKB1NgVsCzbDPP10Yha9yb8771d67KoCtiEEREREREJpDocyFi3CykzFsGRlYuw8UMRMrw3FG8vrUujKmIT5gSKorjlRZCeTlEUeHnxICURs5GN+cjFbGRjPnK5Yza5P/6KpHFxyPvxNwT07IzwSc/AFB2hdVlO547ZOAObMCIiIiIiIWyXU5EyfREy1n4MrxsbImZ7PHzb3aR1WeRkbMKchPcJk0dVVdjtdhiNRmYjDLORjfnIxWxkYz5yuUM2qs0Gy7ItSI1dDhgU1HhjFIKefBCKh9/I2B2ycQXPTrWa8D5hcjkcDhiNRq3LoBIwG9mYj1zMRjbmI5fkbHL2/4jL4+Jg/eMMgp58CGHjhsAYHqJ1WdVGcjauwiaMiIiIiKgapKSk4PDhw7j99tsRFhYG67lEJE+aj6ztX8CnTXNE7l0C75uaaF0mVQM2YURERERELpKTk4OcnBwAwLlz53D8+HHUrhmJnAUbkbtoEwyBAag5/1UE9L5fV6fj6R2bMCIiIiIiFzl58iSOHz8OALCkWRD+699Qlk5AtiUbiXe3RPDI/qh3e1uNq6TqxibMCfhXC7lMHn4xqztjNrIxH7mYjWzMRy6tsmnYsCFq1aqFjN/O4EzcW6idcBbn69bG9cumo9mN9eDr66tJXZLocb/R3xa7CBsxeXj/NrmYjWzMRy5mIxvzkUvLbByZ2ch+5z1YV25DgI8PvujSEoeiWuLZkDAEalKRLHrdb9iEOQmnqJdHVVU4HA4YDAZmIwyzkY35yMVsZGM+cmmRjaqqyPxwLy5OmAukZ+Jcp1b4ulFt2NUs1DZn45efDuDP40Y0b94cLVq0qJaaJNLrfsMmzAk4Rb1cdrsdBoNB6zKoBMxGNuYjF7ORjfnIVZ3Z5B07gaRxccj95ij8unSA1+gnEV47Er4nE/DFZ5/iP53uROOG9QGApyNCn/sNmzAiIiIiIiewp6YjZeYSpK/aDnPD6xD9wWz43XVr4fORERaYzSZERoQjLCxMw0pJa2zCiIiIiIiqQLXbkb56B1JeXwLVakP45GcQPKQXFHPRr9rBwcFo1qwZgoODNaqUpGATRkRERERUSbnfHsPlsbORf+wEAvs8gLDXnoYpMrzEZcPCwtC1a9dqrpAkYhPmBHq6iNDd6O38YnfCbGRjPnIxG9mYj1zOzsZ2MQnJ0xYic+Mn8L6pCWrtfBc+bZo79TX0Qo/7jbgm7NSpU5g+fTqOHDkCf39/dO/eHS+++CK8vLxKXefSpUtYuXIlDhw4gL///huBgYFo06YNRo0ahVq1ahUu98033+DJJ58stn7Xrl0xe/bsKtXNRkweRVF0ed8Jd8BsZGM+cjEb2ZiPXM7MRs23wrLkA6S8tRKKtxkR77yMwH7doBiNThlfb/S634jaYovFggEDBqBu3bqYN28eEhMTMWvWLOTm5mLixImlrvfLL79g79696NmzJ2666Sakpqbi3XffRe/evfHRRx8Vu/Bx5syZqF+/fuG/Q0NDXbZNpC3eOkAuZiMb85GL2cjGfORyRjbZX3yLpPFzYE04h6CnHkbY2CEwhvBuX1Wlx/1GVBO2fv16ZGVlIT4+HiEhIQD+nbJyypQpGD58OCIjI0tc75ZbbsGuXbuKdNE333wz7r77bmzduhWDBg0qsnyjRo2cej8GVVV1+eGRTlVVWK1WmM1mZiMMs5GN+cjFbGRjPnJVNRvrXxeQPDEeWTu/hk+7mxC5dAq8b2zogkr1R6/7jagTMPft24d27doVNmAA0KVLFzgcDhw4cKDU9YKCgor9jBkVFYWwsDBcunTJVeUSERERkQdzZOci5Y1lONuhP3KP/I6aiychZts8NmBUZaJ+CUtISEDPnj2LPBYUFISIiAgkJCRUaKzTp08jOTkZDRo0KPbcsGHDkJaWhoiICHTr1g3/+9//4OPjU6XaiYiIiMgzqKqKrI++QvLEeNgupSDkmT4IfbE/DAF+WpdGHkJUE5aeno6goKBijwcHB8NisZR7HFVVMX36dNSsWRPdunUrfDwwMBBDhgxBmzZt4O3tjcOHD2P58uVISEjAokWLqlS7qqrFHlMUpcTHC54rbT1Xr6uXcQueYzbyxi14rrRstKjJ08atak0l5SN1W91t3KrWxGxk1nRlNlcuJ7VeiTVJySb/jzNIHj8HOV//AL/O7RD9wWyY69cusiyzcd64rthvqlqTs8ctiagmzFnmzZuHw4cPY+nSpfDz+7+/WDRr1gzNmjUr/He7du1Qs2ZNTJ06FUePHkXLli0r/ZpWq7XIeawGg6HwFEmr1Vps+YLZHu12OxwOR5HnTCYTFEWBw+GA3W4v8lzBuAXnz17NbDaXOq7RaITRaISqqrDZbEWeUxSlcF2bzVbsQ+SqccuzrUDx97Ai41Y0m4Jzkiu6reUZF6je97Bg3JJqclU2Bdta2ntYMG7BZ7ikbLT6fJf1Hlbn5xuQc4woyMeTjxHO/HxX5zGivNm48zGitPdQ6jHCarUWyUcPx4gC7nCMuFY2jvRMWN55D5krtsJ0XRSi1rwBn063wW63F3mv3OUY4Yz3sLqOEVcf19z5GKGq5ZsnQlQTFhQUhIyMjGKPWyyWct9ZfOPGjZg/fz5mzJiBdu3aXXP5Ll26YOrUqTh+/Hilm7CCYEp7wwuCKcmVH+6rGQyGUu+bcOWHoaLjXmvdsqYJddW4ZW0rUPZ7WNa43t7ehbWVd9yCZauyrVpk46r3sDLjluc9LPgCUVI2Wn2+q7LPuSobrY4Rvr6+hf//1TzpGOGqz7crjxGVzcaT3kPJx4iCsa/Ox9OOEe74PaK0bIwGAzI3foKUaYvgyMpG6JjBCHn6URh8vKGqqtsdI9zxOHt1Nu58jChPAwYIa8Lq169f7NqvjIwMXL58uciU8qXZu3cvJk+ejBdeeAG9evVyVZklKusgV5aynnfVuhzXteNKrMndxpVYk7uNW5V1r3XTTGnb6m7jVmVdZiO3poJfV1wxblk87T101bilPZ/70+9IGheHvO9/QUCPTgif/CxMMTU1rbcq67rjuBJrcsW4VxM1O2LHjh1x8OBBpKenFz62e/duGAwGtG/fvsx1v/nmG4waNQq9e/fGiBEjyv2aH3/8MQBUecr6ipwDStWj4OdkZiMPs5GN+cjFbGRjPnJdnY09KRWXRr6B8/cNg5qdg5itcxG5eHKRBoyqh173G1G/hPXt2xerV6/GiBEjMHz4cCQmJiI2NhZ9+/Ytco+wAQMG4MKFC9i7dy8A4NSpUxgxYgTq1q2L7t2746effipcNiwsDHXq1AEAjB49Gtdffz2aNWtWODHHypUrce+991apCdPbh8adOByOUn9uJm0xG9mYj1zMRjbmI5fD4YBBVZG+chtS3lgGAKgx4wUEPfUwlDJOMSPX0+N+I+oTFxwcjFWrVmHatGkYMWIE/P390atXL4wcObLIcldf4Pfzzz8jIyMDGRkZeOyxx4os26NHD8yaNQvAvzdp3rFjB5YvXw6r1YpatWrh6aefxrBhw1y/cURERESkmdxDP8PyWjzyfz+NwMe7IfzVYTDWCNW6LNIpReXPOFVy7NgxqKqKFi1aVOg8UHK9gplx9HYHdnfAbGRjPnIxG9mYj0y2C5eQNGk+srZ+Du9bmqHGrJHwaXWD1mXR/+dp+82xY8cAXPtSJ1G/hBEREREROYOal4+0dzcgdfZ7MPj5IuydlxHcrxsMOjvtjWRiE+YEntC1eyq9nV/sTpiNbMxHLmYjG/ORIWvPQSRPmAfr2X8QPKQnQkcPBAL8oFxjhlHShh73GzZhTsJGTB5FUXS5U7sDZiMb85GL2cjGfLRnTTiHpAlzkb33EHw73oKo1a/Dq0k9rcuiMuh1v2ET5iTlvTs2VR9VVQtzYTayMBvZmI9czEY25qMdR2Y2UuNWI+3dDTDVDEPk8mnw/+9dhTkwG7n0mg2bMCfg3CZy2Wy2Mu96TtphNrIxH7mYjWzMp3qpqorMrZ8hedICOFIsCH3hcYQ8/zgMfj7FlmU2cukxGzZhREREROR28n45iaTxc5B78Cf4d70T4VOfg/n6GK3LIioXNmFERERE5DbsaRlImbUU6Su2wly/NqI3vg2//7TVuiyiCmETRkRERETiqXY7MtZ+jOQZi6Hm5iN84tMIHtoLipe+TmMjz8AmzAn0dBGhu2E2cjEb2ZiPXMxGNubjGrnf/4KksbOR9/MfCHj0foS/9jRMUTUqNAazkUuP2bAJcxI9fnikUxRFdxd5ugtmIxvzkYvZyMZ8nM+WmIyUaQuRsWE3vFo0Qq2PF8CnbYsKj8Ns5NJrNmzCiIiIiEgU1WqDZekHSIldAcVsQo23RiPoif9C0eH9pMgzsQlzEt4nTB5VVWGz2WAymZiNMMxGNuYjF7ORjfk4R/ZX3yNpfBysJ88iaEB3hI0bAmNoUJXGZDZy6TUbNmFOwPuEycVs5GI2sjEfuZiNbMyn8qx//4PkifOR9fFX8LmtJSI/nQTvFo2cNj6zkUuP2bAJIyIiIiLNOHLykBa/Fmlz34chJAg1F05EwCP36upXEdIfNmFEREREVO1UVUXWzq+RPDEetn8uI+TpPggd9SQMAX5al0bkcmzCiIiIiKha5Z/4C0nj5yDny+/g1+l2RG98C14N6mhdFlG1YRPmBPy5XC49TnnqLpiNbMxHLmYjG/MpmyMjCylvrYRl8SaYakci6v1Z8Lvvjmr5LsVs5NJjNmzCnISNmDzMRC5mIxvzkYvZyMZ8Sqc6HMjctAfJU9+FIyMLYS8PQvCzfWDw8a6W12c2cuk1GzZhTsIp6uVRVRV2ux1Go5HZCMNsZGM+cjEb2ZhPyfJ+/gOXx8Uh77vj8O9+D2pMeRamWpHVWgOzkUuv2bAJcwI9TqvpLhwOB4y8saNIzEY25iMXs5GN+fwfe3IaUl5fgvTVO+B1Qz3EbJkD3w43a1YPs5FLj9mwCSMiIiIip1FtNqSv2o6UWUsBh4rw6S8geNDDUEz82klUgHsDERERETlFzqGfkTQuDvm/nkJgv64Ie3U4TBGhWpdFJA6bMCIiIiKqEts/l5E8eQEyN38K75ubotYni+DTuqnWZRGJxSbMCfR0EaG70dv5xe6E2cjGfORiNrLpLR81Lx9pCzci9Z33YPD3QcScsQjs2wWKwaB1acXoLRt3osds2IQ5CRsxeRRF0eVO7Q6YjWzMRy5mI5un55OSkoLDhw/j9ttvR1hYGLL2HkLyhLmw/vUPgoc8gtCXn4IxOFDrMkvk6dm4M71mwybMSThFvTyqqhbmwmxkYTayMR+5mI1snp6PxWLBr7/+ihsCw5C3cAuy9xyE7503I2rV6/C6oZ7W5ZXJ07NxZ3rNhk2YE3CKerlsNpsu78LuDpiNbMxHLmYjm6flk5OTg5ycHABA4tkLaPLFcTje/gg5EaHwn/MKgh7uBC8/P42rLB9Py8aT6DEbNmFEREREVKKTJ0/i+LFjCP7+T9TechBNcvJw7JZGyOrRHkYlE81PnUKLFi20LpPI7bAJIyIiIqISRWVa4ffel8APv+FEnVo41vF6nPS+Ho/feAuuiwpEcHCw1iUSuSU2YURERERUhN2SgdRZy2BZvgW5NYKQMLQLfvD3BazpiDLn4czJozh/xojmzZsjLCxM63KJ3A6bMCfQ00WE7obZyMVsZGM+cjEb2dw9H9XhQMaaj5E8YxHU3HwEjRmE0H4PIMbLjJonE/DFZ5/iP53uROOG9QEAvr6+Gldcfu6ejSfTYzZswpxEjx8e6RRF0d1Fnu6C2cjGfORiNrK5ez65P/6KpLFxyDvyGwJ6dUb4pGdhiqpR+HxkhAVmswmREeFu9+uXu2fjyfSaDZswIiIiIh2zXUpByvRFyFi3E17NGyFmx3z43t6y2HLBwcFo1qwZrwMjcgI2YU7C+4TJo6oqbDYbTCYTsxGG2cjGfORiNrK5Wz6q1QbLss1IjV0OmIyoETsKQU8+BKWUG+eGhYWha9eu1Vylc7hbNnqi12zYhDkB7xMmF7ORi9nIxnzkYjayuUs+2V//gKTxc2D94wyCBjyEsHFDYQzz7F+43CUbPdJjNmzCiIiIiHTCei4RyRPjkbXjS/i0bYHIT5fCu2Vjrcsi0h02YUREREQezpGbh7T565A2530YggJQc8EEBPS6T1enfxFJwiaMiIiIyEOpqors3fuR9No82C5cRsjw3gh9aSAMAX5al0aka2zCnIB/RZLLZOJHXCpmIxvzkYvZyCYpn/yTfyNp/BzkfPEtfP/TFtHr34JXwzpal6UZSdlQUXrMRn9b7CJsxORRFIW5CMVsZGM+cjEb2aTk48jMRurbK5G2aBNMMRGIeu91+D3QQURtWpGSDRWn12zYhDkJp6iXR1VVOBwOGAwGZiMMs5GN+cjFbGTTOh9VVZH5wR4kT3kXjvRMhL40ACHPPgaDr3e11yKN1tlQ6fSaDZswJ9DjtJruwm63w2AwaF0GlYDZyMZ85GI2smmVT97RP5E0Lg653x6D/4N3I3zKCJivi6r2OiTjviOXHrNhE0ZERETkpuwpFqTMXIL093bA3PA6RH84G34db9W6LCK6BjZhRERERG5GtduR/t52pMxcCtjsCJ/yLIIH94Ri5lc7InfAPZWIiIjIjeQcPoqkcXHIP34CgX27IOy1p2GqGaZ1WURUAWzCnEBPFxG6G72dX+xOmI1szEcuZiObK/OxXUxC8pQFyPxgL7xb3YBauxbC59YbXfZ6nob7jlx6zIZNmJOwEZNHURRd3nfCHTAb2ZiPXMxGNlflo+ZbkbZ4E1LfWgnFxwsR77yCwMe7QdHhF9fK4r4jl16z0d8WuwinqJfnylkrmY0szEY25iMXs5HNFflkf/4Nkl6dC+vp8wh+6mGEjhkMY0igU8bWE+47cuk1GzZhTsAp6uWyWq0wm81al0ElYDayMR+5mI1szsrHeuYCkibOQ/au/fC5oxUil02Fd7MGTqhQv7jvyKXHbNiEEREREQnhyM5F2tz3kRa/DobwEEQungz/h+/R1S8ERHrAJoyIiIhIY6qqImvHl0ieNB+2SykIebYvQl/sD4O/r9alEZELsAkjIiIi0lD+76eRND4OOV//CL/77kDMh3Ew16+tdVlE5EJswpyApwjIxWzkYjayMR+5mI1sFcnHnp6J1NjlsCzdDHOdaEStjYV/53YurE7fuO/Ipcds2IQ5iR4/PNIpiqK7izzdBbORjfnIxWxkK28+qsOBjPW7kDJ9ERxZuQgbNwQhTz8KxdurGqrUJ+47cuk1GzZhRERERNUk98hvSBoXh7wffkXAI/cifPKzMEVHaF0WEVUzNmFOwvuEyaOqKmw2G0wmE7MRhtnIxnzkYjaylZWP7XIqUmYsQsbanfBqVh8x2+bB945W2hSqQ9x35NJrNmzCnID3CZOL2cjFbGRjPnIxG9muzke12WBZvhWpbywDDApqzHwRQQMegmLiV7Dqxn1HLj1mwyMAERERkQvkHDiCpHFxyP/9NIL6P4iw8UNhDA/RuiwiEoBNGBEREZET2c4nInnyu8ja9jm82zRH7b1L4H1TE63LIiJB2IQREREROYEjNw/p8euQHr8WBn8/1Ix/FQG974NiMGhdGhEJwybMCfR0EaG7MfGce7GYjWzMRy5mI4+qqsjecxBJr86F7Xwigof2QtjLT8EQ6K91aXQF7jty6TEb/W2xi7ARk0dRFOYiFLORjfnIxWzkyT91FsmvzkX2Z4fhe3cbRK99A16N62pdFl2F+45ces1GXBN26tQpTJ8+HUeOHIG/vz+6d++OF198EV5epd/A8NKlS1i5ciUOHDiAv//+G4GBgWjTpg1GjRqFWrVqFVk2MTER06dPx/79+2E2m9G5c2eMGzcOAQEBVaqbU9TLo6oqHA4HDAYDsxGG2cjGfORiNnI4MrOROvs9pC3cCFNkOCJXzoBflw5QVZXfCQTiviOXXrMR1YRZLBYMGDAAdevWxbx585CYmIhZs2YhNzcXEydOLHW9X375BXv37kXPnj1x0003ITU1Fe+++y569+6Njz76CGFhYQAAq9WKIUOGAADefvtt5Obm4o033sBLL72ERYsWVbpuPU6r6S7sdjsMPBdfJGYjG/ORi9loS1VVZG75DMmTF8CRakHoi/0R8lw/GHy9C+93xHxk4r4jlx6zEdWErV+/HllZWYiPj0dISAiAf0OZMmUKhg8fjsjIyBLXu+WWW7Br164i55PefPPNuPvuu7F161YMGjQIAPDJJ5/gxIkT2LlzJ+rXrw8ACAoKwuDBg3H06FG0bNnStRtIREREbivv+EkkjY9D7qGf4d/tLoRPHQFznWityyIiNySq5dy3bx/atWtX2IABQJcuXeBwOHDgwIFS1wsKCip2QV9UVBTCwsJw6dKlIuM3adKksAEDgPbt2yMkJARfffWV8zaEiIiIPIY9NR2Xx8zGuU6DYU9KQ/SmdxC1cjobMCKqNFG/hCUkJKBnz55FHgsKCkJERAQSEhIqNNbp06eRnJyMBg0aFBn/ygYM+PdiwHr16lV4fCIiIvJsqt2OjDUfI3nGYqj5VoRPfgbBQ3pBMYv6+kREbkjUUSQ9PR1BQUHFHg8ODobFYin3OKqqYvr06ahZsya6detWZPzAwMAqj381RVFKvC6stMcLniuotSJjOmNdvYxb1vrMRttxy1rf07ZVq3GrWlNJy0jdVncbt6o1MZvqqSn3u+NIGheH/KN/IqDPAwh/7WkYa4aV+NoF45aUj57fQ0njMhu547oim6rW5OxxSyKqCXOWefPm4fDhw1i6dCn8/Pyq5TVtNluRfxsMhsJTJK1Wa7HlC2Z7tNvtcDgcRZ4zmUxQFAUOhwN2u73EcVVVLXFcs9lc6rhGoxFGo7HwwuErKYpSuK7NZiv2IXLVuOXZVqD4e1iecQ0GAwwGQ4WzMZvNUBSlwttannGB6n0PC8YtqSZXZVOwraW9hwXZGI3GUt9DrT7fZb2H1fn5BrQ9RgAotr2eeIxwxefb1ccIoOLZuOMxouDLjBbHiLwLl5A6fRGyP9gLc8vGqLltLgLatSqstzzHiIL/66nHCHf8HlGd2fB7xLXHLSubgm2Veoy41veIgqbyWkQ1YUFBQcjIyCj2uMViQXBwcLnG2LhxI+bPn48ZM2agXbt2xcbPzMwscfzo6Kqd113wgShJQTAlufLDfbWCJqIkV34YKjrutdYt64Z5rhq3rG0Fyn4PSxu3YCeoaDYFy1ZlW7XIxhXvYWXHvdZ7WHDwKi0brT7fVdnnXJWNFscI4P+2p6R8POUYUdlxtTxGAJXPxpPeQ1ccI9R8KyxLP0TKmyugeJlR4+2XEdivK5QrxrnWPnfl+3R1Pp50jHDH7xHVmQ2/R1Rs3JKykXiMKKneq1Vkmn1RTVj9+vWLXZuVkZGBy5cvF7uWqyR79+7F5MmT8cILL6BXr14ljv/nn38WeUxVVZw+fRrt27evdN0FX/ZL+zJZlrKed9W6ehm34C8ZBX9Ncda4rlxXL+NeKxstavK0catak9VqrdS+40nvIbORO66za8r+8jskjZ8D66mzCHrqYYSNHQJjSPHLF8ozbmn5ePp76A7jMhu54zo7G2fU5Ip1ryRqdsSOHTvi4MGDSE9PL3xs9+7dMBgM12ySvvnmG4waNQq9e/fGiBEjSh3/999/x5kzZwofO3ToENLS0nDXXXc5ZRuIiIjIPVj//gcXB76Kf3qPgrFGCGp/vgwRs0aW2IARETmTqCasb9++8Pf3x4gRI7B//358+OGHiI2NRd++fYvcI2zAgAHo3Llz4b9PnTqFESNGoG7duujevTt++umnwv/9/fffhcvdf//9aNSoEZ5//nl88cUX2LlzJ8aPH4+7776b9wgjIiLyQCkpKdi5cydSUlIKH3Pk5CEldjnOtn8CuT/+hpqLJyFm2zx439hQw0qJSE9EnY4YHByMVatWYdq0aRgxYgT8/f3Rq1cvjBw5sshyV1/g9/PPPyMjIwMZGRl47LHHiizbo0cPzJo1C8C/57IuXboU06dPx6hRo2AymdC5c2eMHz/e9RtHRERE1c5iseDXX39F06ZNERoaiqyP9yF5YjxsF5MQ8kwfhI58EoaA6pnEi4iogKJWZC5FKubYsWNQVRUtWrSo0Hmg5HoFM+OUdd0RaYPZyMZ85GI25ZOTk4OcnBwAwJ8nE/DFZ5/i3kYtUHP1LtgO/gzve9qi5usvwqvBdU59XeYjF7ORy9OyOXbsGACgRYsWZS4n6pcwd1XapBykrYLZbZiNPMxGNuYjF7Mpn5MnT+L48eOw2uz4+8QFtDx4DCFxO5ERGoizw7qidt//oraTGzCA+UjGbOTSazZswsij6W2HdifMRjbmIxezubaGDRsiJjoa51fuxE0r98Lbmo99rW9CqxnP4bZ6EfD19XXZazMfuZiNXHrMhk2Yk5T3xmxUfVRVhd1uh9FoZDbCMBvZmI9czKZ88o/+iYwJ8+D/0x9IaNoQP7aJQkZMC3SOLN89RyuL+cjFbOTSazZswpyAl9XJ5XA4yrzpKWmH2cjGfORiNqWzJ6checZipL//EXKiQvHX891xrmYg8i4lorZ/Bg58/QUAoHnz5te8XqOymI9czEYuPWbDJoyIiIjcmmqzIX3lNqTMWgoACJ78DEJ73YtaJiPOnTuH3bt344472qF27doA4NLTEYmIyoNNGBEREbmtnIM/IWl8HPJ/TUDg490Q/uowGGuEFlmmefPmqF27NsLCwjSqkoioKDZhRERE5HZsFy4hefICZG75DN63NEOtTxbBp3XTYsuFhYWha9euGlRIRFQ6NmFOoKeLCN2N3s4vdifMRjbmI5fes1Hz8pH27gakzl4Ng78PIuaOQ2CfB6AYDFqXBoD5SMZs5NJjNmzCnISNmDyKouhyp3YHzEY25iOX3rPJ2nMQyRPmwfr3Pwge2hOhLz8FY1CA1mUV0ns+kjEbufSaDZswJ+EU9fKoqlqYC7ORhdnIxnzk0ms21oRzSJowF9l7D8G34y2IWv06vJrU07qsYvSajztgNnLpNRs2YU7AKerlstlsMJvNWpdBJWA2sjEfufSUjSMrB6mz30PauxtgqhmGyOXT4P/fu0R/UdNTPu6G2cilx2zYhBEREZEoqqoic+tnSJ60AI4UC0JfeBwhzz8Og5+P1qURETkFmzAiIiISI++Xk0gaPwe5B3+Cf9c7ET71OZivj9G6LCIip2ITRkRERJqzp2UgZdZSpK/YCnO9Woje8Bb87rlN67KIiFyCTZgTSD43Xe8MQqYspuKYjWzMRy5Py0a125Gx9mMkz1gMNTcfYa8NR8iw3lC83PP6EE/Lx5MwG7n0mA2bMCdhIyaPoigwmfgRl4jZyMZ85PK0bHK//wVJY2cj7+c/END7PoRPfAamqBpal1VpnpaPJ2E2cuk1G/1tMREREWnKlpiMlGkLkbFhN7yaN0LMR/Phe1tLrcsiIqo2bMKc4Mr7G5AcqqrCarXCbDYzG2GYjWzMRy53z0a12mBZ9iFSY1cAJiNqvPkSgvo/CMVDbtTq7vl4MmYjl16zYRNGRERELpe973skjZ8D64m/ETTgIYSNHQJjWLDWZRERaYJNGBEREbmM9exFJE+MR9ZHX8HntpaI/HQpvFs00rosIiJNsQkjIiIip3Pk5CFt/lqkzV0DQ1AAar77GgJ6dtbV6UZERKVhE0ZEREROo6oqsnd9jaTX4mH75zJCnn4UoaMGwBDgp3VpRERiVKoJ+/333/HDDz/g1KlTSE1NhaIoCA0NRf369XHzzTejadOmzq5TNP5VTy6z2T3vM6MHzEY25iOX5GzyT/yFpPFzkPPld/C95zZEb3gLXg3raF1WtZKcj94xG7n0mE25m7Dk5GSsXbsWW7duxYULF6CqKsxmM4KDg6GqKtLT02G1WqEoCqKjo9GjRw889thjqFHDfe/3URFsxORhJnIxG9mYj1xSs3FkZCHl7ZWwLNoEU+1IRK2eCb/724ut11X0tr3uhNnIpddsytWEvfnmm1i7di38/f3xwAMP4I477sCNN96IyMjIIsslJibil19+wYEDB7Bx40YsX74cTzzxBF566SWXFC8Jp6iXR1VV2O12GI1GZiMMs5GN+cglLRtVVZG56RMkT3kXjowshI1+CsEj+sLg4611aZqQlg/9H2Yjl16zKVcT9v333+PNN99Ep06dynxzIiMjERkZiXvuuQcTJkzAZ599hqVLlzqtWKlUVdW6BCqFw+GA0UPuP+NpmI1szEcuKdnk/fwHksbFIfe74/B/6D8InzIC5tqR117Rw0nJh4pjNnLpMZtyNWEbNmyo8MCKouDee+/FvffeW+F1iYiISCZ7igUpry9B+nvbYW5SF9Gb4+B35y1al0VE5FY4OyIRERFdk2q3I33VdqTMXAI4VIRPex7Bg3pAMfOrBBFRRfHISURERGXKOfQzksbFIf+Xkwjs1w1hE4bDFBGqdVlERG6rQk3YyZMnsXjxYpw6dQqhoaHo1q0bHn744WLXiW3fvh1jxozBb7/95tRipdLTRYTuRm/nF7sTZiMb85GrOrOx/XMZyVPeReaHe+HduilqfbIIPjc3q7bXd0fcd+RiNnLpMZtyN2FnzpxB7969Ybfb0bBhQ5w4cQLjxo3Dpk2bMGfOHERERLiyTvHYiMmjKIoud2p3wGxkYz5yVVc2al4+0hZtQurbq6D4eSNi9hgE9usKxWBw+Wu7M+47cjEbufSaTbmbsLi4OPj7+2PNmjW4/vrrAQDbtm3DtGnT0KdPHyxduhT169d3WaHScYp6eVRVLcyF2cjCbGRjPnJVRzZZnx5G8qtzYP3rHwQP6oHQMYNgDA50yWt5Gu47cjEbufSaTbn/pPXzzz/jiSeeKGzAAKB79+7YsGEDDAYD+vXrh6NHj7qkSOk4Rb1cNptN6xKoFMxGNuYjl6uysZ4+j3+eGIuLj70MY3QEan+xHDVe/x8bsAriviMXs5FLj9mUuwlLS0tDjRo1ij3eoEEDrF+/HlFRURgwYAC+/vprpxZIREREruPIzkXKzKU4e+eTyDt2ApFLpiBmyxx4N9Xv2S1ERK5W7tMRa9WqhT/++KPE52rUqIH3338fw4cPxzPPPIOOHTs6rUAiIiJyPlVVkbX9SyRPioftcipCRjyG0P89AYO/r9alERF5vHL/Eta2bVvs3r271J8LAwICsGLFCtx55534/PPPnVYgEREROVf+76dx4ZEXkThkIryaN0Kd/asRPn4oGzAiompS7l/CevTogaSkJBw/fhytWrUqcRkvLy/Mnz8fM2fOxO+//+6sGsXT00WE7obZyMVsZGM+clUlG7slA6mxK2BZthnm66MRte5N+N97uxOrI+47cjEbufSYjaJyVokqOXbsGACgRYsWGldCRERUMtXhQMa6XUievhBqdh5CXxqAkOG9oXh7aV0aEZFHKW9vUKGbNRMREZF7yf3xVySNi0Pej78hoGdnhE96BqZofd/bk4hIa5VuwnJycuDry3PHC/A+YfKoqgqbzQaTycRshGE2sjEfuSqSje1yKlKmL0LG2o/hdWNDxGyPh2+7m6qpUn3iviMXs5FLr9mUe2KOKyUlJeHxxx93di1ui2d0ysVs5GI2sjEfua6VjWq1IW3RJpy9vR+ydu5DjTdGofZnS9mAVRPuO3IxG7n0mE2Ffwk7ffo0hgwZUuI9w4iIiEg7Oft/xOVxcbD+cQZBTz6EsHFDYAwP0bosIiK6SoWasB9++AHPPvssrr/+eixbtsxVNREREVEFWM8lInnSfGRt/wI+bZojcu8SeN/UROuyiIioFOVuwnbv3o1XXnkFjRs3xrJlyxAQEODKuoiIiOgaHLl5sMxfj9Q5q2EI9EfN+a8ioPf9urqugojIHZW7CRs5ciSaNWuGFStWIDAw0JU1uR3+x04uk4kTgErFbGRjPnKZTCaoqorsTw4g6bV5sJ1LRPDw3gh7aSAMgf5al6d73HfkYjZy6TGbcm+xj48PkpKSkJaWxiasBGzE5FEUhbkIxWxkYz5yKYoCa8JZJI2fi5zPv4Hv3W0QvTYWXo2u17o0AvcdyZiNXHrNptyzI65ZswZ2ux1PPvkkzp0758qa3JIeZ3WRTlVV2O12ZiMQs5GN+cjkyMxG0pQFOHvnAFhP/oWoVTMQvfFtNmCCcN+Ri9nIpddsyt2ENWvWDBs2bICvry/69++P8+fPu7Iut6K3D407sdvtWpdApWA2sjEfOVRVRcYHe/D37f2QvvRDBP3vcdT+ejX8u3bU5V+PpeO+IxezkUuP2VToPmG1atXC+vXrERMTg/79+7uqJiIiIgKQd+wELjz4HC49Mw0+bZqj9oH3ETzySRh8vbUujYiIqqDCN2sOCgrCihUrcNNNvOkjERGRK9hT03H5lbdx7t4hsKdaEP3BbEStmA7zdVFal0ZERE5QqalIvLy8MHv2bGfXQkREpGuq3Y701TuQ8voSwGZH+JRnETy4JxSz/mYOIyLyZDyqOwHPyZfLaDRqXQKVgtnIxnyqX843R5E0Lg75x04gsG8XhE0YDlNkeLHlmI1szEcuZiOXHrNxahN29uxZ5Ofno0GDBs4c1i2wEZNHURRd7tTugNnIxnyql+1iEpKnvovMTXvg3eoG1Nq1ED633ljissxGNuYjF7ORS6/ZVKoJe++993DkyJEipySOGzcOW7duBQA0bdoUS5YsQXh48b/geSpVVdmICXPlrJXMRhZmIxvzqR5qvhVpizch9a2VUHy8EPHOKwh8vBsUQ+mXazMb2ZiPXMxGLr1mU+GJOQBg06ZNRRqsr7/+Glu2bMGjjz6KCRMm4Ny5c4iPj3dakdJxinq5rFar1iVQKZiNbMzHtbI//wZn7xqIlGmLEPRYV9Q5vA5B/R8sswErwGxkYz5yMRu59JhNpX4Ju3DhQpFTDnft2oXatWtjypQpAICkpCRs27bNORUSERF5COtfF5D02jxk79oPnztaIXLZVHg3098p/EREelepJuzqX34OHDiATp06Ff67Vq1aSEpKqlplREREHsKRnYu0ue8jLX4dDOEhiFw8Gf4P36OrU2+IiOj/VOp0xLp16+LTTz8F8O+piJcuXULHjh0Ln7948SKCgoKcUyEREZGbUlUVmdu/wNn2TyB13loEP9MHdQ6+j4AendiAERHpWKV+CRs8eDBeeukltGnTBjk5OWjQoAE6dOhQ+Pw333yDG264wWlFSsf/kMrFbORiNrIxn6rL/+M0ksbPQc6+H+B33x2I+TAO5vq1qzwus5GN+cjFbOTSYzaVasK6deuGkJAQfPXVVwgKCkK/fv1gMv07VFpaGoKDg9G9e3enFiqdHj880imKArPZrHUZVAJmIxvzqRp7eiZSY5fDsnQzzHWiEbU2Fv6d2zllbGYjG/ORi9nIpddsFJVT+1XJsWPHAAAtWrTQuBIiItKS6nAgY/0upExfBEdWDkJHDUDI049C8fbSujQiIqom5e0NnHqzZj3jfcLkUVUVNpsNJpOJ2QjDbGRjPhWXe+Q3JI2LQ94PvyKgRyeET34WppiaTn8dZiMb85GL2cil12zKNTFH165dsXXrVuTn55d74Pz8fHz44Yfo2rVrpYtzF/wxUS5mIxezkY35lI89KRWXXpyF8/cPh5qTi5itcxG5eLJLGrACzEY25iMXs5FLj9mU65ewHj16YObMmZgxYwbuuecetGvXDjfeeCNq164NX19fAEB2djbOnTuH48eP4+DBg/jiiy9gNpsxePDgChV06tQpTJ8+HUeOHIG/vz+6d++OF198EV5eZZ/OsWbNGuzbtw8///wzUlNTMWfOHDzwwANFlvnmm2/w5JNPFlu3a9eumD17doXqJCIi/VJtNqSv2IqUN5YBAGq8/j8EDewOxcQTTIiI6NrK9V+LoUOH4rHHHsMHH3yALVu2YNu2bYU/FxqNRgCA3W4H8G8n26hRIzz//PPo1asXAgICyl2MxWLBgAEDULduXcybNw+JiYmYNWsWcnNzMXHixDLXLbg59F133YWtW7eWuezMmTNRv379wn+HhoaWu0YiItK3nANHkDQ+Dvm/nUbgE/9F+PihMNbgf0eIiKj8yv0nu4CAAAwcOBADBw7EuXPncOTIESQkJCAtLQ0AEBISgvr166NVq1a47rrrKlXM+vXrkZWVhfj4eISEhAD4t7mbMmUKhg8fjsjIyDLXNRgMOHfu3DWbsEaNGnEiDSIiqhDbhUtInjQfmVs/h/etN6LWnsXwaaWf27EQEZHzVOq8idq1a6N27arf6+Rq+/btQ7t27QobMADo0qULJk2ahAMHDuCRRx4pdV2DoVL3nXYKPV1E6G5MPDVILGYjG/P5P2pePtIWrEdq3GoY/P0QMW88Ah+9H4pG/91hNrIxH7mYjVx6zEbUFickJKBnz55FHgsKCkJERAQSEhKc9jrDhg1DWloaIiIi0K1bN/zvf/+Dj49PlcZkIyaPoijMRShmIxvz+T9Zew4g6dV5sJ27iOChvRA6eiCMQeU/zd7ZmI1szEcuZiOXXrMR1YSlp6cjKCio2OPBwcGwWCxVHj8wMBBDhgxBmzZt4O3tjcOHD2P58uVISEjAokWLqjS2w+Eo9gFSFKXU2V4Kli3reVetq5dxgX9PZzUYDMxG2LhA2dloUZOnjVuVdR0OBxwOR7F8pG6rK8a1JpxD0oS5yPn0MHw73oqo92fCq3HdIsswG/f8fLtyXFVVi+UjtV6JNTEbuTW5WzZVrcnZ45ZEVBPmas2aNUOzZs0K/92uXTvUrFkTU6dOxdGjR9GyZctKjauqKqxWa5H/IBoMhsKfVq1Wa7F1CmZ7tNvtcDgcRZ4ruE+Cw+EonPDk6nELXvNqBXccL2lco9EIo9FYeD+GKynK/92t3GazFfsQuWrc8mwrUPw9LO+4Vqu12JeVa2VjNpuhKEqFt7U84wLV+x4WjFtSTa7KpmBbS3sPC8a12WzF/vql9ee7rPewOj/fgPbHiLy8vCL3bPHUY8TV4zqycpAxdy3SF2+CKTIc4Usmw7dLh8LjScG2anmMqGg27nqMKOs9lHqMsFqtRe535MnHCHf8HlFd2Wh9jHDH7xFX3yfMnY8Rqlq+eweLasKCgoKQkZFR7HGLxYLg4GCXvGaXLl0wdepUHD9+vNJNGPB/H5bSnivNlR/uqxkMhlKvdbvyw1DRca+1blnn5bpq3LK2FSj7PbzWuBXNpmDZqmyrFtm48j2s6LgVeQ9Lykarz3dV9jlXZaPVMcJkMpWaj6cdIwwGA1RVRdaWz5A85V04Ui0I/d8TCB7xGAx+xU9V1/oYUdls3PUYUdHnqjIu4JxjREn5eNoxwl2/R1RHNlofI6QeZ6817pXZuPMxojwNGCCsCatfv36xa78yMjJw+fLlIlPKS3T1X/SvfPxa61Xmuaqsq5dxC/4SwWzkjXutbLSoydPGrWpNld133PE9zPvlJJLGxSH30M/w79YR4VOfg7lOdJljurqmsp7TUzbuVNOVXx5LykdavRJrYjZya3K3bJxRkyvWvZJ2UwqWoGPHjjh48CDS09MLH9u9ezcMBgPat2/vktf8+OOPAYBT1hMR6Yw9NR2Xx8zGuXsGw56UhuhN7yBq5YxyNWBERERV4ZJfwnJzc5GSkoKYmJgKrde3b1+sXr0aI0aMwPDhw5GYmIjY2Fj07du3yD3CBgwYgAsXLmDv3r2Fjx07dgznz59HSkoKAODnn38GAISFhaFt27YAgNGjR+P6669Hs2bNCifmWLlyJe69994qNWEV6Xqpeml56wIqG7ORzZPzUe12ZKz5GMkzFkPNtyJ80jMIHtITilfpp59I4snZeALmIxezkUuP2VSoCTt06BDi4+Nx6tQphIaGolu3bhg8eDB8fX2LLLdnzx6MGTMGv/32W4WKCQ4OxqpVqzBt2jSMGDEC/v7+6NWrF0aOHFlkuZIu8FuzZg22bNlS+O/ly5cDANq2bYvVq1cD+PcmzTt27MDy5cthtVpRq1YtPP300xg2bFiF6iwJGzF5FEXR5X0n3AGzkc2T88n97jiSxsUh7+c/EPDoAwh/bThMUTW0LqvcPDkbT8B85GI2cuk1G0Ut51yKx48fR58+fRAcHIxbb70Vly9fxk8//YQ6depgwYIFaNCgQeGy27dvr1QT5o6OHTsGAGjevDkbMWGu/GgzG1mYjWyemI8tMRnJUxcic+NueLVsjIiZL8Knrfudhu6J2XgS5iMXs5HL07Ip6A2udZZdudvOefPmoXbt2tiwYQNCQkIAAN9//z1eeuklPPbYY1iwYAFuvfXWylfsxipyTwCqXlartcwZbkg7zEY2T8lHtdpgWfIBUt5cAcXLjBpvjUbQE/+FUsqsWO7AU7LxVMxHLmYjlx6zKfcJmL/88gv69OlT2IABwK233ootW7agTp06GDx4MD799FNX1EhERFRh2V9+h7N3DUTylHcR2Pt+1Dm8FsEDurt1A0ZERJ6h3E1YdnY2AgMDiz0eFhaG1atX49Zbb8WLL76ITZs2ObVAIiKiirD+/Q8uDnwV//QeBWN4CGp/tgwRsaNgDA3SujQiIiIAFWjC6tSpg6NHj5b4nK+vLxYuXIjOnTtj4sSJWLdundMKJCIiKg9HTh5S3lyBs+2fQO4Pv6LmwomI2T4P3s0bal0aERFREeVuwu644w7s2bMHOTk5JT5vNpvxzjvvoG/fvjhy5IjTCiQiIiqLqqrI/Hgfznboj9TZ7yF4aG/UObQGgT07e8RF3kRE5HnKPTFHr169oKoqTp8+jWbNmpW4jKIomDRpEq6//nr88ccfTitSupLu8E3aUxQFZrOZ2QjEbGRzp3zyT/yFpPFzkPPld/DrdDuiN74FrwZ1tC7LZdwpGz1iPnIxG7n0mk25p6inkpV3GkoiInIeR0YWUt5aCcviTTDVjkSN6S/A7747dPcfcSIiksXpU9RT2VRV5X/8hVFVFXa7HUajkdkIw2xkk5yP6nAgc9MeJE99F47MbIS9PAjBz/aBwcdb69KqheRsiPlIxmzk0ms2lW7CkpKSUKNGDWfW4rb4Y6JcDocDRk5HLRKzkU1iPnk//4HL4+KQ991x+He/BzWmPAtTrUity6p2ErOh/8N85GI2cukxm3JPzHGlU6dO4dFHH3V2LURERMXYk9Nw+aU3ca7zUKiZ2YjZMgdRS6fosgEjIiLPUOFfwr7//nuMGDECt9xyiyvqISIiAgCoNhvSV21HyqylgENF+PQXEDzoYSgmnklPRETurUL/Jdu1axfGjh2Ldu3aYe7cua6qiYiIdC7n4E9IGh+H/F8TENivK8JeHQ5TRKjWZRERETlFuZuw5cuX480338Rdd92F+Ph4mPiXyEJ6uojQ3fBzKhezkU2rfGz/XEby5AXI3PwpvG9uilqfLIJP66aa1CIV9x3ZmI9czEYuPWZT7i2OjY1FmzZtMG/ePF2+UdfCRkwe3r9NLmYjmxb5qHn5SFu4EanvvAeDvw8i5oxFYN8uUAyVunTZY3HfkY35yMVs5NJrNuXupmrUqIHff/8dv/32G1q2bOnKmtwSp6iXR1XVwlyYjSzMRrbqzidr7yEkT5gL61//IHjIIwh9ZRCMQQEuf113xH1HNuYjF7ORS6/ZlPtPjBs3bkTNmjUxePBgHD9+3JU1uR1OUS+XzWbTugQqBbORrTrysSacwz+Pj8HFfq/AVKsmrvtyBWpMf4EN2DVw35GN+cjFbOTSYzblbsJiYmKwbt06NGnSBIMGDcIvv/ziyrqIiMhDObJykDxjMf6+80nk/3ISkcumIvrDOHjdUE/r0oiIiKpFhU62DwoKwvLly9G+fXsMGjTIVTUREZEHUlUVmVs+w993PAHLuxsQ+nw/XHdwDQIe+o+uTkEhIiKq8AwbXl5emD17NmJjY11RDxEReaC8X08hafwc5B44Ar8uHVBj6vMw143RuiwiIiJNVHqaw1deecWZdbg1/gVXLgNnVhOL2cjmrHzslgykzloGy4qtMNeNQfT6t+DX6TanjK1X3HdkYz5yMRu59JhNuZuw7777Dg0aNEBYWJgr63FbbMTkURSFt1MQitnI5ox8VIcDGWs+RvKMRVBz8xE2YRhChvWG4mV2UpX6xH1HNuYjF7ORS6/ZlLvtfPLJJ3HgwAFX1kLkdJy5Ui5mI1tV8sn94Recf+BpXB4VC797bkOdw2sR+lw/NmBOwn1HNuYjF7ORS4/ZlLvt1OObU15X3t+A5FBVFVarFWazmdkIw2xkq2w+tkspSJm+CBnrdsKreSPEfDQfvrfxvpLOxH1HNuYjF7ORS6/Z6O+3PyIicirVaoNl2Wakxi4HTEbUePMlBPV/EIrRqHVpREREIlWoCdNTd0pERNeW/fUPSBoXB+uJvxE04CGEjR0CY1iw1mURERGJVqEm7OWXX8bLL79crmUVRcGvv/5aqaKIiEg267lEJE+MR9aOL+HTtgUi9y6Bd8vGWpdFRETkFirUhN1xxx2oW7eui0ohIiLpHLl5SJu/Dmlz3ochKAA1330NAT0780wJIiKiCqhQE/bwww/jwQcfdFUtbotfPuQymzkbm1TMRrar81FVFdm79yPptXmwXbiMkKcfReioATAE+GlUoX5x35GN+cjFbOTSYzacmMNJ2IjJw0zkYjayXZ1P/sm/kTR+DnK++Ba+99yG6PVvwathHY2q0zfuO7IxH7mYjVx6zYZNmJNwinp5VFWF3W6H0WhkNsIwG9kK8lFy8pD2ziqkLdoEU0wEolbPhN/97ZmZhrjvyMZ85GI2cuk1GzZhTsB7qMnlcDhg5DTZIjEbuVRVRcamT2CZsQSO9EyEvjQAISMeg8HHW+vSCNx3pGM+cjEbufSYTbmbsN9//92VdRARkQB5R//E5XFxyPv2GPwfvBvhU0bAfF2U1mURERF5FP4SRkREsKdYkDJzCdJXbYe58fWIWP8mAu+5TVenhhAREVUXNmFERDqm2u1If287UmYuBWx2hE99DkGDesAGnmZNRETkKmzCnIB/KZZLb+cXuxNmo72cw0eRNC4O+cdPIPCxrgibMBymmmFQVRVGh0Pr8qgU3HdkYz5yMRu59JgNmzAnYSMmj6Ioutyp3QGz0ZbtYhKSpyxA5gd74d26KWrtXgifW24sfJ75yMVsZGM+cjEbufSaDZswJ+EU9fKoqlqYC7ORhdloQ823Im3RRqS+vQqKrzciZo9BYL+uUAyGossxH7GYjWzMRy5mI5des2ET5gScol4um82my7uwuwNmU72yP/sGSa/OgfXMBQQP6oHQMYNgDA4sdXnmIxezkY35yMVs5NJjNmzCiIg8mPXMBSS9Ng/Zu/fDp31rRC6fBu9mDbQui4iISNfYhBEReSBHdi7S5ryPtPnrYAgPQeSSKfDv/h9dnepBREQkFZswIiIPoqoqsrZ/ieRJ8bBdTkXIiMcQ+r8nYPD31bo0IiIi+v/YhDkB/7IsF7ORi9k4X/7vp5E0Pg45X/8Iv/vbI2ba8zDXq1WpsZiPXMxGNuYjF7ORS4/ZsAlzEj1+eKRTFEV3F3m6C2bjXHZLBlJjV8CybDPM10cjat2b8L/39kqPx3zkYjayMR+5mI1ces2GTRgRkZtSHQ5krNuFlBmL4MjKRdj4oQgZ3huKt5fWpREREVEZ2IQ5Ce8TJo+qqrDZbDCZTMxGGGZTdbk//oqkcXHI+/E3BPTsjPBJz8AUHeGUsZmPXMxGNuYjF7ORS6/ZsAlzAt4nTC5mIxezqRzb5VSkTF+EjLUfw+vGhojZHg/fdjc5/XWYj1zMRjbmIxezkUuP2bAJIyJyA6rNBsuyLUiNXQ4YFNR4YxSCnnwQiomHcSIiInfD/3oTEQmXs/9HXB4XB+sfZxDU/0GEjR8KY3iI1mURERFRJbEJIyISynouEcmT5iNr+xfwbtMctfcugfdNTbQui4iIiKqITZgT6OkiQnejxylP3QWzKZ0jNw+WBRuQGvceDAH+qBn/KgJ63wfFYKi2GpiPXMxGNuYjF7ORS4/ZsAlzEjZi8jATuZhNyVRVRfaeg0iaMBe2c4kIHtYbYaMHwhDoX611MB+5mI1szEcuZiOXXrNhE+YknKJeHlVV4XA4YDAYmI0wzKa4/FN/I/nVecj+7DB8726D6DVvwKtxXU1qYT5yMRvZmI9czEYuvWbDJswJ9Ditpruw2+0wVOMpXFR+zOZfjsxspL7zHtIWboApOgKRK2fAv+udmv+HiPnIxWxkYz5yMRu59JgNmzAiIg2oqorMzZ8iefICONLSETrySYQ81w8GX2+tSyMiIiIXYxNGRFTN8o6fRNK4OOQe/hn+3e5C+NQRMNeJ1rosIiIiqiZswoiIqok9NR0pM5cifdU2mBteh+gPZsPvrlu1LouIiIiqGZswJ9D62g0qndFo1LoEKoWeslHtdqS//xFSXl8CNd+K8MnPIHhILyhmuYdgPeXjbpiNbMxHLmYjlx6zkfsNwM2wEZNHURRd7tTuQE/Z5H57DJfHxSH/6J8I7PMAwl57GqbIcK3LKpOe8nE3zEY25iMXs5FLr9mwCXMSTlEvj6qqhbkwG1n0kI3tYhKSpy1E5sZP4H1TE9Ta+S582jTXuqxy0UM+7orZyMZ85GI2cuk1GzZhTsAp6uWy2Wy6vAu7O/DUbNR8KyxLPkDKWyuheJsR8c7LCOzXDYqb/ZXPU/PxBMxGNuYjF7ORS4/ZsAkjInKS7C++RdL4ObAmnEPQUw8jbOwQGEMCtS6LiIiIhGETRkRURda/LiB5Yjyydn4Nn3Y3IXLpFHjf2FDrsoiIiEgocbemPnXqFJ566im0atUK7du3R2xsLPLz86+53po1azB8+HDcfvvtaNKkCXbv3l3icomJiXj++efRunVrtG3bFq+++ioyMzOdvRlEpAOO7FykvLEMZzv0R+6R31Fz8STEbJvHBoyIiIjKJOqXMIvFggEDBqBu3bqYN28eEhMTMWvWLOTm5mLixIllrrtt2zYAwF133YWtW7eWuIzVasWQIUMAAG+//TZyc3Pxxhtv4KWXXsKiRYsqXbeeLiJ0N8xGLnfORlVVZH30FZInxsN2KQUhz/RB6Iv9YQjw07o0p3HnfDwds5GN+cjFbOTSYzaimrD169cjKysL8fHxCAkJAQDY7XZMmTIFw4cPR2RkZJnrGgwGnDt3rtQm7JNPPsGJEyewc+dO1K9fHwAQFBSEwYMH4+jRo2jZsmWla9fjh0c6RVF0d5Gnu3DnbPL/OI2k8XOQs+8H+HVuh+gPZsOrwXVal+VU7pyPp2M2sjEfuZiNXHrNRtTpiPv27UO7du0KGzAA6NKlCxwOBw4cOFDmugbDtTdl3759aNKkSWEDBgDt27dHSEgIvvrqq0rXTUSez5GRhaSJ8Th791Ow/n0RUWtmIXptrMc1YEREROR6opqwhISEIg0S8O8vVREREUhISHDJ+IqioF69elUen9PUy6OqKqxWK7MRyJ2yUR0OpK/fhb9v64f0VdsQ9sogXPf1Kvjf117r0lzGnfLRG2YjG/ORi9nIpddsRJ2OmJ6ejqCgoGKPBwcHw2KxOGX8wMDi00VXdfyCm8xdTVGUUj9QBacvlvW8q9bVy7gA4HA4mI3AcYGys9GippLWzfv5DySNjUPeD7/A/+F7ED7pGZhqRRYZR1K9zlpXVdUS85G6re42blVrYjYyayr4LnB1PlLrlVgTs5Fbk7tlU9WanD1uSUQ1Ye7MarUWuS7MYDDAZDIVPnc1Ly8vAP9e8+ZwOIo8ZzKZoCgKHA4H7HZ7kecKxi34q8HVCs6pLWlco9EIo9EIVVVhs9mKPHfl+bg2m63Yh8hV45ZnW4Hi72FFxq1oNmazGYqiVHhbyzMuUL3vYcG4JdXkqmwKtrW097Bg3ILPcEnZaPX5LthWe3IaLG8sR9banTDfUA8xW+fCu91NsNlsRepy5Xso5RhRkI8nHyOc+fmuzmNEebNx52NEae+h1seI0sa1Wq1F8tHDMaKAOxwjqisbKceIAu5wjLj6uObOxwhVVYt8tymNqCYsKCgIGRkZxR63WCwIDg52yvglTUdvsVgQHR1dpbELPiylPVeaKz/cVzMYDKVe63blh6Gi415r3YKdojrHLWtbgbLfw2uNW9FsCpatyrZqkY0r38OKjluR97CkbLT6fCsOB7Lf247UWcsAAOEzXkDQwO4wmM1QVVWTbLQ6RphMplLz8bRjhCs/3xUZt4CrsvGk91CrY0R597mS8vG0Y4S7fo+ojmy0Pka463H2ymzc+RhRngYMENaE1a9fv9i1WRkZGbh8+XKxa7kqO/6ff/5Z5DFVVXH69Gm0b1+16zsK/qpS0uPXWq8yz1VlXb2MW/CXCGYjb9xrZaNFTTkHjiBpfBzyfzuNwMe7IfzVYTDWCK3yuK6q19U1VXbfcafPoVbjVrUmZiOzpiu/PJaUj7R6JdbEbOTW5G7ZOKMmV6x7JVETc3Ts2BEHDx5Eenp64WO7d++GwWCocpNUMP7vv/+OM2fOFD526NAhpKWl4a677qr0uBV5w6l6lfXXCtKWlGxsFy4hcdhkXHj4BSi+Pqi1ZzFqzh5TpAHTIyn5UHHMRjbmIxezkUuP2Yja4r59+2L16tUYMWIEhg8fjsTERMTGxqJv375F7hE2YMAAXLhwAXv37i187NixYzh//jxSUlIAAD///DMAICwsDG3btgUA3H///Vi0aBGef/55jBo1Cjk5OYiNjcXdd99dpXuEAWzEJCrrVxbSloRs1Lx8pL27Aamz34PB3xcRc8chsM8DUMpxuwtPJyEfKhmzkY35yMVs5NJrNqKasODgYKxatQrTpk3DiBEj4O/vj169emHkyJFFlivpAr81a9Zgy5Ythf9evnw5AKBt27ZYvXo1gH/PNV26dCmmT5+OUaNGwWQyoXPnzhg/fnyVay/vRXhUfQpm26nI+blUPbTOJmvPQSRPmAfr2X8QPKQnQl9+CsaggGqvQyqt86HSMRvZmI9czEYuvWajqBWZS5GKOXbsGFRVRYsWLXT1wXEHBTPjlDUxB2lDq2ysCeeQNGEusvcegm/HW1Dj9f/Bq0m9ant9d8F9Ry5mIxvzkYvZyOVp2Rw7dgwA0KJFizKXE/VLGBGRKzgys5Eatxpp726AqWYYIpdPg/9/7/KIgz0RERG5HzZhROSxVFVF5tbPkDxpARwpFoS+8DhCnn8cBj8frUsjIiIiHWMTRkQeKe+Xk0gaPwe5B3+Cf9c7ET71OZivj9G6LCIiIiI2Yc7AU5rkKuvmgKQtV2VjT8tAyqylSF+xFeb6tRG98W34/aetS17Lk3HfkYvZyMZ85GI2cukxGzZhTsJGTB5FUXR53wl34IpsVLsdGWs/RvKMxVBz8xE+8WkED+0Fxav0u95TybjvyMVsZGM+cjEbufSajf622EU4Rb08V078yWxkcXY2ud//gqSxs5H38x8IePR+hL/2NExRNao8rl5x35GL2cjGfORiNnLpNRs2YU7AWf7lKpjylORxRja2xGSkTFuIjA274dWiEWI+mg/f26p243X6F/cduZiNbMxHLmYjlx6zYRNGRG5HtdpgWfoBUt9cCZiMqPHWaAQ98V8oRqPWpRERERFdE5swInIr2V99j6TxcbCePIugAd0RNm4IjKFBWpdFREREVG5swojILVjPXkTya/HI+vgr+NzWEpGfToJ3i0Zal0VERERUYWzCiEg0R04e0uLXIm3u+zCEBKHmwokIeOReXV28S0RERJ6FTZgTKIrCL4QCKYoCLy8vrcugEpQnG1VVkbXzayRPjIftn8sIeboPQkc9CUOAXzVVqV/cd+RiNrIxH7mYjVx6zYZNGBGJk3/iLySNn4OcL7+DX6fbEb3xLXg1qKN1WUREREROwSbMSXifMHlUVYXdbofRaGQ2wpSWjSMjCylvrYRl8SaYakci6v1Z8LvvDuZXzbjvyMVsZGM+cjEbufSaDZswJ+B9wuRyOBwwctpyka7MRnU4kLlpD5KnvgtHRhbCXh6E4Gf7wODjrXGV+sV9Ry5mIxvzkYvZyKXHbNiEEZGm8n7+A5fHxSHvu+Pw734Pakx5FqZakVqXRUREROQybMKISBP2FAvSYlcg4/2P4HVDPcRsmQPfDjdrXRYRERGRy7EJI6JqpdpssKzchtQ3lgEOFeHTX0DwoIehmHg4IiIiIn3gtx4n0NNFhO7GxC/2ouQc+hlJ4+KQ/8tJBPTrhvBXh8FUM0zrsqgE3HfkYjayMR+5mI1cesxGf1vsImzE5OH92+Sw/XMZyZMXIHPzp/Bu3RS1PlkEn5ubaV0WlYL7jlzMRjbmIxezkUuv2bAJcxJOUS+PqqpwOBwwGAzMRiNqXj7SFm1C6turoPh5IyJuLAIf6wIoCux2O7MRivuOXMxGNuYjF7ORS6/ZsAlzAk5RL1fBF32qflmfHkbyq3Ng/esfBA9+BKGvPAVjcCCA/7snCLORi/nIxWxkYz5yMRu59JgNmzAicirr6fNIem0esj85AJ8ONyNy5Qx4N62vdVlEREREYrAJIyKncGTlIHXO+7AsWA9jjRBELp0K/4fu1tWpBURERETlwSaMiKpEVVVkbfsCyZPnw56UhpARjyHkhcdh8PfVujQiIiIikdiEOQH/0i+X3s4vrm55vyUgafwc5O7/EX4PdECNac/DXDemXOsyG9mYj1zMRjbmIxezkUuP2bAJcxI2YvIoiqLL+05UB7slA6lvLIdl+RaY68Ygev1b8Ot0W7nXZzayMR+5mI1szEcuZiOXXrPR3xaTrvDWAc6lOhzIWLsTyTMWQc3JQ9irQxEy/FEoXuaKj8VsRGM+cjEb2ZiPXMxGLj1mwybMCVRV1eWHRzpVVWG1WmE2m5mNE+T++CuSxsYh78hvCOjVGeGTnoUpqkalxmI2sjEfuZiNbMxHLmYjl16zYRNGRGWyXUpByvRFyFi3E17NGyFmx3z43t5S67KIiIiI3BabMCIqkWq1wbJsM1JjlwMmI2rEjkLQkw9BMRq1Lo2IiIjIrbEJI6Jisr/+AUnj58D6xxkEDXgIYeOGwhgWrHVZRERERB6BTRgRFbKeS0TyxHhk7fgSPm1bIPLTpfBu2VjrsoiIiIg8CpswJ9DTRYTuxmyu+Kx9euTIzUPa/HVIm/M+DIH+qLlgAgJ63efSzzazkY35yMVsZGM+cjEbufSYDZswJ2EjJg8zuTZVVZG9ez+SXpsH2/lLCB7eG2EvDYQh0N+lr8tsZGM+cjEb2ZiPXMxGLr1mwybMSThFvTyqqsJut8NoNDKbEuSf/BtJ4+cg54tv4Xt3G0SvexNeja6vltdmNrIxH7mYjWzMRy5mI5des2ET5gSqqmpdApXC4XDAyNn8inBkZiP1nVVIW7gRpugIRK2aAb8ud1b7gY/ZyMZ85GI2sjEfuZiNXHrMhk0YkU6oqorMD/ciefICOCwZCB31JEJG9IPB11vr0oiIiIh0hU0YkQ7kHTuBpHFxyP3mKPz/exfCpz4H83VRWpdFREREpEtswog8mD3FgpRZS5G+ajvMDa9D9Iez4dfxVq3LIiIiItI1NmFOoKeLCN2N3s4vLqDa7UhfvQMpry8BbHaET3kWwYN7QjHL2eX1mo27YD5yMRvZmI9czEYuPWYj5xuZm2MjJo+iKLrcqXO+OYqkcXHIP3YCgX27IOy1p2GqGaZ1WUXoNRt3wXzkYjayMR+5mI1ces2GTZiTcIp6eVRVLcxFD9nYLiYheeq7yNy0B96tbkCtXQvhc+uNWpdVIr1l426Yj1zMRjbmIxezkUuv2bAJcwJOUS+XzWbz+Luwq/lWpC3ehNS3VkLx8ULEO68g8PFuUAwGrUsrkx6ycWfMRy5mIxvzkYvZyKXHbNiEEbmx7M+/QdKrc2E9fR7BTz2M0DGDYQwJ1LosIiIiIioDmzAiN2Q9cwFJE+che9d++NzRCpHLpsK7WQOtyyIiIiKicmATRuRGHNm5SJv7PtLi18EQHoLIxZPh//A9ujqHmoiIiMjdsQlzAn4BlstTslFVFVk7vkTypPmwXUpByLN9Efpifxj8fbUurdI8JRtPxXzkYjayMR+5mI1cesyGTZiT6PHDI52iKB5xkWf+76eRND4OOV//CL/77kDMh3Ew16+tdVlV4inZeCrmIxezkY35yMVs5NJrNmzCiISyp2ciNXY5LEs3w1wnGlFrY+HfuZ3WZRERERFRFbEJcxLeJ0weVVVhs9lgMpncKhvV4UDG+l1Imb4IjqxchI0bgpCnH4Xi7aV1aU7jrtnoBfORi9nIxnzkYjZy6TUbNmFOwPuEyeVu2eQe+Q1J4+KQ98OvCHjkXoRPegammJpal+US7paN3jAfuZiNbMxHLmYjlx6zYRNGJIA9KRXJ0xchY+1OeDWrj5ht8+B7RyutyyIiIiIiF2ATRqQh1WaDZflWpL6xDFCAGjNfRNCAh6CYuGsSEREReSp+0yPSSM6BI0gaF4f8308jqP+DCBs/FMbwEK3LIiIiIiIXYxPmBHq6iNDdSJzy1HY+EUmTFiBr2+fwbtMctfcugfdNTbQuq9pJzIb+D/ORi9nIxnzkYjZy6TEbNmFOwkZMHmmZOHLzYFmwAalzVsPg74ea8a8ioPd9UAwGrUurdtKyoaKYj1zMRjbmIxezkUuv2bAJcxJOUS+Pqqqw2+0wGo2aZ5O15wCSXp0H27mLCB7WG2GjB8IQ6K9pTVqSlA0Vx3zkYjayMR+5mI1ces2GTZgT6HFaTXfhcDhgNBo1e/38U2eRPGEusj89DN+72yB6zSx4Na6rWT2SaJ0NlY35yMVsZGM+cjEbufSYDZswIhdwZGYjdfZ7SFu4EabIcESunAH/rnfq6i88RERERFQyNmFETqSqKjK3fIbkyQvgSLUg9MX+CHmuHwy+3lqXRkRERERCsAkjcpK84yeRND4OuYd+hn+3uxA+dQTMdaK1LouIiIiIhBE3LdupU6fw1FNPoVWrVmjfvj1iY2ORn59/zfVUVcXixYtx9913o2XLlujTpw9++umnIst88803aNKkSbH/jRw5sko18xQzuarj/GJ7ajouj5mNc50Gw56UhuhN7yBq5XQ2YNegt3O/3Q3zkYvZyMZ85GI2cukxG1G/hFksFgwYMAB169bFvHnzkJiYiFmzZiE3NxcTJ04sc90lS5Zg7ty5GD16NJo0aYI1a9Zg0KBB2LZtG6677roiy86cORP169cv/HdoaGiVa2cjJo+iKC7dqVW7HRlrPkbyjMVQ860In/wMgof0gmIWtVuJ5OpsqGqYj1zMRjbmIxezkUuv2Yj6trh+/XpkZWUhPj4eISEhAAC73Y4pU6Zg+PDhiIyMLHG9vLw8LFq0CIMGDcLAgQMBALfccgseeOABLFu2DJMnTy6yfKNGjdCiRQun1s4p6uVRVbUwF2dnk/vdcVweOxv5R/9EwKMPIHzi0zBFhjv1NTyZK7OhqmM+cjEb2ZiPXMxGLr1mI+p0xH379qFdu3aFDRgAdOnSBQ6HAwcOHCh1vR9//BGZmZno0qVL4WNeXl7o3Lkz9u3b58qSAXCKeslsNptzx0tMRuKIGTjf9RkAQK2PFyBy/qtswCrB2dmQczEfuZiNbMxHLmYjlx6zEdWEJSQkFDlNEACCgoIQERGBhISEMtcDUGzdBg0a4MKFC8jNzS3y+LBhw9C0aVN07NgRb7zxRrHnia6mWm1IW7Aef9/eD9mfHkLE2y+j9p7F8Gnr3F9UiYiIiMjziTodMT09HUFBQcUeDw4OhsViKXM9Ly8veHsXnQY8KCgIqqrCYrHAx8cHgYGBGDJkCNq0aQNvb28cPnwYy5cvR0JCAhYtWlSl2kv6NUxRlFJ/JSv4ubWs5121rl7GLXiuqtlkf/kdkl+dA+upcwga2B1hY4fAEBJY4mt72nuoVTZa1ORp41a1ppLykbqt7jZuVWtiNjJrujKbK5eTWq/EmpiN3JrcLZuq1uTscUsiqglztWbNmqFZs2aF/27Xrh1q1qyJqVOn4ujRo2jZsmWlx7ZarUXOYzUYDDCZTIXPXc3LywvAv9e8ORyOIs+ZTCYoigKHwwG73V7kuYJxVVUtcVyz2VzquEajEUajEaqqFvvZV1GUwnVtNluxD5Grxi3PtgLF38OKjFvRbMxmMxRFQd6Z80iZNB85u/bD+7YWiJw/Ab4tG8NoNMLhcBTb1vKMC1Tve1gwbkk1uSqbgm1VFKXMz3fBZ7ikbLT6fJf1Hlbn5xuQc4woyMeTjxHO/HyXta3OPkaUNxt3PkaU9h5KPUZYrdYi+ejhGFHAHY4R1ZWNlGNEAXc4Rlx9XHPnY4Sqlm+eCFFNWFBQEDIyMoo9brFYEBwcXOZ6+fn5yMvLK/JrWHp6OhRFKXPdLl26YOrUqTh+/HiVmrCCD0tpz5Xmyg/31QwGAwyGks8YvfLDUNFxr7VuwU5RneOWta1A2e/hteot2FnLO66am4/UeWuQNm8NDCFBqLlwIvx7dCoyxrW2VYtsXPUeVmbcgvfqWp/v0rLR6vNdlX3OVdloeYwoLR9POka46vPt6mNEZbLxpPdQ8jFCUZQS8/HEY0RppB4jqisbCceI0kg9RlydjTsfI8rTgAHCmrD69esXu/YrIyMDly9fLna919XrAcDp06dxww03FD6ekJCAmJgY+Pj4uKbg/09RlDIPctdatzLPVWVdPY1b8JfC8qynqiqyPt6H5InxsF1MQsgzfRA68kkYAvycWpO7vYdaZKNVTZ40blXWNRgMFdp3nPGcnsatyrrMRm5NBb+ulJaPtHol1sRs5NbkbtlUtSZXjHs1URNzdOzYEQcPHkR6enrhY7t374bBYED79u1LXe/mm29GQEAAdu3aVfiY1WrFnj170LFjxzJf8+OPPwYAp09ZT+4l/88z+Kf3KCQ+NQFeTeriuq/fQ/hrT5fYgBERERERVYWoX8L69u2L1atXY8SIERg+fDgSExMRGxuLvn37FrlH2IABA3DhwgXs3bsXAODt7Y3hw4dj3rx5CAsLQ+PGjbFu3TqkpaVh8ODBheuNHj0a119/PZo1a1Y4McfKlStx7733VrkJK+/5n1R9Cs7pLet0REdGFlLeXAHLkg9gqh2FqDWz4H9f6Q0/OUd5siHtMB+5mI1szEcuZiOXXrMR1YQFBwdj1apVmDZtGkaMGAF/f3/06tULI0eOLLJcSRf4DR06FKqqYvny5UhJSUHTpk2xbNkyXHfddYXLNGrUCDt27MDy5cthtVpRq1YtPP300xg2bFiV6q7ITChUvUrLRnU4kLHxE6RMXQhHVjbCXhmE4Gf6wODjXeLy5Hzcb2RjPnIxG9mYj1zMRi49ZqOoetxqJzp27BhUVUWLFi101b27g4KZca6eNCXv5z9weVwc8r47joCH70H45GdhqhVZxkjkbKVlQzIwH7mYjWzMRy5mI5enZXPs2DEA177USdQvYUSuZE9OQ/KMxch4/yN43VAPMVvnwrd9a63LIiIiIiKdYRNGHk+12ZC+ajtSZi0FANSY8QKCnnoYShlTjBIRERERuQq/hTqBJ/x06qms3/2CxPFzkP9bAgIf74bwV4fBWCNU67IIZd9ng7THfORiNrIxH7mYjVx6zEZ/W+wibMRksV24hOTJC5C55TN439IMtT5ZBJ/WTbUui/6/gvuCkEzMRy5mIxvzkYvZyKXXbNiEOQmnqJdBzctH2rsbkDp7NQx+PgiPG4Ogvl1gKOWu6KQNVVXhcDgqdGd5qj7MRy5mIxvzkYvZyKXXbNiEOQEnmJQha89BJE+YB+vf/yB4aE+Ejh4Iu683FIOoe5LT/2e322FgNmIxH7mYjWzMRy5mI5ces2ETRm7PmnAOSa/NQ/aeg/C982ZEvfc6vG6oB1VVYbdatS6PiIiIiKgINmHkthxZOUiNW420BethqhmGyGVT4f/g3br6KZuIiIiI3A+bMHI7qqoia+vnSJq8AI7kNIQ+3w8hLzwBg5+P1qUREREREV0TmzAn4C8v1Sfv11NIGj8HuQeOwK9LB9SY+jzMdWNKXV5v5xe7E2YjG/ORi9nIxnzkYjZy6TEbNmFOwkbMtexpGUh9YxksK7bCXDcG0Rvegt89t5W5jqIourzvhDtgNrIxH7mYjWzMRy5mI5des9HfFrsIp6h3DdXhQMaaj5E8YxHU3HyETRiGkGG9oXiZr73uFbNWMhtZmI1szEcuZiMb85GL2cil12zYhDkBp6h3jdwffkHS2Djk/fQ7Anrfh/CJz8AUVaNCY1itVpjN127YqPoxG9mYj1zMRjbmIxezkUuP2bAJI3Fsl1KQMm0hMtbvglfzRoj5aD58b2updVlERERERE7BJozEUK02WJZ9iNTYFYDJiBpvvoSg/g9CMRq1Lo2IiIiIyGnYhJEI2fu+R9L4ObCe+BtBAx5C2NghMIYFa10WEREREZHTsQlzAj1dROhs1rMXkTwxHlkffQWf21oi8tOl8G7RyGnjMxu5mI1szEcuZiMb85GL2cilx2zYhDmJHj88VeHIyUPa/LVIm7sGhqAA1Hz3NQT07OzU91FRFN1d5OkumI1szEcuZiMb85GL2cil12zYhFG1UlUV2bu+RtJr8bD9cxkhTz+K0FEDYAjw07o0IiIiIqJqwSbMSXifsGvLP/EXksbPQc6X38H3ntsQveEteDWs47LXU1UVNpsNJpOJ2QjDbGRjPnIxG9mYj1zMRi69ZsMmzAl4n7CyOTKykPL2SlgWbYKpVk1ErZ4Jv/vbV8uOxmzkYjayMR+5mI1szEcuZiOXHrNhE0Yuo6oqMjd9guQp78KRkYWw0U8heERfGHy8tS6NiIiIiEgzbMLIJfKO/omksbOR+91x+D/0H4RPGQFz7UityyIiIiIi0hybMHIqe4oFKTOXIH3Vdpib1EX05jj43XmL1mUREREREYnBJswJ9HQRYWlUux3p721HysylgM2O8GnPI3hQDyhmbT9iJhM/4lIxG9mYj1zMRjbmIxezkUuP2ehvi11Ez41YzuGjSBoXh/zjJxDYrxvCJgyHKSJU67KgKIquc5GM2cjGfORiNrIxH7mYjVx6zYZNmJPocYp628UkJE9ZgMwP9sK7dVPU2r0QPrfcqHVZhVRVhcPhgMFg0F020jEb2ZiPXMxGNuYjF7ORS6/ZsAlzAr1Nq6nmW5G2aCNS314FxdcbEbPHILBfVygGg9alFWO322EQWBcxG+mYj1zMRjbmIxezkUuP2bAJowrJ/uwbJL06B9YzFxA8qAdCxwyCMThQ67KIiIiIiNwGmzAqF+uZC0h6bR6yd++HT/vWiFwxHd5N62tdFhERERGR22ETRmVyZOcibc77SJu/DobwEEQumQL/7v/R1Tm7RERERETOxCbMCTyxIVFVFVnbv0TypHjYLqciZMRjCP3fEzD4+2pdWoXo7fxid8JsZGM+cjEb2ZiPXMxGLj1mwybMSTypEcv//TQuj4tD7v4f4Xd/e8RMex7merW0LqvCFEXR5X0n3AGzkY35yMVsZGM+cjEbufSajf622EU8YYp6uyUDqbErYFm2GebroxG17k3433u71mVV2pWzVrp7Np6G2cjGfORiNrIxH7mYjVx6zYZNmBO4+xT1qsOBjHW7kDx9IdTsPISNH4qQ4b2heHtpXVqVWa1WmM1mrcugEjAb2ZiPXMxGNuYjF7ORS4/ZsAnTudwff0XSuDjk/fgbAnp2RvikZ2CKjtC6LCIiIiIij8UmTKdsl1ORMn0RMtZ+DK8bGyJmezx8292kdVlERERERB6PTZjOqDYbLMu2IDV2OWBQUOONUQh68kEoOrwgkoiIiIhIC/zmrSM5+3/E5XFxsP5xBkFPPoSwcUNgDA/RuiwiIiIiIl1hE+YEiqKIns3Fei4RyZPmI2v7F/Bp0xyRe5fA+6YmWpflcoqiwGw2i85Gr5iNbMxHLmYjG/ORi9nIpdds2IR5MEduHizz1yN1zmoYAv1Rc/6rCOh9v64+5HraVnfDbGRjPnIxG9mYj1zMRi49ZsMmzEkk3SdMVVVkf3IASa/Ng+1cIoKH90bYSwNhCPTXurRqpaoq7HY7jEajmGzoX8xGNuYjF7ORjfnIxWzk0ms2bMKcQNJ9wvJP/Y2k8XOR8/k38L27DaLXxsKr0fVal6UZh8MBo9GodRlUAmYjG/ORi9nIxnzkYjZy6TEbNmEewpGZjdR3ViFt4UaYoiMQtWoG/Lrcqau/KBARERERuQM2YW5OVVVkfrgXyVPehSMtHaGjnkTIiH4w+HprXRoREREREZWATZgbyzt2Aknj4pD7zVH4//cuhE99DubrorQui4iIiIiIysAmzAmq+5Q/e2o6UmYuQfqq7TA3vA7RH8yG3123VmsN7kJv5xe7E2YjG/ORi9nIxnzkYjZy6TEbNmFOUh2NmGq3I331DqS8vgSw2RE+5VkED+4JxcwYS6Ioii53anfAbGRjPnIxG9mYj1zMRi69ZsNv707i6inqc745iqRxccg/dgKBfbsgbMJwmCLDXfZ6nkBV1cJcOEGJLMxGNuYjF7ORjfnIxWzk0ms2bMKcwJVT1NsuJiF56rvI3LQH3q1uQK1dC+Fz640uez1PY7PZYDabtS6DSsBsZGM+cjEb2ZiPXMxGLj1mwyZMKDXfirTFm5D61kooPl6IeOcVBD7eDYrBoHVpRERERERUBWzCBMr+/BskvToX1oRzCB7UA6FjBsMYEqh1WURERERE5ARswgSx/nUByRPjkbXza/i0uwmRS6fA+8aGWpdFREREREROxCbMCap6EaEjOxdp89YgLX4tDKHBqLl4EgIe7qSrixNdxcDTN8ViNrIxH7mYjWzMRy5mI5ces2ET5iSVaZhUVUXWR18heWI8bJdSEPJMH4S+2B+GAD8XVKg/iqLAZOJHXCJmIxvzkYvZyMZ85GI2cuk1G/1tsRD5f5xG0vg5yNn3A/w6t0PMh3Ew16+tdVlERERERORibMKc4Mr7G1yLPT0TqW+ugGXphzBfF42oNW/A/747qqFK/VFVFVarFWazmad2CsNsZGM+cjEb2ZiPXMxGLr1mwyasmqgOBzI27EbKtEVwZGUjbMxghDzTB4q3l9alERERERFRNWITVg1yf/odSePikPf9Lwjo0Qnhk5+FKaam1mUREREREZEG2IS5kD0pFckzFiNjzcfwaloPMVvnwrd9a63LIiIiIiIiDbEJcwHVZkP6iq1IeWMZAKDG6/9D0MDuUHQ48wsRERERERXFrsAJrryIMOfAESSNj0P+b6cR+MR/ET5+KIw1QjWsTt/MZrPWJVApmI1szEcuZiMb85GL2cilx2zE3Rnt1KlTeOqpp9CqVSu0b98esbGxyM/Pv+Z6qqpi8eLFuPvuu9GyZUv06dMHP/30U7HlEhMT8fzzz6N169Zo27YtXn31VWRmZla5bvs/l5E4dBIuPPwCFD9f1NqzGDXfeYUNmIYURSn8H8nCbGRjPnIxG9mYj1zMRi69ZiOqCbNYLBgwYACsVivmzZuHkSNHYuPGjZg1a9Y1112yZAnmzp2LgQMHYtGiRYiIiMCgQYNw9uzZwmWsViuGDBmCM2fO4O2338bkyZOxf/9+vPTSS1Wq27R2N/5u9zhyDvyEiHnjUevjBfBpdUOVxqSqU1UVNpsNqqpqXQpdhdnIxnzkYjayMR+5mI1ces1G1OmI69evR1ZWFuLj4xESEgIAsNvtmDJlCoYPH47IyMgS18vLy8OiRYswaNAgDBw4EABwyy234IEHHsCyZcswefJkAMAnn3yCEydOYOfOnahfvz4AICgoCIMHD8bRo0fRsmXLStVtXvERgob2QujLT8EYFFCpMcg1HA4HjEaj1mVQCZiNbMxHLmYjG/ORi9nIpcdsRP0Stm/fPrRr166wAQOALl26wOFw4MCBA6Wu9+OPPyIzMxNdunQpfMzLywudO3fGvn37iozfpEmTwgYMANq3b4+QkBB89dVXla47Z/F4hE99jg0YERERERFdk6gmLCEhoUiDBPz7S1VERAQSEhLKXA9AsXUbNGiACxcuIDc3t9TxFUVBvXr1yhz/WtS60ZVel4iIiIiI9EXU6Yjp6ekICgoq9nhwcDAsFkuZ63l5ecHb27vI40FBQVBVFRaLBT4+PkhPT0dgYGCFxy+L1WqFqqo4fvx4pdYn11JVVXcXeroLZiMb85GL2cjGfORiNnJ5Ujb5+fnl2hZRTZg78pQPjKdiPnIxG9mYj1zMRjbmIxezkcuTsinvTI+imrCgoCBkZGQUe9xisSA4OLjM9fLz85GXl1fk17D09HQoilK4blBQUInT0VssFkRHV+6UwtatW1dqPSIiIiIi0idR14TVr1+/2LVZGRkZuHz5crFrua5eDwBOnz5d5PGEhATExMTAx8en1PFVVcXp06fLHJ+IiIiIiMhZRDVhHTt2xMGDB5Genl742O7du2EwGNC+fftS17v55psREBCAXbt2FT5mtVqxZ88edOzYscj4v//+O86cOVP42KFDh5CWloa77rrLuRtDRERERERUAkUVdGc0i8WCbt26oV69ehg+fDgSExMxa9YsPPjgg5g4cWLhcgMGDMCFCxewd+/ewscWL16MefPmYfTo0WjcuDHWrVuH/fv3Y9u2bbjuuusA/NuYPfLIIwCAUaNGIScnB7GxsWjSpAkWLVpUvRtLRERERES6JKoJA4BTp05h2rRpOHLkCPz9/dG9e3eMHDkSXl5ehcv0798f58+fx+eff174mKqqWLx4MdauXYuUlBQ0bdoU48aNK3bNVmJiIqZPn479+/fDZDKhc+fOGD9+PAICeI8vIiIiIiJyPXFNGBERERERkScTdU0YERERERGRp2MTRkREREREVI3YhBEREREREVUjNmFERERERETViE0YERERERFRNWITRkREREREVI3YhBEREREREVUjk9YFuKtTp05h+vTpRW4q/eKLLxa5qTS53q5du7B9+3b88ssvSE9Px/XXX4/+/fujZ8+eUBQFwL839/7222+Lrbtz5040aNCgukvWjc2bN2PcuHHFHh86dChGjx5d+O9NmzZh6dKluHDhAurVq4eRI0fiP//5T3WWqjul7RMA8M4776Bbt27cb6rJX3/9hWXLluHnn3/GiRMnUL9+fXz00UfFlivPfpKRkYGZM2fi008/hdVqxZ133okJEyagZs2a1bU5Huda+WRmZmLFihX46quvcObMGXh5eaFly5YYOXIkmjRpUrjcuXPn0KlTp2Lj33TTTdi4cWO1bIunKc++U97jGPcd57tWPqXtEwDg5eWFY8eOlbmcJ+w7bMIqwWKxYMCAAahbty7mzZuHxMREzJo1C7m5uZg4caLW5enKypUrUatWLYwdOxahoaE4ePAgXnvtNVy8eBHPPfdc4XI333wzxowZU2Td2rVrV3e5urR06VIEBgYW/jsyMrLw///444/x2muv4emnn8btt9+OnTt34rnnnsOaNWvQqlUrDarVh0mTJiEzM7PIY6tWrcKePXvQrl27wse437jeiRMn8NVXX+Gmm26Cw+GAqqrFlinvfvLiiy/i5MmTmDx5Mry9vREXF4ehQ4fiww8/hMnE/9xXxrXyuXDhAjZs2ICePXvixRdfRF5eHpYvX44+ffrgww8/LPYHi1GjRuG2224r/Le/v3+1bIcnKs++A5TvOMZ9x/mulU/NmjWxYcOGIo+pqoohQ4bg9ttvLzaeR+47KlXYwoUL1VatWqmpqamFj61fv15t2rSpevHiRe0K06Hk5ORij02YMEG9+eabVbvdrqqqqj7xxBPqsGHDqrs03fvwww/Vxo0bl5hRgfvuu08dNWpUkcf69OmjDhkyxNXl0VXuuecedejQoYX/5n5TPQqOU6qqqmPGjFG7detWbJny7Cc//vij2rhxY/Xrr78ufOzUqVNqkyZN1I8//tgFlevDtfLJyspSs7OzizyWmZmptm3bVp06dWrhY2fPnlUbN26s7tq1y7UF60h59p3yHMe477hGefK52uHDh9XGjRurO3fuLHzMk/cdXhNWCfv27UO7du0QEhJS+FiXLl3gcDhw4MAB7QrTobCwsGKPNW3aFJmZmcjOztagIiqvs2fP4syZM+jSpUuRx7t27YpDhw4hPz9fo8r058cff8S5c+fw4IMPal2K7hgMZf9nuLz7yb59+xAUFIT27dsXLlO/fn00bfr/2rv3oKjKNw7gX8AFXWCXKJIgGG61ytVLLoHI6ioFipFNF5gBmSSHRsVLo+WoMQjOyM/LEDUajHQx1GawzImNKESQRi1dJlLEKRXFQBGTloVolQV+fzjstC7GeuEsLd/PDH/se95992HPPOfMs+c975mImpqahx/4KDHU/hGLxRg3bpxRm6OjI7y9vdHW1jacoY16Q+0bczF3hsf97B+VSgUnJycolcphiGjkYRF2HxobG+Hn52fUJpFI4ObmhsbGRgtFRQNqa2sxfvx4ODk5GdpOnDiBSZMmISQkBMnJyTh58qQFIxxd4uPjMXHiRMyePRuFhYXo7e0FAEOu+Pr6GvX39/dHT08Pfv/9d8FjHa1UKhXEYrHJvHvmjeWZmyeNjY3w9fU13As7wM/Pj+clgWm1WsM9MHfKysrCxIkTERERgQ0bNkCj0Qgf4Cgz1HGMuTMy9PT04Pvvv0dMTAwcHBxMtltj7nCi633QarWQSCQm7VKpFB0dHRaIiAao1WqUlZUZzf+eNm0aEhIS4OPjg7a2Nnz00Ud4/fXXUVxcjMmTJ1swWuvm5uaGjIwMhIWFwcbGBocPH8Z7772Ha9euITMz05Ard+bSwGvmkjD0ej2+/fZbKJVKiMViQzvzZmQwN0+0Wq3RvZcDpFIp6uvrhzlK+qetW7fCxsYGSUlJhjZ7e3skJSUhKioKEokEv/zyCwoKClBfX4/9+/dDJBJZMGLrZc5xjLkzMtTU1ECj0SA+Pt6o3Zpzh0UYWY3W1lasWrUK4eHhWLhwoaF9+fLlRv1mzpyJ+Ph47Ny5E7t27RI6zFFjxowZmDFjhuF1VFQUHBwcsHv3brz55psWjIz+6ejRo2hvbzc58TFviO7dl19+iZKSEuTm5sLd3d3Q/vjjjyMrK8vwWi6X46mnnkJ6ejoqKiowd+5cC0Rr/Xgc++8oLS3FY489ZrQ4FGDducPpiPdBIpGgs7PTpL2jowNSqdQCEZFWq8XixYvh4uKCDz744F/nIovFYigUCpw5c0bACAm4fe9kb28vzp49a8iVO3NJq9UCAHNJICqVCi4uLoiKivrXfswbyzA3TyQSicmKlwDPS0I6cuQIMjMzsWTJEixYsGDI/gqFAmKxmDkloMGOY8wdy/vrr79QVVWFuLg42NnZDdnfWnKHRdh9GGyecGdnJ65fvz7oHHAaXjqdDunp6ejs7DRZDp1GroFcuTOXGhsbIRKJ4OXlZYmwRhWdTodDhw4hNjb2Pz2lw5qZmyd+fn64ePGiyTLQFy9e5HlJAHV1dVixYgVefPFFrFixwtLh0D1g7lheRUUFdDrdqFscikXYfYiOjsaxY8cMv0QCQHl5OWxtbY1W16Hhp9frsXLlSjQ2NqKoqMjoGVR3093djerqaoSEhAgQIf1TWVkZ7OzsEBgYCC8vL/j4+KC8vNykT0REBB98LoDDhw+ju7vbrBMf88YyzM2T6OhodHR04Pjx44Y+Fy9eRENDA6KjowWNebQ5f/480tPT8eyzz2Ljxo1mv6+qqgrd3d3MKQENdhxj7lieSqWCt7c3wsLCzOpvLbnDe8LuQ2JiIoqLi7F06VKkp6fj2rVr2LJlCxITE80qAujh2bhxI6qqqrB27Vp0dXWhrq7OsC0wMBCnTp1CUVERYmJi4Onpiba2NnzyySe4fv068vPzLRf4KJCWlobw8HDIZDIAQGVlJUpKSrBw4UK4ubkBADIyMrB69Wp4e3sjPDwcZWVlOHXqFPbs2WPJ0EeN0tJSeHh4YOrUqUbtarWaeSOQv//+G0eOHAEAtLS0oKury1BwyeVyuLq6mpUnkydPRlRUFNatW4d33nkHDg4OyMvLg0wmw3PPPWeR/80aDLV/+vv7kZaWBgcHB6Smphot5ODk5ISAgAAAQG5uLmxsbDBp0iRIJBKcOnUKhYWFCA4Oxpw5c4T/x6zAUPtm4MfZoY5jzJ3hYc6xDQDa29tx/PhxLF68eNBxrDl3bPrvvP5KZrlw4QJycnLw888/w9HREQkJCVi1ahV/vReYUqlES0vLoNsqKyvR29uL7Oxs/Prrr9BoNBg3bhwmT56MZcuWITQ0VOBoR5dNmzbhhx9+QGtrK/r6+uDj44NXXnkFKSkpRksB79+/H7t27cKVK1fg6+uLt956C7NmzbJg5KNDR0cHpk+fjtTUVKxZs8ZoW1NTE/NGIM3NzSaPBhjw2WefITw8HIB5edLZ2YnNmzejoqICer0eUVFR2LBhA38cfABD7R8ARgtB/ZNcLkdxcTGA2/vv888/R1NTE3Q6HcaPH485c+Zg+fLlRo9TIfMNtW/c3d3NPo4xdx4+c49te/fuRXZ2NsrKyuDv72/S15pzh0UYERERERGRgHhPGBERERERkYBYhBEREREREQmIRRgREREREZGAWIQREREREREJiEUYERERERGRgFiEERERERERCYhFGBERERERkYBYhBEREQns6tWrCAkJQW1t7T2/9/z58wgMDMRvv/02DJEREZEQWIQREZHVOHDgAGQyGWQyGdRqtcn2/v5+KBQKyGQypKenWyDC23bs2IGwsDBMnTr1nt8bEBAAhUKB999/fxgiIyIiIbAIIyIiq+Pg4ACVSmXSfuLECbS2tsLe3t4CUd3W3t6OgwcPIjEx8b7HSExMREVFBS5fvvwQIyMiIqGwCCMiIqujUChQXl4OvV5v1K5SqRAUFAQ3NzcLRQZ8/fXXsLOzw6xZs+57jMjISEilUnz11VcPMTIiIhIKizAiIrI68+bNg0ajwdGjRw1tt27dwnfffYf58+cP+p6+vj58+umnmDdvHkJCQhAZGYnMzEx0dHQY9evv78fOnTsRHR2NsLAwpKSk4Ny5c1AqlVi7du2QsR06dAihoaFwdHQ02bZ3717Mnj0boaGhePnll6FWq5GSkoKUlBSjfiKRCHK5HJWVleZ8HURENMKwCCMiIqvj6emJSZMm4ZtvvjG01dTUoLOzE3Pnzh30PZmZmdi6dSumTJmC9evX46WXXkJpaSnS0tLQ09Nj6Jefn4/8/HxMmDABb7/9Nry8vLBo0SJ0d3cPGVdPTw9Onz6NoKAgk2379u1DdnY23N3dsWbNGjzzzDNYunQpWltbBx0rKCgI586dQ1dX15CfS0REI8sYSwdAREQ0HObPn4/t27dDp9Nh7NixKC0txbRp0zB+/HiTvmq1Gvv378e2bduMrpSFh4fjjTfeQHl5OebPn4/29nYUFRVh5syZKCgogI2NDQAgLy8PBQUFQ8Z09epV6HQ6PPnkk0btt27dQn5+PkJCQrB7926MGXP79CyTybB27Vq4u7ubjOXl5YW+vj40NjYiNDT0nr4bIiKyLF4JIyIiqxQXF4ebN2+iqqoKXV1dqK6uvutUxPLycjg7O2P69Olob283/AUFBUEsFuOnn34CABw7dgw9PT1ITk42FGAAkJqaalZMGo0GACCRSIza6+vrodFo8OqrrxoKMOB2ISmVSgcda2CMP//806zPJiKikYNXwoiIyCq5uroiIiICKpUKOp0Ovb29eP755wft29TUhM7OTkRERAy6/caNGwCAK1euAAB8fHxMPutuxdJg+vv7jV4PjOvt7W3UPmbMGHh6epo1BhER/XewCCMiIqsVHx+Pd999F3/88Qeio6NNrkAN6Ovrw6OPPopt27YNut3V1fWhxOPi4gIA0Gq1DzzWwBiPPPLIA49FRETC4nREIiKyWjExMbC1tUVdXR3i4+Pv2s/b2xsajQZTpkxBZGSkyd+ECRMAAB4eHgCAS5cuGb2/vb3dZBXFwTzxxBMYO3YsmpubjdoHxr3zuV96vR4tLS2DjtXc3AxbW1v4+voO+blERDSysAgjIiKr5ejoiKysLGRkZECpVN61X1xcHHp7e7Fz506TbXq93nDVKTIyEiKRCHv27DGaDrh7926z4hGJRAgODkZ9fb1Re3BwMFxcXFBSUmL0bLPS0tK7FndnzpxBQEAAnJ2dzfpsIiIaOTgdkYiIrNqCBQuG7COXy/Haa6+hsLAQZ8+exfTp0yESiXDp0iWUl5dj/fr1iI2NhaurKxYtWoTCwkKkp6dDoVCgoaEBNTU1Zk8LnD17NvLy8tDV1QUnJycAgL29PTIyMpCTk4PU1FTExcWhpaUFBw4cMLlPDLi91P3JkyeRlJR0b18GERGNCLwSRkREBCA7Oxs5OTm4ceMG8vLysH37dvz444944YUXMGXKFEO/lStXIiMjAw0NDdiyZQsuX76Mjz/+GGKx2KzPSUhIQF9fn8mDlpOTk7FhwwZcvXoV//vf/6BWq/Hhhx/C2dkZDg4ORn2PHz8OjUZjVoFJREQjj00/l1ciIiJ6YEqlEnK5HLm5uUP2XbduHS5duoR9+/b9a7++vj5EREQgJiYGmzZtMrQvWbIENjY22LFjxwPHTUREwuOVMCIiIoEtW7YMp0+fRm1traHt5s2bJsvOHzx4EBqNBnK53NB24cIFVFdXY8WKFYLFS0REDxfvCSMiIhKYh4cHTp8+bdRWV1eHzZs3IzY2Fi4uLmhoaMAXX3yBp59+GrGxsYZ+/v7+aGhoEDpkIiJ6iFiEERERjQCenp5wd3dHcXExOjo6IJVKkZCQgNWrV8Pe3t7S4RER0UPEe8KIiIiIiIgExHvCiIiIiIiIBMQijIiIiIiISEAswoiIiIiIiATEIoyIiIiIiEhALMKIiIiIiIgExCKMiIiIiIhIQCzCiIiIiIiIBMQijIiIiIiISEAswoiIiIiIiAT0f2Cro+Q6xM4vAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", + "\n", + "plt.plot(\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.03921\n", + "GdL = 2\n", + "Chi² rid = 0.01961\n", + "P(0, chi²)= 0.01942\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.011216\n", + "1 0.026289\n", + "2 0.000774\n", + "3 0.000933\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "id": "698e3c48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AdC = 0.00162 ± 0.00002\n", + "BdC = 0.00230 ± 0.00258\n", + "cov_ABdC = -0.000000\n", + "P(0,chi²)= 0.01927\n", + "KdC = 24.35604 ± 0.26416\n", + "KBdC = 17.14417 ± 19.22366\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", + "print(\"Ax + B : \")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 257, + "id": "a0ab8534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "id": "12bb0479", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.03892\n", + "GdL = 2\n", + "Chi² rid = 0.01946\n", + "P(0, chi²)= 0.01927\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.008684\n", + "1 0.027599\n", + "2 0.000978\n", + "3 0.001658\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "id": "385db415", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AdY = 0.0016209 ± 0.0000176\n", + "BdY = 0.0023027 ± 0.0025820\n", + "cov_ABdY = -4.486957037705209e-08\n", + "chi² = 0.03892\n", + "chi² rid = 0.01946\n", + "P(0, chi²)= 0.01927\n", + "KdY = 24.35604 ± 0.26416\n", + "KBdY = 17.14417 ± 19.22366\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", + "\n", + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 260, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 261, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 24.12521 ± 0.03921\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.0016212 ± 0.00000\n", + "Bdols = 0.0022585 ± 0.00035\n", + "P(0,chi²)= 0.0194154\n", + "Kdols = 24.3515777 ± 0.03547\n", + "KBdols = 17.4797252 ± 2.74463\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.0016209 ± 0.00002\n", + "BdC = 0.0023027 ± 0.00258\n", + "P(0,chi²)= 0.0192717\n", + "KdC = 24.3560387 ± 0.26416\n", + "KBdC = 17.14417 ± 19.22366\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.00162 ± 0.00002\n", + "Bdy = 0.00230 ± 0.00258\n", + "P(0,chi²)= 0.01927\n", + "KdY = 24.35604 ± 0.26416\n", + "KBdY = 17.14417 ± 19.22366\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.7f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.7f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.7f}\")\n", + "print(f\"Kdols = {Kdols:.7f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.7f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.7f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.7f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.7f}\")\n", + "print(f\"KdC = {KdC:.7f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "Name: t, dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 264, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): nan\n", + "sigmaC (t): inf\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_87397/2995330097.py:10: RuntimeWarning: invalid value encountered in scalar divide\n", + " media = num / den\n", + "/tmp/ipykernel_87397/2995330097.py:11: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sigma = np.sqrt(1.0 / den)\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 265, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 266, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: nan\n", + "Model: OLS Adj. R-squared: nan\n", + "Method: Least Squares F-statistic: nan\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): nan\n", + "Time: 09:57:18 Log-Likelihood: nan\n", + "No. Observations: 4 AIC: nan\n", + "Df Residuals: 2 BIC: nan\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const nan nan nan nan nan nan\n", + "x nan nan nan nan nan nan\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: nan\n", + "Prob(Omnibus): nan Jarque-Bera (JB): nan\n", + "Skew: nan Prob(JB): nan\n", + "Kurtosis: nan Cond. No. 1.01e+03\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "[2] The condition number is large, 1.01e+03. This might indicate that there are\n", + "strong multicollinearity or other numerical problems.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "R² = nan\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 4 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 267, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 268, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 269, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "cov_ABtC = nan\n", + "P(0,chi²)= nan\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 270, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 271, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.00000\n", + "GdL = 2\n", + "Chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 NaN\n", + "1 NaN\n", + "2 NaN\n", + "3 NaN\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 272, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "cov_ABtY = nan\n", + "chi² = 0.00000\n", + "chi² rid = 0.00000\n", + "P(0, chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_87397/788188722.py:16: RuntimeWarning: invalid value encountered in scalar divide\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + "/tmp/ipykernel_87397/788188722.py:17: RuntimeWarning: invalid value encountered in scalar divide\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "/tmp/ipykernel_87397/788188722.py:27: RuntimeWarning: invalid value encountered in scalar divide\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "/tmp/ipykernel_87397/788188722.py:39: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sA = np.sqrt(1 / S)\n", + "/tmp/ipykernel_87397/788188722.py:40: RuntimeWarning: divide by zero encountered in scalar divide\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 273, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 274, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± inf\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "Kdtols = nan ± nan\n", + "KBdtols = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtC = nan ± nan\n", + "KBdtC = nan ± nan\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = nan ± inf\n", + "BtY = nan ± nan\n", + "P(0,chi²)= 0.00000\n", + "KdtY = nan ± nan\n", + "KBdtY = nan ± nan\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 275, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000500\n", + "res_t2 = nan\n", + "res_uAdt = nan\n", + "uKdt_strum = nan\n" + ] + } + ], + "source": [ + "res_t = 0.01 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 276, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 277, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = nan ± nan\n", + "\n", + "RISULTATI OLS:\n", + "Atols = nan ± nan\n", + "Btols = nan ± nan\n", + "Kdtols = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = nan ± nan\n", + "BtC = nan ± nan\n", + "KdtC = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n", + "\n", + "RISULTATI York:\n", + "AtY = nan ± nan\n", + "BtY = nan ± nan\n", + "KdtY = nan ± nan\n", + "Chi² = 0.00000 | rid = 0.00000 | P = 0.00000\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/dinamica/mollaDinamica2.ipynb b/molla/dinamica/mollaDinamica2.ipynb index 928325d..531ddb4 100644 --- a/molla/dinamica/mollaDinamica2.ipynb +++ b/molla/dinamica/mollaDinamica2.ipynb @@ -23,7 +23,7 @@ }, { "cell_type": "code", - "execution_count": 603, + "execution_count": 2, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -60,7 +60,7 @@ }, { "cell_type": "code", - "execution_count": 604, + "execution_count": 3, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -99,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 605, + "execution_count": 4, "id": "5494409f", "metadata": {}, "outputs": [ @@ -417,7 +417,7 @@ "4 10.637000 1.188344 24.5150 0.386480 " ] }, - "execution_count": 605, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -447,7 +447,7 @@ }, { "cell_type": "code", - "execution_count": 606, + "execution_count": 5, "id": "976d5531", "metadata": {}, "outputs": [ @@ -503,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 607, + "execution_count": 6, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -532,7 +532,7 @@ }, { "cell_type": "code", - "execution_count": 608, + "execution_count": 7, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -581,7 +581,7 @@ }, { "cell_type": "code", - "execution_count": 609, + "execution_count": 8, "id": "5be377eb", "metadata": {}, "outputs": [], @@ -608,7 +608,7 @@ }, { "cell_type": "code", - "execution_count": 610, + "execution_count": 9, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -621,8 +621,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 3.114e+05\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.19e-19\n", - "Time: 21:52:51 Log-Likelihood: -14.036\n", + "Date: Mon, 06 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 10:29:56 Log-Likelihood: -14.036\n", "No. Observations: 10 AIC: 32.07\n", "Df Residuals: 8 BIC: 32.68\n", "Df Model: 1 \n", @@ -670,7 +670,7 @@ }, { "cell_type": "code", - "execution_count": 611, + "execution_count": 10, "id": "8d795186", "metadata": {}, "outputs": [ @@ -736,7 +736,7 @@ }, { "cell_type": "code", - "execution_count": 612, + "execution_count": 11, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -798,7 +798,7 @@ }, { "cell_type": "code", - "execution_count": 613, + "execution_count": 12, "id": "6a910226", "metadata": {}, "outputs": [ @@ -874,7 +874,7 @@ }, { "cell_type": "code", - "execution_count": 614, + "execution_count": 13, "id": "b49ec5a3", "metadata": {}, "outputs": [ @@ -943,7 +943,7 @@ }, { "cell_type": "code", - "execution_count": 615, + "execution_count": 14, "id": "538ddb98", "metadata": {}, "outputs": [ @@ -1006,7 +1006,7 @@ }, { "cell_type": "code", - "execution_count": 616, + "execution_count": 15, "id": "c7f54cf3", "metadata": {}, "outputs": [ @@ -1089,7 +1089,7 @@ }, { "cell_type": "code", - "execution_count": 617, + "execution_count": 16, "id": "fc824066", "metadata": {}, "outputs": [ @@ -1163,7 +1163,7 @@ }, { "cell_type": "code", - "execution_count": 618, + "execution_count": 17, "id": "1203e1a0", "metadata": {}, "outputs": [ @@ -1221,7 +1221,7 @@ }, { "cell_type": "code", - "execution_count": 619, + "execution_count": 18, "id": "aaa95426", "metadata": {}, "outputs": [ @@ -1270,7 +1270,7 @@ }, { "cell_type": "code", - "execution_count": 620, + "execution_count": 19, "id": "a9f2a9fc", "metadata": {}, "outputs": [], @@ -1322,7 +1322,7 @@ }, { "cell_type": "code", - "execution_count": 621, + "execution_count": 20, "id": "c95874fb", "metadata": {}, "outputs": [ @@ -1389,7 +1389,7 @@ }, { "cell_type": "code", - "execution_count": 622, + "execution_count": 21, "id": "95dde99f", "metadata": {}, "outputs": [ @@ -1413,7 +1413,7 @@ } ], "source": [ - "Meq = df.m + ( m_mol / 3 )\n", + "Meq = df.m # + ( m_mol / 3 )\n", "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", "\n", "T2 = ( 2 * np.pi / df.w )**2\n", @@ -1435,7 +1435,7 @@ }, { "cell_type": "code", - "execution_count": 623, + "execution_count": 22, "id": "8c9f5b44", "metadata": {}, "outputs": [ @@ -1443,17 +1443,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 3.189874\n", - "1 3.202365\n", - "2 3.215332\n", - "3 3.229734\n", - "4 3.245789\n", + "0 2.888246\n", + "1 2.981052\n", + "2 3.039612\n", + "3 3.083702\n", + "4 3.121004\n", "dtype: float64\n", - "0 0.001449\n", - "1 0.000541\n", - "2 0.000772\n", - "3 0.000963\n", - "4 0.001334\n", + "0 0.001317\n", + "1 0.000508\n", + "2 0.000732\n", + "3 0.000920\n", + "4 0.001283\n", "dtype: float64\n" ] } @@ -1474,7 +1474,7 @@ }, { "cell_type": "code", - "execution_count": 624, + "execution_count": 23, "id": "0d899f17", "metadata": {}, "outputs": [ @@ -1482,8 +1482,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "K-medio: 3.212034524173708\n", - "sigmaC: 0.0003724442799985059\n" + "K-medio: 3.0134007705961383\n", + "sigmaC: 0.0003513307107337363\n" ] } ], @@ -1523,7 +1523,7 @@ }, { "cell_type": "code", - "execution_count": 625, + "execution_count": 24, "id": "4b4c2682", "metadata": {}, "outputs": [], @@ -1550,7 +1550,7 @@ }, { "cell_type": "code", - "execution_count": 626, + "execution_count": 25, "id": "90d191d5", "metadata": {}, "outputs": [ @@ -1563,8 +1563,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 7.624e+04\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.05e-07\n", - "Time: 21:52:52 Log-Likelihood: 23.705\n", + "Date: Mon, 06 Apr 2026 Prob (F-statistic): 1.05e-07\n", + "Time: 10:29:59 Log-Likelihood: 23.705\n", "No. Observations: 5 AIC: -43.41\n", "Df Residuals: 3 BIC: -44.19\n", "Df Model: 1 \n", @@ -1572,13 +1572,13 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.0219 0.004 5.124 0.014 0.008 0.035\n", + "const 0.0837 0.004 20.623 0.000 0.071 0.097\n", "x 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 1.430\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.670\n", "Skew: -0.251 Prob(JB): 0.716\n", - "Kurtosis: 1.279 Cond. No. 344.\n", + "Kurtosis: 1.279 Cond. No. 310.\n", "==============================================================================\n", "\n", "Notes:\n", @@ -1586,10 +1586,10 @@ "\n", "RISULTATI REGRESSIONE:\n", "Adols = 0.01202 ± 0.00004\n", - "Bdols = 0.02190 ± 0.00427\n", + "Bdols = 0.08371 ± 0.00406\n", "R² = 0.99996\n", "Kdols = 3.28476 ± 0.01190\n", - "KBdols = 1.80288 ± 0.35183\n" + "KBdols = 0.47159 ± 0.02287\n" ] }, { @@ -1632,13 +1632,13 @@ }, { "cell_type": "code", - "execution_count": 627, + "execution_count": 26, "id": "a0ba5c8d", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2MAAAIsCAYAAAB/SHEEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoDFJREFUeJzs3Xd0FPX6BvBntqSThA0QujSJoFSlc9GLWAAVUZqihgsqIjaw0aSDCEqv0os0FVFQEGygIHaRolwERIoC6T3ZMr8//G1uQpLdlJ2deZPnc84957qz891355kZ9s00RVVVFURERERERORXJr0LICIiIiIiqojYjBEREREREemAzRgREREREZEO2IwRERERERHpgM0YERERERGRDtiMERERERER6YDNGBERERERkQ7YjBEREREREemAzRgREREREZEO2IwRERFp7OGHH8bDDz+c+9/nz59HTEwMtm3bpmNVRESkNzZjRETkN9u2bUNMTAyOHDmidykinD9/HlOnTsUdd9yBFi1aoHv37ti0aVO+9/z3v//F6NGj0a1bN7Rs2RK9evXCnj17dKqYiIhKwqJ3AURERBVNrVq18Msvv8Bi8fzP8MKFC/Hzzz+jV69eiIqKwscff4yJEyciMDAQ9913HwBgypQpyMjIwIABAxASEoJ3330XzzzzDNasWYP27dv74+sQEVEpsRkjIiLyM0VREBgY6PV9AwcOxLRp02A2mwEA999/P7p164YdO3bkNmMvvPACWrRokTvPPffcgw4dOmDnzp1sxoiIDI6nKRIRkeFcunQJo0ePRseOHXHDDTegZ8+eeOeddwq878KFC3jiiSfQsmVLdOjQAdOnT8eXX36JmJgYfPPNN/ne+9Zbb+HWW29F8+bN0adPH3z//fcFruUCgJycHMyfPx+33XYbbrjhBtx8882YOXMmcnJyilX7li1b0K1bt3yfc7XiXjPWrFmz3EYMACwWCywWC+x2e+5reRsxAAgICIDJZMr3HiIiMiYeGSMiIkOJi4tDv379oCgKBg4cCJvNhv3792Ps2LFIS0vDoEGDAAAZGRmIjY3FlStX8Mgjj6BKlSrYuXNngSYMADZu3IjJkyfjpptuwqBBg3DhwgUMHz4c4eHhqF69eu77XC4Xhg0bhh9++AH9+vVDw4YN8d///hdr167FH3/8gcWLF3us/e2338b48ePRqlUrxMbG4ty5cxg2bBgiIiJQo0aNMi+b9evX49y5cxg+fHiR75k9ezays7Nzj5wREZFxsRkjIiJDmTNnDpxOJ3bs2IHKlSsDAB544AGMHDkSCxcuxIABAxAUFIQtW7bg3LlzWLRoEbp16wYAGDBgAO6999584+Xk5GDevHlo1qwZ1q5dm3udVkxMDEaNGpWvGduxYwcOHjyI9evX46abbsp9/dprr8WECRPw448/onXr1oXWbbfbMWfOHDRp0gTr1q1DQEAAAKBRo0Z45ZVXytyMffDBB5g2bRoGDBiA3r17F/qeZcuWYfXq1Xj++efRrl27Mn0eERFpj6cpEhGRYaiqij179qBr165QVRUJCQm5/+vcuTNSU1Nx7NgxAMCXX36J6Oho3HrrrbnzBwYGol+/fvnGPHr0KJKSktCvX798N8y4++67ERERke+9u3fvRsOGDdGgQYN8n+2+9qqwo255Pyc+Ph4DBgzIbcQAoHfv3qhUqVLpFwqAU6dOYcyYMbj11lsxYcKEQt9z8OBBzJ49Gw8//DAef/zxMn0eERH5B4+MERGRYSQkJCAlJQVbtmzBli1binwP8M/1YnXr1oWiKPmm161bN99/X7x4sdDXLRYLatWqle+1s2fP4tSpU+jQoUOhnx0fH19k7e7Pueaaa/K9brVaUadOnSLnK46PPvoIdrsdEyZMgMlU+N9RP/jgA4SGhuKll14q02cREZH/sBkjIiLDcLlcAP65I2BRp+LFxMRo+vmNGzfG6NGjC52e95RGf0pKSgIAVKtWzeN7IiMj8x2VIyIiY2MzRkREhmGz2RAaGgqXy4WOHTt6fG+tWrXw+++/Q1XVfEfH/vzzz3zvq1mzZu7reW/17nA4cOHChXzNXd26dfHbb7+hQ4cOBY64eeP+nLNnz+Y7sma323H+/Hlcd911JRovr5tuugmqqnp8z80334ymTZuW+jOIiMj/eM0YEREZhtlsxh133IGPP/4Y//3vfwtMd5+iCACdO3fGpUuX8Omnn+a+lp2dja1bt+ab54YbbkBkZCS2bt0Kh8OR+/qOHTuQnJyc773du3fHpUuXCowBAFlZWcjIyCiy9htuuAE2mw2bN2/Odxv89957DykpKR6+tXc33ngjBg4c6PE9N998c4GblxARkbHxyBgREfndu+++iy+//LLA64888gief/55fPPNN+jXrx/69u2LRo0aITk5GceOHcPXX3+Nb7/9FgDQv39/bNiwAc8//zweeeQRVK1aFTt27Mh9mLL7yFZAQACefvppTJkyBbGxsejevTsuXLiAbdu2FbiOrFevXti1axcmTJiAb775Bq1bt4bT6cTp06exe/durFixAs2aNSv0O1mtVjz33HMYP348YmNj0aNHD5w/fx7btm0r8zVjs2fPxnvvvYcTJ04U+Z6XX34ZFy5cwGeffVamzyIiIv9hM0ZERH63adOmQl+/7777UL16dbz99ttYtGgR9u7di02bNiEyMhKNGjXCCy+8kPve0NBQrF27FlOnTsW6desQEhKCe++9F61atcLTTz+d25QBwEMPPQRVVbF69Wq89tpruO6667BkyRJMnTo13/tMJhMWLVqENWvW4P3338fevXsRHByM2rVr4+GHH0b9+vU9fq/+/fvD6XRi5cqVmDlzJho3bowlS5Zg3rx5ZVxiRERUHimqt5PQiYiIBFmzZg1effVV7N+/H9HR0UW+z+VyoUOHDrjtttswdepUP1ZIRET0D14zRkREYmVlZeX77+zsbGzZsgX16tXL14hlZ2cXuAHG9u3bkZSUhLZt2/qlViIioqvxNEUiIhLrqaeeQs2aNXHdddchLS0NH3zwAU6fPo3XX3893/t+/vlnvPrqq7jzzjsRGRmJ48eP45133kHjxo1x55136lQ9ERFVdGzGiIhIrM6dO+Odd97Bjh074HQ60ahRI8yZMwc9evTI975atWqhevXqWL9+PZKTkxEREYFevXrhhRde4HO5iIhIN7xmjIiIiIiISAe8ZoyIiIiIiEgHbMaIiIiIiIh0wGvGivDTTz9BVVVYrVa9SyEiIiIiIh3Z7XYoioJWrVr5dFw2Y0VQVbXAbZCJiIiIiKji0aovYDNWBKvVClVVccMNN0BRFL3LoWJSVRV2ux1Wq5W5CcPsZGJuMjE3uZidTMxNpry5HT16VJPP4DVjREREREREOmAzRkREREREpAM2Y0RERERERDpgM0ZERERERKQDNmMe8AJLmfg4ArmYnUzMTSbmJhezk4m5yaR1brybohfFacicTifsdrsfqiEqnNVqhdls1ruMMuEfP2RibjIxN7mYnUzMTSZ/5MZmzAtVVYsMQlVV/P3330hKSvJvUeSRp8zKs8jISFSvXl3sd1dVFU6nE2azWex3qIiYm0zMTS5mJxNzkylvblphM+aBt4e7uRuxatWqISQkhBuXAbgf1q0oSoXJQ1VVZGRk4PLlywCAGjVq6FxR6blcLvFH+Coi5iYTc5OL2cnE3GTSOjc2Y6XkdDpzG7GoqCi9y6H/VxGbMQAIDg4GAFy+fBnVqlXjzp6IiIhIAN7Ao5Tc14iFhIToXAnRP9zrIq9fJCIiIpKBzVgZVaSjL2RsXBeJiIiIZGEz5gF/3MrE3OTi6ZUyMTeZmJtczE4m5iaT1rmxGfOiIvywX7BgAWJiYgr876677gIAxMTEYOXKlbnv37ZtG3bs2FGssbt27YrJkyfn/veoUaNyx9WC+1oxPXLbv38/Bg0ahJtuugktWrTAvffei3Xr1sHhcOR737Zt2xATE4OEhIQix0pMTMT06dNx++23o1mzZujQoQMeeOABrFmzRuNvoR9FUXiXKYGYm0zMTS5mJxNzk8kfufEGHl5UlNukBwUFYe3atQVeA4AtW7agZs2aua+/9957CAkJwd13313iz3nyySeRkZFRtmI9yHsHTH/mtmrVKrz22mu47bbbMHPmTAQHB2P//v2YOXMmDh06hIULF8JkKt7fPhwOB2JjY5GamorHH38cDRo0QFxcHH788Ud8/vnnGDRokLZfRicV9eYr0jE3mZibXMxOJuYmU97ctMJmzANvt7YvT0wmE1q2bFnotKJeL426dev6bKyilHSjycnJgcViKXazdLXjx4/j9ddfR+/evTFjxozc1zt06IBGjRphzJgxeOutt/Dwww8Xa7xvv/0WJ06cwIYNG9CmTZvc13v27AmXy1WqGqVwOByaP+mefI+5ycTc5GJ2MjE3mbTOjacpkld5T1N8+OGH8e233+KLL77IPZ1xwYIFxR7r6tMU3afsHT9+HI8++ihatmyJ22+/Hdu3by8w7xdffIG+ffuiefPmaN++PSZMmJDvKFtGRgYmT56M7t27o2XLlujatSvGjx+P1NTUfOO4T51cvnw5/v3vf6N58+a5D+7etm0b7r77bjRr1gz/+te/MGfOHDidTo/faf369VAUBU8//XSBab1790a9evUKHHX0JDk5GQBQtWrVAtNK2zASERERkfHwlx3lcjgc+f5X2JHBCRMmoGnTpmjdujW2bNmCLVu2oG/fvmX+7BdeeAGdO3fGokWL0KRJE4waNQqnTp3Knb57924MGzYMjRs3xsKFC/Hiiy9i7969GDt2bO57srKy4HK58Nxzz+HNN9/Es88+i++++w5PPvlkgc/bs2cPvvjiC4wdOxaLFy9GSEgIVq9ejXHjxqFz585YunQpHnvsMaxbtw5z5szxWPt3332HmJgY1KpVq8A0k8mEf//73zh37hwuXbpUrGXRpEkTmEwmjBs3Dl9//TVycnKKNR8RERERycLTFAnAP0eVrr/++nyvzZw5E7169cr3WqNGjRAWFoaQkBCfnr44cOBADBw4EADQqlUr7Nu3Dx9//DGefPJJqKqKmTNnokePHpg2bVruPFWrVsXjjz+OJ598Etdeey1sNhsmTpyYe5qi0+lE7dq18eCDD+LMmTOoX79+7rx2ux3Lly/PfTZXWloa5s+fj0cffRQjR44EAHTq1AlWqxUzZszAkCFDULly5UJrv3TpEmJiYor8bjVq1AAA/P3334iOjva6LOrVq4dRo0Zh1qxZGDRoEKxWK5o3b47u3bvjgQcegMXCzZaIiIjKr4SEBBw6dAjt27eHzWbTuxxN8VedB6W9WM/+x0W4klO9v9HHTBGVYK1X0/sbCxEUFIQNGzbke61OnTq+KKtYOnfunPv/Q0JCULNmTfz9998AgDNnzuDChQsYM2ZMvjsTtm3bFiaTCUePHsW1114LAHj//fexZs0anD17Nt8pjH/88Ue+Zqxdu3b5Htj9008/ISMjA3feeWe+z+jYsSOysrJw8uRJtG3b1vdfvAixsbHo0aMHPvvsM3z77bf4+uuvMXXqVOzZswdr164tt6cr8qJmmZibTMxNLmYnE3MrvuTkZBw/fhxNmjTRvRnTOjc2Y16UNABnfBL+bPcAoMeNFsxm1Du2HeaoyBLPajKZ0KxZM9/XVEyVKlXK999WqzX39LzExEQAwPDhwwud96+//gIA7N27Fy+//DL69++PESNGIDIyEleuXMHw4cORnZ2db56oqKh8/+3+jN69e3v8jMJER0d7nO6eVr169SLfU5iqVauif//+6N+/P+x2O8aPH49t27bh888/x6233lqisSRQFIUXNgvE3GRibnIxO5mYm3eZmZnIzMyEmpmN1AWbUfvSeVzqEo+IiAgAQHBwMIKDg/1akz9yYzPmY+aoSNT9ZpNuR8ZK04gZXWRkJABg/PjxaN68eYHp1apVA/DPdWVNmjTJ91yzb7/9ttAxr26y3Rv6woULC22aateuXWR9bdq0wY4dO/DXX3/lnpLopqoq9u3bhzp16hTrFMWiWK1WDBo0CNu2bcOpU6fKZTNGREREFdfxY8fw18adqL/jEIJSM2HvEoNde77A8aNHYDabcMMNN+DGG2/Uu0yfYzPmRWmeLVDaUwWlsFqtBY40aalBgwaoXr06zp07l3tdWWGysrJgtVrhcrlyn+NR3IdTt2rVCsHBwfj7779x2223lai+hx9+GO+//z7mz5+PV199Nd+0999/H6dPn8Yrr7xS7PGSkpIQFhZW4NqwP/74A0Dhd1ksD1RVhcPhgMVi4akcgjA3mZibXMxOJubmWc5vZxA6ejGa/HwSl6+rjU+7t4HdZkFmtgPZdidCzPpcnpE3N60Yqhk7e/YsVq5cicOHD+PkyZNo0KABdu7cWax5L126hNmzZ2Pfvn3IyMhArVq1MGzYMNxzzz2lrqciPWesJBo0aIDt27fjs88+Q9WqVVGtWrUyHfXxRlEUjBo1Ci+88AIyMjJwyy23IDg4GBcvXsS+ffswYsQI1K9fHx07dsTkyZOxePFitGrVCvv378fXX39drM8IDw/HM888g1mzZuHvv/9G27ZtYTabce7cOXz66adYsGBBkYfGmzZtihdeeAGvvfYa0tLScN999yEoKAhfffUV1q5di1tvvRUPPvhggfk+//xzhIaG5nvt2muvxcmTJ3OfW9a8eXNYLBb8+uuvWLZsGWrWrFniZlESbnMyMTeZmJtczE4m5laQMzkViTNXI3nlNgTVrY7gN8fD2qYZst7+Ckj6DQG2RujZszPCQgL8foqim9a5GaoZO3nyJPbt24cWLVrA5XIV+8tfvnwZ/fv3R/369TFlyhSEhYXh5MmTvCW4Rh577DH8+eefePnll5GSkoKnnnqq0Gds+VL37t0RHh6OpUuX5h7tqlWrFv71r3+hSpUqAIABAwbg3LlzeOutt7Bq1Sp07twZb7zxBvr161eszxg8eDCio6OxevVqbNiwARaLBXXr1sUtt9zi9XzhwYMHo2HDhli9ejVeeOEF2O121K9fHy+99BIefPDBQm+4MWbMmAKvPfvss+jduzfuuOMOfPrpp1i7di2ys7NRvXp13H333Xj88ccRFhZWrO9DREREZESqy4XUjR8hftoyqJnZsI19DJFD+0EJ+Of31oA7mmHnjtO4645mqFu7ZNfcS6OoBmrTXS5X7o/WUaNG4ejRo8U6Mvbiiy/m/gg3m80+qeXIkSNQVRXNmjUr9HByVlZW7u3Sg4KCfPKZVHaqquaeWlrRTgOQvk6qqgq73Q6r1VrhspOMucnE3ORidjIxt//J+uEY4kbPQ/ZPvyKs7+2IGj8MlupV8r3nzJkzePfdd3H//ffnuxu2v+XN7ejRowDg8xveGerIWGlu152WloZdu3Zh+vTpPmvEiIiIiIjIdxyXE5AwZSlSN+9CwA3XoubORQhuV/DGbMA/N1Zr2rRp7g3WyjNDNWOlcezYMdjtdlgsFjz00EP46aefEBkZiXvvvRfPPfdcmW5HWdH/ciEVc5OLt/2VibnJxNzkYnYyVdTcVLsDySvfReLM1YDFjCqvv4Dwh+6C4uEgis1mQ48ePfxYZdF4a3sv4uLiAADjxo1Dv3798NRTT+GXX37B/PnzYTKZ8Pzzz5f5M64+k1NRlNzX3KfF5Z1W2DyFzVvYtLLMy3ELZuPLcX1Rk5bjFva9jVZvcef1tM35uiZp4xqxJq22OWnLwYg1FWfcwt7DZShj3Iq+zUkb1z2vkbY5rcfN2Pc94sfOg/33cwiPvQe20Y/BXDm81MvBFzX5clxfEN+Muf7/4codO3bEqFGjAADt27dHeno6Vq1aheHDh5f6+hlVVZGTk5PvSIvJZMq9vaV7RSqsGXNPz6s40zytnKUZ9+qxy/u4Rf0D5W1sX9Rblnl9Ma573XE4HLnTHA5HgXndt9V1uVxwOp35puVdv+12e4Ga3Oe6O53O3G3v6nGvriHvuKqqFjmue3u7+vuZzWaYzeZCx1WU/z2MsbDv6p5W2Hcty7hlWYYBAQEA4HEZehrX0zIsalxfLMOixjWZTHA4HLmPlCjuuKVdhlpm42n99rQMizMu4PtsPH1X97iF1aQoCiwWS6HzeRtXz30EoN36LWkf4Z5PVfM/ekfvZejP9VviPsJsNsPlcsHhcOTLzT0uYKx9RFmXof3PvxA3fiEyP/oSge2aIXr3UgRc3xAmD9/ViPsI977S/Rvr6ux8QXwzFh4eDuCfBiyvDh06YOnSpTh79ixiYmJKPb6nCy0VRcn9X1HTi1KaecoybnHGLi/jFrWxXP1D0Z81+WNc97qY91kYnp6LYTKZPF6nWdhhefdn5d2JF/aeog7pe5qW93OLys/TvKX9rlqNC3g+tcHTMixLvaXNBvD8XT2N63K5PO4rtVqGRlu/ixrXTatsSrsMnU6nx2ceGXEfoccyNOI+QlXVUu8r9dhH6LUMjbaPcDqdHveV5WEZujKzkTB7HZIWvAVT5QhUWzoeob1vzfdbBZCzj1BV1eu+sqzEN2ONGjXyOL2sDycuqtny9sNe6g966eMWdZRSz5r8Pa6Rm05P091NdHG2OV/WJG1co9XkLbey1CRpORi1Jm/7Si1y02veijIutzmZ4xp1m/PVuKqqIn3nPsRPWATHpXhEDuuPys89DFNYiG41+WvcstLncdY+VKtWLTRu3BgHDx7M9/rBgwcRFBTktVkrLXdnnZGRocn4RCXlXhcr6gXCRERE5H85J87grz4jcGnwKwho0gB1v1yHqHFDi2zEKD9DHRnLzMzEvn37AAAXLlxAWloadu/eDQBo27YtbDYbYmNjcfHiRezduzd3vhEjRuDJJ5/EtGnTcMstt+DIkSNYtWoVhgwZgpAQbVYEs9mMyMhIXL58GQAQEhKiaddMxZP3nN6KkoeqqsjIyMDly5cRGRnJRzwQERGR5pwpaUicuQrJK7bBWrcGqm+cidDbOuhdljiGasbi4+Px7LPP5nvN/d/r1q1Du3btCr1YsGvXrpg9ezYWL16MTZs2oVq1anj66afx+OOPl6kebz/mq1f/54ng7oaMjEGrCyyNLjIyMnedlIqNpEzMTSbmJhezk6m85Ka6XEjdvAsJU5fBlZ4F25jHEDm0L5TAAL1L04TWuSmqlvdqFOzIkSMAiveUbafTWeidXYj8xWq1lpudPBERERlT1o/HETd6LrJ//BVh99+GqAnDYKlRVe+y/KIkvUFJGOrImBEV5yiLpzu3kH9VxNMUywtmJxNzk4m5ycXsZJKem+NyAhKmvYnUjR8i4IZrUXPHIgS3b653WZrT8pb2bmzGPOBBQ5kcDgdvYiEUs5OJucnE3ORidjJJzE21O5C8chsSZ64CLGZUmTkS4Y/cA6UCHYTQOjc2Y0RERERElE/G/u8RN2Ye7Cf/RHjsPbCNehRmW4TeZZU7bMaIiIiIiAgAYD/3N+LHL0T6zn0Iatcc0Z+sQGCza/Uuq9xiM0ZEREREVMG5MrORtHAjkuZvgCkyHNWWjkfYfd1EXuMmCZsxD7jyycTc5GJ2MjE3mZibXMxOJqPmpqoq0j/6EvHjF8Lx1xVEDuuPyiMe4UOb/5/WubEZ88KoGw4VTlEUcRfH0j+YnUzMTSbmJhezk8moueX89w/EjZmHzH3fI6Rbe9TY+gYCGtbRuyzD8EdubMaIiIiIiCoQZ0oaEl9fg+Tl78Bapwaqv/UaQm/vqHdZFRKbMS+0frYA+ZaqqnA4HLBYLMxNGGYnE3OTibnJxexkMkpuqsuF1C27kTBlGVzpmbCNehSRT/SDEhigW01Gljc3rbAZ84DPGZOJucnF7GRibjIxN7mYnUx655b106+IGz0X2T8cR9h93RA1YRgsNavpWpMEWufGZoyIiIiIqJxyXElEwrRlSN34EQKaNkTNDxYiuEMLvcui/8dmjIiIiIionFHtDiSveg+JM1cBJgVVZoxA+CN3Q9HwlDsqOaZBRERERFSOZHz5A+LGzIP9xB8Ij70HttGPwWyL0LssKgSbMQ94YaxMWl5kSdpidjIxN5mYm1zMTiZ/5GY/fwnx4xcifccXCGrbDNGfrEBg88aaf255pnVu3Jq9YEMmi6IozEwoZicTc5OJucnF7GTSOjdXZjaSFm1E0vy3YAoPQ7UlryDs/tu4rpSRP7Y3NmNe8Nb2sqiqCpfLBZPJxNyEYXYyMTeZmJtczE4mrXJTVRUZu75E3CsL4fjrCiKf6I/KIx+BKSzEZ59RkeXNTStsxjzQ+xakVDpOp1PTjYa0w+xkYm4yMTe5mJ1Mvs4t5+RZxI2Zh8wvvkPIre1RY+vrCGhY12fj0z+03t7YjBERERERCeFKTUfC62uQ/ObbsNSujupvzUDIbR15pFQoNmNERERERAanulxI3foxEiYvhSs9A7aXBiNiWH+YggL1Lo3KgM0YEREREZGBZf38G+JGz0X298cQ1vtWRE18Epaa1fQui3yAzZgHPNwrE8+jl4vZycTcZGJucjE7mUqTmzMuEfHT3kTqWx8ioEl91Nw+H8GdWmlQHRVF6+2NzZgXbMhkURSFz18RitnJxNxkYm5yMTuZSpqb6nAgedV2JL62EjApqPLqcwiPvQcKs/crf2xvTNQL3tpelrx3wGRusjA7mZibTMxNLmYnU0lyy/zqR8SNmYec384g/JF7YBv9KMxRkRpXSIXxx53V2Yx5wFvby2S322G1WvUug0qB2cnE3GRibnIxO5m85WY/fwnxExYh/YPPEdTmBtTeuxyBLWL8WCEVRuvtjc0YEREREZFOXFnZSF60GYnz1sMUHoZqi8chrM/tPPJZQbAZIyIiIiLyM1VVkbH7K8S9sgCOi1cQObQvKj8/CKawEL1LIz9iM0ZERERE5Ec5J88ibux8ZH7+LYK7tkONza8joFFdvcsiHbAZIyIiIiLyA1dqOhJnr0XysrdhqR2N6utfRcgdnXhKYgXGZswDRVG4cQijKAoCAgL0LoNKgdnJxNxkYm5yMTuhVBXZ732G+MlL4ErLgO3FwYh4sj9MQYF6V0Ye+GN7YzNGRERERKSR7MMncGX0XGR/dxRh93ZF1MQnYakVrXdZZBBsxrzgc8ZkUVUVTqcTZrOZuQnD7GRibjIxN7mYnRzOuETET1+O1A07EXBdfUS/Oweh/7qRuQmSd3vTCpsxD/icMZlcLpemGw1ph9nJxNxkYm5yMTtjUx0OpKzejoTXVgIAqkx/FpVi74GDvytF0np7YzNGREREROQDmQd+QtyYucj59QzCH74bttGPwlyl8j9/4Lfb9S6PDIjNGBERERFRGTguXELchMVIf/8zBLa5AbX3Lkdgixi9yyIB2IwREREREZWCKysbyYu3IHHeepjCQlBt0ViE9bkdismkd2kkBJsxD3iBpUwWC1drqZidTMxNJuYmF7PTn6qqyPj4AOJeWQDH+UuIGNoXtucHwVQptMh5mJtMWufGtcILNmSy8NlwcjE7mZibTMxNLmanv5zf/0Tc2PnI/OwbBP+7LWpsnImAa6/xOA9zk8kfubEZ84K3tpdFVVW4XC6YTCbmJgyzk4m5ycTc5GJ2+nGlZSDxjTVIWvY2LDWrovq66Qi5s3OxcmBuMuXNTStsxjzgre1lcjqdmm40pB1mJxNzk4m5ycXs/EtVVaS9/THiJy2BKzUdtucHIWL4AJiCAks0DnOTSevc2IwRERERERUi+/AJxI2ei6zvjiK0V1dETXwS1trRepdF5QibMSIiIiKiPJzxSUiYvhwp63cg4Lr6qPnePAR3bq13WVQOGepY6dmzZzF+/Hj06tULTZs2xV133VXiMdasWYOYmBgMHTpUgwqJiIiIqLxSHQ4kr9yGP9s/iLT3P0OVac+g9mcr2YiRZgx1ZOzkyZPYt28fWrRoAZfLVeJrtq5cuYJFixYhKirKJ/XwAkuZeD62XMxOJuYmE3OTi9lpI/PAT4gbOw85x0+j0sCeiBr7OMxVKvtsfOYmk9a5GaoZ69q1K7p16wYAGDVqFI4ePVqi+WfNmoWuXbvi4sWLPquJDZksiqLwOR5CMTuZmJtMzE0uZud7jouXET9xMdLe+xSBN12PWnveRFDL63z6GcxNJn/kZqgWvSyd5/fff49PPvkEzz//vA8rIol4F0y5mJ1MzE0m5iYXs/MNV1Y2Euesw58dBiLzq59QdcEY1Ppwsc8bMTfmJpPWuZWLFt3pdGLKlCl44oknUK1aNZ+Nq6oqnzMmjKqqsNvtsFqtzE0YZicTc5OJucnF7MpOVVVk7DmIuHEL4Dj/NyIe7wvbC4NgqhSq6WcyN3ny5qaVctGMbdy4EZmZmRg0aJDPxy6sG1YUpcgu2b2BeZqu1bwcF7nzFZVbWeoty7wc1/u87mn+3uakjWu0mtzzabHNSVoORq3J2190jVavEWsy2rjuadzmijduQkICDh06hPbt28NmsyHn1DkkjFuAjE8PIfjmm1B9w6sIaFwv9/1a7itLO6/ey9BI4/q7JvdrWh4dE9+MxcfHY/78+XjttdcQEBDg8/Htdnu+v2CYTKbcc0ftdnuB97trcDqdcLlc+aZZLBYoigKXywWn05lvmntcdwd+NXdHXti4ZrMZZrMZqqrC4XDkm6YoSu68DoejwMqk1bjF+a5AwWVY1nHNZnPuuFf/5cn916iSfldvmeuxDN3jFlaTVtm4v2tRy9A9rqdl6G39drlcBbLzxfrtaRn6c/0Gyt8+wmQy5daUNzej7iNKu36Xt32Eu96rP9PbuHrvI7Rav6XtIwrb5vRehkb9HREfH4/jx4/j2pq14Zy/CanL34WlRlVUXT0Fgbd1gKIouWNouY/w9vvE38uwvP6O0GIZAsi9seDV2fmC+GZs3rx5iImJwU033YSUlBQA/yxMh8OBlJQUhISElOnCO0+Hkz0dssy7kl/NZDIVeX1c3pWipON6m9fTctBqXE/fFfC8DMs67tW5uf+7LN9Vj2z0XIZXK+sy9LYcTCZTkducVstQr2zK4z6iqH1lRVm/ixrXzaj7iKJyM+I+Qo9laMR9hKdtzsj7iNKMW9b1OzvHhVpHz0FZORZpGVmoPDIWkcMfgBLk+Q/4Wu4jitrmjLoMfTmutH2EuzkzmUyaNGJAOWjGzpw5g++++w5t2rQpMK1NmzZYvnw5unTpUurxFUUpcmfnbb7STCvLvBz3f6cYFJWbHjVx3OJN95adtO9aUfYRWm5zkpaDUWvylJt7upH2lWWZt6KMy23O+7SEhAQkJycj4/DvSJ30Jtqd/xtnrmuIGpMeh1K/BpCZDltwoF/rNeo2J21co9ZUFuKbsTFjxuQeEXObPn06goKCMHLkSMTExJR6bC0XPGlHy4ssSVvMTibmJhNzk4vZefbtJ5/BvPx91P/5DwTYQrG3V2tcqFUFod99BcuPJjRt2hQ9evTwe13MTSatczNUM5aZmYl9+/YBAC5cuIC0tDTs3r0bANC2bVvYbDbExsbi4sWL2Lt3LwCgSZMmBcYJDw9HSEgI2rVrV+aa2JDJwrzkYnYyMTeZmJtczK5oqsOBlHU70Hj6SqhOF3KeHoD3g8Khpv8BhDfEXd1vRGhwACIiIvxeG3OTyR+5GaoZi4+Px7PPPpvvNfd/r1u3Du3atSv0YkEtaXWxHmlDVVU4nU6YzWbmJgyzk4m5ycTc5GJ2hcs8+DPixsxDzvFTqPRgD9jGDoWlamX0P34CO3f8hbu634gbmpb+bKmyYm4y5c1NK4ZqxmrXro0TJ054fM/69eu9jlOc9xSHlrexJO24XC5NNxrSDrOTibnJxNzkYnb/47h4GfGTliBt2ycIvLEpan28DEGt/nfWVGhwACxmE0KDfX/H7ZJibjJpnZuhmjEiIiIiIm/U7BwkLdmCxDnrYQoNQtX5o1Gp/51Qrrq7X0REBJo2barLqYlExcFmjIiIiIjESN9zAHFjF8Bx/m9EPNYHlV8YBHN4WKHvtdlsutysg6i42IwRERERkeHlnDqH+HHzkfHJIQTffBNqvDUDAY3r6V0WUZmwGfOAF1jKxPOx5WJ2MjE3mZibXBUtO1daBhJnr0PS0i2wVK+C6DXTENrjX+J+p1W03MoLrXNjM+aFtA29olMUhTs7oZidTMxNJuYmV0XKTlVVpG37BPETF8OVlILKIx5B5FMPwuThgc1GVZFyK0/8kRubMS94a3tZVFXNzYy5ycLsZGJuMjE3uSpKdtlHTiJu9FxkffMLQu+6GVGThsNat4beZZVaRcmtvMmbm1bYjHnAW9vL5HA4+JR7oZidTMxNJuYmV3nOzpmQjIQZK5Cy9gNYG9VBjXfmIOTmm/QuyyfKc27lmda5sRkjIiIiIl2pTidS1n2AhFdXAA4noiYNR8SQ+6BY+VOVyjeu4URERESkm8yvDyNu9FzkHPsdlR7oAdu4obBUs+ldFpFfsBkjIiIiIr9z/HUF8ZOWIO3dvQhs1QS1Pl6GoNZN9S6LyK/YjHnACyxlYm5yMTuZmJtMzE0u6dmp2TlIWroVibPXQQkJRNW5o1Dpge5QTCa9S9OU9NwqKq1zYzPmBTccWRRF4cWxQjE7mZibTMxNLunZpe/9GvHj5sN+9i9EPHofKr/4H5gjKuldluak51ZR+SM3NmNEREREpCn76fOIGzcfGXu/RnCXG1F93XQExNTXuywi3bEZ84LPGZNFVVU4HA5YLBbmJgyzk4m5ycTc5JKWnSstA4lz1yNpyRZYqtkQvWoKQu+6WUTtviQtN/pH3ty0wmbMAz5nTCbmJhezk4m5ycTc5JKQnaqqSHvvU8RPXAxXYjIqP/sQIp96EKaQIL1L042E3KggrXNjM0ZEREREPpN99HfEjZ6LrEOHEdrzZkRNHg5r3Rp6l0VkSGzGiIiIiKjMnIkpSHh1BVLWvg9rozqo8fZshNzSRu+yiAyNzRgRERERlZrqdCJl/Q4kTF8OOJyImvQkIobcD8XKn5lE3nAr8YAXWMrEW8fKxexkYm4yMTe5jJRd5qFfEDd6LnKOnkSlAd1hGzcUlugovcsyJCPlRsXHW9vrjA2ZLMxLLmYnE3OTibnJZZTsHH/HIX7SYqS9sxeBrZqg1u6lCLrxer3LMiyj5EYl44/c2Ix5wVvby6KqKpxOJ8xmM3MThtnJxNxkYm5y6Z2dmp2DpGVvI/GNtVBCAlF1zsuo9GAPKCaT32uRRO/cqHTy5qYVNmMe8BakMrlcLk03GtIOs5OJucnE3OTSK7v0Tw4hfuw82M/+hYgh96HyS/+BOaKS3+uQitucTFrnxmaMiIiIiIpkP30eca8sQMaegwjq3BrRa6YhsEkDvcsiKhfYjBERERFRAa70TCTOXY+kxZthqWZD9MrJCL37Fp5mR+RDbMaIiIiIKJeqqkjb/iniJyyGKyEZlZ8ZiMinB8IUEqR3aUTlDpsxD/iXH5l4PrZczE4m5iYTc5NLy+yyj/2OuNFzkfX1YYT2+BeiJj8F6zU1Nfu8ioTbnExa58ZmzAs2ZLIoisKdnVDMTibmJhNzk0ur7JyJKUiYsRIpa7bD2rAOamx9AyH/buvzz6mouM3J5I/c2Ix5wVvby6Kqam5mzE0WZicTc5OJucnl6+xUpxMpG3YiYfpyqDl2RE0YhohH74cSwAcU+xK3OZny5qYVNmMe8Nb2MjkcDj7lXihmJxNzk4m5yeWr7LK+PYIro+ci55f/olL/O2F75QlYoqN8UCEVhtucTFrnxmaMiIiIqAJx/B2H+MlLkPb2HgS2iEGtj5YgqM0NepdFVCGxGSMiIiKqANQcO5LefBuJr6+BEhSAqrNfQqWBPaGYTHqXRlRhsRkjIiIiKucyPv0GcWPnwf7HRUQM7o3KLw2GObKS3mURVXhsxjzgBZYyMTe5mJ1MzE0m5iZXSbKzn7mAuPELkbH7KwR1aoXoVVMQ2LShhtVRUbjNyaR1bmzGvOCGI4uiKLw4VihmJxNzk4m5yVXc7FzpmUictwHJizfDXCUS0SsmI/SeW/i7Rifc5mTyR25sxoiIiIjKCVVVkb79M8RNXAxXfBIin3oAkU8PhCk0WO/SiKgQbMa84HPGZFFVFQ6HAxaLhbkJw+xkYm4yMTe5PGWXffwU4sbMQ9aBnxDSvTOqTH4a1no1daqU8uI2J1Pe3LTCZswDPmdMJuYmF7OTibnJxNzkujo7Z1IqEmasQMrq7bA2qI0aW15HSNd2OlVHReE2J5PWubEZIyIiIhJIdTqRuvFDxE97E2pWDqLGP4GIx/pACeC1SURSsBkjIiIiEibru6OIHzMP2YdPIKzfnYh6ZSgs1avoXRYRlRCbMSIiIiIhHJfiED9pCTLe2YuA5o1R68PFCGrbTO+yiKiU2Ix5wAssZdLyIkvSFrOTibnJxNxkUXPsSF7+DhJeXwMl0Ioqb7yI8IE9oZjNepdGxcRtTiatczPUWnH27FmsXLkShw8fxsmTJ9GgQQPs3LnT4zyXL1/GmjVrcODAAfz555+oVKkS2rRpg5EjR6JWrVplrokNmSyKojAzoZidTMxNJuYmS8Zn3yBu7HzYT59HxODeqPzyEJgjK+ldFpUAtzmZ/JGboZqxkydPYt++fWjRogVcLlex7l5y7Ngx7N27F/fffz9atGiBxMRELFmyBH379sXOnTths9nKVBNvbS+LqqpwuVwwmUzMTRhmJxNzk4m5yWD/4yLixi9Axq6vENSxJaJXTkZAkwa5v5GYnRzc5mTKm5tWDNWMde3aFd26dQMAjBo1CkePHvU6z4033ohdu3blO4TYunVr3HLLLdi+fTsGDx5c6np4C1KZnE6nphsNaYfZycTcZGJuxuXKyELSvA1IWrQJpqhIRC+fhNBe/4aiKFBVldkJxdxk0jo3QzVjpfmi4eHhBV6rXr06bDYbLl++7IuyiIiIiDSnqirS3/8c8RMXwXElEZHDH0DlZx+CKTRY79KISCOGasZ85cyZM4iPj0fDhg31LoWIiIjIq+xfTyNuzDxkffUjQu7sjJqTn4K1ftmvfSciYyt3zZiqqpg6dSqqVauGnj17+mS8q7lPEyiM+zxgT9O1mpfjIne+onIrS71lmZfjep/XPc3f25y0cY1Wk3s+LbY5ScvBqDV5O93eaPUasSatx3UmpSJx5iqkrN4Oa72aqLH5dYTc2q7I7cr9mdzmZI3rZqSaJI7r75rcr2l56VK5a8YWLFiAQ4cOYcWKFQgJCSnzeHa7Pd+FliaTKff6NLvdXuD9AQEBAP45v9TlcuWbZrFYoCgKXC4XnE5nvmnucVVVLXRcq9Va5LhmsxlmsxmqqsLhcOSbpihK7rwOh6PAyqTVuMX5rkDBZVjWcc1mM0wmU4Hc3N9VUZQSf1dvmeuxDN3jFlaTVtm4v2tRy9A9rqdl6G39dk/Pm50v1m9Py9Cf6zdQ/vYR7ovRr87NqPuI0q7f5W0fYbFYYDKZCnymt3H13kdotX7rsY9QnU4kbdiB5FdXQs3OQcToIag05D4EhoUW+V3d4wJF/z4x2j5C2u8IrfYR3n6fAMbaR0j9HaHFMjSZTJreNKdcNWNbt27FokWLMG3aNHTo0KHM4ymKkvvDqTDu8AqTdyW/mslkKvL6uLwrRUnH9Tavp+ckaDWup+8KeF6GpRnX/SOjMO4NqCzfVY9s/L0MPY1b1mXobVpgYGCR9Wi1DPXKprzsI7yN6W3c8rR+FzWum5H2Ee59pae/9hptH1GWcQFj7SOyvj+GK6PmIOfwCYT1vQO2V4bCUr1Kvvd42uY8/TYx2j6irOOWl32Ee5srar7SjutWEZaht2llGRco+ru695VaNGJAOWrG9u7di4kTJ+KZZ55Bnz59fDp2YQvfWyCepms1L8fNfxi5qPeUl+8qcVxP071lJ+27VpR9hJbbnKTlYNSapO0ryzKvhHEdl+KRMGUpUrfsRkCza1Fz5yIEt2teonG5zckc16jbnLRx/V2Tp9OFfaVcNGPffPMNRo4cib59+2L48OE+G1frhU/asNvtXv9ST8bE7GRibjIxN/9Rc+xIXvEuEmathhJgRdU3XkSlgT2heDhK4gmzk4m5yaR1boZqxjIzM7Fv3z4AwIULF5CWlobdu3cDANq2bQubzYbY2FhcvHgRe/fuBQCcOnUKw4cPR7169dCrVy/8/PPPuePZbDbUrVvX79+DiIiICAAyPv8WcWPnw37qHMIH3QvbqCEwVy74WB4iqpgM1YzFx8fj2Wefzfea+7/XrVuHdu3aFbhY8PDhw0hNTUVqaioeeOCBfPP27t0bM2bM0L5wIiIiojzsZy8ifvxCpH/0JYI6tED08okIvL6R3mURkcEoKs/FK9SRI0egqiqaNWum2QV75Hvuu+y479ZDcjA7mZibTMxNO66MLCTN34CkhZtgskUgatKTCLv3Vp8tZ2YnE3OTKW9uR48eBQA0a9bMp59hqCNjRsONRSbmJhezk4m5ycTcfEtVVaTv+ALxExbBcTkBkU8OQOXnHoYpNNjnn8XsZGJuMmmdG5sxL7jhyOLttqVkXMxOJuYmE3MrnYSEBBw6dAjt27eHzWbLfT3ntzOIGzMXmV/+iJA7OqHmtqdhrV9LkxqYnUzMTSZ/5MZmjIiIiKgYkpOTcfz4cTRp0gQ2mw3O5FQkzlyN5JXbYL2mBqpvmoXQbu31LpOIBGEz5oWWD3kj33M/Xd39FHeSg9nJxNxkYm6lk56ZA4fThfT0LKRs2In4acugZmbDNvYxRA7tByVA+yMfzE4m5iZT3ty0wmbMA97bRCbmJhezk4m5ycTciichIQHJyclIz8zB5l0/oMqZS0h7cByu/HUZ6N4REaMfReUm1/q1JmYnE3OTiQ99JiIiItLJoUOHcPz4cZhTMtH586O49reLiK9SCZ890AnJdaug6ZmT6OHnZoyIyg82Y0RERERFaHfjTbjup7NwrduDbKcLB29ugv+264L+PdsgNDgAERERepdIRIKxGSMiIiIqRMa+75E+Zi7U388hIrYXLt13My7s+xT9e7bBDU1j9C6PiMoBNmMe8AJLmbS8yJK0xexkYm4yMbei2f/8C/HjFyH9w30Iat8C0Z9OROANjZB25gwsZhNCgwN0rY/ZycTcZNI6N64VXrAhk0VRFGYmFLOTibnJxNwK58rMRtKCt5C04C2YKkeg2rIJCOt9a+6yioiIQNOmTXU9NZHZycTcZPJHbmzGvOCt7WVRVRUulwsmk4m5CcPsZGJuMjG3/FRVRfrOfYifsAiOS/GIHNYflZ97GKawkHzvs9ls6NGjh05V/oPZycTcZMqbm1bYjHnAW5DK5HQ6Nd1oSDvMTibmJhNz+0fOiTOIGzMPmft/QMjtHVHznTmwNqitd1keMTuZmJtMWufGZoyIiIgqHGdKGhJnrkLyim2w1q2B6htnIvS2DnqXRUQVDJsxIiIiqjBUlwupm3chYeoyuNKzYBvzGCKH9oUSqO9NOYioYmIzRkRERBVC1o/HETd6LrJ//BVh99+GqAnDYKlRVe+yiKgCYzPmAS+wlInnY8vF7GRibjJVpNwclxOQMO1NpG78EAE3XIuaOxYhuH1zvcsqtYqUXXnC3GTSOjc2Y16wIZNFURQ+x0MoZicTc5OpouSm2h1IXrkNiTNXARYzqswcifBH7oFiNutdWqlVlOzKG+Ymkz9y41rhBW9tL0veO2AyN1mYnUzMTaaKkFvG/u8RN2Ye7Cf/RHjsPbCNehRmm37PB/OVipBdecTcZPLHndXZjHnAW9vLZLfbYbVa9S6DSoHZycTcZCqvudnP/Y348QuRvnMfgto1R/QnKxDY7Fq9y/Kp8ppdecfcZNI6NzZjREREJJ4rMxtJCzciaf4GmCLDUW3peITd141HIYjI0NiMERERkViqqiL9oy8RP34hHH9dQeSw/qg84hGYwkL0Lo2IyCs2Y0RERCRSzn//QNyYecjc9z1CurVHja1vIKBhHb3LIiIqNjZjREREJIozJQ2Jr69B8vJ3YK1TA9Xfeg2ht3fUuywiohJjM+aBoig811wYRVFgtVqZm0DMTibmJpPU3FSXC6lbdiNhyjK40jNhG/UoIp/oByUwQO/S/EZqdhUdc5PJH7mxGaNyhzs6uZidTMxNJmm5Zf30K+JGz0X2D8cRdl83RE0YBkvNanqXpQtp2dE/mJtMWufGZswLPmdMFlVV4XQ6YTabmZswzE4m5iaTpNwcVxKRMG0ZUjd+hICmDVHzg4UI7tBC77J0Iyk7+h/mJlPe3LTCZswDPmdMJpfLpelGQ9phdjIxN5mMnptqdyB51XtInLkKMCmoMmMEwh+5G4qFP12Mnh0VjrnJpHVu3KMRERGRoWR8+QPixsyD/cQfCI+9B7bRj8Fsi9C7LCIin2MzRkRERIZgP38J8eMXIn3HFwhq2wzRn6xAYPPGepdFRKQZNmNERESkK1dmNpIWbUTS/LdgCg9DtSWvIOz+23htDRGVe2zGPOA/AjLxfGy5mJ1MzE0mI+Smqioydn2JuFcWwvHXFUQ+0R+VRz4CU1iI3qUZmhGyo5JjbjJpnRubMS/YkMmiKAp3dkIxO5mYm0xGyC3n5FnEjZmHzC++Q8it7VFj6+sIaFhX15okMEJ2VHLMTSZ/5MZmzAve2l4WVVVzM2NusjA7mZibTHrm5kpNR8Lra5D85tuw1K6O6m/NQMhtHbn+FBO3OZmYm0x5c9MKmzEPeGt7mRwOB6xWq95lUCkwO5mYm0z+zk11uZC69WMkTF4KV3oGbC8NRsSw/jAFBfqthvKC25xMzE0mrXNjM0ZERESayvr5N8SNnovs748hrPetiJr4JCw1q+ldFhGR7tiMERERkSaccYmIn/YmUt/6EAFN6qPm9vkI7tRK77KIiAyDzRgRERH5lOpwIHnVdiS+thIwKajy6nMIj70HioU/O4iI8uJe0QNeYCmTyWTSuwQqJWYnE3OTSavcMr/6EXFj5iHntzMIf+Qe2EY/CnNUpCafVVFxm5OJucmkdW5sxrxgQyaLoiiw8C+vIjE7mZibTFrkZj9/CfETFiH9g88R1OYG1N67HIEtYnz6GcRtTirmJpM/cuNaQURERKXmyspG8qLNSJy3HqbwMFRbPA5hfW7nHzOJiIqBzZgH/ni2APmWqqqw2+2wWq3MTRhmJxNzk8kXuamqiozdXyHulQVwXLyCyKF9Ufn5QTCFhfi4WsqL25xMzE2mvLlpxVDN2NmzZ7Fy5UocPnwYJ0+eRIMGDbBz506v86mqiuXLl2Pjxo1ISEhAkyZNMHr0aLRs2VL7oomIiCqYnJNnETd2PjI//xbBXduhxubXEdCort5lERGJY6grCU+ePIl9+/bhmmuuQcOGDYs93/LlyzF//nwMGjQIy5YtQ9WqVTF48GCcO3dOw2qJiIgqFldqOuImLsK5LrGwnzmP6utfRY3Ns9iIERGVkqGasa5du2Lfvn2YP38+rr/++mLNk52djWXLlmHw4MEYNGgQOnTogNmzZyMyMhIrV67UuGIiIqLyT3W5kLplN/5s/yBSVm+H7cXBqPPlOoTe2ZmnXBERlYGhTlMsza0jf/zxR6SlpaF79+65rwUEBOC2227D3r17fVkeERFRhZN9+ASujJ6L7O+OIuzeroia+CQstaL1LouIqFwoVTP222+/4YcffsCpU6eQmJgIRVFQuXJlNGjQAK1bt0aTJk18XWeRTp8+DQBo0KBBvtcbNmyItWvXIisrC0FBQaUam3/tk0nLiyxJW8xOJuYmk7fcnHGJiJ++HKkbdiKgSX3U3D4fwZ1a+ak68oTbnEzMTSatcyt2MxYfH4+NGzdi+/btuHjxIlRVhdVqRUREBFRVRUpKCux2OxRFQY0aNdC7d2888MADqFKlipb1IyUlBQEBAQgMDMz3enh4OFRVRXJycqmbMTdVVfP9t6IoBV7LO62wefwxL8fNP62w3Moyri9qqujjFndef25z0sY1Yk1abXPSloMRayrOuFe/R3U4kLrmfSS89s+p/lHTn0F4bC8oFkvuHYa5DI0xbkXf5qSN6563sPeUt+9aUfYRvlCsZmzWrFnYuHEjQkNDceedd6Jjx464/vrrER2d/zSFS5cu4dixYzhw4AC2bt2KVatW4aGHHsLzzz+vSfFaU1UVOTk5+Y6QmUym3Ie/2e32AvMEBAQAAJxOJ1wuV75pFosFiqLA5XLB6XTmm+Ye130Lzau5u/LCxjWbzTCbzVBVFQ6HI980RVFy53U4HAVWJq3GLc53BQouw7KOazab4XA44HK5ChzZdN9OtqTf1VvmeixD97iF1aRVNu7vWtQydI/raRl6Wr9VVUV2djYURcmXnS/Wb0/L0J/rN1D+9hEmkwl2uz33R3pxx9VrH1Ha9bu87SMsFkuh9WQd/BlJ4xfB/tsZhD10F8JfHARzVCQcqgrY7bruIwDt1m9J+wgAyMnJya3j6nGNto+Q9jtCq32E2WyG0+mE0+ks9PcJYKx9hMTfEYA2y9D9Ha/+d85XitWMff/995g1axZuvfVWj0VER0cjOjoaXbt2xbhx4/Dpp59ixYoVPiu2MOHh4cjJyUF2dna+o2MpKSlQFAURERFlGt/T8yA8HbbMu5JfzWQyFXl9XN6VoqTjepvX0xPEtRrX03cFPC/D0o7rcrkKzc3932X5rnpko8cyLGrcsi5Db8vBPb2wbU6rZahXNuVpH6Gqqsd9ZUVZv4sa181o+wiXy5X748dx4RLiJy5G+vufI/Cm61F773IENG9c5JhFjav1PkKPZWjEfYR73tLsK/k7ovTjlnX9Lur3iRuX4f/eY5R9hKqq+faVWihWM7Zly5YSD6woCrp164Zu3bqVeN6ScF8rdubMGVx33XW5r58+fRo1a9Ys8ymKV/+VPu/r3uYrzbSyzMtx//dXi6Jy06Mmjlu86d6yk/ZdK8o+QsttTtJyMGpNnnIDADU7B8lLtiJx3nqYwkJQbdFYhPW5HYqXG2pxGeo3Lrc5meO6tzn+PimfNZWFoe6mWBqtW7dGWFgYdu3alduM2e127NmzB126dNG5OiIiIuNRVRWZew4iaeISOC5cQsTQvrA9PwimSqF6l0ZEVKEYqhnLzMzEvn37AAAXLlxAWloadu/eDQBo27YtbDYbYmNjcfHixdzb1gcGBmLo0KFYsGABbDYbGjdujE2bNiEpKQlDhgzR7bsQEREZUc7vfyJu7HxkfvYNgv/dFjU2zUTAtdfoXRYRUYVUombs999/x5tvvolTp06hcuXK6NmzJ+69994Ch+4++OADvPzyy/j1119LVEx8fDyeffbZfK+5/3vdunVo165doRcLPvbYY1BVFatWrUJCQgKaNGmClStXok6dOiX6/KtpeUiStOPpHHsyNmYnE3OTwZWWgcQ31iBp2duw1KiKamumIrT7v0r1jE/SF7c5mZibTFrnpqjFvFfjH3/8gd69e8PpdKJRo0aIj4/HpUuX0Lp1a8ybNw9Vq1bNfW9pmzEjOXLkCACgWbNmOldCRERUeqqqIu3tjxE/aQlcqemo/OzDiBg+AKagQO8zExERAO16g2IfGZs7dy5CQ0Px1ltv4Zpr/jmd4f3338eUKVPQv39/rFixosCDl8sDrW5jSdpwP7/D0wWyZEzMTibmZmzZh08gbvRcZH13FKG9uiJq4pOw1o7OvUMYc5OH25xMzE2mvLlppdjnJhw+fBgPPfRQbiMGAL169cKWLVtgMpnw4IMP4pdfftGkSL1o+YA30s7Vz5AgOZidTMzNeJzxSbjy/Cycv+0xuNIyUPO9eai+YhKstf/3fFDmJhezk4m5yaR1bsVuxpKSklClSpUCrzds2BCbN29G9erVERsbiy+//NKnBRIREVHxqA4Hklduw5/tH0Ta+5+hyrRnUPuzlQju3Frv0oiIqBDFPk2xVq1aOHHiRKHTqlSpgg0bNmDo0KEYNmwYbylPRETkZ5kHfkLc2HnIOX4alQb2RNTYx2GuUlnvsoiIyINiHxlr27Ytdu/eXeShurCwMKxevRr/+te/8Nlnn/msQCIiIiqa4+JlXHp8Ii7e+wyU4CDU2vMmqs15mY0YEZEAxT4y1rt3b8TFxeHo0aNo2bJloe8JCAjAokWL8Oqrr+K3337zVY264QWWMjE3uZidTMxNH66sbCQv2YLEuethCg1B1QVjUKnfHVCKeat65iYXs5OJucmkdW7FvrV9RcNb2xMRkRGpqoqMPQcRN24BHOf/RsTjfWF7YRBMlUL1Lo2IqNzS/db2REREpK+cU38ifuwCZHx6CMG3tEGNt2YgoHE9vcsiIqJSKnUzlpmZieDgYF/WYkh8zpgsqqrC4XDAYrEwN2GYnUzMzT9caRlInL0WSUu3wlKjKqqvnYaQ7v8q9TJnbnIxO5mYm0x5c9NKsW/gkVdcXBwGDhzo61oMh2dwysTc5GJ2MjE37aiqitR39uDP9g8iecW7qPx8LOp8tR6hPbqU+Qcdc5OL2cnE3GTSOrcSt3lnzpzBo48+Wugzx4iIiMg3sn/5L+JGz0XWt0cQes+/ETXxSVjrVNe7LCIi8qESHRn74YcfMGDAAERFRWHlypVa1URERFQhJCQk4KOPPkJCQkLua86EZFx58XWc7/YonClpqLFtLqqvnMxGjIioHCr2kbHdu3fjpZdeQuPGjbFy5UqEhYVpWRcREVG5l5ycjOPHj6NJkyaoHB6OlHU7kPDqcsClImrK04gY3BuKlffaIiIqr4q9hx8xYgSaNm2K1atXo1KlSlrWZBi8wFImLS+yJG0xO5mYW+mlZ+bA4XQh89BRnP/PZOQcP4VKD/aAbexQWKpq+9Bm5iYXs5OJucmkdW7FHj0oKAhxcXFISkqqMM0YwIZMGkVRmJlQzE4m5lZyCQkJSE5ORnpmDj7Ysg837f0OgSd3IKtJfZhXT4ClQytYbNo2YsxNLmYnE3OTyR+5FfuasbfeegtOpxOPPPIIzp8/r2VNhsI738iiqiqcTidzE4jZycTcSu7QoUN4b8tW/D7uddz35kbUPJ+Ar7pej3d7XI9tv/6EQ4cOaV4Dc5OL2cnE3GTyR27FPjLWtGlTbNmyBY899hgefvhhbNiwAbVq1dKsMCPgBiOT0+mEyVSqpzaQzpidTMytZFpnmhGz5Vuof8XjWOvr8XPzKNirXocB3W9EaHAAIiIi/FIHc5OL2cnE3GTSOrcSjVyrVi1s3rwZNWvWxMMPP6xVTUREROVOzqlz+OuBF5H+xFQEN6yLuvtWo+HrzyCwchgGdL8RNzSNQf369WGz2fQulYiI/KTEbV54eDhWr16NFi1aaFEPERFRueJKy0D85KU4969HkHPiD0Svnooab89GQEx9hAYHwGI2ITQ4QO8yiYhIB6W6PUhAQADmzJnj61qIiIjKDVVVkbbtE8RPXAxXUgoqj3gEkU89CFNwYO57IiIi0LRpU7+dmkhERMbCe2x6wLveyGQ2m/UugUqJ2cnE3ArKPnIScaPnIuubXxB6182ImjQc1ro1CrzPZrOhR48eOlTI3CRjdjIxN5m0zs2nzdi5c+eQk5ODhg0b+nJYXbEhk0VRFO7shGJ2MjG3/JwJyUiYsQIpaz+AtVEd1HhnDkJuvknvsgpgbnIxO5mYm0z+yK1Uzdi6devw008/5TtVcfTo0di+fTsAoEmTJli+fDmioqJ8UqSeVFVlQyZI3jtgMjdZmJ1MzO0fqtOJlHUfIOHVFYDDiahJwxEx5D4oVmOegMLc5GJ2MjE3mfxxZ/VS3afx7bffztdoffnll3jvvffQr18/jBs3DufPn8fChQt9VqReeGt7mex2u94lUCkxO5kqem6ZXx/G+VsfRdxLsxF6Z2fUObQRkU/0M2wj5lbRc5OM2cnE3GTSOrdS/Utx8eLFfKci7tq1C7Vr18akSZMAAHFxcXj//fd9UyEREZEBOf66gvhJS5D27l4EtmqCWh8vQ1DrpnqXRUREgpSqGbv6iNGBAwdw66235v53rVq1EBcXV7bKiIiIDEjNzkHS0q1InL0OSkggqs4dhUoPdIfCh7kSEVEJlepfjnr16uGTTz4B8M8pipcvX0aXLl1yp//9998IDw/3TYVEREQGkb73a5zrEouEV1cg/OG7UPfQRoQP7MlGjIiISqVUR8aGDBmC559/Hm3atEFmZiYaNmyIzp07507/5ptvcN111/msSL3wAkuZmJtczE6mipCb/fR5xI2bj4y9XyO4y42ovm46AmLq611WmVSE3MorZicTc5NJ69xK1Yz17NkTkZGR2LdvH8LDw/Hggw/CYvlnqKSkJERERKBXr14+LVQv3HBkURQFVqtV7zKoFJidTOU9N1daBhLnrkfSki2wVLMhetUUhN51s/h/G8p7buUZs5OJucnkj9wUlbcMLNSRI0cAAM2aNdO5EiIi8jdVVZH23qeIn7gYrsRkRD49EJFPPQhTSJDepRERkQ606g2Mfd9dA+BzxmRRVRUOhwMWi4W5CcPsZCqPuWUf/R1xo+ci69BhhPa8GVGTh8Nat4beZflUecytomB2MjE3mfLmppViXXHco0cPbN++HTk5OcUeOCcnB++++y569OhR6uL0xoOGMjE3uZidTOUlN2diCq68NBvnbx0CZ0ISarw9G9XXTC13jZhbecmtImJ2MjE3mbTOrVhtXu/evfHqq69i2rRp6Nq1Kzp06IDrr78etWvXRnBwMAAgIyMD58+fx9GjR3Hw4EF8/vnnsFqtGDJkiKZfgIiIqCxUpxMp63cgYfpywOFE1KQnETHkfsM/tJmIiOQr1r80jz32GB544AG88847eO+99/D+++/nHmI1m80AAKfTCeCf7vHaa6/F008/jT59+iAsLEyj0omIiMom89AviBs9FzlHT6LSgO6wjRsKS3SU3mUREVEFUew/+4WFhWHQoEEYNGgQzp8/j59++gmnT59GUlISACAyMhINGjRAy5YtUadOHa3qJSIiKjPH33GIn7QYae/sRWCrJqi1eymCbrxe77KIiKiCKdU5GLVr10bt2rV9XYvh8AJLmbS8yJK0xexkkpSbmp2DpGVvI/GNtVBCAlF1zsuo9GCPCvnQZkm5UX7MTibmJpPWuXGt8IINmSyKojAzoZidTJJyS//kEOLHzoP97F+IGHIfKr/0H5gjKuldli4k5Ub5MTuZmJtM/siNzZgXvLW9LKqqwuVywWQyMTdhmJ1MEnKznz6PuFcWIGPPQQR1bo3oNdMQ2KSB3mXpSkJuVDhmJxNzkylvblphM+YBb0Eqk9Pp1HSjIe0wO5mMmpsrPROJc9cjafFmWKrZEL1yMkLvvoU/hP6fUXMj75idTMxNJq1zYzNGRETliqqqSNv+KeInLIYrIRmVnxmIyKcHwhQSpHdpRERE+bAZIyKiciP72O+IGz0XWV8fRmiPfyFq8lOwXlNT77KIiIgKZbhm7NSpU5g6dSp++uknhIaGolevXnjuuecQEBDgcb7ExETMmTMH+/fvR1JSEmrXro2BAwfigQce8FPlRESkF2diChJmrETKmu2wNqyDGlvfQMi/2+pdFhERkUeaNGNZWVlISEhAzZol+2tkcnIyYmNjUa9ePSxYsACXLl3CjBkzkJWVhfHjx3uc99lnn8Xp06cxcuRI1KhRA/v378fEiRNhNpvRr1+/Un0PXlcgE8/HlovZyaRnbqrTiZQNO5EwfTnUHDuiJgxDxKP3Qwmw6laTFNze5GJ2MjE3mbTOrUTN2Ndff42FCxfi1KlTqFy5Mnr27IkhQ4YgODg43/v27NmDl19+Gb/++muJitm8eTPS09OxcOFCREZGAvjnorlJkyZh6NChiI6OLnS+K1eu4JtvvsGrr76K++67DwDQoUMHHDlyBB9++GGpmzGADZk0iqLwOR5CMTuZ9Mwt69sjuDJ6LnJ++S8q9b8TtleegCU6SpdapOH2Jhezk4m5yeSP3Ird6h09ehSPPvoozpw5g7Zt2yIyMhKLFi3Cvffei1OnTvmkmP3796NDhw65jRgAdO/eHS6XCwcOHChyPofDAQCoVCn/82LCwsLKfEdE3lFRFlVVc/9HsjA7mfTIzfF3HC49OQUXej4JRVFQ66MlqLZwLBuxEuD2Jhezk4m5yeSP3IrdjC1YsAC1a9fGRx99hPnz52PTpk1Yv349srKy8MADD+D7778vczGnT59Ggwb5n/0SHh6OqlWr4vTp00XOV6NGDXTu3BlLly7F77//jrS0NHz00Uc4cOAABg4cWOp6uMHIZLfb9S6BSonZyeSv3NQcOxIXbsSf7R9ExmffoOrsl1Brz5sIanODXz6/vOH2Jhezk4m5yaR1bsU+7nbs2DEMHjw431Grm266Ce+99x4ef/xxDBkyBG+88Qa6detW6mJSUlIQHh5e4PWIiAgkJyd7nHfBggUYMWIEevbsCQAwm80YN24c7rjjjlLXAxTekCmKUmSj5j6t0dN0rebluMidr6jcylJvWebluN7ndU/z9zYnbVyj1eSeT4ttLu+0jM++QfzY+bD/cRERg3uj8kuDYYoIK3R8ZuN9mpvR6jViTUYb1z1N622O4/p2XDcj1SRxXH/X5H5NywM0xW7GMjIyCpwGCAA2mw3r16/HU089heeeew4TJkxAYGCgT4v0RlVVjB49Gn/88QfeeOMNVK1aFQcPHsT06dMRERGR26CVht1uz3fdmMlkyj13tLBO2X3XR6fTCZfLlW+axWKBoihwuVxwOp35prnHVVW10HGtVmuR45rNZpjNZqiqmnvKppuiKLnzOhyOAiuTVuMW57sCBZdhWcc1m8254159vZ/VaoWiKCX+rt4y12MZusctrCatsnF/16KWoXtcT8vQ2/rtcrkKZOeL9dvTMvTn+g2Uv32EyWTKrSlvbr5ahpknzyJx0hJk7TmIwA4tUP3NCQhtHgPgn+Xrr/W7vO0j3PVe/ZnextV7H6HV+i1tH1HYNqf3MiwvvyO02kd4+30CGGsfIfV3hBbLEPhnH6GqaoHsfKHYzVjdunXxyy+/oG/fvgWmBQcHY+nSpXjppZcwfvx4tGzZslTFhIeHIzU1tcDrycnJiIiIKHK+L774Art378YHH3yAmJh//pFu164d4uPjMWPGjDI1Y+6VpqhpRcm7kl/NZDIVeWeWvCtFScf1Nq+nCxC1GtfTdwU8L8Oyjnt1bu7/Lst31SMbPZfh1cq6DL0tB5PJVOQ2p9Uy1Cub8riPKGpfWZpl6ErPROK89UhevAWmKpGotmISQu++Jd9nGG39LmpcN6PuI4rKzYj7CD2WoRH3EZ62OSPvI0ozbnn6N9A9blHbHJfh/95jlH2EuzkzmUyaNGJACZqxjh074t1338WYMWMK3D0R+GeBz549G5GRkdi0aVOpCm7QoEGBa8NSU1Nx5cqVAteS5fX777/DbDajcePG+V5v0qQJ3n77bWRmZhZac3EoilLkzs7bfKWZVpZ5OS5y/2pRVG561MRxizfdW3bSvmtF2Uf4eptTVRXp2z9D3MTFcMUnIfKpBxD59ECYQgvuw420HIxak6fc3NONtK8sy7wVZVwt/50z2nctT+MadZuTNq5RayqLYjdjffr0gaqqOHPmDJo2bVroexRFwYQJE3DNNdfgxIkTJS6mS5cuWLp0ab5rx3bv3g2TyYROnToVOV+tWrXgdDpx4sQJXHfddbmvHzt2DFFRUT5vxMi43H/1YG7yMDuZfJlb9vFTiBszD1kHfkJI986oMvlpWOuV7HmVVDzc3uRidjIxN5n8kZuianlFWgklJyejZ8+eqF+/PoYOHZr70Oe7774730OfY2NjcfHiRezduxcAkJaWhrvvvhtWqxXDhw9HtWrV8NVXX2HVqlV4+umn8eSTT5a4liNHjgAAmjVr5psvR0REhXImpSJhxgqkrN4Oa4PaqDLtGYR0bad3WURERLm06g0M9fS5iIgIrF27FlOmTMHw4cMRGhqKPn36YMSIEfned/UFg2FhYVizZg3mzJmD119/HampqahduzZGjRqFhx56qEw1aXWxHmlDVVU4nU6YzWbmJgyzk6ksualOJ1I3foj4aW9CzcpB1PgnEPFYHygBRZ/TT77B7U0uZicTc5Mpb25aKfWRsbi4OFSpUsXX9RjGkSNHoKoqmjVrxo1GEPdddngqgDzMTqbS5pb13VHEjZ6L7MMnENbvTkS9MhSW6uX33xSj4fYmF7OTibnJlDe3o0ePAvD9kbFiP/Q5r1OnTqFfv34+LYSIiMo/x99xuDR8Gi70GAZVVVHrw8WIXjSWjRgREVVIJT5N8fvvv8fw4cNx4403alEPERGVQ2qOHcnL30HC62ugBFpRdfaLqPRgTyganvpBRERkdCVqxnbt2oVRo0ahQ4cOmD9/vlY1ERFROZLx2TeIGzsf9tPnETG4Nyq/PATmyEp6l0VERKS7Yjdjq1atwqxZs3DzzTdj4cKFHh8CV17wnF6ZKsK6WV4xO5mKys3+x0XEjV+AjF1fIahjS0SvnIzApg39XB0VhdubXMxOJuYmk9a5FXv0mTNnok2bNliwYEGFWpnYkMnCZ8PJxexkKiw3V0YWkuZtQNKiTTBFRSJ6+SSE9vo38zUQbm9yMTuZmJtM/sit2F1VlSpV8Ntvv+HXX39F8+bNtazJUHhre1lUVc3NjLnJwuxkypsbAKS//zniJy6C40oiIoc/gMrPPgRTaLDOVdLVuL3JxexkYm4yXf1vnBaKfTfFrVu3olq1ahgyZEjurR3LOwM9D5tKwOFw6F0ClRKzk8nhcCDn19O4eN9zuPTYBAQ0a4y6X61H1JjH2IgZGLc3uZidTMxNJq1zK3YzVrNmTWzatAkxMTEYPHgwjh07pmVdREQkgDMpFYmvLMT5rkPg/OsKamx+HTXWvwpr/Vp6l0ZERGR4JXrOWHh4OFatWoVOnTph8ODBWtVEREQGpzqdSFm/A+c6PIj0LbthG/s46uxfi5Bb2+ldGhERkRglvhNHQEAA5syZg5kzZ2pRDxERGVzW98cQN2oOsg+fQFjfOxA+ajCC6tTgdRBEREQlVOrbIr700ku+rMOQ+MNCJpOpRAd8yUCYnbE5LsUjYcpSpG7ZjYBm16LmzkUIatsMTqdT79KoFLi9ycXsZGJuMmmdW7Gbse+++w4NGzaEzWbTsh7DYUMmi6IoFerRC+UJszMuNceO5BXvImHWaigBVlR940VUGtgTitkMgM/OkYjbm1zMTibmJpM/cit2q/fII4/gwIEDWtZC5BO8C6ZczM54Mj7/Fudu+Q/iJy1BpX53ou6hjQh/5J7cRgxgblIxN7mYnUzMTSatcyt2q1cRVyB/PFuAfEtVVdjtdlitVuYmDLMzFvvZi4gfvxDpH32JoA4tEL18IgKvb1TgfcxNJuYmF7OTibnJlDc3rfB4KRER5XJlZCFp/gYkLdwEky0C1d6cgLB7b+WPByIiIg2UqBnjP8ZEROWTqqpI3/EF4icsguNyAiKfHIDKzz3MhzYTERFpqETN2IsvvogXX3yxWO9VFAXHjx8vVVFEROQ/Ob+dQdyYucj88keE3NEJNbc9zYc2ExER+UGJmrGOHTuiXr16GpVCRET+5ExOReLM1UheuQ3Wa2qg+qZZCO3WXu+yiIiIKowSNWP33nsv7r77bq1qMRyelimTlhdZkraYnX+oLhdSN36E+GnLoGZmwzb2MUQO7QcloHTLn7nJxNzkYnYyMTeZtM6NN/Dwgg2ZLMxLLmbnH1k/HEPcqLnI/vk3hPW9HVHjh8FSvUqpx2NuMjE3uZidTMxNJn/kxmbMC97aXhZVVeF0OmE2m5mbMMxOW47LCUiYshSpm3ch4IZrUXPnIgS3a17mcZmbTMxNLmYnE3OTKW9uWmEz5kFFfLZaeeByuTTdaEg7zM73VLsDySveQeKsNYDFjCqvv4Dwh+7K99DmsmJuMjE3uZidTMxNJq1zK3Yz9ttvv2lWBBER+V7GF98hbuw82H8/h/DYXrCNfhTmyuF6l0VERET/j0fGiIiES0hIwKFDh9C+fXvYbDbY//wL8eMXIv3D/Qhq3wLRn05E4A2N9C6TiIiIrsJmjIhIuOTkZBw/fhzX1W8ALH8PSQs3wlQ5AtWWTUBY71t5fQIREZFBsRnzgD9gZOL52HIxu9JJz8hG9K/n4VzzMhITUxE5rD8qP/cwTGEhfvl85iYTc5OL2cnE3GTSOjc2Y16wIZNFURTu7IRidiWTkJCA5ORkZBw/g8QJb6Lj2Qv4s+E1qDb7eaRcWwdKThZs0L4ZY24yMTe5mJ1MzE0mf+TGZswL3tpeFlVVczNjbrIwu5L59tMvoKx6Hw1+OIOw8GB82rMlzl1TDaE/HYLll2/RtGlT9OjRQ/M6mJtMzE0uZicTc5Mpb25aYTPmAW9tL5PD4eBT7oVidt6pLhdSN+1C4ymroGZkwf74fXivUhRcGX8A4Q1xV/cbERocgIiICL/VxNxkYm5yMTuZmJtMWufGZoyISIisH48jbtRcZP/0K8Luvw1RE4bBUqMq+h0/gZ07/sJd3W/EDU1j9C6TiIiIionNGBGRwTkuJyBh6jKkbvoIATdci5o7FiG4ffPc6aHBAbCYTQgNDtCxSiIiIiopNmNERAal2h1IXvkuEmeuBixmVJk5EuGP3APlqouJIyIi0LRpU7+emkhERERlx2bMA15gKRNzk4vZ/U/G/u8RN2Ye7Cf/RHjsPbCNehRmW+HNls1m88vNOorC3GRibnIxO5mYm0xa58ZmzAtuOLIoisKLY4Vidv+w//kX4scvQvqH+xDUrjmiP1mBwGbX6l1WkZibTMxNLmYnE3OTyR+5sRkjIjIAV2Y2khZuRNL8DTBFhqPa0vEIu68b/yBERERUjrEZ84LPGZNFVVU4HA5YLBbmJkxFzU5VVaR/uB/x4xfC8XccIof1R+URj8AUpv0Dm32houYmHXOTi9nJxNxkypubVtiMecDnjMnE3OSqaNnlnDiDuLHzkbnve4R0a48ab89GQMM6epdVYhUtt/KCucnF7GRibjJpnRubMSIiP3OmpCFx1mokr3gX1jo1UP2t1xB6e0e9yyIiIiI/YzNGROQnqsuF1M27kDB1GVzpWbCNehSRT/SDEsjngxEREVVEbMaIiPwg66dfETd6LrJ/OI6w+7ohasIwWGpW07ssIiIi0hGbMQ94gaVMvHWsXOUxO8eVRCRMXYbUjR8i4PpGqPnBQgR3aKF3WT5VHnOrCJibXMxOJuYmU4W7tf2pU6cwdepU/PTTTwgNDUWvXr3w3HPPISDA+2k8ly5dwuzZs7Fv3z5kZGSgVq1aGDZsGO65555S18OGTBbmJVd5y061O5C86j0kzlwFmBRUeW0kwh+5G4qGd2TSQ3nLraJgbnIxO5mYm0z+yM1QvwqSk5MRGxuLevXqYcGCBbh06RJmzJiBrKwsjB8/3uO8ly9fRv/+/VG/fn1MmTIFYWFhOHnyJHJycspUE29tL4uqqnC5XDCZTMxNmPKUXcaXPyBuzDzYT/yB8Nh7YBv9GMy2CL3L0kR5yq0iYW5yMTuZmJtMeXPTiqGasc2bNyM9PR0LFy5EZGQkAMDpdGLSpEkYOnQooqOji5x31qxZqF69OlasWAGz2QwA6NChQ5nq4S1IZXI6nZpuNKQd6dnZz/2N+AmLkL7jCwS1bYboT1YgsHljvcvSnPTcKirmJhezk4m5yaR1boZaI/bv348OHTrkNmIA0L17d7hcLhw4cKDI+dLS0rBr1y48+OCDuY0YEZG/uDKzkfD6apzr9BCyvj2CakteQc2diypEI0ZERESlZ6hm7PTp02jQoEG+18LDw1G1alWcPn26yPmOHTsGu90Oi8WChx56CNdffz06deqEWbNmwW63a102EVVQqqoi7cP9ONf5YSTOXoeIR/ug7qGNqNTndp6GQkRERF4Z6jTFlJQUhIeHF3g9IiICycnJRc4XFxcHABg3bhz69euHp556Cr/88gvmz58Pk8mE559/vtQ1FXaqoqIoRZ7C6P4B5mm6VvNyXOTOV1RuZam3LPNyXO/zuqf5e5sr7bj2k2cRN2YeMvd9j+Bb26H6ltcR0LBOvu+iRb1lmVfaNidpORi1Jm+n2xutXiPWZLRx3dO4zcka181INUkc1981uV/T8tIlQzVjpeVyuQAAHTt2xKhRowAA7du3R3p6OlatWoXhw4cjKCioVGPb7fZ8f+E2mUyw/P/d0Ao76ua+66PT6cyty81isUBRFLhcLjidznzT3OOqqlrouO7bahY2rtlshtlshqqqcDgc+aYpipI7r8PhKLAyaTVucb4rUHAZlnVcd81X5+b+roqilPi7estcj2XoHrewmrTKxv1di1qG7nE9LUNv67f7c/Nm54v129MyLOm4rtR0pM7dgJQV78JSOxpV1kxFULf2UBQFdru9wu0jTCYTTCZTgdyMuo8o7fpd3vYRFosFZrO5wGd6G1fvfYRW67cv9xF5v2tplmFx9hHu/U1hv0+Mto+Q9jtCq32Et98ngLH2EVJ/R2ixDM1mM1wuF1RVm5v6GaoZCw8PR2pqaoHXk5OTERFR9J3I3EfT2rdvn+/1Dh06YOnSpTh79ixiYmJKXI+iKB5vqe/puQN5V/KruX+8FPWZpR3X27zujcOf43r6roDnZViacRVFKfK7uDegsnxXPbLx9zL0NG5Zl6G3aZ62N62WYXHHVV0upG39GAlTlsGVngHbS4MR/kQ/mIICi5y3Iuwj3D/sPako63dR47oZaR/h3ld6ms9o+4iyjAtov48o6bhA6dYXb/UYbR9R1nHLyz6iONscl+H/3mOkfYTJZNKsEQMM1ow1aNCgwLVhqampuHLlSoFryfJq1KiRx3Gzs7PLVFdhC99bIJ6mazUvx/3fqRvuvxwaoSaOW7zp3rLT87tm/fwb4kbPRfb3xxDW+1ZETXwSlprVSl2PL2oyyrhabnOSloNRa5K2ryzLvBVlXG5zMsc16jYnbVx/16Sq/9zaXqtGDDDYDTy6dOmCgwcPIiUlJfe13bt3w2QyoVOnTkXOV6tWLTRu3BgHDx7M9/rBgwcRFBTktVkripbnh5J2CjvthmQwWnaOK4m4/NwMXLj9cagZmai5fT6i35zotRGraIyWGxUPc5OL2cnE3GTSOjdDNWMDBgxAaGgohg8fjq+++grvvvsuZs6ciQEDBuR7xlhsbCxuu+22fPOOGDECn332GaZNm4YDBw5g6dKlWLVqFQYNGoSQkBB/fxUiEkx1OJD05js41/5BpH+4H1VefQ61P12J4E6t9C6NiIiIyhFDnaYYERGBtWvXYsqUKRg+fDhCQ0PRp08fjBgxIt/7CrtgsGvXrpg9ezYWL16MTZs2oVq1anj66afx+OOP+/MrEJFwmV/9iCuj58J+4g+EP3IPbKMfhTkqUu+yiIiIqBxSVJ6LV6gjR45AVVU0a9ZM0/NEybfcd9lx362H5NA7O/v5S4ifsAjpH3yOoDY3oMqrzyGwRclv/FPR6J0blQ5zk4vZycTcZMqb29GjRwEAzZo18+lnGOrImNFwY5GJucmlR3aurGwkLdqEpHkbYAoPQ7XF4xDGhzaXCJeVTMxNLmYnE3OTSevc2Ix5wQ1HFkXxfNtSMi5/Z6eqKjJ2fYm48QvhuHgFkUP7ovLzg2AK4zWmJcFtTibmJhezk4m5yeSP3NiMEVGFk3PyLOLGzEPmF98huGs71Nj8OgIa1dW7LCIiIqpg2Ix5oeVD3sj33E9Xdz/FneTwR3au1HQkvL4GyW++DUvtaFRf/ypC7ujEdaUMuM3JxNzkYnYyMTeZ8uamFTZjHvDeJjIxN7m0yk51uZD29h7ET14CV1oGbC8ORsST/WEKCtTk8yoabnMyMTe5mJ1MzE0mrXNjM0ZE5Vr24RO4Mnousr87irB7uyJq4pOw1Ir2PiMRERGRxtiMEVG55IxLRPz05UjdsBMBTeqj5vb5fGgzERERGQqbMSIqV1SHAymrtyPhtZUAgCrTn0X4oF5QNDzfm4iIiKg0+OvEA15gKZOWF1mStsqaXeaBnxA3ei5yfjuD8Ifvhm30ozBXqeyj6qgo3OZkYm5yMTuZmJtMWufGtcILNmSyKIrCzIQqS3aOC5cQN2Ex0t//DIFtbkDtvcsR2CLGxxVSYbjNycTc5GJ2MjE3mfyRG5sxL3hre1lUVYXL5YLJZGJuwpQmO1dWNpIXbUbivPUwVQpFtUVjEdbndigmk8bVkhu3OZmYm1zMTibmJlPe3LTCZswD3oJUJqfTqelGQ9opbnaqqiJj91eIe2UBHBcuI2JoX9ieHwRTpVA/VElX4zYnE3OTi9nJxNxk0jo3NmNEJErO738ibsw8ZH7+LYL/3RY1Ns1CwLXX6F0WERERUYmxGSMiEVyp6Uh4Yw2Sl70NS61qqL5uOkLu7MzTPYiIiEgsNmNEZGiqy4W0d/YgftISuFLTYXvhP4gYPgCmoEC9SyMiIiIqEzZjHvAv7jLxfGy5rs4u+/AJXBk9F9nfHUVor66ImvgkrLWjdaqOisJtTibmJhezk4m5yaR1bmzGvGBDJouiKHyOh1B5s3PGJyFh+nKkrN+BgOvqo+Z78xDcubXOFVJhuM3JxNzkYnYyMTeZ/JEb1woveGt7WfLeAZO5yaKqKlSHAylr30fijJUAgCrTnkH4f+6Fwn/ADIvbnEzMTS5mJxNzk8kfd1bnLxwPeGt7mex2O6xWq95lUAllHvwZcaPnwP7bH6g0sCeixj4Oc5XKepdFxcBtTibmJhezk4m5yaR1bmzGiEhXjguXED9xMdK2f4aA1k1Q6+NlCGrVRO+yiIiIiDTHZoyIdOHKykby4i1InLceptAQVJ0/GoG9uyIgkHdJJCIiooqBzRgR+ZWqqsjYcxBx4+bDcf4SIh7vi8rPx8JUKRR2u13v8oiIiIj8hs0YEflNzqk/ETdmPjI/+wbBt7RBjbdeQ0DjegB4jSYRERFVPGzGPFAUhXe8EUZRFAQEBOhdBl3FlZaBxNlrkbR0Kyw1qqL62mkI6f6vfNsXs5OJucnE3ORidjIxN5n8kRubMSLSjKqqSHtnD+InLYErORWVRz6CyOEPwhTM68KIiIiI2Ix5weeMyaKqKpxOJ8xmM3PTWfbhE4gbPRdZ3x1F6N23IGrScFjrVC/y/cxOJuYmE3OTi9nJxNxkypubVtiMecBrWGRyuVyabjTkmTM+CQmvrkDKug9gbXwNarw7ByFdbirWvMxOJuYmE3OTi9nJxNxk0jo3NmNE5BOqw4GUtR8gYcYKwKUiasrTiBjcG4qVuxkiIiKiwvBXEhGVWebBnxE3Zi5yjp9GpQd7wDZ2KCxVK+tdFhEREZGhsRkjolJzXLyM+ImLkfbepwhs3QS1Pl6GoFZN9C6LiIiISAQ2Yx7wAkuZLBau1lpTs3OQtGQLEuesgyk0GFXnj0al/ndCMZnKNC6zk4m5ycTc5GJ2MjE3mbTOjWuFF2zIZOGz4bSXvucA4sYugOP834h49H5UfvE/MIeHlXlcZicTc5OJucnF7GRibjL5Izc2Y17w1vayqKoKl8sFk8nE3Hws59SfiB+3ABmfHELwzTehxoZXERBT32fjMzuZmJtMzE0uZicTc5Mpb25aYTPmAW9tL5PT6dR0o6loXGkZSJy9DklLt8BSvQqiV09FaM8umvxjwuxkYm4yMTe5mJ1MzE0mrXNjM0ZEhVJVFWnv7kX8pCVwJaWg8ohHEPnUgzAFB+pdGhEREVG5wGaMiArI/uW/iBs9F1nfHkHoXTcjatJwWOvW0LssIiIionKFzRgR5XImJCPh1eVIWbcD1kZ1UOOdOQi5+Sa9yyIiIiIql9iMecALLGXi+dglpzqdSFn7ARJeXQ44XYiaNBwRQ+6DYvXvLoLZycTcZGJucjE7mZibTFrnxmbMCzZksiiKwud4lFDm14cRN3ouco79jkoP9IBt3FBYqtn8Xgezk4m5ycTc5GJ2MjE3mfyRG9cKKnf4OILicfx1BfETFyNt2ycIbNUEtT5ehqDWTXWtidnJxNxkYm5yMTuZmJtMWufGZswDVVW54QijqirsdjusVitzK4KanYOkpVuROHsdlJBAVJ07CpUe6A5F59MnmJ1MzE0m5iYXs5OJucmUNzetGO7k1VOnTuE///kPWrZsiU6dOmHmzJnIyckp0Rhr1qxBTEwMhg4dqlGVRDKl7zmIc/+KRcKrKxD+8F2oe2gjwgf21L0RIyIiIqqIDHVkLDk5GbGxsahXrx4WLFiAS5cuYcaMGcjKysL48eOLNcaVK1ewaNEiREVFaVwtkRw5p84h/pUFyNj7NYK73Ijq66cjIKa+3mURERERVWiGasY2b96M9PR0LFy4EJGRkQD+eer1pEmTMHToUERHR3sdY9asWejatSsuXryocbVExudKy0DinHVIWroVlmo2RK+agtC7buYpEkREREQGYKhzk/bv348OHTrkNmIA0L17d7hcLhw4cMDr/N9//z0++eQTPP/88xpWSWR8qqoi9d29+LPDQCS/+TYqP/sQ6hzYgLC7b2EjRkRERGQQhjoydvr0adx///35XgsPD0fVqlVx+vRpj/M6nU5MmTIFTzzxBKpVq+aTevijVSYtL7KUIPvo74gbPRdZhw4jtOfNiJo8HNa6NfQuq1gqenZSMTeZmJtczE4m5iaT1rkZqhlLSUlBeHh4gdcjIiKQnJzscd6NGzciMzMTgwYN8nldqqrm+29FUQq8lndaYfP4Y16Om39aYbmVZVxf1KTluM6EZCTOWImUdR/A2qgOarw9G8E331To+HrVW9x5/bnNSRvXiDVptc1JWw5GrKk44xb2Hi5DGeNW9G1O2rjueY20zUkb12g1+YKhmrHSio+Px/z58/Haa68hICDAZ+OqqoqcnJx8R8hMJlPuw9/sdnuBedyf73Q64XK58k2zWCxQFAUulwtOpzPfNPe47ltoXs3dlRc2rtlshtlshqqqcDgc+aYpipI7r8PhKLAyaTVucb4rUHAZlnVcs9kMh8MBl8tV4Mim+3ayJf2u3jLXYxm6xwWAnKwspL/1EZJfWwnV6ULk+KGwPd4PitUCu93us2zc37WoZege19My9LR+q6qK7OxsKIqSLztfrN+elqE/12+g/O0jTCZT7nqWNzej7iNKu35L3kcUtgwtFkuh9XgbV899BKDd+i1pHwEg9y7Thf0+Mdo+QtrvCK32EWazGU6nE06ns9DfJ4Cx9hF6LEMj7iPc+0pAu+eNGaoZCw8PR2pqaoHXk5OTERERUeR88+bNQ0xMDG666SakpKQA+GeBOhwOpKSkICQkpNRPz/b0PAhPhy3zruRXM5lMMBVxK/G8K0VJx/U2r6dloNW4nr4r4HkZlnZcl8tVaG7u/y7Ld9UjG0/fNevQL4gbMw85R08ibEB32MY+Dkt0VO539XU2ZV2G3paDe3ph25xWy1Cv9bs87SNUVfW4rzTaPqKoccvjPsJTTS6XK/fHj6/G1XofoccyNOI+wj1vafaV/B1R+nHLun4X9fvEjcvwf+8xyj5CVVWv+8qyMlQz1qBBgwLXhqWmpuLKlSto0KBBkfOdOXMG3333Hdq0aVNgWps2bbB8+XJ06dKlVDVd/Vf6vK97m68008oyL8f9318tispNj5q0GNfx1xXET16CtHf2IrBVE9TavRRBN15v2HqLM91bdlKy0Xpco9Wk5TYnaTkYtSZPubmnG2lfWZZ5K8q43OZkjmvUbU7auEatqSwM1Yx16dIFS5cuzXft2O7du2EymdCpU6ci5xszZkzuETG36dOnIygoCCNHjkRMTIymdRP5i5qdg6RlbyPxjbVQQgJRdc7LqPRgDz60mYiIiEggQzVjAwYMwPr16zF8+HAMHToUly5dwsyZMzFgwIB8zxiLjY3FxYsXsXfvXgBAkyZNCowVHh6OkJAQtGvXzm/1E2kpfe/XiB83H/azfyFiyH2o/NJ/YI6opHdZRERERFRKhmrGIiIisHbtWkyZMgXDhw9HaGgo+vTpgxEjRuR7X2EXDGpBy0OSpB1P59hLZD99HnGvLEDGnoMI6twa0WumIbBJ0aftSlbesqsomJtMzE0uZicTc5NJ69wUVct7NQp25MgRAECzZs10roQqKldaBhLnrkfSki2wVLMhatJwhPKhzURERER+p1VvYKgjY0ak1W0sSRvu53d4ukDW6FRVRdp7nyJ+4mK4EpJR+ZmBiHx6IEwhQXqXpqnykF1FxNxkYm5yMTuZmJtMeXPTCpsxD3jQUCaHwyH2KffZR39H3Ji5yPr6MEJ7/AtRk5+C9ZqaepflN5Kzq8iYm0zMTS5mJxNzk0nr3NiMERmAMzEFCa+uQMra92FtWAc1tr6BkH+31bssIiIiItIQmzEiHalOJ1I27ETC9OVQc+yImjAMEY/eDyWAfzkjIiIiKu/YjBHpJPObXxA3ei5yjpxEpf53wvbKE7BER+ldFhERERH5CZsxD3iBpUxGz83xdxziJy9B2tt7ENgiBrU+WoKgNjfoXZYhGD07Khxzk4m5ycXsZGJuMmmdG5sxL7jhyKIoimEvjlVz7EhathWJb6yFEhSAqrNfQqWBPaGYTHqXZghGzo6KxtxkYm5yMTuZmJtM/siNzRiRH2R8+g3ixs6D/Y+LiBjcG5VfGgxzZCW9yyIiIiIiHbEZ84LPGZNFVVU4HA5YLBZD5GY/cwFx4xciY/dXCOrUCtGrpiCwaUO9yzIko2VHxcPcZGJucjE7mZibTHlz0wqbMQ/4nDGZjJCbKz0TifM2IHnxZpirRCJ6xWSE3nMLd8BeGCE7KjnmJhNzk4vZycTcZNI6NzZjRD6kqirSt3+GuImL4YpPQuRTDyDy6YEwhQbrXRoRERERGQybMSIfyT5+CnFj5iHrwE8I6d4ZVSY/DWu9mnqXRUREREQGxWaMqIycSalImLECKau3w9qgNmpseR0hXdvpXRYRERERGRybMQ94fY9M/rp1rOp0InXjh4if9ibUrBxEjX8CEY/1gRLAW9eWFm/7KxNzk4m5ycXsZGJuMvHW9jpjQyaLv/LK+u4o4kbPRfbhEwjrdyeiXhkKS/Uqfvns8orbmkzMTSbmJhezk4m5yeSP3NiMecFb28uiqiqcTifMZrMmuTn+jkP8lGVI27obAc0bo9aHixHUtpnPP6ci0jo70gZzk4m5ycXsZGJuMuXNTStsxjzgLUhlcrlcPt9o1Bw7kpe/g4TX10AJtKLq7BdR6cGeUDTcOCsiLbIj7TE3mZibXMxOJuYmk9a5sRkj8iLjs28QN3Y+7KfPI2Jwb1R+eQjMkZX0LouIiIiIhGMzRlQE+x8XETd+ATJ2fYWgji0RvXIyAps21LssIiIiIion2IwRXcWVkYWkeRuQtGgTTFGRiF4+CaG9/s1zvImIiIjIp9iMecAf3zKV9rxeVVWR/v7niJ+4CI4riYgc/gAqP/sQTKHBPq6QisJz6WVibjIxN7mYnUzMTSatc2Mz5gUbMlkURSnVRpP962nEjZmHrK9+RMidnVFz8lOw1q+lQYVUlNJmR/pibjIxN7mYnUzMTSZ/5MZmzAve2l4WVVVzMytObs6kVCS+thLJq7fDWq8mamx+HSG3tvNDpXS1kmZHxsDcZGJucjE7mZibTHlz0wqbMQ94a3uZHA6H16elq04nUjd+hPhpy6Bm5cA27nFEPt4XSoC2T1knz4qTHRkPc5OJucnF7GRibjJpnRubMapwsr4/hrhRc5B9+ATC+t2BqFeegKV6Fb3LIiIiIqIKhs0YVRiOS/FImLIUqVt2I6DZtai5cxGC2zXXuywiIiIiqqDYjFG5p+bYkbziXSTMWg0lwIqqb7yISgN7QuGFtERERESkIzZjHvACS5ny5pbx+beIGzsf9lPnED7oXthGDYG5criO1ZEn3OZkYm4yMTe5mJ1MzE0mrXNjM+YFNxxZFEWB1WqF/exFxI9fiPSPvkRQhxaIXj4Rgdc30rs88sCdHcnC3GRibnIxO5mYm0z+yI3NGJUrrowsJM3fgKSFm2CyRaDamxMQdu+tbKqJiIiIyHDYjHnB54zJoKoq0nd8gfgJi+C4nIDIJweg8nMPwxQarHdpVEyqqsLhcMBisXCbE4S5ycTc5GJ2MjE3mfLmphU2Yx7wOWMy5Px2BnFj5iLzyx8RckdHVN3yOoKvvYY7O4G4zcnE3GRibnIxO5mYm0xa58ZmjMRyJqciceZqJK/cBus1NVB90yyE3NoOdrtd79KIiIiIiLxiM0biqC4XUjd+hPhpy6BmZsM29jFEDu0HJcDKvzoRERERkRhsxkiUrB+OIW7UXGT//BvC+t6OqPHDYKleRe+yiIiIiIhKjM2YB7zmyDgclxOQMGUpUjfvQsAN16LmzkUIbte80PdqeZElaYvZycTcZGJucjE7mZibTFrnxrXCCzZk+lLtDiSveAeJs9YAFjOqvP4Cwh+6C4rZXOj7FUVhZkIxO5mYm0zMTS5mJxNzk8kfubEZ84K3ttdPxhffIW7sPNh/P4fw2F6wjX4U5srhHudRVRUulwsmk4m5CcPsZGJuMjE3uZidTMxNpry5aYXNmAe8GYQ+7H/+hfjxC5H+4X4EtW+B6E8nIvCGRsWe3+l0arrRkHaYnUzMTSbmJhezk4m5yaR1bmzGyDBcGVlIWvAWkhZuhKlyBKotm4Cw3rfyL0hEREREVC6xGSPdqaqK9J37ED9+IRyXExA5rD8qP/cwTGEhepdGRERERKQZwzVjp06dwtSpU/HTTz8hNDQUvXr1wnPPPYeAgIAi57l8+TLWrFmDAwcO4M8//0SlSpXQpk0bjBw5ErVq1fJj9VRSOb+dQdzYecjc/wNCbu+Imu/OhbVBbb3LIiIiIiLSnKGaseTkZMTGxqJevXpYsGABLl26hBkzZiArKwvjx48vcr5jx45h7969uP/++9GiRQskJiZiyZIl6Nu3L3bu3AmbzVaqenh6nHacyalInLUaySu2wVq3BqpvnInQ2zr4ZGyejy0Xs5OJucnE3ORidjIxN5m0zs1QzdjmzZuRnp6OhQsXIjIyEsA/F81NmjQJQ4cORXR0dKHz3Xjjjdi1a1e+5wC0bt0at9xyC7Zv347BgweXuiY2ZL6lulxI3bQLCdOWwZWeBduYxxA5tC+UwKKPfJaEoih8jodQzE4m5iYTc5OL2cnE3GTyR26GatH379+PDh065DZiANC9e3e4XC4cOHCgyPnCw8MLLKjq1avDZrPh8uXLZaqJd1T0nawfj+PCnU/gynMzENzlJtQ99BYqPzPQZ40Y8E9e7v+RLMxOJuYmE3OTi9nJxNxk8kduhmrGTp8+jQYNGuR7LTw8HFWrVsXp06dLNNaZM2cQHx+Phg0blroebjC+4bicgMvPvIoLdwyFaneg5o5FiF46HpYaVTX5PLvdrsm4pD1mJxNzk4m5ycXsZGJuMmmdm6GOl6akpCA8vOBDfSMiIpCcnFzscVRVxdSpU1GtWjX07NmzTDUV1pApilJko+Y+rdHTdK3mNdq4cDiRtOJdJM5aDcViRpXXRqLSI3dDMZu91lPaet3zFZVbacctb9noNa6ned3T/L3NSRvXaDW559Nim5O0HIxak7c/KhqtXiPWZLRx3dO4zcka181INUkc1981uV/T8gCNoZoxX1mwYAEOHTqEFStWICSkbLdHt9vt+a4bM5lMuadEFtYpu+/66HQ64XK58k2zWCxQFAUulwtOpzPfNPe4qqoWOq7Vai1yXLPZDLPZDFVV4XA48k1TFCV3XofDUWBl0mpc+8HDiB83H/aTfyL0obsQ8eIgmG0RcLhcMP3/sgAKLkNv43pbhub/b/Suzs39XRVFKfF39Za5VsvQ03d1j1tYTWVdht6+a1HL0D2up2Xobf12uVwFsvPF+u1pGfo6m4q2jzCZTLk15c1Nq2Wo1/pd3vYR7nqv/kxv4+q9j9Bq/Za2jyhsm9N7Gfpz/Za4j/D2+wQw1j5C6u8ILZYh8M8+QlXVAtn5gqGasfDwcKSmphZ4PTk5GREREcUaY+vWrVi0aBGmTZuGDh3Kfnc+90pT1LSi5F3Jr2YymYq8M0velaKk43qb19MFiL4a1/7nX4ifsAgZH+5HULvmqLZ3OQKbXVvkvKWt19MydI97dW7u/y7Ld9Ujm+J8V3+NW9Zl6G05mEymIrc5rZahXtmUx31EUfvKirJ+FzWum1H3EUXlZsR9hB7L0Ij7CE/bnJH3EaUZtzzuI4ra5rgM//ceo+wj3M2ZyWTSpBEDDNaMNWjQoMC1Yampqbhy5UqBa8kKs3fvXkycOBHPPPMM+vTpU+Z6FEXJ/V9h07zNW5ppZZlXz3FdmdlIWrgRSfM3wBQZjmpLxyPsvm5+r1dV1dwNpqj3GHUZVoRxPU33lp2071pR9hFabnOSloNRa/KUm6d/48rymXrNW1HG5TYnc1yjbnPSxtWjJk+Z+YKhmrEuXbpg6dKl+a4d2717N0wmEzp16uRx3m+++QYjR45E3759MXz4cJ/VpOXCLw9UVUX6h/sRP34hHH/HIXJYf1Qe8QhMYWU7PbS0vP3Vg4yL2cnE3GRibnIxO5mYm0z+yM1QzdiAAQOwfv16DB8+HEOHDsWlS5cwc+ZMDBgwIN8zxmJjY3Hx4kXs3bsXAHDq1CkMHz4c9erVQ69evfDzzz/nvtdms6Fu3br+/ioVQs6JM4gbOx+Z+75HSLf2qPH2bAQ0rKN3WUREREREIhiqGYuIiMDatWsxZcoUDB8+HKGhoejTpw9GjBiR731XXzB4+PBhpKamIjU1FQ888EC+9/bu3RszZswodU1aXawnmTMlDYmzViN5xbuw1qmB6m+9htDbO+pdFgDkXpzp6ToIMiZmJxNzk4m5ycXsZGJuMuXNTSuKquW9GgU7cuQIVFVFs2bNuNH8P9XlQurmXUiYugyu9CxUHvkIIp/o59OHNpeV+y47ni6QJWNidjIxN5mYm1zMTibmJlPe3I4ePQoAaNasmU8/w1BHxsi4sn76FXGj5yL7h+MIu68boiYMg6VmNb3LIiIiIiISi80YeeS4koiEqcuQuvFDBFzfCDU/WIjgDi30LouIiIiISDw2Y1Qo1e5A8qr3kDhzFWBSUOW1kQh/5G4oGp4zS0RERERUkfCXtQcV9ZzejC9/QNyYebCf+APhsffANvoxmG3Fe+i2EWh5kSVpi9nJxNxkYm5yMTuZmJtMWufGtcKLitSQ2c/9jfgJi5C+4wsEtW2G6E9WILB5Y73LKhGtH8xH2mF2MjE3mZibXMxOJuYmkz9yYzPmRUW4tb0rMxtJizYiaf5bMIWHodqSVxB2/20iv7eqqnC5XDCZTCLrr8iYnUzMTSbmJhezk4m5yZQ3N62wGfOgvN/1X1VVpH/0JeLHL4TjryuIfKI/Ko98BKawEL1LKxOn06npRkPaYXYyMTeZmJtczE4m5iaT1rmxGaugcv77B+LGzkfmF98h5Nb2qLH1dQQ0rKt3WUREREREFQabsQrGlZqOhFmrkbz8HVhqV0f1t2Yg5LaOPGRORERERORnbMYqCNXlQuqW3UiYsgyu9AzYXhqMiGH9YQoK1Ls0IiIiIqIKic2YB+XlaFHWz78hbvRcZH9/DGG9b0XUxCdhqVlN77I0w/Ox5WJ2MjE3mZibXMxOJuYmk9a5sRnzQnJD5riSiIRpy5C68SMENKmPmtvnI7hTK73L0pSiKHyOh1DMTibmJhNzk4vZycTcZPJHblwrvJB4a3vV4UDyqu1IfG0lYFJQ5dXnEB57D5QKsBPIewdMablVdMxOJuYmE3OTi9nJxNxk8sed1cv/r/MykHhr+8yvfsSV0XNhP/EHwh+5B7bRj8IcFal3WX5lt9thtVr1LoNKgdnJxNxkYm5yMTuZmJtMWufGZqycsJ+/hPgJi5D+wecIanMDovcuR2CLGL3LIiIiIiKiIrAZE86VlY2kRZuQNG8DTOFhqLZ4HML63M5D4EREREREBsdmTChVVZGx60vEjV8Ix8UriBzaF5WfHwRTWIjepRERERERUTGwGRMo5+RZxI2Zh8wvvkNw13aosfl1BDSqq3dZRERERERUAmzGPFAUxVCn+7lS05Hw+hokv/k2LLWjUX39qwi5o5OhatSboiiwWq1cJgIxO5mYm0zMTS5mJxNzk8kfubEZE0B1uZD29h7ET14CV1oGbC8ORsST/WEKCtS7NEPijk4uZicTc5OJucnF7GRibjJpnRubMS/0fs5Y9uETuDJ6LrK/O4qwe7siauKTsNSK1q0eo1NVFU6nE2azmTs9YZidTMxNJuYmF7OTibnJlDc3rbAZ80DP54w54xIRP305UjfsRECT+qi5fT6CO7XSrR5JXC6XphsNaYfZycTcZGJucjE7mZibTFrnxmbMYFSHAymrtyPhtZUAgCrTn0X4oF5QLIyKiIiIiKg84S98A8k88BPiRs9Fzm9nEP7w3bCNfhTmKpX1LouIiIiIiDTAZswAHBcuIW7CYqS//xkC29yA2nuXI7BFjN5lERERERGRhtiMeaD1BZaurGwkL9qMxHnrYaoUimqLxiKsz+1QTCZNP7e84/nYcjE7mZibTMxNLmYnE3OTSevc2Ix5oUVDpqoqMnZ/hbhXFsBx4TIihvaF7flBMFUK9flnVTSKonBnJxSzk4m5ycTc5GJ2MjE3mfyRG5sxL3x9a/uc3/9E3Jh5yPz8WwT/uy1qbJqFgGuv8dn4FZ2qqrmZ8daxsjA7mZibTMxNLmYnE3OTKW9uWmEz5oEvb23vSk1HwhtrkLzsbVhqVUP1ddMRcmdnbpAacDgcsFqtepdBpcDsZGJuMjE3uZidTMxNJq1zYzOmMdXlQto7exA/aQlcqemo/MIgRD75AEzBgXqXRkREREREOmIzpqHswydwZfRcZH93FKH3/BtRk4bDWjta77KIiIiIiMgA2IxpwBmfhITpy5GyfgesMfVQY9tchPzrRr3LIiIiIiIiA2Ez5kFJr+dSHQ6krHkfCTNWACoQNfUZRAy+F4qFi9mfTHw0gFjMTibmJhNzk4vZycTcZNI6N3YJXhS3Ics88BPixsxFzq9nUGlgT9jGPA5L1coaV0dXUxQFFja/IjE7mZibTMxNLmYnE3OTyR+5ca0oI8eFS4ifuBhp2z9D4I1NUevjZQhq1UTvsoiIiIiIyODYjHng6dkCrqxsJC/egsR562EKDUHVBWNQqd8dUHgIWleqqsJut8NqtfKxAcIwO5mYm0zMTS5mJxNzkylvblphM1ZCqqoiY89BxI2bD8f5S4h4vC8qPx8Lc3iY3qUREREREZEgbMZKIOfUn4gbMx+Zn32D4FvaoMZbryGgcT29yyIiIiIiIoHYjBWDKy0DibPXImnpVlhqVEX1tdMQ0v1fPMxMRERERESlxmbME1VF6tt7kDB5CVzJqag88hFEDn8QpuBAvSsjIiIiIiLh2Ix5EPTcHFw5egqhd9+CqEnDYa1TXe+SqBi0vMiStMXsZGJuMjE3uZidTMxNJq1zM9yt/06dOoX//Oc/aNmyJTp16oSZM2ciJyfH63yqquLNN9/ELbfcgubNm6N///74+eefy1SLkpmNGu/OQfVVU9iICaEoSu7/SBZmJxNzk4m5ycXsZGJuMvkjN0M1Y8nJyYiNjYXdbseCBQswYsQIbN26FTNmzPA67/LlyzF//nwMGjQIy5YtQ9WqVTF48GCcO3eu1PVkLR+D4H/dWOr5yf9UVYXD4YCqqnqXQiXE7GRibjIxN7mYnUzMTSZ/5Gao0xQ3b96M9PR0LFy4EJGRkQAAp9OJSZMmYejQoYiOji50vuzsbCxbtgyDBw/GoEGDAAA33ngj7rzzTqxcuRITJ04sVT3cYGRyuVwwm816l0GlwOxkYm4yMTe5mJ1MzE0mrXMz1JGx/fv3o0OHDrmNGAB0794dLpcLBw4cKHK+H3/8EWlpaejevXvuawEBAbjtttuwf/9+LUsmIiIiIiIqFUM1Y6dPn0aDBg3yvRYeHo6qVavi9OnTHucDUGDehg0b4uLFi8jKyvJ9sURERERERGVgqNMUU1JSEB4eXuD1iIgIJCcne5wvICAAgYH5bzkfHh4OVVWRnJyMoKCgEtVit9uhqiqOHj1aovlIf6qq8gJZoZidTMxNJuYmF7OTibnJ5M4tJydHk/wM1YwZCTcWuZidXMxOJuYmE3OTi9nJxNxkcuem1V0VDdWMhYeHIzU1tcDrycnJiIiI8DhfTk4OsrOz8x0dS0lJgaIoHuctSqtWrUo8DxERERERUXEZ6pqxBg0aFLg2LDU1FVeuXClwPdjV8wHAmTNn8r1++vRp1KxZs8SnKBIREREREWnNUM1Yly5dcPDgQaSkpOS+tnv3bphMJnTq1KnI+Vq3bo2wsDDs2rUr9zW73Y49e/agS5cumtZMRERERERUGoY6TXHAgAFYv349hg8fjqFDh+LSpUuYOXMmBgwYkO8ZY7Gxsbh48SL27t0LAAgMDMTQoUOxYMEC2Gw2NG7cGJs2bUJSUhKGDBmi19chIiIiIiIqkqGasYiICKxduxZTpkzB8OHDERoaij59+mDEiBH53udyueB0OvO99thjj0FVVaxatQoJCQlo0qQJVq5ciTp16vjzKxARERERERWLoqqqqncRREREREREFY2hrhkjIiIiIiKqKNiMERERERER6YDNGBERERERkQ7YjBEREREREemAzRgREREREZEO2IwRERERERHpgM0YERERERGRDtiMXeXUqVP4z3/+g5YtW6JTp06YOXMmcnJy9C6L8ti1axeGDRuGLl26oGXLlujVqxfeeecdXP3IvLfffht33HEHmjVrhnvuuQeff/65ThVTYdLT09GlSxfExMTgyJEj+aYxO+N57733cO+996JZs2Zo164dHn30UWRlZeVO/+yzz3DPPfegWbNmuOOOO/Duu+/qWC25ffrpp+jbty9atWqFzp0749lnn8W5c+cKvI/bnH7Onj2L8ePHo1evXmjatCnuuuuuQt9XnIxSU1MxZswYtG3bFq1atcIzzzyDy5cva/0VKiRvuaWlpWHBggXo06cPbrrpJnTs2BFPPPEETpw4UWAs5uZfxd3m3D755BPExMQU+j5fZMdmLI/k5GTExsbCbrdjwYIFGDFiBLZu3YoZM2boXRrlsWbNGgQHB2PUqFFYsmQJunTpgldeeQWLFi3Kfc+HH36IV155Bd27d8fy5cvRsmVLPPXUU/j555/1K5zyWbx4MZxOZ4HXmZ3xLFmyBFOmTEGPHj2wcuVKTJ48GbVr187N7/vvv8dTTz2Fli1bYvny5ejevTvGjh2L3bt361x5xfbNN9/gqaeeQqNGjbBo0SKMGTMGv/32GwYPHpyvkeY2p6+TJ09i3759uOaaa9CwYcNC31PcjJ577jkcOHAAEydOxOuvv44zZ87gscceg8Ph8MM3qVi85Xbx4kVs2bIFnTp1wty5czFlyhSkpqaif//+OHXqVL73Mjf/Ks4255aVlYXp06ejSpUqhU73SXYq5Vq6dKnasmVLNTExMfe1zZs3q02aNFH//vtv/QqjfOLj4wu8Nm7cOLV169aq0+lUVVVVb7/9dnXkyJH53tO/f3/10Ucf9UuN5Nnvv/+utmzZUt20aZPauHFj9ZdffsmdxuyM5dSpU2rTpk3VL774osj3DB48WO3fv3++10aOHKl2795d6/LIg1deeUXt2rWr6nK5cl/7+uuv1caNG6vfffdd7mvc5vTl/ndLVVX15ZdfVnv27FngPcXJ6Mcff1QbN26sfvnll7mvnTp1So2JiVE//PBDDSqv2Lzllp6ermZkZOR7LS0tTW3btq06efLk3NeYm/8VZ5tzmzt3rjpw4MBC3+er7HhkLI/9+/ejQ4cOiIyMzH2te/fucLlcOHDggH6FUT42m63Aa02aNEFaWhoyMjJw7tw5/PHHH+jevXu+9/To0QNff/01Tzs1gKlTp2LAgAGoX79+vteZnfFs27YNtWvXxs0331zo9JycHHzzzTe48847873eo0cPnDp1CufPn/dHmVQIh8OB0NBQKIqS+1qlSpUAIPe0bm5z+jOZPP8UK25G+/fvR3h4ODp16pT7ngYNGqBJkybYv3+/7wuv4LzlFhISguDg4HyvhYaGom7duvlOY2Nu/uctO7c///wTq1evxrhx4wqd7qvs2Izlcfr0aTRo0CDfa+Hh4ahatSpOnz6tU1VUHD/88AP+r717D4qq7OMA/gVlceQqTiOBMBKMGAtoxF0GArUgJdIcw0ZhwoTSEGnM8BKKkJpKRIV4GydArVHzEsTgmKFOaRSmJq4zchVBcAxYdgnBxd33D152XHeV9Q05u73fz8z+sc/znGd/7G/O4fz23MaNGwdLS0t1rh7e0Xd1dYVCodB5vQQNn7KyMly/fh1Lly7V6mPuDM/ly5cxceJEbN++HUFBQfD09ERsbCwuX74MoP+flUKh0Np2Dpz6wW2ncObMmYPa2lrs378fcrkcN2/exGeffQYPDw/4+PgA4DpnDPTNUV1dHVxcXDSKb6B/55DroWGQyWSorq7W2F4yb4brk08+QUxMDCZNmqSzf6hyx2LsATKZDNbW1lrtNjY26OzsFCAi0kdlZSVKS0uRkJAAAOpcPZzLgffMpXDu3r2LzZs3IzU1FZaWllr9zJ3huXPnDn7++WccP34c69atQ15eHkxMTJCQkIC2tjbmzID5+vriq6++QnZ2Nnx9fTF9+nS0tbVh9+7dGDFiBACuc8ZA3xzJZDL1kc8HcR/GcGzduhUmJiaYP3++uo15M0w//fQTLl68iJSUlEeOGarcsRgjo9ba2orU1FQEBAQgLi5O6HBoEPn5+Rg7dizeeOMNoUMhPalUKnR3dyM3NxeRkZEICwtDfn4+VCoV9u3bJ3R49Bh//PEHVq5ciXnz5qGgoAC5ublQKpVITEzUuIEHET193333HQ4ePIj09HTY29sLHQ49Rm9vLzZu3Ijk5GSdl8YMNRZjD7C2toZcLtdq7+zshI2NjQAR0ePIZDIsXrwYtra2+PLLL9XnAA/k6uFcymQyjX4aXs3Nzdi7dy+WLVsGuVwOmUyG7u5uAEB3dzf+/vtv5s4AWVtbw9bWVuM0DVtbW3h4eKCmpoY5M2BZWVkIDAxEWloaAgMDERkZiV27dkEikeD48eMAuL00BvrmyNraGl1dXVrLcx9GeGfOnEF6ejqWLFmC2bNna/Qxb4anoKAApqammDlzJmQyGWQyGRQKBZRKJWQymfo6zaHKHYuxB+g6x1Mul+POnTta10OQsHp6epCUlAS5XI49e/ZoHCYeyNXDuayrq4OZmRmcnJyGNVbq19TUBIVCgcTERPj5+cHPzw/vvvsuACAuLg5vv/02c2eA3NzcHtnX29sLZ2dnmJmZ6cwZAG47BVRbW6t1rYO9vT3GjBmDxsZGANxeGgN9c/Tcc8+hvr5e65mb9fX1XA8FdOnSJaSkpOD111/Xecob82Z46urqcOPGDQQFBan3V0pKSlBbWws/Pz/1czSHKncsxh4QGhqKc+fOqX9tAvpvNmBqaqpxpxQSVl9fH5YvX466ujrs2bMH48aN0+h3cnLChAkTtJ5xVFpaiqCgIIhEouEMl/7r+eefR2FhocZr1apVAICMjAysW7eOuTNA4eHhkEqluHbtmrqto6MDV69ehVgshkgkQkBAAE6cOKGxXGlpKVxdXTF+/PjhDpn+y8HBARKJRKOtubkZHR0dcHR0BMDtpTHQN0ehoaHo7OzE+fPn1WPq6+shkUgQGho6rDFTv5qaGiQlJSEwMBAZGRk6xzBvhmfx4sVa+yshISFwdHREYWEhIiIiAAxd7kYO+V9gxGJjY1FUVISlS5ciKSkJt2/fxpYtWxAbG6u1w0/CycjIQHl5OdLS0tDV1aXx0EsPDw+IRCIkJydjxYoVcHZ2RkBAAEpLS/Hnn3/yGhcBWVtbIyAgQGefWCyGWCwGAObOwEyfPh1eXl5YtmwZUlNTYW5ujl27dkEkEuGtt94CALz33nuIi4vD+vXrERUVhYqKCpSUlCAnJ0fg6P+/xcbGYuPGjcjKykJERASkUqn6us0Hb5POdU5Yd+/exZkzZwD0F8tdXV3qwsvf3x92dnZ65eiFF15ASEgIVq9ejY8++gjm5ubIycmBu7s7Xn75ZUH+tn+zwfKmUqmwaNEimJubIz4+HlVVVeplLS0t1WcdMG/Db7Dcubq6aj0M+ujRo7h9+7bGfsxQ5c5E9fCxtf9ztbW1yMzMxMWLF2FhYYGYmBikpqby10EDEhERgebmZp19p06dUv8Sf+jQIezevRu3bt2Ci4sLPvjgA4SHhw9nqDSIiooKxMXF4fDhw/Dy8lK3M3eGpb29HZs2bUJ5eTkUCgV8fX2xatUqjVMYT506hc8//xz19fVwcHBAYmIi5s6dK2DUpFKp8O233+Kbb77BzZs3YWFhgSlTpiA1NVVrR4PrnHCampowbdo0nX2FhYXqnT99ciSXy7Fp0yacPHkSfX19CAkJwdq1a/mD8lMwWN4APPLGYv7+/igqKlK/Z96Gl77r3IPS0tJQVVWFkpISjfahyB2LMSIiIiIiIgHwmjEiIiIiIiIBsBgjIiIiIiISAIsxIiIiIiIiAbAYIyIiIiIiEgCLMSIiIiIiIgGwGCMiIiIiIhIAizEiIiIiIiIBsBgjIiIaQi0tLfDy8sKFCxeeeNmamhp4eHjg+vXrTyEyIiIyNCzGiIjIKBw5cgTu7u5wd3dHZWWlVr9KpUJYWBjc3d2RlJQkQIT98vLyMHnyZLz44otPvKybmxvCwsLwxRdfPIXIiIjI0LAYIyIio2Jubo6SkhKt9t9++w2tra0QiUQCRNWvvb0dx44dQ2xs7P88R2xsLE6ePInGxsYhjIyIiAwRizEiIjIqYWFhKCsrQ19fn0Z7SUkJxGIxnnnmGYEiA77//nuMGDEC4eHh//McwcHBsLGxwdGjR4cwMiIiMkQsxoiIyKjMnDkTUqkUv/zyi7rt3r17OHHiBKKjo3Uuo1Qq8fXXX2PmzJnw8vJCcHAw0tPT0dnZqTFOpVJh+/btCA0NxeTJk7Fw4UJUV1cjIiICaWlpg8b2448/wtvbGxYWFlp9+/fvx7Rp0+Dt7Y25c+eisrISCxcuxMKFCzXGmZmZwd/fH6dOndLn6yAiIiPGYoyIiIyKo6MjpkyZgh9++EHddvbsWcjlcrz66qs6l0lPT8fWrVvh4+ODNWvWYM6cOSguLsaiRYugUCjU43Jzc5Gbm4tJkyZh5cqVcHJyQkJCArq7uweNS6FQ4MqVKxCLxVp9Bw4cwIYNG2Bvb48PP/wQvr6+WLp0KVpbW3XOJRaLUV1dja6urkE/l4iIjNdIoQMgIiJ6UtHR0cjOzkZPTw9GjRqF4uJi+Pn5Ydy4cVpjKysrcejQIWzbtk3jyFlAQADeeecdlJWVITo6Gu3t7dizZw9eeukl7NixAyYmJgCAnJwc7NixY9CYWlpa0NPTg/Hjx2u037t3D7m5ufDy8kJBQQFGjuz/1+vu7o60tDTY29trzeXk5ASlUom6ujp4e3s/0XdDRETGg0fGiIjI6ERFRaG3txfl5eXo6urC6dOnH3mKYllZGaysrDB16lS0t7erX2KxGKNHj0ZFRQUA4Ny5c1AoFFiwYIG6EAOA+Ph4vWKSSqUAAGtra432qqoqSKVSzJs3T12IAf0FpY2Njc65Bubo6OjQ67OJiMg48cgYEREZHTs7OwQFBaGkpAQ9PT24f/8+XnnlFZ1jb9y4AblcjqCgIJ39bW1tAIBbt24BACZMmKD1WY8qmnRRqVQa7wfmdXZ21mgfOXIkHB0d9ZqDiIj+nViMERGRUZo1axY+/vhj/PXXXwgNDdU6IjVAqVRi7Nix2LZtm85+Ozu7IYnH1tYWACCTyf7xXANzjBkz5h/PRUREhounKRIRkVGaMWMGTE1NcenSJcyaNeuR45ydnSGVSuHj44Pg4GCt16RJkwAADg4OAICGhgaN5dvb27XuuqjLs88+i1GjRqGpqUmjfWDeh58b1tfXh+bmZp1zNTU1wdTUFC4uLoN+LhERGS8WY0REZJQsLCywfv16JCcnIyIi4pHjoqKicP/+fWzfvl2rr6+vT30UKjg4GGZmZti3b5/GaYIFBQV6xWNmZgZPT09UVVVptHt6esLW1hYHDx7UeDZacXHxI4u8q1evws3NDVZWVnp9NhERGSeepkhEREZr9uzZg47x9/fHm2++iZ07d+LatWuYOnUqzMzM0NDQgLKyMqxZswaRkZGws7NDQkICdu7ciaSkJISFhUEikeDs2bN6ny44bdo05OTkoKurC5aWlgAAkUiE5ORkZGZmIj4+HlFRUWhubsaRI0e0riMD+m+R//vvv2P+/PlP9mUQEZHR4ZExIiL619uwYQMyMzPR1taGnJwcZGdn49dff8Vrr70GHx8f9bjly5cjOTkZEokEW7ZsQWNjI/bu3YvRo0fr9TkxMTFQKpVaD2xesGAB1q5di5aWFnz66aeorKxEfn4+rKysYG5urjH2/PnzkEqlehWaRERk3ExUvGUTERHRY0VERMDf3x+bN28edOzq1avR0NCAAwcOPHacUqlEUFAQZsyYgaysLHX7kiVLYGJigry8vH8cNxERGTYeGSMiIhpC77//Pq5cuYILFy6o23p7e7VuV3/s2DFIpVL4+/ur22pra3H69GmkpKQMW7xERCQcXjNGREQ0hBwcHHDlyhWNtkuXLmHTpk2IjIyEra0tJBIJDh8+jIkTJyIyMlI9ztXVFRKJZLhDJiIigbAYIyIiesocHR1hb2+PoqIidHZ2wsbGBjExMVixYgVEIpHQ4RERkUB4zRgREREREZEAeM0YERERERGRAFiMERERERERCYDFGBERERERkQBYjBEREREREQmAxRgREREREZEAWIwREREREREJgMUYERERERGRAFiMERERERERCYDFGBERERERkQD+A9yAAmyopFRPAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAIsCAYAAAAeUFNGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAm9tJREFUeJzs3Xd0FGXbBvBrtqRnN4UQAog0QVAEkRZAVESlqIBSVQRBQMSGFRWCNKmCktB7LyKiqKDYQEEQGwI2DEiVkk2y6cmW+f7w27ypm02ym5l5cv3O8RzZ3Xlyz1wzk70zTZJlWQYRERERERFVik7pAoiIiIiIiETA5oqIiIiIiMgL2FwRERERERF5AZsrIiIiIiIiL2BzRURERERE5AVsroiIiIiIiLyAzRUREREREZEXsLkiIiIiIiLyAjZXREREREREXsDmioiIyMeGDBmCIUOG5P/7/PnzaNq0KXbs2KFgVURE5G1sroiIqMrs2LEDTZs2xbFjx5QuRRPOnz+PadOm4Z577kHLli3Ro0cPbN68udBn/vrrL7z66qvo1q0bWrVqhd69e+Ozzz5TqGIiourNoHQBRERE1U2dOnXw66+/wmBw/2s4ISEBv/zyC3r37o3IyEh8+umneOONN+Dv748HHngAADB16lRkZWVh0KBBCAoKwnvvvYdnnnkGa9asQYcOHapidoiI6P+xuSIiIqpikiTB39+/zM89/PDDmD59OvR6PQDgwQcfRLdu3bBr16785urFF19Ey5Yt86e5//77ERsbi48++ojNFRFRFeNpgUREpDqXL1/Gq6++io4dO+LGG29Er169sH379mKfu3DhAp544gm0atUKsbGxePPNN/HNN9+gadOmOHz4cKHPbty4EXfeeSduuukm9OvXDz/88EOxa6EAIC8vDwsWLMBdd92FG2+8Ebfddhtmz56NvLw8j2rfunUrunXrVujnFOXpNVctWrTIb6wAwGAwwGAwwGaz5b9WsLECAD8/P+h0ukKfISKiqsEjV0REpCpJSUkYMGAAJEnCww8/jIiICOzfvx+vv/46MjIyMGzYMABAVlYWhg4diqtXr+LRRx9FjRo18NFHHxVrqgBg06ZNmDJlCtq0aYNhw4bhwoULGDt2LEwmE2rVqpX/OafTiTFjxuDHH3/EgAED0KhRI/z1119Yu3Yt/vnnHyxatMht7e+++y7i4uJw8803Y+jQoTh37hzGjBkDs9mMmJiYSi+b9evX49y5cxg7dmypn5k3bx5yc3Pzj2wREVHVYXNFRESqMn/+fDgcDuzatQvh4eEAgMGDB+P5559HQkICBg0ahICAAGzduhXnzp3DwoUL0a1bNwDAoEGD0KdPn0Lj5eXl4Z133kGLFi2wdu3a/OucmjZtivHjxxdqrnbt2oWDBw9i/fr1aNOmTf7r1113HSZNmoSffvoJrVu3LrFum82G+fPno1mzZli3bh38/PwAAI0bN8bEiRMr3Vx9+OGHmD59OgYNGoS+ffuW+JmlS5di9erVeOGFF9C+fftK/TwiIio/nhZIRESqIcsyPvvsM3Tt2hWyLCM5OTn/v86dOyM9PR0nTpwAAHzzzTeIjo7GnXfemT+9v78/BgwYUGjM48ePIzU1FQMGDCh0A4n77rsPZrO50Gf37NmDRo0aoWHDhoV+tuvapZKOihX8ORaLBYMGDcpvrACgb9++CA0NrfhCAZCYmIjXXnsNd955JyZNmlTiZw4ePIh58+ZhyJAhGDVqVKV+HhERVQyPXBERkWokJycjLS0NW7duxdatW0v9DPDf9Vb16tWDJEmF3q9Xr16hf1+8eLHE1w0GA+rUqVPotTNnziAxMRGxsbEl/myLxVJq7a6fc+211xZ63Wg04pprril1Ok988sknsNlsmDRpEnS6kv8u+uGHHyI4OBgvv/xypX4WERFVHJsrIiJSDafTCeC/O96Vdupb06ZNffrzmzRpgldffbXE9wueQliVUlNTAQA1a9Z0+5mwsLBCR82IiKhqsbkiIiLViIiIQHBwMJxOJzp27Oj2s3Xq1MHff/8NWZYLHb06e/Zsoc/Vrl07//WCtya32+24cOFCoWatXr16+OOPPxAbG1vsiFhZXD/nzJkzhY582Ww2nD9/Htdff325xiuoTZs2kGXZ7Wduu+02NG/evMI/g4iIKo/XXBERkWro9Xrcc889+PTTT/HXX38Ve991SiAAdO7cGZcvX8YXX3yR/1pubi62bdtWaJobb7wRYWFh2LZtG+x2e/7ru3btgtVqLfTZHj164PLly8XGAICcnBxkZWWVWvuNN96IiIgIbNmypdBt299//32kpaW5meuy3XLLLXj44Yfdfua2224rdjMPIiKqWjxyRUREVe69997DN998U+z1Rx99FC+88AIOHz6MAQMGoH///mjcuDGsVitOnDiB7777Dt9//z0AYODAgdiwYQNeeOEFPProo4iKisKuXbvyH87rOvLk5+eHp59+GlOnTsXQoUPRo0cPXLhwATt27Ch2HVbv3r2xe/duTJo0CYcPH0br1q3hcDhw6tQp7NmzBytWrECLFi1KnCej0YjnnnsOcXFxGDp0KHr27Inz589jx44dlb7mat68eXj//ffx559/lvqZV155BRcuXMCXX35ZqZ9FREQVx+aKiIiq3ObNm0t8/YEHHkCtWrXw7rvvYuHChdi7dy82b96MsLAwNG7cGC+++GL+Z4ODg7F27VpMmzYN69atQ1BQEPr06YObb74ZTz/9dH6TBQCPPPIIZFnG6tWrMWvWLFx//fVYvHgxpk2bVuhzOp0OCxcuxJo1a/DBBx9g7969CAwMRN26dTFkyBA0aNDA7XwNHDgQDocDK1euxOzZs9GkSRMsXrwY77zzTiWXGBERaYEkl3USNxERkYasWbMGM2bMwP79+xEdHV3q55xOJ2JjY3HXXXdh2rRpVVghERGJitdcERGRZuXk5BT6d25uLrZu3Yr69esXaqxyc3OL3RBi586dSE1NRbt27aqkViIiEh9PCyQiIs166qmnULt2bVx//fXIyMjAhx9+iFOnTmHu3LmFPvfLL79gxowZ6N69O8LCwvDbb79h+/btaNKkCbp3765Q9UREJBo2V0REpFmdO3fG9u3bsWvXLjgcDjRu3Bjz589Hz549C32uTp06qFWrFtavXw+r1Qqz2YzevXvjxRdf5HOhiIjIa3jNFRERERERkRfwmisiIiIiIiIvYHNFRERERETkBbzmqhQ///wzZFmG0WhUuhQiIiIiIlKQzWaDJEm4+eab3X6OzVUpZFkudtteIiIiIiKqfjztC9hclcJoNEKWZdx4442QJEnpcqgSZFmGzWaD0WhklhrGHMXBLMXBLMXBLMXAHH3n2LFjHn2O11wRERERERF5AZsrIiIiIiIiL2BzRURERERE5AVsroiIiIiIiLyAzZUbvBBQHLylvhiYoziYpTiYpTiYpRiYo7J4t8AyeNJgORwO2Gy2KqiGqGRGoxF6vV7pMnyKf+wQB7MUB7MUB7MUA3NUHpurMsiyXOqKKssyLl26hNTU1KotisrNXY6iCAsLQ61atYSdT1mW4XA4oNfrhZ3H6oJZioNZioNZioE5Ko/NlRtlPSzM1VjVrFkTQUFBXIlVyvVAaEmShMxIlmVkZWXhypUrAICYmBiFK/Idp9Mp/BG66oJZioNZioNZioE5KovNVQU5HI78xioyMlLpcsgN0ZsrAAgMDAQAXLlyBTVr1uROlYiIiEgBvKFFBbmusQoKClK4EqL/uNZFXv9HREREpAw2V5Uk6pEQ0h6ui0RERETKYnPlBr+sioNZioGnO4qDWYqDWYqDWYqBOSqLzVUZqsOX8vj4eDRt2rTYf/feey8AoGnTpli5cmX+53fs2IFdu3Z5NHbXrl0xZcqU/H+PHz8+f9yq4rrWytdZ7t+/H8OGDUObNm3QsmVL9OnTB+vWrYPdbi/0uR07dqBp06ZITk4udayUlBS8+eabuPvuu9GiRQvExsZi8ODBWLNmjU/nQc0kSeLdjwTBLMXBLMXBLMXAHJXHG1qUoTrcwhsAAgICsHbt2mKvAcDWrVtRu3bt/Nfff/99BAUF4b777iv3z3nyySeRlZVVuWLLqeBdH32V5apVqzBr1izcddddmD17NgIDA7F//37Mnj0bhw4dQkJCAnQ6z/6WYbfbMXToUKSnp2PUqFFo2LAhkpKS8NNPP+Grr77CsGHDfDIPalcdbkxSXTBLcTBLcTBLMTBH5bG5cqOsW7GLRKfToVWrViW+V9rrFVGvXj2vjVUe7prkvLw8GAwGj5ufon777TfMnTsXffv2xcyZM/Nfj42NRePGjfHaa69h48aNGDJkiEfjff/99/jzzz+xYcMGtG3bNv/1Xr16wel0VqhGUdjtdj55XhDMUhzMUhzMUgzMUVk8LZDKVPC0wCFDhuD777/H119/nX/6YHx8vMdjFT0t0HWK3G+//YbHH38crVq1wt13342dO3cWm/brr79G//79cdNNN6FDhw6YNGlSoaNgWVlZmDJlCu655x60bNkSXbt2RVxcHNLT0wuN4zpVcfny5bjjjjtw00035T8IeseOHbjvvvvQokUL3HrrrZg/fz4cDofbeVq/fj0kScLTTz9d7L2+ffuifv36xY4KumO1WgEAUVFRxd6raANIRERERL7Hb2qUz263F/qvpCN3kyZNQvPmzdG6dWts3boVW7duRf/+/Sv9s1988UV07twZCxcuRLNmzTB+/HgkJibmv79nzx6MGTMGTZo0QUJCAl566SXs3bsXr7/+ev5ncnJy4HA4MG7cOCxfvhzPPvssjhw5grFjxxb7eZ999hm+/vprvP7661i0aBGCgoKwevVqTJgwAZ07d8aSJUswcuRIrFu3DvPnz3db+5EjR9C0aVPUqVOn2Hs6nQ533HEHzp07h8uXL3u0LJo1awadTocJEybgu+++Q15enkfTEREREYkgOTkZn3zyidvr09WKpwUSgP+O+txwww2FXps9ezZ69+5d6LXGjRsjJCQEQUFBXj1d8OGHH8bDDz8MALj55puxb98+fPrpp3jyySchyzJmz56Nnj17Yvr06fnTREVFYdSoUXjyySdx3XXXISIiApMnT85/3263o27dunjooYdw+vRpNGzYMP89m82G5cuX5z8bKiMjAwsWLMDjjz+O559/HgDQqVMnGI1GzJw5EyNGjEB4eHiJtV++fBlNmzYtdd5iYmIAAJcuXUJ0dHSZy6J+/foYP3485syZg2HDhsFoNOKmm25Cjx49MHjwYBgM3GyJiIhIXFarFb/99huaNWuGiIgIpcspF35Lc6OiFwLa/rkIpzW97A96mc4cCmP92mV/sAQBAQHYsGFDodeuueYab5Tlkc6dO+f/f1BQEGrXro1Lly4BAE6fPo0LFy7gtddeK3TnvXbt2kGn0+H48eO47rrrAAA7d+7EmjVrcObMmUKnDP7zzz+Fmqv27dsXegD0zz//jKysLHTv3r3Qz+jYsSNycnJw8uRJtGvXzvszXoqhQ4eiZ8+e+PLLL/H999/ju+++w7Rp0/DZZ59h7dq11fb0QF6cKw5mKQ5mKQ5mKQat5yjLMrK/+hHmM1eRma29s3fYXJWhvCuow5KKs+0HA0rceECvR/0TO6GPDCv3pDqdDi1atPB+TR4KDQ0t9G+j0Zh/OlxKSgoAlHh6HwD8+++/AIC9e/filVdewcCBAzFu3DiEhYXh6tWrGDt2LGw2W6EsIyMjC43h+hl9+/Z1+zNKEh0d7fZ913u1atUq9TMliYqKwsCBAzFw4EDYbDbExcVhx44d+Oqrr3DnnXeWaywRSJLEC3QFwSzFwSzFwSzFoOUck5OTkXrkV9jf2gj/n/9AjZsbYMvuHzEIQHCgH8xmsyaOYrG58jJ9ZBjqHd6s2JGrijRWahcWFgYAiIuLw0033VTs/Zo1awL477qsZs2aFXqu1vfff1/imEWbZrPZDABISEgosQmqW7duqfW1bdsWu3btwr///pt/CqCLLMvYt28frrnmGo9OCSyN0WjEsGHDsGPHDiQmJlbL5oqIiIjEZL9sweknJ8G8/ygyI4JxuNfNuHRtBKS0RHy06zwMeh2aN2+Onj17Kl1qmVTVXJ05cwYrV67E0aNHcfLkSTRs2BAfffSRR9NevnwZ8+bNw759+5CVlYU6depgzJgxuP/++ytVU0Wec1XRU/O0wmg0Ijc3t8p+XsOGDVGrVi2cO3cu/7qskuTk5BT7a43rYccFn/tQkptvvhmBgYG4dOkS7rrrrnLVN2TIEHzwwQdYsGABZsyYUei9Dz74AKdOncLEiRM9Hi81NRUhISHFrq36559/AJR8F8HqQJZl2O12GAwGzZ/yUN0xS3EwS3EwSzFoLUdndi6sS7Yi5Z0NCDcagBcegbFnZ5zfexRISwRMjXBvj1vyj1xpgaqaq5MnT2Lfvn1o2bIlnE6nx8+ZunLlCgYOHIgGDRpg6tSpCAkJwcmTJyt9l7Xq9Jyr8mjYsCF27tyJL7/8ElFRUahZs2aljsqURZIkjB8/Hi+++CKysrJw++23IzAwEBcvXsS+ffswbtw4NGjQAB07dsSUKVOwcOHC/JtifPfddx79DJPJhGeeeQZz5szBpUuX0K5dO+j1epw7dw5ffPEF4uPjERgYWOK0zZs3x4svvohZs2YhIyMDDzzwAAICAvDtt99i7dq1uPPOO/HQQw8Vm+6rr75CcHBwodeuu+46nDx5Mv+5WTfddBMMBgN+//13LF26FLVr1y538ycSbpPiYJbiYJbiYJZi0EKOsiwjY+cXSJ66FPZ/r8I84gGEv/gY9GH/XSYyyGDAR7vO494et+DG5qXfNEyNVNVcde3aFd26dQPw3/OQjh8/7tF0c+bMQa1atbBixQro9XoA/z3AlXxj5MiROHv2LF555RWkpaXhqaeeKvEZT97Uo0cPmEwmLFmyJP9oVJ06dXDrrbeiRo0aAIBBgwbh/Pnz2LBhA1auXInOnTvjrbfewoABAzz6GcOHD0d0dDRWr16NDRs2wGAwoF69erj99tvLPH95+PDhaNSoEVavXo0XX3wRNpsNDRo0wMsvv4yHHnqoxBtQvPbaa8Vee/bZZ9G3b1/cc889+OKLL7B27Vrk5uaiVq1auO+++zBq1CiEhIR4ND9EREREapPz02+wTIhHzpHjCOreGTHvvgW/RvUKfSY40A8GvQ7BgX4KVVlxkqzS9tbVXJV1WmBGRgY6dOiAN998s9KnABZ07NgxyLKMFi1alHhYNScnB6dPn0aDBg0QEBDgtZ9L3lfwlEAtHCKvKNHXSVmWYbPZYDQahc6xOmCW4mCW4mCWYlBzjvYLl2GZthQZ2/fC74ZGiJzyFIK6tCnxs8nJyTh06BA6dOigmptYHDt2DADKvAGcqo5cVcSJEydgs9lgMBjwyCOP4Oeff0ZYWBj69OmD5557TrN3TCEiIiIi0jpnRhZSEzYhddEW6EKCEDXvZYQ+1BPS/59tVpKIiAhN3LyiJJpvrpKSkgAAEyZMwIABA/DUU0/h119/xYIFC6DT6fDCCy9UeGxJkko8b7Xg666jIgXfc71enjG9MS3HdZ+Zi1pq8va4BdfJoq+ppd7K1mQwGIp9RgvZeHNcNdZU3nFdWVbmZ1ZlvVquydfjFt0uuQyVH7ei0wIocR/rjZq0tgzVlk15xi1pm1SqXtnpRMa2T5E8fRmcqekwj+6P8OeGQBcaXOz7c1XV5O1xS6L55sr5/8+T6tixI8aPHw8A6NChAzIzM7Fq1SqMHTu2UqdIFXygLPDf86AKfikorblyvV+QJ++5W9kqMm7RsTlu+af11bgF3/fGuK51p+A6a7fbi03ruoOQ0+mEw+Eo9F7B9dtmsxWryXWagcPhyN/2io5btIaC48qyXOq4AEocV6/X519LWXRcSfrf8zxKmlfXeyXNq2vckuota9zKLEM/P79S59WTcSuzDCsyr74a1zWvDoejXMvQl9m4W7/dzasn4wK+W4bu1u+SalJqGfp6H1GZ9Zv7CPXuI8q7DLmP8Gxefb2PyD50FEkT4mH79S8E3nc7wl4fCcM1tSC5mVe17yNk2bM7iGu+uTKZTAD+a6gKio2NxZIlS3DmzBk0bVrxu4y4u5WlJEn5/5X2fmkqMk1lxvVk7Ooyrhpr8sa4rnWx4C3ci97OvSCdTlfijTZcSjql1vWzCu6US/pMaafjunuvrHEL1lzS8qjovJZVk7eXoYu7ea1MvRXNBnA/r94cV5ZlOJ1OSJJUqWWotvW7tHFdfJWNksvQlaVru1RyH+GrZVhd9hGuLN1976mqfURB3Ed4Nm7BP/wX3CaBql2Gtn8u4tKUxcj8aB/8b74etXctRED7/12jpOV9hCff0QEBmqvGjRu7fb8yz2NydaglLcyiX2hLe78kav6CLuK4riM6BTNTuiZfjFvS/Kmt3srW5HQ6odfrvbrNaS1zNdZUkXHdZVmZcSv7nlLTannckrJUuqbqPG5Fp3V9KXe3XaptXrU2blXVVDTHqqjXkZaB1PnrkLpsO/SRYai5aAJCHrwLkps/Avi6pqoat6jS21iNqFOnDpo0aYKDBw8Wev3gwYMICAgos/mqrPKcg0nkS1wXiYiIqCrJdjusa3bibPvBsK56H+HPDUG97zYitP89pTZWolPVkavs7Gzs27cPAHDhwgVkZGRgz549AIB27dohIiICQ4cOxcWLF7F379786caNG4cnn3wS06dPx+23345jx45h1apVGDFiBIKCgnxSq+uwYlZWVqkPlyWqSllZWQDcH94nIiIi8oasr76HZdJC5P1+CiEDuiNywigYYqKULktxqmquLBYLnn322UKvuf69bt06tG/fvsSL57p27Yp58+Zh0aJF2Lx5M2rWrImnn34ao0aN8lmter0eYWFhuHLlCgAgKCioXIcMqeoUPC1QxIxkWUZWVhauXLmCsLAwt9csEREREVVG3skzsExaiKy93yGg/U2os3c5Alpdr3RZqqHahwgrzfWgsBtvvNHt+cmXLl1CampqFVZGFeHpHV60LCwsDLVq1RJ2Pku6SJe0iVmKg1mKg1mKwZc5OpKtSJmzGtY1O2GoUxORcWMQfN/t1WZ9qTYPEfa1si5ui4mJQc2aNUu8LSRRVTEajcIfsZIkSfh5rC6YpTiYpTiYpRh8kaOcZ4N11ftIeWsNZLsDEa+NhHlkP+gC/L36c0TB5qoMnhzxKOv20aQs0U8LrC6YoziYpTiYpTiYpRi8maMsy8j67CAskxbCdvoCTI/ci/BXRsBQM8JL1YqJzZUbPGNSHHa7nTd6EABzFAezFAezFAezFIM3csw98TcscQnI3v8jAm9rg+hVU+HfvJGXKhQbmysiIiIiIoL9SjKSZ65A+saPYWxQB7U2zkTQXR15NLMc2FwREREREVVjzpxcWJe+i5S310My6BE59WmYH+sDychWoby4xIiIiIiIqiFZlpH54dewTFkM+8UrMD/WF+EvPQZ9uEnp0jSLzZUbPAQqDmYpBuYoDmYpDmYpDmYpBk9zzPn5d1gmJiDn8K8IursjYrbOhV/jej6uTnxsrsrAHY32SZLEC3QFwBzFwSzFwSzFwSzF4EmO9otXYJm+DBnbPoVfs4aI2T4fQbe1qaIKxcfmioiIiIhIcM7MbKQu3IzUhE2QggNRY+6LMD3cC5KB7YA3cWmWwZPnXJG6ybIMu90Og8HALDWMOYqDWYqDWYqDWYqhpBxlpxMZ2z+DZdoyOCypCBvdH2HPDYHeFKJwtWJic+UGn3MlDmYpBuYoDmYpDmYpDmYphoI5Zh/6FZaJ8cj95Q8E33c7IuPGwFi/toLViY/NFRERERGRQGxnLiJ56lJkfvgV/Fs2Re0PExAY21LpsqoFNldERERERAJwpmcidd5apC9/D/oIM6LiX0PogHsg6XRKl1ZtsLkiIiIiItIw2eFA+saPkTxjBZwZWQh7+mGEP/0QdMGBSpdW7bC5coMXdIrDwDvhCIE5ioNZioNZioNZalPW/h9gmRiPvN9OIaTf3Qh/fSSMdaL5PVYh3IrKwBVT+yRJYo4CYI7iYJbiYJbiYJbak5d4FpZJi5D16QEEtL0RdT5dioDWzZUuq9pjc1UG3opd+2RZhtPphE6nY5YaxhzFwSzFwSzFwSy1w5GShpS5a2BdtQOGmChEL5+M4N53QJIk5qgCbK7c4C1JxeFwOKDjxZyaxxzFwSzFwSzFwSzVTbbZYV29EylzV0POsyHilREwPzEAugD/Qp9jjspic0VEREREpFKyLCNr73ewTFoIW+I5hD7cCxHjH4chOlLp0qgEbK6IiIiIiFQo9/dTsMQlIPvrIwi8tTWil0+G/42NlS6L3GBzRURERESkIvarKUiZtRJp63fBWL82aq2fgaB7OvE6Kg1gc+UGV2Bx8NxjMTBHcTBLcTBLcTBL5cm5eUhd9i5S568HdBIiJ4+FeXhfSH5Gj8dgjspic1UGNljaJ0kSn90hAOYoDmYpDmYpDmapLFmWkbnra1imLIb9/BWYhvVGxMvDoY8wl2sc5qg8Lv0y8Fbs2lfwro/MUruYoziYpTiYpTiYpXJyj/6JpAnxyDl0FEHdOiBm02z4NalfobGYo/LYXLnBW7GLw2azwWj0/JA6qRNzFAezFAezFAezrFr2S0lInrYU6ds+hbFpfcRsewtBd7Sr9LjMUVlsroiIiIiIqogzKwepizYjNX4TpEB/1Jj9PEyP3AuJp/MJgSkSEREREfmY7HQi4729sExbBsfVZJhH9UP4uEehN4cqXRp5EZsrIiIiIiIfyvn+GJImxiP3p98R3Os2RE4aA2ODOkqXRT7A5oqIiIiIyAds5y4hecpiZOz8En4trkPtnQsQ2OlmpcsiH2Jz5YYkSbzTigAkSYKfn5/SZVAlMUdxMEtxMEtxMEvvcmZkIeXt9bAu2QZdWCiiFryK0IHdIfn4GVTMUXlsroiIiIiIvEB2OJC+6RMkz1gBZ3oGwp4ajLCnHoIuJEjp0qiKsLkqA59zpX2yLMPhcECv1zNLDWOO4mCW4mCW4mCWlZf1zY+wTExA3om/EfLgXYiYMBrGutFVWgNzVB6bKzf4nCtxOJ1O6PV6pcugSmKO4mCW4mCW4mCWFZOXeA6WyYuQtftb+Le5AXX2LEHALTcoVg9zVBabKyIiIiKicnKkpiPlrTWwrtwBQ3Qkai6bhJA+d/KIUTXH5oqIiIiIyEOyzY60tR8gec5qyDl5iHjpMZifGAhdoL/SpZEKsLkiIiIiIvJA5ueHYIlLgO3vswgd3BMRrz4OQ60aSpdFKsLmyg0e1hWHwcBVXQTMURzMUhzMUhzMsnR5f5xGUlwCsr/6HgGdbkb0kjj439RE6bJKxByVxaVfBjZY2sfnlYmBOYqDWYqDWYqDWZbMkZSC5NmrkLb2QxjqxaDW2ukI6nGrapcVc1Qem6sy8Fbs2ifLMpxOJ3Q6HbPUMOYoDmYpDmYpDmZZmJybB+uK95Aybx0AIPKNMTCPeBCSn1Hhytxjjspjc+UGb8UuDofDAZ2Pn4pOvsccxcEsxcEsxcEs//vul/nJN7C8sQj2c5dgevR+RLwyHPrIMKVL8xhzVBabKyIiIiKq9nJ//QtJE+ORc/AXBHZtj5gNM+DXtIHSZZHGqKqtPXPmDOLi4tC7d280b94c9957b7nHWLNmDZo2bYrRo0f7oEIiIiIiEon9UhKuPDMD57s9DkdSCmK2zEXtrXPZWFGFqOrI1cmTJ7Fv3z60bNkSTqez3KflXb16FQsXLkRkZKSPKiQiIiIiETizc2FdtAUpCzZCCvBDjZnjYHr0Pki82x5VgqrWnq5du6Jbt24AgPHjx+P48ePlmn7OnDno2rUrLl686JV6eCGgOHjusRiYoziYpTiYpTiqS5ayLCNjx+dInroE9ivJMI/sh/DnH4XeHKp0aV5RXXJUK1Ut/cqsDD/88AM+//xzvPDCC16siA2WCCRJgsFgYJYaxxzFwSzFwSzFUV2yzPnhBC70eAJXnpgC/5ZNUe/b9agxeawwjVV1yVHNVHXkqqIcDgemTp2KJ554AjVr1lS6HFIh3lJfDMxRHMxSHMxSHCJnaTt/GclTlyBjx+fwu/E61H7/HQR2bq10WT4hco5aIERztWnTJmRnZ2PYsGFeHdf1rICiK6gkSaVeD+b6rLv3fTUtxy35PVmWYbPZ4Ofnp5qaquu4lZnW6XTCZrPBaDQW2ibVOq9qXIZqGbfgNlkaNdWr5Zp8Pa4rS9d2yWWo/LgVnRYA8vLyiu1jvVFTVS3D5ORkHDp0CLGxsYiIiPjve1xGFlLjN8K6eCt0phDUePsVmAb1AHS6EsdWYzblGbekbVLN9Wq9ppJovrmyWCxYsGABZs2a5fYXdUXZbLZCOxmdTgfD/1/oaLPZin3eVYPD4YDT6Sz0nuswrdPphMPhKPSea1zXRlGU0WgsdVy9Xg+9Xg9ZlmG32wu9J0lS/rR2u73YyuGrcT2ZV6D4MvTFuK76XTua8s5rWZkrsQxd45ZUk6+ycc1racvQNa67Zeit9du1TXq6frtbhlW5fgPcRwD/bZOuf6thH1FwXrmPKN8yLLpdqmUf4em8ch/xv3nV/X+zUfR7j5a+R1gsFvz2229o3rw5ws1mpG78GKmzVsJpTUfoqP4wPTUYfmEmSDodHA6HkPuIgp9z1cvvEd7ZR8iyZ0cENd9cvfPOO2jatCnatGmDtLQ0AP8tHLvdjrS0NAQFBeWHXBEl/QWn4HulKbjSFqXT6Uq9vqxgyOUdt6xp3S0HX43rbl4B98vQW+O6NhRXjpWZVyWyUcMydKnsMqzs+m0wGErdJis6r0plU533EQV/OYq0fpc2rouI+wjX/rXokSul9hG+mNfquI8o7XuP2r9H5NpkOJwysg/+ivPDpyLv+EkE970TERNGw3hNrQqPW3A+AHXvI4puk4BY+1kl9xGeNFaAAM3V6dOnceTIEbRt27bYe23btsXy5cvRpUuXCo9f8JdF0dfLmq4i71VmWo5b+ntF/wqnhpqq47iVrangf94c1x21javGmioybsGjj94ct7LviVZTVYxb0napdE3VedyKTuv6q3xp+9jK1OTLZZicnAyr1YrM7Dx8svlLtPvsMPxP70JO84bQr5gIv1vbwC8iQhX1Vmba8oxbNEe11ytCTQVpvrl67bXX8o9Yubz55psICAjA888/j6ZNmypUGRERERH50qFDh3Dyp6O47sAf6PvTaeQE+WFftxa40vJaGE7+iuZGO3r27Kl0mVSNqKq5ys7Oxr59+wAAFy5cQEZGBvbs2QMAaNeuHSIiIjB06FBcvHgRe/fuBQA0a9as2DgmkwlBQUFo3759peopT5dK6ubuMDBpB3MUB7MUB7MUh9aylO12tEpMRtO130DOycXPndrg+PUmOCKbYFCPWxAc6Aez2ax0mVVOazmKRlXNlcViwbPPPlvoNde/161bh/bt25d48ZwvscHSPmYoBuYoDmYpDmYpDq1lmfXFYSRNSoDtrzMIHdgdEa+PQk6yBYm7PsC9PW7Bjc2r55lLWstRRKpqrurWrYs///zT7WfWr19f5jiefMZTnt4ZhNRLlmU4HA7o9XpmqWHMURzMUhzMUhxayTLvr39giVuIrC8OISC2JaL3Lod/y/8aqeDsdBj0OgQHev/u0VqhlRxFpqrmSm3Kc097Ujen01nq3WNIO5ijOJilOJilONScpcOSiuTZq5G29gMYrolG9OppCO7VpVADYTab0bx582p5KmBBas6xOmBzRURERESqJOfZYF35HlLmrgVkGZETR8P8+IOQ/IsfnYqIiODNK0hxbK6IiIiISFVkWUbW7m9geWMxbGcuwvTofQh/eQQMUeFKl0bkFpsrIiIiIlKN3GMnkRSXgJxvf0Lg7W0RvXY6/Js1VLosIo+wuXKDFwKKg+cei4E5ioNZioNZikPpLO2XLUiesRzpmz6BsXE91No0G0HdOvD7WDkpnWN1x+aqDNygtU+SJO5oBMAcxcEsxcEsxaFkls7sXFiXbEXKOxsg+RlR481nYRraG5KRX1PLi9uk8rjWloG3Ytc+WZbzc2SW2sUcxcEsxcEsxaFElrIsI2PnF0iesgT2S0kwP/4gwl8YBn1YaJX8fBFxm1Qemys3eCt2cdjtdj6xXADMURzMUhzMUhxVmWXOjyeQNDEBuUeOI6h7Z8Rsnwe/RvWq5GeLjtuksthcEREREVGVsF+4DMu0pcjYvhd+NzRCzI63EXTrLUqXReQ1bK6IiIiIyKecGVlITdiE1EVboAsJRtS8lxH6UE9IvD6IBMPmioiIiIh8QnY6kb51D5KnL4MzNR3mJwYg/Lkh0IUEKV0akU+wuXKDFwKKg1mKgTmKg1mKg1mKw9tZZh/8BUkT45H3618I7t0VkXFPwFgvxqs/g4rjNqksNldl4AqqfZIk8cJOATBHcTBLcTBLcXgzS9vpC7BMXozMj/fB/+ZmqP3RQgS2v8krY5N73CaVx+aKiIiIiCrNkZaB1PnrkLpsO/SRYai5aAJCHrwLkk6ndGlEVYbNVRn4nCvtk2UZdrsdBoOBWWoYcxQHsxQHsxRHZbKU7XakbfgIybNWQs7KQfi4IQh7cjB0QQE+qpZKw21SeWyu3OBzrsTBLMXAHMXBLMXBLMVRkSyzvvoeSXEJsP1xGqEDuyPi9VEwxET5oDryFLdJZbG5IiIiIqJyyTt5Bpa4BGR9fggB7W9Czb3LEdDqeqXLIlIcmysiIiIi8ogj2YqUOathXb0Thro1Eb1yCoLvu52noBH9PzZXREREROSWnGeDddX7SHlrDWS7AxGvj4R5ZD/oAvyVLo1IVdhcucG/woiDtyUVA3MUB7MUB7MUR0lZyrKMrE8PwDJpIWz/XITpkXsR/soIGGpGKFAheYLbpLLYXJWBDZb2MUMxMEdxMEtxMEtxlJRl7om/YZkYj+xvfkLgbW0QvXoa/Js3UqA68hS3SeWxuSoDb8WufbIsw+FwQK/XM0sNY47iYJbiYJbiKJil42oKkmeuQPrGj2FsWBe1Ns5E0F0dmbEGcJtUHpsrN3grS3E4nU7o9Xqly6BKYo7iYJbiYJbicGTlIH31+0h5ewMkgx6RU5+G+bE+kIz8uqgl3CaVxa2FiIiIqBqTZRkZH3wJy5QlcPx7FebhDyD8xWHQh5uULo1Ic9hcEREREVVTOT//DsuEeOR8fwwB3TogZutc+F93rdJlEWkWmysiIiKiasZ+8Qos05chY9un8GveELXenQdjx5a80xxRJbG5coMXAoqD5x6LgTmKg1mKg1lqizMzG6kLNyM1YROk4EBEvfUSQh/uBeh0cDqdSpdHXsBtUllsrsrABkv7JEnijkYAzFEczFIczFI7ZKcTGe9+Bsv0ZXBYUhE2egDCnnsEelNI/meYpfZxm1Qem6sy8Fbs2ifLcn6OzFK7mKM4mKU4mKU2ZB/6FZaJ8cj95Q8E338HIuOegPHa2oU+wyzFwByVx+bKDd6KXRx2u53nkQuAOYqDWYqDWaqX7cxFWCYvRuaur+Hfsilqf5iAwNiWpX6eWYqBOSqLzRURERGRQJzpmUiZvx6pS7dBH2FGzYTXEdL/bkg6ndKlEQmPzRURERGRAGSHA+kbP0byzBVwZmQh/NlHEDZ2MHTBgUqXRlRtsLkiIiIi0risfT/AEhePvN9OIaT/3YicMBqG2jWVLouo2mFz5QYvBBQHsxQDcxQHsxQHs1RW3t9nYZm0EFmfHURA2xtR59OlCGjdvEJjMUsxMEdlsbkqA1dQ7ZMkiRd2CoA5ioNZioNZKseRkoaUuWtgXbUDhpgoRC+fjODed1T4ewuzFANzVB6bKyIiIiKNkG12WFfvRMqcVZBtdkSMfxzm0f2hC/BXujQiApurMvE5V9onyzLsdjsMBgOz1DDmKA5mKQ5mWXVkWUbW3oOwTFoEW+I5hD7cCxHjH4chOtJr4zNL7WOOymNz5QafcyUOZikG5igOZikOZul7ub8lwhKXgOx9PyDw1taIXj4Z/jc29vrPYZZiYI7KYnNFREREpEL2qylImbUSaet3wVi/Nmqtn4GgezrxiASRirG5IiIiIlIROTcPqcveRer89YBOQuTksTAP7wvJjzcqIFI7NldEREREKiDLMjJ3fQ3LlMWwn78C82N9EP7SY9BHmJUujYg8xObKDR52F4fBwFVdBMxRHMxSHMzSO3KP/omkCfHIOXQUQd06IGbTbPg1qV+lNTBLMTBHZalq6Z85cwYrV67E0aNHcfLkSTRs2BAfffSR22muXLmCNWvW4MCBAzh79ixCQ0PRtm1bPP/886hTp06la2KDpX2SJDFHATBHcTBLcTDLyrP/exWWacuQsW0PjNc3QMy2txB0R7sqr4NZioE5Kk9VzdXJkyexb98+tGzZEk6n06O7nZw4cQJ79+7Fgw8+iJYtWyIlJQWLFy9G//798dFHHyEiIqJSNfFW7NonyzKcTid0Oh2z1DDmKA5mKQ5mWXHOrBykLtqM1PhNkAL9UWPOCzA9ci8khY46MEsxMEflqaq56tq1K7p16wYAGD9+PI4fP17mNLfccgt2795d6BBo69atcfvtt2Pnzp0YPnx4hevhrSzF4XA4oNPplC6DKok5ioNZioNZlo/sdCLjvb2wTFsGR1IKwkb1Q9i4R6E3hShdGrMUBHNUlqqaq4qsCCaTqdhrtWrVQkREBK5cueKNsoiIiIgqLef7Y0iaEI/cn39H8L23ITJuDIwNKn8JAxGph6qaK285ffo0LBYLGjVqVOmxSjp6JUlSqUe1XIdg3b3vq2k5bsnvybJc6DU11FRdx61sTUWz9Na4vqrXF+OqsabyjlswRy3Uq+WafD1u0e2Sy7DkaW1n/0Xy1CXI/OAr+N3UBLV3LkBAx1YlTq/UMnRNV9r3nsrUpOZsqnLcqqippG1SzfVqvaaSCNdcybKMadOmoWbNmujVq1elx7PZbIXOWdXpdPmnINpstmKf9/PzA/DfIVmn01noPYPBAEmS4HQ64XA4Cr3nGleW5RLHNRqNpY6r1+uh1+shyzLsdnuh9yRJyp/WbrcXWzl8Na4n8woUX4a+GNdVv9FohCRJ5Z7XsjJXYhm6xi2pJl9l45rX0paha1x3y9Bb67drm/R0/Xa3DKty/Qa4jwAKf4FTwz6i4LxyH1G+ZVh0u1TLPsLTefX1PsKeloGUt9cjffl26MJMiJj3EkIGdofRz6/UeVVqH6HT6fKnLfi9h98jCs+r2vcRBT/nqpffI7yzj5Blz+7DIFxzFR8fj0OHDmHFihUICgqq1FgFf1GUxLXAS1JwpS1Kp9OVegpkwZDLO25Z07q7NaevxnU3r4D7ZeitcWVZLnRhZ2XmVYls1LAMXSq7DCu7fvv5+UGv15e4TVZ0XpXKpjrvI2RZzv+FLNL6Xdq4LiLuI1z7V9d2qfQ+whfzWpFxZYcDaRs/RvKMFXCmZyBs7EMIe2owdCGFv5eobR/heq+07z3V9XuEixb2EUW3SUCsZajkPsKTxgoQrLnatm0bFi5ciOnTpyM2NtYrY7rbebnj7n1fTctxS35PkqRCOaqhpuo6bmWmLWsnrrZ5VeMyVMu4RbdJb43rjfeUmlar45aWpYjz6un7Wd/8CMvEBOSd+Bsh/e5C5ITRMNSJrrJ6KzOtuy+elRlXLdkoPW5V1FTSNqnmekWpqSBhmqu9e/fijTfewDPPPIN+/fp5bVxPDwGSehU8xMsstYs5ioNZioNZ/k9e4jlY3liErD3fwr/tjaizZwkCbrlB6bI8xizFwByVJ0RzdfjwYTz//PPo378/xo4d67Vxy3PxGqmbzWYr8y9ypH7MURzMUhzVPUtHajpS5q6GdeUOGGrVQM1lkxDS505NfrGt7lmKgjkqS1XNVXZ2Nvbt2wcAuHDhAjIyMrBnzx4AQLt27RAREYGhQ4fi4sWL2Lt3LwAgMTERY8eORf369dG7d2/88ssv+eNFRESgXr16VT4fREREJDbZZkfa2g+QPHsV5DwbIl4eDvMTA6EL9Fe6NCJSkKqaK4vFgmeffbbQa65/r1u3Du3bty92Z5KjR48iPT0d6enpGDx4cKFp+/bti5kzZ/q+cCIiIqoWZFlG1ueHYJm0ELa/zyL0oZ6IeHUkDNGRSpdGRCogyTz3rUTHjh2DLMto0aKFJg/t0/+4btvp7s6PpH7MURzMUhzVLcu8P04jaWI8sr8+goBON6PG1Kfh3+I6pcvyiuqWpaiYo+8cO3YMANCiRQu3n1PVkSu14UopDmYpBuYoDmYpjuqQpSMpBcmzViJt3S4Yr62NWmunI6jHrcLNu2jzU10xR2WxuSoDV1DtkyT3zzUgbWCO4mCW4hApy+TkZBw6dAgdOnRAREQEAEDOzYN1xXtIeWstIEmIfGMMzCMehOQnxjwXJFKW1RlzVB6bKyIiIqr2rFYrfvvtNzRr1gzh4eHI/Hg/LJMXw37uEkxDeyPi5cegjwxTukwiUjk2V2Xgc660T5Zl2O12GAwGZqlhzFEczFIcWs8yOzsb2dnZAIDLVy2w2eywfPcLdE/Nhv374/C/vQ1iNsyAX9MGClfqe1rPkv7DHJXH5soN3utDHMxSDMxRHMxSHFrO8rfffsPx48fhcDhx5a/zaH3gGML++BjWmmE4/fg9qNuvB+pWg8bKRctZ0v8wR2WxuSIiIqJqS2ezI/rzX9Bx3zE4DDp82/kG5NzVGoHB/qirdHFEpDlsroiIiKjakWUZ9f+6hPAFH0G+moLjt7TE0RvDkBfdAqPu74yQID8EBgYqXSYRaQybKyIiIqpWco4cR9LEeOT++BuCe3VBZNwYZOdk4vddH+CBe1qgXt1aSpdIRBrF5soNXggoDoOBq7oImKM4mKU4tJSl7dwlJE9dgoz3v4Dfjdeh9s4FCOx0MwAg+PRpGPQ6BAf6KVylcrSUJZWOOSqLS78MbLC0T5Ik5igA5igOZikOrWTpzMhCyoKNsC7eAp0pBFFvj0fooO6Q9Pr8z5jNZjRv3hxms1nBSpWjlSzJPeaoPDZXZeCt2LVPlmU4nU7odDpmqWHMURzMUhxqz1J2OJC+ZQ+S31wGZ1oGzGMGIfyZh6ELCSr22YiICPTs2VOBKtVB7VmSZ5ij8thcucFbWYrD4XBAp9MpXQZVEnMUB7MUh1qzzD7wM5ImxCPv+EmE9L0TEROfgPEaXkvljlqzpPJhjspic0VERETCsJ06D8vkRcj85Bv439IcdT5ZjIC2NypdFhFVE2yuiIiISPMc1nSkzFsH6/LtMNSMQM0lcQh5oBtPjSKiKsXmioiIiDRLttuRtm4XkmevhJydh4gXhsE8ZiB0QQFKl0ZE1RCbKzf41y5x8NxjMTBHcTBLcSiZZdYXh5E0KQG2v84gdFAPRLw2EoZaNRSrR+u4XYqBOSqLzVUZ2GBpnyRJfOaDAJijOJilOJTKMu/P00iKW4jsLw8jILYlovcuh3/LplVeh0i4XYqBOSqPS78MvBW79hW86yOz1C7mKA5mKY6qztJhSUXy7NVIW/sBDNdEI3r1NAT36sL1yAu4XYqBOSqPzZUbvBW7OGw2G4xGo9JlUCUxR3EwS3FURZZyng3Wle8hZe5aQJYROXE0zI8/CMnfz6c/t7rhdikG5qgsNldERESkSrIsI2v3N7C8sRi2MxdhGno/Il4eDn2NcKVLIyIqEZsrIiIiUp3cYyeRNDEeOQd+RuDtbRG9djr8mzVUuiwiIrfYXBEREZFq2C8lIXnGCqRv/gTGxvVQa9NsBHXrwOtHiEgT2FwRERGR4pzZubAu2YqUtzdA8jeixpvPwjS0NyQjv6oQkXZwj+WGJEn8S5kAJEmC0WhklhrHHMXBLMXhjSxlWUbGzi+QPGUJ7JeSYH78QYS/MAz6sFAvVkpl4XYpBuaoPDZXVC1wJyMG5igOZimOymSZ8+MJJE1MQO6R4wjq0Rkx2+fDr9E1XqyOyoPbpRiYo7LYXJWBz7nSPlmW4XA4oNfrmaWGMUdxMEtxVDRL+4XLsExdioz39sLvhkaI2fE2gm69xYeVUlm4XYqBOSqPzZUbfM6VOJxOJ/R6vdJlUCUxR3EwS3GUJ0tnRhZS4zchddFm6EJDEDXvZYQ+1BMS1wVV4HYpBuaoLDZXRERE5FOy04n0rXuQPH0ZnKnpMD8xAOHPDYEuJEjp0oiIvIrNFREREflM9sFfkDQxHnm//oWQPl0RMfEJGOvFKF0WEZFPsLkiIiIir7OdvgDL5MXI/Hgf/Fs3Q52PFyGgXQulyyIi8ik2V27wQkBx8NxjMTBHcTBLcRTN0pGWgZR5a2Fd/h70NcJRc9EEhDx4FySdTqEKyVPcLsXAHJXF5qoMbLC0T5Ik7mgEwBzFwSzFUTBL2W5H2oaPkDxrJeSsHISPG4KwJwdDFxSgcJXkCW6XYmCOymNzVQbeil37ZFnOz5FZahdzFAezFIcry+yvj8AyaSFsf5xG6MDuiHh9FAwxUUqXR+XA7VIMzFF5bK7c4K3YxWG322E0GpUugyqJOYqDWYoh7+QZJE1MQM6XhxHQ/ibU3LscAa2uV7osqiBul2Jgjspic0VERETl4ki2Inn2KqSt+QD6OjVRc+UUhNx3O/9STkTVHpsrIiIi8oicZ4N11Q6kzF0D2eFExGsjETSsN/xCg9lYERGBzRURERGVQZZlZH164L/rqv65CNOQ+xD+ygjoa4TBZrMpXR4RkWqwuXKDf4UTh463ABYCcxQHs9SO3ON/wxIXj+xvfkLg7W0RvXoa/Js3AvBf08UsxcEsxcAclcXmqgxssLRPkiQYDFzVtY45ioNZaoP9SjKSZyxH+saPYWx0DWptnIWgu2IL/V5kluJglmJgjsrj0iciIqJ8zpxcWJe+i5S310My6BE57RmYH+sDycivDEREZeGe0o2Czwog7ZJlGTabDUajkVlqGHMUB7NUJ1mWkfnBV7BMXQL7xSswD38A4S8Ogz7c5HYaZikGZikG5qg8VTVXZ86cwcqVK3H06FGcPHkSDRs2xEcffVTmdLIsY/ny5di0aROSk5PRrFkzvPrqq2jVqpXviyYiItK4nJ9/h2VCPHK+P4agezohZutc+DWup3RZRESao6or3k6ePIl9+/bh2muvRaNGjTyebvny5ViwYAGGDRuGpUuXIioqCsOHD8e5c+d8WC0REZG22S9eweUnp+LC3aPgzMhEzPb5iNkwk40VEVEFqaq56tq1K/bt24cFCxbghhtu8Gia3NxcLF26FMOHD8ewYcMQGxuLefPmISwsDCtXrvRxxURERNrjzMxG8qyVONvhIWR/fQRRb72Eul+uQtBtbZQujYhI01R1WmBFbh35008/ISMjAz169Mh/zc/PD3fddRf27t3rzfKIiIg0TXY6kfHuZ7BMWwpHshVhowcgfNwQ6EKDlS6NiEgIFWqu/vjjD/z4449ITExESkoKJElCeHg4GjZsiNatW6NZs2berrNUp06dAgA0bNiw0OuNGjXC2rVrkZOTg4CAgAqNzQsBxWE0GpUugbyAOYqDWVa97EO/wjIxHrm//IHg++9AZNwTMF5bu9LjMktxMEsxMEdledxcWSwWbNq0CTt37sTFixchyzKMRiPMZjNkWUZaWhpsNhskSUJMTAz69u2LwYMHo0aNGr6sH2lpafDz84O/v3+h100mE2RZhtVqrXBz5SLLcqF/S5JU7LWC75U0TVVMy3GZjdrHrey0LgU/p9Z5VeMy5LjVMxvbmYtInrIEmbu+hn+r61H7wwQExrb0er0F764r2jLU0rjeqKmk7z3eGNdX9Wpl3KquybVNaqVeLdZUEo+aqzlz5mDTpk0IDg5G9+7d0bFjR9xwww2Ijo4u9LnLly/jxIkTOHDgALZt24ZVq1bhkUcewQsvvOBxQWoiyzLy8vIKfbHT6XT5D2ez2WzFpvHz8wMAOBwOOJ3OQu8ZDAZIkgSn0wmHw1HoPde4rltoFuX6K0RJ4+r1euj1esiyDLvdXug9SZLyp7Xb7cVWDl+N68m8AsWXoS/GlWUZTqcT/v7+0Ol05Z7XsjJXYhm6xi2pJl9l45pXSZLcrt/ulmFl1m+n04m8vDzodLr8bdLT9dvdMqzK9RvgPgL43y98o9Goin1EwXktbf3W4j5CyspB8ry1sC7bDn2ECRFvv4KgB7tB9//7joqMW3ReXftX13ap5D6iMus39xF66HS6/EwLfu/h94jC86r2fUTBbdJVL79HeGcfUXTbKI1HzdUPP/yAOXPm4M4773Q7aHR0NKKjo9G1a1dMmDABX3zxBVasWOHJj6gwk8mEvLw85ObmFjp6lZaWBkmSYDabKzW+u+cEuDvsWnClLUqn05V6fVnBkMs7blnTuntit6/GdTevgPtl6K1xXRuiK8fKzKsS2ahhGbpUdhlWdv0u+MuiqIrOq1LZVOd9RMFfjiKt36WN61JV+wjZ4UD6ho+QMmslnBlZCHvmYYSNHQxdcGClxi3KaDTmZ+naLpXeR/hifalO+whZlt1+76mu3yNctLCPKLpNAmItQyX3EZ40VoCHzdXWrVs9GqwgSZLQrVs3dOvWrdzTlofrWqvTp0/j+uuvz3/91KlTqF27dqVPCSz4y6Lo62VNV5H3KjMtxy39vaJ/hVNDTdVx3MrWVPA/b47rjtrGVWNNFRm34NFHb45b2fe0XlPWvh9giYtH3m+nEDLgHkS+PgqG2jV9Wm9J26WWl6HWx63otK6/ype2j61MTVpbhmrLprzjFs1R7fWKUFNBqrpbYEW0bt0aISEh2L17d35zZbPZ8Nlnn6FLly4KV0dEROR7eX+fhWXSQmR9dhAB7VqgzqdLEdC6udJlERFVO6pqrrKzs7Fv3z4AwIULF5CRkYE9e/YAANq1a4eIiAgMHToUFy9ezL/Nur+/P0aPHo34+HhERESgSZMm2Lx5M1JTUzFixAjF5oWIiMjXHClpSJmzGtbV78MQE4Xo5ZMR3PuOcv2VlYiIvKdczdXff/+NZcuWITExEeHh4ejVqxf69OlTbCf+4Ycf4pVXXsHvv/9ermIsFgueffbZQq+5/r1u3Tq0b9++xIvnRo4cCVmWsWrVKiQnJ6NZs2ZYuXIlrrnmmnL9/KL4y0kcpZ1/S9rCHMXBLCtHttlhXb0TKXNWQbY7EDH+cZhH94cuwL/sib2MWYqDWYqBOSpLkj28t+A///yDvn37wuFwoHHjxrBYLLh8+TJat26Nd955B1FRUfmfrWhzpSbHjh0DALRo0ULhSoiIiP4jyzKy9h6EZdIi2E6dR+jDvRAx/nEYakYoXRoRkdA87Q08PnL19ttvIzg4GBs3bsS1114LAPjggw8wdepUDBw4ECtWrCj2IF8ReHrbRVIv161J3V2kS+rHHMXBLCsm97dEWOISkL3vBwR2uQXRKybD/4bGitbELMXBLMXAHJVX+v0Tizh69CgeeeSR/MYKAHr37o2tW7dCp9PhoYcewq+//uqTIpVSngeGkboVfa4BaRNzFAez9Jz9agquvjAH5+8YDvu5S6i1fgZits9XvLFyYZbiYJZiYI7K8ri5Sk1NRY0aNYq93qhRI2zZsgW1atXC0KFD8c0333i1QCIioupIzs1DSvxGnG03CBkffInIyWNxzTfrENy9M/8iTUSkUh6fFlinTh38+eefJb5Xo0YNbNiwAaNHj8aYMWN4C3QiIqIKkmUZmbu+hmXKYtjPX4H5sT4If+kx6CPMSpdGRERl8PjIVbt27bBnz55SDzWGhIRg9erVuPXWW/Hll196rUAiIqLqIueXP3Dx/qdxeUQc/JrUxzXfrEWNGc+xsSIi0giPj1z17dsXSUlJOH78OFq1alXiZ/z8/LBw4ULMmDEDf/zxh7dqVAxPuxAHsxQDcxQHsyzM/u9VWKYtQ8a2PTBe3wAx295C0B3tlC7LI8xSHMxSDMxRWR7fir264a3YiYjI15xZOUhduBmpCZsgBQUg4pURMD1yLyRDuR5DSUREPub1W7ETERGRd8hOJzLe2wvL1KVwWFIRNqofwsY9Cr0pROnSiIioEircXGVnZyMwMNCbtagSn3OlfbIsw263w2AwMEsNY47iqO5ZZh/+FZaJCcj9+XcE33sbIuPGwNigjtJlVUh1z1IkzFIMzFF5Ht/QoqCkpCQ8/PDD3q5FdXjGpDiYpRiYoziqY5a2s//i0uOTcPHesZAdDtT+IB61Vk/TbGPlUh2zFBWzFANzVFa5j1ydPn0ajz/+eInPvCIiIqLCnOmZSHl7PaxL34UuLBRRC15F6MDukHQV+vsmERGpWLmaqx9//BFPPvkkrr32WqxcudJXNREREWlKdnY2fvvtNwBA8+bNERgYCNnhQPqmj5E8YwWc6ZkIe2owwp56CLqQIIWrJSIiX/G4udqzZw9efvllNGnSBCtXrkRICC+6JSIiAv5rro4fPw4AaNCgAeQffoNlYjzyTiQipN9diJwwGoY60QpXSUREvuZxczVu3Dg0b94cq1evRmhoqC9rUg1eCCgOA29rLATmKA7RsszIykNWjg1hqRnIGDMdKV9+D/+2N6LOniUIuOUGpcvzKdGyrM6YpRiYo7I8XvoBAQFISkpCampqtWmuADZYIpAkiTkKgDmKQ5Qsk5OTYbVakZmdhx07j6DF5/tx44l/kBMZBsP0JxH44N0IiIxUukyfEiVLYpaiYI7K8/hq2o0bN8LhcODRRx/F+fPnfVmTqvCOK9onyzIcDgez1DjmKA5Rsjx06BB2bHsXf0x+Gw8uWoVmf5zF0bYNsXNwB+xIu4DDhw8rXaLPiZIlMUtRMEfleXzkqnnz5ti6dStGjhyJIUOGYMOGDahTR9u3jy0LV0xxOBwO6HhnLs1jjuLQepayLOOWXAOabv8B8plLOHlTcxy6qRYQEYIed9+O6KhImM1mpcusElrPkv6HWYqBOSqrXEu+Tp062LJlC2rXro0hQ4b4qiYiIiLVyv39FP4d8AIyRk1FQN0YXPPFStyw5g3UaloX19aORJPGDdGgQQNEREQoXSoREVWxcre1JpMJq1evRsuWLX1RDxERkSo5klJw9aW5OH/7Y7Cf+Re11r2J2jvehn+L6xAS5IegACP0ev61mIioOqvQ7UT8/Pwwf/58b9dCRESkOnJuHlKXb0fqvHWAJCHyjTEwj3gQkp8x/zOBgYG48cYb8/+fiIiqJ96r0Q3ebUUcer1e6RLIC5ijOLSQpSzLyPxoHyxTFsN+7jJMQ3sj4uXHoI8MK/bZwMBA3HLLLVVfpApoIUvyDLMUA3NUllebq3PnziEvLw+NGjXy5rCKYoOlfZIkcUcjAOYoDi1kmXv0TyRNjEfOd0cRdGcHxGyYCb+mDZQuS3W0kCV5hlmKgTkqr0LN1bp16/Dzzz8XOjXw1Vdfxc6dOwEAzZo1w/LlyxEpwPM9ZFlmg6VxBe/6yCy1izmKQ81Z2i8lIXn6MqRv3QNjk2sRs3Uugrq2V7os1VJzllQ+zFIMzFF5Fbry9t133y3UOH3zzTd4//33MWDAAEyYMAHnz59HQkKC14pUCm/FLg6bzaZ0CeQFzFEcasvSmZWD5LfW4Gz7h5D52UHUmDUO13y9mo2VB9SWJVUcsxQDc1RWhY5cXbx4sdCpf7t370bdunUxefJkAEBSUhI++OAD71RIRETkI7IsI2PH50ieugT2K8kwj+yH8Ocfhd4cqnRpRESkQRVqrooe0Tlw4ADuvPPO/H/XqVMHSUlJlauMiIjIh3KOHEfSxHjk/vgbgnt1Qe24MTA2rKt0WUREpGEVOi2wfv36+PzzzwH8d0rglStX0KVLl/z3L126BJPJ5J0KiYiIvMh27hIuj3oDF3qOgZxnQ+2dC1BrzXQ2VkREVGkVOnI1YsQIvPDCC2jbti2ys7PRqFEjdO7cOf/9w4cP4/rrr/dakUrhhYDiYJZiYI7iUCJLZ0YWUt7ZAOuSrdCZQhD1zniEDuwOiXfWqhRul+JglmJgjsqqUHPVq1cvhIWFYd++fTCZTHjooYdgMPw3VGpqKsxmM3r37u3VQpXCFVT7JEmC0Wgs+4OkasxRHFWdpexwIH3LHiS/uQzOtAyYxwxC+DMPQxcSVGU1iIrbpTiYpRiYo/IkmbfEK9GxY8cAAC1atFC4EiIiqqjsAz8jaUI88o6fRMgD3RAx8QkY60YrXRYREWmMp72BVx8iLCI+50r7ZFmG3W6HwWBglhrGHMVRFVnaTp2HZfIiZH7yDfxvaY46u5cgoM0NPvlZ1Rm3S3EwSzEwR+V5dEOLnj17YufOncjLy/N44Ly8PLz33nvo2bNnhYtTGg/qiYNZioE5isNXWTqs6UiKS8DZzkOQe/RP1Fw6iY2Vj3G7FAezFANzVJZHR6769u2LGTNmYPr06ejatStiY2Nxww03oG7duggMDAQAZGVl4fz58zh+/DgOHjyIr776CkajESNGjPDpDBAREcl2O9LW7ULyrJWQc/IQ8cIwmJ8cBF2gv9KlERFRNeJRczVy5EgMHjwY27dvx/vvv48PPvgg/1Cj/v/vsuRwOAD81y1fd911ePrpp9GvXz+EhIT4qHQiIiIg64vDSJqUANtfZxA6qAciXhsJQ60aSpdFRETVkMfXXIWEhGDYsGEYNmwYzp8/j59//hmnTp1CamoqACAsLAwNGzZEq1atcM011/iqXiIiIgBA3p+nkRS3ENlfHkZAx1aI3jsB/i2bKl0WERFVYxW6oUXdunVRt674D1vkhYDicD0qgLSNOYqjMlk6LKlInrUKaes+hOGaaESvnobgXl24z1YIt0txMEsxMEdlcemXgb+stU+SJOYoAOYojopmKefZYF3xHlLeWgvIMiInjob58Qch+fv5oEryBLdLcTBLMTBH5bG5KgNvxa59sizD6XRCp9MxSw1jjuIob5ayLCNr9zdImrQI9rP/wjT0fkS8PBz6GuFVUC25w+1SHMxSDMxReWyu3OCtLMXhcDig03n05AFSMeYoDk+zzD12EkkT45Fz4GcE3tEOMetnwO/6BlVQIXmK26U4mKUYmKOy2FwREZHq2C8lIXnGCqRv/gTG6+qh1uY5CO7WQemyiIiI3GJzRUREquHMzoV18VakvLMBkr8RNd58FqahvSEZ+euKiIjUT3W/rRITEzFt2jT8/PPPCA4ORu/evfHcc8/Bz8/9BcspKSmYP38+9u/fj9TUVNStWxcPP/wwBg8eXEWVExFRRcmyjIydXyB5yhLYLyXB/PiDCH9hGPRhoUqXRkRE5DGfNFc5OTlITk5G7dq1yzWd1WrF0KFDUb9+fcTHx+Py5cuYOXMmcnJyEBcX53baZ599FqdOncLzzz+PmJgY7N+/H2+88Qb0ej0GDBhQofnghYDi4LnHYmCO4iiYZc6PJ5A0MQG5R44jqEdnxGyfD79GfF6iVnC7FAezFANzVFa5mqvvvvsOCQkJSExMRHh4OHr16oURI0YgMDCw0Oc+++wzvPLKK/j999/LVcyWLVuQmZmJhIQEhIWFAfjvorzJkydj9OjRiI6OLnG6q1ev4vDhw5gxYwYeeOABAEBsbCyOHTuGjz/+uMLNFcAGSwSSJPGZDwJgjuJwZWk7fxnJ05Yi47298LuhMWJ2vI2gW29RujwqB26X4mCWYmCOyvO4tT1+/Dgef/xxnD59Gu3atUNYWBgWLlyIPn36IDEx0SvF7N+/H7GxsfmNFQD06NEDTqcTBw4cKHU6u90OAAgNLXz6SEhISKXv+Mc7BmqfLMv5/5F2MUdxONIzYZmxHOdiH0L2/h8RNe9l1P1iBRsrDeJ2KQ5mKQbmqDyPm6v4+HjUrVsXn3zyCRYsWIDNmzdj/fr1yMnJweDBg/HDDz9UuphTp06hYcOGhV4zmUyIiorCqVOnSp0uJiYGnTt3xpIlS/D3338jIyMDn3zyCQ4cOICHH364wvVwxRSHzWZTugTyAuaobbLTibRNH+Nc7MNIXbgZ5tEDUO/7zTANuQ+SXq90eVRB3C7FwSzFwByV5fFxwxMnTmD48OGFjiq1adMG77//PkaNGoURI0bgrbfeQrdu3SpcTFpaGkwmU7HXzWYzrFar22nj4+Mxbtw49OrVCwCg1+sxYcIE3HPPPRWuByi5wZIkqdTGy3Uaobv3fTUtxy35vaJ/wVFDTdV13MrWVNJf49Q6r2pdhkqNm/3dL7BMTEDer38huHdXhI4fjqBG9Ur9uUrXW9XTanXcotsll6Hy41Z0Wtd0pW2PlalJa8tQbdmUZ9yStkk116v1mkricXOVlZVV7LQ7AIiIiMD69evx1FNP4bnnnsOkSZPg7+/vcQHeIMsyXn31Vfzzzz946623EBUVhYMHD+LNN9+E2WzOb7gqwmazFbruSqfT5Z/LWtJfBlx3NXQ4HHA6nYXeMxgMkCQJTqcTDoej0HuucWVZLnFco9FY6rh6vR56vR6yLOefIukiSVL+tHa7vdjK4atxPZlXoPgy9MW4rvqNRiMkSSr3vJaVuRLL0DVuSTX5KhvXvJa2DF3juluG3lq/Xdukp+u3u2VYles3UP32EbbTF3D1jYXI/uQb+N18PWruXAC/Ns3zf44a9hEF55X7iPItw6LbpVr2EZ7OK/cR/5tXnU6XP23B7z38HlF4XtW+jyj4OVe9/B7hnX2ELMuFto3SeNxc1atXD7/++iv69+9f7L3AwEAsWbIEL7/8MuLi4tCqVStPhy3EZDIhPT292OtWqxVms7nU6b7++mvs2bMHH374IZo2bQoAaN++PSwWC2bOnFmp5sq1EpT2XmkKrrRF6XS6Uu/kUjDk8o5b1rTuLnD01bju5hVwvwy9NW7Rv6hWZl6VyEYNy9Clssuwsuu3wWAodZus6LwqlY3o+whnWgaS5i+Ddfl70NcIQ9SiCQh5oBukAl/gALHW79LGdRFxH+Hav7q2S6X3Eb6Y1+q4jyjte091/R7hooV9RNFtEhBrGSq5j/CksQLK0Vx17NgR7733Hl577bVidwcE/luA8+bNQ1hYGDZv3uxxAQU1bNiw2LVV6enpuHr1arFrsQr6+++/odfr0aRJk0KvN2vWDO+++y6ys7NLrNkTBX9ZFH29rOkq8l5lpuW4pb9X9K9waqipOo5b2ZoK/ufNcd1R27hqrKnge7LdjrT1u5A8ayXk7FyEjxuCsCcHQxcUUOI0Sterlmm1PG5J26XSNVXncSs6reuv8qXtYytTk9aWodqyKe+4RXNUe70i1FSQx81Vv379IMsyTp8+jebNm5f6gydNmoRrr70Wf/75p8dFuHTp0gVLliwpdO3Vnj17oNPp0KlTp1Knq1OnDhwOB/78809cf/31+a+fOHECkZGRXm+sSFtcf6lgltrGHNUv68vDSJq0ELY/TiN0YHdEvD4KhpioYp9jluJgluJglmJgjsqT5PJcoeVjVqsVvXr1QoMGDTB69Oj8hwjfd999hR4iPHToUFy8eBF79+4FAGRkZOC+++6D0WjE2LFjUbNmTXz77bdYtWoVnn76aTz55JPlruXYsWMAgBYtWnhn5oiIBJX31z+wTFqIrM8PIaBDS9SY9jT8WzZVuiwiIiKv8bQ3UNVTxsxmM9auXYupU6di7NixCA4ORr9+/TBu3LhCnyt6AV1ISAjWrFmD+fPnY+7cuUhPT0fdunUxfvx4PPLII5WqydOL10i9ZFmGw+GAXq9nlhrGHNXHkWxF8uxVSFvzAQx1ayJ61VQE33tbmfkwS3EwS3EwSzEwR+VV+MhVUlISatSo4e16VOPYsWOQZRktWrTgyqlxrovneZhc25ijesh5NlhX7UDK3DWQHU6EvzAUYSP7QfL382x6ZikMZikOZikG5ug7nh658vghwgUlJiZiwIABFZmUiIg0SpZlZO7+BudufRSWSYsQ0udO1Pt+C8KfesjjxoqIiEhk5T4t8IcffsDYsWNxyy23+KIeIiJSodzjf8MSF4/sb35C4O1tEb16GvybN1K6LCIiIlUpV3O1e/dujB8/HrGxsViwYIGvaiIiIpWwX7YgeeYKpG/8GMZG16DWxlkIuiuWp5sQERGVwOPmatWqVZgzZw5uu+02JCQkuH3Qlij45UEc1WF9rQ6YY9Vx5uTCumQbUt5eD8loQI3pz8A0rA8ko3cyYJbiYJbiYJZiYI7K8njpz549G23btkV8fHy1Co0NlvbxeWViYI5VQ5ZlZO78EpapS2D/9yrMwx9A+IvDoA83ee1nMEtxMEtxMEsxMEfledwl1ahRA3/88Qd+//133HTTTb6sSVV4K3btk2W50JPnSZuYo+/l/PQbLBPikXPkOILu6YSYbW/Br3E9r/8cZikOZikOZikG5qg8j+8WuG3bNtSsWRMjRozA8ePHfVmTaqjo+cpUSXa7XekSyAuYo2/YL17B5Sen4sI9o+HMzELM9vmI2TDTJ41V/s9klsJgluJglmJgjsryuLmqXbs2Nm/ejKZNm2L48OE4ceKEL+siIiIfc2ZmI3nWSpzt8BCyvz6CqHkvoe6XqxB0WxulSyMiItKkcj3nymQyYdWqVejUqROGDx/uq5qIiMiHZKcTaVt242yHh5CyYCPMj/dDvcObYRpyPyS9XunyiIiINKvcd6bw8/PD/PnzMXv2bF/UQ0REPpT93VFY4hKQ+8sfCL7/DkTGPQHjtbWVLouIiEgIFb7t38svv+zNOlSJFwKKQ6cr10FaUinmWHG2MxdhmbwYmbu+hn+r61F710IEdlDu5kTMUhzMUhzMUgzMUVkeN1dHjhxBo0aNEBER4ct6VIcNlvZJklStHh8gKuZYMc70TKTMX4fUpe9CHxmGmgtfR0i/uyEp+MuXWYqDWYqDWYqBOSrP49+ujz76KA4cOODLWoh8hnd+FANz9Jxst8O69gOcaTcI1hXvIfzZR1Dvu40IHdBd0cYqvz5mKQxmKQ5mKQbmqCyPW9vqGFTBZwWQdsmyDJvNBqPRyCw1jDl6LuvrI7DEJSDv91MIGXAPIl8fBUPtmkqXlY9ZioNZioNZioE5Ko/HDYmIBJH391lYJi1E1mcHEdCuBep8tgwBNzdTuiwiIqJqo1zNFTtgIiL1caSkIWXOalhXvw9D7ZqIXjEFwfffzn02ERFRFStXc/XSSy/hpZde8uizkiTht99+q1BRRERUNtlmh3XV+0iZuxqy3YGI8Y/DPLo/dAH+SpdGRERULZWruerYsSPq16/vo1KIiMgTsiwja+9BWOIWwnb6AkIf7oWI8Y/DULN63c2ViIhIbcrVXPXp0wf33Xefr2pRHZ5SIw6j0ah0CeQFzBHI/S0RlrgEZO/7AYFdbkH0yinwv6Gx0mWVG7MUB7MUB7MUA3NUFm9oUQY2WNrHDMVQ3XO0X0lGyqyVSNvwEYwN6qDWhpkIurujJpeLFmumkjFLcTBLMTBH5bG5KgNvxa59sizD4XBAr9czSw2rrjk6c3JhXbYdKfPXQdLrEDl5LMzD+0Ly0+5fJqtrliJiluJglmJgjspjc+VGdXy2l6icTif0er3SZVAlVaccZVlG5odfwzJ1Meznr8D8WB+Ev/QY9BFmpUvziuqUpeiYpTiYpRiYo7I8bq7++OMPX9ZBRET/L+eXP2CZEI+cw78i6K5YxGyeA7/rrlW6LCIiIioDj1wRESkoOTkZhw4dQocOHWDKdcAybRkytu2BX7OGiHl3HoJub6t0iUREROQhNldERAqyWq348+ivuP7bP5C6cTekoADUmPsiTA/3gmTgLpqIiEhL+JvbDV4IKA6eeywG0XKUnU7k7NyHbsu+gDPXjvDR/RE27lHoTSFKl+ZzomVZnTFLcTBLMTBHZbG5KgMbLO2TJIk7GgGIlGNycjJS9x+B460N8PvjH1xsWBNH7r4L9/a/A2mWqzDb8xARIe4DgUXKsrpjluJglmJgjspjc1UG3opd+2RZzs+RWWqXKDnazv6LM2MmwfT977BGm3GoTxsk1QmDQ76Kj3Z9AINeh+bNm6Nnz55Kl+ozomRJzFIkzFIMzFF5bK7c4K3YxWG32/nEcgFoOUdneiZS3l4P69J3YTYFA3EjEXBHW1z69GcgLREwNcK9PW5BcKAfzGYxbrfujpazpMKYpTiYpRiYo7LYXBER+ZDscCB908dInrECzowshD01GGFPPQRdSBAAYJBOh492nce9PW7Bjc2bKlwtERERVQabKyIiH8na/wMscQnIO5GIkH53IXLCaBjqRBf6THCgHwx6HYID/RSqkoiIiLyFzRURkZflJZ6F5Y3FyNrzLfzb3og6ny5FQOvmJX7WbDajefPm1eJUQCIiItGxuXKDFwKKg1mKQe05OlLTkTJ3Nawrd8AQE4XoZW8guE9Xt3VHREQIffOK0qg9S/IcsxQHsxQDc1QWm6sycAXVPkmSeGGnANSco2yzI23NTiTPWQ05z4aIV0bAPHoAdIH+SpemSmrOksqHWYqDWYqBOSqPzRURUQXJsoysvd/B8sYi2P4+i9CHeiLi1ZEwREcqXRoREREpgM1VGficK+2TZRl2ux0Gg4FZapjacsz9/RQscQnI/voIAjq3RvTSSfBvcZ3SZWmC2rKkimOW4mCWYmCOymNz5QafcyUOZikGNeToSEpB8qyVSFu3C8Zra6PWujcR1L0zf4mVkxqyJO9gluJglmJgjspic0VE5AE5Nw+py7cjdd46QCchcvKTMA9/AJIfz20nIiKi/7C5IiJyQ5ZlZH60D5Ypi2E/dxmmYb0R8dJj0EeGKV0aERERqQybKyKiUuQe/RNJE+OR891RBN3ZATEbZsKvaQOlyyIiIiKVYnPlBq+hEAdvSyqGqsrRfikJydOXIX3rHhibXIuYrXMR1LV9lfzs6oLbpDiYpTiYpRiYo7JU11wlJiZi2rRp+PnnnxEcHIzevXvjueeeg5+fX5nTXr58GfPmzcO+ffuQlZWFOnXqYMyYMbj//vsrXA8bLO1jhmKoihydWTlIXbwFqQs2QQr0Q41Z42Aach8kg+p2lZrGbVIczFIczFIMzFF5qvrGYLVaMXToUNSvXx/x8fG4fPkyZs6ciZycHMTFxbmd9sqVKxg4cCAaNGiAqVOnIiQkBCdPnkReXl6lauKt2LVPlmU4nU7odDpmqWG+zFF2OpGx43NYpi6F42oyzKP6IXzco9CbQ736c+g/3CbFwSzFwSzFwByVp6rmasuWLcjMzERCQgLCwsIAAA6HA5MnT8bo0aMRHR1d6rRz5sxBrVq1sGLFCuj1egBAbGxsperhrSzF4XA4oNPplC6DKskXOeYcOY6kCQuQ+9PvCO7VBZFxY2BsWNerP4OK4zYpDmYpDmYpBuaoLFUt+f379yM2Nja/sQKAHj16wOl04sCBA6VOl5GRgd27d+Ohhx7Kb6yIiNyxnbuEyyMn4ULPMZBtdtTeuQC11kxnY0VEREQVpqrm6tSpU2jYsGGh10wmE6KionDq1KlSpztx4gRsNhsMBgMeeeQR3HDDDejUqRPmzJkDm83m67KJSEOcGVmwTF+Gc7EPI/vgL4h6Zzzq7l2OwE43K10aERERaZyqTgtMS0uDyWQq9rrZbIbVai11uqSkJADAhAkTMGDAADz11FP49ddfsWDBAuh0OrzwwgsVrqmkUwMlSSr1lEHX+a3u3vfVtBy35PdkWS70mhpqqq7jVramolmWZ1zZ4UD6lt1ImbECzrQMmMcOQvjTD0MKDixxelGXoRrGLZijFurVck2+HrfodsllqPy4FZ3WNV1p33sqU5PWlqHasinPuCVtk2quV+s1lURVzVVFOZ1OAEDHjh0xfvx4AECHDh2QmZmJVatWYezYsQgICKjQ2DabrdAFgTqdDob/v3NYSUfFXHc1dDgc+XW5GAwGSJIEp9MJh8NR6D3XuLIslziu67aaJY2r1+uh1+shyzLsdnuh9yRJyp/WbrcXWzl8Na4n8woUX4a+GLfgjkaSpHLPa1mZK7EMXeOWVJOvsnHNa2nL0DWuu2VY2fXbNb1rm/R0/c7c/yOSJy2E7cTfCOrTFebXHod/vdrQ6fVwOp1Vtn4D3EcA/22TrusB1LCPKDiv3EeUbxkW3S6V3kdUdP12twyr8ncgoNw+QqfTQafTFfvew+8RhedV7fuIgtukq15+j/DOPsL1PbIsqmquTCYT0tPTi71utVphNpvdTgf811AVFBsbiyVLluDMmTNo2rRpueuRJMntLeDdPUeg4EpblGsHVtrPrOi4ZU3rWtmrclx38wq4X4beHte1QVRmXpXIRqRlWJn1W6fTwd/fv9RpS5pX26nzSJ6yGJmffAP/W25A7U8WI6DNDeWqyVfZcB/x33Qird+ljevCfcT/PuOLfYSvlmF12UdIkuR2XgB+j+A+ovLjankf4UljBaisuWrYsGGxa6vS09Nx9erVYtdiFdS4cWO34+bm5laqrpIWZlkL2N37vpqW45b8XtHD42qoqbqOW9lpXX81KmubdFjTkfLWWlhXvAdDzQjUXDoJIX3vrNJtWY3LUC3jlnQamTfG9cZ7otXk63ELnhVQ9GiHUjVV93ErOm1pWXqjJq0tQ7VlU55xS8pRzfWKUlNBqrqhRZcuXXDw4EGkpaXlv7Znzx7odDp06tSp1Onq1KmDJk2a4ODBg4VeP3jwIAICAspsvkpTnvMrSd2KHgYmbSorR9luh3XlDpxtNxhpaz9ExIuP4ZrvNiH0gW7l2jGS73GbFAezFAezFANzVJaqmqtBgwYhODgYY8eOxbfffov33nsPs2fPxqBBgwo942ro0KG46667Ck07btw4fPnll5g+fToOHDiAJUuWYNWqVRg2bBiCgoKqelaIqIplfn4I524bhqRX30bwPZ1Q7/AmhD//KHSBpZ9KSERERORNqjot0Gw2Y+3atZg6dSrGjh2L4OBg9OvXD+PGjSv0uZIuoOvatSvmzZuHRYsWYfPmzahZsyaefvppjBo1qipngYiqWN4fp5EUl4Dsr75HQMdWiF40Ef4ty3+NJREREVFlSTLPfSvRsWPHIMsyWrRowdOJNK7oXXNIm4rm6LCkInnWKqSt+xCGa2oh8o0nEdzzVmasAdwmxcEsxcEsxcAcfefYsWMAgBYtWrj9nKqOXKkNV0pxMEsxSJIEOc8G68odSHlrLQAgMu4JmEc8AMm/9Dt7kvpwmxQHsxQHsxQDc1QWm6sycAXVPklyf+tN0o7cz76D5Y1FsJ/9F6ah9yPi5eHQ1whXuiwqJ26T4mCW4mCWYmCOymNzRUSql/vrX0iKS0DOgZ8ReEc7xKyfAb/rGyhdFhEREVEhbK7K4OnTmEm9XE/kdj35m7TDfikJyTNWIH3zJzBeVw9RG2Yg9O5OzFHjuE2Kg1mKg1mKgTkqj82VG7zXhziYpbY4s3NhXbwVKe9sgBTghxoznkPokPtgB3MUBbdJcTBLcTBLMTBHZbG5IiLVkGUZGe9/geSpS2C/bIF5xAMIf2EY9GGh//2ysNmULpGIiIioVGyuiEgVcn44gaSJ8cj94QSCenRGzPb58Gt0jdJlEREREXmMzRURKcp2/jKSpy1Fxnt74XdDY8TseBtBt96idFlERERE5cbmyg1eCCgOg4Gruto4M7KQGr8JqYs2Qxcagqj5ryB0cA9Ien2p0zBHcTBLcTBLcTBLMTBHZXHpl4ENlvZJksQcVUR2OpG+ZTeS31wOZ2o6zGMGIvzZR6ALCXI7HXMUB7MUB7MUB7MUA3NUHpurMvBW7NonyzKcTid0Oh2zVFj2gZ+RNDEeecdOIqRPV0RMfALGejEeTcscxcEsxcEsxcEsxcAclcfmyg3eylIcDocDOp1O6TKqLdvpC7BMXozMj/fBv3Uz1Pl4EQLatSj3OMxRHMxSHMxSHMxSDMxRWWyuiMhnHGkZSJm3Ftbl70FfIxw1F09EyAPdIHGnT0RERAJic0VEXifb7UhbvwvJs1ZCzs5F+POPImzMIOiCApQujYiIiMhn2FwRkVdlfXkYSZMWwvbHaYQO7I6I10fBEBOldFlEREREPsfmyg1eCCgOnnvse3l//QNL3EJkfXEIAR1aIvrzFfBv2dSrP4M5ioNZioNZioNZioE5KovNVRnYYGmfJEl85oMPOZKtSJ69CmlrPoChbk1Er5qK4Htv8/q2wxzFwSzFwSzFwSzFwByVx6VfBt6KXfsK3vWRWXqPnGeDddUOpMxdAzhlREwYhbCR/SD5+/nm5zFHYTBLcTBLcTBLMTBH5bG5coO3YheHzWaD0WhUugwhyLKMrD3fwvLGItj+uQjTo/ch/OURMESF+/xnM0dxMEtxMEtxMEsxMEdlsbkiIo/lHv8blrh4ZH/zEwJvb4vo1dPg37yR0mURERERqQKbKyIqk/2yBckzliN90ycwNroGtTbOQtBdsTzlgIiIiKgANldEVCpnTi6sS7Yh5e31kPyMqDH9GZiG9YFk5K6DiIiIqCh+QyKiYmRZRubOL2GZugT2f6/CPOIBhL8wDPpwk9KlEREREakWmys3JEniaU8CkCQJfn6+uYOdiHJ++g2WCfHIOXIcQfd0Qsy7b8GvUT2ly2KOAmGW4mCW4mCWYmCOymNzRUQAAPuFy7BMW4qM7Xvhd0MjxLw3H0Fd2ihdFhEREZFmsLkqA59zpX2yLMPhcECv1zPLEjgzs5GasAmpCzdDFxKEqHkvIfShXpD0eqVLK4Q5ioNZioNZioNZioE5Ko/NlRt8zpU4nE4n9CprFpQmO51I3/YpkqcvgzMlDebR/RH+3BDoQoOVLq1UzFEczFIczFIczFIMzFFZbK6IqqHs747CMjEeuUf/RPD9dyAy7gkYr62tdFlEREREmsbmiqgasf1zEZbJi5D50T74t7oetXctRGCHm5Qui4iIiEgIbK6IqgFHWgZS316P1KXvQh8ZhpoLX0dIv7sh6XRKl0ZEREQkDDZXbvBCQHEYDNVzVZftdqRt/BjJM1dAzspB+HNDEPbkIOiCA5UurUKqa44iYpbiYJbiYJZiYI7K4tIvAxss7auuzyvL+voILHEJyPv9FEIGdEfkhFEwxEQpXVaFVdccRcQsxcEsxcEsxcAclcfmqgy8Fbv2ybIMp9MJnU5XLbLMO3kGlkkLkbX3OwS0a4E6ny1DwM3NlC6r0qpbjiJjluJgluJglmJgjspjc+UGb8UuDofDAZ3g1xc5UtKQMmc1rKvfh6F2TUSvmILg+28XaudaHXKsLpilOJilOJilGJijsthcEWmcbLPDuup9pMxdDdnuQMSrI2Ee1Q+6AH+lSyMiIiKqVthcEWmULMvI+uwgLJMWwnb6AkyP3IvwV0bAUDNC6dKIiIiIqiU2V0QalHvib1jiEpC9/0cEdrkF0SunwP+GxkqXRURERFStsblyQ6RrVao7Uc49tl9JRvLMFUjf+DGMDeqg1oaZCLq7Y7VZV0XJkZilSJilOJilGJijsthclaG6fGkVmSRJmn/mgzMnF9Zl25Eyfx0kgx6RU56C+bE+kPyMSpdWZUTIkf7DLMXBLMXBLMXAHJXHpU/VglZvqS/LMjI//BqWKYthv3gF5sf6Ivylx6APNyldmiK0miMVxyzFwSzFwSzFwByVxebKDVmWuYIKQJZl2Gw2GI1GTWWZ88sfsEyIR87hXxF0VyxitsyB33XXKl2WYrSaIxXHLMXBLMXBLMXAHJWnupMyExMT8dhjj6FVq1bo1KkTZs+ejby8vHKNsWbNGjRt2hSjR4/2UZVEvmP/9youj52OC3eNhDMtAzHvzkPMptnVurEiIiIi0gJVHbmyWq0YOnQo6tevj/j4eFy+fBkzZ85ETk4O4uLiPBrj6tWrWLhwISIjI31cLZF3OTOzkbpoC1ITNkEKCkCNuS/C9HAvSDx3moiIiEgTVPWtbcuWLcjMzERCQgLCwsIA/PeU6cmTJ2P06NGIjo4uc4w5c+aga9euuHjxoo+rJfIO2elExvbPYJm2DA5LKsJG90fYc0OgN4UoXRoRERERlYOqTgvcv38/YmNj8xsrAOjRowecTicOHDhQ5vQ//PADPv/8c7zwwgs+rJLIe7IP/4oL94zGlbHTEXBLc9Q7sAGRcWPYWBERERFpkKqOXJ06dQoPPvhgoddMJhOioqJw6tQpt9M6HA5MnToVTzzxBGrWrOmVenghoDiMRnXdstx25iIsU5Yg88Ov4HdTE9T+IB6BHVspXZbqqS1HqjhmKQ5mKQ5mKQbmqCxVNVdpaWkwmYrfYtpsNsNqtbqddtOmTcjOzsawYcO8Xpcsy4X+LUlSsdcKvlfSNFUxLcdVfzbO9EykvrMB1qXvQhduQlT8awgdcA9QyvRchoWndSn4ObXOqxqXIcdlNr4ct+DdddVSU3Uc1xs1lfS9xxvj+qperYxb1TW5tkmt1KvFmkqiquaqoiwWCxYsWIBZs2bBz8/Pa+PKsoy8vLxCX+x0Ol3+w9lsNluxaVw/3+FwwOl0FnrPYDBAkiQ4nU44HI5C77nGdd1CsyjXXyFKGlev10Ov10OWZdjt9kLvSZKUP63dbi+2cvhqXE/mFSi+DH0xrizLcDqd8Pf3h06nK/e8lpW5J8vQabfDuuEjWGevgpyRjdAnB8I0dhD8zab8ccszr65xq2oZFpxXSZLcrt/ulmFl1m+n04m8vDzodLr8bdLT9dvdMqzK9RvgPgL43y98o9Goin1EwXktbf329T7C2+thVe0jXPtX13ap5D6iMus39xF66HS6/EwLfu/h94jC86r2fUTBbdJVL79HeGcfUXTbKI2qmiuTyYT09PRir1utVpjN5lKne+edd9C0aVO0adMGaWlpAP5bQHa7HWlpaQgKCqrw06rdPSfA3WHXgittUTqdDjpdyZe7FQy5vOOWNa27ZeCrcd3NK+B+GXprXNeG6MqxMvNakWyy9v8Ay8QE5P2WiJB+dyPi9ZEw1Cl8cxa1L0OXyi7Dyq7fBX9ZFFXReVVq/a7O+4iCvxxFWr9LG9dFxP2sK0vXdqn0PsIX81qd9hGyLLv93lNdv0e4aGEfUXSbBMRahkruIzxprACVNVcNGzYsdm1Veno6rl69ioYNG5Y63enTp3HkyBG0bdu22Htt27bF8uXL0aVLlwrVVPCXRdHXy5quIu9VZlqOW/p7Rf8KVxU15SWehWXSImR9egABbW9EnU+XIqB180qP66t6q2LcytZU8D9vjuuO2sZVY00VGbfg0UdvjlvZ90SrqSrGLWm7VLqm6jxuRad1/VW+tH1sZWrS2jJUWzblHbdojmqvV4SaClJVc9WlSxcsWbKk0LVXe/bsgU6nQ6dOnUqd7rXXXss/YuXy5ptvIiAgAM8//zyaNm3q07qJCnKkpCFl7hpYV+2AISYK0cveQHCfruXaMImIiIhIe1TVXA0aNAjr16/H2LFjMXr0aFy+fBmzZ8/GoEGDCj3jaujQobh48SL27t0LAGjWrFmxsUwmE4KCgtC+ffsqq5+qN9lmR9qanUiesxpyng0Rr4yAefQA6AL9lS6NiIiIiKqAqpors9mMtWvXYurUqRg7diyCg4PRr18/jBs3rtDnSrqAzhd4pEEcpZ1/6w2yLCNr73ewvLEItr/PIvThXogY/zgM0ZE++5nVlS9zpKrFLMXBLMXBLMXAHJUlyeW5t2A1cuzYMQBAixYtFK6E1Cz391OwxCUg++sjCOjcGjWmPAX/FtcpXRYREREReZGnvYGqjlypkae3XST1ct2a1N1FuuVlv5qClFkrkbZ+F4zX1katdW8iqHtnris+5IscSRnMUhzMUhzMUgzMUXlsrtzgQT1x2O12rzyxXM7NQ+ry7Uidtw7QSYic/CTMwx+A5MenoVcFb+VIymOW4mCW4mCWYmCOymJzReQBWZaR+dE+WKYshv3cZZiG9UbES49BHxmmdGlEREREpBJsrojKkHv0TyRNjEfOd0cR1K0DYjbOgl+T+kqXRUREREQqw+aKqBT2S0lInrYU6ds+hbHJtYjZOhdBXXlrfyIiIiIqGZsrN3ghoDjKk6UzKwepizYjNX4TpEB/1Jg1DqYh90EycHNRGrdJcTBLcTBLcTBLMTBHZfHbYhm4gmqfJEkeXdgpO53I2PE5LFOXwnE1GeZR/RA+7lHozaFVUCWVxdMcSf2YpTiYpTiYpRiYo/LYXBEByPn+GJImxiP3p98R3KsLIuPGwNiwrtJlEREREZGGsLkqA59zpX2yLMNut8NgMBTL0nbuEpKnLEbGzi/h1+I61N65AIGdblaoUnLHXY6kLcxSHMxSHMxSDMxReWyu3OBzrsRRNEtnRhZS3l4P65Jt0JlDEPXOeIQO7A5Jr1eoQvIEt0lxMEtxMEtxMEsxMEdlsbmiakV2OJC+eTeS31wOZ3oGwsYORtjTD0EXEqR0aURERESkcWyuqNrI/vYnWOIWIu/4SYQ8eBciJoyGsW600mURERERkSDYXJHwbKfOIWnSQmR/ehD+bW5And1LENDmBqXLIiIiIiLBsLlygxcCapsjNR0pb62BdeUO6GtGoOaSOIQ80I25ahhvLysOZikOZikOZikG5qgsNldl4Bdx7ZHtdqSt/RDJs1dBzslDxIuPwTxmIHSB/kqXRpXAbVEczFIczFIczFIMzFF5bK7KwFuxa0vm54dgmZQA28mzCB3cExGvPg59dCQcDgckZqlpsizD4XBAr9czR41jluJgluJglmJgjspjc+UGb2WpHXl/nEZSXAKyv/oeAZ1uRvTiOPjf1ATAfzk6nU7oeZt1zWOO4mCW4mCW4mCWYmCOymJzRZrmSEpB8uxVSFu3C4ZraqHW2ukI6nEr/1pDRERERFWOzRVpkpybB+vKHUh5ay0AIDLuCZhHPADJ30/hyoiIiIioumJzRZoiyzIyP/kGljcWwX7uEkyP3o+Ilx+Dvka40qURERERUTXH5soNnlqmLrm//oWkuATkHPgZgXe0Q8z6GfC7voFH0/LcYzEwR3EwS3EwS3EwSzEwR2WxuSoDGyzl2S8lIfnN5UjfshvG6+qh1uY5CO7WwePpJUnijkYAzFEczFIczFIczFIMzFF5bK7KwFuxK8eZnQvr4q1IeWcDpAA/1JjxHEyP3g/JWL7VVpbl/ByZpXYxR3EwS3EwS3EwSzEwR+WxuXKDt2JXhizLyHj/CyRPXQL7ZQvMjz+I8OeHQh8WWuEx7XY7n1guAOYoDmYpDmYpDmYpBuaoLDZXpCo5P5xA0sR45P5wAsE9b0VM3Bj4NbpG6bKIiIiIiMrE5opUwXb+MpKnLkHGjs/hd0Nj1H7/HQR2bq10WUREREREHmNzRYpyZmQhNX4TUhdthi40BFHzX0Ho4B6QeDEmEREREWkMmys3eCGg78hOJ9K37Ebym8vhTE2HecxAhD/7CHQhQT75ecxSDMxRHMxSHMxSHMxSDMxRWWyuysAV1PuyD/yMpInxyDt2EiF970TExCdgvKaWz36eJEm8sFMAzFEczFIczFIczFIMzFF5bK6oythOX4Bl8iJkfrwf/q2boc7HixDQroXSZREREREReQWbqzLwOVeV57CmI2XeOliXb4c+KgI1F09EyAPdIOl0VfLzZVmG3W6HwWBglhrGHMXBLMXBLMXBLMXAHJXH5soNPueqcmS7HWnrdyF51krI2bkIf2EowsYMgi4ooOprYZZCYI7iYJbiYJbiYJZiYI7KYnNFPpH15WEkTVoI25//IHRgd0S8PgqGWjWULouIiIiIyGfYXJFX5f31DyxxC5H1xSEExLZE9N7l8G/ZVOmyiIiIiIh8js0VeYXDkork2auRtvYDGK6JRvSqqQi+9zae70tERERE1QabKzfYGJRNzrPBuvI9pLy1FnDKiJgwCmEj+0Hy91O6tEIMBq7qImCO4mCW4mCW4mCWYmCOyuLSLwMbrJLJsoysPd/CMmkRbGcuwvTofQh/eQQMUeFKl1aMJEnMUQDMURzMUhzMUhzMUgzMUXlsrsrAW7EXl3vsJJLiEpDz7U8IvL0totdOh3+zhkqXVSpZluF0OqHT6ZilhjFHcTBLcTBLcTBLMTBH5bG5coO3sizMftmC5BnLkb7pExgbXYNaG2ch6K5YTWy8DocDuip6rhb5DnMUB7MUB7MUB7MUA3NUFpsrKpMzOxfWJVuR8s4GSH5G1Jj+DEzD+kAycvUhIiIiInLht2MqlSzLyNz5JSxTl8D+71WYRzyA8Bcfgz4sVOnSiIiIiIhUR3XNVWJiIqZNm4aff/4ZwcHB6N27N5577jn4+ZV+97krV65gzZo1OHDgAM6ePYvQ0FC0bdsWzz//POrUqVOF1Ysj56ffYJkQj5wjxxHUvTNi3n0Lfo3qKV0WEREREZFqqaq5slqtGDp0KOrXr4/4+HhcvnwZM2fORE5ODuLi4kqd7sSJE9i7dy8efPBBtGzZEikpKVi8eDH69++Pjz76CBERERWqRwvXEnmb/cJlWKYtRcb2vfC7oRFi3puPoC5tlC6r0njusRiYoziYpTiYpTiYpRiYo7JU1Vxt2bIFmZmZSEhIQFhYGID/LsqbPHkyRo8ejejo6BKnu+WWW7B79+5C9/Vv3bo1br/9duzcuRPDhw+vcE3VpcFyZmQhNWETUhdtgS4kCFHzXkLoQ70g6fVKl1ZpkiTxmQ8CYI7iYJbiYJbiYJZiYI7KU1Vru3//fsTGxuY3VgDQo0cPOJ1OHDhwoNTpTCZTsRWpVq1aiIiIwJUrVypVk+h3DJSdTqRt/gRnOzyE1ITNMI/sh3qHN8M05H4hGivgvwxd/5F2MUdxMEtxMEtxMEsxMEflqaq5OnXqFBo2LPy8JJPJhKioKJw6dapcY50+fRoWiwWNGjWqcD2ir5jZ3x3FhbtH4eozMxDQoSWuObAekROfgC40WOnSvM5msyldAnkBcxQHsxQHsxQHsxQDc1SWqo4bpqWlwWQyFXvdbDbDarV6PI4sy5g2bRpq1qyJXr16VaqmkhosSZJKbbxcpxG6e99X03o6ru2fi0ieshiZH+2Df6vrUXvXQgS0b1Hiz1ZDvZUdt+hfcNRQU3Udt7I1lfTXOLXOq1qXoRrGLZijFurVck2+HrfodsllqPy4FZ3WNV1p33sqU5PWlqHasinPuCVtk2quV+s1lURVzZW3xMfH49ChQ1ixYgWCgoIqNZbNZit03ZVOp8s/BbGkvwy47mrocDjgdDoLvWcwGCBJEpxOJxwOR6H3XOPKslziuEajsdRx9Xo99Ho9ZFmG3W4v9J4kSfnT5iWnwvrOBqSvfB/6CDMi3hkP88Du0On1sNvtFR7XbrcXW+k8mVeg+DL0xbiu+o1GIyRJKvcyLCtzb2RT3nl1jVtSTb7KxjWvpS1D17julqG31m/XNlnWvLrec7cMq3L9BtS9j3C3DL05bsFf/GrYRxScV+4jyrcMi26XatlHeDqv3Ef8b151Ol3+tAW/9yixj/B0XgHuI4rOa8HPuerl9wjv7CNkWS60bZRGVc2VyWRCenp6sdetVivMZrNHY2zbtg0LFy7E9OnTERsbW+maXCtBae+VpuBKW5ROpyv1Ti4FQy7vuKVNK9vtSNvwEZJnrYSclYPwZx+B+clB0AUHVmpcF3cXTrqbV8D9MvTWuEX/olqZefV2Ni5qX4YulV2GlV2/DQZDqdtkRedVqWzUtI9wcTev3hy34C9Hkdbv0sZ1EXEf4dq/urZLpfcRvpjX6riPKO17T1XtIwriPsKzcV3zWnSbBMRahkruIzxprACVNVcNGzYsdm1Veno6rl69WuxarJLs3bsXb7zxBp555hn069ev0vW4flGUtDDLWsDu3vfVtCW9l/X1EVjiEpD3+ymEDOiOyAmjYIiJUm29vhq34Mavlpqq47iVrcm1cyvvNsllqL5xXdukVurVak1VMW5J26XSNVXncSs6rSzLbvexlalJa8tQbdmUd9yiOaq9XhFqKkhVzVWXLl2wZMmSQtde7dmzBzqdDp06dXI77eHDh/H888+jf//+GDt2rNdqKs/CVJO8k2dgmbQQWXu/Q0D7m1Bn73IEtLpe6bIUUdZfKkgbmKM4mKU4mKU4mKUYmKPyVNVcDRo0COvXr8fYsWMxevRoXL58GbNnz8agQYMKPeNq6NChuHjxIvbu3QsASExMxNixY1G/fn307t0bv/zyS/5nIyIiUK9evaqeFcU4kq1ImbMa1jU7YahdE9ErpyD4vts12yQSEREREWmFqpors9mMtWvXYurUqRg7diyCg4PRr18/jBs3rtDnil5Ad/ToUaSnpyM9PR2DBw8u9Nm+ffti5syZFa7J04vXlCbn2WBd9T5S3loD2e5AxKsjYR7VD7oAf6VLU5zrAkbXhZKkTcxRHMxSHMxSHMxSDMxReZJcnnsLViPHjh2DLMto0aKFqldOWZaR9dlBWCYthO30BZgeuRfhr4yAoWaE0qWphuvieXcX6ZL6MUdxMEtxMEtxMEsxMEffOXbsGACgRYsWbj+nqiNXVD65J/6GJS4B2ft/ROBtbRC9cgr8b2isdFlERERERNUSmysNsl9JRvLMFUjf+DGMDeqg1saZCLqrI/9CQURERESkIDZXGuLMyYV12XakzF8HyaBH5JSnYB7eF5KRMRIRERERKY3fyt1Qy5EgWZaR+eHXsExZDPvFKzA/1hfhLz0GfbhJ6dI0w92D4Ug7mKM4mKU4mKU4mKUYmKOyuPTLoHSDlfPLH7BMiEfO4V8RdHdHxGydC7/G1efW8t7g7oGIpB3MURzMUhzMUhzMUgzMUXlsrsqg1K3Y7RevwDJ9GTK2fQq/Zg0R8+48BN3etsrrEIEsy3A6nflPLCdtYo7iYJbiYJbiYJZiYI7KY3PlhhJ3qXdmZiN14WakJmyCFByIGnNfhOnhXpB4iLdSHA4HdDqd0mVQJTFHcTBLcTBLcTBLMTBHZfEbu0rITicytn8Gy7RlcFhSETa6P8KeGwK9KUTp0oiIiIiIyANsrlQg+9CvsEyMR+4vfyD4vtsRGTcGxvq1lS6LiIiIiIjKgc2VgmxnLsIyZQkyP/wK/i2bovaHCQiMbal0WUREREREVAFsrtzw1YWAzvRMpMxfD+uyd6ELNyEq/jWEDrgHEs+P9RmeeywG5igOZikOZikOZikG5qgsNldl8GaDJTscSN/0MZJnrIAzIwthTz+EsKcegi440Gs/g4qTJInPfBAAcxQHsxQHsxQHsxQDc1Qel34ZvHUr9qz9P8ASl4C8E4kI6X83Il8fBUOdaC9USGUpeNdH3pZUu5ijOJilOJilOJilGJij8thcueGNW7HnJZ6FZdIiZH16AAFtb0SdT5cioHVzL1RH5WGz2WA0GpUugyqJOYqDWYqDWYqDWYqBOSqLzZWPOFLSkDJ3DayrdsAQE4XoZW8guE9X/hWBiIiIiEhQbK68TLbZYV29EylzV0POsyHilREwPzEAugB/pUsjIiIiIiIfYnPlJbIsI2vvd7BMWghb4jmEPtwLEeMfhyE6UunSiIiIiIioCrC58oLc30/BEpeA7K+PIPDW1ohePhn+NzZWuiwiIiIiIqpCbK7ckCTJ7TVS9qspSJm1Emnrd8FYvzZqrZ+BoHs68boqlZEkCUajkbloHHMUB7MUB7MUB7MUA3NUHpurCpBz85C67F2kzl8P6CRETn4S5uEPQPLjnVnUijsZMTBHcTBLcTBLcTBLMTBHZbG5KkPB51zJsozMXV/DMmUx7OevwDSsNyJeHg59hFnZIsktWZbhcDig1+u5w9Ew5igOZikOZikOZikG5qg8NlduFHzOVe7RP5E0IR45h44iqFsHxGyaDb8m9ZUrjsrF6XRCr9crXQZVEnMUB7MUB7MUB7MUA3NUFpurMtgvJSFl+jKkb/sUxibXImbrXAR1ba90WUREREREpDJsrtwwrt+Nc9s+hxTojxqzxsE05D5IBi4yIiIiIiIqjp2CG8YNu2Ea1R/hzz8KvTlU6XKIiIiIiEjF2Fy5kbNxKiLv6MwLAgXAc4/FwBzFwSzFwSzFwSzFwByVxebKDTkqjI2VACRJ4o5GAMxRHMxSHMxSHMxSDMxReTqlC1C7gncMJG2SZRlOp5NZahxzFAezFAezFAezFANzVB6bKze4YorDbrcrXQJ5AXMUB7MUB7MUB7MUA3NUFpsrIiIiIiIiL2BzRURERERE5AVsroiIiIiIiLyAzZUbvFOgOHQ6ruoiYI7iYJbiYJbiYJZiYI7K4q3Yy8AGS/skSYLBwFVd65ijOJilOJilOJilGJij8tjaEhEREREReQGbKzdkWebt2AUgyzLy8vKYpcYxR3EwS3EwS3EwSzEwR+WxuSIiIiIiIvICNldERERERERewOaKiIiIiIjIC9hcEREREREReQGbKzd4G3ZxGI1GpUsgL2CO4mCW4mCW4mCWYmCOylJdc5WYmIjHHnsMrVq1QqdOnTB79mzk5eWVOZ0sy1i2bBluv/123HTTTRg4cCB++eWXStfDBkv7JEnK/4+0izmKg1mKg1mKg1mKgTkqT1XNldVqxdChQ2Gz2RAfH49x48Zh27ZtmDlzZpnTLl++HAsWLMCwYcOwdOlSREVFYfjw4Th37lylauKtLLVPlmXY7XZmqXHMURzMUhzMUhzMUgzMUXmqeoTzli1bkJmZiYSEBISFhQEAHA4HJk+ejNGjRyM6OrrE6XJzc7F06VIMHz4cw4YNAwDccsst6N69O1auXIk33nijQvVwxRSH0+mEXq9XugyqJOYoDmYpDmYpDmYpBuaoLFUdudq/fz9iY2PzGysA6NGjB5xOJw4cOFDqdD/99BMyMjLQo0eP/Nf8/Pxw1113Yf/+/b4smYiIiIiICIDKmqtTp06hYcOGhV4zmUyIiorCqVOn3E4HoNi0jRo1wsWLF5GTk+P9YomIiIiIiApQ1WmBaWlpMJlMxV43m82wWq1up/Pz84O/v3+h100mE2RZhtVqRUBAQLlqsdlskGUZx48fL9d0pE6yLPPiTgEwR3EwS3EwS3EwSzEwR9/Iy8vzaLmqqrlSE66UYmGeYmCO4mCW4mCW4mCWYmCOvuHpXRhV1VyZTCakp6cXe91qtcJsNrudLi8vD7m5uYWOXqWlpUGSJLfTlubmm28u9zRERERERFR9qeqaq4YNGxa7tio9PR1Xr14tdj1V0ekA4PTp04VeP3XqFGrXrl3uUwKJiIiIiIjKS1XNVZcuXXDw4EGkpaXlv7Znzx7odDp06tSp1Olat26NkJAQ7N69O/81m82Gzz77DF26dPFpzURERERERIDKTgscNGgQ1q9fj7Fjx2L06NG4fPkyZs+ejUGDBhV6xtXQoUNx8eJF7N27FwDg7++P0aNHIz4+HhEREWjSpAk2b96M1NRUjBgxQqnZISIiIiKiakRVzZXZbMbatWsxdepUjB07FsHBwejXrx/GjRtX6HNOpxMOh6PQayNHjoQsy1i1ahWSk5PRrFkzrFy5Etdcc01VzgIREREREVVTkizLstJFEBERERERaZ2qrrkiIiIiIiLSKjZXREREREREXsDmioiIiIiIyAvYXBEREREREXkBmysiIiIiIiIvYHNFRERERETkBWyuiIiIiIiIvIDNVRGJiYl47LHH0KpVK3Tq1AmzZ89GXl6e0mWRG7t378aYMWPQpUsXtGrVCr1798b27dtR9BFu7777Lu655x60aNEC999/P7766iuFKiZPZWZmokuXLmjatCmOHTtW6D3mqQ3vv/8++vTpgxYtWqB9+/Z4/PHHkZOTk//+l19+ifvvvx8tWrTAPffcg/fee0/BaqkkX3zxBfr374+bb74ZnTt3xrPPPotz584V+xy3SXU5c+YM4uLi0Lt3bzRv3hz33ntviZ/zJLf09HS89tpraNeuHW6++WY888wzuHLliq9ngf5fWVlmZGQgPj4e/fr1Q5s2bdCxY0c88cQT+PPPP4uNxSx9j81VAVarFUOHDoXNZkN8fDzGjRuHbdu2YebMmUqXRm6sWbMGgYGBGD9+PBYvXowuXbpg4sSJWLhwYf5nPv74Y0ycOBE9evTA8uXL0apVKzz11FP45ZdflCucyrRo0SI4HI5irzNPbVi8eDGmTp2Knj17YuXKlZgyZQrq1q2bn+kPP/yAp556Cq1atcLy5cvRo0cPvP7669izZ4/ClZPL4cOH8dRTT6Fx48ZYuHAhXnvtNfzxxx8YPnx4oSaZ26T6nDx5Evv27cO1116LRo0alfgZT3N77rnncODAAbzxxhuYO3cuTp8+jZEjR8Jut1fBnFBZWV68eBFbt25Fp06d8Pbbb2Pq1KlIT0/HwIEDkZiYWOizzLIKyJRvyZIlcqtWreSUlJT817Zs2SI3a9ZMvnTpknKFkVsWi6XYaxMmTJBbt24tOxwOWZZl+e6775aff/75Qp8ZOHCg/Pjjj1dJjVR+f//9t9yqVSt58+bNcpMmTeRff/01/z3mqX6JiYly8+bN5a+//rrUzwwfPlweOHBgodeef/55uUePHr4ujzw0ceJEuWvXrrLT6cx/7bvvvpObNGkiHzlyJP81bpPq4/r9J8uy/Morr8i9evUq9hlPcvvpp5/kJk2ayN98803+a4mJiXLTpk3ljz/+2AeVU1FlZZmZmSlnZWUVei0jI0Nu166dPGXKlPzXmGXV4JGrAvbv34/Y2FiEhYXlv9ajRw84nU4cOHBAucLIrYiIiGKvNWvWDBkZGcjKysK5c+fwzz//oEePHoU+07NnT3z33Xc87VOlpk2bhkGDBqFBgwaFXmee2rBjxw7UrVsXt912W4nv5+Xl4fDhw+jevXuh13v27InExEScP3++KsqkMtjtdgQHB0OSpPzXQkNDASD/1Gtuk+qk07n/iudpbvv374fJZEKnTp3yP9OwYUM0a9YM+/fv937hVExZWQYFBSEwMLDQa8HBwahXr16hU/6YZdVgc1XAqVOn0LBhw0KvmUwmREVF4dSpUwpVRRXx448/Ijo6GiEhIfnZFf2S3qhRI9hsthKvHSBl7dmzB3/99RfGjh1b7D3mqQ1Hjx5FkyZNsGjRIsTGxuLGG2/EoEGDcPToUQDA2bNnYbPZiu1zXae8cJ+rDg888AASExOxceNGpKen49y5c5g3bx6aN2+O1q1bA+A2qVWe5nbq1Ck0aNCgUIMN/PelnNupeqWlpeHkyZOF9rHMsmqwuSogLS0NJpOp2OtmsxlWq1WBiqgifvjhB3zyyScYPnw4AORnVzRb17+ZrbpkZ2dj5syZGDduHEJCQoq9zzy14erVq/j222/xwQcfYNKkSVi4cCEkScLw4cNhsViYo0a0adMGCQkJeOutt9CmTRt069YNFosFy5cvh16vB8BtUqs8zS0tLS3/aGVB/G6kbnPmzIEkSRg8eHD+a8yyarC5IqFcunQJ48aNQ/v27fHoo48qXQ5VwOLFixEZGYkHH3xQ6VKoEmRZRlZWFt555x10794dt912GxYvXgxZlrFhwwalyyMP/fTTT3j55ZcxYMAArF27Fu+88w6cTidGjRpV6IYWRKQe7733HrZt24a4uDjUqlVL6XKqHTZXBZhMJqSnpxd73Wq1wmw2K1ARlUdaWhpGjhyJsLAwxMfH55+j7MquaLZpaWmF3iflXbhwAatWrcIzzzyD9PR0pKWlISsrCwCQlZWFzMz/a+/+Y6Ku/ziAPyHuzonASWsSCNNkHXEeGsnxQ3fEkQUpkc7V1QSWNq80Qpop/ohEWJTpTto0NdZSypo6syCGM4a6pVG4WOC5Jb8iEFt5HN1V4J133z8YN6874qyPx92352O7P3i/35/358W9dgevz+fz/nx+Zz79RGhoKKRSKeLi4hxtUqkU8fHx6OjoYB79REVFBVJSUlBSUoKUlBRkZWXh4MGD0Ov1+OyzzwDwO9ZfeZq30NBQmM1ml+35v5FvOnv2LEpLS7F27VosW7bMqY+59A4WV7dwd82pyWTCL7/84rIugHzL8PAwtFotTCYTqqurnU57j+Xur7nt6uqCSCRCdHS0V2Ol8fX19cFisWDNmjVISkpCUlISXnjhBQBAfn4+nnvuOebTT8TGxo7bNzIygpiYGIhEIrd5BMDvXB/R2dnpVCADQEREBKZPn47e3l4A/I71V57m7b777kN3d7fLsyO7u7v5OfUxra2tKCoqwpNPPomioiKXfubSO1hc3UKlUuH8+fOOozbA6ML6wMBApzurkG+xWq1Yv349urq6UF1djRkzZjj1R0dHY9asWS7Pzqmvr0dqairEYrE3w6W/8cADD+Dw4cNOr82bNwMAysrK8PrrrzOffiIjIwNGoxGXL192tA0ODuLSpUuQy+UQi8VITk7GqVOnnLarr6/HnDlzMHPmTG+HTG5ERkZCr9c7tfX392NwcBBRUVEA+B3rrzzNm0qlwtDQEC5cuOAY093dDb1eD5VK5dWYaXwdHR3QarVISUlBWVmZ2zHMpXcETXYAvkSj0aCmpgbr1q2DVqvFzz//jJ07d0Kj0bj8w06+o6ysDE1NTSgpKYHZbHZ6+GF8fDzEYjEKCwuxYcMGxMTEIDk5GfX19fj++++59sPHhIaGIjk52W2fXC6HXC4HAObTDzzyyCNQKBR4+eWXUVxcDIlEgoMHD0IsFuPZZ58FALz44ovIz8/H9u3bkZ2djebmZtTV1UGn001y9DRGo9HgjTfeQEVFBdRqNYxGo2Nd5K238OZn0vf8+eefOHv2LIDRgthsNjsKKaVSifDwcI/y9uCDD2LRokXYsmULNm3aBIlEAp1OB5lMhkcffXRSfrf/molyabfbsXr1akgkEhQUFKC9vd2x7bRp0xxXEjCX3hFg/+u5wf+4zs5OlJeX47vvvkNwcDByc3NRXFzMI28+TK1Wo7+/321fY2Oj4wj4sWPH8N577+Hq1auYPXs2XnnlFWRkZHgzVPoHmpubkZ+fj+PHj0OhUDjamU/fZzAYUFlZiaamJlgsFixYsACbN292umSwsbERe/bsQXd3NyIjI7FmzRqsWLFiEqOmW9ntdnzyySf4+OOP8dNPPyE4OBjz589HcXGx47b5Y/iZ9C19fX3IzMx023f48GHHgSxP8mYymVBZWYnTp0/DarVi0aJF2LZtGw88e8lEuQQw7k28lEolampqHD8zl3ceiysiIiIiIiIBcM0VERERERGRAFhcERERERERCYDFFRERERERkQBYXBEREREREQmAxRUREREREZEAWFwREREREREJgMUVERERERGRAFhcERERCWhgYAAKhQIXL1687W07OjoQHx+PH3744Q5ERkREdxqLKyIi8gsnTpyATCaDTCZDS0uLS7/dbkd6ejpkMhm0Wu0kRDhq7969mDdvHh566KHb3jY2Nhbp6el455137kBkRER0p7G4IiIivyKRSFBXV+fS/s033+DatWsQi8WTENUog8GAkydPQqPR/OM5NBoNTp8+jd7eXgEjIyIib2BxRUREfiU9PR0NDQ2wWq1O7XV1dZDL5bjnnnsmKTLg888/x1133YWMjIx/PEdaWhrCwsLw6aefChgZERF5A4srIiLyK0uWLIHRaMRXX33laLtx4wZOnTqFnJwct9vYbDZ88MEHWLJkCRQKBdLS0lBaWoqhoSGncXa7Hfv27YNKpcK8efOQl5eHK1euQK1Wo6SkZMLYvvzySyQkJCA4ONil76OPPkJmZiYSEhKwYsUKtLS0IC8vD3l5eU7jRCIRlEolGhsbPXk7iIjIh7C4IiIivxIVFYX58+fjiy++cLSdO3cOJpMJjz/+uNttSktL8fbbbyMxMRFbt27F8uXLUVtbi9WrV8NisTjGVVVVoaqqCnFxcdi4cSOio6OxatUq/PHHHxPGZbFY0NbWBrlc7tJ35MgR7NixAxEREXj11VexYMECrFu3DteuXXM7l1wux5UrV2A2myfcLxER+Y6gyQ6AiIjoduXk5GD37t0YHh7GlClTUFtbi6SkJMyYMcNlbEtLC44dO4Zdu3Y5ndlKTk7G888/j4aGBuTk5MBgMKC6uhoPP/ww9u/fj4CAAACATqfD/v37J4xpYGAAw8PDmDlzplP7jRs3UFVVBYVCgUOHDiEoaPRPr0wmQ0lJCSIiIlzmio6Ohs1mQ1dXFxISEm7rvSEiosnDM1dEROR3srOzMTIygqamJpjNZpw5c2bcSwIbGhoQEhKChQsXwmAwOF5yuRxTp05Fc3MzAOD8+fOwWCxYuXKlo7ACgIKCAo9iMhqNAIDQ0FCn9vb2dhiNRjz11FOOwgoYLRDDwsLczjU2x+DgoEf7JiIi38AzV0RE5HfCw8ORmpqKuro6DA8P4+bNm3jsscfcjv3xxx9hMpmQmprqtv/69esAgKtXrwIAZs2a5bKv8Yogd+x2u9PPY/PGxMQ4tQcFBSEqKsqjOYiIyD+wuCIiIr+0dOlSvPbaa/j111+hUqlczhiNsdlsuPvuu7Fr1y63/eHh4YLEI5VKAQC//fbbv55rbI7p06f/67mIiMh7eFkgERH5pcWLFyMwMBCtra1YunTpuONiYmJgNBqRmJiItLQ0l1dcXBwAIDIyEgDQ09PjtL3BYHC5q6A79957L6ZMmYK+vj6n9rF5//rcKqvViv7+frdz9fX1ITAwELNnz55wv0RE5DtYXBERkV8KDg7G9u3bUVhYCLVaPe647Oxs3Lx5E/v27XPps1qtjrNEaWlpEIlE+PDDD50uyzt06JBH8YhEIsydOxft7e1O7XPnzoVUKsXRo0edns1VW1s7btF26dIlxMbGIiQkxKN9ExGRb+BlgURE5LeWLVs24RilUomnn34aBw4cwOXLl7Fw4UKIRCL09PSgoaEBW7duRVZWFsLDw7Fq1SocOHAAWq0W6enp0Ov1OHfunMeX52VmZkKn08FsNmPatGkAALFYjMLCQpSXl6OgoADZ2dno7+/HiRMnXNZhAaO3dP/222/xzDPP3N6bQUREk45nroiI6P/ejh07UF5ejuvXr0On02H37t34+uuv8cQTTyAxMdExbv369SgsLIRer8fOnTvR29uL999/H1OnTvVoP7m5ubDZbC4PAF65ciW2bduGgYEBvPXWW2hpacG7776LkJAQSCQSp7EXLlyA0Wj0qHAkIiLfEmDnLYmIiIj+llqthlKpxJtvvjnh2C1btqCnpwdHjhz523E2mw2pqalYvHgxKioqHO1r165FQEAA9u7d+6/jJiIi7+KZKyIiIgG99NJLaGtrw8WLFx1tIyMjLrdXP3nyJIxGI5RKpaOts7MTZ86cQVFRkdfiJSIi4XDNFRERkYAiIyPR1tbm1Nba2orKykpkZWVBKpVCr9fj+PHjuP/++5GVleUYN2fOHOj1em+HTEREAmFxRUREdIdFRUUhIiICNTU1GBoaQlhYGHJzc7FhwwaIxeLJDo+IiATCNVdEREREREQC4JorIiIiIiIiAbC4IiIiIiIiEgCLKyIiIiIiIgGwuCIiIiIiIhIAiysiIiIiIiIBsLgiIiIiIiISAIsrIiIiIiIiAbC4IiIiIiIiEgCLKyIiIiIiIgH8D5LsvgzrOnb/AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1694,7 +1694,7 @@ }, { "cell_type": "code", - "execution_count": 628, + "execution_count": 27, "id": "3c7c05e6", "metadata": {}, "outputs": [ @@ -1751,7 +1751,7 @@ }, { "cell_type": "code", - "execution_count": 629, + "execution_count": 28, "id": "698e3c48", "metadata": {}, "outputs": [ @@ -1761,11 +1761,11 @@ "text": [ "Ax + B : \n", "AdC = 0.01205 ± 0.00001\n", - "BdC = 0.01985 ± 0.00053\n", + "BdC = 0.08184 ± 0.00050\n", "cov_ABdC = -0.000000\n", "P(0,chi²)= 1.00000\n", "KdC = 3.27519 ± 0.00175\n", - "KBdC = 1.98906 ± 0.05297\n" + "KBdC = 0.48236 ± 0.00292\n" ] } ], @@ -1838,13 +1838,13 @@ }, { "cell_type": "code", - "execution_count": 630, + "execution_count": 29, "id": "a0ab8534", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1907,7 +1907,7 @@ }, { "cell_type": "code", - "execution_count": 631, + "execution_count": 30, "id": "12bb0479", "metadata": {}, "outputs": [ @@ -1965,7 +1965,7 @@ }, { "cell_type": "code", - "execution_count": 632, + "execution_count": 31, "id": "385db415", "metadata": {}, "outputs": [ @@ -1974,13 +1974,13 @@ "output_type": "stream", "text": [ "AdY = 0.0120538 ± 0.0000065\n", - "BdY = 0.0198466 ± 0.0005286\n", - "cov_ABdY = -3.327136085608824e-09\n", + "BdY = 0.0818432 ± 0.0004963\n", + "cov_ABdY = -3.1129590737835483e-09\n", "chi² = 154.21640\n", "chi² rid = 51.40547\n", "P(0, chi²)= 1.00000\n", "KdY = 3.27519 ± 0.00175\n", - "KBdY = 1.98918 ± 0.05298\n" + "KBdY = 0.48237 ± 0.00292\n" ] } ], @@ -2058,13 +2058,13 @@ }, { "cell_type": "code", - "execution_count": 633, + "execution_count": 32, "id": "698bc57c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2135,7 +2135,7 @@ }, { "cell_type": "code", - "execution_count": 634, + "execution_count": 33, "id": "fc32f9e6", "metadata": {}, "outputs": [ @@ -2144,28 +2144,28 @@ "output_type": "stream", "text": [ "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata K = 3.21203 ± 0.00037\n", + "Media pesata K = 3.01340 ± 0.00035\n", "\n", "RISULTATI REGRESSIONE OLS:\n", "Adols = 0.01202 ± 0.00004\n", - "Bdols = 0.02190 ± 0.00427\n", + "Bdols = 0.08371 ± 0.00406\n", "P(0,chi²)= 1.00000\n", "Kdols = 3.28476 ± 0.01190\n", - "KBdols = 1.80288 ± 0.35183\n", + "KBdols = 0.47159 ± 0.02287\n", "\n", "RISULTATI REGRESSIONE Carpi:\n", "AdC = 0.01205 ± 0.00001\n", - "BdC = 0.01985 ± 0.00053\n", + "BdC = 0.08184 ± 0.00050\n", "P(0,chi²)= 1.00000\n", "KdC = 3.27519 ± 0.00175\n", - "KBdC = 1.98906 ± 0.05297\n", + "KBdC = 0.48236 ± 0.00292\n", "\n", "RISULTATI REGRESSIONE York:\n", "Ady = 0.01205 ± 0.00001\n", - "Bdy = 0.01985 ± 0.00053\n", + "Bdy = 0.08184 ± 0.00050\n", "P(0,chi²)= 1.00000\n", "KdY = 3.27519 ± 0.00175\n", - "KBdY = 1.98918 ± 0.05298\n" + "KBdY = 0.48237 ± 0.00292\n" ] } ], @@ -2205,7 +2205,7 @@ }, { "cell_type": "code", - "execution_count": 635, + "execution_count": 34, "id": "f4897de3", "metadata": {}, "outputs": [ @@ -2216,8 +2216,8 @@ "res_T = 0.001000\n", "res_T2 = 0.002551\n", "res_b = 0.004082\n", - "res_uAd = 0.000047\n", - "uKd_strum= 0.012519\n" + "res_uAd = 0.000052\n", + "uKd_strum= 0.012784\n" ] } ], @@ -2241,7 +2241,7 @@ }, { "cell_type": "code", - "execution_count": 636, + "execution_count": 35, "id": "37d88464", "metadata": {}, "outputs": [], @@ -2290,7 +2290,7 @@ }, { "cell_type": "code", - "execution_count": 637, + "execution_count": 36, "id": "9075e52d", "metadata": {}, "outputs": [ @@ -2299,24 +2299,24 @@ "output_type": "stream", "text": [ "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata Kd = 3.21203 ± 0.01252\n", + "Media pesata Kd = 3.01340 ± 0.01279\n", "\n", "RISULTATI OLS:\n", - "Adols = 0.01202 ± 0.00006\n", - "Bdols = 0.02190 ± 0.00427\n", - "Kdols = 3.28476 ± 0.01727\n", + "Adols = 0.01202 ± 0.00007\n", + "Bdols = 0.08371 ± 0.00406\n", + "Kdols = 3.28476 ± 0.01746\n", "Chi² = 3.32681 | rid = 1.10894 | P = 0.65607\n", "\n", "RISULTATI Carpi:\n", "AdC = 0.01205 ± 0.00005\n", - "BdC = 0.01985 ± 0.00053\n", - "KdC = 3.27519 ± 0.01264\n", + "BdC = 0.08184 ± 0.00050\n", + "KdC = 3.27519 ± 0.01290\n", "Chi² = 5.09243 | rid = 1.69748 | P = 0.83485\n", "\n", "RISULTATI York:\n", "AdY = 0.01205 ± 0.00005\n", - "BdY = 0.01985 ± 0.00053\n", - "KdY = 3.27519 ± 0.01264\n", + "BdY = 0.08184 ± 0.00050\n", + "KdY = 3.27519 ± 0.01290\n", "Chi² = 5.09342 | rid = 1.69781 | P = 0.83492\n" ] } @@ -2354,7 +2354,7 @@ }, { "cell_type": "code", - "execution_count": 638, + "execution_count": 37, "id": "0f407f81", "metadata": {}, "outputs": [ @@ -2395,7 +2395,7 @@ }, { "cell_type": "code", - "execution_count": 639, + "execution_count": 38, "id": "99bc83a7", "metadata": {}, "outputs": [ @@ -2403,17 +2403,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "0 3481.378680\n", - "1 3520.884276\n", - "2 3558.947648\n", - "3 3591.253438\n", - "4 3515.263991\n", + "0 3152.185929\n", + "1 3277.558955\n", + "2 3364.449659\n", + "3 3428.875660\n", + "4 3380.118798\n", "dtype: float64\n", - "0 58.960824\n", - "1 30.349344\n", - "2 40.869090\n", - "3 60.110320\n", - "4 110.836582\n", + "0 53.385731\n", + "1 28.252029\n", + "2 38.635615\n", + "3 57.392460\n", + "4 106.575447\n", "dtype: float64\n" ] } @@ -2434,7 +2434,7 @@ }, { "cell_type": "code", - "execution_count": 640, + "execution_count": 39, "id": "ae55d12a", "metadata": {}, "outputs": [ @@ -2442,8 +2442,8 @@ "name": "stdout", "output_type": "stream", "text": [ - "K-medio (t): 3.533948573536872\n", - "sigmaC (t): 0.02071589620414334\n" + "K-medio (t): 3.3035179495747626\n", + "sigmaC (t): 0.019369943676623744\n" ] } ], @@ -2465,7 +2465,7 @@ }, { "cell_type": "code", - "execution_count": 641, + "execution_count": 40, "id": "75e94b0a", "metadata": {}, "outputs": [], @@ -2489,7 +2489,7 @@ }, { "cell_type": "code", - "execution_count": 642, + "execution_count": 41, "id": "896388e2", "metadata": {}, "outputs": [ @@ -2502,8 +2502,8 @@ "Dep. Variable: y R-squared: 0.999\n", "Model: OLS Adj. R-squared: 0.998\n", "Method: Least Squares F-statistic: 2631.\n", - "Date: Sun, 05 Apr 2026 Prob (F-statistic): 1.63e-05\n", - "Time: 21:52:54 Log-Likelihood: 15.713\n", + "Date: Mon, 06 Apr 2026 Prob (F-statistic): 1.63e-05\n", + "Time: 10:30:02 Log-Likelihood: 15.713\n", "No. Observations: 5 AIC: -27.43\n", "Df Residuals: 3 BIC: -28.21\n", "Df Model: 1 \n", @@ -2511,13 +2511,13 @@ "==============================================================================\n", " coef std err t P>|t| [0.025 0.975]\n", "------------------------------------------------------------------------------\n", - "const 0.0107 0.021 0.506 0.648 -0.057 0.078\n", + "const 0.0675 0.020 3.362 0.044 0.004 0.131\n", "x 0.0110 0.000 51.298 0.000 0.010 0.012\n", "==============================================================================\n", "Omnibus: nan Durbin-Watson: 2.074\n", "Prob(Omnibus): nan Jarque-Bera (JB): 0.262\n", "Skew: -0.213 Prob(JB): 0.877\n", - "Kurtosis: 1.963 Cond. No. 344.\n", + "Kurtosis: 1.963 Cond. No. 310.\n", "==============================================================================\n", "\n", "Notes:\n", @@ -2525,10 +2525,10 @@ "\n", "RISULTATI REGRESSIONE OLS (t):\n", "Atols = 0.01104 ± 0.00022\n", - "Btols = 0.01070 ± 0.02113\n", + "Btols = 0.06749 ± 0.02007\n", "R² = 0.99886\n", "Kdtols = 3.57541 ± 0.06970\n", - "KBdtols = 3.69021 ± 7.28924\n" + "KBdtols = 0.58496 ± 0.17399\n" ] }, { @@ -2567,13 +2567,13 @@ }, { "cell_type": "code", - "execution_count": 643, + "execution_count": 42, "id": "61e40e4c", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2MAAAIsCAYAAAB/SHEEAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoYxJREFUeJzs3Xd0FPX6BvBndtN7NpAQAoiAQZTQBJEiehELNlSqBYNYgIsN20WlSFEREZXQm/SmIipeQGygoNhQARtNQMBANsmmJ1vm9we/3ZuQZDdtdvbdPJ9zPB52dr777jwzw75MU1RVVUFEREREREReZdC7ACIiIiIiovqIzRgREREREZEO2IwRERERERHpgM0YERERERGRDtiMERERERER6YDNGBERERERkQ7YjBEREREREemAzRgREREREZEO2IwRERERERHpgM0YERF5zdChQzF06FDXn//++2+0bt0aGzdu1LEqIiIifbAZIyLSwcaNG9G6dWvs27dP71JE+PvvvzF16lRcf/31aN++Pfr27Yu1a9eWec+ff/6JZ599Fn369EGHDh3Qr18/fPzxxzpVTFWxY8cOpKWl6V0GEZFuAvQugIiI6q+kpCT88ssvCAhw/9fR7Nmz8dNPP6Ffv36Ii4vDtm3b8MILLyA4OBh33HEHAGDKlCkoKCjAkCFDEBYWhnfffRePPvooli1bhiuuuMIbX4eqaceOHVi9ejUeeeQRvUshItIFmzEiItKNoigIDg72+L67774bL774IoxGIwCgf//+6NOnDz788ENXM/bUU0+hffv2rnluvfVWdOvWDZs3bxbVjBUUFCAsLEzvMnyOzWaDw+FAUFCQ3qUQEdUZnqZIROTD0tPT8eyzz6J79+5o27YtbrrpJrzzzjvl3nfy5EmMHDkSHTp0QLdu3fDSSy/hyy+/ROvWrbFnz54y7129ejWuueYatGvXDgMGDMD3339f7louACgpKcGsWbNw7bXXom3btrjqqqswffp0lJSUVKn29evXo0+fPmU+53xVvWYsJSXF1YgBQEBAAAICAmC1Wl2vlW7EACAoKAgGg6HMe7wtPT0dzz33HHr27Im2bduid+/emDhxomsZOk9X/fbbb/HCCy+gW7duuOqqq1zzr169GjfddBPatm2Lnj17YtKkScjJySnzGUOHDsXNN9+MQ4cOYejQoWjfvj2uvPJKLFq0qFw9ZrMZzz33HLp3746UlBTceuuteO+998q8x5nJkiVLXOtK+/btMXz4cJw+fRqqqmLOnDno1asX2rVrh1GjRiE7O7vcZ+3YsQN33XUXOnTogI4dO+Khhx7CwYMHXdPHjh2L1atXAwBat27t+u/8GpYtW4Y+ffogJSUFhw8fBgB8/fXXrrE7d+6MUaNGuaYREUnCI2NERD4qIyMDgwYNgqIouPvuu2EymbBz5048//zzyMvLw7BhwwCcO5KSmpqKs2fP4t5770WDBg2wefPmck0YAKxZswaTJ09G586dMWzYMJw8eRKjR49GVFQUGjVq5Hqfw+HAqFGj8MMPP2DQoEFo2bIl/vzzTyxfvhx//fUX5s6d67b2t99+GxMmTEDHjh2RmpqKEydOYNSoUYiOjkZiYmKtl83KlStx4sQJjB49utL3zJw5E8XFxa4jZ96Wnp6OAQMGIDc3F4MGDUKLFi2Qnp6Obdu2oaioqMwRnkmTJsFkMmH06NEoKCgAAKSlpWH27Nno3r077rzzThw9ehRr167Fvn37sHbtWgQGBrrmt1gseOCBB3Dttdeib9++2LZtG2bMmIHk5GRXc1dUVIShQ4fi+PHjuPvuu9GkSRNs3boVY8eORU5ODlJTU8vU/+GHH8JqtWLo0KHIzs7G4sWL8fjjj+OKK67Anj178OCDD+LYsWNYtWoVXnnlFbz88suueTdt2oSxY8eiZ8+eeOqpp1BYWIi1a9firrvuwnvvvYcmTZpg8ODBOHPmDHbt2oXp06dXuAw3btyI4uJiDBo0CEFBQYiOjsbu3bvx4IMPokmTJnj44YdRVFSEVatW4c4778TGjRvRpEmTOsuQiEhzKhERed27776rJicnq7/88kul73nuuefUHj16qJmZmWVeHzNmjHrZZZephYWFqqqq6tKlS9Xk5GR1+/btrvcUFRWpN9xwg5qcnKx+8803qqqqanFxsXr55Zer/fv3V61Wq+u9GzduVJOTk9V77rnH9dqmTZvUiy++WP3uu+/KfPbatWvV5ORk9Ycffqi07pKSErVbt25qv3791OLiYtfr69evL/c5J06cUJOTk9V333230vHO9/7776utW7dWJ0yYUOl75s+fryYnJ6sLFiyo8rh17ZlnnlEvvvjiCjN2OByqqv5vPbjzzjtVm83mmm42m9VLL71UHT58uGq3212vr1q1Sk1OTlbfeecd12v33HOPmpycrL733nuu14qLi9UePXqojzzyiOu1ZcuWqcnJyer777/veq2kpEQdPHiw2qFDBzU3N1dV1f9lcsUVV6g5OTmu97722mtqcnKyeuutt5ZZf5544gn10ksvdWWdl5endu7cWR03blyZ73z27Fn1sssuK/P6pEmT1OTk5HLLx1lDp06dVLPZXGZav3791G7duqlZWVmu13777Tf14osvVp955plyYxER+TKepkhE5INUVcXHH3+M3r17Q1VVZGZmuv7r2bMncnNzceDAAQDAl19+iYSEBFxzzTWu+YODgzFo0KAyY+7fvx/Z2dkYNGhQmRtm3HLLLYiOji7z3q1bt6Jly5Zo0aJFmc92XntV0VG30p9jNpsxZMiQMkd/br/9dkRGRtZ8oQA4fPgwnnvuOVxzzTWYOHFihe/ZvXs3Zs6ciaFDh+Khhx6q1efVlMPhwCeffIJ//etfSElJKTddUZQyfx40aFCZ0zB3794Nq9WKe++9FwbD//6qHjhwICIiIrBjx44y84eFhaFfv36uPwcFBSElJQUnTpxwvbZz5040bNgQN998s+u1wMBADB06FAUFBfjuu+/KjHnDDTeUyatdu3YAzl2LV3r9adeuHaxWK9LT01215+Tk4Kabbiqz7hgMBrRv397tunO+6667DiaTyfXnM2fO4LfffsPtt9+OmJgY1+sXX3wxunfvXm65EBH5Op6mSETkgzIzM5GTk4P169dj/fr1lb4HOHe9WLNmzcr9wG/WrFmZP586darC1wMCApCUlFTmtWPHjuHw4cPo1q1bhZ9tNpsrrd35ORdccEGZ1wMDA9G0adNK56uK//73v7BarZg4cWKZJqW0Dz74AOHh4XjmmWc8jme3213LsbqMRmOZRqG0zMxM5OXl4aKLLqrSWOefWudchi1atCjzelBQEJo2bYqTJ0+Web1Ro0bl8o+OjsYff/zh+vPJkydxwQUXlFtuLVu2LPOZTuefTupszCp73WKxoGnTpvjrr78AoNxpj04REREVvl6RypbLhRdeWO69LVu2xFdffcUboBCRKGzGiIh8kMPhAHDuKMTtt99e4XucNzvQ6vOTk5Px7LPPVji99PVl3uS8UUR8fLzb98TExFTprnunT58uc0SxOpKSkvDZZ5/VaN7zVeWOku6UPqpWVyobs7ImWFXVMv+fPn06GjZsWOVxKxISElLl9xIRScRmjIjIB5lMJoSHh8PhcKB79+5u35uUlIRDhw5BVdUyR0eOHz9e5n2NGzd2vV76Vu82mw0nT54s09w1a9YMv//+O7p161buiIsnzs85duxYmSNrVqsVf//9Ny6++OJqjVda586dXT/2K3PVVVfhkksuqdJ4DRs2xFtvvVWjWtw1UCaTCREREWXuHlgdzmV45MiRMkcTS0pK8Pfff3tcJyqSlJSEP/74Aw6Ho0xDdeTIkTKfWVvOeuPi4jzWWdN16+jRo+WmHTlyBLGxsTwqRkSi8JoxIiIfZDQacf3112Pbtm34888/y00vfWpdz549kZ6ejk8//dT1WnFxMTZs2FBmnrZt2yImJgYbNmyAzWZzvf7hhx/CYrGUeW/fvn2Rnp5ebgzg3F35nHf8q0jbtm1hMpmwbt26MrfBf++998rdlr26LrvsMtx9991u33PVVVfhtttuq9J4wcHB6N69e43+u+yyyyod12AwoE+fPvj888+xb9++ctM9NZTdu3dHYGAgVq5cWea977zzDnJzc8vc/r6qevXqhbNnz+K///2v6zWbzYaVK1ciLCwMXbp0qfaYFbnyyisRERGBBQsWVPhYgdLrbmhoKABUeb2Ij49HmzZtsGnTpjLz/Pnnn9i1a1eNlgsRkZ54ZIyISEfvvvsuvvzyy3Kv33vvvXjyySexZ88eDBo0CAMHDkSrVq1gsVhw4MABfP311/j2228BAIMHD8aqVavw5JNP4t5770XDhg3x4Ycfuo7cOI8+BAUF4ZFHHsGUKVOQmpqKvn374uTJk9i4cWO568j69euHLVu2YOLEidizZw86deoEu92OI0eOYOvWrVi8eHGFN6YAzl0b9vjjj2PChAlITU3FjTfeiL///hsbN26s9TVjM2fOxHvvvVfmWqjz/ec//8HJkyfr7BTCmnriiSewa9cuDB061PV4gLNnz2Lr1q1Ys2YNoqKiKp3XZDJhxIgRmD17Nh544AH07t0bR48exZo1a1zPB6uuwYMHY/369Rg7diwOHDiApKQkbNu2DT/++COee+65al3L5U5ERAReeOEFPPPMM7jjjjtw4403wmQy4dSpU9ixYwc6deqECRMmAAAuvfRSAMDUqVPRs2dPGI1G3HTTTW7Hf+aZZ/Dggw9i8ODBGDBggOvW9pGRkXj44Yfr5DsQEXkLmzEiIh2tXbu2wtfvuOMONGrUCG+//TbmzJmD7du3Y+3atYiJiUGrVq3w1FNPud4bHh6O5cuXY+rUqVixYgXCwsJw2223oWPHjnjkkUfKnE53zz33QFVVvPXWW3jllVdw8cUXY968eZg6dWqZ9xkMBsyZMwfLli3D+++/j+3btyM0NBRNmjTB0KFDK7yBQmmDBw+G3W7HkiVLMH36dCQnJ2PevHl48803a7nE5EhISMCGDRvw5ptv4sMPP0ReXh4SEhLQq1evKl0L9cgjj8BkMmHVqlV4+eWXER0djUGDBuGJJ54o84yxqgoJCcHKlSsxY8YMvPfee8jLy8OFF16Il19+uc6fxXbLLbcgPj4eCxcuxJIlS1BSUoKEhAR07ty5zGddd911GDp0KD766CN88MEHUFXVYzPWvXt3LF68GLNmzcKsWbMQEBCALl264Omnn651s09E5G2K6ulcCSIiEmnZsmV4+eWXsXPnTiQkJFT6PofDgW7duuHaa6/F1KlTvVghERFR/cZrxoiI/EBRUVGZPxcXF2P9+vVo3rx5mUasuLi43PVKmzZtQnZ2Ni6//HKv1EpERETn8DRFIiI/8PDDD6Nx48a4+OKLkZeXhw8++ABHjhzBjBkzyrzvp59+wssvv4wbbrgBMTEx+PXXX/HOO+8gOTkZN9xwg07VExER1U9sxoiI/EDPnj3xzjvv4MMPP4TdbkerVq3w+uuv48YbbyzzvqSkJDRq1AgrV66ExWJBdHQ0+vXrh6eeeqpKz+UiIiKiusNrxoiIiIiIiHTAa8aIiIiIiIh0wGaMiIiIiIhIB7xmrBJ79+6Fqqo1epYLERERERH5D6vVCkVR0LFjxzodl81YJVRVLXf7ZyIiIiIiqn+06gvYjFUiMDAQqqqibdu2UBRF73KoilRVhdVqRWBgIHMThtnJxNxkYm5yMTuZmJtMpXPbv3+/Jp/hU83YsWPHsGTJEvz88884ePAgWrRogc2bN1dp3vT0dMycORM7duxAQUEBkpKSMGrUKNx6660aV01ERERERFR9PtWMHTx4EDt27ED79u3hcDiqfDjwzJkzGDx4MC688EJMmTIFEREROHjwIEpKSjSumIiIiIiIqGZ8qhnr3bs3+vTpAwAYO3ZslQ8Hvvrqq2jUqBEWL14Mo9EIAOjWrZtmdRIREREREdWWT93a3mCofjl5eXnYsmUL7rrrLlcjRkRERERE5Ot8qhmriQMHDsBqtSIgIAD33HMPLr30UvTo0QOvvvoqrFZrrcbmBZYy8XEEcjE7mZibTMxNLmYnE3OTSevcfOo0xZrIyMgAAIwbNw6DBg3Cww8/jF9++QWzZs2CwWDAk08+WevPOP/aNUVRyrxmt9tdjZ+zgavserfz5z1/Wm3m5bi1GzcwMBAGg6HCJtzfvqte41Z1Xk/bXF3WJG1cX6zJXW6+XG9dj+uLNVVl3Irew2UoY9z6vs1JG9c5ry9tc9LG9bWa6oL4ZszhcAAAunfvjrFjxwIArrjiCuTn52Pp0qUYPXo0QkJCajS2qqooKSkp8+PcYDAgIODcYispKcHZs2eRk5Pjmq7VSiZtXD1rqk29RqMRsbGxiIqKcr2/dOYVHW11/ouJ3W53rY9ORqMRRqMRqqrCZrOV+zznvDabrVxdAQEBUBQFDocDdru9wnErqqk241bluyqKUuF3dY5b0Xd1jquqaqXjqqqK4uJiKIpSZpurzTJ0TnO3DOs6G0/LMCgoCEDF60tVxnW3DCsbty6WYWXjGgwGWK1WqKpaJjetlqFe67e7ZShxHxEQEFBhPZ7G1XMfAWi3fkvaRwBw3aCsot8nvraP8PYy9NV9hNFohN1uh91uL5Obc1zAt/YREn9HANosQ+d3PP/vuboivhmLiooCcK4BK61bt26YP38+jh07htatW9d4fHfPgzCbzcjNzUV8fDzCwsLK/Ij0l45f2rjO+SrKzN24qqrCbrcjJycHGRkZsFqtSExMLPc+d4eqS+/YKvpsd/M6d1wVMRgMbq+n9Oa4zmVY0+/qaTk4p1eWnxbfVa9s3C3D2tSr1XroblxVVd3uK+vL+l3ZuE6+to9wOByuHz91Na7W+wg9lqEv7iOc89ZkX6nHPoJ/B57jcDjc7iu5DP/3Hl/ZR6iq6nFfWVvim7FWrVq5nV5cXFyr8c//V3onh8MBi8WC+Ph4xMXF1eozqO44D/9XlpsnkZGRCA4ORkZGBhISEspt0O7GrOm0+jSuu+mlc3PXTNd1TdLG9bWaPOVWm5okLQdfrcldbs7pdZ2bXvPWl3G5zckc11e3OWnj+mpNtSH+Bh5JSUlITk7G7t27y7y+e/duhISEeGzWasp5iDQsLEyT8Uk/4eHhlR4GJyIiIiKqKz51ZKywsBA7duwAAJw8eRJ5eXnYunUrAODyyy+HyWRCamoqTp06he3bt7vmGzNmDP7973/jxRdfxNVXX419+/Zh6dKluP/++zVvlrTslEkfzJSIiIiIvMGnmjGz2YzHHnuszGvOP69YsQJdu3at8GLB3r17Y+bMmZg7dy7Wrl2L+Ph4PPLII3jooYdqVQ9/lMvE3OTiswJlYm4yMTe5mJ1MzE0mrXPzqWasSZMm+OOPP9y+Z+XKlRW+fuONN+LGG2+s85rqww/7tLQ0zJ49u9zrF110ETZv3ozWrVvjmWeewf333w8A2LhxIwIDA3HLLbdUafyioiIsXboUmzdvxokTJxAaGopOnTph5MiR6NChQ5n3Dh06FGFhYViwYEGl4/3000+YPXs2fvvtN+Tm5qJBgwZo27Yt7r//frRv377S+apbN3mXoij8i0og5iYTc5OL2cnE3GTyRm4+1Yz5Iq1uY+lrQkJCsHz58nKvAcD69evRuHFj1+vvvfcewsLCqtTUFBQUYNiwYTh48CAeeOABdO7cGdnZ2Vi1ahXuuusuzJgxo1pN9A8//IB7770XV155JSZNmoTw8HAcO3YMn3zyCX755Re0a9fO9d7zc6tO3eR9tb35CumDucnE3ORidjIxN5lK56YVNmNuaPmAN19jMBjKHaVyquz1qnjzzTfx888/Y/ny5WUeP9CnTx8MHz4czz//PDp37oz4+Pgqjbd27VokJSVhzpw5rn+p6NatG4YMGeJ6rkR9aaD9kc1m0/xJ91T3mJtMzE0uZicTc5NJ69zE302RtNe6dWssWbIEwLnTCL/99lt88cUXaN26NVq3bo20tLQK5ysqKsKGDRvQo0ePcs+BMxqNePTRR1FQUIC33367yrXk5OTAZDJVeMjY3bMuqlM3EREREZE38MgYuZz/VHKj0VjuCNPEiRPx9NNPIyQkBP/5z38AAI0aNapwvP3796OgoAD/+te/Kpx+2WWXISYmBt9//32Va7z00ksxd+5cvPHGG7jlllvQsmXLKs1XnbqJiIiIiLyBzRgBOHdt16WXXlrmtenTp6Nfv35lXmvVqhUiIiIQFhbm8fTF9PR0AEBiYmKl70lMTMQ///xT5Trvv/9+/Pzzz5g3bx7mzZuHmJgY9OzZE3feeSc6d+5c6XzVqZuIiIiIyBvYjLlR0+uOrH+dgsOSW8fVeGaIjkRg88ae31iBkJAQrFq1qsxrTZs2rYuy6lRERASWLl2KX375BV988QV++OEHbNu2DR999BGmTJmCAQMG6F0i1QKv9ZOJucnE3ORidjIxN5m0zo3NmAfVDcBuzsbxrncC/38zCa8yGtH8wCYY42KqPavBYEBKSkqdlpOQkAAAOH36dKXvOX36NC655JJqj92uXTvXnRNPnDiBoUOHYsaMGRg4cCB3dkIpisILmwVibjIxN7mYnUzMzbPCwkIUFhZWOj00NBShoaFerMg7ubEZq2PGuBg027NWtyNjNWnEtNK2bVuEhYXhiy++wNChQ8tN37t3L7Kzs92eXlgVTZs2xQ033IC33noLGRkZaNCgQa3GIyIiIiLvOnToEPbv3w8AsNvtyM/PR3h4uOumbW3btq3zAwe+gM2YBzW5TXpNTxWUIjAwEMXFxR7fFxISgkGDBmHZsmX47rvv0KVLF9c0h8OBWbNmISwsDAMHDqzyZ1fWbP31118ICgpCZGQkHA5Hhc/xqGrdpA9VVWGz2RAQEMCjm4IwN5mYm1zMTibm5lmrVq2QlJQEALBYLNi5cyd69OiB6OhoAPD6UTGgbG5aYTPmRn16zlh1tGjRAps2bcJnn32Ghg0bIj4+3nVK4vkee+wx7N27Fw899BAefPBB10OfV69eje+++w4zZswo94yxs2fPYuvWreXGuvrqqzFu3DjY7XZcd911aN68OfLy8rBt2zZ8/vnnSE1NRVBQUKW5Vadu0ge3OZmYm0zMTS5mJxNzc+/80xCDgoIQHR0Nk8mkY1Xa58ZmjKrtwQcfxPHjx/Gf//wHOTk5ePjhh/HII49U+N6wsDCsWLECS5cuxebNmzFv3jyEhoaiU6dOWL16NTp27FhungMHDuCxxx4r9/qOHTtw9913Y9OmTViwYAHOnj2LkJAQNGvWDC+++CJuv/32OqubiIiIiEhriso2vUL79u2DqqpISUmp8HByUVERjh49igsvvBAhISE6VEgVUVXVdWppTU8DYLb6UFUVVqsVgYGBPIVDEOYmE3OTi9nJxNyqJzMzE9u2bcP111+v65Gx0rk5r2er6+vWDHU6GhEREREREVUJmzE3+C8XMjE3uXjbX5mYm0zMTS5mJxNzk4m3ttcZf9jLwrzkYnYyMTeZmJtczE4m5iaTN3LjkTEPeEmdLM5rxpibPKqqwm63MzthmJtMzE0uZicTc5PJG7mxGXODG4xMzE0uu92udwlUA8xNJuYmF7OTibnJpHVubMZqiT/8/Q8zJSIiItJPdnY20tPTkZ2drXcpmmMzVkPOi/kKCgp0roTqWn5+PhRF4YW2RERERDrIy8tz/efveAOPGjIajYiJicGZM2cAnHu4MS/O1F9NnzOmqipsNhtycnKQk5ODmJgYGI1GDSslIiIioooUFJVAVVUUFJXoXYrm2Iy54enHfKNGjQDA1ZCRb3A2YzVhNBqRmJiI6OjoOq6KqoINsEzMTSbmJhezk4m5VU1OXjE27/oLRruKzbv+wiWXpCAqIli3erTOjc2YB+5+1CuKgsTERMTHx8NqtXqxKtJCQEAAjEYjj3DqRFEU/kUlEHOTibnJxexkYm5Vd9qcjxOnc9E8DDhxOhf/mAt0a8a8kRubMQ+qcpTFaDRyA/MRNT1NkfTH7GRibjIxN7mYnUzMreoS48LRNDESsABNEyPRKC5Mt1pK56YV3sDDDd5VTyabzaZ3CVRDzE4m5iYTc5OL2cnE3KomKiIYN/dojgCjgpt7NNf1FEVA+9zYjBERERERkU8o+v4ATGNn47KdvyMsJEjvcjTHZoyIiIiIiHRlO5mO9JGTcbLvSBiLrEjv2AoRERF6l6U5XjNGRERERES6cOQVIHv2GmTPXQdDRDgavv4fWK/vipBPPkFMTIze5WmOzZgbvMBSJuYmF7OTibnJxNzkYnYyMbeyVIcDuRu2IfPFhXBk5SB65CDEPj4UhogwZGZm6l2ei9a5sRnzgBuOLIqiIDAwUO8yqAaYnUzMTSbmJhezk4m5lVX4zS8wj5uF4p//QHi/3oibMBKBzRL1Lqscb+TGZoyIiIiIiDRnPXYK5knzkP/hFwjucDEafzgHoVe007ssXbEZ80DrZwtQ3VJVFTabDQEBAcxNGGYnE3OTibnJxexkqu+5OXLzkfX6SmQv2ACjKRrxs59HxMDroBh8+16CpXPTCpsxN/icMZmYm1zMTibmJhNzk4vZyVQfc1PtduSu+S8yX14ER14BYh+9GzEP3wVDeKjepVWZ1rmxGSMiIiIiojpV8OUPMI+fjZIDhxAx4FrEjRuBgKQEvcvyOWzGiIiIiIioTpQcPgHzpLko2PIVgru0RdLW+Qi57FKP8xUWFqKwsBAAYLFYUFJSAovF4poeGhqK0FA5R9Sqis0YERERERHVit2Si6zXlsOy+F0EJMQhfuFERNx2TZWvkTt06BD2799/biy7HUVFRdi1axeMRiMAoG3btkhJSdGsfr2wGXOjPl5g6Q+0vMiStMXsZGJuMjE3uZidTP6am2qzIWfFh8h8ZQnUohKYnroP0aMGwxAaXK1xWrVqhaSkpEqn63VUTOvc/HOtqENsyGRRFIWZCcXsZGJuMjE3uZidTP6aW8Fne5AxYTasfx5D5JC+MD33IAIaNajRWL54GqI3cmMz5gFvbS+LqqpwOBwwGAzMTRhmJxNzk4m5ycXsZPK33Er+/AvmiXNQ8Mk3COnWHgnbFyG4fWu9y6pzpXPTCpsxN+rjLUj9gd1u13SjIe0wO5mYm0zMTS5mJ5M/5GbPtCDr1bdgeWsTAprEI2HpFITffJVfNJiV0To3NmNERERERFQptcQKy9L3kPXaMqg2O0zjHkLMgwOgBAfpXZp4bMaIiIiIiKgcVVVRsH03zBPmwHr0JKLuuRmx/7kfAfEmvUvzG2zGiIiIiIiojOJfD8M8YTYKd3yP0F6XIWHJZARf2krvsvwOmzE3/Pn8V38m/Xzs+ozZycTcZGJucjE7maTkZjubhaxXliBn5YcIbN4YjVZNQ9h13evt72Ktc2Mz5kF9XfGkUhTFb5/j4e+YnUzMTSbmJhezk0lCbmpxCbIXvYPsmSsAg4K4SaMRPfx2KEGBepemG2/k5lMt+rFjxzBhwgT069cPl1xyCW6++eZqj7Fs2TK0bt0aI0aMqJOaeEdFWVRVdf1HsjA7mZibTMxNLmYnky/npqoq8j7aieM9hyJz6kJEDLoezfasRczIQfW6EQO8k5tPtegHDx7Ejh070L59ezgcjmp/8bNnz2LOnDmIi4urk3p8cYMhz6xWKwID6/fOQypmJxNzk4m5ycXsZPLF3Ip/+RMZ49NQtPsnhF1zBRJXTUNQ6wv1LsunaJ2bTzVjvXv3Rp8+fQAAY8eOxf79+6s1/6uvvorevXvj1KlTWpRHRERERCSe7Z8MZL68GLlr/4vAi5ohcd0MhF3TVe+y6iWfasZqc4Hc999/j08++QRbt27Fk08+WYdVERERERHJ5ygshmX+emS9sQpKSBAavPw4olJvheLj17P5M79Y8na7HVOmTMHIkSMRHx+vdzlERERERD5DVVXkb/oM5snzYPsnA9EP9Efsk8NgjInUu7R6zy+asTVr1qCwsBDDhg2r87Erum5MUZRKrydz3n3R3XSt5uW4cM1XWW61qbc283Jcz/M6p3l7m5M2rq/V5JxPi21O0nLw1Zo8Xfvsa/X6Yk2+Nq5zGrc5WeM66VFT4Q8HYB4/G8Xf7UfYDT3Q6O2ZCGrZVNwy1KMm52v15gYeNWE2mzFr1iy88sorCAoKqtOxFUWBzWYr85rBYHDd4tJqtZabx1mD3W6Hw+EoMy0gIACKosDhcMBut1c4rqqqFY7rvHCwonGNRiOMRiNUVS1Xr6IornltNlu5lUmrcavyXYHyy7Auxg0KCqp0GSqKUu3v6ilzPZahc9yKatIqG+d3rWwZOsd1twzdrd+KosBoNJabty7Wb3fL0JvrN+Cf+4jAwEBR+4iKxnV+1/q0j3DuK6XsIwDt1m9J+wjn/L62DP3pd0RF4zq/a232EUFBQSgpKalwXKDulyHOZCLrpUXIe/tjBLa5EA3XvYqQKzsBOLfO+9vvCECb9TsoKAh2ux2qqroat7okvhl788030bp1a3Tu3Bk5OTkAzi1Mm82GnJwchIWF1er5AO7unuJuWum/CM9nMBgqvT6u9EpR3XE9zetuOWg1rrvvCrhfhnU9rnMDqs131SMbf1qGeq3ftdnmtMqG+4hz/Gn9rmxcJy7D/72H+4hzuI/wPK4/rd+VjetUV8vQkV+I7DlrYZmzFoaIMDR47WlE3nUjlErGlrQM9dxHaNGIAX7QjB09ehTfffcdunTpUm5aly5dsGjRIvTq1atWn1HRwvcUiLvpWs3Lcc8dRrbb7TAajZW+x1++q8Rx3U33lJ2071pf9hFabnOSloOv1iRtX1mbeevLuNzmZI7rjW1OdTiQ987HME9dCLs5GzEjBiF2zFAYIsNrNW5dT9Nr3pqM6zyaVlmDVxfEN2PPPfec64iY00svvYSQkBA88cQTaN26dY3H1vL8UNJO6UPvJAuzk4m5ycTc5GJ2MmmZW9G3+5AxLg3Fe39D+C1XI27CKAQ2b6zJZ9U3Wm9vPtWMFRYWYseOHQCAkydPIi8vD1u3bgUAXH755TCZTEhNTcWpU6ewfft2AECbNm3KjRMVFYWwsDB07crnJRARERGRf7Ke+AeZk+chb9NnCGqXjMbvpyG0ewe9y6Jq8KlmzGw247HHHivzmvPPK1asQNeuXSu8WJCIiIiIqL5w5BUg681VsMxbD0NMJBrOehaRg2+AUotn9pI+fKoZa9KkCf744w+371m5cqXHcaryHiIiIiIiSVS7HbnrtiLzpYVw5OQhZvSdiHnkLhgiwvQujWrIp5oxX6PVXVNIW7W5eybpi9nJxNxkYm5yMTuZaptb4a69yBiXhpL9BxFxRx+Yxo9EYJOEOqqOKqP19sat2QM2ZLIoisLMhGJ2MjE3mZibXMxOptrkZj16EuZJc5H/0U4EX3YJkv47DyFd2tZxhVQRb2xvbMY80OoBb6QNVVXhcDg0fR4EaYPZycTcZGJucjE7mWqSmz0nD9mvr0D2wndgbBCL+HnjEXFHH14X5kWlc9MKmzE3eGt7mex2u6YbDWmH2cnE3GRibnIxO5mqmptqsyFn1WZkvrIEakERYp+4FzGjhsAQFuKFKul8Wm9vbMaIiIiIiHxAwRffwTxhNkp+O4KIQTcgbtxDCEhsqHdZpCE2Y0REREREOio5dBzmiXNQ8PFuhFyegqSPFyKkY/ln6ZL/YTNGRERERKQDe1YOsmYsg2XpRgQkNkTC4skIv/VqXg9Yj7AZc4Mbgkw8j14uZicTc5OJucnF7GQqnZtqtSFn2SZkvvoW1BIrTGMfQPSIgTCEBOtYIVVE6+2NzZgHbMhkURSFz18RitnJxNxkYm5yMTuZnLmpqor87V/DPHEOrIeOI/Lum2Aa+wACEuL0LpEq4I3tjVsz+R0+jkAuZicTc5OJucnF7GQq/u0IzBPnoPDzbxHSoyMSFkxEcMpFepdFHmi9vbEZc0NVVe7whFFVFVarFYGBgcxNGGYnE3OTibnJxezksZuzkfnKEuSs+AABTRPRaPmLCOt7JfMToPT2phU2Y0REREREdUwtscKy5F1kzVgOAIh+7kGYHuJ1YVQWmzEiIiIiojqiqioKtn4F88S5sB47hajUWxH79HA4osOhaHiEhWRiM0ZEREREVAeK9x9Cxvg0FH31I0Kv7oKE5S8iuE0LqKoKh9Wqd3nkg9iMERERERHVgu1MJjJfXoTc1R8hsGVTNFozHWF9ruB1YeQRmzE3uAHJpOVFlqQtZicTc5OJucnF7HyHo6gYlgVvI+uNlVACjGjw4qOIGnYblMDyP7GZm0xa58ZmzAM2ZLIwL7mYnUzMTSbmJhez8w2qqiL/gy9gnjwPtlNnED38DsQ+NQzG2KgK38/cZPJGbmzGPOCt7WVRVRV2ux1Go5G5CcPsZGJuMjE3uZid/op//gMZz89C0Z5fEHZddySun4GgVs3czsPcZCqdm1bYjLmhqqreJVANOBwOTTca0g6zk4m5ycTc5GJ2+rD9k4HMqQuQu34rgtq0QOLbMxF2dZcqz8/cZNI6NzZjRERERESVcBQUIXveOmTPWg0lNBgNXn0SUffcDCWAP6Op9rgWERERERGdR1VV5G38BObJ82E/m4nohwYgdsy9MEZH6l0a+RE2Y0REREREpRR9fwAZ42ah+IdfEX5TL8RNGIXAFk30Lov8EJsxN3iBpUw8H1suZicTc5OJucnF7LRj/TsdmVPmI2/jJwhqexEab5qF0B4d62Rs5iaT1rmxGfOADZksiqJwZycUs5OJucnE3ORidtpw5BUgO20NsueuhSEyAg3fGIvIITdAqaNlzdxk8kZubMY84K3tZVFV1ZUZc5OF2cnE3GRibnIxu7qlOhzIXb8VmS8uhCM7F9GjBiP2sXtgiAir289hbiKVzk0rbMbc4K3tZbLZbHzKvVDMTibmJhNzk4vZ1Y3Cr3+GeXwain/+AxG39YZp/EgENkvU7POYm0xa58ZmjIiIiIjqDeuxUzBPmof8D79AcMc2aLx5DkK7ttO7LKqn2IwRERERkd9z5OYj6/WVyF6wAUZTNOLnPI+IAddBMRj0Lo3qMTZjREREROQ3CgsLUVhY6Pqzarej5N1PUfjGKqj5hYj492A0fPxeGMJDdayS6Bw2Y27wAkuZmJtczE4m5iYTc5OL2bl36NAh7N+/HwAQ/vtxNNv4FSL/yUZG52ScuOUKtL7yCiTo0IgxN5m0zo3NmAfccGRRFIUXxwrF7GRibjIxN7mYnWetWrVCI6uCwunLYP10D3IuiIfy1kRc1L0TLgIQGqpPI8bc5PFGbmzGiIiIiMgv2LNzkf/aMuQs2YiAhDhg6r+xo+Af3HpJC5hMJr3LIyqHVyx6wNvby6KqKqxWK3MTiNnJxNxkYm5yMbuKqTYbLEvfw/GudyJnxYcwPXUfmu5ejfxulyIvPx95eXn61sfcRPJGbjwy5gY3GJmYm1zMTibmJhNzk4vZlVXw2R5kTJgN65/HEDmkL0zPPYiARg3OTSsqgaqqKCgq0blK5iaV1rmxGSMiIiIicUr+/AvmCXNQ8Ok3COnWHgnbFyG4fWvX9Jy8Ymze9ReMdhWbd/2FSy5JQVREsI4VE5XHZoyIiIiIxLBnWpA5fSlylr2PgKYJSHhrKsJv6lXupmunzfk4cToXzcOAE6dz8Y+5gM0Y+Rw2Y0RERETk89QSKyxL30PWjLeg2h0wjXsIMQ8OgBIcVOH7E+PC0TQxErAATRMj0SguzMsVE3nGZswN3tZeJt46Vi5mJxNzk4m5yVXfslNVFQUf74Z5wmxY/zqFqKG3IPY/9yOgYazb+aIignFzj+bYvu039O3RXPejYvUtN3/BW9vrjA2ZLMxLLmYnE3OTibnJVd+yK/71MMwTZqNwx/cIvaozEt6aiuBLWlZ5/rCQICiKgrCQio+eeUt9y81feCM3NmMeqKrKDUgQVVVht9thNBqZmzDMTibmJhNzk6u+ZGc7m4WsV5YgZ+WHCLwwCY1WT0PYtd2r/Z0jIiJc/+mpvuTmb0rnphU2Y27wFqQyORwOTTca0g6zk4m5ycTc5PLn7NTiEmQvegfZM1cABgVxk0YjevjtUIKqfqpYYWEhCgsLAZw7shEbGwtFUZCZmQkACA0NRWhoqCb1u+PPufkzrXNjM0ZEREREulJVFfmbd8A8eR5sJ9IRfd9tiH36PhhN0dUe69ChQ9i/fz8AwG63o6ioCLt27XL9oG7bti1SUlLqtH6immIzRkRERES6Kf75D2SMT0PR1z8j7JorkLj6FQQlN6/xeK1atUJSUlKl0/U4KkZUGTZjREREROR1tn8ykPnSIuSu24LA5AuQuG4Gwq7pWutx9ToNkagmfKoZO3bsGJYsWYKff/4ZBw8eRIsWLbB582a385w5cwbLli3Drl27cPz4cURGRqJLly544okn3P6rSFXwAkuZeD62XMxOJuYmE3OTS3p2jsJiWOatR9abq6CEBKHBtDGIuvcWKAE+9bO0zknPrb7SOjefWusPHjyIHTt2oH379nA4HFW6gcaBAwewfft29O/fH+3bt0dWVhbmzZuHgQMHYvPmzTCZTLWqiQ2ZLIqicGcnFLOTibnJxNzkkpydqqrI2/QpMifPhy3djOgH+iP2iVQYYyL1Lk1zknOrz7yRm081Y71790afPn0AAGPHjnVdfOnOZZddhi1btiCg1L+mdOrUCVdffTU2bdqE4cOH16om3tpeFlVVXZkxN1mYnUzMTSbmJpfU7Ip+/BXmcWko+m4/wvr2ROI7ryOoZVO9y/IaqbnVd6Vz04pPNWMGg6Ha80RFRZV7rVGjRjCZTDhz5kyt6uGt7WWy2Wx8yr1QzE4m5iYTc5NLUna2U2dgnroAeW9/jKBLWyJx4xsIu/IyvcvShaTc6H+0zs2nmrG6cvToUZjNZrRsWfUntFemooZMUZRKGzVn5+xuulbzcly45qsst9rUW5t5Oa7neZ3TvL3NSRvX12pyzqfFNidpOfhqTZ7+UdHX6vXFmnxtXOc0X9/mHPmFyJ6zFpY5a2EID0OD155G5F03QjEaXe/1pXq1HtfJl2qSOK63a3K+puUBGr9rxlRVxdSpUxEfH4+bbrqp1uNZrdYyhyYNBoPrlEir1Vru/UFBQQDOPdfC4XCUmRYQEABFUeBwOGC328tMc46rqmqF4zo78orGNRqNMP7/zs1ms5WZpiiKa16bzVZuZdJq3Kp8V6D8MqztuM7zes/PzfldFUWp9nf1lLkey9A5bkU1aZWN87tWtgyd47pbhp7Wb4fDUS67uli/3S1Db67fgP/tIwwGg6um0rn56j6ipuu3v+0jnPWe/5mextV7H6HV+i1tH1HRNqf3MnSOqzocKNj4KSwvL4Y904KYEYMQ/djdcIQGw+ZwAP//2fVtH+Hp90npZVjVcfk7ouy4gDbLEIDrXhbnZ1cX/K4ZS0tLwzfffIPFixcjLCys1uM5V5rKplWm9Ep+PoPBUOkpmaVXiuqO62ne0tfVeWtcd98VcL8Mazvu+bk5/1yb76pHNnouw/PVdhl6Wg4Gg6HSbU6rZahXNv64j6hsX1lf1u/KxnXy1X1EZbn54j5Cj2Xoi/sId9ucnvsI6/e/wjw+DcU//Y7wW66GafxIBF2YBFVV4e4WCPVtH1HZNuer+4i6HFfaPsLZnBkMBk0aMcDPmrENGzZgzpw5ePHFF9GtW7daj6coiuu/iqZ5mrcm02ozL8c9t9E4N5jK3uMv31XiuO6me8pO2netL/sILbc5ScvBV2tyl5u7v+Nq85l6zVtfxvXFbc56/DTMk+cj//3PENQuGY3fT0No9w61HlerevUY11e3OWnj6lGTu8zqgt80Y9u3b8cLL7yARx99FAMGDKizcbVc+FT3PP2rB/kuZicTc5OJucnlS9k58gqQ9cZKWOZvgCEmEg3TnkPkoOuh1OCGbP7Ol3KjqvNGbn7RjO3ZswdPPPEEBg4ciNGjR+tdDhEREZHfUu125K7dgsyXFsGRm4eYh+9EzMN3wRBR+8tDiOobn2rGCgsLsWPHDgDAyZMnkZeXh61btwIALr/8cphMJqSmpuLUqVPYvn07AODw4cMYPXo0mjdvjn79+uGnn35yjWcymdCsWbNa1aTVxXqkDefFme6ugyDfxOxkYm4yMTe59M6ucNdeZIxLQ8n+g4jofy1M40YgsEmC1+uQRu/cqGZK56YVn2rGzGYzHnvssTKvOf+8YsUKdO3atdydW37++Wfk5uYiNzcXd955Z5l5b7/9dkybNq3G9Wh5G0vSDnOTi9nJxNxkYm5y6ZGd9ehJmCfNRf5HOxF82SVI+u88hHRp6/U6JOM2J5PWuSkq14wK7du3D6qqIiUlhf+CIYjzlqfu7lZEvonZycTcZGJucnk7O3tOHrJmLodl4TsIiDfBNH4kIm6/hteFVRO3OZlK57Z//34AQEpKSp1+hk8dGSMiIiIi/ak2G3JWbUbmK0ugFhQh9slUxIwaAkNYiN6lEfkVNmNERERE5FLwxXfIGJ8G6+9HETn4BpiefwgBiQ31LovIL7EZc4OHkWXS8iJL0hazk4m5ycTc5NIqu5KDx2CeOAcF279GSNd2iN++CCEdLtbks+ojbnMyaZ0b1woP2JDJovWD+Ug7zE4m5iYTc5NLi+zsWTnIevUtWN56DwGN45GwZDLCb7ma60gd4jYnkzdyYzPmAW9tL4uqqnA4HDAYDMxNGGYnE3OTibnJVZfZqVYbcpZtQub0pVBtdpjGPoDoEQNhCAmuo2rJiducTKVz0wqbMTd4o0mZ7Ha7phsNaYfZycTcZGJuctU2O1VVUbD9a5hfmAvroeOIvOdmmMY+gIB4Ux1WSefjNieT1rmxGSMiIiKqJ0p+P4qM8Wko/OI7hPTshISFLyC4bSu9yyKqt9iMEREREfk5e0YWMqcvRc7yDxB4QWM0WvESwm7oyVPmiHTGZoyIiIjIT6klVlgWv4us15YDAOJeGIXo+/tDCQrUuTIiAtiMucV/LZKJ52PLxexkYm4yMTe5qpKdqqoo2PIlzC/Mg/X4aUTdeytMz9wHY4NYL1RIFeE2J5PWubEZ84ANmSyKovA5HkIxO5mYm0zMTa6qZFe87yAyJsxG0Vc/IvTqLmi04iUEXXyhlyqkinCbk8kbuXGt8IC3tpel9B0wmZsszE4m5iYTc5PLXXa2dDMypy1G7uqPENiqGRqtmY6wPlcwYx/AbU4mb9xZnc2YG7y1vUxWqxWBgTwXXiJmJxNzk4m5yXV+do6iYljmb0DWGyuhBAWiwUuPISq1H5RA/szzJdzmZNI6N26lRERERAKpqor8D76AefI82E6dQfTwOxD71DAYY6P0Lo2IqojNGBEREZEwxT/9DvP42Sja8wvCruuOxPUzENSqmd5lEVE1sRkjIiIiEsJ2+izMU+aj4J3tCGrTAolvz0TY1V30LouIaojNmBu8wFIm5iYXs5OJucnE3GRxFBQhe+5aZKetgRISjAavPomoe26Gwjv0icFtTiatc+MW7AE3HFkUReHFsUIxO5mYm0zMTQ7V4UDexk9gnrIA9rOZiBkxEDFj7oUxKkLv0qgauM3J5I3c2IwRERER+aCi7/YjY3wain/4FeE3XYW4iaMQeGGS3mURUR1iM+YBnzMmi6qqsNlsCAgIYG7CMDuZmJtMzM23Wf9OR+aU+cjb+AmCUi5C402zENqjIwBmJxVzk6l0blphM+YGnzMmE3OTi9nJxNxkYm6+x5FXgOy0NcieuxaGqAg0fGMsIofcAMVoLPM+ZicTc5NJ69zYjBERERHpSHU4kLt+KzJfXAhHdi6iRw1G7GP3wBARpndpRKQxNmNEREREOinc/RMyxqeh5Jc/EXFbb5jGj0Rgs0S9yyIiL2EzRkRERORl1r9OwTxpLvI370BwxzZovHkOQru207ssIvIyNmNu8AJLmbS8yJK0xexkYm4yMTd9OHLzkfX6CmQveBvGuBjEzx2HiP7XQjEYqjwGs5OJucmkdW5cKzxgQyaLoijMTChmJxNzk4m5eZ9qtyN39UfInLYYjrwCxD4+FDH/HgJDeGi1xmF2MjE3mbyRG5sxD3hre1lUVYXD4YDBYGBuwjA7mZibTMzNuwp2fg/zhNkoOXAYEYOuR9zzDyGgcXyNxmJ2MjE3mUrnphU2Y27wFqQy2e12TTca0g6zk4m5ycTctFdy+ATML8xFwdavENKlLZK2LUBIp0tqPS6zk4m5yaR1bmzGiIiIiOqQPTsXWa8tg2XJRgQ0aoCEhS8g/LbePCJCROWwGSMiIiKqA6rNhpzlHyBz+lKoxSUwPX0fokcOhiE0WO/SiMhHsRkjIiIiqqWCT/cgY0IarAePI/LOG2F69gEENGqgd1lE5OPYjLnB0wlk4vnYcjE7mZibTMytbpT8cRQZE+ag8LM9COneAQnzJiC4XbKmn8nsZGJuMmmdG5sxD9iQyaIoCp/jIRSzk4m5ycTcqq6wsBCFhYXlXndk5aBo9joUr92CgKaNkPDWVITf1Evz3w3MTibmJpM3cuNa4QFvbS9L6TtgMjdZmJ1MzE0m5lZ1hw4dwv79+wEARUVFMKefQbs/zuCCT38GVBWOB/qhxfiHoQQHeaUeZicTc5PJG3dWZzPmBm9tL5PVakVgYKDeZVANMDuZmJtMzK1qWrVqhaSkJKiqiqMr34NxyWeIzClE8MDrEPrYXQhvkui1RsyJ2cnE3GTSOjc2Y0RERESVCA0NheHISZgnzEbszh9wuqkJthdHo8ugW/UujYj8AJsxIiIiogrYzmYha9pi5KzaDOMFjbF94C043bAQ9pMlaJ1XjKgI3rKeiGqHt3UhIiIiKkUtLkFW2mocv3wI8j74HHGTH0bxmjfwdURDQFFw4nQu/jEX6F0mEfkBHhkjIiIiwrlrxfM374B58jzYTqQj+r7bEPv0fTCaomHIK0bTxEjAAjRNjESjuDC9yyUiP8BmzA1FUXjHG2EURUFgYCBzE4jZycTcZGJu5RX//Acyxqeh6OufEdbnCiSufgVByc3P3do+MxMA0LtDQ3z1JXBVh4awleQjMzMfoaGhCA0N9VqdzE4m5iaTN3JjM0Z+hzs6uZidTMxNJuZ2ju2fDGS+tAi567YgMPkCJK6fgbDeXV3TS9/aPi8vD4qi4PChP5H+zykAQNu2bZGSkuLVmpmdTMxNJq1zYzPmAZ8zJouqqrDb7TAajcxNGGYnE3OTibkBjsJiWOatR9abq6CEBKHBK2MQNfQWKOc94NV5a3sAsFgs2Lt3Lzp27Ijo6GgA8OpRMYDZScXcZCqdm1bYjLnB54zJ5HA4NN1oSDvMTibmJlN9zU1VVeRt+hSZk+fDlm5G9AP9EftkKozRkRW+v/RpiCaTCRdeeKE3y61Qfc1OOuYmk9a5+VQzduzYMSxZsgQ///wzDh48iBYtWmDz5s0e51NVFYsWLcKaNWuQmZmJNm3a4Nlnn0WHDh20L5qIiIhEKPrhADLGz0bxd/sRfuOVSJwwCkEtm+pdFhHVYz51a/uDBw9ix44duOCCC9CyZcsqz7do0SLMmjULw4YNw4IFC9CwYUMMHz4cJ06c0LBaIiIiksB2Mh3poybj5A0joRYUInHjG2i0/CU2YkSkO59qxnr37o0dO3Zg1qxZuPTSS6s0T3FxMRYsWIDhw4dj2LBh6NatG2bOnImYmBgsWbJE44qJiIjIVznyC5H5yhIc73Y3Cnd8j4Yzn0GTT5cg7MrL9C6NiAiAj52maDBUvzf88ccfkZeXh759+7peCwoKwrXXXovt27fXqh5eYCkTz8eWi9nJxNxk8ufcVIcDeW9/DPPUBbBnWhAzchBiHx8KQ2S43qXVCX/Ozp8xN5m0zs2njozVxJEjRwAALVq0KPN6y5YtcerUKRQVFdVqfDZksiiKwjsVCcXsZGJuMvlzboV7fsHJ60fgzMMvIuTyFDTbvQpx40f6TSPmz9n5M+Ymkzdy86kjYzWRk5ODoKAgBAcHl3k9KioKqqrCYrEgJCSkxuM7HI5yASiKUumdFp3vdTddq3k57jnOzCrKrTb11mZejut5XsB9dtK+a33ZRwDabXOSloOv1uQuN+e0in5kSFyGJcdOIXPKfOS//zmC2rdG4gdpCL2ivbhsaruv1KMmjut53tLz+dI2J21cb9fkjTuri2/GtKSqKqxWa5mNxmAwIOD/n0FitVrLzRMUFAQAsNvtcDgcZaYFBARAURQ4HA7Y7fYy05zjOj/zfIGBgZWOazQaYTQaoaoqbDZbmWmKorjmtdls5VYqrcatyncFyi/D2o5rNBpdtZ6/s3M+Qb2639VT5nosQ+e4FdWkVTbO71rZMnSO624Zelq/S0pKYDAYymRXF+u3u2XozfUb8L99hMFgcO0nS+fmq/uImq7f/raPCAgIKPd5VRlX731EReMqhcXISVsDy/wNUGIiYXr9GYQNuBaKwQCbzeaX+4iKtjlf3UdI+x2h1T7C+ftEVcs/v9YX9xFSf0dosQxtNhsMBkOF2dUF8c1YVFQUSkpKUFxcXOboWE5ODhRFcT2UsaacK01l0ypTeiU/n8FgqPT6uNIrRXXH9TSvc+Pw5rjuvivgfhnWdtzK/sWwNt9Vj2z0XIbnq+0y9LQcDAZDpducVstQr2z8cR9R2b6yvqzflY3r5Kv7iMpy88V9ROlxVbsdueu2IOulxXDk5iF69J2IefhOGCLCKpzXn/YR7rY5X95H1GRcf9xHVLbNcRn+7z11sY+o7rwVfVdnc3b+PxTXJfHNmPNasaNHj+Liiy92vX7kyBE0bty4VqcoAqjwNADn657mq8m02szLceH6V4vKctOjJo5btemespP2XevLPkLLbU7ScvDVmtzl5pzuS/vKqs5b+NWPyBg/GyX7DyKi/7UwjRuBwCYJmtTka5lzm5M5rq9uc9LG9dWaakN8M9apUydERERgy5YtrmbMarXi448/Rq9evXSujoiIiOqK9cjfME+ai/z/fongzpciact8hHSu2qNwiIh8kU81Y4WFhdixYwcA4OTJk8jLy8PWrVsBAJdffjlMJhNSU1Nx6tQp123rg4ODMWLECKSlpcFkMiE5ORlr165FdnY27r///lrVo2UXTNqpySMSyDcwO5mYm0yScrNbcpE1cwUsi95BQLwJ8QsmIuL2a+rt39OSsqP/YW4yaZ2bTzVjZrMZjz32WJnXnH9esWIFunbtWuHFgg8++CBUVcXSpUuRmZmJNm3aYMmSJWjatGmta6qvO3qpFEVxe34z+S5mJxNzk0lKbqrNhpyVHyLzlSVQC4thenIYokcNhiGsdpcgSCYlOyqLucnkjdwU1Rv3bBRo3759AICUlBSdKyEiIqp/Cj7/FhkTZsP6+1FEDukL0/MPIaBRA73LIqJ6SqvegC26G6qqanYbS9KG85an7u5WRL6J2cnE3GTy5dxKDh6DeeIcFGz/GiFXtEfCJ4sR3L613mX5DF/OjirH3GQqnZtW2IwRERGR7uxZOch69S1Y3noPAY3jkbBkMsJvuZo/XInIr7EZIyIiIt2oVhssb21C1qtLodrsMD37IKIfGgBDSLDnmYmIhGMzRkRERF6nqioKtn8N88Q5sB4+gch7boZp7AMIiDfpXRoRkdewGSMiIiKvKv7tCMwTZqPwi+8QemUnJCyahOC2rfQui4jI69iMucHz1GXS8iJL0hazk4m5yaRHbvaMLGS+sgQ5Kz5E4AWN0Wjlywi7vgf/vq0mbnMyMTeZtM6NzZgH/AtCFuYlF7OTibnJ5O3c1OISWBa/i6zXlgOKgrhJ/0b08DugBPHHaXVxm5OJucnkjdzYjHnAW9vLoqoq7HY7jEYjcxOG2cnE3GTyVm6qqqJgy5fImDgXthP/IOreW2H6z3AY42I0+0x/x21OJuYmU+nctMJmzA0+D1smh8Oh6UZD2mF2MjE3mbTOrXjfQWSMT0PRrr0I/dflSFz1MoJaX6jZ59Un3OZkYm4yaZ0bmzEiIiKqM7Z0MzJfXoTcNf9F4EXN0Gjtqwjvc4XeZRER+SQ2Y0RERFRrjqJiWOZvQNYbK6EEBaLBS48hKrUflED+1CAiqgz3kERERFRjqqoi//3PYZ48D7bTZxF9/x2Ifeo+GGMi9S6NiMjnsRlzgxdYysTzseVidjIxN5nqIrein36H+flZKPp2H8Ku74HEDa8hqFWzOqiO3OE2JxNzk0nr3NiMecCGTBZFUbizE4rZycTcZKptbrbTZ2GeuhB5G7YiqE0LJL7zOsKu6lyHFVJluM3JxNxk8kZubMY84K3tZVFV1ZUZc5OF2cnE3GSqaW6OgiJkz12L7LQ1UMJC0GDGU4i6+yYoAfw54S3c5mRibjKVzk0r3Hu6wVvby2Sz2fiUe6GYnUzMTabq5KY6HMh7dzvMUxfCnpGFmBEDEfP4UBijIjSukirCbU4m5iaT1rmxGSMiIqJKFX23HxnjZqH4x98QftNViJs4CoEXJuldFhGRX2AzRkREROVYT/yDzCnzkffepwhKuQiNN81CaI+OepdFRORX2IwRERGRiyOvAFmzVsMybx0MURFo+OZYRA6+AQpvPkBEVOfYjLnBCyxlYm5yMTuZmJtM5+emOhzIXbcFmS8uhCMnD9GjhiD20bthiAjTqUKqDLc5mZibTFrnxmbMA244siiKwotjhWJ2MjE3mc7PrXD3T8gYn4aSX/5ExO3XwDR+JAKbNtKxQqoMtzmZmJtM3siNzRgREVE9Zf3rFMyT5iJ/8w4Ed2qDpI/mIuTyFL3LIiKqN9iMecDnjMmiqipsNhsCAgKYmzDMTibmJpM9Jw/m15Yjd/G7MMbFIH7uOET0vxaKwaB3aeQBtzmZmJtMpXPTSq1GzszMRFZWFhRFQWxsLGJjY+uqLp/A54zJxNzkYnYyMTc5VLsduas/gvnlRVDzixD72D2IGX0nDOGhepdG1cBtTibmJpPWuVWrGSsoKMDWrVvx6aefYu/evcjKyiozPTY2Fh06dECfPn1www03ICyMF/0SERH5goKd38M8Pg0lvx5BxMDrEfnMfQi9oDH/lZ6ISEdVasaysrKwcOFCrFu3DiUlJWjdujWuueYaNG3aFFFRUVBVFTk5Ofj7779x4MABjB8/HlOmTMGQIUPw4IMPwmQyaf09iIiIqAIlh4/DPHEuCrbtQkiXtkjatgDBHdvAarXqXRoRUb1XpWasd+/euOCCC/DMM8/g+uuv99hcZWZmYtu2bdiwYQPWr1+PH3/8sU6KJSIioqqxZ+cia8ZbsCzZiIDEhkhYNAnh/f4FRVF4uhQRkY9Q1Crskb/88ktceeWVNfqA2syrp3379gEA2rZty1M4BFFV1XXTFeYmC7OTibn5HtVqQ87y95E5fSnUEitiHx+K6BGDYAgN/t97mJtYzE4m5iZT6dz2798PAEhJqds7zlbpyFhtmimJjVhp3GBk4U5OLmYnE3PzLfmffAPzxNmwHjyOyLtuhOnZBxGQEFfufcxNLmYnE3OTyRu51fo+jSUlJQgKCqqLWnwSb20vi6qqcDgcMBgMzE0YZicTc/MNJX8cRcaEOSj8bA9CundAwrwJCG6XXOn7mZtczE4m5iZT6dy0UuWR9+7di2uuuQbXXXcdPv/8c9frDzzwgCaF+QKeUy+T3W7XuwSqIWYnE3PTj92cjbP/eR0nrroP1iN/I2HZi2i8aZbbRsw1L3MTi9nJxNxk0jq3Kh8Ze+mll3DvvfdCVVU8/fTTeOSRR5CamsqGhYiIyMvUEissSzcia8YywKEibvwIRD/QH0qw/56pQkTkj6rcjAUEBCA1NRUA0L17dzz00EMICgrioVYiIiIvUVUVBdt2wTxxDqx/nULUvbcg9pn7EdAwVu/SiIioBmp0zVhycjJWrlyJ1NRU5Ofn13VNREREdJ7iA4dgHp+Gwi9/ROjVXZCw7EUEt2mhd1lERFQLVb5m7LLLLsOxY8dcf27atCmWL1+OFi389y8CHvWTyWg06l0C1RCzk4m5act2JhNnnpiOv3vfD9ups2i0+hUkbnit1o0Yc5OL2cnE3GTSOrcqPWesPnI+Z6yunyVARERUFWpxCbIXvo2smSugBBgR+9R9iB5+O5TAWt8ImYiIqkmr3qDO9uiFhYX46KOPUFJSgquuugpJSUl1NbSueGt7WUr/2wJzk4XZycTcaiczMxPffPMNrrjiCphMJgDnlmn+h1/APHkebH+fQfTw2xH79H0wxkbV2ecyN7mYnUzMTSZvHLOqUTP23HPP4ZdffsHmzZsBnHvW2KBBg3Dw4EEAQGRkJJYvX45LLrmk7irVAQ8aymS1WhEYGKh3GVQDzE4m5lY9hYWFKCwsBAD8/fff2L9/P5o0aQIAsO0/hOJX3kLJt/sRdm03JK59FUEXXaBJHcxNLmYnE3OTSevcatSM7dmzB7feeqvrz5s3b8bBgwcxY8YMXHzxxXjkkUcwe/ZszJ07t84KJSIi8geHDh3C/v37AQAWSw6Kiorww9ZPUbDzVzT49neoFyQiacNrCPvX5TpXSkREWqtRM5aRkVHmNMRPPvkEbdu2xc033wwAGDRoEJYsWVI3FRIREfmRVq1aISkpCXkFJViy6mOkfHsYbX88jsDwUIRNGIno1H4Ii4zQu0wiIvKCGjVjoaGhyM3NBQDYbDZ8++23uOeee1zTw8PDXdOJiIjof0JDQxESEoKMt99Hv/lrEFFYgG/bXIrLZz+HxLZN9S6PiIi8qEbN2KWXXooNGzaga9eu+Oyzz5Cfn4/evXu7ph8/fhxxcXF1VqReeIGlTMxNLmYnE3OrHsuuH5H1wlwYf/oD2RddiM8uT0R20/boFROIzMxMhIaGIjQ0VPM6mJtczE4m5iaT1rnVqBl7/PHH8cADD6B///5QVRXXX3892rVr55q+fft2dOrUqc6K1BM3HFkUReHFsUIxO5mYW9XZTqbDPGUB8t7djvykOBx/uB/+TohEwZl0NAnPxa4vPwcAtG3bVvPHqjA3uZidTMxNJm/kVqNmLCUlBVu2bMGPP/6IqKgoXH75/y4yzsnJwV133VXmNSIiovrKkVeA7NlrkD13HQwR4YiePgYxN1+JJkYj/v77b2zduhXdu3dz3VHRG0fFiIjIN9T4OWMmkwl9+vQp93pUVBRSU1NrXNDhw4cxdepU7N27F+Hh4ejXrx8ef/xxBAUFuZ0vKysLr7/+Onbu3Ins7Gw0adIEd999N+68884a1wLwOWPSqKoKm82GgIAA5iYMs5OJuVVOdTiQu2EbMl9cCEdWDqJHDETs40NhiAwv8762bduiSZMmrueMeaU25iYWs5OJuclUOjetVGnk06dPIzExsUYfUJ15LRYLUlNT0bx5c6SlpSE9PR3Tpk1DUVERJkyY4Hbexx57DEeOHMETTzyBxMRE7Ny5Ey+88AKMRiMGDRpUo9r5nDGZmJtczE4m5lZe4Te/wDw+DcU//Y7wW/+FuAkjEXhB43LvM5lMuPHGG3WokLlJxuxkYm4yaZ1blZqxa6+9FrfccgvuvPPOMteGufPjjz9i3bp12LJlC/bt21eledatW4f8/HzMnj0bMTExAAC73Y5JkyZhxIgRSEhIqHC+s2fPYs+ePXj55Zdxxx13AAC6deuGffv24aOPPqpxM0ZERFQd1mOnYJ48H/kffI7gDhej8YdzEHpF1f7eJCKi+qdKzdiaNWvwxhtvYNCgQWjcuDGuuOIKXHrppWjSpAmioqKgqipycnLw999/Y//+/fjmm2+Qnp6Orl27YvXq1VUuZufOnejWrZurEQOAvn37YuLEidi1a5er0TqfzWYDAERGRpZ5PSIiAgUFBVX+fCIioppw5OYj642VsCx4G4bYKMTPfh4RA6+DYjDoXRoREfmwKjVj7dq1w9KlS/Hbb7/h3XffxWeffYaNGzcC+N/dBp2H8BITE9GnTx/0798fbdq0qVYxR44cQf/+/cu8FhUVhYYNG+LIkSOVzpeYmIiePXti/vz5uPDCC9GoUSPs3LkTu3btwowZM6pVAxERUVWpdjty1/wXmS8vhiMvHzGP3IWYh++CIZw34SAiIs+qdTVamzZtMG7cOIwbNw7p6ek4cuQIsrOzAQAxMTFo0aJFpacSVkVOTg6ioqLKvR4dHQ2LxeJ23rS0NIwZMwY33XQTAMBoNGLcuHG4/vrra1yPoigVnida2evOaUDl55dqOS/HPcdoNFaaW23qrc28HNfzvID77KR91/qyjwC02+Z8fTkUfvUjzONno+TAIUQMuBZx40bA2Di+wjF87bsCQEBAgO7LsC7nrS/jAvV3m5M8LuCb25y0cb1dk6qqbnOrCzW+NUhCQkKtGq+6pKoqnn32Wfz111947bXX0LBhQ+zevRsvvfQSoqOjXQ1aTThPgXQyGAyuO6pYrdZy73fe9dFut8PhcJSZ5ryDjsPhgN1ur3BcVVUrHNf5jIOKxjUaja4d8/n1ln4+gs1mK7cyaTVuVb4rUH4Z1sW4BoOh0mWoKEq1v6unzPVYhs5xK6pJq2yc37WyZegc190ydLd+O+et7LvWZv12twy9uX4D/rmPUBRF1D6ionGd37Uq+4jCg8dgmboAhVt3IahTGzT6aA7CLz93XVhJSUmF4wK+t49QFAVWq1XMPgLQbv2WtI8w/P+pr762DP3pd0RF4zq/a21+RyiKImofUZNx/XEf4axXVbW5w7p292msgaioKOTm5pZ73WKxIDo6utL5vvjiC2zduhUffPABWrduDQDo2rUrzGYzpk2bVqtmzN0tSN09BK70Sn4+g8Hg2pmer/RKUd1xPc3r7racWo3r7rsC7pdhTcZ1/pivKDfnn2vzXfXIxtvL0N24tV2G7qY5d4CVbXNaLUO9svGXfYSqqnA4HG73lf6yftstuch6bTksi9+FMd6E+AUTEX5b7zLfW8o+wpmbs5muq3G13EfUZlzAf/YRqqq6/rW+JvtK/o6o+bi1Wb+rsq/kMvzfe3xlH+HMTVEUTRoxwMeasRYtWpS7Niw3Nxdnz55FixYtKp3v0KFDMBqNSE5OLvN6mzZt8Pbbb6OwsLBGD9F0dsCV7ezccTddq3k5btV+YPjLd5U4rrvpnrKT9l3ryz5Cy23OV5aDarMhZ+WHyHxlCdTCEpieHIbofw+BITRYt5pqO835D1fOf/Wty8/Ua976Mm592Ob8cVxf3eakjatHTTabzW0TV1s+dZunXr16Yffu3cjJyXG9tnXrVhgMBvTo0aPS+ZKSkmC32/HHH3+Uef3AgQOIi4urUSNGRERU8Pm3OPGv4cj4z+sIv7Y7mu1Zg9gnUytsxIiIiKrLp46MDRkyBCtXrsTo0aMxYsQIpKenY/r06RgyZEiZ69NSU1Nx6tQpbN++HcC5Jq5x48Z49NFHMXr0aMTHx+Orr77Ce++9h0ceeUSvr0NEREKVHDwG84TZKPjkG4Rc0R4J2xchuH1rvcsiIiI/41PNWHR0NJYvX44pU6Zg9OjRCA8Px4ABAzBmzJgy7zv/gsGIiAgsW7YMr7/+OmbMmIHc3Fw0adIEY8eOxT333OPtr0FERELZMy3IevUtWN7ahIAm8UhYOgXhN1+l2bUCRERUvymqlvdqFGzfvn0AgLZt2/IvYUGc52S7O5eefBOzk8lfclOtNliWvoesGW9BtdkR+8S9iH5wAAwh/nk6or/kVh8xO5mYm0ylc9u/fz8AICUlpU4/o8rXjB05cgSpqam47777cODAAdfro0ePrtOCfA03GFkURXF7pyLyXcxOJum5qaqK/I934USvVJgnzEbErf9Csz1rEfvI3X7biAHyc6vPmJ1MzE0mb+RW5WZs4sSJaN26NVq1aoV77rkH27ZtA4AyN9vwRzxwKIvzlr/MTR5mJ5Pk3Ip/O4LTg57EP3ePRUDjhmjy2RI0fO1pBMSb9C5Nc5Jzq++YnUzMTSZv5Fbla8aKi4vx3HPPAQB69+6NMWPG+H2Hzw1GJqvVquktSEk7zE4mabnZM7KQ+coS5Kz4EIHNG6PRypcRdn0Pv/77rCLScqP/YXYyMTeZtM6tys1Y6QehdevWDQsXLsS///1vtw97IyIi8hVqcQksi99F1mvLAYOCuEn/RvTwO6AE8ccRERHpo8qdVJMmTXDs2DHXn9u1a4e5c+dqUhQREVFdUVUVeR/txPGe98I8ZQEiBl6PZnvWImbkYDZiRESkqyofGRs4cCAiIyPLvNauXTvs3LmzzosiIiKqC8W//ImM8Wko2v0TQnt3ReKqlxHU+kK9yyIiIgJQjSNj9957L3bt2qVlLURERHXClm7Gmcem4e8+D8CekYVGa19F4/Uz2IgREZFPqfKRsfp4MwtFUerdBd3SKYqCwMBA5iYQs5PJ13JzFBbDMn89st5cBSUoEA1efhxR994KJbDKf93VC76WG1Uds5OJucnkjdz4txP5He7o5GJ2MvlCbqqqIn/TZzBPmQ/b6bOIfqA/Yp8cBmNMpOeZ6ylfyI1qhtnJxNxk0jq3ajVj9XElUlW1Xn5vqfiEe7mYnUy+kFvR3t9gHpeGom/3IeyGnkh8+zUEtWymSy1S+EJuVDPMTibmJlPp3LRSrWbs6aefxtNPP12l9yqKgl9//bVGRfmK+nhqpj9wOByabjSkHWYnk1652U6dgfnFhcjbsA1Bl7RA4ruvI6xXZ6/XIRW3N7mYnUzMTSatc6tWM9a9e3c0b95co1KIiIg8cxQUIXvOWmSnrYYSHoqGrz2NyLtvgsIfOUREJEy1mrHbbrsNt9xyi1a1EBERVUp1OJD37naYpyyA3ZyNmBEDEfP4UBijIvQujYiIqEZ4Aw8iIvJ5Rd/uQ8a4NBTv/Q3hN1+FuIn/RmDzxnqXRUREVCtsxtzgBZYyBQRwtZaK2cmkZW7WE/8gc8p85L33KYJSLkLjTbMQ2qOjZp9Xn3B7k4vZycTcZNI6N64VHrAhk4XPhpOL2cmkVW6OvAJkvbkKlvnrYYiKQMNZzyJy8A1QDIY6/6z6iNubXMxOJuYmkzdyq3Iz9vvvv2tZh8/ire1lUVXVlRlzk4XZyVTXuakOB3LXbUHmiwvhyMlD9KghiH30bhgiwuqgWnLi9iYXs5OJuclUOjet8MiYG7y1vUw2mw2BgYF6l0E1wOxkqqvcCnftRcb4NJTsO4iIO/rANH4kApsk1EGFVBFub3IxO5mYm0xa58ZmjIiIdGU9ehLmSfOQ/9EOBHdqg6SP5iLk8hS9yyIiItIcmzEiItKFPScP2a+vQPbCd2BsEIv4eeMRcUcfXhdGRET1BpsxIiLyKtVmQ87qj5A5bTHUgiLEjhmKmH/fCUNYiN6lEREReRWbMTd4gaVMBv6ruljMTqbq5Faw43uYJ6Sh5NcjiBh0A+LGPYSAxIYaVkeV4fYmF7OTibnJpHVubMY8YEMmi6IofI6HUMxOpqrmVnLoOMwT56Dg490IuTwFSR8vREjHNl6okCrC7U0uZicTc5PJG7lxrSC/w8cRyMXsZHKXmz07F1kz3oJlyUYEJDZEwqJJCO/3L+bsA7i9ycXsZGJuMvHW9jryxrMFqG6pqgqr1YrAwEDmJgyzk6my3FSrDTnL30fm9KVQS6ww/ed+RI8cBENIsI7VkhO3N7mYnUzMTabSuWmFzRgREdWp/E++gXnCbFgPHUfkXTfC9OyDCEiI07ssIiIin8NmjIiI6kTJ70eRMWE2Cj//FiE9OiJhwUQEp1ykd1lEREQ+i80YERHVij3TAsvMFchZ8SECmjZCo+UvIqzvlTwVh4iIyAM2Y0REVCNqiRXZi99F1mvLABWImzAS0fffASU4SO/SiIiIRGAz5gb/VVcmLS+yJG0xOxlUVUXB1q9gnjgX1mOnEHXvrYh9ZjgCGsbqXRpVA7c3uZidTMxNJq1zYzPmARsyWZiXXMxOhuL9h2CekIbCL39E6NVdkLD8RQS3aaF3WVRN3N7kYnYyMTeZvJEbmzEPeGt7WVRVhd1uh9FoZG7CMDvfZjuTicxpi5G7ajMCWzZFo9WvIOzabuem2WzMTRhub3IxO5mYm0ylc9MKmzE3VFXVuwSqAYfDoelGQ9phdr7HUVQMy8J3kPX6CigBRsRNfRTR990GJfDcXx+qqjI3oZibXMxOJuYmk9a5sRkjIqJyVFVF/odfwDx5HmwnzyD6vtsR+/R9MMZG6V0aERGR32AzRkREZRT//AcyxqWh6JufEXZtNySufRVBF12gd1lERER+h80YEREBAGz/ZCBz6gLkbtiGwNbNkbjhNYT963K9yyIiIvJbbMbc4AWWMvF8bLmYnT4cBUXInrcO2bNWQwkNRoPpTyDqnpuhBFTtrwjmJhNzk4vZycTcZNI6NzZjHrAhk0VRFO7shGJ23qeqKvLe+xSZk+fBdiYT0Q8NQOyYe2GMjqzyGMxNJuYmF7OTibnJ5I3c2Ix5wFvby6Kqqisz5iYLs/Ouou8PIGN8Goq/P4Dwm3qh8YRRCGzRpNrjMDeZmJtczE4m5iZT6dy0wmbMDd7aXiabzcan3AvF7LRnO5kO85QFyHt3O4LaXoTG772J0J6dajcmcxOJucnF7GRibjJpnRubMSKiesCRV4Ds2WuQPWctDJERaPj6fxB5Z18oPG2GiIhIN2zGiIgEKiwsRGFhIQDAYrFg79696NixI6KjowEAoaGhCA0NhepwIHfDNmROXQBHdi6iRw5C7ONDYYgI07N8IiIiApsxIiKRDh06hP379wMA8vLy8M8//8BsNiMiIgIA0LZtW7TKV2EeNwvFP/+B8H69ETdhJAKbJepZNhEREZXCZswNXmApE3OTi9lVXatWrZCUlAQA+OnnfTh9+jRatkpGh/YpsJ9IR8mMlTj13y8R3OFiNP5wDkKvaKdZLcxNJuYmF7OTibnJpHVuPteMHT58GFOnTsXevXsRHh6Ofv364fHHH0dQUJDHedPT0zFz5kzs2LEDBQUFSEpKwqhRo3DrrbfWuB5uOLIoisKLY4VidtXjPA0xJ68Yn/10FkYH8OWev3HxZ/tQuHQjjKZoxM9+HhEDr4NiMGhWB3OTibnJxexkYm4yeSM3n2rGLBYLUlNT0bx5c6SlpSE9PR3Tpk1DUVERJkyY4HbeM2fOYPDgwbjwwgsxZcoURERE4ODBgygpKfFS9URE3nfanI+/T1rQ59jfSPnmSxSoDpgeuwcxo++EITxU7/KIiIjIDZ9qxtatW4f8/HzMnj0bMTExAAC73Y5JkyZhxIgRSEhIqHTeV199FY0aNcLixYtdD2fr1q1brWvic8ZkUVUVNpsNAQEBzE0YZlczcX/8idFbNsN0JgOHL22NLgsnIja5qdc+n7nJxNzkYnYyMTeZSuemFe3OXamBnTt3olu3bq5GDAD69u0Lh8OBXbt2VTpfXl4etmzZgrvuuqtOn5LN54zJxNzkYnZVl/vrIRwf8hQsdz+NsJhQbB14OQImDoXaIByZmZmuOy16A3OTibnJxexkYm4yaZ2bTx0ZO3LkCPr371/mtaioKDRs2BBHjhypdL4DBw7AarUiICAA99xzD/bu3YuYmBjcdtttePzxx3mOLhH5DbslF1mvLUf2ondQEhmKE6nX4nhyI2Smp+PwoT+R/s8pAOfuppiSkqJztUREROSOTzVjOTk5iIqKKvd6dHQ0LBZLpfNlZGQAAMaNG4dBgwbh4Ycfxi+//IJZs2bBYDDgySefrHFNFXXDiqJU2iU7Dz27m67VvBwXrvkqy6029dZmXo7reV7nNG9vc1LGVW025K7cjMxXlkAtKkHk4/fAeM+NSAgJxkX//5yxTp06ufahoaGhZcaRuM1JycaXa/L0L7q+Vq8v1uRr4zqncZuTNa6TL9UkcVxv1+R8TcujYz7VjNWUw+EAAHTv3h1jx44FAFxxxRXIz8/H0qVLMXr0aISEhNRobKvVWubcXoPB4Dpv1Gq1lnu/866PdrvdVZeT8zxhh8MBu91eZppzXFVVKxzXeXSvonGNRiOMRqPrvNbSSt8FxmazlVuZtBq3Kt8VKL8Mazuu8zTV83NzfldFUar9XT1lrscydI5bUU1aZeP8rpUtQ+e47pahp/Xb4XCUy64u1m93y9Cb6zdQs31E4RffwTJpHqwHjyNiSF9EPT0MxoQ41/TIyEhceOGFUBQFNpvNNa7z87XcRxgMBleupXPz1X1ETddvf9tHOOs9/zM9jav3PkKrvwOl7SMq2ub0Xob+8jtCq32Ep98ngG/tI6T+jtBiGQLn9hGqqs19JHyqGYuKikJubm651y0WC6Kjo93OB5xrwErr1q0b5s+fj2PHjqF169bVrscZUGUL3t3pj6VX8vMZDAYYKrnVdOmVorrjeprX3cWHWo3r7rsC7pdhTcd1jnl+bs4/1+a76pGNHsuwsnFruww9LYfg4OAyn1OdeWv6XfXKpir7iJI//4J54hwUfroHId3aI2HueAS3b+32X+j02Ec4fzxWtq+sL+t3ZeM6+do+IjAw0O2PC1/cR+ixDH1xH+Fum+PvCO3Gre367Wmb4zL833t8ZR+hqqrH3GrLp5qxFi1alLs2LDc3F2fPnkWLFi0qna9Vq1Zuxy0uLq5xTe52zu64m67VvBxX23F9sSZp4/piTb44riMrB1mvvgXLW5sQ0CQeCUunIPzmq1zz+NN39adxfbEmaeP6Yk3SxvXFmjiu79YkbVxv11SVv3dry6fuptirVy/s3r0bOTk5rte2bt0Kg8GAHj16VDpfUlISkpOTsXv37jKv7969GyEhIR6bNXe0PEeU6p6qqrDb7cxNIGYHqCVWZM/fgONd70TOui0wjXsIzXatQsQtV2v6F0FtMDeZmJtczE4m5iaTN3LzqWZsyJAhCA8Px+jRo/HVV1/h3XffxfTp0zFkyJAyzxhLTU3FtddeW2beMWPG4LPPPsOLL76IXbt2Yf78+Vi6dCmGDRuGsLCwGtXDDUam889fJjnqa3aqqiL/41040SsV5olzEHHrv9Bsz1rEPnwXlOAgvcvzqL7mJh1zk4vZycTcZNI6N586TTE6OhrLly/HlClTMHr0aISHh2PAgAEYM2ZMmfdVdMFg7969MXPmTMydOxdr165FfHw8HnnkETz00EPe/ApERNVS/OthmCfMRuGO7xHa6zIkLJmM4EtrfjSfiIiI5FBUHv6p0L59+6CqKlJSUnz29CAqz3mXHXc3XiHfVN+ys53NQtYrS5Cz8kMENm+MuMkPI+y67uK+e33LzV8wN7mYnUzMTabSue3fvx8A6vwZnj51ZIyIyN+pxSXIXvQOsmeuAAwK4iaNRvTw26EE8eH0RERE9Q2bMTf4LxcyVXZLU/J9/pydqqrI/2gnzJPmwnYiHVHD+sH0zHAYTZU/tkMKf87NnzE3uZidTMxNJq1zYzPmARsyWRRF4c5OKH/OrviXP5ExPg1Fu39C2DVXIHHVNAS1vlDvsuqEP+fmz5ibXMxOJuYmkzdyYzPmgZYPeaO6p6qqKzPmJos/Zmf7JwOZLy9G7tr/IvCiZkhcNwNh13TVu6w65Y+51QfMTS5mJxNzk6l0blphM+YG720ik81mc/uEdfJd/pKdo7AYlvnrkfXGKighQWjw8uOISr0VSoB/7nL9Jbf6hrnJxexkYm4yaZ2bf/4yICLSgaqqyN/0GcyT58H2TwaiH+iP2CeHwRgTqXdpRERE5IPYjBER1YGiH3+FeVwair7bj7AbeiLxnZkIatlM77KIiIjIh7EZIyKqBdupMzBPXYC8tz9G0CUtkPju6wjr1VnvsoiIiEgANmNu8AJLmZibXJKyc+QXInvOWmTPXgNDRBgaznwakXfdBKUe3i1LUm70P8xNLmYnE3OTSevc2Ix5wA1HFkVReHGsUFKyUx0O5L3zMcxTF8JuzkbMiEGIHTMUhshwvUvThZTcqCzmJhezk4m5yeSN3NiMERFVUdG3+5AxLg3Fe39D+C1XI27CKAQ2b6x3WURERCQUmzEP+JwxWVRVhc1mQ0BAAHMTxpezs574B5mT5yFv02cIapeMxu+nIbR7B73L8gm+nBtVjrnJxexkYm4ylc5NK2zG3OBzxmRibnL5WnaOvAJkvbkKlnnrYYiJRMNZzyJy8A1QDAa9S/MpvpYbVQ1zk4vZycTcZNI6NzZjRETnUe125K7bisyXFsKRk4eY0Xci5pG7YIgI07s0IiIi8iNsxoiISinctRcZ49JQsv8gIu7oA9P4kQhskqB3WUREROSH2IwREQGwHj0J86S5yP9oJ4IvuwRJ/52HkC5t9S6LiIiI/BibMTd4gaVMWl5kSdrSIzt7Th6yZi6HZdG7MDaIRfz8CYi4/RpeF1YN3OZkYm5yMTuZmJtMWufGtcIDNmSyKIrCzITydnaqzYacVZuR+coSqAVFiH3iXsSMGgJDWIjXavAH3OZkYm5yMTuZmJtM3siNzZgHvLW9LKqqwuFwwGAwMDdhvJldwRffwTxhNkp+O4LIwTfA9PxDCEhsqOln+ituczIxN7mYnUzMTabSuWmFzZgbvAWpTHa7XdONhrSjdXYlh47DPHEOCj7ejZCu7ZC0fRFCOlys2efVF9zmZGJucjE7mZibTFrnxmaMiPyePSsHWTOWwbJ0IwISGyJh8WSE33o1/3WSiIiIdMVmjIj8lmq1IWfZJmS++hbUEitMYx9A9IiBMIQE610aEREREZsxIvI/qqqi4JNvYJ44B9ZDxxF5900wjX0AAQlxepdGRERE5MJmzA2ewiQTz8eWqy6yK/n9KDImzEbh598ipGcnJCyYiOCUi+qgOqoMtzmZmJtczE4m5iaT1rmxGfOADZksiqLwOR5C1TY7e0YWMqcvRc6KDxHQtBEarXgJYTf05DasMW5zMjE3uZidTMxNJm/kxrXCA97aXpbSd8BkbrLUNDu1xArLkneRNWM5ACBuwkhE338HlOCgOq+RyuM2JxNzk4vZycTcZPLGndXZjLnBW9vLZLVaERgYqHcZVAPVyU5VVRRs/QrmiXNhPXYKUam3wvTMcBgbxGpcJZ2P25xMzE0uZicTc5NJ69zYjBGROMX7DyFjfBqKvvoRoVd3QcLyFxHcpoXeZRERERFVC5sxIhLDdiYTmS8vQu7qjxDYsikarZmOsD5X8JQPIiIiEonNGBH5PEdRMSwL3kbWGyuhBBjR4MVHETXsNiiB3IURERGRXPwlQ0Q+S1VV5H/wBcyT58F26gyih9+B2KeGwRgbpXdpRERERLXGZswNRVF4+pMwiqIgKIh30ZPo/OyKf/4DGc/PQtGeXxB2XXckrp+BoFbNdKyQKsJtTibmJhezk4m5yeSN3NiMEZFPsf2TgcypC5C7fiuC2rRA4tszEXZ1F73LIiIiIqpzbMY84HPGZFFVFXa7HUajkbkJY88vRNactciZsxZKaDAavPokou65GQofkunTuM3JxNzkYnYyMTeZSuemFf7KcYPPGZPJ4XBoutFQ3VIdDuRt/ATmKfNhP5uF6IcGIvaJe2GMitC7NKoibnMyMTe5mJ1MzE0mrXNjM0ZEuin6/gAyxs1C8Q+/IuzGKxH13IMIS27OfzUkIiKieoHNGBF5nfXvdGROmY+8jZ8gqO1FaLxpFkK6d4DVatW7NCIiIiKvYTNGRF7jyCtAdtoaZM9dC0NkBBq+MRaRQ26AYjTytGAiIiKqd9iMucFTpWQK4A0ffI7qcCB3/VZkvrgQjuxcRI8ajNjH7oEhIqzM+5idTMxNJuYmF7OTibnJpHVuXCs8YEMmC58N53sKv/4Z5vFpKP75D0Tc1hum8SMR2Cyx3PuYnUzMTSbmJhezk4m5yeSN3NiMecBb28uiqiocDgcMBgNz05n12CmYJ81D/odfILhjGzTePAehXdtV+n5mJxNzk4m5ycXsZGJuMpXOTStsxtzgNSwy2e12TTcacs+Rm4+s11cie8EGGONiED/neUQMuA5KFTJhdjIxN5mYm1zMTibmJpPWubEZI6I6odrtyF3zETJfXgxHXgFiH7sHMaPvhCE8VO/SiIiIiHwSmzEiqrWCL3+AeXwaSg4cRsTA6xA3bgQCGsfrXRYRERGRT/O5Y6WHDx/Gfffdhw4dOqBHjx6YPn06SkpKqjXGsmXL0Lp1a4wYMUKjKokIAEoOn8Dpe5/F6TsehxIWiqRtC5AwdzwbMSIiIqIq8KkjYxaLBampqWjevDnS0tKQnp6OadOmoaioCBMmTKjSGGfPnsWcOXMQFxdX63p4gaVMPB9be/bsXGS9tgyWJRsRkBCHhIUvIPy23rXeZpidTMxNJuYmF7OTibnJpHVuPtWMrVu3Dvn5+Zg9ezZiYmIAnLtobtKkSRgxYgQSEhI8jvHqq6+id+/eOHXqVJ3UxIZMFkVR+BwPDak2G3JWfIjMV5ZALSqB6en7ED1yMAyhwbUem9nJxNxkYm5yMTuZmJtM3sjNp1r0nTt3olu3bq5GDAD69u0Lh8OBXbt2eZz/+++/xyeffIInn3xSwyrJ1/EumNoo+HQPTlx9HzLGvo7wG3qi2Z41iB1zb500Yk7MTibmJhNzk4vZycTcZNI6N59qxo4cOYIWLVqUeS0qKgoNGzbEkSNH3M5rt9sxZcoUjBw5EvHxdXO9iqqq3HCEUVUVVquVudWhkj//wukhT+P0kKdgNEWjyfZFiH9zLAIaNajTz2F2MjE3mZibXMxOJuYmkzdy86njpTk5OYiKiir3enR0NCwWi9t516xZg8LCQgwbNqxOa6po4SuKUmkoztMa3U3Xal6OC9d8leVWm3prM6/Ece2ZFmS9+hZylr2PgCYJSFg6BeE3X6VZTc5p3t7mpI3razU559Nim5O0HHy1Jk8/IHytXl+sydfGdU7jNidrXCdfqkniuN6uyflavWnGaspsNmPWrFl45ZVXEBQUVKdjW63WMteNGQwG17mjVqu13Pudn2+32+FwOMpMCwgIgKIocDgcsNvtZaY5x3V24OcLDAysdFyj0Qij0QhVVWGz2cpMUxTFNa/NZiu3Mmk1blW+K1B+GdZ2XKPR6Br3/Ov9AgMDoShKtb+rp8z1WIbOcSuqqdbL0KHCsnQjMmcsA+wORD97PyKH3w4l+H/blrv1290y9LR+OxyOctnVxfrtbhl6c/0G/G8fYTAYXDWVzs1X9xGetuX6so9w1nv+Z3oatzbLsC72EVqt39L2ERVtc3ovQ3/5HaHVPsLT7xPAt/YReixDX9xHOL+Lw+GAqqrlsqsLPtWMRUVFITc3t9zrFosF0dHRlc735ptvonXr1ujcuTNycnIAnFugNpsNOTk5CAsLq/HFd86VprJplSm9kp/PYDBUemeW0itFdcf1NK+7ZaDVuO6+K+B+GdZ23PNzc/65Nt9Vj2y8tQxVVUXBx7uROXEOrH+dQuQ9N8P0n/thbBjrek9tl6Gn5WAwGCrd5rRahnpl44/7iMr2lb6wfldl3Pq6j6gsNz2WoV7rt7R9hLttzpf3ETUZ1x/3EZVtc1yG/3uPr+wjnM2ZwWDQpBEDfKwZa9GiRblrw3Jzc3H27Nly15KVdvToUXz33Xfo0qVLuWldunTBokWL0KtXrxrVpChKpTs7T/PVZFpt5uW4cP2rRWW56VGThHGLDxyCecJsFO78AaFXdUbCW1MRfElLr9bkKTtfX4beGtfXatJym5O0HHy1Jne5Oaf70r6yNvPWl3G5zckc11e3OWnj+mpNteFTzVivXr0wf/78MteObd26FQaDAT169Kh0vueee851RMzppZdeQkhICJ544gm0bt26RvVoueBJO+7+1YPKsp3NQta0xchZtRmBFyah0eppCLu2u27rPrOTibnJxNzkYnYyMTeZtM7Np5qxIUOGYOXKlRg9ejRGjBiB9PR0TJ8+HUOGDCnzjLHU1FScOnUK27dvBwC0adOm3FhRUVEICwtD165da1UTGzJZmFfVqMUlyF70DrJnrgAMCuImjUb08NuhBOn3FwWzk4m5ycTc5GJ2MjE3mbyRm081Y9HR0Vi+fDmmTJmC0aNHIzw8HAMGDMCYMWPKvK+iCwa1otXFeqQNVVVht9thNBqZWwVUVUX+5h0wT54H24l0RN93G2Kfvg9GU+XXZHqzNmYnD3OTibnJxexkYm4ylc5NK4qq5b0aBdu3bx9UVUVKSgo3GkGcd9lxd4FsfVX88x/IGJ+Goq9/RlifKxA3aTSCkpvrXZYLs5OJucnE3ORidjIxN5lK57Z//34AQEpKSp1+hk8dGSOiumf7JwOZLy1C7rotCEy+AInrZyCsd+1O3yUiIiKi2mMzRuSnHIXFsMxbj6w3V0EJCUKDaWMQde8tUGr4mAciIiIiqlv8VUbkZ1RVRd6mT5E5eT5s6WZEP9AfsU+kwhgTqXdpRERERFQKmzE3eE6vTFpeZOnrin78FeZxaSj6bj/C+vZE4juvI6hlU73LqrL6nJ1kzE0m5iYXs5OJucmkdW5sxjxgQyaLoij1cmdnO3UG5qkLkPf2xwi6tCUSN76BsCsv07usaqmv2UnH3GRibnIxO5mYm0zeyI3NmAe8tb0sqqq6MqsPuTnyC5E9Zy2yZ6+BISIMDWc+jci7boIicIdf37LzF8xNJuYmF7OTibnJVDo3rbAZc4N3/ZfJZrP5/VPuVYcDee98DPPUhbCbsxEzYhBixwyFITJc79JqpT5k54+Ym0zMTS5mJxNzk0nr3NiMEQlTuOcXmMelofin3xF+y9WImzAKgc0b610WEREREVUTmzEiIazHT8M8eT7y3/8MQe2S0fiD2Qjt1l7vsoiIiIiohtiMEfk4R14Bst5YCcv8DTDERKJh2nOIHHQ9FINB79KIiIiIqBbYjLnBCyxl8pfcVLsduWu3IPOlRXDk5iHm4TsR8/BdMESE6V2aZvwlu/qGucnE3ORidjIxN5m0zo3NmAfccGRRFMUvLo4t3LUXGePSULL/ICL6XwvTuBEIbJKgd1ma8pfs6hvmJhNzk4vZycTcZPJGbmzGiHyI9ehJmCfNRf5HOxF82SVI2jIfIZ0v1bssIiIiItIAmzEP+JwxWVRVhc1mQ0BAgKjc7Dl5yJq5HJaF7yAg3oT4+RMQcUcfUd+htqRmV98xN5mYm1zMTibmJlPp3LTCZswNPmdMJkm5qTYbclZtRua0xVALixH7ZCpiRg2BISxE79J0ISk7+h/mJhNzk4vZycTcZNI6NzZjRDop+OI7ZIxPg/X3o4gcfANMzz+EgMSGepdFRERERF7CZozIy0oOHoN54hwUbP8aIV3bIX77IoR0uFjvsoiIiIjIy9iMEXmJPSsHWa++Bctb7yGgcTwSlkxG+C1X89xxIiIionqKzZgb/JEsk6/dOla12mB5axOyXl0K1WaH6dkHEf3QABhCgvUuzef4WnZUNcxNJuYmF7OTibnJxFvb64wNmSy+lJeqqijY/jXME+fAevgEIu+5GaaxDyAg3qR3aT7Jl7KjqmNuMjE3uZidTMxNJm/kxmbMA97aXhZVVWG322E0GnXNreT3o8gYn4bCL75DSM9OSFg0CcFtW+lWjwS+kh1VD3OTibnJxexkYm4ylc5NK2zG3OAtSGVyOByabjTu2DOykDl9KXKWf4DACxqj0YqXEHZDT+54q0jP7KjmmJtMzE0uZicTc5NJ69zYjBHVAbXECsvid5H12nIAQNwLoxB9f38oQTw/nIiIiIgqxmaMqBZUVUXBli+RMXEubCf+QdS9t8L0n+EwxsXoXRoRERER+Tg2Y0Q1VLzvIDLGp6Fo116EXt0FiStfRtDFF+pdFhEREREJwWbMDV7nI5PW52Pb0s3InLYYuas/QmCrZmi0ZjrC+lzB9aUO8Fx6mZibTMxNLmYnE3OTSevc2Ix5wB/YsiiKotlG4ygqhmX+BmS9sRJKUCAavPQYolL7QQnkZlQXtMyOtMPcZGJucjE7mZibTN7Ijb8iPeCt7WVRVdWVWV3lpqoq8j/4AubJ82A7dQbRw+9A7FPDYIyNqpPx6RwtsiPtMTeZmJtczE4m5iZT6dy0wmbMDd7aXiabzVZnT0sv+ul3mMeloWjPLwi7rjsS189AUKtmdTI2lVeX2ZH3MDeZmJtczE4m5iaT1rmxGSOqgO30WZinLkTehq0IatMCiW/PRNjVXfQui4iIiIj8CJsxolIcBUXInrsW2WlroISFoMGMpxB1901QAripEBEREVHd4i9MIgCqw4G8jZ/APGUB7GczETNiIGLG3AtjVITepRERERGRn2Iz5gYvsJSpurkVfbcfGePTUPzDrwi/6SrETRyFwAuTNKqO3OE2JxNzk4m5ycXsZGJuMmmdG5sxD7jhyKIoSpUvsrT+nY7MKfORt/ETBKVchMabZiG0R0eNK6TKVCc78h3MTSbmJhezk4m5yeSN3NiMUb3jyCtAdtoaZM9dC0NUBBq+MRaRQ26Awud/EBEREZEXsRnzgM8Zk0VVVdhsNgQEBJTLTXU4kLt+KzJfXAhHdi6iRw1G7GP3wBARplO1VJq77Mh3MTeZmJtczE4m5iZT6dy0wmbMDT5nTKaKcivc/RMyxqeh5Jc/EXFbb5gmjEJg00Y6VEfucJuTibnJxNzkYnYyMTeZtM6NzRj5Netfp2CeNBf5m3cguGMbNN48B6Fd2+ldFhERERERmzHyT47cfGS/sRLZC96GMS4G8XPHIaL/tVAMBr1LIyIiIiICwGaM/IxqtyNv1WbkvLoMjvwCxD4+FDH/HgJDeKjepRERERERlcFmzA1eYClLwc7vYR4/GyW/HkbEwOsRN+4hBDSO17ssqgYtL5Al7TA3mZibXMxOJuYmk9a5ca3wgA2Z7ys5fBzmF+ahYOtXCOnSFknbFiCk0yV6l0XVpCgKtzeBmJtMzE0uZicTc5PJG7mxGfOAt7b3XfbsXGS9tgyWxe8iILEhEha+gLB+/4KqqsxNIFVV4XA4YDAYmJ0gzE0m5iYXs5OJuclUOjetsBlzg7cg9U2qzYac5R8gc/pSqMUlMD0zHNEjB8MQGux6HoSWGw1px263MzuBmJtMzE0uZicTc5NJ69x8rhk7fPgwpk6dir179yI8PBz9+vXD448/jqCgoErnOXPmDJYtW4Zdu3bh+PHjiIyMRJcuXfDEE08gKSnJi9WT1go+3YOMCWmwHjyOyDtvhOnZBxDQqIHeZRERERERVZtPNWMWiwWpqalo3rw50tLSkJ6ejmnTpqGoqAgTJkyodL4DBw5g+/bt6N+/P9q3b4+srCzMmzcPAwcOxObNm2Eymbz4LUgLJX8cRcaEOSj8bA9CundAwrwJCG6XrHdZREREREQ15lPN2Lp165Cfn4/Zs2cjJiYGwLlDg5MmTcKIESOQkJBQ4XyXXXYZtmzZUuZuJ506dcLVV1+NTZs2Yfjw4d4onzRgN2cjc/pbyFn+PgKaJiBh2YsIv/FKnm9NREREROL51ImrO3fuRLdu3VyNGAD07dsXDocDu3btqnS+qKiocredbNSoEUwmE86cOVPjeviDXz9qiRXZ89fjeNc7kff2NsSNH4FmX61ExE29PObC87HlYnYyMTeZmJtczE4m5iaT1rn51JGxI0eOoH///mVei4qKQsOGDXHkyJFqjXX06FGYzWa0bNmy1nWdfyMPRVEqvbmHs1FwN12ref1hXFVVUbj9a5gnzIb1r1OIHHoLTM8Mh7FhrGu6p3GNRmOFdTEb/cf1NK+77KR91/q0j9Bqm5O2HHyxJnfTAgICXHef9ZV6azNvfRqX25zMcX1xm5M2rh41OXPTik81Yzk5OYiKiir3enR0NCwWS5XHUVUVU6dORXx8PG666aZa1VRSUlLmSIzBYHAdhbNareXe77zRiN1uh8PhKDMtICAAiqLA4XDAbreXmeYcV1XVCscNDAysdFyj0Qij0ei6k2BpiqK45rXZbOVWJq3Grcp3Bcouw5JfDyN70nwUf/UjQq/qjLhFLyDw4gvhAOD4//d5GtdZr9VqLXcELTAwEIqiVPu7espcj2XoHLeimrTIpvR3rWwZOsd1twzdrd/O+RwOR5ns6mL9drcMvbV+O/nbPsJgMMDhcMBms5XJTatlqNf67W/7CHf1+uo+AtBu/Za0j3BOs9vtFf4+8bV9hLeXoa/uI5zb4/m/K53jAr61j5D4OwLQZhk6x1VVbR6b5FPNWF1JS0vDN998g8WLFyMsLKzG46iq6lppKuIMryKlV/LzGQyGSg95ll4pqjuup3ndPUFcq3HdfVfg3DK0n81C5rTFyF39EQIvTEKj1dMQdm33SufxNK7Vaq0wN+efa/Nd9cimKsvQW+PWdhl6Wg4Oh6PSbU6rZahXNv60j7DZbG73lfVl/a5sXCdf20dYrVbXj5+6GlfrfYQey9AX9xF2u73G+0p//B3hrXFru35X9vvEicvwf+/xlX2Es/lzt6+sLZ9qxqKiopCbm1vudYvFgujo6CqNsWHDBsyZMwcvvvgiunXrVuuaFKXiJ297CsTddK3mlTYuSqzIXvg2smaugBJgRNzkhxF9321QgirfUDyN6/xXi8pyq1W9tZiX43qe7ik7ad+1vuwjtNzmJC0HX63JXW7O6b60r6zNvPVlXG5zMsf11W1O2ri+WlNt+FQz1qJFi3LXhuXm5uLs2bNo0aKFx/m3b9+OF154AY8++igGDBigVZlUS6qqIn/zDpgnz4PtRDqi77sNsU/fB6Opag03EREREZE/8KlmrFevXpg/f36Za8e2bt0Kg8GAHj16uJ13z549eOKJJzBw4ECMHj3aG+VSDRT//Acyxqeh6OufEdbnCiSufgVByc31LouIiIiIyOt8qhkbMmQIVq5cidGjR2PEiBFIT0/H9OnTMWTIkDLPGEtNTcWpU6ewfft2AMDhw4cxevRoNG/eHP369cNPP/3keq/JZEKzZs1qVI+WhyTrG9s/Gch8cSFy129FYPIFSFw/A2G9u2ryWcxNLmYnE3OTibnJxexkYm4yaZ2bTzVj0dHRWL58OaZMmYLRo0cjPDwcAwYMwJgxY8q87/y7t/z888/Izc1Fbm4u7rzzzjLvvf322zFt2rQa18QNp3YchcWwzF2HrFmroYQEocErYxA19BYobi4IrQ1PF2eS72J2MjE3mZibXMxOJuYmkzdyU1Qtb5wv2L59+wAAKSkpOlcik6qqyNv0KTInz4ct3YzoB/oj9slUGKMj9S6NiIiIiKhatOoNfOrImC/S6pkC/qzohwPIGD8bxd/tR/iNVyJxwigEtWzqlc92PkNCy1uQkjaYnUzMTSbmJhezk4m5yVQ6N62wGXODBw2rx3YyHeapC5D3znYEXdoKiRvfQNiVl3m9DuYmF7OTibnJxNzkYnYyMTeZtM6NzRjVmiO/ENmz1yB7zloYIsLQcOYziLzrRiiVPHSPiIiIiIjYjFEtqA4H8t7+GOapC2DPtCBm5CDEPj4UhshwvUsjIiIiIvJ5bMaoRgr3/ALzuDQU//Q7wm/9F+ImjETgBY31LouIiIiISAw2Y27wAsvyrMdPwzx5PvLf/wzB7Vuj8QezEdqtvd5llaHlRZakLWYnE3OTibnJxexkYm4yaZ0b1woP2JCd48grQNYbK2GZvwGG2Cg0THsOkYOuh2Iw6F1aGYqiMDOhmJ1MzE0m5iYXs5OJucnkjdzYjHlQ329tr9rtyF3zX2S+vBiO3DzEPHIXYh6+C4bwUL1Lq5CqqnA4HDAYDPU6N4mYnUzMTSbmJhezk4m5yVQ6N62wGXOjvt+CtPCrH5ExLg0lBw4hov+1MI0bgcAmCXqX5ZHdbtd0oyHtMDuZmJtMzE0uZicTc5NJ69zYjFE51iN/wzxpLvL/+yWCO1+KpC3zEdL5Ur3LIiIiIiLyK2zGyMVuyUXWzBWwLHoHAfEmxC+YiIjbr+HhdCIiIiIiDbAZI6g2G3JWfojMV5ZALSyB6clhiB41GIawEL1LIyIiIiLyW2zG3KgPR4QKPv8WGRNmw/r7UUQO6QvT8w8hoFEDvcuqFZ6PLRezk4m5ycTc5GJ2MjE3mbTOjc2YB/7akJUcPAbzxDko2P41Qq5oj4RPFiO4fWu9y6o1RVH4HA+hmJ1MzE0m5iYXs5OJucnkjdy4Vnjgb7e2t2flIOvVt2B56z0EJMUjYclkhN9ytd98x9J3wPSX71RfMDuZmJtMzE0uZicTc5PJG3dWZzPmhj/d2l612mB5axOyXl0K1WaH6dkHEf3QABhCgvUurc5ZrVYEBgbqXQbVALOTibnJxNzkYnYyMTeZtM6NzZifU1UVBdu/hnniHFgPn0DkPTfDNPYBBMSb9C6NiIiIiKheYzPmx4p/OwLzhNko/OI7hF7ZCQmLJiG4bSu9yyIiIiIiIrAZ80v2jCxkvrIEOSs+ROAFjdFo5csIu74Hz1EmIiIiIvIhbMb8iFpcAsvid5H12nJAURA36d+IHn4HlCCen0xERERE5GvYjLmhKIqIo0mqqiL/v1/C/MJc2E78g6jUfjA9cx+McTF6l+Z1iqIgMDBQRG5UFrOTibnJxNzkYnYyMTeZvJEbmzHhivcdRMb4NBTt2ovQf12OxFUvI6j1hXqXpSvu6ORidjIxN5mYm1zMTibmJpPWubEZ88BXnzNmSzcj8+VFyF3zXwRe1AyN1r6K8D5X6F2W7lRVhd1uh9Fo9MncqHLMTibmJhNzk4vZycTcZCqdm1bYjLnhi88ZcxQVwzJ/A7LeWAklKBANXnoMUan9oAQySieHw6HpRkPaYXYyMTeZmJtczE4m5iaT1rnxF7wQqqoi//3PYZ48D7bTZxF9/x2Ifeo+GGMi9S6NiIiIiIhqgM2YAEV7f4N5XBqKvt2HsOt7IPHt1xDUspneZRERERERUS2wGfNhttNnYZ66AHkbtiGoTQskvvM6wq7qrHdZRERERERUB9iMuaHXBZaOgiJkz12L7LQ1UMJC0GDGU4i6+yYoAYyrKng+tlzMTibmJhNzk4vZycTcZNI6N/6698CbDZnqcCDv3e0wT10Ie0YWYkYMRMzjQ2GMivBaDdIpisKdnVDMTibmJhNzk4vZycTcZPJGbmzGPPDWre2LvtuPjHGzUPzjbwi/+SrETRiFwAuTNP9cf6Oqqisz3jpWFmYnE3OTibnJxexkYm4ylc5NK2zG3PDGre2tJ/5B5pT5yHvvUwSlXITGm2YhtEdHzT/Xn9lsNgQGBupdBtUAs5OJucnE3ORidjIxN5m0zo3NmE4ceQXImrUalnnrYIiKQMM3xyJy8A1QeAibiIiIiKheYDPmZarDgdx1W5D54kI4cvIQPWoIYh+9G4aIML1LIyIiIiIiL2Iz5kWFu39Cxvg0lPzyJyJuvwam8SMR2LSR3mUREREREZEO2Iy5UVcX61n/OgXzpLnI37wDwZ3aIOmjuQi5PKVOxqbyDAaD3iVQDTE7mZibTMxNLmYnE3OTSevc2Ix5UJuGzJGbj6zXVyB7wdswxsUgfu44RPS/Fgo3Rs0oioIAPo9NJGYnE3OTibnJxexkYm4yeSM3rhUaUO125K7+COaXF0EtKELs40MR8+8hMISH6l0aERERERH5CDZjbtTk2QIFO7+HeXwaSn49gohB1yPu+YcQ0DhewyqpNFVVYbVaERgYyOd4CMPsZGJuMjE3uZidTMxNptK5aYXNWB0pOXwc5olzUbBtF0K6tEXSxwsR0rGN3mUREREREZGPYjNWS/bsXGTNeAuWJRsRkNgQCYsmIbzfv/ivHkRERERE5BabsRpSrTbkLH8fmdOXQi2xwvSf+xE9YhAMocF6l0ZERERERAKwGauB/E++gXnibFgPHkfkXTfC9OyDCEiI07ssIiIiIiIShM2YG+efaljyx1FkTJiDws/2IKRHRyTMm4Dgdsk6VUeV0fIiS9IWs5OJucnE3ORidjIxN5m0zs3nHnh1+PBh3HfffejQoQN69OiB6dOno6SkxON8qqpi4cKFuPrqq9GuXTsMHjwYP/30U63rURQFdnM2zv7ndZy46j5Yj/yNRstfROP33mQj5oMURXH9R7IwO5mYm0zMTS5mJxNzk8kbuflUM2axWJCamgqr1Yq0tDSMGTMGGzZswLRp0zzOu2jRIsyaNQvDhg3DggUL0LBhQwwfPhwnTpyoeUFWG7Lmrcfxy+9E3tvbEDd+BJp9tQLhN/bixuSjVFWFzWaDqqp6l0LVxOxkYm4yMTe5mJ1MzE0mb+TmU6cprlu3Dvn5+Zg9ezZiYmIAAHa7HZMmTcKIESOQkJBQ4XzFxcVYsGABhg8fjmHDhgEALrvsMtxwww1YsmQJXnjhhRrVEzJ8KjJPZyDq3lsQ+8z9CGgYW6NxyLscDgeMRqPeZVANMDuZmJtMzE0uZicTc5NJ69x86sjYzp070a1bN1cjBgB9+/aFw+HArl27Kp3vxx9/RF5eHvr27et6LSgoCNdeey127txZ43oczRLQ5POlaPjqU2zEiIiIiIioTvlUM3bkyBG0aNGizGtRUVFo2LAhjhw54nY+AOXmbdmyJU6dOoWioqIa1VM8dSSC2rTw/EYiIiIiIqJq8qnTFHNychAVFVXu9ejoaFgsFrfzBQUFITi47DO+oqKioKoqLBYLQkJCqlWL1WqFqqrYv39/teYj/amqymv6hGJ2MjE3mZibXMxOJuYmkzO3kpISTfLzqWbMl3BjkYvZycXsZGJuMjE3uZidTMxNJmduWt1V0aeasaioKOTm5pZ73WKxIDo62u18JSUlKC4uLnN0LCcnB4qiuJ23Mh07dqz2PERERERERFXlU9eMtWjRoty1Ybm5uTh79my568HOnw8Ajh49Wub1I0eOoHHjxtU+RZGIiIiIiEhrPtWM9erVC7t370ZOTo7rta1bt8JgMKBHjx6VztepUydERERgy5YtrtesVis+/vhj9OrVS9OaiYiIiIiIasKnTlMcMmQIVq5cidGjR2PEiBFIT0/H9OnTMWTIkDLPGEtNTcWpU6ewfft2AEBwcDBGjBiBtLQ0mEwmJCcnY+3atcjOzsb999+v19chIiIiIiKqlE81Y9HR0Vi+fDmmTJmC0aNHIzw8HAMGDMCYMWPKvM/hcMBut5d57cEHH4Sqqli6dCkyMzPRpk0bLFmyBE2bNvXmVyAiIiIiIqoSRVVVVe8iiIiIiIiI6hufumaMiIiIiIiovmAzRkREREREpAM2Y0RERERERDpgM0ZERERERKQDNmNEREREREQ6YDNGRERERESkAzZjREREREREOmAzdp7Dhw/jvvvuQ4cOHdCjRw9Mnz4dJSUlepdFpWzZsgWjRo1Cr1690KFDB/Tr1w/vvPMOzn9k3ttvv43rr78eKSkpuPXWW/H555/rVDFVJD8/H7169ULr1q2xb9++MtOYne957733cNtttyElJQVdu3bFAw88gKKiItf0zz77DLfeeitSUlJw/fXX491339WxWnL69NNPMXDgQHTs2BE9e/bEY489hhMnTpR7H7c5/Rw7dgwTJkxAv379cMkll+Dmm2+u8H1VySg3NxfPPfccLr/8cnTs2BGPPvoozpw5o/VXqJc85ZaXl4e0tDQMGDAAnTt3Rvfu3TFy5Ej88ccf5cZibt5V1W3O6ZNPPkHr1q0rfF9dZMdmrBSLxYLU1FRYrVakpaVhzJgx2LBhA6ZNm6Z3aVTKsmXLEBoairFjx2LevHno1asXxo8fjzlz5rje89FHH2H8+PHo27cvFi1ahA4dOuDhhx/GTz/9pF/hVMbcuXNht9vLvc7sfM+8efMwZcoU3HjjjViyZAkmT56MJk2auPL7/vvv8fDDD6NDhw5YtGgR+vbti+effx5bt27VufL6bc+ePXj44YfRqlUrzJkzB8899xx+//13DB8+vEwjzW1OXwcPHsSOHTtwwQUXoGXLlhW+p6oZPf7449i1axdeeOEFzJgxA0ePHsWDDz4Im83mhW9Sv3jK7dSpU1i/fj169OiBN954A1OmTEFubi4GDx6Mw//X3r0HRVW3cQD/ggImsCDmSCBMiAMCokRcBB1IvASikeYoluKEF0pDxTFFRbzxqnkJqbw7Ft5HzUsig2OmUkok3hFnlAVEUBwDlt0VwcU97x++7LjuKtsbcnbr+5nhD57f75x94Jmze549N6lUay7r1rYM2eaaNTQ0YPny5XjzzTf1jrdK7QTS2LRpk+Dn5yfU1tZqYvv27RO8vLyEqqoq8RIjLdXV1TqxlJQUwd/fX3j69KkgCIIwZMgQYdasWVpzxowZI0yaNKlNcqRXKy4uFvz8/IS9e/cKHh4ewrVr1zRjrJ1xkUqlgre3t3DmzJmXzomPjxfGjBmjFZs1a5YQFRX1utOjV1i4cKEQEREhqNVqTSwvL0/w8PAQLly4oIlxmxNX8+eWIAjC3LlzhejoaJ05htTo0qVLgoeHh/Drr79qYlKpVPD09BSOHz/+GjL/d2upbo8ePRLq6+u1YkqlUggKChKWLl2qibFubc+Qba7ZunXrhE8++UTvvNaqHY+MPSc3NxchISGwt7fXxKKioqBWq3Hu3DnxEiMtDg4OOjEvLy8olUrU19fj7t27KCsrQ1RUlNacoUOHIi8vj6edGoG0tDTExsbCzc1NK87aGZ9Dhw6hW7duCA8P1zv+5MkT5OfnIzIyUis+dOhQSKVSVFRUtEWapEdTUxOsra1hZmamidna2gKA5rRubnPiMzd/9a6YoTXKzc2FRCJBv379NHO6d+8OLy8v5Obmtn7i/3It1a1jx4544403tGLW1tZwdXXVOo2NdWt7LdWuWXl5Ob7//nukpKToHW+t2rEZe05JSQm6d++uFZNIJOjSpQtKSkpEyooMcfHiRXTt2hU2NjaaWr24o+/u7g6VSqX3eglqOzk5Obh16xamTZumM8baGZ+rV6/Cw8MDGzZsQEhICHr16oXY2FhcvXoVwLMPK5VKpfPe2XzqB987xTNy5EhIpVLs3r0bCoUCd+/exddffw1vb2/4+/sD4DZnCgytUUlJCdzc3LSab+DZziG3Q+Mgl8tx+/ZtrfdL1s14/ec//0FMTAx69uypd7y1asdm7DlyuRwSiUQnbmdnh7q6OhEyIkMUFBQgOzsb8fHxAKCp1Yu1bP6dtRTP48ePsXLlSiQlJcHGxkZnnLUzPg8fPsRvv/2Go0ePYtGiRVi/fj3MzMwQHx+P6upq1syIBQQE4LvvvsPatWsREBCAQYMGobq6Glu3bkW7du0AcJszBYbWSC6Xa458Po/7MMZj9erVMDMzw9ixYzUx1s04/fLLL7h8+TJmzJjx0jmtVTs2Y2TSqqqqkJSUhODgYMTFxYmdDrVg48aN6Ny5Mz766COxUyEDCYKA+vp6ZGRkIDIyEuHh4di4cSMEQcCuXbvETo9e4dKlS5gzZw5Gjx6NzMxMZGRkQK1WY8qUKVo38CCi1+/HH3/E/v37kZqaCkdHR7HToVdobGzE8uXLkZiYqPfSmNbGZuw5EokECoVCJ15XVwc7OzsRMqJXkcvlmDx5Muzt7fHtt99qzgFurtWLtZTL5Vrj1LYqKyuxfft2TJ8+HQqFAnK5HPX19QCA+vp6PHr0iLUzQhKJBPb29lqnadjb28Pb2xvFxcWsmRFLS0tD3759kZycjL59+yIyMhJbtmxBUVERjh49CoDvl6bA0BpJJBIolUqd5bkPI76zZ88iNTUVU6dOxYgRI7TGWDfjk5mZCXNzc0RHR0Mul0Mul0OlUkGtVkMul2uu02yt2rEZe46+czwVCgUePnyocz0EiauhoQEJCQlQKBTYtm2b1mHi5lq9WMuSkhJYWFjAxcWlTXOlZyoqKqBSqTBlyhQEBgYiMDAQn332GQAgLi4On376KWtnhHr06PHSscbGRri6usLCwkJvzQDwvVNEUqlU51oHR0dHdOrUCeXl5QD4fmkKDK1R9+7dUVpaqvPMzdLSUm6HIrpy5QpmzJiBDz/8UO8pb6yb8SkpKcGdO3cQEhKi2V/JysqCVCpFYGCg5jmarVU7NmPPCQsLw/nz5zXfNgHPbjZgbm6udacUEldTUxNmzpyJkpISbNu2DV27dtUad3Fxwdtvv63zjKPs7GyEhITA0tKyLdOl//Hy8sKOHTu0fubNmwcAWLJkCRYtWsTaGaEBAwZAJpPh5s2bmlhtbS1u3LgBHx8fWFpaIjg4GCdOnNBaLjs7G+7u7ujWrVtbp0z/4+TkhKKiIq1YZWUlamtr4ezsDIDvl6bA0BqFhYWhrq4OeXl5mjmlpaUoKipCWFhYm+ZMzxQXFyMhIQF9+/bFkiVL9M5h3YzP5MmTdfZX+vfvD2dnZ+zYsQMREREAWq927Vv9LzBhsbGx2LlzJ6ZNm4aEhAQ8ePAAq1atQmxsrM4OP4lnyZIlOH36NJKTk6FUKrUeeunt7Q1LS0skJiZi9uzZcHV1RXBwMLKzs3Ht2jVe4yIiiUSC4OBgvWM+Pj7w8fEBANbOyAwaNAi+vr6YPn06kpKSYGVlhS1btsDS0hIff/wxAODzzz9HXFwcFi9ejKioKOTn5yMrKwvp6ekiZ//vFhsbi+XLlyMtLQ0RERGQyWSa6zafv006tzlxPX78GGfPngXwrFlWKpWaxisoKAgODg4G1eidd95B//79MX/+fMydOxdWVlZIT0+Hp6cnhgwZIsrf9k/WUt0EQcDEiRNhZWWFCRMmoLCwULOsjY2N5qwD1q3ttVQ7d3d3nYdBHz58GA8ePNDaj2mt2pkJLx5b+5eTSqVYtmwZLl++DGtra8TExCApKYnfDhqRiIgIVFZW6h07deqU5pv4AwcOYOvWrbh37x7c3Nwwa9YsDBgwoC1TpRbk5+cjLi4OBw8ehK+vrybO2hmXmpoarFixAqdPn4ZKpUJAQADmzZundQrjqVOnsG7dOpSWlsLJyQlTpkzBqFGjRMyaBEHAvn37sHfvXty9exfW1tbw8/NDUlKSzo4GtznxVFRUYODAgXrHduzYodn5M6RGCoUCK1aswMmTJ9HU1IT+/fsjJSWFXyi/Bi3VDcBLbywWFBSEnTt3an5n3dqWodvc85KTk1FYWIisrCyteGvUjs0YERERERGRCHjNGBERERERkQjYjBEREREREYmAzRgREREREZEI2IwRERERERGJgM0YERERERGRCNiMERERERERiYDNGBERERERkQjYjBEREbWi+/fvw9fXFxcvXvzLyxYXF8Pb2xu3bt16DZkREZGxYTNGREQm4dChQ/D09ISnpycKCgp0xgVBQHh4ODw9PZGQkCBChs+sX78effr0wbvvvvuXl+3RowfCw8PxzTffvIbMiIjI2LAZIyIik2JlZYWsrCyd+B9//IGqqipYWlqKkNUzNTU1OHLkCGJjY//vdcTGxuLkyZMoLy9vxcyIiMgYsRkjIiKTEh4ejpycHDQ1NWnFs7Ky4OPjgy5duoiUGfDTTz+hXbt2GDBgwP+9jtDQUNjZ2eHw4cOtmBkRERkjNmNERGRSoqOjIZPJcO7cOU3syZMnOHHiBIYPH653GbVajR9++AHR0dHw9fVFaGgoUlNTUVdXpzVPEARs2LABYWFh6NOnD8aPH4/bt28jIiICycnJLeb2888/o3fv3rC2ttYZ2717NwYOHIjevXtj1KhRKCgowPjx4zF+/HiteRYWFggKCsKpU6cM+XcQEZEJYzNGREQmxdnZGX5+fjh+/LgmlpubC4VCgaFDh+pdJjU1FatXr4a/vz8WLFiAkSNH4tixY5g4cSJUKpVmXkZGBjIyMtCzZ0/MmTMHLi4uiI+PR319fYt5qVQqXL9+HT4+Pjpje/bswdKlS+Ho6Igvv/wSAQEBmDZtGqqqqvSuy8fHB7dv34ZSqWzxdYmIyHS1FzsBIiKiv2r48OFYu3YtGhoa0KFDBxw7dgyBgYHo2rWrztyCggIcOHAAa9as0TpyFhwcjEmTJiEnJwfDhw9HTU0Ntm3bhvfeew+bNm2CmZkZACA9PR2bNm1qMaf79++joaEB3bp104o/efIEGRkZ8PX1RWZmJtq3f/bR6+npieTkZDg6Ouqsy8XFBWq1GiUlJejdu/df+t8QEZHp4JExIiIyOVFRUWhsbMTp06ehVCpx5syZl56imJOTA1tbW/Tr1w81NTWaHx8fH3Ts2BH5+fkAgPPnz0OlUmHcuHGaRgwAJkyYYFBOMpkMACCRSLTihYWFkMlkGD16tKYRA541lHZ2dnrX1byO2tpag16biIhME4+MERGRyXFwcEBISAiysrLQ0NCAp0+f4v3339c7986dO1AoFAgJCdE7Xl1dDQC4d+8eAODtt9/Wea2XNU36CIKg9Xvzel1dXbXi7du3h7Ozs0HrICKifyY2Y0REZJKGDRuGhQsX4s8//0RYWJjOEalmarUanTt3xpo1a/SOOzg4tEo+9vb2AAC5XP6319W8jk6dOv3tdRERkfHiaYpERGSSBg8eDHNzc1y5cgXDhg176TxXV1fIZDL4+/sjNDRU56dnz54AACcnJwBAWVmZ1vI1NTU6d13U56233kKHDh1QUVGhFW9e74vPDWtqakJlZaXedVVUVMDc3Bxubm4tvi4REZkuNmNERGSSrK2tsXjxYiQmJiIiIuKl86KiovD06VNs2LBBZ6ypqUlzFCo0NBQWFhbYtWuX1mmCmZmZBuVjYWGBXr16obCwUCveq1cv2NvbY//+/VrPRjt27NhLm7wbN26gR48esLW1Nei1iYjINPE0RSIiMlkjRoxocU5QUBDGjBmDzZs34+bNm+jXrx8sLCxQVlaGnJwcLFiwAJGRkXBwcEB8fDw2b96MhIQEhIeHo6ioCLm5uQafLjhw4ECkp6dDqVTCxsYGAGBpaYnExEQsW7YMEyZMQFRUFCorK3Ho0CGd68iAZ7fIv3DhAsaOHfvX/hlERGRyeGSMiIj+8ZYuXYply5ahuroa6enpWLt2LX7//Xd88MEH8Pf318ybOXMmEhMTUVRUhFWrVqG8vBzbt29Hx44dDXqdmJgYqNVqnQc2jxs3DikpKbh//z6++uorFBQUYOPGjbC1tYWVlZXW3Ly8PMhkMoMaTSIiMm1mAm/ZRERE9EoREREICgrCypUrW5w7f/58lJWVYc+ePa+cp1arERISgsGDByMtLU0Tnzp1KszMzLB+/fq/nTcRERk3HhkjIiJqRV988QWuX7+OixcvamKNjY06t6s/cuQIZDIZgoKCNDGpVIozZ85gxowZbZYvERGJh9eMERERtSInJydcv35dK3blyhWsWLECkZGRsLe3R1FREQ4ePAgPDw9ERkZq5rm7u6OoqKitUyYiIpGwGSMiInrNnJ2d4ejoiJ07d6Kurg52dnaIiYnB7NmzYWlpKXZ6REQkEl4zRkREREREJAJeM0ZERERERCQCNmNEREREREQiYDNGREREREQkAjZjREREREREImAzRkREREREJAI2Y0RERERERCJgM0ZERERERCQCNmNEREREREQiYDNGREREREQkgv8CSBW8jNXETisAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1cAAAIsCAYAAAAeUFNGAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAnXFJREFUeJzs3Xd4FOXaBvB7tqQnmwRICAFE4AQRAoiIUkRFVLAh0pUmUvQgKtgQG1URERWk915UQMUDiA0UFFERgWOhCQgacDfZ9GTL+/3ht3tSN5tkk5l5c/+uy8uL2Z03z8w9M9knO0URQggQERERERFRpRjULoCIiIiIiEgGbK6IiIiIiIgCgM0VERERERFRALC5IiIiIiIiCgA2V0RERERERAHA5oqIiIiIiCgA2FwREREREREFAJsrIiIiIiKiAGBzRUREREREFABsroiIqNoMHjwYgwcP9v77jz/+QLNmzbBlyxYVqyIiIgoMNldERCrYsmULmjVrhiNHjqhdii788ccfmDZtGm677Ta0bt0aPXr0wIYNGwq957fffsOzzz6Lbt26oU2bNujZsyc+/vhjlSomf+zZswdz585VuwwiooAxqV0AERHVXImJifjpp59gMvn+dfT222/jxx9/RM+ePVGrVi3s2rULkyZNQnBwMO69914AwNSpU5GdnY0BAwYgLCwM7733Hh599FGsXLkS1113XXUsDpXTnj17sG7dOowdO1btUoiIAoLNFRERqUZRFAQHB5f5vvvvvx/Tp0+H0WgEAPTu3RvdunXDhx9+6G2unnzySbRu3do7z913340OHTpg+/btumqusrOzERYWpnYZmuN0OuF2uxEUFKR2KUREpeJpgUREGpaSkoJnn30WHTt2RMuWLXHHHXfg3XffLfa+8+fP46GHHkKbNm3QoUMHvPzyy/jyyy/RrFkzHDhwoNB7161bh5tvvhmtWrVCnz598N133xW7FgoA8vPzMWfOHNxyyy1o2bIlbrjhBsycORP5+fl+1b5p0yZ069at0M8pyt9rrpKTk72NFQCYTCaYTCY4HA7vtIKNFQAEBQXBYDAUek91S0lJwcSJE9G5c2e0bNkSXbt2xUsvveRdh57TQ7/99ltMmjQJHTp0wA033OCdf926dbjjjjvQsmVLdO7cGZMnT0Z6enqhnzF48GDceeedOHHiBAYPHozWrVvj+uuvx5IlS4rVY7VaMXHiRHTs2BHJycm4++67sXXr1kLv8WSybNky77bSunVrDB8+HH/++SeEEJg3bx66dOmCVq1a4eGHH0ZaWlqxn7Vnzx7cd999aNOmDa666iqMGjUKx48f974+YcIErFu3DgDQrFkz739Fa1i5ciW6deuG5ORknDx5EgDw9ddfe8du164dHn74Ye9rRERq4jdXREQa9ffff6Nfv35QFAX3338/YmNjsXfvXjz33HPIzMzEsGHDAPzzTcfQoUNx6dIlDBkyBLVr18b27duLNVUAsH79ekyZMgXt2rXDsGHDcP78eYwZMwZRUVGoW7eu931utxsPP/wwvv/+e/Tr1w9NmjTBb7/9hlWrVuH333/H/Pnzfdb+zjvv4MUXX8RVV12FoUOH4ty5c3j44YdhsViQkJBQ6XWzZs0anDt3DmPGjCn1PbNnz0ZeXp73m63qlpKSgj59+iAjIwP9+vVD48aNkZKSgl27diE3N7fQNzCTJ09GbGwsxowZg+zsbADA3Llz8fbbb6Njx44YOHAgTp8+jQ0bNuDIkSPYsGEDzGazd3673Y4RI0bglltuQY8ePbBr1y7MmjULSUlJ3mYtNzcXgwcPxtmzZ3H//fejfv362LlzJyZMmID09HQMHTq0UP0ffvghHA4HBg8ejLS0NCxduhSPP/44rrvuOhw4cAAjR47EmTNnsHbtWrz66qt45ZVXvPNu27YNEyZMQOfOnfHkk08iJycHGzZswH333YetW7eifv366N+/Py5evIh9+/Zh5syZJa7DLVu2IC8vD/369UNQUBAsFgv279+PkSNHon79+njkkUeQm5uLtWvXYuDAgdiyZQvq168fsAyJiMpNEBFRtXvvvfdEUlKS+Omnn0p9z8SJE0WnTp2EzWYrNH3cuHHi6quvFjk5OUIIIZYvXy6SkpLE7t27ve/Jzc0V3bt3F0lJSeKbb74RQgiRl5cn2rdvL3r37i0cDof3vVu2bBFJSUli0KBB3mnbtm0TV1xxhTh48GChn71hwwaRlJQkvv/++1Lrzs/PFx06dBA9e/YUeXl53umbNm0q9nPOnTsnkpKSxHvvvVfqeEW9//77olmzZuLFF18s9T0LFy4USUlJYtGiRX6PG2hPP/20uOKKK0rM2O12CyH+tx0MHDhQOJ1O7+tWq1W0aNFCDB8+XLhcLu/0tWvXiqSkJPHuu+96pw0aNEgkJSWJrVu3eqfl5eWJTp06ibFjx3qnrVy5UiQlJYn333/fOy0/P1/0799ftGnTRmRkZAgh/pfJddddJ9LT073vff3110VSUpK4++67C20/48ePFy1atPBmnZmZKdq1ayeef/75Qst86dIlcfXVVxeaPnnyZJGUlFRs/XhqaNu2rbBarYVe69mzp+jQoYNITU31Tvv555/FFVdcIZ5++uliYxERVSeeFkhEpEFCCHz88cfo2rUrhBCw2Wze/zp37oyMjAwcO3YMAPDll18iPj4eN998s3f+4OBg9OvXr9CYR48eRVpaGvr161foBhJ33XUXLBZLoffu3LkTTZo0QePGjQv9bM+1SyV9K1bw51itVgwYMKDQtzO9evVCZGRkxVcKgJMnT2LixIm4+eab8dJLL5X4nv3792P27NkYPHgwRo0aVamfV1FutxuffPIJbrrpJiQnJxd7XVGUQv/u169fodMe9+/fD4fDgSFDhsBg+N+v6r59+yIiIgJ79uwpNH9YWBh69uzp/XdQUBCSk5Nx7tw577S9e/eiTp06uPPOO73TzGYzBg8ejOzsbBw8eLDQmN27dy+UV6tWrQD8cy1bwe2nVatWcDgcSElJ8daenp6OO+64o9C2YzAY0Lp1a5/bTlG33norYmNjvf++ePEifv75Z/Tq1QvR0dHe6VdccQU6duxYbL0QEVU3nhZIRKRBNpsN6enp2LRpEzZt2lTqe4B/rrdq2LBhsQ/sDRs2LPTvCxculDjdZDIhMTGx0LQzZ87g5MmT6NChQ4k/22q1llq75+dcdtllhaabzWY0aNCg1Pn88Z///AcOhwMvvfRSoaajoA8++ADh4eF4+umnyxzP5XJ512N5GY3GQh/8C7LZbMjMzMS//vUvv8YqeiqbZx02bty40PSgoCA0aNAA58+fLzS9bt26xfK3WCz49ddfvf8+f/48LrvssmLrrUmTJoV+pkfR0zc9jVZp0+12Oxo0aIDff/8dAIqdZugRERFR4vSSlLZeLr/88mLvbdKkCb766iveEISIVMXmiohIg9xuN4B/viXo1atXie/xXPxfVT8/KSkJzz77bImvF7w+qzp5bpwQFxfn8z3R0dF+3VXuzz//LPSNX3kkJibis88+q9C8Rflzx0RfCn7rFSiljVlaUyuEKPT/mTNnok6dOn6PW5KQkBC/30tEpAVsroiINCg2Nhbh4eFwu93o2LGjz/cmJibixIkTEEIU+vbi7Nmzhd5Xr1497/SCtyZ3Op04f/58oWatYcOG+OWXX9ChQ4di34iUxfNzzpw5U+ibL4fDgT/++ANXXHFFucYrqF27dt4P76W54YYbcOWVV/o1Xp06dbBixYoK1eKrIYqNjUVEREShu+OVh2cdnjp1qtC3ffn5+fjjjz/K3CZKkpiYiF9//RVut7tQg3Tq1KlCP7OyPPXWqlWrzDorum2dPn262GunTp1CTEwMv7UiIlXxmisiIg0yGo247bbbsGvXLvz222/FXi94Klvnzp2RkpKCTz/91DstLy8PmzdvLjRPy5YtER0djc2bN8PpdHqnf/jhh7Db7YXe26NHD6SkpBQbA/jnrnOeO9qVpGXLloiNjcXGjRsL3bZ969atxW4jXl5XX3017r//fp/vueGGG3DPPff4NV5wcDA6duxYof+uvvrqUsc1GAzo1q0bPv/8cxw5cqTY62U1iB07doTZbMaaNWsKvffdd99FRkZGodu1+6tLly64dOkS/vOf/3inOZ1OrFmzBmFhYbjmmmvKPWZJrr/+ekRERGDRokUl3ga/4LYbGhoKAH5vF3FxcWjevDm2bdtWaJ7ffvsN+/btq9B6ISIKJH5zRUSkovfeew9ffvllselDhgzBE088gQMHDqBfv37o27cvmjZtCrvdjmPHjuHrr7/Gt99+CwDo378/1q5diyeeeAJDhgxBnTp18OGHH3q/WfF8OxAUFISxY8di6tSpGDp0KHr06IHz589jy5Ytxa7D6tmzJ3bs2IGXXnoJBw4cQNu2beFyuXDq1Cns3LkTS5cuLfFGDcA/11Y9/vjjePHFFzF06FDcfvvt+OOPP7Bly5ZKX3M1e/ZsbN26tdC1REU988wzOH/+fMBO2auo8ePHY9++fRg8eLD3dvaXLl3Czp07sX79ekRFRZU6b2xsLEaPHo23334bI0aMQNeuXXH69GmsX7/e+3yq8urfvz82bdqECRMm4NixY0hMTMSuXbvwww8/YOLEieW6FsqXiIgITJo0CU8//TTuvfde3H777YiNjcWFCxewZ88etG3bFi+++CIAoEWLFgCAadOmoXPnzjAajbjjjjt8jv/0009j5MiR6N+/P/r06eO9FXtkZCQeeeSRgCwDEVFFsbkiIlLRhg0bSpx+7733om7dunjnnXcwb9487N69Gxs2bEB0dDSaNm2KJ5980vve8PBwrFq1CtOmTcPq1asRFhaGe+65B1dddRXGjh1b6PS1QYMGQQiBFStW4NVXX8UVV1yBBQsWYNq0aYXeZzAYMG/ePKxcuRLvv/8+du/ejdDQUNSvXx+DBw8u8YYCBfXv3x8ulwvLli3DzJkzkZSUhAULFuCtt96q5BrTj/j4eGzevBlvvfUWPvzwQ2RmZiI+Ph5dunTx61qisWPHIjY2FmvXrsUrr7wCi8WCfv36Yfz48YWeceWvkJAQrFmzBrNmzcLWrVuRmZmJyy+/HK+88krAnwV21113IS4uDosXL8ayZcuQn5+P+Ph4tGvXrtDPuvXWWzF48GB89NFH+OCDDyCEKLO56tixI5YuXYo5c+Zgzpw5MJlMuOaaa/DUU09VunknIqosRZR1bgIREenSypUr8corr2Dv3r2Ij48v9X1utxsdOnTALbfcgmnTplVjhURERHLhNVdERBLIzc0t9O+8vDxs2rQJjRo1KtRY5eXlFbveZ9u2bUhLS0P79u2rpVYiIiJZ8bRAIiIJPPLII6hXrx6uuOIKZGZm4oMPPsCpU6cwa9asQu/78ccf8corr6B79+6Ijo7Gf//7X7z77rtISkpC9+7dVaqeiIhIDmyuiIgk0LlzZ7z77rv48MMP4XK50LRpU7zxxhu4/fbbC70vMTERdevWxZo1a2C322GxWNCzZ088+eSTfj0XioiIiErHa66IiIiIiIgCgNdcERERERERBQCbKyIiIiIiogDgNVelOHToEIQQFXqWCBERERERycPhcEBRFFx11VU+38fmqhRCiGK3KyYiIiIioprH375AU83VmTNnsGzZMhw+fBjHjx9H48aNsX37dr/mTUlJwezZs7Fnzx5kZ2cjMTERDz/8MO6+++4K1WI2myGEQMuWLaEoSoXGIG0QQsDhcMBsNjNLHWOO8mCW8mCW8mCWcmCOVefIkSN+vU9TzdXx48exZ88etG7dGm632+8O8eLFi+jfvz8uv/xyTJ06FRERETh+/Djy8/OruGIiIiIiIqJ/aKq56tq1K7p16wYAmDBhAo4ePerXfK+99hrq1q2LpUuXwmg0AgA6dOhQZXUSEREREREVpam7BRoM5S8nMzMTO3bswH333edtrIiIiIiIiKqbppqrijh27BgcDgdMJhMGDRqEFi1aoFOnTnjttdfgcDjULo+IiIiIiGoITZ0WWBF///03AOD5559Hv3798Mgjj+Cnn37CnDlzYDAY8MQTT1R4bEVRSrzuq7TpnteA0u8oUpXzctySXxNCwGQyFfq32jXV1HErW5PJZCr2Hq0uq1bXoRbGLbhP6qFePddU1eMW3S+5DtUft6LzAijxGBuImvS2DrWWTXnGLWmf1HK9eq+pJLpvrtxuNwCgY8eOmDBhAgDguuuuQ1ZWFpYvX44xY8YgJCSkwuM7nc5C/zYYDN4PBZ5vxlwuF5xOJ4QQCAoK8s7nqc3DZDLBYDDA5XLB5XKVOK7nLi9Fee76UtK4RqMRRqMRbre7WL2Konif1eVwOIptHFU1bkWXtarG9WdZg4ODoShKqeN6aippXOCf7aC0dSiE8LkOPdtP0WVVFAVut7tYTZ5xS6qpMuP6s6yedVTS9u05AJW23/jKBvC9Dj3LU55l9bzmax0GOpuy1qHnGOFrHfoatzLrsCLLWtXbt699GdDO9u1rWXmMKLysah0jKrN98xih3WNEedchjxH+LSuPEf4ta8FjhBDC24j5ovvmKioqCsA/DVVBHTp0wMKFC3HmzBk0a9aswuN7gi7ttb/++gt2u73C41PVK/oXVV+MRiPq1KkDi8VS4vt9PVS64IGqqII7b0kKfrNWlMFg8Hk9YnWO61knFV3WstaDr3E98xuNxhKzqeiyqpWNr2WtTL1VtR0GclwhBFwuFxRFkWr7Lm1cDxmPEZ4sPfulmseIqlqHNeUY4cmyrM89FalXr9t3UXo4RhTdJwG51qGaxwh/PkcCEjRXTZs29fl6Xl5ehcf2dKglrUxFUbyNVVxcHMLCwvxe6VS9hBA+s/S8x+l0Ij09HX/99Rdyc3ORkJBQ7H2+Mq7oazVp3MrWVNY+GeifqcVxtVhTRcb1548eWqpXrzVVx7gl7Zdq11STx63ovP78rtTasupt3OqqqWiOWq9XhpoK0n1zlZiYiKSkJOzfvx+DBg3yTt+/fz9CQkLKbL4qyuVyIS0tDXFxcahVq1aV/AwKDH9+YXhERkYiODgYf//9N+Li4ngHSiIiIiLym6aaq5ycHOzZswcAcP78eWRmZmLnzp0AgPbt2yM2NhZDhw7FhQsXsHv3bu9848aNw7///W9Mnz4dN954I44cOYLly5fjwQcfRFhYWJXU6jnfs6rGJ/WEh4fj0qVLcDgcbK6IiIiIyG+aaq6sVisee+yxQtM8/169ejWuvfbaEi+e69q1K2bPno358+djw4YNiIuLw9ixYzFq1Kgqr5mnAsqHmRIRERFRRWiquapfvz5+/fVXn+9Zs2ZNidNvv/123H777QGthx+y5cEs5cBvEuXBLOXBLOXBLOXAHNWl+4cIV7Wa8KF87ty5aNasWbH/7rzzTgBAs2bNsGzZMu/7t2zZgg8//NDv8XNzczF//nzcfvvtSE5ORvv27fHQQw/hxx9/LPbewYMHY/To0T7H+/HHHzFixAh06tQJrVq1QteuXfHoo4/i8OHDJb7fc63V1q1by1U3aYuilH6nQNIXZikPZikPZikH5qg+TX1zpUX+3tNe70JCQrBq1api0wBg06ZNqFevnnf61q1bERYWhrvuuqvMcbOzszFs2DAcP34cI0aMQLt27ZCWloa1a9fivvvuw6xZs8r1jeP333+PIUOG4Prrr8fkyZMRHh6OM2fO4JNPPsFPP/2E1q1bF5vHc1eyLVu2IDw83K+6SXvKc2MS0jZmKQ9mKQ9mKQfmqD42Vz6U52nMemcwGNCmTZsSXyttuj/eeustHD58GKtWrSr0LLJu3bph+PDheO6559CuXTvExcX5Nd6GDRuQmJiIefPmeb/27tChAwYMGFDsoXEF1aQsZeZ0On0+o4L0g1nKg1nKg1nKgTmqi6cFUpkKnhY4ePBgfPvtt/jiiy+8pw/OnTu3xPlyc3OxefNmdOrUqdhDno1GIx599FFkZ2fjnXfe8buW9PR0xMbGlng+sa8H2Q0ZMgQHDx70q24iIiIioorgN1fk5XQ6C/27pHN2X3rpJTz11FMICQnBM888AwCoW7duieMdPXoU2dnZuOmmm0p8/eqrr0Z0dDS+++47v2ts0aIF5s+fjzfffBN33XUXmjRp4td8L774Ip555hm/6iYiIiIiqgg2VwTgn2ujWrRoUWjazJkz0bNnz0LTmjZtioiICISFhZV5umBKSgoAICEhodT3JCQk4K+//vK7zgcffBCHDx/GggULsGDBAkRHR6Nz584YOHAg2rVrV+p8TZs2RXh4OMLDwyt1miMRERERUWnYXPlQ0QsBHb9fgNueEeBqymawRMLcqF7ZbyxBSEgI1q5dW2hagwYNAlFWQEVERGD58uX46aef8MUXX+D777/Hrl278NFHH2Hq1Kno27ev2iVSFeLFufJglvJglvJglnLQa445OTnIyckp9fXQ0FCEhoZWY0UVw+aqDOXdQF3WNJy9diDg4+YKVcZoRKNj22CsFV3uWQ0GA5KTkwNaTnx8PADgzz//LPU9f/75J6688spyj92qVSu0atUKAHDu3DkMHjwYs2bNKrG58twxR68HG/qHoii8QFcSzFIezFIezFIOes7xxIkTOHr0KADA5XIhKysL4eHh3uvsW7ZsGfDPqlWBzVWAGWtFo+GBDap9c1WRxqqqtGzZEmFhYfjiiy8wePDgYq8fOnQIaWlpPk/n80eDBg3QvXt3rFixAn///Tdq165dqfGIiIiIqHo1bdoUiYmJAAC73Y69e/eiU6dOsFgsAKCLb60ANldlqshzrip6ap5emM1m5OXllfm+kJAQ9OvXDytXrsTBgwdxzTXXeF9zu92YM2cOwsLCynUqX2nN0++//46goCBERUUVe83zzAeTyeRX3aRNQgg4nU6YTCZ+C6lzzFIezFIezFIOes6x6Gl/QUFBsFgsiI2NVbGq8mNz5QOfjVSyxo0bY9u2bfjss89Qp04dxMXFeU8BLOqxxx7DoUOHMGrUKIwcOdL7EOF169bh4MGDmDVrVrFnXF26dAk7d+4sNtaNN96I559/Hi6XC7feeisaNWqEzMxM7Nq1C59//jmGDh2KoKCgUutu0qSJ33WTNnGflAezlAezlAezlANzVBebKyq3kSNH4uzZs3jmmWeQnp6ORx55BGPHji3xvWFhYVi9ejWWL1+O7du3Y8GCBQgNDUXbtm2xbt06XHXVVcXmOXbsGB577LFi0/fs2YP7778f27Ztw6JFi3Dp0iWEhISgYcOGmD59Onr16uWz7hEjRvhdNxERERFReSmC7W2Jjhw5AiEEkpOTS/xaNTc3F6dPn8bll1+OkJAQFSokf3lOC/T3phbMVpuEEHA4HDCbzbo71YEKY5byYJbyYJZykCVHm82GXbt24bbbbtPMaYFHjhwBgDJvqmGojmKIiIiIiIhkx+bKBz13/FQYs5SDXm8vS8UxS3kwS3kwSzkwR3Xxmqsy8EO5/jFDOTBHeTBLeTBLeTBLOTBH9fGbqzLwkjT981xzxSz1TQgBl8vFHCXALOXBLOXBLOXAHNXH5soHbpjyYJZycLlcapdAAcIs5cEs5cEs5SBDjmlpaUhJSUFaWprapZQbm6tK4od2+TBTIiIiIvVkZmZ6/9MbNlcV5LlYMDs7W+VKKNCysrKgKAovCCUiIiJSQXZuPoQQyM7NV7uUcuMNLSrIaDQiOjoaFy9eBPDPw3J5EaE2+fOcKyEEnE4n0tPTkZ6ejujoaBiNxmqulIiIiKhmS8/Mw/Z9v8PoEti+73dceWUyoiKC1S7Lb2yufCirWapbty4AeBss0i5Pc1UWo9GIhIQEWCyWaqiKyosNrzyYpTyYpTyYpRz0nuOf1iyc+zMDjcKAc39m4C9rNpsrmfj6QK4oChISEhAXFweHw1GNVVFVMJlMMBqN/AZSoxRF0f0vDPoHs5QHs5QHs5SDDDkm1ApHg4RIwA40SIhE3VphapdULmyuyuDPNx5Go1H3G7LM/DktkLSPOcqDWcqDWcqDWcpBhhyjIoJxZ6dG2L3rZ/To1EhX31oBvKGFT7xrnDycTqfaJVAAMEd5MEt5MEt5MEs56D1HV3omLJt2o8mx8wgLCVK7nHJjc0VERERERKoS+Q7Yl7yLs+0HIGjTJwgKDUFERITaZZUbTwskIiIiIiJVCCGQ9cEXsE5bBOfZPxE5sAcMo3vD8eN3iI6OVru8cmNzRURERERE1S7n68OwTp6PvO//i7BbOqDu6pcR3LwxbDab2qVVGJsrH/R6ISAVxyzlwBzlwSzlwSzlwSzloIcc84+fgXXqQmTv+ArBrZuh3ta3ENq5rdplBQSbqzLoYQMl3xRFgdlsVrsMqiTmKA9mKQ9mKQ9mKQet5+hMsSL1tRVIX7sdpsQ4xC16CRH3dIVikOc2EGyuiIiIiIioyrgzs5E2fyPS5m2EEmRCrUkPw/JALyjB+rsbYFnYXJXBn+dckbYJIeB0OmEymZiljjFHeTBLeTBLeTBLOWgtR+F0In3dR0h9dTnc6ZmwjOqD6EcHwRgdqXZpVYbNlQ98zpU8mKUcmKM8mKU8mKU8mKUctJCjEALZO7+CdcpCOE6eQ0Tf2xD77AiY68erXVqVY3NFREREREQBkfvdMVgnzUfugZ8QekM7xC96CcGtksqcLycnBzk5OQAAu92O/Px82O127+uhoaEIDQ2tsroDhc0VERERERFVSv7Jc7BNX4ysD79AUIsmSNj8OsJuau/3/CdOnMDRo0cBAC6XC7m5udi3bx+MRiMAoGXLlkhOTq6K0gOKzRUREREREVWI6+9UpL6+CvaV22CMq4U6cycisu+tUP6/KfJX06ZNkZiYWOrrevjWCmBz5ZMWLgSkwDCZuKnLgDnKg1nKg1nKg1nKobpydGfnwr5oM1LnrIOiKIh9diQsI/vAEBpcofH0ctpfWbgXlYENlv4pisIcJcAc5cEs5cEs5cEs5VAdOQqXCxkbd8I2Yylc1jRYhvdCzLghMNaKrtKfqxdsrsrAW7HrnxACbrcbBoOBWeoYc5QHs5QHs5QHs5RDVeYohED2pwdgm7IA+T+fQkSvmxE7cRTMjeoF9OfoHZsrH7RwK0sKDJfLBYNET/+uqZijPJilPJilPJilHKoix7zDv8I6eT5yvvwBIR3bIPHjxQi5qnlAf4Ys2FwREREREVExjrN/wvbyEmS+txvmpMtQd90MhN3Skd9u+sDmioiIiIiIvFyp6Uh9YzXsy7bAGBOFOrOfRuTAHlB405MycQ0RERERERHcuXlIX7YFqW+shnC6EDN+CKIf6g9DuP7v4ldd2Fz5wK885cFzyOXAHOXBLOXBLOXBLOVQkRyF243M93bD9vISOP/8G1FD7kbMk8Ngioutggrlpqm96MyZM3jxxRfRs2dPXHnllbjzzjvLPcbKlSvRrFkzjB49OiA1scHSP0VRYDKZmKXOMUd5MEt5MEt5MEs5VCTH7D3f4Y9uI3Dx39MQ3PoKNPhqNerMHM/GqoI09c3V8ePHsWfPHrRu3Rput7vcd+u7dOkS5s2bh1q1agWsJt6KXf8KbkfMUr+YozyYpTyYpTyYpRzKk2PesROwTlmInM8OIPialkj8aD5C2idXdYnS01Rz1bVrV3Tr1g0AMGHCBBw9erRc87/22mvo2rUrLly4EJB6eCt2eTgcDpjNZrXLoEpijvJglvJglvJglnIoK0fn+RTYZixDxqadMF+eiPgV0xB+Rxc21QGiqeaqMuf6fvfdd/jkk0+wc+dOPPHEEwGsioiIiIhI31zpmUh7ay3si9+BEhGG2jPGIWrwXVDMmmoHdE+KtelyuTB16lQ89NBDiIuLU7scIiIiIiJNEPkO2Fe+j9TXV0Lk5iF6zEBEjxkIQ2S42qVJSYrmav369cjJycGwYcMCPnZJpwYqilLqKYOer1R9vV5V83Lckl8TQhSapoWaauq4la2paJaBGreq6q2KcbVYU3nHLZijHurVc01VPW7R/ZLrUP1xKzqvZ77SPvdUpia9rUOtZVOecQvuk0IIZH/wBazTFsF57i9E3nc7Yp4eDlPd2t751a63Ouetqv2mKN03V1arFXPmzMGrr76KoKCggI/vcDgKnYNqMBhg+v8HqDkcjmLv99TgcrngdrsLvea5e4vb7YbL5Sr0mmdcIUSJ43rOnS1pXKPRCKPRCCEEnE5nodcURfHO63Q6i20cVTWuP8sKFF+HVTGup36z2QxFUcq9rGVlrsY69IxbUk1VlY1nWUtbh55xfa3DQG3fnn3S3+3b1zqszu0b4DECKPwBTgvHiILLymNE+dZh0f1SK8cIf5eVx4j/LavBYPDOW/BzDz9HFF5WrR8jPO/L++YnpE9fgrxDPyP0lg6ovWIqzM0aQfx/DTX9c4S/y1rwGCGEfze5031z9dZbb6FZs2Zo164d0tPTAfyzcpxOJ9LT0xEWFuYNubwURfHZsPm6WLDgRluUwWAo9fqygiGXd9yy5vW1HqpqXF/LCvheh4EcNygoyLtDVGZZ1chGK+sQQKXXYWW2b4PBgLCwsFLnreiyqpUNjxH/zCfT9l3auB6yHiMK/p5U8xhRVeuwphwjFEVBcHBwqfMBNftzBKCPY0T+r78jfdpCZO/aj+A2V6DetjkI6dim1PnKqklr61DNY4Q/jRUgQXN1+vRpHDx4ENdcc02x16655hosWbIEXbp0qfD4pa3Islawr9eral6OW7XjarEmvY2rxZr0Nq4Wa+K42q1Jb+NqsSa9javFmjhu1dfkSrHCNnM5MtZ9BFODeMQvnoTwnjdBKeNmcVyHgZm3IN03VxMnTvR+Y+Xx8ssvIyQkBOPHj0ezZs0qNb6/XwGSdgkh4HK5YDQamaWOMUd5MEt5MEt5MEt9cmdmI23eBqTN3wglOAi1Jv8b4YPvgikslDmqRFPNVU5ODvbs2QMAOH/+PDIzM7Fz504AQPv27REbG4uhQ4fiwoUL2L17NwCgefPmxcaJiopCWFgYrr322krVU56L10jb3G53qV8Tk34wR3kwS3kwS3kwS/0QDifS136I1NdWwJ2eBcuovoh+7H4YoiJKvCaJqo+mmiur1YrHHnus0DTPv1evXo1rr722xIvniIiIiIhkJ4RA9o4vYZ26CI6T5xDZ7zbETBgBc/147+ukLk01V/Xr18evv/7q8z1r1qwpcxx/3kNEREREpBe5B4/COmk+cr89gtCb2iN+yWQEt2yqdllUhKaaKyIiIiIi+p/8k+dgm7YIWdv3IKhFUyS8MxthNxa/kRtpA5srH3ghoDwqejt+0hbmKA9mKQ9mKQ9mqS3OS6lInbUS6avfhym+FuLmPYeIPreWeQdA5qgurv0ysMHSP0VRmKMEmKM8mKU8mKU8mKV2uLNzYV+4Galz10ExGBA7cSQsI/vAEOL7OWQAc9QCNldl4K3Y9U8IAbfbXa4HwJH2MEd5MEt5MEt5MEv1CZcLGRt2wPbqMrisabA8eC9ixg2BMdbi/xjMUXVsrnzgHVfk4XK5fD5FnPSBOcqDWcqDWcqDWapDCIHs3V/DOnUhHL+cRsS93RA7cSTMl9Wr0HjMUV1sroiIiIiIVJD74y+wTl6A3K9+QEinqxC3ewlC2lyhdllUCWyuiIiIiIiqkePMBdheXoLMLZ/AfMXlqLt+JsK6XcdT+STA5oqIiIiIqBq4bHakvrEa9mVbYIy1oM4bzyByQHcovMOfNJikD/zrgTx47rEcmKM8mKU8mKU8mGXVcefkwb70XaS9uRbC7Ubskw/AMrovDOGhAf9ZzFFdbK7KwAZL/xRF4TMfJMAc5cEs5cEs5cEsq4Zwu5H57sewvbwEzhQroob0RMyTw2CqE1MlP485qo9rn2oE3lJfDsxRHsxSHsxSHswysLK/OAjr5AXIP3oc4XfegITnRyGoScMq/7nMUV1srnwQQnADlYAQAg6HA2azmVnqGHOUB7OUB7OUB7MMnLyjJ2CdPB85XxxESPtkJP5nAUKuaVktP5s5qo/NFRERERFRJTnPp8D2ylJkbN4Fc+P6qLtqOsJ6XM8mp4Zhc0VEREREVEEuewbS3loH++J3YIgKR+1XxyFq0F1QzPyYXRMxdSIiIiKichJ5+bCv2IbU2asg8vIRPfY+RI8ZCENEmNqlkYrYXBERERER+Um43ch6/3NYpy+C81wKogbdiZinHoCpbm21SyMNYHPlA8+RlYfZbFa7BAoA5igPZikPZikPZlm2nH2HYJ28AHmHfkbYbZ2QsO5VBDW7XO2yCmGO6mJzVQY2WPrHDOXAHOXBLOXBLOXBLH3L/+U0rFMXIvvj/Qi+qjnqbZuD0E5XqV1WMcxRfWyuysBbseufEAIulwtGo5FZ6hhzlAezlAezlAezLJnzr79he3UZMtb/B6aGdRG/ZDLCe96k2XXEHNXH5soHIYTaJVCAuN1uGI1GtcugSmKO8mCW8mCW8mCW/+POzEba3PVIW7ARSmgIak0dC8uwnlCCtH/KHXNUF5srIiIiIiIAwuFE+poPYXttOURmNiyj+iL60fthtESqXRrpBJsrIiIiIqrRhBDI+mgvbFMXwnH6PCL7d0fshAdhSoxXuzTSGTZXRERERFRj5X57BNZJ85F78ChCu16L+OVTEdyiqdplkU6xufKBFwLKg+cey4E5yoNZyoNZyqOmZZl/8ixsUxcj66M9CEr+FxLefQNhN7RTu6xKq2k5ag2bqzKwwdI/RVF4oJEAc5QHs5QHs5RHTcrSedGG1Fkrkb76A5gSaiNu/vOI6H0LFINB7dIqrSblqFVsrsrAW7HrnxDCmyOz1C/mKA9mKQ9mKY+akKU7KwdpCzchbe56KCYjar0wGlEP3gtDSLDapQVMTchR69hc+cBbscvD6XTyieUSYI7yYJbyYJbykDVL4XQiY8MO2F5dBldqOiwP3ouYcUNgjIlSu7QqIWuOesHmioiIiIikI4RA9u79sE5ZCMevvyOi9y2IfXYEzJfVU7s0khibKyIiIiKSSu6hn/+5A+D+HxHSuS3i5z2P4NbN1C6LagA2V0RERESkSzk5OcjJyfH+23XuL+S8sRaOj76EIekyxK6ahugeXXj9EVUbNlc+cEeUB7OUA3OUB7OUB7OUhx6zPHHiBI4ePQpTVi7q7jiIuvuOwRkRgj/uuwl/t2+Glg1iEaPD5aoMPeYoEzZXZeAGqn+KovDCTgkwR3kwS3kwS3noNcsm9Rug1kffIHfxe3C7XPi5UzM0fHokrv5XEwBAaGioyhVWL73mKBM2V0RERESkK8LlQsY7H8P2ylK4LlphGXYPLvS4Bof3fo7LQoMRGxurdolUQ7G5KgOfc6V/Qgg4nU6YTCZmqWPMUR7MUh7MUh56yjL7829hnbwA+cdOIPyuG1Hr+dEwN66PE99+988dAnPz1S5RNXrKUVZsrnzgc67kwSzlwBzlwSzlwSzlofUs844ch3XKAuR8cRAh17ZC4o6FCGnXAgCQnpmH7ft+h9ElsH3f77jyymRERcjzcODy0HqOsmNzRURERESa5Tj3F2wzliLznY9hbtIAdVe/jLDunQt9M/OnNQvn/sxAozDg3J8Z+MuaXWObK1IXmysiIiIi0hyXPQNpb66Bfcl7MERFoPZrTyDq/jugmIp/fE2oFY4GCZGAHWiQEIm6tcJUqJiIzRURERERaYjIy4d9xVakzl4NkedA9KP3I/rfA2CIKL1hiooIxp2dGmH3rp/Ro1MjfmtFqmFz5QMvBJQHb0sqB+YoD2YpD2YpD7WzFG43Mrd9Btv0xXCev4ioQXci5slhMNWt7df8YSFBUBQFYSFBVVyptqmdY03H5qoMbLD0jxnKgTnKg1nKg1nKQ+0sc776AdZJ85F3+FeE9eiMhA0zEZTUqFxjREREeP+rqdTOkdhclYm3Ytc/IQRcLheMRiOz1DHmKA9mKQ9mKQ+1ssz/5TSsUxYge/fXCG7bHPXen4vQjm38nj8nJwc5OTkA/mksYmJioCgKbDYbgH8eIlyTHiTMfVJ9bK584K0s5eF2u2E0GtUugyqJOcqDWcqDWcqjOrN0/nkJtleXIWPDDpgaJiB+6RSE331juRuCEydO4OjRowAAl8uF3Nxc7Nu3z7scLVu2RHJycsDr1zLuk+pic0VERERE1cKdkYXUuethX7gJSlgIak8bi6ihPaEEVew6oaZNmyIxMbHU12vSt1akDWyuiIiIiKhKCYcT6aveh23WCoisHFge6o/osffBGFW566Nq2ml/pH2aaq7OnDmDZcuW4fDhwzh+/DgaN26M7du3+5zn4sWLWLlyJfbt24ezZ88iMjIS11xzDcaPH+/zLxlEREREVLWEEMjavge2aYvgOH0ekQN6IHbCgzDVi1O7NKIqoanm6vjx49izZw9at24Nt9vt1zVPx44dw+7du9G7d2+0bt0aqampWLBgAfr27Yvt27cjNja2wvXwQkB58NxjOTBHeTBLeTBLeQQ6y5wDP/1zB8DvjiHs5usQv2Iagq9sEtCfQcVxn1SXppqrrl27olu3bgCACRMmeC9Q9OXqq6/Gjh07YCrwtO62bdvixhtvxLZt2zB8+PBK1cQGS/8UReGBRgLMUR7MUh7MUh6BzDL/xFnYpi1C1kd7EdQqCQnvvYGwLu0CMjb5xn1SfZpqrgwGQ7nniYqKKjatbt26iI2NxcWLFytdE2/Frn9CCG+OzFK/mKM8mKU8mKU8ApGl86INqbNWIH31hzDVq4O4hS8iotfNUCrw+Y4qhvuk+jTVXAXK6dOnYbVa0aRJ5b565q3Y5eF0OvnEcgkwR3kwS3kwS3lUNEt3ZjbSFm5C2twNUMxG1HrxIUQN7wVDSHAVVEll4T6pLumaKyEEpk2bhri4ONxxxx0BGa8oRVFKbbw8fyXw9XpVzctxS37N81ecgv9Wu6aaOm5layqaZaDGrap6q2JcLdZU3nEL5qiHevVcU1WPW3S/5DpUf9yKzuuZr7TPPSWNK5xOZKz/D1JnLocrLQOWEb0R/dggGGOivO/X4zrUWjblGbekfVLL9eq9ppJI11zNnTsX33zzDZYuXYqwsLBKj+dwOAp9rWowGLzXdzkcjmLvDwoKAvDPg+zcbneh10wmExRFgdvthsvlKvSaZ1whRInjev4CUdK4RqMRRqMRQgg4nc5CrymK4p3X6XQW2ziqalx/lhUovg6rYlxP/WazGYqilHtZy8pcjXXoGbekmqoqG8+ylrYOPeP6WoeB2r49+6S/27evdVid2zfAYwRQ+AOcFo4RBZeVx4jyrcOi+6VWjhH+LiuPEf9bVoPB4J234OeekpZVCIHc3V8j7eUlcB4/i4g+t8Dy9HAYEuPgBuD+/58vy+eIgutQ68eIgu/z1MvPEYE5Rnj+WFAWqZqrzZs3Y968eZg+fTo6dOgQkDE9G0Fpr5Wm4EZblMFgKPX6soIhl3fcsuYteNOP6hrX17ICvtdhoMYt+hfVyiyrGtloYR16VHYdVnb7NplMpe6TFV1WtbKpyceIgr8cZdq+SxvXQ8ZjhOf46tkv1T5GVMWy1sRjRGmfe0wmE3J/+C9skxcg9+vDCLm+LeIXvICQ1lf4/Mu+XrfvovRwjCi6TwJyrUM1jxH+NFaARM3V7t27MWnSJDz66KPo06dPQMb0/KIoaWWWtYJ9vV5V83Lc0l8ruPNrpaaaOG5la/Ic3Mq7T3Idam9czz6pl3r1WlN1jFvSfql2TTV53IrOK4TweYx1nD4P6/TFyHr/MwRd2RgJG2chtGt773tlWoday6a84xbNUev1ylBTQVI0VwcOHMD48ePRt29fjBkzJqBjl2dlkjaV9ZcK0gfmKA9mKQ9mKY/SsnRZ05D6+irYV26DsXYM6sx5FpH9boPC231rEvdJ9WmqucrJycGePXsAAOfPn0dmZiZ27twJAGjfvj1iY2MxdOhQXLhwAbt37wYAnDx5EmPGjEGjRo3Qs2dP/Pjjj97xYmNj0bBhw2pfDiIiIiI9c+fkwb74HaS9tRYAEPvMg7CM7ANDWIjKlRFpm6aaK6vViscee6zQNM+/V69ejWuvvbbYxXOHDx9GRkYGMjIyMHDgwELz9urVCzNmzKhUTf5evEba5bmA0XOhJOkTc5QHs5QHs5SHJ0ujoiDznY9hm7EMrotWWB7ohZjxQ2CsHaN2ieQH7pPqU0R57i1Ygxw5cgRCCCQnJ3Pj1DnPxfO+LtIl7WOO8mCW8mCW8nC73cjYvR/p05cg/+dTCO/ZFbUmjoS5cX21S6Ny4D5ZdY4cOQIASE5O9vk+TX1zRURERETVK++n32CdNB85X36PkOtaIXHnQoRc3ULtsoh0ic0VERERUQ3kOPcXbK8sQeY7H8P8r4aovWIqIm/v4vP22kTkG5srIiIiohrElZaB1DdXw77kPRijI1Hn9acQMbAHnLzOnKjS2Fz5wAOMPHw9GI70gznKg1nKg1nqh8jLh33ZFqS+sRoi34mYcYMR/VB/GCLCIISAiZfhS4H7pLq49svABkv/SnsgIukLc5QHs5QHs9QH4XYjc+unsL28BM7zFxE15C7EPDEMpvha3vcwSzkwR/WxuSoDb8Wuf0IIuN1u7xPLSZ+YozyYpTyYpfZlf/k9rJPmI/+n3xB++/VI2Pgagv51WbH3MUs5MEf1sbnygXepl4fL5eIFuhJgjvJglvJgltqU99+TsE1ZiOxPv0Fwuxao9+E8hF7Xyuc8zFIOzFFdbK6IiIiIJOG8cBG2GcuQsXEHzI0SEb9sCsLvupHfYhBVEzZXRERERDrnSs9E2tz1sC/aDCUsBLVffgxRQ+6GEmRWuzSiGoXNFREREZFOiXwH0le9D9vrKyGyc2F5qD9ixt4HQ2S42qUR1UhsrnzgV+jy4LnHcmCO8mCW8mCW6hBCIOuDL2CdtgjOs38icmAPxD7zIEwJdSo8JrOUA3NUF5urMrDB0j9FUfjMBwkwR3kwS3kwS3XkfH0Y1snzkff9fxHW7TrUXTUdwVc2qdSYzFIOzFF9XPtl4K3Y9a/gXR+ZpX4xR3kwS3kwy+qVf/wMrFMXInvHVwhqlYSELW8i7PqrAzI2s5QDc1QfmysfeCt2eTgcDpjNvKhX75ijPJilPJhl1XOmWJE6awXS12yHKTEOcYteQsQ9XaEE+PQvZikH5qguNldEREREGuTOzEbagk1Ie3sDlCATak16GJYHekEJDlK7NCIqBZsrIiIiIg0RTifS132E1FeXw52eCcvI3oh+bDCM0ZFql0ZEZWBzRURERKQBQghk7/wK1qmL4DhxFhF9b0XshBEwN6irdmlE5Cc2Vz7wQkB5MEs5MEd5MEt5MMvAyP3+GKyTFiD3m8MIvaEd4he+iOBWSdVaA7OUA3NUF5urMnAD1T9FUXhhpwSYozyYpTyYZeU5Tv0B6/TFyPrgcwS1aIKETbMQelP7av/8wSzlwBzVx+aKiIiIqJq5/k5F6uurYF+5Dca4WqgzdyIi+94KxWhUuzQiqgQ2V2Xgc670TwgBp9MJk8nELHWMOcqDWcqDWZafOzsX9kWbkTpnHRRFQeyzI2EZ2QeG0GBV62KWcmCO6mNz5QOfcyUPZikH5igPZikPZukf4XIhY9NO2GYsg+vvVFiG90LMuCEw1opWuzQvZikH5qguNldEREREVUQIgexPD8A2ZQHyfz6FiHu6InbiKJgvT1S7NCKqAmyuiIiIiKpA3uFfYZ08Hzlf/oCQDq2RuGsRQtpeqXZZRFSF2FwRERERBZDj7J+wvbwEme/thjnpMtRdNwNht3TkNTBENQCbKx94EJSHycRNXQbMUR7MUh7M8n9cqelIfXMN7EvfgzE6EnVmP4XIgbdD0ck6YpZyYI7q4tovAxss/VMUhTlKgDnKg1nKg1n+w52bh/RlW5D6xmoIpwsx44cg+qH+MISHql2a35ilHJij+thclYG3Ytc/IQTcbjcMBgOz1DHmKA9mKY+anqVwu5H53m7YXl4C559/I2rI3Yh5chhMcbFql1ZuNT1LWTBH9bG58oG3spSHy+WCwWBQuwyqJOYoD2Ypj5qaZfbe72CdNB/5R44j/I4bkPDOKAQ1bah2WZVSU7OUDXNUF5srIiIiIj/lHTsB65SFyPnsAIKvaYl62+ch9NpWapdFRBrB5oqIiIioDM4LF2F7ZSkyNu2E+fJExK+YhvA7uvDUKyIqhM0VERERUSlc6ZlIe2st7IvfgRIRhtozxiFq8F1QzPwIRUTF8cjgA/8aJQ+eeywH5igPZikPWbMU+Q7YV76P1NdXQuTkIvrfAxH9yEAYIsPVLq3KyJplTcMc1cXmqgxssPRPURQ+80ECzFEezFIees8yJycHOTk5AAC73Y5Dhw6hTZs2CNt/FDmz18B9/iIi77sdsc88CFPd2ipXW7X0niX9gzmqj2u/DLwVu/4VvOsjs9Qv5igPZikPvWd54sQJHD16FACQmZkJ1/f/RdrUNRB//I3UFpchZNJENLn7NpWrrB56z5L+wRzVx+bKB96KXR4OhwNms1ntMqiSmKM8mKU89Jxl06ZNkZiYCNfJc/jrxbcR9t0vyGuSiIhVUxFzXSuEhurnIcCBoOcs6X+Yo7rYXBEREVGNZLZnIfO1FUhfux2uqAjsvTUZJ6++CU936YCoiGC1yyMiHWJzRURERDWKOzMbafM2IG3+RijBQXA9/gDm/O1Eg8gLOPdXJv6yZrO5IqIKYXNFRERENYJwOJG+bjtSZ66AOz0TllF9Ef3Y/cgyBqHekg8B+wU0SIhE3VphapdKRDrF5oqIiIikJoRA9o4vYZ26CI6T5xDR9zbEPjsC5vrxAIAoAHd2aoTdu35Gj06N+K0VEVUYmysfFEXhnVYkoCgKzGYzs9Q55igPZikPPWSZe/AorJPmI/fbIwi98RrEL56E4OR/ASh8K3a3M9/7f5vNBgAIDQ2tMTe10EOWVDbmqD42V1Qj8CAjB+YoD2YpD61mmX/yHGzTFiFr+x4EtWiKhM2vI+ym9oXeU/BW7Lm5uQgJCcGvv/6KM2fOAABatmyJ5OTkaq9dLVrNksqHOaqLzVUZ+Jwr/RNCwOVywWg0MksdY47yYJby0GKWzkupSH19JdJXvQ9TfC3Evf0cIvrcAsVoLPZez63YS1NTvrUCtJkllR9zVB+bKx/4nCt5uN1uGEv4xUr6whzlwSzloZUs3dm5sC/cjNS566AYDIidOBKWEX1gCC39+qmadNqfP7SSJVUOc1SXppqrM2fOYNmyZTh8+DCOHz+Oxo0bY/v27WXOJ4TAkiVLsH79ethsNjRv3hzPPvss2rRpU/VFExERkWqEy4WMDTtge3UZXNY0WB68FzHjhsAYa1G7NCKqgQxqF1DQ8ePHsWfPHlx22WVo0qSJ3/MtWbIEc+bMwbBhw7Bo0SLUqVMHw4cPx7lz56qwWiIiIlKLEAJZu7/GuRsfwKVxryK0Yxs03L8OtaeOZWNFRKrRVHPVtWtX7NmzB3PmzEGLFi38micvLw+LFi3C8OHDMWzYMHTo0AGzZ89GdHQ0li1bVsUVExERUXXL/fEXXLj3cfx139MwxlqQ+PFixC96CeZG9dQujYhqOE2dFmgwlL/X++GHH5CZmYkePXp4pwUFBeGWW27B7t27K1UPLwSUB889lgNzlAezlEd1Zuk4cwG2l5cgc8snMDdrhLrrXkXYLR34+zpAuF/KgTmqS1PNVUWcOnUKANC4ceNC05s0aYJVq1Z5b61aUTxg65+iKDzQSIA5yoNZyqO6snTZ7Eh9YzXsy7fCGBOFOm88g8gB3aGYdP8xRjO4X8qBOapP90el9PR0BAUFITi48N2AoqKiIISA3W6vVHPldruLNViKopR6J0HPe329XlXzctySXxNCQAgBg8GgmZpq6riVmdftdnsfjVBwn9TqsmpxHWpl3IL7ZGm0VK+ea6rqcT1ZevbLQK9Dd24e0pduQdqbayBcLsSMHwLL6H4whIcWeq+e12Ggx63ovMD/PvOU9LmnMjXpbR1qLZvyjFvSPqnlevVeU0l031xVJSEEHA5HoYOMwWCA6f//UuZwOIrNExQUBABwuVxwu92FXjOZTN4PiS6Xq9BrnnE9P7Mos9lc6rhGoxFGoxFCCDidzkKvKYrindfpdBbbOKpqXH+WFSi+DqtiXE/9oaGhUBSl3MtaVuZqrEPPuCXVVFXZeJa1tHXoGdfXOqzs9p2bm+v9Of4sq+c1X+uwOrdvgMcI4H+//IODgzVxjCi4rDxGlG8deur2zBOoY4Rwu5G95VPYZy6HK8WKqCF3I+bJB4CYSLjcbrgKLFMgtm8eI4wwGAzezzxF/4BV0z9HFFxWrR8jCu6Tnnr5OSIwxwhP01oW3TdXUVFRyM/PR15eXqFvr9LT06EoCiyWyt0xyLMRlPZaaQputEUZDIZS/2JbMOTyjlvWvJ6NvTrH9bWsgO91GKhxC/5lE6jcsqqRjRbWoUdl12Flt++CvyyKquiyqpVNTT5GFPzlKNP2Xdq4HjIeIzzHV89+GYhjhGPfj7BNWYj8o8cRfucNiHluFIKaNPB+6KrudVgTjxGlfe6pqZ8jPPRwjCi6TwJyrUO1fgd6zn7yh+6bK8+1VqdPn8YVV1zhnX7q1CnUq1evUqcEAijx63HP9LLmq8hrlZmX45b+WtG/wmmhppo4bmVrKvhfIMf1RWvjarGmiozrmaaXevVaU3WMW9J+WZFx846egHXKAuR8/i1CrmmJxI/mI6R9ckDqrcy8ehu3ovOWdHpnoGrS2zrUWjblHbdojlqvV4aaCtJ9c9W2bVtERERgx44d3ubK4XDg448/RpcuXVSujoiIiHxxnk+B7ZWlyNi8C+bG9RG/cjrCb7++XB9miIi0QlPNVU5ODvbs2QMAOH/+PDIzM7Fz504AQPv27REbG4uhQ4fiwoUL3tusBwcHY/To0Zg7dy5iY2ORlJSEDRs2IC0tDQ8++GCl6uGBXR4Vuc0/aQ9zlAezlEdFs3TZM5D21jrYF78DQ1Q4ar86DlGD7oJi1tRHkxqF+6UcmKO6NHUEs1qteOyxxwpN8/x79erVuPbaa0u8eG7kyJEQQmD58uWw2Wxo3rw5li1bhgYNGlS6JjZY+qcois/zaEkfmKM8mKU8KpKlyMuHfcU2pM5eBZGXj+ix9yF6zEAYIsKqqEryB/dLOTBH9SmiPPcWrEGOHDkCAEhOTi7jnURERFQWIQSytn0G6/RFcJ5LQeT9dyD26eEw1a2tdmlERGXytzdga+tDwWcFkH557kzm6w5IpH3MUR7MUh7+Zpmz7xCskxcg79DPCLutExLWvYqgZpdXY6VUFu6XcmCO6mNzRURERFUi/9fTsE5ZiOyP9yP4quaot20OQjtdpXZZRERVhs0VERERBZTzr79hm7kcGes+gqlhXcQvmYzwnjfxL+lEJD02V0RERBQQ7sxspL29HmkLNkEJDkKtKY/AMqwnlOAgtUsjIqoWbK6IiIioUoTDifS122F7bTlEZjYso/oi+tH7YbREql0aEVG1YnPlA09fkIfZbFa7BAoA5igPZikHIQTyP/4af01bBMepPxDZvztiJzwIU2K82qVRBXC/lANzVBebqzKwwdI/ZigH5igPZimH3G+PwDppPnIPHkXoTe0Rv3QKgls2VbssqiDul3Jgjupjc1UG3opd/4QQcLlcMBqNzFLHmKM8mKW+5Z88C9vUxcj6aA+CWv4LcRtfQ0TXa5mlznG/lANzVB+bKx/4fGV5uN1uGI1GtcugSmKO8mCW+uO8aEPqrJVIX/0BTAm1ETf/eYTf2w1Ol0vt0ihAuF/KgTmqi80VERERlcqdlYO0hZuQNnc9FKMRsc+PgmVEbxhCgv/5IySbKyIiLzZXREREVIxwOpGxYQdsry6DKzUdlgfvRczjg2GMtahdGhGRZrG5IiIiIi8hBLJ374d1ykI4fv0dEb1vQeyzI2C+rJ7apRERaR6bKx94IaA8eO6xHJijPJilNuUe+hnWyQuQu+8QQjq3Rfy85xHcupnPeZilPJilHJijuthclYENlv4pisIDjQSYozyYpfY4fr8A28uLkbn1U5ivuBx1189EWLfryvwdyCzlwSzlwBzVx+aqDLwVu/4JIbw5Mkv9Yo7yYJba4bLZkTp7FezLt8JYKxp13pyAyAHdofj54YxZyoNZyoE5qo/NlQ+8Fbs8nE4nn1guAeYoD2apLndOHuxL3kXaW2sh3G7EPvUALKP7wRAWUu6xmKU8mKUcmKO62FwRERHVEMLlQua7u2F7ZQmcKVZEDe2JmCeGwVQnRu3SiIikwOaKiIioBsj+/FtYJy9A/rETCL/rRiQ8NwpBTRqoXRYRkVTYXBEREUks78hxWKcsQM4XBxHSPhmJOxYipF0LtcsiIpISmysfeCGgPJilHJijPJhl1XP8kQLbK0uR+c4umJs0QN3VLyOse+eAr3tmKQ9mKQfmqC42V2XgBqp/iqLwwk4JMEd5MMuq5bJnIO2ttbAvfheGqHDUnjkeUYPuhGIK/K98ZikPZikH5qg+NldEREQSEHn5sK/YitTZqyHy8hH96P2I/vcAGCLC1C6NiKjGYHNVBj7nSv+EEHA6nTCZTMxSx5ijPJhlYAm3G5nbPoNt+mI4z19E1KA7EfPkMJjq1q76n80spcEs5cAc1Vep5spmsyE1NRWKoiAmJgYxMXLdypXPuZIHs5QDc5QHswyMnH2HYJ00H3k//oKw7p2RsGEmgpIaVWsNzFIezFIOzFFd5WqusrOzsXPnTnz66ac4dOgQUlNTC70eExODNm3aoFu3bujevTvCwngqAhERUaDl/3Ia1ikLkL37awS3bY56789FaMc2apdFRFTj+dVcpaamYvHixdi4cSPy8/PRrFkz3HzzzWjQoAGioqIghEB6ejr++OMPHDt2DC+88AKmTp2KAQMGYOTIkYiNja3q5SAiIpKe889LsL26DBkbdsDUMAHxS6cg/O4befoPEZFG+NVcde3aFZdddhmefvpp3HbbbWU2SzabDbt27cLmzZuxadMm/PDDDwEploiIqCZyZ2Qhde562BdughIagtrTxiJqaE8oQbwrGBGRlijCjxMzv/zyS1x//fUV+gGVmVdNR44cAQC0bNmSfxHUOSGE98YkzFK/mKM8mKX/hMOJ9NUfwDZrBURmNiyj+yH60fthjIpQuzQAzFImzFIOzLHqeHqD5ORkn+/z65uryjRHemysCuKGqX88wMiBOcqDWZZNCIGs7Xtgm7YIjtPnETmgB2InPAhTvTi1SyuEWcqDWcqBOaqv0rdiz8/PR1BQUCBq0STeil3/hBBwu90wGAzMUseYozyYpW85B36CdfIC5B08irCbr0P88qkIbtFU7bJKxCzlwSzlwBzVZ/D3jYcOHcLNN9+MW2+9FZ9//rl3+ogRI6qkMC3grSzl4XK51C6BAoA5yoNZFpd/4iz+GvYcLtw5BiI3DwnvvYGEja9ptrHyYJbyYJZyYI7q8vubq5dffhlDhgyBEAJPPfUUxo4di6FDh7IBISIiqgTnRRtSZ61A+uoPYapXB3ELXkDEvd2gGPz++ycREWmE382VyWTC0KFDAQAdO3bEqFGjEBQUxK8ciYiIKsCdmY20hZuQ9vYGKCYjar34EKKG94IhJFjt0oiIqIIqdM1VUlIS1qxZg6FDhyIrKyvQNREREUlLOJ3IWP8f2F5dBldaBiwjeiPm8cEwxkSpXRoREVWS3+ccXH311Thz5oz33w0aNMCqVavQuHHjKilMC/itnDyMRqPaJVAAMEd51MQshRDI2rUP524YhktPvIbQLlej4dfrUHvyGF03VjUxS1kxSzkwR3X59Zyrmsjfe9kTERGVJfeH/8I6aT5yvz6M0OvbotZL/0Zw62Zql0VERH4K6HOu/JGTk4OPPvoI+fn5uOGGG5CYmBiooVXFW7HrX8G/HzBL/WKO8pAxy5ycHPz3v/8FAFx55ZUIDQ0FADhOn4ft5cXI3PYZgq5sjISNsxDatb00yy1jljUVs5QDc1RfhZqriRMn4qeffsL27dsB/POsq379+uH48eMAgMjISKxatQpXXnll4CpVAb/Uk4fD4YDZbFa7DKok5igPGbLMyclBTk4OAMBut+PQoUMAgNjYWES6FDiXbEHWmg9hrB2DOm9NQGT/7lAkPF1HhizpH8xSDsxRXRVqrg4cOIC7777b++/t27fj+PHjmDVrFq644gqMHTsWb7/9NubPnx+wQomIiLTkxIkTOHr0KAAgMysbKSkXESSAU5Pmov5nh2E0GFDr6eGwjOoLQ1iIytUSEVF1qFBz9ffffxc67e+TTz5By5YtceeddwIA+vXrh2XLlgWmQiIiIg1q2rQpEhMTkZmdjyWb9qLJTwfR9ttTCMvJR8h9PRA9fggi6ieoXSYREVWjCjVXoaGhyMjIAAA4nU58++23GDRokPf18PBw7+tEREQyCg0NRUhICP7++FN0X7QOdVNtONWkLmpPegJNu1+ndnlERKSCCjVXLVq0wObNm3Httdfis88+Q1ZWFrp27ep9/ezZs6hVq1bAilQLLwSUB7OUA3OUhwxZph88gtRpi2DcfxhoUA8fdm2P1Pr10LdhDGw2G0JDQ703tpCZDFnSP5ilHJijuirUXD3++OMYMWIEevfuDSEEbrvtNrRq1cr7+u7du9G2bduAFakmbqD6pygKL+yUAHOUh96zdJz7C7ZXliDznY+REx+NcyN74I/L45B18SJCTU58f/AbHAkKQsuWLaV/nIfes6T/YZZyYI7qq1BzlZycjB07duCHH35AVFQU2rdv730tPT0d9913X6FpREREeudKy0DaW2tgX/IeDFERsLzyGKLvvgH1TEZcYbfj008/BQB06dIFFoulRnxrRUREhWnuIcInT57EtGnTcOjQIYSHh6Nnz554/PHHERQU5HO+1NRUvPHGG9i7dy/S0tJQv3593H///Rg4cGCF6vA8KKxly5b89krnhBBwOp0wmUzMUseYozz0lqXIy4d9+Rakzl4Nke9E9CMDEf1wfxgiwrzvKe05V7LTW5ZUOmYpB+ZYdQL6EOE///wTCQkVu+NReea12+0YOnQoGjVqhLlz5yIlJQUzZsxAbm4uXnzxRZ/zPvbYYzh16hTGjx+PhIQE7N27F5MmTYLRaES/fv0qVLvG+k6qBGYpB+YoDz1kKdxuZG79FLaXl8B5/iKiBt+JmCcfgCm++DXFoaGhuPrqq1WoUn16yJL8wyzlwBzV5Vdzdcstt+Cuu+7CwIEDC11b5csPP/yAjRs3YseOHd5OrywbN25EVlYW3n77bURHRwMAXC4XJk+ejNGjRyM+Pr7E+S5duoQDBw7glVdewb333gsA6NChA44cOYKPPvqows0VERHVTNlffg/rpPnI/+k3hN9+PRI2voagf12mdllERKRxfjVX69evx5tvvol+/fqhXr16uO6669CiRQvUr18fUVFREEIgPT0df/zxB44ePYpvvvkGKSkpuPbaa7Fu3Tq/i9m7dy86dOjgbawAoEePHnjppZewb98+b+NUlNPpBABERkYWmh4REYHs7Gy/fz4REdVseT+fgm3yAmR/+g2C27VAvQ/nIfQ6//6oSERE5Fdz1apVKyxfvhw///wz3nvvPXz22WfYsmULgP/dTc/zFWRCQgK6deuG3r17o3nz5uUq5tSpU+jdu3ehaVFRUahTpw5OnTpV6nwJCQno3LkzFi5ciMsvvxx169bF3r17sW/fPsyaNatcNRARUc3j/PMSbDOWIWPjDpgvq4f4ZVMQfteNvGaBiIjKpVx3C2zevDmef/55PP/880hJScGpU6eQlpYGAIiOjkbjxo1LPXXPH+np6YiKiio23WKxwG63+5x37ty5GDduHO644w4AgNFoxPPPP4/bbrutwvUoilLieaulTfe8BpR+vmtVzstxS35NCAGj0Vjo32rXVFPHrWxNRqOx2Hu0uqxaXYdaGLfgPql2ve70TKS9vQH2RZuhhIWg9vRHETn4LihB5mI/Q0vrUCvjFt0vuX2rP25F5wVQ4jE2EDXpbR1qLZvyjFvSPqnlevVeU0kqdCt2AIiPj69UIxVIQgg8++yz+P333/H666+jTp062L9/P15++WVYLBZvw1URnlMOPQwGA0ymf1abw+Eo9n7PXQ1dLhfcbneh1zx3bnG73XC5XCWOK4QocVzPMwtKGtdoNHp3pKL1FnzegdPpLLZxVNW4/iwrUHwdVtW4ntcrsqxljavGOvSMW1JNVbkOzWYzFEXxuX37WoeV2b49r5dnWT2v+VqH1bl9AzxGFF1Wl8ulyjEiPysbmWu3I/2NNRDZuYgc1Qexjw2CMSoCTqcT7iI/l8cI/5dVrWNEZbZvHiP+WVZFUTR3jNDS5whf2zePEf4vq16PEUIIbyPmS4Wbq6oQFRWFjIyMYtPtdjssFkup833xxRfYuXMnPvjgAzRr1gwAcO2118JqtWLGjBmVaq583crS10PaCm60RRkMBu8H/aIKhlzeccua17OxV+e4vpYV8L0OAzWuEKLQjlaZZVUjGy2sQw/PvlDRZa3M9l2w5pL2yYouq1rZ1ORjhGefVBSl2rdvIQQyP/wCtmmL4Pz9AiIH9kDM08NhqhdX6e27rHplPEZ4svTsl2oeI6pqHdaUY4QnS1+fe2rq5wgPPRwjiu6TgFzrUM1jhD+NFaCx5qpx48bFrq3KyMjApUuX0Lhx41LnO3HiBIxGI5KSkgpNb968Od555x3k5ORU6Jkjng61pJVZ1gr29XpVzctxS3/N7XZ7dzat1FQTx61sTZ4cy7tPch1qb1xfWVZmXF+v5XzzE6yT5iHv+/8irNt1qLtyOoKvbFLpcQMxr57HLSlLtWuqyeNWdF7Ph3Jf+6XWllVv41ZXTUVz1Hq9MtRUUOntpgq6dOmC/fv3Iz093Ttt586dMBgM6NSpU6nzJSYmwuVy4ddffy00/dixY6hVq1aNeZgjEREVl3/8DP4c8iwu3DUGwuFEwpY3kbDhtRIbKyIiosrQ1DdXAwYMwJo1azBmzBiMHj0aKSkpmDlzJgYMGFDo+q6hQ4fiwoUL2L17N4B/mrJ69erh0UcfxZgxYxAXF4evvvoKW7duxdixY9VaHCIiUpEzxYrUWSuQvmY7TPXqIG7hi4jodTMUH6exEBERVYammiuLxYJVq1Zh6tSpGDNmDMLDw9GnTx+MGzeu0PuKXkAXERGBlStX4o033sCsWbOQkZGB+vXrY8KECRg0aFB1LwYREanInZmNtAWbkPb2BihBJtR66SFYht8LJThI7dKIiEhyiijPvQVrkCNHjgAAWrZsWa7zLEl7hBBwuVxlXt9B2sYc5VFVWQqnE+nrPkLqq8vhTs+EZWRvRD82GMboyLJnpgrhfikPZikH5lh1PL1BcnKyz/f5fW7EqVOnMHToUDzwwAM4duyYd/qYMWMqWKI+cMPUP0VRfN79iPSBOcoj0FkKIZC140uc6zIMfz85C6E3tkODr9eh1kv/ZmNVxbhfyoNZyoE5qs/v5uqll15Cs2bN0LRpUwwaNAi7du0CgEI3n5ARv9jTPyGE9z/SL+Yoj0Bmmfv9MVy4eyz+GjIRpoTaqP/pMsTPfwHmBnUDUCmVhfulPJilHJij+vy+5iovLw8TJ04EAHTt2hXjxo2TvjPmhikPh8Ph89kGpA/MUR6VzdJx6g9Ypy9G1gefI+jKxkjYNAuhN7WX+neSVnG/lAezlANzVJffzVXBB2t16NABixcvxr///W+fDw8jIiIKJNffqUidvRr2ldtgrBOLOnMnIrLvrVB8PHyaiIiouvjdGdWvXx9nzpzx/rtVq1aYP39+lRRFRERUkDs7F6lvrsHZ9gORsXEHYp95EA2/WY+oAT3YWBERkWb4/c1V3759ERlZ+MLgVq1aYe/evQEvioiICACEy4WMTTthm7EMrr9TYXmgF2LGD4GxVrTapRERERXj9zdXQ4YMwb59+6qyFiIiIgD/fwfAT77BHzcNx6XHZiCkfTIa7luL2tMfZWNFRESa5fc3VzXx5g6KovDiaAkoigKz2cwsdY45yqOsLPMO/wrr5PnI+fIHhHRojcSdCxFydYtqrpL8wf1SHsxSDsxRfX43V0R6xoOMHJijPErK0nH2T9heWYLMd3fDnHQZ6q6dgbBbOzJ3jWM+8mCWcmCO6ipXc1UTwxJC1MjllgmfVi4H5iiPolm6UtOR+uYa2Je+B2N0JOrMfgqRA2+HYuLf/7SO+6U8mKUcmKP6yvWb66mnnsJTTz3l13sVRcF///vfChWlFTXxVEhZud1uGHlHMd1jjvJwu91QHE5kLN+K1DdWQzhdiBk/BNEP9YchPFTt8qgcuF/Kg1nKgTmqq1zNVceOHdGoUaMqKoWIiGoC4XYja8snSJ+5As4LlxA15C7EPPkATHGxapdGRERUKeVqru655x7cddddVVULERFJLnvvd7BOmo/8I8cRdvv1SNj8OoKaNlS7LCIiooDgCe1ERFTl8o6dgHXKQuR8dgDB7VogbttbiOh4Fa8JICIiqbC58oG/9OVh4oXxUmCO+uO8cBG2V5YiY9NOmC9PRPyKaQi7/Xq1y6IA4n4pD2YpB+aoLq79MrDB0j8+r0wOzFFfXOmZSJuzDvZFm6FEhKH2K48jasjdUMz8tSMT7pfyYJZyYI7q8/u33C+//FKVdWgWb8Wuf0IIb47MUr+Yoz6IfAfsK99H6usrIXJyEf3vgYh+ZCAMkeH/ew+zlAazlAezlANzVB//hOgDb8UuD6fTCbPZrHYZVEnMUbuEEMh6/3NYpy+C8+xfiLzvdsQ+PRymhDolvp9ZyoNZyoNZyoE5qovNFRERVUrO/h9hnTwfeT/8jLBbOyJhzQwEXXG52mURERFVOzZXRERUIfm//Q7r1EXI3vkVgls3Q72tbyG0c1u1yyIiIlINmysiIioX519/I/W1FUhfux2mBvGIW/wSInp2hWIwqF0aERGRqthc+cALAeVh4Ic+KTBHdbkzs5E2bwPS5m+EEmRGrcn/huWBXlCCg8o9FrOUB7OUB7OUA3NUF5urMrDB0j9FUfjMBwkwR/UIhxPp67YjdeYKuNMzYRnVB9GPDoIxOrJC4zFLeTBLeTBLOTBH9XHtU43AW+rLgTlWLyEEsnd8CevURXCcPIeIvrch9tkRMNePD8jYzFIOzFIezFIOzFFdbK58KPisANIvIQQcDgfMZjOz1DHmWL1yvzsG66T5yD3wE0JvvAbxiychOPlfARmbWcqDWcqDWcqBOaqPzRUREXnlnzwH2/TFyPrwCwS1aIqEza8j7Kb2apdFRESkC2yuiIgIzkupSH19JdJXvQ9TfC3Evf0cIvrcAsVoVLs0IiIi3WBzRURUg7mzc2FfuBmpc9dBMRgQO3EkLCP6wBAarHZpREREusPmioioBhIuFzI27oRtxlK4rGmwDO+FmPFDYYy1qF0aERGRbrG58oEXAsrDbDarXQIFAHOsPCEEsj/5BtYpC+D45TQiet2M2ImjYG5Ur1rrYJbyYJbyYJZyYI7qYnNVBjZY+scM5cAcKy/3x19gnbwAuV/9gJCObRD38WKEXNW82utglvJglvJglnJgjupjc1UG3opd/4QQcLlcMBqNzFLHmGPFOc5cgO3lJcjc8gnMzRqh7rpXEXZLB9XWI7OUB7OUB7OUA3NUH5srH4QQapdAAeJ2u2HkXc90jzmWjys1HalvrIZ92RYYY6JQZ/bTiBzYA4pJ/UM/s5QHs5QHs5QDc1SX+r9hiYgooNy5ebAvfQ9pb66BcLoQO34oLA/1gyE8VO3SiIiIpMbmiohIEsLtRua7H8P2ylI4//obUUN6IubJYTDViVG7NCIiohqBzRURkQSy93wH66T5yD96HOF33ICEd0chqElDtcsiIiKqUdhc+cALAeXBc4/lwByLyzt6AtYpC5Dz+bcIuaYlEj+aj5D2yWqXVSZmKQ9mKQ9mKQfmqC42V2Vgg6V/iqLwQCMB5liY83wKbK8sRcbmXTA3ro/4ldMRfvv1ujhmMUt5MEt5MEs5MEf1sbkqA2/Frn9CCG+OzFK/mOM/XPYMpL21DvYl78AQGY7ar45D1KC7oJj1czhnlvJglvJglnJgjurTz29jFfBW7PJwOp18YrkEanKOIt8B+4ptSJ29CiI3D9FjBiL6kftgiAhTu7QKqclZyoZZyoNZyoE5qovNFRGRhgkhkLXtM1hfXgzn2b8Qef8diH16OEx1a6tdGhERERXB5oqIqJrl5OQgJycHAGC323Ho0CFcddVVsFgsAIDQ0FCEhoYiZ98hWCcvQN6hnxF2WyckrJ2BoGaXq1k6ERER+cDmioiomp04cQJHjx4FAGRmZuKvv/6C1WpFREQEACA5ohZqbfoM2bv2Ifiq5qi3bQ5CO12lZslERETkBzZXPvBCQHkwSznIkmPTpk2RmJgIAPjx8BH8+eefaNI0Ca0SEpEzdwPy312I/AbxiF88CeH3dJVmuQuScZlqKmYpD2YpB+aoLs01VydPnsS0adNw6NAhhIeHo2fPnnj88ccRFBRU5rwpKSmYPXs29uzZg+zsbCQmJuLhhx/G3XffXeF6uIHqn6IovLBTAjLl6DntLz0zD5/9eAnBuU6kvvUB7D/8BENIEGpNeQSWYT2hBJd93NMjmbKs6ZilPJilHJij+jTVXNntdgwdOhSNGjXC3LlzkZKSghkzZiA3Nxcvvviiz3kvXryI/v374/LLL8fUqVMRERGB48ePIz8/v5qqJyIqnz9T7Ij/7FvcdPh7mPNdcA+6B41eeBBGS6TapREREVEFaKq52rhxI7KysvD2228jOjoaAOByuTB58mSMHj0a8fHxpc772muvoW7duli6dKn34WkdOnSodE18zpX+CSHgdDphMpmYpY7JlKMQAln/+RLBkxegx+k/cPKKBPxwc3eMefJ+GCOC1S6vysmUZU3HLOXBLOXAHNVnULuAgvbu3YsOHTp4GysA6NGjB9xuN/bt21fqfJmZmdixYwfuu+++gD6Vms+5kgezlIMMOeZ+ewTnejyElGHPQUmsgz9njsGBW1ri2huawJmfBZvN5r2ToMxkyJL+wSzlwSzlwBzVpalvrk6dOoXevXsXmhYVFYU6derg1KlTpc537NgxOBwOmEwmDBo0CIcOHUJ0dDTuuecePP744zz3lIhUl3/yLGxTFyProz1wN62P3/59F9KvaIDMzAwoioKTJ35Dyl8XAAAtW7ZEcnKyyhUTERFReWmquUpPT0dUVFSx6RaLBXa7vdT5/v77bwDA888/j379+uGRRx7BTz/9hDlz5sBgMOCJJ56ocE0ldf+KopT6VwHPV7C+Xq+qeTluya8JIQpN00JNNXXcytZUNMtAjVtV9QKA61IqUl9fifTVH8AYXwtx856D8Y7rEZubC6D4c64URUFISEipxx4tL6u/4xbMUQ/16rmmqh636H7Jdaj+uBWd1zOfzMcetcetjppK2ie1XK/eayqJppqrinK73QCAjh07YsKECQCA6667DllZWVi+fDnGjBmDkJCQCo3tcDgKnbNqMBhgMpm8rxXluauhy+Xy1uXhOf/V7XbD5XIVes0zrhCixHE9376VNK7RaITRaPSeZ1tQwbvGOJ3OYhtHVY3rz7ICxddhVYzrqd9sNkNRlHIva1mZq7EOPeOWVFNVZeNZ1tLWoWdcX+swUNu3Z5/0d/v2tQ6ravt2Z+XANn8jMuZvBIwGWCY8iMgHeiE46p9nWQUFB8PtdiMyMhL169f3jmswGOByuYqtJ5mOEQV/8WvhGFFwWXmMKN86LLpfauUY4e+yqnmMALT1OcJgMHjnLfi5h58jCi+r1o8RBd/nqZefIwJzjBDCv/swaKq5ioqKQkZGRrHpdrsdFovF53zAPw1VQR06dMDChQtx5swZNGvWrNz1FPxFURJfpxsW3GiLMhgMMBhKvtytYMjlHbeseT0be3WO62tZAd/rMFDjCiEK5ViZZVUjGy2sQ4/KrsPKbt+hoaGF6iioossa6GyE04n0NR/C9uoyuFLTYRneC9GPD4YxtvAxrCYfIwr+8pJp+y5tXA8ZjxGe4yvwzzKofYyoimVVKxs1jhGexq60zz019XOEhx6OEUX3SUCudajmMcKfxgrQWHPVuHHjYtdWZWRk4NKlS2jcuHGp8zVt2tTnuHl5eRWuydfByxdfr1fVvBy35NfK+rcaNdXUcSszr68DeGXGDVS9Qghk7/4a1qkL4fjlNCLu7YbYiSNhvqyeajVpdVx/f0FppV4911TV45b2HhmXVS/jarEmjlt9NZX0Pi3XK0tNBWnqboFdunTB/v37kZ6e7p22c+dOGAwGdOrUqdT5EhMTkZSUhP379xeavn//foSEhJTZfPlSnnMsSZuEEHC5XMxS57ScY+6Pv+BCr8fw1/3PwFgrGom7lyB+0UulNlY1nZazpPJhlvJglnJgjurTVHM1YMAAhIeHY8yYMfjqq6/w3nvvYebMmRgwYEChZ1wNHToUt9xyS6F5x40bh88++wzTp0/Hvn37sHDhQixfvhzDhg1DWFhYherhhimPoucEkz5pLUfH7xeQMmoSzt8yEi5rGuqun4l6W99CSJsr1C5N87SWJVUcs5QHs5QDc1SXpk4LtFgsWLVqFaZOnYoxY8YgPDwcffr0wbhx4wq9r6QL6Lp27YrZs2dj/vz52LBhA+Li4jB27FiMGjWqOheBiGoAl82O1NmrYF++FcZa0ajz5gREDugOJYDP2SMiIiL9UQS/ninRkSNHIIRAcnJyuc6zJO3x3FnG181JSPu0kKM7Jw/2Je8i7a21EG43YsbeD8vovjCEh6pSj15pIUsKDGYpD2YpB+ZYdY4cOQIAZT6HUlPfXBERaZFwuZD57m7YXlkCZ4oVUUN7IuaJYTDViVG7NCIiItIQNlc+sOOXR2m35SR9USPH7M+/hXXyAuQfO4Hwu25EwnOjENSkQbXXIRvuk/JglvJglnJgjupic1UGNlj6pygKDzQSqO4c844ch3XKAuR8cRAh7ZOR+J8FCLmmZbX9fJlxn5QHs5QHs5QDc1Qfm6sy+Ps0ZtIuzxPLFUVhljpWXTk6/kiB7ZWlyHxnF8yN66PuqukI63E9t50A4j4pD2YpD2YpB+aoPjZXPvBeH/JwOp0+n8pN+lCVObrsGUh7ay3si9+FISoctWeOR9T9d0Ix8zBZFbhPyoNZyoNZyoE5qoufGoioRhN5+bCv2IrU2ash8vIR/ej9iP73ABgiKvZ8PCIiIqq52FwRUY0k3G5kvv8ZbNMXw3kuBVGD7kTMUw/AVLe22qURERGRTrG5IqIaJ2ffIVgnzUfej78grHtnJKyfiaCkRmqXRURERDrH5soHXggoD2Yph8rmmP/LaVinLED27q8R3LY56r0/F6Ed2wSmOCoX7pPyYJbyYJZyYI7qYnNVBm6g+qcoCi/slEBlcnT+9Tdsry5Dxvr/wNQwAfFLpyD87hu5f6uE+6Q8mKU8mKUcmKP62FwRkbTcGVlIe3sD0hZshBIaglpTx8IyrCeUIP7iISIiosBjc1UGPudK/4QQcDqdMJlMzFLHypOjcDiRvvoD2GatgMjMhmV0P0Q/ej+MURHVVC35wn1SHsxSHsxSDsxRfWyufOBzruTBLOVQVo5CCGRt3wPbtEVwnD6PyP7dEfvsCJjqxVVTheQv7pPyYJbyYJZyYI7qYnNFRFLIOfATrJMXIO/gUYR2vRbxy6ciuEVTtcsiIiKiGoTNFRHpWv6Js7BNW4Ssj/YiKPlfSHj3DYTd0E7tsoiIiKgGYnNFRLrkvGhD6qwVSF/9IUwJtRG34AVE3NsNisGgdmlERERUQ7G58oEXAsrDZOKmLgOTyQR3Vg7sizYjbe56KCYjar34EKKG94IhJFjt8qgcuE/Kg1nKg1nKgTmqi2u/DGyw9E9RFOYoA5cLmRv+A9uMZXClZcAyojdiHh8MY0yU2pVROXGflAezlAezlANzVB+bqzLwVuz6J4SA2+2GwWBgljokhED2x/thnbIAjt/OIKL3LYidOBLmhglql0YVxH1SHsxSHsxSDsxRfWyufOCtLOXhcrlg4LU4upP7w39hnbwAuft/RMj1bRH71gSEX92CvzAkwH1SHsxSHsxSDsxRXWyuiEhzHKfPw/byYmRu+wxBzRuj7obXENq1PZxOp9qlEREREZWKzRURaYbLmobU2athX7EVxtoxqPPWBET27w7FaOQ3yURERKR5bK6ISHXunDzYF7+DtLfWQgiB2KeHwzKqLwxhIWqXRkREROQ3Nlc+8LoOefDcY20SLhcyNu/65w6AF62wDLsHMU8MhbF2TInvZ47yYJbyYJbyYJZyYI7qYnNVBjZY+qcoCp/5oDFCCOR8/i2sUxYg/9hJhN99E2o9NwrmxvVLnYc5yoNZyoNZyoNZyoE5qo9rvwy8Fbv+FbxWh1mqL++n32CdsgA5e75DyLWtkLhjIULatShzPuYoD2YpD2YpD2YpB+aoPjZXPvACenk4HA6YzWa1y6jRHOf+gm3GUmS+8zHMTRqg7uqXEda9c7kO/sxRHsxSHsxSHsxSDsxRXWyuiKhKudIykPbWGtiXvAdDVARqv/YEou6/AwpPWyAiIiLJ8NMNEVUJkZcP+/ItSJ29GiLfiejHBiH64f4wRISpXRoRERFRlWBzRUQBJdxuZG79FLaXl8B5/iKiBt2JmKcegCm+ltqlEREREVUpNldEFDA5X/0A66T5yDv8K8J6dEbChpkISmqkdllERERE1YLNlQ+KovBOKxJQFAVBQUFqlyG1vJ9PwTZlAbI/+QbBV1+Jeh+8jdAOrQP6M5ijPJilPJilPJilHJij+thcEVGFOf+8BNuMZcjYuAOmhgmIXzYF4XfdyD9KEBERUY3E5qoMfM6V/gkh4HK5YDQamWWAuDOykDp3PewLN0EJC0Ht6Y8iasjdUIKq7tavzFEezFIezFIezFIOzFF9bK584HOu5OF2u2E0GtUuQ/dEvgPpqz+AbdYKiKwcWB7qj+ix98EYFVEtP585yoNZyoNZyoNZyoE5qovNFRGVSQiBrA+/gG3aYjh+P4/Igbcj9pnhMNWLU7s0IiIiIs1gc0VEPuV88xOsk+cj77tjCLv5OsSvnIbgK5uoXRYRERGR5rC5IqIS5R8/A+vUhcje8RWCWiUh4b03ENalndplEREREWkWmysfeCGgPEwmbur+cqZYkTprBdLXbIepXh3ELXwREb1uhmIwqF0ac5QIs5QHs5QHs5QDc1QX134Z2GDpH59X5h93ZjbSFmxC2tsboASZUOulhxD1QC8YQoLVLg0Ac5QJs5QHs5QHs5QDc1Qfm6sy8Fbs+ieEgNvthsFgYJYlEE4n0td9hNRXl8OdngnLyN6IfmwwjNGRapdWCHOUB7OUB7OUB7OUA3NUH5srH3grdnm4XC4YNHBam5YIIZC9ax+sUxbCcfwMIvreithnR8LcoK7apZWKOcqDWcqDWcqDWcqBOaqLzRVRDZT7/TFYJy1A7jeHEdrlasQveAHBrZupXRYRERGRrrG5IqpBHKf+gHX6YmR98DmCrmyMhE2zEHpTe546QERERBQAmvvO8OTJk3jggQfQpk0bdOrUCTNnzkR+fn65xli5ciWaNWuG0aNHV1GVRPri+jsVf098C2c7D0buwaOoM+dZ1P9sOcK6XsvGioiIiChANPXNld1ux9ChQ9GoUSPMnTsXKSkpmDFjBnJzc/Hiiy/6NcalS5cwb9481KpVq9L18EOnPGrqucfu7FzYF7+DtDnrAACxzzwIy6i+MIRq4w6A5VVTc5QRs5QHs5QHs5QDc1SXppqrjRs3IisrC2+//Taio6MB/HNR3uTJkzF69GjEx8eXOcZrr72Grl274sKFCwGpiQ2W/imKUuOe+SBcLmRs2gnbjGVw/Z0KywO9EDN+CIy1otUurcJqYo6yYpbyYJbyYJZyYI7q01Rru3fvXnTo0MHbWAFAjx494Ha7sW/fvjLn/+677/DJJ5/giSeeqMIqSY9qyp0fhRDI/vQA/ug6HJcem4GQ9slouG8tak9/VNeNlUdNybEmYJbyYJbyYJZyYI7q0lRre+rUKfTu3bvQtKioKNSpUwenTp3yOa/L5cLUqVPx0EMPIS4uLiD1eJ4VUPTbK0VRSt1wPe/19XpVzctxS35NCAGHw4GgoCDN1FQV4+b99Ctskxci58vvEXJdayTuXIjgtleWOL5a9VZmXrfbDYfDAbPZXGif1EM2gRxXizWVd9yC+2RptFSvnmuq6nE9WXr2S65D9cet6LwAkJ+fX+wYG4ia9LYOtZZNecYtaZ/Ucr16r6kkmmqu0tPTERUVVWy6xWKB3W73Oe/69euRk5ODYcOGBbQmh8NR6CBjMBi8X7c6HI5i7/d8WHC5XHC73YVeM5lM3g+JLper0GuecT07RVFms7nUcY1GI4xGI4QQcDqdhV5TFMU7r9PpLLZxVNW4/iwrUHwdVsW4nvo9B5ryLmtZmauxDj3jAkDOqXOwz1yO7C2fwvSvhqi9chqibu8CRVHgcDgClo1nWUtbh55xfa3DQG3fnn3S3+3b1zqszu0b4DEC+Gef9PxbC8eIgssq4zGiKtdh0f1SK8cIf5eVx4j/LavBYPDOW/QPWDX9c0TBZdX6MaLg+zz1qnmMKGlZ9XqMEEIU+8NDSTTVXFWU1WrFnDlz8Oqrr/r8S2hFlPQXnIKvlabgRluUwWAo9WLDgiGXd9yy5vV1Dm5VjetrWQHf6zBQ43p2FE+OlVlWNbIpbVldaRlIfWM17EvfgzE6ErVnPYnI+26H8v8Hp4qO61FSvZVdh5Xdvk0mU6n7ZEWXVa3tuyYfIwr+ctTCMcJDtmOEPzVVdlzP8bXoN1dqHSOqYllr4jGitM89NfVzhIcejhFF90lArnWo5jHCn8YK0FhzFRUVhYyMjGLT7XY7LBZLqfO99dZbaNasGdq1a4f09HQA/3SfTqcT6enpCAsLq/DFfQV/WRSdXtZ8FXmtMvNy3NJfK/pXOC3UVNF53bl5SF++FalvrIbIdyJm3GBEP9QfhogwTdYbyJoK/hfIcX3R2rharKki4xb89jGQ41b2Ndlqqo5xS9ov1a6pJo9b0Xk9f5Uv7RhbmZr0tg61lk15xy2ao9brlaGmgjTVXDVu3LjYtVUZGRm4dOkSGjduXOp8p0+fxsGDB3HNNdcUe+2aa67BkiVL0KVLl4DXS1SdhNuNzC2fwPbyEjgvXELUkLsQ8+QDMMXFql0aEREREUFjzVWXLl2wcOHCQtde7dy5EwaDAZ06dSp1vokTJ3q/sfJ4+eWXERISgvHjx6NZs2YVqqc8XSppm6+vgfUge+93sE6aj/wjxxF++/VI2Pw6gpo2VLusaqf3HOl/mKU8mKU8mKUcmKO6NNVcDRgwAGvWrMGYMWMwevRopKSkYObMmRgwYEChZ1wNHToUFy5cwO7duwEAzZs3LzZWVFQUwsLCcO2111aqJjZY+qfnDPP+exLWyQuQ89kBBLdrgXofzkPoda3ULksVes6RCmOW8mCW8mCWcmCO6tNUc2WxWLBq1SpMnToVY8aMQXh4OPr06YNx48YVel9JdyepKv7eGYS0SwgBl8sFo9GomyydFy7CNmMZMjbugLlRIuKXT0X4nTfopv6qoMccqWTMUh7MUh7MUg7MUX2KKM+N22uQI0eOQAiB5ORkbpw6V/SZD1rmSs9E2px1sC/aDCUiDLFPPoCoIXdDMWvq7yCq0FOO5BuzlAezlAezlANzrDpHjhwBACQnJ/t8Hz+xEWmAyHfAvvJ9pL6+EiInF9H/HojoRwbCEBmudmlERERE5Cc2V0QqEkIg64MvYJ22CM6zfyJyYA/EPvMgTAl11C6NiIiIiMqJzRWRSnK+PgzrpHnI++FnhN3SAXVXv4zg5qU/coCIiIiItI3NlQ88V1UepT2tWw35v/0O69RFyN75FYJbN0O9rW8htHNbtcvSBS3lSJXDLOXBLOXBLOXAHNXF5qoMbLD0T1EUTRxonClWpM5cjvS122GqH4+4RS8h4p6uUAwGtUvTBa3kSJXHLOXBLOXBLOXAHNXH5qoMvBW7/gkhvDmqkaU7Mxtp8zcibd5GKEEm1Jr8b1ge6AUlOKjaa9EztXOkwGGW8mCW8mCWcmCO6mNz5QPvUi8Pp9NZ7U8sFw4n0tdtR+rMFXCnZ8Iyqg+iHx0EY3RktdYhEzVypKrBLOXBLOXBLOXAHNXF5ooowIQQyN7xJaxTF8Fx8hwi+t6G2GdHwFw/Xu3SiIiIiKgKsbkiCqDc747BOmk+cg/8hNAb2iF+0UsIbpWkdllEREREVA3YXBEFQP7Jc7BNX4ysD79AUIsmSNj8OsJuaq92WURERERUjdhc+cALAeVRVVm6/k6FbdZKpK96H8a4WqgzdyIi+94KhXfqqRLcJ+XBLOXBLOXBLOXAHNXF5qoM3ED1T1GUgF/Y6c7OhX3RZqTOWQdFURD77EhYRvaBITQ4oD+H/qcqciR1MEt5MEt5MEs5MEf1sbkiKgfhciFj407YZiyFy5oGy/BeiBk3BMZa0WqXRkREREQqY3NVBj7nSv+EEHA6nTCZTBXOUgiB7E++gW3qQuT/fAoRvW5G7MRRMDeqF+BqqTSByJG0gVnKg1nKg1nKgTmqj82VD3zOlTwqk2Xe4V/x96T5yP3qB4R0bIPEjxcj5KrmAayO/MV9Uh7MUh7MUh7MUg7MUV1srohK4ThzAbZXliLzvd0wJ12GuutmIOyWjvxLEBERERGViM0VURGu1HSkvrEa9mVbYIyJQp3ZTyNyYA8oJu4uRERERFQ6flok+n/u3DzYl76HtDfXQDhdiB0/FJaH+sEQHqp2aURERESkA2yufODpX/LwdVtS4XYj873dsL28BM4//0bUkLsR89QDMNWJqcYKyR+8vaw8mKU8mKU8mKUcmKO62FyVgQ2W/vnKMHvPd7BOmo/8o8cRfscNSHhnFIKaNqzG6shf3BflwSzlwSzlwSzlwBzVx+aqDLwVu/4JIeByuWA0Gr1Z5h09AeuUBcj5/FsEX9MSiR/NR0j7ZJUrJV9KypH0iVnKg1nKg1nKgTmqj82VD7yVpTzcbjeMRiOc51Nge2UpMjbvgvnyRMSvmIbwO7rwAKQTnhxJ/5ilPJilPJilHJijuthcUY3gTs+EbcFm2Be/AyUiDLVnjEPU4LugmLkLEBEREVFg8JMlSU3kO2BfsRWpr6+CyMtH9JiBiB4zEIbIcLVLIyIiIiLJsLkiKQkhkLXtM1hfXgzn2b8QPrAHaj3zIMwJddQujYiIiIgkxebKB16Ho085+w7BOnkB8g79jLBbO6Lu6ldgSroMBoNB7dKokngOuTyYpTyYpTyYpRyYo7rYXJWBDZZ+5P96Gtapi5C9ax+C21yBetvmILTTVWqXRQGiKAp/YUiCWcqDWcqDWcqBOaqPzVUZeCt27XP+9TdsM5cjY91HMDWIR/ziSQjveROU//+mSgjhzZFZ6hdzlAezlAezlAezlANzVB+bKx94K3Ztc2dmI+3t9UhbsAlKcBBqTR4DywP3QAkOKvZep9PJJ5ZLgDnKg1nKg1nKg1nKgTmqi80V6Y5wOJG+9kOkvrYC7vQsWEb1RfRj98NoiVS7NCIiIiKqwdhckW4IIZD1ny9hm7oQjlN/ILLfbYiZMALm+vFql0ZERERExOaK9CH32yOwTpqP3INHEXpTe8QvnYLglk3VLouIiIiIyIvNlQ+8EFB9+SfPwjZtMbK270FQi6ZIeGc2wm68ptzjMEs5MEd5MEt5MEt5MEs5MEd1sbkqAzdQdTgvpSJ11kqkr34fpvhaiJv3HCL63Oq9A2B5KIrCCzslwBzlwSzlwSzlwSzlwBzVx+aKNMWdlQP7ws1InbsOitGI2IkjYRnZB4aQYLVLIyIiIiLyic1VGficq+ohnE5kbNgB26vL4LLZYXnwXsSMGwJjrKXyYwsBp9MJk8nELHWMOcqDWcqDWcqDWcqBOaqPzZUPfM5V1RNCIHv317BOXQjHL6cRcW83xE4cCfNl9QL+c0j/mKM8mKU8mKU8mKUcmKO62FyRanJ//OWfOwDuO4SQTlchbvcShLS5Qu2yiIiIiIgqhM0VVTvHmQuwTV+MzK2fwnzF5ai7fibCul3Hr6+JiIiISNfYXFG1cdnsSH1jNezLtsAYa0GdN55B5IDuUEzcDImIiIhI//ip1gd+kxIY7pw82Je+i7Q310K43Yh98gFYRveFITy02mowsYGTAnOUB7OUB7OUB7OUA3NUF9d+GdhgVZxwu5H5zsewvbIEzhQroob2RMwTw2CqE1OtdSiKwhwlwBzlwSzlwSzlwSzlwBzVx+aqDLwVe8Vkf3EQ1knzkX/sBMLvvAEJz49GUJMGqtQihIDb7YbBYGCWOsYc5cEs5cEs5cEs5cAc1ae55urkyZOYNm0aDh06hPDwcPTs2ROPP/44goKCSp3n4sWLWLlyJfbt24ezZ88iMjIS11xzDcaPH4/ExMQK18JbWZZf3tETsE6ej5wvDiKkfTIS/7MAIde0VLssuFwuGAwGtcugSmKO8mCW8mCW8mCWcmCO6tJUc2W32zF06FA0atQIc+fORUpKCmbMmIHc3Fy8+OKLpc537Ngx7N69G71790br1q2RmpqKBQsWoG/fvti+fTtiY2OrcSlqJscfKbC9shSZ7+yCuXF91F01HWE9rudfTYiIiIioxtBUc7Vx40ZkZWXh7bffRnR0NIB/uu/Jkydj9OjRiI+PL3G+q6++Gjt27Ch0AV/btm1x4403Ytu2bRg+fHh1lF8juewZSHtrLeyL34UhKhy1Xx2HqEF3QTFratMiIiIiIqpymvrOcO/evejQoYO3sQKAHj16wO12Y9++faXOFxUVVezOKHXr1kVsbCwuXrxYVeXWaCIvH2kLN+PsNQNgX7YF0WPvQ8NvN8LyQC82VkRERERUI2nqU/CpU6fQu3fvQtOioqJQp04dnDp1qlxjnT59GlarFU2aNKlwPTylrTjhdiPz/c9gm74YznMpiBp0J2KeegCmurXVLs0nnnssB+YoD2YpD2YpD2YpB+aoLk01V+np6YiKiio23WKxwG63+z2OEALTpk1DXFwc7rjjjkrXVfTGFoqilHqzC09D5uv1qpq3qsfN2XcItskLkPfjLwjr3gkJ615FULPLIYQocX616y3IaDRKnY1exq3svEajsdgYWl1WLa5DLY3r2Sf1Uq9ea6qOcQvul1yH6o9bmXlLOsYGYly9rUMtZlOecYvuk1qvV881lURTzVWgzJ07F9988w2WLl2KsLCwSo2Vn59f6Bssg8HgPQXR4XAUe7/nroYulwtut7vQayaTCYqiwO12w+VyFXrNM64QosRxzWZzqeMajUYYjUYIIeB0Ogu9piiKd16n01ls4/Bn3LyfT8E6dSFyP/kGQW2aoc67sxHasY3Pcf1ZVqD4Oiyr3oqM6xnDbDbDYDCUex2WlXlVZeNrWT3jllRTVazDgsuqKIrP7dvXOqzM9u12u73jevZJf7dvX+sw0NnUxGNEeccVQsBkMsFgMGjiGFFwWUvbvnmMKHlZi/6hQ81jRGW2bx4jjN790el0Fvrco8Yxwt9lBXiMKLqsBZfXUy8/RwTmGFHwD0i+aKq5ioqKQkZGRrHpdrsdFovFrzE2b96MefPmYfr06ejQoUOl6hFCeDeCknhWeEkKbrRFGQyGUr+yLRhyeccta15fT+wuaVznX3/DOnM5Mtb/B6YGdRG3ZBLC776p2PrwNa6vZQV8r8NAjevZEQt++1HRdahGNlpYhx6VXYeV3b49dZW0T1Z0WdXKRoZjREXH9eyTQUFBUm3fpY3rIeMxwpOlZ79U+xhRFctak44RTqfT5+ee6jpGFMRjhH/jepa16D4JyLUO1TxG+NNYARprrho3blzs2qqMjAxcunQJjRs3LnP+3bt3Y9KkSXj00UfRp0+fgNRU8JdF0ellzVeR1yozb6DGdWdkIe3tDUhbsBFKaAhqTR0Ly7CeUIJK39DVrNef14r+FU4LNdXEcStbU8H/AjmuL1obV4s1VWTcgt8+BnLcyr4mW03VMW5J+6XaNdXkcSs6r+ev8qUdYytTk97WodayKe+4RXPUer0y1FSQppqrLl26YOHChYWuvdq5cycMBgM6derkc94DBw5g/Pjx6Nu3L8aMGVMd5UpHOJxIX/0BbLNWQGRmwzKqL6IfvR9GS6TapRERERERaZ6mmqsBAwZgzZo1GDNmDEaPHo2UlBTMnDkTAwYMKPSMq6FDh+LChQvYvXs3AODkyZMYM2YMGjVqhJ49e+LHH3/0vjc2NhYNGzas7kXRFSEEsj7aC9vUhXCcPo/I/t0RO+FBmBJLfq4YEREREREVp6nmymKxYNWqVZg6dSrGjBmD8PBw9OnTB+PGjSv0vqIX0B0+fBgZGRnIyMjAwIEDC723V69emDFjRoXqKc9XgHqVc+AnWCcvQN7Bowjtei3il09FcIumapcVcDUhy5qAOcqDWcqDWcqDWcqBOapLEeW5t2ANcuTIEQBAcnKyypVUjfwTZ2GbtghZH+1FUPK/UOulfyPshnZql0VEREREpDn+9gaa+uaKqp7zog2ps1YiffUHMCXURtz85xHR+xYofOAcEREREVGlsLkqg7/3tNc6d1YO0hZuQtrc9VBMRtR6YTSiHrwXhpBgtUurcp7nGnien0D6xBzlwSzlwSzlwSzlwBzVx+bKBxnOmBROJzI2/Ae2GcvgSsuA5cF7ETNuCIwxUWqXVq1kyJKYo0yYpTyYpTyYpRyYo7rYXElKCIHsj/fDOmUBHL+dQUTvWxD77AiYL6undmlERERERFJicyWh3EM/wzppPnL3/4iQzm0RP/8FBLdupnZZRERERERSY3MlEcfp87C9vBiZ2z5DUPPGqLvhNYTdfC3PuSUiIiIiqgZsrnzQS1PistmR+voq2FdshbFWNOq8NQGR/btDMRrVLk0zTCZu6jJgjvJglvJglvJglnJgjuri2i+Dlhssd04e7EveRdpbayHcbsQ+9QAso/vBEBaidmmaoiiKpnMk/zBHeTBLeTBLeTBLOTBH9bG5KoMWb8UuXC5kvPMxbK8sheuiFZZh9yDmiaEw1o5RuzRNEkLA7XbDYDBoLkvyH3OUB7OUB7OUB7OUA3NUH5srH7R4K8vszw7AOmUB8o+dRPjdN6HWc6Ngblxf7bI0z+VywcAHJesec5QHs5QHs5QHs5QDc1QXmyudyPvpN1inLkTOFwcRcm0rJO5YiJB2LdQui4iIiIiI/h+bK41znPsLthlLkfnOxzA3aYC6q19GWPfO/KqXiIiIiEhj2FxplCstA2lvrYF9yXswREWg9mtPIOr+O6DwDjBERERERJrET+o+qPHtkMjLh335FqTOXg2R70T0o/cj+t8DYIgIq/ZaZMJzj+XAHOXBLOXBLOXBLOXAHNXF5qoM1dVgCbcbmds+g236YjjPX0TUoDsR8+QwmOrWrpafLzNFUfjMBwkwR3kwS3kwS3kwSzkwR/Vx7ZehOm7FnvPVD7BOmo+8w78irEdnJGyYiaCkRlX6M2uSgnd95LVq+sUc5cEs5cEs5cEs5cAc1cfmyoeqvhV73s+nYJuyANmffIPgq69EvQ/eRmiH1lX6M2sqh8MBs9msdhlUScxRHsxSHsxSHsxSDsxRXWyuVOD88xJsry5DxoYdMDVMQPzSKQi/+0b+hYGIiIiISMfYXFUjd0YWUueuh33hJihhIag9bSyihvaEEsS/LhARERER6R2bq2og8h1IX/0BbLNWQGTlwPJQf0SPvQ/GqAi1SyMiIiIiogBhc1WFhBDI+vAL2KYthuP384gc0AOxEx6EqV6c2qUREREREVGAsbnyQVGUCl8HlfPNT7BOno+8744h7ObrEL9yGoKvbBLgCskfiqLAbDbzmjadY47yYJbyYJbyYJZyYI7qY3MVYPnHz8A2bRGy/vMlglolIeG9NxDWpZ3aZdV4PMjIgTnKg1nKg1nKg1nKgTmqi81VGfx9zpUzxYrUWSuQvmY7TPXqIG7hi4jodTMUPiVbdUIIuFwuGI1GHnB0jDnKg1nKg1nKg1nKgTmqj82VD/4858qdmY20hZuQNncDFLMRtV58CFHDe8EQElwNFZK/3G43jEaj2mVQJTFHeTBLeTBLeTBLOTBHdbG5qiDhdCJj/X9ge3UZXGkZsIzsjZjHBsMYE6V2aUREREREpAI2V+UkhED2rn2wTlkIx/EziOhzC2KfHQlzwwS1SyMiIiIiIhWxuSqH3O+PwTppAXK/OYzQ69sifsELCG7dTO2yiIiIiIhIA9hc+eC5ENBx+jys0xYh64PPEXRlYyRsnIXQru15oaCO8NxjOTBHeTBLeTBLeTBLOTBHdbG58sWeCetzc2BfuQ3G2jGoM+dZRPa7DQo3Wl1RFIUHGgkwR3kwS3kwS3kwSzkwR/WxufIhdNCLSDcYEfvMg7CM7ANDWIjaJVEFCCG8t9Tnt436xRzlwSzlwSzlwSzlwBzVx+bKB8cdnfGvSY/CVCdG7VKokpxOJ8xms9plUCUxR3kwS3kwS3kwSzkwR3XxCbc+OEb3grF2tNplEBERERGRDrC5IiIiIiIiCgA2V0RERERERAHA5soHXggoD4OBm7oMmKM8mKU8mKU8mKUcmKO6eEOLMrDB0j9FUWAycVPXO+YoD2YpD2YpD2YpB+aoPra2REREREREAcDmygfPswJI34QQyM/PZ5Y6xxzlwSzlwSzlwSzlwBzVx+aKiIiIiIgoANhcERERERERBQCbKyIiIiIiogBgc0VERERERBQAbK584G3Y5WE2m9UugQKAOcqDWcqDWcqDWcqBOapLc83VyZMn8cADD6BNmzbo1KkTZs6cifz8/DLnE0Jg8eLFuPHGG9GqVSv0798fP/74Y6XrYYOlf4qieP8j/WKO8mCW8mCW8mCWcmCO6tNUc2W32zF06FA4HA7MnTsX48aNw+bNmzFjxowy512yZAnmzJmDYcOGYdGiRahTpw6GDx+Oc+fOVaom3spS/4QQcDqdzFLnmKM8mKU8mKU8mKUcmKP6NPUI540bNyIrKwtvv/02oqOjAQAulwuTJ0/G6NGjER8fX+J8eXl5WLRoEYYPH45hw4YBAK6++mp0794dy5Ytw6RJkypUDzdMebjdbhiNRrXLoEpijvJglvJglvJglnJgjurS1DdXe/fuRYcOHbyNFQD06NEDbrcb+/btK3W+H374AZmZmejRo4d3WlBQEG655Rbs3bu3KksmIiIiIiICoLHm6tSpU2jcuHGhaVFRUahTpw5OnTrlcz4AxeZt0qQJLly4gNzc3MAXS0REREREVICmTgtMT09HVFRUsekWiwV2u93nfEFBQQgODi40PSoqCkII2O12hISElKsWh8MBIQSOHj1arvlIm4QQvLhTAsxRHsxSHsxSHsxSDsyxauTn5/u1XjXVXGkJN0q5ME85MEd5MEt5MEt5MEs5MMeq4e9dGDXVXEVFRSEjI6PYdLvdDovF4nO+/Px85OXlFfr2Kj09HYqi+Jy3NFdddVW55yEiIiIioppLU9dcNW7cuNi1VRkZGbh06VKx66mKzgcAp0+fLjT91KlTqFevXrlPCSQiIiIiIiovTTVXXbp0wf79+5Genu6dtnPnThgMBnTq1KnU+dq2bYuIiAjs2LHDO83hcODjjz9Gly5dqrRmIiIiIiIiQGOnBQ4YMABr1qzBmDFjMHr0aKSkpGDmzJkYMGBAoWdcDR06FBcuXMDu3bsBAMHBwRg9ejTmzp2L2NhYJCUlYcOGDUhLS8ODDz6o1uIQEREREVENoqnmymKxYNWqVZg6dSrGjBmD8PBw9OnTB+PGjSv0PrfbDZfLVWjayJEjIYTA8uXLYbPZ0Lx5cyxbtgwNGjSozkUgIiIiIqIaShFCCLWLICIiIiIi0jtNXXNFRERERESkV2yuiIiIiIiIAoDNFRERERERUQCwuSIiIiIiIgoANldEREREREQBwOaKiIiIiIgoANhcERERERERBQCbqyJOnjyJBx54AG3atEGnTp0wc+ZM5Ofnq10W+bBjxw48/PDD6NKlC9q0aYOePXvi3XffRdFHuL3zzju47bbbkJycjLvvvhuff/65ShWTv7KystClSxc0a9YMR44cKfQa89SHrVu34p577kFycjKuvfZajBgxArm5ud7XP/vsM9x9991ITk7Gbbfdhvfee0/Faqkkn376Kfr27YurrroKnTt3xmOPPYZz584Vex/3SW05c+YMXnzxRfTs2RNXXnkl7rzzzhLf509uGRkZmDhxItq3b4+rrroKjz76KC5evFjVi0D/r6wsMzMzMXfuXPTp0wft2rVDx44d8dBDD+HXX38tNhazrHpsrgqw2+0YOnQoHA4H5s6di3HjxmHz5s2YMWOG2qWRDytXrkRoaCgmTJiABQsWoEuXLnjhhRcwb94873s++ugjvPDCC+jRoweWLFmCNm3a4JFHHsGPP/6oXuFUpvnz58PlchWbzjz1YcGCBZg6dSpuv/12LFu2DFOmTEH9+vW9mX733Xd45JFH0KZNGyxZsgQ9evTAc889h507d6pcOXkcOHAAjzzyCJo2bYp58+Zh4sSJ+OWXXzB8+PBCTTL3Se05fvw49uzZg8suuwxNmjQp8T3+5vb4449j3759mDRpEmbNmoXTp09j5MiRcDqd1bAkVFaWFy5cwKZNm9CpUye8+eabmDp1KjIyMtC/f3+cPHmy0HuZZTUQ5LVw4ULRpk0bkZqa6p22ceNG0bx5c/HXX3+pVxj5ZLVai017/vnnRdu2bYXL5RJCCHHrrbeK8ePHF3pP//79xYgRI6qlRiq/EydOiDZt2ogNGzaIpKQk8dNPP3lfY57ad/LkSXHllVeKL774otT3DB8+XPTv37/QtPHjx4sePXpUdXnkpxdeeEF07dpVuN1u77Svv/5aJCUliYMHD3qncZ/UHs/vPyGEeOaZZ8Qdd9xR7D3+5PbDDz+IpKQk8eWXX3qnnTx5UjRr1kx89NFHVVA5FVVWlllZWSI7O7vQtMzMTNG+fXsxZcoU7zRmWT34zVUBe/fuRYcOHRAdHe2d1qNHD7jdbuzbt0+9wsin2NjYYtOaN2+OzMxMZGdn49y5c/j999/Ro0ePQu+5/fbb8fXXX/O0T42aNm0aBgwYgMsvv7zQdOapD1u2bEH9+vVxww03lPh6fn4+Dhw4gO7duxeafvvtt+PkyZP4448/qqNMKoPT6UR4eDgURfFOi4yMBADvqdfcJ7XJYPD9Ec/f3Pbu3YuoqCh06tTJ+57GjRujefPm2Lt3b+ALp2LKyjIsLAyhoaGFpoWHh6Nhw4aFTvljltWDzVUBp06dQuPGjQtNi4qKQp06dXDq1CmVqqKK+P777xEfH4+IiAhvdkU/pDdp0gQOh6PEawdIXTt37sRvv/2GMWPGFHuNeerD4cOHkZSUhPnz56NDhw5o2bIlBgwYgMOHDwMAzp49i/9r7/5joq7/OIA/QTmcwHHimgTCJFkQJ2gExw8dBGhBSqQ5wyawsKA0RJoZ/ghFWJhKRIX4g7kQtaZmGsRwxlBXGoXFAs8tfoYgNAOOuwvBw7vvH46b50Ggncfdt+djuz/u/X5/3p8X99rnw73u80ulUuntc4dPeeE+1zQsW7YMTU1NOHr0KBQKBa5fv46PPvoIXl5e8PX1BcBt0lyNN2/Nzc1wc3PTKbCBu1/KuZ2aLrlcjoaGBp19LHNpHCyu7iGXyyEUCvXa7e3t0dfXNwER0cOoqalBeXk5EhMTAUCbu/tzO/yeuTUtt27dws6dO5GWlgZbW1u9fubTPNy8eRPff/89zpw5g23btqGgoAAWFhZITExEd3c382gm/Pz88NlnnyE3Nxd+fn5YuHAhuru7cfDgQUyaNAkAt0lzNd68yeVy7dHKe/G7kWnbvXs3LCwssHLlSm0bc2kcLK7o/0pXVxfS0tIQEBCA+Pj4iQ6HHkJhYSGmT5+Ol19+eaJDoX9Bo9Ggv78f+fn5iIyMRGhoKAoLC6HRaHDkyJGJDo/G6ZdffsHGjRuxYsUKFBcXIz8/H2q1GklJSTo3tCAi0/HVV1/h+PHjyMjIgKOj40SH85/D4uoeQqEQCoVCr72vrw/29vYTEBE9CLlcjjfeeAMikQiffvqp9hzl4dzdn1u5XK7TTxOvo6MDhw4dwrp166BQKCCXy9Hf3w8A6O/vx99//818mgmhUAiRSARPT09tm0gkgpeXFxobG5lHM5GdnY3AwECkp6cjMDAQkZGROHDgAKRSKc6cOQOA+1hzNd68CYVCKJVKveX53cg0XbhwARkZGVizZg2WLl2q08dcGgeLq3uMdM6pQqHAzZs39a4LINMyMDCA5ORkKBQKFBUV6Rz2Hs7d/bltbm6GlZUVXFxcjBorja69vR0qlQpJSUnw9/eHv78/3nzzTQBAfHw8XnvtNebTTLi7u4/aNzg4CFdXV1hZWY2YRwDc55qIpqYmnQIZABwdHTFt2jS0tbUB4D7WXI03b0888QRaWlr0nh3Z0tLC7dTE1NbWIjU1FS+99BJSU1P1+plL42BxdY+QkBBcunRJ+6sNcPfCektLS507q5BpGRoawvr169Hc3IyioiLMmDFDp9/FxQWzZs3Se3ZOeXk5goKCIBAIjBku/YOnnnoKhw8f1nlt2rQJAJCZmYlt27Yxn2YiLCwMMpkM165d07b19vbi6tWrEIvFEAgECAgIwNmzZ3WWKy8vx+zZszFz5kxjh0wjcHJyglQq1Wnr6OhAb28vnJ2dAXAfa67Gm7eQkBD09fXh8uXL2jEtLS2QSqUICQkxasw0usbGRiQnJyMwMBCZmZkjjmEujWPyRAdgSmJjY1FSUoK1a9ciOTkZf/75J3bt2oXY2Fi9L+xkOjIzM1FVVYX09HQolUqdhx96eXlBIBAgJSUFGzZsgKurKwICAlBeXo7ffvuN136YGKFQiICAgBH7xGIxxGIxADCfZmDhwoXw9vbGunXrkJaWBmtraxw4cAACgQCvvvoqAOCtt95CfHw8tm/fjqioKFRXV6OsrAx5eXkTHD0Ni42NxQcffIDs7GyEh4dDJpNpr4u89xbe3CZNz61bt3DhwgUAdwtipVKpLaQkEgkcHBzGlbenn34aCxYswObNm/Hee+/B2toaeXl58PDwwHPPPTchf9t/zVi51Gg0WL16NaytrZGQkID6+nrtsra2ttozCZhL47DQ3H9s8D+uqakJWVlZ+PXXX2FjY4OYmBikpaXxlzcTFh4ejo6OjhH7Kisrtb+AnzhxAgcPHsSNGzfg5uaGd955B2FhYcYMlR5CdXU14uPjcfLkSXh7e2vbmU/T19PTg5ycHFRVVUGlUsHPzw+bNm3SOWWwsrISH3/8MVpaWuDk5ISkpCQsX758AqOme2k0Gnz55Zf44osvcP36ddjY2GDevHlIS0vT3jZ/GLdJ09Le3o6IiIgR+w4fPqz9IWs8eVMoFMjJycG5c+cwNDSEBQsWYOvWrfzh2UjGyiWAUW/iJZFIUFJSon3PXD56LK6IiIiIiIgMgNdcERERERERGQCLKyIiIiIiIgNgcUVERERERGQALK6IiIiIiIgMgMUVERERERGRAbC4IiIiIiIiMgAWV0RERERERAbA4oqIiMiAOjs74e3tjStXrjzwso2NjfDy8sLvv//+CCIjIqJHjcUVERGZhVOnTsHDwwMeHh6oqanR69doNAgNDYWHhweSk5MnIMK7CgoKMHfuXDzzzDMPvKy7uztCQ0PxySefPILIiIjoUWNxRUREZsXa2hplZWV67T/99BO6urogEAgmIKq7enp6cPr0acTGxj70HLGxsTh37hza2toMGBkRERkDiysiIjIroaGhqKiowNDQkE57WVkZxGIxHnvssQmKDPjmm28wadIkhIWFPfQcwcHBsLe3x9dff23AyIiIyBhYXBERkVlZvHgxZDIZfvjhB23b7du3cfbsWURHR4+4jFqtxueff47FixfD29sbwcHByMjIQF9fn844jUaDvXv3IiQkBHPnzkVcXBwaGhoQHh6O9PT0MWP77rvv4OPjAxsbG72+o0ePIiIiAj4+Pli+fDlqamoQFxeHuLg4nXFWVlaQSCSorKwcz8dBREQmhMUVERGZFWdnZ8ybNw/ffvuttu3ixYtQKBR44YUXRlwmIyMDu3fvhq+vL7Zs2YJly5ahtLQUq1evhkql0o7Lz89Hfn4+PD09sXHjRri4uCAxMRH9/f1jxqVSqVBXVwexWKzXd+zYMezYsQOOjo5499134efnh7Vr16Krq2vEucRiMRoaGqBUKsdcLxERmY7JEx0AERHRg4qOjkZubi4GBgYwZcoUlJaWwt/fHzNmzNAbW1NTgxMnTmDPnj06R7YCAgLw+uuvo6KiAtHR0ejp6UFRURGeffZZ7Nu3DxYWFgCAvLw87Nu3b8yYOjs7MTAwgJkzZ+q03759G/n5+fD29kZxcTEmT777r9fDwwPp6elwdHTUm8vFxQVqtRrNzc3w8fF5oM+GiIgmDo9cERGR2YmKisLg4CCqqqqgVCpx/vz5UU8JrKiogJ2dHebPn4+enh7tSywWY+rUqaiurgYAXLp0CSqVCqtWrdIWVgCQkJAwrphkMhkAQCgU6rTX19dDJpNhxYoV2sIKuFsg2tvbjzjX8By9vb3jWjcREZkGHrkiIiKz4+DggKCgIJSVlWFgYAB37tzB888/P+LYP/74AwqFAkFBQSP2d3d3AwBu3LgBAJg1a5beukYrgkai0Wh03g/P6+rqqtM+efJkODs7j2sOIiIyDyyuiIjILC1ZsgTvv/8+/vrrL4SEhOgdMRqmVqsxffp07NmzZ8R+BwcHg8QjEokAAHK5/F/PNTzHtGnT/vVcRERkPDwtkIiIzNKiRYtgaWmJ2tpaLFmyZNRxrq6ukMlk8PX1RXBwsN7L09MTAODk5AQAaG1t1Vm+p6dH766CI3n88ccxZcoUtLe367QPz3v/c6uGhobQ0dEx4lzt7e2wtLSEm5vbmOslIiLTweKKiIjMko2NDbZv346UlBSEh4ePOi4qKgp37tzB3r179fqGhoa0R4mCg4NhZWWFI0eO6JyWV1xcPK54rKysMGfOHNTX1+u0z5kzByKRCMePH9d5NldpaemoRdvVq1fh7u4OOzu7ca2biIhMA08LJCIis7V06dIxx0gkErzyyivYv38/rl27hvnz58PKygqtra2oqKjAli1bEBkZCQcHByQmJmL//v1ITk5GaGgopFIpLl68OO7T8yIiIpCXlwelUglbW1sAgEAgQEpKCrKyspCQkICoqCh0dHTg1KlTetdhAXdv6f7zzz9j5cqVD/ZhEBHRhOORKyIi+r+3Y8cOZGVlobu7G3l5ecjNzcWPP/6IF198Eb6+vtpx69evR0pKCqRSKXbt2oW2tjYcOnQIU6dOHdd6YmJioFar9R4AvGrVKmzduhWdnZ348MMPUVNTg8LCQtjZ2cHa2lpn7OXLlyGTycZVOBIRkWmx0PCWRERERP8oPDwcEokEO3fuHHPs5s2b0draimPHjv3jOLVajaCgICxatAjZ2dna9jVr1sDCwgIFBQX/Om4iIjIuHrkiIiIyoLfffht1dXW4cuWKtm1wcFDv9uqnT5+GTCaDRCLRtjU1NeH8+fNITU01WrxERGQ4vOaKiIjIgJycnFBXV6fTVltbi5ycHERGRkIkEkEqleLkyZN48sknERkZqR03e/ZsSKVSY4dMREQGwuKKiIjoEXN2doajoyNKSkrQ19cHe3t7xMTEYMOGDRAIBBMdHhERGQivuSIiIiIiIjIAXnNFRERERERkACyuiIiIiIiIDIDFFRERERERkQGwuCIiIiIiIjIAFldEREREREQGwOKKiIiIiIjIAFhcERERERERGQCLKyIiIiIiIgNgcUVERERERGQA/wMTv7ldeOLZqgAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -2609,7 +2609,7 @@ }, { "cell_type": "code", - "execution_count": 644, + "execution_count": 43, "id": "354687ec", "metadata": {}, "outputs": [ @@ -2665,7 +2665,7 @@ }, { "cell_type": "code", - "execution_count": 645, + "execution_count": 44, "id": "8d6cd1df", "metadata": {}, "outputs": [ @@ -2675,11 +2675,11 @@ "text": [ "Ax + B (Carpi, t):\n", "AtC = 0.01078 ± 0.00030\n", - "BtC = 0.03084 ± 0.02321\n", - "cov_ABtC = -0.000007\n", + "BtC = 0.08631 ± 0.02172\n", + "cov_ABtC = -0.000006\n", "P(0,chi²)= 0.08857\n", "KdtC = 3.66092 ± 0.10078\n", - "KBdtC = 1.28007 ± 0.96319\n" + "KBdtC = 0.45743 ± 0.11512\n" ] } ], @@ -2702,13 +2702,13 @@ }, { "cell_type": "code", - "execution_count": 646, + "execution_count": 45, "id": "592c257c", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2744,7 +2744,7 @@ }, { "cell_type": "code", - "execution_count": 647, + "execution_count": 46, "id": "12f276cc", "metadata": {}, "outputs": [ @@ -2795,7 +2795,7 @@ }, { "cell_type": "code", - "execution_count": 648, + "execution_count": 47, "id": "d04ee20e", "metadata": {}, "outputs": [ @@ -2804,13 +2804,13 @@ "output_type": "stream", "text": [ "AtY = 0.0107837 ± 0.0002969\n", - "BtY = 0.0308408 ± 0.0232061\n", - "cov_ABtY = -6.719211797637951e-06\n", + "BtY = 0.0863052 ± 0.0217195\n", + "cov_ABtY = -6.265968158785223e-06\n", "chi² = 0.53371\n", "chi² rid = 0.17790\n", "P(0, chi²)= 0.08857\n", "KdtY = 3.66092 ± 0.10078\n", - "KBdtY = 1.28007 ± 0.96319\n" + "KBdtY = 0.45743 ± 0.11512\n" ] } ], @@ -2835,13 +2835,13 @@ }, { "cell_type": "code", - "execution_count": 649, + "execution_count": 48, "id": "e795e732", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -2885,7 +2885,7 @@ }, { "cell_type": "code", - "execution_count": 650, + "execution_count": 49, "id": "46ef07bd", "metadata": {}, "outputs": [ @@ -2894,28 +2894,28 @@ "output_type": "stream", "text": [ "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", - "Media pesata K = 3.53395 ± 0.02072\n", + "Media pesata K = 3.30352 ± 0.01937\n", "\n", "RISULTATI REGRESSIONE OLS:\n", "Atols = 0.01104 ± 0.00022\n", - "Btols = 0.01070 ± 0.02113\n", + "Btols = 0.06749 ± 0.02007\n", "P(0,chi²)= 0.27020\n", "Kdtols = 3.57541 ± 0.06970\n", - "KBdtols = 3.69021 ± 7.28924\n", + "KBdtols = 0.58496 ± 0.17399\n", "\n", "RISULTATI REGRESSIONE Carpi:\n", "AtC = 0.01078 ± 0.00030\n", - "BtC = 0.03084 ± 0.02321\n", + "BtC = 0.08631 ± 0.02172\n", "P(0,chi²)= 0.08857\n", "KdtC = 3.66092 ± 0.10078\n", - "KBdtC = 1.28007 ± 0.96319\n", + "KBdtC = 0.45743 ± 0.11512\n", "\n", "RISULTATI REGRESSIONE York:\n", "AtY = 0.01078 ± 0.00030\n", - "BtY = 0.03084 ± 0.02321\n", + "BtY = 0.08631 ± 0.02172\n", "P(0,chi²)= 0.08857\n", "KdtY = 3.66092 ± 0.10078\n", - "KBdtY = 1.28007 ± 0.96319\n" + "KBdtY = 0.45743 ± 0.11512\n" ] } ], @@ -2955,7 +2955,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 50, "id": "dfcd391e", "metadata": {}, "outputs": [ @@ -2965,8 +2965,8 @@ "text": [ "res_t = 0.000500\n", "res_t2 = 0.024515\n", - "res_uAdt = 0.000451\n", - "uKdt_strum = 0.147238\n" + "res_uAdt = 0.000498\n", + "uKdt_strum = 0.148242\n" ] } ], @@ -2985,7 +2985,7 @@ }, { "cell_type": "code", - "execution_count": 652, + "execution_count": 51, "id": "b52fea3d", "metadata": {}, "outputs": [], @@ -3032,7 +3032,7 @@ }, { "cell_type": "code", - "execution_count": 653, + "execution_count": 52, "id": "0b1e4a1d", "metadata": {}, "outputs": [ @@ -3041,24 +3041,24 @@ "output_type": "stream", "text": [ "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", - "Media pesata K = 3.53395 ± 0.14869\n", + "Media pesata K = 3.30352 ± 0.14950\n", "\n", "RISULTATI OLS:\n", - "Atols = 0.01104 ± 0.00050\n", - "Btols = 0.01070 ± 0.02114\n", - "Kdtols = 3.57541 ± 0.16290\n", + "Atols = 0.01104 ± 0.00054\n", + "Btols = 0.06749 ± 0.02008\n", + "Kdtols = 3.57541 ± 0.16381\n", "Chi² = 0.42434 | rid = 0.14145 | P = 0.06483\n", "\n", "RISULTATI Carpi:\n", - "AtC = 0.01078 ± 0.00054\n", - "BtC = 0.03084 ± 0.02321\n", - "KdtC = 3.66092 ± 0.17842\n", + "AtC = 0.01078 ± 0.00058\n", + "BtC = 0.08631 ± 0.02173\n", + "KdtC = 3.66092 ± 0.17925\n", "Chi² = 0.34851 | rid = 0.11617 | P = 0.04934\n", "\n", "RISULTATI York:\n", - "AtY = 0.01078 ± 0.00054\n", - "BtY = 0.03084 ± 0.02321\n", - "KdtY = 3.66092 ± 0.17842\n", + "AtY = 0.01078 ± 0.00058\n", + "BtY = 0.08631 ± 0.02173\n", + "KdtY = 3.66092 ± 0.17925\n", "Chi² = 0.34851 | rid = 0.11617 | P = 0.04934\n" ] } diff --git a/molla/dinamica/mollaDinamica2Errore.ipynb b/molla/dinamica/mollaDinamica2Errore.ipynb new file mode 100644 index 0000000..6a50fd7 --- /dev/null +++ b/molla/dinamica/mollaDinamica2Errore.ipynb @@ -0,0 +1,2859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.807\n", + "ug = 0.001\n", + "\n", + "m_mol = 15.43\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, + { + "cell_type": "code", + "execution_count": 141, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica2.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "\n", + "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", + "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 142, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1a1ua1w1uw1c1uc1t1a2ua2w2uw2c2uc2t2a3ua3w3uw3c3uc3t3a4ua4w4uw4c4uc4t4wuwmumcucauatut
049.259.71710.0167.656500.00040484.45500.01115.628.91100.0157.656900.00040484.5160.01115.5810.4460.0277.660300.00050485.0820.01915.768.3770.0167.658200.00040484.7520.01115.877.6579750.00171149.250.002887484.701250.2843149.3627750.90825415.70750.133010
169.289.86000.0166.559680.00029423.35200.01118.3110.39000.0126.558910.00022423.1540.00918.2710.4910.0136.560020.00024423.6970.01018.3410.9680.0196.560000.00030423.4650.01418.166.5596520.00051969.280.002887423.417000.22664110.4272500.45447218.27000.078740
288.9711.58400.0145.844170.00020363.22900.01020.2710.17630.0175.845850.00028363.3540.01220.4412.0440.0185.845000.00026363.1830.01320.5411.2240.0165.845130.00025363.2330.01120.495.8450380.00068988.970.002887363.249750.07310911.2570750.79483720.43500.117331
3108.6111.54200.0265.327800.00030303.55020.01922.498.42400.0175.328200.00030303.5810.01222.2710.5010.0225.329600.00030303.8420.01622.559.9590.0145.328220.00020303.4450.01022.155.3284550.000787108.610.002887303.604550.16866910.1065001.29985322.36500.187172
4128.6411.57400.0204.926630.00023242.96200.01424.3311.59200.0234.925370.00029242.8760.01724.3810.2640.0234.924300.00030242.7890.01725.099.1180.0214.926100.00030243.1150.01524.264.9256000.001009128.640.002887242.935500.13895410.6370001.18834424.51500.386480
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 t1 a2 \\\n", + "0 49.25 9.7171 0.016 7.65650 0.00040 484.4550 0.011 15.62 8.9110 \n", + "1 69.28 9.8600 0.016 6.55968 0.00029 423.3520 0.011 18.31 10.3900 \n", + "2 88.97 11.5840 0.014 5.84417 0.00020 363.2290 0.010 20.27 10.1763 \n", + "3 108.61 11.5420 0.026 5.32780 0.00030 303.5502 0.019 22.49 8.4240 \n", + "4 128.64 11.5740 0.020 4.92663 0.00023 242.9620 0.014 24.33 11.5920 \n", + "\n", + " ua2 w2 uw2 c2 uc2 t2 a3 ua3 w3 \\\n", + "0 0.015 7.65690 0.00040 484.516 0.011 15.58 10.446 0.027 7.66030 \n", + "1 0.012 6.55891 0.00022 423.154 0.009 18.27 10.491 0.013 6.56002 \n", + "2 0.017 5.84585 0.00028 363.354 0.012 20.44 12.044 0.018 5.84500 \n", + "3 0.017 5.32820 0.00030 303.581 0.012 22.27 10.501 0.022 5.32960 \n", + "4 0.023 4.92537 0.00029 242.876 0.017 24.38 10.264 0.023 4.92430 \n", + "\n", + " uw3 c3 uc3 t3 a4 ua4 w4 uw4 c4 \\\n", + "0 0.00050 485.082 0.019 15.76 8.377 0.016 7.65820 0.00040 484.752 \n", + "1 0.00024 423.697 0.010 18.34 10.968 0.019 6.56000 0.00030 423.465 \n", + "2 0.00026 363.183 0.013 20.54 11.224 0.016 5.84513 0.00025 363.233 \n", + "3 0.00030 303.842 0.016 22.55 9.959 0.014 5.32822 0.00020 303.445 \n", + "4 0.00030 242.789 0.017 25.09 9.118 0.021 4.92610 0.00030 243.115 \n", + "\n", + " uc4 t4 w uw m um c uc \\\n", + "0 0.011 15.87 7.657975 0.001711 49.25 0.002887 484.70125 0.284314 \n", + "1 0.014 18.16 6.559652 0.000519 69.28 0.002887 423.41700 0.226641 \n", + "2 0.011 20.49 5.845038 0.000689 88.97 0.002887 363.24975 0.073109 \n", + "3 0.010 22.15 5.328455 0.000787 108.61 0.002887 303.60455 0.168669 \n", + "4 0.015 24.26 4.925600 0.001009 128.64 0.002887 242.93550 0.138954 \n", + "\n", + " a ua t ut \n", + "0 9.362775 0.908254 15.7075 0.133010 \n", + "1 10.427250 0.454472 18.2700 0.078740 \n", + "2 11.257075 0.794837 20.4350 0.117331 \n", + "3 10.106500 1.299853 22.3650 0.187172 \n", + "4 10.637000 1.188344 24.5150 0.386480 " + ] + }, + "execution_count": 142, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.width', None)\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, + { + "cell_type": "code", + "execution_count": 143, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n", + "10\n", + "############################################################\n", + "[ 61.28425 121.4515 181.0967 241.76575 60.16725 119.81245 180.4815\n", + " 59.6452 120.31425 60.66905]\n", + "[0.36359352 0.29356288 0.33058029 0.31645313 0.23814054 0.28251562\n", + " 0.26584645 0.18383143 0.15701353 0.21853469]\n", + "############################################################\n", + "[-20.03 -39.72 -59.36 -79.39 -19.69 -39.33 -59.36 -19.64 -39.67 -20.03]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248\n", + " 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.c[x] - df.c[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uc[x]**2 + df.uc[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 144, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.20529679 3.20732177 3.21454516 3.2203806 3.20938434 3.21927571\n", + " 3.22550245 3.22925365 3.23356286 3.23779934]\n", + "[0.01903074 0.00776638 0.00588125 0.00423125 0.01272429 0.00760543\n", + " 0.00476765 0.00998087 0.00424581 0.01168613]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(K)\n", + "print(uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 145, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.22307834012753\n", + "sigmaC: 0.0020227911977321114\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 146, + "id": "1d4c0ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.244949\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.6\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": np.sqrt(ueste**2 + uDx_strum**2),\n", + " \"y\": - F,\n", + " \"uy\": np.sqrt(uF**2 + uF_strum**2)\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 148, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 3.114e+05\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 09:36:10 Log-Likelihood: -14.036\n", + "No. Observations: 10 AIC: 32.07\n", + "Df Residuals: 8 BIC: 32.68\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0101 0.779 0.013 0.990 -1.785 1.805\n", + "x 3.2201 0.006 558.014 0.000 3.207 3.233\n", + "==============================================================================\n", + "Omnibus: 0.921 Durbin-Watson: 0.565\n", + "Prob(Omnibus): 0.631 Jarque-Bera (JB): 0.614\n", + "Skew: 0.062 Prob(JB): 0.736\n", + "Kurtosis: 1.792 Cond. No. 302.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", + "R² = 0.99997\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "id": "8d795186", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA14AAAIsCAYAAADiRXiMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAr9VJREFUeJzs3Xd0FOX7NvBrtqSRRkIIXRIwoSRUlRaQJkhAEKRLk6KooKgovYgoiEgPLXQBQZCiEBAFFMGABaUIfhVCCSglvSdb5v2Dd/eXJYXsZp8tyfU5xyPZmX1yz+y1s3tnmiTLsgwiIiIiIiISRmHvAoiIiIiIiMo6Nl5ERERERESCsfEiIiIiIiISjI0XERERERGRYGy8iIiIiIiIBGPjRUREREREJBgbLyIiIiIiIsHYeBEREREREQnGxouIiIiIiEgwNl5ERI8wdOhQDB061PjzrVu3EBoaij179tixqpKZPHkymjZtau8yypTQ0FAsX77c3mWUSR07dsTkyZPtXUaZMnToUPTo0cPeZRAR2HgRkRn27NmD0NBQXLhwwd6lOIUzZ84gNDQUhw8fLnQ6myLH9cMPP7C5KkR2djaWL1+OM2fOWDzG2bNnsXz5cqSlpVmxMiIix6eydwFERM6mevXqOH/+PFQqbkLLqh9++AHbtm3D+PHjC0w7f/48lEqlHaqyv+zsbKxYsQLjxo1DixYtLBrj999/x4oVK9C7d294e3ubTDt8+DAkSbJGqUREDod7vIiIzCRJElxdXcvtl+/yztXV1WGa7qysLHuXYFUuLi5Qq9X2LsMmZFlGTk5OodNyc3Oh1+tLNb4ts6HVapGXl2ez30fkrNh4EZHV3b17F1OmTEHr1q0RFhaG7t27Y/fu3QXmu337NsaOHYsmTZqgVatW+Oijj/Djjz8iNDS0wKFM27ZtQ6dOndCoUSP07dsXv/76a4FzrwAgLy8Py5YtwzPPPIOwsDA8/fTTWLBgQYm/FOzcuROdO3c2+T0PE32O17Zt29C9e3eEhYUhIiIC77//fqGHZR06dAh9+vRBo0aN0KJFC0ycOBF379595PiXL19Gy5YtMXToUGRmZgIo+WtmK4Z1vH79emzatAkdOnRAo0aNMGTIEPz9998m8xaWA+DBoZwdO3YsdEzD6xwWFoYXXngB58+fN3netm3bADw4n8vwn0FJzvEyHGYaExODRYsWoU2bNmjSpAnGjh2L//77r8D8586dw6hRo9C8eXM0btwYQ4YMwW+//WYyz/LlyxEaGoorV67gnXfewZNPPonBgwcDeHBu1CuvvIIzZ84YM/Hcc88Z30dHjhzBc889h/DwcPTp0weXLl0yex3eunULrVq1AgCsWLHCuF4M6+Kvv/7C5MmT0alTJ4SHh6NNmzaYMmUKkpOTTZZhwYIFAIBOnToZx7h165ZxOUpyjpder8fmzZuNy9SyZUuMGjXK5DBorVaLqKgo4+vcsWNHLFq0qMC2wLDufv31V/Tt2xfh4eHo1KkT9u3b98g6DLVs2rQJ3bt3R3h4OFq3bo2ZM2ciNTW10N/z448/Gl+jHTt2GLNy8OBBLF68GG3btkXjxo2RkZEBoGTvc8Nhyzdv3sSYMWPQtGlTTJw40WSeixcvYuDAgWjUqBE6duyIzz//3GR6Xl4eli5dij59+qB58+Zo0qQJBg8ejNOnT5vM9/B7s3PnzggPD8fVq1dLtL6IyjPH+JMdEZUZCQkJ6N+/PyRJwosvvgg/Pz+cOHEC06ZNQ0ZGBkaMGAHgwV9jhw8fjvv372PYsGGoVKkSDhw4UOi5I9u3b8ecOXPwxBNPYMSIEbh9+zZef/11eHt7o0qVKsb59Ho9Xn31Vfz222/o378/6tSpg7///hubN2/G9evXsXLlymJr37VrF2bOnImmTZti+PDhiI+Px6uvvgofHx9UrVrV4nWSmZmJpKSkAo8X1gwuX74cK1asQOvWrTFo0CBcu3YNn3/+OS5cuIDPP//cuDdgz549mDJlCsLDw/H2228jMTERW7ZswdmzZ7Fv374Ch3AZnD9/HqNHj0ZYWBhWrlwJNze3Er9m9rBv3z5kZmZi8ODByM3NxWeffYbhw4fj66+/RqVKlSwa88CBA8jMzMSAAQMgSRLWrVuH8ePH47vvvoNarcaAAQNw7949nDp1ytgkWGrVqlWQJAljxoxBYmIiNm/ejBEjRmD//v1wc3MDAMTGxmLMmDEICwvDuHHjIEkS9uzZg+HDh2P79u1o1KiRyZhvvvkmHnvsMbz11luQZdn4+I0bN/DOO+9g4MCB6NmzJzZs2ICxY8fi/fffx+LFizFo0CAAwNq1azFhwgQcPnwYCkXJ//7q5+eH2bNnY/bs2XjmmWfwzDPPAICxKf3pp58QHx+PPn36ICAgAP/88w+++OILXLlyBV988QUkScIzzzyD69ev48CBA5gyZQoqVqxoHNsc06ZNw549e9CuXTv07dsXOp0Ov/76K86dO4fw8HAAwPTp07F371507doVL730Es6fP481a9bg6tWriIqKMhnvxo0bePPNN9G3b1/07t0bX375JSZPnoyGDRvi8ccfL7aWmTNnYu/evejTpw+GDh2KW7duYdu2bbh06ZLJexYArl27hnfeeQcDBgxA//79ERQUZJy2cuVKqNVqjBo1Cnl5eVCr1Wa9z7VarbF5nzRpkjFfAJCamoqXX34Z3bp1Q/fu3XHo0CHMnj0barUaffv2BQBkZGRg165d6NGjB/r164fMzEzs3r0bo0ePxq5du1C/fn2T5d6zZw9yc3PRv39/uLi4wMfHx6zXkKhckomISujLL7+UQ0JC5PPnzxc5z9SpU+U2bdrISUlJJo+/9dZbcvPmzeXs7GxZlmV5w4YNckhIiPztt98a58nJyZGfffZZOSQkRD59+rQsy7Kcm5srP/XUU/ILL7wgazQa47x79uyRQ0JC5CFDhhgf27dvn1yvXj35l19+Mfndn3/+uRwSEiL/9ttvRdadl5cnt2rVSu7Vq5ecm5trfHznzp0Ffk98fLwcEhIif/nll0WOJ8uyfPr0aTkkJKTY/5o0aWKcPzExUW7YsKE8cuRIWafTGR/funWrHBISIu/evduk1h49esg5OTnG+Y4fPy6HhITIS5cuNT42adIk4+/49ddf5WbNmskvv/yyyTKW9DWzJcM6btSokXznzh3j4+fOnZNDQkLkjz76yPjYkCFDTF4fg0mTJskdOnQoMOZTTz0lp6SkGB//7rvv5JCQEPnYsWPGx95//305JCSk0NpCQkLkZcuWFVu/4bVv27atnJ6ebnw8JiZGDgkJkTdv3izLsizr9Xq5S5cu8siRI2W9Xm+cLzs7W+7YsaP80ksvGR9btmyZHBISIr/99tsFfl+HDh3kkJAQ+ezZs8bHfvzxR+M6vH37tvHxHTt2mLzHZLnk6zAxMbHI5S8sJwcOHJBDQkJM3pPr1q2TQ0JC5Pj4+EKXY9KkSQUezy82NlYOCQmRP/jggwLTDOvw8uXLckhIiDxt2jST6fPnz5dDQkLk2NhYk9/5cI2JiYlyWFiYPH/+/GJr+eWXX+SQkBD5q6++Mnn8xIkTBR43/J4TJ06YzGvISqdOnUzWobnv85CQEHnhwoUFahwyZIgcEhIib9iwwfhYbm6u3KtXL7lVq1ZyXl6eLMuyrNVqTbYLsizLqampcuvWreUpU6YYHzO8j5o1ayYnJiYWu36IyBQPNSQiq5FlGUeOHEHHjh0hyzKSkpKM/0VERCA9PR1//vknAODHH39EYGAgOnXqZHy+q6sr+vfvbzLmxYsXkZKSgv79+5ucV/Pcc88V+Avr4cOHUadOHQQHB5v87pYtWwJAsVdiu3jxIhITEzFw4EC4uLgYH+/duze8vLwsXykAXn/9dWzcuLHAfxERESbz/fTTT9BoNBg2bJjJnoh+/frB09MTP/zwg0mtgwYNgqurq3G+9u3bIzg4GN9//32BGk6fPo3Ro0ejVatWWL58uXEZzXnN7KFz584IDAw0/tyoUSM0btzYuC4sERkZaZKdJ554AgAQHx9veaFFeP755+Hp6Wn8+dlnn0VAQICx/suXL+P69et47rnnkJycbFz3WVlZaNWqFX755ZcC5/oMHDiw0N9Vt25dk6tkNm7cGADQsmVLVKtWrcDj1l7e/HtYcnNzkZSUZPxd1szQkSNHIEkSxo0bV2Ca4cIchvX70ksvmUwfOXKkyXSDunXrGnMAPNgDFxQU9Mh1dPjwYXh5eaFNmzYm752GDRvCw8OjwDanRo0aaNu2baFjPf/88ybr0JL3uWGv5sNUKhUGDBhg/NnFxQUDBgxAYmKi8bVRKpXG7YJer0dKSgq0Wi3CwsIKHJoKAF26dDF7TyVRecdDDYnIapKSkpCWloadO3di586dRc4DPDi/q1atWgWuYFarVi2Tn//9999CH1epVKhevbrJYzdu3MDVq1eN56E8LDExscjaDb/nscceM3lcrVajZs2aRT6vJEJCQtC6desCj3/11VeF1hAcHGzyuIuLC2rWrInbt2+bzJf/MCWD4ODgAucG5ebm4pVXXkHDhg2xZMkSkwbWnNesMCkpKdBoNEVOL46Pj49Jk1uYh18PAKhduzYOHTpk0e8EUOCwUUMTJuLy5g/XL0kSHnvsMeNref36dQDApEmTihwjPT3dpFGsUaNGofM9vFyGPxjkPxwXgLERtPbypqSkYMWKFYiJiSnwXktPT7fa77l58yYqV64MX1/fIue5ffs2FApFge1GQEAAvL29jevfoLBDiX18fAqcp/WwGzduID09vcTbnKJeu8Kmmfs+V6lUBV5rg8qVK8PDw8Pksdq1awN4sK6aNGkCANi7dy82bNiAa9eumbyvC6u7uGUhosKx8SIiqzH8Zb5nz57o3bt3ofPkv0iBiN8fEhKCKVOmFDq9qC8lZZ2LiwvatWuHY8eO4ccff0SHDh2M00r7mo0fPx4///yzRXVt2bLF4kuSl4ROpyv08aKuRinnO1/KVgy/87333itwDo3Bw1+Y8+/9yK+o5SrN8ha1DgszYcIE/P777xg1ahTq168PDw8P6PV6jB492i7rFkCJL01v6RVK9Xo9/P39sXDhwkKnP7xHKP8erYcVN60kXFxczDpn72H79+/H5MmT0blzZ4waNQr+/v5QKpVYs2ZNoXv+SlsvUXnExouIrMbPzw8VKlSAXq8vdA9PftWrV8eVK1cgy7LJl6ObN2+azGc4ROrmzZvGQwaBByeS375926QpqFWrFv766y+0atXK7HsBGX7PjRs3TP56rdFocOvWLdSrV8+s8SxhqCEuLs5kL1teXh5u3bplXKeG+a5du1bgL+3Xrl0zOawMePDlc+HChXjttdfw5ptvIjo62tjwmPOaFWbSpEkW7zkpyTq9ceNGgceuX79usrfTx8en0C+Ghj0GlrDWvaQerl+WZdy4ccOYW8Pr7OnpadH6t5aSrsOi1ktqaipiY2Mxfvx4k0MADXv0SjJGSdWqVQsnT55ESkpKkXu9qlevDr1ejxs3bqBOnTrGxxMSEpCWllZgb3lpaomNjUWzZs2s3oiY+z4vzr1795CVlWXSxBteG8O6+Oabb1CzZk2sWLHC5DVatmyZpYtARA/hOV5EZDVKpRJdu3bFN998U+CS34DpIWsRERG4e/cujh49anwsNzcXX3zxhclzwsLC4Ovriy+++AJardb4+Ndff13gMKBu3brh7t27BcYAgJycnGLvaxMWFgY/Pz/s2LHD5GqDe/fuFXIIWmFat24NtVqNzz77zGQPwe7du5Geno6nn37aWKu/v3+BWn/44QdcvXoV7du3LzC2i4sLVqxYgfDwcIwdO9Z4+XRzXrPChIWFoXXr1hb9V5KroH333Xcml84+f/48zp07h3bt2hkfq1mzJuLi4kxq/euvv3D27NlHjl8Ud3d3AKU/HG/fvn3Gy4IDD84Jun//vrH+sLAw1KpVCxs2bDBe2j+/R61/aynpOixqvRS1x2jz5s0FHjOMYenhh126dIEsy1ixYkWBaYb3jeG98vDv37hxo8n00urWrRt0Ol2hV0zVarWlyo8l7/OiaLVak0OJ8/LysHPnTvj5+aFhw4YA/u81zL/tOXfuHP744w+Ll4GITHGPFxGZ7csvv8SPP/5Y4PFhw4bhnXfewZkzZ9C/f3/069cPdevWRWpqKv7880/ExsYaD0sbMGAAtm7dinfeeQfDhg1DQEAAvv76a+NhVIa/uLq4uGD8+PH44IMPMHz4cHTr1g23b9/Gnj17Cpy/0atXLxw6dAizZs3CmTNn0KxZM+h0OsTFxeHw4cNYt26d8VLTD1Or1ZgwYQJmzpyJ4cOHIzIyErdu3cKePXtKfY5XSfn5+eGVV17BihUrMHr0aHTs2BHXrl3D9u3bER4ejp49exprnThxIqZMmYIhQ4age/fuxstMV69evcjLv7u5uWHNmjUYNmwYxowZg88++wwhISElfs3soVatWhg0aBAGDRqEvLw8bNmyBb6+vhg9erRxnr59+2LTpk0YNWoU+vbti8TEROzYsQN169YttJkpCcOX0blz5yIiIgJKpRLdu3c3exwfHx8MHjwYffr0MV5O/rHHHjNeREahUGDu3LkYM2YMevTogT59+iAwMBB3797FmTNn4OnpidWrV1u0DOYo6Tp0c3ND3bp1cejQIdSuXRu+vr54/PHHERISgieffBLr1q2DRqNBYGAgTp06Zbw/V36Gdbt48WJERkZCrVajQ4cOBQ6pLErLli3Rq1cvfPbZZ7hx4wbatm0LvV6P3377DS1atMCQIUNQr1499O7dGzt37kRaWhqefPJJXLhwAXv37kXnzp1N9p6XxlNPPYUBAwZgzZo1uHz5Mtq0aQO1Wo3r16/j8OHDmDZtGp599lmLxrb0fV6YypUrIzo6Grdv30bt2rURExODy5cv44MPPjBe7r59+/Y4cuQIXn/9dbRv3x63bt0yZqCs3aibyF7YeBGR2R6+8aZBnz59UKVKFezatQtRUVH49ttv8fnnn8PX1xd169Y1uaFnhQoVsHnzZsydOxdbtmyBh4cHnn/+eTRt2hTjx483OY9lyJAhkGUZGzduxMcff4x69eph1apVmDt3rsl8CoUCUVFR2LRpE/bv349vv/0W7u7uqFGjBoYOHVroSer5DRgwADqdDuvXr8eCBQsQEhKCVatWYenSpaVcYyU3fvx4+Pn5YevWrZg3bx58fHzQv39/vP322yb3A+rTpw/c3NwQHR2NhQsXwsPDA507d8a7775b5D28gAeHtK1fvx5DhgzByJEjsW3bNjz22GMles3s4fnnn4dCocDmzZuRmJiIRo0aYcaMGahcubJxnjp16uDjjz/GsmXLMG/ePNStWxcLFizAgQMHLG4au3TpgqFDh+LgwYP46quvIMuyRY3X2LFj8b///Q9r165FZmYmWrVqhVmzZhn3+gBAixYtsHPnTqxcuRJbt25FVlYWAgIC0KhRI5Mr0YlkzjqcO3cuPvjgA8ybNw8ajQbjxo1DSEgIPv30U3zwwQfYvn07ZFlGmzZtEB0dXeAqfo0aNcKbb76JHTt24Mcff4Rer8fRo0dL3HgBwLx58xAaGordu3djwYIF8PLyQlhYmMlVHefOnYsaNWpg7969+O6771CpUiW88sorhV4NsTTmzJmDsLAw7NixA4sXL4ZSqUT16tXRs2dPNGvWrFRjW/o+f5iPjw/mz5+PuXPn4osvvkClSpUwc+ZMk6vI9unTBwkJCdi5cydOnjyJunXr4pNPPsHhw4ft+scXorJEku11xisRUSE2bdqEefPm4cSJEyaXEX+YXq9Hq1at8Mwzz2Du3Lk2rJBs4datW+jUqRPee+89jBo1yt7lmO3MmTMYNmwYli5davEeDyIiKlt4jhcR2U1OTo7Jz7m5udi5cydq165t0nTl5uYWuCravn37kJKSgqeeesomtRIRERGVBg81JCK7GTduHKpVq4Z69eohIyMDX331FeLi4gpcmvmPP/7AvHnz8Oyzz8LX1xeXLl3C7t27ERISwr0JRERE5BTYeBGR3URERGD37t34+uuvodPpULduXeMJ9/lVr14dVapUwWeffYbU1FT4+PigV69emDhx4iNvwEtERETkCHiOFxERERERkWA8x4uIiIiIiEgwNl5ERERERESC8RwvM/z++++QZdnkXjpERERERFT+aDQaSJJkcg/B4rDxMoMsywUuaU1EREREROWPuX0BGy8zqNVqyLKMsLAwSJJk73KojJFlGRqNBmq1mvkiIZgxEon5IpGYLxLNkoxduHDBrN/Bc7yIiIiIiIgEY+NFREREREQkmMM1XkePHkW/fv3QtGlTRERE4M0330R8fHyB+Xbt2oWuXbsiPDwcPXv2xPHjxwvMk56ejqlTp+Kpp55C06ZN8cYbb+DevXu2WAwiIiIiIiIjh2q8zpw5g3HjxqFu3bqIiorC1KlT8ddff2HkyJHIyckxznfw4EHMmDED3bp1Q3R0NJo0aYJx48bhjz/+MBlvwoQJOHXqFGbPno2FCxfi2rVrGDNmDLRarY2XjIiIiIiIyjOHurjGwYMHUa1aNXz00UfGk9r8/PwwfPhwXLx4EU888QQAYNmyZejevTsmTJgAAGjZsiX+/vtvREVFITo6GsCDS7+fPHkS69evR0REBAAgKCgIkZGROHLkCCIjIy2qkSd0kki8VQGJxoyRSMwXicR8kWiiM+ZQjZdWq0WFChVMmhsvLy8A/3e5xvj4eFy/fh3vvvuuyXMjIyOxYMEC5OXlwcXFBSdOnIC3tzfatGljnCc4OBj169fHiRMnLG68gEc3XzqdDhqNxuLxiaxBrVZDqVTauwxyIPzDEYnEfJFIzBeJZouMOVTj1adPH+zfvx/btm1Dz549kZKSgkWLFqFBgwZo1qwZACAuLg7Ag71X+dWpUwcajQbx8fGoU6cO4uLiEBQUVGAlBgcHG8ewlCzLhb44sizjzp07SElJKdX4VH4VlS1L+fr6okqVKvzAIgAP8qXT6aBUKpkJsjrmi0Rivkg0W2TMoRqvJ554AitWrMA777yDOXPmAADq16+PdevWGf9yn5qaCgDw9vY2ea7hZ8P0tLQ0496y/Hx8fHDx4kWLayzqJsqSJOG///5DamoqAgIC4OHhYXzRDP8v6iZrkiQVO600z+W4Yse1dk2Gxqs0y2PIaFZWFu7fvw9ZllG1atVysw7L47glfa7hQ0WhUAivieM6bk0ix82fL2uNW9qaOK5j1mTuuPm/FDtDvc5ck7ONa62a8m/DSjNucRyq8Tp79izee+899O/fH+3bt0dKSgpWrlyJl19+Gdu3b4ebm5u9SwQAaDQak07Y8AKlpqaiUqVK8PPzM5nf8CFUWNOW/0u2OdNK+1xDTXq9vlyPa+lzDdOsXZMsy8Y8lXZcNzc3yLKM+/fvw8/Pz/j+0Wq1BZ6rUqmMv1On05lMUygUUKkebCoKO4TWcKNBnU5XoGbDuLIsF7iojWFcWZaLHBdAoeMqlUrjh+/D40qSZHxuYctqmFbYspZm3NKsQxcXlyKXtSTjlnQd5l8ulUpV6nVo7dfG0nUo8rUpLt/FLWtJxgVsuw4N4xZWk7XWoaHe/J+R3EaYLqsjbyOstawixs3/ucdthPNuIxz5e4Th35IkGd9zj9pGyLJ5Ryo5VOM1d+5ctGzZEpMnTzY+1qRJE7Rv3x779+/HgAED4OPjA+DBpeIDAgKM86WlpQGAcbq3tzfu3LlT4HekpqYa57FUYXe0zs3NBYAC56g9zJJpJXlBrf07y8u4+R9zlJqsOW6FChWQkJBgstEwbPwKo1AoCvy1Or/CTjo1/K78G+zC5inqhNXippVmXMDyZRU1LlD8ibvFLWtp6s3/AWOowfC6lWZZ7fHaAMWvQ0fLd1HjGpS1dahSqQp8RnIbUfJxAftuIyx5rq22Efm/XHMbUbJxHXEb4cjfIwyfkfmX71HLak7TBThY43X16lV06tTJ5LEqVaqgYsWKuHnzJoAH52gBD871Mvzb8LNarUbNmjWN88XGxhboRK9du4aQkJBS1Zl/b8fDinsRnPXLO8e1TU2F7cEq7bj5Dymz5riO8lyOa/5zDduv/I2XiJo4ruPWJHLch/PlCDVxXMesyZJxS7LdcqR6nbUmZxvXmjU9vP0qTU2Fcaj7eFWrVg2XLl0yeez27dtITk5G9erVAQA1a9ZE7dq1cfjwYZP5YmJi0KpVK+OuwXbt2iE1NRWxsbHGea5du4ZLly6hXbt2FtdoyUomKinmi0TjlS5JJOaLRGK+SDTRGXOoxmvgwIH47rvvMHfuXPz000+IiYnB2LFj4e/vj27duhnnGz9+PA4cOIBly5bhzJkzmDVrFs6fP4/XXnvNOE/Tpk0RERGBqVOn4tChQzh27BjeeOMNhIaGokuXLqWqs6x/OV6+fDlCQ0ML/NejRw8AQGhoKNavX2+cf8+ePfj6669LNHbHjh2NF04BgMmTJxvHLWtOnDiBESNG4IknnkDjxo3x/PPPY8uWLQWOUd6zZw9CQ0ORnJxc5F+Kk5OT8dFHH6FLly4IDw9Hq1atMGjQIGzatMlGS0NlgSRJvCIYCcN8kUjMF4lmi4w51KGGw4YNg4uLCz7//HN8+eWXqFChApo0aYIlS5agYsWKxvl69OiB7OxsREdHY+3atQgKCsKKFSvQtGlTk/GWLFmCefPmYebMmdBqtYiIiMD06dOLPV6zJMw9kc4Zubm5YfPmzQUeA4CdO3eiWrVqxsf37t0LDw8PPPfcc2b/ntdeew1ZWVmlK9YBbdiwAR9//DGeeeYZLFiwAO7u7jhx4gQWLFiA06dPY8WKFYUeA2043DB/vrRaLYYPH4709HS8/PLLCA4ORkJCAs6ePYvjx49jxIgRtloscnKGk9OLavCJSoP5IpGYLxLNFhlzqMZLkiQMGjQIgwYNeuS8/fr1Q79+/Yqdx8vLCx999BE++ugja5Vo0aUjnZFCoUCTJk0KnVbU45aoVauW1caylry8PKhUqmJPDi3OpUuXsHDhQvTu3Rvz5883Pt6qVSvUrVsXU6dOxbZt2zB06NACzy2sqf/555/xv//9D1u3bsWTTz5pfLx79+6FXvmQqDharbbYk5CJSoP5IpGYLxJNdMYc6lBDcg75DzUcOnQofv75Z3z//ffGQxKXL19e4rEePtTQcNjdpUuXMHr0aDRp0gRdunTBvn37Cjz3+++/R79+/dCoUSO0bNkSs2bNMtl7lpWVhTlz5qBr165o3LgxOnbsiJkzZyI9Pd1kHMPhj9HR0ejQoQMaNWpkvAn2nj178NxzzyE8PBxt27bF4sWLC1wm9WGfffYZJEnC+PHjC0zr3bs3ateuXWBvYnEM96bLfxVPA0ubQyIiIiKyLX5royJptVqT/wrb2zdr1iw0aNAAzZo1w86dO7Fz585H7oksiYkTJyIiIgJRUVGoX78+Jk+ejKtXrxqnHz58GK+++ipCQkKwYsUKvPvuu/j2228xbdo04zw5OTnQ6XR46623EB0djTfffBO//PKLybmABkeOHMH333+PadOmYeXKlfDw8MDGjRsxffp0REREYPXq1RgzZgy2bNmCxYsXF1v7L7/8gtDQUOMFYfJTKBTo0KED4uPjcffu3RKti/r160OhUGD69OmIjY1FXl5eiZ5HRERE5Myys7Nx4cIFZGdnm/zbWTnUoYbkOLKystCwYUOTxxYsWIBevXqZPFa3bl14enrCw8PDqocgvvjii3jxxRcBPLhQyg8//IBvvvkGr732GmRZxoIFCxAZGYkPP/zQ+JyAgAC8/PLLeO211/D444/Dz88P77//vnG6VqtFjRo1MHjwYFy7dg1BQUHGaRqNBtHR0fDw8AAAZGRkYNmyZRg9ejTefvttAECbNm2gVqsxf/58jBo1yuS8w/zu3r2L0NDQIpetatWqAIA7d+4gMDDwkeuidu3amDx5Mj755BOMGDECarUajRo1Qrdu3TBo0KBSn7NIRERE5Iiys7Nx8eJF4x+zDf92d3e3c2WW4Tc2M1l6sp3m+r/Qp6Y/ekYrU/h4QV272qNnfIibmxu2bt1q8pjhHmm2EBERYfy3h4cHqlWrZrwh9rVr13D79m1MnTrV5AqBTz31FBQKBS5evIjHH38cALBv3z5s2rQJN27cMDkM8fr16yaNV4sWLYxNFwD8/vvvyMrKwrPPPmvyO1q3bo2cnBz8888/eOqpp6y/4EUYPnw4IiMjcezYMfz888+IjY3F3LlzceTIEWzevJmHHFKJ8aR0Eon5IpGYr/IrIysP95KzodEWf7pHaYnOGBsvC5j7ougSU3CzxSDAHhdCUCpR+899UPr7mvU0hUKB8PBwMTWVgJeXl8nParXaeIhdcnIyAOD1118v9Ln//fcfAODbb7/FpEmTMGDAALz11lvw9fXF/fv38frrryM3N9fkOf7+/iY/G35H7969i/0dhQkMDCx2umFalSpVCkwrroEKCAjAgAEDMGDAAGg0GsycORN79uzB8ePHC9x4nKgwkiTxxHQShvkikZiv8icpKQm3bt1CSlIq9i7ajgtKD1T3zcLfV+IQGJAKHx8f+Pn5We332SJjbLxsQOnvi1pnPrfbHi9zmy5H5+vrCwCYOXMmGjVqVGB65cqVATw4D6x+/fom9w37+eefCx3z4Wbax8cHALBixYpCG6QaNWoUWd+TTz6Jr7/+Gv/995/xsEIDWZbxww8/oGbNmiU6zLAoarUaI0aMwJ49e3D16lU2XkRERFSmnD59Gre+O4mm355HwJ1U6Aa2RKrGE8ePHYVapUSDBg0QGRlp7zLNwsbLApbcx8uSw/2chVqtLrAHSaTg4GBUqVIF8fHxxvPACpOTk1PgLxclvdFz06ZN4e7ujjt37uCZZ54xq76hQ4di//79WLZsGebNm2cybf/+/YiLi8OMGTMKfa5ery9w/4iUlBR4enoWOJfr+vXrAAq/2iFRYWRZhlarhUql4iE7ZHXMF4nEfJUvuuQ0hB/6HSE7TyKjsg9iBvfCn27eqKHOQIeO7RAY4G/8I7m12CJjbLzMVF7u42WO4OBg7Nu3D8eOHUNAQAAqV65cqr05jyJJEiZPnoyJEyciKysL7du3h7u7O/7991/88MMPeOuttxAUFITWrVtjzpw5iIqKMl6gIzY2tkS/w9vbG2+88QY++eQT3LlzB0899RSUSiXi4+Nx9OhRLF++vMgTOxs0aICJEyfi448/RkZGBvr06QM3NzecPHkSmzdvRqdOnTB48OACzzt27BgqVKhgXEYAePzxx/HPP/8Y7wvWqFEjqFQqXL58GWvWrEG1atXMbgypfOM2jERivkgk5qvsk/V6pG87gMS5awGNFh5TRuGXABV6te+E1snZ+POPUwipG2zVQwxNfr/gjLHxolIbM2YMbt68iUmTJiEtLQ3jxo0r9B5W1tStWzd4e3tj9erVxr1Y1atXR9u2bVGpUiUAwMCBA3Hr1i1s3boV69evR0REBD799FP079+/RL9j5MiRCAwMxMaNG7F161aoVCrUqlUL7du3f+QxwCNHjkSdOnWwceNGTJw4ERqNBkFBQXjvvfcwePDgQs/lyn8pfIM333wTvXv3RteuXXH06FFs3rwZubm5qFKlCp577jm8/PLL8PT0LNHyEBERETmqnLOXkDB5CXJ/vwyvAc/Cb8ZYpKkl4Jtv4OnhAk8PF/x9UWnvMktFkvnngxK7cOECZFlGeHh4gV2QOTk5xkuUu7m52alCcmayLBsPY7XWLm7mkvKTZRkajQZqtZqH6pDVMV8kEvNVdukSU5A4dw3Stx2ES8O6qDR/AtxbPDiHPzs7G1euXEHdunUBwPhvEZeTtyRjFy5cAIASX5COe7yIiIiIiMimZJ0OaVu+QtJH0YAso9K8CfAe0QuS8v/2arm7u5s0Nfa84rY1sPEyE//KQiIxXyQaL8dMIjFfJBLzVXbk/HIR9yctQt6Ff+D1Ynf4T38FykoV7V0WLyfviPjlmERgrkg0ZoxEYr5IJOarbNDeT0bSnFVI33EIro1DUf3warg1b2jvsgDYJmNsvCxgyeXkiR4l/+mWzBeJIMsy9Ho9FAoFM0ZWx3yRSMyXc5O1WqRt3Iek+esBpQKVFk6E95AeJocV2pstMsbGy0y8FgmJxKaeRNPpdIVeVZPIGpgvEon5ck7Zp88jYfIi5F2Kg/fQ5+A37WUo/ax7Dy5rEZ0xNl5WxsaMHAnzSERERPagvZOAxDmrkLHrCFyb1Uf1I2vh1qSevcuyKzZeVmI4GS8rK0vIJS6JLJGVlQWAJyQTERGRbcgaLVLXf4mkjzdAclUjYPEkeA2OhMS9lWy8rEWpVMLX1xf37t0DAHh4ePCQMTKLNe/jJcsysrKycO/ePfj6+kLpQMdQExERUdmUfep33J+8GJq/b8B7xPPwmzwKyore9i7LYbDxMlNxX4irVKkCAMbmi8hc1j7Hy9fX15hLIgBswkko5otEYr4cl/a/+0icFYWMvUfh+mQYanwbDddGIfYuy2yiM8bGywJFfTGWJAlVq1ZF5cqVodFobFwVkSm1Ws0PKTIhSRIzQcIwXyQS8+WY5DwNUtbuQvLCTVB4uCFg+VR49e/qlIcV2iJjbLws8Ki9EkqlkhsHMps1DzUkKgwzRiIxXyQS8+V4sk78ioTJS6C5Gg+fUX1QcdJIKH287F2WxWyRMTZeZuJV4kgkrVbLC2GQUMwYicR8kUjMl2PQ3r6LhJlRyPzqONxaNkZg9Gy4Nqxr77KsQnTG2HgREREREVGx5Nw8pKzaieTFW6Dw9EDlVTPg+cIz3ANpBjZeRERERERUpKxjZ5AwZQk0N/6Dz8t94ffuS1B4VbB3WU6HjRcRERERERWgib+DxBnLkXnwBNzaNEWVzR/BpV6QvctyWmy8zMTdqSQS80WiMWMkEvNFIjFftqPPyUVq1A4kL/0MCh8vVF47C57Pdyrzr4Ho5WPjZYGyHjqyD0mSeNIwCcWMkUjMF4nEfNlO5pGfkDBtGbS37sD31QGo+PZwKDw97F2WcLbIGBsvIiIiIqJyTnP9XyRMX4asb07B/eknUHX7x3B5/DF7l1WmsPGywKPu40VkCVmWodVqoVKpmC8SghkjkZgvEon5EkefnYuUZVuRsnw7lJV8EbjhA1To8XS5W8+2yBgbLzPxPl4kEvNFojFjJBLzRSIxX9YlyzKyDp9EwvTl0N5JgO9rA1FxwlAoKrjbuzS7EZ0xNl5EREREROVI3tV4JE5bhqyjp+HesQWqfvEpXOrUtHdZZR4bLyIiIiKickCfmY3kJZ8hZeUOqAL9UWXzh/Do1rbcHVZoL2y8iIiIiIjKMFmWkXngByTOXAHd/WRUfONF+I5/EQoPN3uXVq6w8TIT/yJAIqlUfEuSWMwYicR8kUjMl2XyrtxEwpQlyP7+F3h0aY1Kc9+AOqi6vctySKIzxgRbgM0XiSBJErNFQjFjJBLzRSIxX+bTZ2QhedEWpKzeCVX1yqiybT4qdGlj77Icli0yxsbLArycPIkgyzL0ej0UCgXzRUIwYyQS80UiMV8lJ8syMvcdQ8KsKOiTU1HxneHwfX0QFG6u9i7NodkiY2y8zMRLmZJIOp0OCoXC3mVQGcaMkUjMF4nEfD1a3v+uPTis8MezqBDZFv4fjIe6VlV7l+U0RGeMjRcRERERkRPTZ2Qh6ZONSF27C+qaVVF1x0J4dGph77LoIWy8iIiIiIickCzLyNjzHRJnRUGflgG/90bC97WBkFxd7F0aFYKNFxERERGRk8m9dBUJkxcjJ/YcKjzXHv5zxkFdI9DeZVEx2HiZiSd0kkg8dp1EY8ZIJOaLRGK+HtClZSD54w1IXb8H6qDqqLprETzaP2nvssoE0Rlj42UBNl8kgiRJvEcJCcWMkUjMF4nEfAGyXo/0L75B0pxV0GfmwG/6y/B9uR8kF7W9SysTbJGx8p1gC/Fy8iRC/itmMl8kAjNGIjFfJFJ5z1fuhX+QMGkRcn65CM/eneD//utQVQ2wd1llii0yxsbLTLycPImk0WigVvMvVyQOM0YiMV8kUnnMly4lHUnz1iFt0z6oH6+FanuXwj2imb3LKrNEZ8yhGq+hQ4fi559/LnTaokWL0L17dwDArl27sG7dOvz7778ICgrCW2+9hQ4dOpjMn56ejnnz5uG7776DRqNB27ZtMX36dFSuXFn4chARERERWUrW65H++SEkzl0NOScP/rNfhc/ovpDUDvXVnczkUK/erFmzkJGRYfLY5s2bceTIEbRq1QoAcPDgQcyYMQNjx45Fy5YtERMTg3HjxmHbtm1o0qSJ8XkTJkzAlStXMHv2bLi6umLJkiUYM2YMvvzyy3J/jDAREREROabcc//D/UmLkPvbJXj26wL/ma9CVaWSvcsiK3CoDqRu3boFHnvnnXfQpk0b+Pn5AQCWLVuG7t27Y8KECQCAli1b4u+//0ZUVBSio6MBAL///jtOnjyJ9evXIyIiAgAQFBSEyMhIHDlyBJGRkbZZICIiIiKiEtAlpSLpo2ikbfkKLvWDUO2rFXBv1djeZZEVOfR1Oc+ePYtbt27hueeeAwDEx8fj+vXr6Natm8l8kZGRiI2NRV5eHgDgxIkT8Pb2Rps2bYzzBAcHo379+jhx4oTtFoCIiIiIqBiyToe0LV/hZsvByNjzHfznvoEaR9ez6SqDHGqP18MOHDgADw8PdOrUCQAQFxcH4MHeq/zq1KkDjUaD+Ph41KlTB3FxcQgKCipwRZLg4GDjGJaSJKlcXk2HxJMkCS4uvNM8icOMkUjMF4lUVvOV89ufSJi8BLl//AWvgd3gN2MsVJX97F1WuWSLjDls46XVanHo0CF07NgRHh4eAIDU1FQAgLe3t8m8hp8N09PS0uDl5VVgTB8fH1y8eLHUtRV2ZUNJkoq84qGhUStuuqjncly+No4+riPW5GzjOmJNHNdxa3K2cR2xJmcb1xFrKu/j6hJSkPThGqRvOwiXsMdR7UAU3J4KNxmrrCyr6HEdrabiOGzjderUKSQlJaFHjx72LsWELMvIy8sz2eulUCiMF+zQaDQFnmPonnU6HfR6vck0lUoFSZKg1+uh0+lMphnGlWW50HENl7ssbFylUgmlUglZlqHVak2mSZJkfK5Wqy0QHFHjlmRZgYLrUNS4hmWVJMnsZS3JuIB561CWZej1eri5uUGSJLOX1TBuYTXZax0axi1uHdor38WtQ1vmG7DdNsKQMcPzuI1wrm1EaZdV9DZClmXk5uZCoVCYfEZyG2G6rI68jbDWsooYV5Zl43Rn3kbIOh0yPjuAtE82ArKMSh+/DbdBz0JSKk3GL4vbCEvWoS23EYbPSKVSaXzPPWobYchlSTls43XgwAH4+voaL44BPNhjBTy4VHxAwP/dNC4tLc1kure3N+7cuVNgzNTUVOM8pWEISFHTipI/0A9TKBRQKAo/5S5/2M0d91HPLe4Kj6LGLW5ZgeLXobXHNbyOpVlWa702D284yss6tFe+S/OeE/XaiN5GGDKWfxvGbUTx4zrSNuJhjrgOFQpFgc9IbiNKPi7A7xFFjZv/M9JZtxE5v1xEwuTFyLvwD7xe7A7/6a9AWalisXtOyto2wpG/Rxgyln/5HrWs5jRdgIM2Xjk5Ofjuu+/Qs2dPkxUZHBwM4MG5XoZ/G35Wq9WoWbOmcb7Y2NgCXei1a9cQEhJS6vokqfDzvB618oubLuq5HFfsuNauqbAvK9b8nY44riPW5GzjmvNcw/Yrf+MloiaO67g1iRz34Xw5Qk0c1zFrsmTckmy3HKleA939ZCTNWYX0nYfh2qQeqn+zBm7NGti1prI0rjVrenj7VZqaCuOQVzU8duwYsrKyjFczNKhZsyZq166Nw4cPmzweExODVq1aGXcLtmvXDqmpqYiNjTXOc+3aNVy6dAnt2rUTvwBEREREVK7JWi1S1u5GfKsXkXnkJwR8+i6qH15t0nRR+eKQe7y+/vprVKtWDc2bNy8wbfz48Zg4cSJq1aqFFi1aICYmBufPn8fWrVuN8zRt2hQRERGYOnUqJk2aBFdXVyxevBihoaHo0qWLLReFiIiIiMqZ7J/+QMKUxci7fA3ew3vCb8oYKP1Kf7oLOTeHa7xSU1Px448/Yvjw4YXuwuvRoweys7MRHR2NtWvXIigoCCtWrEDTpk1N5luyZAnmzZuHmTNnQqvVIiIiAtOnTy/2WM2SsGS3IlFJlTafRI/CjJFIzBeJ5Az50t5JQOL7K5Gx+1u4Nm+A6kfWwq1JPXuXRSUkOmOSbMm1EMupCxcuAADCw8PtXAkREREROQpZo0Xqut1IWrARkqsa/jNehdegbpCKudAEOT9zewPH/9OBAzL30pFEJZH/Ut/MF4nAjJFIzBeJ5Mj5yj71O+5PXgzN3zfgPeJ5+E0ZDaVvwfvJkmOzRcbYeJmJOwhJJJ1OV+xlWIlKixkjkZgvEsnR8qX97z4SZ0UhY+9RuD0ZhsDv1sE1/HF7l0WlIDpjbLyIiIiIiEpIztMgZc0XSF64GYoK7qi8Yho8+3d1uD1x5HjYeBERERERlUDWD78iYcoSaOJuwWdUH1ScNBJKb097l0VOgo0XEREREVExNLfuInHGcmQe+AFuLRsjcN37cG1Qx95lkZNh42Um7kYmkRzp2HUqm5gxEon5IpHskS85Nw8pK3cgeclnUHh6oPKqGfB84Rl+HyyjRGeMjZcF+GYjESRJcop7lJDzYsZIJOaLRLJHvrKOnkHC1CXQ3PwPPi/3g9/EEVB4VbBpDWQ7tsgYt5BEDoS3KiDRmDESifkikWyVL83N/x4cVhjzI9wimqHKlo/gEhok/PeS/YnOGBsvM8myzA8WEkKWZWg0GqjVauaLhGDGSCTmi0SyRb70OblIWbEdKUu3QlHRB4HR76NCrw7Mczlhi4yx8SIiIiKici3zyCkkTFsG7e178B07ABXfHgaFp4e9y6Iyho0XEREREZVLmmu3kTB9GbKO/AT39k+i6uefwKVuLXuXRWUUGy8iIiIiKlf0WTlIWbYVKSs+h7KSLwI3fIAKPZ7mYYUkFBsvIiIiIioXZFlG1qEfkTBjBbR3EuD7+iBUfHMIFBXc7V0alQNsvMzEv4SQSGq12t4lUBnHjJFIzBeJVNp85V2NR8LUpcg+dgYenVqi6hefwqVOTStVR2WB6G0YGy8LsPkiEZgrEo0ZI5GYLxKpNPnSZ2YjeclnSFm5A6oqlVBly0fweDaCmSUTtsgDGy8L8HLyJIIsy9DpdFAqlcwXCcGMkUjMF4lkSb5kWUbm198jceYK6BJSUPHNIfAd/yIU7q5iiyWnZIttGBsvM8mybO8SqAzT6/VQKpX2LoPKMGaMRGK+SCRz8pX3zw0kTFmC7B9+hUfXNqg09w2oa1cTXCE5O9HbMDZeRERERFQm6DOykLxoM1JWfwFV9cqosu1jVOjS2t5lEQFg40VERERETk6WZWTuO4aEWVHQJ6ei4jvD4fv6ICjceFghOQ42XkRERETktPL+uob7U5Yg5+RZVOjeDv5zxkFdq6q9yyIqgI2XmXjCMInEcyNINGaMRGK+SKSH86VPz0TSJxuRGr0b6lpVUXXnQnh0bGGn6qgsEL0NY+NlATZfJIIkSfzSQkIxYyQS80Ui5c+XLMvI2H0EibNXQp+RBb/Jo+E7tj8kVxc7V0nOzBbbMDZeFuDl5EkEWZaN2WK+SARmjERivkgkQ77yLsUhccoS5Jw+hwo9O6DSnNehqh5o7/KoDLDFNoyNl5l4OXkSSavVCr9rOpVvzBiJxHyRKLrUdCTOX4eMTV9BHVwDVXcvhsfTT9i7LCpjRG/D2HgRERERkUOS9Xqkf/ENkt5fBX1WNvymvQzfV/pBcmGDT86HjRcREREROZzc838jYfJi5PxyERX6dIb31NFwr1WNh7KS02LjRUREREQOQ5eSjqSPopG2eT/UIY+h2r5lcGvdBBqNxt6lEZUKGy8z8a8sJBLzRaIxYyQS80WlIev1SN8eg8S5qyHnauD//mvwGfUCJLWKFzYjmxCdMTZeFuAbn0SQJIknpZNQzBiJxHxRaeT88RcSJi1C7tnL8OzXBf4zX4WqSiXjdOaLRLNFxth4EREREZFd6JJSkfThWqR99jVcGgSj2lcr4N6qsb3LIhKCjZcFuLubRJBlGVqtFiqVivkiIZgxEon5InPIOh3Sth5A0odrAZ0elT58A94vPQ9JVfhXU+aLRLNFxth4mYn38SKRmC8SjRkjkZgvKomc3/5EwqTFyD33P3gN7Aa/GWOhquz3yOcxXySa6Iyx8SIiIiIi4XQJyUj8YA3Stx+ES/jjqB6zCm5Phtm7LCKbYeNFRERERMLIOh3SNu1H0rxoQJJQacHb8B7WE5JSae/SiGyKjRcRERERCZF95jwSJi9B3p9X4PVid/hPfwVKf197l0VkF2y8zMQTOkkkXiqXRGPGSCTmiwy095KQ+P4qZHxxGK5N6qH64dVwa9agVGMyXyQaLyfvgNh8kQjMFYnGjJFIzBcBgKzVInX9XiR/vB5QqxCw6F14De5e6sMKmS8SzRYZY+NlAV5OnkSQZRk6nQ5KpZL5IiGYMRKJ+aLsn/5AwpTFyLt8Dd7De8Jvyhgo/XysMjbzRaLZImNsvMzES5mSSHq9HkqebEwCMWMkEvNVPmnvJCDx/ZXI2P0tXJs3QI1vo+HaONTqv4f5ItFEZ4yNFxERERGZTdZokRq9G0kLNkByd0XA0snwGtgNkkJh79KIHBIbLyIiIiIyS/bJs7g/eTE0/9yE90vPw2/yaCh9vexdFpFDY+NFRERERCWi/fceEmZGIXP/Mbg9FY7A79bBNfxxe5dF5BTYeJmJJ3SSSDx2nURjxkgk5qvskvM0SFn9BZI/3QxFBXdUXjENnv272vR7EfNFoonOmEMehLt37148//zzCA8PR4sWLTB69Gjk5OQYpx87dgw9e/ZEeHg4unbtii+//LLAGHl5efj444/Rpk0bNGnSBC+99BLi4uKsUh+bLxJBkiRerYmEYsZIJOar7Mr6/hfEPz0CSR9Fw3toD9Q8vQ1eA5616WvNfJFotsiYw+3xWrVqFaKjozF27Fg0adIEycnJiI2NhU6nAwD8+uuvGDduHPr27YupU6fi9OnTmDZtGipUqIBnn33WOM7cuXMRExODyZMnIzAwEKtXr8aIESNw8OBBeHmV7hhkXk6eRJBl2Zgt5otEYMZIJOar7NHcuovEGcuReeAHuLVqjMD1c+DaoI5damG+SDRbZEySHej66HFxcXjuueewcuVKPP3004XOM2rUKGRmZmLHjh3Gx9555x1cvnwZMTExAIA7d+6gY8eOmDVrFgYMGAAASElJQYcOHfDaa69hzJgxFtV34cIFyLKM8PBwvunJ6mRZhkajgVqtZr5ICGaMRGK+yg45Nw8pUTuQvGQLFN6e8J8zDp69O9n1dWW+SDRLMnbhwgUAQHh4eInmd6hDDffs2YMaNWoU2XTl5eXhzJkzJnu2ACAyMhJXr17FrVu3AAAnT56EXq83mc/X1xdt2rTBiRMnxC0AERERkRPL/O404tsOR9InG+A9sjdqnd4Orz6d2ewQWYFDNV7nzp1DSEgIVq5ciVatWiEsLAwDBw7EuXPnAAA3b96ERqNBcHCwyfPq1Hmw29twDldcXBz8/f3h4+NTYD5rnedFREREVFZobvyL/4ZNwZ1B70JVozJqfr8RlWa/DoWnh71LIyozHOocr/v37+PixYv4+++/MWvWLLi7u2P16tUYOXIkjhw5gtTUVACAt7e3yfMMPxump6WlFXoel7e3t3Ge0ijs6ExJkgp93DCtqOeJfi7HdZ7XxnBscf6frTGuqHqtNa4j1uRs45b0uYaMGX52xmV1tnEdsSaR4z68HbPGuKWtieMW/1w5Jw8py7chZfk2KCr6oHL0bFTo2aFEv7M0NZk7bv5slZfXpqzl0NHXYf5tWGnGLY5DNV6yLCMrKwtLly5FvXr1AACNGzdGx44dsXXrVkRERNi5wgc0Go3JLneFQgGVSmWc9jAXFxcAgE6ng16vN5mmUqkgSRL0er3xAiIPj2s45vRharW6yHGVSiWUSiVkWYZWqzWZJkmS8blarbZAcESNW5JlBQquQ1HjGpZVkiSzl7Uk4wLmrUNZlk3mNXdZDeMWVpO91qFh3OLWob3yXdw6tGW+AdttI2RZNo6hUqm4jXjEuIZldZRtRGmX1RbbCMO0/J+R3EaYLqsjbSPyjv2MxBnLob19D16v9IP3Gy9CUcEdWq3W4b5H5P83txHOu41w5O8Rhs9ISZKM77lHbSPyN2kl4VCNl7e3N3x9fY1NF/Dg3KwGDRrgypUr6N69OwAgPT3d5HlpaWkAYDy00NvbGxkZGQXGT0tLK3D4obnyvxiFMbwYhckf6IcpFAooFIUf+Zk/7OaO+6jnGt4Ithy3uGUFil+H1h7X8GYpzbJa+7Ux1FRe1qG98l2a95yo14bbiAfKUr6LGtegLK1DSZLg7u5e6OMAtxElGRewzTZCc+02EqcvQ9a3sXBv/ySqbF8Al7q1SvTch9l6GyFJErcRJRzX0bYRRY3rzNsIc5ouwMEar7p16+LmzZuFTsvNzUWtWrWgVqsRFxeHtm3bGqcZztsynPsVHByMhIQEpKammjRacXFxBc4Ps0RRK/lRK7+46aKey3HFjuuINTnbuI5Yk7ON64g1cVzHrcnZxnXEmpxtXMN0fVYOUpZtRcqKz6EMqIjAjXNRoXu7MrWszjauI9bkbOM6ak2FcaiLa3To0AEpKSm4fPmy8bHk5GT8+eefaNiwIVxcXNCiRQt88803Js+LiYlBnTp1UKNGDQBAREQEFAoFjhw5YpwnNTUVJ0+eRLt27UpdpyXHdBI9imFXOfNFojBjJBLz5bhkWUbGwROIjxiK5OXb4fv6INQ8tRWePZ626MujPTBfJJotMuZQe7w6d+6M8PBwvPHGG3jrrbfg6uqKtWvXwsXFBYMHDwYAvPrqqxg2bBhmz56Nbt264cyZMzhw4AAWL15sHKdKlSro27cvFixYAIVCgcDAQKxZswZeXl4YOHBgqWrkG55EYr5INGaMRGK+HE/e1ZtImLIU2cd/hkfnlqi2ezHUwTXsXZZFmC8STXTGHOoGygCQlJSEefPm4fjx49BoNHjiiScwZcoU1K1b1zjP0aNHsWTJEly7dg3VqlXDyy+/jL59+5qMk5eXh8WLF2P//v3IzMxEs2bNMH36dOOl5y3BGyiTSIa/tPDmkCQKM0YiMV+ORZ+ZjeRFm5GyaidUVQNQ6cM34NG1jdO+NswXiWZJxsy9gbLDNV6OjI0XicQPFRKNGSORmC/bys7OxqVLl5CXlwcXFxcEBQXh9u3bqFOnDvTfnkHCzBXQJ6bA940X4Tv+RSjcXe1dcqkwXySaLRovhzrUkIiIiIgeLTs7GxcvXjR+UfTz88OV707Ae/oaaH86B49nI1Dpg/FQ165m71KJ6P9j42Um/pWFRCrusqVE1sCMkUjMl23pdHpk52qhyNUhdd4WhO0/Bn2NyqiyfQEqPNPK3uVZHfNFoonOGBNsATZfJIIkScwWCcWMkUjMl20kJSUhNTUV167fxI34O6h5+RaeOP0/uOZqca7F4/AbNxCoWwU+SUnw8/Ozd7lWw3yRaLbIGBsvC5h7l2qikpBlGXq93qIb8hGVBDNGIjFftnH69GlcunQJLrfuo8v3l1HldjJuBAfgbEQIMrzcoTxzGmfP/4EGDRogMjLS3uVaDfNFotkiY2y8zMRrkZBIOp2u2Du+E5UWM0YiMV/itWgYjtDDZyHvPI00b3cc7t4cd4ICkafwghuy0KZtCwQ9Vgs+Pj72LtXqmC8STXTG2HgREREROThZlpGx+wjSZ62ElJkF97dexI9+Cug1WtRydUFowydw/cp5NGkUXqYOMSQqS/hnAyIiIiIHlnvxCv59bhzuvTYXbq2boNZPW+H2cl8oXNVwd1XBRa1EzSpeUKuU9i6ViIrBPV5EREREDkiXmo7k+euRumEv1HVrouqXi+HR7gkAgHt2NsLCwoz38fLx8UFYWBjc3d3tXDURFYWNl5l4QieJxGPXSTRmjERivqxD1uuRvvMwkj5YDX1WDvxnjoXPmL6QXNTGedzd3dG8eXOT55X1QwyZLxJNdMbYeFmAzReJIEkS71FCQjFjJBLzZR255/6H+1OWIPeXi/Ds0xn+778OVZVK9i7L7pgvEs0WGWOCLcDLyZMI+a+YyXyRCMwYicR8lY4uOQ1J86KRtmk/1KG1UW3fMri3aWrvshwG80Wi2SJjbLzMxMvJk0gajQZqtfrRMxJZiBkjkZgv88l6PdK3HUTi3DWARgv/OePgM6oPJDW/oj2M+SLRRGeM72oiIiIiO8j54y8kTFqE3LOX4dm/K/xnvgpVoL+9yyIiQdh4EREREdmQLjEFiR+uRfrWA3BpUAfVvo6Ce8tG9i6LiARj40VERERkA7JOh7TPvkbSR9GATo9KH70J7xG9IPGiEUTlAt/pZuIJnSQS80WiMWMkEvNVtJxf/8T9SYuQd/5veA2KhN+MsVAFVLR3WU6F+SLRRGeMjZcF+MYnESRJ4knDJBQzRiIxX4XT3k9G0gerkf55DFwahaB6zCq4PRlm77KcDvNFotkiY2y8iIiIiKxM1mqRtmk/kuavAyQJlT55B95Dn4OkVNq7NCKyEzZeFuB9vEgEWZah1WqhUqmYLxKCGSORmK//k33mPBImLUbepavwGtID/tNehtLf195lOTXmi0SzRcbYeJmJ9/EikZgvEo0ZI5HKe760dxOROGc1Mr44DNem9VH9mzVwa1rf3mWVGeU9XySe6Iyx8SIiIiIqBVmrReq6PUhesAFQqxCw6D14vdgdkkJh79KIyIGw8SIiIiKyUPap35EwZQny/roG7xG94DdlDJQVve1dFhE5IDZeRERERGbS3klA4qwoZOz5Dq5PNESNb6Ph2jjU3mURkQNj42UmntBJIql4E00SjBkjkcpDvmSNFqlrdyHpk42Q3F0RsHQyvAZ242GFNlAe8kX2JTpjTLAF2HyRCJIkMVskFDNGIpWHfGX9+BsSJi+G5ko8fEb2RsXJo6D08bJ3WeVCecgX2ZctMsbGywK8nDyJIMsy9Ho9FAoF80VCMGMkUlnOl/bfe0iYGYXM/cfg1qIRAo/OhmtYXXuXVa6U5XyRY7BFxth4mYmXMiWRdDodFDxchQRixkikspYvOU+DlFU7kbxoMxSeHqi8cjo8+3bhF387KWv5IscjOmNsvIiIiIgeknX8ZyRMWQLN9X/hM+YF+L03EgqvCvYui4icGBsvIiIiov9PE38HiTNWIPPgD3Br3QSBG+fCtX6wvcsiojKAjRcRERGVe/qcXKRG7UDy0s+g8PFC5TWz4Nm7Ew8rJCKrYeNlJm6ASSQeu06iMWMkkrPmK/PbWCRMXQrtrTvwHdsfFd8ZAYWnh73Looc4a77IeYjOGBsvC7D5IhEkSeI9SkgoZoxEcsZ8aW78i4Tpy5F1+CTc2zVH1W3z4RJS295lUSGcMV/kXGyRMSbYArycPImQ/4qZzBeJwIyRSM6UL312LlJWbEfKsq1Q+PkicN0cVOjZ3uHrLs+cKV/knGyRMTZeZuLl5EkkjUYDtVpt7zKoDGPGSCRHz5csy8j65hQSpi+D9t/78H11ACq+PRyKCu72Lo1KwNHzRc5PdMbYeBEREVGZp4m7hYRpS5H13Wm4t38SVXcshEvdWvYui4jKETZeREREVGbps3KQvOQzpER9DlVlPwRu+hAVItvycDUisjk2XkRERFTmyLKMzIMnkDhjObT3klBx3GD4vjkECg83e5dGROUUGy8iIiIqU/Ku3kTC5CXI/v4XeDzTCtW+XAJ1cA17l0VE5RwbLzNJksTDE0gISZKgVquZLxKGGSORHCFf+sxsJC/ajJRVO6GqFoAqW+ejQtc2dquHrMcR8kVlmy0yxsaLyIHwA4VEY8ZIJHvlS5ZlZO4/joRZUdAnpaDiW8PgO24wFO6udqmHxOD2i0QTnTE2XhbgfbxIBFmWodPpoFQqmS8SghkjkeyVr7y/ryNhyhJkn/gNHs9GoNLc8VA/Vs1mv59sg9svEs0WGWPjZSbex4tE0uv1UCqV9i6DyjBmjESyZb70GVlIWrgRqWt2QV2zKqpsX4AKz7Syye8m++D2i0QTnTE2XkREROQ0ZFlGxt6jSJy5Avq0DPi9OxI+rw2Awo2HFRKRY2PjRURERE4h93IcEiYvRs5Pf6BCj6fhP2cc1DWr2LssIqISUdi7gPz27NmD0NDQAv8tXLjQZL5du3aha9euCA8PR8+ePXH8+PECY6Wnp2Pq1Kl46qmn0LRpU7zxxhu4d++erRaFiIiIrESXloGE6ctwq8NI6O4loeoXn6LKxrlsuojIqTjkHq9169bBy8vL+HNgYKDx3wcPHsSMGTMwduxYtGzZEjExMRg3bhy2bduGJk2aGOebMGECrly5gtmzZ8PV1RVLlizBmDFj8OWXX0KlsnyxeUInicRj10k0ZoxEsna+ZFlGxq5vkDh7FfSZ2fCbOga+Y/tDclFb9feQc+D2i0QTnTGHbLwaNmwIPz+/QqctW7YM3bt3x4QJEwAALVu2xN9//42oqChER0cDAH7//XecPHkS69evR0REBAAgKCgIkZGROHLkCCIjI0tVH5svEkGSJH6okFDMGIlk7XzlXryChEmLkPPzBVTo1RGV5rwOVbXKVhufnAu3XySaLTLmUIcaPkp8fDyuX7+Obt26mTweGRmJ2NhY5OXlAQBOnDgBb29vtGnzfzdNDA4ORv369XHixIlS18ErG5IIsixDr9czXyQMM0YiWStfutR03J+8GLc6jYIuJQ1Vv1yMKuveZ9NVznH7RaLZImMO2Xj16NED9evXR6dOnbBmzRrodDoAQFxcHIAHe6/yq1OnDjQaDeLj443zBQUFFdgzFRwcbBzDUnzDk0hardbeJVAZx4yRSKXJl6zXI237QdxsORjpOw7Bf9arqPn9Jni0e8KKFZIz4/aLRBOdMYc61DAgIADjx49H48aNIUkSjh07hiVLluDu3buYOXMmUlNTAQDe3t4mzzP8bJielpZmco6YgY+PDy5evFjqOgtrviRJKrIpMzSAxU0X9VyO6zyvjSzLJo852rI6wzosr+OW9LmGjBl+dsZldbZxHbEmkeM+vB0r6bg55/5CwqQlyP3tT3j26Qy/2a9BVaWSQy+rM43riDWZO27+bDlDvc5ck7ONa62a8m/DSjNucRyq8Wrbti3atm1r/DkiIgKurq7YvHkzxo4da8fKTGk0GpO9aQqFwnjBDo1GU2B+FxcXAIBOp4NerzeZplKpIEkS9Hq9cc/ew+PKslzouGq1ushxlUollEolZFku0L1LkmR8rlarLRAcUeOWZFmBgutQ1LiGZZUkyexlLcm4gHnrUJZlk/rNXVbDuIXVZK91aBi3uHVor3wXtw5tmW/AdtuI/MulUqm4jXjEuIZldZRtRGmX1RbbCEO9+T8ji1uHUnoWUuavQ9rmr6CuVxsBXy6GW8tGkP//uuE24gF+jzBtvLiNcN5thCN/jzD8W5Ik43vuUduI/E1aSZjdeN26dQtHjx7F2bNncfXqVSQnJ0OSJFSsWBHBwcFo1qwZOnbsiJo1a5o7dKG6deuGDRs24PLly/Dx8QHw4FLxAQEBxnnS0tIAwDjd29sbd+7cKTBWamqqcZ7SMASkqGlFyR/ohykUCigUhR/5mT/s5o77qOcWd4VHUeMWt6xA8evQ2uMaXsfSLKu1XpvCNmJFKUvr0F75Ls17TtRrI3obYchY/m0YtxHFj+tI24iHOeI6VKlUBT4jC1uHsl6P9G0HkfThWkCjhf8H4+A9sjekQn43txH/pzx/j8j/5ZrbiJKN64jbCEf+HmH4jMy/fI9aVnOaLsCMxuv48ePYsGEDfvvtN8iyjFq1aqFGjRoICQmBLMtIS0vDX3/9hSNHjmD+/Plo3rw5Ro0ahQ4dOphVUHGCg4MBPDiHy/Bvw89qtdrY7AUHByM2NrZAF3rt2jWEhISUqgZJkoz/FTbtUc+1ZFppnstxxY5r7ZrybxgcbVmdZR2Wx3HNea5SqTTZhjnbsjrbuI5Yk8hxH85XYc/NOXsJCZOXIPf3y/Ds/yz8Z46FKtBfWE0c1zFrsmRcw2eks9TrrDU527jWrMmwDbNGTYUpUePVv39//PXXX+jUqROWLFmC1q1bw9PTs9B5MzIycOrUKXzzzTeYMGEC6tWrh507d5pdmEFMTAyUSiUaNGiAgIAA1K5dG4cPH0bnzp1N5mnVqpVxt2C7du2wcuVKxMbGonXr1gAeNF2XLl3C6NGjLa7FwJIVTfQokiSV6h5zRI/CjJFIj8qXLjEFiXPXIH3bQbg0qINqB6Lg3qKRDSskZ8btF4lmi4yVaPQWLVpg5cqVqFSp0iPn9fT0RNeuXdG1a1fcv38fW7ZsKXExo0aNQosWLRAaGgoAOHr0KL744gsMGzbMeGjh+PHjMXHiRNSqVQstWrRATEwMzp8/j61btxrHadq0KSIiIjB16lRMmjQJrq6uWLx4MUJDQ9GlS5cS10NERESlI+t0SNvyFZI+igZkGZXmTYD38J6FHlZIRFSWSbIll+QQZO7cufjxxx9x584d6PV61K5dG/369cPQoUNN9jLt2rUL0dHR+PfffxEUFIS33367wCGN6enpmDdvHr799ltotVpERERg+vTpCAwMtLi+CxcuQJZlhIeHc68XWZ3h+PXiziEkKg1mjEQqLF85v1zE/cmLkXf+b3gN7g6/6a9AFVDRzpWSM+L2i0SzJGMXLlwAAISHh5dofodqvBwdGy8SiR8qJBozRiLlz5cuIQVJH6xG+ucxcGkUgoCP34bbEw3tXSI5MW6/SDRbNF4l3s//559/lnRWo4YNuZElIiIqL2StDqmbv0Ly/PWAUoFKCyfCe0gPSEVcUYyIqDwpceP1wgsvmPUXBkmScOnSJYuKIiIiIueSc/o87k9aBM1f1+A99Dn4TXsZSr/S38KFiKisKHHjNW/evEfOk5OTgy+++AKXL18uVVFERETkHLR3EpA4ZxUydh2BS9N6qHZ4NdybNbB3WUREDqfEjVfv3r2LnJaXl4cdO3YgOjoa9+/fx5NPPonx48dbpUBHw+OKSaTibgBIZA3MGFmLrNEidf2XSPp4AyQXNSoteg9egyMhFXPzVKLS4PaLRBOdsVJdyzUvLw+ff/451q1bh/v37+Opp57CokWL8OSTT1qrPofE5otEYK5INGaMrCX71O+4P3kxNH/fgPfwXvCbMhrKit72LovKMG6/SDRbZMyixisvLw/bt2/H+vXrcf/+fbRo0aJcNFwGsixzA0BWJ8sydDpdgbumE1kLM0alpb2TgMRZUcjY8x1cnwxDjW+j4dooBADzRWIxXySaLTJmVuOVm5tr3MOVkJCAFi1aYPHixXjiiSeEFOeIePV9Ekmv10PJq3+RQMwYWULO0yBl7S4kL9wEhYcbApZPhVf/rgUOK2S+SCTmi0QTnbESN16bNm3CunXrkJiYiJYtW2Lp0qVo3ry5sMKIiIjI/rJO/IqEyUuguRoPn1F9UHHSSCh9vOxdFhGR0ylx4zV//nxIkoT69eujTp06OHToEA4dOlTsc6ZPn17qAomIiMj2tLfvImFmFDK/Og63Fo0QGD0brg3r2rssIiKnZdahhrIs49KlSyW6P5ckSWy8iIiInIycm4eUVTuRvHgLFJ4eqLxyOjz7duF5NUREpVTixuuvv/4SWYfT4AcPicRj10k0ZoyKk3XsDBKmLIHmxn/webkv/N59CQqvCiV+PvNFIjFfJJrojJXqcvLlFZsvEkGSJH6okFDMGBVFE38HiTOWI/PgCbi1aYoqmz+CS70gs8Zgvkgk5otEs0XG2HhZgJeTJxFkWTZmi/kiEZgxepg+JxepUTuQvPQzKHy8UHntLHg+38mifDBfJBLzRaLZImMWN1779+/Hl19+iVu3biE1NbXAZdYlScJvv/1W6gIdDS8nTyJptVrhd02n8o0ZI4PMIz8hYdoyaG/dge/Y/qj4zggoPD1KNSbzRSIxXySa6IxZ1Hh98skn2LBhAwIDAxEWFgYvL15WloiIyBlorv+LhOnLkPXNKbg//QSqbv8YLo8/Zu+yiIjKPIsar127dqF9+/aIioqC4qGbJxIREZHj0WfnImXZVqQs3w5lJV8Erp+DCs+152FbREQ2YvGhhk8//TSbLiIiIgcnyzKyDp9EwvTl0P53H76vDUTFt4ZBUcHd3qUREZUrFnVO7du3L5Pnb5UE/zJIIjFfJBozVr5o4m7hzqD3cGfYVKjr1kLNHzfDf/orwpou5otEYr5INNEZk2QLrhaRnp6OsWPHIjQ0FC+88AKqVq1a6N4vX19fa9ToMC5cuAAACA8Pt3MlRERERdNn5SB5yWdIifocqkB/VJo7Hh7d2vKLKxGRFZnbG1h0qKG7uzuaNm2K9evX4/PPPy9yvsuXL1syPBEREVlAlmVkHvgBiTNXQHc/GRXHD4bvG0Og8HCzd2lEROWeRY3XnDlzsGvXLjRu3BiNGzcud1c15H28SARZlqHVaqFSqZgvEoIZK9vyrtxEwpQlyP7+F3g80wqV9rwJdVB1m/1+5otEYr5INFtkzKLG69ChQ+jVqxfmz59v7XocHu/jRSIxXyQaM1b26DOykLxoC1JW74SqemVU2TYfFbq0sUstzBeJxHyRaKIzZlHjpVKp0LhxY2vXQkRERCUkyzIy9x1Dwqwo6JNTUfHtYfAdNxgKN1d7l0ZERIWw6KqG3bt3x/Hjx61dCxEREZVA3v+u4b8XJuDuy7Ph1rQeap78DH4TX2LTRUTkwCza49WtWzfMnTsXL7/8svGqhkqlssB8DRs2LHWBRERE9IA+IwtJn2xE6tpdUNesiqo7FsKjUwt7l0VERCVgUeP14osvAnhw1cIff/yxwHTDxSfK4lUNeUIniaRSWXxPc6ISYcackyzLyNjzHRJnRUGflgG/90bC97WBkFxd7F2aCeaLRGK+SDTRGbNo9Hnz5lm7DqfC5otEkCSJ2SKhmDHnlHvpKhImL0ZO7DlU6PE0/D8YD3WNQHuXVQDzRSIxXySaLTJmUePVu3dva9fhVHg5eRJBlmXo9XooFArmi4RgxpyLLi0DyR9vQOr6PVAHVUfVXYvg0f5Je5dVJOaLRGK+SDRbZIz7bM3ES5mSSDqdDgqFRde8ISoRZszxyXo90r/4BklzVkGfmQO/aWPg+0p/SC5qe5f2SMwXicR8kWiiM1aikWfOnIn4+HizB7958yZmzpxp9vOIiIjKo9wL/+DfHq/j/viP4N6mKWrFbkXF8S86RdNFRETFK9Eer//++w/dunVDy5YtERkZiVatWqFq1aqFznvr1i3Exsbi0KFDOHPmDNq0sc9NHImIiJyFLiUdSfPWIW3TPqgfr4Vqe5fCPaKZvcsiIiIrKlHjFR0djd9++w0bNmzAzJkzodPp4Ovri+rVq8PHxweyLCM1NRW3bt1CWloalEol2rVrh82bN+OJJ54QvQxEREROSdbrkf75ISTOXQ05Jw/+s1+Fz+i+kNQ8E4CIqKwp8Za9efPmaN68OZKSknD8+HH88ccfiIuLw507dwAAvr6+6NKlC5o0aYL27dvD399fWNH2xBM6SaTC7odHZE3MmOPIPfc/3J+0CLm/XYJn32fgP+s1qKpUsndZpcJ8kUjMF4kmOmOSzKtFlNiFCxcAAOHh4XauhIiInJUuKRVJH0UjbctXcKkfhErz3oJ76yb2LouIiMxkbm/AYxkswMvJkwj5/wbCfJEIzJh9yTod0rcdROLcNYBWB/+5b8Bn5POQyshNYZkvEon5ItFskbGysbW3Ie4gJJE0Gg3Ual69jMRhxuwj5+wlJExajNw//oLXgGfhN/NVqCr72bssq2O+SCTmi0QTnTE2XkRERILoEpKR+OFapG87CJeGdVH94Eq4PcXD1YmIyiM2XkRERFYm63RI2/wVkuZFA7KMSvPfgvfwnpB4cQAionKLjRcREZEV5fxyEfcnLULehX/g9WJ3+E9/BcpKFe1dFhER2RkbLzPxhE4Sifki0ZgxcbT3kpA0ZxXSdx6Ga+NQVD+8Gm7NG9q7LJtivkgk5otEE50xRUlnXLRoEf766y+RtTgNvvFJBEmSoFarmS8ShhkTQ9ZqkbJ2N+JbvYjMIz+h0sKJqP7NmnLZdDFfJArzRaLZImMlbrzWrl2Lf/75x/hzcnIy6tevj9jYWCGFERERObrs2HO41Xk0Eqcvg2fvTqh1ejt8hvfiuVxERFRAqQ41LK+XVud9vEgEWZah1WqhUqmYLxKCGbMe7Z0EJM5ZhYxdR+DavAGqH1kLtyb17F2WXTFfJBLzRaLZImMl3uNla5mZmWjXrh1CQ0ONd4U22LVrF7p27Yrw8HD07NkTx48fL/D89PR0TJ06FU899RSaNm2KN954A/fu3St1XeW12STbYL5INGasdGSNFimrduBmqxeRdewMAhZPQvWYVeW+6TJgvkgk5otEE50xh228Vq5cCZ1OV+DxgwcPYsaMGejWrRuio6PRpEkTjBs3Dn/88YfJfBMmTMCpU6cwe/ZsLFy4ENeuXcOYMWOg1WpttARERFSWZJ/6HfEdRyJx9ip49X8WtWK3w3tID0gKh/0oJSIiB2LWoYa3b9/Gn3/+CeDBHiUAuHHjBry9vQudv2FDy04svnr1KrZv345JkyZh1qxZJtOWLVuG7t27Y8KECQCAli1b4u+//0ZUVBSio6MBAL///jtOnjyJ9evXIyIiAgAQFBSEyMhIHDlyBJGRkRbVRURE5Y/2v/tInBWFjL1H4fZkGAK/jYZroxB7l0VERE7GrMZr6dKlWLp0qclj77//foH5DOdAXb582aKi5s6di4EDByIoKMjk8fj4eFy/fh3vvvuuyeORkZFYsGAB8vLy4OLighMnTsDb2xtt2rQxzhMcHIz69evjxIkTbLyIiOiR5DwNUtZ8geSFm6Go4IaA5VPh1b8r93AREZFFStx4zZs3T2QdRocPH8bff/+N5cuXG/euGcTFxQFAgYasTp060Gg0iI+PR506dRAXF4egoKACJ8YFBwcbx7AUT+gkkVQq3lqPxGLGSibrh1+RMGUJNHG34DOqDyq+9xKUPl72LsvhMV8kEvNFoonOWIlH7927t8g6AADZ2dmYP38+3nrrLXh6ehaYnpqaCgAFDm00/GyYnpaWBi+vgh+QPj4+uHjxolVqffjkO0mSijwhz9CsFTdd1HM5rnO9NpIkOeyyOss6LI/jmvPc/PM747KKHld7+y4SZ0Yh8+vv4dayEQKjZ8O1YV3Islzke9ZZl9Xa4xY1BrcR9h/XEWuyZFzDZ6Sz1OusNTnbuNas6eEdLJaMWxyH+tPBqlWr4O/vjxdeeMHepRRJlmXk5eWZvDAKhcLYIWs0mgLPcXFxAQDodDro9XqTaYZLVur1+gIXEzGMK8tyoeOq1eoix1UqlVAqlcZLY+ZnuEEcAGi12gLBETVuSZYVKLgORY1rWFZJksxe1pKMC5i3Dg1f7FxdXSFJktnLahi3sJrstQ4N4xa3Du2V7+LWoS3zDdhuG2HImCRJUKlU3EbkG1fOzUNS1OdIW7oNkpcH/JZPgUfvTsW+NrbeRpR2WUVvI/J/Pub/jOQ2wnRZHXkbYa1lFTGuLMvG5eH3COfcRhS3rI6wjTB8RioUCuN77lHbCMNnakk5TON1+/ZtbNiwAVFRUcYLd2RlZRn/n5mZCR8fHwAPLuwREBBgfG5aWhoAGKd7e3vjzp07BX5HamqqcZ7SKO6u1oYXozD5A/0whUIBRRHnDeQPu7njPuq5xe1SFTVuccsKFL8OrT2u4XUszbJa67V5eMNRXtahvfJdmvecqNdG9DbCkLH82zBuI4Cso2eQMHUJNDf+g8+YF1Dx3Zeg8KoAwLG2EQ9zpHVoYKg5/2cktxElHxfg94iixs3/GVmWPgOLGtegrG0jHPl7hCFj+ZfvUctqTtMFOFDjdevWLWg0Grz88ssFpg0bNgyNGzfGp59+CuDBuV7BwcHG6XFxcVCr1ahZsyaAB+dyxcbGFuhCr127hpCQ0l+J6uG/5uV//FHPs2RaaZ7LccWOa+2aCvuyYs3f6YjjOmJNzjauOc81bL/yN14ianKUcbOzs3Hp0iUAD84Pvn37NqpXr47bt2+jtqsnMj+MRmbMj3CLaIYqmz+CS72gwoZ1imV1hHEfzpcj1MRxHbMmS8YtyXbLkep11pqcbVxr1vTw9qs0NRXGYRqv+vXrY8uWLSaPXb58GfPmzcP777+P8PBw1KxZE7Vr18bhw4fRuXNn43wxMTFo1aqVcbdgu3btsHLlSsTGxqJ169YAHjRdly5dwujRo223UEREZFfZ2dnGc3v9/Pxw8eJFVFC7IOmTjfA4dg5KPx8Erp2NCs93tOhDlIiIqKQcpvHy9vZGixYtCp3WsGFD4z3Bxo8fj4kTJ6JWrVpo0aIFYmJicP78eWzdutU4f9OmTREREYGpU6di0qRJcHV1xeLFixEaGoouXbrYZHmIiMh+srOzceXKFUgKFyQmp8LL88Ghg57n4qD56AtUu58E15eeR7Vpr0Dh6WHnaomIqDxwmMarpHr06IHs7GxER0dj7dq1CAoKwooVK9C0aVOT+ZYsWYJ58+Zh5syZ0Gq1iIiIwPTp00t9mUj+RZREKu64aCJrKA8ZS0pKwq1btxB7+jTiU12AjGTobt5H0rZZaHDxGq5XC8QfL3ZEm95tobl/Fz55PvDz87N32WVCecgX2Q/zRaKJzpgkW3ItxP9Po9EgLi4O6enphV5S8cknnyxVcY7mwoULAIDw8HA7V0JEREWJiYnBxYsXkZubC12ODo3OxiHs9xvIcVfj14gQ3AyuDFmS4ObmBrVKiQYNGiAyMtLeZRMRkZMxtzewaPePXq/Hp59+iu3btyMnJ6fI+S5fvmzJ8A7P3EtHEpVEYfe9IbKm8pCxpKQkVK9eHbIs4c7ub9H8xJ/wyMjGn02DkNqnLW78l4B72R6o7KVFh47tEBjgb5Wr3VL5yBfZD/NFotkiYxY1XqtXr8b69esxYMAANG/eHO+99x4mTpwIb29vbN++HZIk4d1337V2rQ6hFDsIiR7JcKlvIlHKesZOnz6NGyd/Rvi351Hv+n3cruWPYz2bIKNiBbgmJ8LH2xWdurTH9SvnEVI3mIcYWllZzxfZF/NFoonOmEUHMu7duxfdunXD+++/j7Zt2wJ4cAGM/v3744svvoAkSTh9+rRVCyUiIiqOPjMbjWP/QZdNP6Bytg7Hn2uBHc90RJqvJ3wrVkTbtm3h7+eHmlW8oFYVfk8XIiIiUSxqvO7cuYOWLVsC+L+7qefl5Rl/7tmzJ/bv32+lEomIiIomyzIyvjqO+DZDkLvxK1R8cwj8j6yGS4cmeCGyNSpV8keTxo1Rr149NGvWDD4+PggLC4O7u7u9SycionLEokMNfX19kZWVBQCoUKECPD09ER8fbzJPWlpa6asjIiIqRt4/N5AwZQmyf/gVHl3boNIH46EOqo6kpCSoVUoE1/THvdsVERYWBj8/P+OhhTzEkIiIbM2ixqtBgwbGq3gAQIsWLbB582bUr18fsixjy5YtCA0NtVqRRERE+ekzspC8aDNSVn8BVfXKqLLtY1To0to43d3dHWFhYdy7RUREDsOixqt///7Yu3cv8vLy4OLigrfeegsvvvgihgwZAlmW4ePjg8mTJ1u7VocgSRKvpkNCSJIEtVrNfJEwZSFjsiwjc98xJMyKgj45FRXfGQ7f1wdB4eZqMp+7u7vx8r7cu2UbZSFf5LiYLxLNFhkr1X288ktPT8eZM2egVCrRtGlT+Pr6WmNYh8L7eBER2U/eX9dwf8oS5Jw8iwqRbeH/wXioa1W1d1lERFRO2eQ+XoXx8vJC586drTWcQ+N9vEgEWZah0+mgVCqZLxLCWTOmT89E0icbkRq9G+paVVF1x0J4dGph77LoIc6aL3IOzBeJZouMWXRVw06dOmHAgAGIi4srdPp3332HTp06laowR8X7eJFIer3e3iVQGedMGZNlGem7vsHNloORtnk//CaNQs0Tm9l0OTBnyhc5H+aLRBOdMYsar9u3b+PPP/9Ev3798N133xWYnpWVhX///bfUxRERUfmU++cV/NtzPO69NhduLRqh5qmtqDhhKCRXF3uXRkREZBGLGi8AmDJlCp588kmMHz8eS5YssWJJRERUXulS05EwdSludRoNXUIyqu5ejCobPoC6RqC9SyMiIioVi8/x8vb2xurVq7FixQqsXLkSly5dwqeffgovLy9r1kdEROWArNcj/YtvkDRnFfSZOfCb/jJ8X+4HyUVt79KIiIiswuI9Xgbjxo3D6tWrce7cOfTt2xf//POPNepyWDyhk0RSqax2vRuiQjlixnLP/41/e7yO++M/gntEM9Q6vQ0Vxw1m0+WEHDFfVHYwXySa6IyVuvECgHbt2mH37t1wd3dH//79cfToUWsM67DYfJEIkiRBoVAwXySMo2VMl5KO++8twq1nxkCXloFqe5cicO1sqKoG2Ls0soCj5YvKFuaLRLNFxqzSeAFAzZo1sXPnTnTp0gXffPONtYZ1SLyyIYkgyzL0ej3zRcI4SsZkvR5pWw/gZstBSN/1Dfzffw01j2+Ee0Qzu9ZFpeMo+aKyifki0WyRMYv2p23ZsgV169Yt8Lirqys+/vhjREZGIikpqdTFOSK+4UkkrVYLtZqHV5E49s5Yzh9/IWHSIuSevQzPfl3gP/NVqKpUsls9ZF32zheVbcwXiSY6Y2Y3XtnZ2Zg/fz769euHQYMGFTrP008/XerCiIio7NAlpSLpo2ikbfkKLg2CUe2rFXBv1djeZREREdmM2Y2Xu7s7bt26xWNsiYjokWSdDmlbDyDpw7WAVodKH74B75eeh8ST5ImIqJyx6Byvtm3b4uTJk9auhYiIypCc3/7E7a6vIGHiQlTo2gY1T2+Hz5i+bLqIiKhcsqjxeu2113D9+nW8++67+PXXX3H37l2kpKQU+K8s4p4+EkmhsNr1bogKZYuM6RKSce/N+bj97FjIej2qH1yJysunQlXZT/jvJvviNoxEYr5INNEZs+jPjt27dwcAXLlyBQcOHChyvsuXL1tWlYNj80UiSJLEe5SQUKIzJut0SNu0H0nzogEAlT5+G97De0JSKoX9TnIc3IaRSMwXiWaLjFk0+uuvv87mg0gAWZb53iKhRGUs+8x5JExegrw/r8Drxe7wn/YylJUqWv33kGPjNoxEYr5INNEZs6jxGj9+vLXrcBqyLPONT0LIsgyNRgO1Ws18kRAiMqa9l4TE91ch44vDcG1SD9UPr4ZbswZWGZucC7dhJBLzRaLZImNW2Z+Wk5MDAHBzc7PGcERE5OBkrRap6/ci+eP1gEqJgE/fhdeL3XlYIRERUREsbrz+/fdfLF++HD/88AOSk5MBABUrVsTTTz+NcePGoXr16lYrkoiIHEf2T38gYcpi5F2+Bu/hPeE3ZQyUfj72LouIiMihWdR4Xb16FYMHD0Z6ejpat26NOnXqAADi4uKwf/9+HD9+HNu3b0dwcLBViyUiIvvR3klA4vsrkbH7W7g2b4Aa30bDtXGovcsiIiJyChY1Xp9++ikUCgX27t2L0FDTD92///4bI0aMwKeffoqoqCirFElERPYja7RIjd6NpAUbILm5IGDJZHgN6gaJl3YmIiIqMYsar19++QUvvfRSgaYLAEJCQvDiiy9i06ZNpa3NIfGEThJJrVbbuwQq48zNWPbJs7g/eTE0/9yE90vPw2/yaCh9vQRVR86O2zASifki0URnzKLGS6vVFnshDXd3d2i1WouLcnRsvkgE5opEMydj2n/vIXFWFDL2HYPbU+EI/G4dXMMfF1gdOTtuw0gk5otEs0XGLDpOpH79+ti1axfS09MLTMvIyMDu3bvRoEHZvZywLMv2LoHKIFmWodVqmS8SpiQZk/M0SF6+DTdbDUH2qT9QecU0VDsQxaaLHonbMBKJ+SLRbJExi+/jNWbMGHTr1g19+vRB7dq1AQDXrl3D3r17kZKSgpkzZ1qzTofBNzyJpNfroeTluEmg4jKW9f0vSJiyBJprt+Ezqg8qThoJpbenjSskZ8ZtGInEfJFoojNmUePVqlUrrF27FgsWLMDatWtNptWvXx+ffPIJWrZsaZUCiYhILM2tu0icsRyZB36AW6vGCFw/B64N6ti7LCIiojLF4vt4tW7dGvv27cP9+/fx77//AgCqVauGgIAAqxVHRETiyLl5SInageQlW6Dw9kTl1TPh2aczz6UgIiISoMSN16JFixAZGYl69eqZPB4QEMBmi4jIyWR+dxqJU5dCE/8ffF7uB7+JI6DwqmDvsoiIiMqsEl9cY+3atfjnn3+MPycnJ6N+/fqIjY0VUpij4l+CSSQeu06i6W/fw51hU3Fn0LtQ1aiMmt9vRKX3X2fTRVbBbRiJxHyRaKIzZvGhhkD5vdAEmy8SQZIkfqiQMPqcXKSs2I6UpVuhqOiDwOj3UaFXB27PyGq4DSORmC8SzRYZK1XjVV7JsswvK2R1siwbs8V8kTVlfnMKCdOXQXv7Hnxe6Y+Kbw+Dknu4yMq4DSORmC8SzRYZY+NlpvK6l49sQ6vVCr9rOpUfmmu3kTBtKbK+jYV7+ydRZfsCSI9VhYIZI0G4DSORmC8STXTGzGq8bt++jT///BMAjDdPvnHjBry9vQudv2HDhqUsj4iIzKXPykHKsq1IWfE5lAEVEbhxLip0bwcA0Gg0dq6OiIiofJLkEu7CqVevXoHdbkUdcmd4/PLly9ap0kFcuHABsiwjPDycu7nJ6mRZhkajgVqtZr7IIrIsIzPmRyTOWA7t3UT4vj4IFScMhcLDzTidGSNRmC8Sifki0SzJ2IULFwAA4eHhJZq/xHu85s2bV9JZiYjIxvKu3kTClKXIPv4zPDq1RNVdi+BSp6a9yyIiIqL/r8SNV+/evUXW4TT4VxYSifkic+kzs5G8eAtSVu2EqkolVPlsHjy6tikyS8wYicR8kUjMF4kmOmO8uIYF+MYnESRJ4knDVGKyLCPz6++ROHMFdAkpqPjmEPiOfxEKd9cin8OMkUjMF4nEfJFotshYiW+gbAs//PADhgwZgpYtWyIsLAydOnXCvHnzjBfyMDh27Bh69uyJ8PBwdO3aFV9++WWBsfLy8vDxxx+jTZs2aNKkCV566SXExcXZalGIiITJ+/s6/uv3Nu6OmgmXsMdR8+Rn8HtvZLFNFxEREdmXQ+3xSklJQaNGjTB06FD4+vrin3/+wfLly/HPP/9gw4YNAIBff/0V48aNQ9++fTF16lScPn0a06ZNQ4UKFfDss88ax5o7dy5iYmIwefJkBAYGYvXq1RgxYgQOHjwILy+vUtXJ+3iRCLIsQ6vVQqVSMV9UKH1GFpI/3YSU1V9AVaMKqmz7GBW6tC7x85kxEon5IpGYLxLNFhlzqMarV69eJj+3aNECLi4umDFjBu7evYvAwECsWrUKjRo1wpw5cwAALVu2RHx8PJYtW2ZsvO7cuYPdu3dj1qxZ6Nu3L4AHVxvp0KEDduzYgTFjxlhcI+/jRSIxX1QYWZaRsfcoEmdFQZ+aDr+JL8Hn9YFQuJm/h4sZI5GYLxKJ+SLRRGfMoQ41LIyvry+AB/eeycvLw5kzZ0z2bAFAZGQkrl69ilu3bgEATp48Cb1ebzKfr68v2rRpgxMnTtisdiKi0sq9HId/e7+Je6+8D7fmDVDz1FZUfGe4RU0XERER2Y9DNl46nQ65ubn4888/ERUVhY4dO6JGjRq4efMmNBoNgoODTeavU6cOABjP4YqLi4O/vz98fHwKzMfzvIjIGejTM5EwYzludRgJ3X/3UXXnQlTZ9CHUNavYuzQiIiKygEMdamjQoUMH3L17FwDQtm1bfPrppwCA1NRUAIC3t7fJ/IafDdPT0tIKPY/L29vbOE9pFLYbUpKkIndPGo4TLW66qOdyXOd5bWRZNnnM0ZbVGdZhWRhXlmVk7P4WSe+vhD4jC35TRsF37ADARV3ktqekNRnGN/xs72UtD+M6Yk0ix314O2aNcUtbE8d1zJrMHTd/tpyhXmeuydnGtVZN+bdhpRm3OA7ZeK1duxbZ2dm4cuUKVq1ahbFjx2Ljxo32LgvAgxWt0WhMTrpTKBRQqR6sSo1GU+A5Li4uAB7sydPr9SbTDCfw6fV66HQ6k2mGcWVZLnRcwyUvCxtXqVRCqVQaTxR8eBkMz9VqtQWCI2rckiwrUHAdihrXsKySJJm9rCUZFzBvHeZ/o1uyrIZxC6vJXuvQMG5x69Be+S5uHdoy38D/bSOyz/8PiVOXIu/ni3Dv8TR8Z46F22PVICkU0Ol0pd5GGGrWaDRQqVTcRjxiXMOyOso2orTLaotthGHs/NsybiNMl7U024jy/D1ClmXjOuI2wnm3EY78PcKwTFqt1viee9Q24uHvbo/ikI1XvXr1AABNmzZFeHg4evXqhW+//RZ169YFgAKXl09LSwMA46GF3t7eyMjIKDBuWlpagcMPLWF4MQpT3PX/8wf6YQqFAgpF4Ud+5g+7ueM+6rn5PyxtNW5xywoUvw6tPa7hzVKaZbX2a2OoqbysQ3vluzTvOWuvQ11qOpLnr0fqhr1Q16mBKrsWwePpJ6xWL7cRlo/riNsIA0dbh5IkFfr5yG1EyccF+D3iUeNKksRtRAnHdbRtRFHjOvM2wpymC3DQxiu/0NBQqNVq3Lx5Ex07doRarUZcXBzatm1rnMdw3pbh3K/g4GAkJCQgNTXVpNGKi4srcH6YpQpb0Y9a+cVNF/Vcjit2XGvWJMsy9Hq98Y3saMvqDOvQ2caV9Xqk7zyMpA9WQ5+VA/+ZY+Ezpi8kl6I/mErzex/OmLXGNXdaeRrXEWsSuawP58veNXFcx63J3HEL235ZY1xrTLPXczmudWvKnzFr1FQYh7y4Rn7nzp2DRqNBjRo14OLighYtWuCbb74xmScmJgZ16tRBjRo1AAARERFQKBQ4cuSIcZ7U1FScPHkS7dq1K1U9lhzPSVRSD++ep7Ir99z/cLvH67j/xjy4t22OWrHb4Pv6oEKbLmtixkgk5otEYr5INNEZc6g9XuPGjUNYWBhCQ0Ph5uaGv/76C+vXr0doaCg6d+4MAHj11VcxbNgwzJ49G926dcOZM2dw4MABLF682DhOlSpV0LdvXyxYsAAKhQKBgYFYs2YNvLy8MHDgQHstHhERdMlpSJoXjbRN+6EOrY1q+5bBvU1Te5dFREREgjlU49WoUSPExMRg7dq1kGUZ1atXR79+/TBq1CjjceNPPPEEli9fjiVLlmD37t2oVq0a5s6di27dupmMNX36dFSoUAGffvopMjMz0axZM2zcuLHQqx0SEYkm6/VI33YQiR+ugZyrgf+c1+Ez6gVIaofaDBMREZEgksxj50rswoULkGUZ4eHhFh3XSVQcw1V5DFf3obIj54+/kDBpEXLPXoZn/67wn/kqVIH+Nq+DGSORmC8Sifki0SzJ2IULFwAA4eHhJZqff2o1E9/sJFJRV90h56RLTEHih2uRvvUAXBoEo9rXUXBv2ciuNTFjJBLzRSIxXySa6Iyx8bIAmy8SQZIkfqiUEbJOh7TPvkbSR9GATo9KH70J7xG9IBVzWVpbYMZIJOaLRGK+SDRbZIyNlwXMvVkaUUnkv1s68+W8cn79E/cnLULe+b/hNSgSfjPGQhVQ0d5lAWDGSCzmi0Rivkg0W2SMjZeZeEociaTVaou9kR85Lu39ZCR9sBrpn8fAJfxxVI9ZBbcnw+xdVgHMGInEfJFIzBeJJjpjbLyIiEpB1mqRtmk/kuavAyQJlRa8De9hPSHxkBgiIiLKh40XEZGFss+cR8Kkxci7dBVeQ3rAf9rLUPr72rssIiIickBsvIiIzKS9m4jEOauR8cVhuDatj+qHV8OtWQN7l0VEREQOjI2XmXhCJ4nEfDk2WatF6ro9SF6wAVCrELDoXXi92AOSQmHv0kqMGSORmC8Sifki0URnjI2XBfjGJxEkSeJJww4s+9TvSJiyBHl/XYP3iF7wmzIGyore9i7LLMwYicR8kUjMF4lmi4yx8SIiKob2TgISZ69ExpffwvWJhqjxbTRcG4fauywiIiJyMmy8LMD7eJEIsixDq9VCpVIxXw5A1miRGr0bSQs2QHJ3RcDSyfAa2M2pDit8GDNGIjFfJBLzRaLZImNsvMzE+3iRSMyXY8j68TckTF4MzZV4eL/0PPwmj4bS18veZVkFM0YiMV8kEvNFoonOGBsvIqL/T/vvPSTMjELm/mNwa9EIgUdnwzWsrr3LIiIiojKAjRcRlXtyngYpq3YiedFmKCp4oHLUNHj268rDWYiIiMhq2HgRUbmWdfxnJExZAs31f+Ezug8qvjcSSm9Pe5dFREREZQwbLzPxL+AkkkrFt6StaG7dReL05cg8+APcWjVG4Ma5cK0fbO+yhGPGSCTmi0Rivkg00Rljgi3A5otEkCSJ2bIBOTcPKVE7kLxkCxTenqi8ZhY8e3cqF+ueGSORmC8Sifki0WyRMTZeFuDl5EkEWZah1+uhUCiYL0Eyv41F4rRl0MT/B59X+sFv4ktQeHrYuyybYcZIJOaLRGK+SDRbZIyNl5l4KVMSSafTQeHE94lyVJob/yJh+nJkHT4J97bNUOWzj+ASGmTvsuyCGSORmC8Sifki0URnjI0XEZVZ+uxcpKzYjpRlW6Hw80Xgujmo0LM9/1pKRERENsfGi4jKHFmWkfXNKSRMXwbtv/fh++oAVHxrWLk6rJCIiIgcCxsvIipTNHG3kDBtKbK+Ow339k+i6o6FcKlby95lERERUTnHxstMPESJROKx65bTZ+UgZelWJK/YDlVlPwRunIsK3dvxPfsQZoxEYr5IJOaLRBOdMTZeFuAXORJBkiTeo8QCsiwjM+ZHJM5YDu3dRFQcNxi+bw6BwsPN3qU5HGaMRGK+SCTmi0SzRcaYYAvwcvIkQv4rZjJfJZN39SYSJi9B9ve/wKNzS1TbvRjq4Br2LsthMWMkEvNFIjFfJJotMsbGy0y8nDyJpNFooFar7V2Gw9NnZiN50WakrNoJVbUAVNk6Hx5dWvPDuASYMRKJ+SKRmC8STXTG2HgRkdOQZRmZ+48jYVYU9EkpqPjWMPiOGwyFu6u9SyMiIiIqFhsvInIKeX9fR8KUJcg+8Rs8no1ApbnjoX6smr3LIiIiIioRNl5E5ND0GVlIWrgRqWt2QVWjCqpsX4AKz7Syd1lEREREZmHjRUQOSZZlZOw9isRZUdCnpsPv3ZHweW0AFG48rJCIiIicDxsvM0mSxBP4SQhJkuDi4mLvMhxC7uU4JExejJyf/kCF7k/D/4NxUNesYu+ynB4zRiIxXyQS80Wi2SJjbLyIyGHo0jKQvGADUtftgbp2NVT94lN4dHjK3mURERERlRobLwvwPl4kgizL0Ol0UCqV5S5fsiwjY9c3SJy9CvrMbPhNHQPfsf0hufCywdZUnjNG4jFfJBLzRaLZImNsvMzE+3iRSHq9Hkql0t5l2FTuxStImLQIOT9fQIVeHVFpzutQVats77LKrPKYMbId5otEYr5INNEZY+NFRHahS01H0rx1SNu4D+q6NVH1y8XwaPeEvcsiIiIiEoKNFxHZlKzXI33HISR+sBpydi78Z46Fz5i+PKyQiIiIyjQ2XkRkM7nn/of7kxcj99c/4fnCM/Cf/RpUVSrZuywiIiIi4dh4mYkndJJIKlXZfEvqktOQ9NFapG3+Ci71glBt3zK4t2lq77LKpbKaMXIMzBeJxHyRaKIzxgRbgM0XiVAW7xEn6/VI33YAiXPXAhot/D8YD5+RvSGpuemxh7KYMXIczBeJxHyRaLbIGL/9WICXkycRZFmGXq+HQqEoE/nKOXsJCZOXIPf3y/Ds/yz8Z46FKtDf3mWVa2UtY+RYmC8Sifki0WyRMTZeZuLl5EkknU4HhUJh7zJKRZeYgsS5a5C+7SBcGtRBtQNRcG/RyN5l0f9XFjJGjov5IpGYLxJNdMbYeBGRVcg6HdK2fIWkj6IBvYxKH70J7xG9IPGYfCIiIiI2XkRUejm/XMT9yYuRd/5veA3uDr/pr0AVUNHeZRERERE5DIfaX3vo0CG8+uqraNeuHZo0aYJevXph9+7dBQ7v27VrF7p27Yrw8HD07NkTx48fLzBWeno6pk6diqeeegpNmzbFG2+8gXv37tlqUYjKBe39ZNx7Yx5uR74KAKh+aDUqL53MpouIiIjoIQ7VeG3atAnu7u6YPHkyVq1ahXbt2mHGjBmIiooyznPw4EHMmDED3bp1Q3R0NJo0aYJx48bhjz/+MBlrwoQJOHXqFGbPno2FCxfi2rVrGDNmDLRabalq5AmdJJKzHLsua7VIjd6N+JaDkXnoR1T65B3UOLIWbk80tHdp9AjOkjFyTswXicR8kWiiMybJDnS1iKSkJPj5+Zk8NmPGDMTExOCXX36BQqFA165dERYWhk8//dQ4z8CBA+Hl5YXo6GgAwO+//46BAwdi/fr1iIiIAADExcUhMjISixYtQmRkpEX1XbhwAQAQHh5u0fOJyoLs0+eRMHkR8i7FwXvoc/CbOgZKf197l0VERERkU+b2Bg71p4OHmy4AqF+/PjIyMpCVlYX4+Hhcv34d3bp1M5knMjISsbGxyMvLAwCcOHEC3t7eaNOmjXGe4OBg1K9fHydOnBC7EESl4EB/BylAeycBd1/7AP8+9zokFxdU/2YNAj59l02Xk3HkjJHzY75IJOaLRBOdMYe/uMZvv/2GwMBAeHp64rfffgMABAUFmcxTp04daDQaxMfHo06dOoiLi0NQUFCBwwKDg4MRFxdXqnpkWeZ9vEgIWZah0WigVqvtkq/s7GxcunQJeXl5cHFxQVBQEG7fvo06j9VG3vYYJH28AZKLGgGL3oPXi90h8ZAPp2PvjFHZxnyRSMwXiWaLjDl04/Xrr78iJiYGkyZNAgCkpqYCALy9vU3mM/xsmJ6WlgYvL68C4/n4+ODixYulrquwbliSpCK7ZMOLV9x0Uc/luM7z2hia+vw/W2PcktabnZ2NixcvGhuvihUr4vreb+B5+Hfor8TDe3gvVJwyGsqK3ibjONI6LK/jlvS5hozlf+2cbVmdbVxHrEnkuA9vx6wxbmlr4riOWZO54+bPljPU68w1Odu41qop/zasNOMWx2Ebrzt37uCtt95CixYtMGzYMHuXY0Kj0Zh0wgqFAqr/f68ijUZTYH4XFxcAD27KptfrTaapVCpIkgS9Xg+dTmcyzTCuoQN/mFqtLnJcpVIJpVIJWZYLXFBEkiTjc7VabYHgiBq3JMsKFFyHosY1LKskSWYva0nGBcxbh7Ism9Rv7rIaxi2spqLWYXZ2Ns6fP4/ExESEhoYiLS0dekhQp+Ug491laHDiN0hNQlHj22i4NAqBRqOB/qGxi1uHhnqLW4f2yndx69CW+QZst43Iv1wqlYrbiEeMa1hWR9lGlHZZLdlGlGTc/MtqqDf/ZyS3EabL6sjbCGstq4hx8zde3EY47zbC3HVoy22E4d+SJBnfc4/aRuRv0krCIRuvtLQ0jBkzBr6+vli+fLnxCiM+Pj4AHlwqPiAgwGT+/NO9vb1x586dAuOmpqYa5ymN4nZBGl6MwuQP9MMUCkWRV1LJH3Zzx33Ucw1vBFuOW9yyAsWvQ2uPa3gdS7Os1nptCtuIFcVa6zA9PR1//vknkpOTkZWdg+T79/H47/Fo+lsctCoVTnVuguqj+0D2doF3IRe/MSwHYPk6tFe+S/OeE/XaiN5GGDKWfxvGbUTx4zrSNuJhjrgOVSpVgc9IbiNKPi7A7xFFjZv/yzW3ESUb1xG3ESLWobXybfiMzL98j1pWc5ouwAEbr5ycHLzyyitIT0/Hzp07TQ4ZDA4OBvDgCoWGfxt+VqvVqFmzpnG+2NjYAl3otWvXEBISUuoaJUkqdEU/auUXN13Uczmu2HGtXVNhX1as+TsL+x3p6enIy8tD+rFY9PjhL3ilZOF/4TVxvkUw8lzUuPHTKfz++29o0KBBsVcEdZR1WB7HNee5hu1X/sZLRE0c13FrEjnuw/lyhJo4rmPWZMm4JdluOVK9zlqTs41rzZoe3n6VpqbCONTZ8VqtFhMmTEBcXBzWrVuHwMBAk+k1a9ZE7dq1cfjwYZPHY2Ji0KpVK+NuwXbt2iE1NRWxsbHGea5du4ZLly6hXbt2parRkpVMVFLF/cXGmpKSknDu3DnEnv4Z+rupaHPoPDrvO4scNxfsf6EFzrSrj1TXAMhKd7Rp2xYvvPACWrZsaZPaSCxbZYzKJ+aLRGK+SDTRGXOoPV7vv/8+jh8/jsmTJyMjI8PkpsgNGjSAi4sLxo8fj4kTJ6JWrVpo0aIFYmJicP78eWzdutU4b9OmTREREYGpU6di0qRJcHV1xeLFixEaGoouXbqUuk42XySCLXN1+vRpnPvlNzz+61U8/+s15LmocLJzQ1wPrQJIElTQ47GaFeGiVqBJo/BCDzEk58NtF4nEfJFIzBeJZouMOVTjderUKQDA/PnzC0w7evQoatSogR49eiA7OxvR0dFYu3YtgoKCsGLFCjRt2tRk/iVLlmDevHmYOXMmtFotIiIiMH369GKP1Swpc0+kIyoJw8U1lEql8Hw117jg8X1/QPr3Pi6HP4bfn6yNHHc/uMrp8PBwh7u7O55s3hiXLl0SWgfZli0zRuUP80UiMV8kmi0yJsmWXAuxnLpw4QJkWUZ4eDjf9GR1hhOHRd4/QhN/B4kzliPz4Am4tW4Clykjsff8L0hITELDxi1x69ol1KsXCl9fX+N9vOrWrQt3d3ch9ZBt2SJjVH4xXyQS80WiWZKxCxcuAADCw8NLNL9D7fEiIjH0OblIjdqB5KWfQeHjhcprZ8Hz+U5ITk6G4uJvUCkVCKrhh6zUimjatKnx0EIeYkhERERkHWy8iMq4zCM/IWHaMmhv3YHv2P6o+M4IKDw9AADu7u5o2LAh7t+/j0qVKiEsLIx7t4iIiIgEYONFVEZprv+LhOnLkPXNKbi3a46q2+bDJaS2yTzu7u5o1aqV8edq1arZuEoiIiKi8oGNl5l4XDGJVNQN/syhz85FyvJtSFm2DQp/XwSum4MKPdszuwTAOhkjKgrzRSIxXySa6Iyx8bIAv8CSCJIkleoNL8sysr45hYTpy6D99z58XxuIim8Ng6ICDx2kB0qbMaLiMF8kEvNFotkiY2y8LMDLyZMIsiwbs2VuvjRxt5AwdSmyjp6Ge4enUHXnQrjUqSWoUnJWpckY0aMwXyQS80Wi2SJjbLzMxKvvk0hardasu6brs3KQvOQzpER9DlWgP6ps/hAe3dryQ4mKZG7GiMzBfJFIzBeJJjpjbLyInJAsy8g88AMSZ66A7n4yKo4fDN83hkDh4Wbv0oiIiIioEGy8iJxM3pWbSJiyBNnf/wKPZ1qh0p43oQ6qbu+yiIiIiKgYbLyInIQ+IwvJi7YgZfVOqKoFoMrW+ajQtY29yyIiIiKiEmDjZSaeO0MiFZYvWZaRuf84EmZFQZ+UgopvD4Pv64OhcHe1Q4Xk7LgNI5GYLxKJ+SLRRGeMjZcF+MYnESRJKnBCZ97/rj04rPDHs/DoFoFKH4yH+jHe5JgsU1jGiKyF+SKRmC8SzRYZY+NF5ID0GVlI+mQjUtfugrpmVVT5/BNU6NzS3mURERERkYXYeFmA9/EiEWRZhkajQe5X3yNx9kro0zLg995I+L42EJKri73LozJAlmVotVqoVCpuw8jqmC8Sifki0WyRMTZeZuJ9vEiUvEtXcX/yYuSePo8KPZ6G/wfjoa4RaO+yqIzhNoxEYr5IJOaLRBOdMTZeRHamS8tA8scbkLp+D1S1q6HKzoWo0LGFvcsiIiIiIiti40VkJ7IsI+OLb5D4/iroM7PhN2U0PEb1hksFD3uXRkRERERWxsaLyA5yL/yDhMmLkfPzBXg+3xH+778OZdUAaDQae5dGRERERAKw8TITT+ik0tClpCNp3jqkbdoH9eO1UHXPEni0bQ7gwR4wXiqXRGPGSCTmi0Rivkg0Xk7eAbH5InPJej3SPz+ExLmrIefkwX/2q/AZ3ReS+v/egswVicaMkUjMF4nEfJFotsgYGy8L8HLyZI7cc//D/UmLkPvbJXj2fQb+s16DqkqlAvPJsgydTgelUsl8kRDMGInEfJFIzBeJZouMsfEyEy9lSiWlS0pF0kfRSNvyFVzqB6Ha/uVwb92k2Ofo9XoolUrbFEjlEjNGIjFfJBLzRaKJzhgbLyIrk3U6pG87iMS5awCtDv4fjIfPqN6QVHy7EREREZVX/CZIZEU5Zy8hYdJi5P7xF7wGPAu/GWOhCvS3d1lEREREZGdsvIisQJeQjMQP1yJ920G4NKyLagei4N6ikb3LIiIiIiIHwcbLTDyhk/KTdTqkbf4KSfOiAVlGpXkT4D2iFyQLjw/mseskGjNGIjFfJBLzRaKJzhgbLwuw+SIAyPnlIu5PWoS8C//Aa3B3+M94BcpKFS0eT5IkfqiQUMwYicR8kUjMF4lmi4yx8bIALydfvmnvJSFpziqk7zwMl0YhqH5oNdyeaFjqcWVZNmaL+SIRmDESifkikZgvEs0WGWPjZSZeTr78krVapG7Yh+SP1wNKBSotnAjvIT0sPqywMFqtVvhd06l8Y8ZIJOaLRPp/7d17XJR13v/x9wADKgKCmpqHBMtTWtDmKQ+lli1q2a/Vu9osa81Tqav+3DQ8rKc281frKTuRlabdlWalSa5uKZq6u7nZmrWlARraekBhOCgCM9f9hzf8REAY4MvM4Ov5ePh4wDXXfOdzzbz5znyc60C+YJrpjNF4ARVwfu+/lPbMYuV9n6zQR+5RxIzR8o8I83RZAAAA8BE0XsAVFJxI05l5ryh73VYF3dJBzbe+rjrR7T1dFgAAAHwMjRdQCiu/QI431uvsordkC7Kr8eJpCvntQNn8/DxdGgAAAHwQjZebOKCz9ju/e79OT1+s/ENHFTpiiCKeeUL+4aE18tjkC6aRMZhEvmAS+YJppjNG41UJ/OHXTgX/Oa0zf1yh7I8+V1CXTmqxLV5BN7Wtsce32WwcNAyjyBhMIl8wiXzBtJrIGI0XrnpWXr4yXvtA6S+skl9wHTVeHqeQ/7qb3QoBAABQbWi8KoHreNUe5xL3Ke2ZJcpPSlXYyPsVPu138g8L8UgtlmWpoKBAAQEB5AtGkDGYRL5gEvmCaTWRMRovN3Edr9qh4PhJpc16STmbdqhO95vVJH6Ogm683tNlkS8YR8ZgEvmCSeQLppnOGI0XrirWhTxlvPK+0hevll/9errmlVmq/5u7+N8zAAAAGEXjhavGuc//rrS4Jco/+h+FjR6qiD88Lr+QYE+XBQAAgKsAjRdqvfyf/6Mzs5YrJ2GX6vSMUdNVf1Jg+0hPlwUAAICrCI2Xm9glzXe4ci8oY8V/K2PJO/JrEKprXv+j6t/X36tfw4AA/iRhFhmDSeQLJpEvmGY6YyS4Erz5gzsuytm6R2kzlqng2Ak1GPeAwqeMkF/9ep4u64psNhvZglFkDCaRL5hEvmBaTWSMxqsSOJ2898o/8ovSZizVua17VPf2W9Xs3ecVeMN1ni6rQizLksvlkp+fH/mCEWQMJpEvmES+YFpNZIzGy02cytQ7uc5fUMayNcpY/q78GzVQkzfnK3jw7T43OTudTvlx4WYYRMZgEvmCSeQLppnOmFel9+jRo5o9e7aGDBmijh07avDgwaWut27dOt19993q3Lmz7r33Xm3fvr3EOllZWYqLi1PXrl0VExOjiRMn6tSpU6Y3ATXMsizlJOxUaq9HlL5srcLGPaCWu9eo/j13+FzTBQAAgNrLqxqvw4cPKzExUdddd53atGlT6jqbN2/WrFmzFBsbq/j4eEVHR2v8+PH65ptviq03adIk7d69W3PmzNELL7yglJQUjRo1SgUFBTWwJagJeUmp+s+Df9CJETNkv76VWu5cpYYzRssvuK6nSwMAAACK8apdDfv166c777xTkjR9+nQdPHiwxDrLli3ToEGDNGnSJElS9+7ddejQIa1YsULx8fGSpP379+vLL7/UypUr1atXL0lSZGSkBg4cqK1bt2rgwIE1s0EwwpVzXulL3lHGy+8poElDNV31rOrF9uYbLgAAAHgtr/rGq7x9KlNTU3XkyBHFxsYWWz5w4EDt3btXeXl5kqSdO3cqNDRUPXv2LFonKipKHTp00M6dO6tUIx/uPceyLGVv2qHUnsPleOV9hU98WC2/fEfBA/vUmteFfddhGhmDSeQLJpEvmGY6Y171jVd5kpOTJV389upSbdq0UX5+vlJTU9WmTRslJycrMjKyxIfxqKioojGqorZ8yPcleYePKi1uqc7v+Er1BtymRgsmyh7Z3NNlVSubzcY1SmAUGYNJ5AsmkS+YVhMZ86kEOxwOSVJoaGix5YW/F96emZmpkJCQEvcPCwsrdfdFd7lcrhLNl81mK/OMh4XrXul2U/f19XFd2eeU/udVcry2TgHNr1GTNQsVPOC2Eo/hqXqrct/Lbyv8vfA6Et7+2lTXuN5Yk6+NW9H7Xv4344vb6mvjemNNpsZ1uVwlxqqOcatyX8b13prcHffS98iyeFO9vlyTr41bXTVd+nPhN1+VGfdKfKrx8gaWZSk/P7/YH76fn19Rh5yfn1/iPoGBgZIunqLy0jcm6eIVsgvfsJxOZ7HbCsctfMzL2e32Msf19/eXv7+/LMsqcUIRm81WdN+CgoISwTE1bkW2Vbr4HFqWpfMbdyhj3qtyZWQq/P+OUIOnHpLT36/Ec+HOuJez2+2y2Wxub2tFxpXcew4ty5LT6VTduhdPDuLuc1g4bmk1VedrU9q2lvUcFo57pefQU/m+0nNoOt+Xq6k5onC7AgICFBAQ4NNzRE2MW7it3jJHVHVba2KOOH/+fNG6l24rc4RvzBHVta0mxrUsS5ZlKSgoiDnCh+cIb/4cUfiz3W4v+psrb46wLPeu7etTjVdYWJiki6eKb9y4cdHyzMzMYreHhobqxIkTJe7vcDiK1qmKwoCUdVtZLg305fz8/Mrcr/TSsLs7bnn3vdJXqqbGvdK2SpKVdExpcUuU++V+1YvtrYbzxyvwumsvPu4V/nehvHFLq7fwdazKtlbXa1PaJFaWymyrqXGr+hx6Kt9V+Zsz9dqYniMKM3bpHOaLc4Qv5buscQvVtucwICCgxHskc0TFx5X4HFHWuJd+uGaOqNi43jhHePPniML3yEu3r7xtdafpknys8YqKipJ08Vivwp8Lf7fb7WrZsmXRenv37i3RhaakpKht27ZVrsNms5X6RJf35Jf39biJ+/rSuK6sHJ39f2/JEb9e9pbN1Oy9F1SvfzevrddETaV9WKnOx/TGcb2xJl8b1537Fs5flzZeJmpiXO+tyeS4l+fLG2piXO+sqTLjVmTe8qZ6fbUmXxu3Omu6fP6qSk2l8anTw7Rs2VKtW7fWli1bii1PSEhQjx49ir4W7NOnjxwOh/bu3Vu0TkpKir7//nv16dOnRmtG+SzLUtb6rfq5+2+V+fbHinj6d2q5a1WJpgsAAADwVV71jdf58+eVmJgoSTp+/Liys7OLmqyuXbsqIiJCEyZM0NSpU9WqVSt169ZNCQkJOnDggNasWVM0TkxMjHr16qW4uDhNmzZNQUFBWrx4sdq1a6cBAwZUqcbKdLco24Xvk5Q2fbFy9/5LwffcoYbzxsveoomny/IY8gXTyBhMIl8wiXzBNNMZs1mVOSWHIceOHVP//v1LvW316tXq1u3iNyDr1q1TfHy8fvnlF0VGRmrKlCnq27dvsfWzsrL03HPPadu2bSooKFCvXr00c+ZMNWlS+Q/13377rSSpc+fOlR4DFzkdWUp//k053vxI9sjmavTcJNW7o4unywIAAAAqxN3ewKsaL29H41V1lsulrA/+orPzXpErJ1fhf3hMDUYPky2w7IMiAQAAAG/jbm/gVbsa+gp3Tx2Jiy4cOHRxt8KvDqr+/+mvhnOfUkCzxuXf8Spx6am+yRdMIGMwiXzBJPIF02oiYzRebuILQvc5M7J09k/xylz1iew3tNK1Hy1V3V63eLosr0S+YBoZg0nkCyaRL5hmOmM0XjDGcrmU9W6Czix4VdaFfDWcM05hTwyVzU7sAAAAcHXhEzCMyP3mB6VNX6wL//xe9YcNUMPZ4xTQtJGnywIAAAA8gsYL1cp51nFxt8LVGxXYIVLXbnxJdXvc7OmyAAAAAI+i8XITB3SWznI6lbnmU5199nWpwKmGCyYq7Hf3yRZAxNwRwPMFw8gYTCJfMIl8wTTTGSPBlUDzVVzuP79T2rTFuvCvHxXywK8VMXucAq6J8HRZPsdms5EtGEXGYBL5gknkC6bVRMZovCqB08lf5ExL15n5rynr3c0K7HSDmm9+WXW6co2zyrIsSy6XS35+fuQLRpAxmES+YBL5gmk1kTEaLzdxKtP/3a3w7U909rl4SVKj56codMS9svn7e7gy3+d0OuXn5+fpMlCLkTGYRL5gEvmCaaYzRuMFt+T+41udnrZYeQcPK+ThQWo4c4z8G4V7uiwAAADAq9F4oUIKTp3V2XmvKOv9LQqKbq/mf3lNdW7p6OmyAAAAAJ9A44UrsgoK5Fj5kdKfXykF+Kvxi39QyMOD2K0QAAAAcAONl5uupgM6z+/5RmnPLFbev1MU+ui9iogbJf+IME+XVaux7zpMI2MwiXzBJPIF00xnjMarEmp781VwIk1n5r6s7PXbFPSrjmq+9XXViW7v6bJqPZvNxjVKYBQZg0nkCyaRL5hWExkjwZVQW08nb+UXyBG/XmcXvSlbnUA1XjJdIQ/Fysb/MNWIS8+YWRvzBc8jYzCJfMEk8gXTaiJjNF5uqq2nkz//5dc6PX2x8g//rNDH7lPEM0/Iv0GIp8u66uTn58tut3u6DNRiZAwmkS+YRL5gmumM0Xhd5Qp+OaUzf1yh7I+/UJ0undTkr28oqPMNni4LAAAAqFVovK5SVl6+Ml77QOkvrJJfcF1d89IM1f+vu/n6HgAAADCAxusqdG7HV0p7ZonyU44rbOT9Cp/2O/mH1vd0WQAAAECtReN1Fck/dlJnZi1XzqeJqtP9ZjV5Y66Cbrze02UBAAAAtR6Nl5tsNpvP7Y5nXchTxor3lL5ktfxCgnXNK7NU/zd3+dx21HY2m012u53XBcaQMZhEvmAS+YJpNZExGq9aLuevf9OZuKXKT/2PwkYPU8TUx+QXEuzpslAG3lBgGhmDSeQLJpEvmGY6YzReleAL1/HK//k/Spu5TOc++1J1et2ipu/8SYHtIj1dFq7Asiw5nU75+/t7fb7gm8gYTCJfMIl8wbSayBiNl5u8/TpertwLynjpXWUsXSO/8DA1iZ+r4CF9maR8hMvlkr+/v6fLQC1GxmAS+YJJ5Aummc4YjVctkvOX3UqbuUwFx0+pwdgHFD7lUfnVr+fpsgAAAICrHo1XLZCfclxpM5bq3La9qntHFzV7d5ECb7jO02UBAAAA+F80Xj7MdS5XGcvWKOOl/5Z/owZq8uZ8BQ++nd0KAQAAAC9D4+Umb2hqLMvSuc92KW3mchWcPKMGTz2k8N8Pl19wXU+Xhipi33WYRsZgEvmCSeQLppnOGI1XJXiy+cpL+llpcct0/ou/q17/7mq27s8KbNPSY/Wg+thsNt5UYBQZg0nkCyaRL5hWExmj8aoET5xO3pVzXumLVyvjlfcV0LSRmq7+k+r9updXfAOH6mFZVlG2eF1hAhmDSeQLJpEvmFYTGaPxclNNn07esizlbNqhM7NfkjMtQ+ETH1aDicPlVzeoRutAzSgoKJDdbvd0GajFyBhMIl8wiXzBNNMZo/HyYnmHjigtbqnOJ+5Tvbt7qtH8CbJHNvd0WQAAAADcROPlhVzZ55T+4tvKePUDBbRooqZrn1fwgNs8XRYAAACASqLx8iKWZSn74891ZvYKuTIyFT71MTV46iH51WG3QgAAAMCX0Xi5ydTBdnk/pOj0M0uU++XXCh7URw3njZe9VTMjjwXv5efn5+kSUMuRMZhEvmAS+YJppjNG41UJ1dl8ubJydHbRm3LEfyj7dc3U7P0XVK9ft2obH77DZrMpIIA/SZhDxmAS+YJJ5Aum1UTGSLCHWJal7PVbdWbOy3Jln1PE9JFqMO4B2YICPV0aAAAAgGpG4+WmS8/xX1kXDv6ktOmLlfv3Awq+546LuxW2aFKNVcIXWZal/Px82e12rlECI8gYTCJfMIl8wbSayBiNVw1yOrKUvnClHG9+JHublmq2frHq3X6rp8sCAAAAYBiNVw2wXC5lvb9FZ+e/KldOriJmjVGD0cNkC+QigAAAAMDVgMbLsAsHDun09MW68NVB1b//TjWc86QCmjX2dFkAAAAAahCNlyHO9Eydfe4NZa76RPa21+naj5epbs8YT5cFAAAAwANovNxU3sF2lsulrLWbdebZ12RdyFfDuU8qbORvZLPzVKN8dju7n8IsMgaTyBdMIl8wzXTGanU3kJSUpAULFmj//v0KDg7WkCFDNGnSJAUGVu2U7WU1X7nf/KC0aX/Wha//rfrDBqjh7HEKaNqoSo+FqwdnaYJpZAwmkS+YRL5gWk1krNY2Xg6HQyNGjFDr1q21fPlynTx5UgsXLlRubq5mz55dpbEvP52880yGzjz7urLWfKrAjlG6duNLqtvj5qpuAq4ylmXJ6XTK39+fNxgYQcZgEvmCSeQLptVExmpt4/Xee+8pJydHL730kho0aCBJcjqdmjt3rsaMGaMmTSp33SzLsv7/z06nMt/ZpLN/ipecLjV6dqJCH79PNq6sjkpyuVzy9/f3dBmoxcgYTCJfMIl8wTTTGfMzNrKH7dy5Uz169ChquiQpNjZWLpdLu3fvrvL4ufu+07EBo5X2hxcVfHdPtdy7VmGjhtJ0AQAAACih1jZeycnJioqKKrYsNDRUjRs3VnJycuUHzsjS6UkLdTx2rGRZap7wiq5ZHqeAayKqWDEAAACA2qrWfj2TmZmp0NDQEsvDwsLkcDgqNWZ+fr5CRsxVps2m/N8/qHODeynD35K+/baq5QKSSh4/CFQ3MgaTyBdMIl8wzd2M5eXlubV+rW28TLDZbMr6cCGnM4UxvKHANDIGk8gXTCJfMM3djNlsNhov6eJuhVlZWSWWOxwOhYWFVWrMmBgugAwAAADAfbX2GK+oqKgSx3JlZWXp9OnTJY79AgAAAACTam3j1adPH+3Zs0eZmZlFy7Zs2SI/Pz/17NnTg5UBAAAAuNrYrEsvTFWLOBwODRo0SJGRkRozZkzRBZTvueeeKl9AGQAAAADcUWsbL0lKSkrS/PnztX//fgUHB2vIkCGaPHmyAgMDPV0aAAAAgKtIrW68AAAAAMAb1NpjvAAAAADAW9B4AQAAAIBhNF4AAAAAYBiNFwAAAAAYRuMFAAAAAIbReAEAAACAYTReAAAAAGAYjVcFJCUl6fHHH1d0dLR69uypRYsWKS8vz9NlwQdt2LBB7dq1K/HvhRdeKLbeunXrdPfdd6tz58669957tX37dg9VDG929OhRzZ49W0OGDFHHjh01ePDgUterSJ6ysrIUFxenrl27KiYmRhMnTtSpU6dMbwK8WEXy9cgjj5Q6pyUlJRVbj3zhcp999pnGjRunPn36KDo6WkOGDNH69et1+eVlmb9QGRXJlyfmr4AqbdVVwOFwaMSIEWrdurWWL1+ukydPauHChcrNzdXs2bM9XR581BtvvKGQkJCi35s0aVL08+bNmzVr1iyNHTtW3bt3V0JCgsaPH6+1a9cqOjraA9XCWx0+fFiJiYm6+eab5XK5SnxgkSqep0mTJumnn37SnDlzFBQUpCVLlmjUqFH68MMPFRDAW8XVqCL5kqRbbrlF06ZNK7asRYsWxX4nX7jc22+/rebNm2v69OkKDw/Xnj17NGvWLJ04cULjx4+XxPyFyqtIviQPzF8WrujVV1+1oqOjrfT09KJl7733ntWhQwfrxIkTnisMPunDDz+02rZta505c6bMdQYMGGBNmTKl2LIHHnjAeuKJJ0yXBx/jdDqLfp42bZo1aNCgEutUJE9ff/211bZtW2vXrl1Fy5KSkqx27dpZmzdvNlA5fEFF8jV8+HBr9OjRVxyHfKE0pb0Pzpw507rllluKssf8hcqqSL48MX+xq2E5du7cqR49eqhBgwZFy2JjY+VyubR7927PFYZaKTU1VUeOHFFsbGyx5QMHDtTevXvZxRXF+PldeQqvaJ527typ0NBQ9ezZs2idqKgodejQQTt37qz+wuETystXRZEvlCYiIqLEsg4dOig7O1vnzp1j/kKVlJeviqrufNF4lSM5OVlRUVHFloWGhqpx48ZKTk72UFXwdYMHD1aHDh3Uv39/vfbaa3I6nZJUlKnIyMhi67dp00b5+flKTU2t8Vrhuyqap+TkZEVGRspmsxVbLyoqinkO5frHP/6h6Ohode7cWcOHD9dXX31V7HbyhYr65z//qSZNmqh+/frMX6h2l+arUE3PX+z4Wo7MzEyFhoaWWB4WFiaHw+GBiuDLGjdurAkTJujmm2+WzWbTF198oSVLlujkyZOaPXt2UaYuz1zh72QO7qhonjIzM4sdc1goLCxMBw8eNFwlfFmXLl00ZMgQtW7dWqdOndLKlSv1+OOP65133lFMTIwk8oWK2bdvnxISEoqOt2H+QnW6PF+SZ+YvGi+gBvXu3Vu9e/cu+r1Xr14KCgrSqlWrNHbsWA9WBgDumzhxYrHf77jjDg0ePFgvv/yy4uPjPVQVfM2JEyc0efJkdevWTY8++qiny0EtU1a+PDF/sathOUJDQ5WVlVViucPhUFhYmAcqQm0TGxsrp9Opf//730WZujxzmZmZkkTm4JaK5ik0NFTZ2dkl7s88B3fVq1dPt99+u7777ruiZeQLV5KZmalRo0apQYMGWr58edGxhcxfqA5l5as0NTF/0XiVo7R9OLOysnT69OkSx34BVVWYqcszl5ycLLvdrpYtW3qiLPioiuYpKipKKSkpJU4XnpKSwjyHKiNfKEtubq7GjBmjrKysEpdZYf5CVV0pXxVV3fmi8SpHnz59tGfPnqL/YZGkLVu2yM/Pr9gZToDKSkhIkL+/vzp27KiWLVuqdevW2rJlS4l1evToocDAQA9VCV9U0Tz16dNHDodDe/fuLVonJSVF33//vfr06VOjNcO3nTt3Tjt27FDnzp2LlpEvlKagoECTJk1ScnKy3njjjWLXs5SYv1A15eWrNDUxf3GMVzkefPBBvfPOO3rqqac0ZswYnTx5UosWLdKDDz5YoRcRuNTIkSPVrVs3tWvXTpL0+eef64MPPtCjjz6qxo0bS5ImTJigqVOnqlWrVurWrZsSEhJ04MABrVmzxpOlwwudP39eiYmJkqTjx48rOzu76ENK165dFRERUaE8xcTEqFevXoqLi9O0adMUFBSkxYsXq127dhowYIBHtg2eV16+Cj/Q3HXXXWrevLlOnTqlt956S6dPn9bSpUuLxiFfKM3cuXO1fft2TZ8+XdnZ2frmm2+KbuvYsaMCAwOZv1Bp5eXrwIEDHpm/bNbl352hhKSkJM2fP1/79+9XcHCwhgwZosmTJ/PtA9y2YMEC7dq1SydOnJDL5VLr1q01bNgwPfLII8VOVbpu3TrFx8frl19+UWRkpKZMmaK+fft6sHJ4o2PHjql///6l3rZ69Wp169ZNUsXylJWVpeeee07btm1TQUGBevXqpZkzZ/IfTFex8vLVtGlTzZs3Tz/++KMyMjJUt25dxcTEaPz48brpppuKrU++cLl+/frp+PHjpd72+eefq0WLFpKYv1A55eXL6XR6ZP6i8QIAAAAAwzjGCwAAAAAMo/ECAAAAAMNovAAAAADAMBovAAAAADCMxgsAAAAADKPxAgAAAADDaLwAAAAAwDAaLwAASpGTk6MePXpo48aNni6lSHp6uqKjo5WYmOjpUgAAbqLxAgD4nLVr16pdu3YaNmyYscdYvXq1goODNWjQIGOP4a7w8HANHTpUS5cu9XQpAAA30XgBAHzOpk2bZLfbdeDAAR09erTax8/Pz9fq1as1bNgw+fv7V/v4VfHQQw/pu+++0969ez1dCgDADTReAACfkpqaqv3792vcuHGy2+3atGlTtT/Gjh07dPbsWcXGxlb72FXVpk0btW3bVh999JGnSwEAuIHGCwDgUzZt2iR/f3898MADuu2220ptvJYtW6b27duX+FZo1qxZ6tSpk3744YcrPsZf//pXNW/eXK1atSq2fPr06YqJidEvv/yiMWPGKCYmRr1799batWslST/++KMeffRRRUdHq2/fviVq27Bhg9q1a6d9+/ZpwYIF6t69u2699VbNnj1beXl5yszM1NNPP60uXbqoS5cuWrRokSzLKlHfbbfdpu3bt5d6GwDAO9F4AQB8yqZNm3TrrbeqUaNGio2N1ZEjR3TgwIFi64wbN04dOnTQjBkzlJ2dLUnatWuXPvjgAz355JNq3779FR9j//79uvHGG0u9zel0atSoUWratKmmTp2q5s2ba968edqwYYOeeOIJderUSVOnTlVwcLCmTZum1NTUEmMsWLBAR44c0YQJE9SvXz+9//77Wrp0qcaOHSun06nJkyfrV7/6lVauXKlPPvmkxP1vvPFGZWZm6vDhwxV92gAAHkbjBQDwGQcPHlRycrIGDhwoSbrzzjtL3d3Qbrfr+eef16lTp7Rw4UJlZmZqxowZ6tSpk0aPHn3FxygoKNDPP/+sFi1alHr7hQsXdO+992ru3Ll6+OGH9frrr6tOnTqKi4vTM888o6efflrDhw/XsmXL5HQ69fHHH5cYo2HDhoqPj9fDDz+sRYsWKSYmRitXrtQNN9ygF198Ub/97W+1YsUKNW3aVB9++GGJ+7ds2VKS9NNPP1XkaQMAeAEaLwCAz9i0aZMCAgI0YMAASVJISIh69+6thIQEOZ3OYuu2bdtWEydO1Lp16zRy5Eilp6fr+eefV0BAwBUfw+FwyLIshYaGlrnOpWdTDA0NVWRkpOrWrVvsmLCoqCiFhoaW+o3X0KFDZbPZin6/6aabZFmWhg4dWrTM399fnTp1KvX+hbWlp6dfcVsAAN6DxgsA4BOcTqc2b96s7t27KyIiomj5wIEDlZaWVupZ/kaOHKn27dvrwIEDGj9+vK6//voKP15Zx08FBQUVe3zpYgPYtGnTYs1U4fLMzMwSY1x77bUl1pOkZs2alVjucDjKrPHyxwMAeC8aLwCAT/jb3/6m06dPlzjTYL9+/VSnTp1ST7KRmppadLr5Q4cOVehxwsLCZLPZSm2YJJV5evmylpfWwPn5lf72W9byyxU2Y+Hh4RVaHwDgeTReAACfUHjtrrvuuqvY8uDgYN1+++3atm2bcnNzi5a7XC5Nnz5d9evX19ixY/Xpp59q69at5T5OQECAWrVqpWPHjlX7NlSXwtratGnj4UoAABVF4wUA8Hq5ubnaunWrbrvtNoWFhZW4/de//rVycnL0xRdfFC176623tH//fs2bN0+///3vFRMTozlz5ujs2bPlPl50dLQOHjxYrdtQnb777juFhITohhtu8HQpAIAKuvIRxgAAeIEvvvhCOTk5kqTXX3+9xO3nz5+XJG3cuFEDBw5UUlKSli5dqvvvv1/9+vWTJC1cuFD33Xef5s6dq6VLl17x8fr3769PPvlEKSkpioyMrOatqbo9e/aob9++HOMFAD6ExgsA4PU2btwoSUpMTFRiYmKZ63355ZdKT0/XtGnTFB4erri4uKLbWrdurSlTpujZZ59VQkJC0SnpS9O3b1+Fh4frs88+05NPPll9G1INkpKSdOjQoWLbBgDwfjaLy94DAFDCihUrtGHDBm3durXME2d4wrPPPqt9+/Zpw4YNfOMFAD6EY7wAACjFY489pnPnzmnz5s2eLqVIenq61q9fr0mTJtF0AYCP4RsvAAAAADCMb7wAAAAAwDAaLwAAAAAwjMYLAAAAAAyj8QIAAAAAw2i8AAAAAMAwGi8AAAAAMIzGCwAAAAAMo/ECAAAAAMNovAAAAADAMBovAAAAADCMxgsAAAAADPsfWGHjzZoHG6cAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 7.89493\n", + "GdL = 8\n", + "Chi² rid = 0.98687\n", + "P(0, chi²)= 0.55620\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.420110\n", + "1 1.597434\n", + "2 0.580057\n", + "3 0.002382\n", + "4 0.351718\n", + "5 0.007741\n", + "6 0.687794\n", + "7 0.295535\n", + "8 2.940543\n", + "9 1.011619\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "9f26f65e", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "id": "6a910226", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 3.2196 +- 0.0063\n", + "BC = 0.2465 +- 0.8111\n", + "cov_ABC = -0.004592\n", + "P(0, chi²)= 0.5298\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 152, + "id": "b49ec5a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 153, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 7.63303\n", + "GdL = 8\n", + "Chi² rid = 0.95413\n", + "P(0, chi²)= 0.52989\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.633484\n", + "1 1.991195\n", + "2 0.770664\n", + "3 0.002415\n", + "4 0.613056\n", + "5 0.057088\n", + "6 0.485976\n", + "7 0.110084\n", + "8 2.315219\n", + "9 0.653852\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 3.2197184 ± 0.0063280\n", + "BY = 0.2357100 ± 0.8110331\n", + "cov_ABY = -0.0045912041981810425\n", + "chi² = 7.63281\n", + "chi² rid = 0.95410\n", + "P(0, chi²)= 0.52987\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.22308 ± 0.00202\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", + "P(0, chi²)= 0.55620\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 3.21962 ± 0.00633\n", + "Bc = 0.24654 ± 0.81108\n", + "P(0, chi²)= 0.52989\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 3.21972 ± 0.00633\n", + "By = 0.23571 ± 0.81103\n", + "P(0, chi²)= 0.52987\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.001000\n", + "0 0.673181\n", + "1 0.917483\n", + "2 1.155540\n", + "3 1.390456\n", + "4 1.627202\n", + "Name: w, dtype: float64\n", + "0 0.001668\n", + "1 0.001921\n", + "2 0.002167\n", + "3 0.002394\n", + "4 0.002637\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Meq = df.m + ( m_mol * 0.438 )\n", + "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", + "\n", + "T2 = ( 2 * np.pi / df.w )**2\n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", + "res_b = 0.01 / np.sqrt(6) # riso bilancia\n", + "res_T = 0.001 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = 2 * T * res_T\n", + "\n", + "res_uAd = np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2)\n", + "\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "# print(f\"res_T2 = {res_T2:.6f}\")\n", + "# print(f\"res_b = {res_b:.6f}\")\n", + "# print(f\"res_uAd = {res_uAd:.6f}\")\n", + "\n", + "uT2 = np.sqrt(uT2**2 + res_T2**2)\n", + "uMeq = np.sqrt(uMeq**2 + res_b**2)\n", + "\n", + "\n", + "print(T2)\n", + "print(uT2)" + ] + }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3.284586\n", + "1 3.271857\n", + "2 3.270507\n", + "3 3.275588\n", + "4 3.284972\n", + "dtype: float64\n", + "0 0.008148\n", + "1 0.006856\n", + "2 0.006137\n", + "3 0.005642\n", + "4 0.005325\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.277534061953767\n", + "sigmaC: 0.0027781383643383675\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "90d191d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 7.624e+04\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.05e-07\n", + "Time: 09:36:11 Log-Likelihood: 23.705\n", + "No. Observations: 5 AIC: -43.41\n", + "Df Residuals: 3 BIC: -44.19\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0025 0.004 0.573 0.607 -0.011 0.016\n", + "x 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 1.430\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.670\n", + "Skew: -0.251 Prob(JB): 0.716\n", + "Kurtosis: 1.279 Cond. No. 355.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Adols = 0.01202 ± 0.00004\n", + "Bdols = 0.00249 ± 0.00434\n", + "R² = 0.99996\n", + "Kdols = 3.28476 ± 0.01190\n", + "KBdols = 15.87245 ± 27.70024\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "a0ba5c8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", + "\n", + "plt.plot(\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 5.15565\n", + "GdL = 3\n", + "Chi² rid = 1.71855\n", + "P(0, chi²)= 0.83925\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 2.154276\n", + "1 0.337895\n", + "2 1.358887\n", + "3 0.340009\n", + "4 0.964582\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "id": "698e3c48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AdC = 0.01204 ± 0.00003\n", + "BdC = 0.00060 ± 0.00308\n", + "cov_ABdC = -0.000000\n", + "P(0,chi²)= 0.81144\n", + "KdC = 3.27929 ± 0.00924\n", + "KBdC = 65.55634 ± 335.64841\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", + "print(\"Ax + B : \")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "id": "a0ab8534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "12bb0479", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 4.78098\n", + "GdL = 3\n", + "Chi² rid = 1.59366\n", + "P(0, chi²)= 0.81144\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 1.024112\n", + "1 0.589929\n", + "2 1.320412\n", + "3 0.162804\n", + "4 1.683719\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "385db415", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AdY = 0.0120387 ± 0.0000339\n", + "BdY = 0.0006022 ± 0.0030833\n", + "cov_ABdY = -9.968105610528536e-08\n", + "chi² = 4.78098\n", + "chi² rid = 1.59366\n", + "P(0, chi²)= 0.81144\n", + "KdY = 3.27929 ± 0.00924\n", + "KBdY = 65.56142 ± 335.70050\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", + "\n", + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.27753 ± 0.00278\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.0120187 ± 0.00004\n", + "Bdols = 0.0024872 ± 0.00434\n", + "P(0,chi²)= 0.8392518\n", + "Kdols = 3.2847627 ± 0.01190\n", + "KBdols = 15.8724517 ± 27.70024\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.0120387 ± 0.00003\n", + "BdC = 0.0006022 ± 0.00308\n", + "P(0,chi²)= 0.8114442\n", + "KdC = 3.2792872 ± 0.00924\n", + "KBdC = 65.55634 ± 335.64841\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.01204 ± 0.00003\n", + "Bdy = 0.00060 ± 0.00308\n", + "P(0,chi²)= 0.81144\n", + "KdY = 3.27929 ± 0.00924\n", + "KBdY = 65.56142 ± 335.70050\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.7f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.7f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.7f}\")\n", + "print(f\"Kdols = {Kdols:.7f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.7f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.7f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.7f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.7f}\")\n", + "print(f\"KdC = {KdC:.7f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.616814\n", + "1 0.834482\n", + "2 1.043973\n", + "3 1.250483\n", + "4 1.502463\n", + "Name: t, dtype: float64\n", + "0 0.010446\n", + "1 0.007193\n", + "2 0.011988\n", + "3 0.020931\n", + "4 0.047373\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 171, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3584.745203\n", + "1 3597.288427\n", + "2 3620.020017\n", + "3 3642.240060\n", + "4 3557.699582\n", + "dtype: float64\n", + "0 60.711968\n", + "1 31.008503\n", + "2 41.570688\n", + "3 60.963865\n", + "4 112.174630\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 172, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): 3.60564201903545\n", + "sigmaC (t): 0.021135882837478397\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 173, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 174, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 0.999\n", + "Model: OLS Adj. R-squared: 0.998\n", + "Method: Least Squares F-statistic: 2631.\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.63e-05\n", + "Time: 09:36:12 Log-Likelihood: 15.713\n", + "No. Observations: 5 AIC: -27.43\n", + "Df Residuals: 3 BIC: -28.21\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const -0.0071 0.021 -0.332 0.761 -0.075 0.061\n", + "x 0.0110 0.000 51.298 0.000 0.010 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 2.074\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.262\n", + "Skew: -0.213 Prob(JB): 0.877\n", + "Kurtosis: 1.963 Cond. No. 355.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = -0.00713 ± 0.02147\n", + "R² = 0.99886\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = -5.53371 ± 16.64994\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 175, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1oAAAIsCAYAAADrrtj2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAoeBJREFUeJzs3Xd4FOXaBvB7dje9J0AIAUXggAqhKSBFVBQVGypdxSiIiNiwIh1BRUQ8JnQEKQIKiKgoKOoRFBQbIqBHadINZNP7lvf7w29zUndTdnf2Se7fdZ3rXO7svPvM3DPDPpmdGU0ppUBERERERERuY9C7ACIiIiIiorqGjRYREREREZGbsdEiIiIiIiJyMzZaREREREREbsZGi4iIiIiIyM3YaBEREREREbkZGy0iIiIiIiI3Y6NFRERERETkZmy0iIiIiIiI3IyNFhERec3w4cMxfPjw4v8+deoU2rRpg02bNulYFRERkfux0SIi0sGmTZvQpk0b7N+/X+9SRDh16hRmzpyJG264AR06dEC/fv2wbt26Uu/5888/8fzzz+O6665Dx44d0b9/f3z22Wc6VUxVsWPHDiQnJ+tdBhGRR5j0LoCIiOqv+Ph4/PrrrzCZnP9zNG/ePPzyyy/o378/YmJi8Omnn2LatGkICAjAnXfeCQCYMWMG8vLyMHToUAQHB+O9997DY489hhUrVuCKK67wxuJQNe3YsQNr1qzBo48+qncpRERux0aLiIh0o2kaAgICXL7v7rvvxosvvgij0QgAGDBgAK677jp89NFHxY3W008/jQ4dOhTPc9ttt6F79+7YsmWLqEYrLy8PwcHBepfhc6xWK+x2O/z9/fUuhYioSvjTQSIiH5aSkoLnn38ePXr0QLt27XDzzTdj48aN5d53+vRpPPTQQ+jYsSO6d++Ol156CV9//TXatGmDPXv2lHrvmjVrcO2116J9+/YYOHAgfvzxx3LXTgFAUVERkpKS0LdvX7Rr1w5XXXUVZs+ejaKioirV/u677+K6664r9TllVfUarYSEhOImCwBMJhNMJhMsFkvxayWbLADw9/eHwWAo9R5vS0lJwYQJE9CrVy+0a9cOffr0wdSpU4vXoeMnpN9//z2mTZuG7t2746qrriqef82aNbj55pvRrl079OrVC9OnT0dWVlapzxg+fDhuueUWHD58GMOHD0eHDh1w5ZVXYunSpeXqMZvNmDBhAnr06IGEhATcdttteP/990u9x5HJsmXLireVDh06YMSIETh79iyUUpg/fz569+6N9u3bY8yYMcjIyCj3WTt27MBdd92Fjh07olOnTnjwwQdx6NCh4unjx4/HmjVrAABt2rQp/l/ZGlasWIHrrrsOCQkJOHLkCADg22+/LR778ssvx5gxY4qnERH5Cp7RIiLyUampqRg8eDA0TcPdd9+N6Oho7Ny5ExMnTkROTg7uu+8+AP+cAUlMTMT58+dx7733okGDBtiyZUu5BgsA1q5dixdeeAGXX3457rvvPpw+fRpjx45FeHg4GjduXPw+u92OMWPG4KeffsLgwYPRsmVL/Pnnn1i5ciX++usvLFiwwGntGzZswJQpU9CpUyckJibi5MmTGDNmDCIiIhAXF1frdbN69WqcPHkSY8eOrfQ9c+fORWFhYfEZL29LSUnBwIEDkZ2djcGDB6NFixZISUnBp59+ioKCglJnZqZPn47o6GiMHTsWeXl5AIDk5GTMmzcPPXr0wLBhw3Ds2DGsW7cO+/fvx7p16+Dn51c8f2ZmJh544AH07dsX/fr1w6effoo5c+agdevWxY1bQUEBhg8fjhMnTuDuu+9G06ZNsW3bNowfPx5ZWVlITEwsVf9HH30Ei8WC4cOHIyMjA2+++SaeeOIJXHHFFdizZw9GjRqF48eP4+2338Yrr7yCl19+uXjezZs3Y/z48ejVqxeefvpp5OfnY926dbjrrrvw/vvvo2nTphgyZAjOnTuHXbt2Yfbs2RWuw02bNqGwsBCDBw+Gv78/IiIisHv3bowaNQpNmzbFI488goKCArz99tsYNmwYNm3ahKZNm7otQyKiWlFEROR17733nmrdurX69ddfK33PhAkTVM+ePVVaWlqp18eNG6cuu+wylZ+fr5RSavny5ap169Zq+/btxe8pKChQN954o2rdurX67rvvlFJKFRYWqq5du6oBAwYoi8VS/N5Nmzap1q1bq3vuuaf4tc2bN6uLL75Y/fDDD6U+e926dap169bqp59+qrTuoqIi1b17d9W/f39VWFhY/Pq7775b7nNOnjypWrdurd57771Kxyvrgw8+UG3atFFTpkyp9D2LFi1SrVu3VosXL67yuO727LPPqosvvrjCjO12u1Lqf9vBsGHDlNVqLZ5uNptV27Zt1YgRI5TNZit+/e2331atW7dWGzduLH7tnnvuUa1bt1bvv/9+8WuFhYWqZ8+e6tFHHy1+bcWKFap169bqgw8+KH6tqKhIDRkyRHXs2FFlZ2crpf6XyRVXXKGysrKK3/vaa6+p1q1bq9tuu63U9vPkk0+qtm3bFmedk5OjLr/8cjVp0qRSy3z+/Hl12WWXlXp9+vTpqnXr1uXWj6OGzp07K7PZXGpa//79Vffu3VV6enrxa7///ru6+OKL1bPPPltuLCIivfCng0REPkgphc8++wx9+vSBUgppaWnF/+vVqxeys7Nx8OBBAMDXX3+N2NhYXHvttcXzBwQEYPDgwaXGPHDgADIyMjB48OBSN5+49dZbERERUeq927ZtQ8uWLdGiRYtSn+241qmis2UlP8dsNmPo0KGlztrccccdCAsLq/lKAXDkyBFMmDAB1157LaZOnVrhe3bv3o25c+di+PDhePDBB2v1eTVlt9vx+eef45prrkFCQkK56ZqmlfrvwYMHl/pp5O7du2GxWHDvvffCYPjfP9WDBg1CaGgoduzYUWr+4OBg9O/fv/i//f39kZCQgJMnTxa/tnPnTjRs2BC33HJL8Wt+fn4YPnw48vLy8MMPP5Qa88YbbyyVV/v27QH8c+1bye2nffv2sFgsSElJKa49KysLN998c6ltx2AwoEOHDk63nbKuv/56REdHF//3uXPn8Pvvv+OOO+5AZGRk8esXX3wxevToUW69EBHpiT8dJCLyQWlpacjKysK7776Ld999t9L3AP9cn3XBBReU+/J+wQUXlPrvM2fOVPi6yWRCfHx8qdeOHz+OI0eOoHv37hV+ttlsrrR2x+dceOGFpV738/NDs2bNKp2vKj755BNYLBZMnTq1VANS0ocffoiQkBA8++yzLsez2WzF67G6jEZjqSagpLS0NOTk5OBf//pXlcYq+3M3xzps0aJFqdf9/f3RrFkznD59utTrjRs3Lpd/REQE/vjjj+L/Pn36NC688MJy661ly5alPtOh7E88HU1XZa9nZmaiWbNm+OuvvwCg3E8RHUJDQyt8vSKVrZeLLrqo3HtbtmyJb775hjcTISKfwUaLiMgH2e12AP+cPbjjjjsqfI/jxgGe+vzWrVvj+eefr3B6yeu5vMlx04VGjRo5fU9kZGSV7k539uzZUmcCqyM+Ph5ffvlljeYtqyp3XnSm5Nkwd6lszMoaXKVUqf+fPXs2GjZsWOVxKxIYGFjl9xIR+Ro2WkREPig6OhohISGw2+3o0aOH0/fGx8fj8OHDUEqVOqtx4sSJUu9r0qRJ8eslb3dutVpx+vTpUo3bBRdcgP/+97/o3r17uTMlrjg+5/jx46XOiFksFpw6dQoXX3xxtcYr6fLLLy/+Il+Zq666CpdeemmVxmvYsCHeeuutGtXirDmKjo5GaGhoqbvsVYdjHR49erTUWcCioiKcOnXK5TZRkfj4ePzxxx+w2+2lmqWjR4+W+szactQbExPjss6ablvHjh0rN+3o0aOIiori2Swi8hm8RouIyAcZjUbccMMN+PTTT/Hnn3+Wm17y5269evVCSkoKvvjii+LXCgsLsX79+lLztGvXDpGRkVi/fj2sVmvx6x999BEyMzNLvbdfv35ISUkpNwbwz93rHHfGq0i7du0QHR2Nd955p9St4N9///1ytyavrssuuwx333230/dcddVVuP3226s0XkBAAHr06FGj/1122WWVjmswGHDdddfhP//5D/bv319uuqtmsUePHvDz88Pq1atLvXfjxo3Izs4udQv4qurduzfOnz+PTz75pPg1q9WK1atXIzg4GF26dKn2mBW58sorERoaisWLF1d4a/2S225QUBAAVHm7aNSoES655BJs3ry51Dx//vkndu3aVaP1QkTkKTyjRUSko/feew9ff/11udfvvfdePPXUU9izZw8GDx6MQYMGoVWrVsjMzMTBgwfx7bff4vvvvwcADBkyBG+//Taeeuop3HvvvWjYsCE++uij4jMujrMG/v7+ePTRRzFjxgwkJiaiX79+OH36NDZt2lTuuq3+/ftj69atmDp1Kvbs2YPOnTvDZrPh6NGj2LZtG958880Kb/IA/HMt1hNPPIEpU6YgMTERN910E06dOoVNmzbV+hqtuXPn4v333y917VFZzz33HE6fPu22n/XV1JNPPoldu3Zh+PDhxbfIP3/+PLZt24a1a9ciPDy80nmjo6MxevRozJs3Dw888AD69OmDY8eOYe3atcXPv6quIUOG4N1338X48eNx8OBBxMfH49NPP8XPP/+MCRMmVOvaKWdCQ0Mxbdo0PPvss7jzzjtx0003ITo6GmfOnMGOHTvQuXNnTJkyBQDQtm1bAMDMmTPRq1cvGI1G3HzzzU7Hf/bZZzFq1CgMGTIEAwcOLL69e1hYGB555BG3LAMRkTuw0SIi0tG6desqfP3OO+9E48aNsWHDBsyfPx/bt2/HunXrEBkZiVatWuHpp58ufm9ISAhWrlyJmTNnYtWqVQgODsbtt9+OTp064dFHHy31E7d77rkHSim89dZbeOWVV3DxxRdj4cKFmDlzZqn3GQwGzJ8/HytWrMAHH3yA7du3IygoCE2bNsXw4cMrvBlBSUOGDIHNZsOyZcswe/ZstG7dGgsXLsQbb7xRyzUmR2xsLNavX4833ngDH330EXJychAbG4vevXtX6dqjRx99FNHR0Xj77bfx8ssvIyIiAoMHD8aTTz5Z6hlaVRUYGIjVq1djzpw5eP/995GTk4OLLroIL7/8stufNXbrrbeiUaNGWLJkCZYtW4aioiLExsbi8ssvL/VZ119/PYYPH46PP/4YH374IZRSLhutHj164M0330RSUhKSkpJgMpnQpUsXPPPMM7Vu5ImI3ElTrn6/QEREIq1YsQIvv/wydu7cidjY2ErfZ7fb0b17d/Tt2xczZ870YoVERER1F6/RIiKqAwoKCkr9d2FhId599100b968VJNVWFhY7vqgzZs3IyMjA127dvVKrURERPUBfzpIRFQHPPLII2jSpAkuvvhi5OTk4MMPP8TRo0cxZ86cUu/75Zdf8PLLL+PGG29EZGQkfvvtN2zcuBGtW7fGjTfeqFP1REREdQ8bLSKiOqBXr17YuHEjPvroI9hsNrRq1Qqvv/46brrpplLvi4+PR+PGjbF69WpkZmYiIiIC/fv3x9NPP12l504RERFR1fAaLSIiIiIiIjfjNVpERERERERuxkaLiIiIiIjIzXiNViX27t0LpVSNnlVCRERERER1h8VigaZp6NSpU5XnYaNVCaVUuVsgExERERFR/VOTvoCNViX8/PyglEK7du2gaZre5VAVKKVgsVjg5+fHzIRgZvIwM3mYmTzMTB5mJk91M9u/f3+1P8OnGq3jx49j2bJl2LdvHw4dOoQWLVpgy5YtVZo3JSUFc+fOxY4dO5CXl4f4+HiMGTMGt912m4erJiIiIiIiKs2nGq1Dhw5hx44d6NChA+x2e5VP0Z07dw5DhgzBRRddhBkzZiA0NBSHDh1CUVGRhysmIiIiIiIqz6carT59+uC6664DAIwfPx4HDhyo0nyvvvoqGjdujDfffBNGoxEA0L17d4/VSURERERE5IxP3d7dYKh+OTk5Odi6dSvuuuuu4iaLiIiIiIhITz7VaNXEwYMHYbFYYDKZcM8996Bt27bo2bMnXn31VVgsllqNzYsZ5eHt+OVhZvIwM3mYmTzMTB5mJo+nM/Opnw7WRGpqKgBg0qRJGDx4MB555BH8+uuvSEpKgsFgwFNPPVXrzyh7rZimaaVes9lsxU2dozmr7PqysvOWnVabeTlu7cb18/ODwWCosMGua8uq17jO5vXUuPVpHXq7JqWUqHo9Pa4v1lR2muO/fbVeX6xJj3FLTnf1HcRbNXHcqo9b0XS9a6or4/paTa6Ib7TsdjsAoEePHhg/fjwA4IorrkBubi6WL1+OsWPHIjAwsEZjK6VQVFRU6ou3wWCAyfTPaisqKsL58+eRlZVVPN1TG5C0cfWqyZmqjGs0GhEVFYXw8PDi95fMvKKzpI6/hthstuLt0cFoNMJoNEIpBavVWu7zHPNardZydZlMJmiaBrvdDpvNVuG4FdVUm3GrsqyaplW4rI5xK1pWx7hKqVLjKqVgt9sREBBQ6bi1WYeOac7WobuzcbUO/f39AVS8vVRl3LLrsOyyemodOsZ1ZOaox9vrUK/t29k69PVjRFFRUXFmji/xUo4RJccFPLd9+9oxQimFwsLC4ryqM67exwh3jSvtGOG4/MUxvbrjAvwe4e1jhOPfs8DAQGia5vIY4fjjYnWIb7TCw8MB/NNcldS9e3csWrQIx48fR5s2bWo8vrN765vNZmRnZ6NRo0YIDg4udUCsK526tHGd7QTOxlVKwWazISsrC6mpqbBYLIiLiyv3PmenmEsetCr6bGfzOg5KFTEYDE6vX/TmuI51WNNlLTut7AFTj3WoVzbOlrU29XpqHZb8h6rsc0e4fTsf10HPY0Rlz4rxtXWo1/bti8cIx+dW9G+aLx8j3D2ulGOE40u8yWQSeYzw1ri+dIwo+x3E1bJWt8kC6kCj1apVK6fTCwsLazV+2b8mOdjtdmRmZqJRo0aIiYmp1WeQezhO11eWWVWEhYUhICAAqampiI2NLbezOhu3ptPq07gVTS+ZV11aVm+uQ2+P68isKrnVpiZp4/piTSUzqujY6Gv1+mJNeo5b2b9ndXFZ69K4nvhcX11Wb4/r7prK/ttW05oqI/5mGPHx8WjdujV2795d6vXdu3cjMDDQZSNWU44OODg42CPjk35CQkIqPTVNRERERFQVPnVGKz8/Hzt27AAAnD59Gjk5Odi2bRsAoGvXroiOjkZiYiLOnDmD7du3F883btw4PPzww3jxxRdx9dVXY//+/Vi+fDlGjhzp8Uaoph0u+S5mSkRERES15VONltlsxuOPP17qNcd/r1q1Ct26davwwrs+ffpg7ty5WLBgAdatW4dGjRrh0UcfxYMPPlireviFWx5mJg+ffycPM5OHmcnDzORhZvJ4OjOfarSaNm2KP/74w+l7Vq9eXeHrN910E2666Sa311QfvrgnJydj3rx55V7/17/+hS1btqBNmzZ49tlnMXLkSADApk2b4Ofnh1tvvbVK4xcUFGD58uXYsmULTp48iaCgIHTu3BkPPfQQOnbsWOq9w4cPR3BwMBYvXlzpeL/88gvmzZuH33//HdnZ2WjQoAHatWuHkSNHokOHDpXOV926yfM0TeM/TMIwM3mYmTzMTB5mJo83MvOpRssX1eRWjhIFBgZi5cqV5V4DgHfffRdNmjQpfv39999HcHBwlRqWvLw83HfffTh06BAeeOABXH755cjIyMDbb7+Nu+66C3PmzKlWg/zTTz/h3nvvxZVXXonp06cjJCQEx48fx+eff459+/ahffv2ACpukKtTN3mHO25gQt7FzORhZvIwM3mYmTzeyIyNlhM1fTiZRAaDodzZJYfKXq+KN954A/v27cPKlStL3YL/uuuuw4gRIzBx4kRcfvnlaNSoUZXGW7duHeLj4zF//vziv0J0794dQ4cOhc1mqzeNcV1itVo9/mR2ci9mJg8zk4eZycPM5PF0ZuLvOkie16ZNGyxbtgzAPz/t+/777/HVV1+hTZs2aNOmDZKTkyucr6CgAOvXr0fPnj3LPefMaDTiscceQ15eHjZs2FDlWrKyshAdHV3hqV5nz3KoTt1ERERERLXFM1pUrOxTuI1GY7mzQ1OnTsUzzzyDwMBAPPfccwCAxo0bVzjegQMHkJeXh2uuuabC6ZdddhkiIyPx448/VrnGtm3bYsGCBfj3v/+NW2+9FS1btqzSfNWpm4iIiIiotthoEYB/rqVq27Ztqddmz56N/v37l3qtVatWCA0NRXBwsMufFKakpAAA4uLiKn1PXFwc/v777yrXOXLkSOzbtw8LFy7EwoULERkZiV69emHYsGG47LLLKp2vOnUTEREREdUWGy0nanqtj+WvM7BnZru5GtcMEWHwa97E9RsrEBgYiLfffrvUa82aNXNHWW4VGhqK5cuX49dff8VXX32Fn376CZ9++ik+/vhjvPDCCxg4cKDeJVI18Zo6eZiZPMxMHmYmDzOTx9OZsdFyoboB2MwZONFtGGC3e6giJ4xGND+4GcaYyGrPajAYkJCQ4NZyYmNjAQBnz56t9D1nz57FpZdeWu2x27dvX3yHwZMnT2L48OF47bXXMHjw4JoVS7rQNI0XDgvDzORhZvIwM3mYWe3l5+cjPz+/0ulBQUEICgpy2+d5IzM2Wm5mjInEBXvW6XZGqyZNlqe0a9cOwcHB+OqrrzB8+PBy0/fu3YuMjAxcfvnltfqcZs2a4cYbb8Rbb72F1NRUNGjQoFbjEREREZF3HT58GAcOHAAA2Gw25ObmIiQkpPgGaO3atXP7SQFPY6PlQk1uF17Tn+9J4efnh8LCQpfvCwwMxODBg7FixQr88MMP6NKlS/E0u92OpKQkBAcHY9CgQVX+7Moaqb/++gv+/v4IDQ2tNLOq1k3eo5SC1WqFyWTiTy6EYGbyMDN5mJk8zKz2WrVqhfj4eABAZmYmdu7ciZ49eyIiIgIA3Ho2C/BOZmy0nKhPz9GqjhYtWmDz5s348ssv0bBhQzRq1Kj4Z4JlPf7449i7dy8efPBBjBo1qviBxWvWrMEPP/yAOXPmlHuG1vnz57Ft27ZyY1199dWYNGkSbDYbrr/+ejRv3hw5OTn49NNP8Z///AeJiYnw9/d3S93kPdzP5GFm8jAzeZiZPMysdsr+NNDf3x8RERGIjo722Gd6OjM2WlRto0aNwokTJ/Dcc88hKysLjzzyCB599NEK3xscHIxVq1Zh+fLl2LJlCxYuXIigoCB07twZa9asQadOncrNc/DgQTz++OPlXt+xYwfuvvtubN68GYsXL8b58+cRGBiICy64AC+++CJuv/12t9VNRERERFQbmmL7XaH9+/dDKYWEhIQKTycWFBTg2LFjuOiiixAYGKhDhVSWUqr4Z4O1OQXMbL1HKQWLxQI/Pz/+1EIIZiYPM5OHmcnDzNwrLS0Nn376KW644QaPndGqbmb79+8HgGpdJ2aocXVERERERERUITZaTvAvEvIwM3l4O1x5mJk8zEweZiYPM5OHt3fXGb+4y8Gs5GFm8jAzeZiZPMxMHmYmjzcy4xktF3gJmxyOa7SYmRxKKdhsNmYmCDOTh5nJw8zkYWbyeCMzNlpOcGeRh5nJY7PZ9C6BqomZycPM5GFm8jAzeTydGRutWuIX+7qHmRIRERHpJyMjAykpKcjIyNC7lFpho1VDjovn8vLydK6E3C03NxeapvGiViIiIiId5OTkFP9PMt4Mo4aMRiMiIyNx7tw5AP88mJcXQuqrNs/RUkrBarUiKysLWVlZiIyMhNFo9FClRERERFSZvIIiKKWQV1Ckdym1wkbLCVdf1hs3bgwAxc0W6c/RaNWU0WhEXFwcIiIi3FgVOcOGVh5mJg8zk4eZycPM3CMrpxBbdv0Fo01hy66/cOmlCQgPDfDIZ3k6MzZaLjj70q5pGuLi4tCoUSNYLBYvVkWeYDKZYDQaeWbSizRN4z9MwjAzeZiZPMxMHmbmPmfNuTh5NhvNg4GTZ7PxtznPI42WNzJjo+VCVc6QGI1G7lw+oDY/HSR9MDN5mJk8zEweZiYPM3OfuJgQNIsLAzKBZnFhaBwT7JHP8UZmvBmGE7z7nDxWq1XvEqiamJk8zEweZiYPM5OHmblHeGgAbunZHCajhlt6NvfYzwYBz2fGRouIiIiIiHyCLTMbEW9vxb/2n0JwoL/e5dQKGy0iIiIiItKVstmQufIDnOg2DP6bd8AQEYrQ0FC9y6oVXqNFRERERES6yf/mZ6ROSkLRwSMIHXwjjI8Mhu2XHxEZGal3abXCRssJXswoDzOTh5nJw8zkYWbyMDN5mFn1Wf46A/O0Bcj9eAcCurRD/KeLEdj5UqSlpXnl8z2dGRstF7jTyKFpGvz8/PQug6qBmcnDzORhZvIwM3mYWfXYc/KQ/voqZCxaD2ODKDRaNAWhd17n1e/d3siMjRYREREREXmcstuR/c5WpL24BPasHEQ9djciH7kLhpAgvUvzCDZaLlTlOVrkG5RSsFqtMJlMzEwIZiYPM5OHmcnDzORhZq7l7/kV5olJKNz3B0LvuBbRU8bAr2msbvV4IzM2Wk7wOVryMDN5mJk8zEweZiYPM5OHmVXMcioFaS8sRM77XyCgQxs02TIfQd3a610WAM9nxkaLiIiIiIjcyp6bj4x5a5Exfx0MYSFo+MZ4hA3tB81Qf54uxUaLiIiIiIjcQimFnPe2w/zCItjMGYh8aDCixt0LQ2iw0/ny8/ORn58PAMjMzERRUREyMzOLpwcFBSEoSNa1XGy0iIiIiIio1gr2/o7UiUko/OEAQm6+CjHTHoZf8yZVmvfw4cM4cOAAAMBms6GgoAC7du2C0WgEALRr1w4JCQkeq90T2Gg5wYsZ5TGZuElLw8zkYWbyMDN5mJk89Tkz69+pMM9YjJz12+DftiWavP8Ggnp1rtYYrVq1Qnx8fKXTPXE2y9OZ1d8toorYbMmhaRrzEoaZycPM5GFm8jAzeeprZvb8QmQufBfpb7wNLcgfDeY8jfB7boH2/2ehqsPbPw30RmZstFzg7d3lUErBbrfDYDAwMyGYmTzMTB5mJg8zk6e+ZaaUQu5HX8E8bQGsZ88jYtRARD2VCGNEmN6lVZk3MmOj5QRv0ymPzWaDoR7dzaYuYGbyMDN5mJk8zEye+pJZ4f5DSJ34Bgq+3Yfgvt0Rt/41+Le6QO+yasTTmbHRIiIiIiIip6zn0pD28lJkr/kYfv+6AHHvzkFwn256l+XT2GgREREREVGFVJEFmUs3Im3OCmgmIxq8+BjC77sdmh/bCFe4hoiIiIiIqBSlFPI+3QXzlPmwnDiL8MT+iH5uBIzREXqXJgYbLSfqw8WMdU19+G10XcPM5GFm8jAzeZiZPHUps8Lfj8I8ORn5O35E0NVd0HjVS/C/+CK9y3I7T2fGRssFNltyaJpWr59hIREzk4eZycPM5GFm8tSVzGxpmUh7ZTmyVn4Avwvi0PjtWQi+vked/D7sjcx8qvU+fvw4pkyZgv79++PSSy/FLbfcUu0xVqxYgTZt2mD06NFuqYl3HpRDKVX8P5KBmcnDzORhZvIwM3mkZ6YsVmQs2YgT3YYhZ8OniJnyEJp9swohN/Ssk00W4J3MfKr1PnToEHbs2IEOHTrAbrdXe8HPnz+P+fPnIyYmxi31SN1Z6jOLxQI/Pz+9y6BqYGbyMDN5mJk8zEweqZnlfbEHqVOSYTl0AmH33ILo50fB1DBK77K8wtOZ+VSj1adPH1x33XUAgPHjx+PAgQPVmv/VV19Fnz59cObMGU+UR0RERERUJxQdPgHzlHnI2/4tAnt0ROyiqQhI+JfeZdUpPvXTwdpckPbjjz/i888/x1NPPeXGioiIiIiI6g5bZjZSJyfj5JX3ouiPvxC7fAaabE5ik+UBPnVGq6ZsNhtmzJiBhx56CI0aNdK7HCIiIiIin6JsNmSt/ghps96Eyi9C9LMjEDFmCAyBAXqXVmfViUZr7dq1yM/Px3333ef2sSu6TkvTtEqv33JcMOhsuqfmre/jOl5jNr47btl5S16IWteWta5uh2UvHvb1er05ri/WVDKvku/z1Xp9sSY9x/X2dxCOW/NxPf0dpLbj5n/9E8yTklH0+1GEDrkR0RMfhF9cQ6fbmZ71emLestPKLntNxnVFfKNlNpuRlJSEV155Bf7+/m4dW9M0WK3WUq8ZDIbiW0FaLJZy8zhqsNlssNvtpaaZTCZomga73Q6bzVbhuEqpCsd1XKhX0bhGoxFGoxFKqXL1appWPK/Vai23oXhq3KosK1B+HdZ2XH9/f6frUNO0ai+rq8z1WIeOcSuqyVPZOJa1snXoGNfZOqwoG03Tig+entq+na1Db27fQN04RjiOjRKPETXdviUfI6xWa6l/z6QdIxzjAvXnGKFpGoxGY7nPlXKMcMe4Eo8R/v7+sNvt5ebV8xhhPX4WqVPnIe+Tr+F/2aVotGU+AjpdDMP/Hx8qqqk+HSMMBkPxdxBXxwilVPF7q0p8o/XGG2+gTZs2uPzyy5GVlQXgnxVltVqRlZWF4ODgWt0j39mdSJxNK/mPXFkGg6HS69FKbtzVHdfVvM7Wg6fGdbasgPN16O5xHTtHbZZVj2zq0jrUa/uuzT7nqWx4jPhHXdq+KxvXgevwf+/hMeIfPEa4Hrcubd+VjevgznVoz8lD2qxlyFy8AcYGkWi0cDJC7ryuwkZB0jrU8xhR3SYLqAON1rFjx/DDDz+gS5cu5aZ16dIFS5cuRe/evWv1GRWtWFcr29l0T81b38d1/KXCaDT6TE0c1/l0pRRsNlvxQbEuLWtdPUaUzMzxmi/X681xfbEmx1+Hy2bmjnGdqWvr0NvjOstMr5o4rvPpnv4OUtWalN2O7HVbkfbiEthzchH1+D2IHDsMhpCgWo3rqXr1rKnsflabmiojvtGaMGFC8Zksh5deegmBgYF48skn0aZNmxqPXdPfY5J+7HZ7pX/JIN/EzORhZvIwM3mYmTx6Z5b/3a8wT0pC4b4/EHrHtYieMgZ+TWN1q0cCT2fmU41Wfn4+duzYAQA4ffo0cnJysG3bNgBA165dER0djcTERJw5cwbbt28HAFxyySXlxgkPD0dwcDC6devmveKJiIiIiLzMcioFadMXIGfzlwjo0AZNtsxHULf2epdF8LFGy2w24/HHHy/1muO/V61ahW7dulV44R0RERERUX1iz81HRvIaZMxfB0N4KBomPY+wITdCq8Vzacm9fKrRatq0Kf744w+n71m9erXLcaryHiIiIiIiaZRSyHlvO8wvLILNnIHIMUMQ9cRwGEKD9S6NyvCpRsvX1PTCN9JPbe4wSfpgZvIwM3mYmTzMTB5vZFbw829InZiEwh8PIuTmqxAz7WH4NW/i8c+tqzydGfdiF9hsyeHqjjHke5iZPMxMHmYmDzOTx9OZWc+eh3nmYuSs/xT+bVuiyeYkBPXs5LHPqw+8sZ+x0XKhJg8nI30opWC322v8rAPyPmYmDzOTh5nJw8zk8VRm9vxCZC58F+lvrIYWFICGrz2DsLtvhsY7UtaaN/YzNlpO8Pbu8thsNqcPzyPfw8zkYWbyMDN5mJk87sxMKYXcD7+CefoCWM+eR8SogYh6KhHGiDC3jE//8PR+xkaLiIiIiMhHFP76J1InJaHg230Ivr4H4ja8Bv+WF+hdFtUAGy0iIiIiIp1Zz6Uh7eWlyF7zMfxaX4i49a8h+JquepdFtcBGi4iIiIhIJ6qwCBlLNyL9tZXQTEY0ePExhN93OzQ/fk2Xjgk6wQtQ5eHv2eVhZvIwM3mYmTzMTJ7qZqaUQt62b5A6ZT6sJ/9G+H39Ef3sCBijIzxUIZXl6f2MjZYLbLbk0DSNzx0RhpnJw8zkYWbyMDN5qptZ4e9HYZ6cjPwdPyLo6i6IW/0y/C++yIMVUlne2M+4F1Odwtvxy8PM5GFm8jAzeZiZPFXJzGbOQNory5G18gP4NW+CxmtmIbhvD2atE0/vZ2y0nFBK8UAniFIKFosFfn5+zEwIZiYPM5OHmcnDzORxlZmyWJG5/H2kv7ocsCvETB2DiAcGQPP306FaAryzn7HRIiIiIiLykLwv9iB1cjIsh08gfPitiBr/AEwNo/Qui7yAjRYRERERkZsVHT4B8+Rk5H3+HQJ7dETs4qkISPiX3mWRF7HRIiIiIiJyE1tGNtLnvIXMZZtgatIIsctnIOSWq/gz0HqIjRYRERERUS0pqw1Zaz5B2qw3oQqKEP3cSEQ8NBiGwAC9SyOdsNFygn95kMfPjxeVSsPM5GFm8jAzeZiZLPlf/wTzpGQU/X4UYUNuRPSk0TA1bqB3WeSCp/czNlousNmSg1nJw8zkYWbyMDN5mJkclmOnYZ42H7mffI3ALu0Q/9kSBHa6RO+yqAq8sZ+x0XKBt3eXQykFm80Go9HIzIRgZvIwM3mYmTzMzPfZs3OR/vpqZCxeD2ODKDRaNAWBt13NB00L4o39jFuDE0opvUugarLb7TAajXqXQdXAzORhZvIwM3mYmW9Sdjuy121F2otLYM/JRdTj9yDykbugBQXAYrHoXR5Vk6f3MzZaREREREQu5H/3K1InvoGiX/9E6J3XIWbKQzDFxwLgH+epYmy0iIiIiIgqYTmVgrTpC5Cz+UsEdLwY8R8vQGDXBL3LIgHYaBERERERlWHPzUdG8hpkzF8HQ3goGiZPQNjgG6AZDHqXRkKw0XKCF6DKw9+zy8PM5GFm8jAzeZiZfpTdjpz3tsM8YzHsaZmIeGgwop4YDkNosNP5mJk8ns6MjZYLbLbk0DSNBzlhmJk8zEweZiYPM9NPwc+/IXViEgp/PIiQW65CzLSH4XdhE5fzMTN5vJEZGy0XeHt3OZRSxXkxMxmYmTzMTB5mJg8z8z7r2fMwz1yMnPWfwr9tKzTZnISgnp2qPD8zk8cbmbHRcoJ3kJHHarV6/Cnf5F7MTB5mJg8zk4eZeYc9vxCZC95BetLb0IID0fC1ZxB2983QanCmg5nJ4+nM2GgRERERUb2ilELuh1/BPH0BrGfPI+LBQYh6KhHG8FC9S6M6hI0WEREREdUbhb/+idSJSSj4bh+Cb+iJuA2vwb/lBXqXRXUQGy0iIiIiqlPy8/ORn59f6jV7agbyX1+Nove+gKnVBYhb/xqCr+mqU4VUH7DRcoIXM8rDzORhZvIwM3mYmTzMrHYOHz6MAwcOAADshUWI+fwnXPTVAcBowKkBvdBo9GBc2LGjWz+Tmcnj6czYaLnAnUYOTdN4EaowzEweZiYPM5OHmdVeq1at0KRJE1i++B65b7wJdeY8tAHXIuKpRDSMCkdQUJBbP4+ZyeONzNhoEREREVGdYvjrLAonJSF/509At3b46qYO6DPyHjRo0Vzv0qgeMehdgK/jLd7lUErBYrEwM0GYmTzMTB5mJg8zqzmbOQPnn30Np66+H9ZTKWi8ZhZyX3wIfwcZkJOT47HPZWbyeCMzntFygjuLPMxMHmYmDzOTh5nJw8yqR1msyFz+PtJfXQ7YFWKmjUHEyAHQ/P2Q9/2PUEohr6DIszUwM3E8nRkbLSIiIiISK/fz72CeMg+WwycQPvxWRI1/AKaGUQCArJxCbNn1F4w2hS27/sKllyYgPDRA54qpvmCjRURERETiFB06DvPkecj74jsE9uyE2CXTENCuVan3nDXn4uTZbDQPBk6ezcbf5jw2WuQ1bLSIiIiISAxbRjbS57yFzGWbYIpvhNi3ZiLk5t4V3ik6LiYEzeLCgEygWVwYGscE61Ax1VdstJzgrd3l4a1V5WFm8jAzeZiZPMysPGW1Imv1R0ibtQyqoAjRz41ExEODYQis/AxVeGgAbunZHNs//R39ejb36NksZiYPb++uMzZbcjAreZiZPMxMHmYmDzMrL2/njzBPSkbR70cRNrQfoic+CFPjBlWaNzjQH5qmITjQ32P1MTN5vJEZGy0XlFLceYRQSsFms8FoNDIzIZiZPMxMHmYmDzP7H8ux0zBPm4/cT75GYJd2iN++FIEdL67WGKGhocX/8xRmJo83MmOj5QRv0ymP3W6H0WjUuwyqBmYmDzOTh5nJU98zs2fnIv31VchYvAHGBlFotGQqQm+/tspfiPPz85Gfnw/gnzMXUVFR0DQNaWlpAICgoCAEBQW5t+Z6nplEns6MjRYRERER+QRlsyF73VakvbQU9pxcRD0xHJFjh8EQHFitcQ4fPowDBw4AAGw2GwoKCrBr167iL9Xt2rVDQkKC2+snKomNFhERERHpLv/bfUidlISiX/9E6J3XIWbKQzDFx9ZorFatWiE+Pr7S6e4+m0VUETZaRERERKQby8m/YZ6+ELkffImAjhcj/uMFCOxau7NNnvhpIFF1+VSjdfz4cSxbtgz79u3DoUOH0KJFC2zZssXpPOfOncOKFSuwa9cunDhxAmFhYejSpQuefPJJp3/JqApezCgPfxstDzOTh5nJw8zkqQ+Z2XPzkZG0BhkL1sEQEYaGyRMQNvgGaAaD3qXVSH3IrK7xdGY+1WgdOnQIO3bsQIcOHWC326t0M4qDBw9i+/btGDBgADp06ID09HQsXLgQgwYNwpYtWxAdHV2rmthsyaFpGg9ywjAzeZiZPMxMnrqembLbkfPedphfWAR7ehYixgxB1OP3wBAq92HCdT2zusgbmflUo9WnTx9cd911AIDx48cXX8TozGWXXYatW7fCZPrfonTu3BlXX301Nm/ejBEjRtSqJt7eXQ6lVHFezEwGZiYPM5OHmclTlzMr+OkgUicmofCn3xByy1WImfYw/C5sondZtVaXM6urvJGZTzVahhqcKg4PDy/3WuPGjREdHY1z587Vqh7e3l0eq9XKJ7MLw8zkYWbyMDN56lpm1rPnYZ6xCDkbPoN/21ZosjkJQT076V2WW9W1zOoDT2fmU42Wuxw7dgxmsxktW7bUuxQiIiKiesueX4jMBe8gPeltaMGBaDj3GYTddTM0/syO6oE612gppTBz5kw0atQIN998s1vGK0vTtErPdjlOPTqb7ql56/u4jteYje+OW3Zex2l7x6n7urSsdXU7LJmZhHq9Oa4v1lQyr5Lv89V6fbEmPcf19ncQd46rlELuh/9B2guLYP07FREPDEDUU4kwhIcWT/elems7rqe/g3Bc99dUdh+rybiu1LlGKzk5Gd999x3efPNNBAfX/qJKi8VS6nebBoOh+Howi8VS7v3+/v4A/nk4nt1uLzXNZDJB0zTY7XbYbLZS0xzjKqUqHNdxWrOicY1GI4xGI5RSsFqtpaZpmlY8r9VqLbeheGrcqiwrUH4d1mbckjlVtg41Tav2srrKXI916Bi3opo8lY1jWStbh45xna3Dstu3472e3r6drUNvbt+A/GNEyTFMJpOoY0Rttm/pxwjH2JqmiTpGlBwXqH/HCMdnVWdcvY8RAFC0/09kTF2Awj37EXxDTzRe/xq0CxrDBsD2/7XVtWOE4/IXqccId40r6RihlCpVv6tjRMk/DlRVnWq01q9fj/nz5+PFF19E9+7d3TKmY4OobFplSm7AZRkMhkqvRyu5cVd3XFfzlrxhiLfGdbasgPN1WN1xS+4wFY3ryLE2y6pHNt5ch67Gre06LDut7EFLj3WoVzZSjxGOzBz/INZ23Lq0fVc2roOex4iymblr3LLcfYwoqz4dI0wmU4WZ1bZeTx4jVGoG0l9eiux1W+HX+kI0Xv8aQq7p6vJsQF04RjjOjkg9RnhrXF86RpT9DuJqWavbZAF1qNHavn07pk2bhsceewwDBw50y5iapjk9kLmatybTajNvfR/XWV561cRxnU/XNK34r7d61SRtXL1rKpuZu8at7jRfHNcXa3KcwSqbmTvGdaaurUNvj+ssM71qcjZdFRYhY8kGpM9dBc3PhAYvP4HwxNug/f8XV1+r1xPjevo7iC8tq57jurMmd34HqUydaLT27NmDJ598EoMGDcLYsWP1LoeIiIiozlNKIW/r10idugDWk38j4v7bEfXsCBijyt8Rmqg+8qlGKz8/Hzt27AAAnD59Gjk5Odi2bRsAoGvXroiOjkZiYiLOnDmD7du3AwCOHDmCsWPHonnz5ujfvz9++eWX4vGio6NxwQUX1Kqmmvwek/Th+O1tZT+1IN/DzORhZvIwM3kkZFb42xGYJycjf+dPCLqmK+Lefhn+bS7SuyzdSMiMSvNGZj7VaJnNZjz++OOlXnP896pVq9CtW7dyF97t27cP2dnZyM7OxrBhw0rNe8cdd2DWrFk1rqemdxgh/TAzeZiZPMxMHmYmj69mZjNnIO2VZcha+SH8LopH4zWvILhvdzYX8N3MqHKezkxT3CoqtH//fiilkJCQwIOHEI470Ti7gQn5FmYmDzOTh5nJ44uZKYsVmcs2IX3OW4ACop5ORMTIAdD8+YBewDczI+eqm9n+/fsBAAkJCVX+DJ86o0VEREREviX38+9gnpwMy9FTCB9+K6LHj4SxQZTeZRH5PDZaRERERFRO0aHjME+eh7wvvkNgz06IXTodAe1a6V0WkRhstJzgqV95nD0DgXwTM5OHmcnDzOTRMzNbRjbSX30Lmcs3wRTfCLFvzUTIzb35vcgF7mfyeDozbhEu8KAih+N5MSQHM5OHmcnDzOTRKzNltSJr1UdIe2UZVGERosc/gIjRg2AIDPB6LdJwP5PHG5mx0XKBt3eXQykFu91e46d3k/cxM3mYmTzMTB49Msvb+SPMk5JR9PtRhA3th+iJD8LUuIFXPrsu4H4mjzcyY6PlBG/IKI/NZqvSk9nJdzAzeZiZPMxMHm9lZjl6CqnT5iNv6zcI7JqA+O1LEdjxYo9/bl3E/UweT2fGRouIiIionrFn5yJ97kpkLNkIU8MoNFoyFaG3X8uzMURuxEaLiIiIqJ5QNhuy121F2ktLYM/JQ9S44Yh8eBgMwYF6l0ZU57DRIiIiIqoH8r/dh9SJb6Bo/yGEDuiLmMmjYYqP1bssojqLjZYTPH0uD38bLQ8zk4eZycPM5HFnZpaTf8M8fSFyP/gSAZ0uQfwnCxHYpZ3bxqd/cD+Tx9OZsdFygc2WHJqm8RkWwjAzeZiZPMxMHndlZs/JQ0byWmQsWAdDRBgazZuI0EHXQ2ND4Hbcz+TxRmbcIlzg7d3lKHmXSGYmAzOTh5nJw8zkqW1mym5HzsbPYJ6xGPb0LESMGYKox++BITTYnWVSCdzP5PFGZmy0nODt3eWxWCzw8/PTuwyqBmYmDzOTh5nJU9PMCn48iNRJSSj86TeE3Ho1YqaOgd+FTTxQIZXF/UweT2fGRouIiIhIOOvZ8zDPWIScDZ/Bv20rNNmchKCenfQui6heY6NFREREJJQ9vxAZC9YhI2kNtOBANJz7DMLuuhma0ah3aUT1HhstIiIiImGUUsjd/CXMLyyENcWMiAcHIurJRBjDQ/UujYj+HxstJ3gxozzMTB5mJg8zk4eZyeMss8J9fyB1YhIK9vyK4Bt6Im7j6/Bv2cyL1VFFuJ/J4+nM2Gi5wJ1GDk3TeBGqMMxMHmYmDzOTp7LMrClmpL20FNnrPoFfm+aI2zAXwVd30aFCKov7mTzeyIyNFhEREZEPU4VFyFi8Aemvr4LmZ0KDl59AeOJt0PjcJiKfxj3UBT5HSw6lFKxWK0wmEzMTgpnJw8zkYWbyODIzGo3I3/YNUqfOh/VkCiJG3IGoZ+6HMSpc7xKpDO5n8ngjMzZaTvA5WvIwM3mYmTzMTB5mJk/hb0eQOX0hCr7+GUHXdEXc27Pg3+YivcsiJ7ifyePpzNhoEREREfkIW2o6zLOWIXv1R/C7KB6N17yC4L7deZaESCA2WkREREQ6UxYrMpdtQvqrbwEAIiePRtSogTAE+OtcGRHVFBstIiIiIh3lbv8W5inzYDl6CuHDb0XUcyNhjwiBxrvYEYnGRssJnqaXx8Q7MInDzORhZvIwM99U9OdfSJ08D/lf7kFgr86IfXM6Atq2glIKBl7vIw73M3k8nRm3CBfYbMmhaRrzEoaZycPM5GFmvseWkY30V99C5vJNMDWNReyKFxFy05XFOTEzeZiZPN7IjI2WC7y9uxxKKdjtdhgMBmYmBDOTh5nJw8x8h7JakbXqI6S9sgyqsAjR4x9AxOhBMAQGlH4fMxOHmcnjjczYaDnB23TKY7PZYDAY9C6DqoGZycPM5GFm+svb8SPMk5NR9N9jCBvaD9ETRsHUuEGl72dm8jAzeTydGRstIiIiIg+xHD2F1Gnzkbf1GwR2TUDT7UsR0KGN3mURkRew0SIiIiJyM3t2LtLnrkTG4g0wNYpG7JJpCLm9D39WRlSPsNEiIiIichNlsyF77SdIe3kp7Dl5iHryXkQ+PAyG4EC9SyMiL2Oj5QT/6iQPfxstDzOTh5nJw8y8I3/3L0idlISi/YcQOrAvYiY/BFOTRjUai5nJw8zk8XRmbLRcYLMlh6ZpfIaFMMxMHmYmDzPzPMuJszBPX4jcD/+DgE6XIP6ThQjs0q7G4zEzeZiZPN7IjFuEC7y9uxwl7xLJzGRgZvIwM3mYmfvk5+cjPz8fAJCZmYl93+5Bwi8ngTVboUWEInLuM4i++xZotfwrOTOTh5nJ443M2Gg5wdu7y2OxWODn56d3GVQNzEweZiYPM3OPw4cP48CBA4BdIXTXr2j5yY+wFVrwd59OONu3My7teBFi3PRTJGYmDzOTx9OZsdEiIiIiqoJWrVoh9nwO8l5cCtuvh3C8VSOYnrgH7fpehXYAgoKC9C6RiHwIGy0iIiIiF6xnziFrxiLkbNwO06Ut8cndA5AamQXbGRs6+ocgPDRA7xKJyMfw9ihERERElbDnFSBtzls40f1u5O/4EQ3nPouCt17Fj/4RAICTZ7PxtzlP5yqJyBfxjBYRERFRGUop5G7+EuYXFsKaYkbEgwMR9WQijOGhQE4hmsWFAZlAs7gwNI4J1rtcIvJBbLSc0DSNd44RRNM0+Pn5MTNBmJk8zEweZlZ9hfv+QOrEJBTs+RXBN/ZC3MbX4d+y2T93HUxLAwD06dgQ33wNXNWxIaxFuUhLy0VQUJBbrtNiZvIwM3m8kRkbLapTeICTh5nJw8zkYWZVY00xI+2lpche9wn82jRH3Ia5CL66S/H04rsOAsjJyYGmaThy+E+k/H0GANCuXTskJCS4pRZmJg8zk8fTmbHRcoHP0ZJDKQWbzQaj0cjMhGBm8jAzeZiZa6qwCBmLNyD99VXQ/ExoMGscwu+9FVqZh5m2atUK8fHxAP55jtbevXvRqVMnRET8c72Wu+46yMzkYWbyeCMzNlpO8Dla8tjtdhiNRr3LoGpgZvIwM3mYWcWUUsj95GuYp82H9WQKIkbcgahn7ocxKrzC95f8aWB0dDQuuugij9XGzORhZvJ4OjOfarSOHz+OZcuWYd++fTh06BBatGiBLVu2uJxPKYWlS5di7dq1SEtLwyWXXILnn38eHTt29HzRREREJE7hwcNInZSMgm9+RtA1XRG35hX4t26ud1lEVIf41O3dDx06hB07duDCCy9Ey5Ytqzzf0qVLkZSUhPvuuw+LFy9Gw4YNMWLECJw8edKD1RIREZE0ttR0nH9mDk71GQnb2fNovOYVxL07h00WEbmdTzVaffr0wY4dO5CUlIS2bdtWaZ7CwkIsXrwYI0aMwH333Yfu3btj7ty5iIyMxLJlyzxcMREREUmgiizIWPQuTnS7CzmbvkDM9IfRbOdKhFzfg9fUEJFH+NRPBw2G6vd9P//8M3JyctCvX7/i1/z9/dG3b19s3769VvXwwCsPfxstDzOTh5nJU98zy93+LcyTk2E5dhrh996K6OdGwtggSu+ynKrvmUnEzOTxdGY+dUarJo4ePQoAaNGiRanXW7ZsiTNnzqCgoKBW47PZkkPTNN7tRxhmJg8zk6c+Z1b05184M+Rp/H3XszA1aYimXy5Dw1ef9vkmqz5nJhUzk8cbmfnUGa2ayMrKgr+/PwICAkq9Hh4eDqUUMjMzERgYWOPx7XZ7uQA0Tav0joSO9zqb7ql56/u4JV+raKdhNvqPW3ZepVTxIxQMBkOdWta6eowomZnjf75crzfH9cWaHHmVzMyX63VXTbb0LKTPeQtZyzfD1CwWjVe+iKAbe1U4hi9uh0qp4u8f3vwOwnFrPq6nv4P40rLqOa47a3IcGw0GQ42XxxXxjZYnKaVgsVhK7TAGgwGm/3+uhsViKTePv78/AMBms8Fut5eaZjKZoGka7HY7bDZbqWmOcR2fWZafn1+l4xqNRhiNRiilYLVaS03TNK14XqvVWm5D8dS4VVlWoPw6rM24jh3BZDJVug41Tav2srrKXI916Bi3opo8lY1jWStbh45xna3Dstu3472O2yV7avt2tg69uX0D8o8RjjFMJhNMJpOoY0Rttm/pxwhHZo4v7lKOESXHBVyvQ0tBIXLe/ghZr66AslgR+dwIRD88FFqAPywWi6hjRGFhYbm/tks4RrhrXGnHCIPBUHyrcInHCHeN6+vHiJLjKvXPc7Qc30FcfY9w/MGqOsQ3WuHh4SgqKkJhYWGps1pZWVnQNK34IYI15dggKptWmZIbcFkGg6HS69FKbtzVHdfVvI4N35vjOltWwPk6rO64JXegisZ15FibZdUjG2+uQ1fj1nYdlp1W9oCmxzrUKxupxwhHZiWPjdy+nY/roPcxoqJ/z3xtHdZm+87f+dM/12H98RfChvVD1POjYIqNKa5J4jGisu8gvnyMcPe4Uo4RJc9CSj1GeGNcPY8Rrr6DuFrW6jZZQB1otBzXZh07dgwXX3xx8etHjx5FkyZNavWzQQAVnrZ3vO5qvppMq828HPd/03yxJo5b8fSSedWlZa3LxwhHZlXJrTY1SRvXF2sqmVFFx0Zfq7cm81qOnkLq1PnI2/YNArsmIHb7UgR0aOO2mvTM3NvfQTiue8b1xOf66rJ6e1x311T237aa1lQZ8Y1W586dERoaiq1btxY3WhaLBZ999hl69+6tc3VERETkCbasHKTPXYnMJRthio1B7JJpCLm9T42/EBERuZtPNVr5+fnYsWMHAOD06dPIycnBtm3bAABdu3ZFdHQ0EhMTcebMmeJbtwcEBGD06NFITk5GdHQ0WrdujXXr1iEjIwMjR46sVT08WMtTk0cEkL6YmTzMTJ66lJmy2ZC99hOkvbwU9tx8RD2ViMiHh8EQFOB6ZkHqUmb1BTOTx9OZ+VSjZTab8fjjj5d6zfHfq1atQrdu3Sq88G7UqFFQSmH58uVIS0vDJZdcgmXLlqFZs2a1ronNlhyapjn9fS35HmYmDzOTpy5llr/7F6ROTELRgUMIHdgXMZMfgqlJI73Lcru6lFl9wczk8UZmmqrp/QrruP379wMAEhISdK6EiIiofrOcOAvztAXI/egrBHS+BA1efByBl7fVuywiqkdq0huw9Xai5LNHyPc5bvnp7E6R5FuYmTzMTB7Jmdlz8pCetAaZC96BISocjeZPROjA66HV8Z9oSc6svmJm8ngjMzZaRERE5FOU3Y6cDZ/BPGMR7BnZiHh4KKIeuxuG0GC9SyMiqjI2WkREROQzCn44gNRJSSj8+XeE3HYNYqaOgd8FcXqXRURUbWy0iIiISHfWM+dgnrEIORu3wz/hX2jyQTKCenTUuywiohpjo0VERES6secVIGPBOmQkr4UhJAgNX38OYcP6QTMa9S6NiKhW2Gg5wYsZ5fHz89O7BKomZiYPM5PHFzNTSiFn8xdIm74Q1nNpiBw9CFFPJsIQFqJ3aT7BFzMj55iZPJ7OjI2WC2y25GBW8jAzeZiZPL6YWeG+P5A64Q0UfL8fwf16ocm0sfBr0VTvsnyGL2ZGzjEzebyRGRstF3h7dzmUUrDZbDAajcxMCGYmDzOTx5cys6aYkfbiEmS/sxV+bZojbuPrCL7qcl1r8kW+lBlVDTOTxxuZsdFygs9ylsdut8PI3/WLwszkYWby6J2ZvaAQmYs3IP31VdAC/NFg1jiE33srNBO/hlRG78yo+piZPJ7OjEc4IiIi8gilFHI/+RrmqfNgPXUOESPvRNQz98MYGaZ3aUREHsdGi4iIiNyu8OBhpE5KRsE3PyOoTzfErZ0N/9bN9S6LiMhr2GgRERGR29hS05E2axmyVn8EvxZN0XjtbIT07a53WUREXsdGywlezCgPfxstDzOTh5nJ443MVJEFmcveQ/qclQCAmOljETHyTmh+/KpRE9zP5GFm8ng6Mx79XGCzJYemaTzICcPM5GFm8ng6M6UU8rZ/C/OUebAcO43we29F9HMjYWwQ5bHPrOu4n8nDzOTxRmZstFzg7d3lUEoV58XMZGBm8jAzeTyZWdGffyF1UjLy//M9gq7sjNhlLyCgbSu3fkZ9xP1MHmYmjzcyY6PlBG/vLo/VauWT2YVhZvIwM3ncnZktPQvps5cj863NMDWLReOVLyK435X8gulG3M/kYWbyeDozNlpERERUJcpqRdbKD5H2yjKoIguiJ45C5IODoAX4610aEZHPYaNFRERELuV99QNSJyfD8sdfCBt2E6InjIIpNkbvsoiIfBYbLSIiIqpU0ZGTME9bgLxt3yCwW3vEbl+KgA5t9C6LiMjnsdFygr81l4eZycPM5GFm8tQkM1tWDtLnrkTmko0wxcYgdul0hPS/hvl7CdezPMxMHk9nxkbLBe40cmiaxotQhWFm8jAzeaqbmbLZkL32Y5hfWgqVV4CopxIR+fAwGIICPFgllcT9TB5mJo83MmOjRURERACA/F17kTopGUUHDiF00PWImTQapiaN9C6LiEgkNlou8DlaciilYLVaYTKZmJkQzEweZiZPVTKznDgL87QFyP3oKwR0vgTxWxch8PK23i2UinE/k4eZyeONzGrVaKWlpSE9PR2apiEqKgpRUXXrKfB8jpY8zEweZiYPM5OnsszsOXlIf+NtZC58F4aocDRaMAmhA/pCMxi8XCGVxf1MHmYmj6czq1ajlZeXh23btuGLL77A3r17kZ6eXmp6VFQUOnbsiOuuuw433ngjgoOD3VosERER1Z6y25G9/lOkzVwMe2Y2IscOQ+Sjd8EQyn+3iYjcpUqNVnp6OpYsWYJ33nkHRUVFaNOmDa699lo0a9YM4eHhUEohKysLp06dwsGDBzF58mTMmDEDQ4cOxahRoxAdHe3p5SAiIqIqKPjhAFInJqFw7+8Iue0axEwdA78L4vQui4iozqlSo9WnTx9ceOGFePbZZ3HDDTe4bJzS0tLw6aefYv369Xj33Xfx888/u6VYIiIiqhnrmXNIm7EYOe9th3/Cv9Dkg2QE9eiod1lERHWWpqrw48Svv/4aV155ZY0+oDbz6mn//v0AgHbt2vGiRiGUUsU3L2FmMjAzeZiZPLbcfGTMX4fMeWthCA1G9IQHETasHzSjUe/SqBLcz+RhZvJUNzNHb5CQkFDlz6jSGa3aNEoSm6ySuLPIwYObPMxMHmYmh1IKOZu/QNr0hbCeS0PkQ4MRNe5eGMJC9C6NXOB+Jg8zk8cbmdX69u5FRUXw9/d3Ry0+ibd3l0MpBbvdDoPBwMyEYGbyMDMZCn75L8wTk1Dw/X4E39gLsVMfQkDLC5iZENzP5GFm8ngjsyrfv3Xv3r249tprcf311+M///lP8esPPPCARwrzBbxNpzw2m03vEqiamJk8zMx3WVPMOPfYyzh9/YOwZ+ci7r3X0XjVSzDwZhficD+Th5nJ4+nMqnxG66WXXsK9994LpRSeeeYZPProo0hMTGQzQkREpDN7QSEyF29A+uuroAX4o8Er4xA+/FZoJhP/nSYi0kmVGy2TyYTExEQAQI8ePfDggw/C39+fp0eJiIh0opRC7sc7YZ42H9bT5xAx4k5EPXM/jJFhepdGRFTv1egardatW2P16tVITExEbm6uu2siIiIiFwoPHEbqpCQU7NqL4GuvQNy6V+H/rwv1LouIiP5fla/Ruuyyy3D8+PHi/27WrBlWrlyJFi1aeKQwX8CzdfIYebticZiZPMxMX7bUdJx/6lWcunYkbClmNF73KuLecd5kMTN5mJk8zEweT2dWpedo1Uc1uVc+ERGRp6giCzKXvYf0OSsBDYh6ZgQiRtwBza/WNxAmIiIXPPYcrarIz8/Hxx9/jKKiIlx11VWIj49319C64u3d5Sj5NwNmJgMzk4eZeU5+fj5+++03AMCll16KoKAgAP+s87ztu2GeMh+WY6cRnngbop8bCWNMZJXGZWbyMDN5mJk83sisRo3WhAkT8Ouvv2LLli0A/nmW1uDBg3Ho0CEAQFhYGFauXIlLL73UfZXqgCf75LFYLPDz89O7DKoGZiYPM3Of/Px85OfnAwAyMzOxd+9eAEB0dDQiIiJgOnkOOS8uRf5/vkfQlZ0Ru3wGAi5tWe3PYWbyMDN5mJk8ns6sRo3Wnj17cNtttxX/95YtW3Do0CHMmTMHF198MR599FHMmzcPCxYscFuhREREdc3hw4dx4MABAEBObh5SUs7BZDJi97bP0PzzfYj95iD8LohD45UvIrjflfxLORGRIDVqtFJTU0v9NPDzzz9Hu3btcMsttwAABg8ejGXLlrmnQiIiojqqVatWiI+PR05eEZZs+AZawUm0+O95dP35P9BsdoQ9NwINxw6DFuCvd6lERFRNNWq0goKCkJ2dDQCwWq34/vvvcc899xRPDwkJKZ5OREREFQsKCkJQUBDOZ6dB+/Ew+v/wHSLTc1F001VoPXscTLExepdIREQ1VKNGq23btli/fj26deuGL7/8Erm5uejTp0/x9BMnTiAmRv4/DvyJhjzMTB5mJg8zc5/8/Hzk/H4Efi++ift2/oS/4yLx8bCrce1D9yDLT0NQfn7xTTFqg5nJw8zkYWbyeDqzGjVaTzzxBB544AEMGDAASinccMMNaN++ffH07du3o3Pnzm4rUk/caeTQNI0XoQrDzORhZu5jy8rB8fFzYNz0H1jCg3Fo2FU40CgIRj8TfvrhO+z390e7du1q/ZgRZiYPM5OHmcnjjcxq1GglJCRg69at+PnnnxEeHo6uXbsWT8vKysJdd91V6jUiIiL6h7LZkL3mY5hfXgr/3HwEPDIMgSP6I6iwAOe/+AIA0Lt3b0RERLjlbBYREenD5x5YfOTIEcycORN79+5FSEgI+vfvjyeeeAL+/s4vBE5PT8frr7+OnTt3IiMjA02bNsXdd9+NYcOG1agOx0PJ2rVrx7NaQiilYLVaYTKZmJkQzEweZlY7+bv2InViEooOHkbooOsRM/khmOIa/jOtkudo1RYzk4eZycPM5KluZh57YPHZs2cRFxdX5UFrOm9mZiYSExPRvHlzJCcnIyUlBbNmzUJBQQGmTJnidN7HH38cR48exZNPPom4uDjs3LkT06ZNg9FoxODBg2tUu4/1oFQFzEweZiYPM6s+y/EzME9bgNwtOxBw2aWI37oIgZe3LfWeoKAgXHbZZR75fGYmDzOTh5nJ4+nMqtRo9e3bF7feeiuGDRtW6losZ37++We888472Lp1a3EH6Mo777yD3NxczJs3D5GRkQAAm82G6dOnY/To0YiNja1wvvPnz2PPnj14+eWXceeddwIAunfvjv379+Pjjz+ucaNFRERUG/acPKT/ezUyF62HISocjRZMQuiAvtAMBr1LIyIiD6tSo7V27Vr8+9//xuDBg9GkSRNcccUVaNu2LZo2bYrw8HAopZCVlYVTp07hwIED+O6775CSkoJu3bphzZo1VS5m586d6N69e3GTBQD9+vXD1KlTsWvXruImqiyr1QoACAsLK/V6aGgo8vLyqvz5RERE7qDsdmSv/xRpMxfDnpmNyEeGIfLRu2EI4TVXRET1RZUarfbt22P58uX4/fff8d577+HLL7/Epk2bAPzvrnyOU29xcXG47rrrMGDAAFxyySXVKubo0aMYMGBAqdfCw8PRsGFDHD16tNL54uLi0KtXLyxatAgXXXQRGjdujJ07d2LXrl2YM2dOtWogIiKqjYLv9yN1UjIK9/6OkP59EDN1DPyaNda7LCIi8rJq3XXwkksuwaRJkzBp0iSkpKTg6NGjyMjIAABERkaiRYsWlf68ryqysrIQHh5e7vWIiAhkZmY6nTc5ORnjxo3DzTffDAAwGo2YNGkSbrjhhhrXo2lahb/drOx1xzSg8t98enLe+j6uUgomk4nZ+PC4ZedVSsFoNEIpVeeWta5uhyUzk1CvN8e1nk6B+YVFyNn0Ofzbt0bch8kIuqJD8Xv0WtaymblrXE/U64s16TVu2cx8oSaOW/m4nv4OwnHdX5Pj2Fjyv6s7ris1ur07AMTGxtaqqXInpRSef/55/PXXX3jttdfQsGFD7N69Gy+99BIiIiKKm6+acPws0cFgMMBk+me1WSyWcu933B3RZrPBbreXmua4q4ndbofNZqtwXKVUheM67vNf0bhGo7H4gFy23pLPCLBareU2FE+NW5VlBcqvQ3eM62wdappW7WV1lbke69AxbkU1eSobx7JWtg4d4zpbh3pt387WoTe3b4DHiOosK+A727ezZUVBEXIWb0BG8hpoIUGIeu1phAy6HprRCIvFovsxwpvbN48RpZe1pscIx3oqOy+PEaWXFfC9Y4Tdbi83L79HlF5WXztGlDxWOjtGKKWKm72qqnGj5Qnh4eHIzs4u93pmZiYiIiIqne+rr77Ctm3b8OGHH6JNmzYAgG7dusFsNmPWrFm1arSc3fLR2UPOSm7AZRkMBhgquRC65MZd3XFdzevY8L05rrNlBZyvw+qO6/hHqbJ6S/6VsKbLqkc23lyHrsat7TosO00pVergpcc61CsbqccIR2YGg6F4e6iv27dSCrnvfwHzjEWwnU9H5OhBiHxiOAxhIRXOq9cxwmQylcvMHeN64xhRVn05Rji+7FX2HcSXjxHuHlfKMcLVd5Cq1Fvf12HJ93jjGFH2O4irZa1ukwX4WKPVokWLctdiZWdn4/z582jRokWl8x0+fBhGoxGtW7cu9foll1yCDRs2ID8/v0bPI3Gs+IpWrKuV7Wy6p+bluP/8NcLx1xJfqYnjOp9ut9uLD4p1aVnr8jHCkVnJRssd41Znmt7jFvzyX5gnvIGCHw4g5KYrETNtLPwuivdIvbWZ1zGtbGbuGteX5q1r41aWmZ41cVzn0z35HcTXllWvcd1dk7u+g1TGp+4v27t3b+zevRtZWVnFr23btg0GgwE9e/asdL74+HjYbDb88ccfpV4/ePAgYmJi3PbQRyIiqt+sf6fi3KMv4XTfUbDn5CHuvdfReOVLLpssIiKqf3zqjNbQoUOxevVqjB07FqNHj0ZKSgpmz56NoUOHlroeLDExEWfOnMH27dsB/NOgNWnSBI899hjGjh2LRo0a4ZtvvsH777+PRx99VK/FISKiOsJeUIjMReuR/u/V0AL80WD2kwgffis0Jz81ISKi+s2n/oWIiIjAypUrMWPGDIwdOxYhISEYOHAgxo0bV+p9ZS++Cw0NxYoVK/D6669jzpw5yM7ORtOmTTF+/Hjcc8893l4MIiKqI5RSyN2yA+bpC2A9fQ4RI+9E1NP3wxgZ5npmIiKq1zRV0/sV1nH79+8HALRr167Gv8sk73JciFrZb9rJ9zAzeepTZoUHDiN1UhIKdu1F8LVXIGbGI/D/14V6l1Vt9SmzuoKZycPM5KluZo7eICEhocqfUeVrtI4ePYrExETcf//9OHjwYPHrY8eOrfKHScSdRQ7HHWOYmRzMTJ76kJktNR3nn3oVp64dCdu5NDRe9yri3nlVZJMF1I/M6hpmJg8zk8cbmVW50Zo6dSratGmDVq1a4Z577sGnn34KAKVuXFEX8YSfHI4HczIzOZiZPHU5M1VkQcaCd3Ci6zDkfPAlYl54BM12rEDIdVfoXVqt1OXM6ipmJg8zk8cbmVX5Gq3CwkJMmDABANCnTx+MGzeuznfu3FnkKflwUJKBmclT1zJTSiFv+26YJ8+D5a8zCE/sj+jnRsAYE6l3aW5T1zKrD5iZPMxMHk9nVuVGq+RDvLp3744lS5bg4YcfdvqgMiIiIl9W9McxpE5KRv5XPyCo92WIfWsmAi5tqXdZRERUB1S5S2ratCmOHz9e/N/t27fHggULPFIUERGRJ9nSs3B+/Os4edX9sPx1Bo1XvYS4ja+zySIiIrep8hmtQYMGISys9O1s27dvj507d7q9KCIiIk9QViuyVnyAtFeWQVltiJ70ICJHDYQW4K93aUREVMdU+YzWvffei127dnmyFiIiIo/J+8/3OHn1/Uid8AZCbu6NC/asQ9Qjd7HJIiIij6jyGa36eGMITdPq9M0+6hpN0+Dn58fMBGFm8kjMrOjICZinzEfeZ7sReEUHxG5fioAObfQuy2skZlbfMTN5mJk83sisyo0WkQQ8wMnDzOSRkpktMxvpc1chc+lGmBo3QOybLyDktqvF1O9O9XGZpWNm8jAzeTydWbUarfq4ASml6uVyS8SnssvDzOSRkJmy2ZC95mOYX14KlVeA6KfuQ8TDQ2EICtC7NF1IyIxKY2byMDN5vJFZtRqtZ555Bs8880yV3qtpGn777bcaFeUr6uPPJaWz2+0wGo16l0HVwMzk8eXM8nftRerEJBQdPIzQwTcgZtJomOIa6l2W7nw5M6oYM5OHmcnj6cyq1Wj16NEDzZs391ApRERENWM5fgbmaQuQu2UHAi5vi/htixB4WVu9yyIionqsWo3W7bffjltvvdVTtRAREVWLPScP6f9ejcxF62GIjkCjhZMReud10AxVvqkuERGRR/BmGEREJI6y25H97jakzVwMe1YOIh8ZhshH74YhJEjv0oiIiACw0XKKFzPKYzJxk5aGmcmjd2YF3+9H6sQkFP7yX4Te3gfRU8bAr1ljXWvydXpnRtXHzORhZvJ4OjNuES6w2ZKDzz2Th5nJo2dm1tMpML+wCDmbPod/+9Zo8uE8BHXvoEstknA/k4eZycPM5PFGZlVutP773/96sg6fxdu7y6GUKs6LmcnAzOTRIzN7XgEy5q1Fxry1MISGoOG/xyNsWD9eh1VF3M/kYWbyMDN5vJEZz2g5wdu7y2O1WuHn56d3GVQNzEweb2WmlELO+1/APH0hbKnpiBw9GFHjhsMQFuLxz65ruJ/Jw8zkYWbyeDozNlpERORzCvb+DvPEJBT8cAAhN12JmGlj4XdRvN5lERERVRkbLSIi8hnWv1ORNnMxst/dBv9LWyBu078RfOVlepdFRERUbWy0iIhId/aCQmQufBfp/34bWqA/Grz6FMLvuQUa7+JFRERC8V8wJ3gxozwGXhwvDjOTx52ZKaWQu2UHzNMWwHrmHCJG3omop++HMTLMbZ9B3M8kYmbyMDN5PJ0ZGy0X2GzJoWkan2EhDDOTx52ZFe4/hNRJSSjY/QuCr7sCce+8Cv9/XeiWsel/uJ/Jw8zkYWbyeCMzbhFUp/B2/PIwM3lqm5n1fDrSZ72JrNUfwa/VBYh7Zw6Cr+3mxgqpLO5n8jAzeZiZPJ7OjI2WEyXvr0++TykFi8UCPz8/ZiYEM5OnNpmpIgsy33wP6XNWAAYNMTMfQ8T9t0Pz4z9FnsT9TB5mJg8zk8cbmfFfNyIi8iilFPI+2w3zlHmw/HUG4Yn9Ef3cCBhjIvUujYiIyGPYaBERkccU/fcYUicnI/+rHxDU+zLErngRAZe00LssIiIij2OjRUREbmdLy0Ta7OXIWvEBTM0ao/GqlxB8Yy/+pIaIiOoNNlpEROQ2ymJF1orNSJu9HMpqQ/SkBxE5aiC0AH+9SyMiIvIqNlpO8C+v8vj5+eldAlUTM5OnsszyvtyD1MnJsBw6gbC7b0b086NgahTt5eqoItzP5GFm8jAzeTydGRstF9hsycGs5GFm8lSUWdGREzBPmY+8z3Yj8IoOiP18CgLat9ahOqoI9zN5mJk8zEweb2TGRssF3t5dDqUUbDYbjEYjMxOCmclTMjN7Vg7SX1uJzDffg6lxA8S++QJCbruaWfoY7mfyMDN5mJk83siMjZYTSim9S6BqstvtMBqNepdB1cDM5LFZLMh9ewvSZr0JlV+E6KfvR8SYITAEBehdGlWC+5k8zEweZiaPpzNjo0VERFWWv2svUicmwfLbEYQOvgExk0bDFNdQ77KIiIh8DhstIiJyyfLXGZinLUDuxzvg3/kSNNm6CEGXt9W7LCIiIp/FRouIiCplz8lD+uurkLFoPYwxkWi4YBICbr0K/gH8mSAREZEzbLSc4MWM8vC30fIwM9+k7HZkv7sNaTMXw56Vg6jH7kbkI3dBCw6E3W7XuzyqJu5n8jAzeZiZPJ7OjI2WC2y25NA0jQc5YZiZb8rf8yvMk5JR+Mt/EXp7H0RPGQO/Zo2LpzMzWbifycPM5GFm8ngjMzZaLvD27nIopYrzYmYyMDPfYjmVgrQXFiLn/S8Q0KENmnw0H0FXtC/1HmYmDzOTh5nJw8zk8UZmbLSc4O3d5bFarXwyuzDMTH/2vAJkzFuLjHlrYQgNQcM3xiNsaD9oBkOF72dm8jAzeZiZPMxMHk9nxkaLiKieUkohZ9PnML+wCLbUdESOHoyoccNhCAvRuzQiIiLx2GgREdUR+fn5yM/PBwBkZmZi79696NSpEyIiIgAAQUFBCAoKAgAU7P0dqROTUPjDAYTc3BsxUx+G30XxutVORERU17DRIiKqIw4fPowDBw4AAHJycvD333/DbDYjNDQUANCuXTtc0jAOaTMXI/vdbfBv2xJxm/6N4Csv07NsIiKiOomNlhO8mFEeZiYPM3OfVq1aIT7+n7NSv+zbj7Nnz6Jlq9bo2CEBqrAItrc/wYl570AL8keDOU8j/J5boNXgjkvMTB5mJg8zk4eZyePpzHyu0Tpy5AhmzpyJvXv3IiQkBP3798cTTzwBf39/l/OmpKRg7ty52LFjB/Ly8hAfH48xY8bgtttuq3E93Gnk0DSNF6EKw8zcy/HTwKycQnz5y3kY7cCXe88h4fxPyHtlKaxnziHigQGIevo+GCPCavQZzEweZiYPM5OHmcnjjcx8qtHKzMxEYmIimjdvjuTkZKSkpGDWrFkoKCjAlClTnM577tw5DBkyBBdddBFmzJiB0NBQHDp0CEVFRV6qnojIN5w15+Lk2Wx0ys1GwnvrkfX33wi+7grEvTsH/q0u0Ls8IiKiesGnGq133nkHubm5mDdvHiIjIwEANpsN06dPx+jRoxEbG1vpvK+++ioaN26MN998s/jhY927d691TXyOlhxKKVitVphMJmYmBDPzjFhVhCF7v0frXw4gMyYKESteQoObr3TL2MxMHmYmDzOTh5nJ443MKn5Iik527tyJ7t27FzdZANCvXz/Y7Xbs2rWr0vlycnKwdetW3HXXXW59wjOfoyUPM5OHmblPXmYWzry6DOZrEtHq0GH81LsNMpOfgKF7W6SlpRXfkbC2mJk8zEweZiYPM5PH05n51Bmto0ePYsCAAaVeCw8PR8OGDXH06NFK5zt48CAsFgtMJhPuuece7N27F5GRkbj99tvxxBNP8DezRFSnKaWQ99lunHnuNWhnUnGuV1v8cdWlOJWVgay/jiAlNQXAP3cdTEhI0LlaIiKi+sGnGq2srCyEh4eXez0iIgKZmZmVzpeamgoAmDRpEgYPHoxHHnkEv/76K5KSkmAwGPDUU0/VuKaKOl1N0yrtgB2nHp1N99S89X1cx2vMxnfHLTuvUqr4f3VtWb21Dov+ewzmycnI3/EjAnt1QsDCSYhqfSEal3mOlqZpCAwMrPSYVtWaSmbm6WWVNq4v1lQyr5Lv89V6fbEmPcf19ncQjlvzcT39HYTjur+msvtYTcZ1xacarZqy2+0AgB49emD8+PEAgCuuuAK5ublYvnw5xo4di8DAwBqNbbFYSv1u02AwwGQyFU8ry3F3RJvNVlyXg+M3oHa7HTabrdQ0x7hKqQrHdZyVq2hco9EIo9EIpf75rWlJJe+oYrVay20onhq3KssKlF+HtRm3ZE6VrUNN06q9rK4y12MdOsatqCZPZeNY1srWoWNcZ+uw7PbteK+nt29n69Cb2zfgvmOELS0TWa+tRM7qj2BqFofYVS8h5MZexeOGhYWhadOmpZbVbrdXe3spm03J9WUymUQdI2qzfUs/RjjG1jRN1DGi5LhA/TtGOD6rOuPye4Q+27fB8M/VOFKPEe4aV9IxQilVqn5Xxwilqn/fBp9qtMLDw5GdnV3u9czMTERERDidD/inuSqpe/fuWLRoEY4fP442bdpUux7HhlbZSnX2k8SSG3BZBoOheIes7DNrMq6reR0bvjfHdbasgPN1WN1xHTuAUqrCcR051mZZ9cjGm+vQ1bi1XYdlp5XNSo91qFc2NT1GwGpD3ooPkP7qW1A2O6InjUbEAwOgBfhD0zSPHyNKZubYHrh9Ox/XQc9jRNnM3DVuWe4+RpRVn44Rjj8QV/QdhN8j/sdXjhFKqXLHyOrWW9/XYcn3eOMYUTYrV8ta3SYL8LFGq0WLFuWuxcrOzsb58+fRokWLSudr1aqV03ELCwtrXJOzA5kzzqZ7at76Pm7JL33uHNcd83LciqeXfW9dWlZPjJv35R6kTk6G5dAJhN19M6KfHwVTo2iv1uRs36vNuNWd5ovj+mJNjjNYnhjXmbq2Dr09bm1y81RNHNf5dE9/B+G47q/Jnd9BKuNTdx3s3bs3du/ejaysrOLXtm3bBoPBgJ49e1Y6X3x8PFq3bo3du3eXen337t0IDAx02Yg5U9PfZJL3OU4BMzM5mFnVFB05gbN3PYuzQ56GMSYSTT9/E41ef65ck+UNzEweZiYPM5OHmcnjjcx8qtEaOnQoQkJCMHbsWHzzzTd47733MHv2bAwdOrTUM7QSExPRt2/fUvOOGzcOX375JV588UXs2rULixYtwvLly3HfffchODi4RvVwZ5Gn7G+Fyfcxs8rZMrOROjkZJ3vdi6I//kLsshfQ5INkBLRvrW9dzEwcZiYPM5OHmcnj6cx86qeDERERWLlyJWbMmIGxY8ciJCQEAwcOxLhx40q9r6KL7/r06YO5c+diwYIFWLduHRo1aoRHH30UDz74oDcXgYio1pTNhqy3tyDt5aVQ+UWIfnYEIsYMgSEwQO/SiIiIqIo0xdM2Fdq/fz+UUkhISKjx7zLJuxx3onF2AxPyLcysvPxvfkbqpCQUHTyC0ME3ImbyaJgaN9C7rGLMTB5mJg8zk4eZyVPdzPbv3w8A1XoepU+d0SIiqq8sf52BedoC5H68AwGXt0X8p4sR2PlSvcsiIiKiGmKj5QT/IiFPZbf0JN9V3zOz5+Qh/fVVyFi0HsaYSDRaOBmhA/r69PGnvmcmETOTh5nJw8zk8XRmbLRc8OUvO1Sapmk8yAlTnzNTdjuy39mKtBeXwJ6Vg6jH7kbkI3fBEBKkd2lO1efMpGJm8jAzeZiZPN7IjI2WCzV5CjTpQylVnBczk6G+Zpa/51eYJyahcN8fCL3jWkRPGQO/prGuZ/QB9TUzyZiZPMxMHmYmjzcyY6PlBO8TIo/VanX6xHDyPfUpM8upFKS9sBA573+BgA5t0OSj+Qi6or3eZVVbfcqsrmBm8jAzeZiZPJ7OjI0WEZGH2XPzkTFvLTLmr4MhLAQN3xiPsKH9oBl86lGGRERE5EZstIiIPEQphZz3tsP8wiLYzBmIfGgwosbdC0NozR6iTkRERHKw0SIi8oCCvb8jdWISCn84gJCbeyNm2lj4NW+id1lERETkJWy0nODFjPIwM3nqWmbWv1NhnrEYOeu3wb9tSzR5/w0E9eqsd1luVdcyqw+YmTzMTB5mJo+nM2Oj5QJ3Gjk0TeNFqMLUpczs+YXIXPgu0t94G1qQPxrMeRrh99wCrY7d7rcuZVZfMDN5mJk8zEweb2TGRouIqBaUUsj96CuYpy2A9ex5RIwaiKinEmGMCNO7NCIiItIRGy0X+BwtOZRSsFqtMJlMzEwI6ZkV7j+E1IlvoODbfQju2x1x61+Df6sL9C7Lo6RnVh8xM3mYmTzMTB5vZMZGywk+R0seZiaPxMys59OR9vJSZL+9BX7/ugBx785BcJ9uepflNRIzq++YmTzMTB5mJo+nM2OjRURURarIgsylG5H+2krAaECDFx9D+H23Q/PjoZSIiIhK47cDIiIXlFLI+3QXzFPmw3LiLMIT+yP6uREwRkfoXRoRERH5KDZaREROFP5+FObJycjf8SOCru6Cxqtegv/FF+ldFhEREfk4NlpO8GJGeUwmbtLS+GpmtrRMpL2yHFkrP4DfBXFo/PYsBF/fg8cF+G5mVDlmJg8zk4eZyePpzLhFuMAvVXJomsa8hPHFzJTFisy3NiP91eWAzY6YKQ8h4oEB0Pz5fBTANzMj55iZPMxMHmYmjzcyY6PlAm/vLodSCna7HQaDgZkJ4WuZ5X2xB6lTkmE5dAJh99yC6OdHwdQwSu+yfIqvZUauMTN5mJk8zEweb2TGRssJ3qZTHpvNBoPBoHcZVA2+kFnR4RMwT5mHvO3fIrB7B8QunIKA9q11rcmX+UJmVD3MTB5mJg8zk8fTmbHRIqJ6y5aZjfQ5K5D55nswNWmE2GUvIOTWq/nXSCIiIqo1NlpEVO8omw1Zqz9C2qw3ofKLEP3sCESMGQJDYIDepREREVEdwUaLiOqVvK9/gnlSEop+O4qwITcietJomBo30LssIiIiqmPYaDnBnw/Jw99Gy+OtzCx/nYF52nzkfrwTAV3aIf7TxQjsfKlXPruu4X4mDzOTh5nJw8zk8XRmbLRcYLMlh6ZpfIaFMN7IzJ6Th/S5q5CxeD2MDaLQaNEUhN55HfftGuJ+Jg8zk4eZycPM5PFGZtwiXODt3eUoeZdIZiaDJzNTdjuy121F2otLYM/JRdTj9yBy7DAYQoLc+jn1DfczeZiZPMxMHmYmjzcyY6PlBG/vLo/FYoGfHx8sK4knMsv/7leYJyWhcN8fCL3jWkRPGQO/prFu/Yz6jPuZPMxMHmYmDzOTx9OZsdEiojrDcioFadMXIGfzlwjo0AZNtsxHULf2epdFRERE9RAbLSISz56bj4zkNciYvw6G8FA0THoeYUNuhMYLk4mIiEgnbLSISCylFHLe2w7zC4tgM2cgcswQRD0xHIbQYL1LIyIionqOjRYRiVTw829InZiEwh8PIuTmqxAz7WH4NW+id1lEREREANhoOaVpGu8cI4imafD399e7DKqGmmRm/TsV5hmLkbN+G/zbtkST999AUK/OHqqQyuJ+Jg8zk4eZycPM5PFGZmy0iEgEe34hMhe+i/Q33oYW5I8Gc55G+D23QDMa9S6NiIiIqBw2Wi7wOVpyKKVgs9lgNBqZmRBVyUwphdwPv4J5+gJYz55HxKiBiHoqEcaIMC9XSwD3M4mYmTzMTB5mJo83MmOj5QSfoyWP3W6HkWc4RHGWWeGvfyJ1UhIKvt2H4Ot7IG7Da/BveYGXK6SyuJ/Jw8zkYWbyMDN5PJ0ZGy0i8jnWc2lIe3kpstd8DL9/XYC4d+cguE83vcsiIiIiqjI2WkTkM1RhETKWbkT6ayuhmYxo8OJjCL/vdmh+PFQRERGRLPz2QkS6U0ohb9s3SJ0yH9aTfyP8vv6IfnYEjNERepdGREREVCNstJzgxYzymEzcpKWxHzqBv6fMR/7OHxF0dRfErX4Z/hdfpHdZ5AT3M3mYmTzMTB5mJo+nM+MW4QKbLTn43DNZbGmZSJu1DFkrP4Bf8yZo/PYsBF/fgxn6OO5n8jAzeZiZPMxMHm9kxkbLBd7eXQ6lFOx2OwwGAzPzYcpiReby95H+6nIou0LU5NGIHDUQhgA+6FEC7mfyMDN5mJk8zEweb2TGRssJ3t5dHpvNBoPBoHcZVIm8L/YgdXIyLIdPIHz4rYh6biTskaHQ/Pz0Lo2qgfuZPMxMHmYmDzOTx9OZsdEiIo8rOnwC5snJyPv8OwT26IjYxVMRkPCvf/6aZLHoXR4RERGR27HRIiKPsWVkI33OW8hctgmmJo0Qu3wGQm65ij+rICIiojrP585vHjlyBPfffz86duyInj17Yvbs2SgqKqrWGCtWrECbNm0wevRoD1VJRM4oqxWZKzbjRLdhyFq9BdHPjUSzXasReuvVbLKIiIioXvCpM1qZmZlITExE8+bNkZycjJSUFMyaNQsFBQWYMmVKlcY4f/485s+fj5iYmFrXwy+E8vC30frL+/onmCcloei3owgbciOiJ42GqXGDSt/PzORhZvIwM3mYmTzMTB5PZ+ZTjdY777yD3NxczJs3D5GRkQD+uUht+vTpGD16NGJjY12O8eqrr6JPnz44c+aMW2pisyWHpml8hoWOLMdOwzxtPnI/+RoBXdoh/rMlCOx0idN5mJk8zEweZiYPM5OHmcnjjcx8qvXeuXMnunfvXtxkAUC/fv1gt9uxa9cul/P/+OOP+Pzzz/HUU095sEryZbxTpPfZs3NhfmERTvQajoJf/kCjRVMQ//ECl02WAzOTh5nJw8zkYWbyMDN5PJ2ZTzVaR48eRYsWLUq9Fh4ejoYNG+Lo0aNO57XZbJgxYwYeeughNGrUyC31KKW40wiilILFYmFmXqLsdmSt+Rgnut2FzDc3Iurxe3DBt2sQNqBvlc8EMzN5mJk8zEweZiYPM5PHG5n51DnOrKwshIeHl3s9IiICmZmZTuddu3Yt8vPzcd9997m1popWvqZplYbi+ILpbLqn5q3v4zpeYzaeHzf/231InZSEol//RMid1yFm8miY4mOrXZPjjxmOB4P74rL62rh611QyMwn1enNcX6ypZF4l3+er9fpiTXqO6+3vIBy35uN6+jsIx3V/TWX3sZqM64pPNVo1ZTabkZSUhFdeeQX+/v5uHdtisZT667zBYCj+Paelguf/OD7fZrPBbreXmmYymaBpGux2O2w2W6lpjnEd3XVZfv//QNeKxjUajTAajVBKwWq1lpqmaVrxvFartdyG4qlxq7KsQPl1WJtxS+ZU2TrUNK3ay+oqcz3WoWPcimryVDYAoKWkIe2FhcjZ/CX82rdGo81vIKBLOyigVLNU2Tosu3073uvp7dvZOvTm9g3IP0aUHMNkMok6RlRlX66rxwjH2Jqm6bYOHeNW5xhRclyg/h0jHJ9VnXH1Pka4a1xpxwjHTRWkHiPcNa6kY4RSqlT9ro4Rju851eFTjVZ4eDiys7PLvZ6ZmYmIiIhK53vjjTfQpk0bXH755cjKygLwz8qyWq3IyspCcHBwjS92c2wQlU2rTMkNuCyDwVDpXU5KbtzVHdfVvM7WgafGdbasgPN1WN1xS+5AFY3ryLE2y6pHNt5ch5WNa8/NR0byWmQuWAdDeCgaJj2P0ME3QKtgfmfLWnZa2QOaHutQr2ykHiMcmZU8Nkrfvh3q+jGion/PfG0d6rV9++oxorLvIL58jHD3uFKOEUop2O120ccIb4zrS8eIihrIyhgMhmo3WYCPNVotWrQody1WdnY2zp8/X+7arZKOHTuGH374AV26dCk3rUuXLli6dCl69+5do5ocf/2r6HVX89VkWm3m5bj/m+aLNUkcV9ntyHlvO8wzFsOelomIhwYj6onhMIQGu62mknnVxXXoS/O6a1xHZlXJrTY1SRvXF2sqmVFFx0Zfq9cXa9JzXG9/B+G47hnXE5/rq8vq7XHdXVPZf9tqWlNlfKrR6t27NxYtWlTqWq1t27bBYDCgZ8+elc43YcKE4jNZDi+99BICAwPx5JNPok2bNjWqp6YrlfTj7K8cVD0FP/+G1IlJKPzxIEJuuQox0x6G34VN3P45zEweZiYPM5OHmcnDzOTxdGY+1WgNHToUq1evxtixYzF69GikpKRg9uzZGDp0aKlnaCUmJuLMmTPYvn07AOCSS8rfRjo8PBzBwcHo1q1brWpisyUHs3IP69nzMM9cjJz1n8K/bUs02ZyEoJ6dPPJZzEweZiYPM5OHmcnDzOTxRmY+1WhFRERg5cqVmDFjBsaOHYuQkBAMHDgQ48aNK/W+ii6+85SaXPhG+nBc1Gg0GplZDdjzC5G54B2kJ70NLTgQDV97BmF33wytkt86uwMzk4eZycPM5GFm8jAzebyRmaZqer/COm7//v1QSiEhIYE7jBCOO9E4u4EJlaeUQu6HX8E8fQGsZ88j4sFBiHoqEcbwUK98NjOThZnJw8zkYWbyMDN5qpvZ/v37AQAJCQlV/gyfOqNFRN5V+OufSJ2YhILv9iH4+h6I2/Aa/FteoHdZREREROKx0SKqh6zn0pD20hJkr/0Efq0vRNz61xB8TVe9yyIiIiKqM9hoEdUjqrAIGUs3Iv21ldBMRjR46XGE39cfWg2fM0dEREREFeO3Kyf4G1t5KntIXX2nlELetm+QOmU+rCf/Rvh9/RH97AgYoyt/ELi3MDN5mJk8zEweZiYPM5PH05mx0XKBzZYcmqbxIFeBwt+PwjwpCfk7f0LQ1V0Qt/pl+F98kd5lAWBmEjEzeZiZPMxMHmYmjzcyY6PlAm/vLodSqjgvZgbYzBlIe2U5slZ+AL/mTdB4zSwE9+3hU+uGmcnDzORhZvIwM3mYmTzeyIyNlhO88708Vqu13j+ZXVmsyFz+PtJfXQ7YFWKmjUHEyAHQ/H1zvTAzeZiZPMxMHmYmDzOTx9OZsdEiqkNyP/8O5inzYDl8AuHDb0XU+Adgahild1lERERE9Q4bLaI6oOjQcZgnz0PeF98hsGcnxC6ZhoB2rfQui4iIiKjeYqNFJJgtIxvpc95C5rJNMDVphNjlMxByy1X8fTgRERGRzthoOcEvq/LUl8yU1Yqs1R8hbdYyqIIiRD83EhEPDYYhMEDv0qqtvmRWlzAzeZiZPMxMHmYmj6czY6PlAncaOTRNqxcXoebt/BHmScko+v0owob2Q/TEB2Fq3EDvsmqkvmRWlzAzeZiZPMxMHmYmjzcyY6NFJITl2GmYp81H7idfI7BLO8R/tgSBnS7RuywiIiIiqgAbLRf4HC05lFKwWq0wmUx1KjN7di7SX1+FjMUbYGwQhUaLpyL0jmvrxDLW1czqMmYmDzOTh5nJw8zk8UZmbLSc4HO05KlLmSmbDdnrtiLtpaWw5+Qi6onhiBw7DIbgQL1Lc6u6lFl9wczkYWbyMDN5mJk8ns6MjRaRD8r/dh9SJyWh6Nc/EXrndYiZ8hBM8bF6l0VEREREVcRGi8iHWE7+DfP0hcj94EsEdLwY8R8vQGDXBL3LIiIiIqJqYqNF5APsufnISFqDjAXrYIgIQ8PkCQgbfAM0g0Hv0oiIiIioBthoOcGLGeWRdmtVZbcj573tML+wCPb0LESMGYKox++BITRY79K8RlpmxMwkYmbyMDN5mJk8vL27zthsySEtq4KfDiJ1YhIKf/oNIbdchZhpD8PvwiZ6l+VV0jIjZiYRM5OHmcnDzOTxRmZstFzg7d3lUErBZrPBaDT6dGbWs+dhnrEIORs+g3/bVmiyOQlBPTvpXZYupGRG/8PM5GFm8jAzeZiZPN7IjI2WE7xNpzx2ux1Go1HvMipkzy9E5oJ3kJ70NrTgQDR87RmE3X0zNB+t11t8OTOqGDOTh5nJw8zkYWbyeDozNlpEHqaUQu4H/4H5hYWw/p2KiFEDEfVUIozhoXqXRkREREQewkaLyIMK9/2B1EnJKPhuH4Jv6Im4DXPh37KZ3mURERERkYex0SLyAOu5NKS9tATZaz+BX+sLEbf+NQRf01XvsoiIiIjIS9hoOcGLGeXR+7fRqrAIGUs2IH3uKmh+JjR46XGE39cfmom7WmX0zoyqj5nJw8zkYWbyMDN5PJ0Zv/25wGZLDk3TdDvIKaWQt/VrpE5dAOvJvxFx/+2IenYEjFHhutQjhZ6ZUc0wM3mYmTzMTB5mJo83MmOj5QJv7y6HUqo4L29mVvjbEZgnJyN/508IuroL4t5+Gf5tLvLa50umV2ZUc8xMHmYmDzOTh5nJ443M2Gg5wdu7y2O1Wr32ZHabOQNpryxD1soP4de8CRqvmYXgvj14gK0mb2ZG7sHM5GFm8jAzeZiZPJ7OjI0WUTUpixWZyzYhfc5bgAJipo1BxMgB0Px5cCUiIiKif7DRIqqG3M+/g3lyMixHTyF8+K2IHj8SxgZRepdFRERERD6GjRZRFRQdOg7z5HnI++I7BPbshNil0xHQrpXeZRERERGRj2Kj5QSvtZHH3ZnZMrKR/upbyFy+Cab4Roh9ayZCbu7NbcONuC7lYWbyMDN5mJk8zEweT2fGRssF7jRyaJrmtgsaldWKrNUfIW3WMqjCIkSPfwARowfBEBjglvHpH+7MjLyDmcnDzORhZvIwM3m8kRkbLaIy8nb+CPOkZBT9fhRhQ/sheuKDMDVuoHdZRERERCQIGy0X+BwtOZRSsFqtMJlMNcrMcvQUUqfNR97WbxDYpR3ity9FYMeLPVApOdQ2M/I+ZiYPM5OHmcnDzOTxRmZstJzgc7TkqUlm9uxcpM9diYwlG2FqGIVGS6Yi9PZreaD0Eu5n8jAzeZiZPMxMHmYmj6czY6NF9Zay2ZC9bivSXloCe04eosYNR+TDw2AIDtS7NCIiIiISjo0W1Uv53+5D6sQ3ULT/EEIH9EXM5NEwxcfqXRYRERER1RFstKhesZz8G+bpC5H7wZcI6Hgx4j9egMCuCXqXRURERER1DBstJ3iNjjwmU8WbtD0nDxnJa5GxYB0MEWFomDwBYYNvgGYweLlCKquyzMh3MTN5mJk8zEweZiaPpzPjFuECmy05NE0rl5ey25Gz8TOYZyyGPT0LEWOGIOrxe2AIDdapSiqposzItzEzeZiZPMxMHmYmjzcyY6PlAm/vLodSCna7HQaDAZqmoeDHg0idlITCn35DyK1XI2bqGPhd2ETvMqmEspmR72Nm8jAzeZiZPMxMHm9kxkbLCd6mUx6bzQZ7ihlpMxcjZ8Nn8G/bCk02JyGoZye9S6NK2Gw2GPgTTlGYmTzMTB5mJg8zk8fTmflco3XkyBHMnDkTe/fuRUhICPr3748nnngC/v7+lc5z7tw5rFixArt27cKJEycQFhaGLl264Mknn0R8fLwXqyc92fMLkZm8BtkL3oEWHIiGc59B2F03QzMa9S6NiIiIiOoZn2q0MjMzkZiYiObNmyM5ORkpKSmYNWsWCgoKMGXKlErnO3jwILZv344BAwagQ4cOSE9Px8KFCzFo0CBs2bIF0dHRXlwK8jalFHI3fwnzCwthTTEjYtRARD2VCGN4qN6lEREREVE95VON1jvvvIPc3FzMmzcPkZGRAP45pTd9+nSMHj0asbEVP+fosssuw9atW0vdOaRz5864+uqrsXnzZowYMcIb5ZMOCvf9gdSJSSjY8yuCb+iBButmI7jNRfx9NBERERHpyqd+SLpz50507969uMkCgH79+sFut2PXrl2VzhceHl7u9oyNGzdGdHQ0zp07V+N6+GXdd1lTzDj3+Cyc6jsKtowsxG2Yi8arZyGg1QV6l0bVxN+zy8PM5GFm8jAzeZiZPJ7OzKfOaB09ehQDBgwo9Vp4eDgaNmyIo0ePVmusY8eOwWw2o2XLlrWuq+xNMTRNq/RGGY7mzNl0T81bH8ZVhUXIXLIR6a+vguZnQsxLjyM88TZo/99om0wmKKUqnJfZ6D9uRfMaS1xDV5eWtS4fIxyZOe7K6uv1emtcX6zJMa1kZr5cry/WpMe4mqaVy0zvmjiu63E9+R3E15a1rhwjjEZjrcZ1xacaraysLISHh5d7PSIiApmZmVUeRymFmTNnolGjRrj55ptrVVNRUVGpM1sGg6H47JnFYin3fsdNO2w2G+x2e6lpJpMJmqbBbrfDZrOVmuYYVylV4bh+fn6Vjms0GmE0GqGUgtVqLTVN07Tiea1Wa7kNxVPjVmVZgfLrsLJxlVLI/3QXMl9YDOupFITdfzvCnrgHxqhwWJUCLBZomla8DsvW61hWTdOqvayuMtdjHTrGrc46rMq4VVnWytahY1xn67Ds9u2orabZVHX7drYOvbl9A/KPESWnm0wmnzlG1HZcx7LWxWNEUVFRqTElHSNKjgt4bvv2tWOE4zPtdnup7yASjhHuGlfaMcJgMMBoNNZ4XIDfI7x9jHD8sdBRk6tjhOP91eFTjZa7JCcn47vvvsObb76J4OCaP5hWKVW88iviWPkVKbkBl2UwGCo9VVly467uuK7mdfb0a0+N62xZAefr0DFu0W9HkDo5GQVf/4yga7oibs0s+LVuXu79jp3PZDJVOK4jx9osqx7ZuGMdumvc2q7DstPKHjD1WId6ZSP1GOHIrOSxkdu383Ed9DxGlM3MXeOW5e5jRFn16Rhht9sr/Q7iy8cId48r5Rjh6jtIVeqt7+uw5Hu8cYwo+x3E1bJWt8kCfKzRCg8PR3Z2drnXMzMzERERUaUx1q9fj/nz5+PFF19E9+7da12T469/Fb3uar6aTKvNvHVtXHtaJtJeWYaslR/C76J4NF7zCoL7dq9SPdKWtb6MW9H0knnVpWWty8cIR2ZVya02NUkb1xdrKplRRcdGX6vXF2vSc1xvfwfhuO4Z1xOf66vL6u1x3V1T2X/balpTZXyq0WrRokW5a7Gys7Nx/vx5tGjRwuX827dvx7Rp0/DYY49h4MCBniqTPExZrMhctgnpc94CFBAzbQwiRg6A5l/5XzCIiIiIiHyJTzVavXv3xqJFi0pdq7Vt2zYYDAb07NnT6bx79uzBk08+iUGDBmHs2LHeKJc8IHf7tzBPmQfL0VMIH34rosePhLFBlN5lERERERFVi081WkOHDsXq1asxduxYjB49GikpKZg9ezaGDh1a6hlaiYmJOHPmDLZv3w4AOHLkCMaOHYvmzZujf//++OWXX4rfGx0djQsuqNktv2t6mpCqr+jPv5A6eR7yv9yDwF6dEfvmdAS0bVXtcZiZPMxMHmYmDzOTh5nJw8zk8XRmPtVoRUREYOXKlZgxYwbGjh2LkJAQDBw4EOPGjSv1vrJ3Odm3bx+ys7ORnZ2NYcOGlXrvHXfcgVmzZtW4Ju40nmXLyEb6q28hc/kmmJrGInbFiwi56coarXdNc36BJPkeZiYPM5OHmcnDzORhZvJ4IzNN1fTG8HXc/v37AQAJCQk6V1I3KasVWas+Qtory6AKixA17l5EjB4EQ2CA3qUREREREZVSk97Ap85o+aKa3DOfnMvb8SPMk5NR9N9jCBvaD9ETRsHUuEGtx3U8H8HxHAbyfcxMHmYmDzOTh5nJw8zk8UZmbLSc4Mk+97IcPYXUafORt/UbBHZNQPxnSxDY8WK3fgYzk4eZycPM5GFm8jAzeZiZPJ7OjI0WeZw9Oxfpc1ciY/EGmBpFo9GSqQi9/Vr+xYeIiIiI6iw2WuQxymZD9tpPkPbyUthz8hD15L2IfHgYDMGBepdGRERERORRbLTII/J3/4LUSUko2n8IoQP7ImbyQzA1aaR3WUREREREXsFGywn+tK36LCfOwjx9IXI//A8COl2C+E8WIrBLO699vsnETVoaZiYPM5OHmcnDzORhZvJ4OjNuES6w2aoae04e0pPWIHPBOzBEhqHRvIkIHXQ9NIPBazVomsa8hGFm8jAzeZiZPMxMHmYmjzcyY6PlAm/v7pyy25Gz8TOYZyyGPT0LEQ8PRdRjd8MQGuz9WpSC3W6HwWBgZkIwM3mYmTzMTB5mJg8zk8cbmbHRcoK36XSu4MeDSJ34Bgp//h0ht16NmKlj4HdhE11rstlsMHjxLBrVHjOTh5nJw8zkYWbyMDN5PJ0ZGy2qNuuZczDPWIScjdvh3+5faLI5CUE9O+ldFhERERGRz2CjRVVmzytAxoJ1yEheC0NIEBrOfRZhd90EzWjUuzQiIiIiIp/CRotcUkohd/OXML+wENYUMyIeHIioJxNhDA/VuzQiIiIiIp/ERssJXswIFO77A6kTk1Cw51cE39gLcRtfh3/LZnqXVSn+NloeZiYPM5OHmcnDzORhZvJ4OjM2Wi7U12bLmmJG2ktLkb3uE/i1aY64DXMRfHUXvctyStM0PsNCGGYmDzOTh5nJw8zkYWbyeCMzbhEu1Lfbu6vCImQs3oD011dB8zOhwctPIDzxNmgCDh4l7xJZnzKTjJnJw8zkYWbyMDN5mJk83sjM978966g+3d5dKYXcT76Gedp8WE+mIGLEHYh65n4Yo8L1Lq1aLBYL/Pz89C6DqoGZycPM5GFm8jAzeZiZPJ7OjI0WofDgYaROSkbBNz8j6JquiFvzCvxbN9e7LCIiIiIisdho1WO21HSkvbIMWas+gt9F8Wi85hUE9+3OU95ERERERLXERqseUkUWZC7fhPRXVwAAYqY/jIgRd0Lz5+luIiIiIiJ3YKNVz+Ru/xbmycmwHDuN8HtvRfRzI2FsEKV3WUREREREdQobLSc0TaszP6Mr+vMvpE6eh/wv9yCwV2fELnsBAW1b6V2WW2maBj8/vzqTWX3AzORhZvIwM3mYmTzMTB5vZMZGq46zZWQjffZyZC5/H6ZmsYhd8SJCbrqyzh4I6upy1WXMTB5mJg8zk4eZycPM5PF0Zmy0XJD6HC1ltSJr5YdIe2UZVJEF0RNGIeLBgTAEBuhdmscopWCz2WA0GkVmVh8xM3mYmTzMTB5mJg8zk8cbmbHRckLqc7TydvyI1ElJsPzxF8KG3YToCaNgio3RuyyvsNvtMBqNepdB1cDM5GFm8jAzeZiZPMxMHk9nxkarDrEcPYXUqfORt+0bBHZNQOz2pQjo0EbvsoiIiIiI6h02WnWALSsH6XNXInPJRphiYxC7ZBpCbu/DU9dERERERDphoyWYstmQvfYTpL28FPbcfEQ9lYjIh4fBEFR3r8MiIiIiIpKAjZYTvnxGKH/3L0idmISiA4cQOrAvYiY/BFOTRnqXpTv+NloeZiYPM5OHmcnDzORhZvJ4OjM2Wi74WrNlOXEW5mkLkPvRVwjofAnity5C4OVt9S7LJ2iaxoOcMMxMHmYmDzOTh5nJw8zk8UZmbLRc8JXbu9tz8pCetAaZC96BITIMjeZNROig66EZDHqX5jOUUsV5+UJm5Bozk4eZycPM5GFm8jAzebyRGRstJ3zh9u7KbkfOhs9gnrEI9oxsRDw8FFGP3Q1DaLDepfkkq9UKPz8/vcugamBm8jAzeZiZPMxMHmYmj6czY6Plwwp+OIDUSUko/Pl3hNx2DWKmjoHfBXF6l0VERERERC6w0fJB1jPnYJ6xCDkbt8O/3b/Q5INkBPXoqHdZRERERERURWy0fIg9rwAZC9YhI3ktDCFBaDj3WYTddRM0XlxJRERERCQKGy0nvHUxo1IKOZu/QNr0hbCeS0Pk6EGIejIRhrAQr3x+XWLgzUHEYWbyMDN5mJk8zEweZiaPpzNjo+WCp5utwn1/IHXCGyj4fj+C+/VCk2lj4deiqUc/s67SNA0mEzdpSZiZPMxMHmYmDzOTh5nJ443MuEXoxJpiRtqLS5D9zlb4tWmOuI2vI/iqy/Uui4iIiIiI3ICNlhMl76/vLvaCQmQu3oD011dBC/BHg1njEH7vrdD4V5BaU0rBYrHAz8+Pz7AQgpnJw8zkYWbyMDN5mJk83siM3+69RCmF3E++hnnqPFhPnUPEyDsR9cz9MEaG6V0aERERERG5GRstLyg8eBipk5JR8M3PCOrTDXFrZ8O/dXO9yyIiIiIiIg9ho+VBttR0pM1ahqzVH8GvRVM0XjsbIX27610WERERERF5GBstD1BFFmQu34T0V1cAAGKmj0XEiDug+fvpWxgREREREXkFGy0nqnthnFIKedu/hXnKPFiOnUb4vbci+rmRMDaI8lCFVJafH5tZaZiZPMxMHmYmDzOTh5nJ4+nMfO7JakeOHMH999+Pjh07omfPnpg9ezaKiopczqeUwpIlS3D11Vejffv2GDJkCH755Zda11PVZqvoz79wdsjT+Pvu52Bq0hBNv1yGhq8+zSbLizRNK/4fycDM5GFm8jAzeZiZPMxMHm9k5lONVmZmJhITE2GxWJCcnIxx48Zh/fr1mDVrlst5ly5diqSkJNx3331YvHgxGjZsiBEjRuDkyZO1qkkp5XS6LT0LqRPewMne98Fy7BQar3wRce/9GwFtW9Xqc6n6lFKwWq0uMyPfwczkYWbyMDN5mJk8zEweb2TmUz8dfOedd5Cbm4t58+YhMjISAGCz2TB9+nSMHj0asbGxFc5XWFiIxYsXY8SIEbjvvvsAAJdddhluvPFGLFu2DNOmTatRPc5WvLJakbXyQ6S9sgyqyILoCaMQOXoQtAD/Gn0WuYfdbofRaNS7DKoGZiYPM5OHmcnDzORhZvJ4OjOfOqO1c+dOdO/evbjJAoB+/frBbrdj165dlc73888/IycnB/369St+zd/fH3379sXOnTvdXmfeVz/g5DUjkPr8vxHS70pcsGcdoh67m00WEREREREB8LFG6+jRo2jRokWp18LDw9GwYUMcPXrU6XwAys3bsmVLnDlzBgUFBW6pr+jISZwd/jzODnoSxogwNN2+FI3eGA9TbIxbxiciIiIiorrBp346mJWVhfDw8HKvR0REIDMz0+l8/v7+CAgIKPV6eHg4lFLIzMxEYGBgtWqxWCxQSuHAgQNATj783t4K06b/QEVHwDJ5BPKuvgxpWhGwf3+1xiXPUkrxQlRhmJk8zEweZiYPM5OHmclTncyKioqqna9PNVq+pNSKDA2C5aE7YXnoTv0KoirhAU4eZiYPM5OHmcnDzORhZvJUJ7Oa3KHQpxqt8PBwZGdnl3s9MzMTERERTucrKipCYWFhqbNaWVlZ0DTN6byV6dSpU7XnISIiIiIiAnzsGq0WLVqUuxYrOzsb58+fL3f9Vdn5AODYsWOlXj969CiaNGlS7Z8NEhERERER1YZPNVq9e/fG7t27kZWVVfzatm3bYDAY0LNnz0rn69y5M0JDQ7F169bi1ywWCz777DP07t3bozUTERERERGV5VM/HRw6dChWr16NsWPHYvTo0UhJScHs2bMxdOjQUs/QSkxMxJkzZ7B9+3YAQEBAAEaPHo3k5GRER0ejdevWWLduHTIyMjBy5Ei9FoeIiIiIiOopn2q0IiIisHLlSsyYMQNjx45FSEgIBg4ciHHjxpV6n91uh81mK/XaqFGjoJTC8uXLkZaWhksuuQTLli1Ds2bNvLkIRERERERE0JRSSu8iiIiIiIiI6hKfukaLiIiIiIioLmCjRURERERE5GZstIiIiIiIiNyMjRYREREREZGbsdEiIiIiIiJyMzZaREREREREbsZGi4iIiIiIyM3YaJVx5MgR3H///ejYsSN69uyJ2bNno6ioSO+y6P9t3boVY8aMQe/evdGxY0f0798fGzduRNnHwW3YsAE33HADEhIScNttt+E///mPThVTSbm5uejduzfatGmD/fv3l5rGzHzP+++/j9tvvx0JCQno1q0bHnjgARQUFBRP//LLL3HbbbchISEBN9xwA9577z0dq63fvvjiCwwaNAidOnVCr1698Pjjj+PkyZPl3sf9TB/Hjx/HlClT0L9/f1x66aW45ZZbKnxfVfLJzs7GhAkT0LVrV3Tq1AmPPfYYzp075+lFqHdcZZaTk4Pk5GQMHDgQl19+OXr06IGHHnoIf/zxR7mxmJl3VHU/c/j888/Rpk2bCt/nrszYaJWQmZmJxMREWCwWJCcnY9y4cVi/fj1mzZqld2n0/1asWIGgoCCMHz8eCxcuRO/evTF58mTMnz+/+D0ff/wxJk+ejH79+mHp0qXo2LEjHnnkEfzyyy/6FU4AgAULFsBms5V7nZn5noULF2LGjBm46aabsGzZMrzwwgto2rRpcX4//vgjHnnkEXTs2BFLly5Fv379MHHiRGzbtk3nyuufPXv24JFHHkGrVq0wf/58TJgwAf/9738xYsSIUo0x9zP9HDp0CDt27MCFF16Ili1bVviequbzxBNPYNeuXZg2bRrmzJmDY8eOYdSoUbBarV5YkvrDVWZnzpzBu+++i549e+Lf//43ZsyYgezsbAwZ8n/t3WlQU2fbB/A/KGAFAmIdKQgj4oCAKKUsgg5UXAqipVpHsVWc4kKrRcWxioq48ah1KdLW3bHFfdS6VGRwrFVplVJxR5xRAoigOBYISUQwmPN+8CVjTCjp05CEx/9vhg9c931OLrjmJOfK2cZDLBarzWXNDEOX7axZQ0MDVq1ahbffflvruN5qJpDK1q1bBT8/P6G2tlYVO3jwoODl5SVUVVUZLzFSqa6u1oilpKQI/v7+wosXLwRBEIThw4cLc+fOVZszfvx4YerUqQbJkbQrLi4W/Pz8hAMHDggeHh7CzZs3VWOsmWkRi8WCt7e3cP78+RbnxMfHC+PHj1eLzZ07V4iKimrr9Og1S5YsESIiIgSlUqmK5eXlCR4eHsLly5dVMW5nxtP8+SQIgrBgwQIhOjpaY44u9bl69arg4eEh/Pbbb6qYWCwWPD09hVOnTrVB5m+u1mr29OlTob6+Xi0ml8uFoKAgYcWKFaoYa2Y4umxnzTZu3Ch8+umnWufps2Y8ovWK3NxchISEwN7eXhWLioqCUqnExYsXjZcYqTg4OGjEvLy8IJfLUV9fjwcPHqCsrAxRUVFqc0aMGIG8vDyeBmpEaWlpiI2NhZubm1qcNTM9R48eRY8ePRAeHq51/Pnz58jPz0dkZKRafMSIERCLxaioqDBEmvT/mpqaYG1tDTMzM1XM1tYWAFSnVXM7My5z87/f3dK1Prm5uRCJRBg4cKBqTq9eveDl5YXc3Fz9J/4Ga61mnTt3xltvvaUWs7a2hqurq9opZqyZ4bRWs2bl5eX44YcfkJKSonVcnzVjo/WKkpIS9OrVSy0mEonQrVs3lJSUGCkras2VK1fQvXt32NjYqOr0+s68u7s7FAqF1msWqO3l5OTg7t27mDlzpsYYa2Z6bty4AQ8PD2zevBkhISHo27cvYmNjcePGDQAvP6QUCoXG+2XzqRp8vzSsMWPGQCwWY9++fZDJZHjw4AG++eYbeHt7w9/fHwC3M1Ona31KSkrg5uam1lQDL3cCud0Zn1Qqxb1799TeG1kz0/Of//wHMTEx6NOnj9ZxfdaMjdYrpFIpRCKRRtzOzg51dXVGyIhaU1BQgOzsbMTHxwOAqk6v17H5d9bR8J49e4Y1a9YgKSkJNjY2GuOsmel58uQJfv/9d5w4cQJLly7Fpk2bYGZmhvj4eFRXV7NmJiYgIADff/89NmzYgICAAAwdOhTV1dXYsWMHOnToAIDbmanTtT5SqVR1tPJV3E8xDevWrYOZmRkmTJigirFmpuXXX3/FtWvXMHv27Bbn6LNmbLSo3aqqqkJSUhKCg4MRFxdn7HSoBVu2bEHXrl3x8ccfGzsV0pEgCKivr0dGRgYiIyMRHh6OLVu2QBAE7N2719jp0WuuXr2K+fPnY9y4ccjMzERGRgaUSiWmT5+udjMMImo7P/30Ew4dOoTU1FQ4OjoaOx3SorGxEatWrUJiYqLWS1HaAhutV4hEIshkMo14XV0d7OzsjJARtUQqlWLatGmwt7fHd999pzovt7lOr9dRKpWqjZNhVFZWYteuXZg1axZkMhmkUinq6+sBAPX19Xj69ClrZoJEIhHs7e3VTquwt7eHt7c3iouLWTMTk5aWhgEDBiA5ORkDBgxAZGQktm/fjqKiIpw4cQIA3xtNna71EYlEkMvlGstzP8W4Lly4gNTUVMyYMQOjR49WG2PNTEdmZibMzc0RHR0NqVQKqVQKhUIBpVIJqVSquhZSnzVjo/UKbedeymQyPHnyRONaBDKehoYGJCQkQCaTYefOnWqHd5vr9HodS0pKYGFhARcXF4Pm+qarqKiAQqHA9OnTERgYiMDAQHz++ecAgLi4OHz22WesmQnq3bt3i2ONjY1wdXWFhYWF1poB4PulgYnFYo1rDRwdHdGlSxeUl5cD4HujqdO1Pr169UJpaanGsyNLS0u53RnJ9evXMXv2bHz00UdaT0djzUxHSUkJ7t+/j5CQENU+SVZWFsRiMQIDA1XPgtRnzdhovSIsLAyXLl1SfYMEvLyI39zcXO3OI2Q8TU1NmDNnDkpKSrBz5050795dbdzFxQU9e/bUeJZPdnY2QkJCYGlpach033heXl7YvXu32s/ChQsBAMuXL8fSpUtZMxM0ePBgSCQS3LlzRxWrra3F7du34ePjA0tLSwQHB+P06dNqy2VnZ8Pd3R09evQwdMpvNCcnJxQVFanFKisrUVtbC2dnZwB8bzR1utYnLCwMdXV1yMvLU80pLS1FUVERwsLCDJozAcXFxUhISMCAAQOwfPlyrXNYM9Mxbdo0jX2SQYMGwdnZGbt370ZERAQA/daso17/gnYuNjYWe/bswcyZM5GQkIDHjx9j7dq1iI2N1dihJ+NYvnw5zp07h+TkZMjlcrUHOXp7e8PS0hKJiYmYN28eXF1dERwcjOzsbNy8eZPXlhiBSCRCcHCw1jEfHx/4+PgAAGtmYoYOHQpfX1/MmjULSUlJsLKywvbt22FpaYlPPvkEAPDFF18gLi4Oy5YtQ1RUFPLz85GVlYX09HQjZ//miY2NxapVq5CWloaIiAhIJBLVtZGv3i6c25nxPHv2DBcuXADwsgmWy+WqpiooKAgODg461efdd9/FoEGDsGjRIixYsABWVlZIT0+Hp6cnhg8fbpS/7X9VazUTBAFTpkyBlZUVJk+ejMLCQtWyNjY2qjMDWDPDaa1m7u7uGg8yPnbsGB4/fqy2r6LPmpkJrx8Xe8OJxWKsXLkS165dg7W1NWJiYpCUlMRv+0xEREQEKisrtY6dPXtW9U364cOHsWPHDjx8+BBubm6YO3cuBg8ebMhUqQX5+fmIi4vDkSNH4Ovrq4qzZqalpqYGq1evxrlz56BQKBAQEICFCxeqnVZ49uxZbNy4EaWlpXBycsL06dMxduxYI2b9ZhIEAQcPHsSBAwfw4MEDWFtbw8/PD0lJSRo7FdzOjKOiogJDhgzROrZ7927VTp4u9ZHJZFi9ejXOnDmDpqYmDBo0CCkpKfxCWM9aqxmAFm/EFRQUhD179qh+Z80MQ9ft7FXJyckoLCxEVlaWWlxfNWOjRUREREREpGe8RouIiIiIiEjP2GgRERERERHpGRstIiIiIiIiPWOjRUREREREpGdstIiIiIiIiPSMjRYREREREZGesdEiIiIiIiLSMzZaREREevTo0SP4+vriypUr/3jZ4uJieHt74+7du22QGRERGRIbLSIiaheOHj0KT09PeHp6oqCgQGNcEASEh4fD09MTCQkJRsjwpU2bNqF///547733/vGyvXv3Rnh4OL799ts2yIyIiAyJjRYREbUrVlZWyMrK0oj/+eefqKqqgqWlpRGyeqmmpgbHjx9HbGzsf72O2NhYnDlzBuXl5XrMjIiIDI2NFhERtSvh4eHIyclBU1OTWjwrKws+Pj7o1q2bkTIDfv75Z3To0AGDBw/+r9cRGhoKOzs7HDt2TI+ZERGRobHRIiKidiU6OhoSiQQXL15UxZ4/f47Tp09j1KhRWpdRKpX48ccfER0dDV9fX4SGhiI1NRV1dXVq8wRBwObNmxEWFob+/ftj0qRJuHfvHiIiIpCcnNxqbr/88gv69esHa2trjbF9+/ZhyJAh6NevH8aOHYuCggJMmjQJkyZNUptnYWGBoKAgnD17Vpd/BxERmSg2WkRE1K44OzvDz88Pp06dUsVyc3Mhk8kwYsQIrcukpqZi3bp18Pf3x+LFizFmzBicPHkSU6ZMgUKhUM3LyMhARkYG+vTpg/nz58PFxQXx8fGor69vNS+FQoFbt27Bx8dHY2z//v1YsWIFHB0d8dVXXyEgIAAzZ85EVVWV1nX5+Pjg3r17kMvlrb4uERGZpo7GToCIiOifGjVqFDZs2ICGhgZ06tQJJ0+eRGBgILp3764xt6CgAIcPH8b69evVjngFBwdj6tSpyMnJwahRo1BTU4OdO3fi/fffx9atW2FmZgYASE9Px9atW1vN6dGjR2hoaECPHj3U4s+fP0dGRgZ8fX2RmZmJjh1ffvR6enoiOTkZjo6OGutycXGBUqlESUkJ+vXr94/+N0REZBp4RIuIiNqdqKgoNDY24ty5c5DL5Th//nyLpw3m5OTA1tYWAwcORE1NjerHx8cHnTt3Rn5+PgDg0qVLUCgUmDhxoqrJAoDJkyfrlJNEIgEAiEQitXhhYSEkEgnGjRunarKAl82inZ2d1nU1r6O2tlan1yYiItPDI1pERNTuODg4ICQkBFlZWWhoaMCLFy/wwQcfaJ17//59yGQyhISEaB2vrq4GADx8+BAA0LNnT43Xaqkh0kYQBLXfm9fr6uqqFu/YsSOcnZ11WgcREbU/bLSIiKhdGjlyJJYsWYK//voLYWFhGkeSmimVSnTt2hXr16/XOu7g4KCXfOzt7QEAUqn0X6+reR1dunT51+siIiLj4KmDRETULg0bNgzm5ua4fv06Ro4c2eI8V1dXSCQS+Pv7IzQ0VOOnT58+AAAnJycAQFlZmdryNTU1Gncn1Oadd95Bp06dUFFRoRZvXu/rz8VqampCZWWl1nVVVFTA3Nwcbm5urb4uERGZJjZaRETULllbW2PZsmVITExEREREi/OioqLw4sULbN68WWOsqalJdfQoNDQUFhYW2Lt3r9qpe5mZmTrlY2Fhgb59+6KwsFAt3rdvX9jb2+PQoUNqz/46efJkiw3c7du30bt3b9ja2ur02kREZHp46iAREbVbo0ePbnVOUFAQxo8fj23btuHOnTsYOHAgLCwsUFZWhpycHCxevBiRkZFwcHBAfHw8tm3bhoSEBISHh6OoqAi5ubk6n8I3ZMgQpKenQy6Xw8bGBgBgaWmJxMRErFy5EpMnT0ZUVBQqKytx9OhRjeu2gJe3ib98+TImTJjwz/4ZRERkUnhEi4iI/uetWLECK1euRHV1NdLT07Fhwwb88ccf+PDDD+Hv76+aN2fOHCQmJqKoqAhr165FeXk5du3ahc6dO+v0OjExMVAqlRoPG544cSJSUlLw6NEjfP311ygoKMCWLVtga2sLKysrtbl5eXmQSCQ6NZFERGS6zATe2oiIiOhvRUREICgoCGvWrGl17qJFi1BWVob9+/f/7TylUomQkBAMGzYMaWlpqviMGTNgZmaGTZs2/eu8iYjIeHhEi4iISI++/PJL3Lp1C1euXFHFGhsbNW7Zfvz4cUgkEgQFBaliYrEY58+fx+zZsw2WLxERtQ1eo0VERKRHTk5OuHXrllrs+vXrWL16NSIjI2Fvb4+ioiIcOXIEHh4eiIyMVM1zd3dHUVGRoVMmIqI2wEaLiIiojTk7O8PR0RF79uxBXV0d7OzsEBMTg3nz5sHS0tLY6RERURvgNVpERERERER6xmu0iIiIiIiI9IyNFhERERERkZ6x0SIiIiIiItIzNlpERERERER6xkaLiIiIiIhIz9hoERERERER6RkbLSIiIiIiIj1jo0VERERERKRnbLSIiIiIiIj07P8A8yWgyIW35iYAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 176, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 1.29718\n", + "GdL = 3\n", + "Chi² rid = 0.43239\n", + "P(0, chi²)= 0.27020\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.279621\n", + "1 0.079508\n", + "2 0.241447\n", + "3 0.601919\n", + "4 0.094687\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 177, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.01342 ± 0.02367\n", + "cov_ABtC = -0.000007\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 2.94068 ± 5.18574\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 178, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA1oAAAIsCAYAAADrrtj2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqP9JREFUeJzs3Xd8E/X/B/DXZXS36YAWKCAgtiAbBwKKiDgQFWWDYBUQUEQFFy72EnFB2UOWLBVRUFDUr6D4BRfKcLFkaoG0TXeb8fn9wS/5Nh1JR5LLJ309Hw8fD0lyn7zvXnfXvHO5O0UIIUBEREREREQeo1G7ACIiIiIiokDDRouIiIiIiMjD2GgRERERERF5GBstIiIiIiIiD2OjRURERERE5GFstIiIiIiIiDyMjRYREREREZGHsdEiIiIiIiLyMDZaREREREREHsZGi4jIDwwdOhRDhw51/Pvs2bNITk7Gli1bVKyqYiZMmIB27dqp8t7JycmYP3++499btmxBcnIyzp49q0o9FdWtWzdMmDBB7TKIiMiL2GgRkV+xf1A+dOiQ2qVIYf/+/UhOTsbOnTvLfF7NJoiIgPz8fMyfPx/79+9XuxQi8jGd2gUQEVFpiYmJOHjwIHQ67qYro1evXujZsyeCgoLULsWlnTt3QlEUtcsgH8jPz0dqaioef/xxdOjQQe1yiMiHeESLiMgPKYqC4OBgaLVatUuRilarRXBwsN83MUFBQdDr9WqXoRohBAoKCtQuwy/l5eWpXQIReQgbLSKSUlpaGl544QV06tQJLVu2RM+ePfH++++Xet25c+cwevRotG3bFh07dsTMmTPxzTffIDk5udRPed59913ceuutaN26Nfr27Ysff/yx1LlTAFBUVIR58+bhtttuQ8uWLXHzzTdjzpw5KCoqqlDtmzZtQvfu3Z3epyRvn6P17rvvomfPnmjZsiVuvPFGTJkyBVlZWaVet2PHDvTu3RutW7dGhw4d8MwzzyAtLc3t+L///jtuuOEGDB06FLm5uQAqnllZioqKMHPmTNxwww1o164dRo8ejX///bfU68o6R6tbt24YNWoUfvzxR/Tt2xetWrXCrbfeiq1btzpNm5mZiVdffRX33HMP2rVrh/bt22PEiBH4448/nF5n/7nmp59+itTUVNx0001o164dnnjiCWRnZ6OoqAgzZsxAx44d0a5dO7zwwgul1o2yztHKysrCzJkz0a1bN7Rs2RJdunTBc889h/T0dMcyePvtt9G7d29cc801aNu2LQYPHox9+/ZVaBl600cffYS+ffuiTZs2uO666/DAAw/g22+/dTxvz+Cbb75xrE8bN24EAJw5cwZPPPEErr/+erRp0wb9+/fH119/7TR+8WW+aNEidOnSBa1atUJKSgpOnTpVqp6KrLf2n9WeP38eo0aNQrt27XDTTTfh3XffBQD8+eefePDBB9G2bVvccsst2LZtW6n3ycrKwowZM3DzzTejZcuWuO2227B06VLYbDYAl7fjjh07AgBSU1ORnJzsdF6hvYbTp0/jkUceQbt27fDMM88AuNxwzZ492zH2HXfcgRUrVkAIUZWIiEgF/E0KEUnn0qVL6N+/PxRFwQMPPIDY2Fjs2bMHL730EnJycvDQQw8BuPxBJSUlBRcvXsSDDz6IWrVqYfv27WWeK7F+/XpMnToV1157LR566CGcO3cOY8aMQVRUFOrUqeN4nc1mw6OPPoqffvoJ/fv3x5VXXom//voLq1evxt9//42FCxe6rP29997DxIkT0a5dO6SkpODMmTN49NFHYTAYULdu3Sovk9zcXMcH8uLKav7mz5+P1NRUdOrUCYMGDcLJkyexYcMGHDp0CBs2bHAcadmyZQteeOEFtGrVCuPHj4fRaMSaNWvw888/Y+vWrYiKiiqzloMHD2LEiBFo2bIlFi5ciJCQkApnVp6XXnoJH3/8Me6++260b98e+/btw8iRIyu8fE6dOoUnn3wSffv2xf33348PPvgAEyZMQIsWLXDVVVcBuPyB/4svvsCdd96J+vXr49KlS9i0aROGDBmCTz75BAkJCU5jLl26FCEhIRg5ciROnTqFdevWQafTQVEUZGVl4fHHH8evv/6KLVu2IDExEY8//ni59eXm5uKBBx7A8ePH0adPH1x99dXIyMjAV199hbS0NMTGxiInJwfvvfce7r77bvTr1w+5ubl4//33MWLECLz33nto3rx5hZeHJ6WmpmL+/PmOZlOv1+PXX3/Fvn37cOONNzped/LkSTz99NMYMGAA+vfvj8aNG+PSpUsYOHAg8vPzMXToUMTExODDDz/Eo48+6vgyo7hly5ZBURQMGzYMOTk5WL58OZ555hm89957jtdUZr21Wq145JFHcO211+KZZ57Btm3bMHXqVISGhuLNN9/EPffcg9tvvx0bN27E888/j7Zt26JBgwYALv8kcMiQIUhLS8PAgQNRt25dHDhwAG+88QYuXryIl156CbGxsZg8eTImT56M2267zTE/ycnJjhosFguGDx+Oa665Bs8//zxCQkIghMCjjz6K/fv3o2/fvmjevDm++eYbzJkzB2lpaXjxxRe9kiUReZggIvIjH3zwgUhKShIHDx4s9zUvvvii6Ny5s0hPT3d6fNy4ceKaa64R+fn5QgghVq5cKZKSksSuXbscrykoKBB33nmnSEpKEvv27RNCCFFYWCiuv/560adPH2E2mx2v3bJli0hKShJDhgxxPLZ161bRrFkz8cMPPzi994YNG0RSUpL46aefyq27qKhIdOzYUfTq1UsUFhY6Ht+0aVOp9zlz5oxISkoSH3zwQbnjCSHEvn37RFJSksv/2rZt63i90WgULVq0EMOGDRNWq9Xx+Lp160RSUpJ4//33nWq9++67RUFBgeN1//nPf0RSUpJ4++23HY89//zzjvf48ccfRfv27cXIkSOd5rGimZXl999/F0lJSWLy5MlOj48fP14kJSWJefPmOR6zrz9nzpxxPHbLLbeIpKQkp8yMRqNo2bKlmD17tuOxwsJCp2UixOUcWrZsKVJTUx2P2Zf53XffLYqKipzqSU5OFiNGjHAaY8CAAeKWW25xeuyWW24Rzz//vOPfb7/9tkhKShKff/55qfm32WxCCCEsFovTMhVCCJPJJDp16iReeOGFUtP5wt9//y2aNWsmxowZU2rZ2esW4n8Z7Nmzx+k1M2bMKJVNTk6O6Natm7jlllscY9qXeY8ePZyWwerVq0VSUpL4888/hRCVX2+TkpLE4sWLHY+ZTCbRunVrkZycLD755BPH48ePHy+1ri1YsEC0bdtWnDx50mme5s6dK5o3by7Onz8vhLi8rpWctmQNc+fOdXp8165dIikpSSxcuNDp8bFjx4rk5GRx6tSpUmMRkf/hTweJSCpCCHz++efo1q0bhBBIT093/HfjjTciOzsbR44cAQB88803SEhIwK233uqYPjg4GP3793ca8/Dhw8jMzET//v2dLj5xzz33wGAwOL12586duPLKK9GkSROn977hhhsAwOWVxQ4fPgyj0YiBAwc6Xazh/vvvR2RkZNUXCoAxY8bgnXfeKfVf8SMKAPDdd9/BbDbjwQcfhEbzvz8B/fr1Q0REBHbv3u1U66BBgxAcHOx4XdeuXdGkSZNSP+0CgH379mHEiBHo2LEj5s+f75jHymRWFntNJX/CmZKSUuHl07RpU1x77bWOf8fGxqJx48Y4c+aM47GgoCDHMrFarcjIyEBYWBgaN26M3377rdSYvXr1cjrPqnXr1hBCoE+fPk6va926Nf755x9YLJZy6/v888/RrFmzUkdwADjON9NqtY5larPZkJmZCYvFgpYtW5ZZny988cUXsNlsGDNmjNP6BKDUeXL169fHTTfd5PTY7t270bp1a6dswsPDMWDAAJw7dw7Hjh1zen3v3r2dth37dPYcq7Le9uvXz/H/UVFRaNy4MUJDQ9GjRw/H402aNEFUVJTT+rJz505cc801iIqKclqnO3XqBKvVih9++KHshVaGQYMGOf17z5490Gq1pdb5YcOGQQiBPXv2VHhsIlIPfzpIRFJJT09HVlYWNm3ahE2bNpX7GuDy+VkNGzYs9YGvYcOGTv8+f/58mY/rdDokJiY6PXbq1CkcP37ccd5FSUajsdza7e9zxRVXOD2u1+sdP0eqqqSkJHTq1KnU4x9//HGZNTRp0sTp8aCgIDRo0ADnzp1zel3jxo1LjdmkSRP89NNPTo8VFhZi1KhRaNGiBd566y2nhrUymZXl3Llz0Gg0pfIpOQ+ulPWzTIPBAJPJ5Pi3zWbDmjVrsH79epw9exZWq9XxXHR0dKnp69Wr5/Rve7Nc8r0iIyNhs9mQnZ2NmJiYMus7ffo0br/9drfz8eGHH2LlypU4efIkzGaz4/H69eu7nC47O7vKF5+IjIxESEhImc+dPn0aGo0GV155pdtxyqrx/PnzaNOmTanH7dmeP38eSUlJjsdLLnP7zwDt5xdWdr0NDg5GbGys02ORkZGoU6dOqf1GZGSk03mMp06dwp9//lnuvsDVOl2cTqdz+nkycHmdj4+PR0REhNPj9uVs306JyL+x0SIiqdhPMr/33ntx//33l/ma4uc/eOP9k5KS8MILL5T5fMkPTDVFUFAQunTpgq+++grffPMNbrnlFsdzamcGoEJXb1y8eDHefvtt9OnTB08++SQMBgM0Gg1mzpxZ5gUISh7Bcfd4WWNUxkcffYQJEyage/fuGD58OOLi4qDVarFkyRKnIy1lmTFjBj788MMqve+sWbPQu3fvKk1bXHnNWmV4etmWt16U93jx97HZbOjcuTNGjBhR5msbNWpUoRqKH0klosDCRouIpBIbG4vw8HDYbLYyj+AUl5iYiGPHjkEI4fTt9OnTp51eZ/+W/PTp046fAAKXT1I/d+6cUxPQsGFD/PHHH+jYsWOlLyFuf59Tp045fQtuNptx9uxZNGvWrFLjVYW9hhMnTjgdRSsqKsLZs2cdy9T+upMnT5b6xv7kyZOljiwoioK5c+fisccew5NPPolly5Y57hlUmczKkpiYCJvNhtOnTzsdxTpx4kSlx3Lls88+Q4cOHTBz5kynx7Oysso9EuUpDRs2xNGjR12+5rPPPkODBg2QmprqtO7NmzfP7fgjRozAvffeW6XamjZtWu5zDRs2hM1mw/Hjx6t0MY569erh5MmTpR63Z1tyPavIeEDF19vqaNiwIfLy8tyu01W51UBiYiL++9//Iicnx+moln25lDzSTkT+iV+hEJFUtFot7rjjDnz22Wf466+/Sj1f/Oc6N954I9LS0vDll186HissLMTmzZudpmnZsiWio6OxefNmp/Notm3b5vTTMgDo0aMH0tLSSo0BAAUFBS7vgdOyZUvExsZi48aNTlcD/PDDD8u8tLo3dOrUCXq9HmvXrnX6dv79999HdnY2br75ZketcXFxpWrdvXs3jh8/jq5du5YaOygoCKmpqWjVqhVGjx6NgwcPAqhcZmXp0qULAGDt2rVOj69evbpiM11BWq221JGRHTt2VOhy9tV1++23448//sCuXbtKPWevyX6UpXiNv/76K3755Re34zdt2hSdOnWq0n/x8fHljtu9e3doNBosWLDAceSyZN2u3HzzzTh48CAOHDjgeCwvLw+bN29GYmKiyyavLFVZb6uqR48eOHDgAL755ptSz2VlZTn2JaGhoY7HKqpLly6wWq2OS83brVq1CoqiOLYJIvJvPKJFRH7pgw8+KPMDzIMPPoinn34a+/fvR//+/dGvXz80bdoUJpMJR44cwX//+198//33AIABAwZg3bp1ePrpp/Hggw+idu3a2LZtm+Mkefs3zUFBQRg7diymTZuGlJQU9OjRA+fOncOWLVtKnRfUq1cv7NixA5MmTcL+/fvRvn17WK1WnDhxAjt37sTy5cvRqlWrMudJr9fjqaeewsSJE5GSkoK77roLZ8+exZYtW6p9jlZFxcbGYtSoUUhNTcWIESPQrVs3nDx5EuvXr0erVq0cRz30ej2eeeYZvPDCCxgyZAh69uzpuEx2YmJiuZdjDwkJwZIlS/Dggw/ikUcewdq1a5GUlFThzMrSvHlz3H333Vi/fj2ys7PRrl077Nu3r8z7J1VH165dsWDBArzwwgto164d/vrrL2zbts0n2QwfPhyfffYZnnzySfTp0wctWrSAyWTCV199hSlTpqBZs2bo2rUrPv/8c4wZMwZdu3bF2bNnsXHjRjRt2lS1m9xeccUVGD16NBYuXIjBgwfj9ttvR1BQEA4dOoT4+Hg8/fTTLqcfOXIkPvnkEzzyyCMYOnQoDAYDtm7dirNnz2L+/PmV/kldVdfbqhg+fDi++uorjB49Gvfffz9atGiB/Px8/PXXX/jss8/w5ZdfIjY2FiEhIWjatCl27NiBRo0aITo6GldddZXTuWcldevWDR06dMCbb77pOKq+d+9efPnll0hJSSm1XyIi/8RGi4j80oYNG8p8vHfv3qhTpw7ee+89LFiwALt27cKGDRsQHR2Npk2bOm72CVy+etnq1asxffp0rFmzBmFhYbjvvvvQrl07jB071umqZEOGDIEQAu+88w5effVVNGvWDIsWLcL06dOdXmf/9n7VqlX46KOPsGvXLoSGhqJ+/foYOnRomSfhFzdgwABYrVasWLECc+bMQVJSEhYtWoS33367mkus4saOHYvY2FisW7cOs2bNgsFgQP/+/TF+/Hinq+j17t0bISEhWLZsGebOnYuwsDB0794dzz77bLn30AKAiIgIrFixAkOGDMGwYcPw7rvv4oorrqhQZuWZOXMmYmJisG3bNnz55Zfo0KEDli5d6jgC5wmjR49Gfn4+tm3bhk8//RRXX301lixZgtdff91j71Ge8PBwvPvuu5g/fz527dqFDz/8EHFxcejYsaPj/l29e/d23Nvr22+/RdOmTfHaa69h586dLhtVb3vyySdRv359rFu3Dm+++SZCQ0ORnJyMXr16uZ22Vq1a2LhxI1577TWsW7cOhYWFSE5OxuLFi6t89Kmq621lhYaGYu3atViyZAl27tyJrVu3IiIiAo0aNcLYsWOdriQ6ffp0TJs2DbNmzYLZbMbjjz/ustHSaDRYtGgR5s2bh08//dRxL7bnnnsOw4YN89g8EJF3KaK6Z+cSEUlm1apVmDVrFvbs2VPqJrTF2Ww2dOzYEbfddhumT5/uwwqJiIhIdjxHi4gCWslLWhcWFmLTpk1o1KiRU5NVWFhY6pySrVu3IjMzE9dff71PaiUiIqLAwZ8OElFAe/zxx1GvXj00a9YMOTk5+Pjjj3HixAnMnTvX6XW//PILZs2ahTvvvBPR0dH47bff8P777yMpKQl33nmnStUTERGRrNhoEVFAu/HGG/H+++9j27ZtsFqtaNq0Kd58803cddddTq9LTExEnTp1sHbtWphMJhgMBvTq1QvPPPMMgoKCVKqeiIiIZMVztIiIiIiIiDyM52gRERERERF5GBstIiIiIiIiD+M5WuU4cOAAhBBO95QhIiIiIqKax2w2Q1EUtGvXrsLTsNEqhxCi1KWeiYiIiIio5qlKX8BGqxx6vR5CCLRs2RKKoqhdDlWAEAJmsxl6vZ6ZSYKZyYeZyYeZyYeZyYeZyaeymR06dKjS7+FXjdapU6ewYsUK/Prrrzh69CiaNGmC7du3V2jatLQ0vPHGG9i9ezfy8vKQmJiIRx99FPfee6+XqyYiIiIiInLmV43W0aNHsXv3brRp0wY2m63Ch+guXLiAAQMGoHHjxpg2bRoiIiJw9OhRFBUVebliIiIiIiKi0vyq0erWrRu6d+8OAJgwYQIOHz5coelee+011KlTB8uXL4dWqwUAdOzY0Wt1EhERERERueJXl3fXaCpfTk5ODnbs2IHBgwc7miwiIiIiIiI1+VWjVRVHjhyB2WyGTqfDkCFD0KJFC3Tu3BmvvfYazGZztcbmyYzy4eX45cPM5MPM5MPM5MPM5MPM5OPtzPzqp4NVcenSJQDAyy+/jP79++Pxxx/HwYMHMW/ePGg0Gjz99NPVfo+S54opiuL0mNVqdTR19uasvPPLSk5b8rnqTMtxvTtuVacNCgoq92itv86rGsvQW+PWpGXo65qEEFLV6+1x/bGmks/Z/+2v9fpjTWqMW/x5d59BfFUTx634uGU9r3ZNgTKuv9XkjvSNls1mAwB06tQJEyZMAADccMMNyM3NxcqVKzFmzBiEhIRUaWwhBIqKipyObGk0Guh0lxdbUVERLl68iKysLMfz3lqBZBtXrZpcUbNeg8GAuLg4p3VJURTHNykWi6XU9DqdDoqiwGazwWq1Oj2n1WodP5UteeS2OuMWX7/LOiJsvwSq1Wp1bHslxxVCwGKxlDmuEMJpXCEEbDYbgoODyx3XPq9ljetuXu3PuVqGVRm3OsswKCgIAFwuQ1fjllyGJefVW8vQPq49M3s9vl6Gaq3frpZhRcYFPJ9NRfcRRUVFjszsH+Jl2UcUHxfw3vrtb/sIIQQKCwsdeVVmXLX3EZ4aV7Z9hP0LVfvzlR0XUG8f4S/L0Nf7CPvfs5CQECiK4nYfYf9ysTKkb7SioqIAXG6uiuvYsSMWL16MU6dOITk5ucrju7q2vtFoRHZ2NuLj4xEWFua0QwyUTl22cV1tBGpkI4RAfn4+Lly4AACoW7dumdPbd0pl0Wg0Ls9fdHXY29Pj2pdD8R10Wa8pr6aSz5XcYVZ1XKDq8+qtcQHX2bia1+rU661lWPwPVcn7jqi1DP1t/S5vXDs11m97TeXdK8bflqFa67c/7iPs71vW3zR/3kd4elxZ9hH2D/E6nU7KfYSvxvWnfUTJzyDu5rWyTRYQAI1W06ZNXT5fWFhYrfFLfptkZ7PZYDKZEB8fj7i4uGq9B3mG/XB9eZmpJSwsDMDl2xAkJCSUuQNwVW9Vn/PHcct6vnhegTSvvlyGvh7XnllFcqtOTbKN6481Fc+orH2jv9XrjzWpOW55f88CcV4DaVxvvK+/zquvx/V0TSX/tlW1pvJIfzGMxMREJCUl4bvvvnN6/LvvvkNISIjbRqyq7B2w/UM0kSv29aS6F2ghIiIiIjn41RGt/Px87N69GwBw7tw55OTkYOfOnQCA66+/HrGxsUhJScH58+exa9cux3Tjxo3DY489hhkzZqBr1644dOgQVq5cieHDh3u9EfKnIyfkv7ieEBEREdUsftVoGY1GPPnkk06P2f+9Zs0adOjQocwT77p164Y33ngDCxcuxIYNGxAfH4+xY8di5MiR1aqHH47lw8zkw/vfyYeZyYeZyYeZyYeZycfbmflVo1W/fn38+eefLl+zdu3aMh+/6667cNddd3m8pprwwX3+/PlITU0t9fhVV12F7du3Izk5Gc899xyGDx8OANiyZQv0ej3uueeeCo1fVFSE9evX4+OPP8bJkydhtVpxxRVX4Pbbb0dKSorjgibVVZGshg4dirCwMCxZssTta/v27Yv7778fDzzwAIDy5/vhhx/G9ddfj0cffbRqhddgiqLwD5NkmJl8mJl8mJl8mJl8fJGZXzVa/qgql3KUUUhICFavXl3qMQDYtGkT6tWr53j8ww8/RFhYWIUarcLCQowYMQK//PILHnjgATz11FMICgrC77//jrVr1yI7OxsvvviiR+ah+FX/ysts0qRJLq+QY7dr1y6cO3cOffr0cTxW3nyPGjUKY8eOxeDBg2EwGKpYfc3krxcwofIxM/kwM/kwM/kwM/n4IjM2Wi5U9eZkMtJoNGjbtm2Zz5X3eEW8/fbb+PHHH7FixQp06tTJ8fgNN9yAwYMH4+eff67y2MDlo2U6nc7RPLlrjCt6cZTVq1ejZ8+eFboH2w033ICoqCh8+OGHeOihhyo0Pv2PxWLx+p3ZybOYmXyYmXyYmXyYmXy8nZn0Vx0k70tOTsaKFSsAXP7p3ffff4+vv/4aycnJSE5Oxvz588ucrqCgABs2bED37t2dmiy74OBgdOzYEQCQl5eHqVOn4o477kCbNm3QrVs3TJw4EdnZ2U7TdOvWDVOnTsWyZctwyy23oHXr1sjMzMT8+fPRvn17HDp0CP369UOrVq3Qo0cP/Oc//3GafujQoRg1apTL+T1z5gx+/PFH3HnnnU7TuZrvO++8E1u3bnU5LhERERHVHDyiRQ4l78Kt1WpLHR2aNGkSnn32WYSEhOD5558HANSpU6fM8Q4fPoy8vDzcdNNNbt+7oKAAVqsV48aNQ2xsLP755x8sXrwYjz32WKnz8j7//HNcccUVeOmll6DRaJwunT5+/Hg8/PDDaNCgATZs2IDHH38cW7ZsqdRNq/ft2wedTofWrVtXeL7btWuH5cuXIz09HbGxsRV+LyIiIiIKTGy0CMDlI0otWrRwemzOnDno1auX02NNmzZFREQEwsLC3P6k8MKFCwCAunXrun3/2NhYTJkyxfFvi8WC+vXrY/DgwTh58iQaN27seM5sNmPZsmWlLt1vNpsxevRo9O3bF4qi4MYbb8Ttt9+OJUuW4I033nBbg92hQ4fQqFEjBAUFOR5zN9/NmjUDABw8eBBdu3at8HsRERERUWBio+VCVU+MM/99HjZTtvsXepjGEAl9o3ruX1iGkJAQrFu3zumxBg0aeKKsCi/HrVu3YtWqVTh16hTy8vIcj//9999OjVaHDh3KvT9a9+7dHf+v1WrRvXt3fPHFF5Wq98KFC4iJianUNPbXX7x4sVLTUc24smegYWbyYWbyYWbyYWby8XZmbLTcqGwAVmMmTncYBNhsXqrIBa0WjY5shTYuutKTajQatGrVyqPlxMfHAwD++ecft6/dtWsXnn/+eQwYMADjxo1DdHQ0Ll68iDFjxqCwsNDptXFxcWWOodfrSzVIcXFxlW5+ioqKnI5mVYT99QUFBZWarqZTFIUnDkuGmcmHmcmHmcmHmVVffn4+8vPzy30+NDQUoaGhHns/X2TGRsvDtHHRaLh/g2pHtKrSZHlLy5YtERYWhm+++Qb9+vVz+dqdO3eiefPmmDp1quOx77//vszXltf8ms1mmEwmp0usG41G1K5du1J1GwwGnDt3rlLT2C/aER0dXanpiIiIiAg4duwYDh8+DACwWq3Izc1FeHi4415XLVu29PhBAW9jo+VGVe6jVdWf78lCr9eXOspUlpCQEAwaNAjvvPMO9u3bhxtuuMHp+cLCQvz888/o2LEjCgoKSn2rsG3btkrX9vnnnzvO0bJarfjiiy/Qpk2bSo3RuHFj7N+/v9Tjrub77Nmzjmmp4oQQsFgs0Ol0/MmFJJiZfJiZfJiZfJhZ9TVt2hSJiYkAAJPJhD179qBz586OL9A9eTQL8E1mbLRcqEn30aqMJk2aYOvWrfjqq69Qu3ZtxMfHIyEhoczXPvnkkzh06BBGjhyJBx54AJ06dYJer8cff/yBd999F7fccgs6duyITp06YerUqViwYAHatWuH3bt347///W+l6tLr9Vi8eDGKiopQv359bNiwAf/++y8WLFhQqXHat2+PBQsW4N9//3W6sqCr+T58+DDCwsLQvHnzSr0XcTuTETOTDzOTDzOTDzOrnpI/DQwKCoLBYPDq1Zy9nRkbLaq0Rx55BKdPn8bzzz+PrKwsPP744xg7dmyZrw0ODsaKFSuwfv16fPzxx9iwYQNsNhuuuOIK9OrVCykpKQCAgQMH4uzZs1i3bh1WrFiBG2+8Ea+//jr69+9f4br0ej3mzp2LadOm4a+//kL9+vUxb948xxUBK+r6669HdHQ09uzZ4/T+ruZ7z549uO222xyHt4mIiIioZlME2+8yHTp0CEIItGrVqszDiQUFBY7LjoeEhKhQIRU3f/58rFy5Ej/99BMURan2IeDZs2fjt99+w5o1a9y+1mQyoXPnznjnnXdw3XXXlfkari9lE0LAbDZDr9fzpxaSYGbyYWbyYWbyYWaelZ6ejs8++wx33HGH145oVTazQ4cOAUClzhPTVLk6ogA2bNgwHDx4EH/88Yfb165duxbt27cvt8kiIiIiopqHjZYL/EZCPp7KLD4+HrNmzUJ6errb10ZHR+Pll1/2yPvWRLwcrnyYmXyYmXyYmXyYmXx4eXeVsdmSw9ixY8s9T6yqevToUaHXDRkyxKPvW5Nw+5IPM5MPM5MPM5MPM5OPLzLjES03eAqbPIQQjv9IDkIIWK1WZiYRZiYfZiYfZiYfZiYfX2TGRssFbizyYWbysVqtapdAlcTM5MPM5MPM5MPM5OPtzNhoVRM/2FNFcD0hIiIiqpjMzEykpaUhMzNT7VKqhY1WFdlPnsvLy1O5EpKBfT3hibJEREREruXk5Dj+kxkvhlFFWq0W0dHRuHDhAgAgLCyMJ0KqzH5+lifuo+UpQgjk5eXhwoULiI6O5g2NiYiIiNzIKyi6/BmqoEjtUqqFjZYL7j6s16lTBwAczRapz95o+Zvo6GjH+kLO2HzKh5nJh5nJh5nJh5l5RlZOIbbv/Rtaq8D2vX/j6qtbISoi2Cvv5e3M2Gi54epDu6IoqFu3LuLj42E2m31YFclEr9dz51sORVG4bCTDzOTDzOTDzOTDzDznH2MuzvyTjUZhwJl/svGvMc8rjZYvMmOj5UZFjpBotVpuXH7AH386SK4xM/kwM/kwM/kwM/kwM8+pGxeOBnUjARPQoG4k6sSFeeV9fJEZL4bhAq8UJx+LxaJ2CVRJzEw+zEw+zEw+zEw+zMwzoiKCcXfnRtBpFdzduZHXfjYIeD8zNlpEREREROQ3wkKCoCgKwkKC1C6lWthoERERERGR34iIiHD8JzM2WkRERERE5Deio6ORkJCA6OhotUupFjZaLvBkRvkwM/kwM/kwM/kwM/kwM/kwM/l4OzM2Wm5wo5GHoijQ6/XMTCLMTD7MTD7MTD7MTD7MzHMKD/6F7OGTUf/j/3r1fXyRGRstIiIiIiJSleXfS7jwxCyc7T4CtvMXkdmqsdolVRvvo+VGRe6jRf5BCAGLxQKdTsfMJMHM5MPM5MPM5MPM5MPMqs6Wm4/MRRuROX89lNBg1Jo9DpaenZHz1ZdefV9fZMZGywXeR0s+zEw+zEw+zEw+zEw+zEw+zKxyhM2G7M2fIX3GUljTTYge2RfRTw2F1hCJ9PR039Tg5czYaBERERERkc/k7z2ASxNTUXTwL4T36oa4V0ZBf0U9tcvyODZaRERERETkdUXHzyB96iLkfvoNgts3R+InCxFyfSsAQH5+PvLz8wEAJpMJRUVFMJlMjmlDQ0MRGhqqSt1VxUaLiIiIiIi8xpqRhYy5q2BauQW6OrUQv2QSIu7rBkXzv+vyHTt2DIcPH778eqsVBQUF2Lt3L7RaLQCgZcuWaNWqlSr1VxUbLRd4MqN8dDqu0rJhZvJhZvJhZvJhZvJhZqWJIjNMKz9ExuurICxWxE4YAcPIftCEBpd6bdOmTZGYmFjuWN44muXtzLhGuMFmSx6KojAvyTAz+TAz+TAz+TAz+TAzZ0II5O34BsbJi2A+dR5RQ+9BzHPDoIuPLXcaX/800BeZsdFyg5d3l4cQAjabDRqNhplJgpnJh5nJh5nJh5nJh5n9T+Gvf+LSxFQUfPcLQm+5HgmrZyC4eRO1yyrFF5mx0XKBl+mUj9VqhUbD+3DLhJnJh5nJh5nJh5nJp6ZnZjl/AcYZy5Dz3mfQJ12BuhvnIuzWDmqX5ZK3M2OjRUREREREVWLLyUPmgg3IXLABSngoas0Zj6ghd0PhOWtstIiIiIiIqHKE1YrsTTuRPnMZbJnZMIzqh5inhkITGa52aX6DjRYREREREVVY3jc/wThxAYoOH0XE/bci9uVR0Desq3ZZfoeNlgs1/WRGGdXk30bLipnJh5nJh5nJh5nJpyZkVnTsNIyTFyLvs70Ivq4lEncsRsi1LdQuq8q8nRkbLTfYbMlDURTew0IyzEw+zEw+zEw+zEw+gZ6ZNd2EjNfegWnVVujqxSNh2RSE97pF6s/JvsjMr1rvU6dOYeLEiejVqxeuvvpq3H333ZUeY9WqVUhOTsaoUaM8UhOvPCgPIYTjP5IDM5MPM5MPM5MPM5NPoGYmCouQuXAjTl8/ENmbdiL2xUfQYO9aRNzXTeomC/BNZn7Veh89ehS7d+9GmzZtYLPZKj3jFy9exIIFCxAXF+eRegJtY6kJzGYz9Hq92mVQJTAz+TAz+TAz+TAz+QRSZkII5G7fDePURbCcSUPUg/cg5tlh0NWOUbs0j/J2Zn7VaHXr1g3du3cHAEyYMAGHDx+u1PSvvfYaunXrhvPnz3ujPCIiIiKigFZw4HcYX0lFwf6DCOt+A+qum42g5MZqlyUlv/rpYHVOSPvxxx/xxRdf4Omnn/ZgRUREREREgc9yLg1pj03DudtHwpaVg7qbX0fdDa+xyaoGvzqiVVVWqxXTpk3D6NGjER8fr3Y5RERERERSsOXkIWPeuzAt2ghNZARqv/EsIgf3hKLVql2a9AKi0Vq/fj3y8/Px0EMPeXzsss7TUhSl3PO37CcGunreW9PW9HHtjzEb/x235LTFT0QNtHkN1PWw5MnD/l6vL8f1x5qK51X8df5arz/WpOa4vv4MwnGrPq63P4N4Y1zYbMha/ykyZi2HLTsHhkcHIHrsA9BEhPllvZ6uqeQ2VqVl6Ib0jZbRaMS8efPw6quvIigoyKNjK4oCi8Xi9JhGo3FcCtJsNpeaxl6D1WqFzWZzek6n00FRFNhsNlit1jLHFUKUOa79RL2yxtVqtdBqtRBClKpXURTHtBaLpdSK4q1xKzKvQOllWN1xg4KCXC5DRVEqPa/uMldjGdrHLasmb2Vjn9fylqF9XFfLsKxsFEVx7Dy9tX67Woa+XL+BwNhH2PeNMu4jqrp+y7yPsFgsTn/PZNtH2McFas4+QlEUaLXaUu8ryz7CE+PKuI8ICgqCzWYrNa0/7iOKvj2AjCkLUfTbCYT1vhWGCcOhS0yAFYDNYqkx+wiNRuP4DOJuHyGEcLy2oqRvtN5++20kJyfj2muvRVZWFoDLC8pisSArKwthYWHVuka+qyuRuHqu+B+5kjQaTbnnoxXfaCo7rrtpXS0Hb43ral4B18vQ0+PaN47qzKsa2QTSMlRr/a7ONuetbLiPuCyQ1u/yxrXjMvzfa7iPuIz7CPfjBtL6Xd64dr5YhkV//Q3j5IXI/2IfQq5vhXo7FyOk/dXVHrcsgbaPqGyTBQRAo3Xy5En88MMPuO6660o9d91112HZsmXo0qVLtd6jrAXrbmG7et5b09b0ce3fVGi1Wr+pieO6fl4IAavV6tgpBtK8Buo+onhm9sf8uV5fjuuPNdm/HS6ZmSfGdSXQlqGvx3WVmVo1cVzXz3v7M0h159V6KQPpc95B1pqPoasfj4QVUxF+T1e/WobenrbkcyW3s+rUVB7pG60XX3zRcSTLbubMmQgJCcH48eORnJxc5bGr+ntMUo/NZiv3mwzyT8xMPsxMPsxMPsxMPv6YmSgsQuay95H5xhpAURA3cTQMw3tDCfbs6Tay8nZmftVo5efnY/fu3QCAc+fOIScnBzt37gQAXH/99YiNjUVKSgrOnz+PXbt2AQCaN29eapyoqCiEhYWhQ4cOviueiIiIiMgPCCGQ+/HXME5bBMvZC4h6qBdin30Y2rhotUurUfyq0TIajXjyySedHrP/e82aNejQoUOZJ94RERERERFQ8NORyzcc/uEwwm7vdPleWFddoXZZNZJfNVr169fHn3/+6fI1a9eudTtORV5DRERERBQozGf+Rfr0JcjZ8gWCWlyJuh+8ibAu16pdVo3mV42Wv6nqiW+knupcYZLUwczkw8zkw8zkw8zko1ZmtuxcZLy9DqbFm6ExRKD2WxMQOfBO3nC4ArydGbdiN9hsycPdFWPI/zAz+TAz+TAz+TAz+aiRmbBYkL3+U6TPXg5bTh6iHx+E6McHQxMR5tM6ZOWLzNhouVGVm5OROoQQsNlsVb7XAfkeM5MPM5MPM5MPM5OPrzPL+2o/Lk1aAPMfJxHR/w7EvfgIdIkJXn/fQOKLzNhoucDLu8vHarW6vHke+R9mJh9mJh9mJh9mJh9fZFb0x0lcmrQA+V/tR0jHNojftQwhbZt59T0DmbczY6NFREREROTHLBczkDFnBbLWbIOuYV0krJqB8Ltu4hFPP8dGi4iIiIjID9kKCmFa8h4y3loLRatB3JTHYBjWG0qQXu3SqALYaBERERER+REhBHK2fon0aUtg+eciDMN6I+bpFGhjDWqXRpXARssFHo6VD3/PLh9mJh9mJh9mJh9mJh9PZVbww2FcmpiKwh+PIKzHjaj73usIurKhR8YmZ97ezthoucFmSx6KovC+I5JhZvJhZvJhZvJhZvLxRGbmU+cv33B461cIankV6n34NkJvbO+hCqkkX2xn3IopoPBy/PJhZvJhZvJhZvJhZvKpambWrBxkvrUWmUvegzbWgNrzXkBk/zt4w2Ef8PZ2xkbLBSEEd3QSEULAbDZDr9czM0kwM/kwM/kwM/kwM/lUJTNhsSBr7Takv7oCIr8QMU8NRfRjA6EJD/VytQT4Zjtjo0VERERE5CNCCOR9sQ/GyQtgPnoakQPuROyLj0BXt7bapZGHsdEiIiIiIvKBwt+OwzhpAfK//gEhndshYeErCG6TrHZZ5CVstIiIiIiIvMiSZkT6qyuQ/e4n0DeqhzprZyHsjs78aWiAY6NFREREROQFtvxCmBZvQsbb66DodYibNhaGh3rxhsM1BBstF/gtg3z0eu64ZMPM5MPM5MPM5MPM5FM8M2GzIWfLF0ifvgSWC+kwDO+NmPEp0MZEqVghleTt7YyNlhtstuTBrOTDzOTDzOTDzOTDzORTPLP8fQdhnJiKwgO/I7xnF9R9ZTSCrmygYnVUFl9sZ2y03ODl3eUhhIDVaoVWq2VmkmBm8mFm8mFm8mFm8hFCoODEGZhmLEPutq8R3CYZ9T6aj9BObdUujcrhi+2MjZYLQgi1S6BKstls0PIGf1JhZvJhZvJhZvJhZvKwmrKR8cYamJZ/AG1cNOIXvISIvrdD0WjULo3c8PZ2xkaLiIiIiKiShNmCrNUfIf21dyAKihD1xAOIfXwwtLzhMP0/NlpERERERBUkhEDeru9gnLQQ5uNnEDn4LsRMGA4Ra4CGFzGhYthoERERERFVQOHhYzBOSkX+np8QelN7JCybguCWTSGEgNlsVrs88jNstFzgCajy4e/Z5cPM5MPM5MPM5MPM/Ivl30tIn7Uc2Rs+hf7KBqjz7myE3dbJ6bMiM5OPtzNjo+UGmy15KIrCnZxkmJl8mJl8mJl8mJn/sOUVIHPRRmTOWw8lJAi1Zj6JqJReUPTOH6GZmXx8kRkbLTd4eXd5CCEceTEzOTAz+TAz+TAz+TAz9QmbDTnvfw7j9KWwXsqAYWRfxIx7EFpDZNmvZ2bS8UVmbLRc4OXd5WOxWLx+l2/yLGYmH2YmH2YmH2amnvzvfrl8w+Ff/0T4PV0R98po6Bsnup2OmcnH25mx0SIiIiKiGs984iyMUxch95M9CG7XHPW2LUDoDa3VLoskxkaLiIiIiGosa2Y2Ml5fBdOKLdDFxyJ+0SuI6N2dNxymamOjRUREREQBJT8/H/n5+eU+HxoaihCdHqZ3tiJj7jsQRWbEPvswDKMHQBMa7MNKKZCx0XKBJzPKh5nJh5nJh5nJh5nJh5lVz7Fjx3D48GEAgNVqRW5uLsLDwy9fZU4ItMmyIWLVpzCfPIfIB3oi9vnh0CXEVes9mZl8vJ0ZGy03uNHIQ1EUnoQqGWYmH2YmH2YmH2ZWfU2bNkVi4uULWJhMJuzZswedO3dG+NlLyJ+9EpbvD0PX9TokrJyG4KuvrPb7MTP5+CIzNlpEREREFFBCQ0MRGhoKAMjMzET+qfOwTVmK7E/3Qn9VQ9TZ8BrCbu3AL9TJq9houcH7aMlDCAGLxQKdTsfMJMHM5MPM5MPM5MPMPMeWm4/CBZtwy/rPIMJDUfvVcYgaeg8UnWc/AjMz+fgiMzZaLvA+WvJhZvJhZvJhZvJhZvJhZtUjbDZkb9qJ9JnLoL+Ugd/bNED88yPR9JabvPeezEw63s6MjRYRERERBYz8b3/GpYmpKDp0FMF3d8XGho2Qr5yD9Zc0NL+uEFERvKog+QZvEEBERERE0is6fhr/PPgCzt//JJQgPRI/WYjcyePwe/7lj7tn/snGv8Y8laukmoRHtIiIiIhIWtZ0EzLmroLpnQ+hq1ML8UsnIeK+W6EoCurmFKJB3UjABDSoG4k6cWFql0s1CBstF3gyo3x4aVX5MDP5MDP5MDP5MDP3RJEZppVbkDF3FYTVhtgJI2AY2c/phsNREcG4u3Mj7Prsd/To3MirPxtkZvLh5d1VxmZLHsxKPsxMPsxMPsxMPszMNSEEcj/9BulTFsF86jyiHrwHMc8Nh652TJmvDwsJgqIoCAsJ8lpNzEw+vsiMjZYbvLy7PIQQsFqt0Gq1zEwSzEw+zEw+zEw+zKx8hb/+iUuvzEfBf39FaLcOqLNmJoKaNXY5TUREhOM/b2Fm8vFFZmy0XOBlOuVjs9mg1WrVLoMqgZnJh5nJh5nJh5k5s5y/AOOMpcjZ/Bn0zRqj7sa5CLu1Q7mvz8/PR35+PoDLRy5iYmKgKArS09MBON/Q2FOYmXy8nRkbLSIiIiLyS7acPGSmrkfmwo3QRISh9uvPInLwXW5vOHzs2DEcPnwYAGC1WlFQUIC9e/c6PlS3bNkSrVq18nr9VLOx0SIiIiIivyKsVmRv3In0mUthM+XAMLo/Yp4cAk1keIWmb9q0KRITE8t93tNHs4jKwkaLiIiIiPxG3p4fYZyYiqIjxxHRuztiXx4FfYM6lRrDGz8NJKosv2q0Tp06hRUrVuDXX3/F0aNH0aRJE2zfvt3lNBcuXMCqVauwd+9enD59GpGRkbjuuuswfvx4l99kVARPZpQPfxstH2YmH2YmH2Ymn5qYWdHRUzBOXoi8z79D8HUtkbhjMUKubaF2WRVWEzOTnbcz86tG6+jRo9i9ezfatGkDm81WoYtRHDlyBLt27UKfPn3Qpk0bZGRkYNGiRejXrx+2b9+O2NjYatXEZkseiqJwJycZZiYfZiYfZiafmpaZ1ZiJ9NfeQdaqj6BLjEfCsikI73WLVJ/BalpmgcAXmflVo9WtWzd0794dADBhwgTHSYyuXHPNNdixYwd0xU6KbN++Pbp27YqtW7di2LBh1aqJl3eXhxDCkRczkwMzkw8zkw8zk09NyUwUFsG0YgsyXl8NCIHYl0fCMKIPNCHeu6mwt9SUzAKJLzLzq0ZLo9FUepqoqKhSj9WpUwexsbG4cOFCterh5d3lY7FYeGd2yTAz+TAz+TAz+QRyZkII5G77GsZpi2E5k4aoB+9F7HMPQ1ur7BsOyyKQMwtU3s7MrxotTzl58iSMRiOuvPLKao9VVrOlKEq5TZi9I3b1vLemrenj2h9jNv47bslp7d8m2b9RCqR5DdT1sHhmMtTry3H9sabieRV/nb/W6481qTmurz+D+GLcgp9/g3HiAhR+fwhht3VE3Xdfhf6qK8oc3x/qrei43v4MwnE9X1PJbawq47oTcI2WEALTp09HfHw8evbsWe3xzGaz0+FEjUbj+Jmi2Wwu9fqgoCAAl+/ZYLPZnJ7T6XRQFAU2mw1Wq9XpOfu4Qogyx7V322WNq9VqodVqIYSAxWJxek5RFMe0Foul1IrirXErMq9A6WVYnXGL51TeMlQUpdLz6i5zNZahfdyyavJWNvZ5LW8Z2sd1tQxLrt/213p7/Xa1DH25fgPy7yOKj6HT6aTaR1Rn/ZZ9H2EfW1EUqfYRxccFat4+wv5elRlX7X1EeeMWnDoH0+wVyNvyJfTNG6P2hjmI6t7RsRxk30fYf5Ul6z7CU+PKtI8QQjjV724fIUTlTycKuEZr/vz52LdvH5YvX46wsLBqj2dfIcp7rjzFV+CSNBpNuT+TLL5yV3Zcd9MWP4/NV+O6mlfA9TKs7LjFN6CyxrXnWJ15VSMbXy5Dd+NWdxmWfK7kDk2NZahWNrLuI+yZFd83cv12Pa6d2vuIsv6e+dsyVGv99td9RHmfQfx5H1GSLScPGW+vg2nxJmgiI1DrjecQOagHlGKvDYR9hBACNptN6n2EL8b1p31EWQ1keTQaTaWbLCDAGq3NmzdjwYIFmDFjBjp27Fjt8ezf/JW1YN0tbFfPe2tajus6M7Vq4riuny++8wqkeQ3kfYQ9s4rkVp2aZBvXH2uyP1cyM0+N60/TBtq45WWmZk2VmVZYrche/wnSZ62ALTsHhkcHIuaJB6CJKP0luD/U64lxvfkZxN/mVa1xPV1T8UaxOjWVJ2AarV27dmHy5Ml44okn0LdvX4+NW9UFS77n7lsO8j/MTD7MTD7MTD6yZ5b39Q8wTkpF0W8nENHvdsS9NBK6xAS1y/Iq2TOriXyRWUA0Wvv378f48ePRr18/jBkzRu1yiIiIiGqcoj9PXr7h8Bf7ENKhNRI/X4qQds3VLotINX7VaOXn52P37t0AgHPnziEnJwc7d+4EAFx//fWIjY1FSkoKzp8/j127dgEAjh8/jjFjxqBRo0bo1asXfvnlF8d4sbGxaNiwYbVqqsqJb6QO+zla9pMpyf8xM/kwM/kwM/nIlpn1UgbS56xE1ppt0DVIQMLKaQi/+2YpavcU2TIj32TmV42W0WjEk08+6fSY/d9r1qxBhw4dSl3h5Ndff0V2djays7MxaNAgp2nvv/9+zJ49u8r1VPVSjqQeZiYfZiYfZiYfZiYfGTKzFRTCtOx9ZL65FlAUxE0aDcOw3lCCg9QuTRUyZEbOvJ2ZIrhWlOnQoUMQQqBVq1b8ZkIS9kt+urpSJPkXZiYfZiYfZiYff89MCIHcrV/BOH0JLOcuwPDwfYh55iFo46LVLk01/p4ZlVbZzA4dOgQAaNWqVYXfw6+OaBERERGR/yr48QguTUxF4Q+HEXZHZ9Td+BqC/v+Gw0TkjI0WEREREblkPv0P0qcvQc6HXyKoRVPU3fIWwm66Ru2yiPwaGy0XeOhXPq5uNkf+iZnJh5nJh5nJx18ys2XnIuOttTAteQ+a6EjUfnsCIgfc6XTDYbrMXzKjivN2Zlwj3GCzJQ93Nwkk/8PM5MPM5MPM5OMPmQmLBVnvfoL02cshcvMRPXYwoscMKvOGw+QfmVHl+CIzNlpu8PLu8hBCwGazQaPRMDNJMDP5MDP5MDP5qJ1Z3pf7cWlSKsx//o2I/nci7qVHoKsX7/M6ZKJ2ZlR5vsiMjZYLvCCjfKxWKzQajdplUCUwM/kwM/kwM/mokVnh7ydgnLQA+f/5HiGd2iLhi+UIbpPs0xpkxu1MPt7OjI0WERERUQ1muZCOjDkrkbV2G/RX1EOd1TMQ1uMmHpkhqiY2WkREREQ1kC2/EKYlm5Hx9jooOi3ipoyBYdj9UIL0apdGFBDYaBERERHVIEII5Hz4JdKnLYbl30swDOt9+YbDMVFql0YUUNhoucBD5vLhb6Plw8zkw8zkw8zk463MCr4/dPmGwz/9hvC7bkLd999A0JUNvfJeNQ23M/l4OzM2Wm6w2ZKHoii8h4VkmJl8mJl8mJl8vJGZ+e/zME5bjNyP/4OgVleh3tZ5CO3czqPvUZNxO5OPLzLjGuEGL+8uj+JXiWRmcmBm8mFm8mFm8vFkZtasHGS+uQaZS9+HNtaA2vNfRGT/O6Dw6ItHcTuTjy8yY6PlAi/vLh+z2Qy9nifxyoSZyYeZyYeZyae6mQmLBVlrtiF9zgqI/ELEPDUU0Y8NhCY81INVUnHczuTj7czYaBEREREFCCEE8r7YB+PkBTAfPY3IgT0Q++Ij0NWppXZpRDUOGy0iIiKiAFB45BiMkxci/+sfEHJjeyQsmojg1klql0VUY7HRIiIiIpKYJc2I9NnLkb3+U+gbJ6LO2lkIu6MzzxUiUhkbLRe4g5IPM5MPM5MPM5MPM5NPRTKz5RfCtGjT5RsOB+tRa/pYRD10HxQ9P96pgduZfLydGbdEN7jRyENRFJ6EKhlmJh9mJh9mJh93mQmbDTkf7EL6jKWwXEiHYUQfxIxPgTY60odVUnHczuTji8zYaBERERFJIv+/v8I4MRWFv/yB8J43o97E0dA3qa92WURUBjZabvA+WvIQQsBisUCn0zEzSTAz+TAz+TAz+ZSVmfnkORinLkLu9t0IbtsM9T5ORWjHNipXSnbczuTji8zYaLnA+2jJh5nJh5nJh5nJh5nJx56ZNTMbGW+ugWnZ+9DWjkX8wpcR0ec23nDYD3E7k4+3M2OjRURERORnhNkC0+qPkfHaOxCFZsQ+/RAMjw6AJixE7dKIqILYaBERERH5CSEEcj/bC+PkhbCcOIvIB3oi9vnhvOEwkYTYaBERERH5gcJDR2GclIr8b35G8I3tkbBsCkJaXaV2WURURWy0XODJjPLR6bhKy4aZyYeZyYeZ+TfLv5eQPms5sjd8Cn3Thqjz7qsIubUDNDwPSyrczuTj7cy4RrjBZkseiqIwL8kwM/kwM/kwM/9ly81H5qKNyJy/HkpIMGrNegpRD97LGw5LiNuZfHyRGbdkN3h5d3kIIWCz2aDRaJiZJJiZfJiZfJiZ/xE2G3Le+xzGGUthNWYiemRfRD81FFrD5RsOMzP5MDP5+CIzNlou8DKd8rFarfyphWSYmXyYmXyYmf/I33sAlyamoujgXwi/9xbEvTIa+kb1Sr2OmcmHmcnH25mx0SIiIiLysqLjZ5A+dRFyP/0Gwe2bo972BQjt0FrtsojIi9hoEREREXmJNSMLGa+vgmnFFujq1EL8kkmIuK8bbzhMVAOw0SIiIiLyMFFkhumdrciY+w6E2YLY54fDMKo/NKHBapdGRD7CRssFnswoH/42Wj7MTD7MTD7MzHeEEMjb8Q2MkxfBfOo8oobcjZjnh0MXH1upcZiZfJiZfLydGRstN9hsyUNRFN7DQjLMTD7MTD7MzHPy8/ORn59f7vPaY2eRM2MZCr77BaFdr0PCqukIvvrKSr8PM5MPM5OPLzLjGuEGL+8uj+JXiWRmcmBm8mFm8mFmnnPs2DEcPnwYAFBQUIBLly6hVq1aiCywoP72/aj1w18ISroCdTa8hrBbO1R5eTMz+TAz+fgiMzZaLvDy7vIxm83Q6/Vql0GVwMzkw8zkw8w8o2nTpkhMTAQA/PHHH/jn5N9ofzoPEVv3QAkLRdT0sYgbdj8UD3xLzszkw8zk4+3M2GgRERERVUBoaChCQ0MhrFaE/ucA7lmzF6GFFkQ/OhDRTw2BNipC7RKJyI+w0SIiIiKqoLxvfsLFl+cj6rfjONk0AT/e3gOPjR8CbQSvJkhEzthoEREREblRdOw0jFMWIW/ntxCtkvFOz7uha1SIv/M0+NeYhyg2WkRUAq9DSURERFQOa7oJl158G2duehBFR44hYelk1P4oFUqby1cTbFA3EnXiwlSukoj8EY9ouaAoCq8cIxFFUaDX65mZRJiZfJiZfJhZ1YjCIphWbkHG66shrDbEvvAIgofejQJhBcx56Na2Nr79Bri5bW1YinKRnp7rOIerupiZfJiZfHyRGRstCijcwcmHmcmHmcmHmVWcEAK5n+yBccoiWE7/g6iUexHz7DDoasfg0KFDjsu75+TkQFEUHD/2F9L+PQ8AaNmyJVq1auWROpiZfJiZfLydGRstN3gfLXkIIWC1WqHVapmZJJiZfJiZfJhZxRX88geMr6SiYN+vCLv1BtRdOwtBzRo7ni9+eXeTyYQDBw6gXbt2MBgMAOCRo1kAM5MRM5OPLzJjo+UC76MlH5vNBq1Wq3YZVAnMTD7MTD7MzDXLuTQYZyxFznufI6h5E9TdNBdh3TqUel3xnwbGxsaicePGpV7jKcxMPsxMPt7OzK8arVOnTmHFihX49ddfcfToUTRp0gTbt293O50QAsuWLcP69euRnp6O5s2b44UXXkDbtm29XzQRERFJyZaTh8z565G5cAM0keGo/caziBx0l0duOExE5FdXHTx69Ch2796NK664AldeeWWFp1u2bBnmzZuHhx56CEuWLEHt2rUxbNgwnDlzxovVEhERkYyE1YqsddtxusMgZC7YAMPoAWi4fwOiht7LJouIPMavGq1u3bph9+7dmDdvHlq0aFGhaQoLC7FkyRIMGzYMDz30EDp27Ig33ngD0dHRWLFihZcrJiIiIpnk7f4RZ28djovjXkXoTdegwX/fRdxLI6GJDFe7NCIKMH71tY1GU/m+7+eff0ZOTg569OjheCwoKAi33XYbdu3aVa16eDKjfPjbaPkwM/kwM/kwM6Dor79hnLwQebv+i5DrWiJx52KEXFOxL3XVwMzkw8zk4+3M/OqIVlWcOHECANCkSROnx6+88kqcP38eBQUF1RqfzZY8FEXh1X4kw8zkw8zkU9Mzs17KwMXn38SZLg+h6K+/kbBiKup9stCvm6yanpmMmJl8fJGZXx3RqoqsrCwEBQUhODjY6fGoqCgIIWAymRASElLl8W02W6kAFEUp94qE9te6et5b09b0cYs/VtZGw2zUH7fktEIIxy0UNBpNQM1roO4jimdm/8+f6/XluP5Ykz2v4pn5c72erEkUFsG0/ANkvrkWEAKxL4+EYUQfKMFBTu/jj+uhEMLx+cOXn0E4btXH9fZnEH+aVzXH9WRN9n2jRqOp8vy4I32j5U1CCJjNZqcNRqPRQPf/J8qazeZS0wQFXd6BW61W2Gw2p+d0Oh0URYHNZoPVanV6zj6u/T1L0uv15Y6r1Wqh1WohhIDFYnF6TlEUx7QWi6XUiuKtcSsyr0DpZVidce0bgk6nK3cZKopS6Xl1l7kay9A+blk1eSsb+7yWtwzt47pahiXXb/tr7ZdL9tb67WoZ+nL9BuTfR9jH0Ol00Ol0Uu0jqrN+y76PsGdm/+Auyz6i+LhAxZahEAL52/cgc+YyWM+lISrlPsQ++xBshghYhACKje/P+4jCwsJS37bLsI/w1Liy7SM0Go3jUuEy7iM8Na4M+wg7IS7fR8v+GcTd5wj7F1aVIX2jFRUVhaKiIhQWFjod1crKyoKiKI6bCFaVfYUo77nyFF+BS9JoNOWej1Z85a7suO6mta/4vhzX1bwCrpdhZcctvgGVNa49x+rMqxrZ+HIZuhu3usuw5HMld2hqLEO1spF1H2HPrPi+keu363Ht1N5HlPX3zN+WYXXXb+uhozC+korCHw4j7PZOiF3/KoKTL9/rSuPiG2l/3UeU9xnEn/cRnh5Xln1E8aOQsu4jfDGu2vsIV59B3M1rZZssIAAaLfu5WSdPnkSzZs0cj584cQL16tWr1s8GAZR52N7+uLvpqvJcdabluP97zh9r4rhlP188r0Ca10DeR9gzq0hu1alJtnH9sabiGZW1b/S3eqs6rflsGtKnL0HOB7sQ1OJK1H3/TYTdfK1HalIzc19/BuG4nhnXG+/rr/Pq63E9XVPJv21Vrak80jda7du3R0REBHbs2OFotMxmMz7//HN06dJF5eqIiIjIW2zZuch4ex1MSzZDExWB2m8+j8hBPaDw6m9E5Af8qtHKz8/H7t27AQDnzp1DTk4Odu7cCQC4/vrrERsbi5SUFJw/f95x6fbg4GCMGjUK8+fPR2xsLJKSkrBhwwZkZmZi+PDh1aqnqt0rqacqtwggdTEz+TAz+QRaZsJiQfb6T5E+ezls2bmIfmwQoscOhiYiTO3SPCbQMqsJmJl8vJ2ZXzVaRqMRTz75pNNj9n+vWbMGHTp0KPPEu0ceeQRCCKxcuRLp6elo3rw5VqxYgQYNGlS7JjZb8lAUxeXva8n/MDP5MDP5BFpmef/5HsZJC1D0+wlE9L8DcS8+Al1igtpleVSgZVYTMDP5+CIzRVT1eoUB7tChQwCAVq1aqVwJERERFf15EsZJC5H35T6E3NAGcdMeR0jbZu4nJCLygKr0Bmy9XSh+7xHyf/ZLfrq6UiT5F2YmH2YmH9kzs1zMQMacFchaux26BnWQ8M50hPfsIuW8VJTsmdVEzEw+vsiMjRYRERH5HVtBIUxL30fGm2ugaDWImzQahmG9HTccJiLyd2y0iIiIyG8IIZC79SsYpy2G5Z+LMDx8P2KeeQja2OrdF5OIyNfYaBEREZFfKPjhMC5NTEXhj0cQdueNqLv5dQQ1bah2WUREVcJGi4iIiFRlPv0P0qctRs7WrxDU8irU+/BthN7YXu2yiIiqhY2WCzyZUT56vV7tEqiSmJl8mJl8/DUza1YOMt9aB9PS96CJjkTteS8gsv8dvOEw/DczKh8zk4+3M2Oj5QabLXkwK/kwM/kwM/n4Y2bCYkHWuu1If3UFRG4+op94ANGPDQyoGw5Xhz9mRq4xM/n4IjM2Wm7w8u7yEELAarVCq9UyM0kwM/kwM/n4W2a5X+yDcfICmP86hcj+dyD2pZHQ1a2tdll+xd8yI/eYmXx8kRkbLRd4L2f52Gw2aPmTE6kwM/kwM/n4Q2aFvx2HcdIC5H/9A0I6tUXCrpcR3CZZ1Zr8mT9kRpXDzOTj7czYaBEREZHXWC6kI+PVFchatx36RvVQZ81MhN15I7/1J6KAx0aLiIiIPM6WXwjTks3IeGstFL0OcVMfh+Hh+6AE8YIBRFQzsNEiIiIijxE2G3I+/BLp05fA8u8lGEb0Qcz4FGhjotQujYjIp9houcCfNciHv42WDzOTDzOTj68yy99/EMaJqSj8+XeE9+yCuu+/iaArG/jkvQMNtzP5MDP5eDszNlpusNmSh6Io3MlJhpnJh5nJxxeZmf8+D+O0xcj9+D8Iap2EelvnIbRzO6++ZyDjdiYfZiYfX2TGRssNXt5dHkIIR17MTA7MTD7MTD7ezMxqykbGm2tgWvYBtHHRiE99CRH9boei0Xj0fWoabmfyYWby8UVmbLRc4OXd5WOxWHhndskwM/kwM/l4OjNhtiBrzcdIn7MSoqAQMeMfRPSjA6EJC/HYe9R03M7kw8zk4+3M2GgRERFRhQghkLfrvzBOXgjzsdOIHHQXYl8YAV2dWmqXRkTkd9hoERERkVuFh4/BOCkV+Xt+QuhN7ZGwZBKCW12ldllERH6LjRYRERGVy/LvJaTPXo7s9Z9Cf2UD1Fk3G2G3d+J5KEREbrDRcoF/ROTDzOTDzOTDzORTlcxseQUwLdqEjHnvQgnWo9bMJxGV0guKnh8dfIHbmXyYmXy8nRn3lm5wo5GHoig8CVUyzEw+zEw+lc1M2GzIef9zGGcsg/ViOgyP9EXMuAehjY70YpVUHLcz+TAz+fgiMzZaREREBADI/+6Xyzcc/vVPhN99M+ImPgp940S1yyIikhIbLTd4Hy15CCFgsVig0+mYmSSYmXyYmXwqkpn5xFkYpy5G7ie7Edy2Gep9nIrQjm18XCnZcTuTDzOTjy8yq1ajlZ6ejoyMDCiKgpiYGMTExHiqLr/A+2jJh5nJh5nJh5nJp7zMrJnZyHhjNUzLP4C2diziF72CiN7decNhP8DtTD7MTD7ezqxSjVZeXh527tyJL7/8EgcOHEBGRobT8zExMWjbti26d++OO++8E2FhYR4tloiIiKpPmC0wvbMVGXPfgSg0I/aZh2EY3Z83HCYi8qAKNVoZGRlYunQpNm7ciKKiIiQnJ+PWW29FgwYNEBUVBSEEsrKycPbsWRw5cgSvvPIKpk2bhoEDB+KRRx5BbGyst+eDiIiI3BBCIO+zvZdvOHzyHCIH34XYCSOgS4hTuzQiooBToUarW7duuOKKK/Dcc8/hjjvucNs4paen47PPPsPmzZuxadMm/Pzzzx4ploiIiKqm8NBfME5aiIJvf0bozdciYcVUBLdoqnZZREQBq0KN1rx583DTTTdVeNDY2FgMGjQIgwYNwjfffFPl4tTGkxnlo9Px+i6yYWbyYWZysfx7CRkzlyFn007omzZEnfVzENb9Bv6N83PczuTDzOTj7cwqNHplmixPTusP+IdIHoqiMC/JMDP5MDN52HLzkblwIzJT10MJDUat2eMQNfQe3nBYAtzO5MPM5OOLzKq9ty0qKkJQUJAnavFLvLy7PIQQsNls0Gg0zEwSzEw+zMz/CZsN2Zs/Q/qMpbCmm2AY2ReGJx6ALjqKmUmC25l8mJl8fJFZha/feuDAAdx66624/fbb8Z///Mfx+IgRI7xSmD/gZTrlY7Va1S6BKomZyYeZ+a/8vQdw9rZHcHHsTIR0aI2G361D3MRHIcJD1S6NKonbmXyYmXy8nVmFj2jNnDkTDz74IIQQePbZZzF27FikpKSwGSEiIlJZ0fEzSJ+6CLmffoPga65G4icLEXJ9KwD80pCISC0VbrR0Oh1SUlIAAJ06dcLIkSMRFBTEw6NEREQqsWZkIWPuKphWboGuTi3EL52EiPtu5d9mIiI/UKVztJKSkrB27VqkpKQgNzfX0zURERGRC6LIDNPKD5Hx+ioIixWxE0bAMLIfNKHBapdGRET/r8LnaF1zzTU4deqU498NGjTA6tWr0aRJE68U5g/4jaB8tFqt2iVQJTEz+TAz9QghkPvpHpy58UEYJy1ARK9uaLh/A2KeHOKyyWJm8mFm8mFm8vF2Zorgj7fLdOjQIQBAq1atVK6EiIgIKPz1T1x6ZT4K/vsrQm+5HnFTxiC4eeB+2UlE5E+q0ht47GYa+fn5+OSTT1BUVISbb74ZiYmJnhpaVby8uzyKf2fAzOTAzOTDzLwnPz8fv/32GwDg6quvRmjo5SsFWs5fgHHGMuRs3gl9s8aou3Euwm7tUOFxmZl8mJl8mJl8fJFZlRqtF198EQcPHsT27dsBXL6XVv/+/XH06FEAQGRkJFavXo2rr77ac5WqgAf75GM2m6HX69UugyqBmcmHmXlOfn4+8vPzAQAmkwkHDhwAAMTGxiJKFwTL6u3IXfoelPBQ1Jr7DKIe6AlFV/k/3cxMPsxMPsxMPt7OrEqN1v79+3Hvvfc6/r19+3YcPXoUc+fORbNmzTB27FikpqZi4cKFHiuUiIgo0Bw7dgyHDx8GAOTk5iEt7QJ0Gg3+nLsMV+z8Cfr8IsQ8OgAxTw2FJjJc5WqJiKgyqtRoXbp0yemngV988QVatmyJu+++GwDQv39/rFixwjMVEhERBaimTZsiMTEROXlFWPret6h74hCu/+4oYi9lQX93F8S8MAKRSY3VLpOIiKqgSo1WaGgosrOzAQAWiwXff/89hgwZ4ng+PDzc8TwRERGVLTQ0FKGhobh46CA6rt2KZmdOIS0hGtmpE9F2wG1ql0dERNVQpUarRYsW2Lx5Mzp06ICvvvoKubm56Natm+P506dPIy4uzmNFqoUnM8qHmcmHmcmHmXlOzrl/kTl3FXQbdyIxPBz/ub0VzjRrgn6tGiI9Pd3RiFUXM5MPM5MPM5OPtzOrUqP11FNPYcSIEejTpw+EELjjjjvQunVrx/O7du1C+/btPVakmrjRyENRFJ6EKhlmJh9m5hmisAimFVtwac5KWK1WnL/repy49kqkpRsRqrPipx/24VBQEFq2bFnt24wwM/kwM/kwM/n4IrMqNVqtWrXCjh078PPPPyMqKgrXX3+947msrCwMHjzY6TEiIiL6/xsOb98N49RFsJxJQ/jgHtA/2g+146LRyGTCl19+CQDo0qULDAaDR45mERGROqp8H63Y2Fh079691ONRUVFISUmpckHHjx/H9OnTceDAAYSHh6NXr1546qmnEBQU5HK6jIwMvPnmm9izZw8yMzNRv359PPDAAxg0aFCVawF4Hy2ZCCFgsVig0+mYmSSYmXyYWdUVHPgdxldSUbD/IMK634C662YjKPl/F7oIDQ1Fu3btAAB16tTxWJPFzOTDzOTDzOTji8wq1Gj9888/qFu3bpXeoDLTmkwmpKSkoFGjRpg/fz7S0tIwe/ZsFBQUYOLEiS6nffLJJ3HixAmMHz8edevWxZ49ezB58mRotVr079+/SrXzPlryYWbyYWbyYWaVYzmXBuOMpch573MENW+CuptfR9gtpX/1ERoaimuuucYrNTAz+TAz+TAz+Xg7swo1WrfddhvuueceDBo0yOlcLFd+/vlnbNy4ETt27MChQ4cqNM3GjRuRm5uL1NRUREdHAwCsViumTJmCUaNGISEhoczpLl68iP3792PWrFno3bs3AKBjx444dOgQPvnkkyo3WkRERFVly8lDxrx3YVq0EZrICNR+41lEDu4JRatVuzQiIvKBCjVa69evx1tvvYX+/fujXr16uOGGG9CiRQvUr18fUVFREEIgKysLZ8+exeHDh7Fv3z6kpaWhQ4cOePfddytczJ49e9CxY0dHkwUAPXr0wKRJk7B3715HE1WSxWIBAERGRjo9HhERgby8vAq/PxERUXUJqxXZ6z9F+qzlsGXnwPDoQMQ88QA0EWFql0ZERD5UoUardevWWLlyJX7//Xd88MEH+Oqrr7BlyxYA/7sqn/3QW926ddG9e3f06dMHzZs3r1QxJ06cQJ8+fZwei4qKQu3atXHixIlyp6tbty5uvPFGLF68GI0bN0adOnWwZ88e7N27F3Pnzq1UDURERFWV9/UPME5KRdFvJxDR9zbEvjQK+vpl/xqDiIgCW6UuhtG8eXO8/PLLePnll5GWloYTJ04gMzMTABAdHY0mTZqU+/O+isjKykJUVFSpxw0GA0wmk8tp58+fj3HjxqFnz54AAK1Wi5dffhl33HFHletRFKXM326W97j9OaD833x6c9qaPq4QAjqdjtn48bglpxVCQKvVOi46E0jzGqjrYfHMZKjXV+Oa//obxskLkffFPgRf3wr1di5GSPurHeOpOa8lM/PUuN6o1x9rUmvckpn5Q00ct/xxvf0ZhON6vib7vrH4vys7rjtVvupgQkJCtZoqTxJC4IUXXsDff/+N119/HbVr18Z3332HmTNnwmAwOJqvqrD/LNFOo9FAp7u82Mxmc6nX26+OaLVaYbPZnJ6zX9XEZrPBarWWOa4Qosxx7df5L2tcrVbr2CGXrLf4PQIsFkupFcVb41ZkXoHSy9AT47pahoqiVHpe3WWuxjK0j1tWTd7Kxj6v5S1D+7iulqFa67erZejL9RvgPqIy8wr4z/pd3rxajZnIemMNctZuh65BAuKWTkLoXTdBURTHe6i9j/Dl+s19hPO8VnUfYV9OJaflPsJ5XgH/20fYbLZS0/JzhPO8+ts+ovi+0tU+wv6lWWVUudHyhqioKGRnZ5d63GQywWAwlDvd119/jZ07d+Ljjz9GcnIyAKBDhw4wGo2YPXt2tRotV5d8dHWTs+IrcEkajQYajabM54qv3JUd19209hXfl+O6mlfA9TKs7Lj2P0rl1Vv8W8Kqzqsa2fhyGbobt7rLsORzQginnZcay1CtbGTdR9gz02g0jvWhJq7ftoJCZC3fgow310BRFMRNHA3D8N5AkP/tI3Q6XanMPDGuL/YRJdWUfYT9w155n0H8eR/h6XFl2Ue4+wxSkXpr+jIs/hpf7CNKfgZxN6+VbbIAP2u0mjRpUupcrOzsbFy8eBFNmjQpd7pjx45Bq9UiKSnJ6fHmzZvjvffeQ35+fpXuR2Jf8GUtWHcL29Xz3pqW417+NsL+bYm/1MRxXT9vs9kcO8VAmtdA3kfYMyveaHli3Mo8p9a4AJD78dcwTlsEy9kLiHqoF2KffRjauGiX03izpoo8VzIzT43rT9MG2rjlZaZmTRzX9fPe/Azib/Oq1rierslTn0HKU34bqoIuXbrgu+++Q1ZWluOxnTt3QqPRoHPnzuVOl5iYCKvVij///NPp8SNHjiAuLs5jN30kIqKaq+CnIzjf8zGkjZiIoGZN0OCb1ag9e1yFmiwiIqp5/OqI1sCBA7F27VqMGTMGo0aNQlpaGubMmYOBAwc6nQ+WkpKC8+fPY9euXQAuN2j16tXDE088gTFjxiA+Ph7ffvstPvzwQ4wdO1at2SEiogBgPvMv0qcvQc6WLxDUoinqfvAmwrpcq3ZZRETk5/yq0TIYDFi9ejWmTZuGMWPGIDw8HH379sW4ceOcXlfy5LuIiAisWrUKb775JubOnYvs7GzUr18fEyZMwJAhQ3w9G0REFABs2bnIeHsdTIs3Q2OIQO23JiBy4J284TAREVWIIqp6vcIAd+jQIQBAy5Ytq/y7TPIt+4mo5f2mnfwPM5NPTchMWCzIevcTZLy6AracPEQ/NhDRjw+W9obDNSGzQMPM5MPM5FPZzOy9QatWrSr8HhU+R+vEiRNISUnBww8/jCNHjjgeHzNmTIXfTEbcWORhv2IMM5MHM5NPoGeW99V+nLllGC49Mxeht3RAw33rETthhLRNFhD4mQUiZiYfZiYfX2RW4UZr0qRJSE5ORtOmTTFkyBB89tlnAOB04YpAxAN+8rDfmJOZyYOZySdQMyv64yTOD3gG/wx4BtqYKCTuWoaEBS9BVy9e7dKqLVAzC2TMTD7MTD6+yKzC52gVFhbixRdfBAB069YN48aNC/jOnRuLfMxms8v7K5D/YWbyCaTMLBfSkTFnJbLWboOuYV0krJqB8P+/4XAgCaTMagpmJh9mJh9vZ1bhRqv4Tbw6duyIpUuX4rHHHnN5ozIiIiJ/ZCsohGnJe8h4ay0UrQZxU8bAMOx+KC5uOExERFQZFe6S6tevj1OnTjn+3bp1ayxcuNArRREREXmDEALZH36BM52GIH32ckQN7omG329E9Oj+bLKIiMijKnxEq1+/foiMjHR6rHXr1tizZ4/HiyIiIvK0gh8O49LEVBT+eARhPW5E3fdeR9CVDdUui4iIAlSFj2g9+OCD2Lt3rzdrISIi8jjzqfP4d8QknLvrUYiCItT78G3UXTOLTRYREXlVhY9o1cQLQyiKEnAnRAcyRVGg1+uZmUSYmXxkysyalYPMt9Yic8l70MYaUHveC4jsf0eNu+GwTJnRZcxMPsxMPr7IrMKNFpEMuIOTDzOTj79nJiwWZK3ZhvQ5KyDyCxHz1FBEPzYQmvBQtUtTjb9nRqUxM/kwM/l4O7NKNVo1cQUSQtTI+ZYR78ouH2YmH3/OTAiBvC/2wTh5AcxHTyNywJ2IffER6OrWVrs0VflzZlQ2ZiYfZiYfX2RWqUbr2WefxbPPPluh1yqKgt9++61KRfmLmvhzSdnZbDZoa9jPgmTHzOTjj5kV/nYcxkkLkP/1Dwjp3A4JC19BcJtktcvyG/6YGbnGzOTDzOTj7cwq1Wh16tQJjRo18lIpRERElWNJMyL91RXIfvcT6BvVQ521sxB2R2d+o0xERKqrVKN133334Z577vFWLURERBViyy+EafEmZLy9Dopeh7hpY2F4qBfvhUVERH6DF8MgIiJpCJsNOVu+QPr0JbBcSIdheG/EjE+BNiZK7dKIiIicsNFygT89kY9Ox1VaNsxMPmpllr/vIIwTU1F44HeE97wZ9SaOhr5JfVVqkQ23M/kwM/kwM/l4OzOuEW6w2ZIH73smH2YmHzUyM588B+O0xcjd9jWC2ySj3kfzEdqprU9rkBm3M/kwM/kwM/n4IrMKN1p//PGHN+vwW7y8uzyEEI68mJkcmJl8fJmZ1ZSNjDfWwLTsfWhrxSB+wUuI6Hs7FI3Gq+8baLidyYeZyYeZyccXmfGIlgu8vLt8LBYL9HqeDC8TZiYfb2cmzBZkrf4I6a+9A1FQhNinH4Lh0QHQhIV47T0DHbcz+TAz+TAz+Xg7MzZaRETkF4QQyNv1HYyTFsJ8/AwiB9+F2AkjoKtTS+3SiIiIKo2NFhERqa7w8DEYJ6Uif89PCO1yDRKWTUFwy6Zql0VERFRlbLSIiEg1ln8vIX3WcmRv+BT6KxugzruvIuy2jjzHgYiIpMdGywX+oZePhifJS4eZyccTmdnyCpC5aCMy562HEhKEWrOeQtSD90LR88+SN3A7kw8zkw8zk4+3M+NfNDfYbMlDURTew0IyzEw+1c1M2GzIef9zGKcvhfVSBgwj+yJm3IPQGiI9WCUVx+1MPsxMPsxMPr7IjGsEBRRejl8+zEw+Vc0sf+8BGCctQOGvfyL8nq6Ie2U09I0TvVAhlcTtTD7MTD7MTD7ezoyNlgvFr69P/k8IAbPZDL1ez8wkwczkU5XMzCfOwjh1EXI/2YPgds1Rb9sChN7Q2suVkh23M/kwM/kwM/n4IjM2WkRE5BXWzGxkvL4KphVboIuPRfziiYi4/1becJiIiGoENlpERORRosgM0ztbkfH6KogiM2KffRiG0QOgCQ1WuzQiIiKfYaNFREQeIYRA3s5vYZy8EOa/zyNqyN2IeW4YdAlxapdGRETkc2y0iIio2gp//ROXJi1Awd4DCO16HRLemY7gq69UuywiIiLVsNFygSczykev16tdAlUSM5NP8cws/1xE+oylyN78GfRXNUSdDa8h7NYO3H/6GW5n8mFm8mFm8vF2Zmy03OCHBXkwK/kwM/nYM7Pl5iNjwQZkLtgAJTQYtV4dh6ih90DhfWT8Drcz+TAz+TAz+fgiM/5FdIOXd5eHEAJWqxVarZaZSYKZycdmtSJr4w5kzl4Ba7oJ0aP6IfqpodBGRahdGpWD25l8mJl8mJl8fJEZGy0XhBBql0CVZLPZoNVq1S6DKoGZySP/259xaWIqig4dRfh93RD38ijor6indllUAdzO5MPM5MPM5OPtzNhoERGRS0XHT8M4ZRHydnyL4GuuRvxH8xDRsS2/tSUiInKBjRYREZXJmm5CxtxVML3zIXR1ayN+6SSE9+oGi8WidmlERER+j40WERE5EUVmmFZuQcbcVRBWG2JfeASGkX2hCQnmT6qJiIgqiI2WC/xZjHz422j5MDP/IYRA7qffIH3KIphPnUfUg/cg5rnh0NWOcXodM5MPM5MPM5MPM5OPtzNjo+UGmy15KIrCnZxkmJn/KPjlDxhfSUXBvl8R2q0D6qyZiaBmjUu9jpnJh5nJh5nJh5nJxxeZsdFyg5d3l4cQwpEXM5MDM1Of5fwFGGcsRc7mz6Bv1hh1N81FWLcO5b6emcmHmcmHmcmHmcnHF5mx0XKB5yLIx2Kx8M7skmFm6rDl5CEzdT0yF26EJiIMtV9/FpGD76rQDYeZmXyYmXyYmXyYmXy8nRkbLSKiGkRYrcjeuBPpM5fCZsqBYXR/xDw5BJrIcLVLIyIiCihstIiIAkR+fj7y8/MBACaTCQcOHEC7du1gMBgAAJqf/kD2jKUoOnIcEX1uQ+xLI6FvUEfNkomIiAIWGy0iogBx7NgxHD58GACQk5ODf//9F0ajEbVyzWiw9TvEHDmFkOtaInHnYoRc00LlaomIiAIbGy0XeDKjfJiZfJiZ5zRt2hSJiYkAgF9+PYT0E6dw7Z6/ELXre2jq1IJh4cuI6Xt7tZc5M5MPM5MPM5MPM5OPtzPzu0br+PHjmD59Og4cOIDw8HD06tULTz31FIKCgtxOm5aWhjfeeAO7d+9GXl4eEhMT8eijj+Lee++tcj3caOShKApPQpUMM/Os0NBQhIaGwmTMxoXFO3Hvt/sARYPwZ4cjfswAaEKCq/0ezEw+zEw+zEw+zEw+vsjMrxotk8mElJQUNGrUCPPnz0daWhpmz56NgoICTJw40eW0Fy5cwIABA9C4cWNMmzYNEREROHr0KIqKinxUPRGRuoQQyN32NS5OXIBrzl/AXy3rY3vLGzGu7z2o44Emi4iIiCrOrxqtjRs3Ijc3F6mpqYiOjgYAWK1WTJkyBaNGjUJCQkK507722muoU6cOli9f7rj5WMeOHatdE++jJQ8hBCwWC3Q6HTOTBDPznIKff7t8w+HvDyG4Wwds7Hk7cvT/Is4QjzpxYR57H2YmH2YmH2YmH2YmH19kpvHKqFW0Z88edOzY0dFkAUCPHj1gs9mwd+/ecqfLycnBjh07MHjwYI/e4Zn30ZIPM5MPM6se89k0pI2einN3jIIlKwcRK6cgfNGLuKZ7MrQaoFvb2rAU5SI9Pd1xRcLqYmbyYWbyYWbyYWby8XZmfnVE68SJE+jTp4/TY1FRUahduzZOnDhR7nRHjhyB2WyGTqfDkCFDcODAAURHR+O+++7DU089xd/MElHAseXkIePtdTAt3gRNZARqv/EcTrVqiO9+/w347DPk5ORAURQcP/YX0v49DwBo2bIlWrVqpXLlRERENYNfNVpZWVmIiooq9bjBYIDJZCp3ukuXLgEAXn75ZfTv3x+PP/44Dh48iHnz5kGj0eDpp5+uck1ldbqKopTbAdsPPbp63lvT1vRx7Y8xG/8dt+S0QgjHf4E2r14b12pF1rufIGP2Ctiyc2B4bCCiHx8MTUQYmhYUoF6D+gBK30dLURSEhISUu0+raE3FM/P6vEo2rj/WVDyv4q/z13r9sSY1x/X1ZxCOW/Vxvf0ZhON6vqaS21hVxnXHrxqtqrLZbACATp06YcKECQCAG264Abm5uVi5ciXGjBmDkJCQKo1tNpudfrep0Wig0+kcz5Vkvzqi1Wp11GVn/w2ozWaD1Wp1es4+rhCizHHtR+XKGler1UKr1Tp+a1pc8SuqWCyWUiuKt8atyLwCpZdhdcYtnlN5y1BRlErPq7vM1ViG9nHLqslb2djntbxlaB/X1TIsuX7bX+vt9dvVMvTl+g1Ubx9R9M3PME5agKLfTyCsd3cYJgyHLjEeVlz+HXhoaCj0ej1sNhsiIyNRv359p3m12WyVXl9KZlN8eel0Oqn2EdVZv2XfR9jHVhRFqn1E8XGBmrePsL9XZcbl5wh11m+N5vLZOLLuIzw1rkz7CCGEU/3u9hFCVP66DX7VaEVFRSE7O7vU4yaTCQaDweV0wOXmqriOHTti8eLFOHXqFJKTkytdj31FK2+huvpJYvEVuCSNRuPYIMt7z6qM625a+4rvy3FdzSvgehlWdlz7BiCEKHNce47VmVc1svHlMnQ3bnWXYcnnSmalxjJUK5vK7COK/vwbFyYvQP6X+xHSoTXqfbYEIe2aV3pcT+wjimdmXx+4frse107NfUTJzDw1bkme3keUVJP2EfYviMv6DMLPEf/jL/sIIUSpfWRl663py7D4a3yxjyiZlbt5rWyTBfhZo9WkSZNS52JlZ2fj4sWLaNKkSbnTNW3a1OW4hYWFVa7J1Y7MFVfPe2vamj5u8Q99nhzXE9Ny3LKfL/naQJpXT4xruZiBjNdWImvNNugaJCBh5TSE332zqjW52vY8XZNs4/pjTfYjWN4Y15VAW4a+Hrc6uXmrJo7r+nlvfwbhuJ6vyZOfQcrjV1cd7NKlC7777jtkZWU5Htu5cyc0Gg06d+5c7nSJiYlISkrCd9995/T4d999h5CQELeNmCtV/U0m+Z79EDAzkwczK5utoBAZ897FmQ6DkPPBF4ibNBoNv12LiHu6Vnln7ynMTD7MTD7MTD7MTD6+yMyvGq2BAwciPDwcY8aMwbfffosPPvgAc+bMwcCBA53uoZWSkoLbbrvNadpx48bhq6++wowZM7B3714sXrwYK1euxEMPPYSwsKrdQ4Ybi3xK/laY/B8z+x8hBHI+/BJnOg1B+sxliBxwJxp+vwHRjw6EEhykdnkOzEw+zEw+zEw+zEw+3s7Mr346aDAYsHr1akybNg1jxoxBeHg4+vbti3Hjxjm9rqyT77p164Y33ngDCxcuxIYNGxAfH4+xY8di5MiRvpwFIqIqKfjxCC5NTEXhD4cRdkdn1N00F0FXXaF2WURERFRFiuBhmzIdOnQIQgi0atVK9Z/qUMXYr0Tj6gIm5F+YGWA+/Q/Spy9BzodfIqjlVYibOgZhN12jdlnlYmbyYWbyYWbyYWbyqWxmhw4dAoBK3Y/Sr45oERHVFLbsXGS8tRamJe9BEx2J2m9PQOSAO6GUc7UkIiIikgsbLRf4jYR8yrukJ/mvmpaZsFiQtW470l9dAZGbj+ixgxE9ZhA0EVU7l1QNNS2zQMDM5MPM5MPM5OPtzNhoucFmSx6KonAnJ5mallnel/txaVIqzH/+jcgBdyL2xUegqxevdlmVUtMyCwTMTD7MTD7MTD6+yIyNlhtVuQs0qUMI4ciLmcmhpmRW+PsJGCctQP5/vkdIp7ZI+GI5gttU/ibq/qCmZBZImJl8mJl8mJl8fJEZGy0XeJ0Q+VgsFpd3DCf/E8iZWS6kI2POSmSt3Qb9FfVQZ/UMhPW4Sfo/woGcWaBiZvJhZvJhZvLxdmZstIiIPMyWXwjTks3IeHsdFJ0WcVMfh+Hh+6AE8Q8wERFRTcFGi4jIQ+w3HE6fthiWfy/BMLw3Yp5+CNqYKLVLIyIiIh9jo0VE5AEF3x+6fMPhn35D+F03oe77byDoyoZql0VEREQqYaPlguznUdREzEw+smdm/vs8jNMWI/fj/yCo1VWot3UeQju3U7ssr5I9s5qImcmHmcmHmcnH25mx0XKDG408FEXhSaiSkTkzqykbmW+tRebS96GNNaD2/BcR2f8OKBqN2qV5lcyZ1VTMTD7MTD7MTD6+yIyNFhFRJQiLBVlrtiF9zgqI/ELEjBuK6EcHQhMeqnZpRERE5EfYaLnB+2jJQwgBi8UCnU7HzCQhU2ZCCOTt+i+MUxbCfPQ0Igf2uHzD4Tq11C7Np2TKjC5jZvJhZvJhZvLxRWZstFzgfbTkw8zkI0NmhUeOXb7h8O4fEXJjeyQsnoTgVlepXZZqZMiMnDEz+TAz+TAz+Xg7MzZaRETlsKQZkT57ObLXfwp940TUWTcbYbd34reVRERE5BYbLSKiEmx5BTAt2oSMee9CCdaj1vSxiHroPih67jKJiIioYvipgYjo/wmbDTkf7IJx+lJYL6bDMKIPYsanQBsdqXZpREREJBk2Wi7w50Hy0em4SsvGXzLL/++vME5MReEvfyC8582Imzga+ib11S7LL/lLZlRxzEw+zEw+zEw+3s6Ma4QbbLbkoSgK85KMP2RmPnkOxqmLkLt9N4LbNkO9j1MR2rGNqjX5M3/IjCqHmcmHmcmHmcnHF5mx0XKDl3eXhxACNpsNGo2GmUlCzcysmdnIeGM1TMs/gLZ2LOIXvoyIPrcF/A2Hq4vbmXyYmXyYmXyYmXx8kRkbLRd4mU75WK1WaPhBWSq+zkyYLchatRXpr70DUWhG7NMPwfDoAGjCQnxWg+y4ncmHmcmHmcmHmcnH25mx0SKiGkEIgbzPv4Nx0gKYT5xF5AM9Efv88Bp3w2EiIiLyDTZaRBTwCg8dhXFSKvK/+RmhXa5BwvKpCG7ZVO2yiIiIKICx0SKigGX59xLSZy5D9sYd0DdtiDrvvoqw2zry9/NERETkdWy0XOCHMfnwt9Hy8UZmttx8ZC7aiMz566GEBKPW7HGIGnoPbzjsIdzO5MPM5MPM5MPM5OPtzPipww02W/JQFIX3sJCMpzMTNhty3vscxhlLYTVmInpkX0Q/NRRaA2847CnczuTDzOTDzOTDzOTji8y4RrjBy7vLo/hVIpmZHDyZWf7eA7g0MRVFB/9C+L23IO6V0dA3qlfdEqkEbmfyYWbyYWbyYWby8UVmbLRc4OXd5WM2m6HX69UugyqhupkVHT+D9KmLkPvpNwhu3xz1ti9AaIfWHqyQSuJ2Jh9mJh9mJh9mJh9vZ8ZGi4ikZM3IQsbrq2BasQW6OrUQv2QSIu7rxhsOExERkV9go0VEUhFFZpje2YqMue9AmC2IfX44DKP6QxMarHZpRERERA5stIhICkII5O34BsbJi2A+dR5RQ+5GzPPDoYuPVbs0IiIiolLYaBGR3yv89U9cmpiKgu9+QWjX65CwegaCmzdRuywiIiKicrHRckFRFF45RiKKoiAoKEjtMqgS3GVm+eci0mcsRfbmz6BPugJ1N85F2K0dfFghlcTtTD7MTD7MTD7MTD6+yIyNFhH5HVtOHjIXbEDmgg1QwkNRa854RA25GwrvUUJERESS4KcWN3gfLXkIIWC1WqHVapmZJEpmJqxWZG/aifSZy2DLzIZhZD9EPzUE2qgItUul/8ftTD7MTD7MTD7MTD6+yIyNlgu8j5Z8bDYbtFqt2mVQJdgzy/vmJxgnLkDR4aOIuP9WxL48CvqGddUuj8rA7Uw+zEw+zEw+zEw+3s6MjRYRqcp87AyMs5Yhb+deBF/bAomfLkLIdS3VLouIiIioWthoEZEqrOkmpL/2DrJWbYWuXm0kLJ2M8Pu68ScXREREFBDYaBGRT4nCIphWbkHG66shrDYYnh+GmFH9oQ0NUbs0IiIiIo9ho+UCv1mXj45XpfNbQgjkbt8N49TFsJz+B1Ep9yLmmYehqRXNbU0y3M7kw8zkw8zkw8zk4+3MuEa4wQ+A8uB9z/xXwYHfYXwlFQX7DyLs1htQd+0sBDVrrHZZVAXczuTDzOTDzOTDzOTji8zYaLnBy7vLQwgBm80GjUbDzPyE5VwajDOWIue9zxHUvAnqbpqLsG7/u+EwM5MPM5MPM5MPM5MPM5OPLzJjo+UCL+8uH6vVCo1Go3YZNZ4tJw+Z89cjc+EGaCLDUfuNZxE56K4ybzjMzOTDzOTDzOTDzOTDzOTj7czYaBGRxwirFdkbdiB91jLYTDkwPDoAMU8OgSYiTO3SiIiIiHyKjRYReUTe7h9hnJSKoiPHEdHnNsS+NBL6BnXULouIiIhIFX53fPP48eN4+OGH0bZtW3Tu3Blz5sxBUVFRpcZYtWoVkpOTMWrUKC9VSUR2RX/9jX8GP4d/+o6DJjwMiZ8tQcLiiWyyiIiIqEbzqyNaJpMJKSkpaNSoEebPn4+0tDTMnj0bBQUFmDhxYoXGuHjxIhYsWIC4uLhq18OTGeXD30b7jvVSBtJfW4Ws1R9BVz8eCSumIvyerpXebpiZfJiZfJiZfJiZfJiZfLydmV81Whs3bkRubi5SU1MRHR0N4PJJalOmTMGoUaOQkJDgdozXXnsN3bp1w/nz5z1SE5steSiKwntY+IAoLELmsveR+cYaQFEQ98ooGEb0gRIcVOmxmJl8mJl8mJl8mJl8mJl8fJGZX7Xee/bsQceOHR1NFgD06NEDNpsNe/fudTv9jz/+iC+++AJPP/20F6skf8YrRXqPEAI5H/0HpzsPQfr0pYjofwcafr8B0WMGVanJKj4uyYWZyYeZyYeZyYeZycfbmflVo3XixAk0adLE6bGoqCjUrl0bJ06ccDmt1WrFtGnTMHr0aMTHx3ukHiEENxqJCCFgNpuZmRcU/HQE53s+hrQRExGU3BgN9qxC7dnjoI2Lrta4zEw+zEw+zEw+zEw+zEw+vsjMr45xZmVlISoqqtTjBoMBJpPJ5bTr169Hfn4+HnroIY/WVNbCVxSl3FDsPzV09by3pq3p49ofYzaeG9dyNg3p05cgZ8sXCLr6StR9/02E3XxtuV9CVLYm+zj2G4MH4jL09Lhq11Q8Mxnq9eW4/lhT8byKv85f6/XHmtQc19efQThu1cf19mcQjuv5mkpuY1UZ1x2/arSqymg0Yt68eXj11VcRFFT1nzCVxWw2O52npdFoHL/nNJvNpV5vf3+r1Qqbzeb0nE6ng6IosNlssFqtTs/Zx7V31yXp9fpyx9VqtdBqtRBCwGKxOD2nKIpjWovFUmpF8da4FZlXoPQyrM64xXMqbxkqilLpeXWXuRrL0D5uWTV5Ihtbdi6Mb65BzvIPoERFIGbu0wjvfweCQkLKnVf7uK6WYcn12/5ab6/frpahL9dvQP59RPExdDqdVPuIimzLgbqPsI+tKIpqy7Aq+4ji4wI1bx9hf6/KjKv2PsJT48q2j7BfVEHWfYSnxpVpHyGEcKrf3T5CCOG0PVaEXzVaUVFRyM7OLvW4yWSCwWAod7q3334bycnJuPbaa5GVlQXg8sKyWCzIyspCWFhYlU92s68Q5T1XnuIrcEkajabcq5wUX7krO667aV0tA2+N62peAdfLsLLjFt+AyhrXnmN15lWNbHy6DC0WZK35GOmzlsOWmwfDY4MQ/fggxw2Hq7sMSz5XcoemxjJUKxtZ9xH2zIrvG2VZv92NG+j7iLL+nvnbMlRr/fbXfUR5n0H8eR/h6XFl2UcIIWCz2aTeR/hiXH/aR5TVQJZHo9FUuskC/KzRatKkSalzsbKzs3Hx4sVS524Vd/LkSfzwww+47rrrSj133XXXYdmyZejSpUuVarJ/+1fW4+6mq8pz1ZmW4/7vOX+syd/HzfvP9zBOWoCi308gov8diHvxEegSy77SpydrKp6X7MvQF+P6Q032zCqSW3Vqkm1cf6ypeEZl7Rv9rV5/rEnNcX39GYTjemZcb7yvv86rr8f1dE0l/7ZVtaby+FWj1aVLFyxevNjpXK2dO3dCo9Ggc+fO5U734osvOo5k2c2cORMhISEYP348kpOTq1RPVRcqqcfVtxxUtqI/TuLSpAXI/2o/Qm5og8RdyxDStpnP3p+ZyYeZyYeZyYeZyYeZycfbmflVozVw4ECsXbsWY8aMwahRo5CWloY5c+Zg4MCBTvfQSklJwfnz57Fr1y4AQPPmzUuNFRUVhbCwMHTo0KFaNbHZkgezqhzLxQxkzFmBrDXboGtYFwnvTEd4zy4+XY7MTD7MTD7MTD7MTD7MTD6+yMyvGi2DwYDVq1dj2rRpGDNmDMLDw9G3b1+MGzfO6XVlnXznLVU58Y3UYT+pUavVMjMXbAWFMC19HxlvroGi1SBuymMwDOsNJcj338QxM/kwM/kwM/kwM/kwM/n4IjNFVPV6hQHu0KFDEEKgVatW3GAkYb8SjasLmNRkQgjkbP0S6dOWwPLPRRgevh8xzzwEbWz5F5rxRU3MTC7MTD7MTD7MTD7MTD6VzezQoUMAgFatWlX4PfzqiBYReUfBD4dxaWIqCn88grAeN6Lue68j6MqGapdFREREFLDYaBEFMPPpf5A+bTFytn6FoJZXod6HbyP0xvZql0VEREQU8NhoEQUga1YOMt9aB9PS96CJjkTteS8gsv8dUMq5twQREREReRYbLRf4G1v5lHeTuppCWCzIWrsN6a+ugMgrQPQTDyB6zCBowkPVLq1cNT0zGTEz+TAz+TAz+TAz+Xg7MzZabrDZkoeiKDV2JyeEQN6X+2GcvADmv04hsv8diH1pJHR1a6tdmks1OTNZMTP5MDP5MDP5MDP5+CIzNlpu8PLu8hBCOPKqSZkV/nYcxkkLkP/1Dwjp3A4JC15GcJuq3aTb12pqZjJjZvJhZvJhZvJhZvLxRWZstFzgle/lY7FYasyd2S1pRqS/ugLZ734CfaN6qLNmJsLuvFG6HXxNyixQMDP5MDP5MDP5MDP5eDszNlpEkrHlF8K0eBMy3l4HRa9D3NTHYXj4PlVuOExEREREZWOjRSQJYbMh58MvkT5tMSwX0mEY3hsx41OgjYlSuzQiIiIiKoGNFpEE8vcfhHFiKgp//h3hPbug7iujEXRlA7XLIiIiIqJysNFyQbZzXSjwMjP/fR7GqYuQu+1rBLVOQr2t8xDauZ3aZXlUoGVWEzAz+TAz+TAz+TAz+Xg7MzZabnCjkYeiKAFzEqrVlI2MN9fAtOwDaOOiEb/gJUT0vR2KRqN2aR4VSJnVFMxMPsxMPsxMPsxMPr7IjI0WkR8RZguy1nyM9DkrIQoKETP+QUQ/OhCasBC1SyMiIiKiSmCj5QbvoyUPIQQsFgt0Op10mQkhkLfrOxgnLYT5+BlEDroLsS+MgK5OLbVL8yqZM6upmJl8mJl8mJl8mJl8fJEZGy0XeB8t+ciYWeHhYzBOSkX+np8QelN7JCydjOBWV6ldls/ImFlNx8zkw8zkw8zkw8zk4+3M2GgRqcTy7yWkz16O7PWfQn9lA9RZNxtht3fiN2FEREREAYCNFpGP2fIKYFq0CRnz3oUSrEetmU8iKqUXFD03RyIiIqJAwU92RD4ibDbkvP85jDOWwXoxHYZH+iJm3IPQRkeqXRoREREReRgbLRf4Ey75+OulVfO/++XyDYd//RPh93RF3CujoW+cqHZZfsFfM6PyMTP5MDP5MDP5MDP58PLuKmOzJQ9/zMp84iyMUxcj95PdCG7bDPW2LUDoDa3VLstv+GNm5Bozkw8zkw8zkw8zk48vMmOj5QYv7y4PIQSsViu0Wq3qmVkzs5Hx+iqYVmyBtnYs4he9goje3QPuhsPV5U+ZUcUwM/kwM/kwM/kwM/n4IjM2Wi7wMp3ysdls0Gq1qr2/MFtgemcrMua+A1FkRuwzD8Mwuj9vOOyC2plR5TEz+TAz+TAz+TAz+Xg7MzZaRB4ghEDeZ3thnLwQ5pPnEPlAT8Q+Pxy6hDi1SyMiIiIiFbDRIqqmwoN/4dKkBSj49meE3nwtElZMRXCLpmqXRUREREQqYqNFVEWWfy8hfcZSZG/aCX3Thqizfg7Cut/A32YTERERERstV/iBWT6++G20LTcfmQs3IjN1PZTQYNSaPQ5RQ+/hDYeriL9nlw8zkw8zkw8zkw8zk4+3M+MnQzfYbMlDURSvbjDCZkP2pp1In7kM1nQTokf1Q/RTQ6GNivDaewY6b2dGnsfM5MPM5MPM5MPM5OOLzNhoucHLu8tDCOHIy9OZ5e89gEuvzEfRoaMI79UNca+Mgv6Keh59j5rIm5mRdzAz+TAz+TAz+TAz+fgiMzZaLvDy7vKxWCwevct30fHTME5ZhLwd3yL4mquR+MlChFzfymPjk+czI+9jZvJhZvJhZvJhZvLxdmZstIjKYM3IQsbcVTCt3AJdnVqIXzoJEffdym+piIiIiKhC2GgRFSOKzDCt/BAZr6+CsFgRO2EEDCP7QRMarHZpRERERCQRNlpEuPwz0dxPv0H6lEUwnzqPqKH3IOa5YdDFx6pdGhERERFJiI2WC/yZmHyqklnhr3/i0ivzUfDfXxF6y/VIWD0Dwc2beKE6Kgu3M/kwM/kwM/kwM/kwM/l4OzM2Wm5wo5GHoiiVOqHRcv4CjDOWIWfzTuibNUbdjXMRdmsHL1ZIJVU2M1IfM5MPM5MPM5MPM5OPLzJjo0U1ji0nD5mp65G5cCOU8FDUmvsMoh7oCUXHzYGIiIiIPIOfLN3gfbTkIYSAxWKBTqcrMzNhtSJ7406kz1wKmykHhlH9EPPUUGgiw1WolgD3mZH/YWbyYWbyYWbyYWby8UVmbLRc4H205FNeZnl7foRx4gIUHTmGiN7dEfvSSOgb1vVxdVQWbmfyYWbyYWbyYWbyYWby8XZmbLQooBUdOw3j5IXI+2wvgq9ricQdixFybQu1yyIiIiKiAMdGiwKS1ZiJ9NfeQdbqj6CrF4+EZVMQ3usWHs4nIiIiIp9go0UBRRQWIXPZB8h8Yw0gBGJffASGR/pCE8IbDhMRERGR77DRcoFHP+QhhEDOtq+RPnUxLGfTEPXgvYh97mFoa8WoXRq5oePVHqXDzOTDzOTDzOTDzOTj7cy4RrjBZsv/FRz4HcZXUlGw/yDCut+Auu/ORlByY7XLogpQFIXbmGSYmXyYmXyYmXyYmXx8kRkbLTd4eXf/ZT6bhvQZS5Dz/i4EXd0EdTa/jpAu10Cj0ahdGlWQEAI2mw0ajYbbmSSYmXyYmXyYmXyYmXx8kRkbLRd4mU7/ZMvJQ8a8d2FatBGayAjUfuM5RA6+C9BoYDab2WhJxmq1MjPJMDP5MDP5MDP5MDP5eDszv2u0jh8/junTp+PAgQMIDw9Hr1698NRTTyEoKKjcaS5cuIBVq1Zh7969OH36NCIjI3Hddddh/PjxSExM9GH15E3CakX2+k+QPmsFbNk5MDw6EDFPPABNRNjl59kYExEREZGf8KtGy2QyISUlBY0aNcL8+fORlpaG2bNno6CgABMnTix3uiNHjmDXrl3o06cP2rRpg4yMDCxatAj9+vXD9u3bERsb68O5IG/I+/oHGCeloui3E4joextiXxoFff0EtcsiIiIiIiqTXzVaGzduRG5uLlJTUxEdHQ3g8iG9KVOmYNSoUUhIKPuD9TXXXIMdO3Y4XTmkffv26Nq1K7Zu3Yphw4b5onzygqI/T16+4fAX+xDSoTUSP1+KkHbN1S6LiIiIiMglv/oh6Z49e9CxY0dHkwUAPXr0gM1mw969e8udLioqqtTlGevUqYPY2FhcuHChyvXwZEb1WC9l4OJzb+DMzQ+j6NhpJKychnrbUt02WfxttHyYmXyYmXyYmXyYmXyYmXy8nZlfHdE6ceIE+vTp4/RYVFQUateujRMnTlRqrJMnT8JoNOLKK6+sdl0lz/1RFKXc84HszZmr5701bSCMaysoRNbyD5D55lpAURD7yigYhveGEhzkeC9X4+p0Ogghynye2ag/blnTarVax/8H0rwG8j7Cnpm77dFf6vXVuP5Yk/254pn5c73+WJMa4yqKUioztWviuO7H9eZnEH+b10DZR2i12mqN645fNVpZWVmIiooq9bjBYIDJZKrwOEIITJ8+HfHx8ejZs2e1aioqKnI6sqXRaBxHz8xmc6nX2y/aYbVaYbPZnJ7T6XRQFAU2mw1Wq9XpOfu4Qogyx9Xr9eWOq9VqodVqIYSAxWJxek5RFMe0Foul1IrirXErMq/A/5ahEAL523Yjc+YyWM9fRNRDvRD51FBoYqNgufxCt+MqiuJYhiXrtc+roiiVnld3mauxDO3jllWTp7MpOa/lLUP7uK6WYcn1215bVbOp6Prtahn6Yv0uTvZ9RPHndTqdz5ehWuu3zPuIoqIipzFl2kcUHxfw3vrtb/sI+3vabDanzyAy7CM8Na5s+wiNRgOtVlvlcQF+jvD1PsL+ZaG9Jnf7CPvrK8OvGi1PmT9/Pvbt24fly5cjLCysyuMIIRwLvyz2hV+W4itwSRqNptxDlcVX7sqO625aV3e/9ta4ruYVuLwMC348AuPEVBT+eARhd3RC3Ka5CLrqCpffHpQ1rn3j0+l0ZdZrz7E686pGNhVZhr4at7rLsORzJXeYaixDtbKRdR9hz6z4vpHrt+tx7dTcR5TMzFPjluTpfURJNWkfYbPZyv0M4s/7CE+PK8s+wt1nkIrUW9OXYfHX+GIfUfIziLt5rWyTBfhZoxUVFYXs7OxSj5tMJhgMhgqNsXnzZixYsAAzZsxAx44dq12T/du/sh53N11VnqvOtLKNazmbhvTpS5Cz5QsEtWiKuh+8ibAu13qkXn+bV45b/vPF8wqkeQ3kfYQ9s4rkVp2aZBvXH2sqnlFZ+0Z/q9cfa1JzXF9/BuG4nhnXG+/rr/Pq63E9XVPJv21Vrak8ftVoNWnSpNS5WNnZ2bh48SKaNGnidvpdu3Zh8uTJeOKJJ9C3b19vlUnVZMvORcZba2Fa8h40hgjUfmsCIgfeCaWcbyCIiIiIiGTjV41Wly5dsHjxYqdztXbu3AmNRoPOnTu7nHb//v0YP348+vXrhzFjxviiXKokYbEg691PkD57OURuPqLHDkb0mEGOGw4TEREREQUKv2q0Bg4ciLVr12LMmDEYNWoU0tLSMGfOHAwcONDpHlopKSk4f/48du3aBQA4fvw4xowZg0aNGqFXr1745ZdfHK+NjY1Fw4YNq1RPVQ8TUml5X+3HpUkLYP7jJCL634m4lx6Brl68x9+HmcmHmcmHmcmHmcmHmcmHmcnH25n5VaNlMBiwevVqTJs2DWPGjEF4eDj69u2LcePGOb2u5FVOfv31V2RnZyM7OxuDBg1yeu3999+P2bNnV7kmbjTVU/j7CRgnLUD+f75HSMc2iN+1DCFtm3nlvRTF9QmS5H+YmXyYmXyYmXyYmXyYmXx8kZkiqnph+AB36NAhAECrVq1UrkROlgvpyJizEllrt0HXsC7iJj+G8LtuYuNKRERERNKpSm/gV0e0/FFVrplfk9kKCmFa8h4y3loLRatB3JQxMAy7H0qQ97/lsd8fwX4fBvJ/zEw+zEw+zEw+zEw+zEw+vsiMjZYLPNhXcUII5Hz4JdKnL4Hln4swDOuNmKdToI2t2GX5PVkHyYWZyYeZyYeZyYeZyYeZycfbmbHRomor+P4QLk1MReFPvyGsx42o+97rCLqyahcgISIiIiIKBGy0qMrMp87DOG0Jcj/6CkGtrkK9rfMQ2rmd2mUREREREamOjRZVmjUrB5lvrUXmkvegjTWg9vwXEdn/DigajdqlERERERH5BTZaLvBkRmfCYkHWmm1In7MCIr8QMU8NRfRjA6EJD1W7NAedjqu0bJiZfJiZfJiZfJiZfJiZfLydGdcIN9hsXT5RMO+LfTBOXgDz0dOIHHAnYl98BLq6tdUuzYmiKMxLMsxMPsxMPsxMPsxMPsxMPr7IjI2WGzX98u6Fvx2/fMPhr39ASOd2SFg0EcGtk9Quq0xCCNhsNmg0mhqdmUyYmXyYmXyYmXyYmXyYmXx8kRkbLRdq8mU6LWlGpL+6AtnvfgJ9o3qos3YWwu7o7Pc7D6vVCg3PFZMKM5MPM5MPM5MPM5MPM5OPtzNjo0VObPmFMC3ahIx566AE6RE3bSwMD/XyyQ2HiYiIiIgCBRstAgAImw05W764fMPhC+kwjOiDmPEp0EZHql0aEREREZF02GgR8vcdhHFiKgoP/I7wnjej3sTR0Depr3ZZRERERETSYqPlgr+fj1Rd5pPnYJy6CLnbdyO4TTLqfTQfoZ3aql1WtfC30fJhZvJhZvJhZvJhZvJhZvLxdmZstNwIxGbLaspGxhtrYFr2PrS1YhC/4CVE9L1d+hsOK4rCe1hIhpnJh5nJh5nJh5nJh5nJxxeZcY1wI5Au7y7MFmSt/gjpr70DUVCE2KcfguHRAdCEhahdmkcUv0pkoGQW6JiZfJiZfJiZfJiZfJiZfHyRGRstFwLl8u5CCOTt+g7GSQthPn4GkYPvQuyEEdDVqaV2aR5nNpuh1/MKiTJhZvJhZvJhZvJhZvJhZvLxdmZstAJc4aGjME5KRf43PyO0yzVIWDYFwS2bql0WEREREVFAY6MVoCz/XkL6rOXI3vAp9E0bos67ryLsto48nE1ERERE5ANstAKMLa8AmYs2InPeeighQag16ylEPXgvFD2jJiIiIiLyFX76DhDCZkPOe5/DOGMprMZMGB7pg5hxD0Jr4A2HiYiIiIh8jY2WC4qiSPFTu/y9B3BpYiqKDv6F8Hu6Iu6V0dA3TlS7LJ9TFAV6vV6KzOgyZiYfZiYfZiYfZiYfZiYfX2TGRktiRcfPIH3aYuR+sgfB7Zqj3rYFCL2htdplqYo7OPkwM/kwM/kwM/kwM/kwM/l4OzM2Wm744320rBlZyHh9FUwrP4QuPhbxiyci4v5bpb/hcHUJIWC1WqHVav0uMyobM5MPM5MPM5MPM5MPM5OPLzJjo+WCv91HSxSZYXpnKzLmvgNhtiD22YdhGD0AmtBgtUvzGzabDVqtVu0yqBKYmXyYmXyYmXyYmXyYmXy8nRkbLQkIIZC381sYJy+E+e/ziBpyN2KeGwZdQpzapRERERERURnYaPm5wl//xKVJC1Cw9wBCu16HhHemI/jqK9Uui4iIiIiIXGCj5acs/1xE+oylyN78GfRXNUSdDa8h7NYO/N0vEREREZEE2Gi5oEZTY8vNR+aCDchcsAFKWAhqvToOUUPvgaJjVBXB30bLh5nJh5nJh5nJh5nJh5nJx9uZ8dO7G75qtoTNhuxNO5E+YymsGVmIHtUf0U8NgTYqwifvHwgUReFOTjLMTD7MTD7MTD7MTD7MTD6+yIyNlhu+uLx7/rc/X77h8KGjiLivG2JfHgX9FfW8+p6BSAjhyIs/sZQDM5MPM5MPM5MPM5MPM5OPLzJjo+WCty/vXnTsNIxTFiFv57cIvrYFEj9dhJDrWnr1PQOdxWKBXq9XuwyqBGYmH2YmH2YmH2YmH2YmH29nxkZLBdZ0EzLmroLpnQ+hq1sbCUsnI/y+bvwGhIiIiIgoQLDR8iFRZIZp5RZkzF0FYbUh9oVHYBjZF5oQ3nCYiIiIiCiQsNHyASEEcj/ZA+OURbCc/gdRD96DmOeGQ1c7Ru3SiIiIiIjIC9houeCJn/IV/PIHjK+komDfrwjt1gF1185CULPGHqiOyqLRaNQugSqJmcmHmcmHmcmHmcmHmcnH25mx0XKjqs2W5VwajDOXIWfzZ9A3a4y6m+YirFsHD1dHxSmKAh3vNyYVZiYfZiYfZiYfZiYfZiYfX2TGNcLDbDl5yExdj8yFG6GJCEPt159F5OC7eMNhIiIiIqIahJ/+XSh+fX23r7Vakb1hB9JnLYPNlAPD6P6IeXIINJHhPqiUgMt5mc1m6PV6XsFREsxMPsxMPsxMPsxMPsxMPr7IjI2WB+Tt/hHGSakoOnIcEX1uQ+xLI6FvUEftsoiIiIiISCVstKqh6OgpGCcvRN7n3yHkupZI3LkYIde0ULssIiIiIiJSGRutKrAaM5E+5x1krf4IuvrxSFg+FeH3duWhYiIiIiIiAsBGq1JEYRFMyz9AxhtrACEQ+/JIGEb04Q2HiYiIiIjICRstF+xHqIQQyN32NYxTF8Fy9gKiUnoh9tmHoK3FGw77G71er3YJVEnMTD7MTD7MTD7MTD7MTD7ezszv7qx2/PhxPPzww2jbti06d+6MOXPmoKioyO10QggsXboUXbt2RevWrTFgwAD88ssv1a6n8MDvOH/3GKQNn4igpEZosGcVar86jk2WH1IUxfEfyYGZyYeZyYeZyYeZyYeZyccXmflVo2UymZCSkgKz2Yz58+dj3Lhx2Lx5M2bPnu122mXLlmHevHl46P/au/uoqMo8DuBfUAYTHIjySCCsggcExJAQBDzDipmMb1RrObUqhS9UiIqnNfKFVEzNNGQN0XwptNTUtBKN1kxlV102NEuiNp1B5UVdF5w3ERiYu3+4zHGcQdAGZia/n3P4g+d57p0ffM8d5se9d+all7Bhwwb07NkTycnJqKiouO96RG9/iKqRKdBrb+Cx3e/hse0rIQroc9/7o44lCAKampogCIK1S6F2Ymb2h5nZH2Zmf5iZ/WFm9qczMrOpSwd37tyJGzdu4P3334e7uzsAoLm5GYsXL0ZKSgp69epldruGhgZs2LABycnJeOmllwAATzzxBBISErB582YsWrTovupxPP0LHn1vLsQvjoJDly73tQ/qXHq9Hl2YlV1hZvaHmdkfZmZ/mJn9YWb2p6Mzs6kzWkVFRYiOjjY0WQAglUqh1+tx/PjxVrc7ffo0tFotpFKpYUwkEmHEiBEoKiq673pufvo2xBPHsMkiIiIiIqJ7YlONlkKhgJ+fn9GYWCxGz549oVAo7rodAJNt/f39UV1djfr6+vsriA0WERERERHdB5u6dFCtVkMsFpuMu7m5QaVS3XU7kUgEZ2fjt1kXi8UQBAEqlQrdunW7p1p0Oh0EQUBpaek9bUfWJQgCb0S1M8zM/jAz+8PM7A8zsz/MzP7cS2aNjY33nK9NNVq2hAeKfWJu9oeZ2R9mZn+Ymf1hZvaHmdmfe8nsft6h0KYaLbFYDI1GYzKuUqng5uZ21+0aGxvR0NBgdFZLrVbDwcHhrtu2ZtCgQfe8DREREREREWBj92j5+fmZ3Iul0Whw7do1k/uv7twOAMrLy43GFQoFvLy87vmyQSIiIiIiot/CphotiUSCEydOQK1WG8YKCwvh6OiI2NjYVrcLDw+Hq6srvvrqK8OYTqfD3/72N0gkkg6tmYiIiIiI6E42demgTCbDtm3bkJqaipSUFFy9ehUrV66ETCYz+gytpKQkVFdX49ChQwAAZ2dnpKSkYO3atfDw8EBAQAB27NgBpVKJKVOmWOvHISIiIiKiB5RNNVpubm7Iz89HVlYWUlNT4eLigvHjxyM9Pd1onV6vR3Nzs9HYtGnTIAgCtmzZgtraWgQFBWHz5s3w8fHpzB+BiIiIiIgIDoIgCNYugoiIiIiI6PfEpu7RIiIiIiIi+j1go0VERERERGRhbLSIiIiIiIgsjI0WERERERGRhbHRIiIiIiIisjA2WkRERERERBbGRouIiIiIiMjC2GjdQS6X4+WXX0ZYWBhiY2OxcuVKNDY2Wrss+r+vvvoKr776KiQSCcLCwpCYmIg9e/bgzo+D2717N0aOHInQ0FCMGzcOR44csVLFdLsbN25AIpEgMDAQZ8+eNZpjZrZn3759ePrppxEaGoqoqChMnToV9fX1hvlvv/0W48aNQ2hoKEaOHInPPvvMitU+2A4fPoznnnsOgwYNwtChQzFr1ixUVFSYrONxZh0XL15EZmYmEhMTERwcjDFjxphd1558NBoN5s2bh8jISAwaNAgzZ87Ef/7zn47+ER44bWWm1Wqxdu1ajB8/HhEREYiJicErr7yCf//73yb7Ymado73HWYtvvvkGgYGBZtdZKjM2WrdRqVRISkqCTqfD2rVrkZ6ejl27dmHFihXWLo3+76OPPsJDDz2EjIwM5OXlQSKRYOHChcjNzTWsOXDgABYuXAipVIqNGzciLCwMM2bMwJkzZ6xXOAEA1q1bh+bmZpNxZmZ78vLykJWVhVGjRmHz5s1YsmQJevfubcivpKQEM2bMQFhYGDZu3AipVIr58+ejsLDQypU/eIqLizFjxgz069cPubm5mDdvHn755RckJycbNcY8zqzn3LlzOHbsGP7whz/A39/f7Jr25jN79mwcP34cixYtwqpVq1BeXo5p06ahqampE36SB0dbmVVXV+PTTz9FbGws1qxZg6ysLGg0GkyYMAFyudxoLTPrHO05zlrU19dj2bJlePTRR83OWywzgQzWr18vhIWFCdevXzeM7dy5UwgKChKuXLlivcLIoKamxmRswYIFQnh4uNDc3CwIgiA89dRTwpw5c4zWTJgwQZg6dWqn1EjmnT9/XggLCxN27NghBAQECD/++KNhjpnZFrlcLgQHBwtHjx5tdU1ycrIwYcIEo7E5c+YIUqm0o8ujOyxcuFCIj48X9Hq9YezkyZNCQECA8N133xnGeJxZT8vfJ0EQhDfeeEMYPXq0yZr25HP69GkhICBA+Pvf/24Yk8vlQmBgoHDgwIEOqPzB1VZmN27cEOrq6ozGtFqtEBkZKSxZssQwxsw6T3uOsxZr1qwR/vznP5tdZ8nMeEbrNkVFRYiOjoa7u7thTCqVQq/X4/jx49YrjAw8PDxMxoKCgqDValFXV4eKigpcuHABUqnUaM2oUaNw8uRJXgZqRUuXLoVMJkPfvn2NxpmZ7dm7dy969+6NuLg4s/ONjY0oLi5GQkKC0fioUaMgl8tRWVnZGWXS/zU1NcHFxQUODg6GsR49egCA4bJqHmfW5eh495db7c2nqKgIYrEYsbGxhjV+fn4ICgpCUVGR5Qt/gLWVWffu3fHQQw8Zjbm4uMDX19foEjNm1nnayqzFpUuX8OGHH2LBggVm5y2ZGRut2ygUCvj5+RmNicVi9OzZEwqFwkpVUVtOnTqFXr16wdXV1ZDTnS/m/f39odPpzN6zQB2vsLAQv/76K1JTU03mmJnt+eGHHxAQEIB169YhOjoaAwYMgEwmww8//ADg1h8pnU5n8nzZcqkGny8717PPPgu5XI5PPvkEGo0GFRUVeO+99xAcHIzw8HAAPM5sXXvzUSgU6Nu3r1FTDdx6EcjjzvrUajXOnTtn9NzIzGzP22+/jcTERPTv39/svCUzY6N1G7VaDbFYbDLu5uYGlUplhYqoLSUlJTh48CCSk5MBwJDTnTm2fM8cO9/NmzexYsUKpKenw9XV1WSemdmea9eu4R//+Ae++OILvPXWW8jNzYWDgwOSk5NRU1PDzGxMREQE3n//faxevRoRERF48sknUVNTg40bN6JLly4AeJzZuvbmo1arDWcrb8fXKbbh3XffhYODA1544QXDGDOzLd9++y2+//57zJo1q9U1lsyMjRbZrStXriA9PR1RUVGYPHmytcuhVuTl5eGRRx7Bn/70J2uXQu0kCALq6uqQk5ODhIQExMXFIS8vD4Ig4OOPP7Z2eXSH06dPY+7cuXj++eeRn5+PnJwc6PV6TJ8+3ejNMIio43z22WfYtWsXMjMz4enpae1yyIyGhgYsW7YMaWlpZm9F6QhstG4jFouh0WhMxlUqFdzc3KxQEbVGrVZj2rRpcHd3x9q1aw3X5bbkdGeOarXaaJ46R1VVFbZs2YKZM2dCo9FArVajrq4OAFBXV4cbN24wMxskFovh7u5udFmFu7s7goODcf78eWZmY5YuXYohQ4YgIyMDQ4YMQUJCAj744AOUlZXhiy++AMDnRlvX3nzEYjG0Wq3J9nydYl3Hjh1DZmYmXnvtNTzzzDNGc8zMduTn58PR0RGjR4+GWq2GWq2GTqeDXq+HWq023AtpyczYaN3G3LWXGo0G165dM7kXgaynvr4eKSkp0Gg02LRpk9Hp3Zac7sxRoVDAyckJPj4+nVrrg66yshI6nQ7Tp0/H4MGDMXjwYLzyyisAgMmTJ+Pll19mZjaoX79+rc41NDTA19cXTk5OZjMDwOfLTiaXy03uNfD09MTDDz+MS5cuAeBzo61rbz5+fn4oLy83+ezI8vJyHndWcubMGcyaNQtPP/202cvRmJntUCgUuHjxIqKjow2vSQoKCiCXyzF48GDDZ0FaMjM2WreRSCQ4ceKE4T9IwK2b+B0dHY3eeYSsp6mpCbNnz4ZCocCmTZvQq1cvo3kfHx/06dPH5LN8Dh48iOjoaIhEos4s94EXFBSErVu3Gn29+eabAIDFixfjrbfeYmY2aNiwYVAqlfj5558NY9evX8dPP/2EkJAQiEQiREVF4euvvzba7uDBg/D390fv3r07u+QHmpeXF8rKyozGqqqqcP36dXh7ewPgc6Ota28+EokEKpUKJ0+eNKwpLy9HWVkZJBJJp9ZMwPnz55GSkoIhQ4Zg8eLFZtcwM9sxbdo0k9ckQ4cOhbe3N7Zu3Yr4+HgAls2sq0V/Ajsnk8mwbds2pKamIiUlBVevXsXKlSshk8lMXtCTdSxevBhHjhxBRkYGtFqt0Qc5BgcHQyQSIS0tDa+//jp8fX0RFRWFgwcP4scff+S9JVYgFosRFRVldi4kJAQhISEAwMxszJNPPonQ0FDMnDkT6enpcHZ2xgcffACRSIQXX3wRAPDqq69i8uTJWLRoEaRSKYqLi1FQUIDs7GwrV//gkclkWLZsGZYuXYr4+HgolUrDvZG3v104jzPruXnzJo4dOwbgVhOs1WoNTVVkZCQ8PDzalc+gQYMwdOhQzJs3D2+88QacnZ2RnZ2NwMBAPPXUU1b52X6v2spMEARMmTIFzs7OSEpKQmlpqWFbV1dXw5UBzKzztJWZv7+/yQcZ79u3D1evXjV6rWLJzByEO8+LPeDkcjmysrLw/fffw8XFBYmJiUhPT+d/+2xEfHw8qqqqzM4dPnzY8J/03bt3Y+PGjaiurkbfvn0xZ84cDBs2rDNLpVYUFxdj8uTJ2LNnD0JDQw3jzMy21NbWYvny5Thy5Ah0Oh0iIiLw5ptvGl1WePjwYaxZswbl5eXw8vLC9OnTMX78eCtW/WASBAE7d+7Ejh07UFFRARcXF4SFhSE9Pd3kRQWPM+uorKzE8OHDzc5t3brV8CKvPfloNBosX74chw4dQlNTE4YOHYoFCxbwH8IW1lZmAFp9I67IyEhs27bN8D0z6xztPc5ul5GRgdLSUhQUFBiNWyozNlpEREREREQWxnu0iIiIiIiILIyNFhERERERkYWx0SIiIiIiIrIwNlpEREREREQWxkaLiIiIiIjIwthoERERERERWRgbLSIiIiIiIgtjo0VERGRBly9fRmhoKE6dOnXP254/fx7BwcH49ddfO6AyIiLqTGy0iIjILuzduxeBgYEIDAxESUmJybwgCIiLi0NgYCBSUlKsUOEtubm5ePzxx/HEE0/c87b9+vVDXFwc/vrXv3ZAZURE1JnYaBERkV1xdnZGQUGByfi//vUvXLlyBSKRyApV3VJbW4vPP/8cMpnsvvchk8lw6NAhXLp0yYKVERFRZ2OjRUREdiUuLg6FhYVoamoyGi8oKEBISAh69uxppcqAL7/8El26dMGwYcPuex8xMTFwc3PDvn37LFgZERF1NjZaRERkV0aPHg2lUonjx48bxhobG/H1119j7NixZrfR6/X46KOPMHr0aISGhiImJgaZmZlQqVRG6wRBwLp16yCRSPD4449j0qRJOHfuHOLj45GRkdFmbd988w0GDhwIFxcXk7lPPvkEw4cPx8CBAzF+/HiUlJRg0qRJmDRpktE6JycnREZG4vDhw+35dRARkY1io0VERHbF29sbYWFhOHDggGGsqKgIGo0Go0aNMrtNZmYm3n33XYSHh2P+/Pl49tlnsX//fkyZMgU6nc6wLicnBzk5Oejfvz/mzp0LHx8fJCcno66urs26dDodzp49i5CQEJO57du3Y8mSJfD09MRf/vIXREREIDU1FVeuXDG7r5CQEJw7dw5arbbNxyUiItvU1doFEBER3auxY8di9erVqK+vR7du3bB//34MHjwYvXr1MllbUlKC3bt3Y9WqVUZnvKKiojB16lQUFhZi7NixqK2txaZNm/DHP/4R69evh4ODAwAgOzsb69evb7Omy5cvo76+Hr179zYab2xsRE5ODkJDQ5Gfn4+uXW/96Q0MDERGRgY8PT1N9uXj4wO9Xg+FQoGBAwfe0++GiIhsA89oERGR3ZFKpWhoaMCRI0eg1Wpx9OjRVi8bLCwsRI8ePRAbG4va2lrDV0hICLp3747i4mIAwIkTJ6DT6TBx4kRDkwUASUlJ7apJqVQCAMRisdF4aWkplEolnn/+eUOTBdxqFt3c3Mzuq2Uf169fb9djExGR7eEZLSIisjseHh6Ijo5GQUEB6uvr0dzcjJEjR5pde/HiRWg0GkRHR5udr6mpAQBUV1cDAPr06WPyWK01ROYIgmD0fct+fX19jca7du0Kb2/vdu2DiIjsDxstIiKyS2PGjMHChQvx3//+FxKJxORMUgu9Xo9HHnkEq1atMjvv4eFhkXrc3d0BAGq1+jfvq2UfDz/88G/eFxERWQcvHSQiIrs0YsQIODo64syZMxgzZkyr63x9faFUKhEeHo6YmBiTr/79+wMAvLy8AAAXLlww2r62ttbk3QnNeeyxx9CtWzdUVlYajbfs987PxWpqakJVVZXZfVVWVsLR0RF9+/Zt83GJiMg2sdEiIiK75OLigkWLFiEtLQ3x8fGtrpNKpWhubsa6detM5pqamgxnj2JiYuDk5ISPP/7Y6NK9/Pz8dtXj5OSEAQMGoLS01Gh8wIABcHd3x65du4w++2v//v2tNnA//fQT+vXrhx49erTrsYmIyPbw0kEiIrJbzzzzTJtrIiMjMWHCBGzYsAE///wzYmNj4eTkhAsXLqCwsBDz589HQkICPDw8kJycjA0bNiAlJQVxcXEoKytDUVFRuy/hGz58OLKzs6HVauHq6goAEIlESEtLQ1ZWFpKSkiCVSlFVVYW9e/ea3LcF3Hqb+O+++w4vvPDCvf0yiIjIpvCMFhER/e4tWbIEWVlZqKmpQXZ2NlavXo1//vOfGDduHMLDww3rZs+ejbS0NJSVlWHlypW4dOkStmzZgu7du7frcRITE6HX600+bHjixIlYsGABLl++jHfeeQclJSXIy8tDjx494OzsbLT25MmTUCqV7WoiiYjIdjkIfGsjIiKiu4qPj0dkZCRWrFjR5tp58+bhwoUL2L59+13X6fV6REdHY8SIEVi6dKlh/LXXXoODgwNyc3N/c91ERGQ9PKNFRERkQTNmzMDZs2dx6tQpw1hDQ4PJW7Z//vnnUCqViIyMNIzJ5XIcPXoUs2bN6rR6iYioY/AeLSIiIgvy8vLC2bNnjcbOnDmD5cuXIyEhAe7u7igrK8OePXsQEBCAhIQEwzp/f3+UlZV1dslERNQB2GgRERF1MG9vb3h6emLbtm1QqVRwc3NDYmIiXn/9dYhEImuXR0REHYD3aBEREREREVkY79EiIiIiIiKyMDZaREREREREFsZGi4iIiIiIyMLYaBEREREREVkYGy0iIiIiIiILY6NFRERERERkYWy0iIiIiIiILIyNFhERERERkYWx0SIiIiIiIrKw/wFuqOJqkS5QEgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 179, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.53371\n", + "GdL = 3\n", + "Chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.003197\n", + "1 0.022511\n", + "2 0.021599\n", + "3 0.113281\n", + "4 0.373118\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 180, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = 0.0107837 ± 0.0002969\n", + "BtY = 0.0134249 ± 0.0236741\n", + "cov_ABtY = -6.86161269517289e-06\n", + "chi² = 0.53371\n", + "chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 2.94068 ± 5.18574\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 181, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 182, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.60564 ± 0.02114\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = -0.00713 ± 0.02147\n", + "P(0,chi²)= 0.27020\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = -5.53371 ± 16.64994\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.01342 ± 0.02367\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 2.94068 ± 5.18574\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = 0.01078 ± 0.00030\n", + "BtY = 0.01342 ± 0.02367\n", + "P(0,chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 2.94068 ± 5.18574\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 183, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000000\n", + "res_t2 = 0.000002\n", + "res_uAdt = 0.000001\n", + "uKdt_strum = 0.000270\n" + ] + } + ], + "source": [ + "res_t = 0.000001 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 184, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 185, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.60564 ± 0.02114\n", + "\n", + "RISULTATI OLS:\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = -0.00713 ± 0.02147\n", + "Kdtols = 3.57541 ± 0.06970\n", + "Chi² = 1.29717 | rid = 0.43239 | P = 0.27019\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.01342 ± 0.02367\n", + "KdtC = 3.66092 ± 0.10078\n", + "Chi² = 0.53370 | rid = 0.17790 | P = 0.08857\n", + "\n", + "RISULTATI York:\n", + "AtY = 0.01078 ± 0.00030\n", + "BtY = 0.01342 ± 0.02367\n", + "KdtY = 3.66092 ± 0.10078\n", + "Chi² = 0.53370 | rid = 0.17790 | P = 0.08857\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/dinamica/mollaDinamica2Lavoro.ipynb b/molla/dinamica/mollaDinamica2Lavoro.ipynb new file mode 100644 index 0000000..8c31a66 --- /dev/null +++ b/molla/dinamica/mollaDinamica2Lavoro.ipynb @@ -0,0 +1,2859 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a80529e4", + "metadata": {}, + "source": [ + "# Analisi dei dati con il sonar\n", + "Minimo Indice:\n", + "- Analisi dei dati statici\n", + "- Analisi dei dati dinamici\n", + " - Sonar\n", + " - Cronometro" + ] + }, + { + "cell_type": "markdown", + "id": "32702b8f", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.807\n", + "ug = 0.001\n", + "\n", + "m_mol = 15.43\n", + "um_mol = 0.01" + ] + }, + { + "cell_type": "markdown", + "id": "fd0b8b1d", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "\n", + "ATTENZIONE: Linea cursed ~17" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'dinamica2.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "\n", + "df = calcola_stats(df, \"w\", err_arbitrario=0.0002)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n", + "df = calcola_stats(df, \"c\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"a\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"t\", err_arbitrario=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1a1ua1w1uw1c1uc1t1a2ua2w2uw2c2uc2t2a3ua3w3uw3c3uc3t3a4ua4w4uw4c4uc4t4wuwmumcucauatut
049.259.71710.0167.656500.00040484.45500.01115.628.91100.0157.656900.00040484.5160.01115.5810.4460.0277.660300.00050485.0820.01915.768.3770.0167.658200.00040484.7520.01115.877.6579750.00171149.250.002887484.701250.2843149.3627750.90825415.70750.133010
169.289.86000.0166.559680.00029423.35200.01118.3110.39000.0126.558910.00022423.1540.00918.2710.4910.0136.560020.00024423.6970.01018.3410.9680.0196.560000.00030423.4650.01418.166.5596520.00051969.280.002887423.417000.22664110.4272500.45447218.27000.078740
288.9711.58400.0145.844170.00020363.22900.01020.2710.17630.0175.845850.00028363.3540.01220.4412.0440.0185.845000.00026363.1830.01320.5411.2240.0165.845130.00025363.2330.01120.495.8450380.00068988.970.002887363.249750.07310911.2570750.79483720.43500.117331
3108.6111.54200.0265.327800.00030303.55020.01922.498.42400.0175.328200.00030303.5810.01222.2710.5010.0225.329600.00030303.8420.01622.559.9590.0145.328220.00020303.4450.01022.155.3284550.000787108.610.002887303.604550.16866910.1065001.29985322.36500.187172
4128.6411.57400.0204.926630.00023242.96200.01424.3311.59200.0234.925370.00029242.8760.01724.3810.2640.0234.924300.00030242.7890.01725.099.1180.0214.926100.00030243.1150.01524.264.9256000.001009128.640.002887242.935500.13895410.6370001.18834424.51500.386480
\n", + "
" + ], + "text/plain": [ + " m1 a1 ua1 w1 uw1 c1 uc1 t1 a2 \\\n", + "0 49.25 9.7171 0.016 7.65650 0.00040 484.4550 0.011 15.62 8.9110 \n", + "1 69.28 9.8600 0.016 6.55968 0.00029 423.3520 0.011 18.31 10.3900 \n", + "2 88.97 11.5840 0.014 5.84417 0.00020 363.2290 0.010 20.27 10.1763 \n", + "3 108.61 11.5420 0.026 5.32780 0.00030 303.5502 0.019 22.49 8.4240 \n", + "4 128.64 11.5740 0.020 4.92663 0.00023 242.9620 0.014 24.33 11.5920 \n", + "\n", + " ua2 w2 uw2 c2 uc2 t2 a3 ua3 w3 \\\n", + "0 0.015 7.65690 0.00040 484.516 0.011 15.58 10.446 0.027 7.66030 \n", + "1 0.012 6.55891 0.00022 423.154 0.009 18.27 10.491 0.013 6.56002 \n", + "2 0.017 5.84585 0.00028 363.354 0.012 20.44 12.044 0.018 5.84500 \n", + "3 0.017 5.32820 0.00030 303.581 0.012 22.27 10.501 0.022 5.32960 \n", + "4 0.023 4.92537 0.00029 242.876 0.017 24.38 10.264 0.023 4.92430 \n", + "\n", + " uw3 c3 uc3 t3 a4 ua4 w4 uw4 c4 \\\n", + "0 0.00050 485.082 0.019 15.76 8.377 0.016 7.65820 0.00040 484.752 \n", + "1 0.00024 423.697 0.010 18.34 10.968 0.019 6.56000 0.00030 423.465 \n", + "2 0.00026 363.183 0.013 20.54 11.224 0.016 5.84513 0.00025 363.233 \n", + "3 0.00030 303.842 0.016 22.55 9.959 0.014 5.32822 0.00020 303.445 \n", + "4 0.00030 242.789 0.017 25.09 9.118 0.021 4.92610 0.00030 243.115 \n", + "\n", + " uc4 t4 w uw m um c uc \\\n", + "0 0.011 15.87 7.657975 0.001711 49.25 0.002887 484.70125 0.284314 \n", + "1 0.014 18.16 6.559652 0.000519 69.28 0.002887 423.41700 0.226641 \n", + "2 0.011 20.49 5.845038 0.000689 88.97 0.002887 363.24975 0.073109 \n", + "3 0.010 22.15 5.328455 0.000787 108.61 0.002887 303.60455 0.168669 \n", + "4 0.015 24.26 4.925600 0.001009 128.64 0.002887 242.93550 0.138954 \n", + "\n", + " a ua t ut \n", + "0 9.362775 0.908254 15.7075 0.133010 \n", + "1 10.427250 0.454472 18.2700 0.078740 \n", + "2 11.257075 0.794837 20.4350 0.117331 \n", + "3 10.106500 1.299853 22.3650 0.187172 \n", + "4 10.637000 1.188344 24.5150 0.386480 " + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pd.set_option('display.max_columns', None)\n", + "pd.set_option('display.width', None)\n", + "\n", + "df" + ] + }, + { + "cell_type": "markdown", + "id": "9b8d8cb4", + "metadata": {}, + "source": [ + "# Analisi statica" + ] + }, + { + "cell_type": "markdown", + "id": "fd1b1164", + "metadata": {}, + "source": [ + "## Permutazioni" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n", + "10\n", + "############################################################\n", + "[ 61.28425 121.4515 181.0967 241.76575 60.16725 119.81245 180.4815\n", + " 59.6452 120.31425 60.66905]\n", + "[0.36359352 0.29356288 0.33058029 0.31645313 0.23814054 0.28251562\n", + " 0.26584645 0.18383143 0.15701353 0.21853469]\n", + "############################################################\n", + "[-20.03 -39.72 -59.36 -79.39 -19.69 -39.33 -59.36 -19.64 -39.67 -20.03]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248\n", + " 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.c[x] - df.c[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uc[x]**2 + df.uc[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "d37fbd7c", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[3.20529679 3.20732177 3.21454516 3.2203806 3.20938434 3.21927571\n", + " 3.22550245 3.22925365 3.23356286 3.23779934]\n", + "[0.01903074 0.00776638 0.00588125 0.00423125 0.01272429 0.00760543\n", + " 0.00476765 0.00998087 0.00424581 0.01168613]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(K)\n", + "print(uK)" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.22307834012753\n", + "sigmaC: 0.0020227911977321114\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "21baebb4", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "1d4c0ffa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.244949\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.6\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "id": "5be377eb", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": np.sqrt(ueste**2 + uDx_strum**2),\n", + " \"y\": - F,\n", + " \"uy\": np.sqrt(uF**2 + uF_strum**2)\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "6ec60a92", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 3.114e+05\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.19e-19\n", + "Time: 09:46:35 Log-Likelihood: -14.036\n", + "No. Observations: 10 AIC: 32.07\n", + "Df Residuals: 8 BIC: 32.68\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0101 0.779 0.013 0.990 -1.785 1.805\n", + "x 3.2201 0.006 558.014 0.000 3.207 3.233\n", + "==============================================================================\n", + "Omnibus: 0.921 Durbin-Watson: 0.565\n", + "Prob(Omnibus): 0.631 Jarque-Bera (JB): 0.614\n", + "Skew: 0.062 Prob(JB): 0.736\n", + "Kurtosis: 1.792 Cond. No. 302.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", + "R² = 0.99997\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "8d795186", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 7.89493\n", + "GdL = 8\n", + "Chi² rid = 0.98687\n", + "P(0, chi²)= 0.55620\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.420110\n", + "1 1.597434\n", + "2 0.580057\n", + "3 0.002382\n", + "4 0.351718\n", + "5 0.007741\n", + "6 0.687794\n", + "7 0.295535\n", + "8 2.940543\n", + "9 1.011619\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "9f26f65e", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "6a910226", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 3.2196 +- 0.0063\n", + "BC = 0.2465 +- 0.8111\n", + "cov_ABC = -0.004592\n", + "P(0, chi²)= 0.5298\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} +- {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} +- {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "id": "b49ec5a3", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA14AAAIsCAYAAADiRXiMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAsChJREFUeJzs3Xd4U3X/PvD7JE0nHbSUsqUFW0bLcDALMhSkICiyVIYKKCIoKD6UPR9BBMpeZQvIkqFQhiIKaEFxMAQfhDJakNG924zz+4Nv8mvooEnzyWjv13V5SXNOPn2fkzsnefcsSZZlGURERERERCSMwtYFEBERERERlXdsvIiIiIiIiARj40VERERERCQYGy8iIiIiIiLB2HgREREREREJxsaLiIiIiIhIMDZeREREREREgrHxIiIiIiIiEoyNFxERERERkWBsvIiIHmPQoEEYNGiQ4eeEhASEhIRgz549NqyqdCIjI9G8eXNbl1GuhISEYOnSpbYuo1zq1KkTIiMjbV1GuTJo0CD06NHD1mUQEdh4EZEJ9uzZg5CQEFy4cMHWpTiEM2fOICQkBIcPHy5yOpsi+/Xjjz+yuSpCTk4Oli5dijNnzpg9xu+//46lS5ciPT3dgpUREdk/J1sXQETkaGrWrInz58/DyYmb0PLqxx9/xNatWzF69OhC086fPw+lUmmDqmwvJycHy5Ytw6hRo9CyZUuzxvjjjz+wbNkyvPLKK/Dy8jKadvjwYUiSZIlSiYjsDvd4ERGZSJIkuLi4VNgv3xWdi4uL3TTd2dnZti7BopydnaFSqWxdhlXIsozc3Nwip+Xl5UGn05VpfGtmQ6PRID8/32q/j8hRsfEiIou7d+8eJkyYgDZt2iA0NBTdu3fH7t27C813+/ZtjBgxAs2aNUPr1q3x6aef4uTJkwgJCSl0KNPWrVvRuXNnNGnSBH369MHZs2cLnXsFAPn5+ViyZAleeOEFhIaG4rnnnsO8efNK/aVgx44deP75541+z6NEn+O1detWdO/eHaGhoQgPD8eMGTOKPCzr0KFD6N27N5o0aYKWLVti3LhxuHfv3mPHv3z5Mlq1aoVBgwYhKysLQOlfM2vRr+N169Zh48aN6NixI5o0aYKBAwfiypUrRvMWlQPg4aGcnTp1KnJM/escGhqKV199FefPnzd63tatWwE8PJ9L/59eac7x0h9mGhMTg4ULF6Jt27Zo1qwZRowYgX///bfQ/OfOncPQoUPx9NNPo2nTphg4cCB+++03o3mWLl2KkJAQXL16FR9//DGeffZZvP766wAenhv17rvv4syZM4ZMvPTSS4b30dGjR/HSSy8hLCwMvXv3xqVLl0xehwkJCWjdujUAYNmyZYb1ol8Xf//9NyIjI9G5c2eEhYWhbdu2mDBhAlJSUoyWYd68eQCAzp07G8ZISEgwLEdpzvHS6XTYtGmTYZlatWqFoUOHGh0GrdFosHz5csPr3KlTJyxcuLDQtkC/7s6ePYs+ffogLCwMnTt3xr59+x5bh76WjRs3onv37ggLC0ObNm0wdepUpKWlFfl7Tp48aXiNtm/fbsjKwYMHERUVhXbt2qFp06bIzMwEULr3uf6w5Vu3bmH48OFo3rw5xo0bZzTPxYsXMWDAADRp0gSdOnXCl19+aTQ9Pz8fixcvRu/evfH000+jWbNmeP3113H69Gmj+R59bz7//PMICwvDtWvXSrW+iCoy+/iTHRGVG4mJiejXrx8kScIbb7wBX19fnDhxApMmTUJmZibefPNNAA//GjtkyBA8ePAAgwcPRpUqVXDgwIEizx3Ztm0bZs6ciWeeeQZvvvkmbt++jffffx9eXl6oVq2aYT6dTof33nsPv/32G/r164d69erhypUr2LRpE27cuIEVK1aUWPuuXbswdepUNG/eHEOGDEF8fDzee+89eHt7o3r16mavk6ysLCQnJxd6vKhmcOnSpVi2bBnatGmD1157DdevX8eXX36JCxcu4MsvvzTsDdizZw8mTJiAsLAwfPTRR0hKSsLmzZvx+++/Y9++fYUO4dI7f/48hg0bhtDQUKxYsQKurq6lfs1sYd++fcjKysLrr7+OvLw8fPHFFxgyZAi++eYbVKlSxawxDxw4gKysLPTv3x+SJGHt2rUYPXo0vvvuO6hUKvTv3x/379/HTz/9ZGgSzLVy5UpIkoThw4cjKSkJmzZtwptvvon9+/fD1dUVABAbG4vhw4cjNDQUo0aNgiRJ2LNnD4YMGYJt27ahSZMmRmN++OGHeOKJJzB27FjIsmx4/ObNm/j4448xYMAA9OzZE+vXr8eIESMwY8YMREVF4bXXXgMArFmzBmPGjMHhw4ehUJT+76++vr6YPn06pk+fjhdeeAEvvPACABia0p9//hnx8fHo3bs3/P398c8//2Dnzp24evUqdu7cCUmS8MILL+DGjRs4cOAAJkyYgMqVKxvGNsWkSZOwZ88etG/fHn369IFWq8XZs2dx7tw5hIWFAQAmT56MvXv3omvXrnjrrbdw/vx5rF69GteuXcPy5cuNxrt58yY+/PBD9OnTB6+88gq++uorREZGonHjxnjyySdLrGXq1KnYu3cvevfujUGDBiEhIQFbt27FpUuXjN6zAHD9+nV8/PHH6N+/P/r164fAwEDDtBUrVkClUmHo0KHIz8+HSqUy6X2u0WgMzfv48eMN+QKAtLQ0vPPOO+jWrRu6d++OQ4cOYfr06VCpVOjTpw8AIDMzE7t27UKPHj3Qt29fZGVlYffu3Rg2bBh27dqFhg0bGi33nj17kJeXh379+sHZ2Rne3t4mvYZEFZJMRFRKX331lRwcHCyfP3++2HkmTpwot23bVk5OTjZ6fOzYsfLTTz8t5+TkyLIsy+vXr5eDg4Plb7/91jBPbm6u/OKLL8rBwcHy6dOnZVmW5by8PLlFixbyq6++KqvVasO8e/bskYODg+WBAwcaHtu3b5/coEED+ddffzX63V9++aUcHBws//bbb8XWnZ+fL7du3Vru1auXnJeXZ3h8x44dhX5PfHy8HBwcLH/11VfFjifLsnz69Gk5ODi4xP+aNWtmmD8pKUlu3Lix/Pbbb8tardbw+JYtW+Tg4GB59+7dRrX26NFDzs3NNcx3/PhxOTg4WF68eLHhsfHjxxt+x9mzZ+WnnnpKfuedd4yWsbSvmTXp13GTJk3ku3fvGh4/d+6cHBwcLH/66aeGxwYOHGj0+uiNHz9e7tixY6ExW7RoIaemphoe/+677+Tg4GD5+++/Nzw2Y8YMOTg4uMjagoOD5SVLlpRYv/61b9eunZyRkWF4PCYmRg4ODpY3bdoky7Is63Q6uUuXLvLbb78t63Q6w3w5OTlyp06d5Lfeesvw2JIlS+Tg4GD5o48+KvT7OnbsKAcHB8u///674bGTJ08a1uHt27cNj2/fvt3oPSbLpV+HSUlJxS5/UTk5cOCAHBwcbPSeXLt2rRwcHCzHx8cXuRzjx48v9HhBsbGxcnBwsDxr1qxC0/Tr8PLly3JwcLA8adIko+lz586Vg4OD5djYWKPf+WiNSUlJcmhoqDx37twSa/n111/l4OBg+euvvzZ6/MSJE4Ue1/+eEydOGM2rz0rnzp2N1qGp7/Pg4GB5/vz5hWocOHCgHBwcLK9fv97wWF5entyrVy+5devWcn5+vizLsqzRaIy2C7Isy2lpaXKbNm3kCRMmGB7Tv4+eeuopOSkpqcT1Q0TGeKghEVmMLMs4evQoOnXqBFmWkZycbPgvPDwcGRkZ+OuvvwAAJ0+eREBAADp37mx4vouLC/r162c05sWLF5Gamop+/foZnVfz0ksvFfoL6+HDh1GvXj0EBQUZ/e5WrVoBQIlXYrt48SKSkpIwYMAAODs7Gx5/5ZVX4Onpaf5KAfD+++9jw4YNhf4LDw83mu/nn3+GWq3G4MGDjfZE9O3bF5UqVcKPP/5oVOtrr70GFxcXw3wdOnRAUFAQfvjhh0I1nD59GsOGDUPr1q2xdOlSwzKa8prZwvPPP4+AgADDz02aNEHTpk0N68IcERERRtl55plnAADx8fHmF1qMl19+GZUqVTL8/OKLL8Lf399Q/+XLl3Hjxg289NJLSElJMaz77OxstG7dGr/++muhc30GDBhQ5O+qX7++0VUymzZtCgBo1aoVatSoUehxSy9vwT0seXl5SE5ONvwuS2bo6NGjkCQJo0aNKjRNf2EO/fp96623jKa//fbbRtP16tevb8gB8HAPXGBg4GPX0eHDh+Hp6Ym2bdsavXcaN24Md3f3QtucWrVqoV27dkWO9fLLLxutQ3Pe5/q9mo9ycnJC//79DT87Ozujf//+SEpKMrw2SqXSsF3Q6XRITU2FRqNBaGhooUNTAaBLly4m76kkquh4qCERWUxycjLS09OxY8cO7Nixo9h5gIfnd9WpU6fQFczq1Klj9POdO3eKfNzJyQk1a9Y0euzmzZu4du2a4TyURyUlJRVbu/73PPHEE0aPq1Qq1K5du9jnlUZwcDDatGlT6PGvv/66yBqCgoKMHnd2dkbt2rVx+/Zto/kKHqakFxQUVOjcoLy8PLz77rto3LgxFi1aZNTAmvKaFSU1NRVqtbrY6SXx9vY2anKL8ujrAQB169bFoUOHzPqdAAodNqpvwkRc3vzR+iVJwhNPPGF4LW/cuAEAGD9+fLFjZGRkGDWKtWrVKnK+R5dL/weDgofjAjA0gpZe3tTUVCxbtgwxMTGF3msZGRkW+z23bt1C1apV4ePjU+w8t2/fhkKhKLTd8Pf3h5eXl2H96xV1KLG3t3eh87QedfPmTWRkZJR6m1Pca1fUNFPf505OToVea72qVavC3d3d6LG6desCeLiumjVrBgDYu3cv1q9fj+vXrxu9r4uqu6RlIaKisfEiIovR/2W+Z8+eeOWVV4qcp+BFCkT8/uDgYEyYMKHI6cV9KSnvnJ2d0b59e3z//fc4efIkOnbsaJhW1tds9OjR+OWXX8yqa/PmzWZfkrw0tFptkY8XdzVKucD5Utai/53/+c9/Cp1Do/foF+aCez8KKm65yrK8xa3DoowZMwZ//PEHhg4dioYNG8Ld3R06nQ7Dhg2zyboFUOpL05t7hVKdTgc/Pz/Mnz+/yOmP7hEquEfrUSVNKw1nZ2eTztl71P79+xEZGYnnn38eQ4cOhZ+fH5RKJVavXl3knr+y1ktUEbHxIiKL8fX1hYeHB3Q6XZF7eAqqWbMmrl69ClmWjb4c3bp1y2g+/SFSt27dMhwyCDw8kfz27dtGTUGdOnXw999/o3Xr1ibfC0j/e27evGn012u1Wo2EhAQ0aNDApPHMoa8hLi7OaC9bfn4+EhISDOtUP9/169cL/aX9+vXrRoeVAQ+/fM6fPx8jR47Ehx9+iOjoaEPDY8prVpTx48ebveekNOv05s2bhR67ceOG0d5Ob2/vIr8Y6vcYmMNS95J6tH5ZlnHz5k1DbvWvc6VKlcxa/5ZS2nVY3HpJS0tDbGwsRo8ebXQIoH6PXmnGKK06derg1KlTSE1NLXavV82aNaHT6XDz5k3Uq1fP8HhiYiLS09ML7S0vSy2xsbF46qmnLN6ImPo+L8n9+/eRnZ1t1MTrXxv9ujhy5Ahq166NZcuWGb1GS5YsMXcRiOgRPMeLiCxGqVSia9euOHLkSKFLfgPGh6yFh4fj3r17OHbsmOGxvLw87Ny50+g5oaGh8PHxwc6dO6HRaAyPf/PNN4UOA+rWrRvu3btXaAwAyM3NLfG+NqGhofD19cX27duNrja4d+9eIYegFaVNmzZQqVT44osvjPYQ7N69GxkZGXjuuecMtfr5+RWq9ccff8S1a9fQoUOHQmM7Oztj2bJlCAsLw4gRIwyXTzflNStKaGgo2rRpY9Z/pbkK2nfffWd06ezz58/j3LlzaN++veGx2rVrIy4uzqjWv//+G7///vtjxy+Om5sbgLIfjrdv3z7DZcGBh+cEPXjwwFB/aGgo6tSpg/Xr1xsu7V/Q49a/pZR2HRa3XorbY7Rp06ZCj+nHMPfwwy5dukCWZSxbtqzQNP37Rv9eefT3b9iwwWh6WXXr1g1arbbIK6ZqNJoy5cec93lxNBqN0aHE+fn52LFjB3x9fdG4cWMA//81LLjtOXfuHP7880+zl4GIjHGPFxGZ7KuvvsLJkycLPT548GB8/PHHOHPmDPr164e+ffuifv36SEtLw19//YXY2FjDYWn9+/fHli1b8PHHH2Pw4MHw9/fHN998YziMSv8XV2dnZ4wePRqzZs3CkCFD0K1bN9y+fRt79uwpdP5Gr169cOjQIUybNg1nzpzBU089Ba1Wi7i4OBw+fBhr1641XGr6USqVCmPGjMHUqVMxZMgQREREICEhAXv27CnzOV6l5evri3fffRfLli3DsGHD0KlTJ1y/fh3btm1DWFgYevbsaah13LhxmDBhAgYOHIju3bsbLjNds2bNYi//7urqitWrV2Pw4MEYPnw4vvjiCwQHB5f6NbOFOnXq4LXXXsNrr72G/Px8bN68GT4+Phg2bJhhnj59+mDjxo0YOnQo+vTpg6SkJGzfvh3169cvspkpDf2X0dmzZyM8PBxKpRLdu3c3eRxvb2+8/vrr6N27t+Fy8k888YThIjIKhQKzZ8/G8OHD0aNHD/Tu3RsBAQG4d+8ezpw5g0qVKmHVqlVmLYMpSrsOXV1dUb9+fRw6dAh169aFj48PnnzySQQHB+PZZ5/F2rVroVarERAQgJ9++slwf66C9Os2KioKERERUKlU6NixY6FDKovTqlUr9OrVC1988QVu3ryJdu3aQafT4bfffkPLli0xcOBANGjQAK+88gp27NiB9PR0PPvss7hw4QL27t2L559/3mjveVm0aNEC/fv3x+rVq3H58mW0bdsWKpUKN27cwOHDhzFp0iS8+OKLZo1t7vu8KFWrVkV0dDRu376NunXrIiYmBpcvX8asWbMMl7vv0KEDjh49ivfffx8dOnRAQkKCIQPl7UbdRLbCxouITPbojTf1evfujWrVqmHXrl1Yvnw5vv32W3z55Zfw8fFB/fr1jW7o6eHhgU2bNmH27NnYvHkz3N3d8fLLL6N58+YYPXq00XksAwcOhCzL2LBhAz777DM0aNAAK1euxOzZs43mUygUWL58OTZu3Ij9+/fj22+/hZubG2rVqoVBgwYVeZJ6Qf3794dWq8W6deswb948BAcHY+XKlVi8eHEZ11jpjR49Gr6+vtiyZQvmzJkDb29v9OvXDx999JHR/YB69+4NV1dXREdHY/78+XB3d8fzzz+PTz75pNh7eAEPD2lbt24dBg4ciLfffhtbt27FE088UarXzBZefvllKBQKbNq0CUlJSWjSpAmmTJmCqlWrGuapV68ePvvsMyxZsgRz5sxB/fr1MW/ePBw4cMDsprFLly4YNGgQDh48iK+//hqyLJvVeI0YMQL/+9//sGbNGmRlZaF169aYNm2aYa8PALRs2RI7duzAihUrsGXLFmRnZ8Pf3x9NmjQxuhKdSKasw9mzZ2PWrFmYM2cO1Go1Ro0aheDgYCxYsACzZs3Ctm3bIMsy2rZti+jo6EJX8WvSpAk+/PBDbN++HSdPnoROp8OxY8dK3XgBwJw5cxASEoLdu3dj3rx58PT0RGhoqNFVHWfPno1atWph7969+O6771ClShW8++67RV4NsSxmzpyJ0NBQbN++HVFRUVAqlahZsyZ69uyJp556qkxjm/s+f5S3tzfmzp2L2bNnY+fOnahSpQqmTp1qdBXZ3r17IzExETt27MCpU6dQv359fP755zh8+LBN//hCVJ5Isq3OeCUiKsLGjRsxZ84cnDhxwugy4o/S6XRo3bo1XnjhBcyePduKFZI1JCQkoHPnzvjPf/6DoUOH2rock505cwaDBw/G4sWLzd7jQURE5QvP8SIim8nNzTX6OS8vDzt27EDdunWNmq68vLxCV0Xbt28fUlNT0aJFC6vUSkRERFQWPNSQiGxm1KhRqFGjBho0aIDMzEx8/fXXiIuLK3Rp5j///BNz5szBiy++CB8fH1y6dAm7d+9GcHAw9yYQERGRQ2DjRUQ2Ex4ejt27d+Obb76BVqtF/fr1DSfcF1SzZk1Uq1YNX3zxBdLS0uDt7Y1evXph3Lhxj70BLxEREZE94DleREREREREgvEcLyIiIiIiIsHYeBEREREREQnGc7xM8Mcff0CWZaN76RARERERUcWjVqshSZLRPQRLwsbLBLIsF7qkNRERERERVTym9gVsvEygUqkgyzJCQ0MhSZKty6FyRpZlqNVqqFQq5ouEYMZIJOaLRGK+SDRzMnbhwgWTfgfP8SIiIiIiIhKMjRcREREREZFgdtd4HTt2DH379kXz5s0RHh6ODz/8EPHx8YXm27VrF7p27YqwsDD07NkTx48fLzRPRkYGJk6ciBYtWqB58+b44IMPcP/+fWssBhERERERkYFdNV5nzpzBqFGjUL9+fSxfvhwTJ07E33//jbfffhu5ubmG+Q4ePIgpU6agW7duiI6ORrNmzTBq1Cj8+eefRuONGTMGP/30E6ZPn4758+fj+vXrGD58ODQajZWXjIiIiIiIKjK7urjGwYMHUaNGDXz66aeGk9p8fX0xZMgQXLx4Ec888wwAYMmSJejevTvGjBkDAGjVqhWuXLmC5cuXIzo6GsDDS7+fOnUK69atQ3h4OAAgMDAQEREROHr0KCIiIsyqkSd0kki8VQGJxoyRSMwXicR8kWiiM2ZXjZdGo4GHh4dRc+Pp6Qng/1+uMT4+Hjdu3MAnn3xi9NyIiAjMmzcP+fn5cHZ2xokTJ+Dl5YW2bdsa5gkKCkLDhg1x4sQJsxsv4PHNl1arhVqtNnt8ImtSqVRQKpW2LoOsgH84IpGYLxKJ+SLRrJExu2q8evfujf3792Pr1q3o2bMnUlNTsXDhQjRq1AhPPfUUACAuLg7Aw71XBdWrVw9qtRrx8fGoV68e4uLiEBgYWGglBgUFGcYwlyzLRb44sizj7t27SE1NLdP4VHEVly3RfHx8UK1aNX6wlXOyLEOr1UKpVPK1Jotjvkgk5otEs0bG7KrxeuaZZ7Bs2TJ8/PHHmDlzJgCgYcOGWLt2reEv8mlpaQAALy8vo+fqf9ZPT09PN+wtK8jb2xsXL140u8bibqIsSRL+/fdfpKWlwd/fH+7u7oYXTf//4m6yJklSidPK8lyOK3ZcS9ekb7zKsjym1CvLMrKzs/HgwQMAQLVq1SwyrrWey3FNe67+Q0WhUAiviePab00ixy2YL0uNW9aaOK591mTquAW/FDtCvY5ck6ONa6maCm7DyjJuSeyq8fr999/xn//8B/369UOHDh2QmpqKFStW4J133sG2bdvg6upq6xIBAGq12qgT1r9AaWlpqFKlCnx9fY3m138IFdW0FfySbcq0sj5XX5NOp6vQ45r7XP00S9cky7IhT9Zah/r31YMHD+Dn51fk85ycHm4qijqEVn+jQa1WW2hsJycnQ02PXtRGP64sy8WOC6DIcZVKpeHD99FxJUkyPFej0RRaF/ppOp0OWq3WYuPql7WocR+3Dp2dnYtd1tKMW9p1WHC5nJycyrwOLf3amLsORb42JeW7pGUtzbiAddehftyiarLUOtTXW/AzktsI42W1522EpZZVxLgFP9u4jXDcbYQ9f4/Q/1uSJMN77nHbCFk27Uglu2q8Zs+ejVatWiEyMtLwWLNmzdChQwfs378f/fv3h7e3N4CHl4r39/c3zJeeng4AhuleXl64e/duod+RlpZmmMdcRd3ROi8vDwAKnaP2KHOmleYFtfTvrCjjFnzMXmqyxbju7u4AHm6cSvoDR1EnnerHK7jBLmqe4k5YLWlaWcYFYNjQF0WhUBT6y7zocYGST9wtaVnLUm/BDxh9DfrXrSzLaovXBih5HVp63LLmu7hx9crbOnRycir0GcltROnHBWy7jTDnudbaRhT8cs1tROnGtcdthD1/j9B/RhZcvsctqylNF2Bnjde1a9fQuXNno8eqVauGypUr49atWwAenqMFPDzXS/9v/c8qlQq1a9c2zBcbG1uoE71+/TqCg4PLVGfBvR2PKulFsJcv2RzXPp776LSi9mBZ+ncWN73goWfm/gHAHtZhRR3XlOfqX+OCjZeImjiu/dYkctxH82UPNXFc+6zJnHFLs92yp3odtSZHG9eSNT26/SpLTUWxq/t41ahRA5cuXTJ67Pbt20hJSUHNmjUBALVr10bdunVx+PBho/liYmLQunVrw67B9u3bIy0tDbGxsYZ5rl+/jkuXLqF9+/Zm12jOSiYqLeaLROMVLEkk5otEYr5INNEZs6vGa8CAAfjuu+8we/Zs/Pzzz4iJicGIESPg5+eHbt26GeYbPXo0Dhw4gCVLluDMmTOYNm0azp8/j5EjRxrmad68OcLDwzFx4kQcOnQI33//PT744AOEhISgS5cuZaqzvH85Xrp0KUJCQgr916NHDwBASEgI1q1bZ5h/z549+Oabb0o1dqdOnQwXTgGAyMhIw7jlzdmzZ/Hee++hdevWCA0NRfv27TFu3DhcuHChyPlL+ktxWezZswchISFITk626LjkeCRJ4hXBSBjmi0Rivkg0a2TMrg41HDx4MJydnfHll1/iq6++goeHB5o1a4ZFixahcuXKhvl69OiBnJwcREdHY82aNQgMDMSyZcvQvHlzo/EWLVqEOXPmYOrUqdBoNAgPD8fkyZNLPF6zNEw9kc4Rubq6YtOmTYUeA4AdO3agRo0ahsf37t0Ld3d3vPTSSyb/npEjRyI7O7tsxdqhrVu3YtasWWjVqhUmTZqEgIAA3Lt3D9988w3efvtt/Prrr4WeU/BQQ0vmq0OHDtixY0ehK4FSxaM/OV1Eg0/EfJFIzBeJZo2M2VXjJUkSXnvtNbz22muPnbdv377o27dvifN4enri008/xaeffmqpEs26dKQjUigUaNasWZHTinvcHHXq1LHYWJaSn58PJyenEk8OLcnff/+NTz/9FL169cLcuXON3rw9evTA8ePHi31uaZv63NzcUl/l09fXt9CVNqni0mg0JZ6ETFQWzBeJxHyRaKIzZleHGpJjKHio4aBBg/DLL7/ghx9+MBySuHTp0lKP9eihhvrD4i5duoRhw4ahWbNm6NKlC/bt21fouT/88AP69u2LJk2aoFWrVpg2bZrR3rPs7GzMnDkTXbt2RdOmTdGpUydMnToVGRkZRuPoD3+Mjo5Gx44d0aRJE8NNsPfs2YOXXnoJYWFhaNeuHaKiogpdJvVRmzdvhiRJGD9+fJFNVMeOHQ3/3rdvH1577TW0aNECLVq0wODBg3H+/Hmj+ZcuXYrmzZvj/Pnz6N+/P8LCwrB161YkJCQgJCQEe/fuxcSJE/H000+jRYsWmDNnjtElV3moIREREZHt2dUeL7Ivj94voajjXqdNm4ZPPvkErq6uGD9+PIDib8JrinHjxqFfv3546623sHPnTkRGRiIsLAz16tUDABw+fBhjx45F7969MXr0aDx48AALFixAeno6oqKiADzcK6TVajF27Fj4+vri33//xapVqzBy5Eh88cUXRr/v6NGjeOKJJzBp0iQoFAq4u7tjw4YN+PzzzzFkyBBERkbi2rVrhsZr3Lhxxdb+66+/IjQ0tFR7mRISEvDyyy+jTp06yM/Px4EDBzBw4EB8/fXXCAwMNMynVqvx8ccf480338TYsWPh4+NjmLZw4UKEh4dj0aJFuHTpEpYsWQKVSlVijURERET2LicnB1evXkX9+vUBwPBvNzc3G1dmHjZeVKTs7Gw0btzY6LF58+ahV69eRo/Vr18flSpVgru7u0UPQXzjjTfwxhtvAHh4oZQff/wRR44cwciRIyHLMubNm4eIiAj897//NTzH398f77zzDkaOHIknn3wSvr6+mDFjhmG6RqNBrVq18Prrr+P69euFGpvo6GjD/awyMzOxZMkSDBs2DB999BEAoG3btlCpVJg7dy6GDh1qdN5hQffu3UNYWFiplnPUqFGGf2u1WrRu3RoXLlzA3r17Db9XX9/YsWMRERFheCwhIQHAw8M158yZAwBo164dcnNzsWHDBgwfPrzM96wjIiIispWcnBxcvHjRcHVz/b/ZeFUQ5p5sp75xB7q0jMfPaGEKb0+o6tZ4/IyPcHV1xZYtW4we098jzRrCw8MN/3Z3d0eNGjUMN8S+fv06bt++jYkTJxrtlWvRogUUCgUuXryIJ598EsDDQ/k2btyImzdvGh2GeOPGDaPGq2XLloamCwD++OMPZGdn48UXXzT6HW3atEFubi7++ecftGjRotj6S5uTa9euYeHChfjjjz+QlJRkVN+jnnvuuSLHeOGFF4x+7tq1K1asWIErV67g2WefLVUdVHHwpHQSifkikZiviiszOx/3U3Kg1pR8ukdZic4YGy8zmPqiaJNScavla4BOJ6iiEiiVqPvXPij9fEx6mkKhKPVeGxE8PT2NflapVMjPzwcApKSkAADef//9Ip/777//AgC+/fZbjB8/Hv379zccnvfgwQO8//77yMvLM3qOn5+f0c/63/HKK6+U+DuKEhAQgDt37hQ7XS8zMxNvv/02fH19ERkZiRo1asDFxQWTJ08uVJ+bmxs8PDyKHOfRQxqrVKkCAHjw4MFja6CKRZIknphOwjBfJBLzVfEkJycjISEBaYkpODR7Pc5WqowalXNw5WocAvzT4O3tbdGLh1kjY2y8rEDp54M6Z7602R4vU5sue6c/v2nq1Klo0qRJoelVq1YF8PA8sIYNGxrdN+yXX34pcsxHm2n9IXrLli0r8py1WrVqFVtfixYt8PXXXyM1NdXoXKxH/fnnn7h79y5Wr16NBg0aGB7PyMgo9DtLavYfvWhGYmIigIeHXhIRERE5otOnT+P+geNo8d0FeKZmI/O1VkhXe+D498egclKiUaNGRqdgOAI2XmYw5z5e5hzu5yhUKlWhPTQiBQUFoVq1aoiPjzecB1aU3NzcQn+5KO2Nnps3bw43NzfcvXu30KF8jzNo0CDs27cPn332meHcq4J++OEHdOjQAbm5uQBgqFGWZfz++++4ffu24VDJ0vj222/x5ptvGn4+cuQI3NzcEBwcbFLdVP7JsgyNRgMnJyceskMWx3yRSMxXxaK5fQ+h236E+shppDxRFV+/0h2X4IJaqkx07NQeAf5+Fj+P3RoZY+NloopyHy9TBAUFYd++ffj+++/h7++PqlWrIiAgQNjvkyQJkZGRGDduHLKzs9GhQwe4ubnhzp07+PHHHzF27FgEBgaiTZs2mDlzJpYvX264QEdsbGypfoeXlxc++OADfP7557h79y5atGgBpVKJ+Ph4HDt2DEuXLi32xM4GDRpg4sSJmDVrFu7du4dXX33VcAPlgwcP4uzZs/jll1/QrFkzuLu7Y8aMGXjnnXdw9+5dLFu2zOR1d+vWLUyYMAERERG4dOkS1qxZgyFDhvDCGlQkbsNIJOaLRGK+yj85Lx+pK3cgJWozFJXc4f75WPzinIu+7TvhQUoO/vrzJwTXDxJ2f1LRGWPjRWU2fPhw3Lp1C+PHj0d6ejpGjRqF0aNHC/2d3bp1g5eXF1atWmXYi1WzZk20a9fOcI7TgAEDkJCQgC1btmDdunUIDw/HggUL0K9fv1L9jrfffhsBAQHYsGEDtmzZAicnJ9SpUwcdOnR47DHAb7zxhuF+ZzNnzkRmZiZ8fX3RqlUrbNiwAcDDc7EWL16MefPmYeTIkahbty6mT5+OtWvXmrQuxo4di19++QUffvghlEolXn/9dYwdO9akMYiIiIhsKfvYGSROXAT1rX/h/U5f+I57E6nqPODIEVRyd0Yld2dcuai0dZllIsn880GpXbhwAbIsIywsrNAuyNzcXMMlyl1dXW1UITkyWZYNh7GWZhd3QkICOnfujMWLF+PFF18s0+9mfisGWZahVquhUql4qA5ZHPNFIjFf5Zf61r9ImrIUWTEn4Rr+FPznjoFzyMMrT1vzPl7mZOzChQsAUOoL0nGPFxERERERWZUuNw+py7YhdfEWKCp7IyB6Bjx6dTRqetzc3IyaGltecdsS2HiZiH9lIZGYLxKNl2MmkZgvEon5Kj+yjv6ExElLoLl9Hz4j+qPyR4OhqOT++CcKxsvJ2yF+OSYRTM1VrVq18L///U9QNVQecdtFIjFfJBLzVT6ob9xB4qTFyD76M9w6PIvq2+bB+cknbF0WAOtkjI2XGcy5nDzR4xQ83ZL5IhFkWYZOp4NCoWDGyOKYLxKJ+XJsupw8pC7ZgtSl26Cs4oOA9bPg0eM5u3otrZExNl4m4rVISCQ29SSaVquFQqGwdRlUTjFfJBLz5XhkWUb2oZNInLIMmruJ8Hn/NVT+cCAUHpa/OIYliM4YGy8LY2NGjoi5JSIiIkvKvxaPxImLkfP9Gbh3boXqOxfAuV5tW5dlU2y8LER/Ml52draQS1wSiZSdnQ2AJy4TERFR2eiycpCy6AukrtgOp2pVUG3zp3B/MZxH9ICNl8UolUr4+Pjg/v37AAB3d3cGjExi6n28LPU7s7Ozcf/+ffj4+ECpdOwbExIREZFtyLKMrG9+QNLUZdAmpqLyhwPhM/oNKNxcbF2a3WDjZaKSvhBXq1YNAAzNF5GpbHWOl4+PjyG/VL6xuSaRmC8SifmyX/n/3ETihEXI+fEs3Lu2RZXZH0BVt4atyzKZ6Iyx8TJDcV+MJUlC9erVUbVqVajVaitXRWQelUrFD7MKQpIkvtYkDPNFIjFf9kmXmY2UBRuRumonnGpVQ7Wtn8GjSxtbl2UWa2SMjZcZHrdXQqlUcuNAJrPFoYZUsTBjJBLzRSIxX/ZFlmVk7juGpKnLoUvLgO+4t+D9/gAoXB33sEJrZIyNl4l49TcSSaPR8AIXJBQzRiIxXyQS82Uf8v++jgcTFiH31O/w6N4efjNHQVWnuq3LsgjRGWPjRUREREREJdJlZCH58w1Ii94NVZ3qqL5jPtw7tbR1WQ6FjRcRERERERVJlmVk7j6KpOkroMvMhm/kMPiM6AfJxdnWpTkcNl5ERERERFRI3l9XkRi5CLmnz8GjZ0dUmfk+nGoG2Losh8XGy0Q8oZNEYr5INGaMRGK+SCTmy3q0aRlI+Ww90tbvhSqoFqrvjoL7c8/YuizhRGeMjZcZ+MYnESRJ4knDJBQzRiIxXyQS82Udsk6HjB2HkTxrFXTZufCb8i68h/eB5Fz+1701MsbGi4iIiIiogss7fwUPIqOQ9+tFVOr9PPymj4RTdX9bl1WusPEyw+Pu40VkDlmWodFo4OTkxHyREMwYicR8kUjMlzjalHQkz1mL9E37oQp+AjX2LYFb2+a2LsvqrJExNl4m4n28SCTmi0Rjxkgk5otEYr4sS9bpkLH1IJL+uxrI18BvxvvwHtobkqritgeiM1Zx1ywRERERUQWU++ffSBy/EHm/X0alfl3hN/U9OAX42bqsco+NFxERERFRBaBNTkPyf9cg/Ytv4NwoCDW+WQ63Vk1sXVaFwcaLiIiIiKgck7VapH/xDZI/jQa0OlT59EN4vdkLkhNbAWvi2jYRT+gkkZy4ASTBmDESifkikZgv8+Se/QuJkVHIO/c/eL4WAd8pI+DkX9nWZdkl0Rljgs3A5otEkCSJ2SKhmDESifkikZgv02kTU5A0azUyth2Ec5Ng1IxZCddnQ21dlt2yRsbYeJmBl5MnEWRZhk6ng0KhYL5ICGaMRGK+SCTmq/RkjQbpG/cjee5aQJJQ5fOP4TXoJUhKpa1Ls2vWyBgbLxPxUqYkklarhUKhsHUZVI4xYyQS80UiMV+Pl3PmPBLHRyH/0jV4DuwBv0nvQOnnY+uyHIbojLHxIiIiIiJyYJp7SUiauQqZOw/DpXlD1DyyGq7NG9q6LHoEGy8iIiIiIgckazRIW7sHKfPWAyon+C/8Dzzf6A6JewbtEhsvIiIiIiIHk/Pzn0iMjEL+39fh9WYv+E4YDmVlL1uXRSVg42UintBJIvHYdRKNGSORmC8Sifl6SHM3EUnTVyDzq2/h8kxj1Po2Gi5NQ2xdVrkgOmNsvMzA5otEkCSJ9yghoZgxEon5IpGYL0BWa5AWvRvJ89ZDcnOB/+JIeA7oxsMKLcQaGavYCTYTLydPIhS8YibzRSIwYyQS80UiVfR8ZZ/8DYmRUVBfjYf326+gcuRQKL09bV1WuWKNjLHxMhEvJ08iqdVqqFQqW5dB5RgzRiIxXyRSRcyX5s59JE5djqz938O1ZRMEHJsOl9D6ti6r3BKdMbtqvAYNGoRffvmlyGkLFy5E9+7dAQC7du3C2rVrcefOHQQGBmLs2LHo2LGj0fwZGRmYM2cOvvvuO6jVarRr1w6TJ09G1apVhS8HEREREZG55Hw1UlfuQMrCTVBUckfVFZNRqU+XCrm3rzyxq8Zr2rRpyMzMNHps06ZNOHr0KFq3bg0AOHjwIKZMmYIRI0agVatWiImJwahRo7B161Y0a9bM8LwxY8bg6tWrmD59OlxcXLBo0SIMHz4cX331VYU/RpiIiIiI7FP28V+QOGER1DfuwHv4q/D9z9tQeHrYuiyyALvqQOrXL7zr9OOPP0bbtm3h6+sLAFiyZAm6d++OMWPGAABatWqFK1euYPny5YiOjgYA/PHHHzh16hTWrVuH8PBwAEBgYCAiIiJw9OhRREREWGeBiIiIiIhKQR1/F0lTliHr4I9wbdMMARtmw6VhkK3LIguy68ug/P7770hISMBLL70EAIiPj8eNGzfQrVs3o/kiIiIQGxuL/Px8AMCJEyfg5eWFtm3bGuYJCgpCw4YNceLECestABERERFRCXS5eUhZsAnxbQci97e/UHXNNNTYt4RNVzlkV3u8HnXgwAG4u7ujc+fOAIC4uDgAD/deFVSvXj2o1WrEx8ejXr16iIuLQ2BgYKHjYIOCggxjmEuSJB5fS0JIkgRnZ2dbl0HlGDNGIjFfJFJ5zVfWt7FInLgYmoS78BnRD5U/fhOKSu62LqtCskbG7Lbx0mg0OHToEDp16gR394cBTEtLAwB4eRnflVv/s356eno6PD0LX2LT29sbFy9eLHNtRV3ZUJKkYq94qG/USpou6rkcl6+NvY9rjzU52rj2WBPHtd+aHG1ce6zJ0ca1x5oq+rjqm3eQNGUZsg+fglu7p1Ftyxw4B9c1Gqu8LKvoce2tppLYbeP1008/ITk5GT169LB1KUZkWUZ+fr7RXi+FQmG4YIdarS70HH33rNVqodPpjKY5OTlBkiTodDpotVqjafpxZVkuclz95S6LGlepVEKpVEKWZWg0GqNpkiQZnqvRaAoFR9S4pVlWoPA6FDWuflklSTJ5WUszLmDaOpRlGTqdDq6urpAkyeRl1Y9bVE22Wof6cUtah7bKd0nr0Jr5Bqy3jdBnTP88biMcaxtR1mUVvY2QZRl5eXlQKBRGn5HcRhgvqz1vIyy1rCLGlWXZMN2RtxG6nDxkrNyBjOVfQuHrg4C1M6F6sQ0kSTIavzxuI8xZh9bcRug/I5VKpeE997hthD6XpWW3jdeBAwfg4+NjuDgG8HCPFfDwUvH+/v6Gx9PT042me3l54e7du4XGTEtLM8xTFvqAFDetOAUD/SiFQgFFMXceLxh2U8d93HNLusKjqHFLWlag5HVo6XH1r2NZltVSr82jG46Ksg5tle+yvOdEvTaitxH6jBXchnEbUfK49rSNeJQ9rkOFQlHoM5LbiNKPC/B7RHHjFvyMdMRthJOTE7KP/ISkyUuh+fcBfEYOQOWxg6HwcCtxz0l520bY8/cIfcYKLt/jltWUpguw08YrNzcX3333HXr27Gm0IoOCHp5kGBcXZ/i3/meVSoXatWsb5ouNjS3UhV6/fh3BwcFlrk+Sij7P63Erv6Tpop7LccWOa+maivqyYsnfaY/j2mNNjjauKc/Vb78KNl4iauK49luTyHEfzZc91MRx7bMmc8YtzXbLnurV01y/jcRJi5H93Wm4dWyB6jvnw7leHZvWVJ7GtWRNj26/ylJTUezyqobff/89srOzDVcz1Ktduzbq1q2Lw4cPGz0eExOD1q1bG3YLtm/fHmlpaYiNjTXMc/36dVy6dAnt27cXvwBEREREVKHpsnOR9Gk0brUbjPz/3UC1Tf9F9R3GTRdVLHa5x+ubb75BjRo18PTTTxeaNnr0aIwbNw516tRBy5YtERMTg/Pnz2PLli2GeZo3b47w8HBMnDgR48ePh4uLC6KiohASEoIuXbpYc1GIiIiIqAKRZRlZB08gacpSaB+koPLo1+HzwUAo3F1tXRrZmN01XmlpaTh58iSGDBlS5C68Hj16ICcnB9HR0VizZg0CAwOxbNkyNG/e3Gi+RYsWYc6cOZg6dSo0Gg3Cw8MxefLkEo/VLA1zdisSlVZZ80n0OMwYicR8kUiOkK/8q7eQOGERcn74Fe4vtEaVPR9CFVjT1mVRKYnOmCSbcy3ECurChQsAgLCwMBtXQkRERET2QpeZjZSFm5G6agecalZFlf9+AI8ubW1dFglmam9g/386sEOmXjqSqDQKXuqb+SIRmDESifkikew1X7IsI2v/cSROWw5dcioqfzQYPqNeh8LVxdalkYmskTE2XibiDkISSavVlngZVqKyYsZIJOaLRLK3fOVfuYHEyCjknPwd7t3CUWXWaKieqGHrsqgMRGeMjRcRERERUSnpMrORPH8D0lbvgqp2dVT78nN4PN/K1mWRA2DjRURERET0GLIsI3PPd0iathy69Ez4/udt+IwcAMnF2dalkYNg40VEREREVIK8y3FIjIxC7s9/wqPHc/CbNRqqWgG2LoscDBsvE9nTCZ1U/tjTsetUPjFjJBLzRSLZIl/a9EykfLYeaev2QBVYE9V3LYR7h2etXgdZh+iMsfEyA5svEkGSJIe4Rwk5LmaMRGK+SCRr50uWZWTuPIKkGSuhy8qB76Th8Hm3HyRnldVqIOuyRsa4hSSyI7xVAYnGjJFIzBeJZK185V345+Fhhb9cQKWXO8FvxvtwqlFV+O8l2xOdMTZeJpJlmR8sJIQsy1Cr1VCpVMwXCcGMkUjMF4lkjXxpUzOQPGct0jfug+rJOqixdzHcwp8S8rvI/lgjY2y8iIiIiKjCknU6ZHx5CEmzV0HOzYff9PfgPawPJBW/JpNlMVFEREREVCHlnfsfHoxfiLzfLqFSnxfgN20knKpVsXVZVE6x8SIiIiKiCkWbko7kT9cgfdPXcG4YiBr7l8KtTTNbl0XlHBsvIiIiIqoQZK0WGVsPIum/awC1Bn6zP4D32y9D4hU5yQqYMhPxhGESSaXiZWpJLGaMRGK+SKSy5iv390tIHB+FvD//hmf/F+E79T04VfW1UHVUHojehrHxMgObLxKBuSLRmDESifkikcqSL21iCpL+uwYZWw/CuXF91Dy4Aq4twixYHZUH1tiGsfEyAy8nTyLIsgytVgulUsl8kRDMGInEfJFI5uRL1mqRvulrJM+JBmQZVeaOhdeQnpCUSsHVkiOyxjaMjZeJZFm2dQlUjul0Oij5gUACMWMkEvNFIpmSr9xfL+LB+IXIv/APPN/oDr/J70JZpbLgCsnRid6GsfEiIiIionJBcz8ZyTNXImPHYbg0a4CaR1bD9alGti6LCAAbLyIiIiJycLJGg7T1+5Dy2TpAqYD/gk/g+UZ3HlZIdoWNFxERERE5rJzYc0icEIX8S3HwGtwTvhOHQ+nrbeuyiAph42UinjBMIvHcCBKNGSORmC8S6dF8ae4mImnmSmTuOgqXpxuh5tE1cG3WwEbVUXkgehvGxssMbL5IBEmS+KWFhGLGSCTmi0QqmC9ZrUHa2t1InrcBkosK/osi4flaN0gKhY2rJEdmjW0YGy8z8HLyJIIsy4ZsMV8kAjNGIjFfJJI+X7k//4nECYugvnITXm++DN8Jw6D08bR1eVQOWGMbxsbLRLycPImk0WiE3zWdKjZmjERivkgUzb8PkDh1GbL3H4frs6EI+G4tXMKetHVZVM6I3oax8SIiIiIiuyTnq5G6eidS5m+C5OEK/6UT4dn/Re5VJYfExouIiIiI7E72j2cfHlYYlwCvoa/Ac+wguPhVZtNFDouNFxERERHZDXXCPSRNWYqsAz/CtXVTBKydAeeGQVCr1bYujahM2HiZiH9lIZGYLxKNGSORmC8qCzkvH6krtiNl0RdQeHqg6qqpqNT7eUiSxAubkVWIzhgbLzPwjU8iSJLEk9JJKGaMRGK+qCyyj51B4sRFUN/6F97v9IXvuDeh8PQwTGe+SDRrZIyNFxERERHZhPrWv0icvATZh07BNfwpVNv8KZxDAm1dFpEQbLzMwN3dJIIsy9BoNHBycmK+SAhmjERivsgUutw8pC7bhtTFW6Co7I2A6Bnw6NWx2OwwXySaNTLGxstEvI8XicR8kWjMGInEfFFpZB39CYmTlkBz+z58RvRH5Y8GQ1HJ/bHPY75INNEZY+NFRERERMKpr99+eFjh0Z/h1uFZVP/yczjXr2Prsoisho0XEREREQmjy85F6pItSF32JZT+lRGwYTY8urfnIYNU4bDxIiIiIiKLk2UZ2YdOInHyUmjuJcHn/ddQecwgKNxdbV0akU2w8TIR/zpDIvFSuSQaM0YiMV+kl3/tFhInLkHO92fg3rkVqu9aCOd6tcs0JvNFovFy8naIzReJwFyRaMwYicR8EQDosnKQErUZqSt3wKlaFVT7Yg7cu7Ytcz6YLxLNGhlj42UGXk6eRJBlGVqtFkqlkvkiIZgxEon5qthkWUbWNz8gaeoyaBNTUfnDgfAZ/QYUbi4WG5/5IpGskTE2XibipUxJJJ1OB6VSaesyqBxjxkgk5qtiyv/nJhInLELOj2fh3rUtqsz+AKq6NSz+e5gvEk10xth4EREREZHJdJnZSFmwEamrdsKpVjVU2/oZPLq0sXVZRHaLjRcRERERlZosy8jcdwxJU5dDl5YB33Fvwfv9AVC4WuawQqLyio0XEREREZVK/t/X8WDCIuSe+h0e3dvDb9ZoqGpXs3VZRA6BjZeJeEInicRj10k0ZoxEYr7KL11GFpLnrUda9FdQ1a2B6jvmw71TS6vWwHyRaKIzphA6upn27t2Ll19+GWFhYWjZsiWGDRuG3Nxcw/Tvv/8ePXv2RFhYGLp27Yqvvvqq0Bj5+fn47LPP0LZtWzRr1gxvvfUW4uLiLFIfmy8SQZIkXq2JhGLGSCTmq3ySZRkZu47gVqvXkb75a/hOGIbaP260etPFfJFo1siY3e3xWrlyJaKjozFixAg0a9YMKSkpiI2NhVarBQCcPXsWo0aNQp8+fTBx4kScPn0akyZNgoeHB1588UXDOLNnz0ZMTAwiIyMREBCAVatW4c0338TBgwfh6elZphp5OXkSQZZlQ7aYLxKBGSORmK/yJ+/iVSRGRiH3zHl49OqEKjNGwqlmgE1qYb5INGtkTJLt6ProcXFxeOmll7BixQo899xzRc4zdOhQZGVlYfv27YbHPv74Y1y+fBkxMTEAgLt376JTp06YNm0a+vfvDwBITU1Fx44dMXLkSAwfPtys+i5cuABZlhEWFsY3PVmcLMtQq9VQqVTMFwnBjJFIzFf5oU3LQMrcdUhbvxeq+rVRZc4YuLd/xqY1MV8kmjkZu3DhAgAgLCysVPPb1aGGe/bsQa1atYptuvLz83HmzBmjPVsAEBERgWvXriEhIQEAcOrUKeh0OqP5fHx80LZtW5w4cULcAhARERE5KFmnQ/qXMYhv/QbSv4yB39QRqH18g82bLqLywq4ar3PnziE4OBgrVqxA69atERoaigEDBuDcuXMAgFu3bkGtViMoKMjoefXq1QMAwzlccXFx8PPzg7e3d6H5LHWeFxEREVF5kXfuf7jd4308+GAO3No9jTqxW+Hz/muQnFW2Lo2o3LCrc7wePHiAixcv4sqVK5g2bRrc3NywatUqvP322zh69CjS0tIAAF5eXkbP0/+sn56enl7keVxeXl6GecqiqKMzJUkq8nH9tOKeJ/q5HNdxXhv9scUFf7bEuKLqtdS49liTo41b2ufqM6b/2RGX1dHGtceaRI776HbMEuOWtSaOW/JzdakZSJ4TjfRNX0MV/ASq710Mt7bNDdPtZVkLZquivDblLYf2vg4LbsPKMm5J7KrxkmUZ2dnZWLx4MRo0aAAAaNq0KTp16oQtW7YgPDzcxhU+pFarjY79VCgUcHJyMkx7lLOzMwBAq9VCp9MZTXNycoIkSdDpdIYLiDw6rv6Y00epVKpix1UqlVAqlZBlGRqNxmiaJEmG52o0mkLBETVuaZYVKLwORY2rX1ZJkkxe1tKMC5i2DmVZNprX1GXVj1tUTbZah/pxS1qHtsp3SevQmvkGrLeNkGXZMIaTkxO3EY8ZV7+s9rKNKOuyWmMboZ9W8DOS2wjjZbWXbYSs0yF317dI/u9qyPka+EwdgUpv9oKkcoJarba77xEF/81thONuI+z5e4T+M1KSJMN77nHbiIJNWmnYVePl5eUFHx8fQ9MFPDw3q1GjRrh69Sq6d+8OAMjIyDB6Xnp6OgAYDi308vJCZmZmofHT09MLHX5oqoIvRlH0L0ZRCgb6UQqFAgpF0Ud+Fgy7qeM+7rn6N4I1xy1pWYGS16Glx9W/WcqyrJZ+bfQ1VZR1aKt8l+U9J+q14TbiofKU7+LG1StP61CSJLi5uRX5OMBtRGnGBayzjcj7828kRkYh7/fLqNSvK3ynjIBTgF+pnvsoa28jJEniNqKU49rbNqK4cR15G2FK0wXYWeNVv3593Lp1q8hpeXl5qFOnDlQqFeLi4tCuXTvDNP15W/pzv4KCgpCYmIi0tDSjRisuLq7Q+WHmKG4lP27llzRd1HM5rthx7bEmRxvXHmtytHHtsSaOa781Odq49liTo42rn65NSkXSf9cgY8sBODeqhxrfLIdbqyZm/86y1MRx7bcmRxvXXmsqil1dXKNjx45ITU3F5cuXDY+lpKTgr7/+QuPGjeHs7IyWLVviyJEjRs+LiYlBvXr1UKtWLQBAeHg4FAoFjh49apgnLS0Np06dQvv27ctcpznHdBI9jn5XOfNFojBjJBLzZb9krRZpG/fhVus3kLX/OKp8+iFqfRf92KbLnjBfJJo1MmZXe7yef/55hIWF4YMPPsDYsWPh4uKCNWvWwNnZGa+//joA4L333sPgwYMxffp0dOvWDWfOnMGBAwcQFRVlGKdatWro06cP5s2bB4VCgYCAAKxevRqenp4YMGBAmWrkG55EYr5INGaMRGK+7E/u2b/wYPxC5J+/As/Xu8N38rtw8q9s67LMwnyRaKIzZlc3UAaA5ORkzJkzB8ePH4darcYzzzyDCRMmoH79+oZ5jh07hkWLFuH69euoUaMG3nnnHfTp08donPz8fERFRWH//v3IysrCU089hcmTJxsuPW8O3kCZRNL/pYU3hyRRmDESifmyL5oHKUietQoZX8bAuUkw/D/7CK7PNLZ1WWZjvkg0czJm6g2U7a7xsmdsvEgkfqiQaMwYicR8WVdOTg4uXbqE/Px8ODs7IzAwELdv30a9uoFQ7ziC5LlrAUmC76R34DXoJUjFXFzAUTBfJJo1Gi+7OtSQiIiIiB4vJycHFy9eNHxR9PX1xY3938LzyJ/Q/u8GPAf2gN+kd6D087F1qUT0f9h4mYh/ZSGRSrpsKZElMGMkEvNlXVqtDjl5GqgycpExfhkaHf8FCHsSNY+shmvzhrYuz+KYLxJNdMaYYDOw+SIRJElitkgoZoxEYr6sIzk5GWlpabh+4xZu3foXT/4Rh6fOXoNOocDPnZqg5rt9IPu4wjs5Gb6+vrYu12KYLxLNGhlj42UGU+9STVQasixDp9OZdUM+otJgxkgk5ss6Tp8+jUuXLsHznzvo8cMl+CRn4UpoLZxrVQ95Lirc+Okn/P77b2jUqBEiIiJsXa7FMF8kmjUyxsbLRLwWCYmk1WpLvOM7UVkxYyQS8yVei8AnEbL1OHD0V9yv5oP9r7ZGavXKyFd4whXZaNuuJQKfqANvb29bl2pxzBeJJjpjbLyIiIiI7Jys1iBtzS6kf74BCjcXuM75AJeRAee8fNRxcUZI42dw4+p5NGsSVq4OMSQqT/hnAyIiIiI7ln3iLOI7vImkmavg9Xp31Dm9DS69O0OpUsLNxQnOKiVqV/OEysmxLxlPVN5xjxcRERGRHdLcvofEqcuR9fVxuLZsgoDvp8OlcX0AgFtODkJDQw338fL29kZoaCjc3NxsXDURFYeNl4l4QieJxGPXSTRmjERivixDzstH6qqdSFm4CYpK7qi6YjIq9eli9B3Ezc0NTz/9tNHzyvshhswXiSY6Y2y8zMDmi0SQJIn3KCGhmDESifmyjOzvzyBx4mKob9yB9/BX4fuft6Hw9LB1WTbHfJFo1sgYE2wGXk6eRCh4xUzmi0Rgxkgk5qts1PF3kTRlKbIOnoBrm2YI2DAbLg2DbF2W3WC+SDRrZIyNl4l4OXkSSa1WQ6VS2boMKseYMRKJ+TKdLjcPacu3I2XxF1B4e6Lqmmmo9HJnNhdFYL5INNEZY+NFREREZANZ38YiceJiaBLuwmdEP1T++E0oKrnbuiwiEoSNFxEREZEVqW/cQeLkJcg+8hPcnnsG1bd9Bucnn7B1WUQkGBsvIiIiIivQ5eQhdelWpC7ZCmUVHwSsmwmPlzrwsEKiCoKNl4m4cSSRmC8SjRkjkZivosmyjOwjPyFx8hJo7jyAz8gBqDx2MBQevOeWKZgvEk10xth4mYFvfBJBkiSeNExCMWMkEvNVNHVcAhInLkb2sdNw69QS1XfMh3O9OrYuy+EwXySaNTLGxouIiIjIwnTZuUhZ9AVSl38JpwA/VNv0X7h3a8c/3hJVYGy8zMD7eJEIsixDo9HAycmJ+SIhmDESifl6SJZlZB34EUlTl0H7IAWVR78Onw8GQuHuauvSHBrzRaJZI2NsvEzE+3iRSMwXicaMkUgVPV/5V28hccIi5PzwK9xfaI0qez6EKrCmrcsqNyp6vkg80Rlj40VERERUBrrMbKQs3IzUVTvgVLMqqm2dC48ubW1dFhHZGTZeRERERGaQZRlZ+48jcdpy6JJTUfmjwfAZ9ToUri62Lo2I7BAbLyIiIiIT5f/v+sPDCk/+Do+IdvCbOQqqJ2rYuiwismNsvEzEEzpJJCcnviVJLGaMRKoI+dJlZiP58w1IW7MLqtrVUX37fLh3bmnrsiqEipAvsi3RGWOCzcDmi0SQJInZIqGYMRKpvOdLlmVk7vkOSdOWQ5eeCd//vA2fkQMguTjburQKobzni2zPGhlj42UGXk6eRJBlGTqdDgqFgvkiIZgxEqk85yvv0jUkRkYhN/YcPF7q8PCwwloBti6rQinP+SL7YI2MsfEyES9lSiJptVooFApbl0HlGDNGIpW3fGnTM5Hy2XqkrdsDVWBNVN+1EO4dnrV1WRVWecsX2R/RGWPjRURERFSArNMhY+cRJM9cCV1WLnwnDYfPu/0gOatsXRoROTA2XkRERET/J+/CP0gcvxC5v15EpZc7wW/G+3CqUdXWZRFROcDGi4iIiCo8bWoGkuesRfrGfVA9WQc19i6GW/hTti6LiMoRNl4m4gmdJBKPXSfRmDESyRHzJet0yPjyEJJmr4Kcmw+/6e/Be1gfSCp+RbI3jpgvciyiM8atihnYfJEIkiTxHiUkFDNGIjlivvLO/Q8Pxi9E3m+XUKlvF/hNfQ9O1arYuiwqgiPmixyLNTLGBJuBl5MnEQpeMZP5IhGYMRLJkfKlTU5D8qfRSN/8NZwbBqLG18vg1rqprcuiEjhSvsgxWSNjbLxMxMvJk0hqtRoqFa+aReIwYySSvedL1mqRsfUgkmavBjRa+M3+AN5vvwyJe1Icgr3nixyf6IxxS0NERETlXu5vfyExchHy/vwbngO6wXfKCDhV9bV1WURUgbDxIiIionJLm5iCpNmrkbH1IJzDnkTNgyvg2iLM1mURUQXExouIiIjKHVmrRfrG/UieEw0AqPLZR/Aa0hOSUmnjyoioomLjRUREROVK7i8X8GB8FPIv/gPPN7rDb/K7UFapbOuyiKiCY+NlIkmSeDUdEkKSJKhUKuaLhGHGSCR7yJfmfjKSZ65Exo7DcGnWADWPrIbrU41sVg9Zjj3ki8o3a2SMjReRHeEHConGjJFItsqXrNEgbf0+pHy2DlAq4L/gE3i+0Z2HFZYz3H6RaKIzxsbLDLyPF4kgyzK0Wi2USiXzRUIwYySSrfKV8/OfSJwQhfzL1+E1pCd8JwyH0tfbar+frIPbLxLNGhlj42Ui3seLRNLpdFDyL7QkEDNGIlkzX5q7iUiasQKZu7+Fy9ONUOvbaLg0DbHK7ybb4PaLRBOdMTZeRERE5DBktQZpa3cjed4GSC4q+C+KhOdr3SApFLYujYioRGy8iIiIyCHknPodDyKjoP7nFrzeehm+kcOg9PG0dVlERKViV38e2rNnD0JCQgr9N3/+fKP5du3aha5duyIsLAw9e/bE8ePHC42VkZGBiRMnokWLFmjevDk++OAD3L9/31qLQkRERBaiuXMf94ZPw51XPoTS2xO1vlsL/7lj2XQRkUOxyz1ea9euhafn/9+YBgQEGP598OBBTJkyBSNGjECrVq0QExODUaNGYevWrWjWrJlhvjFjxuDq1auYPn06XFxcsGjRIgwfPhxfffUVnJzMX2ye0Eki8dh1Eo0ZI5EsnS85X43U1TuRMn8TFB5uqLpsEir168rP4gqK2y8STXTG7LLxaty4MXx9fYuctmTJEnTv3h1jxowBALRq1QpXrlzB8uXLER398O70f/zxB06dOoV169YhPDwcABAYGIiIiAgcPXoUERERZaqPG3wSQZIkfqiQUMwYiWTpfGX/8CsSJyyC+vpteA/rjcr/eRtKr0oWG58cC7dfJJo1MmZXhxo+Tnx8PG7cuIFu3boZPR4REYHY2Fjk5+cDAE6cOAEvLy+0bdvWME9QUBAaNmyIEydOlLkOXtmQRJBlGTqdjvkiYZgxEslS+VIn3MPdtybj374fQelfGbW+X4cqsz9g01XBcftFolkjY3bZePXo0QMNGzZE586dsXr1ami1WgBAXFwcgId7rwqqV68e1Go14uPjDfMFBgYW2jMVFBRkGMNcfMOTSBqNxtYlUDnHjJFIZcmXnJePlKjNiG87ELm/XkTVVVNRY/9SuDSqZ8EKyZFx+0Wiic6YXR1q6O/vj9GjR6Np06aQJAnff/89Fi1ahHv37mHq1KlIS0sDAHh5eRk9T/+zfnp6errROWJ63t7euHjxYpnrLKr5kiSp2KZM3wCWNF3Uczmu47w2siwbPWZvy+oI67Cijlva5+ozpv/ZEZfV0ca1x5pEjvvodqy042YdO42kiYuhvvUvvIf3QeVxb0Lh6WHXy+pI49pjTaaOWzBbjlCvI9fkaONaqqaC27CyjFsSu2q82rVrh3bt2hl+Dg8Ph4uLCzZt2oQRI0bYsDJjarXaaG+aQqEwXLBDrVYXmt/Z2RkAoNVqodPpjKY5OTlBkiTodDrDnr1Hx5VluchxVSpVseMqlUoolUrIslyoe5ckyfBcjUZTKDiixi3NsgKF16GocfXLKkmSyctamnEB09ahLMtG9Zu6rPpxi6rJVutQP25J69BW+S5pHVoz34D1thEFl8vJyYnbiMeMq19We9lGlHVZrbGN0Ndb8DOypHUo33mA5KnLkH3oFFzaNke1dTOgCq4LLQBZq+U24v/we4Rx48VthONuI+z5e4T+35IkGd5zj9tGFGzSSsPkxishIQHHjh3D77//jmvXriElJQWSJKFy5coICgrCU089hU6dOqF27dqmDl2kbt26Yf369bh8+TK8vb0BPLxUvL+/v2Ge9PR0ADBM9/Lywt27dwuNlZaWZpinLPQBKW5acQoG+lEKhQKKYm7+WDDspo77uOeWdIVHUeOWtKxAyevQ0uPqX8eyLKulXpuiNmLFKU/r0Fb5Lst7TtRrI3oboc9YwW0YtxElj2tP24hH2eM6dHJyKvQZWdQ61OXmIW3Zl0hdsgWKyt6oGj0dHj07FvnZym3E/1eRv0cU/HLNbUTpxrXHbYQ9f4/Qf0YWXL7HLaspTRdgQuN1/PhxrF+/Hr/99htkWUadOnVQq1YtBAcHQ5ZlpKen4++//8bRo0cxd+5cPP300xg6dCg6duxoUkElCQoKAvDwHC79v/U/q1QqQ7MXFBSE2NjYQl3o9evXERwcXKYaJEky/FfUtMc915xpZXkuxxU7rqVrKrhhsLdldZR1WBHHNeW5SqXSaBvmaMvqaOPaY00ix300X0U9N+vIT0icvASa2/fh815/VB47GIpK7sJq4rj2WZM54+o/Ix2lXketydHGtWRN+m2YJWoqSqkar379+uHvv/9G586dsWjRIrRp0waVKhV9daHMzEz89NNPOHLkCMaMGYMGDRpgx44dJhemFxMTA6VSiUaNGsHf3x9169bF4cOH8fzzzxvN07p1a8Nuwfbt22PFihWIjY1FmzZtADxsui5duoRhw4aZXYueOSua6HEkSSrTPeaIHocZI5Eely/19dtInLQY2d/Gwq3Ds6j+5edwrl/HihWSI+P2i0SzRsZKNXrLli2xYsUKVKlS5bHzVqpUCV27dkXXrl3x4MEDbN68udTFDB06FC1btkRISAgA4NixY9i5cycGDx5sOLRw9OjRGDduHOrUqYOWLVsiJiYG58+fx5YtWwzjNG/eHOHh4Zg4cSLGjx8PFxcXREVFISQkBF26dCl1PURERFQ2uuxcpC7ZgtRlX0LpXxkBG2bDo3t7/hGTiCocSTbnkhyCzJ49GydPnsTdu3eh0+lQt25d9O3bF4MGDTLaQO/atQvR0dG4c+cOAgMD8dFHHxU6pDEjIwNz5szBt99+C41Gg/DwcEyePBkBAQFm13fhwgXIsoywsDB+YJDF6Y9fL+kcQqKyYMZIpEfzJcsysmJOImnKUmjuJcHn/ddQecwgKNxdbV0qOSBuv0g0czJ24cIFAEBYWFip5rerxsvesfEikfihQqIxYyRSwXyp4+KROGExco7/AvfOreD33w/gXM8yF92iionbLxLNGo1XqQ9k/Ouvv0o7q0Hjxo1Nfg4RERE5Jl12DpKXbUDqiu1wqu6Pal/MgXvXtvyiTEQEExqvV1991aQNpyRJuHTpkllFERERkeOQZRmZ3/yApCnLoEtKReUxg+Az+g0o3FxsXRoRkd0odeM1Z86cx86Tm5uLnTt34vLly2UqioiIiBxD/pUbSJy4GDk/noVrlzbwn/0BnANr2rosIiK7U+rG65VXXil2Wn5+PrZv347o6Gg8ePAAzz77LEaPHm2RAu0ND5cgkUq6ASCRJTBjZCm6zGykLNiI1FU74VSrGqpt+wzuz7e2dVlUjnH7RaKJzliZLlafn5+PL7/8EmvXrsWDBw/QokULLFy4EM8++6yl6rNLbL5IBOaKRGPGyBJkWUbm3mNImrYcurQM+H7yNrxH9ofClYcVkjjcfpFo1siYWY1Xfn4+tm3bhnXr1uHBgwdo2bJlhWi49GRZ5gaALE6WZWi12kJ3TSeyFGaMyirvchwSJyxC7k9/wKP7c/CbNQqq2tUAMF8kFvNFolkjYyY1Xnl5eYY9XImJiWjZsiWioqLwzDPPCCnOHvHq+ySSTqeDUqm0dRlUjjFjZA5teiZSPt+AtOivoKpbA9V3LoB7xxaF5mO+SCTmi0QTnbFSN14bN27E2rVrkZSUhFatWmHx4sV4+umnhRVGREREtiXLMjJ3HUHS9JXQZWXDd8Iw+IzoB8nF2dalERE5nFI3XnPnzoUkSWjYsCHq1auHQ4cO4dChQyU+Z/LkyWUukIiIiKwv7+JVJEZGIffMeXj06oQqM0bCqWaArcsiInJYJh1qKMsyLl26VKr7c0mSxMaLiIjIwWjTMpAydx3S1u+Fqn5tVP8qCu7tK84pBUREopS68fr7779F1uEweEInicRj10k0ZoyKI+t0yNhxGMmzVkGXnQu/qSPgPbwPJOfSX16Z+SKRmC8STXTGynQ5+YqKzReJIEkSP1RIKGaMipN37n94MGER8n69iEqvvgC/6SPhVK2KSWMwXyQS80WiWSNjbLzMwMvJkwiyLBuyxXyRCMwYPUqbko7kOdFI37gfzg0CUWPfEri1bW7WWMwXicR8kWjWyJjZjdf+/fvx1VdfISEhAWlpaYUusy5JEn777bcyF2hveDl5Ekmj0Qi/azpVbMwYAf93WOHWA0iavQZQa+A3azS8334Fkqpsf49lvkgk5otEE50xs7awn3/+OdavX4+AgACEhobC09PT0nURERGRALl/XEbi+Cjk/XEZlfq9CL+pI+AU4GfrsoiIyj2zGq9du3ahQ4cOWL58ORQKhaVrIiIiIgvTJqUi6b9rkLHlAJwb1UONA8vh1rKJrcsiIqowzD6m4LnnnmPTRUREZOdkrRbpm79G8qfRgE5GlU8/hNebvSA58TRvIiJrMqtz6tChQ7k8f6s0eEInicR8kWjMWMWS++tFJHR5B4n/WQiPiPaofXobvIe9KqzpYr5IJOaLRBOdMUk242oRGRkZGDFiBEJCQvDqq6+ievXqRe798vHxsUSNduPChQsAgLCwMBtXQkREVDzNgxQkz1qFjC9j4NwkGP6ffQTXZxrbuiwionLF1N7ArD95ubm5oXnz5li3bh2+/PLLYue7fPmyOcMTERGRGWSNBukb9yN57lpAklDl84/hNeglSLz/ERGRzZnVeM2cORO7du1C06ZN0bRp0wp3VUPex4tEkGUZGo0GTk5OzBcJwYyVbzmnzyMxMgr5l67Ba9BL8J04HEo/H6v9fuaLRGK+SDRrZMysxuvQoUPo1asX5s6da+l67B7v40UiMV8kGjNW/mjuJSFp5kpk7jwCl6caouaR1XBt3tAmtTBfJBLzRaKJzphZjZeTkxOaNm1q6VqIiIiolGS1Bmnr9iBl3npA5QT/hf+B5xvdIfGKw0REdsmsrXP37t1x/PhxS9dCREREpZDz0x9I6DwUSdOWo1KfLqhzetvDc7nYdBER2S2z9nh169YNs2fPxjvvvGO4qqGyiBN3GzfmFZSIiIgsRXM3EUnTliNzz3dweTYUtb6NhkuTYFuXRUREpWBW4/XGG28AeHjVwpMnTxaarr/4RHm8qiFP6CSRnHhDUxKMGXNMcr4aqWt2IWX+RijcXeG/dCI8+3W1uz1czBeJxHyRaKIzZtboc+bMsXQdDoXNF4kgSRKzRUIxY44p+8RZJEYugvpaPLyH9kbl8W9D6W1/VxNmvkgk5otEs0bGzGq8XnnlFUvX4VB4OXkSQZZl6HQ6KBQK5ouEYMYci+b2PSROXY6sr4/DtWUTBERPh0vj+rYuq1jMF4nEfJFo1sgY99maiJcyJZG0Wi0UdnboEJUvzJj9k/PykbpyB1KiNkNRyR1VV0xGpT5dHOLLJvNFIjFfJJrojJVq5KlTpyI+Pt7kwW/duoWpU6ea/DwiIqKKKPv7M4h/7k0kz10HryG9UOf0Nnj27eoQTRcREZWsVHu8/v33X3Tr1g2tWrVCREQEWrdujerVqxc5b0JCAmJjY3Ho0CGcOXMGbdu2tWjBRERE5Y06/i6SpixF1sETcG3bHNU2/hfODQJtXRYREVlQqRqv6Oho/Pbbb1i/fj2mTp0KrVYLHx8f1KxZE97e3pBlGWlpaUhISEB6ejqUSiXat2+PTZs24ZlnnhG9DERERA5Jl5uHtOXbkbL4Cyi8PVF1zTRUerkz93AREZVDpT7H6+mnn8bTTz+N5ORkHD9+HH/++Sfi4uJw9+5dAICPjw+6dOmCZs2aoUOHDvDz8xNWtC3xw5BEKup+eESWxIzZj6yjPyNx0hJoEu7C573+qPzRECgqudu6rDJhvkgk5otEE50xSebVIkrtwoULAICwsDAbV0JERI5KfeMOEicvQfaRn+D23DOoMmcMnJ98wtZlERGRiUztDXhVQzPwcvIkQsG/gTBfJAIzZlu6nDykLtmC1KXboKzig4D1s+DR47ly81owXyQS80WiWSNjbLxMxB2EJJJarYZKpbJ1GVSOMWPWJ8sysg+fQuLkpdDcTYTPyAGoPGYQFB5uti7N4pgvEon5ItFEZ4yNFxERkSD51+KRNGkJso+dhlunlqi+cz6c69WxdVlERGQDbLyIiIgsTJeVg5RFXyB1xXY4Bfih2qb/wr1bOx4iRURUgbHxIiIishBZlpF14EckTV0G7YMUVP7gDfiMfgMKd1dbl0ZERDbGxstE/GslicR8kWjMmDj5V28hccIi5PzwK9y7tEGV2R9AFVjT1mVZFfNFIjFfJJrojClKO+PChQvx999/i6zFYfCNTyJIkgSVSsV8kTDMmBi6zGwkzVyF+PZDoL5xG9W2zkX1rZ9VyKaL+SJRmC8SzRoZK3XjtWbNGvzzzz+Gn1NSUtCwYUPExsYKKYyIiMieybKMzL3HcKvNQKRF70Llj4eg9snN8OjS1talERGRHSrToYYV9dLqvI8XiSDLMjQaDZycnJgvEoIZs5z8/11/eFjhyd/hEdEOfrNGQ1Wnuq3Lsinmi0Rivkg0a2Ss1Hu8rC0rKwvt27dHSEiI4a7Qert27ULXrl0RFhaGnj174vjx44Wen5GRgYkTJ6JFixZo3rw5PvjgA9y/f7/MdVXUZpOsg/ki0ZixstFlZCFx6jLEd3gLmtv3UX37fFTb9GmFb7r0mC8Sifki0URnzG4brxUrVkCr1RZ6/ODBg5gyZQq6deuG6OhoNGvWDKNGjcKff/5pNN+YMWPw008/Yfr06Zg/fz6uX7+O4cOHQ6PRWGkJiIiovJBlGRm7j+JW6zeQvmk/fMcPRe0Tm+DeuaWtSyMiIgdh0qGGt2/fxl9//QXg4R4lALh58ya8vLyKnL9x48ZmFXXt2jVs27YN48ePx7Rp04ymLVmyBN27d8eYMWMAAK1atcKVK1ewfPlyREdHAwD++OMPnDp1CuvWrUN4eDgAIDAwEBERETh69CgiIiLMqouIiCqevEvXkBgZhdzYc/B4qQP8Zo6CqlaArcsiIiIHY1LjtXjxYixevNjosRkzZhSaT38O1OXLl80qavbs2RgwYAACAwONHo+Pj8eNGzfwySefGD0eERGBefPmIT8/H87Ozjhx4gS8vLzQtu3/P8E5KCgIDRs2xIkTJ9h4ERHRY2nTM5Hy2XqkrdsDVWBNVN+1EO4dnrV1WURE5KBK3XjNmTNHZB0Ghw8fxpUrV7B06VLD3jW9uLg4ACjUkNWrVw9qtRrx8fGoV68e4uLiEBgYWOjEuKCgIMMY5uIJnSSSkxNvrUdiMWOPJ+t0yNh5BMkzV0KXlQvfye/A552+kJxVti7N7jFfJBLzRaKJzlipR3/llVdE1gEAyMnJwdy5czF27FhUqlSp0PS0tDQAKHRoo/5n/fT09HR4enoWer63tzcuXrxokVofPflOkqRiT8jTN2slTRf1XI7rWK+NJEl2u6yOsg4r4rimPLfg/I64rKLHzbvwDxIjo5D360V4vNIZVWa8D6fq/pBludj3rKMuq6XHLW4MbiNsP6491mTOuPrPSEep11FrcrRxLVnToztYzBm3JHb1p4OVK1fCz88Pr776qq1LKZYsy8jPzzd6YRQKhaFDVqvVhZ7j7OwMANBqtdDpdEbT9Jes1Ol0hS4moh9XluUix1WpVMWOq1QqoVQqDZfGLEh/gzgA0Gg0hYIjatzSLCtQeB2KGle/rJIkmbyspRkXMG0d6r/Yubi4QJIkk5dVP25RNdlqHerHLWkd2irfJa1Da+YbsN42Qp8xSZLg5OTEbUSBcbWpGUj6dA0yN38Dp/q14b9zPlzbNofSzGUVsY0o67KK3kYU/Hws+BnJbYTxstrzNsJSyypiXFmWDcvD7xGOuY0oaVntYRuh/4xUKBSG99zjthH6z9TSspvG6/bt21i/fj2WL19uuHBHdna24f9ZWVnw9vYG8PDCHv7+/obnpqenA4BhupeXF+7evVvod6SlpRnmKYuS7mqtfzGKUjDQj1IoFFAoir7IZMGwmzru455b0i5VUeOWtKxAyevQ0uPqX8eyLKulXptHNxwVZR3aKt9lec+Jem1EbyP0GSu4Davo2whZp0P6lgNImr0Kcp4avtNHwntob0iqh+PY0zbiUfayDgvS11zwM5LbiNKPC/B7RHHjFvyMLE+fgcWNq1fethH2/D1Cn7GCy/e4ZTWl6QLsqPFKSEiAWq3GO++8U2ja4MGD0bRpUyxYsADAw3O9goKCDNPj4uKgUqlQu3ZtAA/P5YqNjS3UhV6/fh3BwcFlrvXRv+YVfPxxzzNnWlmey3HFjmvpmor6smLJ32mP49pjTY42rinP1W+/CjZeImqyl3FzcnJw6dIlAA/PD759+zZq1qyJ27dvo06WDhnTVyDvt0uo1LcL/Ka+B6dqVYTXVJ7HfTRf9lATx7XPmswZtzTbLXuq11FrcrRxLVnTo9uvstRUFLtpvBo2bIjNmzcbPXb58mXMmTMHM2bMQFhYGGrXro26devi8OHDeP755w3zxcTEoHXr1obdgu3bt8eKFSsQGxuLNm3aAHjYdF26dAnDhg2z3kIREZFN5eTkGM7t9fX1xcWLF+GhkZE5YzkSf74M50ZBqPH1Mri1bmrjSomIqLyzm8bLy8sLLVsWfSPKxo0bG+4JNnr0aIwbNw516tRBy5YtERMTg/Pnz2PLli2G+Zs3b47w8HBMnDgR48ePh4uLC6KiohASEoIuXbpYZXmIiMh2cnJycPXqVUgKZySlpMGzkgdkrQ6+Jy5AM2kTfNVquE0ahurvvw6JV0ojIiIrcLhPmx49eiAnJwfR0dFYs2YNAgMDsWzZMjRv3txovkWLFmHOnDmYOnUqNBoNwsPDMXny5DJfJtKc3YpEpVXScdFEllARMpacnIyEhATEnj6N+DRnIDMFqv/dRubKGNS/dR8Xn6yLSx0aomPrRsiLj4e3tzd8fX1tXXa5UBHyRbbDfJFoojMmyeZcC/H/qNVqxMXFISMjo8hLKj77bPm60eSFCxcAAGFhYTauhIiIihMTE4OLFy8iLy8PUkY+nj19BfUv30Gyvyd+aReCB9V9IANwdXWFykmJRo0aISIiwtZlExGRgzG1NzBr949Op8OCBQuwbds25ObmFjvf5cuXzRne7pl66Uii0ijqvjdEllQRMpacnIyaNWtC1gHpmw+g6c9/A5Bx5rlGyI1ohfvx93A/xx1VPTXo2Kk9Avz9LHK1W6oY+SLbYb5INGtkzKzGa9WqVVi3bh369++Pp59+Gv/5z38wbtw4eHl5Ydu2bZAkCZ988omla7ULZdhBSPRY+kt9E4lS3jN2+vRp3D16Ck2OnkPIg3RcbVQDf7auj3x3F7g8uA9vLxd07tIBN66eR3D9IB5iaGHlPV9kW8wXiSY6Y2YdyLh3715069YNM2bMQLt27QA8vABGv379sHPnTkiShNOnT1u0UCIiopJo7icjbN8ZPLf1JCr5eCNmwHP4uk04ct1c4VO5Mtq1awc/X1/UruYJlVPR93QhIiISxazG6+7du2jVqhWA/3839fz8fMPPPXv2xP79+y1UIhERUfFkjQapq3chvtXr0Pz4G/wXfgL//Yvh06IBXu3WGlWq+KFZ06Zo0KABnnrqKXh7eyM0NBRubm62Lp2IiCoQsw419PHxQXZ2NgDAw8MDlSpVQnx8vNE86enpZa+OiIioBDk//4nECVHIv3wdXkN6wnfCcCh9vZGcnAyVkxJBtf1w/3ZlhIaGwtfX13BoIQ8xJCIiazOr8WrUqJHhKh4A0LJlS2zatAkNGzaELMvYvHkzQkJCLFYkERFRQZq7iUiasQKZu7+Fy9ONUOvbaLg0/f+fO25ubggNDeXeLSIishtmNV79+vXD3r17kZ+fD2dnZ4wdOxZvvPEGBg4cCFmW4e3tjcjISEvXahckSeLVdEgISZKgUqmYLxKmPGRMVmuQFr0byfPWQ3J1hv/iSHgO6AbpkXuvuLm5GS7vy71b1lEe8kX2i/ki0ayRsTLdx6ugjIwMnDlzBkqlEs2bN4ePj48lhrUrvI8XEZHt5Jz6HQ8io6D+5xa83noZvpHDoPTxtHVZRERUQVnlPl5F8fT0xPPPP2+p4ewa7+NFIsiyDK1WC6VSyXyREI6aMc2d+0icuhxZ+7+Ha4swBHy3Fi5hT9q6LHqEo+aLHAPzRaJZI2NmXdWwc+fO6N+/P+Li4oqc/t1336Fz585lKsxe8T5eJJJOp7N1CVTOOVLG5Hw1UpZsxa3WA5H785+oumwSahxYzqbLjjlSvsjxMF8kmuiMmdV43b59G3/99Rf69u2L7777rtD07Oxs3Llzp8zFERFRxZT9w6+If+5NJH8aDa9BPVD79FZ49n+Rf+kmIiKHZVbjBQATJkzAs88+i9GjR2PRokUWLImIiCoqdcI93H1rMv7t+xGU/pVR6/t1qDL7Ayi9Ktm6NCIiojIx+xwvLy8vrFq1CsuWLcOKFStw6dIlLFiwAJ6ePNGZiIhMI+flI3X5dqQs2gyFVyVUXT0NlV7pzD1cRERUbpi9x0tv1KhRWLVqFc6dO4c+ffrgn3/+sURddotfAkgkJyeLXe+GqEj2mLGs704jvt0QJH++Hl5vv4I6p7fBs/fz3N46IHvMF5UfzBeJJjpjZW68AKB9+/bYvXs33Nzc0K9fPxw7dswSw9otfhkgESRJgkKhYL5IGHvLmPrmHfw7eALuvvYJnGpVRe0fNqDK9PehqORu69LIDPaWLypfmC8SzRoZs0jjBQC1a9fGjh070KVLFxw5csRSw9olXtmQRJBlGTqdjvkiYewlY7qcPCR/vgHx4YOQd+4KAtbORPWvFsE5JNCmdVHZ2Eu+qHxivkg0a2TMrP1pmzdvRv369Qs97uLigs8++wwRERFITk4uc3H2iG94Ekmj0UClUtm6DCrHbJ2xrCM/IXHSYmjuPIDPe/1Reexg7uEqR2ydLyrfmC8STXTGTG68cnJyMHfuXPTt2xevvfZakfM899xzZS6MiIjKD3VcAhInL0H2t7Fw6/Asqm+fD+f6dWxdFhERkdWY3Hi5ubkhISGBx9gSEdFj6bJzkbp4C1KWbYNTVV8EbJgNj+7t+RlCREQVjlnneLVr1w6nTp2ydC1ERFROyLKMzIMnEB8+CCnLtqHyqNdR+6ctqNTjOTZdRERUIZnVeI0cORI3btzAJ598grNnz+LevXtITU0t9F95xC8MJJJCYbHr3RAVyRoZy792C//2H4d7b06Cc0hd1Dm5Gb4ThkHh7ir8d5NtcRtGIjFfJJrojJl1cY3u3bsDAK5evYoDBw4UO9/ly5fNq8rOsfkiESRJ4j1KSCjRGdNl5SBl4SakrtwBpxr+qLZlLty7tOE2s4LgNoxEYr5INGtkzKzR33//fX6QEgkgyzLfWySUiIzJsoysr39A4tRl0CWnovLYwfAZ9ToUbi4W/T1k/7gNI5GYLxJNdMbMarxGjx5t6TochizLfOOTELIsQ61WQ6VSMV8khIiM5V+5gcQJi5Bz4je4vxiOKrNHQ/VEDYuMTY6F2zASifki0ayRMYvsT8vNzQUAuLry+H0ioopAl5mN5PkbkLZ6F1S1q6PatnnweKG1rcsiIiKyW2Y3Xnfu3MHSpUvx448/IiUlBQBQuXJlPPfccxg1ahRq1qxpsSKJiMg+yLKMzL3HkDRtOXRpGfD95G14j+wPhSsPKyQiIiqJWY3XtWvX8PrrryMjIwNt2rRBvXr1AABxcXHYv38/jh8/jm3btiEoKMiixRIRke3kXY5DYmQUcn/+Ex7dn4PfrFFQ1a5m67KIiIgcglmN14IFC6BQKLB3716EhIQYTbty5QrefPNNLFiwAMuXL7dIkUREZDva9EykzFuPtLV7oKpbA9V3LoB7xxa2LouIiMihmNV4/frrr3jrrbcKNV0AEBwcjDfeeAMbN24sa212iSd0kkgqlcrWJVA5Z0rGZFlG5q4jSJq+ErqsHPhOHA6fEf0gOTOnVDRuw0gk5otEE50xsxovjUZT4oU03NzcoNFozC7K3rH5IhGYKxLNlIzlXbz68LDCM+fh0asTqsx8H041qgqsjhwdt2EkEvNFolkjY2bdnrlhw4bYtWsXMjIyCk3LzMzE7t270ahRozIXZ69kWbZ1CVQOybIMjUbDfJEwpcmYNi0DiRMWIaHzUGhT0lD9qyhUWzuDTRc9FrdhJBLzRaJZI2Nm38dr+PDh6NatG3r37o26desCAK5fv469e/ciNTUVU6dOtWSddoNveBJJp9NBqVTaugwqx4rLmKzTIWP7ISTNWgU5Jw9+096D9/A+kFQWuesIVRDchpFIzBeJJjpjZn2itm7dGmvWrMG8efOwZs0ao2kNGzbE559/jlatWlmkQCIiEivv3P/wIDIKeWf/QqVXX4Df9JFwqlbF1mURERGVK2b/KbNNmzbYt28fHjx4gDt37gAAatSoAX9/f4sVR0RE4mhT0pH86Rqkb/oazg0DUWP/Uri1aWbrsoiIiMqlUjdeCxcuREREBBo0aGD0uL+/P5stIiIHIut0yNh2EEmz1wBqDfxmjYb30FcgOfGwQiIiIlFKfXGNNWvW4J9//jH8nJKSgoYNGyI2NlZIYfaKV9UhkXjsOommOXcFd7qNwIOPPof7861RO3YrfN7ty6aLLILbMBKJ+SLRRGesTJ+0FfVCE2y+SARJkvihQsJok1KRNHs1MrYehHOjeqhxYDncWjaxdVlUjnAbRiIxXySaNTLGP3GaQZZlNl9kcbIsG7LFfJGlyFot0jd/jeRPowFZht+nH8JrSE8oeCNSsjBuw0gk5otEs0bG2HiZqKLu5SPr0Gg0wu+aThVH7q8X8SAyCvnnr8Dz9e7wnfQOdD6VeFghCcNtGInEfJFoojNm0qfv7du38ddffwGA4ebJN2/ehJeXV5HzN27cuIzlERGRqTQPUpA8axUyvoyBc5Ng1Dy0Cq7PNIYsy9Cp1bYuj4iIqEKS5FLuwmnQoEGh3W7FHXKnf/zy5cuWqdJOXLhwAbIsIywsjLu5yeJkWYZarYZKpWK+yCyyRoP0DfuQPHcdoFTAd9I78BrYA9L/HbPOjJFIzBeJxHyRaOZk7MKFCwCAsLCwUs1f6j1ec+bMKe2sRERkZTmnzyMxciHyL8XBa9BL8J30DpS+3rYui4iIiP5PqRuvV155RWQdDoN/ZSGRmC8yleZuIpJmrkTmrqNweaohah5dA9dmDYqdnxkjkZgvEon5ItFEZ4xnWJuBb3wSQZIknjRMpSarNUhb9xWSP1sPyUUF/6jx8Hw9ApKi+NszMmMkEvNFIjFfJJo1MlbqGyhbw48//oiBAweiVatWCA0NRefOnTFnzhzDhTz0vv/+e/Ts2RNhYWHo2rUrvvrqq0Jj5efn47PPPkPbtm3RrFkzvPXWW4iLi7PWohARCZPz0x+I7/Q2kqatgGffrqgTu+3huVwlNF1ERERkW3a1xys1NRVNmjTBoEGD4OPjg3/++QdLly7FP//8g/Xr1wMAzp49i1GjRqFPnz6YOHEiTp8+jUmTJsHDwwMvvviiYazZs2cjJiYGkZGRCAgIwKpVq/Dmm2/i4MGD8PT0LFOdvI8XiSDLMjQaDZycnJgvKpLm3wdImrYcmXuPweXZUNT6NhouTYJL/XxmjERivkgk5otEs0bG7Krx6tWrl9HPLVu2hLOzM6ZMmYJ79+4hICAAK1euRJMmTTBz5kwAQKtWrRAfH48lS5YYGq+7d+9i9+7dmDZtGvr06QPg4dVGOnbsiO3bt2P48OFm18j7eJFIzBcVRc5XI3XNLqTM3wiFuyv8l06EZ7+uZu3hYsZIJOaLRGK+SDTRGbP741J8fHwAAGq1Gvn5+Thz5ozRni0AiIiIwLVr15CQkAAAOHXqFHQ6ndF8Pj4+aNu2LU6cOGG12omIyir7xFnEd3gLybNWw+v17qgduxVeA7rxsEIiIiIHY5ef3FqtFnl5efjrr7+wfPlydOrUCbVq1cKtW7egVqsRFBRkNH+9evUAwHAOV1xcHPz8/ODt7V1oPp7nRUSOQHP7Hu4OnYp/Xx0LpZ8Pan2/DlU+/RBK77IdKk1ERES2YVeHGup17NgR9+7dAwC0a9cOCxYsAACkpaUBALy8vIzm1/+sn56enl7keVxeXl6GecqiqN2QkiQVu3tSf5xoSdNFPZfjOs5rI8uy0WP2tqyOsA7Lw7hyXj5SV+1EatRmKCq5w3/FZHj26VLs7zWlJn3G9D/belkrwrj2WJPIcR/djlli3LLWxHHtsyZTxy2YLUeo15FrcrRxLVVTwW1YWcYtiV02XmvWrEFOTg6uXr2KlStXYsSIEdiwYYOtywLwcEWr1Wqjk+4UCgWcnB6uSrVaXeg5zs7OAB7uydPpdEbT9Cfw6XQ6aLVao2n6cWVZLnJc/SUvixpXqVRCqVQaThR8dBn0z9VoNIWCI2rc0iwrUHgdihpXv6ySJJm8rKUZFzBtHRZ8o5uzrPpxi6rJVutQP25J69BW+S5pHVoz38D/30ZkfheL5ElLoLn1LyoN7Q3vjwbDubK3Yf2WdRuhr1mtVsPJyYnbiMeMq19We9lGlHVZrbGN0I9dcFvGbYTxspZlG1GRv0fIsmxYR9xGOO42wp6/R+iXSaPRGN5zj9tGPPrd7XHssvFq0ODhzT+bN2+OsLAw9OrVC99++y3q168PAIUuL5+eng4AhkMLvby8kJmZWWjc9PT0QocfmkP/YhSlpOv/Fwz0oxQKBRTFnLNRMOymjvu45xb8sLTWuCUtK1DyOrT0uPo3S1mW1dKvjb6mirIObZXvsrznLL0O1bf+RdKUpciKOQnX8OaotulTODcItFi93EaYP649biP07G0dSpJU5OcjtxGlHxfg94jHjStJErcRpRzX3rYRxY3ryNsIU5ouwE4br4JCQkKgUqlw69YtdOrUCSqVCnFxcWjXrp1hHv15W/pzv4KCgpCYmIi0tDSjRisuLq7Q+WHmKmpFP27llzRd1HM5rthxLVmTLMvQ6XSGN7K9LasjrENHG1eXm4fU5V8iddEXUFT2RsCa6fB4uZOw7cujGbPUuKZOq0jj2mNNIpf10XzZuiaOa781mTpuUdsvS4xriWm2ei7HtWxNBTNmiZqKYpcX1yjo3LlzUKvVqFWrFpydndGyZUscOXLEaJ6YmBjUq1cPtWrVAgCEh4dDoVDg6NGjhnnS0tJw6tQptG/fvkz1mHM8J1FpPbp7nsqvrKM/I77dEKTM3wjv4X1Q5+ctqPRKZ7M25KZgxkgk5otEYr5INNEZs6s9XqNGjUJoaChCQkLg6uqKv//+G+vWrUNISAief/55AMB7772HwYMHY/r06ejWrRvOnDmDAwcOICoqyjBOtWrV0KdPH8ybNw8KhQIBAQFYvXo1PD09MWDAAFstHhER1DfuIHHSYmQf/Rluzz2D6ts+g/OTT9i6LCIiIhLMrhqvJk2aICYmBmvWrIEsy6hZsyb69u2LoUOHGo4bf+aZZ7B06VIsWrQIu3fvRo0aNTB79mx069bNaKzJkyfDw8MDCxYsQFZWFp566ils2LChyKsdEhGJpsvJQ+qSLUhdug3KKj4IWD8LHj2eE76Hi4iIiOyDJPPYuVK7cOECZFlGWFgYvyyRxemvyqO/ug+VD7IsI/vwKSROXgrN3UT4jByAymMGQeHhZpNamDEShfkikZgvEs2cjF24cAEAEBYWVqr57WqPlyPgm51EKu6qO+SY8q/FI2nSEmQfOw23Ti1RfecCONerbdOamDESifkikZgvEk10xth4mYHNF4kgSRI/VMoJXVYOUhZ9gdQV2+FUrQqqbf4U7i+G23zbwYyRSMwXicR8kWjWyBgbLzOYerM0otIoeLd05ssxybKMrAM/ImnKUmgTU1H5gzfg88FAKNxcbF0aAGaMxGK+SCTmi0SzRsbYeJmIp8SRSBqNpsQb+ZH9yv/nJhInLkbOD7/CvWtbVJk1GqrAmrYuqxBmjERivkgk5otEE50xNl5ERGWgy8xGysJNSF21E041q6La1s/g0aWNrcsiIiIiO8PGi4jIDLIsI2vf90icthy6lDRU/ngIfN5/DQpX+ziskIiIiOwLGy8iIhPl/30dDyYsQu6p3+ER0Q5+s0ZDVae6rcsiIiIiO8bGy0Q8oZNEYr7smy4jC8mfb0Ba9G6o6lRH9e3z4d65pa3LMgkzRiIxXyQS80Wiic4YGy8z8I1PIkiSxJOG7ZQsy8j86lskTVsOXWY2fMcPhc97/SG5ONu6NJMwYyQS80UiMV8kmjUyxsaLiKgEeZeuITEyCrmx5+DxUgf4zRwFVa0AW5dFREREDoaNlxl4Hy8SQZZlaDQaODk5MV92QJuWgZTP1iNt/V6ogmqh+u4ouD/3jK3LKhNmjERivkgk5otEs0bG2HiZiPfxIpGYL9uTdTpk7DyC5JkrocvKhe/kd+DzTl9IzuXjEBdmjERivkgk5otEE50xNl5ERP8n7/yVh4cV/noRlXo/D7/pI+FU3d/WZREREVE5wMaLiCo8bWoGkj+NRvqm/VAFP4Ea+5bArW1zW5dFRERE5QgbLyKqsGSdDhnbYpA0exXkPDX8ZoyE99BXIam4aSQiIiLL4rcLE/GEThLJyYlvSWvJ/fNvJI5fiLzfL6NS3y7wm/oenKpVsXVZwjFjJBLzRSIxXySa6IwxwWZg80UiSJLEbFmBNjkNyf9dg/QvvoFzoyDU+HoZ3Fo3tXVZVsGMkUjMF4nEfJFo1sgYGy8z8HLyJIIsy9DpdFAoFMyXALJWi/QtB5D83zWAVocq//0AXm+9DKkC/QWVGSORmC8Sifki0ayRsYrzjcNCeClTEkmr1UKhUNi6jHIn97e/kDg+Cnnn/gfPAd3gO2UEnKr62rosm2DGSCTmi0Rivkg00Rlj40VE5ZY2MQVJs1YjY9tBOIc9iZoxK+H6bKityyIiIqIKiI0XEZU7slaL9I37kTwnGpAkVJn3EbwG94SkVNq6NCIiIqqg2HgRUbmSc+Y8EiMXIf+vq/Ac2AN+k96B0s/H1mURERFRBcfGy0Q8oZNE4rHr5tPcT0bSjJXI3HkYLs0boubhVXB9qpGty7I7zBiJxHyRSMwXiSY6Y2y8zMDmi0SQJIn3KDGDrNEgbd1epHy2DlA5wX/hJ/B8owckfkAXwoyRSMwXicR8kWjWyBgTbAZeTp5EKHjFTOardHJ+/hOJkVHI//s6vIb0hO+E4VD6etu6LLvFjJFIzBeJxHyRaNbIGBsvE/Fy8iSSWq2GSqWydRl2T3M3EUnTVyDzq2/h8nQj1Po2Gi5NQ2xdlkNgxkgk5otEYr5INNEZY+NFRA5DVmuQFr0byfPWQ3Jzgf/iSHgO6MbDComIiMjusfEiIoeQffI3JEZGQX01Hl5vvQzfyGFQ+njauiwiIiKiUmHjRUR2TXPnPhKnLkfW/u/h2rIJAo5Nh0tofVuXRURERGQSNl5EZJfkfDVSV+1EyoJNUHi4oerySajUtytPqiYiIiKHxMbLRJIk8YsfCSFJEpydnW1dhl3IPv4LEicsgvrGHXgP643K/3kbSq9Kti7L4TFjJBLzRSIxXySaNTLGxouI7IY64R6SJi9F1sEf4dqmGQI2zIZLwyBbl0VERERUZmy8zMD7eJEIsixDq9VCqVRWuHzJeflIXb4dKYs2Q+FVCVVXT0OlVzpXuPUgWkXOGInHfJFIzBeJZo2MsfEyEe/jRSLpdDoolUpbl2FVWd/GImnSEqjj/4X3u33hO+4tKCq527qscqsiZoysh/kikZgvEk10xth4EZFNqG/eQeLkpcg+fApu7Z5CtS8+hXNIoK3LIiIiIhKCjRcRWZUuJw+py7YhdckWKHx9ELB2Jjx6duChI0RERFSusfEiIqvJOvITEicthubOA/i81x+Vxw7mYYVERERUIbDxMhH/Kk8iOTmVz7ekOi4BiZOXIPvbWLh1eBbVt8+Hc/06ti6rQiqvGSP7wHyRSMwXiSY6Y0ywGdh8kQjl8R5xuuxcpC7egpRl2+BU1RcBG/8Lj4h25W45HUV5zBjZD+aLRGK+SDRrZIyNlxl4OXkSQZZl6HQ6KBQKh8+XLMvIijmJpClLobmXhMqjXofPhwOhcHe1dWkVWnnKGNkf5otEYr5INGtkjI2XiXg5eRJJq9VCoVDYuowyyb92C4mRi5Dzw69wf6E1auyOgiqolq3Lov9THjJG9ov5IpGYLxJNdMbYeBGRReiycpCycBNSV+6AUw1/VNsyFx5d29q6LCIiIiK7wMaLiMpElmVk7T+OxGnLoUtOReWxg+Ez6nUo3FxsXRoRERGR3bCr/bWHDh3Ce++9h/bt26NZs2bo1asXdu/eXejwvl27dqFr164ICwtDz549cfz48UJjZWRkYOLEiWjRogWaN2+ODz74APfv37fWohBVCPlXbuDfPmNxb/g0uDQJRu1TX8D3k7fYdBERERE9wq4ar40bN8LNzQ2RkZFYuXIl2rdvjylTpmD58uWGeQ4ePIgpU6agW7duiI6ORrNmzTBq1Cj8+eefRmONGTMGP/30E6ZPn4758+fj+vXrGD58ODQaTZlq5AmdJJKjHLuuy8xG4vTliH/uTWji76Hatnmo/sUcqJ6oYevS6DEcJWPkmJgvEon5ItFEZ0yS7ehqEcnJyfD19TV6bMqUKYiJicGvv/4KhUKBrl27IjQ0FAsWLDDMM2DAAHh6eiI6OhoA8Mcff2DAgAFYt24dwsPDAQBxcXGIiIjAwoULERERYVZ9Fy5cAACEhYWZ9XwiRyfLMjL3HkPS1GXQpWei8pjB8B7ZHwpX7uEiIiKiisXU3sCu/nTwaNMFAA0bNkRmZiays7MRHx+PGzduoFu3bkbzREREIDY2Fvn5+QCAEydOwMvLC23b/v8T+4OCgtCwYUOcOHFC7EIQlYEd/R2kkLzLcbjz8ge4/+4MuD4bito/bUHljwaz6XIw9pwxcnzMF4nEfJFoojNm9xfX+O233xAQEIBKlSrht99+AwAEBgYazVOvXj2o1WrEx8ejXr16iIuLQ2BgYKHDAoOCghAXF1ememRZ5n28SAhZlqFWq6FSqWySr5ycHFy6dAn5+flwdnZGYGAgbt++jaCq1ZGzdBvS1u6BKrAmqu9cAPeOLaxeH5WdrTNG5RvzRSIxXySaNTJm143X2bNnERMTg/HjxwMA0tLSAABeXl5G8+l/1k9PT0+Hp6dnofG8vb1x8eLFMtdVVDcsSVKxXbL+xStpuqjnclzHeW30TX3Bny0xbmnrzcnJwcWLFw2Nl4+PD/5dvxseh38HsvPgO2EYvEf0g+SsMhrDntZhRR23tM/VZ0z/syMuq6ONa481iRz30e2YJcYta00c1z5rMnXcgtlyhHoduSZHG9dSNRXchpVl3JLYbeN19+5djB07Fi1btsTgwYNtXY4RtVpt1AkrFAo4OTkZpj3K2dkZwMObsul0OqNpTk5OkCQJOp0OWq3WaJp+XH0H/iiVSlXsuEqlEkqlErIsF7qgiCRJhudqNJpCwRE1bmmWFSi8DkWNq19WSZJMXtbSjAuYtg5lWTaq39Rl1Y9bVE3FrcOcnBycP38eSUlJCAkJQXp6BnSQ4PFvKnLXzUS9y3FQdmuLmnM/grK6/8NxHxm7pHWor7ekdWirfJe0Dq2Zb8B624iCy+Xk5MRtxGPG1S+rvWwjyrqs5mwjSjNuwWXV11vwM5LbCONltedthKWWVcS4BRsvbiMcdxth6jq05jZC/29JkgzvucdtIwo2aaVhl41Xeno6hg8fDh8fHyxdutRwhRFvb28ADy8V7+/vbzR/weleXl64e/duoXHT0tIM85RFSbsg9S9GUQoG+lEKhaLYK6kUDLup4z7uufo3gjXHLWlZgZLXoaXH1b+OZVlWS702RW3EimOpdZiRkYG//voLKSkpyM7JRfq/dxEWG4eGf8UjtbIXTrzSGsGvdYMuLwteycoiz8Ms6zq0Vb7L8p4T9dqI3kboM1ZwG8ZtRMnj2tM24lH2uA6dnJwKfUZyG1H6cQF+jyhu3IJfrrmNKN249riNELEOLZVv/WdkweV73LKa0nQBdth45ebm4t1330VGRgZ27NhhdMhgUFAQgIdXKNT/W/+zSqVC7dq1DfPFxsYW6kKvX7+O4ODgMtcoSVKRK/pxK7+k6aKey3HFjmvpmor6smLJ31nU78jIyEB+Xh50+4/j5Z//gVKjw++tn8T/mtaGTqFA4qmT+OM3VzRq1KjEK4LayzqsiOOa8lz99qtg4yWiJo5rvzWJHPfRfNlDTRzXPmsyZ9zSbLfsqV5HrcnRxrVkTY9uv8pSU1Hs6qqGGo0GY8aMQVxcHNauXYuAgACj6bVr10bdunVx+PBho8djYmLQunVrw27B9u3bIy0tDbGxsYZ5rl+/jkuXLqF9+/ZlqtGclUxUWiX9xcaSkpOTce7cOcSe/gXONx6gy+6zaH3sEu7U9sPuAW1w8alAZCl9ISvd0LZdO7z66qto1aqVVWojsayVMaqYmC8Sifki0URnzK72eM2YMQPHjx9HZGQkMjMzjW6K3KhRIzg7O2P06NEYN24c6tSpg5YtWyImJgbnz5/Hli1bDPM2b94c4eHhmDhxIsaPHw8XFxdERUUhJCQEXbp0KXOdbL5IBGvm6vTp0/gr9gxCT/0P3S/eRqpfJRx55Wk8qFkZAOAEHZ6oXRnOKgWaNQkr8hBDcjzcdpFIzBeJxHyRaNbImF01Xj/99BMAYO7cuYWmHTt2DLVq1UKPHj2Qk5OD6OhorFmzBoGBgVi2bBmaN29uNP+iRYswZ84cTJ06FRqNBuHh4Zg8eXKJx2qWlqkn0hGVhv7iGkqlUmi+ZK0WzW+mIXjbGejUGvzariEuN64OjcoHLnIG3N3d4ObmhmefbopLly4Jq4Osz1oZo4qJ+SKRmC8SzRoZk2RzroVYQV24cAGyLCMsLIxverI4/YnDIu8fkfv7JSSOj0Len3/Ds/+LUIwegD0/HkNiUjIaN22FhOuX0KBBCHx8fAz38apfvz7c3NyE1EPWZY2MUcXFfJFIzBeJZk7GLly4AAAICwsr1fx2tceLiMTQJqUiafZqZGw9COfG9VHjwHK4tWyC5OTkh5djVSoQWMsX2WmV0bx5c8OhhTzEkIiIiMgy2HgRlWOyVov0zV8j+dNoQJZRZc4YeL3ZC9L/XVbVzc0NjRs3xoMHD1ClShWEhoZy7xYRERGRAGy8iMqp3F8v4sH4hci/8A883+gOv8nvQlmlstE8bm5uaN26teHnGjVqWLtMIiIiogqBjZeJeFwxiVTcDf5MoXmQguSZK5Gx/RBcmoag5uFVcH26sQWqo/LAEhkjKg7zRSIxXySa6Iyx8TIDmy8SQZKkMr3hZY0G6Rv2IXnuOkCpQJX54+A1sIfhsEKismaMqCTMF4nEfJFo1sgYGy8z8HLyJIIsy4ZsmZqvnNhzSJwQhfxLcfAa9BJ8J70Dpa+3oErJUZUlY0SPw3yRSMwXiWaNjLHxMhGvvk8iaTQak+6arrmbiKSZK5G56yhcnmqImkfXwLVZA4EVkqMzNWNEpmC+SCTmi0QTnTE2XkQOSFZrkLZ2N5LnbYDkooJ/1Hh4vh4BSaGwdWlEREREVAQ2XkQOJuenP/AgMgrqKzfh9ebL8I0cCmVlL1uXRUREREQlYONF5CA0/z5A0rTlyNx7DK7PhiLg22i4NAm2dVlEREREVApsvEzEEzpJpKLyJeerkbpmF1Lmb4TC3RX+SyfCs19XHlZIZuE2jERivkgk5otEE50xNl5m4BufRJAkqdAJndk/nkXihEVQxyXAe2hvVP7PW1B6e9qoQnJ0RWWMyFKYLxKJ+SLRrJExNl5Edkhz+x4SpyxD1jc/wLVVUwRET4dL4/q2LouIiIiIzMTGywy8jxeJIMsy1FnZyFy7B6lRm6Go5I6qK6eg0qsvMG9kEbIsQ6PRwMnJiZkii2O+SCTmi0SzRsbYeJmI9/EiUbK/P4PECYuguXUX3u/0ge8nb0Hh6WHrsqic4TaMRGK+SCTmi0QTnTE2XkQ2pr71L5KmLEVWzEm4tGmGaps+hUvDIFuXRUREREQWxMaLyEZ0uXlIXbYNqYu3QFHZG1XXTINzRDs4OzvbujQiIiIisjA2XkQ2kHX0JyROWgLN7fvwGdEPlT8aAsnDDWq12talEREREZEAbLxMxBM6qSzUN+4gcdJiZB/9GW4dnkX1bfPg/OQTAB4eV8xL5ZJozBiJxHyRSMwXicbLydshNl9kKl1OHlKXbEHq0m1QVvFBwPpZ8OjxnFGWmCsSjRkjkZgvEon5ItGskTE2Xmbg5eSptGRZRvahk0icsgyau4nwef81VP5wIBQebkXOq9VqoVQqmS8SghkjkZgvEon5ItGskTE2XibipUyptPKvxSNx4mLkfH8G7p1bofrOBXCuV7vE5+h0OiiVSitVSBURM0YiMV8kEvNFoonOGBsvIgvTZeUgZdEXSF2xHU7VqqDa5k/h/mI4/0JHREREVIGx8SKyEFmWkfXND0iaugzaxFRU/uAN+HwwEAo3F1uXRkREREQ2xsaLyALy/7mJxAmLkPPjWbh3bYsqs0ZDFVjT1mURERERkZ1g42UiHi5GBekys5GyYCNSV+2EU60AVNv6GTy6tDF7PB67TqIxYyQS80UiMV8kmuiMsfEyA5svkmUZmfuOIWnqcuhS01F53Jvwef81KFzNP6xQkiR+qJBQzBiJxHyRSMwXiWaNjLHxMgMvJ1+x5f99HQ8mLELuqd/h0b09/GaOgqpO9TKPK8uyIVvMF4nAjJFIzBeJxHyRaNbIGBsvE/Fy8hWXLiMLyZ9vQFr0bqjqVEf1HfPh3qmlRX+HRqMRftd0qtiYMRKJ+SKRmC8STXTG2HgRPYYsy8jcfRRJ01dAl5kN38hh8BnRD5KL8/9r797joqzz/o+/BxhQURDUNE8rWJKmBZXnQ6lli7rar9XtZFZrppaa+vNOMjU128y7zVO25WEry93KsoMreWtlaGq7WbSm7aaBGuZ6QJEBEYGZ6/7DH/MTATl+uWbw9Xw8fDzkmmu+1+ca3vOd+TDXdY3dpQEAAMBP0HgBl3Bu709KT1ik3K/+qdAhfdV47mMKatHU7rIAAADgZ2i8gBK4M7OU8fyflfnnD+SMbqkr31uoejffZHdZAAAA8FM0XhXECZ21m+XxKOudjTr1zCvynMlV5IxH1PCR4XIE18wx5eQLppExmES+YBL5gmmmM0bjVQk88Wunc7v36UTCQp37eo/q33mrGs1+VEFXNqmx7TscDk4ahlFkDCaRL5hEvmBaTWSMxguXPXeGS6eeWynXGx/J2e5Xav7hEtXtGWd3WQAAAKhFaLwqge/xqh0sj0dZazbo5LOvyjqXr0ZzHlX4qN/K4bTnaWFZlgoKChQUFES+YAQZg0nkCyaRL5hWExmj8aogvserdsj97t9Kn/aizn37L9X/3e1qNGucgpo2srss8gXjyBhMIl8wiXzBNNMZo/HCZcV9KlOnnl0u15vrFdwhWs3XL1PdbtfZXRYAAABqORovXBYst1uuN9fr1B9WSG6PGv/hcYU9OFSOIJ4CAAAAMI93naj1cnftVXrCQp37549qcM9ARc4cq6AmEXaXBQAAgMsIjVcFcUKn/3CnZ+jkM68q6y8bFHxdO7VI/JPqdO5od1mXFMQncDCMjMEk8gWTyBdMM50xElwJNF++zSookOv1j3Rq/krJ4VDjBVMUNnKIHIGBdpd2SQ6Hg2zBKDIGk8gXTCJfMK0mMkbjVQlcTt53nf37bqVPW6i8H1LUYMRgNXrqEQU2amh3WeViWZY8Ho8CAgLIF4wgYzCJfMEk8gXTaiJjNF4VxKVMfVPBsZM6OfcVZb+7USFx7dVi4yuqc0MHu8uqMLfbrYCAALvLQC1GxmAS+YJJ5Aummc6YT6X30KFDmjVrloYOHaoOHTpo8ODBJa63du1a3X777erUqZOGDBmiLVu2FFsnKytL06dPV5cuXRQXF6eJEyfq+PHjpncBNcwqKNDpV95VWvf7lPPpTjV58b/8tukCAABA7eVTjdf+/fuVlJSkX/3qV2rbtm2J62zYsEEzZ85UfHy8VqxYodjYWI0fP17fffddkfUmTZqk7du3a/bs2XrhhRd04MABjR49WgUFBTWwJ6gJZ3d8p8P9RunkrJdUf9htav3VXxR2/xA5+GsYAAAAfIxPHWrYr18/3XrrrZKkhIQE7dmzp9g6S5Ys0aBBgzRp0iRJUrdu3bRv3z4tW7ZMK1askCQlJyfryy+/1KpVq9SrVy9JUlRUlAYOHKhNmzZp4MCBNbNDMKLgaLpOzn5Z2e9vVshN16rl5hUKuT7G7rIAAACAUvnURwNlHVOZlpamgwcPKj4+vsjygQMHaufOncrLy5Mkbd26VWFhYerZs6d3nejoaLVv315bt26tUo2c0GkfK79Ap19+Wz93u1c5SV+ryeIEtdjwcq1qujh2HaaRMZhEvmAS+YJppjPmU594lSU1NVXS+U+vLtS2bVvl5+crLS1Nbdu2VWpqqqKiooo1SdHR0d4xqoLmq+blbPtG6QkLlf9TmsJ//38UkTBKgeEN7C6rWjkcDr6jBEaRMZhEvmAS+YJpNZExv0pwZmamJCksLKzI8sKfC293uVxq0KD4m/Lw8PASD1+sKI/HU6z5cjgcpV7xsHDdS91u6r7+Pm7BkeM6+fQynfloi+p0vU5XfPq0QjpeVWwbdtVblftefFvhz4XfI+Hrv5vqGtcXa/K3cct734ufM/64r/42ri/WZGpcj8dTbKzqGLcq92Vc362pouNe+BpZGl+q159r8rdxq6umC/9f+MlXZca9FL9qvHyBZVnKz88v8sQPCAjwdsj5+fnF7hMcHCzp/CUqL3xhks5/Q3bhC5bb7S5yW+G4hdu8mNPpLHXcwMBABQYGyrKsYhcUcTgc3vsWFBQUC46pccuzr9L5x9DKy1fW8vfkWvSWHPXr6oplT6n+8NtVUFBQ7LGoyLgXczqdcjgcFd7X8owrVewxtCxLbrdbdevWlVTxx7Bw3JJqqs7fTUn7WtpjWDjupR5Du/J9qcfQdL4vVlNzROF+BQUFKSgoyK/niJoYt3BffWWOqOq+1sQccfbsWe+6F+4rc4R/zBHVta8mxrUsS5ZlKSQkhDnCj+cIX34fUfh/p9Ppfc6VNUdYVsW+29evGq/w8HBJ5y8V36RJE+9yl8tV5PawsDAdPXq02P0zMzO961RFYUBKu600Fwb6YgEBAaUeV3ph2Cs6bln3vdRHqqbGvdS+SlL+l8k6OX2x8g8eUdjDdyryvx7yHlZYlXFLqrfw91iVfa2u301Jk1hpKrOvpsat6mNoV76r8pwz9bsxPUcUZuzCOcwf5wh/yndp4xaqbY9hUFBQsddI5ojyjyvxPqK0cS98c80cUb5xfXGO8OX3EYWvkRfuX1n7WpGmS/Kzxis6OlrS+XO9Cv9f+LPT6VSrVq286+3cubNYF3rgwAG1a9euynU4HI4SH+iyHvyyPh43cV9/Gjc/7ahOznxJZzYkqU6PWDV9bZ5C2keX67521GuippLerFTnNn1xXF+syd/Grch9C+evCxsvEzUxru/WZHLci/PlCzUxrm/WVJlxyzNv+VK9/lqTv41bnTVdPH9VpaaS+NXlYVq1aqU2bdpo48aNRZYnJiaqe/fu3o8F+/Tpo8zMTO3cudO7zoEDB/TDDz+oT58+NVozyubJPaeMP76htJ4jlPvNXl3x6tNq/uGSYk0XAAAA4K986hOvs2fPKikpSZL0yy+/KDs729tkdenSRZGRkZowYYKmTp2q1q1bq2vXrkpMTNTu3bv11ltveceJi4tTr169NH36dE2bNk0hISFauHChYmJiNGDAgCrVWJnuFqU7s3mn0qcvVsHho2o49neK+L8PKqB+PbvLsg35gmlkDCaRL5hEvmCa6Yw5rMpcksOQw4cPq3///iXetnr1anXt2lWStHbtWq1YsUJHjhxRVFSUpkyZor59+xZZPysrS88995w2b96sgoIC9erVSzNmzFDTpk0rXd/3338vSerUqVOlx8B5+YeOKH3GUuVs/FJ1+9yoxs9NUnC7NnaXBQAAAJRLRXsDn2q8fB2NV9V5zp7T6Zf+otNL3lJAZEM1njteoUNu4a9YAAAA8CsV7Q186lBDf1HRS0fi/GOW8z/blT5jiQqOnFDDR+9WxOSRCgita3dpPuPCS32TL5hAxmAS+YJJ5Aum1UTGaLwqiA8IKy4/9bDSn1qsnE+/Ut2+XXTlOy8ouG1ru8vySeQLppExmES+YBL5gmmmM0bjBWM8ObnKWPSmTi/7q4KuiFTT159V6MDe/KUKAAAAlx0aL1Q7y7J0ZsNWnZy5VAXHTyli/L1q+PgIBdSrY3dpAAAAgC1ovFCt8n76WelPLtLZL75Wvdu6q/n7i+SMbml3WQAAAICtaLwqiMPkSubJzlHGi6t1+pV3FNS8iZq9NV+ht/e0uyy/ExTEUxJmkTGYRL5gEvmCaaYzRoIrgebr/7MsS2c+2qL0p5fJc+q0IqaMVMPH7lVA3RC7S/M7DoeDbMEoMgaTyBdMIl8wrSYyRuNVCVxO/ry8fQeVnrBQZ7d9q3rxvdT4mQly/qq53WX5Lcuy5PF4FBAQQL5gBBmDSeQLJpEvmFYTGaPxqiAuZXr+sMJTL7ymzFfXytnqSjX7638r9NZudpdVK7jdbgUEBNhdBmoxMgaTyBdMIl8wzXTGaLxQbpZlKXvdpzr59DJ5XNmKfOL3avjo3XKEBNtdGgAAAODTaLxQLuf+lar0hIXK3fGdQgffrEbPTJCzZVO7ywIAAAD8Ao0XLsntylbG839W5qp1cka10JVrX1S9WzrbXRYAAADgV2i8KuhyOaHTsixlv/s/OjnnT/KcOavIp0ar4ZjfyRHstLu0Wo1j12EaGYNJ5AsmkS+YZjpjNF6VUNubr3Pf7z9/WOE/vlf9O/qp0ZzHFNT8CrvLqvUcDgffUQKjyBhMIl8wiXzBtJrIGAmuhNp6OXn36Sydem6lXK9/KOfVrXXlukWq1/tGu8u6bFx4xczamC/Yj4zBJPIFk8gXTKuJjNF4VVBtvJy85fEo66+f6OS8V2Tl5qnR7HEKf3iYHE7iUdPy8/PldHI4J8whYzCJfMEk8gXTTGeMd9aXuXP//FEnpr2oc9/8oPrDblOjpx9VULPGdpcFAAAA1Co0Xpcpd4ZLp/6wXK43PlZw+yg1/2ip6vaItbssAAAAoFai8brMWG63stZs0Mlnl0v5BWo0b6LCf3+HHJywCgAAABjDu+3LSO63Pyh92kKd++7fanDXrxU5a5yCroi0uywAAACg1qPxqiCHw+F3V9Nxp2fo5LPLlbVmg4KvvUotNrysOl062V0WLuJwOOR0Ov0uX/AfZAwmkS+YRL5gWk1kjMarFrPcbrne+FinnlshWZYaz5+ssAeGyBEYaHdpKAUvKDCNjMEk8gWTyBdMM50xGq9K8Ifv8cr9eo9OTHtRed/vV4P7BqnRjDEKbBxhd1m4BMuy5Ha7FRgY6PP5gn8iYzCJfMEk8gXTaiJjNF4V5Ovf41Vw/JROzf2Tst7ZqJDrY9Ri4yuqc+O1dpeFcvJ4PArkE0kYRMZgEvmCSeQLppnOGI1XLWEVFCjzzx8q4/lVUmCAGr8wVWEjBnNYIQAAAOADaLxqgbM7vlP6kwuV968DChs5RJHTRyswMtzusgAAAAD8PzRefqzgaLpOznlZ2e9tVsiNHdRi03LVib3G7rIAAAAAXITGq4J84YROK79AmSvf06kFr8kR4lSTRQlqcE+8HAEBdpeGKuLYdZhGxmAS+YJJ5Aummc4YjVcl2Nl8nd2erBMJC5W/75DCHrxDkU8+rMCGDWyrB9XH4XDwogKjyBhMIl8wiXzBtJrIGI1XJdhxOfmC/5zQyaeXKfuDz1Snc0c1/XSlQjpdXaM1wCzLsrzZ8oVPVlH7kDGYRL5gEvmCaTWRMRqvCqrpy8lbefk6/eq7ynjhDQWE1tEVLz2l+r+7nUmnliooKJDT6bS7DNRiZAwmkS+YRL5gmumM0Xj5sJykXUp/cpHyUw8rfNSdinjiIQWGc1ghAAAA4G9ovHxQ/uFjOjlzqc78LUl1ul2vpitmK+Taq+wuCwAAAEAl0Xj5EOtcnk6//LYyFr2pgPr1dMWfZqr+b2/jsEIAAADAz9F4VZCpJijns78rffoi5f/8H4U/MlyRUx9UQINQI9uC7wrgKwFgGBmDSeQLJpEvmGY6YzRelVCdzVf+z/9R+owlyvnkS9XpdYOarf6DgmOiqm18+A+Hw6GgIJ6SMIeMwSTyBZPIF0yriYyRYJt4cs/p9Et/0enFbykgIlxNV8xR6NC+HFYIAAAA1EI0XhV04TX+K+vMpu1Kf2qJCn45roZj71LElJEKqF+vGquEP7IsS/n5+XI6nTTgMIKMwSTyBZPIF0yriYzReNWg/AO/nD+scNMO1b2ls678638r+KrWdpcFAAAAwDAarxrgycnV6SVv6fRLf1Vg44Zq+to8hQ7qw19sAAAAgMsEjZdBlmUp55NtSp+xVAXHTqrhY/co4vERCgita3dpAAAAAGoQjZcheSk/K336Ep39/O+q17+brlz7ooLbtrK7LAAAAAA2oPGqoLIOD/ScOauMhat1+k/vKKhZYzVb/QfV+3UvDitEuTidTrtLQC1HxmAS+YJJ5Aummc5YrW68UlJSNG/ePCUnJys0NFRDhw7VpEmTFBwcXKVxS2qiLMvSmfVf6OSsl+ROP62Ix0eo4YT7FFA3pErbwuWD5hymkTGYRL5gEvmCaTWRsVrbeGVmZuqBBx5QmzZttHTpUh07dkzz589Xbm6uZs2aVaWxL76cfN7+Q0p/cpHOJu1Svdt7qvG8iXK2aV7VXcBlxrIsud1uBQYG8gIDI8gYTCJfMIl8wbSayFitbbzefvttnTlzRi+99JIaNmwoSXK73ZozZ47GjBmjpk2bVmpcy7K8//dk5yjjj6/r9CvvKqhlMzVb87xCB/SojvJxmfJ4PAoMDLS7DNRiZAwmkS+YRL5gmumMBRgb2WZbt25V9+7dvU2XJMXHx8vj8Wj79u1VGtuyLGV98Kl+7n6fMletU+TUh9Rq2xs0XQAAAABKVGs/8UpNTdVvf/vbIsvCwsLUpEkTpaamVnpcx8Ej+s/TK5X7ZbJCB/VRo2cmyNmqWVXLBQAAAFCL1drGy+VyKSwsrNjy8PBwZWZmVmrM/Px8hY1+TjnNGyvv+fHK6dxBJ06fkE6fqGq5gKTi5w8C1Y2MwSTyBZPIF0yraMby8vIqtH6tbbxMcDgccn2ykMuZwhheUGAaGYNJ5AsmkS+YVtGMORwOGi/p/GGFWVlZxZZnZmYqPDy8UmPGxcVVtSwAAAAAl6Fae3GN6OjoYudyZWVl6cSJE4qOjrapKgAAAACXo1rbePXp00c7duyQy+XyLtu4caMCAgLUs2dPGysDAAAAcLlxWBd+MVUtkpmZqUGDBikqKkpjxozxfoHyb37zmyp/gTIAAAAAVEStbbwkKSUlRc8884ySk5MVGhqqoUOHavLkyQoODra7NAAAAACXkVrdeAEAAACAL6i153gBAAAAgK+g8QIAAAAAw2i8AAAAAMAwGi8AAAAAMIzGCwAAAAAMo/ECAAAAAMNovAAAAADAMBqvckhJSdFDDz2k2NhY9ezZUwsWLFBeXp7dZcEPrVu3TjExMcX+vfDCC0XWW7t2rW6//XZ16tRJQ4YM0ZYtW2yqGL7s0KFDmjVrloYOHaoOHTpo8ODBJa5XnjxlZWVp+vTp6tKli+Li4jRx4kQdP37c9C7Ah5UnX/fff3+Jc1pKSkqR9cgXLvbJJ59o3Lhx6tOnj2JjYzV06FC99957uvjrZZm/UBnlyZcd81dQlfbqMpCZmakHHnhAbdq00dKlS3Xs2DHNnz9fubm5mjVrlt3lwU+tXLlSDRo08P7ctGlT7/83bNigmTNnauzYserWrZsSExM1fvx4rVmzRrGxsTZUC1+1f/9+JSUl6frrr5fH4yn2hkUqf54mTZqkn376SbNnz1ZISIgWLVqk0aNH6/3331dQEC8Vl6Py5EuSbrjhBk2bNq3IspYtWxb5mXzhYq+//rpatGihhIQERUREaMeOHZo5c6aOHj2q8ePHS2L+QuWVJ1+SDfOXhUt65ZVXrNjYWCsjI8O77O2337bat29vHT161L7C4Jfef/99q127dtbJkydLXWfAgAHWlClTiiy76667rIcffth0efAzbrfb+/9p06ZZgwYNKrZOefL07bffWu3atbO2bdvmXZaSkmLFxMRYGzZsMFA5/EF58jVixAjrkUceueQ45AslKel1cMaMGdYNN9zgzR7zFyqrPPmyY/7iUMMybN26Vd27d1fDhg29y+Lj4+XxeLR9+3b7CkOtlJaWpoMHDyo+Pr7I8oEDB2rnzp0c4ooiAgIuPYWXN09bt25VWFiYevbs6V0nOjpa7du319atW6u/cPiFsvJVXuQLJYmMjCy2rH379srOzlZOTg7zF6qkrHyVV3Xni8arDKmpqYqOji6yLCwsTE2aNFFqaqpNVcHfDR48WO3bt1f//v316quvyu12S5I3U1FRUUXWb9u2rfLz85WWllbjtcJ/lTdPqampioqKksPhKLJedHQ08xzK9I9//EOxsbHq1KmTRowYoa+//rrI7eQL5fXNN9+oadOmql+/PvMXqt2F+SpU0/MXB76WweVyKSwsrNjy8PBwZWZm2lAR/FmTJk00YcIEXX/99XI4HPr888+1aNEiHTt2TLNmzfJm6uLMFf5M5lAR5c2Ty+Uqcs5hofDwcO3Zs8dwlfBnnTt31tChQ9WmTRsdP35cq1at0kMPPaQ333xTcXFxksgXymfXrl1KTEz0nm/D/IXqdHG+JHvmLxovoAb17t1bvXv39v7cq1cvhYSE6I033tDYsWNtrAwAKm7ixIlFfr7llls0ePBgvfzyy1qxYoVNVcHfHD16VJMnT1bXrl01cuRIu8tBLVNavuyYvzjUsAxhYWHKysoqtjwzM1Ph4eE2VITaJj4+Xm63W//617+8mbo4cy6XS5LIHCqkvHkKCwtTdnZ2sfszz6Gi6tWrp5tvvll79+71LiNfuBSXy6XRo0erYcOGWrp0qffcQuYvVIfS8lWSmpi/aLzKUNIxnFlZWTpx4kSxc7+AqirM1MWZS01NldPpVKtWrewoC36qvHmKjo7WgQMHil0u/MCBA8xzqDLyhdLk5uZqzJgxysrKKvY1K8xfqKpL5au8qjtfNF5l6NOnj3bs2OH9C4skbdy4UQEBAUWucAJUVmJiogIDA9WhQwe1atVKbdq00caNG4ut0717dwUHB9tUJfxRefPUp08fZWZmaufOnd51Dhw4oB9++EF9+vSp0Zrh33JycvTFF1+oU6dO3mXkCyUpKCjQpEmTlJqaqpUrVxb5PkuJ+QtVU1a+SlIT8xfneJXh7rvv1ptvvqnHHntMY8aM0bFjx7RgwQLdfffd5folAhcaNWqUunbtqpiYGEnSZ599pnfffVcjR45UkyZNJEkTJkzQ1KlT1bp1a3Xt2lWJiYnavXu33nrrLTtLhw86e/askpKSJEm//PKLsrOzvW9SunTposjIyHLlKS4uTr169dL06dM1bdo0hYSEaOHChYqJidGAAQNs2TfYr6x8Fb6hue2229SiRQsdP35cr732mk6cOKHFixd7xyFfKMmcOXO0ZcsWJSQkKDs7W9999533tg4dOig4OJj5C5VWVr52795ty/zlsC7+7AzFpKSk6JlnnlFycrJCQ0M1dOhQTZ48mU8fUGHz5s3Ttm3bdPToUXk8HrVp00bDhw/X/fffX+RSpWvXrtWKFSt05MgRRUVFacqUKerbt6+NlcMXHT58WP379y/xttWrV6tr166SypenrKwsPffcc9q8ebMKCgrUq1cvzZgxgz8wXcbKylezZs00d+5c/fjjjzp9+rTq1q2ruLg4jR8/Xtddd12R9ckXLtavXz/98ssvJd722WefqWXLlpKYv1A5ZeXL7XbbMn/ReAEAAACAYZzjBQAAAACG0XgBAAAAgGE0XgAAAABgGI0XAAAAABhG4wUAAAAAhtF4AQAAAIBhNF4AAAAAYBiNFwAAJThz5oy6d++ujz/+2O5SvDIyMhQbG6ukpCS7SwEAVBCNFwDA76xZs0YxMTEaPny4sW2sXr1aoaGhGjRokLFtVFRERISGDRumxYsX210KAKCCaLwAAH5n/fr1cjqd2r17tw4dOlTt4+fn52v16tUaPny4AgMDq338qrjnnnu0d+9e7dy50+5SAAAVQOMFAPAraWlpSk5O1rhx4+R0OrV+/fpq38YXX3yhU6dOKT4+vtrHrqq2bduqXbt2+uCDD+wuBQBQATReAAC/sn79egUGBuquu+5Sjx49Smy8lixZomuuuabYp0IzZ85Ux44d9e9///uS2/j000/VokULtW7dusjyhIQExcXF6ciRIxozZozi4uLUu3dvrVmzRpL0448/auTIkYqNjVXfvn2L1bZu3TrFxMRo165dmjdvnrp166abbrpJs2bNUl5enlwul5544gl17txZnTt31oIFC2RZVrH6evTooS1btpR4GwDAN9F4AQD8yvr163XTTTepcePGio+P18GDB7V79+4i64wbN07t27fXU089pezsbEnStm3b9O677+rRRx/VNddcc8ltJCcn69prry3xNrfbrdGjR6tZs2aaOnWqWrRooblz52rdunV6+OGH1bFjR02dOlWhoaGaNm2a0tLSio0xb948HTx4UBMmTFC/fv30zjvvaPHixRo7dqzcbrcmT56sG2+8UatWrdJHH31U7P7XXnutXC6X9u/fX96HDQBgMxovAIDf2LNnj1JTUzVw4EBJ0q233lri4YZOp1PPP/+8jh8/rvnz58vlcumpp55Sx44d9cgjj1xyGwUFBfr555/VsmXLEm8/d+6chgwZojlz5ui+++7T8uXLVadOHU2fPl1PPvmknnjiCY0YMUJLliyR2+3Whx9+WGyMRo0aacWKFbrvvvu0YMECxcXFadWqVbr66qv1xz/+Uffee6+WLVumZs2a6f333y92/1atWkmSfvrpp/I8bAAAH0DjBQDwG+vXr1dQUJAGDBggSWrQoIF69+6txMREud3uIuu2a9dOEydO1Nq1azVq1ChlZGTo+eefV1BQ0CW3kZmZKcuyFBYWVuo6F15NMSwsTFFRUapbt26Rc8Kio6MVFhZW4idew4YNk8Ph8P583XXXybIsDRs2zLssMDBQHTt2LPH+hbVlZGRccl8AAL6DxgsA4Bfcbrc2bNigbt26KTIy0rt84MCBSk9PL/Eqf6NGjdI111yj3bt3a/z48brqqqvKvb3Szp8KCQkpsn3pfAPYrFmzIs1U4XKXy1VsjObNmxdbT5KuvPLKYsszMzNLrfHi7QEAfBeNFwDAL3z11Vc6ceJEsSsN9uvXT3Xq1CnxIhtpaWney83v27evXNsJDw+Xw+EosWGSVOrl5UtbXlIDFxBQ8stvacsvVtiMRURElGt9AID9aLwAAH6h8Lu7brvttiLLQ0NDdfPNN2vz5s3Kzc31Lvd4PEpISFD9+vU1duxY/e1vf9OmTZvK3E5QUJBat26tw4cPV/s+VJfC2tq2bWtzJQCA8qLxAgD4vNzcXG3atEk9evRQeHh4sdt//etf68yZM/r888+9y1577TUlJydr7ty5evzxxxUXF6fZs2fr1KlTZW4vNjZWe/bsqdZ9qE579+5VgwYNdPXVV9tdCgCgnC59hjEAAD7g888/15kzZyRJy5cvL3b72bNnJUkff/yxBg4cqJSUFC1evFh33nmn+vXrJ0maP3++7rjjDs2ZM0eLFy++5Pb69++vjz76SAcOHFBUVFQ1703V7dixQ3379uUcLwDwIzReAACf9/HHH0uSkpKSlJSUVOp6X375pTIyMjRt2jRFRERo+vTp3tvatGmjKVOm6Nlnn1ViYqL3kvQl6du3ryIiIvTJJ5/o0Ucfrb4dqQYpKSnat29fkX0DAPg+h8XX3gMAUMyyZcu0bt06bdq0qdQLZ9jh2Wef1a5du7Ru3To+8QIAP8I5XgAAlODBBx9UTk6ONmzYYHcpXhkZGXrvvfc0adIkmi4A8DN84gUAAAAAhvGJFwAAAAAYRuMFAAAAAIbReAEAAACAYTReAAAAAGAYjRcAAAAAGEbjBQAAAACG0XgBAAAAgGE0XgAAAABgGI0XAAAAABhG4wUAAAAAhtF4AQAAAIBh/wvhZ/+jzQzJjQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "id": "538ddb98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 7.63303\n", + "GdL = 8\n", + "Chi² rid = 0.95413\n", + "P(0, chi²)= 0.52989\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.633484\n", + "1 1.991195\n", + "2 0.770664\n", + "3 0.002415\n", + "4 0.613056\n", + "5 0.057088\n", + "6 0.485976\n", + "7 0.110084\n", + "8 2.315219\n", + "9 0.653852\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "4ec42f61", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "id": "c7f54cf3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 3.2197184 ± 0.0063280\n", + "BY = 0.2357100 ± 0.8110331\n", + "cov_ABY = -0.0045912041981810425\n", + "chi² = 7.63281\n", + "chi² rid = 0.95410\n", + "P(0, chi²)= 0.52987\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "id": "fc824066", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA14AAAIsCAYAAADiRXiMAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAr4JJREFUeJzs3Xd0FOX7NvBrtqSSQkIIXRIwoSQUUWpAmiABUZCmUlSKiKBYCb2IgggECD1SBaRJUQjFglIM2AUEvwqhBBAkvSdb5v2D3+6bJYXsZp8tyfU5xyPZmX1yz+y1s3tnmiTLsgwiIiIiIiISRmHvAoiIiIiIiCo6Nl5ERERERESCsfEiIiIiIiISjI0XERERERGRYGy8iIiIiIiIBGPjRUREREREJBgbLyIiIiIiIsHYeBEREREREQnGxouIiIiIiEgwNl5ERA8wbNgwDBs2zPjzjRs3EBoaij179tixqrKJiopCy5Yt7V1GhRIaGoqYmBh7l1Ehde3aFVFRUfYuo0IZNmwY+vTpY+8yiAhsvIjIDHv27EFoaCjOnTtn71KcwpkzZxAaGorDhw8XO51NkeP6/vvv2VwVIzc3FzExMThz5ozFY/z666+IiYlBRkaGFSsjInJ8KnsXQETkbGrXro2zZ89CpeImtKL6/vvvsXXrVkyYMKHItLNnz0KpVNqhKvvLzc3F8uXLMX78eLRp08aiMX777TcsX74c/fr1g7e3t8m0w4cPQ5Ika5RKRORwuMeLiMhMkiTB1dW10n75ruxcXV0dpunOycmxdwlW5eLiArVabe8ybEKWZeTl5RU7LT8/H3q9vlzj2zIbWq0WBQUFNvt9RM6KjRcRWd2dO3cwefJktG/fHmFhYejduzd2795dZL6bN29i7NixaNGiBdq1a4cPP/wQJ06cQGhoaJFDmbZu3Ypu3bqhWbNmGDBgAH7++eci514BQEFBAZYtW4YnnngCYWFhePzxx7FgwYIyfynYsWMHunfvbvJ77if6HK+tW7eid+/eCAsLQ0REBGbPnl3sYVmHDh1C//790axZM7Rp0wbvvPMO7ty588DxL168iLZt22LYsGHIzs4GUPbXzFYM63jdunXYuHEjunTpgmbNmmHo0KH4+++/TeYtLgfAvUM5u3btWuyYhtc5LCwMzz77LM6ePWvyvK1btwK4dz6X4T+DspzjZTjMNC4uDosXL0aHDh3QokULjB07Fv/++2+R+f/44w+MHDkSrVq1QvPmzTF06FD88ssvJvPExMQgNDQUly5dwttvv43HHnsMzz//PIB750a98sorOHPmjDETTz31lPF9dPToUTz11FMIDw9H//79ceHCBbPX4Y0bN9CuXTsAwPLly43rxbAu/vrrL0RFRaFbt24IDw9Hhw4dMHnyZKSmpposw4IFCwAA3bp1M45x48YN43KU5RwvvV6PTZs2GZepbdu2GDlypMlh0FqtFitWrDC+zl27dsXixYuLbAsM6+7nn3/GgAEDEB4ejm7dumHfvn0PrMNQy8aNG9G7d2+Eh4ejffv2mDFjBtLT04v9PSdOnDC+Rtu3bzdm5eDBg4iOjkbHjh3RvHlzZGVlASjb+9xw2PL169cxevRotGzZEu+8847JPOfPn8eQIUPQrFkzdO3aFZ999pnJ9IKCAixduhT9+/dHq1at0KJFCzz//PM4ffq0yXz3vze7d++O8PBwXL58uUzri6gyc4w/2RFRhZGUlIRBgwZBkiS88MIL8PPzw/HjxzF16lRkZWXhxRdfBHDvr7EjRozA3bt3MXz4cFSrVg0HDhwo9tyRbdu2Yc6cOXj00Ufx4osv4ubNm3jttdfg7e2NGjVqGOfT6/V49dVX8csvv2DQoEFo0KAB/v77b2zatAlXr17FypUrS619165dmDFjBlq2bIkRI0YgMTERr776Knx8fFCzZk2L10l2djZSUlKKPF5cMxgTE4Ply5ejffv2eO6553DlyhV89tlnOHfuHD777DPj3oA9e/Zg8uTJCA8Px1tvvYXk5GRs3rwZv/76K/bt21fkEC6Ds2fPYtSoUQgLC8PKlSvh5uZW5tfMHvbt24fs7Gw8//zzyM/Px6effooRI0bgyy+/RLVq1Swa88CBA8jOzsbgwYMhSRI++eQTTJgwAV9//TXUajUGDx6M//77D6dOnTI2CZZatWoVJEnC6NGjkZycjE2bNuHFF1/E/v374ebmBgCIj4/H6NGjERYWhvHjx0OSJOzZswcjRozAtm3b0KxZM5Mx33jjDTz00EN48803Icuy8fFr167h7bffxpAhQ9C3b1+sX78eY8eOxezZsxEdHY3nnnsOALB27VpMnDgRhw8fhkJR9r+/+vn5YdasWZg1axaeeOIJPPHEEwBgbEp/+OEHJCYmon///ggICMA///yDnTt34tKlS9i5cyckScITTzyBq1ev4sCBA5g8eTKqVq1qHNscU6dOxZ49e9CpUycMGDAAOp0OP//8M/744w+Eh4cDAKZNm4a9e/eiZ8+eeOmll3D27FmsWbMGly9fxooVK0zGu3btGt544w0MGDAA/fr1w+eff46oqCg0bdoUDz/8cKm1zJgxA3v37kX//v0xbNgw3LhxA1u3bsWFCxdM3rMAcOXKFbz99tsYPHgwBg0ahKCgIOO0lStXQq1WY+TIkSgoKIBarTbrfa7Vao3N+6RJk4z5AoD09HSMGTMGvXr1Qu/evXHo0CHMmjULarUaAwYMAABkZWVh165d6NOnDwYOHIjs7Gzs3r0bo0aNwq5du9C4cWOT5d6zZw/y8/MxaNAguLi4wMfHx6zXkKhSkomIyujzzz+XQ0JC5LNnz5Y4z5QpU+QOHTrIKSkpJo+/+eabcqtWreTc3FxZlmV5/fr1ckhIiPzVV18Z58nLy5OffPJJOSQkRD59+rQsy7Kcn58vt27dWn722WdljUZjnHfPnj1ySEiIPHToUONj+/btkxs1aiT/9NNPJr/7s88+k0NCQuRffvmlxLoLCgrkdu3ayU8//bScn59vfHzHjh1Ffk9iYqIcEhIif/755yWOJ8uyfPr0aTkkJKTU/1q0aGGcPzk5WW7atKn88ssvyzqdzvj4li1b5JCQEHn37t0mtfbp00fOy8szznfs2DE5JCREXrp0qfGxSZMmGX/Hzz//LD/yyCPymDFjTJaxrK+ZLRnWcbNmzeTbt28bH//jjz/kkJAQ+cMPPzQ+NnToUJPXx2DSpElyly5diozZunVrOS0tzfj4119/LYeEhMjffvut8bHZs2fLISEhxdYWEhIiL1u2rNT6Da99x44d5czMTOPjcXFxckhIiLxp0yZZlmVZr9fLPXr0kF9++WVZr9cb58vNzZW7du0qv/TSS8bHli1bJoeEhMhvvfVWkd/XpUsXOSQkRP7111+Nj504ccK4Dm/evGl8fPv27SbvMVku+zpMTk4ucfmLy8mBAwfkkJAQk/fkJ598IoeEhMiJiYnFLsekSZOKPF5YfHy8HBISIr///vtFphnW4cWLF+WQkBB56tSpJtPnz58vh4SEyPHx8Sa/8/4ak5OT5bCwMHn+/Pml1vLTTz/JISEh8hdffGHy+PHjx4s8bvg9x48fN5nXkJVu3bqZrENz3+chISHywoULi9Q4dOhQOSQkRF6/fr3xsfz8fPnpp5+W27VrJxcUFMiyLMtardZkuyDLspyeni63b99enjx5svExw/vokUcekZOTk0tdP0RkiocaEpHVyLKMo0ePomvXrpBlGSkpKcb/IiIikJmZiT///BMAcOLECQQGBqJbt27G57u6umLQoEEmY54/fx5paWkYNGiQyXk1Tz31VJG/sB4+fBgNGjRAcHCwye9u27YtAJR6Jbbz588jOTkZQ4YMgYuLi/Hxfv36wcvLy/KVAuC1117Dhg0bivwXERFhMt8PP/wAjUaD4cOHm+yJGDhwIKpUqYLvv//epNbnnnsOrq6uxvk6d+6M4OBgfPfdd0VqOH36NEaNGoV27dohJibGuIzmvGb20L17dwQGBhp/btasGZo3b25cF5aIjIw0yc6jjz4KAEhMTLS80BI888wzqFKlivHnJ598EgEBAcb6L168iKtXr+Kpp55Camqqcd3n5OSgXbt2+Omnn4qc6zNkyJBif1fDhg1NrpLZvHlzAEDbtm1Rq1atIo9be3kL72HJz89HSkqK8XdZM0NHjx6FJEkYP358kWmGC3MY1u9LL71kMv3ll182mW7QsGFDYw6Ae3vggoKCHriODh8+DC8vL3To0MHkvdO0aVN4eHgU2ebUqVMHHTt2LHasZ555xmQdWvI+N+zVvJ9KpcLgwYONP7u4uGDw4MFITk42vjZKpdK4XdDr9UhLS4NWq0VYWFiRQ1MBoEePHmbvqSSq7HioIRFZTUpKCjIyMrBjxw7s2LGjxHmAe+d31atXr8gVzOrVq2fy861bt4p9XKVSoXbt2iaPXbt2DZcvXzaeh3K/5OTkEms3/J6HHnrI5HG1Wo26deuW+LyyCAkJQfv27Ys8/sUXXxRbQ3BwsMnjLi4uqFu3Lm7evGkyX+HDlAyCg4OLnBuUn5+PV155BU2bNsWSJUtMGlhzXrPipKWlQaPRlDi9ND4+PiZNbnHufz0AoH79+jh06JBFvxNAkcNGDU2YiMub31+/JEl46KGHjK/l1atXAQCTJk0qcYzMzEyTRrFOnTrFznf/chn+YFD4cFwAxkbQ2sublpaG5cuXIy4ursh7LTMz02q/5/r166hevTp8fX1LnOfmzZtQKBRFthsBAQHw9vY2rn+D4g4l9vHxKXKe1v2uXbuGzMzMMm9zSnrtiptm7vtcpVIVea0NqlevDg8PD5PH6tevD+DeumrRogUAYO/evVi/fj2uXLli8r4uru7SloWIisfGi4isxvCX+b59+6Jfv37FzlP4IgUifn9ISAgmT55c7PSSvpRUdC4uLujUqRO+/fZbnDhxAl26dDFOK+9rNmHCBPz4448W1bV582aLL0leFjqdrtjHS7oapVzofClbMfzO9957r8g5NAb3f2EuvPejsJKWqzzLW9I6LM7EiRPx22+/YeTIkWjcuDE8PDyg1+sxatQou6xbAGW+NL2lVyjV6/Xw9/fHwoULi51+/x6hwnu07lfatLJwcXEx65y9++3fvx9RUVHo3r07Ro4cCX9/fyiVSqxZs6bYPX/lrZeoMmLjRURW4+fnB09PT+j1+mL38BRWu3ZtXLp0CbIsm3w5un79usl8hkOkrl+/bjxkELh3IvnNmzdNmoJ69erhr7/+Qrt27cy+F5Dh91y7ds3kr9cajQY3btxAo0aNzBrPEoYaEhISTPayFRQU4MaNG8Z1apjvypUrRf7SfuXKFZPDyoB7Xz4XLlyIcePG4Y033kBsbKyx4THnNSvOpEmTLN5zUpZ1eu3atSKPXb161WRvp4+PT7FfDA17DCxhrXtJ3V+/LMu4du2aMbeG17lKlSoWrX9rKes6LGm9pKenIz4+HhMmTDA5BNCwR68sY5RVvXr1cPLkSaSlpZW416t27drQ6/W4du0aGjRoYHw8KSkJGRkZRfaWl6eW+Ph4PPLII1ZvRMx9n5fmv//+Q05OjkkTb3htDOviyJEjqFu3LpYvX27yGi1btszSRSCi+/AcLyKyGqVSiZ49e+LIkSNFLvkNmB6yFhERgTt37uCbb74xPpafn4+dO3eaPCcsLAy+vr7YuXMntFqt8fEvv/yyyGFAvXr1wp07d4qMAQB5eXml3tcmLCwMfn5+2L59u8nVBvfu3SvkELTitG/fHmq1Gp9++qnJHoLdu3cjMzMTjz/+uLFWf3//IrV+//33uHz5Mjp37lxkbBcXFyxfvhzh4eEYO3as8fLp5rxmxQkLC0P79u0t+q8sV0H7+uuvTS6dffbsWfzxxx/o1KmT8bG6desiISHBpNa//voLv/766wPHL4m7uzuA8h+Ot2/fPuNlwYF75wTdvXvXWH9YWBjq1auH9evXGy/tX9iD1r+1lHUdlrReStpjtGnTpiKPGcaw9PDDHj16QJZlLF++vMg0w/vG8F65//dv2LDBZHp59erVCzqdrtgrpmq12nLlx5L3eUm0Wq3JocQFBQXYsWMH/Pz80LRpUwD//zUsvO35448/8Pvvv1u8DERkinu8iMhsn3/+OU6cOFHk8eHDh+Ptt9/GmTNnMGjQIAwcOBANGzZEeno6/vzzT8THxxsPSxs8eDC2bNmCt99+G8OHD0dAQAC+/PJL42FUhr+4uri4YMKECXj//fcxYsQI9OrVCzdv3sSePXuKnL/x9NNP49ChQ5g5cybOnDmDRx55BDqdDgkJCTh8+DA++eQT46Wm76dWqzFx4kTMmDEDI0aMQGRkJG7cuIE9e/aU+xyvsvLz88Mrr7yC5cuXY9SoUejatSuuXLmCbdu2ITw8HH379jXW+s4772Dy5MkYOnQoevfubbzMdO3atUu8/LubmxvWrFmD4cOHY/To0fj0008REhJS5tfMHurVq4fnnnsOzz33HAoKCrB582b4+vpi1KhRxnkGDBiAjRs3YuTIkRgwYACSk5Oxfft2NGzYsNhmpiwMX0bnzp2LiIgIKJVK9O7d2+xxfHx88Pzzz6N///7Gy8k/9NBDxovIKBQKzJ07F6NHj0afPn3Qv39/BAYG4s6dOzhz5gyqVKmC1atXW7QM5ijrOnRzc0PDhg1x6NAh1K9fH76+vnj44YcREhKCxx57DJ988gk0Gg0CAwNx6tQp4/25CjOs2+joaERGRkKtVqNLly5FDqksSdu2bfH000/j008/xbVr19CxY0fo9Xr88ssvaNOmDYYOHYpGjRqhX79+2LFjBzIyMvDYY4/h3Llz2Lt3L7p3726y97w8WrdujcGDB2PNmjW4ePEiOnToALVajatXr+Lw4cOYOnUqnnzySYvGtvR9Xpzq1asjNjYWN2/eRP369REXF4eLFy/i/fffN17uvnPnzjh69Chee+01dO7cGTdu3DBmoKLdqJvIXth4EZHZ7r/xpkH//v1Ro0YN7Nq1CytWrMBXX32Fzz77DL6+vmjYsKHJDT09PT2xadMmzJ07F5s3b4aHhweeeeYZtGzZEhMmTDA5j2Xo0KGQZRkbNmzARx99hEaNGmHVqlWYO3euyXwKhQIrVqzAxo0bsX//fnz11Vdwd3dHnTp1MGzYsGJPUi9s8ODB0Ol0WLduHRYsWICQkBCsWrUKS5cuLecaK7sJEybAz88PW7Zswbx58+Dj44NBgwbhrbfeMrkfUP/+/eHm5obY2FgsXLgQHh4e6N69O959990S7+EF3Dukbd26dRg6dChefvllbN26FQ899FCZXjN7eOaZZ6BQKLBp0yYkJyejWbNmmD59OqpXr26cp0GDBvjoo4+wbNkyzJs3Dw0bNsSCBQtw4MABi5vGHj16YNiwYTh48CC++OILyLJsUeM1duxY/O9//8PatWuRnZ2Ndu3aYebMmca9PgDQpk0b7NixAytXrsSWLVuQk5ODgIAANGvWzORKdCKZsw7nzp2L999/H/PmzYNGo8H48eMREhKCRYsW4f3338e2bdsgyzI6dOiA2NjYIlfxa9asGd544w1s374dJ06cgF6vxzfffFPmxgsA5s2bh9DQUOzevRsLFiyAl5cXwsLCTK7qOHfuXNSpUwd79+7F119/jWrVquGVV14p9mqI5TFnzhyEhYVh+/btiI6OhlKpRO3atdG3b1888sgj5Rrb0vf5/Xx8fDB//nzMnTsXO3fuRLVq1TBjxgyTq8j2798fSUlJ2LFjB06ePImGDRvi448/xuHDh+36xxeiikSS7XXGKxFRMTZu3Ih58+bh+PHjJpcRv59er0e7du3wxBNPYO7cuTaskGzhxo0b6NatG9577z2MHDnS3uWY7cyZMxg+fDiWLl1q8R4PIiKqWHiOFxHZTV5ensnP+fn52LFjB+rXr2/SdOXn5xe5Ktq+ffuQlpaG1q1b26RWIiIiovLgoYZEZDfjx49HrVq10KhRI2RlZeGLL75AQkJCkUsz//7775g3bx6efPJJ+Pr64sKFC9i9ezdCQkK4N4GIiIicAhsvIrKbiIgI7N69G19++SV0Oh0aNmxoPOG+sNq1a6NGjRr49NNPkZ6eDh8fHzz99NN45513HngDXiIiIiJHwHO8iIiIiIiIBOM5XkRERERERIKx8SIiIiIiIhKM53iZ4bfffoMsyyb30iEiIiIiospHo9FAkiSTewiWho2XGWRZLnJJayIiIiIiqnzM7QvYeJlBrVZDlmWEhYVBkiR7l0MVjCzL0Gg0UKvVzBcJwYyRSMwXicR8kWiWZOzcuXNm/Q6e40VERERERCQYGy8iIiIiIiLBHK7x+uabbzBw4EC0bNkSEREReOONN5CYmFhkvl27dqFnz54IDw9H3759cezYsSLzZGZmYsqUKWjdujVatmyJ119/Hf/9958tFoOIiIiIiMjIoRqvM2fOYPz48WjYsCFWrFiBKVOm4K+//sLLL7+MvLw843wHDx7E9OnT0atXL8TGxqJFixYYP348fv/9d5PxJk6ciFOnTmHWrFlYuHAhrly5gtGjR0Or1dp4yYiIiIiIqDJzqItrHDx4ELVq1cKHH35oPKnNz88PI0aMwPnz5/Hoo48CAJYtW4bevXtj4sSJAIC2bdvi77//xooVKxAbGwvg3qXfT548iXXr1iEiIgIAEBQUhMjISBw9ehSRkZEW1cgTOkkk3qqARGPGSCTmi0Rivkg00RlzqMZLq9XC09PTpLnx8vIC8P8v15iYmIirV6/i3XffNXluZGQkFixYgIKCAri4uOD48ePw9vZGhw4djPMEBwejcePGOH78uMWNF/Dg5kun00Gj0Vg8PpG1qNVqKJVKe5dBDoJ/OCKRmC8Sifki0WyRMYdqvPr374/9+/dj69at6Nu3L9LS0rB48WI0adIEjzzyCAAgISEBwL29V4U1aNAAGo0GiYmJaNCgARISEhAUFFRkJQYHBxvHsJQsy8W+OLIs4/bt20hLSyvX+FR5lZSt8vD19UWNGjX4oUWQZRk6nQ5KpZJ5IKtjvkgk5otEs0XGHKrxevTRR7F8+XK8/fbbmDNnDgCgcePG+OSTT4x/tU9PTwcAeHt7mzzX8LNhekZGhnFvWWE+Pj44f/68xTWWdBNlSZLw77//Ij09HQEBAfDw8DC+aIb/l3STNUmSSp1WnudyXLHjWrsmQ+NVnuUxTJNlGTk5Obh79y5kWUatWrWsXq9hWnnGdcSanG3csj7X8KGiUCiE18RxHbcmkeMWzpe1xi1vTRzXMWsyd9zCX4qdoV5nrsnZxrVWTYW3YeUZtzQO1Xj9+uuveO+99zBo0CB07twZaWlpWLlyJcaMGYNt27bBzc3N3iUCADQajUknbHiB0tPTUa1aNfj5+ZnMb/gQKq5pK/wl25xp5X2uoSa9Xl+px7X0uYZp1q5JlmVjnqwxrpubG2RZxt27dxEYGAilUgmtVlvkuSqVyvg7dTqdyTSFQgGV6t6morhDaA03GtTpdEVqNowry3KRi9oYxpVlucRxARQ7rlKpNH743j+uJEnG5xa3rIZpxS1recYtzzp0cXEpcVnLMm5Z12Hh5VKpVOVeh9Z+bSxdhyJfm9LyXdqylmVcwLbr0DBucTVZax0a6i38GclthOmyOvI2wlrLKmLcwp9t3EY47zbCkb9HGP4tSZLxPfegbYQsm3ekkkM1XnPnzkXbtm0RFRVlfKxFixbo3Lkz9u/fj8GDB8PHxwfAvUvFBwQEGOfLyMgAAON0b29v3L59u8jvSE9PN85jqeLuaJ2fnw8ARc5Ru58l08ryglr7d1aWcQs/5ig1WXtcT09PJCUlQaPRQKlUGjd+xVEoFEX+Wl1YcSedGn5X4Q12cfOUdMJqadPKMy4Ai5dV1LhA6Sfulras5am38AeMoQbD61aeZbXHawOUvg4dLd8ljWtQ0dahSqUq8hnJbUTZxwXsu42w5Lm22kYU/nLNbUTZxnXEbYQjf48wfEYWXr4HLas5TRfgYI3X5cuX0a1bN5PHatSogapVq+L69esA7p2jBdw718vwb8PParUadevWNc4XHx9fpBO9cuUKQkJCylVn4b0d9yvtRXDmL+8cV3xNxe3Bssa4JR32U95xHeG5HNf85xq2X4UbLxE1cVzHrUnkuPfnyxFq4riOWZMl45Zlu+VI9TprTc42rjVrun/7VZ6aiuNQ9/GqVasWLly4YPLYzZs3kZqaitq1awMA6tati/r16+Pw4cMm88XFxaFdu3bGXYOdOnVCeno64uPjjfNcuXIFFy5cQKdOnSyu0ZKVTFRWzBeJxqtckkjMF4nEfJFoojPmUI3XkCFD8PXXX2Pu3Ln44YcfEBcXh7Fjx8Lf3x+9evUyzjdhwgQcOHAAy5Ytw5kzZzBz5kycPXsW48aNM87TsmVLREREYMqUKTh06BC+/fZbvP766wgNDUWPHj3KVWdF/3IcExOD0NDQIv/16dMHABAaGop169YZ59+zZw++/PLLMo3dtWtX44VTACAqKso4bkUQFRWFtm3bFntly48++ggtW7Ys9hBYoOieiOLExMSgZcuW1iqXKhlJknhFMBKG+SKRmC8SzRYZc6hDDYcPHw4XFxd89tln+Pzzz+Hp6YkWLVpgyZIlqFq1qnG+Pn36IDc3F7GxsVi7di2CgoKwfPnyIl9IlyxZgnnz5mHGjBnQarWIiIjAtGnTSj1esyzMPZHOGbm5uWHTpk1FHgOAHTt2GK+QBwB79+6Fh4cHnnrqKbN/z7hx45CTk1O+Yh3Ie++9h2PHjuHjjz/GBx98YHz8f//7HzZv3ox3330XNWrUKPa5hQ81rOj5IvswnJz+oAafyBLMF4nEfJFotsiYQzVekiThueeew3PPPffAeQcOHIiBAweWOo+Xlxc+/PBDfPjhh9Yq0aJLRzojhUKBFi1aFDutpMctUa9ePauNZS0FBQVQqVSlnhxaEj8/P0RFRWHy5Mno378/WrVqBVmWMWvWLISGhmLYsGGlPr+kpt5QE1F5abXaUk9CJioP5otEYr5INNEZc6hDDck5FD7UcNiwYfjxxx/x3XffGQ9JjImJKfNY9x9quGfPHoSGhuLChQsYNWoUWrRogR49emDfvn1Fnvvdd99h4MCBaNasGdq2bYuZM2ea7D3LycnBnDlz0LNnTzRv3hxdu3bFjBkzkJmZaTKO4fDH2NhYdOnSBc2aNTMeKrhnzx489dRTCA8PR8eOHREdHV3kMqn369evH1q3bo1Zs2ZBq9Xi888/xx9//IE5c+ZAqVTi5s2beP3119GqVSu0aNECI0eOxP/+978y13S/5cuXo3nz5vj+++9LrYuIiIiI7Id/QqcS3X+/hOKOe505cybeffdduLm5YdKkSQBQ4qF05njnnXcwaNAgvPTSS9i5cyeioqIQHh6OBg0aAAAOHz6MN998E/3798eECRNw9+5dLFq0CBkZGYiOjgYA5OXlQafT4c0334Sfnx/+/fdfrF69GuPGjcOnn35q8vuOHj2Khx56CFOnToVCoYCHhwc2bNiAjz/+GCNGjEBUVBQuX75sbLzeeeedUuufPXs2+vbti+joaOzevRsvvPACwsLCkJWVhWHDhkGhUGD27NlwdXXFqlWrMHToUOzfv99k3RVX0/0++ugjbN++HWvXrkWbNm3Ku9qJiIiIHEZubi4uXbqEhg0bAoDx3+7u7nauzDJsvKhYOTk5aNq0qcljCxYswNNPP23yWMOGDVGlShV4eHhY9RDEF154AS+88AKAexdK+f7773HkyBGMGzcOsixjwYIFiIyMNDmPKiAgAGPGjMG4cePw8MMPw8/PD7NnzzZO12q1qFOnDp5//nlcuXIFQUFBxmkajQaxsbHG5iYrKwvLli3DqFGj8NZbbwEAOnToALVajfnz52PkyJEm5x3eLygoCK+88gpiYmJQo0YNTJw4EcC9PWi3bt3CwYMHjU3kY489hi5dumDTpk3G5rW4mgozHL546NAhbNy4Ec2bNzd3FRMRERE5tNzcXJw/f954dXPDv9l4VRKWnmynuXoL+vTMB89oZQofL6jr13rwjPdxc3PDli1bTB4z3CPNFiIiIoz/9vDwQK1atYxXA7xy5Qpu3ryJKVOmmOyVa926NRQKBc6fP4+HH34YALBv3z5s3LgR165dMzkM8erVqyaNV5s2bUwanN9++w05OTl48sknTX5H+/btkZeXh3/++QetW7cudRnGjBmDmJgYPPfcc/D09AQA/Pzzz3j44YeNTRcA+Pr6on379vj1119Nnn9/TQayLOO9997DqVOnsHnzZjRq1KjUOogK40npJBLzRSIxX5VXVk4B/kvNhUZb+uke5SU6Y2y8LGDui6JLTsP1Ns8Ber2gikqhVKL+n/ug9Pc162kKhQLh4eFiaioDLy8vk5/VajUKCgoAAKmpqQCA1157rdjn/vvvvwCAr776CpMmTcLgwYPx5ptvwtfXF3fv3sVrr72G/Px8k+f4+/ub/Gz4Hf369Sv1d5TGcE+5widpZmRkoFq1akXm9ff3xz///GNyQY/7azLQaDT49ttv0b59+3LfDJwqF0mSeGI6CcN8kUjMV+WTkpKCGzduID0pFYffX4efvPxQq2ou/r6UgMCAdPj4+MDPz89qv88WGWPjZQNKf1/UO/OZ3fZ4mdt0OTpfX18AwIwZM9CsWbMi06tXrw7g3nlgjRs3Nrlv2I8//ljsmPc30z4+PgDuXbiiuHPW6tSpY1HtPj4+uHLlSpHHk5OTjb+zpJoMXFxcsGbNGowePRqzZs0yWT4iIiKiiuD06dP478tv0ebrc6iSnovM59oiQ+OJY99+A7VKiSZNmiAyMtLeZZqFjZcFLLmPlyWH+zkLtVpdZA+SSMHBwahRowYSExON54EVJy8vr8hfLsp6o+eWLVvC3d0dt2/fxhNPPFGuegtr1aoVjhw5goSEBAQHBwMA0tPT8cMPP2DQoEHQ6/Vlytajjz6KlStX4pVXXoGrqyumTp1qtRqp4pJlGVqtFiqViofskNUxXyQS81W5aG7cQdjW76A5egYp9atj/7N9cFF2RR11Frp07YTAAP8if7AuL1tkjI2XmSrLfbzMERwcjH379uHbb79FQEAAqlevjsDAQGG/T5IkREVF4Z133kFOTg46d+4Md3d33Lp1C99//z3efPNNBAUFoX379pgzZw5WrFhhvEBHfHx8mX6Ht7c3Xn/9dXz88ce4ffs2WrduDaVSicTERHzzzTeIiYmx6MTO/v37Y+PGjXjllVcwceJE41UNVSoVRowYYdZY7dq1Q0xMDF577TW4u7sbLwJCVBpuw0gk5otEYr4qPjm/AGkrtiN1yWYofLzgueht/KjKwaBOXXE3NRd//n4KIQ2DrXqIocnvF5wxNl5UbqNHj8b169cxadIkZGRkYPz48ZgwYYLQ39mrVy94e3tj9erVxr1YtWvXRseOHY3nUA0ZMgQ3btzAli1bsG7dOkRERGDRokUYNGhQmX7Hyy+/jMDAQGzYsAFbtmyBSqVCvXr10LlzZ4uPAa5SpQo+/fRTzJ8/H9OnT4der8cjjzyCLVu2oGbNmma/4R9//HEsWbIEb7zxBlxdXUs8742IiIjIkWV/FY/kqcugSfwXvmMHoerbLyKtIA84cgRVPFxQxcMFf59X2rvMcpFk/vmgzM6dOwdZlhEeHl5kF2ReXp7xEuVubm52qpCcmSzLxsNYrbmLm9kkA1mWodFooFareagOWR3zRSIxXxWX5totJE2LQc7hk3Dv1ArV5k2ES0h9ALa9j5clGTt37hwAlPmCdNzjRURERERENqXPzUfa8m1IW7YFCj9fBH4yB559O5s0Pe7u7iZNjT2vuG0NbLzMxL+ykEjMF4nGyzGTSMwXicR8VQyyLCPnyCkkTVsG7a278B03BFXfHA6Fp/1viszLyTsgfjkmEZgrEo0ZI5GYLxKJ+aoYNAk3kDR1KXK+Pg33Lq1Rc8dCuDSoZ++yANgmY2y8LGDJ5eSJHqTw6ZbMF4kgyzL0ej0UCgUzRlbHfJFIzJdz0+fkIW3pFqQu3wZVdT8EbvwAnpEdHeq1tEXG2HiZidciIZHY1JNoOp0OCoXC3mVQBcV8kUjMl/ORZRnZcSeQPD0G2jvJqDr+efi+MRQKD8e82JfojLHxsjI2ZuRomEkiIiKytYLL15EUtQS53/0EjyfaodbuaKiD69i7LLti42UlhpPxcnJyhFzikshSOTk5AHhSMhEREYmnz85F6uJNSFu1A6paAaixZT48e3awd1kOgY2XlSiVSvj6+uK///4DAHh4ePCQMTKLte/jJcsycnJy8N9//8HX1xdKpXPfdJCIiIgclyzLyN5/DEkzV0Cfkoaqbw2H72vPQ+Huau/SHAYbLzOV9oW4Ro0aAGBsvojMJeIcL19fX2M2idiAk0jMF4nEfDmugr+vImnyEuQe/wUevSJQ7f0JUD9Uy95lmU10xth4WaCkL8aSJKFmzZqoXr06NBqNjasiKkqtVvODiowkSWIeSBjmi0RivhyTPisHKQs3IH3NLqjr1kSNzz6GZ/e29i7LIrbIGBsvCzxor4RSqeTGgcxm7UMNie7HjJFIzBeJxHw5FlmWkbXnayTPXAF9Rhb83nsZvuOGQHJ1sXdpFrNFxth4mYlXiCORtFotL4JBQjFjJBLzRSIxX44h/2ICkqKikffD7/Ds8zj8358AdZ1Ae5dlFaIzxsaLiIiIiIhKpcvIQuqC9Uj/ZA/UQbVRc+cieHRpbe+ynAobLyIiIiIiKpYsy8jadQTJs1ZBn50Lvymj4Tt2ECQX7n00FxsvIiIiIiIqIv/8JSRNWoy8H8+hyjNd4T/7NahqVbd3WU6LjZeZeEInicR8kWjMGInEfJFIzJft6NIzkTLvE2Rs2Af1w/VQc88SeHRsZe+yhBOdMTZeFuAbn0SQJIknDZNQzBiJxHyRSMyXbch6PTI/O4Tkuash5xXAf9ar8Bk1AJK64rcMtshYxV+LRERERERUqvw//oe7UdHI//lPVBnwBPxnjoOqRjV7l1WhsPGywIPu40VkCVmWodVqoVKpmC8SghkjkZgvEon5EkeXmoGUD9ciY9MXcGkchFr7Y+DevoW9y7I5W2SMjZeZeB8vEon5ItGYMRKJ+SKRmC/rkvV6ZG49gOS5awGNFv5zX4fPy89AUlXe9kB0xirvmiUiIiIiqoTyfr2ApKglyP/tIrwGPwm/Ga9CVd3P3mVVeGy8iIiIiIgqAV1yGpLnrkHm1oNwadoQtQ6sgHubZvYuq9Jg40VEREREVIHJOh0yNn+BlA9jAVlGtXkT4f3i05CUSnuXVqmw8TITT+gkkVSV+Lhqsg1mjERivkgk5ssyeT+dx91Ji1Fw7h94vdAb/tNegbJaVXuX5ZBEZ4wJtgCbLxJBkiRmi4Rixkgk5otEYr7Mp72bipQ5q5C5/RBcm4ei9uHVcGvV1N5lOSxbZIyNlwV4OXkSQZZl6PV6KBQK5ouEYMZIJOaLRGK+yk7WapGxYR9S5q8DlApUW/gOvIf24WGFD2CLjLHxMhMvZUoi6XQ6KBQKe5dBFRgzRiIxXyQS8/VgufF/IGlyNAouJMB7eF/4TRkNpZ+PvctyGqIzxsaLiIiIiMiJaW8nIXnOKmTtOgrXVk1Q++hauLVoZO+y6D5svIiIiIiInJCs0SJ93edI+Wg9JFc1AqInwev5SEjcM+iQ2HgRERERETmZ3FO/4W5UNDR/X4P3i8/AL2oklFW97V0WlYKNl5l4QieJxGPXSTRmjERivkgk5use7b93kTxzBbL2fgO3x8IQ+FUsXJuF2LusCkF0xth4WYDNF4kgSRLvUUJCMWMkEvNFIjFfgFygQdraXUhduBEKDzcExEyB16CePKzQSmyRscqdYAvxcvIkQuErZjJfJAIzRiIxXyRSZc9Xzvc/I2nyEmgSbsBnZH9Ufe8lKH287F1WhWKLjLHxMhMvJ08iaTQaqNVqe5dBFRgzRiIxXyRSZcyX9uYdJE1fjuwvv4Nb2+YIjJ0F16YN7V1WhSU6Yw7VeA0bNgw//vhjsdMWL16M3r17AwB27dqFTz75BLdu3UJQUBDefPNNdOnSxWT+zMxMzJs3D19//TU0Gg06duyIadOmoXr16sKXg4iIiIjIUnJ+AdJW7UBq9GYoqnig+qrpqPLsE5Vyb19F4lCN18yZM5GVlWXy2KZNm3D06FG0a9cOAHDw4EFMnz4dY8eORdu2bREXF4fx48dj69ataNGihfF5EydOxKVLlzBr1iy4urpiyZIlGD16ND7//PNKf4wwERERETmmnG/OIGnKEmiu/wufMQPh986LUHh52rsssgKH6kAaNiy66/Ttt99Ghw4d4OfnBwBYtmwZevfujYkTJwIA2rZti7///hsrVqxAbGwsAOC3337DyZMnsW7dOkRERAAAgoKCEBkZiaNHjyIyMtI2C0REREREVAaa6/8ieXoMsuNOwC3iEdTY/CFcQoPsXRZZkUNfBuXXX3/FjRs38NRTTwEAEhMTcfXqVfTq1ctkvsjISMTHx6OgoAAAcPz4cXh7e6NDhw7GeYKDg9G4cWMcP37cdgtARERERFQKfV4+UhZtRGKHocj77S8Erp2FWnuWsOmqgBxqj9f9Dhw4AA8PD3Tr1g0AkJCQAODe3qvCGjRoAI1Gg8TERDRo0AAJCQkICgoqchxscHCwcQxLSZLE42tJCEmS4OLiYu8yqAJjxkgk5otEqqj5yj76A5KmLoP25h34jh2Eqm+NgKKKh73LqpRskTGHbby0Wi0OHTqErl27wsPjXgDT09MBAN7epnflNvxsmJ6RkQEvr6KX2PTx8cH58+fLXVtxVzaUJKnEKx4aGrXSpot6Lsfla+Po4zpiTc42riPWxHEdtyZnG9cRa3K2cR2xpso+rubqLSRPW4acoz/A/fFHUWPrfLg8/JDJWBVlWUWP62g1lcZhG69Tp04hJSUFffr0sXcpJmRZRkFBgcleL4VCYbxgh0ajKfIcQ/es0+mg1+tNpqlUKkiSBL1eD51OZzLNMK4sy8WOa7jcZXHjKpVKKJVKyLIMrVZrMk2SJONztVptkeCIGrcsywoUXYeixjUsqyRJZi9rWcYFzFuHsixDr9fDzc0NkiSZvayGcYuryV7r0DBuaevQXvkubR3aMt+A7bYRhowZnsdthHNtI8q7rKK3EbIsIz8/HwqFwuQzktsI02V15G2EtZZVxLiyLBunO/M2Qp+bj8wVnyFj5XaoqlVF4Pr3oe7RDpIkmYxfEbcRlqxDW24jDJ+RSqXS+J570DbCkMuyctjG68CBA/D19TVeHAO4t8cKuHep+ICAAOPjGRkZJtO9vb1x+/btImOmp6cb5ykPQ0BKmlaSwoG+n0KhgKKEO48XDru54z7ouaVd4VHUuKUtK1D6OrT2uIbXsTzLaq3X5v4NR2VZh/bKd3nec6JeG9HbCEPGCm/DuI0ofVxH2kbczxHXoUKhKPIZyW1E2ccF+D2ipHELf0Y64zZCpVIh59BJJM+IgfZ2MnxfG4KqbwyDwtO91D0nFW0b4cjfIwwZK7x8D1pWc5ouwEEbr7y8PHz99dfo27evyYoMDg4GcO9cL8O/DT+r1WrUrVvXOF98fHyRLvTKlSsICQkpd32SVPx5Xg9a+aVNF/Vcjit2XGvXVNyXFWv+Tkcc1xFrcrZxzXmuYftVuPESURPHddyaRI57f74coSaO65g1WTJuWbZbjlSvgSbhBpKmLEXut2fg0a0tau5cDJcGde1aU0Ua15o13b/9Kk9NxXHIqxp+++23yMnJMV7N0KBu3bqoX78+Dh8+bPJ4XFwc2rVrZ9wt2KlTJ6SnpyM+Pt44z5UrV3DhwgV06tRJ/AIQERERUaWmz85F8gdrkdhpBDSXrqPG5g9R47MFJk0XVS4Oucfryy+/RK1atdCqVasi0yZMmIB33nkH9erVQ5s2bRAXF4ezZ89iy5YtxnlatmyJiIgITJkyBZMmTYKrqyuio6MRGhqKHj162HJRiIiIiKgSkWUZ2Qe+R/L0GOiS0lD19Rfg+/pQKNxd7V0a2ZnDNV7p6ek4ceIERowYUewuvD59+iA3NxexsbFYu3YtgoKCsHz5crRs2dJkviVLlmDevHmYMWMGtFotIiIiMG3atFKP1SwLS3YrEpVVefNJ9CDMGInEfJFIzpCvgn+u3Tus8Luf4NGzA6q9PwHqoNr2LovKSHTGJNmSayFWUufOnQMAhIeH27kSIiIiInIU+qwcpC7ehLTVO6GqXR3VPngDnj3a27ssEszc3sDx/3TggMy9dCRRWRS+1DfzRSIwYyQS80UiOWq+ZFlG9r5vkTRzBfSp6aj69gj4vvYcFG48rNDZ2CJjbLzMxB2EJJJOpyv1MqxE5cWMkUjMF4nkaPkq+OsK7k5egryTv8Kzdyf4zxkPdb2a9i6LykF0xth4ERERERGVkT4zGykfb0B67G6o69VEzR0L4dG1jb3LIifAxouIiIiI6AFkWUbW7qNInrUS+qwc+EWNgu/YQZBcXexdGjkJNl5ERERERKXI//MSkqKWIO/0H/Ds2wXV5rwGVe1Ae5dFToaNl5kc6YROqngc6dh1qpiYMRKJ+SKR7JEvXXomUj9aj/T1e6EOroOau6Ph8fijNq+DbEN0xth4WYDNF4kgSZJT3KOEnBczRiIxXySSrfMl6/XI3HkEKXNWQZ+dB79pY+A7ZiAkF7XNaiDbskXGuIUkciC8VQGJxoyRSMwXiWSrfOWf/RtJUdHI++k8qvTvDv9Z46CqGSD895L9ic4YGy8zybLMDxYSQpZlaDQaqNVq5ouEYMZIJOaLRLJFvnRpmUj5MBYZm/ZDHfIQau1bBvcOLYX8LnI8tsgYGy8iIiIiqrRkvR6Z2+KQPHc15HwN/GePg8/IZyGp+TWZrIuJIiIiIqJKKe/3v5A0aTHyf72IKoN6wn/Gq1AF+tu7LKqg2HgRERERUaWiS0lHygdrkfHpl3BpEoxaX66Ae9tm9i6LKjg2XkRERERUKcg6HTI+/RIpH8YCOj2qffgGvF98GhKvyEk2wJSZiScMk0hqNS9TS2IxYyQS80UilTdfeb/8iaRJ0cj/43/wei4SftPHQhVQ1UrVUUUgehvGxssCbL5IBOaKRGPGSCTmi0QqT750SalIfn8NMrcdhEv4w6gdtwpuj4VZsTqqCGyxDWPjZQFeTp5EkGUZOp0OSqWS+SIhmDESifkikSzJl6zTIWPjfqTMiwUkCdUWvAXv4X0hKZWCqyVnZIttGBsvM8mybO8SqALT6/VQ8gOBBGLGSCTmi0QyJ1+5Z84iKWoJCv68BK+hfeA/dQyU/r5iCySnJ3obxsaLiIiIiCoE7X8pSJ69Clk7D8O1ZWPUPrwabo80sXdZRADYeBERERGRk5O1WqSv24vUj9YBahUCFr8Lrxf6QFIo7F0akREbLyIiIiJyWrk//I6kqGgU/HUF3i8+Db/Jo6Gs6m3vsoiKYONlJp4wTCLx3AgSjRkjkZgvEun+fGlvJyF51kpkff4VXB9tijpfxcK1eaidqqOKQPQ2jI2XBdh8kQiSJPFLCwnFjJFIzBeJVDhfskaL9NjdSFmwHpK7KwKWRsFrSC8eVkjlYottGBsvC/By8iSCLMvGbDFfJAIzRiIxXySSIV95p35D0uQl0PxzHd4vPQO/qFFQ+nrZuzyqAGyxDWPjZSZeTp5E0mq1wu+aTpUbM0YiMV8kivbWf7g7fTlyv/wObm2aIfCbdXANa2jvsqiCEb0NY+NFRERERA5JLtAgbfVOpC7aBMnTDQHLp8JrUE/uVSWnxMaLiIiIiBxOzrEf7x1WePUWvEf1h9fEoXD1r8qmi5wWGy8iIiIichiaG3eQPC0G2Qe/h1v7FgjcMBcujYKg0WjsXRpRubDxMhP/ykIiMV8kGjNGIjFfVB5yfgHSVmxH6pLNUPh4ofqamajSrxskSeKFzcgmRGeMjZcF+MYnESRJ4knpJBQzRiIxX1Qe2V/FI3nqMmgS/4Xv2EGo+vaLUFTxME5nvkg0W2SMjRcRERER2YXm2i0kTYtBzuGTcO/UCjW2zINLSH17l0UkBBsvC3B3N4kgyzK0Wi1UKhXzRUIwYyQS80Xm0OfmI235NqQt2wKFny8CP5kDz76dS8wO80Wi2SJjbLzMxPt4kUjMF4nGjJFIzBeVRfaRU0iauhTaW3fh++pgVH1zuMlhhSVhvkg00Rlj40VEREREwmkSbiBp2jLkfBUP986Poeb2hXBpWM/eZRHZDBsvIiIiIhJGn5OHtKVbkLp8G1TV/RC48QN4RnbkIYNU6bDxIiIiIiKrk2UZ2XEnkDw9Bto7yag6/nn4vjEUCg83e5dGZBdsvMzEv86QSLxULonGjJFIzBcZFFy+jqSoJcj97id4PNEOtXZHQx1cp1xjMl8kGi8n74DYfJEIzBWJxoyRSMwXAYA+OxepizchbdUOqGoFoMaW+fDs2aHc4zJfJJotMsbGywK8nDyJIMsydDodlEol80VCMGMkEvNVucmyjOz9x5A0cwX0KWmo+tZw+L72PBTurlYbn/kikWyRMTZeZuKlTEkkvV4PpVJp7zKoAmPGSCTmq3Iq+PsqkiYvQe7xX+DRKwLV3p8A9UO1rP57mC8STXTG2HgRERERkdn0WTlIWbgB6Wt2QV23JmpsWwDPJ9rZuywih8XGi4iIiIjKTJZlZO39BskzV0Cfngm/d1+Gz7jBULhZ57BCooqKjRcRERERlUn+xQQkRUUj74ff4dnncfjPGQ913Rr2LovIKbDxMhNP6CSReOw6icaMkUjMV8Wly8hC6oL1SP9kD9RBtVFz5yJ4dGlt0xqYLxJNdMYUQke30N69e/HMM88gPDwcbdq0wahRo5CXl2ec/u2336Jv374IDw9Hz5498fnnnxcZo6CgAB999BE6dOiAFi1a4KWXXkJCQoJV6mPzRSJIksSrNZFQzBiJxHxVTLIsI3PnYSS2fQEZnx6A35TRqPv9Rps3XcwXiWaLjDncHq9Vq1YhNjYWY8eORYsWLZCamor4+HjodDoAwM8//4zx48djwIABmDJlCk6fPo2pU6fC09MTTz75pHGcuXPnIi4uDlFRUQgMDMTq1avx4osv4uDBg/Dy8ipXjbycPIkgy7IxW8wXicCMkUjMV8WTf/4SkiYtRt6P51Dlma7wn/0aVLWq26UW5otEs0XGJNmBro+ekJCAp556CitXrsTjjz9e7DwjR45EdnY2tm/fbnzs7bffxsWLFxEXFwcAuH37Nrp27YqZM2di8ODBAIC0tDR06dIF48aNw+jRoy2q79y5c5BlGeHh4XzTk9XJsgyNRgO1Ws18kRDMGInEfFUcuvRMpMz7BBkb9kH9cD1UmzcRHh1b2bUm5otEsyRj586dAwCEh4eXaX6HOtRwz549qFOnTolNV0FBAc6cOWOyZwsAIiMjcfnyZdy4cQMAcPLkSej1epP5fH190aFDBxw/flzcAhARERE5KVmvR8a2g7je9nlkbj8E/5mvou6xDXZvuogqCodqvP744w+EhIRg5cqVaNeuHcLCwjBkyBD88ccfAIDr169Do9EgODjY5HkNGjQAAOM5XAkJCfD394ePj0+R+ax1nhcRERFRRZH/x/9ws/c43H1jPjwefwz1Tm+D77ghkNQOd1YKkdNyqHfT3bt3cf78efz999+YOXMm3N3dsXr1arz88ss4evQo0tPTAQDe3t4mzzP8bJiekZFR7Hlc3t7exnnKo7ijMyVJKvZxw7SSnif6uRzXeV4bw7HFhX+2xrii6rXWuI5Yk7ONW9bnGjJm+NkZl9XZxnXEmkSOe/92zBrjlrcmjlv6c/VpmUj+YC0yN38Bl0ZBqLl/GdzbtTBOd5RlLZytyvLaVLQcOvo6LLwNK8+4pXGoxkuWZeTk5GDp0qVo1KgRAKB58+bo2rUrtmzZgoiICDtXeI9GozE59lOhUEClUhmn3c/FxQUAoNPpoNfrTaapVCpIkgS9Xm+8gMj94xqOOb2fWq0ucVylUgmlUglZlqHVak2mSZJkfK5Wqy0SHFHjlmVZgaLrUNS4hmWVJMnsZS3LuIB561CWZZN5zV1Ww7jF1WSvdWgYt7R1aK98l7YObZlvwHbbCFmWjWOoVCpuIx4wrmFZHWUbUd5ltcU2wjCt8GcktxGmy+oo2whZr0fezqNI+WAtZI0WvrNeRZUXn4GkUkKj0Tjc94jC/+Y2wnm3EY78PcLwGSlJkvE996BtROEmrSwcqvHy9vaGr6+vsekC7p2b1aRJE1y6dAm9e/cGAGRmZpo8LyMjAwCMhxZ6e3sjKyuryPgZGRlFDj80V+EXoziGF6M4hQN9P4VCAYWi+CM/C4fd3HEf9FzDG8GW45a2rEDp69Da4xreLOVZVmu/NoaaKss6tFe+y/OeE/XacBtxT0XKd0njGlSkdShJEtzd3Yt9HOA2oizjArbZRuT9egHJk5cg/7e/4DX4SVSd9gpUgf5leu79bL2NkCSJ24gyjuto24iSxnXmbYQ5TRfgYI1Xw4YNcf369WKn5efno169elCr1UhISEDHjh2N0wznbRnO/QoODkZSUhLS09NNGq2EhIQi54dZoqSV/KCVX9p0Uc/luGLHdcSanG1cR6zJ2cZ1xJo4ruPW5GzjOmJNzjauYbouOQ3Jc9cgc+tBuDRtiFoHVsC9TTOLf2d5auK4jluTs43rqDUVx6EurtGlSxekpaXh4sWLxsdSU1Px559/omnTpnBxcUGbNm1w5MgRk+fFxcWhQYMGqFOnDgAgIiICCoUCR48eNc6Tnp6OkydPolOnTuWu05JjOokexLCrnPkiUZgxEon5clyyTof0DXtxve3zyP7yO1SbNxF1vo59YNPlSJgvEs0WGXOoPV7du3dHeHg4Xn/9dbz55ptwdXXF2rVr4eLigueffx4A8Oqrr2L48OGYNWsWevXqhTNnzuDAgQOIjo42jlOjRg0MGDAACxYsgEKhQGBgINasWQMvLy8MGTKkXDXyDU8iMV8kGjNGIjFfjifvp/O4O2kxCs79A68XesN/2itQVqtq77IswnyRaKIz5lA3UAaAlJQUzJs3D8eOHYNGo8Gjjz6KyZMno2HDhsZ5vvnmGyxZsgRXrlxBrVq1MGbMGAwYMMBknIKCAkRHR2P//v3Izs7GI488gmnTphkvPW8J3kCZRDL8pYU3hyRRmDESiflyLNq7qUiZswqZ2w/BtXkoqn30JtxaNbV3WRZjvkg0SzJm7g2UHa7xcmRsvEgkfqiQaMwYicR82VZubi4uXLiAgoICuLi4ICgoCDdv3kSD+kHQbD+MlPnrAKUCflPHwHtoH0glXFzAWTBfJJotGi+HOtSQiIiIiB4sNzcX58+fN35R9PPzw9X9X8Hr8G/Q/X0N3sOegt/UMVD6le9qzkRkPWy8zMS/spBIpV22lMgamDESifmyLZ1Oj9x8LdQZech8LwZNvvsJaPYwah9dC7cWjR48gJNhvkg00Rljgi3A5otEkCSJ2SKhmDESifmyjZSUFKSnp+PK1eu4fu1fPPxbAh75+TJ0SiV+6NYctcc8C9nHFT4pKfDz87N3uVbDfJFotsgYGy8LmHuXaqKykGUZer3eohvyEZUFM0YiMV+2cfr0aVy4cAFe/9zCU99dgHdqNv4Oq4OzbRog31WNq6dO4ddff0GTJk0QGRlp73Kthvki0WyRMTZeZuK1SEgknU5X6h3ficqLGSORmC/xWgc9jNCtx4CjP+G/mlXxxbPNkFajKgoUXnBDDjp0bIOgh+rBx6findvFfJFoojPGxouIiIjIwckFGqSt3YWMhRuh9HCD6/w3cFHOgEt+Aeq5uiC06aO4euksWjQLr1CHGBJVJPyzAREREZEDyzn+MxI7v4SU99fA+/neqBu/Fa79ukKpVsLdVQUXtRJ1a3hBrXLuS8YTVXTc40VERETkgLQ37yBpxgpkf3EMbm2bIzB2FlybNgQAuOfmIiwszHgfLx8fH4SFhcHd3d3OVRNRSdh4mYkndJJIPHadRGPGSCTmyzrk/AKkrdqB1OjNUFTxQPVV01Hl2SdMvoO4u7ujVatWJs+r6IcYMl8kmuiMsfGyAJsvEkGSJN6jhIRixkgk5ss6cr49g6TJS6C59i98xgyA37svQeHlae+y7I75ItFskTEm2AK8nDyJUPiKmcwXicCMkUjMV/lorv+L5OkxyI47AbeIR1Bj04dwaRRk77IcBvNFotkiY2y8zMTLyZNIGo0GarXa3mVQBcaMkUjMl/n0eflIW/EZ0pZ8CkVVHwSunQXPZ7qyuSgG80Wiic4YGy8iIiIiO8g++gOSpi6D9uYd+I4dhKpvjYCiioe9yyIiQdh4EREREdmQ5uotJE1dipyjP8C982Ooue0juDz8kL3LIiLB2HgRERER2YA+Nx9py7YgLWYblNV8Ebj+fXj2eZyHFRJVEmy8zMSNI4nEfJFozBiJxHwVT5Zl5Bw+iaRpMdDeToLvuCGoOnEYFJ6855Y5mC8STXTG2HhZgG98EkGSJJ40TEIxYyQS81W8gsuJSJ66DDnfnIZ71zaouXMRXBrUtXdZTof5ItFskTE2XkRERERWps/OReqST5G2cjtUNaqhxuYP4fFkBP94S1SJsfGyAO/jRSLIsgytVguVSsV8kRDMGInEfN0jyzKyD3yP5Okx0CWloerrL8D39aFQuLvauzSnxnyRaLbIGBsvM/E+XiQS80WiMWMkUmXPV8E/15A0ZSlyv/sJHj07oNr7E6AOqm3vsiqMyp4vEk90xth4EREREZWDPisHqYs3IW31TqhqV0eNrR/Bs0d7e5dFRA6GjRcRERGRBWRZRva+b5E0cwX0qemo+vYI+L72HBRuPKyQiIpi40VERERkpoK/ruDu5CXIO/krPCM7wv/9CVDXq2nvsojIgbHxMhNP6CSRVCq+JUksZoxEqgz50mdmI+XjDUiP3Q11vZqouX0hPLq1sXdZlUJlyBfZl+iMMcEWYPNFIkiSxGyRUMwYiVTR8yXLMrI+/wrJs1ZCn5kNv0kj4fvqYEiuLvYurVKo6Pki+7NFxth4WYCXkycRZFmGXq+HQqFgvkgIZoxEqsj5yr9wGUlR0ciL/wOeT3WG/5zxUNcJtHdZlUpFzhc5BltkjI2XmXgpUxJJp9NBoVDYuwyqwJgxEqmi5UuXnonUj9Yjff1eqIProObuaHg8/qi9y6q0Klq+yPGIzhgbLyIiIqJCZL0emTuPIGXOKuiz8+A3bQx8xwyE5KK2d2lE5MTYeBERERH9n/yzf987rPCn86jSvzv8Z42DqmaAvcsiogqAjRcRERFVerq0TKR8GIuMTfuhDnkItfYtg3uHlvYui4gqEDZeZuIJnSQSj10n0ZgxEskZ8yXr9cjcFofkuash52vgP3scfEY+C0nNr0iOxhnzRc5FdMa4VbEAmy8SQZIk3qOEhGLGSCRnzFfe738hadJi5P96EVUG9oD/jFehqlHN3mVRMZwxX+RcbJExJtgCvJw8iVD4ipnMF4nAjJFIzpQvXUr6vcMKN38BlybBqPXFcri3a27vsqgUzpQvck62yBgbLzPxcvIkkkajgVrNq2aROMwYieTo+ZJ1OmRsOYCUD9YCOj2qffA6vF96BhL3pDgFR88XOT/RGeOWhoiIiCq8vF/+RNKkaOT/8T94DekFv+ljoaruZ++yiKgSYeNFREREFZYuKRXJ769B5raDcAl/GLXjVsHtsTB7l0VElRAbLyIiIqpwZJ0OGRv3I2VeLCBJqLbgLXgP7wtJqbR3aURUSbHxIiIiogol98xZJEUtQcGfl+A1tA/8p46B0t/X3mURUSXHxstMkiTxajokhCRJUKvVzBcJw4yRSI6QL+1/KUievQpZOw/DtWVj1D68Gm6PNLFbPWQ9jpAvqthskTE2XkQOhB8oJBozRiLZK1+yVov0dXuR+tE6QK1CwOJ34fVCH0i84W6Fwu0XiSY6Y2y8LMD7eJEIsixDp9NBqVQyXyQEM0Yi2StfuT/8jqTJ0Si4eAXeI/rCb/JoKP18bPb7yTa4/SLRbJExNl5m4n28SCS9Xg8lT/wmgZgxEsmW+dLeTkLy7JXI2v0VXFs1QZ2vYuHaPNQmv5vsg9svEk10xth4ERERkdOQNVqkx+5GyoL1kNxdEbA0Cl5DevGwQiJyeGy8iIiIyCnknvwVd6OiofnnOrxfegZ+UaOg9PWyd1lERGXiUH8e2rNnD0JDQ4v8t3DhQpP5du3ahZ49eyI8PBx9+/bFsWPHioyVmZmJKVOmoHXr1mjZsiVef/11/Pfff7ZaFCIiIrIS7a3/cHvUTNzq9waUvt6o8806BMx/k00XETkVh9zj9cknn8DL6/9vTAMDA43/PnjwIKZPn46xY8eibdu2iIuLw/jx47F161a0aNHCON/EiRNx6dIlzJo1C66urliyZAlGjx6Nzz//HCqV5YvNEzpJJB67TqIxYySStfMlF2iQtnonUhdtgsLTHdVXTEWVgT35WVxJcftFoonOmEM2Xk2bNoWfn1+x05YtW4bevXtj4sSJAIC2bdvi77//xooVKxAbGwsA+O2333Dy5EmsW7cOERERAICgoCBERkbi6NGjiIyMLFd93OCTCJIk8UOFhGLGSCRr5yvn2I9ImrwEmqu34DOqP6q+9zKU3lWsNj45F26/SDRbZMyhDjV8kMTERFy9ehW9evUyeTwyMhLx8fEoKCgAABw/fhze3t7o0KGDcZ7g4GA0btwYx48fL3cdvLIhiSDLMvR6PfNFwjBjJJK18qW5cQe3X5yGfwe9DWV1P9Q5th7V5r7OpquS4/aLRLNFxhyy8erTpw8aN26Mbt26Yc2aNdDpdACAhIQEAPf2XhXWoEEDaDQaJCYmGucLCgoqsmcqODjYOIal+IYnkbRarb1LoAqOGSORypMvOb8AqYs3I7H9C8j7+Tyqr5mJWvtj4No42IoVkjPj9otEE50xhzrUMCAgABMmTEDz5s0hSRK+/fZbLFmyBHfu3MGMGTOQnp4OAPD29jZ5nuFnw/SMjAyTc8QMfHx8cP78+XLXWVzzJUlSiU2ZoQEsbbqo53Jc53ltZFk2eczRltUZ1mFlHbeszzVkzPCzMy6rs43riDWJHPf+7VhZx83+Oh5JU5ZCm3gbPmMGouo7L0JRxcOhl9WZxnXEmswdt3C2nKFeZ67J2ca1Vk2Ft2HlGbc0DtV4dezYER07djT+HBERAVdXV2zatAljx461Y2WmNBqNyd40hUJhvGCHRqMpMr+LiwsAQKfTQa/Xm0xTqVSQJAl6vd64Z+/+cWVZLnZctVpd4rhKpRJKpRKyLBfp3iVJMj5Xq9UWCY6occuyrEDRdShqXMOySpJk9rKWZVzAvHUoy7JJ/eYuq2Hc4mqy1zo0jFvaOrRXvktbh7bMN2C7bUTh5VKpVNxGPGBcw7I6yjaivMtqi22Eod7Cn5GlrUP55l2kzFyOnEMn4dqhJaqtnwN1SH3oAMg6HbcR/4ffI0wbL24jnHcb4cjfIwz/liTJ+J570DaicJNWFmY3Xjdu3MA333yDX3/9FZcvX0ZqaiokSULVqlURHByMRx55BF27dkXdunXNHbpYvXr1wvr163Hx4kX4+PgAuHep+ICAAOM8GRkZAGCc7u3tjdu3bxcZKz093ThPeRgCUtK0khQO9P0UCgUUJdz8sXDYzR33Qc8t7QqPosYtbVmB0tehtcc1vI7lWVZrvTbFbcRKUpHWob3yXZ73nKjXRvQ2wpCxwtswbiNKH9eRthH3c8R1qFKpinxGFrcO9bn5SF++DWkxW6Hw80X1T2bD86nOxX62chvx/1Xm7xGFv1xzG1G2cR1xG+HI3yMMn5GFl+9By2pO0wWY0XgdO3YM69evxy+//AJZllGvXj3UqVMHISEhkGUZGRkZ+Ouvv3D06FHMnz8frVq1wsiRI9GlSxezCipNcPC947wTEhKM/zb8rFarjc1ecHAw4uPji3ShV65cQUhISLlqkCTJ+F9x0x70XEumlee5HFfsuNauqfCGwdGW1VnWYWUc15znKpVKk22Ysy2rs43riDWJHPf+fBX33Owjp5A0dSm0t+7C99XBqPrmcCiqeAirieM6Zk2WjGv4jHSWep21Jmcb15o1GbZh1qipOGVqvAYNGoS//voL3bp1w5IlS9C+fXtUqVL81YWysrJw6tQpHDlyBBMnTkSjRo2wY8cOswsziIuLg1KpRJMmTRAQEID69evj8OHD6N69u8k87dq1M+4W7NSpE1auXIn4+Hi0b98ewL2m68KFCxg1apTFtRhYsqKJHkSSpHLdY47oQZgxEulB+dIk3EDStGXI+Soe7p0fQ83tC+HSsJ4NKyRnxu0XiWaLjJVp9DZt2mDlypWoVq3aA+etUqUKevbsiZ49e+Lu3bvYvHlzmYsZOXIk2rRpg9DQUADAN998g507d2L48OHGQwsnTJiAd955B/Xq1UObNm0QFxeHs2fPYsuWLcZxWrZsiYiICEyZMgWTJk2Cq6sroqOjERoaih49epS5HiIiIioffU4e0pZuQerybVBV90Pgxg/gGdmRf8QkokpHki25JIcgc+fOxYkTJ3D79m3o9XrUr18fAwcOxLBhw0w20Lt27UJsbCxu3bqFoKAgvPXWW0UOaczMzMS8efPw1VdfQavVIiIiAtOmTUNgYKDF9Z07dw6yLCM8PJwfGGR1huPXSzuHkKg8mDES6f58ybKM7LgTSJ4eA+2dZFQd/zx83xgKhYebvUslJ8TtF4lmScbOnTsHAAgPDy/T/A7VeDk6Nl4kEj9USDRmjEQqnC9NQiKSJi9F7rEf4dG9Lap98AbUwXXsXSI5MW6/SDRbNF5lPpDxzz//LOusRk2bNjX7OUREROSc9Dm5SIlZj7RVO6CqFYAaW+bDo0d7flEmIoIZjdezzz5r1oZTkiRcuHDBoqKIiIjIeciyjKwvjiF5+nLoU9NR9c3h8B3/PBTurvYujYjIYZS58Zo3b94D58nLy8POnTtx8eLFchVFREREzqHg76tImrwEucd/gVuP9gj44HW41K9t77KIiBxOmRuvfv36lTitoKAA27dvR2xsLO7evYvHHnsMEyZMsEqBjoaHS5BIpd0AkMgamDGyFn1WDlIWbkD6ml1Q162JGts+gkf3dvYuiyowbr9INNEZK9fF6gsKCvDZZ5/hk08+wd27d9G6dWssXrwYjz32mLXqc0hsvkgE5opEY8bIGmRZRtbeb5A8cwX06Znwe/dl+IwbDIUbDyskcbj9ItFskTGLGq+CggJs27YN69atw927d9GmTZtK0XAZyLLMDQBZnSzL0Ol0Re6aTmQtzBiVV/7FBCRFRSPvh9/h2edx+M8ZD3XdGgCYLxKL+SLRbJExsxqv/Px84x6upKQktGnTBtHR0Xj00UeFFOeIePV9Ekmv10OpVNq7DKrAmDGyhC4jC6kL1iP9kz1Q16+FmjsXwaNL6yLzMV8kEvNFoonOWJkbr40bN+KTTz5BcnIy2rZti6VLl6JVq1bCCiMiIiL7kmUZWbuOIHnWKuizc+E3ZTR8xw6C5MJzbYiIzFXmxmv+/PmQJAmNGzdGgwYNcOjQIRw6dKjU50ybNq3cBRIREZHt5Z+/dO+wwjNn4fl0V1Sb8xpUtarbuywiIqdl1qGGsizjwoULZbo/lyRJbLyIiIicjC49E6nz1yF9/V6oG9ZFzc+j4dGp8pxSQEQkSpkbr7/++ktkHU6DJ3SSSDx2nURjxqgksl6PzO2HkPz+asi5+fCf+Sp8Rg+ApC7732iZLxKJ+SLRRGesXJeTr6zYfJEIkiTxQ4WEYsaoJPl//A93o6KR//OfqPLsE/CfNQ6qGtXMGoP5IpGYLxLNFhlj42UBXk6eRJBl2Zgt5otEYMbofrrUDKR8uBYZm76AS+Mg1NofA/f2LSwai/kikZgvEs0WGbO48dq/fz8+//xz3LhxA+np6UUusy5JEn755ZdyF+hoeDl5Ekmr1Qq/azpVbswYAf93WOHWA0ieuxbQaOH//gT4jOwHSVW+v8cyXyQS80Wiic6YRVvYjz/+GOvXr0dgYCDCwsLg5eVl7bqIiIhIgLxfLyApagnyf7uIKoOehP+MsVAF+tu7LCKiCs+ixmvXrl3o3LkzVqxYAYVCYe2aiIiIyMp0yWlInrsGmVsPwqVJA9Q6sALubZrZuywiokrD4mMKHn/8cTZdREREDk7W6ZCx+QukfBgLyDKqzZsI7xF9y31YIRERmceizqlz584V8vytsuAJnSQS80WiMWOVS95P53GjxxgkvbcYnpGdUDd+G3xG9hfWdDFfJBLzRaKJzpgkW3C1iMzMTIwdOxahoaF49tlnUbNmzWL3fvn6+lqjRodx7tw5AEB4eLidKyEiIiqZ9m4qUt5fjczP4uDSLAQBH70Ft0eb2rssIqIKxdzewKI/ebm7u6Nly5ZYt24dPvvssxLnu3jxoiXDExERkQVkrRYZG/YhZf46QKlAtYXvwHtoH0i8/xERkd1Z1HjNmTMHu3btQvPmzdG8efNKd1VD3seLRJBlGVqtFiqVivkiIZixii339FkkRS1GwYUEeA97Cn5Tx0Dp52Oz3898kUjMF4lmi4xZ1HgdOnQITz/9NObPn2/tehwe7+NFIjFfJBozVvFobychec4qZO06CtdHGqP20bVwa9HILrUwXyQS80Wiic6YRY2XSqVC8+bNrV0LERERlZGs0SJ93edI+Wg9JFc1AqInwev5SEi84jARkUOyaOvcu3dvHDt2zNq1EBERURnknvoNiV1fRvLMlfAa2BP14rfdO5eLTRcRkcOyaI9Xr169MHfuXIwZM8Z4VUNlMSfuNm3KKygRERFZi/Z2EpJnrkDWnq/h+lgY6nwVC9dmIfYui4iIysCixuuFF14AcO+qhSdOnCgy3XDxiYp4VUOe0EkiqXhDUxKMGXNOcoEGaWt3IXXhRig83BAQMwVeg3o63B4u5otEYr5INNEZs2j0efPmWbsOp8Lmi0SQJInZIqGYMeeUc/xnJEUtgeZyInxG9kfVSS9D6eN4VxNmvkgk5otEs0XGLGq8+vXrZ+06nAovJ08iyLIMvV4PhULBfJEQzJhz0d68g6QZK5D9xTG4tW2OwNhZcG3a0N5llYj5IpGYLxLNFhnjPlsz8VKmJJJOp4PCwQ4dooqFGXN8cn4B0lbtQGr0ZiiqeKD6qumo8uwTTvFlk/kikZgvEk10xso08owZM5CYmGj24NevX8eMGTPMfh4REVFllPPtGSR2GoGU+evgPeJp1Du9DV4DejhF00VERKUr0x6vf//9F7169ULbtm0RGRmJdu3aoWbNmsXOe+PGDcTHx+PQoUM4c+YMOnToYNWCiYiIKhrN9X+RPD0G2XEn4NahJWps+hAujYLsXRYREVlRmRqv2NhY/PLLL1i/fj1mzJgBnU4HX19f1K5dGz4+PpBlGenp6bhx4wYyMjKgVCrRqVMnbNq0CY8++qjoZSAiInJK+rx8pK34DGlLPoXC1xvV185ElWe6cQ8XEVEFVOZzvFq1aoVWrVohJSUFx44dw++//46EhATcvn0bAODr64sePXqgRYsW6Ny5M/z9/YUVbU/8MCSRirsfHpE1MWOOI/voD0iaugzaG7fh++pgVH1rBBRVPOxdVrkwXyQS80Wiic6YJPNqEWV27tw5AEB4eLidKyEiImeluXoLSdOWIefIKbg//iiqzZsIl4cfsndZRERkJnN7A17V0AK8nDyJUPhvIMwXicCM2Zc+Nx9py7YgLWYblNV8Ebj+fXj2ebzCvBbMF4nEfJFotsgYGy8zcQchiaTRaKBWq+1dBlVgzJjtybKMnMMnkTQtBtrbSfAdNwRVJw6DwtPd3qVZHfNFIjFfJJrojLHxIiIiEqTgciKSpy5Dzjen4d61DWruXASXBnXtXRYREdkBGy8iIiIr02fnInXJp0hbuR2qGtVQY/OH8HgygodIERFVYmy8iIiIrESWZWQf+B7J02OgS0pD1ddfgO/rQ6Fwd7V3aUREZGdsvMzEv1aSSMwXicaMiVNw6TqSJi9B7nc/waNHe1Sb+zrUQbXtXZZNMV8kEvNFoonOmKKsMy5evBh//fWXyFqcBt/4JIIkSVCr1cwXCcOMiaHPykHynNVI7DQCmqs3UWPrfNTc+lGlbLqYLxKF+SLRbJGxMjdea9euxT///GP8OTU1FY0bN0Z8fLyQwoiIiByZLMvI2vsNrrcfivTYXaj69gjUPbEZnj062Ls0IiJyQOU61LCyXlqd9/EiEWRZhlarhUqlYr5ICGbMegr+d+XeYYUnfoVnZEf4vz8B6no17V2WXTFfJBLzRaLZImNl3uNla9nZ2ejUqRNCQ0ONd4U22LVrF3r27Inw8HD07dsXx44dK/L8zMxMTJkyBa1bt0bLli3x+uuv47///it3XZW12STbYL5INGasfPSZ2UiasRyJnV+C9uZ/qLl9IWps+rDSN10GzBeJxHyRaKIz5rCN18qVK6HT6Yo8fvDgQUyfPh29evVCbGwsWrRogfHjx+P33383mW/ixIk4deoUZs2ahYULF+LKlSsYPXo0tFqtjZaAiIgqClmWkbn7KK63ewEZm/bDb9JI1D2+CR7d2ti7NCIichJmHWp48+ZN/PnnnwDu7VECgGvXrsHb27vY+Zs2bWpRUZcvX8a2bdswadIkzJw502TasmXL0Lt3b0ycOBEA0LZtW/z9999YsWIFYmNjAQC//fYbTp48iXXr1iEiIgIAEBQUhMjISBw9ehSRkZEW1UVERJVP/oXLSIqKRl78H/B8qjP854yHuk6gvcsiIiInY1bjtXTpUixdutTksdmzZxeZz3AO1MWLFy0qau7cuRgyZAiCgoJMHk9MTMTVq1fx7rvvmjweGRmJBQsWoKCgAC4uLjh+/Di8vb3RocP/P8E5ODgYjRs3xvHjx9l4ERHRA+nSM5H60Xqkr98LdXAd1NwdDY/HH7V3WURE5KTK3HjNmzdPZB1Ghw8fxt9//42YmBjj3jWDhIQEACjSkDVo0AAajQaJiYlo0KABEhISEBQUVOTEuODgYOMYluIJnSSSSsVb65FYzNiDyXo9MnceQcqcVdBn58Fv2hj4jhkIyUVt79IcHvNFIjFfJJrojJV59H79+omsAwCQm5uL+fPn480330SVKlWKTE9PTweAIoc2Gn42TM/IyICXl1eR5/v4+OD8+fNWqfX+k+8kSSrxhDxDs1badFHP5bjO9dpIkuSwy+os67AyjmvOcwvP74zLKnrc/HP/ICkqGvk/nYdnv26oNvs1qGoGQJblEt+zzrqs1h63pDG4jbD/uI5YkyXjGj4jnaVeZ63J2ca1Zk3372CxZNzSONSfDlatWgV/f388++yz9i6lRLIso6CgwOSFUSgUxg5Zo9EUeY6LiwsAQKfTQa/Xm0wzXLJSr9cXuZiIYVxZlosdV61WlziuUqmEUqk0XhqzMMMN4gBAq9UWCY6occuyrEDRdShqXMOySpJk9rKWZVzAvHVo+GLn6uoKSZLMXlbDuMXVZK91aBi3tHVor3yXtg5tmW/AdtsIQ8YkSYJKpeI2otC4urRMJH+4Flmbv4SqYV0E7FwItw4tobRwWUVsI8q7rKK3EYU/Hwt/RnIbYbqsjryNsNayihhXlmXj8vB7hHNuI0pbVkfYRhg+IxUKhfE996BthOEztawcpvG6efMm1q9fjxUrVhgv3JGTk2P8f3Z2Nnx8fADcu7BHQECA8bkZGRkAYJzu7e2N27dvF/kd6enpxnnKo7S7WhtejOIUDvT9FAoFFIriLzJZOOzmjvug55a2S1XUuKUtK1D6OrT2uIbXsTzLaq3X5v4NR2VZh/bKd3nec6JeG9HbCEPGCm/DKvs2QtbrkbHlAJLnroacr4HfrHHwGdkfkvreOI60jbifo6zDwgw1F/6M5Dai7OMC/B5R0riFPyMr0mdgSeMaVLRthCN/jzBkrPDyPWhZzWm6AAdqvG7cuAGNRoMxY8YUmTZ8+HA0b94cixYtAnDvXK/g4GDj9ISEBKjVatStWxfAvXO54uPji3ShV65cQUhISLlrvf+veYUff9DzLJlWnudyXLHjWrum4r6sWPN3OuK4jliTs41rznMN26/CjZeImhxl3NzcXFy4cAHAvfODb968idq1a+PmzZuol61H5qyVyP/lAqoM7AH/Ga9CVaOa8Joq8rj358sRauK4jlmTJeOWZbvlSPU6a03ONq41a7p/+1WemorjMI1X48aNsXnzZpPHLl68iHnz5mH27NkIDw9H3bp1Ub9+fRw+fBjdu3c3zhcXF4d27doZdwt26tQJK1euRHx8PNq3bw/gXtN14cIFjBo1ynYLRUREdpWbm2s8t9fPzw/nz5+Hp1ZG1uwVSPrhIlyaBKPWF8vh3q65nSslIqKKzmEaL29vb7RpU/yNKJs2bWq8J9iECRPwzjvvoF69emjTpg3i4uJw9uxZbNmyxTh/y5YtERERgSlTpmDSpElwdXVFdHQ0QkND0aNHD5ssDxER2U9ubi4uXboESeGC5NR0eFXxhKzTw+/4OWinboKfRgP3qaNQ87XnIfFKaUREZANO92nTp08f5ObmIjY2FmvXrkVQUBCWL1+Oli1bmsy3ZMkSzJs3DzNmzIBWq0VERASmTZtW7stEWrJbkaisSjsumsgaKkPGUlJScOPGDcSfPo3EdBcgKxXq/91E1qo4NLz+H84/XB8XOjdGl3ZNkJ+YCB8fH/j5+dm77AqhMuSL7If5ItFEZ0ySLbkW4v/RaDRISEhAZmZmsZdUfOyxx8pVnKM5d+4cACA8PNzOlRARUUni4uJw/vx55OfnQ8oswKOn/8bDF28hJcALZzqFIqmGL2QAbm5uUKuUaNKkCSIjI+1dNhERORlzewOLdv/o9XosWrQI27ZtQ15eXonzXbx40ZLhHZ65l44kKovi7ntDZE2VIWMpKSmoXbs2ZD2QsfkAmv/wFwAZZx5vgrzItribeAf/5XqgupcWXbp2QmCAv1WudkuVI19kP8wXiWaLjFnUeK1evRrr1q3D4MGD0apVK7z33nt455134O3tjW3btkGSJLz77rvWrtUhlGMHIdEDGS71TSRKRc/Y6dOncfvoSTQ7+gdC72bgUpNa+L1dQxR4uML17n/w8XZFtx6dcfXSWYQ0DOYhhlZW0fNF9sV8kWiiM2bRgYx79+5Fr169MHv2bHTs2BHAvQtgDBo0CDt37oQkSTh9+rRVCyUiIiqN9r8UhO87g8e3nkAVXx/EDXkcX7SPQJ67G3yrVkXHjh3h7+eHujW8oFYVf08XIiIiUSxqvG7fvo22bdsC+P93Uy8oKDD+3LdvX+zfv99KJRIREZVM1mqRtmYXEts+D+33vyBg8bsI2L8Uvq0b4dle7VCtmj9aNG+ORo0a4ZFHHoGPjw/CwsLg7u5u79KJiKgSsehQQ19fX+Tk5AAAPD09UaVKFSQmJprMk5GRUf7qiIiISpH7w+9ImhyNgotX4D2iL/wmj4bSzwcpKSlQq5QIruuP/25WRVhYGPz8/IyHFvIQQyIisjWLGq8mTZoYr+IBAG3atMGmTZvQuHFjyLKMzZs3IzQ01GpFEhERFaa9nYTk2SuRtfsruLZqgjpfxcK1+f//3HF3d0dYWBj3bhERkcOwqPEaNGgQ9u7di4KCAri4uODNN9/ECy+8gKFDh0KWZfj4+CAqKsratToESZJ4NR0SQpIkqNVq5ouEqQgZkzVapMfuRsqC9ZDcXRGwNApeQ3pBuu/eK+7u7sbL+3Lvlm1UhHyR42K+SDRbZKxc9/EqLDMzE2fOnIFSqUTLli3h6+trjWEdCu/jRURkP7knf8XdqGho/rkO75eegV/UKCh9vexdFhERVVI2uY9Xcby8vNC9e3drDefQeB8vEkGWZeh0OiiVSuaLhHDWjGlv/YfkmSuQte9buLUOR+DXn8A1/GF7l0X3cdZ8kXNgvkg0W2TMoqsaduvWDYMHD0ZCQkKx07/++mt069atXIU5Kt7Hi0TS6/X2LoEqOGfKmFygQWrMVlxvNxS5p35H9eVTUevACjZdDsyZ8kXOh/ki0URnzKLG6+bNm/jzzz8xcOBAfP3110Wm5+Tk4NatW+UujoiIKqec735C4uMvIuWDWHgP64O6p7fCa/CT/Es3ERE5LYsaLwCYPHkyHnvsMUyYMAFLliyxYklERFRZaW7cwe2XpuHfgW9BGVAVdb5dh2pzX4fSu4q9SyMiIioXi8/x8vb2xurVq7F8+XKsXLkSFy5cwKJFi+DlxROdiYjIPHJ+AdJWbEfqks1QeFdB9TUzUaVfN+7hIiKiCsPiPV4G48ePx+rVq/HHH39gwIAB+Oeff6xRl8PilwASSaWy2vVuiIrliBnL/vo0EjuOQMrH6+H9cj/UO70NXv27c3vrhBwxX1RxMF8kmuiMlbvxAoBOnTph9+7dcHd3x6BBg/DNN99YY1iHxS8DJIIkSVAoFMwXCeNoGdNcu4V/h0/G7efehapOddT9bgOqzXoNiioe9i6NLOBo+aKKhfki0WyRMas0XgBQt25d7NixAz169MCRI0esNaxD4pUNSQRZlqHX65kvEsZRMqbPzUfKxxuQGDEM+b//D4GfzEHNz5fAJTTIrnVR+ThKvqhiYr5INFtkzKL9aZs3b0bDhg2LPO7q6oqPPvoIkZGRSElJKXdxjohveBJJq9VCrVbbuwyqwOydsewjp5A0dSm0t+7C99XBqPrmcO7hqkDsnS+q2JgvEk10xsxuvHJzczF//nwMHDgQzz33XLHzPP744+UujIiIKg7NlZtImroUOV/Fw73zY6i5fSFcGtazd1lEREQ2Y3bj5e7ujhs3bvAYWyIieiB9Th7Slm1B2vLPoAyoisANc+HZuxM/Q4iIqNKx6Byvjh074uTJk9auhYiIKghZlpF18DgSI4YhNWYbfF97DnVPbUGVPo+z6SIiokrJosZr3LhxuHr1Kt599138/PPPuHPnDtLS0or8VxHxCwOJpFBY7Xo3RMWyRcYKLl/Hv4PfwZ0Xp8IltD7qndgMv8mjoPBwE/67yb64DSORmC8STXTGLLq4Ru/evQEAly5dwoEDB0qc7+LFi5ZV5eDYfJEIkiTxHiUklOiM6bNzkbp4E9JW7YCqVgBqbJkPjx7tuc2sJLgNI5GYLxLNFhmzaPTXXnuNH6REAsiyzPcWCSUiY7IsI/uL75A0Yzn0KWmo+uZw+I5/Hgp3V6v+HnJ83IaRSMwXiSY6YxY1XhMmTLB2HU5DlmW+8UkIWZah0WigVquZLxJCRMYK/r6KpMlLkHv8F3g8GYFqcydA/VAtq4xNzoXbMBKJ+SLRbJExq+xPy8vLAwC4ufH4fSKiykCflYOUhRuQvmYXVHVqoMa2BfB8op29yyIiInJYFjdet27dQkxMDL7//nukpqYCAKpWrYrHH38c48ePR+3ata1WJBEROQZZlpG19xskz1wBfXom/N59GT7jBkPhxsMKiYiISmNR43X58mU8//zzyMzMRPv27dGgQQMAQEJCAvbv349jx45h27ZtCA4OtmqxRERkP/kXE5A0eQnyTv0Gz96Pw//98VDXrWHvsoiIiJyCRY3XokWLoFAosHfvXoSGhppM+/vvv/Hiiy9i0aJFWLFihVWKJCIi+9FlZCH14w1Ij/0c6vq1UHPnInh0aW3vsoiIiJyKRY3XTz/9hJdeeqlI0wUAISEheOGFF7Bx48by1uaQeEIniaRWq+1dAlVw5mRMlmVk7TqC5FmroM/Ohd+U0fAdOwiSC3NKxeM2jERivkg00RmzqPHSarWlXkjD3d0dWq3W4qIcHZsvEoG5ItHMyVj++UtIiopG3pmz8Hy6K6rNeQ2qWtUFVkfOjtswEon5ItFskTGLbs/cuHFj7Nq1C5mZmUWmZWVlYffu3WjSpEm5i3NUsizbuwSqgGRZhlarZb5ImLJkTJeeiaTJS3Cj20joUtNR8/No1PhkNpsueiBuw0gk5otEs0XGLL6P1+jRo9GrVy/0798f9evXBwBcuXIFe/fuRVpaGmbMmGHNOh0G3/Akkl6vh1KptHcZVIGVlDFZr0fm9kNIfn815Nx8+M98FT6jB0BSW+WuI1RJcBtGIjFfJJrojFn0idquXTusXbsWCxYswNq1a02mNW7cGB9//DHatm1rlQKJiEis/D/+h7tR0cj/+U9UefYJ+M8aB1WNavYui4iIqEKx+E+Z7du3x759+3D37l3cunULAFCrVi0EBARYrTgiIhJHl5qBlHmxyNi4Hy6NglBr3zK4d2hp77KIiIgqpDI3XosXL0ZkZCQaNWpk8nhAQACbLSIiJyLr9cjcdhDJc9cCGi38358An5f78bBCIiIigcp8cY21a9fin3/+Mf6cmpqKxo0bIz4+XkhhjopX1SGReOw6iaY9+w9u9RqLu299DI/u7VA3fit8XxnIpousgtswEon5ItFEZ6xcn7SV9UITbL5IBEmS+KFCwuiS05D8wVpkbjkAlyYNUOvACri3aWbvsqgC4TaMRGK+SDRbZIx/4rSALMtsvsjqZFk2Zov5ImuRdTpkbP4CKR/GArIM/w/fgPeIvlDwRqRkZdyGkUjMF4lmi4yx8TJTZd3LR7ah1WqF3zWdKo+8n87jblQ0Cs7+Da/ne8Nv6hjofatAUnHTT2JwG0YiMV8kmuiMmfXpe/PmTfz5558AYLx58rVr1+Dt7V3s/E2bNi1neUREZC7t3VSkvL8amZ/FwaVZCGofWg23R5tClmXoNRp7l0dERFQpSXIZd+E0atSoyG63kg65Mzx+8eJF61TpIM6dOwdZlhEeHs7d3GR1sixDo9FArVYzX2QRWatFxoZ9SJm/DlBI8Jv2CryH9oH0f8esM2MkEvNFIjFfJJolGTt37hwAIDw8vEzzl3mP17x588o6KxER2Vju6bNIiopGwYXL8B72FPymjIbS39feZREREdH/KXPj1a9fP5F1OA3+lYVEYr7IXNo7yUieswpZO4/A9ZHGqH1kDdxaNi5xfmaMRGK+SCTmi0QTnTGeYW0BvvFJBEmSeNIwlZms0SJ93R6kLlgPqFUIWPwevF7oDUlR8u0ZmTESifkikZgvEs0WGSvzDZRt4fvvv8fQoUPRtm1bhIWFoVu3bpg3b57xQh4G3377Lfr27Yvw8HD07NkTn3/+eZGxCgoK8NFHH6FDhw5o0aIFXnrpJSQkJNhqUYiIhMk99RtudBuJ5JkrUGVAD9Q7vQ3ew54qtekiIiIi+3KoPV5paWlo1qwZhg0bBl9fX/zzzz+IiYnBP//8g/Xr1wMAfv75Z4wfPx4DBgzAlClTcPr0aUydOhWenp548sknjWPNnTsXcXFxiIqKQmBgIFavXo0XX3wRBw8ehJeXV7nq5H28SARZlqHVaqFSqZgvKpb2dhKSZ65A1p6v4fpYGOp8FQvXZiFlfj4zRiIxXyQS80Wi2SJjDtV4Pf300yY/t2nTBi4uLpg+fTru3LmDwMBArFq1Cs2aNcOcOXMAAG3btkViYiKWLVtmbLxu376N3bt3Y+bMmRgwYACAe1cb6dKlC7Zv347Ro0dbXCPv40UiMV9UHLlAg7S1u5C6cCMUHm4IiJkCr0E9LdrDxYyRSMwXicR8kWiiM+bwx6X4+voCADQaDQoKCnDmzBmTPVsAEBkZicuXL+PGjRsAgJMnT0Kv15vM5+vriw4dOuD48eM2q52IqLxyjv+MxM4vIeX9NfB+vjfqxm+F95BePKyQiIjIyTjkJ7dOp0N+fj7+/PNPrFixAl27dkWdOnVw/fp1aDQaBAcHm8zfoEEDADCew5WQkAB/f3/4+PgUmY/neRGRM9DevIPbI2fg32ffhNLPB3W+XYdqH74BpU/5DpUmIiIi+3CoQw0NunTpgjt37gAAOnbsiEWLFgEA0tPTAQDe3t4m8xt+NkzPyMgo9jwub29v4zzlUdxuSEmSStw9aThOtLTpop7LcZ3ntZFl2eQxR1tWZ1iHFWFcOb8A6Wt2InXxZiiqeCBgxTR4DexR4u81pyZDxgw/23tZK8O4jliTyHHv345ZY9zy1sRxHbMmc8ctnC1nqNeZa3K2ca1VU+FtWHnGLY1DNl5r165Fbm4uLl26hFWrVmHs2LHYsGGDvcsCcG9FazQak5PuFAoFVKp7q1Kj0RR5jouLC4B7e/L0er3JNMMJfHq9HjqdzmSaYVxZlosd13DJy+LGVSqVUCqVxhMF718Gw3O1Wm2R4IgatyzLChRdh6LGNSyrJElmL2tZxgXMW4eF3+iWLKth3OJqstc6NIxb2jq0V75LW4e2zDfw/7cRWV/HI2VaDLTXbqHKyP7weWs4XKr6GNdvebcRhpo1Gg1UKhW3EQ8Y17CsjrKNKO+y2mIbYRi78LaM2wjTZS3PNqIyf4+QZdm4jriNcN5thCN/jzAsk1arNb7nHrSNuP+724M4ZOPVqFEjAEDLli0RHh6Op59+Gl999RUaNmwIAEUuL5+RkQEAxkMLvb29kZWVVWTcjIyMIocfWsLwYhSntOv/Fw70/RQKBRQlnLNROOzmjvug5xb+sLTVuKUtK1D6OrT2uIY3S3mW1dqvjaGmyrIO7ZXv8rznrL0ONYm3kTw9BtkHj8OtQ0vU2PgBXBoFWa1ebiMsH9cRtxEGjrYOJUkq9vOR24iyjwvwe8SDxpUkiduIMo7raNuIksZ15m2EOU0X4KCNV2GhoaFQq9W4fv06unbtCrVajYSEBHTs2NE4j+G8LcO5X8HBwUhKSkJ6erpJo5WQkFDk/DBLFbeiH7TyS5su6rkcV+y41qxJlmXo9XrjG9nRltUZ1qGzjavPy0f6iu1IXfopFD5eqL52Jqo8003Y9uX+jFlrXHOnVaZxHbEmkct6f77sXRPHddyazB23uO2XNca1xjR7PZfjWremwhmzRk3FcciLaxT2xx9/QKPRoE6dOnBxcUGbNm1w5MgRk3ni4uLQoEED1KlTBwAQEREBhUKBo0ePGudJT0/HyZMn0alTp3LVY8nxnERldf/ueaq4so/+gMSOI5CycAN8Rj2LevFb4dWvu0UbcnMwYyQS80UiMV8kmuiMOdQer/HjxyMsLAyhoaFwc3PDX3/9hXXr1iE0NBTdu3cHALz66qsYPnw4Zs2ahV69euHMmTM4cOAAoqOjjePUqFEDAwYMwIIFC6BQKBAYGIg1a9bAy8sLQ4YMsdfiERFBc/UWkqYtQ86RU3B//FHU3PYRXB5+yN5lERERkWAO1Xg1a9YMcXFxWLt2LWRZRu3atTFw4ECMHDnSeNz4o48+ipiYGCxZsgS7d+9GrVq1MHfuXPTq1ctkrGnTpsHT0xOLFi1CdnY2HnnkEWzYsKHYqx0SEYmmz81H2rItSIvZBmU1XwSufx+efR4XvoeLiIiIHIMk89i5Mjt37hxkWUZ4eDi/LJHVGa7KY7i6D1UMsiwj5/BJJE2LgfZ2EnzHDUHVicOg8HS3Sy3MGInCfJFIzBeJZknGzp07BwAIDw8v0/wOtcfLGfDNTiKVdNUdck6ahBtImrIUOd+chnvXNqi5cyFcGtSza03MGInEfJFIzBeJJjpjbLwswOaLRJAkiR8qFYQ+Jw+pSz5F2orPoAr0R41NH8CjV0e7bzuYMRKJ+SKRmC8SzRYZY+NlAXNvlkZUFoXvls58OSdZlpF94Hskz1gO3d1UVH39BfhOeAEKDzd7lwaAGSOxmC8Sifki0WyRMTZeZuIpcSSSVqst9UZ+5LgKLl1H0uQlyP3uJ3j0aI9qc1+HOqi2vcsqghkjkZgvEon5ItFEZ4yNFxFROeizcpC6eDPSVu+AqnZ11Ng6H549Oti7LCIiInIwbLyIiCwgyzKy932LpJkroE9NR9W3R8D3teegcHO1d2lERETkgNh4ERGZqeB/V+4dVnjiV3hGdoT/+xOgrlfT3mURERGRA2PjZSae0EkiMV+OTZ+ZjZSPNyA9djfUdWui5vaF8OjWxt5lmYUZI5GYLxKJ+SLRRGeMjZcF+MYnESRJ4knDDkqWZWR9/hWSZ62EPiMLfu+9DN9xQyC5uti7NLMwYyQS80UiMV8kmi0yxsaLiKgU+RcuIykqGnnxf8Dzqc7wnzMe6jqB9i6LiIiInAwbLwvwPl4kgizL0Gq1UKlUzJcD0GVkIfWj9UhftwfqoNqouWsxPDo/Zu+yyoUZI5GYLxKJ+SLRbJExNl5m4n28SCTmy/5kvR6ZO48gZc4q6LPz4DdtDHzHDITkUjEOcWHGSCTmi0Rivkg00Rlj40VE9H/yz/2DpEmLkffTeVTp1w3+s1+DqmaAvcsiIiKiCoCNFxFVerq0TKTM+wQZG/dB/XA91Nq7FO4Rj9i7LCIiIqpA2HgRUaUl6/XI3BaH5LmrIedr4D97HHxGPgtJzU0jERERWRe/XZiJJ3SSSCoV35K2kvf7X0iKikb+LxdQZWAP+M94Faoa1exdlnDMGInEfJFIzBeJJjpjTLAF2HyRCJIkMVs2oEtJR8qHscjY/AVcGgeh1hfL4d6uub3LsglmjERivkgk5otEs0XG2HhZgJeTJxFkWYZer4dCoWC+BJB1OmRuPYjkuWsArQ7+c1+Hz8vPQKpEf0Flxkgk5otEYr5INFtkrPJ847ASXsqURNLpdFAoFPYuo8LJ++VPJEUtQf7vf8FrSC/4TR8LVXU/e5dlF8wYicR8kUjMF4kmOmNsvIiowtIlpSJ57hpkbj0Il/CHUfvgSri1Drd3WURERFQJsfEiogpH1umQsXE/UubFAgCqffQWvEf0haRU2rkyIiIiqqzYeBFRhZL34zncnRSNgj8vweuF3vCfOgbKalXtXRYRERFVcmy8zMQTOkkkHrtuOe1/KUiZswqZOw7DtUUj1D68Gm6PNLF3WQ6HGSORmC8Sifki0URnjI2XBdh8kQiSJPEeJRaQtVqkr9uL1I/WASolAha9C68XevOwwmIwYyQS80UiMV8kmi0yxgRbgJeTJxEKXzGT+Sqb3B9+R9LkaBRcvALvEX3hN3k0lH4+9i7LYTFjJBLzRSIxXySaLTLGxstMvJw8iaTRaKBWq+1dhsPT3k5C8uyVyNr9FVxbNUGdr2Lh2jzU3mU5BWaMRGK+SCTmi0QTnTE2XkTkNGSNFumf7EbKgg2QXNUIWBIFr+d6QeJx/0REROTg2HgRkVPIPfkr7kZFQ/PPdXi/9Az8okZB6etl77KIiIiIyoSNFxE5NO2t/5A8cwWy9n0Lt9bhCPz6E7iGP2zvsoiIiIjMwsaLiBySXKBB2pqdSF24CQpPd1RfPhVVBvXkSdVERETklNh4mUmSJH7xIyEkSYKLi4u9y3AIOd/9hKTJS6C5chM+o/qj6nsvQ+ldxd5lOT1mjERivkgk5otEs0XG2HgRkcPQ3LiD5OkxyD7wPdzaNUfgujlwbdLA3mURERERlRsbLwvwPl4kgizL0Ol0UCqVlS5fcn4B0lZuR2r0Zii8q6D66hmo0r97pVsPolXmjJF4zBeJxHyRaLbIGBsvM/E+XiSSXq+HUqm0dxk2lfPNGSRNWQLN9X/hM2Yg/N55EQovT3uXVWFVxoyR7TBfJBLzRaKJzhgbLyKyC831f5E0bRlyDp2Ee8dHUGPzh3AJDbJ3WURERERCsPEiIpvS5+Ujbfk2pC3dAkVVHwTGzobn01146AgRERFVaGy8iMhmso+cQtK0ZdDe/A++rw5G1TeHQ1HFw95lEREREQnHxstM/Ks8iaRSVcy3pObKTSRNXYqcr+Lh3vkx1PzsY7g0rGfvsiqlipoxcgzMF4nEfJFoojPGBFuAzReJUBHvEafPyUPasi1IW/4ZlAFVEbhhLjx7d6pwy+ksKmLGyHEwXyQS80Wi2SJjbLwswMvJkwiyLEOv10OhUDh9vmRZRnbcCSRPj4H2TjJ8X3sOVScOg8LDzd6lVWoVKWPkeJgvEon5ItFskTE2Xmbi5eRJJJ1OB4VCYe8yyqXg8nUkTV6K3GM/wqNbW9TctRguDerauyz6PxUhY+S4mC8Sifki0URnjI0XEVmFPjsXqdGbkbZyO1Q1A1Dj03nw6NmBf5kkIiIiAhsvIionWZaR/eV3SJ6xHLqkNFSdOAy+E16Awt3V3qUREREROQyH2l976NAhvPrqq+jUqRNatGiBp59+Grt37y5yeN+uXbvQs2dPhIeHo2/fvjh27FiRsTIzMzFlyhS0bt0aLVu2xOuvv47//vvPVotCVCkU/H0V/w58C3dGzoBLeAjqnvwUfu+9zKaLiIiI6D4O1Xht3LgR7u7uiIqKwqpVq9CpUydMnz4dK1asMM5z8OBBTJ8+Hb169UJsbCxatGiB8ePH4/fffzcZa+LEiTh16hRmzZqFhQsX4sqVKxg9ejS0Wm25auRhUySSsxy7rs/KQfLslUh8/EVorv2LGtsWoOan86CuX8vepdEDOEvGyDkxXyQS80Wiic6YJDvQ1SJSUlLg5+dn8tj06dMRFxeHn376CQqFAj179kRYWBgWLVpknGfIkCHw8vJCbGwsAOC3337DkCFDsG7dOkRERAAAEhISEBkZicWLFyMyMtKi+s6dOwcACA8Pt+j5RM5OlmVk7f0GyTNXQJ+eiaoTh8Nn3GAo3LiHi4iIiCoXc3sDh/rTwf1NFwA0btwYWVlZyMnJQWJiIq5evYpevXqZzBMZGYn4+HgUFBQAAI4fPw5vb2906NDBOE9wcDAaN26M48ePi10IonJwoL+DFJF/MQG3+r2B/16ZDbdWTVH31BZUfWs4my4n48gZI+fHfJFIzBeJJjpjDn9xjV9++QWBgYGoUqUKfvnlFwBAUFCQyTwNGjSARqNBYmIiGjRogISEBAQFBRU5LDA4OBgJCQnlqkeWZd7Hi4SQZRkajQZqtdou+crNzcWFCxdQUFAAFxcXBAUF4ebNmwiuXhO5yz9DeuznUNevhZo7F8GjS2ub10flZ++MUcXGfJFIzBeJZouMOXTj9fPPPyMuLg6TJk0CAKSnpwMAvL29TeYz/GyYnpGRAS8vryLj+fj44Pz58+Wuq7huWJKkErtkw4tX2nRRz+W4zvPaGJr6wj9bY9yy1pubm4vz588bGy9fX1/8u343PA//CuTkwW/ySPi8MgiSq4vJGI60DivruGV9riFjhp+dcVmdbVxHrEnkuPdvx6wxbnlr4riOWZO54xbOljPU68w1Odu41qqp8DasPOOWxmEbr9u3b+PNN99EmzZtMHz4cHuXY0Kj0Zh0wgqFAiqVyjjtfi4uLgDu3ZRNr9ebTFOpVJAkCXq9HjqdzmSaYVxDB34/tVpd4rhKpRJKpRKyLBe5oIgkScbnarXaIsERNW5ZlhUoug5FjWtYVkmSzF7WsowLmLcOZVk2qd/cZTWMW1xNJa3D3NxcnD17FsnJyQgNDUVGRib0kOD5bxry1s9BgwsJUD7ZHrXnvwVlrer3xr1v7NLWoaHe0tahvfJd2jq0Zb4B220jCi+XSqXiNuIB4xqW1VG2EeVdVku2EWUZt/CyGuot/BnJbYTpsjryNsJayypi3MKNF7cRzruNMHcd2nIbYfi3JEnG99yDthGFm7SycMjGKyMjA6NHj4avry9iYmKMVxjx8fEBcO9S8QEBASbzF57u7e2N27dvFxk3PT3dOE95lLYL0vBiFKdwoO+nUChKvJJK4bCbO+6Dnmt4I9hy3NKWFSh9HVp7XMPrWJ5ltdZrU9xGrCTWWoeZmZn4888/kZqaipzcPGT8exvh8VfQ+M/rSPf1xvF+bRHyXCT0BTnwLubiN4blACxfh/bKd3nec6JeG9HbCEPGCm/DuI0ofVxH2kbczxHXoUqlKvIZyW1E2ccF+D2ipHELf7nmNqJs4zriNkLEOrRWvg2fkYWX70HLak7TBThg45WXl4dXXnkFmZmZ2LFjh8khg8HBwQDuXaHQ8G/Dz2q1GnXr1jXOFx8fX6QLvXLlCkJCQspdoyRJxa7oB6380qaLei7HFTuutWsq7suKNX9ncb8jMzMTBfn50H3xHZ4+9Q9UWh1+a/cw/te8LnQKBZJOnsBvv7ihSZMmpV4R1FHWYWUc15znGrZfhRsvETVxXMetSeS49+fLEWriuI5ZkyXjlmW75Uj1OmtNzjauNWu6f/tVnpqK41CNl1arxcSJE5GQkICtW7ciMDDQZHrdunVRv359HD58GN27dzc+HhcXh3bt2hl3C3bq1AkrV65EfHw82rdvD+Be03XhwgWMGjWqXDVaspKJyqq0v9hYU0pKChITE3Hj5r9wuXoXEd9fQPU76UgIqYEzbR5Gvo87CuANN0U+OnRsg6CH6lllbzHZn60yRpUT80UiMV8kmuiMOVTjNXv2bBw7dgxRUVHIysoyuSlykyZN4OLiggkTJuCdd95BvXr10KZNG8TFxeHs2bPYsmWLcd6WLVsiIiICU6ZMwaRJk+Dq6oro6GiEhoaiR48e5a6TzReJYMtcnT59Gn/Gn0HTk3+j9/kbSPPzxJFnWuFunaoAABX0eKhuVbioFWjRLLzYQwzJ+XDbRSIxXyQS80Wi2SJjDtV4nTp1CgAwf/78ItO++eYb1KlTB3369EFubi5iY2Oxdu1aBAUFYfny5WjZsqXJ/EuWLMG8efMwY8YMaLVaREREYNq0aaUeq1lW5p5IR1QWhotrKJVKofmS9Xq0vJ6BkG1noNdo8VPHxrjYpCa0Lr5wlTPh4eEOd3d3PNaqOS5cuCCsDrI9W2WMKifmi0Rivkg0W2RMki25FmIlde7cOciyjPDwcL7pyeoMJw6LvH9E3m8XkTQpGvm/XUSVQU9C+foQ7Pn+GyQlp6Bp87a4ceUCGjUKha+vr/E+Xg0bNoS7u7uQesi2bJExqryYLxKJ+SLRLMnYuXPnAADh4eFlmt+h9ngRkRi65DQkf7AWmVsOwKVJA9Q6sALubZohJSXl3uVYlQoE1fFDTnpVtGzZ0nhoIQ8xJCIiIrIONl5EFZis0yHj0y+R8sFaQC+j2odvwPvFpyH93yG37u7uaNq0Ke7evYtq1aohLCyMe7eIiIiIBGDjRVRB5f38J+5OWoyCs3/D6/ne8Jv2ClQBVU3mcXd3R7t27Yw/16pVy9ZlEhEREVUKbLzMxOOKSaSSbvBnDu3dVKS8vxqZn8XBpVkIah9aDbdHm1qhOqoIrJExopIwXyQS80Wiic4YGy8LsPkiESRJKtcbXtZqkbFxP1LmfwJIEqp9/Da8hz0FiR9U9H/KmzGi0jBfJBLzRaLZImNsvCzAy8mTCLIsG7Nlbr5yT59FUlQ0Ci5chvewp+A3ZTSU/r5iCiWnVZ6MET0I80UiMV8kmi0yxsbLTLz6Pomk1WrNumu69k4ykuesQtbOI3B9pDFqH1kDt5aNBVZIzs7cjBGZg/kikZgvEk10xth4ETkhWaNF+ro9SF2wHlCrELD4PXi90BuSQmHv0oiIiIioGGy8iJxM7qnfkDR5CQr+ugLvF5+B3+RRUFb1tndZRERERFQKNl5ETkJ7OwnJM1cga8/XcH0sDHW+ioVr81B7l0VEREREZcDGy0w8oZNEKi5fskaL9LW7kPLxBkjurghYNhleg5/kYYVkEW7DSCTmi0Rivkg00Rlj42UBvvFJBEmSipzQmXP8ZyRNXgLNpUT4jOyPqpNehtLHy04VkrMrLmNE1sJ8kUjMF4lmi4yx8SJyQNqbd5A0YwWyvzgGtzbNEPjtLLg2bWjvsoiIiIjIQmy8LMD7eJEIsixDk52D7HV7kLp4MxRVPFB95TRUGdCDeSOrkGUZWq0WKpWKmSKrY75IJOaLRLNFxth4mYn38SJRcr79EUlTlkB77V/4jBkAv3dfgsLL095lUQXDbRiJxHyRSMwXiSY6Y2y8iOxMk3gbydNjkH3wOFzbNUeNjR/AtXGwvcsiIiIiIiti40VkJ/q8fKSv2I7UpZ9C4eOF6mtmwqV3R7i4uNi7NCIiIiKyMjZeRHaQffQHJE1dBu2N2/AdOwhV334Rkqc7NBqNvUsjIiIiIgHYeJmJJ3RSeWiu3kLStGXIOXIK7o8/iprbPoLLww8BuHdcMS+VS6IxYyQS80UiMV8kGi8n74DYfJG59Ln5SIvZirRlW6Gs5ovAdXPg+VRnkywxVyQaM0YiMV8kEvNFotkiY2y8LMDLyVNZybKMnCOnkDRtGbS37sJ33BBUfXM4FJ7uxc6r0+mgVCqZLxKCGSORmC8Sifki0WyRMTZeZuKlTKmsNAk3kDRlKXK+OQ33rm1Qc8dCuDSoV+pz9Ho9lEqljSqkyogZI5GYLxKJ+SLRRGeMjReRlelz8pC65FOkrfgMqkB/1Nj0ATx6deRf6IiIiIgqMTZeRFYiyzKyD3yP5BnLobubiqqvvwDfCS9A4eFm79KIiIiIyM7YeBFZQcGl60iavAS53/0Ejx7tUW3u61AH1bZ3WURERETkINh4mYmHi1Fh+qwcpC7ejLTVO6CqXR01ts6HZ48OFo/HY9dJNGaMRGK+SCTmi0QTnTE2XhZg80WyLCN7/zEkzVwBfUoaqr41HL7jn4fCzdXiMSVJ4ocKCcWMkUjMF4nEfJFotsgYGy8L8HLylVvB/67cO6zwxK/wjOwI/znjoX6oVrnHlWXZmC3mi0Rgxkgk5otEYr5INFtkjI2XmXg5+cpLn5WDlI83IH3tLqjr1kTN7Qvh0a2NVX+HVqsVftd0qtyYMRKJ+SKRmC8STXTG2HgRPYAsy8ja8zWSZ66APiMLfu+9DN9xQyC5uti7NCIiIiJyEmy8iEqRf+EykqKikRf/Bzyf6nzvsMI6gfYui4iIiIicDBsvomLoMrKQ+tF6pK/bA3VQbdTctRgenR/7f+3de3gU9d338c8m2QQIJISDIAhNghJB0MQqBzlYQLEBanwsVlsRtYiAAgVuHoMRcgNiRWrlJIpGqkVpVYQqlIhQwYCAVSreiFbFJGiAckgIORKS7M79B0/2ISQhx19mN7xf18V1JbOzv/nO5rO/3S87M2t3WQAAAPBRNF61xAmdTZvldivv7Q90av6LchcUqc0T49V6wq/kCGycY8rJF0wjYzCJfMEk8gXTTGeMxqsOeOI3TWe/PKjM+OdU9NkBtbxjqNrOe1QBnS5rtO07HA5OGoZRZAwmkS+YRL5gWmNkjMYLlzzX6TydevoV5b72rpxXdVWnvy1V84HX210WAAAAmhAarzrge7yaBsvtVt5f31fWgpWyiorVdu4khT40Wg6nPU8Ly7JUWlqqgIAA8gUjyBhMIl8wiXzBtMbIGI1XLfE9Xk3D2f/5Vifjn9PZf32tlncNV9vESQro2M7ussgXjCNjMIl8wSTyBdNMZ4zGC5cU16kcnfp9knJXb1Bgjwh12vC8mve/zu6yAAAA0MTReOGSYLlcyluzSVkLXpJKXWq7YKpCf3uHHAE8BQAAAGAe7zrR5BX96ytlzlqis198o1b3xKrNnIkKuKyN3WUBAADgEkLjVUuc0Ok7XJnZylrwkvLWbFJgr6vUedMLatant91lXVQAn8DBMDIGk8gXTCJfMM10xkhwHdB8eTfL5VLua+/p1NNJkqR2z8xQyP23y+Hvb3NlF+dwOMgWjCJjMIl8wSTyBdMaI2M0XnXA5eS9V9GnX+pk/GIVHzioVveOVNvZE+TfLszusmrEsiy53W75+fmRLxhBxmAS+YJJ5AumNUbGaLxqiUuZeqfSE6d0av6Lyntrs4Kir1bnD15Ss+t72l1WrblcLvn5+dldBpowMgaTyBdMIl8wzXTGvCq9P/zwgxITExUXF6eePXtq1KhRla63du1a3Xbbberdu7duv/12bd++vcI6eXl5SkhIUJ8+fRQTE6OpU6fqxIkTpncBjcwqLdXpl99RRv97VbBlt9r/8f+q8+aVPtl0AQAAoOnyqsbr4MGDSklJ0U9+8hN169at0nU2bdqkOXPmKDY2VklJSYqOjtbkyZP1xRdflFtv2rRp2rVrl+bOnatnn31W6enpGj9+vEpLSxthT9AYzuz+QoeHjVPW7GVqeecwdf3kLwoZ6/3ncgEAAODS41WHGg4dOlS33HKLJGnWrFk6cOBAhXWWLVumkSNHatq0aZKkfv366bvvvtOKFSuUlHTuYgr79u3Txx9/rFWrVmngwIGSpIiICI0YMUJbtmzRiBEjGmeHYETpsUxlzXtB+e9sVdBPe+qKrUkKui7K7rIAAACAKnnVJ17VHVOZkZGhQ4cOKTY2ttzyESNGaM+ePSouLpYk7dixQyEhIRowYIBnncjISPXo0UM7duyoV42c0Gkfq6RUp198Uz/2v1eF2z9V+yWz1Dn5xSbVdHHsOkwjYzCJfMEk8gXTTGfMqz7xqk5aWpqkc59ena9bt24qKSlRRkaGunXrprS0NEVERFRokiIjIz1j1AfNV+M78/HnOjlrsUoO/qiQB+9Qm1kPyb91K7vLalAOh4PvKIFRZAwmkS+YRL5gWmNkzKcSnJOTI0kKCQkpt7zs97Lbc3Nz1apVxTfloaGhlR6+WFtut7tC8+VwOKq84mHZuhe73dR9fX3c0qMnlDX3BRW8u03N+vTWZVuTFNT7qgrbsKve+tz3wtvKfi/7Hglv/9s01LjeWJOvjVvT+174nPHFffW1cb2xJlPjut3uCmM1xLj1uS/jem9NtR33/NfIqnhTvb5ck6+N21A1nf9z2SdfdRn3Ynyq8fIGlmWppKSk3BPfz8/P0yGXlJRUuE9gYKCkc5eoPP+FSTr3DdllL1gul6vcbWXjlm3zQk6ns8px/f395e/vL8uyKlxQxOFweO5bWlpaITimxq3JvkrnHkOruER5r6xT7uLX5Qhursuef0Itf3WbSktLKzwWtRn3Qk6nUw6Ho9b7WpNxpdo9hpZlyeVyqXnz5pJq/xiWjVtZTQ35t6lsX6t6DMvGvdhjaFe+L/YYms73hRprjijbr4CAAAUEBPj0HNEY45btq7fMEfXd18aYI86cOeNZ9/x9ZY7wjTmiofbVxLiWZcmyLAUFBTFH+PAc4c3vI8p+djqdnudcdXOEZdXuu319qvEKDQ2VdO5S8e3bt/csz83NLXd7SEiIjh07VuH+OTk5nnXqoywgVd1WlfMDfSE/P78qjys9P+y1Hbe6+17sI1VT415sXyWpZPf/KCthiUrSjihk3P9Rm8d+K//QVvUet7J6y/6O9dnXhvrbVDaJVaUu+2pq3Po+hnbluz7POVN/G9NzRFnGzp/DfHGO8KV8VzVumab2GAYEBFR4jWSOqPm4Eu8jqhr3/DfXzBE1G9cb5whvfh9R9hp5/v5Vt6+1abokH2u8IiMjJZ0716vs57LfnU6nunTp4llvz549FbrQ9PR0de/evd51OByOSh/o6h786j4eN3FfXxq35PBxZc1ZroK/p6hZ/+vU4ZX5CurZrUb3taNeEzVV9malIbfpjeN6Y02+Nm5t7ls2f53feJmoiXG9tyaT416YL2+oiXG9s6a6jFuTecub6vXVmnxt3Ias6cL5qz41VcanLg/TpUsXhYeHa/PmzeWWJycnq3///p6PBQcPHqycnBzt2bPHs056erq+/vprDR48uFFrRvWss8XKXrxaGQPGqOizA7psZaI6vbe8QtMFAAAA+Cqv+sTrzJkzSklJkSQdOXJE+fn5niarT58+atOmjaZMmaKZM2eqa9eu6tu3r5KTk7V//3698cYbnnFiYmI0cOBAJSQkKD4+XkFBQVq8eLGioqI0fPjwetVYl+4WVSv88J/KTFiikh//o9CH71KbmQ/Ir1Ww3WXZhnzBNDIGk8gXTCJfMM10xhxWXS7JYcjhw4c1bNiwSm9bvXq1+vbtK0lau3atkpKSdPToUUVERGjGjBkaMmRIufXz8vL09NNPa+vWrSotLdXAgQM1e/ZsdejQoc71ffnll5Kk3r1713kMnFPy43+UOXuZCt//WM0HXa92T09TYFSE3WUBAAAANVLb3sCrGi9vR+NVf+6iszr9/F90eukb8gsLVbv5kxUcN4T/xQIAAIBPqW1v4FWHGvqK2l46EucUfLBLmbOXqfTICbWeeLfCZoyVX8sWdpflNc6/1Df5gglkDCaRL5hEvmBaY2SMxquW+ICw9krSjyjziaUq3LpHzX92oy7/6x8UeGVXu8vySuQLppExmES+YBL5gmmmM0bjBWPchUU6vewNnX7+r/JvH6YOry5Q8MjB/E8VAAAALjk0XmhwlmWp8P2dypy9XKXHs9T60V8rbNp98mvRzO7SAAAAAFvQeKFBFaf+qMyEZTqz7Z9qMayfLl/7nAK7dbG7LAAAAMBWNF61xGFylXMXnFH24tU6/eJbCujYTh1ff1otbhvA41VLAQE8JWEWGYNJ5AsmkS+YZjpjJLgOaCb+P8uyVLDxI2UlPi9X5mmF/W6MWk+5V37Ng+wuzec4HA6yBaPIGEwiXzCJfMG0xsgYjVcdcDn5c4q/O6TMhKU6k7JXLX4+UO2enCJneCe7y/JZlmXJ7XbLz8+PfMEIMgaTyBdMIl8wrTEyRuNVS1zKVHLnFyr7j6/p9Mq3FXBFR3X8yyIF39rf7rKaBJfLJT8/P7vLQBNGxmAS+YJJ5Aummc4YjRdqzLIs5b/7obISV8idk6c2Mx9U6KP3yK8ZhxUCAAAAF0PjhRop/iZdJx9foqKPP1fwyMFq++QUObt0tLssAAAAwCfQeOGi3HkFOrXoT8pJWidneCdd/tazajG0r91lAQAAAD6FxquWLpUTOi3LUv47W5Q19wW58wvV5vGH1Hrir+QICrS7tCaNY9dhGhmDSeQLJpEvmGY6YzReddDUm6+zB75X5qzFKvrnfgXHDVW7eY8ooHMHu8tq8hwOB99RAqPIGEwiXzCJfMG0xsgYCa6Dpno5eVdOnrIXrlLOn/4m55VddPm6xWox+Aa7y7pknH/FzKaYL9iPjMEk8gWTyBdMa4yM0XjVUlO8nLzldivvrc069eRKuQuL1DZxokLHj5Yj0Gl3aZeckpISOZ087jCHjMEk8gWTyBdMM50xGq9L3Nn/+VYnH1+is58dUMs7b1HbeY8qoGM7u8sCAAAAmhQar0uUKztXp55OUu5r78kZFa5O7y5T8wExdpcFAAAANEk0XpcYy+1W3ppNynrqJam4VG3nT1bouDvlcBIFAAAAwBTebV9Cir74Rpnxz+ns5/9Wy1/dpraJkxTQoa3dZQEAAABNHo1XLTkcDp+7mo4r67SynnpZeW/8XYE9u6nTxhVq3u9au8vCBRwOh5xOp8/lC76DjMEk8gWTyBdMa4yM0Xg1YZbLpdzXN+rU75Mkl1vtfv87hTwQJwffg+G1eEGBaWQMJpEvmES+YJrpjPEOvA584Xu8ivZ+pZPxz6l4/3dq9ZuRajN7ggLah9ldFi7Csiy5XC75+/t7fb7gm8gYTCJfMIl8wbTGyBiNVy15+/d4lZ7M1qknVyrvr8kKvLa7Or+/Us1uuMbuslBDbrdb/v7+dpeBJoyMwSTyBZPIF0wznTEarybCKi1V7mvv6dTCVySHQ+3+8F8Kue8XcjBBAQAAALaj8WoCznyyX5mzFqv461S1GjNKbZ94WP5tW9tdFgAAAID/h8bLh5Uez1LW/BeV//YHCorpoc4fvKRmMT3sLgsAAADABWi8askbTui0SkuV88p6ZS/6k+QMUPvnHlOre0fK4ednd2moJ45dh2lkDCaRL5hEvmCa6YzReNWBnc3XmV37lPn4EhV/k66QB+LU5vHx8g8Lsa0eNByHw8GLCowiYzCJfMEk8gXTGiNjNF51YMfl5EuPZSrrv1cof/0/FHRjL12xNUlB10U1ag0wy7IsT7a84ZNVND1kDCaRL5hEvmBaY2SMxquWGvty8lZJqXJeXqtTf3hVjuZBar/scbW6++ccVthElZaWyul02l0GmjAyBpPIF0wiXzDNdMZovLxY4Y69ynx8iUq+z1DouDsVFv9b+Ye2srssAAAAALVE4+WFSo8cV2biChVs2K5mfa9Vhw/nKqjXlXaXBQAAAKCOaLy8iHW2WKdXvq3s5/4sv5YtdNkLs9Vy9HCOZQYAAAB8HI1XLZlqggq3f3rusMJDRxU6/pdq89hv5dcq2Mi24L38OHcPhpExmES+YBL5gmmmM0bjVQcN2XyVZBxT1pznVbApRc1uilaHVxcoqEdkg40P3+FwOBQQwFMS5pAxmES+YBL5gmmNkTESbBN30VnlrHhT2Utfl19oK1328n+r5R3DOKwQAAAAaIJovGrp/Gv811XB1j3KTFiq0sPH1HrirxT2Xw/Ir2WLBqwSvsiyLJWUlMjpdNKAwwgyBpPIF0wiXzCtMTJG49WISg4dVebsZSr8YJea33yDLv/LMwq86id2lwUAAADAMBqvRuA+c1anl6/R6WVr5N+utTqsmq/gX/yM/7EBAAAALhE0XgZZlqXCD3Ypc/YylR49qdaP3KOw6WPlF9zc7tIAAAAANCIaL0NK0g4rM2GpCj/8RM2H9NHlbz2rwG5d7S4LAAAAgA1ovGqpusMD3YVFyl7yuk6v+KsCOrRVxz8/pRaxgzisEDXidDrtLgFNHBmDSeQLJpEvmGY6Y0268UpNTdWCBQu0b98+BQcHKy4uTtOmTVNgYGC9xq2sibIsSwWbdihrznK5TmYrbMpv1HrqGPm1aFavbeHSQXMO08gYTCJfMIl8wbTGyFiTbbxycnJ0//33Kzw8XMuXL9fx48e1cOFCFRUVKTExsV5jX3g5+eLvf1Tm40t05qPP1OLW/mq3/ndyRnSu7y7gEmNZllwul/z9/XmBgRFkDCaRL5hEvmBaY2SsyTZeb775pgoKCvT888+rdevWkiSXy6V58+ZpwoQJ6tChQ53GtSzL87M7v1DZz63W6ZVvKaDzZeq4ZqGChw9oiPJxiXK73fL397e7DDRhZAwmkS+YRL5gmumM+Rkb2WY7duxQ//79PU2XJMXGxsrtdmvXrl31GtuyLOW/u00/DrhPOUlrFTZjrLrsXE3TBQAAAKBSTfYTr7S0NP3yl78stywkJETt27dXWlpancd1HPqP/jN3lYp2fq7gEYPUdv5kOX/Sqb7lAgAAAGjCmmzjlZubq5CQkArLQ0NDlZOTU6cxS0pKFPLw71XYsa2KFz6qwj7X6GRulvRlVn3LBSRVPH8QaGhkDCaRL5hEvmBabTNWXFxcq/WbbONlgsPhUG7yYi5nCmN4QYFpZAwmkS+YRL5gWm0z5nA4aLykc4cV5uXlVViek5Oj0NDQOo0ZExNT37IAAAAAXIKa7MU1IiMjK5zLlZeXp5MnTyoyMtKmqgAAAABcipps4zV48GDt3r1bubm5nmWbN2+Wn5+fBgzg6oMAAAAAGo/DOv+LqZqQnJwcjRw5UhEREZowYYLnC5R/8Ytf1PsLlAEAAACgNpps4yVJqampevLJJ7Vv3z4FBwcrLi5O06dPV2BgoN2lAQAAALiENOnGCwAAAAC8QZM9xwsAAAAAvAWNFwAAAAAYRuMFAAAAAIbReAEAAACAYTReAAAAAGAYjRcAAAAAGEbjBQAAAACG0XjVQGpqqh588EFFR0drwIABWrRokYqLi+0uCz5o/fr1ioqKqvDv2WefLbfe2rVrddttt6l37966/fbbtX37dpsqhjf74YcflJiYqLi4OPXs2VOjRo2qdL2a5CkvL08JCQnq06ePYmJiNHXqVJ04ccL0LsCL1SRf9913X6VzWmpqarn1yBcu9P7772vSpEkaPHiwoqOjFRcXp3feeUcXfr0s8xfqoib5smP+CqjXXl0CcnJydP/99ys8PFzLly/X8ePHtXDhQhUVFSkxMdHu8uCjXnnlFbVq1crze4cOHTw/b9q0SXPmzNHEiRPVr18/JScna/LkyVqzZo2io6NtqBbe6uDBg0pJSdF1110nt9td4Q2LVPM8TZs2Td9//73mzp2roKAgLVmyROPHj9e6desUEMBLxaWoJvmSpOuvv17x8fHlll1xxRXlfidfuNBrr72mzp07a9asWQoLC9Pu3bs1Z84cHTt2TJMnT5bE/IW6q0m+JBvmLwsXtXLlSis6OtrKzs72LHvzzTetHj16WMeOHbOvMPikdevWWd27d7eysrKqXGf48OHWjBkzyi27++67rYceesh0efAxLpfL83N8fLw1cuTICuvUJE+ff/651b17d2vnzp2eZampqVZUVJS1adMmA5XDF9QkX2PGjLEefvjhi45DvlCZyl4HZ8+ebV1//fWe7DF/oa5qki875i8ONazGjh071L9/f7Vu3dqzLDY2Vm63W7t27bKvMDRJGRkZOnTokGJjY8stHzFihPbs2cMhrijHz+/iU3hN87Rjxw6FhIRowIABnnUiIyPVo0cP7dixo+ELh0+oLl81Rb5QmTZt2lRY1qNHD+Xn56uwsJD5C/VSXb5qqqHzReNVjbS0NEVGRpZbFhISovbt2ystLc2mquDrRo0apR49emjYsGF66aWX5HK5JMmTqYiIiHLrd+vWTSUlJcrIyGj0WuG7apqntLQ0RUREyOFwlFsvMjKSeQ7V+vTTTxUdHa3evXtrzJgx+uyzz8rdTr5QU//617/UoUMHtWzZkvkLDe78fJVp7PmLA1+rkZubq5CQkArLQ0NDlZOTY0NF8GXt27fXlClTdN1118nhcGjbtm1asmSJjh8/rsTERE+mLsxc2e9kDrVR0zzl5uaWO+ewTGhoqA4cOGC4SviyG2+8UXFxcQoPD9eJEye0atUqPfjgg3r99dcVExMjiXyhZvbu3avk5GTP+TbMX2hIF+ZLsmf+ovECGtGgQYM0aNAgz+8DBw5UUFCQ/vznP2vixIk2VgYAtTd16tRyv//sZz/TqFGj9MILLygpKcmmquBrjh07punTp6tv374aO3as3eWgiakqX3bMXxxqWI2QkBDl5eVVWJ6Tk6PQ0FAbKkJTExsbK5fLpX//+9+eTF2YudzcXEkic6iVmuYpJCRE+fn5Fe7PPIfaatGihW6++WZ99dVXnmXkCxeTm5ur8ePHq3Xr1lq+fLnn3ELmLzSEqvJVmcaYv2i8qlHZMZx5eXk6efJkhXO/gPoqy9SFmUtLS5PT6VSXLl3sKAs+qqZ5ioyMVHp6eoXLhaenpzPPod7IF6pSVFSkCRMmKC8vr8LXrDB/ob4ulq+aauh80XhVY/Dgwdq9e7fnf1gkafPmzfLz8yt3hROgrpKTk+Xv76+ePXuqS5cuCg8P1+bNmyus079/fwUGBtpUJXxRTfM0ePBg5eTkaM+ePZ510tPT9fXXX2vw4MGNWjN8W2FhoT766CP17t3bs4x8oTKlpaWaNm2a0tLS9Morr5T7PkuJ+Qv1U12+KtMY8xfneFXjnnvu0euvv65HH31UEyZM0PHjx7Vo0SLdc889NfojAucbN26c+vbtq6ioKEnShx9+qLfffltjx45V+/btJUlTpkzRzJkz1bVrV/Xt21fJycnav3+/3njjDTtLhxc6c+aMUlJSJElHjhxRfn6+501Knz591KZNmxrlKSYmRgMHDlRCQoLi4+MVFBSkxYsXKyoqSsOHD7dl32C/6vJV9obm1ltvVefOnXXixAm9+uqrOnnypJYuXeoZh3yhMvPmzdP27ds1a9Ys5efn64svvvDc1rNnTwUGBjJ/oc6qy9f+/fttmb8c1oWfnaGC1NRUPfnkk9q3b5+Cg4MVFxen6dOn8+kDam3BggXauXOnjh07JrfbrfDwcN1111267777yl2qdO3atUpKStLRo0cVERGhGTNmaMiQITZWDm90+PBhDRs2rNLbVq9erb59+0qqWZ7y8vL09NNPa+vWrSotLdXAgQM1e/Zs/oPpElZdvjp27Kj58+fr22+/1enTp9W8eXPFxMRo8uTJuvbaa8utT75woaFDh+rIkSOV3vbhhx/qiiuukMT8hbqpLl8ul8uW+YvGCwAAAAAM4xwvAAAAADCMxgsAAAAADKPxAgAAAADDaLwAAAAAwDAaLwAAAAAwjMYLAAAAAAyj8QIAAAAAw2i8AACoREFBgfr3768NGzbYXYpHdna2oqOjlZKSYncpAIBaovECAPicNWvWKCoqSnfddZexbaxevVrBwcEaOXKksW3UVlhYmEaPHq2lS5faXQoAoJZovAAAPmfjxo1yOp3av3+/fvjhhwYfv6SkRKtXr9Zdd90lf3//Bh+/Pn7961/rq6++0p49e+wuBQBQCzReAACfkpGRoX379mnSpElyOp3auHFjg2/jo48+0qlTpxQbG9vgY9dXt27d1L17d/3tb3+zuxQAQC3QeAEAfMrGjRvl7++vu+++WzfddFOljdeyZct09dVXV/hUaM6cOerVq5e++eabi27jH//4hzp37qyuXbuWWz5r1izFxMTo6NGjmjBhgmJiYjRo0CCtWbNGkvTtt99q7Nixio6O1pAhQyrUtn79ekVFRWnv3r1asGCB+vXrpxtuuEGJiYkqLi5Wbm6uHnvsMd1444268cYbtWjRIlmWVaG+m266Sdu3b6/0NgCAd6LxAgD4lI0bN+qGG25Qu3btFBsbq0OHDmn//v3l1pk0aZJ69OihJ554Qvn5+ZKknTt36u2339Yjjzyiq6+++qLb2Ldvn6655ppKb3O5XBo/frw6duyomTNnqnPnzpo/f77Wr1+vhx56SL169dLMmTMVHBys+Ph4ZWRkVBhjwYIFOnTokKZMmaKhQ4fqrbfe0tKlSzVx4kS5XC5Nnz5dP/3pT7Vq1Sq99957Fe5/zTXXKDc3VwcPHqzpwwYAsBmNFwDAZxw4cEBpaWkaMWKEJOmWW26p9HBDp9OpZ555RidOnNDChQuVm5urJ554Qr169dLDDz980W2Ulpbqxx9/1BVXXFHp7WfPntXtt9+uefPm6d5779XLL7+sZs2aKSEhQY8//rgee+wxjRkzRsuWLZPL5dK7775bYYy2bdsqKSlJ9957rxYtWqSYmBitWrVKV111lf74xz/qN7/5jVasWKGOHTtq3bp1Fe7fpUsXSdL3339fk4cNAOAFaLwAAD5j48aNCggI0PDhwyVJrVq10qBBg5ScnCyXy1Vu3e7du2vq1Klau3atxo0bp+zsbD3zzDMKCAi46DZycnJkWZZCQkKqXOf8qymGhIQoIiJCzZs3L3dOWGRkpEJCQir9xGv06NFyOBye36+99lpZlqXRo0d7lvn7+6tXr16V3r+stuzs7IvuCwDAe9B4AQB8gsvl0qZNm9SvXz+1adPGs3zEiBHKzMys9Cp/48aN09VXX639+/dr8uTJuvLKK2u8varOnwoKCiq3felcA9ixY8dyzVTZ8tzc3ApjdOrUqcJ6knT55ZdXWJ6Tk1NljRduDwDgvWi8AAA+4ZNPPtHJkycrXGlw6NChatasWaUX2cjIyPBcbv67776r0XZCQ0PlcDgqbZgkVXl5+aqWV9bA+flV/vJb1fILlTVjYWFhNVofAGA/Gi8AgE8o++6uW2+9tdzy4OBg3Xzzzdq6dauKioo8y91ut2bNmqWWLVtq4sSJ+vvf/64tW7ZUu52AgAB17dpVhw8fbvB9aChltXXr1s3mSgAANUXjBQDwekVFRdqyZYtuuukmhYaGVrj95z//uQoKCrRt2zbPsldffVX79u3T/Pnz9bvf/U4xMTGaO3euTp06Ve32oqOjdeDAgQbdh4b01VdfqVWrVrrqqqvsLgUAUEMXP8MYAAAvsG3bNhUUFEiSXn755Qq3nzlzRpK0YcMGjRgxQqmpqVq6dKnuvPNODR06VJK0cOFC3XHHHZo3b56WLl160e0NGzZM7733ntLT0xUREdHAe1N/u3fv1pAhQzjHCwB8CI0XAMDrbdiwQZKUkpKilJSUKtf7+OOPlZ2drfj4eIWFhSkhIcFzW3h4uGbMmKGnnnpKycnJnkvSV2bIkCEKCwvT+++/r0ceeaThdqQBpKam6rvvviu3bwAA7+ew+Np7AAAqWLFihdavX68tW7ZUeeEMOzz11FPau3ev1q9fzydeAOBDOMcLAIBKPPDAAyosLNSmTZvsLsUjOztb77zzjqZNm0bTBQA+hk+8AAAAAMAwPvECAAAAAMNovAAAAADAMBovAAAAADCMxgsAAAAADKPxAgAAAADDaLwAAAAAwDAaLwAAAAAwjMYLAAAAAAyj8QIAAAAAw2i8AAAAAMAwGi8AAAAAMOx/AYRxzNykx52nAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "15a6fec5", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati caso statico" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "id": "1203e1a0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.22308 ± 0.00202\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 3.22008 ± 0.00577\n", + "Bols = 0.01011 ± 0.77853\n", + "P(0, chi²)= 0.55620\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 3.21962 ± 0.00633\n", + "Bc = 0.24654 ± 0.81108\n", + "P(0, chi²)= 0.52989\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 3.21972 ± 0.00633\n", + "By = 0.23571 ± 0.81103\n", + "P(0, chi²)= 0.52987\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "fb210b61", + "metadata": {}, + "source": [ + "# Dinamica Sonar\n", + "Qui specifico la formula perché non è così ovvia:\n", + "- $M_{eq} = M + \\frac m 3$\n", + "- $\\omega = \\frac{2\\pi}{T} \\quad \\Rightarrow \\quad T = \\frac{2\\pi}{\\omega}$\n", + "- A: coefficiente della regressione lineare $A = \\frac{T^2}{M_{eq}}$\n", + "- $K = \\frac{4 \\pi^2}{A}$\n", + "\n", + "Nota: nelle formule comparirà un $/1000$, questo serve a riportare il valore in unità di misura standard: N/m" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "id": "95dde99f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_T = 0.010000\n", + "0 0.673181\n", + "1 0.917483\n", + "2 1.155540\n", + "3 1.390456\n", + "4 1.627202\n", + "Name: w, dtype: float64\n", + "0 0.016412\n", + "1 0.019158\n", + "2 0.021501\n", + "3 0.023587\n", + "4 0.025521\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Meq = df.m + ( m_mol * 0.33333 )\n", + "uMeq = np.sqrt( df.um**2 + um_mol**2 / 9 )\n", + "\n", + "T2 = ( 2 * np.pi / df.w )**2\n", + "uT2 = np.sqrt( (8*np.pi**2 / df.w**3)**2 * df.uw**2 )\n", + "\n", + "res_b = 0.01 # riso bilancia\n", + "res_T = 0.01 # riso T\n", + "\n", + "T = 2 * np.pi / df.w\n", + "res_T2 = 2 * T * res_T\n", + "\n", + "res_uAd = np.sqrt( (1 / Meq)**2 * res_T2**2 + (T2 / Meq**2)**2 * res_b**2)\n", + "\n", + "\n", + "print(f\"res_T = {res_T:.6f}\")\n", + "# print(f\"res_T2 = {res_T2:.6f}\")\n", + "# print(f\"res_b = {res_b:.6f}\")\n", + "# print(f\"res_uAd = {res_uAd:.6f}\")\n", + "\n", + "uT2 = np.sqrt(uT2**2 + res_T2**2)\n", + "uMeq = np.sqrt(uMeq**2 + res_b**2)\n", + "\n", + "\n", + "print(T2)\n", + "print(uT2)" + ] + }, + { + "cell_type": "markdown", + "id": "7bd743d4", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo della Meq (massa equivalente)\n", + "- Calcolo della media pesata sui K" + ] + }, + { + "cell_type": "code", + "execution_count": 112, + "id": "8c9f5b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3.189871\n", + "1 3.202362\n", + "2 3.215330\n", + "3 3.229732\n", + "4 3.245788\n", + "dtype: float64\n", + "0 0.077772\n", + "1 0.066869\n", + "2 0.059828\n", + "3 0.054789\n", + "4 0.050908\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Ad = T2 / Meq\n", + "uAd = np.sqrt( (1/Meq)**2 * uT2**2 + (T2/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kd = 4 * np.pi**2 / Ad\n", + "uKd = np.sqrt( (4 * np.pi**2 / Ad**2)**2 * uAd**2 )\n", + "\n", + "Kd /= 1000\n", + "uKd /= 1000\n", + "\n", + "print(Kd)\n", + "print(uKd)" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "id": "0d899f17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.2221352803714884\n", + "sigmaC: 0.026847776957366426\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "KdM, uKdM = mediaPesata(Kd, uKd)\n", + "print(\"K-medio:\", KdM)\n", + "print(\"sigmaC: \", uKdM)" + ] + }, + { + "cell_type": "markdown", + "id": "6741544e", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "id": "4b4c2682", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "datad = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2,\n", + " \"uy\": uT2\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "ad203fbd", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "90d191d5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 7.624e+04\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.05e-07\n", + "Time: 09:46:36 Log-Likelihood: 23.705\n", + "No. Observations: 5 AIC: -43.41\n", + "Df Residuals: 3 BIC: -44.19\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0219 0.004 5.124 0.014 0.008 0.035\n", + "x 0.0120 4.35e-05 276.124 0.000 0.012 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 1.430\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.670\n", + "Skew: -0.251 Prob(JB): 0.716\n", + "Kurtosis: 1.279 Cond. No. 344.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Adols = 0.01202 ± 0.00004\n", + "Bdols = 0.02190 ± 0.00427\n", + "R² = 0.99996\n", + "Kdols = 3.28476 ± 0.01190\n", + "KBdols = 1.80283 ± 0.35181\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datad[\"x\"])\n", + "model = sm.OLS(datad[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bdols = model.params[\"const\"]\n", + "Adols = model.params[\"x\"]\n", + "uBdols = model.bse[\"const\"]\n", + "uAdols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "# Calcolo del K dai parametri\n", + "Kdols = (2*np.pi)**2 / Adols / 1000\n", + "uKdols = np.sqrt( (4*np.pi**2 / Adols**2)**2 * uAdols**2 ) / 1000\n", + "KBdols = (2*np.pi)**2 / Bdols / 1000\n", + "uKBdols = np.sqrt( (4*np.pi**2 / Bdols**2)**2 * uBdols**2 ) / 1000\n", + "\n", + "\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Adols = {Adols:.5f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.5f} ± {uBdols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")\n", + "print(f\"Kdols = {Kdols:.5f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.5f} ± {uKBdols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 116, + "id": "a0ba5c8d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = Bdols + Adols * xfit\n", + "\n", + "plt.plot(\n", + " xfit, yfit,\n", + " color=\"crimson\", linewidth=1, zorder=10, label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 117, + "id": "3c7c05e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.05333\n", + "GdL = 3\n", + "Chi² rid = 0.01778\n", + "P(0, chi²)= 0.00322\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.022300\n", + "1 0.003403\n", + "2 0.013819\n", + "3 0.003505\n", + "4 0.010305\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bdols + Adols * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (Adols * datad[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pdols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pdols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "a1296a66", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "698e3c48", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AdC = 0.01204 ± 0.00033\n", + "BdC = 0.02009 ± 0.02973\n", + "cov_ABdC = -0.000009\n", + "P(0,chi²)= 0.00290\n", + "KdC = 3.27952 ± 0.09031\n", + "KBdC = 1.96545 ± 2.90895\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AdC, BdC, uAdC, uBdC, covABdC, chidC = reg_lin(datad[\"x\"], datad[\"y\"], datad[\"ux\"], datad[\"uy\"])\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdC = (2*np.pi)**2 / AdC / 1000\n", + "uKdC = np.sqrt( (4*np.pi**2 / AdC**2)**2 * uAdC**2 ) / 1000\n", + "KBdC = (2*np.pi)**2 / BdC / 1000\n", + "uKBdC = np.sqrt( (4*np.pi**2 / BdC**2)**2 * uBdC**2 ) / 1000\n", + "\n", + "print(\"Ax + B : \")\n", + "print(f\"AdC = {AdC:.5f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.5f} ± {uBdC:.5f}\")\n", + "print(f\"cov_ABdC = {covABdC:.6f}\")\n", + "print(f\"P(0,chi²)= {chidC:.5f}\")\n", + "print(f\"KdC = {KdC:.5f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "a0ab8534", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdC + AdC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "12bb0479", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.04962\n", + "GdL = 3\n", + "Chi² rid = 0.01654\n", + "P(0, chi²)= 0.00290\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.010533\n", + "1 0.006123\n", + "2 0.013854\n", + "3 0.001878\n", + "4 0.017229\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BdC + AdC * datad[\"x\"]\n", + "sigma = np.sqrt(datad[\"uy\"]**2 + (AdC * datad[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((datad[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(datad)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PdC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datad[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f3bf75d6", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 121, + "id": "385db415", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AdY = 0.0120379 ± 0.0003315\n", + "BdY = 0.0200862 ± 0.0297283\n", + "cov_ABdY = -9.375764600499696e-06\n", + "chi² = 0.04962\n", + "chi² rid = 0.01654\n", + "P(0, chi²)= 0.00290\n", + "KdY = 3.27952 ± 0.09031\n", + "KBdY = 1.96545 ± 2.90895\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AdY, BdY, uAdY, uBdY, cov_ABdY, chi2_val, chi2_red = york_fit(datad.x, datad.y, datad.ux, datad.uy)\n", + "PdY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "# Calcolo del K dai parametri\n", + "KdY = (2*np.pi)**2 / AdY / 1000\n", + "uKdY = np.sqrt( (4*np.pi**2 / AdY**2)**2 * uAdY**2 ) / 1000\n", + "KBdY = (2*np.pi)**2 / BdY / 1000\n", + "uKBdY = np.sqrt( (4*np.pi**2 / BdY**2)**2 * uBdY**2 ) / 1000\n", + "\n", + "\n", + "print(f\"AdY = {AdY:.7f} ± {uAdY:.7f}\")\n", + "print(f\"BdY = {BdY:.7f} ± {uBdY:.7f}\")\n", + "print(f\"cov_ABdY = {cov_ABdY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "698bc57c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=datad,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " datad[\"x\"],\n", + " datad[\"y\"],\n", + " xerr=datad[\"ux\"],\n", + " yerr=datad[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, datad[\"x\"].max(), 200)\n", + "yfit = BdY + AdY * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T^2 (s^2)\")\n", + "plt.title(\"Legge di ??\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "2e612bc6", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici" + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "id": "fc32f9e6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.22214 ± 0.02685\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Adols = 0.0120187 ± 0.00004\n", + "Bdols = 0.0218980 ± 0.00427\n", + "P(0,chi²)= 0.0032238\n", + "Kdols = 3.2847627 ± 0.01190\n", + "KBdols = 1.8028281 ± 0.35181\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AdC = 0.0120379 ± 0.00033\n", + "BdC = 0.0200862 ± 0.02973\n", + "P(0,chi²)= 0.0028961\n", + "KdC = 3.2795186 ± 0.09031\n", + "KBdC = 1.96545 ± 2.90895\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ady = 0.01204 ± 0.00033\n", + "Bdy = 0.02009 ± 0.02973\n", + "P(0,chi²)= 0.00290\n", + "KdY = 3.27952 ± 0.09031\n", + "KBdY = 1.96545 ± 2.90895\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {KdM:.5f} ± {uKdM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Adols = {Adols:.7f} ± {uAdols:.5f}\")\n", + "print(f\"Bdols = {Bdols:.7f} ± {uBdols:.5f}\")\n", + "print(f\"P(0,chi²)= {Pdols:.7f}\")\n", + "print(f\"Kdols = {Kdols:.7f} ± {uKdols:.5f}\")\n", + "print(f\"KBdols = {KBdols:.7f} ± {uKBdols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AdC = {AdC:.7f} ± {uAdC:.5f}\")\n", + "print(f\"BdC = {BdC:.7f} ± {uBdC:.5f}\")\n", + "print(f\"P(0,chi²)= {PdC:.7f}\")\n", + "print(f\"KdC = {KdC:.7f} ± {uKdC:.5f}\")\n", + "print(f\"KBdC = {KBdC:.5f} ± {uKBdC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ady = {AdY:.5f} ± {uAdY:.5f}\")\n", + "print(f\"Bdy = {BdY:.5f} ± {uBdY:.5f}\")\n", + "print(f\"P(0,chi²)= {PdY:.5f}\")\n", + "print(f\"KdY = {KdY:.5f} ± {uKdY:.5f}\")\n", + "print(f\"KBdY = {KBdY:.5f} ± {uKBdY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "6f4edfa1", + "metadata": {}, + "source": [ + "# Dinamica Cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "0f407f81", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 0.616814\n", + "1 0.834482\n", + "2 1.043973\n", + "3 1.250483\n", + "4 1.502463\n", + "Name: t, dtype: float64\n", + "0 0.010446\n", + "1 0.007193\n", + "2 0.011988\n", + "3 0.020931\n", + "4 0.047373\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "T2t = (df.t / 20)**2\n", + "uT2t = 2 * (df.t / 20) * (df.ut / 20)\n", + "\n", + "print(T2t)\n", + "print(uT2t)" + ] + }, + { + "cell_type": "markdown", + "id": "8d097869", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "99bc83a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 3481.375388\n", + "1 3520.881843\n", + "2 3558.945703\n", + "3 3591.251814\n", + "4 3515.262640\n", + "dtype: float64\n", + "0 58.964242\n", + "1 30.353010\n", + "2 40.870817\n", + "3 60.111122\n", + "4 110.836851\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "Adt = T2t / Meq\n", + "uAdt = np.sqrt( (1/Meq)**2 * uT2t**2 + (T2t/Meq**2)**2 * uMeq**2 )\n", + "\n", + "Kdt = 4 * np.pi**2 / Adt\n", + "uKdt = (4 * np.pi**2 / Adt**2) * uAdt\n", + "\n", + "Kdt\n", + "uKdt\n", + "\n", + "print(Kdt)\n", + "print(uKdt)" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "ae55d12a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio (t): 3.5339477952923186\n", + "sigmaC (t): 0.02071746981839289\n" + ] + } + ], + "source": [ + "KdtM, uKdtM = mediaPesata(Kdt, uKdt)\n", + "KdtM /= 1e3\n", + "uKdtM /= 1e3\n", + "print(\"K-medio (t):\", KdtM)\n", + "print(\"sigmaC (t):\", uKdtM)" + ] + }, + { + "cell_type": "markdown", + "id": "634a06e9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici" + ] + }, + { + "cell_type": "code", + "execution_count": 127, + "id": "75e94b0a", + "metadata": {}, + "outputs": [], + "source": [ + "datat = pd.DataFrame({\n", + " \"x\": Meq,\n", + " \"ux\": uMeq,\n", + " \"y\": T2t,\n", + " \"uy\": uT2t\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "e7761130", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 128, + "id": "896388e2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 0.999\n", + "Model: OLS Adj. R-squared: 0.998\n", + "Method: Least Squares F-statistic: 2631.\n", + "Date: Wed, 08 Apr 2026 Prob (F-statistic): 1.63e-05\n", + "Time: 09:46:38 Log-Likelihood: 15.713\n", + "No. Observations: 5 AIC: -27.43\n", + "Df Residuals: 3 BIC: -28.21\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0107 0.021 0.506 0.648 -0.057 0.078\n", + "x 0.0110 0.000 51.298 0.000 0.010 0.012\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 2.074\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.262\n", + "Skew: -0.213 Prob(JB): 0.877\n", + "Kurtosis: 1.963 Cond. No. 344.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE OLS (t):\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = 0.01070 ± 0.02113\n", + "R² = 0.99886\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = 3.69001 ± 7.28846\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 5 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(datat[\"x\"])\n", + "model = sm.OLS(datat[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "Btols = model.params[\"const\"]\n", + "Atols = model.params[\"x\"]\n", + "uBtols = model.bse[\"const\"]\n", + "uAtols = model.bse[\"x\"]\n", + "R2t = model.rsquared\n", + "\n", + "Kdtols = 4 * np.pi**2 / Atols / 1000\n", + "uKdtols = (4 * np.pi**2 / Atols**2) * uAtols / 1000\n", + "KBdtols = 4 * np.pi**2 / Btols / 1000\n", + "uKBdtols = (4 * np.pi**2 / Btols**2) * uBtols / 1000\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS (t):\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"R² = {R2t:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 129, + "id": "61e40e4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = Btols + Atols * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit OLS t\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di ?? — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "354687ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 1.29711\n", + "GdL = 3\n", + "Chi² rid = 0.43237\n", + "P(0, chi²)= 0.27018\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.279595\n", + "1 0.079492\n", + "2 0.241430\n", + "3 0.601905\n", + "4 0.094687\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Btols + Atols * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (Atols * datat[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "\n", + "N = len(datat)\n", + "nut = N - 2\n", + "\n", + "chi2_red = chi2_val / nut\n", + "Ptols = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Ptols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "c28f2d34", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 131, + "id": "8d6cd1df", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B (Carpi, t):\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.03084 ± 0.02321\n", + "cov_ABtC = -0.000007\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 1.28006 ± 0.96321\n" + ] + } + ], + "source": [ + "AtC, BtC, uAtC, uBtC, covABtC, chitC = reg_lin(datat[\"x\"], datat[\"y\"], datat[\"ux\"], datat[\"uy\"])\n", + "\n", + "KdtC = 4 * np.pi**2 / AtC / 1000\n", + "uKdtC = (4 * np.pi**2 / AtC**2) * uAtC / 1000\n", + "KBdtC = 4 * np.pi**2 / BtC / 1000\n", + "uKBdtC = (4 * np.pi**2 / BtC**2) * uBtC / 1000\n", + "\n", + "print(\"Ax + B (Carpi, t):\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"cov_ABtC = {covABtC:.6f}\")\n", + "print(f\"P(0,chi²)= {chitC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 132, + "id": "592c257c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtC + AtC * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit Carpi (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "id": "12f276cc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 0.53370\n", + "GdL = 3\n", + "Chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.003196\n", + "1 0.022509\n", + "2 0.021597\n", + "3 0.113279\n", + "4 0.373115\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BtC + AtC * datat[\"x\"]\n", + "sigma = np.sqrt(datat[\"uy\"]**2 + (AtC * datat[\"ux\"])**2)\n", + "chi2_val = np.sum(((datat[\"y\"] - F_fit) / sigma)**2)\n", + "chi2_red = chi2_val / nut\n", + "PtC = chi2.cdf(chi2_val, df=nut)\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nut}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PtC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((datat[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "0823cca1", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit" + ] + }, + { + "cell_type": "code", + "execution_count": 134, + "id": "d04ee20e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AtY = 0.0107837 ± 0.0002969\n", + "BtY = 0.0308411 ± 0.0232070\n", + "cov_ABtY = -6.719692180359672e-06\n", + "chi² = 0.53370\n", + "chi² rid = 0.17790\n", + "P(0, chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 1.28006 ± 0.96321\n" + ] + } + ], + "source": [ + "AtY, BtY, uAtY, uBtY, cov_ABtY, chi2_val_t, chi2_red_t = york_fit(datat.x, datat.y, datat.ux, datat.uy)\n", + "PtY = chi2.cdf(chi2_val_t, df=nut)\n", + "\n", + "KdtY = 4 * np.pi**2 / AtY / 1000\n", + "uKdtY = (4 * np.pi**2 / AtY**2) * uAtY / 1000\n", + "KBdtY = 4 * np.pi**2 / BtY / 1000\n", + "uKBdtY = (4 * np.pi**2 / BtY**2) * uBtY / 1000\n", + "\n", + "print(f\"AtY = {AtY:.7f} ± {uAtY:.7f}\")\n", + "print(f\"BtY = {BtY:.7f} ± {uBtY:.7f}\")\n", + "print(f\"cov_ABtY = {cov_ABtY}\")\n", + "print(f\"chi² = {chi2_val_t:.5f}\")\n", + "print(f\"chi² rid = {chi2_red_t:.5f}\")\n", + "print(f\"P(0, chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 135, + "id": "e795e732", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "sns.scatterplot(data=datat, x=\"x\", y=\"y\", s=7)\n", + "\n", + "plt.errorbar(\n", + " datat[\"x\"], datat[\"y\"],\n", + " xerr=datat[\"ux\"], yerr=datat[\"uy\"],\n", + " fmt=\"none\", ecolor=\"gray\", elinewidth=1, capsize=3, alpha=0.7\n", + ")\n", + "\n", + "xfit = np.linspace(0, datat[\"x\"].max(), 200)\n", + "yfit = BtY + AtY * xfit\n", + "\n", + "plt.plot(xfit, yfit, color=\"crimson\", linewidth=1, zorder=10, label=\"Fit York (t)\")\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "plt.xlabel(\"Meq (g)\")\n", + "plt.ylabel(\"T² (s²)\")\n", + "plt.title(\"Legge di Hooke dinamica — cronometro\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "038b2684", + "metadata": {}, + "source": [ + "## Raccolta finale di dati dinamici col cronometro" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "46ef07bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.53395 ± 0.02072\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = 0.01070 ± 0.02113\n", + "P(0,chi²)= 0.27018\n", + "Kdtols = 3.57541 ± 0.06970\n", + "KBdtols = 3.69001 ± 7.28846\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.03084 ± 0.02321\n", + "P(0,chi²)= 0.08857\n", + "KdtC = 3.66092 ± 0.10078\n", + "KBdtC = 1.28006 ± 0.96321\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "AtY = 0.01078 ± 0.00030\n", + "BtY = 0.03084 ± 0.02321\n", + "P(0,chi²)= 0.08857\n", + "KdtY = 3.66092 ± 0.10078\n", + "KBdtY = 1.28006 ± 0.96321\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols:.5f}\")\n", + "print(f\"P(0,chi²)= {Ptols:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols:.5f}\")\n", + "print(f\"KBdtols = {KBdtols:.5f} ± {uKBdtols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC:.5f}\")\n", + "print(f\"P(0,chi²)= {PtC:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC:.5f}\")\n", + "print(f\"KBdtC = {KBdtC:.5f} ± {uKBdtC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY:.5f}\")\n", + "print(f\"P(0,chi²)= {PtY:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY:.5f}\")\n", + "print(f\"KBdtY = {KBdtY:.5f} ± {uKBdtY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "70201336", + "metadata": {}, + "source": [ + "## Aggiungi gli errori strumentali" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "dfcd391e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "res_t = 0.000000\n", + "res_t2 = 0.000002\n", + "res_uAdt = 0.000002\n", + "uKdt_strum = 0.000681\n" + ] + } + ], + "source": [ + "res_t = 0.000001 / 20 # risoluzione cronometro\n", + "res_t2 = np.max(2 * df.t * res_t)\n", + "\n", + "res_uAdt = np.max(np.sqrt( (1 / Meq)**2* res_t2**2 +(T2t / Meq**2)**2 * res_b**2))\n", + "uKdt_strum = np.max(np.abs(4 * np.pi**2 / Adt**2) * res_uAdt) / 1000\n", + "\n", + "print(f\"res_t = {res_t:.6f}\")\n", + "print(f\"res_t2 = {res_t2:.6f}\")\n", + "print(f\"res_uAdt = {res_uAdt:.6f}\")\n", + "print(f\"uKdt_strum = {uKdt_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 138, + "id": "b52fea3d", + "metadata": {}, + "outputs": [], + "source": [ + "uKdtM_fin = np.sqrt(uKdtM**2 + uKdt_strum**2)\n", + "\n", + "uAtols_fin = np.sqrt(uAtols**2 + res_uAdt**2)\n", + "uBtols_fin = np.sqrt(uBtols**2 + res_uAdt**2)\n", + "uKdtols_fin = np.sqrt(uKdtols**2 + uKdt_strum**2)\n", + "\n", + "uAtC_fin = np.sqrt(uAtC**2 + res_uAdt**2)\n", + "uBtC_fin = np.sqrt(uBtC**2 + res_uAdt**2)\n", + "uKdtC_fin = np.sqrt(uKdtC**2 + uKdt_strum**2)\n", + "\n", + "uAtY_fin = np.sqrt(uAtY**2 + res_uAdt**2)\n", + "uBtY_fin = np.sqrt(uBtY**2 + res_uAdt**2)\n", + "uKdtY_fin = np.sqrt(uKdtY**2 + uKdt_strum**2)\n", + "\n", + "uy_fin_t = np.sqrt(datat[\"uy\"]**2 + res_t2**2)\n", + "ux_fin_t = np.sqrt(datat[\"ux\"]**2 + res_b**2)\n", + "\n", + "GdLt = len(datat) - 2\n", + "\n", + "F_fit_tols = Btols + Atols * datat[\"x\"]\n", + "sigma_tols = np.sqrt(uy_fin_t**2 + (Atols * ux_fin_t)**2)\n", + "chi2_tols = np.sum(((datat[\"y\"] - F_fit_tols) / sigma_tols)**2)\n", + "\n", + "F_fit_tC = BtC + AtC * datat[\"x\"]\n", + "sigma_tC = np.sqrt(uy_fin_t**2 + (AtC * ux_fin_t)**2)\n", + "chi2_tC = np.sum(((datat[\"y\"] - F_fit_tC) / sigma_tC)**2)\n", + "\n", + "F_fit_tY = BtY + AtY * datat[\"x\"]\n", + "sigma_tY = np.sqrt(uy_fin_t**2 + (AtY * ux_fin_t)**2)\n", + "chi2_tY = np.sum(((datat[\"y\"] - F_fit_tY) / sigma_tY)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "858bbff7", + "metadata": {}, + "source": [ + "## Risultati della propagazione dell'errore" + ] + }, + { + "cell_type": "code", + "execution_count": 139, + "id": "0b1e4a1d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI CON ERRORE STRUMENTALE (cronometro):\n", + "Media pesata K = 3.53395 ± 0.02073\n", + "\n", + "RISULTATI OLS:\n", + "Atols = 0.01104 ± 0.00022\n", + "Btols = 0.01070 ± 0.02113\n", + "Kdtols = 3.57541 ± 0.06970\n", + "Chi² = 1.29702 | rid = 0.43234 | P = 0.27016\n", + "\n", + "RISULTATI Carpi:\n", + "AtC = 0.01078 ± 0.00030\n", + "BtC = 0.03084 ± 0.02321\n", + "KdtC = 3.66092 ± 0.10078\n", + "Chi² = 0.53368 | rid = 0.17789 | P = 0.08857\n", + "\n", + "RISULTATI York:\n", + "AtY = 0.01078 ± 0.00030\n", + "BtY = 0.03084 ± 0.02321\n", + "KdtY = 3.66092 ± 0.10078\n", + "Chi² = 0.53368 | rid = 0.17789 | P = 0.08857\n" + ] + } + ], + "source": [ + "print(\"RISULTATI CON ERRORE STRUMENTALE (cronometro):\")\n", + "print(f\"Media pesata K = {KdtM:.5f} ± {uKdtM_fin:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI OLS:\")\n", + "print(f\"Atols = {Atols:.5f} ± {uAtols_fin:.5f}\")\n", + "print(f\"Btols = {Btols:.5f} ± {uBtols_fin:.5f}\")\n", + "print(f\"Kdtols = {Kdtols:.5f} ± {uKdtols_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tols:.5f} | rid = {chi2_tols/GdLt:.5f} | P = {chi2.cdf(chi2_tols, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI Carpi:\")\n", + "print(f\"AtC = {AtC:.5f} ± {uAtC_fin:.5f}\")\n", + "print(f\"BtC = {BtC:.5f} ± {uBtC_fin:.5f}\")\n", + "print(f\"KdtC = {KdtC:.5f} ± {uKdtC_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tC:.5f} | rid = {chi2_tC/GdLt:.5f} | P = {chi2.cdf(chi2_tC, GdLt):.5f}\")\n", + "\n", + "print(\"\\nRISULTATI York:\")\n", + "print(f\"AtY = {AtY:.5f} ± {uAtY_fin:.5f}\")\n", + "print(f\"BtY = {BtY:.5f} ± {uBtY_fin:.5f}\")\n", + "print(f\"KdtY = {KdtY:.5f} ± {uKdtY_fin:.5f}\")\n", + "print(f\"Chi² = {chi2_tY:.5f} | rid = {chi2_tY/GdLt:.5f} | P = {chi2.cdf(chi2_tY, GdLt):.5f}\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/statica/mollaStatica1.ipynb b/molla/statica/mollaStatica1.ipynb index d6ab88b..b6eedef 100644 --- a/molla/statica/mollaStatica1.ipynb +++ b/molla/statica/mollaStatica1.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 58, + "execution_count": 20, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 59, + "execution_count": 21, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 60, + "execution_count": 22, "id": "5494409f", "metadata": {}, "outputs": [ @@ -215,7 +215,7 @@ "4 168.53 0.002887 " ] }, - "execution_count": 60, + "execution_count": 22, "metadata": {}, "output_type": "execute_result" } @@ -226,7 +226,7 @@ }, { "cell_type": "code", - "execution_count": 61, + "execution_count": 23, "id": "976d5531", "metadata": {}, "outputs": [ @@ -282,7 +282,7 @@ }, { "cell_type": "code", - "execution_count": 62, + "execution_count": 24, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -290,10 +290,10 @@ "name": "stdout", "output_type": "stream", "text": [ - "[23.12238655 23.79957321 23.89802584 23.89480155 24.50322786 24.30058505\n", - " 24.15933014 24.09836266 23.99026349 23.88530016]\n", - "[0.22419984 0.16285763 0.10115386 0.15188559 0.31275403 0.14045171\n", - " 0.2012065 0.36234381 0.31901124 0.61345112]\n" + "[0.04459466 0.05636189 0.07164148 0.08906597 0.04476779 0.05643232\n", + " 0.07206497 0.04463879 0.05651695 0.04482161]\n", + "[0.08074652 0.11183321 0.10315038 0.2075251 0.10230673 0.09273618\n", + " 0.20255041 0.12077527 0.21682558 0.21247745]\n" ] } ], @@ -305,13 +305,13 @@ "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", "\n", "\n", - "print(K)\n", - "print(uK)" + "print(uF)\n", + "print(ueste)" ] }, { "cell_type": "code", - "execution_count": 63, + "execution_count": 25, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -360,7 +360,7 @@ }, { "cell_type": "code", - "execution_count": 64, + "execution_count": 26, "id": "7e75ec05", "metadata": {}, "outputs": [], @@ -387,7 +387,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 27, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -400,8 +400,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 2.238e+04\n", - "Date: Sat, 04 Apr 2026 Prob (F-statistic): 4.46e-15\n", - "Time: 19:37:55 Log-Likelihood: -27.238\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): 4.46e-15\n", + "Time: 15:51:49 Log-Likelihood: -27.238\n", "No. Observations: 10 AIC: 58.48\n", "Df Residuals: 8 BIC: 59.08\n", "Df Model: 1 \n", @@ -449,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 28, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -515,7 +515,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 29, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -577,7 +577,7 @@ }, { "cell_type": "code", - "execution_count": 68, + "execution_count": 30, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -653,7 +653,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 31, "id": "e2407a04", "metadata": {}, "outputs": [ @@ -722,7 +722,7 @@ }, { "cell_type": "code", - "execution_count": 70, + "execution_count": 32, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -785,7 +785,7 @@ }, { "cell_type": "code", - "execution_count": 71, + "execution_count": 33, "id": "bfb895c6", "metadata": {}, "outputs": [ @@ -868,7 +868,7 @@ }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 34, "id": "202de438", "metadata": {}, "outputs": [ @@ -942,7 +942,7 @@ }, { "cell_type": "code", - "execution_count": 73, + "execution_count": 35, "id": "caf23dbe", "metadata": {}, "outputs": [ @@ -1000,7 +1000,7 @@ }, { "cell_type": "code", - "execution_count": 74, + "execution_count": 36, "id": "8f5c8bb7", "metadata": {}, "outputs": [ @@ -1010,8 +1010,8 @@ "text": [ "u_strum_m = 0.004082\n", "u_strum_Dx = 0.020412\n", - "uF_strum = 0.089066\n", - "uK_strum = 0.662828\n" + "uF_strum = 0.058091\n", + "uK_strum = 0.273764\n" ] } ], @@ -1028,10 +1028,10 @@ "umasse_strum = np.maximum(umasse, u_strum_m)\n", "\n", "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", - "uF_strum = np.max(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", - "uDx_strum = np.max(ueste_strum)\n", + "uF_strum = np.average(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", + "uDx_strum = np.average(ueste_strum)\n", "\n", - "uK_strum = np.max(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", "\n", "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", @@ -1049,7 +1049,7 @@ }, { "cell_type": "code", - "execution_count": 75, + "execution_count": 37, "id": "a1dc24c9", "metadata": {}, "outputs": [], @@ -1096,12 +1096,12 @@ "id": "2e57c7d8", "metadata": {}, "source": [ - "## Risutltati della propagazione dell'errore strumentale massimo" + "## Risultati della propagazione dell'errore strumentale massimo" ] }, { "cell_type": "code", - "execution_count": 76, + "execution_count": 38, "id": "c8e264fa", "metadata": {}, "outputs": [ @@ -1110,22 +1110,22 @@ "output_type": "stream", "text": [ "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata K = 23.95113 ± 0.66530\n", + "Media pesata K = 23.95113 ± 0.27970\n", "\n", "RISULTATI REGRESSIONE OLS:\n", - "Aols = 23.96871 ± 0.68192\n", - "Bols = 0.09993 ± 2.98913\n", - "Chi² OLS = 3.95368 | rid = 0.49421 | P = 0.13872\n", + "Aols = 23.96871 ± 0.31720\n", + "Bols = 0.09993 ± 2.92755\n", + "Chi² OLS = 7.21389 | rid = 0.90174 | P = 0.48626\n", "\n", "RISULTATI REGRESSIONE Carpi:\n", - "AC = 24.04738 ± 0.67577\n", - "BC = -1.56983 ± 2.18409\n", - "Chi² Carpi = 4.03420 | rid = 0.50428 | P = 0.14598\n", + "AC = 24.04738 ± 0.30375\n", + "BC = -1.56983 ± 2.09901\n", + "Chi² Carpi = 7.28743 | rid = 0.91093 | P = 0.49404\n", "\n", "RISULTATI REGRESSIONE York:\n", - "AY = 24.06480 ± 0.67582\n", - "BY = -1.81758 ± 2.18788\n", - "Chi² York = 4.06701 | rid = 0.50838 | P = 0.14897\n" + "AY = 24.06480 ± 0.30386\n", + "BY = -1.81758 ± 2.10295\n", + "Chi² York = 7.33375 | rid = 0.91672 | P = 0.49891\n" ] } ], @@ -1163,8 +1163,8 @@ "\n", "In generale con il Chi² vale:\n", "- \\~50%: Errori ottimamente stimati\n", - "- \\<5% : Fit troppo grande\n", - "- \\>95%: Fit troppo piccolo\n", + "- \\<5% : Fit troppo grande (errori sovrastimati)\n", + "- \\>95%: Fit troppo piccolo (errori sottostimati)\n", "\n", "In generale mi sembra che nei paper se è presente un Chi² si riporta la probabilità complementare (probabilità di ottenere gli stessi risultati o peggio)" ] diff --git a/molla/statica/mollaStatica1Errore.ipynb b/molla/statica/mollaStatica1Errore.ipynb new file mode 100644 index 0000000..c7787ad --- /dev/null +++ b/molla/statica/mollaStatica1Errore.ipynb @@ -0,0 +1,1075 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3a8dfc0e", + "metadata": {}, + "source": [ + "# Analisi della molla statica 1" + ] + }, + { + "cell_type": "markdown", + "id": "2ff20b69", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 323, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.806\n", + "ug = 0.001" + ] + }, + { + "cell_type": "markdown", + "id": "39d2ffea", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "- Permutazioni e calcolo dei Delta" + ] + }, + { + "cell_type": "code", + "execution_count": 324, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'statica1.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "df = calcola_stats(df, \"Dx\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 325, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1Dx1Dx2Dx3Dx4Dx5Dx6DxuDxmum
088.9777.2677.2877.2677.2877.2477.4277.2900000.06542288.970.002887
1108.6168.9268.9469.0068.9868.9069.0268.9600000.047329108.610.002887
2128.6460.8861.0060.8260.9461.0860.9460.9433330.090701128.640.002887
3148.3852.9652.9652.7852.8852.8853.0052.9100000.079750148.380.002887
4168.5344.4244.6844.4844.8044.9244.5244.6366670.196943168.530.002887
\n", + "
" + ], + "text/plain": [ + " m1 Dx1 Dx2 Dx3 Dx4 Dx5 Dx6 Dx uDx \\\n", + "0 88.97 77.26 77.28 77.26 77.28 77.24 77.42 77.290000 0.065422 \n", + "1 108.61 68.92 68.94 69.00 68.98 68.90 69.02 68.960000 0.047329 \n", + "2 128.64 60.88 61.00 60.82 60.94 61.08 60.94 60.943333 0.090701 \n", + "3 148.38 52.96 52.96 52.78 52.88 52.88 53.00 52.910000 0.079750 \n", + "4 168.53 44.42 44.68 44.48 44.80 44.92 44.52 44.636667 0.196943 \n", + "\n", + " m um \n", + "0 88.97 0.002887 \n", + "1 108.61 0.002887 \n", + "2 128.64 0.002887 \n", + "3 148.38 0.002887 \n", + "4 168.53 0.002887 " + ] + }, + "execution_count": 325, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 326, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (0, 4), (1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]\n", + "10\n", + "############################################################\n", + "[ 8.33 16.34666667 24.38 32.65333333 8.01666667 16.05\n", + " 24.32333333 8.03333333 16.30666667 8.27333333]\n", + "[0.08074652 0.11183321 0.10315038 0.2075251 0.10230673 0.09273618\n", + " 0.20255041 0.12077527 0.21682558 0.21247745]\n", + "############################################################\n", + "[-19.64 -39.67 -59.41 -79.56 -20.03 -39.77 -59.92 -19.74 -39.89 -20.15]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248\n", + " 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.Dx[x] - df.Dx[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uDx[x]**2 + df.uDx[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "5b3b6776", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 327, + "id": "22ee2969", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.122474\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.3\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 328, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.06306119 0.07970365 0.10131313 0.12595571 0.06330605 0.07980326\n", + " 0.10191206 0.06312361 0.07992295 0.06338217]\n", + "[0.14669697 0.16585134 0.16012495 0.24097026 0.15958279 0.15362291\n", + " 0.23669953 0.17200775 0.24902476 0.24524817]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "uF = np.sqrt(uF**2 + uF_strum**2)\n", + "ueste = np.sqrt(uDx_strum**2 + ueste**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(uF)\n", + "print(ueste)" + ] + }, + { + "cell_type": "code", + "execution_count": 329, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 23.960003307113187\n", + "sigmaC: 0.08168429733984035\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "02fc45a9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 330, + "id": "7e75ec05", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": ueste,\n", + " \"y\": - F,\n", + " \"uy\": uF\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "313237da", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 331, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 2.238e+04\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): 4.46e-15\n", + "Time: 16:05:09 Log-Likelihood: -27.237\n", + "No. Observations: 10 AIC: 58.47\n", + "Df Residuals: 8 BIC: 59.08\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0999 2.914 0.034 0.973 -6.621 6.821\n", + "x 23.9663 0.160 149.602 0.000 23.597 24.336\n", + "==============================================================================\n", + "Omnibus: 0.134 Durbin-Watson: 0.595\n", + "Prob(Omnibus): 0.935 Jarque-Bera (JB): 0.285\n", + "Skew: -0.202 Prob(JB): 0.867\n", + "Kurtosis: 2.277 Cond. No. 40.8\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 23.96627 ± 0.16020\n", + "Bols = 0.09992 ± 2.91442\n", + "R² = 0.99964\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 332, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 333, + "id": "986ff4a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 8.98934\n", + "GdL = 8\n", + "Chi² rid = 1.12367\n", + "P(0, chi²)= 0.65680\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 4.133515\n", + "1 0.519142\n", + "2 0.225526\n", + "3 0.189276\n", + "4 1.196827\n", + "5 2.013893\n", + "6 0.639176\n", + "7 0.052148\n", + "8 0.001775\n", + "9 0.018061\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "6015e6fd", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 334, + "id": "2d4b7144", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 23.9876 ± 0.1850\n", + "BC = -0.4229 ± 3.1072\n", + "cov_ABC = -0.515395\n", + "P(0, chi²)= 0.6507\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} ± {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} ± {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 335, + "id": "e2407a04", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 336, + "id": "32e9948f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 8.93858\n", + "GdL = 8\n", + "Chi² rid = 1.11732\n", + "P(0, chi²)= 0.65250\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 3.737859\n", + "1 0.457413\n", + "2 0.224745\n", + "3 0.216224\n", + "4 1.403759\n", + "5 2.150882\n", + "6 0.638812\n", + "7 0.098109\n", + "8 0.005076\n", + "9 0.005697\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "ad1c81fc", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 337, + "id": "bfb895c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 24.0003646 ± 0.1848548\n", + "BY = -0.6143995 ± 3.1050788\n", + "cov_ABY = -0.5147053957702236\n", + "chi² = 8.93384\n", + "chi² rid = 1.11673\n", + "P(0, chi²)= 0.65209\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 338, + "id": "202de438", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "63442336", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati" + ] + }, + { + "cell_type": "code", + "execution_count": 339, + "id": "caf23dbe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 23.96000 ± 0.08168\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 23.96627 ± 0.16020\n", + "Bols = 0.09992 ± 2.91442\n", + "P(0, chi²)= 0.65680\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 23.98765 ± 0.18498\n", + "Bc = -0.42288 ± 3.10716\n", + "P(0, chi²)= 0.65250\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 24.00036 ± 0.18485\n", + "By = -0.61440 ± 3.10508\n", + "P(0, chi²)= 0.65209\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1e38b0bd", + "metadata": {}, + "source": [ + "## Minima interpretazione (Mio commento -> Non necessario)\n", + "Sovrastimando l'errore in modo molto marcato ovviamente il Chi² viene ridotto.\n", + "Il Chi² che stiamo usando serve per stimare quale sia la probabilità di ottenere un Chi² minore o uguale a quello osservato.\n", + "Sapendo che il valore buono è ~50% stiamo un po' allargando le distribuzioni in modo un po' esagerato.\n", + "\n", + "In generale con il Chi² vale:\n", + "- \\~50%: Errori ottimamente stimati\n", + "- \\<5% : Fit troppo grande (errori sovrastimati)\n", + "- \\>95%: Fit troppo piccolo (errori sottostimati)\n", + "\n", + "In generale mi sembra che nei paper se è presente un Chi² si riporta la probabilità complementare (probabilità di ottenere gli stessi risultati o peggio)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/molla/statica/mollaStatica2.ipynb b/molla/statica/mollaStatica2.ipynb index f09bde9..fe194a3 100644 --- a/molla/statica/mollaStatica2.ipynb +++ b/molla/statica/mollaStatica2.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 82, + "execution_count": 105, "id": "f34c5b88", "metadata": {}, "outputs": [], @@ -51,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 106, "id": "08efb2be", "metadata": {}, "outputs": [], @@ -86,7 +86,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 107, "id": "5494409f", "metadata": {}, "outputs": [ @@ -199,7 +199,7 @@ "3 0.188750 108.610000 0.002887 " ] }, - "execution_count": 84, + "execution_count": 107, "metadata": {}, "output_type": "execute_result" } @@ -210,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 108, "id": "976d5531", "metadata": {}, "outputs": [ @@ -265,7 +265,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 109, "id": "2ad19283", "metadata": {}, "outputs": [ @@ -292,7 +292,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 110, "id": "5f59d6c9", "metadata": {}, "outputs": [ @@ -341,7 +341,7 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 111, "id": "7e75ec05", "metadata": {}, "outputs": [], @@ -368,7 +368,7 @@ }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 112, "id": "aefe7756", "metadata": {}, "outputs": [ @@ -381,8 +381,8 @@ "Dep. Variable: y R-squared: 1.000\n", "Model: OLS Adj. R-squared: 1.000\n", "Method: Least Squares F-statistic: 1.277e+05\n", - "Date: Sat, 04 Apr 2026 Prob (F-statistic): 3.68e-10\n", - "Time: 19:38:07 Log-Likelihood: -7.2422\n", + "Date: Mon, 06 Apr 2026 Prob (F-statistic): 3.68e-10\n", + "Time: 10:04:08 Log-Likelihood: -7.2422\n", "No. Observations: 6 AIC: 18.48\n", "Df Residuals: 4 BIC: 18.07\n", "Df Model: 1 \n", @@ -438,7 +438,7 @@ }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 113, "id": "1d42b009", "metadata": {}, "outputs": [ @@ -504,7 +504,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 114, "id": "986ff4a6", "metadata": {}, "outputs": [ @@ -562,7 +562,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 115, "id": "2d4b7144", "metadata": {}, "outputs": [ @@ -638,7 +638,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 116, "id": "e2407a04", "metadata": {}, "outputs": [ @@ -707,7 +707,7 @@ }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 117, "id": "32e9948f", "metadata": {}, "outputs": [ @@ -766,7 +766,7 @@ }, { "cell_type": "code", - "execution_count": 95, + "execution_count": 118, "id": "bfb895c6", "metadata": {}, "outputs": [ @@ -849,7 +849,7 @@ }, { "cell_type": "code", - "execution_count": 96, + "execution_count": 119, "id": "202de438", "metadata": {}, "outputs": [ @@ -923,7 +923,7 @@ }, { "cell_type": "code", - "execution_count": 97, + "execution_count": 120, "id": "caf23dbe", "metadata": {}, "outputs": [ @@ -981,7 +981,7 @@ }, { "cell_type": "code", - "execution_count": 98, + "execution_count": 121, "id": "8f5c8bb7", "metadata": {}, "outputs": [ @@ -991,8 +991,8 @@ "text": [ "u_strum_m = 0.004082\n", "u_strum_Dx = 0.020412\n", - "uF_strum = 0.071603\n", - "uK_strum = 0.022946\n" + "uF_strum = 0.053018\n", + "uK_strum = 0.012599\n" ] } ], @@ -1009,10 +1009,10 @@ "umasse_strum = np.maximum(umasse, u_strum_m)\n", "\n", "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", - "uF_strum = np.max(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", - "uDx_strum = np.max(ueste_strum)\n", + "uF_strum = np.average(np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 ))\n", + "uDx_strum = np.average(ueste_strum)\n", "\n", - "uK_strum = np.max(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", "\n", "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", @@ -1030,7 +1030,7 @@ }, { "cell_type": "code", - "execution_count": 99, + "execution_count": 122, "id": "a1dc24c9", "metadata": {}, "outputs": [], @@ -1082,7 +1082,7 @@ }, { "cell_type": "code", - "execution_count": 100, + "execution_count": 123, "id": "c8e264fa", "metadata": {}, "outputs": [ @@ -1091,22 +1091,22 @@ "output_type": "stream", "text": [ "RISULTATI CON ERRORE STRUMENTALE INCLUSO:\n", - "Media pesata K = 3.20156 ± 0.02327\n", + "Media pesata K = 3.20156 ± 0.01318\n", "\n", "RISULTATI REGRESSIONE OLS:\n", - "Aols = 3.20145 ± 0.02463\n", - "Bols = 0.02655 ± 0.99102\n", - "Chi² OLS = 1.17582 | rid = 0.29396 | P = 0.11794\n", + "Aols = 3.20145 ± 0.01546\n", + "Bols = 0.02655 ± 0.99084\n", + "Chi² OLS = 1.52520 | rid = 0.38130 | P = 0.17783\n", "\n", "RISULTATI REGRESSIONE Carpi:\n", - "AC = 3.20054 ± 0.02472\n", - "BC = 0.11948 ± 0.95263\n", - "Chi² Carpi = 1.17417 | rid = 0.29354 | P = 0.11767\n", + "AC = 3.20054 ± 0.01559\n", + "BC = 0.11948 ± 0.95244\n", + "Chi² Carpi = 1.52143 | rid = 0.38036 | P = 0.17716\n", "\n", "RISULTATI REGRESSIONE York:\n", - "AY = 3.20061 ± 0.02472\n", - "BY = 0.11263 ± 0.95193\n", - "Chi² York = 1.17400 | rid = 0.29350 | P = 0.11764\n" + "AY = 3.20061 ± 0.01559\n", + "BY = 0.11263 ± 0.95173\n", + "Chi² York = 1.52133 | rid = 0.38033 | P = 0.17714\n" ] } ], diff --git a/molla/statica/mollaStatica2Errore.ipynb b/molla/statica/mollaStatica2Errore.ipynb new file mode 100644 index 0000000..4617623 --- /dev/null +++ b/molla/statica/mollaStatica2Errore.ipynb @@ -0,0 +1,1056 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3a8dfc0e", + "metadata": {}, + "source": [ + "# Analisi della molla statica 1" + ] + }, + { + "cell_type": "markdown", + "id": "2ff20b69", + "metadata": {}, + "source": [ + "## Import delle librerie e set di variabili gloabali" + ] + }, + { + "cell_type": "code", + "execution_count": 154, + "id": "f34c5b88", + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy as sc\n", + "from scipy.stats import chi2\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib as mpl\n", + "import statsmodels.api as sm\n", + "\n", + "\n", + "g = 9.806\n", + "ug = 0.001" + ] + }, + { + "cell_type": "markdown", + "id": "39d2ffea", + "metadata": {}, + "source": [ + "## Lettura dei dati e calcolo delle deviazioni standard campionarie\n", + "- Lettura del CSV\n", + "- Creazione del data frame\n", + "- Deviazioni standard\n", + "- Permutazioni e calcolo dei Delta" + ] + }, + { + "cell_type": "code", + "execution_count": 155, + "id": "08efb2be", + "metadata": {}, + "outputs": [], + "source": [ + "df = pd.read_csv(r'statica2.csv')\n", + "\n", + "def calcola_stats(df, prefix, err_arbitrario):\n", + " cols = [col for col in df.columns if col.startswith(prefix)]\n", + "\n", + " def riga_stats(row):\n", + " valori = row[cols].dropna()\n", + " n = len(valori)\n", + "\n", + " if n == 0:\n", + " return pd.Series({prefix: np.nan, f\"u{prefix}\": np.nan})\n", + " elif n == 1:\n", + " return pd.Series({prefix: valori.iloc[0], f\"u{prefix}\": err_arbitrario})\n", + " else:\n", + " media = valori.mean()\n", + " sigma = valori.std(ddof=1)\n", + " return pd.Series({prefix: media, f\"u{prefix}\": sigma})\n", + "\n", + " stats = df.apply(riga_stats, axis=1)\n", + " df[prefix] = stats[prefix]\n", + " df[f\"u{prefix}\"] = stats[f\"u{prefix}\"]\n", + "\n", + " return df\n", + "\n", + "df = calcola_stats(df, \"Dx\", err_arbitrario=0.01)\n", + "df = calcola_stats(df, \"m\", err_arbitrario=0.0028867513)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 156, + "id": "5494409f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
m1Dx1Dx2Dx3Dx4Dx5Dx6DxuDxmum
049.246667212.10211.64212.00212.18212.52212.04212.0800000.28481649.2466670.002887
169.276667150.92150.26150.02150.16150.40150.18150.3233330.31784769.2766670.002887
288.96666790.3490.3490.3890.5290.2690.2890.3533330.09266488.9666670.002887
3108.61000029.8230.1830.1030.2030.1030.4030.1333330.188750108.6100000.002887
\n", + "
" + ], + "text/plain": [ + " m1 Dx1 Dx2 Dx3 Dx4 Dx5 Dx6 Dx \\\n", + "0 49.246667 212.10 211.64 212.00 212.18 212.52 212.04 212.080000 \n", + "1 69.276667 150.92 150.26 150.02 150.16 150.40 150.18 150.323333 \n", + "2 88.966667 90.34 90.34 90.38 90.52 90.26 90.28 90.353333 \n", + "3 108.610000 29.82 30.18 30.10 30.20 30.10 30.40 30.133333 \n", + "\n", + " uDx m um \n", + "0 0.284816 49.246667 0.002887 \n", + "1 0.317847 69.276667 0.002887 \n", + "2 0.092664 88.966667 0.002887 \n", + "3 0.188750 108.610000 0.002887 " + ] + }, + "execution_count": 156, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 157, + "id": "976d5531", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0, 1), (0, 2), (0, 3), (1, 2), (1, 3), (2, 3)]\n", + "6\n", + "############################################################\n", + "[ 61.75666667 121.72666667 181.94666667 59.97 120.19\n", + " 60.22 ]\n", + "[0.42678644 0.29951071 0.34168211 0.33107904 0.36966652 0.21026967]\n", + "############################################################\n", + "[-20.03 -39.72 -59.36333333 -19.69 -39.33333333\n", + " -19.64333333]\n", + "[0.00408248 0.00408248 0.00408248 0.00408248 0.00408248 0.00408248]\n" + ] + } + ], + "source": [ + "perm = [(x,i) for x in range(0,len(df)) for i in range(x+1,len(df))]\n", + "\n", + "este = np.array([df.Dx[x] - df.Dx[j] for x,j in perm])\n", + "ueste = np.array([np.sqrt(df.uDx[x]**2 + df.uDx[j]**2) for x,j in perm])\n", + "\n", + "masse = np.array([df.m[x] - df.m[j] for x,j in perm])\n", + "umasse = np.array([np.sqrt(df.um[x]**2 + df.um[j]**2) for x,j in perm])\n", + "\n", + "\n", + "print(perm)\n", + "print(len(perm))\n", + "\n", + "print(\"#\"* 60)\n", + "print(este)\n", + "print(ueste)\n", + "\n", + "print(\"#\"* 60)\n", + "print(masse)\n", + "print(umasse)" + ] + }, + { + "cell_type": "markdown", + "id": "5b3b6776", + "metadata": {}, + "source": [ + "## Calcolo dei K e media pesata\n", + "- Calcolo del K\n", + "- Calcolo della media pesata (sui K)" + ] + }, + { + "cell_type": "code", + "execution_count": 158, + "id": "22ee2969", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u_strum_m = 0.004082\n", + "u_strum_Dx = 0.020412\n" + ] + } + ], + "source": [ + "res_b = 0.01\n", + "res_c = 0.05\n", + "\n", + "# Incertezza strumentale su una differenza: res/sqrt(12) * sqrt(2) = res/sqrt(6)\n", + "u_strum_m = res_b / np.sqrt(6)\n", + "u_strum_Dx = res_c / np.sqrt(6)\n", + "\n", + "# Massimo tra campionario e strumentale, punto per punto\n", + "ueste_strum = u_strum_Dx\n", + "umasse_strum = u_strum_m\n", + "\n", + "# Worst-case scalare: prendi il massimo anche di ueste_strum\n", + "uF_strum = np.sqrt( (g * umasse_strum)**2 + (masse * ug)**2 )\n", + "uDx_strum = ueste_strum\n", + "\n", + "# uK_strum = np.average(np.sqrt( (1/este)**2 * uF_strum**2 + (F/este**2)**2 * uDx_strum**2 ))\n", + "\n", + "print(f\"u_strum_m = {u_strum_m:.6f}\")\n", + "print(f\"u_strum_Dx = {u_strum_Dx:.6f}\")\n", + "# print(f\"uF_strum = {uF_strum:.6f}\")\n", + "# print(f\"uK_strum = {uK_strum:.6f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 159, + "id": "2ad19283", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.06330605 0.07975344 0.10125841 0.06309237 0.07936924 0.06306327]\n", + "[0.42727431 0.30020549 0.3422913 0.3317077 0.37022966 0.21125814]\n" + ] + } + ], + "source": [ + "F = masse * g\n", + "uF = np.sqrt((g * umasse)**2 + (masse * ug)**2)\n", + "\n", + "uF = np.sqrt(uF**2 + uF_strum**2)\n", + "ueste = np.sqrt(uDx_strum**2 + ueste**2)\n", + "\n", + "K = - F / este\n", + "uK = np.sqrt((1/este)**2 * uF**2 + (F / este**2)**2 * ueste**2 )\n", + "\n", + "\n", + "print(uF)\n", + "print(ueste)" + ] + }, + { + "cell_type": "code", + "execution_count": 160, + "id": "5f59d6c9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "K-medio: 3.2012390383768037\n", + "sigmaC: 0.0038754337050082212\n" + ] + } + ], + "source": [ + "def mediaPesata(x, ux, dim = 0):\n", + " x_arr = x.to_numpy() if isinstance(x, (pd.Series, pd.DataFrame)) else np.asarray(x)\n", + " sigma_arr = ux.to_numpy() if isinstance(ux, (pd.Series, pd.DataFrame)) else np.asarray(ux)\n", + "\n", + " w = 1.0 / (sigma_arr ** 2)\n", + "\n", + " num = np.nansum(w * x_arr, axis=dim)\n", + " den = np.nansum(w, axis=dim)\n", + "\n", + " media = num / den\n", + " sigma = np.sqrt(1.0 / den)\n", + "\n", + " return media, sigma\n", + "\n", + "media, uA = mediaPesata(K, uK)\n", + "print(\"K-medio:\", media)\n", + "print(\"sigmaC: \", uA)" + ] + }, + { + "cell_type": "markdown", + "id": "02fc45a9", + "metadata": {}, + "source": [ + "## Analisi con regressioni e grafici\n", + "Ogni blocco ha:\n", + "- Regressione\n", + "- grafico\n", + "- chi^2\n", + "\n", + "Nota: Ax + B" + ] + }, + { + "cell_type": "code", + "execution_count": 161, + "id": "7e75ec05", + "metadata": {}, + "outputs": [], + "source": [ + "sns.set_theme(style=\"whitegrid\")\n", + "\n", + "data = pd.DataFrame({\n", + " \"x\": este,\n", + " \"ux\": ueste,\n", + " \"y\": - F,\n", + " \"uy\": uF\n", + "})" + ] + }, + { + "cell_type": "markdown", + "id": "313237da", + "metadata": {}, + "source": [ + "### Regressione lineare \"OLS\"\n", + "\n", + "Non tiene conto dei nostri errori, un risultato puro e semplice" + ] + }, + { + "cell_type": "code", + "execution_count": 162, + "id": "aefe7756", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " OLS Regression Results \n", + "==============================================================================\n", + "Dep. Variable: y R-squared: 1.000\n", + "Model: OLS Adj. R-squared: 1.000\n", + "Method: Least Squares F-statistic: 1.277e+05\n", + "Date: Tue, 07 Apr 2026 Prob (F-statistic): 3.68e-10\n", + "Time: 16:16:38 Log-Likelihood: -7.2416\n", + "No. Observations: 6 AIC: 18.48\n", + "Df Residuals: 4 BIC: 18.07\n", + "Df Model: 1 \n", + "Covariance Type: nonrobust \n", + "==============================================================================\n", + " coef std err t P>|t| [0.025 0.975]\n", + "------------------------------------------------------------------------------\n", + "const 0.0265 0.991 0.027 0.980 -2.724 2.777\n", + "x 3.2011 0.009 357.408 0.000 3.176 3.226\n", + "==============================================================================\n", + "Omnibus: nan Durbin-Watson: 1.155\n", + "Prob(Omnibus): nan Jarque-Bera (JB): 0.275\n", + "Skew: -0.058 Prob(JB): 0.871\n", + "Kurtosis: 1.957 Cond. No. 271.\n", + "==============================================================================\n", + "\n", + "Notes:\n", + "[1] Standard Errors assume that the covariance matrix of the errors is correctly specified.\n", + "\n", + "RISULTATI REGRESSIONE:\n", + "Aols = 3.20112 ± 0.00896\n", + "Bols = 0.02655 ± 0.99066\n", + "R² = 0.99997\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/jack/uni/lab/.venv/lib/python3.13/site-packages/statsmodels/stats/stattools.py:74: ValueWarning: omni_normtest is not valid with less than 8 observations; 6 samples were given.\n", + " warn(\"omni_normtest is not valid with less than 8 observations; %i \"\n" + ] + } + ], + "source": [ + "X = sm.add_constant(data[\"x\"])\n", + "model = sm.OLS(data[\"y\"], X).fit()\n", + "\n", + "print(model.summary())\n", + "\n", + "# Estrazione parametri\n", + "Bols = model.params[\"const\"]\n", + "Aols = model.params[\"x\"]\n", + "uBols = model.bse[\"const\"]\n", + "uAols = model.bse[\"x\"]\n", + "R2 = model.rsquared\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"R² = {R2:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 163, + "id": "1d42b009", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = Bols + Aols * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare OLS\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 164, + "id": "986ff4a6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 2.76283\n", + "GdL = 4\n", + "Chi² rid = 0.69071\n", + "P(0, chi²)= 0.40173\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.905553\n", + "1 0.040505\n", + "2 0.097209\n", + "3 1.035334\n", + "4 0.617420\n", + "5 0.066809\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = Bols + Aols * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (Aols * data[\"ux\"])**2)\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "Pols = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "6015e6fd", + "metadata": {}, + "source": [ + "### Regressione lineare Carpi" + ] + }, + { + "cell_type": "code", + "execution_count": 165, + "id": "2d4b7144", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ax + B : \n", + "AC = 3.2002 ± 0.0092\n", + "BC = 0.1201 ± 0.9568\n", + "cov_ABC = -0.008013\n", + "P(0, chi²)= 0.3995\n" + ] + } + ], + "source": [ + "def sigma_y_equiv(x, y, sigma_x, sigma_y):\n", + " # Stima iniziale di A con sola sigma_y\n", + " sy2 = sigma_y**2\n", + " Sw = np.sum(1 / sy2)\n", + " Sx = np.sum(x / sy2)\n", + " Sxx = np.sum(x**2 / sy2)\n", + " Sy = np.sum(y / sy2)\n", + " Sxy = np.sum(x * y / sy2)\n", + " delta = Sxx * Sw - Sx**2\n", + " A_est = (Sxy * Sw - Sx * Sy) / delta\n", + "\n", + " # Propagazione\n", + " sigma_eq = np.sqrt(sigma_y**2 + A_est**2 * sigma_x**2)\n", + " return sigma_eq\n", + "\n", + "\n", + "def reg_lin(x, y, sigma_x, sigma_y):\n", + " x = np.asarray(x, dtype=float)\n", + " y = np.asarray(y, dtype=float)\n", + " sigma_x = np.asarray(sigma_x, dtype=float)\n", + " sigma_y = np.asarray(sigma_y, dtype=float)\n", + "\n", + " # Propagazione errore x → y\n", + " sigma_y_eq = sigma_y_equiv(x, y, sigma_x, sigma_y)\n", + "\n", + " # Somme pesate\n", + " w = 1.0 / sigma_y_eq**2\n", + " Sw = np.sum(w)\n", + " Sx = np.sum(w * x)\n", + " Sxx = np.sum(w * x**2)\n", + " Sy = np.sum(w * y)\n", + " Sxy = np.sum(w * x * y)\n", + " delta = Sxx * Sw - Sx**2\n", + "\n", + " # Parametri\n", + " A = (Sxy * Sw - Sx * Sy) / delta\n", + " B = (Sxx * Sy - Sxy * Sx) / delta\n", + " sigma_A = np.sqrt(Sw / delta)\n", + " sigma_B = np.sqrt(Sxx / delta)\n", + " cov_AB = -Sx / delta\n", + "\n", + " # Chi quadro\n", + " x2 = np.sum((y - A * x - B)**2 / sigma_y_eq**2)\n", + " dof = len(x) - 2\n", + " chi = sc.stats.chi2.cdf(x2, dof) # P(X² > x2)\n", + "\n", + " return A, B, sigma_A, sigma_B, cov_AB, chi\n", + "\n", + "\n", + "AC, BC, uAC, uBC, covABC, chiC = reg_lin(data[\"x\"], data[\"y\"], data[\"ux\"], data[\"uy\"])\n", + "print(\"Ax + B : \")\n", + "print(f\"AC = {AC:.4f} ± {uAC:.4f}\")\n", + "print(f\"BC = {BC:.4f} ± {uBC:.4f}\")\n", + "print(f\"cov_ABC = {covABC:.6f}\")\n", + "print(f\"P(0, chi²)= {chiC:.4f}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 166, + "id": "e2407a04", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot(\n", + " data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BC + AC * xfit\n", + "\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare Carpi\"\n", + ")\n", + "\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 167, + "id": "32e9948f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Chi² = 2.75428\n", + "GdL = 4\n", + "Chi² rid = 0.68857\n", + "P(0, chi²)= 0.40025\n", + "\n", + "\n", + "############################################################\n", + "capiamo quale dato sta contribuendo maggiormente\n", + "0 0.958978\n", + "1 0.033756\n", + "2 0.060884\n", + "3 0.962374\n", + "4 0.638537\n", + "5 0.099753\n", + "dtype: float64\n" + ] + } + ], + "source": [ + "F_fit = BC + AC * data[\"x\"]\n", + "sigma = np.sqrt(data[\"uy\"]**2 + (AC * data[\"ux\"])**2)\n", + "\n", + "\n", + "chi2_val = np.sum( ((data[\"y\"] - F_fit) / sigma)**2 )\n", + "\n", + "N = len(data)\n", + "nu = N - 2\n", + "\n", + "chi2_red = chi2_val / nu\n", + "PC = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"Chi² = {chi2_val:.5f}\")\n", + "print(f\"GdL = {nu}\")\n", + "print(f\"Chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "print(\"\\n\\n\" + \"#\"*60)\n", + "print(\"capiamo quale dato sta contribuendo maggiormente\")\n", + "print(((data[\"y\"] - F_fit) / sigma)**2)" + ] + }, + { + "cell_type": "markdown", + "id": "ad1c81fc", + "metadata": {}, + "source": [ + "### Regressione lineare pesata Yorkfit " + ] + }, + { + "cell_type": "code", + "execution_count": 168, + "id": "bfb895c6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AY = 3.2002863 ± 0.0092220\n", + "BY = 0.1132724 ± 0.9560993\n", + "cov_ABY = -0.008001359496108713\n", + "chi² = 2.75422\n", + "chi² rid = 0.68856\n", + "P(0, chi²)= 0.40024\n" + ] + } + ], + "source": [ + "def york_fit(x, y, sx, sy, max_iter=50, tol=1e-15):\n", + " # Pesi iniziali\n", + " wx = 1 / sx**2\n", + " wy = 1 / sy**2\n", + "\n", + " # Stima iniziale della pendenza (OLS y|x)\n", + " A = np.cov(x, y, aweights=wy)[0,1] / np.cov(x, x, aweights=wy)[0,1]\n", + "\n", + " for _ in range(max_iter):\n", + " A_old = A\n", + "\n", + " # 1) Pesi combinati\n", + " Wi = (wx * wy) / (A**2 * wy + wx)\n", + "\n", + " # 2) x e y pesati (eq. 10)\n", + " X_bar = np.sum(Wi * x) / np.sum(Wi)\n", + " Y_bar = np.sum(Wi * y) / np.sum(Wi)\n", + "\n", + " # 3) Variabili centrate\n", + " Ui = x - X_bar\n", + " Vi = y - Y_bar\n", + "\n", + " # 4) beta\n", + " beta_i = Wi * (Ui / wy + A * Vi / wx)\n", + "\n", + " # 5) Aggiornamento pendenza\n", + " A = np.sum(Wi * beta_i * Vi) / np.sum(Wi * beta_i * Ui)\n", + "\n", + " # Convergenza\n", + " if abs(A - A_old) < tol:\n", + " break\n", + "\n", + " # 6) Intercetta\n", + " B = Y_bar - A * X_bar\n", + "\n", + " # S = somma Wi (xi - x)**2\n", + " S = np.sum(Wi * Ui**2)\n", + "\n", + " sA = np.sqrt(1 / S)\n", + " sB = np.sqrt(1 / np.sum(Wi) + X_bar**2 * sA**2)\n", + "\n", + " # cov(A,B)\n", + " cov_AB = -X_bar * sA**2\n", + "\n", + " # CHI QUADRATO\n", + " chi2 = np.sum(Wi * (Vi - A * Ui)**2)\n", + " dof = len(x) - 2\n", + " chi2_red = chi2 / dof\n", + "\n", + " return A, B, sA, sB, cov_AB, chi2, chi2_red\n", + "\n", + "AY, BY, uAY, uBY, cov_ABY, chi2_val, chi2_red = york_fit(data.x, data.y, data.ux, data.uy)\n", + "PY = chi2.cdf(chi2_val, df=nu)\n", + "\n", + "\n", + "print(f\"AY = {AY:.7f} ± {uAY:.7f}\")\n", + "print(f\"BY = {BY:.7f} ± {uBY:.7f}\")\n", + "print(f\"cov_ABY = {cov_ABY}\")\n", + "print(f\"chi² = {chi2_val:.5f}\")\n", + "print(f\"chi² rid = {chi2_red:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 169, + "id": "202de438", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10,6))\n", + "\n", + "# Seaborn scatter\n", + "sns.scatterplot( data=data,\n", + " x=\"x\",\n", + " y=\"y\",\n", + " s=7\n", + ")\n", + "\n", + "# Barre d’errore\n", + "plt.errorbar(\n", + " data[\"x\"],\n", + " data[\"y\"],\n", + " xerr=data[\"ux\"],\n", + " yerr=data[\"uy\"],\n", + " fmt=\"none\",\n", + " ecolor=\"gray\",\n", + " elinewidth=1,\n", + " capsize=3,\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Linea di regressione\n", + "xfit = np.linspace(0, data[\"x\"].max(), 200)\n", + "yfit = BY + AY * xfit\n", + "\n", + "plt.plot(\n", + " xfit,\n", + " yfit,\n", + " color=\"crimson\",\n", + " linewidth=1,\n", + " zorder=10,\n", + " label=\"Fit lineare York\"\n", + ")\n", + "\n", + "plt.xlim(left=0)\n", + "plt.ylim(bottom=0)\n", + "\n", + "\n", + "plt.xlabel(\"Δx (mm)\")\n", + "plt.ylabel(\"Forza F (mN)\")\n", + "plt.title(\"Legge di Hooke — punti permutati con errorbar\")\n", + "plt.legend()\n", + "plt.grid(True, linestyle=\"--\", alpha=0.1)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "63442336", + "metadata": {}, + "source": [ + "## Raccolta finale dei dati" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "id": "caf23dbe", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "RISULTATI senza ERRORE STRUMENTALE INCLUSO:\n", + "Media pesata K = 3.20124 ± 0.00388\n", + "\n", + "RISULTATI REGRESSIONE OLS:\n", + "Aols = 3.20112 ± 0.00896\n", + "Bols = 0.02655 ± 0.99066\n", + "P(0, chi²)= 0.40173\n", + "\n", + "RISULTATI REGRESSIONE Carpi:\n", + "Ac = 3.20021 ± 0.00923\n", + "Bc = 0.12013 ± 0.95680\n", + "P(0, chi²)= 0.40025\n", + "\n", + "RISULTATI REGRESSIONE York:\n", + "Ay = 3.20029 ± 0.00922\n", + "By = 0.11327 ± 0.95610\n", + "P(0, chi²)= 0.40024\n" + ] + } + ], + "source": [ + "print(\"RISULTATI senza ERRORE STRUMENTALE INCLUSO:\")\n", + "print(f\"Media pesata K = {media:.5f} ± {uA:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE OLS:\")\n", + "print(f\"Aols = {Aols:.5f} ± {uAols:.5f}\")\n", + "print(f\"Bols = {Bols:.5f} ± {uBols:.5f}\")\n", + "print(f\"P(0, chi²)= {Pols:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE Carpi:\")\n", + "print(f\"Ac = {AC:.5f} ± {uAC:.5f}\")\n", + "print(f\"Bc = {BC:.5f} ± {uBC:.5f}\")\n", + "print(f\"P(0, chi²)= {PC:.5f}\")\n", + "\n", + "print(\"\\nRISULTATI REGRESSIONE York:\")\n", + "print(f\"Ay = {AY:.5f} ± {uAY:.5f}\")\n", + "print(f\"By = {BY:.5f} ± {uBY:.5f}\")\n", + "print(f\"P(0, chi²)= {PY:.5f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "1e38b0bd", + "metadata": {}, + "source": [ + "## Minima interpretazione (Mio commento -> Non necessario)\n", + "Sovrastimando l'errore in modo molto marcato ovviamente il Chi² viene ridotto.\n", + "Il Chi² che stiamo usando serve per stimare quale sia la probabilità di ottenere un Chi² minore o uguale a quello osservato.\n", + "Sapendo che il valore buono è ~50% stiamo un po' allargando le distribuzioni in modo un po' esagerato.\n", + "\n", + "In generale con il Chi² vale:\n", + "- \\~50%: Errori ottimamente stimati\n", + "- \\<5% : Fit troppo grande (errori sovrastimati)\n", + "- \\>95%: Fit troppo piccolo (errori sottostimati)\n", + "\n", + "In generale mi sembra che nei paper se è presente un Chi² si riporta la probabilità complementare (probabilità di ottenere gli stessi risultati o peggio)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": ".venv", + "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.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}