{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "3950394e",
   "metadata": {},
   "source": [
    "# A simple symbolic regression example"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b2e278b",
   "metadata": {},
   "source": [
    "This notebook implements a **symbolic regression pipeline** based on **Genetic Programming (GP)** using the `flex` framework and its custom `GPSymbolicRegressor`.\n",
    "\n",
    "The goal is to discover analytical expressions that best fit a given `PMLB` dataset by:\n",
    "- evolving symbolic expressions;\n",
    "- optimizing embedded numerical constants;\n",
    "- penalizing overly complex expressions;\n",
    "- evaluating performance on training and test datasets.\n",
    "\n",
    "The code supports:\n",
    "- multi-variable regression problems;\n",
    "- automatic constant tuning using gradient-based optimization;\n",
    "- parallel execution using Ray."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d87649c",
   "metadata": {},
   "source": [
    "## Imports and Dependencies"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e49fc0b8",
   "metadata": {},
   "source": [
    "First, we import all the required libraries for:\n",
    "\n",
    "- **Genetic Programming**: `deap.gp`, custom `flex.gp` utilities\n",
    "- **Numerical computation**: `numpy`, `mygrad`\n",
    "- **Optimization**: `pygmo` (for constant fitting)\n",
    "- **Machine Learning utilities**: `scikit-learn`\n",
    "- **Parallelism**: `ray`\n",
    "- **Dataset generation**: custom `generate_dataset` function\n",
    "\n",
    "The code relies on both evolutionary optimization (for structure) and gradient-based optimization (for constants)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "0c69ee88-9958-4bd4-820c-ef8773eab4d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env: RAY_ACCEL_ENV_VAR_OVERRIDE_ON_ZERO=0\n"
     ]
    }
   ],
   "source": [
    "%env RAY_ACCEL_ENV_VAR_OVERRIDE_ON_ZERO=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "07bf41f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from deap import gp\n",
    "\n",
    "from flex.gp import regressor as gps\n",
    "from flex.gp.util import (\n",
    "    detect_nested_trigonometric_functions,\n",
    "    load_config_data,\n",
    "    compile_individual_with_consts,\n",
    ")\n",
    "from flex.gp.primitives import add_primitives_to_pset_from_dict\n",
    "import numpy as np\n",
    "import ray\n",
    "\n",
    "import warnings\n",
    "import pygmo as pg\n",
    "\n",
    "import re\n",
    "from sklearn.metrics import r2_score\n",
    "\n",
    "import time\n",
    "\n",
    "import mygrad as mg\n",
    "from mygrad._utils.lock_management import mem_guard_off\n",
    "\n",
    "from functools import partial\n",
    "\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from pmlb import fetch_data\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "cdf63d53-52de-46b2-b5d2-fbb990f47547",
   "metadata": {},
   "outputs": [],
   "source": [
    "# set up number of cpus per ray worker\n",
    "num_cpus = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "2acdc993",
   "metadata": {},
   "outputs": [],
   "source": [
    "# --- Custom generate dataset function ---\n",
    "def generate_dataset(problem: str=\"1027_ESL\", random_state: int=42, scaleXy: bool=True):\n",
    "    np.random.seed(42)\n",
    "    num_variables = 1\n",
    "    scaler_X = None\n",
    "    scaler_y = None\n",
    "\n",
    "    # PMLB datasets\n",
    "    X, y = fetch_data(problem, return_X_y=True, local_cache_dir=\"./datasets\")\n",
    "\n",
    "    num_variables = X.shape[1]\n",
    "\n",
    "    X_train, X_test, y_train, y_test = train_test_split(\n",
    "        X, y, test_size=0.25, random_state=random_state\n",
    "    )\n",
    "\n",
    "    y_train = y_train.reshape(-1, 1)\n",
    "    y_test = y_test.reshape(-1, 1)\n",
    "\n",
    "    if scaleXy:\n",
    "        scaler_X = StandardScaler()\n",
    "        scaler_y = StandardScaler()\n",
    "\n",
    "        X_train_scaled = scaler_X.fit_transform(X_train)\n",
    "        y_train_scaled = scaler_y.fit_transform(y_train)\n",
    "        X_test_scaled = scaler_X.transform(X_test)\n",
    "    else:\n",
    "        X_train_scaled = X_train\n",
    "        y_train_scaled = y_train\n",
    "        X_test_scaled = X_test\n",
    "\n",
    "    y_test = y_test.flatten()\n",
    "    y_train_scaled = y_train_scaled.flatten()\n",
    "\n",
    "    num_train_points = X_train.shape[0]\n",
    "\n",
    "\n",
    "    # note y_test and y_train_scaled must be flattened\n",
    "    return (\n",
    "        X_train_scaled,\n",
    "        y_train_scaled,\n",
    "        X_test_scaled,\n",
    "        y_test,\n",
    "        scaler_X,\n",
    "        scaler_y,\n",
    "        num_variables,\n",
    "        num_train_points,\n",
    "    )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac321d61",
   "metadata": {},
   "source": [
    "## Evaluation Function and Constant Optimization"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0dc49f4f",
   "metadata": {},
   "source": [
    "The core of the symbolic regression pipeline is the definition of the fitness function. First, we need to define an error measure, which in this case will be the standard MSE between the targets and the predictions.\n",
    "However, we remark that each individual carries some numerical constants that need to be optimized as well. For example, the individual\n",
    "$$I(x) = c_1\\sin(x) + c_2x^2 + c_3$$\n",
    "may have a near 0 fitness for a given triple $(c_1, c_2, c_3)$ and a very large fitness for other triples. This simple examples shows that it is important to auto-optimize carefully the constants in each individual.\n",
    "\n",
    "If the evaluation function is differentiable, then one natural choice to auto-optimize constants is the use of any gradient-based solver. In this example, we are going to use the library `mygrad` for autodifferentiation and `pygmo` for the optimization routine."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5d2a1496",
   "metadata": {},
   "outputs": [],
   "source": [
    "def eval_model(individual, X, consts=[]):\n",
    "    num_variables = X.shape[1]\n",
    "    if num_variables > 1:\n",
    "        X = [X[:, i] for i in range(num_variables)]\n",
    "    else:\n",
    "        X = [X]\n",
    "    warnings.filterwarnings(\"ignore\")\n",
    "    y_pred = individual(*X, consts)\n",
    "    return y_pred\n",
    "\n",
    "\n",
    "def compute_MSE(individual, X, y, consts=[]):\n",
    "    y_pred = eval_model(individual, X, consts)\n",
    "    MSE = np.mean((y - y_pred) ** 2)\n",
    "\n",
    "    if np.isnan(MSE) or np.isinf(MSE):\n",
    "        MSE = 1e8\n",
    "\n",
    "    return MSE\n",
    "\n",
    "\n",
    "def eval_MSE_and_tune_constants(tree, toolbox, X, y):\n",
    "    individual, num_consts = compile_individual_with_consts(tree, toolbox)\n",
    "\n",
    "    if num_consts > 0:\n",
    "\n",
    "        eval_MSE = partial(compute_MSE, individual=individual, X=X, y=y)\n",
    "\n",
    "        x0 = np.ones(num_consts)\n",
    "\n",
    "        class fitting_problem:\n",
    "            def fitness(self, x):\n",
    "                total_err = eval_MSE(consts=x)\n",
    "                # return [total_err + 0.*(np.linalg.norm(x, 2))**2]\n",
    "                return [total_err]\n",
    "\n",
    "            def gradient(self, x):\n",
    "                with mem_guard_off:\n",
    "                    xt = mg.tensor(x, copy=False)\n",
    "                    f =  mg.tensor(self.fitness(xt)[0], copy=False)\n",
    "                    f.backward()\n",
    "                return xt.grad\n",
    "\n",
    "            def get_bounds(self):\n",
    "                return (-5.0 * np.ones(num_consts), 5.0 * np.ones(num_consts))\n",
    "\n",
    "        # PYGMO SOLVER\n",
    "        prb = pg.problem(fitting_problem())\n",
    "        algo = pg.algorithm(pg.nlopt(solver=\"lbfgs\"))\n",
    "        # algo = pg.algorithm(pg.pso(gen=10))\n",
    "        # pop = pg.population(prb, size=70)\n",
    "        algo.extract(pg.nlopt).maxeval = 10\n",
    "        pop = pg.population(prb, size=1)\n",
    "        pop.push_back(x0)\n",
    "        pop = algo.evolve(pop)\n",
    "        MSE = pop.champion_f[0]\n",
    "        consts = pop.champion_x\n",
    "\n",
    "        if np.isinf(MSE) or np.isnan(MSE):\n",
    "            MSE = 1e8\n",
    "    else:\n",
    "        MSE = compute_MSE(individual, X, y)\n",
    "        consts = []\n",
    "    return MSE, consts"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae5d6075",
   "metadata": {},
   "source": [
    "## Expression Complexity and Structure Checks"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d2fe80d",
   "metadata": {},
   "source": [
    "These helper functions analyze individuals to:\n",
    "- count trigonometric functions;\n",
    "- detect nested trigonometric expressions;\n",
    "- penalize overly complex or pathological solutions.\n",
    "\n",
    "They are later used to regularize the fitness function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0da61564",
   "metadata": {},
   "outputs": [],
   "source": [
    "def check_trig_fn(ind):\n",
    "    return len(re.findall(\"cos\", str(ind))) + len(re.findall(\"sin\", str(ind)))\n",
    "\n",
    "\n",
    "def check_nested_trig_fn(ind):\n",
    "    return detect_nested_trigonometric_functions(str(ind))\n",
    "\n",
    "def get_features_batch(\n",
    "    individuals_batch,\n",
    "    individ_feature_extractors=[len, check_nested_trig_fn, check_trig_fn],\n",
    "):\n",
    "    features_batch = [\n",
    "        [fe(i) for i in individuals_batch] for fe in individ_feature_extractors\n",
    "    ]\n",
    "\n",
    "    individ_length = features_batch[0]\n",
    "    nested_trigs = features_batch[1]\n",
    "    num_trigs = features_batch[2]\n",
    "    return individ_length, nested_trigs, num_trigs"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d91b01b2",
   "metadata": {},
   "source": [
    "## Fitness and Prediction Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c76e3097",
   "metadata": {},
   "source": [
    "The fitness function combines:\n",
    "- prediction error (MSE),\n",
    "- structural penalties (expression length),\n",
    "- functional penalties (nested trigonometric functions).\n",
    "\n",
    "A **Tarpeian selection** strategy is applied to discard very large trees early."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3116cafd",
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(individuals_batch, toolbox, X, penalty, fitness_scale):\n",
    "\n",
    "    predictions = [None] * len(individuals_batch)\n",
    "\n",
    "    for i, tree in enumerate(individuals_batch):\n",
    "        callable, _ = compile_individual_with_consts(tree, toolbox)\n",
    "        predictions[i] = eval_model(callable, X, consts=tree.consts)\n",
    "\n",
    "    return predictions\n",
    "\n",
    "\n",
    "def compute_MSEs(individuals_batch, toolbox, X, y, penalty, fitness_scale):\n",
    "\n",
    "    total_errs = [None] * len(individuals_batch)\n",
    "\n",
    "    for i, tree in enumerate(individuals_batch):\n",
    "        callable, _ = compile_individual_with_consts(tree, toolbox)\n",
    "        total_errs[i] = compute_MSE(callable, X, y, consts=tree.consts)\n",
    "\n",
    "    return total_errs\n",
    "\n",
    "\n",
    "def compute_attributes(individuals_batch, toolbox, X, y, penalty, fitness_scale):\n",
    "\n",
    "    attributes = [None] * len(individuals_batch)\n",
    "\n",
    "    individ_length, nested_trigs, num_trigs = get_features_batch(individuals_batch)\n",
    "\n",
    "    for i, tree in enumerate(individuals_batch):\n",
    "\n",
    "        # Tarpeian selection\n",
    "        if individ_length[i] >= 50:\n",
    "            consts = None\n",
    "            fitness = (1e8,)\n",
    "        else:\n",
    "            MSE, consts = eval_MSE_and_tune_constants(tree, toolbox, X, y)\n",
    "            fitness = (\n",
    "                fitness_scale\n",
    "                * (\n",
    "                    MSE\n",
    "                    + 100000 * nested_trigs[i]\n",
    "                    + 0.0 * num_trigs[i]\n",
    "                    + penalty[\"reg_param\"] * individ_length[i]\n",
    "                ),\n",
    "            )\n",
    "        attributes[i] = {\"consts\": consts, \"fitness\": fitness}\n",
    "    return attributes\n",
    "\n",
    "\n",
    "def assign_attributes(individuals_batch, attributes):\n",
    "    for ind, attr in zip(individuals_batch, attributes):\n",
    "        ind.consts = attr[\"consts\"]\n",
    "        ind.fitness.values = attr[\"fitness\"]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f33ba80",
   "metadata": {},
   "source": [
    "## Main Training and Evaluation Pipeline"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dcd3c2af",
   "metadata": {},
   "source": [
    "The following cell orchestrates the entire symbolic regression process:\n",
    "1. loads configuration from a YAML file;\n",
    "2. generates training and test datasets;\n",
    "3. builds the GP primitive set;\n",
    "4. initializes the symbolic regressor;\n",
    "5. trains the model;\n",
    "6. evaluates performance on training and test sets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "ada47da7",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2026-02-25 11:18:31,563\tINFO worker.py:1998 -- Started a local Ray instance. View the dashboard at \u001b[1m\u001b[32mhttp://127.0.0.1:8265 \u001b[39m\u001b[22m\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Generating initial population(s)...\n",
      " Removing duplicates from initial population(s)...\n",
      " DONE.\n",
      "DONE.\n",
      "Evaluating initial population(s)...\n",
      "DONE.\n",
      " -= START OF EVOLUTION =- \n",
      "   \t     \t           fitness            \t             size             \n",
      "   \t     \t------------------------------\t------------------------------\n",
      "gen\tevals\tmin   \tavg   \tmax   \tstd   \tmin\tavg   \tmax\tstd   \n",
      "1  \t2000 \t0.1103\t0.6129\t1.1296\t0.3316\t2  \t8.0595\t21 \t3.8143\n",
      "Best individuals of this generation:\n",
      "sub(mul(c, ARG1), mul(c, add(ARG2, ARG1)))\n",
      "2  \t2000 \t0.1103\t0.3508\t0.7454\t0.1588\t2  \t8.302 \t24 \t4.1524\n",
      "Best individuals of this generation:\n",
      "sub(mul(c, ARG1), mul(c, add(ARG2, ARG1)))\n",
      "3  \t2000 \t0.1103\t0.247 \t0.3748\t0.075 \t2  \t7.982 \t24 \t4.2672\n",
      "Best individuals of this generation:\n",
      "sub(mul(c, ARG1), mul(c, sub(ARG2, ARG1)))\n",
      "4  \t2000 \t0.1061\t0.2048\t0.2911\t0.0589\t2  \t8.306 \t26 \t4.397 \n",
      "Best individuals of this generation:\n",
      "aq(ARG1, mul(sub(ARG2, ARG1), sub(add(ARG2, ARG3), c)))\n",
      "5  \t2000 \t0.1061\t0.1666\t0.2527\t0.0349\t3  \t9.182 \t30 \t4.6258\n",
      "Best individuals of this generation:\n",
      "aq(ARG1, mul(sub(ARG2, ARG1), sub(add(ARG2, ARG3), c)))\n",
      "6  \t2000 \t0.1061\t0.1456\t0.1732\t0.0135\t3  \t8.649 \t25 \t4.5359\n",
      "Best individuals of this generation:\n",
      "aq(ARG1, mul(sub(ARG2, ARG1), sub(add(ARG2, ARG3), c)))\n",
      "7  \t2000 \t0.1061\t0.1388\t0.1532\t0.0085\t3  \t8.7245\t25 \t4.6155\n",
      "Best individuals of this generation:\n",
      "aq(ARG1, mul(sub(ARG2, ARG1), sub(add(ARG2, ARG3), c)))\n",
      "8  \t2000 \t0.1025\t0.135 \t0.1453\t0.0064\t3  \t8.984 \t26 \t4.6724\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "9  \t2000 \t0.1025\t0.1326\t0.14  \t0.0052\t3  \t8.775 \t26 \t4.217 \n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "10 \t2000 \t0.1025\t0.1309\t0.1368\t0.0046\t3  \t7.96  \t26 \t4.1211\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "11 \t2000 \t0.1025\t0.1296\t0.135 \t0.0044\t3  \t7.452 \t26 \t4.1453\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "12 \t2000 \t0.1025\t0.1287\t0.1332\t0.0043\t3  \t6.97  \t25 \t4.1004\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "13 \t2000 \t0.1025\t0.1277\t0.1321\t0.0043\t3  \t6.9555\t28 \t4.2998\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "14 \t2000 \t0.1025\t0.127 \t0.1311\t0.0044\t3  \t7.129 \t28 \t4.4758\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "15 \t2000 \t0.1025\t0.1262\t0.131 \t0.0044\t3  \t7.443 \t28 \t4.7715\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "16 \t2000 \t0.1025\t0.1254\t0.13  \t0.0045\t3  \t7.3915\t28 \t4.9913\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "17 \t2000 \t0.1025\t0.1247\t0.129 \t0.0046\t3  \t7.422 \t29 \t5.281 \n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "18 \t2000 \t0.1025\t0.1238\t0.1284\t0.0047\t3  \t8.152 \t29 \t5.586 \n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "19 \t2000 \t0.1025\t0.123 \t0.1274\t0.0049\t3  \t8.9855\t29 \t5.7858\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "20 \t2000 \t0.1025\t0.1222\t0.127 \t0.0049\t3  \t10.028\t29 \t5.8074\n",
      "Best individuals of this generation:\n",
      "aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      " -= END OF EVOLUTION =- \n",
      "The best individual is aq(sub(mul(c, ARG1), sin(ARG2)), sub(mul(c, ARG2), mul(c, ARG1)))\n",
      "The best fitness on the training set is 0.1025\n",
      "Best parameters =  [1.9244978  2.9227811  2.16785583]\n",
      "Elapsed time =  89.945805311203\n",
      "Individuals per sec =  466.9478454796689\n",
      "MSE on the test set =  1.535581223536389\n",
      "R^2 on the test set =  0.796316488032204\n",
      "MSE on the training set =  2.2604829120253043\n",
      "R^2 on the training set =  0.9115115245302139\n"
     ]
    }
   ],
   "source": [
    "regressor_params, config_file_data = load_config_data(\"simple_sr.yaml\")\n",
    "\n",
    "scaleXy = config_file_data[\"gp\"][\"scaleXy\"]\n",
    "\n",
    "# generate training and test datasets\n",
    "(\n",
    "    X_train_scaled,\n",
    "    y_train_scaled,\n",
    "    X_test_scaled,\n",
    "    y_test,\n",
    "    _,\n",
    "    scaler_y,\n",
    "    num_variables,\n",
    "    _,\n",
    ") = generate_dataset(\"1096_FacultySalaries\", scaleXy=scaleXy, random_state=29802)\n",
    "\n",
    "if num_variables == 1:\n",
    "    pset = gp.PrimitiveSetTyped(\"Main\", [float], float)\n",
    "    pset.renameArguments(ARG0=\"x\")\n",
    "elif num_variables == 2:\n",
    "    pset = gp.PrimitiveSetTyped(\"Main\", [float, float], float)\n",
    "    pset.renameArguments(ARG0=\"x\")\n",
    "    pset.renameArguments(ARG1=\"y\")\n",
    "else:\n",
    "    pset = gp.PrimitiveSetTyped(\"Main\", [float] * num_variables, float)\n",
    "\n",
    "pset = add_primitives_to_pset_from_dict(pset, config_file_data[\"gp\"][\"primitives\"])\n",
    "\n",
    "batch_size = config_file_data[\"gp\"][\"batch_size\"]\n",
    "if config_file_data[\"gp\"][\"use_constants\"]:\n",
    "    pset.addTerminal(object, float, \"c\")\n",
    "\n",
    "callback_func = assign_attributes\n",
    "fitness_scale = 1.0\n",
    "\n",
    "penalty = config_file_data[\"gp\"][\"penalty\"]\n",
    "common_params = {\"penalty\": penalty, \"fitness_scale\": fitness_scale}\n",
    "\n",
    "gpsr = gps.GPSymbolicRegressor(\n",
    "    pset_config=pset,\n",
    "    fitness=compute_attributes,\n",
    "    predict_func=predict,\n",
    "    score_func=compute_MSEs,\n",
    "    common_data=common_params,\n",
    "    callback_func=callback_func,\n",
    "    print_log=True,\n",
    "    num_best_inds_str=1,\n",
    "    save_best_individual=False,\n",
    "    output_path=\"./\",\n",
    "    seed_str=None,\n",
    "    batch_size=batch_size,\n",
    "    num_cpus=num_cpus,\n",
    "    remove_init_duplicates=True,\n",
    "    **regressor_params,\n",
    ")\n",
    "\n",
    "tic = time.time()\n",
    "gpsr.fit(X_train_scaled, y_train_scaled)\n",
    "toc = time.time()\n",
    "\n",
    "best = gpsr.get_best_individuals(n_ind=1)[0]\n",
    "\n",
    "if hasattr(best, \"consts\"):\n",
    "    print(\"Best parameters = \", best.consts)\n",
    "\n",
    "print(\"Elapsed time = \", toc - tic)\n",
    "individuals_per_sec = (\n",
    "    (gpsr.get_last_gen() + 1)\n",
    "    * gpsr.num_individuals\n",
    "    * gpsr.num_islands\n",
    "    / (toc - tic)\n",
    ")\n",
    "print(\"Individuals per sec = \", individuals_per_sec)\n",
    "\n",
    "u_best = gpsr.predict(X_test_scaled)\n",
    "\n",
    "# de-scale outputs before computing errors\n",
    "if scaleXy:\n",
    "    u_best = scaler_y.inverse_transform(u_best.reshape(-1, 1)).flatten()\n",
    "\n",
    "MSE = np.mean((u_best - y_test) ** 2)\n",
    "r2_test = r2_score(y_test, u_best)\n",
    "print(\"MSE on the test set = \", MSE)\n",
    "print(\"R^2 on the test set = \", r2_test)\n",
    "\n",
    "pred_train = gpsr.predict(X_train_scaled)\n",
    "\n",
    "if scaleXy:\n",
    "    pred_train = scaler_y.inverse_transform(pred_train.reshape(-1, 1)).flatten()\n",
    "    y_train_scaled = scaler_y.inverse_transform(\n",
    "        y_train_scaled.reshape(-1, 1)\n",
    "    ).flatten()\n",
    "\n",
    "MSE = np.mean((pred_train - y_train_scaled) ** 2)\n",
    "r2_train = r2_score(y_train_scaled, pred_train)\n",
    "print(\"MSE on the training set = \", MSE)\n",
    "print(\"R^2 on the training set = \", r2_train)\n",
    "\n",
    "# ray is explicitly shut down at the end of the execution to release computational resources\n",
    "ray.shutdown()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1da3e467-7d35-4af2-8626-253ac7e43a4f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'(1.9244978027630006*ARG1 - sin(ARG2))/sqrt((-2.1678558285490226*ARG1 + 2.922781097169807*ARG2)**2 + 1)'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# get the sympy version of the best individual\n",
    "best_expression_sympy_str = str(gpsr.get_best_individual_sympy())\n",
    "best_expression_sympy_str"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8954382d",
   "metadata": {},
   "source": [
    "## Plots"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "daad8ec9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGwCAYAAAC99fF4AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAXYBJREFUeJztnQl8VdW1/1fmhCFhSCBAwpAgCKKA0EehotQqiNaHrRaUFhG1LdW2INVaCrR9VEVqn2LbB45VsYL8XxGpFhTocwBxKgWkoEwJGZhCEjLPyf1/1sZzuTe5F5KQm73P2r/v53M+995zzz1nZf3O3mdlD2uHeTweDwEAAAAAAD/C/T8CAAAAAAAESQAAAAAAQUBLEgAAAABAABAkAQAAAAAEAEESAAAAAEAAECQBAAAAAAQAQRIAAAAAQAAiA+0E56ehoYGOHTtGnTt3prCwMLgMAAAAcAGcHrK0tJR69+5N4eHnbitCkNRKOEBKTU1t7c8BAAAAoJGcnBxKSUk55zEIkloJtyA5To6Pj6e2pqSkJCTnBfC9raBMyQXayqUkBM9CPic3cjjP8XOBIKmVOF1sLF4ogpny8nIESZqA72UCXeUCbeVSHsJnYXOGymDgtqGcr58UwPcAZQqgvpROuOZnIZ7EhhITE6PbBGuB72UCXeUCbeUSo/lZiCDJUIqKinSbYC3wvUygq1ygrVyKND8LESQZSnJysm4TrAW+lwl0lQu0lUuy5mchgiRDycrK0m2CtcD3MoGucoG2csnS/CwM83BWJdCqKYQJCQlUXFyMWWgAAACAwOc3WpIMZf/+/bpNsBb4XibQVS7QVi77NT8L0ZJkaEtSfX09RUREtPl5AXxvKyhTcoG2cqkPwbMQLUkCyMzM1G2CtcD3MoGucoG2csnU/CxEd5uh6B7RbzPwvUygq1ygrVySMbsNBIK78YAe4HuZQFe5QFu5FGt+FqIlyVCio6N1m2At8L1MoKtcoK1cojU/C7HArWFU1NRRYXkNFZXWUnVkBbmR7h1jKC7avYPOda8VBEIDdJULtJVLuOb6GEGSYWz5PI9+unonuZn42Eh65/4J1L1TjGtXne7evbtuM0AbA13lAm3lUq65PkaQZBgRYWEUE+neloya+gYqqaqjz3KL6esX9yA3kpiYqNsEEAKgq1ygrVwSNdfHCJIM44bLeqmNE2gNHjyY3MYPVv6TNu07STmn3dlVyOTk5LjS9+DcQFe5QFu56NbWvU0Wwhk0aBC5kb7dOqjX7AL3Bklu9T04N9BVLtBWLoM018cIkgzlwIED5EZSvwyS3NyS5Fbfg3MDXeUCbeVyQHN9jCDJUHRHzxfcklRYSW7Frb4H5wa6ygXaymUQWpKAidHzBbckFVaQx+MhN+JW34NzA13lAm3lcgAtSSAQqamprnRMStc49VpWXUdFFbXkRtzqe3BuoKtcoK1cUjXXx+huM5T8/HxyI7FREdQz/kx+pOxCd45LcqvvwbmBrnKBtnLJ11wfI0gylI4dO5JbSe3q7sHbbvY9CA50lQu0lUtHzfWx9iBp+fLlNGDAAIqNjaVRo0bR1q1bgx57/Phxmj59usqZwKnK586d2+SYvXv30s0330z9+/ensLAwWrZs2QVfVwcNDQ3kVs4O3nZnkORm34PgQFe5QFu5NGiuj7UGSWvWrFGBzoIFC2jnzp00fvx4mjx5MmVnZwc8vrq6mpKSktTxw4cPD3hMRUUFpaWl0aOPPkrJycltcl0d1NTUkFtJ8Rm87Ubc7HsQHOgqF2grlxrN9bHWIOnxxx+nu+66i+6++24aMmSIavXhQVorVqwIeDy3Dj355JN0++23U0JCQsBjvvKVr9Bjjz1Gt956K8XExLTJdXUQ7O9zU0tSjkvTALjZ9yA40FUu0FYuCZrr43Cd0eGOHTto4sSJfvv58/bt2427LrdilZSU+G2h5MSJE+RW3N7d5mbfg+BAV7lAW7mc0Fwfh+scsV5fX089e/b028+fQ+mU1l53yZIlKqJ1NmdaIq9QfPDgQXVOXm+N4dfKykrKysqi06dPU15eHh07dkwFVocPH6ba2lq/Yzlwy8jIoOLiYjXuiu3o1q0bHTlyRAVnvsfW1dXRoUOHqLS0lI4ePUqnTp2iwsJC1VXI1/Q9lvMUcY4J7oLk9W8KCgrU35+bm0tlZWUB7a6qqlLXZbtPnjzptZvta2w3f+b9/D3bzccXFRURlReoY46erqC6+gZ1LF+H7ebrOnazPWw32+fY6/vK+/l7Po6P59/x7/k8wezm67MdbE9z7Oa/j4/nv5d/z+dhHzvH8nXYT3xd9hv7j+1hf7J97F/HXl/t2W7WxbGb9WK7+dy+x7K+jt2sO9vN9wHbx/dFY7v5/nHs5vuK7eb7rLH2jt18fwazm/v6A92zbDef27GbrxnI7szMTGUr280bv+d9zbGbrxHIbrbJsZttZbt54/dOWTuf3cHKGv8NbFswuwOVNT6HU9bOZ3ewshaqOoLvGbfWEU5Za3zPtraO4Dq5PeuIQGUNdURdSOqIXr16tXkdwdo3lzCPpox/7Ig+ffqo1puxY8d69z/88MP08ssv0xdffHHO30+YMIFGjBgRdGC20z3HY498B3i39rosOG8OLCYHSix6fHw8tTVuXeCWaWjw0MWL3qKa+gba+vOvexNMugU3+x4EB7rKBdrKZX8I6mN+fnNg3ZzndyRpIjExkSIiIpq03nCU17iVx4Tr8vimYGOcQoGbH9Lh4WEqqWRGfrlKA+C2IMnNvgfBga5ygbZy0a2ttu626OhoNfV+8+bNfvv587hx48Rdt6U4TYVuxXd5Erfhdt+DwEBXuUBbuezXXB9ra0li5s2bRzNmzKDRo0errq9nnnlG9S/Pnj1bfT9//nzVx7xy5Urvb3bt2qVeuf+X+6D5Mwc+Q4cOVfu5r3Pfvn3e9/x7PqZTp040cODAZl3XBPr160duxs2Dt93uexAY6CoXaCuXfprrY61B0rRp09TAvMWLF6uBVMOGDaMNGzZ4ncL7GucuGjlypPc9z1JbtWqVOp4H1DljjnyP+f3vf6+2q666it59991mXdcEuDuQx1S5ldRuca5NA+B234PAQFe5QFu5nNBcH2sbuO12WjLwqzXwDIwuXbqQW3nr38dp9l/+RSNSu9Dr936N3ITbfQ8CA13lAm3lUhSC+rglz2/ty5KAwPjOpHMjKV+u35brwvXb3O57EBjoKhdoK5dqzfUxgiRD0b1ezYXSt/uZICm/rIbKq8/kHXILbvc9CAx0lQu0lUuDzWu3AXNXPr5Q4mOjKCEuSr3PPe2ucUlu9z0IDHSVC7SVS0fN9TGCJEPhDKJux60z3CT4HjQFusoF2solX3N9jCDJUJxlT9yMW4MkCb4HTYGucoG2cknVXB8jSDIUXjfI7aR40wC4K0iS4HvQFOgqF2grlwzN9TGCJEPRnYq9LVuS3BYkSfA9aAp0lQu0lctgW5clAWanYm8LUr9MA8Drt7kJCb4HTYGucoG2ctmvuT5GkGQoaWlpJGlMkptylkrwPWgKdJULtJVLmub6GEGSoeTk5JDb6d0ljsLDiKpqG+hUmXsSNErwPWgKdJULtJWLbm0RJBlKYmIiuZ3oyHDqleC+Ndwk+B40BbrKBdrKJVFzfYwgyVDKyspIAmcXunXPuCQpvgf+QFe5QFu5lGmujxEkGUpERARJwDt420VBkhTfA3+gq1ygrVwiNNfHCJIMJTo6miTgxoSSUnwP/IGucoG2conWXB8jSDKU4uJikkBqN/elAZDie+APdJULtJVLseb6GEGSoSQnJ5OoIMlFA7el+B74A13lAm3lkqy5PkaQZChZWVkkqbvtWHEl1dQ1kBuQ4nvgD3SVC7SVS5bm+hhBkqHoTsXeViR2iqa4qAjiXJLHitzRmiTF98Af6CoXaCuXwViWBJiYir2tCAsL86YBcMvgbSm+B/5AV7lAW7nsx7IkIBADBw4U4xi3reEmyffgLNBVLtBWLgM118fobjOUjIwMkoIzeNstLUmSfA/OAl3lAm3lkqG5PkaQZCi9evUiaUFSrktmuEnyPTgLdJULtJVLL831MYIkQykqKiIpuC2hpCTfg7NAV7lAW7kUaa6PESQZSmxsLEnBbUGSJN+Ds0BXuUBbuejWFkGSwbPCpJDS9czstuLKWrWZjiTfg7NAV7lAW7mEaa6PESQZSkWFO1pdmkPHmEiVL8ktC91K8j04C3SVC7SVS4Xm+hhBkqF0796dJJHyZRqAXBekAZDme3AG6CoXaCuX7prrYwRJhpKbm0uScNO4JGm+B2eArnKBtnLJ1VwfI0gylIsuuogk4aYgSZrvwRmgq1ygrVwu0lwfI0gylAMHDpAknKVJclyQK0ma78EZoKtcoK1cDmiujxEkGYruRf1ClVDSDQO3pfkenAG6ygXaymUwFrgFJi7qF6r123JPV1JDg4dMRprvwRmgq1ygrVz2277A7fLly2nAgAEqYdSoUaNo69atQY89fvw4TZ8+XUWW4eHhNHfu3IDHrV27loYOHUoxMTHqdd26dX7fl5aWqt/269eP4uLiaNy4cfTpp5+SSfTt25ck0SshliLDw6imvoFOllaRyUjzPTgDdJULtJVLX831sdYgac2aNSpYWbBgAe3cuZPGjx9PkydPpuzs7IDHV1dXU1JSkjp++PDhAY/58MMPadq0aTRjxgzavXu3ep06dSp9/PHH3mPuvvtu2rx5M7388su0Z88emjhxIl1zzTV09OhRMoVTp06RJCIjwql3F3eMS5Lme3AG6CoXaCuXU5rr4zCPx6Ot72PMmDF0+eWX04oVK7z7hgwZQjfddBMtWbLknL+dMGECjRgxgpYtW+a3nwOkkpIS2rhxo3ffddddR127dqXVq1dTZWUlde7cmdavX0833HCD9xg+1ze/+U166KGHmmU7XyMhIYGKi4spPj6e2prCwkLq1q0bSeJ7z31M2w7l0++/M5xuGZVCpiLR9wC6SgZlVi6FIaiPW/L81taSVFNTQzt27FCtOL7w5+3bt7f6vNyS1PickyZN8p6zrq6O6uvrm6wHw91u27ZtC3pebsVix/puoYRtlEaqS9IASPQ9gK6SQZmVS73m+lhbkJSfn6/++J49e/rt588nTpxo9Xn5t+c6J7cijR07ln7729/SsWPHlA1/+ctfVHccj3kKBrdsceTpbKmpqWp/eXk5HTx4UJ3HGWDGr9xilZWVRadPn6a8vDx1LQ6sDh8+TLW1tX7HcsCYkZGholq2gW3l3x05ckQFZ77HcpB36NAhNa6Kuwe5KZIjbe6i5Gv6HsuNhDx9ktO65+TkUEFBgfI7J+cqKysLaHdVVZW6Ll//5MmTXrvZvsZ282fez9+z3Xw8r9jMv+fz+B7L1+ngORMcHcjNV3azPWw32+fY6/vK+/l7Po6P57+X7ea/P5jdfH22g+1pjt389/Hxjr+d8/jazX7i67Lf2H9sD/uT7WP/Ovb6as92sy6O3awX2836+R7L+jp2s+5sN98HbB/fF43t5vvHsZvvK7ab77PG2jt28/0ZzO6GhoaA9yzbzed27OZrBrI7MzNT2cp288bveV9z7OZrBLKbbXLsZlvZbt74vVPWzmd3sLLGfmbbgtkdqKzxOZyydj67g5W1UNURTlmTVEew3Xxdx25T64hAZQ11RF1I6gj2a1vXEed61hvT3caO6NOnj2rh4aDF4eGHH1Zjhb744otWdbdFR0fTSy+9RLfddpt33yuvvEJ33XWXurkZFuPOO++k999/nyIiIlSX36BBg+hf//oX7du3L+D1WHDeHFhMDpRC1d3GFRwHdJJ487Nj9ONVO2l0v6701x+NI1OR6HsAXSWDMiuXUGjriu62xMREFaA0bjXiKK9xS1BLSE5OPu8509PT6b333lMRKkefn3zyiYpkeZZdMHimHDvTdwsl/J+LNJw0ADmGr98m0fcAukoGZVYuJzXXx9qCJG7x4Sn/PMvMF/7MU/JbC7dKNT7npk2bAp6zY8eO1KtXL9WM+vbbb9OUKVPIFPr370/ScJYmOVlSTVW15o77keh7AF0lgzIrl/6a62OtKQDmzZtHzz33HP35z3+mzz//nO677z7Vvzx79mz1/fz58+n222/3+82uXbvUxq1A3AfN7327yObMmaOCoqVLl6ouO37dsmWLX04lDojeeust1TfKAdXXv/51lXtp1qxZZArcJSiNLh2iqHNMpDeppKlI9D2ArpJBmZXLYc318ZknliZ4uj4PuFu8eLEaSDVs2DDasGGDSvLI8L7GOZNGjhzpfc+z41atWqWOdwbbcovRq6++SgsXLqRFixaprjXOx8TpBhy4H5IDMB6cyFMLb775ZjUWKioqikxBdyr2UBAWFkYp3TrQ58dL1PIkA3t0IhOR6HsAXSWDMiuXwZrrY615ktxMqPMk8Yh83TdHKPjhy/+kt/eepP/6z0to5jgzu7Wk+t52oKtcoK1c9oegPnbFwG1gdj9syAdvG5wrSarvbQe6ygXayqW/zWOSQHBaksfBTfTtbn5CSam+tx3oKhdoK5fjmutjBEmG0qVLF5LI2TQA5g7clup724GucoG2cumiuT5GkGQoTuJLqUuTcHebqcPhpPredqCrXKCtXKo018cIkgzF1ADiQknpGqdey6rr6HRFLZmIVN/bDnSVC7SVi0dzfYwgyVA6dDjT4iKN2KgI6hkfY/Tgbam+tx3oKhdoK5cOmutjBEmGwvmjpOJk3jZ18LZk39sMdJULtJVLgeb6GEGSoaSkpJBUTF/DTbLvbQa6ygXayiVFc32MIMlQeMkUqfgO3jYRyb63GegqF2grF93aIkgyFMkZn88GSWamAZDse5uBrnKBtnIZrLk+RpBkcCp2qZg+Jkmy720GusoF2splv+b6GEGSoaSlpZH0IOloUSXV1TeQaUj2vc1AV7lAW7mkaa6PESQZSnZ2NkmlR+cYio4Mp/oGDx0vNi9xo2Tf2wx0lQu0lUu25voYQZKhJCUlkVTCw8O8SSVNHLwt2fc2A13lAm3lkqS5PkaQZChlZWUkGZPTAEj3va1AV7lAW7mUaa6PESQZSmRkJEnG5MHb0n1vK9BVLtBWLpGa62MESYYSFRVFdgRJ5qUBkO57W4GucoG2conSXB8jSDKUkpISkkxqN3PHJEn3va1AV7lAW7mUaK6PESQZSo8ePUgyJmfdlu57W4GucoG2cumhuT5GkGQouqc9tleQVFBeQ+XVdWQS0n1vK9BVLtBWLtlIAQBMTMUeauJjo6hLhygjZ7hJ972tQFe5QFu5DMayJMDEVOztmgbAsMHbNvjeRqCrXKCtXPZjWRIQiIEDB4p3jKlpAGzwvY1AV7lAW7no1hZjkgwlIyODpGPq4G0bfG8j0FUu0FYuGZrrYwRJhtK7d2+SjqlpAGzwvY1AV7lAW7n01lwfI0gylNOnT5N0TO1us8H3NgJd5QJt5XJac32MIMlQYmNjSTq+67d5PB4yBRt8byPQVS7QVi6xmutjBEmGEhYWRtLp3SWOwsOIqmob6FRZNZmCDb63EegqF2grlzDN9TGCJEOpqDCrCyoUREeGU6+EOOPSANjgexuBrnKBtnKp0FwfI0gylO7du5MNmDh42xbf2wZ0lQu0lUt3zfUxgiRDyc3NJRswcfC2Lb63DegqF2grl1zN9TGCJEPRnUCr/bNumxMk2eJ724CucoG2chloezLJ5cuX04ABA9QI9lGjRtHWrVuDHnv8+HGaPn26WsslPDyc5s6dG/C4tWvX0tChQykmJka9rlu3zu/7uro6WrhwobpuXFwcpaWl0eLFi6mhoYFM4eDBg2QDfbub15Jki+9tA7rKBdrK5aDm+lhrkLRmzRoV6CxYsIB27txJ48ePp8mTJwdd9be6upqSkpLU8cOHDw94zIcffkjTpk2jGTNm0O7du9Xr1KlT6eOPP/Yes3TpUnrqqafoT3/6E33++ef0u9/9jh577DH64x//SKage1G/9iLly5ak3NPmDNy2xfe2AV3lAm3lMlhzfRzm0ZigZsyYMXT55ZfTihUrvPuGDBlCN910Ey1ZsuScv50wYQKNGDGCli1b5refA6SSkhLauHGjd991111HXbt2pdWrV6vP3/zmN6lnz570/PPPe4+5+eabqUOHDvTyyy83y3a+RkJCAhUXF1N8fDyFYlE/3TdHe3CqtJq+8vAW4lme+387Wc14040tvrcN6CoXaCuX/SGoj1vy/Nb2RKqpqaEdO3bQxIkT/fbz5+3bt7f6vNyS1PickyZN8jvnFVdcQf/4xz/owIED6jO3OG3bto2uv/76oOflVix2rO8WSvr27Us2kNgpmuKiIohD9aNFZrQm2eJ724CucoG2cumruT7WFiTl5+dTfX29atHxhT+fOHGi1efl357vnA8++CDddtttdPHFF1NUVBSNHDlSdfvxvmBwyxZHns6Wmpqq9peXl6s+U/5bOOJl+LWyspKysrJUSvW8vDw6duyYCqwOHz5MtbW1fsdywMiL+HFUy+Ou2NYjR46ojYMz32N5PNWhQ4eotLSUjh49SqdOnaLCwkLVRcnX9D2WGwk5EOQ8Ezk5OVRQUKD8zrMFysrKAtpdVVWlrst2nzx50ms329fYbv7M+/l7tpuPLyoqUr/n8/gey9dhu/m6jt1sD9vVp8uZjKrZBeVeu/mV7ea/i4/j4/l3/Hs+TzC7+fpsB9vTHLv57+Pj+e917P7ss8/87GY/8XXZb+w/x262j/3r2OurPdvNujh2s15sN+vneyzr69jNurPdfB+wfXxfNLab7x/Hbr6v2G6+zxpr79jN92cwu3kMXqB7lu3mczt28zUD2Z2ZmalsZbt54/e8rzl28zUC2c02OXazrWw3b/zeKWvnsztYWWNd2bZgdgcqa3wOp6ydz+5gZS1UdYRT1qTXEWw32+dbNzSuI/ga7VlHBCprqCNCU0ewpm1dR7D2zcajiaNHj3I3n2f79u1++x966CHP4MGDz/v7q666yjNnzpwm+6OiojyrVq3y2/eXv/zFExMT4/28evVqT0pKinr97LPPPCtXrvR069bN8+KLLwa9XlVVlae4uNi75eTkKPv5fSgoKCjw2MJdL37i6ffgm56XPzziMQGbfG8T0FUu0FYuBSGoj/m53dzndyRpIjExkSIiIpq0GnGU17glqCUkJyef95wPPPAA/eIXv6Bbb71Vfb700ktVlMmtRTNnzgx4Xp4px1t7wf8N2kKKzxpuJmCT720CusoF2sqlTnN9rK27LTo6Wk3537x5s99+/jxu3LhWn3fs2LFNzrlp0ya/c3ITLacQ8IUDNpNSAHDzoy04CSVNyZVkk+9tArrKBdrKpVZzfaytJYmZN2+emqI/evRoFdw888wzqn959uzZ6vv58+er/siVK1d6f7Nr1y71yv2/3AfNnzng4nxIzJw5c+jKK69U0/ynTJlC69evpy1btqiB2Q433ngjPfzww2pA2CWXXKLSDzz++ON05513kimEYsacqaR6gyQzBm7b5HubgK5ygbZyiddcH2sNkni6Pg/M40SOPJBq2LBhtGHDBurXr5/6nvc1zpnEg6wdeHbcqlWr1PE8oI7hFqNXX31VJYtctGgRpaenq3xMnG7AgfMh8Xf33HOP6orr3bs3/fCHP6Rf/epXZApsV+fOnckGTFuaxCbf2wR0lQu0lUue5vpYa54kNxPqPEncDxsZqTWGbTcqaupo6K/eVu93/3oiJcRFabXHJt/bBHSVC7SVS10I6mNX5EkC54anQ9pCh+hIlS/JlHFJNvneJqCrXKCtXA5rro8RJBmKbRmfz45L0h8k2eZ7W4CucoG2chmsuT5GkGQoTiIsW0g1KA2Abb63BegqF2grl/2a62MESYbSv39/sgmTBm/b5ntbgK5ygbZy6a+5PkaQZCicmt0m+hqUBsA239sCdJULtJXLMc31MYIkQ+nWrRvZREq3OGPGJNnme1uArnKBtnLpprk+RpBkKLwgn40tSbmnK6mhQW9WCtt8bwvQVS7QVi6VmutjBEnACHolxFFkeBjV1DfQydIq3eYAAAAACJJMJS7uTPeTLUSEh1Gfrmf+5uwCvV1utvneFqCrXKCtXOI018doSTKUwsJCso2zaQD0Nq/a6HsbgK5ygbZyKdRcHyNIMpQ+ffqQbaQakgbARt/bAHSVC7SVSx/N9TGCJEPJzMwk2zibBkBvkGSj720AusoF2solU3N9jCDJUHSnYtdBqiFpAGz0vQ1AV7lAW7kMxrIkwMRU7DZn3bbR9zYAXeUCbeWyH8uSgECkpaVZO3A7r7Saqmrrtdlho+9tALrKBdrKJU1zfYzuNkPJzs4m2+jSIYo6x0Sq97kaF7q10fc2AF3lAm3lkq25PkaQZChJSUlkG2FhYZRiwBpuNvreBqCrXKCtXJI018cIkgylrKyMbKTvl4O3dY5LstX30oGucoG2cinTXB8jSDKUyMgz3U62YcLgbVt9Lx3oKhdoK5dIzfUxgiRD0X1j6E4oqTMNgK2+lw50lQu0lUskgiQQiNLSUisdY0LWbVt9Lx3oKhdoK5dSzfUxWpIMpUePHmQjThqA3NOV5PF4tNhgq++lA13lAm3loltbBEmGonvaoy5Sup4ZuF1WXUenK2q12GCr76UDXeUCbeWSjRQAwMRU7LqIjYqg5PhYreOSbPW9dKCrXKCtXAZjWRJgYip2E9Zw0zUuyWbfSwa6ygXaymU/liUBgbjooousdYzuwds2+14y0FUu0FYuF2mujzEmyVAOHz5MtnJ28LaeIMlm30sGusoF2srlsOb6GEGSofTu3ZtsRXdCSZt9LxnoKhdoK5femutjBEmGUlhYSLaSqnn9Npt9LxnoKhdoK5dCzfUxgiRDiYs7M3jZ5pako0WVVFff0O7Xt9n3koGucoG2conTXB8jSALG0aNzDEVHhlN9g4eOF1fpNgcAAIClIEgylMpKPV1NJhAeHuZNKqkjV5LNvpcMdJULtJVLpeb6WHuQtHz5chowYADFxsbSqFGjaOvWrUGPPX78OE2fPl0llwoPD6e5c+cGPG7t2rU0dOhQiomJUa/r1q3z+75///4UFhbWZLv33nvJFLp160Y2o3Pwtu2+lwp0lQu0lUs3zfWx1iBpzZo1KtBZsGAB7dy5k8aPH0+TJ08Omoa8urqakpKS1PHDhw8PeMyHH35I06ZNoxkzZtDu3bvV69SpU+njjz/2HvPpp5+qgMvZNm/erPZ/5zvfIVM4duwY2YyTBiBHQxoA230vFegqF2grl2Oa6+Mwj65VRIlozJgxdPnll9OKFSu8+4YMGUI33XQTLVmy5Jy/nTBhAo0YMYKWLVvmt58DpJKSEtq4caN333XXXUddu3al1atXBzwXB2pvvvkmHTx4ULUoNQe+RkJCAhUXF1N8fDy1NQ0NDaq1zFaefT+DHt7wOd04vDf98baR7Xpt230vFegqF2grl4YQ1McteX5rexLU1NTQjh07aOLEiX77+fP27dtbfV5uSWp8zkmTJgU9J9vxl7/8he68885zBkjcisWO9d1CCQdsNnM2DUD7tyTZ7nupQFe5QFu56NZWW5CUn59P9fX11LNnT7/9/PnEiROtPi//tiXnfP3116moqIjuuOOOc56XW7Y48nS21NRUtb+8vFyJyH+Ls8YMv/Jgs6ysLDp9+jTl5eWpJkMOrDh7aG1trd+xHKhlZGSoqJa7/5y/4ciRIyo48z22rq6ODh06RKWlpXT06FE6deqUyiPBXZR8Td9juZHwwIEDVFFRQTk5OVRQUKD8npubS2VlZQHtrqqqUtdlu0+ePOm1m+1rbDd/5v38PdvNx7Mv+fd8Ht9j+TpsN1/XsZvtYbvZPsde57WhJE/99kh+qTqOj+ff8e/5PMHs5uuzHWxPc+zmv4+P57/XsdvBsZv9xNdlv7H/2B72J9vN/nXs9tWe/y7WxbGb9WK7WT/fY1lfx27Wne3m+4Dt4/uisd18/zh2833FdvN91lh7x26+P4PZzf+hBbpn2W4+t2M3XzOQ3ZmZmcpWtps3fs/7mmM3XyOQ3WyTYzfbynbzxu+dsnY+u4OVNYZtC2Z3oLLG53DK2vnsDlbWQlVHOGXN1jqCX3k/f5+YmNiudUSgsoY6oi4kdUTfvn3bvI5g7Y3vbmNH9OnTR7XwjB071rv/4Ycfppdffpm++OKLVnW3RUdH00svvUS33Xabd98rr7xCd911l98D0LeViX/zxhtvnPN6LDhvDiwmB0qh6m5jYXWvfqyTkqpauuw3m9T7vf81iTrGRLbbtW33vVSgq1ygrVz2h6A+bkl3W/s9eRrBkX9ERESTFh6O8hq3BLWE5OTkZp+TI8stW7bQa6+9dt7z8kw53toLjp5tJj42irp0iKKiilo1ePvi5LYPRINhu++lAl3lAm3l0ldzfaytu41bb3jKvzOzzIE/jxs3rtXn5VapxufctGlTwHO+8MIL1KNHD7rhhhvINDiwsx1vGoCC9h2XBN/LBLrKBdrKJU/zs1BbSxIzb948NUV/9OjRKrh55plnVP/y7Nmz1ffz589XfcwrV670/mbXrl3qlft/uQ+aP3PAxfmQmDlz5tCVV15JS5cupSlTptD69etVa9G2bdv8rs19lhwkzZw5kyIjtbohIJ07dybb4TQAn+UWU87p9k0mBt/LBLrKBdrKpbPmZ6HW6ICn6/PAvMWLF6uBVMOGDaMNGzZQv3791Pe8r3HOpJEjz04H59lxq1atUsfzgDqGW4xeffVVWrhwIS1atIjS09NVPiZON+ALB058bp7VZiI8+NJ2dM1wg+9lAl3lAm3lUqf5WdgmQRKP7t+zZ48KVjgfUUu455571BaIF198scm+5owzv+WWW9R2LjhNgMYUUcbfGDZn3YbvZQJd5QJt5VKn+VnYqjFJnHzx+eef9wZIV111lUoKybO93n333ba20Uo6depEtpPaTc/6bfC9TKCrXKCtXDppfha2Kkj661//6l0WhKfOc94DnrLvLDECLhweb2U7TksSz25rz1Y/+F4m0FUu0FYupzQ/C1sVJHHiJp5qz/AYIl7zbNCgQSoXEXe7AfdPezSB3l3iKDyMqKq2gU6Vnc1RFWrge5lAV7lAW7n0dWMKAM45tG/fPtXV9tZbb9E111yj9nP2U859BC4czvZqO1ER4dQrof273OB7mUBXuUBbuWRofha2KkiaNWsWTZ06Vc1G4/XOrr32WrX/448/posvvritbbQSZHxuPC6p/dIAwPcyga5ygbZyGax59YNWBUm/+c1v6LnnnqMf/OAH9MEHH3gzUXMr0i9+8Yu2ttFKfNebshkdM9zge5lAV7lAW7ns1/wsbHUKgMZT7HnRQE7MCNqGAQMGwJWagiT4XibQVS7QVi66tW1VSxJns+YEjQ7c9da9e3dKSUmhzz77rC3tsxbONA70JJSE72UCXeUCbeVyVPOzsFVB0tNPP61yIjG8ThpvGzdupOuuu47uv//+trbRSrp166bbBGuDJPheJtBVLtBWLt00Pwtb1d3Gy4U4QdKbb76pWpI4g3X//v2bLP8BWkdlZSUlJCRY7z5ev03dcyVVVFPXQNGRoV+TGb6XCXSVC7SVS6XmZ2Grnji89EhOTo5675sCgBP+cVoAANqKxE7RFBcVQZxL8mhR+y50CwAAwG5aFSR9+9vfpunTp6up/7xA7eTJk9X+Xbt20cCBA9vaRiuJizsz9d12OMVE33bucoPvZQJd5QJt5RKn+VnYqiDpiSeeoB//+Mc0dOhQNR7JWVuFu+GCLVYLWkZhYSFc1ihXUnvNcIPvZQJd5QJt5VKo+VnYqjFJUVFRAQdo89ptoG3o3bs3XKlp8DZ8LxPoKhdoK5femp+FrR4F+/LLL9MVV1yh/oCsrCy1b9myZbR+/fq2tM9ajhw5otsE4wZv80K37QF8LxPoKhdoK5cjmp+FrQqSVqxYQfPmzVNjkTiJpDNYu0uXLipQAu5PxW5zQkn4XibQVS7QVi6D3bgsyR//+Ed69tlnacGCBX4L2o4ePZr27NnTlvZZi+5U7GZ2t7XP7Db4XibQVS7QVi77NT8LWxUkZWZm0siRI5vs5zXcysvL28Iu60lPT7feB40HbhdX1lJxRW3I/QLfywS6ygXayiVd87MwvLVrqfB0/8Zw1m2e8QYuHGecFyDqEB1JiZ1i2m1cEnwvE+gqF2grlyzNz8JWzW574IEH6N5776WqqiqVQPKTTz6h1atX05IlS+i5555reystpEePHrpNMK41Kb+sWs1wG9YntNlX4XuZQFe5QFu59ND8LGxVkDRr1iyqq6ujn//851RRUaESS/bp04eefPJJuvXWW9veSgspKSmhzp076zbDqMHbO7OL2mXwNnwvE+gqF2grF93atipIYr7//e+rLT8/nxoaGrRHe9LgXFRATxoA+F4m0FUu0FYuUZqfha0OkhwSExPbxhLgR2TkBUsjNA1A6Ge4wfcyga5ygbZyidT8LGzVwO2TJ0/SjBkzVCJJ/gM4DYDvBi6c0tJSuDFAGoDcduhug+9lAl3lAm3lUqr5WdiqEO2OO+6g7OxsWrRoEfXq1UstQgraFnRfBk4DkHu6kuobPBQRHrp7Dr6XCXSVC7SVSw83Dtzetm0bbd26lUaMGNH2FgEFB6G6M42aRK+EOIoMD6Oa+gY6WVJFvbuEbmVo+F4m0FUu0FYu2Zqfha3qbktNTVVT/0HoQIDkD7cc9eka1y4L3cL3MoGucoG2chnsxmVJeH22X/ziF9oXnpOM7lTsNq/hBt/LBLrKBdrKZb/mZ2GrutumTZum8iNxuvAOHTo0maJXWFjYVvZZy0UXXaTbBONI8aYBCO0MN/heJtBVLtBWLhdpfha2Kkh64oknMFg7xBw6dIgGDRoU6su4siUp1N1t8L1MoKtcoK1cDml+FrZ6dhsILSkpKXBxkCDpwMlS+vfR4pD5pyoiIaTnDyUpXeOoS4do3WYYCcqUXKCtXFI0PwtbFSRxLqTjx483mZpXUFCg9tXX17eVfdbCvuSuTNA0DcDeYyX0zT9ug2sC0Dk2kj74xdUUH4uM7ShT9oD6Ui4Fmp+FrQqSgs1sq66upuho/BfbFiBAasrQXvH09cFJ9MWJ0CYX42V2wsNbNadBK6dKq6m0qo72HSuhr6Z1122OcaBMyQXayqWD5saCFgVJf/jDH9QrJ4987rnnqFOnTt7vuPXo/fffp4svvrhFBixfvpwee+wx1TJ1ySWXqJlz48ePD3gsH/Ozn/2MduzYQQcPHqSf/vSn6vjGrF27ViW6PHz4sBpc/vDDD9O3vvUtv2OOHj1KDz74IG3cuJEqKytVn+fzzz9Po0aNIhNAioWmREaE0wuz/iPkvuf1CN243M7MP39C7x04RRmnyhEkBQBlSi7QVi4ezemGIls6YNsx+qmnnvJbgoRbkPr376/2N5c1a9bQ3LlzVaD0ta99jZ5++mmaPHky7du3j/r27RuwpSopKYkWLFjgtaUxH374oZp999vf/lYFRuvWraOpU6eqBJhjxoxRx5w+fVpd7+tf/7oKkriLkAOqLl26kClUVVXpNsFa3Or7tKSOXwZJZbpNMRK36grOD7SVS5XmchvmaUWYxsHFa6+9Rl27dr2gi3PQcvnll9OKFSu8+4YMGUI33XQTLVmy5Jy/nTBhgsr43bgliQOkkpISFfw4XHfddcrW1atXq8+c4+mDDz5QWcObCwdovDnwNTipZnFxMcXHx1NbU15eTh07dmzz8wK5vn/5oyxa9Pq/6eqLe9Cf7/iKbnOMw626gvMDbeVSHoJyy8/vhISEZj2/WzXw4p133rngAKmmpkZ1m02cONFvP3/evn17q8/LLUmNzzlp0iS/c/7tb3+j0aNH03e+8x3VijRy5Eh69tlnz3leDtrYqc7GAZIjIHf9cXejk/SKX7kLLysrS7Va5eXl0bFjx5Qw3GJVW1vrdyz7IiMjQwnGXYonTpxQx3GyTg7MfI+tq6tTUyJ50T/uMjx16pTKS8Wp2/mavsdy/HvgwAGV0yonJ0cNgOOupNzcXCorKwtoN0ftfF22mxcyduxm+xrbzZ95P3/PdvPxRUVF6vd8Ht9j+TpsN1/XsZvtYbvZPsde31fez9/zcXw8/45/z+cJZjdfn+1ge5pjN/99fDz/vY7du3fv9rOb/cTXZb+x/9ge9ifbx/517PXVnu1mXRy7WS+2m/XzPZb1dexm3dluvg/YPr4vGtvN94VjN99XbDffZ3zN6Koz+cm+OHraazffn8Hs5rFXge5ZtpvP7djN1wxkd2ZmprKV7eaN3/O+5tjN13Ds9j2WbXLsZlvZbt74vVPWzmd3sLLGurJtwewOVNb4HE5ZO5/dwcpaqOoIp6yhjshWZas964jGdZtb6ohAdpteR2RlZbV5HcE+bPOWpHnz5qkuLI7o+P25ePzxx897PnZEnz59VIvOuHHjvPsfeeQReumll86bZTNYSxJ3+7344os0ffp0775Vq1bRrFmzvC1BsbGx3r+JA6VPPvlEdftxd9/tt99uREsS38C+3Zmg/XCr73lNuzGP/IN47d/Pf3sdxUS6728IJW7VFZwfaCuX+hCU25a0JDV7TNLOnTvpiy++UK0u/D4YPKi7JTQ+nmO2lp6jpefkKJNbkjggY/hv2rt3r+r2CxYkxcTEqK294P8odK9ZYytu9X2PzjHUMTqCymvqKbuggi7q2Vm3SUbhVl3B+YG2cjmkudxGtqSLzcmPxO+d8T88461nz54tvjDPHuLzcROcL9wU1przOSQnJ5/3nL169aKhQ4f6HcNjoXhWnCmgMofvWwr/I5CW1In2HC2mw6fKESShTFkD6ku5DHbTAreNe+Z4cDT3AbYG7hbj6fabN2/228+ffbvfWsrYsWObnHPTpk1+5+SZbY2787j/tV+/fmQKuhf1sxk3+55nuDEZ+ZjhJklXcG6grVz2u3GB27bKX8BjgmbMmKG6vji4eeaZZ9RgttmzZ6vv58+frwaGrVy50vubXbt2qVceJMcD3vgzB1xOy9CcOXPoyiuvpKVLl9KUKVNo/fr1tGXLFpUCwOG+++5TQRN3t3F6AB6TxNfmzRQCpUAA8P35SE86k7uMcyUBlClbQH0pl766n4WeFhAeHu7Jy8vzfu7UqZMnIyPDcyH8z//8j6dfv36e6Ohoz+WXX+557733vN/NnDnTc9VVV/kdzyY33vj3vvzv//6vZ/DgwZ6oqCjPxRdf7Fm7dm2T677xxhueYcOGeWJiYtQxzzzzTIvsLi4uVtfm11Bw5MiRkJwXyPb9G7uPevo9+Kbnpv/ZptsU43CzruDcQFu5HAlBuW3J87tFeZJ4qQZO9ugMYH7jjTfo6quvbpLDgHMoSaclo+NbA0/bvNA0C8A+3/OSJNf/YSslxEXRrl9de8GTICThZl3BuYG2cjkdgnIbktltzMyZM/0+f+9732udheC8cN4IoAc3+35A4pl/WIora6mwvIa6d2q/GZmm42ZdwbmBtnKp1VxuWxQkvfDCC6GzBPjBibmAHtzs+7joCOrTJY6OFlVSRn45giQhuoJzA23lUqe53LpvqXNL8F08GMD3rZrhhjXcUKYsAfWlXDppfhYiSDIUnrkH4PvWgBluKFO2gfpSLqc0PwsRJBmK9mmPFuN23zstSYfRkiRKVxAcaCuXvprLLYIkQ+HFCwF83xrSEpErCWXKLlBfyiVD87MQQZKh6E7FbjNu973TkpRdWEG19Q26zTEGt+sKggNt5TLYTcuSAHtSsduM232fHB9LcVERVNfgUYESkKErCA60lct+zeUWQZKhDBgwQLcJ1uJ234eHh/nMcMPyJFJ0BcGBtnIZoLncIkgylNzcXN0mWIsE36d513DDQreSdAWBgbZyydVcbhEkGUr37t11m2AtEnyf9mXmbcxwk6UrCAy0lUt3zeUWQZKhVFRgLAl833rQ3YYyZROoL+VSoflZiCDJULAwKXzfJgkl8zEmCWVKPqgv5RKmeZFuBEmGEhsbq9sEa5Hge2ehW17ktqiiRrc5RiBBVxAYaCuXWM3lFkGSoRQVFek2wVok+L5jTCT1SjhTuRzGDDcxuoLAQFu5FGkutwiSDKVXr166TbAWKb7H8iQydQVNgbZy6aW53CJIMpQjR47oNsFapPgey5PI1BU0BdrK5YjmcosgyVB0p2K3GSm+PzvDDbmSJOkKmgJt5TIYy5IAE1Ox24wU33sTSmKGmyhdQVOgrVz2Y1kSEIj09HQ4RhNSfO8klMwqKKc6LHQrRlfQFGgrl3TN5RbdbYaiux/WZqT4vk+XOIqJDKfaeg/lnq4k25GiK2gKtJXLEYxJAoHo2bMnHKMJKb7nhW6dfElYnkSOrqAp0FYuPTWXW7QkGUpJSYluE6xFku+9mbeRK0mUrsAfaCuXEs3lFkGSoURHR+s2wVok+d47wy0fM9wk6Qr8gbZyidZcbhEkGUpERIRuE6xFku/PJpTEGm6SdAX+QFu5RGgutwiSDKWsDP/5w/cXDrrbUKZsAPWlXMo0PwsRJBlKUlKSbhOsRZLvnYHb+WXVVFxZSzYjSVfgD7SVS5LmcosgyVCys7N1m2AtknzfOTaKenSOUe9tz7wtSVfgD7SVS7bmcosgyVB0p2K3GWm+P7s8id3jkqTpCs4CbeUyGMuSABNTsduMNN+fXZ7E7pYkabqCs0BbuezHsiQgEIMGDYJjNCHN987yJLa3JEnTFZwF2splkOZyi+42Qzl48KBuE6xFmu/TeyChpERdwVmgrVwOai632oOk5cuX04ABAyg2NpZGjRpFW7duDXrs8ePHafr06aqPMjw8nObOnRvwuLVr19LQoUMpJiZGva5bt87v+9/85jcUFhbmtyUnJ5NJpKSk6DbBWqT5Pj3xTJCUWVBO9Q0eshVpuoKzQFu5pGgut1qDpDVr1qhAZ8GCBbRz504aP348TZ48Oeho9urqajUdkI8fPnx4wGM+/PBDmjZtGs2YMYN2796tXqdOnUoff/yx33GXXHKJCrqcbc+ePWQSBQUFuk2wFmm+79M1jqIjw6mmroGOWrzQrTRdwVmgrVwKNJdbrUHS448/TnfddRfdfffdNGTIEFq2bBmlpqbSihUrAh7fv39/evLJJ+n222+nhISEgMfwOa699lqaP38+XXzxxer1G9/4htrvS2RkpGo9crbz5WLgAI3XkPHdQkmHDh1Cen5gj+8jwsOof/czf9NhiwdvS9MVnAXayqWD5nKrLUiqqamhHTt20MSJE/328+ft27e3+rzcktT4nJMmTWpyTu7n7N27t+rqu/XWWykjI+Oc512yZIkKzJyNgzmmvLxcnau+vt47Cp9fKysrKSsri06fPk15eXl07NgxFVgdPnyYamtr/Y5lX/D1i4uLVavWiRMnqLS0lI4cOaKCM99j6+rq6NChQ+r7o0eP0qlTp6iwsFC1vvE1fY/1eDx04MABqqiooJycHBWR5+fnU25urspiGsjuqqoqdV22++TJk1672b7GdvNn3s/fs918fFFRkfo9n8f3WL4O283Xdexme9huts+x1/eV9/P3fBwfz7/j3/N5gtnN12c72J7m2M1/Hx/Pf69jt9OS6djNfuLrst/Yf2wP+5PtY/869vpqz+dgXRy7WS+2m/XzPZb1dexm3dluvg/YPr4vGtvN949jN99XbDffZ421d+zm+5Pt7hMfpb7718Fcr90NDQ0B71m2m8/t2M3XDGR3ZmamspXt5o3f877m2M3XCGQ32+TYzT5mf/PG752ydj67g5U11oRtC2Z3oLLG53DK2vnsDlbWQlVHOGUNdUS28kt71hGByprb64hAdjcYUEc09ndb1BHsw+YS5mH1NMCO6NOnD33wwQc0btw47/5HHnmEXnrppfNO+5swYQKNGDGiSQsRL4b34osvqrFLDqtWraJZs2Yp0ZiNGzeqm4BHzfPN/9BDD9EXX3xBe/fupe7duwe8Hv/W+T3DYnKgxKLHx8dTW8M3re6+WFuR6PvH3v6C/uedw/TdMX3p4W9dSjYiUVdwBmgrl9wQlFt+fnNjR3Oe35GkGR407QvHbI33tfU5edyTw6WXXkpjx46l9PR0FZzNmzcv4Dl5EDhv7UWXLl3a7VpAvu/Tvhy8bXMaAIm6gjNAW7l00VxutXW3JSYmqtV9uQnOF24K69mzZ6vPy+OLWnrOjh07qmBJ91RDX1rSHAjg++Zm3T5s8dIkKFNygbZyOa75WagtSOJuMZ7yv3nzZr/9/Nm3+62lcKtQ43Nu2rTpnOfkbrTPP/+cevXqRaaQlpam2wRrkeh7J+t2Xmk1lVbZudCtRF3BGaCtXNI0l1uts9u4a+u5556jP//5zypIue+++9RgttmzZ6vveWYaz2TzZdeuXWrjQXI84I3f79u3z/v9nDlzVFC0dOlSNc6IX7ds2eKXU+n++++n9957Tw0g49QAt9xyi+qjnDlzJpkCD+AD8H1bkRAXRYmdotX7zHw7u9xQpuQCbeVySPOzUOuYJM5nxKPpFy9erJrUhg0bRhs2bKB+/fqp73lf45xJI0eO9L7n2XE8KJuP59H/DLcYvfrqq7Rw4UJatGiRGmvE+ZjGjBnjNxDstttuUyPieer/V7/6Vfroo4+81zUB3Yv62YxU3/O4pPyyQjUu6bIU+8bnSNUVQFvJDNZcbrXNbnM7LRkd3xp4dp/um8NWpPp+/muf0epPcuinVw+keRPl/X226gqgrWT2h6DctuT5rX1ZEhAYk1q1bEOq750ZboctneEmVVcAbSXTT3O5RZBkKI1n6AH4/kKxfYYbypRcoK1cTmh+FiJIMpRgy64A+P5CZ7gdKSinBgsXukWZkgu0lUuC5mchgiRD4bTtAL5vS1K7xlFURBhV1TbQsWL7FrpFmZILtJVLjeZnIYIkQ+F1dQB835ZERoRT324drM28jTIlF2grl3rNz0IESYbSqdOZrhEA37cl6V92uWVYOC4JZUou0FYunTQ/CxEkGQrncALwfajGJdk4ww1lSi7QVi75mp+FCJIMJTU1VbcJ1iLZ984Mt4x8+1qSJOtqO9BWLqmayy2CJEPJyMjQbYK1SPZ9uhMkWdiSJFlX24G2csnQXG4RJBkKMgPD96FMKHm8uIoqaurIJlCm5AJt5TJYc5Z8BEkGp2IH8H1b07VjNHXrGG1laxLKlFygrVz2a34WIkgylLS0NN0mWIt036cl2pl5W7quNgNt5ZKmudwiSDKUnJwc3SZYi3TfewdvW9aSJF1Xm4G2csnRXG4RJBlKYmKibhOsRbrvnTQAGfl2BUnSdbUZaCuXRM3lFkGSoZSX2/UAMwnpvne622xLKCldV5uBtnIp11xuESQZSng4pIHvQ9uSlJlfTh6PPQvdokzJBdrKJVzzsxBPYkOJiYnRbYK1SPd9v+4dKDI8jCpq6ulESRXZgnRdbQbayiVGc7lFkGQoRUVFuk2wFum+j/JZ6PZwnj1dUNJ1tRloK5cizeUWQZKhJCcn6zbBWmzwvY3Lk9igq61AW7kkay63CJIMJSsrS7cJ1mKD770z3CxKA2CDrrYCbeWSpbncIkgyFN2p2G3GBt/bmFDSBl1tBdrKZTCWJQEmpmK3GRt8n97DvpYkG3S1FWgrl/1YlgQEYuDAgXCMJmzwvdOSdKy4kipr6skGbNDVVqCtXAZqLrfobjOUzMxM3SZYiw2+50VuE+KiiNMkcb4kG7BBV1uBtnLJ1FxuESQZiu4R/TZjg+/DwsKsm+Fmg662Am3lkozZbSAQxcXFcIwmbPF9WqJd45Js0dVGoK1cijWXW7QkGUp0dLRuE6zFFt97W5IsmeFmi642Am3lEq253CJIMhTd69XYjC2+T3dyJVkyJskWXW0E2solHGu3ARNXPrYZW3yf/mVL0uG8MisWurVFVxuBtnIp11xu8a+VoSQmJuo2wVps8X3f7h0oPIyovKae8kqrSTq26Goj0FYuiZrLLYIkQ8nJydFtgrXY4vuYyAhKdRa6tWBcki262gi0lUuO5nKLIMlQBg0apNsEa7HJ905SSRtmuNmkq21AW7kM0lxutQdJy5cvpwEDBlBsbCyNGjWKtm7dGvTY48eP0/Tp09VaLjyYa+7cuQGPW7t2LQ0dOpRiYmLU67p164Kec8mSJSpnTLBz6eLAgQO6TbAWm3xv00K3NulqG9BWLgc0l1utQdKaNWtUcLJgwQLauXMnjR8/niZPnkzZ2dkBj6+urqakpCR1/PDhwwMe8+GHH9K0adNoxowZtHv3bvU6depU+vjjj5sc++mnn9IzzzxDl112GZmG7ujZZmzy/dkZbvK722zS1TagrVwG2dyS9Pjjj9Ndd91Fd999Nw0ZMoSWLVtGqamptGLFioDH9+/fn5588km6/fbbKSEhIeAxfI5rr72W5s+fTxdffLF6/cY3vqH2+1JWVkbf/e536dlnn6WuXbue11YO0EpKSvw2ydGzzdjkeydXkg1jkmzS1TagrVwO2NqSVFNTQzt27KCJEyf67efP27dvb/V5uSWp8TknTZrU5Jz33nsv3XDDDXTNNdc067zcLceBmbNxMOdMTzx48CDV19d7Vyvm18rKSsrKyqLTp09TXl4eHTt2TAVWhw8fptraWr9j2RcZGRkqsyh3KZ44cUJd48iRIyo48z22rq6ODh06RKWlpXT06FE6deoUFRYWqtY3vqbvsTytm2+wiooKNfitoKCA8vPzKTc3VwWJgeyuqqpS12W7T5486bWb7WtsN3/m/fw9283HFxUVqd/zeXyP5euw3Xxdx262h+1m+xx7fV95P3/Px/Hx/Dv+PZ8nmN18fbaD7WmO3fz38fH89zp28/e+drOf+LrsN/Yf28P+ZPvYv469vtqz3ayLYzfrxXazfr7Hsr6O3aw72833AdvH90Vju/n+cezm+4rt5vussfaO3Xx/BrO7oaGBPMUn1G9yCyupqLRMnYvt5nM7dvM1A9nNayqxrWw3b/ye9zXHbr5GILvZJsdutpXt5o3fO2WNjwlU1hy7g5U1fs+2BbM7UFnjczhl7Xx2BytroaojnLKGOiKbOnfu3K51RKCyJrWO2H+OstYedQT3HrV1HcE+bDYeTRw9epQTs3g++OADv/0PP/ywZ9CgQef9/VVXXeWZM2dOk/1RUVGeV155xW8ff46OjvZ+Xr16tWfYsGGeysrKc57Ll6qqKk9xcbF3y8nJUfbz+1CQlZUVkvMC+N6XhoYGz7BfveXp9+Cbni+Ol4i+PVCm5AJt5ZIVgmchP7eb+/yOJM3woGlfOOJuvK8tz8nR5pw5c2jTpk1qsHhz4UHgvLUXHTue6QYB7Y9NvncWut2dW6yWJxmc3JmkYpOutgFt5dJRc7kN15kgKiIiQjXB+cJNYT179rygFYPPdU7u4uPPPJMuMjJSbe+99x794Q9/UO+5CdIEuLkQwPftgS3Lk6BMyQXayqVB87MwXOeidRyobN682W8/fx43blyrzzt27Ngm5+RWI+ecPIh7z549tGvXLu82evRoNYib33PgZgLcZwvg+3YdvJ0ne/A2ypRcoK1cajQ/C7V2t82bN09N0ecghYMbno7Pg9lmz56tvueZaTwwbOXKld7fcCDD8CA5HvDGnzng4nxIDHelXXnllbR06VKaMmUKrV+/nrZs2ULbtm1T3/MAv2HDhjVpzuvevXuT/ToJNnsPwPehypV0WHhLEsqUXKCtXBI0Pwu1Bkmcz4hH0y9evFiNNucgZcOGDdSvXz/1Pe9rnDNp5MiR3vfcdbZq1Sp1PI/+Z7jF6NVXX6WFCxfSokWLKD09XeVjGjNmDLkJ7jIcOHCgbjOsxDbfOy1JPCapLcYEmoptutoEtJXLCc3lNoxHb2u7uovhqYoc4fKUxvj4+DY/P4+NMqXrzzZs831VbT0N+dVbxDXBpwuuoaTO7TdBoT2xTVebgLZyqQ9BuW3J81v7siQgMJwvA+jBNt/HRkVQny5x3tYkqdimq01AW7kc0lxuESQZCq9PB+D79sKGGW4oU3KBtnIZrPlZiCDJUJxsoQC+bw9smOGGMiUXaCuX/ZqfhQiSDMUZvA7g+/ac4Sa5JQllSi7QVi79ND8LESQZSuOEmAC+DyXpiWdnuEkFZUou0FYuJzQ/CxEkGUqXLl10m2AtNvreaUnKOV1JNXUys73bqKstQFu5dNFcbhEkGQqvoAzg+/aiZ3wMdYyOoPoGD2UXyuxyQ5mSC7SVS7XmZyGCJEPRvV6Nzdjo+zML3X6ZefuUzCDJRl1tAdrKpcHWtduA2Ssf24ytvvfOcBM6LslWXW0A2sqlo+ZyiyDJUPLz83WbYC22+j4t8csZbkJbkmzV1QagrVzyNZdbBEmGkpqaqtsEa7HV975ruEnEVl1tANrKJVVzuUWQZCgZGRm6TbAWW33vDZKE5kqyVVcbgLZyydBcbhEkGYruVOw2Y6vvne62oopaKiyvIWnYqqsNQFu5DMayJMDEVOw2Y6vv46LPLnQrcfC2rbraALSVy34sSwICkZaWBsdowmbfSx6XZLOu0oG2cknTXG7R3WYoOTk5uk2wFpt9n+ZdnkTeuCSbdZUOtJVLjuZyiyDJUBITE3WbYC02+15yQkmbdZUOtJVLouZyiyDJUMrK5HV3uAWbfX92hps8H9isq3SgrVzKNJdbBEmGEhERodsEa7HZ9+lftiRlF1RQbb2sZTxs1lU60FYuEZrLLYIkQ4mOjtZtgrXY7Pvk+FiKi4qgOrXQbQVJwmZdpQNt5RKtudwiSDKU4uJi3SZYi82+Dw8PowFCB2/brKt0oK1cijWXWwRJhpKcnKzbBGux3fdS0wDYrqtkoK1ckjWXWwRJhpKVlaXbBGux3ffODDdpLUm26yoZaCuXLM3lFkGSoehOxW4ztvs+XegMN9t1lQy0lctgLEsCTEzFbjO2+z5daK4k23WVDLSVy34sSwICMXDgQDhGE7b73hm4zYvcFlXIWejWdl0lA23lMlBzuUV3m6FkZGToNsFabPd9x5hIlQpAWmuS7bpKBtrKJUNzuUWQZCi9evXSbYK1wPcyZ7hBV7lAW7n00vwsRJBkKEVFRbpNsBb43nd5EjktSdBVLtBWLkWan4UIkgwlNvZMdweA73UO3pbUkoQyJRdoK5dYzc9CBEmGEhYWptsEa4Hvz+ZKkjQmCbrKBdrKJUzzsxBBkqFUVMhaN8tNwPdEaV/OcMsqKKc6IQvdQle5QFu5VGh+FmoPkpYvX04DBgxQTWqjRo2irVu3Bj32+PHjNH36dJVcKjw8nObOnRvwuLVr19LQoUMpJiZGva5bt87v+xUrVtBll11G8fHxahs7dixt3LiRTKJ79+66TbAW+J6oT5c4iokMp9p6D+WeriQJQFe5QFu5dNf8LNQaJK1Zs0YFOgsWLKCdO3fS+PHjafLkyZSdnR3w+OrqakpKSlLHDx8+POAxH374IU2bNo1mzJhBu3fvVq9Tp06ljz/+2HtMSkoKPfroo/TPf/5TbVdffTVNmTKF9u7dS6aQm5ur2wRrge8bLXQrJPM2dJULtJVLruZnYZjH4/HouviYMWPo8ssvVy07DkOGDKGbbrqJlixZcs7fTpgwgUaMGEHLli3z288BUklJiV/L0HXXXUddu3al1atXBz1ft27d6LHHHqO77roraIDGmwNfIzU1Va1QzK1RbQ3Lorsv1lbg+zPc+8q/6O97jtPCG4bQ3ePTyO1AV7lAW7l4QvAs5Od3QkJCs57f2lqSampqaMeOHTRx4kS//fx5+/btrT4vtyQ1PuekSZOCnrO+vp5effVVKi8vV91uweCgjZ3qbBwgMfy7gwcPqvM46dP5tbKyUi3Md/r0acrLy6Njx44pYQ4fPky1tbV+x7IvOGEWC8ZdiidOnKDPPvuMjhw5ogIz32Pr6uro0KFDVFpaSkePHqVTp05RYWGhan3ja/oeyzfXgQMHVJ9uTk4OFRQUUH5+vorMy8rKAtpdVVWlrst2nzx50ms329fYbv7M+/l7tpuP5+ma/Hs+j++xfB22m6/r2M32sN1sn2Ov7yvv5+/5OD6ef8e/5/MEs5uvz3awPc2xm/8+Pp7/Xsdu515x7GY/8XXZb+w/tof9yfaxfx17fbVnu1kXx27Wi+1m/XyPZX0du1l3tpvvA7aP74vGdvP949jN9xXbzfdZY+0du/n+DGZ3Q0NDwHuW7eZzJ8aeGYu08/DxgHZnZmYqW9lu3vg972uO3XyNQHazTY7dbCvbzRu/d8ra+ewOVtZYV7YtmN2Byhqfwylr57M7WFkLVR3hlDXUEdm0a9eudq0jApU1G+uIo1/azdcMVR3BPTxtXUewD41vSWJH9OnThz744AMaN26cd/8jjzxCL7300nnXawnWkhQdHU0vvviiGrvksGrVKpo1a5ZfS9CePXtUUMQ3fKdOndQx119/fdDrtXdLEgC6Wbczl+5bs5v+Y0A3+n8/DP4PBAAAuAlXtCQ5NG5Ga4umteackwd/838fH330Ef3oRz+imTNn0r59+4KekweBOwO9nU3yon42A9+fIS3RyZUkIw0AdJULtJXLfs3PwkhdF05MTKSIiAjVBOcLN4X17Nmz1edNTk5u1jm5xclZOG/06NH06aef0pNPPklPP/00mUDfvn11m2At8L1/1u38smoqqaql+NgocjPQVS7QVi59NT8LtbUkcZDCU/43b97st58/+3a/tRTuQmt8zk2bNp33nNza5NudphvupwbwvU46x0ZRUucYMa1JKFNygbZyOaX5WaitJYmZN2+emqLPLTkc3DzzzDNqMNvs2bPV9/Pnz1cDw1auXOn9DXeRMTxIjp3Hnzng4nxIzJw5c+jKK6+kpUuXqmn969evpy1bttC2bdu85/jlL3+pUg3wmCIedMYDt99991166623yBR4nBSA73WTntSRTpVWq+VJRqR2ITeDMiUXaCuXTpqfhVqDJJ6uz6PpFy9erEabDxs2jDZs2ED9+vVT3/O+xjmTRo4c6X3Ps+N4wDUfz6P/GW4x4qBn4cKFtGjRIkpPT1f5mDjdgAPPVODgjM/Pg7c4sSQHSNdeey2ZAs88APC9CcuTfJRRSIcFrOGGMiUXaCuXes3PQq1BEnPPPfeoLRA8S60xzZmMd8stt6gtGM8//zyZDk+RBPC9KcuTSOhuQ5mSC7SVS43mZ6H22W0gMEgroA/4/izpXy50KyFIgq5ygbZyidecYgdBkqFwlyCA702Z4ZZZUE71DdqS87cJKFNygbZyOan5WYggyVD69++v2wRrge/PktK1A0VHhFNNXQMdK3L3QrfQVS7QVi79NT8LESQZCqdoB/C9biLCw6h/Ygf13u2Dt1Gm5AJt5XJY87MQQZKhcEZwAN+blHn7sMvHJaFMyQXaymWw5mchgiRD0Z2K3Wbg+8DjkjhXkpuBrnKBtnLZr/lZiCDJUHT3w9oMfN80V5KEGW7QVS7QVi79MSYJBIITXQI9wPdBWpLy3d2SBF3lAm3lclzzsxAtSYbSpYu7l4BwM/C9P+lfjkk6WVJNZdV15Fagq1ygrVy6aH4WIkgylKqqKt0mWAt8709ChyhK7BTt+nFJ0FUu0FYuVZqfhQiSDKU5y68A+L69Z7i5eVwSypRcoK1cPJqfhQiSDKVDhzO5aQB8bwISZrihTMkF2sqlg+ZnofYFbkFgCgoKKCEhAe7RAHwfPEjad7yEck9XkBvJzj5BfftG6TYDhABoK5e8Yyfpco3PQgRJhpKSkqLbBGuB74N3t235PE9t7uWQbgNAyIC2Evnmpcl0+SX6ro8gyVAyMzO1Zxq1Ffi+Kf+R1o0G9+xMRwrcPSYpLCxMtxkgBEBbuVRV6K1zwjy6R0W5lJKSEtUdVlxcTPHx8brNAQAAAEAbP78xcNtQdKditxn4XibQVS7QVi77NT8L0ZJkaEtSbW0tRUVhkKkO4HuZQFe5QFu51IbgWYiWJAFkZ2frNsFa4HuZQFe5QFu5ZGt+FqK7zVCSkpJ0m2At8L1MoKtcoK1ckjQ/CxEkGUpZmXuT9rkd+F4m0FUu0FYuZZqfhQiSDCUyEtkZ4HuAMgVQX9pNpOZnIYIkQ8GgbfgeoEwB1Je2E6V5AhOCJEPh0fcAvgcoUwD1pc2UaH4WIkgylB49eug2wVrge5lAV7lAW7n00PwsRJBkKLqnPdoMfC8T6CoXaCuXbM3PQiSTbCVYlgQAAABwH0gmKQDdqdhtBr6XCXSVC7SVy34sS+JOQt2SVF9fTxEREW1+XgDf2wrKlFygrVzqQ/AsREuSADIyMnSbYC3wvUygq1ygrVwyND8LkbGwlXg8npBOT+zUqZP2qY+2At/LBLrKBdrKpVMInoXO+Zzn+LlAkNRKSktL1WtqamprTwEAAAAAjc9xHjZzLjC7rZU0NDTQsWPHqHPnzhQWFkZtHeVy8JWTkxOS8U4AvrcNlCm5QFu5lIToWcgtSBwg9e7dm8LDz50JCS1JrYQdm5KSQqGEbwoESXqA72UCXeUCbeUSH4Jn4flakByQTBIAAAAAIAAIkgAAAAAAAoAgyUBiYmLo17/+tXoF8D1AmQKoL20kxoBnIQZuAwAAAAAEAC1JAAAAAAABQJAEAAAAABAABEkAAAAAAAFAkAQAAAAAEAAESQbx/vvv04033qiygHIW79dff123SVbwm9/8Rvnbd0tOTtZtFghBGeJMu6w3fx8XF0cTJkygvXv3wtcCtL3jjjualOOvfvWr2uwFzWPJkiX0la98Ra1e0aNHD7rpppto//79xpRbBEkGUV5eTsOHD6c//elPuk2xjksuuYSOHz/u3fbs2aPbJBCCMvS73/2OHn/8cfX9p59+qoLha6+91rsWI3B3/Xjdddf5leMNGza0q42g5bz33nt077330kcffUSbN2+muro6mjhxotLbiHLrAUbC0qxbt063GVbw61//2jN8+HDdZoAQl6GGhgZPcnKy59FHH/Xuq6qq8iQkJHieeuop+N/l9ePMmTM9U6ZM0WYTaBvy8vKUvu+9954R5RYtSQAQ0cGDB1VT7oABA+jWW2+ljIwM+EUYmZmZdOLECfVfqgMnqbvqqqto+/btWm0DbcO7776rumwGDRpE3//+9ykvLw+udRnFxcXqtVu3bkaUWwRJwHrGjBlDK1eupLfffpueffZZVSDHjRtHBQUF1vtGEqwr07NnT7/9/Nn5DriXyZMn0yuvvEL/93//R//93/+tumWuvvpqqq6u1m0aaCbcSDhv3jy64ooraNiwYUaU28iQXwEAF1SuDpdeeimNHTuW0tPT6aWXXlIFFsiCB/Q2rpgb7wPuY9q0ad73/IAdPXo09evXj/7+97/Tt7/9ba22gebx4x//mD777DPatm2bMeUWLUkANKJjx44qWOIuOCAHZ8Zi4/8+uUum8X+pwP306tVLBUkox+7gJz/5Cf3tb3+jd955h1JSUowptwiSAGgEN89//vnnqpIFcuDxZlzh8gwah5qaGjW7hrtXgSy4uzwnJwfl2HA8Ho9qQXrttddUVymXU5PKLbrbDKKsrIwOHTrk/cwD1nbt2qUGsPXt21erbZK5//77Vf4V9jH/d/LQQw9RSUkJzZw5U7dpoI3L0Ny5c+mRRx6hiy66SG38vkOHDjR9+nT42sXa8sZ5dG6++WYVFB05coR++ctfUmJiIn3rW9/Sajc4Nzz9f9WqVbR+/XqVK8lpMUpISFA5kbhLTWu5Dfn8OdBs3nnnHTX1sfHGU1tB6Jg2bZqnV69enqioKE/v3r093/72tz179+6FywWWIZ5OzCkfeEpxTEyM58orr/Ts2bNHt9ngArWtqKjwTJw40ZOUlKTKcd++fdX+7Oxs+NZwKICmvL3wwgveY3SW27AvjQQAAAAAAD5gTBIAAAAAQAAQJAEAAAAABABBEgAAAABAABAkAQAAAAAEAEESAAAAAEAAECQBAAAAAAQAQRIAAAAAQAAQJAEAAAAABABBEgAAtDEvvvgidenSBX4FwOUgSAIAaIPXaZozZw4NHDiQYmNj1areV1xxBT311FNUUVHhCmX69+9Py5Yt89s3bdo0OnDggDabAABtAxa4BQBoISMjg772ta+pFhdesPLSSy+luro6FVz8+c9/pt69e9N//ud/arGNV2uqr6+nyMjWVZG8MCdvAAB3g5YkAIAW7rnnHhWE/POf/6SpU6fSkCFDVKDEK7n//e9/pxtvvFEdV1xcTD/4wQ+oR48eFB8fT1dffTXt3r3bex5e/X3EiBH08ssvq1YdXj381ltvpdLSUr+g53e/+x2lpaWp4GX48OH017/+1fv9u+++q1Ybf/vtt2n06NEUExNDW7dupcOHD9OUKVNUC1enTp3oK1/5Cm3ZssX7uwkTJlBWVhbdd9996ve8BetuW7FiBaWnp1N0dDQNHjxY2esL//a5555Tq9bzCue82vnf/vY37/enT5+m7373u5SUlKT+Bv7+hRdeaFNNAAD+IEgCALQ7BQUFtGnTJrr33nupY8eOAY/hoIGDmxtuuEF1y23YsIF27NhBl19+OX3jG9+gwsJC77EczLz++uv05ptvqu29996jRx991Pv9woULVUDBgcrevXtVUPO9731PHefLz3/+c1qyZAl9/vnndNlll1FZWRldf/31KjDauXMnTZo0SQVv2dnZ6vjXXnuNUlJSaPHixXT8+HG1BWLdunWqW/FnP/sZ/fvf/6Yf/vCHNGvWLHrnnXf8jvuv//ovFTB+9tln6rocFDl/56JFi2jfvn20ceNGZR//LYmJiRegAgDgvHgAAKCd+eijjzxc/bz22mt++7t37+7p2LGj2n7+8597/vGPf3ji4+M9VVVVfselp6d7nn76afX+17/+tadDhw6ekpIS7/cPPPCAZ8yYMep9WVmZJzY21rN9+3a/c9x1112e2267Tb1/5513lD2vv/76eW0fOnSo549//KP3c79+/TxPPPGE3zEvvPCCJyEhwft53Lhxnu9///t+x3znO9/xXH/99d7PfP2FCxd6P7PdYWFhno0bN6rPN954o2fWrFnntQ8A0HZgTBIAQBtO95TDJ598Qg0NDaoFpbq6WrUccWtO9+7d/Y6rrKxUrUcO3M3WuXNn7+devXpRXl6ees+tL1VVVXTttdf6naOmpoZGjhzpt4+72nwpLy9XrTvcOnXs2DE1Zoqv7bQkNRdu+eEuQ194PNaTTz7pt49brxy4hY3/Jufv+NGPfqS6Iv/1r3/RxIkT6aabbqJx48a1yA4AQMtAkAQAaHd4NhsHSF988YXffh4zxDiDnjlg4oCHxww1xnfMT1RUlN93fG7+rXMOhsc59enTx+84HnvkS+OuvwceeECNU/r973+vbGa7brnlFhVgXWhAyI1Hjfed6++YPHmyGv/Efwd3/3GXI3dXsm0AgNCAIAkA0O5wyxC37PzpT3+in/zkJ0HHJfH4Ix6PxAO8ubWoNQwdOlQFQ9z6c9VVV7Xotzx4+4477lCDqRlu1Tpy5IjfMTwQm2fCnQselL5t2za6/fbbvfu2b9+u9rcEHrTN9vA2fvx4FcQhSAIgdCBIAgBoYfny5arLibu4eIYadzWFh4fTp59+qlqYRo0aRddccw2NHTtWdS0tXbpUzQrjbi8exM37GnePBYK7rO6//341WJtbZTgPU0lJiQpSeMbazJkzg/6WW494cDYP1uZWHR487bTsOHDw9v7776sZdRyMBRpMzcEMD8h2Bp2/8cYb6ry+M+XOx69+9Svlk0suuUR1RXIXYEuDLABAy0CQBADQAk+H5xljnCNp/vz5lJubq4IMbvnhoIZTBHBgwgHRggUL6M4776RTp05RcnIyXXnllWpafnP57W9/q1II8Mw1zs/EXXUcsPzyl7885++eeOIJdV0e+8PBz4MPPqgCLF94ZhvPVuO/h4OXM2Ow/eGAjscfPfbYY/TTn/6UBgwYoGbbcQqB5sItVuwnbsnibj9uSXr11Veb/XsAQMsJ49HbrfgdAAAAAIBokCcJAAAAACAACJIAAAAAAAKAIAkAAAAAIAAIkgAAAAAAAoAgCQAAAAAgAAiSAAAAAAACgCAJAAAAACAACJIAAAAAAAKAIAkAAAAAIAAIkgAAAAAAAoAgCQAAAACAmvL/AZq8oGlUtl/jAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fitness = gpsr.get_train_fit_history()\n",
    "generations = gpsr.generations\n",
    "plt.plot(np.arange(1, generations+1), fitness)\n",
    "plt.xlabel(\"Generations\")\n",
    "plt.ylabel(\"Fitness\")\n",
    "plt.xticks([1, 5, 10, 15, 20])\n",
    "plt.grid(True, linestyle=\":\", linewidth=0.5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "3e8dd2d2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y_min = min(np.min(y_train_scaled), np.min(y_test))\n",
    "y_max = max(np.max(y_train_scaled), np.max(y_test))\n",
    "\n",
    "plt.scatter(y_train_scaled, pred_train, s=5, label=\"Training\")\n",
    "plt.scatter(y_test, u_best, s=5, label=\"Test\")\n",
    "plt.plot([y_min, y_max], [y_min, y_max], \"k--\", linewidth=1)\n",
    "plt.grid(True, linestyle=\":\", linewidth=0.5)\n",
    "plt.xlabel(\"Targets\")\n",
    "plt.ylabel(\"Predictions\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  }
 ],
 "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.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}