diff --git a/eSTARlight&STARlight_efficiency.ipynb b/eSTARlight&STARlight_efficiency.ipynb
new file mode 100644
index 0000000..1c5ba6b
--- /dev/null
+++ b/eSTARlight&STARlight_efficiency.ipynb
@@ -0,0 +1,2714 @@
+{
+  "nbformat": 4,
+  "nbformat_minor": 0,
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "authorship_tag": "ABX9TyP4pV58kgJZVC1c1KJGDucJ",
+      "include_colab_link": true
+    },
+    "kernelspec": {
+      "name": "python3",
+      "display_name": "Python 3"
+    },
+    "language_info": {
+      "name": "python"
+    }
+  },
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {
+        "id": "view-in-github",
+        "colab_type": "text"
+      },
+      "source": [
+        "<a href=\"https://colab.research.google.com/github/neharozera/estarlight/blob/master/eSTARlight%26STARlight_efficiency.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 76
+        },
+        "id": "VLQQYPbHGufW",
+        "outputId": "3ced3f44-1bfd-4e00-b530-5019e709530c"
+      },
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-06bedc64-cd95-4621-bbdb-6396234a2e23\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-06bedc64-cd95-4621-bbdb-6396234a2e23\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving 1000weight_eSTAR.csv to 1000weight_eSTAR.csv\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "# Read the CSV file into a pandas DataFrame\n",
+        "dfJL = pd.read_csv('1000weight_eSTAR.csv', delimiter = ' ')\n",
+        "dfJL"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 424
+        },
+        "id": "EZkfMySkHKhg",
+        "outputId": "b5a3aa6e-2d78-4a5b-8cea-a677a790ec4c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "          _weight\n",
+              "0    7.211057e-04\n",
+              "1    3.797298e-05\n",
+              "2    1.185909e-06\n",
+              "3    2.771149e-04\n",
+              "4    7.428326e-04\n",
+              "..            ...\n",
+              "995  4.762781e-05\n",
+              "996  3.679190e-05\n",
+              "997  4.506751e-04\n",
+              "998  7.484310e-05\n",
+              "999  3.891889e-07\n",
+              "\n",
+              "[1000 rows x 1 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-e4d7a256-b549-42d0-bcb3-62cfb9712386\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>_weight</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>7.211057e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>3.797298e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>1.185909e-06</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>2.771149e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>7.428326e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>995</th>\n",
+              "      <td>4.762781e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>996</th>\n",
+              "      <td>3.679190e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>997</th>\n",
+              "      <td>4.506751e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>998</th>\n",
+              "      <td>7.484310e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>999</th>\n",
+              "      <td>3.891889e-07</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>1000 rows × 1 columns</p>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-e4d7a256-b549-42d0-bcb3-62cfb9712386')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-e4d7a256-b549-42d0-bcb3-62cfb9712386 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-e4d7a256-b549-42d0-bcb3-62cfb9712386');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-56d9272f-63b0-43e3-9ca0-b7dc0c0fb3f2\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-56d9272f-63b0-43e3-9ca0-b7dc0c0fb3f2')\"\n",
+              "            title=\"Suggest charts.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-56d9272f-63b0-43e3-9ca0-b7dc0c0fb3f2 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 3
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "dfJL1 = dfJL[\"_weight\"]*1"
+      ],
+      "metadata": {
+        "id": "N_Nw_jXbHiRy"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.rc('font',size=18)\n",
+        "plt.rcParams['figure.figsize'] = [12, 8]\n",
+        "ax1 = plt.subplot()\n",
+        "plt.hist(dfJL1, bins=np.logspace(start=np.log10(10**(-9)), stop=np.log10(1), num=35))\n",
+        "plt.gca().set_xscale(\"log\")\n",
+        "ax1.minorticks_on()\n",
+        "ax1.tick_params('both', length=15, width=2, which='major')\n",
+        "ax1.tick_params('both', length=7, width=1, which='minor')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 481
+        },
+        "id": "VaQ--bqdHrEd",
+        "outputId": "9ae3104c-63c7-459d-dda3-1bcef1f16ac8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "min(dfJL1), max(dfJL1)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "T6fITshpJjqA",
+        "outputId": "62c5f380-d408-42f3-c009-f1d4c8c2c92e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(5.4712760427301e-09, 0.0023608355786331)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 7
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calculate the average of the entire DataFrame\n",
+        "average = np.mean(dfJL1)\n",
+        "\n",
+        "# Print the average\n",
+        "print(\"Average of the data:\", average)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "AL4hdAm7MeoY",
+        "outputId": "b238e240-ce1f-432e-af0a-1f5e79a0021e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Average of the data: 0.00020731469384381696\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Efficiency = average/max(dfJL1)\n",
+        "\n",
+        "# Print the efficiency\n",
+        "print(\"Effiency of weight distribution(1000) is {:.2%}\".format(Efficiency))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "dEHAJ0tLNgS8",
+        "outputId": "08904891-0588-4201-b4d0-7327e932846e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Effiency of weight distribution(1000) is 8.78%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 76
+        },
+        "id": "Eyg1fN-L0mv6",
+        "outputId": "7d3fef2a-aff1-475a-f709-b14488d23a45"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-e73c1049-131b-4066-a7f0-60766588d1f7\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-e73c1049-131b-4066-a7f0-60766588d1f7\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving estartotalEweight.csv to estartotalEweight.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "# Read the CSV file into a pandas DataFrame\n",
+        "dfJQ = pd.read_csv('estartotalEweight.csv', delimiter = ' ')\n",
+        "dfJQ"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 424
+        },
+        "id": "2F7oI57z2MEH",
+        "outputId": "1d831645-e8d3-429e-ac89-bf998b5269e4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "              _weight\n",
+              "0        2.556725e-03\n",
+              "1        2.575669e-03\n",
+              "2        8.307553e-05\n",
+              "3        1.249811e-03\n",
+              "4        8.352440e-04\n",
+              "...               ...\n",
+              "2499339  3.397276e-07\n",
+              "2499340  3.903792e-07\n",
+              "2499341  9.819945e-07\n",
+              "2499342  5.005073e-07\n",
+              "2499343  3.020904e-05\n",
+              "\n",
+              "[2499344 rows x 1 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-f7ecc96d-4591-466d-a0b1-582d3e233c40\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>_weight</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>2.556725e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>2.575669e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>8.307553e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>1.249811e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>8.352440e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2499339</th>\n",
+              "      <td>3.397276e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2499340</th>\n",
+              "      <td>3.903792e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2499341</th>\n",
+              "      <td>9.819945e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2499342</th>\n",
+              "      <td>5.005073e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2499343</th>\n",
+              "      <td>3.020904e-05</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>2499344 rows × 1 columns</p>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-f7ecc96d-4591-466d-a0b1-582d3e233c40')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-f7ecc96d-4591-466d-a0b1-582d3e233c40 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-f7ecc96d-4591-466d-a0b1-582d3e233c40');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-ac10e176-0a1a-45a3-8608-8bdcd595c330\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-ac10e176-0a1a-45a3-8608-8bdcd595c330')\"\n",
+              "            title=\"Suggest charts.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-ac10e176-0a1a-45a3-8608-8bdcd595c330 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 14
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "dfJQ1 = dfJQ[\"_weight\"]*1"
+      ],
+      "metadata": {
+        "id": "r0VrYbgn2koO"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.rc('font',size=18)\n",
+        "plt.rcParams['figure.figsize'] = [12, 8]\n",
+        "ax1 = plt.subplot()\n",
+        "plt.hist(dfJQ1, bins=np.logspace(start=np.log10(10**(-10)), stop=np.log10(1), num=35))\n",
+        "plt.gca().set_xscale(\"log\")\n",
+        "ax1.minorticks_on()\n",
+        "ax1.tick_params('both', length=15, width=2, which='major')\n",
+        "ax1.tick_params('both', length=7, width=1, which='minor')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 460
+        },
+        "id": "c17Sjs6A24-N",
+        "outputId": "961d0a0b-0a16-4a6d-ce3b-cc74ddcbd9d7"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x800 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAABC8AAAKwCAYAAAC4UVWRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABQTElEQVR4nO3de5iW9X0n/vc4nA+DYytl1Agk1qDRbq1N2hQMcT3gkWJcE1eJ1qoZddfWKElMqsJYe3nE7rZxkUTjIbFxNbZZNoKHEGPEUw16xapoY3SQymgQZGYeRkSY+f3Bj2dnZGZgEGZumNfrurjyzP39fu77M4+3Ic873+d7V7S1tbUFAAAAoKB26+sGAAAAALojvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChDejrBiiG1tbWLF++PCNHjkxFRUVftwMAAMAurq2tLc3Nzdlrr72y227dr60QXpAkWb58eT72sY/1dRsAAAD0M8uWLcs+++zT7RzhBUmSkSNHJtl401RVVfVxNwAAAOzqmpqa8rGPfaz8ebQ7wguSpPxVkaqqKuEFAAAAvWZrti6wYScAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKzaNS+4GGhoY0NDR0O6dUKvVSNwAAANAzwot+YO7cuamrq+vrNgAAAGCbVLS1tbX1dRPsWFu78mLy5MlpbGxMVVVVL3UGAABAf9XU1JRRo0Zt1edQKy/6gZqamtTU1HQ7p6mpqZe6AQAAgJ6xYScAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACi0AX3dAADsisZdev8Ov0b9Ncfv8GsAABSBlRcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACs2Gnf1AQ0NDGhoaup1TKpV6qRsAAADoGeFFPzB37tzU1dX1dRsAAACwTYQX/UBtbW2mTp3a7ZxSqZTJkyf3UkcAAACw9YQX/UBNTU1qamq6ndPU1NRL3QAAAEDP2LATAAAAKDThBQAAAFBovjYCQL8z7tL7+7oFAAB6wMoLAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChDejrBtjxGhoa0tDQ0O2cUqnUS90AAABAzwgv+oG5c+emrq6ur9sAAACAbSK86Adqa2szderUbueUSqVMnjy5lzoCAACArSe86AdqampSU1PT7ZympqZe6gYAAAB6xoadAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKLQBfd0AO15DQ0MaGhq6nVMqlXqpGwAAAOgZ4UU/MHfu3NTV1fV1GwAAALBNhBf9QG1tbaZOndrtnFKplMmTJ/dSRwAAALD1hBf9QE1NTWpqarqd09TU1EvdAAAAQM/YsBMAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFtt3Ci2uuuSYVFRXlP91pbm7OrFmzcvDBB2fEiBEZNWpUPv3pT2f27NlZt27dFq/19ttv55JLLsknP/nJDB06NHvssUcOO+yw3HLLLWlra9ti/W9+85vU1tZm/PjxGTJkSPbcc89MmTIl991331b9rs8++2ymT5+effbZJ4MHD05NTU1OOumk/OxnP9uq+kceeSQnnXRSampqMnjw4Oyzzz6ZPn16nn322a2qBwAAgP6kom1rPu1vwSuvvJI//MM/zNq1a8vHujrt0qVL8/nPfz719fVJkmHDhmXDhg15//33kySHHHJIFi5cmOrq6k7rFy9enClTpmTlypVJkhEjRmTt2rVZv359kmTKlCmZN29eBg0a1Gn9/Pnzc8opp6SlpSVJUlVVlVKplNbW1iTJWWedlVtvvbXLAOaWW27J+eefX77eqFGj0tTUVP59Z86cmVmzZnVamySzZs1KXV1dkqSioiJVVVVpbGxMkgwYMCBz5szJOeec02X9jtLU1JRRo0alsbExVVVVvX59gN407tL7+7qF7aL+muP7ugUAgG3Wk8+hH3nlRWtra/7yL/8ya9euzWc/+9lu565fvz4nnnhi6uvrU1NTk4cffjhr1qxJS0tL7r777owcOTLPPfdcpk+f3ml9Y2NjTjjhhKxcuTITJkzIM888k+bm5qxZsybf/va3M3DgwDz44IO56KKLOq1//fXX88UvfjEtLS2ZOHFiXnnllTQ2NqaxsTFXXHFFkuS2227L9ddf32n9k08+mfPOOy/r16/PtGnTsmzZsqxevTorVqxIbW1tkqSuri733HNPp/X33HNPObiora3NihUrsnr16ixbtizTpk3L+vXrc9555+XJJ5/s9n0EAACA/uQjr7z4n//zf+aiiy7K6aefnv3226/84byz0956663lVQVPPPHEZmHHD3/4w5x22mlJkp/+9Kc54ogjOoxffvnlueqqqzJ06NC8+OKLGT9+fIfxq6++Ot/61rdSWVmZl156Kfvvv3+H8S9/+cv5wQ9+kDFjxmTJkiXZfffdO4zX1tbmO9/5TqqqqlJfX7/Z6o/DDjssixYtysEHH5zFixdn4MCBHcaPOeaYPPjggxk3blxeffXVVFZWlsc2bNiQT3ziE1m6dGmOOeaYLFiwoEPtunXrcuihh+aFF17IpEmT8thjj232/u1IVl4A/YmVFwAAfa/XVl68/vrr+Zu/+Zv8zu/8Tv7+7/9+i/PvuOOOJMnhhx/e6SqNU089tRxI3HnnnZuNbzrWfl57F154YUaMGJENGzbkrrvu6jC2Zs2a8p4W559//mbBRZJ885vfTLLxDfzxj3/cYey1117LokWLkiQzZszYLLhoX19fX59f/OIXHcYeffTRLF26tMO89gYNGpQZM2YkSRYtWpTXX399szkAAADQH32k8OLcc8/NmjVrcuONN2bPPffsdm5LS0sef/zxJMmxxx7b6ZyKioocc8wxSZKHHnqow9grr7ySN954o9v6ESNG5LDDDuu0ftGiRXnvvfe6rR83blwOOOCATusffvjh8utNPX7YpEmTMnLkyG7rR44cmYkTJ3Za376vD9cDAABAf7XN4cV3v/vdLFy4MEceeWTOOOOMLc5fsmRJeVPMgw46qMt5m8beeuutrFq1qnz8hRde2GxOd/UvvfRSh+M9rX/xxRc7rR89enRGjx7daW1lZWUmTJjQbf0BBxzQ4esk7Y0ePbocAn24HgAAAPqrAdtS9Oabb+ZrX/tahg4dmrlz525VzfLly8uv99577y7ntR9bvnx59thjj22qb2pqSqlUyogRIzrUV1dXZ+jQoVusb3+99j93d+1N488888xHql+xYsVm9R9244035sYbb+x2Tk9sCpYAAACgaLYpvKitrU1jY2OuvfbafPzjH9+qmubm5vLrYcOGdTmv/Vj7mm2t3xRebKrvrrb9ePvrFaH+w5qamvLmm292OwcAAAB2BT0OL37wgx/k/vvvzx/+4R/m4osv3hE9sRWqqqq2uIqjJ1pbW9PQ0LDdzgcAAADbS4/Ci7fffjsXXXRRKisr893vfjcDBmx9+aaNLJONm3d2pf1Y+5oP13f1GJUt1Xd37fbj7WuLUP9hF1988XYNjzY9ogYAAACKpkcbdl566aVZuXJlvvKVr2TChAkplUod/qxbt64898PH9tprr/JYd193aD/Wvqan9VVVVeWvjLSvf/fdd8tPHemuvv312v+8pa9q7Kh6AAAA6K96FF68/vrrSZI5c+Zk5MiRm/25+uqry3M3Hfv617+eZONTNnbbbePl2j/548M2jY0ZM6a8WWfS8QkhW1N/4IEHdjje0/pPfepTndb/9re/zYoVKzqt3bBhQ15++eVu65csWZINGzZ0Wt/+3B+uBwAAgP5qmx+V2lPDhg3LxIkTkyQPPPBAp3Pa2try4IMPJkmOPvroDmP7779/9t13327r16xZk8cee6zT+kmTJpWfMtJV/dKlS7NkyZJO64866qjy667qH3/88fJGm13VNzc354knnui0vv15P1wPAAAA/VWPwouf//znaWtr6/LPzJkzy3M3Hfsf/+N/lI+deeaZSZJHHnkkTz/99Gbnv/fee/Paa68lSc4444wOYxUVFeVjd999d+rr6zerv+mmm1IqlVJZWZnTTz+9w9jw4cNz8sknJ9m4cqSxsXGz+muvvTbJxlUj06ZN6zD28Y9/PJMmTUqSzJ49Ox988MFm9ddcc02SZOzYsfnc5z7XYWzy5MkZO3Zsh3ntffDBB5k9e3aSjUHL+PHjN5sDAAAA/VGvrbxINoYXBx98cNra2nLyySdn4cKFSTY+6eLee+/NueeemyQ59thjc8QRR2xWP2PGjIwZMyYtLS05/vjjs3jx4iTJunXrMmfOnFx++eVJkq985SvZf//9N6u/8sorM3z48DQ0NOTEE0/Mr3/96yQbV2xceeWVufnmm5Mkl112Waqrqzerv/baa1NZWZlf/epXOfXUU8v7U6xatSoXXHBBFixYkCS57rrrUllZ2aG2srIy1113XZJk/vz5ueCCC7Jq1aokG/e5OPXUU/P88893mAcAAAAkFW1tbW3b62SzZs1KXV1dko0rLzpTX1+fww8/vLxyYtiwYWltbc3atWuTJIccckgWLlzYaXiQJIsXL86UKVOycuXKJBtXSaxdu7a8EuLoo4/OvHnzMnjw4E7r58+fn1NOOaX8VI9Ro0alVCqV96E466yzcuutt6aioqLT+ltuuSXnn39+1q9fnyTZfffd09jYWP59Z86cmVmzZm3Ve1RRUZFRo0Zl9erVSZIBAwZkzpw5Oeecc7qs31E2PW2ksbGxyye5AOwqxl16f1+3sF3UX3N8X7cAALDNevI5tFdXXiTJuHHj8vzzz+eKK67IQQcdlIqKigwcODCHHnpobrjhhjz11FNdBhdJcuihh+bFF1/MV7/61fz+7/9+PvjggwwfPjyTJk3Kd7/73SxYsKDL4CJJjjvuuDz//PM599xzM27cuKxduzbV1dU56qij8qMf/Sjf+973ugwukuScc87J008/ndNOOy177713WlpaMnr06EybNi0LFy7sNrhINoYXCxcuzLRp0zJ69Oi0tLRk7733zmmnnZannnqqT4ILAAAAKLLtuvKCnZeVF0B/YuUFAEDfK/TKCwAAAICeEF4AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKLQBfd0AO15DQ0MaGhq6nVMqlXqpGwAAAOgZ4UU/MHfu3NTV1fV1GwAAALBNhBf9QG1tbaZOndrtnFKplMmTJ/dSRwAAALD1hBf9QE1NTWpqarqd09TU1EvdAAAAQM/YsBMAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEIb0NcNsOM1NDSkoaGh2zmlUqmXugEAAICeEV70A3Pnzk1dXV1ftwEAAADbRHjRD9TW1mbq1KndzimVSpk8eXIvdQQAAABbT3jRD9TU1KSmpqbbOU1NTb3UDQAAAPSMDTsBAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaAP6ugF2vIaGhjQ0NHQ7p1Qq9VI3AAAA0DPCi35g7ty5qaur6+s2AAAAYJsIL/qB2traTJ06tds5pVIpkydP7qWOAAAAYOsJL/qBmpqa1NTUdDunqampl7oBAACAnrFhJwAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0Ab0dQMA0N64S+/v6xYAACgYKy8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIU2oK8bYMdraGhIQ0NDt3NKpVIvdQMAAAA9I7zoB+bOnZu6urq+bgMAAAC2ifCiH6itrc3UqVO7nVMqlTJ58uRe6ggAAAC2nvCiH6ipqUlNTU23c5qamnqpGwAAAOgZG3YCAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKFtU3jx7LPPpq6uLlOnTs2ECRPyO7/zOxk4cGB+53d+JxMnTszf/d3fZdWqVd2e4+23384ll1yST37ykxk6dGj22GOPHHbYYbnlllvS1ta2xR5+85vfpLa2NuPHj8+QIUOy5557ZsqUKbnvvvu2+neYPn169tlnnwwePDg1NTU56aST8rOf/Wyr6h955JGcdNJJqampyeDBg7PPPvtk+vTpefbZZ7eq/p//+Z8zZcqUjB49OkOGDMn48eNTW1ubV199davqAQAAoL+oaNuapOBD/vt//++56aabyj8PGTIkAwcOTHNzc/nY7/7u72bevHn57Gc/u1n94sWLM2XKlKxcuTJJMmLEiKxduzbr169PkkyZMiXz5s3LoEGDOr3+/Pnzc8opp6SlpSVJUlVVlVKplNbW1iTJWWedlVtvvTUVFRWd1t9yyy05//zzy9cbNWpUmpqayqHJzJkzM2vWrC5//1mzZqWuri5JUlFRkaqqqjQ2NiZJBgwYkDlz5uScc87ptLatrS1nn312brvttiTJbrvtlhEjRqSpqSlJMmzYsNx777057rjjurz+jtDU1JRRo0alsbExVVVVvXptgPbGXXp/X7ew06i/5vi+bgEAYJv15HPoNq28+MxnPpPrr78+Tz75ZN5999289957aWpqSnNzc+64447sueeeeeeddzJt2rTyh/pNGhsbc8IJJ2TlypWZMGFCnnnmmTQ3N2fNmjX59re/nYEDB+bBBx/MRRdd1Om1X3/99Xzxi19MS0tLJk6cmFdeeSWNjY1pbGzMFVdckSS57bbbcv3113da/+STT+a8887L+vXrM23atCxbtiyrV6/OihUrUltbmySpq6vLPffc02n9PffcUw4uamtrs2LFiqxevTrLli3LtGnTsn79+px33nl58sknO62//vrry8HFzJkzy72//PLL+bM/+7O0tLTki1/8Yl5//fXu/yEAAABAP7FNKy+25KGHHsqUKVOSJD/4wQ9y+umnl8cuv/zyXHXVVRk6dGhefPHFjB8/vkPt1VdfnW9961uprKzMSy+9lP3337/D+Je//OX84Ac/yJgxY7JkyZLsvvvuHcZra2vzne98J1VVVamvr091dXWH8cMOOyyLFi3KwQcfnMWLF2fgwIEdxo855pg8+OCDGTduXF599dVUVlaWxzZs2JBPfOITWbp0aY455pgsWLCgQ+26dety6KGH5oUXXsikSZPy2GOPdRh/9913M3bs2DQ3N6e2tjY333zzZuMHHnhg3nrrrUyfPj3f//73u3qLtzsrL4CisPJi61l5AQDszHb4yost+dM//dPy6//4j//oMHbnnXcmSU499dTNgoskufDCCzNixIhs2LAhd911V4exNWvWlPe0OP/88zcLLpLkm9/8ZpKNb8KPf/zjDmOvvfZaFi1alCSZMWPGZsFF+/r6+vr84he/6DD26KOPZunSpR3mtTdo0KDMmDEjSbJo0aLNVk/8y7/8S/mrNZ3VV1dX57zzzkuS3HfffVmzZs1mcwAAAKC/2SHhRfsVB5/4xCfKr1955ZW88cYbSZJjjz2209oRI0bksMMOS7JxBUd7ixYtynvvvddt/bhx43LAAQd0Wv/www+XXx9zzDGd1k+aNCkjR47stn7kyJGZOHFip/Xt++qq/sADD8zYsWO7rX/vvffKQQsAAAD0ZwO214nef//9NDQ05Cc/+Ul574n99tsvJ554YnnOCy+8UH590EEHdXmugw46KAsWLMhLL73U4XhP6pcsWZIXX3yx0/rRo0dn9OjRndZWVlaW9+Loqv6AAw7o8HWS9kaPHp0999wzK1as6LJ+S71v8uKLL5a/fvNhN954Y2688cYuz9NTmzY7BQAAgKL5yOHFkCFD8v777292fOLEifmnf/qnDB48uHxs+fLl5dd77713l+fcNNbU1JRSqZQRI0Z0qK+urs7QoUO3WN/+eu1/7u7am8afeeaZj1S/YsWKbaofNmxYdt9996xevXqz+vaampry5ptvdtsHAAAA7Ao+cngxZsyYrF27NqVSqbxHw+GHH57rrrsu++67b4e57R+lOmzYsC7P2X6subm5HF5squ+utv14++vtbPWrV6/erL69qqqqLYYoPdHa2pqGhobtdj4AAADYXj5yeFFfX19+/dvf/jbf//7383d/93f5zGc+k8suuyxXXnnlR70Enbj44otz8cUXb7fzbdrlFQAAAIpmu27YOXr06FxyySV54IEHUlFRkb/927/NT37yk/L4po0wk6SlpaXL87Qfa1+z6XV3te3H29fuCvUAAADQH+2Qp4185jOfyaRJk5Ik3/nOd8rH99prr/Lr7vZr2DRWVVVV/spI+/p33323/NSR7urbX6/9z1vaK6Iv61taWrJ69epO6wEAAKA/2iHhRfL/NqV89dVXy8faP0mj/ZNDPmzT2IEHHtjheE/rP/WpT3Va/9vf/jYrVqzotHbDhg15+eWXu61fsmRJNmzY0Gl9+3N3Vb81vXdWDwAAAP3RDgsvXnvttSQdv/qw//77lzfxfOCBBzqtW7NmTR577LEkydFHH91hbNKkSeWnjHRVv3Tp0ixZsqTT+qOOOqr8uqv6xx9/vLxRZlf1zc3NeeKJJzqtb3/eruqXLFmSN954o9v6oUOHllevAAAAQH/W4/Biw4YNaWtr63bOwoUL86//+q9Jks9//vPl4xUVFTnjjDOSJHfffXeHzT43uemmm1IqlVJZWZnTTz+9w9jw4cNz8sknJ0nmzJmTxsbGzeqvvfbaJBtDk2nTpnUY+/jHP14OBGbPnp0PPvhgs/prrrkmSTJ27Nh87nOf6zA2efLkjB07tsO89j744IPMnj07ycagZfz48R3GTzrppIwcOTJtbW2d1q9evTo333xzkuTkk0/O8OHDN5sDAAAA/U2Pw4tly5blkEMOydy5c/Paa691CDKWLVuWa665Jn/+53+etra27LHHHvnqV7/aoX7GjBkZM2ZMWlpacvzxx2fx4sVJknXr1mXOnDm5/PLLkyRf+cpXsv/++292/SuvvDLDhw9PQ0NDTjzxxPz6179OsnHFxpVXXln+8H/ZZZelurp6s/prr702lZWV+dWvfpVTTz21vP/EqlWrcsEFF2TBggVJkuuuuy6VlZUdaisrK3PdddclSebPn58LLrggq1atSrJxH4tTTz01zz//fId57VVXV+eyyy5Lktx888258sory4+X/fd///eceOKJaWhoyPDhwz2lBQAAAP5/FW1bWkbxIfX19R1WFAwaNChVVVV57733yh/Ek2T8+PG57777csghh2x2jsWLF2fKlClZuXJlko2rJNauXVteCXH00Udn3rx5GTx4cKc9zJ8/P6ecckr5qRyjRo1KqVQq70Nx1lln5dZbb01FRUWn9bfcckvOP//8rF+/Pkmy++67p7GxsRzEzJw5M7NmzeryPZg1a1bq6uqSbFxNMmrUqPImmwMGDMicOXNyzjnndFrb1taWs88+O7fddluSjYHIiBEjyqtIhg0blnvvvTfHHXdcl9ffETY9KrWxsTFVVVW9em2A9sZden9ft7DTqL/m+L5uAQBgm/Xkc2iPw4t169Zl3rx5+fnPf56nn346y5cvzzvvvJPKysrsueee+U//6T/lz//8z3PaaaeV96fozNtvv51rr702P/nJT7Js2bIMGTIkBx10UM4888z85V/+ZXbbrftFIb/5zW9y7bXX5uGHH05DQ0NGjhyZQw45JLW1teWvlnTn2WefzezZs/Poo49mxYoVqa6uzmc/+9lceOGF+c//+T9vsf5nP/tZ/vEf/zFPPvlk3n333ey5556ZPHlyLr744hx66KFbrL/vvvsyd+7cPPfcc2lubs6YMWNy9NFH5+tf/3r222+/LdZvb8ILoCiEF1tPeAEA7Mx2aHjBrkl4ARSF8KI4hCMAwI7Uk8+hO+xpIwAAAADbg/ACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0Ab0dQPseA0NDWloaOh2TqlU6qVuAAAAoGeEF/3A3LlzU1dX19dtAAAAwDYRXvQDtbW1mTp1ardzSqVSJk+e3EsdAQAAwNYTXvQDNTU1qamp6XZOU1NTL3UDAAAAPWPDTgAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABTagL5ugB2voaEhDQ0N3c4plUq91A0AAAD0jPCiH5g7d27q6ur6ug0AAADYJsKLfqC2tjZTp07tdk6pVMrkyZN7qSMAAADYesKLfqCmpiY1NTXdzmlqauqlbgAAAKBnbNgJAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChDejrBtjxGhoa0tDQ0O2cUqnUS90AAABAzwgv+oG5c+emrq6ur9sAAACAbSK86Adqa2szderUbueUSqVMnjy5lzoCAACArSe86AdqampSU1PT7ZympqZe6gYAAAB6xoadAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAU2oC+boAdr6GhIQ0NDd3OKZVKvdQNAAAA9Izwoh+YO3du6urq+roNAAAA2CbCi36gtrY2U6dO7XZOqVTK5MmTe6kjAAAA2HrCi36gpqYmNTU13c5pamrqpW4AAACgZ2zYCQAAABSalRcAbLVxl97f1y0AANAPWXkBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChbVN4sXLlytx2222ZPn16DjzwwAwfPjyDBw/OPvvsk2nTpuVf/uVftniO5ubmzJo1KwcffHBGjBiRUaNG5dOf/nRmz56ddevWbbH+7bffziWXXJJPfvKTGTp0aPbYY48cdthhueWWW9LW1rbF+t/85jepra3N+PHjM2TIkOy5556ZMmVK7rvvvq16D5599tlMnz49++yzTwYPHpyampqcdNJJ+dnPfrZV9Y888khOOumk1NTUlN+76dOn59lnn92qegAAAOgvKtq25pP+hwwcODDr168v/zxkyJBUVlZmzZo15WPHHntsfvSjH2XYsGGb1S9dujSf//znU19fnyQZNmxYNmzYkPfffz9Jcsghh2ThwoWprq7u9PqLFy/OlClTsnLlyiTJiBEjsnbt2nJPU6ZMybx58zJo0KBO6+fPn59TTjklLS0tSZKqqqqUSqW0trYmSc4666zceuutqaio6LT+lltuyfnnn1++3qhRo9LU1FQOTWbOnJlZs2Z1Wpsks2bNSl1dXZKkoqIiVVVVaWxsTJIMGDAgc+bMyTnnnNNl/Y7Q1NSUUaNGpbGxMVVVVb16bWDnMe7S+/u6BXpR/TXH93ULAMAurCefQ7dp5cX69evzmc98Jv/rf/2v/OY3v8l7772XUqmU119/PWeffXaSZMGCBamtre209sQTT0x9fX1qamry8MMPZ82aNWlpacndd9+dkSNH5rnnnsv06dM7vXZjY2NOOOGErFy5MhMmTMgzzzyT5ubmrFmzJt/+9rczcODAPPjgg7nooos6rX/99dfzxS9+MS0tLZk4cWJeeeWVNDY2prGxMVdccUWS5Lbbbsv111/faf2TTz6Z8847L+vXr8+0adOybNmyrF69OitWrCj/vnV1dbnnnns6rb/nnnvKwUVtbW1WrFiR1atXZ9myZZk2bVrWr1+f8847L08++WTX/wAAAACgH9mmlRePPPJIDj/88C7HzzvvvMydOzdJ8sYbb+RjH/tYeezWW28tryp44okn8tnPfrZD7Q9/+MOcdtppSZKf/vSnOeKIIzqMX3755bnqqqsydOjQvPjiixk/fnyH8auvvjrf+ta3UllZmZdeein7779/h/Evf/nL+cEPfpAxY8ZkyZIl2X333TuM19bW5jvf+U6qqqpSX1+/2eqPww47LIsWLcrBBx+cxYsXZ+DAgR3GjznmmDz44IMZN25cXn311VRWVpbHNmzYkE984hNZunRpjjnmmCxYsKBD7bp163LooYfmhRdeyKRJk/LYY49t/ubuIFZeAFvDyov+xcoLAGBH2uErL7oLLpKUV18kyS9/+csOY3fccUf5HB8OLpLk1FNPLQcSd95552bjm461n9fehRdemBEjRmTDhg256667OoytWbOmvKfF+eefv1lwkSTf/OY3k2x8E3/84x93GHvttdeyaNGiJMmMGTM2Cy7a19fX1+cXv/hFh7FHH300S5cu7TCvvUGDBmXGjBlJkkWLFuX111/fbA4AAAD0NzvkaSNDhgwpv96wYUP5dUtLSx5//PEkG/fE6ExFRUWOOeaYJMlDDz3UYeyVV17JG2+80W39iBEjcthhh3Vav2jRorz33nvd1o8bNy4HHHBAp/UPP/xw+fWmHj9s0qRJGTlyZLf1I0eOzMSJEzutb9/Xh+sBAACgP9oh4cXPf/7z8uuDDz64/HrJkiXlTTEPOuigLus3jb311ltZtWpV+fgLL7yw2Zzu6l966aUOx3ta/+KLL3ZaP3r06IwePbrT2srKykyYMKHb+gMOOKDD10naGz16dPbcc89O6wEAAKA/GrC9T7h69epcffXVSTbuD/HJT36yPLZ8+fLy67333rvLc7QfW758efbYY49tqm9qakqpVMqIESM61FdXV2fo0KFbrG9/vfY/d3ftTePPPPPMR6pfsWLFZvXt3Xjjjbnxxhu7PU9PbAqVAAAAoGi2a3jR2tqaL3/5y2loaMiQIUPy7W9/u8N4c3Nz+XVnj1DtbKx9zbbWbwovNtV3V9t+vP31ilDfXlNTU958881uzwMAAAC7gu0aXvz1X/91fvKTnyRJbrrppvzBH/zB9jw97VRVVW1xBUdPtLa2pqGhYbudDwAAALaX7RZezJgxo7zS4u///u/zl3/5l5vN2bSRZbJx886utB9rX/Ph+q4epbKl+u6u3X68fW0R6tu7+OKLc/HFF3d7np7Y9IgaAAAAKJrtsmHn17/+9cyePTtJcsMNN+Siiy7qdN5ee+1Vft3dVx7aj7Wv6Wl9VVVV+Ssj7evffffd8lNHuqtvf732P2/p6xo7qh4AAAD6o48cXnzta1/L9ddfnyS57rrrcskll3Q594ADDshuu228ZPsnf3zYprExY8aUN+tMOj4hZGvqDzzwwA7He1r/qU99qtP63/72t1mxYkWntRs2bMjLL7/cbf2SJUs6PEK2vfbn/nA9AAAA9EcfKbyYMWNGbrjhhiQbg4uvfe1r3c4fNmxYJk6cmCR54IEHOp3T1taWBx98MEly9NFHdxjbf//9s++++3Zbv2bNmjz22GOd1k+aNKn8lJGu6pcuXZolS5Z0Wn/UUUeVX3dV//jjj5c32uyqvrm5OU888USn9e3P++F6AAAA6I+2ObyYMWNGh6+KbCm42OTMM89MkjzyyCN5+umnNxu/995789prryVJzjjjjA5jFRUV5WN333136uvrN6u/6aabUiqVUllZmdNPP73D2PDhw3PyyScnSebMmZPGxsbN6q+99tokG/ebmDZtWoexj3/845k0aVKSZPbs2fnggw82q7/mmmuSJGPHjs3nPve5DmOTJ0/O2LFjO8xr74MPPii/p5MmTcr48eM3mwMAAAD9zTaFF+33uLjxxhu7/arIh5155pk5+OCD09bWlpNPPjkLFy5MsvFpF/fee2/OPffcJMmxxx6bI444YrP6GTNmZMyYMWlpacnxxx+fxYsXJ0nWrVuXOXPm5PLLL0+SfOUrX8n++++/Wf2VV16Z4cOHp6GhISeeeGJ+/etfJ9m4YuPKK6/MzTffnCS57LLLUl1dvVn9tddem8rKyvzqV7/KqaeeWt6fYtWqVbnggguyYMGCJBtXolRWVnaorayszHXXXZckmT9/fi644IKsWrUqycZ9Lk499dQ8//zzHeYBAABAf1fR1tbW1pOCN954o7x6YLfddsuee+7Z7fwZM2ZkxowZHY7V19fn8MMPL6+cGDZsWFpbW7N27dokySGHHJKFCxd2Gh4kyeLFizNlypSsXLkyycZVEmvXri2vhDj66KMzb968DB48uNP6+fPn55RTTik/1WPUqFEplUrlfSjOOuus3HrrramoqOi0/pZbbsn555+f9evXJ0l23333NDY2ZtNbOXPmzMyaNavL92TWrFmpq6tLsnE1yahRo7J69eokyYABAzJnzpycc845XdbvCJueNtLY2NjlU1wAxl16f1+3QC+qv+b4vm4BANiF9eRzaI9XXrS2tnZ4/fbbb3f7p1QqbXaOcePG5fnnn88VV1yRgw46KBUVFRk4cGAOPfTQ3HDDDXnqqae6DC6S5NBDD82LL76Yr371q/n93//9fPDBBxk+fHgmTZqU7373u1mwYEGXwUWSHHfccXn++edz7rnnZty4cVm7dm2qq6tz1FFH5Uc/+lG+973vdRlcJMk555yTp59+Oqeddlr23nvvtLS0ZPTo0Zk2bVoWLlzYbXCRbAwvFi5cmGnTpmX06NFpaWnJ3nvvndNOOy1PPfVUrwcXAAAAUGQ9XnnBrsnKC2BrWHnRv1h5AQDsSDt05QUAAABAbxJeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACi0AX3dADteQ0NDGhoaup1TKpV6qRsAAADoGeFFPzB37tzU1dX1dRsAAACwTYQX/UBtbW2mTp3a7ZxSqZTJkyf3UkcAAACw9YQX/UBNTU1qamq6ndPU1NRL3QAAAEDP2LATAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCG9DXDbDjNTQ0pKGhods5pVKpl7oBAACAnhFe9ANz585NXV1dX7cBAAAA20R40Q/U1tZm6tSp3c4plUqZPHlyL3UEAAAAW0940Q/U1NSkpqam2zlNTU291A0AAAD0jA07AQAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAotAF93QA7XkNDQxoaGrqdUyqVeqkbAAAA6BnhRT8wd+7c1NXV9XUbAAAAsE2EF/1AbW1tpk6d2u2cUqmUyZMn91JHAAAAsPWEF/1ATU1Nampqup3T1NTUS90AAABAzwgvAHYR4y69v69bAACAHcLTRgAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAAptQF83AAAU07hL79/h16i/5vgdfg0AYOdn5QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaAP6ugF2vIaGhjQ0NHQ7p1Qq9VI3AAAA0DPCi35g7ty5qaur6+s2AAAAYJsIL/qB2traTJ06tds5pVIpkydP7qWOAAAAYOsJL/qBmpqa1NTUdDunqampl7oBAACAnrFhJwAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAAptm8KLlpaWLFiwIFdddVW+8IUvZOzYsamoqEhFRUVmzZq1Ved4++23c8kll+STn/xkhg4dmj322COHHXZYbrnllrS1tW2x/je/+U1qa2szfvz4DBkyJHvuuWemTJmS++67b6uu/+yzz2b69OnZZ599Mnjw4NTU1OSkk07Kz372s62qf+SRR3LSSSelpqYmgwcPzj777JPp06fn2Wef3ar6f/7nf86UKVMyevToDBkyJOPHj09tbW1effXVraoHAACA/qKibWuSgg/5+c9/nsMPP7zTsZkzZ24xwFi8eHGmTJmSlStXJklGjBiRtWvXZv369UmSKVOmZN68eRk0aFCn9fPnz88pp5ySlpaWJElVVVVKpVJaW1uTJGeddVZuvfXWVFRUdFp/yy235Pzzzy9fb9SoUWlqaiqHJlv6HWbNmpW6urokSUVFRaqqqtLY2JgkGTBgQObMmZNzzjmn09q2tracffbZue2225Iku+22W0aMGJGmpqYkybBhw3LvvffmuOOO6/L6O0JTU1NGjRqVxsbGVFVV9eq1ge1j3KX393UL0GP11xzf1y0AAH2kJ59Dt/lrI9XV1TniiCPyta99LT/84Q8zZsyYraprbGzMCSeckJUrV2bChAl55pln0tzcnDVr1uTb3/52Bg4cmAcffDAXXXRRp/Wvv/56vvjFL6alpSUTJ07MK6+8ksbGxjQ2NuaKK65Iktx22225/vrrO61/8sknc95552X9+vWZNm1ali1bltWrV2fFihWpra1NktTV1eWee+7ptP6ee+4pBxe1tbVZsWJFVq9enWXLlmXatGlZv359zjvvvDz55JOd1l9//fXl4GLmzJnl3l9++eX82Z/9WVpaWvLFL34xr7/++la9nwAAALCr26aVFxs2bEhlZWWHY+PGjcvSpUu3uGrh8ssvz1VXXZWhQ4fmxRdfzPjx4zuMX3311fnWt76VysrKvPTSS9l///07jH/5y1/OD37wg4wZMyZLlizJ7rvv3mG8trY23/nOd1JVVZX6+vpUV1d3GD/ssMOyaNGiHHzwwVm8eHEGDhzYYfyYY47Jgw8+mHHjxuXVV1/t8Htu2LAhn/jEJ7J06dIcc8wxWbBgQYfadevW5dBDD80LL7yQSZMm5bHHHusw/u6772bs2LFpbm5ObW1tbr755s3GDzzwwLz11luZPn16vv/973f5Pm5vVl7Azs/KC3ZGVl4AQP+1w1defDi46Ik777wzSXLqqaduFlwkyYUXXpgRI0Zkw4YNueuuuzqMrVmzprynxfnnn79ZcJEk3/zmN5NsfBN+/OMfdxh77bXXsmjRoiTJjBkzNgsu2tfX19fnF7/4RYexRx99NEuXLu0wr71BgwZlxowZSZJFixZttnriX/7lX9Lc3NxlfXV1dc4777wkyX333Zc1a9ZsNgcAAAD6m1592sgrr7ySN954I0ly7LHHdjpnxIgROeyww5IkDz30UIexRYsW5b333uu2fty4cTnggAM6rX/44YfLr4855phO6ydNmpSRI0d2Wz9y5MhMnDix0/r2fXVVf+CBB2bs2LHd1r/33nvloAUAAAD6s14NL1544YXy64MOOqjLeZvGXnrppY9U/+KLL3ZaP3r06IwePbrT2srKykyYMKHb+gMOOKDL1SejR4/Onnvu2W391vTeWT0AAAD0RwN682LLly8vv9577727nLdprKmpKaVSKSNGjOhQX11dnaFDh26xvv312v/c3bU3jT/zzDMfqX7FihXbVD9s2LDsvvvuWb169Wb17d1444258cYbu+2jJzY9qQUAAACKplfDi037PSQbP6R3pf1Yc3NzObzYVN9dbfvx9tfb2epXr169WX17TU1NefPNN7s9DwAAAOwKejW8YPupqqra4gqQnmhtbU1DQ8N2Ox8AAABsL70aXmzaCDNJWlpaunwUSktLS6c1m163H++uvn1tUepXrVq1zfXtXXzxxbn44ou7PU9PbHpEDQAAABRNr27Yuddee5Vfd/eVh01jVVVV5a+MtK9/9913y08d6a6+/fXa/7ylr1v0ZX1LS0tWr17daT0AAAD0R70aXrR/kkb7J4d82KaxAw888CPVf+pTn+q0/re//W1WrFjRae2GDRvy8ssvd1u/ZMmSbNiwodP69ufuqn5reu+sHgAAAPqjXg0v9t9//+y7775JkgceeKDTOWvWrMljjz2WJDn66KM7jE2aNKn8lJGu6pcuXZolS5Z0Wn/UUUeVX3dV//jjj5c3yuyqvrm5OU888USn9e3P21X9kiVL8sYbb3RbP3To0EyaNKnTOQAAANCf9Gp4UVFRkTPOOCNJcvfdd6e+vn6zOTfddFNKpVIqKytz+umndxgbPnx4Tj755CTJnDlz0tjYuFn9tddem2TjfhHTpk3rMPbxj3+8HAjMnj07H3zwwWb111xzTZJk7Nix+dznPtdhbPLkyRk7dmyHee198MEHmT17dpKNQcv48eM7jJ900kkZOXJk2traOq1fvXp1br755iTJySefnOHDh282BwAAAPqbbQ4v3n333bzzzjvlP62trUk27tnQ/nipVOpQN2PGjIwZMyYtLS05/vjjs3jx4iTJunXrMmfOnFx++eVJkq985SvZf//9N7vulVdemeHDh6ehoSEnnnhifv3rXyfZuGLjyiuvLH/4v+yyy1JdXb1Z/bXXXpvKysr86le/yqmnnlref2LVqlW54IILsmDBgiTJddddl8rKyg61lZWVue6665Ik8+fPzwUXXJBVq1Yl2biPxamnnprnn3++w7z2qqurc9lllyVJbr755lx55ZVZs2ZNkuTf//3fc+KJJ6ahoSHDhw/PlVde2f0/AAAAAOgnKtra2tq2pXDcuHFZunTpFuedeeaZuf322zscW7x4caZMmZKVK1cm2bhKYu3ateWVEEcffXTmzZuXwYMHd3rO+fPn55RTTik/lWPUqFEplUrlfSjOOuus3HrrramoqOi0/pZbbsn555+f9evXJ0l23333NDY2ZtNbMXPmzMyaNavL32nWrFmpq6tLsnE1yahRo8qbbA4YMCBz5szJOeec02ltW1tbzj777Nx2221JNgYiI0aMKK8iGTZsWO69994cd9xxXV5/R9j0tJHGxsYunwIDFNu4S+/v6xagx+qvOb6vWwAA+khPPof26tdGNjn00EPz4osv5qtf/Wp+//d/Px988EGGDx+eSZMm5bvf/W4WLFjQZXCRJMcdd1yef/75nHvuuRk3blzWrl2b6urqHHXUUfnRj36U733ve10GF0lyzjnn5Omnn85pp52WvffeOy0tLRk9enSmTZuWhQsXdhtcJBvDi4ULF2batGkZPXp0Wlpasvfee+e0007LU0891WVwkWwMO773ve/lRz/6UY466qhUV1dn7dq1GTt2bM4999z86le/6vXgAgAAAIpsm1desGux8gJ2LKsioHNWXgBA/1X4lRcAAAAAW0t4AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQBvR1A+x4DQ0NaWho6HZOqVTqpW4AAACgZ4QX/cDcuXNTV1fX120AAADANhFe9AO1tbWZOnVqt3NKpVImT57cSx0BAADA1hNe9AM1NTWpqanpdk5TU1MvdQMAAAA9Y8NOAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKbUBfN8CO19DQkIaGhm7nlEqlXuoGimncpff3dQsAAEAXhBf9wNy5c1NXV9fXbQAAAMA2EV70A7W1tZk6dWq3c0qlUiZPntxLHQEAAMDWE170AzU1Nampqel2TlNTUy91AwAAAD1jw04AAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhWbDTgCgz4y79P4dfo36a47f4dcAAHYsKy8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFNqAvm4AYEvGXXp/X7cAAAD0ISsvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSaDTv7gYaGhjQ0NHQ7p1Qq9VI3AAAA0DPCi35g7ty5qaur6+s2AAAAYJsIL/qB2traTJ06tds5pVIpkydP7qWOAAAAYOsJL/qBmpqa1NTUdDunqampl7oBAACAnrFhJwAAAFBowgsAAACg0IQXAAAAQKHZ8wL4SMZden9ftwAAAOzirLwAAAAACk14AQAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgEITXgAAAACFJrwAAAAACk14AQAAABSa8AIAAAAotAF93QCw44y79P6+bgGgz/XGfxfWX3P8Dr8GAPRnVl4AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBonjbSDzQ0NKShoaHbOaVSqZe6AQAAgJ4RXvQDc+fOTV1dXV+3AQAAANtEeNEP1NbWZurUqd3OKZVKmTx5ci91RJKMu/T+vm4BAABgpyC86AdqampSU1PT7ZympqZe6gYAAAB6xoadAAAAQKEJLwAAAIBCE14AAAAAhWbPC+iEzTQBAACKw8oLAAAAoNCEFwAAAECh+doIAMBH1BtfN6y/5vgdfg0AKCrhBTsd+1EAAAD0L742AgAAABSa8AIAAAAoNOEFAAAAUGjCCwAAAKDQhBcAAABAoQkvAAAAgELzqFQAgJ1AbzwqvP6a43f4NQBgW1h50Ueam5sza9asHHzwwRkxYkRGjRqVT3/605k9e3bWrVvX1+0BAABAYVh50QeWLl2az3/+86mvr0+SDBs2LO+//35++ctf5pe//GXuuuuuLFy4MNXV1X3bKAAAABSA8KKXrV+/PieeeGLq6+tTU1OTO++8M0ceeWRaW1tz77335txzz81zzz2X6dOn5/77d/zyUAAA+idfRQJ2JsKLXnbHHXfk3/7t35Ik9913Xz772c8mSXbbbbd86UtfSmtra0477bTMnz8/CxcuzBFHHNGX7QIA/YgPswAUlfCil91xxx1JksMPP7wcXLR36qmn5m/+5m/y+uuv58477xReAAC7FAHJ1umN9wlgZyK86EUtLS15/PHHkyTHHntsp3MqKipyzDHHZM6cOXnooYd6sz0AgF2CD/7FIawCthfhRS9asmRJWltbkyQHHXRQl/M2jb311ltZtWpV9thjj83m3Hjjjbnxxhu3W28bNmxIkjQ1NW23c+4ore+39HULAAAUxM7wv1+Bzm3697etrW2Lc4UXvWj58uXl13vvvXeX89qPLV++vNPwoqmpKW+++eb2bTDJxz72se1+TgAA2FFG/Y++7gD4qJqbmzNq1Khu5wgvelFzc3P59bBhw7qc136sfU17VVVV3QYgPdXa2ppzzjknl1xySSoqKrbbeSm+CRMmpKGhITU1NXn55Zf7uh3YjHuUonOPUnTuUYrOPdp/tbW1pbm5OXvttdcW5wovdlIXX3xxLr744r5ug13AbrvtVv7PqqqqPu4GNucepejcoxSde5Sic4/2b1tacbHJbju4D9oZOXJk+XVLS9f7NrQfa18DAAAA/ZHwohe1XwrT3X4V7ce2ZvkMAAAA7MqEF73ogAMOKC+JeuGFF7qct2lszJgxnW7WCQAAAP2J8KIXDRs2LBMnTkySPPDAA53OaWtry4MPPpgkOfroo3utNwAAACgq4UUvO/PMM5MkjzzySJ5++unNxu+999689tprSZIzzjijV3sDAACAIhJe9LIzzzwzBx98cNra2nLyySdn4cKFSTY+qvTee+/NueeemyQ59thjc8QRR/RlqwAAAFAIHpXaywYMGJB58+bl8MMPT319fY488sgMGzYsra2tWbt2bZLkkEMOyV133dXHnQIAAEAxWHnRB8aNG5fnn38+V1xxRQ466KBUVFRk4MCBOfTQQ3PDDTfkqaeeSnV1dV+3CQAAAIVg5UUfGTlyZOrq6lJXV9fXrQAAAEChWXkBAAAAFJrwAgAAACg04QUAAABQaMILAAAAoNCEFwAAAEChCS8AAACAQhNeAAAAAIUmvAAAAAAKTXgBAAAAFNqAvm4A6FsXX3xxmpqaUlVV1detQKfcoxSde5Sic49SdO5RtkZFW1tbW183AQAAANAVXxsBAAAACk14AWx3y5Yty5lnnpnf+73fy+DBg3PggQfmH/7hH2KhF0XwF3/xF6moqOjyz7nnntvXLdLP1dfXd3l//sVf/EVftwd54403Mn369EyYMCFVVVUZMWJEDjrooFx55ZVpbm7u6/YgpVIps2bNygknnJAxY8b4789dhD0vgO2qoaEhf/Inf5J33303/+2//bfst99+efTRR/PXf/3XeeONN3LDDTf0dYv0c7W1tTnyyCM3O3777bdn4cKFOf744/ugK9jcSSedlC984Qsdjn3iE5/oo27g/3n77bfzH//xHznppJPysY99LJWVlfnlL3+Zq666KvPmzcuTTz6ZgQMH9nWb9GPvvPNO6urqUlNTkz/+4z/O/fff39ctsR3Y8wLYrv7qr/4q//iP/5gf/ehHOfnkkzscv+mmm/Liiy9mwoQJfdghbK61tTVjx47N+++/nzfffNP/6KZP1dfXZ/z48Zk5c2ZmzZrV1+3AVrv++uvz9a9/Pffff3+OO+64vm6Hfuz999/PO++8k7333jtr167N0KFDc+aZZ+b222/v69b4CHxtBNiuHn300QwdOnSz/7fwy1/+clpbW/NP//RPfdQZdO2nP/1p/uM//iOnn3664IJCee+99/Lee+/1dRuwVcaPH58keffdd/u4E/q7wYMHZ++99+7rNtjOhBfAdvX+++9n6NChqaio6HB8+PDhSZJnnnmmL9qCbt12221JkrPOOquPO4H/Z/bs2Rk2bFiGDRuW/fbbL//4j/9o7yAKZe3atXnnnXeybNmy3H///fnWt76VIUOG5HOf+1xftwbsgoQXUGAtLS1ZsGBBrrrqqnzhC1/I2LFjy5u2be1S4ubm5syaNSsHH3xwRowYkVGjRuXTn/50Zs+enXXr1m33nidMmJBVq1blhRde6HD8kUceSZK8+eab2/2a9J2d8R79sMbGxvz4xz/OH/3RH+UP/uAPdvj16F074z2622675YgjjsjVV1+defPmZe7cuamurs5f/dVf5atf/ep2vx59a2e8Rze55ZZbsueee2bffffNCSeckN122y3/5//8n3zsYx/bYdek9+3M9yi7Fht2QoH967/+60f6zujSpUvz+c9/PvX19UmSYcOG5f33388vf/nL/PKXv8xdd92VhQsXprq6erPatra2vP/++1t1nd122y2DBg1Kklx44YWZN29evvSlL+Uf/uEfst9+++UXv/hFLrvssgwYMCAtLS3b/PtQPDvjPfphd999d9auXWvVxS5qZ7xH99133/z0pz/tMH722WfniCOOyD/8wz+ktrY2BxxwwDb/ThTLzniPbjJt2rRMmDAhjY2NeeKJJ/Loo4+mqalpm38XimlnvkfZtVh5AQVXXV2dI444Il/72tfywx/+MGPGjNmquvXr1+fEE09MfX19ampq8vDDD2fNmjVpaWnJ3XffnZEjR+a5557L9OnTO61funRphg4dulV//uiP/qhcd8QRR+S2227LW2+9lSOPPDLjxo1LbW1t/u7v/i7V1dUZOXLkdnlfKI6d7R79sNtvvz2DBg3Kaaedtk2/P8W3s9+jSVJZWZlvfOMbaWtry8MPP9zj94Bi21nv0X322SdHHnlkTj755MyePTvf+MY3csopp2wWvrHz21nvUXYtVl5AgR122GFZtWpVh2OXXnrpVtXecccd+bd/+7ckyX333ZfPfvazSTam0l/60pfS2tqa0047LfPnz8/ChQtzxBFHdKj/3d/93fI+AFvy4aT8zDPPzH/9r/81zz//fNatW5eDDjooAwYMyIUXXpjDDz98q87JzmFnvUc3eeWVV/LUU0/lv/yX/5I99thjq87FzmVnv0fbGzt2bJKNjwBk17Er3aNf+MIXMmTIkNx2222dPpKandOudI+ycxNeQIFVVlZuc+0dd9yRJDn88MPLf1G0d+qpp+Zv/uZv8vrrr+fOO+/c7C+LESNG5C/+4i+2+fqDBg3KH//xH5d/njdvXlpbW3PMMcds8zkpnp35Hk1s1Nkf7Oz3aHuvvvpqkuT3fu/3tts56Xu70j26fv36fPDBB542sovZle5Rdm6+NgK7oJaWljz++ONJkmOPPbbTORUVFeUg4aGHHtqh/TQ3N+eyyy7Lvvvumy996Us79FrsHIpwj27YsCHf//73U1NTkylTpmz387Nz68t79Le//e1mx9auXZu//du/TWVlpfuVJH17j7799tudHp87d242bNiQP/mTP9lu12LnVYS/69m1WHkBu6AlS5aktbU1SXLQQQd1OW/T2FtvvZVVq1Ztl2XzpVIpf/qnf1rejfqtt97KrbfemhUrVuShhx7KsGHDPvI12Pn15T26ycMPP5zly5fnG9/4xkf6f5XYNfXlPVpbW5uVK1fm8MMPzz777JO33nord955Z1599dXMnDkz++2330e+Bju/vrxHv/GNb+Sll17KUUcdlbFjx6ZUKuXRRx/N//2//zef/OQn89d//dcf+Rrs/Pr67/pvf/vbWb16ddavX58kef7553PVVVclST73uc95pO9OSHgBu6Dly5eXX++9995dzms/tnz58u3yl8WgQYPyqU99Krfffnvefvvt7L777jnyyCMzc+bM7L///h/5/Owa+vIe3eT2229PEstR6VRf3qMnnHBC7rzzztx8881ZtWpVhg8fnj/6oz/KNddck5NPPvkjn59dQ1/eo1/4wheycuXK3HHHHVmxYkUGDBiQ/fbbL5dddllmzJiRqqqqj3wNdn59/Xf9DTfckKVLl5Z/fu655/Lcc88lSWbOnCm82AkJL2AX1NzcXH7d3UqH9mPtaz6KQYMG5X//7/+9Xc7Frqsv79FN7r777tx9993b9ZzsOvryHj377LNz9tlnb5dzsevqy3t06tSpmTp16nY5F7uuvv67ftOjWdl12PMCAAAAKDThBeyCRo4cWX7d0tLS5bz2Y+1rYEdzj1J07lGKzj1K0blH2d6EF7AL2muvvcqv33zzzS7ntR9rXwM7mnuUonOPUnTuUYrOPcr2JryAXdABBxyQ3Xbb+K/3Cy+80OW8TWNjxozZrhshwpa4Ryk69yhF5x6l6NyjbG/CC9gFDRs2LBMnTkySPPDAA53OaWtry4MPPpgkOfroo3utN0jcoxSfe5Sic49SdO5RtjfhBeyizjzzzCTJI488kqeffnqz8XvvvTevvfZakuSMM87o1d4gcY9SfO5Ris49StG5R9mehBdQcO+++27eeeed8p/W1tYkGzc3an+8VCp1qDvzzDNz8MEHp62tLSeffHIWLlyYJGltbc29996bc889N0ly7LHH5ogjjujdX4pdinuUonOPUnTuUYrOPUoRVLS1tbX1dRNA18aNG5elS5ducd6ZZ56Z22+/vcOx+vr6HH744eXnXA8bNiytra1Zu3ZtkuSQQw7JwoULU11dvb3bph9xj1J07lGKzj1K0blHKQIrL2AXNm7cuDz//PO54oorctBBB6WioiIDBw7MoYcemhtuuCFPPfWUvyjoU+5Ris49StG5Ryk69yjbi5UXAAAAQKFZeQEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhSa8AAAAAApNeAEAAAAUmvACAAAAKDThBQAAAFBowgsAAACg0IQXAAAAQKEJLwAAAIBCE14AAAAAhfb/ARPEunir7LGXAAAAAElFTkSuQmCC\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "min(dfJQ1), max(dfJQ1)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "B1qTQ37x3qA4",
+        "outputId": "cf349022-6f59-47ca-cfae-b6672a59722f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(1.69192200324465e-28, 0.0027242016116445)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 21
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calculate the average of the entire DataFrame\n",
+        "average = np.mean(dfJQ1)\n",
+        "\n",
+        "# Print the average\n",
+        "print(\"Average of the data:\", average)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "VFI4x5hP5H7l",
+        "outputId": "3d8db24c-f7b0-490f-9de3-680f0ff724fa"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Average of the data: 6.302073865634676e-06\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Efficiency = average/max(dfJQ1)\n",
+        "\n",
+        "# Print the efficiency\n",
+        "print(\"Effiency of weight distribution is {:.2%}\".format(Efficiency))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "_3lprl6F5fJf",
+        "outputId": "66ed1da1-2d53-48cb-cdbc-72adc328f0b4"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Effiency of weight distribution is 0.23%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 76
+        },
+        "id": "8TWY1RJe66FM",
+        "outputId": "f14a6f2f-ef83-42e4-84a1-40ec8e367dc3"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-6078eef7-b7c4-4613-b72e-ea4d2bd8c6a4\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-6078eef7-b7c4-4613-b72e-ea4d2bd8c6a4\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving 1000weight_STAR.csv to 1000weight_STAR.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "# Read the CSV file into a pandas DataFrame\n",
+        "dfJP = pd.read_csv('1000weight_STAR.csv', delimiter = ' ')\n",
+        "dfJP"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 424
+        },
+        "id": "bYE74Qlr7F-3",
+        "outputId": "7e82c25a-28ba-4819-d709-85b80f98e39f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "          _weight\n",
+              "0    7.642962e-07\n",
+              "1    1.399554e-05\n",
+              "2    9.906489e-08\n",
+              "3    2.440670e-06\n",
+              "4    6.377706e-07\n",
+              "..            ...\n",
+              "995  5.157958e-07\n",
+              "996  1.465904e-07\n",
+              "997  6.468880e-07\n",
+              "998  7.492059e-07\n",
+              "999  4.099606e-07\n",
+              "\n",
+              "[1000 rows x 1 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-993849c2-e407-47d1-bbf4-7ed4e214710b\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>_weight</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>7.642962e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>1.399554e-05</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>9.906489e-08</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>2.440670e-06</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>6.377706e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>995</th>\n",
+              "      <td>5.157958e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>996</th>\n",
+              "      <td>1.465904e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>997</th>\n",
+              "      <td>6.468880e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>998</th>\n",
+              "      <td>7.492059e-07</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>999</th>\n",
+              "      <td>4.099606e-07</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>1000 rows × 1 columns</p>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-993849c2-e407-47d1-bbf4-7ed4e214710b')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-993849c2-e407-47d1-bbf4-7ed4e214710b button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-993849c2-e407-47d1-bbf4-7ed4e214710b');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-802ed291-bb34-4f73-80d5-8bc8540e02c1\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-802ed291-bb34-4f73-80d5-8bc8540e02c1')\"\n",
+              "            title=\"Suggest charts.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-802ed291-bb34-4f73-80d5-8bc8540e02c1 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 26
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "dfJP1 = dfJP[\"_weight\"]*1"
+      ],
+      "metadata": {
+        "id": "jNyb5gwX7YC4"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.rc('font',size=18)\n",
+        "plt.rcParams['figure.figsize'] = [12, 8]\n",
+        "ax1 = plt.subplot()\n",
+        "plt.hist(dfJP1, bins=np.logspace(start=np.log10(10**(-10)), stop=np.log10(1), num=35))\n",
+        "plt.gca().set_xscale(\"log\")\n",
+        "ax1.minorticks_on()\n",
+        "ax1.tick_params('both', length=15, width=2, which='major')\n",
+        "ax1.tick_params('both', length=7, width=1, which='minor')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 482
+        },
+        "id": "HXQVmxaw7gfP",
+        "outputId": "42bd5c7d-5bb5-44f7-b3a6-ae77f551fd9f"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x800 with 1 Axes>"
+            ],
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/8AAAKyCAYAAACDs25QAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABLy0lEQVR4nO3de5hddX0v/vfkQpJJmBAUzSZiEg83Mel5ALU/wDDSYJCLo4ZSUKjhPrUtXgIoRQsZDyhCSHu8jwVBlEpFK1CQi6Si1QIC0oMglWpIwLBDCQnZ2Qy3ZOb3BydzEpNM9gyTvWcWr9fz7IedtT7f7/qssEh4z1r7u5t6enp6AgAAABTWiEY3AAAAAGxfwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwoxrdQFF0d3fniSeeyI477pimpqZGtwMAAEDB9fT0ZO3atdl1110zYkTf9/YHFP6ffvrp3HDDDVm8eHF++ctfZtmyZVm3bl122WWXvPWtb828efPy/ve/v8851q5dm0svvTTf//738+ijj2bkyJHZc889c9xxx+WMM87IDjvs0Of4J598MhdffHFuvPHGPPbYYxk3blze8pa3ZN68eTnllFPqHsCfeOKJ7LbbbnU9JgAAADz++ON5wxve0GdNU09PT09/Jx49enTWrVvX++uxY8dm5MiRefbZZ3u3HX744fne976X5ubmzcYvW7Ys73znO7N06dIkSXNzc9avX58XXnghSbLvvvtm8eLFmTRp0haPf9999+Wwww7L008/nSSZMGFCnn/++d6eDjvssNxwww3b/AHCYFqzZk122mmnPP7442lpaanbcQEAAHh1qlQq2W233fLMM89k4sSJfdYOKPw3NTXl7W9/e0488cQcdthhedOb3pQkWbp0aS644IJcfvnlSZITTjgh3/rWtzYZu27duuy333751a9+lVKplKuuuiqHHnpouru7c+211+a0007L2rVrc8QRR+Smm27a7Nhr1qzJ3nvvnRUrVmTvvffOt771rbz1rW/Niy++mH/4h3/Ixz/+8bz00kv58Ic/nK985Sv9PbUBq1QqmThxYtasWSP8AwAAsN31J4cOKPz/+Mc/ziGHHLLV/X/xF3+Rzs7OJMljjz22yePwl19+eU499dQkyb//+7/ngAMO2GTsd77znXzwgx9Mktx+++2ZPXv2Jvv/9m//NhdccEHGjRuXhx56KNOnT99k/+c+97mce+65GTlyZH79619nzz337O/pDYjwDwAAQD31J4cOaLX/voJ/kpxyyim97++9995N9n3zm9/sneMPg3+SHHfccb2B/qqrrtps/4ZtG9dt7IwzzsiECROyfv36XH311ds4EwAAACi+7fJVf2PHju19v379+t73XV1d+fnPf57k5TUBtqSpqSnvfve7kyS33XbbJvt+85vf5LHHHutz/IQJEzJr1qwtjgcAAIBXo+0S/u+4447e9zNnzux9//DDD6e7uztJMmPGjK2O37BvxYoVWbVqVe/2Bx98cLOavsb/+te/7l/jAAAAUEAD+qq/vjzzzDP53Oc+lySZNWtW9tprr959TzzxRO/7KVOmbHWOjfc98cQT2XnnnQc0vlKppFqtZsKECZvVLFq0KIsWLdrW6dRsww81AAAAYKgZ1PDf3d2dP//zP0+5XM7YsWPzpS99aZP9a9eu7X2/pa8A3NK+jccMdPyWwn+lUsny5cu3OgcAAAAUxaCG/49+9KO58cYbkyRf/vKX80d/9EeDOf2gamlp6fPpgf7q7u5OuVwetPkAAABgsAxa+D/rrLN67/T/3d/9XU4++eTNanbcccfe911dXVuda+N9G4/5w/Fb+yqDrY3f2Pz58zN//vyt9tBfG75iAQAAAIaaQVnw7xOf+EQuvfTSJMnChQvzsY99bIt1u+66a+/7vh6533jfxmP6O76lpWWLj/wDAADAq8krDv9nn312LrnkkiTJxRdfnDPPPHOrtW9+85szYsTLh9x45f4/tGHf5MmTexf7SzZd4b+W8fvss08NZwAAAADF9orC/1lnnZWFCxcmeTn4n3322X3WNzc356CDDkqS3HLLLVus6enpya233pokmTNnzib79txzz7zxjW/sc/yzzz6bf/u3f9vieAAAAHg1GnD4P+usszZ51H9bwX+DefPmJUl+/OMf5+67795s/7XXXpslS5YkST70oQ9tsq+pqal32zXXXJOlS5duNv7LX/5yqtVqRo4cmeOPP77m8wEAAICiGlD43/gz/osWLerzUf8/NG/evMycOTM9PT05+uijs3jx4iQvr5Z/7bXX5rTTTkuSHH744Zk9e/Zm488666xMnjw5XV1dOfLII3PfffclSV588cV89atfzd/+7d8mSU4//fTsueeeAzk9AAAAKJSmnp6env4MeOyxxzJ16tQkyYgRI7LLLrv0WX/WWWflrLPO2mTb0qVLc8ghh/TeuW9ubk53d3eef/75JMm+++6bxYsXZ9KkSVuc87777sthhx2Wp59+OsnLK/o///zzeemll5K8/Lj/DTfckDFjxvTn1F6RDav9r1mzZqvfQgAAAACDpT85tN9f9dfd3b3J+yeffLLP+mq1utm2adOm5YEHHsjChQvzz//8z3n00UczevTovOUtb8kHPvCBnHHGGdlhhx22Ouf++++fhx56KJ///Odz44035vHHH8/48eMzY8aMzJs3LyeffHLvwoIAAADwatfvO/9smTv/AAAA1FN/cqjb4wAAAFBwwj8AAAAUnPAPAAAABdfvBf9ejcrlcsrlcp81W1rYEAAAAIYC4b8GnZ2d6ejoaHQbAAAAMCBW+69BrXf+W1tbrfYPAABAXfRntX93/mtQKpVSKpX6rKlUKnXqBgAAAPrHgn8AAABQcMI/AAAAFJzwDwAAAAXnM/8AvGpNO+em7X6MpRcdud2PAQCwLe78AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABTeq0Q0MB+VyOeVyuc+aarVap24AAACgf4T/GnR2dqajo6PRbQAAAMCACP81aG9vT1tbW5811Wo1ra2tdeoIAAAAaif816BUKqVUKvVZU6lU6tQNAAAA9I8F/wAAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACm5UoxsYDsrlcsrlcp811Wq1Tt0AAABA/wj/Nejs7ExHR0ej2wAAAIABEf5r0N7enra2tj5rqtVqWltb69QRAAAA1E74r0GpVEqpVOqzplKp1KkbAAAA6B8L/gEAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFNyoRjcwHJTL5ZTL5T5rqtVqnboBAACA/hH+a9DZ2ZmOjo5GtwEAAAADIvzXoL29PW1tbX3WVKvVtLa21qkjAAAAqJ3wX4NSqZRSqdRnTaVSqVM3AAAA0D8W/AMAAICCE/4BAACg4IR/AAAAKDjhHwAAAApuQOG/q6srN998cy644ILMnTs3U6dOTVNTU5qamrJgwYKtjlu6dGlvXS2vk046abM5TjzxxJrGrlu3biCnBgAAAIUzoNX+f/GLX+SII47o97iRI0fm9a9/fZ81zz//fNasWZMkedvb3rbVurFjx2bixIlb3d/U1NTv/gAAAKCIBvxVf5MmTcp+++3X+/r4xz+eFStW9Dlmt91222bNGWeckS996UsZN25cPvjBD2617thjj82VV145kNYBAADgVWVA4X/WrFlZtWrVJtvOOeecV9zM888/n6uvvjpJcvTRR2ennXZ6xXMCAADAq92APvM/cuTIwe4jSfLP//zPWb16dZLk1FNP3S7HAAAAgFebIbXa/+WXX54k2WOPPdLa2trgbgAAAKAYhkz4X7JkSX784x8nSU455ZRt1i9evDh77rlnxo4dm5aWlsycOTMf+9jH8l//9V/bu1UAAAAYVga84N9g+8Y3vpGenp6MGjUq8+bN22b973//+4wcOTItLS2pVCp58MEH8+CDD+arX/1q/v7v/z4f/vCH+xy/aNGiLFq0aLDaT3d396DNBQAAAINpSIT/9evX967cf+SRR2by5Mlbrd1vv/3ytre9LUcddVTe8IY3ZOTIkenq6sott9yST3ziE/nd736Xv/zLv8zrXve6HH300Vudp1KpZPny5YN9KgAAADDkDInwf8stt/QG8W0t9PeRj3xks23Nzc2ZO3duWltb87a3vS2PPvpozjzzzMydOzdNTU1bnKelpSVTpkx55c3/X93d3SmXy4M2HwAAAAyWIRH+L7vssiTJlClTcvjhhw94nte85jU599xzc9ppp2XZsmW5//77s99++22xdv78+Zk/f/6Aj/WHKpVKJk6cOGjzAQAAwGBpePh/8sknc+ONNyZJTjzxxFf8NYIHHHBA7/slS5ZsNfwDMLRNO+emRrcAAFAYDV/t/6qrrsq6devS1NSUk08+udHtAAAAQOE0PPxffvnlSZJDDjkkb3rTm17xfHfddVfv++nTp7/i+QAAAGC4a2j4/9nPfpbf/OY3Sba90F+S9PT09Ll/1apV+exnP5sk2W233bLvvvu+8iYBAABgmBtw+F+9enVWrlzZ+9rwPfddXV2bbK9Wq1udY8NCfzvvvHPmzp27zWN++9vfzty5c/P9738///3f/927/bnnnst1112XAw44IEuWLEmSXHLJJRkxouEPNgAAAEDDDXjBv3333TfLli3bbPsll1ySSy65pPfX8+bNy5VXXrlZXaVSybXXXpskOeGEEzJmzJhtHnP9+vX5wQ9+kB/84AdJkvHjx2fs2LF55plnsn79+iTJmDFjsmjRohx77LEDOS0AAAAonIat9n/NNdekq6srSW2P/Ccvrwtw4YUX5s4778zDDz+cp59+OmvWrElLS0t23333/Mmf/Ena29t91h8AAAA20tSzrQ/SU5NKpZKJEyf2/jACgFemKF/1t/SiIxvdAgBQUP3JoT4UDwAAAAUn/AMAAEDBCf8AAABQcA1b8G84KZfLKZfLfdb09ZWGAAAA0EjCfw06OzvT0dHR6DYAAABgQIT/GrS3t6etra3Pmmq1mtbW1jp1BAAAALUT/mtQKpVSKpX6rKlUKnXqBgAAAPrHgn8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBjWp0A8NBuVxOuVzus6ZardapGwAAAOgf4b8GnZ2d6ejoaHQbAAAAMCDCfw3a29vT1tbWZ021Wk1ra2udOgIAAIDaCf81KJVKKZVKfdZUKpU6dQMAAAD9Y8E/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCG9XoBoaDcrmccrncZ021Wq1TNwAAANA/wn8NOjs709HR0eg2AAAAYECE/xq0t7enra2tz5pqtZrW1tY6dQQAAAC1E/5rUCqVUiqV+qypVCp16gYAAAD6x4J/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFN6rRDQwH5XI55XK5z5pqtVqnbgAAAKB/hP8adHZ2pqOjo9FtAAAAwIAI/zVob29PW1tbnzXVajWtra116ggAAABqJ/zXoFQqpVQq9VlTqVTq1A0AAAD0jwX/AAAAoOCEfwAAACg44R8AAAAKTvgHAACAghtQ+O/q6srNN9+cCy64IHPnzs3UqVPT1NSUpqamLFiwoM+xCxYs6K3t6/Xb3/62z3l++ctf5oQTTsgb3vCGjBkzJqVSKe9///vzr//6rwM5JQAAACisAa32/4tf/CJHHHHEKzrw6NGjs/POO291/6hRW2/tsssuy4c//OGsW7cuSTJx4sQ8+eSTue6663Ldddfl/PPP3+YPIQAAAODVYsCP/U+aNCmzZ8/O2Wefne985zuZPHlyv8YfeOCBWbFixVZf06ZN2+K4O++8M3/xF3+RdevW5X3ve18ef/zxPPPMM3nqqafS3t6eJOno6Mh3v/vdgZ4aAAAAFMqA7vzPmjUrq1at2mTbOeecMygNbcsnPvGJrF+/PjNnzsx3v/vdjB49Oknymte8Jl/72teydOnS3HrrrfnkJz+Zo48+OiNHjqxLXwAAADBUDejOf6MC9ZIlS/Kzn/0sSXLWWWf1Bv+N/c3f/E2SZOnSpfnpT39a1/4AAABgKBpWq/3/6Ec/6n3/7ne/e4s173jHO7LjjjsmSW677ba69AUAAABDWcPC/0MPPZQZM2akubk5EyZMyF577ZXTTjst999//1bHPPjgg0mS173udXnd6163xZqRI0dm77337j0GAAAAvNoN6DP/g2HlypVZtWpVdtppp1QqlTzyyCN55JFHcvnll+fcc8/NBRdcsNmYJ554IkkyZcqUPueeMmVK7rnnnt76LVm0aFEWLVr0yk5iI93d3YM2FwAAAAymuof/PfbYIxdffHHe+973Zvr06Rk9enRefPHF3HHHHTn33HNz33335cILL8ykSZNy5plnbjJ27dq1SZLm5uY+j7Fh/4b6LalUKlm+fPkrPBsAAAAY+uoe/o8//vjNtu2www6ZM2dODj744Bx88MG55557smDBgpx66qmZOHHidumjpaVlm08Q9Ed3d3fK5fKgzQcAAACDpWGP/W/J2LFj89nPfjbvete7Uq1Ws3jx4sydO7d3/4aF/Lq6uvqcZ8P+DfVbMn/+/MyfP38Qun5ZpVLZbj+oAAAAgFdiyK32f8ABB/S+X7JkySb7dt111yTZ5uP6G/ZvqAcAAIBXsyEX/vsyY8aMJMl///d/56mnntpizfr16/Of//mfSZK3vOUtdesNAAAAhqohF/7vuuuu3vfTp0/fZN+73vWu3ve33HLLFsf//Oc/713ob86cOduhQwAAABhe6hr+e3p6+tz/wgsv5FOf+lSSZPz48Zk9e/Ym+9/0pjflHe94R5Lk0ksvzUsvvbTZHBdddFGSZOrUqTn44IMHo20AAAAY1gYc/levXp2VK1f2vjZ8z31XV9cm26vVau+Yn/70pzn00EPzrW99K7///e97t7/00ktZvHhxZs2albvvvjtJct5552WnnXba7Lif//znM3LkyPyf//N/ctxxx/V+vn/VqlX5y7/8y9x8881JkosvvjgjR44c6OkBAABAYTT1bOt2/FZMmzYty5Yt22bdvHnzcuWVVyZJ7rjjjhxyyCG9+8aNG5fx48dnzZo1vXfxR4wYkXPOOScXXnjhVue87LLL8uEPfzjr1q1Lkuy0005Zs2ZN75MF559/fhYsWDCQ0xqwDav9r1mzJi0tLXU9NkARTTvnpka3MCiWXnRko1sAAAqqPzm0rl/1N3PmzCxcuDB33nlnfvWrX2XlypV55pln0tzcnH322SezZs3K6aefnpkzZ/Y5z6mnnpr99tsvl156aX7yk5/kqaeeyute97occMABOeOMM/Inf/IndTojAAAAGPoGfOefTbnzDzC43PkHAOhbf3LokFvtHwAAABhcwj8AAAAUnPAPAAAABVfXBf+Gq3K5nHK53GfNxl9pCAAAAEOJ8F+Dzs7OdHR0NLoNAAAAGBDhvwbt7e1pa2vrs6Zaraa1tbVOHQEAAEDthP8alEqllEqlPmsqlUqdugEAAID+seAfAAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcKMa3cBwUC6XUy6X+6ypVqt16gYAAAD6R/ivQWdnZzo6OhrdBgAAAAyI8F+D9vb2tLW19VlTrVbT2tpap44AAACgdsJ/DUqlUkqlUp81lUqlTt0AAABA/1jwDwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4EY1uoHhoFwup1wu91lTrVbr1A0AAAD0j/Bfg87OznR0dDS6DQAAABgQ4b8G7e3taWtr67OmWq2mtbW1Th0BAABA7YT/GpRKpZRKpT5rKpVKnboBAACA/rHgHwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwY1qdAPDQblcTrlc7rOmWq3WqRsAAADoH+G/Bp2dneno6Gh0GwAAADAgwn8N2tvb09bW1mdNtVpNa2trnToCAACA2gn/NSiVSimVSn3WVCqVOnUDAAAA/WPBPwAAACg44R8AAAAKTvgHAACAghP+AQAAoOAGFP67urpy880354ILLsjcuXMzderUNDU1pampKQsWLOhz7PLly/OVr3wlxxxzTHbfffeMGzcu48aNy/Tp0/OBD3wg//qv/9rn+AULFvQeq6/Xb3/724GcGgAAABTOgFb7/8UvfpEjjjii3+Mef/zxTJ06NT09Pb3bmpub09PTk6VLl2bp0qW55pprcvLJJ+frX/96Ro4cudW5Ro8enZ133nmr+0eN8kUGAAAAkLyCx/4nTZqU2bNn5+yzz853vvOdTJ48eZtj1q9fn56ensyePTvf/OY3s3z58jz77LOpVqt56KGH8t73vjdJ8o1vfGObTxAceOCBWbFixVZf06ZNG+ipAQAAQKEM6Pb4rFmzsmrVqk22nXPOOdscN2nSpNx3333Zb7/9Ntk+YsSI7LPPPvnBD36QI444Irfcckv+/u//Pp/61KcyduzYgbQIAAAA/F8DuvPf1+P4fZk4ceJmwX9jTU1NOfnkk5Mk1Wo1Dz/88ICOAwAAAPw/Q261/43v9K9fv76BnQAAAEAxDLnwf8cddyRJdthhh+y5555brXvooYcyY8aMNDc3Z8KECdlrr71y2mmn5f77769TpwAAADA8DKkl8R999NF87WtfS5Ice+yxaWlp2WrtypUrs2rVquy0006pVCp55JFH8sgjj+Tyyy/PueeemwsuuKDPYy1atCiLFi0atN67u7sHbS4AAAAYTEMm/D/33HM55phj0tXVlde+9rW56KKLtli3xx575OKLL8573/veTJ8+PaNHj86LL76YO+64I+eee27uu+++XHjhhZk0aVLOPPPMrR6vUqlk+fLl2+t0AApt2jk3NboFAAD6YUiE/3Xr1uWDH/xg7rvvvowePTpXX311dt111y3WHn/88Ztt22GHHTJnzpwcfPDBOfjgg3PPPfdkwYIFOfXUUzNx4sQtztPS0pIpU6YM2jl0d3enXC4P2nwAAAAwWBoe/tevX5/jjz8+1113XUaNGpV//Md/zJw5cwY019ixY/PZz34273rXu1KtVrN48eLMnTt3i7Xz58/P/PnzX0nrm6hUKlv9QQMAAAA0UkMX/Fu/fn1OOOGEfPe7383IkSPz7W9/O3/6p3/6iuY84IADet8vWbLklbYIAAAAw17D7vxvuOP/T//0T73B/9hjj21UOwAAAFBYDQn/69evzwc/+MFN7vgfd9xxgzL3XXfd1ft++vTpgzInAAAADGd1f+x/wx3/7373uxk1alSuvvrqmoN/T09Pn/tfeOGFfOpTn0qSjB8/PrNnz37F/QIAAMBwN+Dwv3r16qxcubL3teF77ru6ujbZXq1We8ds+Iz/P/3TP/Uu7tefR/1/+tOf5tBDD823vvWt/P73v+/d/tJLL2Xx4sWZNWtW7r777iTJeeedl5122mmgpwcAAACF0dSzrdvpWzFt2rQsW7Zsm3Xz5s3LlVdemeTl8N7a2pokGT16dHbeeec+x/7v//2/N/nhwB133JFDDjmk99fjxo3L+PHjs2bNmrz00ktJkhEjRuScc87JhRde2N9TekU2rPa/Zs2atLS01PXYAPU27ZybGt3CsLH0oiMb3QIAUFD9yaF1/cz/hqcDkpfv1j/55JN91j/33HOb/HrmzJlZuHBh7rzzzvzqV7/KypUr88wzz6S5uTn77LNPZs2aldNPPz0zZ87cLv0DAADAcDTg8L906dJ+j3nnO9+5zc/t9+U1r3lNzjzzzAGPBwAAgFejui/4BwAAANSX8A8AAAAFJ/wDAABAwdV1wb/hqlwup1wu91mz8VcaAgAAwFAi/Negs7MzHR0djW4DAAAABkT4r0F7e3va2tr6rKlWq2ltba1TRwAAAFA74b8GpVIppVKpz5pKpVKnbgAAAKB/LPgHAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAU3KhGNzAclMvllMvlPmuq1WqdugEAAID+Ef5r0NnZmY6Ojka3AQAAAAMi/Negvb09bW1tfdZUq9W0trbWqSMAAAConfBfg1KplFKp1GdNpVKpUzcAAADQP8I/AGxH0865absfY+lFR273YwAAw5vV/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAouFGNbmA4KJfLKZfLfdZUq9U6dQMAAAD9I/zXoLOzMx0dHY1uAwAAAAZE+K9Be3t72tra+qypVqtpbW2tU0cAAABQO+G/BqVSKaVSqc+aSqVSp24AAACgfyz4BwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcKMa3cBwUC6XUy6X+6ypVqt16gYAAAD6R/ivQWdnZzo6OhrdBgAAAAyI8F+D9vb2tLW19VlTrVbT2tpap44AAACgdsJ/DUqlUkqlUp81lUqlTt0AAABA/1jwDwAAAApO+AcAAICCE/4BAACg4IR/AAAAKLgBhf+urq7cfPPNueCCCzJ37txMnTo1TU1NaWpqyoIFC2qa48knn8yZZ56ZvfbaK+PGjcvOO++cWbNm5bLLLktPT882x//ud79Le3t7pk+fnrFjx2aXXXbJYYcdlu9///sDOSUAAAAorAGt9v+LX/wiRxxxxIAPet999+Wwww7L008/nSSZMGFC1q5dm5/97Gf52c9+lu9973u54YYbssMOO2xx/A9/+MMcc8wx6erqSpK0tLRk1apVue2223LbbbflpJNOyuWXX56mpqYB9wgAAABFMeDH/idNmpTZs2fn7LPPzne+851Mnjy5pnFr1qzJUUcdlaeffjp777137rnnnqxduzbPPvtsvvSlL2X06NG59dZb87GPfWyL4x999NH82Z/9Wbq6unLQQQflN7/5TdasWZM1a9bkvPPOS5JcccUVueSSSwZ6agAAAFAoAwr/s2bNyqpVq3L77bfn4osvznHHHZcxY8bUNHbhwoVZsWJFxo0blx/+8Id561vfmiTZYYcd8ld/9Vfp6OhIknz961/PI488stn48847L88++2wmT56cG2+8MXvuuWeSl58e6OjoyOmnn54kufDCC7N69eqBnB4AAAAUyoDC/8iRIwd8wKuuuipJctxxx2X69Omb7T/jjDMyYcKErF+/PldfffUm+5599tnez/R/+MMfzk477bTZ+L/5m79JklQqlVx33XUD7hMAAACKoq6r/f/mN7/JY489liQ5/PDDt1gzYcKEzJo1K0ly2223bbLvZz/7WZ577rk+x0+bNi1vfvObtzgeAAAAXo3qGv4ffPDB3vczZszYat2Gfb/+9a9f0fiHHnpoQH0CAABAkQxotf+BeuKJJ3rfT5kyZat1G/ZVKpVUq9VMmDBhk/GTJk3KuHHjtjl+4+P9oUWLFmXRokW1N78N3d3dgzYXAAAADKa6hv+1a9f2vm9ubt5q3cb71q5d2xv+N4zva+zG+zc+3h+qVCpZvnz5tpsGAACAYa6u4X8oaWlp6fPpg/7q7u5OuVwetPkAAABgsNQ1/O+4446977u6utLS0rLFuq6uri2O2fB+4/19jd947B+aP39+5s+fv+2ma1SpVDJx4sRBmw8AAAAGS10X/Nt111173/f1yP2GfS0tLb2P/G88fvXq1b2r/vc1fuPjAQAAwKtVXcP/xiv0b7xy/x/asG+fffZ5RePf8pa3DKhPAAAAKJK6hv8999wzb3zjG5Mkt9xyyxZrnn322fzbv/1bkmTOnDmb7HvHO97Ru8r/1sYvW7YsDz/88BbHAwAAwKtRXcN/U1NTPvShDyVJrrnmmixdunSzmi9/+cupVqsZOXJkjj/++E32jR8/PkcffXSS5Ktf/WrWrFmz2fjPf/7zSV7+vP/73ve+wT0BAAAAGIYGHP5Xr16dlStX9r42fM99V1fXJtur1eom484666xMnjw5XV1dOfLII3PfffclSV588cV89atfzd/+7d8mSU4//fTsueeemx33M5/5TMaPH59yuZz3vOc9+a//+q8kLz8x8JnPfCZf+9rXkiSf/vSnM2nSpIGeHgAAABRGU09PT89ABk6bNi3Lli3bZt28efNy5ZVXbrLtvvvuy2GHHZann346yct36Z9//vm89NJLSV5+XP+GG27ImDFjtjjnD3/4wxxzzDG9q/pPnDgx1Wo169evT5KcdNJJufzyy9PU1DSQUxuQDav9r1mzZqvfYgBQFNPOuanRLbCRpRcd2egWAIAG6E8Oretj/xvsv//+eeihh/Lxj388e+yxR1566aWMHz8+73jHO/IP//APufnmm7ca/JPkiCOOyAMPPJDTTjst06ZNy/PPP59JkyblXe96V773ve/lG9/4Rl2DPwAAAAxlA77zz6bc+QdeTdz5H1rc+QeAV6chf+cfAAAAqJ9RjW4AAHhl6vEkhqcLAGB4c+cfAAAACs6d/xqUy+WUy+U+a/7wKw0BAABgqBD+a9DZ2ZmOjo5GtwEAAAADIvzXoL29PW1tbX3WVKvVtLa21qkjAAAAqJ3wX4NSqZRSqdRnTaVSqVM3AAAA0D8W/AMAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApuVKMbGA7K5XLK5XKfNdVqtU7dAAAAQP8I/zXo7OxMR0dHo9sAAACAARH+a9De3p62trY+a6rValpbW+vUEQAAANRO+K9BqVRKqVTqs6ZSqdSpGwAAAOgfC/4BAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABTcqEY3MByUy+WUy+U+a6rVap26AQAAgP4R/mvQ2dmZjo6ORrcBAAAAAyL816C9vT1tbW191lSr1bS2ttapIwAAAKid8F+DUqmUUqnUZ02lUqlTNwAAANA/FvwDAACAghP+AQAAoOCEfwAAACg44R8AAAAKTvgHAACAghP+AQAAoOCEfwAAACg44R8AAAAKTvgHAACAghP+AQAAoOCEfwAAACi4UY1uYDgol8spl8t91lSr1Tp1AwAAAP0j/Negs7MzHR0djW4DAAAABkT4r0F7e3va2tr6rKlWq2ltba1TRwAAAFA74b8GpVIppVKpz5pKpVKnbgAAAKB/LPgHAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUXN3Df1NTU82vQw45ZLPxCxYsqGnsb3/723qfGgAAAAxJdV/t//Wvf32f+1966aWsWrUqSfK2t71tq3WjR4/OzjvvvNX9o0b5IgMAAABIGhD+V6xY0ef+Sy+9NGeddVaS5JRTTtlq3YEHHpg77rhjMFsDAACAQhpyn/m//PLLkyTveMc7stdeezW4GwAAABj+hlT4//d///c8/PDDSZJTTz21wd0AAABAMQyp8L/hrv/EiRNzzDHHNLgbAAAAKIYhE/6r1Wq++93vJkk+8IEPpLm5uc/6hx56KDNmzEhzc3MmTJiQvfbaK6eddlruv//+erQLAAAAw8aQWRL/mmuuSbVaTVLbI/8rV67MqlWrstNOO6VSqeSRRx7JI488kssvvzznnntuLrjggj7HL1q0KIsWLRqU3pOku7t70OYCAACAwTRkwv9ll12WJPmf//N/Zv/9999q3R577JGLL744733vezN9+vSMHj06L774Yu64446ce+65ue+++3LhhRdm0qRJOfPMM7c6T6VSyfLlywf9PAAAAGCoGRLh/6GHHsrdd9+dZNt3/Y8//vjNtu2www6ZM2dODj744Bx88MG55557smDBgpx66qmZOHHiFudpaWnJlClTXnnz/1d3d3fK5fKgzQcAAACDZUiE/w13/ceOHZsTTjhhwPOMHTs2n/3sZ/Oud70r1Wo1ixcvzty5c7dYO3/+/MyfP3/Ax/pDlUplqz9oAAAAgEZq+IJ/L774Yr797W8nSY4++ujstNNOr2i+Aw44oPf9kiVLXtFcAAAAUAQND//XX399Vq5cmaS2hf4AAACA/ml4+N/wyP/uu++e1tbWVzzfXXfd1ft++vTpr3g+AAAAGO4aGv4fe+yx3H777UmSk08+OU1NTX3W9/T09Ln/hRdeyKc+9akkyfjx4zN79uzBaRQAAACGsYaG/2984xvp7u7OqFGjcuKJJ26z/qc//WkOPfTQfOtb38rvf//73u0vvfRSFi9enFmzZvV+a8B55533itcPAAAAgCJo2Gr/3d3dueKKK5IkRxxxREql0jbH9PT0ZPHixVm8eHGSZNy4cRk/fnzWrFmTl156KUkyYsSInHPOOfnEJz6x/ZoHAACAYaRh4f/222/PY489lqT2hf5mzpyZhQsX5s4778yvfvWrrFy5Ms8880yam5uzzz77ZNasWTn99NMzc+bM7dk6ALzqTDvnpu06/9KLjtyu8wPAq13Dwv+cOXO2+Rn+P/Sa17wmZ5555nbqCAAAAIqp4av9AwAAANuX8A8AAAAFJ/wDAABAwTXsM//DSblcTrlc7rOmWq3WqRsAAADoH+G/Bp2dneno6Gh0GwAAADAgwn8N2tvb09bW1mdNtVpNa2trnToCAACA2gn/NSiVSimVSn3WVCqVOnUDAAAA/WPBPwAAACg44R8AAAAKTvgHAACAghP+AQAAoOCEfwAAACg44R8AAAAKTvgHAACAghP+AQAAoOCEfwAAACg44R8AAAAKTvgHAACAghP+AQAAoOBGNbqB4aBcLqdcLvdZU61W69QNAAAA9I/wX4POzs50dHQ0ug0AAAAYEOG/Bu3t7Wlra+uzplqtprW1tU4dAQAAQO2E/xqUSqWUSqU+ayqVSp26AQAAgP6x4B8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMGNanQDw0G5XE65XO6zplqt1qkbAAAA6B/hvwadnZ3p6OhodBsAAAAwIMJ/Ddrb29PW1tZnTbVaTWtra506AgAAgNoJ/zUolUoplUp91lQqlTp1AwAAAP1jwT8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIb1egGhoNyuZxyudxnTbVarVM3AAAA0D/Cfw06OzvT0dHR6DYAAABgQIT/GrS3t6etra3Pmmq1mtbW1jp1BAAAALUT/mtQKpVSKpX6rKlUKnXqBgAAAPrHgn8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBNST8X3nllWlqatrm6/bbb9/qHL/73e/S3t6e6dOnZ+zYsdlll11y2GGH5fvf/34dzwQAAACGvoau9j9ixIjssssuW90/ZsyYLW7/4Q9/mGOOOSZdXV1JkpaWlqxatSq33XZbbrvttpx00km5/PLL09TUtF36BgAAgOGkoY/977bbblmxYsVWX7NmzdpszKOPPpo/+7M/S1dXVw466KD85je/yZo1a7JmzZqcd955SZIrrrgil1xySb1PBwAAAIakYfeZ//POOy/PPvtsJk+enBtvvDF77rlnkmTChAnp6OjI6aefniS58MILs3r16ka2CgAAAEPCsAr/zz77bO9n+j/84Q9np5122qzmb/7mb5IklUol1113XR27AwAAgKFpWIX/n/3sZ3nuueeSJIcffvgWa6ZNm5Y3v/nNSZLbbrutbr0BAADAUNXQ8P/UU09l//33z4QJEzJu3Li86U1vygknnJA77rhji/UPPvhg7/sZM2Zsdd4N+x566KFB7RcAAACGo4au9t/V1ZVf/vKXmTRpUp599tk8+uijefTRR3P11VfnpJNOyte//vWMGvX/WnziiSeSJJMmTcq4ceO2Ou+UKVM2qd+SRYsWZdGiRYN0Jkl3d/egzQUAAACDqSHhf9ddd83555+fuXPnZq+99sqYMWOyfv363H333Tn//PNz++2354orrsj48ePzxS9+sXfc2rVrkyTNzc19zr9h/4b6LalUKlm+fPkgnA0AAAAMbQ0J/3PmzMmcOXM22TZy5MgceOCBufXWWzN37txcf/31+cpXvpKPfOQj2WOPPQa9h5aWlt4nBAZDd3d3yuXyoM0HAAAAg6Whj/1vyYgRI7Jw4cJcf/316e7uzr/8y79k/vz5SZIdd9wxycsfF+jLhv0b6rdk/vz5vfMOhkqlkokTJw7afAAAADBYhlz4T5Ldd989r33ta7Ny5cosWbKkd/uuu+6aJFm9enWee+65rX7uf8Pj/BvqAV5Npp1zU6NbAABgiBlWX/W38Qr/G6/8/4c27HvLW96y3XsCAACAoW5Ihv/f/e53WblyZZJk+vTpvdvf8Y539N7tv+WWW7Y4dtmyZXn44YeTZLN1BQAAAODVqO7hv6enZ5v7zz777CQvf/7/qKOO6t03fvz4HH300UmSr371q1mzZs1m4z//+c8nefnz/u973/sGqWsAAAAYvuoe/pctW5a3v/3t6ezszJIlS3p/GNDd3Z277rorhx9+eH7wgx8kSdrb27PXXnttMv4zn/lMxo8fn3K5nPe85z35r//6ryTJs88+m8985jP52te+liT59Kc/nUmTJtXxzAAAAGBoasiCf/fcc0/uueeeJMmYMWOy4447Zu3atXnhhRd6a0466aR84Qtf2Gzs9OnT893vfjfHHHNM/u3f/i177rlnJk6cmGq1mvXr1/eO3fD0AAAAALza1T38v/71r88Xv/jF3HnnnfmP//iPPPXUU1m9enXGjh2b6dOn58ADD8zJJ5+cgw46aKtzHHHEEXnggQfy+c9/Pj/60Y9SLpczadKk7Lvvvmlvb+/9aAAAAACQNPVs60P41KRSqWTixIlZs2ZNWlpaGt0O8Crmq/4YjpZedGSjWwCAYac/OXRIrvYPAAAADB7hHwAAAApO+AcAAICCa8hq/8NNuVxOuVzus6ZardapGwAAAOgf4b8GnZ2d6ejoaHQbAAAAMCDCfw3a29vT1tbWZ021Wk1ra2udOgIAAIDaCf81KJVKKZVKfdZUKpU6dQMAAAD9Y8E/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKLhRjW4AAKAepp1z03Y/xtKLjtzuxwCAgXDnHwAAAApO+AcAAICC89h/Dcrlcsrlcp811Wq1Tt0AAABA/wj/Nejs7ExHR0ej2wAAAIABEf5r0N7enra2tj5rqtVqWltb69QRAAAA1E74r0GpVEqpVOqzplKp1KkbAAAA6B8L/gEAAEDBCf8AAABQcMI/AAAAFJzP/AMADTftnJsa3QIAFJo7/wAAAFBwwj8AAAAUnPAPAAAABSf8AwAAQMEJ/wAAAFBwwj8AAAAUnPAPAAAABTeq0Q0MB+VyOeVyuc+aarVap24AAACgf4T/GnR2dqajo6PRbQAAAMCACP81aG9vT1tbW5811Wo1ra2tdeoIAAAAaif816BUKqVUKvVZU6lU6tQNAAAA9I8F/wAAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACk74BwAAgIIT/gEAAKDghH8AAAAoOOEfAAAACm5UoxsYDsrlcsrlcp811Wq1Tt0AAABA/wj/Nejs7ExHR0ej2wAAAIABEf5r0N7enra2tj5rqtVqWltb69QRAAAA1E74r0GpVEqpVOqzplKp1KkbAAAA6B8L/gEAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAXXkPD/9NNP54orrsgJJ5yQffbZJ+PHj8+YMWPyhje8Ie973/vygx/8YKtjr7zyyjQ1NW3zdfvtt9fxjAAAAGDoashq/5MnT866det6fz127NiMHj06y5cvz/Lly3P99dfn8MMPz/e+9700NzdvcY4RI0Zkl1122eoxxowZM+h9AwAAwHDUkDv/69aty9vf/vZ85Stfye9+97s899xzqVarefTRR3PKKackSW6++ea0t7dvdY7ddtstK1as2Opr1qxZ9TodAAAAGNIacuf/X//1X3PIIYdstn3atGm57LLLMmrUqHR2dubb3/52PvvZz2a33XZrQJcAAABQDA2587+l4L+xDXf/k+Tee+/d3u0AAABAoQ3J1f7Hjh3b+379+vUN7AQAAACGvyEZ/u+4447e9zNnztxizVNPPZX9998/EyZMyLhx4/KmN70pJ5xwwiZjAQAAgAZ95r8vzzzzTD73uc8lSWbNmpW99tpri3VdXV355S9/mUmTJuXZZ5/No48+mkcffTRXX311TjrppHz961/PqFFbP71FixZl0aJFg9Z3d3f3oM0FAAAAg2lIhf/u7u78+Z//ecrlcsaOHZsvfelLm9XsuuuuOf/88zN37tzstddeGTNmTNavX5+77747559/fm6//fZcccUVGT9+fL74xS9u9ViVSiXLly/fnqcDAAAAQ8KQCv8f/ehHc+ONNyZJvvzlL+eP/uiPNquZM2dO5syZs8m2kSNH5sADD8ytt96auXPn5vrrr89XvvKVfOQjH8kee+yxxWO1tLRkypQpg9Z7d3d3yuXyoM0HAAAAg6Wpp6enp9FNJMlZZ52VSy+9NEnyd3/3d/nYxz42oHl++9vf9gb+Sy+9NPPnzx+sFvtUqVQyceLErFmzJi0tLXU5JsCWTDvnpka3AK9aSy86stEtAPAq0p8cOiQW/PvEJz7RG/wXLlw44OCfJLvvvnte+9rXJkmWLFkyGO0BAADAsNbwx/7PPvvsLFy4MEly8cUX58wzz2xwRwAAAFAsDQ3/Gz/qf/HFF+fss89+xXP+7ne/y8qVK5Mk06dPf8XzAQAAwHDXsPC/cfBfuHBhTXf8e3p60tTU1Of+DT9AGDFiRI466qjBaRYAAACGsYZ85n/jz/gvWrSo5kf9ly1blre//e3p7OzMkiVLsmGtwu7u7tx11105/PDD84Mf/CBJ0t7enr322mv7nAAAAAAMI3Vf7f+xxx7L1KlTk7x8d36XXXbps/6ss87KWWedlSRZunTpJo/yjxkzJjvuuGPWrl2bF154oXf7SSedlK9//esZNap+DzZY7R8YKqz2D41jtX8A6qk/ObTuj/13d3dv8v7JJ5/ss75arfa+f/3rX58vfvGLufPOO/Mf//Efeeqpp7J69eqMHTs206dPz4EHHpiTTz45Bx100HbrHwCgkerxAz4/xAAonrqH/2nTpmWgDxuMGzcuf/3Xf52//uu/HuSuAAAAoLga8pl/AAAAoH4a+lV/AK9GPpMPxeW/bwCGKnf+AQAAoODc+a9BuVxOuVzus2bjhQkBAABgKBH+a9DZ2ZmOjo5GtwEAAAADIvzXoL29PW1tbX3WVKvVtLa21qkjAAAAqJ3wX4NSqZRSqdRnTaVSqVM3AAAA0D8W/AMAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IR/AAAAKDjhHwAAAApuVKMbGA7K5XLK5XKfNdVqtU7dAAAAQP8I/zXo7OxMR0dHo9sAAACAARH+a9De3p62trY+a6rValpbW+vUEQAAANRO+K9BqVRKqVTqs6ZSqdSpGwAAAOgfC/4BAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABTcqEY3MByUy+WUy+U+a6rVap26AQAAgP4R/mvQ2dmZjo6ORrcBAFAY0865absfY+lFR273YwAMF8J/Ddrb29PW1tZnTbVaTWtra506AgAAgNoJ/zUolUoplUp91lQqlTp1AwAAAP1jwT8AAAAoOOEfAAAACk74BwAAgILzmX+AjdRj9WmAoc6fhQDF484/AAAAFJzwDwAAAAUn/AMAAEDBCf8AAABQcMI/AAAAFJzwDwAAAAUn/AMAAEDBjWp0A8NBuVxOuVzus6ZardapGwAAAOgf4b8GnZ2d6ejoaHQbAAAAMCDCfw3a29vT1tbWZ021Wk1ra2udOgIAAIDaCf81KJVKKZVKfdZUKpU6dQMAAAD9Y8E/AAAAKDjhHwAAAApO+AcAAICCE/4BAACg4IZ1+F+7dm0WLFiQmTNnZsKECZk4cWLe9ra35dJLL82LL77Y6PYAAABgSBi2q/0vW7Ys73znO7N06dIkSXNzc1544YXce++9uffee3P11Vdn8eLFmTRpUmMbBQAAgAYbluF/3bp1ec973pOlS5emVCrlqquuyqGHHpru7u5ce+21Oe2003L//ffnhBNOyE033dTodoFBMu0c/z0DMLRs77+bll505HadH3j1GJaP/X/zm9/Mr371qyTJ97///Rx66KFJkhEjRuTYY49NZ2dnkuSHP/xhFi9e3LA+AQAAYCgYtuE/SQ455JAccMABm+0/7rjjMn369CTJVVddVdfeAAAAYKgZdo/9d3V15ec//3mS5PDDD99iTVNTU9797nfnq1/9am677bZ6tsdGPAZXm6I8yl6Ufx8AFEdR/o4FGAzD7s7/ww8/nO7u7iTJjBkztlq3Yd+KFSuyatWquvQGAAAAQ9Gwu/P/xBNP9L6fMmXKVus23vfEE09k55133mT/okWLsmjRokHra/369UmSSqUyaHMOd90vdG3X+Yvye729f5/qpR7/PoryewUAtSrK/+8A28eGPyN6enq2WTvswv/atWt73zc3N2+1buN9G4/ZoFKpZPny5YPbXJLddttt0Odkyyb+faM7YGP+fQDA4PP3K1CLtWvXZuLEiX3WDLvwP1haWlr6fHKgv7q7u3PqqafmzDPPTFNT06DNy9C39957p1wup1Qq5T//8z8b3Q5sxjXKUOcaZThwnTLUuUZfnXp6erJ27drsuuuu26wdduF/xx137H3f1bX1R4A33rfxmA3mz5+f+fPnD25zvCqNGDGi958tLS0N7gY25xplqHONMhy4ThnqXKOvXtu647/BsFvwb+OfaPT12P7G+2r5KQgAAAAU1bAL/29+85t7f6r14IMPbrVuw77JkydvttgfAAAAvJoMu/Df3Nycgw46KElyyy23bLGmp6cnt956a5Jkzpw5desNAAAAhqJhF/6TZN68eUmSH//4x7n77rs323/ttddmyZIlSZIPfehDde0NAAAAhpphG/5nzpyZnp6eHH300Vm8eHGSl1fcv/baa3PaaaclSQ4//PDMnj27ka0CAABAww271f6TZNSoUbnhhhtyyCGHZOnSpTn00EPT3Nyc7u7uPP/880mSfffdN1dffXWDOwUAAIDGG5Z3/pNk2rRpeeCBB3LeeedlxowZaWpqyujRo7P//vtn4cKFueuuuzJp0qRGtwkAAAANNyzv/G+w4447pqOjIx0dHY1uBQAAAIasYXvnHwAAAKiN8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFN6rRDcBwN3/+/FQqlbS0tDS6Fdgi1yhDnWuU4cB1ylDnGmVbmnp6enoa3QQAAACw/XjsHwAAAApO+Ich6PHHH8+8efPy+te/PmPGjMk+++yTL3zhC/GgDkPBiSeemKampq2+TjvttEa3yKvc0qVLt3p9nnjiiY1uD/LYY4/lhBNOyN57752WlpZMmDAhM2bMyGc+85msXbu20e1BkqRarWbBggU56qijMnnyZH+GFoDP/MMQUy6X88d//MdZvXp1/uqv/iq77757fvKTn+SjH/1oHnvssSxcuLDRLfIq197enkMPPXSz7VdeeWUWL16cI488sgFdwebe//73Z+7cuZts+x//4380qBv4f5588sn8/ve/z/vf//7stttuGTlyZO69995ccMEFueGGG3LnnXdm9OjRjW6TV7mVK1emo6MjpVIpb33rW3PTTTc1uiVeIZ/5hyHmIx/5SL74xS/me9/7Xo4++uhNtn/5y1/OQw89lL333ruBHcLmuru7M3Xq1LzwwgtZvny5/2mloZYuXZrp06fn/PPPz4IFCxrdDtTskksuySc+8YncdNNNOeKIIxrdDq9yL7zwQlauXJkpU6bk+eefz7hx4zJv3rxceeWVjW6NAfLYPwwxP/nJTzJu3LjN7lb9+Z//ebq7u/OP//iPDeoMtu7222/P73//+xx//PGCP0PKc889l+eee67RbUBNpk+fniRZvXp1gzuBZMyYMZkyZUqj22AQCf8wxLzwwgsZN25cmpqaNtk+fvz4JMk999zTiLagT1dccUWS5KSTTmpwJ/D/XHrppWlubk5zc3N23333fPGLX7R2CkPK888/n5UrV+bxxx/PTTfdlHPPPTdjx47NwQcf3OjWgAIS/im0rq6u3Hzzzbngggsyd+7cTJ06tXfRp1ofBV27dm0WLFiQmTNnZsKECZk4cWLe9ra35dJLL82LL7446D3vvffeWbVqVR588MFNtv/4xz9OkixfvnzQj0njDMdr9A+tWbMm1113Xfbbb7/80R/90XY/HvU1HK/RESNGZPbs2fnc5z6XG264IZ2dnZk0aVI+8pGP5OMf//igH4/GGo7X6AaXXXZZdtlll7zxjW/MUUcdlREjRuT666/Pbrvttt2OSWMM5+uU4rDgH4X2i1/84hV9Zm7ZsmV55zvfmaVLlyZJmpub88ILL+Tee+/Nvffem6uvvjqLFy/OpEmTNhvb09OTF154oabjjBgxIjvssEOS5IwzzsgNN9yQY489Nl/4whey++6756c//Wk+/elPZ9SoUenq6hrw+TD0DMdr9A9dc801ef755931L6jheI2+8Y1vzO23377J/lNOOSWzZ8/OF77whbS3t+fNb37zgM+JoWU4XqMbvO9978vee++dNWvW5N///d/zk5/8JJVKZcDnwtA1nK9TisOdfwpv0qRJmT17ds4+++x85zvfyeTJk2sat27durznPe/J0qVLUyqV8qMf/SjPPvtsurq6cs0112THHXfM/fffnxNOOGGL45ctW5Zx48bV9Npvv/16x82ePTtXXHFFVqxYkUMPPTTTpk1Le3t7LrzwwkyaNCk77rjjoPy+MHQMt2v0D1155ZXZYYcd8sEPfnBA58/QN9yv0SQZOXJkPvnJT6anpyc/+tGP+v17wNA2XK/RN7zhDTn00ENz9NFH59JLL80nP/nJHHPMMZv98IpiGK7XKcXhzj+FNmvWrKxatWqTbeecc05NY7/5zW/mV7/6VZLk+9//fg444IAkL/9E9Nhjj013d3c++MEP5oc//GEWL16c2bNnbzL+ta99be/noLflD39KO2/evHzgAx/IAw88kBdffDEzZszIqFGjcsYZZ+SQQw6paU6Gh+F6jW7wm9/8JnfddVf+9E//NDvvvHNNczG8DPdrdGNTp05N8vLXV1EcRbpG586dm7Fjx+aKK67Y4leqMnwV6TplGOuBV5mpU6f2JOk5//zz+6ybNWtWT5KeQw45ZIv7u7u7e6ZPn96TpOdDH/rQduh0U9dff31Pkp5vfOMb2/1YNNZwukY/+clP9iTpuemmm7bL/AxNw+ka3diGP0e/9KUvbfdj0VjD9Rp9/vnne0aOHNlz+OGHb/dj0XjD6Tp97rnnepL0zJs3b7vMT3147B+2oKurKz//+c+TJIcffvgWa5qamvLud787SXLbbbdt137Wrl2bT3/603njG9+YY489drsei+FhKFyj69evz7e+9a2USqUcdthhgz4/w1sjr9H//u//3mzb888/n//1v/5XRo4c6XolSWOv0SeffHKL2zs7O7N+/fr88R//8aAdi+FtKPx9T3F47B+24OGHH053d3eSZMaMGVut27BvxYoVWbVq1aA89lytVvP//X//X+9KsCtWrMjll1+ep556Krfddluam5tf8TEY/hp5jW7wox/9KE888UQ++clPZuTIkYM2L8XQyGu0vb09Tz/9dA455JC84Q1vyIoVK3LVVVflt7/9bc4///zsvvvur/gYDH+NvEY/+clP5te//nXe9a53ZerUqalWq/nJT36Sf/mXf8lee+2Vj370o6/4GBRDo/++/9KXvpRnnnkm69atS5I88MADueCCC5IkBx98sK+lHGaEf9iCJ554ovf9lClTtlq38b4nnnhiUP6g3WGHHfKWt7wlV155ZZ588snstNNOOfTQQ3P++ednzz33fMXzUwyNvEY3uPLKK5MkJ5544qDNSXE08ho96qijctVVV+VrX/taVq1alfHjx2e//fbLRRddlKOPPvoVz08xNPIanTt3bp5++ul885vfzFNPPZVRo0Zl9913z6c//emcddZZaWlpecXHoBga/ff9woULs2zZst5f33///bn//vuTJOeff77wP8wI/7AFa9eu7X3f1532jfdtPOaV2GGHHfJP//RPgzIXxdXIa3SDa665Jtdcc82gzklxNPIaPeWUU3LKKacMylwUVyOv0ba2trS1tQ3KXBRbo/++3/DVghSDz/wDAABAwQn/sAU77rhj7/uurq6t1m28b+MxsL25RhnqXKMMda5RhgPXKYNJ+Ict2HXXXXvfL1++fKt1G+/beAxsb65RhjrXKEOda5ThwHXKYBL+YQve/OY3Z8SIl//zePDBB7dat2Hf5MmTB3UhNdgW1yhDnWuUoc41ynDgOmUwCf+wBc3NzTnooIOSJLfccssWa3p6enLrrbcmSebMmVO33iBxjTL0uUYZ6lyjDAeuUwaT8A9bMW/evCTJj3/849x9992b7b/22muzZMmSJMmHPvShuvYGiWuUoc81ylDnGmU4cJ0yWIR/Cm/16tVZuXJl76u7uzvJywujbLy9Wq1uMm7evHmZOXNmenp6cvTRR2fx4sVJku7u7lx77bU57bTTkiSHH354Zs+eXd+TolBcowx1rlGGOtcow4HrlIbrgYKbOnVqT5JtvubNm7fZ2EcffbRn2rRpvTXNzc09Y8eO7f31vvvu27Nq1ar6nxSF4hplqHONMtS5RhkOXKc0mjv/0Idp06blgQceyHnnnZcZM2akqakpo0ePzv7775+FCxfmrrvuyqRJkxrdJq9irlGGOtcoQ51rlOHAdcpgaOrp6elpdBMAAADA9uPOPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwQn/AAAAUHDCPwAAABSc8A8AAAAFJ/wDAABAwf3/MldA/g7NaEIAAAAASUVORK5CYII=\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "min(dfJP1),max(dfJP1)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "docwIorh7ua6",
+        "outputId": "dbdc28b3-0703-4dbe-9f41-054de2051b85"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(2.78965040474745e-10, 0.0021213631205086)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 29
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calculate the average of the entire DataFrame\n",
+        "average = np.mean(dfJP1)\n",
+        "\n",
+        "# Print the average\n",
+        "print(\"Average of the data:\", average)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "tONcb8Tq8CQ2",
+        "outputId": "e382f868-3eb1-4cbf-e802-58f04c2591f0"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Average of the data: 1.6320660269565937e-05\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Efficiency = average/max(dfJP1)\n",
+        "\n",
+        "# Print the efficiency\n",
+        "print(\"Effiency of weight distribution is {:.2%}\".format(Efficiency))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "v77Awe1Q8PfN",
+        "outputId": "6648d7fc-b9fb-4224-f11e-2d9204968b71"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Effiency of weight distribution is 0.77%\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "from google.colab import files\n",
+        "uploaded = files.upload()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 76
+        },
+        "id": "6GCSNedI8rC8",
+        "outputId": "2c7f11da-9d35-4ccd-f366-46d04922278c"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<IPython.core.display.HTML object>"
+            ],
+            "text/html": [
+              "\n",
+              "     <input type=\"file\" id=\"files-99d4a2d0-3b99-40cb-8f45-67b6e779d866\" name=\"files[]\" multiple disabled\n",
+              "        style=\"border:none\" />\n",
+              "     <output id=\"result-99d4a2d0-3b99-40cb-8f45-67b6e779d866\">\n",
+              "      Upload widget is only available when the cell has been executed in the\n",
+              "      current browser session. Please rerun this cell to enable.\n",
+              "      </output>\n",
+              "      <script>// Copyright 2017 Google LLC\n",
+              "//\n",
+              "// Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+              "// you may not use this file except in compliance with the License.\n",
+              "// You may obtain a copy of the License at\n",
+              "//\n",
+              "//      http://www.apache.org/licenses/LICENSE-2.0\n",
+              "//\n",
+              "// Unless required by applicable law or agreed to in writing, software\n",
+              "// distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+              "// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+              "// See the License for the specific language governing permissions and\n",
+              "// limitations under the License.\n",
+              "\n",
+              "/**\n",
+              " * @fileoverview Helpers for google.colab Python module.\n",
+              " */\n",
+              "(function(scope) {\n",
+              "function span(text, styleAttributes = {}) {\n",
+              "  const element = document.createElement('span');\n",
+              "  element.textContent = text;\n",
+              "  for (const key of Object.keys(styleAttributes)) {\n",
+              "    element.style[key] = styleAttributes[key];\n",
+              "  }\n",
+              "  return element;\n",
+              "}\n",
+              "\n",
+              "// Max number of bytes which will be uploaded at a time.\n",
+              "const MAX_PAYLOAD_SIZE = 100 * 1024;\n",
+              "\n",
+              "function _uploadFiles(inputId, outputId) {\n",
+              "  const steps = uploadFilesStep(inputId, outputId);\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  // Cache steps on the outputElement to make it available for the next call\n",
+              "  // to uploadFilesContinue from Python.\n",
+              "  outputElement.steps = steps;\n",
+              "\n",
+              "  return _uploadFilesContinue(outputId);\n",
+              "}\n",
+              "\n",
+              "// This is roughly an async generator (not supported in the browser yet),\n",
+              "// where there are multiple asynchronous steps and the Python side is going\n",
+              "// to poll for completion of each step.\n",
+              "// This uses a Promise to block the python side on completion of each step,\n",
+              "// then passes the result of the previous step as the input to the next step.\n",
+              "function _uploadFilesContinue(outputId) {\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  const steps = outputElement.steps;\n",
+              "\n",
+              "  const next = steps.next(outputElement.lastPromiseValue);\n",
+              "  return Promise.resolve(next.value.promise).then((value) => {\n",
+              "    // Cache the last promise value to make it available to the next\n",
+              "    // step of the generator.\n",
+              "    outputElement.lastPromiseValue = value;\n",
+              "    return next.value.response;\n",
+              "  });\n",
+              "}\n",
+              "\n",
+              "/**\n",
+              " * Generator function which is called between each async step of the upload\n",
+              " * process.\n",
+              " * @param {string} inputId Element ID of the input file picker element.\n",
+              " * @param {string} outputId Element ID of the output display.\n",
+              " * @return {!Iterable<!Object>} Iterable of next steps.\n",
+              " */\n",
+              "function* uploadFilesStep(inputId, outputId) {\n",
+              "  const inputElement = document.getElementById(inputId);\n",
+              "  inputElement.disabled = false;\n",
+              "\n",
+              "  const outputElement = document.getElementById(outputId);\n",
+              "  outputElement.innerHTML = '';\n",
+              "\n",
+              "  const pickedPromise = new Promise((resolve) => {\n",
+              "    inputElement.addEventListener('change', (e) => {\n",
+              "      resolve(e.target.files);\n",
+              "    });\n",
+              "  });\n",
+              "\n",
+              "  const cancel = document.createElement('button');\n",
+              "  inputElement.parentElement.appendChild(cancel);\n",
+              "  cancel.textContent = 'Cancel upload';\n",
+              "  const cancelPromise = new Promise((resolve) => {\n",
+              "    cancel.onclick = () => {\n",
+              "      resolve(null);\n",
+              "    };\n",
+              "  });\n",
+              "\n",
+              "  // Wait for the user to pick the files.\n",
+              "  const files = yield {\n",
+              "    promise: Promise.race([pickedPromise, cancelPromise]),\n",
+              "    response: {\n",
+              "      action: 'starting',\n",
+              "    }\n",
+              "  };\n",
+              "\n",
+              "  cancel.remove();\n",
+              "\n",
+              "  // Disable the input element since further picks are not allowed.\n",
+              "  inputElement.disabled = true;\n",
+              "\n",
+              "  if (!files) {\n",
+              "    return {\n",
+              "      response: {\n",
+              "        action: 'complete',\n",
+              "      }\n",
+              "    };\n",
+              "  }\n",
+              "\n",
+              "  for (const file of files) {\n",
+              "    const li = document.createElement('li');\n",
+              "    li.append(span(file.name, {fontWeight: 'bold'}));\n",
+              "    li.append(span(\n",
+              "        `(${file.type || 'n/a'}) - ${file.size} bytes, ` +\n",
+              "        `last modified: ${\n",
+              "            file.lastModifiedDate ? file.lastModifiedDate.toLocaleDateString() :\n",
+              "                                    'n/a'} - `));\n",
+              "    const percent = span('0% done');\n",
+              "    li.appendChild(percent);\n",
+              "\n",
+              "    outputElement.appendChild(li);\n",
+              "\n",
+              "    const fileDataPromise = new Promise((resolve) => {\n",
+              "      const reader = new FileReader();\n",
+              "      reader.onload = (e) => {\n",
+              "        resolve(e.target.result);\n",
+              "      };\n",
+              "      reader.readAsArrayBuffer(file);\n",
+              "    });\n",
+              "    // Wait for the data to be ready.\n",
+              "    let fileData = yield {\n",
+              "      promise: fileDataPromise,\n",
+              "      response: {\n",
+              "        action: 'continue',\n",
+              "      }\n",
+              "    };\n",
+              "\n",
+              "    // Use a chunked sending to avoid message size limits. See b/62115660.\n",
+              "    let position = 0;\n",
+              "    do {\n",
+              "      const length = Math.min(fileData.byteLength - position, MAX_PAYLOAD_SIZE);\n",
+              "      const chunk = new Uint8Array(fileData, position, length);\n",
+              "      position += length;\n",
+              "\n",
+              "      const base64 = btoa(String.fromCharCode.apply(null, chunk));\n",
+              "      yield {\n",
+              "        response: {\n",
+              "          action: 'append',\n",
+              "          file: file.name,\n",
+              "          data: base64,\n",
+              "        },\n",
+              "      };\n",
+              "\n",
+              "      let percentDone = fileData.byteLength === 0 ?\n",
+              "          100 :\n",
+              "          Math.round((position / fileData.byteLength) * 100);\n",
+              "      percent.textContent = `${percentDone}% done`;\n",
+              "\n",
+              "    } while (position < fileData.byteLength);\n",
+              "  }\n",
+              "\n",
+              "  // All done.\n",
+              "  yield {\n",
+              "    response: {\n",
+              "      action: 'complete',\n",
+              "    }\n",
+              "  };\n",
+              "}\n",
+              "\n",
+              "scope.google = scope.google || {};\n",
+              "scope.google.colab = scope.google.colab || {};\n",
+              "scope.google.colab._files = {\n",
+              "  _uploadFiles,\n",
+              "  _uploadFilesContinue,\n",
+              "};\n",
+              "})(self);\n",
+              "</script> "
+            ]
+          },
+          "metadata": {}
+        },
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Saving startotalEweight.csv to startotalEweight.csv\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import pandas as pd\n",
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "# Read the CSV file into a pandas DataFrame\n",
+        "dfJS = pd.read_csv('startotalEweight.csv', delimiter = ' ')\n",
+        "dfJS"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 424
+        },
+        "id": "uWD_e75L-_Tv",
+        "outputId": "7f83168b-ddad-4fe3-ee5f-af6e4851625e"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "              _weight\n",
+              "0        1.078153e-03\n",
+              "1        2.427741e-03\n",
+              "2        2.008891e-03\n",
+              "3        3.091033e-04\n",
+              "4        2.507293e-03\n",
+              "...               ...\n",
+              "8996808  2.380422e-08\n",
+              "8996809  3.039204e-10\n",
+              "8996810  3.737553e-09\n",
+              "8996811  3.277676e-09\n",
+              "8996812  4.099606e-07\n",
+              "\n",
+              "[8996813 rows x 1 columns]"
+            ],
+            "text/html": [
+              "\n",
+              "  <div id=\"df-4ba8c004-473a-4ef5-a742-8d5dddf7b436\" class=\"colab-df-container\">\n",
+              "    <div>\n",
+              "<style scoped>\n",
+              "    .dataframe tbody tr th:only-of-type {\n",
+              "        vertical-align: middle;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe tbody tr th {\n",
+              "        vertical-align: top;\n",
+              "    }\n",
+              "\n",
+              "    .dataframe thead th {\n",
+              "        text-align: right;\n",
+              "    }\n",
+              "</style>\n",
+              "<table border=\"1\" class=\"dataframe\">\n",
+              "  <thead>\n",
+              "    <tr style=\"text-align: right;\">\n",
+              "      <th></th>\n",
+              "      <th>_weight</th>\n",
+              "    </tr>\n",
+              "  </thead>\n",
+              "  <tbody>\n",
+              "    <tr>\n",
+              "      <th>0</th>\n",
+              "      <td>1.078153e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>1</th>\n",
+              "      <td>2.427741e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>2</th>\n",
+              "      <td>2.008891e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>3</th>\n",
+              "      <td>3.091033e-04</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>4</th>\n",
+              "      <td>2.507293e-03</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>...</th>\n",
+              "      <td>...</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8996808</th>\n",
+              "      <td>2.380422e-08</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8996809</th>\n",
+              "      <td>3.039204e-10</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8996810</th>\n",
+              "      <td>3.737553e-09</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8996811</th>\n",
+              "      <td>3.277676e-09</td>\n",
+              "    </tr>\n",
+              "    <tr>\n",
+              "      <th>8996812</th>\n",
+              "      <td>4.099606e-07</td>\n",
+              "    </tr>\n",
+              "  </tbody>\n",
+              "</table>\n",
+              "<p>8996813 rows × 1 columns</p>\n",
+              "</div>\n",
+              "    <div class=\"colab-df-buttons\">\n",
+              "\n",
+              "  <div class=\"colab-df-container\">\n",
+              "    <button class=\"colab-df-convert\" onclick=\"convertToInteractive('df-4ba8c004-473a-4ef5-a742-8d5dddf7b436')\"\n",
+              "            title=\"Convert this dataframe to an interactive table.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "  <svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\" viewBox=\"0 -960 960 960\">\n",
+              "    <path d=\"M120-120v-720h720v720H120Zm60-500h600v-160H180v160Zm220 220h160v-160H400v160Zm0 220h160v-160H400v160ZM180-400h160v-160H180v160Zm440 0h160v-160H620v160ZM180-180h160v-160H180v160Zm440 0h160v-160H620v160Z\"/>\n",
+              "  </svg>\n",
+              "    </button>\n",
+              "\n",
+              "  <style>\n",
+              "    .colab-df-container {\n",
+              "      display:flex;\n",
+              "      gap: 12px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert {\n",
+              "      background-color: #E8F0FE;\n",
+              "      border: none;\n",
+              "      border-radius: 50%;\n",
+              "      cursor: pointer;\n",
+              "      display: none;\n",
+              "      fill: #1967D2;\n",
+              "      height: 32px;\n",
+              "      padding: 0 0 0 0;\n",
+              "      width: 32px;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-convert:hover {\n",
+              "      background-color: #E2EBFA;\n",
+              "      box-shadow: 0px 1px 2px rgba(60, 64, 67, 0.3), 0px 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "      fill: #174EA6;\n",
+              "    }\n",
+              "\n",
+              "    .colab-df-buttons div {\n",
+              "      margin-bottom: 4px;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert {\n",
+              "      background-color: #3B4455;\n",
+              "      fill: #D2E3FC;\n",
+              "    }\n",
+              "\n",
+              "    [theme=dark] .colab-df-convert:hover {\n",
+              "      background-color: #434B5C;\n",
+              "      box-shadow: 0px 1px 3px 1px rgba(0, 0, 0, 0.15);\n",
+              "      filter: drop-shadow(0px 1px 2px rgba(0, 0, 0, 0.3));\n",
+              "      fill: #FFFFFF;\n",
+              "    }\n",
+              "  </style>\n",
+              "\n",
+              "    <script>\n",
+              "      const buttonEl =\n",
+              "        document.querySelector('#df-4ba8c004-473a-4ef5-a742-8d5dddf7b436 button.colab-df-convert');\n",
+              "      buttonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "\n",
+              "      async function convertToInteractive(key) {\n",
+              "        const element = document.querySelector('#df-4ba8c004-473a-4ef5-a742-8d5dddf7b436');\n",
+              "        const dataTable =\n",
+              "          await google.colab.kernel.invokeFunction('convertToInteractive',\n",
+              "                                                    [key], {});\n",
+              "        if (!dataTable) return;\n",
+              "\n",
+              "        const docLinkHtml = 'Like what you see? Visit the ' +\n",
+              "          '<a target=\"_blank\" href=https://colab.research.google.com/notebooks/data_table.ipynb>data table notebook</a>'\n",
+              "          + ' to learn more about interactive tables.';\n",
+              "        element.innerHTML = '';\n",
+              "        dataTable['output_type'] = 'display_data';\n",
+              "        await google.colab.output.renderOutput(dataTable, element);\n",
+              "        const docLink = document.createElement('div');\n",
+              "        docLink.innerHTML = docLinkHtml;\n",
+              "        element.appendChild(docLink);\n",
+              "      }\n",
+              "    </script>\n",
+              "  </div>\n",
+              "\n",
+              "\n",
+              "<div id=\"df-91aab8e8-41e7-48f4-8abf-d3634b82f029\">\n",
+              "  <button class=\"colab-df-quickchart\" onclick=\"quickchart('df-91aab8e8-41e7-48f4-8abf-d3634b82f029')\"\n",
+              "            title=\"Suggest charts.\"\n",
+              "            style=\"display:none;\">\n",
+              "\n",
+              "<svg xmlns=\"http://www.w3.org/2000/svg\" height=\"24px\"viewBox=\"0 0 24 24\"\n",
+              "     width=\"24px\">\n",
+              "    <g>\n",
+              "        <path d=\"M19 3H5c-1.1 0-2 .9-2 2v14c0 1.1.9 2 2 2h14c1.1 0 2-.9 2-2V5c0-1.1-.9-2-2-2zM9 17H7v-7h2v7zm4 0h-2V7h2v10zm4 0h-2v-4h2v4z\"/>\n",
+              "    </g>\n",
+              "</svg>\n",
+              "  </button>\n",
+              "\n",
+              "<style>\n",
+              "  .colab-df-quickchart {\n",
+              "      --bg-color: #E8F0FE;\n",
+              "      --fill-color: #1967D2;\n",
+              "      --hover-bg-color: #E2EBFA;\n",
+              "      --hover-fill-color: #174EA6;\n",
+              "      --disabled-fill-color: #AAA;\n",
+              "      --disabled-bg-color: #DDD;\n",
+              "  }\n",
+              "\n",
+              "  [theme=dark] .colab-df-quickchart {\n",
+              "      --bg-color: #3B4455;\n",
+              "      --fill-color: #D2E3FC;\n",
+              "      --hover-bg-color: #434B5C;\n",
+              "      --hover-fill-color: #FFFFFF;\n",
+              "      --disabled-bg-color: #3B4455;\n",
+              "      --disabled-fill-color: #666;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart {\n",
+              "    background-color: var(--bg-color);\n",
+              "    border: none;\n",
+              "    border-radius: 50%;\n",
+              "    cursor: pointer;\n",
+              "    display: none;\n",
+              "    fill: var(--fill-color);\n",
+              "    height: 32px;\n",
+              "    padding: 0;\n",
+              "    width: 32px;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart:hover {\n",
+              "    background-color: var(--hover-bg-color);\n",
+              "    box-shadow: 0 1px 2px rgba(60, 64, 67, 0.3), 0 1px 3px 1px rgba(60, 64, 67, 0.15);\n",
+              "    fill: var(--button-hover-fill-color);\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-quickchart-complete:disabled,\n",
+              "  .colab-df-quickchart-complete:disabled:hover {\n",
+              "    background-color: var(--disabled-bg-color);\n",
+              "    fill: var(--disabled-fill-color);\n",
+              "    box-shadow: none;\n",
+              "  }\n",
+              "\n",
+              "  .colab-df-spinner {\n",
+              "    border: 2px solid var(--fill-color);\n",
+              "    border-color: transparent;\n",
+              "    border-bottom-color: var(--fill-color);\n",
+              "    animation:\n",
+              "      spin 1s steps(1) infinite;\n",
+              "  }\n",
+              "\n",
+              "  @keyframes spin {\n",
+              "    0% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "      border-left-color: var(--fill-color);\n",
+              "    }\n",
+              "    20% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    30% {\n",
+              "      border-color: transparent;\n",
+              "      border-left-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    40% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-top-color: var(--fill-color);\n",
+              "    }\n",
+              "    60% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "    }\n",
+              "    80% {\n",
+              "      border-color: transparent;\n",
+              "      border-right-color: var(--fill-color);\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "    90% {\n",
+              "      border-color: transparent;\n",
+              "      border-bottom-color: var(--fill-color);\n",
+              "    }\n",
+              "  }\n",
+              "</style>\n",
+              "\n",
+              "  <script>\n",
+              "    async function quickchart(key) {\n",
+              "      const quickchartButtonEl =\n",
+              "        document.querySelector('#' + key + ' button');\n",
+              "      quickchartButtonEl.disabled = true;  // To prevent multiple clicks.\n",
+              "      quickchartButtonEl.classList.add('colab-df-spinner');\n",
+              "      try {\n",
+              "        const charts = await google.colab.kernel.invokeFunction(\n",
+              "            'suggestCharts', [key], {});\n",
+              "      } catch (error) {\n",
+              "        console.error('Error during call to suggestCharts:', error);\n",
+              "      }\n",
+              "      quickchartButtonEl.classList.remove('colab-df-spinner');\n",
+              "      quickchartButtonEl.classList.add('colab-df-quickchart-complete');\n",
+              "    }\n",
+              "    (() => {\n",
+              "      let quickchartButtonEl =\n",
+              "        document.querySelector('#df-91aab8e8-41e7-48f4-8abf-d3634b82f029 button');\n",
+              "      quickchartButtonEl.style.display =\n",
+              "        google.colab.kernel.accessAllowed ? 'block' : 'none';\n",
+              "    })();\n",
+              "  </script>\n",
+              "</div>\n",
+              "    </div>\n",
+              "  </div>\n"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 33
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "dfJS1 = dfJS[\"_weight\"]*1"
+      ],
+      "metadata": {
+        "id": "Ml0NAL7-_TZy"
+      },
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "plt.rc('font',size=18)\n",
+        "plt.rcParams['figure.figsize'] = [12, 8]\n",
+        "ax1 = plt.subplot()\n",
+        "plt.hist(dfJS1, bins=np.logspace(start=np.log10(10**(-20)), stop=np.log10(1), num=35))\n",
+        "plt.gca().set_xscale(\"log\")\n",
+        "ax1.minorticks_on()\n",
+        "ax1.tick_params('both', length=15, width=2, which='major')\n",
+        "ax1.tick_params('both', length=7, width=1, which='minor')\n",
+        "plt.show()"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 501
+        },
+        "id": "TD1vJJeW_cQy",
+        "outputId": "dd84505a-2666-4504-c377-350a94d4fb61"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 1200x800 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "min(dfJS1), max(dfJS1)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "CU9GPsrS_uYU",
+        "outputId": "644145f2-6dd8-48af-c992-f9fc918fa790"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(5.90477993850479e-32, 0.0027242016116445)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 36
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Calculate the average of the entire DataFrame\n",
+        "average = np.mean(dfJS1)\n",
+        "\n",
+        "# Print the average\n",
+        "print(\"Average of the data:\", average)"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "W0Q_btHUAXIX",
+        "outputId": "ec002aed-a1c1-4cd7-b944-0785905a31d7"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Average of the data: 1.7475563814467354e-06\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "Efficiency = average/max(dfJS1)\n",
+        "\n",
+        "# Print the efficiency\n",
+        "print(\"Effiency of weight distribution is {:.2%}\".format(Efficiency))\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "9Cie4l6WAoWG",
+        "outputId": "90251c27-845c-4d40-d091-7e35eebadfd8"
+      },
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Effiency of weight distribution is 0.06%\n"
+          ]
+        }
+      ]
+    }
+  ]
+}
\ No newline at end of file
diff --git a/include/nucleus.h b/include/nucleus.h
index b75ba11..77f5c03 100644
--- a/include/nucleus.h
+++ b/include/nucleus.h
@@ -66,21 +66,46 @@ class nucleus
 
 	double nuclearRadius() const { return _Radius; }
 	double rho0() const { return _rho0; }
