From fd248fb313cb418bb39323c732afaeb626cab589 Mon Sep 17 00:00:00 2001 From: Dave Whipp Date: Sun, 13 Oct 2024 22:51:28 +0300 Subject: [PATCH] Update first part of plotting material --- .../chapter-04/md/00-plotting-in-python.md | 19 +- .../part1/chapter-04/md/01-basic-plotting.md | 73 ++-- .../chapter-04/nb/00-plotting-in-python.ipynb | 15 +- .../chapter-04/nb/01-basic-plotting.ipynb | 405 ++++++++---------- 4 files changed, 229 insertions(+), 283 deletions(-) diff --git a/source/part1/chapter-04/md/00-plotting-in-python.md b/source/part1/chapter-04/md/00-plotting-in-python.md index e09431b9..1e482d3e 100644 --- a/source/part1/chapter-04/md/00-plotting-in-python.md +++ b/source/part1/chapter-04/md/00-plotting-in-python.md @@ -15,7 +15,7 @@ jupyter: # Plotting in Python -Data visualization is an essential part of understanding and interpreting data, and Python has a large number of libraries available for use in visualizing different types of data. Below we provide a bried overview of some of the Python plotting landscape as well as an introduction to the terminology commonly used to refer to different parts of a plot created using Python. +Data visualization is an essential part of understanding and interpreting data, and Python has a large number of libraries available for use in visualizing different types of data. Below we provide a brief overview of some of the Python plotting landscape as well as an introduction to the terminology commonly used to refer to different parts of a plot created using Python. ## Python plotting libraries @@ -26,14 +26,14 @@ _**Figure 4.1**. Plotting libraries available in Python. Interactive version onl Python has many nice, useful libraries that can be used for plotting. In the figure above, you can see a number of the available plotting library options, along with how they relate to one another. Of the options above we would like to highlight the following: -- [Matplotlib](https://matplotlib.org/) [^matplotlib]: Matplotlib is one of the most widely used Python plotting libraries, sometimes referred to as "*the grand old man of Python plotting*". Plot examples can be found in the [Matplotlib gallery](https://matplotlib.org/gallery.html). +- [Matplotlib](https://matplotlib.org/) [^matplotlib]: Matplotlib is one of the most widely used Python plotting libraries, sometimes referred to as "*the grand old man of Python plotting*". Plot examples can be found in the [Matplotlib gallery](https://matplotlib.org/stable/gallery/index.html). - - [Matplotlib Basemap](https://matplotlib.org/basemap/index.html) [^basemap]: The Matplotlib Basemap Toolkit is a plugin for visualizing maps in Python. Example plots available in the [Matplotlib basemap gallery](https://matplotlib.org/basemap/users/examples.html). + - [Matplotlib basemap](https://matplotlib.org/basemap/stable/) [^basemap]: The Matplotlib basemap toolkit is a plugin for visualizing maps in Python. Example plots available in the [Matplotlib basemap gallery](https://matplotlib.org/basemap/stable/users/examples.html). - [Seaborn](https://seaborn.pydata.org/) [^seaborn]: Seaborn is a high-level interface for drawing attractive statistical graphics that is built on top of Matplotlib. Example plots can be found in the [Seaborn gallery](https://seaborn.pydata.org/examples/index.html). - [Bokeh](https://docs.bokeh.org/en/latest/) [^bokeh]: Bokeh is a modern plotting library for static and interactive web-based plots including graphs, maps, and charts. Examples can be found in the [Bokeh gallery](https://docs.bokeh.org/en/latest/docs/gallery.html). -- [Plotly](https://plotly.com/python/) [^plotly]: Similar in some ways to Bokeh, Plotly is a modern plotting library for static and interactive web-based plots. Some features are commercial. Example plots are available in the [Plotly gallery](https://plotly.com/python/basic-charts/). -- [Dash](https://plotly.com/dash/) [^dash]: Dash is a Python framework for building analytical web applications. No JavaScript required. +- [Plotly](https://plotly.com/python/) [^plotly]: Similar in some ways to Bokeh, Plotly is a modern plotting library for static and interactive web-based plots. The Python library for Plotly is free and open source, but some Plotly features are commercial. Example plots are available in the [Plotly gallery](https://plotly.com/python/basic-charts/). +- [Dash](https://plotly.com/dash/) [^dash]: Dash is a Python framework for building analytical web applications. No JavaScript required. Some parts of Dash are commercial. - [ggplot](https://yhat.github.io/ggpy/) [^ggplot]: ggplot is a Python plotting environment for those familiar with creating plots in R using ggplot2. You can use ggplot in Python too! Plot examples can be found in the [ggplot examples](https://yhat.github.io/ggpy/). - [HoloViews](https://holoviews.org/) [^holoviews]: and [GeoViews](https://geoviews.org/) [^geoviews]: HoloViews and GeoViews aim to let the data visualize itself. Learn more in the HoloViews introductory video at . @@ -43,10 +43,10 @@ Python has many nice, useful libraries that can be used for plotting. In the fig You should explore the plotting galleries and examples of different visualization libraries above to learn what's possible to do in Python. As you will see, the plotting possibilities in Python are numerous and rich. To get started, we suggest starting by learning to use one that suits your needs best, and later extending your knowledge and skills to other visualization libraries as necessary. - + ## Anatomy of a plot -There are a variety of different kinds of plots (also known as graphs, charts, diagrams, etc.) available that have been designed to visually represent the characteristics of a dataset. Here is a list of several different types of plots that can be used to present different kinds of data. You can find more information about this plots online in Wikipedia, for example. +There are a variety of different kinds of plots (also known as graphs, charts, diagrams, etc.) that have been designed to visually represent the characteristics of a data set. Here is a list of several different types of plots that can be used to present different kinds of data. You can find more information about this plots online in Wikipedia, for example. - [Bar chart](https://en.wikipedia.org/wiki/Bar_chart) - [Histogram](https://en.wikipedia.org/wiki/Histogram) @@ -67,9 +67,8 @@ However, before starting to visualize our data on a plot our data we need to add _**Figure 4.2**. The basic elements of a plot. Image source: Tenkanen (2017)._ - In spite of the large variety of types of plots, there are certain elements that are common for most of them (not all). Thus, it is useful to know at least the basic terminology since it makes it easier to find help and information from the internet when you start creating or modifying your own plots. Figure 4.2 illustrates different elements of a basic line plot. - + ### Common plotting terminology @@ -105,7 +104,7 @@ The common terms in Table 4.1 may vary a bit depending on the plotting library t ## Footnotes -[^basemap]: +[^basemap]: [^bokeh]: [^dash]: [^geoviews]: diff --git a/source/part1/chapter-04/md/01-basic-plotting.md b/source/part1/chapter-04/md/01-basic-plotting.md index 88a5a438..bf929844 100644 --- a/source/part1/chapter-04/md/01-basic-plotting.md +++ b/source/part1/chapter-04/md/01-basic-plotting.md @@ -20,13 +20,9 @@ At this point we are familiar with some of the features of pandas and explored s ## Creating a basic x-y plot -The first step for creating a basic x-y plot is to import pandas and read in the data we want to plot from a file. We will be using a datetime index for our weather observation data as we [learned in Chapter 3](../../chapter-03/nb/03-temporal-data.ipynb). In this case, however, we'll include a few additional parameters in order to *read the data* with a datetime index. We will read in the data first, and then discuss what happened. +The first step for creating a basic x-y plot is to import `pandas` and read in the data we want to plot from a file. We will be using a `datetime` index for our weather observation data as we [learned in Chapter 3](/part1/chapter-03/nb/03-temporal-data.ipynb). In this case, however, we'll include a few additional parameters in order to read the data with a `datetime` index. We will read in the data first and then discuss what happened. -Let's start by importing the libraries we will need (pandas and Matplotlib), and then read in the data. - -```python editable=true slideshow={"slide_type": ""} tags=["remove-cell"] -import warnings -``` +Let's start by importing the libraries we will need (`pandas` and `matplotlib`) and then read in the data. ```python import pandas as pd @@ -36,7 +32,7 @@ fp = "data/029740.txt" data = pd.read_csv( fp, - delim_whitespace=True, + sep=r"\s+", na_values=["*", "**", "***", "****", "*****", "******"], usecols=["YR--MODAHRMN", "TEMP", "MAX", "MIN"], parse_dates=["YR--MODAHRMN"], @@ -44,10 +40,10 @@ data = pd.read_csv( ) ``` -So, let us now examing what is different here compared to files read in Chapter 3. There are two significant changes in the form of two new parameters: `parse_dates` and `index_col`. +So, let us now examining what is different here compared to files read in Chapter 3. There are two significant changes in the form of two new parameters: `parse_dates` and `index_col`. -- `parse_dates` takes a Python list of column name(s) for data file columns that contain date data and pandas will parse and convert data in these column(s) to the *datetime* data type. For many common date formats pandas will automatically recognize and convert the date data. -- `index_col` is used to state a column that should be used to index the data in the DataFrame. In this case, we end up with our date data as the DataFrame index. This is a very useful feature in pandas as we will see below. +- `parse_dates` takes a Python list of column name(s) for data file columns that contain date data and `pandas` will parse and convert data in these column(s) to the `datetime` data type. For many common date formats `pandas` will automatically recognize and convert the date data. +- `index_col` is used to state a column that should be used to index the data in the `DataFrame`. In this case, we end up with our date data as the `DataFrame` index. This is a very useful feature in `pandas` as we will see below. Having read in the data file, we can now have a quick look at what we have using `data.head()`. @@ -55,7 +51,7 @@ Having read in the data file, we can now have a quick look at what we have using data.head() ``` -As mentioned above, you can now see that the index column for our DataFrame (the first column) contains date values related to each row in the DataFrame. With this we are already able to create our first plot using pandas. We will start by using the basic line plot in pandas to visualize at our temperature data. +As mentioned above, you can now see that the index column for our `DataFrame` (the first column) contains date values related to each row in the `DataFrame`. With this we are already able to create our first plot using `pandas`. We will start by using the basic line plot in `pandas` to visualize at our temperature data. ```python ax = data.plot() @@ -63,18 +59,18 @@ ax = data.plot() _**Figure 4.3**. A basic plot of the example temperature data using Matplotlib._ -Now, let's break down what just happened. First, we first created the plot object using the `plot()` method of the `data` DataFrame. Without any parameters given, this makes the plot of all columns in the DataFrame as lines of different color on the y-axis with the index, time in this case, on the x-axis. Second, in case we want to be able to modify the plot or add anything to it after the basic plot has been created, we assign the plot object to the variable `ax`. Why don't we check its data type below using the `type()` function. +Now, let's break down what just happened. First, we first created the plot object using the `.plot()` method of the `data` `DataFrame`. Without any parameters given, this makes the plot of all columns in the `DataFrame` as lines of different color on the y-axis with the index, time in this case, on the x-axis. Second, in case we want to be able to modify the plot or add anything to it after the basic plot has been created, we assign the plot object to the variable `ax`. Why don't we check its data type below using the `type()` function. ```python type(ax) ``` -OK, so this is a data type we have not seen previously, but clearly it is part of matplotlib. In case you were skeptical before, we now have evidence that pandas is using matplotlib for generating plots. +OK, so this is a data type we have not seen previously, but clearly it is part of `matplotlib`. In case you were skeptical before, we now have evidence that `pandas` is using `matplotlib` for generating plots. ### Selecting plot data based on date -Now we can make a few small changes to our plot to further explore plotting with pandas. We can begin by plotting only the observed temperatures in the `data['TEMP']` column. In addition, we can restrict ourselves to observations from only the afternoon of October 1, 2019 (the last day in this dataset). We will do this by first creating a pandas series for only the desired data column and restricting the dateof interest. Once we have created the new pandas series we can plot the results. +Now we can make a few small changes to our plot to further explore plotting with `pandas`. We can begin by plotting only the observed temperatures in the `data['TEMP']` column. In addition, we can restrict ourselves to observations from only the afternoon of October 1, 2019 (the last day in this data set). We will do this by first creating a `pandas` `Series` for only the desired data column and restricting the date of interest. Once we have created the new `pandas` `Series` we can plot the results. ```python # Create basic plot with subset of data @@ -84,12 +80,12 @@ ax = oct1_temps.plot() _**Figure 4.4**. A plot of the example temperature data for the afternoon of October 1, 2019._ -So, what did we change this time? First, we selected only the `'TEMP'` column from the `data` DataFrame by using `data['TEMP']` instead of `data`. Second, we added a restriction to the date range using `loc[]` to select only rows where the index value `data.index` is greater than `'201910011200'`. In that case, the number in the string is in the format `'YYYYMMDDHHMM'`, where `YYYY` is the year, `MM` is the month, `DD` is the day, `HH` is the hour, and `MM` is the minute. This will result in temperatures only from noon onwards on October 1, 2019. Finally, by saving this selection to the variable `oct1_temps` we're able to now use `oct1_temps.plot()` to plot only our selection. As you can see, we are able to easily control the values plotted in pandas, but we can do even better. +So, what did we change this time? First, we selected only the `'TEMP'` column from the `data` `DataFrame` by using `data['TEMP']` instead of `data`. Second, we added a restriction to the date range using `.loc[]` to select only rows where the index value `data.index` is greater than `'201910011200'`. In that case, the number in the string is in the format `'YYYYMMDDHHMM'`, where `YYYY` is the year, `MM` is the month, `DD` is the day, `HH` is the hour, and `MM` is the minute. This will result in temperatures only from noon onward on October 1, 2019. Finally, by saving this selection to the variable `oct1_temps` we're able to now use `oct1_temps.plot()` to plot only our selection. As you can see, we are able to easily control the values plotted in `pandas`, but we can do even better. ## Basic plot formatting -We can control the appearance of our plots, making them look nicer and provide more information by using a few additional plotting options available in pandas and/or matplotlib. Let's start by changing the line format, adding some axis labels, and adding a title. +We can control the appearance of our plots, making them look nicer and provide more information by using a few additional plotting options available in `pandas` and/or `matplotlib`. Let's start by changing the line format, adding some axis labels, and adding a title. ```python # Change line and symbol format, and add axis labels/title @@ -113,7 +109,7 @@ In addition to labeling the plot axes and adding a title, there are several othe ### Changing the figure size -While the default plot sizes we're working with are fine, it is often helpful to be able to control the figure size. Fortunately, there is an easy way to change the figure size in pandas and matplotlib. In order to define the figure size, we simply include the `figsize` parameter with a tuple (set of values in normal parentheses) that lists the width and height of the figure (in inches!). +While the default plot sizes we're working with are fine, it is often helpful to be able to control the figure size. Fortunately, there is an easy way to change the figure size in `pandas` and `matplotlib`. In order to define the figure size, we simply include the `figsize` parameter with a tuple (set of values in normal parentheses) that lists the width and height of the figure (in inches!). For example, adding the parameter @@ -122,7 +118,7 @@ figsize=(12, 6) ``` to the `ax.plot()` function will increase the figure size to be 12 inches wide and 6 inches tall. -Note that it is also possible to change the default figure size for all figures in a Jupyter Notebook by importing the pyplot module from matplotlib (i.e., `import matplotlib.pyplot as plt`)and then defining the default figure size using `plt.rcParams['figure.figsize'] = [12, 6]`. In this case the figure size should be given as a Python list. +Note that it is also possible to change the default figure size for all figures in a Jupyter Notebook by importing the `pyplot` module from `matplotlib` (i.e., `import matplotlib.pyplot as plt`)and then defining the default figure size using `plt.rcParams['figure.figsize'] = [12, 6]`. In this case the figure size should be given as a Python `list`. @@ -142,7 +138,7 @@ would add the text "This is my text." aligned to the left starting from the date ### Changing the axis ranges -In some cases you may want to plot only a subset of the data you are working with. You can modify the range of values that are plotted by definiing the axis ranges. Changing the plot axes can be done using the `xlim` and `ylim` parameters of the `plot()` function, where `xmin` is the minimum bound of the x-axis, `xmax` is the maximum bound, and the same goes for the y-axis with `ymin` and `ymax`. For example, adding +In some cases you may want to plot only a subset of the data you are working with. You can modify the range of values that are plotted by definiing the axis ranges. Changing the plot axes can be done using the `xlim` and `ylim` parameters of the `.vplot()` function, where `xmin` is the minimum bound of the x-axis, `xmax` is the maximum bound, and the same goes for the y-axis with `ymin` and `ymax`. For example, adding ```python ax.plot( @@ -170,16 +166,15 @@ ax.plot( ) ``` -In this case, 3:00 pm on October 1, 2019 is defined by `datetime(2019, 10, 1, 15)` using the datetime library. In this format we are able to specify a set of comma-separated values for the year, month, day, hour, minute, seconds, and microseconds to define a date. If only year, month, and day are given, datetime assumes the time on that day is midnight at the start of the day. - +In this case, 3:00 pm on October 1, 2019 is defined by `datetime(2019, 10, 1, 15)` using the `datetime` library. In this format we are able to specify a set of comma-separated values for the year, month, day, hour, minute, seconds, and microseconds to define a date. If only year, month, and day are given, `datetime` assumes the time on that day is midnight at the start of the day. -Defining axis ranges this way is handy becaues it will adjust the range of values shown on the plot, but not alter the source data in any way. This can be quite nice when exploring your datasets. +Defining axis ranges this way is handy because it will adjust the range of values shown on the plot, but not alter the source data in any way. This can be quite nice when exploring your data sets. ### Adding a legend -The final example of a common plot feature we can add is a legend. The legend allows you to provide some additional information about the lines, points, or other features of a plot, and adding a legend is quite simple. To do so, we need to add two things: a `label` parameter in the plot function that lists the text that should be displayed in the legend, and a call to the `legend()` function to display the plot legend. For example, adding the following to the plot will add and display a legend. +The final example of a common plot feature we can add is a legend. The legend allows you to provide some additional information about the lines, points, or other features of a plot, and adding a legend is quite simple. To do so, we need to add two things: a `label` parameter in the `.plot()` function that lists the text that should be displayed in the legend, and a call to the `.legend()` function to display the plot legend. For example, adding the following to the plot will add and display a legend. ```python ax.plot( @@ -191,7 +186,7 @@ ax.legend() This would add the label "Observed temperature" to the legend for the line formatted using the `ax.plot()` function. The legend can be displayed by adding `ax.legend()` to the code. -Note that by default the legend will automatically be positioned in the top right corner of a plot, or in a location where it minimizes interference with other plot elements. The location of the legend can be controlled using the `loc` parameter in the call to the `legend()` function. The [matplotlib documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html) [^matplotlib-legend] contains more information about how to control the location of the plot legend. +Note that by default the legend will automatically be positioned in the top right corner of a plot, or in a location where it minimizes interference with other plot elements. The location of the legend can be controlled using the `loc` parameter in the call to the `.legend()` function. The [`matplotlib` documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html) [^matplotlib-legend] contains more information about how to control the location of the plot legend. ### The modified example plot @@ -231,7 +226,7 @@ As you can see, we now have a more informative plot with only a few changes in t ## Dealing with datetime axes -One issue we will encounter both with placing text on the plot and changing the axis ranges is the datetime index for our DataFrame. In order to do either thing, we need to define x-values using a datetime object. The easiest way to do this is to use the pandas `pd.to_datetime()` function, which converts a character string date to a datetime object. For example, we can convert 13:00 on October 1, 2019 from the character string `'201910011300'` to a datetime equivalent by typing +One issue we will encounter both with placing text on the plot and changing the axis ranges is the `datetime` index for our `DataFrame`. In order to do either thing, we need to define x-values using a `datetime` object. The easiest way to do this is to use the `pandas` `pd.to_datetime()` function, which converts a character string date to a `datetime` object. For example, we can convert 13:00 on October 1, 2019 from the character string `'201910011300'` to a `datetime` equivalent by typing ```python pd.to_datetime("201910011300") @@ -306,9 +301,9 @@ ax.legend(loc=4) ## Bar plots in pandas -In addition to line plots, there are many other options for plotting in pandas. +In addition to line plots, there are many other options for plotting in `pandas`. Bar plots are one option, which can be used quite similarly to line plots with the addition of the `kind=bar` parameter. -Note that it is easiest to plot our selected time range for a bar plot by selecting the dates in our data series first, rather than adjusting the plot limits. Pandas sees bar plot data as categorical, so the date range is more difficult to define for x-axis limits. For the y-axis, we can still define its range using the `ylim=[ymin, ymax]` parameter. Similarly, text placement on a bar plot is more difficult, and most easily done using the index value of the bar where the text should be placed. +Note that it is easiest to plot our selected time range for a bar plot by selecting the dates in our data `Series` first, rather than adjusting the plot limits. `pandas` sees bar plot data as categorical, so the date range is more difficult to define for x-axis limits. For the y-axis, we can still define its range using the `ylim=[ymin, ymax]` parameter. Similarly, text placement on a bar plot is more difficult, and most easily done using the index value of the bar where the text should be placed. ```python oct1_afternoon = oct1_temps.loc[oct1_temps.index <= "201910011500"] @@ -330,17 +325,17 @@ ax.legend() _**Figure 4.8**. A bar plot using pandas with the example temperature data._ -You can find more about how to format bar charts on the [pandas documentation website](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.bar.html) [^pandas-docs]. +You can find more about how to format bar charts on the [`pandas` documentation website](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.bar.html) [^pandas-docs]. ## Saving your plots as image files -Saving plots created using pandas can be done in several ways. -The recommendation for use outside of Jupyter notebooks is to use Matplotlib's `plt.savefig()` function. +Saving plots created using `pandas` can be done in several ways. +The recommendation for use outside of Jupyter Notebooks is to use the `plt.savefig()` function from `matplotlib`. When using `plt.savefig()`, you simply give a list of commands to generate a plot and include `plt.savefig()` with some parameters as the last command in the Python cell. The file name is required, and the image format will be determined based on the listed file extension. -Matplotlib plots can be saved in a number of useful file formats, including PNG, PDF, and EPS. +`matplotlib` plots can be saved in a number of useful file formats, including PNG, PDF, and EPS. PNG is a nice format for raster images, and EPS is probably easiest to use for vector graphics. Let's check out an example of how to save our lovely bar plot. @@ -393,24 +388,20 @@ This would save the output plot as a PDF file with a resolution of 600 dots per ## Interactive plotting, a teaser -We have seen in the previous parts of this chapter that there are many ways to configure and visualize data using Python. Up to this point, however, we have focussed on static visualizations in Jupyter notebooks or those saved as images. As you might imagine, there are numerous Python options to also create interactive visualizations that allow those viewing them to dive deeper into the data and explore. Interactive visualizations are increasingly popular online, and here we provide a brief example of how to create an interactive visualization using the data we have already plotted above. In this example, we will be using the hvPlot library [^hvplot], which we will return to using later in Part 2 of this book. +We have seen in the previous parts of this chapter that there are many ways to configure and visualize data using Python. Up to this point, however, we have focused on static visualizations in Jupyter Notebooks or those saved as images. As you might imagine, there are numerous Python options to also create interactive visualizations that allow those viewing them to dive deeper into the data and explore. Interactive visualizations are increasingly popular online, and here we provide a brief example of how to create an interactive visualization using the data we have already plotted above. In this example, we will be using the `hvplot` library [^hvplot], which we will return to using later in Part 2 of this book. -hvPlot is a high-level plotting package that can accept several different common Python data types and plot them using using the bokeh visualization library [^bokeh]. The great thing with hvPlot is that it takes almost no effort to move from plotting in pandas to creating interactive plots. We can explore this in the following example. +`hvplot` is a high-level plotting package that can accept several different common Python data types and plot them using using the `bokeh` visualization library [^bokeh]. The great thing with `hvplot` is that it takes almost no effort to move from plotting in `pandas` to creating interactive plots. We can explore this in the following example. -Let us start by importing the pandas submodule of hvPlot. +Let us start by importing the `pandas` submodule of `hvplot`. ```python import hvplot.pandas ``` -With the submodule imported, we can simply take a slice of data from the `data` DataFrame, the month of July in 2014 in this example, and create a plot just as we would in pandas. The only difference here is that we will use the `hvplot()` method rather than the `plot()` method from pandas. +With the submodule imported, we can simply take a slice of data from the `data` `DataFrame`, the month of July in 2014 in this example, and create a plot just as we would in `pandas`. The only difference here is that we will use the `.hvplot()` method rather than the `.plot()` method from `pandas`. -```python editable=true slideshow={"slide_type": ""} tags=["remove_cell"] -warnings.simplefilter("ignore") -``` - ```python editable=true slideshow={"slide_type": ""} july2014_df = data.loc[(data.index >= "201407010000") & (data.index < "201407310000")] @@ -430,9 +421,9 @@ july2014_df.hvplot( _**Figure 4.9**. An interactive plot example using hvPlot._ -Now we have an interactive line plot where the users can place their mouse cursor above the line to see the plotted values at a given location, zoom in and/or pan the plot to areas of interest, and click on the legend items to hide or display them. And as you can see, hvPlot makes it very easy to start creating your own interactive plots from pandas DataFrames. +Now we have an interactive line plot where the users can place their mouse cursor above the line to see the plotted values at a given location, zoom in and/or pan the plot to areas of interest, and click on the legend items to hide or display them. And as you can see, `hvplot` makes it very easy to start creating your own interactive plots from a `pandas` `DataFrame`. -That is all we will explore for the moment, but you are welcome to have a look at the [hvPlot User Guide](https://hvplot.holoviz.org/user_guide/index.html) [^hvplot_guide] to learn more about the types of visualizations available in hvPlot and how to use them. +That is all we will explore for the moment, but you are welcome to have a look at the [`hvplot` User Guide](https://hvplot.holoviz.org/user_guide/index.html) [^hvplot_guide] to learn more about the types of visualizations available in `hvplot` and how to use them. ## Footnotes diff --git a/source/part1/chapter-04/nb/00-plotting-in-python.ipynb b/source/part1/chapter-04/nb/00-plotting-in-python.ipynb index c9088a60..500ff2cf 100644 --- a/source/part1/chapter-04/nb/00-plotting-in-python.ipynb +++ b/source/part1/chapter-04/nb/00-plotting-in-python.ipynb @@ -13,7 +13,7 @@ "source": [ "# Plotting in Python\n", "\n", - "Data visualization is an essential part of understanding and interpreting data, and Python has a large number of libraries available for use in visualizing different types of data. Below we provide a bried overview of some of the Python plotting landscape as well as an introduction to the terminology commonly used to refer to different parts of a plot created using Python." + "Data visualization is an essential part of understanding and interpreting data, and Python has a large number of libraries available for use in visualizing different types of data. Below we provide a brief overview of some of the Python plotting landscape as well as an introduction to the terminology commonly used to refer to different parts of a plot created using Python." ] }, { @@ -29,14 +29,14 @@ "\n", "Python has many nice, useful libraries that can be used for plotting. In the figure above, you can see a number of the available plotting library options, along with how they relate to one another. Of the options above we would like to highlight the following:\n", "\n", - "- [Matplotlib](https://matplotlib.org/) [^matplotlib]: Matplotlib is one of the most widely used Python plotting libraries, sometimes referred to as \"*the grand old man of Python plotting*\". Plot examples can be found in the [Matplotlib gallery](https://matplotlib.org/gallery.html).\n", + "- [Matplotlib](https://matplotlib.org/) [^matplotlib]: Matplotlib is one of the most widely used Python plotting libraries, sometimes referred to as \"*the grand old man of Python plotting*\". Plot examples can be found in the [Matplotlib gallery](https://matplotlib.org/stable/gallery/index.html).\n", "\n", - " - [Matplotlib Basemap](https://matplotlib.org/basemap/index.html) [^basemap]: The Matplotlib Basemap Toolkit is a plugin for visualizing maps in Python. Example plots available in the [Matplotlib basemap gallery](https://matplotlib.org/basemap/users/examples.html).\n", + " - [Matplotlib basemap](https://matplotlib.org/basemap/stable/) [^basemap]: The Matplotlib basemap toolkit is a plugin for visualizing maps in Python. Example plots available in the [Matplotlib basemap gallery](https://matplotlib.org/basemap/stable/users/examples.html).\n", " - [Seaborn](https://seaborn.pydata.org/) [^seaborn]: Seaborn is a high-level interface for drawing attractive statistical graphics that is built on top of Matplotlib. Example plots can be found in the [Seaborn gallery](https://seaborn.pydata.org/examples/index.html).\n", "\n", "- [Bokeh](https://docs.bokeh.org/en/latest/) [^bokeh]: Bokeh is a modern plotting library for static and interactive web-based plots including graphs, maps, and charts. Examples can be found in the [Bokeh gallery](https://docs.bokeh.org/en/latest/docs/gallery.html).\n", - "- [Plotly](https://plotly.com/python/) [^plotly]: Similar in some ways to Bokeh, Plotly is a modern plotting library for static and interactive web-based plots. Some features are commercial. Example plots are available in the [Plotly gallery](https://plotly.com/python/basic-charts/).\n", - "- [Dash](https://plotly.com/dash/) [^dash]: Dash is a Python framework for building analytical web applications. No JavaScript required.\n", + "- [Plotly](https://plotly.com/python/) [^plotly]: Similar in some ways to Bokeh, Plotly is a modern plotting library for static and interactive web-based plots. The Python library for Plotly is free and open source, but some Plotly features are commercial. Example plots are available in the [Plotly gallery](https://plotly.com/python/basic-charts/).\n", + "- [Dash](https://plotly.com/dash/) [^dash]: Dash is a Python framework for building analytical web applications. No JavaScript required. Some parts of Dash are commercial.\n", "- [ggplot](https://yhat.github.io/ggpy/) [^ggplot]: ggplot is a Python plotting environment for those familiar with creating plots in R using ggplot2. You can use ggplot in Python too! Plot examples can be found in the [ggplot examples](https://yhat.github.io/ggpy/).\n", "- [HoloViews](https://holoviews.org/) [^holoviews]: and [GeoViews](https://geoviews.org/) [^geoviews]: HoloViews and GeoViews aim to let the data visualize itself. Learn more in the HoloViews introductory video at .\n", "\n", @@ -54,7 +54,7 @@ "source": [ "## Anatomy of a plot\n", "\n", - "There are a variety of different kinds of plots (also known as graphs, charts, diagrams, etc.) available that have been designed to visually represent the characteristics of a dataset. Here is a list of several different types of plots that can be used to present different kinds of data. You can find more information about this plots online in Wikipedia, for example.\n", + "There are a variety of different kinds of plots (also known as graphs, charts, diagrams, etc.) that have been designed to visually represent the characteristics of a data set. Here is a list of several different types of plots that can be used to present different kinds of data. You can find more information about this plots online in Wikipedia, for example.\n", "\n", "- [Bar chart](https://en.wikipedia.org/wiki/Bar_chart)\n", "- [Histogram](https://en.wikipedia.org/wiki/Histogram)\n", @@ -75,7 +75,6 @@ "\n", "_**Figure 4.2**. The basic elements of a plot. Image source: Tenkanen (2017)._\n", "\n", - "\n", "In spite of the large variety of types of plots, there are certain elements that are common for most of them (not all). Thus, it is useful to know at least the basic terminology since it makes it easier to find help and information from the internet when you start creating or modifying your own plots. Figure 4.2 illustrates different elements of a basic line plot." ] }, @@ -122,7 +121,7 @@ "source": [ "## Footnotes\n", "\n", - "[^basemap]: \n", + "[^basemap]: \n", "[^bokeh]: \n", "[^dash]: \n", "[^geoviews]: \n", diff --git a/source/part1/chapter-04/nb/01-basic-plotting.ipynb b/source/part1/chapter-04/nb/01-basic-plotting.ipynb index ac1f1df8..97f0ad80 100644 --- a/source/part1/chapter-04/nb/01-basic-plotting.ipynb +++ b/source/part1/chapter-04/nb/01-basic-plotting.ipynb @@ -23,42 +23,16 @@ "source": [ "## Creating a basic x-y plot\n", "\n", - "The first step for creating a basic x-y plot is to import pandas and read in the data we want to plot from a file. We will be using a datetime index for our weather observation data as we [learned in Chapter 3](../../chapter-03/nb/03-temporal-data.ipynb). In this case, however, we'll include a few additional parameters in order to *read the data* with a datetime index. We will read in the data first, and then discuss what happened.\n", + "The first step for creating a basic x-y plot is to import `pandas` and read in the data we want to plot from a file. We will be using a `datetime` index for our weather observation data as we [learned in Chapter 3](/part1/chapter-03/nb/03-temporal-data.ipynb). In this case, however, we'll include a few additional parameters in order to read the data with a `datetime` index. We will read in the data first and then discuss what happened.\n", "\n", - "Let's start by importing the libraries we will need (pandas and Matplotlib), and then read in the data." + "Let's start by importing the libraries we will need (`pandas` and `matplotlib`) and then read in the data." ] }, { "cell_type": "code", - "execution_count": 1, - "metadata": { - "editable": true, - "slideshow": { - "slide_type": "" - }, - "tags": [ - "remove-cell" - ] - }, - "outputs": [], - "source": [ - "import warnings" - ] - }, - { - "cell_type": "code", - "execution_count": 2, + "execution_count": 5, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/f7/rhmqxfmx40s4yv9bhh7skq4m0000gp/T/ipykernel_67812/633907917.py:6: FutureWarning: The 'delim_whitespace' keyword in pd.read_csv is deprecated and will be removed in a future version. Use ``sep='\\s+'`` instead\n", - " data = pd.read_csv(\n" - ] - } - ], + "outputs": [], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", @@ -67,7 +41,7 @@ "\n", "data = pd.read_csv(\n", " fp,\n", - " delim_whitespace=True,\n", + " sep=r\"\\s+\",\n", " na_values=[\"*\", \"**\", \"***\", \"****\", \"*****\", \"******\"],\n", " usecols=[\"YR--MODAHRMN\", \"TEMP\", \"MAX\", \"MIN\"],\n", " parse_dates=[\"YR--MODAHRMN\"],\n", @@ -79,17 +53,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "So, let us now examing what is different here compared to files read in Chapter 3. There are two significant changes in the form of two new parameters: `parse_dates` and `index_col`.\n", + "So, let us now examining what is different here compared to files read in Chapter 3. There are two significant changes in the form of two new parameters: `parse_dates` and `index_col`.\n", "\n", - "- `parse_dates` takes a Python list of column name(s) for data file columns that contain date data and pandas will parse and convert data in these column(s) to the *datetime* data type. For many common date formats pandas will automatically recognize and convert the date data.\n", - "- `index_col` is used to state a column that should be used to index the data in the DataFrame. In this case, we end up with our date data as the DataFrame index. This is a very useful feature in pandas as we will see below.\n", + "- `parse_dates` takes a Python list of column name(s) for data file columns that contain date data and `pandas` will parse and convert data in these column(s) to the `datetime` data type. For many common date formats `pandas` will automatically recognize and convert the date data.\n", + "- `index_col` is used to state a column that should be used to index the data in the `DataFrame`. In this case, we end up with our date data as the `DataFrame` index. This is a very useful feature in `pandas` as we will see below.\n", "\n", "Having read in the data file, we can now have a quick look at what we have using `data.head()`." ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -169,7 +143,7 @@ "1952-01-02 00:00:00 36.0 NaN NaN" ] }, - "execution_count": 3, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -182,17 +156,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As mentioned above, you can now see that the index column for our DataFrame (the first column) contains date values related to each row in the DataFrame. With this we are already able to create our first plot using pandas. We will start by using the basic line plot in pandas to visualize at our temperature data." + "As mentioned above, you can now see that the index column for our `DataFrame` (the first column) contains date values related to each row in the `DataFrame`. With this we are already able to create our first plot using `pandas`. We will start by using the basic line plot in `pandas` to visualize at our temperature data." ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -211,12 +185,12 @@ "source": [ "_**Figure 4.3**. A basic plot of the example temperature data using Matplotlib._\n", "\n", - "Now, let's break down what just happened. First, we first created the plot object using the `plot()` method of the `data` DataFrame. Without any parameters given, this makes the plot of all columns in the DataFrame as lines of different color on the y-axis with the index, time in this case, on the x-axis. Second, in case we want to be able to modify the plot or add anything to it after the basic plot has been created, we assign the plot object to the variable `ax`. Why don't we check its data type below using the `type()` function." + "Now, let's break down what just happened. First, we first created the plot object using the `.plot()` method of the `data` `DataFrame`. Without any parameters given, this makes the plot of all columns in the `DataFrame` as lines of different color on the y-axis with the index, time in this case, on the x-axis. Second, in case we want to be able to modify the plot or add anything to it after the basic plot has been created, we assign the plot object to the variable `ax`. Why don't we check its data type below using the `type()` function." ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -225,7 +199,7 @@ "matplotlib.axes._axes.Axes" ] }, - "execution_count": 5, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +212,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "OK, so this is a data type we have not seen previously, but clearly it is part of matplotlib. In case you were skeptical before, we now have evidence that pandas is using matplotlib for generating plots." + "OK, so this is a data type we have not seen previously, but clearly it is part of `matplotlib`. In case you were skeptical before, we now have evidence that `pandas` is using `matplotlib` for generating plots." ] }, { @@ -247,17 +221,17 @@ "source": [ "### Selecting plot data based on date\n", "\n", - "Now we can make a few small changes to our plot to further explore plotting with pandas. We can begin by plotting only the observed temperatures in the `data['TEMP']` column. In addition, we can restrict ourselves to observations from only the afternoon of October 1, 2019 (the last day in this dataset). We will do this by first creating a pandas series for only the desired data column and restricting the dateof interest. Once we have created the new pandas series we can plot the results." + "Now we can make a few small changes to our plot to further explore plotting with `pandas`. We can begin by plotting only the observed temperatures in the `data['TEMP']` column. In addition, we can restrict ourselves to observations from only the afternoon of October 1, 2019 (the last day in this data set). We will do this by first creating a `pandas` `Series` for only the desired data column and restricting the date of interest. Once we have created the new `pandas` `Series` we can plot the results." ] }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -278,7 +252,7 @@ "source": [ "_**Figure 4.4**. A plot of the example temperature data for the afternoon of October 1, 2019._\n", "\n", - "So, what did we change this time? First, we selected only the `'TEMP'` column from the `data` DataFrame by using `data['TEMP']` instead of `data`. Second, we added a restriction to the date range using `loc[]` to select only rows where the index value `data.index` is greater than `'201910011200'`. In that case, the number in the string is in the format `'YYYYMMDDHHMM'`, where `YYYY` is the year, `MM` is the month, `DD` is the day, `HH` is the hour, and `MM` is the minute. This will result in temperatures only from noon onwards on October 1, 2019. Finally, by saving this selection to the variable `oct1_temps` we're able to now use `oct1_temps.plot()` to plot only our selection. As you can see, we are able to easily control the values plotted in pandas, but we can do even better." + "So, what did we change this time? First, we selected only the `'TEMP'` column from the `data` `DataFrame` by using `data['TEMP']` instead of `data`. Second, we added a restriction to the date range using `.loc[]` to select only rows where the index value `data.index` is greater than `'201910011200'`. In that case, the number in the string is in the format `'YYYYMMDDHHMM'`, where `YYYY` is the year, `MM` is the month, `DD` is the day, `HH` is the hour, and `MM` is the minute. This will result in temperatures only from noon onward on October 1, 2019. Finally, by saving this selection to the variable `oct1_temps` we're able to now use `oct1_temps.plot()` to plot only our selection. As you can see, we are able to easily control the values plotted in `pandas`, but we can do even better." ] }, { @@ -287,17 +261,17 @@ "source": [ "## Basic plot formatting\n", "\n", - "We can control the appearance of our plots, making them look nicer and provide more information by using a few additional plotting options available in pandas and/or matplotlib. Let's start by changing the line format, adding some axis labels, and adding a title." + "We can control the appearance of our plots, making them look nicer and provide more information by using a few additional plotting options available in `pandas` and/or `matplotlib`. Let's start by changing the line format, adding some axis labels, and adding a title." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -340,7 +314,7 @@ "source": [ "### Changing the figure size\n", "\n", - "While the default plot sizes we're working with are fine, it is often helpful to be able to control the figure size. Fortunately, there is an easy way to change the figure size in pandas and matplotlib. In order to define the figure size, we simply include the `figsize` parameter with a tuple (set of values in normal parentheses) that lists the width and height of the figure (in inches!).\n", + "While the default plot sizes we're working with are fine, it is often helpful to be able to control the figure size. Fortunately, there is an easy way to change the figure size in `pandas` and `matplotlib`. In order to define the figure size, we simply include the `figsize` parameter with a tuple (set of values in normal parentheses) that lists the width and height of the figure (in inches!).\n", "\n", "For example, adding the parameter\n", "\n", @@ -349,7 +323,7 @@ "```\n", "to the `ax.plot()` function will increase the figure size to be 12 inches wide and 6 inches tall.\n", "\n", - "Note that it is also possible to change the default figure size for all figures in a Jupyter Notebook by importing the pyplot module from matplotlib (i.e., `import matplotlib.pyplot as plt`)and then defining the default figure size using `plt.rcParams['figure.figsize'] = [12, 6]`. In this case the figure size should be given as a Python list." + "Note that it is also possible to change the default figure size for all figures in a Jupyter Notebook by importing the `pyplot` module from `matplotlib` (i.e., `import matplotlib.pyplot as plt`)and then defining the default figure size using `plt.rcParams['figure.figsize'] = [12, 6]`. In this case the figure size should be given as a Python `list`." ] }, { @@ -375,7 +349,7 @@ "source": [ "### Changing the axis ranges\n", "\n", - "In some cases you may want to plot only a subset of the data you are working with. You can modify the range of values that are plotted by definiing the axis ranges. Changing the plot axes can be done using the `xlim` and `ylim` parameters of the `plot()` function, where `xmin` is the minimum bound of the x-axis, `xmax` is the maximum bound, and the same goes for the y-axis with `ymin` and `ymax`. For example, adding\n", + "In some cases you may want to plot only a subset of the data you are working with. You can modify the range of values that are plotted by definiing the axis ranges. Changing the plot axes can be done using the `xlim` and `ylim` parameters of the `.vplot()` function, where `xmin` is the minimum bound of the x-axis, `xmax` is the maximum bound, and the same goes for the y-axis with `ymin` and `ymax`. For example, adding\n", "\n", "```python\n", "ax.plot(\n", @@ -403,10 +377,9 @@ ")\n", "```\n", "\n", - "In this case, 3:00 pm on October 1, 2019 is defined by `datetime(2019, 10, 1, 15)` using the datetime library. In this format we are able to specify a set of comma-separated values for the year, month, day, hour, minute, seconds, and microseconds to define a date. If only year, month, and day are given, datetime assumes the time on that day is midnight at the start of the day.\n", + "In this case, 3:00 pm on October 1, 2019 is defined by `datetime(2019, 10, 1, 15)` using the `datetime` library. In this format we are able to specify a set of comma-separated values for the year, month, day, hour, minute, seconds, and microseconds to define a date. If only year, month, and day are given, `datetime` assumes the time on that day is midnight at the start of the day.\n", "\n", - "\n", - "Defining axis ranges this way is handy becaues it will adjust the range of values shown on the plot, but not alter the source data in any way. This can be quite nice when exploring your datasets." + "Defining axis ranges this way is handy because it will adjust the range of values shown on the plot, but not alter the source data in any way. This can be quite nice when exploring your data sets." ] }, { @@ -415,7 +388,7 @@ "source": [ "### Adding a legend\n", "\n", - "The final example of a common plot feature we can add is a legend. The legend allows you to provide some additional information about the lines, points, or other features of a plot, and adding a legend is quite simple. To do so, we need to add two things: a `label` parameter in the plot function that lists the text that should be displayed in the legend, and a call to the `legend()` function to display the plot legend. For example, adding the following to the plot will add and display a legend.\n", + "The final example of a common plot feature we can add is a legend. The legend allows you to provide some additional information about the lines, points, or other features of a plot, and adding a legend is quite simple. To do so, we need to add two things: a `label` parameter in the `.plot()` function that lists the text that should be displayed in the legend, and a call to the `.legend()` function to display the plot legend. For example, adding the following to the plot will add and display a legend.\n", "\n", "```python\n", "ax.plot(\n", @@ -427,7 +400,7 @@ "\n", "This would add the label \"Observed temperature\" to the legend for the line formatted using the `ax.plot()` function. The legend can be displayed by adding `ax.legend()` to the code.\n", "\n", - "Note that by default the legend will automatically be positioned in the top right corner of a plot, or in a location where it minimizes interference with other plot elements. The location of the legend can be controlled using the `loc` parameter in the call to the `legend()` function. The [matplotlib documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html) [^matplotlib-legend] contains more information about how to control the location of the plot legend." + "Note that by default the legend will automatically be positioned in the top right corner of a plot, or in a location where it minimizes interference with other plot elements. The location of the legend can be controlled using the `loc` parameter in the call to the `.legend()` function. The [`matplotlib` documentation](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.legend.html) [^matplotlib-legend] contains more information about how to control the location of the plot legend." ] }, { @@ -441,22 +414,22 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 8, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -506,25 +479,14 @@ "source": [ "## Dealing with datetime axes\n", "\n", - "One issue we will encounter both with placing text on the plot and changing the axis ranges is the datetime index for our DataFrame. In order to do either thing, we need to define x-values using a datetime object. The easiest way to do this is to use the pandas `pd.to_datetime()` function, which converts a character string date to a datetime object. For example, we can convert 13:00 on October 1, 2019 from the character string `'201910011300'` to a datetime equivalent by typing" + "One issue we will encounter both with placing text on the plot and changing the axis ranges is the `datetime` index for our `DataFrame`. In order to do either thing, we need to define x-values using a `datetime` object. The easiest way to do this is to use the `pandas` `pd.to_datetime()` function, which converts a character string date to a `datetime` object. For example, we can convert 13:00 on October 1, 2019 from the character string `'201910011300'` to a `datetime` equivalent by typing" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Timestamp('2019-10-01 13:00:00')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "pd.to_datetime(\"201910011300\")" ] @@ -542,22 +504,22 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 10, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -616,7 +578,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 13, "metadata": { "tags": [ "remove_cell" @@ -629,7 +591,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 14, "metadata": { "tags": [ "hide-cell", @@ -640,16 +602,16 @@ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA/MAAAIICAYAAAAi3r7NAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtTUlEQVR4nOzdd1gUV/828HvpHQSkCYKigg1sUbF3xd5r7D0mdiXYsGPvsfcWjEZjN/oo2DUoYFARLCBYsCFd6s77hy/7c0MRFHZ24f5cF9eTnT175p7d8YHvzplzJIIgCCAiIiIiIiIilaEmdgAiIiIiIiIiKhgW80REREREREQqhsU8ERERERERkYphMU9ERERERESkYljMExEREREREakYFvNEREREREREKobFPBEREREREZGKYTFPREREREREpGJYzBMRERERERGpGBbzRESkMLt374ZEIsGdO3dyfL5jx45wcHD4pr6HDBlS4NdGRERAIpFg9+7d37RPiUSCn3/++bv3MWnSJEgkEjx69CjXNjNnzoREIkFAQMA3Zc3LjRs3MHfuXMTGxhZ63/mRnJyMuXPnws/PT5T9K7vFixfjr7/+EjsGEREpGRbzRERUYllbW+PmzZvo0KGDqPsYPnw4AGDnzp05Pi+VSrF3717UqFEDtWrVKvSMN27cwLx580Qt5ufNm8diPhcs5omIKCcs5omIqMTS1tZG/fr1Ubp0aVH3Ua1aNdStWxf79u1DRkZGtufPnz+PFy9eyIp+Ul2ZmZlITU0VOwYA4NOnT2JHICKi78BinoiIlJogCNi4cSNq1KgBXV1dlCpVCj179sSzZ8+++trDhw+jXr16MDY2hp6eHsqXL49hw4bJns9pCPzcuXMhkUjw4MED9OvXD8bGxrC0tMSwYcMQFxf31awzZsyApqYmtm3blus+cjJ8+HBER0fj7Nmz2Z7btWsXtLW1MWDAAKSkpGDKlCmoUaMGjI2NYWpqCjc3Nxw/fjzb67JuA9i3bx8qV64MPT09uLq64tSpU3LHO23aNABAuXLlIJFIIJFIZFfJDx06hDZt2sDa2hq6urqoXLkyfv31VyQlJcnt686dO+jbty8cHBygq6sLBwcH9OvXD8+fP8/zuCMiImRfdMybN0+2/yFDhsjaPH78GP3794eFhQW0tbVRuXJl/Pbbb3L9+Pn5QSKR4ODBg/Dw8IC1tTUMDAzQqVMnvHnzBgkJCRg1ahTMzc1hbm6OoUOHIjExMcf3a8uWLahUqRK0tbVRpUoV+Pj4ZMsdHR2N0aNHw9bWFlpaWihXrhzmzZsn92VM1me/bNkyLFy4EOXKlYO2tjZ8fX3z/TlKJBIkJSVhz549svemWbNmss9OIpFky5Z1O0tERIRsm4ODAzp27IijR4+iZs2a0NHRwbx58/J9LACwadMmuLq6wsDAAIaGhnB2dsaMGTNy+WSJiKioaYgdgIiISp7MzMwcr0ALgpBt2+jRo7F7926MHz8eS5cuRUxMDObPn48GDRrg3r17sLS0zHEfN2/eRJ8+fdCnTx/MnTsXOjo6eP78OS5dupSvjD169ECfPn0wfPhwBAcHw9PTE0DuQ+FTU1MxZMgQnD59GidPnkS7du3ytZ8s/fr1w6RJk7Bz50506tRJtv3jx484fvw4unXrhlKlSiEuLg4xMTGYOnUqypQpg7S0NPzvf/9D9+7dsWvXLgwaNEiu39OnT8Pf3x/z58+HgYEBli1bhm7duiE0NBTly5fHiBEjEBMTg/Xr1+Po0aOwtrYGAFSpUgXA50K6ffv2mDhxIvT19fHo0SMsXboU//zzj9x7GRERAScnJ/Tt2xempqZ4/fo1Nm3ahB9++AEPHz6Eubl5jsdtbW2Nc+fOoV27dhg+fDhGjBgBALIC/+HDh2jQoAHKli2LlStXwsrKCn///TfGjx+P9+/fw8vLS66/GTNmoHnz5ti9ezciIiIwdepU9OvXDxoaGnB1dcXvv/+OwMBAzJgxA4aGhli3bp3c60+cOAFfX1/Mnz8f+vr62Lhxo+z1PXv2BPC5+K1bty7U1NQwZ84cODo64ubNm1i4cCEiIiKwa9cuuT7XrVuHSpUqYcWKFTAyMkLFihWRmpqar8/x5s2baNGiBZo3b47Zs2cDAIyMjL52OuUoICAAISEhmDVrFsqVKwd9ff18H4uPjw9++ukn/PLLL1ixYgXU1NTw5MkTPHz48JuyEBFRIRCIiIgUZNeuXQKAPH/s7e1l7W/evCkAEFauXCnXT1RUlKCrqytMnz5dtm3w4MFyr12xYoUAQIiNjc01T3h4uABA2LVrl2ybl5eXAEBYtmyZXNuffvpJ0NHREaRSqWwbAGHcuHHChw8fhEaNGgllypQRgoKCvrqP3AwePFjQ1NQU3rx5I9u2fv16AYBw4cKFHF+TkZEhpKenC8OHDxdq1qwp9xwAwdLSUoiPj5dti46OFtTU1ARvb2/ZtuXLlwsAhPDw8DzzSaVSIT09Xbh8+bIAQLh3716ubTMyMoTExERBX19fWLt2bZ79vnv3TgAgeHl5ZXuubdu2gq2trRAXFye3/eeffxZ0dHSEmJgYQRAEwdfXVwAgdOrUSa7dxIkTBQDC+PHj5bZ37dpVMDU1ldsGQNDV1RWio6PljsPZ2VmoUKGCbNvo0aMFAwMD4fnz53KvzzrnHjx4IAjC/332jo6OQlpaWp7vQV6fo76+vjB48OBsr8k6V/8r69/Zl5+nvb29oK6uLoSGhsq1ze+x/Pzzz4KJiUmex0BERIrFYfZERKRwe/fuhb+/f7afRo0aybU7deoUJBIJfvzxR2RkZMh+rKys4OrqmueEaT/88AMAoHfv3vjjjz/w8uXLAmXs3Lmz3GMXFxekpKTg7du3ctvDw8Ph5uaG+Ph43Lp1C66url/t+8tjycjIkI1IGD58ONLT07Fv3z5Z2127dsHe3h4tW7aUbTt8+DAaNmwIAwMDaGhoQFNTEzt27EBISEi2fTVv3hyGhoayx5aWlrCwsPjq8Pcsz549Q//+/WFlZQV1dXVoamqiadOmACC3v8TERHh4eKBChQrQ0NCAhoYGDAwMkJSUlGOu/EhJScHFixfRrVs36Onpyb1n7du3R0pKCm7duiX3mo4dO8o9rly5MgBkm4CwcuXKiImJyTbUvmXLlnKjPdTV1dGnTx88efIEL168APD5vGzevDlsbGzkMrm7uwMALl++LNdn586doampme34CvI5FgYXFxdUqlRJblt+j6Vu3bqIjY1Fv379cPz4cbx//75IMhIRUf6xmCciIoWrXLky6tSpk+3H2NhYrt2bN28gCAIsLS2hqakp93Pr1q08C4omTZrgr7/+QkZGBgYNGgRbW1tUq1YNv//+e74ympmZyT3W1tYGkH3SsH/++QdhYWHo06cPbG1tv9pvREREtmPJKpgaN26MSpUqyYY2//vvvwgICMDQoUNl90YfPXoUvXv3RpkyZbB//37cvHkT/v7+GDZsGFJSUr56HFnHkp/JzxITE9G4cWPcvn0bCxcuhJ+fH/z9/XH06NFs70X//v2xYcMGjBgxAn///Tf++ecf+Pv7o3Tp0t880dqHDx+QkZGB9evXZ3vP2rdvDwDZzgFTU1O5x1paWnlu/+97ZmVllS1H1rYPHz4A+Hxenjx5MlumqlWr5pgp69aFLxX0cywMOeXI77EMHDgQO3fuxPPnz9GjRw9YWFigXr16uHDhQpFkJSKir+M980REpLTMzc0hkUhw9epVWTH9pZy2falLly7o0qULUlNTcevWLXh7e6N///5wcHCAm5tboWTs06cPrKysMHPmTEilUsyaNSvP9jY2NvD395fb5uTkJPvvYcOG4ddff8U///yDgwcPQk1NTW4yuP3796NcuXI4dOiQ3ORnRTFD+qVLl/Dq1Sv4+fnJrsYDyLaEXVxcHE6dOgUvLy/8+uuvcpliYmK+ef+lSpWCuro6Bg4ciHHjxuXYply5ct/cf06io6Nz3Zb1xYi5uTlcXFywaNGiHPuwsbGRe5zTJHWF8Tnq6OjIXvPlv4XcvuTKKUdBjmXo0KEYOnQokpKScOXKFXh5eaFjx44ICwuDvb19vnMTEVHhYDFPRERKq2PHjliyZAlevnyJ3r17f3M/2traaNq0KUxMTPD3338jMDCw0Ip5AJg1axYMDQ0xadIkJCUlwdvbO9e2WlpaqFOnTq7PDx48GLNmzcKWLVtw4sQJtGzZUq5Qkkgk0NLSkivMoqOjc5zNPr9yG3WQtY//fmmyZcuWbO0EQcjWbvv27cjMzPzm/evp6aF58+YIDAyEi4uL7Gp6Ubp48SLevHkjG2qfmZmJQ4cOwdHRUTbyomPHjjhz5gwcHR1RqlSpb9pPQT7H3EZSODg4APg8giPrthIAOHnyZL5zfMux6Ovrw93dHWlpaejatSsePHjAYp6ISAQs5omISGk1bNgQo0aNwtChQ3Hnzh00adIE+vr6eP36Na5du4bq1atj7NixOb52zpw5ePHiBVq2bAlbW1vExsZi7dq1cvd8F6YJEybAwMAAo0aNQmJiItatW5fjldCvsbKyQvv27bFr1y4IgpBtbfms5cV++ukn9OzZE1FRUViwYAGsra3x+PHjb8pevXp1AMDatWsxePBgaGpqwsnJCQ0aNECpUqUwZswYeHl5QVNTEwcOHMC9e/fkXm9kZIQmTZpg+fLlMDc3h4ODAy5fvowdO3bAxMTkq/s3NDSEvb09jh8/jpYtW8LU1FTWz9q1a9GoUSM0btwYY8eOhYODAxISEvDkyROcPHky36sT5Je5uTlatGiB2bNny2azf/TokdzydPPnz8eFCxfQoEEDjB8/Hk5OTkhJSUFERATOnDmDzZs3f/WWi4J8jtWrV4efnx9OnjwJa2trGBoawsnJCe3bt4epqSmGDx+O+fPnQ0NDA7t370ZUVFS+jze/xzJy5Ejo6uqiYcOGsLa2RnR0NLy9vWFsbCz3RQIRESkOi3kiIlJqW7ZsQf369bFlyxZs3LgRUqkUNjY2aNiwIerWrZvr6+rVq4c7d+7Aw8MD7969g4mJCerUqYNLly7J7gcubMOHD4e+vj4GDhyIpKQkbN++/Zv7OXHiBExNTdG1a1e554YOHYq3b99i8+bN2LlzJ8qXL49ff/0VL168kK0bXlDNmjWDp6cn9uzZg23btkEqlcLX1xfNmjXD6dOnMWXKFPz444/Q19dHly5dcOjQIdSqVUuuj4MHD2LChAmYPn06MjIy0LBhQ1y4cCHbxHO52bFjB6ZNm4bOnTsjNTUVgwcPxu7du1GlShUEBARgwYIFmDVrFt6+fQsTExNUrFhRdt98YercuTOqVq2KWbNmITIyEo6Ojjhw4AD69Okja2NtbY07d+5gwYIFWL58OV68eAFDQ0OUK1cO7dq1y9cV7oJ8jmvXrsW4cePQt29fJCcno2nTpvDz84ORkRHOnTuHiRMn4scff4SJiQlGjBgBd3d32RJ/X5PfY2ncuDF2796NP/74Ax8/foS5uTkaNWqEvXv3ypYRJCIixZIIQg6L+hIRERGVMBKJBOPGjcOGDRvEjkJERPRVnM2eiIiIiIiISMWwmCciIiIiIiJSMbxnnoiIiAgA7zwkIiJVovJX5r29vSGRSDBx4sQcnx89ejQkEgnWrFmj0FxERERERERERUWli3l/f39s3boVLi4uOT7/119/4fbt27CxsVFwMiIiIiIiIqKio7LD7BMTEzFgwABs27YNCxcuzPb8y5cv8fPPP+Pvv//O17I4qampSE1NlT2WSqWIiYmBmZnZN60TTERERERERFQQgiAgISEBNjY2UFPL+9q7yhbz48aNQ4cOHdCqVatsxbxUKsXAgQMxbdq0fK8l7O3t/c3r8xIREREREREVlqioKNja2ubZRiWLeR8fHwQEBMDf3z/H55cuXQoNDQ2MHz8+3316enpi8uTJssdxcXEoW7YsoqKiYGRk9N2ZiYiIiIiIiPISHx8POzs7GBoafrWtyhXzUVFRmDBhAs6fPw8dHZ1sz9+9exdr165FQEBAgYbHa2trQ1tbO9t2IyMjFvNERERERESkMPmpZSWCiq3D8tdff6Fbt25QV1eXbcvMzIREIoGamhqWLl2KadOmyd1fkJmZCTU1NdjZ2SEiIiJf+4mPj4exsTHi4uJYzBMREREREVGRK0gdqnJX5lu2bIng4GC5bUOHDoWzszM8PDxgbW2Ntm3byj3ftm1bDBw4EEOHDlVkVCIiIiIiIqIioXLFvKGhIapVqya3TV9fH2ZmZrLtZmZmcs9ramrCysoKTk5OCstJREREREREVFRUep15IiIiIiIiopJI5a7M58TPzy/P5/N7nzwRERERERGRKuCVeSIiIiIiIiIVw2KeiIiIiIiISMWwmCciIiIiIiJSMSzmiYiIiIiIiFQMi3kiIiIiIiIiFcNinoiIiIiIiEjFsJgnIiIiIiIiUjEs5omIiIiIiIhUDIt5IiIiIiIiIhXDYp6IiIiIiIhIxbCYJyIiIiIiIlIxLOaJiIiIiIiIVAyLeSIiIiIiIiIVw2KeiIiIiIiISMWwmCciIiIiIiJSMSzmiYiIiIiIiFQMi3kiIiIiIiIiFcNinoiIiIiIiEjFsJgnIiIiIiIiUjEs5omIiIiIiIhUDIt5IiIiIiIiIhXDYp6IiIiIiIhIxbCYJyIiIiIiIlIxLOaJiIiIiIiIVAyLeSIiIiIiIiIVw2KeiIiIiIiISMWwmCciIiIiIiJSMSzmiYiIiIiIiFQMi3kiIiIiUkoODg5Ys2ZNofe7e/dumJiYFHq/yqJZs2aYOHGi2DGIqIixmCciIqI8bd68GYaGhsjIyJBtS0xMhKamJho3bizX9urVq5BIJAgLC1N0zO8yZMgQdO3a9avtSlKRNHfuXNSoUUPUDP7+/hg1atR39VFUXwgos6NHj2LBggVixyCiIsZinoiIiPLUvHlzJCYm4s6dO7JtV69ehZWVFfz9/ZGcnCzb7ufnBxsbG1SqVKnA+xEEQe4LAyoaaWlpCt3f93yupUuXhp6eXiEnKv5MTU1haGgoyr4jIyNF2S9RScRinoiIiPLk5OQEGxsb+Pn5ybb5+fmhS5cucHR0xI0bN+S2N2/eHACwf/9+1KlTB4aGhrCyskL//v3x9u1bubYSiQR///036tSpA21tbVy9ehXNmjXDL7/8gokTJ6JUqVKwtLTE1q1bkZSUhKFDh8LQ0BCOjo44e/asXM6HDx+iffv2MDAwgKWlJQYOHIj379/Lnj9y5AiqV68OXV1dmJmZoVWrVkhKSsLcuXOxZ88eHD9+HBKJBBKJRO5YswwZMgSXL1/G2rVrZe0iIiLyte9vOaas9+f06dNwdXWFjo4O6tWrh+DgYLlcN27cQJMmTaCrqws7OzuMHz8eSUlJsucdHBywcOFCDBkyBMbGxhg5ciQAwMPDA5UqVYKenh7Kly+P2bNnIz09HcDnYejz5s3DvXv3ZMe6e/duREREQCKRICgoSNZ/bGys3HuW2+cqCAKWLVuG8uXLQ1dXF66urjhy5Ei29/lL/72qLpFIsH37dnTr1g16enqoWLEiTpw4kevrmzVrhufPn2PSpEmy4/jS33//jcqVK8PAwADt2rXD69ev5Z7ftWsXKleuDB0dHTg7O2Pjxo155s3rGKVSKWxtbbF582a51wQEBEAikeDZs2cAgLi4OIwaNQoWFhYwMjJCixYtcO/ePVn7rBET+/btg4ODA4yNjdG3b18kJCTIHfeXI0gcHBywePFiDBs2DIaGhihbtiy2bt0ql+PGjRuoUaMGdHR0UKdOHfz111/ZPuv8GDx4MKpVq4bly5dnez+JqJAJlKO4uDgBgBAXFyd2FCIiItH1799faNOmjezxDz/8IBw+fFgYO3asMGPGDEEQBCE1NVXQ1dUVtm/fLgiCIOzYsUM4c+aM8PTpU+HmzZtC/fr1BXd3d1kfvr6+AgDBxcVFOH/+vPDkyRPh/fv3QtOmTQVDQ0NhwYIFQlhYmLBgwQJBTU1NcHd3F7Zu3SqEhYUJY8eOFczMzISkpCRBEATh1atXgrm5ueDp6SmEhIQIAQEBQuvWrYXmzZvLntfQ0BBWrVolhIeHC//++6/w22+/CQkJCUJCQoLQu3dvoV27dsLr16+F169fC6mpqdneg9jYWMHNzU0YOXKkrF1GRsZX9y0IwjcdU9b7U7lyZeH8+fPCv//+K3Ts2FFwcHAQ0tLSBEEQhH///VcwMDAQVq9eLYSFhQnXr18XatasKQwZMkS2b3t7e8HIyEhYvny58PjxY+Hx48eCIAjCggULhOvXrwvh4eHCiRMnBEtLS2Hp0qWCIAhCcnKyMGXKFKFq1aqyY01OThbCw8MFAEJgYKCs/48fPwoABF9f3zw/1xkzZgjOzs7CuXPnhKdPnwq7du0StLW1BT8/v1zPO3t7e2H16tWyxwAEW1tb4eDBg8Ljx4+F8ePHCwYGBsKHDx9yfP2HDx8EW1tbYf78+bLjEARB2LVrl6CpqSm0atVK8Pf3F+7evStUrlxZ6N+/v+y1W7duFaytrYU///xTePbsmfDnn38Kpqamwu7du3PN+7VjnDJlitCoUSO510yZMkVwc3MTBEEQpFKp0LBhQ6FTp06Cv7+/EBYWJkyZMkUwMzOTHaOXl5dgYGAgdO/eXQgODhauXLkiWFlZyf4dCsLn823ChAly76Opqanw22+/CY8fPxa8vb0FNTU1ISQkRBAEQYiPjxdMTU2FH3/8UXjw4IFw5swZoVKlStk+6/x4+/atsHbtWqF27dqCurq64O7uLvj4+AifPn0qUD9EJVVB6lAW87lgMU9ERPR/tm7dKujr6wvp6elCfHy8oKGhIbx580bw8fERGjRoIAiCIFy+fFkAIDx9+jTHPv755x8BgJCQkCAIwv8VfX/99Zdcu6ZNm8oVPBkZGYK+vr4wcOBA2bbXr18LAISbN28KgiAIs2fPlvuyQRAEISoqSgAghIaGCnfv3hUACBERETlmGzx4sNClS5evvg//LZLys+9vPaas98fHx0fW5sOHD4Kurq5w6NAhQRAEYeDAgcKoUaPk9n316lVBTU1NVjzZ29sLXbt2/eqxLVu2TKhdu7bssZeXl+Dq6irXpiDF/Jefa2JioqCjoyPcuHFDrr/hw4cL/fr1yzVTTsX8rFmz5PqVSCTC2bNn892HIHwu5gEIT548kW377bffBEtLS9ljOzs74eDBg3KvW7Bggazw/q/8HGNAQIAgkUhk52FmZqZQpkwZ4bfffhMEQRAuXrwoGBkZCSkpKXJ9ODo6Clu2bBEE4fPnoqenJ8THx8uenzZtmlCvXj3Z45yK+R9//FH2WCqVChYWFsKmTZsEQRCETZs2CWZmZnIF97Zt276pmP/Sw4cPBQ8PD8HW1lYwMTERRo8eLTu/iShnBalDVX6Yvbe3NyQSidxQorlz58LZ2Rn6+vooVaoUWrVqhdu3b4sXkoiISMU1b94cSUlJ8Pf3x9WrV1GpUiVYWFigadOm8Pf3R1JSEvz8/FC2bFmUL18eABAYGIguXbrA3t4ehoaGaNasGYDs99TWqVMn2/5cXFxk/62urg4zMzNUr15dts3S0hIAZMP27969C19fXxgYGMh+nJ2dAQBPnz6Fq6srWrZsierVq6NXr17Ytm0bPn78WCjvzdf2/a3HlMXNzU3236ampnByckJISIhs37t375bbd9u2bSGVShEeHi57XU7v8ZEjR9CoUSNYWVnBwMAAs2fPLtT7nb/c58OHD5GSkoLWrVvLZd27d6/ce5QfX76P+vr6MDQ0zPae5Yeenh4cHR1lj62trWX9vHv3DlFRURg+fLhc3oULF+aaNz/HWLNmTTg7O+P3338HAFy+fBlv375F7969AXz+PBMTE2FmZibXR3h4uNx+HRwc5O6J/zJ7br583yQSCaysrGSvCQ0NhYuLC3R0dGRt6tatm2d/ixcvlsuY07lTuXJlLFmyBM+fP4enpyd27tyJdu3a5dkvEeWfhtgBvoe/vz+2bt0q939OAFCpUiVs2LAB5cuXx6dPn7B69Wq0adMGT548QenSpUVKS0REpLoqVKgAW1tb+Pr64uPHj2jatCkAwMrKCuXKlcP169fh6+uLFi1aAACSkpLQpk0btGnTBvv370fp0qURGRmJtm3bZpuATV9fP9v+NDU15R5LJBK5bVn3PkulUtn/durUCUuXLs3Wl7W1NdTV1XHhwgXcuHED58+fx/r16zFz5kzcvn0b5cqV+4535uv7/tZjysuXbUePHo3x48dna1O2bFnZf//3Pb516xb69u2LefPmoW3btjA2NoaPjw9WrlyZ537V1D5fBxIEQbYt6z77//pyn1nHdPr0aZQpU0aunba2dp77/K+c3sf8vGf56SfruLL627ZtG+rVqyfXTl1dPcf+8nuMAwYMwMGDB/Hrr7/i4MGDaNu2LczNzWV9WFtb5zhnw5dL6X3Le5DXawRByDafwJefcU7GjBkj+xICAGxsbLK1iYqKwoEDB7Bv3z6Eh4ejV69eGDp0aJ79ElH+qWwxn5iYiAEDBmDbtm1YuHCh3HP9+/eXe7xq1Srs2LED//77L1q2bKnImERERMVG8+bN4efnh48fP2LatGmy7U2bNsXff/+NW7duyf5Qf/ToEd6/f48lS5bAzs4OAORmwy9stWrVwp9//gkHBwdoaOT8541EIkHDhg3RsGFDzJkzB/b29jh27BgmT54MLS0tZGZmfnU/ObXLz76/x61bt2SF+cePHxEWFia78l+rVi08ePAAFSpUKFCf169fh729PWbOnCnb9vz5c7k2OR1r1kWR169fo2bNmgCQrwnSqlSpAm1tbURGRsq+CFKU/H62X7K0tESZMmXw7NkzDBgwIF+vye8x9u/fH7NmzcLdu3dx5MgRbNq0SfZcrVq1EB0dDQ0NDTg4OBQo8/dwdnbGgQMHkJqaKvvi4Wv/Xk1NTWFqappte0JCAv7880/s27cPfn5+aNCgASZNmoTevXvDyMio0LO/f/8e9+7dQ4sWLbJ9IUE5EwQBV69eRWRkJOzt7WVLjEqlUhw8eDDX15UpU0Y2wSkAHDx4MNcvkaysrNCqVSvZ4z/++CPXlTTMzc3lRmwcPXpUbpWUL5mYmKBjx46yxydOnEB8fHyObQ0MDOSWHD1z5gxiYmJybKujo4OePXvKHv/999949+5dtnbNmzfP9mWdmFS2mB83bhw6dOiAVq1aZSvmv5SWloatW7fC2NgYrq6uubZLTU1Famqq7HFuJwUREVFJ1bx5c4wbNw7p6elyxUrTpk0xduxYpKSkyP7QK1u2LLS0tLB+/XqMGTMG9+/fL9J1r8eNG4dt27ahX79+mDZtGszNzfHkyRP4+Phg27ZtuHPnDi5evIg2bdrAwsICt2/fxrt371C5cmUAn4ct//333wgNDYWZmRmMjY2zXcnManf79m1ERETAwMAApqamX913bldy82v+/PkwMzODpaUlZs6cCXNzc9kfqB4eHqhfvz7GjRuHkSNHQl9fHyEhIbhw4QLWr1+fa58VKlRAZGQkfHx88MMPP+D06dM4duxYtmMNDw9HUFAQbG1tYWhoCF1dXdSvXx9LliyBg4MD3r9/j1mzZn31GAwNDTF16lRMmjQJUqkUjRo1Qnx8PG7cuAEDAwMMHjz4u96jvDg4OODKlSvo27cvtLW1ZVfBv2bu3LkYP348jIyM4O7ujtTUVNy5cwcfP37E5MmTs7XP7zGWK1cODRo0wPDhw5GRkYEuXbrI+mjVqhXc3NzQtWtXLF26FE5OTnj16hXOnDmDrl275ni7RGHo378/Zs6ciVGjRuHXX39FZGQkVqxYAQAFLpC7du2KZ8+eYeDAgdi6davcrQyF7cOHD3Bzc8OTJ0+wY8cODBs2rMj2VVxkZmZi4sSJ2LBhAwCgT58+smJeEAQMHDgw19d27NhRrpgfNmyYXP30pRYtWsgV82PHjs21kK5Xr55cMT9hwgS8ePEix7bVqlWTK+anT5+O0NDQHNuWL19erpifPXs2AgICcmxraWkpV8wvXLgQ165dy9bu1KlTLOa/l4+PDwICAuDv759rm1OnTqFv375ITk6GtbU1Lly4kOf/eXt7e2PevHlFEZeIiKhYaN68OT59+gRnZ2fZ/d3A52I+ISEBjo6OsqvwpUuXxu7duzFjxgysW7cOtWrVwooVK9C5c+ciyWZjY4Pr16/Dw8MDbdu2RWpqKuzt7dGuXTuoqanByMgIV65cwZo1axAfHw97e3usXLkS7u7uAICRI0fCz88PderUQWJiInx9fWX3+H9p6tSpGDx4MKpUqYJPnz4hPDwcDg4Oee77ey1ZsgQTJkzA48eP4erqihMnTkBLSwvA5/ugL1++jJkzZ6Jx48YQBAGOjo7o06dPnn126dIFkyZNws8//4zU1FR06NABs2fPxty5c2VtevTogaNHj6J58+aIjY3Frl27MGTIEOzcuRPDhg1DnTp14OTkhGXLlqFNmzZfPY4FCxbAwsIC3t7eePbsGUxMTFCrVi3MmDHju96fr5k/fz5Gjx4NR0dHpKamfnX4eJYRI0ZAT08Py5cvx/Tp06Gvr4/q1avLzdP0X/k9xgEDBmDcuHEYNGgQdHV1ZdslEgnOnDmDmTNnYtiwYXj37h2srKzQpEkTuX9zhc3IyAgnT57E2LFjUaNGDVSvXh1z5sxB//795e6jz4+NGzeiUqVKRX6VPDU1Fd26dcOTJ08AfF4ikfKWnJyM/v374/jx4wA+F9z/vV05r3/LWaNxsrRq1SrX22xq1Kgh97h58+Zyyyd+KWukUZYmTZrILe35pf+OWGnYsCHs7e1zbPvlbU4AUL9+/VzrwVKlSsk9rlu3LvT09LK1y++XgYoiEfL7/2hKIioqCnXq1MH58+dlV9qbNWuGGjVqyK1DmpSUhNevX+P9+/fYtm0bLl26hNu3b8PCwiLHfnO6Mm9nZ4e4uLgiGRJERERElBc/Pz80b94cHz9+lLtfmkgRDhw4gKFDhyIuLk7uCwdlIAgCBg0ahP3790NHRwfHjh3jxHpf8fbtW3Tq1An//PMPtLW1sW/fPvTq1UvsWJSD+Ph4GBsb56sOVbkr83fv3sXbt29Ru3Zt2bbMzExcuXIFGzZsQGpqKtTV1aGvr48KFSqgQoUKqF+/PipWrIgdO3bA09Mzx361tbULPAELEREREVFxsHfvXpQvXx5lypTBvXv34OHhgd69eytdIQ98HgGxf/9+qKur48SJE2jdurXYkZTau3fv4ObmhmfPnsHU1BTHjx9Ho0aNxI5FhUDlivmWLVsiODhYbtvQoUPh7OwMDw+PXO9LEwQh13s6iIiIiIhKsujoaMyZMwfR0dGwtrZGr169sGjRIrFjZXP48GF4eXkB+Dyk/8tC/vr16/j7778xf/58seIpJXNzczRs2BCCIODs2bNwcnISOxIVEpUbZp+TL4fZJyUlYdGiRejcuTOsra3x4cMHbNy4Efv378fdu3dRtWrVfPVZkOENRERERERU9F6+fIlOnTqhZcuWWL58uWx7VFQUypUrJxuxmzWpW0n25ZKDaWlpiIuL4zLdKqAgdej3z8qiZNTV1fHo0SP06NEDlSpVQseOHfHu3TtcvXo134U8EREREREpnzJlyuDatWtYsmSJ3HY7OzuMHDkSADBx4sRcl0wrKdatW4fevXvLlmXU0tJiIV8MFYsr80WBV+aJiIiIiMT38eNHXL169aurYbx79w4VKlRAfHy8bPWFkkYqlWLq1KlYvXo1gM/ru3OiO9VSoq/MExERERFR8ZCWloYePXqgS5cu+O233/JsW7p0acyePRsA4OnpicTEREVEVBqfPn1C7969ZYX8kiVL5NZOp+KHxTwRERERESkdQRAwZswY+Pr6wtDQMF/3wf/yyy9wdHREdHR0tqH4xdmHDx/QqlUr/Pnnn9DS0sLBgwfh4eEhu2eeiicW80REREREpHSWLFmCXbt2QU1NDYcOHYKLi8tXX6OtrY0VK1YAAFasWIGoqKiijim6Z8+eoUGDBrhx4wZMTExw/vx59OvXT+xYpAAqtzQdEREREREVb4cPH8aMGTMAAOvXr4e7u3u+X9ulSxcMGDAAbdq0QZkyZYoqotJ4+/YtIiMjUbZsWZw9exZVqlQROxIpCCfAywUnwCMiIiIiUrxbt26hefPmSElJwcSJE2X3gFPuLly4gGrVqsHa2lrsKPSdOAEeERERERGppEuXLiElJQWdOnWSDZn/HklJScVuqbotW7YgMDBQ9rh169Ys5EsgFvNERERERKQ0ZsyYgT/++AMHDx6Eurr6d/V16NAhVKpUCfv37y+kdOKSSqXw8PDAmDFj0L59e7x//17sSCQiFvNERERERCSq9PR0pKSkyB736tULBgYG391vREQEXr16BU9PTyQlJX13f2JKTU3FgAEDsGzZMgDAuHHjYGZmJnIqEhOLeSIiIiIiEo0gCPjpp5/QqlWrQr/SPGHCBJQrVw6vXr2SFcGq6OPHj2jTpg18fHygoaGBPXv2YNasWVx6roRjMU9ERERERKJZsWIFtm/fjhs3buDOnTuF2reOjg6WL18OAFi2bBkiIyMLtX9FeP78ORo2bIgrV67AyMgI586dw6BBg8SORUqAxTwREREREYni6NGj8PDwAACsXr0a7dq1K/R9dO/eHU2aNEFKSgo8PT0Lvf+iNmfOHISEhKBMmTK4du0aWrZsKXYkUhIs5omIiIiISOH8/f3x448/QhAEjBs3DuPHjy+S/UgkEqxevRoSiQQHDx7EzZs3i2Q/RWXDhg0YOHAgbt26herVq4sdh5QIi3kiIiIiIlKo58+fo1OnTvj06RPc3d2xZs2aIr3/u1atWhg6dCgA4Pz580W2n8Jy9epVCIIAADA0NMTevXtha2srcipSNizmiYiIiIhIoQYPHow3b97AxcUFhw4dgoaGRpHvc9GiRbh27Rq8vLyKfF/fShAEzJw5E02aNMHSpUvFjkNKruj/1RAREREREX1hy5YtGDlyJA4cOABDQ0OF7NPKygpWVlYK2de3SEtLw/Dhw7F//34AkFuqjygnLOaJiIiIiEihnJyccPnyZdGWVouMjMTdu3fRrVs3Ufb/X7GxsejevTt8fX2hrq6OrVu3YtiwYWLHIiXHYp6IiIiIiIrcxo0bUbFiRbRu3RoARCvkHz58iNq1a0NNTQ2hoaGi34seFRUFd3d3PHjwAAYGBjhy5Ajatm0raiZSDbxnnoiIiIiIitTx48fx888/w93dHf/++6+oWSpXrozatWsjOTkZM2bMEDVLcnIyGjVqhAcPHsDa2hpXrlxhIU/5xmKeiIiIiIiKzN27d9G/f38IgoARI0aIvryaRCLBmjVrAAD79u3DP//8I1oWPT09zJgxA1WrVsWtW7dQs2ZN0bKQ6pEIWWsekJz4+HgYGxsjLi4ORkZGYschIiIiIlI5UVFRqFevHl6/fo02bdrg1KlT0NTUFDsWAGDIkCHYs2cP3NzccP36dYUO+09KSoK+vr7scUpKCnR0dBS2f1JeBalDeWWeiIiIiIgKXUJCAjp16oTXr1+jatWq+OOPP5SmkAeAxYsXQ09PDzdv3sShQ4cUsk9BEDBv3jzUqlULHz58kG1nIU/fgsU8EREREREVqoyMDPTr1w/37t2DhYUFTp8+DWNjY7FjybGxsYGnpycAYPr06fj06VOR7i89PR3Dhw/H3LlzERYWhmPHjhXp/qj4YzFPRERERESFSiqVonTp0tDR0cGJEydgb28vdqQcTZkyBZUqVcKgQYNQlHcfx8fHo0OHDti1axfU1dWxZcsWjBgxosj2RyUD75nPBe+ZJyIiIiL6doIgIDQ0FM7OzmJHyVN6enqRDv9/+fIlOnTogHv37kFPTw+HDx9G+/bti2x/pNp4zzwRERERESnc/fv3kZmZCeDzrPHKXsgDkCvkC/s656NHj1C/fn3cu3cPlpaWuHz5Mgt5KjQs5omIiIiI6Lvdu3cPbm5u6NatG5KSksSOU2A3b95EgwYNcOfOnULr09TUFFpaWnB2dsbNmzdRp06dQuubiMU8ERERERF9l1evXqFjx45ITExEcnIytLS0xI5UYBs3bsStW7cwceLEQrtCb2FhgfPnz+P69esoV65cofRJlIXFPBERERERfbOkpCR06tQJL168gLOzM44cOaJUS9Dll7e3N3R1dXH9+nUcOXLkm/oQBAGLFy/Grl27ZNscHR1hampaWDGJZFjMExERERHRN8nMzMSAAQMQEBCA0qVL4/Tp0zAxMRE71jextbWFh4cHAGDatGlISUkp0OszMjIwZswYzJw5E6NGjUJYWFhRxCSSYTFPRERERETfZPr06Th+/Di0tbVx/PhxlC9fXuxI32XatGmwtbXF8+fPsXr16ny/LjExEV26dMHWrVshkUiwevVqVKpUqQiTErGYJyIiIiKibxAREYFNmzYBAPbs2QM3NzeRE30/PT09eHt7AwAWL16M169ff/U10dHRaNq0Kc6cOQNdXV0cO3YMP//8c1FHJWIxT0REREREBefg4IArV65g7dq16NOnj9hxCk3//v1Rt25dJCYmYsuWLXm2DQkJQf369WW3Gfj6+qJLly4KSkolnYbYAYiIiIiISHUIggCJRAIAqFOnTrFbbk1NTQ3r1q1DSEgIBg0alGfbEydO4Pnz56hYsSLOnj0LR0dHBaUkYjFPRERERET5FB0dja5du2LDhg3Froj/Ur169VCvXr2vtps+fTokEgmGDRsGc3NzBSQj+j8cZk9ERERERF+VnJyMzp074/bt2xg5ciSkUqnYkRQiKSkJDx48APB5VMKePXuQlJQEAJBIJJg+fToLeRKFyhfz3t7ekEgkmDhxIgAgPT0dHh4eqF69OvT19WFjY4NBgwbh1atX4gYlIiIiIlJRUqkUAwcOhL+/P0xNTfHHH39ATU3lS4mvCgoKgpOTEzp16oTk5GT8/PPPGDJkCPr161divswg5aXSw+z9/f2xdetWuLi4yLYlJycjICAAs2fPhqurKz5+/IiJEyeic+fOuHPnjohpiYiIiIhU06+//oqjR49CS0sLf/31FypWrCh2JIWoUKECBEFAeHg4qlatioiICEgkErRo0aJEfJlByk1li/nExEQMGDAA27Ztw8KFC2XbjY2NceHCBbm269evR926dREZGYmyZcvm2F9qaipSU1Nlj+Pj44smOBERERGRCtm2bRuWL18OANixYwcaN24sciLFMTAwgLe3NwYPHoyIiAjo6Ohg//796NGjh9jRiFR3mP24cePQoUMHtGrV6qtt4+LiIJFIYGJikmsbb29vGBsby37s7OwKMS0RERERkeq5du0afvrpJwCAl5cXfvzxR5ETKd6PP/6Ijh07wt7eHhcvXmQhT0pDJa/M+/j4ICAgAP7+/l9tm5KSgl9//RX9+/eHkZFRru08PT0xefJk2eP4+HgW9ERERERUotWoUQPu7u4wMjKCl5eX2HFEoaamhhMnTgCAbEk+ImWgcsV8VFQUJkyYgPPnz0NHRyfPtunp6ejbty+kUik2btyYZ1ttbW1oa2sXZlQiIiIiIpVmYGCAY8eOISMjo0QXsiX52El5qdww+7t37+Lt27eoXbs2NDQ0oKGhgcuXL2PdunXQ0NBAZmYmgM+FfO/evREeHo4LFy7keVWeiIiIiIg++/TpE3bt2gVBEAAA6urqvOhFpIRU7sp8y5YtERwcLLdt6NChcHZ2hoeHB9TV1WWF/OPHj+Hr6wszMzOR0hIRERERqQ6pVIohQ4bgjz/+wL1797BmzRqxIxFRLlSumDc0NES1atXktunr68PMzAzVqlVDRkYGevbsiYCAAJw6dQqZmZmIjo4GAJiamkJLS0uM2ERERERESm/27Nn4448/oKmpiW7duokdh4jyoHLF/Ne8ePFCNkFFjRo15J7z9fVFs2bNFB+KiIiIiEjJ7dq1C4sXLwbweTm6pk2bipyIiPJSLIp5Pz8/2X87ODjI7u8hIiIiIqKv8/X1xahRowAAM2fOxODBg0VORERfo3IT4BERERERUeF59OgRunfvjoyMDPTp0wfz588XOxIR5QOLeSIiIiKiEiwoKAgJCQlwc3PD7t27oabGEoFIFRSLYfZERERERPRt+vbtC0tLS1SrVg06OjpixyGifGIxT0RERERUwgiCgPj4eBgbGwMAmjdvLnIiIioojqEhIiIiIiph5s2bh9q1ayM0NFTsKET0jVjMExERERGVIPv378e8efPw9OlT3Lx5U+w4RPSNWMwTEREREZUQV69exfDhwwEAHh4eGDJkiLiBiOibsZgnIiIiIioBHj9+jK5duyItLQ09e/bE4sWLxY5ERN+BxTwRERERUTEXExODDh06ICYmBnXr1sXevXu5BB2RiuO/YCIiIiKiYm7y5Ml4/Pgx7O3tceLECejq6oodiYi+E5emIyIiIiIq5lasWIH3799jyZIlsLS0FDsOERUCFvNERERERMWcubk5Tp06JXYMIipEHGZPRERERFQM+fj4YNu2bWLHIKIiwivzRERERETFzPXr1zF48GCkpaXB2toaHTt2FDsSERUyXpknIiIiIipGnj59KluCrkuXLnB3dxc7EhEVARbzRERERETFxMePH9GhQwe8f/8etWvXxoEDB6Curi52LCIqAizmiYiIiIiKgbS0NPTo0QOhoaGwtbXFiRMnoK+vL3YsIioiLOaJiIiIiFScIAgYM2YMfH19YWBggFOnTsHGxkbsWERUhFjMExEREREVAxUqVIC6ujoOHToEV1dXseMQURGTCIIgiB1CGcXHx8PY2BhxcXEwMjISOw4RERER0Vc9ffoUjo6OYscgom9UkDqUV+aJiIiIiFTUgwcPkJiYKHvMQp6o5GAxT0RERESkgiIiItCiRQs0adIE0dHRYschIgVjMU9EREREpGJiY2PRoUMHvH37FoIgwMDAQOxIRKRgLOaJiIiIiFRIeno6evfujYcPH8LGxgYnT55kMU9UArGYJyIiIiJSEYIg4Oeff8aFCxegr6+PU6dOwdbWVuxYRCQCFvNERERERCpi5cqV2Lp1K9TU1PD777+jZs2aYkciIpGwmCciIiIiUgEJCQlYvXo1AGDVqlXo1KmTyImISEwaYgcgIiIiIqKvMzQ0xM2bN+Hj44Px48eLHYeIRCYRBEEQO4Qyio+Ph7GxMeLi4mBkZCR2HCIiIiIqoQRBgEQiETsGESlAQepQDrMnIiIiIlJS8fHxaNCgAf766y+xoxCRkmExT0RERESkhDIyMtCnTx/cunUL48aNQ3JystiRiEiJsJgnIiIiIlIygiBgwoQJOHfuHHR1dXH8+HHo6emJHYuIlAiLeSIiIiIiJbNu3Tps3LgREokEBw8eRJ06dcSORERKhsU8EREREZESOXnyJCZNmgQAWL58Obp27SpuICJSSipfzHt7e0MikWDixImybUePHkXbtm1hbm4OiUSCoKAg0fIREREREeVXWFgY+vXrB0EQMGrUKEyePFnsSESkpFS6mPf398fWrVvh4uIitz0pKQkNGzbEkiVLREpGRERERFRwjo6OGDFiBFq3bo0NGzZwSToiypWG2AG+VWJiIgYMGIBt27Zh4cKFcs8NHDgQABAREZHv/lJTU5Gamip7HB8fXyg5iYiIiKho7N27F0eOHMnxuSpVqshd2Bk0aBBiY2NzbOvo6IjVq1fLHo8aNQrR0dE5ti1Tpgw2bdoke/zLL7/g+fPnObY1NzfHzp07ZY+nTp2KsLCwHNsaGhriwIEDUFdXx5o1a5CWlgZNTc0c2xIRASpczI8bNw4dOnRAq1atshXz38Lb2xvz5s0rhGREREREVNSSk5MxevRopKSk5Pj8x48f5R6fP38eb968ybFtrVq15B5fvHgRz549y7Gtk5OT3GM/Pz/cv38/x7a2trZyj69du4bbt2/n2NbU1FTusZaWVo7tiIiyqGQx7+Pjg4CAAPj7+xdan56ennL3JMXHx8POzq7Q+iciIiKiwqOpqYmjR49i8eLFGDRoULbh6JaWlnKPV65ciU+fPuXYl5mZmdzjxYsXIyEhIce2xsbGco/nzp2b7YuDLPr6+nKPPT098e7duxzbamtr57idiCg3EkEQBLFDFERUVBTq1KmD8+fPw9XVFQDQrFkz1KhRA2vWrJFrGxERgXLlyiEwMBA1atQo0H7i4+NhbGyMuLg4GBkZFVJ6IiIiIiIiopwVpA5VuSvzd+/exdu3b1G7dm3ZtszMTFy5cgUbNmxAamoq1NXVRUxIREREREREVLRUrphv2bIlgoOD5bYNHToUzs7O8PDwYCFPREREVMyFh4dj06ZN6NixI5o0aSJ2HCIiUahcMW9oaIhq1arJbdPX14eZmZlse0xMDCIjI/Hq1SsAQGhoKADAysoKVlZWig1MRERERIXq1KlTWL58Oe7cuYNLly6JHYeISBQqvc58bk6cOIGaNWuiQ4cOAIC+ffuiZs2a2Lx5s8jJiIiIiOh7nT17FgDg7u4uchIiIvGo3AR4isIJ8IiIiIiUz6dPn2BqaoqUlBQEBwdnG7FJRKTKClKHFssr80RERERUPF2+fBkpKSmwtbVF1apVxY5DRCQaFvNEREREpDK+HGL/37XliYhKEhbzRERERKQyeL88EdFnLOaJiIiISCV8+PABcXFx0NDQQMuWLcWOQ0QkqiJdmm7dunUFfs3QoUNhaGhYBGmIiIiISJWZmZnh9evXePz4MScoJqISr0hns1dTU4OtrS3U1dXz1T4qKgphYWEoX758UUXKN85mT0RERERERIpUkDq0SK/MA8CdO3dgYWGRr7a8Ik9EREREOZFKpZBIJJz0jojo/yvSe+a9vLxgYGCQ7/YzZsyAqalpESYiIiIiIlV04cIF2NjYwMPDQ+woRERKoUivzHt5eRWovaenZxElISIiIiJVdvbsWURHRyMmJkbsKERESqHIZ7O/dOkSMjIyino3RERERFSMcUk6IiJ5RV7Mt27dWu4b1Pr16+Ply5dFvVsiIiIiKiaePXuGsLAwLklHRPSFIi/m/ztZ/oMHD5CamlrUuyUiIiKiYiLrqnyDBg1gbGwschoiIuVQ5MU8EREREdH34BB7IqLsiryY/+8SIlxShIiIiIjyKyUlBZcuXQLAYp6I6EtFvs68IAho2bIlNDQ+7yo5ORmdOnWClpaWXLuAgICijkJEREREKubTp0/4+eefERAQABcXF7HjEBEpjSIv5v+7PF2XLl2KepdEREREVEyUKlUKy5YtEzsGEZHSkQj/naGOAADx8fEwNjZGXFwcjIyMxI5DRERERERExVxB6lBOgEdERERESunNmzc4e/YsPn36JHYUIiKlU+TF/Nu3bzFq1Cj07dsXDx48KOrdEREREVExcfToUbRv3x4dO3YUOwoRkdIp8mJ+6NChsLKyQrdu3eDu7p5t3XkiIiIiopxkLUnXsmVLkZMQESmfIi/mAwMD0adPH/Tu3RvR0dF49+5dUe+SiIiIiFRcamoql6QjIspDkc9m37VrV3h6esLe3h4uLi6wsLAo6l0SERERkYq7evUqkpKSYGVlhRo1aogdh4hI6RT5lfkNGzagT58+cHZ2ln27SkRERESUl6wh9u3atYNEIhE5DRGR8inyK/NqamoYMGBAUe+GiIiIiIqRrGKeQ+yJiHLGpemIiIiISKlERkYiJCQEampqaN26tdhxiIiUUpEW87Vq1cLHjx/z3b5Ro0Z4+fJlESYiIiIiImVnZ2eHBw8eYO/evShVqpTYcYiIlFKRDrMPCgrCvXv3YGpqmu/2qampRRmJiIiIiJScRCJBlSpVUKVKFbGjEBEprSK/Z75ly5b5Xluek5sQERERERERfV2RFvPh4eEFfo2trW0RJCEiIiIiVXDt2jVs2LABvXv3Rvfu3cWOQ0SktIq0mLe3ty/K7omIiIiomPnrr79w6NAh6OjosJgnIsoDZ7MnIiIiIqXBJemIiPKHxTwRERERKYXIyEg8fPiQS9IREeUDi3kiIiIiUgpZV+Xr16+f79WQiIhKKhbzRERERKQUOMSeiCj/FFrMx8bGYvv27fD09ERMTAwAICAgAC9fvvzmPr29vSGRSDBx4kTZNkEQMHfuXNjY2EBXVxfNmjXDgwcPvjc+ERERERWRtLQ0XLx4EQCLeSKi/FBYMf/vv/+iUqVKWLp0KVasWIHY2FgAwLFjx+Dp6flNffr7+2Pr1q1wcXGR275s2TKsWrUKGzZsgL+/P6ysrNC6dWskJCR872EQERERURF4/fo1KleuDCsrK9SsWVPsOERESk9hxfzkyZMxZMgQPH78GDo6OrLt7u7uuHLlSoH7S0xMxIABA7Bt2zaUKlVKtl0QBKxZswYzZ85E9+7dUa1aNezZswfJyck4ePBgoRwLERER5S4iIgL//POP2DFIxdjb2+Off/7B06dPoabGO0GJiL5GYf9P6e/vj9GjR2fbXqZMGURHRxe4v3HjxqFDhw5o1aqV3Pbw8HBER0ejTZs2sm3a2tpo2rQpbty4kWt/qampiI+Pl/sBgMuXL0MQhALnIyIiKqlat26NevXqYe7cufwdSgWmp6cndgQiIpWgsGJeR0dHViB/KTQ0FKVLly5QXz4+PggICIC3t3e257K+GLC0tJTbbmlpmeeXBt7e3jA2Npb92NnZAQA6d+6MYcOGIT09vUAZiYiISqLo6Gg8efIEADBv3jz+DqV8SUxMzPHvRCIiyp3CivkuXbpg/vz5sl/oEokEkZGR+PXXX9GjR4989xMVFYUJEyZg//79csP1/0sikcg9FgQh27YveXp6Ii4uTvYTFRUFAFBTU8Pu3bvRoUMH/pIhIiL6iqCgIACAoaGh7Hdonz59xA1FSu/333+HmZkZxo8fL3YUIiKVobBifsWKFXj37h0sLCzw6dMnNG3aFBUqVIChoSEWLVqU737u3r2Lt2/fonbt2tDQ0ICGhgYuX76MdevWQUNDQ3ZF/r9X4d++fZvtav2XtLW1YWRkJPcDAIcOHYK+vj4uXLiAxo0bf9fM+0RERMVd1uoxHTt2xIkTJ2BkZIThw4eLnIqU3dmzZ5GRkVHg0ZpERCWZRFDwzWyXLl1CQEAApFIpatWqle2e969JSEjA8+fP5bYNHToUzs7O8PDwQNWqVWFjY4NJkyZh+vTpAD4vdWJhYYGlS5fmeN9+TuLj42FsbIy4uDg8fvwYHTp0wJs3b2Bra4szZ86gevXqBcpNRERUEgiCgNevXyMlJQXly5fHx48f5SaqzcjIgIaGhogJSdmkpaXB3NwcCQkJ8Pf3R506dcSOREQkmi/r0KwLzLlRyG/TjIwM6OjoICgoCC1atECLFi2+uS9DQ0NUq1ZNbpu+vj7MzMxk2ydOnIjFixejYsWKqFixIhYvXgw9PT3079//m/ZZu3Zt3Lp1C+7u7nj06BEaN26MsLAwWFhYfPNxEBERFUcSiQQ2Njayx18W8s+ePUO7du2wefPm7/pbgIqXGzduICEhARYWFqhVq5bYcYiIVIZCinkNDQ3Y29sjMzNTEbvD9OnT8enTJ/z000/4+PEj6tWrh/Pnz8PQ0PCb+3RwcMCNGzfQtWtXtGnThoU8ERFRAS1cuBCPHz9Gu3btsGPHDgwcOFDsSKQEzp49CwBo27Ytl6QjIioAhQ2z37VrFw4fPoz9+/fD1NRUEbv8LrkNb0hLS4OmpqZsMr2EhAQYGBjkObkeERFRSXDnzh3Mnz8fLVq0wMSJE7M9n5KSgiFDhuDQoUMAPhf3M2bM4O/QEs7FxQXBwcE4cODAN4+iJCIqLpRumD0ArFu3Dk+ePIGNjQ3s7e2hr68v93xAQICionwXLS0t2X8nJiaiWbNmqF27NjZu3Mh7AImIqES7desWTp48CalUmmMxr6Ojg4MHD8Le3h7Lli3DrFmzEBERgY0bN0JTU1PxgUl0L168QHBwMCQSCdq0aSN2HCIilaKw6rNr166K2pXC+Pr6IigoCAEBAXjx4gX++OMPGBgYiB2LiIhIFIGBgQCAmjVr5tpGTU0NS5cuRdmyZTF+/Hhs374dL168wOHDh/k7tATS19fHhg0b8OzZM5ibm4sdh4hIpSh8NntVkd/hDcePH0e/fv3w6dMn1KpVC6dOnYK1tbUCkxIRESmH2rVrIyAgAH/++Se6d+/+1fYnTpxA3759Ub16dfj6+kJPT08BKYmIiJRXQYbZs5jPRUHexNu3b6NTp0549+4d7O3tcebMGVSpUkVBSYmIiMSXnp4OAwMDpKWl4enTpyhfvny+Xufv7w97e3tOLEtERISC1aEKmzJUTU0N6urquf6osnr16uHmzZuoWLEinj9/joYNG+LGjRtixyIiIlKYkJAQpKWlwcjICOXKlcv363744Qe5Qn758uW4fPlyUUQkJRMcHIzNmzcjMjJS7ChERCpJYffMHzt2TO5xeno6AgMDsWfPHsybN09RMYqMo6Mjbty4gS5duuDZs2coU6aM2JGIiIgUJut++Ro1anzz7PQnTpzA9OnToaWlhT179qBv376FGZGUzIEDB7B06VIMGDAA+/fvFzsOEZHKUVgx36VLl2zbevbsiapVq+LQoUMYPny4oqIUGXNzc/zvf/9DZGQk7O3txY5DRESkMDExMdDT08tz8ruvad26Nbp3746jR4+iX79+iIyMxLRp07h0XTGVtb68u7u7yEmIiFST6PfMP336FC4uLkhKShIzRjYFuVchL8ePH8eFCxewZs0aLl1HRETFWmZmJj59+vRds9JnZmZi6tSpWLNmDQBg7NixWLduHX+HFjMvX76Era0tJBIJ3r59y5nsiYj+P6W8Zz4nnz59wvr162FraytmjCLz7t07DBgwAL/99hu6d++udF9YEBERFSZ1dfXvXl5OXV0dq1evxurVqyGRSLBp0yb+Di2Gzp07B+DznAks5ImIvo3CivlSpUrB1NRU9lOqVCkYGhpi586dWL58uaJiKFTp0qWxZ88e6Ojo4OTJk2jevDnevHkjdiwiIiKlN3HiRBw+fFj2O/TChQtiR6JCxCH2RETfT2HD7Hfv3i13z5uamhpKly6NevXqoVSpUoqIUCCFNcweAG7cuIHOnTvjw4cPKFeuHM6ePQsnJ6dCSkpERCSuv/76CzNmzEDPnj0xf/78Qu37xo0buHnzJqZMmVKo/ZJ40tPTYW5ujvj4eNy6dQv16tUTOxIRkdIoSB2qsBvQWrRoATs7uxwnsYmMjETZsmUVFUXhGjRogBs3bsDd3R3Pnj1DgwYNcOLECTRs2FDsaERERN/t7t27CAkJwatXrwq97wYNGqBBgwayx2/fvsXTp0/h5uZW6PsixXj48CGSkpJgZmaGOnXqiB2HiEhlKWyYfbly5fDu3bts27OuVhd3lSpVws2bN1G3bl3ExMTgzz//FDsSERFRofhyWbqilJSUhI4dO6J58+Y4cuRIke6Lio6rqyvev3+P06dPQ11dXew4REQqS2HFfG6j+RMTE6Gjo6OoGKKysLDApUuXsHTp0mI7TwAREZU8WcX89yxLlx8SiQQ2NjZITU1F7969sXr16iLdHxUdExMTDq8nIvpORX7P/OTJkwEAa9euxciRI6Gnpyd7LjMzE7dv34a6ujquX79elDEKrDDvmc9LWloatm/fjtGjR/PbaSIiUjlv376FpaUlJBIJ4uLiYGhoWKT7y8zMxIQJE/Dbb78BACZMmICVK1fydygRERULSrU0XWBgIAIDAyEIAoKDg2WPAwMD8ejRI7i6umL37t1FHUNpjRkzBuPGjUOvXr2QnJwsdhwiIqICCQoKAgBUqFChyAt54PPSdevXr5eNcFu7di169eqFT58+Ffm+6fvt3bsXbm5u2LVrl9hRiIhUXpFPgOfr6wsAGDp0KNauXVukV7lVUdu2bXHgwAEcO3YMLVu2xIkTJ1C6dGmxYxEREeVLVjFf1EPsvySRSDB16lTY2dlh0KBBOHbsGEaPHo29e/cqLAN9m1OnTuHWrVto06aN2FGIiFSewu6Z37VrFwv5HPTp0wf/+9//UKpUKdy6dQsNGjTAkydPxI5FRESUL4aGhqhevTp++OEHhe+7T58+uHDhApydnTF37lyF758KJiMjAxcuXAAAtGvXTuQ0RESqT2HrzAOAv78/Dh8+jMjISKSlpck9d/ToUUXFyBdF3TOfJSQkBO3bt0dERATMzc1x8uRJ1K9fv8j3S0REpOoyMzPl7pn/8OEDzMzMRExEObl27RoaN24MU1NTvH37lvMcEBHlQKnumc/i4+ODhg0b4uHDhzh27BjS09Px8OFDXLp0CcbGxoqKobQqV66Mmzdvonbt2nj//j26du3K+/+IiIjy4cui8NSpU3BwcMCxY8dETEQ5OXv2LACgTZs2LOSJiAqBwor5xYsXY/Xq1Th16hS0tLSwdu1ahISEoHfv3ihbtqyiYig1Kysr+Pn5oWvXrti/fz90dXXFjkRERJSrlJQUZGRkiB1Dzr59+5CYmIgePXpg/fr1YsehL5w7dw4A4O7uLnISIqLiQWHF/NOnT9GhQwcAgLa2NpKSkiCRSDBp0iRs3bpVUTGUnoGBAY4dO4ZWrVrJtj19+hRSqVTEVERERNnt2rULhoaGmDhxothRZA4cOIDRo0dDEASMHz8eU6dO5e9QJRAdHY2AgAAAnyf/JSKi76ewYt7U1BQJCQkAgDJlyuD+/fsAgNjYWC7JlofQ0FD88MMP6NevH1JSUsSOQ0REJBMYGIiUlBTo6emJHUVGQ0MDmzZtwuLFiwEAK1euRN++ffk7VGRZoyVatGgBS0tLseMQERULCivmGzduLJvBtHfv3pgwYQJGjhyJfv36oWXLloqKoXIePHiAxMRE/PHHH2jdujViYmLEjkRERARAnGXp8kMikcDT0xP79++HpqYmDh8+jNatW/PigYgqVKiAI0eO4OLFi2JHISIqNhQ2m31MTAxSUlJgY2MDqVSKFStW4Nq1a6hQoQJmz56NUqVKKSJGvil6Nvu8+Pr6olu3boiLi4OTkxPOnj2LcuXKiZqJiIhKtoyMDBgaGiIlJQVhYWGoWLGi2JFylPU7tF+/fti4cSMkEonYkYiIiHJVkDpUIcV8RkYGDhw4gLZt28LKyqqod1colKmYB4D79++jffv2iIqKgoWFBU6fPo06deqIHYuIiEqo+/fvo3r16jA0NERsbCzU1BQ22K/Anj59Cnt7e2hoaIgdpUR68eIFkpKSUKlSJX6ZQkT0FUq3NJ2GhgbGjh2L1NRUReyuWKpWrRpu3bqFGjVq4O3bt2jatCn++ecfsWMREVEJlTXE3tXVVakLeQBwdHSUFfLp6eno2bMnTp06JXKqkmPLli1wdnbGL7/8InYUIqJiRWG/fevVq4fAwEBF7a5YsrGxwZUrV9C2bVvUqlULLi4uYkciIqISKut3eo0aNcQNUkCbNm3Cn3/+iS5dumDLli1ixykRstaX54hCIqLCpbDxZj/99BOmTJmCFy9eoHbt2tDX15d7noVp/hgaGuLkyZNITk6Gjo4OAMiW3FH2KyNERFR81KxZE926dUOzZs3EjlIgY8eORVBQEHbt2oUxY8YgIiICixYt4u/QIvLmzRvcvXsXANCuXTuR0xARFS8KmwAvp1+SEokEgiBAIpEgMzNTETHyTdnumc/Lr7/+iqioKOzcuRPa2tpixyEiIlJqgiBgwYIF8PLyAgD079+fv0OLyN69ezF48GDUrFlTts48ERHlriB1qMKuzIeHhytqVyVKWFgYVq5ciYyMDLx69QrHjh2DiYmJ2LGIiIiUlkQiwZw5c2Bvb48RI0bg4MGDePnyJY4dO6Z0q+uouqwh9u7u7iInISIqfhR2ZV7VqNKV+fPnz6Nnz55ISEhAlSpVcPbsWZQtW1bsWEREVExFR0cjLS0NdnZ2Kj87+YULF9CjRw8IgoBr167B1dVV7EjFRmZmJiwsLBATE4OrV6+iUaNGYkciIlJ6SjebfZZ9+/ahYcOGsLGxwfPnzwEAa9aswfHjxxUZo9hp06YNrl69ijJlyuDhw4eoX7++bJZhIiKiwrZp0ybY29tj3LhxYkf5bq1bt8a1a9dw7NgxFvKF7J9//kFMTAxMTExQv359seMQERU7CivmN23ahMmTJ6N9+/aIjY2V3SNvYmKCNWvWKCpGseXq6opbt26hevXqeP36NRo3boxz586JHYuIiIqhrC+MnZ2dxQ1SSFxcXNCqVSvZ45s3b/J3aCFwdXXFyZMnsWLFCtnSgEREVHgUVsyvX78e27Ztw8yZM6Guri7bXqdOHQQHBysqRrFma2uLq1evomXLlkhMTERsbKzYkYiIqBhS1WXp8iMiIgKdOnVCx44dsWPHDrHjqDQ9PT107NgRw4cPFzsKEVGxpLBiPjw8HDVr1sy2XVtbG0lJSQXqa9OmTXBxcYGRkRGMjIzg5uYmm2AF+LwMypAhQ2BjYwM9PT20a9cOjx8//u5jUAXGxsY4c+YMTp8+jb59+4odh4iIipkPHz4gKioKAIrlsHQbGxu0b98emZmZGDFiBObMmQNOL0RERMpIYWOeypUrh6CgINjb28ttP3v2LKpUqVKgvmxtbbFkyRJUqFABALBnzx506dIFgYGBqFKlCrp27QpNTU0cP34cRkZGWLVqFVq1aoWHDx9mW9++ONLS0kL79u1lj1+9eoVVq1Zh3rx5OQ5z+3IpnrS0tDz/aPmybXp6umyN+9xyZE2MpAxtMzIy8lwCUVNTU7aEYlZbDQ0NuZEkREQlXdYQ+/Lly8PY2FjcMEVAS0sLe/bsgb29PRYuXIgFCxbg+fPn2LhxI7S1tWW/RwVBQFpaWq79qKmpQVNTU2naAkBqamqubSUSCbS0tAqt7YULF3Djxg307NkTtWrVyrUvIiL6DoKC7Ny5UyhTpozg4+Mj6OvrC7///ruwcOFC2X9/r1KlSgnbt28XQkNDBQDC/fv3Zc9lZGQIpqamwrZt23J9fUpKihAXFyf7iYqKEgAIcXFx351NTJmZmUKdOnUEADn+mJmZybVv1qxZrm11dXXl2nbo0CHXtgAEqVQqa9urV6882yYkJMjaDhkyJM+2b968kbUdN25cnm2fPXsmaztt2rQ82wYHB8vazp07VwAgGBkZCQEBAYX2eRARqboVK1YIAIQePXqIHaXIbd26VVBXV5f9npg+fbrsuWfPnuX5O2XcuHGyttHR0Xm2HTJkiKxtQkJCnm179+4tayuVSvNs26FDB7nj0dHRybVts2bN5NqamZnl2rZu3bpybcuWLZtrW09Pz0L5LIiISoq4uLh816EKG2Y/dOhQeHl5Yfr06UhOTkb//v2xefNmrF279ruGg2dmZsLHxwdJSUlwc3OTfTuso6Mja6Ourg4tLS1cu3Yt1368vb1hbGws+7Gzs/vmTMpETU0N8+fPh5mZmdhRVFJ8fDx++eUXDrEkIvr/su6Xz+nWueJm5MiROHnyJH+HfiMDAwMMGDBA7BhERMWWKOvMv3//HlKpFBYWFt/cR3BwMNzc3JCSkgIDAwMcPHgQ7du3R3p6OipWrIi6detiy5Yt0NfXx6pVq+Dp6Yk2bdrg77//zrG/1NRUuWFi8fHxsLOzU4l15vMjIyMDycnJ2bZLJBIYGhrKHiclJeU5FP3L9yI5ORkZGRm5tjU0NJQNcS9I20+fPiE9PT3XtgYGBrLh8AVpm5KSkudwRH19fdmQ+tTUVERGRqJGjRpITk7GoUOH0Lt371xfS0RUUpw9exa+vr7o0aMH6tWrJ3Ychcj6HaqlpSW7WCCVSpGYmJjrazQ1NaGrq1vgtoIgICEhIde2Ghoa0NPTK3Bb4PPfNrlRV1eXuxUxISEh1y+y89tWR0dHbjg+ERF9XUHWmVd4Mf/27VuEhoZCIpHAyckJpUuX/qZ+0tLSEBkZidjYWPz555/Yvn07Ll++jCpVquDu3bsYPnw47t27B3V1dbRq1UpW0J05cyZf/RfkTaTia/78+fDy8oK9vT1CQkJkf2wREREREREVtoLUoQobZh8fH4+BAwfCxsYGTZs2RZMmTWBjY4Mff/wRcXFxBe5PS0sLFSpUQJ06deDt7Q1XV1esXbsWAFC7dm0EBQUhNjYWr1+/xrlz5/DhwweUK1eusA+LirmpU6fC1tYWz58/x+rVq8WOQ0REREREBECBxfyIESNw+/ZtnD59GrGxsYiLi8OpU6dw584djBw58rv7FwQh22yqxsbGKF26NB4/fow7d+6gS5cu370fKln09PSwdOlSAMCWLVvyHNJPRFTc/fvvv7h06RI+fvwodhQiIqIST2FL050+fRp///03GjVqJNvWtm1bbNu2De3atStQXzNmzIC7uzvs7OyQkJAAHx8f+Pn54dy5cwCAw4cPo3Tp0ihbtiyCg4MxYcIEdO3aFW3atCnUY6KSoV+/fnj16hWGDRsmt8QPEVFJs2nTJmzevBnTp0+XfdFJRERE4lBYMW9mZpbjerTGxsYoVapUgfp68+YNBg4ciNevX8PY2BguLi44d+4cWrduDQB4/fo1Jk+ejDdv3sDa2hqDBg3C7NmzC+U4qOSRSCSYOnWq2DGIiERXkmayJyIiUnYKmwBv69atOHz4MPbu3Qtra2sAQHR0NAYPHozu3btj9OjRioiRb5wAj3IiCAKuXLmCJk2ayGbfJyIqCTIzM2FoaIhPnz7h0aNHcHJyEjsSERFRsaOUs9nXrFkTT548QWpqKsqWLQsAiIyMhLa2NipWrCjXNiAgQBGR8sRinv5LEAR06dIFJ0+exJEjR9CjRw+xIxERKUxISAiqVKkCPT09xMfHy5byJCIiosJTkDpUYcPsu3btqqhdERUJiUSCmjVr4uTJk5g2bRo6dOggW2+YiKi4CwoKAgC4urqykCciIlICCivmvby8FLUroiIzffp0bN++HeHh4Vi7di08PDzEjkREpBBZ98vXqFFD3CBEREQEQIFL030pMTER8fHxcj9EqkBfXx9LliwBACxatAhv3rwRORERkWJkXZnn5HdERETKQWHFfHh4ODp06AB9fX3ZDPalSpWCiYlJgWezJxLTgAED8MMPPyAhIYGrJBBRibFs2TJs2bIFrVq1EjsKERERQYET4DVo0AAAMGHCBFhaWmabCbxp06aKiJFvnACP8nLjxg00bNgQEokEAQEBHHZKRERERETfTSknwPv3339x9+5dLmVDxUKDBg3Qt29fBAUFITk5Wew4RERERERUwiismP/hhx8QFRXFYp6KjY0bN8LAwACamppiRyEiKlJnzpzBixcv0KJFC1SoUEHsOERERAQFFvPbt2/HmDFj8PLlS1SrVi1bAeTi4qKoKESFgnM9EFFJsX37dhw7dgyrVq3CpEmTxI5DREREUGAx/+7dOzx9+hRDhw6VbZNIJBAEARKJBJmZmYqKQlSo0tLSsGHDBujq6mLs2LFixyEiKnRclo6IiEj5KKyYHzZsGGrWrInff/89xwnwiFTV0aNHMWXKFBgZGaFHjx6wsLAQOxIRUaH5+PEjIiIiALCYJyIiUiYKm81eX18f9+7dU5l77TibPeWXVCrFDz/8gICAAIwePRqbN28WOxIRUaHx8/ND8+bN4eDggPDwcLHjEBERFWsFqUMVts58ixYtcO/ePUXtjkhh1NTUsGbNGgDAtm3b8O+//4obiIioEHGIPRERkXJS2DD7Tp06YdKkSQgODkb16tWzTYDXuXNnRUUhKnSNGzdGr169cPjwYUyePBkXLlzgrSREVCwEBQUBAGrWrCluECIiIpKjsGH2amq5DwJQxgnwOMyeCio8PByVK1dGamoqjh8/zi+oiKhYcHFxQXBwMP9/jYiISAGUcpi9VCrN9UfZCnmib1GuXDlMnjwZAODh4QGpVCpyIiKi7+fr64uLFy+icePGYkchIiKiLyhsmP2XUlJSoKOjI8auiYqUp6cnnj9/jpkzZ+Y5GoWISFWYmZmhRYsWYscgIiKi/1BYtZGZmYkFCxagTJkyMDAwwLNnzwAAs2fPxo4dOxQVg6hIGRoa4sCBA6hSpYrYUYiIiIiIqBhTWDG/aNEi7N69G8uWLYOWlpZse/Xq1bF9+3ZFxSBSqDdv3ogdgYjom/3222+YNm0aAgICxI5CRERE/6GwYn7v3r3YunUrBgwYAHV1ddl2FxcXPHr0SFExiBQiMzMTY8eORdmyZXH//n2x4xARfZODBw9ixYoVCAkJETsKERER/YfCivmXL1+iQoUK2bZLpVKkp6crKgaRQqirq+Pt27dIS0vD5MmToaBFI4iICo1UKsW9e/cAcFk6IiIiZaSwYr5q1aq4evVqtu2HDx/mHwlULGXdUnLhwgWcOXNG7DhERAXy5MkTJCUlQUdHB5UqVRI7DhEREf1HkRfzw4YNQ0JCAry8vPDzzz9j6dKlkEqlOHr0KEaOHInFixdjzpw5RR2DSOEcHR0xceJEAMCUKVM4AoWIVEpgYCCAz7fDaWiIsvgNERER5aHIi/k9e/bg06dP6NSpEw4dOoQzZ85AIpFgzpw5CAkJwcmTJ9G6deuijkEkipkzZ8LCwgKhoaHYtGmT2HGIiPItKCgIAIfYExERKasiL+a/vFe4bdu2uHz5MhITE5GcnIxr166hTZs2RR2BSDRGRkZYuHAhAGDu3Ln48OGDyImIiPIn68p8jRo1xA1CREREOVLIPfMSiUQRuyFSSsOGDYOLiwsEQUBwcLDYcYiI8iUyMhIAr8wTEREpK4XcBFepUqWvFvQxMTGKiEKkcOrq6vj9999haWkJMzMzseMQEeXLgwcPEBUVBSsrK7GjEBERUQ4UUszPmzcPxsbGitgVkVKqUqWK2BGIiApEIpGgbNmyYscgIiKiXCikmO/bty8sLCwUsSsipSYIAk6fPg1DQ0M0bdpU7DhERERERKSiivyeed4vT/R/tm7dik6dOmHs2LFcqo6IlNb48ePRvXt33Lx5U+woRERElAuFzmZPVNL17dsX5ubmCAkJwZYtW8SOQ0SUozNnzuDYsWNITk4WOwoRERHlosiLealUyiH2RP+fsbExFixYAADw8vLixI9EpHTi4uLw9OlTAFyWjoiISJkpZGk6Ivo/I0aMQLVq1RATE4P58+eLHYeISM6///4LALCzs+MKHEREREqMxTyRgmloaGDVqlUAgN9++w2hoaEiJyIi+j+BgYEAeFWeiIhI2alkMb9p0ya4uLjAyMgIRkZGcHNzw9mzZ2XPJyYm4ueff4atrS10dXVRuXJlbNq0ScTERPJat26NTp06ISMjA1OnThU7DhGRTFYxX7NmTZGTEBERUV4UsjRdYbO1tcWSJUtQoUIFAMCePXvQpUsXBAYGomrVqpg0aRJ8fX2xf/9+ODg44Pz58/jpp59gY2ODLl26iJye6LMVK1bg2bNnGDVqlNhRiIhkgoKCALCYJyIiUnYSoZhMN29qaorly5dj+PDhqFatGvr06YPZs2fLnq9duzbat28vm3zsv1JTU5Gamip7HB8fDzs7O8TFxcHIyKjI81PJJAgCl28khdmzZw/CwsIwb948aGio5He5VMQEQUDjxo1x9+5dhISEwMHBQexIREREJUp8fDyMjY3zVYeq5DD7L2VmZsLHxwdJSUlwc3MDADRq1AgnTpzAy5cvIQgCfH19ERYWhrZt2+baj7e3N4yNjWU/dnZ2ijoEKsG+LOQzMzNFTELFXXBwMIYNG4bFixdj27ZtYschJSWRSHDt2jUkJCTA3t5e7DhERESUB5Ut5oODg2FgYABtbW2MGTMGx44dQ5UqVQAA69atQ5UqVWBrawstLS20a9cOGzduRKNGjXLtz9PTE3FxcbKfqKgoRR0KlXDp6elYvXo1nJ2dERsbK3YcKqaWL18OqVQKAJg9ezbPNcqThoYGRw0REREpOZUt5p2cnBAUFIRbt25h7NixGDx4MB4+fAjgczF/69YtnDhxAnfv3sXKlSvx008/4X//+1+u/Wlra8sm1Mv6IVIEiUSC7du348mTJ1i4cKHYcaiY2rJlCxYvXozy5cvjw4cPud5yRCVb1hc+REREpPyKzT3zrVq1gqOjI9asWQNjY2McO3YMHTp0kD0/YsQIvHjxAufOnctXfwW5V4Hoe/39999o164dNDU18eDBA1SsWFHsSFRMnTt3Du7u7tDQ0MCDBw9QqVIlsSOREmnZsiXevn2LTZs25TmajYiIiIpGibpnPosgCEhNTUV6ejrS09OhpiZ/aOrq6rziQEqrbdu2aN++PdLT0zFt2jSx41Axcv/+fbn5GNq1a4f27dsjIyMDmzdvFjEZKRupVAp/f3/cv38fxsbGYschIiKir1DJYn7GjBm4evUqIiIiEBwcjJkzZ8LPzw8DBgyAkZERmjZtimnTpsHPzw/h4eHYvXs39u7di27duokdnShXK1asgLq6Oo4fP46LFy+KHYeKgffv36Nx48aoVasWXr58Kdu+cuVK7Ny5E8uXLxcxHSmb8PBwJCQkQFtbG87OzmLHISIioq9QyWL+zZs3GDhwIJycnNCyZUvcvn0b586dQ+vWrQEAPj4++OGHHzBgwABUqVIFS5YswaJFizBmzBiRkxPlrnLlyvjpp58AAJMmTeLs9vTd5s6di9jYWKipqcHKykq23dnZGUOHDoW6urqI6UjZBAYGAgCqVasGTU1NkdMQERHR16jkQsM7duzI83krKyvs2rVLQWmICo+Xlxf279+PBw8e4MaNG2jcuLHYkUhFPXjwQDaMftWqVbkW7snJyQgJCUHt2rUVGY+UUFBQEACgZs2a4gYhIiKifFHJYp6ouDIzM8OuXbvg6OiIatWqiR2HVJQgCJg8eTIyMzPRrVs3NG/ePMd2oaGhaNWqFVJTU/H48WPeJ13CZV2Zr1GjhrhBiIiIKF9Ucpg9UXHWpUsXFvL0Xc6ePYvz589DU1Mzz/viy5cvD319fbx79w6LFi1SYEJSRrwyT0REpFpYzBMpsQcPHiAiIkLsGKRC0tPTMXnyZADAxIkT4ejomGtbTU1NrFq1CgCwZs0aPHnyRCEZSfmkpaWhadOmqFy5MlxcXMSOQ0RERPnAYp5ISW3ZsgWurq6ywowoP96/fw9zc3OULl0aM2fO/Gp7d3d3tG3bFunp6Zg+fboCEpIy0tLSwsGDB/Hw4UMYGBiIHYeIiIjygcU8kZJq1KgRAODYsWPw9fUVOQ2pCmtra1y9ehW3b9/O1z3wEokEK1euhLq6Os81IiIiIhXCYp5ISVWtWlW2nCKXqqOCkEgkKFeuXL7b81yj6OhoSKVSsWMQERFRAbCYJ1Jic+fOhYmJCe7du4fdu3eLHYeUWEhICKZPn464uLhven3WuVaxYkUkJCQUcjpSdk2bNoWRkRFu3boldhQiIiLKJ4kgCILYIZRRfHw8jI2NERcXByMjI7HjUAm2Zs0aTJo0CZaWlggLC+P5SDlq3749zp49i0GDBmHPnj3f1MebN29gaWlZyMlI2SUmJsLIyAiCIODNmzewsLAQOxIREVGJVZA6lFfmiZTcTz/9hIoVK+LNmzfw9vYWOw4pobNnz+Ls2bPQ1NTErFmzvrkfFvIl07179yAIAmxsbFjIExERqRAW80RKTktLCytXroSxsTFsbGzEjkNKJj09HVOmTAEAjB8/HhUrVvzuPl+8eIGhQ4ciPDz8u/si5cf15YmIiFSThtgBiOjrOnbsiPDwcJQqVUrsKKRktm7dipCQEJibm3/XVfkv/fTTTzh58iQSExNx+PDhQumTlFdgYCAAoEaNGuIGISIiogLhlXkiFSCRSFjIUzYfP37EnDlzAADz58+HiYlJofS7aNEiqKmp4ciRI7hy5Uqh9EnKi1fmiYiIVBOLeSIVIggCTp8+jX79+nEZKcKiRYsQExODqlWrYuTIkYXWb/Xq1TFq1CgAwMSJE7lUXTGWnp6O4OBgALwyT0REpGpYzBOpkLi4OPTv3x8+Pj7Yu3ev2HFIZJMnT8bgwYOxevVqaGgU7l1T8+fPh5GREQIDA3muFWMpKSnw8PBAz549Ua5cObHjEBERUQFwabpccGk6UlYrVqzAtGnTYGVlhcePH8PAwEDsSFRMfXmuhYWFwdDQUOxIRERERMUal6YjKsZ++eUXODo6Ijo6GkuWLBE7DokgPj5eIfv58lxbvXq1QvZJRERERPnDYp5IxWhra2PFihUAPl85ff78uciJSJEyMjLQsGFDdOvWDa9evSrSfWlra2P16tX49ddfMXHixCLdF4nj5s2bePnyJThIj4iISPVwmH0uOMyelJkgCGjZsiV8fX3Rt29f/P7772JHIgXZvHkzxo4dC1NTUzx58oSrHNA3EwQBpqamiI2NRVBQEFxdXcWOREREVOJxmD1RMSeRSLB69WpIJBL4+Pjg3r17YkciBYiNjcXs2bMBAPPmzVN4IS8IAt6/f6/QfVLRef78OWJjY6GpqYnKlSuLHYeIiIgKqHCnPyYihXF1dcXcuXNRo0YNuLi4iB2HFGDhwoV4//49KleujNGjRyt032FhYRg6dCjS0tJw+/ZtqKnxu2BVFxgYCACoWrUqtLS0RE5DREREBcVinkiFzZkzR+wIpCCPHz/GunXrAACrVq2CpqamQvdvbGyM4OBgJCQkYP/+/Rg0aJBC90+FL6uYr1mzpshJiIiI6Fvw0gpRMfHhwwckJSWJHYOKyPTp05Geng53d3e0a9dO4fu3tLTErFmzAACenp4814qBoKAgACzmiYiIVBWLeaJiYP/+/ahYsSKWLl0qdhQqAh8+fEBAQADU1dWxcuVK0XJMmDAB5cuXx6tXr7Bs2TLRclDhyLoyX6NGDXGDEBER0TdhMU9UDOjp6eHjx49Yvnw5IiMjxY5DhczMzAyPHj3CqVOnRJ2oTFtbG8uXLwcALFu2jOeaCnv//j1evHgBAJzFnoiISEWxmCcqBrp164amTZsiJSUFnp6eYsehIqCrqyvK8Pr/4rlWPGhra2PPnj2YN28el18lIiJSUVxnPhdcZ55UTWBgIGrXrg1BEHDjxg24ubmJHYm+U1xcHI4ePYpBgwZBXV1d7DgyWeeaq6srrl+/Dj09PbEjERERERULXGeeqASqWbMmhg0bBgCYNGkSpFKpyInoey1atAjDhg1Dv379xI4ip2bNmvDz88OdO3dYyBMRERGJhMU8UTGycOFCGBgY4Pbt2/j999/FjkPf4enTp1i7di0AYMiQIeKGyUGTJk2UarQAFczu3btx+fJlpKamih2FiIiIvhGLeaJixMrKCjNnzoSamhrCwsLEjkPfYfr06UhLS0Pbtm3h7u4udpxcffr0CStWrOBSdSokKSkJw4YNQ7NmzfDx40ex4xAREdE30hA7ABEVrokTJ6JDhw6oXr262FHoG/n5+eHo0aOypegkEonYkXLVrl07XLlyBUlJSfDy8hI7DuVDcHAwBEGApaUlrKysxI5DRERE34hX5omKGR0dHRbyKiwzMxOTJk0CAIwePRpVq1YVOVHexo0bBwBYunSpbKkzUm5BQUEAPs99QERERKqLxTxRMRYSEoI1a9aIHYMKYPfu3QgKCoKxsTHmzZsndpyv6tWrFxo2bIhPnz5xqToVERgYCACoUaOGuEGIiIjou7CYJyqmXr58CVdXV0yaNAn//POP2HEon1xdXeHm5gYvLy+Ym5uLHeerJBKJ7Auj/fv34/bt2+IGoq/KKuZ5ZZ6IiEi1sZgnKqbKlCmD/v37A/h8H70gCCInovyoU6cOrl+/jvHjx4sdJd/q1KmDwYMHA+C5puwyMjIQHBwMgMU8ERGRqlPJYn7Tpk1wcXGBkZERjIyM4ObmhrNnz8qel0gkOf4sX75cxNREird48WLo6enh5s2bOHTokNhxKA9fFsASiUTlln3LOtdu3boFHx8fseNQLkJDQ5GSkgIDAwM4OjqKHYeIiIi+g0oW87a2tliyZAnu3LmDO3fuoEWLFujSpQsePHgAAHj9+rXcz86dOyGRSNCjRw+RkxMplo2Njew+5unTp+PTp08iJ6LcDBo0CL/++ivi4+PFjvJNss61bt26oW7dumLHoVw4Ojri+vXr2LVrF9TUVPJPACIiIvr/JEIxGQ9pamqK5cuXY/jw4dme69q1KxISEnDx4sV89xcfHw9jY2PExcXByMioMKMSKdSnT5/g5OSEqKgoLFiwALNmzRI7Ev3HlStX0LRpU6ipqSEwMBAuLi5iR/omUqmUBSIRERHRdyhIHaryf3VlZmbCx8cHSUlJcHNzy/b8mzdvcPr06RyL/C+lpqYiPj5e7oeoONDV1cWyZcsAAEuWLMGrV69ETkRZUlJSsGjRIri7uwMARo4cqbKFPIBshbxUKhUpCf1X1rl27949saMQERFRIdEQO8C3Cg4Ohpubm+zev2PHjqFKlSrZ2u3ZsweGhobo3r17nv15e3urxDJQRN+iT58+2Lt3L1q2bAkzMzOx45R4giDg+PHjmDx5MsLDwwEAjRo1wuLFi0VOVjhevXoFT09PqKmpYdeuXWLHKdEEQcCJEycwadIkhIeH48KFC/D19YVEIhE7GhEREX0nlR1mn5aWhsjISMTGxuLPP//E9u3bcfny5WwFvbOzM1q3bo3169fn2V9qaipSU1Nlj+Pj42FnZ8dh9lRsCILAP+CVhLe3N2bMmAHg86oDy5YtQ79+/YrN5/PPP/+gXr16AAB/f3/UqVNH5EQlU0hICCZOnIjz588D+DyvwfLly4vVuUZERFTcFGSYvcoW8//VqlUrODo6YsuWLbJtV69eRZMmTRAUFARXV9cC9cd75qk4y8jIgLq6Ov+gF0lUVBRcXV0xduxYeHp6wsDAQOxIhW7QoEHYt28fGjZsiKtXr/JcU6C4uDjMmzcP69evR0ZGBrS0tDBlyhTMmDGjWJ5rRERExUmJumc+iyAIclfWAWDHjh2oXbt2gQt5ouLswoULcHFxwZEjR8SOUiJIpVLs2LFDbt14Ozs7REZGYtGiRcW2uMpaqu769es81xTs4MGDWL16NTIyMtC5c2c8fPgQixcvLrbnGhERUUmlksX8jBkzcPXqVURERCA4OBgzZ86En58fBgwYIGsTHx+Pw4cPY8SIESImJVI+N2/eREhICKZNm4aUlBSx4xRrN2/eRL169TBixAisX78eN27ckD1X3AsrW1tbeHh4AADPNQVITEyU/ffIkSPRvXt3nDt3DsePH+d68kRERMWUShbzb968wcCBA+Hk5ISWLVvi9u3bOHfuHFq3bi1r4+PjA0EQ0K9fPxGTEimfqVOnwtbWFs+fP8fq1avFjlMsvX79GoMHD0aDBg1w584dGBkZYdWqVfjhhx/EjqZQPNeK3uvXrzFo0CDUrFlTNjpNQ0MDf/75J9q2bStyOiIiIipKxeae+cLGe+apODtw4AB+/PFHGBgYICwsDNbW1mJHKhbS0tKwZs0aLFiwQHaldNiwYVi8eDEsLS1FTieOrHOtfPnyCA0NhYaGyi6iolRSU1Oxdu1auXPt1KlT6NChg8jJiIiI6HuUyHvmiSj/+vXrh3r16iExMRGzZs0SO06xkZaWhrVr1yIxMRH16tXD7du3sWPHjhJbyAOfz7U1a9YgICCAhXwhOXPmDKpXrw4PDw+5c42FPBERUcnCK/O54JV5Ku5u3boFNzc3SCQS3LlzB7Vq1RI7kkoKDw+Hvb091NQ+fzd67NgxxMfHY+DAgbJtRIUhOTkZvXv3xunTpwEAlpaWWLZsGX788Ueea0RERMUEr8wT0VfVr18f/fv3hyAIOHjwoNhxVE5CQgI8PDzg5OSE/fv3y7Z369YNgwcPZnGVA0EQcP78efA75G+jq6sLqVQKTU1NTJs2DWFhYRg0aBDPNSIiohKKfwEQlWBLlizBsWPHsHz5crGjqAypVIq9e/eiUqVKWLZsGdLT0+Hn5yd2LKUnCALatm2Ltm3b4ujRo2LHUQlSqRT79u3Du3fvAAASiQS//fYbgoODsWzZMo4aIyIiKuFYzBOVYHZ2dujatSskEonYUVSCv78/GjZsiMGDByM6OhoVKlTAqVOnsHPnTrGjKT2JRIL69esD4FJ1+XHnzh00bNgQgwYNkpvXoly5cnBychIxGRERESkLFvNEBACIiYnBpUuXxI6htJYuXYp69erh1q1bMDAwwNKlS3H//n1OOlYA06dPh42NDcLDw7F27Vqx4yilt2/fYsSIEahbty5u3boFfX19VKhQQexYREREpIRYzBMRQkNDUbFiRXTt2hVv3rwRO45Saty4MQBg4MCBCA0NxfTp06GtrS1yKtViYGAAb29vAMCiRYt4rn0hPT0dq1evRsWKFbFjxw4IgoCBAwciLCwM06ZNEzseERERKSEW80SEihUronz58khISMCcOXPEjqMUzp8/jy1btsgeN2jQAKGhodi7dy9sbGxETKbafvzxR9SpUwcJCQmYPXu22HGUxuLFizF58mTEx8ejdu3auHHjBs81IiIiyhOXpssFl6ajkub69eto1KgR1NTUEBAQAFdXV7EjieLZs2eYPHkyjh8/Dh0dHYSEhMDBwUHsWMVK1rkmkUgQEBCAGjVqiB1JFIIgyOariImJQaNGjTBlyhQMHTqUM9QTERGVUFyajogKrGHDhujTpw+kUikmTZpU4pYPS0pKwqxZs1ClShUcP34c6urqGD16NExMTMSOVuxknWvVqlVDWlqa2HEULutc69Spk+zfmampKe7fv4/hw4ezkCciIqJ84ZX5XPDKPJVEz58/h5OTE1JTU/HXX3+hS5cuYkcqcoIg4NChQ5g6dSpevnwJAGjVqhXWrl2LKlWqiJyu+IqNjYWhoSHU1dXFjqIwOZ1rfn5+aNq0qcjJiIiISFnwyjwRfRN7e3tMnToVADBlyhSkpqaKnKjovXr1CkOHDsXLly/h4OCAY8eO4fz58yzki5iJiUmJKuSDgoLQtGlT9OvXT+5ca9KkidjRiIiISEVpiB2AiJTLr7/+it27d6NFixZISUkpljO2JyUlQV9fHwBQpkwZeHl5ISMjA1OmTIGurq7I6UqWT58+YfXq1TA2Nsa4cePEjlPoEhISMH36dGzduhVSqRS6urqYMWMGzzUiIiL6bhxmnwsOs6eSLDExEQYGBmLHKHQZGRnYvHkzvLy8cPLkSTRo0EDsSCXewYMHMWDAABgZGeHJkycoXbq02JEKVXp6OlxcXPDo0SP07dsXy5Ytg52dndixiIiISElxmD0RfZfiWMhfunQJNWvWxC+//IKYmBhs3rxZ7EgEoG/fvqhVqxbi4+OLzbKIV69elU3sp6mpiW3btuHy5cv4/fffWcgTERFRoWExT0S5Cg0NRZcuXRAcHCx2lG/2/Plz9OrVCy1btsT9+/dhamqKTZs2YdeuXWJHIwBqampYs2YNAGDr1q3F4lxr0qQJ1q9fL9veqFEj3htPREREhY7FPBHlysvLCydOnFDZperWrVsHZ2dnHDlyBGpqahg3bhweP36MMWPGlKjJ15Rd48aN0bNnT5VdFjE5ORlz586VO9fev38vdiwiIiIq5ljME1GuvL29oaWlhYsXL+LUqVNixykwY2NjpKSkoFmzZggMDMSGDRtgamoqdizKwbJly1TuXBMEAUeOHEHlypUxb948uXPN29tb7HhERERUzLGYJ6JclStXDpMnTwbweam6rPuAlVVwcDAuXrwoezxw4ECcPXsWly5dgouLi4jJ6Gu+PNc8PT1V4ur8zJkz0atXL0RGRsLOzg5//PEHzzUiIiJSGBbzRJQnT09PWFpa4vHjx/jtt9/EjpOjmJgY/PLLL6hZsyYGDRqExMREAJ/vx27Xrh0kEonICSk/PD09MXjwYBw7dkwlPrOBAwfC0NAQXl5eePToEXr16qUSuYmIiKh44NJ0ueDSdET/Z8eOHRgxYgRMTEzw+PFjmJubix0JAJCZmYnt27dj5syZ+PDhAwCgR48e2LhxIywsLEROR8VJ1rkWFRWFhQsXyrbHx8fzdwQREREVGi5NR0SFasiQIahRowZiY2NlM4+L7dq1a6hTpw7GjBmDDx8+oGrVqrh48SKOHDnCQr6YePnypdgRAMifa97e3rh//77sORbyREREJBYW80T0Verq6li7di2WLl2KWbNmiR0Hjx49QuPGjREUFAQTExOsW7cOQUFBaNGihdjRqBBkZGRg2LBhKFeunFzhrGgvXrxA//795c611atXw8nJSbRMRERERFk0xA5ARKqhSZMmoq6VLQiC7H5kZ2dn9O/fH4aGhliwYAFKly4tWi4qfBoaGoiNjUV6ejqmTJmCc+fOKfRe9JSUFKxatQqLFi1CcnIyJBIJRo4ciYULF/JcIyIiIqXBe+ZzwXvmiXKXkZGBFy9ewMHBocj3JQgCTpw4gVmzZuHMmTOws7MDAEilUqipcXBRcfX06VNUrlwZ6enpOH36NNq3b6+wfb9//x4VK1ZEbGwsGjZsiHXr1qFWrVoK2z8RERGVXLxnnoiKTEhICFxdXdGuXTukp6cX+b7atWuHrl274v79+1i8eLHsORbyxZujoyMmTpwIAJg8eXKRn2vPnz+XLYdnbm6OtWvX4sCBA7h69SoLeSIiIlJK/GuYiArExsYG7969Q2hoKDZv3lwk+4iLi8PkyZPh4uKC8+fPQ0tLC56enli+fHmR7I+U08yZM1G6dGmEhoZi06ZNRbKPrHOtQoUKOHXqlGz7oEGD0L9/fy41R0REREqLxTwRFYixsbFsaS4vLy/ExMQUav979+5FpUqVsHr1amRkZKBz5854+PAhFi9eDAMDg0LdFyk3Y2NjLFiwAAAwd+5c2fKDhUEqlWLnzp1y59qFCxcKrX8iIiKiosZinogKbPjw4XBxccHHjx8xb968Qu07NDQUb9++hZOTE86ePYvjx4/D0dGxUPdBqmP48OGoXr061NTU8PDhw0Lp89atW6hXrx6GDx8uO9fOnTuHdevWFUr/RERERIrACfBywQnwiPJ28eJFtGrVCurq6ggODkblypW/qZ/Xr18jLi4Ozs7OAIDExETs2rULo0ePhpaWVmFGJhUVEhICa2trmJiYfHdfc+bMkV3tNzQ0xNy5c/Hzzz/zXCMiIiKlwAnwiKjItWzZEp07d0ZmZiamTp1a4NenpqZi2bJlqFSpEgYPHgypVAoAMDAwwC+//MLiimQqV65cKIU8ANSvXx8AMGzYMDx+/BiTJ0/muUZEREQqicU8EX2zFStWQFNTE0lJSUhMTMz3686cOYPq1avDw8MDiYmJkEgkhXo/NBVPgiDgyJEj8PPzy/drzpw5gwMHDsget2/fHiEhIdixYwcsLS2LICURERGRYrCYJ6JvVrFiRdy9exe+vr75mpwuLCwMHTp0QIcOHfD48WNYWlpiz549uHHjBkqXLq2AxKTKNmzYgF69euGnn35CRkZGnm0fP36Mjh07okOHDhg3bhzevn0rey7rlg4iIiIiVcZinoi+S/Xq1fO1fJe/vz+qVauGM2fOQFNTE9OmTUNYWBgGDRrENeMpXwYOHAgzMzOEhIRgy5YtObZJSEiAh4cHqlatitOnT0NTUxMjR46Ejo6OgtMSERERFS3+BU1EheLjx4/w9PTEx48fc3y+du3acHV1Rbt27RAcHIxly5ZxckkqEBMTE9nkdXPmzJE716RSKfbt24dKlSph2bJlSE9Pl51ry5cv57lGRERExY5KFvObNm2Ci4sLjIyMYGRkBDc3N5w9e1auTUhICDp37gxjY2MYGhqifv36iIyMFCkxUfHXvXt3LFmyBPPnzwfw+Up8z549kZSUBABQU1PD//73P5w5cwZOTk5iRiUVNnLkSFStWhUxMTGycw0Anjx5gqFDhyI6OhoVKlTAyZMnea4RERFRsaaSS9OdPHkS6urqqFChAgBgz549WL58OQIDA1G1alU8ffoUdevWxfDhw9GvXz8YGxsjJCQEP/zwAywsLPK1Dy5NR1QwFy5cQJs2baChoYFevXrBx8cHgiDAy8sLc+fOFTseFSPnz59H27ZtAQCPHj2SFeyenp4wMTHBxIkToa2tLWZEIiIiom9SkDpUJYv5nJiammL58uUYPnw4+vbtC01NTezbty/fr09NTUVqaqrscXx8POzs7FjMExVAx44dcfr0adnjH3/8EUuXLoWNjY2Iqag4yjrXduzYgWHDhokdh4iIiKhQlKh15jMzM+Hj44OkpCS4ublBKpXi9OnTqFSpEtq2bQsLCwvUq1cPf/31V579eHt7w9jYWPZjZ2enmAMgKkZWrVoFa2tr1K1bF9euXcO+fftYyFORyDrX7t27J3YUIiIiIlGo7JX54OBguLm5ISUlBQYGBjh48CDat2+P6OhoWFtbQ09PDwsXLkTz5s1x7tw5zJgxA76+vmjatGmO/fHKPFHhEAQhX7PbE30vnmtERERU3JSIYfZpaWmIjIxEbGws/vzzT2zfvh2XL1+GiYkJypQpg379+uHgwYOy9p07d4a+vj5+//33fPXPe+aJiIiIiIhIkUrEMHstLS1UqFABderUgbe3N1xdXbF27VqYm5tDQ0MDVapUkWtfuXJlzmZPRERERERExYLKFvP/JQgCUlNToaWlhR9++AGhoaFyz4eFhcHe3l6kdERERERERESFR0PsAN9ixowZcHd3h52dHRISEuDj4wM/Pz+cO3fu/7V353FR1XsfwD/DsAqCCqigIOaCC6ISmZBrZSKuuYTpdQ+vZlevj9qiT/d6H1KkkijNLC3Qct/yWoomigumCeoFBcUNRUXJBUSUgZn5Pn9wmZwAFYUzDn7er5evmjO/OfM94wc53znn/A4AYMaMGQgJCUGXLl0M18xv2bIF8fHxpi2ciIiIiIiIqBKYZTN/7do1jBgxAllZWXBycoKvry9iY2PRo0cPAMDrr7+OxYsXIzw8HJMnT4a3tzc2bNiATp06mbhyIiIiIiIioidnthPgVTVOgEdERERERERKeiYmwCMiIiIiIiJ6VrGZJyIiIiIiIjIzbOaJiIiIiIiIzAybeSIiIiIiIiIzY5az2RMRERERkenp9XoUFhaaugwis2FlZQW1Wl0p62IzT0REREREFVZYWIjz589Dr9ebuhQis1KrVi3Ur18fKpXqidbDZp6IiIiIiCpERJCVlQW1Wg0PDw9YWPDqXaKHERHcvXsX2dnZAAA3N7cnWh+beSIiIiIiqhCtVou7d+/C3d0dNWrUMHU5RGbDzs4OAJCdnY26des+0Sn3/AqNiIiIiIgqRKfTAQCsra1NXAmR+Sn5AqyoqOiJ1sNmnoiIiIiIHsuTXvNL9CyqrJ8bNvNEREREREREZobNPBEREREREZGZYTNPRERERET0J15eXoiKijJ1GZWmum0PsZknIiIiIqJnSGZmJsaNGwd3d3dYW1ujUaNGmDJlCm7cuGHq0kxq9OjRGDBggKnLUERMTAxq1apl6jKeGJt5IiIiIiJ6Jpw7dw7+/v5IT0/HqlWrcObMGSxevBhxcXEICAjAzZs3TVabTqeDXq832ftXB4WFhYq/55POSP8k2MwTEREREVGlyM/PL/dPQUHBI4+9d+/eI42tqEmTJsHa2ho7duxA165d4enpiV69emHnzp24fPkyZs2aZTQ+Ly8Pw4YNg4ODA9zd3bFgwQKj52fPng1PT0/Y2NjA3d0dkydPNjxXWFiId999Fw0aNIC9vT1efPFFxMfHG54vOTr8008/oVWrVrCxscGSJUtga2uLnJwco/eZPHkyunbtanh84MABdOnSBXZ2dvDw8MDkyZONPo/s7Gz07dsXdnZ2aNy4MVasWPHAz2X27NlYtmwZNm/eDJVKBZVKZaj18uXLCAkJQe3ateHs7Iz+/fsjIyPD8NqSI/pz585FvXr1UKtWLfzrX/+CVqvFjBkzUKdOHTRs2BDfffed4TUZGRlQqVRYvXo1AgMDYWtri9atWxt9PgCQmpqK4OBgODg4oF69ehgxYgSuX79ueL5bt25455138D//8z9wcXFBjx49AACRkZFo06YN7O3t4eHhgbfffht37twBAMTHx2PMmDHIzc01bOvs2bMBFM8y/+OPPxrVUKtWLcTExBjVvXbtWnTr1g22trb44YcfAADR0dFo2bIlbG1t0aJFCyxatOiBn3mlECpTbm6uAJDc3FxTl0JERERE9FS5d++epKamyr1794yWAyj3T3BwsNHYGjVqlDu2a9euRmNdXFzKHFcRN27cEJVKJXPnzi3z+dDQUKldu7bo9XoREWnUqJHUrFlTwsPD5dSpU/LFF1+IWq2WHTt2iIjIunXrxNHRUbZu3SoXLlyQQ4cOyTfffGNY37BhwyQwMFD27t0rZ86ckU8++URsbGwkPT1dRESio6PFyspKAgMDJSEhQU6ePCl37tyRevXqydKlSw3r0Wq1Uq9ePfn6669FRCQ5OVkcHBzks88+k/T0dElISJD27dvL6NGjDa/p1auX+Pj4yIEDByQxMVECAwPFzs5OPvvsszK3PS8vT9544w0JCgqSrKwsycrKEo1GI/n5+dKsWTMZO3asJCcnS2pqqgwbNky8vb1Fo9GIiMioUaOkZs2aMmnSJDl58qR8++23AkB69uwpc+bMkfT0dAkLCxMrKyu5ePGiiIicP39eAEjDhg1l/fr1kpqaKm+99ZbUrFlTrl+/LiIiV65cERcXF/nggw8kLS1Njhw5Ij169JDu3bsb6u7atas4ODjIjBkz5OTJk5KWliYiIp999pns2rVLzp07J3FxceLt7S0TJ04UERGNRiNRUVHi6Oho2Na8vDwRKc7vpk2bjD4bJycniY6ONqrby8tLNmzYIOfOnZPLly/LN998I25uboZlGzZskDp16khMTEyZn3d5Pz8iFetD2cyXg808EREREVHZzLGZP3jwYJnNWonIyEgBINeuXROR4mY+KCjIaExISIj06tVLRETmz58vzZs3l8LCwlLrOnPmjKhUKrl8+bLR8ldeeUU++OADESlu5gHIsWPHjMZMnjxZXn75ZcPj7du3i7W1tdy8eVNEREaMGCHjx483es2+ffvEwsJC7t27J6dOnRIAcvDgQcPzaWlpAqDcZl6kuCnv37+/0bJvv/1WvL29DV9wiBQ3w3Z2drJ9+3bD6xo1aiQ6nc4wxtvbWzp37mx4rNVqxd7eXlatWiUifzTF8+bNM4wpKiqShg0bSkREhIiIfPjhh/Laa68Z1ZOZmSkA5NSpUyJS3My3a9eu3G0qsXbtWnF2djY8jo6OFicnp1LjHrWZj4qKMhrj4eEhK1euNFoWFhYmAQEBZdZTWc28ZaUe5iciIiIiomdWyanMZVGr1UaPs7Ozyx1rYWF8NfD9p3VXleJervhU6xIBAQFGYwICAgwzwg8ZMgRRUVF47rnnEBQUhODgYPTt2xeWlpY4cuQIRATNmzc3er1Go4Gzs7PhsbW1NXx9fY3GDB8+HAEBAbhy5Qrc3d2xYsUKBAcHo3bt2gCApKQknDlzxujUeRGBXq/H+fPnkZ6eDktLS/j7+xueb9GixWNN+FbyXjVr1jRaXlBQgLNnzxoet27d2ujvrF69evDx8TE8VqvVcHZ2LvV3fv/nW1JzWlqa4b13794NBweHUnWdPXvW8Nnev50ldu/ejblz5yI1NRW3b9+GVqtFQUEB8vPzYW9vX5GPoEz3v+fvv/9umFQxNDTUsFyr1cLJyemJ3+tB2MwTEREREVGlqEijVFVjy9O0aVOoVCqkpqaWOWv7yZMnUbt2bbi4uDxwPSXNvoeHB06dOoVffvkFO3fuxNtvv41PPvkEe/bsgV6vh1qtRlJSUqkvMe5vTu3s7Iy+PACADh06oEmTJli9ejUmTpyITZs2ITo62vC8Xq/HX//6V6Pr80t4enri1KlTRnU+Cb1ej+eff77Ma+5dXV0N/29lZWX0nEqlKnPZo0zwV1K3Xq9H3759ERERUWqMm5ub4f//nI0LFy4gODgYEyZMQFhYGOrUqYP9+/dj3LhxD52sTqVSGb7UKVHWa+5/z5JtWrJkCV588UWjcX/+u69sbOaJiIiIiKjac3Z2Ro8ePbBo0SJMnToVdnZ2hueuXr2KFStWYOTIkUZN8MGDB43WcfDgQbRo0cLw2M7ODv369UO/fv0wadIktGjRAikpKWjfvj10Oh2ys7PRuXPnCtc6bNgwrFixAg0bNoSFhQV69+5teM7Pzw8nTpxA06ZNy3xty5YtodVqkZiYiA4dOgAATp06VWpSvT+ztraGTqczWubn54c1a9agbt26cHR0rPB2PMzBgwfRpUsXAMVHspOSkvDOO+8Y3nvDhg3w8vKCpeWjt62JiYnQarWYP3++4WyBtWvXGo0pa1uB4i8osrKyDI9Pnz6Nu3fvPvD96tWrhwYNGuDcuXMYPnz4I9dZGTibPRERERERPRMWLlwIjUaDnj17Yu/evcjMzERsbCx69OiBBg0aYM6cOUbjExIS8PHHHyM9PR1ffvkl1q1bhylTpgAono3+22+/xfHjx3Hu3Dl8//33sLOzQ6NGjdC8eXMMHz4cI0eOxMaNG3H+/HkcPnwYERER2Lp160PrHD58OI4cOYI5c+Zg8ODBsLW1NTz33nvv4ddff8WkSZNw7NgxnD59Gv/+97/xt7/9DQDg7e2NoKAghIaG4tChQ0hKSsJbb71l9OVFWby8vJCcnIxTp07h+vXrKCoqwvDhw+Hi4oL+/ftj3759OH/+PPbs2YMpU6bg0qVLFf34S/nyyy+xadMmnDx5EpMmTcKtW7cwduxYAMV3Hrh58ybefPNN/Pbbbzh37hx27NiBsWPHltmIl2jSpAm0Wi0WLFhg+HtZvHhxqW29c+cO4uLicP36dUPD/vLLL2PhwoU4cuQIEhMTMWHChFJnGJRl9uzZCA8Px+eff4709HSkpKQgOjoakZGRT/DpPBybeSIiIiIieiY0a9YMiYmJaNKkCUJCQtCkSROMHz8e3bt3x6+//oo6deoYjZ82bRqSkpLQvn17hIWFYf78+ejZsyeA4luWLVmyBC+99BJ8fX0RFxeHLVu2GK6Jj46OxsiRIzFt2jR4e3ujX79+OHToEDw8PB6pzhdeeAHJycmljvb6+vpiz549OH36NDp37oz27dvjww8/NDr1PDo6Gh4eHujatSsGDhyI8ePHo27dug98z9DQUHh7e8Pf3x+urq5ISEhAjRo1sHfvXnh6emLgwIFo2bIlxo4di3v37lXKkfp58+YhIiICbdu2xb59+7B582bDZQ7u7u5ISEiATqdDz5494ePjgylTpsDJyanUnAr3a9euHSIjIxEREQEfHx+sWLEC4eHhRmMCAwMxYcIEhISEwNXVFR9//DEAYP78+fDw8ECXLl0wbNgwTJ8+HTVq1Hjodrz11ltYunQpYmJi0KZNG3Tt2hUxMTFo3LjxE3w6D6eSP18UQACA27dvw8nJCbm5uVVySgkRERERkbkqKCjA+fPn0bhxY6OjxkSPIiMjA40bN8bRo0fRrl07U5ejuAf9/FSkD+WReSIiIiIiIiIzw2aeiIiIiIiIyMxwNnsiIiIiIiJSjJeXV6lbwFHF8cg8ERERERERkZlhM09ERERERI+FR1eJKk6v11fKeniaPRERERERVYiVlRVUKhV+//13uLq6QqVSmbokoqeeiKCwsBC///47LCwsYG1t/UTrYzNPREREREQVolar0bBhQ1y6dAkZGRmmLofIrNSoUQOenp6wsHiyE+XZzBMRERERUYU5ODigWbNmKCoqMnUpRGZDrVbD0tKyUs5mYTNPRERERESPRa1WQ61Wm7oMomcSJ8AjIiIiIiIiMjNm2cx/9dVX8PX1haOjIxwdHREQEIBt27YZnh89ejRUKpXRn44dO5qwYiIiIiIiIqLKY5an2Tds2BDz5s1D06ZNAQDLli1D//79cfToUbRu3RoAEBQUhOjoaMNrnnSmQCIiIiIiIqKnhVk283379jV6PGfOHHz11Vc4ePCgoZm3sbFB/fr1H3mdGo0GGo3G8Dg3NxcAcPv27UqomIiIiIiIiOjBSvpPEXnoWLNs5u+n0+mwbt065OfnIyAgwLA8Pj4edevWRa1atdC1a1fMmTMHdevWLXc94eHh+Ne//lVquYeHR5XUTURERERERFSWGzduwMnJ6YFjVPIoLf9TKCUlBQEBASgoKICDgwNWrlyJ4OBgAMCaNWvg4OCARo0a4fz58/jwww+h1WqRlJQEGxubMtf35yPzOTk5aNSoES5evPjQD5HoSdy+fRseHh7IzMyEo6OjqcuhaoxZI6Uwa6QUZo2UwqyRUnJzc+Hp6Ylbt26hVq1aDxxrtkfmvb29cezYMeTk5GDDhg0YNWoU9uzZg1atWiEkJMQwzsfHB/7+/mjUqBF+/vlnDBw4sMz12djYlNnoOzk58QeWFFEyoSNRVWPWSCnMGimFWSOlMGukFAuLh89Vb7bNvLW1tWECPH9/fxw+fBiff/45vv7661Jj3dzc0KhRI5w+fVrpMomIiIiIiIgqnVnemq4sImJ0mvz9bty4gczMTLi5uSlcFREREREREVHlM8sj8zNnzkSvXr3g4eGBvLw8rF69GvHx8YiNjcWdO3cwe/ZsDBo0CG5ubsjIyMDMmTPh4uKC119//ZHfw8bGBv/85z/LvcaeqLIwa6QUZo2UwqyRUpg1UgqzRkqpSNbMcgK8cePGIS4uDllZWXBycoKvry/ee+899OjRA/fu3cOAAQNw9OhR5OTkwM3NDd27d0dYWBhnpiciIiIiIqJqwSybeSIiIiIiIqJnWbW5Zp6IiIiIiIjoWcFmnoiIiIiIiMjMsJknIiIiIiIiMjNs5omIiIiIiIjMDJt5oirE+SWJiIgeD3+HEhE92DPXzGs0Ghw4cAAXLlwwdSlUzRUVFSE7O9vwmDslVFWKiopw+fJlw2NmjapKSba0Wq2JK6HqTqfTIS8vz9Rl0DOgqKgIGRkZKCoqAsDfoVR1qmJ/7Zlq5qOiouDl5YW//vWvaNu2LRYvXgydTmfqsqgaioyMRMuWLTFw4EAMHjwYBw8ehEqlMnVZVA3Nnz8fzZo1Q+/evdGnTx/8+uuvzBpViYULF6Jbt24AAEtLS+7wUpX57LPP8NJLL2HAgAH4+9//jrNnzwIA9Hq9iSuj6iYyMhK+vr4YMmQIunXrht9++w0qlYpZo0pXVftrz8x95j/88EOsW7cOkZGRaN68OZYvX44FCxbgypUrsLOzM3V5VE2ICKZNm4atW7ciIiIC9+7dw+bNm7Fjxw5s2rQJXbp0MXWJVI1ERkZiwYIF+PTTT3H79m1s3rwZCQkJWLdunaHpInpSly5dwqxZs7Bt2zZcv34dc+fOxfvvvw+dTge1Wm3q8qgaOX36NCZMmIDMzEzMmjULJ0+eRHx8PGrWrIkdO3aYujyqRv7zn//gnXfewbVr1/DRRx9Br9fj+++/x8WLF5GSkmLq8qiaqcr9NcvKKfHpduPGDfzyyy8IDQ1FcHAwAGDEiBHYsGED8vPzYWdnBxHh0Sx6YpcuXcLu3bvx0UcfoX///gCAoUOHwsPDA3PnzoWTkxPatm1r4irJ3On1euj1euzcuRO9evXCoEGDAABjxoxB586dERERgVq1aqFdu3amLZSqhdTUVNy7dw9ffvklTpw4gU8//RTjxo2Dq6sr9Ho9LCyeqZP8qIro9Xps2bIFtra2iI+Ph7u7OwBg/fr1+Oijj3Dy5Em0aNHCxFVSdXHo0CF4eHhg06ZNcHFxAQDk5ORg7dq1KCgogK2tLXsDemJK7K89E7+B7e3tkZycDBsbG8OyWbNmwc3NDevWrcOVK1dMWB1VJxqNBidOnDDscOh0OuTk5KBWrVo4cuQItm/fjsLCQhNXSebOwsICer0eKSkp8PPzAwAUFBQAKL6cKD09HbGxsdBoNKYsk8xcyYl7L7/8MqZOnYohQ4Zg6NCh8PLywrRp0wCAO7pUaXQ6HZo1a4ZJkybB3d3dcJqzg4MDrl69CmdnZxNXSNVBSa7Gjh2LWbNmGRp5ANi6dSuaNWuGxMRENvJUKZTYX6t2zXxsbKzRdXw6nQ62traYPn06/vGPf2DAgAFwcnLC6dOn4evriy+++AIDBw7ETz/9ZMKqyRz9OWtA8XWkAQEBCAsLQ2FhIdRqNaKjo9G+fXv4+/tj7dq1KCoq4rWmVCEbN25EVFQUfvnlF+Tk5AAArK2tERgYiB9++AEAYGtrC71ej+effx6vvfYaNmzYgOvXr5uwajJH92ctNzcXAKBWqxEQEAAAeO655zBx4kT8+OOPhrlAOBkePY77s3br1i1YWVmhZ8+ehjMoSxqp27dvw93dnZdE0mO7P2u3b98GUNxktW7dGgAQFxeHunXrIj09HRkZGRg+fDgGDBjA36FUYcuXL8fUqVOxfPlywyTY1tbW6NixY9Xtr0k1kZqaKl27dhWVSiVhYWEiIqLT6YzGXLhwQUJDQ2Xo0KGi1WpFRESv14ufn5/MnDmz1HiispSVtZI86XQ6Wb9+vTg5OUn79u2lfv36Urt2bfntt9/k9OnTolKpJCMjw5TlkxlJSkqStm3bStOmTaVbt25Sv3596du3r4gU/9u1bNkyadiwoWzdulVERO7duyciIpmZmaJSqeTgwYMmq53My4OyVkKv14tI8e/Svn37SmBgoClKJTP3KFkT+SNvU6ZMkREjRohI6f06ogd51Kz99NNPsmHDBtFoNKLRaOTChQuiUqlkw4YNIvJHFonKc/XqVXnllVekQYMG8vrrr4unp6d4e3sb9sN++OEHadCgQZXsr1WLZv78+fMyatQoGTx4sEyZMkVq1qwp165dExHjH8C8vDxp166dbNu2TUT++CBfffVVCQ4OVr5wMjsPylpJQy8ikpycLDExMRITE2NYvnfvXvHy8pLjx4+bpHYyL4cPH5aOHTvKtGnTJC8vT3Jzc2Xnzp1ia2srO3bsEBGRtLQ0GTRokHTq1MnwOr1eL9nZ2eLp6SnfffedqconM/KgrO3cuVNESu/MbtmyRZydnWX58uUiIpKQkCCXLl1SvHYyL4+TtRYtWsi3335reHz+/PkyxxHd71Gydv9+2/10Op00atRIZs6cqWTJZMbWrVsnrVq1MvQEBQUF8sILL0jv3r0lJSVFrl27JgMGDKiS/bVqcZp93bp10a5dO8yYMQPvv/8+GjdujKlTp5YaZ2tri9u3byMpKcnwOD09Hfn5+QgJCVG6bDJDD8ra/ddWtWnTBqNGjcKoUaMMsz3v378fDRo0QJMmTUxSO5kXEYGbmxveeecdODg4wNHREa1atYKPjw/OnTsHAGjRogX+8pe/4MKFC5g+fTqKioqgUqmQkpICGxsbzmhPj+RBWSu5JVjJv2/y30uEAgMDMXz4cHzwwQcYNGgQOnXqhBMnTphsG8g8VCRrAJCcnIycnBwEBQXh5s2bGDduHJ577jmkp6fzemZ6oEfJWnl349ixYwdcXFzw5ptvKlkymSkRwb59++Dq6oqaNWtCr9fDxsYGUVFRyM7OxtKlS+Hq6orQ0FBkZGRU/v7aE3wJ8VQo+Wa2oKDAsGzt2rVGpyyUnJZVWFgon3zyiahUKgkJCZHJkydL3bp1ZdCgQXLr1i3FayfzUpGslcjMzJQzZ87I3Llzxc3NTZYuXWq0LqLy3L17V3Jyckotb9iwoWzfvt3wWKPRyJo1a6RGjRri5+cno0ePFkdHRxk/frzcu3ePWaOHetSs3e/GjRsSEhIiKpVKevfuLWlpaVVdJlUDFc3a6tWrpUOHDhIeHi6Ojo7SpUsXSU1NVaJUMnMVzdrVq1flwoULEhERIe7u7jJjxgwpKCjg71B6oJJ8vPfee9KyZUsRMT7jY+bMmdKxY0fZt2+fiBT/m1bZ+2tmf2u6km9mbWxsDDNPBgUFoXfv3pg8eTIOHTpkuG2OlZUVpk+fDrVajZMnTyIzMxMxMTHo1auXKTeBzERFslYiJSUF//jHP5Cbm4tvvvkGffr0MVoXUXns7OxK3TYzMTERFhYWaNOmjeEe39bW1njjjTfg4uKCo0eP4sSJE1i5ciV69+5t4i0gc/GoWSuRmZmJMWPG4MSJE9i2bRt69uxpqtLJzFQ0a7GxsTh8+DBu3bqF6OhoDBw40FSlk5mpSNays7OxZs0aLF68GHq9Hl9//bVhf40IwEPvbvDGG28gMjISO3fuxKuvvgqNRgMbGxuEhoZi1apVSE5ORqdOnRASEgJXV9dK3V9TiTz902qXfIB//kf+QX799Vd0794dS5YswYgRI6DT6ZCfnw9HR8cqrpbMWWVnTUSwf/9+dO7cuYorJ3NTkayVjI2KisLq1atx4MABwxdHD/sFQ1RZWbt/zK5du/DKK69UZdlkhioza3q9HsuWLYNWq0VoaGhVl05mprKzlpqaioyMDDbxVEpRURGA4oPC5blx4wbGjx+P06dPIzk5GQAM2ezTpw8cHBywevXqKqnvqb9mPioqCmPGjAFQ/rUtZfH398fEiRMxa9YspKWlYeTIkfj000+Rn59fVaWSmavsrOXl5UGlUrGRp1IqmrWS++Lu2bMHAQEBsLCwwJ07dzBx4kTs2LGjSmsl81aZWdu+fTuA4jOL2MjTn1Vm1rZt2wYLCwuMHj2ajTyVUplZi42NhYWFBXx8fNjIUynz5s3Da6+9htdffx2ff/654RZyJZkq4ezsjEmTJuHSpUuYM2cOgOJsFhYWoqCgAJ6enlVX5GOdnK+AtLQ06d+/v9jb20vdunVl1apVIlL+zJNlSUxMFJVKJSqVSlq0aMHrrKhMzBop5UmyptFoxMfHR/bs2SMxMTHi7OwsjRs3llOnTlV12WSGmDVSCrNGSmHWSClHjx6VDh06SKtWrWTp0qXy5ptvip+fn/ztb38r9zUajUYWLVokKpVKpk2bJrt375YFCxaIu7u7xMXFVVmtT20zHxMTI3379pU1a9bImDFjJCAgQO7evSsiD588TK/XS1xcnNSvX188PT3lp59+UqJkMlPMGinlSbIWGxsrKpVKnJycpFatWvLDDz8oUTKZKWaNlMKskVKYNVJCfn6+vPfee/Lmm28aTZD+z3/+U4KDg+XGjRsPfP0nn3winTp1kpYtW4qnp6esW7euSut96pr5ktnA79y5I3v27BERkX//+9/Svn17+eijj4zGlKeoqEjCw8Nl9uzZVVssmTVmjZRSGVnbtWuX2NvbS3h4eNUWS2aNWSOlMGukFGaNlJSbmyuLFi2SvXv3ikjxvr6IyOeffy5NmzY1PP6z+zOo1+sVO0v3qZgALyYmBpmZmejQoQM6deoEe3t7o+dv3bqF8PBwbN26FZs3b0aTJk3KnfBC/jvJhV6vLzVpDxGzRkqpzKwBwO3bt6FWq0uth4hZI6Uwa6QUZo2Ucn/WXnrpJTg4OECr1cLSsvimbyX7+WFhYTh27BjWr1//wImHReGJiU3azJ87dw5vvPEGbt68iUaNGuHkyZPw9fXFypUr4ezsDOCPD3D//v2YNWsWmjdvjiVLlpiqZDJTzBophVkjpTBrpBRmjZTCrJFSyspamzZtsGrVKkPWStpklUqFAQMG4IUXXsCsWbOeqjsJmfRw4pYtW2BpaYkTJ05g69at2L17N5KSkvD+++/j4sWLAP74EDt27Ii+ffti3759iI+PBwAcOnQIT8GJBWQGmDVSCrNGSmHWSCnMGimFWSOllJW1I0eO4P3330dmZiaAP46y5+Xl4cCBAwgICABQ3NxfunTJMMaUTNbMFxUVYcuWLWjTpg3s7OxgbW2NFi1aYPHixdi5cye2bt0KoHhaf71eD0tLSwQHB6NNmzb43//9X/Tt2xcBAQE4ceKEqTaBzASzRkph1kgpzBophVkjpTBrpJSHZe3nn38GAMNltPHx8XBwcED37t2RlZWFYcOGoV27drh69arJj9CbpJkXEVhZWcHJyQlXrlwxLAOAwYMHw8/PDxs3bsTZs2eLi/zvB+nq6ors7GwcOHAAlpaWOHfuHHx8fEyxCWQmmDVSCrNGSmHWSCnMGimFWSOlVDRrAHDy5Em0bdsW8+bNQ9OmTZGdnY2kpCTUr1/fJNtgpEqn13uI77//XpydneX48eMiIlJQUCAiIklJSWJjYyP79+83jE1JSRFvb2957rnnDDNZEj0qZo2UwqyRUpg1UgqzRkph1kgpFcnaSy+9JCqVSlq0aCHbtm0zSb3lqbIj83Lf9QN6vd7ouaKiIgBAq1at4Ovri7CwMACAjY0N9Ho9/Pz80KxZM+zYscPwmmbNmmHevHk4e/YsunTpUlVlkxli1kgpzBophVkjpTBrpBRmjZRSmVnLz89H9+7dERMTg7S0NAQFBSm0FY+mSpr58PBwTJo0CVFRUcjLyzOcClPy4VlZWQEA/Pz8MHToUOzduxdr1qwpLsjCAlevXkVRURE8PDwAADqdDjY2NhgwYEBVlEtmjFkjpTBrpBRmjZTCrJFSmDVSSmVnzd7eHmFhYRg5cqQJtubhKrWZP3PmDNq2bYuVK1fi7t27mDt3Ll599VVs374dwB8f3tq1a2FtbY2NGzdiyJAhGDp0KMaOHYuvvvoKycnJWL58OXQ6HV588UUAKPeekfTsYtZIKcwaKYVZI6Uwa6QUZo2UUlVZe+pV5jn7CxcuFH9/f7l7966IiOTm5kq3bt0kKChIkpOTRURk8ODB4urqKp9++qloNBrDaydMmCCtW7eWJk2aiKenp/z888+VWRpVM8waKYVZI6Uwa6QUZo2UwqyRUp7VrFVaM6/VaiU0NFR69eolWq3WsHz79u3StWtXmTRpkoiIrF27VrKysgzP6/V6w3/v3LkjiYmJlVUSVVPMGimFWSOlMGukFGaNlMKskVKe5aw99mn2ubm5Ro/VajWKiopQUFAAvV4PnU4HAHjttdfQpUsXHD58GAcOHMCQIUOMpvEvuTefiMDe3h7PP//845ZE1RSzRkph1kgpzBophVkjpTBrpBRm7Q8VbuZ37tyJ1q1bY+HChSgoKAAAaLVaAMC4ceOwZ88eHDt2DGq12rC8X79+KCgowH/+85/yC7EwyS3v6SnGrJFSmDVSCrNGSmHWSCnMGimFWSvtkSvXarVYunQpJk+ejKKiInz99dc4deoUAMDS0hIA4O/vj27duuG9994D8MfkFP7+/rCwsMDZs2cBGN8ugOjPmDVSCrNGSmHWSCnMGimFWSOlMGvle+RmXqPRQKPR4C9/+QuOHDkCnU6HRYsWIS8vzzDG1tYW//d//4eEhAQsWLDAcF+/u3fvwtbWFi4uLgD+OKWBqCzMGimFWSOlMGukFGaNlMKskVKYtQeoyAX2Fy9elLy8PBERWb9+vVhaWsovv/xSaty8efPE2dlZRo8eLXFxcTJ9+nRp2LChHD169DEv7adnDbNGSmHWSCnMGimFWSOlMGukFGatbCqRip9roNfrYWFhgcDAQDg4OOD7779HvXr1jMZ8+eWXWLduHXJyciAi+OqrrxAYGFhpX0LQs4FZI6Uwa6QUZo2UwqyRUpg1UgqzZuyxmnmdTge1Wo3jx4/D19cX0dHRGDFiBCwsLFBUVAQrKyvD9QgXLlyAl5dXZddNzwhmjZTCrJFSmDVSCrNGSmHWSCnMmrHHauaBPz7IcePGYf/+/YiNjUVBQQF27tyJsWPHwt7evrJrpWcUs0ZKYdZIKcwaKYVZI6Uwa6QUZu0Pjz0Pf8nkAYsXL8aVK1cwaNAgtG7dGgcPHqy04ogAZo2Uw6yRUpg1UgqzRkph1kgpzNofLB/3hRYWFrhz5w62bNmCwsJCAMC2bdvQs2fPSiuOCGDWSDnMGimFWSOlMGukFGaNlMKs3edJZs/bvHmzqNVqiYiIeJLVED0Us0ZKYdZIKcwaKYVZI6Uwa6QUZq3YY18zDwC5ubmoUaMGrKysKvP7BaJSmDVSCrNGSmHWSCnMGimFWSOlMGvFnqiZJyIiIiIiIiLlPfYEeERERERERERkGmzmiYiIiIiIiMwMm3kiIiIiIiIiM8NmnoiIiIiIiMjMsJknIiIiIiIiMjNs5omIiIiIiIjMDJt5IiIiIiIiIjPDZp6IiIiIiIjIzLCZJyIiojKNHj0aKpUKKpUKVlZWqFevHnr06IHvvvsOer3+kdcTExODWrVqVV2hREREzyA280RERFSuoKAgZGVlISMjA9u2bUP37t0xZcoU9OnTB1qt1tTlERERPbPYzBMREVG5bGxsUL9+fTRo0AB+fn6YOXMmNm/ejG3btiEmJgYAEBkZiTZt2sDe3h4eHh54++23cefOHQBAfHw8xowZg9zcXMNR/tmzZwMACgsL8e6776JBgwawt7fHiy++iPj4eNNsKBERkZlhM09EREQV8vLLL6Nt27bYuHEjAMDCwgJffPEFjh8/jmXLlmHXrl149913AQCBgYGIioqCo6MjsrKykJWVhenTpwMAxowZg4SEBKxevRrJyckYMmQIgoKCcPr0aZNtGxERkblQiYiYuggiIiJ6+owePRo5OTn48ccfSz03dOhQJCcnIzU1tdRz69atw8SJE3H9+nUAxdfM//3vf0dOTo5hzNmzZ9GsWTNcunQJ7u7uhuWvvvoqOnTogLlz51b69hAREVUnlqYugIiIiMyPiEClUgEAdu/ejblz5yI1NRW3b9+GVqtFQUEB8vPzYW9vX+brjxw5AhFB8+bNjZZrNBo4OztXef1ERETmjs08ERERVVhaWhoaN26MCxcuIDg4GBMmTEBYWBjq1KmD/fv3Y9y4cSgqKir39Xq9Hmq1GklJSVCr1UbPOTg4VHX5REREZo/NPBEREVXIrl27kJKSgqlTpyIxMRFarRbz58+HhUXxVDxr1641Gm9tbQ2dTme0rH379tDpdMjOzkbnzp0Vq52IiKi6YDNPRERE5dJoNLh69Sp0Oh2uXbuG2NhYhIeHo0+fPhg5ciRSUlKg1WqxYMEC9O3bFwkJCVi8eLHROry8vHDnzh3ExcWhbdu2qFGjBpo3b47hw4dj5MiRmD9/Ptq3b4/r169j165daNOmDYKDg020xUREROaBs9kTERFRuWJjY+Hm5gYvLy8EBQVh9+7d+OKLL7B582ao1Wq0a9cOkZGRiIiIgI+PD1asWIHw8HCjdQQGBmLChAkICQmBq6srPv74YwBAdHQ0Ro4ciWnTpsHb2xv9+vXDoUOH4OHhYYpNJSIiMiuczZ6IiIiIiIjIzPDIPBEREREREZGZYTNPREREREREZGbYzBMRERERERGZGTbzRERERERERGaGzTwRERERERGRmWEzT0RERERERGRm2MwTERERERERmRk280RERERERERmhs08ERERERERkZlhM09ERERERERkZtjMExEREREREZmZ/wcG1GOu7KwkOwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -689,29 +651,29 @@ "source": [ "## Bar plots in pandas\n", "\n", - "In addition to line plots, there are many other options for plotting in pandas.\n", + "In addition to line plots, there are many other options for plotting in `pandas`.\n", "Bar plots are one option, which can be used quite similarly to line plots with the addition of the `kind=bar` parameter.\n", - "Note that it is easiest to plot our selected time range for a bar plot by selecting the dates in our data series first, rather than adjusting the plot limits. Pandas sees bar plot data as categorical, so the date range is more difficult to define for x-axis limits. For the y-axis, we can still define its range using the `ylim=[ymin, ymax]` parameter. Similarly, text placement on a bar plot is more difficult, and most easily done using the index value of the bar where the text should be placed." + "Note that it is easiest to plot our selected time range for a bar plot by selecting the dates in our data `Series` first, rather than adjusting the plot limits. `pandas` sees bar plot data as categorical, so the date range is more difficult to define for x-axis limits. For the y-axis, we can still define its range using the `ylim=[ymin, ymax]` parameter. Similarly, text placement on a bar plot is more difficult, and most easily done using the index value of the bar where the text should be placed." ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 13, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -744,7 +706,7 @@ "source": [ "_**Figure 4.8**. A bar plot using pandas with the example temperature data._\n", "\n", - "You can find more about how to format bar charts on the [pandas documentation website](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.bar.html) [^pandas-docs]." + "You can find more about how to format bar charts on the [`pandas` documentation website](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.plot.bar.html) [^pandas-docs]." ] }, { @@ -753,12 +715,12 @@ "source": [ "## Saving your plots as image files\n", "\n", - "Saving plots created using pandas can be done in several ways.\n", - "The recommendation for use outside of Jupyter notebooks is to use Matplotlib's `plt.savefig()` function.\n", + "Saving plots created using `pandas` can be done in several ways.\n", + "The recommendation for use outside of Jupyter Notebooks is to use the `plt.savefig()` function from `matplotlib`.\n", "When using `plt.savefig()`, you simply give a list of commands to generate a plot and include `plt.savefig()` with some parameters as the last command in the Python cell.\n", "The file name is required, and the image format will be determined based on the listed file extension.\n", "\n", - "Matplotlib plots can be saved in a number of useful file formats, including PNG, PDF, and EPS.\n", + "`matplotlib` plots can be saved in a number of useful file formats, including PNG, PDF, and EPS.\n", "PNG is a nice format for raster images, and EPS is probably easiest to use for vector graphics.\n", "Let's check out an example of how to save our lovely bar plot.\n", "\n", @@ -815,18 +777,42 @@ "source": [ "## Interactive plotting, a teaser\n", "\n", - "We have seen in the previous parts of this chapter that there are many ways to configure and visualize data using Python. Up to this point, however, we have focussed on static visualizations in Jupyter notebooks or those saved as images. As you might imagine, there are numerous Python options to also create interactive visualizations that allow those viewing them to dive deeper into the data and explore. Interactive visualizations are increasingly popular online, and here we provide a brief example of how to create an interactive visualization using the data we have already plotted above. In this example, we will be using the hvPlot library [^hvplot], which we will return to using later in Part 2 of this book.\n", + "We have seen in the previous parts of this chapter that there are many ways to configure and visualize data using Python. Up to this point, however, we have focused on static visualizations in Jupyter Notebooks or those saved as images. As you might imagine, there are numerous Python options to also create interactive visualizations that allow those viewing them to dive deeper into the data and explore. Interactive visualizations are increasingly popular online, and here we provide a brief example of how to create an interactive visualization using the data we have already plotted above. In this example, we will be using the `hvplot` library [^hvplot], which we will return to using later in Part 2 of this book.\n", "\n", - "hvPlot is a high-level plotting package that can accept several different common Python data types and plot them using using the bokeh visualization library [^bokeh]. The great thing with hvPlot is that it takes almost no effort to move from plotting in pandas to creating interactive plots. We can explore this in the following example.\n", + "`hvplot` is a high-level plotting package that can accept several different common Python data types and plot them using using the `bokeh` visualization library [^bokeh]. The great thing with `hvplot` is that it takes almost no effort to move from plotting in `pandas` to creating interactive plots. We can explore this in the following example.\n", "\n", - "Let us start by importing the pandas submodule of hvPlot." + "Let us start by importing the `pandas` submodule of `hvplot`." ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 17, "metadata": {}, "outputs": [ + { + "data": { + "text/html": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, { "data": { "application/javascript": [ @@ -835,12 +821,13 @@ " return new Date();\n", " }\n", "\n", - " var force = true;\n", - " var py_version = '3.4.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", - " var reloading = false;\n", - " var Bokeh = root.Bokeh;\n", + " const force = true;\n", + " const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n", + " const reloading = false;\n", + " const Bokeh = root.Bokeh;\n", "\n", - " if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n", + " // Set a timeout for this load but only if we are not already initializing\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n", " root._bokeh_timeout = Date.now() + 5000;\n", " root._bokeh_failed_load = false;\n", " }\n", @@ -866,16 +853,14 @@ " root._bokeh_onload_callbacks.push(callback);\n", "\n", " if (root._bokeh_is_loading > 0) {\n", + " // Don't load bokeh if it is still initializing\n", " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", " return null;\n", - " }\n", - " if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n", + " // There is nothing to load\n", " run_callbacks();\n", " return null;\n", " }\n", - " if (!reloading) {\n", - " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", - " }\n", "\n", " function on_load() {\n", " root._bokeh_is_loading--;\n", @@ -886,11 +871,12 @@ " }\n", " window._bokeh_on_load = on_load\n", "\n", - " function on_error() {\n", - " console.error(\"failed to load \" + url);\n", + " function on_error(e) {\n", + " const src_el = e.srcElement\n", + " console.error(\"failed to load \" + (src_el.href || src_el.src));\n", " }\n", "\n", - " var skip = [];\n", + " const skip = [];\n", " if (window.requirejs) {\n", " window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n", " root._bokeh_is_loading = css_urls.length + 0;\n", @@ -898,19 +884,20 @@ " root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n", " }\n", "\n", - " var existing_stylesheets = []\n", - " var links = document.getElementsByTagName('link')\n", - " for (var i = 0; i < links.length; i++) {\n", - " var link = links[i]\n", + " const existing_stylesheets = []\n", + " const links = document.getElementsByTagName('link')\n", + " for (let i = 0; i < links.length; i++) {\n", + " const link = links[i]\n", " if (link.href != null) {\n", - "\texisting_stylesheets.push(link.href)\n", + " existing_stylesheets.push(link.href)\n", " }\n", " }\n", - " for (var i = 0; i < css_urls.length; i++) {\n", - " var url = css_urls[i];\n", - " if (existing_stylesheets.indexOf(url) !== -1) {\n", - "\ton_load()\n", - "\tcontinue;\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (existing_stylesheets.indexOf(escaped) !== -1) {\n", + " on_load()\n", + " continue;\n", " }\n", " const element = document.createElement(\"link\");\n", " element.onload = on_load;\n", @@ -921,22 +908,23 @@ " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", " document.body.appendChild(element);\n", " } var existing_scripts = []\n", - " var scripts = document.getElementsByTagName('script')\n", - " for (var i = 0; i < scripts.length; i++) {\n", + " const scripts = document.getElementsByTagName('script')\n", + " for (let i = 0; i < scripts.length; i++) {\n", " var script = scripts[i]\n", " if (script.src != null) {\n", - "\texisting_scripts.push(script.src)\n", + " existing_scripts.push(script.src)\n", " }\n", " }\n", - " for (var i = 0; i < js_urls.length; i++) {\n", - " var url = js_urls[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", " }\n", - " var element = document.createElement('script');\n", + " const element = document.createElement('script');\n", " element.onload = on_load;\n", " element.onerror = on_error;\n", " element.async = false;\n", @@ -944,13 +932,14 @@ " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", " document.head.appendChild(element);\n", " }\n", - " for (var i = 0; i < js_modules.length; i++) {\n", - " var url = js_modules[i];\n", - " if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", + " for (let i = 0; i < js_modules.length; i++) {\n", + " const url = js_modules[i];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", " }\n", " var element = document.createElement('script');\n", " element.onload = on_load;\n", @@ -962,12 +951,13 @@ " document.head.appendChild(element);\n", " }\n", " for (const name in js_exports) {\n", - " var url = js_exports[name];\n", - " if (skip.indexOf(url) >= 0 || root[name] != null) {\n", - "\tif (!window.requirejs) {\n", - "\t on_load();\n", - "\t}\n", - "\tcontinue;\n", + " const url = js_exports[name];\n", + " const escaped = encodeURI(url)\n", + " if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n", + " if (!window.requirejs) {\n", + " on_load();\n", + " }\n", + " continue;\n", " }\n", " var element = document.createElement('script');\n", " element.onerror = on_error;\n", @@ -992,11 +982,11 @@ " document.body.appendChild(element);\n", " }\n", "\n", - " var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.2.min.js\", \"https://cdn.holoviz.org/panel/1.4.5/dist/panel.min.js\"];\n", - " var js_modules = [];\n", - " var js_exports = {};\n", - " var css_urls = [];\n", - " var inline_js = [ function(Bokeh) {\n", + " const js_urls = [\"https://cdn.holoviz.org/panel/1.5.0/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.0/dist/panel.min.js\"];\n", + " const js_modules = [];\n", + " const js_exports = {};\n", + " const css_urls = [];\n", + " const inline_js = [ function(Bokeh) {\n", " Bokeh.set_log_level(\"info\");\n", " },\n", "function(Bokeh) {} // ensure no trailing comma for IE\n", @@ -1004,26 +994,27 @@ "\n", " function run_inline_js() {\n", " if ((root.Bokeh !== undefined) || (force === true)) {\n", - " for (var i = 0; i < inline_js.length; i++) {\n", - "\ttry {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " try {\n", " inline_js[i].call(root, root.Bokeh);\n", - "\t} catch(e) {\n", - "\t if (!reloading) {\n", - "\t throw e;\n", - "\t }\n", - "\t}\n", + " } catch(e) {\n", + " if (!reloading) {\n", + " throw e;\n", + " }\n", + " }\n", " }\n", " // Cache old bokeh versions\n", " if (Bokeh != undefined && !reloading) {\n", - "\tvar NewBokeh = root.Bokeh;\n", - "\tif (Bokeh.versions === undefined) {\n", - "\t Bokeh.versions = new Map();\n", - "\t}\n", - "\tif (NewBokeh.version !== Bokeh.version) {\n", - "\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", - "\t}\n", - "\troot.Bokeh = Bokeh;\n", - " }} else if (Date.now() < root._bokeh_timeout) {\n", + " var NewBokeh = root.Bokeh;\n", + " if (Bokeh.versions === undefined) {\n", + " Bokeh.versions = new Map();\n", + " }\n", + " if (NewBokeh.version !== Bokeh.version) {\n", + " Bokeh.versions.set(NewBokeh.version, NewBokeh)\n", + " }\n", + " root.Bokeh = Bokeh;\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", " setTimeout(run_inline_js, 100);\n", " } else if (!root._bokeh_failed_load) {\n", " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", @@ -1041,8 +1032,12 @@ " // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n", " // before older versions are fully initialized.\n", " if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n", + " // If the timeout and bokeh was not successfully loaded we reset\n", + " // everything and try loading again\n", + " root._bokeh_timeout = Date.now() + 5000;\n", " root._bokeh_is_initializing = false;\n", " root._bokeh_onload_callbacks = undefined;\n", + " root._bokeh_is_loading = 0\n", " console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n", " load_or_wait();\n", " } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n", @@ -1050,13 +1045,16 @@ " } else {\n", " root._bokeh_is_initializing = true\n", " root._bokeh_onload_callbacks = []\n", - " var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n", + " const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n", " if (!reloading && !bokeh_loaded) {\n", - "\troot.Bokeh = undefined;\n", + " if (root.Bokeh) {\n", + " root.Bokeh = undefined;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", " }\n", " load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n", - "\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", - "\trun_inline_js();\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", " });\n", " }\n", " }\n", @@ -1065,7 +1063,7 @@ " setTimeout(load_or_wait, 100)\n", "}(window));" ], - "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n var force = true;\n var py_version = '3.4.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n var reloading = false;\n var Bokeh = root.Bokeh;\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n run_callbacks();\n return null;\n }\n if (!reloading) {\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error() {\n console.error(\"failed to load \" + url);\n }\n\n var skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n var existing_stylesheets = []\n var links = document.getElementsByTagName('link')\n for (var i = 0; i < links.length; i++) {\n var link = links[i]\n if (link.href != null) {\n\texisting_stylesheets.push(link.href)\n }\n }\n for (var i = 0; i < css_urls.length; i++) {\n var url = css_urls[i];\n if (existing_stylesheets.indexOf(url) !== -1) {\n\ton_load()\n\tcontinue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n var scripts = document.getElementsByTagName('script')\n for (var i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n\texisting_scripts.push(script.src)\n }\n }\n for (var i = 0; i < js_urls.length; i++) {\n var url = js_urls[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (var i = 0; i < js_modules.length; i++) {\n var url = js_modules[i];\n if (skip.indexOf(url) !== -1 || existing_scripts.indexOf(url) !== -1) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n var url = js_exports[name];\n if (skip.indexOf(url) >= 0 || root[name] != null) {\n\tif (!window.requirejs) {\n\t on_load();\n\t}\n\tcontinue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n var js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.4.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.4.2.min.js\", \"https://cdn.holoviz.org/panel/1.4.5/dist/panel.min.js\"];\n var js_modules = [];\n var js_exports = {};\n var css_urls = [];\n var inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (var i = 0; i < inline_js.length; i++) {\n\ttry {\n inline_js[i].call(root, root.Bokeh);\n\t} catch(e) {\n\t if (!reloading) {\n\t throw e;\n\t }\n\t}\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n\tvar NewBokeh = root.Bokeh;\n\tif (Bokeh.versions === undefined) {\n\t Bokeh.versions = new Map();\n\t}\n\tif (NewBokeh.version !== Bokeh.version) {\n\t Bokeh.versions.set(NewBokeh.version, NewBokeh)\n\t}\n\troot.Bokeh = Bokeh;\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n var bokeh_loaded = Bokeh != null && (Bokeh.version === py_version || (Bokeh.versions !== undefined && Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n\troot.Bokeh = undefined;\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n\tconsole.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n\trun_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" + "application/vnd.holoviews_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n const py_version = '3.5.2'.replace('rc', '-rc.').replace('.dev', '-dev.');\n const reloading = false;\n const Bokeh = root.Bokeh;\n\n // Set a timeout for this load but only if we are not already initializing\n if (typeof (root._bokeh_timeout) === \"undefined\" || (force || !root._bokeh_is_initializing)) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks;\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, js_modules, js_exports, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n if (js_modules == null) js_modules = [];\n if (js_exports == null) js_exports = {};\n\n root._bokeh_onload_callbacks.push(callback);\n\n if (root._bokeh_is_loading > 0) {\n // Don't load bokeh if it is still initializing\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n } else if (js_urls.length === 0 && js_modules.length === 0 && Object.keys(js_exports).length === 0) {\n // There is nothing to load\n run_callbacks();\n return null;\n }\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n window._bokeh_on_load = on_load\n\n function on_error(e) {\n const src_el = e.srcElement\n console.error(\"failed to load \" + (src_el.href || src_el.src));\n }\n\n const skip = [];\n if (window.requirejs) {\n window.requirejs.config({'packages': {}, 'paths': {}, 'shim': {}});\n root._bokeh_is_loading = css_urls.length + 0;\n } else {\n root._bokeh_is_loading = css_urls.length + js_urls.length + js_modules.length + Object.keys(js_exports).length;\n }\n\n const existing_stylesheets = []\n const links = document.getElementsByTagName('link')\n for (let i = 0; i < links.length; i++) {\n const link = links[i]\n if (link.href != null) {\n existing_stylesheets.push(link.href)\n }\n }\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const escaped = encodeURI(url)\n if (existing_stylesheets.indexOf(escaped) !== -1) {\n on_load()\n continue;\n }\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error;\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n } var existing_scripts = []\n const scripts = document.getElementsByTagName('script')\n for (let i = 0; i < scripts.length; i++) {\n var script = scripts[i]\n if (script.src != null) {\n existing_scripts.push(script.src)\n }\n }\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (let i = 0; i < js_modules.length; i++) {\n const url = js_modules[i];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) !== -1 || existing_scripts.indexOf(escaped) !== -1) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error;\n element.async = false;\n element.src = url;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n for (const name in js_exports) {\n const url = js_exports[name];\n const escaped = encodeURI(url)\n if (skip.indexOf(escaped) >= 0 || root[name] != null) {\n if (!window.requirejs) {\n on_load();\n }\n continue;\n }\n var element = document.createElement('script');\n element.onerror = on_error;\n element.async = false;\n element.type = \"module\";\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n element.textContent = `\n import ${name} from \"${url}\"\n window.${name} = ${name}\n window._bokeh_on_load()\n `\n document.head.appendChild(element);\n }\n if (!js_urls.length && !js_modules.length) {\n on_load()\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.holoviz.org/panel/1.5.0/dist/bundled/reactiveesm/es-module-shims@^1.10.0/dist/es-module-shims.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-3.5.2.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-3.5.2.min.js\", \"https://cdn.holoviz.org/panel/1.5.0/dist/panel.min.js\"];\n const js_modules = [];\n const js_exports = {};\n const css_urls = [];\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {} // ensure no trailing comma for IE\n ];\n\n function run_inline_js() {\n if ((root.Bokeh !== undefined) || (force === true)) {\n for (let i = 0; i < inline_js.length; i++) {\n try {\n inline_js[i].call(root, root.Bokeh);\n } catch(e) {\n if (!reloading) {\n throw e;\n }\n }\n }\n // Cache old bokeh versions\n if (Bokeh != undefined && !reloading) {\n var NewBokeh = root.Bokeh;\n if (Bokeh.versions === undefined) {\n Bokeh.versions = new Map();\n }\n if (NewBokeh.version !== Bokeh.version) {\n Bokeh.versions.set(NewBokeh.version, NewBokeh)\n }\n root.Bokeh = Bokeh;\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n }\n root._bokeh_is_initializing = false\n }\n\n function load_or_wait() {\n // Implement a backoff loop that tries to ensure we do not load multiple\n // versions of Bokeh and its dependencies at the same time.\n // In recent versions we use the root._bokeh_is_initializing flag\n // to determine whether there is an ongoing attempt to initialize\n // bokeh, however for backward compatibility we also try to ensure\n // that we do not start loading a newer (Panel>=1.0 and Bokeh>3) version\n // before older versions are fully initialized.\n if (root._bokeh_is_initializing && Date.now() > root._bokeh_timeout) {\n // If the timeout and bokeh was not successfully loaded we reset\n // everything and try loading again\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_is_initializing = false;\n root._bokeh_onload_callbacks = undefined;\n root._bokeh_is_loading = 0\n console.log(\"Bokeh: BokehJS was loaded multiple times but one version failed to initialize.\");\n load_or_wait();\n } else if (root._bokeh_is_initializing || (typeof root._bokeh_is_initializing === \"undefined\" && root._bokeh_onload_callbacks !== undefined)) {\n setTimeout(load_or_wait, 100);\n } else {\n root._bokeh_is_initializing = true\n root._bokeh_onload_callbacks = []\n const bokeh_loaded = root.Bokeh != null && (root.Bokeh.version === py_version || (root.Bokeh.versions !== undefined && root.Bokeh.versions.has(py_version)));\n if (!reloading && !bokeh_loaded) {\n if (root.Bokeh) {\n root.Bokeh = undefined;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n }\n load_libs(css_urls, js_urls, js_modules, js_exports, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n }\n // Give older versions of the autoload script a head-start to ensure\n // they initialize before we start loading newer version.\n setTimeout(load_or_wait, 100)\n}(window));" }, "metadata": {}, "output_type": "display_data" @@ -1318,40 +1316,16 @@ "metadata": {}, "output_type": "display_data" }, - { - "data": { - "text/html": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, { "data": { "application/vnd.holoviews_exec.v0+json": "", "text/html": [ "
\n", - "
\n", + "
\n", "
\n", "