Tilde/Tilde_endpoint03-stats.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "configured-studio",
   "metadata": {},
   "source": [
    "# Exploring Observation Statistics From Tilde"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "charged-mechanism",
   "metadata": {},
   "source": [
    "## &nbsp;Table of contents\n",
    "### 1. Building a Basic Tilde Query and Extracting the Key Statistics\n",
    "### 2. Building a Query using startdate and enddate parameters\n",
    "### 3. Building a Query using parameters from the last 7 days\n",
    "### 4. Building a Query using Percentiles\n",
    "### 5. Comparing query results from several stations"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "defensive-promotion",
   "metadata": {},
   "source": [
    "## &nbsp;1. Building a Basic Tilde Query and Extracting the Key Statistics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "republican-mailing",
   "metadata": {},
   "source": [
    "###### Import required modules and set the source URL"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "fitted-honor",
   "metadata": {},
   "outputs": [],
   "source": [
    "import requests\n",
    "import json\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from tabulate import tabulate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "english-clearing",
   "metadata": {},
   "outputs": [],
   "source": [
    "source = 'https://tilde.geonet.org.nz/v4'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "humanitarian-collapse",
   "metadata": {},
   "source": [
    "### A basic query with the minimum required parameters\n",
    "\n",
    "The query is `https://tilde.geonet.org.nz/v4/stats/` with the source URL being stated above `https://tilde.geonet.org.nz`.\n",
    "\n",
    "The minimum required parameters are:\n",
    "- domain = `envirosensor`\n",
    "- key = `NA002/fumarole-temperature/02/snapshot/nil`\n",
    "\n",
    "This specifies a station `NA002`, a data name `fumarole-temperature`, a sensor code `02`, a data method `snapshot`, and no aspect information (specified by `nil`).\n",
    "\n",
    "Optional parameters are:\n",
    "- startdate = `latest` or `2022-03-01`\n",
    "- enddate = `7d` or `2022-03-15`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "weekly-petersburg",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = source+'/stats/envirosensor/NA002/fumarole-temperature/02/snapshot/nil'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "numerical-concern",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Response [200]>\n"
     ]
    }
   ],
   "source": [
    "r = requests.get(url)\n",
    "print (r)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "equal-institute",
   "metadata": {},
   "source": [
    "###### Store the response as a nested dictionary and see the output"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "noticed-ratio",
   "metadata": {},
   "source": [
    "A nested dictionary in python is a dictionary within a dictionary. It's a collection of dictionaries into one single directory. In TILDE, each domain has different entries which sit within that specific domain name, e.g. for example, the envirosensor entries sit within the envirosensor domain. By creating a nested dictionary we can then specify the domain and then split it by domain name. `summary` is our nested dictionary and when printed we can see that there are a lot of key:value pairs. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "talented-cable",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary = r.json()\n",
    "type(summary)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "retained-clock",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'series': {'domain': 'envirosensor',\n",
       "  'station': 'NA002',\n",
       "  'name': 'fumarole-temperature',\n",
       "  'sensorCode': '02',\n",
       "  'method': 'snapshot',\n",
       "  'aspect': 'nil'},\n",
       " 'latitude': -39.1564,\n",
       " 'longitude': 175.6347,\n",
       " 'elevationM': 2280,\n",
       " 'datum': 'WGS84',\n",
       " 'relativeHeightM': 0,\n",
       " 'valueUnit': 'degC',\n",
       " 'errorUnit': 'degC',\n",
       " 'first': {'val': 84, 'err': 0, 'qc': '', 'ts': '2021-05-06T04:00:00Z'},\n",
       " 'last': {'val': 76.24502, 'err': 0, 'qc': '', 'ts': '2025-01-09T21:50:00Z'},\n",
       " 'maximum': {'val': 85.400002,\n",
       "  'err': 0,\n",
       "  'qc': '',\n",
       "  'ts': '2021-05-10T12:00:00Z'},\n",
       " 'minimum': {'val': 0.400351,\n",
       "  'err': 0,\n",
       "  'qc': '',\n",
       "  'ts': '2024-05-30T23:00:00Z'},\n",
       " 'count': 181419,\n",
       " 'mean': 77.0286,\n",
       " 'median': 78.86,\n",
       " 'populationStdDev': 9.3114,\n",
       " 'percentiles': None}"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "unable-claim",
   "metadata": {},
   "source": [
    "##### We can then specify the series\n",
    "<br>\n",
    "Extract the key statistics and display them in a more readable format. To do this, we select the 'series' key of the dictionary and assign it to a new dictionary called `my_series`. Printing the output of `my_series`, can also be compared to `summary` above to see what happens when we select this key."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "desperate-factory",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': 'envirosensor',\n",
       " 'station': 'NA002',\n",
       " 'name': 'fumarole-temperature',\n",
       " 'sensorCode': '02',\n",
       " 'method': 'snapshot',\n",
       " 'aspect': 'nil'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_series = summary['series']\n",
    "my_series"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "pharmaceutical-decade",
   "metadata": {},
   "source": [
    "We can also add some other key statistics from our dictionary `summary`, by using the same method that we did for 'series'. To specify the statistics required, we need to make sure we are selected the correct values. For example, within `summary`, the dictionary `first` has multiple keys ('value', 'err', 'qc', and 'ts'). To specify the first observed time we would need `summary['first']['ts']`. For other keys within `summary` that don't have sub-keys (e.g. count, mean, median), we can just use `summary['count']`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "historical-prophet",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_series['first obs'] = summary['first']['ts']\n",
    "my_series['last obs'] = summary['last']['ts']\n",
    "my_series['maximum obs'] = summary['maximum']['val']\n",
    "my_series['minimum obs'] = summary['minimum']['val']\n",
    "my_series['number obs'] = summary['count']\n",
    "my_series['mean obs'] = summary['mean']\n",
    "my_series['median obs'] = summary['median']\n",
    "my_series['population stdev'] = summary['populationStdDev']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "local-clerk",
   "metadata": {},
   "source": [
    "We can now print `my_series` in a nice, easily readable table by using tabulate (https://pypi.org/project/tabulate/), which allows to print items to a table using (my_series.item()). The type of table format has many different options, such as 'simple', 'grid', 'fancy_grid', and 'presto' available. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "passing-monaco",
   "metadata": {},
   "source": [
    "If `tabulate` is not installed (if using an older version of the `environment.yml` file), either run `conda env update -f environment.yml` after pulling the most recent environment.yml file from the data-tutorials github repository or run `conda install -c conda-forge tabulate` in a terminal within your conda environment."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "liberal-texas",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Parameter        | Value                |\n",
      "|------------------|----------------------|\n",
      "| domain           | envirosensor         |\n",
      "| station          | NA002                |\n",
      "| name             | fumarole-temperature |\n",
      "| sensorCode       | 02                   |\n",
      "| method           | snapshot             |\n",
      "| aspect           | nil                  |\n",
      "| first obs        | 2021-05-06T04:00:00Z |\n",
      "| last obs         | 2025-01-09T21:50:00Z |\n",
      "| maximum obs      | 85.400002            |\n",
      "| minimum obs      | 0.400351             |\n",
      "| number obs       | 181419               |\n",
      "| mean obs         | 77.0286              |\n",
      "| median obs       | 78.86                |\n",
      "| population stdev | 9.3114               |\n"
     ]
    }
   ],
   "source": [
    "headers = ['Parameter', 'Value']\n",
    "data = [(k,v) for k,v in my_series.items()]\n",
    "print (tabulate(data, headers=headers, tablefmt='github'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "middle-allah",
   "metadata": {},
   "source": [
    "## &nbsp;2. Building a Query using startdate and enddate parameters\n",
    "\n",
    "The minimum required parameters are:\n",
    "- domain = `dart`\n",
    "- key = `NZJ/water-height-detided/40/15m/nil`\n",
    "\n",
    "This specifies a station `NZJ`, a data name `water-height-detided`, a sensor code `40`, a data method `15m`, and no aspect information (specified by `nil`).\n",
    "\n",
    "We will now be adding a start date and end date of:\n",
    "- startdate = `2022-03-01`\n",
    "- enddate = `2022-03-10`\n",
    "\n",
    "For this, we will begin by changing our URL and then generating a nested dictionary called `summary`, as shown previously. Printing the summary will show a very similar summary to above, but this time the first and last datapoints will be what we have specified in the URL. Feel free to test this by uncommenting `summary` to see what the output is. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "valued-nurse",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'series': {'domain': 'dart',\n",
       "  'station': 'NZJ',\n",
       "  'name': 'water-height-detided',\n",
       "  'sensorCode': '40',\n",
       "  'method': '15m',\n",
       "  'aspect': 'nil'},\n",
       " 'latitude': -26.6672,\n",
       " 'longitude': 163.9549,\n",
       " 'elevationM': 0,\n",
       " 'datum': 'WGS84',\n",
       " 'relativeHeightM': -1912,\n",
       " 'valueUnit': 'm',\n",
       " 'errorUnit': 'm',\n",
       " 'first': {'val': -0.0775, 'err': 0, 'qc': '', 'ts': '2022-03-01T00:00:00Z'},\n",
       " 'last': {'val': -0.0607, 'err': 0, 'qc': '', 'ts': '2022-03-10T23:45:00Z'},\n",
       " 'maximum': {'val': 0.0273, 'err': 0, 'qc': '', 'ts': '2022-03-08T00:00:00Z'},\n",
       " 'minimum': {'val': -0.1903, 'err': 0, 'qc': '', 'ts': '2022-03-10T19:15:00Z'},\n",
       " 'count': 960,\n",
       " 'mean': -0.0861,\n",
       " 'median': -0.0896,\n",
       " 'populationStdDev': 0.0494,\n",
       " 'percentiles': None}"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = source+'/stats/dart/NZJ/water-height-detided/40/15m/nil/2022-03-01/2022-03-10'\n",
    "\n",
    "r = requests.get(url)\n",
    "summary = r.json()\n",
    "summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "entire-police",
   "metadata": {},
   "source": [
    "We will now use a similar method as we did before and select the `series` component of the dictionary as well as adding some other key statistics as we did above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "color-parade",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'domain': 'dart',\n",
       " 'station': 'NZJ',\n",
       " 'name': 'water-height-detided',\n",
       " 'sensorCode': '40',\n",
       " 'method': '15m',\n",
       " 'aspect': 'nil'}"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_series2 = summary['series']\n",
    "my_series2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "returning-discussion",
   "metadata": {},
   "outputs": [],
   "source": [
    "my_series2['first obs'] = summary['first']['ts']\n",
    "my_series2['last obs'] = summary['last']['ts']\n",
    "my_series2['maximum obs'] = summary['maximum']['val']\n",
    "my_series2['minimum obs'] = summary['minimum']['val']\n",
    "my_series2['number obs'] = summary['count']\n",
    "my_series2['mean obs'] = summary['mean']\n",
    "my_series2['median obs'] = summary['median']\n",
    "my_series2['population stdev'] = summary['populationStdDev']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "raised-closure",
   "metadata": {},
   "source": [
    "As before we will now use tabulate and print this into a table. In this table we can see that the `first obs` and the `last obs` are using the start and end dates that we specified in the URL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "manufactured-music",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Parameter        | Value                |\n",
      "|------------------|----------------------|\n",
      "| domain           | dart                 |\n",
      "| station          | NZJ                  |\n",
      "| name             | water-height-detided |\n",
      "| sensorCode       | 40                   |\n",
      "| method           | 15m                  |\n",
      "| aspect           | nil                  |\n",
      "| first obs        | 2022-03-01T00:00:00Z |\n",
      "| last obs         | 2022-03-10T23:45:00Z |\n",
      "| maximum obs      | 0.0273               |\n",
      "| minimum obs      | -0.1903              |\n",
      "| number obs       | 960                  |\n",
      "| mean obs         | -0.0861              |\n",
      "| median obs       | -0.0896              |\n",
      "| population stdev | 0.0494               |\n"
     ]
    }
   ],
   "source": [
    "headers = ['Parameter', 'Value']\n",
    "data = [(k,v) for k,v in my_series2.items()]\n",
    "print (tabulate(data, headers=headers, tablefmt='github'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "external-advocate",
   "metadata": {},
   "source": [
    "## &nbsp;3. Building a Query using parameters from the last 7 days\n",
    "\n",
    "The minimum required parameters are:\n",
    "- domain = `coastal`\n",
    "- key = `WLGT/water-height/41/15s/nil`\n",
    "\n",
    "This specifies a station `WLGT`, a data name `water-height`, a sensor code `41`, a data method `15s`, and no aspect information (specified by `nil`).\n",
    "\n",
    "We will now be adding:\n",
    "- `latest`\n",
    "- period = `7d`\n",
    "\n",
    "The latest `period` can be 30d (latest 30 days), 7d, 2d, 1d, or 6h (latest 6 hours). Other periods will produce an error.\n",
    "\n",
    "When calculating the start of the query, the current time is taken into account.\n",
    "\n",
    "We will begin again by changing our URL and then generating a nested dictionary called `summary`, as shown previously. Printing the summary will show a very similar summary to above, but this time we will be seeing the first and last data points for the data period that has been selected, in this case the last 7 days from the current time. Feel free to test this by uncommenting `summary` to see what the output is.  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "prepared-discussion",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = source+'/stats/coastal/WLGT/water-height/41/15s/nil/latest/7d'\n",
    "\n",
    "r = requests.get(url)\n",
    "summary = r.json()\n",
    "#summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ancient-means",
   "metadata": {},
   "source": [
    "We will now use a similar method as we have done before and select the `series` component of the dictionary as well as adding some other key statistics. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "bottom-conclusion",
   "metadata": {},
   "outputs": [],
   "source": [
    "#selecting the series component of the `summary` dictionary\n",
    "my_series3 = summary['series']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "dried-finance",
   "metadata": {},
   "outputs": [],
   "source": [
    "#selecting key statistics\n",
    "my_series3['first obs'] = summary['first']['ts']\n",
    "my_series3['last obs'] = summary['last']['ts']\n",
    "my_series3['maximum obs'] = summary['maximum']['val']\n",
    "my_series3['minimum obs'] = summary['minimum']['val']\n",
    "my_series3['number obs'] = summary['count']\n",
    "my_series3['mean obs'] = summary['mean']\n",
    "my_series3['median obs'] = summary['median']\n",
    "my_series3['population stdev'] = summary['populationStdDev']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "familiar-breeding",
   "metadata": {},
   "source": [
    "As before we will now use tabulate and print this into a table. In this table we can see that the `first obs` and the `last obs` are using the data period that we specified in the URL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "frozen-violin",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "| Parameter        | Value                |\n",
      "|------------------|----------------------|\n",
      "| domain           | coastal              |\n",
      "| station          | WLGT                 |\n",
      "| name             | water-height         |\n",
      "| sensorCode       | 41                   |\n",
      "| method           | 15s                  |\n",
      "| aspect           | nil                  |\n",
      "| first obs        | 2025-01-02T22:11:00Z |\n",
      "| last obs         | 2025-01-09T22:10:00Z |\n",
      "| maximum obs      | 3.9756               |\n",
      "| minimum obs      | 2.6027               |\n",
      "| number obs       | 40317                |\n",
      "| mean obs         | 3.3146               |\n",
      "| median obs       | 3.3169               |\n",
      "| population stdev | 0.3839               |\n"
     ]
    }
   ],
   "source": [
    "headers = ['Parameter', 'Value']\n",
    "data = [(k,v) for k,v in my_series3.items()]\n",
    "print (tabulate(data, headers=headers, tablefmt='github'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "complimentary-prerequisite",
   "metadata": {},
   "source": [
    "## &nbsp;4. Building a Query using Percentiles\n",
    "\n",
    "The minimum required parameters are:\n",
    "- domain = `envirosensor`\n",
    "- key = `OT001/lake-temperature/01/snapshot/nil/latest/7d`\n",
    "\n",
    "This specifies a station `FOXVF`, a data name `air-humidity`, a sensor code `03`, a data method `snapshot`, and aspect `nil`.\n",
    "\n",
    "Our query is for the last 7 days.\n",
    "\n",
    "We will now be adding:\n",
    "- `?percentiles=10,75`, 10th and 75th percentiles\n",
    "\n",
    "We will begin again by changing our URL and then generating a nested dictionary called `summary`, as shown previously. Printing the summary will show a very similar summary to above, but this time we will be seeing the 10th and 75th percentiles. Feel free to test this by uncommenting `summary` to see what the output is. In our previous `summary` dictionaries we had `percentile=None`, now we are seeing a specific result. To change to different percentiles, e.g. 25 and 70, just change the URL `?percentiles=25,70`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "complete-induction",
   "metadata": {},
   "outputs": [],
   "source": [
    "url = source+'/stats/envirosensor/OT001/lake-temperature/01/snapshot/nil/latest/7d?percentiles=10,75'\n",
    "\n",
    "r = requests.get(url)\n",
    "summary = r.json()\n",
    "#summary"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "earlier-stuff",
   "metadata": {},
   "source": [
    "#### Box-and-whisker plot.\n",
    "If we specified a low and a high percentile, we can summarise the distribution of observations, with a box-and-whisker style plot (https://en.wikipedia.org/wiki/Box_plot). We begin by specifying the median, minimum and maximum values which are avialable directly from the summary dictionary. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "accredited-little",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52.55202 58.277 70.41575\n"
     ]
    }
   ],
   "source": [
    "medv = summary['median']\n",
    "minv = summary['minimum']['val']\n",
    "maxv = summary['maximum']['val']\n",
    "print (minv,medv,maxv)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "altered-speech",
   "metadata": {},
   "source": [
    "From the `percentiles` values in the summary dictionary we can generate more values for the box and whisker plot. Where `lopcp` and `hipcp` are the low and high percentage values that we set in the URL (in this example, 10 and 75), `lopcv` and `hipcv` are the low and high percentage values, `first` and `last` are the first and last timestamp values from the summary dictionary. We can also print all of these variables and see that they match up with the `summary` information above. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "conservative-concentration",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{'percentile': 10, 'value': 54.071}, {'percentile': 75, 'value': 63.713}]\n",
      "10 75 54.071 63.713 2025-01-02T22:20:00Z 2025-01-09T21:50:00Z\n"
     ]
    }
   ],
   "source": [
    "pcs = summary['percentiles']\n",
    "\n",
    "lopcp = pcs[0].get('percentile')\n",
    "hipcp = pcs[1].get('percentile')\n",
    "\n",
    "lopcv = pcs[0].get('value')\n",
    "hipcv = pcs[1].get('value')\n",
    "\n",
    "first = summary['first']['ts']\n",
    "last = summary['last']['ts']\n",
    "\n",
    "print (pcs)\n",
    "print (lopcp,hipcp,lopcv,hipcv,first,last)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "joint-satin",
   "metadata": {},
   "source": [
    "We will now plot this using a box-and-whisker style by using our above parameters. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "chronic-hormone",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x7a99383050a0>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots()\n",
    "#draw box from lowpcv to hipcv\n",
    "ax.bar(0, hipcv-lopcv, bottom=lopcv, color='#41b0f0', label='precentiles '+str(lopcp)+'-'+str(hipcp))\n",
    "# vertical line from minv to maxv\n",
    "ax.vlines(0, minv, maxv, color='black', label='min-max')\n",
    "#horizontal line at medv\n",
    "ax.hlines(medv, -0.4, 0.4, linestyles='dashed', colors='red', label='median')\n",
    "\n",
    "#make more like a box-and-whisker\n",
    "ax.set_xlim(-1,1)\n",
    "ax.ticklabel_format(useOffset=False, style='plain')\n",
    "plt.xticks([])\n",
    "\n",
    "plt.legend(loc='best')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "crucial-airplane",
   "metadata": {},
   "source": [
    "## &nbsp;5. Comparing query results from several stations\n",
    "\n",
    "We now make a query for several stations and extract the relevant data from each query, then use this data to demonstrate how to calculate the temperature range for several sites over the time period queried. \n",
    "\n",
    "We can create a list of stations using a data summary query, and then loop through that list, making an API call for each, and accumulating the results. However, for the envirosensor data domain, this is not straightforward as stations do not record the same data series, in contrast to the dart data domain, for example. We create a list of stations by query to show how this is done, but will manually set the station list \n",
    "\n",
    "Our query is for the time period from `2022-03-01` to `2022-03-10`.\n",
    "\n",
    "We will query air-temperature as this is more consistent between sites than fumarole-temperature, which varies substantially from site to site. The air-temperature typically has a sensor code of `01`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fatty-jersey",
   "metadata": {},
   "outputs": [],
   "source": [
    "#make a query to get a list of all possible stations to query\n",
    "url = 'https://tilde.geonet.org.nz/v4/dataSummary/envirosensor'\n",
    "r = requests.get(url)\n",
    "summary = r.json()\n",
    "\n",
    "stations = summary['domain']['envirosensor']['stations']\n",
    "stacodes = list(stations.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "e46b16d0-6232-48ee-ae4a-830384696c37",
   "metadata": {},
   "outputs": [],
   "source": [
    "#manually set stations to look at, some of those measuring air-temperature\n",
    "stacodes = ['NA002', 'TO003', 'TO006']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "proper-source",
   "metadata": {},
   "source": [
    "The next sub-codes creates the station list with corresponding temperature range. These are the inputs used in the subsequent plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "rough-matrix",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<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>range</th>\n",
       "      <th>min</th>\n",
       "      <th>max</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>station</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>NA002</th>\n",
       "      <td>20.429</td>\n",
       "      <td>5.031</td>\n",
       "      <td>25.46</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TO003</th>\n",
       "      <td>12.850</td>\n",
       "      <td>8.660</td>\n",
       "      <td>21.51</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>TO006</th>\n",
       "      <td>10.080</td>\n",
       "      <td>10.620</td>\n",
       "      <td>20.70</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          range     min    max\n",
       "station                       \n",
       "NA002    20.429   5.031  25.46\n",
       "TO003    12.850   8.660  21.51\n",
       "TO006    10.080  10.620  20.70"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#make a dataframe for later use\n",
    "df = pd.DataFrame()\n",
    "\n",
    "#dates for query\n",
    "d1 = '2022-03-01'\n",
    "d2 = '2022-03-10'\n",
    "\n",
    "for code in stacodes:\n",
    "    url = source+'/stats/envirosensor/'+code+'/air-temperature/01/snapshot/nil/'+d1+'/'+d2\n",
    "    r = requests.get(url)\n",
    "    summary = r.json()\n",
    "    \n",
    "    #if maximum and minimum have values, calculate range and append to dataframe\n",
    "    if ((summary['maximum'])and(summary['minimum'])):\n",
    "        value_range = summary['maximum']['val'] - summary['minimum']['val']\n",
    "        #make a dictionary of the extracted data\n",
    "        d = {'range':value_range, 'station':code, 'min':summary['minimum']['val'], 'max':summary['maximum']['val']}\n",
    "        #append this to the dataframe\n",
    "        df = pd.concat([df,pd.DataFrame([d])],ignore_index=True)\n",
    "\n",
    "#make station the dataframe index\n",
    "df.set_index('station', inplace=True)\n",
    "\n",
    "df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "sharing-geneva",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, '2022-03-01 - 2022-03-10')"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABNoAAAHyCAYAAAA9TKO2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB3EklEQVR4nO3dd3gU1f/28XsTkk0hCQRIA6QGEAgQelGKdKVJU5QmioUiRaSICCiCYENBsCGgIuhXQFBQinQEpAUBlaJAaBGkJBAgkOQ8f/BkfyzJJlnYkETer+vay+w5Z2Y+M7tZNzdnZizGGCMAAAAAAAAAt8UtuwsAAAAAAAAA/gsI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoA4D+sZ8+eslgsmjVrVnaXAgCAS40ZM0YWi0VjxozJ7lIcmjVrliwWi3r27JndpQAA7hCCNgDIZSIiImSxWOTt7a24uLg7uu3Dhw/LYrE4/eAPDNc6f/68xowZo8mTJ2d3KS5TvHjxVO8bLy8vlShRQl27dtXWrVuzu8T/jDFjxtxyMHHjZ8Dhw4cztcztvLYp/1hw48PHx0ehoaGqXbu2+vXrp59//lnGmEzVcvr0ab322muqV6+egoOD5enpqfz586tWrVoaMWKE9u/fn2qZtD7TfH19Va5cOfXv31/R0dGZ2nZ6+3Tzo127dk6tE3dGYmKiPvroIzVq1EgFChSQh4eHgoKCFBERoW7dumnGjBk6d+5cptb1X/wcBwBclye7CwAAZF5UVJT27NkjSbpy5Yq+/fZb9erVy+H40NBQlS1bVgEBAS7ZvpeXl+rVq5eq/dSpUzpw4ICsVquqV6+eqr9MmTIu2T6uO3/+vMaOHatixYpp4MCB2V2OS4WHhysoKEiSFBsbq4MHD2rOnDmaN2+eZs6cqW7dumVzhbnf2LFjJemOzwK6ndc2KChI4eHhkq6HHefPn9eOHTu0ZcsWffDBB6pcubK++OILRUREOFzHrFmz1L9/f128eFHS9QCwWLFiio2N1Y4dO/Trr7/qzTff1Ouvv65hw4alWr5ixYq2z9JTp07p4MGD2rdvn7744gutWLFCNWrUcOp43LhPNytfvrxT60LWi4uLU4sWLbRp0yZJUsGCBRUREaHk5GQdPHhQe/bs0Zdffqng4GC1atXKtlxAQIDKli2r0NBQu/X9lz/HAeCuZwAAucbgwYONJJMvXz4jyTRs2DC7SzLGGDNz5kwjyRQrViy7S7krHDp06D93vIsVK2YkmZkzZ9q1nz171nTs2NFIMn5+fubs2bPZU+B/iCRzq18BU957ksyhQ4cytcztvLY9evQwkkyPHj1S9V26dMnMnz/fREREGEnGx8fH7NixI80aPvjgAyPJWCwW069fP3P06FG7/nPnzpnp06ebwoULm7Zt29r1pezv6tWr7doPHjxoqlSpYiSZe++91yQlJWV4LDLaJzhn9OjRRpIZPXp0lm/r6aefNpJMwYIFzY8//mjXl5iYaNauXWueeOIJs2LFikyt77/4OQ4AuI5TRwEgl0hKStLcuXMlSVOnTpW7u7vWrl3r9GlLQG6SP39+zZgxQ76+vrpw4YKWL1+e3SXBRW73tfX29lb79u21ZcsWNW7cWJcuXVLnzp2VlJRkN27v3r0aNGiQJOmDDz7QlClTVKRIEbsx+fLl07PPPqu9e/eqZcuWmdp+qVKl9Nlnn0mS/vjjD+3atcup+pF7JCYmas6cOZKkyZMnq0WLFnb97u7uql+/vj777DM1adIkO0oEAOQgBG0AkEusXLlSJ0+eVEhIiB599FE98MADMsbYvvynxdHNEG68gPTp06fVr18/FS9eXB4eHllyPbVLly5p4sSJql69uvz9/eXj46MqVarozTffVEJCQqrxN9Z35swZ9enTR0WKFJG3t7cqV66sefPm2cYeOXJETzzxhMLCwuTt7a1q1appyZIladaRcq2ow4cPa9myZWrYsKECAgLk7++vpk2bav369enux7Jly9SmTRsFBwfLarWqSJEieuKJJ/TXX3+lGptyLavixYtLkj755BPVqFFDfn5+slgstnF///23Jk6cqIYNG6po0aKyWq0qVKiQWrRokeZ+9OzZUyVKlLDt+83XdrpxXHo3wnB0EXFn3hvOHI/b4e/vbzv9OK3rgq1YsUL9+vVT5cqVFRgYKC8vL5UqVUrPPfecwyD6xuNz4sQJ9erVS6GhofLy8lKFChX0wQcfOKzn6tWrGj9+vMqWLSsvLy8VLlxYzz77rE6fPp3hxdn//PNP9erVS8WLF5fValWBAgX00EMPadWqVU4fl5iYGE2ZMkXNmzdX8eLF5eXlpfz586tBgwb64osvUo1PqS3Fze+dzF5zzZUyem0zw9vbW19++aWsVqsOHjyo//3vf3b9EydO1NWrV9WsWTM999xz6a4rICBAzzzzTKa3HRkZKT8/P0nSgQMHnC8+AxldSH/NmjWyWCxq2LChw/akpCRNnDhR9957r7y9vVW8eHGNGTNGiYmJkqTLly9r1KhRKl26tO13Z9KkSWle9+78+fOaMWOG2rZtq9KlS8vb21sBAQGqVauW3n//fds6b3bj59P8+fNVv3595cuXL9X7bu/everWrZuKFCkiT09PBQcHq0OHDtq8ebPzB0/SsWPH9Pzzz6tMmTLy9vZWvnz51KhRI3377bdOrefUqVOKj4+XJFWpUsWpZdN6DTP7OZ7C2c+NM2fOaMiQISpXrpy8vLzk6+ur4sWLq0WLFpo2bZpT9QMAnEfQBgC5xOeffy5JeuSRR+Tu7q7HH39cktL8gzqzTp8+rerVq+vDDz9UQECAypcvL3d3d5fUm+L48eOqUaOGhg8frl27dik4OFjFixfX3r17NXToUDVp0kSXL19Oc9lz586pdu3amjFjhoKDg1WgQAH99ttv6tKliz7//HPt27dPNWvW1DfffKOwsDDlzZtXO3bsUNu2bbVy5UqHNc2bN08tW7bU7t27VaZMGXl6emrlypVq2LBhqj/SUwwcOFAtWrTQ999/L0mqUKGCLly4oFmzZqlq1ar65ZdfHG7vueee09NPP61//vlH5cqVU758+Wx948eP1/Dhw7V9+3b5+PioUqVK8vDw0LJly9SqVStNnDjRbl1lypSxXQfParWqXr16dg9Xyei9cTvH41ZcunRJkuTj45Oqr2XLlpo2bZpiYmJUrFgxhYeH659//tGHH36oqlWr6vfff3e43iNHjqhatWqaO3euwsLCVKBAAf3+++/q16+fXn/99VTjExMT1aZNG40cOVL79+9X8eLFFRQUpBkzZqhmzZo6e/asw2198803qly5smbOnKmzZ8+qfPny8vT01NKlS9WkSRNNmTLFqWPy6aef6vnnn9f69euVJ08eRUREyN/fX+vWrVP37t1ThUr33HOP3Xvk5veOl5eXU9t3lfRe28wKCQmx3UDgxoA6MTFRCxYskCT17dv31otMR1qBVE7yyCOPaPjw4bJYLCpWrJiio6M1duxYPf3007py5YoaNWqkCRMmyNfXV6Ghofr77781bNiwNMPiH374QU899ZR++uknJSYmKiIiQgULFtS2bds0YMAAtWvXTsnJyQ5rmThxojp27Kj9+/erTJkyKlSokK1v8eLFqlatmr788kvFx8ercuXKMsZowYIFqlevnj755BOn9nvt2rWqWLGipkyZomPHjik8PFz+/v5as2aNOnXqpCFDhmR6XTf+A8mvv/7qVB1pceZz3NnPjdjYWNWqVUtvv/22Dh06pFKlSqlcuXK6fPmyli9frpdeeum26wcAZCB7z1wFAGTGhQsXjI+Pj5Fkfv31V2OMMXFxccbb29tIMtu2bUtzuZRrAd18baSU69q4u7ubOnXq2F2v6PLly07X5+gabUlJSaZu3bpGknn00UdNTEyMre/o0aPm/vvvN5LMkCFD0qzPw8PDNGrUyPzzzz+2vjfeeMNIMqGhoaZmzZrm0UcfNXFxcbbtPfPMM0aSqVmzZqo6U64VlSdPHjN48GBz9epVY4wx165dM0OHDjWSjL+/vzlx4oTdch9++KGRZEqUKGF3nabExEQzbtw4I8kUKVLE7tilXH/H3d3d+Pr6mkWLFtn6Ll26ZPt56dKlZvPmzSY5Odlum+vWrTOhoaHG3d3dHDx40K4vM9f2cfTap3B0baPMvDdu5XhkxNF1vIwxZv/+/SZPnjxGklm3bl2q/o8++sgcP37cru3SpUvm9ddfd3gtw5Tj4+HhYTp27GjOnTtn65s2bZqRZLy8vOzajTHmzTffNJJMYGCg2bhxo609OjraREZGGg8PjzSP665du4zVajVeXl7m448/true1+LFi42/v79xd3c3UVFR6Rwle+vXrzerVq0yiYmJqbZ17733GklmzZo1qZZTDrlGmzEZv7bOXM9sypQpRpIpW7asrW3r1q22a7Pd/FpmVsr+3nyNNmOM2bFjh61/+/btmVqfM/uU8tnqaOzq1auNJNOgQYM02z08PEyRIkXMzp07bX1r1qwxnp6exmKxmDZt2piIiAjz119/2frnzJljJBmr1Zrqunm7du0yP/zwg7ly5Ypd+19//WXq169vJJlZs2alqjPlGHl6epqPP/7Y9nl37do1c+3aNXP8+HHj7+9vJJkBAwaYhIQEY8z1z/SU32MPDw+za9cuu/U6+hw7fvy4CQwMNBaLxYwfP96u3o0bN5rChQsbSeb7779P87impV69erbrCU6YMMEcOHAgU8s5eg0z8zl+K58bb731lpFkmjVrZs6cOWO3viNHjph33303U3UDAG4dQRsA5AKzZs0ykkzp0qXt2jt16mT7wyQtGQVtVqs1VUBxKxwFbYsXLzaSTI0aNcy1a9dSLXfixAmTN29ekzdvXrvwKaU+b2/vVPUlJiaaIkWK2MK2+Ph4u/5z584ZLy8vIynVHxkpf/BXrlw5zf2oWrWqkWReeeUVW1tCQoIJCQkx7u7uDi+03qFDByPJfP7557a2GwOJt99+O83lMvLpp58aSeb111+3a78TQZuj98atHo+MpBXGxMbGmhUrVpjy5csbSaZevXqZXl+K++67z0gyx44ds2tPOT4hISHm4sWLqZZLeS8sWLDA1paUlGT7A/3LL79MtcyBAweMu7t7mse1ffv2RpJ577330qwzJSTq1auX0/uYlpUrVxpJpnfv3qn6ckLQltnX1plQ6rvvvjOSTP78+dNtc5ajoO3GmyGEh4c7fTOE9B4pbjdok2QWLlyYarkuXbrYAsi0fo9r166d6v2fkYMHDxpJpmnTpqn6Umrp379/msuOHDnSSDJVqlRJs//BBx80kky3bt3s2h19jqXcOGjQoEFpru/77783kswDDzyQiT27bteuXaZAgQJ2r1PBggVNy5YtzcSJE010dHSay91O0HYrnxsp/9h04z/uAADuLE4dBYBcIOX00Mcee8yuPeX00blz5zq8Nk56mjRporCwsNsv0IGUU7Z69uypPHnypOoPDQ1VjRo1dPHiRW3fvj1Vf8uWLVPV5+7uroiICElSly5dUp1uli9fPtu1bw4dOpRmXX369Em3fdmyZba2TZs2KSYmRlWrVlVkZGSay7Vp00bS9VOV0tK9e/c021OcPn1a7733nh577DE1adJE9913n+677z5NnjxZkrLlIuuO3huuOB7peeKJJ2zXKQoICFDTpk31559/6pFHHrGdppqWbdu2afjw4WrTpo0aNGhgO4b79++XJP32229pLtelSxf5+vqmaq9Ro4ak69fQS/H777/r+PHj8vX1VadOnVItU7p0ad1///2p2q9evaqlS5fK3d3d4bW2bvWYXbhwQZ988ol69OihZs2a6f7779d9992n4cOHS8qe944jt/raZlbK63jhwgVbW8rPab3Gzurfv7/tfVW2bFmVLVtWUVFRyps3r2bNmiU3N+e+VgcFBaU6ZdDVp4AHBgbaTqm9Ucp1xiIjI9P8PU5pu/H9nyIhIUFfffWVevfurebNm9vecz169JCU/nvO0Wdhyo0w+vXrl2b/gAED7MZlJOX/PU899VSa/S1atJCnp6d++eWXTP+/s1KlStqzZ48GDRqk4OBgSdK///6rH3/8UcOGDVOpUqU0cuTIdE+ddcatfm4ULVpUkrRw4cJb+l4AALh9qf/qAQDkKMePH9fq1aslpQ7aWrZsqfz58+vUqVNavny5HnzwQafWfe+997qszrTs3r1bkjR9+nR99dVXaY5JCUKOHz+eqq9UqVJpLpNyXZ/0+v/44w9dvHgxzX5H+53SnlKT9H/7cPjwYd13331pLnf+/HlJae9DwYIFVbBgwTSXk67/4di5c2fFxsY6HJPedb+yiqNjdLvHIyPh4eEKCgqSMUYxMTH6+++/5eHhoRo1aih//vypxhtj1K9fvwwv8O3oGDp6DwUFBUmS3Xso5WL35cqVk6enZ5rLVapUSWvWrLFr279/v65cuSJPT0+Hv6Pm/1/ny5ljtnPnTrVq1UonTpxwOCY73juOOPvaOivltfL397e1pdyoIOVC9rdjz549tp+tVqtKlCihJk2aaMiQIQ7fR+lp2bKlw5uVuMrtfIZKSvUZGh0drWbNmmnfvn0Ot5nee87R50rKZ2758uXT7K9QoYIk6Z9//lFcXJzda3yzixcv2m6w8PTTTzscJ0lXrlzRmTNnbMFZRkJCQvTOO+/onXfe0R9//KGtW7fq559/1uLFi3X+/HmNHz9eVqtVr7zySqbWl55b/dx44okn9Oabb2rWrFn68ccf1aJFC91///1q1KiRSpYsedt1AQAyRtAGADncnDlzlJycrKpVq6ps2bJ2fZ6enurUqZM+/vhjffHFF04Hba6Y5ZGelPDoxj9QHUnrhgiOLo6eclHqjPpT/gi5WUqIcrOUP7ZunBGTsg+nT5/W6dOn01wuRVr7kN4xPn/+vB599FHFxsaqe/fu6tOnj8qWLSt/f3+5ublp5cqVatq0qa5du5budrOCo7pv93hk5KWXXrKbvbFx40a1a9dOQ4YMUXBwsLp27Wo3/osvvtC0adPk6+urN998U02bNlXhwoXl7e0tSeratavmzJnj8Bg62s+U2Uk3vodSwpqU8CYtafWlHLOrV69q48aNDpeVrv/hnxlJSUnq3LmzTpw4oQcffFDDhg1ThQoVlC9fPrm7u+vgwYMKDw/PlveOI86+ts5KucPsjb/fhQsXlnT9d+38+fN2NyJx1urVq1Pd3TOnc/VnaM+ePbVv3z7VqlVLY8eOVZUqVRQYGCgPDw8lJiba/uuIo9+3lEAvo89m6frnc3pB243/aJHR75t0a59T0vXQ8N5771X37t115swZde7cWatWrdKkSZM0bNgwWa3WW1pvilv93AgLC9OmTZs0atQoLVmyRLNnz9bs2bMlSbVr19Y777yjOnXq3FZtAID0ceooAORwKaeN7tixw3ba1Y2Pjz/+WJK0aNEixcXFZWepqeTNm1eStGLFCpnr1wV1+HB0akxWcBQQnTp1SpJ9WJKyD48//niG+3DzTKaM/Pjjjzp37pzq1KmjWbNmqVatWsqXL58t5Dl69Ogt7N11GYWNtzrDJyuPR1puvNvggAEDUr3H58yZI0l6++239dxzz6l06dK2kE26vWN4s5SQwNFMSck+pE2RcswKFy6c4TFz9Hrd7Ndff9XBgwdVrFgxLViwQPXr11eBAgVsd4Z15X5nlYxeW2dt2LBBklSzZk1bW+XKleXj4yNjjNatW3db688OWfV7fCtOnDih1atXy8fHR0uXLlXz5s0VHBwsDw8PSbf3nkv5HUn5DL7ZP//8Y/s5vaD7xnVJ10OqjH7fihcvfst1pyhQoIDt7p/x8fHp3uk4s27nc+Pee+/Vt99+q/Pnz2v16tUaM2aMypUrp82bN6tZs2a2GX8AgKxB0AYAOdjOnTu1Z88eWSwWBQcHO3x4enrq8uXLmj9/fnaXbCflNKDMzGi7k/74449028uUKWNry8p9SPljp06dOrY/qG/k6FpHaY29WUoo5ChUPHjwYCartJcdr2m7du1Uu3ZtnT17Vu+8845dX8oxrFu3bqrlrl275vC1vhUp74s///zT4UyxlFNrbxQeHi4PDw+dPHnSZadypux3tWrV0pw5k5OuzZae9F5bZ5w8eVKLFy+WJD300EO2dg8PD7Vv316SMjy9OCfKqt/jW3HkyBFJ10+dDgwMTNV/O++5lN8tRwHV3r17JV2f2ZbebDZJCggIsF1fMmW5O+HG0zKvXr2a4fiMPsdd8blhtVrVsGFDjR49Wnv27FG9evV08eJFzZ0795bWBwDIHII2AMjBUmaz1a9fXzExMQ4fL7zwgt34nCLlD9yPPvoo06fE3QmO/uBOaW/WrJmt7f7771fBggW1a9cul8zQulHKzKsbZ2ukOHPmjGbMmJHucumd8pTyR9/WrVtT9R07dszuhg/OyMrjkZ6Ui/u///77djPK0juGM2fOzPD0Vmfce++9Kly4sC5evKhvv/02Vf/ff/+t9evXp2r38fFR8+bNlZycrPfff98ltaS339euXbPdSCO9ZW/1lDlXc/TaZtbly5fVrVs3JSQkqEyZMurQoYNd/7Bhw+Th4aFly5bpww8/THddsbGxtlnCOUHK73FUVFSqUzKTk5M1c+bMO1ZLyvvm1KlTac6wmzRp0i2vu3nz5pKkqVOnptmf8nuTMi4jKf/vSe/3wBmJiYk6d+5cumN++eUXSddPO8/MNfsy+j109eeGu7u77SYv6V3XEQBw+wjaACCHSkpKsv2rc7du3dIdm3JtozVr1uSoU8Yefvhh1a5dW3/++adat26davZFQkKClixZol69et3Ruvbs2aOhQ4faZiUlJibqpZde0vbt2+Xn56dnn33WNtbLy0uvvvqqJKlTp05auHBhqj8y9+zZo2HDhmXqekA3SrlD5TfffKOVK1fa2k+ePKkOHTo4vNZRoUKF5Ofnp1OnTjmcsdWyZUtJ0nfffaelS5farfvxxx+/5bvRZeXxSE+bNm1077336ty5c5o+fbqtPeWGDC+//LJdqPbTTz/pxRdflJeXl8tqcHNz08CBAyVJzz//vDZv3mzrO3bsmDp37uxwlsprr70mq9WqcePG6Y033kj1x/XJkyf13nvvZRgEpahdu7by5MmjjRs36vPPP7e1x8bG6vHHH08zgEuREt7cyl1hs4Kj1zYjly9f1sKFC1WrVi39/PPP8vX11TfffGM7fTZFxYoV9fbbb0u6fmfh559/XseOHbMbExsbq08//VQVK1a0+33JbpUrV1ZYWJhOnjyp0aNH237Xrly5ooEDB7rkFMXMqlChgvLnz69jx47p9ddft6tlwIAB2rlz5y2v+7nnnpO/v7+ioqI0aNAg24yw5ORkTZo0SUuWLJGHh4ftH5UyMmzYMAUGBmr27NkaPHiw7QYtKc6ePavPPvtM48aNy9T6Ll68qOLFi2vo0KHavXu33WeeMUY//PCD7a6rrVq1SvcGOCky8zl+K58bI0eO1IwZM1Lt8549e/TNN99IkqpWrZqp/QYA3BqCNgDIoVasWKGYmBh5eXmpY8eO6Y4tX768IiMjZYyxXbMqJ3Bzc9OCBQsUGRmplStXKjw8XOHh4apdu7YqVKggf39/tWrV6o7/Yfvaa6/prbfeUmhoqGrWrKnQ0FBNmDBBbm5u+vjjj22nHaV47rnnNHz4cP37779q3769ChYsqJo1a6patWoqUKCAIiIiNGnSpDSvz5WeatWqqWPHjrp27ZqaNm2q8PBwRUZG6p577tGOHTv0xhtvpLmcxWJRp06dJF3/g6lGjRpq2LCh3YXa7733Xj355JNKTEzUQw89pJIlS9rWferUKfXp08e5g3YHjkd6LBaLhgwZIkl65513bDMkhw4dqsDAQG3ZskXFihVTZGSkSpQooZYtW6patWqpZjfdroEDB6pZs2b6999/VadOHd17772qWrWqSpQooTNnzthC2pvDnipVqmju3LmyWq0aMWKEAgMDFRkZqVq1aumee+5RWFiYBg4cmOlrJ4WEhNhCvx49eqhYsWKqXr26QkND9d133+ndd991uOwjjzwi6XogULVqVdt7JyYmxqljUbVqVdtddW9+OHMXTkev7Y1+/PFH3XfffbrvvvtUp04dlStXTgEBAWrfvr12796tKlWqaPPmzapcuXKa2+jfv78+/fRT+fj4aMqUKSpatKhKlSqlWrVqqVy5cipUqJB69+6tmJgYh3fTzQ7u7u6aOHGiJGn8+PEKDg5WjRo1FBwcrJkzZ2rChAl3rBYPDw+99tprkqRRo0YpLCzMVsuUKVNs1yi7FWFhYfriiy/k6empyZMnKyQkxPbZPGzYMLm5uWnq1KmqVKlSptZXpEgRLV68WAULFtS7776roKAgVapUSbVr11apUqVUsGBBPfnkk5k+Bd5isSguLk5vvvmmKlWqpAIFCqhq1aqqUqWKChQooNatW+vYsWOqWLGiPvroo0yvM6PP8Vv53Ni7d6+eeuopFShQQOHh4apVq5bCw8MVERGhEydOqFGjRhn+4x0A4PYQtAFADpVyGmjr1q0VEBCQ4fiUWW057fTR0NBQbdq0SdOmTVP9+vV15swZ7dy5UxcuXFDNmjU1duxYrV69+o7W9Oijj+rHH39UhQoV9Oeff+rKlSt64IEHtHr1aj366KNpLjNhwgRt3LhRjz32mHx9fbVr1y4dPnxYRYoUUa9evbRkyRI1btzY6VrmzJmjUaNGqXjx4jpy5IhiYmLUsWNHbd261WFoIEnvvfeeBgwYoJCQEO3atUtr165NNUPpww8/1KuvvqpSpUrp+PHjOn36tJ555hlt2rTptu6+KGXd8UhP165dFRYWppiYGH322WeSpHvuuUebNm1S+/bt5enpqT///FNeXl4aO3asfvrpJ+XJ49obrOfJk0fff/+9xo0bp/DwcP3999+KiYlRjx49tGXLFtv10tK6YPvDDz+s33//XQMGDFDx4sW1b98+/f777/Lx8dHDDz+s2bNn206jzIxJkyZp8uTJKleunGJiYnTkyBE1adJE69evV4sWLRwuN3z4cI0ePVqlS5fW77//bnvvOHt697lz53TmzBmHD2ek9dre6NSpU9q4caM2btyoqKgonT9/XlWrVlXfvn21cuVK7dy5UxUrVkx3G08++aT++usvjRkzRnXq1FFcXJx27Nihf/75R5GRkRoxYoT27dtnC/1yiq5du+qbb75RtWrVdOHCBf39999q3LixtmzZomrVqt3RWvr27asvv/xSVapU0dmzZ3Xw4EFVr15dS5cu1VNPPXVb627Tpo22b9+uxx9/XF5eXoqKipIxRg8//LA2bNigp59+2qn11atXT7///rtGjhyp8uXL69ChQ/rtt9/k5uamFi1aaNq0aXrvvfcyta6AgADt379fkydP1kMPPaSgoCAdPHhQv//+uzw9PdW0aVNNnz5d27dvV0hISKZrzMznuLOfGy+//LKGDx+uGjVq6OLFi4qKitLly5fVoEEDff7551q+fLnLPxcBAPYsJrO3twIAIJdLCbMOHTrkkjvNATdr3bq1fvjhBy1cuFDt2rXL7nIAAABwhzGjDQAAwAWOHTumFStWyN3dXbVr187ucgAAAJANCNoAAACcMG7cOB04cMCubd++fWrbtq0SEhLUtm1bp04fAwAAwH8Hp44CAO4anDoKV0h5HxUsWFDFixdXbGysLXgrWbKk1q1bp8KFC2dzlQAAAMgOzGgDAABwwqhRo9S8eXNZrVbt2bNHx48fV4UKFTRy5Eht27aNkA0AAOAuxow2AAAAAAAAwAWY0QYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAgW61atUq9evVSuXLl5Ovrq8KFC6tt27bavn17muN37NihJk2aKG/evMqXL5/at2+vv//+227M/v37NWTIEFWrVk358uVTYGCg6tWrp2+//TbV+hYsWKAuXbqodOnS8vb2VvHixfX444/rwIEDTu1HZuqKj4/Xo48+qrJly8rPz0++vr6qUKGCxo0bp/j4+Exv6+LFixo4cKDCwsLk5eWlKlWqaN68eanGbdiwQU899ZSqVasmq9Uqi8Wiw4cPO7VfmeXscVy5cqXq1KkjHx8fFSxYUD179tSpU6fsxmzfvl19+/ZVRESE/Pz8FBwcrCZNmmjVqlWp1vfpp5+qXbt2Kl68uLy9vVW6dGk999xzOnnypFP7kZm6jh49qocfflglS5aUr6+vAgICFBkZqalTpyoxMTFT2zl27JgGDhyoBg0aKF++fLJYLJo1a9Zt1QUAALIfQRsAAMhW06dP1+HDhzVgwAAtXbpU7733nk6dOqXatWunClT+/PNPNWzYUFevXtU333yjzz77TPv379f999+v06dP28YtX75cS5YsUYcOHfS///1Pc+bMUXh4uDp16qRXX33Vbp0TJ07UpUuXNHLkSP30008aN26cdu7cqapVq2rv3r2Z2ofM1nXt2jUZYzR48GDNnz9fixYtUocOHfTqq6+qbdu2mT5m7du31+zZszV69Gj9+OOPqlGjhrp06aKvvvrKbtzPP/+slStX6p577lHdunUzvf5b4cxxXLt2rVq2bKng4GAtWrRI7733nlauXKnGjRsrISHBNm7u3Ln69ddf1atXLy1atEiffvqprFarGjdurM8//9xunaNHj1bevHk1fvx4/fTTTxo6dKh++OEHVatWTf/880+m9iGzdcXHx8vf31+jRo3S4sWLNW/ePN13333q37+/nn322Uxt6+DBg5ozZ448PT314IMPuqQuAACQAxgAAIBs9M8//6Rqu3DhggkODjaNGze2a+/UqZMpWLCgiY2NtbUdPnzYeHh4mKFDh9raTp8+bZKTk1Ot96GHHjI+Pj7mypUr6W7/+PHjxsPDwzz55JOZ2ofM1uXI0KFDjSTz119/ZTh2yZIlRpL56quv7NqbNm1qwsLCTGJioq0tKSnJ9vObb75pJJlDhw5lYo+c58xxrFGjhilfvry5du2arW3jxo1Gkpk2bVq660xMTDSVKlUypUqVynD7W7duNZLMa6+9lql9yGxdjnTu3NnkyZPH7v3lyI2vTUqdM2fOzJK6AADAncOMNgAAkK2CgoJSteXNm1fly5fX0aNHbW2JiYn64Ycf1KFDB/n7+9vaixUrpkaNGmnhwoW2toIFC8pisaRab82aNXXp0iWdPXs23e2HhYWpSJEidtt3xJm6HClUqJAkKU+ePBmOXbhwofLmzatOnTrZtT/xxBM6ceKEtmzZYmtzc7tzX/UyexyPHz+urVu3qlu3bnb7W7duXZUpU8bueKW1Tnd3d1WrVi3Va5PW2GrVqsnd3T1Tr6MzdTlSqFAhubm5yd3dPcOxmX1tXFEXAAC4cwjaAABAjhMbG6sdO3aoQoUKtra//vpLly9fVqVKlVKNr1Spkg4ePKgrV66ku97Vq1erUKFCaYYyN/r777915MgRu+07cit1GWOUmJiouLg4/fTTT3r77bfVpUsX3XPPPRlub8+ePbr33ntThXIp29+zZ0+G67hT0jqOKfU5Ol4Z1Z+YmKj169dn6rVZu3atkpKSMjX2VupKeR3PnTunr7/+WrNmzdILL7yQqcA0s273eAEAgDuLoA0AAOQ4ffv2VXx8vEaOHGlrO3PmjCQpMDAw1fjAwEAZY3Tu3DmH6/z000+1Zs0avfzyy+nOOEpMTNSTTz6pvHnzatCgQRnWeit1ff311/Lw8FBAQIBatmypli1bprrmWHrbc7StG+vJbo6OY0bHK6P6x4wZo4MHD2r06NHpjrtw4YL69OmjokWLqlevXhnWeyt1TZw4UR4eHgoMDFSXLl00cOBAjR8/PsNtOeN2jxcAALizXPfPbQAAAC4watQozZkzR1OmTFG1atVS9ad1SmhGfT/++KP69u2rjh07qn///g6XN8boySef1Pr16zV//nwVLVrU1pecnKzk5GS7bd0Y2DlTV/PmzbV161ZduHBBmzZt0sSJE3XmzBktXLhQbm5uMsYoKSnJbpkbZ0ndyjFwVkb7m570jmNGdaZX/6effqrXX39dL7zwQro3j7hy5Yrat2+vI0eOaNWqVcqbN6+tLykpScYY23M3Nze70zidqatnz55q0qSJzp49q1WrVunNN99UbGyspkyZIkkZvo7OuJXjBQAA7jxmtAEAgBxj7NixGjdunF5//XX169fPrq9AgQKS0p6xdfbsWVksFuXLly9V37Jly9S+fXs1bdpUc+bMcRhMGGP01FNP6csvv9SsWbNSBTm9evWSh4eH7dG4ceNbrit//vyqXr26GjVqpJdeekkff/yxFi9erEWLFkm6fsrjjdvy8PDQ4cOHbdtztC0p7ZlPt8LR/mYko+OY0fFyVP/MmTP1zDPP6Omnn9abb77pcPsJCQl6+OGHtWHDBi1evFi1atWy62/cuLHdfqXMdruVukJCQlS9enU1a9ZMb7zxhl599VVNnTpVO3fulCTNnj071evorFs9XgAAIHswow0AAOQIY8eO1ZgxYzRmzBi99NJLqfpLlSolb29v7d69O1Xf7t27Vbp0aXl5edm1L1u2TO3atVODBg00f/58eXp6prntlHBo5syZmjFjhrp27ZpqzJgxY+zCPz8/v1uu62Y1a9aUJO3fv1/S9Yv4b9261W5MWFiYJCkiIkJz585VYmKi3eyolO1XrFgx3W1llqP9TU9mjmNKfbt379aDDz5o17d79+406585c6aeeuop9ejRQx9++KHDsDQhIUHt2rXT6tWrtWjRojTDwY8++kgXLlywPS9YsOAt13WzG1/HyMhItW7dOtXr6CxX1AUAAO6gbLnXKQAAwA1effVVI8m8/PLL6Y7r3LmzCQoKMnFxcba2I0eOGE9PTzNs2DC7scuWLTNeXl6mSZMm5vLlyw7XmZycbJ588kljsVjMxx9/fEv1O1NXWmbMmGEkmW+//TbDsUuXLjWSzLx58+zaW7RoYcLCwkxiYmKay7355ptGkjl06FCG27gVzhzHmjVrmooVK9rVumnTJiPJTJ8+3W7szJkzjZubm+nevbtJSkpyuM4rV66Yli1bGk9PT/PDDz/c0j44U1daRo0aZSSZbdu2ObXdrVu3Gklm5syZWVIXAAC4cyzG3HCRCgAAgDvs7bff1pAhQ9SiRYs0L3Bfu3Zt289//vmnatSooapVq2r48OG6cuWKXnnlFZ09e1ZRUVEqVKiQJGnDhg1q1qyZgoOD9dlnn8nb29tuneXLl5e/v78kqX///po6dap69eql3r17242zWq2KjIzMcB8yW9dHH32k9evXq1mzZipatKji4+O1fv16TZkyRZGRkVq7dm2mruHVrFkzbdu2TRMnTlTp0qU1d+5cffLJJ/ryyy/1+OOP28adPn1aa9eulSR9//33+vzzzzVt2jQVKlRIhQoVUoMGDTLcVmY5cxzXrFmjpk2bqnXr1urTp49OnTql4cOHKyAgQNu2bZPVapUk/e9//9Ojjz6qKlWqaMqUKXbXUpOkyMhI29jWrVvrhx9+0MiRI9WqVSu7cf7+/ipfvnyG+5DZukaPHq1//vlH9evXV+HChXX+/Hn99NNP+uSTT9S+fXt98803mTpm3377raTrd2cdNmyY+vbtq4YNG0qSOnbs6HRdAAAgB8jupA8AANzdGjRoYCQ5fNxs27ZtpnHjxsbHx8f4+/ubdu3amYMHD9qNGT16dLrrXL16tW1ssWLFHI4rVqxYpvcjM3Vt3LjRtGrVyoSFhRlPT0/j4+NjKleubF577TUTHx+f6W1duHDBPP/88yYkJMR4enqaSpUqmblz56Yat3r1aof71qBBg0xvLzOcPY7Lly83tWvXNl5eXiYwMNB0797d/PPPP3ZjevToke7reOPsvPTGObOvmalr8eLFpkmTJiY4ONjkyZPH5M2b19SsWdO8//775tq1a5neljPv+8zUBQAAsh8z2gAAAAAAAAAX4K6jAAAAAAAAgAsQtAEAAAAAAAAuQNAGAAAAAAAAuABBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC6QJ7sLyImSk5N14sQJ+fn5yWKxZHc5AAAAAAAAyEbGGF24cEFhYWFyc3M8b42gLQ0nTpxQ0aJFs7sMAAAAAAAA5CBHjx5VkSJFHPYTtKXBz89P0vWD5+/vn83VAAAAAAAAIDvFxcWpaNGitszIEYK2NKScLurv70/QBgAAAAAAAEnK8BJj3AwBAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNruAgnXjHpPO6ve084q4ZrJ7nIAAAAAAAD+kwjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcIFsDdomTJigGjVqyM/PT0FBQWrXrp327dtnN6Znz56yWCx2j9q1a2e47vnz56t8+fKyWq0qX768Fi5cmFW7AQAAAAAAAGRv0LZ27Vr17dtXmzdv1ooVK5SYmKhmzZopPj7eblyLFi108uRJ22Pp0qXprnfTpk165JFH1K1bN+3atUvdunVT586dtWXLlqzcHQAAAAAAANzFLMaYHHMbytOnTysoKEhr165V/fr1JV2f0Xb+/Hl99913mV7PI488ori4OP3444+2thYtWih//vyaO3duhsvHxcUpICBAsbGx8vf3d3o/cpqEa0b9PjknSZraO7+sHpZsrggAAAAAACD3yGxWlKOu0RYbGytJCgwMtGtfs2aNgoKCVKZMGfXu3VunTp1Kdz2bNm1Ss2bN7NqaN2+uX375Jc3xCQkJiouLs3sAAAAAAAAAzsgxQZsxRoMHD9Z9992nihUr2tpbtmypOXPmaNWqVXr77be1detWPfDAA0pISHC4rpiYGAUHB9u1BQcHKyYmJs3xEyZMUEBAgO1RtGhR1+wUAAAAAAAA7hp5sruAFP369dNvv/2mDRs22LU/8sgjtp8rVqyo6tWrq1ixYlqyZInat2/vcH0Wi/3pkcaYVG0pRowYocGDB9uex8XFEbYBAAAAAADAKTkiaOvfv78WL16sdevWqUiRIumODQ0NVbFixXTgwAGHY0JCQlLNXjt16lSqWW4prFarrFar84UDAAAAAAAA/1+2njpqjFG/fv20YMECrVq1SiVKlMhwmTNnzujo0aMKDQ11OKZOnTpasWKFXdvy5ctVt27d264ZAAAAAAAASEu2zmjr27evvvrqKy1atEh+fn62WWgBAQHy9vbWxYsXNWbMGHXo0EGhoaE6fPiwXnrpJRUsWFAPP/ywbT3du3dX4cKFNWHCBEnSgAEDVL9+fU2cOFFt27bVokWLtHLlylSnpQIAAAAAAACukq0z2qZPn67Y2Fg1bNhQoaGhtsfXX38tSXJ3d9fu3bvVtm1blSlTRj169FCZMmW0adMm+fn52dYTHR2tkydP2p7XrVtX8+bN08yZM1WpUiXNmjVLX3/9tWrVqnXH9xEAAAAAAAB3B4sxxmR3ETlNXFycAgICFBsbK39//+wu57YlXDPq98k5SdLU3vll9Uj7phAAAAAAAABILbNZUbbOaAMAAAAAAAD+KwjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwgWwN2iZMmKAaNWrIz89PQUFBateunfbt22frv3btmoYNG6aIiAj5+voqLCxM3bt314kTJ9Jd76xZs2SxWFI9rly5ktW7BAAAAAAAgLtUtgZta9euVd++fbV582atWLFCiYmJatasmeLj4yVJly5d0o4dOzRq1Cjt2LFDCxYs0P79+9WmTZsM1+3v76+TJ0/aPby8vLJ6lwAAAAAAAHCXypOdG//pp5/sns+cOVNBQUHavn276tevr4CAAK1YscJuzJQpU1SzZk1FR0frnnvucbhui8WikJCQLKkbAAAAAAAAuFmOukZbbGysJCkwMDDdMRaLRfny5Ut3XRcvXlSxYsVUpEgRtWrVSjt37nQ4NiEhQXFxcXYPAAAAAAAAwBk5Jmgzxmjw4MG67777VLFixTTHXLlyRcOHD9djjz0mf39/h+sqV66cZs2apcWLF2vu3Lny8vJSvXr1dODAgTTHT5gwQQEBAbZH0aJFXbJPAAAAAAAAuHtYjDEmu4uQpL59+2rJkiXasGGDihQpkqr/2rVr6tSpk6Kjo7VmzZp0g7abJScnq2rVqqpfv77ef//9VP0JCQlKSEiwPY+Li1PRokUVGxvr1HZyqoRrRv0+OSdJmto7v6welmyuCAAAAAAAIPeIi4tTQEBAhllRtl6jLUX//v21ePFirVu3zmHI1rlzZx06dEirVq1yOvxyc3NTjRo1HM5os1qtslqtt1Q7AAAAAAAAIGXzqaPGGPXr108LFizQqlWrVKJEiVRjUkK2AwcOaOXKlSpQoMAtbScqKkqhoaGuKBsAAAAAAABIJVtntPXt21dfffWVFi1aJD8/P8XExEiSAgIC5O3trcTERHXs2FE7duzQDz/8oKSkJNuYwMBAeXp6SpK6d++uwoULa8KECZKksWPHqnbt2goPD1dcXJzef/99RUVF6YMPPsieHQUAAAAAAMB/XrYGbdOnT5ckNWzY0K595syZ6tmzp44dO6bFixdLkqpUqWI3ZvXq1bbloqOj5eb2f5Pzzp8/r6effloxMTEKCAhQZGSk1q1bp5o1a2bZvgAAAAAAAODulmNuhpCTZPYCd7kFN0MAAAAAAAC4dZnNirL1Gm0AAAAAAADAfwVBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAASFPCNaPe086q97SzSrhmsrscAACAHI+gDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAAC4RMI1o97Tzqr3tLNKuGayu5w7jqANAAAAAAAAcAGCNgAAAAAAAMAF8ji7QEJCgn799VcdPnxYly5dUqFChRQZGakSJUpkRX0AAAAAAABArpDpoO2XX37RlClT9N133+nq1avKly+fvL29dfbsWSUkJKhkyZJ6+umn9eyzz8rPzy8rawYAAAAAAABynEydOtq2bVt17NhRhQsX1rJly3ThwgWdOXNGx44d06VLl3TgwAG9/PLL+vnnn1WmTBmtWLEiq+sGAAAAAAAAcpRMzWhr1qyZ/ve//8nT0zPN/pIlS6pkyZLq0aOH9u7dqxMnTri0SAAAAAAAACCny1TQ1rdv30yvsEKFCqpQocItFwQAAAAAAADkRrd119GLFy8qLi7O7uGMCRMmqEaNGvLz81NQUJDatWunffv22Y0xxmjMmDEKCwuTt7e3GjZsqL1792a47vnz56t8+fKyWq0qX768Fi5c6FRtAAAAAAAAgDOcDtoOHTqkhx56SL6+vgoICFD+/PmVP39+5cuXT/nz53dqXWvXrlXfvn21efNmrVixQomJiWrWrJni4+NtYyZNmqR33nlHU6dO1datWxUSEqKmTZvqwoULDte7adMmPfLII+rWrZt27dqlbt26qXPnztqyZYuzuwsAAAAAAABkSqbvOpri8ccflyR99tlnCg4OlsViueWN//TTT3bPZ86cqaCgIG3fvl3169eXMUaTJ0/WyJEj1b59e0nS7NmzFRwcrK+++krPPPNMmuudPHmymjZtqhEjRkiSRowYobVr12ry5MmaO3fuLdcLAAAAAAAAOOJ00Pbbb79p+/btKlu2rMuLiY2NlSQFBgZKuj57LiYmRs2aNbONsVqtatCggX755ReHQdumTZs0aNAgu7bmzZtr8uTJaY5PSEhQQkKC7bmzp8ACAAAAAAAATp86WqNGDR09etTlhRhjNHjwYN13332qWLGiJCkmJkaSFBwcbDc2ODjY1peWmJgYp5aZMGGCAgICbI+iRYvezq4AAAAAAADgLuT0jLZPP/1Uzz77rI4fP66KFSvKw8PDrr9SpUq3VEi/fv3022+/acOGDan6bj491RiT4SmrziwzYsQIDR482PY8Li6OsA0AAAAAAABOcTpoO336tP766y898cQTtjaLxWILspKSkpwuon///lq8eLHWrVunIkWK2NpDQkIkXZ+hFhoaams/depUqhlrNwoJCUk1ey29ZaxWq6xWq9N1AwAAAAAAACmcPnW0V69eioyM1KZNm/T333/r0KFDdv91hjFG/fr104IFC7Rq1SqVKFHCrr9EiRIKCQnRihUrbG1Xr17V2rVrVbduXYfrrVOnjt0ykrR8+fJ0lwEAAAAAAABuh9Mz2o4cOaLFixerdOnSt73xvn376quvvtKiRYvk5+dnm4UWEBAgb29vWSwWDRw4UOPHj1d4eLjCw8M1fvx4+fj46LHHHrOtp3v37ipcuLAmTJggSRowYIDq16+viRMnqm3btlq0aJFWrlyZ5mmpAAAAAAAAgCs4HbQ98MAD2rVrl0uCtunTp0uSGjZsaNc+c+ZM9ezZU5I0dOhQXb58WX369NG5c+dUq1YtLV++XH5+frbx0dHRcnP7v8l5devW1bx58/Tyyy9r1KhRKlWqlL7++mvVqlXrtmsGAAAAAAAA0uJ00Na6dWsNGjRIu3fvVkRERKqbIbRp0ybT6zLGZDjGYrFozJgxGjNmjMMxa9asSdXWsWNHdezYMdO1AAAAAAAAALfD6aDt2WeflSS9+uqrqfpu9WYIAAAAAAAAQG7ndNCWnJycFXUAAAAAAAAAuZrTdx0FAAAAAAAAkFqmgrZ58+ZleoVHjx7Vxo0bb7kgAAAAAAAAIDfKVNA2ffp0lStXThMnTtQff/yRqj82NlZLly7VY489pmrVquns2bMuLxQAAAAAAADIyTJ1jba1a9fqhx9+0JQpU/TSSy/J19dXwcHB8vLy0rlz5xQTE6NChQrpiSee0J49exQUFJTVdQMAAAAAAAA5SqZvhtCqVSu1atVKZ86c0YYNG3T48GFdvnxZBQsWVGRkpCIjI+XmxiXfAAAAAAAAcHdy+q6jBQoUUNu2bbOiFgAAAAAAACDXYgoaAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALjALQdtV69e1b59+5SYmOjKegAAAAAAAIBcyemg7dKlS3ryySfl4+OjChUqKDo6WpL0/PPP64033nB5gQAAAAAAAEBu4HTQNmLECO3atUtr1qyRl5eXrb1Jkyb6+uuvXVocAAAAAAAAkFvkcXaB7777Tl9//bVq164ti8Viay9fvrz++usvlxYHAAAAAAAA5BZOz2g7ffq0goKCUrXHx8fbBW8AAAAAAADA3cTpoK1GjRpasmSJ7XlKuPbJJ5+oTp06rqsMAAAAAAAAyEWcPnV0woQJatGihX7//XclJibqvffe0969e7Vp0yatXbs2K2oEAAAAAAAAcjynZ7TVrVtXGzdu1KVLl1SqVCktX75cwcHB2rRpk6pVq5YVNQIAAAAAAAA5ntMz2iQpIiJCs2fPdnUtAAAAAAAAQK7ldNAWFxeXZrvFYpHVapWnp+dtFwUAAAAAAADkNk4Hbfny5Uv37qJFihRRz549NXr0aLm5OX1mKgAAAAAAAJArOR20zZo1SyNHjlTPnj1Vs2ZNGWO0detWzZ49Wy+//LJOnz6tt956S1arVS+99FJW1AwAAAAAAADkOE4HbbNnz9bbb7+tzp0729ratGmjiIgIffTRR/r55591zz336PXXXydoAwAAAAAAwF3D6XM7N23apMjIyFTtkZGR2rRpkyTpvvvuU3R09O1XBwAAAAAAAOQSTgdtRYoU0YwZM1K1z5gxQ0WLFpUknTlzRvnz57/96gAAAAAAAIBcwulTR9966y116tRJP/74o2rUqCGLxaKtW7fqzz//1LfffitJ2rp1qx555BGXFwsAAAAAAADkVE4HbW3atNG+ffv04Ycfav/+/TLGqGXLlvruu+9UvHhxSdJzzz3n6joBAAAAAACAHM3poE2SihcvrjfeeMPVtQAAAAAAAAC51i0FbefPn9evv/6qU6dOKTk52a6ve/fuLikMAAAAAAAAyE2cDtq+//57Pf7444qPj5efn58sFoutz2KxOBW0rVu3Tm+++aa2b9+ukydPauHChWrXrp3d+tIyadIkvfjii2n2zZo1S0888USq9suXL8vLyyvTtQEAAAAAAADOcPquoy+88IJ69eqlCxcu6Pz58zp37pztcfbsWafWFR8fr8qVK2vq1Klp9p88edLu8dlnn8lisahDhw7prtff3z/VsoRsAAAAAAAAyEpOz2g7fvy4nn/+efn4+Nz2xlu2bKmWLVs67A8JCbF7vmjRIjVq1EglS5ZMd70WiyXVsgAAAAAAAEBWcnpGW/PmzbVt27asqCVd//zzj5YsWaInn3wyw7EXL15UsWLFVKRIEbVq1Uo7d+68AxUCAAAAAADgbub0jLaHHnpIL774on7//XdFRETIw8PDrr9NmzYuK+5Gs2fPlp+fn9q3b5/uuHLlymnWrFmKiIhQXFyc3nvvPdWrV0+7du1SeHh4msskJCQoISHB9jwuLs6ltQMAAAAAAOC/z+mgrXfv3pKkV199NVWfxWJRUlLS7VeVhs8++0yPP/54htdaq127tmrXrm17Xq9ePVWtWlVTpkzR+++/n+YyEyZM0NixY11aLwAAAAAAAO4uTp86mpyc7PCRVSHb+vXrtW/fPj311FNOL+vm5qYaNWrowIEDDseMGDFCsbGxtsfRo0dvp1wAAAAAAADchZye0ZYdZsyYoWrVqqly5cpOL2uMUVRUlCIiIhyOsVqtslqtt1MiAAAAAAAA7nK3FLTFx8dr7dq1io6O1tWrV+36nn/++Uyv5+LFizp48KDt+aFDhxQVFaXAwEDdc889kq5fL+1///uf3n777TTX0b17dxUuXFgTJkyQJI0dO1a1a9dWeHi44uLi9P777ysqKkoffPCBs7sJAAAAAAAAZJrTQdvOnTv14IMP6tKlS4qPj1dgYKD+/fdf+fj4KCgoyKmgbdu2bWrUqJHt+eDBgyVJPXr00KxZsyRJ8+bNkzFGXbp0SXMd0dHRcnP7vzNgz58/r6effloxMTEKCAhQZGSk1q1bp5o1azq7qwAAAAAAAECmOR20DRo0SK1bt9b06dOVL18+bd68WR4eHuratasGDBjg1LoaNmwoY0y6Y55++mk9/fTTDvvXrFlj9/zdd9/Vu+++61QdAAAAAAAAwO1y+mYIUVFReuGFF+Tu7i53d3clJCSoaNGimjRpkl566aWsqBEAAAAAAADI8ZwO2jw8PGSxWCRJwcHBio6OliQFBATYfgYAAAAAAADuNk6fOhoZGalt27apTJkyatSokV555RX9+++/+uKLL9K9sycAAAAAAADwX+b0jLbx48crNDRUkvTaa6+pQIECeu6553Tq1Cl9/PHHLi8QAAAAAAAAyA2cmtFmjFGhQoVUoUIFSVKhQoW0dOnSLCkMAAAAAAAAyE2cmtFmjFF4eLiOHTuWVfUAAAAAAAAAuZJTQZubm5vCw8N15syZrKoHAAAAAAAAyJWcvkbbpEmT9OKLL2rPnj1ZUQ8AAAAAAACQKzl919GuXbvq0qVLqly5sjw9PeXt7W3Xf/bsWZcVBwAAAAAAAOQWTgdtkydPzoIyAAAAAAAAgNzN6aCtR48eWVEHAAAAAAAAkKs5fY02AAAAAAAAAKkRtAEAAAAAAAAuQNAGAAAAAAAAuABBGwAAAAAAAOACtxy0HTx4UMuWLdPly5clScYYlxUFAAAAAAAA5DZOB21nzpxRkyZNVKZMGT344IM6efKkJOmpp57SCy+84PICAQAAAAAAgNzA6aBt0KBBypMnj6Kjo+Xj42Nrf+SRR/TTTz+5tDgAAAAAAAAgt8jj7ALLly/XsmXLVKRIEbv28PBwHTlyxGWFAQAAAAAAALmJ0zPa4uPj7Waypfj3339ltVpdUhQAAAAAAACQ2zgdtNWvX1+ff/657bnFYlFycrLefPNNNWrUyKXFAQAAAAAAALmF06eOvvnmm2rYsKG2bdumq1evaujQodq7d6/Onj2rjRs3ZkWNAAAAAAAAQI7n9Iy28uXL67ffflPNmjXVtGlTxcfHq3379tq5c6dKlSqVFTUCAAAAAAAAOZ5TM9quXbumZs2a6aOPPtLYsWOzqiYAAAAAAAAg13FqRpuHh4f27Nkji8WSVfUAAAAAAAAAuZLTp452795dM2bMyIpaAAAAAAAAgFzL6ZshXL16VZ9++qlWrFih6tWry9fX167/nXfecVlxAAAAAAAAQG7hdNC2Z88eVa1aVZK0f/9+uz5OKQUAAAAAAMDdyumgbfXq1VlRBwAAAAAAAJCrOX2NNgAAAAAAAACpOT2jrVGjRumeIrpq1arbKggAAAAAAADIjZwO2qpUqWL3/Nq1a4qKitKePXvUo0cPV9UFAAAAAAAA5CpOnzr67rvv2j2mTp2qDRs2aODAgfLw8HBqXevWrVPr1q0VFhYmi8Wi7777zq6/Z8+eslgsdo/atWtnuN758+erfPnyslqtKl++vBYuXOhUXQAAAAAAAICzXHaNtq5du+qzzz5zapn4+HhVrlxZU6dOdTimRYsWOnnypO2xdOnSdNe5adMmPfLII+rWrZt27dqlbt26qXPnztqyZYtTtQEAAAAAAADOcPrUUUc2bdokLy8vp5Zp2bKlWrZsme4Yq9WqkJCQTK9z8uTJatq0qUaMGCFJGjFihNauXavJkydr7ty5TtUHAAAAAAAAZJbTQVv79u3tnhtjdPLkSW3btk2jRo1yWWEp1qxZo6CgIOXLl08NGjTQ66+/rqCgIIfjN23apEGDBtm1NW/eXJMnT3a4TEJCghISEmzP4+LibrtuAAAAAAAA3F2cDtr8/f3t7jrq5uamsmXL6tVXX1WzZs1cWlzLli3VqVMnFStWTIcOHdKoUaP0wAMPaPv27bJarWkuExMTo+DgYLu24OBgxcTEONzOhAkTNHbsWJfWDgAAAAAAgLuL00HbrFmzsqCMtD3yyCO2nytWrKjq1aurWLFiWrJkSaqZdTe6MQiUrs+6u7ntRiNGjNDgwYNtz+Pi4lS0aNHbqBwAAAAAAAB3G6dvhlCyZEmdOXMmVfv58+dVsmRJlxTlSGhoqIoVK6YDBw44HBMSEpJq9tqpU6dSzXK7kdVqlb+/v90DAAAAAAAAcIbTQdvhw4eVlJSUqj0hIUHHjx93SVGOnDlzRkePHlVoaKjDMXXq1NGKFSvs2pYvX666detmaW0AAAAAAAC4u2X61NHFixfbfl62bJkCAgJsz5OSkvTzzz+rePHiTm384sWLOnjwoO35oUOHFBUVpcDAQAUGBmrMmDHq0KGDQkNDdfjwYb300ksqWLCgHn74Ydsy3bt3V+HChTVhwgRJ0oABA1S/fn1NnDhRbdu21aJFi7Ry5Upt2LDBqdoAAAAAAAAAZ2Q6aGvXrp2k69c/69Gjh12fh4eHihcvrrffftupjW/btk2NGjWyPU+5TlqPHj00ffp07d69W59//rnOnz+v0NBQNWrUSF9//bX8/Pxsy0RHR8vN7f8m5tWtW1fz5s3Tyy+/rFGjRqlUqVL6+uuvVatWLadqAwAAAAAAAJyR6aAtOTlZklSiRAlt3bpVBQsWvO2NN2zYUMYYh/3Lli3LcB1r1qxJ1daxY0d17NjxdkoDAAAAAAAAnOL0XUcPHTqUFXUAAAAAAAAAuZrTQZskxcfHa+3atYqOjtbVq1ft+p5//nmXFAYAAAAAAADkJk4HbTt37tSDDz6oS5cuKT4+XoGBgfr333/l4+OjoKAggjYAAAAAAADcldwyHmJv0KBBat26tc6ePStvb29t3rxZR44cUbVq1fTWW29lRY0AAAAAAABAjud00BYVFaUXXnhB7u7ucnd3V0JCgooWLapJkybppZdeyooaAQAAAAAAgBzP6aDNw8NDFotFkhQcHKzo6GhJUkBAgO1nAAAAAAAA4G7j9DXaIiMjtW3bNpUpU0aNGjXSK6+8on///VdffPGFIiIisqJGAAAAAAAAIMdzekbb+PHjFRoaKkl67bXXVKBAAT333HM6deqUPv74Y5cXCAAAAAAAAOQGTs1oM8aoUKFCqlChgiSpUKFCWrp0aZYUBgAAAAAAAOQmTs1oM8YoPDxcx44dy6p6AAAAAAAAgFzJqaDNzc1N4eHhOnPmTFbVAwAAAAAAAORKTl+jbdKkSXrxxRe1Z8+erKgHAAAAAAAAyJWcvuto165ddenSJVWuXFmenp7y9va26z979qzLigMAAAAAAAByC6eDtsmTJ2dBGQAAAAAAAEDu5nTQ1qNHj6yoAwAAAAAAAMjVnL5GmyT99ddfevnll9WlSxedOnVKkvTTTz9p7969Li0OAAAAAAAAyC2cDtrWrl2riIgIbdmyRQsWLNDFixclSb/99ptGjx7t8gIBAAAAAACA3MDpoG348OEaN26cVqxYIU9PT1t7o0aNtGnTJpcWBwAAAAAAAOQWTgdtu3fv1sMPP5yqvVChQjpz5oxLigIAAAAAAAByG6eDtnz58unkyZOp2nfu3KnChQu7pCgAAAAAAAAgt3E6aHvsscc0bNgwxcTEyGKxKDk5WRs3btSQIUPUvXv3rKgRAAAAAAAAyPGcDtpef/113XPPPSpcuLAuXryo8uXLq379+qpbt65efvnlrKgRAAAAAAAAyPHyOLuAh4eH5syZo1dffVU7d+5UcnKyIiMjFR4enhX1AQAAAAAAALmC00FbilKlSqlkyZKSJIvF4rKCAAAAAAAAgNzI6VNHJWnGjBmqWLGivLy85OXlpYoVK+rTTz91dW0AAAAAAABAruH0jLZRo0bp3XffVf/+/VWnTh1J0qZNmzRo0CAdPnxY48aNc3mRAAAAAAAAQE7ndNA2ffp0ffLJJ+rSpYutrU2bNqpUqZL69+9P0AYAAAAAAIC7ktOnjiYlJal69eqp2qtVq6bExESXFAUAAAAAAADkNk4HbV27dtX06dNTtX/88cd6/PHHXVIUAAAAAAAAkNvc0l1HZ8yYoeXLl6t27dqSpM2bN+vo0aPq3r27Bg8ebBv3zjvvuKZKAAAAAAAAIIdzOmjbs2ePqlatKkn666+/JEmFChVSoUKFtGfPHts4i8XiohIBAAAAAACAnM/poG316tVZUQcAAAAAAACQqzl9jTZXWrdunVq3bq2wsDBZLBZ99913tr5r165p2LBhioiIkK+vr8LCwtS9e3edOHEi3XXOmjVLFosl1ePKlStZvDcAAAAAAAC4mzk9o+3KlSuaMmWKVq9erVOnTik5Odmuf8eOHZleV3x8vCpXrqwnnnhCHTp0sOu7dOmSduzYoVGjRqly5co6d+6cBg4cqDZt2mjbtm3prtff31/79u2za/Py8sp0XQAAAAAAAICznA7aevXqpRUrVqhjx46qWbPmbV2LrWXLlmrZsmWafQEBAVqxYoVd25QpU1SzZk1FR0frnnvucbhei8WikJCQW64LAAAAAAAAcJbTQduSJUu0dOlS1atXLyvqSVdsbKwsFovy5cuX7riLFy+qWLFiSkpKUpUqVfTaa68pMjLS4fiEhAQlJCTYnsfFxbmqZAAAAAAAANwlnL5GW+HCheXn55cVtaTrypUrGj58uB577DH5+/s7HFeuXDnNmjVLixcv1ty5c+Xl5aV69erpwIEDDpeZMGGCAgICbI+iRYtmxS4AAAAAAADgP8zpoO3tt9/WsGHDdOTIkayoJ03Xrl3To48+quTkZE2bNi3dsbVr11bXrl1VuXJl3X///frmm29UpkwZTZkyxeEyI0aMUGxsrO1x9OhRV+8CAAAAAAAA/uOcPnW0evXqunLlikqWLCkfHx95eHjY9Z89e9ZlxUnXQ7bOnTvr0KFDWrVqVbqz2dLi5uamGjVqpDujzWq1ymq13m6pAAAAAAAAuIs5HbR16dJFx48f1/jx4xUcHHxbN0PISErIduDAAa1evVoFChRweh3GGEVFRSkiIiILKgQAAAAAAACuczpo++WXX7Rp0yZVrlz5tjd+8eJFHTx40Pb80KFDioqKUmBgoMLCwtSxY0ft2LFDP/zwg5KSkhQTEyNJCgwMlKenpySpe/fuKly4sCZMmCBJGjt2rGrXrq3w8HDFxcXp/fffV1RUlD744IPbrhcAAAAAAABwxOmgrVy5crp8+bJLNr5t2zY1atTI9nzw4MGSpB49emjMmDFavHixJKlKlSp2y61evVoNGzaUJEVHR8vN7f8uNXf+/Hk9/fTTiomJUUBAgCIjI7Vu3TrVrFnTJTUDAAAAAAAAaXE6aHvjjTf0wgsv6PXXX1dERESqa7Q5cw21hg0byhjjsD+9vhRr1qyxe/7uu+/q3XffzXQNAAAAAAAAgCs4HbS1aNFCktS4cWO7dmOMLBaLkpKSXFMZAAAAAAAAkIs4HbStXr06K+oAAAAAAAAAcjWng7YGDRpkRR0AAAAAAABAruaW8ZDU1q9fr65du6pu3bo6fvy4JOmLL77Qhg0bXFocAAAAAAAAkFs4HbTNnz9fzZs3l7e3t3bs2KGEhARJ0oULFzR+/HiXFwgAAAAAAADkBk4HbePGjdOHH36oTz75xO6Oo3Xr1tWOHTtcWhwAAAAAAACQWzgdtO3bt0/169dP1e7v76/z58+7oiYAAAAAAAAg13E6aAsNDdXBgwdTtW/YsEElS5Z0SVEAAAAAAABAbuN00PbMM89owIAB2rJliywWi06cOKE5c+ZoyJAh6tOnT1bUCAAAAAAAAOR4eZxdYOjQoYqNjVWjRo105coV1a9fX1arVUOGDFG/fv2yokYAAAAAAAAgx3M6aJOk119/XSNHjtTvv/+u5ORklS9fXnnz5nV1bQAAAAAAAECu4fSpo7169dKFCxfk4+Oj6tWrq2bNmsqbN6/i4+PVq1evrKgRAAAAAAAAyPGcDtpmz56ty5cvp2q/fPmyPv/8c5cUBQAAAAAAAOQ2mT51NC4uTsYYGWN04cIFeXl52fqSkpK0dOlSBQUFZUmRAAAAAAAAQE6X6aAtX758slgsslgsKlOmTKp+i8WisWPHurQ4AAAAAAAAILfIdNC2evVqGWP0wAMPaP78+QoMDLT1eXp6qlixYgoLC8uSIgEAAAAAAICcLtNBW4MGDSRJhw4d0j333COLxZJlRQEAAAAAAAC5TaaDthTFihXLijoAAAAAAACAXM3pu44CAAAAAAAASI2gDQAAAAAAAHABp4I2Y4yOHDmiy5cvZ1U9AAAAAAAAQK7kdNAWHh6uY8eOZVU9AAAAAAAAQK7kVNDm5uam8PBwnTlzJqvqAQAAAAAAAHIlp6/RNmnSJL344ovas2dPVtQDAAAAAAAA5Ep5nF2ga9euunTpkipXrixPT095e3vb9Z89e9ZlxQEAAAAAAAC5hdNB2+TJk7OgDAAAAAAAAOR2Vg+LPukTmN1lZBung7YePXpkRR0AAAAAAABArpapoC0uLk7+/v62n9OTMg4AAAAAAAC4m2QqaMufP79OnjypoKAg5cuXTxaLJdUYY4wsFouSkpJcXiQAAAAAAACQ02UqaFu1apUCA6+fX7t69eosLQgAAAAAAADIjTIVtDVo0CDNn28WFRV12wUBAAAAAAAAuZHb7a4gNjZW06ZNU9WqVVWtWjVX1AQAAAAAAADkOrcctK1atUpdu3ZVaGiopkyZogcffFDbtm1zah3r1q1T69atFRYWJovFou+++86u3xijMWPGKCwsTN7e3mrYsKH27t2b4Xrnz5+v8uXLy2q1qnz58lq4cKFTdQEAAAAAAADOcipoO3bsmMaNG6eSJUuqS5cuyp8/v65du6b58+dr3LhxioyMdGrj8fHxqly5sqZOnZpm/6RJk/TOO+9o6tSp2rp1q0JCQtS0aVNduHDB4To3bdqkRx55RN26ddOuXbvUrVs3de7cWVu2bHGqNgAAAAAAAMAZmQ7aHnzwQZUvX16///67pkyZohMnTmjKlCm3tfGWLVtq3Lhxat++fao+Y4wmT56skSNHqn379qpYsaJmz56tS5cu6auvvnK4zsmTJ6tp06YaMWKEypUrpxEjRqhx48aaPHnybdUKAAAAAAAApCfTQdvy5cv11FNPaezYsXrooYfk7u6elXXp0KFDiomJUbNmzWxtVqtVDRo00C+//OJwuU2bNtktI0nNmzdPd5mEhATFxcXZPQAAAAAAAABnZDpoW79+vS5cuKDq1aurVq1amjp1qk6fPp1lhcXExEiSgoOD7dqDg4NtfY6Wc3aZCRMmKCAgwPYoWrTobVQOAAAAAACAu1Gmg7Y6derok08+0cmTJ/XMM89o3rx5Kly4sJKTk7VixYp0r5t2OywWi91zY0yqtttdZsSIEYqNjbU9jh49eusFAwAAAAAA4K7k9F1HfXx81KtXL23YsEG7d+/WCy+8oDfeeENBQUFq06aNywoLCQmRpFQz0U6dOpVqxtrNyzm7jNVqlb+/v90DAAAAAAAAcIbTQduNypYtq0mTJunYsWOaO3euq2qSJJUoUUIhISFasWKFre3q1atau3at6tat63C5OnXq2C0jXb++XHrLAAAAAAAAALcrjytW4u7urnbt2qldu3ZOLXfx4kUdPHjQ9vzQoUOKiopSYGCg7rnnHg0cOFDjx49XeHi4wsPDNX78ePn4+Oixxx6zLdO9e3cVLlxYEyZMkCQNGDBA9evX18SJE9W2bVstWrRIK1eu1IYNG1yxqwAAAAAAAECaXBK03apt27apUaNGtueDBw+WJPXo0UOzZs3S0KFDdfnyZfXp00fnzp1TrVq1tHz5cvn5+dmWiY6Olpvb/03Mq1u3rubNm6eXX35Zo0aNUqlSpfT111+rVq1ad27HAAAAAAAAcNexGGNMdheR08TFxSkgIECxsbH/ieu1JVwz6vfJOUnS1N75ZfVI/2YSAAAAEt8hAAAAUmQ2K7qta7QBAAAAAAAAuI6gDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABcgaAMAAAAAAABcgKANAAAAAAAAcAGCNgAAAAAAAMAFCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABQjaAAAAAAAAABfIk90FAAAAIGeyelj0SZ/A7C4DAAAg12BGGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAAAAAAgAsQtAEAAAAAAAAuQNAGAAAAAAAAuABBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC6Q44O24sWLy2KxpHr07ds3zfFr1qxJc/yff/55hysHAAAAAADA3SRPdheQka1btyopKcn2fM+ePWratKk6deqU7nL79u2Tv7+/7XmhQoWyrEYAAAAAAAAgxwdtNwdkb7zxhkqVKqUGDRqku1xQUJDy5cuXhZUBAAAAAAAA/yfHnzp6o6tXr+rLL79Ur169ZLFY0h0bGRmp0NBQNW7cWKtXr053bEJCguLi4uweAAAAAAAAgDNyVdD23Xff6fz58+rZs6fDMaGhofr44481f/58LViwQGXLllXjxo21bt06h8tMmDBBAQEBtkfRokWzoHoAAAAAAAD8l1mMMSa7i8is5s2by9PTU99//71Ty7Vu3VoWi0WLFy9Osz8hIUEJCQm253FxcSpatKhiY2PtrvOWWyVcM+r3yTlJ0tTe+WX1SH82IAAAAAAAAP5PXFycAgICMsyKcvw12lIcOXJEK1eu1IIFC5xetnbt2vryyy8d9lutVlmt1tspDwAAAAAAAHe5XHPq6MyZMxUUFKSHHnrI6WV37typ0NDQLKgKAAAAAAAAuC5XzGhLTk7WzJkz1aNHD+XJY1/yiBEjdPz4cX3++eeSpMmTJ6t48eKqUKGC7eYJ8+fP1/z587OjdAAAAAAAANwlckXQtnLlSkVHR6tXr16p+k6ePKno6Gjb86tXr2rIkCE6fvy4vL29VaFCBS1ZskQPPvjgnSwZAAAAAAAAd5lcdTOEOyWzF7jLLbgZAgAAAAAAwK3LbFaUa67RBgAAAAAAAORkBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAAAAAAgAsQtAEAAAAAAAAuQNAGAAAAAAAAuABBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAAAAAAgAsQtAEAAAAAAAAuQNAGAAAAAAAAuABBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALhAjg7axowZI4vFYvcICQlJd5m1a9eqWrVq8vLyUsmSJfXhhx/eoWoBAAAAAABwN8uT3QVkpEKFClq5cqXtubu7u8Oxhw4d0oMPPqjevXvryy+/1MaNG9WnTx8VKlRIHTp0uBPlAgAAAAAA4C6V44O2PHnyZDiLLcWHH36oe+65R5MnT5Yk3Xvvvdq2bZveeustgjYAAAAAAABkqRx96qgkHThwQGFhYSpRooQeffRR/f333w7Hbtq0Sc2aNbNra968ubZt26Zr1645XC4hIUFxcXF2j/8Sq4dFn/QJ1Cd9AmX1sGR3OQAAAAAAAP9JOTpoq1Wrlj7//HMtW7ZMn3zyiWJiYlS3bl2dOXMmzfExMTEKDg62awsODlZiYqL+/fdfh9uZMGGCAgICbI+iRYu6dD8AAAAAAADw35ejg7aWLVuqQ4cOioiIUJMmTbRkyRJJ0uzZsx0uY7HYz9gyxqTZfqMRI0YoNjbW9jh69KgLqgcAAAAAAMDdJMdfo+1Gvr6+ioiI0IEDB9LsDwkJUUxMjF3bqVOnlCdPHhUoUMDheq1Wq6xWq0trBQAAAAAAwN0lR89ou1lCQoL++OMPhYaGptlfp04drVixwq5t+fLlql69ujw8PO5EiQAAAAAAALhL5eigbciQIVq7dq0OHTqkLVu2qGPHjoqLi1OPHj0kXT/ls3v37rbxzz77rI4cOaLBgwfrjz/+0GeffaYZM2ZoyJAh2bULAAAAAAAAuEvk6FNHjx07pi5duujff/9VoUKFVLt2bW3evFnFihWTJJ08eVLR0dG28SVKlNDSpUs1aNAgffDBBwoLC9P777+vDh06ZNcuAAAAAAAA4C5hMSl3C4BNXFycAgICFBsbK39//+wuBwAAAAAAANkos1lRjj51FAAAAAAAAMgtCNoAAAAAAAAAFyBoAwAAAAAAAFyAoA0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgDQAAAAAAAHABgjYAAAAAAADABfJkdwE5kTFGkhQXF5fNlQAAAAAAACC7pWREKZmRIwRtabhw4YIkqWjRotlcCQAAAAAAAHKKCxcuKCAgwGG/xWQUxd2FkpOTdeLECfn5+clisWR3OS4RFxenokWL6ujRo/L398/ucgAAQC7BdwgAAOCs/+L3B2OMLly4oLCwMLm5Ob4SGzPa0uDm5qYiRYpkdxlZwt/f/z/zJgcAAHcO3yEAAICz/mvfH9KbyZaCmyEAAAAAAAAALkDQBgAAAAAAALgAQdtdwmq1avTo0bJardldCgAAyEX4DgEAAJx1N39/4GYIAAAAAAAAgAswow0AAAAAAABwAYI2AAAAAAAAwAUI2gAAAAAAAAAXIGgDAAAAAAAAXICgLQfq2bOnLBaL3njjDbv27777ThaLJdX4smXLytPTU8ePH0/VZ4zRmDFjFBYWJm9vbzVs2FB79+61G5OQkKD+/furYMGC8vX1VZs2bXTs2DFb/+HDh/Xkk0+qRIkS8vb2VqlSpTR69GhdvXrVRXsMAABuh8ViSffRs2dP29gffvhBDRs2lJ+fn3x8fFSjRg3NmjUr1Tqjo6PVunVr+fr6qmDBgnr++edT/b9/9+7datCggby9vVW4cGG9+uqruvE+Wxs2bFC9evVUoEABeXt7q1y5cnr33Xez6jAAAAAn5dTvENL1rGLkyJEqVqyYrFarSpUqpc8++ywrDoNL5cnuApA2Ly8vTZw4Uc8884zy58/vcNyGDRt05coVderUSbNmzdLIkSPt+idNmqR33nlHs2bNUpkyZTRu3Dg1bdpU+/btk5+fnyRp4MCB+v777zVv3jwVKFBAL7zwglq1aqXt27fL3d1df/75p5KTk/XRRx+pdOnS2rNnj3r37q34+Hi99dZbWXocAABAxk6ePGn7+euvv9Yrr7yiffv22dq8vb0lSVOmTNHAgQM1bNgwTZs2TZ6enlq0aJGeffZZ7dmzx/b/9aSkJD300EMqVKiQNmzYoDNnzqhHjx4yxmjKlCmSpLi4ODVt2lSNGjXS1q1btX//fvXs2VO+vr564YUXJEm+vr7q16+fKlWqJF9fX23YsEHPPPOMfH199fTTT9+pwwMAABzIqd8hJKlz5876559/NGPGDJUuXVqnTp1SYmLinTgst8cgx+nRo4dp1aqVKVeunHnxxRdt7QsXLjQ3v2Q9e/Y0w4cPNz/++KMpWbKkSU5OtvUlJyebkJAQ88Ybb9jarly5YgICAsyHH35ojDHm/PnzxsPDw8ybN8825vjx48bNzc389NNPDmucNGmSKVGixG3vKwAAcK2ZM2eagICAVO3R0dHGw8PDDB48OFXf+++/bySZzZs3G2OMWbp0qXFzczPHjx+3jZk7d66xWq0mNjbWGGPMtGnTTEBAgLly5YptzIQJE0xYWJjd95GbPfzww6Zr1663unsAACCL5KTvED/++KMJCAgwZ86cceUu3hGcOppDubu7a/z48ZoyZYrdaZw3unDhgv73v/+pa9euatq0qeLj47VmzRpb/6FDhxQTE6NmzZrZ2qxWqxo0aKBffvlFkrR9+3Zdu3bNbkxYWJgqVqxoG5OW2NhYBQYG3uZeAgCAO+Xbb7/VtWvXNGTIkFR9zzzzjPLmzau5c+dKkjZt2qSKFSsqLCzMNqZ58+ZKSEjQ9u3bbWMaNGggq9VqN+bEiRM6fPhwmjXs3LlTv/zyixo0aODCPQMAAFkpO75DLF68WNWrV9ekSZNUuHBhlSlTRkOGDNHly5ezcE9dg6AtB3v44YdVpUoVjR49Os3+efPmKTw8XBUqVJC7u7seffRRzZgxw9YfExMjSQoODrZbLjg42NYXExMjT0/PVKen3jjmZn/99ZemTJmiZ5999pb3DQAA3Fn79+9XQECAQkNDU/V5enqqZMmS2r9/v6Tr3w9u/v6QP39+eXp62n2HSOs7RkrfjYoUKSKr1arq1aurb9++euqpp1y2XwAAIGtlx3eIv//+Wxs2bNCePXu0cOFCTZ48Wd9++6369u3r8v1zNa7RlsNNnDhRDzzwgN15yilmzJihrl272p537dpV9evX1/nz55UvXz5b+803UDDGpHlThcyMOXHihFq0aKFOnTrxJRkAgP+Qm//fn9b3gIzGmP9/EeOb29evX6+LFy9q8+bNGj58uEqXLq0uXbq4snwAAJBNsuI7RHJysiwWi+bMmaOAgABJ0jvvvKOOHTvqgw8+sF07LidiRlsOV79+fTVv3lwvvfSSXfvvv/+uLVu2aOjQocqTJ4/y5Mmj2rVr6/Lly7YpmyEhIZJS/6vyqVOnbGlxSEiIrl69qnPnzjkck+LEiRNq1KiR6tSpo48//til+wkAALJWmTJlFBsbqxMnTqTqu3r1qv7++2+Fh4dLuv794ObvD+fOndO1a9fsvkOk9R1DSj2bvkSJEoqIiFDv3r01aNAgjRkzxlW7BQAAslh2fIcIDQ1V4cKFbSGbJN17770yxji8vFZOQdCWC7zxxhv6/vvv7a6ZNmPGDNWvX1+7du1SVFSU7TF06FDb6aMlSpRQSEiIVqxYYVvu6tWrWrt2rerWrStJqlatmjw8POzGnDx5Unv27LGNkaTjx4+rYcOGqlq1qmbOnCk3N946AADkJh06dFCePHn09ttvp+r78MMPFR8fb5tlVqdOHe3Zs8fuTmTLly+X1WpVtWrVbGPWrVunq1ev2o0JCwtT8eLFHdZhjFFCQoKL9goAAGS17PgOUa9ePZ04cUIXL160jdm/f7/c3NxUpEiRrNhN18muuzDAsR49epi2bdvatXXr1s14eXkZSebq1aumUKFCZvr06amW3b9/v5FkoqKijDHGvPHGGyYgIMAsWLDA7N6923Tp0sWEhoaauLg42zLPPvusKVKkiFm5cqXZsWOHeeCBB0zlypVNYmKiMeb6XUhLly5tHnjgAXPs2DFz8uRJ2wMAAOQsju4YZowx77zzjnFzczMvvfSS+eOPP8zBgwfN22+/baxWq3nhhRds4xITE03FihVN48aNzY4dO8zKlStNkSJFTL9+/Wxjzp8/b4KDg02XLl3M7t27zYIFC4y/v7956623bGOmTp1qFi9ebPbv32/2799vPvvsM+Pv729GjhyZZfsPAABuTU76DnHhwgVTpEgR07FjR7N3716zdu1aEx4ebp566qks239XIWjLgdIK2g4fPmysVquRZL799lvj5uZmYmJi0lw+IiLC9O/f3xhjTHJyshk9erQJCQkxVqvV1K9f3+zevdtu/OXLl02/fv1MYGCg8fb2Nq1atTLR0dG2/pkzZxpJaT4AAEDOkt6XZGOMWbRokbn//vuNr6+v8fLyMtWqVTOfffZZqnFHjhwxDz30kPH29jaBgYGmX79+5sqVK3ZjfvvtN3P//fcbq9VqQkJCzJgxY0xycrKt//333zcVKlQwPj4+xt/f30RGRppp06aZpKQkl+0vAABwjZz0HcIYY/744w/TpEkT4+3tbYoUKWIGDx5sLl265JJ9zUoWY/7/FecAAAAAAAAA3DIutAUAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAAAAAAgAsQtAEAACBHOXz4sCwWi6KiorK7FAAAAKcQtAEAAGShnj17ql27dg77ixcvLovFIovFIm9vb5UrV05vvvmmjDG2MSnBU8rDz89PFSpUUN++fXXgwIFU67x69aomTZqkypUry8fHRwULFlS9evU0c+ZMXbt2zVZXyvo8PDxUsmRJDRkyRPHx8be0nw0bNtTAgQOdXi6t41O0aFGdPHlSFStWvKVaAAAAskue7C4AAADgbvfqq6+qd+/eunLlilauXKnnnntO/v7+euaZZ+zGrVy5UhUqVNClS5e0e/duvffee6pcubK+//57NW7cWNL1kK158+batWuXXnvtNdWrV0/+/v7avHmz3nrrLUVGRqpKlSqSpBYtWtjCt/Xr1+upp55SfHy8pk+ffqcPgR13d3eFhIRkaw0AAAC3ghltAAAA2czPz08hISEqXry4nnrqKVWqVEnLly9PNa5AgQIKCQlRyZIl1bZtW61cuVK1atXSk08+qaSkJEnS5MmTtW7dOv3888/q27evqlSpopIlS+qxxx7Tli1bFB4ebluf1WpVSEiIihYtqscee0yPP/64vvvuO4d1Tps2TeHh4fLy8lJwcLA6duwo6fqstLVr1+q9996zzZI7fPiwkpKS9OSTT6pEiRLy9vZW2bJl9d5779nWN2bMGM2ePVuLFi2yLbdmzZo0Tx1du3atatasKavVqtDQUA0fPlyJiYm2/oYNG+r555/X0KFDFRgYqJCQEI0ZM+YWXxEAAIBbQ9AGAACQQxhjtGbNGv3xxx/y8PDIcLybm5sGDBigI0eOaPv27ZKkOXPmqEmTJoqMjEw13sPDQ76+vg7X5+3tbTu19Gbbtm3T888/r1dffVX79u3TTz/9pPr160uS3nvvPdWpU0e9e/fWyZMndfLkSRUtWlTJyckqUqSIvvnmG/3+++965ZVX9NJLL+mbb76RJA0ZMkSdO3dWixYtbMvVrVs31baPHz+uBx98UDVq1NCuXbs0ffp0zZgxQ+PGjbMbN3v2bPn6+mrLli2aNGmSXn31Va1YsSLD4wgAAOAqnDoKAACQzYYNG6aXX35ZV69e1bVr1+Tl5aXnn38+U8uWK1dO0vXruNWsWVMHDhxQw4YNna7h119/1VdffWU7BfVm0dHR8vX1VatWreTn56dixYrZwryAgAB5enrKx8fH7pRPd3d3jR071va8RIkS+uWXX/TNN9+oc+fOyps3r7y9vZWQkJDuqaLTpk1T0aJFNXXqVFksFpUrV04nTpzQsGHD9Morr8jN7fq/HVeqVEmjR4+WJIWHh2vq1Kn6+eef1bRpU6ePBwAAwK1gRhsAAEA2e/HFFxUVFaW1a9eqUaNGGjlyZJozu9KSctMEi8Vie57yc0Z++OEH5c2bV15eXqpTp47q16+vKVOmpDm2adOmKlasmEqWLKlu3bppzpw5unTpUobb+PDDD1W9enUVKlRIefPm1SeffKLo6OhM1Zfijz/+UJ06dez2q169erp48aKOHTtma6tUqZLdcqGhoTp16pRT2wIAALgdBG0AAADZrGDBgipdurTq1Kmj+fPn691339XKlSsztewff/wh6fpsMUkqU6aMrS0jjRo1UlRUlPbt26crV65owYIFCgoKSnOsn5+fduzYoblz5yo0NFSvvPKKKleurPPnzztc/zfffKNBgwapV69eWr58uaKiovTEE0/o6tWrmaovRVrh4c0Bo6RUp9taLBYlJyc7tS0AAIDbQdAGAACQg+TPn1/9+/fXkCFDbGGSI8nJyXr//fdVokQJ22mcjz32mFauXKmdO3emGp+YmKj4+Hjbc19fX5UuXVrFihXL1DXh8uTJoyZNmmjSpEn67bffdPjwYa1atUqS5OnpabshQ4r169erbt266tOnjyIjI1W6dGn99ddfdmPSWu5m5cuX1y+//GJ3PH755Rf5+fmpcOHCGdYNAABwpxC0AQAAZLHY2FhFRUXZPdI7fbJv377at2+f5s+fb9d+5swZxcTE6O+//9bixYvVpEkT/frrr5oxY4bc3d0lSQMHDlS9evXUuHFjffDBB9q1a5f+/vtvffPNN6pVq5YOHDhwS/vwww8/6P3331dUVJSOHDmizz//XMnJySpbtqwkqXjx4tqyZYsOHz6sf//9V8nJySpdurS2bdumZcuWaf/+/Ro1apS2bt1qt97ixYvrt99+0759+/Tvv/+meTOGPn366OjRo+rfv7/+/PNPLVq0SKNHj9bgwYNt12cDAADICbgZAgAAQBZbs2ZNqruA9ujRQ7NmzUpzfKFChdStWzeNGTNG7du3t7U3adJEkuTj46NixYqpUaNG+vjjj1W6dGnbGKvVqhUrVujdd9/VRx99pCFDhsjHx0f33nuvnn/+eVWsWPGW9iFfvnxasGCBxowZoytXrig8PFxz585VhQoVJF2/g2iPHj1Uvnx5Xb58WYcOHdKzzz6rqKgoPfLII7JYLOrSpYv69OmjH3/80bbe3r17a82aNapevbouXryo1atXq3jx4nbbLly4sJYuXaoXX3xRlStXVmBgoJ588km9/PLLt7QvAAAAWcViMjonAQAAAAAAAECGmGsPAAAAAAAAuABBGwAAAAAAAOACBG0AAAAAAACACxC0AQAAAAAAAC5A0AYAAAAAAAC4AEEbAAAAAAAA4AIEbQAAAAAAAIALELQBAAAAAAAALkDQBgAAAAAAALgAQRsAAAAAAADgAgRtAAAAAAAAgAsQtAEAAAAAAAAu8P8Aetbo+LO5maoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1500x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig,ax = plt.subplots(figsize=(15,5))\n",
    "ax.vlines(df.index, df['min'], df['max'], color='cornflowerblue', label='range')\n",
    "    \n",
    "ax.set_ylabel('Air temperature range (m)')\n",
    "ax.set_xlabel('LRDCP station')\n",
    "\n",
    "plt.suptitle('Air Temperature Range at LRDCP Fumarole Sites ', fontsize=16)\n",
    "plt.title(d1+' - '+d2)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "geonet-tutorial",
   "language": "python",
   "name": "geonet-tutorial"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.7"
  },
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showmarkdowntxt": false
 },
 "nbformat": 4,
 "nbformat_minor": 5
}