+	double woodSaxonSkinDepth() const { return _woodSaxonSkinDepth;}
+	/** The "wine_bottle" parameter
+	 */
+	double w() const {return _w;}
+	
 	
 private:
 
-	double woodSaxonSkinDepth() const { return 0.53; } // 0.53 fm skin depth
-	double rws(const double r) const;
-
+	 
+	
+    double rws(const double r) const;
 	int    _Z;                      ///< atomic number of nucleus
 	int    _A;                      ///< nucleon number of nucleus
-        int    _productionMode;
+    int    _productionMode;
 
 	double _r0;
 	double _Radius;
 	double _rho0;
-
+	double _w;               ///< 3pF fermi model parameter
+	double _woodSaxonSkinDepth;
+	double _v; ///< Sum of Gaussian(SOG) model parameter 
+	double *_a;  // SOG model parameter
+        double *_b;  // SOG model parameter
+        double *_c;  // SOG model parameter
+
+//SOG model parameters https:doi.org/10.1016/0092-640X(87)90013-1
+
+	double pkCarb[12] = {0.009560250143852663, 0.02161993792818375, 0.023894326875090147, 0.022871610300732596, 0.01787510497352304, 0.013266599310805718, 0.0020798983410400215, 0.0012487276970433168, 0.0001121651485588463, 0.00001856133380347859, 0.00000004241988368721027, 0.0};
+        double okCarb[12] = {0.016690, 0.050325, 0.128621, 0.180515, 0.219097, 0.278416, 0.058779, 0.057817, 0.007739, 0.002001, 0.000007, 0.0};
+        double qkCarb[12] = {0.0, 0.4, 1.0, 1.3, 1.7, 2.3, 2.7, 3.5, 4.3, 5.4, 6.7, 0.0};
+    
+	double rkHel[12] = {0.2, 0.6, 0.9, 1.4, 1.9, 2.3, 2.6, 3.1, 3.5, 4.2, 4.9, 5.2};
+        double tkHel[12] = {0.034724, 0.430761, 0.203166, 0.192986, 0.083866, 0.033007, 0.014201, 0.0, 0.006860, 0.0, 0.000438, 0.0};
+	double skHel[12] = {0.010229060308680777, 0.0683272860306785, 0.01954234673886537, 0.009254567928457054, 0.002338942473693466, 0.0006455191775197494, 0.00022017367746850975, 0.0, 0.000059954958779193, 0.0, 0.000001978748821697672, 0.0};
 };
 
 
 #endif  // NUCLEUS_H
