diff --git a/.idea/autora.iml b/.idea/autora.iml index 7bfbf6e7a..e163492a5 100644 --- a/.idea/autora.iml +++ b/.idea/autora.iml @@ -5,8 +5,6 @@ - - @@ -25,4 +23,4 @@ - \ No newline at end of file + diff --git a/example/cycle/cycle_results_plots.ipynb b/docs/cycle/cycle_results_plots.ipynb similarity index 99% rename from example/cycle/cycle_results_plots.ipynb rename to docs/cycle/cycle_results_plots.ipynb index 6e99c8c52..d01f36ef0 100644 --- a/example/cycle/cycle_results_plots.ipynb +++ b/docs/cycle/cycle_results_plots.ipynb @@ -6,20 +6,26 @@ " # Examples of using cycle results plotting functions" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false } }, { "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, - "pycharm": { - "name": "#%%\n" - } + "collapsed": true }, "outputs": [], "source": [ @@ -99,10 +105,7 @@ "cycle.run(5)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -115,10 +118,7 @@ "* Default panel configuration is 4 plots to a row." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -139,10 +139,7 @@ "plot_results_panel_2d(cycle); # Add semicolon to supress creating two figures in jupyter notebook" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -151,10 +148,7 @@ "### Default parameters can be changed by passing in keywords" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -178,10 +172,7 @@ " );" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -194,10 +185,7 @@ " * Below shows ways to specify the parameters of the [scatter](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.scatter.html) points and theory [line](https://matplotlib.org/stable/api/_as_gen/matplotlib.axes.Axes.plot.html)." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -224,10 +212,7 @@ " );" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -236,10 +221,7 @@ "Saving the figure to an object (above) will allow you to cycle through the axes to make panel-specific edits." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -265,10 +247,7 @@ "fig\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -280,10 +259,7 @@ "2. **Slice**: Constructed with `slice()` or `np.s_[]`" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -334,10 +310,7 @@ "fig.suptitle('Last Cycle')" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -370,10 +343,7 @@ "fig.supxlabel('x1', y=0.1)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -423,10 +393,7 @@ "fig2.suptitle('Last 2 Cycles')" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -436,10 +403,7 @@ "The 3D plotter has similar functionality as the 2D plotter but will only work with problem spaces where there are exactly 2 independent variable values. Only one dependent value can be plotted at a time." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -508,10 +472,7 @@ "cycle_mlr.run(5)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -532,10 +493,7 @@ "fig = plot_results_panel_3d(cycle_mlr); # Add semicolon to supress creating two figures in jupyter notebook" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -559,10 +517,7 @@ " );" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -589,10 +544,7 @@ " );\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -607,10 +559,7 @@ "\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -638,10 +587,7 @@ " );" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -669,10 +615,7 @@ " );\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } } ], @@ -697,4 +640,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/example/cycle/cycle_scoring.ipynb b/docs/cycle/cycle_scoring.ipynb similarity index 99% rename from example/cycle/cycle_scoring.ipynb rename to docs/cycle/cycle_scoring.ipynb index 9f4bb6421..ee048bd39 100644 --- a/example/cycle/cycle_scoring.ipynb +++ b/docs/cycle/cycle_scoring.ipynb @@ -3,26 +3,32 @@ { "cell_type": "markdown", "source": [ - "# Cycle Scoring\n", + "# Scoring\n", "This notebook shows how to use autora.cycle scoring tools.\n", "\n", "We'll be using the [Iris toy dataset](https://scikit-learn.org/stable/datasets/toy_dataset.html#iris-plants-dataset) from sklearn to create a simple logistic regression cycle. This model will classify samples into different species of irises based on flower measurements. The dataset will be split between a training set and test set; the test set will be withheld for the scoring metrics." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false } }, { "cell_type": "code", "execution_count": 1, "metadata": { - "collapsed": true, - "pycharm": { - "name": "#%%\n" - } + "collapsed": true }, "outputs": [], "source": [ @@ -49,10 +55,7 @@ "Data is split where 33% is reserved for testing." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -65,10 +68,7 @@ "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=.33, random_state=1)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -80,10 +80,7 @@ "3. **Experiment Runner** - Creates an oracle that uses the full dataset to match experimental independent variables (flower measurements) and returns the dependent variable (species)." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -155,10 +152,7 @@ "cycle.run(20)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -176,10 +170,7 @@ "\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -209,10 +200,7 @@ "print(f'Specified scorer - precision: {np.around(results_specified_precision, 2).tolist()}')" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -221,10 +209,7 @@ "Note that the \"default scorer\" and \"specified scorer 1\" results should be the same because the `LogisticRegression` estimator's default is the `accuracy_score` function." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -238,10 +223,7 @@ "Below are several examples." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -275,10 +257,7 @@ " figsize=(5,3));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -302,10 +281,7 @@ " scorer_kw=dict(average='weighted', zero_division=0));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -329,10 +305,7 @@ " scorer_kw=dict(average='weighted'));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -356,10 +329,7 @@ " scorer_kw=dict(average='weighted'));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -383,10 +353,7 @@ " scorer_kw=dict(average='weighted', multi_class='ovr'));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -425,10 +392,7 @@ "fig.axes[0].set_title('Accuracy Over 20 Cycles')\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } } ], @@ -453,4 +417,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/example/cycle/cycle_scoring_bms.ipynb b/docs/cycle/cycle_scoring_bms.ipynb similarity index 99% rename from example/cycle/cycle_scoring_bms.ipynb rename to docs/cycle/cycle_scoring_bms.ipynb index c1eb23dfc..bb45b8878 100644 --- a/example/cycle/cycle_scoring_bms.ipynb +++ b/docs/cycle/cycle_scoring_bms.ipynb @@ -4,10 +4,7 @@ "cell_type": "markdown", "source": [], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -17,10 +14,19 @@ "The aim of this example notebook is to use the AutoRA `Cycle` to recover a ground truth theory from some noisy data using BSM and random sampling. We will evaluate the model with AutoRa's scoring and plotting functions." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false } }, { @@ -40,10 +46,7 @@ "from autora.skl.bms import BMSRegressor" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -54,10 +57,7 @@ "The space of allowed x values is reals between -10 and 10 inclusive. We discretize them as we don't currently have a sampler which can sample from the uniform distribution." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -97,20 +97,14 @@ "plt.legend()" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { "cell_type": "markdown", "source": [], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -120,10 +114,7 @@ "We create a synthetic experiment that adds noise." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -161,10 +152,7 @@ "plt.legend()" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -174,10 +162,7 @@ "We use a common BMS regressor with a common parametrization as the theorist." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -188,10 +173,7 @@ "bms_theorist = BMSRegressor(epochs=800)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -200,10 +182,7 @@ "## Experimentalist - Random Sampler" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -220,10 +199,7 @@ ")" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -245,10 +221,7 @@ "random_experimentalist_cycle.run(n_cycles);" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -257,10 +230,7 @@ "## Evaluating Results" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -270,10 +240,7 @@ "We will test the performance of the models against the ground truth. Here we generate the ground truth values across the value range as the test set." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -285,10 +252,7 @@ "y_test = ground_truth(X_test)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -320,10 +284,7 @@ " figsize=(5,3));" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -347,10 +308,7 @@ " );\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -374,10 +332,7 @@ " );\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } } ], @@ -402,4 +357,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/example/cycle/simple_cycle_bms_darts.ipynb b/docs/cycle/simple_cycle_bms_darts.ipynb similarity index 77% rename from example/cycle/simple_cycle_bms_darts.ipynb rename to docs/cycle/simple_cycle_bms_darts.ipynb index 5d9bb8991..be862996f 100644 --- a/example/cycle/simple_cycle_bms_darts.ipynb +++ b/docs/cycle/simple_cycle_bms_darts.ipynb @@ -8,10 +8,19 @@ "It uses a trivial experimentalist which resamples the same x-values each cycle." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false } }, { @@ -24,10 +33,7 @@ "from itertools import repeat, chain" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -39,10 +45,7 @@ " return (xs ** 2.) + xs + 1." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -51,10 +54,7 @@ "The space of allowed x values is the integers between 0 and 10 inclusive, and we record the allowed output values as well." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -68,10 +68,7 @@ " )" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -81,10 +78,7 @@ "Since the space of values is so restricted, we can just sample them all each time." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -97,10 +91,7 @@ " [list(chain.from_iterable((repeat(study_metadata.independent_variables[0].allowed_values, 10))))])" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -109,10 +100,7 @@ "When we run a synthetic experiment, we get a reproducible noisy result:" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -133,10 +121,7 @@ "example_synthetic_experiment_runner(x)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -145,10 +130,7 @@ "## Bayesian Machine Scientist" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -160,10 +142,7 @@ "bms_theorist = BMSRegressor(epochs=100)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -174,10 +153,7 @@ "as well as a monitor which will let us know which cycle we're currently on." ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -193,10 +169,7 @@ ")" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -205,10 +178,7 @@ "We can run the cycle by calling the run method:" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -219,10 +189,7 @@ "cycle.run(num_cycles=3)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -232,10 +199,7 @@ "experiment runner were:" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -244,10 +208,7 @@ "The observations include the conditions and the results:" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -258,10 +219,7 @@ "cycle.data.observations[0]" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -270,10 +228,7 @@ "The best fit theory after the first cycle is:" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -284,10 +239,7 @@ "len(cycle.data.observations)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -298,10 +250,7 @@ "str(cycle.data.theories[0].model_), cycle.data.theories[0].model_.fit_par[str(cycle.data.theories[0].model_)]" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -312,10 +261,7 @@ "str(cycle.data.theories[-1].model_), cycle.data.theories[-1].model_.fit_par[str(cycle.data.theories[-1].model_)]" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -327,10 +273,7 @@ "plot_results_panel_2d(cycle, subplot_kw=dict(figsize=(12,4)))" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -339,10 +282,7 @@ "## DARTS\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false }, "execution_count": 217 }, @@ -355,10 +295,7 @@ "darts_theorist = DARTSRegressor(max_epochs=100)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -374,10 +311,7 @@ ")" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -388,10 +322,7 @@ "darts_cycle.run(3)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -402,10 +333,7 @@ "darts_cycle.data.theories[-2].visualize_model()\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -416,10 +344,7 @@ "darts_cycle.data.theories[-2].model_repr()\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -431,10 +356,7 @@ "darts_cycle.run(3)" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -446,10 +368,7 @@ "plot_results_panel_2d(darts_cycle, wrap=3)\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } } ], @@ -474,4 +393,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/docs/cycle/simple_cycle_bms_model_poppernet.ipynb b/docs/cycle/simple_cycle_bms_model_poppernet.ipynb new file mode 100644 index 000000000..1bda9fd20 --- /dev/null +++ b/docs/cycle/simple_cycle_bms_model_poppernet.ipynb @@ -0,0 +1,622 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from autora.cycle import Cycle\n", + "from autora.experimentalist.pipeline import Pipeline\n", + "from autora.experimentalist.pooler import grid_pool, poppernet_pool\n", + "from autora.experimentalist.sampler import nearest_values_sampler\n", + "from autora.skl.bms import BMSRegressor\n", + "from autora.variable import Variable, VariableCollection" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "# meta parameters\n", + "ground_truth_resolution = 1000\n", + "samples_per_cycle = 7\n", + "value_range = (-1, 5)\n", + "allowed_values = np.linspace(value_range[0], value_range[1], ground_truth_resolution)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [], + "source": [ + "# define ground truth\n", + "def ground_truth(xs):\n", + " # return (xs ** 2.) + xs + 1.\n", + " y = xs * 1.0\n", + " y[xs < 0] = 0\n", + " return y" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [], + "source": [ + "# define variables\n", + "study_metadata = VariableCollection(\n", + " independent_variables=[\n", + " Variable(name=\"x1\", allowed_values=allowed_values, value_range=value_range)\n", + " ],\n", + " dependent_variables=[Variable(name=\"y\", value_range=(-20, 20))],\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [], + "source": [ + "# define experiment platform\n", + "def get_synthetic_experiment_runner():\n", + " rng = np.random.default_rng(seed=180)\n", + "\n", + " def runner(xs):\n", + " return ground_truth(xs) + rng.normal(0, 0.5, xs.shape)\n", + "\n", + " return runner\n", + "\n", + "synthetic_experiment_runner = get_synthetic_experiment_runner()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [], + "source": [ + "# Initialize the experimentalist\n", + "random_experimentalist = Pipeline(\n", + " [\n", + " (\"grid_pool\", grid_pool), # type: ignore\n", + " (\"nearest_values_sampler\", nearest_values_sampler), # type: ignore\n", + " ],\n", + " {\n", + " \"grid_pool\": {\"ivs\": study_metadata.independent_variables},\n", + " \"nearest_values_sampler\": {\n", + " \"allowed_values\": np.linspace(\n", + " value_range[0], value_range[1], samples_per_cycle\n", + " ),\n", + " \"n\": samples_per_cycle,\n", + " },\n", + " },\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [ + "# define theorist\n", + "bms_theorist = BMSRegressor(epochs=100)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:autora.skl.bms:BMS fitting started\n", + " 0%| | 0/100 [00:00:2: RuntimeWarning: invalid value encountered in power\n", + " return X0**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + " 3%|▎ | 3/100 [00:00<00:03, 24.45it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(_a0_/X0)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", + " warnings.warn('Covariance of the parameters could not be estimated',\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(_a0_/X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 6%|▌ | 6/100 [00:00<00:04, 19.35it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -_a0_*log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -_a0_*log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -_a0_*log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -_a0_*log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return -_a0_*log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return -_a0_*log(X0)\n", + " 10%|█ | 10/100 [00:00<00:03, 24.48it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + " 13%|█▎ | 13/100 [00:00<00:03, 25.56it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 17%|█▋ | 17/100 [00:00<00:02, 28.60it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 25%|██▌ | 25/100 [00:00<00:02, 29.38it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(relu(_a0_/X0))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(relu(_a0_/X0))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(relu(_a0_/X0))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + " 29%|██▉ | 29/100 [00:01<00:02, 30.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return abs(X0**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 33%|███▎ | 33/100 [00:01<00:02, 31.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(X0**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(sig(_a0_/X0)**2)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(sig(_a0_/X0)**2)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sig(sig(_a0_/X0)**2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 37%|███▋ | 37/100 [00:01<00:01, 32.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + " 41%|████ | 41/100 [00:01<00:01, 32.14it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sig(sig(sig(X0**_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + " 45%|████▌ | 45/100 [00:01<00:01, 32.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 49%|████▉ | 49/100 [00:01<00:01, 32.49it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(X0**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return abs(log(X0))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return abs(log(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return abs(log(X0))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return abs(log(X0))\n", + " 53%|█████▎ | 53/100 [00:01<00:01, 32.94it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 57%|█████▋ | 57/100 [00:01<00:01, 32.46it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(sqrt(X0)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(sqrt(X0)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(sqrt(X0)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(sig(sig(log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(sig(sig(log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(sig(sig(log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 61%|██████ | 61/100 [00:02<00:01, 32.52it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(sqrt(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(X0)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(X0)\n", + " 65%|██████▌ | 65/100 [00:02<00:01, 33.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(X0)**X0\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(X0)**X0\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 69%|██████▉ | 69/100 [00:02<00:00, 33.02it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 73%|███████▎ | 73/100 [00:02<00:00, 31.93it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + " 77%|███████▋ | 77/100 [00:02<00:00, 31.69it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return abs(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(relu(relu(X0))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(relu(relu(X0))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + " 81%|████████ | 81/100 [00:02<00:00, 32.10it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + " 85%|████████▌ | 85/100 [00:02<00:00, 31.54it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(X0))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(_a0_/X0)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_/X0\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(X0)\n", + " 97%|█████████▋| 97/100 [00:03<00:00, 33.64it/s]:2: RuntimeWarning: invalid value encountered in divide\n", + " return relu(relu(X0))/X0\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return relu(relu(X0))/X0\n", + "100%|██████████| 100/100 [00:03<00:00, 31.19it/s]\n", + "INFO:autora.skl.bms:BMS fitting finished\n" + ] + } + ], + "source": [ + "# define seed cycle\n", + "# we will use this cycle to collect initial data and initialize the BMS model\n", + "seed_cycle = Cycle(\n", + " metadata=study_metadata,\n", + " theorist=bms_theorist,\n", + " experimentalist=random_experimentalist,\n", + " experiment_runner=synthetic_experiment_runner,\n", + ")\n", + "\n", + "# run seed cycle\n", + "seed_cycle.run(num_cycles=1)\n", + "\n", + "seed_model = seed_cycle.data.theories[0].model_\n", + "seed_x = seed_cycle.data.conditions[0]\n", + "seed_y = seed_cycle.data.observations[0][:, 1]" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [], + "source": [ + "# now we define the poppernet experimentalist which takes into account\n", + "# the seed data and the seed model\n", + "popper_experimentalist = Pipeline(\n", + " [\n", + " (\"popper_pool\", poppernet_pool), # type: ignore\n", + " (\"nearest_values_sampler\", nearest_values_sampler), # type: ignore\n", + " ],\n", + " {\n", + " \"popper_pool\": {\n", + " \"metadata\": study_metadata,\n", + " \"model\": seed_model,\n", + " \"x_train\": seed_x,\n", + " \"y_train\": seed_y,\n", + " \"n\": samples_per_cycle,\n", + " \"plot\": True,\n", + " },\n", + " \"nearest_values_sampler\": {\n", + " \"allowed_values\": allowed_values,\n", + " \"n\": samples_per_cycle,\n", + " },\n", + " },\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 11, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Finished training Popper Network...\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:autora.skl.bms:BMS fitting started\n", + " 9%|▉ | 9/100 [00:00<00:03, 28.62it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sig(_a0_**X0)\n", + " 21%|██ | 21/100 [00:00<00:02, 31.02it/s]/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", + " warnings.warn('Covariance of the parameters could not be estimated',\n", + "100%|██████████| 100/100 [00:03<00:00, 32.37it/s]\n", + "INFO:autora.skl.bms:BMS fitting finished\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# running a new cycle taking into account the seed data and model\n", + "# TODO: need to find a way to incorporate the seed data into the cycle\n", + "cycle = Cycle(\n", + " metadata=study_metadata,\n", + " theorist=bms_theorist,\n", + " experimentalist=popper_experimentalist,\n", + " experiment_runner=synthetic_experiment_runner,\n", + ")\n", + "cycle.run(num_cycles=1)\n", + "\n", + "# plot output of architecture search\n", + "all_obs = np.row_stack(seed_cycle.data.observations)\n", + "x_obs, y_obs = all_obs[:, 0], all_obs[:, 1]\n", + "plt.scatter(x_obs, y_obs, s=10, label=\"seed data\")\n", + "\n", + "all_obs = np.row_stack(cycle.data.observations)\n", + "x_obs, y_obs = all_obs[:, 0], all_obs[:, 1]\n", + "plt.scatter(x_obs, y_obs, s=10, label=\"collected data\")\n", + "\n", + "x_pred = np.array(study_metadata.independent_variables[0].allowed_values).reshape(\n", + " ground_truth_resolution, 1\n", + ")\n", + "y_pred_seed = seed_cycle.data.theories[0].predict(x_pred)\n", + "y_pred_final = cycle.data.theories[0].predict(x_pred)\n", + "plt.plot(x_pred, y_pred_seed, color=\"blue\", label=\"seed model\")\n", + "plt.plot(x_pred, y_pred_final, color=\"red\", label=\"final model\")\n", + "plt.legend()\n", + "plt.show()\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/example/cycle/simple_cycle_uncertainty_experimentalist.ipynb b/docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb similarity index 97% rename from example/cycle/simple_cycle_uncertainty_experimentalist.ipynb rename to docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb index 0b6c64313..7fc16de7b 100644 --- a/example/cycle/simple_cycle_uncertainty_experimentalist.ipynb +++ b/docs/cycle/simple_cycle_uncertainty_experimentalist.ipynb @@ -11,6 +11,18 @@ "collapsed": false } }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": null, diff --git a/example/pipeline/Experimentalist Pipeline Examples.ipynb b/docs/pipeline/Experimentalist Pipeline Examples.ipynb similarity index 73% rename from example/pipeline/Experimentalist Pipeline Examples.ipynb rename to docs/pipeline/Experimentalist Pipeline Examples.ipynb index 1f28a8c32..71f367052 100644 --- a/example/pipeline/Experimentalist Pipeline Examples.ipynb +++ b/docs/pipeline/Experimentalist Pipeline Examples.ipynb @@ -1,38 +1,46 @@ { "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Introduction\n", + "This notebook demonstrates the use of the `Pipeline` class to create Experimentalists. Experimentalists consist of two main components:\n", + "1. Condition Generation - Creating combinations of independent variables to test\n", + "2. Experimental Design - Ensuring conditions meet design constraints.\n", + "\n", + "The `Pipeline` class allows us to define a series of functions to generate and process a pool of conditions that conform to an experimental design." + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "outputs": [], "source": [ - "import numpy as np\n", - "\n", - "from functools import partial\n", - "from autora.variable import DV, IV, ValueType, VariableCollection\n", - "from autora.experimentalist.pipeline import Pipeline\n", - "from autora.experimentalist.pool import grid_pool\n", - "from autora.experimentalist.filter import weber_filter\n", - "from autora.experimentalist.sampler import random_sampler" + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" ], "metadata": { "collapsed": false } }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 3, + "outputs": [], "source": [ - "# Introduction\n", - "This notebook demonstrates the use of the `Pipeline` class to create Experimentalists. Experimentalists consist of two main components:\n", - "1. Condition Generation - Creating combinations of independent variables to test\n", - "2. Experimental Design - Ensuring conditions meet design constraints.\n", + "import numpy as np\n", "\n", - "The `Pipeline` class allows us to define a series of functions to generate and process a pool of conditions that conform to an experimental design.\n" + "from autora.variable import DV, IV, ValueType, VariableCollection\n", + "from autora.experimentalist.pipeline import Pipeline\n", + "from autora.experimentalist.pooler import grid_pool\n", + "from autora.experimentalist.filter import weber_filter\n", + "from autora.experimentalist.sampler import random_sampler" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { @@ -58,15 +66,12 @@ "The examples in this notebook will create a Weber line-lengths experiment. The Weber experiment tests human detection of differences between the lengths of two lines. The first example will sample a pool with simple random sampling. We will first define the independent and dependent variables (IVs and DVs, respectively).\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "outputs": [], "source": [ "# Specifying Dependent and Independent Variables\n", @@ -102,10 +107,7 @@ ")" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -125,8 +127,17 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": "Pipeline(steps=[('grid_pool', ), ('weber_filer', ), ('random_sampler', )], params={'grid_pool': {'ivs': [IV(name='S1', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 1 Intensity', rescale=1, is_covariate=False), IV(name='S2', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 2 Intensity', rescale=1, is_covariate=False)]}, 'random_sampler': {'n': 10}})" + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "## Set up pipeline functions with the partial function\n", "# Random Sampler\n", @@ -153,16 +164,23 @@ "The pipeline is run twice below to illustrate that random sampling is performed. Rerunning the cell will produce different results.\n" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } + "collapsed": false } }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 6, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampled Conditions:\n", + " Run 1: [(3.75, 3.75), (0.0, 3.75), (2.5, 5.0), (3.75, 5.0), (1.25, 1.25), (2.5, 3.75), (2.5, 2.5), (1.25, 3.75), (1.25, 2.5), (0.0, 0.0)]\n", + " Run 2: [(1.25, 5.0), (0.0, 5.0), (5.0, 5.0), (0.0, 1.25), (1.25, 2.5), (2.5, 2.5), (1.25, 3.75), (3.75, 3.75), (2.5, 3.75), (0.0, 0.0)]\n" + ] + } + ], "source": [ "# Run the Pipeline\n", "results1 = pipeline_random_samp.run()\n", @@ -172,10 +190,7 @@ " f'Run 2: {results2}')" ], "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } + "collapsed": false } }, { @@ -189,8 +204,18 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 7, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Sampled Conditions:\n", + " Run 1: [(1.25, 2.5), (0.0, 2.5), (3.75, 5.0), (0.0, 3.75), (0.0, 0.0), (0.0, 1.25), (2.5, 2.5), (1.25, 1.25), (3.75, 3.75), (1.25, 3.75)]\n", + " Run 2: []\n" + ] + } + ], "source": [ "## Set up pipeline functions with the partial function\n", "# Pool Function\n", @@ -236,8 +261,17 @@ }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 8, + "outputs": [ + { + "data": { + "text/plain": "Pipeline(steps=[('grid_pool', ), ('weber_filer', ), ('random_sampler', )], params={'grid_pool__ivs': [IV(name='S1', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 1 Intensity', rescale=1, is_covariate=False), IV(name='S2', value_range=None, allowed_values=array([0. , 1.25, 2.5 , 3.75, 5. ]), units='intensity', type=, variable_label='Stimulus 2 Intensity', rescale=1, is_covariate=False)], 'random_sampler__n': 10})" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "pipeline_random_samp = Pipeline([\n", " (\"grid_pool\", grid_pool),\n", @@ -274,4 +308,4 @@ }, "nbformat": 4, "nbformat_minor": 0 -} \ No newline at end of file +} diff --git a/example/synthetic/inventory.ipynb b/docs/synthetic/inventory.ipynb similarity index 72% rename from example/synthetic/inventory.ipynb rename to docs/synthetic/inventory.ipynb index edd49aef2..54be9ee17 100644 --- a/example/synthetic/inventory.ipynb +++ b/docs/synthetic/inventory.ipynb @@ -3,15 +3,26 @@ { "cell_type": "code", "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], "metadata": { - "collapsed": true - }, + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, "outputs": [], "source": [ - "from sklearn.linear_model import LinearRegression\n", - "\n", - "from autora.synthetic import retrieve, Inventory" - ] + "from autora.synthetic import retrieve, Inventory\n", + "from sklearn.linear_model import LinearRegression" + ], + "metadata": { + "collapsed": false + } }, { "cell_type": "code", diff --git a/docs/theorist/bms/example.ipynb b/docs/theorist/bms/example.ipynb new file mode 100644 index 000000000..b297a26bd --- /dev/null +++ b/docs/theorist/bms/example.ipynb @@ -0,0 +1,210 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Bayesian Machine Scientist" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Example" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's generate a simple data set with two features $x_1, x_2 \\in [0, 1]$ and a target $y$. We will use the following generative model:\n", + "$y = 2 x_1 - e^{(5 x_2)}$" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "x_1 = np.linspace(0, 1, num=10)\n", + "x_2 = np.linspace(0, 1, num=10)\n", + "X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2)\n", + "\n", + "y = 2 * X[:,0] + np.exp(5 * X[:,1])" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Now let us choose a prior over the primitives. In this case, we will use priors determined by Guimerà et al (2020).\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [], + "source": [ + "prior = \"Guimera2020\"" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Set up the BMS Regressor\n", + "\n", + "We will use the BMS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below:\n", + "\n", + "- **`epochs`**: The number of epochs to run BMS. This corresponds to the total number of equation mutations - one mcmc step for each parallel-tempered equation and one tree swap between a pair of parallel-tempered equations.\n", + "- **`prior_par`**: A dictionary of priors for each operation. The keys correspond to operations and the respective values correspond to prior probabilities of those operations. The model comes with a default.\n", + "- **`ts`**: A list of temperature values. The machine scientist creates an equation tree for each of these values. Higher temperature trees are harder to fit, and thus they help prevent overfitting of the model.\n", + "\n", + "\n", + "Let's use the same priors over primitives that we specified on the previous page as well as an illustrative set of temperatures to set up the BMS regressor with default parameters.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [], + "source": [ + "from autora.skl.bms import BMSRegressor\n", + "\n", + "temperatures = [1.0] + [1.04**k for k in range(1, 20)]\n", + "\n", + "primitives = {\n", + " \"Psychology\": {\n", + " \"addition\": 5.8,\n", + " \"subtraction\": 4.3,\n", + " \"multiplication\": 5.0,\n", + " \"division\": 5.5,\n", + " }\n", + "}\n", + "\n", + "bms_estimator = BMSRegressor(\n", + " epochs=1500,\n", + " prior_par=primitives,\n", + " ts=temperatures,\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Now we have everything to fit and verify the model." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 10, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:autora.skl.bms:BMS fitting started\n", + " 0%| | 0/1500 [00:00 1\u001B[0m \u001B[43mbms_estimator\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mfit\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX\u001B[49m\u001B[43m,\u001B[49m\u001B[43my\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 2\u001B[0m bms_estimator\u001B[38;5;241m.\u001B[39mpredict(X)\n", + "File \u001B[0;32m~/Developer/autora/autora/skl/bms.py:133\u001B[0m, in \u001B[0;36mBMSRegressor.fit\u001B[0;34m(self, X, y, num_param, root, custom_ops, seed)\u001B[0m\n\u001B[1;32m 120\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39madd_primitive(root)\n\u001B[1;32m 121\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpms \u001B[38;5;241m=\u001B[39m Parallel(\n\u001B[1;32m 122\u001B[0m Ts\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mts,\n\u001B[1;32m 123\u001B[0m variables\u001B[38;5;241m=\u001B[39m\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mvariables,\n\u001B[0;32m (...)\u001B[0m\n\u001B[1;32m 131\u001B[0m seed\u001B[38;5;241m=\u001B[39mseed,\n\u001B[1;32m 132\u001B[0m )\n\u001B[0;32m--> 133\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodel_, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mloss_, \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mcache_ \u001B[38;5;241m=\u001B[39m \u001B[43mutils\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mrun\u001B[49m\u001B[43m(\u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mpms\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mepochs\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 134\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mmodels_ \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpms\u001B[38;5;241m.\u001B[39mtrees\u001B[38;5;241m.\u001B[39mvalues())\n\u001B[1;32m 136\u001B[0m _logger\u001B[38;5;241m.\u001B[39minfo(\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mBMS fitting finished\u001B[39m\u001B[38;5;124m\"\u001B[39m)\n", + "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/utils.py:35\u001B[0m, in \u001B[0;36mrun\u001B[0;34m(pms, num_steps, thinning)\u001B[0m\n\u001B[1;32m 33\u001B[0m desc_len, model, model_len \u001B[38;5;241m=\u001B[39m [], pms\u001B[38;5;241m.\u001B[39mt1, np\u001B[38;5;241m.\u001B[39minf\n\u001B[1;32m 34\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m n \u001B[38;5;129;01min\u001B[39;00m tqdm(\u001B[38;5;28mrange\u001B[39m(num_steps)):\n\u001B[0;32m---> 35\u001B[0m \u001B[43mpms\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmcmc_step\u001B[49m\u001B[43m(\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 36\u001B[0m pms\u001B[38;5;241m.\u001B[39mtree_swap()\n\u001B[1;32m 37\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m num_steps \u001B[38;5;241m%\u001B[39m thinning \u001B[38;5;241m==\u001B[39m \u001B[38;5;241m0\u001B[39m: \u001B[38;5;66;03m# sample less often if we thin more\u001B[39;00m\n", + "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/parallel.py:102\u001B[0m, in \u001B[0;36mParallel.mcmc_step\u001B[0;34m(self, verbose, p_rr, p_long)\u001B[0m\n\u001B[1;32m 99\u001B[0m p_rr \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m0.0\u001B[39m\n\u001B[1;32m 100\u001B[0m \u001B[38;5;28;01mfor\u001B[39;00m T, tree \u001B[38;5;129;01min\u001B[39;00m \u001B[38;5;28mlist\u001B[39m(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtrees\u001B[38;5;241m.\u001B[39mitems()):\n\u001B[1;32m 101\u001B[0m \u001B[38;5;66;03m# MCMC step\u001B[39;00m\n\u001B[0;32m--> 102\u001B[0m \u001B[43mtree\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mmcmc_step\u001B[49m\u001B[43m(\u001B[49m\u001B[43mverbose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverbose\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mp_rr\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mp_rr\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mp_long\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mp_long\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 103\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mt1 \u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mtrees[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124m1.0\u001B[39m\u001B[38;5;124m\"\u001B[39m]\n", + "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/mcmc.py:1160\u001B[0m, in \u001B[0;36mTree.mcmc_step\u001B[0;34m(self, verbose, p_rr, p_long)\u001B[0m\n\u001B[1;32m 1157\u001B[0m \u001B[38;5;28;01melse\u001B[39;00m:\n\u001B[1;32m 1158\u001B[0m \u001B[38;5;66;03m# Try to replace the root\u001B[39;00m\n\u001B[1;32m 1159\u001B[0m newrr \u001B[38;5;241m=\u001B[39m choice(\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mrr_space)\n\u001B[0;32m-> 1160\u001B[0m dE, dEB, dEP, par_valuesNew \u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mdE_rr\u001B[49m\u001B[43m(\u001B[49m\u001B[43mrr\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mnewrr\u001B[49m\u001B[43m,\u001B[49m\u001B[43m \u001B[49m\u001B[43mverbose\u001B[49m\u001B[38;5;241;43m=\u001B[39;49m\u001B[43mverbose\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m 1161\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnum_rr \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m \u001B[38;5;129;01mand\u001B[39;00m \u001B[38;5;241m-\u001B[39mdEB \u001B[38;5;241m/\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mBT \u001B[38;5;241m-\u001B[39m dEP \u001B[38;5;241m/\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mPT \u001B[38;5;241m>\u001B[39m \u001B[38;5;241m0\u001B[39m:\n\u001B[1;32m 1162\u001B[0m paccept \u001B[38;5;241m=\u001B[39m \u001B[38;5;241m1.0\u001B[39m\n", + "File \u001B[0;32m~/Developer/autora/autora/theorist/bms/mcmc.py:1093\u001B[0m, in \u001B[0;36mTree.dE_rr\u001B[0;34m(self, rr, verbose)\u001B[0m\n\u001B[1;32m 1090\u001B[0m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mpar_values \u001B[38;5;241m=\u001B[39m old_par_values\n\u001B[1;32m 1092\u001B[0m \u001B[38;5;66;03m# Prior: change due to the numbers of each operation\u001B[39;00m\n\u001B[0;32m-> 1093\u001B[0m dEP \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;28;43mself\u001B[39;49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mprior_par\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[38;5;124;43mNopi_\u001B[39;49m\u001B[38;5;132;43;01m%s\u001B[39;49;00m\u001B[38;5;124;43m\"\u001B[39;49m\u001B[43m \u001B[49m\u001B[38;5;241;43m%\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mrr\u001B[49m\u001B[43m[\u001B[49m\u001B[38;5;241;43m0\u001B[39;49m\u001B[43m]\u001B[49m\u001B[43m]\u001B[49m\n\u001B[1;32m 1094\u001B[0m \u001B[38;5;28;01mtry\u001B[39;00m:\n\u001B[1;32m 1095\u001B[0m dEP \u001B[38;5;241m+\u001B[39m\u001B[38;5;241m=\u001B[39m \u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mprior_par[\u001B[38;5;124m\"\u001B[39m\u001B[38;5;124mNopi2_\u001B[39m\u001B[38;5;132;01m%s\u001B[39;00m\u001B[38;5;124m\"\u001B[39m \u001B[38;5;241m%\u001B[39m rr[\u001B[38;5;241m0\u001B[39m]] \u001B[38;5;241m*\u001B[39m (\n\u001B[1;32m 1096\u001B[0m (\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnops[rr[\u001B[38;5;241m0\u001B[39m]] \u001B[38;5;241m+\u001B[39m \u001B[38;5;241m1\u001B[39m) \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2\u001B[39m \u001B[38;5;241m-\u001B[39m (\u001B[38;5;28mself\u001B[39m\u001B[38;5;241m.\u001B[39mnops[rr[\u001B[38;5;241m0\u001B[39m]]) \u001B[38;5;241m*\u001B[39m\u001B[38;5;241m*\u001B[39m \u001B[38;5;241m2\u001B[39m\n\u001B[1;32m 1097\u001B[0m )\n", + "\u001B[0;31mKeyError\u001B[0m: 'Nopi_*'" + ] + } + ], + "source": [ + "bms_estimator.fit(X,y)\n", + "bms_estimator.predict(X)" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Troubleshooting\n", + "\n", + "We can troubleshoot the model by playing with a few parameters:\n", + "\n", + "- Increasing the number of epochs. The original paper recommends 1500-3000 epochs for reliable fitting. The default is set to 1500.\n", + "- Using custom priors that are more relevant to the data. The default priors are over equations nonspecific to any particular scientific domain.\n", + "- Increasing the range of temperature values to escape local minima.\n", + "- Reducing the differences between parallel temperatures to escape local minima.\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/theorist/bms/example.md b/docs/theorist/bms/example.md deleted file mode 100644 index c891f9c96..000000000 --- a/docs/theorist/bms/example.md +++ /dev/null @@ -1,61 +0,0 @@ -# Bayesian Machine Scientist - -## Example - -Let's generate a simple data set with two features $x_1, x_2 \in [0, 1]$ and a target $y$. We will use the following generative model: -$y = 2 x_1 - e^{(5 x_2)}$ - -```python -import numpy as np - -x_1 = np.linspace(0, 1, num=10) -x_2 = np.linspace(0, 1, num=10) -X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2) - -y = 2 * X[:,0] + np.exp(5 * X[:,1]) -``` - -Now let us choose a prior over the primitives. In this case, we will use priors determined by Guimerà et al (2020). - -```python -prior = "Guimera2020" -``` - -## Set up the BMS Regressor - -We will use the BMS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below: - -- **`epochs`**: The number of epochs to run BMS. This corresponds to the total number of equation mutations - one mcmc step for each parallel-tempered equation and one tree swap between a pair of parallel-tempered equations. -- **`prior_par`**: A dictionary of priors for each operation. The keys correspond to operations and the respective values correspond to prior probabilities of those operations. The model comes with a default. -- **`ts`**: A list of temperature values. The machine scientist creates an equation tree for each of these values. Higher temperature trees are harder to fit, and thus they help prevent overfitting of the model. - - -Let's use the same priors over primitives that we specified on the previous page as well as an illustrative set of temperatures to set up the BMS regressor with default parameters. - -```python -from autora.skl.bms import BMSRegressor - -temperatures = [1.0] + [1.04**k for k in range(1, 20)] - -bms_estimator = BMSRegressor( - epochs=1500, - prior_par=primitives, - ts=temperatures, -) -``` - -Now we have everything to fit and verify the model. - -```python -bms_estimator.fit(X,y) -bms_estimator.predict(X) -``` - -## Troubleshooting - -We can troubleshoot the model by playing with a few parameters: - -- Increasing the number of epochs. The original paper recommends 1500-3000 epochs for reliable fitting. The default is set to 1500. -- Using custom priors that are more relevant to the data. The default priors are over equations nonspecific to any particular scientific domain. -- Increasing the range of temperature values to escape local minima. -- Reducing the differences between parallel temperatures to escape local minima. diff --git a/docs/theorist/bms/search_space.ipynb b/docs/theorist/bms/search_space.ipynb new file mode 100644 index 000000000..07171e1c5 --- /dev/null +++ b/docs/theorist/bms/search_space.ipynb @@ -0,0 +1,126 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Bayesian Machine Scientist\n", + "\n", + "## Search space\n", + "\n", + "BMS searches the space of operations according to certain parameters to find the best model. As such, the search space is defined by the set of operations that can be applied in each computation step of the model. These operations are also referred to as *primitives*. We can select from the following set of primitives:\n", + "\n", + "- **$\\textit{constant}$**: The output of the computation $x_j$ is a constant parameter value $a$ where $a$ is a fitted float value.\n", + "- **\\+**: The output of the computation $x_j$ is the sum over its two inputs $x_i, x_{ii}$: $x_j = x_i + x_{ii}$.\n", + "- **\\-**: The output of the computation $x_j$ is the respective difference between its inputs $x_i, x_{ii}$: $x_j = x_i - x_{ii}$.\n", + "- **\\***: The output of the computation $x_j$ is the product over its two inputs $x_i, x_{ii}$: $x_j = x_i * x_{ii}$.\n", + "- **\\/**: The output of the computation $x_j$ is the respective quotient between its inputs $x_i, x_{ii}$: $x_j = x_i / x_{ii}$.\n", + "- **abs**: The output of the computation $x_j$ is the absolute value of its input $x_i$: $x_j = |(x_i)|$.\n", + "- **relu**: The output of the computation $x_j$ is a rectified linear function applied to its input $x_i$: $x_j = \\max(0, x_i)$.\n", + "- **exp**: The output of the computation $x_j$ is the natural exponential function applied to its input $x_i$: $x_j = \\exp(x_i)$.\n", + "- **log**: The output of the computation $x_j$ is the natural logarithm function applied to its input $x_i$: $x_j = \\log(x_i)$.\n", + "- **sig**: The output of the computation $x_j$ is a logistic function applied to its input $x_i$: $x_j = \\frac{1}{1 + \\exp(-b * x_i)}$.\n", + "- **fac**: The output of the computation $x_j$ is the generalized factorial function applied to its input $x_i$: $x_j = \\Gamma(1 + x_i)$.\n", + "- **sqrt**: The output of the computation $x_j$ is the square root function applied to its input $x_i$: $x_j = \\sqrt(x_i)$.\n", + "- **pow2**: The output of the computation $x_j$ is the square function applied to its input $x_i$: $x_j$ = $x_i^2$.\n", + "- **pow3**: The output of the computation $x_j$ is the cube function applied to its input $x_i$: $x_j$ = $x_i^3$.\n", + "- **sin**: The output of the computation $x_j$ is the sine function applied to its input $x_i$: $x_j = \\sin(x_i)$.\n", + "- **sinh**: The output of the computation $x_j$ is the hyperbolic sine function applied to its input $x_i$: $x_j = \\sinh(x_i)$.\n", + "- **cos**: The output of the computation $x_j$ is the cosine function applied to its input $x_i$: $x_j = \\cos(x_i)$.\n", + "- **cosh**: The output of the computation $x_j$ is the hyperbolic cosine function applied to its input $x_i$: $x_j = \\cosh(x_i)$.\n", + "- **tan**: The output of the computation $x_j$ is the tangent function applied to its input $x_i$: $x_j = \\tan(x_i)$.\n", + "- **tanh**: The output of the computation $x_j$ is the hyperbolic tangent function applied to its input $x_i$: $x_j = \\tanh(x_i)$.\n", + "- **\\*\\***: The output of the computation $x_j$ is the first input raised to the power of the second input $x_i,x_{ii}$: $x_j$ = $x_i^{x_{ii}}$.\n", + "\n", + "## Example" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 0, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ] + }, + { + "cell_type": "markdown", + "source": [ + "The following example sets up a search space over four illustrative operations found in Wikipedia pages that are tagged by psychology. These operations are our primitives:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "\n", + "primitives = {\n", + " \"Psychology\": {\n", + " \"addition\": 5.8,\n", + " \"subtraction\": 4.3,\n", + " \"multiplication\": 5.0,\n", + " \"division\": 5.5,\n", + " }\n", + "}" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We can then pass these primitives directly to the BMS regressor as follows:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "from autora.skl.bms import BMSRegressor\n", + "\n", + "bms_estimator = BMSRegressor(\n", + " prior_par=primitives\n", + ")\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/theorist/bms/search_space.md b/docs/theorist/bms/search_space.md deleted file mode 100644 index 524b1b528..000000000 --- a/docs/theorist/bms/search_space.md +++ /dev/null @@ -1,51 +0,0 @@ -# Bayesian Machine Scientist - -## Search space - -BMS searches the space of operations according to certain parameters to find the best model. As such, the search space is defined by the set of operations that can be applied in each computation step of the model. These operations are also referred to as *primitives*. We can select from the following set of primitives: - -- **$\textit{constant}$**: The output of the computation $x_j$ is a constant parameter value $a$ where $a$ is a fitted float value. -- **\+**: The output of the computation $x_j$ is the sum over its two inputs $x_i, x_{ii}$: $x_j = x_i + x_{ii}$. -- **\-**: The output of the computation $x_j$ is the respective difference between its inputs $x_i, x_{ii}$: $x_j = x_i - x_{ii}$. -- **\***: The output of the computation $x_j$ is the product over its two inputs $x_i, x_{ii}$: $x_j = x_i * x_{ii}$. -- **\/**: The output of the computation $x_j$ is the respective quotient between its inputs $x_i, x_{ii}$: $x_j = x_i / x_{ii}$. -- **abs**: The output of the computation $x_j$ is the absolute value of its input $x_i$: $x_j = |(x_i)|$. -- **relu**: The output of the computation $x_j$ is a rectified linear function applied to its input $x_i$: $x_j = \max(0, x_i)$. -- **exp**: The output of the computation $x_j$ is the natural exponential function applied to its input $x_i$: $x_j = \exp(x_i)$. -- **log**: The output of the computation $x_j$ is the natural logarithm function applied to its input $x_i$: $x_j = \log(x_i)$. -- **sig**: The output of the computation $x_j$ is a logistic function applied to its input $x_i$: $x_j = \frac{1}{1 + \exp(-b * x_i)}$. -- **fac**: The output of the computation $x_j$ is the generalized factorial function applied to its input $x_i$: $x_j = \Gamma(1 + x_i)$. -- **sqrt**: The output of the computation $x_j$ is the square root function applied to its input $x_i$: $x_j = \sqrt(x_i)$. -- **pow2**: The output of the computation $x_j$ is the square function applied to its input $x_i$: $x_j$ = $x_i^2$. -- **pow3**: The output of the computation $x_j$ is the cube function applied to its input $x_i$: $x_j$ = $x_i^3$. -- **sin**: The output of the computation $x_j$ is the sine function applied to its input $x_i$: $x_j = \sin(x_i)$. -- **sinh**: The output of the computation $x_j$ is the hyperbolic sine function applied to its input $x_i$: $x_j = \sinh(x_i)$. -- **cos**: The output of the computation $x_j$ is the cosine function applied to its input $x_i$: $x_j = \cos(x_i)$. -- **cosh**: The output of the computation $x_j$ is the hyperbolic cosine function applied to its input $x_i$: $x_j = \cosh(x_i)$. -- **tan**: The output of the computation $x_j$ is the tangent function applied to its input $x_i$: $x_j = \tan(x_i)$. -- **tanh**: The output of the computation $x_j$ is the hyperbolic tangent function applied to its input $x_i$: $x_j = \tanh(x_i)$. -- **\*\***: The output of the computation $x_j$ is the first input raised to the power of the second input $x_i,x_{ii}$: $x_j$ = $x_i^{x_{ii}}$. - -## Example - -The following example sets up a search space over four illustrative operations found in Wikipedia pages that are tagged by psychology. These operations are our primitives: - -```python -primitives = { - "Psychology": { - "addition": 5.8, - "subtraction": 4.3, - "multiplication": 5.0, - "division": 5.5, - } -} -``` -We can then pass these primitives directly to the BMS regressor as follows: - -```python -from autora.skl.bms import BMSRegressor - -bms_estimator = BMSRegressor( - prior_par=primitives -) -``` diff --git a/docs/theorist/bms/weber.ipynb b/docs/theorist/bms/weber.ipynb new file mode 100644 index 000000000..ecd2759df --- /dev/null +++ b/docs/theorist/bms/weber.ipynb @@ -0,0 +1,14324 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3ba2ff78", + "metadata": {}, + "source": [ + "Example file which shows some simple curve fitting using BMSRegressor and some other estimators." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "41b221c2", + "metadata": {}, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "import pandas as pd\n", + "import numpy as np\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "import matplotlib.pyplot as plt\n", + "from autora.skl.bms import BMSRegressor\n", + "from autora.synthetic import retrieve" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "343e2f03", + "metadata": {}, + "outputs": [], + "source": [ + "def show_results_complete(\n", + " data_: pd.DataFrame,\n", + " estimator=None,\n", + " show_results=True,\n", + " projection=\"2d\",\n", + " label=None,\n", + "):\n", + " \"\"\"\n", + " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", + " \"\"\"\n", + " if projection == \"2d\":\n", + " plt.figure()\n", + " data_.plot.scatter(\n", + " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", + " )\n", + " elif projection == \"3d\":\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(projection=\"3d\")\n", + " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", + " if estimator is not None:\n", + " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", + " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", + " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", + "\n", + " if label is not None:\n", + " plt.title(label)\n", + "\n", + " if show_results:\n", + " plt.show()\n", + "\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "5bfd6747", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %% Load the data\n", + "s = retrieve(\"weber_fechner\",rng=np.random.default_rng(seed=180), resolution=20)\n", + "X_ = s.domain()\n", + "y_ = s.experiment_runner(X_)\n", + "data = pd.DataFrame(np.column_stack([X_, y_]), columns=[\"S1\", \"S2\", \"difference_detected\"])\n", + "show_results = partial(show_results_complete, data_=data, projection=\"3d\")\n", + "show_results(label=\"input data\")\n", + "X, y = data[[\"S1\", \"S2\"]], data[\"difference_detected\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "89405909", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but LinearRegression was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %% Fit first using a super-simple linear regression\n", + "\n", + "first_order_linear_estimator = LinearRegression()\n", + "first_order_linear_estimator.fit(X, y)\n", + "\n", + "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "f67dbeeb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/sklearn/base.py:439: UserWarning: X does not have valid feature names, but PolynomialFeatures was fitted with feature names\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAGlCAYAAADQ/XDvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d5ykaV3vD7/vWLmqqzr3TE9PDjuzs4ndnZllF4QlKogKPKAcWUU5HMGDeI4/41F5jiCGc8RwRPRRVIIoCPo7Epa4LLts3unJoWemu6d7OlfOd3z+qL5rqjqH6uma2fv9eq041VVXXZWuz/3Ngm3bNi4uLi4uLmtE3OwNuLi4uLjc3LhC4uLi4uKyLlwhcXFxcXFZF66QuLi4uLisC1dIXFxcXFzWhSskLi4uLi7rwhUSFxcXF5d14QqJi4uLi8u6cIXExcXFxWVduEJyE/HII48gCAKCIHDo0KGGry8IAh/4wAcavm4j+Pu//3sEQWBoaKh625133ll9P37kR35k8zYH/O7v/i6CIGzac23fvp1HHnnkhjy/i8tcXCG5yWhra+PTn/40H/vYx+b97Qc/+AEvf/nL8fv9dHV18V//638ll8vNu8/v/u7vkkqlGr63xx9/nDe/+c309vbi9Xrp6uri9a9/PU8++WTDnwvgox/9KJ/+9Kdpa2vbkPVdXFxWhrzZG3BZHYFAgHe9613zbu/v7+fVr341Bw4c4H//7//N6Ogof/zHf8zAwABf+9rXqvf7wQ9+wIc//GEeeeQRWlpaGrq3ixcvIooi73vf++jq6iKZTPKZz3yGhx56iK985Su8/vWvb+jzvfGNbwTgt37rtxq67s3IhQsXEEX3utBlc3CF5BbhN37jN4hGozz22GOEw2Gg4u74+Z//eb7xjW/w2te+dsP38HM/93P83M/9XN1tv/ALv8DOnTv5+Mc/vqSQWJaFpml4vd6N3uaaMAwDy7JQVfWGPF+hUMDv96/4/h6PZwN3s37y+TyBQGCzt+GyQbiXMLcAmUyGb37zm7zrXe+qigjAT//0TxMMBvmXf/kXoOJb/5Vf+RUAduzYUY0v1MYdAP7t3/6NQ4cO4fF4OHjwIF//+tfXvDe/3097e/s8V5oTj/nsZz/LwYMH8Xg81ec5c+YMr3rVq/D5fGzdupXf+73fw7KsNe+hlqmpKd7znvfQ2dmJ1+vljjvu4B/+4R/q7jM0NIQgCPzxH/8xH//4x9m1axcej4ezZ88C8MQTT3Dvvffi9XrZtWsXn/zkJxd9vs985jPcc889+Hw+YrEY73jHOxgZGam7zytf+UoOHTrECy+8wEMPPYTf7+c3fuM3VvW65sZInJjSk08+yS//8i/T3t5OIBDgx37sx5ienp73+K997Ws8+OCDBAIBQqEQP/zDP8yZM2fq7nPy5EkeeeQRdu7cWXVd/uzP/izxeLzufk4M5+zZs/zkT/4k0WiUl7/85at6PS43F65Fcgtw6tQpDMPgZS97Wd3tqqpy5513cvz4cQB+/Md/nIsXL/JP//RP/Mmf/Ek1ttDe3l59zBNPPMGXvvQlfuEXfoFQKMSf/dmf8RM/8RNcvXqV1tbWFe0nk8mgaRozMzP84z/+I6dPn17wYPzOd77Dv/zLv/CBD3yAtrY2tm/fzsTEBD/0Qz+EYRj82q/9GoFAgL/+67/G5/Ot9e2pUiwWeeUrX8mlS5f4wAc+wI4dO/jCF77AI488QiqV4oMf/GDd/T/1qU9RKpV473vfi8fjIRaLcerUKV772tfS3t7O7/7u72IYBr/zO79DZ2fnvOf7yEc+wv/4H/+Dt7/97fzcz/0c09PT/Pmf/zkPPfQQx48fr3MtxuNx3vCGN/COd7yDd73rXQuutxZ+8Rd/kWg0yu/8zu8wNDTExz/+cT7wgQ/wz//8z9X7fPrTn+bd7343r3vd6/iDP/gDCoUCn/jEJ3j5y1/O8ePH2b59OwDf/OY3uXLlCj/zMz9DV1cXZ86c4a//+q85c+YMTz/99LwEgLe97W3s2bOHj370o7jTKm5xbJebhne/+912X1/fvNu/8IUv2ID9+OOPz/vb2972Nrurq6v67z/6oz+yAXtwcHDefQFbVVX70qVL1dtOnDhhA/af//mfr3ifr3vd62ygut5//s//2S4Wi/OeSxRF+8yZM3W3/9Iv/ZIN2M8880z1tqmpKTsSiSy6776+PvuHf/iHl93Xxz/+cRuwP/OZz1Rv0zTNPnr0qB0MBu1MJmPbtm0PDg7agB0Oh+2pqam6Nd7ylrfYXq/XHh4ert529uxZW5Iku/bnNDQ0ZEuSZH/kIx+pe/ypU6dsWZbrbn/FK15hA/Zf/dVfLfsabNu2f+d3fsee+9Pt6+uz3/3ud1f//alPfcoG7Icffti2LKt6+4c+9CFbkiQ7lUrZtm3b2WzWbmlpsX/+53++br2JiQk7EonU3V4oFObt5Z/+6Z/mffec/b3zne9c0etxuflxXVu3AMViEVjYT+71eqt/XwkPP/wwu3btqv778OHDhMNhrly5suI1Pvaxj/GNb3yDv/3bv+XIkSNomoZhGPPu94pXvILbbrut7ravfvWrHDlyhPvuu696W3t7Oz/1Uz+14udfjK9+9at0dXXxzne+s3qboijV7Lbvfe97dff/iZ/4iTprzTRNHn30Ud7ylrewbdu26u0HDhzgda97Xd1jv/SlL2FZFm9/+9uZmZmp/tfV1cWePXv47ne/W3d/j8fDz/zMz6z7Nc7lve99b52l8OCDD2KaJsPDw0DFykilUrzzne+s26ckSdx///11+6y1CkulEjMzMxw5cgSAF198cd5zv+9972v463FpTlzX1i2A8wMvl8vz/lYqlVblFqo9IB2i0SjJZBIATdNIJBJ1f29vb0eSpOq/77zzzur//653vYu7776bRx55hC9+8Yt1j9uxY8e85xoeHub++++fd/u+fftWtH/TNOfFAGKxGKqqMjw8zJ49e+ZlNx04cKD63Evtb3p6mmKxyJ49exbc31e/+tXqvwcGBrBte8H7QkXAatmyZcuGBPLnfp7RaBSg+nkODAwA8KpXvWrBx9fG3BKJBB/+8If5/Oc/z9TUVN390un0vMcu9Pm63Jq4QnIL0N3dDcD4+Pi8v42Pj9PT07PitWoFoRZ71sf9gx/8gB/6oR+q+9vg4GDVjz4XVVV585vfzMc+9jGKxWKdqDUi7jGXkZGReQfYd7/7XV75yleueq317M+yLARB4Gtf+9qC72kwGGzYcy3Fcp+nk8Tw6U9/mq6urnn3k+XrR8Tb3/52fvCDH/Arv/Ir3HnnnQSDQSzL4vWvf/2CyRAb9Zpcmg9XSG4BDh06hCzLPP/887z97W+v3q5pGv39/XW3rbf6+o477uCb3/xm3W0LHUC1FItFbNsmm80ue7j09fVVr5JruXDhwor219XVNW9/d9xxR3XtkydPYllWnVVy/vz56t+Xor29HZ/Pt6L97dq1C9u22bFjB3v37l3R3jcDx43Z0dHBww8/vOj9kskk3/72t/nwhz/Mb//2b1dvX+i9cHnp4cZIbgEikQgPP/wwn/nMZ8hms9XbP/3pT5PL5Xjb295Wvc3J5V9rZXs0GuXhhx+u+8+p/Zjr7nCe51//9V/p7e2lo6Nj2fXf+MY38vTTT/Pss89Wb5uenuazn/3sivbn9Xrn7c9x57zxjW9kYmKiLmPJMAz+/M//nGAwyCte8Yol15Ykide97nX827/9G1evXq3efu7cOR599NG6+/74j/84kiTx4Q9/eF7Gkm3b81JmN4vXve51hMNhPvrRj6Lr+ry/O25Cx7KZ+1o+/vGPb/geXZof1yK5RfjIRz7CsWPHeMUrXsF73/teRkdH+V//63/x2te+tq4Q8J577gHgN3/zN3nHO96Boii86U1vakix2Bve8Aa2bt3K/fffT0dHB1evXuVTn/oUY2NjdYf3Uvw//8//w6c//Wle//rX88EPfrCa/utYE+vhve99L5/85Cd55JFHeOGFF9i+fTtf/OIXefLJJ/n4xz9OKBRado0Pf/jDfP3rX+fBBx/kF37hF6pCdPDgwbr97dq1i9/7vd/j13/91xkaGuItb3kLoVCIwcFBvvzlL/Pe976X//7f//u6Xk8jCIfDfOITn+A//af/xN1338073vEO2tvbuXr1Kl/5yld44IEH+Iu/+AvC4TAPPfQQf/iHf4iu62zZsoVvfOMbDA4ObvZLcGkCXCG5Rbj77rv51re+xa/+6q/yoQ99iFAoxHve8x5+//d/v+5+9957L//zf/5P/uqv/oqvf/3rWJbF4OBgQ4TkZ3/2Z/n85z/Pn/zJn5BKpYhGoxw5coTPfe5zPPjggytao7u7m+9+97v84i/+Ih/72MdobW3lfe97Hz09PbznPe9Z1/58Ph+PPfYYv/Zrv8Y//MM/kMlk2LdvH5/61KdW3PDw8OHDPProo/zyL/8yv/3bv83WrVv58Ic/zPj4+Dyh+7Vf+zX27t3Ln/zJn/DhD38YgN7eXl772tfy5je/eV2vpZH85E/+JD09PXzsYx/jj/7ojyiXy2zZsoUHH3ywLpPsc5/7HL/4i7/I//k//wfbtnnta1/L1772tVXF4FxuTQR7rq3q0rQ88sgjfOc73+HFF19EluWG98q62UilUhiGwd13383hw4f5j//4j83ekovLSxI3RnKTMTIyQnt7u9tygkprkfb29nktR1xcXG4srkVyE3H27FnGxsaASvqoUwz2UuWZZ56pJhe0t7dXs7NcXFxuLK6QuLi4uLisC9e15eLi4uKyLlwhcXFxcXFZF66QuLi4uLisC1dIXFxcXFzWhSskLi4uLi7rwhUSFxcXF5d14QqJi4uLi8u6cIXExcXFxWVduELi4uLi4rIuXCFxcXFxcVkXrpC4uLi4uKwLV0hcXFxcXNaFKyQuLi4uLuvCFRIXFxcXl3XhComLi4uLy7pwhcTFxcXFZV24QuLi4uLisi5cIXFxcXFxWReukLi4uLi4rAtXSFxcXFxc1oUrJC4uLi4u68IVEhcXFxeXdeEKiYuLi4vLunCFxMXFxcVlXbhC4uLi4uKyLlwhcXFxcXFZF66QuLi4uLisC1dIXFxcXFzWhSskLi4uLi7rwhUSFxcXF5d14QqJi4uLi8u6cIXExcXFxWVdyJu9AZeXFrZtY5om5XIZSZKq/4mie03j4nKz4gqJyw3Dtm10XccwDMrlcvV2URSRZRlZll1hcXG5CRFs27Y3exMutz6maaLrOpZlIQgCmqYhiiK2bWPbNpZlYds2giAgCIIrLC4uNxGukLhsKLZtYxgGhmEAIAhC1TIRBGHB+zui4uDcT1VVFEVBluUFH+vi4rI5uK4tlw3DsqyqFQJUrQ1HJBwLpBZBEJAkqfpvR1iefvpp9u3bR0tLC6IoIklSndXiCouLy+bhColLw3EOf13X69xVc++zksPfERbnfyVJqq6taRqCIFSFRVGU6n1cYXFxuXG4QuLSUBy31enTp+no6KCtra0hh7qzxmIWy1xhmRtjcYXFxWXjcIXEpWE4B7ppmmSzWaLRaMMO8FqX2NzbHWFx/m5ZFpqmUS6XXWFxcbkBuELism6c2hDDMLAsC1EUFz34NxJHHFxhcXG5sbhC4rIuHFeWaZoAVRFxUnsbxVqEaSFhcf4rl8tomlbdsyssLi5rxxUSlzXjXOnXWiG1LHbwb9YhXRv0lyRpnrDUWixOmrFTw+IKi4vL4rhC4rJqHFeWk5W10EG7nAWx2oN5I1xlSwlLqVSq3scVFheXpXGFxGVVWJaFYRjzXFlz2YwYyXpZibCUSiUMw6Ctrc0VFheXWVwhcVkRK6kNqaXRQrJZwfu5wpJMJkkmkwSDQaAipHNjLK6wuLzUcIXEZVkWanOy3EF5M1oky+G8bkEQUBSlrk9YuVymVCq5wuLyksQVEpclqa0NceIFK2GtQqIZFjbgkeufpxmFaa6gOsJimma1VX5tjMVp67ISIXZxuZlwhcRlQRarDVkpqz34kwWdJ68kOD+Rw7ZhT0eAYzujdIQ8dXtqZhyBcMS2VlgMw6j+faE+Ya6wuNzMuELiMo/FakNWw2qEJF82+JcXx7gyXSAWVBGApweTjCSLvOu+rUT9yk150C4mLIZhVLsfO8JS2yfMbZnvcrPhColLHcvVhqyU1QjJuckcg/Eiu9r9yFLlEI35FQam85way/LQ7hjQPBbJet4TV1hcbkVcIXEBVlYbshpWIySTGQ1RoCoiAKIo4FUkRpPF6nq3GssJC7jTI11uDlwhcWmIK2suSwmJbduMJItMZjX8ioQsgWXNv69mWoS9ct3jbmUWE5bazsbu9EiXZsQVkpc4pmkyMjKCz+cjEolseLfesm7yr8fHeGE4QVG3kESBiLeSyXQtVaI77AEBprMaPllkf1ewut5LjYWExcmi03WdfD5PsViku7u7Kizu9EiXzcAVkpcotbUho6OjdHZ20tLS0rD1FxOSJy7FefJygs6gwpaIhGnbDCdKqJKAIglcnikA0OKTec2Bdna3B+r2/FJm7iyWfD7PxMQEbW1tC1os7vRIlxuFKyQvQeaOwN0I14ggCNX1HQzT4tnhJCGPTNgnY9ugiAJ9MS9XkyV+aG8bAVXCsm16oz6ifqVuvWag2cTMEQ5YfMiXOz3SZaNxheQlRO1BU5uVJYrivEN/vSx0WOmmTVEz8Sj1wiWLApZlIwpwqCe06HrNdohvNnPHFbvTI102C1dIXiIsFVDfqM66c8XJq4hsafFxdjxL1Hf9wMuWTXyKRGdN8aHLyliu35k75MvlRuAKyUuA2jYni7V8vxEWiSAIPLSnjaF4gcvTBVr8CmXDJFc2ObojSm/Uu+R6rkVSz1yLZCnc6ZEuG4krJLcwK21z0uhphnBdnK4mCvSPpEkXdbZEfdzVG+Ftd7Tz788OkEgLtAT8vOJgOw/ubnUPrFWyns9sKWFxp0e6rBZXSG5RVlMbslGurTPTGi9cvEKqqCGJIqZl861TI9zlS/CWfa2UDJtcJo49OcW5UoRoNEosFiMYDM5LAHAtkvmsxiJZjlphWcn0SCfV2O1s7AKukNySOBXqK21zshHB9oJu8/hwEcWvsrejUgsyPRPn7Giezv2d/OjBfVVhKBQK1TkfV69eBaClpYVoNEo0GiUQCCz6PJtBMx2cG7UXd3qky2pwheQWorY2ZDVtTjbian80o5MsWdzR48U0DSYnpwDYs6Wda3mBbMkg6Km4SQKBAIFAgK1bt2LbNtlslmQySTwe5/Lly3VFdm1tbfh8vobu9WalkRbJcqxEWJLJJH6/n0gk4grLSwxXSG4RFqoNWU0gttEWiSNLhXyeZCJOMBgkFouRLOgYlo3NwgehIAiEw2HC4TB9fX1YlkU6nebChQtks1mefvppPB5P1VqJRqN4PC/NbK/NdPUtJCxjY2O0trZWP4+FWua7wnJr4grJTc5qR+AuhCiK1VhKo9gaVvAJBpfG4uzb2kYgEMCybaZzZe7rixLySCs6CEVRJBqNEgqFCAaDbNmyhXQ6XXWDnT17lkAgUBWVlpYWFEVZdt1bgRtpkSxHrai40yNferhCchMzN6C+1gFJjXBt5UoGP7iS4OS1NJZp4M2Nc3vMZtBq5VreRi0VKBkWW1t8vP5g55qe07ZtZFmmtbWV1tZWAHRdr8ZXLl++TKFQIBwOV4UlEonUFemtl2YL+DfTIWxZVl1tkjs98qWDKyQ3KcvVhqyG9Qbbc2WDv3z8CqevZbEtnWwmhyBJ7I+pvO9Vuzg1liFV0NkW9fGy7VHag2q1TfpKWez1KYpCR0cHHR0dAJRKpaqwnDt3Dk3TiESuZ4SFQqFbpltus4naUhaSOz3y1sYVkpuM9Y7AXYj1WiRPDyY4fS1DRNQoawW29sYolk0uJnLkygbveNnWea9hLazkcV6vl+7ubrq7u7Ftm2KxSDKZJJFIMDo6imVZdRlhwWDwpj2omsm1BVS/jythNUO+5rrCXJoPV0huIjZibgisP9h+YjhBPpshFBDp7u5CkRVsK4dlwaWpPPfviDVkj2t5jN/vx+/3s2XLFmzbJpfLVS2WwcHBagzG+c/n8zXV4bwUzSYk69nPaoTFnR7ZfLhCcpNgWRaTk5NMTk6yf//+hh4g67FIJiYmGBsdRZRVuro6ru9LELCxkcTG7XO9rhxBEAiFQoRCIbZt24ZlWWSzWRKJBJOTk1y8eBFVVauiEovFmj4jrNmEpFEH+3LCAu70yGbCFZImp3YEbrlcJplMNvzwWEuLFMuyOH/+PGNjY7zy8Ha+dDZDXjMJeipfqUzJQBYFblukm+9q2YgDUxRFIpEIkUiEHTt2YJom6XS66gY7d+4cfr+/zmJpJprNIqkNtjeaxYTF6WwMrrBsJq6QNDGWZWEYRtWVJUlSw+s9YPWurZPD03zxybPMFCwO7+7jgZ4OjpVlnr6S4FqqiG0LiLbFXR0Sh7rDCz7fag+cG9EiRZIkYrEYsVjFFafrOqlUquoGO336NKqqIssy8XiclpaWhmaErZZmE5JGWiTLsZCw1E6PBKqFueFw2J0eucG4QtKELFYbslFCshqL5NEXL/PJxwcxRIVoOMRjl1K8MJrjkSPbuLcvysXJLJIk0q5oiOlriA10bd1oFEWhvb2d9vZ2AMrlMgMDA2QyGS5cuEC5XK6mGsdiMcLh8A29Ar6RB/dK2EiLZDkWmsUyMTHB9PQ0t99+e/U+7vTIjcEVkiajts0J1F+9b0RPLOc5llvXsixOnTnHZ58aR/b6OdAVqVoJVxNF/v3EOP/zzQe4szcCwNTUFAPpxu5xs9NdPR5PNcvr4MGDFItFEokEyWSSa9euYZpmNSPMaT650QdVMx2EzWQh1RZIyrLsTo/cYFwhaSJqa0NqzXaHjTpMl7NICoUC/f39jOcsbF+Y3tD1zCZBEOgMe5jIlhlOFNnbGdzQvTYTPp+PLVu2VDPC8vl8NSNsaGgIQRDq4it+v7+hB1Wzvb/NaCE5+1nIYnGnRzYOV0iagNXMDdkoi2SxQ2liYoLTp0+zZcsWuvb08h/jF7Hm3NeybUSoy9BaTkiaMUayHgRBIBgMEgwG6e3trWaEJZNJpqenuXTpErIsV62VaDSK17v4IK+V0EwWAGyua2shnGLdhagVFnfI1/pxhWSTWU1tyI10bTlZWVdGxvB27qQQiLEl6KEv5uP8ZI6dbRKiIGDZNuOZMrvbg/TFfHVrNvPBv9HUZoRt3769mhHmuMHOnz+P1+uts1hUVV3VczSbkDSzRbIUtW4wcIVlLbhCsok4X9TNnBvirFt76DuurDNxk+dTUeJDM9hM0x708ODuVlJFncvTBQTAxqYz7OWn7tuKLF3/0S4nJKsVmY3oUHwjmZsRZhhGNSNseHiYM2fOEAwG65pPyvLyP89mOcicdNxm2Q+srtK+lqWExZ0euTCukGwCtbUhq5kb4hz4jf7B1h7SjiuLUAdPxHUKmklPixcBmMiU+frZKf7LQ9tJFXWms2Vagx7u2x6lI+SZt2ajLZJbycKRZZm2tjba2toA0DStGl8ZGBigVCoRCoWqbjAnhbWWZno/nL00m0XSiPTsWmFZaHpkrbC8VKdHukJyg1lPmxPnR9qoH0jtupZlcfbsWcbGxjh06BDfGtZIF8fY2Rao7m9Li5crMwVOj2V574Pbl1yz0UJyq/8gVVWls7OTzs5OgGqPsGQyydjYGIZhzGs+2UwWgPNZN8t+oPI72YiRArWZlO70yAqukNxAVjsCdy7O/Rt9JepcVaVSKY4dO4bf72fmzCWkOXsUBAFFEpjOlVe0V9ciWTs+nw+fz0dPTw+2bS84jti5AMjlcgQCgU09pByLtpkOyrW6tlaLKyyukNwQ5taGrPULVGuRNIqJiQlOnTqFIAgcOXKk+hy9MT+mFa9kZNUImG5abI/5l13XtUgahyAsPI743LlzFAoFnn/++WpGWG3zyRtJs7q2NmM/SwnL1atXyWaz7N69+5aaHukKyQYzdwTuWtqDODRSSEzT5MKFC4yNjbFnzx4uXbpU96N7+a4Y3zo3xeBMnvagBwSYyWl0hDw8tLdt2fVvZYtks3/sglAZR+zz+YhGo3VTI8fHx7lw4ULdOOJYLLbqjLDV0qyurc1sYeNQ+5t30vwda/JWmR7pCskGUVvw1Mi5IY3IXsrn85w4cQJBEDh27BiWZfHd4xf5i8euMJIo0tPi5eH97fzyw7v5p+dGGZjKY9s2h7eEecfLttIbXf5qdyPqSFzqcWIkta3woZIRttQ44mg0uqKMsNXg1JA00+e0WRbJUpimOa+Z5FLTI28WYXGFZAPYqLkhzlrrEZLaAsN9+/YhiiLfPTvGP18WkLwTeGSJ02MZnrqS4L+8Ygf/4437mMqWsW3oDHtW9TpuRYukGfZQy0Kfx2aMI26mwL9DMwtJLYt1Nq4Vlne+8528+93v5p3vfOdmbHtZXCFpMJZlMTExAUAsFmv4j2utQlLryrr99tur2UGaYfHPL05QNm1ui/kRxIolMZoq8dlnRrh/e5TO8OorsNfSmn4pmu2QagZWenjfiHHEzVbVDjePkMxlIWGZmJhouBXZSJp3ZzcZtW1OxsbG8Hg81SvCRrIWIZnryvL7rwfLhxMFJrMaYQWo6Z/VEVSZympcns5zsGd+K/iV0EjX1nLrvRRZ6/uxEeOIm62qHZpXSFYbrxIEgUKhUPe7bTZcIWkAc11ZkiRV//9Gs9og9vj4OGfOnKlzZdUiCgKCAJUVbaByYFiAKLDmCYe1qcoLHUJOyvFKfxzNdrXbDDTCnSQIjRlH3IyuraV6bW0Wa0kAcBqChkKNGRK3EbhCsk4Wqg2RJKma6ttoVmqRLObKmsv2Vj99MR8vpjL0WDayVOmfNZkps7MtwK72wJr2uZSQOCnHlmXh9Xqr1dvRaHTRArKXeu+uhdiIw1sQ5o8jzmQyJJPJeeOInc/N4/G4rq0VslZxy+fzBAJr+y3eCFwhWSO1tSFz25xsVE+sla69lCsLIJHXOD2WQRQEbt8S5meP9XF5dJLhRAFRELGxaQ96eM8DfSjS2n6ICxVPWpbFhQsXuHbtGocOHSIYDFZnpjsTCGsHRUUikaY7CJqNjT68RVGkpaWFlpaWeeOIR0ZGOHv2bNWicSzzjagmXwvNKiRrSWwoFAquRXKrMXcE7tysrI2aZOg811JrL+fK+r8nJ/jMMyMkixoCAjG/wruP9vKTuyyszi3EiyYdIQ8P7m6jp2Xtbc7nCkmpVKK/vx/TNDl27BiqqqLrel2/qXK5XB0UdebMGQzDoKWlhVgsVm1u6XKdzbDQFhtHPDY2hq7rfP/73ycUCtU1n9ysWo5bRUg0TUPXdYLB4Abtav24QrIKFhuBO5fNsEhM0+T8+fOMj48v6srqH0nz/3tyCMuy2RKp1IJMZct88vvD/Eg7/OQdnQ2riK4Vkng8zokTJ2hvb+e2225b1PXn8XjqgsDOoKhEIkEikQDgzJkzVYtlvfM8bnaaIS7hjCMWBIFyucwdd9xRja/UjiOubT55Iw5357fabEKylhhJLpcDcIXkVmBuQH2p4itRFDc02D5XSPL5PP39/YiiuKAry+E7F6YpaibbalqcdIU9jCSLnEltTLru4OAgw8PDHDhwgK1bt67q8bWDokZGRpiamsLn8zE2NsaFCxeqld3OIXWj0iM3+/CupVn24sRIPB4PXV1ddHV1VXtNOVamkxFWm2q8UeOIm7FlC6wtRpLL5apJEc2KKyQroHYE7kqKC2+ka2s5V1Yt07nyvCwsRxBzemPnfTgWx9jYGPfffz/h8NpSiB0EQUCWZXbu3MnOnTsxDKOuyK5YLFbbrsdisRt25buZNINF4rDQXgRB2LRxxM53udm+A2txbTmpv832WmpxhWQJVjoCdy4baZE4hX4rcWXNZXd7gOeHUnWNGC3LxrJtuvyNy4pKp9McP34cgHvuuachQcK577ssy7S3t9Pe3g5Qd+XrZIQ58ZVoNLrp3XE3gmbKYltJHclcK3OxccS1WXxrdV/eSkLSDN2dl8MVkkVYT5uTjbZISqUSTz/99LKurLm89rZOvnN+hpFEkWhAARsSBZ2eFi93tBXXvWfbthkdHeX8+fPs3LmTgYGBhrqbljo4vV4vPT091bbr+XyeRCJBPB7n8uXLdQdULBbD4/EsutZa93CjaSaLZC3pv6sZRxyLxWhpaVlxMV8zCokTt1mtkDR76i+4QrIgqx2BO5eNDLaXy2Wmp6fp7e1d1pUFFYujbFh4FZHeqI/feuM+/v6pq1ycyiEAR3ZEeffRbYyeeW5dh6Rpmpw5c4aZmRnuvvtuWltbGRgYaNjBu5rPoPbK16mFcFJWr127xrlz56pNDJ0DqpnbTyxFswhJIyrblxpHPDg4SD6fX/E44kY1Sm0kzpngWiS3OGsdgTuXjRASx5WVTqfp7OzkwIEDS95fNy3+rX+c/3tqglRBpyfi5a139/Dq/e187MduYyZXGQ/aFlQRBIFrZ9fu2nKC/ZIkcezYsao7YqkiwhvZImVud9zaJobOWFsns2itvaY2g5vdIlmOlYwjrm0+WTuOuBkztmq9G6uhUCi4FsnNwnK1Iauh0TGS2qyszs7OFbmy/vr7Q3zp+BiSKOBVRAamcvzRNwco6hZvOtxF+wIz1tcifpOTk5w6dYqtW7eyd+/euh9JI6vRG3lIzW1iuFCvqdpZHo0KADeal5qbbTXjiFVVbbrPbK1C4lgkzcxLXkhWWhuyGhoZI5mblXX+/Pll1x5Pl/j6mUl8qkTUX6kyjvgUJjJl/vn5UV57oB2PUm9er7Zbr2VZXLx4kdHRUQ4dOkRXV9e8+zS6rclGHZxzx9rmcjkSiQQzMzNcvnwZRVGqorJRSRRrodkskhttASw2jthJujBNk5MnT1YvCjbbPeQE2le7B8el18y8pIVk7gjcRg3maYRra7GsrJUc+ANTOXJlk55IvdUR8crM5DXG0iV2tNVf4azm0C+VSpw4cQJd1zl69OiiV0tLvZfNOtiqttdUX1/fvJYg2Wy2OmzIia9s5hS+ZhGSzRY1QagfRzwzM8OFCxeIRCJ1CRebOY54rRMbC4WCKyTNSm1tSG3v/0bgCMlaf1xLFRiKooiu60s+PuSVkSUB3bTwiNe/uJppoYgCQc/8j32l4pdIJOjv76etrY177rlnySB1o6ckNkNLkIGBAbLZbLUpZrlcXvcsj7Wy2Yd3Lc3WRt62bRRFoa+vj76+vmrCxWaOI75VGzbCS1BInID60NAQoijS09PT8B9jbcBvtVcg4+PjnD59mt7e3nkxB1jZgX+oJ8z2mJ+B6TxdYQFFEinrJpmSwSv3ts+Lj8Dyh75t2wwODnL58mX27dtHb2/vsu/bRsRI0kWd0WSJsmkR8sj0Rr14lRtnEUiShM/nY//+/QB17pSRkRGAusNpoZbrjaKZYiTN1v13rqttsXHEiUTiho0jXmvDxlwu19QNG+ElJiS1tSHZbHbD0gOdL/BqhMRxZU1MTHD48OFFCwwXEpLRZJF/6x/j+EiakFfh4QOVeesf/fpFrqWKlccJAod6wvzCK3YsuO5SwXZd1zl16hSZTIb77ruPSCSyotfUaCGZzJtcPD1FsqCDICAAW6NeXrGnlbD3xn2Va78zc2d5ON2Mp6enGRgYQFXVqkXjBIEbRbNZJM2yF1g+ZrMZ44jXKiT5fJ7u7u51PfdG85IRkrm1IRs5fMr5ApumuaKW2rWurKNHjy6ZlTVXSIbjBf7bF08znimhSAKmZfPi1RRvONTJX77zMM8OpYjnNLZGvdy7PbpoW/jFYi+ZTIb+/n78fn+1a+9KaaSQaKbFubhFpMNkR1sli8qwbIbjBU5dy/DArlhDnmc9CIJAOBwmHA5XC+ycOojh4WHOnDlDMBisikoj4ivNcng3m2trtcH/5cYR67peN+JgreOI1xojaeY+W/ASEJLFakMkSULTtA15TufHvZKYw3KurIXWrl3308+MMJ4p0RnyIM720cqVDb55doofPtTJq/e3r3jPcw/90dFRzp07V+1vtZYAeaOEJF4wSWsW+yLe6j5kUSAWUBlOFLlnm3lDXFyreT2SJNVd9Tp1EIlEgvPnz6Pr+rz4ymre42ayAtZ6SG4U680iW2gcsZMNNjIygm3bqx5HvB6LxA22byJLtTnZ6HG4y6UA17qy7rjjjuqV0HLUWiS2bfP0YAKfIlVFBCCgSuRKBi+OpDm8dWVuqNp1TdPk3LlzTE5Octddd1ULwlZLI4XEtsGyKuN/axEFMCywmidcsCi1dRC1h5PjpweqouLEV5aimWIkN7tFshS144i3bt265nHE6wm2u0KySSw0AreWjRQSWDooPjcrazVpiHNdULJYGY27EPIq5q07h36hUKC/v786XXE9KZKNEBLdtLBsaA0oBBSbmZxGx2yygG3bJPIaezuD+NXmuRpeCXMPJ6eBYSKRqI609Xg8dfGVuW7SZrNImmUvsLF1LWsdR7ye6YiukNxg5taGLBZQ38gOvUutPzY2xpkzZ1bsylpoXUegBEHgVfva+ecXrqGbFopUEZlU0cCnShzdufK4gSAIZDIZBgYGVtSSfqVrrrntStmgfzTDwHQey4KIpNHpr8SAhuIFVFmkqJm0BVUO9zR3RstKqG1guGPHjrqsImcMsdMm3wn+ghsjWYwb6WpbaByxExurHUcsiiIej2dV44idBqRu+u8NxKkNqT1oF/uhbbRFMte1tVZX1lzmWjo/dV8vJ0bTXJzKVy0Tryzyrvu3sat9ZV8+y7LI5XIUi0Vuv/32hmWIrFVINMPiWxdmGJjKE/UrSKLA+ekSVsHmx+9sIVnUyZUM2kMqu9oCtPibY0Z4I5mbVVQul6vxlbNnz2IYBrZtc+3aNTo7OzdsQNRKaSbrCDa319bc2JgzjvjKlStkMplVjyN2039vELVtTlba9XMjW71D/YG/HlfWQuuWdZNcySDgkWgNqvzp/+cw3zo/zdmxDEGPzEN72rhj68oGSZXLZU6cOEG5XKa3t7ehaYZrFZKrySJXZgr0xXyocuUwkKMejids0iWdl29yhtZmHJhzJw/m83meffZZstks165dq/roHYtlM6q2m01ImqWjszOOeHp6utrSZTXjiG9kjORjH/sYv/7rv84HP/hBPv7xj6/4cc3xTq+Dtc4NuRExEtM01+3KqmU6W+bPvj/Gdy+WUV98mgNdId7zQB93b2vhLXd085Y7VicCyWSS/v5+YrEYHR0dDf/hrVVIkgUdy6YqIlCpg/EqMJ4uN3KLNyW1Y1dvu+02FEWp+uidqm2v11s3IGqlrpS10oyurWbaD1zP2pp7UVDbfLJ2HPGFCxfYsmXLDev++9xzz/HJT36Sw4cPr/qxN7WQrHYEbi03QkiuXr1KNptdlyvLoaiZ/Pd/Pc258QyiDQrw/NUUFyZz/Mnbbuf2LSsfZWvbNkNDQ1y6dIm9e/eybds2zp492/AsoLUKiWdWQOa6S3QDgp6bK6i+0TjtfWp99M4cj9r4Sm0NRCQSafgh24wWSbMJyUJxm9qki7njiB999FG+8pWvIEkSH/rQh3jjG9/Iq1/9avbu3dvw9zqXy/FTP/VT/M3f/A2/93u/t+rHN9c7vUKcgLqmaWsSEdhY11Y+nyebzVIsFjl27Ni6RQTguxdnuDiZo8Un45ch6JFpD6pkSwaff250xesYhkF/fz/Dw8Pce++99PX1VWNJjX4/1iok26I+Yn6F0VQJ07Ir2VlFA1G02dPR3NkrNwrnfV3oe+/M8di7dy/3338/DzzwAFu2bKFUKnHmzBkef/xx+vv7uXr1KrlcriEXEG6MZHlWkrXlDGXr7e3l7/7u7zh+/DiCIHDPPffwr//6r9xxxx189KMfbfje3v/+9/PDP/zDPPzww2t6/E1nkaxnBG4tG5W15biyVFWlr6+vYb7qC5NZABRJxGnZKAgCHkXk1FhmRWtks1mOHz+Oz+ebV6W+2jbyK2GlQmLZNiPJEpOZMpIosC3q5ZV7W3niUoLhRBHbBtmGAy0CO1pvrO+/WVnNZ+XxeOqK65wrXsdiEUWxbgzxWuaku66t5VlLHYmmaei6zm//9m8jSRKlUolisdjQfX3+85/nxRdf5LnnnlvzGjeVkCxXG7IaHIukUVdStUV8d9xxB9euXWvowdziU7CpFOZRs65hWrT4lvd/X7t2jbNnz7J9+3Z279497zXfaIvEsiwKhQKq18d3L8Y5OZZFNyxsIOyVeXB3K2+9u5vxdBnTsvFYRUavxJvqqnczWcoiWYraMcS9vb11XXHHxsa4cOECPp+vLr6ykthZs7m21lr8t5GspY7ESf113luv17smoV+MkZERPvjBD/LNb35zXeveFEJSWxuynhG4tTgfqGma6w4y53I5Tpw4UZeVNTEx0dCD+VX72vnMMyOkigaKXXlPClrFovqR2+cPlXKoTTu+8847aW9fuGXKStrTr5bFhKRYLHL8+HEymQzXSgon0iq9sRBbYkFkWWYyU+b7l+JsiXjY2VYJKqfTBiNNUMndTNXksP4MstqK7J07d2IYRtVauXz5MsVisVq/EovF5mUUObgWyfKsRUg2el77Cy+8wNTUFHfffXf1NtM0efzxx/mLv/gLyuXyivbc9ELSyBG4tTRKSBbLymr03Pa+Vj//7TV7+N/fGiCRBS2noUgibzjYyY/dtXC21mqq1Bs9zXCxNePxOP39/XR2dnL48GE+/9wIvkIaLZ/mcmISj8dDwB9goiQxFM8v2PLeZeMETZZl2tvbqxccpVKp2mPq1KlTWJZFS0tL1WJxDrlms0iaUUjWUiS50cWIr371qzl16lTdbT/zMz/D/v37+dVf/dUV77dphWQjRuDW4qy11jjJXFfW3ID6RsRg3niokzt7AvztV55k174d3NUbZX/XwoVo09PTnDx5ku7ubvbv37/qZpCNoFZIajPF9u/fz5YtW9A0DUn10hoT6GnxYhomhUKBfD5PKpnmxf4ZlFTl0PJ4PBta93OzsVbX1mrxer309PTUjSFOJpN1UwdjsVhdN4lmoBmFZC3utrmurUYTCoU4dOhQ3W2BQIDW1tZ5ty9FUwqJbdtkMhmy2Sytra0NFxFYWWPFxVjIlTWX9aYXT2ZKfOXUJNdSRXpafLzhYCc9LV7aQx7ubbd5+O6eBS0p27a5dOkSQ0NDHDx4kJ6enhU930YG2w3D4PTp06RSKe69915KgpcLkzk8osWOmJfBeAHTspFkiVA4hOjxs00N8/L9LYTsAolEglQqhWVZnDt3bkNme9ys3EgrYKEeU04bF+czdoZDOWOIN6sosNmExLkwbjaLpFE0nZA4VkgymeTKlSs88MADG/ZcaznsV1pguJ6YQ/9Iml/50mlSBR3bBkGAf3pulI/92G3cNVuxvpAAaprGiRMnKBaLHDlyZFVtFTbKtVUul3n66adRFIU77rmP71xKcXZ8glzZxCPB1hYvnUGVy9MFQl4Jw7IpGzZ3bw2zf0srktjGtm3bSKfT9Pf3oyhKdbZHre9+I2ojmpkbZZEsRW18ZWxsjIMHD1ZjLAMDA5RKpWrF9o0eQ9xsbe2dc2atMZIbyWOPPbbqxzSNkDhzQwzDwLIsFEXZ0IJBWJ2QLOfKmstaXVumZfPRr18gWdCJ+hVEodLdN1nQ+ejXLvLPP/cyYL6QJJNJTpw4QSQS4dixY6u+Emx0TAcq7Vempqbo7e1l3759fP3sFM8OJekOe+iJeMkUygxMF9jfGeBV+1q5MlNAlUT2dQW5rSuIVNO92ImN7d69u7q204L99OnTWJY1rwX7Rh2yzRALaLa6Ddu2q9Mgnd9G7QwPp2K7to2L3+/fsNfQbBaJ89tai0XS7J1/oUmEZKHaEFmWm0ZIVuLKWmjttRzM5yeyjCSKBD0y4uyPTBQEQh6ZsXSJM+O5uniGbdsMDw8zMDDAnj17qgWGq6Wxs0NsLl++TCqVorOzkwMHDpAtGZwey9IeUIn4FCzbJuhV6EJgNFXitQfaObZEt+K5r2lubUQul6uOuD11foC8rRIIhdnaHmPP1na8nlvLDdZs2WMLBdt9Ph9btmypVmzXfkaXLl1CUZQ68W+kq7LZhMQ0zTW56G9Ue5T1sulCMncEbu3gqY0O3q3kKtxxZW3bto09e/as+Mu51it83bSx7IUHONl2ZT6Hs7bjl04mk7zsZS8jGo2u+vkcGhVs13WdkydPksvlaG9vr15NFTSDsm7SGqg/LPyKSDxvVVOZl2Kxw7PWd6+0dHKFBBOJDMXpIs9fHSLaf5F7tgbpbK90ZL2RLpaNohktkqX2U/sZ9fX1YZpmNb7itFoPBoN18ZW1uqaceEQzfcZr7cCRy+Vci2QpFhuB6+BYCxv5g1nKIlmtK2suaxWSfZ1BogGFRF6jxadUX3uubBLxyRzoDvHMZZFcLsfx48fxeDwcO3YMj2d9abKNCLY7lfPOfPcLFy5U14z4FEJemVRRrw6hcmanBFSJ6DKt4FfyHSjpJs8PpynqNge2tiEKAmXDZHgmT8lbKYAcHa20k1nNJMJmpVmExLbtVdeRSJJUff/h+hji2o64kUikriPuSl+v851rNiFZ65jd9Vwg3ig2RUhW0ubE8fFvZNBsMSHJ5XL09/cjy/Ka276vNUbiUyX+y0M7+INHB0gWdGRRwLBsFEngvQ9uJ+iRsW2bkydPsn37dvbs2dOQA2W9FsnExASnTp2qq5yvdZd5FYn7t0f5yulJRlNFQh6ZTFEjVzZ5xd5WIiuozl9O6KZzGomCxtYWX9Ut6JElokEvWUHkodt2IgrMm0TodMptbW3d1Eyj1dBMrq1GBP4XGkPsFEbWjiF2LgCWioE53+NbQUiKxSK9vb0bsKPGsim/GOcLsNzgKVj7B7ASFhKStbqyFlp7pQfzcLxA/2iagEfi6I4YP3pHN+1BlX954RpD8QLbYn7eencPL98Vqw412rt3Lzt37lzT3hZirRaJZVkMDAwwMjLC4cOH6ezsBCouuDPTGgOJPP6rl9jTEeCevihvvqObZweTpIsafkXigZ1R7t+x/BXXSg4pw7KxF3ALOmJs2TaSKBIOhwmHw2zfvr2uktvJNHKuhJ1Mo9rnbpYDvJlcW422ABbqiOuI/9TUFAMDA3g8nrrAfW18pRmFZK0XxLlcrjoyoJnZtEuv5Q4u50tgGMaG1QvUWg3rdWUttPZyQmKYFh97dID/9+Q4mmEjCBDzK/x/33yAB3a1cmxXa/W+xWKRZ555Btu28Xq91VGrjWItwXYn3bhUKnHkyJGqL9e2bf7fExN883IBWRJoV3S+dX6GcxNZ/tP927hza4RsSUfGxKtIq3ZZLEbUp+BXJTIlo2rh2LZNuqhzoCuIIs0/WOZWcjuZRs6VsCAIdW6wZqJZhKR2IulGIAhCnfjXjrJ1UsGDweC8oH2zvD+w9t5fbtbWOhEEYcMztxyroRGurLmsxLX1T8+N8qX+MWRRIOyVsGxIFHR+7ctn+df/fB8ds+1BZmZmOHHiRDUD6qmnntqQKvTVrJlOpzl+/DiRSISjR4/WuYOGE0VeuJoi6pMIqiIdES9dYZuLkzmeHkzwljt7iPoVNG3lwrXQoaCbFldmCgzFCxgWbIt62d7q48JknlzZRJVFsiWD1oDCno6VZb7UZhpZlkU2myUejzM2Nsb58+eRZRmv10s8Hl9XQHi9NKNFcqP2M3eUraZp1TTjc+fOoWkaAMPDwwtalZvBemIkrpCskxsxVz2dTjM0NLRuV9ZCay93MH/x+BjY4FMqXzBJqAxuypcNHj0zybvu7+Xy5csMDg5y4MABtm7dCmxMzcdqXFtOJ+Fdu3axY8eOeT/SsVSRom4S80rYjptBEGjxK1yYzK35EKzdn2nZPHk5ydmJHKokIIowGK+M5723L8JERqOomexq87Ozzb9sMH8hRFEkEokQiUTYuXMnuq5z9uxZSqVSNSDs9J2KxWI3dG56s7jYYPOD26qq1k0cnJmZ4cyZM2QyGYaHh+dZlZuRXLFWIXHTf5dhs8fhmqZJIpEgn89z5513NmT4VC0rOexnshryHIe+KAgIAkyki7zwwgsUCgXuv/9+wuHrExA3qi/WcmtalsX58+cZHx/nrrvuoq2tbcH7ybMuJMu2oea8M0wbj0+sutFWc+jOE6t0iQtTObrDKr7ZLDDDshmKF9nZ6ueH9rYutMy6UBQFv9+Pz+djz549dW6woaEhJEkiGo3S2tra8LqIuTSTRbLRrq3VIAgCqqoiyzKHDx+uWpW1yRUej6cqKjdiDDGsLUbizI5ZTYeKzaKpLRJZljeklsRxZRmGQXt7e8NFBFbm2trTGeDEaAZvzaFgWjaWZWMmryG2t3D06NF5X/TNsEhKpRL9/f1YlsXRo0eXDADubg8QC6hMzuRomx1xUNAM8prBa7at7b123h/nAJ3JaeimXRURqATVfYrISKrIwZ6N+/E5SSJOQHjr1q11fadq6yJqW7g00g3WTELSzC3ka63K2jHEyWSyOobYabUTjUYb/jk5uDGSTWQjLJLarCxFUchkVjZdcLWsZHDWI0f7+JV/PU22bOCVJSzbpqybxDwWP3r3Tvbv2bngY2/0NMNkMkl/fz+tra0cPHhw3g8tU9R5bjjFwFQOjyxy+5YIbzjYwT89mWI4rZERcsiSwD3botzX15iceFEU6qwdB9OyFwyqbzS1fad27dpVrYtIJBLVTLuWlpaqtbKR7UFuNDdTC3lnDLFjTZfL5XmfU23WXqPclW6MZIO40a6thbKyrl69umGuM+eLvJSQvHJvGx9+037+8nuDTGbKWJbJgRab33rTIQ5sX3jGiLP2Rlgkc9e0bZurV69y8eJF9u7dy7Zt2+a9llRB5+9+MMzAZA6PImFaFsdHUjy4u423HQpzaTLP1r5uusIedrcHqm6v1eI8r2ZUfpDdYQ8Bj0QirxGbrZbPl01M26YvtvkFhnPrIvL5PIlEotp+XVGUOvfKat1grkWyOKtxI3k8nrr4SqFQqAbuh4aGqhcIzue01viKaZqrdqE53xs3RrJOGtUmZbGsrI2MwTg/rOVaNbzxUBfHtgX49tPHCXk9PHTfXcuOvNwIIZlrkZimyZkzZ4jH40u2X3nqSpyLkzl2tQeqlkC6qPPUlQRtO2Vu71C4Y+/CsZTVMJ3TOBkXGHz2GoossqcjyMHuIGfGc1yeKYANqiRye0+Y7a3NlXdfO95227Ztde1B1trJuNmEpFn2AmvvsyUIAoFAgEAgUB1DnMlkSCQSjI+Pc+HChWrxqtPGZaXisJYYSaFQwLZtN0ayXhqR/rtUgeFGCsliExgr7SRmXTNcrwg/1LfyrLGNEhJnTWcUriiKHD16dElhOz2WJeiR69xJEZ/CRKbEtSxEW9bvgkvkNb55Ps6VLBy2oaRbPHE5wb6OAK870EY8r2Pa0B5U6Y54qlXti+GkDQ/GC+imzdYWLzvb/Cuqrm8Ec9uDrLWTcbMc3jeTa2s1iKJIS0sLLS0tANX4ytwxxM5ntdQFwFrntQOua2spNtq1tZICw42YYujgvD7ncJ7JlfnE9wb5+tkpNMPiyI4ob9gmoBam6irCV8JGBtudmpWuri4OHDiw7A9SFitt7muppoM2qKPw+ckcUzmNLh/EAkolgOpTuDxT4LbuELdvCS+/yCymZfPccIoLU3n8ioQkCBwfzTCeLvPg7hgh743/SSzVydip4p6bZdRMVkAzurY2Yj8LxVecC4AzZ85gGEZdG5fayYZrnY4oSdK6++jdCJraIlmrkKy0wHCtrd5XgiAIVaHKlQ1+7tP9DM7kEUQQEPjuhWmevgx/96476OxsX/XaG7Xv48eP19WsLMcdvREuTuUp6ZUqdYCZnEbIK7Mj5sHWtXXvaSxdJuCRydScmx5ZxLIhWVjd8LCpbJnLMwW6Q57qfmMBheFExUI5vIwobfQBvlCXXOcq+MqVK9WrYK/Xi2maTdHl9la1SJZj7gWAEwdzMsKcdPBYLIau62uejrjZn+9KaGohkWWZcrm8qsesplfWjSh4tCyLr5+aZHAmj0cREaiYyF4ZNEvkn/unub1vdULSaIvEMAzOnj0LwD333LNsK5DJTJl0UactqHJkR4xLU3lOXktjWZUW+EGPxGsOdNAdKBKPr98iCagSZeP6/JXq/9qgyqv7kaWKBoZpV0UEKpZTQJUZT5eWFZIbTW0V9549eyiVSiQSCcbGxigWizzxxBObXmzXbBbJWlNt18PcOJiTDp5MJrl27RrZbJbLly+TyWSqVstyzUFvlhbycAu5tmpdWXfeeWe1d1Kj1l8LzoHfP5quZKraFoZpIksyoihi6CbPDqXWtG6j0n/z+TzHjx+vBg1rCx/nkisZfOHFa5wYzVDUTQIeiSM7orzjZT3c09fCSKKAIons7wqxs83PyMjImvdl2zYlw0KVRPZ0BLgwmSWrz44fsGzG0yVa/Ap90dUdnE4B6FzLQp8jLs2K1+ulp6cHWZYZHh5m3759JBIJJiYmNq2TcTO52aA5hlrVpoPv3LmTp556is7OTnRdr8ZXwuFw9SIgHA7P2/PNkrEFTW6RrGaC4Vp6Zd0oIQmoArZtYRqV6mhh9jCzbIj4Vv8RrGcefC1TU1OcPHmSrVu3snPnTr7zne8saunYts0/v3CNJy7F6Qx7aAsqpIsGXz8zhSKJ/NidPdyzraXuMWt1wV2YzHF8JM1MXiegStzeE+Jl2yL831G4Ei8iSyKtAZWX74rRsoLWJ7ppEc9XXGyxgELYKzOV02gPqoiCQLZsYFoW25ogbXilOFbAejoZN4qXqmtrNViWVc30AqqWZTKZ5NSpU1iWVddux+fzUSgUNrTe6BOf+ASf+MQnGBoaAuDgwYP89m//Nm94wxtWvdamCslyHWdXkv67nrbvzpX9Rn3xRFEkm83SbUwgAqYgogiVQ8AwK91+33S4a03rrse1Zds2ly5dYmhoiEOHDtHd3V03unchxtNlTo6m6Qp7qod3W1DFsm2eupLgNfs7CM4JVC/3A1jo8z83keMrp6cwLYuITyFV1Hn03AxHd0R4oNNm521teD0qPRFvdUDWUlxNFHn+aop4TgNBoDWg0BPxMJ4pM5wsIlCJtxzqCbNtldbNZrLQ57RUJ+Ph4eG6mohYLLZsmvlq9tJMB3czCsncrC3Hsuzp6akmWCSTSeLxOCdOnOCDH/wg+/fvx7ZtxsfH6e5evK5srWzdupWPfexj7NmzB9u2+Yd/+Ad+9Ed/lOPHj3Pw4MFVrdXUFslS6b9rcWXNxflgN+KL50yAvHDhAq84uAu9ReSTTwxR0q8LwA/tbeMdL1tZULuW9QiJMwo3n89z5MiRao56bQuShUgVNQq6SWe4PoMk6JGJ5zXSJX1BIVnNPk3L5vmrKWzsai1IlMq0yFNjWXYAe9r9K85imclpfP9ygqJu0hWpHJqTmTJF3eKh3bHZscY2LT6F1oCy4iu/Zrj6Xok7ablOxoFAoK4mYq2tQZrRIrkR/bNWw1J1JLUJFtu2bWP//v386Z/+KZ/97Gc5deoUW7du5cCBA7zmNa/hN3/zNxftcbda3vSmN9X9+yMf+Qif+MQnePrpp28tIdnICYbO+jC/1mO9OMV85XKZHTt2sGvXLnbtglftb+db56bRTIv7d1TahYhzpzCtgLUKiTMKNxAIzOvhNTddeS4xv0pAlciUdKL+61XYmZJO0CMvWIOx1OFSLpe5fPkyPp+P1tZWfD4fubJBIq8TnbNW1K9wabpAbpVeyKvJIumCzs72637mrVEfV2YKxHMad/Y2dqbLjWY1h/dCnYwdN9j58+fRNG3NnYxdi2RpHK/HSoXa6/XyIz/yI1y6dAmPx8Pf/M3f8J3vfIdvf/vbGzbkyjRNvvCFL5DP5zl69OiqH9/0rq25QuK0MG9E23en+V4j4yT5fJ7+/n4kSSISidR98Hs6guzpWH8WxlpiD+Pj45w+fboqbKvt4dUZ9nBXbwuPXZzBtCqZWemiQaZk8pY72gl65n+VFtunM8skEAiQzWYZGBjA5/MRiEQxyhZFPHX1HCXDQpVFFHt17dNzZRNlgawuWRTIlTcuNnYjWG+yhaIodHR00NHRUR1t67RwWW0n42a0SJpJSGpHiq8GJ9gei8V461vfylvf+taG7+3UqVMcPXqUUqlEMBjky1/+Mrfddtuq12l6i8SJkZimydmzZ5mamlqzK2sutbUejWBycpJTp06xZcsW9u3bx/Hjxzek3mM1FollWVy8eJHR0dFlJz/WHvyGaXF6LMuFySwCAvu6gvzYnd0oksALV1NMZssEPTJvPtzF6w8uXEy50OHixLR27dpVHaM6nioyEU+iFTMEynFOXDNJtfhojwSRVR/jeZM9HQGiqRW95CotPhndsLBsu1rtbtk2umUtG6Q3LZuxdInpbCVI3x6qxGWahUZmSq23k7GbtbU0zvmyljqSjU7/3bdvH/39/aTTab74xS/y7ne/m+9973urFpOmFhInRpLNZjlx4kRDJxg6NKIo0TmsR0ZGOHjoEN8bNfnVv3qW0USevmiR97/Ky8MHGteqfqXpv+VymRMnTqBpGkePHl02ldBZ1zAtPv3MCI9fiqPN1m+oZ0Ue2t3Kf7q/l9cf7CRTMmgNqEtWgtdanLZtV9+jO++8k7a2NqbSBb5+Zoor8QJlwybs9XJ47z5iPUXOjCY5P57B0KfpCkps726lILBs8kUirxHP68iSQFfYQ3tIZThRpD2oYtswk9foDKpLZmiZls0LV1Ocn8zXTf/b3xkgZNs0wxG1kYf3Yp2M4/H4gp2MN6NuYymaUUici9bVkMvlGhYPWQxVVdm9ezdQqSF77rnn+NM//VM++clPrmqdTXdtLYWj4E8//XTDJxjWPsd6LJJSqcSJEyfQdZ2jR4/yl0+O8Y/PzNZP2DYDMyV++Yun+Z0f2c9P3NXTkD2vxCJx3EctLS3cfffdK4oBOQf/iyNpvjcwQ2tAJeytXLlnijrfG5jh9i1hXtYXrXbcXcl6uq5z4sQJisViVdB0w+T/nprk/ESOLS1evLJIsqDz/UtJ3nR7By/f20mqoOORIEiZdCpBIQHPPfcckUikeog5vnzTsnl2KMWpsSy5soEoCHSEVA52B4lkNSYylcLWXW1+7u6NEF5CAMfSJS5M5mkLqNXMsIJmcmEyT59i0hNujnqTG2UFLNfJ2BkmNTk5SSwW2/RAd7MJyVoaNkKlaeONLki0LGvVReDQxBaJaZqcP38eqOQ39/Q05hCey3qEJJFI0N/fT1tbG/fccw/TeYPPPTeKQKXi2jItbGx0y+bPvnOZN93etepK7IVYTkhGR0c5d+4cu3fvZvv27avKRrIsi5OjaUzTrooIQNinMJUrc3I0w8tWOFPEiT899dRTBAIBjhw5Uj1kriaLDM4U6I158SuVr2F7yEPZtHlhJMPd21pqXEkhOjvaGBsb4/DhwxSLxTpffiwWI0mAZ8Z0YkEPO0M+TMvmWqrMyWtZfuyOTiwq70HIIy37fkxmy9hQl17sVyVm8jBTMOgJb9zkw5WyWe6khToZnz9/nlwut+ZOxo1mrQf3RrFWi22jx+z++q//Om94wxvYtm0b2WyWz33uczz22GM8+uijq16rKYWkNisLqBbxbARrERLbthkcHOTy5cvs27eP3t5eBEHg+MgMumnjkWd/4EKlr5YiCSQKOldm8uzvWn9L6MWExLIszp07x8TEBHfffTetrasbN1t1bVn2gtlkgiCgr8INmE6nKRQK7Ny5kz179tQdfLmSgW7Z1Xn1DkGPRK5koBkW8gJ1Ik4DQyelNZ1OE4/HefbUNcbSZcSoDyMYJBgIsKXFy3CiyGiqzP6ulV/ZNdE49EVplpntTlNBWZbZt2/fmjsZN5Jms0jWOtRqo1ukTE1N8dM//dOMj48TiUQ4fPgwjz76KK95zWtWvVbTCcncrKzvfOc7N6T6fKXous6pU6fIZDLcd999RCLXU0h9ioQwO7iv9qdi25V/r6SAbiUslA1VKpU4fvw4tm2vOY7krHugO8STl+J1jRhLuoltw23dy/eism2bK1eucOXKFVRVZe/evfPuE/EpeGSRXNkg5Llu+WSKBl0RD54FLLe5B1CtL78t7sUX0/ChkZt1vQCkLC9jk7Ajqqy4/qQz5OHcRI6iblaFrqhXvoOtvua40m2mAHftXtbSybjR3CpCstGurb/9279t2FpNEyNZLCvrRjRWXOn6mUyG/v5+/H4/x44dm5cSeXRnjKhfIVnQcTTDtmwsBG7fEmJbrDE54HPFz3Gxtbe3c9ttt63ZrHcskvv6Yjw/lOT4SLo6Z8QwLe7a1sLL5rRBmYthGJw+fZpUKsWBAwe4cuVK3d+LWuW97o362NsRoH80TUew0ucqWdCxbJt7+1qQFqmvWexKfGvUy4sjGl1tEVqiLdiWTSpXoDidoZCa4cknhwgGg9XYylyXS7qoE8/riAK0BlX2dgS4OJkD5ztq2+ztDBIu5VbyVm44zSYkCx3ci3UyjsfjdZ2Mnc8kFAo1RABuFSFxe22tklpX1gMPPFDXuqFRUxIXY6VC4sQdlqrD8CoSv/+Wg3zoC6co6SZQ6YbbHlL48JsONGzPzoFv2zbDw8MMDAzUudhWSzyn8cxQkmevmlwVkjx8OMz7HtrBU4MJ+kfSANzZG+HYzlZ8S1hVhUKh2gDy2LFj5PPXs54mMyUeuzDDhanKQby/M8h921vwKyLnJ/PECxpRn8L9O1q4Y8vC7r+lXtuBrhCDM0UGZ4pEAwqGaZMqCbxszxZed1s7lqHPc7k4V8VjZZWLcY1c2ai0UfEr1RjNRKYEQFfYS0+Ll8sDU01zgDcLK41J1HYyhuv9ppw0Y6AhnYybTUjWsh8nqeFmmI4ITSAkyxUYNmJK4lIsJyS1rVjuuuuuZdPxXr67lf94/xH+/cQEF0enaPeYvO8NL2vo9D2n9uXUqVPLjsJdjsvTef7isSuMJovkcgb9yWmeGinyC6/YycP7O3h4/8rSluPxOP39/XR3d7N//35EUayOCk0VdD7zzCjDiQJtwYoV98SlOMPxPO++bwuv2NtGUTNp8SsLurRqcYRpJFnk9FiWyUyZaEDhtq4Qr7utjZNjWcZTZTyyyMt3Rblja7jS8VdV62Zz53K5Sl+jK+M8OZwj5FXpjgXxB4JkivDsUIo3HmxnW2z597VsWIgCdVMiN5pms0jWspe5/aacFi61nYwda2U1nYybTUjWY5G4beRXwPj4OOfPn1+ywPBGdOhdbP1CoUB/fz+CIKwq7tAZ9vLeB7czPCwwMzPT8BGumqZhGAbFYpFjx46teYKaZdl89tkRrqWK7GwLkBAK+AMqEzmNzzw7wod/ZD/yMoejbdtcvXqVixcvsn//fnp7e6t/c9J/T1xLM5wosKcjUHVZRX0KF6eynBrP8uDu1iXTcWvXg4r4ffXMFLmySdAjMZnVuDRd4FV7W3nDbR2UdBNJFBY92GtdLkNakD6yxFSTXC7HxPg4hmFwFR/dcoH79vYsGiCeyWmcn8wxmS0jItAX87G/K9iwWNhSNJOQNOLgFgSh2sl4x44d6+pkfKsIyUZnbTWSTRWSrq6u6rS3xdgs15bTYr2np6d6hb2WtRtd2T49Pc2JEycAuPfee9f1g7mWKnJlpkBnyDt7wAsIQHfYy8jsxMClWrpYllWNay1kFTlCMpooospCXdxDEgUE2+KJEwNsC1hs6Yghr+DHZpgWzw5V5qHsar8ec5rIlHl2OMW+ztUd5HnNxOtRCIeDhCMRsG3KZY2z1+JMJ1I888wIHo+n6pJxPs9kQeeJywlSRZ0Wn4Jp2xwfTZMq6jy4O3ZDrJNmEZKNELW1djLeyG7ea2UtQmJZlmuRrBRRFJdtZX0jgu21sz0sy+LSpUsMDw9XW6yvlUZOMqzNhNqzZw/nz59f94/XsCrdb50DXhAqGWayCKZdqfBejFKpRH9/P5ZlcezYsQU/R0dIwj4Zw6xfq1gscen8WQoBgS99N4EsSfR2trK9p53t3W20hOZfiQmCQLZsMpXTqi4yh/ZgpYJ9OqfRt4q5Il1hD8OJ0vU2KoKAICvEWlq490A7vS2euivjYrGI1+vlQtxgoiCxp+t60D7okRlJFpnIlOnd4Jb0zWSR3IimjSvtZOyUCjSTkKylriWfzwO4MZKVsJIfwo2IkZRKlYCq01KkXC5z9OjRZa8Gnh9O8pePDXLiWpqIT+Gtd/fwcw9srxYdNqqPl2EY1ZTj+++/H4/Hw/nz59d9mGxp8VWsj2Rx9vAVAJupTJmOkIe+RbLMUqkUx48fp7W1lYMHDy7ZHtu2bQ72hHl6MMm1VInusIdkKsWz/WewdZ22YCWd2DBNBsemGBybAqCrtYXO1gg7etrZ2tGKIleeQxIq1sxcYdJNC1kUqxMQFyNTMrg0lWMyq+FTJdoCCm0BmaHZIL1p2aSLOrvbK3UokiTS1tZWjY2dOXMGXdc5PZ5hJpXHTI0TDoUIhUMEA0FMG7KljbOgHZqljgRufNPGpToZX7x4EYDTp0/P636wWZimueo0Z0dIXNdWg7hR6b/JZJL+/n6i0eiKWoo8eTnO+z7bj1UZHU5BK/EXjw1y+lqW//POwwiC0BDXVi6X4/jx43i9Xo4ePYqqqlULar0mvCqL/MTdPfz194e4PJPHKFmYJY3WsJ8fv6tnwQwtJzliz5499PX1LfkDdYRkZ1uANx3u4tEzkzx7bpDxkat4ZYG9nUFa5kyItG2bcNDPRDzFRDzFiYvDSJJESzhMIh6nbUuBXW1+XhxJE/BIKJI422CxTF/UN29eSi3Jgs6jZ6cZS5fwKiKaWRnle1tXkJ4WH6OpEooocP/2Fg50hRZ0T0mShNfr5bZgC56ZPDHFIpvLMTk5yXDpKmnby7S3SCZgb9hEQud9aiaLZDP3UtvJuFQq8YMf/IC2tjaSyWRd9wPnv6U6GW8EpmmueohYoVBAUVZe+7TZ3BRCspExEkEQyOVyPP/88+zdu5dt27at6Efxv791CdMGUWC2s6yAZdk8NjDDiyNp7tnWsm7XltNNuLe3l71791b35YjHatc2TIvnr6Y4OZoB4FBPiHu3R/nvr9nN9wfiHL80Qm/Mz5vv3c3BnvrCQ8uyuHDhAmNjY8tmr83kyrwwnOLKVIapSdg1nefebS2MXx0mZ6fo6o3QHQ3gkQSKpTKG8zpsCAf8ZPPF6lol3eLKRI7ExWnSmRzfv/wdDvZ1IqheTqX9BEIhJEmmO+zhlXtbl7RITlzLcC1dYmerv+rOm8lpXJop8La7url/ewuCICy4Rr5sMBgv8vy1En7VpK9XRBQENMlDZ1eQ9s5ORuJ5IkYJH6VqkoZzeLW2tjb8AGsWIWmmmIQjatu2bWPbtm2r7mS8EawlRpLL5QgEAk3zGS/HTeHaWksTsZVgGAbXrl2jWCxy3333rbgVS65kcH6iUg9R+xoEoeIcemYwsS4hsW2bgYEBhoeHuf322+nqqh/HuxYh0U2Lv3p8kMcH4uhm5XGPnp3kgV2tfOCVO9nfFaI/lCIcDrNzjohomlZ1+R05cmRJc3skUeDvn7rKtVQJWbQZj8NffPsircYMXrtUtRhMQydbtrAsC69HwaMqCECmRkQsGwam80xly4Q8MgFVQJRkTgxNsbs9gFdJkkvBlvYY+7ZswYOx6NWxbloMx4vE/Epd0L81oHAlXmAiU2Zf58KuzEzJ4DsXZriWKpHJmtiCTVrI0BZUMW2bkWQRAYGOsI97tnXRHfFiWRaZTIZEIlGtQXJ6ULW2thIOh9d1+G62FVBLM+1lrqgt1MnYCdo7nYxrg/YbMSN9LTESR0huFm4Ki2QjXFvOtEBJkggEAqvq56VIlQwkY4FgtG2DX628rWuJkWiaxsmTJykUCovGaZyBXKsRkueGknzvYpxYQKm2fs+XDZ68HOfubS28cm/bgu3ps9ksL774IqFQiCNHjizp8rNtm2+cnWIsVWJPZwDbtChPl7h47gyYOsd2xebViQiz/chKZR3dMCqzMTweRBEmUkUSeZ2IV8HrUSgXBVTRwhQFJrNl7uqNIApglnI8c/ICL567TMjvZWtHK9u72+jtbEWdbQhZec9g7ltmz/4fcYnD4/xEjpFkkZ1tfiY0CVmWUL0ymZLJq/e1YlN5fHtQrYuPtbS04A+GESJdiNkihVyWqXSWsbExbNuuGxy1WtdHM00lbKa9LGcdqXPqieZ2MlYUpc4N1ogWLmtp2ui0R2kWgV6OTReSlUxJbLRry/Hzb9++nUgkUg3QrRSPIvGaA+18/cxU9WrMtm1My0YWRV5/W0d176s57DOZDMePHycUCs0bhTuX1Vo7x0fSGJZVNz8k4JGZzGq8eDXFK/e2zROnyclJTp48yfbt29m9e/eyX+psyeDSdJ72sIooCEzF4wwNDxNrbSWRF8mWzTohEQTweTyUNL1ubkl+NvkhV9IQRJFQwIdlW1izlpQqi5QNC9OyEaXKnvxelbJmkEjnSKRznByopIhu7YjR193Gjp52drX5eHooTYtPrsY/JjNlon6F7sjCvmjbthmMF2iZY8m0+GQG40XymrmoJVPQTJ4aTDKcKGDbYNkiYW8r9x7YSZtqEo/HGR8f58KFC/j9/qq10tLSsqKDp1kOmWaakLgaN9tCnYwdN1gjOxmvxbWVz+c3bKzuRrDpQrIcjbRIarvjOkWQ8Xh8Tev/6uv2cnosy0iigPPdkgSB//HGfXTNtj9fzWHvTA7cuXMnO3fuXPaHuVohsey5rSRn1xGoWlaOINq2zeXLlxkcHFzQtbYkQqXQ8erVEYaHhzFNE62sYegGpmnh9agosoSumwiCTTZfXPS1emQRVZHJ5osoUsUKUxWZgikSUKge7CG/l2yhNO/xmm7ywqUxnjo/SiTgI+RTKNge+hM+IpEIgiQR8coc3RldcFTw9fdo7sVO5Xlte+nD/OJUjivTeXpjvqpwTWTKHB/J8IaDHezYUSm+c7KO4vE4586dQ9f1OmtloQOlmdxJN5NFshS1QXmgYZ2M1xojuVlqSOAmEJJGpf86VeoAR48erf4415pZ1RHy8OX33c9XT09wYjRDzK/wpsNd7K4p4HNcRUt9uWuD2KsZIbycJTeXQz1hvnthhqJmVrOxnI6+d26NVPdrmib9/f1kMhmOHDmyqjz2kFdmV6uff3v8BVS9kr6IDdmyQcAjEfUrlMoapTIEfT5yhSIBnxdRFCiWdUzTxLIrLjcE6I4FGU2VmMzqBFUZw7JJ5EogSvR1BPCpMj6Ph3JNHZBDQTO5NJ0nXTRQPR6uzMQJeWV2tPqwTJvx6at0tUbp29VNTG1Z9GAWBIHd7X6evJIk6r/+PZnOaUR8Ml2LZImZls1QvEjYp9Rlf3WEVK4mSkxly2xvrXwH585Pd9wtTsdcr9dbtVai0SiSJL2k03+XopGB/0Z1Ml5rHYkbI1kFK3FtrVdIpqenOXnyJF1dXRw4cKDui7ae9f2qxFvv3sJb796y4N+dL89iX+5yuUx/f391uuJqTNnVWiTHdsZ46kqC54dT1aQA07a5q7eFl++uNNEzDIPp6WnC4XA11XglVKwYyBaKGPGreG2NmYKOgE3OgJggsLcjiCqLlVoPRSZXLGJaFvliafY7AEUTrsRLxHNlBAH8E3m2Rr3IkkA8p1MyISIK9LUF6GnxIUkSqVxFsCqxFbUqSlcTOdJFk86IH93QsSSFVEFnNFXmtq5gpamvWeT0wCBDI2MgwPbudvpmYys5zSZdMvAqIrvbA0xkygzFC0xnDUTJptcH925vWbK1i2XZzE0Am7VlWKzWc667xTCMasfcixcvUi6XaWlpwTCM6oXKZh/izbAHh43KIFuok7FTu+J0Mg6Hw3UtXJx9rNW15QpJA1nPQW/bNpcuXWJoaGjRKYsbWaeyVHaVU9QXi8W45557VtyQrnbt1QiJR5H40Kt38/ilGV4YTmHbcHdfCw/tbq1M/5uZYWJigkAgwD333LOiH2NZN/n+pTg/uJJgciZJfuoqW8IKd/T4mQxKlAxIJcoc2tlKQBXxqpWCv1JZm7dWUTc5PpKhbEFQlQCbvCEwnNI53O2nLwaj1/J0tvppiwZBgELpejZfJbZS+XdBM8kbAq1h32y1voAo2AQ9MpmSTkEzCXgkJElClSVyxYpb7PTlEfoHrjKaLKGJXvyhMK2xKPu3tPLArhh7OgIcP5cm4FW590AH7aH51kimZJAu6nhlkS1RLyevZWnxK9VgfqpoEPTItAZWFsSVZbmuILJQKJBIJBgaGmJsbIyZmZk6a2Uzxtw2k2vrRs2PlySp7nNZqpOxI/qr4WZqjwI3gZDIsrymYLuTslosFpd00Thugo24kllMSEZGRjh//vyKivqWWnsxIbFtm2eHkjx6dorRZJGtUR+vP9jJvX0tvO62Tl53W2fdfYeGhhgYGKC1tRWPx7Oi98GybD733CjfvxSnlE4wM36VYtlgLCHxsr4o21v9lVhLVscrQSTgxwYky8YwTGzqL8mnsholSyDqvW6hBhWbeL7EWErk4NYIpaBKOOjFtCzMJURUVRQMI4eGiS0JiIKAoqrIsk05X8aybVRVxragOEfUJjJlxtIlAqqOYJQYjk9y+qzNmQudvPXIbva2iISCnnkiYlg2L15Nc3YiS75sosoirQGFiFdmKF7Ep4iVqY+iyD3bwvMaeWZKBrmygUcWifmVRb8Tfr8fv99POp3G5/PR0tJCPB5ncHCQM2fOEA6H6+Z73AhL4VZ1ba2GpToZA9WR3CvtZOxaJKtkuS+gYzGsxnxOpVL09/cTiUQ4duzYkh9a7WHf6C+gIAh1KcBOS/qpqak1jcKtZSkh+ca5Kf7m+8OUDBO/KjGWLnHyWob3vnw7r73telt40zQ5c+YM8Xice++9l+np6Wq7mOW4MpPnucEEZnqC/PQUfkXEJ6vE8xqD8TyxQAtQEYWg30s6X+T6xyfg93oQsCmWNcqaji0p2GYe264/YCWxYmGUyjo2kC+WCYcUgn4vtg2lcrmuJ1jA5yFbKOOVBfKaScQnY2OjaRqZUuWg7mwJIooVMdRrLlIMy2Ymp+GRRYI+T+Vzsy18os2ZK6PYhRRaLk1XWwv3FW36utvoiIYRBIFz41meHU4R9Sv0taqUdIvRVIktES/3b48wk9PxKSK9MR9bItdTfXXTon80w8BUnrxWyWrrjXq5r6+FwBIJALZtzwsOl0ol4vF4XWNDx1rZyIruZrJImqE4sraTcW9vL48//jg7d+4knU6vuJNxoVCgo2NlIxyagU0XkuWojTMs52esbWm+0qt9Z03TNBcVHMO0+Ma5Kb5xdhrLtnnl3jZ+5Pauas3AUjgHfrFYrAb7F2tyuBoWqyMpaCb/8sI1LNuuBnMBxlIlvvDCNR7cXRlO5YzmhUrygdfrJR6PrziIe3kqw6WBC/jtEqIooszWa/h1i0Rew7JsJFHEpyqVrCul9r21KZTKmKaFbVuEQ378xQKiPN8tY1rgU0WCfi/XyjoeH5imRa4mS8vnUcmWTWbyOqmJGUJehY6Qh+FEpQ5FlUV000ISBfZ2t1CoEUsntiKIItlCCcOyCfq86LrBbJUJkihgWna1yeVUMsPxC0P84ORFfB6V3q42LqXAGwwR9Vdeg1+V2NriZTqncSwY5fCWCAtxfiLH8ZE00YDCtqCXom5xYTKPbcMP7W1d9Pu70IWV1+uta2yYyWSIx+PVim5nGmFra2vDphGCa5EshXMR2dHRUc1+XKqTcTQaxefzkcvl2Llz54bs6fd///f50pe+xPnz5/H5fBw7dow/+IM/YN++fWtes+mFxDncDcNYUkicEa/JZHJVg55EUUQQhEXjJIZp8f7Pn+R7F2eqV9TfODvFF164xt/99N1LTgx01k8mk1y6dImOjg5uu+22hnzRF7NIhuJ5EjmdtmD9oRwLKMzkNIbiBbq8RtXUPnjwYHU/Ky1ynEllePzpFyjmMnj9KiIWmlZxERmWRcjvIRL0ISBQ1K4fyHPRyiVEAdIZm6BsowomyYJFLFRJq0zmy/hUiR3t4VnhEBZc6/JUhtGMQb5QRpJFpksQ88nsaguQKmrkNZMWn8z2jggq9Z9zbWzFMi1iQR/pkkGLV6Gs6YBN2bBQZRGvLJID/F5PNT5TKJU5fXmUM+NZFElkuDVCe2uM9tYoLeEQmmFR1Bd+T3XT4uJUnqBXpmXW1RVQJXoiHkaSReJ5fV6X41qWOrydgsiWlpZqRbdjrZw8eRLbtuvat6ynp9NLIdi+VkzTrHomHOZ2MnY6IIyNjfGJT3yCf//3f6erq4toNEqhUGh4Pcn3vvc93v/+93PvvfdiGAa/8Ru/wWtf+1rOnj27ZnfapgvJcl9Ap4p7qYC409jQ4/GsadDTUgH3/zg1wfcuzsy7vX80zeeeG+U9D/Qtuq4Tezl//jwHDhyoG/q0XhaqQgdQJbFadV/7LphWpV18Mj7F6PiVBfuKLbZmLZdGJvjKE8fxiRYBVSZd1In4FEQBNMNCMyz6Yn4Ks+m8siwR8HlQFZVCWcOyrEqGVyZNMpnERMA0DHxeD70BD+MFkVSuCAiEfSr7u4JE/GrlqneBOhjdshnLGOiaTmxWPG3bZjJVQBW8HO6NIklitf3K3O9brmwwk9Mp6hatIS+qUBHFKU3Dq0gIooSBQFdExqdKWF6VfLGMx3f9xy2LAl5ZJK+ZJJJpiqUyFy4PIYgy/lCIyQ6R7mA3Pm+9KJQNi5Jh4VfrDz6vUim4LOqLf+dXe3irqlqXylrbht0piKydRrjSw9ipO2qWw7sZhWSpC+Bawd+5cyfbt29nz549fPKTn+RLX/oS//iP/8iDDz7I2972Nt773vc2ZE9f//rX6/7993//93R0dPDCCy/w0EMPrWnNTReS5XC66C520I+Pj3P69Gn6+vrYvXv3mgdQLbb+V09PMvf36szt+OrpiUWFxDAMzpw5g2ma1XnqjWQxi2RnW4CdbX7OjGfZpkhVUZnKavQGLPITg4vGZ5aySGzb5vv9F/n2ixfwqQrRoI9DW8KcvpYhWahYI5IosLsrQk9Yqb6flmWTK5RQ1cq6HkVhemqSsUSBlB0gr9tIIsQMiMo6nWKJsiIQCYaIhGS8sk2uUOm/JYjg96iE/D5KZQ1BEkikymSL5apLqfI6Ku6weF6nrBsolkRZ15FlGZ9auV+hpDGdK3NpOk/ZsPGoMlNjaXyqSGfIQ0EzKeomsm3TE1LpCnkI+nwUsml83uvPZc027mwPecjFC+hI6PkShmVR0nQUweKp42d45sRZOmOR2Sr7DjpjYbyKRMgjkS4ZdQWRubKJX5WXLJJcTx3J3GmEuq7X9Z8yTbPqamltbV1yMqizj2aySDa6CeNqWO1+2tra+Omf/mn+/u//nj/90z/l3nvv5Rvf+AbZbHbD9phOpwGqsba10PRCAgu3SXGu9MfGxrjjjjvWFZhaqieWZlizFcz1t9tUrigXolAo8OKLL6IoSjXLptEsJiSiKPDeB7fzh98YYCRZOYBt2yYolHl1j8wDx44tup/Fano03eBPvvQE3+6/TEEzEQWBaEDhzq0tvO72HiYzZXKlMp0RPx7BQqwpnnBEFyqZdNOTE0zlDcbKKoZtE/Sq6JbF1ayG3eLntm0dyILNTCJFIh5H1w28Xi9+v68yNa5URpCL+D0qllXJ0FostiXLcuVzmi1YNE2TXHE28cGyGc8aiJJCd0ihVCoRCCgkCzrZksHBniCmVREJVZFQ5ErtS76kI8s2JXRSZZuCbiIDrQGZ/d0Rrs7kKBuVeMzWqJfOsGf2PbCZiKfIFUo8c/oSPo/Ktq42PN4g+YLABBD2yhR1k3TR4HBPqE4cHQzLRhIa605SFIXOzk46OzurBZHxeJypqalqQaQTW2lpaak7GJ3vS7NYATebRbIYTvrv3r172bt37wbsrIJlWfzSL/0SDzzwAIcOHVrzOpsuJCv5Mcy1GJzAtW3bHFviYFwpS1W3v3JvG88MJevExLYrV9+v2je/Ct0Zhbtlyxb27dvHM888syF1Ko6QlHWTJ68kODmaQRbhZduj3NsX5Q9//BBPDSYYnU6Tnb7GvdvCHL3njmUz2OY1bcwX+bMvP86j/VcBCHplLMtmKlvm2aEED+5upSMgsy3mxbJBkSUMw6xJq63ENYrFIql4HEn1UBA96JZG1CdjYyKLIKoSMwUTUVaRRZtoLEpMiKHrBsVigUKhiKZpzMzEkbAp5CW8Ph8yNrJgUdAgFvIDNppuoNvQ7hWxF/lc85pJXjPwyQLlchlJllBlmZgkkymUKekWflXCoyhYtlVX+5IsmUyn81iWjUcWydsCWc1kT4fC3dtbSeeLSIKALNW4DQURj6ownswxk9MoaFlOjaZoDShYNmiCij8Ypqs9xr27u7h9TnB+KF7gwmSOZEEn7FWwsgYrbIKwKmoLIvv6+upmp1+4cAFN02hpaalaK07dSjNZJKutydpI1lLX4oj5jZiO+P73v5/Tp0/zxBNPrGud5nnHl6C2TcrMzAwnTpygs7OTAwcONMSMXcq19dZ7tvCFF8cYnMnjDOWTRIGOkIefPnLdXVXbn6q2+HEj5rZD5Ydb0Aw+8rWLPDuUxLQrE7a+dmaK193WwftfuZO7Wm3ksWF23r2y/l1zXVvXphJ8+9lT9A9OY1oW0cCsj18UiIoKqaLOTN5ge5uHQqly0Do1gpIk4feo+DwypVKBbDpDKFLphns6OYNPkeosII8sktbgWiLLlhYvqqLMFjBaKKpCOBxmbGycaCREoVSmUChUBwa1eVTGcxbjyRwCNpLiIeIR2dsdwSuLFIrleW3Ggj4vppHFEiVEUcAyLUqmhmZagI1XVYkEPWi6QalkVN87y7aZzpsIskSLX0GRK8KaKWpcnkzjlyouK99slb2mGdhUrIfxZI7BeAHNtFGlSnpyqqCzLeajKwSSkCc7nuLZ5CgTo21s725ne3c7Y1mDxy8lsOxKUeVYpsS1CYNgpMyWhZsqNIza2em2XbkgcIL2V65cqQpJPB6ntbV10w/xW8Uicbr/biQf+MAH+I//+A8ef/xxtm7duq61bgohcVxbly5dYnBwkAMHDqz7hc9dfzEhCXpkPveel/F3Tw7z1TOTWJbNaw508J4H+mgLVsLZuq5z6tQpstks999/P+Hw9XkejZzbXosoijw5nOeZoQJtQQ8+pfJlzZR0Hj07xVa1QLg0uSq3X61FcvryCN94+mRlMFChjNejoqoeLMtC13VEUUCSFHKajrZAryvTNMnkixiGSSqZZlvvVsKhEEVNRxIENEeVbRtRlrFtMI0SilSxLnXDqNZ4CIKA3+cl5FOxEClJARKCgimYBEyLAGVahTIFS8TrDxJQLXqiQSxDp2CAJIn4PBURLJQ1Al4PqVyBgEciWzRomXUh2VTiE60BhbBPIZ0rAKDIMt7Z2Mo1S6Bk2ER9Ep7ZaZWWbeNTRDJlg6JuokhCNavLoyqIVOJ8yXIlhbjWZZUrG0zndboiPizTQBYFSprOxeFxLg6PV1xwBQF/KMz+bZ1EvF6ifoWpcZuLM2WO6CZe5cbEBARBqLpqe3t7MU2T6elpzp49y+DgIGfPnq3WR7S2tm5KG/RbRUg2siDRtm1+8Rd/kS9/+cs89thj7NixY91r3hRCIggCg4ODWJY176BuBMvNDYn4FD708G4+9PDueX/L5XK8+OKL+P3+BftTNWpu+0J77h+vDFTy1RwkIY/MRCLHM5dL/I+fOLKqqxpBEDBMk+8+f4YXzl25vqZXZjxdwpmKKwgCkqIiaCUCixxipmmRScXRDJOOjk4ESSY7GzTvawtwcbqEJYhIkoBpWSTzGiGvvGBcQJEkdMMgU9QYS1hkLRlFlrBtiXjRpD0Y4NDOLkTbIJHKUChkmBhL4vX68Pt9+Hz+SiW8IBDwqOiGSTTkZ58tcmo0STyvIQoClg0BVeS2LTGyhVLVlWnUxFbAwqPKFVE1bczZGgpzdqaJVHNw+r0eimUN27Yp6WUS2WLFXaYqCIKIYRhE/BLJvEaqUF6wb5dmWCQyxcoI2akJFFmmvTVKsZAnqXhJFQ26bpCQzEWSJCKRigvuyJEj1fqIeDzO8PDwpoy4bTYhWUvw3zRNisXihlkk73//+/nc5z7Hv//7vxMKharV95FIZMnEiqXYdCFZ7oolnU6TSqWqB/VG9BJaq/tpYmKCU6dO0dfXx549exZ8LRtpkRiWXTeQyTRNMpk0NtCzpXfVX0TNMHj85BXUYEvd7dtb/UznNNJFA78qIcsyU8ksUb9Ce1DF5/GgyBKarlMsa+i6TjoRRzNtRLEyCKqkW+imhU+R2BrxkinozBRNCsUyiqrQGvZzoNPP3BpPn1dF0wxMyyJdtpkpGMRCCopYsWh8kkJSg5wh0O730tamYNut6LpGsVicDRwnUFUZTQoQL1nYQsUt1R32cnhrhLwOJcNCtA22xoIYur5Qx/1KDEiEmE9hKpMj4lXwKDKiJJHTNVp8Cv7ZuqKg31fNNoPrI5lNy56tTwFVVdA0E4+qEPR6QLCuZybM4veqiBQp6zoeuSKoY5PTTMcTiNdmaLHSHNrRw7auVnraKqnON5La1N+59RHObI+rV69y9uzZalNDZ0LkRlgrN6rX1kpZy35yucr01Y2KkXziE58A4JWvfGXd7Z/61Kd45JFH1rTmpgvJYti2zcjICBcuXCAYDNLe3r5hDelW27jRtm0uXrzIyMgIhw8fprOzc9H7blSMRBRFbmtTGcpq6KaFbRqVFEFZJeCTubNvZQWZDvF0ji9/7ziTySwHOrrAFiiWy5iWRVfYyx1bwgxMFygZUNJLdEW83N4TRpVFiuUyxdnYiK5rJGdmCIWCdIQiDFwZ4txEgZliFsOy8SkSfTEfR/d0cHU6TbZYsS5aAyqKJKDKMh6PUqkbsSvDrZwixJxemami1GSFeT0K2XSJ0XiWiBrC61FQZRnTqtSuRCIRZEnk9GiSwakclmkgAFNJifGEwuGtLcQCHiRJRZV92IDP78MwzVlrAqayZSazGmXDRLZEgqpOW8BLsqiTKRuIQNgn0xvz4feqqIpMadYSsWzQTRtFEmjxyUxmyyiSSMDnoVAsky4ZRHwy2OasC8+DIFQ6GCMIGIZJyCMxmS0jiSLybJV90bDpCoqYusaL5wd59swlBFHCFwjRGouya2sH+3ta6qzVjWCxqva5I26d2R7xeJzR0VGAuvYt6ymInLufZhOS1VokhULFpbpRFslGjCBoSiExDIOzZ88yMzPDPffcw8TExIYcxg6rERKnGWSpVOLIkeVdRxvp2jqyRWWo6OHkSALT0FFVD7Ilc2RnlKM7Vp4TPnhtiv944kXSuQKmaXF6JMFwvEBBM+mI+DnQHebAlih9bUGS+TKSIBDyyvNSovO5HMlEnFAkij8UxrZhtCiRsUwCqoQsWpR0k4szZSQxwZaIh5DqLGJhWQJlXaes64QDPrLFcuWKXBQpaxX3U+1PQPV40MplLNtCnB2lW9b06hW/KImEfF5SJZ140SYaCuBVREzDRNM14jmN04Pj7Gn34vP6UFQPXq+H0uwLkySRqZzBYErHMi28qsJ0Ik9SEjnUG6Yr4kUzLBRJIOyVkSQRSRRJ5wpYNsQLJjMFg5JuIdomUZ9M2CtTtkTSiVwlQ0qV6G3xIc6m9GYLZaazZVJlKGo6fo9K1KcSMy3SJQNrNnswIAv0tQbQzcrc+4JmMhjPkS/HgSEAulsjPHzndg71dbGlfWOslZWmIc+d7eG0b7l27Rrnzp0jGAxWhWWtkwjh1hCSfD6Px+PZ9MSF1bDpO51XaZzL0d/fj6Io1Z5U09PTDR+3W8tKD/t0Os3x48eJRCIcPXp0RR/0Rrq2fJLN23datJsWM2Ibfq+HY7tiPLy/fUV9wGzb5vmzV3j8+LnqgTCctZhJpACQJYErUxkmMhov6w2yJeqnty2MbVd6ZdWOx82mU6TSGdo7Oqp+1uRsVlfYL+ORZBTFQ0gUSeQrrVq6w+qsxWZXK6SxwedTZwPdQt28kqhfJm1J6LZA0KtSKpfRZmt5FmrL7veqpPMFJtJlSrpBV8RfuWhQLCRZIiapKLJMMChRKORJptKAjc9XiatIiodLk3lkSSLgr2RhEfKQKdtcSxW5Y2ukOm9EEgVURam2pB9LlxiOF2etLJGSYTFhCuzuDOERIVMQUWWJsFdGqUkTnkiXmMhbmEaleWSmUCSesdjW6qOvPYRhgW1b5BMlBNusdgoYTZXIl41qlwHLhul0nq8/e4Hzl4bxqDK9na3s6Gmnr7udcGBtvvCFvkOrPbgFQSASiRCJRNi5c2e1IDIej1eLeGsnRK7Gb9+MQrJaayuXyxEIBJompXolbLqQ1OLEHHp7e9m7d2/1CyHLMuVyeZlHrx1Jkqq9ohbDmfO+a9cuduzYseIPWZIk9AWymtaCbducn8iRKupY6RLF+AzBYJBf+YkHVv1lNUyTbz97mqGx6aorJq9ZTORtfD4Bv0fGtm1agn6mUjnOTdh0hDwYpuP3r3TwBZux0WtkiyW6e3rq3I8FzcS0QZGEagq3rutItklRt1FVdVYQNDTDRBaFymCqUsWlpJsmM3mNXNmsTBm0TDp8IikTxpJ5JFlGFiW2tda3dbdtm3DAP9sSpXLIC4KAphsIsxckoigiqzKqVHEhBAJ+bBs0rUyhUCSbzZDIaaQ0lRafTMmqFD6WNR1FECiblUI+nyKh6wY211vS66bNZKaMKgsE1MpPzCNLlC0YnExzeEuYba0BvKqKZdkUyhVR1k2bjC5gmzqh2cC7KkNBgKmMRkfQg08SCAV8DExbBHwefF4PM5kiudnqeEfYfF4V0yqTKmiUwiqCYHB5dJLLo5MAxCJBdm/tpLezlZ72KPIa0+gb0bBxbkFkLpcjHo8zOTnJxYsX8fl8dfPsl7rCbzYhWct+HCG5mWgKIbFtm/Pnz3Pt2rUFYw4bOXzKWX8xq8GpoB8fH+euu+6qDrJZKY2ySK6livzhowNcmMxR0g0Eo8yd7SK//66X4VFX9zHmCiX+/XvPMz6TrN6mKgo6MoYg41clBEDxeNA1Db8qkS7qFHWzGkwGm2Q6SyYZR7dsdmzvw+fxYFrW9dRXWUQUQJBkTNOoWh2aaeGVKwdwxjQBm1Cg0uTRME0kw6KkG5wazzOTK1MxVGwwTfZ3eukOeEiXKvuI+BRifgXfbGxENwwkUSRbuN62PuKT8SsSmdl4hG3bCKJMNpOjsyOAbVt4PUolO8yjoKoq0WgLbRbMXJxC0wxKxdk2LYKAiYRPNimWyiiiB9O2UGSZkOpDNw0yqQKaYVVbnEhSpTGoZBoUDYuyUUkR1o3rohz0eikYFoVyHo9cfzB7ZJFc2aSkG8TCYbL5IoZpkS+WsYXKEDBFUfD5FGzLRJFkSuVK7YzlWHpzKJY0Xjg3yLNnLqPItdZKG5Hgygt8G92wsXYS4fbt26sFkfF4nPPnz6PrOi0tLXXz7Gufv9mEZK0xEtciWSWWZfHss89iGAZHjx5dUIkXapHSSBYTqlKpxIkTJ6p7W0sFfSNE0DAtfu+rFzg/kSOk2IiU0WWZZ6csPv/8NR45tnjjyLlMxFP822PP12UUQaVuQ9M0bNPAFkRUVQF7VgjtSlsUqSbIXSwWSSVmUDw+ulvbMEyrmt4rCgI+jwe/10OrXyGeLRINeCs1EoaFbtrsafdV1wv6vOQK111loigwmbdIlW1ag15s26JYKJAzYDhtcH+LSNTvtOGvrFEqaximWWllUtJIlWAqV0bXdKJ+me2tPgbjBRJ5HVlVsIp5OsMeemZng5TKOiUqlqMkSYQDXsqaSVvYTzxfpiUUxDJN0tkcec3AQ4Z8yqCQU/H5fKiqpypcfo+Kz+dBFARkWcC2LAzDRLcsZElAnnPQSZKIYVsUSyWwTGxJwuvxVERX0zHMykCsSMBPNu98bnb1tXtkERGLeDpPZzQ421bGQzGvEVCZV2fi9aik82UksWKt6YbBlWuTXLlWsVai4SC7t3bQ29nKlo7YktbKRh/ccwsinQmR8Xicy5cvo6pqVVSi0egtISQ321AraAIhEUWR7du309bWtugbXlvZvhHMPewvTuY4e3Wa3MQgh/sqrdbXWkHfCIukfzTNpak8QcnE1nUi4RCWaaFninztzBTvuHfriorSzg+O8bUf9GNaC7+XbUGVgCqSKRqEbWu2rsSibArs7w7TEvRSLGnkslmSiQSRaHTBmh7TssmXSgR9XnoDFl6vj6whUdRMJMFmd3uAHW2VCYqRoI9MvtLt18EwLYZnsshYmKaFVtaQFZnusJ+pdIF02cLvUaoWjm1bqLMV5tl8kXOTeSYzWvVgn8rJbIn6uHd7K6miRrGs41d9RP3KvJnqpmVTtmByLEXAI7Gj1YsoSWTLJoZlU7YEOsJejuzrIZ1KUywWZpveCdWaFZ/PR0iGqYKB34SAV8UWJEpli86AjFe5ftApioxgV4TQI4vEAgpj6TK2Zc3OUbHRbJFtrZXU6LJhV2NGumWTK5uokkB3WGUiLzOeyKFIIrpZQpVFulr9BH2VqZfFskY8b3D1WhzDrKzfEfLQHlTrEidKmsYL54d47uwVZEmit7OV7T3t7Ohpn2et3MgW8oIgEAgECAQC1YJIZ5795cuXKRaLlc7Pk5PVVi+bfVW/FiHJ5XI31ZhdaAIhAeju7l7ysN1o15YTbE/kNf7rP5/kueFU9W/3z2h8fJdJLLB5QjKezJMvlvB5IRQJI4oSmlWebbNhkCkZSwqJbds80X+BZ04PIIqVIVEClerrytjaymEQDfroC1SCwqlC5epcEARaAyo7YyqFYplcJk0um6NvW2/FZVXz2vJlkyszeSazGqIk0RmQCKkq7cUMrR4PcshLe7SF7lgYyzaRRIlM3pkzMn/PhmFQNkwEUURVPZiGgShKeD1ewkEvhVKlVX3A5yFfLGNZJtM5jYlMmZBHQp5tH29YNqPJPFG/SE/Yi7ctCDYUymWsmumK2bLJlUSlcNCybTySSE+Ll91tPrIlA920KHk0trYGK0IWDhEKBbEsm4lUnqFkntxkAo9g0hP147MgVxTJFnVkSaQ9oLCrI0TI58GybCzboqjpJPMammHhkUW6I15MCxIFrTKyV5HoCKrEvAKarqMqlbYsSV1kbKqALWgoksC21hA9IZO07KGomcQCCq0BhaBHriZGJMtwaTJLwKviVSFbLDMYL2DbNp3hSowp4Ku0u3GsQ8M0GRybYnBsiu8CLaFANbaypSO2qS3kJUmqNpOEipX81FNPVYuEnYJIx2LZjHn2aylIdFxbNxNNISTLcaNiJL/0Lyd54Wqq7m/PD6f5b188zafeffea1l5v+m8mk2Hm6gCqLKD4Aohi5UspUGnV0eFTqkORFqKs6Xz1yX4uj1aqVy3r+nTBRF7jcrxSIyFJ0O4Bv2jxQ7vaGM+UKM/6+bvDXgRskvEZcoUS3d1dWIIIloXP40GWRNKFMs8MTpPRbDwSmJrB+axFe1Dlrq1bMMolCoUC0+OjpGdkIuEwkqwSi0ZmixkrdRuCUJmxHpQt4lmDtoCCdzaRoKBbKBJ4RJNcoYxA5WCzLAufR6VY1siUK8KmSCI2lfo+r6qSKxeZTBVp98sYNZ9HZf+VvmUXR7KkCxoRXyVoXdQthuJFvEpl2JSAQMYukiuWkT2V99Dv9XAtVWIobaKZMqpPwRQkhjNFtgTAaxUxbYGQ10vMr2CZBtmCRcDrJZUvM5wsky5bGIaBaRjEAio72/x0hT0gSsiijSoKVYtBNwwuTWUZyxjEIh5iIR+6BZdncvSEZPpiC7tfPaqH4dEZVAlkTGyr0rFAswTSGnRLEj5VJl9cOqmlVNY4fmGI589dqVS2e2UUW2P3vjzR8OYefs7U0dtuuw1FUUin09Uq+9p59s6EyBthraylINF1bW0QsixveIzkakrjmaH8vL+Zts0PriQYnMmzo231H+56ChKdWSsPHtzJGa3A81fT6LMdZ1MFHcuGt9zZvWiqbzKT598ee454ev4sg3RR58nLCXJlk4DXQ7msMZC1CckqdwZ9+NXKrHOAclkjnZzBsGDr1i11P4zibDbd5ak8WV2gLaQiUOk/5rcsZvIaMwWTvlgl3VNRRAr5Aql0lkIyzcTkJD6fD7/fj+r1Iysq+UyKqFgiG/CQ06Fs6VWraVe7n6CnEmAOBnykc3kci0ZVZPw+L4piIIqVhpCqR6WsaVi2jSBQ81lUMrkKpRI+j4epTIls2aAzGkCgEpvwqxK6aTGRKdEb86PIIsWyXokfOe9xrsiF8QyCbdMR9qEo8qyFYlKUFA7u6KRcLlEoFEmlkkxPTxONBEkJMiN5SJYsWnwyfo+A7fGQ0W2mCib7O/yUdbPO4oPK6IKZnIYq2QQ8CgI2gmWgCjbJosUeVUUSBQplrVolH/B5mEjm0U2rmg0GlT8Ltkk6pyF0BdE0g1DAh2ladY93qG35ApVD8upkmkwmy2The7QEA+ycja30draiyDe2dYvz2YqiWFcQCVAul6vNJkdGRhAEoa59S6MKIufiurZuICuZq76RFkkul2M0VQIW/8BHksU1CclaXFu1lfN33nkn7e3t/EaXxl9+b5BnBhNkSwYhj8zLOwx+/M6eBdcYHp/mW8+exjAqUwoNo/79uzSVJ69btIW8WKaJxyOjmxbxbImB8RTb2wIEvB6KhSLx6QlUb4Du1tZ5RYjOfnM62KaOoYPTc9/j8SAbItlZK8HvVSvDnlQv7e1ewEbTNNLZPCdGU8zkZ7BECVUQ2N7m58F9HUxkykyki8iiTVfIQ0fYgyiI+Lwq2TluMd0w8UsWlmlQ0kUioQC2ZWEhIAoi7SHvbGNKqrEVn8dDoVSiODvRUa9JA1dVBT8ShmkiUAnIz6WSTWUSC3gQJZHibMZawCNRNgVUjwevquDz+bDtKD5VZnImSTJb4NpMCY8kULQ9FZeVqqBgk8jrpAoa0YB3thhTR5u9kNKMSqsZz+zFg9PYUpVF8ppBIlsk4JGqjS4lUaRU1pDFSrKEYdqoNVlhmmER9HsplsqVmEz+enaaz1uJrWiajixL1Wy8uZ+98/stahonBq7y4vlBJElia3uU7T2VDsbR8MZnIdUKyVw8Hg89PT309PRgWVZ1QmRtQaTjAltPQeRc3GB7E+EISaMDe7ZtMzQ0xMDAAF2Bpb8421vXNvNkta4tXdc5ceIExWKxrnI+FlD5rTfuYypbJl3U8VpFLp8/UzdECiqv6fiFIR57/iyWbc3eVmkl4lEUDNOkUCqTKFkoooBVszdZFMAWSBY0+mw/k1MzJJMJIi1R2ttaUWUZwzIpluprbkJ+P5aZxqqc0NXBLbquY+ga2DItIR+WaeNVlMrVLgACqqoyWiiR1BVUVUCwLQwbzk1kyeWy7Grzs7fFT7SlBb/Xg2GaWDZ1LhjTsshrJrIo0hpQ6W3xMVEwuTaTqXwGAmxvC7GrMzJbTFm5qg76PWRyhcr7I1fiKWXdRJVEECqWWFGD1kCl1XzQ4yOrKpg14iUKs+m9ooCm6TV7srFtg0KxhCKJeFUZj6pimiaRSBhUP8FyBp9kY+o6+UIeK2uh+nxkC0WKERGlxqWlyjKqKiNJJl61TDJv12UoaYaFLArV4kZJFDEMk7xeccFF/B66YzCWLCKYFopUGedrCjIB2Z5n1ZqWTTpfQhYrdStlTSPo987WvVy3VpyP2+dRKetG9TA3TZPhiRmGJ2b4HueIBP3s6Gmnt7OVbV1tqErjj56lhKQWURTrCiI1TatOiDx9+jSWZdXNs3dcZmvd01piJN3d3Wt+zs3gphESYHYGeGO2bBgGp0+fJpVKcejQIc6cOcMr9rTyxKV4de4IVA6KV+5tY9sivuflWI1rywkSBgIBjhw5smBwsCPkoSPkIZUy5tUHmKbFt549xalLV+tun9s6JOT34VclMiUJQRSwZwPO9ux/iiiQTiZIZ7K0d3Ti83nrW4+IIn6POhuDsMkWCnSFPIwmihR1C99sVlJeqxQS7u6KkspeTzeWxMrVLsBkKs94uoAsmKiigM9XybTJlgzygg2iRDqdYnp6mlDQj8/rw+vzEQmHEAQYmMhweSpHQa+kKHeEvBzaGqEtVyJZkMCGiF+hNaBWxUcSBUJ+HwXNIF0G0zIJ+ioNKCcyZXyKhCiAIUgItklX0FexCnSDoqbj8agEfF5EsXLADyfLJHJlWvwyApVeWAXNZGuLF1UWZ1vuS2TyhdnPQ6A94ieS0SmVDQJBFb/tR1UUxmbSiJjEpybIyBJ+vx+fz4/l9aIZBgGfl5hfYiYpYYkSCBV3W1G36I1Wnk9RZLBtSppOQTPRTAuPbNLmFSh4BVJFE80W8SgKHapAT+h6V17LhulsmamcRlk3iYUChPMarYFK12Rn/461Uszn8aoKJU1fsodTsaRx5so1+i8OI4oiWztis2OH24mFG5Nd5RRHrnYtVVXp6uqiq6urriByYmKiWhBZO89+pcJQ6Tpgr8kicV1ba2C5D/7/z96fxsh6Zved4O/dt1gzI7ebmXcnL3cWyVpYlLWUVkttj9Vy98iepTX2wIY+aL7IGEACBjYwMAYGNC0I1tjQh25LxnjG7XYDUo8XyW7LKlWVXAuLvNzJu6+5xx7vvjzPfHgiIjPvvWSRl6TMmqkDEIWbFfFGxLs85znn/JdZ8vikEkkURVy8eBHbtnnppZcoS7WT+r//1af4td9/mz++1FXfC/jxC0v8g//yyYf+rA/b2trf3+eNN97g5MmTnD9/nqsHMe/tdQlsky+dblO7R2L83uNGScof/tlr3Nw5+MDPqfsKbrtWN7nbC0mkEhDUNI1hnGFpghoJ47Bg7cS6WpTuCSEERVVRVYIkywlcm/OrTaJCcmlnRL9QC45jGTyz0cLVK462oKqpjzvAwWBMklcs1R0c257PwhxT7ZiDRovlTgfH0un1R4RRyEGvx7ZhEONwfShwXIdWzaOsBFujlLQoeeFUi8XgftlyxXGxubQ94MpBRJSVGKZJw3M42aoROCa7oxTTdvAo2Wj5tLzDzYCQkt1JwbXRHrphUrM1Nts+umEwSnLKokDTlGTLZtvDNA0MTSdOM3pRwcEkIy0FdcfE1yWjokBi4Ts2g6TAcRzOLQV0Aos0TYjjhLt7XQZJhe0prbCVVkDTLEnTgkQrcR2bR5c8Nluu4qxUgiQvudlP6EeKh2IZOos1i1MLHhsSJDpSVHiWgWOpakcIydXdEbf6CYau0QhcuuOIA1SCWZ4mnJlEDoBp6iSpVEZhQihVAo4nFMe2qCoxBzkIIbi92+X2bpevX3yPuu/NyZCbq4s4D4mu+iQ4JA8iRM6qlRkh8l4/+/dbv2adiIcZtv8gkXwKMdtlfBJzktmCvbGxMZdhmfERao7BP/7ffI67g4Q7g4STCx7rrY+nSfS9EomUkuvXr3P9+nWeeuopFpdW+Af/7gp/crlLVgg0DZZqDv/nnz7Pl44IMR497n5/xO9/9WUmUYJjqxZWVVVESQ7aoae2a1tzxvfpBZ9BVHCzF3MwjtEA24DHOhZN12B1bZM0f7C0i+86vLc95NpBSJhV+JbOmU7AuUWPtaYzR04t+CbO+z5DkvFoRJmEOKZBJbV5P9k0TdKqwDLANjTqvsskTqjV69TqdUVQTBJevjUkzQuMKiOpXHRDp+GYTHJISo2mo6qDWZiGjmka7AxC3t0LqSpJ21eLYxgnvJukfP5Um2dOdciLiqoqj+iACbIs43ovYVTZ1AILkaXsjwX1ScaFlRrLvk4loBm4dOo2CEkpKrKiYGuYcq0bUwmJqWv0owLf1tloeeRSZxyl1GyDtU6NzcUaGhqWZRALk95Yp/J0wiQmH1fc6U444Uvafonj+dR9F8fS0TWNtBJ4ts2tQc5BWOBbOnXHIKsk26MMxzQ5txRMZy5qp5yX5fQ/we4kp+47NDyHLM9puCaTrGR3nLIYWMdIqTXf4+5wSFnJORlV0zR8x8HQNdKiRJ8qGN8LGjgacZpx6fYOb1y9ja7rrC+1ObW2xOm1Dp3Wh0dXfRpkRNM0WV5eZnl5eU6I7PV6dLtdrl69iuM4x/zsj250Z8/nDyqSz0homvaxB+5SSq5evcrNmzd56qmnjvUgj7bOdF1no+2x0f5kRO0+6Hsfba/NDLv+X9+5w797Z5+aY7LgW1RCsh9m/IN/d4X//n//HAvTXfYskVy6tc0f/tlr893eveq3vquqjaKsCOOUUkgsQ7Vbnj/Z4kwnoBfllEWOU4SIssCvt0jzQu3eXcXYTtOcoqpo1gJevbHPG1tjpATH1BilJRfvjMhLwaMrNTp1h6KoqIRU6r2acv2btUaklAz6PbI0YWN1ibGecneYIh0Dy5BMkpy0FDy2WqfTrCOEwDKtI46JOq7nI42EVt2m4TlEcUSWZZRlRFTp3NzOObfSYKHZmBJaS4pCkGYF+5OctKjoBIdInYZr0YtyeklJfQrtBYnvOJimznA04dqdXSaVzXK7AaIA0yCwdfpxyd444cJKbbrpkehI0qLAtk003WB7PEFHtdnUkWGUVGQVPLpkIxbs+SI9a8GVlWR7UmDaLgu2Rm6rRbIf5/TSCR1NEo8GhIMeC606Y8PC9zyitGBrEOKZGoGrhDHt6SK7H2Ys1635sP5opNNBfsM3iJNEtTlNk5ZlE2UFeSnwbGNKJPUZhcnRkdj82s6qFd91KMsK31W8mTjN7qtWTNNA17T5PSuE4M5ejzt7Pb7xGtR8d2o53GFztTN3qnxQfNqs9qOEyJMnT1JV1dzP/sqVK6RpeszPXtM0dF3/yK22HySSh4wPc6I/jkxKURS88cYbRFHEiy++eJ9hzOzmq6rqEyctHa14jv7OJEl49dVXMU2Tl156Cdu2kVLyb97cVQPOaSvLNDRW6g57k4yvX+3xV549TIDv3N7njb1XHoikAvVgCSGJkpS3t8fcHuXklaRuG5zruJxa8Gn7FrZIGSQjWouL7O3tH75fqvcCIDWatYCsVKQ9pFT8FU3DQ1nGXutGPLnRJs2KOXL0cCgucW0LXdfYunuXUVyw0FnCdR2ePKH+vjdWKr22qfPISo2nNlpzu9uZj7ptKR5InOS4lk5capRVieu4uI5LWQmKKMPUJPt7e+zt7tJuNjBth0a9Rt13QU+PORmq66RhW6YiSLZmCUbBaMPehIODA/xGG8/UcW2DIlf9b6mBZ0n6cakgxlISeO60dadRpTm9qCBMcxYDB9ue2gqLisCBbphyesF54MIel4IkFzhGRV5q6IaObZosmiZbcYRXa7K85OBaBvu9PkkY0uv2KDSTMDZo+w5FUVCUJbZlYepQSkOh6RDH+DSghCVtSxEY7RmZsyxJCvVbzenGxDYMepOEvUlGb1xgIqgX4hhjv+a5cyXkfP7cKqHPWbXCtFrMi/d/rsMk4/rWPm9du4OuaawttTmztsSpE0ss3VOt/HmbWhmGQafTmevvHZVvuXFDIdeklOzv79Nutz/02vID1NanGA8rkzKZTLh48SJBELyvw+Js1/Bpyb3DcfRGv9/n4sWLrK2t8dhjjx2+RsI4Ke9D0Bi6hobifoB68P7om69ze3/EuUeWSNNy3sKahZSSRi1gHEZ8++aQawcRpq5h6hp7aUY/ynBdh3o5oTccsbKyiuu67O8fwD27RkPXsS2TURjRj3LCJKPm2liOSn5lUeCaOqnQ2e6Hx5R4D0NjEiXc3Tvg+rAi1xyMJGbBLzjXcfncRoMoq8hKQdO3CRzzHritqmpm7TbDUJa4L98aEuUVnqVTCckkLek0XB7ZaGHoGqYOB70Bw+GQvb09HMchrWyKSmBYJqauU009PbKipH6MTyAZDocMBkPWVtdINIdrgx6ZqTYFtm2h6zpxIbENMHSDuu8yjuJpIlUS70jlfFhWFTITWJaFqASaruM6Jq5lIUR5bFE0dB3H0ijKAls35/dQmisWvBQCz7ZYbNZIsnyKQmpRVhWTKGYnmdAfT7B1CHyfLEvJhYFl6hR5jtQ1PNdG0zQOJhlRVuCaBp4B/bii4ap7Ja8kcVGx3nSxdEUWvdUdc/UgIhMaZaFRVhrJXsgjHZ+6a05bkSn3hzzmZc80eVvmg2crmqbh2vb8PUJKtvb7bO33+cbrlwg8l1Ori5xdX2ZztfOfXWdr5me/sbGBEIK7d+9y48YNbty4MSdEzqqV9yNESimJouhTc0f8tOL7JpE8TGtrRug7ffo058+f/8DK59PiqhytdnRdn7s+PvbYY2xubh7/DrrG+eUar94e0nDN+ffNCuWed7YTMApj/uBPXma3NyTJC+IkwzRNAtdBopFMZU/qgc8kihkmJbf7MZ6l40wJYq6lBsPfvrLLcwsVG+sbNGqBQhdNiXyzcCxzDreVUs75CEVVYRzhXBiWhV5IfOfBu64kSTjo9ni3D5k0qTmAKLnbz+iHCV95bIXVtoeQkjTLSfP336XqmoZjm9RFxrkFi5u9kriQmIbJiQWbcwsuuqbRqPmMw5h2e4F2e4GqKonjBDEJ0YuUG1sJzZoylSow6TR8Ti81QJZICd1ulziOOHVyE9/3IEzxbV2pCLsmeVFQVAoddfZEk8VmTcnhG6aCQiMRQtLwLALHYJQWLDd88jynkpJhUrLR8pCywrJMvKmsfJjmJKVAE4LANgmzclr9KbhtmFX4JtRci8EkQkroxSXduCLOBZYG7UadUVLgOSZZmhBHSqp/vW4yGQn8KWrtajcmzJXHiWmY1F2DhgtRruZDhq6xUrfZaHn4nsM4TrkzSEgLQcs3icsKaUiSvGI3qtjoNA6r2PcJ17YopnOTbG6xoOG7NoaukxUVZanagskH2EeEccLtvR7v3NhC1zQC28CSOacfGbHc/nSsfD9s6LpOEAQ4jsOXvvQl0jSdVytHCZEzNNhRP/s4jh9KIPbDxNe+9jV+4zd+g1deeYWdnR1+//d/n5//+Z//2Mf9TCSSD9va+rALvRCCy5cvc/fuXZ599lmWl5c/0eN/lJhVIWVZcvnyZfb39/n85z8/Z9zeG3/tC+u8uzthZ5zRcE2KShLnJc9uNFn3Bf/s3359LiUCagcjhJjvAE1dpx54INWub9iNKCpJYB8O/KqqwtAgTAray+sYpkGUqvcLCY5l0Qg8BBDF6ZTDo95bd02WajZ3h4pjYJsGFTr9ScJqw8G3NGV3axiUU4Z0OJkQToaMhEsmSxYCa/79HVOnFxVc3RvzhTMd4jTHMgx816SSkiTNpp8t2RqmbI+Vb4pvwam2x+lFnxMtjzAr5y1B2zAIPJeyqtB1DSGgFIIwlxi2x+aJGq2Fklv9hK3emLIs8XRBy88YD0sC3yecjNFkyZnTp4kKwWQYU3NNzi/XuLIf0otmUGhYa7qcWa4zmKg2nK5pBJ5NmFbEeY5rGpxfrnGjn7M7iucFX8s3WW/aCgVXSJKsZHtSsD1IkJqOZ5vUPEsRRaN8+ltUYmpYBnGWY5om26OUawcxmqakYcJSGXetLdSIs4LStFlseSzXLOpmRZok7O3tcTuEDIemb+HYJhJBd5zRqdl8brON1DRMTWLr6l6K04w4rwizippjoKEhUdWZbymp+53+BM8ylCy/qdBu8RHe0b3s+MOQ89cZho5j25iGju7qD6xWABqBPx/yCynZ6Q0Zjyf0/+jP8F2H02tLnFlf4uTKIq5zP4Lv046jXQjXdY8RIsfj8Zxl/84771Cv17l8+TKdToc4jj+1iiSKIp599ln+5t/8m/zCL/zCJ3bcz0Qi+TDxYWVS8jzntddeI8/z95Wlf1B8WolktmC+9tprAHPXx/eLF88s8H/5uQv8P791m9v9BNvQ+Kln1nhxTef3/+Q78/bb0UQyC9eyqKQ8IjWulGcty0IzTKQoqaqKcopG8lx7XqUc/b5xmlGvB0zCGEPXqXkuEkmSFggpeWa9QVYKhqlgkhcgJYuBzbPrTTRNOyLJrpBZWRyxtnaCve0IXTvewkHTMHTIhD7tqWtzFBFMF2Xf4ep+yFu7EVUlsHTYTwS9MOfpEw022h4L/iEIwbJMhvPZChxEJVe7CZMkAyloexZfOLfEU67JI8vq/tClII5joiii1+uhaRpm0OQbV7tkQkfTdWq2zsmWzQsnW/SjnFJImp7FStMnyw4Xy0lW8MrtAcO4pBIC37V5bK3JCyddtvsmeaW4Nm3PnFeAUkpuDXJudiNcS8c2JJO4YDCRnF+uEbg2SV5i6pKVhsvN6z1AmWjdHaaYhjb3P/EsnUwaDCYJz6zXMfQajanDY5RkNOo1oqxiZydEz1OyJCEKS0zDxDBM+qGkXCgJHAPTUO0ww1D3QVLE0+Qx/bFTNXvPdRmGCVI69/GWZkgu01Azpw/im1iGMfWsP0p6nVUrBlmh7A5qgTdPIrM4OoeM04xbuwe8c+Mumqaxutji9FqHMyeWWV7486lW3m9mo+s6rVaLVqt1jBD5z//5P+df/st/SVVV/J2/83f4hV/4BX7mZ37mvs7Fx4mf/dmf5Wd/9mc/sePN4vsmkXyYhX5mhdtqtXj++ec/Eufk0/JWVxLjSqLhc5/73IeCAv7w+UV+6OwCw6TA0jW+8+Z7fOu1mxiGQc13QUKUZsBhGyrwlMyFuOchXfBMAhMGk5jANhBVgWa5iKrg1IJ/3zxG01B9/lBJcsdZwTvbY7ZGKULCmaU6F1br/MWnA24ejIkypTy8UneOQUOlFAx6PbIsY3FpGakZOIaGZpjYU4Z3WaqkohkWuix5kAqwkJL+OObyfgSiYrHmYhgmlajojROudyPWmu7U6taYJsLDRWh3nPL63TGaBr5lgG7RzzRevjng+fXgSCI18DyP0WhIENSoNVp84+qBmh3oCr20F+lMEocfubDChYZPWVZImC+YoFj27+xM6EeF8nHXDUo0Xr3Z5akTdU4u+niODZpygqympLVK09kaDAlsfT54r9k6k6xid5TwQtNmre6BpmEaGp5tYZqGQn4VxzW0XMehSlKioprLqRyVN/FdB92USEJ818UyfYQQ5EVBmuWEYcSdu8rbxPd8TNuZ+73bhkYrcIkKiW8ZSCSObdObxDRdE+9I5ZsWqpJKC0GrJvAMoaoV28KyTMVDSrP5ZbdNE4Gco/MOQx67pjXfQ5v+jqPVilIiPuJxM22xSSnZ6Q7Y6Q745ptX8FxnmlSWOLnSwXM/nWrlw8qjzAiRv/mbv8mv//qv8/jjj/P888/ze7/3e/zyL/8y//gf/2P+9t/+25/Kd/yk4v9nEsndu3d59913OX/+PKdPn/7IO46PI674frG9vc3bb7+NYRicO3fugTdVmJa8fGtAVgqeXm/MeSu6ruEa8K+//l1u7yqCZFVVhPHsHGi4jqkkwV2HUZg+EL1lGhpfOt3iG1e7jOIcw9QxKVlvuXzhTIfAtSiKkiTPMQz1kI+jBM9zKSrBt28O2Rml6NOB/3euH7A1yvj8hs+pTg3bnLawjixUVVUy6HUpK8Hy6tr8d59oudzsJewPI+quiWkYRCXYpmCj9eAqTUqJ0E3GUULTsyjLaq4bVnMtcqGBYeI7OnlR3YdEujNQkvBtz0LTFI9EkzkHo4xuy+bcstqdDkZjtre3qNcbnD65zhu3egjdYr3jK++XokDLc3rDjO+8E/PMRhPH9RQSzHLJioK8qJROVlLS9q0pb8WkKAoSYGuYstpwCY8h2Ww81+LWQUhRSRruDB6s5GYcQyMpKgRKS0xIQSohyQvKUvmyeK6DpmtomnJqzHJVLRm6hvGAHbGh6+RZjK1DLjTqjouQAkM3yKXBsh9wfs0njiO6/b7S2rJsDNulUfNZDUyudWN20wwhlM9Kux5wsu3M/V0macnl/Ygwq3Bdm7vDPr5t8siSryqW6WxE06fVhqaRlRXlB8zG0DR8x54niNlzMKtW4ihU94XvMYmSBz4PAEmacf3uPpdv7yKEYGWhOfdbWW43/rPqbGVZRp7n/L2/9/f4+3//7zMYDL73mz4D8ZlIJB8H/iuE4N1332V3d5fnn39+7k3wUeOTbG3NZjRbW1s899xzvPXWWw8s5//0Spf/9n+5Si/MEag5xi987gS//CNn6I0m/MFXXz4Cf703JHmh4L2jMFVzCdNUrObs6KJeoacjPrcokBsdSqk4E8t1ByFKJrE6p4Hnzi1hi6LAdR22R5ny9nAVugkNdMNipz/htq/jWYfIKkM38D2bLMvY2tkHw2BldRVNO3woG67FsxsN3tmdEGYCNIFroPgiNVdxTnSdJMsoSpXUG4HHnd4EQ1fkQt04ItJYVVSVxNAgzUsljujq5EVJmimGeZQp7SxdN+a/bVY5JXlFmGSEYcj+/j4bJ1ZZXuqQ5uVcckVDcZgMw8B1XYSZY/vKm+Wgpx7yGVqn1aijmxaGaShGu65TTBdM29RVQpASfd6WVIrFg3EMssKxTDTTwjF08kJJjhRSErg22hT1NRvgz+4BA4FvCA7CgsWGCxoYpkUUF6zV7blcDSjDsAKTre0Bjqlzoulwo5ewM5hgGzq5UBDtC2t1At/CtCxqjRa3ehE3+xHJIEFuT2i7sNrwqXyPg0FC3bU52bYJHB3PsTEMnUsHQyZpwcZinTTLCQKbYVxwq59Qd835NZBSUlWCtKwoK4FrW9iWoWRmksNqRSG4rAcIRx5WK3lRKng3imn/IN4KKFuBoiznJMnd3pDd3pBvvXkFz7E5udrhkZOrPLK5+j7P3oeLhxVs9Dxv/r73m6V+1uIzkUiAqevb+/dOH5RI0jTltddeQwjBSy+9hOc9PInwk0okRVHw2muvkWUZL774IkEQPJDdfneQ8H/7w8uEWclCzcbQYJyW/PPv3sWuIrTJwZzA96CwDAPHMggTBeM92pOOc8E4l4iyQEZddN3k5MbGfQKPs/BdZ25Vq5s2/X6fJJqwGytCpKFr05aKQVkW6LrG7jjlwsohaaoSgt39HuF4gOX4bJxYRdc19scJvUmKaxos1mzWmi6biwF745SqErR9C8vQEVIe26n7roNtGaR5RcM1aPsW+5N86mqokkqYlpxba4IoERxvaTm2GiC3ay47oxSQ8+s7Y7u7lj6F9w5YO7HKQrvNcDowb3g2+qTCsm2q8lCMUDNt6q7F0nKbjpRkWUYcRwyHA/b398k0mzwzKAwNyzNxHMXlyEqlVzVLIhqKbDeezrMarknbM9kdxdRdE8vQqNDRDIv1ljO3uxVC0Ovvk0mTbljg2oJzSwFSi+mNFYlQ02DRt3jsRJO6a1NWFb1JzM1hyd5wMCcRNj2TUwse47Qkyis6nsmpTp3AUr4jrm2xNcnZnlSYlk3Hc8hLwSSrCCqNphixZOWYCIokJNc8pISkUJ+33KpNr4VNXpTUXJMwq4jzat6K812bJCum8w1VqcyqFd3Q8RxrOtTnA9FgUkp8x2YUxnP5HdAIpppgWVGS5TmeY5MfuZ73RpLlXN/a5+nzH38u8TCCjWEYft/5tcNnKJF8rzBNk+zITnswGHDx4kWWlpZ44oknHtoKdxafxIxkxlmp1Wq8+OKL8xnNg479x+8dMElLluv2/KZpuCa37tzln/27S/ylp9VuSNcUiQuNeU/dtdXiUFTiWPIVEl67M+TKfkRaqP59YMJPPLVMs+6TZsV9/ee67zKJUsR04Lu4qFRP0zShGg8pipwsExiGOVUKlkg5VQo+EuPxmGgyot5sUavVGcdqNrE1TCmlkvto+yZfPrOAVgkW/fcnZ9mmSVZU3DiYIKWkU3P54rklvnNzwMEoASQasL5Y52zL5kGzlbwoyYuS0ws+e6OUsJAEtkVeFIzjgrZvQTphlERsbm5QD/wjiUwtxK4esTcMqTsmpmmRlBLHqFhpqJ66pmm4rovrujRbCxRlAVXJwc0+W90Bnqnj2CYlBrbj8OhaC8+xyIoS17bZH0V0Q9WGChyTc9O2Ty/KiXJJ3fNYDWClbuPYKuFevXWXy72C0vC4sxvhWqZyXlxwWKmZ5KXEsXRanoWsSibTVuh2WNENczoNH1lVFFXFIC6wDJ2n1pQAZs1XRMpZognTnOu7I3QkNcfCti0CqWHbOeOs4OzmGsPuHoZhkGUpw+FAVX6Wi6ZZJGmKOALmsC2LAkV6lFPiZpLlCCFVtalrx6yPFW+mxNR10rxQCtamSSEqkiSfX3YpJfXA4/ZgcM9mSU5niSoagYdEVc/vV63YlsnP/+jnWV9euO//+6jx/y+mVvB9lEiOSsnfvn2by5cvc+HCBTY3Nz+R7P1xZyR7e3u88cYbD+SsPOjY/UjtnmevE0Iw2LlFMewRHbHNVTv1w51YM/Dniz4cR21dO4h4Z2eCoYNnCHTdJKkkf/LuLn/xyRV825i3wIqqxDQMxlFyD/NeSZd7ns+5NZ39fIKQJboUZJlixle6xZKnkWUptu0wHPRJk5j24tIckXZpL+RmL8a3DWqmrnbFIXzj8j5/8ekTGLo+T4xHw3Us7vZjXr87JExLJOBZBueXAl5Yr9Ft2gjDoOnYNFwNUd1/zaK8JMkFnYZP0y14fDXgRjdmECboGqwvBKxaGbooOH3qJJaldsV5KRinJYYOTc/iqRN1ruxHjNMSE4GrC84vBSw1fBxL2Qz3Jwk3ejF74wzTsmg6Go9vLrE7StkfJ2R5iSEz6kbC+CCDtEaz0WBvkvHWTsIkTue78U7N5sm1OqdKD8dxqMocbyqamaQp13d2uDmBTHPp1HwcyyBKc+4MEwxD43zHm3utzFpguq4hMNjpRziGTlUW0/Ns0zFtwjwnzEpOLNQYR8fnbHkpyCuBP5VFqSqBlAJdCgQ6lmXj2jaGbdOo15FSkqYpsiq52R/SzypangJX2LbNMCkIbBNTk2pRlxAWcPMgZJKWWIbGasNhtaGAG3P5lKkQ5n3yP44NqFbheH4e37/qDqdcKBUzlr1OVhZkWYFr2/zCj3+B1cXWA4/xUaOqqo9smDVLJJ9WRRKGIVevXp3/+8aNG7z22mssLCxw8uTJhz7uZyaRfJjWVlEUvPnmm/R6vQ/kYjxMPGxrS0rJtWvXuHHjBk8//TSrq/f3VR/U2jrT8ad+4gKqgu6d6xRpQikkndqDUSSNwGcYxoceFZZF4Nl4rkOc5Fw7CBESbFFh22reYJmScVpyZ5Dw2GqNLC8oigrXsYiTTBEZpSTJc+7No+dXW+xOMq4dFGQVgIluwHrNpGEU7Ozs4to6uqbTbLXnpKpSCO70U2xTn3vJ+76HlqT0o4pbBxOW6w4g8RwHy1RzDUM3OBjHvHJrQFoKGp6FBsR5xTu7EwLHYHPBxzQN0qxAVALHsnBs5bMyjFLe252wPUzBsKAasNZ0eWKtzlrTIcwqNCmY9A8Qpc6pU5tIwLYMbg9S3t0ekuRqNtLwTJ5Yq/PFM21KqVBPNcdE17R5tVNUgje2JwwSQc21qYqSO1HBMC544WST88s1KiEV674sKfOMKIq4u3vAtVBHaiYLgYPn+0ipcTBJuNOPee50h0mcwTSJFEXBzs4OwrApDIOGZWCbOlmeY2iSmmczzJm24ap5ItE1DcPQORgnVEKgmYfPWJ7nCKnMunzPRUqo+cf92i1Dw9R18lLiB0qaRghJXompi2RGmuc0XBffdRjGBYXhkVc5T51Z5fLuhHGSE8c5+SjGNnXWXA9TU8TaflxyaT+iEpK651JKyfV+SlJUPLHWRCLfVz5FCEGYpNQ8l1GU4rk2nmOCZswhybPwXWfa9jy6vshj85ZG4POXf/h5VhabD/y8h4nPoqnVd7/7Xb7yla/M//2rv/qrAPzSL/0Sv/d7v/fQx/3MJJLvFUIIRqMRQgi+/OUvfyyzmQfFwySSsix58803GY/HD9TwmsWDWls/8dgy/+K7W1zdOqDo3QUkRaV0nJ5YO34cTVPIlHEUH9sxVkIwiVKkZiCkYJIotVXHc9CkNn8vGqRTaXfLNNFQ/WYhJEVZoV6idmgK61/g2RaTOOXZ9QYnmi574wwJdAKblYaDmCKzikpgWg7dXh+dHo16gDBdsrLEMY254GaR5xi6hpCSrDy0u02ynDiVNGoeaZYzyCSZ1Gh5ytsDoOaY9OOcnUnO5kJwRDpFU73v6WJzeS/i9qik4XnosiRF52Y/RtM0nllvEJglOzt7uK7D6ZOb89787V7Ea3fH6Bp0Gh5SavSilLe2J/zwI0uYspqjqY7G/iTjYJKy2q5R5jmmCb7r0U8qDqKKU+3DtltQr1GWLn6tTuHEyHhIYAqiKCKMQizTQkOnm9gIqexxkzQnSVN2d3eUiJ9bp5qMCVyXfKoqoDHjwKRMYpeaayl4r6ZTlCVJVlB3bTzbJCkqLF2ft3SirKJZ86iKnFCqc5iVglEGSSkwEDRcg34qGcfKQTGvBFGmJFN822AoVeXyys0+/aQizXMs02Sh5vL4eptBlJIWAsfUCAxBzZLcurNNVVVspRaZNFisuegokqzUYZBKCqnh2yZlKR7YgkJOW3GJqqLSLCeMc2zbom6oof8swu/BtPdch7/yoy+w1G584Os+ajzsjOTTFGz8sR/7sQ/csD9sfF8kkm63y+XLl9F1nS9+8YufCDxPSsl/vNTlX7+xwySrOFev+MrJD48nj+OYV199Fdu2+fKXv3xM4uDeeFBrq+6a/B+fa/Lf3niLrUqZVLU9i+dPtlhveVPVXW0+0zjqCHgYaoeZZRnDXpfArEhKDSQYppJYyUt17KZn4TsOaVFQluWcqa4SkxpmhknKQZiTlOAYGmeW62gIllBS9rPIspRRv4du2awtd+ZleFHkitQ3GaOVOZPCxNQ1yqLEMHTyUvli1J2jt51KIso2F0ZhQlWUaI6jdNE0KIsS13EIk/J9AQhJUbEzzggsA0PODLwcLMtmPyzoj0PG/S6NRp2TG+uEccJskb87UEm16VtU0/O96Nv0k5JuVLDZdo8N8mcRZSWWZVMWxVwCt6oqtKpgfxxzruPhOfac5FnO2nCaggUHgUpOVakkQbJccNDt8u6VMfXAxzRNwvGQ9dUV/FqNYZRR811GUYJ/D1/DtRT/RAhJWQrKqqCsKlzHxjJNHlkVvHlnwDAtcczptbBUi9LQFBAhzAXv7qo2k64rAETDd1ms2URpwTjJMQ2N9abLmc5MwkOyF1XsxRWBBUFgU0nJ/jAizzNeONkmcO0px0NnHCVs+nWiNOPWzQG6LBmOhui6jm3ZeL7LMMk5GEXTyvxQOiUtSvK8UCq8nnNfgpi1tqpptRJ4DlGc4cwQjQ9w9ww8l7/6419gsfnJM8kfZkbyacqjfJrxmU4kUkpu3LjBtWvXOHnyJLu7u59YEvl7/+o9/sdXtuayE3+mwb+9pPM/nc9YaXxwX7PX6/Haa69x4sQJLly48KGsPY8mEiEEX33lXV577zo/8ViHJK8ohaTmmGjaoequ7ygZbtuyqPuegrXmh/IomqaRZxnjYQ8vqPPcGZ+vXekxTktcU853/8sNnyc3F0FWlEU1l7U4Wv8nRcV3bo7YD/N59fTanQEvnmkraK6nFoODbp/RsI/r12m1mseOYVk2zaZNs9lCq+V881qXfphiUiF1E6EZbLZsGq4+PS/gOe48iQBTv/GpedZ0121ZFmmccrbTxHMV9PbeHnIp1X82hyZaZVGgCUmUZOzsh1w4ucpSZ2GKzDp8f5yXc4va2eeVZYkoS4ZhwqKnZPeDqatjkuUIKah5LsVBDLZ1TEu9FBLH1OeJY6Y04E8l3TsCLGNCkqv5g23bOI5NWKWcWgloN3XG4zFZlqHrOr3RhElacHK1w3oqubJXUmUl9swuV0g22h6GruO5FnlesjdO2R6lczmTE02PZzZaHMQVk6RgoW6y6Oks1axDZn0vZpyWLPhqE+I4DvvDGFmVPHWihhAujcCl7lqkmbIVAOjFFbauY01334am0fRMxmlJP8oQoqI+ZaJ7roVlGEpbzI0ROPiWalsjBYPhmCgXDJ0MWwR4ns+wrDgIc0ZJiedYrLd9AvUAzC1/4TizfU5IvGe2YujTakUDUzf4+R/7PO3Gp9NKetjW1vebhDx8hhLJfQvDtG00Go344he/CMDW1tYn8lmv3B7yP766NV9LZsmklwh++0+u8ff/yhMPfJ+Uklu3bnHlyhUef/xxNjY2PtTnHU0kSZbz77/1Brd3uvMb/ygbeBZ135vqZ8ljvBDHsnAdJXqnIQjDCYudzvzm+6FzC7y5NWaUluganO34/PCFVaI4njN/PddD0yBOi/n3emcvZnuUUHcMTNuaigoWvHxryE8+tsQkShgNR8TRmLXVNer1+pyEN4tKSCopWah5nAA+f6rF1YOIOK/QpWTJgyUjZutuSL0WUA9qZFmOZR1Wc2tNlxu9mEFUKKFJx6U3jPBsg+VADegt08B3bYSAOEuxLYtSgIEgK8Gcnk8JTOIMUeScWO7QajUZjFWrq+YpyZAkK2h4FluDFBzFMi6KQs2uNObXRgh5qGdm6ASuw1rL4spByCjJ5/OcaDpjWak7NAJvaq+rAZL+RJEjPcvgzFKNW4OMSSHRZEFalNQckzOdAJnH5HlBZ2mFnbDg6n5MIXJevtHlRMNmxbEZ5jpSN2nWDNbqJit1m8BTs4CtYcJ7uxNKIbENnd2spBvmPL5a54kVD9Ook+cFnmtjGgZZXjCMU0ZpNZ0D6di2TZqm1BydcVqQFpVynJxyj6RUiD/DMEHTj6kagBIgFQKqSlL3vTkkN0kLhmWGoWustXxujzJ006Lm2KplWeqs1XUW6xpRFLF70Gc7MYiFrpBrlsPtXsjpRZ/Ti/7U8lcjz8v586QUmB9M0J1VK43A4xd+/As0a5/e7v8HieQ/c4RhyMWLF3Fdd+7VEYbhJ0YY/Pfv7GNo2jE5EU2DSsIfvb3/wERSVRXvvPMO3W6XL3zhC7RarQ/9ebP5S3eoSIbDSQQwHxRXQhDP3AylRj1Q/IIHPQh5WZLmBZPhgKIoWFlaYmmpQ5zlCCHYaCtXR+WXrrFQ9wnjQ2SW4LBNpmQmbCoJd/oxrqkr4iFqV1l3TIaxsoe1ipAsTVhcWgHDmic5x7aQaLx+d8TV3TGGZVMz+1xYrXNqwWez7ZEWAsvQsKYyG4YO4/GE/f6QPEsJfBfD9rEdC9/1+PzJFpf2QvqZJElTVuoOj6wESgEXRawbT6uYwLOREhbqHqc7Nd7bGYNUBMBJnBBnJU+st1hfWiSM1e+W93BWzi03GGYQlgK7VFIwUV6yENhze9lZ2JYJUiUoDXik43G1K5kUqj1oonF+yePcamvKEdGI8pLLexG9KEdISd01OdcJ+Nx6g1u9kLzUOLtcZ7PtMRn06A+GrK2tcn1Ycruf43k+lqiIM5M7UcXJWsGKlgEGDSugZvg0pygo0zS40VX310x/DJQFwe1BysZicMg3OtLmsU0T23EwNIlrm6RZhqEbKASGapceVtUanmMRJYqFbWkGSanR8F2Ykj6jrMAxdTpNf96C6oY5dwYpYaZmeYs1i7atEeYVaZZjWRar7RrnFj1MrULTWsQHEVkyoelIhCgo44RKM7m2V9Jy9SPoRQUOaNV8SiEf+OzMolUL+Ks/8UUawSdjXvd+8YNE8p8x9vb2ePPNN9nc3OTRRx+dVypH4b8fFxpXTglp9x5HA6oHDKLSNOXixYsADzXo13Wd27s9/vk33qM7UZaqC4F9XJzQ0Kl5DppmzO1wH/jdy4pRv0ucFVSGwzv7MeZwj8WazfmVJpZhkBUFtqUQRmGczJnQ97azhJQYhs5ud0JRlniOjWlZSCkoS8UAr6SkNxiwYMup3MnRW0bt6P/sWp/tUYY/1Sw6SATDG0O+fLbFUs051s+fDZGDWp2gVmdrEPPazphRMkIKwUpg8NSqzwvrdeJSA03Hs/X54P1o1AOX/jiiEuBYOucWlXz83WHGOIwQVcWzpzo8udEkPiICGOcl26OMMC3xbJ3VhsPzm03evNMnLiSWZXG2HXCmbc8TK4BhGlw/CDmYZBi6mhutNhwWA4t+VCCBlm+x1qrN3QXjLOf1u2P6UU7gmFiaxiAqeFckPLum8+y6GvBKKenu7RLHMWdOn0IYFvt3D6j5DrYmwTDwLINBXBBpFo+dWSNNEuI4JhwPeH1vF8/zqQyHpBAs1H1MXfmZSCFp+jaTtGQQpg8EDhiaxNMFg1xikOM4Npqm05sk1ByT5lT0UUpJUsE7twcMooIsFiw2gUqyO1SCk0UlQdN5dLWBZ+kkGfSjgnd2lQyMb+nTzUvKZqfOY22DrLQxddUSM3Qlae85NpMipha4ND2bsiypyoq8yOlFOVdv77Bat/A8H9/3MHQFAw40YwpQcabunPl8ttZu1PirP/4F6v6nm0Tg4YbtURSxsPDxOSx/3vGZSiRXrlzh5s2bD4TRHrXD/ShijA+KH32kw//7O3cVWmm2YkvQNfjKo51jrx0Oh1y8eJFOp/NQxEcpJa9e3ea/++ol9uND4tVaw+FHH+3MF1nL0EnzkrxQCriBp5A3yqJ2iqjJMob9LlIzKL0237xyQCEKdF3NDN7dnvAjj3Zo+i4SNdjGsoiz7L4komsavu8wiVIC16TmmEzSHJNDj/ekVPIjNUtnZXXpmNzJLPYnGfthTitw0KUAKkwLhknJzUHO2eWmYivnJY25Yqv6HrvjlFfujCkriec6VJVkN5VU+yVnw100BPUgQPc9DNOet8CklFi2zdcv7bIzUjLzDc/kkaXp4h/3yFvw6Jkz1F0HqUliodp4gzjn1TsjNVDWNISErXHJEyuCL59tE+cVhq7hWSp5+Z5qnWRFxdcv77M/ydCnUPU7g5RTCx5Pnqiz1nTRdR3XMhnN1Zclg7RiUmgsN32qSl3Hmu+yO4i4M9Bo+U2kFOzt7VMUBevr60g0euOErKgILBPLUlDpoizwbIMwKymFxPd9VpcXGYcJrSnQoTuKiMKcKovxHQvLsglqPlkh0I2KB03zJBJNajy5scB3rh/QC0sMvaASEtvUubDRotOsTblAOa/e6pIUFZQ5WSXZjyoWfAvb1IhzQWAbnFwMWPR1kizH0HV6qQTNZDE47ATUPIftfsiy37iv8iurikmcUFUluqarc+s4lFalOCTCZGXZp2kJ4jhiMkyZxClurljrvu8TJYfVimObLLcb/NwPPUfgfTRux8PGwxISf1CRfIy4fv06Ozs7fPnLX37giZwlj08ikfzw+UV+5JFFvn61p25qqQa/jg6/8pWz89fNhCAfeeQRTp069ZErobKq+PfffJ1/9s0bbMcatq7K70oo6e8/vdzlLz65QuA5pHlxpHUg5+0nKRVJL88SBgf72H6AGzT50zd3KYRSYLUsi1IItkYpV7opT62qmUwsFaDeNEz8KXImzjIMXccwjHmrx9A0Hlut8d1bI0ZpoYa4RUklNU43dU6eWMZ3lcJumpfH2PFRAVJq0ySiQkPDMXR2hxGTWF3LRs1Hk8oDPZ7OfK4eRBRTmRQAwzVxipJBWuKur7DgGUp+ZDQhS1ULzHU9glqdr767y/4kw7MNDF2jG+YM45zTXs5S3eWJk5uqBThtq2iA59i8uhUR5VKJKuo6umHQnSS8u1vRqdlzKXZ1FVQbsB64vLc9pBsVLDUDdCRlWZIWFbcHyodlreUrt8R75M/HcUaZ51RTr3HHcZBCYpsGo7REiIrd3V2khPX1E+i6Es400xKkmKoXHEHs6Qa+rTgTvm0zidKpW6ODbTu0Wi1GDNkdJRSVoCwTJmFIInRWGi5N38J3XSohuN2dcHeYMk4KGjWPZU/n2Y0G+5NMiS1aOss1Rw3Oo4Sa53DlYEKBTsMSJJWgtdCgqCDMBc+v1Kk5Fq6lqmIpKoSm5o8HowgdEFIN2k3DoCiU3lVcVCxwf5VkGQbLDZfLu2NsQ87tkbMKaoHL+kIdTZSsLi+yP4y4NtgiSkD2htT0HqsNi2bNx/N8ltp1/ou/8JxSifhzCEXgfLjW1vebOyJ8hhLJqVOnOHHixPv6Gs/scD+JOYmua/w//tqz/A/fvcsfvLZDlJc8vx7w+WDI2U6AEIJLly6xvb390EKQYZzyB199mWvbPW71E3QpMU3l92DpOnpRsTVMyKWBdp8Q3fHodnsMBn0WFpdoNRvcHGRkUle75mluM3UNx7F5d2vAY0su2hFkVnXE+MqzLXRDnwIMxHxYfmbRx9A0ruxHyobX0Di76PLUyUVAO0LeUnMR2zJBgEGMEBVC6nMdKVDtw4atBreeax/zSDF0Hdu2iEoN11a3oGWpIbc5Ra0p+RiHRqNJo6F27VmWUWQpr125w/bEoOmamIaS1TA1nf1RTN9y+PKZk9Pfe/h9JNAdx+wNQ3xLGSfNQBB1x2SSlQzjgs4RmLOyK1ZOk/uTDB2lXyZQlWwj8MgmGeE0dxyVk5+FPZ0LSSFxXGcu81OUFct1n2HvAM+2aS4soOk6udQYjhJcU7V5BnFBy1Oe9nkpCLOSR5YDfNtW1sCBSz/Mub4/JikqAttgo+1RCohKjaLMqahoWJIFI+PK1eu4rkMsHW6MlbaaZzt0Rwl7Q8EjSwFnO/ejmOq+yzCMGYYZRZIQI6jXazi2g28Y7I9jcqETeDZZXqBp+nwuBxLb0BinJZ6poWsGSaJmUYZh0Ao8ap7aYMzasBKdQkiWA5NeYNOPiilIS2IZOqebNoiCmu8RZyVXezkHqUbdt9B1l3FRoeXg5AW6GHHCbXPj2tUHOhJ+GjHbFH7URPID+O/HjPdLIEfjk1TotU2d/+bFk/w3LypZgNFoxCuvvHKfMdbDXNSd7oD/+avfJUxSZVkqwZiS/kRVQVWhSdAMi3FacGrRU4PPe+YzQkjGwz7jScjK6hqO41BWFaMwQZYFmgHG1IxIM3TSOKFEIVPUYPt4BVWbonpErj5HSIljm7i2RVkKNtuSupYQRZLFxUU870G/XSPLS2zTJExSTrQ9mgcZUV4SWIqRkpUCISXnlmrYtnkfB6YSyvnQkBVxUdIM6kp6w9Dnwpz3+qQ4toVr22SuR5BZGNEIDUGaKMayrhtKx0pzpoid+6vH2dk1TZOqqubKvJqmYVj2vOqaybY0Am+aALVj7we1oCl2uFLlNQ0dz7bIy+qYg+Vy3aHmxoSlRpVkylwqKxVzJ+5T2R6dxQ65gEu7CfuTlDwrcC2dlYaDlErMU0iJaehstnweX2vNwQJ3+xFv7UzICoFt2+xFFZ5Z8PypNmGckhY2rqWzGNhY0/MbRRHv3hkrC18nJy+UknOlW+yGFWeXDRCH/jD1wJ1vBNIkpqwki+062pT0KIpi6qxp4FhqkzFDBKpkIlhtOAzinFIzSNIYIWGcVtQdE0cX84F8LnRu9hO6YUZZFCzVHc52fFbqFZOpC+aCb9HyrTnE91Y/YW8Y4RuChmfjuA5lKTiYxHTWNvg//Zc/TJ4mc5vbd999l3q9zuLi4gf6p3+ceNhEEobhDyqSTzs+rEviw8RMXfib3/wmjUbjIxtjzeLdG1v80X96nUqohFd3TAwNjklC6RqiAl1WWFRzXkTgu4q8lmRkec6o3yPJC06sb2AeEb/r1GwMXaMUEl1UgEmRpRRC4+RiQM1z5jLqoBa9Zs2bo4iSouLdnQm3BmoQf6Lp8thqDS0dI8qCs6dPUlbcZ5I1O5YiEKpj2brGsyc8Xr09YpxUaIaBbZpcWKtxfuUoC/3e0Di14PH2vsYojHEtnUpIolyyUPc5s1Sb+454U7jzzGvEMVXP3LItQCPLMgxDo5IaeTyhu5dTqwUYlo1lO/NFInAMOnWPnWE8b6cBTNJC8Tn0ikpoh8rDc1VajZWGy0GYU1YCc1pllNJAlyVt3yTJChLUb7Usg1IoQl/g6nzhTIeLt/qMUwWbtXVoGQkbCw0WFxcoheT17Yi9QUTNNam7JrnU2JqUPLUaYOlQlGqRXKw7ZFPPjkoILu8rK+WF4MjvKSSXdsb86IVlxNTueBamaWJ5AbpTseJryKqgKArlZS9iEqFz0y05tdykHvhYptJjE0Kwu7PLoqtxUDgUAmxjqgWXC+qOQWBp88pXSEFcKkRWVSllgKc2F7m6OyItK3Q0Go7BI8seOgIhNKJc8PZezCTJ8SwdwzDZDisKmfPEss9a87BaPGpcNYwLTENDFuqczNwqg6DOhQuP4zk2nmPTbDY5e/YsWZbR6/Xo9Xrcvn0bXdfnSWVhYeFDbWq/V8w2vD8QbfwMxqdlhwuKZCiEYH19nXPnzn3kHYoQgq9ffI+X37mGPrWnBdC1nNMLLpcPErJSYFtK9iEvK84s+rSmC5qUco61T9OU8aCvhqknTtynN7Rcd9hse1zvJZS5oBA5eSlwLJ3HOmqhsS2FeinKCtPQpnBZjaISfO1Kj4MwxzaUQOO1g4itYczzSzqn11fISzlnDxu6kjEpSjFXiN3uhwzjAsvQpsgll5983GZvnFEKwYl2DddQcwDLtSnLmUfKkWG/Dk9ttgnzLnf6JYO4QEej7pk8s6bcBw1dtY/KSpAd4ausNBxqjkF3HONoFbVaQImBIXOe3Fgi8CCKY6LeANPQaNRrOK5Lo17n7KLLMMroRbli3QuJaxk8tlLD1HXMqaT9cJJQCkFRKYb8o2sW3TBjbzydK1k2sko5veAfW8R7Uc6lvZBRUqDrOgs1h2fWm/zUU2vsDmNGk5B01Ge5s0Cz2ZyioHT2hxEt35rzMTzUAnmrG/FjF5anMGt5rEIaJUr+XSkFKACA67pkZUw/zNgbhASO8v446sroOcq2oKgqPMuaL5xZUVLGOVkac/3GgFY9AMPCdV2l7By4bG4u8dqdAQeTnIkoMU0D3zJ4dMmfw7uVS2TIzjidS/bXfY8LqwE/+tgqB+MYXYOmayrXd6kUpXtxySjK5oRIAEtXaLClwODcsjKd0oHxEZtde8roR8r5HdZuNrGXNmkEx2ciW8OUawcRpbBZXz7Dlx9/gmgyptfrcfPmTd555x0ajcY8sdRqtYeqVmaD9o/yXinlD2YkHzc+rLnVJ51IpJRcvXqVmzdvAnD27NmPfOOkecG/+car3NjaBw4F5VRovHS2jRSCrUgjywt0HR5ZDnjp7P0wvziO6Pe6BLUGQaNFUVY4to1rm3MnQk2Dn376BH/65m1uDTOkBicXPB5fq7NSVw9OUVYIkeFYJlGaU/MdQOPNOwN6UU7dNRSXRgh0NMKsYkQNXTfm5yU6wrUIPBdd1/jWtR7vbQ/JhUK5NVyTL5xq06nZbLY9JUsfJ0g59W6fViTm1H1xkBSEcUYrsBFZwXMbDc51fEaJYpd3agpyK6XE91wGkwim4N9giqAys5xNvyRJBML0mOQSSyt5dKXGqQVfQT/9gE5HsjeMefdgTCUy9HKX052A59Y8dkIlC+/bBustl7ZvY1sGM/2vG92Y692YtFAJ7UTT5akTDU53JKNUkBc5nSBgqWbPocmTrOTinRFxXtHwbZCSnUHMJM548UwbLU/Q4iHnT6/j+zWSLKNZ87h1uw9wH6nPNnXivEJoci6xcpSZPUrL+fUBlC9Nlk2/z2E1WYlD3oxrmziazvpCjWv7E0xdzP1golzQafo8cqpJzXU46A/Y6U+4szUiLMBzKjaiA5460abSTMZJSVWVSuHXONx5b48ytkYpdcfAMnQs22YwiXnzdsYXTrdZqtl4ro2h6XNSq+dY9LcnSmFA06ZdXpUYpFROonGqREZHSYZjm9iWhRSCTi1nZ5SRquEV7VaTpY2zaLrO+aXD9uyfXevzHy51GaclGgop+dxGg59/dpV2u8358+dJ03Rerdy6dQvDMI5VKx+2S/Ew0F/4wYzkzyXezyXxYaMsS9544w3CMOQLX/gC3/rWtz4yZK8/DvmDP3mZ/jh8n1dIiqLgmSWDF88vkkmdhcDBMTXlVz17lYRwMqLfH9BZWjpW3uZFQT4z+9F1GoFLXlQ8vuyxZER4nkUQ2Pj+4Y3r2CZSMm9rzBBa3TBFMwxcxyFNU8pyKvRomexP7teTAuUolxclb2+PeHNrhGuZdFybSkiGYcK3bw74qcc7dBq1I0zu4zFOCv708gHdeOaEZ/LoSp3HllwarnUPt0FO5xOqippkJdcPIvbGGboOdTJONk3+6xfPcxCWTJKElmsROMdv5xu9mLe2JgjdoipzpHQZHVQ82opolCmrrkOtFqDrFc7Ula+sKm71Et7anqBrGp5lUAjJ9W5MVgp+/InV6bm05jpWRVmRpBlbw4QoK1lpKg90IRU6rB/lXN3pUxcRq6sraIZNkuXUfeWPsdjw0HZDSiGP+bxkpWCt5VOVYj6EPpoUarZOO3CZ5IIF1ySd+p+HWclS3cZ3ji9krmMzSTIMDdYbBoPQYBCX6EIt2U3P4vHVGg3fI0wy4krn3YOMUpoEnk2al7yzE7LXG/HUmo9pudR9j1bgKi2sKaJvd5xiaGqhtm2bPM+pOSa9KKcf5tQdUxFwZ9faV170Dd+jF6n7kan6iZRKstHUwbHMuRHYnV5EPy6m59jm/Eqdd24nVGaAu3wS0zT4iQsdNtuKL7I1TPkPl7romsaFZYUkjLKSl2+POLXo8aXTSkncdV3W19dZX19HCMFwOKTX63H9+nXefvttms0mnU6HxcVFfN9/303nwyC24AeorT+XmA1JP4mIooiLFy/iOA4vvvjivLyvqupD90hvbO3z1Vff+UB1UQ2Nuu/R6/XpLJv4gKwK0krJwLu2RVGWbO9sE4Yxq2sncJwHI0o0VItiMI6RUlCr12m16qRJQr8/5OCgi+M4LLabVKWDYaqWx9GwDJ2qrEhiReSzLRvLscmiHNu8/6HwXXsOTb7ejdEB19Copomt4ZqEBQxzDT/N7vs8UIvBy7cG7EcCz5Q4tkZaFFy81aUqGnzuZBvLMilKQZ7neK4777WHWck3r/UZpSWWDmmWsY+OEQSs5iUNG9quP9+lz4a8cV7y7k6IaVm4hkCzbYSU9OOCofR59tQqaZoQRTGiCOke7NOo17Acj2v7E7RptaXOmYJI91LBne6Etq/EBI9WXJZpkAsddwqtlVM4tKZBVZb0RikXLqzhOIo06brW/Df6BrQ9k0EqaHomSMEkzrAtm7WGdcRaF0ASZhV5pfgaZxdd3tuP2RmEmIYJuk6r5vLosj+vlCSSbiy4fH2XJK+wTZ3NtsezGw2GcTH/21LNpV33kEhkVfLWzT0qTNYWAnUszyEtKyoMMk2jzFL6gwE7Oxq+r2C27VYDw7SxTbBMa65SPIt7Cb81z2UYJUgJbVfjjqGRS4Oaa05NyBSR82SnrtSakVzei7gzzOa2xXcGKUs1i+dXXf7yX/ohbNvk9IJ/zI7hWjdmkpY8unxILQgcE9soeGt7Mk8kR0PXdRYWlNHbI488QpIk82rl+vXrWJY1TyrtdvtY4ngYDkme5xRF8YNE8nHiz7O1dXBwwOuvv87GxgaPPvro/IJ/WHixlJJX37vBV195Z97fPfRMr6btJw3TNDENncEwfqB0c1GWxEnCaNAjLyoefeQcpql8qY+KPEqp2iaDpIJexFrTUSgwTaMSGpbjs7LmYRkGZZHRHwzZ3t3DNC2CwMf3A1xXDfLXWy7v7oyVA5+rRCLDOEVWgrNLTeqBCxLiNMN3nTmBUEglRW8Zxx8OwzCgKOmPI5a9Gp7rYBk6eXGIXupGOYMUAlPOxRED20Bkkhu9mEeWaxh5iWnouI6yo50hzK53I0ZpScPRSdOEhmthewG3eyHrDWXde3SXPrPpPYgrCgzqeoU2peGpCkNnd5Ty9HoDz/NZXlxgEifkeUEcR3QP+gzDEsexKKupZ7tl4rsWB+OEKK9oP6DzUFYC3zZJswmBqeYOGhrjyYSirFhZa+M4auduW8aRHblqaX1uo8G7uyHdUC2QzXrAI0tKTypOlIR/WlS8vTPhIMyphMQ1Dc6t1HlmLWB/omTia47JasMhcCzl9a5pXDuI+O7NLjrgmAZJXvH29oS8FHO7ZF3X5zv+NE3Z2t6hMj0W6z62pVFM53T1KZlSGA1OdFpzM6s4jhgM+uzv7yMqm0lqYusCz1OyKXGi9LWa3uEmTTNMvnO9y/5EXbtOzWaj6bI7TtmNleBiK3B5aqNJ3bVIsoxBWLI1VsN419KRUkHNY83nxEaDL55uqTnKPYu4EtC8f40xp7DqBz3jQh5vN3qex8bGBhsbG1RVNa9Wrly5QpqmtNvteRusLMuH4pAAPyAkftrxcVtbUkpu3rzJ1atXefLJJzlx4sR9x/9eiaSsKv7Dt9/krWt35n+7173NMk0C11F8iCR9X9OuNM0Y9btgmKydOEGal5Ar2OXMvS1Kcr5xo8f1/ZCiqlSF45r8hXMLLNWPDxJdx2ZSVbQXl+gsLyPLkvFkwv7+HlJK5WkvKs424HZoMMkEaAJL13hkOWCzNVPiVUJ7lRDUA48sV33spmexN87wpmZVumFQVhVSVDSmA98kzZmNQZWWmEE3UVL3QXC80pup1+aVoOU6SHFc/0nToJcqgEKWxViWTb1WI89zKgGDuGCtea9cjUZZVeRFSVnkmJ4SFpRSKjXgqWS+FIJ6o8Zk2oqbufjVGy2uRgfEWUGe50gh0HMDTCXK6BgPrriaNY/FOMc1dUZJSVBJkjgmzCsWW3UeW+/gO4q3kmQFk7SkGylWftu3aPsWL5xsEmUVjmtDqRJrNIUM+47NazsDJUVj6QS2SVZJ3rw74Mm1Oo8s1+77TmGS4bkO72z1sU3lXy+qSm1g8oo7g4RTCx4118I0FAs9SWJ2d/dYXGiz3a3IsgybQzXgsqrQdW2+wGqahud5WI6D7jVACtplzuD2kK1ejGVMMAwDTTc4t9rk5FKdqpKUleDrl/fpx0qcE+BWP6HpmTyz3iSrBKaus9R0EVNItaEbindlWASuIjpqGpxYXiQxanRLqVqK003YLKHous5G28M2NMKsnJNOKyGZZCU/snxYjZRC8t1bQ16+NWKcFmy0XF48054n3FkcnZ2Amm3MqpVr166p36xp9Ho9Wq3Wh0oqYaja4z+YkXzM+DAuiQ9bkVRVxdtvv02v1+OLX/wizeb9Tmjfy243SlL+5z99he2D/gd+lutYU5kMhX6q+R6OZWDo+pyjEEfToXq9SavVukdb69C97e3dmMt7IZ5tKRhskTNOC75+rc9ffnoFy1DKq45jHyPhVZUEzaDWaFFvthBlQXd/j7SoWLIqOksOE2Fj2TZrzRnySJt7xM/aLrPv4zo2nzu1yFcvHTBMcuq+S5IVpHnJSsNh9b4FHYqqxMZEVjmWqSN0A9tQboFSKqc9zzJoBq7SURLHr72UUCQJUZSxUHMJAh+JhmGaSJnfN5xW515pMjVcA9c0mCQ5gS2mvwJyDM4verRq/jEE1CwMXeP0os/bOxMM28U2IUlzxlFG3axIB3uMyxqO66GbJkmpUWCwOx6yVLd5er3BuztjuqMINOg0azyxVsMzVQVaCcl2WPLO9oQozZFSDbtPLXg8sVpjrV1jHKdK2XIaQkju9CZs9ybUbJ2a76EhsYUgLwpu9xNOTQmlh+dOwbS3ehPSUuJbkE/JkLqu0wws+nFBXql/p7nil+zv79HpLFGv1zlRRLy3F+KYgrrvEicJ47TEtww2FgKCKSz76v6YqwexMsPSNGq2zlMnl5mkBXujGFGW1PQcK9zn2vUJS4tt7o5LJoXGaiugKgukBM9SrcdBkvPIch1zKhs0i0oIkjSjLHKEbU9bS4sEvk88KVg7sY5t21RVhRCCcZJzeT8myiuW6w5Pr9V49e4Y21TPTJhVnOv4vHCyNf+Mf//uAf/xUhdTV6rcr29NuHoQ89c+f4In196/5eT7Pr7vs7m5SVVVXL16lW63y6VLl8jz/Fi14nkP1vmaQX8/CauMP+/4TCWS7xWmac5JZB8l0jTl1VdfRdd1Xnrppff1Uf6gRLXXG/Gvvv4KZSUIXJcoy+4jEIIisd3tTtgaJWjARsvD1iVJpvzJPcdm2B/Q73VpL3beFzMupaTme7x1dwsdgS5LRKWqHcvSCfOKrWHKo6uKGHa0VXJvxHHMZDjAsFw21xbVA5okDEcjxpM+sZhAFtBs1HB8/0ibaBZqHtB2NF7YqHG1r5KZYZqcazo8vd44xmoHxV53LJMwTunUbJZqNtujFN82lJig1EC3eHKzNe2j35sUJL1ej7qeMbJsDNtRr5MQ5iW+Y3JupUngmSSpIgbOZNSllNQdk/PLPu/tqqGsoandZtOzeGy1Tjj1ezFMgyTLudsLySo5lXL3kbrJtf0xcaRQW5udGs+caGDrgiiKOegPuNYvGFRTBxQpaXo2T60FnPNTMs9S/fXApua55IXSrhrEOa/dHIAGbc/AtFyyCm70UtbaAbr+4HlbWghKIRWkuyjmMxjftlSCtixkVSGmbPKZWZht6Op8CzH3C5FCEOUlutQwp6rMWZKzs39Aajbo9Uvs8Zilms1aw2aQw3Z/AppGYBs8vlajqirGcUU/ynl3LwLNoB04ZLmCVmel4MUzbR5dqc+vZ57naKJid/+AG72cMNexhUoIrqvaflYhmaQVxj1JJCsrKiFpesosLSsFa6sLBL6nJPgbbZ7dVHMKwzC4ehDxP7y8zdZQ1cemrvHIks/PPL7AjV5KUUkePRfw+VPtOQS/G+Z8+8aApmcqyXxgqWZzvRvztat9Hl+t3XefPygMw8DzPBqNBk899dS8Wjk4OODKlSt4njdPKq1Wa544wjD8VP3aAf7RP/pH/MZv/Aa7u7s8++yz/PZv//bcpuPjxPdVIjEMgzT9YNvMe2MwGHDx4kWWl5d54oknPjDbv18iuXRzmz/8T6/NCXEwtb/1XDSN+ULmOTZ/+t4ur90ZzU2NTEPncxt16lKV3dvb20yimJWVVeq12nzYnhzVaNI06p5Ld6y0qGY7TQ21CIBAlBVC07EtZUlbVdWhA9+RuL0/4Mp+RFxptGsa56yMtaaLabt0llxWVzXKPGMymbC9vYOQEt8PCAIfz/OOCTVKKXlqY4GNdkycK2l411I6XrqmYLNlpVpRcIgY09D4wqkWr90dsTvOyEuBbWg8d3KRjbp5KKdfVfNd+v7+PlmW84ULmzg7MTe70bxicUydx1dqmFRESYWmabTrPkUpCPOSqhLUXZMLKzWansXWMCUrBZ2aw/nlOroSOSHOcsajgldujxilFWgGhq4Imk+vBmw0FggzNYhueYfAhVbLZlDZDAkxtQIHQV5V9CaC7yQpz69YnFxdRteNY8kNYG+SkVWCRV+ZYZVliYFqE97uRZy5sEwl5HwuMgvPUrIySV5gH2mvJUWJZ0nyosDUlZugYpZP4b6WwUrd4WY/xtQ1bEOp88alZKVm4VsaO/sHbO332S484kpgWzpVlXN3kPDMyQVOGZJJqmyYOzUb9wg59u4wISslnUBDlDmWobPSDOhFBb2oZL01g5NDp91iHMWsr28wMcaMdycKKh+GhGGIZVnklYHb9nAs1W7rhymX90L2xhmVkAS2GsRbtUX6lcNgXNFotnh2s8lzJ1WXIS0q/qdXt9mb5JxfrmNM1QTe3otZb3n8H760fqTzoXTTdF1nZ5QySkseWTreWloMLHZGKeOknCedtKh4dzdkb5Lj2wZPrNaODfdnqC1N0wiCgCAIOHnyJGVZMhgM6Ha7vPPOO1RVRbvd5pVXXqFWq32qba1/8S/+Bb/6q7/K7/zO7/ClL32J3/qt3+JnfuZnuHTpEsvLyx/r2J+pRPJhWlsfZUZy584d3nvvPS5cuMDm5ub3zPT3eqtLKfmz1y/xrTev3PdaxbNQSc0yTTzb4mYv5tU7Y5ASd6rqm5eCV++MeaohaXf3SfKK9fV1DMM4Bus1DQPPsRFSICRM4gRLV54gg7jgKLK1EBLTsvDNQ1jvbMhs6LryLMlyLt3t8epOqmClhs6wG3NnkPL5k815T72sJEGtjm46tBY6SFEShhHdbpdeXDGqLKRustL0efrkIuM4Rdd0ao5+5DwcfodGoJLPMEq5O4gxdJ2lmo1rGbx4ZoEwK8kqwWoroJjOlI76rgshuL59QFrC+vIajm3z3LrBetOhH6l21krdmQ9tpZQ0Apf3tvq8vTNhlKhKqVNzeeZEjZW6IkxapomuMf8cUKzsV2+P6IU5Dc9E1wSaaXHjYILvmHzxVJt6lqk24ZEwDI27wxxNiik/B+yygjgmyjV2JwJR3qHdbJAlDoZlY5ozVOCUNHfE5dIwTGQSk+Ta3GdFOTIqjkqS5awv1Fg8iNkepQS2gWVo8yrl1KJ3uNnQ4NL2gDv9mLiEhZrDWjsgKyu6oSIR2pZFx7d4bDVgOBwyHA5JrAZhlLMQGOiaRBoaubS5tBfyk48ts9qsKB4wlM4qDcvQDlvCUlKWBWWZM0ktHCvAtkwMQ2M4SVRylJLVhsfdYYYAGp5SRg6zClEVJINd3isHuJ7P5YGgn0oCx8aWFeO0YGl1lc+fbCIkrG1s8uhKXYEnprO7qwcRW8OUzbY3b38Gjqoy3tiJ+EvPrmHr2rwFJuU0mUjlGz+zLp6tF3ml9L1msj3DuOCfvbzF5f1oLvraqdn818+vzdtf7wf/NU2TpaUllpaW5gTE3d1dfvd3f5c33niDIAj4tV/7NX7u536Ol1566RNh2c/iN3/zN/lbf+tv8Tf+xt8A4Hd+53f4N//m3/BP/sk/4dd+7dc+1rE/U4nke8WHhf8KIXjvvffY2dnhhRde+ND6/kcrkiwv+KNvvs6V2zsf+B7ftcnykjBOeP1Wl6qqCDwbTTeQosKWkjgXdEuH01Jjff3EAxNaWVXkpZKTKMsKz7HRNXh6vck3rnXnO+NKCCrdZDXQ77EE1uaDaikFw0Gfd7s5QjdpOIeouCgreWNrzKkFH8vQjku7SwADv9YgDnWu9iLyqqIsc24PC97dHvLiyRpLrTr2VJ7kaNSmznSX90Pe2ZmQVWqnXXMMnl712Wh5NDwTz3Ee6EE/ilK+dmmXsNAwHZdLwy5rTZ8ffrTDRtuaky0PfzHUAo/b3Qkv3xqSFAoSK5Hc7U8Yhgk/8dgyy01PSXncA9PuRzmDuKDuKhkb23EocjUwv7435lzbwTY11QIzVIIWQiDRiFLlXw7KUz5JEjzXQRQazXad8yca7HX7TIYj8iyj5nv4gY9vTX1vhFqcdF2nKHKKSrJ4BIwghKQ/TtgPMyzLou5UfPn8Eq/dHnK3H5KVqjJ7rFPj9IKPriu+z3vbI97cGlMIgW3oDKKU2wc6z2w0eXpzgbQQChzh6gwHAyaTCSura1y9OcGzDNS6q6nrm+f044Lb3TGbbXfOmynLiiTLcB0H39LYK0qkbc/vBqHWVjzbIM0LbNtkbxByq5+yH5ZUSBZdg822x/YwZZAU6JqB45g8ttZgvWGTJDHb/ZC73RzPhFLamKbJk+dPsZ+b9FL4v/6vv/RAguDMfti6BxhhGzp5WZGXEsc15t2JrCgJk4L1ts9G0+XWIOFU28WcJutemPOTjy3NLR/++FKXd3dCzix6ilUvJbcGCX/w+h5nFn182/hQhERN06jVapw/f56vfe1r/NN/+k/57d/+bfb39/nFX/xFkiTh7bff/tBOrB8UeZ7zyiuv8Ou//uvzv+m6zk/+5E/yzW9+82Mf//sqkXyYYXue51y8eJGyLHnppZfed7D1fscXQjCcRPzBV1+mOwynu3yNJC/vq4YUiztjxiKO80oplFYVcvY9NQ0MQ7UzFhfftyoKPJc4yahEhZRKvlzTNE4vuujmCm9uTRjFGbbtsNEwee5k84FmT1VVMuh1GaYVSSlxTSVoaJjK2c8XkjCv6IYZF06071PJBcXdeGt7PCd7IU0qYJRUXO6mZOHwGLTYcRxadZ9xlLA9ynj97hgNqNsGEsE4KvjurYITC3WavvVA3k2apnzj0g7jQqfTrKPJkrzSuN0L+calii+fbePYin1elhVZXuI6NmGccqsfE+cVbd+an1/bsBjEBdtTqOiMc+B7h224vBRUUi04lm3PPeJNQyMvFRjAnppTgQJRGLqBZRkst3xuHkwwqcjSDM/zkLqBVhSstutkpaDVatFqtRCiIo4TJlGMjCIC3aQfSVzTRNMEWamIi5tHcMV7k4w37o5IhUFRZFiGzkbL45n1Bo+u+KAZ+LYCLuiajmUZjOOUK/shAnmfO+LlvQnnVhq4eo7EYDIaUhUZZ06dIj8GctCwLAXqOB5HeTMSzbQoK8G5lTo7o5RhXFBzTJWws5KGa7HScGgELoNJzMU7I/bGGY6pdvpXJxWLdY+XHl0izgRZntNwzUN/HqvJoLRwJ2PqtkZRltTrdQTg6oJQ2sRpRqN2/xK23nKpu6qSXwgOPWx6Uc7jqzVqU6KmkJJvXR/w1Ss9BrFqUZ3reOQSbg9TpFQE0afWAn7oTJ2iKMgqyetbYxYCa16h6JrGZtPl5kDJrzy93ngouwshBBsbG/zu7/4uQghef/111tfXP9Ix3i+6XbXJXVlZOfb3lZUV3nvvvY99/M9UIvlerafv1doaj8e8+uqrtFotXnjhhY98IQ3D4O5en4vfenc+s5j1mqUEz7WxDIO0KHAt8x5kEyzVHXZGKcoFRO3MqqpCExDoFaBNNbi0qWS2mLZmfMZRPGfyHjeh0jjZtDnT7pBVys+k5j1YvyrPM0b9HugmS0sL6PsHMD1mOW2hCcAwTeqBT5o/eEC/O87ISkG77qqkONUwcnRBP9P4yhPn0MQhtNi1TLpdC98PuNnNKIWczhTUfKThmowyweXdEY8tB8zbcIZOlhcMhmNubO8TVgaLzZpSntXUDtK31fcJswpQEGvL1HFtpUtV8xzGaYmha8fuH03TMG2b7iTmzIKqZMQ9bbilpo/vKalFOTf/gqQQ1Bxz7tcOR4mZkjQv2GhY3DkQDBJBK6iTS0GSFJxZbuKbh5yFUgi2hhndsMTQHZYX6vzQCZ33tofc7cdIDTabLmc7DpZWAQZpWfHanSElFoFZoVs2WSm42YtpeMqmFwRlIbAsE8dUvfi4kMR5RXAPoz1wDDJhsDsIaXkWBwf7ZFnG2toaAg3ftjiz3OCd7TENw5gnkTArp8rBx7XEbvQzuuMYNDUzOdfx2Y8qwqKaSpbYPL5Wp9PwmcQZ++OMgzCn5Vtz5n5gG/QmCVt9h0eWArTAw3MOPXOEYJ50dMPkwlkleaLrOolhYlQZ3/7mNwkCn6WlJRYWFphIl1Fa0vIsXjzT4j9e6k1/g8EoKWi6Jl+50Jlf5z+71udfvLKNoWm0fJMoq/iz60N+5PwCP/fkCmFWshhYnF5wMTSmtgulEu7UlTClpimu0cw9cua++rBeJDPwja7rPPfccx/p/f854zOVSL5XfFBFsrOzw1tvvcXZs2cfSi8L4MrWAa9d26Hdvp/lqmmQZjmFruPYFmleTrkWFXFSgCZ5fLXGlf2QJFey4lVVIdGUnlMgEKI6psHluw62aRKl6dy74V4nQwDXtqhEhSkEUsgp1+PoXEVy0OszGfaxvWD+/RcCxfswjekiKyVxoVRkPaOiKDVcx8Y2DPKyJMmK6edLdMtC3Je0DxdHUzdptRdYWVkhzzPCMKI3GLLXz5GVTlEo/3BFzLSQSUKYFPPjzNpwo9GIyXjI0soKVhojqwL9CKzX1DXySijSmDM7F8cVbWuOyb5RYVoWoqyoRIVl25RRhG+/n5GRhmdqbLYcLu+M1JzLMYhzlfAfWQrmc4ea7xDFGUlREefK8MnIJ5zyC8b4hHmFYWg8e3KRJ9bqaFKQ5gWlkLx8a8judHMBcHtYcGrB5nNnlnnuDBRFSRzHxHHIeNCl7nv0S5u4hJZTzc+Fa+nkpeBOP+Fcxwc0bMs85j8vhVCeN5aNqSlHRQ0Nw7Sp4gRdg729XcqyZHXtBP2kYpJF2IbOUmCxVLM5mCSYhoVAw9R1Hl0O8KeeMeO04I2diHGU4TuKDHh3kBBmJV861aIQ6v7t1BwFw64EGsxVj4/Kv2iaUnXeG6ecXVRdg9nGTAN81+GM63Cjn6LVOhRSwzVNdL+JnVb8whfWefFUg36/z82tPf77b77BrQmqleu7PHtygf/VM6u8uTVmlBZ8/lSLv3BuYT4bzEvBVy/3sHSNjamMSsO1sKOc1+6O+enHl+/jaQkhaJsmZxY9Xt+a0PIOxSW7YUHdMdloqfd81vzaO50OhmGwt7d37O97e3v3udE+THxfJZIHzUiklFy5coXbt2/z7LPPPhT6oKoEX3v1XV67usUDgE/zcKypflU6MydSC61h6HiOS+C5/NSFgm/d6NMNCwxDZ63h8sXTbUb7W8eABKahHsTBJEQI5QviWBZlWREf8bOYe4g8AIRQVsqwajweEU3GrK6s0Gg05uipF062+NqVHpOpuJ9mmHimwfMbtbkXeZoVpFP5c9sycW2T86smr94ekRTMB5hSqt7zmUUfU9exTOVMqBKChuvXWPcDTssJ7+1FSFESxzmWbZPlOVIcSo5Mrxz9fp/xeMLa2hqe72PcGJFJjYajrGXLoiQtKxxTp+aax6qCo3Gy7XG7l9Abx2oQbTsMk5Ka57D+AH7L7Lci4YllHwvBrX5CluXUbYNH1ps8dqKJrumgwWAc8/buhNt95Tooy5IFR/DiI2t4rk0hwLPV7GAmCeLYFtv9lL2opO4qhQPLUm29GwcRa3WH5bqDZVk0m02azaYiKyYxeT8hjRMSaWDbqhU3IwFmpZjOHyzKe5B6Dc+k4ejsjyPaUyVh07Y5GGcs+jbhQFWoneVVXrkzZm+SI4RE13Xqnsljyz6rdYtRUmCbOsv1GuttH9tWfJHL3YRRlLIQWPO2qmPqDOOCvUnO6UUfXdMwTINRqGC3uq5R8x1MKz8GpjFNizxOsLx7lyDJKC05CDNqjsnf/Knn+F/e7dLLdQrHpwn87JPLvHR2QQEvVlb4t9cy9qjYWNExqpz+JOY/vD6mv+/wv/38GoudNZqNxrHN5SAuGMT5MTsBUOTQ692YvUl2XyKZkRt/+slVtscF13sZgaOTFiph/vRjizQdnaIoKMvyI29mwzD81BKJbdu88MIL/PEf/zE///M/D6jE+Md//Mf8yq/8ysc+/vdVIrm3IimKgjfeeIMoinjxxRcf6iLEac6/+tp3ubPXo6wktmXQCHy1Q08P2x3+1OPjQYTFSgjCRElLyKjHT5yt0VxcJssKpusw4wNtvgAqqKsgTtP53/KiJC8qsrJib1Kg6Trr7QdxOg5DSslwMCBNItqLS2jmjJSoWkd136Xp27y3MyYTOpYuONX2jslUHI2yqpBYUJU8eaLBO3sJk1KiVcojvOGaPHmijmdbFFVFmt9bHWqcXnC52YuIMmgEDYqqJE5zbEq0qMvBQYLve4RhSJblnDq5ged5pFnB2U7Au7sTBpMY29TJSwm6wdMbTRYbvpJyeQCobzGwef5kk7d3xqSlThTG1ByTZ9YbdOruvGqL0oyDcUY/qSiqirZnstZ0eWy1ziMrNQVdNlQ7JYwzmoHHKEy43Eu53s+xDR09SykkHOQW7+4nfOmsj6Nrc4+QWeRFyfW9EZqoME0b21JtG9cyCTPV6lm+Z6EyDYOlzgKRmOAPSuWxUpZkZYlEkkiLzaaNCdPBvzoZaVmRFQLfNnhyTc1nBlGOZTuUYUjdNenoEb7jsrmxwSu3+myPUhqupTZHSPphxjs7gh99ZJHTi4ezmjQvp9W3S2+S4rkOtj3lc0k1H5AoEIehaziWdYzTJISkbmkYsmIUS9o1V9k8Z4oLc9RjJM4r3toe0w1zKik5eeo01u0u/7vPtaivnSEtJestd87xANifZLyxNWal7kyTgk+71aIxSdmOU+52x3MV306nM2+D+baBYxrTVuDhMpjkFY6hHbNcvjfOdgL+9l84xbduDLjei2l7Fs9tNnh2va44OlFEFEWYpkme53M5eU3TPpB+EMfxp+pF8qu/+qv80i/9Ep///Of54he/yG/91m8RRdEcxfVx4jOVSD7MjKSa9uxnoou+7/PlL3/5oWByB4Mxv/8nL08Va9WOI8uL+b9tSz1ouq4zCmM+6OvNmOq1RpNaQzHJLUP5hJuGMW9DBK5LnB4O1dXvBtC42Yv51o0BSVGhmxaG3OOx1To/emFlzleZcSmEqBj0u+R5ydLK6hxeOj3ivHVkIPmhR1eQQlKIiiR98FzkKIEQ4Mm1Gi3P5FY/IS10TizUeGy1Ts1ROlEPqpAA2r7Nl8+2ubyfsT+O0IDNBZ/nNps0bZ3xZMz+/gFSCpqNOlmaIaSGYRg8eaKObepcO4jISoFv65zreDy93mQSJaoNZ5kURUl/khDmFa5lUHdMTi8GnF2qszWI0DRY8C0MXZ9XbSB5c3vC9YHyVqkqxd9Yb7t88VRL+dgf4Uc0Ao9xrPgn1/bGGFJSpTmWadKu14jziq1xRpiXOA9g2MOhkLtlWWTZoWujYZi4ro1jmaR5MYUAa2qwn+R0ajarDZetYYpjGui2SZJXuLpkxZNcv3kL37Vx/YBL/ZK9ULXRHNPg7KLPi2fahAX0JwmO4SCiPoFr01roMIoSbnYjPMcm8ByklBSFGnSP05KDMOfEPVXczBrANTX2xxm+IUED07LQNNCSEs9WXuxHW46VkEo3zDN5fLXGe3sh/bikrBS0/ZGVOo+utdCAMM147e6I/UlG3TU5feYMk0zySlfn2SdXeWHlwazycVqSloKFeyqLhmcTF5LNc+c4veAxHA7nhMAkSWi325yp2Xx7O8exdOqOSVII7g4TnllvcnLhg0E6G22P/6p9/2viOObNN9/kxIkTdDqdect6tgGdJZMHJZUoiu4bhn+S8Yu/+IscHBzwd//u32V3d5fPfe5z/NEf/dEn8pmfqUTyvWI2PN/b2+Ott95ic3OTRx999KHmIZdv7/CHf/bavD0FqgwvisMFsihLHNtkHMUYhk7gqpZLmGTzEl1KmIxHDIcDOkvL9xGKZkP7sqqoew66riTeo6Q8Ng8ZpwX/6XpfGSl5DlKUZCW8vT2h4Zo8ulxTvWPPRpQVd7d2qITGyurakRtSkhRqgK/QLwreO2szwOFcRUo5b5ndSyBUobHe8lhvHT4sdcdUC4qtRAmLsiRJ82Pn39A1zi41Wa2nhFmArjH/LnlZMBhN8D2PUxtr3O2Oef3OgCxXi+eJdsDZhYDzSz55JXFMjWbgz5FlaVYQpTlvbY+51U8ppI6pwUrd4oun2+iivG+XP4v9Sc71foYmSpq2gcREoLMTVmxPCjYaSuDwXmXeOFewbL0qsExD2bgWBbZpkGSSUuh0aqr9WN1Tra7WbfqJJE2zOZ8hKwXIipohyYoSx7Jwp4vYpZ2hkpUPbJ7fbNJwTe4OEkohWW95PL25QGBK5T4Yx7x8a8TWOMe1DDzbIisq3twe4Tk2my2btu2wvb2D77ksLS1NRT7l1LZXmzPkNU3HdQyiQuPoTzjqWT+7H7ZHGZO0VAP8PGeSlnimwalODds0MTSN7iTh6kHE9jBFSEmnZnN+KeCnn1rj9sEEIT3avkXTO7Rh7kU5o0zSaQac3NykLEtWmh6x5vH1qz2+cqFzzPNkFks1m7pjMEyKY9d+mChYd6dmH1PxvXDhAnEc0+12eao64ObWkOt3JkhDJdYn11v84udPfCgG+70RxzGvvPIKKysrx9alGahmxls52lU5qgf25+GO+Cu/8iufSCvr3vi+SiSzBfPNN9/kqaeeYm1t7SMfQ0rJt968wptX72DoGvl8wD0jRM4Y6QaWacx36EKIKd8CQJvu5mBne4vRVP7dth8s/w7KlGkUxRRTFJUa7qoFPUozbvZicgE110QKNfB1TIMoK7m6H/Hocg0J9AdjxoMeuuVwcmMV27IoipKtfsjFu2MOJooRvVR3+PK5DtyDLDvcoavf2675VFL5ivRCNZhXLYKjD5IiGs6semftDgBN1zmIK8JEkSZPLvjTGdLx9kCWZezu7hAENU5trvOd613e3ZlMtZ48docavTThhN3Hti0C3ydYaDOOkmOJ6r2dCe/thAq5ZYJA42Y/AU3npx5fns+H7r3mo0yJZM7goBpgIKiKkhv7IWcXl+dS9JMjidegoipy5eHiumionXiYZJi6sgSYxBKQeI6DZR4qHz+5ucjeZIf9ST5tASk83+kF77D/rsE7W0NevzskKSSGaeKYCY8sujy+WuPCSk3BsGsekzhFoqFpOqXuMC4NFus+pq68dQxRkguN1293aWo+/eGQWhDQ6XTm19M2NBbrHtuDGMtT6s9SCsZxiSYFddfAd20MXUfXNYaTeFpZSZbrNk+u1bm8HzJMiikiz+KZjSYGknGkXCVfvTOmG1d4lokmSu4MEsa5xhc2NU4uPJi5nRRKaPP0hXPkRYHnebTbbfS0YJIqkIPt3Z9Imp7FS+cW+Ndv7lEJpWg9SUuiXPCXn+nc43Ojwvd9Tp48ycmTJ/nCcwVv3dzj+k6XPByxJEdsXZ2QdTp0Oh1c98Eztvu+f5LwyiuvsLy8fN/mdrZuHdXyu5cMCbC9vf1QHiafhfhMJZIPqiyqquLNN98EeOihel6U/Ltvvs6lW9vzv808QSohGOn6dPBtT1Va30+/SjIYhYwHPbKi4vzZM7iOTZYX81bFLGYtozQvsZxqjsw6uqDrmobULUVivKdlZOjaFEkEYTghGo9wgzrNZpMsLxUZMiv506sDolLimMo1bmdc8Idv7vAzTyw98GECldwGYcylvZC3tsfkUsPQdRZ8kxc26rR9G02DwHXnVr1HY5QUfONan1FSoOkGSMlyM+bHL3QwNTFnhMdxxN7ePq1Wi5Pra1zbG/LOzhiNQ1nxrBRsRZLTa+ucalqEkwk3bt9R1dVUssW0Xa73YkxDIeFm4Atpatzth9w6cFkIrPmCnuUlaZ7TqPnEW2Me1JvUNeWRMVdwLso5qzyJE0bdfTZaHlthRVpUBJ5LGGfERcWZjn8kWWpEqbLiHacljcBl05b8+GMrXNodcTDJ0XVYbbist6aeJLbF/iTl1dtDhFSQaQ2I8oK3tnMWGy6nFnwM3WAwCY/J1UR5RVEJao41tyzQDQMzyYjSnLv7fTwTRFmQhJO5f33gOZxZyOmOE6WYYOmUlaQSkrMdn6an5FXqvsftgzHXeynduERHSaqcn3qnD+IC21JscXmkjNkdZRxMUgUw0AXoOg2/TjfM2BorU6sHPed112bj9BlGSc5iI6DVaoGmWlerdYfAfv8F9r94agXH0PnGtT7jVIEb/uKTC/zEY0vv+55ZWJbFc49s8NwjGwoBF4YcHBywvb3Ne++9R61WozNNKs1m84HfPUkSvvvd77K0tPQ9OySzpDL735la8de//nUuXrzIj//4j3/P7/xZjM9UInm/SJKEixcvYhhq8fiwu4SjMY4Sfv9PXuZgMDr296Is5+0t0zAIPKXxE+fvLw6ZJgmDfg/DcjixvjJly6pdrGOr3ncpBKKqEBKiVBEJDw66jMeTqfaOj2Wp3XHgOXjGBFkWCN1QXhaaRjUdcndqNsPBgCQOabYX8P3j5e/1bsQkLag5Boap0GCurTPKSq4exDy/eVzp+FDUL+FmL+GV20NA6TIJUbEzyPmzouK/emET29DmlcixYyD59s0Bg7igFTggBWUl2BmE/Omlih97ZJHAdQgnE/q9LstLS6wud5jEKVtDJZrXOoLYcU2drKy43U84v1TDbxicabXRpNJi6g+GDJOcMDZwbQPDMJWKMGqXHeeSKK9YCJT7YJKpvNEMFFR2faHGpf2IojpkPFdT3P/mQg0xdUcENSDeO+ixv39AZ3GRswsLvL6l2mm9cYRtGpzp+Dy73ph//6ys+PaNIfthjqbrVOWIwDH5/Mkm55drPHNSmWEl0xaY79ikRcGdvpoHLcwo7yjexyAquLo74vRiwDCMcSwbxzanCrg5rqWr9lQlcWwdXVPkxKyoQJQsL7ZZbDdJkoQwitnb7SM0k4bvsNoKeH6jxu2hYq7XXYNTC950yK64OduDkG/dGMx5GEJKLkUZYSn5sUc7tAKXshIU5XHAxSQ7DvW1bIc8y9BFye4w4ZkTDTzHppJC6YlJZQr2iz/2JL/7jRvcSmzatk9SVgzjgrJSn3evD87RsAydn31qha9c6DCZJhLX+ug7e03TqNfr1Ot1zp49S57n9Ho9ut0uFy9eVNDmaVJZXFzEsizSNOWVV16h0+lw4cKFj9xm13Wdb3/72/z1v/7X+Yf/8B/yy7/8yx/5e38W4jOfSPr9Pq+99horKys8/vjjfO1rX/vIUvJ39/v8f/70u3PY7oNCTtVjb/f6tKYeIoHroGmHDz9AFIUMej1qjRat1v1S9DP9LH/qRzLrG3emSp+KM6BMgEzTZHlxgTRNOb3g8c6OYmNblUSfav54jsXpBhR5wkJnCce5P4n2o2LacrGpSpUAKwRaVdINc3xP+WOneUFZVtSO2Nhe3lfw4/q0MjCmMNNRUnJ5d8TJlotpGPhT5NNsrjKICvpRQSNwFYEQtXh4lsH+dFc+g/eurq2w1G6hTPZsiurBg3rDMMnK6ojulmoFeUGdjaDOCSm58uYeeSEYj4boho5pqFmHaWjHdq26ruNappJkB9qucgXcHpdkEkSliGUrTZ+TbXveDquk5O3bXa4fhOiWzZpecd6I+fLZRU63JxRVk1bNwbf0Y94p7+6G7ExyWr6NLgXCshinJa/eGfGTgY0Qh0TIVj1ACIklBGlRTbW3jp8LXQehW3PtrbwsyacbHl3X2Fisc6Kfc7sbqh67VhKnBWGa8dhKQGdBcYlMx/v/tvfe4XXcdb7/a+b0pt7de2+SncQhFJNeHDmh32wIgXthuSS/3WVZyi5LWWAJm3uBZbMLWVrYhVwCsdMTHHDshDSIbbnHRbJlWbZ0iso5OnXq7485MzqSJRcVS0rm9ew+PJGl0feMzpnP9/sp7zct4RzRXIhMNgM9WQKdaeYXaSwoDuCt9OFwunB7PAj5lG0yY6Ra+3IKZQVqAapL50x3kpNRH9NKPFZ6VlaMzjxBMJSEdYzaodvjRsrlEARDednrEpEVFTm/6RIFgeKQjyuXzyV86gQfvXw6u3o87GlPEOuTKPa52LiignctKB/y/TIYr8sxogAyHG63m9raWmNwU9OIx+PEYjFOnDjBgQMHCIVCpNNpq/YyklrtG2+8wfve9z6++c1v8pd/+Zfjqvw7nkyqQDL4Jra1tXHkyBEWL17MjBkzgJF5kvi9btYuncuxtk46Yj1n/14Egn4v4Vh3QRFdH6AH5fO46enpoqe7m7KKymFVOo3dfoBEMmW4x+WMOQuHQ6Qk4KWkKEA6a8hmaIpMrLuXdDqFIAisqfRxrNdNOKmg6UZOel5Iw6tLlFVW4fV48Lpdgya0jWE10elCkQcWvjUd/O5+iXlHvqdfALxuJ5mcRDyj4HIO3O25XC50OUtvSmJmibHzTBTUVQI+D4mcju5woisyiIWpPGOAsDMSw4vMzBnT8ft9eSkZg8oiLyd6JRCdVhASHU6UTIaKwNDdMjrGCWPF9FLeOB7F7Q3gdohkcjmSmSyVfgE1HSctBAiFAjhFkdM9SSMwO0Rqijysm1VMa1ea9t4smuZkbnUJ86v8CJqOnPdIeflwB229OdwuFy5doDmaJpo2ZjfM+gqqQlo1XqvP40bRNNrjOXxuB2K+xiYKgpWvj/TlrKaFoN9Hb18KM3JUFPloiyuIohMtfy90QBdchFwDA66sanQmcsiqRonPxZppQTRFIZpSkFQNTZaZX+Fn9awK62cOdfRxpk/FK2qUBzwomk4iK3NGcVPj9pBIpshksvi8LopDIXJZFy6Ph66kZLVCF/5tBdFJVypHdciFohonPwC3y4HP42Gu4KA5kiStiuj59vm0pFqWCgPeZ04HVy6fS2fbcWbPns2cOXNYiVF4T+YUKoMeSzJlohFFkdLSUkpLS1mwYAG9vb3s2bMHp9NJLBbjlVdesU4rZWVlF1TraGpqYtOmTXz5y1/m3nvvnbJBBCZZIDHRNI1Dhw4RiURYu3btgEnzkbgklhUFuWzZfC5bNp9kOktze5jmU520dcYQRRGnKJLMZPMyB2fPiRTKv9fU1BIKGoqm2ZzMsXCCZFYh6HUyo9RPcdBPIpk+a1Jd03RLqdftdODxekHw4fH6kGSFbDZLKpViYTDFTI+Gy+3B51AQHE6qqqoQBHM3ZwRR0zVP12HFjDKOx9rJSLol65GRNZyiwNwKIw3mdjkQEAY80D0uN+VFPjri/QV5Z95nW9f0s6Q2wAiU6UyO0oAbFyqy7sDjcqNpCqqikJVVRE3FI8CcWTNxiE7L19xkerGHZo9INJnJD+q5yWZkSvxu5lUO3bVi1mpml0KyNsSJWJpkTjGmr+tKaZgeRM6miXd3EYlGOd4nEs2CqguIgqH+etmsEuZXBplfGbRaWhXJ0I7yuFy0nIlyJqkS8rnxuY0TWpHfSSyR4UhYYP3cgeKflsWvKKKpOk6XA6fbUATQNA1RMO6XeQILBbxnmWnVBF0UuSDWl8bnduJwugyJFrfOrILCdKQvx862XlL51JHb7WJ6sZuGmUWEu+JEuvuYPrOCuooSI7ipKj19acJJFRcqnvxO3ekQCHld9GYUFEcx1dVFCIJxQuvq7iWV6sEhgqB5kPPpWdFh/qwTXcswhEkksqIhKxkEXefyeZXsbouTlA2FXZcIC6qCTC/tP0173C6uXbuIMyePM3fuXGbNmmX9W3nAPWBWZLKRy+U4ePAglZWVLF26FE3TLGn4w4cPI0kSZWVlVmAZSu9v//793HrrrXzuc5/jb//2b6d0EAEQ9HPptl9idF2nr6+PpqYmNE1jzZo1Z/0R/vSnPzF9+vQxETPLSjInTkdoPtXJ8dMR+pIpzpw5w9y5c6zvkSTJKKorGjU1tTjyudpEVuH5QxF6MyqIIrquUR70cPWCUkIex7ByJ2YqoL+zSO+XKVFVMtkciUSCdLKPnGx0dvh83nzBOTBAP0wURetkcbJX5s+tvXnvCw2PU2TV9CKW1ATxeTxIsnJWeyrAia4Urx3vAQwnR1VTSaZzFPmc3Lis6qyWS4dDwON0kc5J7D+TYP/pBIIALlFE1gw9qyVlDtYvnpYv4g4tFZCVVQ539nEmaUyDTy/xsrA6SHVJwDBakhSrcUFFxyE40XXFmqjOyip9+fx9KF/w9nvcSIrCoY4+dp2KI2oyDl1DEAWyqjEdf92SKqpKQ1ZLK2D5nxzvznEy5aAs4MHpMvxHZEkiLRlSJRtXVJ/VFmrWOrYfiRLuy1FipggdTiQNFEXlnXOLmFFZXBBEdHKKhphPBaVyCofDSTr7JARBpNzvYFFVgLrSIA6ng0Q6x7P7zhjyNl4nLpeLdFYiLSnML3NSJqSpqanB6+3/rOi6Dg4Xz+zvxOtyIKJZmyRdN6TQr5xXxowyHy5nYbDXkSSZlnCcfR0pnAIEvC4cLiepnLE5eef88iGHWg3LYUO8M6eoRPuMwcLaEj8VIR+KqpLO5vB63FzbsJj21mYWLFhgZRumArlcjl27dlFUVMSyZcvOCgDmjFssFiMWi9Hb24vfb+iBJRIJli9fTktLCzfddBOf/vSn+drXvjblgwhMshNJLpfjtddeo7S0lOXLlw+r5z9Su93BeN0ulsyZxpI501BUlcMtbTz7Qgq/10M6myObzdITi+L0eKmr6xd703V48WiM7pSExynicICmC8TiGf54ymyAXgAAZItJREFUXOT9a2rJZCUGR+ig30sqM3g6WxggU5JNp8mlk1RWVOL0eFAUhVQqTSqVoqurC7fbTSAQoKS4CKfLYeXpZxa7qFxaRmc8i9vtYkaZH5cATqeYDy5D34M55X6yssaRaJa+VBpRgMqQm/csrqY85CGT7W+nNU815rzJ8toQXqfIsUiKZE7GrcvMK/fyjqUzkRQFv8+NrhkifFlJs0QA/W6jGPrORTUDWqqBAZ7vOiL7O1Oc6Eoj5XIU+1wsqw0xrcR3Vj486POQyhrzPc2RJA50gj4vDofRiSdKEj19GY62R0j3xQkE/Hg8XnRdo7PT8LSvKCvjZCqBDmhqvt9fABxOvC4nbqdjQGux8TsN06pF1UF60zK9aRmPU0TRFDQd5lX4mVFRlP9+LydjSQ6eidOdNupa00p8LK0NcsXcMjRdICvJVmE5nZMgB23daTIqlBf5EQVD0cHjFEhnVVpjEktX1A5oQDGbKXr70rgFjWR+psLpdCIKIsmsjMshUBpw43QMPjEa/vWLp1egODyciKVIqQJyNocTjdmlTlxqGinrxuXxWJ1khvio2SIOHqfD0rACrK+HAj7es2o+7a3NLFy4cEwk0i8VphT7cEEE+qXhg8Egs2fPRpZluru7iUaj3H333XR2dhIKhbjsssv4zGc+85YIIjAJTyTt7e3W8NRQ7Nmzh+LiYubMmTPkv4+GTCbDiy++yLXXXkvTwcO8/OcmZIcPwTnwmN2dknlszxlEQbCc/dB1FE1D1aBxZTUVIS8Bn1GPSGdz+H2eIT3C+9Hp6TblTirwen04HaJR5MaoiaiqSiqVRpVzxBN9CKLDknL3er0D7pm5O8zkcvg8HmRVyU+1D/z9xqnGRW8yQ0/acLgz/dvNdfkKJspTgwYQwWjvPdMZoby0mJnT6wa8Tk3XOXimj5buHJKqIWga00q8XLWwcghRyH5UXeePx3s53ZPBIxp6ZpIu4BJFrpxdRE2BF4uZpgIBTdd5Ym8nuq4PUO8FSEiwus5PnVehuyeen+swNie1tbXkVNh2tJucohF0G6qusqaRzKosqwuxoi5keXIIgs7xzjhZWSPodVLicxLpk2iOpuhKGUOCc8p8rJhZZqkJdKclXm7uJqsKBDxOZMWYx6ku9rJhUSUMc3prjibZ3RanqjiInK+DyYpCKifjcjm5ZUXNAL/2oN9rzT8dj6XYk5f19zhFZE1DUnQW1xXzjnkVhgDmIDfGfnQk3cHprj7EvNKvqEmk08bGRhSgKBTE7fZQUlxMVj73Bi/g8/DeNQtob21h8eLF1NXVnfP7JxOSJLFz505CoRDLly8f2RD00aN89KMfJRQKkcvlaGpqYt26dfz0pz9l2bJl47DqS8ekOpEIgiHCNpYuiReDeQI6cuQI8Wgnd952I2VlZXTF+zh2Ksyxtg4i3XGystHW63a7UAsn4wUBBY2sYgwaJdNZBMFIf2iqRlFeul0a9IHTNI2erhiyIlNRVWPJvRQWuUVBoCjgp7Q4RCqdpbi0jEwmQyqVIhIJo+tYQcXv81GUTzEAVpeMOdUuKRqJTJag25g9SGdzuJ0i1UVDtVUbUg4dPUkOnklwOi4hig5ml/uYX+5Byabp6opRU1lJbXWl1Q1m8mZnkn2nE4YOk1NAAVp7cmjN3Vy9oOysuRuT3qxGZ0+GoEvAmd+hu3WdeDbHkXCSedWGT7wgQiLZH7hEQaAs4OJMbxavy2GMjggimi6AlqPI6yJUHMIfCBGLdhqdYpLMyZNtlBSFWFjq4FBUoTet568HtcUeFlUFMdt3JZfOtoMddGUMu2OXKFATdLB2ZglXzi0DdETRUFYu1J1qiaYs3xRQcToF/B4/sbRMRzxLTdA15L0o8rrwuN2kslncDoFMNouqKKi4qPa7CXo9OJ0iuZyE2+WyggjA3Ao/giBYv9vtEFlaG2JRdcB6f4iiQMBjTPYXDnSaAWlORWHdyonP56e8vBxZlkmlUmQzGY5EooQCfnz+AA6X+yzjs5Dfy4Y182k73szSpUtHNEw8UZgnkWAwOOxJ5Hy0trbS2NjIxo0b+cEPfoAoinR2dvLcc89NqYA6HJMqkFwIY5naGow5dRqLxbjiiissuYKKkiIqSopYv2IBiVSG3UdPsaPtT6QTcTwFHU+KpuMURcMMCkPh1+l0kBqgb2XURNp7c+w+2UM4nsLrFJgZFFg7v3bYbg9VM3L98b4UHfEsJ3okElmVkNvF/Moail2GVk9PTzfxHp2w020FFvOa6ZzCa8e7OBFLowkOSv2G2GFN0DVsLSPk9xLpTbLtcIyejIxLFNCR2dOW4XinSEOFztzZs/D7A2f5syiaxrFIEodo+E+IogO3oJOVFNpjfZyu8FJX6sebV7I103RBv5dDHVE0XcPpKMjFC4bneFcqZ9RxAl4SyYx1SpBlhUxOYlF1kFhSIp6V8bmdaHlZ97oSL9VFHnK5HB0dHYRCQQRvESldwhNwIjgVStUkCwNZEoohx15V7GdGeRCHKFrpm6f2tNORyBH0OHA5dHKKSmuXRNDnYf3ccnKShNPhGBBEALpS8gDXPofTacwaKTLRRJYZJf0Ck5l8m7Wu68ytLuZYJGnY+2oK6Dq6w4XX6WBhVYBMTkKUDGkXWVEpCvjyKtKGwsCccj+zynzkFI2Qz22cngtSdJqmF4iDGidQj8tFRjJSokM/NwVcLjfT60LG36K0jHQ6TV8qRTodxet2URQK4XC5KS8t4b1r5nPyeDPLly8fVz2pscYMIn6/n+XLl59TdHE4Tp8+zc0338wNN9xgBRGAmpqaMRFMnAxMuUDicDgM5dExxtTJAVizZs2wmjdFAR/vWbOQj/U4+K9XT6Bm+yCbJJNMoGk6S+qC+N0Oa1p+cMcSCBxs7+WVlm4UTUMQHfTJAofjILYnWDer9KzfKYA1+9EcTfP6iW4U1XD869B1TvZkuWZJFbOm1aAqKsl0lnQ6RSLRRzQaw+v14PP5eaNDoiMh4Xa7EDSVzt4Uv+9L8875ZSyqKcHhFMnmzAHN/px3SyxNT8bwWxAFoz01J0n0pBUSjjK8eSHKgM9juQ8qqkZW1sgpmmEp63Sgq4afisshkJFVkjklr3qcbwEWoCgQQFEVq/7R37RgoGg6RW4nQb97gAaXeZ/dLicLa/24XW72tffSk5ZwoLGkJsjS2hC5bIbOzjAlpSWc6BNoPhlFE5xoiozbIbK8LsSqxXXIUpZ4vI/u3hjt6R78AT9V5WW0RuJEk1I+iBgPBE/ebrW5M8GS6gABtzG9XRTwkZONtQmCgM8lksgYJx2Xy4WSbznWdeMag+VrAl43LqeDVDbH2pnFIKXpTOk43R5K/C4WVQepLvJaMzNm4DLncByiiC+vD5fOyvi9bmRZHXbTYL7bnA4HvUmjRdmwFnCh6jqZghSYofvmsToRRdFBMBgiGAwZbe/ZLOl0GjGXZVmNnxPNR6mrq6OoqGi4XzzpkGWZ3bt34/f7WbFixYiCSEdHBzfddBPvec97+I//+I8RXWMqMOkCSaFnwVA4HA6y2bOtWkdDd3c3TU1N1NXVGW/+c/yxzbbeT101E79LYMueTuLZcqpniLx7lpdlZRDpitPblx5SIVfTdZra48iqaigL6xoOp4OconE4nGbtnEpCHkOmQtP1Aaq8sqqxu60XNd+aK2DoN6VyMq+0dFEdrMYpipSXFFFSFCSdlVAUhXQ6xclYktM9Eh63C4dmpKdcHgfJnMLBjj5mlPogZ3QUeT1ufB7DvEvXIZzIIQpYQUSSJNB1nG43PVmNTP4hXug+6Pd68Ho8eFwuY8ZBVS05XEXVcQjCoBqGTsDnyz/ADLvUIr+XlKQRcOkIuk5W0dCAxXUlpAbt9nUMmQ8UHVlRmVbipSpYAaLDMMeSFRKJBNFohIqKSrplB0fDPXi9Hpy6Ak4naUll35kE5UE3lUEPJWXllFdUgKaSTqU4eeo00bRKThLwiC70AldGlygi5T1bnIICBfsHr9uFx+1iYU0x4UQESRdBltF0w4XQ53ZQVzIwrajrGqIo0pvMoKoqfT0xlld5eVdlFRlJydu8GpI2LpdjkOCmgarpVprL73Vb/5uT5bPSqyZFAe8AJYMBLef54IZgnFL6UkMP+AqCgM/nY1pNBVctm03biRZqa2vJZDK88sorVhdTZWXlsLIjE40sy+zatQuv1zviIBIOh7nlllu47LLL+PGPfzxldbQuhEkXSM7HWNdITp06xeHDh62hxzNnzgybOjPloM0ZgY+tn8lfXD7D0vcxW2U1TeN0tIfmU500nwpbuWiAREamLyvjdIg4BN3q0Xc7RNKSyolInLkVAQRBoCToMyRW8g/oWFIiI2tG7j//QRcQCOS946OJLBVBj/XBd4gCoeIgJaEAp1IiTk8Sl6CiqTqSIiEAIiLdSQlZ1XA5HDhE49o9CVNK30HQ70VIGl1IkmQMmfn8AaR0DseQZdp+GfvFtSF2tnbjdLhwiwI5SSIta9QUeagK5QUUBcOzvjA15nGKrJsR5M8ne0lkjHkat9PFsho/M0v6012arnMknKQlmiIra4R8TlbNKKNWMLrrUDUUIJ6Ik04kmD9nFg6Xm6ZDYQSnCxeqlbsJuB30ZhXae7JUBo1ivo6A1+NFRWRWMERFTuH4wSgZWcIhSTgcIg6HAwknHqeAe4jnTU5WyMkKNUEnq2aVcyScJCGDrij43CJrphdbLcwmwfz9UFWVjo4OnE4H5ZXlxibC68brcaFphqLs2afegfi9bsNLx9rY6HjcLjxOp2UtoOtQFPQNqalWeK/TuRxet+GX7vMY1tOSYohUFgaE8uIg71g6k1Otx1m9ejXl5cZ0emEX0549ewDOkh2ZaMyTiMfjYeXKlSMKIrFYjI0bN7J8+XIeeuihi7b9nmpMuVc3VjUSTdM4cuQIZ86cob6+3nqji6I45PVNGWjztGS+uVwO4azhKVEUmVFdzozqct7TsJRIT4LmU2GaT3VwpvMEQj4MFL5BtbxwoJku8XkMKXPDf0Qn4PUQVPI/kzeF13UjzWGe0AbPOKh5W15RECjye0FP4vJ40TUFXdPQdA0pp+LQFNrb2igOhQgEA8huj7U2WdGoCTo41qGQklX8XkP8L501TikzhvFtMLvG5msaiZSf1q40GVXH6RSZVVnEVfNKEclLmLucJNM5srJKd8p4OFcG3VQXeblhaRWdCWPor8TnJOR24HY68XicqKrGH49GONyZRBTBKYp0Z3V2HA5z2eyS/DCmTnd3D4lEgtraGlQcqJKKLroQhRwOhxNFyRf88/dPVk0FaNHQXcvv9nUd/G4nM0u9HI+puN1eHCJksgo5OUNNsUiit8dqLT67i87HIgHqgg66UjIOUWB2ZQi/xyj4S7JqNGd4DZkSRZHp6OjA7fbkh1L7TwnmPIqqaQR9nrMK5Sb9bdGFXxUswU8wUmChvHaWQxQsz5vBWMZV+e6/TE4mU+iu6XGhaRoBr5fLF9Vx6uQJVq9eTVlZ/yCny+WiurraaqqJx+NEo1GOHz/OgQMHKC0ttQyohlOPGE9kWaapqQm3282qVatGFER6enpobGxk/vz5/OpXv5oUwXG8mXSB5ELNrUaDLMvs3buXTCbD+vXrB7xhh7p+oZeAaUpzoQiCQHVZMWUhPx45QZ1/Nl0+maaWM2haLj/9DFlFI+RxUldsOBsm09mCvb5AKivhd+j4XQJJSSfkdoEgIEuG+VJpwH2WbSj0F/yrAgpeh048lSHgMcQvNRUEUWbptCBzp4fo7Y0TjcWQJEPG2yzWV3qhyqMQyTrIaIYDodMhsGpGKUvqSslK8gDxPrOmk0hlcIoil80uZWltiERWwevMtxfrGi6XA4/bha7rHOxMcuhMIj+oZ9jyXj6nlMqgh8V1JWRyUr+bZF53qi+ncLwrjc/rwes0/i6KLNGn6Bzs6GNWmY/urhiZTIZp0+pwuQzbWp/PTYkH2rskFNGZP1UYNS0BhbKAC7fLAbpgyeUX0jCzGLdD5GR3GlV34vc6WD2rioXlbpJ9ScKdYXQMufJAwI/X66OkKGDt9kNeF6G8IrOqKPTla1J+jwe320FWUpGkHJ2dnfh8fior+2XgwbB8VjXNChoDC+X9UvYOh0Bq2Nbe/E/oOn6vl96+jPW3M7XZClNgDoeAy+kcMoUG/Smw6vJiLl9QS/upNurr6w0V32EQBIGSkhJKSkpYsGABmUyGaDRKLBbj2LFj+Hw+KisrqaiooKSkZNzrC4qi0NTUhNPpHPFJJB6P09jYSF1dHY888sg5rSXeSkyqORIw/pjnChSRSISjR49y1VVXjej6qVSK3bt34/P5WLVq1Vm7hVdeeYUFCxZYMvWFfgGmXeZIfueePXsIBAKsWLGCzj6JLz7+JsfDceR0H1IqgUvN8K55pSyaVnrOeZP23gx/bO5G0gQ0VUEQRYJeN9curqTYM/BnPC4nmq5bD/kz8SyvtnSTllR0jB3mjFIvN66chlMUkBV1QF0llUpZpx2fz4+vpIK27jSCIFBb5KUiaLZ49k/nJ7MSp+M5MjnDrGo4CXtvXslWVjSOx1K8dqIHp9OF3+NEkWWSWZmgx8kH1s1EleUhH4Zt3Wleau6myGv4tCuyjNPpRNYMjbOGSnCjUltbi9PpzLsQusjkDC2n7UdiJLIKHqeIjo6kGErLt66ZjtfpIJnJnbMw7XK76Iqn8XscOAseOqIoIOgaqWSSru5eRFEH0WUF5qHSHGatI5uTkaQckXCYivJSyssrSBecKLwe1wUUzA05lmxWwut1o2kDtdn60Qn5fWd12xX+u6FmbRiTJQrUAIaitqKEhnnVnGk/RX19PcXFZ4uaXiiKoljKu7FYDE3TrBRYRUXFmO/yFUVh9+7dOJ1OVq1aNaJ6Rl9fH42NjRQVFfHkk0+OSKV8qjLlAklXVxcHDhzg3e9+90Vfu6uriz179jBt2rRh1Tpff/11Zs2aRU1NzcCayEWeREy6u7vZt28f06ZNY/78+dY10pLKi8e6aOtOUxF08445JcTjcZpPdXLidMTqvBmM2+kgnlV4syNOMqdS5HUyr8JPyGtYyxrT5KDpKlmp39fbRFIMO1FJNaTL51UXW91PYJxgfB43qqZxuiNMb28vxcVFOATo7o3jcDgtGXzjg9J/TzoTEq+29pDKKQiCA5cD5pV5aJhZMuDe+b1uspJsrW3roQjRpETIm3/A6joIIilF4B1ziplZ4h7y3ncmsrxwpIuQ32OJP4IhnyJJMu+Z5WXRnJko+d27w+EgV2APEM/IvNnZx5l4Pk1X6qN+djkOtPzajKYBp8NBVpKt7jIYWjdrMALGEF4uJ5HJpOnujZNMpfPqBEZQ8XiMzizD5tnQXOvs7LB26mBsXvxew7I5k8sNWyg/19pEUcDvzQ/I5nKoqk7Q3991NRwup2itzXhvuNB14xqFsWxaVSmrZ1XQ2WGkiseyO0vX9XyjRJRoNEoqlaK4uNgq2Pv9/lEV7M2TiCiKrF69ekRBJJVKcfvtt+N0Onn66afH3elwsjHpAomqqucspsfjcXbt2nXRBjCmkvCSJUvOKcvwxhtvDJCOhpGfRE6fPm0V8i9GG0xVNU5Fumhu66TldNj6sHs9LhRFPSsPPpiQ30sqm8OfHzIbygYWdEKWnPygf9F1otEouVyW+XNn4fX48oVfhXQ6kz+tGMX4QMBPIBDA4fHz5L5OspKC320MAuYUDVUTePfiKpZUG11kfp/bSLcUvOs2N51BVvsn0XVdx+X20NOXYkVdEQ2zSvPzFdoAuRddgOff7CKayBDyOAyrZEUjkckxLeTkmuXTEAQRj9uJKBhtraqmDZB/h3x9quC+DfeJ8LicuF1ORIdAvO/cu3PTsnfgLImOyyEiSTni8QTdvQk8bheBQAC3xwvohMMRysvLKCoauJv3+zz5orhmFLmdTqRBVseDrXGHXZtoqBADxgnoHJsWQRCG3NQIAvjyToplRUGWTy+ls+MMDQ0NhEJD+6uPFdls1kqBdXd34/F4rBRYaWnpRaWkVFVl9+7dowoimUyG97///SiKwrPPPjvur38yMulqJOfjYmskmqZx+PBhOjo6aGhoGFD4GwpRFJFl2QoiI8mT6rpOc3Mz7e3trFmz5ry/czAOh8js2kpm11Zytb6cjq5eTrRHOHaqk6548py/t/BBUpg7D3g9Ruu0JKEoGj6vZ8ggomkax9s7aE8oOH0h4m19zCqVKPK6CPi9+en8IiRZIZczFIuTiTiHoxGSGYGgx5FXlReM9FBO4cCpbqaHnIQCXnTd6EgqLAwX+1x0JrKA8SF2uQwfC4CQ13mWm2TA70bAaCZYNyPEK8dlEhnFaAFWFMr9Tt6xqBZBMHbQkpUKMk4jpvw7gqHthTZQZmU4crLhChjvy1gqAXqBR4uJmG/ZHjyQCIYRleBwU1JWQV1dHdlMlr5kH9FIBFVT8eT1q1RVtR5qQb+HVNqsdeSL3AVzM+bMkohw3lOS4czozqsBGHhcTjxu14AhRpfTaaT7hgkyug7pjMSs2gqWTSsm3NnB2rVrCQaDw/7uscLr9TJjxgxmzJiBqqpWCuzAgQNomkZ5ebmVAjtXjUJVVcuwaqRBJJvN8pGPfIRMJsPWrVvflkEEpuCJxNTDuv766897SpBlmT179pDL5aivrz9vF4iu6+zfv59EIsG0adOoqqq66DynqqocOHCAvr6+cw42jpSueJ/RAdYepjPWa31dAAIFGkvD4XAI+NxuRIeILPcbEoFxxD944gz7uzRUwQ15xVi/y8E755dTW2zeC91q/RREgd6+FDtbezjYkcTr1NE13TBbcohIqiHgd/c75w4KXEbayCGKHAv3sf1IGE0zCr2KbMjRl/hd3LC06ix3PLfLCTpIimEgpupwuL2b0+EoFcUBFkyryKf5PGQHPeTPQtcpLQqgqJrROaUMvUkx7u/QqSAz9SSKAlJe8mWoIn0hXo8bWZaNzrq+PmKxKNNrjXRqV28vmUwOr9dDZVkpiE5c53ggmiKNqUyOgNdoW05lJWszZGJ1XQ1rIW3UaoI+NwgCSatrcGjmTKtkcXWIWCxKQ0PDhKdzTPVwMwWWTCYpKiqyUmCBQKDfpEtV2bNnD5qmUV9fP6Igksvl+Iu/+AvC4TC///3vB9hdvN2YdIFE07RzTq7Lssy2bdu45pprztmbnUql2LVrF4FAgFWrVp23j9vszMrlcoTDYaLRKL29vYRCIaqqqqiqqjrvByWbzbJnzx4cDgerVq0a946NvnSGlvYIzac66IqnBgSRjKzSHEkRSebwOEVml/uZWxlE1xnQYeVyOvB5XKQzWZqPt/JGTCSjuwi6dDD+j2ROocTvHiCjbrazJlIZ3C4XJ7uzbDsSxSsa8uiapqKoKilJZ3qxm8um+6yawFA75va4zN7TCfqyMrqqUFXkYe3MkrPkyr0eN8oAGX5DlSAc7qS2uprKynJkRTUm7IdQYC6k/zWY903Py604kOX+2QhR5CzdrKFw54vSDlG0OqcGz1fAwBpRIhGnq6ubmppqfD5zo2OkwBQpR6y7l3hfHy6Xy/KuH1ibGrpgLpBPPTlEcpKMqmmD5OKHxpSrUVTNuMYQHVwA82dUM7/ST3dXFw0NDRPSqns+stmsVaw3lbMrKyspKyujra0NXddZs2bNiGY8ZFnmox/9KK2trbzwwgvW+MDblSkXSDRN4/nnn2fDhg14PJ4hvycWi7F3716mT5/OwoULz3tyMQvqg4vqkiQRjUaJRCJ0d3fj8/moqqqisrKSoqKiAdc1fVTKyspYunTpJZdCyOQkTpyJ0nKqk33HO3j2QCfxjJzvqQKny8nK2gCrpp3dSZPJpAmHw+ieIl7rUHCLAqLev6NWNJ2cqnHj0ioqgobkxuCHl6xqbD0UoTut4PO4EARIZxU8LgeX1XnwC4ZqrMMhFjwQfQiCYJ0wMpJMPCvjdTmpKvZZaSPzHTrUCcPczVdWVllplVDASzYn4fW4UbWB0h6FGOms4U9wRpB1o6MPmQYsxEgvqcjKwFOAOfOiaRqpjETA58l3Yen09vbS29tLTc1QMvD9KUqnQ0SVJeJ9Cbp74oBgtRZXlpWSPk9wcDqMOpFDdFieIEMFc5/bhaQM1xGm43W7cLmcTKssY2aJi3hvLw0NDUMaN002VFW1BiE7OjqsLrCqqioqKiqGfZYMhaIofPzjH+fw4cO88MILVofn25kpF0gAtm7dylVXXTXkCeFCi+rQL3di1lzOVVQ32xEjkQjRaBSXy0VlZSVVVVUoisKBAweYM2cOs2fPHjPJh0hfjt/sOs0fm7txiALvWVjBB+vrKBliXqSQf37uME/uPI5fy5BLJUAQSGeMzqybl1dZopLQ/yAuL69A9BezZVcbPqeYn61wgiAgyRJZSeX6pVXUFHnxed1DtpMmcwpNp+Kc7s2CIFDqd7N2dhmzy/2kczkURSOTyVitxbquU1JUhNfnw+3xDhl8RUHA73PjdIj5gn//27W3t5eenh5rN6/rOsUBH4n0UB1LxmtOZ2UjXef1DNMS24/RTWUM74miQMDrQccQVCxM+RhpqqGNwwoJ+j0IuoCGTvvpDhJ9CWpra3G7+x9iheZQQ+EQBdA1En0JMuk0iWRmwMzP4N21yykiCuKAgvlQ3VdGLUk5ZyoLYMmcaUwPOejrS9DQ0DClWlw1TWPv3r1IksSiRYvo7u4mFosRj8cHpMCCweCwn2FVVfnUpz5FU1MT27dvp6am5hK/isnJlAwk27ZtY926dQNaDDVN48033yQcDrNmzZrz5iuHm1S/0DV2d3cTiUTo7OxEVVVKS0uZNWvWBfs1n4+ulMRf/eYArV1pSzFW0XQWVgf5/vuX97fKDkLVdDY9+GckWaPEbwz7ZdNJMn1xIrEu6uv8LK8rAnR6enqJx3uprq6msqyU3lSGJ/Z2ksqpeS0v4zSTklSK/V4+vG4aTlE85y4eQBdEJFXFLWJJuRhaWl5EQcinSRQcAsS6e0gmU8iyjN/vs04rDofx+gp35wKC1SnUfqaDnt44tbW11m4y5PcMsBIeCocoEvAZFsXnqom4XU7DJneIfzcFC0VRQNM0Mln53HUYCltyIRqNkcmkmTd7Nl6fh1zOXMf55joMRBG8bjeZnIRTEEinU3T3xkmlMwNai4MBPwIC0jlqjoJgCJHqGI0HQ71ek2XzplPrF0ilkjQ0NFzULn6iKQwi9fX1A+ZQcrncgBSY0+m0usAKP8+qqnLvvffyyiuvsGPHjjFxaX2rMOm6ti5kNz+4c0uSJOtNsn79+vMetUc7HyKKImVlZUQiEURRZOHChaRSKQ4fPowsy5bEQ2VlJU6nk/aeDC+3GIZJq6cXsXJa0Xl/55P7OjnZnaY86MYp9kt3HA0nef7NCO9bM7SHgW4WNvKXFwQBXyCE1x8k56vgyoZKlpXCH9/YQyKRYPq06RSFAiQzOZyiyJoZxbx+ooe+nIJDMIyiXA6RhhlFqKpGJm+VahpdpQcZXZn5f484+PUJA0QdS4J+VE2nrsadH4KUSaXSJJN9xGIxPB4Pfr+PmqoKqxNJx9Adi0ajZLMZ5s6eRSDgM6a4ReG8QcTlFHGI4sCaSD5do8gq6Xw9w+d2IavDt1mb6wj6PKQyEj6PC6fTMeAa1vdaJ4w0um4M1EpSjrq6aciajpzK5tdh6GflcvJZiseFGB1h/c6Ysq7j8vqprvEZrcW5HL3xOJHODmIOBx6vYdPs8/mGvKY/371nBML+GtHg17JywQwqPRrpdHpKBpF9+/YNGUQAPB4P06ZNY9q0aZb/ejQatfzXH3roIVavXk1LSwsvvfQS27dvt4PIICbdiUTXdUNd9hz88Y9/ZPHixVRWVpJMJtm9ezfBYJCVK1decFF9NEOGsixbb8zVq1dbgUvXdZLJJJFIhEgkQiqVYl8yyJMtMpJmPNSd+RTVP9y44Cw/9ELueWQ/+04nqAwOLNiH+3JsWFDBN25dPOzPfut3R/ndwQjVIY+RCsEQi9SAf33/UtIdLeRyOeYtXEx7rJfmtk7aI91WLSKcyHIskiKeVSj2OVk+rZSKgHPIB6tZrDfTOuey9TXv0eD0k8vZL7ufzkqoqkIqnUZXJLp7EzidxhCkz+ent7cHVTWm1R0Op9Vqq6gqXrcLTR96ituUPDnX7tzldBDwelDyvvXnYrh24QGvJZMzpPjTWXRdIxwOoyjm2vtPraa+lrlul9NhiTIWuhea2l/n7QhzG5pXiiLTl0jQ1RtHVTXrxOf3+3E4HAR87nP+vVxOYzh1/owaShyS1f04lWQ/NE1j//79ZDIZGhoaLmoi3uwCu++++3j22Wdpbm5m2bJlvO997+OWW26hvr7+ktZCv/a1r/H1r399wNcWLVrE4cOHL9kahmPSnUguBPNEEovF2LNnDzNmzBhVUf1C0HWd5miaWDxJ6kwz5UV+1q1bNyBwCYJAKBQiFAoxb9489p2M8cRvDyEpKj6HjkMQUXSRPxyOsKw2xAcbhndG87nEIeX0BcA7lMRsAXdeNoP9p/s4E8/iEEDVwSUKNK6spKf1EG6321p7VXkp9YvmkMlKtJwO03wqjLMjarklBnwDfdsHY2oshfzGbEjQ70XXsGTwB93FIRVmC6XKHaJAyB+gvKSYRCpFqLiMTCZNMpmit7cDgGAwSC6XIxRy5ae9Jes65jX6fThyeJzmCePc80cel5N4/uQgigL+glmTwtrBuaba+1+LTjDgRQP8XhfHT7Shahp1dbWIYn8QMdNUhcFvgHS7mJduxxhUzZynsD6wYC4SKCohWFyCU4BkKkl3jyGSWFocpNfpJuD343INHRhkRWPVglqCZJAk5aIfxBPNaIII9PuvC4JAKpXi1Vdf5dixYzz99NN873vfY8eOHaxZs2acVj80y5Yt4w9/+IP135NFVXhyrKKAC01thcNhIpEIS5cuPe8xc3BR/WKDSGtXmn/+3TEOdSSQZIWg28Gd68tZdZ5ayGttSRREKos9hiudoiKoCqmMwiOvHaOhJENVVdWQxb0NCyv4c2svaUnF73ag6zopyUjhvHv+uVsNZ5b5+MEHl/P0/jAHziQIeZ1cOTOIt/c4RUXlLFmy5KydlM/rZvm8GSyfNwNJVjjZEeNER4RjJzvPmf8fXBw2u5sEQTDk5yE/sGeowp6v+8kY2tPoS6eMwBzw4fcaHUJ+v5+ioiIymTTxnm66YjHcHg+BgLHLNh/QhT4cAZ8bdPA53WQl6ayuKpPBJ4xC10BTyFDEaAVOnGfoD4zJ8WReBr6zswNRdDB/7mycDofVSjs4TTUUmqaTk1QEQFYUAj5j9iaTk/MGZP34PIbXyGBZHF0HWQePL0itL4Df66KvL0lvb5xTXd351mL/Wa3Fly2bi09NoeZnLaZaEDlw4ICVihvJ2nVd55vf/Cb/7//9P7Zv386SJUu44ooruPPOO5EkaULuh9PpnJQF/kkXSM6HphmdP4lEgrVr115UUT0tqbx+ood4VmFhVZDldaHzBpSMrPL5xw7RGkvhQiXkdSFpAj95tY1iv4vbVw/vPZ3MqXmrUkOi3OUWceEip0sogkgymaS1tRWPx2PNqphGP9cuqWRXW5wXjsRI5owHhssh0riyhivnnX9Svirk4eNXzgQMva+9e/cyfeZM5s6de97X7HY5WTCzhgUza7h67XLaI900t3fScio8oBAsYNjiDtVhZHrWQ37Ize9FQMDtcgyrFeVyGg6M5qyDruv0xPvo6Ogg4PczY3odTqcTXSsxpruzxmR9b2+cSCSKz+e1ivVOp2sICfV+ddycpFh+8YZUzPCyIjqQzuQI5RWN+619jQnzwvspCkZDQDKdRVGUvAy8i6qq6vxpQsYcxnQ5HOTyLonD/U08bqN1WMoHwMI6k8ftxu1yGBsUQRjkOTI0RjE/g8PlpbzSS02tiCJJJBJ9dHZ2YrYWv7thKV4liQ7U19dPmp3vhWAGkVQqRUNDw4hScbqu853vfIef/vSnvPDCCyxZsmTAv09Ueu/YsWPU1dXh9XpZv3493/72t5k5c+aErKWQSVcjAaN4PtSyJElizx6jSDxz5kwWLlx4zusU1kP2n+njy08dIZrMu/s5RC6fXcI3bl1MwD38h2TroQhfefJNPKLRMup0Grve7pTEzDIf/+/jDcM+BJ45EOaff3eMYp/Tms7WdZ1YUuKm5dV8+caFlsSD2VYsimJ/UCkpYVdbgp1tvTgEgcvnlLJ6+vkL9YV0dHRw6NAhlixZQl3d8Km0C0HXdcLdcVpOhTnW3kkmK51zNw0UCBKaKRl9yGJ94SCcSTabobOzk+Li4vyGQchrTuXwuF3G4KBiNACoqkIqlSadTpHJZCkJ+REcbgLBQP5Df/Y9czsdBHwespKcT48Nf1+DPk+B5EzhNfq9UbI5Ga/bmByXZcNLxOfzUlFROeBv5nI68t1r+Q2CUxxy5mWoezIUAZ8bSVbztSp9gFpwIeeTgXHkVYunlwUocWuW3IjZODIVWn11XbeUJdauXTviIPK9732P7373u2zbtu2Sp6+G47nnniOZTLJo0SI6Ojr4+te/zunTpzlw4MCES7NMmUBiFtVDoRAOhwOfz8eCBQuGvUZhEMnIGh/66W5iyRwhrwsxLyiYlVU+snYaf331vCGvoaoq33l8J48fTVMRGjjnYCjcCjz7mcstf/HBpCWVex/Zz5udSdxOwZi2llVK/S7+9QMrWFA1cA7G7Bgxg4qqqtaHuKKi4qLainVd58SJE5w8eZKVK1eOy+RtTyJpybV0xHrOengNN6RXiFHgdqNo2oACdyqVIhKJUF5ebrV5D9ScGngNn8eFoumk01kCPg+d0S7S6RTpdAaHQ8ynvwJ4vabh1MBWW1P1WNMHPogHF8KHwyGKuF0Owy0xl6P5RCt+f4CKinIKH9xul+MsdYFCzJkX84RxrnZcGNq4ShT6r2Fqml2IlhjAO1cvRE8Z6a758+dbQ3zxeJxgMGjNTp1r1mKi0HWdgwcPkkgkRtxZpus6DzzwAPfddx9bt27lsssuG4eVjg29vb3MmjWL7373u3ziE5+Y0LVMiUASjUbZu3cvM2fOZMGCBRw+fBhBEFi8eOjOpcFF9a1vRvnq00cIeZxWFxNAX1Yh4HHw9P++DI9z4EM6l8uxd+9e/typ8KvDKsV+l9WGC8aJZHqpj0c+MfyJBIx5kF+8fopth2NIqkb9jGI+tn4GS2rOvYMwpbPNDrBsNkt5ebk1WX+u/KwpVBmLxVizZs0l2a0k01mOnzaEJU91duFxOcnltaTORdDvsdSAHaKI3+uipzdO++kOKqsqCQTy0+oX8CA06zVmK6vRJKCSyWSs04quG4ZTleWlIDoQhOGHIM2INdRJpJDCE0Yul6WjwzhFTa+tRhRFqzbjdRudb+c7YZjWuLquW3MzQ/msB/1ekucNDjqlIT+KqiEphi3vcO/X99QvRk5E8Xg8Z7kDSpJELBYjGo3S1dVlDeRWVlZetOLueKDrOocOHaK3t5e1a9eOOIj853/+J1/72td47rnnuPLKK8dhpWPLunXruOaaa/j2t789oeuYlIlPQRCsAvnJkyc5duwYy5Yts1IzDodjyKHF4YrqPSnjewePNrgcAllZIy2pAwJJMpmkqamJkpIS7rp2ETvC+2jvMaTKHXlvdUEQ+EB93Xl3ZeUBN5+9eh5//d65aLo+wADpfPeguLiY4uJi5s+fb+3Q29raOHToEKWlpVZQKUw5KIrCvn37yOVyXHbZZZcsHRH0e1m5YCYrF8wkJ8ucOB2huT1M6+nosN4qg7ufVE3l1JkuQzaktoaK0hIABPH8qrbG9XwD6jVGDcdnKBYXhZAVlVxOQpVztJ/pQFGU/FS4cVoxT3yarpPNyTidDrI5iYDXg+gQyeaUswrc5gkjJytkMhnC4U5KS0spLi4hZaX9jACnA0gKcr6mMRT9EirGf6cLrmHOvMiKilMUzxtEzGHOngLJe6/bZSj9FkilCAJsaFhCtieM3+9nxYoVZwUGt9tNXV0ddXV11kBuNBrl4MGDKIpizU6Nh+nU+SgMIqM5iTz00EN89atf5emnn54SQSSZTNLS0sKdd9450UuZnCcSWZZRFIVDhw4RjUZZs2bNAMvOlpYWkskkq1atsr5WOGQIA+VOdp7s5f/7zX7cTgceZ/8HpDcjM6vMx68/0WCJEcZiMfbv38/MgsJ0SzTFN547Sks0hapBwOPgA2tq+Z9XzTrLJ/1SkMlkrJNKobxDSUkJR44cweVysXLlyknRZaOoKm2dXbS0h2lpD+dPH/1DeoXig7FYF6lUcoBsiHkSMZWCh9qZmwXuc6efDEtZt9OYw8jkzCFIw1sllzPUdv3+AMXFIbxuzxABsL/ALSsqaLplmpVOpwiHI1RUlBMKDTR1GmzkZUi/G6eTQt2r4VJ3gwn5vWQkCZ/bjaoPrSXWP68zfJecOeV/2dK5pLo6CAaDLF++/KJOF0Mp7paUlFhBZbwVgXVd580336S7u5u1a9eOaOOk6zq/+tWv+Nu//VueeOKJi/Y6ulR87nOfY+PGjcyaNYszZ87w1a9+lT179nDo0CEqKysndG2TMpCYyr2qqlJfX3/Wm6O1tZXu7m7q6+uBgfUQQ6114AdB03U+8+v97G7rNYa6ROMk4hAF/v6GBdyyohqAU6dOcfToUZYuXUptbe1Z1zgSTtKX7/g6n97VpUKSJCKRCB0dHfT29uJ0Opk+fTrV1dWEQufvSruU6LpOR6yXE2ciHG49Q29f2vp6JBIhl8tRV1eL0+k6R22iYGcuq0iKgsflsmZJhqNQNwv6PThk1TCHUlWVVCqNnPdYERxOy7TL2OEOvI8+jxtN03C7nfT2xmlrPz1AONLEOGEM3TwCZjrPkPXvS2bO23VVFPCe1X7crwMGmbymWVHgQqRWBK5eu5S+6GmKi4tZtmzZqN8vpulUNBqlu7vbSCPmU2BmR+JYoes6hw8fpqura1RB5Le//S333HMPjz76KDfccMOYrW+s+fCHP8xLL71EV1cXlZWVXHXVVXzrW99i3ryha7yXkkkZSF5//XUAVqxYMWTbYXt7Ox0dHaxbt+6CJ9UTWZkHdrTy+8NRFFWjKuThritmsDEfRI4cOUJnZyerV68ecPqZCljtvdOnEwwGLfc4l8tldYCVlJRMuqDSFU9ypPU0L76+i1g8SU2NMfEtiiJel/OcvhlgdDu5HA4cTgfqoN19IefSzYL+Qjv51uOcJJPJpEmlUqTThke9mf7y+XwE/V4yeRXiRCJBV1cXtbU1VJSVYtZmVE2/qBNGXzqDIOSDSkGRvPB+FQWHdrQcTEnIh6rqZKWzU3EmDlHkmnVL6Q2forS0lKVLl475+8MUOjXfj4AVVMrKykbVUlwYREajQPzYY4/xyU9+kkceeYRbbrllxOt5uzMpA0k6nT5nUOjo6KC1tZUrrrjiouVOUpJCKqdSHnDjEAUURbGmX9esWTMlJLELMdt7B9v5mrLZZgcYYHXclJeXT3hxFIzT1O7du3G5XMyZv5CT+RRYtCdx3rbioYKDWazXdSzXwvPpZpmY6Sd0Q5AR+nf32axRrE+lUridIg6nG3/AjyzLxONxampq8Hr73zcCUBzwo+pq/mE+fOfVUCcMg/6Zl0xOwut2nVdL7GzRx8JUnNEmLQiGLP21ly2l60wbFRUVLF68eNw3GaZsvnlayWazlJWVWSmwizlN6LrOkSNHiEajrF27dsSf2aeffpq7776bX/7yl9x2220juoaNwaQMJIqinNNONxKJcPToUa644gprmGskH4RMJsOePXtwu92TpqZwoei6TmtrKydOnGDlypVUVFSc83t7e3utuoopLGl6MUzEsFk6nWb37t1WSqUwsGVyklGsPxWmtSN61oP4QoKDIAgUBbxGO29mKM/6fgYXuK1rwICuKbfLSVdPnFQqTV9fAlU1rHFDodAACfeBTQT5uRmHA0lVLY/1Cz9hGMFBkhU8LieyZlxjqJNXcBgHRxOnQyQU8HHF0rnEzrRSXV19QdJC40EqlbKCSjweJxQKXZCMu67rHD16lEgkMqog8rvf/Y4777yTn/3sZ3zoQx8azUuxYZIGknPZ7ZoPxTfeeIOampoR77Dj8Th79uyhqqqKRYsWTYod+oWiaRpHjhwhEomwZs2aAXL658MsjppBJZ1OD2grvhQTu319fezevZvq6moWLVp0zgeZrKi0dcZoPtVJS3sEQWBA4Xo4Bs5X6MMW6y+shdaQqJcUFbfTwZmOTrp64lRVVSHLEqlUmmw2i9vtorq8HN3hOMcQpBOP24FDdNCbTJ3n9w4tK18485LJ11/8vvPPurhdDq5dt5TwqRPU1dUxf/78SZHuvNDWYl3XOXbsGJ2dnaxdu3bErowvvPACH/7wh/nRj37EHXfcMSnuwVRnSgWSQrkT85gciURQFGVA2uZ8g3vhcJiDBw8yb948Zs6cOaXeSKqqsm/fvjFLxZltxdFolEQiQXFxsVVXGY80n1nPmT179kWbgGmaxulIjyHX0h4mnhza/OncMyf9xXoRgd5kashZEuu79X4/FF3HSsvMmjmDYMBnOR8qioIDjXCsm0wmjaOgWD+cNe5QqbhCznfCAHA4BII+D5rGWXWVQjwuJ9detpSOky1Mnz6defPmTcr3vaqqlox7NBq1WosrKiqsuarRBJGXXnqJD3zgA/zrv/4rd99996S8B1ORKRNICoNIYSqrcHAvHA4jSdKwaRtz2ru1tZUVK1ZMeMvcxZLL5QZ4wo91Ks7suIlEIvT09BAMBgf41Y/2QxcOhzlw4MBZ9ZyRoOs6kZ4EzafCtLR3Eu3pAzivbpb5s0ZaKYPL6cTrcQ1ZrC/0dDc6y8JIkkxdXa1lvAV5xeKgz/DwyEqomko6bTpBGp1pgYAffyBAVVlpwXxJP0J+Gt0stHvcrvOeMEzl4MJZE7/Hg8PpMEy78u3LHreL69Yt4czJFqutfSpQeHo+ffo0kiRRVFRETU0NlZWVFx1MXn31VW6//Xb+5V/+hU996lN2EBlDJmUgGeySOFwQGUyhH0g4HCaTyVBWVkZ1dTXl5eUcO3aM7u7uSzbtPZakUil2795NSUnJWTWF8UCWZSuodHV14fV6raAy2K/+Qjh16hTHjh0btwDe05fixOkIR052DCnXYqLr+rCtsQNPCDkCPsPTXdc1Ojs70TTN6iwrxEiP9ase+71GI0c6P1mfzWZJp9MoUo5UJovP57cUiwdfSxQEvB4X6OBwGBa50hADnQ5RwONynaOzTcfjdhHye3nH8rmcOtFsWUFPJXRdp6WlhdOnT7NixQqrtnKxrcVvvPEGjY2NfOMb3+Cee+6xg8gYM6kDiTmpPlIPETNt09nZSTKZxOFwMHfuXOrq6qaUOU9PT4/luzIRKQnT+8VMNzgcDiuVeD55DF3XOX78OG1tbWcNlo4X6WyOlnbDW+VkR2xAob3woT8cAnn5eQwr3ZbWk+g61NTUDHit59fh6j8h6JpOMpNBkuR8W3GKXE7C6/X064B53EMEByMguF1OFMU48TidIi6n01JJHg6/182165Zw6vgxK4071WhpaaG9vZ2GhoYBMzrnai0enN5uamrilltu4ctf/jKf/exn7SAyDkzaQCJJ0rCT6hdDKpWiqakJv99PaWmpVQsoKSmxdtiTWdW0s7OTgwcPsmjRIqZPnz7RyxkgLBmJRNA0bdj6lDl1HIvFqK+vP2tY71KQk2Vaz0Q51tZJtCdBdyJ1zu8XBQGv12V0eqmGDLzT4WT2rBm4nM4CL5HBaaWh6T855Ppl31XDPVFVVSv9lctm8fu8ON2e/BDk0MV6bz6oqJpKOiMNO6MS8Hm4du1iTrYcZcGCBcyYMeMC79jkwdyArF279pzvHU3TiMfjA1qLDx48iCzLrFy5ko9//ON87nOf44tf/KIdRMaJSRlIFEUhm+3fNY40jVM4qFfYoZLNZq0HYW9vL0VFRVRVVVFdXT1p5khMnbHjx49P2nqOruvE43HrXuZyOas+VVpaypEjR0ilUpNmPkdVNU5Fumg5Faa5vfOsQnbhIKSiGDLwHo+HysqqggeQIaTodjrJ5aVWhns4OUQRl8sx5MnBko5XNWRZBUGnpzdhDUGKoqFYbJhNGX7rLqeYl+RX8us10mhgpNHMTVfI7+Xq+oWcPH6MRYsWTUl/cVO5+nxBZChSqRT//d//zc9+9jMOHTpEbW0tf/mXf0ljYyMrVqyY0GBy33338aUvfYm/+qu/4vvf//6ErWOsmZSB5K677qKlpYVNmzZx6623Mm3atIv+47e3t3PkyJHzFnZNiZFIJEJ3d7dVYK6urh53naDhMAeuwuHwRbf3ThSD/eqTySROp5M5c+ZQW1s7IiG98UTXdTq6eq2gkkhmLD90WZbo6OjA7/fn53P633uDfdNNf/XBxXrjoe8o8GEZGpdTxOEQcTmc6JZisWHeZp5WdF2jKBQkGAzidHmG3FiZMy9FAR/rl86iteUYixcvHrUHzURgBpGGhoYR1zKPHDnCjTfeyIc+9CHWrFnDU089xdatW/nYxz7GAw88MMYrvjDeeOMNPvjBD1JUVMSGDRvsQDLetLe38+ijj7JlyxZeffVV1q5dS2NjI42NjcyaNeucQcXsNT9z5gwrV66krOz8boImgwvMPp/PCiqXyn9BVVX2799POp2eNDv5iyGXy1nT6uXl5cRiMUtY0kwljrR1czzp6u2j5XSYA8dOsufgYUKhUP69U+Al4nQgFBhSDcYq1gOyrA77fdb1XA7QBaSCDkVByA9BCqb8vIqmKiSTKeKJPmRZthSLAwH/gO6x4qCf966ex4kWQy17Mlqyno/W1lZaW1tHFURaWlq44YYb+PCHP8z9999vBd5sNmsoS0/AfUkmk9TX1/Mf//EffPOb32T16tV2ILlU6LpOR0cHjz32GFu2bOGll15i5cqVVlAZPFBlPoRTqRSrV68e1YlCURRisRiRSIRYLIbb7aa6unrEXUsXgiRJNDU1jVt773hjdpaZ2k3mBziXy1kBuru7m0AgYAWVyWSQ1NvbS1NTE5XVtShOH82nOjkV7kLT9PPqdZmY36dqmmEuhUA6l0NV9SG+Tzun6Zc5cyIIIMkKmZycVyw2vFWy2Rwej4dAwE9ddaVREznezPLly6murh6DO3JpMVO5DQ0NIz6Ft7a2cuONN7Jx40Z+8IMfTJpB47vuuouysjK+973v8Z73vMcOJBOFruvEYjErqLzwwgssXrzYCiper5e//Mu/5O/+7u94z3veM6YP4cF2uA6HwzqpjJUYotkUUFRUdNFS3pOBeDxOU1MTdXV1LFiwYNh7Isuy1QFmBmizWD+RwpJdXV3s3bv3rMJ0VpI53h7mxJkIx09HhvWbB85hXKUT8HlxiAJZSUYUxAuy0B1stetxOQ2ZFFUjk8sZ6bR0Cicaq2aV4XU5qaqqYtasWWOutDvetLW10dLSMqog0t7ezvXXX891113HD3/4w0nzGfr1r3/Nt771Ld544w28Xq8dSCYLuq7T09PDk08+yebNm9m6dSter5eVK1fyz//8z9TX14/bm8g09TFrAYIgUFlZSXV19Yid4np7e9mzZw/Tpk2bNLIVF4P5EJ43bx6zZs264J8bLCxp3suqqirKysou2YMgEomwf//+Ie0DClFUlbaOGM15b5XCji2vx418AY6QXrcTURRwOvKe9cMU671uF7KiDqsR5nQYSsEhv591C2tpPd7CrFmzyGazxGIx616aSrsXY9N8qTGDSH19PcXFxSO6RkdHBzfccAPvfOc7+fGPfzxpXu+pU6dYu3Ytv//971m5ciWAHUgmI48//jh33nknt9xyC9lslueff57a2loaGxvZtGkTa9asGdegYoohhsNhdF2/aIVdU65lqrZomu3J53sIn4/Ce1kojWHey/ESljxz5gyHDx9m+fLlVFVVXdR6O2K9NLeHOdUZI9rbd179L5/HTU4eqBPmtibrVVL5Yr3P40KSlfMGpeqyItYvnsHJ1uOsWrWK8vJya22FEkKyLFNeXm4FlsmUMj116hTNzc2jCiLhcJgbb7yRtWvX8otf/GLSBBEwnk+33XbbgDWpqmr5JuVyuUm13pEypQPJ3r17ueqqq/iv//ovSwY6mUzy7LPPsnnzZp577jnKysq49dZb2bRpE+vWrRu3P5rZChsOh60PrxlUKioqhvy9J0+epKWlZdK2956PtrY2mpubz6s+fLGYsjfmg9BUKBhrYUlz/YUP4ZGuN9bbZ5xUTnUS7k6c9T2mD/u5jKscokgw4EXTVJLps9WIC6mtKOGyhXW0tZ5gzZo1lJaWDrs2s5uu0MHQvJcT2czR3t7O0aNHqa+vH/GgaiwW46abbmLp0qU8/PDDE6JkfS76+vo4efLkgK/dfffdLF68mC984QssX758glY2tkzpQALGjma4nXw6nWbr1q1s3ryZZ555hkAgwMaNG9m0aRPr168ftzedqRFkBpVsNmvtrisrK3E4HBw9etQy0hrpTmyi0HWd5uZmTp8+zZo1a8Z9/aZCQSQSoa+vb9TDpKbm2smTJ8dl2j6eTFtBpT3Sjd/rJp2Vh3VJNAn4PJZhligI+H1DF+unVZWydl4Np9oufv2ZTMYa3DP11MwNz6VsfDCDyLmC4Pno7u7m5ptvZu7cuTzyyCNTRq3CTm1NYbLZLH/4wx/YsmULTzzxBE6nk40bN3Lbbbdx1VVXjdtxX9d1UqmUFVRSqZT1u6bKjEghmqZZHtn19fWXfNZm8DBpKBSyAvSFDK6Z7eEdHR3U19ePu+ZaOpPjxJkoze2dtJ6JDltgD/jceUveIVdtFevLioKsnFVB+6m2UaWDoL/xwWx3N+XbzcaH8UoJnz59miNHjowqiPT29rJx40ZqamrYsmXLpJtTOhd2IHmLIMsy27dvZ/PmzTz++OOoqsrNN9/Mpk2beM973jNub0pJkti1axeKouByuUgmk5SWllq768n+YTAl7LPZLGvWrJlwaRnTx6Jw7sd8EA7Vom1KtnR1dU1IEJRkhZMdMZrbOzl+OmJNvAfzXiLn+yDOqq1g5cwyzpw+TX19/ZhuQszGB/O0YkrfmNpVY3V6N2tSq1evvqgZr0ISiQSbNm2iqKiIJ598csLfhzZv00BSiKIovPzyy/z2t7/l8ccfJ5VKcfPNN9PY2MjVV189Zjlk0xGwqKiIZcuW4XA4yGQy1u46Ho9TXFxMdXX1hOeuh0KWZfbs2QPA6tWrJ1XBFvpF/My5H7NF29xdAxw4cIC+vj4aGhom/OGjqhqno90cPx3hWFtn3m53eOZMq2RpXQnhzvE/SZn1PjOomDUqM7CMdMPT0dHBm2++Oaogkkwmuf3223G73Tz99NOTcrj17cjbPpAUoqoqr732Go8++iiPPfYYPT093HDDDTQ2NnLdddeNeAdrtveea8Yil8tZQaWnp8dK2VRXV0/4hyWbzbJ79278fj8rVqyY9F0mhS3a0WgUXdcRRUOnqqGhYdIFaV3XCXfH83ItYWK9fQP+ff6MahbVhAh3dp6lgnspMKXbI5EIiUTCUimorKy84M+EGURG09iQTqd5//vfj6ZpPPvssxMiAmozNHYgGQZN03jjjTesoNLR0cF1111HY2MjN9544wXvCCORCAcOHLio9l5JkgZItZiT4Kb+16WcM0kmkzQ1NVFeXs7ixYsnzZDXhSLLMrt27UKSjHkNsxXW7KabbCcrgJ5EkuZ8UAn5vcyt8BGLRmloaJgw/TcTU6XA9AQx04nn8gTp7Ozk0KFDowoi2WyWD33oQySTSbZu3TrlaotvdexAcgFomsaePXusoNLa2srVV19NY2MjN99887AfILO99GJnFAopLIjGYjG8Xq8l1RIKhcY1qJgnqclszXouTMkZl8vFqlWrEEVxgLBkKpUa0FY82WpUuq5z+PBhYrEYDQ0NE34yHUyhJ0g0GkUUxbMGSk1XzFWrVo24RTyXy3HHHXcQjUZ5/vnnR1ygtxk/7EBykei6zsGDBy1RycOHD7NhwwY2bdrEzTffTHl5OZqm8fOf/5z58+ePaXusaTAVDocteRGzDjDWkhjRaJT9+/czf/78KWmIZKbjAoEAK1asGPIklU6nraBi+tWbD8KJfmjrus6hQ4fo6emZlOm4wZg+NWZQkWWZYDBIIpFg2bJlIx5WlWWZj370o5w8eZJt27aNat7HZvywA8ko0HWdo0ePsnnzZjZv3sy+ffu48soryWQynD59mpdffnncxPPMLptwODxA/8v0AhlNUDlz5gxvvvnmlFWQNRsbSktLWbJkyQWl4yaTsKS5WYnH45OiMeBiMb10jh07htfrJZfLUVpaagXpC309iqLw8Y9/nMOHD7N9+/YpObT7dsEOJGOEruvs3LmTD3zgAySTSWRZZtWqVdx66600NjZSV1c3bg8jczdoBhVd162H4MVqVrW2tnL8+PFRT3tPFMlkkl27dlFTU8PChQtHdM8HpxM9Hs+4nfwGo2kaBw4cIJlM0tDQMOnSbRdCNBpl3759rFixgqqqKmsI0pz9MT1/zNmfoe6nqqp86lOfoqmpie3bt0/JDc3bCTuQjBEnTpzg+uuvZ+XKlfzXf/0XsViMzZs3s2XLFl577TXWrVtnSbXMnDlz3B5GpqClmbJRVXVYK9zBP2cO6k3FQUnoVyCeMWMGc+fOHZN7XKj8XCiGOB7CkpqmWV40DQ0NU2ZSuxAziAwnZW/O/pjqz4YDpVGsN4cgVVXl3nvv5ZVXXmHHjh1T0uHx7YYdSMaIM2fO8NOf/pR/+Id/GPBw0XWdM2fOWPL3f/zjH1m5ciWbNm2isbFxXIvYpmaVOVUvSZIl1VJRUWENmWmaxqFDh+jt7aW+vn7C6wMjwbRVnjt37kUpEF8MhcKSZpAuvJ+jaYvWNI29e/eSy+Wor6+fkkEkFouxd+/eC/ZDGaz+/I1vfMPa7Ozdu5cXX3xx3P6W5+OHP/whP/zhD2ltbQVg2bJlfOUrX+HGG2+ckPVMduxAcgnRdZ1IJMLjjz/Oli1b2L59O4sXL7aCyuLFi8c1qCSTSSuoZDIZysvLqaiooLOzE0VRWLNmzZRNpezfv/+S+pObQdoMKtls1morvliFXVVV2bt3L7IsU19fPylbks9HLBZj3759LF26dERpKF3X+f3vf88PfvAD/vSnP6GqKtdffz2NjY3ceuutYyoKeiE89dRTOBwOFixYgK7r/OIXv+D++++nqamJZcuWXdK1TAXsQDJBmCmoJ554gs2bN/OHP/yBuXPnWvL3y5YtG9eZjWQySUdHB21tbWiaRllZmdVWPJV2w6aM/US7Ag72qzelbyorK89ZXFZVlT179qBpGmvWrJl06rUXgulHM9IgAsaJ7Mtf/jK//e1v2b59O4qi8MQTT/D444/zyU9+kk984hNjvOqLp6ysjPvvv39SrGWyYQeSSUI8Huepp56yjLqmTZtmBZXVq1ePeVDJZDLs3r2bYDDIvHnzrOJyIpGgpKTEkmqZzB1DpoLsWMvYj5bBxWVTpaCqqmrAQKGiKDQ1NSEIAqtXr56SQaS7u5s9e/awZMmSEbf46rrOP/3TP/GLX/yCHTt2sHjx4rP+fSJnmFRV5be//S133XUXTU1NLF26dMLWMlmxA8kkpK+vb4CnSkVFhaVUvG7dulEHlb6+PsObvLLyrHSaqa4bDoeJx+MUFRVZJ5XJNMvQ2trKiRMnWL169aQeUBusUuD3+61C/bFjx3A6naxevXrSy84MhRlEFi9eTF1d3Yiuoes69913Hz/60Y/Yvn37pPLn2L9/P+vXryebzRIMBnn44Ye56aabJnpZkxI7kExy0uk0v/vd7yxPlWAwaHV/rV+//qIfQD09PezZs4dZs2YxZ86cc+70zNmKcDhseVeYQWWipDp0XaelpYX29vYxV8AdbxRFsQZKI5EIoihSV1dn2TRPJeWAnp4empqaRh1Evve97/G9732Pbdu2sXr16rFd5CiRJIm2tjbi8TiPPvooP/nJT3jxxRftE8kQ2IFkCpHNZvn9739veaq43W7rpPKOd7zjvEVaU/dr4cKFTJ8+/aJ+tyzLVlAp1P+6lAN7uq5z5MgRIpEI9fX1U1K0T5Ikdu/ejcfjYdq0aVZKERjQVjyZTyhmEBlNc4Ou6zzwwAN85zvfYevWraxbt26MVzn2XHPNNcybN48HH3xwopcy6bADyRRFkqQBniqapnHLLbdYniqDC+ZmPWE0ul8mhTtrU//LDCpD+YCMBYUtylNBMmQoTD8aU0XZTFHquj6grViW5SHbtCcDvb297N69e0SbERNd1/nP//xPvv71r/Pcc8+xfv36MV7l+PDe976XmTNn8tBDD030UiYddiB5C6AoCn/84x8tT5VMJmN5qmzYsIF/+qd/QlEU/uEf/mHM6wnmwJ4ZVJxO5wAfkLEIKpqmsW/fPjKZDPX19VOyRTmXy7Fr1y5CodA5O/JMm2ZztqJQWHKiO+p6e3tpampi/vz5F6xkPRhd13nooYf40pe+xNNPP8273vWuMV7l2PClL32JG2+8kZkzZ9LX18fDDz9snZ6uvfbaiV7epMMOJG8xVFXl1VdftZSKk8kkuq7zxS9+kU984hPjOmyoaZo1BR6NRhEEYYD+10iaBMz2WEVRpuyMRTabZdeuXRQXF7Ns2bKLCq6DvUCKi4ute3opT2XxeJzdu3ePOoj88pe/5HOf+xxPPvkkGzZsGONVjh2f+MQn2LZtGx0dHRQXF7Ny5Uq+8IUv2EFkGCZ1IPn3f/937r//fjo7O1m1ahX/9m//xmWXXTbRy5oS5HI57rzzTv70pz9xww038Ic//IFwOMy1117Lpk2buOGGG8bVZc/U/zLTNbquD5BquZCgIssyTU1NiKI4ZdtjM5kMu3btoqysjCVLlozqhJbNZq2gYjY/FLYVj1edygwi8+bNG7EStK7r/OY3v+Hee+9l8+bNXH/99WO8SpuJZNIGkkceeYSPfvSj/OhHP+Lyyy/n+9//Pr/97W85cuTIqHP8bwfuvvtuDh06xNNPP01lZSWaptHU1GTJ37e1tXHNNdfQ2NjITTfdNK5ihINrAIqiUFFRQXV19bD6X7lcjt27d+P1elm5cuWkLj4PRzqdZteuXVRWVrJo0aIxvb9m80OhZpU5+zOWf8tEIsGuXbtGLT2zZcsWPvWpT/HII49wyy23jMnabCYPkzaQXH755axbt44HHngAMHa4M2bM4N577+WLX/ziBK9u8nPixAlLXXUwuq5z4MABK6gcPXp0gKdKWVnZuOt/mbMquVzOCipmYdkcljT97aeaKyMYKaldu3ZRXV09YhXiC6VQWNK0FDBPfyNNKUJ/EJkzZw6zZ88e8fqefvpp7r77bn75y19y2223jfg6NpOXSRlIJEnC7/fz6KOPsmnTJuvrd911F729vTzxxBMTt7i3GGZLrempsn//ft71rnfR2NjIxo0bqaqqGnf9LzOoZDIZiouLSSaTVFZWsnTp0ik1W2FiStnX1dUxf/78S/oaBqcUNU27IPXnwfT19bFr1y5mz549qiDyu9/9jjvvvJOf//znfPCDHxzxdWwmN5MykJw5c4Zp06bx6quvDmgN/PznP8+LL77In/70pwlc3VsXc9jPlL/ftWsXV155pSWcN56eKmDMuezfvx+n04ksy5OmW+liMB/AYyllP1J0XScej1t1lWw2S0VFhSXbPlzjgvkazKHVkbJt2zY+8pGP8OCDD/I//sf/mJKbApsLww4kNkOi6zptbW1WUHn99ddZt24djY2NNDY2jrmnitlaOnv2bObMmUMmk7EmwE39LzOoTFb9r0Qiwe7du0f9AB4PdF0nlUqdV1gymUyyc+dOZs6cydy5c0f8+1566SU+8IEP8IMf/ICPfexjdhB5izMpA4md2ppcmJ4qW7ZsYcuWLbz88susWrXKkr8f7c7bVI9dsGDBkK2lpv6XKYJYVFRkBZXJ4p1idjaNtp5wqchkMtY9NTXViouL6ejoYMaMGcybN2/E13711Ve5/fbb+T//5//wv/7X/7KDyNuASRlIwCi2X3bZZfzbv/0bYOR+Z86cyT333GMX2ycQXdcJh8OWp8qOHTtYsmSJFVQutjvJTGctXbr0gtRjJUmyHoDd3d0DWmAnSjLFPE2Npj12IpEkifb2do4fP46u6wPkb0Kh0EX9Pf/85z+zadMmvvnNb/KZz3zGDiJvEyZtIHnkkUe46667ePDBB7nsssv4/ve/z29+8xsOHz48ob4TNv3ouk53d/cAT5X58+db8vdLly49Z8fQmTNnOHz48IhlW8wWWFNZ1+fzUVVVRXV19SXT/zIVcEcjGTLRpFIpdu7cybRp05g1a9YAa2GXy3XBSgW7d+9m48aN/OM//iN/8zd/YweRtxGTNpAAPPDAA9ZA4urVq/nBD37A5ZdfPtHLshkCs7Breqo8//zzTJ8+3Qoqq1atGhBUWlpaOHnyJKtXr6asrGzUv9/U/zIfgG632woq46X/ZabkLqUz41hjtinX1tae1WE22AoXsGoqg4dK9+3bx80338zf/d3f8YUvfMEOIm8zJnUgsZm69PX18cwzz7B582Z+97vfUVFRwa233kpjYyOPPfYYb7zxBo899hjFxcVj/ruHmqsolGoZi4ecaS07GkOniSadTrNz505qampYsGDBOe+L6VdvngBlWWb//v0Eg0GWL1/OBz/4Qe655x6+8pWvTFgQ+fa3v82WLVs4fPgwPp+PK6+8ku985zssWrRoQtbzdsIOJOfhpZde4v7772fXrl10dHTw2GOPDWgAsDk/qVTK8lR5/PHHcTqdvP/97+cjH/kIV1xxxbhOrWuaZu2qI5EIgiBQWVlpeYCMZFjPlOMfjbXsRGNO3VdVVV30wKQpLPnAAw/w3//935w+fZo5c+bwhS98gcbGRiorK8dx5cNzww038OEPf5h169ahKAp///d/z4EDBzh06NCE+ee8XbADyXl47rnneOWVV2hoaOD222+3A8kIUVWVT3/602zdupW///u/57XXXuPJJ5/E4/GwceNGNm3adEGeKqPB3FWbA5DmsF51dfUFe4CEw2EOHDjAihUrpqxUTyaTYefOnSMKIoU0Nzdz4403cuONNzJ//nwee+wxdu3axd/8zd9w//33j/GqL55oNEpVVRUvvvjipFUZfqtgB5KLQBAEO5CMkJ/85Cf83//7f/n9739vFaUlSeKFF16wTiqA5any7ne/e1yHEM2ajjmrYnqAmFItQwWVjo4O3nzzTVasWDFhu+7RYgaR0ep/tba2csMNN7Bp0ya+//3vWye706dP09PTMyksc5ubm1mwYAH79++fFOt5K2MHkovADiQjR1VVEonEsH4oiqLw0ksvWZ4q2WyWW265hcbGRt773veO6xBioQdIOBy2JsBNYymXy2V1mK1atYry8vJxW8t4ks1m2blzJ+Xl5SxevHjEQeTUqVNcf/313HDDDfzHf/zHpNRC0zSNW2+9ld7eXl5++eWJXs5bHjuQXAR2ILk0qKrKK6+8wqOPPsrjjz9OPB63dr/XXnvtuA4hmhPg5kkllUrh9/tJp9OsXLlyyqazzCAyWjn7jo4Orr/+et71rnfx4x//eNKqMn/605/mueee4+WXX56ybdlTCTuQXAR2ILn0aJrGn/70J8uoKxKJcN1117Fp0yauv/76cfVUAaNNubW1Fa/XSyaTsWRFqqqqpoxTo2msVVpaOqogEg6HufHGG1m3bh0PPfTQpA0i99xzD0888QQvvfTSpJOqeatiB5KLwA4kE4umaezevduSvz916hTXXHMNmzZt4qabbhrzeZGTJ09y/Phx1qxZQ0lJyVmyIhPlVngx5HI5du7cSUlJyajUlKPRKDfffDPLli3jV7/61aQ0GdN1nXvvvZfHHnuMHTt2sGDBgole0tsGO5BcBHYgmTxomjbAU+XYsWO8973vpbGxcUw8VU6cOEFrayv19fVDzrrkcjkrqPT09BAKhQa4FU4GTJ9409dlpPeju7ubm266iXnz5vGb3/xm0tod/+///b95+OGHeeKJJwbMjhQXF0/aQP9WwQ4k5yGZTNLc3AzAmjVr+O53v8uGDRsoKyubkrpKb0V0Xefw4cNWUDlw4ADvfve7LU+VysrKi3qItrS0cOrUKRoaGi4odSZJ0gCpFlOrqrq6elwtcM+3pp07d446iPT29rJx40Zqa2vZsmXLpJbzH+41/vznP+djH/vYpV3M2ww7kJyHHTt2sGHDhrO+ftddd/HQQw9d+gXZnBPTU8UMKk1NTQM8VWpra4d94Jg/e/r0aRoaGkYkAinL8gCpFq/XawWVixVAHClmEAmFQixfvnzEvzORSLBp0yaKi4t54oknJq18v83EYwcSm7csuq5z8uRJNm/ezGOPPcbrr7/OZZddZnmqzJgxw3rIaprGkSNHiEQirF27dkzSU6qqEovFCIfDAwQQq6urx9RXvRBJkti1axeBQIDly5ePuDU3mUxy++2343a7eeaZZ+zUkM05sQOJzdsCXdc5ffq05anyyiuvsHr1ajZt2sTGjRv59re/TS6X4z//8z/Hpb24UAAxEokM0P8qKSkZk1kMM4j4/X5WrFgx4mum02ne//73o+s6zzzzzITJ89tMHexAMoWwRenGBtNT5bHHHmPz5s288sorBAIB7rrrLv7iL/5iVLIhF4Lpqx4Oh4lGo+i6bgWVsrKyEQUAWZbZtWsXPp9vVEEkm83yoQ99yNJHKyoqGtF1bN5e2IFkCmGL0o0tqqryP//n/2THjh18+tOfZseOHWzbto0FCxZw6623ctttt7FkyZJxndzWdZ3e3l5rAFJVVSorK6mqqqK8vPyCZjXMIOL1elm5cuWI15vL5bjjjjuIxWI8//zzlJSUjOg6Nm8/7EAyhbFF6UbHv/zLv/Czn/2Mbdu2MW3aNEt/68knn7Q8VWbOnGkFldE8pC8EXddJJBJWUJEkaYBUy1CzG7Iss3v3btxu91meLxeDJEl89KMf5dSpU2zbtm1MPGJs3j7YgWQKY4vSjY5kMkkqlRrWcTORSAzwVKmqqrKCSkNDw7gHlWQyaQWVTCZDeXm5ZSzlcrlQFIXdu3fjcrlGFURkWeYTn/gER44c4YUXXpiygpQ2E4cdSKYotijdpSWVSvHcc8+xZcsWnnnmGYqLi7n11lvZtGkTl19++bjLhSSTSatQn0wmKS0tJZPJ4PV6WbNmzYh/v6IofOpTn2Lv3r1s377dtrG2GRF2IJmi2KJ0E0cmk+H5559ny5YtPPXUU3i93gGeKuMtH9LX18eePXtQFAVVVSkpKbGK9Rcz66GqKvfccw+vvfYaO3bsoK6ubhxXbfNWxg4kUxBblG7yIEkSf/jDH9iyZQtPPPEEgiBw8803c9ttt/Gud71rzCfBFUWhqakJURRZvXo1sixb8vfxeJyioiJrVuVcsx+apvHXf/3XbN++ne3bt9sqDTajwg4kUwhblG5yI8uy5anyxBNPkMvluPnmm9m0aRMbNmwY9WS4qqo0NTUhCAKrV68+K52Vy+WIRqOEw2F6enoIBoNUV1efpf+laRqf//zneeaZZ9ixY4e9GbEZNXYgmULYonRTB1VVefnlly1PlUQiwY033simTZu45pprLnro0QwiwAXVRGRZtoJKV1cXgiDw3HPP8b73vY8nnniCLVu2sH379gnfjLz00kvcf//97Nq1i46ODlsUdYpiB5IphC1KNzXRNI3XX3/dCirRaHSAp8r5JsdVVWXPnj1omkZ9ff1FF9YVRWH//v384z/+I6+++ioAd955J5/85CdZu3bthIhKmjz33HO88sorNDQ0cPvtt9uBZIpiBxIbm0uIpmns2rWLzZs3s2XLFtrb27nmmmtobGwc0lNFVVX27t2LqqqsWbNmxIV8Xdf59re/zc9+9jM+//nPs3PnTp566ilKSkp49tlnWbZs2Vi9xBFj2zRMXexAYmMzQWiaxr59+6yg0tzczNVXX82tt97KLbfcgtvt5pOf/CR33HEH119//aiCyHe/+12+//3v88ILL7Bq1SrAqKls27aNDRs2TIrUqB1Ipi7jN1Fl87bghz/8IStXrqSoqIiioiLWr1/Pc889N9HLmhKYnVff+MY3OHDgAE1NTVxxxRX86Ec/Ys6cOVx55ZUcPHiQhQsXjnhORNd1/u3f/o3vfe97bN261QoiAB6Ph5tuumlSBBGbqY0dSGxGxfTp07nvvvvYtWsXO3futFwKDx48ONFLm1IIgsDSpUv5yle+wp/+9Cfe9a53kcvlKC8vZ+3atdx00008+OCDdHR0cKFJBF3XefDBB7nvvvt49tlnWbt27Ti/Cpu3K3YgsRkVGzdu5KabbmLBggUsXLiQb33rWwSDQV5//fWJXtqURFVVPvShDxGPx9m/fz+vvfYaR48eZePGjTz66KMsWrSI6667jgceeIBTp04NG1R0XefnP/85X/va13jqqae44oorLvErsXk7YQcSmzFDVVV+/etfk0qlWL9+/UQvZ0ricDjYuHGjpb4rCAJz5szhc5/7HC+//DInTpzggx/8IM888wzLli1jw4YNfP/73+fEiRNWUNF1nf/+7//mS1/6Ek8++STvfOc7J/hV2bzVsYvtNqNm//79rF+/nmw2SzAY5OGHH+amm26a6GW9pdF1nc7OTh577DG2bNnCiy++yPLly2lsbMTj8fCtb32LLVu2cN111030Us9JMpmkubkZMOZjvvvd77JhwwbKysrsafsphB1IbEaNJEm0tbURj8d59NFH+clPfsKLL77I0qVLJ3ppbwt0Xaerq4snnniChx9+mBdeeIFf/vKX3HHHHRO9tPOyY8cONmzYcNbX77rrLh566KFLvyCbEWEHEpsx55prrmHevHk8+OCDE72Utx2mpbAt5GlzKbFrJDZjjqZp5HK5iV7G2xJBEOwgYnPJGV+9a5u3PF/60pe48cYbmTlzJn19fTz88MPs2LGDrVu3TvTSbGxsLhF2ILEZFZFIhI9+9KN0dHRQXFzMypUr2bp1K9dee+1EL83GxuYSYddIbGxsbGxGhV0jsbGxsbEZFXYgsbGxsbEZFXYgsXlLc9999yEIAn/913890UuxsXnLYgcSm7csb7zxBg8++CArV66c6KXY2LylsQOJzVuSZDLJHXfcwY9//GNKS0snejk2Nm9p7EBi85bkM5/5DDfffDPXXHPNRC/FxuYtjx1IbN5y/PrXv2b37t18+9vfnuilvGX593//d2bPno3X6+Xyyy/nz3/+80QvyWYCsQOJzVuKU6dO8Vd/9Vf86le/wuv1TvRy3pI88sgjfPazn+WrX/0qu3fvZtWqVVx//fVEIpGJXprNBGEPJNq8pXj88ce57bbbBljTqqqKIAiIokgulxuxba2NweWXX866det44IEHAENbbcaMGdx777188YtfnODV2UwEtkSKzVuKq6++mv379w/42t13383ixYv5whe+YAeRUSJJErt27eJLX/qS9TVRFLnmmmt47bXXJnBlNhOJHUhs3lKEQiGWL18+4GuBQIDy8vKzvm5z8cRiMVRVpbq6esDXq6urOXz48AStymaisWskNjY2Njajwj6R2Lzl2bFjx0Qv4S1DRUUFDoeDcDg84OvhcJiampoJWpXNRGOfSGxsbC4Yt9tNQ0MD27Zts76maRrbtm1j/fr1E7gym4nEDiQ2NpeAr33tawiCMOD/Fy9ePNHLGhGf/exn+fGPf8wvfvEL3nzzTT796U+TSqW4++67J3ppNhOEndqysblELFu2jD/84Q/WfzudU/Pj96EPfYhoNMpXvvIVOjs7Wb16Nb/73e/OKsDbvH2Ymu9kG5spiNPpfMvUEe655x7uueeeiV6GzSTBTm3Z2Fwijh07Rl1dHXPnzuWOO+6gra1topdkYzMm2JPtNjaXgOeee45kMsmiRYvo6Ojg61//OqdPn+bAgQOEQqGJXp6NzaiwA4mNzQTQ29vLrFmz+O53v8snPvGJiV6Ojc2osFNbNjYTQElJCQsXLqS5uXmil2JjM2rsQGJjMwEkk0laWlqora2d6KXY2IwaO5DY2FwCPve5z/Hiiy/S2trKq6++aikUf+QjH5nopdnYjBq7/dfG5hLQ3t7ORz7yEbq6uqisrOSqq67i9ddfp7KycqKXZmMzauxiu42NjY3NqLBTWzY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o8IOJDY2NjY2o+L/B8/AuHrxeZQFAAAAAElFTkSuQmCC" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", + "polynomial_estimator = GridSearchCV(\n", + " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", + " param_grid=dict(polynomialfeatures__degree=range(4)),\n", + ")\n", + "polynomial_estimator.fit(X, y)\n", + "\n", + "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "3d870dbb", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:autora.skl.bms:BMS fitting started\n", + " 0%| | 7/1500 [00:00<01:15, 19.80it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2**2*_a0_**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return -_a0_**S2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return -_a0_**S2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return -_a0_**S2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1/S2\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S1/_a0_)\n", + " 1%| | 10/1500 [00:00<01:11, 20.75it/s]/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:906: OptimizeWarning: Covariance of the parameters could not be estimated\n", + " warnings.warn('Covariance of the parameters could not be estimated',\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S2**2)\n", + " 1%| | 16/1500 [00:00<01:10, 21.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*cos(S2)**(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*cos(S2)**(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*cos(S2)**(-S1)\n", + " 1%|▏ | 19/1500 [00:00<01:09, 21.32it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + " 1%|▏ | 22/1500 [00:01<01:06, 22.25it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**S1\n", + " 2%|▏ | 25/1500 [00:01<01:11, 20.69it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2*_a0_**sin(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**(_a0_/S1)\n", + " 2%|▏ | 28/1500 [00:01<01:11, 20.71it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/pandas/core/arraylike.py:402: RuntimeWarning: overflow encountered in square\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return -_a0_*_a0_**(-S1)\n", + " 2%|▏ | 34/1500 [00:01<01:13, 20.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sig(_a0_**S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sig(_a0_**S1)/S1\n", + " 3%|▎ | 40/1500 [00:01<01:15, 19.45it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2*_a0_**(-S2)\n", + " 3%|▎ | 42/1500 [00:02<01:16, 19.18it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2*_a0_**(-S2 - _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**3 + sig(_a0_**S1)**S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + " 3%|▎ | 44/1500 [00:02<01:19, 18.29it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + " 3%|▎ | 46/1500 [00:02<01:25, 17.02it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2**S2)\n", + " 3%|▎ | 48/1500 [00:02<01:29, 16.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_)/S1)\n", + " 3%|▎ | 52/1500 [00:02<01:28, 16.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sig(_a0_**S1)/S1\n", + " 4%|▎ | 56/1500 [00:02<01:29, 16.12it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**((1/2)*_a0_)\n", + " 4%|▍ | 58/1500 [00:03<01:27, 16.48it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2*_a0_**(S2**S2)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/scipy/optimize/_minpack_py.py:862: RuntimeWarning: overflow encountered in square\n", + " cost = np.sum(infodict['fvec'] ** 2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2*_a0_**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2*_a0_**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1 - _a0_*(S1 + S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1 - _a0_*(S1 + S2))\n", + " 4%|▍ | 60/1500 [00:03<01:26, 16.62it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S1)**((1/2)*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S1)**((1/2)*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S1)**((1/2)*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*(S1*S2)**(1/4)/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(sin(S1))\n", + " 4%|▍ | 62/1500 [00:03<01:24, 17.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + " 4%|▍ | 64/1500 [00:03<01:22, 17.31it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**((1/2)*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2 + _a0_**relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S1**(S1**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S1**(S1**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S1**(S1**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*(S1 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S1 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S1 + _a0_)/S1)\n", + " 4%|▍ | 66/1500 [00:03<01:26, 16.57it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(S1 + S2)*cosh(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_/S1)\n", + " 5%|▍ | 68/1500 [00:03<01:29, 16.04it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S1 + tan(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(_a0_/S1)\n", + " 5%|▍ | 70/1500 [00:04<02:30, 9.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(-relu(fac(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + " 5%|▍ | 72/1500 [00:04<02:14, 10.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return ((S1*S2)**(1/4)/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2*_a0_**relu(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1))\n", + " 5%|▍ | 74/1500 [00:04<02:05, 11.35it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**_a0_*(S2 + _a0_**2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_/S1)/S1\n", + " 5%|▌ | 76/1500 [00:04<01:55, 12.38it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_*sig(sig(log(_a0_)))**(_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (tan(sqrt(S2*_a0_*relu(S1)))/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (tan(sqrt(S2*_a0_*relu(S1)))/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(sig(log(_a0_)))**(S1*_a0_)*tanh(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + 2*_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(_a0_*_a0_**(-_a0_))\n", + " 5%|▌ | 78/1500 [00:04<01:53, 12.52it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_*relu(S1))**(1/4)/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2 - _a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2 - _a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**tanh(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**tanh(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**tanh(_a0_)\n", + " 5%|▌ | 80/1500 [00:04<01:43, 13.68it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(log(S1))\n", + " 5%|▌ | 82/1500 [00:04<01:41, 13.98it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**tanh(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**tanh(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(_a0_**2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S1)\n", + " 6%|▌ | 84/1500 [00:05<01:38, 14.37it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + fac(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**sin(_a0_)\n", + " 6%|▌ | 86/1500 [00:05<01:40, 14.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(-relu(_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_/S1)\n", + " 6%|▌ | 88/1500 [00:05<01:40, 14.06it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S2*(_a0_**_a0_)**relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S2*(_a0_**_a0_)**relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S2*(_a0_**_a0_)**relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(2)*sqrt(-S2*_a0_**S2/S1)\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return cosh(S1**(-S2)*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return cosh(S1**(-S2)*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return cosh(S1**(-S2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + " 6%|▌ | 90/1500 [00:05<01:36, 14.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*(S2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(2)*sqrt(-S2*_a0_/S1)/S1\n", + " 6%|▌ | 92/1500 [00:05<01:40, 14.05it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*fac(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(2)*sqrt(-S2*(S2 + _a0_)/S1)\n", + " 6%|▋ | 94/1500 [00:05<01:35, 14.65it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return ((-S1)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return ((-S1)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return ((-S1)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-(2*S2*_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-(2*S2*_a0_)**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-(2*S2*_a0_)**S1)\n", + " 6%|▋ | 96/1500 [00:05<01:32, 15.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*cosh(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*sig(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*sig(_a0_/S1)\n", + " 7%|▋ | 98/1500 [00:06<01:34, 14.82it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*relu(S2)/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*relu(S2)/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_*relu(S2)/tan(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(_a0_*relu(S2)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(_a0_*relu(S2)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S1)/S1\n", + " 7%|▋ | 100/1500 [00:06<01:29, 15.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S1**sin(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**sin(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**sin(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**S1\n", + " 7%|▋ | 102/1500 [00:06<01:30, 15.40it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cosh(log(_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cosh(log(_a0_)**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sqrt(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S1**3)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return cosh((1/2)*log(_a0_)/_a0_)\n", + " 7%|▋ | 104/1500 [00:06<01:32, 15.04it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return ((S2*_a0_)**(1/4)/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return ((1/2)*(S2*_a0_)**(1/4)/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(relu(S2)/(S1*_a0_)))\n", + " 7%|▋ | 106/1500 [00:06<01:32, 15.00it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**(-relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**(-relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(_a0_))/S1\n", + " 7%|▋ | 108/1500 [00:06<01:34, 14.81it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + " 7%|▋ | 110/1500 [00:06<01:34, 14.76it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S1)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**(1/4)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(S2)/(S1*_a0_))**(1/4)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**cos(_a0_)\n", + " 7%|▋ | 112/1500 [00:06<01:32, 15.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (cos(S2)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (cos(S2)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (cos(S2)**(1/4)/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1))**(-relu(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + " 8%|▊ | 114/1500 [00:07<01:29, 15.41it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/_a0_**3)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + " 8%|▊ | 116/1500 [00:07<01:26, 15.92it/s]:2: RuntimeWarning: invalid value encountered in divide\n", + " return relu(_a0_)/(sqrt(S1)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + " 8%|▊ | 118/1500 [00:07<01:27, 15.84it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**_a0_*sig(_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**_a0_*sig(_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**_a0_*sig(_a0_)**S1\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S1 + S2)*sig(S2*_a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_/log(_a0_)\n", + " 8%|▊ | 120/1500 [00:07<01:35, 14.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return S1**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return S1**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**cos(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**cos(_a0_)\n", + " 8%|▊ | 122/1500 [00:07<01:33, 14.68it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sig(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2))**(-_a0_)\n", + " 8%|▊ | 124/1500 [00:07<01:27, 15.69it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/S1)\n", + " 8%|▊ | 126/1500 [00:07<01:23, 16.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_/S1)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_/S1)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_/S1)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**(2*S1)\n", + " 9%|▊ | 128/1500 [00:07<01:23, 16.42it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**(-_a0_)\n", + " 9%|▊ | 130/1500 [00:08<01:23, 16.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return ((S2*_a0_)**(1/4)/S1)**(sqrt(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**(-_a0_)\n", + " 9%|▉ | 132/1500 [00:08<01:23, 16.47it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_/S1)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_/S1)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S2/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S2/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S2/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S1**2)\n", + " 9%|▉ | 134/1500 [00:08<01:21, 16.67it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(_a0_*sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(_a0_*sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*tanh(_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*tanh(_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(_a0_)/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/S1)/S1\n", + " 9%|▉ | 136/1500 [00:08<01:23, 16.40it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(-relu(S2)/(_a0_*relu(sinh(_a0_))))\n", + " 9%|▉ | 138/1500 [00:08<01:24, 16.21it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return (S1 + S2)*sig(S1 + _a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(-relu(S2)/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(-relu(S2)/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S2)\n", + " 9%|▉ | 140/1500 [00:08<01:28, 15.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return ((S2*_a0_)**((1/4)*S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S2*relu(S1)))\n", + " 9%|▉ | 142/1500 [00:08<01:26, 15.68it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)*exp(-S1)/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + _a0_ + exp(S2/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + _a0_ + exp(S2/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2**(-S1)*relu(S2)/relu(S1))\n", + " 10%|▉ | 144/1500 [00:08<01:25, 15.78it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S1*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S1*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S1/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S1/_a0_))))\n", + " 10%|▉ | 146/1500 [00:09<01:27, 15.42it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(relu(S2)**3/(_a0_**3*relu(S1)**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(relu(S2)**3/(_a0_**3*relu(S1)**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S1**2*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_))**_a0_)\n", + " 10%|▉ | 148/1500 [00:09<01:37, 13.83it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sin(S1)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sin(S1)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sin(S1)))**_a0_)\n", + " 10%|█ | 150/1500 [00:09<01:41, 13.26it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**(-S2)*sqrt(sinh(S2*_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_**(-S2)*sqrt(sinh(S2*_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/relu(S1**2))\n", + " 10%|█ | 152/1500 [00:09<01:39, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(_a0_/(S2 + _a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*relu(S1)))\n", + "/Users/jholla10/Developer/autora/autora/theorist/bms/mcmc.py:1197: RuntimeWarning: overflow encountered in exp\n", + " paccept = np.exp(-dEB / self.BT - dEP / self.PT)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + " 10%|█ | 154/1500 [00:09<01:43, 13.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + " 10%|█ | 156/1500 [00:09<01:49, 12.27it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*_a0_**((1/2)*S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*_a0_**((1/2)*S1)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + " 11%|█ | 158/1500 [00:10<01:45, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tanh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tanh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tanh(_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(exp(S1 + exp(S2/_a0_))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + " 11%|█ | 160/1500 [00:10<01:40, 13.33it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(S2/_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(S2/_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(S2/_a0_)**S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(_a0_/(S1 + _a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(_a0_))/S1\n", + " 11%|█ | 162/1500 [00:10<01:38, 13.56it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(1/sqrt(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + " 11%|█ | 164/1500 [00:10<01:35, 14.01it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(_a0_**_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(tan(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(tan(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(tan(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(sin(S1))\n", + " 11%|█ | 166/1500 [00:10<01:39, 13.38it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(_a0_*relu(S1)))\n", + " 11%|█ | 168/1500 [00:10<01:36, 13.78it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**exp(S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**exp(S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**exp(S2)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(S1 + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(S1 + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(S1 + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**2\n", + " 11%|█▏ | 170/1500 [00:10<01:32, 14.42it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(_a0_**S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(_a0_**S1)/S1\n", + " 11%|█▏ | 172/1500 [00:11<01:27, 15.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_)/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sig(_a0_)/log(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(sinh(_a0_*tan(S2)))/S1)**sig(S1)\n", + " 12%|█▏ | 174/1500 [00:11<01:27, 15.10it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(2*_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(2*_a0_)**S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S2*(2*_a0_)**S1\n", + " 12%|█▏ | 176/1500 [00:11<01:27, 15.21it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(sinh(S1**2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(sinh(S1**2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + " 12%|█▏ | 178/1500 [00:11<01:27, 15.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*exp(-S1)/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*relu(S1*S2)))\n", + " 12%|█▏ | 180/1500 [00:11<01:24, 15.69it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log((S2 + _a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1*_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S1 + S2)*sig(2*_a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(S1))**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(S1))**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(S1))**log(_a0_))\n", + " 12%|█▏ | 182/1500 [00:11<01:27, 14.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-log(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-log(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + " 12%|█▏ | 184/1500 [00:11<01:30, 14.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**(S1**2)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(log(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + sqrt(_a0_))/S1\n", + " 12%|█▏ | 186/1500 [00:11<01:35, 13.75it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sinh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sinh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sinh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sqrt(_a0_) + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(S1 + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(S1 + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (tanh(sinh(_a0_*abs(S2)))/S1)**sig(S2**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/log(S1))\n", + " 13%|█▎ | 188/1500 [00:12<01:34, 13.84it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sin(_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sin(_a0_)**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-S2)*relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**3)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**3)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**3)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + sqrt(_a0_))/S2\n", + " 13%|█▎ | 190/1500 [00:12<01:34, 13.90it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*relu(S2**_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 13%|█▎ | 192/1500 [00:12<01:32, 14.20it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return S1**_a0_/fac(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(tan(S1 + exp(S2*_a0_))))\n", + " 13%|█▎ | 194/1500 [00:12<01:30, 14.50it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(cosh(S2)/S1)/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(cosh(S2)/S1)/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(cosh(S2)/S1)/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1*_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1*_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1*_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*(S1 + sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**(-_a0_)*(S1 + sqrt(_a0_))\n", + " 13%|█▎ | 196/1500 [00:12<01:30, 14.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", + " 13%|█▎ | 198/1500 [00:12<01:31, 14.17it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(relu(_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(relu(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**(S1**(3/2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1 + sqrt(_a0_)\n", + " 13%|█▎ | 200/1500 [00:12<01:31, 14.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sqrt(_a0_))/S1\n", + " 13%|█▎ | 202/1500 [00:13<01:30, 14.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/2*relu(S2)/(S2*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(S1*sin(S2))\n", + " 14%|█▎ | 204/1500 [00:13<01:26, 14.90it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1*_a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*_a0_)/sqrt(S1*_a0_/S2)\n", + " 14%|█▎ | 206/1500 [00:13<01:28, 14.63it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(S1 + _a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(relu(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)/S1**(3/2)\n", + " 14%|█▍ | 208/1500 [00:13<01:28, 14.62it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + " 14%|█▍ | 210/1500 [00:13<01:26, 14.87it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(_a0_**_a0_ + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + " 14%|█▍ | 212/1500 [00:13<01:26, 14.91it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(cos(_a0_)**3)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(cos(_a0_)**3)**S1)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(exp(2*S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(exp(2*S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(exp(2*S2))**_a0_\n", + " 14%|█▍ | 214/1500 [00:13<01:24, 15.17it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(S1*_a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**2/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**2/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**2/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2/(S1*_a0_))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2/(S1*_a0_))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(S2/(S1*_a0_))/S1\n", + " 14%|█▍ | 216/1500 [00:14<01:28, 14.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sinh(cos(2*_a0_))**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sinh(cos(2*_a0_))**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S1 + _a0_)*relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1**2)**(S1**S2)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 15%|█▍ | 218/1500 [00:14<01:32, 13.88it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*sig(sqrt(_a0_))**S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2*sig(sqrt(_a0_))**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + " 15%|█▍ | 220/1500 [00:14<02:08, 9.97it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(_a0_**(3/2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(sqrt(_a0_)/S1)/S1\n", + " 15%|█▍ | 222/1500 [00:14<01:54, 11.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + " 15%|█▍ | 224/1500 [00:14<01:50, 11.55it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**S1))))\n", + " 15%|█▌ | 226/1500 [00:14<01:43, 12.34it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 15%|█▌ | 228/1500 [00:15<01:37, 13.01it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(sin(_a0_)))\n", + " 15%|█▌ | 230/1500 [00:15<01:30, 14.06it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + " 15%|█▌ | 232/1500 [00:15<01:25, 14.76it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(-relu(S2)/(sqrt(_a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + " 16%|█▌ | 234/1500 [00:15<01:22, 15.28it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (log(sinh(_a0_*abs(S2)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (log(sinh(_a0_*abs(S2)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_/S1)/S1\n", + " 16%|█▌ | 236/1500 [00:15<01:21, 15.52it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)\n", + " 16%|█▌ | 238/1500 [00:15<01:19, 15.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cosh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 16%|█▌ | 240/1500 [00:15<01:20, 15.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**(2*S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**(2*S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**(2*S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + " 16%|█▌ | 242/1500 [00:15<01:17, 16.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/2*relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S2)*sig(_a0_/S1)**(S1*log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 16%|█▋ | 244/1500 [00:16<01:23, 15.12it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_**(-1.0))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1**2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1**2)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 16%|█▋ | 246/1500 [00:16<01:23, 15.06it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(fac(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(fac(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(fac(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-cos(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-cos(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_/S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_/S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_/S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2)**_a0_)\n", + " 17%|█▋ | 248/1500 [00:16<01:20, 15.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*exp(-S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*exp(-S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*exp(-S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1 + _a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1 + _a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(S1 + _a0_)**S1)\n", + " 17%|█▋ | 250/1500 [00:16<01:17, 16.16it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(S2 + _a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return -sqrt(_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1))\n", + " 17%|█▋ | 252/1500 [00:16<01:14, 16.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(relu(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-log(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + " 17%|█▋ | 254/1500 [00:16<01:13, 16.90it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(relu(_a0_))**_a0_))\n", + " 17%|█▋ | 256/1500 [00:16<01:11, 17.46it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + " 17%|█▋ | 260/1500 [00:17<01:13, 16.92it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + " 17%|█▋ | 262/1500 [00:17<01:12, 17.03it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**(2*S2))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**(2*S2))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**(2*S2))**_a0_)\n", + " 18%|█▊ | 264/1500 [00:17<01:12, 16.98it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 18%|█▊ | 266/1500 [00:17<01:15, 16.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(-S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(-S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(-S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**exp(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*(S1 + _a0_)))\n", + " 18%|█▊ | 268/1500 [00:17<01:17, 15.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sig(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sig(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*sig(_a0_**S1)**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + " 18%|█▊ | 270/1500 [00:17<01:18, 15.57it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S1)\n", + " 18%|█▊ | 272/1500 [00:17<01:16, 16.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**_a0_/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + " 18%|█▊ | 274/1500 [00:17<01:17, 15.88it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(cos(S2)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + " 18%|█▊ | 276/1500 [00:18<01:16, 16.03it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S1)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + " 19%|█▊ | 278/1500 [00:18<01:14, 16.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*sinh(S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(relu(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(relu(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(relu(S1))**(S2**S2)))\n", + " 19%|█▊ | 280/1500 [00:18<01:13, 16.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(relu(sin(S1)))**_a0_))\n", + " 19%|█▉ | 282/1500 [00:18<01:12, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(2*_a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return S2**_a0_/log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_)\n", + " 19%|█▉ | 284/1500 [00:18<01:14, 16.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1**(_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1**(_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1**(_a0_**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_))\n", + " 19%|█▉ | 286/1500 [00:18<01:12, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1 + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1 + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)\n", + " 19%|█▉ | 288/1500 [00:18<01:12, 16.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S1 + _a0_)/(S1*sqrt(_a0_**3))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + " 19%|█▉ | 290/1500 [00:18<01:13, 16.36it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_/S1)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2*(_a0_/S1)**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 19%|█▉ | 292/1500 [00:18<01:11, 16.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-tan(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-tan(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(relu(S1)*tanh(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 20%|█▉ | 294/1500 [00:19<01:11, 16.78it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)\n", + " 20%|█▉ | 296/1500 [00:19<01:26, 13.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + " 20%|█▉ | 298/1500 [00:19<01:19, 15.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + " 20%|██ | 300/1500 [00:19<01:15, 15.97it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(S1))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(S1))**(S1*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + " 20%|██ | 302/1500 [00:19<01:14, 15.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(S2*_a0_)**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + " 20%|██ | 304/1500 [00:19<01:13, 16.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2**_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**3)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**3)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_/sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(_a0_*_a0_**S2))))\n", + " 20%|██ | 306/1500 [00:19<01:15, 15.75it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S1)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + " 21%|██ | 308/1500 [00:20<01:12, 16.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S1**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S1**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S1**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sig(_a0_))*exp(-sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2))\n", + " 21%|██ | 310/1500 [00:20<01:12, 16.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + " 21%|██ | 312/1500 [00:20<01:12, 16.36it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_**3))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_**3))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_**3))**_a0_\n", + " 21%|██ | 314/1500 [00:20<01:12, 16.35it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(-_a0_**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(-_a0_**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(-_a0_**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + " 21%|██ | 316/1500 [00:20<01:11, 16.59it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S2*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + " 21%|██ | 318/1500 [00:20<01:11, 16.58it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-tanh(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 21%|██▏ | 320/1500 [00:20<01:10, 16.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2**2))\n", + " 21%|██▏ | 322/1500 [00:20<01:11, 16.46it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + " 22%|██▏ | 324/1500 [00:20<01:09, 16.87it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S2**S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-sig(_a0_)/(S2 + _a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + " 22%|██▏ | 326/1500 [00:21<01:13, 16.02it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S2)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S2)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S2)/(S1 + _a0_)\n", + " 22%|██▏ | 328/1500 [00:21<01:10, 16.52it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_ + sig(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + " 22%|██▏ | 330/1500 [00:21<01:11, 16.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S2))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*exp(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + " 22%|██▏ | 332/1500 [00:21<01:09, 16.71it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2*_a0_)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)\n", + " 22%|██▏ | 334/1500 [00:21<01:10, 16.49it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(cos(S1 + exp(S2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S2))/sqrt(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S2))/sqrt(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S2))/sqrt(S1)\n", + " 22%|██▏ | 336/1500 [00:21<01:10, 16.62it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tanh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tanh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tanh(_a0_))**_a0_)\n", + " 23%|██▎ | 338/1500 [00:21<01:10, 16.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*(S1 + S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*(S1 + S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*(S1 + S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**abs(_a0_)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sin(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sin(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sin(_a0_))**_a0_)\n", + " 23%|██▎ | 340/1500 [00:21<01:12, 16.08it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 23%|██▎ | 342/1500 [00:22<01:11, 16.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*exp(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2 + _a0_)/sqrt(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_/S1)/sqrt(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1))\n", + " 23%|██▎ | 344/1500 [00:22<01:28, 13.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + " 23%|██▎ | 346/1500 [00:22<01:22, 14.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**abs(_a0_)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(S2*cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sig(_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sig(_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", + " 23%|██▎ | 348/1500 [00:22<01:19, 14.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*sig(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*sig(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*sig(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + " 23%|██▎ | 350/1500 [00:22<01:14, 15.51it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S2)))**_a0_))\n", + " 23%|██▎ | 352/1500 [00:22<01:11, 15.99it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + " 24%|██▎ | 354/1500 [00:22<01:08, 16.79it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S2*S2**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + " 24%|██▎ | 356/1500 [00:22<01:08, 16.81it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sinh(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sinh(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(cos(exp(S2*_a0_) + log(_a0_))))\n", + " 24%|██▍ | 358/1500 [00:23<01:10, 16.27it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-relu(S2)/(S1*_a0_))**S1\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1))\n", + " 24%|██▍ | 360/1500 [00:23<01:10, 16.16it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + " 24%|██▍ | 362/1500 [00:23<01:09, 16.27it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1 + sin(S2**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + sqrt(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**abs(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**abs(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**abs(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/sin(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(_a0_)/S1)\n", + " 24%|██▍ | 364/1500 [00:23<01:07, 16.73it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(tanh(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + " 24%|██▍ | 366/1500 [00:23<01:08, 16.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(exp(cos(S1 + exp(S1**S1*S2))))\n", + " 25%|██▍ | 368/1500 [00:23<01:10, 16.15it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-cos(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-cos(S2)/(S1*_a0_))\n", + " 25%|██▍ | 370/1500 [00:23<01:10, 16.05it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 25%|██▍ | 372/1500 [00:23<01:10, 16.10it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(-_a0_**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return log(-_a0_**_a0_/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-S1)**_a0_))\n", + " 25%|██▍ | 374/1500 [00:24<01:41, 11.07it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_) + exp(S1)\n", + " 25%|██▌ | 376/1500 [00:24<01:32, 12.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*tan(S2)))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/(S1*S2))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/(S1*S2))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/(S1*S2))/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_ + _a0_**_a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*sig(_a0_)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1*sqrt(S2*_a0_)/S2\n", + " 25%|██▌ | 378/1500 [00:24<01:25, 13.05it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**abs(_a0_)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 25%|██▌ | 380/1500 [00:24<01:20, 13.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin(S2**_a0_)**S2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin(S2**_a0_)**S2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/_a0_)/sqrt(S1*S2)\n", + " 25%|██▌ | 382/1500 [00:24<01:16, 14.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sig(_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(-S1)*sqrt(S2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(sinh(S1))**_a0_\n", + " 26%|██▌ | 384/1500 [00:24<01:13, 15.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(-S1*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + " 26%|██▌ | 386/1500 [00:25<01:14, 15.03it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S2)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*sinh(S2))*exp(-S1)\n", + " 26%|██▌ | 388/1500 [00:25<01:16, 14.58it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin(S2**_a0_)**S2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-S1 - _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(log(S2))/(S1*_a0_))\n", + " 26%|██▌ | 390/1500 [00:25<01:14, 14.90it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1 + sqrt(_a0_/S1)\n", + " 26%|██▌ | 392/1500 [00:25<01:16, 14.52it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*tanh(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*tanh(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(S1)**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(S1)**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(S1)**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(sin(_a0_)))\n", + " 26%|██▋ | 394/1500 [00:25<01:12, 15.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S2*sqrt(S2*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-_a0_)\n", + " 26%|██▋ | 396/1500 [00:25<01:13, 15.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S2)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_*_a0_**(2*S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(cos(S1))\n", + " 27%|██▋ | 398/1500 [00:25<01:08, 16.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/tan(S2))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(S2/_a0_)/sqrt(tan(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 27%|██▋ | 400/1500 [00:25<01:08, 15.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1))\n", + " 27%|██▋ | 402/1500 [00:26<01:10, 15.62it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(sqrt(_a0_)))**_a0_\n", + " 27%|██▋ | 404/1500 [00:26<01:09, 15.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + " 27%|██▋ | 407/1500 [00:26<01:02, 17.37it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S1) + _a0_)**(S1**(3/2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S2**(S2**S1)/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 27%|██▋ | 409/1500 [00:26<01:02, 17.47it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(tan(_a0_))/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2 + sin(sqrt(_a0_)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_/S2)\n", + " 27%|██▋ | 411/1500 [00:26<01:00, 17.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S2))\n", + " 28%|██▊ | 413/1500 [00:26<01:01, 17.66it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sinh(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 28%|██▊ | 415/1500 [00:26<01:03, 17.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/sin(_a0_))**sig(S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/(S1*S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin(S2**_a0_)**S2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)\n", + " 28%|██▊ | 417/1500 [00:26<01:05, 16.59it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/S1**2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(S2)/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", + " 28%|██▊ | 419/1500 [00:27<01:04, 16.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_/S2))**_a0_\n", + " 28%|██▊ | 421/1500 [00:27<01:05, 16.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(sin(S2))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(fac(S1 + exp(S2**2/_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S2))**_a0_\n", + " 28%|██▊ | 423/1500 [00:27<01:07, 15.92it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + " 28%|██▊ | 425/1500 [00:27<01:04, 16.67it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + " 28%|██▊ | 427/1500 [00:27<01:05, 16.38it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**4)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**4)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**4)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2/_a0_)/sqrt(S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/(S2*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S1)))**_a0_))\n", + " 29%|██▊ | 429/1500 [00:27<01:06, 16.11it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2/_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2/_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S2/_a0_)**S1))\n", + " 29%|██▊ | 431/1500 [00:27<01:05, 16.25it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*(_a0_**2)**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + " 29%|██▉ | 433/1500 [00:27<01:07, 15.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sin(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sin(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*sin(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*sin(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + sqrt(S2**2/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + sqrt(S2**2/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)*sig(sig(S1))**(-S1*_a0_)\n", + " 29%|██▉ | 435/1500 [00:28<01:08, 15.44it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S1))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S1))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S1))*exp(-S1)\n", + " 29%|██▉ | 437/1500 [00:28<01:06, 16.04it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_/S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (log(relu(S2/_a0_))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (log(relu(S2/_a0_))/S1)**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*log(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*log(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*log(S2))*exp(-S1)\n", + " 29%|██▉ | 439/1500 [00:28<01:09, 15.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S1)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + " 29%|██▉ | 441/1500 [00:28<01:09, 15.14it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-tan(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(-S1)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(-S1)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(-S1)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + " 30%|██▉ | 443/1500 [00:28<01:11, 14.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_*sinh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*sin(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*sqrt(S2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**(-_a0_)*sqrt(S2*_a0_)\n", + " 30%|██▉ | 445/1500 [00:28<01:09, 15.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(exp(_a0_))/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(tan(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(tan(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(tan(S1)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + " 30%|██▉ | 447/1500 [00:28<01:08, 15.45it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2))/S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2))/S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2))/S2)\n", + " 30%|██▉ | 449/1500 [00:28<01:05, 15.98it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(exp(sinh(S1 + exp(S2**2/_a0_))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(sinh(S1 + exp(S2**2/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + " 30%|███ | 451/1500 [00:29<01:11, 14.60it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S2)**_a0_\n", + " 30%|███ | 453/1500 [00:29<01:10, 14.79it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*sin(S1)))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/S1\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(cos(S1 + exp(S2*_a0_**_a0_/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/tanh(S1)\n", + " 30%|███ | 455/1500 [00:29<01:08, 15.37it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/tan(S1)\n", + " 30%|███ | 457/1500 [00:29<01:09, 14.96it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/relu(S1)\n", + " 31%|███ | 459/1500 [00:29<01:06, 15.75it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2*_a0_))/S1**(3/2)\n", + " 31%|███ | 461/1500 [00:29<01:06, 15.52it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/abs(S1)\n", + " 31%|███ | 463/1500 [00:29<01:06, 15.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(cos(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(cos(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(cos(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 31%|███ | 465/1500 [00:30<01:07, 15.30it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_))**_a0_\n", + " 31%|███ | 467/1500 [00:30<01:10, 14.55it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S1/_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 31%|███▏ | 469/1500 [00:30<01:09, 14.81it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))*sig(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S2/(S1*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + " 31%|███▏ | 471/1500 [00:30<01:10, 14.51it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + " 32%|███▏ | 473/1500 [00:30<01:08, 14.96it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(-S1**2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(-S1**2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(-S1**2)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S1))\n", + " 32%|███▏ | 475/1500 [00:30<01:12, 14.17it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return abs(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return abs(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return abs(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/log(S1)\n", + " 32%|███▏ | 477/1500 [00:30<01:10, 14.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2**3))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2**3))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 32%|███▏ | 479/1500 [00:31<01:10, 14.55it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return abs(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return abs(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return abs(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(S1))**(-S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2**3)**3/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2**3)**3/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs((_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + " 32%|███▏ | 481/1500 [00:31<01:09, 14.77it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(log(_a0_)**3))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(_a0_)**3))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + " 32%|███▏ | 483/1500 [00:31<01:13, 13.85it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/(S1*_a0_**2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**2)**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(S1)\n", + " 32%|███▏ | 485/1500 [00:31<01:12, 14.00it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + sin(cos(S1)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(cos(S1 + log(relu(S2)/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(cos(S1 + log(relu(S2)/_a0_))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**3))\n", + " 32%|███▏ | 487/1500 [00:31<01:11, 14.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(2*_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(cos(S1 + exp(relu(sqrt(_a0_))/_a0_))))\n", + " 33%|███▎ | 489/1500 [00:31<01:14, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (S2/_a0_ + sin(log(_a0_)**_a0_))*exp(-S1)\n", + " 33%|███▎ | 491/1500 [00:31<01:11, 14.06it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S2 - _a0_)**_a0_))*exp(-S1)\n", + " 33%|███▎ | 493/1500 [00:32<01:09, 14.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**S1/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-S1)\n", + " 33%|███▎ | 495/1500 [00:32<01:12, 13.82it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-sig(_a0_**_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-sig(_a0_**_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-sig(_a0_**_a0_)/S1)/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-S2)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 33%|███▎ | 497/1500 [00:32<01:17, 12.93it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(S2)/_a0_)**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*fac(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S1)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S2)))**_a0_\n", + " 33%|███▎ | 499/1500 [00:32<01:11, 13.91it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S1))**(S1**S1*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(_a0_)))/S1**(3/2)\n", + " 33%|███▎ | 501/1500 [00:32<01:08, 14.61it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_/(S1 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S1 + _a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_)**_a0_\n", + " 34%|███▎ | 503/1500 [00:32<01:09, 14.39it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 34%|███▎ | 505/1500 [00:32<01:10, 14.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_**(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + " 34%|███▍ | 507/1500 [00:33<01:09, 14.26it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 34%|███▍ | 509/1500 [00:33<01:06, 14.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**(-_a0_)*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**(2*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**(2*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1))**(2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(S1*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-S2)*relu(S2))))))\n", + " 34%|███▍ | 511/1500 [00:33<01:10, 14.09it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*sqrt(S2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_**(-S2)*sqrt(S2*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(tan(S1 + exp(relu(S2)/_a0_)))))\n", + " 34%|███▍ | 513/1500 [00:33<01:10, 13.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2**3))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2**3))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", + " 34%|███▍ | 515/1500 [00:33<01:11, 13.72it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(cos(S2)))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-fac(_a0_))\n", + " 34%|███▍ | 517/1500 [00:33<01:09, 14.06it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(S2))))))\n", + " 35%|███▍ | 519/1500 [00:33<01:10, 13.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(S1*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return relu(relu(exp(cosh(S1 + exp(relu(S2)/_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cosh(S1 + exp(relu(S2)/_a0_)))))\n", + " 35%|███▍ | 521/1500 [00:34<01:13, 13.28it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(cos(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(cos(S2))/(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + " 35%|███▍ | 523/1500 [00:34<01:13, 13.25it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**(3/2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**(3/2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1**(3/2))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**(-S1)*relu(S2)/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(log(S2**3))/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(log(S2**3))/(S1 + _a0_))\n", + " 35%|███▌ | 525/1500 [00:34<01:12, 13.37it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_))/sqrt(S1*S2))\n", + " 35%|███▌ | 527/1500 [00:34<01:09, 14.03it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_**3*relu(S2)**3/S1**3)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_**3*relu(S2)**3/S1**3)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S1))/(S1 + _a0_))\n", + " 35%|███▌ | 529/1500 [00:34<01:10, 13.84it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + " 35%|███▌ | 531/1500 [00:34<01:11, 13.56it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(sin(S1))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(sin(S1))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(sin(S1))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((S1 + S2)**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((S1 + S2)**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + " 36%|███▌ | 533/1500 [00:34<01:10, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(_a0_*relu(S2)/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(fac(_a0_*relu(S2)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/cos(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_**(2*S1))**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + " 36%|███▌ | 535/1500 [00:35<01:13, 13.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return S2**_a0_/(_a0_ + log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(-sqrt(_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(-sqrt(_a0_)/S1)/S1)\n", + " 36%|███▌ | 537/1500 [00:35<01:13, 13.03it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S2*sqrt(S2*_a0_)/S1\n", + " 36%|███▌ | 539/1500 [00:35<01:11, 13.38it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S2 + exp(_a0_*relu(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-2*_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*tanh(_a0_)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + " 36%|███▌ | 541/1500 [00:35<01:12, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2*_a0_)**_a0_)\n", + " 36%|███▌ | 543/1500 [00:35<01:09, 13.68it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*fac(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-_a0_**(-S1)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/(_a0_ + cos(S2)))\n", + " 36%|███▋ | 545/1500 [00:35<01:13, 12.95it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sin(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sin(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return abs(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**(-S2)*exp(-sig(_a0_)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(S1))**(sqrt(_a0_))\n", + " 36%|███▋ | 547/1500 [00:36<01:14, 12.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*tanh(S1)))/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S1*S2))/(S1 + _a0_))\n", + " 37%|███▋ | 549/1500 [00:36<01:11, 13.35it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(_a0_*relu(S2))**relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(_a0_*relu(S2))**relu(S1))\n", + " 37%|███▋ | 551/1500 [00:36<01:10, 13.53it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*tanh(_a0_)**S1))\n", + " 37%|███▋ | 553/1500 [00:36<01:07, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2*_a0_*relu(S1)))\n", + " 37%|███▋ | 555/1500 [00:36<01:06, 14.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sinh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(sinh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(S1)))\n", + " 37%|███▋ | 557/1500 [00:36<01:02, 15.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S2 + _a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**_a0_\n", + " 37%|███▋ | 559/1500 [00:36<01:02, 15.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2**2)**3/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(S2**2)**3/S1)\n", + " 37%|███▋ | 561/1500 [00:36<01:05, 14.42it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(-sig(_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(-sig(_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S1)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S1)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S1)))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", + " 38%|███▊ | 563/1500 [00:37<01:40, 9.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/relu(S1))\n", + " 38%|███▊ | 565/1500 [00:37<01:29, 10.45it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", + " 38%|███▊ | 567/1500 [00:37<01:23, 11.24it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + exp(sqrt(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*_a0_**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-S1)/_a0_**(1/4)\n", + " 38%|███▊ | 569/1500 [00:37<01:18, 11.85it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(-S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(-S2*_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(sqrt(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**(-_a0_)*sig(_a0_))/S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(S1 + _a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S2))\n", + " 38%|███▊ | 571/1500 [00:37<01:13, 12.64it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(log(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + " 38%|███▊ | 573/1500 [00:38<01:10, 13.14it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(tan(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(tan(S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(_a0_*relu(2*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 38%|███▊ | 575/1500 [00:38<01:07, 13.65it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sinh(relu(S1))**(sqrt(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(relu(S1 + exp(S2/_a0_)))))\n", + " 38%|███▊ | 577/1500 [00:38<01:07, 13.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*log(_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*log(_a0_)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(-sig(_a0_**S2)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 39%|███▊ | 579/1500 [00:38<01:06, 13.77it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(relu(S2))/_a0_)**relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(relu(relu(S2))/_a0_)**relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(log(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(sin(S1))))\n", + " 39%|███▊ | 581/1500 [00:38<01:06, 13.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(_a0_*(S1 + S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*_a0_/S1))/S1)\n", + " 39%|███▉ | 583/1500 [00:38<01:07, 13.58it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S1**2/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/((S1 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + " 39%|███▉ | 585/1500 [00:38<01:09, 13.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_**(-S1)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(cos(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(cos(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(cos(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_*sqrt(S2/_a0_)/S1\n", + " 39%|███▉ | 587/1500 [00:39<01:11, 12.77it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S2/S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S2/S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-sqrt(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**(-_a0_)\n", + " 39%|███▉ | 589/1500 [00:39<01:08, 13.36it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*sin(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*sin(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + " 39%|███▉ | 591/1500 [00:39<01:08, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S1)*relu(relu(S2))/_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(-S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(-S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(-S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-2*S2)\n", + " 40%|███▉ | 593/1500 [00:39<01:10, 12.85it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2)**(S1**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*log(_a0_)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp((S1 + exp(S2/_a0_))**3)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**fac(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(S2 + _a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((-sinh(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((-sinh(S1))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(-_a0_/(S1*S2))/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(-_a0_/(S1*S2))/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(-_a0_/(S1*S2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 40%|███▉ | 595/1500 [00:39<01:09, 13.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*(_a0_/S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + " 40%|███▉ | 597/1500 [00:39<01:05, 13.81it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(_a0_*relu(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2*relu(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2*relu(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 40%|███▉ | 599/1500 [00:40<01:13, 12.18it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(cos(S2)))/(_a0_*relu(S1)))\n", + " 40%|████ | 601/1500 [00:40<01:34, 9.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + " 40%|████ | 603/1500 [00:40<01:30, 9.91it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-S2)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2)*sig(sinh(_a0_))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(cos(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(sqrt(_a0_) + exp(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tanh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tanh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/S1**(3/2)\n", + " 40%|████ | 605/1500 [00:40<01:26, 10.32it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 40%|████ | 607/1500 [00:40<01:24, 10.55it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2 + _a0_))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(S2*exp(2*exp(S2))**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(S2*exp(2*exp(S2))**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(S2*exp(2*exp(S2))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2*relu(S2)))/S1)\n", + " 41%|████ | 609/1500 [00:41<01:17, 11.55it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**_a0_)))))\n", + " 41%|████ | 611/1500 [00:41<01:15, 11.80it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(_a0_/S1))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(S2/_a0_))/(_a0_*relu(S1)))\n", + " 41%|████ | 613/1500 [00:41<01:16, 11.60it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S2)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S2)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S2)))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**_a0_/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**_a0_/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-_a0_**_a0_/S1)/S1)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + " 41%|████ | 615/1500 [00:41<01:14, 11.81it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(-S2))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(-S2))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(-S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2**_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", + " 41%|████ | 617/1500 [00:41<01:11, 12.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S1)/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sin(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sin(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sin(_a0_)))**_a0_\n", + " 41%|████▏ | 619/1500 [00:41<01:12, 12.20it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2*relu(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2*relu(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1))**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1))**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1))**(_a0_**S1)\n", + " 41%|████▏ | 621/1500 [00:42<01:12, 12.11it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(relu(log(S1)))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*(S2 + _a0_)))/S1)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_**_a0_)/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/S1**(3/2)\n", + " 42%|████▏ | 623/1500 [00:42<01:12, 12.14it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))**_a0_/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**S1/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**S1/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/S1**(3/2)\n", + " 42%|████▏ | 625/1500 [00:42<01:09, 12.64it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*log(S2)))/S1)\n", + " 42%|████▏ | 627/1500 [00:42<01:09, 12.65it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(2*_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1 + _a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(-S2))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(-S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + " 42%|████▏ | 629/1500 [00:42<01:10, 12.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(_a0_*relu(2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**(-_a0_)*relu(relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + tan(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + " 42%|████▏ | 631/1500 [00:42<01:14, 11.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(_a0_)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S1)*(sqrt(S1) + _a0_)/S1\n", + " 42%|████▏ | 633/1500 [00:42<01:09, 12.43it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(tan(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(tan(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(relu(S2))/(relu(S1)*relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + " 42%|████▏ | 635/1500 [00:43<01:08, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(relu(S1))**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(relu(S1))**log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(relu(S1))**log(_a0_))\n", + " 42%|████▏ | 637/1500 [00:43<01:07, 12.74it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-relu(sin(S2))/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_)))**_a0_\n", + " 43%|████▎ | 639/1500 [00:43<01:06, 12.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*tan(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*tan(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 43%|████▎ | 641/1500 [00:43<01:06, 12.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(relu(S2)/(_a0_*relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))**2\n", + " 43%|████▎ | 643/1500 [00:43<01:07, 12.62it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/S1**(3/2)\n", + " 43%|████▎ | 645/1500 [00:43<01:07, 12.70it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-relu(S2)/(_a0_*relu(sin(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(fac(_a0_)))**_a0_))**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(sqrt(S1 + exp(S2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + " 43%|████▎ | 647/1500 [00:44<01:05, 13.02it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(relu(S1))**_a0_\n", + " 43%|████▎ | 649/1500 [00:44<01:04, 13.19it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sin(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sin(S2)/(_a0_*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sinh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sinh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(sinh(_a0_)))**_a0_\n", + " 43%|████▎ | 651/1500 [00:44<01:04, 13.23it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(2*_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/_a0_**2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*_a0_))\n", + " 44%|████▎ | 653/1500 [00:44<01:04, 13.23it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + " 44%|████▎ | 655/1500 [00:44<01:04, 13.10it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/((S2 + _a0_)*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))**2\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S2)/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(_a0_**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + " 44%|████▍ | 657/1500 [00:44<01:04, 12.99it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(tan(S1 + exp(S2/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S2**2*relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 44%|████▍ | 659/1500 [00:44<01:05, 12.86it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/(S1*relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-S1)*log(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + " 44%|████▍ | 661/1500 [00:45<01:04, 13.09it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*log(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2/_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(_a0_))\n", + " 44%|████▍ | 663/1500 [00:45<01:04, 13.07it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + " 44%|████▍ | 665/1500 [00:45<01:03, 13.09it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(-log(S2*relu(S2))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(-log(S2*relu(S2))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(2*_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/S1**(3/2)\n", + " 44%|████▍ | 667/1500 [00:45<01:03, 13.21it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 45%|████▍ | 669/1500 [00:45<01:03, 13.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_/S2))**_a0_))\n", + " 45%|████▍ | 671/1500 [00:45<01:03, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/(S2 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**(-S1)*relu(relu(S2/_a0_)))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(log(S2*relu(S2))**3/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(log(S2*relu(S2))**3/S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + " 45%|████▍ | 673/1500 [00:46<01:02, 13.17it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*relu(S2)/relu(S1))**S2\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(abs(S1 + exp((S2 + _a0_)/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(-log(S2*relu(S2))/S1))\n", + " 45%|████▌ | 675/1500 [00:46<01:03, 13.02it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(tanh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(tanh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(tanh(_a0_)))**_a0_\n", + " 45%|████▌ | 677/1500 [00:46<01:03, 13.04it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp((S1 + exp((S2 + _a0_)/_a0_))**2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + " 45%|████▌ | 679/1500 [00:46<01:01, 13.32it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S1*_a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(sqrt(_a0_)/S1)/S1)\n", + " 45%|████▌ | 681/1500 [00:46<01:01, 13.31it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(_a0_**S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/relu(S1/S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(cos(log(S2*relu(S2)))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(cos(log(S2*relu(S2)))/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(_a0_/S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(_a0_/S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(_a0_/S1))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(_a0_**S1))**_a0_\n", + " 46%|████▌ | 683/1500 [00:46<01:01, 13.31it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1))**(_a0_**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(-_a0_/(S1*S2))/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(-_a0_/(S1*S2))/S1)\n", + " 46%|████▌ | 685/1500 [00:46<01:01, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(tan(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + " 46%|████▌ | 687/1500 [00:47<01:01, 13.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + sin(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + sin(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + " 46%|████▌ | 689/1500 [00:47<01:00, 13.40it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-cos(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(tan(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + " 46%|████▌ | 691/1500 [00:47<01:00, 13.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2*_a0_)**_a0_\n", + " 46%|████▌ | 693/1500 [00:47<01:00, 13.38it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S1**_a0_*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + " 46%|████▋ | 695/1500 [00:47<00:58, 13.69it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-sqrt(S1)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(_a0_**S2))/S1**(3/2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**S1*_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 46%|████▋ | 697/1500 [00:47<00:57, 14.02it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(tan(log(S2**2))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(tan(log(S2**2))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + " 47%|████▋ | 699/1500 [00:47<01:00, 13.35it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/(S2 + _a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return log(sqrt(_a0_*relu(S2)/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S2)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(tan(S2)))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + " 47%|████▋ | 701/1500 [00:48<01:03, 12.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return abs(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + " 47%|████▋ | 703/1500 [00:48<01:04, 12.28it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + " 47%|████▋ | 705/1500 [00:48<01:01, 12.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return abs(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return abs(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(S1*sqrt(S2/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1*_a0_)**_a0_/(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 47%|████▋ | 707/1500 [00:48<01:00, 13.21it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + " 47%|████▋ | 709/1500 [00:48<01:00, 13.16it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(S2*_a0_/S1))/S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2**2))\n", + " 47%|████▋ | 711/1500 [00:48<00:57, 13.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)**_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S1)))**_a0_\n", + " 48%|████▊ | 713/1500 [00:49<00:58, 13.45it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + _a0_**S2))))))\n", + " 48%|████▊ | 715/1500 [00:49<00:58, 13.37it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((2*S1 + relu(S2))**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_/S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_/S1)/S1)\n", + " 48%|████▊ | 717/1500 [00:49<00:56, 13.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(tan(S1)))/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S2**S1))**_a0_\n", + " 48%|████▊ | 719/1500 [00:49<01:02, 12.56it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (1/2)*sqrt(S2*_a0_)/_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 48%|████▊ | 721/1500 [00:49<01:02, 12.40it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + " 48%|████▊ | 723/1500 [00:49<00:58, 13.38it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1/_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1/_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(relu(S1/_a0_))**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/S1)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(relu(sinh(S1**S2))**_a0_))\n", + " 48%|████▊ | 725/1500 [00:49<00:56, 13.83it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(fac(_a0_)))\n", + " 48%|████▊ | 727/1500 [00:50<00:55, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*tan(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*tan(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + " 49%|████▊ | 729/1500 [00:50<01:02, 12.40it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(log(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(log(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(log(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 49%|████▊ | 731/1500 [00:50<01:04, 11.85it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + " 49%|████▉ | 733/1500 [00:50<01:01, 12.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(sin(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(_a0_))**_a0_)\n", + " 49%|████▉ | 735/1500 [00:50<00:59, 12.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S1) + _a0_)**(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(relu(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S1**S1)))\n", + " 49%|████▉ | 737/1500 [00:50<00:58, 13.02it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(relu(S1))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(_a0_)/_a0_)*exp(-S1)\n", + " 49%|████▉ | 739/1500 [00:51<01:01, 12.37it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1/_a0_)**_a0_\n", + " 49%|████▉ | 741/1500 [00:51<01:27, 8.70it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + " 50%|████▉ | 743/1500 [00:51<01:15, 10.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/sin(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/sin(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(-S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(-S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(-S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + " 50%|████▉ | 745/1500 [00:51<01:08, 11.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2*_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2*_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(relu(tan(_a0_)))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S1)))\n", + " 50%|████▉ | 747/1500 [00:51<01:05, 11.56it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(tan(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(tan(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(tan(S2)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + " 50%|████▉ | 749/1500 [00:52<01:00, 12.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*cos(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*cos(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", + " 50%|█████ | 751/1500 [00:52<01:01, 12.11it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*_a0_**S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*_a0_**S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S1))**_a0_\n", + " 50%|█████ | 753/1500 [00:52<00:57, 12.90it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + " 50%|█████ | 755/1500 [00:52<00:55, 13.37it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + " 50%|█████ | 757/1500 [00:52<00:55, 13.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(_a0_)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + S2**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S2 + S2**S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(sin(S1)))**_a0_\n", + " 51%|█████ | 759/1500 [00:52<00:54, 13.62it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)*exp(-S2 - _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(sin(S2)))\n", + " 51%|█████ | 761/1500 [00:52<00:55, 13.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_**3*relu(S2)**3/relu(S1)**3)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_**3*relu(S2)**3/relu(S1)**3)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*cos(S2))*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2 + _a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(cos(S1)))\n", + " 51%|█████ | 763/1500 [00:53<00:54, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((-sinh(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((-sinh(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((-sinh(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**3*_a0_/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return relu(exp(_a0_/relu(_a0_))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return relu(exp(_a0_/relu(_a0_))/S1)\n", + " 51%|█████ | 765/1500 [00:53<00:52, 14.13it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2*_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sin(_a0_)**(-_a0_)\n", + " 51%|█████ | 767/1500 [00:53<00:51, 14.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(_a0_**relu(S1))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(_a0_**relu(S1))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*relu(S2)/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/(S2 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (sqrt(S1) + _a0_**_a0_)/(sqrt(S1)*relu(S1))\n", + " 51%|█████▏ | 769/1500 [00:53<00:51, 14.11it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(sinh(S1))**_a0_\n", + " 51%|█████▏ | 771/1500 [00:53<00:54, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(_a0_*relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(sinh(S1))**(sqrt(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_/S1))\n", + " 52%|█████▏ | 773/1500 [00:53<00:53, 13.64it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(S2/_a0_)/relu(S1))\n", + " 52%|█████▏ | 775/1500 [00:53<00:52, 13.76it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(_a0_**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + " 52%|█████▏ | 777/1500 [00:54<00:50, 14.24it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S1**S2 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(S1**S2 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + " 52%|█████▏ | 779/1500 [00:54<00:54, 13.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(relu(S1)*sqrt(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sinh(log(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(_a0_**relu(S1))/S1)\n", + " 52%|█████▏ | 781/1500 [00:54<00:52, 13.64it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*_a0_**(-S1)*relu(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(_a0_**relu(S1))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(_a0_*relu(S2))**relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S1))**(S2**S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S2)))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cosh(S2)/relu(S1))/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cosh(S2)/relu(S1))/S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(cosh(S2)/relu(S1))/S1)\n", + " 52%|█████▏ | 783/1500 [00:54<00:51, 14.03it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_*exp(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(S1))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(S1))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(S1))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + " 52%|█████▏ | 785/1500 [00:54<00:49, 14.49it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*log(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*log(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*log(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-exp(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S1/_a0_))**_a0_\n", + " 52%|█████▏ | 787/1500 [00:54<00:50, 14.17it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S1/(S2*_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(relu(_a0_)))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S1**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S1**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(S1**S2))**_a0_\n", + " 53%|█████▎ | 789/1500 [00:54<00:51, 13.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(fac(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(abs(S1 + exp(_a0_*(S2 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + " 53%|█████▎ | 791/1500 [00:55<00:53, 13.14it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(log(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(log(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(log(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(-_a0_*relu(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*(_a0_ + _a0_**_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**(-_a0_)\n", + " 53%|█████▎ | 793/1500 [00:55<00:53, 13.18it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(S2 + _a0_)*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + " 53%|█████▎ | 795/1500 [00:55<00:51, 13.74it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S1))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_*log(-_a0_*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sinh(_a0_))**_a0_\n", + " 53%|█████▎ | 797/1500 [00:55<00:51, 13.75it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(-S2)*(sqrt(S1) + _a0_)/relu(S1)\n", + " 53%|█████▎ | 799/1500 [00:55<00:47, 14.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2**_a0_*_a0_/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(_a0_*(S2 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(_a0_*(S2 + _a0_))))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-S2**2))/relu(S1))\n", + " 53%|█████▎ | 801/1500 [00:55<00:48, 14.48it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu(sinh(S1))**(_a0_**S2)))\n", + " 54%|█████▎ | 803/1500 [00:55<00:47, 14.74it/s]:2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return relu(exp(_a0_/relu(_a0_))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + " 54%|█████▎ | 805/1500 [00:56<00:45, 15.14it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1**2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + " 54%|█████▍ | 807/1500 [00:56<00:47, 14.72it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1/_a0_)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(sinh(S1))**_a0_\n", + " 54%|█████▍ | 809/1500 [00:56<00:49, 14.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(-(_a0_*relu(S2))**relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + " 54%|█████▍ | 811/1500 [00:56<00:47, 14.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(exp(_a0_**relu(S1))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(S1))\n", + " 54%|█████▍ | 813/1500 [00:56<00:45, 15.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(-sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + " 54%|█████▍ | 815/1500 [00:56<00:46, 14.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)*cos(S1)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 54%|█████▍ | 817/1500 [00:56<00:44, 15.26it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(-_a0_*relu(S2)/relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(tan(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(exp(_a0_/relu(S1))/log(_a0_))\n", + " 55%|█████▍ | 819/1500 [00:56<00:45, 15.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(sin(S2)))/(sqrt(S1)*relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-(_a0_ + relu(S2))/relu(relu(S1)))\n", + " 55%|█████▍ | 821/1500 [00:57<00:46, 14.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S1) + _a0_)/(sqrt(S1)*relu(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2*relu(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + " 55%|█████▍ | 823/1500 [00:57<00:47, 14.21it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(exp(_a0_/relu(S1))/sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**(-_a0_)*exp(_a0_/relu(S1)))\n", + " 55%|█████▌ | 825/1500 [00:57<00:47, 14.24it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_**3))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_**3))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S1) + _a0_)**(sqrt(S1)*relu(cosh(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(_a0_/relu(S2 + _a0_))/S1)\n", + " 55%|█████▌ | 827/1500 [00:57<00:47, 14.05it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/cos(S1))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2*_a0_))/cos(S1))**sig(relu(S1))\n", + " 55%|█████▌ | 829/1500 [00:57<00:46, 14.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_**2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2/_a0_))**_a0_\n", + " 55%|█████▌ | 831/1500 [00:57<00:47, 14.20it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S2)/relu(S1**3)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sqrt(_a0_**_a0_/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S1**3)/relu(relu(S1))))\n", + " 56%|█████▌ | 833/1500 [00:57<00:47, 14.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + " 56%|█████▌ | 837/1500 [00:58<00:45, 14.70it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)**_a0_\n", + " 56%|█████▌ | 839/1500 [00:58<00:44, 14.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(S1))))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)**2/relu(relu(S1))))\n", + " 56%|█████▌ | 841/1500 [00:58<00:43, 15.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp((S2 + _a0_)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp((S2 + _a0_)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*exp(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sqrt(S2/_a0_)*exp(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + " 56%|█████▌ | 843/1500 [00:58<00:45, 14.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*abs(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_**S1))**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + " 56%|█████▋ | 845/1500 [00:58<00:46, 13.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return (relu(relu(S2*_a0_))/relu(_a0_))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sinh(_a0_))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + " 56%|█████▋ | 847/1500 [00:58<00:47, 13.89it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S1*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**(-_a0_)\n", + " 57%|█████▋ | 849/1500 [00:59<00:48, 13.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(cos(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (sqrt(S2) + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(_a0_/relu(_a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(_a0_/relu(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + " 57%|█████▋ | 851/1500 [00:59<00:49, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2*_a0_))/S1)**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2*_a0_))/S1)**sig(relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**3))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(S2 + _a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + " 57%|█████▋ | 853/1500 [00:59<00:48, 13.47it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S2))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + " 57%|█████▋ | 855/1500 [00:59<00:48, 13.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_ + relu(log(-_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return _a0_ + relu(log(-_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return S1**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*sig(sig(S1))**(_a0_*_a0_**S2)\n", + " 57%|█████▋ | 857/1500 [00:59<00:47, 13.56it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1/_a0_)**_a0_)\n", + " 57%|█████▋ | 859/1500 [00:59<00:46, 13.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(tan(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(tan(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + " 57%|█████▋ | 861/1500 [00:59<00:45, 14.02it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(_a0_**S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_**_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(exp(_a0_))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(exp(_a0_))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 58%|█████▊ | 863/1500 [01:00<00:44, 14.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(cos(S1 + exp(_a0_*(S2 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(cos(S1 + exp(_a0_*(S2 + _a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(S1/_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(_a0_/relu(_a0_))/S1\n", + " 58%|█████▊ | 865/1500 [01:00<00:43, 14.47it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sig(sqrt(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2))**_a0_\n", + " 58%|█████▊ | 867/1500 [01:00<00:45, 14.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + " 58%|█████▊ | 869/1500 [01:00<00:44, 14.18it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2*_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(S2)))/relu(S1))\n", + " 58%|█████▊ | 871/1500 [01:00<00:42, 14.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S1**S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 58%|█████▊ | 873/1500 [01:00<00:43, 14.42it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*exp(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + " 58%|█████▊ | 875/1500 [01:00<00:43, 14.40it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S2**2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(log(_a0_)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1 + _a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + " 58%|█████▊ | 877/1500 [01:01<00:43, 14.21it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tan(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tan(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tan(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(tan(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sin(S1))**_a0_\n", + " 59%|█████▊ | 879/1500 [01:01<00:44, 13.88it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_**2)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_**2)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_**2)*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 59%|█████▊ | 881/1500 [01:01<00:45, 13.55it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(_a0_*exp(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + " 59%|█████▉ | 883/1500 [01:01<00:45, 13.47it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + " 59%|█████▉ | 885/1500 [01:01<00:45, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + " 59%|█████▉ | 887/1500 [01:01<00:45, 13.49it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(tan(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(tan(S2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(tan(S2))**_a0_)\n", + " 59%|█████▉ | 889/1500 [01:01<00:43, 14.10it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(log(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(log(S1))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/(S2 + _a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + " 59%|█████▉ | 891/1500 [01:02<00:45, 13.49it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(S1/_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(cos(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tan(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tan(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tan(_a0_))**_a0_\n", + " 60%|█████▉ | 893/1500 [01:02<00:45, 13.28it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 60%|█████▉ | 895/1500 [01:02<00:44, 13.50it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(S2 + _a0_))**_a0_\n", + " 60%|█████▉ | 897/1500 [01:02<00:43, 13.73it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/_a0_**2\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(_a0_/S1)**_a0_))\n", + " 60%|█████▉ | 899/1500 [01:02<00:43, 13.83it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(2*S1)/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + " 60%|██████ | 901/1500 [01:02<00:44, 13.58it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + " 60%|██████ | 903/1500 [01:03<00:43, 13.65it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_/S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**_a0_/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((3*S1 + S2)**(S2**S1)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 60%|██████ | 905/1500 [01:03<00:42, 13.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2/_a0_))/S1)**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2/_a0_))/S1)**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tanh(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tanh(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/sinh(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S2))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**(sqrt(S2))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + " 60%|██████ | 907/1500 [01:03<00:41, 14.16it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**3*_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + " 61%|██████ | 909/1500 [01:03<00:42, 13.96it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(tan(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(S1*_a0_))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + " 61%|██████ | 911/1500 [01:03<00:44, 13.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S2**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tanh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(S2**2/_a0_)))))\n", + " 61%|██████ | 913/1500 [01:03<00:43, 13.51it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**_a0_*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(_a0_**S1 + exp(S2**2/_a0_)))))\n", + " 61%|██████ | 915/1500 [01:03<00:44, 13.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sin(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(_a0_) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + " 61%|██████ | 917/1500 [01:04<00:43, 13.26it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S1*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2*relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(fac(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(sinh(S1))**_a0_\n", + " 61%|██████▏ | 919/1500 [01:04<00:46, 12.38it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(relu(S1 + exp(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(relu(S2))/(S1 + _a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**cosh(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 61%|██████▏ | 921/1500 [01:04<00:45, 12.86it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*log(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*log(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(relu(sig(_a0_))**S1*log(_a0_)))\n", + " 62%|██████▏ | 923/1500 [01:04<00:43, 13.36it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(S2 + _a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_/S1)*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2**2))/relu(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**3/S2**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**3/S2**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**3/S2**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + " 62%|██████▏ | 925/1500 [01:04<00:44, 13.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*log(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + " 62%|██████▏ | 927/1500 [01:04<00:42, 13.36it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2/S1**3)))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**S1)**3)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2))\n", + " 62%|██████▏ | 929/1500 [01:05<00:45, 12.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(sig(S2**(cosh(S2)**2)))**(S1*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(-_a0_*relu(sin(S1))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + " 62%|██████▏ | 931/1500 [01:05<00:43, 12.95it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(_a0_*relu(S2))**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(_a0_*relu(S2))**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return cos(sqrt(S2*_a0_)*exp(-S1))\n", + " 62%|██████▏ | 933/1500 [01:05<00:41, 13.63it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (sinh(S1)**2)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (sinh(S1)**2)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (sinh(S1)**2)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**3)**sinh(S1)))\n", + " 62%|██████▏ | 935/1500 [01:05<01:01, 9.25it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(fac(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(fac(_a0_*relu(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**(-_a0_)*S2**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/(S1 + _a0_)\n", + " 62%|██████▏ | 937/1500 [01:05<00:56, 9.94it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-S2*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return (sinh(S2**S2)**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2))/relu(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(relu(S2))/relu(S1*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*log(S1)))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(abs(S1 + exp(S2**2/_a0_)))))\n", + " 63%|██████▎ | 939/1500 [01:06<00:54, 10.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sin(log(S2**2))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sin(log(S2**2))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(((S1 + _a0_)**3)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*relu(S2)*relu(relu(S1))))\n", + " 63%|██████▎ | 941/1500 [01:06<00:50, 11.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*sig(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(relu(S2))/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-_a0_/relu(sin(_a0_)))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(-S2)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + " 63%|██████▎ | 943/1500 [01:06<00:49, 11.16it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2**2))/(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(cos(S1 + exp(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(cos(S1 + exp(S2**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return (log(_a0_)**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return (log(_a0_)**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return (log(_a0_)**2)**_a0_\n", + " 63%|██████▎ | 945/1500 [01:06<00:47, 11.72it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)*tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(_a0_)/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(_a0_)/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(_a0_)/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*relu(S2)/relu(relu(S1))))\n", + " 63%|██████▎ | 947/1500 [01:06<00:46, 12.00it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-_a0_*relu(S2)/relu(S2/_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S1**_a0_/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S1**_a0_/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-relu(S2)/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (_a0_ + sqrt(tan(S1)))/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 63%|██████▎ | 949/1500 [01:06<00:45, 12.20it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(_a0_**_a0_)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + " 63%|██████▎ | 951/1500 [01:06<00:43, 12.65it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(sqrt(_a0_)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/fac(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-relu(S2)/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(relu(S1))/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(log(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(log(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + " 64%|██████▎ | 953/1500 [01:07<00:41, 13.30it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S1)))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1 + S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(_a0_ + relu(S2))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(_a0_ + relu(S2))/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + " 64%|██████▎ | 955/1500 [01:07<00:40, 13.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sqrt(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sqrt(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S2**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S1)**_a0_)\n", + " 64%|██████▍ | 957/1500 [01:07<00:41, 13.12it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(relu(relu(S2*_a0_))/relu(S1 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(-_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu((sinh(S1)**2)**log(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(relu(S2))/relu(2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(relu(S2))/relu(2*_a0_)))\n", + " 64%|██████▍ | 959/1500 [01:07<00:41, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-relu(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 64%|██████▍ | 961/1500 [01:07<00:42, 12.58it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(relu(S2))/relu(S1 + log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S1**2)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S1**2)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S1**2)**(S2**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(relu(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(S1 + _a0_))**sig(relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1 + _a0_)**_a0_)\n", + " 64%|██████▍ | 963/1500 [01:07<00:43, 12.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2**2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2**2))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S2)*relu(S2)**2)))))\n", + " 64%|██████▍ | 965/1500 [01:08<00:43, 12.39it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(tan(S1 + exp(relu(S2)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return ((sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(fac(S1)))))**S2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + " 64%|██████▍ | 967/1500 [01:08<00:41, 12.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(_a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-_a0_/relu(log(S1)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-_a0_/relu(log(S1)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-_a0_/relu(log(S1)))/S1\n", + " 65%|██████▍ | 969/1500 [01:08<00:43, 12.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S2*tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sqrt(S2) + _a0_)/(relu(cosh(fac(S1)))*sqrt(tanh(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(S2*relu(sig(_a0_**_a0_))**S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**2/_a0_**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**2/_a0_**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**2/_a0_**2)**_a0_\n", + " 65%|██████▍ | 971/1500 [01:08<00:44, 11.83it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(S2)/relu(log(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(S2)/relu(log(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(relu(S2)/relu(log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*log(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*log(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tanh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(tanh(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(2*_a0_)**_a0_)\n", + " 65%|██████▍ | 973/1500 [01:08<00:42, 12.34it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_ + _a0_**S1)/(sqrt(S1)*relu(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2/_a0_)/sqrt(S1*tan(S2)))\n", + " 65%|██████▌ | 975/1500 [01:08<00:39, 13.17it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(sinh(S1)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(sinh(S1)**2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(sinh(S1)**2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2*_a0_)**_a0_)\n", + " 65%|██████▌ | 977/1500 [01:08<00:40, 12.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S2**S2)\n", + " 65%|██████▌ | 979/1500 [01:09<00:44, 11.65it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*(S2 + _a0_)))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(S2**S2)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(S2**S2)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*sinh(cosh(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*sinh(cosh(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1**2)**_a0_\n", + " 66%|██████▌ | 983/1500 [01:09<00:41, 12.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*tan(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(_a0_)/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(_a0_)/relu(S1))/S1\n", + " 66%|██████▌ | 985/1500 [01:09<00:40, 12.60it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S2))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S2))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S1))\n", + " 66%|██████▌ | 987/1500 [01:09<00:46, 11.11it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return (sqrt(S2) + _a0_)/(sqrt(S1)*relu(cosh(S1**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(_a0_)/relu(S1))/S1\n", + " 66%|██████▌ | 989/1500 [01:10<00:44, 11.41it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(S1)/relu(relu(S1))))\n", + " 66%|██████▌ | 991/1500 [01:10<00:43, 11.69it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/relu(S1))\n", + " 66%|██████▌ | 993/1500 [01:10<00:42, 12.06it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", + " 66%|██████▋ | 995/1500 [01:10<00:40, 12.54it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-log(S2*relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-log(S2*relu(S2))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)\n", + " 67%|██████▋ | 999/1500 [01:10<00:42, 11.81it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(S2*_a0_))**sig(relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cos(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cos(fac(S1))))\n", + " 67%|██████▋ | 1001/1500 [01:11<00:42, 11.84it/s]:2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(sinh(S2)))))\n", + " 67%|██████▋ | 1003/1500 [01:11<00:41, 12.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + " 67%|██████▋ | 1005/1500 [01:11<00:40, 12.25it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(cos(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(cos(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(cos(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sin(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sin(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + " 67%|██████▋ | 1007/1500 [01:11<00:39, 12.48it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(relu(_a0_)))/S1\n", + " 67%|██████▋ | 1009/1500 [01:11<00:37, 13.25it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1 + _a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*S2**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", + ":2: RuntimeWarning: overflow encountered in cosh\n", + " return sqrt(S2)*_a0_/(sqrt(S1)*relu(cosh(fac(S1**2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-sinh(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + " 67%|██████▋ | 1011/1500 [01:11<00:38, 12.68it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(sin(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(S2**_a0_/(S1 - S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(S2**_a0_/(S1 - S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(S2**_a0_/(S1 - S2))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(tan(S2))))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tan(_a0_)**_a0_\n", + " 68%|██████▊ | 1013/1500 [01:11<00:37, 13.09it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(exp(_a0_)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**((S1 + S2)**3)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**((S1 + S2)**3)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**((S1 + S2)**3)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((2*_a0_)**_a0_)\n", + " 68%|██████▊ | 1015/1500 [01:12<00:36, 13.17it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return S1**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1 + _a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + " 68%|██████▊ | 1017/1500 [01:12<00:37, 12.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + " 68%|██████▊ | 1019/1500 [01:12<00:39, 12.14it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(S1/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(S1**2)**2)**(_a0_**_a0_)))\n", + " 68%|██████▊ | 1021/1500 [01:12<00:37, 12.83it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**(2*S1))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(relu(log(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**(2*S2))**2)**_a0_))\n", + " 68%|██████▊ | 1023/1500 [01:12<00:36, 12.96it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(relu(S2/_a0_)/sqrt(S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_**S2)**_a0_)\n", + " 68%|██████▊ | 1025/1500 [01:12<00:38, 12.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(log(S2)))**sig(relu(S1))\n", + " 68%|██████▊ | 1027/1500 [01:13<00:40, 11.60it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S1**S1)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/S1\n", + " 69%|██████▊ | 1029/1500 [01:13<00:39, 11.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(S2*relu(-S2)))/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + " 69%|██████▊ | 1031/1500 [01:13<00:40, 11.59it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 69%|██████▉ | 1033/1500 [01:13<00:38, 12.03it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(tan(S1 + exp(_a0_*relu(S2)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + " 69%|██████▉ | 1035/1500 [01:13<00:43, 10.62it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(cos(S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(cos(S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(cos(S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 69%|██████▉ | 1037/1500 [01:14<00:43, 10.72it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(exp(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(exp(S2)))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(sin(S2)))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sqrt(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + " 69%|██████▉ | 1039/1500 [01:14<00:41, 11.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S1*_a0_)))))\n", + " 69%|██████▉ | 1041/1500 [01:14<00:43, 10.67it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return tanh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S1/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + " 70%|██████▉ | 1043/1500 [01:14<00:40, 11.33it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/(_a0_*relu(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/relu(S1))/S1\n", + " 70%|██████▉ | 1045/1500 [01:14<00:37, 12.29it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S2*cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tanh(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(sinh(S1**2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(sinh(S1**2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-sin(S2)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_))))\n", + " 70%|██████▉ | 1047/1500 [01:14<00:36, 12.35it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1**2)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + " 70%|██████▉ | 1049/1500 [01:14<00:34, 13.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/(S1*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2/(S1*relu(relu(S1))))))\n", + " 70%|███████ | 1051/1500 [01:15<00:35, 12.77it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((-S1**4)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((-S1**4)**_a0_))\n", + " 70%|███████ | 1053/1500 [01:15<00:34, 13.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/_a0_))/relu(_a0_**S2))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return (relu(relu(S2/_a0_))/relu(_a0_**S2))**sig(S1)\n", + " 70%|███████ | 1055/1500 [01:15<00:37, 11.73it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(tan(S1 + exp(_a0_*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + " 70%|███████ | 1057/1500 [01:15<00:37, 11.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2*exp(-S1)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S2 + sqrt(S2*_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 71%|███████ | 1059/1500 [01:15<00:36, 11.94it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_/S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2*relu(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**3)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**3)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**3)))\n", + " 71%|███████ | 1061/1500 [01:15<00:35, 12.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S1**_a0_/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(sinh(S2)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(sinh(S2)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(sinh(S2)**2)**_a0_)\n", + " 71%|███████ | 1063/1500 [01:16<00:35, 12.40it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(fac(_a0_))**2)**_a0_))\n", + " 71%|███████ | 1065/1500 [01:16<00:35, 12.12it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/(S2*_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S1)\n", + " 71%|███████ | 1067/1500 [01:16<00:39, 10.85it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(-S2)*sqrt(S2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**cosh(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**cosh(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**cosh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1*_a0_)**_a0_)\n", + " 71%|███████▏ | 1069/1500 [01:16<00:37, 11.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + " 71%|███████▏ | 1071/1500 [01:16<00:35, 12.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2**_a0_/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S2**_a0_/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(sig(log(S2*relu(S2)))/relu(-S1))\n", + " 72%|███████▏ | 1073/1500 [01:16<00:34, 12.53it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(log(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return S1**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-S1**3/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (1/2)*sqrt(S2*_a0_)/S1\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((relu(_a0_)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((relu(_a0_)**2)**_a0_))\n", + " 72%|███████▏ | 1075/1500 [01:17<00:32, 12.99it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S2**2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S2**2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(S2*_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + " 72%|███████▏ | 1077/1500 [01:17<00:33, 12.61it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(relu(log(relu(S2/(_a0_*relu(relu(S1)))))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(relu(log(relu(S2/(_a0_*relu(relu(S1)))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(sqrt(_a0_)*relu(sig(_a0_))**S1))\n", + " 72%|███████▏ | 1079/1500 [01:17<00:33, 12.43it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(log(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**3))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**3))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1**2)**(S2**3))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(S1 + _a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tan(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(tan(_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + " 72%|███████▏ | 1081/1500 [01:17<00:33, 12.62it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(cosh(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(cosh(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(cosh(S1)**2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(log(-S2*_a0_**(-_a0_)/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*cos(S1))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*cos(S1))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*cos(S1))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/relu(S1))/S1\n", + " 72%|███████▏ | 1083/1500 [01:17<00:32, 12.69it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(-S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(-S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(-S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-1/(S2*relu(relu(S1))))))\n", + " 72%|███████▏ | 1085/1500 [01:17<00:31, 13.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(relu(_a0_**S1))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(relu(S1))**_a0_))\n", + " 72%|███████▏ | 1087/1500 [01:18<00:46, 8.91it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(2*S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(2*S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(-(S2/_a0_)**relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(log(-(S2/_a0_)**relu(relu(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return (sin((3*S1 + S2)**_a0_) + sinh(S1))*exp(-S1/_a0_)\n", + " 73%|███████▎ | 1089/1500 [01:18<00:42, 9.65it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/(S1 + _a0_))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2*relu(S2)))/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(log(S2*relu(S2)))/S1)\n", + " 73%|███████▎ | 1091/1500 [01:18<00:37, 10.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-1/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(-1/relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((-sinh(_a0_**2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((-sinh(_a0_**2))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((-sinh(_a0_**2))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S1)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return sqrt(S2)*_a0_/(relu(abs(_a0_))*sqrt(tanh(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2**2/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_\n", + " 73%|███████▎ | 1093/1500 [01:18<00:35, 11.53it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(log(-S2/(_a0_*relu(_a0_/S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/S2**2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (sin((3*S1 + S2)**_a0_) + 1/sqrt(_a0_))*exp(-S1/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-sqrt(_a0_)/relu(S1))/S1\n", + " 73%|███████▎ | 1095/1500 [01:18<00:33, 12.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(relu(S1)))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2*relu(S2)))/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**sin(_a0_)\n", + " 73%|███████▎ | 1097/1500 [01:19<00:33, 11.92it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(S2/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(S2/S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2*relu(S2)))/tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2*relu(S2)))/tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + " 73%|███████▎ | 1099/1500 [01:19<00:32, 12.28it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S2 + _a0_))/S1\n", + " 73%|███████▎ | 1101/1500 [01:19<00:32, 12.40it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1/_a0_)*sin((3*S1 + S2)**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1/_a0_)*sin((3*S1 + S2)**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(tanh(_a0_))**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(-S2*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**sin(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**sin(_a0_)\n", + " 74%|███████▎ | 1103/1500 [01:19<00:31, 12.52it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S2/S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S1/relu(_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**_a0_))))))\n", + " 74%|███████▎ | 1105/1500 [01:19<00:30, 13.06it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-exp(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-exp(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-exp(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_**(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**sin(_a0_)\n", + " 74%|███████▍ | 1107/1500 [01:19<00:29, 13.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(S2**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S2)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S2)**_a0_/(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S1)**_a0_)\n", + " 74%|███████▍ | 1109/1500 [01:19<00:28, 13.55it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sinh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sinh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sinh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(_a0_*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(exp(cos(S1 + sqrt(_a0_*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(S2/_a0_)/sqrt(S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((relu(S1)**2)**(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((relu(S1)**2)**(S1**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((relu(S1)**2)**(S1**S2)))\n", + " 74%|███████▍ | 1111/1500 [01:20<00:29, 12.99it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(-S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(-S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**sin(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2*relu(S2)))/log(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2*relu(S2)))/log(S1)))\n", + " 74%|███████▍ | 1113/1500 [01:20<00:28, 13.50it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(S1/_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(relu(S2/_a0_)/sqrt(S1*S2)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(_a0_*exp(relu(S2))) + log(_a0_)))))\n", + " 74%|███████▍ | 1115/1500 [01:20<00:28, 13.33it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(sqrt(sig(log(relu(S2)*log(_a0_)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + " 74%|███████▍ | 1117/1500 [01:20<00:28, 13.50it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + " 75%|███████▍ | 1119/1500 [01:20<00:28, 13.49it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(S1)**log(_a0_)\n", + " 75%|███████▍ | 1121/1500 [01:20<00:28, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S2*(S2 + _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(2*_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sin(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sin(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(sin(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 75%|███████▍ | 1123/1500 [01:21<00:28, 13.08it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(relu(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + " 75%|███████▌ | 1125/1500 [01:21<00:28, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2/relu(2*_a0_)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(relu(S2/relu(2*_a0_)))/S1)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/tan(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/tan(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/tan(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(_a0_**S2))))))\n", + " 75%|███████▌ | 1127/1500 [01:21<00:28, 13.09it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(log(_a0_))/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(log(_a0_))/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(log(_a0_))/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/log(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/log(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/log(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1*_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + " 75%|███████▌ | 1129/1500 [01:21<00:28, 13.18it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(relu(S2)*cos(S2)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(_a0_**S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log((S2 + _a0_)/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(2*_a0_)))/S2)**sig(S1)\n", + " 75%|███████▌ | 1131/1500 [01:21<00:27, 13.37it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(sin(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(sin(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2*relu(S2)))/(S2 + _a0_)))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1)*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((relu(fac(_a0_))**2)**_a0_))\n", + " 76%|███████▌ | 1133/1500 [01:21<00:28, 13.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**(-_a0_)*sig(_a0_))/S1\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(S2 + _a0_)**2)**_a0_))\n", + " 76%|███████▌ | 1135/1500 [01:21<00:28, 13.01it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S2)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*log(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(tanh(log(S2*relu(S2)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(tanh(log(S2*relu(S2)))/relu(S1)))\n", + " 76%|███████▌ | 1137/1500 [01:22<00:29, 12.45it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S1/relu(2*_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_/(relu(log(fac(S1)))*sqrt(tanh(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_/(relu(log(fac(S1)))*sqrt(tanh(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 76%|███████▌ | 1139/1500 [01:22<00:29, 12.06it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(2*_a0_)))/relu(sinh(S2)))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return S1**(-_a0_**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(2*_a0_)))/relu(S2))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(cos(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(-_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((2*_a0_)**_a0_))\n", + " 76%|███████▌ | 1141/1500 [01:22<00:30, 11.89it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(tan(relu(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(S1*cos(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sqrt(log(S2**2))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sqrt(log(S2**2))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((relu(_a0_/S2)**2)**_a0_))\n", + " 76%|███████▌ | 1143/1500 [01:22<00:28, 12.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_/S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + " 76%|███████▋ | 1145/1500 [01:22<00:28, 12.51it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(log(S1))**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(S2)))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1))/relu(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(relu(abs(fac(S1)))*sqrt(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return S1**log(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + " 76%|███████▋ | 1147/1500 [01:22<00:27, 12.95it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt((S1 + _a0_)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(S1**S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**3)**(-_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 77%|███████▋ | 1149/1500 [01:23<00:26, 13.06it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(S1**S2)))))))\n", + " 77%|███████▋ | 1151/1500 [01:23<00:28, 12.25it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/relu(S1))/S1\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-abs(_a0_)/relu(relu(S1))))\n", + " 77%|███████▋ | 1153/1500 [01:23<00:29, 11.84it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(exp(relu(relu(S2)))*abs(S1))))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**_a0_\n", + " 77%|███████▋ | 1155/1500 [01:23<00:28, 12.01it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(-S1)*relu(abs(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + " 77%|███████▋ | 1157/1500 [01:23<00:27, 12.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(sig(log(S2**2))/relu(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(S1 + _a0_)))\n", + " 77%|███████▋ | 1159/1500 [01:23<00:28, 12.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_*relu(log(-S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(log(S2)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/relu(S1*_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + " 77%|███████▋ | 1161/1500 [01:24<00:28, 11.94it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2**3/(_a0_**3*relu(relu(S1))**3)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2**3/(_a0_**3*relu(relu(S1))**3)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*cosh(relu(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S1))**(S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2**2))/sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(sig(log(S2**2))/sin(S1)))\n", + " 78%|███████▊ | 1163/1500 [01:24<00:27, 12.08it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(relu(2*S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(relu(2*S2))))))))\n", + " 78%|███████▊ | 1165/1500 [01:24<00:26, 12.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sinh(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sinh(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 78%|███████▊ | 1167/1500 [01:24<00:25, 12.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(sinh(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(relu(sinh(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S1)**_a0_\n", + " 78%|███████▊ | 1171/1500 [01:24<00:24, 13.37it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(tan(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S2))**sig(S1)\n", + " 78%|███████▊ | 1173/1500 [01:24<00:24, 13.15it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(exp(S1)))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(sig(log(S2*(S2 + _a0_)))/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + " 78%|███████▊ | 1175/1500 [01:25<00:24, 13.31it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-fac(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-fac(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-fac(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S2 + _a0_))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(sinh(S2**S2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(sinh(S2**S2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu(sinh(S2**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return S1**(sqrt(_a0_))\n", + " 78%|███████▊ | 1177/1500 [01:25<00:24, 13.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", + " 79%|███████▊ | 1179/1500 [01:25<00:24, 13.10it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_**3)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*tan(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 79%|███████▊ | 1181/1500 [01:25<00:23, 13.34it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(S2**S1*exp(relu(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(log(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(log(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu((sinh(S1)**2)**(S1**S1)))\n", + " 79%|███████▉ | 1183/1500 [01:25<00:23, 13.41it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return _a0_*sqrt(log(_a0_))/(sqrt(tanh(S1))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S2*_a0_))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-log(_a0_)/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-log(_a0_)/S1)/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + sin(S1) + tan(S2))**_a0_))*exp(-S1)\n", + " 79%|███████▉ | 1185/1500 [01:25<00:24, 13.07it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(cos(S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(relu(cos(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(cosh(relu(S2))))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*exp(cosh(relu(S2))))))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(sin(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(sin(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(sin(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar divide\n", + " return exp(-sig(_a0_)/relu(_a0_))/relu(S1)\n", + " 79%|███████▉ | 1187/1500 [01:26<00:24, 12.92it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(cos(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**(2*_a0_))**_a0_))\n", + " 79%|███████▉ | 1189/1500 [01:26<00:23, 13.42it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*relu(cosh(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(cos(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(cos(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sinh(cos(S1))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(_a0_**_a0_)**2)**_a0_))\n", + " 79%|███████▉ | 1191/1500 [01:26<00:24, 12.72it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", + " 80%|███████▉ | 1193/1500 [01:26<00:23, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)))/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + log(S1))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + log(S1))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S1**S1)**2)**_a0_))\n", + " 80%|███████▉ | 1195/1500 [01:26<00:25, 12.11it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(-S1)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_))**_a0_\n", + " 80%|███████▉ | 1199/1500 [01:26<00:22, 13.14it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_/(sqrt(tanh(log(S1)))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(cos(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + " 80%|████████ | 1201/1500 [01:27<00:22, 13.29it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_/(sqrt(tanh(S1))*abs(relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in divide\n", + " return sqrt(S2)*_a0_/(sqrt(tanh(S1))*abs(relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S2 + _a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 80%|████████ | 1203/1500 [01:27<00:23, 12.43it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**(2*S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + " 80%|████████ | 1205/1500 [01:27<00:24, 11.95it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu((sinh(sqrt(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S2)**relu(S1)))\n", + " 80%|████████ | 1207/1500 [01:27<00:24, 11.93it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-relu(S1))/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((S1/_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-cosh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(tan(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + " 81%|████████ | 1209/1500 [01:27<00:23, 12.14it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2*cosh(S2))))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 81%|████████ | 1211/1500 [01:28<00:24, 11.80it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(cos(S1))/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(-_a0_)*exp(-sig(_a0_)/S1)\n", + " 81%|████████ | 1213/1500 [01:28<00:24, 11.78it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(cos(S2))))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((_a0_**_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_/S1**2)/relu(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(tan(S1)))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2*_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(relu(S2/_a0_)/sqrt(-S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(_a0_))**_a0_\n", + " 81%|████████ | 1215/1500 [01:28<00:24, 11.87it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S1)**_a0_\n", + " 81%|████████ | 1217/1500 [01:28<00:23, 12.04it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*_a0_*relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/(S2*_a0_))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + " 81%|████████▏ | 1219/1500 [01:28<00:23, 12.10it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(-S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(S1)**_a0_))\n", + " 81%|████████▏ | 1221/1500 [01:28<00:23, 12.10it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(S1)**(_a0_**_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sinh(log(S1)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1))**(S1**S2)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", + " 82%|████████▏ | 1223/1500 [01:28<00:22, 12.22it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + " 82%|████████▏ | 1225/1500 [01:29<00:22, 11.98it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(tan(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(tan(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(tan(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + " 82%|████████▏ | 1227/1500 [01:29<00:25, 10.69it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return -log(-S2*_a0_/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S1*S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(_a0_)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(sin(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(sin(_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(sinh(sin(_a0_))**_a0_))\n", + " 82%|████████▏ | 1229/1500 [01:29<00:24, 11.07it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(S1)**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(S1)**(sqrt(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + " 82%|████████▏ | 1231/1500 [01:29<00:23, 11.30it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2/_a0_))**2)**_a0_))\n", + " 82%|████████▏ | 1233/1500 [01:29<00:24, 11.08it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S1*_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S1/_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return _a0_*relu(log(-S2*_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((_a0_**S2)**_a0_))\n", + " 82%|████████▏ | 1235/1500 [01:30<00:22, 11.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S1**S1/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 82%|████████▏ | 1237/1500 [01:30<00:22, 11.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(tan(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(tan(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(tan(S2))/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + " 83%|████████▎ | 1239/1500 [01:30<00:22, 11.73it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(sinh(S1)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(sinh(S1)**(S1**S1)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(sinh(S1)**(S1**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-log(_a0_)/relu(relu(S1))))\n", + " 83%|████████▎ | 1241/1500 [01:30<00:22, 11.74it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sin(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*sig(relu(sig(sig(sig(S2)))))**(S2**S2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(_a0_**_a0_)**2)))))\n", + " 83%|████████▎ | 1243/1500 [01:30<00:22, 11.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sig(sqrt(S2/_a0_)*exp(-S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", + " 83%|████████▎ | 1245/1500 [01:30<00:21, 11.62it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(relu(S1**S1))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((_a0_/S2)**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", + " 83%|████████▎ | 1247/1500 [01:31<00:30, 8.30it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(log(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(cosh(S1)))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(cosh(S1)))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_)**_a0_\n", + " 83%|████████▎ | 1249/1500 [01:31<00:27, 9.23it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(relu(log(_a0_))/relu(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/cos(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/cos(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(relu(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(cos(sinh(relu(S1)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + " 83%|████████▎ | 1251/1500 [01:31<00:25, 9.96it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + " 84%|████████▎ | 1253/1500 [01:31<00:23, 10.64it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2/S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(sig(_a0_))**relu(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**((1/2)*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_\n", + " 84%|████████▎ | 1255/1500 [01:31<00:22, 10.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_**3)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + " 84%|████████▍ | 1257/1500 [01:32<00:22, 10.98it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S2**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(relu(S1)))**_a0_))\n", + " 84%|████████▍ | 1259/1500 [01:32<00:20, 11.56it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(fac(S2)*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(sin(S2)))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(sinh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(sinh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(sinh(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(_a0_/S2))**2)**_a0_))\n", + " 84%|████████▍ | 1261/1500 [01:32<00:20, 11.42it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(relu((sinh(S2**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return S1**(S1**S1)\n", + " 84%|████████▍ | 1263/1500 [01:32<00:19, 11.95it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**2))/sinh(S2 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**(S1**S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + " 84%|████████▍ | 1265/1500 [01:32<00:19, 12.15it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cosh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cosh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cosh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**S2*relu(relu(S2))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return fac(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + " 84%|████████▍ | 1267/1500 [01:32<00:19, 12.20it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1)**(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1)**(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(S1)**(_a0_**_a0_))\n", + " 85%|████████▍ | 1269/1500 [01:33<00:18, 12.62it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S2)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(-S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(-S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**3)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(relu(S2)/relu(S2 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log((relu(relu(S2/relu(_a0_)))/relu(S1))**sig(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2*log(S2)))/sinh(S1))\n", + " 85%|████████▍ | 1271/1500 [01:33<00:17, 12.78it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/sin(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + " 85%|████████▍ | 1273/1500 [01:33<00:16, 13.43it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(sqrt(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(tan(S1))**_a0_/(_a0_ + relu(S1)))\n", + " 85%|████████▌ | 1275/1500 [01:33<00:16, 13.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2)*_a0_**2/(sqrt(tan(S2))*abs(relu(fac(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S2/_a0_)**_a0_)\n", + " 85%|████████▌ | 1277/1500 [01:33<00:17, 13.00it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S2 + _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return -_a0_**_a0_\n", + " 85%|████████▌ | 1279/1500 [01:33<00:16, 13.35it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/tan(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(relu(S2)/tan(relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(S2/relu(_a0_))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-relu(S2/relu(_a0_))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sinh(fac(_a0_))**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(S1 + _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1 + _a0_)**_a0_)\n", + " 85%|████████▌ | 1281/1500 [01:33<00:15, 13.96it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(log(_a0_)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(relu(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(relu(S1))**(S1**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(relu(S1))**(S1**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + " 86%|████████▌ | 1283/1500 [01:34<00:15, 13.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return exp(-_a0_**_a0_/S1)/relu(S1)\n", + " 86%|████████▌ | 1285/1500 [01:34<00:15, 13.51it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*log(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S1)**2)**_a0_))\n", + " 86%|████████▌ | 1287/1500 [01:34<00:16, 13.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1 + _a0_)*(S1**2 + S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sin(S1)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_**_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", + " 86%|████████▌ | 1289/1500 [01:34<00:16, 12.63it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(cos(S2)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1**(-S1)*S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(relu(_a0_)))**2)**_a0_))\n", + " 86%|████████▌ | 1291/1500 [01:34<00:16, 12.78it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(_a0_)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2/_a0_)*exp(-S2 - _a0_)\n", + " 86%|████████▌ | 1293/1500 [01:34<00:15, 13.35it/s]:2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sin\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S1*S2))**(S1**S2)))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(relu(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(fac(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", + " 86%|████████▋ | 1295/1500 [01:35<00:15, 13.63it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1/_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu((S1/_a0_)**_a0_)\n", + " 86%|████████▋ | 1297/1500 [01:35<00:17, 11.93it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*_a0_)/S1**3\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sin(S2/S1))**_a0_))*exp(-S1)\n", + " 87%|████████▋ | 1299/1500 [01:35<00:16, 12.46it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 87%|████████▋ | 1301/1500 [01:35<00:15, 12.89it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(tan(S2)**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*sin(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*sin(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(S2*sin(S2))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**(-S2)*sig(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S1)**2/_a0_)))))\n", + " 87%|████████▋ | 1303/1500 [01:35<00:16, 12.24it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu((sinh(relu(_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**S2/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 87%|████████▋ | 1305/1500 [01:35<00:15, 12.67it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(relu(relu(S1))*log(_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(sin(_a0_))**_a0_/(_a0_ + relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu((sinh(relu(S2*_a0_))**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sinh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sinh(S2)/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(tan(S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(tan(S2)))**_a0_\n", + " 87%|████████▋ | 1307/1500 [01:36<00:15, 12.15it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_**2*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + " 87%|████████▋ | 1309/1500 [01:36<00:15, 12.70it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(tan(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(tan(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/S2)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(S1)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return exp(-sig(_a0_)/log(_a0_))/relu(S1)\n", + " 87%|████████▋ | 1311/1500 [01:36<00:14, 13.09it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp((relu(relu(S2))**2)**_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + (S1 + S2)*sin(S1*S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + (S1 + S2)*sin(S1*S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(tan(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S2))**2\n", + " 88%|████████▊ | 1313/1500 [01:36<00:14, 12.98it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(sin(S1)))**_a0_\n", + " 88%|████████▊ | 1315/1500 [01:36<00:14, 12.50it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**_a0_/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(log(_a0_)))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(cos(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(log(cos(S1 + exp(relu(relu(S2))**2/_a0_)))))\n", + " 88%|████████▊ | 1317/1500 [01:36<00:14, 12.84it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((_a0_**_a0_)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((_a0_**_a0_)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu((_a0_**_a0_)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(exp(S2)))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + " 88%|████████▊ | 1319/1500 [01:36<00:13, 12.94it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(relu((sinh(S1)**2)**(_a0_**S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(_a0_**S2))**2\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(tan(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(log(S1))**_a0_)**2\n", + " 88%|████████▊ | 1321/1500 [01:37<00:13, 13.22it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*exp(-_a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(S1/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(S2))**2/relu(_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + " 88%|████████▊ | 1323/1500 [01:37<00:14, 12.56it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*_a0_**2/(sqrt(S1**_a0_)*abs(relu(fac(log(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return _a0_*(relu(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + " 88%|████████▊ | 1325/1500 [01:37<00:13, 13.41it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(_a0_)/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-sig(_a0_)/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(log(-_a0_**_a0_/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(relu(_a0_)))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S2)*log(sig(relu(_a0_)))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + " 88%|████████▊ | 1327/1500 [01:37<00:13, 12.66it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/relu(S2 + _a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1*_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1*_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1*_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_**_a0_)**_a0_)**2\n", + " 89%|████████▊ | 1329/1500 [01:37<00:13, 12.91it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(cos(S1))**_a0_)**2\n", + " 89%|████████▊ | 1331/1500 [01:37<00:12, 13.63it/s]:2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1**S1)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(S1**S1)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2/_a0_)**relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + ":2: RuntimeWarning: overflow encountered in square\n", + " return relu(sinh(S1)**(S1**S1))**2\n", + " 89%|████████▉ | 1333/1500 [01:38<00:12, 13.48it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S1))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(sin(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(S2*relu(_a0_**S1)**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(_a0_)))**_a0_\n", + " 89%|████████▉ | 1335/1500 [01:38<00:12, 12.94it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(-S2)))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(log(S1)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(log(S1)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(S2*relu(sqrt(_a0_))**S1))\n", + " 89%|████████▉ | 1337/1500 [01:38<00:12, 13.01it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(log(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 + cos(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(S2**S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*sin(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + " 89%|████████▉ | 1339/1500 [01:38<00:12, 12.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(relu(relu(S1)))**(sqrt(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + " 89%|████████▉ | 1341/1500 [01:38<00:11, 13.57it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(relu(S2**S2)))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(relu(S2**S2)))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(relu(relu(S2**S2)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1*S2)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1*S2)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1*S2)*exp(-S1)\n", + " 90%|████████▉ | 1343/1500 [01:38<00:11, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-(S2 + _a0_)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + sin(S1*relu(_a0_))**(S1 + S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2/_a0_ + sin((S1 + sin(S1*relu(_a0_))**(S1 + S2))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + " 90%|████████▉ | 1345/1500 [01:38<00:12, 12.29it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((2*S1 + S2 + sin(S1*relu(_a0_)))**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-S1)*sin((2*S1 + S2 + sin(S1*relu(_a0_)))**_a0_)**(S2/_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (S2**(-S1)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + " 90%|████████▉ | 1347/1500 [01:39<00:12, 12.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(cos(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**2))/sinh(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", + " 90%|████████▉ | 1349/1500 [01:39<00:11, 13.00it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(_a0_**S2)**2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 90%|█████████ | 1351/1500 [01:39<00:11, 13.19it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S1)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + " 90%|█████████ | 1353/1500 [01:39<00:11, 12.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1)*exp(-S1)\n", + " 90%|█████████ | 1355/1500 [01:39<00:11, 13.08it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**(-_a0_))**2\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**(-_a0_))**2\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sinh(S2**S2)**(-_a0_))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu((sinh(S1)**2)**(_a0_**S2)))\n", + " 90%|█████████ | 1357/1500 [01:39<00:10, 13.46it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(_a0_**S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(relu(2*_a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(sinh(_a0_)**(-_a0_))**2\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + " 91%|█████████ | 1359/1500 [01:40<00:10, 13.67it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(log(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*tanh(S1)/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/log(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(relu(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(S1)**(_a0_**_a0_)\n", + " 91%|█████████ | 1361/1500 [01:40<00:10, 13.71it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(relu(relu(sinh(S1))**(S2**S2)))\n", + " 91%|█████████ | 1363/1500 [01:40<00:09, 13.73it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(fac(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return relu(log(fac(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(tan(S2))))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1/_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1/_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(relu(S1/_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + " 91%|█████████ | 1365/1500 [01:40<00:09, 13.57it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(log(S1)))))\n", + " 91%|█████████ | 1367/1500 [01:40<00:09, 14.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + " 91%|█████████▏| 1369/1500 [01:40<00:09, 14.08it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(log(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(tan(S1))**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + tan(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + tan(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(_a0_/S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(relu(_a0_**S2)**2/_a0_)))))\n", + " 91%|█████████▏| 1371/1500 [01:40<00:09, 14.29it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(2*_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(2*_a0_)))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(2*_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return exp(-_a0_**S2/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/sin(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(relu(S1))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S2))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sinh(S1)**(S2**S2))\n", + " 92%|█████████▏| 1373/1500 [01:41<00:09, 13.60it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(sinh(tan(S2)))**_a0_))\n", + " 92%|█████████▏| 1375/1500 [01:41<00:08, 14.26it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sinh(S1)**(-_a0_**S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(cos(S2/(_a0_*relu(relu(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + " 92%|█████████▏| 1377/1500 [01:41<00:08, 14.09it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2/(_a0_*relu(relu(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/tan(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (relu(relu(S2/relu(_a0_)))/tan(S1))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 92%|█████████▏| 1379/1500 [01:41<00:08, 14.09it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-1/relu(relu(S1))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(_a0_)))**_a0_\n", + " 92%|█████████▏| 1381/1500 [01:41<00:08, 14.28it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(relu(S1)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(relu(S1)))**_a0_\n", + " 92%|█████████▏| 1383/1500 [01:41<00:08, 13.97it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(_a0_*cos(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*abs(relu(fac(sin(S1))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**_a0_\n", + " 92%|█████████▏| 1385/1500 [01:41<00:08, 13.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return -sqrt(S2*_a0_)/S1\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return exp(-sig(_a0_)/S1)/relu(_a0_)\n", + " 92%|█████████▏| 1387/1500 [01:42<00:08, 13.34it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tan(S2)/(_a0_*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (-sinh(S1))**_a0_\n", + " 93%|█████████▎| 1389/1500 [01:42<00:08, 13.33it/s]:2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sqrt(-S1*_a0_))**_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (S2/_a0_ + sin((2*S1 + S2 + sqrt(-S1*_a0_))**_a0_))*exp(-S1)\n", + " 93%|█████████▎| 1391/1500 [01:42<00:08, 13.01it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1)/S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(S1)/S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_/S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + _a0_)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(cos(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + " 93%|█████████▎| 1393/1500 [01:42<00:08, 13.19it/s]:2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(log(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/((S1 + S2)*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/tan(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(cos(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(cos(S2)))/sinh(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + " 93%|█████████▎| 1395/1500 [01:42<00:07, 13.83it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return ((1/2)*relu(relu(S2/relu(_a0_)))/_a0_)**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S1 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S1 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S1 + _a0_))**_a0_\n", + " 93%|█████████▎| 1397/1500 [01:42<00:07, 14.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/(S1*relu(relu(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 93%|█████████▎| 1399/1500 [01:42<00:07, 14.24it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/sinh(sin(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(relu(relu(log(_a0_))))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(relu(relu(log(_a0_))))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(relu(relu(log(_a0_))))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S1**S2)\n", + " 93%|█████████▎| 1401/1500 [01:43<00:07, 13.92it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/cos(S2))\n", + " 94%|█████████▎| 1403/1500 [01:43<00:07, 13.45it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S1**2 - _a0_))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2*_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/relu(S1 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(-S2)*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + " 94%|█████████▎| 1405/1500 [01:43<00:07, 12.85it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(sin(S2))*abs(relu(fac(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(_a0_)))**_a0_\n", + " 94%|█████████▍| 1407/1500 [01:43<00:07, 13.16it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(tanh(_a0_))))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S1/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S1/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return exp(-_a0_**S1/S1)/relu(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + " 94%|█████████▍| 1409/1500 [01:43<00:07, 12.81it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return (S1**(-S1)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**(2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(S1)**_a0_\n", + " 94%|█████████▍| 1411/1500 [01:43<00:07, 11.90it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(relu(exp(cos(_a0_**_a0_ + exp(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S1)**_a0_\n", + " 94%|█████████▍| 1413/1500 [01:44<00:06, 12.50it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(sin(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(S1)/_a0_)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + " 94%|█████████▍| 1415/1500 [01:44<00:06, 12.86it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**(-_a0_)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (_a0_**(-_a0_)*relu(relu(S2/relu(_a0_))))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/sinh(S2 + _a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return exp(-S1)*sqrt(log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**3)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + " 94%|█████████▍| 1417/1500 [01:44<00:09, 8.63it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(relu(_a0_)))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(_a0_/relu(S1)))\n", + " 95%|█████████▍| 1419/1500 [01:44<00:08, 9.36it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(relu(relu(sinh(_a0_))**_a0_))\n", + " 95%|█████████▍| 1421/1500 [01:44<00:07, 10.16it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(S2/S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(log(_a0_))**S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return sinh(relu(S2 + _a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S2 + _a0_)**_a0_))\n", + " 95%|█████████▍| 1423/1500 [01:45<00:07, 10.99it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(relu(relu(S1*_a0_)**_a0_))\n", + " 95%|█████████▌| 1425/1500 [01:45<00:06, 11.53it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(relu(fac(S1)))*sqrt(cos(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + log(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(S2 + log(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_/S2)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(S2*relu(sig(log(_a0_)))**S1))\n", + " 95%|█████████▌| 1427/1500 [01:45<00:06, 12.04it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(cos(_a0_)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2 + _a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(_a0_**S2))**_a0_))\n", + " 95%|█████████▌| 1429/1500 [01:45<00:05, 12.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*_a0_/tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*_a0_/tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return cos(S2)**_a0_/(_a0_ + relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S2)**(2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 95%|█████████▌| 1431/1500 [01:45<00:05, 12.23it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2**3*_a0_**3/relu(S1)**3))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2**3*_a0_**3/relu(S1)**3))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(fac(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-cos(S2)/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(-sinh(S2))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + " 96%|█████████▌| 1433/1500 [01:45<00:05, 12.27it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(-_a0_**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(2*S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(2*S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(2*S2**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(tan(sinh(S1))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(tan(sinh(S1))**_a0_))\n", + " 96%|█████████▌| 1435/1500 [01:46<00:05, 11.53it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(-S1)*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S1)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(_a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + " 96%|█████████▌| 1437/1500 [01:46<00:05, 11.47it/s]:2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(sin(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(tan(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(_a0_**S2)**_a0_))\n", + " 96%|█████████▌| 1439/1500 [01:46<00:05, 11.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sinh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sinh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*sinh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(S2/log(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*_a0_/relu(S1)))**3\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return relu(sqrt(relu(sinh(S1**S2))**_a0_))\n", + " 96%|█████████▌| 1441/1500 [01:46<00:04, 12.21it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_*fac(S2)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(log(fac(S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(log(fac(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(sqrt(relu(sinh(S1))**(S2**S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(-S2))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + log(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(S1 + log(relu(relu(S2))**2/_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + " 96%|█████████▌| 1443/1500 [01:46<00:04, 12.45it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + " 96%|█████████▋| 1445/1500 [01:46<00:04, 11.67it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(-sig(_a0_)/S1)/relu(tanh(_a0_)))\n", + " 96%|█████████▋| 1447/1500 [01:47<00:04, 12.16it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S2**S1))\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return relu(S2)*relu(sig(sig(relu(_a0_))))**(_a0_*exp(S2))\n", + " 97%|█████████▋| 1449/1500 [01:47<00:04, 12.31it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sig(log(S2**3))/sinh(S2*_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return (_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S1))**_a0_\n", + " 97%|█████████▋| 1451/1500 [01:47<00:04, 12.18it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(relu(relu(S2/_a0_)/sqrt(S1*(-S1 + S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sin(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**(2*_a0_)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", + " 97%|█████████▋| 1453/1500 [01:47<00:03, 12.51it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(sin(S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/relu(cosh(S2)))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return _a0_**(2*_a0_)\n", + " 97%|█████████▋| 1455/1500 [01:47<00:03, 12.86it/s]:2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return sinh(relu(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_**_a0_)**_a0_\n", + " 97%|█████████▋| 1457/1500 [01:47<00:03, 12.82it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return log(S1)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return relu(exp(-sig(_a0_)/S1)/relu(_a0_**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_*relu(sinh(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_*relu(sinh(S1))))\n", + " 97%|█████████▋| 1459/1500 [01:47<00:03, 13.32it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(tan(S2)**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(log(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**(2*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**(2*_a0_)\n", + " 97%|█████████▋| 1461/1500 [01:48<00:03, 12.98it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(_a0_)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(_a0_)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sig(_a0_)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S2)\n", + " 98%|█████████▊| 1463/1500 [01:48<00:03, 11.95it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(relu(sinh(S1))/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(relu(sinh(S1))/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(exp(cos(S1 + exp(_a0_**(-S1)*relu(relu(relu(S2)))**2)))))\n", + " 98%|█████████▊| 1465/1500 [01:48<00:02, 11.86it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(log(-S2*_a0_/relu(S2 + _a0_)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(tan(S1))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(sqrt(relu(sinh(log(_a0_)))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + " 98%|█████████▊| 1467/1500 [01:48<00:02, 11.07it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (relu(relu(S2/relu(sqrt(_a0_))))/relu(_a0_))**sig(S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(_a0_)**_a0_))\n", + " 98%|█████████▊| 1469/1500 [01:48<00:02, 11.61it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*_a0_/tan(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return (relu(relu(S2 + relu(sqrt(_a0_))))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(relu(sinh(S1))/_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1 + _a0_)**_a0_\n", + " 98%|█████████▊| 1471/1500 [01:49<00:02, 10.87it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S1)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(relu(relu(relu(S2)))**2*exp(-_a0_))))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2*_a0_)**relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(log(-(S2*_a0_)**relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: overflow encountered in power\n", + " return sinh(S1)**(S2**S1)\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(S2/_a0_)**_a0_\n", + " 98%|█████████▊| 1473/1500 [01:49<00:02, 10.63it/s]:2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/relu(S1))\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(exp(S2/S1**2)/relu(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return sqrt(sig(log(log(_a0_)**3))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(log(_a0_)**3))/sinh(S1))\n", + " 98%|█████████▊| 1475/1500 [01:49<00:02, 11.44it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return log(tan(S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S1/relu(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(sqrt(relu(sinh(_a0_))**_a0_))\n", + " 98%|█████████▊| 1477/1500 [01:49<00:01, 11.72it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(sin(S2))**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(exp(-_a0_/S1)/relu(fac(_a0_)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(tanh(S2)/relu(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + " 99%|█████████▊| 1479/1500 [01:49<00:01, 11.40it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*cosh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*cosh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2*cosh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sqrt(sinh(log(S2**3))/sinh(S1))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S2/_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1*_a0_)**_a0_\n", + " 99%|█████████▊| 1481/1500 [01:49<00:01, 10.24it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return _a0_**S1*relu(sig(sig(relu(relu(_a0_)))))**(S1*_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(relu(_a0_**S2*relu(sig(_a0_))**S1))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1 + _a0_)**_a0_\n", + " 99%|█████████▉| 1483/1500 [01:50<00:01, 10.88it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2*_a0_/S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(S2*_a0_/S1))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return (relu(relu(S2/relu(_a0_)))/_a0_**2)**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sqrt(sig(log(S2 + _a0_))/sinh(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return sinh(S1)**log(_a0_)\n", + " 99%|█████████▉| 1485/1500 [01:50<00:01, 11.39it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sin(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(sin(S2*_a0_/relu(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S2*_a0_)**_a0_\n", + " 99%|█████████▉| 1487/1500 [01:50<00:01, 11.66it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S2)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(sinh(S1*_a0_))**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/relu(tan(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/relu(tan(S2)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return log(S2/relu(tan(S2)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(relu(S1))**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(relu(S1))**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(relu(S1))**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return tan(S1)**_a0_\n", + " 99%|█████████▉| 1489/1500 [01:50<00:00, 12.73it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (log(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (log(relu(S2/relu(_a0_)))/relu(S1))**sig(S1)\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*sin(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return relu(S1)**(_a0_**S2)\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S1*S2/relu(S1)))\n", + " 99%|█████████▉| 1491/1500 [01:50<00:00, 12.86it/s]:2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(relu(relu(S2/_a0_)/sqrt((S1**3 + S2)*tan(S2))))\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return relu(sqrt(_a0_ + relu(sinh(S1))))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-2*S2**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sin(relu(S1))**_a0_\n", + ":2: RuntimeWarning: overflow encountered in exp\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(relu(relu(S2)))**2/S1)))))\n", + ":2: RuntimeWarning: invalid value encountered in cos\n", + " return relu(relu(exp(cos(S1 + exp(_a0_*relu(relu(relu(S2)))**2/S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in scalar power\n", + " return relu(_a0_)**_a0_\n", + "100%|█████████▉| 1493/1500 [01:50<00:00, 12.74it/s]:2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (_a0_/S2)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2**2/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S2/relu(_a0_))*exp(-S2)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2/_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S1 + _a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(relu(exp(cos(exp(relu(relu(relu(S2)))**2/_a0_) + log(_a0_)))))\n", + "100%|█████████▉| 1495/1500 [01:51<00:00, 12.62it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-sqrt(S1)*S2/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in log\n", + " return log(log(_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-S2))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return (S1/_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(sqrt(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(sqrt(_a0_))**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in sqrt\n", + " return sinh(sqrt(_a0_))**_a0_\n", + "100%|█████████▉| 1497/1500 [01:51<00:00, 12.85it/s]:2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tanh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tanh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-tanh(S1)/relu(S1)))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return sqrt(S1**2/relu(_a0_))*exp(-S1)\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(_a0_**S1)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sinh(S1**S2)**_a0_\n", + "100%|█████████▉| 1499/1500 [01:51<00:00, 12.89it/s]:2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(relu(log(S1)))))\n", + ":2: RuntimeWarning: divide by zero encountered in divide\n", + " return relu(sqrt(S2)*relu(_a0_)**2/(sqrt(S1**_a0_)*sqrt(relu(log(S1)))))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", + ":2: RuntimeWarning: overflow encountered in sinh\n", + " return sqrt(sig(log(S2**3))/sinh(S1**S2))\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in scalar power\n", + " return sinh(_a0_)**_a0_\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: divide by zero encountered in power\n", + " return relu(sqrt(relu(S2*_a0_)**_a0_))\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in power\n", + " return sinh(S2*_a0_)**_a0_\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_/S1)/relu(S1))\n", + ":2: RuntimeWarning: invalid value encountered in log\n", + " return relu(log(-_a0_/S1)/relu(S1))\n", + "100%|██████████| 1500/1500 [01:51<00:00, 13.46it/s]\n", + "INFO:autora.skl.bms:BMS fitting finished\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/pandas/core/arraylike.py:402: RuntimeWarning: divide by zero encountered in log\n", + " result = getattr(ufunc, method)(*inputs, **kwargs)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/mpl_toolkits/mplot3d/art3d.py:1180: RuntimeWarning: invalid value encountered in subtract\n", + " v1[poly_i, :] = ps[i1, :] - ps[i2, :]\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1665: RuntimeWarning: invalid value encountered in multiply\n", + " multiply(a1, b2, out=cp0)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1666: RuntimeWarning: invalid value encountered in multiply\n", + " tmp = array(a2 * b1)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1668: RuntimeWarning: invalid value encountered in multiply\n", + " multiply(a2, b0, out=cp1)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/numpy/core/numeric.py:1669: RuntimeWarning: invalid value encountered in multiply\n", + " multiply(a0, b2, out=tmp)\n", + "/Users/jholla10/Library/Caches/pypoetry/virtualenvs/autora-17yK3Jyq-py3.8/lib/python3.8/site-packages/mpl_toolkits/mplot3d/proj3d.py:180: RuntimeWarning: invalid value encountered in divide\n", + " txs, tys, tzs = vecw[0]/w, vecw[1]/w, vecw[2]/w\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "log((S2 / S1))\n" + ] + }, + { + "data": { + "text/plain": "array([[0. ],\n [1.82624565],\n [2.43545837],\n [2.81130323],\n [3.08383954]])" + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# initialize model\n", + "# hyper parameters\n", + "\n", + "prior_par = {\n", + " \"Nopi_/\": 5.912205942815285,\n", + " \"Nopi_cosh\": 8.12720511103694,\n", + " \"Nopi_-\": 3.350846072163632,\n", + " \"Nopi_sin\": 5.965917796154835,\n", + " \"Nopi_tan\": 8.127427922862411,\n", + " \"Nopi_tanh\": 7.799259068142255,\n", + " \"Nopi_**\": 6.4734429542245495,\n", + " \"Nopi_pow2\": 3.3017352779079734,\n", + " \"Nopi_pow3\": 5.9907496760026175,\n", + " \"Nopi_exp\": 4.768665265735502,\n", + " \"Nopi_log\": 4.745957377206544,\n", + " \"Nopi_sqrt\": 4.760686909134266,\n", + " \"Nopi_cos\": 5.452564657261127,\n", + " \"Nopi_sinh\": 7.955723540761046,\n", + " \"Nopi_abs\": 6.333544134938385,\n", + " \"Nopi_+\": 5.808163661224514,\n", + " \"Nopi_*\": 5.002213595420244,\n", + " \"Nopi_fac\": 10.0,\n", + " \"Nopi2_*\": 1.0,\n", + " \"Nopi_sig\": 1.0,\n", + " \"Nopi_relu\": 1.0,\n", + "}\n", + "\n", + "# temperatures\n", + "ts = [1.0] + [1.04**k for k in range(1, 20)]\n", + "\n", + "# epoch num\n", + "epochs = 1500\n", + "\n", + "# fit model\n", + "estimator = BMSRegressor(prior_par, ts, epochs)\n", + "estimator = estimator.fit(X, y)\n", + "\n", + "# model estimate\n", + "show_results(\n", + " estimator=estimator, label=\"BMS Regressor\"\n", + ")\n", + "print(estimator.model_)\n", + "\n", + "# model prediction\n", + "test_x = X.head()\n", + "estimator.predict(test_x)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "375b5b94", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best model:\t log((S2 / S1))\n", + "Desc. length:\t -659.941451339323\n" + ] + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "estimator.present_results()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/theorist/bsr/bsr.ipynb b/docs/theorist/bsr/bsr.ipynb index 406678431..651d16d29 100644 --- a/docs/theorist/bsr/bsr.ipynb +++ b/docs/theorist/bsr/bsr.ipynb @@ -57,6 +57,18 @@ "collapsed": false } }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, { "cell_type": "code", "execution_count": 28, @@ -71,12 +83,11 @@ } ], "source": [ - "from autora_bsr.skl.bsr import BSRRegressor\n", + "from autora.skl.bsr import BSRRegressor\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "x = np.expand_dims(np.linspace(start=-1, stop=1, num=500), 1)\n", - "# y = x^3 + sin(x)\n", "y = np.power(x, 3) + np.sin(x)\n", "\n", "# initialize regressor\n", @@ -100,7 +111,7 @@ "
\n", "\n", "## References\n", - "Jin, Ying, et al. \"Bayesian symbolic regression.\" arXiv preprint arXiv:1910.08892 (2019)." + "Jin, Ying, et al. \"Bayesian symbolic regression.\" arXiv preprint arXiv:1910.08892 (2019).\n" ], "metadata": { "collapsed": false diff --git a/docs/theorist/bsr/example.md b/docs/theorist/bsr/example.md deleted file mode 100644 index c64c48d31..000000000 --- a/docs/theorist/bsr/example.md +++ /dev/null @@ -1,28 +0,0 @@ -# Bayesian Symbolic Regression - -## Example - -The following toy example shows out-of-the-box functionality of BSR. It first generates data using the equation, $y = \sin(x) + x^3$, as ground-truth, and then fits the data with default meta-parameters. For ease and efficiency of illustration, it applies a small number of iterations, `itr_num`. As displayed in the plot below, the algorithm provides results that are not only reasonable, but exactly match the ground-truth equation. - -```python -from autora_bsr.skl.bsr import BSRRegressor -import numpy as np -import matplotlib.pyplot as plt - -x = np.expand_dims(np.linspace(start=-1, stop=1, num=500), 1) -# y = x^3 + sin(x) -y = np.power(x, 3) + np.sin(x) - -# initialize regressor -bsr = BSRRegressor(itr_num = 500) -bsr.fit(x, y) -y_pred = bsr.predict(x) - -# plot out the ground truth versus predicted responses -plt.figure() -plt.plot(x, y, "o") -plt.plot(x, y_pred, "-") -plt.show() -``` - -![img.png](img.png) diff --git a/docs/theorist/darts/example.ipynb b/docs/theorist/darts/example.ipynb new file mode 100644 index 000000000..a79322552 --- /dev/null +++ b/docs/theorist/darts/example.ipynb @@ -0,0 +1,342 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Differentiable Architecture Search\n", + "\n", + "## Example" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Let's generate a simple data set with two features $x_1, x_2 \\in [0, 1]$ and a target $y$. We will use the following generative model:\n", + "$y = 2 x_1 - e^{(5 x_2)}$" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "collapsed": true + }, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "x_1 = np.linspace(0, 1, num=10)\n", + "x_2 = np.linspace(0, 1, num=10)\n", + "X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2)\n", + "\n", + "y = 2 * X[:,0] + np.exp(5 * X[:,1])" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Now let us define the search space, that is, the space of operations to consider when searching over the space of computation graphs." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 2, + "outputs": [], + "source": [ + "primitives = [\n", + " \"none\",\n", + " \"add\",\n", + " \"subtract\",\n", + " 'mult',\n", + " \"logistic\",\n", + " 'exp',\n", + " 'relu',\n", + "]" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "## Set up the DARTS Regressor\n", + "\n", + "We will use the DARTS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below:\n", + "\n", + "- **num_graph_nodes**: The number of latent variables used to represent the model.\n", + "- **arch_updates_per_epoch**: The number of architecture updates per training epoch. These updates affect the architecture weights $\\alpha$ indicating the relative contribution of each operation for a given computation step.\n", + "- **arch_learning_rate_max**: The initial learning rate of the architecture weight optimizer.\n", + "- **param_updates_per_epoch**: The number of parameter updates per epoch. Once the architecture updates are complete, the parameters associated with each operation are updated.\n", + "- **param_momentum**: The momentum of the parameter optimizer.\n", + "- **max_epochs**: The maximum number of epochs to run DARTS.\n", + "- **output_type**: The type of output to produce. In our case, we treat the outcome as a real variable, i.e., \"real\".\n", + "\n", + "\n", + "Let's set up the DARTS regressor with some default parameters.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "from autora.skl.darts import DARTSRegressor\n", + "\n", + "darts_estimator = DARTSRegressor(\n", + " num_graph_nodes=1,\n", + " arch_updates_per_epoch=1,\n", + " arch_learning_rate_max=0.001,\n", + " param_updates_per_epoch=500,\n", + " param_momentum=0.9,\n", + " max_epochs=300,\n", + " output_type=\"real\",\n", + " primitives=primitives,\n", + ")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Now we have everything to run differentiable architecture search and visualize the model resulting from the highest architecture weights. Note that the current model corresponds to the model with the highest architecture weights." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/300 [00:00\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator.fit(X, y)\n", + "darts_estimator.visualize_model()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We can refine the fit by running the `fit` method again, after changing the parameters. This allows us to keep the same architecture but refit the parameters in the final sampled model, for example:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "outputs": [ + { + "data": { + "text/plain": "0it [00:00, ?it/s]", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "bece0e3dc61b41cca6eae1d70d0af091" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator.set_params(\n", + " max_epochs=0, # no epochs of architecture fitting\n", + " param_updates_for_sampled_model=1000, # 1000 steps of param optimiziation\n", + ")\n", + "darts_estimator.fit(X, y)\n", + "darts_estimator.visualize_model()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "We can also change how the model is sampled from the architecture weight distribution:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 6, + "outputs": [ + { + "data": { + "text/plain": "0it [00:00, ?it/s]", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "c7be110e32954ed092c008d024a309b3" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\n47.75 * x\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nReLU(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator.set_params(\n", + " max_epochs=0, # no epochs of architecture fitting\n", + " sampling_strategy=\"sample\", # overriding default \"max\"\n", + " param_updates_for_sampled_model=800,\n", + ")\n", + "darts_estimator.fit(X, y)\n", + "darts_estimator.visualize_model()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "To recover the initial model, we need to return the sampling strategy to the default `\"max\"`:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": "0it [00:00, ?it/s]", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "4f4026df6f5e4934905010e90bc42fc8" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nexp(x)\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\nexp(x)\n\n\n\nP(detected) = (x + 0.00)\n\nP(detected) = (x + 0.00)\n\n\n\nk1->P(detected) = (x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator.set_params(\n", + " max_epochs=0, # no epochs of architecture fitting\n", + " sampling_strategy=\"max\",\n", + " param_updates_for_sampled_model=1000,\n", + ")\n", + "darts_estimator.fit(X, y)\n", + "darts_estimator.visualize_model()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "As long as the architecture has not been refitted in the meantime, the architecture should be identical to the initial result, as the `sampling_strategy=\"max\"` is deterministic. The coefficients of the architecture functions may, however, be different, as they have different starting values compared to when they were initially set.\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/docs/theorist/darts/example.md b/docs/theorist/darts/example.md deleted file mode 100644 index 60546967c..000000000 --- a/docs/theorist/darts/example.md +++ /dev/null @@ -1,101 +0,0 @@ -# Differentiable Architecture Search - -## Example - -Let's generate a simple data set with two features $x_1, x_2 \in [0, 1]$ and a target $y$. We will use the following generative model: -$y = 2 x_1 - e^{(5 x_2)}$ - -```python -import numpy as np - -x_1 = np.linspace(0, 1, num=10) -x_2 = np.linspace(0, 1, num=10) -X = np.array(np.meshgrid(x_1, x_2)).T.reshape(-1,2) - -y = 2 * X[:,0] + np.exp(5 * X[:,1]) -``` - -Now let us define the search space, that is, the space of operations to consider when searching over the space of computation graphs. - -```python -primitives = [ - "none", - "add", - "subtract", - 'mult', - "logistic", - 'exp', - 'relu', -] -``` - -## Set up the DARTS Regressor - -We will use the DARTS Regressor to predict the outcomes. There are a number of parameters that determine how the architecture search is performed. The most important ones are listed below: - -- **num_graph_nodes**: The number of latent variables used to represent the model. -- **arch_updates_per_epoch**: The number of architecture updates per training epoch. These updates affect the architecture weights $\alpha$ indicating the relative contribution of each operation for a given computation step. -- **arch_learning_rate_max**: The initial learning rate of the architecture weight optimizer. -- **param_updates_per_epoch**: The number of parameter updates per epoch. Once the architecture updates are complete, the parameters associated with each operation are updated. -- **param_momentum**: The momentum of the parameter optimizer. -- **max_epochs**: The maximum number of epochs to run DARTS. -- **output_type**: The type of output to produce. In our case, we treat the outcome as a real variable, i.e., "real". - - -Let's set up the DARTS regressor with some default parameters. - -```python -from autora.skl.darts import DARTSRegressor - -darts_estimator = DARTSRegressor( - num_graph_nodes=1, - arch_updates_per_epoch=1, - arch_learning_rate_max=0.001, - param_updates_per_epoch=500, - param_momentum=0.9, - max_epochs=300, - output_type="real", - primitives=primitives, -) -``` - -Now we have everything to run differentiable architecture search and visualize the model resulting from the highest architecture weights. Note that the current model corresponds to the model with the highest architecture weights. - -```python -darts_estimator.fit(X, y) -darts_estimator.visualize_model() -``` - -We can refine the fit by running the `fit` method again, after changing the parameters. This allows us to keep the same architecture but refit the parameters in the final sampled model, for example: -```python -darts_estimator.set_params( - max_epochs=0, # no epochs of architecture fitting - param_updates_for_sampled_model=1000, # 1000 steps of param optimiziation -) -darts_estimator.fit(X, y) -darts_estimator.visualize_model() -``` - -We can also change how the model is sampled from the architecture weight distribution: -```python -darts_estimator.set_params( - max_epochs=0, # no epochs of architecture fitting - sampling_strategy="sample", # overriding default "max" - param_updates_for_sampled_model=800, -) -darts_estimator.fit(X, y) -darts_estimator.visualize_model() -``` - -To recover the initial model, we need to return the sampling strategy to the default `"max"`: -```python -darts_estimator.set_params( - max_epochs=0, # no epochs of architecture fitting - sampling_strategy="max", - param_updates_for_sampled_model=1000, -) -darts_estimator.fit(X, y) -darts_estimator.visualize_model() -``` - -As long as the architecture has not been refitted in the meantime, the architecture should be identical to the initial result, as the `sampling_strategy="max"` is deterministic. The coefficients of the architecture functions may, however, be different, as they have different starting values compared to when they were initially set. diff --git a/docs/theorist/darts/weber.ipynb b/docs/theorist/darts/weber.ipynb new file mode 100644 index 000000000..c728c226a --- /dev/null +++ b/docs/theorist/darts/weber.ipynb @@ -0,0 +1,348 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "source": [ + "Example file which shows some simple curve fitting using DARTSRegressor and some other estimators." + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": null, + "outputs": [], + "source": [ + "# Uncomment the following line when running on Google Colab\n", + "# !pip install autora" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 1, + "outputs": [], + "source": [ + "from functools import partial\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "from sklearn.linear_model import LinearRegression\n", + "from sklearn.model_selection import GridSearchCV\n", + "from sklearn.pipeline import make_pipeline\n", + "from sklearn.preprocessing import PolynomialFeatures\n", + "\n", + "from autora.skl.darts import DARTSRegressor\n", + "from autora.synthetic import retrieve, describe" + ], + "metadata": {} + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# %% Define some helper functions\n", + "\n", + "def show_results_complete(\n", + " data_: pd.DataFrame,\n", + " estimator=None,\n", + " show_results=True,\n", + " projection=\"2d\",\n", + " label=None,\n", + "):\n", + " \"\"\"\n", + " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", + " \"\"\"\n", + " if projection == \"2d\":\n", + " plt.figure()\n", + " data_.plot.scatter(\n", + " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", + " )\n", + " elif projection == \"3d\":\n", + " fig = plt.figure()\n", + " ax = fig.add_subplot(projection=\"3d\")\n", + " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", + "\n", + " if estimator is not None:\n", + " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", + "\n", + " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", + "\n", + " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", + "\n", + " if label is not None:\n", + " plt.title(label)\n", + "\n", + " if show_results:\n", + " plt.show()\n", + "\n", + " return\n" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "outputs": [], + "source": [ + "# %% Load the data\n", + "s = retrieve(\"weber_fechner\",rng=np.random.default_rng(seed=180), resolution=20)\n", + "X = s.domain()\n", + "y = s.experiment_runner(X)\n", + "data = pd.DataFrame(np.column_stack([X, y]), columns=[\"S1\", \"S2\", \"difference_detected\"])" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 4, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "show_results = partial(show_results_complete, data_=data, projection=\"3d\")\n", + "show_results(label=\"input data\")" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %% Fit first using a super-simple linear regression\n", + "\n", + "first_order_linear_estimator = LinearRegression()\n", + "first_order_linear_estimator.fit(X, y)\n", + "\n", + "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", + "polynomial_estimator = GridSearchCV(\n", + " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", + " param_grid=dict(polynomialfeatures__degree=range(4)),\n", + ")\n", + "polynomial_estimator.fit(X, y)\n", + "\n", + "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/30 [00:00", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nlogistic(x)\n\n\n\nk3\n\nk3\n\n\n\nx1->k3\n\n\n-2.40 * x + -0.14\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-0.92 * x + 0.12\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\n-0.73 * x + -0.66\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\nlogistic(x)\n\n\n\nx2->k3\n\n\n0.52 * x + -0.51\n\n\n\nk4\n\nk4\n\n\n\nx2->k4\n\n\n0.71 * x + 0.45\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1->k2\n\n\n-1.12 * x + -0.91\n\n\n\nk1->k3\n\n\n-1.02 * x + -0.76\n\n\n\nk1->k4\n\n\n-0.39 * x + 0.70\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->k5\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.35 * x + 0.49\n\n\n\nk3->k5\n\n\n1.35 * x + 0.37\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\n0.54 * x + 0.56\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator_tuned = DARTSRegressor(\n", + " batch_size=64,\n", + " arch_updates_per_epoch=100,\n", + " param_updates_per_epoch=100,\n", + " max_epochs=30,\n", + " output_type=\"probability\",\n", + " num_graph_nodes=5,\n", + " primitives=[\n", + " \"none\",\n", + " \"linear\",\n", + " \"logistic\",\n", + " ]\n", + ")\n", + "\n", + "darts_estimator_tuned.fit(X, y)\n", + "\n", + "show_results(estimator=darts_estimator_tuned, label=\"pre-tuned DARTSRegressor\")\n", + "darts_estimator_tuned.visualize_model()" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 8, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/1 [00:00", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk4\n\nk4\n\n\n\nx1->k4\n\n\n-0.63 * x + 0.40\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-1.56 * x + 0.03\n\n\n\nx2\n\nx2\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\n-0.27 * x + -0.38\n\n\n\nk3\n\nk3\n\n\n\nx2->k3\n\n\nlogistic(x)\n\n\n\nx2->k4\n\n\n0.81 * x + 0.32\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1\n\nk1\n\n\n\nk1->k3\n\n\n-1.38 * x + -1.09\n\n\n\nk1->k4\n\n\nlogistic(x)\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.40 * x + 0.36\n\n\n\nk3->k5\n\n\n1.36 * x + 0.26\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\nlogistic(x)\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator_tuned.set_params(\n", + " arch_updates_per_epoch=0,\n", + " param_updates_per_epoch=1000,\n", + " sampling_strategy=\"sample\",\n", + " max_epochs=1\n", + ")\n", + "darts_estimator_tuned.fit(X, y)\n", + "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", + "darts_estimator_tuned.visualize_model()\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 9, + "outputs": [ + { + "data": { + "text/plain": "0it [00:00, ?it/s]", + "application/vnd.jupyter.widget-view+json": { + "version_major": 2, + "version_minor": 0, + "model_id": "d795b0ef59f340ecaa60a90cd7d9b0ff" + } + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/svg+xml": "\n\n\n\n\n\n\n\n\nx1\n\nx1\n\n\n\nk1\n\nk1\n\n\n\nx1->k1\n\n\nlogistic(x)\n\n\n\nk3\n\nk3\n\n\n\nx1->k3\n\n\n-2.40 * x + -0.11\n\n\n\nk5\n\nk5\n\n\n\nx1->k5\n\n\n-0.90 * x + 0.12\n\n\n\nx2\n\nx2\n\n\n\nx2->k1\n\n\n-0.66 * x + -0.67\n\n\n\nk2\n\nk2\n\n\n\nx2->k2\n\n\nlogistic(x)\n\n\n\nx2->k3\n\n\n0.47 * x + -0.46\n\n\n\nk4\n\nk4\n\n\n\nx2->k4\n\n\n0.70 * x + 0.43\n\n\n\nx2->k5\n\n\nlogistic(x)\n\n\n\nk1->k2\n\n\n-1.14 * x + -0.85\n\n\n\nk1->k3\n\n\n-1.11 * x + -0.70\n\n\n\nk1->k4\n\n\n-0.42 * x + 0.67\n\n\n\nP(detected) = Sigmoid(x + 0.00)\n\nP(detected) = Sigmoid(x + 0.00)\n\n\n\nk1->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk2->k4\n\n\nlogistic(x)\n\n\n\nk2->k5\n\n\nlogistic(x)\n\n\n\nk2->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk3->k4\n\n\n1.38 * x + 0.47\n\n\n\nk3->k5\n\n\n1.35 * x + 0.36\n\n\n\nk3->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk4->k5\n\n\n0.56 * x + 0.54\n\n\n\nk4->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\nk5->P(detected) = Sigmoid(x + 0.00)\n\n\n1.00 * x\n\n\n\n", + "text/plain": "" + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "darts_estimator_tuned.set_params(\n", + " arch_updates_per_epoch=0,\n", + " param_updates_per_epoch=1000,\n", + " sampling_strategy=\"max\",\n", + " max_epochs=0\n", + ")\n", + "darts_estimator_tuned.fit(X, y)\n", + "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", + "darts_estimator_tuned.visualize_model()\n" + ], + "metadata": { + "collapsed": false + } + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.13" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/example/cycle/simple_cycle_bms_model_poppernet.py b/example/cycle/simple_cycle_bms_model_poppernet.py deleted file mode 100644 index a0027625d..000000000 --- a/example/cycle/simple_cycle_bms_model_poppernet.py +++ /dev/null @@ -1,134 +0,0 @@ -import matplotlib.pyplot as plt -import numpy as np - -from autora.cycle import Cycle -from autora.experimentalist.pipeline import Pipeline -from autora.experimentalist.pooler import grid_pool, poppernet_pool -from autora.experimentalist.sampler import nearest_values_sampler -from autora.skl.bms import BMSRegressor -from autora.variable import Variable, VariableCollection - -# meta parameters -ground_truth_resolution = 1000 -samples_per_cycle = 7 -value_range = (-1, 5) -allowed_values = np.linspace(value_range[0], value_range[1], ground_truth_resolution) - - -# define ground truth -def ground_truth(xs): - # return (xs ** 2.) + xs + 1. - y = xs * 1.0 - y[xs < 0] = 0 - return y - - -# define variables -study_metadata = VariableCollection( - independent_variables=[ - Variable(name="x1", allowed_values=allowed_values, value_range=value_range) - ], - dependent_variables=[Variable(name="y", value_range=(-20, 20))], -) - - -# define experiment platform -def get_synthetic_experiment_runner(): - rng = np.random.default_rng(seed=180) - - def runner(xs): - return ground_truth(xs) + rng.normal(0, 0.5, xs.shape) - - return runner - - -synthetic_experiment_runner = get_synthetic_experiment_runner() - -# Initialize the experimentalist -random_experimentalist = Pipeline( - [ - ("grid_pool", grid_pool), # type: ignore - ("nearest_values_sampler", nearest_values_sampler), # type: ignore - ], - { - "grid_pool": {"ivs": study_metadata.independent_variables}, - "nearest_values_sampler": { - "allowed_values": np.linspace( - value_range[0], value_range[1], samples_per_cycle - ), - "n": samples_per_cycle, - }, - }, -) - -# define theorist -bms_theorist = BMSRegressor(epochs=100) - -# define seed cycle -# we will use this cycle to collect initial data and initialize the BMS model -seed_cycle = Cycle( - metadata=study_metadata, - theorist=bms_theorist, - experimentalist=random_experimentalist, - experiment_runner=synthetic_experiment_runner, -) - -# run seed cycle -seed_cycle.run(num_cycles=1) - -seed_model = seed_cycle.data.theories[0].model_ -seed_x = seed_cycle.data.conditions[0] -seed_y = seed_cycle.data.observations[0][:, 1] - - -# now we define the poppernet experimentalist which takes into account -# the seed data and the seed model -popper_experimentalist = Pipeline( - [ - ("popper_pool", poppernet_pool), # type: ignore - ("nearest_values_sampler", nearest_values_sampler), # type: ignore - ], - { - "popper_pool": { - "metadata": study_metadata, - "model": seed_model, - "x_train": seed_x, - "y_train": seed_y, - "n": samples_per_cycle, - "plot": True, - }, - "nearest_values_sampler": { - "allowed_values": allowed_values, - "n": samples_per_cycle, - }, - }, -) - -# running a new cycle taking into account the seed data and model -# TODO: need to find a way to incorporate the seed data into the cycle -cycle = Cycle( - metadata=study_metadata, - theorist=bms_theorist, - experimentalist=popper_experimentalist, - experiment_runner=synthetic_experiment_runner, -) -cycle.run(num_cycles=1) - -# plot output of architecture search -all_obs = np.row_stack(seed_cycle.data.observations) -x_obs, y_obs = all_obs[:, 0], all_obs[:, 1] -plt.scatter(x_obs, y_obs, s=10, label="seed data") - -all_obs = np.row_stack(cycle.data.observations) -x_obs, y_obs = all_obs[:, 0], all_obs[:, 1] -plt.scatter(x_obs, y_obs, s=10, label="collected data") - -x_pred = np.array(study_metadata.independent_variables[0].allowed_values).reshape( - ground_truth_resolution, 1 -) -y_pred_seed = seed_cycle.data.theories[0].predict(x_pred) -y_pred_final = cycle.data.theories[0].predict(x_pred) -plt.plot(x_pred, y_pred_seed, color="blue", label="seed model") -plt.plot(x_pred, y_pred_final, color="red", label="final model") -plt.legend() -plt.show() diff --git a/example/sklearn/bms/weber_bms.ipynb b/example/sklearn/bms/weber_bms.ipynb deleted file mode 100644 index 4bd85b941..000000000 --- a/example/sklearn/bms/weber_bms.ipynb +++ /dev/null @@ -1,815 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "3ba2ff78", - "metadata": {}, - "source": [ - "Example file which shows some simple curve fitting using BMSRegressor and some other estimators." - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "41b221c2", - "metadata": {}, - "outputs": [], - "source": [ - "# Import Packages\n", - "import pandas as pd\n", - "import numpy as np\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import GridSearchCV\n", - "from sklearn.pipeline import make_pipeline\n", - "from sklearn.preprocessing import PolynomialFeatures, StandardScaler\n", - "from functools import partial\n", - "import matplotlib.pyplot as plt\n", - "from autora.skl.bms import BMSRegressor" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "343e2f03", - "metadata": {}, - "outputs": [], - "source": [ - "def show_results_complete(\n", - " data_: pd.DataFrame,\n", - " estimator=None,\n", - " show_results=True,\n", - " projection=\"2d\",\n", - " label=None,\n", - "):\n", - " \"\"\"\n", - " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", - " \"\"\"\n", - " if projection == \"2d\":\n", - " plt.figure()\n", - " data_.plot.scatter(\n", - " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", - " )\n", - " elif projection == \"3d\":\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(projection=\"3d\")\n", - " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", - " if estimator is not None:\n", - " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", - " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", - " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", - "\n", - " if label is not None:\n", - " plt.title(label)\n", - "\n", - " if show_results:\n", - " plt.show()\n", - "\n", - " return" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "5bfd6747", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# load data\n", - "XLABS = [\n", - " \"S1\",\n", - " \"S2\",\n", - "]\n", - "data = pd.read_csv(\"./weber_data.csv\")\n", - "show_results = partial(show_results_complete, data_= data, projection=\"3d\")\n", - "show_results(label=\"input data\")\n", - "\n", - "X, y = data[XLABS], data[\"difference_detected\"]" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "id": "89405909", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZkAAAGlCAYAAAAoHYsYAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9d7Bk6V3fj79OPqfzzWFy2pnNSburnV0h8QW0lkBgCVBZRZUVChCUf6aAorCosgtkTKkovrahhA0GvkZyGQwIBQySUEJC0kqrlbQ7Oee5OXU8OTy/P053z00T7sy9O3d3z6tqS5p7+54+fbr7eZ/nE94fSQghyMjIyMjI2ADku30CGRkZGRmvXTKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRycjIyMjYMDKRyXhd8L73vY+dO3feteeSJInf+q3fekWePyNjM5GJTMYSWq0Wv/mbv8m/+Bf/gt7eXiRJ4mMf+9htHctxHH7rt36Lr33ta+t6jhkZGa8e1Lt9Ahmbi7m5Of7jf/yPbN++nYcffviOBMJxHD784Q8D8Ja3vGV9TvBViuu6qGr2dct4/ZHtZDKWMDIywuTkJJcvX+b3fu/37vbp3DKe55EkySvyXEIIXNdd09+YprmpRca27bt9ChmvUTKRyViCYRgMDw/f0mO/973v8dxzz9Hf349lWezatYsPfOADAFy6dImBgQEAPvzhDyNJ0i3lJS5cuMBP//RP09vbSy6X441vfCOf/exnlzzma1/7GpIk8Vd/9Vf8+3//79myZQu5XI5GowHAZz7zGR544AFM0+SBBx7g05/+9KrPlSQJv//7v8/999+PaZoMDQ3xwQ9+kGq1uuRxO3fu5Md+7Mf4whe+wBve8AYsy+J//I//cUvXqMPy1/5bv/VbSJLEuXPneN/73kelUqFcLvP+978fx3FW/P3//t//m8cffxzLsujt7eVf/at/xdWrV5c85hvf+AY//dM/zfbt2zEMg23btvErv/IrKwTxfe97H4VCgfPnz/P2t7+dYrHIz/zMz6zp9WRk3Cqb99YqY1MzMzPDW9/6VgYGBvjQhz5EpVLh0qVLfOpTnwJgYGCAP/qjP+IXf/EXeec738m73vUuAB566KHrHnN6epqDBw/iOA6/9Eu/RF9fHx//+Mf58R//cf72b/+Wd77znUse/9u//dvous6v/dqv4fs+uq7zxS9+kZ/8yZ/kvvvu4yMf+Qjz8/O8//3vZ+vWrSue74Mf/CAf+9jHeP/7388v/dIvcfHiRf7wD/+Ql19+meeffx5N07qPPX36NO95z3v44Ac/yM/93M+xf//+9biMvPvd72bXrl185CMf4aWXXuLP/uzPGBwc5Hd/93e7j/md3/kd/sN/+A+8+93v5md/9meZnZ3lox/9KD/wAz/Ayy+/TKVSAeATn/gEjuPwi7/4i/T19fHiiy/y0Y9+lLGxMT7xiU8sed4oinjuued49tln+X//3/+XXC63Lq8nI2MFIiPjOnz3u98VgPjzP//zFb/79Kc/LQDx3e9+97p/Pzs7KwDxm7/5m7f0fL/8y78sAPGNb3yj+7Nmsyl27doldu7cKeI4FkII8dWvflUAYvfu3cJxnCXHeOSRR8TIyIio1Wrdn33xi18UgNixY0f3Z9/4xjcEIP7iL/5iyd//4z/+44qf79ixQwDiH//xH2/pdbz3ve9d8lxCiBXX4Td/8zcFID7wgQ8sedw73/lO0dfX1/33pUuXhKIo4nd+53eWPO7o0aNCVdUlP19+LYQQ4iMf+YiQJElcvnx5yfkB4kMf+tAtvZ6MjDshC5dl3Badu+d/+Id/IAzDdTnm5z73OZ588kmeffbZ7s8KhQI///M/z6VLlzhx4sSSx7/3ve/FsqzuvycnJzl06BDvfe97KZfL3Z//yI/8CPfdd9+Sv/3EJz5BuVzmR37kR5ibm+v+9/jjj1MoFPjqV7+65PG7du3iueeeW5fXuZhf+IVfWPLvN73pTczPz3dDf5/61KdIkoR3v/vdS85zeHiYffv2LTnPxdfCtm3m5uY4ePAgQghefvnlFc/9i7/4i+v+ejIylpOJTMZt8eY3v5mf/Mmf5MMf/jD9/f38xE/8BH/+53+O7/u3fczLly+vGoa69957u79fzK5du1b8PcC+fftWHGP5cc+ePUu9XmdwcJCBgYEl/7VaLWZmZm74XOvF9u3bl/y7p6cHoJsXOnv2LEII9u3bt+I8T548ueQ8r1y5wvve9z56e3spFAoMDAzw5je/GYB6vb7keVRVXTWEmJGx3mQ5mYzbQpIk/vZv/5YXXniBv//7v+cLX/gCH/jAB/jP//k/88ILL1AoFDb8HBbfua+VJEkYHBzkL/7iL1b9fadoYT2e60YoirLqz0V7KnqSJEiSxOc///lVH9u5znEc8yM/8iMsLCzw7/7dv+PAgQPk83nGx8d53/vet6LyzjAMZDm7x8zYeDKRybgj3vjGN/LGN76R3/md3+Ev//Iv+Zmf+Rn+6q/+ip/92Z9FkqQ1HWvHjh2cPn16xc9PnTrV/f3N/h7Su//lLD/unj17+PKXv8wzzzyzYQKyHuzZswchBLt27eKee+657uOOHj3KmTNn+PjHP86//tf/uvvzL33pS6/EaWZkXJfsVibjtqhWq9277Q6PPPIIQDdk1qlYqtVqt3TMt7/97bz44ot8+9vf7v7Mtm3+5E/+hJ07d67IqyxnZGSERx55hI9//ONLwkNf+tKXVuRz3v3udxPHMb/927+94jhRFN3yOW8073rXu1AUhQ9/+MMrrrcQgvn5eeDajmjxY4QQ/MEf/MErd7IZGauQ7WQyVvCHf/iH1Go1JiYmAPj7v/97xsbGAPi3//bfUi6X+fjHP85//+//nXe+853s2bOHZrPJn/7pn1IqlXj7298OpCGm++67j7/+67/mnnvuobe3lwceeIAHHnhg1ef90Ic+xP/5P/+Ht73tbfzSL/0Svb29fPzjH+fixYt88pOfvKXwzkc+8hF+9Ed/lGeffZYPfOADLCws8NGPfpT777+fVqvVfdyb3/xmPvjBD/KRj3yEQ4cO8da3vhVN0zh79iyf+MQn+IM/+AN+6qd+6k4v5R2zZ88e/tN/+k/8xm/8BpcuXeJf/st/SbFY5OLFi3z605/m53/+5/m1X/s1Dhw4wJ49e/i1X/s1xsfHKZVKfPKTn1zR85OR8Ypz1+raMjYtnZLd1f67ePGiEEKIl156SbznPe8R27dvF4ZhiMHBQfFjP/Zj4nvf+96SY33rW98Sjz/+uNB1/ZbKmc+fPy9+6qd+SlQqFWGapnjyySfFP/zDPyx5TKeE+ROf+MSqx/jkJz8p7r33XmEYhrjvvvvEpz71qVXLioUQ4k/+5E/E448/LizLEsViUTz44IPi13/918XExMSS6/GjP/qjN79wbdZSwjw7O7vkcX/+53++5Dovfk3PPvusyOfzIp/PiwMHDoh/82/+jTh9+nT3MSdOnBA//MM/LAqFgujv7xc/93M/Jw4fPryiDP29732vyOfzt/x6MjLuBEmIZXvwjIyMjIyMdSLLyWRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBiZyGRkZGRkbBjq3T6BjNcXQgjiOMb3fRRF6f4ny9n9TkbGa5FMZDJeMYQQhGFIFEX4vt/9uSzLqKqKqqqZ6GRkvMaQhBDibp9ExmufOI4Jw5AkSZAkiSAIkGUZIQRCCJIkQQiBJElIkpSJTkbGa4RMZDI2FCEEURQRRREAkiR1dzSSJK36+I7gdOg8Ttd1NE1DVdVV/zYjI2PzkYXLMjaMJEm6uxegu0vpCEhn57IYSZJQFKX7747ovPDCC+zfv59KpYIsyyiKsmS3k4lORsbmJBOZjHWnIwxhGC4JgS1/zK0IQ0d0Ov+rKEr32EEQIElSV3Q0Tes+JhOdjIzNQSYyGetKJxR27NgxBgcH6e/vX5cFv3OM6+10lovO8pxOJjoZGXeHTGQy1o3OYh/HMc1mk56ennVb3BeH2Zb/vCM6nd8nSUIQBPi+n4lORsZdJhOZjDum0/sSRRFJkiDL8nVFYSPpCEcmOhkZm4dMZDLuiE54LI5jgK7AdMqT14vbEa3VRKfzn+/7BEHQPedMdDIyNoZMZDJum84OYfHuZTHXE4W7tYAvLkBQFGWF6Cze6XRKpTs9OpnoZGTcHpnIZKyZTnisUz222iJ8s53HWhftjQi/3Uh0PM/rPiYTnYyM2ycTmYw1kSQJURStCI8t527kZO6UWxEdz/OIooj+/v5MdDIyboFMZDJuiVvpfVnMeovM3SokWC461WqVarVKoVAAUpFdntPJRCcj4xqZyGTclNWsYW62iL4adzI3o/O6JUlC07Qlvmu+7+N5XiY6GRnLyEQm44Ys7n3p5CduhdfCTuZmLBfbjujEcdwdZ7A4p9OxwrkVkc7IeK2QiUzGqlyv9+VW2QhR2Gwis5yOeHSEeLHoRFHU/f1qvmuZ6GS8VslEJmMF1+t9WQsbsZN5tXE90YmiqOtC3RGdxb5r2ViDjNcSmchkLOFmvS+3ymt5J3Mn1yQTnYzXG5nIZAC31vuyFrKdzM25mehANjU049VPJjIZ6xIeW85reSezUVxPdBY7TGdTQzNebWQi8zonjmOuXr2KZVmUy+UNd02+k+O93lhNdDrVfmEYYts2rusyMjLSFZ1samjGZiO7BXqdsvgOeWxsjEajsa6L081Exg8iDp+7uiYheq3vZG7G8so027aZmJggDEMcx6HValGv12m1Wl1ngtf7Ncu4+2Q7mdchy8cib0S4RZKk7vGXMz0zw//3qS+xYAcc3b2Fd/zA45SLxZs6CGwGNtui3QmfwfUHuGVTQzPuJpnIvI5YvAgtrh6TZfm6gnC7rLaQJUnCuXPn+L9fexE7ktB1jaNnr3DmwmWevW8H20aH6Onpobe3F8MwVhxvsy3wd5vlI6yzqaEZm5FMZF4n3Ci5v1EOx4uFy/M8Dh8+zMkr0wRagbKpAoJKRUKIhOPTDlbRw3HGOXnyJLlcjp6enu5/Gatzs91fNsAt426TiczrgMXWMNez5d/Inczs7CxHjhwhUS3mAxVdhzhOFj1WBkXmpUtzPPPQPp596CHq9TrVapWLFy9y7NgxFEUhSRIMw6BSqXRDRK9nlu9kbkQ2NTTjbpF9U1/D3Ko1zHpPsYR0UYvjmNOnT3PlyhW27NjFi2cnSQRcb80SAr55+CxT83Xe+uT9DAwMABAEAYcPHyZJEs6ePYvneZRKpe4up1QqLQkTvV64k/fsRqKTTQ3NWE8ykXmNspbel40Il0VRxNzcHIZh8Njjb+Dvnj/KQsOmmDdpuf4N/3Z6ocHffOW7vOPZR6gUc+i6jmmaVCoVtm3bhuu6Xcv9iYkJoiiiXC53RadYLL4uekfWspO5GYtF51amhnaq3DKH6YybkYnMa5BO5/6tWsOsd+J/ZmaGK1euYBgGTz31FP/3m4dYaNgAtBwf01AJEIRRKoC2H1FzQ7wooZI3cYIWOV3lL7/0Am9/+iF2jvQvOb5lWViWxejoKEIIHMfpis6VK1cQQizJ5+Tz+XUvz94sbNS5ZFNDM9aLTGReQyye+7IWa5j12skkScKZM2e4evUqQ0NDCCF4/sg5Lk7MLXmc54dIgGXoTNUcxmoeUZxg6irjVQdVhq0VkxLwma+/xMEH92KxenhIkiTy+Tz5fJ6tW7cihKDValGtVllYWODChQvIsrxEdCzLek0shOu5k7kZtyI61WqVXC5HuVzORCejSyYyrxFW631ZS1L4Tncyruty6NAhkiTh4MGDzM7O8t3j57hcC1d9fBQn+GFEI0zPvZLXURUFI4xoehGzzYCioQISzx85h0nAM48cINcKyOkKOX31HIwkSRSLRYrFItu3bydJEhqNBtVqlenpac6cOYOu613BWa1c+tXC3SzpXk10JiYm6Ovr617P1cYaZKLz+iMTmVc5ax2LvBqyLHdzN7fD9PQ0x44dY3h4mAMHDqAoCkdOn+foxUlKPf3X/Ts/Sqg1XXqLOWRJ4Afp5E1LV3DDGD9KMDWFOBG8dGWelyZe5rFHBb2lPPcM5nlgtIim3Dj3IssylUqFSqXCrl27iOO4W7k2Pr56ubSmabd9LV5JXsmdzM1YLDjZ1NCMxWQi8ypmeXL/dodf3W64LEkSTp8+zfj4OPfffz8jIyMA1FoO//TSGVpuwJatJk3bBSRA0PRiml5InCQo7VMVgBDpXW8cx4vEMv39VNNnzk3IJR7nzp5h986dNLwISYJHtpbXdM6KotDb20tvby8AYRhSq9WWlEsXCoWu4Cwvl95sDaGbaYFOkmRJ71U2NTQDMpF51XKz3pe1cDuJf8dxOHz4MEIInn76afL5PAB+GPGZf/4+fpjuSpq2R9408IKQsarLZN0nihMSIZAkUBWN2bpNJaejyjKaplJzPXpyKoYqE0QJVTvAVCVMVUEkCafPnmV0dJQzpsKBoQKmdq0Md6YZ4IQxeV1hoKDf9LpomsbAwMCSculOEcFq5dLr3U90J2w2wbvRziqbGvr6JROZVxl3OhZ5Nda6k5mamuLYsWOMjo5y4MCB7sKRJAmf+9Zh5motOjsXANsL8GPBjB2hqTJFU00Xa0lmruVhKDJ1N+z+zUA5T68BIBHGMVEiUCXQNKVbkXb56hgL9RZv2deLqVk4QczzFxa4suDiRwmGKrOz1+Lp3b3Xzd+shq7rDA0NMTQ0BLCiXDoMQ1RV5dKlS3e9XHozhcuA7ufxVljLALfl4bWMVxeZyLyK2Ii5L3Drif8kSTh16hQTExM88MADDA8PL/n9N4+c5fzYTPuYaXNlh6rtE4QRI5UCru+jKDIIga7IFE2FvrxBlCTIkoQfRUy2ZBy/SaEtEIqmEwQhmpYmlcNYUK1W+Yevf593vfkxDk+5nJ62GS0b5HQFJ4g5OW1jaArP7um97WuzvFz63LlzVKtVms3mK1IufSM2m8jcyflkU0Nfu2Qi8yohSRKmp6eZnp7mwIEDr6gtP6ThsUOHDiFJEgcPHiSXyy35/YmL4xw7f3XxUfGihAU7QJUlkiRdNFzfx9R1ojgi6Ex/lCR6chqJEFycc5htBWiKhK5pzLRCJFmmZfsUDRVTCIIowY8SRssG9ZbD//zct6A0zNaha7uWnK4wUNC4MOfw8JYSRfPaR90JYlp+RE5XKBi3/hWQJAld18nlcjzwwAObolx6s4nMei362dTQ1w6ZyGxyFo9F9n2farW67gvLzWxlOuGxLVu2sH///hVf5Im5Gl/8zjHiOKGYM6k2Ha7WfCbqMVNRE1mS0BWJOBEEUYxppH5lQkCcCEpmWs1VdyPm7YCSqaIqaeisUDKYbYVYqkQi0sZNTZEZKRkMFtNdjeMHnD52EjneRXHXtu71MTWFphfgRwlFIEoEL12pc2KqiRPEmJrC/qE8b9hewVDXvjjd7XLpzbaTWZz4X29uNjUUMtHZrGQis4lJkoQoirrhsY5J5HpzvXBZHMecOnWKyclJHnzwwW6eYjEN2+Xvvv4SUdvwsul4tEKYsSNUCXrzOnEiqLkhIhGEKEzXbBACIUkMli0qufRj6IYxiaAtMJ2CBIEsYnKWwYApKJYLyBLU3IiTUy3iRFA0VSTg1OVJWrbDI/fuQ1UV6m5I0VQpGOnu5tBYnW9dWKBsaQwWDZwg5sWLNeJE8AN7+9Z0vVbjlS6X3mwis547mZtxs6mhQLcpueNtl00NvTtkIrMJuV7vy0aJzGo7Gdu2OXToELIsrxoeAwjCiL/7+kvYi7zIEiG4NNcgZ2jEpHeYiixRsTTcGHpNmUTXiZKEvC6jKjKtUCIMfZJk0TkICVVRCMKQJBFEIqSSL6BrMhfmHKabPpoiI0kwWffQNJ1qw8Z1PebqNvfs3YOiGTy2rYypKXhhzInJFiVLo7+gA2Co6d+fmbZ5eEuJsrW+/TF3Wi59M17JRf1W2MidzM1YbZbO1NQUs7OzPPjgg93HdHY6i6vXMjaWTGQ2GYutYWBpv8FGDBfrPMfi405MTHD8+HG2bdvGPffcs+pCJoTgH184yvRCA0jDXkIIBBDFApIYIUDXNIIwxNRVGg2PgmHSm9fxw4jzsy3mbYc4ERiGQRKFJELQ8iL6Sjn8IA11IUFJl7G9AGEUmHciiqbabcRU8yrTNYdyTkORoN60OX7iJD/55ke5b6QIgB3EOEFMX36pkBQMlZrj0vLjrshEiWCs6lJzQ0xVYXuv1c313EnZ8FrLpW/FXXozLZKbaWe1uDlUVdVsauhdJBOZTcTi3pfFoYAOG+GWDNd2MnEcc/LkSaanp3n44YcZHBy87t+8cOw8lyZnCeOE8ZrLbDMgFoKSqSJJ4EcCKUkIwhDL0Gk4PqosYWrpa5pqeMw0A0qWhianr8sRKnEUoRsGUzUbAWiyxEjJxErSkGG15RELQd40CMIIWZIRSYLezqkcGCqkJc+yxPeOnGCu1mDfzq0UTQ1Tk2j5cbevBtIcj6Up5Nsi4gQxXzk9x9kZm7h9rYeKBj+0v58tFXNdr/vNyqVv5i69GftkNtvOqnM+2dTQu0cmMpuAtcx92aidTBRFvPDCCyiKwsGDB7Es67qPP315kuePnEWSJC7XAq7OO1iagizBbDNAIEgSQRgKCmGMnwSEicRAwSCnqyRCMNsMMFQZTe50iIOlCgQKwwUNkU8LA/K6gqpITM62kKUYLQciSfCDENPQ0+eJIhIh0OR016cpElUn5OK8w3cuHaPn6Dj79+7GMlS8MEGWoGiq2H7MrB3w+LYylVy6i/n+lTonJlts7zG7ljaXqy5fOzvPux8bWfdrv5i1ukvfzfDUamy28+k0Kq/GYtHJBrhtLJnI3GXW0vuyUSKzsLCAbdvs2rWLffv23fBudGq+zj++cDT9O9tnYqHFYCVP3L4btDSFeTugoMv4MSiaRhyFbCkabO8vEMUJIklIRJqrWYymqoSej4Rgx0CJlusxXvWYqHvUWwGyJFEJPCQkml6EaejIiozvpQ4Cve1QWBgnXJx38MKEHktD8ltcuXiO8uBW7hntIUkEkw0fU1V4w/YyT+6oABBECWdmWvTmtO5uR5EltlVMxmoeE/Ubz8FZT27FXVoIgWVZGIaxKdylN/NO5kbcaIBbJjp3TiYyd5HOh/huzX2J45gTJ04wPT2NYRjs37//ho9vOR6f+efvd7vunSD1GUvCENM08f10ETZUhTiJuadPo3fAQmAyVff51rk5BBI9eR1Fphu6kki/6F6UoMkSliZjux5uJHNx3kFXZYpGuquwgxhFkigYJpPVdEaNqWtsreToy6cJ/bob4QRxKjBSet0C3+fiuTP0mffwcz94gFaQkNMVSov6Z6JEEMViRTmzIkvEQhDGyYovjBvGqLJ0U6POO2W1cukjR44ghNgU7tKdkuLNtOiuxYFgMTcSnWxq6NrJROYusLj3ZS1zXzq5k/X4MrdaLQ4dOoSmadx///2cOXPmho8Po5i//er3uDDTwAkiVFkmaX/5hADf99FUlUQkRElIxdLxfBtVljg1bTNR89BVGVWWGFuwu6W7VSdEVyRkVcX3Q7b2mN0k+/mZOrquU9CgFfkoMhQtDTuEPktmuJAnFpA3FCo5DV3VcP2gm0vpXKJOlRpJzEvHTnFse56n7tuFJEmEccLlBRc3iKlYKoNFnQvz7pJKs6oTUjRU+vM6tVTXuFp1eelqnYmaj6ZI3DtS4NGt5TVZ2NwJHWPJfD7Pzp0777q7dGch3mw7mfUYy71YdFabGrpYdLKpoSvJROYV5k6sYRZ7hN3Jl2dsbIyTJ0+yY8cO9u7dS71ev2ESWQjBP3zrCF8+NsZ8y0eI1JWsc8dfc0PKlkoQRfixQFFUei2ZMBQ0vIiZpk/RVLvJeUtXmGt6DJZzWIrAT2SSOGL7YJ6BdnkxCLwwAQGynM6aCaMITVWJPB9JhoF2M6YQgrmmT9NzyFk6cZKgyhJ+lFDOW3i+jwC8KGGkZPDto+eYqzV59L69fPn0AmM1j0SArsoM5DVMVebcnE3ZUHHDhFgIDu7uoZLTqAGzTszXj85Q90J6czp+lPC1M/PMtQJ+9IEhVPmVWVgW32wsL5eOoqibz1mPculbORfYXNVuSZJsiLDeygC3xQ7Tr/exBpnIvIKsdSzycjqPv92qoiiKOHHiBHNzczz66KP09/d3j3ujY754/AL/+P1zLDgRPXkDCYEQUHfDNGGvydTctPHNVBV29OXZ0aNzpjaLE6QGl/qyEJSlKTQdn6ceGMH1AuI4wY9iJhs+YSzI6TI5XWHBDlJ7+CRBU5T2LiV9Hkj7cs7N2Ew2/PbOyiZvGciyRChkZuo2SltwcrrCUCkVptNXpvjC0TFKQ9vYP9qLpsjYfsTVmseDo0WKhsp43WegaHBguMD+oXz33M8tRNQJ2TNw7WdFU+XMjM3DVZedfSt7ijaCG+1oVVVd93LpG9EJ426mRfR2w2VrJROdG5OJzCvA8t6X2/1wLd7JrJVms8mhQ4fQdZ2DBw9imtfKcW9kkHn26jRfe/k0M00fXU59xjRVJQhDSpZKzQnZ3pNDV2XiJGGgnMfxfC7NtghRyUupt3IiBPKi1xwlgmJOx7Y9VFWhGQmOXG1gB+3ZOKS2MJIkUXNDiNIFI/ASenMqZSv96M40fSbqPgVTQW/nRZwgQlJUhgoqTVcQJoLRcmpD0/Eqa3oRE/NNHO88QzmZgb5e8oZKT05jsuHz9qcHl5Q6L2baienpXfrVsTSFKBZUnZCdt24ecMfc6ufoTsulb8ZmDZfdjfO5kehcuXKFZrPJ3r17XzdTQzOR2WCWj0W+k/kYtyMyQohujH7nzp3s2bNnxRfvet5lYzNV/u4bh9pfkI6zcoIfJli6juOlYSipbR9TyBkcujzPWNXF8SM8N2Kr6mOoCnUnpGxpyLKEH8bEAoYKWhrGCiKOj9eJUOjNpV34cZIu2L05DVWRaXoJge+zrSKzf6RMksQkiWDeDpFlugIDUDQ15uwAXdF5cnc/ru+TytY14kSQCIFIYk6fv0jLdti5bQuGmjo4B7HAvE6kJa/JeNHS9yBJBBLclgfa7XInfTJrLZe+mbv0Zg2XrUdO5k5Z/J3vtCp0inheD1NDM5HZIBY3e63n3JdbteWHNDx2/Phx5ufnl4THVjvu4mPW3ZB/PDrO33z5O/i+T09Ox9Bk6k6IpSlIEnhBQCypGGpMydQo5gxOTdS4MOtgajJ9eY1q6FBr+RiaQilnUHPS6jNNkdk1UGAgr3afr+lHlE0V0zDwgwBFlsjpCl6U8AO7+xmfnCFJNEYG8kRRhKGpoKRisfiyCglkJf0Ch3GM5wcUcyYN2+sm+oVI80K6IpNICp4XcP7SVZotm3z/KDv7C93mTEh3YeM1j7obUW+E7KwonHESqk5IxVKJE8FYzWOwqLOjd2l/UcOLmKynIZOtFZP8Glyfb8Z6VXPdSrn0zdylOz0ym2lRvFs7mRsRx/EK484bTQ19LYhOJjIbwEbNfekc61ZEptls8vLLL2OaJs8888wNy1kX72T8MOZ/v3CFL75wmNDzUGSZiZqHpkioisS8HaCrMlGcLioHRsoMlCxabsBEzUORU5v9OI6RJajkVKpOyN6BHPeNlqk2bUZ6ioj42u4uEWmFmixJ+EGApmpESYwsJQhJxg1CDE0iDCUSke5wvNDD0hWGyjnm7Fo6aRMwdYOm6yFLEkVDRQBNx0dWVE5O1Jl30kqgiqXRX7KYrDooctrAefrqNMWFBs8dONjt4Wl6EZ8/PsO5OQc/SvDsJoOW4KHdJc7OOlyYd5AlGGy7AiwWkZev1vnWhSo1N0Qi3e39wN7ertXNerARi87tuEtvtvJl2Nwis5jrOUwvFp33vOc9vPe97+U973nP3TjtOyITmXUmSRKmpqYA6O3t3RBb/huJjBCCsbExTp06xa5du9izZ89Nz6GT+BdCcGKyyT+/dAI1cimV8gRBgKXJzLcCBooWeT11NzY0jcGiyWjFJEoEpq7iRzGqcs3GA+jmYRIhsBTBlm39zDdsZls+NSdAkWRyhoKpyjhBTN5QCKMQWU6bOfuLKqkTjYQfCw5dbVB1w26Op2go9JfyzNZbFHMW9bpNIgQjJbPbxR9ECUcmarRCgaWkgjrTCsnrCdt6TGpuSBAJenMaI0WF7x46Sr/5ILtGB/jns/Mcm2yytZL6l40nDpdrPjuCmPe8YZS59uybrT3WklDZ5QWXfzozjyZL7O7PIQRMNXy+fGqO3rzOcOnOe1heqYX9VtylTdNMr+vMzIaXS98qrxaRWc5qojM1NbWu1YCvJK/Os96ELLaGmZiYwDAM+vrWPwN8I5GJoohjx45RrVZ57LHHbvn5F1etffv4Bebn5+nL6/h+gKapxHGMrsq4YczDW8vdv3OCmKs1D8dLLfX7y3kuz9S7oSYh0uZGWZLI6So5U2eubnNiqsm5iQWiOEFWZExdo2RpeJEgcBJURSYI0zDXvsEikL7eq/WIZiJRyWmoskSUCGpOyIAS8OiOfq7ON8nlUpflgYLRFbg5O6DuRt38jiTLFIDpustQUePhrSWSBJSOmAURf/eNl3lo305OzSsMFoxu/4upyvTlUifoN+/t5cBwYdVrenamhRfGbO1UoEmwpWJyZsbm4py9biJzN1itXHpiYoILFy68IuXSt8pmFRld12/+wEVIkoTjOKs6ob8ayERmHVgeHlMUpfv/15vrlRs3Gg0OHTqEZVkcPHjwlru9hRCM130uNeHrxy9z8tzFtAkmTekThhGKLCOkdLfRYaLmcn7Bp257SND1A8tZJlUnwFAk/DjtoRkuGQyVTPwg4vzUAqeu1ugpmOQtA8/zaHkBM1WP0YJCImskQmH7cIkeU0aXYoo5i8m5hLqfUC4o3T4UVZYommrava8KntyZLnp+GC15jbYfIUu0CwoSDFUFCRQpDYdJSCxv2BcCnj96jiuuxhvu27vkd4YiEUTJiuT/Ypp+vKQYoYMigR2uj2vDZglRqaraFZKnnnpqw8ulb5UbeZfdLW6nGEEIgW3bFIvrF2Z9JclE5g5ZrfdFUZRuufJ6s3wnI4Tg6tWrnD59mt27d7N79+5bXnhafsRff2+cI2M1zl0K+eThb1AyZHRVouZElK3UUbnpBSSJYPdQuoh7YcyFaoDt+fTltW5CveZGbKmolE2LastDkmBXf47d/XlkWWJ8YpLLMy1ylkkhZyGEoFIuYxo+c3ZAoaAxYCRISUSjOoFtGiSW1XUTEJK0wu9MlSGIIYhi/DBCliXylo7tBt3H6KpMZ1SNYaQ7NABF1TDU63/hC6aGO1Pn+e8f4dnHHiBnpWXfDT9hqKzSm7t+SGikZHBsorGkdDtK0lEI1xpO74zNIjKw1Bxzo8ul13JOm01kblf4bNsmn8/f/IGbkExkbpPFvS/LrWE2yshy+bHDMOTYsWPUajUef/zxbvjiVvn7I1N8+8ICAzmZuDqFruvMtgIqloaupHYqkJbl7unPUdSglDeZn7Opt1x62wIDacWYoco0vYhn95aJIouJsSbbB3JYusr5i5cQAoqlEg2/c20Evh9gmAayE6HpBltHywRhTDkMcF2Xpu2yUGsgEoGCQtMLKZlq94saoqArcTeclSQC2/URssZUtYmuKvTkNExNxg4FggAEtIIIBGztK6MqcneyZ5Qk1JyIWAj6ihYjJZ1zszZf/vZLPHhgH06Y4EXwhh3lFZViQgjcMEFTJA4MFTg+2eLcrEN/XiMRMO+E7Oqz2DewfovFZhGZG5ljrne59K2yWUXmdnZxjuNkO5nXE8vHIi+vHtuoCZad50qShHq9zqFDh8jn8zzzzDNrjvNWnYCXr9boy6lMXr1AEPj0l4pAgBvGPLGjhzBJSBIoWyo5Pf2o+GFElKx+By23+1ugbSqZJCgkfOfYOVTDYmSgl0EvYn6qmfaVtA9hOz6apjJQNLv9K0Eic6UlMdtSESKPSUhJi5j3fVzfRxEJip4mm+8dLqK2F5M4EZyeaTHd8EkkhSSOKZsq23tyTDX9VDjbJcw7ey0sBZDAMjQmaw5npls0/RhV1ZCmW4yUDPYN5plq+Bw7dZrR/l6e3TfAG3f2LHntZ2dsXrhYZbrpY6gyD28p8dy9/RydaLYr0CSe3lnhiR2VFf5mcSKYbvrEiWCgoF+3CXQ5m2mezK3a/K9HufRazum1IDJBEBCGIYXC6vm/zU4mMmvgemORl7OROxlJkpienmZ6epo9e/awa9eu2/oCtrwIL4ix5ydpNJoI0g9zwTKYbg8MGyqm4aE4EUzWPZwwxtRUFCm1iYmEjCZ1TDLTu/gdvRayJBEDiaTw9y9dRjKLiFBw1a7Sm9ep5DQW7JBOiicWMFo2GK7kQCQ4fsiR8QbVdl+OLEnMOgmGBPdv7WOu5RMmkIQeZTUmbsww7mlYlsWMJ3OlFlIwVExNAkmn5kSodshDowVafnpjUDSuealFUYLrR1xcCGj6MQPlHGEQ4EcSl6se9w4VeGRLiSgRNBsLzE4FxPEDKHL69Tk3a/OpQ1M4YUxvTsMJE75wcpYndlT4iYeG8KN0AV6tUXOs5vLV0/OM1z2SRNCb1zm4u4eHtpRu+h5upnDZ7dr830659K3kGzvf1c0mMreTk2m1WgCZyLzWWZ7cv1HjmSzLG5L4D8MQx3FwHIc3vOEN9PT03PyP2gghuLzgcn42dUbe0WsRtKpcnZiiYKrdfvi641HIXWsa9KOYl6/UmW35SEo6uTKvKxQMlQUnQNc1RBzhRwlFQ2VHX444jpmfm+FcLSFSLPpMBVPX8YKQ6abP9h6L4WGD2WbahzNY1Nk7XMb1/DQHFEDVDenJad18hmQqLNgJYSI4uHeAIIzImTp+EBJGEa7rYTtOamcTC0KhQqSiqAq9hRx1N6Tlx91xAMtZcELmmw7DPQXCMJ2NY2oKQZww2fDYUjHRFAlZgquzNf76yy/yjmcfoVLM8eLlGk4QsXtRGCyvKxyfbPL49jLbelYfANf0Ij53bIbpZsBo2UCRJGZbAV88OUvRVNl1Cx5om0Vk1mtg2a2US9+Ku/RmtLmB28vJtFotJEnKqsteyywei3wrjZUbES6r1WocPnwYgN27d69JYOJE8LcvjfO1M3PYfgwSaJFLfWqcIBY0vYgwgaYfEScSeysq5ZyOEILjEw2mGj6D5RxJHCEMrWuMee9IgZmGj2RaFDTBtp4cGiHj49NEskErhIGKhiJLhFGIpioULYM5O+DAUIHtPQaSJFPMmTQdF5AQAmYaNqqqszjHL0lpBVjDi7qC6HgBmqqQMw1kWUE3LayaTA6BQlpOHvsxtm1jxzJ+r0KgiXZocel7GMYJkiQTxxGqmpZtJ4lAlWWCKEEgkBb9zVy9xd9942Xe+OA+pup+tyenQ9FUmWr4zNvhdUXm/Fxq7LmnL4fcfrFbKiYX5hyOTzRvKjKbbSezEedyu+7Sne/fZhSZte5kOuXLm+213CqZyNyAWx2LvJz13MkIIbh8+TJnz55l7969zM/Pr/lD+t3LVb54YoaypTFaNnFcl+++fJEkidjZl2O+FWALCV2R2TGUZ1dfHj+IECK1tS/lTZI4rZaTkCiZGjU3xFQVntqVfvlzpsbUzBwTc3OMjgxTDxWSMWdJNViSxMhCkCgqYduOP2dotByPxYu+oShEoYuay3U9yiAVy5JlLClRDqOYWJYoWAYt16NgKCw4IT05g3y+QBSFOF5IFIS4dpMFL3WFNk0L00wT0oqikNMVdE3BCyI0RUZWZDRNwbMDRsrmEoEBKOQMFhotPvf8IeZEgULvwJLfh3GCIqUD2K6H7cdp+feyijlTk5m3w5u+r5spJ/NKTcW8VXfpUunm4ca7we2ITKvVWrdiiLtBJjLX4U6sYdZrJxMEAceOHaPRaPDEE09QqVSo1WprPvb3LtdIRGprEkUR58+do2SpzNRDNEXi2b19nL3QYNtoiXzu2l13mCTESYLc7s251sWf9pF0hoMlScKFS1cJA4979uwmTKCoxGhyOjmysKhfxAkjCrrKYDmP6/kEUYxA0PJjnCBt+uwvaJgLMvMtl4qlI6sKTivB1HV6zKULWSIEC82AsOYy0lNke49Fw4uoeTGWmk6z9GPY1ldkz0ghdTaIY2zHodGoMzMzi65r9FXK5JWYOSfB1NLham6YUMyZbKlcc6wWAnRVwXavmW769VmuztYx799HX8EkiBKuVl22VMwb2v6nUznTptLFM2jsIOaB0s0LOTbTTma9wmVr5Xrl0vPz8wA8//zzr0i59K3QyROtVWRezeXLkInMqqx1LPJy1iPxX61WOXz4MKVSiYMHD3arx27n2C0vQm/bqZw/f7474wJZQpIVFFnCVNMelChJWLDTwobBkkXFVBirugxX8kRRiBDgBAmGKlOxNILAZ2pqCl8oBEY/nzsxi6HrDOUVenRBM0xIRISmSN0E+K7+dBxA3tRoOgFHJ5pM1n2CON3d9OV1dvfnuLzgMm+ni7lp6JQlj/7CtbBU04s4Ptmk5oYkAozJFrsHijwwUmKyFVBtpVMrd/Tk2N6bA9I8mqTKKFYBOzSYsFsovsz0dIuSEhKImKarEioqPXmDnX0G2/oKtBwPQXqNkiRJnZqjVJBGyybunMNLh48zun0nOdNkW4/F2+8fvKEr856BPNt6TC7OOQyVDBQJZlsBZVPlgdFbK1fdLCLzSu1kbkanXLpSqTA3N8cTTzzxipRL3wqd7222k3kdc7tjkZdzJyIjhODSpUucO3eOffv2sWPHjiXncCvHbnkRRycaeGHM9t4c9wzmOT7Z4NLly9TrdaBdapwk5DSJYs4AJGaaPmfmGjT9CElA3tIZLmpYmsxUzSZnaGl4KknYN1hABC5jszNouRLjLYVqtYGpKbQcj4arIkdwYEue6VaIHyX05HR29OUYKekULJN6y+b8vM+VWoilSOQNjTAWTDXSEQJP7axQdyMUVQXfRhOpC0Hn/I9ONKi5ESVTbe88Yk5M1HjD7n6e2F6h6QWosrRkjg2k82ZeHmvQcCPKhbTZsxkpiILFw3ty+J6H47qEfpPmXJPzdpVKqYiuGyDJnJ13cedrRLFAU2VGSgZ7+nPpgLbWBG/efz/P3Lt1xaC2DrafNo3mdIV3PDjE18/Nc2neJRGCrT0WB3f3sLWyeh5n+Wdlsyw8d2sncz06O4ZXqlz6VlgcFVkLjuNkO5nXAjfrfVkLt5uTCYKAo0eP0mq1ePLJJymXyyseczOr/yPjdf7n81eYangIkToiP7ilhBm1OHFhDFOTSQA/TBgqGQwXDZqOh6SoHJ5oEYnUvdgwdKotl0vzIfeNFLH9mAUnoFTQ2d1fIHGqzM21GB4e5koTqnaD3rzezVxEiWDOUbF0hWf3lrohIUmS2tb7DmEsuDJvY8hQypkEYYiuSJRMlQU7wAkShssmmqIwX3VotUKGTJ0gCJlp+tS91JWgk/exdAUhq5ybrDOU66W3YNFy/RXXaKLu0/Ai+gs6sizIFyxcP2DeDqj7JsPlEpVyiU6zqOu6LNTqSEnMhYZg2kmo5OW2KMLFthPz7v50ITh84hQFNeINB5aWl4/XPJ6/sMCleRdZggNDBZ7Z08u7Hhmh6oTEiaAnp61wNbgemy0ns9lEZvlivlHl0rfK7YpMZyfzauV1LzK32vuyFm4nJ9MJj5XLZQ4ePHhdF9sb7WRqTsj/983LzLZ8dvRZKJJEw4v45+NXqQQz7BlImwo1GXb35dk9kOu6Jo83IwJh0JfT0HSNMAjai31I3Q15bHtazRZFIVNTU1iGypYtWzFNnbmpKrq8NDWuyhJRHNMKEkxDww/SZH3eNNqVZBDEaUmyoaaGmLpuEARpiKvpCYIoxjK0rkWMEOC2K8qELCMESxZkTVWRAh+ftHO/5XoU8xZNO61c615rJ0STJTRNJQwjgiRB11Tw424fTYqEYRgYhkHBGmKq2qI+P03R1CAKaHpO2/hR4eq8zdaKia6mfT3fOX6BqfkGb33qAQxNZbbp87cvTzLd9Bko6CSJ4PkLafPme96whZ4bWNRAuvu5NO/iRjH9eZ1tPdamWtg3W0/KrZQKr1e59FrOSVGUNb9ntm2/antk4HUuMsvHIq/X0KW1hMuEEFy8eJHz589zzz33sH379huew/WmWAIcHq8z3fTZ2ZfrLr6mnFCdukJi6bx5T5kH23+6/DnCGJIoQtdzRIt2YaosdUciO47N9PQ0hUKB3v4BijkTgUCVBFGy2jlJIBLCKCZvGYRRhBcEdBZ8U5WxVBk3TNAVlSAI0DQd2/PRVZnBnsIiD7Jr5xtGMboMhq4TRjGaKiNL6fhnP0rozentRLpE0/bImwZuEHar1AxVRlY1wkVValEUgRDkrZUJd0NXcfyAIBEkQkKVBP19/biel9oK+QFNx+X8pStU8ga9lRLIGufGpqk2bd7x7CMcmXCZavjcM5jrXvuSpXJhzuHMTItHtq7ctXa4vODy+eMzTDd9EKCpEvcOFajEm0dkNpPgwe2J3u2WS6/lnG7XUiYTmVchi3tfFs9uWA86InOzL14QBBw5cgTbtq8bHlvt2GG4enmr7cew6O4+jmMunDuLJGJajkc+N4zteKv+raVJSJGC76eNiKqmEQYhYZxQNjUWFuap1WoMDAxSLBZxgojYDTFVie19OaYbPl4YY2pKOijMi9AVGChoJInA9X1KOYuFhk3LT/M6eV1mR5/F8ckmTS/C0GTswCWIYd9QEaKQJWMvuSZkFVOlx4BZV0ZLYgxdpmn7KJLEjj6LxaJkewG6piArEl4YsWOgyNT5ORwhd0uMm36MoUgUVdrhPLf9uZBApJ5opqqgKRJhLPCDAEPXURWFQMj0GBI7t+bRJcF8rY7rptd5xjIZn5pB6dtBTiss+TxoiowA5lvXL1f2wpgvnJhlrhWwq33z4AQxh8YbDEcJj2+ShX2zJP47rMfO6lbKpYvFIr29vbfkLv16NMeE16HIdJL7ly5dQpZlRkdH1/0OrPNBu9Gdy8LCAocPH6anp+eG4bHlLN8ltfyIqh3Qk9PZ2mOiKhK2H5HTFS5dvIDruvhhwtaKhe145EydIIyYqLlcnndo+RFlSyOnyZQSiQUnIK+rEEYEQsHUZMyoSasVs3XrVmJJ5buXq8w5Mb4fYOkK+waL7B8pc366gR0E6YRKTWF7AYqGAggsw+TiTJ0zsy4zDZckEeR1mXsG89w/UuTSvIsXpdVlB4bz7OozKFpmN6fiRQmXGwnn7HlUWWakbHDvSBFzzqEaqHi+T9nS2NlnMVRcuRtx/JAwFvQULSQpYHd/jitVl4W2CailKdwzmKdgajQdj2LOxHF9LENvlyun+a1eS2GiEabl1okgjAWxkNnWY9BfKWG7HoODQyzO51RrDc5f+B5KaRBt31by+Xy7P0duj4K+/sJzpeox3fDY3mt1bx5yukLZ1LgyCVG8OfIymzHxv96it1q5dK1WY2Fh4ZbcpW/XHLPVar1qzTHhdSYyi3tfms3mhs3M7nywVhMZIQQXLlzgwoUL7N+/n23btq3pHDoiE0QJn3p5gq+cnqXlp1Yvb9rbz4NbSnz/Sg2vOk1zYQE3jDE1mT2D6Z2Q4wWM1TxeutrAC0JUObUykREcGFBpWQpzrTREVdQShvWIiqXTP5CK8YvnF5huhVhquti5YczhsRqPbSvz1gdGuTrXQFFkBgo6MxMOQkApbzFTs/ne5RpNL6KcMwBBw/E5Mt7kyZ0Vnt3Tixel3miWphBEcTenMl1tcXjSYaGVUMjFCBEzZwcsOCFvumeQWstFkovkdJVg2SyZRAguzTtcrXoEscDUGuweLLKrz2K4ZFB3IyQJenPaEmPKlutTzlu4QQAIhEhDjNvLWuqvJgQtPy0N39Fj8uCWCo5/LRS4OJ9TqVTQij5HxmocOXeVPaN9RHFMI9ao5C361eC6C1AYJSSwohhAV+U0xHnLn5yN5bUQLlsrnXLpkZGR67pLVyqV7k4niqLbEhnbthkZGdmAV/DK8LoRmeW9Lxs5WKzz4Y7jeMkOxfd9jhw5guu6PPXUU7fVldwRmU98f5xPvjxBTleoWBotP+LThyZ47r5BnhqS+fzFeQQwUjbZN1hgoJBWyQRxwpGxGlGUMFTOp4l2XWd8rsZYPeCt94/gRQn1egOnUaWvt4/BgT4kJMYWbObstCBAaa8nRUWm7oacn3PY3pvj4R397Z4SAIm8qdGwXSbqHk0voienIUmpA3N/0WKm4XK16tKX18nrCjlTx/Gu5WGatse0HdPwE4p6atfSeR3TrYiLMw0Gi+lri6K43fl/raIszXnYqDIUcia263Po8jz3belhT59BwVj9K5A3debqLcbqPjN2hB+E9Od1yopgR1mjUK4QxAmmqnQ9ztKihtXDkf0Fg3uGS1xZcDk7WWN0y1a29Gg80ieYvXqeiQununfBvb29FItFJElioKiT11XqbrTEumbBDumzuGXH5o3mtRguWwu34i4N6fd3fHx8TeXSr+apmPA6EJnr9b4oikIQBDc/wG3Q+eAsDmvNz89z5MgRent7efTRR297HK3Urhj7ytlZCobCQHuBzelpU+VXj1/ljb0Bb3tgmCCK0ZQ0Ad6h6gQ4QUzRVAnCAMOy8D0PU5Vo+jENL8RrVPE9ly1bRjFNiyCMkWWJCBmB3BWYDoYq4wQxYSxoOh6WoRHFMbqq4HghhmniBteMRaEzmjnCMg0abhqyKuasVRfpq/MtdFVBWXTfbmgqrSAdq9wRmUSIdPeTM2k66c7latVFVyR6Szl8P6BgqDhSzIWZBjsqA1iG2q1866BrCrYXcHQyHRmgqzKmoXNx3sGQYvb3qfRrqbgIIciZOi3XJwgjrHYvURTHNLwIJ4jRFJmenMbWisWO/iJTVRszmOFfPvgo9+0YSh2sXZeFhYXuXTDQFZx7Bw2+P+7Q9CNMVe4KzhZ58+webjepvVHc7Wq31cqlz58/z/z8/JrLpV/t1WWb59ZjA+iExzqJ8sXhsY0ekdwpYxZCcO7cOV566SX27t3LQw89dEfzzmVZZt6Jsf2IkrU0j2PKMVcvXWSqZqMqMqV2k+WSv2+7cAkBmqYReB6aqqWPE4KpqSmSJGbbtm2Y5rWGwDhOKJgqiiITRkuvWxAlmKqM2lYf1w+RJRlFkUhEKgyWriAQKyrjXM+nr5SjYF0rbV6OKktdw0pN06BdqCGShJXriETT8cmbBn6UhhULOQPfv7a7MTWZIE6ouX638q17fdoVhtNNn9mWT9lSKRoqGgmjvQWcMGHGvvb6S/mlvTiun/a7nJ31+P6VOkfGm7x8tc73r9QJYhBJzEDRoKjLfPGFw3zneHqHm8vl2Lp1Kw8++CDPPvssDz/8MMVikenpaYy5M+wUMyheg8BzeGg0z7seGabf3Bz5GMh2MjdDlmV0XadQKPDYY4/xAz/wA9x7770YhsH4+DjPP/88L7zwAqdPn2ZmZmbJDfB6iczXv/513vGOd3Tz0J/5zGdu+jdf+9rXeOyxxzAMg7179/Kxj31szc/7mt3JrDYWeTEbKTKQfqg8z+PEiRP4vs8b3/jGdUneybJMQQNDVXD8CENNk9xxHHP+3HmkJMbS5PbddEIxZ9B0/HbMPPUvK5oqzSBBVdI7+CAM8SJBRYeBcpG+vl6uiZMgigXlgoVwPEo6LLgyOSlBlSS8MCYWgp39uSWd9Yoi44cxedMgIQ3bnZ/VqDohxfZogZYfoqsy2ypmuvPRVIJw5XsyWjaZaXhEIq3qMk2T+YaNoSrXHWVsewE5XcM0NFw/xFzUfd+xrzEUuT1JM839NFoOOSsVjaYXkSR0h6EBhEGY7qDaxWA5U+u6Ry/m/GyLi3MOPUULOUmHvFWdkONTTR4eLXSvkxDwraPnmKle66cBqLoRF+uCmDJbdg/xUEGjXq+zsLDAwsICdnWGqajYbSY0TfOu7yJeD4n/O2Vx3m21culOEcHFixexbZtvf/vbjI2NIYRYl/fXtm0efvhhPvCBD/Cud73rpo+/ePEiP/qjP8ov/MIv8Bd/8Rd85Stf4Wd/9mcZGRnhueeeu+Xnfc2JzPLel+sl9zdq5stiDh06xODgII899tgd7V6CKOG7l6ucn7UJnBYDIuHJnRW+dHIWWZYoGApnz1+g2mixozeXNgvS7sGZaXCpGjA230RXZXb25Xhoa5mXrjZYsNM78DCMMKSYA4N5dmwd7d6ZT9Q9zkw3aYUgi5idfTke2Vrm2ESTqhfjxgm6LHHvcLHb7Q7piOapaouxlmD83BxDfRX6cjKPb69wdKJB3U1Dlzld5b6RIn15FS+IUGR5WU4mtZHZ1mMxXbMZq4ZIIVSdJnnLZE+vQcm8flWepsBwyeTivItEnDZ9RgLbj9laMckbnS9umvvpKRZotHdTHcPK5Rb/YRRT0GQKOQPPD1kuMHEimGyk0zGlJEI3dITnM1DOMd9wqTkGvctm2pwbm6Ha/A7vePYRLlQjvnxqjlo7hJjTFd6wo8xbDwzQ19eXfh6CgIWFBU6cOMH58+c5ffo05XK5m2Du5HNeSTbjTuZuC+9ybnROqqrS399Pf38/kL7HrVaLM2fOcOrUKd73vvfxR3/0R/zQD/0Qb3/723n66afX/Pxve9vbeNvb3nbLj//jP/5jdu3axX/+z/8ZgHvvvZdvfvOb/Nf/+l9fvyLT6X3p5EJu1Fy5UTuZTuw1DEN27tzJ/v377+gL3/QifvcLZzg8VidOBFEco4mQn//BHG/a18fLV+tcuHwVt1ZlW4/Fo9uu9drMtXy+eW4eN4zJmQZ2GHHoaoO9wyWe3dPD1Xmb2YUaZk5iqGBSyad2+aW8xanxKt+5VCVM0qZJP044Ot6g4UU8s6eXmhsSJ9BfsiC5dh2LeZNLMw1evFRlrpGgqQFXG3MULYPHthX5gb191N00pJTXJUq51NIFIE4SbNdn1k04NV7FjQQVKx3e9cBInooWIpkGimwyUNDpL6YW/P6yijJIFz3LMNjdG+P6AVVfZsH20RSZLWWTe4cLLBYIy9Cpt5y081+B/oKOqck0vZiimS4MfpgggF5TJo4TLEPv9tN0iJJ056cqqTQFfoBpmWnRiRCEqzatwnzd5k///nkWlF6K5TL7BtKmzZoT8q3zVbaWTR5sT8vUdZ3h4WFOnDjBY489hhCCarXK3Pw83zt1CS+WGO0vs2+0j76+Pizr5j5od8rrsbpsrcRxfMs3m7qu8+M//uO84x3vYP/+/fzpn/4prVaLr3zlK/zN3/zNbYnMWvn2t7/ND//wDy/52XPPPccv//Ivr+k4rwmRWWwNc6vOyRsxWMzzPA4fPkwQBFiWRV9f3x1/8T59aILvX6kxUjYxNQXf87gyH/BX3x/jv/zkAzw6IPMVMY081N+uPrr2fKenW7hhTCWnISGwLJ3IkLg022TITMgFC9w/XKC/f4CZmRk6O4eG7XJhwSdMBL15kySOU6GJYsZrLlWncO1uPIko5XPUWw45S6dpexybaND0Ioq6hGkoKKpK3fU5Mg5ve2CISnt0QM7QVniLnZpucWbGRlPTc56sp4O/Hhw2KamCkcFrselOQULe0rHddBGfqHtMN3wUTaekpXb7j2wt0fRihFxGJqagK0uuk6bIhFGEAPwwNa8cquTY70WcmbHTXhoBmiIxWlTZ0WPi+iEQpv00XvrcALoqkTcU6m4aotNUDd/zCZJUyPL69e+upxsu5+bO8+g9O6A0CpCOqnZCTky1uiIDSyc/mqZJrBi8MKNwlhxN3+f4lYDDU+Psz52lnDO6oZk7tUa5HpsxXHYn0YONII7jrpv6WrBtm7179/LII4/wvve9b/1P7DpMTU11e4I6DA0N0Wg0cF33lm9eNte7cBvc7tyX9d7JzM7OcuTIEQYGBnj88cd58cUX7/j4Qgj++cwclq50S1UlWaZHF9TdiC8fG2N+7AK9pkQpX6becroN8kIIZls+hqp0wz2yLCPHIVECV6bneWTnYDdPJLUXfoAgEsw2HPKmgbSoy15vV5HV3HBRyCcVpVLBwvODtDnUCckbCpEv0fFNLhgqDTdgsuawe7CEEFBrtpCkRbNmgphL8y66IpPTQFV1EiNhwfa5UA3Zba68KUhzKj55y+T5szNcrXqoqkYcN0kSwWTD4w3by93SZ10zkCSpW1EmIVBVBddP3Q1afowip4UO+0cqVCyVqpOOEihbKnri0XJ8cu30Wsv1MXSVJBGEUYyExPYei+NeRM2NyengRxFBJNjeazHck6flrDTtFEK0z9vm4pWrNG2bA3t3o6oqunLN2mfx4zvvG8A/nZ7jyESDrRWT7b05Wn7EeM0jHtzOPaPaEmuUxV3q5XJ5XcJKmzFctpnOB26vGbPTf5N1/N8l1joWeTHrJTJJknD27FmuXLnCfffdx5YtW7rHv9OdkhDgt7vgO0ik+404Cvn2oePs7kkryBq2SyFn4vo+SZK6sWiyjNN+jYqqEgYBrucRBgnb94xSKFwbxiW1B5FB2viXMw1s10c3NVRVI4rShRYJdGXpl1eS0h4VRVHaX6JrlvwdjZLaJW1JIoiiBGWVBaDupiMBOv0gURQhSRLlfI6GbeNf99MqcWmmwVQrpmjpaDIIoZEIwXwr4GrVY+9A+iW9tvtJX18xZ9FwXC4veFycs3HDBFmW6Mlp3DccM1TJUzCD1FZGV5mabrL8Y+YHEYpyLZ/UKamebkVUbQ9dkdnZm86YaTmdEuulQlPOW8zZ9fRaxoK5+QVeclzu3b8PO0jY3bf6XaMkScy1As7N2oyUTfLtvp+CoTJYNDgz6/Kmff3sa8f6fd/v9m6cPHmSMAy7+Zze3l4KhcJt7Ug2405ms4nM7eSJPM8jjuO70vE/PDzM9PT0kp9NT09TKpXWFIJ9VYrM7Y5FXsx6iEAnPBaGIU8//fSSMsP1GFwmyxKPbC3zldOz9Ob1tCpJknCChNb8VYo7lt7d2K6PqaskQhCEMbv6cxweqxMmkIQBjuPiJRLlvMlgQV8iSnBtJ1POm4wWVY63XPwoRhcCWdVYqLcoWRpDpWslv0IICjmrPUIZCrpMX9FisuZgtBVGAC0/JmeoDJbSSjLHD8iZBkGY+pgB7VEA6e6k0+GuaTp120HXNWSu7/G14ISEQUhPziJJEuJYIEsSqpKWI3dEBjq7H49KIU+12WKqGXByqoksSRRMlTgRzDR9wijhKU0mb6YjDJJEsFpGRQjBXNMnjFwGKnmIA/YMlRgoekRxagezuPKu6aR2NWEUEcUJlqHRdD368joDBZ3pZoChSLT8FuPffpknHzrAw8sMNBfvZNwwwosS+gtLF1VLk2l6EW6YUG6vCYZhMDw8zPDwcPcuudOf07FaWty7cauLSZaTuTm3s5OxbRvgrvTJPP3003zuc59b8rMvfelLa84HvepE5k7GIi/mTqvLOuGxoaEh7r333hUfnts5fhAlfPvCAi9dqSFJ8PiOHn784RGOTjS4PO+Q01U8P2BqaoqdZYWBRR5dcSK4suAwXvcAiR19BXb15ak6IVerLr7voygqBUvjDdt7sPR0hLChqwgh8GPBvBPhqT49QcSB4SJNL2Ki7mH7EUgBfaUcj24toC3ayZTzFo1FDZRxIrhnMIcTJMws+BgigkCgqzL3jRTJtUuKIbW4MTQVVU0bInvzOmVTpeamfmq6puJ6Hm6YsLUkU8ppS3ZcSxFIbet+SZLQNK3dgMuKoWUApp6KVyFnMn612Q2HQSp2qqxRc0Nmm+ngs7xprDrnxQkiTky1qNohsRBok012D5bYLjwUWWo3w67E9QM0VU4HwcVJ9zwPDBUoWz7TDZ9YCIZLOnJjkjMXSzx537X5NIv7jXpyGkVDpeaE3eZcoH0d1e7rWs7iLvVt27aRJAnNZpOFhQWmpqY4c+YMpml2Q2s3yudk4bKbczsGmbZtI8vyuhRvtFotzp071/33xYsXOXToEL29vWzfvp3f+I3fYHx8nP/1v/4XAL/wC7/AH/7hH/Lrv/7rfOADH+Cf/umf+Ju/+Rs++9nPrul5X1Uic7Pel7WwuFlyLcdZHB67//77GR0dXfVxa93JBFHC737hDN88P0+UpGWz/3h8hjff08e/f9s9fOHEDEfGG9j+PJra4Mmdu1k8JfLbFxa4vOC0Pbbg8rzNlp48D/Qk5KIQdaiHnKkzUjbJ6dfedj+IuDjv8L2JEM+PUBfm0GXYP1zk6d296SAvN+1nGSqZlCyDRCQE7R6Ymu0wXvOYaqThn6GiwZaKxVM7SpxSfFqhRE/BYluPye6hyoqO/iCK0x1E2w7moS2ldGqlH4MXAYLBgs6+AZNmdR5TT90Ewmjptd05UObC3BRuKGFpCmEYIqsqURIwXFraSa3IEnGSLuy26+OEAlNTVzwGUmPOa04EaXd/Op8mXVhPTLaYbaVWO6oiESYSpybryFKRvf35FY2riwnbIUYvFrh+RMFQ0BSZ7T0W23uWLirfOnqOatPmBx+/F0NTl+xkCobKY9vL/NOpOcJEUDBUml66u3l2dw/WLVrPyLJMuVymXC6za9eubu/G9fI5lUpliU/fZtrJ3K7j8UZyuzuZ9Rq9/L3vfY8f/MEf7P77V3/1VwF473vfy8c+9jEmJye7bhMAu3bt4rOf/Sy/8iu/wh/8wR+wdetW/uzP/mxN5cvwKhGZxb0vdzIWeTGdN3stZYWu63L48GHiOF4RHlvt+GsRma+dmeMb5+bpzevk2hVIth/xtTNzPLWrl//fD+7hzJUpPvlPV5lqyRi6QtReaMdqLpcXHCxN6Y78DaKYy/MtyrLKQ/u2o8irf7jn7YDvX64SBCGVvI4kSXhhwvGJBpW2FUp/4doi7QUhiix3rVtevFjjyoLTNXy5OGezrcfiyZ29bMtDX2+ZQr6AaaaVZx0cx6bRaOIKDTuRURWF3YMlevMab9rTQ9VLaLpBap1TMIhCnyYC1w9RFRnL0LulzzlTB89nV1+OC/NO29QSJClk50Bx2YItMPSl/miWCrN+TClndmfMxO1S456CuajhUsJ2A3JmGrqcd0KqTkjJVNPdnZT2tQRhxOU5m+0Vk/ySvp+ltEKJ71yaoeXHmIZOThHsHch3ixQWY+oapy5PMlNt8I5nH6Fg6u3XmH4PDu7qwVRlXr5ap+nH9OQ0Ht9e5pGta/fH67C8d8P3/W5o7cSJE0RRRKVS6Zo/biaR2aw7mbWKTGcq5npc27e85S03nKa6Wjf/W97yFl5++eU7et5NLzLrORZ5MWsVmZmZGY4ePcrw8DAHDhy46YdlrTuZFy4uIKArMAB5Q2XeDnnxYpX7B3Q+/+0jaWVUmM6Nsdqhp6l6Omq5IzBRFJHEMZIQVCONvGWmu8Bo5fmMVR38KKGUM4jCgHyhiCIFVJ2QK/POqrPmBQlhFDHrxFxesMnrKlr7ucMo4cqCy2jZRZfA80P6ejTi7h29SDvXqzXGPJ3JpkcUp3fBx8ZqPDBa4tHt/ehqwFDhWmhmcSdMFCfEcdB1M3CDtCnywHCe/oLObMsnEWkYaahokDM1RDtPtVrSfVuPxbwdMNdw6SnmcFwP24/pLxqUjZULleuH9PQoCCQikfbECCEwdCMdvKbIhHGCF8ZItIsLlvXTeLHE9y7OEgvIGwpCRCx4EienWzyypdR9LwEUWe7uvObrNv/nS9/hhx47kF7N9qKhyBJP7KjwyNYSbphgafKSsOZ6YBgGIyMjS1yHO6LjeR7Hjx+nr6+vu9N5JfpzrsdmFJnbSfy/2mfJwCYWmY0Yi7yYzrFuljdJkoQzZ85w9epVHnjggVu23F5rTiaKBau9Ook0fv+Zf34pLZFtn3cYRcRJ6svVQQhBEARtXzIVpS1yXvvuP2dqON7S5LkXJiiqRhKnP4/CAEVRUdUYdxWLl7TJMXUzvjBdR1Z1dFWikxLXVBkRxEzWPXZYEqoi4wUhcZKQMzTOX7pMEITEuT5mai2KeRNdkYijmKYfcmyySWxXGSxZqLqOZVnt3gJpSS5mqulz4cICrVhGTiK29Zjs6U9Fpn+Z1Uyn+qtcMKm3VtrADJd07h8pcmHOodp00HWd0YrGQ1sqS0q4lxwzjDA1iZyh40cx5ZyF395BeVFMwVAxVJnUSy2tKLM9P31vVIXTMw2CWNCX7wiphCpD3YtpBAn9bZERIq1qsxfthlw/5H987kVqXszL8SV29ud5YkeF7b0WmrL+4rIay/M5zz//PNu3byeKIiYnJzl9+vQt53M2gs0oMrebk1mvnczdYlOKjBCCRqNBs9nsNjSu90VebGJ5PRzH4fDhwyRJwsGDB9d0R7HWEunHd1T49oUF/ChpL07pVEQhEoKFcZp6x8UgfbwQ6X8tx2P3UJmzMy1ajoemShimSRyn3elbKmmZcnr3n1DMmzRa1+6qhyp5zs/aJOq1hHoUR0QxjPSsfL3lQo5GJycBJFGIbFmIJOmaYXbKrGUpraqK4oQg8Ll06RKVUoGhwSG+eaGKBN3Xqmoq/abJbNMlNisYpkQchUxOTiJJErpuIERCHEfM2hHfu1wDWUWVIkJJ4cSUje3HPLqtxHIRAVCVdHJmOvXSI0pEauyppe7V23osRsoGth8jS7Clr4gXRCvm0ywmp8n05xQmWzDXdNAVGS+KEQK291hLCg5aro+pa+27WZmGG6IvKwqQpXRxbDgBO/vTfppywaJhL81jnZ9zuDLv4DotFPMc061tnJ9z+OnHRtjVd3cs4YUQlEqlFfmcjhfXsWPHKJVK3aq1crm8oSKw2USmc9Oc7WQ2AZ3dS7Va5cKFCzzzzDMb9lw3EoLp6WmOHj3K6Ogo+/fvX/OH40ZjkgFaXsT3rtTwwpj7R4r88IEBvnF2jsNjja6zcJwIBmhQVqBjmN0RhyCKiUWCpStYiceAKZh2JAQ6ftv3arRsLvEUE0DT9igVLFq2h6YpbCnrVHIac00PTQbCGDdMKBgqW8v6klHEBcugYTt0FvGhksHleQc/CNFUBVVR8YL0uQeLOpYq8MOQuNVkZmaGSqVCuaeXnGkQJdUl1Vqy1A4vCkCSKRSLgGDr6CgzCzVsu4XnCa5cucqZhkKITklLY9wSoMkKU62QmhtRWeZO3R2hLATVlsuVesSFmQZhlGBqMjt7c+zss1BlmbIlU8wZNGwPRU7Ll+3r5FRA4v6RIrl5l6mWguv7FAyV7T0mWyorbdu9IKSUM4mShLyhUHWXfj46jjOGKtNyPHqKOaoNZ8kI6pYfMVX3sDQZSYXAadKcuEgysJXvXLRuKjINL+LMTIvZZprv2jdYWFEYcTssL6C5UT7n+PHj3XxOZ6dzu/0512OzeZd11pnbzcm8mtk0IrO890XTtA03sFxNZJIk4fTp04yPj/PAAw8wPDx8W8e+UbjsW+fn+a9fOc9sKw2f5HSFH3twmP/w9gN85fQsL1xYQJJgQHFImjIF61ryOIgFZxvw/SPTJEKgS4JhM+TJHf0EWoFLs02CKGKkbLKjN7cidJIIwdnJGjEyZUujoMGb9vbz/YszTDUCBLC91+L+kRKl9ijiUt5Ke1u8xZMf01zGWNVlouaBn06YlBWN0bLJA9v6uHjpMnEc4fsBQ0PD3S+L4wUMlQzm7ICkXboryTJ+ECJL0JPrfCwlmq5Pf28FVVWwbYeh0VFOOlWUMMBz49ShVk2bQN0AQrF0oep4mHVGKJ+YbHFx3iFvaph6asx5bLKJQLC7P49l6N2O/DhJsD2fUt6ivmj3J9qCJUsSlqmzqw+29STIUglNlYjj1XfHBcvoGnDuGSwx3fCpuxF5QyERou2TptJf0NEUJe2nMY1uPw2k/UZBLKiYCl77vbAdB3vsEkelmH/58NB1B5nNNn3+7sg0V2semiwRxgnfu1LnuXsHuG/kzpr9blbCvDyfY9t2tyn04sWLyLLcFZze3l5M07zusW6FzbaT6URMbmcn82qeJQObRGRW631RVfUVFxnHcTh06BAABw8evKNpdNcLxU3VPX73i2dptodtKZJE3Yv45MsT7OjL8a5HR3nXo6OcG5vm777+ErIEjue3/cFsnj+/wIQtYeoJIolpxAI31tit5hnJK4wUerpDtJbTcEO+dWGB+ZYPiooKbO3L8cS2Eo9tyVMrCoaHR5YknQEcP20eVBSJeivADROKhoqlKzy9u5crCy6T7eKD0YrJg9v6aLZsXDddULdt24qmLc2T7Og1GVtwaPgCU5cJPI84FoyUDYZLSxcY2/XRVRVNkciZOrqqIIRGwbC6hSFBFBGEMeNj4+RHKiSygmVa9JTy3XBTy0/7fnK6gqmkIVirYFJteVxacNk9UCCMo2VZGImGneZU5poOF6oBc06MvjDPtr4iI4WIgqG2RwIIENIyJ+kUQ1exPZ+OSBuy4PGdfZwYr2H7cToptKCzdyCHocpdq5soTvtpTF1rV/alR0gWJahMw2C+6XL+/Hm+f6rMwQf2rLor+PbFKmM1jz39ue4u8mrV5Z/PzbOzL7ek6GStrKWEWZIkCoUChUKh25/TaDRYWFjo5nMsy+oKTqVSWXM+Z7OJTBzHtxX2f7VbysAmEJnlY5EXDxXr2PVvFIsrwKampjh27Bijo6McOHDgjj+g16su++ezc9SdkOGy2Y3ZVyyNqTDmc8em+bEHh5mtNvjctw4vSnSntjGtSGay7qErIIs0mZ23DOwQvndhjh97cIgEuk7KS+++Bd+6sJAO4spbkESEUcLFmSYFU2VXXkKRWCEwAIamMVd3eGmswWTDJwgidEViV3+eh7eW2d2f74bldFWh1mgwNzOdFhvkCysEBiCvq7xxV4WxesBkM8CQFLb1pOGe1Zoe/TAiTgRFy2BLWefkVICuJuiKjKJphJHEQNlkz5Y8nu+RRC7N6gJT0wq59iz2ViARxAk9+rVRCFEUdUOCkQBWqcADqLZcjkzYjDdjNElgyiqnJqpMWhpP7Kh0e1HiJGnfFFy7/rKcVp8trx4t6RJv2jdA3Q3SIg4j9Zkr5s0l5d5hlBBJaZFHGKePa7QLODQtNRn1ooStFZMXj19god5aMp8G0nL4C3Mu/QV9yfUdKZtcnk/HYy92RVgrd9LxL8sylUqFSqUCpNWR1WqVarXK+fPncV13hd/ajb6fnfzHZhOZ26mMbbVa2U7mdrneWOQOnV3GRtpVKEratHfixAkmJibuKDy2nOuJTNUJQVrZha4rMnNNH8fz+czXX1p1eNfEQpMoAU2WUBUFTdOQZQVdjmj5EX47kd25+y7kTDw/SG1SWj4LTkApb0ISIZEKSiwEZyZq7L+/n9VMU9KSX5fvXKoyVnWxNIVKwcJ2PU5NNVFkqWt5IksSzWaT8clJenp6SeIIo934OW8HXF1wcMPUm2x7j0V/0aRgKBwYzJEzdfwg6lrMrERgaAoN2+WRHX00vYjpZkDLj5GAoqny6NYSxbwO+Ry6ppDECa7rUms0mZmZpRkkxKGCLaUO0J1FyHY9crkcIo7hOpVZUw2fmYZLSZfRVAVdBS2vs2CHjNeWL9DXdj+O65MzdGbqDtMNj6YfY2oyQ0WDsqURRhElU0XX0lHVectoN3suD/ulRR69xRz7hmJOTjSYdyVmGi4SgpGS0S3yWDyfpqeYb1+9zpktpTs15w6GbKYCun4d/6qqMjAwwMDAAJDaN3VCaxMTE0RRtMT6Znn11WKH6s3C7fTIQBou6+np2YAzeuW4KyJzK9Ywnd6VjU7gnTt3DsMw7jg8tpzr5WR29afPEcZJN18ihMANYx7fVuL/fuPldpntUpIkwW01iKMQTZXQ2mW9SOmxDHVl6WrHNkYRAj9MSJCRk6XnpMoSQSyo2h6GqqAoEnGcfkkLuXQkctUJmW6kYSZdlUmikFLeotZyuTBnc+9wEVWGVqvB7PwCw8Mj5HI5ZmdnCMKIqVbEt87O4UcJkgSX5uHSvMPTuyoU24PDHC9A1xQ0RcVbpaKrmDOZmIgACd8P+MEDQ1xZaNF0I3RVZqCgd19/Z4RylAh002R3T5mm4+H7AfOXqkw3AwLfR1MkEkkhkjW2mO1eoev0EzW8qN2OKbo5w8T3URUpvXFYhZbrUy6YTFUdXrpap+FF6SjpRDBW87h3uMBIyVxS+Zd6wF3vpiothx7tyWMqCRfHXMq9OXK6SsVSl3yHOv00/+KND7J7dICCobKjz+LIWIOSpXZvcqYaPn15vStQt8NyR+j1xjTNFfmcThHBxYsXURRlieh01o7Xgsi4rsu2bds24IxeOe6KyHQ+jDcbKga3/+bcjMnJSWq1GpVKhSeeeGLdP5DXy8m8aW8/nxiY4MxMi6KhosgSdTckryts1Vo0bG/F7i0IfKampug1VHoLJvNND02NMC0Lx03Lce8byK8eZgoiFFliuCePrtTwomTJKGI/SrB0lZyu0HDS6ZSaKiNBO1kuYfsxYSzI6+2/kyAMAywz7bpveT64DWwvYOvWbYvi56l7wHevzoCs0pO7ZpjZ8GOOjDd4Zve1u7QgTC1mOg7JkOYeZuyYc1M1ag2wjSY7e9Mmv9FKjqQklli3CCHItS1q0n/T7VMBeGL3AEfGG8y1ArwoRpMkeuQAy3M4f9GmWMhTKhZIWHrjoykSiRBoqkoYRQRBgG7oJE7YLcNeTjoIzeXMjI0bQV9eQyLtKWp4EedmbPrzetctIAgj8qbR7afp4IYxVSfd8ZfalXMVy6THgJFVmmUXv/f/9xsv88xDe3nDgV08vauHmabP+VkHXZUJojS39gN7e+8oH/NK7hwW53O2b99OkiTU63Wq1SoTExPd/hyAhYWFJaJzN7ndm+VWq7WuN793g7t29WVZvqHFQecDG0XRbQ36uR5xHHPq1CmmpqaoVCr09/dvyJejEy47PtHgyydnqLoh+wYL/Iv7hvhPP34vf/b8JV64WCWME+4fKfLUsMzs5DgAxXwajhICms0G0zOz9FQq9PX1kqsEfOX4OL5QcBo2pmGwu1/lwdHr24fEiaBiauweLHJibIEkUVAVCT9Ku8gPDBW6iesgjNFVMHQNIdI79HzbUyuIkyU5G88LUBUJtzaHquls3bplyXwYSYIFNy2JLpvpvJQoDtFVDSOM04U+TJZUQyUidUhO/cJcjk/anJuzSeKYMISTUy3Gax5Pt8VpscU+QClvrfBHS3cAPjnTQJEjntxZoeZEhHFCOadjKOmoAtd1cV2XarWGaagISSGXy2FZFoNFg/FGRN22sdR0Ya21PDRNZWvPykVAVWTCOMILE+ZtH0OWMHQT3/eRJCk1tHRD6m5EX16jkDNpOT4+EaahEscJYZQwUfc4N2vjhekNi67I7BkqMmAmaX5mkaCuhiLLvHD8AlPzDd761AO8+7FRTk23mG74lEyVe4byq7o6rIXFk2hfaRa7Ru/evZsoipienub06dNcuHCB48ePrymfs1HcrpdaVl22gUiStO4VZq1Wi8OHDyPLMgcPHuT8+fPrPh2zgyzLfGMs5MvfO4obxIDgSydn+bvDk/zeux7g37/9AI32/JRGvc5nvv79a+fpeBiawnfOjHN62iGUVAotnwNRi/2DBd6yw6QpTCS1TE9OY2tfPk2Mx6uLdsdn7JGRPJaqcGqyRhQnFHSV/cMF7hks4LpOuoMiXbibjttNXvfkNIZLBlerLkKAqkgEUYIXRmzTE8rlPoYHB1Zd7IQQ3YRAFIVouk7Sfk8X/WoZaVjIjSUuLrgYCui6ipME5CyVqhtxftbmka1l4jjBidMmyzBKuiMHIBWsybrPbCs9r4GCwfa+HKauURFQyJndHZOqqhSLxfbcDoHvB8giZq5WZ35+npxpMKAp2CKh4YMr0h3Mrj6LgYKGoWtLKso0Ve16q3UIggDDMAjCYMkLT8Nk166d50epSCUSZ2dsBILevIYE+LHgzHQTqS+98Wp1BXm5sIJAYIeCuu0x3xxnvmHzE296hKd3rW+Mf6PDZWtBVdWucecb3/hGPM/rhtbGx8dJkqTrt7ZaPmejuJOcTCYyG8h6Tq+cmJjg+PHjbNu2jXvuuQdZltd9OuZiqm7M5y/FSFrCUCk1nowTwVjV40++eYnf+Yn7KFka8/XWskqydDF+/sRlTlcFiqqjSoK6E/GdC1UiIVMOY0Z69UV9J2Gaz1BlvLaN/oIdcHq6yYIn0IjZM1Bgd3+O+4dzPLS1iONHqNI1t2FJkkgSQaEtSMuLB57c2YMiS0zUPXw/RkpiRi3BM/u3oOn6osXuWtJakiR6TBlTE9hBRCVvEbatV4JEYjCvLgndLWfeDokSQdHSiNulxbIkYaoSkw2fR7rD0SQ8P8Q0NPyQbuPly1frXK163Wt7ad5lsuHx+PYyvcU81ZZznWeWMIy0QXH3jjJRFGM7DkqrhR4nNPwETZcZKFn0ldRuRVnHo2zxbsrUZHpzGpN1H0OTCYIARVVo+GmIdLBsdYVuMVGcMF51iCWFkta2HJIk8qaG7TvM2iF97XNtOh6Wqad2Pe2OTj+KuVwPmVywiRKBKktcrbpUWy4/8ezD7B4duO51XyubLdG+uLLMNE1GR0cZHR1dkc+5cOECqqp2Bae3t7f7vq83tysyWQnzHfBKjUiO45iTJ08yPT3Nww8/zODg4JLj36gr/044NJHG4bdUtGtl2bJEzlD47qUqLS9CkRI+/c/fx1+U6HYcm/HJaS43ZRRFpqBJKJpOFIZ4keDoWI0nB1gRakzzGWn45OJMg6+emcWLJWSRkAjBdCOtLntiRw9xFJPXlW5FU4pEztC6i6MdRCzYAWrdY1tvnlLO4Jk9fVRbLmNTs1iqzP17d+F38yHpYpc3DdwgJGkvdoYqcf9oiaMTTeaaLrIkiBMoGApP7u5HklbfSRZzBt5sGiYTQkZVr/VJCAHKos9PZ4Ry0/G7oaaLczZXqx55XVli3jlW9djRX0TCppi3Vq3kgnQXUHNCriy4FHMGA4U8umGmwhknmKaB67pMTU0hSWCaFk3LYmSwl6a7eFchsbs/R8uPWbBDZFkiSQIsXeWBrRVUGYLrfMSjRBCFIUYxTxCE6LpG4AcoskQYC6RF317XS/tpNFXBCyKu1iOuzLYoW2l/URCnnwF1soH0jZd5+oG9S+bTLCZOBJcXXKabaXHEzt7cCj+4xdzNcNlqXK98+Ub5nPHxcU6ePEkul1vit7Ze+Zzbycl0RPFuTMVcTzb1TkZV1TvqlWm1Whw6dAhVVTl48OAKV1hFUfC8lWGG9SAR6UK1/GvXbtnDj2K++dJx6s3O3XTqTlyr1dCLvUSzTUxVRgBRGKIoKqaU0PICmoHE4Cr5rEQImo7HiRkXJxSUzbScGVIjzLPTLfYN5Knk9G5FUymfmkbmTYMpP0AIweGxOmdmWvhRgixJlMwqB/f00WdJ1GYnGS4X2LVj26qz6m0vQNfU9gKYmlruGyowULI4O9XACWN6cxo7+3IYckLONPAWiRKk7tIt12eoZKQWK16EpSWoqkoYJwSxYO+A2X1thUXhok6oqeqm3m3aop2SpsoQJYwv2AzkSjTtlaIIECUJR8ab6YwcWSGKGhRNlaf3pBYpiiJTLJYoFkttU1I/nTrq2Jw4NY9lGhimiaYbmKZJyUxt96caPi0/wlRlBos6W3qs1FU7WN0mv2CoSBI4rk/eMtNZSgLCWFAuqhAt/ZtOP42sqEw3au35NOljdEUib6jMtQKcIOZbR88xU22s6KcJooTPH5/h6GSTKE6L2iuWxg/v7+PBLavn/V6tA8uW53PCMOz6rXX6cxb7rZVKpdt+nVlOZpNyJzuZ8fFxTpw4wfbt29m3b9+qb/B6jEi+Ho9ur6DL0HAjyu2Z9YkQtPyYN+7q4eWT5zh7dRrL0PD8gPF2/f/WrVvxYhlJapIIgdIeiyxJEgmgyAqacr3pkOkCNFFtpTNWuPbaDFWm6UdMN30qufSuVAAN26NSsJiv1UHAuVmb45Np/0vJ1IiFoOaG/NPJKR6shNyzYwvFYukGpbaCiapNzY2IA7CIKVgGCJ8ndvYseVwcxziej6FpoKQNl6oiE8WpyWTRULlvpMDxyRY1NyIIInKywVDJYM9AmmzvlFkvPpcoTkcRKJq2pFJPIvVIixa953a7dFpS08Ue4MKcw9WqS0/eQhIRQlWpeRHfPjfLEyM6/qLdryRJGIaJZVpomoLr+biuR9128BoOIkp7XyzLYksxh95nAVJ3TAGwxKF5Mf0Fjf68nk4sjRxkWcaPBWVTZaig0aytcvWFSEvAJRlNXvrZVuW02COKBWhpP43rv8SPPHl/t5/m8HiDl8YabK2Y5HQF0c5rfeXMPFsqJr35lTuazTaw7HYbMTVNW9Gf0wmtHT16tJvP6ex01pLPyXIyd4GNCpdFUcTJkyeZmZnhkUce6X5g1uv4t8r23hwHhxK+W0vDFIqc9p/05TWe3aJw6MxlAKr1BrMzMxTyOcrDI8iyjI5gsGgwUUtH+Oq6QRD42H7MQMlksLAyXNYhDR1phGGAYaQLQrKoN2Z5mbMsp4u7ruvIEpydaQHX5toogCEltLwEkevFyheQ5bah5bJziBPBdy9XubLgEMapiORNA8mqsq33+mWYfhghy2m4TkgS7qIE+p7+PL05jfGay9y8z+4teXYNFFDk1OG5U2a9nIGCzpUFF8kwkZI4PVdFJY5DBotLv7RBGCPLael00/EYq3pYmooiJQgkJAnKpkrDixiveWyrGG0xTBfxxWXTQQxnqxGzLYgTjbxZoCcI6Jc8arUakiTTUy7QsnUs00JRlK5Dc5wkS8qxVVnm/tEiM62Qqws2iRBsK+kcGK1gNxus9hUq5izCpoMsYiIUNEnqumO7bYdvU0sX4JypMz5bXdJPc3yySU6Tu++/JEmMlA3OzjpcWnBXFZnNuJNZj7aH5fmcVqtFtVplfn6e8+fPo6rqEr+1G+Vz4jheszVOJ1yW5WQ2kLVayzSbTQ4fPoymaTzzzDM3NdlbT5FpehFfPTPLdMNne6/FwZ1lfmhU8LaD9/ClU3PMtQLuHynyxKjBi4ePA4Jarc7Cwjy9vX309FQoWJ27W4mnd/fyT6dmaQTgNB2QoGRpHNzVQ9hcIGes/oHtK+cZLdY4O+OhK6n1jKyoNBwPU5XZUr4WMhRCkDPMdHEMQhDgxekdL7Qtf/wApDR0GZPe2TadANPQVgxCOzvT4sKsjakp5HWZMFZouj4vT9gMFM3u4rYaSSJQFIWmFzFWdTFUmb5COoGyJ6dTMhSu+Ats60nHGCiSgtrOP6zGaNlksuwzUfeQFSVtznQ9RssGW8orPxdJkpZO502TMElQFXWJkMtS24YmAS+MKEt0/cRK+XQQmhCCoxNpmC1vKJiqjOsHuJFKuVBg++AQURTgOi7Nep3ZmVn09swcy7Io5HNYhsZCy0OWpPY1sNAVma1lvV3mICHiiIKls7BMZfKmTtNx0RSZLWWDc3MOoapgtnNvsRDs7M2jKTKqIrfHGEjdfpqnH9iLF6a/W4wkSUhcmxa6nI105bgdNsJSRpKkbvXh4nzOwsJCN5+Tz+eX+K0tzufcjvA5TlrxmeVkNpBbLWEWQnTf6J07d7Jnz55b+pCtl8icnGzy7z59nJmm352lsqPX4scH4Kd2V/ihe4cAWGjY/OUXv00UxczMzOB5LqOjo5imxXwr4NRUk95inooBJVPjp96wjbPTTZpuSN5Q2N52VZ5upaWrO3p7266+6Rc8bxmp7crWMgt2wIITgkgXEsvUeWxLHmtR093iWSWSBFESUzIUpsN0F+L7AaqqoCgafhDRX8x17W5WG4R2Yc5GliUMTU5dHKKInJY2Q042ffYPFgiuM/PeMnW+cWaaSwsukVCQkoiypfGGHWUqlrbsrj1N9K/m0dZBkSUe315mqGaw4MaIJGGkUmYgr6zatJoi4Xgug+UCV+eb6Iu66INYoCoyeT39dyf/US6Y3WtYdULm7KCdbE8/f0VFpu6GjDcVdvTnyFtFNM2gVK4QxzGe5+I4LrOzs5wbS5gPNWLZQIiYHYNlthQjcrpKKi/XsL0AQ1W6Uzg1VW47JaSP2tZjoSoy4zUPL4ioFC36LZmRsgEIdE1dUnItBHzr6Dlc2cLW+xgs6l1XgKaXuioMFVe/U3+thMvWwuJ8DtAdT1KtVjl79iye51Eqlbo7nSiKbsuBGcjCZbfLeoXLoijixIkTzM3N8eijj3bnV9wKa51euerzxwkf/uwpphoevbnUfDCKEy7OOXzGkXlXO/7v+gF//82XaDRbTE1NoapqahchKXz97BwX5xyiJEGSFijlDN5yTx8jJWXV+SCSlCbUG45H3kpLjFPX3tSKP2+oPHf/EJfnHapOgK4q7Oi12NZfxHbT2H9HkBaXGwsB+wfzTFZnaEQypqKSSAqOHzHcU6A/v/SL27VDyZk07HSMsyJLSEhIktztu5FIy6zjJOl2tC/G1FWOXK1ydsZGV2WKOiDpVL2QFy/V+H/299F5ZiGgVLDaBpLXPMJszydOBF6YhoQUWUKR08quvbLcniqavu7VChY6lPIWW4ohc02Vup9gyGmVVxAnbO+xKOrXdk6yJON4QVr2bXu4YUKciBX2PoYq03L99M520e5IURTy+QL5fIGaE3D2Sg0nDNElFyHJHL00w5il8ti2IsV8Dlm+tkgJkSbpBZAzNBJgvu4QxYK8oWCoCqNlk+GS0S1hLrdLq4vdMvWVCK/F7EyNMNrOYKVAGKev/YkdFbb2rB4Z2Izhslf6fDRNY3BwsFu9mjb1pn5rY2NjhGHYdSXv7e0ll8vddA20bRtFUTasrPqVYlPvZG4mMs1mk0OHDnW9x9Y6g+JmkzFvhSPjDa4suJRNrXuHrCoyeUPlcivkyrzNvlGDz33rMGMTM0zPTFMopnc4IHHoao1zMzaaKpHX0hBN3fb5yul53v3Y6HVcrKRuKGeu7nB2zuXivI2IY3b05bh3uIippQOpFtNyfExDQ5GkriAtPiaA4tW4pwJTvoKXKAiRsG+kwoPDVtsVYCkC2jNncgwWDS7O2elgrig1Ao2SVMAqOY04Edie1+4nSavqZDnNbVyYdZBlqetmjEgoGgrNQDDV8BltD9ZazUCy6XiMNQLOTLVwgqhddmuxbzBPzjS7d+wdk8l0kV0pNDlDo+X4DBYNHh6FSwsurVCgJjF7B3Ls6s9Rr1a7r7wzFjmMPHKmTs6IUCRpiS8dpGJQzqc3A4okdYeiLV5kxutpPmewnEsnisppOGuu5XN5pk5RnsMwjG5orfP+R3FCgsTxyRaT1RaJSI1Pt1ZMdvalx+pM4Gw6HuW8eUOHgJyusLMM8/NXiM3tbB/q5/6RAvePFFeYunZ4Pe5kbkbnferkc7773e+Sy+VW5HM6O53VhKSTj7nbr+VO2dQio6oqvr96F/nY2BinTp1i586d7N2797Y+5OsRLmv6EbEQK0IwqiwhhETDC/nq90/y4uETtFotRoaH6eutYLtpufCZmRaSnNqFdCjmUqPEczNNHtneu6JZL911CLww5osnZ6i6MTICSVY4dLXOeM3lrfcOrWrbH0YRkqpiaFq3Iz0RYkl3+hP7tyGQafkRlbyJocrdiZfXvQ6Ox0Pbeph1YuYaDqYmE4QJQSTY1rd4Rkxn5n0qNKamUnf81Eds2ZdJBuI4QlLSKjFNkXE8f4l1DaQVcUcnmiiyjGWoeH7I8ckWkqqxf8UXVGoPA1vavKgqMkEcdxvxB4sGg0WdKBZUijma9tKQ3PIue8cLGCjoDJUtxqsORVNFlSXcMCZBYktJQ5aktiinowBajtstcm+0Q1II0HSNIAhRZBldU+nt72OkIHdtb2ZmGiRJmgcJPJdDkw5VL6G/ZCHiCCeIOT/noCky23qu5eBURcb2AmRZRlMlvCDCCSKm2sPTDE1msGDQX9DYWtbJR1X25Ao8vGX0ht+vzbaTud1y4Y2i49E4NDTEwMAAcRx3+3OuXr3KiRMnyOfzXcHp5HPW0+b/v/23/8bv/d7vMTU1xcMPP8xHP/pRnnzyyVUf+7GPfYz3v//9S35mGMZtt3u86sJlURRx/Phx5ufneeyxx+jr67vtc1gPkbl3uEhOU7CDiJJ5LRlvBxF5DaozU3zuG99FCNi2bRuqqmG7aXf4QtNOQ0yLRxzoOkmY7gIcP8J2vfbAMmeJsSgIzs60qPmCnNrpthZIhsVMw+F82x15KQJTS8cJp/YxKt88O82lOZsgDCnrEgcHe7phmd68gSxDEEVLTCuvx1DJ4E17ejg51WK67qApElvyCk/t6V0hwp18iu2mDX9FU2XeDpcUB0RJOn1SJaaULzBJJ8nMoscknJ9zUGSp7egs6ClYtPyQM5M1thb7yRsrP+ad5kVVVbgw02KqFdF0fXpzGjt6LcqWBkioitTd/XR2RKaurSibhnRXce9QDl1VmKjaOInA1GTuGSqytbK0KqvpeFiGThTFhHGCpck03BDDtAjarg0CkfbvJDGVYhFZVigUUtuber2O3WpxebbG5IJPTpNwmiGmZVEwVOIkZKLusaXSmVu0NA8TSZBIMkfGm7T8GE2RiF3BTMNnV3+OB7f10rA9vn30PDPVJs8t66cJ44RTU+mU0Xqjie4JHomSVW9sXmk2w05mOYtLmBVF6e5i9uzZsyKf4zgOv/u7v8vOnTsplUpEUbTmyrTF/PVf/zW/+qu/yh//8R/z1FNP8fu///s899xznD59eklz+mJKpRKnT5/u/vtOdqqbeiezXAQajQaHDh3CsiyeeeaZO45VrofIDBYN3vXoCH/54hgLdoCuyl3heEPF5f/+07fIFwr09w8seqPSu/meQo6KpTHT9DHUtAosCVMrFQnozacLXcN2u4tc0umZSRJmnYQkCpHNa2+jiEMUVWeq7q0QmcV330Gc8MWjY8zaISKK0FSVOS/iq2fmeet9g/TkdAz92qJkux6lnEXdXplkB9BUhSCM6ctpPLu7B9MYYmpmFsduYagrE555y6TWtFEVhZyhs3cgT82p0fQiTE0maudXhksG/XkNIdLiBEWRl/STOEGcztFZtLjFSYylq8z7IU0/XlVkIE3en55ucK4aELY76RfsgMm6xxM7KkvKdVvtsQmGlr7O3HUCmZamcP+Qxf2jRapNl+GeAkEQrPpY1w9RVRnL0Bkpmyy4CQtNj7wmkwhoeGnBR39Bp+n4FPMmtuMhkFDV1C9NNspYrQZFXSIMI5rNJiQCoWo0QnBck0LOpJS/VuQBaejw1GQdH4XevNwVbsePmWxGDFZbWO1ZQOfHZvjrRfNpwjjhH45Oc3i8iSxJuK5DsxmhH5vmRx9YfQf9SrJZReZ657Q8n1Ov13n729/O5z//ec6fP09/fz8/+IM/yA//8A/znve8Z8031v/lv/wXfu7nfq67O/njP/5jPvvZz/I//+f/5EMf+tCqfyNJ0vrN1lqXo9wmN1PHTgmzEIIrV67wne98h9HR0f8/e38ebFt+1XeCnz0PZ7zz+N59Y2a+nGdlphBoAqkMNKKqKex2N5hucLgr1G1CXXbYDptymIiiHWCD23YEtqPoquoIDKZMY7BsZDmNhITGnDNf5nv55unOZz5nz/v36z9++5x7zr335fCUIhNaKyJDyptn2GcPv/Vba30HHn/88fdkGDZUgv5O5zL/3Q+c4Oc/cZLVKQ9d0zg1V+IvnnFIdm9QrlSZm5s/9Lf2w5hH16YxDZMgk8SpMh6L0py5isPKmDpuP4yxLWVupWkajmkg88NbWCJPcW0La2xxr4xIiyqu7hbVhkyZqvqUXBvPULLyb2z0qJTcfRbCGt1AaZnpunKAfGOzx398bZN/9/IG37jSZLe3t4hFcUzVdw4VwFTJKy703HLCOOXe5TqPrFYpuyZJIfR5ctbnQ8fqTFV8BlFCkgmQTMC3bUMN+bMhvFYbfn+CbVn4t0kwoNwir7ZTyFLmayUqjsG0bxEkORd2BuyX70wSJQtjF9VWJgTXWyHPX+/w/PUO11thAd7Q0ETO8YUaefbWbcYsE0RJwqmFCnfNeegatMKUbpxRcU3uX6qMVKrVTE1ZA5RciyTLcS0DU9eRuoHve9SqVSrVCpnQKNkGuzvbbK3f4uLla/R6vRElIBOCdphiyUwlq6IFWXZNwjijG09uvhqdAb/5n77J5fUd3twe8Mp6j+Way4lZnyM1m7mSzsu3elzYHrzl7/3TiA9qknmn6LJarcbP//zP89M//dM88cQTfOlLX+KZZ57h93//92m32+/qe5Mk4fnnn+eTn/zk6G+6rvPJT36Sr3/967d9X7/fZ21tjSNHjvBjP/ZjnD179l1973h8oCuZoazMyy+/TKvV4rHHHisG5u9NDC/6u7kpv3GlyW99+xaXdwesTnn8xKPLfOzuOX7y8VX+28dWCKKYl196iS88dx7btvC8twYjrNQcPnr3LC/d7NEehOga3DVf5vFjUwcGrVHRpy97Nt1+wNqMz41WSDLWphhKwSxXbaSUeI4NSPrh3qA/jiOubDQYQpulEGiaEgyVaDQicVtNr0GR7L56cYdLOz3lsGk7nL3V4drugI/dPcuUrwzVhjDbcSO0PSvivQVcopLog0dnWJvxGCQCS9cU38a1CxSciixXSWlomexaCkV1aTdA11AyMbFyzFysmkz7KtmG8cHFvpdIgihmyjNJ0gTTshBZhmcbNAYpcSZxzL1zUPY9dhtNNE1jxnX44/ObbHST0Vm61YnY7jk8slqj5Fj0BhGmoWOOqQkcDIkQSobozHKN2bJFL8rQNY26Zx1oM6rf7hAGA0Cj5pnMlG02uzG+LbF0nTAVmJbFiYUypxaP0On26fUH9Ps9Go1dVQW5Llkm0A2DJE0xdANTN0HTEDI5dPeZpIpPo5VmkFp5RNiUUuIYOjFwpRFw3/L7y+sYmsp9kOJOeDJDtv8jjzzCI488wt/8m3/zXX/v7u4ueZ6zsLAw8feFhQXOnTt36HvuvvtufuM3foMHH3yQTqfDr/zKr/DMM89w9uxZVldX3/UxfKCTTBRFDAaDEXrsvYbyjRujvRMhvP/w2ia/+PnzJLnA0BUH4flrbf76x0/yf3hylXa7zQsvvsgrN1qU6rN0N9bxncle/HDQqmsay3UX29C5d6nK0bqDblpEUYxj3f5mlFIJTNqmwfGaz3o74spuQFzsUHVd49R8iaPTHlku0LQM37FHi2y322V3d4dqyccI07HPFQghkKaNAsTevsq83uhztTGg5Dq4tkmWJjieRSdMeWOjxzMnh+W8RpzuGaFFcYJn2wyimO1ezM1WSJYLpks2R6bckcCmbeZkucC2hmRLDU2bTEoK0aaG5/ctVUgywW4o2e6GGLrGfMXmkdWqglkLQdmfhC7rmjZyWh5qOWdZVri0gk7O+Pq+vxK8sNlmJxBUHROzQG+luWC9E7NUjTkxZyGkJMmUEdt+35edXsz1VkgnyqiXPeZ9NT+ZKrmUnXykJrA/bEsh2qI0UxWdhDMLZRxTZ7sXE6Y5nmVwZMpjseogBJRLJRxHOXAKIYgiBSBwRMRGV5B6Bq5tUyr59GOBbxsjKaSD9x9cuHKdgeZzbOqe4rkpyJjaB0Mk84NWyQy7JXeaZP604+mnn+bpp58e/fszzzzDmTNn+Bf/4l/wi7/4i+/6897XJDNESe2PYXvs/Pnz6LrO448//l25eYeoj3cyl4nTnH/6R5dJcknN21NW7oYp/+qrV3igFrN5/TLt3CY3PfSCIdILQlaWqvQGIS/f7PLSjQ5JLtAA1zL4xH1LLBXHIvOM2Vrp9hyGQr6k1c4IopiVFZ+PnNI4MVdivR2habBSc1mquSOWtmkYdAYRFd/h0rUbDPp9FheXmMLkSnuLQaIUmQFSCeQZ963Osbf0HoydXkIuBI6lI4UYMb5tU2ejG43eqxUs+aFC9FS1RKsb8PpGj9fWu6r9BWhawJVdmw+fVMQ2yzTwHaWblu+zix6/XYbDc8PI+fg989xsDhgkHq6lM1uyR9doBF0uKX7N8DzWUvXbu1FGzVW7+CzLGSQZ9yxVRzBk1zIZhJOQ751+Qp5lOJ47WkQsQweZ0UnkhLK2kFJZIRSqz5vdmFdu9UhzQcm12WoN2GwpEdNTcxqWaeA51oHqS9PUP/0oY6ObEoQx90+b2GbGPQtljs94ZLnEtRThtFJyCz4RxexHfabvl/D9EuVajnmrw04vJooE290mti65b7lCHA4wPA/DOLhEzJQcNjba/Mnzr/D4A2cQUhJloDkax2e+MwO09yI+aElm3Gb+3cR7ISkzOzuLYRhsbW1N/H1ra+sdz1wsy+KRRx7h4sWLd3QMH5wrUUSaprz00ktcvnyZ++67D/ju7Y60go/wTpLMhZ0BjUFCyTEmjqdkG7SDhD9+7RrluVWuNQKGi5FqDUFvELHZy3nuWodMKCSRY+kkQuMPX7lFc7A3++gFinOxX9oDwLAsvn1ll3M7MTtBTncQ4rs2x2ZLPHlsiifWpliue6PkXfZdwjhVem5vXkTLM46treH7PlO+zeNrU1iGTi/K6UY5UtM5OeOyUjUpuQ76bZjxaueuzlueZ5iWao8JKQsuzR7AYRiea9PsDEjRObveRUOp+9Z9i7JjsNWLebPo5yeFlpk1sfPb+6wozbneDLnaCNjphqPZk6qIPObKziH3jEZvoHxXqiVPzbhMnfuXK9imTjNIaQUJnShjxrc4VrepFPMngTyg0zZUdsjzHCnlqBI2bfs2g/6977/SiMiFZLbs4Fk6dd/CNjSuNUOiNCfNcqIkpexPVu5lz+Xydo9vXm1xbificifnj85tcrmpQAuOaVAqLL191y5aniqyTBDECbFQnkCNQYJl6Dx0pM5jx2a4b3WaR47P8aFTc1RsnSQKuHXzJrdu3aTZbBSmdmpDsTzls1i12e30+cLXXuDV67u0YsGjR6rctfD+s9M/qEnm/ahkbNvmscce49lnnx39TQjBs88+O1GtvFXkec6rr77K0tLSHR3DB6pd1ul0eOmllyiVSnz4wx8uFrH8u6qN9E4Jmbaho6ExLt8khSAqeDxHjhzlG29cnnjPeKX28o0GUgPfspBSlc5alhGmkos7fZ4s7c2agig5sJtd76U8+/p1kkwipQAkW8kOH71rFt+xDux8h8ZZURSysbGJ7/vMzs9hWxamoRPGyg56ueZysxViOzbd7Vvcc7SqhCeHkv2FOvJ4rNRdXtvs049SSrZJnqUIdHKhTSgUqEoGHEu5RGqaxsXNDplmUDIEURSh6RqGYRSmWhEPLFfHGP1yAhGnaXC9FXJ2MyAs5G1sQ+e+lRqnZ92RhfFbhSYlUZri2iZRkrFcc6m6JhvdWHneuyZLVQfL0OkOQqYqPt1DKsv5isONVjSah2VZBoZJFgTMV+q3/f7dbsggzSm7FrppkBXn1rMN2kFaoOuMA8TRiu9wq9nj/JYSyqy5OlmqPIcubCp02dGZMmGcTOiSDSPOct7Y7LPbTzBMiyzLmPJNziyUODZXLiq1Yajd8/w8xHHMbqvLtRu7dGJB2feoeybL0yWm/QqdMGXQuMmxY/N86t65ke7dMJqDhEu7AUkmmKs4HJ/xDigivNfxQUwyww3tu4l+v/+uFExuF5/73Of46Z/+aR5//HGefPJJfu3Xfo3BYDBCm/3UT/0UKysr/NIv/RIA/+Af/AOeeuopTp06Rbvd5pd/+Ze5du0aP/uzP3tH3/++t8tAtVSuXbvGhQsXOHnyJMePKzOl4Y7wvVJVPSzeKYz51FyJ47M+F7b7WIaFLLS9IqmzWDLZ2lwn35esVJJRf+tHGZoUSKmjGSZC5KPfP4gPfn+aqb582XNoDWL+yxubpLnEt3WEgCRTu/lXb3V59GidLBcj+Xi/EErsdJR18MzMLJVqlY1uTJAEVD2L43NVBmFMyTF5/MQcvSDiSntygRhWFOMcGSkly9MVHlqOefF6m26hW6ahsVL3eGRteux8akpYEkZ+LUJIsiQh0eXIijnLMtJEEIiMoN8likKcwiBsWNnFScYghQvrfXIBNVfpmSVS55UbbVyjzhEOkiTHwzR0elHKdjdC19WiHCcpZcfk9NzBR6Facmn3Q8UP2ZdsF6sOq3WXW+2Ifpyh6Rq6lnNqocZi7fazQ1PXQAikaU2okYmCEzQ56NdGCSZOsgKMIJguWSSxAE05b0ap4FY7ZL5iU/ZshGQfMhAu7QRsdmNqnoVlgOY6NPox1zo5JedwJetcAIZNmzK7AixXpxEmbPYC1ps91ioaFd+n7Em2trb5j19/ZYJP88Zmn/94dpvmQPG+TF3jzGKZH31gYQQa+G7EBy3J3On6FQTBezKT+cmf/El2dnb4hV/4BTY3N3n44Yf5wz/8wxEY4Pr16xPnq9Vq8XM/93Nsbm4yNTXFY489xte+9jXuvffeO/r+972SSZKE1157jW63y+OPPz4SnIPJwfz7nWR0XePvfPouPve/vUqjH49Ug6uOwYemI7p9cUATaqjfBTBTtpVgJQKk4sRkiVq467cdsiom/s12TJzm+LYxmiOZGmQo5eNHj9ZUWy6IqJU8+mHE1tY2YRiwvLxMisnnX92kOUgRUqLrGguVNj/y8Cp2QTZUx3vQQmCoTjwUoqyVPLpBxF3zZebLNjdaEZkQzJRsVuoeIs/HzoPENo1iV60+28oDpMjBspT4pmOTphmRSDk6raRX+s02Ugpc18P3PbLMw3ddOplBnIkCvaZ6xaQpoZRcb4UcmfLGklI6qRosJVebEa/caBGmAk2Dl250eOrUHDUb9i+ynmOPbKjjUbK1aRTzJl3TeGi1ymLVYaef4Ng2VVsRUkuOTbZPoXoYjmmwOl3mwlYHhEXJdwmDiE6UMe1bB+4FXdNI0hyJnNQuUyYExb1Z6JhJ0HQdQ0q0Mcu8KM3Z6SeUHHNkYiZFzlTJYbsbslo1JojE47HVjbjR7DNf80EKclcZx/XjDKPsYmgp/X5Inud85VsvcuHyNX78o48zPTvHF17fZpDknJpXOl1hmvPKrS5LNYfvP3XnJOq3i+/mpvRO4k4VCN5L6+XPfvazfPaznz30v33pS1+a+Pdf/dVf5Vd/9Vffk++F9znJtFotXnjhBSqVCs888wy2PYnEUkgfjSzLDvy39yreDSHz9IzN5x7S+Pq6iSzNsDLl44Y7NBpBsciHo+EyTLbL7l2qcmU3IMo1zDxVjpcY+I7krvnb71Yc26I9aKEbFromR8wNiUp8SS5GREVd0+kHyhI4zwSrq0cwDIP/cnaLnX6Cb+kYuiI6rncinn1jkx9+cBld18gLmZLDbWo0Gt0A3bTZ7QYjuHTdt0cGaMMYIr8qvosuMhqNBqAetK2tTVyZcXqhytVmSBKk6FqK1E2qrsmjx2cxNcn0jCRJEoIgpN8f0Gg0ME2LOBOgK0i2YVgjzoeha0Tp3oIeREoUdBw63Es1nr/WBKDmmeo4o4yvvrnND923hGswqkRNQyfNJ9tNyrq5SyvUEFmKX1EclaWay93L9QmiYzhUqHYsgn3De8vUOTHj0AkcGoOUXtTHMC3qnnVAH0xKiT+GinNNJTmTjSVPWThlTpXssTmMhufYo2o4E5JcyAmSpFZMldIsL56tw2X8m4MUXRvKJCmrBwtFiI2Ezurc9Oj6ep5Ho9Pnf/79Z6lNzXA5m+bUQpk0NbAtC88yqLgmr633+L6T07fVQvtO44NWydzpJvm9lJV5P+N9TTKdToe1tTWOHTt26MxF07TvqrEY3N4d88rugH/z/Drnt3osVh0+dsxHb1xmbXGRT//AGXRd509eucDXbzbHj5jeoNhJp+lEkpmvOPzoI6t8+Y1NOpFCly2UDT569wL1knnorndYEcyWbaTokEsTQ9dR1ZCSMVmd2hv0S5lx6ep1yuUKx9YW0XSNW80Bu/0E11L9e1CDe0fCzVbMVmvAVNlFzc4Pov2ElLy23uXNnQFxKrAMgxOzHg+tVN+yty6EJJcSXYMkidnY2MBxHFZXj7CqaSzUAq41BiSZYKHi8MjxWURhLwzKqM22Her1+gh263W3SQcRgTQxdKXBZRgGaWEGNx7j0GGAb1/bJBOSKW/vdTXPpBVkXNru8uBqDcswiVKlfjCu5RalOc9d77DbT0jTFN202IiaPLJaZW22MqFmPYw9hWolhplLSSokjm1hG4LHj9bZHSgrZMfUWan7WKY2slIAqJQmZ0yzJZu6E9IKIUsEUkjCIKXqmqzN+BNzmDBOR3O9XEg8WydMcixPibDatk2rHyoeUJ5RKR+OatR0DctWlSEoxQWzSFZ7nT2lXVYul5mdrhMlKTcaA7p5m6Ck0Wo0MAwD3y+RYhPqLkLCbXAl33H8eUky71W77P2O9zXJHD9+/G1Nyb7bSeawz3/hepv/22+/UsxKlH7U518R/F+fWeITBeLt3NV1vv7q4ZC+oLD0dWxz5PKokEIR//Ujy3SjDF2Diqt8QqRU7ZnxhU0lGLV4rdQ9lmou6+0QQ9fRDYMoz3BtnQdXaoAkiwNurG8yOztHtVpVi6yuKTfIQkNrGGqRsQiihDDNKRXtIM9RnIfxeO1Wl5dudjFNA0uHLM84u94jEfDMsfqhv1/xWxKiRKk1bG9uUKlUmZ6eYrgInpj1WZtS8F+1mEY4toUQcsIdEtRGwPdLzHoaHenRTUBqkjxJCbMEz9SoGzFBEOC67miBEVKSpBmObTKI8wmNONhzaInTfOSOOVXxaPXCided3+qz3Yupuia5niPJiTKDsxsDZsvOPqeXvZBAsxdyo5txaauLZhg4eoeTsz7LNWfCn0VKQZZrIysEBZuOAUma781rHlypcqMZcrOVEScpqzMeR6c8ar4z4SgKw7leTq3scnTK542tPu1AEVl3ugFCSk7NlXAtYwQHT7NsgqOzXPfZut4i1ZR3TZ4L4izHde1Ra09V0qqFqFB4GlNll2s3O9xqGDx672nSNGEwGHBju82JUspLL7RH+l3VavU9TQp/XpLMnwdXTPgAzGTeLt6tO+adfP54kpFS8g+/8Cb9KKNkG2R5hkSSYvC/PN/gv306IYkC/vAbr972M+Ms51tXW7y51UWic3rQ5v7lMmXHVFa+3uSuW+16k1Hl4rkW/VDNA0D15T9x9xwv3WxzcWdAlmXMl02eODHHQsWm3WzQ7vZYWVnBcfYUBoSQ2JrAcRziNMYttKgsS80bbEMf9eKFUKrOi55DXqD5lAhiD8sycQ0J6FgG6JrgynaPJ9amMcknqlBlzayRCEGv12Wrn9GmxKCb4Wxsc3KuxKm50kgry7XNkYVynGQHjNDGw9I1Pn7PHC/f6rLeiTFdl5WyxVpFxyGl2WyQZRmu6+J5Pr7vY1sGvSBmsV5id9CZmGUMYcnlQvvNc2ya3aDQ+QpH52C9Gyv5FkMnT9WCWrY0eomgEwvqzuELmkTy8q0ut9pKjoc8ox3lvHSzi0aVpX0OnaKwQij7Lkma0QpSLu8Go5bVQtXh5KzPybkSM1aCyDWWl6awLXOiXTf8bc1BSpILvEHCXUs1DB02exndMKHsGKzU3QmX0DBWqEbbMmj0lWX4XNliueaw0YkRMkOiWmdHphyOzlboB9FItNRxLNabA3IhKTsGSzWH61u7NLsD7r7rFJlW4oGTU/zv7pvBzgY0m01effVVdgPBriwRah6rs1UePTbDsUN8lN5pfNCSzJ0cz9B6+c+6Kyb8GUgy79Qd805jf5K52Y64uDPAMiDNUnRNw3JsLCkZxDlfOrfBzo3LeI51qCdJmgs+/+oWu/24qAkEr2z0ubTd5TMPL99WrHE4y6iVPIIoOTAbsU2dJ49N88TaFGEUs7W5zvFZn+vXbiB1nSNHjh66W6q6FsfqFhcaOWGaY1sWQRAhpOSBxfKBPn13ELE4N0MQJQzijEwzMckYp1TZhkYvFay3+ty/Oq0WGvbsnLuDkO3tLW62Il5v62hGiqlnhIbJN6806UUZjx6tYRSzoPHfOmozlVy6+xwvXdtAZCmPH62TFrMo11ItoUGUADMjc6ggGBANemzmAs/zqBkOvmPQiQSeqcbiQSKoeSYrNRfbMkYw614QUfYdwjglT5UEzv4qyHFsOlFAP4w5MjU1Skrj0QpStroxNc/G1CWaYeK7NrvdkMuNgMXawSpISnUzhKnkxRtd+nGGbxvkUnJ5N6AbZTyxVgOUHbKh6wdskftxxmvrPdqhaj+auuLgPHFsmmOzGv0oGZnL7Y+brYArjYBEqHloxZKcnC0xV3bohOp5qPsmdV957/iuUuqWusUfn9+mG2UIKYsWoMs9i2V2eglXL77Jx5+4j08/vMxC1QGqLC0tcXG7zx9/+wab7QFa3uGlazt86dWr/OBddZ46vcjU1NQ7UuMYjw9akvlOKpnvtcu+w3iv3DG/k9hPxpRiT17dtc3RzSFRvJhvvvQGc65aCYY73vF+/IXtPrv9uJhXyML7JCfIdV5b7/Gh41PcLjQN4ixjqx/z8o02nSBhumRzZrHCXNFa0TQN09ARQvLmhUvMz85QrU/dVoYE4EPHp3CsDpd2I5I8x7N0zixWuH+5uu/71TC4HypzsxnDRJfbZFIyrnSTCeWf44/aLBZpnqtKoN1jY2MD3dDZTGwyETNT2rNPjnWbCzsDTs+VmK26DML4wH0gUQTWSOi8drNFM0ipuBZ+KqgXdKLhPEhIySCKC3+aEMuysCyLlcU5uoOQKIoJwwARdlkxUzYykzi3QEpW6g73LVXwbbNQtt5brAdhgmOZVH1V7e30E5wiIZumSWcQ4pg6dc8aAR2GKtmjz4hzcgmOZZAVfC85lLiJU7JcjtBew6iWFC/m/GaPIBXMVdzRzNA1Jc1BwnYvwZMKoBCnGVmej+5FKeH1jT7NIKXmKU+bJBPcbIXUSiF3zbmUXedQf6DGIOHsRg8hJLWSi0Rjs6scTx89UmO2fBB8E0QqMb+xExHkGjXXRNc1wiTnym7IfUtlHlxR91lz/TqXp03m7ztZiKNK/vhSi1BoPHJ8fqQufmmrw/MbCTV5kTzZszGemZmhUqm87brx5yXJvJfosvczPvCVzJ9muyzLMhrXz7PgCtZDfXSjSikJkhx625T1KmAwtP4tuQ5hko4WqI2O2tVrGui6RZbGGKaJzDJudWPsQip+fwwZ+s9d2eVrl5pKPUzT2en3ubw74GN3z7E27TP0EpFScGT1KIalko/nWoSHtJgADF3nibVpnjyu049S6r59gGAJkxDmPFcmYqcWqrx2szVyWMyEOheLVXe06IRxSsVz6HZ73Lx5g0qlglup07u1ia0z4f9ia5JeLgly7QCXYzw2OhHfuNomEWBqGp0oIk0kVinkvpX9PBRtYqF3bZN+ECPR0C2buusyPa2xkGUcDwJavQBd5uRZl6ibkZt10sw4sBAMocsPHpniqxd2aIUphtTopwmGYXJ63qdcVKZDK4DxmZJl6AoVl2Yj/osEwkiZlu1HV7m2OdI3awcpSptTYlkWaZpiFAoS/TjDsySWaRSbC3Uv+q7DZjugFSowwJAYaZs6tbLP1Z0uq1UT2zyo5Qaw3olIc8F8xVVyPhLmqx67/ZjdfnKgvTe8Z5qBoBPnrE7XSAvVad82SXPlaTP+vtcu32Kn3edTH7qfXizY6EQsVPYUGnRd59h8jZvtiCP3HGHR12g2mzSbTW7cuAEwmuVMT08fcMMdSvz8WU8yQojvVTJ/WvGnMfhP03Rk5ey6Lv/DZx7k//G75xiMKedmvQaPzet4+0hk+5nxQ4ti07JHPJjRdyHJc4nv2gcW2GrZo9ENeO5qGyElrqmEGjXbIQhjvnmlxUrNYWd7iyRJ8B0Lw1KL/FAEslJyafdCrrcCdvsJjqFzbNan4pj4hUCjZyk2+FDFeHxXOIQwK98WgyhOeXCpTJLD5a02Uaq84herLt93amb0XsvU2djeYXtnh7UjKxiWS5wpgcn9qUxIiW4YZFlKySsfytCXUvLaRo84E1QdA9uxEUKym8Sc3wk4Ob8nfz8e/TDGcywyKTm/3efyrtqFu5bBqTmfEzM+1WqVarWqWmAIojBgfWuHJElG9sa+7xVirKq6qdrwsTOLvHajwXYnwrd0Ti9VOTo1qdMVJxmGoY+u7/H5Cue3+rTDlJpnYWgQZYI0lyyWDMq+M3Ln1HU1NB8WQo6p0xZq8yJEimPbRLHawFi6Ttm1lfXC2PcHUUIuQWraBPPeMAyIM3KhQASWMVQTmCSu9qNcef+MQdnzPFdKF9rhi3bZcwiSDKQkzdQ5VG62GpahoOXDOZgiC0f0g5jf6n6TDz9674EKEhjB6Q1Nw/M8VlZWWFlZIctzrm+16HTarK+vc/78eTzPG1U59Xp99BkfpCRzp+KYwPdmMt9pvJN22Z/GTKbZbPKNb3xjwsr5//MzJf7N87d4Y6OHLwPc0GC1fviuYsSMdx2lCrAbEsfxCKKpeuYaJ+dK5EIQRgnVkkunmDmUPMVv2OpGRGmOY+mjcyOyFNdx6IYRb1y+wWzZ5tTJ47xx7s1RQgDVy99u9/nypQ63Gv3iyCQv3+rw8XuXWNH2FvNJFeNoDE+m2hUlzx0RNG1T55ljFR5fq7PR7OPZBnNle+zaSXa2d2h3uywvr2BYDhXfhSBiqeZwYTspZgdq4RqkgoptMF9RKgLVknvA736Q5HTDDM/SsR2HNFXilCXbJMgEjUEy4bUzGRov3WjxxmYAMsc2dPpRxos3uqS55J5CW0vTNGzbxXZcyrU6YRQXs5yQyze7NGPQTYuZssvabAXXgh+6f4WL166jazpTU4cPpvNcEOYJtbJLtx/x8GqVV251aYdqVmEbOsdnfI7P+HvunIaOZZoTKs3LdZetnoI4+7ZOFMcEuY5nGazNlmk3dw/9fscAW4MMHQuh5i5S+QSVHWMMZagVIJM9G+qSYxCESiR0dK9IqdQpOFj9lDyVNByjULEWEuIE27LJMuWNNF9Rc6ehejRoyodnp0Pzy89Rqi2y2bNGmmtSStY7MatTLktjygmXdgb80ZsNbnXUvXJ8epEfePAe3Dyg2Wxy/vx54jimWlWtuSAIsCzrHa0x3+3I8/xdWw8Mk8z32mV/CvHdrGSEEOzs7LC+26F65C6s6YXRTXlyrsTf/vRdbLe6/P5XXqDde2t12SEy6IHVaa43Q97Y7JEJiRSgIzk67XFmUS1wEugOIqpljzRJC82xYhA7VF4sng1N00jSGDSdctnn+NpSAXXWDmi6vXSjy61GTw1jyRWPQuj80esb/PghoIPxeUqWKRa8aVmcvdks0EzKigA0bE1wz3JtRPADJWbabTUIk5TV1SOjAe2Qdf/wao2tVo9BnI92syXX4oljNaxirtQdHJxn6IXasKYbZOmw4pOkWYphebcV7qz4DjudgIvbAwxNUiv7JHGMYyoI88WdASdnfSxDLwbmgjTLMXSdSsnHMEwaicnFQBImGULmXG33eHOzy+MrHu22hS7liCdyMCSNQUpjkGI2QpbrPjXf4sMnp2kMEtJcUnFMKq4xusBpJqh6DnK4WSh4+otVh9NzPlebYaEUocRYHz42TckxaN9GJdu3TZZrDpcbAZ5jY+kag0AtzMdm/AMturDQybNMjRPzVbYv7dDNleGZkJJelFHxLGZL9mT1o2tc2+2T5TmmJpnyTDqhAikkmSDKJa5tsVJX7SxD14gTwbVmyM12RJwJLENjyu8wM7/IRTmjINBI5ssOP3jP3GjuttGJ+DcvbNAJU+YrDkJKXrnVpRmk/MzTR7hnfl6pY4Qh29vbdDodXn75ZXRdn2itvddWIe808jw/0NZ7uxgmyffrmN/L+DORZL4bM5kwDHn+hRf5N+dCvrJukL14BV27wiOrNf7Hz9zHcl0NpX/vy8/THYRUSz6dfvCWOyNd1wnTjE8/sMzJuTYXNrsMgoAzR+c5On2wBz8IY0quTSZSBJLFqoNvGQRJjmvtqR0kmWTKtzhzbBltrO4YJ04KKbm8O1CoIZmj6TqaoeFpOYNYya7st2OGPdKea5vcGmicu7ZLKtQi71kGTx6f4vhMaeK1nmPR7vZoN3bBsFhZWSkADnsRRAk13+KxeR2tOk07SJkqe8yXDHx78rYbzjOGtgC+bTBfdbnZjjAcQ+mfSYhyjZojODpTRuT5BKqqXOyqu1FGkgnKjkGaJNi2kq1xLJ0wzelFGdMlS0Gni5ZlLgRBFKMbFq/e6pALJQMEajjdjXNuBgZres5gMEDXQOQ5umnheR6maY1afFd2A6SuREPPrne5e7HKmUWFzjosPMeiF8Zs9WLW+znb7T6eZXB02uPUXInlmks7zNB1mPEtamUFb3ZtiyhJkUi2ewlb3ViRTX2LtRkf1zLYGuTEWU7ddzg65UxUBgCdMOVGSyUx37ZYmytxz0KZq82QXqy4XDNlm7vmS8VmQ20geqnk7HqX9iBCShBpzkrdol5x2eklJEJScQyOzfiszVZGiL1rzZA3twdYhgKNJLngVjsCNnmwpHH65Ammyy53z5cmrK9futmlGSScniuNnr+yY3JpR9lGPHV8Ck3T8H2fhYUFrly5wkc+8hE6nQ7NZpObN2/yxhtvUC6XRwmnVqv9qUnP3MlMpt/vUyqVPhCV2HcafybaZXH81sq67zZ2dnZ45ZVX+EqzxH+5BUiwTdUTf+FGh//uX7/Eb/1fHuPffeWFgn+g0R2EhyKIQBmRpblgoV4iilOSNOP4fJU5X+fmrfA2mH+JZyvv9nHF5adPTPPlCw3CVIxQRZ5t8H2nZ9GAJM0pFW6b+5NMXogsgkLCabpe+IHc3gQLFGnvRi/htd0MKSQlR6GvgjTna5ea1D1rpBeWZjmtdpt+p4VbqlKv1xjuqHMh2Okr+PVs2UaTOVLkPLg6ja7rEw6X+2P/POOJY9P03tiiE6ajPbulw4NLJdI0wxqTjXEsk6Co7mxTV7MgIbENTQ3MDZM4VzBk29RvI6KpcXm7S4pB1d27L01DxzElO6Hg0WNze+1JzSBPY27s7mJZNn1pc7GRUfE9TE2AbRFmgnMbHaZ9k6PT/gGJGV3XyHLBejcq2nmCkuvQiVJevtUlTAX3LJRHFei4Nl4Yp5Rcm3Obfa40wmKOoSD46+2IZ07OsDatJGV8x8LQNKIxsEcrSHnpZodBoTgQ5xnbl3Y5szrFk8fqiryqQ8UxJ57TKM15bSOgH6bMlF2EyGm0Y271Mh6Zsjg5WyITw5mieqYM1NzwZjvCMjQqxe+xDANd09jtpwx6HTrr13j66QcmEgzAZjfGsyYtNgxd+RWN22SA6k50U52rzYjZcoWTJ6c4efIkSZLQarVoNpu88cYbpGlKvV4fJZ3v5oJ+JzOZYZL58xB/JiqZ96pdJqXk4sWLXL16ldP3nOF/+K3LICWWrm5ao9i5XtwZ8M/+4JsQ9SbeP4T25oX4YTdK+erFBjfbkeJAGJInj01xer5MFKegaQcgqsOolvzRojuuuHx8FlxD8PLVHRJpsDBV4e6FMkfmqiNNtCCK8R1zQg7H1HXmKw632qH6PbZNnmWkWYZlWcwdAj8dhqbBhe0BWZpSK7kgJZquZiD9OOPSzoDH15Sdc6PRYDDosbi4yOz01Miz5GYr5NvXWvTjDKRKjA+tVNDknibY21k25LkgyGPqFZ9WN+Djd89woxUV8vc6RthioWKNzplezLOyTIyGx3XPZLZss9GJ0V01AI/TlDDNOT5bZqHmj5QU9oeQkjzLMAojMtVLNyHO2DvVGoahj4bMy0vL7LTaXLneIc0EYb+DaRgYpoljmoSJ5FY7ZK5kjSRmhjJASoQz5uL2gEwIpnwLEHglmyDNudoIODrl4tvmSFl777glW72YW10D29TxilmLEJJGkHC5EXByxsMyNNIsJ59Q05ZcbQQESc5MySqG9QmRZnBxs8NqbZ7ZsnGAfwPKsrrdC5kqKcsK27ZxTIilamst19wR3H1oOZDlAt00SYXENScXW8fUCcOUIBV0g5B//cVv8umn7ufkyvzoNTMlizc2JzdJQwvv6hixuR2k/G/Pb/LN6xpfHVyj6pp86Fidj989i23bLCwssLCwoNCigZrlNBoNLl++jGVZo4QzNTX1nmol3olA5lBS5nuVzHsQt3PHHMZ71S5LkoSXX36ZKIp46qmnGAiLXvym0vOSezewoWtknRYvX8x4aLV24HOiQvzQNE3+/as36IYZpmUh85ReCn90fgfL0Dg2U0IIhTjbr85c9h26gz1zM1APTT+MEGlC0NzmqePTxUI26XCoQiNKc8qeQ5rviWY+fKTGTj8mEgZ6GCukkZQcn7I4uVAjTJKxxXLve8u+S3sQq511luI6HnmejSyPgyRHiJzNzU2yLOfEsWPkUum0lVyHjXbAVy81iDNl3asV7/nWtQ731nTiRJEClYlaPLFgD2VselHGRjfCtm1qQYcjMxUGUcypub3d3M2b7Yljz4XScLMtkzhNi8/TePRIjW/lbZqBUp02NI35ss1DK5XiYT/8wZ0u2ViG8tLxbRPHVUipKBOsHdLuBAjilJmpGn4jx0kjSpZSYM6yjDiOSTKNbk8yCEyEFFRLPv0gVLyWICJKBf04xx9Dy+V5jqNDF4NOlFHz7AP+MADdWBDGOXPVPXdOTQPfdbjZVElmGEM17Yrv0eoFtIIUzzawLHuEBnMtneYgZasTcHy2jGVqhf21CtPQFZJseOWkEjI1TZMs1wjHREqllNiWOUJR5lmGbRjkwPgIPM0FpqExU/FGfki/80fP49fnSFzVBlus2Dimxo1WWFhKS251YuYqzgjIIaTk3760yYu3evgmHKm7tIKUL7y+g2cZfOTUnl+TpmmUSiVKpRJHjhwhz/NRa+3atWucPXuWSqUy0Vr7TtBqd9IuGwwG+P6dqx58kOJ9TzJvF+9FJdNqtXjppZeYmprikUcewTRN7FQ92P2i9zyMqN8l7WxTHdtJ7Y8sF5zf6tJP1AKHzEHXMTRJkktevNHh2ExplEDH1Zk9xxrJqKy3Q16+1WW3H1OyTVZKkjkz5tSJNXRDCRv6rkV/cIhwYdHnrlfLZFlOmgsWqy4/9sgRvnVph+2eoGzpnJ4vc99SlUHBHxHF3GMYtbJHdxAxU7LY6oYgJXmeoukGwwRQtnVu3LiJZVncc9fJCcmXQZQoReUcKmOuoWXHoBvlbAYauRBoms4gjA85Bsm5rQGvrfdIhVqcTB1OzYU8fXIGkQvSUatvUiV6aMwGSvY/ihWXpOyYfPSuGeV5nwhKjkLE+a5FLwip+t6hRmR1z+TYjM+lnQGpFGhRQK6ZlGydu+bHWxf7h+cpS3WPm+0YNA3bNrBtmywXxEFC3TVoNBrkuZK8mZ2aop3n6IVZm65r5Ps2WrmQiCyj6rlY5rAduBcTKgmZ2imbpomu6/S7AdYhEO8hoqzsOxiGUuPOx9SmhVTwE0NX1U+mqVlXP4yRUuJYJq6p2lRDxCBAmqQI02N6rFquljy22gM2uxGDOMezDaquruSASi66UPdsL844NldGE+o4klzw8s0uu+cbzE1PsXL0GFcbAdMlC98yuNGK0DVYrrl8+t65EVfrWjPkws6ApapF0NGxDFXZp7nkm1dbPHW8fltBV8MwRgkFlFHbkJvz2muvIYRgampq9BrP895VhXGnM5k/DxwZ+DOQZL4TCPO4Gdrp06dZW1sb3RyOZfATj63w//7aNTIBupRkSUzYXKdecjk6/da7iEY/RkqBrluITBSbaA1dkzSKPvGQdyILC+aK75CkGVLCtUbAfz63TVbMUQZRxE4P7luqcEIzMU0De+QlclioKiCMUyxD+bcLKanrOZ88c3iCjBJFCiy5ttqtu/ZIseDuxQoXt3sEqcTXBTITxJmg5Fq4SZvKTI211ZVDlXrbA3UuTNMtFi0VlmUySNIJqPXeMTj0goCdfsort7qAYosLIYgywZtbfWZKNifnS/tcP9XZ8B2LfhDRCVPObvTY6ilV5sWqyz3zHjXPYrG6h+jZqyY1ugV0Ny3Y8uMClA8sV5gp2VxvRYSJxmzJ5r4jdSx5u+ugFtQkD5jydFqRRBPpSPdsseZxzxG1wKVpShxHtLtdojDEskwMy2Ha0bjZzRR5U1fuq90oo+5ZzFUdtMIDaJJPIqm7BtZAyQX5NkipyLJxKjgxe/v7N4pTVqc8LuxEJFmOqetIJN0ow3cMZor5m5TQDSKCTGOzGxMlfequyXTJZref4Fk6uqbRTSVVS7A27eMW6gk3Gj1evtktNnFqNuNaBlO+xSCKQTeRhYr46bFj3ezGNAYpU76FjAc0bl7ixImT7AQZn3hklpWai65rrNbdiaTRjTLiNGfO1QnHEkDZMejFOUGSU/PU65uDhG9fa3N+a1C0das8cmRPVdxxHJaWllhaWlIdhn6fZrPJzs4OFy5cwHGcidba28GT75Qn872ZzHsU76RddidJJssyXnvtNVqt1gEztGF89qMn2G4P+PzZHaI4Idm9wZRr8ENnZqhXvJE3x2ExHMaKLEE3TKRQpDMhoVIQNodQW1ksElkukCg74m9dbZEJiWOonb5pauRonN8e8MBqnSlNw3UsHMsiyw8hLAKXd0M2+z00DY7NlLh3dXrkn3K7yIWSYamWfAZjIpwzJZvHl13e2IkJcnU9pj2dNS/kvpNHcT1/xJ3ZH1VXIcPSLMWybLI0wbQs0ihkyh4e7f5jUNDl5662SDLBTEW16IZuj91McL0ZsDbtjSTzh2uHaegkeU4/yfjKJaWF5pgGeS64vNOnFaZ8/4naCMWmSICT1zKMEtpRxrnNAVvdEF1TC9c9S2VOL1RZrY9BTqXALfxZ9s6/pNFPSYSG1omYrzg8uVbnajNkNxBkWcpS1eHYjD9avCzLpF6ZYRDFdMOMfhDhmoIZs0uDnGY3VWAN3aDqWzx5fIaguEa2ZaCZGq1+TDNI6AxyZko6J2d9LuwECjZtCvIsZ3WmzNr0JOR+pxdzrRnSjZXw64n5KnN+QjOSJIX1sm8b3DumZyeRvLHZ52Y3IRcKTHJVCubKNmvTHrt9BYKZcuDMok/J0pW8kG3z5taAQZwxXbJHTdFOmJJkyuYgyQW1kkPNtVXSKaIVpOi6NtKKC8OIc+fOYU8vsdmZmjA7k1Ih67pRho7SsevH6USV0YsyZsr2yIlzt5/wP3/jBlcbIb5jkOaC19Z7XGsG/DePLB1oiWqaRqVSoVKpsLa2Rp7ntNttms0mV65cGbXWZmZmmJ6eplKpHGit3Wm77HtJ5k8p7iTJjLP3n3nmmdtizW1T5xf+wmkeMDa40DcZLM4W4n1784ZxyZhhSCl58Mg0z11rk+QSiwxN18mLgubeJUUIGxEqhaBa9kZEtkGS000khrZ3A2q6ji4lUSZYb4esTJcLcp4c6XINPy8Xgpd2JY24zZAvc6kZc36rx48/dnS0MN0uNE0jyTI812YQxKMUsFA2mfV17FKNZqOBnscsLa1iWg6WaRAX0v3748RciTe3B/SjHE/EGKZNqx/hmDpL/qQA5thRqMrCtNHNeKICApWgo2wIGCg4PbaFgJHfy9VGSC/KqLrWqOXpmDqtfsRmv8LxKYlnW4V//X7xyoSvXGopqwPXIU1Tzm8PGGQaT61pI+WGYQzh27ZlEKWSr19usd1PlUUxSmjziaP10YzAc6wJThHstZBeudVlu6dIqo6pc+/qAj+wCBvNPu1+hMxjZt2UsLOLcF08zyNJJVcaERcbEYMwJk1TvHbOA0c8nlir0UkUJH7Ks1iqOVR9Z+TOud6JePmmIqPapkaUa+xc3uXMYpkjUy65ZpAkCfMVB2+szbbbT7jeivBsA9sC3bDJcslOL2ap6nL3QgkhYfNWoCoPKfFsh832gCDXKDnm6KxrKNhxP85GTqpVX2moObY52hyZ+sFNZ57nbNy8zo1ZC/nokmoVRxn/35c3eW29R5gJSrZOlksagxgfhYJrBUqF+ukTU6NE//UrLa40Qk7N+aN2XzfK+Na1Do8eqXFy7q0XdsMwmJmZYWZGJbsoig7I3uxvrd3J4P/Pi6QM/BlIMqZpvqvB//r6OmfPnp1g7w/j3GaPV291mS7ZfOTUjIK76jo3NrcoVeYoVycJU0PJGAxGFsLAyIL4B8/M8V/O7yhXxjxX7Zaj0zywMplkKvt1oqQgzxI0XbGctaFG2vDzy94Y+7vQ5Sp5DELFS7iwPWAnBMfUsEwD3bRI4pgbrYyXrjZ4ZG2aKE3J84Or+3DQf3W7y9VGQI7BjG8UO18NkQt6jS0c3WBx+SimYWCaBt1BhGtbCCkOaK9VXYvvPz3Dc9fadKKMJEmYKbs8eqRGsHOD/ZXMeMz4ZrHT1UYcIClVtTM/gYjTCJOMBd8lSVXrTEngaxMzNUXk1Fhv9XlwZZEsFwcg5wAXdwLCJKfuKYi3X3LVgtzqs163DkjGgEK0JWnO9T7cbCfUSy46glzotIKU5693+OhdilQ4zikK4xTftej0Q56/3mGzG1OyFfs+SgUvXGnyxPFpTi/PFKrUAk0KWp0u7XaH7e0dQmzOtyWGbjBfK9HpdIgFnN3o84kzC8yVBbC3mRq6c9q2yYXtAbmUTJWs0U69G2pc3g34geI5KHklwn3w/N1+ArqOXayPIleIPtu22OrFHB1VSwpkPm6ylqYJJddWenj70CYScC2TXqi00ra6Ca1IkKQplqG0ocM0H6kTRKnE0CSt3S3+4E9e5oeevI9/+9Im37jSZr5qM1O26EYZjUFK1daJY43tfkLVM/nkPbN8aMz36I3NPlXXGCUYUJX4VldVeuNJ5vJuwMs3u3SilNW6xyNHqszsg1e7rsvy8jLLy8tq/trr0Ww22dzc5M0338R1FSij0+lg2/Y7VpT+XiXzHsbbDdCGlczbwV+FELzxxhtsbm7y8MMPMzc3N/pvQZLz3//b1/jym7sIqZazmbLFP/3Jh0i6O1zd7nKiPHvo5ydj/u6DMKHsOXSL1svRaZ+//OQRrjfDYvDuUPctqiVvJBnj2ibdfohVQCLTNKW5vcGsp7ET5uiODSIHKUkyge/azHoHdz39gp2fZQraCgoJpxsmeZqMWkjXmgF3LZSxLQPT0A60z2plj29c3Obb19qjXbam6cxVXR6cEmTRgGq1yuysOh+VQvYFIEoKW+FDtNcWqy4/fP8CYa4WuCnfwjJ0rraN21QyYBkmK1VB3dVpBYrvIvKMOJdUXfPArtJzTNr9kHqtimUqNNRhCURKqRwfi7RlmcYBI7TdQaLg5cPqMM8L51CNTpjCIUkGFBrqRiuhUiqjs2f/XHFM2mHKbl9VBLBnGlb1HYIkZXeQsDtIqLrmCNquABIZ5za6rE3P49oGlmnSCyKmpqaZmoI8z3j+Wos0D7HJabUUosvVJFEOl7e7hxJts1zQDWJiaeBZQum1mSZpppj53SijG2XMlm0GYYxjmUj2QBme45ClAdhjMwcpybIU264wTC5Squry+m6fIMlwLYOKY9IcxMyWHXTTIMty+kWrruZZyn48l7x8s8tGVyUmy7JJkhjbVKoBQaKe+5LvcqxiMlOyuHRzm3+51eZiUmWhWhp5M82UbHIhSaKMz5x2OHPmGFO+NWqTpblAKygF+yljw8rJHJvxfP1Ki999aZNelGEZGt+40uIbV1r8zNNHRioG+0PTtJE23rFjx5TgbqPB2bNnuXLlCufOnaNWq42qnLdSlA6CgPn524OP/izF+55k3i6Gvcy3Gp6FYchLL72ElJJnnnkGz5tcIH7t2Yt8+U2l9WTqauFpDlJ+9n/6Kv/HM0N3P8G4Z8p4KPhnjG7aXNvtUvOskQChZegHFsOhVEouRDGHKaDAQcDW1iblcoWP31vjP57dphcloBsjKO5HTkxhm7f5ncWQX9fVZdN0A5FnEzfqkNswdHrc40aA79rc3O3x3LU2QkhKthJDFEKy2R5g5zr3zdijBK0SzOQsI8tzLu/0udpO2O0oZ8i7F8ssVFxqZQ9tEOGbdnEsquopew5hMnmcGmAYisfyA6emObvRVwx/22a1pGYD5TEZHMc2idMc11eLd65p3L1c41ozZJDko8UkSHIsQ+fM8tSoGjQOSYyuqTTNhseiaRp5YZntO7cf5GYC0A1EGmN6zmgDZBYIsSQ/yOfIcoFn20TpACEOyvvbhk6U5QSxUkXYnzgNw0TqJq7tUPYUECaKInRdJ05jthoRi06K53k4jjtxnk1NQ2QJtutgmwp8AIyssccBV3GqrlGKjhQCz1QIsiQXI8Z/JiS5gJrNqJ0c55Jv3+ix249HqLOSrfg7O70IQ9fRDOWseXq+zFTRCdjoRmx0YyquiaUXkxvHozVIOD3nYRs6vufg6oJq4SILsNXq8+aNDR69/y7w9matZcfkVk9g6HtyNhudiGfP73J2o49eqFh0wpSZkoVnG0gp2eolVF2L03MKgNCNMj7/2jZCyBGqUAjJhd0B/+mNHf7KU6vvmEg+5FM99dRTE6i1a9euoev6qLU2MzMz0dbv9/ucOHHibb/jncQ//+f/nF/+5V9mc3OThx56iH/6T/8pTz755G1f/zu/8zv8vb/39xSf8PRp/uE//If8hb/wF+74+z/wSWZYXmZZdmiSGbL3FxcXOXPmzIHeZ5zm/NsX10eOfqBu1TyNaG5f52x1lrKjbH9vN5sbxBlfvtjkRjNAagaWLnjsSI2Hj+yx3fdHECeUHBvDMBBC0mq1aLWazM3NUamodtp//cgSl3YGNAYJFdfhgdUaBrdn5oPakS3VLK42DEQuMIzhnEYtTEenD3IjqiWPME5I0owbLVV1DROMel2OJiWbA8HTa2VAEQX7wcHZzmvrPV643iYXEsuyubgz4Hor5FP3LwP7gRJKi60XREzXlItiLiXr7RChmegyY75s4dsmT6zVeeyoItjVy/4Eik3XNJBDAl7x26SkYsKTJ2Z57sou3VAtno5l8MjRKcrWnrbXkOSplKcLHa9pn91+QpTmVHyXJEnoxTm2oXgZ48l5PEq2jqvnhJnAyTJ0XbVcB1FSOI1OPlJD6Dqk1EsuhqEXSsh75ynJBSXbxLPNgryYH/AqqnsW6201PzMMA13XcVwHW+aszPpkWcz29raai3geuuVi2A4V12amZLPRTzA9C13XyfKcfqSG8vUxMuNOP+bcZp9unGOaNr6RM+VbNAcJA3LQFKVsoWKzUnfVbzYNNkKDZhZS91T1muaCTpQxX7E5OuUqCLOlc2qxTt0zR52ARj8plBzG7hmhnFYzqXH/YkURbaXyb+qEKVGmKjIdwWtvnOfUsSOsrCyjaRrdKMMzNaru3pD/X/3Jda43Q6ZK9kh8U0jJjXY0AiRUHZNP3Tc7siS4vBvQGCScGFPq0HWNuZLN+e0B/TgvrNPV2vDNq21e3+xj6hoPrlR4/Gh9BJ7Ic/V7dF2fUJQWQtDr9Wg0Gqyvr3Pu3DlKpRL9fp9Op/Oetct++7d/m8997nP8+q//Oh/60If4tV/7NT71qU9x/vz5Qyulr33ta/ylv/SX+KVf+iV+5Ed+hN/8zd/kM5/5DC+88AL333//HR3D+55k3m5HoGma2mXuG/6Ps/fvu+8+lpeXD31/P86JUjGx9EmRkzTXQQr6cYaVZZRcu9iFTh6PkJJ//+omrUgoJjwZSa7z9attDF0fzV8mo5CMCWMkkn63TT+IDtgjO6ZRgAQkJdchiBLK+4ibh8Xd82XOrbfppBoyyUbTjPmKw6n5/cNCrVBc9ukNwkkWt5SkaQYobxKkpB8mLC+7ZFl+oM0Vpjmv3OoAQ8tigWc59MKUP7mwzY89uMjBy6ke5V4QkUqNL76+RSsUZGmKpsF0yeL7T05TckyVTAr+z9BvPs3ykU2BlLDdTxHhgJJtslCxOVqzOPLoKtd3+wgpWa55lFyDLNufrDV6QUylpDTp1mY82lHKjXbKTmeApml4lsHDq1VKtjEiLu63Q7BMg6M1wZstQSdMcU2dVEiEZnB8yh7ZWYOqHMcRimVLXaONbown9qTwhYDjsx6OZY7EUruDiByD7W6IqcFKzeFGO6IVJHiWQaoZ9HoxMxWX1ekSC/V5Ov2AQZTw2q0O650OWS4U+KLmULUMmv1IadppGhXX5P7lvXZNN0p54UaXKM2plz2SJKEd67hGxpnFMp1IQe9nSjbLNWc0SA8zyW6QMzNVxizIu5ahU7INOmHGA8vVUUVqmQrPb+iGItJq2qHTOiFyciFwbYtuGhFnOa+u99juJaS5GPtuwYWrN2h1e0wvHSFM4alFZ1TVfvNqi+utiJNzpdEMZsq3uNoIeepYndmyjaXr3LVQYrVeqDzISbmmw+7mYfTjjH/1J9c5u9HHNpXg6ws3Oryx2eenPrSKZei3RZbpuk6tVqNWq3HixAnSNKXVavG7v/u7/Mqv/ArNZpOrV68ihOCHfuiHeOCBB+6I/f+P//E/5ud+7uf4mZ/5GQB+/dd/nc9//vP8xm/8Bn/rb/2tA6//J//kn/DpT3+av/E3/gYAv/iLv8gXv/hF/tk/+2f8+q//+rv+fvgAJJm3C03TDiDM9rP338pzoe5bzJRsdvoxRoHEihu3yFO1K5wt2cie0tWaqVcPoMmuNQaK+yDzESRZR5IJeHm9N/GgDmOojZUkCWmasR4nbOYVnn1uE8vQuXuhzCNH9nY741paQ/Ott0o0M1WfDy2abEQ6u7EymFqb8jizWBm1NYYxHPR3+gGubbE6XeKFG22STIDM0TUdwzQZJDkrFRNQzqBCygnUDygYbJwqcuPe5ws826Afq0W37k8ORjVtSByU/NEb2+wMUsqWiWaYZLlgt5fwzWttPn7XDBMQ41jJ4NfKSn6nH2c8t5XTz3qgKX2yubLNMyem8W24a6ECEnRDL1SqJ84C652Yq42AQZIzV/U4MePx1PEZTnRDGgNlR7xQccZ8aobERZdbjT432iGGaZMNYpaqFpVKhYvbAwZJjmvqHJt2efTYLEGkqj/L0OmFCZd2Bmx0VEW0VHO4d6GEDjQiQT9Wbpun5ks8dHRmBBEXUvLqrS7XWhGpAEPTqDo69yyUFI8kyBBxzErV5sGjdTxLATPKnstz17vc6gs818XUYBCn3OzlLDsRFVsiDYuK73LP6jRS7p3vG62IIMlZqPmkaYpj6tgGtCPVln1k9eCu2jJ02oMEZSSbYfsecaycTk1DJ8qyMSKtcol9Y6NDK8wmBFXH23FJrlQL1mbLI73AF84pK++Ka1JxDOJM0ItVi1RK2Gn16A8u8BMffZQHp1L0InVd3g1wTX1iyG8ZOmjqfz997/zoGfnm1TZfvtBkp59Q901EIZOzWszmhJDsDBKePj5F2RkmsTZnN/qsTXujZ3kQZ3z7eofHjtZ5eLX6jjkylmUxPz/PX/trf42/+lf/Kp/4xCe4//77+fKXv8zf//t/n4997GP8wR/8wdt+zngkScLzzz/P3/7bf3v0N13X+eQnP8nXv/71Q9/z9a9/nc997nMTf/vUpz7F7/3e772r7x6PD3ySgUlpmcPY+2/5Xl3jr37kGP/jH75Jlguy7jZZpLwaZko2R6c9rvc1pBR7BmQmo8U1yHUQ2QF5eQ2pvNItCzGGfhtyMgaDAVtb23RTned3czLRxTAtgiTlxRsKYfSjDy5S9d0DHI6hVH6cZCPdr/2fb5sad8+6fKheV8escShHZoiEAzW4n6tYHJv2eHOrh67rhQS7Uj84M+9RssVodrF/pqNr2ihpaEpXBN0wSVIlilktuRMSPcMzBZJWkLI9SPBMHQ2BaVpAgmPpbHdjOmE2GuIOwzRM+mFEybP5L+d3aceSsmNgWyaZEGz2Yp673ub7T80QpxlV3z1Ub+vN7QEv3+yObKN3+glXdgd84p55ap514HvH46XrTc5uDkhyEFkPIXLW+4KP3lPnSN0lzSWmoaFrGkEUqzlFnCI1nT+5tMNmNx5xPrZ6MYtVh6ePTxGlOZZto+UZ0xWP/tg9cHFnwMWdAMfSqbsKGt+JJec2+3zsrhk1ZL95i1rFm5hb3WwO2O5nVF2boW1MyXdpdEMGus2Hj1WIo4gwDLh8+aq6XoaN53l0wxTbNAo5oeLKaYDM6YYpJbc6Uq0GJQqrGSa6FFgGxJnALlSvsywjSjNcU6dUcJU81+WPz2+x3lEISTQwTAsd1W2gILvqusbJuSplU907G60Bu5Gk4pqjhdyxDJXYpORDx6cV0MPQ2bl5mRtpiVKlRqkdKSXuQ+gHUjKqdgCePb/L77ywoThurqn4RGFGaOkEqbIkSHPJkbrHD94zN9pUvl5UMMPjAsWfy9oxl3YGPLxavSOOjK7rBEHAj//4j/NjP/ZjJEnC5ubmu/oMgN3dXfI8Z2FhYeLvCwsLnDt37tD3bG5uHvr6O/n+YbzvSeadlIDDJHP16tVD2ftvF3/5yVXSXPD/+g8vEvVbAByb8fnoXbNFO04flcjjaDIAQ/ZGN+b490nA1jXSJKFeUa2ooeBhs9mk3W4zP7/Ai2/skAr1EECO6VjkWc5mJ2Kjl2DcRksrKHw+0A2eu9Lgze0+udRZrFg8tFqbILHuHfPkHMF37VH/e3jU29u7HDH7LN01x5vbfeJMslh1uW+5QtUSbG43GCq2jc90On2lG1WyTQaJQgmZtk2aJESZYKnmoomcSnmSxDpMSlGaA3qxy9TIsgTDtDDymFSqRWo8LEMnzTKEkNxs9GnGEttgtCs1dR3PVAzxXpSxOFUqfisTba4ozTm7oUzchslECkE/h29dbvCZR1cOdecE6MUZr633kGjUHQPd9+n1+zTCnDe3Bzy4UsU2J6/doDCkO3ury1Y3puqao2POhWSrG3OjFXJitgRIKiW/UEfeI+5ebYQYhjbirBg6lCxBPzPoxJJpXaDWtcnvDpKMOE0pFVBZKeWoKgnTHKGZoxaNEIIoihBZQqvVIBnkhKmFzZ48DSipGdfUCgKvx057wNnNPjtBThQrhJ4BJLlSDLDTnExq5FLn5LSrxDsdm3PrbW61IyqOiVnMo5JMEOsma/U9aPVcxWWxao+6CXEmiOOEeslWHkBFR8M2NPqJwNB1vOIabLQDPv/iNazqLIurCSXHIE5zdvoJsyWFaNssrskDy6r7MYgzvniugWnoLBczmZmSzXpHydd834lpwiznSAFhHleINnQORTei7d2nd8KRkVIyGAxGHRrbtjl69Oi7+owPUrzvSeadhGEYXLp0iTAMb8vef6vQNI1PnizTvt+nFx1HK1o8w9gv2TH0aXctkxOzPt+4YhAmObqqtBFqDsl9S1UMXS8kYzyCKGZ9fZ00TVldXcW2HRrRtsKsDSX4c2WSlUm41QpZqd7elChJM77w+jY3OylSKOTPhTDmejPk6WWTOWvymMfnCHutLiVv0o9Seq1dEBlHjqxi2zaPn5gfteU8x2Kn0eQgp0WbMBb70PEpvnqxQZBr5F3lr1NxTJ48psQMD5JYVSVzZKaKqTWIM1ksnhpJHJEUs4navoG5aRojKZk4U0KMjrWHMAL1ICepIJeMjNxgr+UYRAoyHKX5xEDechycMKYdpmy2+ixPVQ7VMtvsxiS5YLrkIHKhRB5tiyRPud4KeXClwv6FvlRI9ax3AgzLnGjVGIUb23YvKZIMZIWo5fB6ZUIh1Kx9lbOh68hMEKUCvXT4Y+uYRqE7JgDlxpilqmVlmfpEQowywdVuzk4vx7EqLC/YdNZbdKIUW4vR0IiljmebLFbt4j4IObcbca2d4OqSkm0SpRn9DFZrFrmEOBV4ljJIO7NcI0pSsjxnpx8rU7wxwINt6vSDFNPwuH+pTJbnlH2HXhCz208IU8XLsQyNoIA/W5ZFmioAQNlzR5uWfpzx/PUO7UhQEg3apsagvkSOxiDOFCwdNZP50QcWRvYbG92YdpiwUJmEJc+ULLZ6CU8cq99WoufBlSov3ewW7qVqPWkHak53d0HKvZNKBvZUmL+TmJ2dxTAMtra2Jv6+tbXF4uLioe9ZXFx8V69/J/GBTzK9Xm+kSPpW7P3xuLQz4NX1LjMlm6ePT9ELQv7dV14kz3NKtk7Zc+mN7V5VJbO3k1atMY1uEDNd9fnh+xf5j2e3Rg6PuqZxar7EE8emivfDIAi4cfMmju2wuLiArqsby9Q1kn2kSCFydM3As9/69N9sh9xohegauK5DliZYuoK7nm/CbPlgQlALrEMuJGGc8OKNNq9v9IjTDFPXuGepyso+B8s8FyPOzO1mnv1C3PLUQoW5qsubmz36sWpxnZwtTSTtUduxALD5jk2WJdw1X+bV9S6DJEOTQs2FgGNVjfbOJqbj4vses1P1idZMzTMVzDdJqXgGuqEjcqWt5lg6dd86oMowNEKzTXOkIadpCg6cp3seNbq2p2U2tCHeu05Svb7wuQelJmxaFkJOGJgCChQwrEp0IEszLL9EksR7VbDcE5YcV9feq0Qjyo5Jc5CMzYcgl6BJgaULLMMYcTpaQcpWN1ZkS99iyrfY7sXMlBVBN9MMUpFyasofqRj044yvX2nRCdU9IQ2lMrFYrxBGMYNEDd7LhmTVz2ht3SJwXHLD5tpOStlRqsgiV6rbYaig4x+9S7HgLUNpmg3CiOlqmVZvcFs+rgYkaSFs6nlstPo8f71DY6AUtIctWiHVnNDOcqRukUmdpbKBU7SqbrUjBklG1dYwDI140IM8geoyT6zNctd8GV3XuGu+NEGodC0dS9dJMjH6LFAbG8vQxuyqD8YTa3Xe2FTHmwuJROKYBh+9a4a7F9Qm4k6TzHuBLrNtm8cee4xnn32Wz3zmM4Cigjz77LN89rOfPfQ9Tz/9NM8++yw///M/P/rbF7/4RZ5++uk7Po4PdJIZsvcdx+HIkSNvm2DiNOdv/O5ZvvD69uhv8yWT/2olxS6Ic0oVeWgjq9o6mjZeyShk2HCR6wcxR2bL/JVnPK7s9onSnPmKMzLxklIisoSr129Sr08xOztTKC2r9x+tGlxsqbaPrmtIIch1E03krNZsqr5LZx+CaRgbHaV+a7sOeZZimBZCZBiaxs4gn0iMw5DFaiqRPH+jw8s32siCmyE1ndfWlS30R07NAsqbpuK7RZKZlPQI05wLW322ezGOZXBi1ufYbIn5qod3WwtiFcMWnmcpCRjbcXn4SA1Lh9dutkhySdVXrov3LJRJ4xiRJfS7bba2tvA8D8/z8X0Pz7I4Oefz6s02/TjFFZChtOAeOTp728wYJxmzZYuq59ALY6qeiZQ5QkrCNGel5o52oOM2xEN5+6OzFV5d7xFn2sgHRUpJlKacWKljm+YEydM09FH1tVh1FIcnjPBdp3A4VXDWxapDaQx5Fmc5652YMOkyXy+xNuXSDlO6UYprKV+XWGgslpUNclx4tOz2Bed3lMXCMGHOV2yOzlbZbPfJBdhGzt2LNe5dKo/8hy7tBrTDjCnPLBZASajpbHcCPnnfIlGsoMV1z1LWF1lKGIZc3+0TJQIti8ktE8dxR6rZSa4UyIeGZGkuaISCb19fx7UttTGQkkzIEZUgLYb8cxUHvUAVvrEdsd1TbH1TV4KfQ1tnU9eIM4lj5Ty0WuVIbS9ZDIU4gVHmj6OYbucS1+ccfubpw9tNKzWXU/MlXrrZVWAHUyWcrW7Eo0drLL1Fp8Exdf7KU6s8frTGxR3lSnvPQpl7FsujY7kTccw8zwnD8D2Rlfnc5z7HT//0T/P444/z5JNP8mu/9msMBoMR2uynfuqnWFlZ4Zd+6ZcA+Ot//a/zAz/wA/yjf/SP+OEf/mF+67d+i+eee45/+S//5R0fw/ueZA5bXPez92/dujVh0HW7+Ef/+SJffGMvwUgpWb9xlf/1ashfeeroGKNX3dAlzyWKE7X4FwtVxffY7gwIE9ViMQ2dqCBB3rNUG1MDLhacfpeNnQYLC4uUSqURcXM4x7h7xqIdQyPIyaVE0y00kfH0iWmmfJvusLUz4bOiwtQ1NMNEpMoATeRKI01qcgQX3R/DQX+YZJy91UFDw7X1UV84yQSXdgY8cqRO2TFHPA5N0yj7Dq2W+txulPKFs9t0x2T9L273ePLkHPcvlArOyeHJERRK6PJWwMWtnHoUsFrLWapaVPMO33/UoT4zp3aOUtkAGJ6HY1eYn5+n2ekSBCE7nT7JdoOKa3LE8wlqOluRTiYErmXw9D2LrJQPT3YSqRZeNB5c9nnuhqAdKadODai5Jg+tVhmvRdIsJ5aSVOpoSHxDqRlf3BkQZwJd04gSBT44OeOOjMfCOEEzTJ6/2qQdKp+W1brLsRlPJZpugKYbmJrGsRmPtZm9OUxjkPDNq216UTFw3+gxX/O5b7HK9VbAIM5wHIfVks6ZxT0Tq04sONvo43gudSsvVJ8l24OMh2oep09OE2eCsmNSdsyiGrYIopSNToRjqApBN3TyNMMxlVfMerPPw0eniceqOoGB7vicWqtxub+BoZloUhAEA3RdQbhNkaHlKWCQ5pLnbvRYbwfFcxIqWwPDoBdlww4qmgYrdZfFmoPUoB2mrLf61MseutzTMis7Blkuefz4FKYOs7UScZxgWwY6yvHTtw2ElMV110b3gNR0rl+9zNdfq/LUfScO3K+apvEXH1tmEGdcaYSqekLj7oUyP/no8tvOfS1D55EjNR45Ujv0v9/JTKbfVzPEt0LNvtP4yZ/8SXZ2dviFX/iF0Xr6h3/4h6Ph/vXr1yeO75lnnuE3f/M3+bt/9+/yd/7O3+H06dP83u/93h1zZOADkGT2x2Hs/c3NzbcVyUwywW8/d4vxrkne2yGPBuTApd0Bdy9MXrTBsKVimUqq3jL5nW9fVT7t7N1Ajx2tk+aCTAjKhQ5Znme0mw0GYcyRI6tY1qTOVneg9MZc0+Cjx2160qUR5mgi58RcaVQJwV4rar/Xy5nlOi/e6JAINfRG08gzxTA/MecfwPMPB/1SSi7f2hrNlUx7DwFnGhpxKmgHKYtTpdFuWkrJIEyKFp7yxOlEKb5tjHZlqdR57kqDlYoaolZLHv0gOtAJibOc//T6No1QkCaCrbDLpV2TeSvhiaNVZmcVXFkIUSxkUgEgpDoXgbD52q0OnVACNlOuzmktY8XLWHI1TMdlbqqCbatjGLfEbocpr2/02ehE6LrG2rTHvYtlfvTBBS7vhnQGIRXH5Oi0NyEGCXBlN+DsZo8gzjFtm2kXHlmtMe1bXG+FSvbHl6xNOVRdiywX5HlCjsF/ePEm/SQfATIu7wY8slplpa587wEWqi7HillMGKt20PPXO/TijJqn2nq5kGy2A3xL51P3zZPkFMP7yWNthpJUQFUTmJZCdNmmRpwLbrZDTs3NTLxeHaug4rvoWgFcsR3SZBLurVByqqrLpOTF6y1utSOEplEydRxTJYqSY+LaNkGcInWY9zUaO9s0NdhNbW51lb/QcGOXZIIwE5xZqhJECVpRdS3XXGrFRifNlZqAzFNMxy7udVFUMEo5Y2mqMlJySIqZTdlzWKmnXGuG9IKUqiHRhCTIJBaC1SmXb7x2ie1Wl0996H5cexJNuFh1+O8/eZKzGz1ag5TpksW9S5WJ9tmdxp20y4JAJef3SiDzs5/97G3bY1/60pcO/O0nfuIn+Imf+In35LvhA5ZkbsfefydKzEM28DBknpEHijioaUry+7BQysLgOya//a1rbHX3ZjVJJvjm1RaapvHY0TpSKg0xS4dbN9axbJvV1dV9OxXJIM6LhTnCsU2khLvmKkjJhCrveCiflT35E8vQMQ144lidb11tFegrtQWcqzjcNWUUPAGl6WZbSiU5yzI2NjaxNDU8F0jyNMWwLPI0Iy/advWSQ7BPnVjTNAZRyqpjc6MZKkOtIsHohomZpQSFV3vdtwvSpEWa5xPkxzc2ejRCgWtITBN0HSV/Ii1yR1UPCrEnkFLNqDzHIogSWkHKs282iHMl3S6FYHuQE2Yaj8y6TJUcTEOn1+0yCEJs26ZereB6HoMUvvRmQxFsDR0pJK9v9GiGkh84WeX0jIO3XD6gjgxq/vXt6201i/Bd0iRls6/z9SttPnH3zGhQvLOzgzXWp7dMg6+c3yHIdaquPlrA+3HGq+s9Pn3vHEtjwqtGMa8IooRGX8nUl+09szdD1/AsnfVWQJzWqPkW/UPaorncmwhlaapUAAwDopA0n9x9p7ngVjuiF2e41oCjMxVe3+wRRTGGrlqrQZLjmDrzFbX5SdKMP7ncYnOQY2tK+qYTpqBB3TcJU0GUZZiaxqKb831n1tRGJQi4cr1Plg6IhCzM1Aw12xKCNM346D2Loyq45DqjjU7ZMXEK0VBDT4vF2RjxiaZKzgHzNiGVo+zKdIWH45znLkcEmcQQORXf5u45b6RqcPnWDr/9n7/Fj37fw0xXJ+cdjqnz6G2qke8k7lTm33Gcdyym+UGP9/1XDHd+b8XefycWzFO+Rc0z6YSFHpVhYs0eJWuuI7NkAnq4PwxD52ojZKufF94venFsavj74o02D68qJFm326O5u8vy8gKuV56AMN5shXztcpNmYVq2VHO5f0ZntmTiWha9Q2RKxiMXgjBKKPsOWZYTJRkPrtRYrrlc3h2QZJKFqsOJWZ9up0M/illc8hgUOlbdXpeNjU3K5RKrs3NcCba53gzVUpSmSE35ZyzXXaZ864BopFroVEWDro+U3DRdQ4gxL5Xxuc0+tWGAG50ERI5hGqRSybr4js0gFVxvBRyb9UdQa8MwKHsKkSUlnN/uE6VCuWzqGrppY+opvThjY6AxXTVYnJ9jECWj3nUQBrQ6bS52dTqBoOIWO2hNQ2Cw1Q243lIAhcOOF5SydS4k05USWaoWNVNK2mHGVj9jtXbw/tGQxLlkuxdj6xqWaSOkAKFkYnpRynYv4UhB6Cu5e1I9Fd9ls6ckTsYRaKASTZwJMinph/EIMShRmyVD16hYquoYStRouk6SJOToLFTGNLCKIX8rUGAHJHi2Sc2z6AbJiIdlGxr3LJZGigU7/YStXoxv6vi+RxqrmVYnVLOPHzg1rYbjWk6nsUOa5ZiGzvxMHe3GAMexKTkmeZ4p59Y0Ikmh3++xvqUxO1VDwphttlroT8z4vL7ZV3BoQ5DmEs00ODnr4tvmxDUbvxK9IOLkQpW010DzykzXaji6OHBum90B//qL3+TTT93Pybdwv32vIs/zdwRWGo9+v0+pVLojhv8HMd73JJNlGc8999xbsvdN0yx8yG8fpqHzsx8+xj/6zxdHf9NNB3d+jUq8O9qJ7g+9UBRoDEKkyDBMCzm2oGqaqmh6UUY6aNPr9Tl57ChSV+6VGkpYcLsX8x9e2yqshtXNsd6O2OlKfuzeOv0oLoiUt/8dSlspQnZTZss2TrHKz5YdZsuTN6rin0i6g5B6xefW5jbb29vMzMxSq6kd2UdOzfDsuR22ewlJLtA1wULV40ceWj6QYMY/09A1Vqo2l3YDbNNCiVblJLlqa63UJwVIh5VBxXeI4rSYn0mSNEFJ1lhF4lamWoMwLhB+ESVP7U6HvI52mFGIISuQhBCYloWMMvoplD13BMowDINyuVy0FSQvvbqJZRtkWUKWpmoXbdmIPKc5SDk5O368+aj1CdAOM0XyTPd2yoamIWROO4i5e7E8AnMMo+y7bHeC0b/nxcxMN01Emk20ES1Tn+DD9MOYhZqHa6uqYJwcGCY5M1UfS1PVSi+IaESCF6406MY5mgYukmnPpBVlmKaJlkQkmaDmWTx0dBqRKbHPV9d7NAYpNdcsoPqCINOIk5THj9bopwKZ5yxUHWZKe22kXqzAKp7rkMYxpmWR52p2oyoig4qrE0XRhJTQIEw4uVBj68I2QoJpWpimRZwJXC1jrmzT7/fY3d2hXilj2g6mZeO6StjzrvkStqFzuREoXTnX4Ni0x8PHZun0A8Yr7/0xiBIsA47MlkjlQYmoYSRpxu9/5SWeuv/koXOa9zKEEHc0k/nzIvMPH4AkYxgGc3NzrK6u3rY8fKfGZT/74TWiNOd/+pNro9bZ48em+X9+5vu4cPkaz527OvF6KSW+59BoCkXoKuQxhk6XFPrJhqbR2tnC1OHee04TJepYRiRI1+HlN7bJiwV6eNNKKUk1k9e3AuZmpke+MIc5bnbClC+8vk0nluRZiq7BifkqH7tresQYH49hBVjxXS5euUYYBBxfO4pmjGln2SY/8sAiW72YbpRRcUxOL9YVM73QAzv4mer/P3KkxmY3Ikgkmg55sWjfv1Q5tCocovbqFZ+lisl2J8A0i3OhqZaNrilpFYBBFFMrexMSMJqmUXYsGoNUDW+L1lOWKmSdbwm6g5Bq1Rqd470FQsOzLTpRTLlcUclC00niiDwX9LsddnZShVbzPHTdoD9CGSrJkt1BijsmyzOc73mWPgJzbG+rhb/sOapdaOkj8p5j6iAEUkhioeNZBnOFJ45pGLQHMRe2laCo0llzWZtyudiI6IYKXJLkAse2ODltj1qVO72Yr1xqkqHhWya5yGkGkpqWc+9yld1BRpyknJjxOTHrI/OMiu+y0w3Y6sbKJrnY0TuOgyRhEGdYBtw75VP2ncLOYe8+c0wdXTdIC425LEvRdYNcSjxzDyG2J/cvcSyTQZQw7+uszVW50egV94by+Tk+W+LUcrVok1lsN9rEUUg4GLCdJLiuujZH6h7HZmZIhcQq7MI7/eC2JoLjIYQgSnJqVf/A/b0/vnX2Mo1On08+ce+BOc17FXc6k/leJfMehqZpHD9+/G0tmN+JcZmua/zfP36S//OH17i8O2CmZI923SuPnWF2qsIXv3l21CIYIrE0TWfB1yk5BkGSF/L5OgqblLPkS0qezfGjRwqr2L2LLwor4UYokEKgjQ1odcMiSxNa4Zge1iGOm0JK/vDsFu1YYEiBbWjkEi5udXFMjR88Mz+C1Y6fN8vQOX/xkoJJVuf4T+dbbA8yLAR3L5Z5cEW1+BarLotVKHsO/VAluP4Yk398oR4SGuq+zV/80HGev6KkUSr+FGt1i7Xp23vHV3yPje0Gc9qAumfSSyQiz9GEQmYdm/FYrXvq+4r5lGWaIJVbIsDJOZ+b7ZAgyQueiJoXaEiWSya1WkXBxotzpzQ1Fa9pbdpjqxsTRDGeayOyjEwz8Ry4e6WCQUq73WZnZwfHUY6TQZQwUy1x73KNP35zZ/S9QkoGSU7FMQsrZgXm8ByLm72cF15eJ05z5is2x2d8OpEi/A397C1D48mTc2rH7zu0+iF/cqmpZGZ0hex6Y7NP3Te5b6HEdiBo9wKW6x6n5/yJltfF3YA4E9Q9C03XcGybLInpJ4J6yeG+xYMD4n4YYxoGUtMY8h8Nw1AVXpG8c6H+txfEBYgjLDB5sFhxqJdsmr2QimtiaBpBnJLmgoePzExspDRNo1ra09+zDJ1Hln1WajYb7QhQXkvLNVWtuLZJEKeUSiVKpRJSSlxTZ6vRZDAY0Gw2ME0Tz/MplUpYpiptFf/KQDe0oiqcDFWF62RCzWnGaQqHRcmzuXBji0anf+ic5r2I/3+3XoYPQJJ5J2Ga5ruyYC47Jg+uHBzi3X9ilalKid//yotoMJJc0XWlY/wjDyzy+Ve36MfZiIMyXzL48Ikqq0vzxdDxsBtWw9EFumkjURBZNF2x9AFn3z02TlaM04z1dkQ7yjE1Nf8AMIrW1fnNLh86Vmd6wi0TkJLeIMDzfLRSlS+8vlO0xCAyLL51tcV2N+aH7p1H0zQcy9x3/GrRLPsuu52QF260uLw7IE0lN/Ndnjo5iy0yHl/bU1cYmqal+4bmWS5oRpKXr15Hj3usLc3x3xyrcn6rzxs3dvBsixPzFU7MlUY76kppTwR0kEqSTOKZsFr3ePRIjVduKdImgEnOQ4sex1fnsS0TQ9cJ45gkE9xshUSpoOaaHJ1y2O17XGvHtPsRFL/7/kWf5enhQjxNlCS8drPDlVtd4qxNzbM4NW1x34LHhd1oxLmY8i2eXKuPIbskz6+H3BoU8F8EjUHCDSfiibUajUFKK1CIvKPTHgsVi1rJpRfG3GhFbPViys6eCoCUkk6gGPnff7xKxZsjE+LA3KFdVDloSpA0ywSWZZHkGtvtgJXK4QNrU5NUHZNWnONIxR6VQJgq4uGUP9YeGylfq9bnVMXn0ZWc569ndMKMXCqr6FOzPkdqJtXCa0hKsC2DfjipmGAZOitVm7Upd2SXDao9LeUktUnTNOJcsrq0SBAlZHlOFIUEQUC/22JzcxO3sKH2fQ/bdooN02SlUi15XE/SEZm6F9zeQr3kOsX9p31X5zR3kmT6/f6fG+tl+IAkmXEdrsPinbbL3kmszE3xlz/1NL//lRdHN6n6fsFs2eH/9NQRrjUGbDXauKTcfXSO+dkZwii+LRse4N6lCpvndxG6gYGC5Wa5AE0RMvfHhOPmVr9gpE9yyPWCJDqIM2xjr/IIggHtdgtN01lcXODfv7pFkgtcUy/kawTSsrjeDtnoRhyZ8pFwaJuh0Q34/Os7tAYxmpQIAee2Bqx3En7kgfmRwCHsmaaND83XOyFfudiiG6ghtm0adM2Up8uCexfLLNsxu80Wbi7pd3N832eqVqY7UKq/X7vcZKMbIwU4jsVds4q0eXzG50ajR6fd5u6VaSqVqmrb5GqeEgqDPzw73BCodsx8xeYjJ6e4e6HCrXaArmms1F2Wp8fnKZLnb/a5shuj6waO69CKUl5YjzgzFfPYNPRynZKn3ueMtVF2+ykbgYZJTsmxled9ltINM641I545MTV+arFMnX6UYOo6nVAh6cYH0ZqmYegam92YB5YZSQ8NPVmGUXb2AC3DyPIMXXMmZjn7Q9M0ziyW+Na1Nt3MRIsjcqnuq3uWygfeG8YppqmPEsiUb/Hxu2fZ6SckRSU19FHpFhV5HKnkcrtnYwjzHpKOy757qIQPFCoNlpp16rrOwuwMvSCklioyaBCEtFotDMPA81zmZqbIpaauo63EVPc76A6rH83cc4k1DX0CcADfvTnNnZAxh+2yPy/xgUgybxfvZZIBteP5yU9+iC9841XOXduYEMjMswwzbLJa0llcPIJlmWRZhmtbhxImh3H3QplGP+GVWx0y3UQKianrPLbiU3f2S8+rEELSDyKOzFbh/Da51Bk3TcylxDb0QmlXaUeF/S7ddptSuUoQBOQCtrrRSBdrGJpUgpTb/ZTTi/ahBlwAb271afUjXEvJtcRhjm2bdMOEcxs9HlubXDiHfKGK77LdGfBH5xsESYalS2zLJMnh3GaPqmty31KZSq3O/Owsm7sNwjCg12mztaXjuB5fv5XQCNQwWbc0kiTh1U2lertW0TDDFo+eXEa3nInhci4k/+m1DQapcjo0dKXPttGJObsT8/hKibpXGQmbdvsB1ZKSEmqFGdebIbapKxa/pmF7Jr0oYzO1uf9YnVUEO80WG+udUdvG9z06iUGSJFQcBR3PswzLcrCSnI1uNJJBGYZpKP21HEAT6IfMHIVUcwfftUetHdOcTOTHZzw2u/HI/EsAYa5TsnJOzVewzKFe2cFYrrn84JlFXrnZpJ96OLrk2IzH0anDLYSlUGrdZd+lH8TomjbRuhuPQZTg2RbdtxjGg6qeukHEdKVEqz/grYb3cbH5qnjuqDVtWTaWZVOt1pBSCXsGQciNW5sYmkQ3LKqVEoZlHxCyhUmX2H6gaAX7QRzDeCs+zZ3EnZAxv9cuex/CNM13NJN5N2GZBj/84YeYq1f4wtdfRAg5YY88O6ugSCXPHfl8HEaY3AuNZ07O8OTJOc6ttzF1jTOrdXrtDu327QeQ1bKPNgg5Olvl+q5SfNY1ZeUrJdy/XMUydIQQbG1tYmqwvHqEJEkZDAaFha6Csu4PKXJ8x76tbhTARjcaaXCJPEe3TGSR0Nc7EY8d8h4poReE3Gir1pJrqPaNhoZjQpAIzm32uW9JMdSjLGdlaZEoUuoK7W6PqztddvsJpi6LCbuOYyoPktc3+5SThLWjq5iWfaDKXe9EygXRMrAsEyGUkZV0TS5tdnloqYRjGqMkI6WgFyR4js3lRkgm1AxAM3RE8VsdU6cbZWQY2LbNyeNrBFHMYBAShgHtVovNttr9CiFGO+YsTdBNCx0xkQj3IwmXqw5vbvVJpI2FIm0muZKDOTZbIhlDnmXZkDipPmO17vLQSoU3Nvv04xzDsvC0nMdWaxiaREplGR0cAu+1LQNdFzx9fBq4fctTXVeJ61gMwpgkzQpfo9vfu2XPYXOnRy7lbZ1Eh2GZutKIc+zbfv8whBBkIqPsOftmhkpn0PN8PM8vzlWKQU6706ez0wCg2Wzi+/4I4KE+UxZaaiWlpfYWiW7Ip/mxjzxCvXL7GeQ7ie+1y25nav+nHG9Xmr7Xlcz4937o/pP8V089AFKwubnB7Owsc3Nzo2Fmf6y0j5KMPJf47uGcm7LvYJJz/3KVexYryEw9qPI2aJiSt6df9fHTU9y1WEPTdXIpsfRCbWCtTpom3Lx5A8cymZlfQGpKB8qxFInv1Jzi64zaYVLxN0zLYrFsMIgiqr57aEvSNvTR42YYFiLNMCxrpHhwuwjDiI1tJZFuW85IykOx9zXCNGf8Qe4HISXfATRKJR/DLaMbBq5to+sqiSZJgsxzgihhenaesl869JiTTIxaZKIQr9R0E02o2cFQeFPZ3iqIumkaJFmOb1vouoFuWuRZViQiqbzpNUa2yIMwwTYt6rUKc7NzrK2tcc+ReSwdokwSRRFRHBEnCVEUc2KujF3Mbvb6/XsxX7G5d7FMlib0M+Ujn2SCtRmPuxerB8ihKpGr6wYad82X+fS9c/zgfQt85FiFR+dgvqJ22lmu5jgV35k4XxrygMJ4GCu+jOccvIdrJW8sUSgnUc+1x+SY9sIyDYI4GbXJBmFEpXT4PQZSzVWLeZPUDv/+YVR8jzDORurf+lusD7VyCc10mJmb457TJwHQdYN2u83169fZ2Fin3W4RxzG2ZdLph5Q854A/1P4IogTzfWL8f6+SeR9imGT291vfi8iyDBl2+PA9y2ynDnGmHpKSZx+KTBkSJve7V7q2eYBBP0LEFO584wq/tmUQxXt9Ydcy+Phd03z4ZJ04A9dQUuhBMGBzc4uZ6Smmp6f39KSkJIpTKr7LY0drbPdidvsx5AohZhgGHz5eH5HrugV8erBPBub4bIlLuwNSqWFlhbR+nGAYBnctHq6d1O126XWaTJd9aAcIDAzdQAo1H8mEZLFiT+zsqyXlcGnoyl+k7Jgj2wTFVtdJkxQhwDag32lwrrnDVK2CZtj4vo9RLHZTvo1pKHVrx9QKvSpBKnXKNredU2iaxkLVoeJb9MIM31SpMROCJJfcNeOhIxGF/H5UDJHVPCFipuJzesbiYisnkRoyVwmqYkm8aJfNzZB6tcJACtD2L1Aa9y9XWKq5bHZjdF1nvupydNp/iwpgTyE6TTNMQ6fkQOYaXG9rE/faYSixciHXsj+Gc5Lxe9ixTXrhwdcq4VAd17aIkr1KyTT0gms1rIMVcrLsK9O28cQ27vwKRaWWHXyGgMKTae+5G85pJBTV3l4YukZcVIBCSPpJjO+YzMxMAxpZlhGGqhLtdrq0LAPDsvE8n1q1csD5dTw++cS9lL3DW4rvJu50JrO0tPQdf/cHJf7MJBlQu4L3Umqh3+/z4osvYpomU2WPH/3+j/IHX32RrWZ3IgHsD/VA79kkG7pOXlgW7w9d1wiTDMMwMIzhwF8NX5NDKhzH0HFNKHkON9c3aTabzM/PMzs9PfGQa4XSci+ImJ8q82MP6VxpBGz3YlzL5J7FCv4+mfJ+IQMz3q5Ym/a4b6nKG1t9wlwoAp2UnJrzOD2vdud7aCfJ7m6DcNBnfnGRRcvmYnOTxkAtRIZhEqcJpq5x/0p19L17C0eRpOOE00s1nr/eojFIsQ0NkecINDRD5/GT8yzPOcRxxGAQQNJne3sL1/XwfZ+S77M27XFpJyDLBbZtEydKOfiJu5d4q02q55h8+FidP35zhyg3yFJlvbxcc3h4tTpSPVCzN0nJdWj3AsVvCiKO1Uzmyg7tzCTNJdMli6NTHjJPGQQB7U6HNInJMfB9dbyK8a0W4pmSPZKa91379hPzsRgt9I49ljQOf98QJWYY+qF8rGHs3cOOmk/I2x9Kmgkyba99N54cDgzaw6SQUlJtZc+xJroBh32/0r9TVafqWEwec5wqyaWSu6eOrlp79r7ZiiRMMkqeU4AYTCqVivrHd9hpdlTC6XbY2dnBdR2mahXQLRzHGf2OM8eWOH1k0h3yTmLYVr2TSubPU7vsA5Fk3q46GSaW9zLJbG1t8eqrr3LkyBFWV1f56le/iudY/O8/9gR//NJ5nt9H3DwsFETSBo3bDhKHyLkkVXIgJddG07S3JIoJIbh05RrkGctLy8xO129DnFSrQm8QUfYc7lk0OTmbU/Hd237+flkVTYNP3LvIidku15sBzWaT+47NsTLlk+eCSEgqvuqNb21tkqYZx46tIaRajD95Zo5vXmlxqx2SpinTFZ/7FzzWphU/yTSMQ9UFwijmRx8+wudfus5OLwZNx7YM7l2pc3pWVUGu6+K6aje5vGyw22rT7w9otVqsmDralMVmZBAnKVO+xX1LFVYqJmXfIYiSg60bCZZhMFe2+JEHF7nZCpG6ScmEheoe+XE4y7FNg0GoxDc7/YCypwbgdVdnrVadvG8Nh9mpGt1BRJ5n6FKw02qzuakMoBQJVM0JjMIPJsmU5MpBvtLBUIk6GkF3pZzAeUxEluWKre/Yt5Fh2YteEFMvefSjtyYuDtt39YpPuxuMvvyw44gTNbz3HZtM5G81ElQtuQI67drWbe/bXAgGhS1FdxBRK3sFgXT8GFXCG4SFwV1BERieu+H9NDW1J6ff7QdoosdWnOB5HvMzUzxz3/G3PBfvNIYt/jsZ/H8vyfwph7JI1t6TuYyUkgsXLnDt2jUeeOABFhcXieN41Js3DJ2PPXaG6WqJZ597/S3ZxaBuoDhNb1t6jyeDXAxNmLTbtv6UwOUGmqaxtLTIbL1KZxC+5efCXvKYqvi0+wdfPx5DWZWKr3Zv3UHEQtVloepwMWuyWN3b1UkpaXZ6dJoNRC645/TJYsCsZkAlW+fjd88QZUpnquwYVDx3tMhbhkGYHEzAUkK33eDR6QxtdRZpWMxWlL1zdsh1jrOc2ZlpputTxGlKFIXMZyk7rQ5JmlPxDUp2TpZlDEJwLBMhIR0DjIxzcxxT5+Sc6ns7lhIxTYrXDmc5uqFjmAZ6Me9q9/rkaUrJ80cttSERtOwp2C9oGIZ6rNZWV0nSlKCA3w530I5jM12voRkWjmNPOI8eVg37jjX67CHJUI4JZO47s1iWWSgdMyGdc1iUPYf2IMAyzQMtsf1h6Crp+p5DnGQFqfnw+1gIiW5ouKZFnGRvmUDDOKXquyT524F71JyoVnYZHPKbxp+peEQRsEjTg9XRfkkiQ4N2p8s9S1Wef+7b+L7PzMwM09PT1Ov1d50ogJE9yfcqmT8DoRX6Yt9pkkmShFdeeYUgCHj66adHF3K8HTe8mR46fZTpaonf/8pLE9In46GcDfcInYchbMZdN0ueU/S9NSol9aCMLylRFLKxsUmpVGJubo6y59DqDbAtC4zJnvRh3CLbNAuC5VsvLKAWeeWdAeN9dfXfxpJXGLK5uUG5XOHeu08UpDu16A4fak1TUOJC7JZBFOPYFo5lFovj/u+W7O7uMhgELC4uUimXRnI8tzvXAHGSqraJ52Bb6tYtVWqkaUoQDBgM+jQau1iWhe/7lMtl6pUyYZJSctUO+LC1Ti1IOr7rEERqwzF+LTVNI0kiNje3qNWqVKoVNfiOYoSQWKbOIAoRYlyBQFlCW6ZOrVLGcVympqaKKidnp9kmDMMCLeUx8H3qtQqmpk+gFw1dJ51oISmSoWubB8QfQcHzhzt8WaiG75+JDGM4vAdNbTy0/FCS4/CaDZFnaZZjm8ZIb+6wZFcu4MIUYqC3S6DD4+gX5/2d3LtJlmNaBsY+pOf+jZsQEg0dxzaI07dKdEph4+Mfeojve+gu0jSl2WzSbDZ5/fXXyfOcqSk1E52ZmcHzvNt8zmQM15N3O0f+XpL5LsQ7uQjvVFrmdtHtdnnxxRepVCo8/fTTWNYeBn6YWPI8n/j7kYUZ/vKnn+bf/fEL7LR6E5/nudboIYI9iGS15NPpBxPaWlKCYxsTPvT9IJ6Qye92u+zu7jAzM0OtVsM2zUJKRpskbhZtOSVmCcMEYVsGUaI8SvpBRNX3RooGh4VjmaMB7TgrWh22HJ0zdUyzLC7M0h2EWJYBGgiRjRLMYWEZSu9raOo1jDwXbG1tkec5KysrWJZJmmW4nvuWbZXR+4UgjFJqFY92b6BsDmwL265Tr9fJc1EQ9wI2NjZZX5fMTdfo90w837/trlIIQRDFlAsU3vhmodfrs7Ozw+zsLNVqRQ2hs5xapUS3H2IXlcMw+Q6vj6ZpJKlE18Vo8S77PmEcMz+/gJSSOFacj3a7xc7ONr7nUatW0AwLyzIPmTuoiJIMw9BxLXMksTJe8eyFSkqH2UvvDe9VSMmYHMtkUhryjIaRZP8/9v48TI67vBbHT63dVb13zz7aF0vWrpFkW8IBGxvbMjYSuwmXLTwBksC9SSBfICuBJEDIDVyHG0gCCYSE3yXgFYMx3o2xMbY0o323RtvM9Dq9V9f++6P6U13dXd09M5qRRo4Oj58HzdRUf7q6q97P+77nPceysxB4rum+dAYvoH3zHjDr1lH77roPbDr7QQxTs8YAqkHF8YW09Pmse9SNkOBEdySAG9ZZ7DSO49Db24veXuszKhaLyGQySCQSOHHiBARBsANOOBxu+Z2ayYwMcJVddtkwXWkZJ4iN89KlS7F8+fKmoEZ2G27um2G/iHvedAMefWE/Tp636uscy0BVdZdGqTUw6dy5URRVpdqaTV9wSVbBMjTy2QzSk1n09/dDEETQFAWapqFotdIFcdwksu+1cpbFsqEpGoqh1tZRdf6UXAZILQ+RmgKAU+aGZEjpdAr5fB79/f0I+P1QVd1mtFGURdNt9PYg8HAcStVymSQrtoumpmmYmJgAy3IYHBywb0CftzYFbmlgtS/3BXwe5IplBMQqxdzZGmFo+P0++P0+qwSmyNAUGXKljEQiCd7jscgDPhE872kKkpqmg60OaZqGiWw2i2x2En19vRDF+pmJkiSjKxzAZKEEtjqXY1RN2Jz/3zCAfKmMoChC1mrzMBRFwesV4PUKAKK2zXE2XwAMq9mdZnhb1JOqY6yZUDUDNKPDJ1jq16pL05yg0V7ajdllwQpKope33TG9HOua3RimiVJVbLWWDZtNwQtwb94D9ZkXeX0yT6NqWh21u5F5pusGynqtT+PMZDiGrpb+apR0Z5/GCZahccf168G6BAuKomzywOLFi6FpGiYnJ5FOp3H06FGoqopwOGyX1kRRtNcwE/qyaZoolUqz4oo5X3DFBJmZlMsMw8CxY8dw4cIFbNq0Cd3d3TM6v4djsev1m/HCgZP41cGTYKqWzK1QlGR4PRx0XYdhWKWFiqI2feF0Xa9aS+tYvXKF5f5nWsrQ7g1QylZyzpfK9nt0ihM6UXJx3LQsg5vPT7IlD8cgmUxC03QsWGA5fvIsg1K1nGGdg0LZETycQZtYWTtLboVyBSwFnLlwAX5/ALFYzH648ywLSVHsfxfKUjWzUlx3nT6vxy57FaUavVdz2SBQFBALh1CUKvAFgujpo5EvFJDPF5HL5UBRFERRrP4ngGUZ6IaJSrkCD8dhYmICuUIRAwOD8LjMdYheDzL5EkQPD0XXqw+VevIAMWYzTQOqrlnMN9Os6ntTddeOZTkEAhwCgSA8HANVkZHK5JDJZCzVCa9gEwjI+7NUIyREgj5M5sttqwJWSQwI+YWOsvllR1Ay0Z4EV66o6IpZ2bDVm3LPQkjznhAdRC/vSrEGaqVG0ieiaaraq2tcM2Uz3iSpbG+S+KoitBOyS0UAAHZsWIGu8NTKUyzLoru7G93d3TBNa4A7nU4jnU7j1KlT4HneDjgzYZYBFoW5cUNzJWNeBJmplsumE2RkWcbIyAhUVcX27ds7pp+dzk9RFF63YSW6Qn787FcHOr5+pZqlRAJ+vKrqTf0TRZExPj4Oj8eD/v5+yJqOgChUnf7a16SL5QoEngNDU9UyhvuNChDHTcreQbqxcghkWYGkaIgEvQj39YFhWJtZRkpozs+qUK33Fyuy9eA0TQi8pyoHUkOhUEQqlcRAXy98Pr8dEKwhSgpGgyRKqSLDw3EwGbOuvGIFJLUu+5BkBSzDuDatiWcNOV7TDQQDQcQiYZQrSlWepIzJyQziccVuxguCF+Pj4zANAyuWLYHmEuw4hkWluhZJqa7Bw9mbj1opkamuxVd9sJtgmZoPUe3YWsChSaZJsRgY6LV27JIMSSqjXJaQyWRgmkA2m4XP50NXNIxsQepYEgIs6nxJqjgymfZBySt6YJqADPdSNZFxKVXN9hqzhGZUrclFD1TNaFsiJdRpn8CDQntGZlGSwTEMOJZpuekCmisCi/piGLpmcYc1t3gnFGUrSS9atAi6riObzSKdTuPkyZOoVM0Ez5w5g1gsNmX5/quZzGXCdKRlstkshoeHEYlEsGXLlinRnqcaxFYt7kc4IOKh5/a2fFgTeD0cciUJooetCzLFojX3EQ5HEI1G4OzroCoTo3dgtcmqZTGsqO0pqoDFaitVZEQCIjL5UkPZxQIhHVCgIPqDCAV8MA0TuaJU1+BvRFGqwMtz0AwDAs/V3dymCUxOTiKXy6G3txceQQQoCl6egyQrlj6WywCg9f7UajO+WnOn3AMSYIlm6oZR17S2drJyczlMJ8w6y3JAEATEYjF4WAaJqtR8Op2ulkn8KJTK6IqE6wOnWe1nONiE5LxujXPBw6EoVexhUlJG9fu81nBsQ+Yner0oSYolySNbQ5ghvwiO4xAMhmAYOs6cOQvTNJHPTiKRSNhZTigYsDTkXKSPTNOEl7c2G4Wy3NGfxRpIrpUxm/s91jlp2iK+EMZZJ4kZwCLEgDKs0rMLxb12fut6U0znh3NFUcHStG3l0ebVUShXEAv5cNt1a2dtwJthGMRiMcRiMQDA2bNncf78eeRyOZw+fRosy9q/j0Qidf1fAlVVIcvya6rxPy9kZaaCqQaBc+fO4eWXX8aSJUuwcePGKc/V0DQ95UypNxrCe2/fgYHucMtjvB6uqgBgOR36BGvwLpNJI5GIo7e3F9GoNZkMoFpSU1CSZLAsA55rn2ZzLAvVISfSCTzHIl+SEfSJTXvXQiGPsbExRKORanpPQdWsBwbLUC0DDEFFUeHlmDrqsWGYSCTiKBQKGBwcsNN/TdchqxqiAV/LAFM7h4FyxQpGooeD3IZea5mmybYMCYX2yt5kmBam9VnJmg5BEKCqGvx+H3p6LMn3RCKBA4ePIj+ZRi6fh6ZpCPi8rrRs67wygr7apDhD003ileShVpE1RIMBMAxt9wUDoheFUgWGYcAwdKvMpul1sjFkkxCLxbBw0SL09w/A6/WgWCzh1dOjGD1zFlKxgEpFqrsGIb9QV0IqVRSwVfJAI6yeBukfUbbqcrMci1UWFKuzLoQA01piBlXDNwmyosEwW8s0AVb/U1JUFEpWn8iNUVdbiglQNMrVeZp2nz8AXL92OYK+qTHFZgKGYSCKIjZs2IDXv/71WLNmDTiOw+nTp/H8889jz549OH36NPL5vL3WYrEIAHOSyWQyGbz3ve9FMBhEOBzGhz/8Yfv1WuGmm26qy7QpisLHPvaxab3uFZPJdAoyhmHg8OHDiMfjGBoasncT0zm/W+O/FXyCB++65To88fJhHDx1vuFcFomAUDZpmkauUEalXESpVMaCBQvA87XAQFfnMpSqpI3cUOJqBEVZO2nSvG/nuEmOp2kr6ylUp/4tVpuOdDqNXC6Pvr5+iKKIbDYHCiYM3UBF0cCxDERvK291CyzDoKIQS2MvsvkS4vEJAMCCBYNNdWkPx2GyWG7TfG4GTdFOSp0rKAqWRH1AbMlOch5bKFcgCjx03YQkVTAxMYFQKIhIJGrNmNjkAcVSvK5ISOSyGB+n4fOJ1Wl+b10AttZQgej1oCIr8PJcU/mw7tiyhIAooCwrFqNQtXp3Vi/HQR4AkCtKVbKDZNOsJVkDz/PgeR6hUBiGoUOSKiiWy6AMFROSDFEUEQ4FMalr9gwPgVOhuJZ91GZtnHAzDTNNEwFfY/bWWmKmkXlWa94LTf09UlokmU65gbzQCNHDIV2xSoBkE1FqYdGxalEfVi+eW+kWZ+OfpmlEo1FEo1GsWLEClUoFmUwG6XQaZ8+eBU3TeOyxxxCNRu0S3Gzjve99L8bHx/H4449DVVV86EMfwkc+8hF8//vfb/t3v/3bv43Pf/7z9r+n2y+aF0HmYinMlUoFw8PDME0TO3bsmDKPvfH80yUWsAyD269fh+5wAM/sPWJTij0c33SDJhJxcByHJUsWg2Vrg5utGv2kxNU4DW5ZLgt2PZ3MKbg5bpLjiWw7gSSrYGgKmVQSxZJUDXo8UPXBoSkTleoAnSUDY1TP4fLgrk7Rk519ejKP/GQKLMuhu7u7aefLOMoZNVMp9yY/UGWqSXK11GOV5bQ25ZWAT0C2SitunC1qWrppggKFfD6HdCKBWCyKYDBYdwxFAR4PD4+HB8ewMGFYfZxsHhMTViAl5AFBqOmrlaufXSttLCdKFRkCX7OUtq4ZY6+RzCQBJvKlMjwcA9HDolCqgGGYBuIF43hImeijgcxkDrlsDsWyBI+Ht60LiNxNLfsQkC9KbXsajUGJZWhIsgbOJZlulJhpDBqOq+waFJqZZzXyQmNZUvRyGMtm665FUZLh5TnohlH3mgHRgzduubbdRzIraMcu83q9GBgYwMDAAAzDGmF49NFH8b3vfQ+lUgk7duzAzp07cccdd+C66667aKWTI0eO4Gc/+xlefvllbN26FQDwD//wD7jzzjvxd3/3dxgYGGj5t6Iooq+vb8avPW/KZTNVYs5kMnjhhRfg9/tx/fXXzyjAtDt/J1AUhS2rl+DtN2+Dh2etXakjwJTLZei6Xm3wD0A3rBvFJ1glgmCj42X92ZEvWWZl5OoE/bUHANHZIrDKH4w9qAhYJZLG4TZNUzF65gwqiorVK5fbAcYwTPREIzg/NoFz584ilUqiVCpb2VKpgoDgbZLMCoi10lG5XMbY2BgYXsCSRQvAsc03mIdn66bwSxW5ac0ENG1ZGZNSQkVRAdPqcbjBy9d0shTVor/6vK1LiUGfgAsTcYxNTCDW04P+3jauiNU+jKYb8HpFLF+yCIsXL0ZflSAxOZnFmTOjuHBhDJOTWVAwkC9KUDS97RoIGJZBRdUgNhxrDSLTYFnGEhKlKSSTSVA0azEHDaPKYjRcykMUNIPCgoE++bhrCAAAlSZJREFUDAwOYtGiRQgGQ9A0FRMTcZw9exbJZALFYhGGYaBQqiDsF1DuIDFDgpJf8HRwkrGycvI5BH1C22Fba56Gs2WPWjHPavM8XqCqNK1q7gK6FUW1NnLe2nfmtuvWwdviOzSbmKo4Jk3TCIfD+Ju/+Rt861vfQjQaxSc+8QmcPHkSb3nLW/D4449f9FpefPFFhMNhO8AAwK233gqapvHSSy+1/dv//M//RFdXF9atW4fPfvazKJfL03rteZHJTAUsy0KWa19+0zRx5swZnDhxAqtWrcLChQsvqoE3nZ6MG5b0d+G9t2/Hg8/uJStENpur+pUzVWdH5+CmjHDAh8l80bUR7wQpcdE0haLjxnOb+ncObhqm2XSjkga/3+9DV1c3JEWtlirK1Ye3H0t8fkhSpUrPTEGr9ivyooiuaBiGCbvRnq+yt3K5PNLpNLq7uxEI+KsUVBYsw1RdCOEYEIXLmusH6wjVurGBXGuw15MGaIpuIksYtt6V9f6c3w8vx+HVM+dRKpUwMDAAj8eaUCeukI3fpaCvtnbDNCwZfp+AAkXB6/UiFotC0zSUy2VIZQlnzpyDCcqmR/d0RVEsV1y/o37B6sNQFKr9hOb1kmsSjyfAMhS6e3uhm3BkHc2DoABVfT8W6SDgE2w5FcCELMsol8vI5XJIpZLwejwo+v3w+3zgPXwL3ySCqm05VS1ltoFhmDBMHbTJdFRSryiqpSbAUB2GcylbDJSmLb2yllJNOvHn8WL5YDcW9U2vlD5TzNSwLBAI4H3vex/e//732+rzF4uJiQm7z0jAsiyi0aidkbvhN3/zN7F48WIMDAxg//79+PSnP41jx47h/vvvn/JrXzFBxplp6LqOgwcPIpPJYOvWrYhEIrNy/un0ZNwQDfrxm7dvxyO/GMav9x9GuVzGwMAgUqmkqwRMoSRZ8vtSe2tnwBoSZFiLJis5aLJuX0DDsKi/godH2VTsG69QKCCZTNiqAmR4jog/KlpNesNSEBZgmjFbtqVYtGRbRMGLUMAPRfaC4zmkUmkUi0UMDPTbgpaApRtGUTR8Xi9MGK4BprZmq8lvlWzKCPrFao/JHYVqQCiUKjBhQhC4loymQtmy/S1LStUWADh3/jwqimKrDljXE1URSm9dCU/0epArSU29l8ZyH1H97e/pRqFcsX3q0+k04vEEoqEAGM4DryDYr0nmOZznLlT7NIQaTj7/iYlx+EUBwXDEfniVZRWRoA/5ktQ0CMqzNPIlqTqnY/XZnLNNHo+3KndjZbe0aSA1mUU6kwFDMwiHAlVKt9D0sBS9vOXUKmuIeEXwHNMyKNGUxZaUZLmjxAxgzaUVyzICPi/yHYRDGZqGomp2Wa7VsSYse40bN65sea7ZBqlgTAdk2p+8j06Z0Gc+8xl8+ctfbnvMkSNHprUGJz7ykY/Y/3/9+vXo7+/HLbfcglOnTmH58uVTOse8CTKtHpgEpCdTLpdtef4dO3ZM+0Nsd/5ZMUYzdPQLGpb1hJDVYmBZtum9ORv9RF6mnVsgBYCtSu5TFGXXo9tdM5ZhrHkEn4CiVEE6lUYul0NfXx9E0Woq2tRZ04BuGKApGjxL2UKRgPUwbZRtqVQkyHIFUi5XXZPV1LTKbvUwTQOKqsHr4TruYgGgUJIQrsq1tAN5yAsCD4aiOzLVSpKlp6YoCpKJBFRdx8DAoN1DqTuWzOnQ1tBkpWE2p/FYopYgqxpCPhH5smSpEFd7NaYJqKpFHqhUypicTIOiGYiCD5FwABTDNl0XJzVckioYHx9HJBiALxiu63PZwU7wVif0q2Uz0wTLMlBlw/6cLfJA2e59OEki4aAfxXKz3E29zYI1COr1eqo9Duv7p+q6XRJzIzlYVGi5+r6IxIy7w6xT369QqlQ1/irVrUE9uOo9YX13KXg5BoqLQyxgjQXccf16cLNoFdIJl8Kw7JOf/CQ++MEPtj1m2bJl6OvrQyKRqPu5pmnIZDLT6rdcf/31AICTJ09eeUGmE1iWRaVSwYsvvoj+/n6sXr16RrpArTAbQYbM58RiMfz2Pdfj6JkJPP7rg9VgYAUQt0a/JKvgmHpfdyf8Df4dRamCkE+0/90IJ2srXywjN5mGVK5v8Nem0U0EfCJK1Ye0UyjSDTRNoScWRbZQQr5YRjjghw4KuVwO6XQKgiBUH64+e7fOMJSVTRB15jaFEIZhqgGB7djkty4AIGsaPHx7ijMAFIpl5CdT4Hgese6etgFPVmtinG4in06Qcl+gRTnQCtR8LQibJnRNRUWScPb8mPWdEAU7KJEHU0VRoWkqUok4goEAQtFYy2y7XJHrypPE/8Ypd1MjD0jweljomgHNMOHhuLo+Yr3cDdDfRyM1mUW5XEYmMwm/4AFdNf8ixBPDMC0H1gaiikVXrh/6JBIzzvIo0CwFAxCNPx6arjdQwc2qSGlVt8w0UaooiAStUmAjy3L7+hXoidaTOuYaMzEsm671MlEf6ITt27cjm81iz5492LLFMlV/6qmnYBiGHTimgpGREQCYlqnaFRFkTNNEMplEqVTC+vXrMTg4OOuvwTBMXc9nurhw4QIOHz6MlStXYvHixaAoCmuXDSIS9OEf/38JOxgE/e5uhapuQDNqxlAETqXnGihryNPLgWpqxHtsfSdNUzE+Pg6aZrBo0SJ4qkOQpKxinV+wAwxQLxRZaNGbSGZymJiw1KIjXTH4RQFlSYZcpfqWSlaJiON4dEfDqFRYeDxeW53ZaGD7OMFzDKSKAk3XwTJMy8ALkBkUq0dDUVTLnTRg2UVPppPwCD6EwlH4fS3Ycg6QkhAp4bXPwqyMJygKyLn0U+pQHfQMh4IQ/EGbIp3L5ZFIJOGp6qsxDINMJo1IJILFC/qRLXSSjbHKnSG/WD2WvBzVJHejqDoYmoaXt4KQqjoFT+vlbmTNQFcsCiMSAc8y1YAjIZ1OQ9M05HI5GIYOQRDrbAsYhq5+ds1r1qvfM0JdBuBKmwZqGn+ih6vaTKCFiKaJsqxiIByuY1kOdoexZdXMpvovBjPpycyVpMy1116LO+64A7/927+Nb37zm1BVFR//+Mdxzz332MyyCxcu4JZbbsG///u/47rrrsOpU6fw/e9/H3feeSdisRj279+PP/iDP8DrX/96bNiwYcqvPe+DjKZpOHDgACYnJ+HxeOYkwAAzb/wTfbSxsTFs3rwZXV1ddb8f6Arjzm2r8OuTE/B4Pe3dCk3UzbwIHr5O6bkRsqojwNDgq/71Xp5FsWoBXalYJRZiG2CY1s6Y6EVRFAXBw7fsYxCJeGcZSvR6MJ5II5lMIBKJIhQKgaIsf3cPz1ksMZ5DOByCrhugTB3J9CQkyWKjkAwn4Pc3qTMDxKa3lgnYTf4W9GkPz9kZl1mV43Fr3BeLJaRTloqyr7pLtCXwS5Lr5RUdGmmFUnOPpP5zMyF4vChJFaiaZgfdVhkbxzKoKJqtO1dkaHi9HkSjEWiajnK5jHw+D1m2bJo5GrgwkUJPLFJVP3A9LQDre9yOwNAod+PheZimUZWDqTmCOskDFGVN8wseDqCoqvmaiFgsivPnL8Dj4atZTgYsy0IQLNsCweN3nfNyrMamLltlv9abvFrz3gNF1Vytom3TMsc8jwHg9uvXzWrVY6qYablsrqb9//M//xMf//jHccstt4Cmabz97W/Hvffea/9eVVUcO3bMZo/xPI8nnngCX/va11AqlbBw4UK8/e1vx5/+6Z9O63XnTZBx26ERe2Sv14sNGzZg//79c/b6M2n8K4qCffv2QZZlbN++veUOxC96sfO61TiVknD49FiHs1I2XVjR3JSeHUdSlse5aJh24940TbvBH43GEA7XGvy6bqJQkhD0C5AkpaP8RlGqQOAt8UcKwEQigXQ6g56eXvh89e+VeL2Q4CF6rfX09vZY2ldVK+XJyYxd4++OhWFSDHierz7U65vrBIVSBUFSAqz+vjEgWdej2rgnzWXDRC6XRSYziSWLFoBm62mrhbLkKrDJVQVNnWtx9kgaS3gBn1AXBEnQdc3YTIClGaia4npeUt5SVQW9vb3wi16kMlmUywUkEnHLm8YrgPd4wfP178c0TXg4FuWK7EpgaITorZVtw0EfCkWpKoZZPwgKWGVSYp1NVI9JwBJFH0TRMnKzyA4SJtNpXBgbRzjgB8VyEASx5ayHWs1EO0rMwOrpBERvdf6pmX1HniOKalkRvOm6NQj5L4/Y5HwLMtFotO3g5ZIlS+rK7wsXLsSzzz570a87b4JMI5z2yNdccw1KpdLsNOZbYLo9mUKhgOHhYfj9ftxwww1th6WYqiDizu0bEAv58fy+4x3ZZLppVhkxbMuBQtL41w0dhsnCw3EYn4hXJ/ibG/xEkqRYlhHyiy3nEJyQFAUsTSM3mcFkNtdSkRiA/RDyC1474FnrrFkpx2JRqKqGcrmEVCYLU1cBmqk2lAV4vR6X3TdQkCpVR0YVHo5tawdQkmTwLItEJoFsroBrViyFi+SZ9f6qVGuPTbWmqgODbh4uarWEV8vCPLw7q60x6BIEXKwM7PPyHC5MxG2LBV9VNr6rKwaAsPzKtqinRZH2VQdBvU1DlK2ERgGArbKyyKUulq3rawXcGqGE9HL8gscejKyRBxRbIBOo9vNEH6LhMCqKAkVRIZXLMFUF51Ip8LxzENRbJ1dUkdUmfxg3EJVnYtnstAJoJJYsG+zGtUtaDxnONeZbkLlcmHdBxs0eGagFgakwlGaC6QSZeDyO/fv3Y8mSJVixYkXH9dA0XbXrpXD92uXoCgfw01/ua6lYG6hScwGLFdMoTU5AgkxQFJAtlpFIxEGbBhYuGATHWx4fpMFPjqcoKwvIFcvVAUi67VS8ruuYTCVRlhWsWrHclhNpBRLMeI6FomiupR2OYxEKhRAKhWAYBmjDQDqbRTwerzbBRUcTvFbmKFesJnA74gBgPRjPnj8PXdNw7TXLICntP1fSy/ALXtA02gqfOud0iP1BK4Zf/c5fsi2a3b4uqqZhfCIF6CoGBgbAcVyTJA3HcRb1PBSy7gNDRzJjmZ2xNIU4x9vXjWx6iNCos19lmqYVHBv6V26K1gxj9boKZWvWhrzffMly56QpODYwFGiKgmEaAKg6skNffx9SkzmUS2UkElaPUhAEdEfDKGuW3I2uG5B0dwsJwOqRkX6jJKtg2XqyDBHrBACfl8et29bMybNiqphJ479UKlU1DV87mDdBxrK4dbdHBuotki9WYsENU+nJmKaJU6dO4fTp03UBcLrnXj7Yg9+8fTseeHYPsoX66dmAWN+30auDm1ZDufHGoyB4WGTyBYyPT4CmKXT39SPgE6CoGlRHNmHV1qsGYdUHndsQpBOKoiKbTsGgKPT3D0BStI6mYkGfaP9e8PJQVK1tWS7oE1GUKujr60M/BeQLJZTLJWSzWSSTCXi9XruXw1dVayuK1rLJr+u6pSZNUVi4YAFU3WxJYnCCPChbsMibkC9JiAb9yBZKbXskQHWmR7Sm3d2WQMREVVVFf38/wgE/YALFSutgR1EUTJrFssULUarI0FQNuXwBhUIBqWrWQAIOIV2QIU/nZ9SImqK1t6oczdh+LuSNkms1kbDmv4I+AXI1VRQd9Gjn9ZZkDbFwGOFgEKqmQZYVmLqK8UQKsqzUyd2YMC3qsmN+jKHpKrW+dk5Ns/o0xLLZuQF903VrIbTIuC8VZjqMeTWTmSPk83m8/PLLrvbIAOzAMldBplNPhhAQ8vk8brjhhmmppNI0DaVBtTcW8uO9t2/HI8+P4MxEGgCRhK+JB9ZguQVaMwOyvY/3cCwKRQnFUhKiaDX4KYpCuSKDoS1CgNPbnOfqDcIAxxBkw5S5JElIp5IQfX5bMBJobypWcy60YE/9s4wrvdjp90KyiVgkWG2CWxP0pVLZps4GfQLAcPD5ROi6gZBfrFuzoqiYmLA8erq7e+CplqrcSAyNIGq/hmF01FMDLLmebLE0pUAKAJphgGNZmFVzMwJdN6oT16Y9t6PpBmjaKmm5mbERUJQV7MJ+EUXIiETCiETC0HUd5XLNgtrqm4goiiJ6u6J1bEI3WIrWVh9MM3RXdl8qlUalIqG/vx86KAT9Igxdd5Trav5D5D+rLEhX1ZRpULQAr+iHruuQJAmSVMbERB4UBQiCgHAoCI/HC90wq/dG86bCNGuWzeerQWbjioVYOtCZ1juXME1zxuWy15KXDDCPgowkSRgcHHS1RwZqFslz1ZdpVy4jA6Acx2H79u2uQ4edzu0WwAQPj7fdtBXPDh/FvhPnoOlu+lM1kMFNtapVpWoqCsUSYrGuuga/YZjQdWsWwS9aFGWKokABLQOpc8o8n8shk06jr68XXqG5aUoGEJ0ClIyr8GEtePgEb93DzbJorvd7MU1rOJVkSyzLIhQKIhQKQvDwNlMtHk/YsyVd0TAohoeiyJiYmEAgEEQ0Gm0ycyMkBrVa7qpHfR/G7f054eFqDzw3+ZxGOEkKVjmKR0VRoGkaxscnwLIsent7bV8W3bAUsFuZsTkR9InIlaS6NTAMg0DAj0DAD9M0UalY8jHZbBaZdAqCV4BXEODxesFxvGt2ZRHLKFAUXSdqSqRtVFXBwMCAveFTdR0Cz4FVtboZLGc5kaIoqNXh3Gio5uRJpG78fn91ENQyaEsk09A1FaGAH7kcC1EUqvee+yaMYxlEg/5LOtXfCuQ+m26Qea25YgLzKMj09fV1lOeftan8aZw7nU5jZGTkogZASU/G/XVpvHHrGnSHA3ji5cMdz0VmBiqlAgpFazo4HA5Xf1sbuqMoCibM6i7eA8MwqxLrrVEoV1As5JCdnMTSJYtgUq1vkLpSm6SAZ5mW4odW8KjRammahgn3XobFEKvPljiWhVz1ebE01yxn0VKpjPF4EoZulQW9XgGBgL/Oornu2ikKuAYHSwAI+jxNfRjy/hrLcpSjZERQC6TNWmuN2R0pR/EMjTNnxqy+RHeX3V9z6rW5mbE54eFYOztzSviUHGU2y5jNC0HwIiAOYDJftPTVJAn5XBaa4VSRFuyehofj7HWTACbJCuLxCei6gYGBgboHKMcylnWC1wNFq2VrjYOghmGVhDO5okUekGTAoX1mDYJaJJFIBKApE4ViCaauYmxsDDTN2MoDjXI3iqrhjVtWuYqtXmrMNMgUi8WrmczlxHTcMaeLxiBjmibOnj2L48eP49prr8WCBQtmfO6p9HvWr1iISNCHh38x3JZdY5oGJtMZZHIF9MSikDVLQp3oUzW6WNZ2pO2le0hfQFFUrFy+DBTD1D2I3f/GKrVFgj5k8sW2PQ9b/sTrAUXTHUs2TmYUTVF1094UBXg8Hng8HtA0jUwmg3AoCJoCJsbHkIgz8AoCRNEHQfDWrUvVdagOB0uf14tcsTkgkffXKLDpEzyuZbfGLAyoDYs2QpIqeHV8HP09XfCINZ2qRio0OS8xQmuS32/4PE3TQFGqVCXy6wc3fVV2GMuyCAaDCAaDMA0TNGUgkco4hFC91sbFYXmgahpMw0A2nYJpmhgY6K97uDszNZs8UA3kjYOglp+M9b2yWGIcVE2HbtT6KbV1m/DwPAyf9e/e3l6kMzmUpTImJy3Cg8dDenYCrumPYKAr0vxBXgaQ+30mPZm58JK5nLiigsxcZjIkEJAH9eHDh5FIJGZFgHOqMzgLeqJ47+3b8dBze5GYLDT9XtM0TKaTUDQdCxYsQDY7CbGqCeYsSTgfmLWBTrSc3dA0DRMTE6BpGiuXL7VYb1rrHbQTPq8HmXyp7bBi/bWgoWi65ezZYcMgqyr8gtdVTNE0rSyzWCxgYMByhqRAYeGCQYwn0pAkCclkAoZhQBBE22SM7CwLZRkhn+Bq0dwIIrBJAW37OnVZmGx5qTRuGMrlMuLxOKLRKLw+P0SvRctmGbrlYCwJ0KKXR0XWYJhGS0VrsgYyK0Qe7JbGXMOxNAUTDJYuXohiqQKlqq9mqApOvvoqOI6DKIrwer3IZCbBsgxWLltal9l5eb6JRNBKKZuqliWtnpPFVJNVHQxNQeBZO9MmGyKrj1Z7rZKkIBIOwu/3QdMNaJqKctnq5VCqhKFrBzE6Oore3l5EIpFpZxGzCdL0nw67zTTNqz2ZucRUjcvmslwGWAZo+/btg2EY2LFjR52q8EzRrlzWiJBfxD1vugE/+9UBHD9bk+CW5QoS8TgEQcTAQJ/dTC2UK4jFulxLYY0GUW6zG7Js9TIEQUR/X2/d3EHLHXQVPMtCqg4t2kOFuuHS87Ag8DXPeKaDRhpQ072iKNQxxKysKwHFVlG2SCKBatmrryeGYrkC0+yqSraUkM/nkUzWJFt8Ph9Ujbc1zzo27jXrocExLFS9fXAsVawAJjX0UgqFIpLJpG2HAFi0bJ5jLSuLDvRwyxmShY/nm1Shm9ZAhChNklG18XGpSuazLINIMGANPIajkCQJxWIR2WwcFAVwnA8TyRS6oxEoug7TaN3jA2CTB8gQbaDhu+TMchRdRyhgKW+bpgmeZZArlQGznjxQR10GEAxyiEUjeNcbt+LgyB7QNI3jx49DURSEw2HEYjHEYrFL3ueYCX0ZuNqTuexo5445G+cGgF/96leIxWJYu3btrO2EpqsmwHMs7r5xE148cBIvHDiJYrGIRCKBvt5uiD4/SIOfphkUi1m8euYswqEQRFGATYhqcKwkcM5ujCdSSCaTiEQiCIfC1aDhFEp0yNnLanX+ofo7UKBoCoajjEWGCht7HkD1QedkVdnaVe4zEY0S+IQhliuWbP+LwcFaX8Dn9dhlr2LZoVRAWa6WkUhNsqVcLkMulzA+PgFRFBEKBuDzia2nza2tNSRZcR2wbIRQDQLOnk42m8PkZKY6JFtvrMdzLEqS0tRPcYNpWq6l1pxO+2NlVUNA8ELvNPkLq1/l5YlStpVx8jwPWZYRCAQQDAZQLkvI5axg7a9aOldoBjzvaUkeKEiWUjZVlUxqBYqyPGFCAR9KJRkUTYGm6OpMVL1Xjqpa6gjE8fUNm1chGrRKTCtWrADLsrbFQiqVwsmTJyEIgh1wwuHwnMvMzIRZBlxll112sCw7Z5lMPB4HAAwODmLlypWzOsQ1E100iqKwff0KlPOTePCZV7FsyUKAJrRu66YLBALwer3WDZXJYGJCgd8nguE86O2KotxiLsM0gXNjE6iUCuju6YHf52ttrwwH26o6uGlbOruUjmqlkvpSm1vpCKhptTlfm6rOWDT2jybzBaSTCXg4DtGumrUz58ioCCRFqWNyAZZdQjBI/F4kVCoVlMsljE/EYRg6oqEgKJaDKPrAOlw9/d5aH8ZWNWhxvWiqRjs2DKtHIpdLmJzMoL/fKus54XMYlrXqpzjBVQVEFVVrqU9GIHh4W+NrKiKfFE2hXLEUG9LZPMbHxxEI+BGNxmzVBqKvBl1FJpuDpspQNOcAbbP3jKXSwMHDcS0ZeADsDUI4IKJYHf4E6hUrnHI3uUIJqxf3Y82S/roeCEVRtgX1okWLrDLz5CTS6TSOHDkCTdMQiUTsoDMb1YpGzGRGRlEUqKp6NcjMFS5Xucw0TRw7dgznz58HYAWZ2Z4Snk65jEDXdRw4cACsVsYfvn83nth7vM6AijT4if98JBK2dupSGbSu4cjxE9Waug8+n1VXJw/uVCqFUqmMvr4+REIBMDRlP+hawckmo6fg30J6Hvmy1LJ/QEDKNaqqWU15lwBWqciWaZc/gL7eHrAsbWdLDE01yMBbcGNnWfMwStXvxfJIicUsv5dSqQQoFZyxy2o+9HRFUCg3P8jdBDZN04Tg5eom65PJJCSpgmtWLIOmo06tgKsy8pwkDdsSQVaagqyzwU6yzFbHNpIOOol8Oj+jZCaL/GQaoVAI4XC46Xvh9fIwDA49Hi9M0wRLmZhIZpDJZJBIqFXvGSvo8DwH0WMFaZqim/o0jRC9HkwWyuDY2gaBlMrINSUUaS/P48aNK6Hruq2gbgUho+4Bz7KsLYlP+h6pVAoTExM4fvw4RFG0A04oFJqVLGemMzIArg5jXk7MdrlMVVXs27cPkiRh+/btePHFF+ckU5pukKlUKhgeHrayme3b4fF48N7uGB58bi8uJDIAmhv8gLVT745Foagaevv6kExPolQu2XMlgiBAVa1hzwULBsGyLAzThK6a8Ho6+7EYhgFDN0GztSDXChQF5MsSQm2my50grCRrwLL++FKphEQigWjUUn52ZkugqLaS/TV2lvWAth6+9e+Tour9Xvr7B5CazEKWKzj16ihAUQ6ar2hnUERgkwxjOrXDDMNEPB6HpmkYHByEqltSLoZuWj2dBqHMuvdbsfophgmbHCF4ONfrWLNPMO1jTdNskqQBan0znayhCq+HswNMuSwhHp9ANBpFX0+366Apx1rZlHXtKOigsGTRApQl2SYPWAO0afgFAamq3I1QHb5t1edjaRpyNSNtRd92qkjv3LERkWAAqqpidHQUfr/f+o5W10vTtP2f8+/JTM6SJUugqioymQzS6TQOHjwI0zQRjUbtoDPdmTiCmQSZYrEIAFd7MnOJqbhjzlYQKBaL2Lt3L3w+H7Zv3w6WZWfFgtkN01l3Pp/Hnj17EIvFsG7dOpuF4+FYvP0NW/DUniM4dPqC69/SFG3PJJQqMmLRMIIBP1TdQKlUQjKZBLHnTSSS8Pt9CAWDlsUT1d6PBbB2x7ppoiLJU2KTsSyDolQByzCgKHRsbLMMjaIk1+12c7kcMpkMenp6mqidJtCRzQbUMoSwX2yrS0ZQUTXEohEwNIWSJEOSKnaNX9MStjGbzydCglWu8/Ks/eDUdR0TE5a0jTVPYj3knMQLlmXa2kvLJHP08KgoGrQWjo/kvOTYsqw0CWXWvbcG8oc14Gydu1SyNiTd3V0IBAL2oClRpQbqDfGcsO0eWNrWWGMoCsVSGcVS0cH0E1AQRXRFI9B00+7zuemp1dG3SzUFbgBYt2wBVizohWEYOHLkCCRJwubNm8FxHPTqsHJjwCEZkTPocByH3t5e9PZajqCFQgHpdBoXLlzAkSNHEAgE7IATDAanXOWYqW6Zz+e7LLYEc4l5FWQ6gWVZqG1qulNFIpHA/v37sWjRorr+y1yx16aayUxMTODAgQNYvnw5li5dagddctOwLIPbrl+HnmgQz+49WkftbSzVALVpdFNRkEol7RtG01RL1VqVcerVV8FxvPXAFEV0RcKu5SEAdbvj9hP0sIgHNANJsywF3AYb664RRUM3rFIH8RgZPXcexWIR/f39TXVznmNRrqgwTaOO2tsKvmoZxsOzoEB3DHhkty5WVaFFUYBpEiXkEorFItJpSyPMJ/oQDgXh94nIFUsYHx8Hx/Ho6emps0oGrJ4OhfqSZyuQOZ1IwIfJQqnjsSTAdHLydJI/LEdLuWoPkUJvb30wVzUNGmVZfmu60bZ5T4IoYQ3yPAfBFCCIAkwTtjkb0VcTqzM5HO9BVyTsWkaz6dtVBW7dsOSE3jC0GrquY//+/VAUBVu3brVZhuThbhiGfe+QMpp1TsoOOo1ZDpkhWrp0KRRFQTqdRjqdxvnz50FRlB1wotFok/RV3TWeQU+mWCzC5/NNOZBdKbiiggzDMKh0YNS0g2maePXVV/Hqq69i3bp1TRaicx1kWj1UnOvasGEDent77Z+Tm8TJud98zWJEg3785Jcj9g6z1e41MzmJVCqFBQP94DzWg5rjOCwc6EehLCEYjlXLGxbbamIijq5ICDTHw+utTYC77WBbTdADzXRVt8FG5/tv7GWcPH0GtKlj4YIFYBq16ihCDLAeGuWKAp5lQVHuwYPoklFU60l+J3yCx+5ROVWUKYoCz3Pg+TDC4TD0aoZIGRpGz54DAHg5BgzDoLu7uynAAFWJfU2HJlt6ccVy/Q69EYGqwvaU5pAoy1/IL3inNLNkyfQD+Vwe6UzalflmHWeiJCkI+LxtJW6AGmswEhCRydcCozVAW+sfEn21iiShXCggHo/bGaIg1KtvAzV7aY5lsPOG9WBpCiMjI9B1HUNDQ64PfGepjNx/5H5y3uduZTXAKqH29/ejv78fhmEgn88jnU7jzJkzOHz4MILBoB10/H5/3Xd6JuWy1yJ9GZhnQWYq5bKZ9mQ0TcPBgweRzWZx/fXXI+iYaCaYqTtmJzh3Vo1fPF3XcfDgQUxOTtaty5nuuw11Le6L4T233YCHnhuGrKhNMiqmCUxOZpDL5dHb2weW99oPS5/grU2lM3SdzhUpDanFDFKqDt5r7TKzmg6Gbb5pVF2H5lDtBWrT5W4bMqdGGnkIOtllVqkpDsBEd18fRK/VXFYcn7tf8DT1YRSNEBOaZ28a+zDtAh7Hsk2Di24MOHLtBvq6USxXwHoETEyMw6BocDSFs2dHHQ1wHziOteY/HG6eRaniappGYNG4a8d2mkMKVOeKZKgtDdZq75NBqSIjk5lEuVTAwsFBsG36D9ZnKk0pa/TyPCYL7QOjra/m98PDs9BVFROpDCYns0gkapP8Pp9o66upmoZN1y5FTySA4eFhmKaJoaGhKQnmkgDSKsshz5VWWQ5N0wiHrc3F8uXLIcuyneWcOXMGDMMgFouhq6sLkUhkxj2Zq5nMZcZMKcySJGHv3r1gWRY7duxo2cyby0wGaA4ysixj7969AGA3+Ela31hLdkMk4MN7brsBj764H6ULCfvnhmEimUxAlmUMDg7Y79eWnFfcZzxIWUisljcMXYOmVJDMZCBJFZtx5bzxAYdqr88LWdVQrjRPlzvhfGByLG0/vFVVxfj4BHi+VmoifigkePgdWUYjjOou2rJFsIJHO2YbmYwvVRT7QdiKqeZkwJGAYM23WBpqiUQc0WgMoZC1SaCqLKZs3qrxcxyPnlgYsixXDbus87p5uFQ/jKZNV800jWtSRhYb9NraHWu9TxoT8SQKhYJVjhQEsAxj072d8HlratkkawTl7kNEgbK/u+3cRAlqGS+FxQsHUK5YZmc1c7ZJMAwDURSxaKAHW1YtskkxQ0NDM55la8xynP9NJcvxeDwYGBjAwMAADMNANptFOp3GqVOnIElS1aBNQKlUglg1n+uE16LMP3CFBZmZBIFMJoORkRH09vbi2muvbVsnnavGv/PLTJDP57F3715EIhGsW7cODMPY6Tx5sEylpuvhWLzlxk345f6TePnIq9C0WtN5cHCw6SbUdCvQURTV1uqWogCGZeEXo4h1dSGbt3xeLAtlS2KkkR5dLMsIiB5omtLBVsx6CPIsa79HJ0U5FovVBRE7eFT7DZ3u13xZgl8UYJrmlCbjyYNQ4DhX73iCWkDgUVEtXa5cLo9UKoWenh74/bVehklR8AeD6OqKolCqwNQVZLJ52z+dZDiCYJWnGplUbtka4C7ZwjKMzcrqdKx1bi9Onz2HclnCwMAAeJ5ryeYigcd5bqWFGCeAJm03NzdRAosx57SttvTqOIapGtsFYRgmKhUJcqWCRQEav3z+eXAcZ/dMyPW7GLiV1UjAmWqWE41GEY1GsXLlSkiShEOHDkGWZbz88svged4uq7WTu3kt6pYB8yzIdIr20y2XnT17FseOHcOqVauwaNGijsfPVSZD3hc5N3HWXLZsGZYtW2bvWNuVx9qBpmn8xqZrIPI0/vORp8F7PLa3jBPOOYupTK7bxyuWBzzLMAgGrRtfksoolcp19OjeriiyRR1eD49OjpuAxT4rSTKgaxgfH0MkEq1aFjSDgqPf0GFGB7B6LyxLg2c7y8BUFBV+0dNyt+0EeRiHfF6MnhtHNptFf3+f68OOCIiG/SIkhUMP74VpWhJBVrCunyuRRRGxcNAiP3SYWypU/YUKpUqVBNGaFUiOLZaszOLU6FnIslx14Kw9AgibK+S3LI6Jw6nbud3EOJ0ZT+M1awx2FEW5MuZqmatlpGfNM4m4/YaN0PIJsCyLrq4uJJNJnDhxAqIooru7e9Ym+VuV1cj9OZUsRxAEeL1edHd3VzUGrSyHyN04B0Gd35u5CjJ//dd/jZ/85CcYGRkBz/PIZrMd/8Y0TfzFX/wF/uVf/gXZbBave93r8I1vfAMrV07fRmFeBZlOmGoQILTGeDyOLVu2TNnOdK56MsQzQ9d1nDp1asoN/ukgmUwiN3EW7771eoycSTc1tRutfztNrjceXyxb8iCKogEw7Ilq8tCEruH8+ARU1XpoBvw+RCNhqC2sJgmRIJezmqnLlyyESbt/HZ0KAzLU9qy2KhiaglRRWu6ineBYBuWKZVg2lSAmenicPH0OpiZjYKAfHo+n5bGmacIwTXh4FlrFAAXTlrKPxaJQVQ3lcsmeK0knPQiFAmA5Dzieb/ldINPxkYDYlvHlPFbgOZwfG4OiEC+Y5h01RVnqyKLXA4ah29KsncOjqqY1ZTyNKErW8GixXIFPdM/UgGYjvQXdEai5OHw+H9avXw+aprF06VJ7xiWZTOLAgQMwDMPui3R1dc14xsWJVuSBxrJ2Y5ZDejKkVxOLxbBy5UqbCk+CpCAICAQCOHXqFPL5/JyUyxRFwTvf+U5s374d3/72t6f0N3/7t3+Le++9F9/97nexdOlS/Nmf/Rluv/12HD58eNoKCZTZrtN+iaFpWtuHfC6Xw549e/DGN76x5TGyLNusk82bN08rnT506BBYlsWqVaumte6p4IknnkAkEkGhUMDQ0NCUG/xTwdmzZ3Hy5EmsWbMGfX19KJYr+PHzIxhPZwFY6stEDsYNftHa5RKWk4fjoGjux3MsC5qi6uRBnP0EVVVtN0upYs2mWG6Wfng8lsaV6OHtpnOhkEdfX59ls+z1oNKgkQbA9cHPMQwYx9S/EwHB21T2ahk8TEt+hfSpTBP2rt+N9cUxDMbGxyFVKrZVcqOuW93rOoJ4p/6EYRgwdQ3pyRwUuQKYJjhbyr6ZcUVYfW6fSSN0XUd+MgNZ1bBwwWDL4E/g4TgYpgGaotueF7ACacgnoKJodQSNVgj6BJQkuaMoKQAERS+WBCn0xCL23FirNeTzVukymbR6TaFQyA44gUBg1hvqjVmOUwl9//796Ovrw+DgYMu/J3I3r7zyCn73d38XpVIJfX19+OxnP4udO3di4cKFs7re73znO/j93//9jpmMZecwgE9+8pP41Kc+BcB69vb29uI73/kO7rnnnmm97msqkyF9jnA4jPXr10+7KThXPRlZlquUzTJuuOEGeKuMKbIrAto3+FvBMAwcP34c8XgcQ0NDtnmZX/Tinbdsw+O/PoRjZyYcplHucGYpJvlfi+MbzbHIfAsBx3EIh0MIh0PQdQPlchmmpmBifBwUTSHg90MSBeRyBSiKjIGBQfC8RT8tV+SmpnLjgJ69jgZfGAKf14O8S8nGWTJyBo9mZeDq9XCxVTYMAxPJBGRFwcDAoFXuq67ZjT7t4bg6+f52/QkACAV8KJQk9PR0wzQtqRtdlZHKZG3vFMuywAePh7eHKNuZpgFWgMllUqioBvr6+qAZZtuMjRizqZoOijKaXE0bEfQJyJcrLdl9TrCMVSKlKKpOV84NmqbBDwl93QuxZs2atqUwiqIQCoUQCoVs9lcqlUIqlcLo6CgYhkFXVxe6u7sRjUZnxcK9VZZTKpVQKpXAsiwURWk5CErkbnbu3IlTp07h937v93D69Gl873vfw+/+7u9ix44dePbZZy852+z06dOYmJjArbfeav8sFArh+uuvx4svvnhlB5mp9GTIzqHx2PHxcRw8eLBukHG6YBjG1kCaLRQKBezZY0mQr1692g4wzga/U5tpqlBVFQcOHEClUsF1113XlLGxDIM7bliPnkgAz40c73g+qaLYelGdyi+kHu8XLDZcK8dNQo8GgO6eXuSLRciS5TtvmlbzW5YtIUSyISBNZbHqyWJ2CJBOOwI3oUwCt+DRyMiqux7EVpm1mupWJpCGrOoYGBiod2R0oU+7OWgCrZvxgoevK00RqRvwPNZ0dyOTK6BclqrllgwCPgE0y9vECwBNpmmA9aBOJuJgGA79/X12/89iA9YfS+Bs3je6mjZ+T51W1ISg4UYNJ+fiOcYWSm3n+qmqGnithPUr1mHNmjXTvj88Hg8GBwcxODhos79IiUqSJEQiETvLmY0+CPk+yLKMAwcOYGBgAF1dXQ5Rz/aDoETZ441vfCO+8IUvYHJyEocPH74sdGaick7K+QS9vb3276aDeRVkOoHsPnRdt/+/aZo4fvw4zp07h40bN6Knp2fG55/txn8ikcC+ffuwbNkyjI2NAUBdLXem5TFJkjA8PAyv14vrrruu5a6MoihsWb3UGtx8YV/HRryH51CUlI67Uevc1SFT0wQFqk740Q2yqiLkF3Emk4YgiIhEIpCksi0d79ylcxyHklRBNOifuuOmYO3s3ejHTpDg4eFYV0aWEyRD4FkG5yfGYYC2H9SNaKRP+32tVa2B+syKYdwdNJ3HhoMB8ByPUCgI0cMjmZmsGqBZxAuLei7CMHQEfSIkRYEsqxgfH0PQ70coEqlbN+mnNNo4iF5PU/OeXGO/4LUtsWu/bA6kbrNQQPPAcCvXT1XVkE0ncc8tW2cUYBrhZH+tWrUK5XLZznJOnDhhN+nJjMtMyQPlchl79uxBb28vrrnmGnvdUx0EdTb+I5EIXve617V8rc985jP48pe/3HY9R44cwerVq2f0XmYTV1SQIbtdEmRUVcX+/ftRKpVwww03XHTTbLYa/6Zp4vTp0zh16hTWr1+Pvr4+xONx6Lp+0Q3+bDaLffv22V/kqdwQSwe68ZvVwc3JQsn1GKeDZkmSEfILyLWRhnd619cJP7YAQ5k4euIU/P4Ali8cQFGS4fV6HD4vFj3acmBk0R0NYaxSQVckjJKsdJxepykaqqFZwaNDMFVVDRzDu4pINqJSkXE2MYFYOAyvr3NdP1+WEPb7Okq7kMzK6+HAMkxHsgHRBqMBSIpmEy+6ugBFsWZ1crmcHbADPgH5fAFdkTAEf7BlMHWW+zTDbBt4nZbYiqq11DEDrCa/83vBc6xrxmLLxlQdQqWKjPHxcbz19ZuxYf26OdnJi6KIRYsW2TYAmUwGqVQKhw4dgqZpiEajdpYz1Sa3JEnYs2cPenp66gIMUM9YIxmN2yDo2NjYlEv8n/zkJ/HBD36w7THLli2b0rka0dfXB8BiwTpVUeLxODZt2jTt882rINPpC0UezKTuuXfvXgiCgO3bt7fVEZoqZiOTMQwDBw8eRDqdxnXXXYdQKGSvXVGUiwowExMTOHz4MFasWDElSrYT0aAf97zpevz0hf04M5Gq+x3T4KBpMYysWZOyJDdlKY3Hyx16DYpcwfj4BMLhMEKhcNPu1fJ5Cdr0aENTMJnNo1SexMREHJFwEF5BAM97XIOqT/DaZa9OkjFArQ9jmkDQ39pnRZIkxCfi6O3pglf0wy96bEvjVuBYFgWpAp5nOwZe63gGFUXr6LUCALKswifw8PKsfZ0tuRYPPB5P1etFsxrgmUl4OQaFQgFlWanO5Hhd36dSzdhIFtZ2DVWKsXVs+xkkpyCoYbYve5YrMkxDRzIxgevXLccbtm+9JKUilmXR09ODnp4eqzRYtNxLx8bGcPToUfj9fjvghEKhlt+TV155Bd3d3U0BphHk+9s4CPqLX/wCw8PDbUlNThDrgrnA0qVL0dfXhyeffNIOKvl8Hi+99BJ+53d+Z9rnm1dBZipgWdaurS5cuLDjhzodXGzjX5ZlW+5i+/btdQ3+QCCAI0eO4MKFC+jp6UF3d/eUa8FE2+zs2bNYv379jL9cgofHW98whOdGjmPvsdHqyQG+6mvSCLJ71p2MqBbHt+o15PMF5HOTiHV11w0rtnLcZBkGDO8Dy3vQ5ZgpyaQzMHQNDMdDFH0QRREcx1ZlYGrU2XaSMQAgenk7IFGU5bPi5slSLJaQTCaweMEgaI6vXo9mCf46mDXFAFkxOs4iefjaMGK7xj1BwC/YfZtWjqKqqiGXy6OrOviXLxRBGRoSiXh1nkm02WpOCrNP8CBbLHc0TQMs3kRNjLP9sbphgK2y4ipV1Wc3KIqCsbFxLBnswztuf/1l6UVQFIVAIIBAIIBly5bZApmpVMpWGSABJxaLgeM4VCoV7NmzB11dXVi1atW0103TNF566SW85z3vwb333ouPfexjs/6+zp49i0wmg7Nnz0LXdYyMjACwXERJ9Wf16tX44he/iLe+9a2gKAq///u/j7/6q7/CypUrbQrzwMAAdu/ePe3Xn1cUZsMw2qosm6aJJ598EoZhYN26dRgYGJjV14/H4zh16hR27Ngx7b8lDX4ns62xwa8oik2xzGQyEAQB3d3d6OnpaSkjrus6Dh8+jGw2i02bNs2aa97BV8/jiZcPw+f1dPR7YRkGHEtDklUEfELb2QnTtGin+XIFmUwGmlxGMNIFQXAvO/DVYUDbcVPwtsxCVFUFdA3JzCQqlQp4nkckFALL864WwI1CkSz5TFw2Ek5PFiKE6AwwTjA0DQ/HNhEeWpWP3GaRKFDgObYuezFNtGzGW7Tv+jmUxvPW5G2iGOjrqQtYlgp1AaWiNZNjydt4IIoiIuEQQNF1x5YrimufrfEz8gle12yXwBlkW81kybJSHcaN4OP33Inu8PxzhjQMA7lczu7lEJvkcrmMaDRqz+9MFy+//DJ27dqFz3/+8/jEJz4xJ8H1gx/8IL773e82/fzpp5/GTTfdBMAKsP/2b/9ml+DIMOY///M/I5vN4sYbb8Q//uM/4pprrpn268+rIGOaJpQWlEYiJDkxMYHVq1dj8eLFs/76yWQSR48exW/8xm9M6+9Ig3/p0qVYvny5zeAhdddGJglgsX7IUFYymQRN03bAiUajdnlt3759ME0TGzdubDv0NxOMJSfx8PPDrrbIbgj5RWQL5Y6yLqZpIp+dhFyREI51dxyKo2kaXt6SmGnXLLfObQWxbLEM2tSQSE+iXJaqk+FE5qamHu2cTek0lEnTNEqFPCYSKQwO9EMUxbYDn37Ri0I1m/B5LZZUq2vT6KLZzu7a5/XUNdiZannVbS2Ch4ei6cjlckgkkujp6UZfT5fruZ09EqsPVoZULkNRKjBM2BmiIAgQvLy16WsgJLitu1VPjqZo0HT9ugWeh1LtTQJWz2t8fBzhcBi7br4eW69d6n4B5xmy2SxGRkbAMAwURQHP83aWE41Gp9RbGR4exl133YU/+ZM/wSc/+cnLkr1dClwRQYawqWiahqZpWLFihd2cmk1kMhns37/fju6dYJomRkdHcfLkSbvBT34+nQY/oVgmEgkkk0moqopwOIx8Pj/jmZ+pIl+S8PAvhpGYzLc9jmNZ242yHcVZ1w3E4xNgaAqDAwOgGaYjqw2wBgtZikZBqkzpZgv5rUl30jy11KMt8oBh6BAEscpWE+HhefgFHtli+wwslUqhXC5jxdJFYLn2AYnAL3ohywoMEx2HC4nApsfDoVhuHZAAixpswmrEt8vuAKBcLCIzmUEk2oVIOAhV01v2PxiaBs+xddlFoSTVXT9d1yGKAgJ+P8KhoD24aUn0uJ+78bwAWpb/WIYBy9LI5goYH59AJBLB+lXL8I6bL00f5mIhyzJeeeUVhMNhrFmzBoZhYLJqqZFMJqEoSh15wG0g/MCBA7jzzjvxh3/4h/jjP/7jK+J9zxTzPshMTk5ieHgYPT09WLNmDV5++WUsWLCg7STtTJHL5fDKK6/glltu6XisYRg4dOgQUqkUhoaG7Ab/xUrEmKaJ8+fP49ixY+A4DqqqIhKJ2FnOdCUdpgJF1fDzXx/E8bMtOPAUZVN+AbSczFdVDRMT45ZfzeAgVF0HRdEQPFxbSjRTpXCq2tS8UHiWhWZYPY/GSfeaOZb1wFQUGaGAHwznQU8sAlkzmh7uhmEikUhAURT09/cjGvLDBDpmVQRBn4BSRZkSacTLc6AoakoBjKZpBEQvcsXWzfhsNovJSUs/LRYJQdONjjbagFXa03RLvsV5PcgQKFFtqMgVhP0+gOHQFQ3DAN02OJJeUTt3TsCyGJ9MpyD6g+jpiuF9O3cg6Lt4scu5hizL2LNnD4LBINauXes6C1QqleyyWjabtfXV8vk81q1bh1OnTuHOO+/E7/zO7+Bzn/vcazrAAPOs8d94sc+dO4ejR49i1apVWLhwISiKmrHc/1Qw1ca/oigYHh6GrutNDf6LmeAHgPPnz+P48eNYs2YNBgYGIEkSkskkEokEjh8/Dr/fbxMHGo2SZgqeY/HmHRvRFQ7ghf0nmn4fcPjPALXJfOeUuyzLGB+fgCiKWLpogcOAzEBJklsO8zX60Xd03ARA0RQMzaiWIhuGICmnOVbEGhYtlZAvFHH0RBpBnwiwHHyiD16vB4ZhIh6fgGmaGBwcgF+sPRwbpf3dYBEMpJo6c5sJdphWL6aiqB2b/IAlYZMrll2b/MQvKJ/PV51DPVafpzo82gllWYXPwzUFDDIEyvNOc7EyGFPHq2fOggJlZ4iCIDYZsxXKFYT8YluFAEmSMDExgWg0hoX9vdixYcUVEWAURWkbYADrGeb3++H3+7FkyZI6fbUPfehDmJiYQCAQwHXXXYff+73fe80HGGCeZTKA9bAyDANHjx7F+Pg4Nm3ahFgsZv9+ZGQEoVAIS5fOfu1WkiQ8++yzuP3221t++IVCAXv37kUwGMSGDRvsBn+jWN5MMpjjx49jfHwcGzduRCQSaTpGVVW7h5NKpeCpqi13d3fPigItAJw4F8fPfnXAZk/5BXdlXcAKpALPIZmZRDweRyQSwYL+vpYzHz5S9nF85ZzK0E600iZzO540zN3ZZLUARNSjdVVBNpe35XBYlkV/fz881SzDGdxYhgHL0K6OkI09nlpvxv39O9ferskPNBMDfILH9r0xTSCdtprP/f39lgW0oyfUyVjMNE34BKu5T3o67TZuxJPGw7EoFK2AXS6XrD5X1c3S5xPtoWDBywMG6novBNYAadzWE1u1qB937tgw7x+2iqLglVdeQSAQwLp1M5vfOX78ON7//vcjEAjYTNRt27bh29/+NtauXTsHq54fmHdBplAoYGRkBKqqYvPmzU12pAcOHIDX652R5HQnKIqCp556Cm9605tceyDJZBL79u3D4sWLsWLFiik1+KcCTdNw4MABSJKETZs2TcmCVdd1ZDIZJBIJpFIpmKZpB5xYLHZRPZxktoCHntsLWdXaCmsClnVvqZiDLxBGdyzaUliTYDqN+MaHtk/wtO1lNDKd2g0LwjRw4cIFkOF1RVEQDQdBs566B2ZtHXzdMGGrZrwVPJpf140dBjQ3+QnctMW8PAdV0zE+MYFKpYL+fkuqn6VpoGEtHMuCouDaD2ts3luB1N2wjKYpMDRjbzpYhgHHMCjLClRVtRWkK5VK1ZgtApNm4fF4wLFW74VsFCxriDi6u7sRCPjhF7143x07IHguXi15LkEyGJ/P11aksx1GR0exc+dO3H333bj33ntB0zQmJibw6KOPYvfu3a6bytcK5lWQ0XUdTz31FAKBANavX+8ql3LkyBFQFDUncgmapuGJJ57AG9/4xjpGlGmaOHPmDE6cOIF169bZU7CzIdFfqVQwPDwMnuexYcOGGQ2VmqZZZRdZxIFKpYJYLGYHnZlInpcrMh791QGcGU+5/p6Ua3I5S0W5OxaCoupTavKzDAOeY6Co7eX6yesEfV7IigrNMDuWMwnTiWXplgHMKu2NIxgMYuFAvzXJzjKIpzIol0s2PZqw1XjeYvUF7SFOy3qgXbnLmU20Y4cB1Sa/WbOY9lXl8Bu/TqZpIpVMwjQ0RLt6wLJsW9q3Wz/Mw3Ou5bRWWVgrIc3GQKXrBnRNQTabR6lsZZQkw+mOhpHMZBGPJ+rM3d5201Ys6e9qcQXnB0iAEUVxxjTlCxcu4LbbbsNtt92Gb3zjG7NScbiSMK+CDGBlC+1kuY8fPw5VVeckvTRNE4899hhuuukmu8FuGAYOHz6MZDKJzZs320rHsxFgcrkcRkZG0N3djdWrV8/Kl480HklZLZ/PIxQK2cSBqWRJBLpu4Om9R7D/5Lmm10gmk5CkCvr7+8BxHPyC1xrabONB74To5adEWSYI+gQUy3Jbb3kCD8daar8uD95yWUI8bjGawuEwTBMIBUTkCiX7MyTq0WSXTtO0HXBikTBYhkKh3FlIla9ukjjWfS1OWDRuDqqqQzeNpmBqGCYmJiZgGAb6+/sQ8vtQlGrGZa1gmkDIV7Wjpml4WKal7E5jFtauVGofS1StKco+t2maqFQqtoWyoqgQeAasx9Ks4zgWm69ZjJu3XNv2mlxuqKqKPXv2QBCEGQeY8fFx3HHHHbjxxhvxrW99a85YovMZ8y7IqKradrd66tQplEolbNiwYU5e/+c//zle97rXwefz1TX4h4aG6hr8FytyGY/HcejQISxbtgyLFy+es5p0pVKxA04mk4EoijZxoNUAaCNGTpzFM3uOwDDNKkU5DsPQ0dfXD5Zl6na1hJ7q5vNCQMpYrUpLjSDndw5utoKz39C4Cy8Wi0gkkuju7rKHWkk5iOdY16HCRno0Q1Wtk30iON7T8aHhF70wDLOj4ChB0NesGafrBiYmxkFRFPr6+qqKvUDI50Wh3HoQ0gmf1wNQVNuGPIHo5aubheZg1wjBa1lEiF539e5CoVjdOPrBUCZyhRKiQR/uufU69Pf1tZRqudwgAcbr9WLDhg0zCjDxeBx33nknhoaG8N3vfndW7AWuRFxxQWZ0dBSZTAZDQ0Nz8vpPPvkktm3bBpqmbSYJKd3NVoN/dHQUp0+fxrp16y5KNXq60DTN5vKnUikwDGNnOJ3UZ8/G03jgmVcweuYcWJZFb29PtfFfM/wiaNcAd1N4bkWJBpr7MGRws9UAaWNznSgd5/I5ZDIZ9Pb22tmcVfYS7AdvJ6FPCoBh6Mjm8pAkCaamAQxrq0cTXxwCp5kb0QVr930ha3fSuHVdx/j4OBiGRW9vb43NRVHwsCxommryvXGD6PVAr3532yk+19bitXtyneAXPFC05lJpPl9AOp1Cb28fRNFij3EMjZs2LgOlVpBKWaXYRqmWyw1VVbF3717wPI+NGzfOKMCkUinceeeduPbaa/H9739/Xryvy4UrLsicP38e4+Pj2LZt25y8/tNPP40lS5bg1KlTWLRoEVauXFnX4CeXayZfPGILnU6nsWnTJtsd83KADJARerSu64jFYujp6UFXV1fTrqtQKOD5F1/C/nNZsIIPFEW17TW4sacYhgEFuB5vmZXVZynW8J8B0yX4uGmTuREJTBOQSgWk0hn09PbB662pJrj1G9yGCmuvWZ91aaoGGjomkhlUKhWwbC3gCIIXPMvWOUW2k2BpXLuX5yBVZJw7fwEeD4+enp669+oMpp2cMVmahglrWJShaXj49nNL5NwURVcJC62zH/IdsPx5eLtPlcvlkcmk0dfXVzeM+LoN1+D6tZY6MOklkky7XC7bPi/d3d3TKu3OFlRVxfDwMDiOm3GAmZycxF133YXFixfjv/7rv2bFBvpKxrwLMp0smMfHx3HmzBnccMMNs/7apmniqaeegq7rddpos9F/UVUV+/btg6Zp2LRp05wMVc4UxLqW3OylUgnRaNQmDpRKJezfvx9LlixB/+AC/OxXB/DqhQREL99RksbJnhK8PKQ2x5O+BHkAtmpSEzh3/G4Bz+odpSBJEhYtXACvx2M/iNtZTAPNje12TpL+6hxRuVyuDjGWIPAcKJarSrUI9sPKLVtyk19RFBWJxASCfj8CoUhdX8Tntdbi/BlFUXUPeec1cCMGtBLYdGZf1t+j7YyT89xkY3F+bAKZyUn09/fVfc8HuiN41xu3tXxwk5mwVCpVp+3X1dU1axT9dtA0DXv37gXLsti4ceOM+ie5XA533303ent7cf/998+6FNSViCsuyJChxBtvvHFWX5c0+C9cuIBrrrnGnsNx+j3MpDwGAKVSCSMjI/D5fHMqETNbKJfLdoZD/MB7enqwfPlyWzn6V4dO4cUDJ6d0Pg/HwcOxyHcQ4iQIiAJ0Q5+Sphqh9TZ6w1hT/HGoqor+/n6w1eFR0cNbw6QN4pRu8ItWqY3nWaiae0blXAchPfgED1KZnE0eUFW1Ok9ikQc8PG9nS25BwBKMHEcgEEAsFm3qebUS+XTLHtvRuBsDKQUKHOcuA+TzepqUqt1mlrLZLKRSAbHuHpuVB1jZ1vt27kDYP7XshGj7kcl5wzDsslpXV9esl59mI8AUCgXs2rULwWAQDz/88LzaSF5OXHFBJp1O4+DBg3jDG94wa6+pKIo9m0NRlO2nMBsNfqKHNjg4aM/WXAkg9gJnzpzBggULqra/aXg8Hps4EM9JeOzXhzoqMIheDyqKWpeltINfsAgWUzErA6x+h6JrNtnAapRbEjl9fX1gmNoO2DSBaNDX0XHTXruHhwlMSQbGmvpnUaqodQFJUVQ74Djp0T2xCDze+sn/SqXmvRMOh0FRzmyiUiU1tL+GJHvkmM6BVOB5qIYBTdPainYC9UrVlpZdfeCdnJxELpdDf38/AlWaMglYt12/DuuWLWi7llZwy7QJY5KU1S7mvtI0zdZG3LRp04wCTKlUwtve9jawLItHHnlkViydXyuYd0FG13U7c3BDLpfDnj17pmzu0wnFYhF79+6F3+/Hhg0bMDw8jP7+fvT3919Ugx+w+PFHjx7F6tWr50Rrba5AsrrJyUls3rzZ9pzQdb1OORoAaI+IPa8moYNukhgBLEMy06jtvFv5vBA4+zDO7KAVCPGAkA2yhSLGxyfAcSx6enqb1kRouX6htZy9E0FRgKSooGmqs1yLWRX6ZJmWD2tLpkVCuVyCIlfAcxxolofPJ8I0UZXqjyEUau7XhauioJ2a/IAVEBianlJQZxkGopdHrtjehAyA3dMxDdMmfFgzU5PI53Po7x+ApzpcSRQh+mJhvOU3Ns3aBoswJklZjShfzMQ+Wdd17N2796ICjCRJeMc73gFN0/DTn/501uw4Xiu44jh1s+FeSZBKpTAyMlLX4Kdpuo58MJM6sGmaOHnyJM6fP4/NmzcjGo3OynovBTRNw759+6CqKrZt21aX8jMMY7sIEn+NRCKB9VIZzx04jYpB27pWDMMApiUPI2m1LKBQlhDwCe4PYYoCRVMwNevaV4jjpguDDbB6GURXzDRNZHJ55DIpeDw8uru7mx5qPMfaU/elilzdmbdmW4lej+3+aJmKedtSgG3HTVmtnyFxgGEYBAJ+BAJ+8ByLbK4AQ1WQSiahajo8Hg9o2nJ/dT7wvDyPbLEMjmXBTkGfjGcYlGRlSn0zmCbKFQUBsXXficAiD1AwaQqmbAKgkMlkUCgUMDAwUNfkNgwDJkzcet2aWc3gvV4vFi5ciIULF9obn1QqhYMHD8IwDMRiMbus1q7pruu6bUY20wBTqVTwnve8B5Ik4bHHHrsaYFxwxWUyU9EXmwrOnDljC1GSLMM0TRw4cAD5fB6Dg4MzUj0mvjeFQgGbN2++otJmoj7g8XiwYcOGKfP6TdNELp/HQ8+8jH3HR6EoCrxeL7pjEYDmwHHN52n0FQFa65gBzY33xqn7SkXGxIQ1xb+gvw8VpVm7y41I0IpN1piBWa/ZugluNd3rZWOIb71b5hEUBbtHVSgUMJlOo7u7CxVFtdWjPR4vfD4RPp8fPsFrM9UoiqqyvtyzlEZvm4CvtcW0syfUNGDpAqcIqM/rwdnzYyiWiujvH2iicAPA7tcPYdngpaHpm6aJQqFgZ9rFYhHBYNAuq/l8PsfAreUQaRgGhoaGZhRgZFnG//gf/wPxeByPP/74a1oa5mIw74JMJ3dMVVXx5JNP4tZbb53RcBOhEcfjcWzevNn+YhAGmSzLiMfjSCaTyGazCAQC9u69U8CoVCq2kdHGjRuvKOpioVDA8PAwYrEYrr322hlncHuPncFTLx+CoSm2gyXH8fD5ahIt5FnnFJ9sN11unbt+cNPZ0Caii9Fo1LZcaBzc7NRvaPx9O121xiZ4O2q2G71YrPZhKKpG9e3t7bOywCpDTNM0m60GQ4Wqw6ZHk41P0N8cPNx0zIBml1ACN2JAq+BIgQLHMlVWniXSqSoy+vr6Qbl8XzasWIhbt10+4cdKpWITB9LpNHjeynCj0SjOnj0L0zSxefPmGT1HVFXF+9//foyOjuKpp56qE/G9inpccUHGMAz8/Oc/x8033zxteqCqqhgZGYEsy9iyZYvN3yfN/cYGv6IoNsuKUCpbTcuTh3Q0GsWaNWuuKH2idDqN/fv3Y/HixVi6dOlFlzZOj6Xw2Ev7Ua4oLhItTN0sCU3T1TKU3Ja9RSB6eWv2pRoArJ1rCj093XbviIAMblKg2rpWEhA2WcDf3mIaqDXBFVW15l/a9D6c8yZWGdGEpltGddlsto7q25gt+QXLT6ZSkWx6NFBVHRB96I6GUalKuXSyr3aKkwJWIG5lcOYWHEk2aRm8JSFJEvr7ByB4PVZZ1FHSjAR8eO/t2+1gf7lBBGWTySTGx8dtthqZC5vOs0TTNPzWb/0Wjh49iqeeeuqSDlRfibjiggwAPPbYY7jxxhunVYoqlUrYs2eP3eAnE/xOD5h2DX5CqSQilBzH2dPymqbh4MGDWLp0KZYsWXLFMMgAYGxsDEeOHMG1115rzwXNBjL5Ih56bhiThZL9M0uixXpYlkolSwJGFBEJBxEKhabUpKZpCl6Og24YiCdTmJycrJsobwTHMPDyHPLl5hKXG4KigKJUgTGF24Kpmopl25iKEZgmEBA90A2r/5HJpFEoFC2LARcVYp/ggarpTdIupgnIcsUOOKqqIhjwQxRFRCNhVJT2E/osw4BjaUu6v8MckhUcLWq46GDBJZMJVCoyBgb667IAkg3SFIV3v+l69MfCHa/LpYRhGNi3bx8URcGqVauQyWSQSqWQy+XqymrtfJp0XcdHP/pRDA8P4+mnn54Th97XGq7IIEOkX6Y6MU8a/AsXLsQ111xz0RP8hmHYMvsTExPQdR2RSASLFy+esr/35YZpmjh9+jTOnDmDDRs2zEm6X1FU/PSFfRh1UXK2HpYyoCtIZrJQVRXRUBAM54EgimDZ5mtIdupFSUZ2MoOKVEa0q7v1LtSslr0UZUqOm2Sg0yKAdGaTeT0cKrKGgOhx7dM0IlDVMRs9fx7lklT1gmk97xEQvZAVrU41oBEWPboETZEhVyowaaZOPbrVkiIBX90GoBVMEwj6vShLCjRdRyKRhKLI6O8faPqMSBa2ZtkgXrd+9q04LgbOADM0NFQ3ZyPLcl1ZjWVZm63mvJ91XccnPvEJ/PKXv8QzzzxzRTFGLyfmXZBxs2BuxDPPPNPS2KsRZ8+exbFjx5oa/IZhQNf1Gc+/EGO1RCKBFStWoFQqIZFIQFVVWxaju7t7XoriOeVtNm/ePKeMGMMw8NzIcew9Ntr0O2cfhjwsFVmGJElgOa76sKxpgpEpdWJn0NfXh1g42PIB30gkaOe42VhqsiboPS3ZZI0+K516Pl6ehyTLSCQSMHUd/QP9MFt111EjBtA0DS/HotxuToey7LHL5QooU0c8lUGlIoGmGVtuXxAE+xqR9xXwCSi2afI7r4tpmhg9ew6yQoZb3TdSfbEQ3n3L9XWzSZcbhmFg//79kGW5KcC4HUvklpLJJBRFwXe+8x1s2rQJp06dwnPPPYenn34aixcvvoTv4MrGFRlkfvGLX2D16tXo7u5ueYzTXXNoaKipwX+xEjH79++HoijYtGmT3dsxTbOq9JtAIpGw5VlIH2c+SExommbfcJs3b75kU8mHXr2Ax18+ZJd+rH6A+xS9aRrQFAWpTNYKOCxrZTm8B5OTk9B1ve5B55aluLG9gBk4bro011v5ybSya7Z03iicOz8GXdesDIbjWmqkESdKJ/yiF4WWwbS+eU+OdapHG4YOQRAR8Pvg9/vt6SDBw7cV2CTnisfjoEwT/QP9MFo8MViGwfvu2IFIcP4wKg3DsA0Bt2zZMi2lAMJW+9KXvoSf/vSnOHnyJNauXYu3v/3tuOuuuzA0NHRJe6+f+9zn8Jd/+Zd1P1u1ahWOHj16ydYwE8y/bfYU0GlWxtng3759uy2016rBPx2Uy2WMjIxAEARs27atyUExEAggEAhg+fLlKJfLSCQSGBsbw9GjRxEKhWymmlM08FKBsN84jmta+1xj7bJBRAIiHn5+BGVZqZYs3R9sFEWD83hxzfIlyBZKkCsyKlIZ2XQaAOD3+yHLMmhaAE1TKEqVusFNlmEgK5prqUjVdWiGUUeJ9vK8K3WaooBCyVJFdrLJWs35SLJSnfqv1//y8hxOnR6FaZro7x8Aw9DQDQOSrDQFD0vDrPkpXixXEKj2i5wQvTzypXpWXrFcgejxgGVZiKKAWMwisRSLRUjlIuKJhE2PVkQffKLgOnvDcyyKpUq1JGxYZn0UDZF3z6zesHn1aybAANb9TPozpVIJL7zwAk6cOIFHHnkEX/3qV/HMM89g8+bNc7R6d6xduxZPPPGE/e/5WClpxLzLZIBqrb4Nfv3rX2NwcNC1JloqlbB3716IooiNGzdOu8HfDtlsFiMjI+jv77d7O1MFmVJOJBKYnJyE3++3iQPtGo2zhWKxaLPfZkpRng0UyhU89tJBnJ1wd9xshM/rgaqqODV6BhzHIRgMolyWUCqV7N25z+eDKIrw8BxYhgZFU22FOIFa/6AkyWCYWtmrFcjgJk1RUFowsgicVgcCz+HEq6NgGBq9vX2uqgj+qhOmic6Om86SXyu6MkGjtw8JrJqm2cQBSZLAcRx8Ph+6omHoJm0FLBPw8CxOnzkH0zTQ19dfVwJrDI5L+7ux+w1D84b0YhgGDh48iFKphC1btsxonMA0TXzhC1/Ad77zHTz99NO49tqayZqiKOA47pK+38997nN48MEHMTIycsleczYw/8OgC1plMul0GiMjIxgcHMSqVatcG/wzDTDj4+M4fPgwrrnmGixcuHDaf++cUlZVFalUColEAqOjo7YeWE9Pz5yYOGUyGezbtw+LFi3CsmXLLuuDICB6ses3NuPnLx3EsbPjHY9XVQVnzp23WGjRGKiqaVgsFoOiKCiVSsjlskgmE/B6BXTHwvD7/B3PS1FAviQhEvQh34GuDACyooJlaPA819JZksA0TRTKFYg8ixOnXgXL8ejt7Wl53YtSBYKXB0PTHSfuLU0yK1tiaLqt46ZWDUZ+wQNZ1VGqBl6WZREKBREKBWEYhi1zc+r0WYgeDmBY9HRF8eroGACgv7+/aVNiZ1YVGQLP4bbr173mAsyXv/xlfPvb38ZTTz1VF2AAXLYZuBMnTmBgYABerxfbt2/HF7/4RSxatOiyrGWqmJeZjKIobXeKIyMjCIVCtlIyUGvwX3vttViwwBLim43+CxGKPHv2LNavX4+urtn1JCeyGIQaTdO0HXCmq8PkBhIcZ5uifLEwTRO/PnwaLxw40fKzNnQNZ8+dRzAYQk93FxiGbsn4UlUNhqYgPZmDJFnBAwwHn88PnuddS2fTcdwEgIDgRUGqtJTJd0JRVWSSCfh8PgSrNs/twLFs1cW4tS9M3doFLwATxTZZD4FpWrpnuVJ7qrVpWhk3dBUTyRQMw4Qo1tSj3UozXp7Dm65bh5ULezuu41LANE1bcWPr1q0zDjBf/epX8fd///d48sknL3lJrBUeffRRFItFrFq1CuPj4/jLv/xLXLhwAQcPHpzXcjZXZJA5ePAgPB4PVq5cCcMwcOzYMYyNjdXphM1GgNF1HYcOHUIul6sTipwrEGYLCTi6rtssta6urmlRoy8FRXk2cOp8Aj99cX9TuUoqlZFKpxAKh22qejs5FaefDBkA1TUZ2VwBFEXbigNerxdUlY3lLHt1ctx0TukDtRKXGzNLURTk0ilQHI9YrAtenrMILa1KclVhzYqitvSFcYIMURqGOSX7akJqaOdASmAYJhLxCbAMg2gsinyhiFKpDFmuqUdbjD8rcK9dtgC3X7+u7etfKpimiUOHDiGfz2PLli0zItqYpomvf/3r+NKXvoTHHnsM11133RysdHaQzWaxePFi/P3f/z0+/OEPX+7ltMQVGWSOHDkCiqKwfPly7Nu3D5VKBUNDQ7Pa4JdlGfv27QMAbNq06ZKnx0TenDDVKpWK7VzZ3d3dkYZ59OhRpFKpOacozwZS2QIe+sUwctWhxlwuj3Ihh0A4Cr+/vpFMPFOcSs7tJt05hkFZKiOby1sSLTDhE30Ih4JgOL6pR+KmEt3Kw8WNTVapyJhMJeARfYhEog220e5WB43MtnYaaUCzBlu74NHIVONY1qKMu2Rtuq4jm0lB0Uz09fWCqZblyhW5qh5tydxIkqXc0NsVwYfuej16e7ovu8KFaZo4fPgwstkstm7dOuMA88///M/43Oc+h0cffRQ7duyYg5XOLrZt24Zbb70VX/ziFy/3UlpiXgaZThbMx48fhyRJyOfzEAQBmzZtmtUGP2mSh8NhrFmz5rIPV5qmac/hJBIJFItFRCIRO+A4aciXi6J8sZBkBT9+fgQHjr0KuVxEKBpry8DzeWtS/QFfexkY8oAvSTJkuQLoGhLpSWiaBkEQ7CyHfM6NlOh2jp5O+RVJkpBMJBCNRuFvEdgbG+ait7U/jLtRmHvm4hY8KIoC60JqoCgagqc+4Om6jslUEpoJ9Pb2Nlk9Nwb1ilTBjWsWgFIlaJpmz4bNhaFYJzgDzJYtW2b0nTdNE9/5znfw2c9+Fo888ghe//rXz8FKZxfFYhGLFi3C5z73OfzP//k/L/dyWuKKDDIHDhzA2NgYFi1ahNWrV9sNfpK9ADMPMKlUCgcOHJgXTfJWkCTJDjhOSYxwOIxjx46B4zhs2LDhkt/sFwPTNHH4yBE8+esDKFPClDJHi01GoSR1NhQDrAe8oRu23L+iqCiVSiiXS5DlmuqxKPoQ8vug6joEjzu92QmKomDqKl4dPYtFCwbA8u0fcoTl5WYZ3fQeORamCSia1lSya15HffBoZxntzAh13UA8PgGe49HV3eX6nW8MvNetWYYbN17jqnwcDoftgDPXKuSmaeLIkSPIZDLYunXrjAPMf/7nf+KTn/wkHnrooVnzqpptfOpTn8Ldd9+NxYsXY2xsDH/xF3+BkZERHD58uO3M4OXGFRdkzp07h8OHD8Pv9+N1r3sdgPr+C/GEmQnOnTtny//39/fPeP2XEoqiIJFIYHx8HNlsFizLYsGCBejt7UUgEJiXQbIRhA1EaunHz6fw9J7DHfXDaIoGzzGgKGpKzpUcw8LDM67Nck3Tq4OLNVpvVyQMQfTBpOi24ppkAHfl0sXQMLXyrJfjwLBTC5DE/EtWtbYBCagFD8MwpiQK6mEZnHh1FOGgH4FQpO3xRGAzGvDhPW+6wXWqn1D1k8kkMpkMRFG0+4qzzZw0TRNHjx5FOp2+qADzwx/+EB//+Mfxox/9CHfcccesrW+2cc899+C5555DOp1Gd3c3brzxRvz1X/81li9ffrmX1hbzMsi4WTCTL9TY2BgGBwdRKBSwbdu2WWOQHTt2DBMTE9i0aRPC4fAsvZNLA0JRXrBgAfx+v+0ayHGczVSzrHznX8AhJmmapmHz5s12BnM+kcGPnx9pGTwa+zDtdu3WH1TLXrLi6mXjhGEYkCsVlMtlFIpFCDwHmvM0ybMAQD6fRzqdxsIFg2A5vmqP3L6nSNZbUdS6OZaWS6++V4qmWk79O8GyjCUzI7V3/lRVDePjY+iOhBAIRzsGMMAKNO+65Tp0hTv3+YioLPk+ArADTjQavahBQmeAcSqqTxcPPPAAPvKRj+AHP/gB7rrrrhmv5ypa44oIMpqmYWRkxJ7czeVyGB0dxQ033HDRAUbTNHsqePPmzZdlEv9iQCjKjRbPRNqcMNUA2MOfsVjssjdqASsL27t3LziOswdnncgVJTz0i71IZQtNf9vYmzBNy5mylRZXY3Pd8rJhbAMuJ+qNvCzlaBgaEqlJmKZhy+yrqlr1tO9DKBCwqccejoVhouWAp5PZ5hzcbAWnLlrHYIpaD8nDczB0E6revA5VVTE2No5wyI9QOAaGplrK3Dhx09BqDK1a0vYYN5imiWw2a2c5lUoF0WjULqtNJwshm8JkMomtW7fO+J595JFH8KEPfQj/8R//gbe+9a0zOsdVdMa8DzLlchl79+6F1+vFxo0bwXEcEokEjh8/jhtuuMG+UWcSYCRJwsjICHievyJ7GKOjozh9+jQ2bNjQdn6H3OCkj0NEPImXxuWQpiCfaygUwtq1a1sGPUXV8LNfHcDJ83H7Zx6OazlLInh5KEq9Fpfo4V1lUKwHPN9UPmvVXBc9PHKFIgrFIvL5AnTdskvu644BDFt3HRmahqcFm6yRHdZoyOaEm+dLu0ysce1uzp+KomJ8fAx+nx8D/b11w6XtZoAW9cbw9pu3zkpGXCqV7ICTy+UQCASmJLVvmiaOHz+ORCJxUQHmZz/7Gd73vvfhX//1X/Hud7/7Yt7KVXTAvAwyxII5k8lgeHgYAwMDWLVqFWiath+YL7/8Mvr6+ma8M8/lchgZGUFPT4997isFZDYokUhg8+bNU7Y8AGqifyTglMvlOmr0paBqFwoF7N27F729vbYyQ6c1v3jgJH516BQoigLHMG3l751Mq07SK40PeA/PQamagLmBZxkkkylk83lLZZsGkulsdY7EU7VL9oHjrDmSoCgg52BmtQpggKVDVpHrbaNbeb40SsYA7YMvYbWRDCYQCGDxggHXrMgtW/LyHN6383UIiLPPVlQUBalUCslkEul02vZq6u7urhtINk0TJ06cwMTEBLZu3WqPLEwXTz31FO655x5885vfxHvf+955WUZ+LWHeBpnR0VEcOXIEq1atsmUTnBIxJPVOJBLQNK2uFNSJchyPx3Ho0CEsX74cixYtuqK+ZLquY//+/bNW3iPU6GQyiXw+P+cinqR/tGTJkmkbvB07O4Hn9x2352nagTCtALPlgKUTPq8HFVUFS9MtZWNM00QymYQsy1i2ZDFMioJh1GwjrDmSEsplCSzL2IOLXdEwSlKlpTK0EzxnTf7LqtY2IBH4BY+ViVEUPCzbVi2AoymcePU0gsEgBvt6IbXxy2mcAbpzx0asXjz3ZBhd1+uk9gk9uqury54bu5gA89xzz+Gd73wn/s//+T/40Ic+dEXd+1cq5mWQOX36NI4cOYJNmzbZk+rOAOMsjzmHFuPxOBRFaVkKIlPwo6OjWL9+/bym/blBlmWMjIyAYRi7dDibcBPxJAHH5/Nd9A0Zj8dx8ODBpv7RtM6RyePhXwx3pBUDlgwMRVPINUj1t0JQFFBRVNcsyTRNxOMJqKpiGXYxNEJ+EVmXcxuGCUkq19klx8IheAXRdQC0ETRNwy94kCtKHdlhJBMzDLOtjpksyxgfH0dvdwyhUASGaXZs9JO+1dKBLuzcvqH9QuYAzqz7woULUBQFwWAQfX196O7unnageeGFF/C2t70Nf/u3f4uPfvSjVwPMJcK8DDKVKrOHcOxbBZhGOP1c4vE4JElCNBpFb28vYrEYTpw4gUwmc0VMwTeCqEuHw+G2PYzZgqqqdsBJp9Pwer12wAkGg9O+Qc+dO4cTJ07MSnAvSTJ+/PwwxlLZlscIPG97zvsIC63NV91qvstgmGaTMMMwMTExAcMw0N/fB4ZhbFOxTo6bpmn1/kxdRTaXh2noYHmPrRztlnVb8zNWNjEVx02f1wMDJuSGUhtBpWIFmEgkjFAohJBPgKzqU9JIC/oE/I87dsDbxsFzLmGaJk6dOoULFy5g/fr1di9nuvTol19+Gbt27cIXvvAFfPzjH78aYC4h5mWQIRbMZIJ/phIxpBQ0MTGBYrEIhmGwbNkyDAwMXDYV1ZlgcnLSto9evnz5Jb9BdF23a+bJZBIMw9jlyU4ink6B0c2bN88aPVzTdTz5yhEcevV80+8aXSuB2oyHpjXv3jmGhW4adbNZpIdhBZhxUBSFvr4+a2alQaqlneMmUOvDmCagqSoMzbKcVhQyAGopDnAc12SI1imIOXtOfLUX5Sz3VSoVjI9PIBqNIBQK2eW1qWikAcA73rgNi3ovn+7dqVOncP78eWzZsqVOO7AdPbqxZD48PIy77roLf/qnf4o//MM/vBpgLjHmbZBRFGVWJvhLpRKGh4chiiIikYjdewiHw/bOfD5Lr0xMTODQoUNYtWqVrS59OeEU8UwkEjAMo2U/jExjp1IpDA0NzbrAqGmaGDl+Fs8MH7Ub9dZDWnC1TWYZBhxLN7lOCh7elbrr5VmceHUULMOit7cXNE2BpmgwDN1ET27luOnWuCcDk5O5Akplp68Lj55YGGA48LzHLpW1CpBumm1OjTRJqmBiYhzRaAyhULApmJJ1tCo9Dq1agpuGVrv+7lKAbE62bt3a9rtjGAZyuVwdPfrQoUNQVRUbNmzAb/3Wb+FTn/oUPvOZz1wNMJcB8zLIaJpmSY5XMdPSkHNIccWKFfYXrFKp2A/JbDaLYDCInp4e9Pb2zps5GdM0cebMGbz66qvztn9kmiZyuZx9LWVZtvthkUgEx44dQ6lUmvP5o9HxFH7yy32QVXVKcyTOY1o1161BxXEEAz5EozEY1ay6VQAD6s3Kqj+Ah2VaEgl8Xg8kRYFhmNB1A7qqWEKe5RJomq6W1HwQBC84lm0KkO2IAQwMnHh1FF1d3QgGrdJwq2DqXAdBLBTAe2+/Aexl0u0jCuKdAowbSqUSvve97+Ff//VfcfjwYfT39+NjH/sYdu3ahfXr11/WQPOlL30Jn/3sZ/G//tf/wte+9rXLto5LiXkZZD7wgQ/g1KlT2L17N97ylrdgcHBw2l+M8+fP49ixYx2bzESWJZFIIJPJ2M3u3t7eOdddagUybBaPx6dNUb5ccPbDiIgny7JYunQp+vv7Z6SKOx1M5kt49MX9iE/mO07bmyYQ8nuh6YYr88yaIxmHKIqW4CPLgGVocCzTke3lpEQ7hyhbwcPVbABI1kMGQAlxwPJ1sajRPbEIyrLSZFXgRLlcRjwex6JBS0fNhNmRqeZcB03T+M3bbkBP5PJ870iA2bJly4x7p8eOHcPOnTvx7ne/G5s3b8aPf/xjPPbYY/jgBz+Ir3/967O84qnh5Zdfxrve9S4Eg0HcfPPNV4PM5cT58+fxox/9CPfffz9eeOEFbN26Fbt27cKuXbuwePHitgGHcOnHxsawYcMG219mKmhsdguCYAecS2GRDFj9jwMHDqBcLl+RCgSyLNtT/LFYDKlUyhbxJOXJmdJPO6GiqHj0hf04PZ7seCxD0xA9HEqVeol8WVYwPm7NkUSjNal+D2dZO7djcDkR8gsolCt12UEr0DSNoOhF1oWabZrWNSW6aoqiIhYJwiuIYDkPWLY+0yiVrADT02MNNXp4DgxFuQ6juq3Dy3PYsnoJtl27tOPxc4HR0VGMjo5eVIA5deoU7rjjDtxzzz34yle+YldCKpUKstks+vr6ZnPJU0KxWMTQ0BD+8R//EX/1V3+FTZs2XQ0y8wGmaWJ8fBwPPPAA7r//fjz33HPYsGGDHXCcJTCg9oAulUrYtGnTRWUimqbZFsmpVAo8z6O3t3fG7KqpQFEUDA8PzxlFea5BGHCRSARr1qyxb25Zlu3gnclkrB15NeDMdvA2DAPP7z+BV46cbnmMs7nubJaTJnk4HEYkEq77Gw/PoSKrTV42biD+M0RAspPjJlEkaLQBcIOiqKAMFflCEfliyWEkJlaz8mT1ula/+xQFocoMm4qI6ILuCN5+89bLYm9BysNbtmyZcfY+OjqKnTt34u6778a99947b4asP/CBDyAajeKrX/0qbrrppqtBZj7CNE2kUik74Dz11FNYvXq1HXC8Xi8+9rGP4Y/+6I9w0003zeoDutEimWEYO8OZLeFJQlAIBoNYt27dvLk5popcLmerM6xcubLlNVFV1WaqkeBNiAOzKeJ5ZHQMP//1oSlJr9A0DUNVcfrsWbtJ3u74diKYpmnCJ3htOZlOjpuNcv+dSmxOuX+aolAulzCZzUOSyjBNwOfzIRwOwePx2ooD+Wpjv1O/iudYvO+O1yHkv/TZ89mzZ3Hq1KmLCjDnz5/H7bffjttuuw3f+MY35s099P/+3//DX//1X+Pll1+G1+u9GmSuBJimicnJSTz88MO477778Nhjj8Hr9WLDhg34m7/5GwwNDc3ZF8wwDFt4MpFIgKIodHd3o7e3tyOdtxWy2SxGRkYwODjYlJ1dCUin09i3bx+WL1+OxYsXT/nvGkU8ybXs6elBNBq96M9wPJXFw8+P1DXq3dhepVIJ8XgCSxctABi27vqT+ZnGj6SVCGYrAzU3x81Wjp6ttMloigZN10vkUBQNVZZw9vwYwuEQNE1DuVwGQCEWCYFmOQiCCJqmOoqI3nHDeqxZOrMh2YsBCTBDQ0MIhUIzOsf4+DjuuOMO/MZv/Ab+5V/+5bIbDRKcO3cOW7duxeOPP44NG6yB1qtB5grDgw8+iPe973246667UKlU8POf/xz9/f3YtWsXdu/ejc2bN89pwCHCk/F4HKZpTlvpmEjcrFy5EgsXLpyTdc4lCMX6Yj14nNfSKSdCruVMRTwL5Qoe/sUw4pkcKFhKw84hxEKhgFQqZasaOOdSGIYBXGyXCRpFML08h0obqZbGmZd2mUWjSnQrZls+b61/xbLF0E3KNvBTZAVSuYRcoQjD0CEIom3I5vd5m0REr1nUhzfv2HjJNzjnzp3DyZMnLyrAxONx7Ny5E1u3bsV3v/vdeRNgAOv59Na3vrVuTbqu275XsizPq/XOBa7oILNv3z7ceOON+Pd//3dbqrtYLOKnP/0p7rvvPjz66KOIRqN4y1vegt27d2Pbtm1z9oESOm88HreVjknA6erqcn3dM2fO4NSpU/OWotwJZ8+excmTJzuqQE8XRCqI9HGIcsNMRTxVTcfjvz6I88nJulJULpdDJpNBb28fRLFWIvLynDXcyLmrKDciKArIlyTwHNtWuBOoDW7SNNWkrtwIp0q0Wxktl8sjk0mjr68fguC1ynSSDMM0HFYFVq+POIAqigKv14tQMIiA3w8DliLC+3fugOC5tAPK58+fx/HjxzE0NDTjId1UKoU777wTa9aswfe///3LoijeDoVCAWfOnKn72Yc+9CGsXr0an/70p7Fu3brLtLJLhys6yADWTqhVBlAul/HYY4/hvvvuw09+8hP4fD7cfffd2L17N7Zv3z5nX0iiuUQCTqVSsXfl3d3dYBgGx48ft03SZrqDu1wwTRMnT57EhQsXsHnz5jlfP1FuSCQSKBQKMxqkNQwDrxwdxS/3n4BhmMhmJ5HNWl4wbucIigIUXetoKEYQCfgwWShN6ViOYeDxcB3pzQChWwtVxYDarWoFyMmm9Xt4DnwbqrWqalWmWhlypYKgX8TtN6zH5jUrLxmDEqgFmM2bNyMSiczoHJlMBm9+85uxbNky/OAHP7hiVDyulsteo6hUKnjiiSdw//3346GHHgLLsrj77rvx1re+FTfeeOOcMblM06zW/K2AUyqV7Ne6UmZgnDAMw/ZUHxoauuSzRI2DtIFAwA7eUxnaO3U+ge898hQyk7nq/E7zg8nL86goypQMxQCLCFAsyxC99crFrRAQBRSlypTODVjZD01T9sBkNpvF5GQW/f398Hrr54841lJxZhi6I5tM1w0s6Qnimt5AncQ+IWHMVZn5woULOHbs2EUFmGw2i7vvvht9fX24//7753wOazZxNcj8N4Cqqnj66adx33334cEHH4Su63jzm9+M3bt346abbpqzL6yiKNizZw80TQPHcSgWi4hEIvaufL7fKMRmoFKpYPPmzZddjof4kDjnmshD0o1mTmRuTp8bw9kiICnNpa1Gv5pO0iuNUi0cy4KmqJbik052WDuzMgIns83DcUil00hnMi0HXJ1T/Z3YZNGgD++9fQc4lrFJGESahcgFES2w2cr6x8bGcPToUWzatGlaM2xO5PN57N69G8FgEA8//PBl/x5eRXv8twwyTmiahueffx4//OEP8eCDD6JUKuHNb34zdu3ahVtuuWXWhiGJE2QwGMTatWvBMAwkSbJ35blcDqFQCL29veju7p53Q5iqqmJkZAQAsGnTpnk3w0MEE8lcE6GZk105ABw8eBCFQgFbtmyBSdH4yS/34Ww8XXeeVg9mN+kVwF2qxRKf9DQ16RvpynXnltUmBWWnkrRpApOTGRQLRSxdsgi6y13baDENVCnRLmwymqJwz5tuQF+sudRJ+osk4JCeGAk6M90MjY+P2xYeMw0wxWIRb3vb28DzPB555JE5G+y9itnDf/sg44Su63jxxRfxox/9CA888AAmJydxxx13YNeuXbjttttmXBoiFOV2MySyLNsBZ3Jy0i4D9fb2XvYbqVKpYO/evRBFEevXr5/3bBgnzTyZTMI0TdA0DZqmsWXLFjuAG4aBZ4ePYfi41Zj1Cx4Uys10ZQKn9ApQP4PSCJKlEKn+VnRlAp6zMgUyuElRFFjGUpI2Tav/UCgUMDDQD57nmwY3SYnPDYKHh6LWs8l2bFiJG9Yub3cZbRB5/UQigXw+b6s3dHd3T/meIAFm48aNtkfUdFEul/GOd7wDhmHgpz/96awLrl7F3OBqkGkBwzDw8ssv2wFnfHwct912G3bt2oWdO3dOWfIikUjg4MGD06IoK4pSJ29DJuSJntqlpJkWi0UMDw8jFoth9erV82bAbapQVRV79uyBUu2xqKpq2013dXWB4zjsP3kOv9x/HLKq18n9u4FIr5im0aTm7Aaf14OyrEyp/+Ic3CRsMtO05pBKpSL6+wfAO3xdSNZFgQLHdrakpmkKsqJioCuMd91y3Yw+S6LeQDxdSImynafLxMQEDh8+fFEBplKp4N3vfjeKxSIee+yxK66X+d8ZV4PMFGAYBkZGRuyAMzo6iltuuQW7du3Cm9/85pY3F6H4rlu3Dj09PTN6bTIhT8pAXq/XlrcJBAJzGnBIBrZgwYLL4mNzsSAyPRzHYePGjaBpuk7Es1Qq2dRoBSx+/uvDU9L4YmgKfsHr6orpBp+Xh6YbLdWYGxEJiEjnSqAoCqlUCuVyGQMD/a4lSoHnwXI0CqXOBAKKohD0CXjbTVsQCVw8YcPp6ZJMJkHTdNMwLXFD3bhx44xp7rIs473vfS+SySR+/vOfz5gscBWXB1eDzDRhmiYOHTpkC3gePXoUN998M3bv3o03v/nNiMViMAwD//Zv/4YVK1bMKsWXmIfF43FbkoX0HTo5A04XyWQSBw4cwIoVK7Bo0aJZO++lAinx+Xw+rF+/3nXXXi6X7YCTz+fBegSMnMlANtCy5+TUPZuKyjJMwOvhoGo6eI7tyPgiumdeD4/RM+cgVST09w+A49wb76LXA0XVwLp42bjhTdetw/rls+9LRHyGSMBRVRV+vx/5fB5r166d8aCuqqp4//vfjzNnzuDJJ5+ccSZ0FZcPV4PMRcA0TRw/fhz33Xcf7rvvPuzfvx87duyAJEm4cOECnn/+efT29s7JaxM2UDwer9NTI14uFxNwxsbGcOTIEaxdu/ayKNZeLAjJIhKJ4Nprr51SWYiUgS6Mj+PJV44iWZCrjpU+8Dxv92kaiQGCpz1tuVH3LCB6W1oqE92zkiQjmUzA1DX09vYBLdbP0jRMALphTIluvWywB7t+Y/OcZ6TEC+nEiRPwer2QZRmRSMTOcqbKBtM0Db/1W7+Fo0eP4umnn74iB5av4mqQmTWYpolXXnkF73znO1EsFqGqKjZu3Ii3vOUt2LVrFwYGBubs5ia7SBJwTNO0A850NcBGR0fx6quvXlT9/HKiWCxiz5496OvrwzXXXDOja64oCh5/cQTP7j2CcrkMlmUs4clQECzHN03pWxIwdJOkTCuTML9QzYAalkb0zRKJBBRFQX//AAQP7+q46UYkaEe3Fj083n/n6yB6554mn0wmsX//fqxfvx49PT2QJMnuMWazWduzicw2uX1Guq7jox/9KIaHh/H0009fkZudq7BwNcjMEk6fPo3bb78dGzZswL//+78jlUrhvvvuw/33348XX3wR27Zts+VtFi1aNGcBh4iHkjKQrust7ZEb/+7EiRMYHx+/IodEgZoS9MKFC7Fs2bKLvsbHz07g0Rf3I18ooFgqQVdkKJoBn88yEBMEwX4Ni7bMoyRZD/1WdGWCRsaXh+NQURTE45Yk0cBAv/1ZuWUp7Up1bpTo3a8fwrLBmfUFpwMSYNatW+eaxZPZJqLC7fF4bOIAGQDVdR2f+MQn8Mtf/hLPPPNMW9PBq5j/uBpkZgljY2P49re/jT/5kz+pyxxM08TY2JhtUfCLX/wCGzZswO7du7Fr1645bagTDTCiNqAoii1v09XVZQ/YGYaBw4cPI5vNYmho6LJTpmcCYrW9bNmyaSlBd0JiMo+HnhsGAORLZVQqFZRKloGY07FSFMVqY92LXLGMgE9sadNMYDO+VA08Q+PMuQvQdQ39/f1NmwHn4CbPsR11z5yU6PXLF+JN1629yCvRGalUCvv27WsZYBrRqML9hS98wd4I7du3D88+++ysfpbTwTe+8Q184xvfwOjoKABg7dq1+PM//3Ps3LnzsqznSsbVIHMJYZomEokEHnzwQdx///14+umnsXr1ajvgrF69ek4DTrFYtAOOJEmIxWLo6urCxMQENE3D5s2b573qgBsISWHVqlVzsustSRU88st9uJCctH9GHCtJwNE0DaIowOfzYaCnG8WK3NEGGqgyvkQPjp48DV03qgGmdXlT9HpgGgakNmrPBDRNoyccwDveuM0OOnOFVCqF/fv3Y82aNTMqbZmmiccffxz33nsvXnrpJei6jttvvx27du3CW97yllkVYJ0KfvzjH4NhGKxcuRKmaeK73/0uvvKVr2B4eBhr1859wH4t4WqQuUwgZa2HHnoI9913H5544gksW7bMtihYu3btnM6kFItFjI+P4+zZszAMA9Fo1KZGXylCg0DNamCqu+eZQtcNPLXnCA6cOuf6e6J0LEsSpIqMgF+E6POB93jbSrIIPIdTo2cg8ByCkWjHQdeA6LWp0J0cN2mKwrtvvR79XeH2b+4iQfyEZhpgACub/tM//VP88Ic/xNNPPw1N0/DQQw/hwQcfxEc+8hF8+MMfnuVVTx/RaBRf+cpX5sVariRcDTLzBLlcDj/+8Y9tE7bBwUE74GzatGnWA44kSdi7dy/8fj+WL19uz+Lk83mEw2Fb3mY+60IRJd/ZthpoBdM0MXLiLJ7dexSG221TpSsXShLK5RIkqQxdVWFSjIOpVk+Nnhgfh2Ga6OvrQ0AULMdNuN+STiJBJ8dNALhh7XLs2LBy5m94CshkMhgZGcG11147Y5qyaZr4/Oc/j+9+97t45plnsHr16qbfX84ZLV3X8cMf/hAf+MAHMDw8jDVr1ly2tVyJuBpk5iEKhUKdJ05XV5etGL1t27aLDjiFQgHDw8Po7u5uKtERleN4PI5cLodgMGhnOPNJT210dBSnT5/Gpk2bLvlw3pmJNH7yy5EmNpmbdpiu66B0DROpDCoVCRzHwefzwev1olwsQNEM9PX1gaatz8DDczB0E6pen6XQNAWGZpqdOF0cNwGgLxbCu2+5vm3p7WJBAszq1asxMDAwo3OYpokvfelL+OY3v4mnn356XvmrHDhwANu3b0elUoHf78f3v/993HnnnZd7WVccrgaZeY5yuYyf/exntieO3++3WWrbt2+fto7Y5OQkRkZGsHjxYixdurTtDpHMjsTjcUxOTsLv99sB51JL/BOYpolTp07h/PnzGBoaumwsuMlCCQ89N4xMvgigNV2ZwC94kS+WUZbKKBZLMFQZFVVHIBCA3++D1yvYszgMTTcNbrZTVG503GQZBv/jju2IBudO22tychLDw8MXHWC++tWv4qtf/SqefPJJbNq0aXYXeZFQFAVnz55FLpfDj370I3zrW9/Cs88+ezWTmSauBpkrCJVKBY8//rjticPzvJ3hvO51r+uojEx01K655hosWDC9qW9VVe2A49RT6+npuWRmV6Zp4tixY0gkEhgaGrrsAomyquGnL+zDmfE0aLo1XZlA8PAoyzLi4+MARSMQCKBcLqNUsszORNFnU6NpmrJpyr7qXE27S0wcNzVdxxu3rsGmlXOn0kACzMUQLUzTxNe//nV8+ctfxmOPPYZt27bN8ipnH7feeiuWL1+Of/qnf7rcS7micDXIXKFQFKXOE8cwDNx11122J05j8570Ly5GR41A07Q6eRuv12sHHDcfl9mAk2btVFK+3DAMAy8ePIWXDp3qeKyu60gk4vAJXgRCNVUG00QDNVq3qdF9XVFISr2CciuwDIMl/V24+8ZNcxb0s9ks9u7dO6ONCoFpmvjnf/5n/OVf/iUeffRRbN++fZZXOTd44xvfiEWLFuE73/nO5V7KFYWrQeY1AE3T8Itf/ML2xJEkyfbEufnmm/H5z38emqbhT/7kT2a9f6HrOtLptB1wWJat83GZjYedYRjYv38/JEnC0NDQvKRZHxkdw89/fQh6i2xG03SMj48hEvDDH47A5/W4yv6bJqAoFjW6WCyBoQyIggjeK8ArCG3Lo4KHx/vu2AG/ODdkjWw2i+HhYaxYsWLKiuKNME0T3/nOd/DZz34WjzzyCF7/+tfP8ipnB5/97Gexc+dOLFq0CIVCAd///vftrOtNb3rT5V7eFYWrQeY1Bl3X8cILL9iK0cViEaZp4jOf+Qw+/OEPz+mgpWEYtnFYMpkERVF1emozISzouo6RkRFomoahoaF5Z5bmxHg6i4d/MdI0hKlpGsbGxhEO+hEIhav+MkDIJyDn0rQnCPi8SE8WUC6XIFcqUGQZNMvZTLVG0cy7b9yMlQvnhsady+Wwd+/eiw4w//Ef/4FPfepTePjhh3HzzTfP8ipnDx/+8Ifx5JNPYnx8HKFQCBs2bMCnP/3pqwFmBpjXQeb//t//i6985SuYmJjAxo0b8Q//8A+47rrrLveyrgjIsoz3ve99eOmll3DHHXfgiSeeQDwex5ve9Cbs3r0bd9xxx5Q9cWYCoqdG5G1M06yTt5lKwFFVFcPDw6BpGps2bZo1C+C5RLFcwY+fH8F4OgsAUFUN4+Nj8Ik+9Pb2uLpiutGWPRwHRdPqBjp1XYehqkhmJlGpSOB53g44m65Zgju2b5iT90QCzPLly2esyG2aJv7rv/4Ln/jEJ3Dffffh9ttvn+VVXsV8xbwNMj/4wQ/w/ve/H9/85jdx/fXX42tf+xp++MMf4tixYxfdU/jvgA996EM4fPgwHnnkEXR3d8MwDAwPD9sWBWfPnsWtt96KXbt24c4775x1qwAnTNNENpu1A46maejq6kJvb29LPTVZlrF37154vV5s2LBh3rtxOqHpOh7/9SHsP3EGY2PjEEUBSxYuaOmK6UZb9vAcZJepfpIBZfJFSFIZpVIZ0FXs3LoSCwYH2pqHzQT5fB579uy5aLme+++/Hx/96Efxgx/8AHfdddesrO0qrgzM2yBz/fXXY9u2bfj6178OwNoZL1y4EJ/4xCfwmc985jKvbv7j9OnTtsptI0zTxMGDB+2Ac/z48TpPnGg0Oud6amQWR5ZlO+AQPTUyKBoMBudc+WCuUCwW8f9+/DhOp8tYvGCwoyumk7bcztaZwCd4UZZkgALe9oYtEBjDLlMyDGNnjTMtUwK1ALN06VIsWbJkRucAgEceeQQf+tCH8B//8R9461vfOuPzXMWViXkZZBRFgSiK+NGPfoTdu3fbP//ABz6AbDaLhx566PIt7jUGQgsmnjgHDhzA61//euzatQt33303enp65lxPjQQcSZIQCoVQLBbR3d2NNWvWXHFunEDNbmBgYACUEMTPXzrYNLjZCqGAiGy+3JauTODhOWxcsRA3brzG/lljmdIwjCmpcDeiUChgz549WLJkyUUFmJ/97Gd43/veh3/7t3/Du971rhmf5yquXMzLIDM2NobBwUG88MILdfTG/+//+//w7LPP4qWXXrqMq3vtggw6EouCPXv2YMeOHbZI4Vx64gDWHM+BAwfAsixUVbWtka8kPTXycHbaDWTyRTz03DAmC6W2f0tTNGiagtfDoVhq9ptpRHc4iN+87YaWU/2maSKXy9leLpVKBV1dXba0fisSBXkPZGB3pnjyySfxnve8B//0T/+E3/zN37wiNwxXcfG4GmSuwhWmaeLs2bN2wPnVr36Fbdu2YdeuXdi1a9ese+IQeuySJUuwdOlSSJJkK0YTPTUScOarnlo+n8fevXtdH86SrOCnL+zHmYmU6986bZ0BQPDyUNrMxzAMg/fedgO6wlMjb5imiVKpZGc4xWIRkUjENg8j17RYLOKVV17BokWLsGzZsqm+9SY899xzeOc734l7770XH/zgB68GmP/GmJdB5mq5bH6BeOLcf//9uP/++/H8889j48aNtkXBxRqEERXflStXutJjiZ4acVYMBoN2wJkv3jeEgdWuf2EYBp4bOY69x0abfucXPChK9cQAjmVBUe5qyzcNrcbQKvfXmQokSbKvKdGoC4VCGB8fx8KFC7F8+fIZn/uFF17A2972Nvzd3/0dfvu3f/tqgPlvjnkZZACr8X/dddfhH/7hHwBYN+iiRYvw8Y9//Grj/zLCNE3E43HbE+eZZ57BtddeawecVatWTeuhQkpka9asmZKKr6Io9sMxk8nYVr5E3uZygGRhU6X4Hnz1PJ54+TCMapbCMSx007D/7QRF0RA8HMoOZtqi3hjefvPWWXt4K4qC8+fP49VXX4VpmnWSQYFAYFqv8+tf/xq7d+/GX/3VX+H3fu/3rgaYq5i/QeYHP/gBPvCBD+Cf/umfcN111+FrX/sa/uu//gtHjx6dU9+Qq5g6TNNEJpOp88RZsWKFbVGwZs2atsymsbExHD16dMZSN0RPLZFIIJ1OQxAE9PT0oLe395LpqREl4unKrIwlJ/HwL4ZRlpWO4prEFTNfkuDlebz/ztchMItT/aVSCa+88goGBwexePFie6A2lUqB47gpKzjs3bsXd999N/7sz/4Mf/AHf3A1wFwFgHkcZADg61//uj2MuWnTJtx77724/vrrL/eyrsIFpMlMPHF+/vOfY8GCBXbA2bhxY13AOXXqFM6cOYNNmzYhGo1e9OsTPTXycOR53g44c6WnRsp8MxWKzJckPP7rQy37NI3wCR68ftNqXLtkZr4tbiiVStizZw/6+/uxYsWKuuvUaI8MwO7hNA7U7t+/H29+85vxR3/0R/j0pz99NcBchY15HWSu4spFoVDAT37yE9x333342c9+hq6uLrzlLW/Brl278MADD+Dll1/GAw88gFAoNOuvTfTUnHMjTnmb2XgAErvhizHrAgBV0/HYSwdw/OxEx2NXL+7HnTs2zvi1GlEul/HKK6+gr68PK1eubHtdDMNANpu1M0dVVXHgwAH4/X6sW7cO73rXu/Dxj38cf/7nf37ZAswXv/hF3H///Th69CgEQcCOHTvw5S9/GatWrbos67kKC1eDTAc899xz+MpXvoI9e/ZgfHwcDzzwQB0Z4So6o1Qq2Z44Dz74IFiWxTve8Q685z3vwQ033DCn0/yGYdi78UQiAYqi0N3djd7e3hkPKhLLhIuxG3bCNE28dPhVvLD/RMtj/KIX77tjBwTP7FC5y+Uy9uzZg56eHlxzzTXTCgymaaJQKODrX/86vve97+HChQtYunQpPv3pT2PXrl3o7u6elTVOF3fccQfuuecebNu2DZqm4Y//+I9x8OBBHD58+LL5H13F1SDTEY8++ih++ctfYsuWLXjb2952NcjMELqu43d+53fw2GOP4Y//+I/x4osv4uGHH4bH48Hdd9+N3bt3T8kT52JAduNk+JMMKvb29iIajU4p2MXjcRw8eBDr16+fdXmjE+fi+NmvDjS5XwLA22/ehsV9sVl5HUmS8Morr8wowDhx8uRJ7Ny5Ezt37sSKFSvwwAMPYM+ePfiDP/gDfOUrX5mVtV4Mkskkenp68Oyzz85btef/DrgaZKYBiqKuBpkZ4lvf+hb+9//+33j88cftBrmiKHjqqafsDAeA7Ynzhje8YU4HMEkPicziqKpaJ2/jFnDGx8dx5MgRrF+/fs5268lsAQ89txf5Uk1WZmjVEtw0tLrNX00dJMB0///bu/+YKAs/DuDv8weeItwBAmlpmcNfEIJgSivbKYqCwGEt5yjN2WwWLuec5R+ZrTldbeSWfYtsaiuZNT08GZJO4HCgWBxo6NLERJEhoPHDQ7g7nuf5/uF4FjNL7u7hOY73a/MPn83jc2ze+54fn88nNLTfTwL+XV1dHZYsWQKj0Yjdu3fLZ4QNDQ1obW31ijXKtbW1iIiIQE1NjVfUM1QxZPqBIeM6QRDQ0dHxyH02PT09OH36tLwTp7u7G8uWLUN6ejoWLFigaANm7+Wf3jOc3s74sLAwjBs3DiNHjpSfhJs1axZCQjxzRvEo97vtyC+7gIaWvxCiC0Bm0jyM8MAlxe7ublRWViIkJATTp093OWDq6+uRlJSEJUuW4H//+59XzpYTRRFpaWloa2tDWVmZ2uUMaQyZfmDIDAxBEFBeXo7Dhw/j6NGjaG9vl781L1q0SNEGzN7O+N4znM7OTowZMwb3799HdHT0gE0AFwQRpdWXETXlKYQFBbr9er0BExwcjBkzZrgcMI2NjUhKSsL8+fOxd+9er52OvX79ehQWFqKsrMzlDZ7kGQyZfmDIDDxRFHHu3Dl5CVtzczMWL14Mo9GIpKQkRXfiAA8eta6rq4NWq0VXV5c8iiUsLMwrN3T+k+7ublitVgQFBbkVME1NTVi6dCnmzJmDAwcOeG3AZGVlwWw24/Tp027NXiPPYMj0A0NGXaIooqqqSl5RUF9fj8TERBiNRiQnJ3u8H+bGjRv4888/ERsbC71e/9AoFp1OJwfO6NGjPfZzPclut6OyshJ6vd6tqdYtLS1ISUlBZGQkDh486JUL5CRJwoYNG5CXlweLxYKIiAi1SyIwZPqFIeM9RFHssxPn6tWrWLBgAdLT0z2yE+f69euoq6vD7Nmz/7GXx263y4HT2tqKgIAAOXC85XFZu90Oq9Uq7+Vx9ffx119/ITk5GVOmTMFPP/3ktSuw33nnHeTm5sJsNvfpjdHpdF77JWAoYMj8B5vNhtraWgBAbGwssrOzYTAYEBwc7PIqWvIsSZJw+fJlOXAuXryIl19+Wd6JExoa2q8P2GvXrqG+vh5xcXGPdTnO4XD0GW/TO/srPDwc/v7+qjQnOhwOVFZWuh0wbW1tSE1Nxfjx42Eymbx65cKj3uP+/fvx5ptvDmwxJGPI/AeLxQKDwfDQ8dWrV+PAgQMDXxD9q96dOL2BU11d3Wcnzvjx4x/5YdT7bxsaGhAXF+fSwE2n09lnvI1Wq5UDp7/DJl3VGzABAQGIiopy+Wd2dHTAaDRCp9PBbDZ77YoF8m4MGfJZkiThxo0bOHLkCPLy8lBRUYHnn39e3okzceJE+QNYFEVcuXIFzc3NiI+P98glL0EQcOfOHTQ1NfUZNhkeHg6dTqdI4DgcDlitVvj7+yMqKsrlx4ttNhuWL18OPz8/FBQU8HITuYwhQ0OCJEloaGiQd+KUl5cjJiYGRqMRqamp2LlzJ+x2O7755htFHpH++7DJ5ubmPvPU9Hq9R3pNegNmzJgxeO6551x+zfv37+PVV1+FJEkoKChQbYUC+QaGzCDCAYCe0bsTJy8vD0eOHEF5eTn8/f2xevVqvP76626NWnkcoiiitbUVTU1NaGlpgSRJcuAEBwe7FA5OpxNWqxWjR492K2C6u7uxYsUKed5cYKD7PTo0tDFkBhEOAPQsQRDw1ltvwWKxYP369bBYLCgqKkJERATS0tKQkZGBGTNmKNrRLkkS2tra5OZPQRAQGhqKsLAwhISEPFYvSm/AaLVaREdHu1yv3W5HZmYm7ty5g5MnT0Kv17v0OkR/x5AZxDgA0D2ffvop9u3bh6KiIjz55JPyPLNjx47JO3EmTZokB447H+CPQ5IkdHR0yIHjcDj6jLf5p94Up9OJqqoq+Pn5PbSzpz8cDgdWrVqF+vp6FBUVeWTHDxHAkBnUOADQPTabDZ2dnY/ctNrR0dFnJ05YWJgcOHFxcYoHjs1mkwOnq6sLISEh8tKwkSNHoqenB1VVVRg5cqRbAeN0OrF27VpcuXIFxcXFqo3qJ9/EkBmkOABwYHV2dqKwsBAmkwkFBQXQ6XRIS0uD0WjE3LlzFR+xYrPZ5IcGbDYbgoKC0NXVBa1Wi9jYWJd/fk9PD95++21cuHABJSUlXG1OHseQGaQ4AFA9XV1dOHnyJEwmE/Lz86HVavvsxFF65Mq9e/dw/vx59PT0QBAE6PV6+cGB/vSyCIKArKwsnD17FhaLBRMmTFCwahqqGDKDEAcAeg+Hw4FTp07BZDLBbDZDo9EgJSUFGRkZmD9/vsc75Ht6elBdXY1hw4YhJiYGTqdTXlHQ3t6OwMBAuRfn33pbRFHExo0bUVJSgpKSEk6vIMUwZAYRDgD0bk6nU96JYzabYbfbkZKSAqPRCIPB4HbHvCAIqK6uhkajQUxMzEOXyOx2O1paWtDU1ITW1laMHTsW4eHhD81TE0URW7ZsQUFBASwWC7+okKIYMoMIBwAOHoIgoKysTN6J09HRgaVLl8JoNCIxMbHfDZ+9AQPgse7BOJ1OOXDu3r0LjUaDwsJCvPLKKzCbzTCZTCgpKVH9i8rp06fx2WefwWq1orGxkQNofRBDZhDhAMDBSRRFVFRUyIHT0tLSZyfOf3XUC4KA8+fPQxRFzJ49u983+Xt6elBTU4MPP/wQZ86cAQC88cYbWLduHeLj41UZ4NmrsLAQ5eXliIuLw/LlyxkyPoghQzSARFGE1WrFkSNHYDKZcOvWLSQmJiI9Pf0fd+IIgoALFy5AEATExsa6/FCBJEnYuXMn9u3bhy1btqCyshL5+fnQ6/U4fvw4IiMjPfUWXcZVGr6JIUOkElEU8dtvv8mBU1tbi4ULFyItLQ3Lli2Dn58f1q1bh8zMTCQlJbkVMNnZ2di9ezeKi4sxa9YsAA/u4RQVFcFgMHjF5VaGjG9SrpuMhoSvvvoK0dHRCAwMRGBgIBISElBYWKh2WYNC7xNin3zyCS5evIjq6mrMmzcPX3/9NSZPnowXXngBly5dwtSpU13ug5EkCV988QU+//xznDhxQg4YABg1ahSSk5O9ImDIdzFkyC1PPfUUdu3aBavVisrKSnk75aVLl9QubVDRaDSYOXMmtm3bhnPnzmH+/Pmw2+0ICQlBfHw8kpOTkZOTg8bGRjzuxQdJkpCTk4Ndu3bh+PHjiI+PV/hdED2MIUNuSU1NRXJyMiIiIjB16lTs2LEDY8eORUVFhdqlDUqCIGDFihVob29HTU0Nzp49iz/++AOpqak4fPgwpk2bhsWLF2PPnj2or69/ZOBIkoT9+/dj+/btyM/Px7x58wb4nRA9wJAhjxEEAYcOHUJnZycSEhLULmdQGj58OFJTU+UpyBqNBpMnT8bmzZtRVlaG69ev47XXXkNBQQEiIyNhMBiwe/duXL9+XQ4cSZLw/fffY+vWrTh27Bheeuklld8VDWW88U9uq6mpQUJCArq7uzF27Fjk5uYiOTlZ7bJ8miRJuH37NvLy8mAymVBaWoqoqCikp6dj1KhR2LFjB0wmExYvXqx2qf/KZrOhtrYWwIP+n+zsbBgMBgQHB3MKgY9gyJDbHA4Hbt68ifb2dhw+fBjffvstSktLMXPmTLVLGxIkScLdu3dhNpuRm5uL4uJi/PDDD8jMzFS7tP9ksVhgMBgeOr569WocOHBg4Asij2PIkMclJiZiypQpyMnJUbuUIad3zTSHppK34D0Z8jhRFGG329UuY0jSaDQMGPIqys4kJ5+3detWLF26FJMmTcK9e/eQm5sLi8WCEydOqF0aEXkBhgy5pbm5GatWrUJjYyN0Oh2io6Nx4sQJLFq0SO3SiMgL8J4MEREphvdkiIhIMQwZIiJSDEOGfNquXbug0WiwceNGtUshGpIYMuSzfv31V+Tk5CA6OlrtUoiGLIYM+SSbzYbMzEzs3bsXQUFBapdDNGQxZMgnvfvuu0hJSUFiYqLapRANaQwZ8jmHDh1CVVUVdu7cqXYpPuvLL7/EM888A61Wi7lz5+KXX35RuyTyUgwZ8in19fV47733cPDgQWi1WrXL8Uk//vgjNm3ahI8++ghVVVWYNWsWkpKS0NzcrHZp5IXYjEk+5ejRo8jIyOizrlgQBGg0GgwbNgx2u93lVcb0wNy5czFnzhzs2bMHwINZdRMnTsSGDRvwwQcfqFwdeRuOlSGfsnDhQtTU1PQ5tmbNGkyfPh3vv/8+A8ZNDocDVqsVW7dulY8NGzYMiYmJOHv2rIqVkbdiyJBPCQgIQFRUVJ9j/v7+CAkJeeg49d+dO3cgCALCw8P7HA8PD8fly5dVqoq8Ge/JEBGRYngmQz7PYrGoXYLPGDduHIYPH46mpqY+x5uamvDEE0+oVBV5M57JENFj8/PzQ1xcHIqKiuRjoiiiqKgICQkJKlZG3oohQzQAtm/fDo1G0+fP9OnT1S7LJZs2bcLevXvx3Xff4ffff8f69evR2dmJNWvWqF0aeSFeLiMaIJGRkTh16pT89xEjBud/vxUrVqClpQXbtm3D7du3ERMTg59//vmhhwGIAIYM0YAZMWKEz9y3yMrKQlZWltpl0CDAy2VEA+Tq1auYMGECnn32WWRmZuLmzZtql0SkOHb8Ew2AwsJC2Gw2TJs2DY2Njfj444/R0NCAixcvIiAgQO3yiBTDkCFSQVtbG55++mlkZ2dj7dq1apdDpBheLiNSgV6vx9SpU1FbW6t2KUSKYsgQqcBms+HatWsYP3682qUQKYohQzQANm/ejNLSUtTV1eHMmTPypOiVK1eqXRqRovgIM9EAuHXrFlauXIm7d+8iNDQUL774IioqKhAaGqp2aUSK4o1/IiJSDC+XERGRYhgyRESkGIYMEREphiFDRESKYcgQEZFiGDJERKQYhgwRESmGIUNERIphyBARkWIYMkREpBiGDBERKYYhQ0REivk/wUSQlt4++JAAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit first using a super-simple linear regression\n", - "\n", - "first_order_linear_estimator = LinearRegression()\n", - "first_order_linear_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "id": "f67dbeeb", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", - "polynomial_estimator = GridSearchCV(\n", - " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", - " param_grid=dict(polynomialfeatures__degree=range(4)),\n", - ")\n", - "polynomial_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "3d870dbb", - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.skl.bms:BMS fitting started\n", - "INFO:autora.theorist.bms.utils:Finish iteration 0\n", - "INFO:autora.theorist.bms.utils:Finish iteration 1\n", - "INFO:autora.theorist.bms.utils:Finish iteration 2\n", - "INFO:autora.theorist.bms.utils:Finish iteration 3\n", - "INFO:autora.theorist.bms.utils:Finish iteration 4\n", - "INFO:autora.theorist.bms.utils:Finish iteration 5\n", - "INFO:autora.theorist.bms.utils:Finish iteration 6\n", - "INFO:autora.theorist.bms.utils:Finish iteration 7\n", - "INFO:autora.theorist.bms.utils:Finish iteration 8\n", - "INFO:autora.theorist.bms.utils:Finish iteration 9\n", - "INFO:autora.theorist.bms.utils:Finish iteration 10\n", - "INFO:autora.theorist.bms.utils:Finish iteration 11\n", - "INFO:autora.theorist.bms.utils:Finish iteration 12\n", - "INFO:autora.theorist.bms.utils:Finish iteration 13\n", - "INFO:autora.theorist.bms.utils:Finish iteration 14\n", - "INFO:autora.theorist.bms.utils:Finish iteration 15\n", - "INFO:autora.theorist.bms.utils:Finish iteration 16\n", - "INFO:autora.theorist.bms.utils:Finish iteration 17\n", - "INFO:autora.theorist.bms.utils:Finish iteration 18\n", - "INFO:autora.theorist.bms.utils:Finish iteration 19\n", - "INFO:autora.theorist.bms.utils:Finish iteration 20\n", - "INFO:autora.theorist.bms.utils:Finish iteration 21\n", - "INFO:autora.theorist.bms.utils:Finish iteration 22\n", - "INFO:autora.theorist.bms.utils:Finish iteration 23\n", - "INFO:autora.theorist.bms.utils:Finish iteration 24\n", - "INFO:autora.theorist.bms.utils:Finish iteration 25\n", - "INFO:autora.theorist.bms.utils:Finish iteration 26\n", - "INFO:autora.theorist.bms.utils:Finish iteration 27\n", - "INFO:autora.theorist.bms.utils:Finish iteration 28\n", - "INFO:autora.theorist.bms.utils:Finish iteration 29\n", - "INFO:autora.theorist.bms.utils:Finish iteration 30\n", - "INFO:autora.theorist.bms.utils:Finish iteration 31\n", - "INFO:autora.theorist.bms.utils:Finish iteration 32\n", - "INFO:autora.theorist.bms.utils:Finish iteration 33\n", - "INFO:autora.theorist.bms.utils:Finish iteration 34\n", - "INFO:autora.theorist.bms.utils:Finish iteration 35\n", - "INFO:autora.theorist.bms.utils:Finish iteration 36\n", - "INFO:autora.theorist.bms.utils:Finish iteration 37\n", - "INFO:autora.theorist.bms.utils:Finish iteration 38\n", - "INFO:autora.theorist.bms.utils:Finish iteration 39\n", - "INFO:autora.theorist.bms.utils:Finish iteration 40\n", - "INFO:autora.theorist.bms.utils:Finish iteration 41\n", - "INFO:autora.theorist.bms.utils:Finish iteration 42\n", - "INFO:autora.theorist.bms.utils:Finish iteration 43\n", - "INFO:autora.theorist.bms.utils:Finish iteration 44\n", - "INFO:autora.theorist.bms.utils:Finish iteration 45\n", - "INFO:autora.theorist.bms.utils:Finish iteration 46\n", - "INFO:autora.theorist.bms.utils:Finish iteration 47\n", - "INFO:autora.theorist.bms.utils:Finish iteration 48\n", - "INFO:autora.theorist.bms.utils:Finish iteration 49\n", - "INFO:autora.theorist.bms.utils:Finish iteration 50\n", - "INFO:autora.theorist.bms.utils:Finish iteration 51\n", - "INFO:autora.theorist.bms.utils:Finish iteration 52\n", - "INFO:autora.theorist.bms.utils:Finish iteration 53\n", - "INFO:autora.theorist.bms.utils:Finish iteration 54\n", - "INFO:autora.theorist.bms.utils:Finish iteration 55\n", - "INFO:autora.theorist.bms.utils:Finish iteration 56\n", - "INFO:autora.theorist.bms.utils:Finish iteration 57\n", - "INFO:autora.theorist.bms.utils:Finish iteration 58\n", - "INFO:autora.theorist.bms.utils:Finish iteration 59\n", - "INFO:autora.theorist.bms.utils:Finish iteration 60\n", - "INFO:autora.theorist.bms.utils:Finish iteration 61\n", - "INFO:autora.theorist.bms.utils:Finish iteration 62\n", - "INFO:autora.theorist.bms.utils:Finish iteration 63\n", - "INFO:autora.theorist.bms.utils:Finish iteration 64\n", - "INFO:autora.theorist.bms.utils:Finish iteration 65\n", - "INFO:autora.theorist.bms.utils:Finish iteration 66\n", - "INFO:autora.theorist.bms.utils:Finish iteration 67\n", - "INFO:autora.theorist.bms.utils:Finish iteration 68\n", - "INFO:autora.theorist.bms.utils:Finish iteration 69\n", - "INFO:autora.theorist.bms.utils:Finish iteration 70\n", - "INFO:autora.theorist.bms.utils:Finish iteration 71\n", - "INFO:autora.theorist.bms.utils:Finish iteration 72\n", - "INFO:autora.theorist.bms.utils:Finish iteration 73\n", - "INFO:autora.theorist.bms.utils:Finish iteration 74\n", - "INFO:autora.theorist.bms.utils:Finish iteration 75\n", - "INFO:autora.theorist.bms.utils:Finish iteration 76\n", - "INFO:autora.theorist.bms.utils:Finish iteration 77\n", - "INFO:autora.theorist.bms.utils:Finish iteration 78\n", - "INFO:autora.theorist.bms.utils:Finish iteration 79\n", - "INFO:autora.theorist.bms.utils:Finish iteration 80\n", - "INFO:autora.theorist.bms.utils:Finish iteration 81\n", - "INFO:autora.theorist.bms.utils:Finish iteration 82\n", - "INFO:autora.theorist.bms.utils:Finish iteration 83\n", - "INFO:autora.theorist.bms.utils:Finish iteration 84\n", - "INFO:autora.theorist.bms.utils:Finish iteration 85\n", - "INFO:autora.theorist.bms.utils:Finish iteration 86\n", - "INFO:autora.theorist.bms.utils:Finish iteration 87\n", - "INFO:autora.theorist.bms.utils:Finish iteration 88\n", - "INFO:autora.theorist.bms.utils:Finish iteration 89\n", - "INFO:autora.theorist.bms.utils:Finish iteration 90\n", - "INFO:autora.theorist.bms.utils:Finish iteration 91\n", - "INFO:autora.theorist.bms.utils:Finish iteration 92\n", - "INFO:autora.theorist.bms.utils:Finish iteration 93\n", - "INFO:autora.theorist.bms.utils:Finish iteration 94\n", - "INFO:autora.theorist.bms.utils:Finish iteration 95\n", - "INFO:autora.theorist.bms.utils:Finish iteration 96\n", - "INFO:autora.theorist.bms.utils:Finish iteration 97\n", - "INFO:autora.theorist.bms.utils:Finish iteration 98\n", - "INFO:autora.theorist.bms.utils:Finish iteration 99\n", - "INFO:autora.theorist.bms.utils:Finish iteration 100\n", - "INFO:autora.theorist.bms.utils:Finish iteration 101\n", - "INFO:autora.theorist.bms.utils:Finish iteration 102\n", - "INFO:autora.theorist.bms.utils:Finish iteration 103\n", - "INFO:autora.theorist.bms.utils:Finish iteration 104\n", - "INFO:autora.theorist.bms.utils:Finish iteration 105\n", - "INFO:autora.theorist.bms.utils:Finish iteration 106\n", - "INFO:autora.theorist.bms.utils:Finish iteration 107\n", - "INFO:autora.theorist.bms.utils:Finish iteration 108\n", - "INFO:autora.theorist.bms.utils:Finish iteration 109\n", - "INFO:autora.theorist.bms.utils:Finish iteration 110\n", - "INFO:autora.theorist.bms.utils:Finish iteration 111\n", - "INFO:autora.theorist.bms.utils:Finish iteration 112\n", - "INFO:autora.theorist.bms.utils:Finish iteration 113\n", - "INFO:autora.theorist.bms.utils:Finish iteration 114\n", - "INFO:autora.theorist.bms.utils:Finish iteration 115\n", - "INFO:autora.theorist.bms.utils:Finish iteration 116\n", - "INFO:autora.theorist.bms.utils:Finish iteration 117\n", - "INFO:autora.theorist.bms.utils:Finish iteration 118\n", - "INFO:autora.theorist.bms.utils:Finish iteration 119\n", - "INFO:autora.theorist.bms.utils:Finish iteration 120\n", - "INFO:autora.theorist.bms.utils:Finish iteration 121\n", - "INFO:autora.theorist.bms.utils:Finish iteration 122\n", - "INFO:autora.theorist.bms.utils:Finish iteration 123\n", - "INFO:autora.theorist.bms.utils:Finish iteration 124\n", - "INFO:autora.theorist.bms.utils:Finish iteration 125\n", - "INFO:autora.theorist.bms.utils:Finish iteration 126\n", - "INFO:autora.theorist.bms.utils:Finish iteration 127\n", - "INFO:autora.theorist.bms.utils:Finish iteration 128\n", - "INFO:autora.theorist.bms.utils:Finish iteration 129\n", - "INFO:autora.theorist.bms.utils:Finish iteration 130\n", - "INFO:autora.theorist.bms.utils:Finish iteration 131\n", - "INFO:autora.theorist.bms.utils:Finish iteration 132\n", - "INFO:autora.theorist.bms.utils:Finish iteration 133\n", - "INFO:autora.theorist.bms.utils:Finish iteration 134\n", - "INFO:autora.theorist.bms.utils:Finish iteration 135\n", - "INFO:autora.theorist.bms.utils:Finish iteration 136\n", - "INFO:autora.theorist.bms.utils:Finish iteration 137\n", - "INFO:autora.theorist.bms.utils:Finish iteration 138\n", - "INFO:autora.theorist.bms.utils:Finish iteration 139\n", - "INFO:autora.theorist.bms.utils:Finish iteration 140\n", - "INFO:autora.theorist.bms.utils:Finish iteration 141\n", - "INFO:autora.theorist.bms.utils:Finish iteration 142\n", - "INFO:autora.theorist.bms.utils:Finish iteration 143\n", - "INFO:autora.theorist.bms.utils:Finish iteration 144\n", - "INFO:autora.theorist.bms.utils:Finish iteration 145\n", - "INFO:autora.theorist.bms.utils:Finish iteration 146\n", - "INFO:autora.theorist.bms.utils:Finish iteration 147\n", - "INFO:autora.theorist.bms.utils:Finish iteration 148\n", - "INFO:autora.theorist.bms.utils:Finish iteration 149\n", - "INFO:autora.theorist.bms.utils:Finish iteration 150\n", - "INFO:autora.theorist.bms.utils:Finish iteration 151\n", - "INFO:autora.theorist.bms.utils:Finish iteration 152\n", - "INFO:autora.theorist.bms.utils:Finish iteration 153\n", - "INFO:autora.theorist.bms.utils:Finish iteration 154\n", - "INFO:autora.theorist.bms.utils:Finish iteration 155\n", - "INFO:autora.theorist.bms.utils:Finish iteration 156\n", - "INFO:autora.theorist.bms.utils:Finish iteration 157\n", - "INFO:autora.theorist.bms.utils:Finish iteration 158\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.theorist.bms.utils:Finish iteration 159\n", - "INFO:autora.theorist.bms.utils:Finish iteration 160\n", - "INFO:autora.theorist.bms.utils:Finish iteration 161\n", - "INFO:autora.theorist.bms.utils:Finish iteration 162\n", - "INFO:autora.theorist.bms.utils:Finish iteration 163\n", - "INFO:autora.theorist.bms.utils:Finish iteration 164\n", - "INFO:autora.theorist.bms.utils:Finish iteration 165\n", - "INFO:autora.theorist.bms.utils:Finish iteration 166\n", - "INFO:autora.theorist.bms.utils:Finish iteration 167\n", - "INFO:autora.theorist.bms.utils:Finish iteration 168\n", - "INFO:autora.theorist.bms.utils:Finish iteration 169\n", - "INFO:autora.theorist.bms.utils:Finish iteration 170\n", - "INFO:autora.theorist.bms.utils:Finish iteration 171\n", - "INFO:autora.theorist.bms.utils:Finish iteration 172\n", - "INFO:autora.theorist.bms.utils:Finish iteration 173\n", - "INFO:autora.theorist.bms.utils:Finish iteration 174\n", - "INFO:autora.theorist.bms.utils:Finish iteration 175\n", - "INFO:autora.theorist.bms.utils:Finish iteration 176\n", - "INFO:autora.theorist.bms.utils:Finish iteration 177\n", - "INFO:autora.theorist.bms.utils:Finish iteration 178\n", - "INFO:autora.theorist.bms.utils:Finish iteration 179\n", - "INFO:autora.theorist.bms.utils:Finish iteration 180\n", - "INFO:autora.theorist.bms.utils:Finish iteration 181\n", - "INFO:autora.theorist.bms.utils:Finish iteration 182\n", - "INFO:autora.theorist.bms.utils:Finish iteration 183\n", - "INFO:autora.theorist.bms.utils:Finish iteration 184\n", - "INFO:autora.theorist.bms.utils:Finish iteration 185\n", - "INFO:autora.theorist.bms.utils:Finish iteration 186\n", - "INFO:autora.theorist.bms.utils:Finish iteration 187\n", - "INFO:autora.theorist.bms.utils:Finish iteration 188\n", - "INFO:autora.theorist.bms.utils:Finish iteration 189\n", - "INFO:autora.theorist.bms.utils:Finish iteration 190\n", - "INFO:autora.theorist.bms.utils:Finish iteration 191\n", - "INFO:autora.theorist.bms.utils:Finish iteration 192\n", - "INFO:autora.theorist.bms.utils:Finish iteration 193\n", - "INFO:autora.theorist.bms.utils:Finish iteration 194\n", - "INFO:autora.theorist.bms.utils:Finish iteration 195\n", - "INFO:autora.theorist.bms.utils:Finish iteration 196\n", - "INFO:autora.theorist.bms.utils:Finish iteration 197\n", - "INFO:autora.theorist.bms.utils:Finish iteration 198\n", - "INFO:autora.theorist.bms.utils:Finish iteration 199\n", - "INFO:autora.theorist.bms.utils:Finish iteration 200\n", - "INFO:autora.theorist.bms.utils:Finish iteration 201\n", - "INFO:autora.theorist.bms.utils:Finish iteration 202\n", - "INFO:autora.theorist.bms.utils:Finish iteration 203\n", - "INFO:autora.theorist.bms.utils:Finish iteration 204\n", - "INFO:autora.theorist.bms.utils:Finish iteration 205\n", - "INFO:autora.theorist.bms.utils:Finish iteration 206\n", - "INFO:autora.theorist.bms.utils:Finish iteration 207\n", - "INFO:autora.theorist.bms.utils:Finish iteration 208\n", - "INFO:autora.theorist.bms.utils:Finish iteration 209\n", - "INFO:autora.theorist.bms.utils:Finish iteration 210\n", - "INFO:autora.theorist.bms.utils:Finish iteration 211\n", - "INFO:autora.theorist.bms.utils:Finish iteration 212\n", - "INFO:autora.theorist.bms.utils:Finish iteration 213\n", - "INFO:autora.theorist.bms.utils:Finish iteration 214\n", - "INFO:autora.theorist.bms.utils:Finish iteration 215\n", - "INFO:autora.theorist.bms.utils:Finish iteration 216\n", - "INFO:autora.theorist.bms.utils:Finish iteration 217\n", - "INFO:autora.theorist.bms.utils:Finish iteration 218\n", - "INFO:autora.theorist.bms.utils:Finish iteration 219\n", - "INFO:autora.theorist.bms.utils:Finish iteration 220\n", - "INFO:autora.theorist.bms.utils:Finish iteration 221\n", - "INFO:autora.theorist.bms.utils:Finish iteration 222\n", - "INFO:autora.theorist.bms.utils:Finish iteration 223\n", - "INFO:autora.theorist.bms.utils:Finish iteration 224\n", - "INFO:autora.theorist.bms.utils:Finish iteration 225\n", - "INFO:autora.theorist.bms.utils:Finish iteration 226\n", - "INFO:autora.theorist.bms.utils:Finish iteration 227\n", - "INFO:autora.theorist.bms.utils:Finish iteration 228\n", - "INFO:autora.theorist.bms.utils:Finish iteration 229\n", - "INFO:autora.theorist.bms.utils:Finish iteration 230\n", - "INFO:autora.theorist.bms.utils:Finish iteration 231\n", - "INFO:autora.theorist.bms.utils:Finish iteration 232\n", - "INFO:autora.theorist.bms.utils:Finish iteration 233\n", - "INFO:autora.theorist.bms.utils:Finish iteration 234\n", - "INFO:autora.theorist.bms.utils:Finish iteration 235\n", - "INFO:autora.theorist.bms.utils:Finish iteration 236\n", - "INFO:autora.theorist.bms.utils:Finish iteration 237\n", - "INFO:autora.theorist.bms.utils:Finish iteration 238\n", - "INFO:autora.theorist.bms.utils:Finish iteration 239\n", - "INFO:autora.theorist.bms.utils:Finish iteration 240\n", - "INFO:autora.theorist.bms.utils:Finish iteration 241\n", - "INFO:autora.theorist.bms.utils:Finish iteration 242\n", - "INFO:autora.theorist.bms.utils:Finish iteration 243\n", - "INFO:autora.theorist.bms.utils:Finish iteration 244\n", - "INFO:autora.theorist.bms.utils:Finish iteration 245\n", - "INFO:autora.theorist.bms.utils:Finish iteration 246\n", - "INFO:autora.theorist.bms.utils:Finish iteration 247\n", - "INFO:autora.theorist.bms.utils:Finish iteration 248\n", - "INFO:autora.theorist.bms.utils:Finish iteration 249\n", - "INFO:autora.theorist.bms.utils:Finish iteration 250\n", - "INFO:autora.theorist.bms.utils:Finish iteration 251\n", - "INFO:autora.theorist.bms.utils:Finish iteration 252\n", - "INFO:autora.theorist.bms.utils:Finish iteration 253\n", - "INFO:autora.theorist.bms.utils:Finish iteration 254\n", - "INFO:autora.theorist.bms.utils:Finish iteration 255\n", - "INFO:autora.theorist.bms.utils:Finish iteration 256\n", - "INFO:autora.theorist.bms.utils:Finish iteration 257\n", - "INFO:autora.theorist.bms.utils:Finish iteration 258\n", - "INFO:autora.theorist.bms.utils:Finish iteration 259\n", - "INFO:autora.theorist.bms.utils:Finish iteration 260\n", - "INFO:autora.theorist.bms.utils:Finish iteration 261\n", - "INFO:autora.theorist.bms.utils:Finish iteration 262\n", - "INFO:autora.theorist.bms.utils:Finish iteration 263\n", - "INFO:autora.theorist.bms.utils:Finish iteration 264\n", - "INFO:autora.theorist.bms.utils:Finish iteration 265\n", - "INFO:autora.theorist.bms.utils:Finish iteration 266\n", - "INFO:autora.theorist.bms.utils:Finish iteration 267\n", - "INFO:autora.theorist.bms.utils:Finish iteration 268\n", - "INFO:autora.theorist.bms.utils:Finish iteration 269\n", - "INFO:autora.theorist.bms.utils:Finish iteration 270\n", - "INFO:autora.theorist.bms.utils:Finish iteration 271\n", - "INFO:autora.theorist.bms.utils:Finish iteration 272\n", - "INFO:autora.theorist.bms.utils:Finish iteration 273\n", - "INFO:autora.theorist.bms.utils:Finish iteration 274\n", - "INFO:autora.theorist.bms.utils:Finish iteration 275\n", - "INFO:autora.theorist.bms.utils:Finish iteration 276\n", - "INFO:autora.theorist.bms.utils:Finish iteration 277\n", - "INFO:autora.theorist.bms.utils:Finish iteration 278\n", - "INFO:autora.theorist.bms.utils:Finish iteration 279\n", - "INFO:autora.theorist.bms.utils:Finish iteration 280\n", - "INFO:autora.theorist.bms.utils:Finish iteration 281\n", - "INFO:autora.theorist.bms.utils:Finish iteration 282\n", - "INFO:autora.theorist.bms.utils:Finish iteration 283\n", - "INFO:autora.theorist.bms.utils:Finish iteration 284\n", - "INFO:autora.theorist.bms.utils:Finish iteration 285\n", - "INFO:autora.theorist.bms.utils:Finish iteration 286\n", - "INFO:autora.theorist.bms.utils:Finish iteration 287\n", - "INFO:autora.theorist.bms.utils:Finish iteration 288\n", - "INFO:autora.theorist.bms.utils:Finish iteration 289\n", - "INFO:autora.theorist.bms.utils:Finish iteration 290\n", - "INFO:autora.theorist.bms.utils:Finish iteration 291\n", - "INFO:autora.theorist.bms.utils:Finish iteration 292\n", - "INFO:autora.theorist.bms.utils:Finish iteration 293\n", - "INFO:autora.theorist.bms.utils:Finish iteration 294\n", - "INFO:autora.theorist.bms.utils:Finish iteration 295\n", - "INFO:autora.theorist.bms.utils:Finish iteration 296\n", - "INFO:autora.theorist.bms.utils:Finish iteration 297\n", - "INFO:autora.theorist.bms.utils:Finish iteration 298\n", - "INFO:autora.theorist.bms.utils:Finish iteration 299\n", - "INFO:autora.theorist.bms.utils:Finish iteration 300\n", - "INFO:autora.theorist.bms.utils:Finish iteration 301\n", - "INFO:autora.theorist.bms.utils:Finish iteration 302\n", - "INFO:autora.theorist.bms.utils:Finish iteration 303\n", - "INFO:autora.theorist.bms.utils:Finish iteration 304\n", - "INFO:autora.theorist.bms.utils:Finish iteration 305\n", - "INFO:autora.theorist.bms.utils:Finish iteration 306\n", - "INFO:autora.theorist.bms.utils:Finish iteration 307\n", - "INFO:autora.theorist.bms.utils:Finish iteration 308\n", - "INFO:autora.theorist.bms.utils:Finish iteration 309\n", - "INFO:autora.theorist.bms.utils:Finish iteration 310\n", - "INFO:autora.theorist.bms.utils:Finish iteration 311\n", - "INFO:autora.theorist.bms.utils:Finish iteration 312\n", - "INFO:autora.theorist.bms.utils:Finish iteration 313\n", - "INFO:autora.theorist.bms.utils:Finish iteration 314\n", - "INFO:autora.theorist.bms.utils:Finish iteration 315\n", - "INFO:autora.theorist.bms.utils:Finish iteration 316\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.theorist.bms.utils:Finish iteration 317\n", - "INFO:autora.theorist.bms.utils:Finish iteration 318\n", - "INFO:autora.theorist.bms.utils:Finish iteration 319\n", - "INFO:autora.theorist.bms.utils:Finish iteration 320\n", - "INFO:autora.theorist.bms.utils:Finish iteration 321\n", - "INFO:autora.theorist.bms.utils:Finish iteration 322\n", - "INFO:autora.theorist.bms.utils:Finish iteration 323\n", - "INFO:autora.theorist.bms.utils:Finish iteration 324\n", - "INFO:autora.theorist.bms.utils:Finish iteration 325\n", - "INFO:autora.theorist.bms.utils:Finish iteration 326\n", - "INFO:autora.theorist.bms.utils:Finish iteration 327\n", - "INFO:autora.theorist.bms.utils:Finish iteration 328\n", - "INFO:autora.theorist.bms.utils:Finish iteration 329\n", - "INFO:autora.theorist.bms.utils:Finish iteration 330\n", - "INFO:autora.theorist.bms.utils:Finish iteration 331\n", - "INFO:autora.theorist.bms.utils:Finish iteration 332\n", - "INFO:autora.theorist.bms.utils:Finish iteration 333\n", - "INFO:autora.theorist.bms.utils:Finish iteration 334\n", - "INFO:autora.theorist.bms.utils:Finish iteration 335\n", - "INFO:autora.theorist.bms.utils:Finish iteration 336\n", - "INFO:autora.theorist.bms.utils:Finish iteration 337\n", - "INFO:autora.theorist.bms.utils:Finish iteration 338\n", - "INFO:autora.theorist.bms.utils:Finish iteration 339\n", - "INFO:autora.theorist.bms.utils:Finish iteration 340\n", - "INFO:autora.theorist.bms.utils:Finish iteration 341\n", - "INFO:autora.theorist.bms.utils:Finish iteration 342\n", - "INFO:autora.theorist.bms.utils:Finish iteration 343\n", - "INFO:autora.theorist.bms.utils:Finish iteration 344\n", - "INFO:autora.theorist.bms.utils:Finish iteration 345\n", - "INFO:autora.theorist.bms.utils:Finish iteration 346\n", - "INFO:autora.theorist.bms.utils:Finish iteration 347\n", - "INFO:autora.theorist.bms.utils:Finish iteration 348\n", - "INFO:autora.theorist.bms.utils:Finish iteration 349\n", - "INFO:autora.theorist.bms.utils:Finish iteration 350\n", - "INFO:autora.theorist.bms.utils:Finish iteration 351\n", - "INFO:autora.theorist.bms.utils:Finish iteration 352\n", - "INFO:autora.theorist.bms.utils:Finish iteration 353\n", - "INFO:autora.theorist.bms.utils:Finish iteration 354\n", - "INFO:autora.theorist.bms.utils:Finish iteration 355\n", - "INFO:autora.theorist.bms.utils:Finish iteration 356\n", - "INFO:autora.theorist.bms.utils:Finish iteration 357\n", - "INFO:autora.theorist.bms.utils:Finish iteration 358\n", - "INFO:autora.theorist.bms.utils:Finish iteration 359\n", - "INFO:autora.theorist.bms.utils:Finish iteration 360\n", - "INFO:autora.theorist.bms.utils:Finish iteration 361\n", - "INFO:autora.theorist.bms.utils:Finish iteration 362\n", - "INFO:autora.theorist.bms.utils:Finish iteration 363\n", - "INFO:autora.theorist.bms.utils:Finish iteration 364\n", - "INFO:autora.theorist.bms.utils:Finish iteration 365\n", - "INFO:autora.theorist.bms.utils:Finish iteration 366\n", - "INFO:autora.theorist.bms.utils:Finish iteration 367\n", - "INFO:autora.theorist.bms.utils:Finish iteration 368\n", - "INFO:autora.theorist.bms.utils:Finish iteration 369\n", - "INFO:autora.theorist.bms.utils:Finish iteration 370\n", - "INFO:autora.theorist.bms.utils:Finish iteration 371\n", - "INFO:autora.theorist.bms.utils:Finish iteration 372\n", - "INFO:autora.theorist.bms.utils:Finish iteration 373\n", - "INFO:autora.theorist.bms.utils:Finish iteration 374\n", - "INFO:autora.theorist.bms.utils:Finish iteration 375\n", - "INFO:autora.theorist.bms.utils:Finish iteration 376\n", - "INFO:autora.theorist.bms.utils:Finish iteration 377\n", - "INFO:autora.theorist.bms.utils:Finish iteration 378\n", - "INFO:autora.theorist.bms.utils:Finish iteration 379\n", - "INFO:autora.theorist.bms.utils:Finish iteration 380\n", - "INFO:autora.theorist.bms.utils:Finish iteration 381\n", - "INFO:autora.theorist.bms.utils:Finish iteration 382\n", - "INFO:autora.theorist.bms.utils:Finish iteration 383\n", - "INFO:autora.theorist.bms.utils:Finish iteration 384\n", - "INFO:autora.theorist.bms.utils:Finish iteration 385\n", - "INFO:autora.theorist.bms.utils:Finish iteration 386\n", - "INFO:autora.theorist.bms.utils:Finish iteration 387\n", - "INFO:autora.theorist.bms.utils:Finish iteration 388\n", - "INFO:autora.theorist.bms.utils:Finish iteration 389\n", - "INFO:autora.theorist.bms.utils:Finish iteration 390\n", - "INFO:autora.theorist.bms.utils:Finish iteration 391\n", - "INFO:autora.theorist.bms.utils:Finish iteration 392\n", - "INFO:autora.theorist.bms.utils:Finish iteration 393\n", - "INFO:autora.theorist.bms.utils:Finish iteration 394\n", - "INFO:autora.theorist.bms.utils:Finish iteration 395\n", - "INFO:autora.theorist.bms.utils:Finish iteration 396\n", - "INFO:autora.theorist.bms.utils:Finish iteration 397\n", - "INFO:autora.theorist.bms.utils:Finish iteration 398\n", - "INFO:autora.theorist.bms.utils:Finish iteration 399\n", - "INFO:autora.theorist.bms.utils:Finish iteration 400\n", - "INFO:autora.theorist.bms.utils:Finish iteration 401\n", - "INFO:autora.theorist.bms.utils:Finish iteration 402\n", - "INFO:autora.theorist.bms.utils:Finish iteration 403\n", - "INFO:autora.theorist.bms.utils:Finish iteration 404\n", - "INFO:autora.theorist.bms.utils:Finish iteration 405\n", - "INFO:autora.theorist.bms.utils:Finish iteration 406\n", - "INFO:autora.theorist.bms.utils:Finish iteration 407\n", - "INFO:autora.theorist.bms.utils:Finish iteration 408\n", - "INFO:autora.theorist.bms.utils:Finish iteration 409\n", - "INFO:autora.theorist.bms.utils:Finish iteration 410\n", - "INFO:autora.theorist.bms.utils:Finish iteration 411\n", - "INFO:autora.theorist.bms.utils:Finish iteration 412\n", - "INFO:autora.theorist.bms.utils:Finish iteration 413\n", - "INFO:autora.theorist.bms.utils:Finish iteration 414\n", - "INFO:autora.theorist.bms.utils:Finish iteration 415\n", - "INFO:autora.theorist.bms.utils:Finish iteration 416\n", - "INFO:autora.theorist.bms.utils:Finish iteration 417\n", - "INFO:autora.theorist.bms.utils:Finish iteration 418\n", - "INFO:autora.theorist.bms.utils:Finish iteration 419\n", - "INFO:autora.theorist.bms.utils:Finish iteration 420\n", - "INFO:autora.theorist.bms.utils:Finish iteration 421\n", - "INFO:autora.theorist.bms.utils:Finish iteration 422\n", - "INFO:autora.theorist.bms.utils:Finish iteration 423\n", - "INFO:autora.theorist.bms.utils:Finish iteration 424\n", - "INFO:autora.theorist.bms.utils:Finish iteration 425\n", - "INFO:autora.theorist.bms.utils:Finish iteration 426\n", - "INFO:autora.theorist.bms.utils:Finish iteration 427\n", - "INFO:autora.theorist.bms.utils:Finish iteration 428\n", - "INFO:autora.theorist.bms.utils:Finish iteration 429\n", - "INFO:autora.theorist.bms.utils:Finish iteration 430\n", - "INFO:autora.theorist.bms.utils:Finish iteration 431\n", - "INFO:autora.theorist.bms.utils:Finish iteration 432\n", - "INFO:autora.theorist.bms.utils:Finish iteration 433\n", - "INFO:autora.theorist.bms.utils:Finish iteration 434\n", - "INFO:autora.theorist.bms.utils:Finish iteration 435\n", - "INFO:autora.theorist.bms.utils:Finish iteration 436\n", - "INFO:autora.theorist.bms.utils:Finish iteration 437\n", - "INFO:autora.theorist.bms.utils:Finish iteration 438\n", - "INFO:autora.theorist.bms.utils:Finish iteration 439\n", - "INFO:autora.theorist.bms.utils:Finish iteration 440\n", - "INFO:autora.theorist.bms.utils:Finish iteration 441\n", - "INFO:autora.theorist.bms.utils:Finish iteration 442\n", - "INFO:autora.theorist.bms.utils:Finish iteration 443\n", - "INFO:autora.theorist.bms.utils:Finish iteration 444\n", - "INFO:autora.theorist.bms.utils:Finish iteration 445\n", - "INFO:autora.theorist.bms.utils:Finish iteration 446\n", - "INFO:autora.theorist.bms.utils:Finish iteration 447\n", - "INFO:autora.theorist.bms.utils:Finish iteration 448\n", - "INFO:autora.theorist.bms.utils:Finish iteration 449\n", - "INFO:autora.theorist.bms.utils:Finish iteration 450\n", - "INFO:autora.theorist.bms.utils:Finish iteration 451\n", - "INFO:autora.theorist.bms.utils:Finish iteration 452\n", - "INFO:autora.theorist.bms.utils:Finish iteration 453\n", - "INFO:autora.theorist.bms.utils:Finish iteration 454\n", - "INFO:autora.theorist.bms.utils:Finish iteration 455\n", - "INFO:autora.theorist.bms.utils:Finish iteration 456\n", - "INFO:autora.theorist.bms.utils:Finish iteration 457\n", - "INFO:autora.theorist.bms.utils:Finish iteration 458\n", - "INFO:autora.theorist.bms.utils:Finish iteration 459\n", - "INFO:autora.theorist.bms.utils:Finish iteration 460\n", - "INFO:autora.theorist.bms.utils:Finish iteration 461\n", - "INFO:autora.theorist.bms.utils:Finish iteration 462\n", - "INFO:autora.theorist.bms.utils:Finish iteration 463\n", - "INFO:autora.theorist.bms.utils:Finish iteration 464\n", - "INFO:autora.theorist.bms.utils:Finish iteration 465\n", - "INFO:autora.theorist.bms.utils:Finish iteration 466\n", - "INFO:autora.theorist.bms.utils:Finish iteration 467\n", - "INFO:autora.theorist.bms.utils:Finish iteration 468\n", - "INFO:autora.theorist.bms.utils:Finish iteration 469\n", - "INFO:autora.theorist.bms.utils:Finish iteration 470\n", - "INFO:autora.theorist.bms.utils:Finish iteration 471\n", - "INFO:autora.theorist.bms.utils:Finish iteration 472\n", - "INFO:autora.theorist.bms.utils:Finish iteration 473\n", - "INFO:autora.theorist.bms.utils:Finish iteration 474\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:autora.theorist.bms.utils:Finish iteration 475\n", - "INFO:autora.theorist.bms.utils:Finish iteration 476\n", - "INFO:autora.theorist.bms.utils:Finish iteration 477\n", - "INFO:autora.theorist.bms.utils:Finish iteration 478\n", - "INFO:autora.theorist.bms.utils:Finish iteration 479\n", - "INFO:autora.theorist.bms.utils:Finish iteration 480\n", - "INFO:autora.theorist.bms.utils:Finish iteration 481\n", - "INFO:autora.theorist.bms.utils:Finish iteration 482\n", - "INFO:autora.theorist.bms.utils:Finish iteration 483\n", - "INFO:autora.theorist.bms.utils:Finish iteration 484\n", - "INFO:autora.theorist.bms.utils:Finish iteration 485\n", - "INFO:autora.theorist.bms.utils:Finish iteration 486\n", - "INFO:autora.theorist.bms.utils:Finish iteration 487\n", - "INFO:autora.theorist.bms.utils:Finish iteration 488\n", - "INFO:autora.theorist.bms.utils:Finish iteration 489\n", - "INFO:autora.theorist.bms.utils:Finish iteration 490\n", - "INFO:autora.theorist.bms.utils:Finish iteration 491\n", - "INFO:autora.theorist.bms.utils:Finish iteration 492\n", - "INFO:autora.theorist.bms.utils:Finish iteration 493\n", - "INFO:autora.theorist.bms.utils:Finish iteration 494\n", - "INFO:autora.theorist.bms.utils:Finish iteration 495\n", - "INFO:autora.theorist.bms.utils:Finish iteration 496\n", - "INFO:autora.theorist.bms.utils:Finish iteration 497\n", - "INFO:autora.theorist.bms.utils:Finish iteration 498\n", - "INFO:autora.theorist.bms.utils:Finish iteration 499\n", - "INFO:autora.theorist.bms.utils:Finish iteration 500\n", - "INFO:autora.theorist.bms.utils:Finish iteration 501\n", - "INFO:autora.theorist.bms.utils:Finish iteration 502\n", - "INFO:autora.theorist.bms.utils:Finish iteration 503\n", - "INFO:autora.theorist.bms.utils:Finish iteration 504\n", - "INFO:autora.theorist.bms.utils:Finish iteration 505\n", - "INFO:autora.theorist.bms.utils:Finish iteration 506\n", - "INFO:autora.theorist.bms.utils:Finish iteration 507\n", - "INFO:autora.theorist.bms.utils:Finish iteration 508\n", - "INFO:autora.theorist.bms.utils:Finish iteration 509\n", - "INFO:autora.theorist.bms.utils:Finish iteration 510\n", - "INFO:autora.theorist.bms.utils:Finish iteration 511\n", - "INFO:autora.theorist.bms.utils:Finish iteration 512\n", - "INFO:autora.theorist.bms.utils:Finish iteration 513\n", - "INFO:autora.theorist.bms.utils:Finish iteration 514\n", - "INFO:autora.theorist.bms.utils:Finish iteration 515\n", - "INFO:autora.theorist.bms.utils:Finish iteration 516\n", - "INFO:autora.theorist.bms.utils:Finish iteration 517\n", - "INFO:autora.theorist.bms.utils:Finish iteration 518\n", - "INFO:autora.theorist.bms.utils:Finish iteration 519\n", - "INFO:autora.theorist.bms.utils:Finish iteration 520\n", - "INFO:autora.theorist.bms.utils:Finish iteration 521\n", - "INFO:autora.theorist.bms.utils:Finish iteration 522\n", - "INFO:autora.theorist.bms.utils:Finish iteration 523\n", - "INFO:autora.theorist.bms.utils:Finish iteration 524\n", - "INFO:autora.theorist.bms.utils:Finish iteration 525\n", - "INFO:autora.theorist.bms.utils:Finish iteration 526\n", - "INFO:autora.theorist.bms.utils:Finish iteration 527\n", - "INFO:autora.theorist.bms.utils:Finish iteration 528\n", - "INFO:autora.theorist.bms.utils:Finish iteration 529\n", - "INFO:autora.theorist.bms.utils:Finish iteration 530\n", - "INFO:autora.theorist.bms.utils:Finish iteration 531\n", - "INFO:autora.theorist.bms.utils:Finish iteration 532\n", - "INFO:autora.theorist.bms.utils:Finish iteration 533\n", - "INFO:autora.theorist.bms.utils:Finish iteration 534\n", - "INFO:autora.theorist.bms.utils:Finish iteration 535\n", - "INFO:autora.theorist.bms.utils:Finish iteration 536\n", - "INFO:autora.theorist.bms.utils:Finish iteration 537\n", - "INFO:autora.theorist.bms.utils:Finish iteration 538\n", - "INFO:autora.theorist.bms.utils:Finish iteration 539\n", - "INFO:autora.theorist.bms.utils:Finish iteration 540\n", - "INFO:autora.theorist.bms.utils:Finish iteration 541\n", - "INFO:autora.theorist.bms.utils:Finish iteration 542\n", - "INFO:autora.theorist.bms.utils:Finish iteration 543\n", - "INFO:autora.theorist.bms.utils:Finish iteration 544\n", - "INFO:autora.theorist.bms.utils:Finish iteration 545\n", - "INFO:autora.theorist.bms.utils:Finish iteration 546\n", - "INFO:autora.theorist.bms.utils:Finish iteration 547\n" - ] - } - ], - "source": [ - "# initialize model\n", - "# hyper parameters\n", - "\n", - "prior_par = {\n", - " \"Nopi_/\": 5.912205942815285,\n", - " \"Nopi_cosh\": 8.12720511103694,\n", - " \"Nopi_-\": 3.350846072163632,\n", - " \"Nopi_sin\": 5.965917796154835,\n", - " \"Nopi_tan\": 8.127427922862411,\n", - " \"Nopi_tanh\": 7.799259068142255,\n", - " \"Nopi_**\": 6.4734429542245495,\n", - " \"Nopi_pow2\": 3.3017352779079734,\n", - " \"Nopi_pow3\": 5.9907496760026175,\n", - " \"Nopi_exp\": 4.768665265735502,\n", - " \"Nopi_log\": 4.745957377206544,\n", - " \"Nopi_sqrt\": 4.760686909134266,\n", - " \"Nopi_cos\": 5.452564657261127,\n", - " \"Nopi_sinh\": 7.955723540761046,\n", - " \"Nopi_abs\": 6.333544134938385,\n", - " \"Nopi_+\": 5.808163661224514,\n", - " \"Nopi_*\": 5.002213595420244,\n", - " \"Nopi_fac\": 10.0,\n", - " \"Nopi2_*\": 1.0,\n", - " \"Nopi_sig\": 1.0,\n", - " \"Nopi_relu\": 1.0,\n", - "}\n", - "\n", - "# temperatures\n", - "ts = [1.0] + [1.04**k for k in range(1, 20)]\n", - "\n", - "# epoch num\n", - "epochs = 1500\n", - "\n", - "# fit model\n", - "estimator = BMSRegressor(prior_par, ts, epochs)\n", - "estimator = estimator.fit(X, y)\n", - "\n", - "# model estimate\n", - "show_results(\n", - " estimator=estimator, label=\"BMS Regressor\"\n", - ")\n", - "print(estimator.model_)\n", - "\n", - "# model prediction\n", - "test_x = X.head()\n", - "estimator.predict(test_x)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "375b5b94", - "metadata": {}, - "outputs": [], - "source": [ - "estimator.present_results()\n" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/example/sklearn/bms/weber_bms_sklearn.py b/example/sklearn/bms/weber_bms_sklearn.py deleted file mode 100644 index 8da2e155f..000000000 --- a/example/sklearn/bms/weber_bms_sklearn.py +++ /dev/null @@ -1,39 +0,0 @@ -import warnings - -import pandas as pd - -from autora.skl.bms import BMSRegressor -from autora.theorist.bms import get_priors - -warnings.filterwarnings("ignore") - - -# load data -XLABS = [ - "S1", - "S2", -] - -raw_data = pd.read_csv("weber_data.csv") -x, y = raw_data[XLABS], raw_data["difference_detected"] - -# initialize model -# hyper parameters - -prior_par, _ = get_priors() - -# temperatures -ts = [1.0] + [1.04**k for k in range(1, 20)] - -# epoch num -epochs = 1500 - -estimator = BMSRegressor(prior_par, ts, epochs) -estimator = estimator.fit(x, y) - -print(estimator.model_) - -test_x = x.head() -estimator.predict(test_x) - -estimator.present_results() diff --git a/example/sklearn/bms/weber_data.csv b/example/sklearn/bms/weber_data.csv deleted file mode 100644 index f9550c969..000000000 --- a/example/sklearn/bms/weber_data.csv +++ /dev/null @@ -1,211 +0,0 @@ -,S1,S2,difference_detected -0,0.0,0.0,0.5 -1,0.0,0.2631578947368421,0.5654124021530151 -2,0.0,0.5263157894736842,0.6286234259605408 -3,0.0,0.7894736842105263,0.6877183318138123 -4,0.0,1.0526315789473684,0.7412799000740051 -5,0.0,1.3157894736842104,0.7884804010391235 -6,0.0,1.5789473684210529,0.8290553689002991 -7,0.0,1.8421052631578947,0.8631975054740906 -8,0.0,2.1052631578947367,0.8914136290550232 -9,0.0,2.3684210526315788,0.9143873453140259 -10,0.0,2.631578947368421,0.9328665137290955 -11,0.0,2.8947368421052633,0.9475856423377991 -12,0.0,3.1578947368421053,0.9592186808586121 -13,0.0,3.421052631578948,0.9683560729026794 -14,0.0,3.684210526315789,0.975498378276825 -15,0.0,3.947368421052632,0.9810601472854614 -16,0.0,4.2105263157894735,0.9853783845901489 -17,0.0,4.473684210526316,0.9887233972549438 -18,0.0,4.7368421052631575,0.9913098812103271 -19,0.0,5.0,0.9933071732521057 -20,0.2631578947368421,0.2631578947368421,0.43458759784698486 -21,0.2631578947368421,0.5263157894736842,0.5 -22,0.2631578947368421,0.7894736842105263,0.5654124021530151 -23,0.2631578947368421,1.0526315789473684,0.6286234259605408 -24,0.2631578947368421,1.3157894736842104,0.6877183318138123 -25,0.2631578947368421,1.5789473684210529,0.7412799000740051 -26,0.2631578947368421,1.8421052631578947,0.7884804010391235 -27,0.2631578947368421,2.1052631578947367,0.8290553689002991 -28,0.2631578947368421,2.3684210526315788,0.8631975054740906 -29,0.2631578947368421,2.631578947368421,0.8914136290550232 -30,0.2631578947368421,2.8947368421052633,0.9143873453140259 -31,0.2631578947368421,3.1578947368421053,0.9328665137290955 -32,0.2631578947368421,3.421052631578948,0.9475856423377991 -33,0.2631578947368421,3.684210526315789,0.9592186808586121 -34,0.2631578947368421,3.947368421052632,0.9683560729026794 -35,0.2631578947368421,4.2105263157894735,0.975498378276825 -36,0.2631578947368421,4.473684210526316,0.9810601472854614 -37,0.2631578947368421,4.7368421052631575,0.9853783845901489 -38,0.2631578947368421,5.0,0.9887233972549438 -39,0.5263157894736842,0.5263157894736842,0.37137657403945923 -40,0.5263157894736842,0.7894736842105263,0.43458759784698486 -41,0.5263157894736842,1.0526315789473684,0.5 -42,0.5263157894736842,1.3157894736842104,0.5654124021530151 -43,0.5263157894736842,1.5789473684210529,0.6286234259605408 -44,0.5263157894736842,1.8421052631578947,0.6877183318138123 -45,0.5263157894736842,2.1052631578947367,0.7412799000740051 -46,0.5263157894736842,2.3684210526315788,0.7884804010391235 -47,0.5263157894736842,2.631578947368421,0.8290553689002991 -48,0.5263157894736842,2.8947368421052633,0.8631975054740906 -49,0.5263157894736842,3.1578947368421053,0.8914136290550232 -50,0.5263157894736842,3.421052631578948,0.9143873453140259 -51,0.5263157894736842,3.684210526315789,0.9328665137290955 -52,0.5263157894736842,3.947368421052632,0.9475856423377991 -53,0.5263157894736842,4.2105263157894735,0.9592186808586121 -54,0.5263157894736842,4.473684210526316,0.9683560729026794 -55,0.5263157894736842,4.7368421052631575,0.975498378276825 -56,0.5263157894736842,5.0,0.9810601472854614 -57,0.7894736842105263,0.7894736842105263,0.31228166818618774 -58,0.7894736842105263,1.0526315789473684,0.37137657403945923 -59,0.7894736842105263,1.3157894736842104,0.43458759784698486 -60,0.7894736842105263,1.5789473684210529,0.5 -61,0.7894736842105263,1.8421052631578947,0.5654124021530151 -62,0.7894736842105263,2.1052631578947367,0.6286234259605408 -63,0.7894736842105263,2.3684210526315788,0.6877182722091675 -64,0.7894736842105263,2.631578947368421,0.7412799000740051 -65,0.7894736842105263,2.8947368421052633,0.788480281829834 -66,0.7894736842105263,3.1578947368421053,0.8290553689002991 -67,0.7894736842105263,3.421052631578948,0.8631974458694458 -68,0.7894736842105263,3.684210526315789,0.8914136290550232 -69,0.7894736842105263,3.947368421052632,0.9143873453140259 -70,0.7894736842105263,4.2105263157894735,0.9328665137290955 -71,0.7894736842105263,4.473684210526316,0.9475856423377991 -72,0.7894736842105263,4.7368421052631575,0.9592186808586121 -73,0.7894736842105263,5.0,0.9683560729026794 -74,1.0526315789473684,1.0526315789473684,0.2587200701236725 -75,1.0526315789473684,1.3157894736842104,0.31228166818618774 -76,1.0526315789473684,1.5789473684210529,0.37137657403945923 -77,1.0526315789473684,1.8421052631578947,0.43458759784698486 -78,1.0526315789473684,2.1052631578947367,0.5 -79,1.0526315789473684,2.3684210526315788,0.5654124021530151 -80,1.0526315789473684,2.631578947368421,0.628623366355896 -81,1.0526315789473684,2.8947368421052633,0.6877182722091675 -82,1.0526315789473684,3.1578947368421053,0.7412799000740051 -83,1.0526315789473684,3.421052631578948,0.7884804010391235 -84,1.0526315789473684,3.684210526315789,0.8290553689002991 -85,1.0526315789473684,3.947368421052632,0.8631974458694458 -86,1.0526315789473684,4.2105263157894735,0.8914136290550232 -87,1.0526315789473684,4.473684210526316,0.9143873453140259 -88,1.0526315789473684,4.7368421052631575,0.9328665137290955 -89,1.0526315789473684,5.0,0.9475856423377991 -90,1.3157894736842104,1.3157894736842104,0.21151967346668243 -91,1.3157894736842104,1.5789473684210529,0.2587200999259949 -92,1.3157894736842104,1.8421052631578947,0.31228169798851013 -93,1.3157894736842104,2.1052631578947367,0.3713766038417816 -94,1.3157894736842104,2.3684210526315788,0.43458759784698486 -95,1.3157894736842104,2.631578947368421,0.5 -96,1.3157894736842104,2.8947368421052633,0.5654124021530151 -97,1.3157894736842104,3.1578947368421053,0.6286234855651855 -98,1.3157894736842104,3.421052631578948,0.6877183318138123 -99,1.3157894736842104,3.684210526315789,0.7412799000740051 -100,1.3157894736842104,3.947368421052632,0.7884804010391235 -101,1.3157894736842104,4.2105263157894735,0.8290553689002991 -102,1.3157894736842104,4.473684210526316,0.8631975054740906 -103,1.3157894736842104,4.7368421052631575,0.8914136290550232 -104,1.3157894736842104,5.0,0.9143873453140259 -105,1.5789473684210529,1.5789473684210529,0.17094460129737854 -106,1.5789473684210529,1.8421052631578947,0.21151965856552124 -107,1.5789473684210529,2.1052631578947367,0.2587200701236725 -108,1.5789473684210529,2.3684210526315788,0.31228166818618774 -109,1.5789473684210529,2.631578947368421,0.37137654423713684 -110,1.5789473684210529,2.8947368421052633,0.4345875084400177 -111,1.5789473684210529,3.1578947368421053,0.5 -112,1.5789473684210529,3.421052631578948,0.5654124021530151 -113,1.5789473684210529,3.684210526315789,0.6286234259605408 -114,1.5789473684210529,3.947368421052632,0.6877183318138123 -115,1.5789473684210529,4.2105263157894735,0.7412799000740051 -116,1.5789473684210529,4.473684210526316,0.788480281829834 -117,1.5789473684210529,4.7368421052631575,0.8290553689002991 -118,1.5789473684210529,5.0,0.8631974458694458 -119,1.8421052631578947,1.8421052631578947,0.13680249452590942 -120,1.8421052631578947,2.1052631578947367,0.17094461619853973 -121,1.8421052631578947,2.3684210526315788,0.21151967346668243 -122,1.8421052631578947,2.631578947368421,0.2587200701236725 -123,1.8421052631578947,2.8947368421052633,0.31228166818618774 -124,1.8421052631578947,3.1578947368421053,0.3713766038417816 -125,1.8421052631578947,3.421052631578948,0.43458759784698486 -126,1.8421052631578947,3.684210526315789,0.5 -127,1.8421052631578947,3.947368421052632,0.5654124021530151 -128,1.8421052631578947,4.2105263157894735,0.6286234259605408 -129,1.8421052631578947,4.473684210526316,0.6877183318138123 -130,1.8421052631578947,4.7368421052631575,0.7412799000740051 -131,1.8421052631578947,5.0,0.788480281829834 -132,2.1052631578947367,2.1052631578947367,0.10858631134033203 -133,2.1052631578947367,2.3684210526315788,0.13680247962474823 -134,2.1052631578947367,2.631578947368421,0.17094458639621735 -135,2.1052631578947367,2.8947368421052633,0.21151962876319885 -136,2.1052631578947367,3.1578947368421053,0.2587200701236725 -137,2.1052631578947367,3.421052631578948,0.31228166818618774 -138,2.1052631578947367,3.684210526315789,0.37137654423713684 -139,2.1052631578947367,3.947368421052632,0.4345875084400177 -140,2.1052631578947367,4.2105263157894735,0.5 -141,2.1052631578947367,4.473684210526316,0.5654124021530151 -142,2.1052631578947367,4.7368421052631575,0.628623366355896 -143,2.1052631578947367,5.0,0.6877182722091675 -144,2.3684210526315788,2.3684210526315788,0.08561266213655472 -145,2.3684210526315788,2.631578947368421,0.10858631134033203 -146,2.3684210526315788,2.8947368421052633,0.13680247962474823 -147,2.3684210526315788,3.1578947368421053,0.17094461619853973 -148,2.3684210526315788,3.421052631578948,0.21151967346668243 -149,2.3684210526315788,3.684210526315789,0.2587200701236725 -150,2.3684210526315788,3.947368421052632,0.31228166818618774 -151,2.3684210526315788,4.2105263157894735,0.3713766038417816 -152,2.3684210526315788,4.473684210526316,0.43458759784698486 -153,2.3684210526315788,4.7368421052631575,0.5 -154,2.3684210526315788,5.0,0.5654124021530151 -155,2.631578947368421,2.631578947368421,0.06713350117206573 -156,2.631578947368421,2.8947368421052633,0.08561266213655472 -157,2.631578947368421,3.1578947368421053,0.10858633369207382 -158,2.631578947368421,3.421052631578948,0.13680250942707062 -159,2.631578947368421,3.684210526315789,0.17094461619853973 -160,2.631578947368421,3.947368421052632,0.21151967346668243 -161,2.631578947368421,4.2105263157894735,0.25872012972831726 -162,2.631578947368421,4.473684210526316,0.3122817277908325 -163,2.631578947368421,4.7368421052631575,0.3713766038417816 -164,2.631578947368421,5.0,0.43458759784698486 -165,2.8947368421052633,2.8947368421052633,0.052414361387491226 -166,2.8947368421052633,3.1578947368421053,0.06713351607322693 -167,2.8947368421052633,3.421052631578948,0.08561268448829651 -168,2.8947368421052633,3.684210526315789,0.10858633369207382 -169,2.8947368421052633,3.947368421052632,0.13680250942707062 -170,2.8947368421052633,4.2105263157894735,0.17094466090202332 -171,2.8947368421052633,4.473684210526316,0.21151971817016602 -172,2.8947368421052633,4.7368421052631575,0.25872012972831726 -173,2.8947368421052633,5.0,0.3122817277908325 -174,3.1578947368421053,3.1578947368421053,0.04078132286667824 -175,3.1578947368421053,3.421052631578948,0.052414342761039734 -176,3.1578947368421053,3.684210526315789,0.06713348627090454 -177,3.1578947368421053,3.947368421052632,0.08561263978481293 -178,3.1578947368421053,4.2105263157894735,0.10858631134033203 -179,3.1578947368421053,4.473684210526316,0.13680247962474823 -180,3.1578947368421053,4.7368421052631575,0.17094458639621735 -181,3.1578947368421053,5.0,0.21151962876319885 -182,3.421052631578948,3.421052631578948,0.031643956899642944 -183,3.421052631578948,3.684210526315789,0.04078132286667824 -184,3.421052631578948,3.947368421052632,0.052414342761039734 -185,3.421052631578948,4.2105263157894735,0.06713350117206573 -186,3.421052631578948,4.473684210526316,0.08561266213655472 -187,3.421052631578948,4.7368421052631575,0.10858631134033203 -188,3.421052631578948,5.0,0.13680247962474823 -189,3.684210526315789,3.684210526315789,0.024501590058207512 -190,3.684210526315789,3.947368421052632,0.031643956899642944 -191,3.684210526315789,4.2105263157894735,0.04078133404254913 -192,3.684210526315789,4.473684210526316,0.052414361387491226 -193,3.684210526315789,4.7368421052631575,0.06713350117206573 -194,3.684210526315789,5.0,0.08561266213655472 -195,3.947368421052632,3.947368421052632,0.018939798697829247 -196,3.947368421052632,4.2105263157894735,0.02450159564614296 -197,3.947368421052632,4.473684210526316,0.03164396435022354 -198,3.947368421052632,4.7368421052631575,0.04078133404254913 -199,3.947368421052632,5.0,0.052414361387491226 -200,4.2105263157894735,4.2105263157894735,0.01462159026414156 -201,4.2105263157894735,4.473684210526316,0.0189397931098938 -202,4.2105263157894735,4.7368421052631575,0.024501584470272064 -203,4.2105263157894735,5.0,0.03164394944906235 -204,4.473684210526316,4.473684210526316,0.011276605539023876 -205,4.473684210526316,4.7368421052631575,0.01462159026414156 -206,4.473684210526316,5.0,0.0189397931098938 -207,4.7368421052631575,4.7368421052631575,0.008690104819834232 -208,4.7368421052631575,5.0,0.011276605539023876 -209,5.0,5.0,0.006692850962281227 diff --git a/example/sklearn/darts/__init__.py b/example/sklearn/darts/__init__.py deleted file mode 100644 index e69de29bb..000000000 diff --git a/example/sklearn/darts/weber.ipynb b/example/sklearn/darts/weber.ipynb deleted file mode 100644 index 8ded45059..000000000 --- a/example/sklearn/darts/weber.ipynb +++ /dev/null @@ -1,246 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "source": [ - "Example file which shows some simple curve fitting using DARTSRegressor and some other estimators." - ], - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "from functools import partial\n", - "\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from sklearn.linear_model import LinearRegression\n", - "from sklearn.model_selection import GridSearchCV\n", - "from sklearn.pipeline import make_pipeline\n", - "from sklearn.preprocessing import PolynomialFeatures\n", - "\n", - "from autora.skl.darts import DARTSRegressor, Val" - ], - "metadata": { - "pycharm": { - "name": "#%%\n", - "is_executing": true - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "# %% Define some helper functions\n", - "\n", - "def show_results_complete(\n", - " data_: pd.DataFrame,\n", - " estimator=None,\n", - " show_results=True,\n", - " projection=\"2d\",\n", - " label=None,\n", - "):\n", - " \"\"\"\n", - " Function to plot input data (x_, y_) and the predictions of an estimator for the same x_.\n", - " \"\"\"\n", - " if projection == \"2d\":\n", - " plt.figure()\n", - " data_.plot.scatter(\n", - " \"S1\", \"S2\", c=\"difference_detected\", cmap=\"viridis\", zorder=10\n", - " )\n", - " elif projection == \"3d\":\n", - " fig = plt.figure()\n", - " ax = fig.add_subplot(projection=\"3d\")\n", - " ax.scatter(data_[\"S1\"], data[\"S2\"], data[\"difference_detected\"])\n", - "\n", - " if estimator is not None:\n", - " xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore\n", - "\n", - " zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel())))\n", - "\n", - " ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5)\n", - "\n", - " if label is not None:\n", - " plt.title(label)\n", - "\n", - " if show_results:\n", - " plt.show()\n", - "\n", - " return\n", - "\n", - "\n", - "# %% Load the data\n", - "\n", - "\n", - "data = pd.read_csv(\"./weber_data.csv\")\n", - "show_results = partial(show_results_complete, data_=data, projection=\"3d\")\n", - "show_results(label=\"input data\")\n", - "\n", - "X = data[[\"S1\", \"S2\"]]\n", - "y = data[\"difference_detected\"]\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "\n", - "# %% Fit first using a super-simple linear regression\n", - "\n", - "first_order_linear_estimator = LinearRegression()\n", - "first_order_linear_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=first_order_linear_estimator, label=\"1st order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": { - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "\n", - "# %% Fit using a 0-3 order polynomial, getting the best fit for the data.\n", - "polynomial_estimator = GridSearchCV(\n", - " make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)),\n", - " param_grid=dict(polynomialfeatures__degree=range(4)),\n", - ")\n", - "polynomial_estimator.fit(X, y)\n", - "\n", - "show_results(estimator=polynomial_estimator, label=\"[0th-3rd]-order linear\")" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_estimator_tuned = DARTSRegressor(\n", - " batch_size=64,\n", - " arch_updates_per_epoch=100,\n", - " param_updates_per_epoch=100,\n", - " max_epochs=30,\n", - " output_type=\"probability\",\n", - " num_graph_nodes=5,\n", - " primitives=[\n", - " \"none\",\n", - " \"linear\",\n", - " \"logistic\",\n", - " ]\n", - ")\n", - "\n", - "darts_estimator_tuned.fit(X, y)\n", - "\n", - "show_results(estimator=darts_estimator_tuned, label=\"pre-tuned DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_estimator_tuned.set_params(\n", - " arch_updates_per_epoch=0,\n", - " param_updates_per_epoch=1000,\n", - " sampling_strategy=\"sample\",\n", - " max_epochs=1\n", - ")\n", - "darts_estimator_tuned.fit(X, y)\n", - "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()\n" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "darts_estimator_tuned.set_params(\n", - " arch_updates_per_epoch=0,\n", - " param_updates_per_epoch=1000,\n", - " sampling_strategy=\"max\",\n", - " max_epochs=0\n", - ")\n", - "darts_estimator_tuned.fit(X, y)\n", - "show_results(estimator=darts_estimator_tuned, label=\"resampled DARTSRegressor\")\n", - "darts_estimator_tuned.visualize_model()\n" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.13" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} \ No newline at end of file diff --git a/example/sklearn/darts/weber.py b/example/sklearn/darts/weber.py deleted file mode 100644 index 18dda574e..000000000 --- a/example/sklearn/darts/weber.py +++ /dev/null @@ -1,140 +0,0 @@ -""" -Example file which shows some simple curve fitting using DARTSRegressor and some other estimators. -""" - -import logging -import pathlib -from functools import partial - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -from sklearn.linear_model import LinearRegression -from sklearn.model_selection import GridSearchCV -from sklearn.neural_network import MLPRegressor -from sklearn.pipeline import make_pipeline -from sklearn.preprocessing import PolynomialFeatures, StandardScaler - -from autora.skl.darts import PRIMITIVES, DARTSRegressor - -logging.basicConfig(level=logging.INFO) - -# %% Define some helper functions - - -def show_results_complete( - data_: pd.DataFrame, - estimator=None, - show_results=True, - projection="2d", - label=None, -): - """ - Function to plot input data (x_, y_) and the predictions of an estimator for the same x_. - """ - if projection == "2d": - plt.figure() - data_.plot.scatter( - "S1", "S2", c="difference_detected", cmap="viridis", zorder=10 - ) - elif projection == "3d": - fig = plt.figure() - ax = fig.add_subplot(projection="3d") - ax.scatter(data_["S1"], data["S2"], data["difference_detected"]) - if estimator is not None: - xs, ys = np.mgrid[0:5:0.2, 0:5:0.2] # type: ignore - zs = estimator.predict(np.column_stack((xs.ravel(), ys.ravel()))) - ax.plot_surface(xs, ys, zs.reshape(xs.shape), alpha=0.5) - - if label is not None: - plt.title(label) - - if show_results: - plt.show() - - return - - -# %% Load the data -datafile_path = pathlib.Path(__file__).parent.joinpath("./weber_data.csv") -data = pd.read_csv(datafile_path) -show_results = partial(show_results_complete, data_=data, projection="3d") -show_results(label="input data") -X = data[["S1", "S2"]] -y = data["difference_detected"] - -# %% Fit first using a super-simple linear regression -first_order_linear_estimator = LinearRegression() -first_order_linear_estimator.fit(X, y) -show_results(estimator=first_order_linear_estimator, label="1st order linear") - -# %% Fit using a 0-3 order polynomial, getting the best fit for the data. -polynomial_estimator = GridSearchCV( - make_pipeline(PolynomialFeatures(), LinearRegression(fit_intercept=False)), - param_grid=dict(polynomialfeatures__degree=range(4)), -) -polynomial_estimator.fit(X, y) -show_results(estimator=polynomial_estimator, label="[0th-3rd]-order linear") - -# %% Fit using DARTS with parameters we know work -darts_estimator_tuned = DARTSRegressor( - batch_size=64, - arch_updates_per_epoch=1, - param_updates_per_epoch=100, - max_epochs=500, - output_type="probability", - darts_type="original", - num_graph_nodes=2, - primitives=PRIMITIVES, -) -darts_estimator_tuned.fit(X, y) -show_results( - estimator=darts_estimator_tuned, label="pre-tuned Original-DARTS Regressor" -) -darts_estimator_tuned.visualize_model().view() - -# %% Fit using DARTS with parameters we know should work -darts_estimator_tuned = DARTSRegressor( - batch_size=64, - arch_updates_per_epoch=1, - param_updates_per_epoch=100, - max_epochs=500, - output_type="probability", - darts_type="fair", - num_graph_nodes=2, - primitives=["add", "subtract", "none"], -) -darts_estimator_tuned.fit(X, y) -show_results(estimator=darts_estimator_tuned, label="pre-tuned Fair-DARTS Regressor") -darts_estimator_tuned.visualize_model().view() - -# %% -darts_estimator_tuned.resample_model(sampling_strategy="sample") -show_results(estimator=darts_estimator_tuned, label="resampled DARTSRegressor") -darts_estimator_tuned.visualize_model().view() - -# %% Fit using DARTS with a Cross-Validation-Search -darts_estimator = GridSearchCV( - make_pipeline( - StandardScaler(), - DARTSRegressor( - batch_size=5, - arch_updates_per_epoch=1, - param_updates_per_epoch=500, - max_epochs=10, - output_type="probability", - ), - ), - param_grid=dict(dartsregressor__num_graph_nodes=range(1, 5)), - scoring="neg_mean_squared_error", - n_jobs=5, -) -darts_estimator.fit(X, y) -print(darts_estimator.best_params_) -show_results(estimator=darts_estimator.best_estimator_, label="DARTSRegressor") -darts_estimator.best_estimator_[1].visualize_model().view() - -# %% Fit using Multilayer-Perceptron -mlp_estimator = MLPRegressor() -mlp_estimator.fit(X, y) -show_results(estimator=mlp_estimator, label="Multilayer-Perceptron") diff --git a/example/sklearn/darts/weber_data.csv b/example/sklearn/darts/weber_data.csv deleted file mode 100644 index fc1b1243c..000000000 --- a/example/sklearn/darts/weber_data.csv +++ /dev/null @@ -1,211 +0,0 @@ -ID,S1,S2,difference_detected -0,0.0,0.0,0.5 -1,0.0,0.2631578947368421,0.5654124021530151 -2,0.0,0.5263157894736842,0.6286234259605408 -3,0.0,0.7894736842105263,0.6877183318138123 -4,0.0,1.0526315789473684,0.7412799000740051 -5,0.0,1.3157894736842104,0.7884804010391235 -6,0.0,1.5789473684210529,0.8290553689002991 -7,0.0,1.8421052631578947,0.8631975054740906 -8,0.0,2.1052631578947367,0.8914136290550232 -9,0.0,2.3684210526315788,0.9143873453140259 -10,0.0,2.631578947368421,0.9328665137290955 -11,0.0,2.8947368421052633,0.9475856423377991 -12,0.0,3.1578947368421053,0.9592186808586121 -13,0.0,3.421052631578948,0.9683560729026794 -14,0.0,3.684210526315789,0.975498378276825 -15,0.0,3.947368421052632,0.9810601472854614 -16,0.0,4.2105263157894735,0.9853783845901489 -17,0.0,4.473684210526316,0.9887233972549438 -18,0.0,4.7368421052631575,0.9913098812103271 -19,0.0,5.0,0.9933071732521057 -20,0.2631578947368421,0.2631578947368421,0.43458759784698486 -21,0.2631578947368421,0.5263157894736842,0.5 -22,0.2631578947368421,0.7894736842105263,0.5654124021530151 -23,0.2631578947368421,1.0526315789473684,0.6286234259605408 -24,0.2631578947368421,1.3157894736842104,0.6877183318138123 -25,0.2631578947368421,1.5789473684210529,0.7412799000740051 -26,0.2631578947368421,1.8421052631578947,0.7884804010391235 -27,0.2631578947368421,2.1052631578947367,0.8290553689002991 -28,0.2631578947368421,2.3684210526315788,0.8631975054740906 -29,0.2631578947368421,2.631578947368421,0.8914136290550232 -30,0.2631578947368421,2.8947368421052633,0.9143873453140259 -31,0.2631578947368421,3.1578947368421053,0.9328665137290955 -32,0.2631578947368421,3.421052631578948,0.9475856423377991 -33,0.2631578947368421,3.684210526315789,0.9592186808586121 -34,0.2631578947368421,3.947368421052632,0.9683560729026794 -35,0.2631578947368421,4.2105263157894735,0.975498378276825 -36,0.2631578947368421,4.473684210526316,0.9810601472854614 -37,0.2631578947368421,4.7368421052631575,0.9853783845901489 -38,0.2631578947368421,5.0,0.9887233972549438 -39,0.5263157894736842,0.5263157894736842,0.37137657403945923 -40,0.5263157894736842,0.7894736842105263,0.43458759784698486 -41,0.5263157894736842,1.0526315789473684,0.5 -42,0.5263157894736842,1.3157894736842104,0.5654124021530151 -43,0.5263157894736842,1.5789473684210529,0.6286234259605408 -44,0.5263157894736842,1.8421052631578947,0.6877183318138123 -45,0.5263157894736842,2.1052631578947367,0.7412799000740051 -46,0.5263157894736842,2.3684210526315788,0.7884804010391235 -47,0.5263157894736842,2.631578947368421,0.8290553689002991 -48,0.5263157894736842,2.8947368421052633,0.8631975054740906 -49,0.5263157894736842,3.1578947368421053,0.8914136290550232 -50,0.5263157894736842,3.421052631578948,0.9143873453140259 -51,0.5263157894736842,3.684210526315789,0.9328665137290955 -52,0.5263157894736842,3.947368421052632,0.9475856423377991 -53,0.5263157894736842,4.2105263157894735,0.9592186808586121 -54,0.5263157894736842,4.473684210526316,0.9683560729026794 -55,0.5263157894736842,4.7368421052631575,0.975498378276825 -56,0.5263157894736842,5.0,0.9810601472854614 -57,0.7894736842105263,0.7894736842105263,0.31228166818618774 -58,0.7894736842105263,1.0526315789473684,0.37137657403945923 -59,0.7894736842105263,1.3157894736842104,0.43458759784698486 -60,0.7894736842105263,1.5789473684210529,0.5 -61,0.7894736842105263,1.8421052631578947,0.5654124021530151 -62,0.7894736842105263,2.1052631578947367,0.6286234259605408 -63,0.7894736842105263,2.3684210526315788,0.6877182722091675 -64,0.7894736842105263,2.631578947368421,0.7412799000740051 -65,0.7894736842105263,2.8947368421052633,0.788480281829834 -66,0.7894736842105263,3.1578947368421053,0.8290553689002991 -67,0.7894736842105263,3.421052631578948,0.8631974458694458 -68,0.7894736842105263,3.684210526315789,0.8914136290550232 -69,0.7894736842105263,3.947368421052632,0.9143873453140259 -70,0.7894736842105263,4.2105263157894735,0.9328665137290955 -71,0.7894736842105263,4.473684210526316,0.9475856423377991 -72,0.7894736842105263,4.7368421052631575,0.9592186808586121 -73,0.7894736842105263,5.0,0.9683560729026794 -74,1.0526315789473684,1.0526315789473684,0.2587200701236725 -75,1.0526315789473684,1.3157894736842104,0.31228166818618774 -76,1.0526315789473684,1.5789473684210529,0.37137657403945923 -77,1.0526315789473684,1.8421052631578947,0.43458759784698486 -78,1.0526315789473684,2.1052631578947367,0.5 -79,1.0526315789473684,2.3684210526315788,0.5654124021530151 -80,1.0526315789473684,2.631578947368421,0.628623366355896 -81,1.0526315789473684,2.8947368421052633,0.6877182722091675 -82,1.0526315789473684,3.1578947368421053,0.7412799000740051 -83,1.0526315789473684,3.421052631578948,0.7884804010391235 -84,1.0526315789473684,3.684210526315789,0.8290553689002991 -85,1.0526315789473684,3.947368421052632,0.8631974458694458 -86,1.0526315789473684,4.2105263157894735,0.8914136290550232 -87,1.0526315789473684,4.473684210526316,0.9143873453140259 -88,1.0526315789473684,4.7368421052631575,0.9328665137290955 -89,1.0526315789473684,5.0,0.9475856423377991 -90,1.3157894736842104,1.3157894736842104,0.21151967346668243 -91,1.3157894736842104,1.5789473684210529,0.2587200999259949 -92,1.3157894736842104,1.8421052631578947,0.31228169798851013 -93,1.3157894736842104,2.1052631578947367,0.3713766038417816 -94,1.3157894736842104,2.3684210526315788,0.43458759784698486 -95,1.3157894736842104,2.631578947368421,0.5 -96,1.3157894736842104,2.8947368421052633,0.5654124021530151 -97,1.3157894736842104,3.1578947368421053,0.6286234855651855 -98,1.3157894736842104,3.421052631578948,0.6877183318138123 -99,1.3157894736842104,3.684210526315789,0.7412799000740051 -100,1.3157894736842104,3.947368421052632,0.7884804010391235 -101,1.3157894736842104,4.2105263157894735,0.8290553689002991 -102,1.3157894736842104,4.473684210526316,0.8631975054740906 -103,1.3157894736842104,4.7368421052631575,0.8914136290550232 -104,1.3157894736842104,5.0,0.9143873453140259 -105,1.5789473684210529,1.5789473684210529,0.17094460129737854 -106,1.5789473684210529,1.8421052631578947,0.21151965856552124 -107,1.5789473684210529,2.1052631578947367,0.2587200701236725 -108,1.5789473684210529,2.3684210526315788,0.31228166818618774 -109,1.5789473684210529,2.631578947368421,0.37137654423713684 -110,1.5789473684210529,2.8947368421052633,0.4345875084400177 -111,1.5789473684210529,3.1578947368421053,0.5 -112,1.5789473684210529,3.421052631578948,0.5654124021530151 -113,1.5789473684210529,3.684210526315789,0.6286234259605408 -114,1.5789473684210529,3.947368421052632,0.6877183318138123 -115,1.5789473684210529,4.2105263157894735,0.7412799000740051 -116,1.5789473684210529,4.473684210526316,0.788480281829834 -117,1.5789473684210529,4.7368421052631575,0.8290553689002991 -118,1.5789473684210529,5.0,0.8631974458694458 -119,1.8421052631578947,1.8421052631578947,0.13680249452590942 -120,1.8421052631578947,2.1052631578947367,0.17094461619853973 -121,1.8421052631578947,2.3684210526315788,0.21151967346668243 -122,1.8421052631578947,2.631578947368421,0.2587200701236725 -123,1.8421052631578947,2.8947368421052633,0.31228166818618774 -124,1.8421052631578947,3.1578947368421053,0.3713766038417816 -125,1.8421052631578947,3.421052631578948,0.43458759784698486 -126,1.8421052631578947,3.684210526315789,0.5 -127,1.8421052631578947,3.947368421052632,0.5654124021530151 -128,1.8421052631578947,4.2105263157894735,0.6286234259605408 -129,1.8421052631578947,4.473684210526316,0.6877183318138123 -130,1.8421052631578947,4.7368421052631575,0.7412799000740051 -131,1.8421052631578947,5.0,0.788480281829834 -132,2.1052631578947367,2.1052631578947367,0.10858631134033203 -133,2.1052631578947367,2.3684210526315788,0.13680247962474823 -134,2.1052631578947367,2.631578947368421,0.17094458639621735 -135,2.1052631578947367,2.8947368421052633,0.21151962876319885 -136,2.1052631578947367,3.1578947368421053,0.2587200701236725 -137,2.1052631578947367,3.421052631578948,0.31228166818618774 -138,2.1052631578947367,3.684210526315789,0.37137654423713684 -139,2.1052631578947367,3.947368421052632,0.4345875084400177 -140,2.1052631578947367,4.2105263157894735,0.5 -141,2.1052631578947367,4.473684210526316,0.5654124021530151 -142,2.1052631578947367,4.7368421052631575,0.628623366355896 -143,2.1052631578947367,5.0,0.6877182722091675 -144,2.3684210526315788,2.3684210526315788,0.08561266213655472 -145,2.3684210526315788,2.631578947368421,0.10858631134033203 -146,2.3684210526315788,2.8947368421052633,0.13680247962474823 -147,2.3684210526315788,3.1578947368421053,0.17094461619853973 -148,2.3684210526315788,3.421052631578948,0.21151967346668243 -149,2.3684210526315788,3.684210526315789,0.2587200701236725 -150,2.3684210526315788,3.947368421052632,0.31228166818618774 -151,2.3684210526315788,4.2105263157894735,0.3713766038417816 -152,2.3684210526315788,4.473684210526316,0.43458759784698486 -153,2.3684210526315788,4.7368421052631575,0.5 -154,2.3684210526315788,5.0,0.5654124021530151 -155,2.631578947368421,2.631578947368421,0.06713350117206573 -156,2.631578947368421,2.8947368421052633,0.08561266213655472 -157,2.631578947368421,3.1578947368421053,0.10858633369207382 -158,2.631578947368421,3.421052631578948,0.13680250942707062 -159,2.631578947368421,3.684210526315789,0.17094461619853973 -160,2.631578947368421,3.947368421052632,0.21151967346668243 -161,2.631578947368421,4.2105263157894735,0.25872012972831726 -162,2.631578947368421,4.473684210526316,0.3122817277908325 -163,2.631578947368421,4.7368421052631575,0.3713766038417816 -164,2.631578947368421,5.0,0.43458759784698486 -165,2.8947368421052633,2.8947368421052633,0.052414361387491226 -166,2.8947368421052633,3.1578947368421053,0.06713351607322693 -167,2.8947368421052633,3.421052631578948,0.08561268448829651 -168,2.8947368421052633,3.684210526315789,0.10858633369207382 -169,2.8947368421052633,3.947368421052632,0.13680250942707062 -170,2.8947368421052633,4.2105263157894735,0.17094466090202332 -171,2.8947368421052633,4.473684210526316,0.21151971817016602 -172,2.8947368421052633,4.7368421052631575,0.25872012972831726 -173,2.8947368421052633,5.0,0.3122817277908325 -174,3.1578947368421053,3.1578947368421053,0.04078132286667824 -175,3.1578947368421053,3.421052631578948,0.052414342761039734 -176,3.1578947368421053,3.684210526315789,0.06713348627090454 -177,3.1578947368421053,3.947368421052632,0.08561263978481293 -178,3.1578947368421053,4.2105263157894735,0.10858631134033203 -179,3.1578947368421053,4.473684210526316,0.13680247962474823 -180,3.1578947368421053,4.7368421052631575,0.17094458639621735 -181,3.1578947368421053,5.0,0.21151962876319885 -182,3.421052631578948,3.421052631578948,0.031643956899642944 -183,3.421052631578948,3.684210526315789,0.04078132286667824 -184,3.421052631578948,3.947368421052632,0.052414342761039734 -185,3.421052631578948,4.2105263157894735,0.06713350117206573 -186,3.421052631578948,4.473684210526316,0.08561266213655472 -187,3.421052631578948,4.7368421052631575,0.10858631134033203 -188,3.421052631578948,5.0,0.13680247962474823 -189,3.684210526315789,3.684210526315789,0.024501590058207512 -190,3.684210526315789,3.947368421052632,0.031643956899642944 -191,3.684210526315789,4.2105263157894735,0.04078133404254913 -192,3.684210526315789,4.473684210526316,0.052414361387491226 -193,3.684210526315789,4.7368421052631575,0.06713350117206573 -194,3.684210526315789,5.0,0.08561266213655472 -195,3.947368421052632,3.947368421052632,0.018939798697829247 -196,3.947368421052632,4.2105263157894735,0.02450159564614296 -197,3.947368421052632,4.473684210526316,0.03164396435022354 -198,3.947368421052632,4.7368421052631575,0.04078133404254913 -199,3.947368421052632,5.0,0.052414361387491226 -200,4.2105263157894735,4.2105263157894735,0.01462159026414156 -201,4.2105263157894735,4.473684210526316,0.0189397931098938 -202,4.2105263157894735,4.7368421052631575,0.024501584470272064 -203,4.2105263157894735,5.0,0.03164394944906235 -204,4.473684210526316,4.473684210526316,0.011276605539023876 -205,4.473684210526316,4.7368421052631575,0.01462159026414156 -206,4.473684210526316,5.0,0.0189397931098938 -207,4.7368421052631575,4.7368421052631575,0.008690104819834232 -208,4.7368421052631575,5.0,0.011276605539023876 -209,5.0,5.0,0.006692850962281227 diff --git a/mkdocs.yml b/mkdocs.yml index 4fd0c54cb..a41d901ec 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,9 +1,14 @@ # yaml-language-server: $schema=https://squidfunk.github.io/mkdocs-material/schema.json site_name: Autonomous Empirical Research +repo_url: 'https://github.com/autoresearch/autora' +edit_uri: 'blob/main/docs/' theme: name: material + custom_dir: mkdocs/overrides + features: + - content.action.edit watch: - autora/ @@ -12,7 +17,7 @@ plugins: - search - gen-files: scripts: - - docs/gen_ref_pages.py + - mkdocs/_gen_ref_pages.py - literate-nav: nav_file: SUMMARY.md - section-index @@ -21,6 +26,10 @@ plugins: python: import: - https://scikit-learn.org/stable/objects.inv + - mkdocs-jupyter: + include_source: true + execute: false + ignore_h1_titles: True markdown_extensions: @@ -35,27 +44,42 @@ extra_javascript: nav: - Introduction: 'index.md' +- Experimentalists: + - Overview: 'experimentalists/overview.md' + - Pipeline: 'pipeline/Experimentalist Pipeline Examples.ipynb' +- Synthetic Experiments: + - Inventory: 'synthetic/inventory.ipynb' - Theorists: - Overview: 'theorist/overview.md' - DARTS: - - Introduction: 'theorist/darts/introduction.md' - - How it works: 'theorist/darts/how_it_works.md' - - Meta parameters: 'theorist/darts/meta_parameters.md' - - Search space: 'theorist/darts/search_space.md' - - Example: 'theorist/darts/example.md' + - Introduction: 'theorist/darts/introduction.md' + - How it works: 'theorist/darts/how_it_works.md' + - Meta parameters: 'theorist/darts/meta_parameters.md' + - Search space: 'theorist/darts/search_space.md' + - Examples: + - Basic Usage: 'theorist/darts/example.ipynb' + - Weber-Fechner Law: 'theorist/darts/weber.ipynb' - BMS: - - Introduction: 'theorist/bms/introduction.md' - - How it works: 'theorist/bms/how_it_works.md' - - Meta parameters: 'theorist/bms/meta_parameters.md' - - Search space: 'theorist/bms/search_space.md' - - Example: 'theorist/bms/example.md' - - BSR: - - Introduction: 'theorist/bsr/introduction.md' - - How it works: 'theorist/bsr/how_it_works.md' - - Meta parameters: 'theorist/bsr/meta_parameters.md' - - Search space: 'theorist/bsr/search_space.md' - - Example: 'theorist/bsr/example.md' -- Experimentalists: - - Overview: 'experimentalists/overview.md' -- Code Reference: reference/ # - + - Introduction: 'theorist/bms/introduction.md' + - How it works: 'theorist/bms/how_it_works.md' + - Meta parameters: 'theorist/bms/meta_parameters.md' + - Search space: 'theorist/bms/search_space.ipynb' + - Examples: + - Basic Usage: 'theorist/bms/example.ipynb' + - Weber-Fechner Law: 'theorist/bms/weber.ipynb' + - BSR: + - Introduction: 'theorist/bsr/introduction.md' + - How it works: 'theorist/bsr/how_it_works.md' + - Meta parameters: 'theorist/bsr/meta_parameters.md' + - Search space: 'theorist/bsr/search_space.md' + - Example: 'theorist/bsr/bsr.ipynb' +- Cycle: + - Scoring: + - Logistic Regression: 'cycle/cycle_scoring.ipynb' + - BMS: 'cycle/cycle_scoring_bms.ipynb' + - Plotting: 'cycle/cycle_results_plots.ipynb' + - Examples: + - DARTS & BMS: 'cycle/simple_cycle_bms_darts.ipynb' + - BMS & Poppernet: 'cycle/simple_cycle_bms_model_poppernet.ipynb' + - Uncertainty Experimentalist: 'cycle/simple_cycle_uncertainty_experimentalist.ipynb' +- Code Reference: reference/autora/ diff --git a/docs/gen_ref_pages.py b/mkdocs/_gen_ref_pages.py similarity index 100% rename from docs/gen_ref_pages.py rename to mkdocs/_gen_ref_pages.py diff --git a/mkdocs/overrides/main.html b/mkdocs/overrides/main.html new file mode 100644 index 000000000..611f41563 --- /dev/null +++ b/mkdocs/overrides/main.html @@ -0,0 +1,19 @@ +{% extends "base.html" %} + +{% block content %} +{% if page.nb_url %} + + {% include ".icons/material/download.svg" %} + +{% endif %} +{% if page.file.src_uri %} + {% if page.file.src_uri.endswith('.ipynb') %} + + {% include ".icons/material/play-circle-outline.svg" %} + + {% endif %} +{% endif %} + +{{ super() }} +{% endblock content %} diff --git a/poetry.lock b/poetry.lock index 71305236f..7a9ee00a7 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,4 +1,4 @@ -# This file is automatically @generated by Poetry and should not be changed by hand. +# This file is automatically @generated by Poetry 1.4.1 and should not be changed by hand. [[package]] name = "anyio" @@ -157,14 +157,14 @@ files = [ [[package]] name = "beautifulsoup4" -version = "4.12.0" +version = "4.12.1" description = "Screen-scraping library" category = "dev" optional = false python-versions = ">=3.6.0" files = [ - {file = "beautifulsoup4-4.12.0-py3-none-any.whl", hash = "sha256:2130a5ad7f513200fae61a17abb5e338ca980fa28c439c0571014bc0217e9591"}, - {file = "beautifulsoup4-4.12.0.tar.gz", hash = "sha256:c5fceeaec29d09c84970e47c65f2f0efe57872f7cff494c9691a26ec0ff13234"}, + {file = "beautifulsoup4-4.12.1-py3-none-any.whl", hash = "sha256:e44795bb4f156d94abb5fbc56efff871c1045bfef72e9efe77558db9f9616ac3"}, + {file = "beautifulsoup4-4.12.1.tar.gz", hash = "sha256:c7bdbfb20a0dbe09518b96a809d93351b2e2bcb8046c0809466fa6632a10c257"}, ] [package.dependencies] @@ -686,14 +686,14 @@ pyflakes = ">=3.0.0,<3.1.0" [[package]] name = "fonttools" -version = "4.39.2" +version = "4.39.3" description = "Tools to manipulate font files" category = "main" optional = false python-versions = ">=3.8" files = [ - {file = "fonttools-4.39.2-py3-none-any.whl", hash = "sha256:85245aa2fd4cf502a643c9a9a2b5a393703e150a6eaacc3e0e84bb448053f061"}, - {file = "fonttools-4.39.2.zip", hash = "sha256:e2d9f10337c9e3b17f9bce17a60a16a885a7d23b59b7f45ce07ea643e5580439"}, + {file = "fonttools-4.39.3-py3-none-any.whl", hash = "sha256:64c0c05c337f826183637570ac5ab49ee220eec66cf50248e8df527edfa95aeb"}, + {file = "fonttools-4.39.3.zip", hash = "sha256:9234b9f57b74e31b192c3fc32ef1a40750a8fbc1cd9837a7b7bfc4ca4a5c51d7"}, ] [package.extras] @@ -759,14 +759,14 @@ test = ["coverage", "mock (>=4)", "pytest (>=7)", "pytest-cov", "pytest-mock (>= [[package]] name = "griffe" -version = "0.25.5" +version = "0.26.0" description = "Signatures for entire Python programs. Extract the structure, the frame, the skeleton of your project, to generate API documentation or find breaking changes in your API." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "griffe-0.25.5-py3-none-any.whl", hash = "sha256:1fb9edff48e66d4873014a2ebf21aca5f271d0006a4c937826e3cf592ffb3706"}, - {file = "griffe-0.25.5.tar.gz", hash = "sha256:11ea3403ef0560a1cbcf7f302eb5d21cf4c1d8ed3f8a16a75aa9f6f458caf3f1"}, + {file = "griffe-0.26.0-py3-none-any.whl", hash = "sha256:38f3f6bbe834501cc199a07b7b7e0e2550aaf19a9d1ee27acf879027e47c9b9e"}, + {file = "griffe-0.26.0.tar.gz", hash = "sha256:08675ffe8c17139e7769e950dd21f8e98a2e76205cbbd2911d5dec26d2cbf1be"}, ] [package.dependencies] @@ -921,14 +921,14 @@ test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio" [[package]] name = "ipython" -version = "8.11.0" +version = "8.12.0" description = "IPython: Productive Interactive Computing" category = "dev" optional = false python-versions = ">=3.8" files = [ - {file = "ipython-8.11.0-py3-none-any.whl", hash = "sha256:5b54478e459155a326bf5f42ee4f29df76258c0279c36f21d71ddb560f88b156"}, - {file = "ipython-8.11.0.tar.gz", hash = "sha256:735cede4099dbc903ee540307b9171fbfef4aa75cfcacc5a273b2cda2f02be04"}, + {file = "ipython-8.12.0-py3-none-any.whl", hash = "sha256:1c183bf61b148b00bcebfa5d9b39312733ae97f6dad90d7e9b4d86c8647f498c"}, + {file = "ipython-8.12.0.tar.gz", hash = "sha256:a950236df04ad75b5bc7f816f9af3d74dc118fd42f2ff7e80e8e60ca1f182e2d"}, ] [package.dependencies] @@ -944,6 +944,7 @@ prompt-toolkit = ">=3.0.30,<3.0.37 || >3.0.37,<3.1.0" pygments = ">=2.4.0" stack-data = "*" traitlets = ">=5" +typing-extensions = {version = "*", markers = "python_version < \"3.10\""} [package.extras] all = ["black", "curio", "docrepr", "ipykernel", "ipyparallel", "ipywidgets", "matplotlib", "matplotlib (!=3.2.0)", "nbconvert", "nbformat", "notebook", "numpy (>=1.21)", "pandas", "pytest (<7)", "pytest (<7.1)", "pytest-asyncio", "qtconsole", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "stack-data", "testpath", "trio", "typing-extensions"] @@ -1295,6 +1296,29 @@ files = [ {file = "jupyterlab_widgets-3.0.7.tar.gz", hash = "sha256:c3a50ed5bf528a0c7a869096503af54702f86dda1db469aee1c92dc0c01b43ca"}, ] +[[package]] +name = "jupytext" +version = "1.14.5" +description = "Jupyter notebooks as Markdown documents, Julia, Python or R scripts" +category = "dev" +optional = false +python-versions = "~=3.6" +files = [ + {file = "jupytext-1.14.5-py3-none-any.whl", hash = "sha256:a5dbe60d0ea158bbf82c2bce74aba8d0c220ad7edcda09e017c5eba229b34dc8"}, + {file = "jupytext-1.14.5.tar.gz", hash = "sha256:976e66be8056459a2067e0ec3ff68cc31e00c31895faf9eb893022d319e8f5b4"}, +] + +[package.dependencies] +markdown-it-py = ">=1.0.0,<3.0.0" +mdit-py-plugins = "*" +nbformat = "*" +pyyaml = "*" +toml = "*" + +[package.extras] +rst2md = ["sphinx-gallery (>=0.7.0,<0.8.0)"] +toml = ["toml"] + [[package]] name = "kiwisolver" version = "1.4.4" @@ -1402,6 +1426,31 @@ importlib-metadata = {version = ">=4.4", markers = "python_version < \"3.10\""} [package.extras] testing = ["coverage", "pyyaml"] +[[package]] +name = "markdown-it-py" +version = "2.2.0" +description = "Python port of markdown-it. Markdown parsing, done right!" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "markdown-it-py-2.2.0.tar.gz", hash = "sha256:7c9a5e412688bc771c67432cbfebcdd686c93ce6484913dccf06cb5a0bea35a1"}, + {file = "markdown_it_py-2.2.0-py3-none-any.whl", hash = "sha256:5a35f8d1870171d9acc47b99612dc146129b631baf04970128b568f190d0cc30"}, +] + +[package.dependencies] +mdurl = ">=0.1,<1.0" + +[package.extras] +benchmarking = ["psutil", "pytest", "pytest-benchmark"] +code-style = ["pre-commit (>=3.0,<4.0)"] +compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] +linkify = ["linkify-it-py (>=1,<3)"] +plugins = ["mdit-py-plugins"] +profiling = ["gprof2dot"] +rtd = ["attrs", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + [[package]] name = "markupsafe" version = "2.1.2" @@ -1552,6 +1601,38 @@ files = [ {file = "mccabe-0.7.0.tar.gz", hash = "sha256:348e0240c33b60bbdf4e523192ef919f28cb2c3d7d5c7794f74009290f236325"}, ] +[[package]] +name = "mdit-py-plugins" +version = "0.3.5" +description = "Collection of plugins for markdown-it-py" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mdit-py-plugins-0.3.5.tar.gz", hash = "sha256:eee0adc7195e5827e17e02d2a258a2ba159944a0748f59c5099a4a27f78fcf6a"}, + {file = "mdit_py_plugins-0.3.5-py3-none-any.whl", hash = "sha256:ca9a0714ea59a24b2b044a1831f48d817dd0c817e84339f20e7889f392d77c4e"}, +] + +[package.dependencies] +markdown-it-py = ">=1.0.0,<3.0.0" + +[package.extras] +code-style = ["pre-commit"] +rtd = ["attrs", "myst-parser (>=0.16.1,<0.17.0)", "sphinx-book-theme (>=0.1.0,<0.2.0)"] +testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] + +[[package]] +name = "mdurl" +version = "0.1.2" +description = "Markdown URL utilities" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, + {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, +] + [[package]] name = "mergedeep" version = "1.3.4" @@ -1636,6 +1717,28 @@ files = [ [package.dependencies] mkdocs = ">=1.0.3,<2.0.0" +[[package]] +name = "mkdocs-jupyter" +version = "0.24.1" +description = "Use Jupyter in mkdocs websites" +category = "dev" +optional = false +python-versions = ">=3.7" +files = [ + {file = "mkdocs_jupyter-0.24.1-py3-none-any.whl", hash = "sha256:759833c7d1528ae2d6337342786be7bc1e2235b0b98e9326427d4cf8d4eebee0"}, + {file = "mkdocs_jupyter-0.24.1.tar.gz", hash = "sha256:9677037fb7e931268f3df7599fc0828c261247df3d1575bced320ba8b7d1d46d"}, +] + +[package.dependencies] +jupytext = ">1.13.8,<2" +mkdocs = ">=1.4.0,<2" +mkdocs-material = ">9.0.0" +nbconvert = ">=7.2.9,<8" +pygments = ">2.12.0" + +[package.extras] +test = ["pytest", "pytest-cov"] + [[package]] name = "mkdocs-literate-nav" version = "0.6.0" @@ -1703,14 +1806,14 @@ mkdocs = ">=1.0.3" [[package]] name = "mkdocstrings" -version = "0.20.0" +version = "0.21.0" description = "Automatic documentation from sources, for MkDocs." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "mkdocstrings-0.20.0-py3-none-any.whl", hash = "sha256:f17fc2c4f760ec302b069075ef9e31045aa6372ca91d2f35ded3adba8e25a472"}, - {file = "mkdocstrings-0.20.0.tar.gz", hash = "sha256:c757f4f646d4f939491d6bc9256bfe33e36c5f8026392f49eaa351d241c838e5"}, + {file = "mkdocstrings-0.21.0-py3-none-any.whl", hash = "sha256:05c52573366f0a32536f7bf0258f2a8ad180836058bb024b252b8a61a25452b3"}, + {file = "mkdocstrings-0.21.0.tar.gz", hash = "sha256:df7399cec11bdc12ece9a370a6c37bac70ea0a07f479c051d0c82b07a38a3220"}, ] [package.dependencies] @@ -1762,14 +1865,14 @@ tests = ["pytest (>=4.6)"] [[package]] name = "nbclassic" -version = "0.5.3" +version = "0.5.5" description = "Jupyter Notebook as a Jupyter Server extension." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "nbclassic-0.5.3-py3-none-any.whl", hash = "sha256:e849277872d9ffd8fe4b39a8038d01ba82d6a1def9ce11b1b3c26c9546ed5131"}, - {file = "nbclassic-0.5.3.tar.gz", hash = "sha256:889772a7ba524eb781d2901f396540bcad41151e1f7e043f12ebc14a6540d342"}, + {file = "nbclassic-0.5.5-py3-none-any.whl", hash = "sha256:47791b04dbcb89bf7fde910a3d848fd4793a4248a8936202453631a87da37d51"}, + {file = "nbclassic-0.5.5.tar.gz", hash = "sha256:d2c91adc7909b0270c73e3e253d3687a6704b4f0a94bc156a37c85eba09f4d37"}, ] [package.dependencies] @@ -1798,14 +1901,14 @@ test = ["coverage", "nbval", "pytest", "pytest-cov", "pytest-jupyter", "pytest-p [[package]] name = "nbclient" -version = "0.7.2" +version = "0.7.3" description = "A client library for executing notebooks. Formerly nbconvert's ExecutePreprocessor." category = "dev" optional = false python-versions = ">=3.7.0" files = [ - {file = "nbclient-0.7.2-py3-none-any.whl", hash = "sha256:d97ac6257de2794f5397609df754fcbca1a603e94e924eb9b99787c031ae2e7c"}, - {file = "nbclient-0.7.2.tar.gz", hash = "sha256:884a3f4a8c4fc24bb9302f263e0af47d97f0d01fe11ba714171b320c8ac09547"}, + {file = "nbclient-0.7.3-py3-none-any.whl", hash = "sha256:8fa96f7e36693d5e83408f5e840f113c14a45c279befe609904dbe05dad646d1"}, + {file = "nbclient-0.7.3.tar.gz", hash = "sha256:26e41c6dca4d76701988bc34f64e1bfc2413ae6d368f13d7b5ac407efb08c755"}, ] [package.dependencies] @@ -1816,19 +1919,19 @@ traitlets = ">=5.3" [package.extras] dev = ["pre-commit"] -docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme"] -test = ["ipykernel", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] +docs = ["autodoc-traits", "mock", "moto", "myst-parser", "nbclient[test]", "sphinx (>=1.7)", "sphinx-book-theme", "sphinxcontrib-spelling"] +test = ["flaky", "ipykernel", "ipython", "ipywidgets", "nbconvert (>=7.0.0)", "pytest (>=7.0)", "pytest-asyncio", "pytest-cov (>=4.0)", "testpath", "xmltodict"] [[package]] name = "nbconvert" -version = "7.2.10" +version = "7.3.0" description = "Converting Jupyter Notebooks" category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "nbconvert-7.2.10-py3-none-any.whl", hash = "sha256:e41118f81698d3d59b3c7c2887937446048f741aba6c367c1c1a77810b3e2d08"}, - {file = "nbconvert-7.2.10.tar.gz", hash = "sha256:8eed67bd8314f3ec87c4351c2f674af3a04e5890ab905d6bd927c05aec1cf27d"}, + {file = "nbconvert-7.3.0-py3-none-any.whl", hash = "sha256:8983a83d0b083d56b076019f0a319f63bc16af70c9372892b86a0aab0a264b1d"}, + {file = "nbconvert-7.3.0.tar.gz", hash = "sha256:b970a13aba97529c223d805dd0706c2fe04dfc05e250ad4e6f7ae33daf6fede1"}, ] [package.dependencies] @@ -1894,20 +1997,20 @@ files = [ [[package]] name = "networkx" -version = "3.0" +version = "3.1" description = "Python package for creating and manipulating graphs and networks" category = "main" optional = false python-versions = ">=3.8" files = [ - {file = "networkx-3.0-py3-none-any.whl", hash = "sha256:58058d66b1818043527244fab9d41a51fcd7dcc271748015f3c181b8a90c8e2e"}, - {file = "networkx-3.0.tar.gz", hash = "sha256:9a9992345353618ae98339c2b63d8201c381c2944f38a2ab49cb45a4c667e412"}, + {file = "networkx-3.1-py3-none-any.whl", hash = "sha256:4f33f68cb2afcf86f28a45f43efc27a9386b535d567d2127f8f61d51dec58d36"}, + {file = "networkx-3.1.tar.gz", hash = "sha256:de346335408f84de0eada6ff9fafafff9bcda11f0a0dfaa931133debb146ab61"}, ] [package.extras] default = ["matplotlib (>=3.4)", "numpy (>=1.20)", "pandas (>=1.3)", "scipy (>=1.8)"] -developer = ["mypy (>=0.991)", "pre-commit (>=2.20)"] -doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.2)", "pydata-sphinx-theme (>=0.11)", "sphinx (==5.2.3)", "sphinx-gallery (>=0.11)", "texext (>=0.6.7)"] +developer = ["mypy (>=1.1)", "pre-commit (>=3.2)"] +doc = ["nb2plots (>=0.6)", "numpydoc (>=1.5)", "pillow (>=9.4)", "pydata-sphinx-theme (>=0.13)", "sphinx (>=6.1)", "sphinx-gallery (>=0.12)", "texext (>=0.6.7)"] extra = ["lxml (>=4.6)", "pydot (>=1.4.2)", "pygraphviz (>=1.10)", "sympy (>=1.10)"] test = ["codecov (>=2.1)", "pytest (>=7.2)", "pytest-cov (>=4.0)"] @@ -2322,93 +2425,82 @@ files = [ [[package]] name = "pillow" -version = "9.4.0" +version = "9.5.0" description = "Python Imaging Library (Fork)" category = "main" optional = false python-versions = ">=3.7" files = [ - {file = "Pillow-9.4.0-1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1b4b4e9dda4f4e4c4e6896f93e84a8f0bcca3b059de9ddf67dac3c334b1195e1"}, - {file = "Pillow-9.4.0-1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:fb5c1ad6bad98c57482236a21bf985ab0ef42bd51f7ad4e4538e89a997624e12"}, - {file = "Pillow-9.4.0-1-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:f0caf4a5dcf610d96c3bd32932bfac8aee61c96e60481c2a0ea58da435e25acd"}, - {file = "Pillow-9.4.0-1-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:3f4cc516e0b264c8d4ccd6b6cbc69a07c6d582d8337df79be1e15a5056b258c9"}, - {file = "Pillow-9.4.0-1-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:b8c2f6eb0df979ee99433d8b3f6d193d9590f735cf12274c108bd954e30ca858"}, - {file = "Pillow-9.4.0-1-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b70756ec9417c34e097f987b4d8c510975216ad26ba6e57ccb53bc758f490dab"}, - {file = "Pillow-9.4.0-1-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:43521ce2c4b865d385e78579a082b6ad1166ebed2b1a2293c3be1d68dd7ca3b9"}, - {file = "Pillow-9.4.0-2-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:9d9a62576b68cd90f7075876f4e8444487db5eeea0e4df3ba298ee38a8d067b0"}, - {file = "Pillow-9.4.0-2-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:87708d78a14d56a990fbf4f9cb350b7d89ee8988705e58e39bdf4d82c149210f"}, - {file = "Pillow-9.4.0-2-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:8a2b5874d17e72dfb80d917213abd55d7e1ed2479f38f001f264f7ce7bae757c"}, - {file = "Pillow-9.4.0-2-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:83125753a60cfc8c412de5896d10a0a405e0bd88d0470ad82e0869ddf0cb3848"}, - {file = "Pillow-9.4.0-2-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:9e5f94742033898bfe84c93c831a6f552bb629448d4072dd312306bab3bd96f1"}, - {file = "Pillow-9.4.0-2-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:013016af6b3a12a2f40b704677f8b51f72cb007dac785a9933d5c86a72a7fe33"}, - {file = "Pillow-9.4.0-2-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:99d92d148dd03fd19d16175b6d355cc1b01faf80dae93c6c3eb4163709edc0a9"}, - {file = "Pillow-9.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:2968c58feca624bb6c8502f9564dd187d0e1389964898f5e9e1fbc8533169157"}, - {file = "Pillow-9.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c5c1362c14aee73f50143d74389b2c158707b4abce2cb055b7ad37ce60738d47"}, - {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bd752c5ff1b4a870b7661234694f24b1d2b9076b8bf337321a814c612665f343"}, - {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9a3049a10261d7f2b6514d35bbb7a4dfc3ece4c4de14ef5876c4b7a23a0e566d"}, - {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16a8df99701f9095bea8a6c4b3197da105df6f74e6176c5b410bc2df2fd29a57"}, - {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:94cdff45173b1919350601f82d61365e792895e3c3a3443cf99819e6fbf717a5"}, - {file = "Pillow-9.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:ed3e4b4e1e6de75fdc16d3259098de7c6571b1a6cc863b1a49e7d3d53e036070"}, - {file = "Pillow-9.4.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d5b2f8a31bd43e0f18172d8ac82347c8f37ef3e0b414431157718aa234991b28"}, - {file = "Pillow-9.4.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:09b89ddc95c248ee788328528e6a2996e09eaccddeeb82a5356e92645733be35"}, - {file = "Pillow-9.4.0-cp310-cp310-win32.whl", hash = "sha256:f09598b416ba39a8f489c124447b007fe865f786a89dbfa48bb5cf395693132a"}, - {file = "Pillow-9.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:f6e78171be3fb7941f9910ea15b4b14ec27725865a73c15277bc39f5ca4f8391"}, - {file = "Pillow-9.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:3fa1284762aacca6dc97474ee9c16f83990b8eeb6697f2ba17140d54b453e133"}, - {file = "Pillow-9.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:eaef5d2de3c7e9b21f1e762f289d17b726c2239a42b11e25446abf82b26ac132"}, - {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a4dfdae195335abb4e89cc9762b2edc524f3c6e80d647a9a81bf81e17e3fb6f0"}, - {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6abfb51a82e919e3933eb137e17c4ae9c0475a25508ea88993bb59faf82f3b35"}, - {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:451f10ef963918e65b8869e17d67db5e2f4ab40e716ee6ce7129b0cde2876eab"}, - {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:6663977496d616b618b6cfa43ec86e479ee62b942e1da76a2c3daa1c75933ef4"}, - {file = "Pillow-9.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:60e7da3a3ad1812c128750fc1bc14a7ceeb8d29f77e0a2356a8fb2aa8925287d"}, - {file = "Pillow-9.4.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:19005a8e58b7c1796bc0167862b1f54a64d3b44ee5d48152b06bb861458bc0f8"}, - {file = "Pillow-9.4.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:f715c32e774a60a337b2bb8ad9839b4abf75b267a0f18806f6f4f5f1688c4b5a"}, - {file = "Pillow-9.4.0-cp311-cp311-win32.whl", hash = "sha256:b222090c455d6d1a64e6b7bb5f4035c4dff479e22455c9eaa1bdd4c75b52c80c"}, - {file = "Pillow-9.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:ba6612b6548220ff5e9df85261bddc811a057b0b465a1226b39bfb8550616aee"}, - {file = "Pillow-9.4.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5f532a2ad4d174eb73494e7397988e22bf427f91acc8e6ebf5bb10597b49c493"}, - {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dd5a9c3091a0f414a963d427f920368e2b6a4c2f7527fdd82cde8ef0bc7a327"}, - {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef21af928e807f10bf4141cad4746eee692a0dd3ff56cfb25fce076ec3cc8abe"}, - {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:847b114580c5cc9ebaf216dd8c8dbc6b00a3b7ab0131e173d7120e6deade1f57"}, - {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:653d7fb2df65efefbcbf81ef5fe5e5be931f1ee4332c2893ca638c9b11a409c4"}, - {file = "Pillow-9.4.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:46f39cab8bbf4a384ba7cb0bc8bae7b7062b6a11cfac1ca4bc144dea90d4a9f5"}, - {file = "Pillow-9.4.0-cp37-cp37m-win32.whl", hash = "sha256:7ac7594397698f77bce84382929747130765f66406dc2cd8b4ab4da68ade4c6e"}, - {file = "Pillow-9.4.0-cp37-cp37m-win_amd64.whl", hash = "sha256:46c259e87199041583658457372a183636ae8cd56dbf3f0755e0f376a7f9d0e6"}, - {file = "Pillow-9.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:0e51f608da093e5d9038c592b5b575cadc12fd748af1479b5e858045fff955a9"}, - {file = "Pillow-9.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:765cb54c0b8724a7c12c55146ae4647e0274a839fb6de7bcba841e04298e1011"}, - {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:519e14e2c49fcf7616d6d2cfc5c70adae95682ae20f0395e9280db85e8d6c4df"}, - {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d197df5489004db87d90b918033edbeee0bd6df3848a204bca3ff0a903bef837"}, - {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0845adc64fe9886db00f5ab68c4a8cd933ab749a87747555cec1c95acea64b0b"}, - {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:e1339790c083c5a4de48f688b4841f18df839eb3c9584a770cbd818b33e26d5d"}, - {file = "Pillow-9.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:a96e6e23f2b79433390273eaf8cc94fec9c6370842e577ab10dabdcc7ea0a66b"}, - {file = "Pillow-9.4.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:7cfc287da09f9d2a7ec146ee4d72d6ea1342e770d975e49a8621bf54eaa8f30f"}, - {file = "Pillow-9.4.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d7081c084ceb58278dd3cf81f836bc818978c0ccc770cbbb202125ddabec6628"}, - {file = "Pillow-9.4.0-cp38-cp38-win32.whl", hash = "sha256:df41112ccce5d47770a0c13651479fbcd8793f34232a2dd9faeccb75eb5d0d0d"}, - {file = "Pillow-9.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:7a21222644ab69ddd9967cfe6f2bb420b460dae4289c9d40ff9a4896e7c35c9a"}, - {file = "Pillow-9.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0f3269304c1a7ce82f1759c12ce731ef9b6e95b6df829dccd9fe42912cc48569"}, - {file = "Pillow-9.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:cb362e3b0976dc994857391b776ddaa8c13c28a16f80ac6522c23d5257156bed"}, - {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a2e0f87144fcbbe54297cae708c5e7f9da21a4646523456b00cc956bd4c65815"}, - {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:28676836c7796805914b76b1837a40f76827ee0d5398f72f7dcc634bae7c6264"}, - {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0884ba7b515163a1a05440a138adeb722b8a6ae2c2b33aea93ea3118dd3a899e"}, - {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:53dcb50fbdc3fb2c55431a9b30caeb2f7027fcd2aeb501459464f0214200a503"}, - {file = "Pillow-9.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:e8c5cf126889a4de385c02a2c3d3aba4b00f70234bfddae82a5eaa3ee6d5e3e6"}, - {file = "Pillow-9.4.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:6c6b1389ed66cdd174d040105123a5a1bc91d0aa7059c7261d20e583b6d8cbd2"}, - {file = "Pillow-9.4.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0dd4c681b82214b36273c18ca7ee87065a50e013112eea7d78c7a1b89a739153"}, - {file = "Pillow-9.4.0-cp39-cp39-win32.whl", hash = "sha256:6d9dfb9959a3b0039ee06c1a1a90dc23bac3b430842dcb97908ddde05870601c"}, - {file = "Pillow-9.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:54614444887e0d3043557d9dbc697dbb16cfb5a35d672b7a0fcc1ed0cf1c600b"}, - {file = "Pillow-9.4.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b9b752ab91e78234941e44abdecc07f1f0d8f51fb62941d32995b8161f68cfe5"}, - {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3b56206244dc8711f7e8b7d6cad4663917cd5b2d950799425076681e8766286"}, - {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aabdab8ec1e7ca7f1434d042bf8b1e92056245fb179790dc97ed040361f16bfd"}, - {file = "Pillow-9.4.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:db74f5562c09953b2c5f8ec4b7dfd3f5421f31811e97d1dbc0a7c93d6e3a24df"}, - {file = "Pillow-9.4.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e9d7747847c53a16a729b6ee5e737cf170f7a16611c143d95aa60a109a59c336"}, - {file = "Pillow-9.4.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:b52ff4f4e002f828ea6483faf4c4e8deea8d743cf801b74910243c58acc6eda3"}, - {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:575d8912dca808edd9acd6f7795199332696d3469665ef26163cd090fa1f8bfa"}, - {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3c4ed2ff6760e98d262e0cc9c9a7f7b8a9f61aa4d47c58835cdaf7b0b8811bb"}, - {file = "Pillow-9.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e621b0246192d3b9cb1dc62c78cfa4c6f6d2ddc0ec207d43c0dedecb914f152a"}, - {file = "Pillow-9.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:8f127e7b028900421cad64f51f75c051b628db17fb00e099eb148761eed598c9"}, - {file = "Pillow-9.4.0.tar.gz", hash = "sha256:a1c2d7780448eb93fbcc3789bf3916aa5720d942e37945f4056680317f1cd23e"}, -] - -[package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-issues (>=3.0.1)", "sphinx-removed-in", "sphinxext-opengraph"] + {file = "Pillow-9.5.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:ace6ca218308447b9077c14ea4ef381ba0b67ee78d64046b3f19cf4e1139ad16"}, + {file = "Pillow-9.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d3d403753c9d5adc04d4694d35cf0391f0f3d57c8e0030aac09d7678fa8030aa"}, + {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ba1b81ee69573fe7124881762bb4cd2e4b6ed9dd28c9c60a632902fe8db8b38"}, + {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fe7e1c262d3392afcf5071df9afa574544f28eac825284596ac6db56e6d11062"}, + {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f36397bf3f7d7c6a3abdea815ecf6fd14e7fcd4418ab24bae01008d8d8ca15e"}, + {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:252a03f1bdddce077eff2354c3861bf437c892fb1832f75ce813ee94347aa9b5"}, + {file = "Pillow-9.5.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:85ec677246533e27770b0de5cf0f9d6e4ec0c212a1f89dfc941b64b21226009d"}, + {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b416f03d37d27290cb93597335a2f85ed446731200705b22bb927405320de903"}, + {file = "Pillow-9.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:1781a624c229cb35a2ac31cc4a77e28cafc8900733a864870c49bfeedacd106a"}, + {file = "Pillow-9.5.0-cp310-cp310-win32.whl", hash = "sha256:8507eda3cd0608a1f94f58c64817e83ec12fa93a9436938b191b80d9e4c0fc44"}, + {file = "Pillow-9.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:d3c6b54e304c60c4181da1c9dadf83e4a54fd266a99c70ba646a9baa626819eb"}, + {file = "Pillow-9.5.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:7ec6f6ce99dab90b52da21cf0dc519e21095e332ff3b399a357c187b1a5eee32"}, + {file = "Pillow-9.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:560737e70cb9c6255d6dcba3de6578a9e2ec4b573659943a5e7e4af13f298f5c"}, + {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:96e88745a55b88a7c64fa49bceff363a1a27d9a64e04019c2281049444a571e3"}, + {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d9c206c29b46cfd343ea7cdfe1232443072bbb270d6a46f59c259460db76779a"}, + {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cfcc2c53c06f2ccb8976fb5c71d448bdd0a07d26d8e07e321c103416444c7ad1"}, + {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:a0f9bb6c80e6efcde93ffc51256d5cfb2155ff8f78292f074f60f9e70b942d99"}, + {file = "Pillow-9.5.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:8d935f924bbab8f0a9a28404422da8af4904e36d5c33fc6f677e4c4485515625"}, + {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:fed1e1cf6a42577953abbe8e6cf2fe2f566daebde7c34724ec8803c4c0cda579"}, + {file = "Pillow-9.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c1170d6b195555644f0616fd6ed929dfcf6333b8675fcca044ae5ab110ded296"}, + {file = "Pillow-9.5.0-cp311-cp311-win32.whl", hash = "sha256:54f7102ad31a3de5666827526e248c3530b3a33539dbda27c6843d19d72644ec"}, + {file = "Pillow-9.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:cfa4561277f677ecf651e2b22dc43e8f5368b74a25a8f7d1d4a3a243e573f2d4"}, + {file = "Pillow-9.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:965e4a05ef364e7b973dd17fc765f42233415974d773e82144c9bbaaaea5d089"}, + {file = "Pillow-9.5.0-cp312-cp312-win32.whl", hash = "sha256:22baf0c3cf0c7f26e82d6e1adf118027afb325e703922c8dfc1d5d0156bb2eeb"}, + {file = "Pillow-9.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:432b975c009cf649420615388561c0ce7cc31ce9b2e374db659ee4f7d57a1f8b"}, + {file = "Pillow-9.5.0-cp37-cp37m-macosx_10_10_x86_64.whl", hash = "sha256:5d4ebf8e1db4441a55c509c4baa7a0587a0210f7cd25fcfe74dbbce7a4bd1906"}, + {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:375f6e5ee9620a271acb6820b3d1e94ffa8e741c0601db4c0c4d3cb0a9c224bf"}, + {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:99eb6cafb6ba90e436684e08dad8be1637efb71c4f2180ee6b8f940739406e78"}, + {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dfaaf10b6172697b9bceb9a3bd7b951819d1ca339a5ef294d1f1ac6d7f63270"}, + {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_aarch64.whl", hash = "sha256:763782b2e03e45e2c77d7779875f4432e25121ef002a41829d8868700d119392"}, + {file = "Pillow-9.5.0-cp37-cp37m-manylinux_2_28_x86_64.whl", hash = "sha256:35f6e77122a0c0762268216315bf239cf52b88865bba522999dc38f1c52b9b47"}, + {file = "Pillow-9.5.0-cp37-cp37m-win32.whl", hash = "sha256:aca1c196f407ec7cf04dcbb15d19a43c507a81f7ffc45b690899d6a76ac9fda7"}, + {file = "Pillow-9.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:322724c0032af6692456cd6ed554bb85f8149214d97398bb80613b04e33769f6"}, + {file = "Pillow-9.5.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:a0aa9417994d91301056f3d0038af1199eb7adc86e646a36b9e050b06f526597"}, + {file = "Pillow-9.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f8286396b351785801a976b1e85ea88e937712ee2c3ac653710a4a57a8da5d9c"}, + {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c830a02caeb789633863b466b9de10c015bded434deb3ec87c768e53752ad22a"}, + {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fbd359831c1657d69bb81f0db962905ee05e5e9451913b18b831febfe0519082"}, + {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8fc330c3370a81bbf3f88557097d1ea26cd8b019d6433aa59f71195f5ddebbf"}, + {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:7002d0797a3e4193c7cdee3198d7c14f92c0836d6b4a3f3046a64bd1ce8df2bf"}, + {file = "Pillow-9.5.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:229e2c79c00e85989a34b5981a2b67aa079fd08c903f0aaead522a1d68d79e51"}, + {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:9adf58f5d64e474bed00d69bcd86ec4bcaa4123bfa70a65ce72e424bfb88ed96"}, + {file = "Pillow-9.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:662da1f3f89a302cc22faa9f14a262c2e3951f9dbc9617609a47521c69dd9f8f"}, + {file = "Pillow-9.5.0-cp38-cp38-win32.whl", hash = "sha256:6608ff3bf781eee0cd14d0901a2b9cc3d3834516532e3bd673a0a204dc8615fc"}, + {file = "Pillow-9.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:e49eb4e95ff6fd7c0c402508894b1ef0e01b99a44320ba7d8ecbabefddcc5569"}, + {file = "Pillow-9.5.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:482877592e927fd263028c105b36272398e3e1be3269efda09f6ba21fd83ec66"}, + {file = "Pillow-9.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3ded42b9ad70e5f1754fb7c2e2d6465a9c842e41d178f262e08b8c85ed8a1d8e"}, + {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c446d2245ba29820d405315083d55299a796695d747efceb5717a8b450324115"}, + {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8aca1152d93dcc27dc55395604dcfc55bed5f25ef4c98716a928bacba90d33a3"}, + {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:608488bdcbdb4ba7837461442b90ea6f3079397ddc968c31265c1e056964f1ef"}, + {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:60037a8db8750e474af7ffc9faa9b5859e6c6d0a50e55c45576bf28be7419705"}, + {file = "Pillow-9.5.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:07999f5834bdc404c442146942a2ecadd1cb6292f5229f4ed3b31e0a108746b1"}, + {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:a127ae76092974abfbfa38ca2d12cbeddcdeac0fb71f9627cc1135bedaf9d51a"}, + {file = "Pillow-9.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:489f8389261e5ed43ac8ff7b453162af39c3e8abd730af8363587ba64bb2e865"}, + {file = "Pillow-9.5.0-cp39-cp39-win32.whl", hash = "sha256:9b1af95c3a967bf1da94f253e56b6286b50af23392a886720f563c547e48e964"}, + {file = "Pillow-9.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:77165c4a5e7d5a284f10a6efaa39a0ae8ba839da344f20b111d62cc932fa4e5d"}, + {file = "Pillow-9.5.0-pp38-pypy38_pp73-macosx_10_10_x86_64.whl", hash = "sha256:833b86a98e0ede388fa29363159c9b1a294b0905b5128baf01db683672f230f5"}, + {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aaf305d6d40bd9632198c766fb64f0c1a83ca5b667f16c1e79e1661ab5060140"}, + {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0852ddb76d85f127c135b6dd1f0bb88dbb9ee990d2cd9aa9e28526c93e794fba"}, + {file = "Pillow-9.5.0-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:91ec6fe47b5eb5a9968c79ad9ed78c342b1f97a091677ba0e012701add857829"}, + {file = "Pillow-9.5.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:cb841572862f629b99725ebaec3287fc6d275be9b14443ea746c1dd325053cbd"}, + {file = "Pillow-9.5.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:c380b27d041209b849ed246b111b7c166ba36d7933ec6e41175fd15ab9eb1572"}, + {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7c9af5a3b406a50e313467e3565fc99929717f780164fe6fbb7704edba0cebbe"}, + {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5671583eab84af046a397d6d0ba25343c00cd50bce03787948e0fff01d4fd9b1"}, + {file = "Pillow-9.5.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:84a6f19ce086c1bf894644b43cd129702f781ba5751ca8572f08aa40ef0ab7b7"}, + {file = "Pillow-9.5.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:1e7723bd90ef94eda669a3c2c19d549874dd5badaeefabefd26053304abe5799"}, + {file = "Pillow-9.5.0.tar.gz", hash = "sha256:bf548479d336726d7a0eceb6e767e179fbde37833ae42794602631a070d630f1"}, +] + +[package.extras] +docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] [[package]] @@ -2457,14 +2549,14 @@ testing = ["pytest", "pytest-benchmark"] [[package]] name = "pre-commit" -version = "3.2.1" +version = "3.2.2" description = "A framework for managing and maintaining multi-language pre-commit hooks." category = "dev" optional = false python-versions = ">=3.8" files = [ - {file = "pre_commit-3.2.1-py2.py3-none-any.whl", hash = "sha256:a06a7fcce7f420047a71213c175714216498b49ebc81fe106f7716ca265f5bb6"}, - {file = "pre_commit-3.2.1.tar.gz", hash = "sha256:b5aee7d75dbba21ee161ba641b01e7ae10c5b91967ebf7b2ab0dfae12d07e1f1"}, + {file = "pre_commit-3.2.2-py2.py3-none-any.whl", hash = "sha256:0b4210aea813fe81144e87c5a291f09ea66f199f367fa1df41b55e1d26e1e2b4"}, + {file = "pre_commit-3.2.2.tar.gz", hash = "sha256:5b808fcbda4afbccf6d6633a56663fed35b6c2bc08096fd3d47ce197ac351d9d"}, ] [package.dependencies] @@ -2730,14 +2822,14 @@ files = [ [[package]] name = "pytz" -version = "2023.2" +version = "2023.3" description = "World timezone definitions, modern and historical" category = "main" optional = false python-versions = "*" files = [ - {file = "pytz-2023.2-py2.py3-none-any.whl", hash = "sha256:8a8baaf1e237175b02f5c751eea67168043a749c843989e2b3015aa1ad9db68b"}, - {file = "pytz-2023.2.tar.gz", hash = "sha256:a27dcf612c05d2ebde626f7d506555f10dfc815b3eddccfaadfc7d99b11c9a07"}, + {file = "pytz-2023.3-py2.py3-none-any.whl", hash = "sha256:a151b3abb88eda1d4e34a9814df37de2a80e301e68ba0fd856fb9b46bfbbbffb"}, + {file = "pytz-2023.3.tar.gz", hash = "sha256:1d8ce29db189191fb55338ee6d0387d82ab59f3d00eac103412d64e0ebd0c588"}, ] [[package]] @@ -2937,14 +3029,14 @@ cffi = {version = "*", markers = "implementation_name == \"pypy\""} [[package]] name = "qtconsole" -version = "5.4.1" +version = "5.4.2" description = "Jupyter Qt console" category = "dev" optional = false python-versions = ">= 3.7" files = [ - {file = "qtconsole-5.4.1-py3-none-any.whl", hash = "sha256:bae8c7e10170cdcdcaf7e6d53ad7d6a7412249b9b8310a0eaa6b6f3b260f32db"}, - {file = "qtconsole-5.4.1.tar.gz", hash = "sha256:f67a03f40f722e13261791280f73068dbaf9dafcc335cbba644ccc8f892640e5"}, + {file = "qtconsole-5.4.2-py3-none-any.whl", hash = "sha256:30975c6a7d7941dd646d00a23e5982db49beaa60c3920bb243727d43da805f12"}, + {file = "qtconsole-5.4.2.tar.gz", hash = "sha256:dc935780da276a2ab31a7a08a8cf327a2ea47fa27e21d485073251a7eeb16167"}, ] [package.dependencies] @@ -2964,14 +3056,14 @@ test = ["flaky", "pytest", "pytest-qt"] [[package]] name = "qtpy" -version = "2.3.0" +version = "2.3.1" description = "Provides an abstraction layer on top of the various Qt bindings (PyQt5/6 and PySide2/6)." category = "dev" optional = false python-versions = ">=3.7" files = [ - {file = "QtPy-2.3.0-py3-none-any.whl", hash = "sha256:8d6d544fc20facd27360ea189592e6135c614785f0dec0b4f083289de6beb408"}, - {file = "QtPy-2.3.0.tar.gz", hash = "sha256:0603c9c83ccc035a4717a12908bf6bc6cb22509827ea2ec0e94c2da7c9ed57c5"}, + {file = "QtPy-2.3.1-py3-none-any.whl", hash = "sha256:5193d20e0b16e4d9d3bc2c642d04d9f4e2c892590bd1b9c92bfe38a95d5a2e12"}, + {file = "QtPy-2.3.1.tar.gz", hash = "sha256:a8c74982d6d172ce124d80cafd39653df78989683f760f2281ba91a6e7b9de8b"}, ] [package.dependencies] @@ -3222,14 +3314,14 @@ win32 = ["pywin32"] [[package]] name = "setuptools" -version = "67.6.0" +version = "67.6.1" description = "Easily download, build, install, upgrade, and uninstall Python packages" category = "main" optional = false python-versions = ">=3.7" files = [ - {file = "setuptools-67.6.0-py3-none-any.whl", hash = "sha256:b78aaa36f6b90a074c1fa651168723acbf45d14cb1196b6f02c0fd07f17623b2"}, - {file = "setuptools-67.6.0.tar.gz", hash = "sha256:2ee892cd5f29f3373097f5a814697e397cf3ce313616df0af11231e2ad118077"}, + {file = "setuptools-67.6.1-py3-none-any.whl", hash = "sha256:e728ca814a823bf7bf60162daf9db95b93d532948c4c0bea762ce62f60189078"}, + {file = "setuptools-67.6.1.tar.gz", hash = "sha256:257de92a9d50a60b8e22abfcbb771571fde0dbf3ec234463212027a4eeecbe9a"}, ] [package.extras] @@ -3371,6 +3463,18 @@ webencodings = ">=0.4" doc = ["sphinx", "sphinx_rtd_theme"] test = ["flake8", "isort", "pytest"] +[[package]] +name = "toml" +version = "0.10.2" +description = "Python Library for Tom's Obvious, Minimal Language" +category = "dev" +optional = false +python-versions = ">=2.6, !=3.0.*, !=3.1.*, !=3.2.*" +files = [ + {file = "toml-0.10.2-py2.py3-none-any.whl", hash = "sha256:806143ae5bfb6a3c6e736a764057db0e6a0e05e338b5630894a5f779cabb4f9b"}, + {file = "toml-0.10.2.tar.gz", hash = "sha256:b3bda1d108d5dd99f4a20d24d9c348e91c4db7ab1b749200bded2f839ccbe68f"}, +] + [[package]] name = "tomli" version = "2.0.1" @@ -3758,4 +3862,4 @@ tinkerforge = ["tinkerforge"] [metadata] lock-version = "2.0" python-versions = ">=3.8.10,<3.11" -content-hash = "cd15a9522077c181db8a206c2d934a3b21d4a4dd70299fb5c0d8ac23ebf81d55" +content-hash = "b7321e5061e9b302290ca59115fd79daf9f86e2db7595b565b8d4929916cd635" diff --git a/pyproject.toml b/pyproject.toml index 39c8df04c..c158f6c70 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -47,6 +47,7 @@ mkdocs-gen-files = ">=0.3.4,<0.5.0" mkdocs-literate-nav = ">=0.4.1,<0.7.0" mkdocs-section-index = "^0.3.4" mkdocstrings-python = ">=0.7.1,<0.10.0" +mkdocs-jupyter = "^0.24.1" [build-system] requires = ["poetry-core>=1.0.0"]