From b9c1006aff7ab6231c1ccb9230c518dedfa14ade Mon Sep 17 00:00:00 2001 From: Bert Debusschere Date: Fri, 8 Sep 2023 17:39:30 -0700 Subject: [PATCH] refining pybcs demo --- PyUQTk/PyPCE/pce_tools.py | 7 +- .../surrogate_genz-BCS_detailed.ipynb | 4087 ++++++++++++++--- 2 files changed, 3350 insertions(+), 744 deletions(-) diff --git a/PyUQTk/PyPCE/pce_tools.py b/PyUQTk/PyPCE/pce_tools.py index 1701aa0..277039a 100644 --- a/PyUQTk/PyPCE/pce_tools.py +++ b/PyUQTk/PyPCE/pce_tools.py @@ -418,6 +418,7 @@ def UQTkBCS(pc_begin, xdata, ydata, eta=1.e-3, niter=1, mindex_growth=None, ntry pc_model_final: PC object with basis expanded by the iterations cfs_final: 1D Numpy array with PC coefficients for each term of the final model [#terms_in_final_basis,] + sigma2: data noise variance, updated by bcs algorithm (if desired), scalar """ # Sends error message if y-values are multi-dimensional @@ -561,12 +562,14 @@ def UQTkBCS(pc_begin, xdata, ydata, eta=1.e-3, niter=1, mindex_growth=None, ntry print("Coefficients:") print(cfs_final) print(len(cfs_final), " terms retained out of a full basis of size", full_basis_size) - print("Reestimated sigma2:", sigma2) + print("Reestimated sigma2: %.3e"%sigma2) if return_sigma2: return pc_model_final, cfs_final, sigma2 else: - print("Please note that sigma2 will be returned by default in future versions.") + print("\nPlease note that sigma2 will be returned by default in future versions.") + print("To remain compatible, set input argument return_sigma2 to True and expect") + print("three return arguments: pc_model, coefficients, updated noise variance\n") return pc_model_final, cfs_final ################################################################################ def UQTkOptimizeEta(pc_start, y, x, etas, niter, nfolds, mindex_growth, verbose, plot=False): diff --git a/examples/surrogate_genz/surrogate_genz-BCS_detailed.ipynb b/examples/surrogate_genz/surrogate_genz-BCS_detailed.ipynb index 2a05c22..38cb5db 100644 --- a/examples/surrogate_genz/surrogate_genz-BCS_detailed.ipynb +++ b/examples/surrogate_genz/surrogate_genz-BCS_detailed.ipynb @@ -20,19 +20,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 12, "id": "f74bf835-9ef7-452b-85cc-7fd3ebbe7dd3", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "PyMC is required for some of the MCMC postprocessing codes.\n", - "Will proceed without, but some convergence tests will not be available.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "import math \n", @@ -41,7 +32,9 @@ "\n", "import PyUQTk.pce as uqtkpce\n", "import PyUQTk.PyPCE.pce_tools as pce_tools\n", - "from PyUQTk.utils.func import *" + "from PyUQTk.utils.func import *\n", + "\n", + "import matplotlib.pyplot as plt" ] }, { @@ -55,7 +48,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 6, "id": "aa0bbccd-c5e7-40ab-a720-9ccf740514e9", "metadata": {}, "outputs": [], @@ -82,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 7, "id": "38790a1d-574d-427b-b5e3-44eb3408aa0e", "metadata": {}, "outputs": [], @@ -115,14 +108,21 @@ "source": [ "## BCS with default settings\n", "\n", - "We perform BCS by inputting the PCSet object that contains the starting basis, the x training data, and the y training data. Set verbose to 0 to silence print statements, to 1 for some statements, and 2 for all statements. UQTkBCS returns pc_final, a PCSet object that contains the set of basis terms selected by BCS, and c_k, an array of coefficients.\n", + "We perform BCS by inputting the PCSet object that contains the starting basis, the x training data, and the y training data. \n", + "\n", + "Set verbose to:\n", + "* 0 to silence print statements, \n", + "* 1 for some statements, \n", + "* 2 for all statements. \n", + "\n", + "UQTkBCS returns pc_final, a PCSet object that contains the set of basis terms selected by BCS, and c_k, an array of coefficients.\n", "\n", "We then evaluate the polynomial chaos expansion and calculate the normalized root mean square error." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 20, "id": "b14fa3eb", "metadata": {}, "outputs": [ @@ -138,20 +138,20 @@ " 0.17744271 0.17615609 0.16997361 0.16081588 0.101805 0.10113724\n", " 0.09661748 -0.07820574 -0.06027544 0.05970374 0.03663573]\n", "17 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.0057584471268748265\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" + "Reestimated sigma2: 5.758e-03\n", + "\n", + "The NRMS error between a 4-dimensional genz_osc function and a BCS-based PC surrogate of order 4 is 3.986e-01\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "0.3985792514972794" + "
" ] }, - "execution_count": 4, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -159,17 +159,29 @@ "pc_start = uqtkpce.PCSet(\"NISPnoq\", nord, ndim, pc_type, pc_alpha, pc_beta)\n", "\n", "# Perform BCS\n", - "pc_final, c_k = pce_tools.UQTkBCS(pc_start, x_train, y_train, verbose=1)\n", + "pc_final, c_k, _ = pce_tools.UQTkBCS(pc_start, x_train, y_train, verbose=1, return_sigma2=True)\n", "\n", - "# Evaluate the PCE\n", + "# Evaluate the PCE on test data\n", "pce_evals = pce_tools.UQTkEvaluatePCE(pc_final, c_k, x_test)\n", "\n", "# Calculate error metric\n", "MSE = np.square(np.subtract(y_test, pce_evals)).mean()\n", "NRMSE=math.sqrt(MSE)/np.abs(y_test.mean())\n", - "print(\"The NRMS error between a\", ndim, \"-dimensional\", model, \"function and a BCS-based PC surrogate of \\\n", - "order\", nord, \"is\")\n", - "NRMSE" + "\n", + "print(\"\\nThe NRMS error between a %d-dimensional %s function and a BCS-based PC surrogate of \\\n", + "order %d is %.3e\"%(ndim,model,nord,NRMSE))\n", + "\n", + "# Plot the PCE evaluation on test data vs. the actual test data using a parity plot\n", + "fig1 = plt.figure(figsize=(8,6))\n", + "ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n", + "\n", + "y_test_mM = [y_test.min(),y_test.max()]\n", + "\n", + "ax1.plot(y_test,pce_evals,\".\")\n", + "ax1.plot(y_test_mM,y_test_mM) # Diagonal line\n", + "\n", + "ax1.set_xlabel(\"Test Data y\", size=16)\n", + "ax1.set_ylabel(\"Predicted y\", size=16); \n" ] }, { @@ -188,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "id": "69af5724", "metadata": {}, "outputs": [ @@ -203,19 +215,20 @@ "[-0.41699246 -0.41728052 -0.3752697 -0.37492286 -0.35607029 0.10600481\n", " 0.07808621 0.0588526 ]\n", "8 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.010273138809217236\n", - "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" + "Reestimated sigma2: 1.027e-02\n", + "\n", + "The NRMS error between a 4-dimensional genz_osc function and a BCS-based PC surrogate of order 4 is 3.413e-01\n" ] }, { "data": { + "image/png": "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", "text/plain": [ - "0.34125304607524054" + "
" ] }, - "execution_count": 5, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ @@ -231,9 +244,21 @@ "# Calculate error metric\n", "MSE = np.square(np.subtract(y_test, pce_evals)).mean()\n", "NRMSE=math.sqrt(MSE)/np.abs(y_test.mean())\n", - "print(\"The NRMS error between a\", ndim, \"-dimensional\", model, \"function and a BCS-based PC surrogate of \\\n", - "order\", nord, \"is\")\n", - "NRMSE" + "\n", + "print(\"\\nThe NRMS error between a %d-dimensional %s function and a BCS-based PC surrogate of \\\n", + "order %d is %.3e\"%(ndim,model,nord,NRMSE))\n", + "\n", + "# Plot the PCE evaluation on test data vs. the actual test data using a parity plot\n", + "fig1 = plt.figure(figsize=(8,6))\n", + "ax1 = fig1.add_axes([0.15, 0.15, 0.80, 0.75])\n", + "\n", + "y_test_mM = [y_test.min(),y_test.max()]\n", + "\n", + "ax1.plot(y_test,pce_evals,\".\")\n", + "ax1.plot(y_test_mM,y_test_mM) # Diagonal line\n", + "\n", + "ax1.set_xlabel(\"Test Data y\", size=16)\n", + "ax1.set_ylabel(\"Predicted y\", size=16); " ] }, { @@ -248,7 +273,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 23, "id": "7e91b59f", "metadata": {}, "outputs": [ @@ -258,25 +283,29 @@ "text": [ "============ Split # 1 / 2 ============\n", "==== BCS with multiindex of size 70 ====\n", - "BCS has selected 11 basis terms out of 70\n", + "BCS has selected 6 basis terms out of 70\n", "============ Split # 2 / 2 ============\n", "==== BCS with multiindex of size 70 ====\n", "BCS has selected 9 basis terms out of 70\n", "Coefficients:\n", - "[-0.36086702 -0.39646567 -0.43178513 -0.36018123 -0.42112969 0.0879354 ]\n", - "6 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.00806177346345383\n", - "Please note that sigma2 will be returned by default in future versions.\n", + "[-0.36159581 -0.4003449 -0.42695139 -0.36334667 -0.42364005]\n", + "5 terms retained out of a full basis of size 70\n", + "Reestimated sigma2: 7.943e-03\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.3635490460636571" + "0.3662391313936095" ] }, - "execution_count": 6, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -313,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 24, "id": "18a8a231", "metadata": {}, "outputs": [ @@ -330,24 +359,22 @@ "[-0.42936009 -0.41619203 -0.38638634 -0.38245578 -0.35561764 0.10454476\n", " 0.1129687 0.07118968]\n", "8 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.010179250417000242\n", - "Please note that sigma2 will be returned by default in future versions.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ + "Reestimated sigma2: 1.018e-02\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.3629652828458752" + "0.3629652828458754" ] }, - "execution_count": 7, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -384,7 +411,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "id": "e252d5f5", "metadata": {}, "outputs": [ @@ -401,18 +428,22 @@ "[-0.42936009 -0.41619203 -0.38638634 -0.38245578 -0.35561764 0.10454476\n", " 0.1129687 0.07118968]\n", "8 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.010179250417000239\n", + "Reestimated sigma2: 1.018e-02\n", + "\n", "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.3629652828458752" + "0.3629652828458754" ] }, - "execution_count": 8, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -463,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "id": "e9ab0cc4", "metadata": {}, "outputs": [ @@ -471,173 +502,811 @@ "name": "stdout", "output_type": "stream", "text": [ - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, @@ -647,20 +1316,18 @@ "0.3524436425793535" ] }, - "execution_count": 9, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAJeCAYAAAAk+bR8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAABPs0lEQVR4nO3deXxcVf3/8dfJ2ibpvtDShdKyCAjK0kKLQpGCIBYQ2WSRIgiyyKYifPH3tX5FRVTEFVBUFFAURRAQBCutCAUqiyB7S1u60CXd27TNdn9/TNY2SSfJZO4sr+fjkcfc3Htn5pNDOrxz7jnnhiiKkCRJUv4oiLsASZIkpZcBUJIkKc8YACVJkvKMAVCSJCnPGAAlSZLyTFHcBWSLEILTpSVJUtaJoihsu88eQEmSpDxjAJQkScozXgJOQghhasvv82Hx7JkzZzJ58uS4y8gYtkdrtkcz26I126M126OZbdFaT7dHCNtd9W3FHsAkRFH0YNw1SJIkpYoBUJIkKc8YACVJkvKMYwBToL6+nsrKStauXUtdXV3c5aREv379eP311+Muo1MKCwvp378/gwcPpqDAv20kSWqPATAFFi9eTAiBMWPGUFxcvMOBl9lgw4YN9OnTJ+4ykhZFETU1NSxfvpzFixczevTouEuSJCljGQBTYNOmTey5556d7nWKoojZs2fz3HPPNQWuCRMmMHHixJwIkekUQqCkpIQRI0bw5ptvxl2OJEkZzQCYIp0JfzU1NfziF7/gxhtvZMWKFdTU1FBTU0NxcTHFxcUMHTqUq6++mvPOO4/i4uIerDr3eOlXkqQdMwCm2caNGzn22GN54YUXqKqqanWsurqa6upq5s+fzxe+8AV++9vf8te//pWKioqYqpUkSbnI7pI0qqmp4dhjj2XOnDnbhb9tVVVV8dxzz/Gxj32MmpqaNFWYnHfffZeKioqcmfAiSVK+MQCm0S9+8QteeOEFtm7dmtT5W7du5fnnn+eXv/xlt9/7jjvuYN9996WsrIxhw4Zx0UUXsXbt2qSeO2bMGP7+9783fT969Gg2btxIYWFht+uSJEnpZwBMkyiKuPHGG3fY87etqqoqbrzxxm7dfu573/seX/7yl/nOd77DunXreOaZZ1i4cCFHHXUU1dXVXX5dSZKUnQyAaTJ79mxWrFjRpecuX76c2bNnd+m569ev56tf/So/+tGPOOaYYyguLmbMmDH84Q9/YOHChdx1111Mnz6dk08+mdNOO40+ffpwwAEH8MorrwBw9tln8+677zJ16lQqKiq48cYbWbBgASEEamtrAZg8eTJf+cpXmDRpEhUVFUydOpVVq1Zx5pln0rdvX8aPH8+CBQsAtntu4/Nvv/12INFTeeihh3LllVfSv39/xo4dy9NPP80dd9zBqFGjGDp0KL/+9a+71BaSJCnBAJgmzz33XJfH8tXW1jJnzpwuPffpp59my5YtnHTSSa32V1RUcOyxx/L4448D8MADD3DKKaewevVqzjjjDM444wxqamq48847GT16NA8++CAbN27k6quvbvN97rnnHu68806WLFnCvHnzmDhxIueeey6rV69mr7324mtf+1rSNT/77LPst99+rFq1ijPOOIPTTz+dOXPmMHfuXO666y4uvfRSNm7c2KX2kCRJBsAeE0Jo9XXllVd2+XLr1q1bueKKK7Z7zWRUVlYyePBgioq2n/A9fPhwKisrATjwwAM5+eSTKS4u5qqrrmLLli0888wzSdd47rnnMm7cOPr168exxx7LuHHjmDJlCkVFRZxyyim8+OKLSb/WrrvuyrnnnkthYSGnnXYaixYt4n//938pLS3l6KOPpqSkhLlz5yb9epIkqTUDYA+JoqjV1/e//31KSkq69FqlpaXcfPPN271mMgYPHkxlZWWrS66N3nvvPQYPHgzAqFGjmvYXFBSw8847s3Tp0qRr3GmnnZq2e/fuvd33nemx2/a5be2zB1CSpK4zAKbJhAkTuryoc1FREePHj+/ScydOnEhpaSn33Xdfq/2bNm3ikUce4cgjjwRg0aJFTcfq6+tZunQpO++8M0BK70pSXl4O0GoyzLJly1L2+pIkaccMgGkyceJEhg4d2qXn7rTTTkycOLFLz+3Xrx9f/epX+fznP8+jjz5KTU0NCxYs4JRTTmHkyJGcffbZADz//PPcd9991NbWcvPNN1NaWsohhxzS9P7vvPNOl95/W0OGDGHEiBHcdddd1NXV8ctf/pJ58+al5LUlSVJyDIBpEkLg6quvpqysrFPPKysr4+qrr+5WL9zVV1/NN7/5Tb74xS/St29fDj74YEaNGsWMGTMoLS0F4IQTTuD3v/89AwYM4M477+Suu+5q6rG89tpruf766+nfvz/f/e53u1xHo5///Od85zvfYdCgQbz66qtMmjSp268pSZKS563g0ui8887j7rvvZs6cOUktBl1aWsqBBx7IZz7zmZS893nnndfu8V69enHXXXc1fb9hw4am7RNOOIETTjih1fktxyDOnDmz1bHrr7++1fdTpkxpNWnj2GOPZf78+W3WMW3aNKZNm9b0/W677bbdeMfFixe3+3NIkqQdswcwjYqLi3nkkUeYMGHCDnsCy8rKmDBhAn/961+7PHZQkiSpLQbANKuoqGDGjBncdNNNjB07lvLyckpLSwkhUFpaSnl5OWPHjuWmm25ixowZVFRUxF2yJEnKMV4CjkFxcTEXXnghF1xwAbNnz2bOnDls2LCBPn36MGHCBA455JCUzrzdkenTp6ftvSRJygfff/wtfjDj7Y5PevThdg9dfuTuXHnUHimuqpkBMEYhBCZNmuQkCEmScsyVR+3RboAbc00i+C244bh0ltSKl4AlSZLyjAFQkiQpzxgAJUmS8oxjANMkqcGgHejpwaCSJCl/GADTJNMHg3ZHRUUFL7/8MmPHjo27FEmSlAQvAee4ioqKpq+CggJ69+7d9P3dd9/d6debPHkyt99+e6t9GzduNPxJkpRF7AHMcRs3bmzaHjNmDLfffjtTpkyJsSJJkhQ3ewDzVH19PTfccAPjxo1j0KBBnHrqqaxevRqALVu2cP755zNo0CD69+/P+PHjWb58Oddddx1PPvkkl156KRUVFVx66aVAYj3Dxnv9Tps2jUsuuYTjjjuOPn36cPDBBzNv3rym933sscfYc8896devHxdffDGHH374dj2KkiSpZ9kD2AMax/T19PO6M2bwhz/8Iffffz+zZs1iyJAhXHbZZVxyySX87ne/49e//jXr169n0aJFlJaW8tJLL9G7d2++8Y1v8NRTT3HWWWdx/vnnt/vav/vd73j00Uc54IADOOecc7juuuu45557qKys5OSTT+aOO+7g+OOP5yc/+Qk///nPOfvss7v8c0iSpM6zBzBP3XbbbXzjG99g5MiRlJaWMn36dP74xz9SW1tLcXExq1evZu7cuRQWFnLggQfSt2/fpF/7pJNOYsKECRQVFXHmmWfy0ksvAfDXv/6VffbZh5NOOomioiIuu+wyhg0b1kM/oSRJao89gD2gsz1zccwCXrhwIZ/4xCcoKGj+G6CwsJDly5dz9tlnM3fuXE4//XTWrl3LWWedxTe+8Q2Ki4uTeu2Woa6srKxpHOLSpUsZNWpU07EQAiNHjkzRTyRJkpJlD2CeGjVqFI888ghr165t+tqyZQsjRoyguLiYa6+9ltdee42nn36ahx56iN/85jdAIrR11fDhw1m8eHHT91EUtfpekiSlhwEwT33uc5/juuuuY+HChQCsXLmSBx54AIAnnniCV199lbq6Ovr27UtxcTGFhYUA7LTTTrzzzjtdes/jjjuOV155hfvvv5/a2lp+8pOfsGzZstT8QJIkKWkGwDx1+eWXc/zxx3P00UfTp08fDjnkEJ599lkAli1bxtlnn03fvn3Za6+9OPzwwznrrLOanvfHP/6RAQMGcNlll3XqPQcPHsy9997L1VdfzaBBg3jttdc46KCDKC0tTfnPJ0mS2ucYwDyyYMGCpu2CggKuuuoqrrrqqu3O+9SnPsXHP/5x+vTps92xiRMn8tZbb7XaF0VR0/Ydd9zR6tjkyZNbXeY95phjmp5fX1/PyJEjHQcoSVKaGQDTJJl7AXe0DEyu3Av4b3/7GwcffDC9e/fmO9/5DlEUccghh8RdliRJecUAmCYd3Qs4n8yePZszzjiD6upq9t57b+6//3569+4dd1mSJOUVA6DSavr06UyfPj3uMiRJymtOApEkScozBkBJkqQ8YwCUJEnKMwZASZKkPOMkkHR54lsw64auP//wa+CIa1NXjyRJylsGwHQ54tr2A9z0fg2P69JXTxcce+yxnH766ZxzzjkpPVeSJKWXATDHVVRUNG1XVVVRWlradF/f2267jTPPPDPp13rkkUd65FxJkpReBsAct3HjxqbtMWPGcPvttzNlypTtzqutraWoyF8HSZLygZNAkhBCmBp3Dak2c+ZMRo4cybe//W2GDRvGueeey5o1a/j4xz/OkCFDGD16NB//+Mdb3cd38uTJ3H777UDinr8f+tCH+OIXv8iAAQPYddddW/X6debc+fPnc9hhh9GnTx+mTJnCJZdcwllnnZWmlpAkKf/Y5ZOEKIoeDCEk/4TGMX2d1dnndXPM4LJly1i9ejULFy6kvr6eqqoqzj33XP7whz+wdu1aLr/8ci699FLuv//+Np//7LPPcs4551BZWcnPfvYzzjvvPJYsWUJbbdXRuWeccQaHHnoof//733nuuef42Mc+xvHHH9+tn02SJLXPHsA8VlBQwNe+9jVKS0vp3bs3gwYN4pOf/CRlZWX06dOH6667jlmzZrX7/F122YXPfvazFBYWcs455/Dee++xfPnyTp377rvvMmfOHP7v//6PkpISPvShDxn+JEnqYfYA9oTO9szFNAt4yJAh9OrVq+n7qqoqrrzySh599FHWrFkDwIYNG6irq2uaONLSsGHDmrbLysqA1mMOkzm3srKSgQMHNu0DGDVqFIsWLerGTyZJkjpiD2Ae2/ZS7fe+9z3efPNNnn32WZYsWcI///lPAKIo6rEahg8fzurVq6mqqmraZ/iTJKlnGQDVZMOGDfTu3Zv+/fuzevVqvva1r/X4e+6yyy4cdNBBTJ8+nerqambPns2DDz7Y4+8rSVI+MwCqyRVXXMHmzZsZPHgwRx55JMccc0xa3vfuu+9m9uzZDBo0iK985SucdtpplJaWpuW9JUnKR44BzCMLFixo2p48eXKrJV4Adt55Z2bOnAkkegP79OnDhRde2HS88RjAtGnTmDZtWqvnt7xU3Jlzx40bx5NPPtn0/Wmnncb73ve+JH8qSZLUWQbAdEnmXsAdLQOTw/cCnjNnDgMHDmTXXXflscce44EHHuCaa66JuyxJknKWATBdOroXcJ5btmwZJ510EqtWrWLkyJHccsst7L///nGXJUlSzjIAKnZTp05l6tScu9mKJEkZy0kgkiRJecYAmCL19fVxlyD87yBJUjIMgClQXl7OkiVLqK6u7tFFk9W+KIqorq5myZIllJeXx12OJEkZzTGAKTBy5EgqKytZuHAhtbW1cZeTElu2bGl1m7hsUFRURL9+/Rg8eHDcpUiSlNEMgClQUFDA0KFDGTp0aNylpMzMmTOdiStJUo7yErAkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOUZA6AkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOUZA6AkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOWZorgLkCRJyjlPfAtm3dDmoQW9Gjamd/D8w6+BI65NdVVNDICSJEmpdsS17Qe46f0aHtelr55teAlYkiQpzxgAJUmS8owBUJIkKc8YACVJkvKMAVCSJCnPGAAlSZLyjAFQkiQpzxgAJUmS8owBUJIkKc8YACVJkvKMAVCSJCnPGAAlSZLyjAFQkiQpzxgAJUmS8owBUJIkKc8YACVJkvKMAVCSJCnPGAAlSZLyjAFQkiQpzxTFXYAkSVK+2LClhpO23sj7w3y+H2MdBkBJkqQ0mbdyE29HIymkLtY6vAQsSZKUJnNXbARgt7A01joMgJIkSWnSFAALlsRahwFQkiQpTZp7AA2AkiRJeWHeSi8BS5Ik5Y2ttXUsXLWJAurZNbwXay0GQEmSpDRYUFlFfQSjwwpKQ22stRgAJUmS0iBTxv+BATApIYSpcdcgSZKyW2MAHGcAzA5RFD0Ydw2SJCm7zc2QCSBgAJQkSUqLTFkDEAyAkiRJPa6uPuKdlY2XgO0BlCRJynlL1mxma209O/UtpW/YHHc5BkBJkqSeNnflBgB2G1oRcyUJBkBJkqQe1jT+b4gBUJIkKS80BUB7ACVJkvJD0xqABkBJkqTcF0WRPYCSJEn5ZOXGrazfUkvfXkUMqSiNuxzAAChJktSjWvb+hRBiribBAChJktSD5mXY5V8wAEqSJPWoTBv/BwZASZKkHjV3pQFQkiQprzQvAt0HarbEXE2CAVCSJKmHrN9Sw/L1WyktKmDEgN6w+p24SwIMgJIkST2mcQLI2CEVFBYEWDU35ooSDICSJEk9ZLsJIAZASZKk3NY0AWSIAVCSJCkvbLcGoAFQkiQpt3kJWJIkKY9sqanj3dVVFAQYM7gMqlZD1aq4ywIMgJIkST1iwapN1Eewy6BySosKYdW8uEtqYgCUJEnqAY2Xf8dl2AQQMABKkiT1iEwd/wcGQEmSpB5hAJQkScozBkBJkqQ8Ulcf8U7lJgDGDSmH+nongUiSJOWyxWuqqK6tZ1jfXvTpVQwblkLtZigfEndpgAFQkiQp5dq9/Dtot5gqas0AKEmSlGLbBcDKtxOPg8bFVFFrBkBJkqQUa1oDsKkHsGH8nz2AkiRJuWnuyoYewG0XgR60e0wVtWYAlCRJSqEoihwDKEmSlE9WbtjKhi219OtdzOCKEqithrULgQADd427PMAAKEmSlFIte/9CCLBmPkT10H80FJXGXF2CAVCSJCmF2h3/Nzgzxv+BAVCSJCmlMn38HxgAJUmSUsoAKEmSlGe2XwS6MQBmxiLQYACUJElKmfVbalixYSu9igsY0b93Yqc9gJIkSbmrsfdv7OAKCgoCbFkHm1ZAUS/oOzLm6poZACVJklJk+/F/DbeAGzgOCjIndmVOJZIkSVluXrsTQDJn/B8YACVJklImG2YAgwFQkiQpZZoWgd42AGbQItBgAJQkSUqJLTV1LFpdRWFBYMyg8sROewAlSZJy1/zKTdRHsMvAMkqKCiCKmieBGAAlSZJyT+P4v3GNl383LIPqjdB7AJQNjLGy7RkAJUmSUqD9CSCZNf4PDICSJEkp0TQBZEhmzwAGA6AkSVJKZMsagGAAlCRJ6ra6+oh3KjcBLcYA2gMoSZKUuxatrqK6tp7h/XpRUVqU2JmhawCCAVCSJKnbtpsAUlcDaxYktgeOjaeoDhgAJUmSuqlxAsi4xgkga9+F+lroNwqKe8dYWdsMgJIkSd20XQ9g5duJxwycAAIGQEmSpG7LpjUAwQAoSZLULVEUdbAETObNAAYDoCRJUres2LCVDVtr6V9WzKDyksROA6AkSVLuarr8O6SCEEJiZwYvAg0GQEmSpG7Zbvzf1o2w4T0oLIH+o2OsrH0GQEmSpG7YLgCunpd4HDgWCgpjqqpjBkBJkqRuaAyA2XALuEYGQEmSpG5oXAR6t8ZFoCsze/wfGAAlSZK6bN3mGlZu2Erv4kJG9G+444c9gJIkSbmr8fLv2CHlFBRsOwM4MxeBBgOgJElSl223AHQUwaqGSSD2AEqSJOWe7cb/bVoJW9dBaT8oHxxjZR0zAEqSJHVR+/cAHgeNi0JnIAOgJElSF7UbAAdn7vg/MABKkiR1yZaaOhatqaKwILDLoPLEziyYAQwGQEmSpC55Z+Umogh2GVRGSVFDpGqaAJK5awCCAVCSJKlLtpsAAlD5duIxw3sAi+IuQJIkKRttN/6vvg5Wv5PYfvV+uO2wjl9ger/2jx1+DRxxbfeLbIcBUJIkqQu2WwNw7btQXwN9doYpX018tWHMNQ8DsOCG49JSZ1u8BCxJktQF288Azo7xf2AAlCRJ6rTaunrmV24CYFzjGMBV2TH+DwyAkiRJnbZozWaq6+rZuV8vyksbRtRlyRqAYACUJEnqtMbLv+OGtpgBnCVrAIIBUJIkqdO2G/8HLcYAGgAlSZJyznYBsLoK1i2CgiLoPzrGypJjAJQkSeqk7RaBblz/b8AYKCyOp6hOMABKkiR1QhRF268B2DT+L/MngIABUJIkqVOWr9/Kxq21DCgrZlBFaWJnUwDM/DUAwQAoSZLUKW1PAMmeGcBgAJQkSeqUuSs2AAZASZKkvNE4AaTpDiCQVYtAgwFQkiSpU7a7BFy1GjavgZIKqNgpxsqSZwCUJEnqhLkrEvcA3n4G8DgIIaaqOscAmIQQwtS4a5AkSfFbV1VD5cat9C4uZOd+vRM7K99OPGbJ+D8wACYliqIH465BkiTFb+7KxASQcUPLKSho6O3LsjUAwQAoSZKUtKbxf21NALEHUJIkKfe0vQbgvMRjliwCDQZASZKkpG0XAOvrYXVjALQHUJIkKec0rgHYFADXL4baLYnlX3r1jbGyzjEASpIkJWFLTR2L12ymqCCwy6DyxM4sHP8HBkBJkqSkzFu5kSiCXQaVUVzYEKGycPwfGAAlSZKS0uYEkCxcAxAMgJIkSUmZ1+YMYC8BS5Ik5aztJoBAVi4CDQZASZKkpDQvAt0nsaN2K6x9F0IBDBgTX2FdUBR3AZIkZavvP/4WP5jxdscnPfpwu4cuP3J3rjxqjxRXpZ5QW1fP/MpNQOI2cACsfgeIoP8YKCqJrbauMABKktRFVx61R7sBbsw1ieC34Ibj0lmSesi7q6uoqYsY0b83ZSUN8SlLx/+Bl4AlSZJ2qPHy77i2xv8Nzq7xf2AAlCRJ2qGmCSBD2poAkl1rAIIBUJIkaYfaXgPQS8CSJEk5K5fWAAQDoCRJUoeiKGLeysQM4KYAuHkNVFVCcRn02TnG6rrGWcCSpKyT1PIrHXD5FXXGsvVb2Li1loHlJQwsb1juZdU7iceB46Ag+/rTDICSpKzj8itKp+YFoHNjAgh4CViSJKlDbS8B09ADnYXj/8AAKEmS1KE2ZwBn8RqAYACUJEnqUIcBMEt7AB0DKElSFnNCTM+bt3KbABhFsGpeYnvg2Jiq6h4DoCRJWcwJMT1rbVU1lRurKSspZOd+vRI71y+FmiooGwRlA+MtsIu8BCxJktSOpgkgQyoIISR2Nl3+zc7xf2AAlCRJalcujv8DLwHHIhPGayRVw6MP92gNSdfRgbTWYXu01sPtYVt0oY4O5Fp7SOnSdgBsGP+XpWsAAoQoiuKuISuEEJoaqifbLBPGa2RCDdZhHZleg3VYRzbUkQk1NJo5cyaTJ0+Ou4xOm/ar55j55kpuPetAjnn/sMTOu0+Btx+DU++EvY/v9Gum479L0+VqIIqisO1xLwFLkiS1I1cvARsAJUmS2rC5uo4lazdTVBDYZVBZYmdtNaxZCISsXQIGDICSJEltmrdyI1EEYwaXU1zYEJnWLoSoDvqPguJe8RbYDQZASZKkNjQtAD2kxeXfyuy+B3AjA6AkSVIbcnX8HxgAJUmS2tRxAMzeRaDBAChJktSmXF0DEFwIWpIkaTu1dfUsWLUJgLFDypsPJHkJOJlF0xvXA2xLTy+abgCUJEnaxsLVVdTURYzo35uykoa4tGU9bFwGhaXQb2SHz7/yqD06DHBxL4ztJWBJkqRttHn5d3WLy78FhTFUlTpJBcAQwmEhhNHJvmgIYb8Qwqe7XpYkSVJ8cnn8HyTfA/gEMK3ljhDCl0MIq9o5/xPAr7pRlyRJUmzm5fASMJB8ANzuJsJAL6B/6kqRJEnKDHNXthEAc2QRaHAMoCRJUitRFDX3AA7JvTUAwQAoSZLUynvrtrCpuo5B5SUMKC9J7IyiFmMA7QGUJEnKKY0TQMa1vPy7cQVUb4Be/aFsYDyFpZABUJIkqYW2ZwC3GP8X2poakV06EwCjHqtCkiQpQzRNAGlr/N/g7B//B527E8j0EML0bXeGEOpSV44kSVK82u4BbJwAkv1rAELnAmBn+zvtMZQkSVmn7TUAc2cCCCQZAKMocqygJEnKeWs2VbNqUzXlJYUM79er+UAOrQEITgKRJElq0jj+b9zQCkLjZI+6WlgzP7E9cGxMlaVWZy4BS5Ikten7j7/FD2a83fFJjz7c7qHLj9ydK4/aI8VVdd7cthaAXrsQ6muh70goKY+pstRKOgCGEAqiKKpvY38/4KvAR0iME5wFfD2KopUpq1KSJGW0K4/ao90AN+aaRPBbcMNxPV5HUkG0A/uP6g9sswZg0/i/3JgAAkkGwBDC54GbQwjHRFH0eIv9JcBMYD+aJ4m8Hzg6hHBgFEWbUlyvJElSu7obRM/55XNAB2sA5ohkxwB+GFjZMvw1OA/4APAGMAU4GLgf2B24OEU1SpIkpUXHS8DkXwD8APBMG/tPI7HcyzlRFP0jiqI5DfuWAyekpkRJkqSeV1Vdy5K1mykuDOwysKz5QI4tAg3JB8AhwPyWO0IIBcB4YGEURf9u3B9FUS3wKPC+VBUpSZLU095ZmRi5NmZQOUWFLSJSDo4BTDYAlgM12+x7H9CbtnsG3wP6dqMuSZKktGrz8m/1Jli/BAqKod/omCpLvWQDYCWw5zb7Dm54fL6N83sBa7tYkyRJUtq1Pf6vofdv4K5QmDur5yUbAJ8Djgkh7A0QEisjTiMx/u+JNs7fG1iaigIlSZLSoeMJILkz/g+SD4A/BYqBp0II9wEvAh8CXoqi6IWWJ4YQejUca6tnUJIkKSM13QVkSG6vAQhJBsCG5V++AlQAJ5JY9+9d4Jw2Tj+NxJjBx1JToiRJ2eXFd9c0bdfWbXcPBWWgmrp6FlRuIoRtA2DuLQEDnbgXcBRF3wTGkQh4U4B9oij6bxunvgZ8AngoJRVKkpQloijizmcWcupts5v2HfODJ3ns1WVEURRjZdqRhauqqK2PGNG/N71LCpsP5OAi0NDJewFHUfQuiZ6/js6Z062KJEnKQpur67ju/le474UlrfbPXbGRC+58nvFjBnDNsXtx4C4DYqpQHWlz/F8U5eQagNCJHkBJktS2has28YmfPsV9Lyyhd3EhPzj9g03Hvjp1bwaWlzBnwRo+ecvTfO7O55nXMNZMmaPxv8luLS//Vq2CLeugtC+UD4mpsp6R7L2AD+vKi0dR9M+uPE+SpGwx4/XlXPH7l9iwpZZdB5dz61kHsuewPlx+z0sAnHvorpx84Ehum/UOt//rHR59dRmPv76c08eP4vIpuzO0T694fwABO5oBPA5CiKGqnpPsJeCZJJZ86azCHZ8iSVL2qauPuPnvb/GjfyRCwtF778R3T/0AfXsVb3dun17FfPGje3L2xF24+e9v8fs5i7j72Xf584tLOP/DY7ngsLFUlObOGnPZqM0AWJmb4/+gc2MAa4HHgTU7OlGSpFy2ZlM1l93zIk++XUlBgC999H187vCxhB30Eu3UtxffOmk/PnPornz70Tf5++vL+eGMt/ntswu5/MjdOX3CaIoLHZ2VbvX1UfMl4DxYAxCSD4DzgV2BjwB/An7u5V1JUj56efFaLrrrBZas3czA8hJ+9Kn9OXS3wZ16jd136sPt5xzEnAWr+eZfX+fFd9fy/x54lV8+tYAvfXRPjn3/sB2GSaXOe+u3UFVdx+CKEvqXlTQfaHkJOMckuw7gOOAo4EHgFOCJEMLrIYQvhBA691svSVKWuue5dzn5ltksWbuZD4zqz0Of/1Cnw19L48cM5L6LJnHrWQcwdnA58ys3cfHdL/CJnz7Ns++sSmHl6kjj5d9W6/9Bi0Wgc+8ScGfWAZwRRdFpwAjgahJjAr8DLA4h/D6EMKWHapQkKVZbaur48h9f5pr7XqG6rp6zDhnNHy48hJ379+72a4cQOOb9w/nblYdx/YnvZ3BFKS8tWstpP3uG8+6Yw1vLN6TgJ1BH2hz/V18Hq99JbOdrD2BLURStiqLoe1EU7Q0cDtwLTAX+FkKYG0L4QKqLlCQpLotWV3HKrbP5/b8XUVpUwPdO+QDXn7gvpUWpnedYXFjAWYfswqwvTeaKKbtTVlLIjDdWcMzN/+TLf3yZZeu2pPT91KzNALhuEdRthYphUNonpsp6TrdGmkZR9GQURWeTGBu4hMQ4wV1SUZgkSXGb+eYKpv74X7yyZB2jB5Zx38WT+OSBI3v0PctLi7hiyh7M+tIRnH3ILhSEwO//vYjJ332CGx99g/Vbanr0/fPRvI6WgMmxBaAbdTkAhhBKQwhnhRBmAU8BI4F/AW+kqjhJkuJQXx/xwxlvc+4dc1hbVcNH3jeUBy/9EPvs3C9tNQzpU8rXT3w/j191OB/bdxhbaur56cx5HH7jE/ziX/PZWluXtlpy3dw2ZwA3jv/Lvcu/0IUAGELYL4TwQ2Ap8BtgL+D7wF5RFB0eRdFbKa5RkqS0WVdVw/m/+Tc3PZ7439kXjtqD2z99EP3Ktl/fLx12HVzOT888kD9fPIkJuw5kTVUNX3/oNabcNIsHXlpCfb33GO6O1ZuqWb2pmorSIob1bbEod9MM4NybAALJ3wmkHPgU8FngoIbd/wB+Dvw5iiL7oyVJWe/Vpeu46K4XeHd1Ff3LivnB6ftz+B6ZcQuw/UcP4PcXHMKM11fw7Uff4O0VG7n8npf4+ZPvcO2xe3VrNnI+a54BXN566Z0cXgQakl8HcBlQ1vD4LeD2KIoW9FRRkiSl25+eX8z//PkVttbWs++Ifvz0zAMYNbAs7rJaCSEwZe+dmLznEP70wmJuevwt/rtkPWfe/iyH7TGEa455H3vv3DfuMrNKUwAc2t4SMLk5BjDZAFgO1AALgcOAw5JYoDKKoujwbtQmSVKP21pbx9cfeo27nnkXgNPHj2L68fvQqzhz72ZaVFjAaeNHc/wHRvDLp+Zz68x5/POtlTz59ko+8cERXHX0HowckFnhNVO1OQO4ZnNiFnAohAG5Obe1M7eCKwYO6cT5DkqQJGW0pWs3c9HdL/CfRWspKSrg/47fh9MnjI67rKT1LinkkiN241MTRvPjf8zlzmcWcN+LS3jolfc4Z2JuBpdUa5oA0nIR6NXzgQgGjIHCeMZ+9rRkA+CuPVqFJElp9tTcSj7/uxdZvamaEf17c+tZB7LvyPTN8k2lgeUl/O/UvZk2aQzffexN/vKfpfz8yflNx2vq6r3HcDvaXgImt8f/QZIBMIqihT1diCRJ6RBFEbfMmsd3//Ym9REctscQfnDaBxlQXrLjJ2e40YPK+OGn9uezHx7LDY++zlNzE7eTO/dXc/jJmQfQr3du9mZ11aattSxZu5mSwgJGtxzvmeNrAEI3F4LuSAghM6ZNSZLUYP2WGi6883lufDQR/i77yG78atr4nAh/Le07sh93nXdw0/f/mlvJybc8zaLVVTFWlXneWbkJgDGDyyhq2UOa42sAQg8EwBBCvxDCN4F5qX5tSZK66s1lGzjhx0/x2GvL6duriF+ccxBXHb0nhQU7nNSYlVpO1tx9aAVvr9jIiT95iucXromxqswyd2XiPsu7bTcDOLfXAIROBsAQwi4hhJNCCFNDCDttc6xXCOFa4B3gms6+tiRJPeWBl5Zw4k+eYn7lJvYa3pcHP/8hjtxrpx0/MUf86eJJfHj3wazaVM2nfv4MD/5nadwlZYSmGcBDtgmAOb4GIHQipDXc/WMecC9wP7AghHBxw7HJwJvA9UBv4AfA2NSWKklS51TX1jP9L69y+T0vsbmmjpMOGMF9F01il0HlcZeWVn17FfPLaeM54+DRVNfW8/nfvciP//E2UZTfC3a0uQZg1WrYvBqKy6HP8Jgq63nJ3gnkHOBSoB54HQjAnsAPQwibgNuAwobH66Mo8k8LSVKslq/fwsV3v8DzC9dQXBj46tR9OPPg0SSxjm1OKi4s4Bsnvp+xg8v5xl9f57uPvcX8yiq+ddK+lBTl50W7NtcAbDn+L4d/V5JdBmYaUA0cEUXRbIAQwmHA48AvgMXA1CiKXumJIiVJ6qzjfvgvKjduZXi/Xvz0zAPYf/SAuEuKXQiB8z88llEDy7jinpf40wuLWbymitvOPpD+Zbk1EWZHaurqWbiqihBgXMtLwHkw/g+SvwS8H4l7/s5u3BFF0T9JXAoOwGcMf5KkuG3cWtu0XblxK5PGDeKhz3/I8LeNj+4zjD9cOJGhfUp5dv5qPvHTp5lfuSnustJq4apN1NZHjBzQu/VdX/JgDUBIPgD2A+a2sb+hlZjdxjFJknrcpq21PPifpXzuzuc58OuPN+2/aPI4fvOZCQyqKI2xusy178h+PHDpoew1vC/zKzfxiZ8+xXPzV8ddVtq0OwEkT3oAk70EXEDiXsDbqgGIomhzyiqSJGkHqqpr+ccbK3j45fd44s0VbKmp3+6cLx/zvhgqyy7D+/Xm3s9N5LLfvcg/3ljBWbc/y7dP3pdP7D8y7tJ6XJvj/6B5DOBgA2Cj/J4qJEmK1ebqOp54MxH6ZryxvFXoO2iXAXxs3+F8bN/hHPKtGTFWmX0qSov4+acP4usPvcYdTy/gyt//h/mVVVw5ZfecnjDTZgCsr28OgANzdxFo6FwAnB5CmN7WgRBCXRu7oyiKOvP6kiS1srm6jplvruChV97jH6+vYHNN8/9uDhjdn+P225mP7TuM4f16x1hl9issCEw/fh92HVzO1x58lR/OeJsFlZu48eT9Wo+PyyFzV7YRANcvgdrNUD4EevePp7A06UxA6+yfAbn7Z4Mkqcdsqalj5psrefiV95jx+nKqqptD3wdH9efj+w3n2H2HM6K/oS/Vzpk0htEDy7j0ty/wl/8sZenazdx29oE5N46yvj5i3orEpJfdhvRpPpAn4/8gyQAYRVF+LhAkSUqLLTV1zHprZeLy7uvL2dQi9H1gVH8+vu9wjt13GCMHlMVYZX444n1D+eNFkzjvjjn8e+EaPvHTp/nltPHbj5XLYkvXbWZzTR2DK0rpV1bcfMAAKElSz9pSU8eTb1fy8MtL+fvrK1ot4bLfyH4c1zCmb9RAQ1+67TW8L/dfcijn/frfvLJkHSf99CluPetAJu02OO7SUqJ5/N82d4RpWgTaAChJUspsra3jybcq+esr7/H4a8vZ0CL0vX9EX47bd2eO23c4owcZ+uI2tG8vfn/hIVz5+5f426vL+fQvn+Obn9iXU8ePiru0bmt/BrA9gJIkpUR1bT3/mruSh15+j8dfbR369tm5L8ftN5zj9h2ed/fnzQZlJUXccuaB3PDoG/zsn+9w9Z9eZv6qTXzp6D0pKMjeof7trwGYH4tAgwFQktQDqmvreWpuJQ+/8h6PvbqM9VuaQ99ew/vy8f0Sl3d3HWzoy3QFBYH/+dhejBlUzv974L/cMnMeC1dt4qZTP5i1M4SbewBbTACp3Qpr34VQAAN3jamy9DEASpI6JYoioiixOGx9w3Z91LxU7Jfu/Q9/2yb0vW9Yn6bQN3bbXhdlhTMOHs2ogb25+K4X+Osry1iy9hlu//RBDOmTfTOE21wCZs0CiOphwBgoyr6fqbMMgBnkzy8ubtqectOsGCvJnBrAOrZlHZlVA2ROHR/57sztQlkUNQS2Vvvb2pdIdPXb7E/sjpqeU5/ELQHufT7xWbbnTn04riH05dIM0nz24d2HcN/Fkzj3jjn8Z9FaTvzJU/xy2nj2HNZnx0/OIGuraqgoLWKnvi2CXh6N/wMDYEZZV9V8t73G7uk4ZUINYB3bso7MqgEyp453Kjel9f0KAoQQEo8EqusSd+a4YsruHLfvcHbfKbtCgZKz+059+PPFh3LBnf/mxXfXcvItT/PjMw/g8D2GxF1ap4wbWtH6TieV+TP+DwyAGeXE/Ucw/cHXAHj8ysNiq+Oo7/8z9hqswzoyvYZMrOPvVx2+XSgLAUKAghCaH0mc0/L7ghAgbB/q2n4ubd4ibMw1DwNwxZQ90vfDKxZD+pTyu88ewhfu/Q8Pv/wen7ljDl87fh/OOmSXuEtL2vYTQOwBVEz6l5U0bWfCX86ZUANYx7asI7NqgMypw8usSqdexYX86PT92XVQOT9+Yi5fuf+/zK/cxP98bC8Ks2CG8PZLwOTPGoAA3uFDkiR1SUFB4Isf3ZPvnvIBigsDv/jXfC6883k2tVjqJxNEUcTTTz/N+jkPULPmPQBqVy8iajF5Kd96AA2AkiSpW04+cCS/+czB9OtdzN9fX86pt81m+fotcZdFTU0Nt956K+PGjePoo49mzaxfEQoTFz+v+/z5jBs3jltvvZWaDatg0woo6g19R8RcdXoYACVJUrdNHDeIP188iTGDynh16XpO+PFTvLp0XWz1bNy4kY985CN84QtfYP78+WzatIlQWExR3yFEtTVseG8+8+fP5wtf+AKXnP7RxJMGjYOC/IhG+fFTSpKkHjd2SAX3XXwoE8YMZNn6LZxy62z+8cbytNdRU1PDsccey5w5c6iqqmraXzxwZOL4miWJNf+Aqqoqqt9LTMCsHzA27bXGxQAoSZJSZmB5CXeeP4FP7D+Cquo6zv/1v9Newy9+8QteeOEFtm7d2mp/8aDEfYxrVi1qtX/Xfokw+NKizFjSKR2cBSxJklKqtKiQm079ALsOLuemx99q2n/7k+/Qt1cxFb2KqCgtok+vxFdFaTF9ehVRVlLY5hJDnRFFETfeeGOrnr9G7QXAPQcl+sN+99hz7P/FqNs1ZAMDoCRJSrkQApcduTu7DCrj8nteAuD6h1/v8DkFgYZgWNwUEJvDYnFDWCxq8bjNvl5FvPri86xYsaLN1y8e1HAJeNXiVvv3aAiAzy9Yx+zZs5k0aVI3f/rMZwCUJEk95oQPjmgKgOceOoaNW2rZsKWWjVtr2bClhg1ba5v2ba6pY/2W2lb3ke6KQRfdzYDqKqKtVdRvraK+OvFYOnJvAGoqW/cANgbA11fWMmfOHAOgJElSqnx16j4dHq+tq2fT1jrWb6lh49YWIbFFaEyExdbBsfG8jVtrWbNxC3WFRRT27gu9+273HvVbq6hds6Tp++EVgYqSQGVVPcvXV7Nhw4aU/9yZyAAoSZIyQlFhAf3KCuhXVtzl17j55pv58rXXURuKKCjpTSgtp6C0rOGrnOqVC4hqq5vOb+z9e2tVPSUlJfTpkxl39ulpBkBJkpQzJkyYQHFhoHrTeuo3r9/h+XsObg6ARUVFjB8/vqdLzAguAyNJknLGxIkTGTp0aNLnN/YAvrmqnp122omJEyf2VGkZxQAoSZJyRgiBq6++mrKysqTO32NgIgot3FjM1VdfnRdLwIABUJIk5ZjzzjuPAw44gNLS0h2e29gDWDJsLz7zmc/0dGkZwwAoSZJySnFxMY888ggTJkzosCewqADGDiigPoIf//avFBd3ffJJtjEASpKknFNRUcGMGTO46aabGDt2LOXl5VBYDARKS0spLy/nsH13obgwEPqPomLAkLhLTitnAUuSpJxUXFzMhRdeyAUXXMDs2bP5+P/eQX31Zr72yYOYMGEChwxcC787nTBot7hLTTsDoCRJymkhBCZNmkTfg9YAcPnlxyUOPP3jxGMeBkAvAUuSpPy06u3EowFQkiQpT6yal3gcbACUJEnKD6vmJh7tAZQkScoDWzfChvegsAT6jYq7mrQzAEqSpPzT2Ps3cCwUFMZbSwwMgJIkKf/k8eVfMABKkqR81DgBxAAoSZKUJ/K8B9CFoCVJ6qLvP/4WP5jxdofnjLnm4XaPXX7k7lx51B6pLkvJyOM1AMEAKElSl1151B4dBriZM2cyefLk9BWk5ESRl4DjLkCSJCmtNq2EreuhVz8oHxx3NbEwAEqSpPzScvxfCPHWEhMDoCRJyi95PgEEDICSJCnfVOb3BBAwAEqSpHyT5xNAwAAoSZLyjZeADYCSJCl/FFAPq99JfDNwbLzFxMgAKEmS8sbIsBLqa6DPzlBaEXc5sTEASpKkvDE2vJfYGJy/l3/BO4FIkqRc8sS3YNYNbR5a0KvFN/P/CdP7bX/S4dfAEdf2TG0ZxAAoSZK6L5ngNb2D56cqeB1xbfuv0zLwffSbMPGS7r9fljIASpKk7ksmeE1fl756diSPZwCDYwAlSVI+MgBKkiTlkYIi6L9L3FXEygAoSZLyy4BdoTC/R8EZACVJUn7J88u/kKcBMITwPyGEN0MI9SGEE+OuR5IkpVGerwEIeRoAgRnAx4B/xl2IJElKM3sA4w+AIYSRIYQfhRBmhxCqQghRCGFMO+eOCiH8MYSwLoSwPoRwXwhhdGffM4qiZ6Momtft4iVJUuaqr4eaLbBlHWyqbN5vAMyIdQB3A04FngeeBI5u66QQQhnwD2ArcA4QAdcDT4QQ9ouiaFN6ypUkSV3yzkyorYa6aqjb2rC9tXv76mqgdmvb++pr2q7DAJgRAfCfURTtBBBCOJ92AiDwWWAssGcURXMbzn8ZeBu4ELipYd8LQHu9gvtHUbQohbVLkqSOrH6nefs3J6T//QtLoLAUikqgalViX8VO6a8jw8QeAKMoqk/y1OOBZxrDX8Nz54cQngJOoCEARlF0QOqrlCRJnbb4efjtqc3fj/kwFJU2B7LChq/GfYXFDdvJ7mvndVruC6H5/RvvSNJyX56KPQB2wj7AA23sfxU4Jc21SJKkjrz5CNx7LtRubt437aH46lEr2RQABwJr2ti/GhjQmRcKIXwF+BwwBHh/COHHwEFRFC1r49wLgAta7ps5c2Zn3q5L0vEe2VADWMe2rCOzagDr2JZ1NNu4cWNG1JHuGoYvfZQ93rqNQD3vDTuS4ctmxFLHtiY3PMZdB8T/u5FNARASEz+21el+3CiKricxgSSZc38G/CyE0PTekydP7uxbJu/Rh3v+PbKhBuuwjkyvwTqsIwkzZ87s+Tqe+BbMuqHNQwt6NRbSwfMPvwaOuDY1tUQR/OPr8NYtTa89fPI18LX+QAb8N5mZeIi9DtL0u9GBbAqAa0j0Am5rAG33DEqSlPuOuLb9ANc45m36up6vo7Ya/vJ5ePkeCIUw9WY44NM9/77qkmwKgK+SGAe4rb2B19JciyRJarRlHfz+bJg/C4rL4dRfw+5HxV2VOpBNAfAvwHdDCGOjKHoHoGHB6EOBa+IsTJKkuHz/8bf4wYy32zzWeAl4zDUPt/v8y4/cnSuP2qPrBaxfCnefAsv/C+VD4cw/wM77d/31lBYZEQBDCCc3bB7Y8HhsCGElsDKKolkN+34OXAo80DCJIwK+DiwCbktnvZIkZYorj9qj/QA3PfGw4IbjeubNl78Gd58M65fAoN3hrD/CgDE9815KqYwIgMC923z/04bHWTRM2omiaFMI4SPA94E7SUz+mAFcEUXRxjTVKUmSAOY/CfecCVvXwaiD4VP3QFlbQ/WViTIiAEZRlNRM3iiK3gU+2cPlSJKkjrzyR7j/osRt2faaCif9HIp7x12VOiEjAqAkScoCUQRP/wge/3+J7w/+HHz0m1BQGG9dLXWwLE6TxtnRbUnlsjgZzAAoSZJ2rL4OHr0WnmsYdn/09TDx0ubbqmVK8OpgWZzGyTA9NiYyixgAJUlSx2o2w5/OhzceStxf98RbYN+TW59j8MoqBkBJktS+Tavgd6fD4uegVz84/bcw5kNxV6VuMgBKkqS2rZ6fWOZl1VzoOzKxzMvQveKuSilgAJQkSdtb8gL89lTYtBJ22hfOvBf6Do+7KqWIAVCSJLX21mNw7zlQUwVjJ8Opd0KvvnFXpRQqiLsASZKUQZ7/dWLMX00VfOBTcMa9hr8cZA+gJElKrPE381sw69uJ7w/7EhxxXfMyL8opBkBJkvJdXQ08eDm8dDeEAjjuJjjo3LirUg8yAEqSlM+2boA/fBrm/QOKy+DkX8Gex8RdlXqYAVCSpHy1YVlimZdlr0DZYDjzDzDiwLirUhoYACVJykcr34S7PgnrFsHAsXDWnxKPygsGQEmS8s3CpxMzfbesg5Hj4VP3QPnguKtSGhkAJUnKJ6/+Ge67AOqqYc/j4JO3Q0lZ3FUpzVwHMAkhhKlx1yBJUrfN/gncOy0R/safD6fdafjLU/YAJiGKogeD6yBJkrJVfT08dh0889PE91O+Bode7hp/ecwAKElSrvvjNHjtASgohhNvgf1OibsixcwAKElSrnvtASjtC6ffDbseFnc1ygAGQEmScl3fEXDmvbDTPnFXogxhAJQkKRctf615e9rDMHDX+GpRxnEWsCRJuWjWt5u3DX/ahgFQkqRcs/xVeO3+uKtQBjMASpKUa2beEHcFynAGQEmScsmy/8Lrf4GiXnFXogxmAJQkKZfMauj9O/DceOtQRjMASpKUK957GV5/MNH796Er4q5GGcxlYCRJyhWNM38P+gz0GZbWt/7+42/xgxlvd3jOmGsebvfY5UfuzpVH7ZHqstQOA6AkSbngvf/AGw9BUW849Iq0v/2VR+3RYYCbOXMmkydPTl9B6pABUJKUdextasPMht6/8edBn53irUUZzwAoSco6O+ptyjtLX4I3H27o/bs87mpi5R8HyTEASpKU7RrX/Rt/HlQMjbeWmPnHQXKcBSxJUjZb+iK89QgUl8Uy9k/ZyQAoSVI2a+r9Ox8qhsRbi7KGAVCSpGy15Hl469FE79+ky+KuRlnEAChJUrZq7P2b8Fl7/9QpBkBJkrLR4n/D249BcTlMyu+Zv+o8A6AkSdmosffv4AugfFC8tSjrGAAlSco2i+bA3MehpAImfj7uapSFDICSJGWbmd9KPE6w909dYwCUJCmbLHoO5s2Akj4wyd4/dY0BUJKkbNLY+3fwhVA2MN5alLUMgEkIIUyNuwZJknj3WZj3j0Tv38RL4q5GWcwAmIQoih6MuwZJkpj5zcTjIZ+z90/dYgCUJCkbLJwN78yE0r72/qnbDICSJGWDxrF/h1wEvQfEW4uyngFQkqRMt/BpmD8LSvslAqDUTSGKorhryAohhKaG6m6bff/xt/jBjLe7/PzLj9ydK4/aI+trsA7ryPQarCNz68gYT3wLZt3Q9ecffg0cce2Oz7vj47DgyeTPbzS9X8Pjuq7Vl0IzZ85k8uTJcZeRMXq6PUIITdtRFIXtjhsAk5PKAJgN/Ifamu3Rmu3RzLZozfZoIVXha8G/4I7jEr1/V7wMvfunv4YU8HejtbgDoJeAJUnKZI33/J14SefCn9SBorgLkCRJ7Zj/ZOLSb69+iaVf2pLMZejGnsC2dPaysnKCAVCSpEwURc0zfydemgiBbTniWgOcOs1LwJIkZaL5/4SFT0Gv/nBwO71/UhcZACVJyjRR1Dz2b9Kl0KtvvPUo5xgAJUnKNPNnwbtPJxZ8nnBh3NUoBxkAJUnKJFGUmNgBDWP/7P1T6hkAJUnKJO88AYuegd4D4WB7/9QzDICSJGWKVmP/Pg+lfeKtRznLAChJUqaY9w9Y9Gyi92/CZ+OuRjnMAChJUiZoue7foZfZ+6ceZQCUJCkTzJ0Bi+dA2SAYb++fepYBUJKkuEURzPxmYvvQy6G0It56lPMMgJIkxW3u32HJ81A2GMafH3c1ygMGQEmS4hRF8ESL3r+S8njrUV4wAEqSFKe3H4OlL0D5EBh/XtzVKE8YACVJikurmb9X2PuntDEASpIUl7f+BktfhPKhcNBn4q5GecQAKElSHFr2/n3oCigpi7Uc5RcDoCRJcXjzEXjvJajYyd4/pZ0BUJKkdGvV+3clFPeOtx7lHQOgJEnp9uZfYdnLUDEMDpwWdzXKQwZASZLSyd4/ZQADYBJCCFPjrkGSlCPeeAiWvQJ9htv7p9gYAJMQRdGDcdcgScoB9fUw84bE9oeuguJe8dajvGUAlCQpXd54CJb/F/rsDAd8Ou5qlMcMgJIkpUPL3r8P2/uneBkAJUlKh9f/Aitehb4j7P1T7AyAkiT1tPp6mPXtxPaHr4Ki0njrUd4zAEqS1NNefwBWvAZ9R8L+Z8ddjWQAlCSpR9XXw0x7/5RZDICSJPWk1/4MK1+HfqPs/VPGMABKktSTmnr/vgBFJfHWIjUwAEqS1JMq34R+o+GDZ8ZdidTEAChJUk87zN4/ZRYDoCRJPam/vX/KPAZASZJSrb6uefuwL0FhcXy1SG0wAEqSlGrP/6p5+wOfiq8OqR0GQEmSUmnZK/Do/zR/b++fMpABUJKkVNm6Ae6dBnVb465E6pABUJKkVIgiePAKWDUXhu4TdzVShwyAkiSlwvN3wH//CMXlcModcVcjdcgAKElSd733Mjzy5cT21JthyB6xliPtiAFQkqTu2LK+edzfAefAfqfGXZG0QwZASZK6Korgwcth9TzY6f1w7LfjrkhKigFQkqSu+vcv4dX7oKQiMe6vuHfcFUlJMQBKktQV7/0HHr02sT31BzB493jrkTrBAChJUme1HPd34Lmw78lxVyR1igFQkqTOiCJ48DJY/Q7stC8c8624K5I6zQAoSVJnzLkdXv2z4/6U1QyAkiQla+lL8LeG+/xO/QEM3i3WcqSuMgBKkpSMLesaxv1Vw0GfcdyfspoBUJKkHYki+MvnYc18GLYvfNRxf8puBkBJknZkzu3w2gNQ0gdO+TUU94q7IqlbDICSJHVk6YvN4/6O/yEMGhdvPVIKGAAlSWpPy3F/48+H958Ud0VSShgAJUlqSxTBA5fCmgUwbD84+htxVySljAEwCSGEqXHXIElKs+d+Bq//BUr7wqmO+1NuMQAmIYqiB+OuQZKURktegL9dl9g+/ocwcGy89UgpZgCUJKmlzWsT4/7qa2D8Z2GfT8RdkZRyBkBJkhpFETxwCaxdCMM/AB913J9ykwFQkqRGz94GbzyUGPd3yh1QVBp3RVKPMABKkgSw5Hl47CuJ7RN+7Lg/5TQDoCRJm9c0j/ubcCHsfULcFUk9ygAoScpvjev9rX0Xdt4fjv563BVJPc4AKEnKb8/c0jDurx+c/CvH/SkvGAAlSflr8fPw+P8mtk/8CQzcNd56pDQxAEqS8lPLcX8HXwR7edMn5Q8DoCQp/0QR3H8JrHsXdj4Ajvq/uCuS0soAKEnKP8/8FN58GHr1g1N+BUUlcVckpVVR3AVIktRpT3wLZt3Q9eeHhv6PE34KA8akpCQpmxgAJUnZ54hrE19tmd6v4XHd9seqVsNth8G6RXDIxbDXx3uuRimDeQlYkpQfogjuvzgR/kYcCFO+FndFUmzsAYxDdy9dHH5N+3/5pqiGyQAze7iGJOrYoTTVMRlsjxYmQ8+3h23RqTp2KNfaoytm/xjeeiQx7u9kx/0pv4UoiuKuISuEEJoaqkfbrKNLF+mSCTVYh3Vkeg3WkV11LHoOfnUs1NfC6b+F9x0XTx15bObMmUyePDnuMjJGT7dHCKFpO4qisO1xLwFLknJb1Wq499xE+Jt4aXrCn5ThDICSpNxVXw/3XwTrF8OIg+DIr8ZdkZQRDICSpNw1+8fw1qPQq7/r/UktGAAlSbnp3Wfh79MT25+4FfqPjrUcKZMYACVJuemPn4GoLjHub89j465GyigGQElSblq/GEaOhynT465EyjgGQElS7qitbt7uPSCx3l9hcXz1SBnKhaAlSZkrimDLWthUCZtWJr42rmj9fcvtLWubn3virdB/VFyVSxnNAChJSq+aLVBV2UaQaxnmGo9VQn1N8q8dCiCqT2zveUzP1C/lAANgJtm4snl76UuxldEkE2oA69iWdTTLhBrAOrb13/vaCHItAt7W9Z17vZI+UDEEyhu/BrexPTTx2HsA/N+Anvm5pBzireCSlJZbwT17Gzxydc+8tiRlioKiNoLctl+Dmx+Le3fu9TPlFmyZUkeG8FZwrcV9Kzh7ADNJ2aDm7WH7xVfHspfjr8E6rCPTa7CO9uvY6/jWQa5iaOvve/WHsN3/jySlkQEwk+x7MvzpvMT2556Mr47Gv1rjrME6rCPTa7CO9us47c5460inJ74Fs27o+JzGdmnL4dfAEdemtiYpCQZASZK66ohrOwxwXvZUpnIdQEmSpDxjAJQkScozBkBJkqQ8YwCUJEnKMwZASZKkPGMAlCRJyjMGQEmSpDzjOoCSpOzjAsxStxgAJUnZZwcLMEvqmJeAkxBCmBp3DZIkSakSoiiKu4asEEJoaqhut1kyly46kopLF5lQg3VYR6bXYB2ZW0eW8FZwzWyL1nq6PUIITdtRFIXtjhsAk5PSAJgF/Ifamu3Rmu3RzLZozfZozfZoZlu0FncA9BKwJElSnjEASpIk5RkDoCRJUp4xAEqSJOUZA6AkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOUZA6AkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOUZA6AkSVKeMQBKkiTlGQOgJElSnjEASpIk5RkDoCRJUp4xAEqSJOWZorgLyEYhhLhLkCRJ6jJ7ACVJkvKMAVCSJCnPhCiK4q5BGSiE8O8oig6Ku45MYXu0Zns0sy1asz1asz2a2Ratxd0e9gBKkiTlGQOg2vOzuAvIMLZHa7ZHM9uiNdujNdujmW3RWqzt4SVgSZKkPGMPoCRJUp4xAEqSJOUZA6AkSVKeMQCqy0II/xNCeDOEUB9COLGD884NIUQdnZMLOmqPEEKvEML9IYTXQwgvhRD+FkIYG1OpPW5HvxshhHEhhH+FEN4KIbwYQsibpSFCCB8LITzf8HO/EkL4dNw1xSmEUBJCuDmE8HYI4dUQwl/jrilu+fKZ2ZF8+8zcVjo+Iw2A6o4ZwMeAf7Z3QghhF+CzwDPpKipGO2qPW6Io2iuKog8CDwK3p6uwGOyoLW4F7oiiaA/gauDukAf3WAwhFAC/Bc6Oomh/4OPAz0MIFfFWFqtvAiXAnlEU7QOcF3M9scqzz8wdyafPzG31+GekATBHhBBGhhB+FEKYHUKoavjrcUw7544KIfwxhLAuhLA+hHBfCGF0Z98ziqJnoyia10FNBcAvgM8DWzv7+t2Rae0RRdGWKIr+1mLXM0Ba/prNtLYIIQwBDgF+3XDu4w2HDuzs+3RXDG3T+AE+sOGxP7AKqO7SD5Bi6W6PEEIZcAFwTRRF9QBRFL3X7R8kBeL4dxPnZ+aOpLs94vzM7IpUtk+6PiMNgLljN+BUYA3wZHsnNXzg/gN4H3AOcDawO/BECKE8xTVdBTwVRdHzKX7dZGRie7T0eeCBHnz9ljKtLUYDS6Moqmmxb2HD/nRLa9tEUVQHnALcH0JY2PCen46iKCMCIOn/Xdmt4b2uCSHMCSE8HUI4oavFp1gc/27i/Mzckbg/R9L5mdkVqWyf9HxGRlHkVw58AQUtts8HImBMG+ddDtQBu7XYtytQC1zVYt8LQGU7X6O2ec2ZwInb7NuHxF9sxe2dk0/tsc3xa4HZQFk+tgWJv2Lf3Gbf48BJ6fr9iKttgKKGNjms4fzxwFJgcLp/9gxpjwMb3uO8hvPfB6wExuVhW8T6mZlp7bHNa6b1MzPu9iFNn5FFKCdEDZdPknA88EwURXNbPHd+COEp4ATgpoZ9B3SzpMOAXYC3Q2LYwjDgZyGE4VEU3dLN196hDGwPAEIIXwQ+CUyJoqgqFa+5IxnYFu8CO4cQiqPmv3B3adifVulum5AYyL1zFEX/bDh/TghhCbA/iQ/4WMXQHptJ/I/yzobz3wghvESiPdodXpIOMbTFRcT4mbkjcX2OxPGZ2RUpbp+0fEZ6CTj/7AP8t439rwJ7p+pNoii6JYqi4VEUjYmiaAyJv2wvyIQPsm2kpT0AQghXAZ8CjoqiaG0qXztF0vW7sRJ4DpgGEEI4isTYuEy87NUoVW2ziMQH+94AIYTdSFw6erPbFaZXStojiqJK4G/AMQAhhOHA+4FXUlBjuqSqLbLlM3NHUvY5kgWfmV2xw/ZJ12ekATD/DCQxRmFbq4EBnXmhEMJXQgiLgYnA7SGExSGEYSmoMZ3S0h4hhJHA90gM+n8iJJY1+He3Kk+9dP5ufA44N4TwFvAd4Myo4TpHhkpJ20RRtJzEDM/fhxD+A/wZuCSKorT3fnZTyn5XgIuAy0MIrwCPAl+MoiibAnEq2yIXpKQ9suQzsyuSbZ8e/4z0EnB+auuXqNPTy6Mouh64PslzJ3f29dOox9sjiqLFXXnNGKTldyOKoreBSZ193Zilqm1+B/yu++XELlXtsQA4stvVxCslbdHqBTP7M3NHut0eWfSZ2RU7bJ90fEbaA5h/1tC8BEVLA2j7r5JcZ3s0sy3aZ9u0Zns0sy1asz06ljHtYwDMP6+SGIOwrb2B19JcSyawPZrZFu2zbVqzPZrZFq3ZHh3LmPYxAOafvwCHhBa31GlYrPLQhmP5xvZoZlu0z7ZpzfZoZlu0Znt0LGPaJ2T2uGt1Rgjh5IbNI0kMIL2YxJpaK6MomtVwTjnwH2Az8BUSYxG+DvQB9ouiaGO66+4ptkcz26J9tk1rtkcz26I126NjWdc+qVxU0K94vxp+kdr6mrnNeaOBPwHrgQ3A/bSxYGW2f9ketoVtY3vYFraH7dP2lz2AkiRJecYxgJIkSXnGAChJkpRnDICSJEl5xgAoSZKUZwyAkiRJecYAKEmSlGcMgJIkSXnGAChJkpRnDICSlCIhhCiJr8ktzp++7T5JSoeiuAuQpBz0tQ6OLUhXEZLUHgOgJKVYFEXT465BkjrivYAlKUVCCIk7wkdRSOLcBcAubR1rfH4IYQ/gM8CUhnP7AsuAvwH/F0XR4pQULinv2AMoSfG4GTgROBz4NW1fGj4J+BzwBPA0UA3sA5wPTA0hHBRF0ZI01Copx9gDKEkp0tgDSPtjALdEUXRDi/OnA18FjoiiaGYbrzcCqIyiaOs2+48GHgF+FkXRRSkoXVKesQdQklLvq+3sXwfc0M6x7bTXuxdF0WMhhFeBj3ahNkkyAEpSqiUzBjAZIYQAnAlMAz4ADAAKW5xSnYr3kZR/DICSlLluAq4A3iMx8WMJsLnh2DTamUQiSTtiAJSkDBRCGApcBvwXmBRF0YZtjn8qlsIk5QTvBCJJ8alreCxs49hYEp/Rj7UR/kY2HJekLjEASlJ8VjU8jm7j2IKGxw+FEJoCYgihAvg5XsGR1A0uAyNJKZLEMjAA90dR9FLD+XuRuMS7ErgbWAMQRdH1Dcd/B5zecM5jQD/gKGALUAV8MFUTTiTlFwOgJKVIiwDYkXOjKLqjxXPOAr4I7An0glZ3AikDrgNOA0aSCIp/Af4X+BNwuAFQUlcYACVJkvKMYwAlSZLyjAFQkiQpzxgAJUmS8owBUJIkKc8YACVJkvKMAVCSJCnPGAAlSZLyjAFQkiQpzxgAJUmS8sz/B2xyRrfNq9GOAAAAAElFTkSuQmCC", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAANaCAYAAADf/z5OAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACL/UlEQVR4nOzdeXxU1f3/8fedTPYFSCAQ9h0EBEEWFRRcKwouKK2KWAG1arWotFba/lyq39ZaW7VadxT3Faw7VlGwKCoKiODGvgohCRCyz2Tu74+bTGZIQrbJ3Jk7r+fjkUfO3Llz55NDNHnn3HOOYZqmKQAAAACAY7jsLgAAAAAAEFoEPQAAAABwGIIeAAAAADgMQQ8AAAAAHIagBwAAAAAOQ9ADAAAAAIdx210A6ub1erV+/fqgY5mZmXK5yOYAAABALPH5fCooKAg61q9fP7nd9cc5gl6EWr9+vQYNGmR3GQAAAAAi0Lfffqsjjjii3ucZHgIAAAAAhyHoAQAAAIDDEPQAAAAAwGGYoxehMjMzax379ttv1b59exuqcQaPx6MPPvhAp5xyiuLj4+0uJybQ5/ag3+1Bv9uDfrcH/W4P+t0ekdDveXl5tdbvqCsvBCLoRagnn3yy1rH27durQ4cONlTjDB6PR23atFGHDh34n2OY0Of2oN/tQb/bg363B/1uD/rdHpHa7w2txs+tmxFq1qxZdpcAAAAAIEoR9AAAAADAYQh6AAAAAOAwzNFzmMrKSnk8HrvLiEgej0dut1tlZWWqrKy0u5ywcbvdiouLk2EYdpcCAACAMCHoOYRpmtq9e7f2799vdykRyzRNderUSdu3b4+50BMXF6fs7Gy1adMm5r52AACAWETQc4jqkJedna2UlBR+ma+Dz+dTUVGR0tLSGlylyClM05TX61VhYaF++uknlZaWKicnx+6yAAAA0MoIeg5QWVnpD3lZWVktvp5pmlq1apVWrFihdevWqbS0VMnJyRo8eLBGjRql4cOHR2WQ9Pl8qqioUFJSUswEvWrp6elKTExUXl6esrOzFRcXZ3dJAAAAaEUEPQeonpOXkpLS4us89thjuvfee7V+/XoZhiG32y3TNGUYhrxer0zTVL9+/XTdddfp8ssvj6i9RHB4qamp2rt3rzweD0EPAADA4WJrWMPhWjLKtnbtWo0aNUrXXHONNmzYIMka2fN4PPJ6vfJ4PDJNU5K0YcMGXXPNNRo1apTWrl0bktrR+qJxFBYAAADNQ9CDli5dqtGjR2vt2rUyTdMf6OpTfc7atWs1evRoLV26NEyVAgAAAGgMgl6MW7t2rSZOnKjy8vImbzlQWVmp8vJyTZw4kZE9AAAAIIIQ9GKYx+PRxRdfrIqKCvl8vmZdw+fz+a/T2vv3ffbZZ5o6dapycnKUkJCgTp066fzzz9fy5cubfc0HH3xQ8+fPr3V8y5YtMgyjzucAAACASEfQi2GPPfaY1qxZ0+LNw71er9asWaPHHnssRJXVdv/992vs2LHasWOH7rrrLn3wwQe6++67tXPnTo0bN04PPPBAs65bX9DLycnR8uXLdeaZZ7awcgAAACD8WHUzRpmmqXvvvTek17zvvvt01VVXhXzRj08++UTXXXedzjjjDL322mtyu2u+bS+44AKde+65mj17toYPH66xY8eG5D0TExN1zDHHhORaAAAAQLgxohejVq1apfXr1ze48EpjmaapH3/8UatXrw7J9QL99a9/lWEYeuihh4JCniS53W49+OCDMgxDd955pyTp1ltvlWEYWrVqlaZMmaKMjAy1adNG06dPV15env+1PXv21Lp167R06VIZhiHDMNSzZ09Jdd+6WX3dNWvWaOrUqWrTpo0yMzN1ww03yOv16ocfftDpp5+u9PR09ezZU3fddVdQrfPnz5dhGNqyZUvQ8SVLlsgwDC1ZssR/bMKECRoyZIiWL1+u4447TsnJyerZs6eefPJJSdLbb7+tESNGKCUlRUceeaQWLVrUwl4GAACAkxD0YtSKFStCPvJmGIZWrFgR0mtWVlbqo48+0siRI9W1a9c6z+nWrZuOPvpoffjhh0G3oZ577rnq27evXn31Vd166616/fXXdd555/nnEr722mvq3bu3hg8fruXLl2v58uV67bXXGqzp5z//uYYNG6YFCxbo8ssv1z333KPrr79e55xzjs4880y99tprOumkk/T73/9eCxcubPbXvnv3bs2YMUOXXXaZXn/9dR155JGaOXOm/vznP2vu3Lm68cYbtWDBAqWlpemcc87Rrl27mv1eAAAAcBZu3XSwkpISff/993U+99FHHykuLk5erzdk7xcXF+cPZXUZOHBgkzd1z8vLU0lJiXr16nXY83r16qUvvvhC+fn5/mNTpkzxj6qddtpp6tChg6ZPn66XX35Z06dP1/Dhw5WcnKyMjIwm3aZ5xRVX6IYbbpAknXLKKfrvf/+rBx54QAsXLtS5554ryRqRe+utt/Tcc89pypQpTfqaq+Xn5+u9997T0UcfLUkaOXKksrOzdeedd2rDhg3q3LmzJKlz58466qijtGDBAl177bXNei8AAAA4C0HPwb7//nt/SAgHr9erF198US+++GKdz3/11VcaMWJEq7x39S2ogaOU06ZNCzrn5z//uWbMmKElS5Zo+vTpzX6vSZMmBT0+4ogj9PXXX2vixIn+Y263W3379tXWrVub/T45OTlB/36ZmZnKzs5Wz549/SGv+v0ltei9AAAA4CwEPQcbOHCgvvrqqzqfu+uuu7RgwYKQjui53W6df/75+t3vfldvPU3Vvn17paSkaPPmzYc9b8uWLUpJSVFmZqb/WKdOnWrVl5mZGTTq1xyB7yFJCQkJSklJUVJSUq3jhYWFIXuf6mvW9f6SVFZW1uz3AgAAgLMQ9BwsJSWl3hG0E088US+//HJI36+yslInnnhiSEft4uLidOKJJ2rRokXasWNHnfP0duzYoa+++koTJ05UXFyc//ju3bvVpUsX/2Ov16uCggJlZWWFrL6mqA6C5eXlQccDF4gBAAAAQoHFWGLUqFGjQrbiZjXTNDVq1KiQXlOS5s6dK9M0dfXVV9fa86+yslJXXXWVTNPU3Llzg5577rnngh6//PLL8nq9Gj9+vP9YYmKiSktLQ15zXapX9FyzZk3Q8TfeeCMs7w8AAIDYwYhejBo+fLj69eunDRs2hCTwGYahfv366aijjmp5cYcYO3as7r33Xl133XUaN26crrnmGnXv3l3btm3Tv//9b33++ee69957ddxxxwW9buHChXK73Tr11FO1bt06/b//9/80ZMgQ/fznP/efc+SRR+rFF1/USy+9pN69eyspKUlHHnlkyL8GyQrXAwYM0G9/+1t5vV61a9dOr732mpYtW9Yq7wcAAIDYxYhejDIMQ9ddd11Irzl79uyQb9lQ7dprr9Unn3yirl27as6cOTrppJN0ww03KCcnR8uWLatztcmFCxfq+++/15QpU3TzzTdr0qRJWrhwoX9OmyTddtttGj9+vC6//HKNHj1akydPbpX6Jes21DfffFMDBw7UlVdeqUsuuUSJiYl64IEHWu09AQAAEJsY0Ythl19+uR599FGtXbu21i2RTeF2uzV48GBdccUVIayutmOOOUavvPJKo8/v3r170G2RPp+v1uIoPXr00HvvvVfrtT179qw10nnrrbfq1ltvrXXu/PnzgzZWrxa4AXq1fv361fl+h75XXa+VVGuz9fpeDwAAgNjGiF4Mi4+P17PPPquEhAS5XM37VnC5XP7ruN383QAAAACIBAS9GDdkyBC9++67SkxMbHJQc7vdSkxM1LvvvqshQ4a0UoUAAAAAmoqgB40fP15ffPGFBg8eLMMwGpxnV33O4MGD9cUXXwStYhkJbr31Vpmmqfbt29tdCgAAAGALgh4kWSN7K1as0AMPPKC+fftKsgJdfHy83G634uPj/QGwX79+euCBB7RixQpG8gAAAIAIxKQq+MXHx+vqq6/WVVddpdWrV2vFihVat26dSkpKlJKSosGDB2vUqFE66qijWm11TQAAAAAtR9BDLYZhaPjw4Ro+fLjdpQAAAABoBoIeAAAAgJiTW1im3IPlDZ7n9Xq1vUhat6uwUYsXZqcnKjsjKRQltghBL0Y19hu7qSLlGxsAAAA4nOc+36b7Fq9v5Nlu3f3NZ406c/bJ/XT9qf2bX1iIEPRiVNO+sRsvUr6xAQAAgMOZNqa7Th3UscHzLnnicxUUe5SZGq+nZ45p8Pzs9MRQlNdiBL0Y1dhv7F8+8YXyiyuUlZqgp2aObvD8SPnGBgAAAA4nOyOpUXeixce5/J+HdGnT2mWFDEEvRkXDN3ZjV/b86KOPNGHChBa9V0lJie666y5NmDCh1rXmz5+vGTNmaPPmzerZs2eL3gcAAAAIB4IeItby5cuDHt9+++366KOP9OGHHwYdHzRoUIvfq6SkRLfddpsk1Qp6Z555ppYvX66cnJwWvw8AAAAQDgQ9RKxjjjkm6HGHDh3kcrlqHW9tHTp0UIcOHcL6ngAAAEBLuOwuAGiJiooK3XHHHRo4cKASExPVoUMHzZgxQ3v37g0678MPP9RJJ52k3r17KzU1Vd27d9d5552nkpISbdmyxR/kbrvtNhmGIcMwdOmll0qybt00DENbtmzxX2/ChAkaMmSIVqxYoeOPP14pKSnq3bu37rzzTvl8vqD3XrdunU477TSlpKSoQ4cO+vWvf623335bhmFoyZIlrdk9AAAAiFGM6CFq+Xw+nX322frf//6nG2+8Uccdd5y2bt2qW265RRMmTNCXX36p5ORkbdmyRWeeeabGjRunBx54QDk5Ofrpp5+0aNEiVVRUKCcnR4sWLdLpp5+uWbNm6bLLLpOkBkfxdu/erWnTpmnOnDm65ZZb9Nprr2nu3Lnq3LmzLrnkEknSTz/9pPHjxys1NVUPPfSQsrOz9cILL+iaa65p9f4BAABA7CLoOdjk+5dpbwv3yss9WOb/fMxfFrfoWh3SE/XmteNadI1AL7/8shYtWqQFCxZoypQp/uPDhg3TqFGjNH/+fF111VX66quvVFZWprvuuku9evVSRkaGXC6XLrroIv9rjj76aElS165dG31raH5+vt555x2NHm2tRnrKKadoyZIlev755/1B75577lFBQYE+/vhj/1zCiRMn6vTTTw8aIQQAAABCiaDnYHsPlmt3YVlIruUzFbJrhcpbb72ltm3bavLkyfJ6vf7jRx11lDp16qQlS5boqquu0lFHHaWEhARdeeWVuvTSS3Xqqaeqb9++LX7/Tp06+UNetaFDh2r16tX+x0uXLtWQIUNqLRhz4YUX6r333mtxDQAAAEBdCHoO1iEEe9rlHiyTz5RchpSd3vB2DK1dT6A9e/Zo//79SkhIqPP5vLw8SVKfPn30wQcf6G9/+5t+97vfqbi4WL1799ZvfvMbzZ49u9nvn5WVVetYYmKiSktL/Y/z8/PVq1evWud17NjwHoYAAABAcxH0HCwUt0ke85fF2l1Ypuz0JH32h5NDUFXotG/fXllZWVq0aFGdz6enp/vbxx9/vMaOHat9+/bpxx9/1L///W9dd9116tixoy644IJWqzErK0t79uypdXz37t2t9p4AAAAAq24iak2aNEn5+fmqrKzUyJEja30MGDCg1mvi4uI0ZswY/fvf/5YkrVy5UpI1EicpaDQuFMaPH6+1a9fq22+/DTr+4osvhvR9AAAAgECM6CFqXXDBBXruued0xhlnaPbs2Ro9erTi4+O1Y8cOffTRRzr77LN17rnn6uGHH9aHH36oiRMnqn379nK5XJo/f74kawEVyRr969Gjh15//XWdfPLJyszMVPv27dWzZ88W1XjdddfpiSee0MSJE/XnP/9ZHTt21PPPP6/vv/9ekuRy8bcWAAAAhB6/ZSJqxcXF6Y033tAf/vAHLVy4UOeee67OOecc3XnnnUpKStKRRx4pyVqcxev16rbbbtPUqVP1y1/+Unv37tUbb7yh0047zX+9efPmKSUlRWeddZZGjRqlW2+9tcU1du7cWUuXLlX//v115ZVXatq0aUpISNCf//xnSVLbtm1b/B4AAADAoRjRQ9SYP3++fySumtvt1pw5czRnzpx6X3fMMcdo4cKF8vl8Kiws9G+vcKiTTz7ZfytnoEsvvdS/eXq1+jY6P7Q+SRo8eLDef//9oGNXXHGF0tLSNHDgwHrrBgAAAJqLoBejcgvLlNuIPfY8lT7/57U7DzR4fnZ6orIzWrY6p9P8+c9/VufOndW7d28VFRXprbfe0uOPP64//elP9a4YCgAAALQEQS9GPff5Nt23eH2jz88vrtCk+5c1eN7sk/vp+lP7t6Q0x4mPj9ff//537dixQ16vV/369dM///nPFm3tAAAAABwOQS9GTRvTXacOCv1ebtkh3ivPCebOnau5c+faXQYAAABiCEEvRmVnJHGLJQAAAOBQrLoJAAAAAA5D0AMAAAAAhyHoAQAAAIDDMEcvVh3cbX2EWnon6wMAAACAbQh6serLJ6Wld4b+uuNvkk5khUkAAADATgS9WDVyhjRgYsPnPXueVJInpbSXLl7Q8PmM5gEAAAC2I+jFqsbeYhmXUPO581GtWhIAAACA0GAxFkQswzAa9bFkyZIWvc+tt94qwzCa9dolS5aEpAYAAAAglBjRQ8Ravnx50OPbb79dH330kT788MOg44MGDWrR+1x22WU6/fTTm/XaESNGaPny5S2uAQAAAAglgh4i1jHHHBP0uEOHDnK5XLWOH6qkpEQpKSmNfp+uXbuqa9euzaoxIyOjwXoAAACAcOPWTUS1CRMmaMiQIfr444913HHHKSUlRTNnzpQkvfTSSzrttNOUk5Oj5ORkDR48WLfeequKi4uDrlHXrZs9e/bUpEmTtGjRIo0YMULJyckaOHCgnnjiiaDz6rp189JLL1VaWpo2bNigM844Q2lpaerWrZvmzJmj8vLyoNfv2LFD559/vtLT09W2bVtNmzZNK1askGEYmj9/fug6CgAAADGFET0ne2S8VJTbsmsU7a75/I8jWnattGzpV0tbdo06/PTTT7r44ot144036i9/+YtcLuvvF+vXr9cZZ5yh6667Tqmpqfr222/1t7/9TWvWrKl1+2ddvv76a82ZM0c33XSTOnbsqMcff1yzZs1S3759dcIJJxz2tR6PR2eddZZmzZqlOXPm6OOPP9btt9+uNm3a6Oabb5YkFRcX68QTT1RBQYH+9re/qW/fvlq0aJF+8YtftLxTAAAAENMIek5WlCsd3BWaa5m+0F0rxAoKCvTKK6/opJNOCjr+pz/9yd82TVPHHnusunfvrkmTJmnNmjUaOnToYa+bl5enTz75RN27d5cknXDCCVq8eLGef/75BoNeRUWFbrvtNk2dOlWSdPLJJ+vLL7/U888/7w96Tz31lDZs2KB3333XP0fwtNNOU0lJiR555JGmdQIAAAAQgKDnZGnZLb9G0W4r5BkuKa2Fe+SFop46tGvXrlbIk6RNmzbpT3/6kz788EPl5ubKNE3/c999912DQe+oo47yhzxJSkpKUv/+/bV169YGazIMQ5MnTw46NnTo0KCRxKVLlyo9Pb3WQjAXXnghQQ8AAAAtQtBzslDcJvmPI6yRvLRO0pzvWn69VpCTk1PrWFFRkY4//nglJSXpjjvuUP/+/ZWUlKQff/xR06dPV2lpaYPXzcrKqnUsMTGxUa9NSUlRUlJSrdeWlZX5H+fn56tjx461XlvXMQAAAKApCHqIenXtgffhhx9q165dWrJkicaPHy9J8vl82rUrcm4/zcrK0hdffFHr+O7du22oBgAAAE7CqptwpOrwl5iYGHQ8klayHD9+vA4ePKh333036PiLL75oU0UAAABwCkb04EjHHXec2rVrpyuvvFK33HKL4uPj9eyzz2rt2rV2l+b3y1/+Uvfcc48uvvhi3XHHHerbt6/effddvffee5LkXz0UAAAAaCp+k4QjZWVl6e2331ZKSoouvvhizZw5U2lpabX2wbNTamqqPvzwQ02YMEE33nijzjvvPG3btk0PPvigJKlt27b2FggAAICoxYhehJo3b57dJUSc+fPn17r1MnCj8kMde+yx+vTTT/2PfT6fCgsLVVlZGTRaduutt+rWW28Neu2WLVvqvOah7zdhwoSg1Tzrq7O+9+nWrZsWLFgQdOwvf/mLDMPQiBEj6v7CAAAAgAYQ9CLUrFmzNHfu3NZ7g4O7rY+GVFbUfN61uuHz0ztZH2iUBx54QJI0cOBAeTweffjhh/rXv/6liy++WF27drW5OgAAAEQrgl6s+vJJaemdjT+/JE96dHzD542/STqxFQOqw6SkpOiee+7Rli1bVF5eru7du+v3v/990GbvAAAAQFMR9GLVyBnSgImhvy6jeU0yc+ZMzZw50+4yAAAA4DAEvVjFLZYAAACAY7HqJgAAAAA4DEHPQQ5d/REIxPcHAABA7CDoOUB8fLwkqaSkxOZKEMmKi4tlGIb/+wUAAADOxRw9B4iLi1Pbtm2Vm5sryVrJ0TAMm6uKPD6fTxUVFSorKwvaR8/JTNOU1+tVYWGhCgsL1bZtW8XFxdldFgAAAFoZQc8hOnWyFlapDnuozTRNlZaWKjk5OeaCcFxcnHJyctSmTRu7SwEAAEAYEPQcwjAM5eTkKDs7Wx6Px+5yIpLH49HHH3+sE044IaZuX3S73YqLi4u5cAsAABDLCHoOExcXx6159YiLi5PX61VSUlJMBT0AAADEntiYqAQAAAAAMYSgBwAAAAAOQ9ADAAAAAIch6AEAAACAwxD0AAAAAMBhCHoAAAAA4DAEPQAAAABwGIIeAAAAADgMQQ8AAAAAHIagBwAAAAAOQ9ADAAAAAIch6AEAAACAwxD0AAAAAMBhCHoAAAAA4DAEPQAAAABwGIIeAAAAADgMQQ8AAAAAHIagBwAAAAAOQ9ADAAAAAIch6AEAAACAwxD0AAAAAMBhCHoAAAAA4DAEPQAAAABwGIIeAAAAADgMQQ8AAAAAHIagBwAAAAAOQ9ADAAAAAIch6AEAAACAwxD0AAAAAMBhCHoAAAAA4DAEPQAAAABwGIIeAAAAADgMQQ8AAAAAHIagBwAAAAAOQ9ADAAAAAIdx210AAAAAAITdwd3WRwMG+DapvVGhLF+CtGt1w9dN72R92IygBwAAACD2fPmktPTOBk97WpISJXklPdqI646/STpxbstqCwGCHgAAAIDYM3KGNGBig6cVPDpZmSpUgTKUecWbDV83AkbzJIIeAAAAgFjUyFssvVWRySu31PmoVi4qdFiMBQAAAAAchqAHAAAAAA5D0AMAAAAAhyHoAQAAAIDDEPQAAAAAwGEIegAAAADgMAQ9AAAAAHAYgh4AAAAAOAxBDwAAAAAchqAHAAAAAA5D0AMAAAAAhyHoAQAAAIDDEPQAAAAAwGEIegAAAADgMAQ9AAAAAHAYgh4AAAAAOAxBDwAAAAAchqAHAAAAAA5D0AMAAAAAhyHoAQAAAIDDEPQAAAAAwGEIegAAAADgMAQ9AAAAAHAYgh4AAAAAOAxBDwAAAAAchqAHAAAAAA5D0AMAAACAOpimKdO0u4rmcdtdAAAAAABEok15xZpcfrf6GLv0s7gvdY3dBTUBI3oAAAAAUIeNuUUqUZK+MXtrv5lmdzlNQtADAAAAgDps2Fvkb/d07bGxkqYj6AEAAABAHTbmFvvbPY3dNlbSdAQ9AAAAAKjDxqoRPUM+dTdyba6maQh6AAAAAHAI0zT9Qa+Lkackw2NzRU1D0AMAAACAQ+w9WK6DZV5JUh9jl83VNB1BDwAAAAAOEbgQC0EPAAAAABxg496ahVgIegAAAADgABtza0b0+roIegAAAAAQ9TZy6yYAAAAAOEv1iF6GipWlQpuraTqCHgAAAAAEKC73ateBMklSD2OPDMPmgpqBoBeh5s2bZ3cJAAAAQEzanFezEEtP1x4bK2k+gl6EmjVrlt0lAAAAADEpcH5eT2O3jZU0H0EPAAAAAAIErrjZ02BEDwAAAACiXuBm6T0IegAAAAAQ/TbmWnP04uMMdTbyba6meQh6AAAAAFCl0mf6F2PpmZUqt+GzuaLmIegBAAAAQJUd+0pUUWmFu77ZaTZX03wEPQAAAACoErjiZp8OBD0AAAAAiHobAlbc7JOdamMlLUPQAwAAAIAq1QuxSIzoAQAAAIAjBN662ZugBwAAAADRrzro5bRJUlqi2+Zqmo+gBwAAAACSCoortK/EIym6b9uUCHoAAAAAIOmQhVg6RO9CLBJBDwAAAAAkHbK1QhTvoScR9AAAAABAkrQx1xl76EkEPQAAAACQFDyi15cRPQAAAACIfhv3WnvopSW6lZ2eaHM1LUPQAwAAABDzyjyV2r6vRJK1EIthGDZX1DIEPQAAAAAxb3NesUzTakf7/DyJoAcAAAAAjlpxUyLoAQAAAIA25hb72/4RvYN7lC4rALrlsaOsZiPoAQAAAIh5wStuVm2Wvvc7JatCkpRE0AMAAACA6LKhag+9OJeh7plVQS9/o/95b5RFp+iqFgAAAABCzOcztSnPCno9MlOU4K6KSQFBr1JxdpTWbAQ9AAAAADFt14FSlXl8kqTegStuFhD0AAAAACAqVW+ULkl9A1fczN/gb/oUXfvqEfQAAAAAxLSNuQFbK3Somp9X6ZX2bQk4i6AHAAAAAFFjQ1176O3fKvm8NlXUcgQ9AAAAADEtaESvfVXQK9hkUzWhQdADAAAAENOq5+i1T0tUm5R462DA/LxoRNADAAAAELMOlHiUV1QuKWCjdCloa4VoRNADAAAAELM25gUuxFL3ipvRiKAHAAAAIGZtyK0n6FXtoRdt2ypUI+gBAAAAiFkb61px01Mm7d8uSaqM0sgUnVUDAAAAQAhszK3ZLN2/h96+LZJMSVKl4sJfVAgQ9AAAAADErE1VI3rJ8XHq3CbZOhgwP89L0AMAAACA6FHh9WlrQYkkqXeHVLlcVfPxCmpW3OTWTQAAAACIIlvzi1Xps27RrG/FTW7dBAAAAIAoErQQS1DQ2+RvMqIHAAAAAFFk496AhVgCN0uvvnUztYPMKI1M0Vk1AAAAALTQxoA99PpWb61QXiQd/MlqZ/axoarQIOgBAAAAiEkbqm7dNAypZ1bViF5BzW2byuprQ1WhQdADAAAAEHNM0/SP6HVrl6Kk+KpFVwIWYlFWbxsqCw2CHgAAAICYs6ewXMUVlZICNkqXgrZWYEQPAAAAAKJI/StuBgQ95ugBAAAAQPQIDHr+hVikQ4Iet24CAAAAQNTYELDiZp/sOjZLz+giJaSEuarQIegBAAAAiDl13rpZUiCVFljtrOi9bVMi6AEAAACIQRtzrc3S26XEKzM1wToYuLVCFM/Pkwh6AAAAAGJMUblXuwvLJB1mIZYoXnFTIugBAAAAiDGb6l2IJXAPPUb0AAAAACBqBC3EEjii55A99CSCHgAAAIAYE7QQS3bAZunVI3qGS2rbI8xVhRZBDwAAAEBMqV6IRQoY0TNNKb9qMZa2PSR3gg2VhQ5BDwAAAEBMqR7RS3C71LVd1V55RblSxUGrHeXz8ySCHgAAAIAY4q30aUu+NaLXu32q4lyG9YSD5udJBD0AAAAAMWRbQYk8laakQ7dWCFhxM8r30JMIegAAAABiyMa9gfPzAhdiCRzRI+gBAAAAQNQIXnHTmXvoSQQ9AAAAADFkY7176FWtuBmXILXpFuaqQo+gBwAAACBmBI7o9a6+ddPnqwl67XpJrjgbKgstgh4AAACAmGCapjZUjeh1aZuslAS39UThTslbZrUdsOKmRNADAAAAECPyiipUWOaVFDCaJx0yP693mKtqHQQ9AAAAADEhaCGWoPl5ztpDTyLoAQAAAIgRgUGvb9CKmwFBzwF76EkEPQAAAAAxYmNu4B569QQ9RvQAAAAAIHpsCNpDr445evGpUnqnMFfVOgh6AAAAAGJC9R566UludUhLtA5WeqT9W612Vm/JMGyqLrQIegAAAAAcr7SiUjv3l0qybts0qgPd/m2Sz1qJ0ynz8ySCHgAAAIAYsCmvEQuxOGR+nkTQAwAAABADNu6tbyGWwD30GNEDAAAAgKixITdwD72AhVgcuIeeRNADAAAAEAOCNkvPrmdEjzl6AAAAABA9qlfcdLsMdc9MqXkif5P1OamtlJIZ/sJaCUEPAAAAgKNV+kxtzrPm6PVsn6r4uKoY5CmTDmy32ll9HLO1gkTQAwAAAOBwu/aXqtzrk3TI/Lx9myWZVttB8/Mkgh4AAAAAhwteiMX58/Mkgh4AAAAAhwtaiKVDfXvoEfQAAAAAIGo0asVNgh4AAAAARI+NuYGbpQfuobepps2tmwAAAAAQPTZUjeh1zEhUelJ8zRPVI3qp2VJShg2VtR6CHgAAAADHKiiuUEFxhaRD5ueVH5SK9lhth624KRH0AAAAADjYpkYtxNI7jBWFB0EPAAAAgGMFr7gZOD8vMOgxogcAAAAAUWPj3pqFWPpmp9c8ETii57CFWCSCHgAAAAAHC9osPTtgRC+fET0AAAAAiErVt26mJMSpU0ZSzROBe+hl9gpzVa2PoAcAAADAkco8ldpeUCLJWojFMIyaJ6vn6LXpJsUn21Bd6yLoAQAAAHCkrfkl8plWO2ghlpICqXSf1c503oqbEkEPAAAAgEMFrrjZN7u+rRWcNz9PIugBAAAAcKighViC9tALmJ+X5bwVNyWCHgAAAACHCtpDL3BEz+F76EkEPQAAAAAOVR30XIbUIyul5omgFTcZ0QMAAACAqODzmdqYa22W3j0zRYnuuJonq+foGXFSux42VNf6CHoAAAAAHGd3YZlKPZWSDlmIxTRrgl67HlJcvA3VtT6CHgAAAADHqXchlqI9ksca6XPq/DyJoAcAAADAgYIWYqlvxU2Hzs+TCHoAAAAAHCh4xc2AzdKD9tAj6AEAAABA1KheiEWKvT30JIIeAAAAAAeqHtFrn5agtikJNU8UbKppM0cPAAAAAKJDYZlHuQfLJUm9A0fzpJoRvbhEKaNrmCsLH4IeAAAAAEfZWN+Km75KqWCz1c7sLbmcG4ec+5UBAAAAiEkb9wbOzwtYiOXADqnSGulz8vw8iaAHAAAAwGGCV9wMGNEriI0VNyXJbXcBAAAAABBKgbdu9g1acTMg6KV0kHatbvBabnlrPjfifKV3sj5sRtADAAAA4Cgbqkb0Et0udWmbXPNEYNDL/VZ6/08NXivT/7lQenR8w28+/ibpxLlNqLZ1EPQAAAAAOIan0qdt+SWSrBU3XS6j5snAPfSOuUoa86sGr3fJE18ov7hCWakJenrm6IYLiIDRPImgBwAAAMBBtuaXyOszJR2yEItUM0cvIU3qdKRkGGrID6487THL1dGVKHU+KsTVth4WYwEAAADgGEELsQTOz6v0SPu2Wu3M3o0KedGMoAcAAADAMQKDXt/AFTf3bZXMSqud1TfMVYUfQQ8AAACAY2yob7P0wPl5Dt9aQSLoAQAAAHCQ6s3SDUPq1T5gjl7QHnqM6AEAAABAVDBNU5uqRvS6tE1WckJczZOBI3qZjOgBAAAAQFTYe7BcB8utDc6DbtuUgvfQ49ZNAAAAAIgOG+pbiEWqCXrJ7aSUTDkdQQ8AAACAI2ysbyEWT6lUuMNqx8D8PImgBwAAAMAhqhdikQ7ZLL1gU007BubnSQQ9AAAAAA4RtFl64K2bMTY/TyLoAQAAAHCI6ls32yTHKys1oeaJGNtDTyLoAQAAAHCA4nKvdh0ok2QtxGIYRs2TgXvocesmAAAAAESHTfXNz5O4dRMAAAAAolHQ/Lz69tBL6yglpoexKvsQ9AAAAABEvXqDXlmhVJxrtWNkawWJoAcAAADAAepdcTNofl7vMFZkL4IeAAAAgKi3oWrFzYQ4l7q1S655Imh+HiN6AAAAABAVvJU+bckrkST1bJ8id1xAzInBhVgkgh4AAACAKLdjX6kqKn2S6lqIJXAPPUb0YLN58+bZXQIAAAAQFQ674qZ/jp4htesVvqJsRtCLULNmzbK7BAAAACAqBC/EErCHnmnWjOi16SbFJ4W5MvsQ9AAAAABEteqFWCSpb4eAffJKCqSyA1Y7K3ZW3JQIegAAAACi3Ma9xf527w4BI3oxOj9PIugBAAAAiGKmafpH9HLaJCk10V3zZNAeerGz4qZE0AMAAAAQxQqKK3Sg1COJFTcDEfQAAAAARK3A2zb7BN62KcXsHnoSQQ8AAABAFAtaiCX70BG9qqDnckttu4exKvsR9AAAAABErXr30DPNmjl6bXtIcfFhrsxeBD0AAAAAUSt4D72AoHfwJ8lTYrVjbH6eRNADAAAAEMWqg15aolvZ6Yk1T8Tw/DyJoAcAAAAgSpV5KrVjX6kkayEWwzBqngxacZOgBwAAAABRYdPeYpmm1e5z6EIsMbyHnkTQAwAAABCl6l2IRTrk1k3m6AEAAABAVGhU0HMnSRldwlhVZCDoAQAAAIhKgZul980O2CzdVynt22y1M3tLrtiLPW67CwAAAEBkyC0sU+7B8gbP83q92l4krdtVKLe74V8ns9MTlZ2RFIoSgSAbqzZLj3MZ6p4ZEPQObJcqK6x2Zm8bKrMfQQ8AAACSpOc+36b7Fq9v5Nlu3f3NZ406c/bJ/XT9qf2bXxhQB5/P1KY8K+j1yEpRgjtg1C5oxc3Ym58nEfQAAABQZdqY7jp1UMcGz7vkic9VUOxRZmq8np45psHzg/Y2A0Jk5/5SlXl8kuqan7epph2DWytIBD0AAABUyc5IatQtlvFxLv/nIV3atHZZQJ0OvxALI3qxNysRAAAAQNQLXIilT4fU4CdjfA89iaAHAAAAIAoFjegdull69YheQrqUlh3GqiIHQQ8AAABA1NmQW8+tm94Kaf82q53VWzKMMFcWGQh6AAAAAKLOpqoRvQ7piWqTHF/zxL4tkmkt0hKr8/Mkgh4AAACAKLO/pEJ5RdY+eczPqxtBDwAAAEBUCV6IhRU360LQAwAAABBVDr+1QsCIXozuoSexjx4AAEBI5RaWKfdgecivm52e2Kg97oBYsDFgIZa+9a24KUmZvcNUUeQh6AEAAITQc59v032L14f8urNP7qfrT+0f8usC0eiwWysUbLI+J2dKKZlhrCqyEPQAAABCaNqY7jp1UMcGz/vlE18ov7hCWakJemrm6AbPz05PDEV5gCNUz9FLjo9TTuBId0WJVLjTasfw/DyJoAcAABBS2RlJjbrFMj7O5f88pEub1i4LcIxyb6W2FZRIknp3SJXLFbBPXvVonhTT8/MkFmMBAAAAEEW25Zeo0mdKamjFTYIeAAAAAESFDYdbiIU99PwIegAAAACiRuO3VmCOHgAAABDV2NYidgRtlp6dGvxkYNCL4a0VJIIeAAAAHIBtLWJH9YieYUg9sw4NelVz9NJzpMRDRvtiDEEPAAAAUY9tLWKDaZr+zdK7tUtRUnxczZOl+6WSPKsd4/PzJIIeAAAAHIBtLWLD7sIyFVdUSmpgIZYYX3FTYjEWAAAAAFFiY27A/LwOh962yR56gRjRg6TonsDc2Nq9Xq+2F0nrdhXK7W74W7+1a6fPa4uk2psqkmqn30OLfq8tkmqPxH4H0HoOu+JmAStuBiLoQVJ0T2BuWu1u3f3NZ406s7Vrp89ri7zaGy/yaqffQ4V+ry3yao+sfgfQeoKC3qG3bgZuls4cPYIeLNE8gbmxtV/yxOcqKPYoMzVeT88c0+D5rV07fV5bJNVOv4cW/V5bJNVOvwOIFoGbpde/h54hZfYKX1ERiqAHSdE9gTlaa4/WuiVqtwu124Pa7RHNtQNoPdUjepmpCcpMTah5wjRrgl7bbpKbP+qwGAsAAACAiHewzKM9hdbc3VoLsZTkS+UHrDbz8yQR9AAAAABEgU17A1fcZH5eQwh6AAAAACLeYVfczGfFzUMR9AAAAABEvKCFWLIP3UMvYESPPfQkEfQAAAAARIHAEb2+HdKDnwzaQ4+gJxH0AAAAAESBjVVz9BLcLnVplxz8ZPWtmy631KZ7mCuLTAQ9AAAAABHNU+nT1nwr6PVun6o4l1HzpM8nFWyy2u16SXHsICcR9AAAAABEuO0FJfJUmpLqWIjl4E+Sp8Rqc9umH0EPAAAAQEQLWojl0D30Clhxsy6MawIAAACIaBsD99DLPtweer0bfc3cwjLlHixv8DxPpc//ee3OAw2en52eqOyMpEbX0VoIegAAAAAiWmvsoffc59t03+L1jT6/oNijSfcva/C82Sf30/Wn9m/0dVsLQQ8AAABARAsMer0PvXUzv3lbK0wb012nDurY4Hler1fLli3TuHHj5HY3HJ+y0xMbXUNrIugBAAAAiFimaWpj1Ry9Lm2TlZJwSISpnqPnTpbSOzf6utkZSY26xdLj8WhrmjS4c4bi4+MbfX27sRgLAAAAgIi1t6hchWVeSXXMz6v0SgWbrXZmb8lFvKlGTwAAAACIWBtzAxZiOfS2zQPbJZ/HarO1QpBmBb0bbrhBN9xwg3Jzc+t8vrKyUtu2bdO2bdsOe51NmzZpxIgROvroo5tTBgAAAACHa/xCLAS9QM2ao3fvvffKMAxddtllys7OrvX8999/ryOPPFIul0ter7fe65SWlmr16tUyDKPecwAAAADErsMGPfbQq1er3rppmmZrXh4AAACAwwXvoXfoipuBe+gxoheIOXoAAAAAIlb1ipsZSW51SDtk64Jm7qEXCwh6AAAAACJSSYVXO/eXSrJW3Kw15at6RC8xQ0ptH+bqIhtBDwAAAEBE2hR42+ah8/O85daqm5K1EAvrfgQh6AEAAACISIddiGXfFsn0WW3m59VC0AMAAAAQkYIWYjl0Dz3m5x0WQQ8AAABARKpeiEWS+mYfuodewIqb7KFXC0EPAAAAQESqvnUzPs5Qt8yU4CcL2Cz9cJq1YXq1Bx98sM4N03Nzc/3tP//5z/W+PvA8AAAAAKhW6TO1Kc+6dbNHVqri4w4Zowq8dZM5erW0KOg99NBD9T5XvfTpbbfd1pK3AAAAABCDdu4rVYXXWmyl1vw8qSbopbSXktuGr7Ao0eygZ5pmKOsAAAAAAL/DrrhZUSwd3GW1uW2zTs0Keh999FGo6wAAAAAAvw2HW4ilYFNNmxU369SsoDd+/PhQ1wEAAAAAfocd0QtccTOzd5gqii4tmqMHAAAAoGVyC8uUe7C8wfO8Xq+2F0nrdhXK7W741/js9ERlZySFokRbBAa93uyh12QEPQAAAMBGz32+TfctXt/Is926+5vPGnXm7JP76fpT+ze/MJtVb5beMSNR6UnxwU/ms7VCQ8IS9IqLi/XBBx9ow4YNcrlc6tWrl0455RSlpaU1/GIAAADAwaaN6a5TB3Vs8LxLnvhcBcUeZabG6+mZYxo8Pzs9MRTlHVZjRyObKiHOUEFxhaQ6btuUgvfQ49bNOjUr6Jmmqffff1+S1K1bNx1xxBH1nvvUU09pzpw52rdvX9Dx1NRU/d///Z+uvfba5pQAAAAAOEJ2RlKjbrGs3kcuPs6lIV3atHZZjdK00cjGO//orv52rYVYpJo5eumdpYQ6tl5A84Le119/rdNPP12GYejVV1+tN+g988wzmjFjhgzDqLUdQ1FRka677jpVVFRozpw5zSkDAAAAgI0aOxr5yye+UH5xhbJSE/TUzNENnv/pxjx/u9aIXuk+qSTfanPbZr2aFfSWLl0qScrOztY555xT5zn79u3T7NmzJVkjgH379tWFF16ozp0768svv9RTTz0lr9erm2++WRdccIG6dOnSvK8AAAAAgC1aazTy9dU7/e3aK24Gbq1A0KuPqzkv+vjjj2UYhs466ywZhlHnOU899ZT2798vwzB0/PHHa/Xq1brtttv0q1/9So899pjefvttuVwulZWV6ZlnnmnRFwEAAADAOaoXYpGkPtmH3JpZwIqbjdGsoLdpk5Wix44dW+85r732mr997733KiUlJej5U089VVOnTpVpmmzADgAAAMCverP01IQ4dTp0xDBoDz1G9OrTrKCXm5srSerXr1+dz1dUVOiLL76QYRjq16+fhg8fXud5Z599tiTp22+/bU4ZAAAAABymzFOp7ftKJEl9stNq30HIHnqN0qygl5dnTY5MTa17hZtVq1apvNxaZnXcuHH1XqdvX+sf5tAVOQEAAADEpi35xapex7HOrRWqR/QMl9SuZ9jqijbNCnpJSdbwaX0B7fPPP/e36xvNkyS321oLxuPxNKcMAAAAAA6zMTdgfl6HQwaWTFMqqFqMpW13yZ0QxsqiS7OCXteu1r4WK1asqPP5jz/+2N8eM6b+zRzz861lUdPT05tTBgAAAACH2bi3yN+uNaJXvFcqL7TazM87rGYFvWOPPVamaeqxxx6rNRqXl5end999V5KUmZmpESNG1HuddevWSZJ69OjRnDIAAAAAOEz1QiySNUcvCPPzGq1ZQe+Xv/ylJGnDhg0655xz9P3338vj8WjNmjWaMmWKSktLZRiGLrzwQrlc9b/FkiVLZBiGhgwZ0rzqAQAAADhK9YhenMtQj6zglfuDVtxkD73DataG6ccff7zOO+88LViwQIsWLdKiRYtqnZOWlqbf//739V5j3759euedd/zXAwAAABDbfD5Tm6r20OuemaJEd1zwCYF76HHr5mE1a0RPkp5++mlNnDhRpmnW+khJSdHzzz+vLl261Pv6hx9+WBUVFZKk008/vbllAAAAIMwqfdaSiGb10ohAiPxUWKZST6WkOhZikRjRa4JmjehJUnJyst5++20tWrRI//nPf7R161YlJCRo+PDhmjVrlrp163bY12/btk3nnXeeunTp4l/cBQAAAJHtxS+2Ka/I+mN9frFHi7/bo5MGZtfe6wxoho25h1mIRZLyq1bcdMVLbQ6fN2Jds4NetdNPP71ZI3IPPfRQS98aAAAAYVLurdStb3yrF77Y5j9W6TM166kvdWzvLP3xzCM0pEsbGyuEE2w4XNDz+Wpu3czsJcW1OMo4WrNv3QQAAEBs2FNYpgse/Swo5AVavilfk+5fphteWq1d+0vDXB2cJGhrhUNX3Dy4S/KWWW3m5zWIoAcAAIB6rdhSoDP/tUyrtu2XJCW6XcpIskZS2iS7g1ZFXLhqp068e4nuWvS9DpZ56roccFjBe+gdMkeP+XlNQtADAABALaZp6pnlW3Tho58pr6hcktSlbbIWXHWckhOslRCT4uP0/vXjdfOkQWqbEi9JKvf69OCSjZrw9yV6ZvkWeSp9tn0NiD4bq1bcbJ+WoLYpCcFPBu2hR9BrSLNubJ05c2ZIizAMQ/PmzQvpNQEAANA8ZZ5K/b//rNUrX+3wHxvbN0v3XzhCmanBv3wnuF2aOa6XzhvRVf9eskHzP9miikqf8osr9P9eX6cnP9mimyYO1KmDOrJgCw7rQKlHew9af1ToXedCLGyW3hTNCnrz588P+X+oBD0AAAD77dpfqiuf/UprdhzwH7vihN668WcD5I6r/2awNinx+sMZR2j6MT1013s/6M2vd0mSNuUV64pnvtLoXpn64xlHaFi3tq39JSBKBd+2WUfQYw+9JmnRrZt17aHX3A8AAADYa/nGfE2+f5k/5CXHx+lfFw7XH8444rAhL1C3zBTdf+FwvXb1cRrVs53/+BebC3T2vz/R7BdXace+klapH9EtcGuFvocuxCLVzNGLT5HSc8JUVfRqUdBLTk7WBRdcoLffflter1c+n6/ZHwAAALCHaZqat2yzLp73ufKLrT3yumemaOHVx+msYZ2bdc3h3dvp5V8dq4cvPlo9AxZseX31Lp30j6X667vf6UApC7agRvX8PKmOhVgqvdK+LVY7s7fkYqmRhjSrh2bNmqWMjAyVlpbqpZde0qRJk9SlSxfdcMMNWrVqVahrBAAAQCsprajUdS+t1u1vfatKn3WX1fj+HfTGNWN1RE5Gi65tGIZOH9JJ/71+vG6dPEjtqhZsqfD69MjSTZrw9480/5PNqvDyR380cOvm/q2Sz2u1WYilUZoV9B577DHt2bNHL730ks4880y53W7t2bNH9913n0aOHKnBgwfrb3/7m7Zv3x7qegEAABAi2wtKdN5Dn+r11bv8x359Yh89cemo2isetkCC26VLx/bSkt+dqCvH91GC2/oVdF+JR7e++a1+du/HWrR2N9N5Ylx10Et0u9SlbXLwkwWbatrMz2uUZo95JiQkaOrUqXrjjTe0a9cuf8gzTVPfffed/vCHP6hXr146+eSTNX/+fB08eDCUdQMAAKAF/rd+ryY/sEzf/lQoSUpNiNPDF4/Q7342UHGu1lkds01yvG6aOFAfzhmvc46quSV0c16xrnz2K019eLlWbdvXKu+NyFbh9WlrvjV3s3eHNLkO/R4M2kOPFTcbIyQ3t2ZlZenaa6/V559/ru+//15/+MMf1KNHD/l8Pn300UeaNWuWOnXqpAsvvFDvvPMOc/IAAABsYpqmHl66Ub984gvtL7HmyPVqn6r//HqsTh8SngUuurZL0b0XDNcb14zV6F6Z/uNfbt2ncx/8VNc8v1LbC1iwJZZsKyj23zpc90Is7KHXVCGfxdi/f3/dcccd2rRpk5YuXaqZM2f65/O9/PLLmjx5snr16hXqtwUAAEADisu9uuaFVbrz3e9V9Tu1TjkiW69fM1b9OqaHvZ6hXdvqpSuO0WOXjFTvgMU33lrzk07+x1L939vf6kAJC7bEgg25h1mIRWJErxladbma448/Xo8//rh2796te++9V4mJiTJNU3v37m3NtwUAAMAhtuQVa8qDn+rtNT/5j113Sj89On2kMpLibavLMAydOqij3rvuBN1+9mD/huwVlT499r/NOuHvH2neMhZscbpG76GX2EZKyQpTVdGtWRumN1Zpaan+85//6JlnntEHH3ygysrK1nw7AAAA1OGjH3I1+4VVKiyzVi1MT3Trn784SqcO6mhzZTXi41yafmxPnT28ix5eslHzlm1WudenA6Ue3f7Wt3p6+Rb9/vSBmjikkwyjdeYQwj6HDXqeMml/1SKPWX0k/v0bpVWC3uLFi/Xss89q4cKFKioq8q+g1KVLF02bNk3Tp09vjbcFAABAAJ/P1INLNugf7/+o6gUt+2an6ZHpR9c9ahIBMpLidePpAzXtmB76x3s/aOGqnZKkrfkluvq5lRrRva3+eOYgHd2jXQNXQjSp3izdMBR0G6+kqv3zqr6BmZ/XaCELemvXrtUzzzyj559/Xrt2WUv0mqaptLQ0TZkyRdOnT9dJJ53EX2AAAADC4GCZR3Ne/lr//XaP/9jpgzvp7p8PU1piq97UFRJd2ibrn784SjPH9dL/vf2dlm/KlySt3LZf5z30qc44spN+f/pA9ciqYz4Xooppmv7N0ru2S1ZSfFzwCczPa5YW/Ve+e/duPf/883rmmWe0Zs0aSdY/VFxcnE4++WRNnz5dU6ZMUXJycgNXAgAAQKhs3FukK57+0v/Ls2FIvz1tgK6e0Cfq/ug+pEsbPX/5GH30Q67+8s732lA18vPON7v1/rd7dMmxPXXtSX1Duu8fwiv3YLmKyq3big87P09iD70maFbQe+655/TMM89o8eLF8vl8/lszhw4dqunTp2vatGnq1KlTSAsFAABAw/67brduePlr/y/OGUlu/evC4ZowINvmyprPMAydNLCjTujXQS99uV33vP+j8ooq5Kk0NW/ZZr3y5XZde1I/XXJcDyW64xq+ICJK9W2bUj1BL2hEj6DXWM0KetOnT5dhGDJNU507d/bPuxsyZEio6wMAAEAj+Hym7l28Xv9avN5/bGCndD0y/WjH3N7ojnNp2pgeOvuoLnpk6UY99r9NKvP4VFjm1f+9852e/myLbvzZQE0amhN1I5exrMEVN/M31bQJeo3Wols3k5OT1adPH61YsUIrVqxo9nUMw9DixYtbUgoAAEDMOlDq0Q0vrdbi73P9xyYNzdFd5w9VSkLkz8drqrREt+acNkAXjemuf/z3Ry1YuUOmKW0vKNW1L6zSvGWb9cczj9ConpkNXwy22xA0oneYPfRSO0hJbcJUVfRr0X/5ZWVlWrZsWYsKME2Tv7gAAAA00497DupXz3ylzXnWfDyXId00caAuP76343/HymmTrLunDtOMsT31l3e+0ycbrAVbVm/fr6kPL9fpgzvp9xMHqld7Z4xoOlX1XFLJWhU2SHmRVLTbajM/r0maFfS6d+/u+P9xAAAARLp3vvlJv33la5VUWHsVt0uJ1/0XjtC4fu1triy8Bnduo2dnjdGSH/fqr+98px/3WCNEi9bt1gff7dHFx/TQb07u59+MHZGl+tbNtinxtf+NAhdiYcXNJmlW0NuyZUuIywAAAEBjVfpM3f3fH/TQkppfggflZOiR6UerW2aKjZXZxzAMnTggW8f3ba9Xv9qhf7z/o/YeLJfXZ2r+p1u0YOUOXXNiX/8igogMReVe/XSgTJI1P6/WYFJ+YNDrHcbKop/zbtoGAABwsP0lFbr2hVX63/o8/7Fzh3fRX849UskJrDjpjnPpgtHdNXlYZz368SY9+vEmlXoqdbDMq7+++71cVTmCwBcZNgfctln3/DxG9JrLZXcBkrRgwQK7SwAAAIh43+4q1OQHlvlDXpzL0C2TB+mfPx9GyDtEaqJb15/aX0t+N0G/GNlN1QNFvqp8d6DMowqvz74CIUnasPegv80eeqFlW9AzTVPPPfecBg8erF/84hd2lQEAABAVXl+9U1Me+kTbC0olSVmpCXrusjGaMbYXayccRseMJP3t/KF65zfH64T+HfzHyzw+XfrkFzpQ6rGxOmzMPcxCLFLwHnqZ3LrZFGEPel6vV/PmzVP//v11ySWX6LvvvmPoHAAAoB7eSp/ueOtbzX5xtco81gjUsK5t9Oa143RM7yybq4seR+Rk6OmZo9UmOd5/7NON+Zr68Kfasa/ExspiW8N76FWN6GV0kRJic/5pc7Vojl5xcbEeffRRvf/++9q+fbvcbrd69uypqVOn6he/+IXi4mpuITBNU/Pnz9dtt92m7du3+48lJCTo0ksvbdEXAQAA4ET5ReW69oVV+nRjvv/Y1KO76vZzhigpnls1myM5Pk4HSj0yDMk0pR/3FOncBz/Vk5eO0pAu7NEWbtVBLyHOpa7tkoOfLCmQSgusNhulN1mzg96aNWt0xhln6Keffqp1/I033tBDDz2kd999V2lpaVq/fr0uuugirVy5UpIV8JKSkjRr1iz9/ve/V9euXVv2VQAAADjM2p0H9KtnvtLO/datmvFxhm6ePFgXj2Gbq1DISk1QelK8NucVa+/Bcv38keV64KLhOmlgR7tLixneSp+25FmjqT3bp8gdd8jNhgWbatrMz2uyZt26WVxcrLPPPlu7du2SaZp1fnz66ae65pprtG7dOh177LFauXKlTNNUSkqKbrjhBm3evFn3338/IQ8AAOAQC77aofMe+tQf8jqkJ+qFy4/R9GN6EPJCxO1yacFVx2lkj3aSpJKKSl321Jd65rOtNlcWO7bvK1VFpXU7ct23bQbMz2PFzSZrVtB7+umntXXrVhmGoZNOOkkff/yxioqKVFpaqq+++koXXHCBTNPUCy+8oAsuuEAFBQUyDENXX321Nm3apLvvvlsdO/LXEgAAgECeSp9ufWOd5rzytcqrVoQc0b2t3rp2nEb2zLS5OufJTE3Qs5eN0ZlH5kiyVuT8f/9Zq7++8518PtaQaG0bc2vm59W9EEvg1gqM6DVVs27dfPPNNyVJ/fv316JFi+R211xm+PDhev7557V//34tWrRI69atU0JCghYuXKgzzjgjNFUDAAA4zN6D5fr1cyv1xZYC/7GLxnTXLZMHKdHNfLzWkhQfp/svHK6u7ZL1yMfWrYKPfLxJO/aV6h8/H8ZcyFbU8EIsjOi1RLNG9L755hsZhqEbbrghKOQF+uMf/yhJMgxDM2fOJOQBAADUY9W2fZp8/zJ/yEuIc+nOKUfqL+ceScgLA5fL0NwzjtDt5wzxb6j+9jc/adrjn6uguMLe4hyswaBXvYee4ZLa9ghTVc7RrKCXn2+t/DRgwIB6zzniiCP87bPOOqs5bwMAAOB4JRVe/eKRz7S7sEyS1CkjSS/96hhdMLq7zZXFnunH9NDjvxyplKrN57/auk/nPfSptuQVN/BKNMeGgFs3e3dIDX7SNGtu3WzbQ3InhLEyZ2hW0Csrs/5H1L59+3rPycysuY+8c+fOzXkbAAAAx6reR7iwzOtfkGJ0z0y9ee04De/ezs7SYtpJAzvqpSuOVYf0REnS5rxiTXnoU321dZ/NlTmLaZrauNcK0DltkpSaeMhdgkW5UkVVEGR+XrOEZcP0+m7vBAAAiDWb84p1/+L1yjvklsBLj+up5y4f4w8YsM+RXdvotauPU/+O1u2EBcUVuuixz/TuNz818Eo0Vn5xhQ6UeiTVtxAL8/NaigQGAADQynbsK9Hba37Sm2t2ae3OwlrP/2PqMJ13NFtORZKu7VL0ypXH6apnv9KnG/NV7vXp6udX6o9nHKFZ43qxzUULBa64edj5eRJ76DVTi4Legw8+qOzs7JCcd/PNN7ekFAAAgIiSW1imt7/5SW9+vUsrt+2v97ys1ARCXoRqkxyv+TNG66aFa7Rw5U6ZpnTH299pe0GJbp48WHEuwl5zVd+2KUl9Dp2fJx0yokfQa44WBb2HHnrosM9X/6WjofMkgh4AAIh++UXlenftbr21Zpc+31wgs46t2IZ2baPJQzvr0Y83aW9RueLjwjKTBs2U4HbpH1OHqVu7FN23eL0k6anlW7Vzf5n+deFRSkngBrnm2NDQiB576LVYs78zzbr+z9VMDH0DAIBodaDUo/fW7dabX+/SpxvzVVnHRtsDO6Vr8rDOOvPIHPVsb41ezFu2OdylopkMw9D1p/ZX13bJmrvwG3l9pj74bo8uePQzPf7LkcpOT7K7xKgTtLXC4TZLj0uQ2nQLU1XO0qyg99FHH4W6DgAAgKhRVO7V4u/26M2vd2npj3vlqawd7nq3T9WkYZ01eWiO+nVMt6FKhNrUkd2U0yZZVz37lQ6We7VmxwFNefBTzZ8xSn2z+Tduiuqgl57oVvahCxD5fFKBtXm92vWSXOwl2RzNCnrjx48PdR0AAAARrcxTqQ+/z9Vba3Zp8Xe5Kvf6ap3TpW2yJg/rrMnDcjQoJ4O7lhxoXL/2euWqYzXzyRXadaBMO/aVasqDn+rRS0bqmN5ZdpcXFUorKrVzf6kkqXd2Wu3/Tgp3SJXlVpsVN5uNm4oBAADqUe6t1P9+zNOba3bpg2/3qLiistY5HTMSdeaRVrg7qltbwl0MGNgpQ6/9eqxmPLlC3/5UqMIyr6bP+1x/P3+Yzhnexe7yIt7mvGL//NW6F2IJnJ/XOzxFORBBDwAAIIC30qdPN+brza936b11u1VY5q11TlZqgs44MkeThuZoVM9MuVh9MeZ0zEjSy1ceq2ueX6klP1i371730mrt2FeiX5/Yl8B/GBv2NrQQC3vohQJBDwAAxLxKn6kvNhforTW79O7a3So4ZDNzScpIcmvikBxNHtZZx/TOlJvVMmNeWqJbj18yUje/sU7Pf75NknT3f3/U9oJS3XHuEFZUrUfDe+htqmmzh16zEfQAAEBMMk1TK7ft15tf79I73/yk3IPltc5JTYjTaYM7afKwHI3r20EJbn5xRzB3nEv/d84Qdc9M0Z3vfi9JeunL7dp1oFQPThuh9KR4myuMPIErbvatc8VNRvRCgaAHAABihmmaWrerUG9+vUtvrfnJvyBEoKR4l04e2FGTh+VowoBsJcWz4h8OzzAMXTm+j7q0Tdacl79WRaVP/1ufp6kPL9eTM0Ypp02y3SVGlOrN0t0uQz2yUmqfUD1HLz5VSu8UxsqchaAHAAAc74fdB/XWml168+td2pJfUuv5hDiXxg/ooElDc3TKER2VmsivSGi6ycM6q1ObJF3+9JfaX+LR97sP6tx/f6onLh2lQZ0z7C4vIpimqU1VI3rds1Jq395a6ZH2bbHaWb0l5jo2G/8XAwAAjrRpb5HeWvOT3lqzSz/uKar1fJzL0Li+7TVpaI5OG9xJbZK5xQ4tN6pnphZcdZxmPLlC2wpKtLuwTD9/ZLn+PW2ExvfvYHd5tqs0Tf/WJHXOz9u/TTKrVrdlfl6LEPQAAIBj7NhX4g93a3cW1nreMKRjemVp8rDOOn1IJ2WmJthQJZyuT4c0Lbz6OF321JdavX2/isq9mjl/hf5y7hD9YlR3u8uzVWWl6W+z4mbrIugBAICoV1Lu1bkPfqJV2/bX+fzRPdpp8tAcnXFkjrIzksJbHGJS+7REvXD5MbrupVV6b90eVfpM/X7BN9peUKo5p/WP2e0XvL6aoFf3QiyBe+gxotcSBD002h1vfav9JdZy0/tLKvSbF1bZXFHTHCjx+D9HU+30uT3od3vQ7/YI7PdfP7dSPtOUacr6LGtOTeBjn3nIsQbOlWnKd8i5Ul2vtV4feK7pv071uZJk+mvYX9XvB8sra4W8oV3baNLQHJ05tLO6tGUxDIRfckKcHpx2tP7v7e/0xCebJUkPfLRB2/eV6K7zhyrRHXsL/QQGvbo3S2dEL1QIemi0D3/IVVnVPdVlXp/e+HqXzRU1T7TWHq11S9RuF2q3R7TX/vY3P9ldRosM7JSuSUNzNGloZ/VsX8cvkUCYxbkM3Tx5kLplJuvPb30r05ReX71Luw+U6dHpI9UmJbbmhnp9Pn+7d5176AWM6DFHr0UIegAAoFW5DGv5eZchGTJkGNZcOZdhyGUYMqSqY0bQuVL1YwWcZwS8Vtq+r1SVPlOpCXH6z6/Hql/HdHu/WKAeM8b2Uue2yZr94iqVeXz6fHOBpjz0iebPGK1umXVsMeBQlVUjeh3SE+teAKn61s2ktlJKZvgKcyCCHhrtucvGaPL9y5RXVKH2aQl67eqxdpfUJOc++ElU1h6tdUvUbhdqt4cTau+QlqjXrxlbb7AyZH2WERzeXFVzjVyHnFsd3lrTmL98oD2F5UpLchPyEPF+NriTXrziWF321ArlFVVo495infvgJ5r3y1Ea1q2t3eWFRfWdm3XetukplQ7ssNpZfdhaoYUIemi0nDbJcrusvU7cLlfU/fUpzvrzsOJcRlTVTp/bg363B/1uj+p+j3MZ6sxcNqBVHdWtrRZeNVaXzv9Cm/YWK6+oQhc8+pn+deFwnTqoo93lhU2dC7EUbJZUlQSZn9diroZPAQAAABAq3bNStPCq4zS6l3VrYqmnUr965ks99ekWewsLozq3VmB+XkgR9AAAAIAwa5uSoGdmjdbZR3WWZN3SeMsb63THW9/KF7AypVM1vIceQa+lCHoAAACADRLdcbrn50fp1yfWhJrHl23W1c+tVJmn0sbKQsM0Ta1cuVKPPPKItrz1gCpyN/ufK92zRaZ5SKBlD72QIugBAAAANnG5DP3uZwP11ylH+uf6Llq3Wxc+9pnyi8ptrq55PB6PHnzwQQ0YMEBHH320rrrqKuV+/paM+ERJkq+iTKefMEYDBgzQgw8+KI/H2g8zKOhx62aLEfQAAAAAm104urvm/XKkUhOsTdRXbduvKQ99qk17i2yurGnWrl2rUaNG6ZprrtGGDdatmKZpyjQkdxtrsRlPwQ5JpjZs2KBrrrlGo0aN0tq1a2vm6KVmS0kZNn0FzkHQAwAAACLAhAHZevnKY9Uxwxr52ppfoikPfaovtxTYXFnjLF26VKNHj9batWutcBdwa2Z8u84yXFaI9eZbWyhUn7N27VqdPG60VLTHOpkVN0OCoAcAAABEiMGd2+i1q8dqYCdrX8j9JR5d9PjnemvNLpsrO7y1a9dq4sSJKi8vV2Vl7fmF8Zld/W1rRK9GZWWluqV6ag5k9W61OmMJQQ8AAACIIJ3bJuvlK4/V8f3aS5IqvD5d8/wqFZd7ba6sbh6PRxdffLEqKirk8/nqPCc+q1vN+fnbaz3ft11Nu7ItQS8UCHoAAABAhMlIitcTl47S1KNrRsKKyq2RstKKSv133W59ujFPa3ce0Ja8YuUXlavCW3fIam2PPfaY1qxZU+dIXjV3VsCIXv6OWs/3y6qJJe9/tbHW82g6t90FAAAAAKgtPs6lu84fqu6ZKfrH+z/6jxeWeXXFM1/V+ZoEt0sZSW6lJ8UrLdGt9CTrIy0xXulJbmUkuZVW9bx13GoHHk9NiJNhGI2q0TRN3XvvvQ1/LVW3bpq+Snn21b4NtX9mTdB74MVF+tn1ZqNrQN0IegAAAECEMgxD157cT10zk3X9S183eH6F16e8ogrlFVU0+z1dhpSa6FZGUBisCo9VwTGjKkjm796hHWamEroOka+8WGZFiXzlJfKVF0u+mhG++KoRPe+BPVKlp9Z7Bo7oLV61WatXr9bw4cOb/TWAoAcAAABEvHOHd9X/vf2d8ooqlJ7k1pXj++hgmVcHyzwqKvf629bnmuM+s+FrH8pnyn+dxsg+7//VfR1PuczyEvkqSuVKSJZU922bktQ/y1qRc+t+n8orDa1YsYKg10IEPQAAACAKVG+onpIQp1+f2PAWBKZpqqSiUgfLvCoq96iwzKuiQ4JgYXW7+nh5Tbuw6nVlnubN/XPFJ0rxiYpTzUordS3EkplsKDPZ+trWF/jkdru1bt26Zr0nahD0AAAAAAcyDEOpiW6lJrolJTX7OhVen4rKrZBYWDVqaI0ievToE0/r81XfSPFJciWmyJWYIiMxVa6ElKrHqTISU+RKSFblwTwVff1erev3D7ht88d8nxVQS0qaXS8sBD0AAAAA9Upwu5TpTlBmakKt55bM360PVyyQx1N73l1j9QtYiGV9gU+GYSglJaXZ14OFoAcAAACgWQYPHiyvt2X7+x06ouf1Vmrw4MEtLS3msY8eAAAAgGYZNWqUTLMZK74ECBrRq7p1c9SoUS0tLeYR9AAAAAA0y/Dhw9WvX78W7XlXvbWC12dqywFT/fv311FHHRWiCmMXQQ8AAABAsxiGoeuuu65F16i+dXPzPp+8Pmn27Nlslh4CBD0AAAAAzXb55Zdr6NChiouLa/JrO6UZSkuo2lphnzR06FBdccUVoS4xJhH0AAAAADRbfHy8nn32WSUkJMjlalq8CFyIZdN+6dlnn5XbzXqRoUDQAwAAANAiQ4YM0bvvvqvExMQmBbXAhVh+dtGvNWTIkNYoLyYR9AAAAAC02Pjx4/XFF19o8ODBMgyjwXl2hmFoQPua2z37jflZa5cYUwh6AAAAAEJiyJAhWrFihR544AH17dtXkhXoDJdbcsXJcLn9AbBfv346b8JRNS/O6mtDxc5F0AMAAAAQMvHx8br66qv1ww8/aOXKlXr44YeVPWay0oacrOwxk/Xwww9r5cqV+v7779W7jc96UVyilNHV3sIdhpmOAAAAAELOMAwNHz5cw4cP1xN5fbS7sEydMpJ0xRUnWyf4KqWCzVY7s7fUxIVccHj0JgAAAIDwO7BDqiy32ll97K3FgQh6AAAAAMKvYGNNm6AXcgQ9AAAAAOGXHxD0Mgl6oUbQAwAAABB+gUGPFTdDjqAHAAAAIPzyN9S0uXUz5Ah6AAAAAMKveo5eQpqU1tHeWhyIoAcAAAAgvCo90r6tVjuzt1S1iTpCh6AHAAAAILz2bZXMSqvN/LxWQdADAAAAEF7Mz2t1BD0AAAAA4VXAiputjaAHAAAAILwCR/TYQ69VuO0uAAAAAJEht7BMuQfLGzzPU+nzf16780CD52enJyo7I6nF9cFBgvbQI+i1BoIeAAAAJEnPfb5N9y1e3+jzC4o9mnT/sgbPm31yP11/av+WlAanqQ56ye2klEx7a3Eogh4AAAAkSdPGdNepgxrez8zr9WrZsmUaN26c3O6Gf53MTk8MRXlwCk+pVLjDanPbZqsh6AEAAECSlJ2R1KhbLD0ej7amSYM7Zyg+Pj4MlcFRCjbVtFmIpdWwGAsAAACA8GF+XlgQ9AAAAACED3vohQVBDwAAAED4BO6hxxy9VkPQAwAAABA+3LoZFgQ9AAAAAOFTHfTSOkqJ6fbW4mAEPQAAAABhkWKWSMW51gNW3GxVBD0AAAAAYdHN/KnmQWZv+wqJAQQ9AAAAAGHR3dxV84ARvVZF0AMAAAAQFt0UMKLHQiytiqAHAAAAICwY0Qsfgh4AAACAsKiZo2dI7XrZWovTue0uAAAAAECUOrjb+mjAAN9GZRnl6mnusA6kdZT2fl//C9I7WR9oNoIeAAAAYKdGh6VNam9UKMuXIO1a3fB1wxGWvnxSWnpng6c9JUmJAQeKdkuPjq//BeNvkk6c29LqYhpBDwAAALBTI8PS05IVlrySHm3EdcMRlkbOkAZMbPC0gkcnK1OFNQcGnSONu77+FzCa12IEPQAAAMBOTQxLBcpQ5hVvNnzdcISlRo4aeg+NHd3GSJ2Pap2aIImgBwAAANiriWHJK3f0hyRW3Gx1rLoJAAAAILzYQ6/VEfQAAAAAhI/LLbXtbncVjkfQAwAAANDKzJpm2x5SXLx9pcQIgh4AAACAVuUKDHrMzwsLgh4AAACAVhWnypoHzM8LC4JeK9qxY4euvfZajRkzRklJSTIMw+6SAAAAgLAj6IUfQa8VbdiwQa+88oqys7M1ZswYu8sBAAAAbBEnX82DTIJeOBD0WtEJJ5yg3bt3680339TEiQ1vggkAAAA4kTtoRI85euFA0GtFLhfdCwAAAFTfumlKUkYXW2uJFVGdRDZv3qzHHntMl19+uYYNGya32y3DMHTHHXc06vXvvPOOTjnlFGVmZio1NVUjRozQ/fffL5/P1/CLAQAAADTMV+m/dbNScRKDIWHhtruAlrjvvvt03333Neu1d955p+bOnStJ6t27t9LS0vT111/rN7/5jT744AO99tprjMgBAADAeSq9UmW55C2XKiusD29F8LGgz+UBz9dzXq3XBHyuKFb1koReuaI7gESRqO7n9u3ba9KkSRo9erRGjRqlxx9/XAsWLGjwdcuXL9cf/vAHuVwuPfvss7rwwgslSV9//bV+9rOf6Y033tA///lP/fa3v/W/5uDBg9q5c2eD187JyVGbNm2a/0UBAAAAdUhQhSQpTcXS69dIlZ7Dh6/6wppp391rlYqz7b1jTVQHvT/96U9Bj1988cVGve6OO+6QaZq6/PLL/SFPkoYNG6Z//vOfmjZtmu68807Nnj1b8fHxkqS333476Nz6PPnkk7r00ksb/0UAAAAAh+PzSR/crLYqkiSlqFxa9YzNRTWNKcmQVKpEpdpdTIyI6qDXHIWFhfrggw8kSbNmzar1/NSpU3XVVVcpPz9fH330kU477TRJ0gUXXKALLrggrLUCAAAgxlV6pNd/La15qfGvMeIkd6IUl1D1OVFyJwR8TjjMc4mHvLaOz8147d4/91W2CuRjRC9sYi7orVq1ShUVFUpKStKIESNqPR8fH69Ro0Zp8eLF+vzzz/1BDwAAAAir8iLp5UukjYsl1YyKFShDmVe9VxWk6ghaLsIUYjDorV+/XpLUvXt3ud11f/m9e/fW4sWL/ee2xKuvvipJWrt2bdDjQYMGadCgQbXOLy8vV3l5uQ4ePFjrOY/HI4/H0+KaWsK0FsWVKdP2WprMrPkcTbXT5/ag3+1Bv9uDfrdHNPd7db3RVrcURf1evFdxL10o10+rJUlmXKIOVMarrYrklVuezH51v67SZ31EsIju9zpEwvd7c9475oLevn37JEnt2rWr95zq56rPbYmpU6fW+fiWW27RrbfeWuv8v/71r7rtttvqvNYHH3xg+0IvZWVxkgyVlZXpnXfesbWWpiorr6q9PLpqp8/tQb/bg363B/1uj2ju92rvv/++3SU0WTT0e0p5ro7d+Helle+RJFXEpejz3ter/48PSoZkmmbE1l6fY0wzamuvZuf3+4EDB5r8mpgLemVlZZKkhISEes9JTEyUJJWWlrb4/UzTbPikAHPnztUNN9ygvLw89enTJ+i5U045RR06dGhxTS3xl3VLdaCiXElJSTrjjPG21tJUf1lbVXtidNVOn9uDfrcH/W4P+t0e0dzvHo9H77//vk499VT/wnW2O7hbKtrT4GkLvlmpfE+FshISdMbw2tN4aknrKKV3CkGBjbR7jdwv/lZGea4kyUzPkXHByzom+wjt+7+HJEmGYeiMM84IX00hsG/VdZKis/ZI+H7fu3dvk18Tc0EvKSlJklRRUVHvOeXl5ZKk5OTksNQUKDExUYmJif4aAsXHx9v+P1OjahcUQ4bttTSZUfM5mmqnz+1Bv9uDfrcH/W6PqO73KpHwu4nf189KS+9s8LSnJSlRklfSE4247vibpBPntqy2xtq0RHrxYqmiagpP+wEyLl6g+Lbdap0aMf3eDNFau53f781535gLeo25LbMxt3cCAAAggoycIQ2Y2OBpBY9OVqYKrQVNrniz4euGazTvm1el166UfFVzsbqNkS58UUrJDM/7w3FiLuj162dNXN22bZu8Xm+dC7Js2rQp6FwAAABEtlyzrXLNhu/G6lD1669Hbq01ezV4fraZqOwWV9eA5Q9K7wWMGg44Qzr/CSk+/HeXwTliLugNHz5c8fHxKisr08qVKzV69Oig5z0ej1asWCFJGjNmjB0lAgAAoIme+3yb7lvc8IrpyxMlGZLPlCbdv6zB82ef3E/Xn9o/BBXWwTSlD26RPrmv5tiIS6Qz75HiYu7XdIRYzH0HZWRk6JRTTtG7776refPm1Qp6r7zyigoLC5WVlaUJEybYUyQAAACaZNqY7jp1UMcGz2v/fIJULLVPS9BbV4xr8Pzs9MRQlFdbpUd641rp6xdqjp1wo3TiHyTDqP91QCPFXNCTpD/+8Y9atGiRHn/8cU2YMEEXXnihJOnrr7/WDTfcIEm68cYbD7syJwAAACJHdkaSsjOSGj7R5ZIkxbtcGtLFpm2ryoukV34pbfig6oAhnXm3NOoye+qBI7nsLqAlPvnkE7Vv397/8eKLL0qy9qILPL59+/ag140dO1a33367fD6fLrroIvXp00fDhg3TiBEjtGfPHp155pmaM2eOHV8SAAAAnKw4T3pqck3Ii0uUfv40IQ8hF9Ujeh6PR/n5+bWOl5SUqKSkxP+4srKy1jl//OMfNWzYMN1zzz366quvtHv3bh155JGaMWOGrrnmGsXFxbVq7QAAAIgx+7ZIz0yRCjZajxPbSBe+IPUca2tZcKaoDnoTJkxo8obkgSZNmqRJkyaFsCIAAACgDj+tkZ47v2ZT9/Qc6eIFUsfB9tbVUgd3Wx8NcMtb83nX6oavm94pvBvVO1BUBz0AAAAg4m1aKr04LWAj9P7SxQulOjZCjzpfPtmojeoz/Z8LpUfHN3zdcG5U71AEPQAAAKC1rF0gLfxVzUboXUdLF70UvBF6NI+KNXKj+l8+8YXyiivUPjVBT80c3eD5jOa1HEEPAAAAaA2fPSwtuklS1VSj/qdL5z8pJaQEnxfNo2KNDJM/uPK12yxTJ1eS1Pmo1q0Jkgh6AAAAQGiZprT4NmnZPTXHhl8sTbqv7o3QGzkqdskTXyi/uEJZqQl6mlExNICgBwAAAIRKpUd64zfS18/XHDvhd9KJf6x/I/RGj4rlaY9Zro6uREbF0CCCHgAAABAKFcXSy7+UNrxfdcCQzvi7NPpyW8tCbCLoAQAAAC1VnC89P1Xa+ZX1OC5BOu9xadDZ9taFmEXQAwAAAFpi31bp2SlS/gbrcWJG1Ubo4+ytCzGNoAcAAAA01+5vpGfPC94IfdqrUqch9taFmEfQAwAAAJpj88fWRujlhdbjrH7S9IVS2+721gWIoAcAAAA03brXpIVXSJUV1uOuo6SLXg7eCB2wEUEPAAAAaIrPH5XevVH+jdD7/Uya+qSUkGprWUAggh4AAADQGKYpfXi79L9/1Bw76mJp8r1SXLxtZQF1IegBAAAADan0SG/OllY/V3Ps+N9KJ/2p/o3QARsR9AAAAIDDqSiWXrlUWv/fqgOGNPEuacwVdlYFHBZBDwAAAKhPcb70/M+lnV9aj+MSpCmPSoPPtbcuoAEEPQAAAKAu+7Zae+Tlr7ceJ2ZIFzwn9TrB3rqARiDoAQAAAIfavbZqI/Td1uO0TtLFr0qdjrS3LqCRCHoAAABAoM3/k168KGAj9L7SxQuldj3srQtoAoIeAAAAUG3df6SFl9dshN7laOmiV6TULFvLApqKoAcAAABI0hePSe/8Tv6N0PueKv38KTZCR1Qi6AEAACC2mab04R3S/+6uOXbUNGnyfWyEjqhF0ItQ8+bNs7sEAAAA56v0Sm/NllY9W3Ns3A3SyTezETqimsvuAlC3WbNm2V0CAACAs1WUSC9NCwh5VRuhn3ILIQ9RjxE9AAAAxB7TJz19lrRjhfU4LkE69xFpyBR76wJChKAHAACA2FOSV7NHXkK6tRF67/H21gSEEEEPAAAAsaPSY332ea3PaR2laa9KOUPtqwloBQQ9AAAAxIaiXGskr1pmH2n6QqldT9tKAloLQQ8AAACx4dN/yb9HnitemvVfKbW9rSUBrYVVNwEAAOB8RXulFQHbVyVnEvLgaAQ9AAAAON/yByRPSc1jV5x9tQBhQNADAACAsxXnS188ZncVQFgR9AAAAOBsnz0oeYqtdnyKvbUAYULQAwAAgHOVFEifP2K1XfFSQpq99QBhQtADAACAc33+sFRx0GoPnya5WHQesYGgBwAAAGcq3S999rDVdrmlcTfYWg4QTgQ9AAAAONMXj0rlB6z2sAuldj3srQcII8auAQAA4DxlhdLyf1ttI046PnJH83ILy5R7sLzB8zyVPv/ntTsPNHh+dnqisjOSWlwfohNBDwAAAM7zxaNS2X6rPfQXUmZvW8s5nOc+36b7Fq9v9PkFxR5Nun9Zg+fNPrmfrj+1f0tKQxQj6AEAAMBZyg9aG6RLkuGSTvitvfU0YNqY7jp1UMcGz/N6vVq2bJnGjRsnt7vhX+Oz0xNDUR6iFEEPAAAAzrJinlS6z2ofOVXK6mNvPQ3Izkhq1C2WHo9HW9OkwZ0zFB8fH4bKEM0IegAAACHEfCubVRRLn95f9cCQjo/s0bxox/d75CLoAQAAhFBT51vlF1cw3yqUvnxCKsmz2kOmSB3os9bE93vkIugBAACEUGPnWzUV860aoaJE+uRfVQ8M6YTf2VpOLOD7PXIR9AAAAEKosfOt0ApWPiUV51rtQWdL2UfYW08M4Ps9crFhOgAAAKKfp0xadm/NY0bzEOMIegAAAIh+K5+WinZb7YGTpE5D7K0HsBlBDwAAANHNWy4tu6fm8fjf21cLECEIegAAAIhuq56VDu6y2gPOkHKG2lsPEAEIegAAAIhe3org0Tzm5gGSCHoAAACIZl8/Lx3YbrX7nSZ1GWFvPUCEIOgBAAAgOlV6pP/9o+Yxc/MAP4IeAAAAotOal6T926x2n5OlriPtrQeIIAQ9AAAARJ9Kr/Tx3TWPGc0DghD0AAAAEH2+eUXat9lq9xovdR9jbz1AhCHoAQAAILr4KqWP/17zeMJN9tUCRCiCHgAAAKLL2oVSwUar3fN4qcdx9tYDRCCCHgAAAKKHr1L6+K6ax+NvtK8WIIIR9AAAABA9vv2PlPej1e5+rDWiB6AWgh4AAACig88nLQ2Ymzf+95Jh2FcPEMEIehFq3rx5dpcAAAAQWb5/U9r7ndXuOlrqPcHWcoBIRtCLULNmzbK7BAAAgMjh80lLA+fmMZoHHA5BDwAAAJHvh3ekPWutducRUt+T7a0HiHAEPQAAAEQ205SW/q3m8YSbGM0DGkDQAwAAQGT78T1p9xqrnTNM6neavfUAUYCgBwAAgMhlmtLSO2seMzcPaBS33QUgMuQWlin3YHmD53kqff7Pa3ceaPD87PREZWcktbi+w4nW2qO1bona60Lth0fttVH74UVz7VHt4G7royFer9qUbJF++lpyN+LXyfRO1kdzbPhA2rXKanc8UhpwRvOuA8QYwzRN0+4iUNvevXuVnZ0ddCw3N1cdOnRolfe75/0fdd/i9SG/7uyT++n6U/uH/LqBorX2aK1bova6UPvhUXtt1H540Vx7VPvor8GjZ6Ey/ibpxLlNf51pSo+fIu380nr882ekQWe1rJZ/HCEd3CWld5bmfNeya4WZx+PRO++8ozPOOEPx8fF2lxMzIqHfm5MNGNGDJGnamO46dVDHkF83Oz0x5Nc8VGNr93q9WrZsmcaNGyd3I/762Nq10+e1RVLtTRVJtdPvoUW/1xZJtUdiv0e1kTOkARMbPM189jwZJXkyU9rLuHhBw9dt7mjepo9qQl72IGngpOZdB4hBBD1IkrIzkqL2VpbG1u7xeLQ1TRrcOSMi/gpGn9uDfrcH/W4P+h1N1thbLOPiaz53Pqp1ajFNaUnASpsn/E5ysbwE0FgEPQAAAESezR9L2z+z2u0HSIPOPvz5jZ1fWFlR83nX6obPb8n8QsBGBD0AAABEnqV31bTH3yi54g5//pdPNm1+YUme9Oj4hs9r7vxCwGYEPQAAAESWLcukrcusdlZfafC5Db+mkfMLm4zRPEQpgh4AAAAiy9JD5+Y1MJoncYslcAhmtAIAACBybF1uzc+TpMze0pDz7a0HiFIEPQAAAESOjwPm5h3/WymOG9CA5iDoAQAAIDJsXyFt/NBqt+0hDf25vfUAUYygBwAAgMgQODfv+Dk1+/UBaDKCHgAAAOy38ytpw/tWu003adiF9tYDRDmCHgAAAOy39O817eNvkNwJ9tUCOABBDwAAAPb66Wvpx3etdkYX6ahp9tYDOABBDwAAAPZaGrDS5rjrJXeifbUADkHQAwAAgH12fyN9/5bVTs+Rhk+3tx7AIQh6AAAAsM/HAXPzxl4nxSfZVgrgJAQ9AAAA2GPPt9K3r1vt1Gzp6F/aWw/gIAQ9AAAA2CNoNG+2FJ9sXy2AwxD0AAAAEH57f5DWvWa1U9pLI2fYWw/gMAQ9AAAAhN/Hd0syrfbY30gJqbaWAzgNQQ8AAADhlbdBWvuq1U7OlEbOsrcewIEIegAAAAiv/90tmT6rfdw1UmKavfUADkTQAwAAQPjkb5TWvGy1k9pKoy63tRzAqQh6AAAACJ9l/5TMSqt97DVSUoa99QAORdADAABAeOzbIn39otVObCONucLWcgAnI+gBAAAgPP73T8nntdrHXCUltbG3HsDBCHoAAABoffu3Sauft9qJGdIxV9pbD+BwBD0AAAC0vmX3Sj6P1R7zKym5na3lAE5H0AMAAEDrOrBTWvWM1U5Ik4652t56gBhA0AMAAEDr+uReqbLCao++XErJtLUcIBYQ9AAAANB6Cn+SvnrKasenWFsqAGh1BD0AAAC0nk//JVWWW+1Rl0mp7e2tB4gRBD0AAAC0joN7pC+fsNruZOm4a+2tB4ghBD0AAAC0jk//JXnLrPbImVJatr31ADGEoBeh5s2bZ3cJAAAAzVe0N2A0L0ka+xt76wFiDEEvQs2aNcvuEgAAAJpv+QOSp8RqH32plN7J1nKAWEPQAwAAQGgV50tfPGa14xKksbPtrQeIQQQ9AAAAhNZn/5Y8xVZ7xCVSRmd76wFiEEEPAAAAoVNSIH3+qNV2xUtjr7O1HCBWEfQAAAAQOp8/LFUctNrDL5badrO3HiBGEfQAAAAQGqX7pc8ettoutzTuelvLAWIZQQ8AAACh8fkjUvkBqz3sQqldD3vrAWIYQQ8AAAAtV1ZoLcIiSUacdPwce+sBYhxBDwAAAC33xaNSWfVo3gVSZi976wFiHEEPAAAALVN+0NogXZIMF6N5QAQg6AEAAKBlVjwule6z2kdOlbL62FsPAIIeAAAAWqCiWPr0/qoHhnT8b20tB4CFoAcAAIDm+/IJqSTfag85T+rQ3956AEgi6AEAAKC5TFP65F9VDwzpBEbzgEjhtrsAAAAARClPiVReaLUHnS1lH2FvPQD8GNEDAABA81QU1bTH32hfHQBqIegBAACgWQzTZzWOmCx1HGxvMQCCEPQAAADQNKYZ/PgERvOASEPQAwAAQNN4SmraA86QcobaVwuAOhH0AAAA0HgVJczNA6IAQQ8AAACN995c/9w8My5R6jzc5oIA1IWgBwAAgMZZu1D6an7N48R020oBcHgEPQAAADSsYLP05uzgY3Hx9tQCoEEEPQAAAByet0J6daZ/c3TTnWRzQQAaQtADAADA4S2+Tdq10mpn9paS2thbD4AGEfQAAABQvx/fk5Y/YLVd8dL5T0gGv0ICkY7/SgEAAFC3wl3Sf66qeXza7ayyCUQJgh4AAABq81VKC6+QSvKtx/0nSmOutLcmAI1G0AMAAEBtH98tbfmf1c7oIp3zoGQY9tYEoNEIegAAAAi2ZZm09E6rbbik8x6XUjLtrQlAkxD0AAAAUKM4X1pwmWT6rMcT/iD1OM7emgA0GUEPAAAAFtO0Fl85+JP1uNcJ0vE32FsTgGYh6AEAAMDy2YPS+vesdkp76dxHJVecvTUBaBaCHgAAAKSdK6X3b6l5fO4jUkaOffUAaBGCHgAAQKwrK5RenSn5PNbj434j9TvF3poAtAhBDwAAIJaZpvTWddK+zdbjLiOlk2+2tSQALUfQAwAAiGWrnpHWLrDaiW2k8+dJcfH21gSgxQh6AAAAsSr3O+mdG2sen/UvqV1P28oBEDoEPQAAgFhUUSK9MkPyllqPR86UBp9ja0kAQoegBwAAEIvemyvt/c5qZw+WfvYXe+sBEFIEPQAAgFizdqH01XyrHZ8iTX1Sik+2tSQAoUXQAwAAiCUFm6U3Z9c8nniX1GGAffUAaBUEPQAAgFjhrbD2yysvtB4fOVUafrG9NQFoFQQ9AACAWLH4NmnXSqud2VuadI9kGPbWBKBVEPQAAABiwY//lZY/YLVd8dL5T0iJ6fbWBKDVEPQAAACcrnCX9J8rax6fdrvUebh99QBodQQ9AAAAJ/NVSguvkEryrcf9J0pjrjz8awBEPYIeAACAk318t7Tlf1Y7o4t0zoPMywNiAEEvQs2bN8/uEgAAQLTbskxaeqfVNlzSeY9LKZn21gQgLAh6EWrWrFl2lwAAAKJZcb604HLJ9FmPJ8yVehxnb00AwoagBwAA4DSmKb1+tXRwl/W41wnS8XPsrQlAWBH0AAAAnOazB6UfF1ntlPbSuY9Krjh7awIQVgQ9AAAAJ9m5Unr/lprH5z4iZeTYVw8AWxD0AAAAnKKsUHp1puTzWI+P+43U7xR7awJgC4IeAACAE5im9NZ10r7N1uMuI6WTb7a1JAD2IegBAAA4wapnpLULrHZiG+n8eVJcvL01AbANQQ8AACDa5X4nvXNjzeOz7pPa9bStHAD2I+gBAABEM0+p9MoMyVtqPT56hjT4XHtrAmA7gh4AAEA0W3STtPc7q509WDr9r/bWAyAiEPQAAACi1dqF0lfzrXZ8ijT1SSk+2daSAEQGgh4AAEA0KtgsvTm75vHEu6QOA+yrB0BEIegBAABEG2+FtV9eeaH1+Mip0vCL7a0JQEQh6AEAAESbD/8s7VpptTN7S5PukQzD3poARBSCHgAAQDRZ/7706f1W2xUvnf+ElJhub00AIg5BDwAAIFoU7pJe+1XN49NulzoPt68eABHLbXcBAAAAjnJwt/URaqkdrJBXkm897j9RGnNl6N8HgCMQ9AAAAELpyyelpXeG/ro9xklbl1ntjC7SOQ8yLw9AvQh6AAAAoTRyhjRgYsPnPXueVJInpbSXLl5w+HN/+lp66zqrbbik8x6XUjJbXCoA5yLoAQAAhFJ6J+ujIXEJNZ87H1X/ecX50gsXSqbPejxhrtTjuBaXCcDZCHqwtNZ8gsb+sGuJxtbu9apNyRbrr6LuRnzrt3bt9HltkVR7U0VS7fR7aNHvtUVS7ZHY76FkmtLrV0sHd1mPe50gHT/H3poARAWCHiytNZ9g/E3SiXNDf91Ajaw9XtIESfqhkddt7drp89oiqPYmi6Da6fcQo99ri6DaI7LfQ+mzh6QfF1ntlPbSuY9Krjh7awIQFQh6sLTGfAIpPH81bWTt5rPnySjJk5nSXkYk1E6f1xZBtdPvIUa/1xZBtdPvEWrnSun9m2sen/uIlJFjXz0AogpBD5ZQzycIp0bXHl/zORJqp8/tQb/bg363B/0evcoKpVdnSj6P9fi430j9TrG3JgBRhQ3TAQAAIolpSm9dL+3bbD3ucrR00v+ztyYAUYegBwAAEElWPSOtfdVqJ7aRzn9CcifYWxOAqEPQAwAAiBS530vv3Fjz+Kz7pHY9bSsHQPQi6AEAAEQCT6n06gzJW2o9PnqGNPhce2sCELUIegAAAJFg0U1S7rdWO3uwdPpf7a0HQFQj6AEAANht7ULpq/lWOz5FmvqkFJ9sa0kAohtBDwAAwE4+r/Tm7JrHE++SOgywrx4AjsA+egAAAHYq3VezX96RU6XhF9tbDwBHYEQPAADATtUhr10v6cx/SoZhbz0AHIERPQAAgHDyVkgleZKnpOaYK96al5eUYV9dAByFoAcAANASpilVFEnFe6Wivdbn4lypOE8qyj2kvVcq21/7GqfdLnUeHvbSATgXQQ8AAOBQPp9UWlAV3qoCWvVHUVVwK86tCXbVe981R1yiNObK0NUOACLoAQCAWOEtrx3QDh1t83/kSWZlaN8/IV1KbS+lZUupHaSNH1q3bya3Y14egJAj6KHxDu6RfFU/9HyV0oGd9tbTVNFae7TWLVG7XajdHo6pfYe9tTRVde3eCum7N4MDW+DIW/FeqexAiN/ckFIypdTsgACXHRzmqh+ndpASUoJf/o8jrKBnsDYegNAj6KHx5p8pFe+x2sV7pHsG2VtPE1X/rdQozo262iXR53ah3+1Bv9ujeI90z2C7q2gSf7+X5ksvhWBbgriEqoBW9ZFWHdSyg9upHaSULCmOX6UARCb+7wQAAJwtIV1K61DHaFtgmKt6LqkNt1ECcASCHhqv78nSge2St0xyJ0n9f2Z3RU1i/vieDG+ZTHeSjGiq/cf36HM70O/2oN/tEdTvp9tdTZOYPy6y+j0+VcYJc2pG29ICglx8st1lRo+Du62PhlR6aj7vWt3w+emdrA8AYUPQQ+NN/Jv07RvSwV1Scqb086ftrqhp/jFQOviTNek9mmr/xxH0uR3od3vQ7/YI6ven7K6maar7PSlDOn6O3dVEvy+flJbe2eBp/ltmS/KkR8c3fN3xN0knzm1ZbQCahKAHAAAAy8gZ0oCJDZ7m8Xr1ySefaOzYsYp3N+LXSUbzgLAj6AEAAMDS2FssPR4dSNkp5QyT4uNbvy4ATcZ6vgAAAADgMAQ9AAAAAHAYgh4AAAAAOAxBDwAAAAAchqAHAAAAAA5D0AMAAAAAhyHoAQAAAIDDEPQAAAAAwGEIegAAAADgMG67CwAAAHCUg7utj4ZUVtR83rW64fPTO1kfANAIBD0AAIBQ+vJJaemdjT+/JE96dHzD542/STpxbvPrAhBTCHoAAAChNHKGNGBi6K/LaB6AJiDoAQAAhBK3WAKIACzGEqHmzZtndwkAAAAAohQjehFq1qxZmjs3jPfhR/PE8UbX7qn5HAm10+e1RVTt9HtI0e+1RVTt9DsAOA1BD5ZonjjeyNqN6s+RUjt9XlsE1e4XhbXT7yFGv9cWQbVHZL8DQAQg6MESzRPHG1m7x+vVJ598orFjxyre3Yhv/daunT6vLYJqb7IIqp1+DzH6vbYIqj0i+x0AIgBBD5ZovpWlsbV7PDqQslPKGSbFx7d+XQ2hz+1Bv9uDfrcH/Q4AMYvFWAAAAADAYQh6AAAAAOAwBD0AAAAAcBiCHgAAAAA4DEEPAAAAAByGoAcAAAAADkPQAwAAAACHIegBAAAAgMMQ9AAAAADAYQh6AAAAAOAwBD0AAAAAcBiCHgAAAAA4DEEPAAAAAByGoAcAAAAADkPQAwAAAACHIegBAAAAgMMQ9AAAAADAYQh6AAAAAOAwBD0AAAAAcBiCHgAAAAA4DEEPAAAAAByGoAcAAAAADkPQAwAAAACHIegBAAAAgMMQ9AAAAADAYQh6AAAAAOAwBD0AAAAAcBiCHgAAAAA4DEEPAAAAABzGbXcBqJvP56t1LC8vz4ZKnMPj8ejAgQPau3ev4uPj7S4nJtDn9qDf7UG/24N+twf9bg/63R6R0O915YC68kIggl6EKigoqHVs0KBBNlQCAAAAINIUFBSoY8eO9T7PrZsAAAAA4DAEPQAAAABwGIIeAAAAADiMYZqmaXcRqM3r9Wr9+vVBxzIzM+Vykc2b6+DBg+rTp482btyo9PR0u8uJCfS5Peh3e9Dv9qDf7UG/24N+t0ck9LvP56u1hke/fv3kdte/5AqLsUQot9utI444wu4yHCUxMVGS1L59e2VkZNhcTWygz+1Bv9uDfrcH/W4P+t0e9Ls9IqXfD7fwSl0YHgIAAAAAhyHoIWYkJibqlltu8f9VBq2PPrcH/W4P+t0e9Ls96Hd70O/2iNZ+Z44eAAAAADgMI3oAAAAA4DAEPaAeO3bs0LXXXqsxY8YoKSlJhmE0+Bqv16uhQ4fKMAy9+OKLYajSmRrb96+++qrOPfdcde/eXSkpKRo8eLD+8Y9/yOPxhLni6NeU7/ctW7bo7LPPVnp6utq1a6fp06crLy8vjNU633/+8x8dc8wxysjIUHZ2ts4880ytXr3a7rJiwvPPP6+RI0cqOTlZWVlZOvXUU/n+DhN+hoYPPz9bV6T8nCToAfXYsGGDXnnlFWVnZ2vMmDGNes19992nvXv3tnJlztfYvr/77rvldrt155136u2339ZFF12kP/3pT7rsssvCWK0zNLbPi4qKdOKJJ2rnzp164YUX9Oijj+rTTz/VmWeeKZ/PF8aKneu///2vpkyZon79+unVV1/VI488otzcXJ188snatWuX3eU52t/+9jfNmDFDp59+ut555x099dRTGjZsmMrLy+0uLSbwMzR8+PnZeiLq56QJoE6VlZX+9l//+lezof9cduzYYaanp5tPPfWUKcl84YUXWrtEx2ps3+fm5tY6dvvtt5uSzN27d7dafU7U2D6/++67zcTERHPXrl3+Y1988YUpyVy4cGGr1xkLLr30UrNnz56mz+fzH9u4caMpyXziiSdsrMzZfvjhB9PtdpuPPPKI3aXEJH6Ghhc/P1tPJP2cZEQPqEdTN6efPXu2zjrrLJ1wwgmtVFHsaGzfd+jQodaxo48+WpIY+Wiixvb5W2+9pRNPPFE5OTn+Y6NGjVL//v315ptvtlZ5MaWiokLp6elBt8+2bdtWkmSyflqrefLJJ5WUlKRLL73U7lJiEj9Dw4ufn60nkn5OEvRgm82bN+uxxx7T5ZdfrmHDhsntdsswDN1xxx2Nev0777yjU045RZmZmUpNTdWIESN0//3323L72KJFi/Tf//5Xf//738P+3s3hpL4/1P/+9z8lJCSoT58+dpcSxCl9/u2332rw4MG1jg8ePFjfffddWGtprkj/t5g1a5a+++47/etf/9K+ffu0Y8cO/eY3v1G3bt00ZcqUkLyHHSK935cvX64BAwboqaeeUo8ePeR2uzV8+HC99957Ibm+XSK936Xo+xnaGNHQ74eK1J+foRDOf4+I+jkZ1vFDIMDs2bNNSbU+br/99gZfW31rmSSzd+/e5tChQ02Xy2VKMs8666yg29BC4XC3spWWlpp9+vQx7777btM0TXPz5s0Rf9uJU/r+UN9++62ZkpJiXnPNNSGtIRSc0ufx8fF11jxr1iyzf//+Ia2jtUTDv8Xrr79upqen+9+rV69e5g8//BCSa9sl0vt9wIABZlpampmTk2M+/fTT5qJFi8yf/exnZnx8vPn999+3+Pp2ifR+j8afoY0R6f1+qEj++RkK4fz3iKSfk+4WZESgRdq3///t3X9MVfUfx/HXJfkhpsgQmtri1xypGZYK5VaSc7kJoSyt3MgKzWa2aMhyqzFo/Zh/GLRq+ofabStnlk2ny1UTUYdCiwoa0VwbkJubQw0mvwn3+f7RuIMvID8unHPu4fnY7h/33M8593NeH+DD+5x7zp2jjIwMpaSkaMWKFTp48KC+/fbbEderqKjQW2+9paCgIH355ZfavHmzJKmmpkZr167VyZMnVVxcrPz8fN86ra2tunr16ojbnjt3riIiIsa0Hx988IFCQkL0+uuvj2k9O7kl+/5u3ryprKwsJSYmas+ePePezmRxU+ZD3ZHTBNBHCp0+FhcvXtSWLVuUnZ2tp59+Wh0dHSopKdGTTz6p8vJy3XvvvePcc3s5Pffbt2+rra1NR48e1bp16yRJjz/+uOLj47V3714dOHBgPLttO6fnHohz6Gg4Pff+nD5/TgQrx0Ny0DxpaVkJ3MELL7wwqqMr69atM5LM9u3bB712+PBhI8lERUWZnp4e3/IjR44MeSTn/x9er3fI9xzuDEdjY6MJDQ01x44dM83Nzaa5udnU1NQYSebQoUOmpaVlbCHYJBCz76+1tdWkpKSY2NhYc/Xq1ZF32AECNfOYmBiza9euQcuzsrLMI488csd9cSqnjcWyZctMenr6gO23t7eb6Ohok5ub69e+OonTck9JSTGSTEdHx4D3WL9+vVm5cqV/O+sgTsrdLXPoaDgp9/4Ccf6cCJM5Hk6aJ7lGDwHl1q1bOnPmjKT/rmP5f5s2bdKsWbN08+ZNlZWV+ZY/99xzMsaM+BjrRfgNDQ3q7u7Wxo0bFRkZqcjISCUnJ/v6d88994x/Zx3Gadn36e7uVlZWlurr6/XDDz9o3rx549qOEzkx88WLF6uurm7Q8rq6Oi1cuHDM2wsUVo5FXV2dHn744QHbDw8PV1JSkv7666/J2UGHsjL3xYsXD3sUvqura+J3zsGsyn0qzaGjYfXffDfPnxNhvOPhpHmSQg8B5bffflNPT4/CwsIG/SMkScHBwVqxYoUk6aeffpr0/ixdulRlZWUDHkeOHJEkFRQU6Mcff5z0PljFadlL/33UavPmzaqsrNTp06eVlJRkyftaxYmZZ2RkqKysTNeuXfMt++WXX3T58mU99dRTlvTBDlaORVxcnKqqqgYsa2tr059//qn4+Hi/th1orMw9IyNDxhiVlpb6lnV0dKiiosJ3N8Kpwqrcp9IcOhpW/ry7ff6cCOMdDyfNk1yjh4DSdzT7vvvu07RpQ//4JiQkqLS0dEKOfB87dkySVFtbO+D5okWLtGjRIs2ePVtpaWkD1mlsbPS1cdNtop2WvSTt3LlTx48f17vvvqvbt2+rsrLSt35iYuKQt48OJE7M/OWXX9Ynn3yizMxMFRYWqqurS7t371ZKSorWr1/vdx+cysqxeO2117Rz505t375dGzduVHt7u4qLi9Xa2qpXXnnFr20HGitz37Bhg1JSUrRt2zbt2bNHMTExKikpUXt7u3bt2uXXtgONVblPpTl0NKz8eXf7/DkRxjseTponKfQQUJqbmyVJkZGRw7bpe62vrT82bdo05PPCwkIVFRX5vf1A4sTsv//+e0n/HfktKCgY0N7r9Qb892E5MfOZM2fq7Nmzys3N1bPPPqtp06YpIyNDJSUlY/7uyUBi5Vjs2LFDYWFh+vTTT/XVV18pLCxMycnJOnv2rJYsWeLXtgONlbkHBQXpu+++U35+vvLy8tTZ2anU1FSVlZVNubMdVv/twX+szN3t8+dEGO94OGmepNBDQOm7TiIkJGTYNqGhoZKkzs5Ov9/PjOMOSXFxcQF1B8LRcmL2fUd+3cqJmUtSfHy8Tp486ff7BRIrx8Lj8SgnJ0c5OTl+bccNrP4dmDNnjj7//HO/txPorM69P7fOoaNhZe5unz8ngj/j4ZR50r2HX+FKYWFhkqSenp5h23R3d0uSpk+fbkmfpgqytx6ZOwdjYQ9ytwe524PcncUN40Ghh4Aymo8sjOZUO8aO7K1H5s7BWNiD3O1B7vYgd2dxw3hQ6CGgLFiwQJJ05coV9fb2Dtmmvr5+QFtMDLK3Hpk7B2NhD3K3B7nbg9ydxQ3jQaGHgPLQQw8pODhYXV1d+vXXXwe9/u+//+rnn3+WJKWmplrdPVcje+uRuXMwFvYgd3uQuz3I3VncMB4Ueggos2bN0po1ayRJhw4dGvT6N998o1u3bikqKmrQLZvhH7K3Hpk7B2NhD3K3B7nbg9ydxQ3jQaGHgPP222/L4/Ho4MGDvi9WlaSamhrl5eVJkt5888073iUJ40P21iNz52As7EHu9iB3e5C7swT8eBjAJuXl5SYqKsr3CA0NNZJMeHj4gOVXrlwZtO57771nJBlJJiEhwTz44IMmKCjISDLp6emmt7fXhj0KHGRvPTJ3DsbCHuRuD3K3B7k7y1QdDwo92KasrMz3i3OnR0NDw5Drnzp1yqxevdpERESY8PBwk5ycbD766CNH/8I5Bdlbj8ydg7GwB7nbg9ztQe7OMlXHw2PMFP1WSgAAAABwKa7RAwAAAACXodADAAAAAJeh0AMAAAAAl6HQAwAAAACXodADAAAAAJeh0AMAAAAAl6HQAwAAAACXodADAAAAAJeh0AMAAAAAl6HQAwAAAACXodADAAAAAJeh0AMAYJKcO3dOHo9nTI833njD7m4DAFyAQg8AAAdLS0uTx+NRWlqa3V0BAASQaXZ3AACAqWDHjh169dVXR2w3Z84cC3oDAHA7Cj0AACwQExOjBx54wO5uAACmCD66CQAAAAAuQ6EHAIADvfjii/J4PDp//rwk6fz584Nu3BIXFzdgnfb2dh09elTbtm3T0qVLFRERoeDgYEVHR2vVqlXau3ev2trabNgbAIDV+OgmAAAukZ6e7isM+7tx44YuXLigCxcuaN++fTp9+rTuv/9+G3oIALAKhR4AAA70/vvvKz8/Xy+99JKqqqq0fPlyeb3eAW1CQkIGPO/t7dWSJUuUmZmp5cuXa968eTLG6O+//9bx48f19ddfq6GhQRs2bFB1dbXCwsKs3CUAgIUo9AAAsEBTU5Nqa2tHbJeUlKTg4GDNnz9f8+fP14wZMyRJM2bMGPFmLl6vVwsWLBi0PDU1Vc8884y2bt2qtWvX6vLlyzp8+LC2bt06vp0BADgehR4AABbYv3+/9u/fP2K7hoaGQdfejdZQRV5/a9asUWZmpk6cOKETJ05Q6AGAi1HoAQDgUtevX1dLS4u6u7t9y6KjoyVJNTU1dnULAGABCj0AACxQWFiooqKiSX+fixcv6uOPP9aZM2f0zz//DNvuxo0bk94XAIB9KPQAAHCJoqIivfPOO6Nq29nZOcm9AQDYie/RAwDABUpLS31FXkJCgvbt26fff/9dLS0t6u3tlTFGxhgVFBTY3FMAgBU4owcAgAscOHBAkjR79mxVVFQoJiZmyHbNzc1WdgsAYBPO6AEA4GAej2dU7f744w9J0urVq4ct8iSpqqpqQvoFAHA2Cj0AABys70vN+985cyi9vb2SpI6OjmHbVFdXq7KycuI6BwBwLAo9AAAcbO7cuZKk+vp6GWOGbdf3HXrl5eWqr68f9Pr169eVnZ09OZ0EADgO1+gBAGCBpqYm1dbWjthu+vTpSkxM9D1fuXKlvF6vmpqalJeXp+zsbEVEREiSgoODFRsbK0nasmWLTp06pba2Nq1atUq7d+/WsmXLZIzRpUuXVFxcrGvXrunRRx9VRUXF5OwkAMAxPOZOhwcBAMC4nTt3Tk888cSY1klOTlZ1dbXveVtbm5KTk4c8SxcbG6vGxkbf85ycHHm93iG3e9ddd+nDDz9Uc3Oz7+6c/AsAAO7FRzcBAHCwu+++W5cuXVJubq4WLlyo8PDwYdt+9tln+uKLL/TYY49p5syZCg0NVWxsrJ5//nnfNgAAUwNn9AAAAADAZTijBwAAAAAuQ6EHAAAAAC5DoQcAAAAALkOhBwAAAAAuQ6EHAAAAAC5DoQcAAAAALkOhBwAAAAAuQ6EHAAAAAC5DoQcAAAAALkOhBwAAAAAuQ6EHAAAAAC5DoQcAAAAALkOhBwAAAAAuQ6EHAAAAAC5DoQcAAAAALvM/q/cSwRKwDBAAAAAASUVORK5CYII=", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -693,7 +1360,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 27, "id": "42e66fb4", "metadata": {}, "outputs": [ @@ -701,350 +1368,1632 @@ "name": "stdout", "output_type": "stream", "text": [ - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.3812234953036564" + "0.38122349530365623" ] }, - "execution_count": 10, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1074,7 +3023,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 28, "id": "caa35226", "metadata": {}, "outputs": [ @@ -1082,167 +3031,811 @@ "name": "stdout", "output_type": "stream", "text": [ - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", - "Please note that sigma2 will be returned by default in future versions.\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", + "\n", + "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, @@ -1252,20 +3845,18 @@ "0.3524436425793535" ] }, - "execution_count": 11, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -1301,7 +3892,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 29, "id": "35fcdb16", "metadata": {}, "outputs": [ @@ -1315,8 +3906,12 @@ "Coefficients:\n", "[-0.42051375 -0.42015352 -0.39242555 -0.3595962 -0.35627711 0.08883738]\n", "6 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.011497501756394954\n", + "Reestimated sigma2: 1.150e-02\n", + "\n", "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, @@ -1326,7 +3921,7 @@ "0.3524436425793535" ] }, - "execution_count": 12, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" } @@ -1363,7 +3958,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 30, "id": "34a6a1a8", "metadata": {}, "outputs": [ @@ -1379,18 +3974,22 @@ "[-0.36935208 -0.3959887 -0.38575969 -0.41041135 -0.3524368 0.12510656\n", " 0.11470634 0.09683046 0.1290426 0.08523407]\n", "10 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.005758447126874832\n", + "Reestimated sigma2: 5.758e-03\n", + "\n", "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.3361300705992166" + "0.3361300705992165" ] }, - "execution_count": 13, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" } @@ -1421,7 +4020,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 31, "id": "0e299d8e", "metadata": {}, "outputs": [ @@ -1437,18 +4036,22 @@ "[-0.37410154 -0.39643237 -0.40111915 -0.39888695 -0.35358233 0.15128684\n", " 0.10741545 0.13063637 0.121388 0.12643134 0.0594203 0.0915976 ]\n", "12 terms retained out of a full basis of size 70\n", - "Reestimated sigma2: 0.005758447126874825\n", + "Reestimated sigma2: 5.758e-03\n", + "\n", "Please note that sigma2 will be returned by default in future versions.\n", + "To remain compatible, set input argument return_sigma2 to True and expect\n", + "three return arguments: pc_model, coefficients, updated noise variance\n", + "\n", "The NRMS error between a 4 -dimensional genz_osc function and a BCS-based PC surrogate of order 4 is\n" ] }, { "data": { "text/plain": [ - "0.32363253923406987" + "0.32363253923407015" ] }, - "execution_count": 14, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -1485,7 +4088,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.12" + "version": "3.9.17" } }, "nbformat": 4,