+
+
+
+
+
diff --git a/include/starlightconstants.h b/include/starlightconstants.h
index dd03dc9..2094b03 100644
--- a/include/starlightconstants.h
+++ b/include/starlightconstants.h
@@ -102,8 +102,8 @@ namespace starlightConstants
         static const double rho0Mass  = 0.769;               // [GeV/c^2]
 	static const double rho0Width = 0.1517;              // [GeV/c^2]
 	static const double rho0BrPiPi = 1.0;                // Branching ratio pi+pi-
-        static const double rho0PrimeMass  = 1.540;          // [GeV/c^2]
-	static const double rho0PrimeWidth = 0.570;          // [GeV/c^2]
+        static const double rho0PrimeMass  = 1.465;          // [GeV/c^2]
+	static const double rho0PrimeWidth = 0.4;          // [GeV/c^2]
 	static const double rho0PrimeBrPiPi = 1.0;           // Branching ratio pi+pi- (set to 100%)
         static const double OmegaMass  = 0.78265;            // [GeV/c^2]
 	static const double OmegaWidth = 0.00849;            // [GeV/c^2]
diff --git a/src/e_wideResonanceCrossSection.cpp b/src/e_wideResonanceCrossSection.cpp
index 5d58c53..75a90e3 100644
--- a/src/e_wideResonanceCrossSection.cpp
+++ b/src/e_wideResonanceCrossSection.cpp
@@ -125,6 +125,11 @@ e_wideResonanceCrossSection::crossSectionCalculation(const double bwnormsave)
 		W = _wideWmin + double(iW)*dW + 0.5*dW;
 		int nQ2 = 1000;
 		for(iEgamma = 0 ; iEgamma < nEgamma; ++iEgamma){    // Integral over photon energy
+		  // Displaying the percentage progress
+		  float ratio = float(iW)/float(nW)  + 1/float(nW)*float(iEgamma)/float(nEgamma);
+		 printf("calculating cross section :%3.2f %%\r",float(ratio *100.0));
+		  
+		  
 		  // Target frame photon energies
 		  ega[0] = exp(minEgamma + iEgamma*dEgamma );
 		  ega[1] = exp(minEgamma + (iEgamma+1)*dEgamma );
diff --git a/src/gammaavm.cpp b/src/gammaavm.cpp
index f10765a..af22252 100644
--- a/src/gammaavm.cpp
+++ b/src/gammaavm.cpp
@@ -35,6 +35,7 @@
 #include <fstream>
 #include <cassert>
 #include <cmath>
+#include <sstream>
 
 #include "gammaavm.h"
 //#include "photonNucleusCrossSection.h"
@@ -1124,8 +1125,11 @@ eXEvent Gammaavectormeson::e_produceEvent()
 	int iFbadevent=0;
 	int tcheck=0;
 	starlightConstants::particleTypeEnum ipid = starlightConstants::UNKNOWN;
-        starlightConstants::particleTypeEnum vmpid = starlightConstants::UNKNOWN; 
-	// at present 4 prong decay is not implemented
+    starlightConstants::particleTypeEnum vmpid = starlightConstants::UNKNOWN; 
+	// at present 4 prong decay is implemented (rhoprime(1450))
+	double ptCutMin2 = _ptCutMin*_ptCutMin;//used for ptCut comparison without using square roots - to reduce processing time
+	double ptCutMax2 = _ptCutMax*_ptCutMax;//same as above
+
 	double comenergy = 0.;
 	double rapidity = 0.;
 	double Q2 = 0;
@@ -1137,6 +1141,103 @@ eXEvent Gammaavectormeson::e_produceEvent()
 	double e_E=0., e_phi=0;
 	double t_px =0, t_py=0., t_pz=0, t_E;
 	bool accepted = false;
+	
+	if (_VMpidtest == starlightConstants::FOURPRONG) {
+	double mom[3] ={0,0,0};
+	lorentzVector decayVecs[4];
+	bool accepted;
+	double rapidity = 0;
+	do {
+	tcheck = 0;//reinitialized after every loop cycle - to avoid infinite loop
+	iFbadevent = 0;//same as above.
+	//pickwy(comenergy, rapidity); 
+	pickwEgamq2(comenergy,cmsEgamma, targetEgamma, 
+		   Q2, gamma_pz, gamma_pt, //photon infor in CMS frame
+		   e_E, e_theta);
+	
+	//Vector meson is created and its four momentum is determined below
+	//if (_VMinterferencemode == 0)
+	 momenta(comenergy,cmsEgamma, Q2, gamma_pz, gamma_pt, //input
+		  rapidity, E, mom[0], mom[1], mom[2], //VM
+		  t_px, t_py, t_pz, t_E, //pomeron
+		  e_phi,tcheck);
+		  
+	 _nmbAttempts++;
+	 accepted = true;//re-initialized after every loop cycle -to avoid infinite loop
+	
+	if(tcheck != 0 || !fourBodyDecay(ipid,E,comenergy,mom,decayVecs,iFbadevent))
+	{//if either vector meson creation, or further decay into four pions, is impossible
+	accepted = false;
+	continue;//this skips the etaCut and ptCut checks.
+	}
+	
+	if (_ptCutEnabled) {
+	for (int i = 0; i < 4; i++) {
+	double pt_chk2 = 0;
+	pt_chk2 += pow( decayVecs[i].GetPx() , 2);
+	pt_chk2 += pow( decayVecs[i].GetPy() , 2);// compute transverse momentum (squared) for the particle, for ptCut checks.
+	
+	if (pt_chk2 < ptCutMin2 || pt_chk2 > ptCutMax2) {//if particle does not fall into ptCut range.
+	accepted = false;
+	break;//skips checking other daughter particles
+	}
+	}
+	}
+	if (_etaCutEnabled) {
+	for (int i = 0; i < 4; i++) {
+	double eta_chk = pseudoRapidity(
+	decayVecs[i].GetPx(),
+	decayVecs[i].GetPy(),
+	decayVecs[i].GetPz()
+	);
+	//computes the pseudorapidity in the laboratory frame.
+	if (eta_chk < _etaCutMin || eta_chk > _etaCutMax) {//if this particle does not fall into range
+	accepted = false;
+	break;//skips checking other daughter particles
+	}
+	}
+	}
+	if (accepted and (tcheck == 0)) {
+	_nmbAccepted++;//maintain counts of accepted events.
+	}
+	
+	} while (!accepted || tcheck != 0);//repeats loop if VM creation, decay, ptcut or etaCut criterias are not fulfilled. Important to avoid situations where events produced is less than requested.
+	if (iFbadevent==0&&tcheck==0) {
+	  double e_ptot = sqrt(e_E*e_E - starlightConstants::mel*starlightConstants::mel);
+	  double e_px = e_ptot*sin(e_theta)*cos(e_phi);
+	  double e_py = e_ptot*sin(e_theta)*sin(e_phi);
+	  double e_pz = e_ptot*cos(e_theta);
+	  lorentzVector electron(e_px, e_py, e_pz, e_E);
+	  event.addSourceElectron(electron);
+	  // - Generated photon - target frame
+	  double gamma_x = gamma_pt*cos(e_phi+starlightConstants::pi);
+	  double gamma_y = gamma_pt*sin(e_phi+starlightConstants::pi);
+	  lorentzVector gamma(gamma_x,gamma_y,gamma_pz,cmsEgamma);
+	  vector3 boostVector(0, 0, tanh(_rap_CM));
+	  (gamma).Boost(boostVector);
+	  event.addGamma(gamma, targetEgamma, Q2);
+
+	double md = getDaughterMass(ipid);
+	//adds daughters as particles into the output event.
+	for (unsigned int i = 0; i < 4; ++i) {
+	starlightParticle daughter(decayVecs[i].GetPx(),
+	                          decayVecs[i].GetPy(),
+	                          decayVecs[i].GetPz(),
+	  sqrt(decayVecs[i].GetPx()*decayVecs[i].GetPx()+decayVecs[i].GetPy()*decayVecs[i].GetPy()+decayVecs[i].GetPz()*decayVecs[i].GetPz()+md*md),//energy
+	  md,  // _mass
+	  ipid*(2*(i/2)-1),   // make half of the particles pi^+, half pi^-
+	  (2*(i/2)-1));//charge
+	event.addParticle(daughter);
+	}
+	// - Scattered target and transfered momenta at target vertex
+	  double target_pz =  - _beamNucleus*sqrt(_pEnergy*_pEnergy - pow(starlightConstants::protonMass,2.) ) - t_pz;
+	  //Sign of t_px in following equation changed to fix sign error and conserve p_z.  Change made by Spencer Klein based on a bug report from Ya-Ping Xie.  Nov. 14, 2019
+	  lorentzVector target(-t_px, -t_py, target_pz, _beamNucleus*_pEnergy - t_E);
+	  double t_var = t_E*t_E - t_px*t_px - t_py*t_py - t_pz*t_pz;
+	  event.addScatteredTarget(target, t_var);
+	}
+	}
+else {
 	do{
 	  pickwEgamq2(comenergy,cmsEgamma, targetEgamma, 
 		   Q2, gamma_pz, gamma_pt, //photon infor in CMS frame
@@ -1259,6 +1360,7 @@ eXEvent Gammaavectormeson::e_produceEvent()
 	  double t_var = t_E*t_E - t_px*t_px - t_py*t_py - t_pz*t_pz;
 	  event.addScatteredTarget(target, t_var);
 	}
+}
 	return event;
 
 }
diff --git a/src/inputParameters.cpp b/src/inputParameters.cpp
index eb645f1..5d8c7c9 100644
--- a/src/inputParameters.cpp
+++ b/src/inputParameters.cpp
@@ -386,15 +386,16 @@ inputParameters::configureFromFile(const std::string &_configFileName)
 		defaultMaxW         = mass + 5 * width;  // use the same 1.5GeV max mass as ZEUS
 		_inputBranchingRatio = starlightConstants::rho0BrPiPi; 
 		break;
-		//	case 999:  // pi+pi-pi+pi- phase space decay
-		//		_particleType = FOURPRONG;
-		//		_decayType    = WIDEVMDEFAULT;
-		//		mass          = starlightConstants::rho0PrimeMass;
-		//		width         = starlightConstants::rho0PrimeWidth;		
-		//		defaultMinW   = 4 * pionChargedMass;
-		//                defaultMaxW     = sqrt(beam1LorentzGamma()*beam2LorentzGamma())*2*(starlightConstants::hbarc)/(1.2*pow(float(beam1A()),1./6.)*pow(float(beam2A()),1./6.)); // JES 6.17.2015 to avoid problems with no default
-		//		_inputBranchingRatio = 1.0; 
-		//		break;
+	case 999:  // rho'(1450)-> pi+pi-pi+pi- phase space decay
+		_particleType = FOURPRONG;
+		_decayType    = WIDEVMDEFAULT;
+		mass          = starlightConstants::rho0PrimeMass;
+		width         = starlightConstants::rho0PrimeWidth;		
+		defaultMinW   = 4 * pionChargedMass;
+                defaultMaxW   = mass + 5 * width;	    
+    	        _inputBranchingRatio = starlightConstants::rho0PrimeBrPiPi; 
+		break;
+
 	case 223:  // omega(782)
 		_particleType = OMEGA;
 		_decayType    = NARROWVMDEFAULT;  
diff --git a/src/nucleus.cpp b/src/nucleus.cpp
index e83b47d..2ce71eb 100644
--- a/src/nucleus.cpp
+++ b/src/nucleus.cpp
@@ -61,22 +61,25 @@ void nucleus::init()
 		{
 		  _Radius = 6.624;
 		  _rho0 = 0.160696;
+		  _woodSaxonSkinDepth = 0.53; // fixed for 2pF model	
 		}
 		break;
 	case 79:
 		{
 		  _Radius = 6.38;
 		  _rho0 = 0.169551;
+	          _woodSaxonSkinDepth = 0.53; // fixed for 2pF model
 		}
 		break;
 	case 29:
 		{
                   _Radius = 4.214;
 		  _rho0 = 0.173845;
+	          _woodSaxonSkinDepth = 0.53; // fixed for 2pF model
 		}
 		break;
 	case 1: 
-		{
+	    {
 		  //is this a proton or deuteron
 		  if(_A==1){
 		    _Radius = 0.7;
@@ -87,14 +90,14 @@ void nucleus::init()
 		    _Radius = 0.;
 		    _rho0 = -1.0;
 		  }
-		  else {
-		    _Radius = 2.1;
-		    _rho0 = _A;
-		  }
-		}
-		break;
-	case -1: 
-		{
+		else{
+			_Radius = 2.127; // Measured rms radius for deuteron
+			_rho0 = _A;
+	     }
+	    }
+	    break;
+	case -1:
+	    {
 		  //is this a anti-proton
 		  if(_A==1){
 		    _Radius = 0.7;
@@ -107,38 +110,113 @@ void nucleus::init()
 		  }
 		  else {
 		    _Radius = 2.1;
-		    _rho0 = _A;
-		  }
-		}
-		break;
-	default:
-		printWarn << "density not defined for projectile with Z = " << _Z << ". using defaults." << endl;
-                _Radius = 1.2*pow(_A, 1. / 3.);
-		_rho0 = 0.138/(1.13505-0.0004283*_A);  //This matches the radius above
-		if( _Z < 7 ){
-		  // This is for Gaussian form factors/densities 
-		  _rho0 = _A;
-		}
+		    _rho0 = _A;	  
+	     }
+	    }
+	    break;
+	case 2: 
+	    {
+	    // Helium-4 (sum of gaussian model) https://doi.org/10.1016/0092-640X(87)90013-1
+		_a = rkHel;   // Ri values from Table V
+	        _b = tkHel;   // Qi values from Table V
+		_c = skHel;   // Ai coefficients calculated
+		_v = 0.81649; //width of Gaussians calculated
+		_rho0 = 2.0;
+		_Radius = 1.676;
+	    }
+	    break;
+	case 4: 
+	    {
+	    // Beryllium(10)
+		_Radius = 2.357; //measured rms radius
+		_rho0 = _A;
+	    }
+	    break;
+	case 5: 
+	    {
+	    // Boron(11)
+		_Radius = 2.42; //measured rms radius
+		_rho0 = _A;
+	    }
+	    break;
+	case 6: 
+	    {
+	    // Carbon(12) sum of gaussian model
+		 _a = qkCarb;
+	         _b = okCarb;
+		 _c = pkCarb;
+		 _v = 0.97978;
+		 _rho0 = 2.0;
+		 _Radius = 2.469;
+	    }
+	    break;
+	case 7: 
+            {
+	    // Nitrogen(14)(3pF model)
+		_Radius = 2.570;
+		_woodSaxonSkinDepth = 0.5052;
+		_w = -0.180;	   // 3pF fermi model wine parameter
+		_rho0 = 0.1790484; // determined by normalization
+	    }
+	    break;
+	case 8:
+	    {
+	    //Oxygen(16)(3pF model)
+		_Radius = 2.608;
+		_woodSaxonSkinDepth = 0.513;
+		_w= -0.051; // 3pF fermi model wine parameter
+		_rho0 = 0.16536; // determined by normalization
+	     }
+	     break;
+default:
+	     printWarn << "density not defined for projectile with Z = " << _Z << ". using defaults." << endl;
+             _Radius = 1.2*pow(_A, 1. / 3.);
+	     _rho0 = 0.138/(1.13505-0.0004283*_A);  //This matches the radius above
+	      if( _Z < 7 ){
+		// This is for Gaussian form factors/densities
+		_rho0 = _A;
+	    }
 	}
 }
 
 //______________________________________________________________________________
 nucleus::~nucleus()
-{ }
+{
+}
 
 //______________________________________________________________________________
 double
 nucleus::rws(const double r) const
 {
-  if( _Z < 7 ){
-    // Gaussian density distribution for light nuclei 
-    double norm = (3./(2.*starlightConstants::pi))*sqrt( (3./(2.*starlightConstants::pi)) );
-    norm = norm/(nuclearRadius()*nuclearRadius()*nuclearRadius());
-    return norm*exp(-((3./2.)*r*r)/(nuclearRadius()*nuclearRadius()));
-  }else{
-    // Fermi density distribution for heavy nuclei 
-    return 1.0 / (1. + exp((r - nuclearRadius()) / woodSaxonSkinDepth())); 
-  }
+	if (((_Z == 2) && (_A == 4)) || ((_Z == 6) && (_A == 12)))
+	{
+		// Sum of Gaussian Model https://doi.org/10.1016/0092-640X(87)90013-1
+		double _P = 0.0;
+		for (int i = 0; i < 12; i++) {
+		    _P += _c[i] * (exp(-1.0 * pow((r -_a[i]) /_v, 2)) + exp(-1.0 * pow((r +_a[i]) /_v, 2)));    
+		}
+		return _P;
+	}
+	else if (_Z < 7)
+	{
+		// Gaussian density distribution for light nuclei
+		double norm = (3. / (2. * starlightConstants::pi)) * sqrt((3. / (2. * starlightConstants::pi)));
+		norm = norm / (nuclearRadius() * nuclearRadius() * nuclearRadius());
+		return norm * exp(-((3. / 2.) * r * r) / (nuclearRadius() * nuclearRadius()));
+	}
+	else if (_Z == 7 || _Z == 8)
+	{
+		// 3-parameter-Fermi Model (3pF) https://doi.org/10.1016/0092-640X(87)90013-1
+		double x = exp(-(r - nuclearRadius()) / woodSaxonSkinDepth());
+		return x * (1.0 + w() * r * r / nuclearRadius() / nuclearRadius()) / (1.0 + x);
+		// expression adjusted to avoid problems on some machines if r is too large
+	}
+	else
+	{
+
+		// Fermi density distribution for heavy nuclei
+		return 1.0 / (1. + exp((r - nuclearRadius()) / woodSaxonSkinDepth()));
+	}
 }
 
 //______________________________________________________________________________
@@ -146,34 +224,50 @@ double
 nucleus::formFactor(const double t) const
 {
 	// electromagnetic form factor of proton
-	if ((_Z == 1) && (_A == 1)) {
+	if ((_Z == 1) && (_A == 1))
+	{
 		const double rec = 1. / (1. + t / 0.71);
 		return rec * rec;
 	}
-
-        if( _Z < 7 ){
-	  // Gaussian form factor for light nuclei
-          const double R_G    = nuclearRadius();
-          return exp(-R_G*R_G*t/(6.*starlightConstants::hbarc*starlightConstants::hbarc));
-        } else {
-          // nuclear form factor, from Klein Nystrand PRC 60 (1999) 014903, Eq. 14
-          const double R    = nuclearRadius();
-          const double q    = sqrt(t);
-          const double arg1 = q * R / hbarc;
-          const double arg2 = hbarc / (q * R);
-          const double sph  = (sin(arg1) - arg1 * cos(arg1)) * 3. * arg2 * arg2 * arg2;
-          const double a0   = 0.70;  // [fm]
-          return sph / (1. + (a0 * a0 * t) / (hbarc * hbarc));
-        }
+        // form factor for nuclei following sum of gaussian model https://arxiv.org/pdf/hep-ph/0608035
+	if (((_Z == 2) && (_A == 4)) || ((_Z == 6) && (_A == 12)))
+	{
+		double _F = 0.0;
+		const double q = sqrt(t);
+		for (int i = 0; i < 12; i++) {
+		    double qai = q * _a[i] / hbarc;
+		    double term1 = std::cos(qai);
+		    double term2 = (2 * _a[i] * hbarc/(_v*_v * q)) * (std::sin(qai));
+		    _F += (_b[i]/(1 + (2*_a[i] *_a[i]/(_v *_v)))) * (term1 + term2);     
+		}
+		return std::exp(-q * q *_v * _v/ (4 * hbarc * hbarc)) * _F;
+	}
+	
+	if (_Z < 7)
+	{
+		// Gaussian form factor for light nuclei
+		const double R_G = nuclearRadius();
+		return exp(-R_G * R_G * t / (6. * starlightConstants::hbarc * starlightConstants::hbarc));
+	}
+	else
+	{
+		// nuclear form factor, from Klein Nystrand PRC 60 (1999) 014903, Eq. 14
+		const double R = nuclearRadius();
+		const double q = sqrt(t);
+		const double arg1 = q * R / hbarc;
+		const double arg2 = hbarc / (q * R);
+		const double sph = (sin(arg1) - arg1 * cos(arg1)) * 3. * arg2 * arg2 * arg2;
+		const double a0 = 0.70; // [fm]
+		return sph / (1. + (a0 * a0 * t) / (hbarc * hbarc));
+	}
 }
 
 //______________________________________________________________________________
-
 double
 nucleus::dipoleFormFactor(const double t, const double t0) const
 {
-     const double rec = 1. / (1. + t / t0);
-     return rec * rec;
+	const double rec = 1. / (1. + t / t0);
+	return rec * rec;
 }
 
 //______________________________________________________________________________
@@ -183,27 +277,28 @@ nucleus::thickness(const double b) const
 	//    JS      This code calculates the nuclear thickness function as per Eq. 4 in
 	//    Klein and Nystrand, PRC 60.
 	//    former DOUBLE PRECISION FUNCTION T(b)
-                                                  
+
 	// data for Gauss integration
-	const unsigned int nmbPoints         = 5;
-	const double       xg[nmbPoints + 1] = {0., 0.1488743390, 0.4333953941, 0.6794095683,
-	                                        0.8650633667, 0.9739065285};
-	const double       ag[nmbPoints + 1] = {0., 0.2955242247, 0.2692667193, 0.2190863625,
-	                                        0.1494513492, 0.0666713443};
-  
-	const double zMin   = 0;
-	const double zMax   = 15;
-	const double zRange = 0.5 * (zMax - zMin); 
-	const double zMean  = 0.5 * (zMax + zMin); 
-	double       sum    = 0;
-	for(unsigned int i = 1; i <= nmbPoints; ++i) {
-		double zsp    = zRange * xg[i] + zMean;
+	const unsigned int nmbPoints = 5;
+	const double xg[nmbPoints + 1] = {0., 0.1488743390, 0.4333953941, 0.6794095683,
+									  0.8650633667, 0.9739065285};
+	const double ag[nmbPoints + 1] = {0., 0.2955242247, 0.2692667193, 0.2190863625,
+									  0.1494513492, 0.0666713443};
+
+	const double zMin = 0;
+	const double zMax = 15;
+	const double zRange = 0.5 * (zMax - zMin);
+	const double zMean = 0.5 * (zMax + zMin);
+	double sum = 0;
+	for (unsigned int i = 1; i <= nmbPoints; ++i)
+	{
+		double zsp = zRange * xg[i] + zMean;
 		double radius = sqrt(b * b + zsp * zsp);
-		sum          += ag[i] * rws(radius);
-		zsp           = zRange * (-xg[i]) + zMean;
-		radius        = sqrt(b * b + zsp * zsp);
-		sum          += ag[i] * rws(radius);
+		sum += ag[i] * rws(radius);
+		zsp = zRange * (-xg[i]) + zMean;
+		radius = sqrt(b * b + zsp * zsp);
+		sum += ag[i] * rws(radius);
 	}
-  
+
 	return 2. * zRange * sum;
 }
diff --git a/src/photonNucleusCrossSection.cpp b/src/photonNucleusCrossSection.cpp
index ca09dbe..2c15897 100644
--- a/src/photonNucleusCrossSection.cpp
+++ b/src/photonNucleusCrossSection.cpp
@@ -101,12 +101,12 @@ photonNucleusCrossSection::photonNucleusCrossSection(const inputParameters& inpu
 	  break;
 	case FOURPRONG:
 	  _slopeParameter      = 11.0;
-	  _vmPhotonCoupling      = 2.02;
+	  _vmPhotonCoupling      = 3.64; //arXiv:2005.13624
 	  _vmQ2Power_c1 = 2.09;
 	  _vmQ2Power_c2 = 0.0073; // [GeV^{-2}]
 	  _ANORM       = -2.75;
 	  _BNORM       = 0;  
-	  _defaultC    = 11.0;
+	  _defaultC    = 1.0;
 	  _channelMass  = starlightConstants::rho0PrimeMass;
 	  _width        = starlightConstants::rho0PrimeWidth;
 	  break;
@@ -257,9 +257,9 @@ photonNucleusCrossSection::getcsgA(const double targetEgamma,
 	double W = _channelMass; //new change, channel mass center used for the t min integration.
 	  
 	//     DATA FOR GAUSS INTEGRATION
-	double xg[6] = {0, 0.1488743390, 0.4333953941, 0.6794095683, 0.8650633667, 0.9739065285};
-	double ag[6] = {0, 0.2955242247, 0.2692667193, 0.2190863625, 0.1494513492, 0.0666713443};
-	NGAUSS = 6;
+	double xg[16] = {0, 0.0514718426, 0.153869914, 0.2546369262, 0.352704726, 0.4470337695, 0.5366241481, 0.620526183, 0.697850495, 0.7677774321, 0.829565762, 0.8825605358, 0.9262000474, 0.960021865, 0.9836681233, 0.9968934841};
+	double ag[16] = {0, 0.1028526529, 0.10176239, 0.09959342059, 0.096368737, 0.0921225222, 0.086899787, 0.0807558952, 0.0737559747, 0.0659742299, 0.05749315622, 0.0484026728, 0.038799193, 0.0287847079, 0.018466468, 0.0079681925};
+	NGAUSS = 16;
 	
 	//       Note: The photon energy passed to this function is now in the target frame. The rest of the calculations are done in the
 	//       CMS frame. The next lines boost the photon into the CM frame.
@@ -373,10 +373,10 @@ photonNucleusCrossSection::e_getcsgA(const double Egamma, double Q2,
 	int NGAUSS; 
   
 	//     DATA FOR GAUSS INTEGRATION
-	double xg[6] = {0, 0.1488743390, 0.4333953941, 0.6794095683, 0.8650633667, 0.9739065285};
-	double ag[6] = {0, 0.2955242247, 0.2692667193, 0.2190863625, 0.1494513492, 0.0666713443};
-	NGAUSS = 6;
-  
+	double xg[16] = {0, 0.0514718426, 0.153869914, 0.2546369262, 0.352704726, 0.4470337695, 0.5366241481, 0.620526183, 0.697850495, 0.7677774321, 0.829565762, 0.8825605358, 0.9262000474, 0.960021865, 0.9836681233, 0.9968934841};
+	double ag[16] = {0, 0.1028526529, 0.10176239, 0.09959342059, 0.096368737, 0.0921225222, 0.086899787, 0.0807558952, 0.0737559747, 0.0659742299, 0.05749315622, 0.0484026728, 0.038799193, 0.0287847079, 0.018466468, 0.0079681925};
+	NGAUSS = 16;
+	
 	//       Find gamma-proton CM energy
 	Wgp = sqrt( 2.*(protonMass*Egamma)
 		    +protonMass*protonMass + Q2);
@@ -418,12 +418,12 @@ photonNucleusCrossSection::e_getcsgA(const double Egamma, double Q2,
                   if( beam==1 ){
  		     csgA = csgA + ag[k] * _bbs.electronBeam().formFactor(t) * _bbs.electronBeam().formFactor(t);
                   }else if(beam==2){
- 		     csgA = csgA + ag[k] * _bbs.targetBeam().formFactor(t) * _bbs.targetBeam().formFactor(t);	
-  		  }else{
+ 		     csgA = csgA + ag[k] * _bbs.targetBeam().formFactor(t) * _bbs.targetBeam().formFactor(t);
+        	}else{
 		     cout<<"Something went wrong here, beam= "<<beam<<endl; 
                   }
-               }
-
+				  }           
+			    
 	       t    = ax * (-xg[k]) + bx;
                if( A_1 <= 1 && A_2 != 1){ 
 			  csgA = csgA + ag[k] * _bbs.targetBeam().formFactor(t) * _bbs.targetBeam().formFactor(t);
@@ -433,11 +433,12 @@ photonNucleusCrossSection::e_getcsgA(const double Egamma, double Q2,
                   if( beam==1 ){
  			    csgA = csgA + ag[k] * _bbs.electronBeam().formFactor(t) * _bbs.electronBeam().formFactor(t);
                   }else if(beam==2){
- 			    csgA = csgA + ag[k] * _bbs.targetBeam().formFactor(t) * _bbs.targetBeam().formFactor(t);	
+ 			    csgA = csgA + ag[k] * _bbs.targetBeam().formFactor(t) * _bbs.targetBeam().formFactor(t);
   		  }else{
 			    cout<<"Something went wrong here, beam= "<<beam<<endl; 
                   }
-	       }
+				 }
+				  
 	   }
 	   csgA = 0.5 * (tmax - tmin) * csgA;
 	   csgA = Av * csgA;
@@ -926,7 +927,6 @@ photonNucleusCrossSection::sigmagp(const double Wgp)
 		{ 
 		case RHO:
 		case RHOZEUS:
-		case FOURPRONG:
 			WgpMax = 1.8;
 			WgpMin = 1.60; //this is the cutoff threshold for rho production. But rho has large width so it's lower
 			if(Wgp<WgpMax) thresholdScaling=(Wgp-WgpMin)/(WgpMax-WgpMin);
@@ -936,6 +936,16 @@ photonNucleusCrossSection::sigmagp(const double Wgp)
 			if(_backwardsProduction)sigmagp_r=thresholdScaling*1.E-4*0.14*pow(Wgp,-2.7);
 			if(_backwardsProduction)sigmagp_r=thresholdScaling*1.E-4*0.206*pow(((Wgp*Wgp-protonMass*protonMass)/(2.0*protonMass)),-2.7);
 			break;
+	        case FOURPRONG:
+			WgpMax = 3.6;
+			WgpMin = 3.2;
+			if(Wgp<WgpMax) thresholdScaling=(Wgp-WgpMin)/(WgpMax-WgpMin);
+			sigmagp_r=thresholdScaling*1.E-4*(0.16*exp(0.41*log(Wgp))+23.0*exp(-1.4*log(Wgp))); //arXiv:2005.13624
+			//This is based on the omega cross section:
+			//https://arxiv.org/pdf/2107.06748.pdf
+			if(_backwardsProduction)sigmagp_r=thresholdScaling*1.E-4*0.14*pow(Wgp,-2.7);
+			if(_backwardsProduction)sigmagp_r=thresholdScaling*1.E-4*0.206*pow(((Wgp*Wgp-protonMass*protonMass)/(2.0*protonMass)),-2.7);
+			break;
 		case OMEGA:
 		case OMEGA_pi0gamma:
 			WgpMax = 1.8;
@@ -991,7 +1001,7 @@ photonNucleusCrossSection::sigmagp(const double Wgp)
 			sigmagp_r*=1.E-10*2.1*exp(0.74*log(Wgp)); 
 			break;
 		default: cout<< "!!!  ERROR: Unidentified Vector Meson: "<< _particleType <<endl;
-		}                                                                  
+		}                                                              
 	return sigmagp_r;
 }