diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..4d47dbe Binary files /dev/null and b/.DS_Store differ diff --git a/.Rhistory b/.Rhistory new file mode 100644 index 0000000..4280473 --- /dev/null +++ b/.Rhistory @@ -0,0 +1,512 @@ +fname = strsplit(i, "/")[[1]][9] +substring(fname, 1, 8) +subject = substring(fname, 1, 8) +# read in their fitbit data, df +df <- read.csv(i) +head(df) +# list all heart rate data files and select the first as an example +hr_files <- list.files("~/Box/CogNeuroLab/Wearables/data/fitbit/", pattern = "heartrate_1min", full.names = TRUE) +hr_files +hr_fname <- paste0(data_dir, subject, "_heartrate_1min_20190901_20200327.csv") +hr_fname +hr_fname <- paste0(data_dir, "/", subject, "_heartrate_1min_20190901_20200327.csv") +hr_fname +paste0(out_dir, "/", subject, "_interpolated_mean.csv") +hr <- read.csv(hr_fname) +hr +# find fitbit data start and end times and create a sequence in 1 minute intervals +df <- c() +df$Time <- seq(mdy_hms(head(hr[,1], 1)), mdy_hms(tail(hr[,1], 1)), by = "1 min") +library(lubridate) +df$Time <- seq(mdy_hms(head(hr[,1], 1)), mdy_hms(tail(hr[,1], 1)), by = "1 min") +hr$Time <- mdy_hms(hr$Time) +df$Time +# merge sequence with actual fitbit data to identify nans in hr data and associated timestamps +df2 <- merge(df, hr, by = "Time", all = T) +# load in subject's activity data file +# read in their fitbit data, df +df <- read.csv(i) +df$ActivityMinute <- mdy_hms(df$ActivityMinute) +# merge heart rate data and steps data +df3 <- merge(df2, df, by.x = "Time", by.y = "ActivityMinute") +# set NA values for steps where HR is NA +df3$Steps <- ifelse(is.na(df3$Value), NA, df3$Steps) +df3$Steps +sum(is.na(df3$Steps)) +# create df$StepsInt +dfInt <- interpolate_steps(df3) +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df$StepsInt) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df$StepsInt) +print(dim(x)[1]) +} +return(df) +} +# create df$StepsInt +dfInt <- interpolate_steps(df3) +library(dplyr) +library(ggplot2) +library(zoo) +library(reshape2) +# create df$StepsInt +dfInt <- interpolate_steps(df3) +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +df <- c() +x <- c() +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df$StepsInt) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df$StepsInt) +print(dim(x)[1]) +} +return(df) +} +# create df$StepsInt +dfInt <- interpolate_steps(df3) +head(df) +head(df3) +sum(is.na(df3$Steps) +) +# find missing data chunks +find_missing <- function(stepsdata){ +x <- df %>% +dplyr::mutate(missing = ifelse(is.na(stepsdata), 1, 0)) %>% +dplyr::group_by(group = cumsum(c(0, diff(missing) != 0))) %>% +filter(missing == 1 & n() > 1) %>% +summarize("start_missing"=min(as.character(Time)), +"end_missing"=max(as.character(Time)), +"length_missing"=n()) %>% +ungroup() %>% +select(-matches("group")) +# create new cloktime variable +x$startclock=lubridate::hour(x$start_missing) + lubridate::minute(x$start_missing)/60 +x$endclock=lubridate::hour(x$end_missing) + lubridate::minute(x$end_missing)/60 +x <- x[order(x$length_missing),] +return(x) +} +find_missing(df3$Steps) +df3 %>% +dplyr::mutate(missing = ifelse(is.na(stepsdata), 1, 0)) +df3$Steps %>% +dplyr::mutate(missing = ifelse(is.na(stepsdata), 1, 0)) +df3 %>% +dplyr::mutate(missing = ifelse(is.na(Steps), 1, 0)) +# find missing data chunks +find_missing <- function(df){ +x <- df %>% +dplyr::mutate(missing = ifelse(is.na(Steps), 1, 0)) %>% +dplyr::group_by(group = cumsum(c(0, diff(missing) != 0))) %>% +filter(missing == 1 & n() > 1) %>% +summarize("start_missing"=min(as.character(Time)), +"end_missing"=max(as.character(Time)), +"length_missing"=n()) %>% +ungroup() %>% +select(-matches("group")) +# create new cloktime variable +x$startclock=lubridate::hour(x$start_missing) + lubridate::minute(x$start_missing)/60 +x$endclock=lubridate::hour(x$end_missing) + lubridate::minute(x$end_missing)/60 +x <- x[order(x$length_missing),] +return(x) +} +find_missing(df3) +# create df$StepsInt +dfInt <- interpolate_steps(df3) +df3 +str(df3) +find_missing(df3) +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df$StepsInt) +print(dim(x)[1]) +} +return(df) +} +interpolate_steps(df3) +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df$StepsInt) +print(dim(x)[1]) +} +return(df) +} +interpolate_steps(df3) +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df3) +print(dim(x)[1]) +} +return(df) +} +interpolate_steps(df3) +x <- find_missing(df) +x <- find_missing(df3) +x +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df) +print(dim(x)[1]) +} +return(df) +} +interpolate_steps(df3) +# find missing data chunks +find_missing <- function(df){ +x <- df %>% +dplyr::mutate(missing = ifelse(is.na(StepsInt), 1, 0)) %>% +dplyr::group_by(group = cumsum(c(0, diff(missing) != 0))) %>% +filter(missing == 1 & n() > 1) %>% +summarize("start_missing"=min(as.character(Time)), +"end_missing"=max(as.character(Time)), +"length_missing"=n()) %>% +ungroup() %>% +select(-matches("group")) +# create new cloktime variable +x$startclock=lubridate::hour(x$start_missing) + lubridate::minute(x$start_missing)/60 +x$endclock=lubridate::hour(x$end_missing) + lubridate::minute(x$end_missing)/60 +x <- x[order(x$length_missing),] +return(x) +} +interpolate_steps <- function(df){ +# where df is a dataframe containing Steps by minute from fitbit +df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 +# create new dataframe +df$StepsInt <- df$Steps +x <- find_missing(df) +while (dim(x)[1] > 0) { +# convert start and end times to clocktimes +startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 +endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 +# get index values for missing period +replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) +# now we want to see the steps data during the time period of interest on all other days +mean_steps <- df %>% +filter(clocktime >= startclock) %>% +filter(clocktime <= endclock) %>% +summarise(mean_steps = mean(Steps, na.rm = T)) %>% +unlist() +# replace values with the mean steps value from all other time periods +df$StepsInt[replaceindex] <- mean_steps +# checking that we replaced them all +missing <- df %>% +filter(Time > ymd_hms(x$start_missing[1])) %>% +filter(Time < ymd_hms(x$end_missing[1])) %>% +summarise(missing = sum(is.na(StepsInt))) %>% +unlist() +if (missing > 0){ +print("error - detected missing values!") +} else { +print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) +} +# make a plot to check that NA periods of interest are being interpolated +x <- data.frame(x, seq_along(start)) +p <- df %>% +filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% +filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% +select(Time, Steps, StepsInt) %>% +melt(id.vars = c("Time")) %>% +ggplot() + +geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, +ymax=Inf), fill="yellow", alpha=0.02) + +geom_line(aes(x = Time, y = value, group = variable, color = variable)) + +facet_wrap(. ~ variable, nrow = 2) + +scale_color_brewer(palette = "Set1") + +theme_classic() + +xlab("Time") + ylab("Steps") + +ylim(-0.1, max(df$Steps, na.rm = T)) +# to do: figure out how to get these plots to print while in a while loop! +print(p) +# check for missing periods and update on each round of interpolation +x <- find_missing(df) +print(dim(x)[1]) +} +return(df) +} +interpolate_steps(df3) +str(df3) +paste0(data_dir, "/", subject, "_heartrate_1min_*.csv") +hr_files <- list.files(data_dir, pattern = "heartrate_1min", full.names = T) +hr_files +subject diff --git a/Fitbit Actiwatch Time Series Correlation.ipynb b/Fitbit Actiwatch Time Series Correlation.ipynb deleted file mode 100644 index ecfb6f6..0000000 --- a/Fitbit Actiwatch Time Series Correlation.ipynb +++ /dev/null @@ -1,3534 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Time Series Correlation\n", - "\n", - "Code from [Towards Data Science](https://towardsdatascience.com/four-ways-to-quantify-synchrony-between-time-series-data-b99136c4a9c9)\n", - "\n", - "Other resources:\n", - "[Applied Time Series Analysis](https://nwfsc-timeseries.github.io/atsa-labs/sec-tslab-correlation-within-and-among-time-series.html)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/Users/megmcmahon'" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import scipy.stats as stats\n", - "import os\n", - "import glob\n", - "\n", - "home_dir = os.getenv(\"HOME\")\n", - "home_dir" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv\"" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10011_10_24_2019_4_30_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10012_10_18_2019_3_30_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10014_11_11_2019_5_20_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10016_1_24_2020_11_45_00_AM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10023_11_11_2019_1_50_00_PM_New_Analysis.csv']" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv\")\n", - "act_files[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LineActivitySleep/WakeUnnamed: 6
Time
2019-10-18 15:30:003335.00.00.0
2019-10-18 15:31:007478.00.00.0
2019-10-18 15:32:001177.02.00.0
2019-10-18 15:33:0015109.02.00.0
2019-10-18 15:34:0019613.02.00.0
\n", - "
" - ], - "text/plain": [ - " Line Activity Sleep/Wake Unnamed: 6\n", - "Time \n", - "2019-10-18 15:30:00 3 335.0 0.0 0.0\n", - "2019-10-18 15:31:00 7 478.0 0.0 0.0\n", - "2019-10-18 15:32:00 11 77.0 2.0 0.0\n", - "2019-10-18 15:33:00 15 109.0 2.0 0.0\n", - "2019-10-18 15:34:00 19 613.0 2.0 0.0" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# resample actiwatch data to 1 minute bins\n", - "\n", - "act = pd.read_csv(act_files[1], skiprows=156)\n", - "act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - "act = act.set_index(act['Time'])\n", - "act = act.resample('1T').sum()\n", - "act[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10012_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10014_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10016_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10023_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10024_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10025_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10033_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10035_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10038_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10040_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10045_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10049_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10062_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10076_minuteStepsNarrow_20190901_20200327.csv']" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fitbit_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*minuteStepsNarrow*\", recursive=True)\n", - "fitbit_files[0:15]" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ActivityMinuteStepsTimeActivity
Time
2019-10-18 00:00:0010/18/2019 12:00:00 AM02019-10-18 00:00:000
2019-10-18 00:01:0010/18/2019 12:01:00 AM02019-10-18 00:01:000
2019-10-18 00:02:0010/18/2019 12:02:00 AM02019-10-18 00:02:000
2019-10-18 00:03:0010/18/2019 12:03:00 AM02019-10-18 00:03:000
2019-10-18 00:04:0010/18/2019 12:04:00 AM02019-10-18 00:04:000
\n", - "
" - ], - "text/plain": [ - " ActivityMinute Steps Time \\\n", - "Time \n", - "2019-10-18 00:00:00 10/18/2019 12:00:00 AM 0 2019-10-18 00:00:00 \n", - "2019-10-18 00:01:00 10/18/2019 12:01:00 AM 0 2019-10-18 00:01:00 \n", - "2019-10-18 00:02:00 10/18/2019 12:02:00 AM 0 2019-10-18 00:02:00 \n", - "2019-10-18 00:03:00 10/18/2019 12:03:00 AM 0 2019-10-18 00:03:00 \n", - "2019-10-18 00:04:00 10/18/2019 12:04:00 AM 0 2019-10-18 00:04:00 \n", - "\n", - " Activity \n", - "Time \n", - "2019-10-18 00:00:00 0 \n", - "2019-10-18 00:01:00 0 \n", - "2019-10-18 00:02:00 0 \n", - "2019-10-18 00:03:00 0 \n", - "2019-10-18 00:04:00 0 " - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fit = pd.read_csv(fitbit_files[1])\n", - "fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - "fit['Activity'] = fit['Steps']\n", - "fit = fit.set_index(fit['Time'])\n", - "fit[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Activity_ActActivity_Fit
Time
2019-10-18 15:30:00335.0105
2019-10-18 15:31:00478.090
2019-10-18 15:32:0077.013
2019-10-18 15:33:00109.00
2019-10-18 15:34:00613.080
\n", - "
" - ], - "text/plain": [ - " Activity_Act Activity_Fit\n", - "Time \n", - "2019-10-18 15:30:00 335.0 105\n", - "2019-10-18 15:31:00 478.0 90\n", - "2019-10-18 15:32:00 77.0 13\n", - "2019-10-18 15:33:00 109.0 0\n", - "2019-10-18 15:34:00 613.0 80" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = []\n", - "df = pd.merge(act, fit, how='inner', left_index=True, right_index=True, suffixes = ('_Act', '_Fit'))\n", - "df = df[['Activity_Act', 'Activity_Fit']]\n", - "df[0:5]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Check missing values" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Subject missing 0 values from Actiwatch\n", - "Subject missing 0 values from Fitbit\n" - ] - } - ], - "source": [ - "print('Subject missing %s values from Actiwatch' % df['Activity_Act'].isnull().sum())\n", - "print('Subject missing %s values from Fitbit' % df['Activity_Fit'].isnull().sum())" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pandas computed Pearson r: 0.7624352988259909\n", - "Scipy computed Pearson r: 0.7624352988259291 and p-value: 0.0\n" - ] - } - ], - "source": [ - "overall_pearson_r = df.corr().iloc[0,1]\n", - "print(f\"Pandas computed Pearson r: {overall_pearson_r}\")\n", - "# out: Pandas computed Pearson r: 0.2058774513561943\n", - "\n", - "r, p = stats.pearsonr(df.dropna()['Activity_Act'], df.dropna()['Activity_Fit'])\n", - "print(f\"Scipy computed Pearson r: {r} and p-value: {p}\")\n", - "# out: Scipy comput" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "f,ax=plt.subplots(figsize=(7,3), dpi=400)\n", - "df.rolling(window=30,center=True).median().plot(ax=ax)\n", - "ax.set(xlabel='Time',ylabel='Pearson r')\n", - "ax.set(title=f\"Overall Pearson r = {np.round(overall_pearson_r,2)}\");" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'Activity data and rolling window correlation')" - ] - }, - "execution_count": 145, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Set window size to compute moving window synchrony.\n", - "r_window_size = 60\n", - "# Interpolate missing data.\n", - "df_interpolated = df.interpolate()\n", - "df_interpolated = df_interpolated\n", - "# Compute rolling window synchrony\n", - "rolling_r = df_interpolated['Activity_Act'].rolling(window=r_window_size, center=True).corr(df_interpolated['Activity_Fit'])\n", - "f,ax=plt.subplots(2,1,figsize=(14,6), dpi=400, sharex=True)\n", - "df.rolling(window=30,center=True).median().plot(ax=ax[0])\n", - "ax[0].set(xlabel='Frame',ylabel='Activity')\n", - "rolling_r.plot(ax=ax[1])\n", - "ax[1].set(xlabel='Frame',ylabel='Pearson r')\n", - "plt.suptitle(\"Activity data and rolling window correlation\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Time\n", - "2019-10-18 15:30:00 NaN\n", - "2019-10-18 15:31:00 NaN\n", - "2019-10-18 15:32:00 NaN\n", - "2019-10-18 15:33:00 NaN\n", - "2019-10-18 15:34:00 NaN\n", - " ..\n", - "2019-10-25 07:49:00 NaN\n", - "2019-10-25 07:50:00 NaN\n", - "2019-10-25 07:51:00 NaN\n", - "2019-10-25 07:52:00 NaN\n", - "2019-10-25 07:53:00 NaN\n", - "Length: 9624, dtype: float64" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rolling_r" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Not great!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## At what times of day are correlation values low?" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Activity_ActActivity_Fit
Time
2019-10-18 20:15:000.00
2019-10-18 20:16:00261.04
2019-10-18 20:17:00143.00
2019-10-18 20:18:000.00
2019-10-18 20:19:0028.00
.........
2019-10-25 07:20:000.00
2019-10-25 07:21:0055.00
2019-10-25 07:22:000.00
2019-10-25 07:23:000.00
2019-10-25 07:24:000.00
\n", - "

3056 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " Activity_Act Activity_Fit\n", - "Time \n", - "2019-10-18 20:15:00 0.0 0\n", - "2019-10-18 20:16:00 261.0 4\n", - "2019-10-18 20:17:00 143.0 0\n", - "2019-10-18 20:18:00 0.0 0\n", - "2019-10-18 20:19:00 28.0 0\n", - "... ... ...\n", - "2019-10-25 07:20:00 0.0 0\n", - "2019-10-25 07:21:00 55.0 0\n", - "2019-10-25 07:22:00 0.0 0\n", - "2019-10-25 07:23:00 0.0 0\n", - "2019-10-25 07:24:00 0.0 0\n", - "\n", - "[3056 rows x 2 columns]" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_interpolated[df_interpolated.index.isin(rolling_r[rolling_r < 0.5].index)]" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " after removing the cwd from sys.path.\n", - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:5: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " \"\"\"\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Number of Minutes')" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import datetime as dt\n", - "\n", - "df_lowr = df_interpolated[df_interpolated.index.isin(rolling_r[rolling_r < 0.5].index)]\n", - "df_lowr['Time'] = pd.to_datetime(df_lowr.index)\n", - "df_lowr['times'] = df_lowr['Time'].dt.hour\n", - "#df_lowr.groupby(df_lowr['times']).sum()\n", - "fig, ax = plt.subplots()\n", - "ax.hist(df_lowr['times'], bins=22)\n", - "plt.title(\"Number of Minutes with Fitbit vs Actiwatch Activity R < 0.5 per Hour\")\n", - "ax.set_xlabel('Hour')\n", - "ax.set_ylabel('Number of Minutes')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fitbit and Actiwatch have low correlation values around 23:00-01:00 for this participant." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def crosscorr(datax, datay, lag=0, wrap=False):\n", - " \"\"\" Lag-N cross correlation. \n", - " Shifted data filled with NaNs \n", - " \n", - " Parameters\n", - " ----------\n", - " lag : int, default 0\n", - " datax, datay : pandas.Series objects of equal length\n", - " Returns\n", - " ----------\n", - " crosscorr : float\n", - " \"\"\"\n", - " if wrap:\n", - " shiftedy = datay.shift(lag)\n", - " shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n", - " return datax.corr(shiftedy)\n", - " else: \n", - " return datax.corr(datay.shift(lag))\n", - "\n", - "d1 = df['Activity_Act']\n", - "d2 = df['Activity_Fit']\n", - "minutes = 5\n", - "fpm = 30\n", - "rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - "offset = np.ceil(len(rs)/2)-np.argmax(rs)\n", - "\n", - "f,ax=plt.subplots(figsize=(14,3), dpi=400)\n", - "ax.plot(rs)\n", - "ax.axvline(np.ceil(len(rs)/2),color='k',linestyle='--',label='Center')\n", - "ax.axvline(np.argmax(rs),color='r',linestyle='--',label='Peak synchrony')\n", - "ax.set(title=f'Offset = {offset} frames\\nActiwatch <> Fitbit',ylim=[.1,.9],xlim=[90,211], xlabel='Offset',ylabel='Pearson r')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the plot above, we can infer from the negative offset that Actiwatch is leading the interaction (correlation is maximized when Fitbit is pulled forward by 1 frames)." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TimeActivity_ActActivity_Fit
02019-10-18 15:30:00335.0105
12019-10-18 15:31:00478.090
22019-10-18 15:32:0077.013
32019-10-18 15:33:00109.00
42019-10-18 15:34:00613.080
............
96192019-10-25 07:49:000.00
96202019-10-25 07:50:000.00
96212019-10-25 07:51:000.00
96222019-10-25 07:52:000.00
96232019-10-25 07:53:000.00
\n", - "

9624 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " Time Activity_Act Activity_Fit\n", - "0 2019-10-18 15:30:00 335.0 105\n", - "1 2019-10-18 15:31:00 478.0 90\n", - "2 2019-10-18 15:32:00 77.0 13\n", - "3 2019-10-18 15:33:00 109.0 0\n", - "4 2019-10-18 15:34:00 613.0 80\n", - "... ... ... ...\n", - "9619 2019-10-25 07:49:00 0.0 0\n", - "9620 2019-10-25 07:50:00 0.0 0\n", - "9621 2019-10-25 07:51:00 0.0 0\n", - "9622 2019-10-25 07:52:00 0.0 0\n", - "9623 2019-10-25 07:53:00 0.0 0\n", - "\n", - "[9624 rows x 3 columns]" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfn = df.reset_index()\n", - "dfn" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Windowed time lagged cross correlation\n", - "minutes = 5\n", - "fpm = 30\n", - "no_splits = 20\n", - "samples_per_split = df.shape[0]/no_splits\n", - "rss=[]\n", - "dfn = df.reset_index()\n", - "\n", - "for t in range(0, no_splits):\n", - " d1 = dfn['Activity_Act'].loc[(t)*samples_per_split:(t+1)*samples_per_split]\n", - " d2 = dfn['Activity_Fit'].loc[(t)*samples_per_split:(t+1)*samples_per_split]\n", - " rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " rss.append(rs)\n", - "rss = pd.DataFrame(rss)\n", - "f,ax = plt.subplots(figsize=(10,5))\n", - "sns.heatmap(rss,cmap='RdBu_r',ax=ax)\n", - "ax.set(title=f'Windowed Time Lagged Cross Correlation',xlim=[0,301], xlabel='Offset',ylabel='Window epochs')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);\n", - "\n", - "# Rolling window time lagged cross correlation\n", - "minutes = 5\n", - "fpm = 30\n", - "window_size = 300 #samples\n", - "t_start = 0\n", - "t_end = t_start + window_size\n", - "step_size = 30\n", - "rss=[]\n", - "while t_end < 5400:\n", - " d1 = dfn['Activity_Act'].iloc[t_start:t_end]\n", - " d2 = dfn['Activity_Fit'].iloc[t_start:t_end]\n", - " rs = [crosscorr(d1,d2, lag, wrap=False) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " rss.append(rs)\n", - " t_start = t_start + step_size\n", - " t_end = t_end + step_size\n", - "rss = pd.DataFrame(rss)\n", - "\n", - "f,ax = plt.subplots(figsize=(10,10), dpi=400)\n", - "sns.heatmap(rss,cmap='RdBu_r',ax=ax)\n", - "ax.set(title=f'Rolling Windowed Time Lagged Cross Correlation',xlim=[0,301], xlabel='Offset',ylabel='Epochs')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "At offset close to 0, seeing high correlation across many of the epochs, with some epochs with lower correlation values regardless of offset, meaning there are periods with low correlation between the two devices' activity data." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Code to shift time series data: [Andres Araujo](https://stackoverflow.com/questions/33171413/cross-correlation-time-lag-correlation-with-pandas)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "def df_shifted(df, target=None, lag=0):\n", - " if not lag and not target:\n", - " return df \n", - " new = {}\n", - " for c in df.columns:\n", - " if c == target:\n", - " new[c] = df[target]\n", - " else:\n", - " new[c] = df[c].shift(periods=lag)\n", - " return pd.DataFrame(data=new)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Offset is 1.0 frames\n" - ] - } - ], - "source": [ - "print(\"Offset is %s frames\" % offset)\n", - "if offset > 1:\n", - " df_new = df_shifted(df, 'Activity_Act', lag = int(offset))\n", - "\n", - " overall_pearson_r_new = df_new.corr().iloc[0,1]\n", - " print(f\"Pandas computed Pearson r: {overall_pearson_r_new}\")\n", - " # out: Pandas computed Pearson r: 0.2058774513561943\n", - "\n", - " r_new, p_new = stats.pearsonr(df_new.dropna()['Activity_Act'], df_new.dropna()['Activity_Fit'])\n", - " print(f\"Scipy computed Pearson r: {r_new} and p-value: {p_new}\")\n", - " # out: Scipy comput\n", - " \n", - " f_new,ax_new=plt.subplots(figsize=(7,3))\n", - " df_new.set_index('Time').rolling(window=30,center=True).median().plot(ax=ax)\n", - " ax_new.set(xlabel='Time',ylabel='Pearson r')\n", - " ax_new.set(title=f\"Overall Pearson r = {np.round(overall_pearson_r,2)}\");" - ] - }, - { - "cell_type": "code", - "execution_count": 172, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-10-24 16:30:00 NaN\n", - "1 2019-10-24 16:31:00 NaN\n", - "2 2019-10-24 16:32:00 NaN\n", - "3 2019-10-24 16:33:00 NaN\n", - "4 2019-10-24 16:34:00 NaN\n", - "... ... ..\n", - "20123 2019-11-07 15:53:00 NaN\n", - "20124 2019-11-07 15:54:00 NaN\n", - "20125 2019-11-07 15:55:00 NaN\n", - "20126 2019-11-07 15:56:00 NaN\n", - "20127 2019-11-07 15:57:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-10-18 15:30:00 NaN\n", - "1 2019-10-18 15:31:00 NaN\n", - "2 2019-10-18 15:32:00 NaN\n", - "3 2019-10-18 15:33:00 NaN\n", - "4 2019-10-18 15:34:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-11 17:20:00 NaN\n", - "1 2019-11-11 17:21:00 NaN\n", - "2 2019-11-11 17:22:00 NaN\n", - "3 2019-11-11 17:23:00 NaN\n", - "4 2019-11-11 17:24:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-24 11:45:00 NaN\n", - "1 2020-01-24 11:46:00 NaN\n", - "2 2020-01-24 11:47:00 NaN\n", - "3 2020-01-24 11:48:00 NaN\n", - "4 2020-01-24 11:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-11 13:50:00 NaN\n", - "1 2019-11-11 13:51:00 NaN\n", - "2 2019-11-11 13:52:00 NaN\n", - "3 2019-11-11 13:53:00 NaN\n", - "4 2019-11-11 13:54:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-05 15:15:00 NaN\n", - "1 2019-11-05 15:16:00 NaN\n", - "2 2019-11-05 15:17:00 NaN\n", - "3 2019-11-05 15:18:00 NaN\n", - "4 2019-11-05 15:19:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-05 14:15:00 NaN\n", - "1 2019-12-05 14:16:00 NaN\n", - "2 2019-12-05 14:17:00 NaN\n", - "3 2019-12-05 14:18:00 NaN\n", - "4 2019-12-05 14:19:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-07 14:50:00 NaN\n", - "1 2019-11-07 14:51:00 NaN\n", - "2 2019-11-07 14:52:00 NaN\n", - "3 2019-11-07 14:53:00 NaN\n", - "4 2019-11-07 14:54:00 NaN\n", - "... ... ..\n", - "20123 2019-11-21 14:13:00 NaN\n", - "20124 2019-11-21 14:14:00 NaN\n", - "20125 2019-11-21 14:15:00 NaN\n", - "20126 2019-11-21 14:16:00 NaN\n", - "20127 2019-11-21 14:17:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-07 14:45:00 NaN\n", - "1 2020-02-07 14:46:00 NaN\n", - "2 2020-02-07 14:47:00 NaN\n", - "3 2020-02-07 14:48:00 NaN\n", - "4 2020-02-07 14:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-22 21:45:00 NaN\n", - "1 2020-01-22 21:46:00 NaN\n", - "2 2020-01-22 21:47:00 NaN\n", - "3 2020-01-22 21:48:00 NaN\n", - "4 2020-01-22 21:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-29 13:45:00 NaN\n", - "1 2020-01-29 13:46:00 NaN\n", - "2 2020-01-29 13:47:00 NaN\n", - "3 2020-01-29 13:48:00 NaN\n", - "4 2020-01-29 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-02-12 13:08:00 NaN\n", - "20124 2020-02-12 13:09:00 NaN\n", - "20125 2020-02-12 13:10:00 NaN\n", - "20126 2020-02-12 13:11:00 NaN\n", - "20127 2020-02-12 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-04 11:45:00 NaN\n", - "1 2019-12-04 11:46:00 NaN\n", - "2 2019-12-04 11:47:00 NaN\n", - "3 2019-12-04 11:48:00 NaN\n", - "4 2019-12-04 11:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-02 10:45:00 NaN\n", - "1 2019-12-02 10:46:00 NaN\n", - "2 2019-12-02 10:47:00 NaN\n", - "3 2019-12-02 10:48:00 NaN\n", - "4 2019-12-02 10:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-27 13:45:00 NaN\n", - "1 2020-01-27 13:46:00 NaN\n", - "2 2020-01-27 13:47:00 NaN\n", - "3 2020-01-27 13:48:00 NaN\n", - "4 2020-01-27 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-02-10 13:08:00 NaN\n", - "20124 2020-02-10 13:09:00 NaN\n", - "20125 2020-02-10 13:10:00 NaN\n", - "20126 2020-02-10 13:11:00 NaN\n", - "20127 2020-02-10 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-08 23:45:00 NaN\n", - "1 2019-11-08 23:46:00 NaN\n", - "2 2019-11-08 23:47:00 NaN\n", - "3 2019-11-08 23:48:00 NaN\n", - "4 2019-11-08 23:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20076\n", - "[]\n", - "subject 20076 no fitbit data available\n", - "20103\n", - "[15]\n", - "merging 20103_2_20_2020_4_45_00_PM_New_Analysis.csv with WA_20103_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-20 16:45:00 NaN\n", - "1 2020-02-20 16:46:00 NaN\n", - "2 2020-02-20 16:47:00 NaN\n", - "3 2020-02-20 16:48:00 NaN\n", - "4 2020-02-20 16:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20105\n", - "[16]\n", - "merging 20105_2_20_2020_1_45_00_PM_New_Analysis.csv with WA_20105_minuteStepsNarrow_20190901_20200327.csv\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Time R\n", - "0 2020-02-20 13:45:00 NaN\n", - "1 2020-02-20 13:46:00 NaN\n", - "2 2020-02-20 13:47:00 NaN\n", - "3 2020-02-20 13:48:00 NaN\n", - "4 2020-02-20 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-03-05 13:08:00 NaN\n", - "20124 2020-03-05 13:09:00 NaN\n", - "20125 2020-03-05 13:10:00 NaN\n", - "20126 2020-03-05 13:11:00 NaN\n", - "20127 2020-03-05 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20108\n", - "[17]\n", - "merging 20108_2_25_2020_4_45_00_PM_New_Analysis.csv with WA_20108_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-25 16:45:00 NaN\n", - "1 2020-02-25 16:46:00 NaN\n", - "2 2020-02-25 16:47:00 NaN\n", - "3 2020-02-25 16:48:00 NaN\n", - "4 2020-02-25 16:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20113\n", - "[18]\n", - "merging 20113_2_28_2020_2_15_00_PM_New_Analysis.csv with WA_20113_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-28 14:15:00 NaN\n", - "1 2020-02-28 14:16:00 NaN\n", - "2 2020-02-28 14:17:00 NaN\n", - "3 2020-02-28 14:18:00 NaN\n", - "4 2020-02-28 14:19:00 NaN\n", - "... ... ..\n", - "20123 2020-03-13 13:38:00 NaN\n", - "20124 2020-03-13 13:39:00 NaN\n", - "20125 2020-03-13 13:40:00 NaN\n", - "20126 2020-03-13 13:41:00 NaN\n", - "20127 2020-03-13 13:42:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20115\n", - "[19]\n", - "merging 20115_3_12_2020_2_40_00_PM_New_Analysis.csv with WA_20115_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-03-12 14:40:00 NaN\n", - "1 2020-03-12 14:41:00 NaN\n", - "2 2020-03-12 14:42:00 NaN\n", - "3 2020-03-12 14:43:00 NaN\n", - "4 2020-03-12 14:44:00 NaN\n", - "... ... ..\n", - "20123 2020-03-26 14:03:00 NaN\n", - "20124 2020-03-26 14:04:00 NaN\n", - "20125 2020-03-26 14:05:00 NaN\n", - "20126 2020-03-26 14:06:00 NaN\n", - "20127 2020-03-26 14:07:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n" - ] - } - ], - "source": [ - "r_window_size = 120\n", - "rolling_r = []\n", - "rdf = pd.DataFrame(columns = ['Time', 'R'])\n", - "\n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " act = pd.read_csv(f, skiprows=header_offset + 6)\n", - " act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - " act = act.resample('1T', on='Time').sum()\n", - " \n", - " fit = pd.read_csv(fitbit_files[indices[0]])\n", - " fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - " fit['Activity'] = fit['Steps']\n", - "\n", - " df = pd.merge(act, fit, on = 'Time', suffixes = ('_Act', '_Fit'))\n", - " df = df[['Time', 'Activity_Act', 'Activity_Fit']]\n", - " \n", - " rolling_r = df['Activity_Act'].rolling(window=r_window_size, center=True).corr(df['Activity_Fit'])\n", - " rdf['Time'] = df['Time']\n", - " rdf['R'] = rolling_r\n", - " print(rdf)\n", - " rdf.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/correlation/\" + subject + \"_\" + str(r_window_size) + \"_window_rolling_r.txt\")\n", - " \n", - "# df.set_index('Time')\n", - "\n", - "# d1 = df[['Time','Activity_Act']]\n", - "# d2 = df[['Time','Activity_Fit']]\n", - " \n", - "# d1.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/\" + subject + \"_act.txt\", sep = \" \", header = False, index = False)\n", - "# d2.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/fitbit/\" + subject + \"_fit.txt\", sep = \" \", header = False, index = False) \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 211, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:13: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n", - "of pandas will change to not sort by default.\n", - "\n", - "To accept the future behavior, pass 'sort=False'.\n", - "\n", - "To retain the current behavior and silence the warning, pass 'sort=True'.\n", - "\n", - " del sys.path[0]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
RSubjectTimeUnnamed: 0
0NaN100112019-10-24 16:30:000.0
1NaN100112019-10-24 16:31:001.0
2NaN100112019-10-24 16:32:002.0
3NaN100112019-10-24 16:33:003.0
4NaN100112019-10-24 16:34:004.0
\n", - "
" - ], - "text/plain": [ - " R Subject Time Unnamed: 0\n", - "0 NaN 10011 2019-10-24 16:30:00 0.0\n", - "1 NaN 10011 2019-10-24 16:31:00 1.0\n", - "2 NaN 10011 2019-10-24 16:32:00 2.0\n", - "3 NaN 10011 2019-10-24 16:33:00 3.0\n", - "4 NaN 10011 2019-10-24 16:34:00 4.0" - ] - }, - "execution_count": 211, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "subjects = []\n", - "for f in glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/*_act.txt\"):\n", - " subjects.append(str.split(f, \"actiwatch/\")[1][0:5])\n", - "\n", - "subjects \n", - "\n", - "dfcor = pd.DataFrame(columns = ['Time', 'R','Subject'])\n", - "a = pd.DataFrame()\n", - "\n", - "for subject in subjects:\n", - " a = pd.read_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/correlation/\" + subject + \"_10_window_rolling_r.txt\")\n", - " a.loc[:,'Subject'] = subject\n", - " dfcor = pd.concat((dfcor, a))\n", - "\n", - "dfcor[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 232, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Subject Hour\n", - "10011 0.0 0.139213\n", - " 1.0 0.061152\n", - " 2.0 0.135681\n", - " 3.0 0.225732\n", - " 4.0 0.150240\n", - " ... \n", - "20115 19.0 0.377630\n", - " 20.0 0.194753\n", - " 21.0 0.328070\n", - " 22.0 0.221494\n", - " 23.0 0.180645\n", - "Name: R, Length: 480, dtype: float64" - ] - }, - "execution_count": 232, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import datetime as dt\n", - "\n", - "dfcor['Time'] = pd.to_datetime(dfcor['Time'])\n", - "dfcor['Hour'] = dfcor['Time'].dt.hour\n", - "dfcor['Hour'] = dfcor['Hour'].astype(float)\n", - "dfm = dfcor.groupby(['Subject', 'Hour']).mean()['R']\n", - "dfm" - ] - }, - { - "cell_type": "code", - "execution_count": 243, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Hour\n", - "0.0 0.281796\n", - "1.0 0.282439\n", - "2.0 0.283439\n", - "3.0 0.280574\n", - "4.0 0.230017\n", - "5.0 0.242924\n", - "6.0 0.293340\n", - "7.0 0.325577\n", - "8.0 0.332633\n", - "9.0 0.366684\n", - "10.0 0.390324\n", - "11.0 0.362339\n", - "12.0 0.393035\n", - "13.0 0.392728\n", - "14.0 0.366866\n", - "15.0 0.379989\n", - "16.0 0.389629\n", - "17.0 0.380125\n", - "18.0 0.364146\n", - "19.0 0.360860\n", - "20.0 0.355317\n", - "21.0 0.354799\n", - "22.0 0.363602\n", - "23.0 0.309182\n", - "Name: R, dtype: float64" - ] - }, - "execution_count": 243, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfm.groupby('Hour').mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 242, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 242, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "dfm.groupby('Hour').mean().plot(figsize = (10, 8))" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_minuteStepsNarrow_20190901_20200327.csv\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_minuteStepsNarrow_20190901_20200327.csv\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_minuteStepsNarrow_20190901_20200327.csv\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_minuteStepsNarrow_20190901_20200327.csv\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_minuteStepsNarrow_20190901_20200327.csv\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_minuteStepsNarrow_20190901_20200327.csv\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_minuteStepsNarrow_20190901_20200327.csv\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_minuteStepsNarrow_20190901_20200327.csv\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_minuteStepsNarrow_20190901_20200327.csv\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_minuteStepsNarrow_20190901_20200327.csv\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_minuteStepsNarrow_20190901_20200327.csv\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_minuteStepsNarrow_20190901_20200327.csv\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_minuteStepsNarrow_20190901_20200327.csv\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_minuteStepsNarrow_20190901_20200327.csv\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_minuteStepsNarrow_20190901_20200327.csv\n", - "20076\n", - "[]\n", - "subject 20076 no fitbit data available\n", - "20103\n", - "[15]\n", - "merging 20103_2_20_2020_4_45_00_PM_New_Analysis.csv with WA_20103_minuteStepsNarrow_20190901_20200327.csv\n", - "20105\n", - "[16]\n", - "merging 20105_2_20_2020_1_45_00_PM_New_Analysis.csv with WA_20105_minuteStepsNarrow_20190901_20200327.csv\n", - "20108\n", - "[17]\n", - "merging 20108_2_25_2020_4_45_00_PM_New_Analysis.csv with WA_20108_minuteStepsNarrow_20190901_20200327.csv\n", - "20113\n", - "[18]\n", - "merging 20113_2_28_2020_2_15_00_PM_New_Analysis.csv with WA_20113_minuteStepsNarrow_20190901_20200327.csv\n", - "20115\n", - "[19]\n", - "merging 20115_3_12_2020_2_40_00_PM_New_Analysis.csv with WA_20115_minuteStepsNarrow_20190901_20200327.csv\n" - ] - } - ], - "source": [ - "def crosscorr(datax, datay, lag=0, wrap=False):\n", - " \"\"\" Lag-N cross correlation. \n", - " Shifted data filled with NaNs \n", - " \n", - " Parameters\n", - " ----------\n", - " lag : int, default 0\n", - " datax, datay : pandas.Series objects of equal length\n", - " Returns\n", - " ----------\n", - " crosscorr : float\n", - " \"\"\"\n", - " if wrap:\n", - " shiftedy = datay.shift(lag)\n", - " shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n", - " return datax.corr(shiftedy)\n", - " else: \n", - " return datax.corr(datay.shift(lag))\n", - "\n", - "cc = []\n", - "metrics = []\n", - " \n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " act = pd.read_csv(f, skiprows=header_offset + 6)\n", - " act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - " act = act.resample('T', on='Time').sum()\n", - " \n", - " fit = pd.read_csv(fitbit_files[indices[0]])\n", - " fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - " fit['Activity'] = fit['Steps']\n", - "\n", - " df = pd.merge(act, fit, on = 'Time', suffixes = ('_Act', '_Fit'))\n", - " df = df[['Time', 'Activity_Act', 'Activity_Fit']]\n", - " df.set_index('Time')\n", - "\n", - " d1 = df['Activity_Act']\n", - " d2 = df['Activity_Fit']\n", - " minutes = 5\n", - " fpm = 30\n", - " rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " offset = np.ceil(len(rs)/2)-np.argmax(rs)\n", - " \n", - " cc.append([subject, max(rs), offset])" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
subjectcross_coroffset
0100110.4637741.0
1100120.7624351.0
2100140.5967351.0
3100160.7503651.0
4100230.6505561.0
\n", - "
" - ], - "text/plain": [ - " subject cross_cor offset\n", - "0 10011 0.463774 1.0\n", - "1 10012 0.762435 1.0\n", - "2 10014 0.596735 1.0\n", - "3 10016 0.750365 1.0\n", - "4 10023 0.650556 1.0" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cc_df = pd.DataFrame(cc, columns = ['subject', 'cross_cor', 'offset'])\n", - "cc_df.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/crosscor.csv\")\n", - "cc_df[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Mean Cross-Correlation')" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.set_palette(sns.color_palette('Paired'))\n", - "fig, axes = plt.subplots(dpi=400)\n", - "sns.boxplot(y = cc_df['cross_cor'], ax = axes)\n", - "axes.set_title('Fitbit to Actiwatch Cross-Correlation')\n", - "axes.set_xlabel('')\n", - "axes.set_ylabel('Mean Cross-Correlation')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "** Future ** \n", - "1. Sleep stages (Where is this info for actiwatch? For fitbit, read in the sleep file)\n", - "2. Add metrics (sleep efficiency, onset latency, rest-activity measures, etc.)\n", - "3. Group comparisons between young and old" - ] - }, - { - "cell_type": "code", - "execution_count": 201, - "metadata": {}, - "outputs": [], - "source": [ - "#total slep time\n", - "\n", - " # problem with fitbit on this subject?" - ] - }, - { - "cell_type": "code", - "execution_count": 401, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_sleepDay_20190801_20200223.csv\n", - "0.43712572020543233\n", - "404.75\n", - "452.75\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_sleepDay_20190801_20200223.csv\n", - "0.5577895564104254\n", - "460.625\n", - "468.75\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_sleepDay_20190801_20200223.csv\n", - "-0.24001630690962514\n", - "463.375\n", - "398.25\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_sleepDay_20190801_20200223.csv\n", - "0.5150449868048569\n", - "364.94444444444446\n", - "406.44444444444446\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_sleepDay_20190801_20200223.csv\n", - "0.010588429625877095\n", - "352.0\n", - "334.09090909090907\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_sleepDay_20190801_20200223.csv\n", - "0.8861869111036961\n", - "374.0357142857143\n", - "426.07142857142856\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_sleepDay_20190801_20200223.csv\n", - "0.896163486670367\n", - "402.67857142857144\n", - "446.42857142857144\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_sleepDay_20190801_20200223.csv\n", - "-0.19098409963335677\n", - "475.38461538461536\n", - "509.2307692307692\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_sleepDay_20190801_20200223.csv\n", - "0.8119841885482925\n", - "404.0\n", - "422.14285714285717\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_sleepDay_20190801_20200223.csv\n", - "0.5375240772667004\n", - "362.10714285714283\n", - "406.57142857142856\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_sleepDay_20190801_20200223.csv\n", - "0.5681335673696446\n", - "444.2857142857143\n", - "445.14285714285717\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_sleepDay_20190801_20200223.csv\n", - "0.7311272070953267\n", - "406.64285714285717\n", - "431.2142857142857\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_sleepDay_20190801_20200223.csv\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_sleepDay_20190801_20200223.csv\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_sleepDay_20190801_20200223.csv\n", - "0.0007197990452573281\n", - "498.0769230769231\n", - "507.46153846153845\n" - ] - } - ], - "source": [ - "fb_sleep_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*sleepDay*\", recursive=True)\n", - "tst_cor = []\n", - "\n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_sleep_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_sleep_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - " footer_offset = []\n", - " rpx = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Statistics' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for footer_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " footer_offset = footer_offset +6\n", - " break\n", - "\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - "\n", - "\n", - " rpx_metrics = pd.read_csv(f, skiprows=header_offset, nrows=footer_offset-header_offset, engine='python')\n", - " rpx_metrics = rpx_metrics[rpx_metrics['Interval Type'] == 'SLEEP']\n", - " rpx_metrics['Sleep Time'] = rpx_metrics['Sleep Time'].astype(float)\n", - " rpx_metrics['Start Date'] = pd.to_datetime(rpx_metrics['Start Date'])\n", - " \n", - " fb_sleep = pd.read_csv(fitbit_sleep_files[indices[0]], engine='python')\n", - " fb_sleep['Start Date'] = pd.to_datetime(fb_sleep['SleepDay'])\n", - " fb_sleep['Sleep Efficiency'] = (tst_df['TotalMinutesAsleep']/tst_df['TotalTimeInBed'])*100\n", - " \n", - " tst_df = pd.merge(rpx_metrics, fb_sleep, on = 'Start Date')\n", - " \n", - " try:\n", - " r = np.corrcoef(tst_df['Sleep Time'], tst_df['TotalMinutesAsleep'])[0,1]\n", - " m_act = np.mean(tst_df['Sleep Time'])\n", - " m_fit = np.mean(tst_df['TotalMinutesAsleep'])\n", - " m_eff_act = np.nanmean(tst_df['Efficiency'].astype(float))\n", - " m_eff_fit = np.nanmean(tst_df['Sleep Efficiency'])\n", - " \n", - " \n", - " print(r)\n", - " print(m_act)\n", - " print(m_fit)\n", - " \n", - " tst_cor.append([r, 'Actiwatch', m_act, m_eff_act])\n", - " tst_cor.append([r, 'Fitbit', m_fit, m_eff_fit])\n", - " except:\n", - " 'NA'\n", - "\n", - "tst_cor = pd.DataFrame(tst_cor, columns = ['tst_cor', 'device', 'tst_mean', 'efficiency_mean'])" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "10012\n", - "10014\n", - "10016\n", - "10023\n", - "10024\n", - "10025\n", - "10033\n", - "10035\n", - "10038\n", - "10040\n", - "10045\n", - "10049\n", - "10062\n", - "10076\n", - "20103\n", - "20105\n", - "20108\n", - "20113\n", - "20115\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SleepDayTotalSleepRecordsTotalMinutesAsleepTotalTimeInBedSubjectinterval_number
010/25/2019 12:00:00 AM1508556100110
111/4/2019 12:00:00 AM1450488100111
211/5/2019 12:00:00 AM1480544100112
311/6/2019 12:00:00 AM1405429100113
411/7/2019 12:00:00 AM1373404100114
.....................
83/22/2020 12:00:00 AM1491553201158
93/23/2020 12:00:00 AM1423477201159
103/24/2020 12:00:00 AM24484572011510
113/25/2020 12:00:00 AM15085732011511
123/26/2020 12:00:00 AM24344622011512
\n", - "

230 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " SleepDay TotalSleepRecords TotalMinutesAsleep \\\n", - "0 10/25/2019 12:00:00 AM 1 508 \n", - "1 11/4/2019 12:00:00 AM 1 450 \n", - "2 11/5/2019 12:00:00 AM 1 480 \n", - "3 11/6/2019 12:00:00 AM 1 405 \n", - "4 11/7/2019 12:00:00 AM 1 373 \n", - ".. ... ... ... \n", - "8 3/22/2020 12:00:00 AM 1 491 \n", - "9 3/23/2020 12:00:00 AM 1 423 \n", - "10 3/24/2020 12:00:00 AM 2 448 \n", - "11 3/25/2020 12:00:00 AM 1 508 \n", - "12 3/26/2020 12:00:00 AM 2 434 \n", - "\n", - " TotalTimeInBed Subject interval_number \n", - "0 556 10011 0 \n", - "1 488 10011 1 \n", - "2 544 10011 2 \n", - "3 429 10011 3 \n", - "4 404 10011 4 \n", - ".. ... ... ... \n", - "8 553 20115 8 \n", - "9 477 20115 9 \n", - "10 457 20115 10 \n", - "11 573 20115 11 \n", - "12 462 20115 12 \n", - "\n", - "[230 rows x 6 columns]" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fitbit_sleep_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*sleepDay*.csv\")\n", - "fitbit_sleep_files\n", - "\n", - "fit_sleep = pd.DataFrame(columns = ['SleepDay', 'TotalSleepRecords', 'TotalMinutesAsleep', 'TotalTimeInBed', 'Subject'])\n", - "\n", - "\n", - "for file in fitbit_sleep_files:\n", - " subject = str.split(file, \"WA_\")[1][0:5]\n", - " print(subject)\n", - " \n", - " a = pd.read_csv(file, sep = \",\")\n", - " a['Subject'] = subject\n", - " fit_sleep = pd.concat((fit_sleep, a))\n", - "\n", - "fit_sleep['interval_number'] = fit_sleep.index\n", - "fit_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
analysis_namesubject_iddata_start_datedata_start_timeinterval_typeinterval_numberstart_datestart_timeend_dateend_time...percent_immobilefragmentationnumber_of_scoresnumber_of_manualnumber_of_schedulednumber_of_no_responsesavg_scoreavg_manualavg_scheduledUnnamed: 30
39New Analysis1001110/24/20194:30:00 PMSLEEP010/24/20198:55:00 PM10/25/20196:07:00 AM...89.1314.57NaNNaNNaNNaNNaNNaNNaNNaN
40New Analysis1001110/24/20194:30:00 PMSLEEP110/25/201910:42:30 PM10/26/20196:44:30 AM...92.957.05NaNNaNNaNNaNNaNNaNNaNNaN
41New Analysis1001110/24/20194:30:00 PMSLEEP210/26/201910:11:00 PM10/27/20197:09:30 AM...93.5918.31NaNNaNNaNNaNNaNNaNNaNNaN
42New Analysis1001110/24/20194:30:00 PMSLEEP310/28/201912:17:30 AM10/28/20195:57:30 AM...92.3514.79NaNNaNNaNNaNNaNNaNNaNNaN
43New Analysis1001110/24/20194:30:00 PMSLEEP410/28/201911:29:00 PM10/29/20196:02:00 AM...93.266.74NaNNaNNaNNaNNaNNaNNaNNaN
..................................................................
1507New Analysis201153/12/20202:40:00 PMSLEEP93/21/202010:58:00 PM3/22/20208:02:00 AM...86.6719.82NaNNaNNaNNaNNaNNaNNaNNaN
1508New Analysis201153/12/20202:40:00 PMSLEEP103/22/202011:23:30 PM3/23/20207:07:00 AM...88.0323.91NaNNaNNaNNaNNaNNaNNaNNaN
1509New Analysis201153/12/20202:40:00 PMSLEEP113/23/202010:47:30 PM3/24/20207:22:30 AM...87.9622.64NaNNaNNaNNaNNaNNaNNaNNaN
1510New Analysis201153/12/20202:40:00 PMSLEEP123/24/202010:03:30 PM3/25/20206:48:30 AM...88.3819.31NaNNaNNaNNaNNaNNaNNaNNaN
1511New Analysis201153/12/20202:40:00 PMSLEEP133/25/202010:16:00 PM3/26/20207:06:30 AM...88.9716.74NaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

274 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " analysis_name subject_id data_start_date data_start_time interval_type \\\n", - "39 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "40 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "41 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "42 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "43 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "... ... ... ... ... ... \n", - "1507 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1508 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1509 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1510 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1511 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "\n", - " interval_number start_date start_time end_date end_time ... \\\n", - "39 0 10/24/2019 8:55:00 PM 10/25/2019 6:07:00 AM ... \n", - "40 1 10/25/2019 10:42:30 PM 10/26/2019 6:44:30 AM ... \n", - "41 2 10/26/2019 10:11:00 PM 10/27/2019 7:09:30 AM ... \n", - "42 3 10/28/2019 12:17:30 AM 10/28/2019 5:57:30 AM ... \n", - "43 4 10/28/2019 11:29:00 PM 10/29/2019 6:02:00 AM ... \n", - "... ... ... ... ... ... ... \n", - "1507 9 3/21/2020 10:58:00 PM 3/22/2020 8:02:00 AM ... \n", - "1508 10 3/22/2020 11:23:30 PM 3/23/2020 7:07:00 AM ... \n", - "1509 11 3/23/2020 10:47:30 PM 3/24/2020 7:22:30 AM ... \n", - "1510 12 3/24/2020 10:03:30 PM 3/25/2020 6:48:30 AM ... \n", - "1511 13 3/25/2020 10:16:00 PM 3/26/2020 7:06:30 AM ... \n", - "\n", - " percent_immobile fragmentation number_of_scores number_of_manual \\\n", - "39 89.13 14.57 NaN NaN \n", - "40 92.95 7.05 NaN NaN \n", - "41 93.59 18.31 NaN NaN \n", - "42 92.35 14.79 NaN NaN \n", - "43 93.26 6.74 NaN NaN \n", - "... ... ... ... ... \n", - "1507 86.67 19.82 NaN NaN \n", - "1508 88.03 23.91 NaN NaN \n", - "1509 87.96 22.64 NaN NaN \n", - "1510 88.38 19.31 NaN NaN \n", - "1511 88.97 16.74 NaN NaN \n", - "\n", - " number_of_scheduled number_of_no_responses avg_score avg_manual \\\n", - "39 NaN NaN NaN NaN \n", - "40 NaN NaN NaN NaN \n", - "41 NaN NaN NaN NaN \n", - "42 NaN NaN NaN NaN \n", - "43 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "1507 NaN NaN NaN NaN \n", - "1508 NaN NaN NaN NaN \n", - "1509 NaN NaN NaN NaN \n", - "1510 NaN NaN NaN NaN \n", - "1511 NaN NaN NaN NaN \n", - "\n", - " avg_scheduled Unnamed: 30 \n", - "39 NaN NaN \n", - "40 NaN NaN \n", - "41 NaN NaN \n", - "42 NaN NaN \n", - "43 NaN NaN \n", - "... ... ... \n", - "1507 NaN NaN \n", - "1508 NaN NaN \n", - "1509 NaN NaN \n", - "1510 NaN NaN \n", - "1511 NaN NaN \n", - "\n", - "[274 rows x 31 columns]" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_sleep = pd.read_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/Combined Export File WA (2).csv\")\n", - "act_sleep = act_sleep[act_sleep['interval_type'] == 'SLEEP']\n", - "act_sleep['interval_number'] = act_sleep['interval_number'].astype(int) - 1\n", - "act_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [], - "source": [ - "fit_sleep['Subject'] = fit_sleep['Subject'].astype('int')\n", - "fit_sleep['interval_number'] = fit_sleep['interval_number'].astype('int')\n", - "act_sleep['interval_number'] = act_sleep['interval_number'].astype('int')" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
analysis_namesubject_iddata_start_datedata_start_timeinterval_typeinterval_numberstart_datestart_timeend_dateend_time...number_of_no_responsesavg_scoreavg_manualavg_scheduledUnnamed: 30SleepDayTotalSleepRecordsTotalMinutesAsleepTotalTimeInBedSubject
0New Analysis1001110/24/20194:30:00 PMSLEEP010/24/20198:55:00 PM10/25/20196:07:00 AM...NaNNaNNaNNaNNaN10/25/2019 12:00:00 AM150855610011.0
1New Analysis1001110/24/20194:30:00 PMSLEEP110/25/201910:42:30 PM10/26/20196:44:30 AM...NaNNaNNaNNaNNaN11/4/2019 12:00:00 AM145048810011.0
2New Analysis1001110/24/20194:30:00 PMSLEEP210/26/201910:11:00 PM10/27/20197:09:30 AM...NaNNaNNaNNaNNaN11/5/2019 12:00:00 AM148054410011.0
3New Analysis1001110/24/20194:30:00 PMSLEEP310/28/201912:17:30 AM10/28/20195:57:30 AM...NaNNaNNaNNaNNaN11/6/2019 12:00:00 AM140542910011.0
4New Analysis1001110/24/20194:30:00 PMSLEEP410/28/201911:29:00 PM10/29/20196:02:00 AM...NaNNaNNaNNaNNaN11/7/2019 12:00:00 AM137340410011.0
..................................................................
269New Analysis201153/12/20202:40:00 PMSLEEP93/21/202010:58:00 PM3/22/20208:02:00 AM...NaNNaNNaNNaNNaN3/23/2020 12:00:00 AM142347720115.0
270New Analysis201153/12/20202:40:00 PMSLEEP103/22/202011:23:30 PM3/23/20207:07:00 AM...NaNNaNNaNNaNNaN3/24/2020 12:00:00 AM244845720115.0
271New Analysis201153/12/20202:40:00 PMSLEEP113/23/202010:47:30 PM3/24/20207:22:30 AM...NaNNaNNaNNaNNaN3/25/2020 12:00:00 AM150857320115.0
272New Analysis201153/12/20202:40:00 PMSLEEP123/24/202010:03:30 PM3/25/20206:48:30 AM...NaNNaNNaNNaNNaN3/26/2020 12:00:00 AM243446220115.0
273New Analysis201153/12/20202:40:00 PMSLEEP133/25/202010:16:00 PM3/26/20207:06:30 AM...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

274 rows × 36 columns

\n", - "
" - ], - "text/plain": [ - " analysis_name subject_id data_start_date data_start_time interval_type \\\n", - "0 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "1 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "2 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "3 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "4 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - ".. ... ... ... ... ... \n", - "269 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "270 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "271 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "272 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "273 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "\n", - " interval_number start_date start_time end_date end_time ... \\\n", - "0 0 10/24/2019 8:55:00 PM 10/25/2019 6:07:00 AM ... \n", - "1 1 10/25/2019 10:42:30 PM 10/26/2019 6:44:30 AM ... \n", - "2 2 10/26/2019 10:11:00 PM 10/27/2019 7:09:30 AM ... \n", - "3 3 10/28/2019 12:17:30 AM 10/28/2019 5:57:30 AM ... \n", - "4 4 10/28/2019 11:29:00 PM 10/29/2019 6:02:00 AM ... \n", - ".. ... ... ... ... ... ... \n", - "269 9 3/21/2020 10:58:00 PM 3/22/2020 8:02:00 AM ... \n", - "270 10 3/22/2020 11:23:30 PM 3/23/2020 7:07:00 AM ... \n", - "271 11 3/23/2020 10:47:30 PM 3/24/2020 7:22:30 AM ... \n", - "272 12 3/24/2020 10:03:30 PM 3/25/2020 6:48:30 AM ... \n", - "273 13 3/25/2020 10:16:00 PM 3/26/2020 7:06:30 AM ... \n", - "\n", - " number_of_no_responses avg_score avg_manual avg_scheduled \\\n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - ".. ... ... ... ... \n", - "269 NaN NaN NaN NaN \n", - "270 NaN NaN NaN NaN \n", - "271 NaN NaN NaN NaN \n", - "272 NaN NaN NaN NaN \n", - "273 NaN NaN NaN NaN \n", - "\n", - " Unnamed: 30 SleepDay TotalSleepRecords \\\n", - "0 NaN 10/25/2019 12:00:00 AM 1 \n", - "1 NaN 11/4/2019 12:00:00 AM 1 \n", - "2 NaN 11/5/2019 12:00:00 AM 1 \n", - "3 NaN 11/6/2019 12:00:00 AM 1 \n", - "4 NaN 11/7/2019 12:00:00 AM 1 \n", - ".. ... ... ... \n", - "269 NaN 3/23/2020 12:00:00 AM 1 \n", - "270 NaN 3/24/2020 12:00:00 AM 2 \n", - "271 NaN 3/25/2020 12:00:00 AM 1 \n", - "272 NaN 3/26/2020 12:00:00 AM 2 \n", - "273 NaN NaN NaN \n", - "\n", - " TotalMinutesAsleep TotalTimeInBed Subject \n", - "0 508 556 10011.0 \n", - "1 450 488 10011.0 \n", - "2 480 544 10011.0 \n", - "3 405 429 10011.0 \n", - "4 373 404 10011.0 \n", - ".. ... ... ... \n", - "269 423 477 20115.0 \n", - "270 448 457 20115.0 \n", - "271 508 573 20115.0 \n", - "272 434 462 20115.0 \n", - "273 NaN NaN NaN \n", - "\n", - "[274 rows x 36 columns]" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep = pd.merge(act_sleep, fit_sleep, how='left', left_on=['subject_id','interval_number'], right_on = ['Subject','interval_number'])\n", - "df_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['analysis_name', 'subject_id', 'data_start_date', 'data_start_time',\n", - " 'interval_type', 'interval_number', 'start_date', 'start_time',\n", - " 'end_date', 'end_time', 'duration', 'off_wrist', 'percent_off_wrist',\n", - " 'total_ac', 'percent_invalid_sw', 'onset_latency', 'efficiency',\n", - " 'wake_time', 'percent_wake', 'sleep_time', 'percent_sleep',\n", - " 'percent_immobile', 'fragmentation', 'number_of_scores',\n", - " 'number_of_manual', 'number_of_scheduled', 'number_of_no_responses',\n", - " 'avg_score', 'avg_manual', 'avg_scheduled', 'Unnamed: 30'],\n", - " dtype='object')" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_sleep.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['SleepDay', 'TotalSleepRecords', 'TotalMinutesAsleep', 'TotalTimeInBed',\n", - " 'Subject', 'interval_number'],\n", - " dtype='object')" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fit_sleep.columns" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Total Sleep Time Correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.6274709645794498" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "column_1 = df_sleep[\"sleep_time\"].astype('float')\n", - "column_2 = df_sleep[\"TotalMinutesAsleep\"].astype('float')\n", - "correlation = column_1.corr(column_2)\n", - "correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch mean TST is 421.75 +/- 106.93\n", - "Fitbit mean TST is 428.77 +/- 100.81\n" - ] - } - ], - "source": [ - "print(\"Actiwatch mean TST is %.2f +/- %.2f\" % (df_sleep[\"sleep_time\"].astype('float').mean(), df_sleep[\"sleep_time\"].astype('float').std()))\n", - "print(\"Fitbit mean TST is %.2f +/- %.2f\" % (df_sleep[\"TotalMinutesAsleep\"].astype('float').mean(), df_sleep[\"TotalMinutesAsleep\"].astype('float').std()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-7.0166937010002925" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"sleep_time\"].astype('float').mean() - df_sleep[\"TotalMinutesAsleep\"].astype('float').mean()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Time In Bed Correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.5758078399291401" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep['tib'] = (df_sleep[\"sleep_time\"].astype('float') * 100)/df_sleep[\"percent_sleep\"].astype('float')\n", - "column_1 = df_sleep[\"tib\"].astype('float')\n", - "column_2 = df_sleep[\"TotalTimeInBed\"].astype('float')\n", - "correlation = column_1.corr(column_2)\n", - "correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 551.997205\n", - "1 482.014388\n", - "2 538.528421\n", - "3 339.984817\n", - "4 392.996531\n", - " ... \n", - "269 543.998220\n", - "270 463.475524\n", - "271 515.000542\n", - "272 524.980699\n", - "273 530.477759\n", - "Name: tib, Length: 274, dtype: float64" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep['tib']" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 556.0\n", - "1 488.0\n", - "2 544.0\n", - "3 429.0\n", - "4 404.0\n", - " ... \n", - "269 477.0\n", - "270 457.0\n", - "271 573.0\n", - "272 462.0\n", - "273 NaN\n", - "Name: TotalTimeInBed, Length: 274, dtype: float64" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"TotalTimeInBed\"].astype('float')" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch mean TIB is 466.92 +/- 113.54\n", - "Fitbit mean TIB is 458.29 +/- 108.92\n" - ] - } - ], - "source": [ - "print(\"Actiwatch mean TIB is %.2f +/- %.2f\" % (df_sleep[\"tib\"].astype('float').mean(), df_sleep[\"tib\"].astype('float').std()))\n", - "print(\"Fitbit mean TIB is %.2f +/- %.2f\" % (df_sleep[\"TotalTimeInBed\"].astype('float').mean(), df_sleep[\"TotalTimeInBed\"].astype('float').std()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8.624066661546749" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"tib\"].astype('float').mean() - df_sleep[\"TotalTimeInBed\"].astype('float').mean()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/R/.DS_Store b/R/.DS_Store new file mode 100644 index 0000000..5008ddf Binary files /dev/null and b/R/.DS_Store differ diff --git a/README.nd b/README.nd deleted file mode 100644 index ad2403c..0000000 --- a/README.nd +++ /dev/null @@ -1,3 +0,0 @@ -# wearables - -This is crazy and I am learning so much! diff --git a/__init__.py b/__init__.py deleted file mode 100644 index 8b13789..0000000 --- a/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/actiwatch-vs-fitbit.Rmd b/actiwatch-vs-fitbit.Rmd deleted file mode 100644 index 525f16e..0000000 --- a/actiwatch-vs-fitbit.Rmd +++ /dev/null @@ -1,115 +0,0 @@ ---- -title: "Validation Study" -author: "Megan McMahon" -date: "1/11/2020" -output: html_document ---- - -```{r setup, include=FALSE} -knitr::opts_chunk$set(echo = TRUE) - -library(readr) -library(tidyverse) -library(ggplot2) -library(lubridate) - -steps_files <- list.files("~/Box/CogNeuroLab/Wearable Assessment/data/fitbit", pattern = "WA_?????_.*.minuteStepsNarrow.*.csv", recursive = TRUE, full.names= TRUE) - -d <- read.csv(steps_files[1]) -head(d) - -``` - - -```{r} -read_activity_file <- function(filename, device) { - # read actigraphy file - csv format, 2 columns, datetime and activity - d=read.csv(filename, header=TRUE, sep=',', na.string=' ', stringsAsFactors = FALSE) - colnames(d) <- c('time', 'activity') - - if (device == "fitbit" | device == "Fitbit") { - d$time <- lubridate::parse_date_time(d$time, "%m/%d/%Y %I:%M:%S %p") - d$record_id <- stringr::str_sub(basename(filename), 4, 8) - d$period <- tail(d$time, 1) - head(d$time, 1) - - } else if (device == "actiwatch" | device == "Actiwatch") { - d$record_id <- stringr::str_sub(basename(filename), 1, 5) - d$period <- ymd_hms(tail(d$time, 1), tz="UTC") - ymd_hms(head(d$time, 1), tz="UTC") - - } else { - print("Invalid device type") - } - - d %>% - mutate(hour = lubridate::hour(time)) %>% - group_by(hour) %>% - summarise(activity_h=sum(activity)) %>% - na.omit() - - return(d) -} - -get_all_activity_data <- function(actiwatch_file, fitbit_file, print = TRUE) { - #act <- read_activity_file(actiwatch_file, "actiwatch") - fitbit <- read_activity_file(fitbit_file, "fitbit") - d <- merge(act, select(fitbit, -record_id), by = "time", all = TRUE, suffixes = c("_act", "_fit") ) - - - print(head(d)) - - return(d) -} - -# generate random actiwatch data for testing -ex <- read_activity_file(steps_files[1], "fitbit") -act <- ex -corrupt <- rbinom(length(act$activity),1,0.1) # choose an average of 10% to corrupt at random -corrupt <- as.logical(corrupt) -noise <- rnorm(sum(corrupt),0,10) # generate the noise to add -act$activity[corrupt] <- act$activity[corrupt] + noise # about 10% of x has been corrupted - -# full data -d_new <- get_all_activity_data(NA, steps_files[1]) -``` - - - -```{r} -plot_steps <- function(d){ - - #alpha = 0.4 as example to make transparent lines - p.act <- ggplot(d) + - geom_line(aes(x = time, y = activity_act, color = "Actiwatch"), size = 0.3) + - #geom_line(aes(x = time, y = activity_fit, color = "Fitbit"), size = 0.3) + - theme_minimal() + - scale_color_manual(name = "Device", values = c("blue", "red")) + - facet_wrap(. ~ day(time), scales = "free_x") + - scale_x_discrete(expand = c(0,0), label = '') + - xlab("Time") + ylab("Activity") + - ggtitle(paste("Activity Band Data", d$record_id[1])) - - return(p.act) -} - -plot_steps(d_new) -``` - - - -```{r} -plot_steps_diff <- function(d){ - - p.diff <- ggplot(d) + - geom_line(aes(x = time, y = activity_act - activity_fit), size = 0.3) + - theme_minimal() + - facet_wrap(. ~ day(time), scales = "free_x") + - scale_x_discrete(expand = c(0,0), label = '') + - xlab("Time") + ylab("Activity") + - ggtitle(paste("Discrepancy in Activity Band Recordings:", d$record_id[1])) - - return(p.diff) -} - -plot_steps_diff(d_new) -``` - diff --git a/analysis.Rmd b/analysis.Rmd deleted file mode 100644 index 96f8791..0000000 --- a/analysis.Rmd +++ /dev/null @@ -1,331 +0,0 @@ ---- -title: "Fitbit Analysis" -author: "Megan McMahon" -date: "4/23/2020" -output: html_document ---- - -```{r setup, include=FALSE} -knitr::opts_chunk$set(echo = TRUE) - -library(readr) -library(tidyverse) - -work_dir <- "~/Box/CogNeuroLab/Wearables/data/circadian_measures/7_days/" -``` - -```{r read-data, warning=F} -fit <- read_csv(paste0(work_dir, "nparact_7days_fit.csv")) -fit$Device <- "Fitbit Charge 2 HR" -act <- read_csv(paste0(work_dir, "nparact_7days_act.csv")) -act$Device <- "Actiwatch 2.0" - -fitc <- read_csv(paste0(work_dir, "cosinor_7days_fit.csv")) -actc <- read_csv(paste0(work_dir, "cosinor_7days_act.csv")) - -d1 <- merge(fit, fitc, by = "record_id") -d2 <- merge(act, actc, by = "record_id") -d <- rbind(d1, d2) - -d$Device <- as.factor(d$Device) -d$Group <- factor(ifelse(d$record_id < 20000, -1, 1), labels = c("Young Adults", "Older Adults")) - -d %>% - group_by(Group, Device) %>% - summarise_all(list(mean = mean, sd = sd)) -``` - -# Non-Parametric Circadian Measures - -```{r boxplot} -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = IS, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/IS_box.png", dpi = 300, height = 5, width = 8) - -``` - -```{r} -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = IV, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/IV_box.png", dpi = 300, height = 5, width = 8) - -``` - -```{r} -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = RA, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/RA_box.png", dpi = 300, height = 5, width = 8) - -``` - -```{r} -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = M10, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ggsave("~/Box/CogNeuroLab/wearables/results/figures/M10_box.png", dpi = 300, height = 5, width = 8) - -``` - -```{r} -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = L5, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/L5_box.png", dpi = 300, height = 5, width = 8) - -``` - -# Cosinor Circadian Measures - -```{r} - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = actamp, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("Amplitude") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/amp_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = actphi, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("Acrophase") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/acrophase_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = actbeta, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("Slope (Beta)") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/slope_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = actupmesor, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("Up-Mesor") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/upmesor_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = actdownmesor, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("Down-Mesor") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/downmesor_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = rsqact, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("R-Squared") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/rsqared_box.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Device, y = fact, fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") + - ylab("F-Statistic") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/fact_box.png", dpi = 300, height = 5, width = 8) -``` - -# Other Plots - -```{r} - -d %>% - ggplot() + - geom_boxplot(aes(x = d$IS[d$Device == "Fitbit Charge 2 HR"], y = d$IS[d$Device == "Actiwatch 2.0"], fill = Group)) + - theme_classic() + - facet_wrap(~ Group) + - scale_fill_brewer(palette="Set1") - - -``` - - -```{r scatter plot} -d %>% - drop_na() %>% - dplyr::select(record_id, Device, Group, actphi) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = actphi) %>% - ggplot(aes(x = `Actiwatch 2.0`, y = `Fitbit Charge 2 HR`, group = Group, color = Group)) + - geom_point() + - geom_abline() + - theme_classic() + - facet_wrap(~ Group) + - scale_color_brewer(palette="Set1") + - ggtitle("Acrophase") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/acrophase_scatter.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - dplyr::select(record_id, Device, Group, fact) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = fact) %>% - ggplot(aes(x = `Actiwatch 2.0`, y = `Fitbit Charge 2 HR`, group = Group, color = Group)) + - geom_point() + - geom_abline() + - theme_classic() + - facet_wrap(~ Group) + - scale_color_brewer(palette="Set1") + - ggtitle("F-Statistic") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/fact_scatter.png", dpi = 300, height = 5, width = 8) - -d %>% - drop_na() %>% - dplyr::select(record_id, Device, Group, actamp) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = actamp) %>% - ggplot(aes(x = `Actiwatch 2.0`, y = `Fitbit Charge 2 HR`, group = Group, color = Group)) + - geom_point() + - geom_abline() + - theme_classic() + - facet_wrap(~ Group) + - scale_color_brewer(palette="Set1") + - ggtitle("Amplitude") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/amp_scatter.png", dpi = 300, height = 5, width = 8) -``` - - -```{r bland-altman plot} - -library(PairedData) - -d %>% - dplyr::select(record_id, Device, Group, IS) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = IS) %>% - as.data.frame() %>% - drop_na() -> d2 - -cor.test(d2$`Fitbit Charge 2 HR`, d2$`Actiwatch 2.0`) - -baplot <- paired.plotBA(d2, "Actiwatch 2.0","Fitbit Charge 2 HR", groups="Group") + facet_grid(~Group) + theme_classic() + ggtitle("Interdaily Stability") - -ggsave("~/Box/CogNeuroLab/Wearables/results/figures/IS_baplot.png", plot = baplot, dpi = 300, height = 5, width = 8) - -``` - -```{r} -d %>% - dplyr::select(record_id, Device, Group, IV) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = IV) %>% - as.data.frame() %>% - drop_na() -> d2 - -cor.test(d2$`Fitbit Charge 2 HR`, d2$`Actiwatch 2.0`) - -baplot <- paired.plotBA(d2, "Actiwatch 2.0","Fitbit Charge 2 HR", groups="Group") + facet_grid(~Group) + theme_classic() + ggtitle("Intradaily Variability") -baplot - -ggsave("~/Box/CogNeuroLab/Wearables/results/figures/IV_baplot.png", plot = baplot, dpi = 300, height = 5, width = 8) -``` - -```{r bland altman plot RA} -d %>% - dplyr::select(record_id, Device, Group, RA) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = RA) %>% - as.data.frame() %>% - drop_na() -> d2 - -cor.test(d2$`Fitbit Charge 2 HR`, d2$`Actiwatch 2.0`) - -baplot <- paired.plotBA(d2, "Actiwatch 2.0","Fitbit Charge 2 HR", groups="Group") + facet_grid(~Group) + theme_classic() + ggtitle("Relative Amplitude") -baplot - -ggsave("~/Box/CogNeuroLab/Wearables/results/figures/RA_baplot.png", plot = baplot, dpi = 300, height = 5, width = 8) -``` - -```{r} -d %>% - dplyr::select(record_id, Device, Group, M10) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = M10) %>% - as.data.fM10me() %>% - drop_na() -> d2 - -cor.test(d2$`Fitbit Charge 2 HR`, d2$`Actiwatch 2.0`) - -baplot <- paired.plotBA(d2, "Actiwatch 2.0","Fitbit Charge 2 HR", groups="Group") + facet_grid(~Group) + theme_classic() + ggtitle("M10") -baplot - -ggsave("~/Box/CogNeuroLab/Wearables/results/figures/M10_baplot.png", plot = baplot, dpi = 300, height = 5, width = 8) -``` - -```{r} -d %>% - dplyr::select(record_id, Device, Group, L5) %>% - pivot_wider(id_cols = c("record_id", "Device", "Group"), names_from = Device, values_from = L5) %>% - as.data.fL5me() %>% - drop_na() -> d2 - -cor.test(d2$`Fitbit Charge 2 HR`, d2$`Actiwatch 2.0`) - -baplot <- paired.plotBA(d2, "Actiwatch 2.0","Fitbit Charge 2 HR", groups="Group") + facet_grid(~Group) + theme_classic() + ggtitle("L5") -baplot - -ggsave("~/Box/CogNeuroLab/Wearables/results/figures/L5_baplot.png", plot = baplot, dpi = 300, height = 5, width = 8) -``` - -## Cross-correlation - -```{r} -crosscor <- read_csv("~/Box/CogNeuroLab/Wearables/data/crosscor.csv") -head(crosscor) - -d1 <- merge(d, crosscor, by.x = "record_id", by.y = "subject") -head(d1) - -mean(crosscor$cross_cor, na.rm = T) - -d1 %>% - drop_na() %>% - ggplot() + - geom_boxplot(aes(x = Group, y = cross_cor, fill = Group)) + - theme_classic() + - scale_fill_brewer(palette="Set1") + ylab("Cross-Correlation Coefficient") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/crosscor_box.png", dpi = 300, height = 5, width = 8) - -``` -` - diff --git a/cr_nparact.R b/cr_nparact.R deleted file mode 100644 index d007d3c..0000000 --- a/cr_nparact.R +++ /dev/null @@ -1,215 +0,0 @@ -#fitbit study -act_raw <- "~/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/" -fit_raw <- "~/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/fitbit/" -out <- "~/Box/CogNeuroLab/Wearables/data/circadian_measures/7_days/" - - -truncate_all <- function(in_dir, out_dir, ndays){ - library(lubridate) - # truncate to number of days desired for recording period - for (f in list.files(in_dir)){ - d <- read_delim(paste0(in_dir, f), delim = " ", col_names = F) - subject <- substr(f, 1, 5) - start = ymd_hms(tail(d$X1, 1), tz="UTC") - days(ndays) - d_truncated <- d[d$X1 >= start,] - write.table(d_truncated, paste0(out_dir, subject, "_", ndays, "days.txt"), sep = " ", row.names = F, col.names = F) - } -} - -calc_nparact <- function(in_dir, out_dir, SR, device){ - #device = "act" or "fit" - #SR = 1/60 for validation study if actiwatch has already been resampled from python script - library(nparACT) - actall <- nparACT_base_loop(in_dir, SR = SR, fulldays = F) - actall$record_id <- substr(list.files(in_dir), 1, 5) - write.csv(actall, paste0(out_dir, "nparact_7days_", device, ".csv"), row.names = F) -} - -run_cosinor <- function(d, filename, proc_dir = out_dir, print = FALSE) { - # modified from Stephanie Sherman - - results <- data.frame(stringsAsFactors = FALSE) - d$record_id <- substr(filename, 1, 5) - d$cloktime=lubridate::hour(d$time) + lubridate::minute(d$time)/60 - - if (sum(d$cloktime) != 0) { - d$twopio24 = (2*3.14159)/24 - d$xcos = cos(d$twopio24*d$cloktime) - d$xsin = sin(d$twopio24*d$cloktime) - - #d$activity=as.character(d$ZCM) - #d$activity=as.numeric(d$PIM, 'NA') - d$lactivity = log((d$activity +1),10) - - allwatch=d[,c('record_id','cloktime','lactivity','xcos','xsin','twopio24')] - allwatch=na.omit(allwatch) - - model=lm(allwatch$lactivity ~ allwatch$xcos + allwatch$xsin) - allwatch$linactxb=coef(model)['(Intercept)'] - allwatch$linactcos=coef(model)['allwatch$xcos'] - allwatch$linactsin=coef(model)['allwatch$xsin'] - #need column for residuals called linract - allwatch$linract=model$residuals - - # filename = paste0(work_dir, '/residuals/', subject, '_residuals.csv') - # write.csv(allwatch, file = filename, row.names = FALSE) - - actres1 <- allwatch - - actres1$linactamp = sqrt(actres1$linactcos^2 + actres1$linactsin^2) - actres1$linactmin = actres1$linactxb-actres1$linactamp - - for (p in 1:length(actres1$lactivity[1])){ - if (actres1$linactsin[1] > 0 & actres1$linactcos[1] > 0) { - actres1$phase = atan(actres1$linactsin/actres1$linactcos)} - else if (actres1$linactsin[1] > 0 & actres1$linactcos[1] < 0) { - actres1$phase = 3.14159 - atan(actres1$linactsin/abs(actres1$linactcos))} - else if (actres1$linactsin[1] < 0 & actres1$linactcos[1] < 0) { - actres1$phase = 3.14159 + atan(abs(actres1$linactsin)/abs(actres1$linactcos))} - else {(actres1$linactsin[1] < 0 & actres1$linactcos[1] > 0) - actres1$phase = 2*3.14159 - atan(abs(actres1$linactsin)/(actres1$linactcos))} - } - - actres1$linactacro = actres1$phase*24/(2*3.14159) - - #get sum of squares (uss variable) - linractuss=(sum((actres1$linract)^2))-((sum(actres1$linract))^2/(length(actres1$linract))) - - #num_nonmissingvalues - nlinract=dim(actres1)[1] - - #nonlinear regression - carhythm = function(actphi,actbeta,actalph,actmin,actamp,cloktime) { - twopio24 = (2*3.14159)/24 - rhythm = cos(twopio24*(cloktime - actphi )) - lexpt=actbeta*(rhythm - actalph) - expt = exp(lexpt) - er = expt/(1 + expt) - actmin + actamp*er - - } - - #if want it to print out iterations change trace=TRUE - error = try(b <- nls(actres1$lactivity ~carhythm(actphi,actbeta,actalph,actmin,actamp,cloktime), - data=actres1, algorithm='port', - start=list(actphi = 12,actbeta = 2.00,actalph = 0.0,actmin =0,actamp=1), - lower=list(actphi = -3,actbeta = 0,actalph = -1,actmin =0,actamp=1), - upper=list(actphi = 27,actbeta = Inf,actalph = 1,actmin =Inf,actamp=5), - control=list(maxiter=200), #warnOnly=TRUE - trace=FALSE)) - print(error) - - if(class(error)!="try-error"){ - actres1$rnlact=resid(b) - actres1$pnlact=fitted(b) - - - # take estimates from model and add to actres (in SAS all5) changes parameter names - ## x beginning variables are the same as the e beginning variables - actres1$xactphi=coef(b)['actphi'] - actres1$xactbeta=coef(b)['actbeta'] - actres1$xactalph=coef(b)['actalph'] - actres1$xactmin=coef(b)['actmin'] - actres1$xactamp=coef(b)['actamp'] - - actres1$coact = actres1$linactxb + actres1$linactcos*actres1$xcos + actres1$linactsin*actres1$xsin - - ncssrnlact=(sum((actres1$rnlact)^2))-((sum(actres1$rnlact))^2/(length(actres1$rnlact))) - cssact=(sum((actres1$lactivity)^2))-((sum(actres1$lactivity))^2/(length(actres1$lactivity))) - nact=length(actres1$lactivity) - nlinract=length(actres1$lactivity) - - - actacos=acos(actres1$xactalph[1])/actres1$twopio24[1] - acthalftimel=-actacos + actres1$xactphi[1] - acthalftimer=actacos + actres1$xactphi[1] - actwidthratio = 2*actacos/24 - - - if(actres1$xactalph[1] < -0.99 |actres1$xactalph[1] > 0.99){ - actwidthratio = 0.5 - acthalftimel = (actres1$xactphi[1] - 6) - acthalftimer = actres1$xactphi[1] + 6 - } - - actdervl = -sin((acthalftimel - actres1$xactphi[1])*actres1$twopio24[1]) - actdervr = -sin((acthalftimer - actres1$xactphi[1])*actres1$twopio24[1]) - - #sd is standard error I can get that from nls output - sdactphi=summary(b)$coefficients['actphi',2] - sdactbeta=summary(b)$coefficients['actbeta',2] - sdactalph=summary(b)$coefficients['actalph',2] - sdactmin=summary(b)$coefficients['actmin',2] - sdactamp=summary(b)$coefficients['actamp',2] - - #t is t value from model - tactphi=summary(b)$coefficients['actphi',3] - tactbeta=summary(b)$coefficients['actbeta',3] - tactalph=summary(b)$coefficients['actalph',3] - tactmin=summary(b)$coefficients['actmin',3] - tactamp=summary(b)$coefficients['actamp',3] - - rsqact = (cssact - ncssrnlact)/cssact - fact = ((cssact - ncssrnlact)/4)/(ncssrnlact/(nlinract - 5)) - ndf = 4 - ddfact = nlinract - 5 - efact = ddfact/(ddfact - 2) - varfact = ( 2/ndf )*( efact**2 )*( (ndf + ddfact -2)/(ddfact - 4) ) #wilks p. 187 */; - tfact = (fact - efact)/sqrt(varfact) - varact = cssact/(nlinract - 1) - mselinact = linractuss/(nlinract - 3) - msenlinact = (ncssrnlact/(nlinract - 5)) - fnlrgact = ((linractuss - ncssrnlact)/2)/(ncssrnlact/(nlinract - 5)) - flinact = ((cssact - linractuss)/2)/(linractuss/(nlinract - 3)) - - actmesor = actres1$xactmin[1] + (actres1$xactamp[1]/2) - actupmesor = acthalftimel - actdownmesor = acthalftimer - actamp=actres1$xactamp[1] - actbeta=actres1$xactbeta[1] - actphi=actres1$xactphi[1] - actmin=actres1$xactmin[1] - actalph=actres1$xactalph[1] - session=actres1$session[1] - record_id=actres1$record_id[1] - rhythm=as.character(c(record_id, actamp,actbeta,actphi,actmin,actmesor,actupmesor,actdownmesor,actalph,actwidthratio,rsqact,fact,fnlrgact)) - newline <- data.frame(t(rhythm), stringsAsFactors = FALSE) - #results <- rbind(results, newline) - return(newline) - }else{ - print(paste0("Unable to obtain cosinor model for subject ", d$record_id[1])) - newline <- c(d$record_id[1], rep(NA, 12)) - return(newline) - } - - } -} - -calc_cosinor <- function(in_dir, out_dir, device){ - library(readr) - library(lubridate) - results <- c() - - for (filename in list.files(in_dir)){ - print(filename) - d <- read_delim(paste0(in_dir, filename), delim = " ") - colnames(d) <- c("date", "time", "activity") - d$time <- with(d, ymd(date) + hms(time)) - rhythm <- run_cosinor(d, filename, proc_dir) - results <- rbind(results, rhythm) - - } - colnames(results)=c('record_id','actamp','actbeta','actphi','actmin','actmesor','actupmesor','actdownmesor','actalph','actwidthratio','rsqact','fact','fnlrgact') - write.csv(results, file = paste0(out_dir, "cosinor_7days_", device, ".csv"), row.names = F) - return(results) -} - - - -truncate_all(in_dir=act_raw, out_dir=paste0(out_dir, "actiwatch/"), 7) -calc_nparact(in_dir=paste0(out, "actiwatch/"), out_dir=out, SR=1/60, device = "act") -calc_cosinor(in_dir=paste0(out, "actiwatch/"), out_dir=out, device = "act") - -truncate_all(in_dir=fit_raw, out_dir=paste0(out_dir, "fitbit/"), 7) -calc_nparact(in_dir=paste0(out, "fitbit/"), out_dir=out, SR=1/60, device = "fit") -calc_cosinor(in_dir=paste0(out, "fitbit/"), out_dir=out, device = "fit") diff --git a/docs/Fitbit Actiwatch Time Series Correlation.ipynb b/docs/Fitbit Actiwatch Time Series Correlation.ipynb deleted file mode 100644 index ecfb6f6..0000000 --- a/docs/Fitbit Actiwatch Time Series Correlation.ipynb +++ /dev/null @@ -1,3534 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Time Series Correlation\n", - "\n", - "Code from [Towards Data Science](https://towardsdatascience.com/four-ways-to-quantify-synchrony-between-time-series-data-b99136c4a9c9)\n", - "\n", - "Other resources:\n", - "[Applied Time Series Analysis](https://nwfsc-timeseries.github.io/atsa-labs/sec-tslab-correlation-within-and-among-time-series.html)" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/Users/megmcmahon'" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import pandas as pd\n", - "import numpy as np\n", - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import scipy.stats as stats\n", - "import os\n", - "import glob\n", - "\n", - "home_dir = os.getenv(\"HOME\")\n", - "home_dir" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "'/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv'" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv\"" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10011_10_24_2019_4_30_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10012_10_18_2019_3_30_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10014_11_11_2019_5_20_00_PM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10016_1_24_2020_11_45_00_AM_New_Analysis.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10023_11_11_2019_1_50_00_PM_New_Analysis.csv']" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/*.csv\")\n", - "act_files[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 139, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
LineActivitySleep/WakeUnnamed: 6
Time
2019-10-18 15:30:003335.00.00.0
2019-10-18 15:31:007478.00.00.0
2019-10-18 15:32:001177.02.00.0
2019-10-18 15:33:0015109.02.00.0
2019-10-18 15:34:0019613.02.00.0
\n", - "
" - ], - "text/plain": [ - " Line Activity Sleep/Wake Unnamed: 6\n", - "Time \n", - "2019-10-18 15:30:00 3 335.0 0.0 0.0\n", - "2019-10-18 15:31:00 7 478.0 0.0 0.0\n", - "2019-10-18 15:32:00 11 77.0 2.0 0.0\n", - "2019-10-18 15:33:00 15 109.0 2.0 0.0\n", - "2019-10-18 15:34:00 19 613.0 2.0 0.0" - ] - }, - "execution_count": 139, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "# resample actiwatch data to 1 minute bins\n", - "\n", - "act = pd.read_csv(act_files[1], skiprows=156)\n", - "act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - "act = act.set_index(act['Time'])\n", - "act = act.resample('1T').sum()\n", - "act[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 140, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10012_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10014_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10016_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10023_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10024_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10025_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10033_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10035_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10038_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10040_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10045_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10049_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10062_minuteStepsNarrow_20190901_20200327.csv',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10076_minuteStepsNarrow_20190901_20200327.csv']" - ] - }, - "execution_count": 140, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fitbit_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*minuteStepsNarrow*\", recursive=True)\n", - "fitbit_files[0:15]" - ] - }, - { - "cell_type": "code", - "execution_count": 141, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ActivityMinuteStepsTimeActivity
Time
2019-10-18 00:00:0010/18/2019 12:00:00 AM02019-10-18 00:00:000
2019-10-18 00:01:0010/18/2019 12:01:00 AM02019-10-18 00:01:000
2019-10-18 00:02:0010/18/2019 12:02:00 AM02019-10-18 00:02:000
2019-10-18 00:03:0010/18/2019 12:03:00 AM02019-10-18 00:03:000
2019-10-18 00:04:0010/18/2019 12:04:00 AM02019-10-18 00:04:000
\n", - "
" - ], - "text/plain": [ - " ActivityMinute Steps Time \\\n", - "Time \n", - "2019-10-18 00:00:00 10/18/2019 12:00:00 AM 0 2019-10-18 00:00:00 \n", - "2019-10-18 00:01:00 10/18/2019 12:01:00 AM 0 2019-10-18 00:01:00 \n", - "2019-10-18 00:02:00 10/18/2019 12:02:00 AM 0 2019-10-18 00:02:00 \n", - "2019-10-18 00:03:00 10/18/2019 12:03:00 AM 0 2019-10-18 00:03:00 \n", - "2019-10-18 00:04:00 10/18/2019 12:04:00 AM 0 2019-10-18 00:04:00 \n", - "\n", - " Activity \n", - "Time \n", - "2019-10-18 00:00:00 0 \n", - "2019-10-18 00:01:00 0 \n", - "2019-10-18 00:02:00 0 \n", - "2019-10-18 00:03:00 0 \n", - "2019-10-18 00:04:00 0 " - ] - }, - "execution_count": 141, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fit = pd.read_csv(fitbit_files[1])\n", - "fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - "fit['Activity'] = fit['Steps']\n", - "fit = fit.set_index(fit['Time'])\n", - "fit[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 142, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Activity_ActActivity_Fit
Time
2019-10-18 15:30:00335.0105
2019-10-18 15:31:00478.090
2019-10-18 15:32:0077.013
2019-10-18 15:33:00109.00
2019-10-18 15:34:00613.080
\n", - "
" - ], - "text/plain": [ - " Activity_Act Activity_Fit\n", - "Time \n", - "2019-10-18 15:30:00 335.0 105\n", - "2019-10-18 15:31:00 478.0 90\n", - "2019-10-18 15:32:00 77.0 13\n", - "2019-10-18 15:33:00 109.0 0\n", - "2019-10-18 15:34:00 613.0 80" - ] - }, - "execution_count": 142, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df = []\n", - "df = pd.merge(act, fit, how='inner', left_index=True, right_index=True, suffixes = ('_Act', '_Fit'))\n", - "df = df[['Activity_Act', 'Activity_Fit']]\n", - "df[0:5]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Check missing values" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Subject missing 0 values from Actiwatch\n", - "Subject missing 0 values from Fitbit\n" - ] - } - ], - "source": [ - "print('Subject missing %s values from Actiwatch' % df['Activity_Act'].isnull().sum())\n", - "print('Subject missing %s values from Fitbit' % df['Activity_Fit'].isnull().sum())" - ] - }, - { - "cell_type": "code", - "execution_count": 143, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pandas computed Pearson r: 0.7624352988259909\n", - "Scipy computed Pearson r: 0.7624352988259291 and p-value: 0.0\n" - ] - } - ], - "source": [ - "overall_pearson_r = df.corr().iloc[0,1]\n", - "print(f\"Pandas computed Pearson r: {overall_pearson_r}\")\n", - "# out: Pandas computed Pearson r: 0.2058774513561943\n", - "\n", - "r, p = stats.pearsonr(df.dropna()['Activity_Act'], df.dropna()['Activity_Fit'])\n", - "print(f\"Scipy computed Pearson r: {r} and p-value: {p}\")\n", - "# out: Scipy comput" - ] - }, - { - "cell_type": "code", - "execution_count": 144, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "f,ax=plt.subplots(figsize=(7,3), dpi=400)\n", - "df.rolling(window=30,center=True).median().plot(ax=ax)\n", - "ax.set(xlabel='Time',ylabel='Pearson r')\n", - "ax.set(title=f\"Overall Pearson r = {np.round(overall_pearson_r,2)}\");" - ] - }, - { - "cell_type": "code", - "execution_count": 145, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0.5, 0.98, 'Activity data and rolling window correlation')" - ] - }, - "execution_count": 145, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Set window size to compute moving window synchrony.\n", - "r_window_size = 60\n", - "# Interpolate missing data.\n", - "df_interpolated = df.interpolate()\n", - "df_interpolated = df_interpolated\n", - "# Compute rolling window synchrony\n", - "rolling_r = df_interpolated['Activity_Act'].rolling(window=r_window_size, center=True).corr(df_interpolated['Activity_Fit'])\n", - "f,ax=plt.subplots(2,1,figsize=(14,6), dpi=400, sharex=True)\n", - "df.rolling(window=30,center=True).median().plot(ax=ax[0])\n", - "ax[0].set(xlabel='Frame',ylabel='Activity')\n", - "rolling_r.plot(ax=ax[1])\n", - "ax[1].set(xlabel='Frame',ylabel='Pearson r')\n", - "plt.suptitle(\"Activity data and rolling window correlation\")\n" - ] - }, - { - "cell_type": "code", - "execution_count": 146, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Time\n", - "2019-10-18 15:30:00 NaN\n", - "2019-10-18 15:31:00 NaN\n", - "2019-10-18 15:32:00 NaN\n", - "2019-10-18 15:33:00 NaN\n", - "2019-10-18 15:34:00 NaN\n", - " ..\n", - "2019-10-25 07:49:00 NaN\n", - "2019-10-25 07:50:00 NaN\n", - "2019-10-25 07:51:00 NaN\n", - "2019-10-25 07:52:00 NaN\n", - "2019-10-25 07:53:00 NaN\n", - "Length: 9624, dtype: float64" - ] - }, - "execution_count": 146, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "rolling_r" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Not great!" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## At what times of day are correlation values low?" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
Activity_ActActivity_Fit
Time
2019-10-18 20:15:000.00
2019-10-18 20:16:00261.04
2019-10-18 20:17:00143.00
2019-10-18 20:18:000.00
2019-10-18 20:19:0028.00
.........
2019-10-25 07:20:000.00
2019-10-25 07:21:0055.00
2019-10-25 07:22:000.00
2019-10-25 07:23:000.00
2019-10-25 07:24:000.00
\n", - "

3056 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " Activity_Act Activity_Fit\n", - "Time \n", - "2019-10-18 20:15:00 0.0 0\n", - "2019-10-18 20:16:00 261.0 4\n", - "2019-10-18 20:17:00 143.0 0\n", - "2019-10-18 20:18:00 0.0 0\n", - "2019-10-18 20:19:00 28.0 0\n", - "... ... ...\n", - "2019-10-25 07:20:00 0.0 0\n", - "2019-10-25 07:21:00 55.0 0\n", - "2019-10-25 07:22:00 0.0 0\n", - "2019-10-25 07:23:00 0.0 0\n", - "2019-10-25 07:24:00 0.0 0\n", - "\n", - "[3056 rows x 2 columns]" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_interpolated[df_interpolated.index.isin(rolling_r[rolling_r < 0.5].index)]" - ] - }, - { - "cell_type": "code", - "execution_count": 84, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " after removing the cwd from sys.path.\n", - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:5: SettingWithCopyWarning: \n", - "A value is trying to be set on a copy of a slice from a DataFrame.\n", - "Try using .loc[row_indexer,col_indexer] = value instead\n", - "\n", - "See the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", - " \"\"\"\n" - ] - }, - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Number of Minutes')" - ] - }, - "execution_count": 84, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import datetime as dt\n", - "\n", - "df_lowr = df_interpolated[df_interpolated.index.isin(rolling_r[rolling_r < 0.5].index)]\n", - "df_lowr['Time'] = pd.to_datetime(df_lowr.index)\n", - "df_lowr['times'] = df_lowr['Time'].dt.hour\n", - "#df_lowr.groupby(df_lowr['times']).sum()\n", - "fig, ax = plt.subplots()\n", - "ax.hist(df_lowr['times'], bins=22)\n", - "plt.title(\"Number of Minutes with Fitbit vs Actiwatch Activity R < 0.5 per Hour\")\n", - "ax.set_xlabel('Hour')\n", - "ax.set_ylabel('Number of Minutes')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Fitbit and Actiwatch have low correlation values around 23:00-01:00 for this participant." - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 44, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAEkQAAAUkCAYAAACURc5FAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAA9hAAAPYQB1ayvdAAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Wm8rXVZP/7PxQyCgJbiCISSqCCoOKUIWg5oQo6Z9nf6mTmUY2ZGpZk5pJVp/fw5FA45ombmPIQ5oSCgkjgiOKCioICAjNf/wdooHte9zt5rr73WOWe/36/X/YDvdd/X99rr7HXf68His6u7AwAAAAAAAAAAAAAAAAAAAAAAsEhbLXoAAAAAAAAAAAAAAAAAAAAAAAAAgUgAAAAAAAAAAAAAAAAAAAAAAMDCCUQCAAAAAAAAAAAAAAAAAAAAAAAWTiASAAAAAAAAAAAAAAAAAAAAAACwcAKRAAAAAAAAAAAAAAAAAAAAAACAhROIBAAAAAAAAAAAAAAAAAAAAAAALJxAJAAAAAAAAAAAAAAAAAAAAAAAYOEEIgEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAAFg4gUgAAAAAAAAAAAAAAAAAAAAAAMDCCUQCAAAAAAAAAAAAAAAAAAAAAAAWTiASAAAAAAAAAAAAAAAAAAAAAACwcAKRAAAAAAAAAAAAAAAAAAAAAACAhROIBAAAAAAAAAAAAAAAAAAAAAAALJxAJAAAAAAAAAAAAAAAAAAAAAAAYOEEIgEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAAFg4gUgAAAAAAAAAAAAAAAAAAAAAAMDCCUQCAAAAAAAAAAAAAAAAAAAAAAAWTiASAAAAAAAAAAAAAAAAAAAAAACwcAKRAAAAAAAAAAAAAAAAAAAAAACAhROIBAAAAAAAAAAAAAAAAAAAAAAALJxAJAAAAAAAAAAAAAAAAAAAAAAAYOEEIgEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAAFg4gUgAAAAAAAAAAAAAAAAAAAAAAMDCCUQCAAAAAAAAAAAAAAAAAAAAAAAWTiASAAAAAAAAAAAAAAAAAAAAAACwcAKRAAAAAAAAAAAAAAAAAAAAAACAhROIBAAAAAAAAAAAAAAAAAAAAAAALJxAJAAAAAAAAAAAAAAAAAAAAAAAYOEEIgEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAAFg4gUgAAAAAAAAAAAAAAAAAAAAAAMDCCUQCAAAAAAAAAAAAAAAAAAAAAAAWTiASAAAAAAAAAAAAAAAAAAAAAACwcAKRAAAAAAAAAAAAAAAAAAAAAACAhROIBAAAAAAAAAAAAAAAAAAAAAAALJxAJAAAAAAAAAAAAAAAAAAAAAAAYOG2WfQAAAAAAAAAAABboqq6dpIjkhyc5JZJfjXJrkl2SVJjLtm9u3+8zN7bJLlHkt9Y6r/XUu9dk2w75pInd/c/rvBHAOAqquq2Se6a0X13vyS7ZXTf3WHM6e/s7iPnOB4AAAAAAAAAwBZBIBIAAAAAAAAAsFmpqh0yCqG4WkbhPxckOX+5YUJrrapumOR5Se6fZLsZ9946yVOSPDHJ9WbZG2BaVbVjkmsk2TnJxUnO7e4fLXaq2amqI5L8ZUbhdgAAAAAAAAAArCGBSAAAAAAAAADAJquqtk9yaJI7J7ldkn2TXDdJjTn3/CRfT/K5JP+T5IPd/a25DTua4V5JXpdk9zXofe0kb01yp1n3BqazFAR0UJJbZxQINM5/dPfJ85tq7VXV1ZLcN8m9ktwmyV7Z4L5cVeck+UKS9yc5pru/OucxV20phO6lSR676FkAAAAAAAAAANYLgUgAAAAAAAAAwCanqg5I8oQkD0iy2zIv2yXJgUvHw5J0VX0syauTvKG7L1uLWa9UVbdOckySHdag93ZJ3p7kDrPuDSxPVW2b5OZJDr7KcbNs/DtYpyfZIgKRloKQnpnkcdn4vfkaGYXZ3TnJc6vq3Un+rLtPWdspZ+oFEYYEAAAAAAAAADBXApEAAAAAAAAAgE1GVe2T5IVJfidJrbZdkkOWjr+qqr/o7jessuf4jaq2TvKmrEEY0pJnRhjSwlTVbkmeNKb04+7+x3nPw3xU1Y2S3D4/Dz86MGv3Ht/kVdUhSV6f5AbTXJ7k3knuUVV/k+Svu7tnOd+sVdWhSZ666DkAAAAAAAAAANab2sS/VwIAAAAAAAAArANVVUmekuQ5SXZcw63em+TR3f2dWTatqgdlFIg0zveSvDbJcUm+m+QnA+d9sbuvGNN7pyTfSnKNMddcnuTtSd6X5KtJzlta29B3u/vsST8Dw6pqryTfGFM6o7v3muswzE1VnZzkFjNo9YjuPnoGfRamqh6W5JVJtp1Ry3cmeWB3XzKjfjNXVe9Nco+B8ieTvCXJKUl+lGTcz3Fed39zjcYDAAAAAAAAANhibbPoAQAAAAAAAACA9a2qdk7yuiRHzmG7eyY5oap+p7uPm2HfRw6sH5fknt3941X0PiLjw5AuTnL37v7oKnoDTFRVv5vkX5NsNcO2RyR5Y1U9sLvHhbgtVFVdN8NhSM/o7hfMcx4AAAAAAAAAgPVkll9SAQAAAAAAAABYkaraLcmx2XgY0mVJ3pvkSUkOSXKdJDsl2TbJ7kn2T/LAJC9P8p2N9NojybFVdc+pB7+Kqtoqye0Hyo9ZZRhSktxxYP1fhCEBa6mqbpHk3zL8PbNLk7wmyeEZ3Vu3S7JrkoOTHJXk2xPa3zfJX81s2Nn6jYH1E4UhAQAAAAAAAACsLYFIAAAAAAAAAMBCVNUuST6Q5FYTTrs4yd8l2bO7D+/ul3T3x7r7e919UXdf1t0/7u5Tuvut3f3YJHsmuX+SL03ou32St1fVb87gR7lJkl3GrH+9uz8/g/4HD6y/fQa9gdU7P8kJix5i1qpquyRvSrLDwCmfT7J/dz+8u9/b3d/v7ku7+7zuPqG7n5tk3yQvmbDNn1fVUPjQIg3dd98x1ykAAAAAAAAAANYhgUgAAAAAAAAAwNxVVSV5XYZDJ5JRwMjNu/vp3X3mcnt39+Xd/bYk+yf56yRXDJy6Q5JjqupGy+09YI+B9VNX2Xde/YHl+2mS45K8LMnDktw0yW5JHrDIodbIkzIKfBvn+CR37O4vT2qwFFz3pCTPGDhlqyQvrapN7Xts7rsAAAAAAAAAAAuyzaIHAAAAAAAAAADWpWckOWJC/ZgkD+nuS6bdoLsvS/JXVfXZJG9Jsv2Y03ZN8vaqOri7L55yq90H1n88Zb959wfGuzTJyRmF/xyfUUjbF5buLb9glPG25aiqqyd55kD57CRHdvf5y+3X3S+oqgOT/O6Y8kFL629Y8aBrx30XAAAAAAAAAGBBNrW/rAUAAAAAAAAAbOGqar8kz5pwytuTPGg1YUhX1d3/meR+SS4fOGX/JH+xii12Hlgf2m8m/bt7Vv2B8W7X3Qd19x909yu7+6RxYUhbqD/IKDBunGd095lT9PyjJOcO1P5kin5raa3v6wAAAAAAAAAADBCIBAAAAAAAAADM28uTbDdQ+1yS3+/uK2a5YXe/O8nTJ5zy9Kq6yZTta8rrgE3YOg8d+8OB9a8n+ddpGnb3D5P840D5wKq6/TR914j7OgAAAAAAAADAgmyz6AEAAAAAAAAAgPWjqu6e5JCB8sVJHtLdF67R9v+Q5F5J7jKmtm2Sv0ry4KGLq2rbJL8+pnS9gUt2q6qbL2Ous7r7rKraO8nVlnH+lfMsp/cl3f2V5fYEqKrbJtlnoPzPqwys+79Jjkqy9Zja7yX51Cp6r1hVXSvJtcaUhu7Fe1fVD5fR+svdfen0kwEAAAAAAAAArF/V3YueAQAAAAAAAABYJ6rqE0nuMFB+QXc/Y433v0mSL2T8H5G6IslNu/vLA9fuleQbazDWs7v7WVV1bJI7z7j3Gd2913JPrqprJ7l7koOWjusluXqSXTMKMLlw6fhRkjOWji8nOS7Jid198SyH32C2mye5a5LbJ7lxkhsk2TnJdksz/TDJ15OckOQjST7S3ZdPudeGISnXTfL+MaeemdHrtRLf6O4LppmLTddG7g+P6O6j5zbMKlXVC5I8fUzpiiTX7+7vrrL/+5PcbUzpzO4eCphbE1X1rIzC8GZt7+4+fbVNqmr7JIdm9HodkNG9b/eMApsuSPLNJK/v7hesoOdOGT2HD0qy39KxR0b3+l2SdJKLknw/o3v8yUk+nuTDi753LQUTHpZRuOGBGb0eu2YUanjlc+m4JG/r7o9O0f/qSY5c2uOgjO79u2b0u392Rs+7Y5O8sbu/tsofZyVz7Zzkt5LcKaPfg72TXDOj34PLk5yf0e/CqRn9W/1Xd397jWfaLaPn3y0zeq32zM8/L2yb0e/QhUnOXZrtjCRfTfLpJMcv+ncJAAAAAAAAgE2bQCQAAAAAAAAAYC6q6oAknxson5tkz+4+dw5zvCrJowbKf9/dTx24bq9soYFIVXX3JH+UUbjBuLCo5bgkyUeTvDnJ27v7R1P2uepcO2T0b/W4JDdd4eVnJfnnJC9Z6e/VGoakJMlh3X3sGvVmQbawQKQTMwo42dDx3X2bGfR/QpKXDpRv3t3/u9o9VjDLszLHQKSqOjrJw8ac/wu/I1V1tSR/kuSx+cVwtnHe2d1HTjqhqm6c5IEZ3eNvm1GQ3EpdlORNSV7Y3V+a4vpxcz0r41//Z3f3s65y3tYZvRZPzygMbzk+n+QJ3f2xZcxxrSTPTPKYJDsso3cneWuSJ3f3mcucZ8Wq6hYZ/R78TpKdVnBpJ/lQkudOEwy1kZlum+TJSY7I8l6rcS7PKBjpzUneutqQNQAAAAAAAAC2PFstegAAAAAAAAAAYN14xITaq+cRhrTkHyfUHlpV285pjoWrqutU1TFJ3pfkXpk+DCkZBWz8VpJXJfnXGcx2/yRfT/KyrDwMKRmFiDw7yZer6n6rnQfWg6raLcmBA+X/ntE2H5lQO2xGe2y2qurOSb6YUVDQxsKQNtbrt6vq+CRfSfI3Se6U6cKQkmTHjJ7jX6iqF1fVtH1WpKr2TPKpjEK0lhuGlCQHJPloVR21kf73SXJqkidm+QE/lVHA1Oer6o4rmGl5zauuVVWvS3JykodkZWFIV873W0mOrao3VdU1ZzDTrlX18oz+LR6U6cOQkmTrJHdI8pIk71ntbAAAAAAAAABseQQiAQAAAAAAAADzct8JtVfOa4juPiXJcQPlayWZebjBpqiq9s4o2GAtwoJq6gurdqiqo5O8Ncl1ZzDLtZMcU1UvqKqp54J14qAMv38/M6M9Tk3yk4HaLWe0x2apqh6S5INJbjijlndPcusZ9brSNkmekuR/quoaM+79C6pq/4yeUwdP2yLJc6rqbwf6PzXJO5NM+3NcM8n7q2ra+cbNdEiSLyR56IxaPijJ8VV1s1XMdM0kxyZ5TFbxfB9qP+N+AAAAAAAAAGwBBCIBAAAAAAAAAGuuqvbLcMDD/3b3l+Y5T5JjJtTuPrcpFmQpxOKjSfZc9CxXVVU7J/lAkoetQfunJ3nZGvSFLcmBE2onz2KD7u4knxsoHzSLPTZHVXWPJEcn2XbBoyzXbZN8sKp2WovmVXWDJO9Ncp0ZtPuzqnrABv3/OMmLZtB7pyRvncXrUFX3T/KhjMIZZ2nvJP9dVTedYqbtMgrpmnRvAAAAAAAAAICZ2mbRAwAAAAAAAAAA68JhE2rvm9sUP/f+DAchjJ21u09PUhuuV9XDk/zbmEte090PX+5A3X3ouPWq6oHzf2mWFXhBkhtMqH8ro9fo5CRfT3JukguT7Jhk1yS7J9kvyS2S3CrJ9VcxS5KkqrZN8l9J7jThtMuSfCLJsUk+n+TsJOcluWaS6yW5a5LDl/57nMdV1de6+x9WOy9soW4ysH5pktNnuM/XkvzGmPV9Z7jHRnX3s5I8a8P1qjo2yZ3HXHJYdx+7BqPskeTF+eXv812QUUDO+zO6L38/SWcUmHOLJEdOud/3knw2yQlJvpzkR0vHpUl2W+p/cEb344Mn9Lllkn9J8vAp5xiydZI3Z3Rfv6qzk7w7yYeTnJnknIyeR/skuXeSe2X4j0S+pKre193nV9WhSf5+zDlfyOg5dGJGr/VFGb0Wt07ywCQ3G+i9Z5I/XzqmUlWHJ3ljJn+n89sZ/ewfy+jn/2FGr9W1k+yf0c9/u4FrfzXJf1XVrbv7nBWM9ieZHFT2g4x+Pz+b0fv6Rxn93m6X0eeF3ZL8epIDMvp92WcFewMAAAAAAACwTglEAgAAAAAAAADm4ZYTah+b2xQ/978ZBSlcY0ztgKraursvn/NMc1FVN07yqIHy6UmekuQ/untsENNAzwOT/HaSh2QUfDCNl2R8AEkyCkJ6eZIXdfcZE3q8pqp2yijA4U8zCnDa0Aur6tjuPmmoyYYhKVW1V5JvjDn1jO7ea8I8sLnZa2D9jBnfE08bWN+pqq7V3WfNcK/NwZ8lufpV/vvSJC9N8uzuPm/gmvckeV5V3XCZe5ye5C1J3tzdJy7j/DclSVUdlOSvkhwxcN7Dquq13f2RZc6xHP8no5CoK12Y5PlJ/q67fzrm/A8neUVV3SrJ6zM+2Os6Sf6oql6W5N8zChK60ilJntzdHxqY5z1V9TdJHp9RkNK4710+rar+qbu/P+HnGmvpufyGgb7J6DPLc5K8tbuvGDjnnUn+pqpul+QfMj4Yae8kr0hy/2XOdfUkzxwon53kaUle392XLaffUs99k9wnye9mFKgIAAAAAAAAAL9k6K8hAQAAAAAAAADM0i0m1JYTzDBTS2E/nxso75DxYQpbivslqTHrX0ly6+5+x0rCkJKku0/u7uck2S/JvZN8fCXXV9U9kzx2oPydJId29x9tJAzpylku7O5nJzksyQ/HnLJNkv+3kvm2BFXVm8Fx7KJfJzIUrvPdGe8zqd9eM95rc3DVMKTzkhzW3U+dEIb0M939zY2c8vkkD0jya939p8sMQ7pq/5O6+8gkj04yFIr17JX0XIarhiH9IMkdu/s5A2FIP9Pdn01y1yRDr8ljMgpWuu5V1t6Z0bNvKAzpyt5XdPdLMxwouF2SB0/qMU5VbZXkNUl2HTjlFUlu1d1vnhCGdNU5j0typyRHD5xyv6o6fJnjHZ5kpzHrP0hycHcfvZIwpKX5vtLdL+ruWy/N+V8ruR4AAAAAAACA9UEgEgAAAAAAAAAwDzcaWL8gybfnOchVnDqhts/cppi/ewys/0F3n72axj3y7u5+0XKvqartkvzzQPn7GQVhfGKKWT6d5G5JLh5TPriq7rPSnrAO/OrA+vdnvM/3pphhPbgkyd2nuecNeFGSA7v7mJUG3W2ou1+V4eC6O1bV/qvpP+DCjMKhTlruBd19ZpInD5RvmF/8Gd6b5H7dPe45MdT/tUnePVB+6HL7XMWjktx+oPbC7n7MSuZLku6+rLsfkeQtA6c8Z5mthj4v/El3f2MlM43T3R/v7qNW2wcAAAAAAACALY9AJAAAAAAAAABgTVXVTkl2GyifsdqQhlU4Y0LtenObYv72HLP23e7+6NwnGXlkkr3HrF+e5IjuPn3axkshGn86UH7StH1hS1RVlWT3gfK5M95uUr9rzHivzcnfdvdxs2rW3afP8hnb3a/MKERonN+b1T5X8fTu/t+VXtTdb0/yxY2cdnaSR3b35VPMNRQodKuqWvbv71Ig4FAg0LuSPGOlg23g0Rn/WeeWVXXIMq4f93nhiiRvXdVUAAAAAAAAALARApEAAAAAAAAAgLV23Qm1789til921oTadeY2xfxde8zapHCotfbEgfVXd/enZ9D/X5J8e8z6oVU1LuwB1qtdMvx9svNnvNekfkMBelu6M5I8b9FDLMNfDqz/1oz3+VJG9+9pvW0j9ed39/em7P2ZjH+uJMmBK+hz3yQ3HLN+cZI/Xm2YVXefl+T5A+WHLaPFuM8LZ3X3hdNPBQAAAAAAAAAbJxAJAAAAAAAAAFhrO0+o/WhuU/yycybUJs28uRsXsLDL3KdIUlW3T3KTMaXLkzxrFnt096VJ/nnc9knuOYs9YAux/YTaT2e816R+k+bYkh3d3ZcseoiN6e4TknxnTOnAqprlv90/rzIQ6KMTahcl+ddpGy/NNdR/JYFIjxhYf3V3n76ioYa9JsmPx6wfvoxrx73+O1dVrW4kAAAAAAAAAJhsm0UPAAAAAAAAAABs8XaYULt4blOsbO8d5zbF/J2dZKcN1m5aVXt39zfmPMsRA+vHdvd3Z7jPB5M8b8z6YUlePsN9NmX7L3qAZbhg0QOsc9tNqF02470unXKOLdlrFz3ACnwyyQM2WNs6yX5JTp7RHm9Z5fVfmlD7cHdPCkVcjlMH1vdezsVVtUtGz6Bx3jjVRGN090VV9fEk996gtEdV7dfdQz9HMvq8sKGdkxySyYFTAAAAAAAAALAqApEAAAAAAAAAgLU2KdxiUijGWluvgRynJLnBBmuV5JVVde/u/ukcZ7nbwPo7ZrzPyRmF7Vxtg/WDZrzPJqu7T1n0DGzytp5Qu3zGe03qtx6/03Zmd5+26CFW4PsD63tlNoFIX+/us1bToLu/U1WXJtl2TPm41fRecvrA+q7LvP6wjJ/trCSfmGagCcYFIiWjZ+CkQKRTktxpzPpLq+rO3f2jWQwHAAAAAAAAABvaatEDAAAAAAAAAABbvIsn1MaFAczLpNCjSTNv7j40sH7XJJ+uqrtVVa31EFW1fZKbD5Q/N8u9uvvyJN8bU9qnqtZj+AqMc9mE2qzfJ5P6LTIob1FOXPQAK3TOwPoeM+p/0oz6XDCwPovQpp8MrF99mdffemD9C93dU8wzyXcG1m+ykeuGPi/sn+TEqnpgVU0KUgMAAAAAAACAqfhCFwAAAAAAAACw1n46obbD3KZY2d4XzW2K+XtNkr9OcrUxtQOSvD/JV6vqLUn+M8lnlwKFZu0mGQ7E+tIa7Hd2kn02WNsqyXWSfGsN9oPNzaQgonkGIl0y4702B1+c52ZVdY0kd8wo2Gb/JPtmFORz9SS7ZPpn8y4zGTD54Yz6/CTJbmvUfygQabmvwf4D62v1/Bvnehu57l0ZPR9vMKa2V5I3J/nO0ueFdyb5VHevx/cvAAAAAAAAADMmEAkAAAAAAAAAWGvnTahdc25TrGzv8+c2xZx199lV9bdJnjvhtBsn+fOl47yq+niSTywdn+7uSSFXy7XnhNoPqmoGWyzLNSMQCZLJ4XU7znivnaacY0v147XeoKq2TnL/JA9Jco8MB9KtxqxCDmf1egyF+c2i/1DvrZd5/dAz8PFV9fgp5pnGxM9g3X1pVT0jyb9POO16SZ68dFxUVZ9K8vEkn0zyie4eCo4CAAAAAAAAgEECkQAAAAAAAACAtXbmhNoec5vil117Qu07c5tiMZ6X5KCMwjE25upJDl86kuSnVfXJJB9Ockx3f2XKGa475XWzNuugF9gsdff5VXVZxn+nbJcZbzep349mvNfmYFJw4KpV1SFJXpZk/7XcJ8sPA9qYi2fUZ1H9l2NTeAZu9PnX3W+oqlslecoy+91l6UiSy6rqM0k+kuTt3X3S1JMCAAAAAAAAsK5stegBAAAAAAAAAIAtW3dfnOSHA+U9q2pR31/Ye0Jtiw5E6u5O8qAkz09yxQov3yGjsIPnJvlyVX26qh5VVSv9w1yzDliZ1naLHgA2IUNhRLvNeJ9J/c6Z8V6bgwvWomlVbVVVf5fko1n7MCRWZlN4Bi7r+dfdT03yxCSXrLD/NknukOSoJCdW1f9W1VOqShAhAAAAAAAAABMJRAIAAAAAAAAA5uGrA+vbZ3Iw0Vrab0LtK3ObYkG6+4ru/rMkt0ryvlW0uk2SVyX5UlUdsYLrtl/FnrNUix4ANiFnDazvMeN9JvUbmoGVe2mSpy16CMbaFJ6By37+dfc/ZfS56Y1JLp9yv5smeXGS06rqUVP2AAAAAAAAAGAdWOlf5gMAAAAAAAAAmMbJSW4/UDs4ydfnOEuqapskBw6Uz8+c51mk7j45yT2r6kZJHp7kyCQ3m6LVPkn+o6pekuQp3X3FRs7fWJ0ZqqqbL3qGZbigu7+x6CHWudMz/v1/3RnvM6nf6TPea12qqocmedxGTrsoyWeSfC7JaUm+m+TsJD9JckmSSweue1ySx85m0nXriiRbL3qIleju05L8XlU9Lcn/l+R+SW6Zlf9hzj2SvKqq7pbk4d190WwnBQAAAAAAAGBzJxAJAAAAAAAAAJiHz06oHZLkTfMaZMlBSa42UDupu3uew2wKuvtrSY5KclRV7ZHksIz+be6U5KZJapmtnphR0MNTNnLehRNqt8oojGMe1ksAzxcWPcAyfDTJoYseYp0bej9cv6q26+5ZvS/3GVg/r7vPmdEe61ZV7ZTkRRNOOTHJ3yZ5d3f/dIr+P5x2Nn7mwiS7jll/dZJ/nNMMF0xzUXefmeT5SZ5fVbtndN++c0afF26R5Qc9PTDJ1lX1gPX4uQsAAAAAAACAYQKRAAAAAAAAAIB5+NCE2r3mNsXP3XtCbdKs60J3fy/JG5eOVNU1MwpHumuS+yS5wUZaPLmqPtDd75twztkTamcuzQDM16kD61snuVGSL85on31XuD8r89Ak1x6o/UuSJ3X3pavov/sqrmXk7IwPRLqsu0+Z9zDT6u4fJXnH0pGqunqS30hyl4w+Lwy91690vySPSfLyNRwTAAAAAAAAgM3MVoseAAAAAAAAAADY8nX3GUm+NFC+YVXddp7zJLn/hNr75zbFZqK7z+7ud3T3E7r7hknukOTfk1wx4bLnbKTtNyfUrrHSGYGZOGlC7aBZbFBV2yTZf4r9Wb4HDqx/OMkTVhmGlLhHz8LQM3Czfm27+7zufm93/0l3/3qSAzIK4bp4wmVHVdX285kQAAAAAAAAgM2BQCQAAAAAAAAAYF7eMqH2h/MaoqrulOSmA+XTkhw/r1k2V939qe5+aJLbJfn+wGm3rqp9JrQ5dULtxlMPB6zG55IMheXMKrjuwCRD4ScnzGiPdauqts4otG6cZ3d3z2CbX5tBj/Vu6Bm4RT3/uvtplXpgAAAgAElEQVQL3f34jELQvjxw2vWS3HF+UwEAAAAAAACwqROIBAAAAAAAAADMy9FJhoIYHlxV15/THE+bUDt6RmER60J3H5/kvhn+d73LhGvPSnLGQPnOqxwNmEJ3X5jk0wPlu85om0l9PjyjPdazGyTZccz6OUk+vtrmVbVjkluttg/5zMD6AVW121wnmYPu/mqSeyb56cApg58XAAAAAAAAAFh/BCIBAAAAAAAAAHPR3d9I8p6B8vZJnrPWM1TVbyS5z0D5p0letdYzbGm6+5NJPjlQ3nMjlw+Fn/zm9BOticsH1reb6xSr0N21GRyHLvp1IknywYH1m1bVjWfQ/8iB9a919+kz6L/eXWtg/VszCvy7U5JtZ9BnvfvIwPpW2ULDgZY+B75toLyxzwsAAAAAAAAArCMCkQAAAAAAAACAeXr2hNrDqmrNQgCqavsk/2/CKa/s7u+u1f5buBMG1n9lI9e9Y2B9/6o6bBXzzNpPB9Z3nOsUMB9vnVB76GoaV9WNktxuoPyW1fTmZ4aC2i6aUf/Hz6jPutbd30zy2YHyE+c5y5xN+3kBAAAAAAAAgHVEIBIAAAAAAAAAMDfdfXySYwbKleQ1VbXHGm3/4iQ3G6idl+R5a7TvenDJwPoFG7nufUm+M1D7i+nHmbkfJekx67tV1U7zHgbWUnefmuSkgfIfVtUOq2g/Kejl31fRl587Z2D9uqttXFX7Jbn3avvwM68eWD+kqg6Z6yTzM+3nBQAAAAAAAADWEYFIAAAAAAAAAMC8PTHJuQO16yf5z6raZZYbVtUfJ3n8hFOe0d3fneWe68y+A+tnTrqouy9L8tKB8mFV9bRVTTUjS3N+f6C83zxngTl52cD6tZI8dZqGVfVrSR49UP7v7v7iNH35JT8YWL9hVd1o2qZVtW2S18Z3DmfptUl+OFB7TVX9yjyHmZOpPi8AAAAAAAAAsL74cgIAAAAAAAAAMFfdfWaSP5pwysFJPlxV15rFflX19CQvmXDKB5K8fBZ7beqq6ter6r5VNbPvjFTVdZPcY6B8yjJa/FOSbw/Unl9VvzPVYBNU1fZVdcQKLzt1YP23VzsPrEZVHV1VPXAcOmXb12c4oOSoqtp/hTNuneTfkmw/cMoLVtKPYd39gyTfGSg/fZqeVVUZPUdvPe1c/LLuviDJXw+U90rytlkHRCZJVd2sqm6+kXN+paoeUVXbzXDfqyV50EB5OZ8XAAAAAAAAAFgnBCIBAAAAAAAAAHPX3a9L8rIJpxyc5OSquvu0e1TVr1bVWzM5aOP0JA/u7p52n83MdZK8LcmpVfXoqtpxNc2qauckb8z4kJOzk3x4Yz26+6Ikjx0ob51RIMRzZhHiVFW7VdUzMvp3f/EKL//kwPqTq+qAVQ0Gm5juviTJMwfKOyR5V1XdcDm9lt67r0hyyMApH+zu9698SiYYej0fVVUPXkmjqto2yWsyfJ9mdf4lyXEDtUOSnLCx8KLlqqo7VdW7knwhyYEbOX3nJP+a5LSqempV7brKvbdJ8uoke4wpX5bk7avpDwAAAAAAAMCWRSASAAAAAAAAALAoT07yjgn16yR5X1W9u6oOXW7Tqtqjqv4yydeS3H/CqWclOby7z1lu7y3IvhkFlJxVVW+oqiOraoeVNKiqu2UU4jAUcnJ0d1+2nF7d/V9JXjK0VZKjkpxSVQ9fCudYyZy7L133riTfS/K8jA9k2Jj/HFi/epLPVNUbl0KmDq2qW1bVzQeOq02xNwtSVftO+Lf82ZHRe2rI9ZbTY+lY0e/3Gnttkv8ZqO2Z5PiquvekBkuhSe9J8siBUy5K8sdTT8iQ1w+sb5XkdUshcxsNxKuqw5N8Psnvb1D61irnY0l3X57kIUmGPovsm+SzVfWqqvr1lfSukdtU1Qur6usZvZ/vndFzdbmul+RFSb5fVe+sqodU1dVXOMdtkhyb5EEDp7yzu3+wkp4AAAAAAAAAbNm2WfQAAAAAAAAAAMD61N2XVdWDkrwlyZETTj08yeFVdUaSDyT5bEZhR+cmuTTJzhn9D/s3TXJYkjtk49+JOCvJb3b3qav6ITZ/Oyd58NJxaVV9PskJSU7O6DU6J8mPk2ybZJckeyc5IKN/kxtN6Ht6kmetcJanZhSyMvS7sF+Sf0vyD1X18YyCHU5bmvFHSXZIstvScYMkBy0d+2YGfzSsuz9TVSckufWY8vZJfnfp2JjDMgqGYPPwgYx+L1fjb5aO5dg7o/fPwnV3V9VDk5yU5JpjTrlWkndV1fFJ3rx03jlJdkxy4yR3T3K/jN4fQ57Y3V+a6eCku/+7qj6S5C5jyltnFDL3uKp6c5JPJDkjyU+S7J5RYNxtMwrO2WfM9cdmdP/9y9lPvj5192lVdZ8kH8zo/bOh7ZI8Kskjq+qUjF7/45P8IKP33MVJds3o+XfNJDfL6Pl34NLaLGyf5D5Lx+VVdWpGnxdOTPLd/PxZvFVGny32THLzjO4DB0zoe26SJ85oRgAAAAAAAAC2EAKRAAAAAAAAAICF6e5Lq+p+SZ6X5OkbOX3PJI9eOlbj5CRHdPc3V9lnS7NtklstHatxfpKHdPdPVnJRd19eVQ9M8tpMDhbaLaOgjntPP+LUnphREMXWC9gb5q67v1VVRyZ5f5KdBk47eOlYqRd39yunHo6NeUKST2UUlDPONZI8dulYrm9kFKD3h6sbjQ119yeq6m5J3pXhEKNKsv/SsUhbZxR2dPMkD19Fn0uTPLK7vzOLoQAAAAAAAADYcqz6r98BAAAAAAAAAKxGd1/R3X+aUcDNt9dwq8uT/H2SOwhDWjNnJ7lLd39ymou7+9Ikv5fkGRkFJWxSln6uR2YTnA3WSnd/PMnhSc6ZYdsXdvfTZtiPDXT3qUkemNndr05Lcrfu/t6M+rGBpffabZKcuOhZ5uCiJEd299sXPQgAAAAAAAAAmx6BSAAAAAAAAADAJqG7353kZkmem+S8Gbd/X5LbdvdTu/uiGffenPwwyVqFQb0pyS26+4TVNOmRFyS5dZL/nslkv+jiJMckedw0F3f3azMKrHj/LIeCTVl3fzTJwUk+vspWP0zyu0sheKyx7v5AksOSfGeVrd6T0TP0a6ufikm6+6tJbp/kTzP7z0JJ8tUkR2X0uWiSC5J8eQ32T5IPJjmou9+zRv0BAAAAAAAA2Mxts+gBAAAAAAAAAACu1N3nJTmqql6c5GFJfj/JLadsd06SNyd5dXd/dkYjjnN6kreNWT9+Rv3H9Z5Kd5+SZM+qukWSeye5W0YhJztO2fKCJP+R5P929ydmM+VId38+yV2q6k5JHp/kt5PsNGW7H2cUrvS+JMd09zmrnO3kJPeoqj2THJ7ktklukuT6SXZPskP8oTK2MN19WlUdkuT3kjw9yQEruPzHSV6R5AWrff/NyUczCm/a0A/mPchqdfcnqurAJM9I8pgkO6/g8hOSPL+7Z/YcYuO6+5IkL6yqVyT5P0kemWS/adsl+XxGIUT/sdxndXf/IMlNqurGGT1/755RUNMuU85xSUbBWq9aCsAEAAAAAAAAgEHV3YueAQAAAAAAAABgUFXdIMmdk9wuyb5Jfi2j0JmrZfTHoC5M8pMk30rytSQnJ/lYkhO6+7JFzLw5qaptkxyU5DYZvb43SrJ3kt0yCs7YKaPX+Nyl48rX+MQkH+7un8xpzp2S3CWjQIZbJNkryXXy89+DC5Kcn+S8JN9McmqSLyU5Kclnu/vyecwJ60VV3SrJvTK6d9wkya9kdM+4OKN7xWlJPpfkA0k+2N0XLmhUllTV7hmF4R2a5FZJfjXJNTMKcPtJku8m+XKS45K8bymYblyfbTL+jzFe5rm7NqrqJhk9Aw/O6Fl9w4ye0zsmuSw/f/6dndG/4ZeSfDHJx5fCjWYxw1ZJ9s/PQwD3yegz2TUyCkraKclPl+Y4N8kZGT2DT0ryoc0kDA0AAAAAAACATYBAJAAAAAAAAAAAAAAAAAAAAAAAYOG2WvQAAAAAAAAAAAAAAAAAAAAAAAAAApEAAAAAAAAAAAAAAAAAAAAAAICFE4gEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAABg4QQiAQAAAAAAAAAAAAAAAAAAAAAACycQCQAAAAAAAAAAAAAAAAAAAAAAWDiBSAAAAAAAAAAAAAAAAAAAAAAAwMIJRAIAAAAAAAAAAAAAAAAAAAAAABZOIBIAAAAAAAAAAAAAAAAAAAAAALBwApEAAAAAAAAAAAAAAAAAAAAAAICFE4gEAAAAAAAAAAAAAAAAAAAAAAAsnEAkAAAAAAAAAAAAAAAAAAAAAABg4QQiAQAAAAAAAAAAAAAAAAAAAAAACycQCQAAAAAAAAAAAAAAAAAAAAAAWDiBSAAAAAAAAAAAwP/P3n2H2VZQd+P/LgSUYkNF1KCAGAtiQ2yoKGpsIU1MoqIQYzTGFI0mGqN5bW9MbL/XFt/EkihojNEktsSGWIAo1ih2AVvEiohYqOv94wz54Xj2zGkzZ+69n8/znMd719p77TVnzj5nnsfhewEAAAAAAAAAAJZOIBIAAAAAAAAAAAAAAAAAAAAAALB0ApEAAAAAAAAAAAAAAAAAAAAAAIClE4gEAAAAAAAAAAAAAAAAAAAAAAAsnUAkAAAAAAAAAAAAAAAAAAAAAABg6QQiAQAAAAAAAAAAAAAAAAAAAAAASycQCQAAAAAAAAAAAAAAAAAAAAAAWDqBSAAAAAAAAAAAAAAAAAAAAAAAwNIJRAIAAAAAAAAAYCJV9bCq6jGPly17N1hPVR048Pr94rJ3A/5/VXXawL1602XvNk5VPW5g3+cse7fVquq8gV33XPZuAAAAAAAAAHApgUgAAAAAAAAAAAAAAAAAAAAAAMDSCUQCAAAAAAAAALYZVbV/VV1SVT3wePOydwSAbUFVnbTG5+lGPG667K8ZAAAAAAAAANj6BCIBAAAAAAAAANuSY5LUGv17VdU1N2sZAAAAAAAAAAAAYHF2XvYCAAAAAAAAAACTqKpK8pB1Dts5ydFJnrvxG20dVfVrSW42pvUv3f2Jzd6Hra2qHprkumNar+jur2z2PgAboarukOQXxrRO6e53bPY+25Oquk+S24xp/Xt3n7rZ+wAAAAAAAACwfRGIBAAAAAAAAABsKw5Psv8Exx2THSwQKcmvJXnQmPoXkwhEYrWHJjlsTP1dSQQiAduLOyT5X2Pqz00iEGk+90nyqDH17yQRiAQAAAAAAADAXHZa9gIAAAAAAAAAABM6dsLjDq6qW23kIgAAAAAAAAAAAMDi7bzsBQAAAAAAAAAA1lNVeyY5aopTjk3y0Y3ZBgC2a19Ncp8NmPuFDZgJAAAAAAAAAGxnBCIBAAAAAAAAANuCo5LsMcXxD6iqx3b3hRu10I6ou1+W5GXL3gOADXVBd5+2rIt3902Xde3tXXfvuewdAAAAAAAAAGA9Oy17AQAAAAAAAACACRw7UP/gQP3qSY7cmFUAAAAAAAAAAACAjSAQCQAAAAAAAADY0qpq/yR3Hmg/I8kpA71jNmYjAAAAAAAAAAAAYCMIRAIAAAAAAAAAtrpjktSY+neSvC3JcQPn3buqrrFhWwEAAAAAAAAAAAALJRAJAAAAAAAAANiyqqqSPGSg/druvijJPyW5YEx/lyRHb9RuACxWVe1SVbed8dwrVdXNF70TAAAAAAAAAACbSyASAAAAAAAAALCVHZ5k/4He8UnS3d9L8paBY47ZiKUAWJyqOqSqXpDk60lePOOYvZN8vKo+XlWPqaprLm5DAAAAAAAAAAA2y87LXgAAAAAAAAAAYA1DgUZf6O4PXubvxyX5tTHH3byqbtHdH1/8amurqkMyCnQ6NMmBSfZNcsUkl0/yoyTnJvl2kk8n+VSSk5Oc0t0XTjD7pqtKVx449OfGHLuW87r7S1Mcz4Sqat8kd0pyUJIbJ7lBkqsmuVKSPZL8JMkPMgqE+UKSjyR5Z3d/bM7r7prk51eVdx84fP+qOmeK8Wd399dn22ykqnZPcrckd0hyiyT7JblmRs9JZfScnJvkSxndK59IckJ3f3Ge606x33WS/EqSuyQ5eGW3PVd2+lZG368Tk/x7ko91d2/GXtuDqrp2kqMzep+/yWVaX55z9M2TPC/Js6rq7UlemeRN3X3+nHPZ4qrqwCRXuExpn4FDrzblZ+NF3f3Z2Tf7aSvvy3dPcp+MXq8HZvQ5vktG73lfSvLxJG9L8ubu/vGirj2rqrpxkstdprTXwKHXmvK5/XF3nz77ZgAAAAAAAABsj8rv4AAAAAAAAAAAW1FV7ZHkGxmFj6z2F9399Mscu2uSszL+P9B/fnc/emO2/GlVdfUkj0ryW0muN8OIHyR5V5KXJ/mP7r5kzDV2TrJuaNKMTujuuw81q+phSV46pvXy7n7YWoOr6rZJPjCmdUp3Hzbdmv8z87lJ/nigPc/c5yf5wzGt3+/uF084Y+eMgn5+LckRGQVezOKMJC9O8pJZQjFWAkK+MOO117Pu931IVd0mo+/dkRkOaFrLGUn+JcnfdfdEX98az8Xp3X3gqmOvn+RpSX4jPx0CspaPJnlMd79vwuN3OFW1W5JfzSgE6e5Jdhpz2Ee6+9YzzF7rtX5Okn9K8qruPmXa2durqjopybj3yZ+5JzZTVZ2WUXjcagd392kznDev73b31de47uOSPHtM67nd/bjLHLdLRp8tj01yrQmvfXaSFyR5dnf/aPKVB3c9L6PAudWu2N3nzXDevGa63wEAAAAAAADYvo37hRIAAAAAAAAAgK3gqIwPQ0qS4y/7l+6+IKOwi3EeuBJCsGGqateqemKSLyV5SmYLQ0qSK2YUFvKWJGdW1RUWsuDW8JGMAp9WO7Sqhr7P67nbGr155h4xUH/3JCdX1QuSfD3J25I8PLOHISXJAUmem+TzVXXvOeZsCVV1QFW9KckHMwobmiUMKRk9L49L8rmqetai9kuSqnpUkk8meWAmD0NKklsleW9V/U1V+b2sFTVyeFW9PMk3k7w6yS9kc3937SpJHpHk5Kr6fFU9qapmfZ+GqVXVDZKcmuQ5mTwMKRkFPT4lyWlVdegGrAYAAAAAAAAAW45fvAEAAAAAAAAAtqpjB+ond/eZY+rHDRx/jST3XchGY1TVAUn+M8n/TrLHAkdfN8nOC5y3VN19UZL3jWntkuRO086rqqsludkah8w6d+8kB41pndXdn5lwzMMzet0t0s8leWtVPWHBczdNVR2d5BNJjlzk2IzCkeYfNPLiJC9Kstscox6Z5JVVNU2Y0nanqq5fVU9NckaS9yR5aEahb8t2gyRPzyh07sSqOnaO8DRYV1XdIsnJSW4xx5j9k7y/qn55MVsBAAAAAAAAwNYlEAkAAAAAAAAA2HKqar8khw+0xwYfdfd/JvniwDnHzL/Vz6qqQ5KcmuRWGzF/O/TugfrdZph114zCcNayyLknzjBr0SrJM6vqccteZFpV9b8yuncXGRq2aM9L8nsLmnV0kscvaNY2o6quUlUPr6qTMno//osk+00x4uIkH5nx8ucm+ewUx1eSuyT5+yTfrKrjquoeVeV36liYqrpOkrdmMSF5l0/y+qq65wJmAQAAAAAAAMCWtd38K4IAAAAAAAAAwHblmIwPpbkgyevWOO/4JE8ZU79vVV29u7+zgN2SJFV1UJITklx5nUNPT/IfST6c5Fsrj12TXDXJPkluneTQJLdMcrlF7bdFDQUiHTHDrEnOWeTcod0ndXFGYS0fXnmcleR7K4/LZ/R62D/J7ZPcI8k115j111V1ane/b86dNkVV/XnG35eXdVGSU5K8LckZGd0n5yS5UpK9khyQ5LZJbpdk3w3Y8beTPHpM6+MZhZl8fGWn8zIKNrlRkiOzdujWk6vqdd09FNS2XaiqyyW5Z5KHJPnlJFeYYczHMgrMek13f3OWPbr7W0luXFWHZhRI9ZtJ9p7w9N1Xzjk6yX9X1fFJXtndn5llF1hRGf1ccu1V9c7o/e71Gb3ffT3JFZNcJ8mdktw/o8+EcXZO8rqqunV3f2EjlgYAAAAAAACAZavuXvYOAAAAAAAAAAD/o6oqyRczCkBZ7V+7+9fWOPeAjAKIxnl0dz9/ASumqq6a5CMZBdgMeW+SP+nuD004c58kv5HkwUkOWSlfsbvPm+Dc45M8aEzrwd19/CTXn3DHhyV56ZjWy7v7YROcX0m+neRqq1qXJLlGd589xS6fTXLDdQ6bZe4Xkhw4pnVAd5854YyfZBRydEmS9yV5bZLXd/d3Jzx/14wCMf4qyc8NHPb5JAd190WTzFw1/6Qkh41p3am7T5p23jrX+tUkb8j4gLMkOT/JC5M8c9LvU1XdNskDVx5XT/KG7j5qgvMOTDIuQOT7SXbJKBTnUqckeWx3f2CdmYcl+fskNxg45HXd/Rvr7bYtqqqbZRSC9KCMwt2m9dUkr05yXHd/epG7JUlV7ZxRUNODk/xSkt1mGPOhJK9K8o+T3r/bkjXeC07v7nHvg5uiqk5LctCY1sHdfdoUcx6X5NljWs/t7sfNut8U1/lafvY9/NQkv7XWa37lM+DxSZ6c0XvTOB9McofuvmTKXc9LsseY1kQ/b1xmzouSPGpM6w+6+0XT7AQAAAAAAAAAq+207AUAAAAAAAAAAFa5c8aHISXJcWud2N1nJDl5oH3sHDut9sIMhyFdkOQh3X2XScOQkqS7v9Hdz+/uW2cU4rHQYJqtoEf/ctd7xrR2SnLXSedU1bUzPgzp/Dnn7pvxYUhfmjQMacVFGYWo3Ki779rdfztNmEp3X9Ddr05ycJK3DBz28xkfgrVlVNU1MwrQGgpD+nSSm3T3n0wTWtXdH+zuP0qyX5I/TfKNOVe9cn46DOn5Se64XhjSyi4nJzk8oxC3cX65qvaac78to6quWVWPqaqPJfmvJI/NdGFI5yZ5RZIjklyvu/9sI8KQkqS7L+rut3b3b67s+NsZvf9M8y8IHprR+/3Xq+pfqupXqmoooAZWWx2G9HdJDlvvNb/yGfD0jMKqvj9w2G0zek0DAAAAAAAAwHZn52UvAAAAAAAAAACwyrED9e8leesE5x+XUYjAareoqpt19ydmXSxJqurwDAfR/CjJr3X32+e5Rne/I8k75pmxhb07yf3G1I9I8oYJZxwxpvaNJO9Pcv8Fz01GO0/j4CkDlMbq7nOq6qiMXgt3HnPIo5K8ct7rbKC/SnK1gd6pSe49TRDSat39wyTPnvX8Ac/r7sdOucdZVfXbSd47pn35JA9I8uJFLLcMVXX5JL+U5CFJ7pXpf+fsoiRvS3J8kjd2908Wu+H6uvvSIKZXrASfHb3yuMmEI3ZN8qsrj+9U1WuTvLK7P7wR+24Bu1bVTRc479PdfckC522L/i3JI6d5Hrr7Q1X1qxndP7uOOeSpVfXK7r5gUUsCAAAAAAAAwFaw07IXAAAAAAAAAAC4VFXtkeSogfbrJvyP/l+XZOi4Y2fZa5VnrNH7g3nDkHYAQ+FCQ2FEkx57YpITNmBuMmUg0iLCkC4z6/yMXrfjXtOHVtX1F3WtRaqqGyZ58ED7O0mOnCcMaYN8JMkTZjmxu9+X5N8H2tO8BreMqrp9Vf3fjMLGXpfkFzNdGNKpSf4wybW7+8ju/qdlhCGt1t1f7e5ndvdBSQ5J8n+SfHOKEVdP8vtJPlRVn6qqx1fVdTZi1yXaN8knF/jYfXPX33K+leSYWUKhuvvEjMLlxrlWkgfOsxgAAAAAAAAAbEUCkQAAAAAAAACAreSoJHsO9I6bZEB3fy/JWwbaD6qqaQI9fkpV3SLJHQfab+nuV8w6e0fR3Z9N8vUxrRtV1bUnHHPXMbUTMj64aN65GZi7aVYClv5+oH2PzdxlCr+X5HIDvUd297c2c5kJ/VF3XzjH+a8eqN9yjpmbqqquV1VPqqrPJzklySOSXGWKEWdmFBp3w+6+bXe/sLu/vRG7LkJ3f7S7H5PkOknuk+Qfk/xoihE3ySis5itV9Y6qelBV7ejhP/ysJ3f3uXOc/6wk/z3Q+6055gIAAAAAAADAliQQCQAAAAAAAADYSo4dqJ/Z3SdPMWcoPGnvjEIvZrVW8MCfzDF3R3PiQP2I9U6sqgOS7Dem9e7u/kKSr8449wZJ9h3T+mx3n7Xe+ZvgjQP1223qFhNYCR07eqD9ge5+/WbuM6GPTPkeM87bB+r7V9U0oUKbqqr2rKpjq+rEjAKNnp7kBlOM+F6Sv0ty5yTX7+4nd/fnN2DVDdPdF3f3f3T3A5Psk9F7/buTXDLhiJ0yCic7Psk3quoVVXV4VdXGbMw25FtJXj7PgO7+YZIXDLTvWFXXmmc+AAAAAAAAAGw1ApEAAAAAAAAAgC2hqq6X5PCB9vFTjvv3JN8d6B0z5azLOnKgfmJ3f3aOuTuadw/U1w0uGjjmzO4+c+XP48KWZp2bDO+62YbCem66qVtM5g5J9hrovWQzF5nCa+cd0N3fTTIUnnW9eecvUlXtVFV3r6rjknwzyd8nuUuSSQN8Lkjyb0mOSnKt7n5Ed7+/u3tDFt5E3f2D7v6H7r5bRt+3JyQ5bYoRV8woUOk9Sc6oqqdV1YGL35RtxD9398ULmPPaJOPur50y2WccAAAAAAAAAGwzBCIBAAAAAAAAAFvFMRkO45gqEKm7L0jyTwPtX6yqq00zL0mqav8k+w+0XzHtvB3cogOR3j3w53nnDs3bdN19bpIfj2ntt8mrTOJuA/UfJnndZi4yhaHAqWl9caB+pQXNn0tV3aiqnpnky0nemeToJLtPMeKUJL+XUQjSr3b3G7r7/A1YdUvo7q91919398FJbpnkeUm+McWI/ZI8OckXqurkqnp4VV1lA1Zl63r9IoZ091eSnDrQvuMirgEAAAAAAAAAW4VAJAAAAAAAAABg6aqqkjxkoH1qd39+hrHHDdR3TfLAGebdao3eSTPM22F195eSnDmmdb2quv46p9dCt8MAACAASURBVI8LLjph4M8TzV15/d1lTKuTnLjOPpvpe2Nqe1XVLpu+ydqG7pUPd/dPNnWTyX1sQXPOHahviUCkJO9K8oQkPzfFOV9M8pQkB3b3Yd39ku4+eyOW28q6++Pd/diMnrt7JXl1RiFfk7pDkr9N8qQNWG/RTu/uWuDjvGV/QUvSST6ywHlDsw5e4DUAAAAAAAAAYOkEIgEAAAAAAAAAW8GdkgwF1gwFG62puz+QUZDHOMfOMPKggfq3VgJ+mM67B+rjAo+SJFV1UJJrrjWru7+W5AvTzE1y0yR7j6n/1yKDX6rqoKo6pqqeW1XvqKrTqurLVfW9qrqoqnqtR5JrjxubZM9F7bggQ/fKqZu6xeR+uMCgph8M1LdKINKkvpvkb5Lcvrtv0N1P7e7Tl73UVtDdF3f327v76CT7JDkmo6CpS5a7GVvQmd099J4wi08M1G+4wGsAAAAAAAAAwNIJRAIAAAAAAAAAtoJjB+oXJXntHHOHwpRuVVU3nXLWvgP106acw8hQINLd1jhnXKjRp7r7mxPMnnbu0JypVNV1qurPq+pTGb1W/iHJHye5R0bBQddNcpUkl5vjMleYd89FqapKcp2B9ic3c5cpfG+Bsy4eqM/z/d1MH0ryK0mu1d2PWgmWY0B3n9fdr+rue2T0GfFnSc5b8lpsHZ9b8LzPDtSvVlW7LvhaAAAAAAAAALA0ApEAAAAAAAAAgKWqqt2THDXQflt3f2eO8cev0Tt2ylnXHKifPeUcRobChu66EqozzrjgonFzxtXWmnvXgfrMgUhVtWtV/VlGgRjPSHKTWWdNYCuF7Vw1yVAwx1a9V85f9gJbyKFJHp/kd6rqasteZltRVYck+dMkj06y55LXYes4Z8Hzvj9QryRXX/C1AAAAAAAAAGBpBCIBAAAAAAAAAMt2VJIrDvSOm2dwd5+R5OSB9oOqaucpxu0+UF904MEOobu/keQzY1p7J7np6mJV7ZTk8DHHnzCmdmKSnnPuRUneN6a+rqq6bpIPJ/nLJHvMMmMbNnSfJO6VbcXtk7w4yVlV9aaqun9VXWHZS201VXW9qnpiVX0mo/v9jzIcnMeO6QcLnnfuGr213nsBAAAAAAAAYJsyzS/1AQAAAAAAAABshGMH6ucnOaOqfibEZkrvT3LYmPo+Se6V5C0Tztl1oH7eLEuRJHl3khuPqR+R5JOrardMctVVtYuTvHf1yd397ar6ZJKbTTD3VkmuMmaHD3f31GEWVXWtlZ32m/bc7cTQfZK4V7aCf8voPXeSoK5dkhy58vh+Vb0hyfFJ3tPdqwPHdghVdZUk90/y4CR3TFJTjjgjySmL3ost60cLnvfDNXprvfcCAAAAAAAAwDZFIBIAAAAAAAAAsDRVdb0kdxloXz7JhzZ4hWMzeSDS+QP1PRezyg7pxCSPGlM/Isnzx9RW+1h3nzMw+90ZH4g0ydxLd5tKVVWSV2f9MKT/TvLBJJ9O8uUk30xybkaBQRdlFPQ0zruSXHPavTbZ0H2SuFeWrrt/v6oen+R+SY5JctdMFupz5SQPXXl8tapek+T47j5tw5bdIqpq1yT3SXJ0kl/M6LNpGucm+eckr0ry/h01TGoHtfuC560VZHbBgq8FAAAAAAAAAEsjEAkAAAAAAAAAWKZjMlkYx0Y5sqr26u6zJzj2RwP1qyxyoR3MiUk6P/saOLyqLtfdlw0GGhdcdMIas9+d5NEzzr30/Gn9ekYBM+NckuSlSV7S3f81w+xU1SWznLfJhu6TxL2yJXT3DzMK53lVVe2b5MFJHpLkhhOO2DfJ45M8vqr+K8lxSf6xu7++EfsuS1XdIaPn5teT7DXl6RdnFGD2qiT/2t0/XvB6bBuuuOB5V1qjt9Z7LwAAAAAAAABsU3Za9gIAAAAAAAAAwI6pqiqjEI5l2jXJAyY89lsD9asuaJcdzkoQ1bhwoCsnOeTSv1TVLknuOOa4tUKL3ptRKMksc89PcvIas4c8dqB+bpJ7dvfvzhqGtGJbeK2dk+SCgd62sP8Opbu/2t1/2d03SnL7JC9JMklA3KVunuQ5Sb5aVe+sqmOqatEhMJumqn6+qp5WVadn9B7wu5kuDOm0JH+aZN/uvld3v0YY0g5t0SFwV16j950FXwsAAAAAAAAAlkYgEgAAAAAAAACwLHdKcv1lL5Hk2AmP+8pA/eAF7bGjGgo1OuIyf75Nkj1X9S9IctLQ0O4+N8mH15l72yR7jDnmA9OGmFTVfkkOHWg/srvfNc28MfN3S3KFeWZshu7uJF8baLtXtrDu/kB3/16SayU5Ksmbk1w44ek7Jbl7kn9I8s2qek1V3aeqdt6QZReoqq5RVX9QVR9M8rkkT05ywBQjvp3kBUkO6e6Du/vZ3X3WRuzKNueGC553o4H6d7p7KIgOAAAAAAAAALY5ApEAAAAAAAAAgGU5dtkLrLh1VR00wXGfGqjvvRKGw2yGApHudpk/HzGm/4Hu/tEMs9ebu9ZOa7nTQP3z3f2aGeatNk1Ay7IN3Su33dQtmEl3X9Ddb+juX0pynSSPTvKxKUbsluQBSd6a5L+r6gVVNRQWthRVtVtV/UZVvSXJ1zMKNLrNFCMuSPIvSX4lyXW6+4+6+6MbsCrbtv2ranWY3zxuNlD/3AKvAQAAAAAAAABLJxAJAAAAAAAAANh0VbV7kqMG2m/u7lr0I8k1klw0cM1jJlj7I2v07jjB+Yz3voz/vhxWVbuu/HlccNEJE8weF2y03tyh89Zzw4H6m2aYNc5Q4NJWNHSv3LqqrrCpmzCX7v52dz+/u2+V5OAkz0ly1hQj9k7yB0lOrarPVdWTq2r/jdh1PVW1U1UdUVV/n+SbSV6b5L5Jdp5izKlJHpXkWt19v+5+Y3dfuAHrsn2oJLde4LxDBuqnLfAaAAAAAAAAALB0ApEAAAAAAAAAgGW4X5IrDvRevREX7O7vJHn7QPvoqrrcOud/OckXB9oPnWe3Bbh4oL7rQH3L6O4fJPnwmNZuSW5fVbsluf2Y/iShRScnOX+Nubcbc84Pk3xwgtmr7T1Q//IMs8YZCm+axUa/Xt41UN8jya8v6Bpssu4+rbv/JMm+Se6dUaDQj6cY8fNJnpbkjKo6qap+t6r22oBVf0pVHVxVf53kKxkFqR2b4c+fcb6a5JlJbtTdt+3uv+nusxe/KRtgK3w2DoU/TqWqrpvkNgPtkxZxjSlthecWAAAAAAAAgO2UQCQAAAAAAAAAYBmOHaifl+RNG3jd1wzUr5XknhOc/+aB+l2r6kazrbQQPxmo77apW8xuKNzobkkOS3L5VfWJQou6+8dJPjDF3CQ5qbsvXG/2GEMhENMExoxVVddO8ivzzrmMjX69fCDJtwd6j1zQNViS7r64u9/W3Q9Isk+S38kokKWnGHNYkpckOauq/q2q7ldV4+7HmVTVtavqcVX18SSfSPKnSa4zxYgfJjkuyd2T7NfdT+zuzy1qPzbNVvhsvP96gYsT+s0kNabemSwgcNG2wnMLAAAAAAAAwHZKIBIAAAAAAAAAsKmq6rpJ7jrQ/teVEJuN8saMgi7GOXaC8/9+jd6zpt5mcc4eqE8TALJMQ2EOR6w8Vnv/FKFFJ0wxd61d1jP0Pbj2jPMu6zFJdlnAnEtt6Ouluy/OKExmnNtV1f0WcR2Wr7vP7e6XdfedkhyY5KlJzphixK5JfjnJ65N8o6peWlW3n2WXqtqlqo6pqncm+WqSZye5+RQjOsmJGX0W7NPdD+nuE7r7kln2YUvYCp+Neyf57XkGVNXuSf5woH1yd399nvkz2grPLQAAAAAAAADbKYFIAAAAAAAAAMBmOyZJDfRes5EX7u4fZhSKNM4vVdVV1zn/k0neM9A+sqp+a4715vG1gfqNN3WL2Z2c5Pwx9dsk+cUx9XEhR0PGBRwNzR06fhLfHqjfbcZ5SZKVcJhHzzNjjM14vfxNkosGei+pqr0XeC22gO4+o7ufklEw0p2TvDzJuVOMuEqShyV54YwrXC/JPyS5e6b7vbjPJXlSkv26+4jufmV3nzfjDmwtW+Wz8elVdaU5zn98hoOG1gpq3Ehb5bkFAAAAAAAAYDskEAkAAAAAAAAA2GzHDNS/leRdm3D9Vw/UL5/kNyc4/8lr9F5UVb8w/Upz+8xA/W5VtfumbjKD7v5Jkv8c09olycFj6tOEFp2aZHW4ydDcc5J8dIrZl/Wxgfqdq+q2swysqp/LKCRs5xl3GjL0erlvVQ2FlU2lu0/PKJxmnGskeXNV7bWIa7G19Mj7u/thSfZJ8sAkb09y8XI3+ynfS/J/k9y+u2/U3f+7u7+y7KVYuM8O1Perqptu4h57J3llVU39+5pVddckTxhofyPDP9NstKHPkcO8twMAAAAAAAAwL4FIAAAAAAAAAMCmqao7Jbn+QPt13X3RJqzxjiTfGegdu97J3X1SklcOtHfPKOjl6NlWG6mqu1XV+6pqzwlPOTXJuOfuikmeV1WXm2efTTJpyNHZST4+6dDuvjDJSRMe/t7uvmTS2avPTfKTMfVKcnxV7TPNsKq6cZJTkuw34z5rOWWgfoMkT1zgdZ6Y4XvtNkneV1X7zzq8qnavqsdW1YtmncHG6u4fd/c/dve9kuyb5E+TnLakdS5K8pYk909yre5+ZHd/YEm7sAm6+7tJPjfQfuEUn7GL8CtJXjLN53FVHZrkX5PsOnDIU7r7/EUsN4NP5GfDBpNR4OCLqmqXTd4HAAAAAAAAgO2IQCQAAAAAAAAAYDMdu0bv1ZuxwEro0usG2rdZCaJZz6OTnDnQ2zXJcVV1YlXdetK9quoaVfWoqvpgkncludOk53b3eUlOHGg/Isknq+ovquqXq+p2VXVwVd10zGO/Sa+5ASYNRHrPDKFFk86e9Lif0d0/TvIvA+0Dk3ygqu6+3pyq2rOqnp7kIxkFyFzq+0l+MOt+l9Xdn03yhYH2M6rq1Kp6fFXdp6pus8br5drrXOfbSX4nSQ8cclCSz1TVX1fVXpPuX1WHVNVzk3wpyXOSTBU2xXJ091nd/ezuPjjJIUlekOTbm3DpjyV5TJLrdPeR3f36JYbIsPneNFC/S5LPVdVzqurXq+oOVXXzgfe6G8147a+t+vvDk5xSVTdZ66Sq2rWqnpTk5CRXHjjsQ0leNuNec1v5Weo/BtoPSPLpqnp6Vf3qys8dNxt4bodCMgEAAAAAAADYge287AUAAAAAAAAAgB1DVe2e5P4D7dO7+wObuM6rk/zeQO+YJE9Y6+TuPqeqjszaYQV3SfKhqjo9yVszCrj5VkYBIDsn2SujIJdbJjk0ya0z3+9yvDjJPQZ6N07y1AlmnJBk3dCeDXJqkvOS7LnOcSfMMHvSc2YORFrxlCS/nvHfx+sleWdVfSTJGzN6PXwnySVJ9k5y3SS/kNH3cNxz8AdJnpnkinPueKkXJ/k/A71DVx7reXmSh611QHf/W1X9RZKnDxxy+SR/muSPq+rkJG9LckZG98o5Sa6U5KpJDljZ6XZJ9p9gN7aw7v5oko9W1WOT3CfJQ5IcmVGg3CKcldH7/Cu7+7QFzWTb9LdJ/jjJ5cb0rp3ksRPM+G6Sq89w7ddlFP51+GVqt0ly2sr73RuSnJ7k6xm9t18nozDE+2f0M8KQ85I8uLsvnmGnRXpxhn+uOzDJkyaY8ZGMfv4BAAAAAAAAgP8hEAkAAAAAAAAA2Cz3y3CYyz9u5iLdfUpVfSnJfmPaD66qP18vaKC7P1VV90jyjiRXWePQ6yf5w1l3nVR3v7Gq3pnhUKQtrbsvrKqTktxrnUNnCS36eJKzs3bAxLfmDU7p7i9U1dOzdvjUISuPabywu4+rqmfOvt3PeEmS30ly0AJnjtXdz6iqKyT58zUO2zmj0JDD1ziG7Ux3X5TkTUneVFV7JfnNJAfPOO7CJK9N8qok79gCYTFsAd19elU9L8mfLOPySY5O8qGMAhAvVUnuuPKY1sVJfqO7Pzf/evPp7vdW1T9nOBQJAAAAAAAAAGay07IXAAAAAAAAAAB2GMeu0Xv1Zi1xGa8ZqF87E4YKdfeHktwuyacWtdScfjOj4IVt1XphR1/v7s9OO7S7L0ny3nUOO3HauQPXeloW+3p+WZJHL3BekqS7L0hyZJLTFz174HpPyiiA6fzNuB7bnu4+u7v/prsfOeP5X+7uB3T3fwhDYpUnJnndMi7c3V9Lct8k313AuAsyCkP69wXMWpSHZv3PVwAAAAAAAACYikAkAAAAAAAAAGDDVdV1k9x1oP2xWUJuFmAoEClZO7zpp3T355IcmuSvklw4506X9elp53X32UnulOTPk3x7gbtslvUCkdbrL2v2ag9J8owkPceMHyd5THf/zkqg08J195lJbpXkOUl+sBHXWHW9lyW5ZRYbnnFRktMWOA/YznT3RRkFBh6b5ItLuP5HkxyW+d6rvpzkzt39hsVstRjdfV6Suyf54yRnLXkdAAAAAAAAALYTOy97AQAAAAAAAABgh3D1JE8b6J28mYtcqrs/VVWPS3LFMe0fTznrx0n+rKr+Jsljkjw4o695Wt9L8h9JXtrd75nh/HT3+Un+sqqek1EI1V2S3CLJ/kmukdHXu8ssszfBxzJ6Dq460J8ntOiEdfoLC0RaCTB6clW9I8lfZBQWManzk7w2yVNXAos2VHefm+RPqup/JfmFJHdOcnCS/TJ6veyRBf6OUXd/JsldqurSAI17zDj/s0lel+Tvuvu/F7Uf7GBekeRdY+pnb/YiG627O8krq+pVSW6X0fvyrZIcmOSaSa6UZNcktUHX/1xVHZLR+95jkuw94anfS/LCJM/q7h9uxG7zWgmc+v+q6oUZfYYckdHPHQdk9HVeKVv35w4AAAAAAAAAtqAa/f/8AAAAAAAAAAAsSlXtnFEowJ2THJLk+kn2yShcZqck5yX5QZKzknwmyaeTnJTkg9198TJ2ZuNU1cFJ7p3k8CQ3SLJXkqtkFH50bpIzM3oNnJjkbd393YE5l8+YsI7u/snGbL7xqurqSe6Z5LAkB2UUxLRXkt2SXJjRfXJukjMyulc+keSd3f2VZewLMK+qukJGYXD3yig46PpJrpxRONx5Sb6c5ONJ3p7kjd39oyWtCgAAAAAAAABLIRAJAAAAAAAAAAAAAAAAAAAAAABYup2WvQAAAAAAAAAAAAAAAAAAAAAAAIBAJAAAAAAAAAAAAAAAAAAAAAAAYOkEIgEAAAAAAAAAAAAAAAAAAAAAAEsnEAkAAAAAAAAAAAAAAAAAAAAAAFg6gUgAAAAAAAAAAAAAAAAAAAAAAMDSCUQCAAAAAAAAAAAAAAAAAAAAAACWTiASAAAAAAAAAAAAAAAAAAAAAACwdAKRAAAAAAAAAAAAAAAAAAAAAACApROIBAAAAAAAAAAAAAAAAAAAAAAALJ1AJAAAAAAAAAAAAAAAAAAAAAAAYOkEIgEAAAAAAAAAAAAAAAAAAAAAAEsnEAkAAAAAAAAAAAAAAAAAAAAAAFi6nZe9AFtHVd0kyU2TXDvJnkl+kuTbST6T5GPdfeES15tKVV0/yUFJrpHk6ivlc5KcntHX8t1l7QYAAAAAAAAAAAAAAAAAAAAAwM+q7l72DixRVe2b5A+TPDCjIKQhP0jypiQv6O5TN2O3aVXVgUkek+TeSfZf49BLknwwycuTHN/d52/CegAAAAAAAAAAAAAAAAAAAAAArEEg0g6qqnZK8oQkT0qy25SnH5fkD7r7+wtfbAZVtVeSZyU5JsnOU55+epLf7e53LXwxAAAAAAAAAAAAAAAAAAAAAAAmJhBpB1RVuyX55yT3nWPMF5Lcs7vPXMxWs6mqmyR5U5LrzzHmkiRP7O6/XsxWAAAAAAAAAAAAAAAAAAAAAABMSyDSDqaqLpfkzUnuPXDIhUk+neQ7Sa6Y5CZJ9hw49ktJ7tDdZy14zYlU1c2SvD/JlQYOuSSj4KZvJtk1yXWS7LvGyD/r7r9a6JIAAAAAAAAAAAAAAAAAAAAAAExkp2UvwKZ7WsaHIZ2T5DFJrtHdt+juu3f3bZPsleSoJJ8fc85+Sf5xJWRpU1XVVZP8S8aHIX0nyR8m2ae7b9Tdh3f37bv7uklumOR5GQU/rfaXVXWfDVsaAAAAAAAAAAAAAAAAAAAAAIBB1d3L3oFNUlU3T/KRJKsDjM5McvfuPmONc/dI8oYk9xzT/v3ufvHCFp1AVR2f5EFjWh9Mct/u/u46598yyduTXGNV66wkN+rucxeyKAAAAAAAAAAAAAAAAAAAAAAAExGItAOpqncluduq8g+T3Lq7PzvB+bsnOTXJQataZye5Xneft5BF19/jhkk+nWSnVa3PZfS1TLRHVd0so6/n8qtaz+rux8+9KAAAAAAAAAAAAAAAAAAAAAAAE1sdKMN2qqpunZ8NQ0qSp08ShpQk3f2jJL8zprVXkofPsd60Hp/xr93fmiaUqbs/keSpY1q/V1V7zbocAAAAAAAAAAAAAAAAAAAAAADTE4i04xgXWPTdJC+cZkh3/2eSt49pjQtKWriqqiS/NKb1npXdpvWiJD9YVdszydEzzAIAAAAAAAAAAAAAAAAAAAAAYEYCkXYAVbVzkqPGtF7d3T+aYeRLx9RuVFW3mmHWtG6e5Gpj6q+aZVh3/yDJv45pCUQCAAAAAAAAAAAAAAAAAAAAANhEApF2DLdLctUx9TfMOO+tSX48pn7vGedN47YD9VPmmPmfY2q3rqq955gJAAAAAAAAAAAAAAAAAAAAAMAUBCLtGO46pvajjA8CWld3/yTjA4iOmGXelMaFFF2U5PNzzPzUmFoludscMwEAAAAAAAAAAAAAAAAAAAAAmIJApB3DoWNqH+vuC+eYeeqY2q3mmDepq4+pfb+7e46Z5wzUbz3HTAAAAAAAAAAAAAAAAAAAAAAApiAQacdwszG10+ac+YkxtatU1fXmnLue3cbUzp9z5k8G6reYcy4AAAAAAAAAAAAAAAAAAAAAABMSiLSdq6pdk+w7pvXFOUefPlA/YM656zlnTO3Kc868ykD9wDnnAgAAAAAAAAAAAAAAAAAAAAAwoZ2XvQAbbt+MD7767znnDp2/35xz1/PdMbU9qmrP7j5vxpn7DNR/rqp27u6LZpy7rqq6/ZwjrpbksJU/n3GZ//3RnHMBAAAAAAAAAAAAAAAAAAAAYEe0e5IDVtXe0t1nLWOZHY1ApO3fNQbq35xz7tD5Q9dblK8M1A9NcuKMMw8dqO+UUeDQvM/VWk7ZwNkAAAAAAAAAAAAAAAAAAAAAwPwenuSly15iR7DTshdgw+01UP/+PEO7++IkPxzTuto8cydw0kD9F+aYuda5G/31AAAAAAAAAAAAAAAAAAAAAAAQgUg7gj0H6uctYPa4QKQ9FjB3UHd/NcmZY1oPrarLTzuvqm6Z5LZrHLKhXw8AAAAAAAAAAAAAAAAAAAAAACMCkbZ/uwzUL1rA7AvH1HZdwNz1HD+mtneSv5hmSFXtlOQF6xy2GV8PAAAAAAAAAAAAAAAAAAAAAMAOb+dlL8CGu9xA/eIFzB43YzNeUy9M8rgku62qP76qPtzd/zrhnOckueM6x2x0aNgd5jz/kIyej//xt3/7tzn44IPnHAsAAAAAAAAAwMTOOCM5+ui1jzn++OSAA8acekaOXufc448/PgeMORcAAAAAAAAAgMX75Cc/mUc84hGry2csY5cdkUCk7d9FA/VFfO/HzbhwAXPX1P3/2LnzIDvLOn3419OdJgvphIQkICQQFYEhKJtEwqAogw4B2ZwA8irgggg6NerMOG4wIPo6WjIooxb+RFFwGUVQkcUaldcFCMHIgOxbQljCnj0k6SSd+/0DfmrSp5Puc7r7JOnPp+pUme/93N/nyiEVuqziKs9VVfXFJP++wVFrkh9XVXVOkgtLKR217ldVtUOSLyU5uQevW9VQ2E0opdzSyP2qqrrMXv3qV2fatGmNrAUAAAAAAAAAoDdGjdr0M/vum0yZUuPqpu/uu+++mVLjLgAAAAAAAAAAA2ZFswMMFgqRtn41S4GSbNMHu2vt6O59fe38JG9I8sYN5q1JPpfkA1VVXZXkliTPJGlLsnOSw5Mcm2TkBvdmJzmwxnv8ZQQAAAAAAAAAAAAAAAAAAAAAMAAUIm39lnUzb++D3bV2LO2DvZtUSumsquqkJP+TZN8aj0xM8qGXPptySZL7U7sQ6dm6QwIAAAAAAAAAAAAAAAAAAAAA0GMtzQ5Av1vQzXy7RpZWVTUsydBevK/PlVKeTXJIkqsbWHNhkjNTu9xpTZLnG9gNAAAAAAAAAAAAAAAAAAAAAEAPKUTa+j3dzXzHBvd2d7+79/WLUsoLpZTjkhyX5M5eXL03yRGllH8ppaxLMrrGMw+XUkpf5AQAAAAAAAAAAAAAAAAAAAAAYOOGNDsA/e7JJB1Jhm4w36XBvd3df6TBvXUppVxdVdXPk0xN8vdJ3phkYpJxSUYlWf5StllJfprkVxuUHe1ZY+3d/ZkZAAAAAAAAAAAAAAAAAAAAAIC/UIi0lSullKqq5iTZa4Oj3Rtc/apu5g83uLduLxUc3frS5/xeXn9NjdnMhkMBAAAAAAAAAAAAAAAAAAAAANAjLc0OwIC4vcZsnwZ37ldj9kQp5fkG9w64qqrGJ9m5xtFvBjoLAAAAAAAAAAAAAAAAAAAAAMBgpRBpcLi1xmyvqqpGN7BzWg/fsyX4hxqzOaWUPw14EgAAAAAAAAAAAAAAAAAAAACAQUoh0uDw6xqz1iSH17OsqqoJSfbr4Xu2BKfUmH1/wFMAAAAAAAAAAAAAAAAAAAAAAAxiCpEGgVLKfUnm1Dg6qc6VJyapNnxNkmvr3Nc0VVUdnOTgDcYdSS5uQhwAAAAAAAAAAAAAAAAAAAAAgEFLIdLg8b0as+OqqprUmyVVVVVJPljj6LellCfqStYkVVUNSfL1GkffKqU8PdB5AAAAAAAAAAAAAAAAAAAAAAAGM4VIIm6jgQAAIABJREFUg8c3kqzeYNaW5LO93PPuJHvWmH+1pwuqqppXVVXZ4DOvlzka8lKx038lefUGR4uSnDuQWQAAAAAAAAAAAAAAAAAAAAAAUIg0aJRSnkxyaY2jU6uqOqEnO6qq2j3JhTWO7k7yswbi1aWqqpF13mtL8vUkZ9U4/mAp5fmGggEAAAAAAAAAAAAAAAAAAAAA0GsKkQaXc5IsrDH/blVVJ2/sYlVV+yW5IcnoGsf/VEpZ1wf5eqyqqiFJ5ldV9dWqqg6qqmqTf5arFx2V5K4kZ9R45OullP/u66wAAAAAAAAAAAAAAAAAAAAAAGzakGYHYOCUUp6vquq9SX66wdHQJD+oquqUJP8nyawkzydpT7JPknckeVeSthprv1RK+U2/hd64UUk++NLnuaqqfpvkziQPJlmUZFWS7ZNMSPLaJG9N8rJudv0syT/2c14AAAAAAAAAAAAAAAAAAAAAALqhEGmQKaX8rKqqTyb5XI3j6S99euraJB/rk2CNG5/khJc+vfWtJGeWUjr7NhIAAAAAAAAAAAAAAAAAAAAAAD3V0uwADLxSyn8k+UiSRgqAvpdkRillTd+kaorFSd5VSjm9lLK22WEAAAAAAAAAAAAAAAAAAAAAAAYzhUiDVCnly0n+Nsltvbz6VJJTSimnlFI6+j5Zj61LcmWSJXXcXZDkC0leWUq5rE9TAQAAAAAAAAAAAAAAAAAAAABQlyHNDkDzlFJuTfLaqqoOT/LOJIcn2bnGo4uT3JgXC4h+1GgRUillciP3X9qxLskJVVUNSfLaJNOS7J9ktyS7JhmVZHiSVUkWJXk4ye1Jfp3kV6WU1Y1mAAAAAAAAAACAJMmoUcmMGZt+puZ4VGZs4u6obu4CAAAAAAAAAMDWRiESKaX8Oi8WBaWqqu2S7JRk27xYJvR8KeWpJsbbqFLK2iSzXvoAAAAAAAAAAMDAmzQp+fGP67w6KT+u8y4AAAAAAAAAAGxtFCKxnlLK4iSLm50DAAAAAAAAAAAAAAAAAAAAAIDBRSESAAAAAAAAAAAAAAAAAACwVVqzZk2WLl2ajo6OdHZ2Zt26dSmlNDsWAAB/paqqtLS0pLW1NUOGDEl7e3uGDRuWqqqaHY0mUIgEAAAAAAAAAAAAAAAAAABsNVavXp1ly5Zl6dKlWbVqVbPjAADQSwsWLEhra2va29szcuTIbLvttmlpaWl2LAaIQiQAAAAAAAAAAAAAAAAAAGCLV0rJM888k0WLFjU7CgAADers7MzixYuzePHitLa2ZqeddsrIkSObHYsBoPoKAAAAAAAAAAAAAAAAAADYoilDAgDYenV2dubxxx/PggULUkppdhz6mUIkAAAAAAAAAAAAAAAAAABgi6UMCQBgcHj22Wfz1FNPKUXayg1pdgAAAAAAAAAAAAAAAAAAAIB69bQMaciQIWltbU1LS8sApAIAoKfWrVuXdevWZe3atZssO1qyZElGjBiR7bbbboDSMdAUIgEAAAAAAAAAAAAAAAAAAFuk1atXb7QMacSIERk1alTa29szZIj/tBoAYHO2bt26rFixIsuWLcvy5cuzdu3ams8988wz2XbbbdPW1jbACRkIfmoHAAAAAAAAAAAAAAAAAAC2SMuWLas5r6oqO++8c9rb2wc4EQAA9WppacnIkSMzcuTIlFKycOHCPPvss12eW7duXRYtWpQJEyY0ISX9raXZAQAAAAAAAAAAAAAAAAAAAOqxdOnSmnNlSAAAW7aqqrL99ttnp512qnm+fPnyAU7EQFGIBAAAAAAAAAAAAAAAAAAAbHHWrFmTVatWdZmPGDFCGRIAwFZi9OjR2XbbbbvMOzo6snr16iYkor8pRAIAAAAAAAAAAAAAAAAAALY4S5curTkfNWrUACcBAKA/dffz3fLlywc4CQNBIRIAAAAAAAAAAEAj7rknqaqNf+65p5ur96Sqqo1+7unmLgAAAAAADHYdHR015+3t7QOcBACA/jRy5Mia8+5+HmTLphAJAAAAAAAAAAAAAAAAAADY4nR2dnaZDRkyJEOGDGlCGgAA+kt3P+PV+nmQLZ9CJAAAAAAAAAAAAAAAAAAAYIuzbt26LrPW1tYmJAEAoL/V+jlPIdLWSSESAAAAAAAAAAAAAAAAAACwxSmldJm1tPjPpwEAtka1fs6r9fMgWz4/0QMAAAAAAAAAAAAAAAAAAAAAAE2nEAkAAAAAAAAAAAAAAAAAAAAAAGg6hUgAAAAAAAAAAAAAAAAAAAAAAEDTKUQCAAAAAAAAAAAAAAAAAAAAAACaTiESAAAAAAAAAAAAAAAAAAAAAADQdAqRAAAAAAAAAAAAAAAAAAAAAACAplOIBAAAAAAAAAAAAAAAAAAAAAAANJ1CJAAAAAAAAAAAAAAAAAAAAAAAoOkUIgEAAAAAAAAAAAAAAAAAAAAAAE2nEAkAAAAAAAAAAAAAAAAAAAAAAGg6hUgAAAAAAAAAAAAAAAAAAAAAAEDTKUQCAAAAAAAAAAAAAAAAAAAAAACabkizAwAAAAAAAAAAAAAAAAAAAAB9Y+7cuZkzZ04ee+yxLF26NCtWrMg222yT7bbbLmPGjMkOO+yQffbZJ6NGjWp2VACALhQiAQAAAAAAAAAAAAAAAAAAwBZq0aJFufrqq/PTn/40N998cxYsWLDJO1VVZY899sjUqVPztre9LdOnT88222wzAGkBADZOIRIAAAAAAAAAAAAAAAAAAABsYR577LF84QtfyHe+852sWLGiV3dLKbn//vtz//335/LLL8/YsWNz0kkn5V//9V/zile8op8Sb91+97vfZeXKlevNDj300AwfPrxJiQBgy6QQCQAAAAAAAAAAAAAAAAAAALYQa9euzec///l87nOf61LAU6+FCxfm4osvzre+9a2cddZZOfvsszNu3Lg+2T1YnHbaaXn00UfXmz3yyCOZPHlycwIBwBZKIRIAAAAAAAAAAAAAAAAAAABsAZ566qmcdNJJufHGGzf57Pjx47PLLrukvb09ra2tWb58eZ588snMnz8/69atq3ln9erVueiii3LXXXflhhtu6Ov4AACbpBAJAAAAAAAAAAAAAAAAAAAANnNz587N4YcfnkceeaTm+fDhwzNjxoy87W1vyyGHHJJx48bVfG7FihWZNWtWfvnLX+aHP/xhHn300S7PdHZ29ml2AICeaml2AAAAAAAAAAAAAAAAAAAAAKB7zz77bA477LCaZUitra358Ic/nEcffTSXX355jjvuuG7LkJJkxIgROeyww/L5z38+jzzySK6++upMnTq1P+MDAPSYQiQAAAAAAAAAAAAAAAAAAADYTK1duzbHHntsHn300S5nL3vZy3LjjTfmS1/6UsaPH9/r3VVV5ZhjjsmsWbNy2WWXZezYsX0RGQCgbgqRAAAAAAAAAAAAAAAAAAAAYDP12c9+NrNmzeoynzhxYm666aZMmzat4XdUVZVTTz01f/rTn3LIIYc0vA8AoF4KkQAAAAAAAAAAAAAAAAAAAGAzNGfOnHzuc5/rMm9tbc1VV12VV7ziFX36vokTJ+aGG27IySef3Kd7AQB6akizAwAAAAAAAAAAAAAAAAAAAABdnXPOOVmzZk2X+cc//vFMnTq1X965zTbb5P3vf39DO1asWJHbb789c+bMyXPPPZeVK1dmu+22yw477JCJEyfmwAMPzJAhA1t3MH/+/Nx2222ZN29eli1blvb29owfPz577rln9t1331RVNaB5+srq1atzxx135OGHH87TTz+dlStXZuTIkdlhhx2y0047ZerUqRk2bNiAZnr++edz++23Z+7cuVm8eHHWrFmT9vb27L333vm7v/u7Ac0CwJZHIRIAAAAAAAAAAAAAAAAAAABsZubPn58rrriiy3zy5Mk599xzm5Bo41atWpXvfe97+f73v5+bbropa9eu7fbZ0aNH581vfnPOOOOMvPnNb67rffPmzcvLX/7y9Wa77rpr5s2b9+dfr1u3Lt///vfzla98JbNnz+5214QJE3LyySfn7LPPzrhx43r0/vPOOy+f/vSnN/rMhvm6c+655+a8887r0bNJ0tnZmSuvvDLf/e53c8MNN2TVqlXdPjt8+PAcdthhOe2003LCCSf0+B0bqlUYVUr58/9es2ZNLr/88lxyySWZPXt21q1b1+X5Qw89VCESAJvU0uwAAAAAAAAAAAAAAAAAAAAAwPouvfTSdHZ2dpmfccYZaWtra0Ki2kop+fa3v53Jkyfnfe97X377299utAwpSZYsWZIrr7wyb3nLW3LkkUfmgQce6PNcDz74YA466KCceuqpGy1DSpJnn302F110UV75ylfmJz/5SZ9n6UvXXHNN9thjj7z97W/Pddddt9EypCRZuXJlrrvuupx44omZNm1a/vCHP/R5pttuuy377LNPTj/99Nx66601y5AAoKcUIgEAAAAAAAAAAAAAAAAAAMBmplYxT1tbW9773vc2IU1tS5cuzfHHH5/3vOc9eeaZZ+ra8Ytf/CIHHXRQbrzxxj7LdfPNN+eggw7aZBHShpYuXZoTTzwx3/3ud/ssS19ZvXp1zjzzzBxzzDGZM2dOXTtmzZqVN7zhDbnqqqv6LNcvfvGLvP71r899993XZzsBGNyGNDsAAAAAAAAAAADAFm3o0GSvvTb9TM3x0Oy1ibtDu7kLAAAAAADA1uupp57KHXfc0WX+xje+MRMmTGhCoq4WLVqUt7zlLfnjH//Y7TPbb799Jk2alLFjx2bZsmV57LHHahYnLV68OG95y1tyzTXX5PDDD28o1913352jjjoqS5Ys6TbL4sWL8/DDD2fp0qVd7nd2dub9739/pk2blt12262hLH2lo6Mjb3vb23L99dd3+8yoUaOy6667Zty4cVm5cmXmz5+fxx9/vOauE088Md/+9rdz6qmnNpTrjjvuyIwZM7Jy5cr15iNHjsyuu+6a8ePHZ+nSpZk/f37dhVkADD4KkQAAAAAAAAAAABqx227JPffUeXW33FPnXQAAAAAAoP816//HHzp0aF1FLA8//HA6Ojr6IdGmTZkypdd3Hn/88ZqFNH2hnjybk1tvvbXmfOrUqQOcpLZSSk455ZSaZUijR4/OBz7wgZx88snZe++9U1XVeud/+tOf8rWvfS2XXnppOjs7/zxftWpV3vGOd+Suu+6qu/Rp1apVmTFjxp/LkNra2nL66afn9NNPz3777bdeljVr1uRXv/pVPvGJT+TOO+9cb8/KlSvzgQ98IL/85S+7fdfpp5+eI4444s+/Pv744/P000+v98xPfvKTvOxlL9tk7okTJ270/CMf+UjNMqRhw4blPe95T9797ndnv/32S2tr63rnDz30UL71rW/loosuyqpVq/48X7duXc4888xMnTo1e+655ybzdeed73xnVqxY8edfH3vssfnQhz6UQw45JG1tbes9e9ddd2X27Nl1vwuAwaMqpTQ7A1CnqqqmJZn517OZM2dm2rRpTUoEAAAAAAAAAAAAAAAAADAw5s2bl5UrV643Gz58eCZPntxn79iwyGWg7LXXXnWVMU2ZMiX33ntvPyTatHr+u/UTTjghV155ZT+kqS/P5uTcc8/N+eef32X+s5/9LMcee2wTEq3vggsuyEc/+tEu8yOOOCLf+973sv32229yx8yZM3PMMcdkwYIF682PPvro/PznP9/k/Xnz5uXlL395t+e77LJLrr322rz61a/e6J6VK1fm2GOPza9+9asuZw888EB23333TWZJksmTJ+fRRx9db/bII480/HfSlVdemRNOOKHL/MADD8wVV1zRo/33339/pk+fnnnz5q0332+//TJ79uwuRUq1bOzvw+HDh+dHP/pRjj766E3uAajXQPzs93/dcsstOfjggzccH1xKuaXPX0YXLc0OAAAAAAAAAAAAAAAAAAAAAPzF3Llza87322+/AU7S1SOPPJJPfvKTXeYnnnhirr/++h6VISXJwQcfnBtuuCHDhg1bb37NNdfktttuayjjDjvskJkzZ26yDCl5sUzjBz/4QcaOHdvl7Dvf+U5DORq1bNmynHHGGV3mhxxySG688cYel4DsueeeufHGGzNu3Lj15rfffnt++tOfNpSxpaUl1157rTIkAPqMQiQAAAAAAAAAAAAAAAAAAADYjDzxxBM15xsW2jTDl770paxZs2a92ZQpU3LZZZelqqpe7dpnn33yH//xH13mX/7ylxvK+O1vfzs777xzj58fN25czjrrrC7zm2++uaEcjbrkkkuyaNGi9WYTJkzIz372swwdOrRXuyZOnJhLLrmky/yiiy5qKOOHPvShHHbYYQ3tAIC/phAJAAAAAAAAAAAAAAAAAAAANiMbluAkSVtbW0aMGNGENH+xcOHCXHrppV3mF1xwQYYNG1bXzjPPPDMTJkxYb3bFFVfkhRdeqGvfQQcdlOnTp/f63oknnthldvvtt6eUUleORq1du7ZmMdSnP/3pbL/99nXtPO644/Ka17xmvdlNN92Uhx56qK59Q4cOzac+9am67gJAdxQiAQAAAAAAAAAAAAAAAAAAwGZk5cqVXWajR49uQpL1XXPNNV2Kil71qlfliCOOqHvnsGHDMmPGjPVmq1evzq233lrXvve+97113ZsyZUqXUqdly5bl6aefrmtfo26++eY8/vjj683a29vzrne9q6G973znO7vMbrzxxrp2HXvssXWXMwFAdxQiAQAAAAAAAAAAAAAAAAAAwGZk7dq1XWZDhw5tQpL1/f73v+8y+4d/+IeG977+9a/vMps5c2af7eqJ1tbWTJ48uct8yZIlde1rVK3v+qijjupS2tRbffldv+lNb2ooCwDUohAJAAAAAAAAAAAAAAAAAAAANiO1Sm+aVczz12qV9Lz2ta9teG+tIqI777yz13taW1uz++67151j1KhRXWabUyHS5vRdJ8kBBxzQYBoA6GpIswMAAAAAAAAAAAAAAAAAAAAAf7Htttt2mS1fvjydnZ1pbW1tQqKko6MjDz/8cJf5ihUrMmvWrIZ2P/bYY11mCxcu7PWeMWPGpKqqunMMHz68y2zVqlV172vE3Xff3WXW2dnZ8He9Zs2aLrN6vuskmThxYkNZAKAWhUgAAAAAAAAAAAAAAAAAAAA11CokGQhDhw6t697VV1+djo6OPk7Tfy688MKcd955zY6xWdpxxx1rzpcsWZKxY8cOcJoXLViwoOb81FNP7Zf31VPSU6tIqlGllD7f2RO1fv8f+9jHBuxdPTF69Og+TgIACpEAAAAAAAAAAAAAAAAAAABqmjJlSrMj9Mpuu+3W7Ai9MmnSpGZH2Gx199088sgjTStEqrc0p15LliwZ0PdtTpYvX57Vq1cP2Pvq/a5HjBjRx0kAIGlpdgAAAAAAAAAAAAAAAAAAAADgL7or4/rDH/4wwEn+YvHixQP6vs7OzgF93+ZkoL/rdevWDej7AGBjFCIBAAAAAAAAAAAAAAAAAADAZuSAAw6oOZ89e/YAJ/mLIUOGNO3dg43vGoDBzL8FAQAAAAAAAAAAGvHww8mxx278mauvTnbbrcbVh3PsJu5effXV2a3GXQAAAAAAALZe+++/f0aPHp0lS5asN//d736XUkqqqhrwTKNGjao5v/fee/M3f/M3A5xm69bdd3399ddn+vTpA5wGAAaWQiQAAAAAAAAAAIBGdHQk99676Wdqjjty7ybudnRzFwAAAAAAgK1XW1tb/v7v/z5XXHHFevO5c+fmhhtuyOGHHz7gmSZNmlRzvmDBggFOsvUbMWJExo4dm4ULF643910DMBi0NDsAAAAAAAAAAAAAAAAAAAAAsL5TTjml5vzrX//6ACd5UXt7eyZOnNhl/uijjzYhzdZvr7326jLzXQMwGChEAgAAAAAAAAAAAAAAAAAAgM3M9OnTs8suu3SZX3311bn99tubkCiZNm1al9lvfvObJiTZ/FRV1af7fNcADFYKkQAAAAAAAAAAAAAAAAAAAGAz09ramnPOOafLfO3atTn11FPT0dHRb+9esGBBzflb3/rWLrPrr7++X7NsKYYOHdpltmbNmrr31fqub7rppjz77LN17wSALYFCJAAAAAAAAAAAAAAAAAAAANgMvfvd785rXvOaLvO77747H/3oR/vlnddee23e9a531Tw77rjjMnLkyPVmTz31VL7xjW/0S5YtSXt7e5fZCy+8UPe+Qw45JC9/+cvXm3V0dOQLX/hC3TsBYEugEAkAAAAAAAAAAAAAAAAAAAA2Q62trbn88svT1tbW5ewrX/lKPv7xj6eU0ifvWr16df7t3/4txxxzTJYtW1bzmVGjRuV973tfl/m///u/57777uuTHFuqMWPGdJnNmzev7n0tLS358Ic/3GX+1a9+Nb/73e/q3gsAmzuFSAAAAAAAAAAAAAAAAAAAALCZ2mefffK1r32t5tkXvvCFHH300Zk/f35D77j++uvz6le/Ol/84hc3WbB09tlnZ/vtt19vtnjx4hx55JF9Uor00EMP5fLLL294z0Dba6+9usxuueWWhnaeddZZ2WOPPdabrV69Oscff3xuvvnmhnYnyZNPPpmLL7644T0A0JcUIgEAAAAAAAAAAAAAAAAAAMBm7H3ve1/OOeecmmfXXXdd9txzz3z0ox/N3Llze7xz6dKl+c53vpMDDjggRx11VB588MEe3Rs7dmy++c1vdpnPmzcvr33ta/PlL385K1as6HGOJFm+fHmuvPLKHH300dljjz3ygx/8oFf3NwcHHHBAl9mll16aJ554ou6dbW1t+e53v5u2trb15osWLcqhhx6ac845J4sWLerVzo6Ojlx//fV5xzvekcmTJ+eiiy6qOx8A9IchzQ4AAAAAAAAAAAAAAAAAAAAAbNz555+fbbfdNp/4xCdSSlnvbPny5bngggtywQUXZN99980hhxySvfbaK7vsskva29vT2tqaF154IU8++WQeeOCB3HLLLZk1a1Y6OjrqynLcccflM5/5TJeSphUrVuQjH/lIzj///Lz97W/P61//+uy3334ZN25ctttuu3R0dGTp0qVZuHBh7rvvvtx5552ZPXt2fvOb39SdZXPx1re+NcOGDcuqVav+PHv++eezzz775JRTTsnrXve67Ljjjhk+fHiXuxMnTszEiRNr7j3wwAPzrW99K6eddtp6/9w7Ozvz2c9+NhdeeGFOOOGEHHrooTnwwAMzYcKEbLfdduns7MySJUuyePHiPPjgg7nzzjtz22235de//nWWL1/e918AAPQRhUgAAAAAAAAAAAAAAAAAAACwBfjYxz6W17zmNTnttNPy3HPP1XzmjjvuyB133FH3O0aNGpWTTjppk8+dffbZaWlpyac+9akuZ4sWLcrFF1+ciy++uO4cW5oxY8bklFNOySWXXLLefOHChbnooos2evfcc8/Neeed1+35KaecklJKTj/99KxZs2a9sxUrVuSyyy7LZZddVnd2ANictDQ7AAAAAAAAAAAAAAAAAAAAANAz06dPz/33358PfOADaWtr67O9Q4cOzYc+9KHMmTMnZ511Vo/ufPKTn8y1116bHXbYoc9yJOnT39dA+s///M/svvvu/bL71FNPze9///vstttufbp3S/2uAdh6KUQCAAAAAAAAAAAAAAAAAACALcjYsWPzta99LXPnzs3HP/7x7LLLLnXvmjp1ar761a9m/vz5+fKXv5xx48b16v5RRx2VBx98MJ/61KcyduzYunO0tbVl+vTp+eEPf5gf//jHde9ppvb29syaNSsnn3xyWlr6vs7hoIMOyt13350LLrggO++8c917Wlpa8oY3vCHf/OY3c/PNN/dhQgBoXFVKaXYGoE5VVU1LMvOvZzNnzsy0adOalAgAAAAAAAAAYBC6555k7703/szddydTptS4ek/23sTdu+++O1Nq3AUAAAAAgMFu3rx5Wbly5Xqz4cOHZ/Lkyc0JBE32v//7v7npppsye/bszJkzJ4899liWLFmSlStXZptttsmYMWMyZsyY7Ljjjtl///1z4IEH5nWve11DZUobWrlyZa677rpce+21mTVrVh566KGsW7eu5rM77bRT9txzz+y///457LDD8oY3vCHbbrttn2VptieeeCI/+tGP8sc//jF33XVXnnvuuSxfvjwrVqzo8uy5556b8847r1f7165dm1/+8pf5+c9/npkzZ+a+++7L2rVraz47fvz47Lnnntlnn31y2GGH5Y1vfGPGjBlTz28LoGkG8me/W265JQcffPCG44NLKbf0+cvoYkizA7D5qKpqryR7J9kpycgkq5I8l+S+JLeXUtY0MV6vVFW1Y5L9k+yQZLskI5IsT7I4yVNJbiulLGheQgAAAAAAAAAAAAAAAAAAgL6z//77Z//9929qhuHDh2fGjBmZMWNGkmTNmjWZP39+lixZktWrV2fEiBFpb2/P9ttvv1WVH9UyceLE/Mu//Eu/7R8yZEiOPPLIHHnkkUmSzs7OPPnkk1m0aFE6OjoybNiwjBo1KmPGjMmoUaP6LQcA9DWFSINcVVWTkvxTkv8nLxYhdWdZVVU/T/JfpZQ/DEi4Xqqq6tVJzkhyXJKJPXh+bpIfJ/lmKeXhfo4HAAAAAAAAAAAAAAAAAAAwqLS1tWXy5MnNjjEotLa2ZtKkSZk0aVKzowBAQ1qaHYDmqKqqpaqqTyZ5IMm/ZuNlSEnSnuQdSW6tquryqqpG93fGnqqqaqeqqn6W5M4k/5gelCG95BVJPpbkwaqqvl1V1Zj+yggAAAAAAAAAAAAAAAAAAAAAwMYpRBqEqqoanuTnSf7fJMPrWHFKktlVVb28T4PVoaqqw5Pcm+TYRtYkeVeSe6uq2q8vcgEAAAAAAAAAAAAAAAAAAAAA0DtDmh2AgVVVVWuSq5JM7+aRNXmxYOj5JO1J9koyssZzr0ry/1VVdXAp5an+yLopVVW9KS8WO22s1OnpJI8lWZb5hCxVAAAgAElEQVRkVJJdk0zo5tkdk/y6qqo3lVLu7MusAAAAAAAAAAAAAAAAAAAAAABsXEuzAzDgzk/tMqTFST6SZHwpZd9SyuGllNclGZtkRpIHa9yZnOS/XypZGlBVVY1K8oPULkN6IcnnkryylPKyUsrrXvr9TC2l7JBk9yRfTLKqxt2xSb5fVZWyMAAAAAAAAAAAAAAAAAAAAACAAaQQaRCpqmqfJB+rcfRIkgNKKV8upSz564NSyppSylVJ9k/yPzXuHprkzD4Pu2nnJNmxxnxukv1LKZ8qpcytdbGU8lAp5d+SHJDksRqP7J3kg32WFAAAAAAAAAAAAAAAAAAAAACATVKINLj8Z5LWDWYvJDmyu/Kg/6uU8kKStyW5p8bx+VVVjeybiJtWVVVLklNrHK1KckQp5cGe7Cml3JvkiCQdNY5r7QcAAAAAAAAAAAAAAAAAAAAAoJ8oRBokqqp6bZK/q3H0mVLK/T3ZUUpZkeR9NY7GJjmjgXi99bokE2rMLy6lPNSbRaWU+5L8nxpH+1dVtXM94QAAAAAAAAAAAAAAAAAAAAAA6D2FSINHrcKiBUm+0pslpZRbkvxPjaNaRUn95VXdzK+qc9+Pu5m/os59AAAAAAAAAAAAAAAAAAAAAAD0kkKkQaCqqiFJZtQ4+n4pZUUdKy+pMduzqqr969hVjx26md9b5777upm/rM59AAAAAAAAAAAAAAAAAAAAAAD0kkKkweGgJGNqzK+qc991SVbWmE+vc19vVd3Ml9e5b2k388469wEAAAAAAAAAAAAAAAAAAAAA0EsKkQaHN9WYrUhySz3LSimrksyscXRYPfvq8Ew38+3r3Deum/nTde4DAAAAAAAAAAAAAAAAAAAAAKCXFCINDgfWmN1eSlnTwM4/1Jjt38C+Rt+dJFPr3Pe6GrM1Sf63zn0AAAAAAAAAAAAAAAAAAAAAAPSSQqTB4TU1Znc3uPPOGrPtqqratcG9m1RKuS/JfTWO3lXnyvfUmF1bSllZ5z4AAAAAAAAAAAAAAAAAAAAAAHpJIdJWrqqqbZJMqnH0cIOr53Qzf0WDe3vqCzVmx1dVdWxvllRVdUKSozcYr0vy+XqDAQAAAAAAAAAAAAAAAAAAAADQe0OaHYB+Nym1i6/mN7i3u/uTG9zbI6WUy6qqOinJ9A2O/ruqqrNKKZdtakdVVWck+a8aR18spfyhL3L2IMO0Blfs3SdBAAAAAAAAAAAAAAAAAAAAAACaTCHS1m98N/NnGtzb3f3u3tcfTkryP0n+ulRoeJLvVFX1wSTfTnJzkseSLE8yMi8WNh2S5D1J9qux85tJPtF/kbuYOYDvAgAAAAAAAACgP0yZkpRS59UpKXXeBQAAAAAAAACArY1CpK3f2G7mSxpZWkrprKrqhSTbbnC0fSN7e5lhWVVVb0ryH0n+KUnrXx0f+NKnpxYm+Vgp5Zt9GBEAAAAAAAAAAAAAAAAAAAAAgB5qaXYA+t3IbubL+2D3CzVmGxYk9atSSkcp5Z+T7JHkv5I80csVtyb5SJLJypAAAAAAAAAAAAAAAAAAAAAAAJpHIdLWr62b+do+2L2mxmybPthbj3V5seRpaS/v7ZLkb5K8ss8TAQAAAAAAAAAAAAAAAAAAAADQY0OaHYB+19rNvLMPdtfaMaB/pqqq2i7JfyY5tc53vyzJGUnOqKrqp0nOKqU804cRN+XgBu/vneQbfREEAAAAAAAAAAAAAAAAAAAAAKCZFCJt/dZ2M++Lf/a1dqzpg709UlXVlCTXJ9mlxvGiJD9PcnOS+UmWJhmdZOckf5vkmCTbbXDn+CSHVFU1vZRyW3/l/mullFsauV9VVV9FAQAAAAAAAAAAAAAAAAAAAABoKoVIW7+Obubb9MHuWju6e1+fqqrqFUluSLLDBkdrk3wmyYWllOXdXP9GVVUjk/xzkn9P0vpXZ+OT/Kqqqr8tpdzXx7EBAAAAAAAAAAAAAAAAAAAAAOhGS7MD0O+WdTNv74PdtXYs7YO9G1VVVWuS76VrGdLqJEeUUs7fSBlSkqSUsryUcn6SI16699fGJPluVVUKwwAAAAAAAAAAAAAAAAAAAAAABohCpK3fgm7m2zWytKqqYUmG9uJ9femkJNNqzD9USrmhN4tKKb9O8uEaRwckeUcd2QAAAAAAAAAAAAAAAAAAAAAAqINCpK3f093Md2xwb3f3u3tfX/rHGrMHklxS575vvHS/J+8BAAAAAAAAAAAAAAAAAAAAAKAfKETa+j2ZpKPGfJcG93Z3/5EG925UVVWjk7yuxtF/l1I669n50r0f1Tg6oKqqMfXsBAAAAAAAAAAAAAAAAAAAAACgdxQibeVKKSXJnBpHuze4+lXdzB9ucO+m7Jvaf25vanDvjTVmVZJ9GtwLAAAAAAAAAAAAAAAAAAAAAEAPKEQaHG6vMWu06Ge/GrMnSinPN7h3U8Z3M3+mwb3d3R/X4F4AAAAAAAAAAAAAAAAAAAAAAHpgSLMDMCBuTfKODWZ7VVU1upSypM6d07p5T3/r7s/smgb3dndfaRgAAAAAAAAAABv3+OPJP//zxp+58MJk0qQaVx/PP2/i7oUXXphJNe4CAAAAAAAAAMDWRiHS4PDrGrPWJIcnuaq3y6qqmpBkvx6+p6893818fJIHGtg7vpv5cw3sBAAAAAAAAABgMFi6NLnyyo0/c9553Vxdmis3cfe8bu4CAAAAAAAAAMDWpqXZAeh/pZT7ksypcXRSnStPTFJt+Jok19a5rzee7WZ+QIN7D+xmrhAJAAAAAAAAAAAAAAAAAAAAAGAAKEQaPL5XY3ZcVVWTerOkqqoqyQdrHP22lPJEXcl65/4kL9SYH9/g3rfVmC196X0AAAAAAAAAAAAAAAAAAAAAAPQzhUiDxzeSrN5g1pbks73c8+4ke9aYf7WnC6qqmldVVdngM68nd0spq5P/n707D6u6zP8//jqAIJssCirgllkalktqqLlbLpSZpmlqizqSWfNzbNrLtClrqsm+M1mGfUstq1FLM1MzU9Pcci1xRcWFXBBQFBAFzuf3R+W34+cAZ4Oj8nxcF9dcvO/7ft/vczqHi2vAF1phZ6mTxWLp4ugMl8zTU1J7O0vLDcMocqUnAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMA5BCJVEoZhHJX0oZ2l+y0WywBHelgsluskvWVnKUXSfDfGc9ZnJdRnWSyWOs40slgsDSTNcPIeAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAICHEYhUubwgKdtO/WOLxTK4tIMWi6WFpO8lhdlZ/qthGFYPzOeozyX9YqdeW9IGi8XS1ZEmFoulh6T1kqLtLG+RNMflCQEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAATiEQqRIxDCNT0gg7SwGSPrVYLIssFstdFoulpsVi8bVYLOEWi6WTxWJJlrRBUpyds5MNw1hRnnNf6vfwpTGSLthZri3pe4vFstJisSRZLJamFoslwmKx+FkslkiLxXKjxWIZbbFY1khaIvthSOclPWoYhlF+jwIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA8Gd+3h4AFcswjPkWi+VZSZPsLPf6/cNRCyU95ZHBnGQYxo8Wi2WopM9lP9ir0+8fzrJKGmIYxjp35gMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAOMdekAyucoZhvCrpb5KK3WjziaR7DMMo9MxUzjMMY46kOyQd81DLY5LuMAzjCw/1AwAAAAAAAAAAAAAAAAAAAAAAAAAAAABcRaZOnSqLxWLz8fDDD3t7LMBhu3fvNr2GGzdu7O2xAOAiApEqKcMw3pbUXtJmJ48ekzTMMIxhhmGc9/xkzjEMY7GkGyW9I+mMi23OSPqPpKa/9wMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAVDA/bw8A7zEMY4OkVhaLpbukoZK6S4q1s/W0pNWS5kr6r7tBSIZh1HfnvJ1+WZIes1gsz0gaKKmzpDaSrpNksXdE0l5JP0laKWm2YRi5npwJAAAAAAAAAAAAAAAAAAAAAAAAAAAAANw1YcIETZw40akzQUFBCgsLU1hYmBo0aKDWrVurdevW6t69u6pWrVpOkwIAAHgGgUiQYRjLJC2TJIvFEi4pRlKwpAJJmYZhHPPieA77PdTow98/ZLFYAiRFSgrXb48nT7+FO2W7G+oEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAJej/Px85efn69ixY9q9e7cWL14sSYqMjNQDDzygv/3tb6pTp46XpwQAALDPx9sD4PJiGMZpwzB2Goax0TCM7VdKGJI9hmGcNwzjmGEYuwzD2PT7/x4jDAkAAAAAAAAAAAAAAAAAAAAAAAAAAABAZZOdna3JkyeradOmmj59urfHAQAAsItAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKokzZ87ooYce0jPPPOPtUQAAAEz8vD0AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABw3Lp160pcy83NVWZmpjZv3qxvvvlGu3btsrvvtddeU506dfTII4+U15gAAABOIxAJAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIArSEJCQpl7Bg0apNdff13z5s1TUlKSMjMzTXuefPJJ9evXT7Vq1SqPMQEAAJzm4+0BAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACA51ksFvXr10+bNm2yG3qUl5enl19+2QuTAQAA2EcgEgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAV7F69erpk08+sbv22WefyWq1VvBEAAAA9hGIBAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAVa5bt27q0KGDqZ6dna0tW7Z4YSIAAAAzP28PAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAyl/fvn21evVqU33Dhg1q1aqVy30zMjK0bds2HTx4UKdPn1ZRUZGioqIUHR2tRo0a6YYbbnBn7FIZhqFDhw5p9+7dSk9P19mzZ5Wfn6/Q0FBFRkYqOjparVq1UmRkZLnNcLUwDEP79u3T9u3bdfLkSZ05c0bnz59XYGCggoKCFB0drfr166thw4YKDw/39rjlLj8/Xxs3btSePXuUnZ0tX19fRUVFKS4uTu3atVNQUFC5z5CZmamff/5Zhw4dUlZWlgoKChQUFKTQ0FDVq1dPjRs3Vt26dWWxWMpthvT0dG3evFkHDx5Ubm6uqlWrpqioKDVp0kTNmjUrt3vtOXnypLZu3aoDBw4oJydHhYWFqlatmpo1a6ZOnTo51au4uFgpKSnatWuXjh07pry8PFWpUkVhYWFq0KCBWrZsqaioqHJ6JCVLTU3Vtm3blJ6ervz8fEVERCgqKkrNmzdXo0aNKnwewBsIRAIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAoBIoKfQoIyPD6V5Hjx5VcnKy5syZo507d5a6t169ekpMTNS4cePUsGFDp++61Pbt27Vo0SKtXLlSa9as0dmzZ0vdb7FYFB8frzvvvFP/7//9P9WsWdPtGTxh8+bNuuOOO3T8+HGbelBQkD799FPdddddFTLH8uXLNWPGDM2fP19nzpxx6EyjRo2UkJCgxMREJSYmKiQkxO6+Fi1aaNu2bTa11157TU899ZTbcxcUFCgmJkanTp2yqc+bN099+/a1eyYhIUEbNmywqa1bt04JCQkXP9+8ebPeeOMNLViwQOfOnbPbJyAgQF27dtWECRPUpk0bNx+JrUOHDmnatGmaN29eme8tSapZs6a6d++uPn36qG/fvvL393d7hqKiIn388cd65513tGXLlhL31apVS0OHDtUzzzzjUuhYQUGBAgMDbWoBAQEqKCi4+PmFCxc0ffp0TZs2TZs3b5ZhGKY+PXr0cDgQ6ccff9TUqVP19ddfl/l6v+mmmzRkyBAlJSUpLCzMof6XWrhwoe68806bWmJiohYuXHjx8/z8fL3//vt67733lJqaWmKva665RiNHjtTYsWNNz1tJvvjiC91zzz02tRo1aig9PV0BAQFOPBL7XnnlFT3//PM2tZtvvlmbNm1yuzcqLx9vDwAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMpfVFSU3XpmZqbDPXJzc/X3v/9dDRo00MSJEx0KbDl06JDeffdd3XDDDRo3blyZAUYlmTJlim644QbddNNNevrpp7VkyRKHehmGoZSUFL366quqX7++nnjiCRUWFro0g6csXLhQnTp1MoUhRUdHa+XKlRUShpSWlqbevXurW7dumjlzpsNhSJKUmpqqjz/+WIMGDVJcXFyJ+0aPHm2qffDBB3ZDbZw1e/ZsUxhSTEyM7rjjDpf6XbhwQY899phat26t//73vyWGIUnS+fPntXjxYt1yyy1KSkpScXGxS3f+WUZGhkaOHKmGDRvqlVdecei9JUknTpzQrFmzdO+99youLk5r1qxxa46dO3eqTZs2Gj58eKlhSJJ0/Phxvfnmm2rYsKFNwI+nrF+/XjfeeKOSkpK0adMmt143aWlp6tmzpzp06KBZs2Y59Hr/5Zdf9NRTT6levXqaMmWKR163l1q9erWaNm2qcePGlRqGJEkHDhzQs88+q+uuu87hwKG77rpLMTExNrXMzEx9+eWXLs/8B6vVqg8++MBUT0pKcrs3KjcCkQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAqATcDfNISUlRy5Yt9a9//UsXLlxw+vyFCxc0efJkde7cWRkZGU6f/+ijj7Rr1y6nz/1ZQUGB3nzzTXXv3l0nT550q5erpkyZor59+yovL8+mfv3112v9+vVq3bp1uc+wfft2JSQkaPHixW73KigoKHFtyJAhqlatmk1t3759Wr58udv3Jicnm2rDhw+Xn5+f073Onj2rrl276p133nH6fZKcnKx77rlHVqvV6Xv/8P333+vGG2/U//7v/7oVrnTy5EkdOXLE5fMrV65U27ZttXXrVqfOnT59Wnfffbdmz57t8t2Xmj9/vjp37qy9e/e63evbb79Vy5Yt9e2337p0PicnR48++qj69eun/Px8t+f5w6xZs9StWzelpaU5dS49PV1du3Z1KPzKz89PI0eONNXtvX+ctXTpUh08eNCmFhoaqsGDB7vdG5Wb81/FAQAAAAAAAAAAAAAAAAAAAAAAAAAAAADAFSczM9NuvUaNGmWe3bhxo26//XadPn26xD1169ZVzZo1FRoaqszMTB04cEC5ubmmfVu2bFG7du20Zs0a1axZ0/EHUAIfHx/VrVtXERERCgsLk2EYysnJ0YEDB3TmzBm7Z1atWqV+/fpp5cqV8vX1dXsGRxiGoSeeeEL/+te/TGsdOnTQ/PnzFRkZWe5znDlzRj179iwxlMrHx0dxcXGKjY1VUFCQCgsLdebMGWVkZOjo0aNO3RUcHKxhw4ZpypQpNvXk5GR169bN5cewc+dOUxiMj4+P3eCXshQWFqpPnz6mfgEBAbrmmmsUFRWloqIiHTlypMSwofnz52vy5Ml6/PHHnb5/9uzZGjp0qAoLC0vcEx4ertjYWEVFRamwsFCnTp3SwYMHPRrOs3XrVt15552m92yNGjVUp04dRURE6NSpU9q3b5/Onj1rOl9UVKQRI0bolltuUb169dya5aefftLgwYN1/vx5m3poaKjq1aunqKgonT59Wr/++muZ4WpLlizRXXfdVWKIW5UqVVS/fn3FxMQoLy9Phw8fLrHn/Pnzdccdd2jJkiXy9/d37cH9buHChXrggQdMAVgxMTGKiYlRaGiosrOztXv3btPzIP0W4nXfffcpJSVFoaGhpd71l7/8Ra+88orNXStXrlRqaqoaNWrk8mOwF6p03333KSQkxOWegEQgEgAAAAAAAAAAAAAAAAAAAAAAAAAAAADYt2OHd+4NCJCuvdb5c/v2SXZCEypEfLzzZ44ckUoIq3GbK/NUAhs3brRbj4qKKvVcRkaG+vTpYzcMqVGjRnr88cd15513KiYmxmbtwoULWrlypV555RWtWrXKZm3//v166KGHtGjRIicfheTn56dbb71Vffr0Ufv27dW0aVMFBQWZ9hmGoT179ujzzz/Xe++9Zwo5+fHHH/Xiiy/q5ZdfdnoGZxUUFGjYsGGaO3euaW3w4MH66KOPFBAQUO5zSNKECRPsBhvdeuutGjt2rG677TZVq1bN7tnTp0/r559/1pIlS7Rw4UKlpKSUed/DDz9sCkSaP3++Tp48WeZrryT2glh69uzpUhDP888/b/P6bN++vZ566il169bN9Lras2ePJk2apJkzZ5r6vPDCCxo0aJBiY2Mdvnv58uUlhiGFhobqscce0913362bb75ZFovFZr24uFg7d+7UihUr9N///lfr1q2TYRgO3/1neXl5uueeey6GIfn7+yspKUnDhw9Xs2bNbO4uLCzUkiVL9PTTT2vnzp02fXJzc/XYY49pwYIFLs0hSVarVUOHDlVBQcHF2j333KNHH31U7du3l5+fbVTKtm3b9PPPP9vtdfToUQ0ZMsRuGFJcXJxefPFF9e/fXxERETZrGzdu1Lvvvqvp06ebzq1YsULPPfec3njjDRce3W+OHDmiYcOGXQwoCg0N1bhx43Tffffpuuuus9mbn5+vuXPn6rnnnlN6errN2uHDh/Xiiy/qrbfeKvW+uLg43XnnnZo/f75NPTk52eXHcfz4cX399demelJSkkv9gD+zuPrFDID3WSyWtpLW/rm2du1atW3b1ksTAQAAAAAAAAAAAAAAVEI7dkhNm5a+JyXF7i/d79ixQ03LOJuSkqJ4fmEfAAAAAAAAAACTgwcP6ty5cza1wMBA1a9f33OXXBI+UWFuuMG1MKb4eOmScIoK48q/Wx8wQLITDuMRV8m/o58wYYImTpxoqruaE9CxY0etXr3aVP/pp5/UunVru2cMw1DPnj21dOlSm7qPj4+ee+45TZgwQT4+PmXe/fbbb2vcuHGm2adMmaJHHnnEofkTExPVunVrjRkzxukgnVOnTmnkyJH68ssvbeoBAQE6fPiwoqOjHeozdepUjR492qaWlJSkqVOnlngmMzNTffr00bp160xrTz31lF599VVT2E15KSoqUq1atZSVlWVT//vf/67XX3/d6Tk2bNig9957z25wzJ/Ze+29/vrreuKJJ5y6T/otXCo2NlbZ2dk29fnz5+uuu+4q9WxCQoI2bNhgd83X11f/+c9/TP997ZkyZYoeffRRU33ixIkaP358meel314XTZs21YkTJ0xr/fr103vvvefw61KSdu/erVdffVV9+vRR//79S93XpEmTEtevueYaffPNN2rcuHGp9+Xl5SkxMVE//PCDTd3Hx0cHDhxwKJyqoKBAgYGBJa6HhIRo7ty56tGjR5m9LmUYhnr06KHvvvvOtNa/f399+OGHJQZ//WHp0qXq37//xaCoP1gsFn3//ffq0qVLmXMsXLhQd955Z4nrbdq00VdffaVatWqV2uf48ePq0qWLdu/ebVMPCwvTsWPHSn0epd8ey6XPY1RUlNLT0+Xv71/GozCbNGmSnnvuOZtaq1atSgze84QK+d7vd+vWrVO7du0uLbczDMP8hRweV/Z3FQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA4Ir2/fff2w1DioiI0M0331ziuQ8//NAUhiRJycnJeumllxwKQ5KksWPH6u233zbVX375ZRUWFjrUY+HChZowYYLTYUjSb49z9uzZSkxMtKmfP39e77//vtP9HJWamqqEhARTGJKvr6+mTp2q1157rcLCkCRp8+bNpjCkxo0b65///KdLc9xyyy1lhiFJshsyNG3aNKfvk6S5c+eawpBiY2N1xx13uNTvD9OnT3coDEmSxowZowEDBtjt4ahnn33WbhjSww8/rDlz5jgVhiT99t9xxowZpYYhlSU2NlZr164tMwxJkoKDg/XZZ5+ZQoWsVqtmzJjh8gx/8PPz05IlS1wKQ5J++3phLwypV69edue25/bbb9eCBQsUEBBgUzcMQ2PHjnVprj9r2bKlVqxYUWYYkiTVqlVLn376qXx9fW3qOTk5mjdvXpnnb7vtNl177bU2tZMnTzp09lKGYeiDDz4w1ZOSkpzuBdhDIBIAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFexQ4cOaejQoXbX7r333hJDjQzD0BtvvGGqjxkzRiNGjHB6jr/+9a/q2bOnTe3YsWOaPXu2Q+fdDQ76I4To0nCTWbNmudW3JGvWrFHbtm21f/9+m3pISIi+/vprr4SHHDlyxFTr3bu3w8FWrurfv78p4Cc1NVUrVqxwuldycrKpNnz4cFNQjDPuv//+Et8jJRk/fryplpaWpmPHjpV5Ni0tTR9++KGp3r59e02ZMqXc/3uU5OOPP1bNmjUd3l+7dm395S9/MdXXrFnj9ixPPPGE2rdv7/L5//znP6ZaeHi4ZsyYoSpVqjjcp0uXLnryySdN9V9++UU//PCDy/MFBATo888/V1BQkMNnWrRoYTf4y5Hn22Kx2P2aY+/9VJbvvvtOaWlpNrXQ0FANHjzY6V6APQQiAQAAAAAAAAAAAAAAAAAAAAAAAAAAAABwFTIMQ/PmzVOrVq10/Phx03pgYKBeeOGFEs8vWLBAe/bssalFRETopZdecnkme/fZC4YpL3FxceratatNbe/evcrOzvboPbNnz1b37t2VlZVlU69du7ZWrVqlXr16efQ+R505c8ZUq1atWrnf6+/vbzdEy9kwlt27d2v16tU2NR8fH40cOdLl2Xx8fPTiiy86fa5p06Zq0qSJqb558+YyzyYnJ6u4uNim5ufnpxkzZngtDKlz587q0qWL0+cGDhxoqjnyHJQmKChITz/9tMvn9+7dq2XLlpnq48ePV1RUlNP9nnnmGcXExJjq77zzjkvzSdKwYcPUqFEjp8+583wPHz5cVatWtamtWHCFWP8AACAASURBVLFC+/btc2oGe+/bIUOGKDg42Kk+QEkIRAIAAAAAAAAAAAAAAAAANxiGUeaejDMFFTAJAAAAAAAAAAAAKov169eX+LF8+XLNnj1bTz75pOLj49WvXz9lZmba7TNp0iS7IR9/+Pzzz021oUOHKjIy0uXZ27Vrp2uuucb0eIqKilzu6azWrVvbfG4YhjZs2OCx/m+88YYGDRqkggLbnxM2bdpU69evV4sWLTx2l7PCw8NNtZ9++qlC7h41apQp7GfevHklvj7tsRfE0qtXL9WtW9flubp06WJ6TTrq5ptvNtVSU1PLPDd37lxT7a677lLDhg1dmsMT7AVWOaJZs2by8/OzqWVlZenUqVMuz3LPPfe4FdS1dOlS08/y/f399cADD7jULzAw0O7Z7777zqHfGbDH1efb1decJEVGRpoClQzD0LRp0xy+/8SJE1qwYIGpnpSU5HAPoCx+ZW8BAAAAAAAAAAAAAAAAAJRkX2hNPTJ8Sql7/lIUKvPfaJQaNmyolJSUUs968xdeAQAAAAAAAAAAcHlq27at2z3Gjh2rsWPHlrpn9erVplr//v3dvrtDhw46cODAxc/z8/O1bds2tWrVyu3ejoiOjjbV9u/f73bf4uJiPfroo5o6dapprWvXrvryyy8VFhbm9j3uiI+PN9UWLVqkzz//XIMGDSrXu+vXr69evXrpm2++uVg7f/68ZsyYoccff7zM8+fPn9fMmTNN9VGjRrk1V4cOHVw+e+2115pqOTk5pZ5JS0vTvn37THVXA3I8xdXnISAgQHFxcTp48KBNPScnRxERES717NKli0vn/rBu3TpT7fbbb3crzG3IkCF69dVXbWo5OTnauXOn3fdVaYKCguwGGznC3mvuzJkzDp8fPXq06X00ffp0vfzyy6pSpUqZ5z/66CMVFhba1Fq3bq3mzZs7PANQFgKRAAAAAAAAAAAAAAAAAMANi/edVmpUvVL3rD+WbzcQqWrVqk7/YiQAAAAAAAAAAADgjuDgYL355pt6+OGHS923f/9+/frrrzY1i8XicojHn9WvX99U++WXX5wORCoqKtKKFSu0fv16bd++Xbt379apU6d09uxZnT17Vlar1eFep0+fduruS+Xm5mrQoEE2YT9/uP/++/XBBx84FDZS3q6//no1bNjQFAB133336euvv9bYsWPVunXrcrt/9OjRpucoOTnZoUCkuXPnKisry6YWGxurxMREt2a64YYbXD5brVo1U62sQKTNmzebaj4+Pmrfvr3Lc7grKChI9eqV/nPv0rjyPJTG3a8z69evN9VuueUWt3recMMNCg0N1dmzZ23q69atc/rn/tdee63LXw98fX0VFBSk/Pz8i7WioiLl5eUpODi4zPMJCQlq3ry5tm3bdrGWkZGhefPmaeBAe7/Z8H8Mw9C0adNM9aSkJCceAVA2ApEAAAAAAAAAAAAAAAAAwA1LUo6XuWfjwewKmAQAAAAAAAAAAAAoWVhYmIYOHarHH39cDRo0KHN/SkqKqRYZGWm37ix7QSnZ2Y7/TC0jI0OTJk3Sp59+qpMnT7o9j+ReINLx48fVqVMnbdmyxbQ2fvx4TZw40Z3RPO65557T8OHDbWqGYejTTz/Vp59+qgYNGqh3797q2LGjbr31VsXExHjs7l69eqlevXo6dOjQxdrevXu1cuVKde7cudSzycnJptrIkSPl6+vr1kyRkZEunw0MDDTVCgoKSj2TmppqqjVu3NhuqFBFcec5kFx7HkoTFxfnzjg6fPiwqdaiRQu3elosFjVv3lyrV68u866yeOL5/nMgkvTb8+1IIJL0WzDZpSFGycnJZQYiLVu2TAcOHLCpVatWTYMGDXLoXsBRBCIBAAAAAAAAAAAAAAAAgIsOZ+Vr57EzZe47kn1Ox3MKVCusagVMBQAAAAAAAAAAPMYDwS8uCQhw7dxXX0nnz3t2lvL01lvShAnenuKqU7VqVYWFhSk8PFz16tVTq1at1KZNG912220KCgpyuE9WVpbdWtu2bT057kWOBiJNmzZNTz75pFsBRvbk5eW5fParr74y1apUqaLk5GQ9+OCDbkxVPh566CEtW7ZMn376qd31tLQ0TZkyRVOmTJEk1alTR506dVKXLl3Uo0cPxcbGuny3j4+PkpKS9Oyzz9rUk5OTSw1E2rNnj1atWmVT8/X11YgRI1ye5Q+Ohsg4yjCMUtd//fVXU83dACB3efo5kMp+HkrjTjjU2bNnVVRUZKrXrl3b5Z5/sBcOdurUKaf7ePv5HjJkiJ544gmdOfN/v++wfPly7d+/Xw0bNizxnL1QsiFDhpTL40HlRiASAAAAAAAAAAAAAAAAALjo2x3HHd7708Fs9Wnmub+cCgAAAAAAAAAAKkB8vLcncM6113p7AufUqePtCa5Y7gSNOMrRgCJPycnJKXPPyy+/rBdeeKFc7vf0c+rn5+eRAJbyMnPmTMXFxenNN9+U1Wotde+RI0f0ySef6JNPPpHFYlGnTp00cuRIDRo0SL6+vk7fPWLECE2YMEEXLly4WPvyyy+VlZWl6tWr2z1jL4ilV69eqnMFfh3Jzc011cLDw70wyeUpICDApdfVH0oKKHInZOkPYWFhDt93OQsODtawYcMuhp5Jv30NnDZtml577TW7ZzIyMuyGvyUlJZXbnKi8fLw9AAAAAAAAAAAAAAAAAABcqZwKREoz/wVdAAAAAAAAAAAA4HJ1+vTpCr2vuLi41PU5c+aUGIbk6+urFi1aaPTo0Xr99df12WefadGiRVq+fLnWrl2rdevW2Xw8+eSTHp29WbNmCgwMtKmdO3dOffr00fz58z16l6f4+vrqn//8p37++WcNHDhQ/v7+Dp0zDEMrV67U0KFDFR8frxUrVjh9d3R0tPr162dTO3/+vGbMmGF3//nz5zVz5kxTfdSoUU7ffTmw91q/9PUD1507d85u3RPPsb0eeXl5bvf1htGjR5tq06dPV2Fhod39H330kWmtTZs2atasWbnMh8qNQCQAAAAAAAAAAAAAAAAAcEHGmQJtPuz4X3rcmHbl/VVIAAAAAAAAAAAAVF5+fn7eHuGi/Px8jRs3zlT38/PTs88+qyNHjmjLli1699139cQTT2jQoEHq1auXunTporZt2yohIcHmo06dOh6dLyEhQUuWLFFoaKhN/cKFCxowYIBmzZrl0fs8qWnTpvrvf/+rY8eO6cMPP9SQIUMUGxvr0Nk9e/aoe/fu+s9//uP0vY888oipNm3aNLt7v/zyS2VmZtrU4uLi1Lt3b6fvvRyEh4ebamfOnPHCJFenatWq2a2fPXvW7d72eoSFhbnd1xvi4+PVsWNHm9qJEyf01VdfmfYahqEPPvjAVE9KSiq3+VC5EYgEAAAAAAAAAAAAAAAAAC5YuvOEDMPx/XtOnNXp/AvlNxAAAAAAAAAAAADgQfZCRerWrSvDMMrlY+rUqSXOMm/ePKWnp9vUfH19tXjxYr3yyiuqXbu2U4/t1CnP/zGTjh076vvvv1dkZKRNvaioSPfff3+JYT+Xi8jISD300EP65JNPlJ6ergMHDmjmzJkaOXKkGjZsWOI5q9WqsWPHavHixU7d16FDB8XHx9vUdu/erVWrVpn2Jicnm2ojR46Ur6+vU3deLi59jUjS6dOnvTDJ1SkiIsJu3ROhUzk5Oaaavf+eV4rRo0ebavbeb8uXL9e+fftsamFhYRo0aFC5zYbKjUAkAAAAAAAAAAAAAAAAAHDBtzuOO31m00HP/2I1AAAAAAAAAAAAUB7q1KljqmVlZXlhEmnBggWm2qOPPqru3bu71C8zM9Pdkexq3bq1Vq5cqZo1a9rUrVarRo0apcmTJ5fLveWhQYMGGjZsmKZNm6Z9+/Zp586deuaZZ1S9enXTXqvVqscff1xWq9WpOxwJY0lNTdXKlSttar6+vhoxYoRTd11OatSoYaqlpqZ6YZKrU9WqVVW1alVT/cCBA2733r9/v6lWUgDTlaBfv36Kjo62qS1btkxpaWk2NXshSUOGDFFQUFC5zofKi0AkAAAAAAAAAAAAAAAAAHDS6fwLWrff+V/23ngwuxymAQAAAAAAAAAAADzvhhtuMNXy8vK8Eoq0efNmU23YsGEu99uyZYs745Tqxhtv1KpVq+wGSo0bN07/+Mc/yu3u8tSkSRNNmjRJqamp6tmzp2l9165d2rRpk1M9hw0bpuDgYJvaF198oezs//u5qr0glt69eysuLs6puy4nzZs3N9XS09N19OhRL0xzdbL39Wvr1q1u9bxw4YJ27Njh0F1XCn9/f1O4mGEYmjZt2sXPT548qfnz55vOJiUllft8qLwIRAIAAAAAAAAAAAAAAAAAJ32/K0NFVsPpcz8RiAQAAAAAAAAAAIArRJMmTRQWFmaqr1ixosJnOXHihKnWpEkTl3oVFBQ4HdzjrOuuu06rV69Ww4YNTWvjx4/XU089Va73l6eIiAh9/vnnql69umntxx9/dKpXtWrVNGTIEJtaQUGBZs6cKem3AJoZM2aYzo0aNcqpey43bdq0UdWqVU31pUuXemGaq1Pbtm1NtR9++MGtnmvWrFFhYaFDd11JRo0aJR8f2/iZjz76SEVFRZKk6dOn68KFCzbrt9xyi2666aYKmxGVD4FIAAAAAAAAAAAAAAAAAOCkJTuOu3Rue3qOzl0o9vA0AAAAAAAAAAAAgOf5+Piod+/epvqXX35ZoXMUFxcrNzfXpubj46PAwECX+s2aNUsFBQWeGK1U9erV0+rVqxUfH29ae/311zVmzBgZhvN/hOVyEBYWpl69epnqx487/3PU0aNHm2rJycmSfnutnTx50matTp06du++kgQEBNgN0Xnvvfe8MM3VqV27dqbahg0btG/fPpd7/hHU9Wd169ZVTEyMyz0vB/Xr1ze9p44fP66vvvpKhmFo2rRppjNJSUkVNR4qKQKRAAAAAAAAAAAAAAAAAMAJeeeLtGrvybI32lFkNbT18CkPTwQAAAAAAAAAAACUj2HDhplqs2fP1p49eypsBl9fX4WEhNjUrFarTpw44XSvoqIivf32254arUy1a9fWDz/8oJYtW5rW3n33XQ0fPlzFxVfmH1SpUaOGqebKY2nevLkSEhJsart27dLq1asvBiP92ciRI+Xr6+v0PZebBx980FT76aef9O2331b8MFehXr16KSgoyFSfPHmyS/3S09M1Z84cU33AgAEu9bvclBRMtmLFCqWmptrUw8LCdO+991bUaKik/Lw9AAAAAAAAAAAAAAAAAABcSX7Ye1Lni6wXP6+ed1rDtn5T6pmPWyQqKzhckvTTwWy1u/a3Xw7OyMjQu+++W+rZRx55RNHR0W5ODQAAAAAAAAAAADivZ8+eio+P144dOy7WiouL9cADD2jFihUKDAyskDliYmK0d+9em9rixYv10EMPOdXnpZdeUkpKiidHK1P16tW1fPlyJSYmas2aNTZr06dPV15enmbNmqUqVapU6Fzu2r9/v6kWGxvrUq/Ro0dr/fr1NrVnn33W9Hz5+vpqxIgRLt1xuRk8eLCef/55HTlyxKY+fPhwbd++XZGRkV6a7OoQERGhoUOHmkK13n//ff3lL39R8+bNner3t7/9TXl5eTY1Hx8fjRkzxu1ZLwe9evVS/fr1dfDgwYu17777Tvn5+aa9Q4cOtRs2BXgSgUgAAAAAAAAAAAAAAAAA4IQlKcdtPo/Mz9HYNZ+Veuab62+9GIi08WD2xfrJkyc1ceLEUs8OGDCAQCQAAAAAAAAAAAB4hcVi0VtvvaUePXrY1Dds2KCBAwdq1qxZqlatmlt3LF++XD4+PurcuXOJezp06GAKRJo0aZIGDhyo4OBgh+6ZOXOmJk2a5M6oLgsLC9O3336rvn37atmyZTZrc+bMUX5+vubOnauqVauW+yxTpkxR9erVNWDAAPn6+rrUY/fu3VqyZImp3qpVK5f6DRw4UOPGjVNWVtbF2o8//mjal5iY6HLo0uWmSpUqevrpp02BOkePHtXtt9+uRYsWufRz4sLCQuXk5KhGjRqeGvWK9de//lUffPCBrNb/+4NHxcXF6tevn3788UfFxMQ41GfSpEmaO3euqd63b181aNDAY/N6k4+Pj5KSkvTMM89crBmGYfd9mJSUVJGjoZLy8fYAAAAAAAAAAAAAAAAAAHClOF9UrOW7M9zqseXQaRUWW8veCAAAAAAAAAAAAFwGbr/9dj388MOm+sKFC9WiRQstWrRIhmE41TM9PV1TpkxRs2bN1K1bN23btq3U/X379jXV9u3bpz59+tiE6Nhz7tw5vfDCC3rwwQdVXFwsSS4HAbkjODhYCxcuVJ8+fUxr33zzjRITE5WXl1fuc2zfvl2DBw9Ww4YN9corryg1NdWp81u3blXv3r1VWFhoU69bt646dOjg0kxVq1bVQw89VOa+qy2IZfTo0erdu7epvnnzZiUkJGjBggUO98rOzta///1vNWzY0BS6VVnFx8frqaeeMtXT0tLUuXNnbdiwodTzBQUFeuKJJ/Tcc8+Z1iIiIvTvf//bY7NeDoYPHy5/f/9S97Rt21Y33nhjBU2EyszP2wMAAAAAAAAAAAAAAAAAwJVi7b4s5Z4vcqvHucJi7Th6Rs3rhHtoKgAAAAAAAAAAAKB8/c///I/27t2r5cuX29QPHDigxMREXX/99brnnnvUvn17NWnSRBEREQoJCVFubq5ycnKUkZGh7du3a/v27Vq9erU2bdrk1P2JiYlq2bKltmzZYlNfvny5mjRpcjFYpnHjxgoODlZmZqbS0tL0zTffaObMmTpy5MjFM8HBwUpKStJbb73l+hPiooCAAH3xxRcaNmyYPv/8c5u15cuX67bbbtPixYsVFhZW7rMcOnRIzz//vJ5//nnddNNN6tSpk1q2bKlmzZopOjpaERERCggIUG5urg4fPqytW7dq3rx5WrBggaxW8x+AeeONN2SxWFyeJykpSf/6179KDNeqW7euevbs6XL/y5HFYtHMmTPVsmVLHT582GYtLS1Nd911l1q1aqW7775b3bp1U1xcnGrUqKGioiKdOnVK+/bt06ZNm7RixQp99913ppAqSBMnTtTSpUu1efNmm3pqaqratWun/v37a/DgwWrRooVq166tvLw8HT58WN98840+/PBDHThwwG7fqVOnKjY2tiIeQoWJjo5W//799dlnn5W4Z9SoURU4ESozApEAAAAAAAAAAAAAAAAAwEFLUo57pM/GtGwCkQAAAAAAAAAAAHDF8Pf314IFCzRw4EAtWrTItL5nzx698sor5Xa/xWLR+++/r44dO+rcuXM2aydPntRLL72kl156qcw+Pj4++uijj5SVlVVeo5bJz89Ps2bNUkhIiD744AObtXXr1qlLly5aunSpatSoUWEz/fLLL/rll19cPp+UlKSBAwe6NcO1116r2267TUuXLrW7PnLkSPn4+Lh1x+WoevXq+u6779StWzelp6eb1jdt2qRNmzbpueee88J0V74qVapo/vz56tixo9LS0mzWrFar5syZozlz5jjVc+LEiW6/3i9Xo0ePLjEQKTw8XPfee28FT4TK6ur7ag8AAAAAAAAAAAAAAAAA5aCo2Krvdp3wSK+fDmZ7pA8AAAAAAAAAAABQUYKDg7VgwQJNnDhRVapU8WhvR/q1atVKn3zyiQICAly6IyAgQDNmzNCAAQNcOu9JPj4+mjZtmsaOHWta27p1qzp27KijR496YTLnWCwWPf3005o6dapH+o0ePdpu3dfXVyNGjPDIHZej6667Ths3blTXrl29PcpVKS4uTmvWrFG7du3c6uPv76/33ntP48eP99Bkl58OHTooPj7e7trQoUMVGBhYwROhsiIQCQAAAAAAAAAAAAAAAAAcsPHgKWXnXfBIr00Hs2W1Gh7pBQAAAAAAAAAAAFQUX19fjR8/Xjt27NDgwYPdCkYKDw/XyJEjtWrVKo0ZM8ahM/369dOPP/6o66+/3qm7WrVqpbVr12ro0KGujFpuJk+erOeff95U37Vrlzp27KiDBw96/M77779fDzzwgKKjo93q065dO61fv16vvvqqhyaT7rzzTsXGxprqd9xxh2JiYjx2z+WoVq1aWrZsmWbMmKFrr73WpR4hISEaOXKk2rdv7+Hprny1a9fWqlWrNHnyZEVFRTl9vkePHtq2bZsefvjhcpju8lJSMFlSUlIFT4LKzGIY/FINcKWyWCxtJa39c23t2rVq27atlyYCAAAAAAAAAAAAAAC4ek1YsEPT1x401RudPKTvPiz9F7RvGz5FqVH1bGpL/9ZRhZmH1bRp01LPpqSklPgXGAEAAAAAAAAAqMwOHjyoc+fO2dQCAwNVv3597wwElIP09HSlp6eb6gkJCV6Yxuz48eP64osvtHTpUm3cuFHHjh2zu8/Pz08NGjRQkyZNlJCQoG7duunmm2+Wr6+vS/darVbNmTNHs2bN0qpVq5STk2PaU69ePXXt2lX33XefunfvbrO2Y8cOrVixwqbWtGlTde7c2aV5rkRWq1Xbtm3T2rVrtW7dOv3yyy9KS0tTXl6e3f3h4eG66aabdOutt+q+++4rl59hnjt3TjExMTp9+rRNfdGiRerVq5fH77tcWa1WLVu2TF988YVWrVqlvXv3ymq1mvYFBgaqUaNGSkhIUI8ePXT77bcrJCTECxNfWc6dO6e5c+dq3rx5WrNmjTIyMkx7/Pz8dOONN6p79+4aOnSobrrpJi9M6h3/+Mc/NH78eJtau3bttGbNGi9N9H8q8nu/devWqV27dpeW2xmGsc7jl8GEQCTgCkYgEgAAAAAAAAAAAAAAQMUwDEPtXluuYzkFpjVXA5Fe7ttULUJzCUQCAAAAAAAAAMBFBCIBl5+8vDz9+uuvys3NlWEYCgkJUWhoqKKiolSlSpVyudNqterEiRPKysrS+fPnFRISotjYWIJhXJSRkaHTp08rNzdXFotFoaGhCgsLU1RUVLnfPXPmTD3wwAM2tXr16unAgQPy8fEp9/svVxcuXFB6erpycnJUXFys4OBghYWFqVatWpX6efGU7OxsHTt2TPn5+fLz81N4eLjq1KkjPz8/b49W4axWq6655hodOnTIpj59+nTTe9MbCESqPCrfuw8AAAAAAAAAAAAAAAAAnPRLeo7dMCR3bDyYrRY3+nu0JwAAAAAAAAAAAOBNwcHBuu666yr0Th8fH9WuXVu1a9eu0HuvVtHR0YqOjvbK3cnJyabayJEjK33oj7+/v6655hpvj3HVioyMVGRkpLfHuCwsXbrUFIYUHh6ugQMHemkiVFaV+6s+AAAAAAAAAAAAAAAAADhgyY7jHu+5MS3b4z0BAAAAAAAAAAAA4Eq0fft2rVmzxqZWpUoVjRgxwksTAZXPe++9Z6o98MADCgwM9MI0qMwIRAIAAAAAAAAAAAAAAACAUhiGoSUpng9EOppToOM55zzeFwAAAAAAAAAAAACuNK+//rqp1q9fP9WuXdsL0wCVz65du7Rw4UKbmsVi0ZgxY7w0ESozApEAAAAAAAAAAAAAAAAAoBSpGblKy8wrl94pR3PKpS8AAAAAAAAAAAAAXCl+/vlnffbZZ6b6Y4895oVpgMrp2WefldVqtan16NFDjRo18tJEqMwIRAIAAAAAAAAAAAAAAACAUixJOV5uvbennym33gAAAAAAAAAAAABwucvKytKwYcNUXFxsU+/atavat2/vpamAyuXdd9/V/PnzTfXx48d7YRpA8vP2AAAAAAAAAAAAAAAAAABwOSsrEKlaoOu/hrX919MunwUAAAAAAAAAAACAK0VOTo527dolSbJarfr111/1888/a8qUKTp92vbnphaLRS+//LI3xgSuaikpKcrNzZUk5ebm6sCBA/rss8+0cuVK097ExES1bdu2gicEfkMgEgAAAAAAAAAAAAAAAACU4HBWvnYeO1PqnoRrqrvc/0j2OZfPAgAAAAAAAAAAAMCVYt26derVq5dDe0eNGkUQC1AOHnzwQW3evLnMfSEhIXrnnXcqYCLAPh9vDwAAAAAAAAAAAAAAAAAAl6tvdxwvc8+t19aogEkAAAAAAAAAAAAA4OrXsmVLvfnmm94eA6i0fHx8NG3aNNWvX9/bo6ASIxAJAAAAAAAAAAAAAAAAAEqwpIxApCB/X7WsG1FB0wAAAAAAAAAAAADA1atnz5769ttvFRIS4u1RgEopPDxcs2bN0qBBg7w9Cio5P28PAAAAAAAAAAAAAAAAAACXo4wzBdp86FSpe7o0jlZAFd8KmggAAAAAAAAAAAAArh4hISGKiYlR27ZtNXToUHXv3t3bIwGVSpUqVRQREaH4+Hj17NlTw4cPV40aNbw9FkAgEgAAAAAAAAAAAAAAAADY8+3OE2Xu6RlfS1LpoUkAAAAAAAAAAAAAUNn17NlThmF4ewygUtu0aZO3RwAc4uPtAQAAAAAAAAAAAAAAAADgcvRtyvFS1/19fdSlcXQFTQMAAAAAAAAAAAAAAABc/QhEAgAAAAAAAAAAAAAAAIBLnM6/oHUHskrd06FRDYUE+FXQRAAAAAAAAAAAAAAAAMDVj0AkAAAAAAAAAAAAAAAAALjE97syVGw1St3To2kth/s1qBHs7kgAAAAAAAAAAAAAAADAVY9AJAAAAAAAAAAAAAAAAAC4xJIdx0td9/WxqHuTmg73axpbzd2RAAAAAAAAAAAAAAAAgKsegUgAAAAAAAAAAAAAAAAA8Cd554u0au/JUvfc0iBSkcH+DvdsGhvm7lgAAAAAAAAAAAAAAADAVY9AJAAAAAAAAAAAAAAAAAD4kx/2ntT5Imupe3o2reVUzxsJRAIAAAAAAAAAAAAAAADKRCASAAAAAAAAAAAAAAAAAPzJkpTjZe65/QbnApGiQquqTmSgqyMBAAAAAAAAAAAAAAAAlQKBSAAAAAAAAAAAAAAAAADwu/NFxVq+ndsmWAAAIABJREFUO6PUPc3rhKtWWFWne7euH+nqWAAAAAAAAAAAAAAAAEClQCASAAAAAAAAAAAAAAAAAPxu7b4s5Z4vKnVPz6a1XOrdhkAkAAAAAAAAAAAAAAAAoFQEIgEAAAAAAAAAAAAAAADA75akHC9zT4941wKRWjcgEAkAAAAAAAAAAE+yWCymmtVq9cIkAAAAKG/2vs+z9/0grnwEIgEAAAAAAAAAAAAAAACApKJiq77bdaLUPY1rhapBjWCX+l9TI1g1QvxdOgsAAAAAAAAAAMx8fMz/VLq4uNgLkwAAAKC82fs+z9fX1wuToLz5eXsAAAAAAAAAAAAAAAAAALgc/JSWrey8C6Xu6RFfy1yMi5Nmzy69eVycLBaLWtWL1JIdxy+W/arVUI27nr74eVignybdfaPNXzCMi4tz7AEAAAAAAAAAAFDJ2PsH8EVFRSoqKpKfH/+MGgAA4Grxx/d4lyIQ6erEd/IAAAAAAAAAAAAAAAAAIOmrbUfL3NOzqZ1ApLAwacAAh+5o3cA2EMknIFjBjW+9+HmRpFu6dVa96sEO9QMAAAAAAAAAoDILCAiwWz979qwiIiIqeBoAAACUl9zcXLv1kr4fxJXNx9sDAAAAAAAAAAAAAAAAAIC3FRQWa9H2Y6XuqVc9SI1rhbp1T5v6kWXu+Skt2607AAAAAAAAAACoLKpVq2a3fubMmQqeBAAAAOWppO/vQkJCKngSVAQCkQAAAAAAAAAAAAAAAABUeit2Z+js+aJS9/S+sbYsFotb9zSpHaqQAL9S92w8SCASAAAAAAAAAACOqFKliqpWrWqq5+fn6+zZs16YCAAAAJ6Wk5OjvLw8Uz0gIED+/v5emAjljUAkAAAAAAAAAAAAAAAAAJXe/G2/lrnn7haxbt/j5+ujlvUiSt2z8eApt+8BAAAAAAAAAKCyqFatmt36r7/+SigSAADAFcwwDGVmZuro0aN210NCQip4IlQUApEAAAAAAAAAAAAAAAAAVGo5+YVasftkqXua1K6m62qGeuS+NvVLD0RKy8xTxtkCj9wFAAAAAAAAAMDVLjTU/v9/bxiG0tPTdejQIZ06dUpFRUUVPBkAAACcZbValZubq2PHjmnfvn06edL+73P4+PgoIqL037/AlcvP2wMAAAAAAAAAAAAAAAAAgDctSjmmC8XWUvf0bR7jsfta148sc8/GtFNKvKm2x+4EAAAAAAAAAOBq5e/vr4iICJ06dcruen5+/v9n796D9KzuO8F/T7eu6IpuIDUgMMIYBEjgC8YOsYkdY4MtSEKcTeLLhp3JZjdTqZmtSWUrtVvJxtmZ1FbN7uwkmdlc7BnbSbwZjzcgA2vHjmMb2RhsghACAxIgLmoJJC6SkBC69Nk/wBtbfvt5JfXbz9vq/nyqunCf8z3n+XY3f1GPf28OHDiQnTt3Ztq0aRkcHMzAwEDLLQEAaDIyMpKRkZEcOXIktdau+TPOOCPTp09voRn9YCASAAAAAAAAAAAwpd1y3/bG/VKSdT0ciLTm7IWZMTjQOITpu9teMBAJAAAAAACO0xlnnJEkow5F+oEjR47kyJEjbVQCAGCcLFiwIAsWLOh3DcaRgUj8/0opFye5JMmKJHOTHEyyK8n3k9xXaz3cx3oAAAAAAAAAANBzwy+9krufeKEx8/bzFmf5gtk9e+as6YO57KwF+d6To/+fMu7p0gkAAAAAAPhHpZTjHooEAMCpa9myZVm0aFFKKf2uwjgyEGmKK6WcneQ3kvxSXhuENJp9pZT1Sf5drfWeVsqNopTyn5J8vIVH/Uqt9T+18BwAAAAAAAAAAPpk/f3DXTM3Xt70Ws3Jeet5ixoHIn1/597sPXg482dN7/mzAQAAAABgMjIUCQBg8hocHMzQ0FDmzJnT7yq0YKDfBeiPUspAKeW3kzyS5F+meRhSksxL8stJ7i6lfKaUsmC8OwIAAAAAAAAAwHi75b7tjfszBgfy/kuW9/y5bzt3UeN+rcm9DQOTAAAAAACAH1dKyZlnnplVq1Zl2bJlmT17dr8rAQBwkgYHB7Nw4cKcddZZWbVqlWFIU8i0fhegfaWU2Uk+n+T6k7zio0neXkq5ttb6RO+aTThb+l0AAAAAAAAAAIDx8/DOvXl4577GzE+9aVkWzJ7e82e/+dzTU8prg49G890nXsg1Fy7r+bMBAAAAAGCymz59ehYvXpzFixfn8OHD2bt3b1599dWMjIzk6NGjqU3/gR4AgNaVUjIwMJDBwcFMnz49c+fOzaxZs1JK6Xc1+sBApCmmlDKY5AtJPjBK5HCSh5LsTjIvycVJ5nbIXZDka6WUd9Rad4xH1z57pNb6rX6XAAAAAAAAAABg/Nxy33DXzI2XD43Ls+fPmp6Lzpyfh3bsHTXz3W0vjMuzAQAAAABgKvnBcCQAAODUYCDS1PN76TwM6aUk/0uS/1hr3fODxVLK9CTrkvyrJG885sy5ST5XSnlPrfXo+NTt6BNJ/q8e3fW+vPZzH+tTPbofAAAAAAAAAIAJaGSkZv3G7Y2Z+bOm5Zo3Le1+2Z49yd/+bXPmfe9LFiz4kaW3nbcom7ftyCtP3NfxyIZHS/5ywdP54HXvz4JjzgIAAAAAAAAAwGRkINIUUkpZk+S3Omw9keS9tdbHj92otR5O8oVSypeSfCHJtcdE3pXk15L8cY/rjqrW+liSx3pxVynltzssH0nymV7cDwAAAAAAAADAxHTPthcyvOdgY+a6S5dn5rTB7pc980zy4Q83ZzZv/rGBSG89d1H+dO/u7L71D0Y99pG/STZv3mwgEgAAAAAAAAAAU8JAvwvQqn+T5Ng3tPYnua7TMKQfVmvdn+RnkzzYYfv3Silze1OxPaWUM5N8oMPWHbXWnW33AQAAAAAAAACgPbdu3N41c8PaoXHt8NbzTh/X+wEAAAAAAAAA4FRjINIUUUp5S5L3dNj6RK314eO5o9Z6IMk/7bC1KMmvjqFev3w8ybQO659quwgAAAAAAAAAAO159cjR3L5pR2Nm+YJZufK8RePaY9m8WRlaOGtcnwEAAAAAAAAAAKcSA5Gmjk4Di55P8ocnckmt9a4kX+6w1WlQ0kT3Kx3Wnk1ye9tFAAAAAAAAAABoz9cf2ZW9B480ZtatXZGBgTLuXS4ZWtA18+rho+PeAwAAAAAAAAAAJgIDkaaAUsq0JDd12PrLWuuBk7jyzzqsvamUcsVJ3NUXpZR3Jrmww9ana63Nb7sBAAAAAAAAAHBKu+W+7V0zN64daqFJsubshV0zD2zf00ITAAAAAAAAAADoPwORpoa3Jzm9w/oXTvK+25O80mH9Ayd5Xz/cPMr6p1ptAQAAAAAAAABAq/YePJy/e/i5xsyFZ8zLRcvnt9LninM6vdbzo+598sUWmgAAAAAAAAAAQP8ZiDQ1XNNh7UCSu07mslrrwSTf7rD1UydzX9tKKXOTfLjD1rdqrY+03QcAAAAAAAAAgPZ86YGdOXRkpDFz4+VDLbVJFs+d2TXzDwYiAQAAAAAAAAAwRRiINDW8tcPafbXWw2O4854Oa1eM4b42fTjJ3A7rn2y7CAAAAAAAAAAA7bpl4/aumXVrV7TQ5Pg9vnt/ntt3sN81AAAAAAAAAABg3BmINDVc1mFt8xjv3NRhbWEpZeUY723DzR3WXk7yn9suAgAAAAAAAABAe3buOZi7Hn++MfO28xZlaOHslhodv29t3d3vCgAAAAAAAAAAMO4MRJrkSikzkpzdYWvrGK9+bJT1N4zx3nFVSnljknd22PrrWuv+tvsAAAAAAAAAANCe9fdvT63NmRvXDrVT5gTducVAJAAAAAAAAAAAJr9p/S7AuDs7nQdfbR/jvaOdP3eM9463m0dZ/2SrLV5XSrlqjFdc0pMiAAAAAAAAAABTwC33DTfuTx8sue7SM1tqc2I2bNmdWmtKKf2uAgAAAAAAAAAA48ZApMlv6Sjrz47x3tHOj/a8viulDCb5WIet79da72q7z+u+3afnAgAAAAAAAABMKY8+uy8P7djbmLnmwmVZeNqMlhqdmOf2vZpHn305F545r99VAAAAAAAAAABg3Az0uwDjbtEo63vGcmmt9WiS/R22Fo/l3nF2XZLlHdY/1XYRAAAAAAAAAADadct927tmbrx8qIUmJ+/OLbv6XQEAAAAAAAAAAMaVgUiT39xR1l/uwd2dBiLN6cG94+XmDmtHkny27SIAAAAAAAAAALRnZKTm1o3DjZl5M6flp960rKVGJ+fOLbv7XQEAAAAAAAAAAMaVgUiT3/RR1o/04O7DHdZm9ODeniulLEtyfYet22qtz7bdBwAAAAAAAACA9tz71IvZ/tIrjZn3X3JmZk0fbKnRybn7iefz6pGj/a4BAAAAAAAAAADjZlq/CzDuRntLqxdvRnW6Y6L+O/WxdB4O9cm2ixzjHWM8f0mSP+1FEQAAAAAAAACAyeqW+7Z3zfzM5UMtNBmbg4dHcu+2F/OOVUv6XQUAAAAAAAAAAMbFRB1eQ+8cGWW9F3/7Tncc7sG94+FXOqztSPL/tl3kh9Va7xrL+VJKr6oAAAAAAAAAAExKh46M5PYHdjRmzpg/M1e+YXFLjcbmzq27DUQCAAAAAAAAAGDSGuh3Acbdq6Osz+jB3Z3uGO15fVNKeXuSiztsfbrWerTtPgAAAAAAAAAAtOcbj+7KSweaP+Nr3ZoVGRw4NT6YasOW3f2uAAAAAAAAAAAA48ZApMlv3yjr83pwd6c79vbg3l67eZT1T7XaAgAAAAAAAACA1t2ycXvXzA1rh1po0hubh/fkhf2H+l0DAAAAAAAAAADGhYFIk9/zo6wvHMulpZRZSWaewPP6opRyWpJf6LB1Z611S9t9AAAAAAAAAABoz76Dh/PVh55tzKxaNjerV8xvqdHY1Zp8a+vuftcAAAAAAAAAAIBxYSDS5LdzlPUzx3jvaOdHe16//HySTm+sfbLtIgAAAAAAAAAAtOtLm3fm1SMjjZmfuXwopZSWGvXGhi0GIgEAAAAAAAAAMDkZiDT5DSd5tcP6OWO8d7TzT4zx3l67ucPa3iSfb7sIAAAAAAAAAADtunXjcNfMujUrWmjSW3du2ZVaa79rAAAAAAAAAABAzxmINMnV1958eqzD1hvHePUFo6xvHeO9PVNKOT/J1R22/rrWeqDtPgAAAAAAAAAAtOe5vQfz7cd2N2besvL0nL3otJYa9c7wnoN5fPf+ftcAAAAAAAAAAICeMxBparivw9qaMd55eYe1Z2qtzW+RtevmJKXD+ifbLgIAAAAAAAAAQLvW3z+ckdqcueHyoXbKjIM7H93V7woAAAAAAAAAANBzBiJNDXd3WLu4lLJgDHdedZzP6YtSymCSj3fYerDWOmF6AgAAAAAAAAAwPm7ZuL1xf9pAyQcvXd5Sm97bsHUifW4ZAAAAAAAAAAD0hoFIU8NXO6wNJnnvyVxWSlmW5PLjfE6/XJuk00f4fartIgAAAAAAAAAAtGvrcy9n8/a9jZl3X7g0p8+Z0VKj3rvrsedz+OhIv2sAAAAAAAAAAEBPGYg0BdRav5/ksQ5bv3CSV344STn2MUluO8n7xsPNHdYOJ/ls20UAAAAAAAAAAGjXrRu3d83csLbTZ22dOvYfOpr7nnqp3zUAAAAAAAAAAKCnDESaOv6iw9qNpZSzT+SSUkpJ8usdtr5ea33mpJr1WCllSZIPddj6Yq11V9t9AAAAAAAAAABoT601t24cbszMmTGY9150RkuNxs+GLV6FAQAAAAAAAABgcjEQaer40ySHjlmbnuT3T/CeX0nypg7rf3S8F5RStpVS6jFf206wR5OPJJnRYf2TPXwGAAAAAAAAAAAT0P3P7MlTLxxozFx7yZmZPWOwpUbj55tbdve7AgAAAAAAAAAA9JSBSFNErXU4yac6bH2slPLzx3NHKeWNSf73Dlubk9wyhnq9dnOHte1Jvtx2EQAAAAAAAAAA2rV+43DXzI1rh1poMv42PfNS9hw43O8aAAAAAAAAAADQM9P6XYBW/c9JPpxk0THrny2lTKu1fm60g6WUy5OsT7Kgw/Zv1FpHelfz5JVS3prk0g5bn661Hm27DwAAAAAAAAAA7Tk6UnPbpuaBSEvmzsg7zl/c2wcvXZr8zu90z3RcXprfGeXs1udezm2bhjN4WqdXdpKRmtz1+O68/5LlJ1QXAAAAAAAAAAAmKgORppBa6+5Syn+T5G+O2ZqZ5K9KKR9N8idJvpNkd5J5SdYk+eUk/3WS6R2u/T9qrX8/bqVP3M0d1mqST7VdBAAAAAAAAACAdt39xPN5bt+rjZnrL12eaYMDvX3wsmXJ7/7uSR5dlt8d5eyeVw7nrk98JUdH6qjnv7nFQCQAAAAAAAAAACYPA5GmmFrrLaWU307yrzpsf+D1r+N1W5Lf6kmxHiilzE7yix22vlFrfaztPgAAAAAAAAAAtOuL9w93zaxbu6KFJr2xYPb0rDlrQf7hqZdGzWzYsrvFRgAAAAAAAAAAML56/FFnnApqrf86yb9IcnQM1/xFkptqrYd706onfi7Jgg7rn2q7CAAAAAAAAAAA7Tp0ZCR3PLCzMTO0cHauOOf0lhr1xtUXLG3cf+qFA3ny+f0ttQEAAAAAAAAAgPFlINIUVWv9t0nemeTeEzy6I8lHa60frbW+2vtmY3Jzh7U9Sf5L20UAAAAAAAAAAGjXhq27sueV5s/2+tCaFSmltNSoN66+YEnXzJ1bdrfQBAAAAAAAAAAAxt+0fhegf2qtdyd5SynlvUk+kuS9SYY6RF9KcmdeGyz012MdhFRrPXcs5xv8j/nxIV97aq2vjNPzAAAAAAAAAACYINZvHO6aWbdmRQtNemvN2Qszd+a0vPzqkVEzG7bszkfevrLFVgAAAAAAAAAAMD4MRCK11q8m+WqSlFIWJlmRZE6Sg0l211p39LHecau13tPvDgAAAAAAAAAAtO+VQ0fztw8925g5f+mcXLR8XkuNemf64ECuOn9xvtLw833rsd05cnQk0waP/SwxAAAAAAAAAAA4tXgDhh9Ra32p1vpQrfW7tdYHTpVhSAAAAAAAAAAATF1/9/CzOXDoaGNm3ZqhlFJaatRbV1+wpHF/38Ej2bR9T0ttAAAAAAAAAABg/BiIBAAAAAAAAAAAnNLWbxzumlm3dkULTcbH1Rcs7ZrZsGV3C00AAAAAAAAAAGB8GYgEAAAAAAAAAACcsva8cjhff2RXY+bSoQU5b8mclhr13rmLT8vQwtmNmTu3NP8OAAAAAAAAAADgVGAgEgAAAAAAAAAAcMr68oM7c+joSGNm3ZoVLbUZH6WUXH3BksbMfU+9lH0HD7fUCAAAAAAAAAAAxoeBSAAAAAAAAAAAwCnri/cPN+6XknxwzfKW2oyfqy9Y2rh/ZKTmO4+/0FIbAAAAAAAAAAAYHwYiAQAAAAAAAAAAp6Rd+17Nt7bubsy89dxFWb5gdkuNxs87zl+cUpozG7bsaqcMAAAAAAAAAACMk2n9LgAAAAAAAAAAAHAy7nhgR0Zqc2bdmhXjX+TgweSxx5oz55+fzJrV4ejBPNbl7Pnnn5/T58zKZUMLcv8ze0bN3dllOBQAAAAAAAAAAEx0BiIBAAAAAAAAAACnpPX3DzfuTxsoue7S5eNf5LHHkksuac5s3pysXt3h6GO5pMvZzZs3Z/Xq1fmJC5Y0DkR6fNf+bH/plQwtnH1ctQEAAAAAAAAAYKIZ6HcBAAAAAAAAAACAE/XMiwdy75MvNmZ+4oIlWTRnRkuNxt9PrFraNbNhy64WmgAAAAAAAAAAwPgwEAkAAAAAAAAAADjlfPH+HV0z69asaKFJe65YuTCnzRhszHxzy+6W2gAAAAAAAAAAQO8ZiAQAAAAAAAAAAJxy1t8/3Lg/c9pA3rf6zJbatGPmtMFced6ixsy3t+7OyEhtqREAAAAAAAAAAPSWgUgAAAAAAAAAAMApZetz+/L9HXsbM++5aFnmzpzWUqP2XH3B0sb9Fw8czoPDzb8bAAAAAAAAAACYqAxEAgAAAAAAAAAATinrNw53zaxbs6KFJu27+oIlXTPf3LKrhSYAAAAAAAAAANB7BiIBAAAAAAAAAACnjFpr1t/fPBBp3sxpefeFy1pq1K5Vy+bmjPkzGzMbtuxuqQ0AAAAAAAAAAPSWgUgAAAAAAAAAAMAp44Hte7Lt+QONmfetPjOzpg+21KhdpZRcfcHSxsy9T76YA4eOtNQIAAAAAAAAAAB6x0AkAAAAAAAAAADglLF+43DXzLq1K1po0j9XX7Ckcf/Q0ZHc/cQLLbUBAAAAAAAAAIDeMRAJAAAAAAAAAAA4JYyM1Ny2aUdjZvGcGXnn+YtbatQf71zVPBApSTZs2d1CEwAAAAAAAAAA6C0DkQAAAAAAAAAAgFPCd7e9kJ17DzZmrrt0eaYNTu7XopbMnZmLl89vzNy5ZVdLbQAAAAAAAAAAoHcm95s/AAAAAAAAAADApLH+/uGumXVrV7TQpP+uvmBJ4/6jz76cB4f3tNQGAAAAAAAAAAB6w0AkAAAAAAAAAABgwjt8dCR3PLCjMbNiway8+ZzTW2rUX1dfsLRr5rN3PdlCEwAAAAAAAAAA6B0DkQAAAAAAAAAAgAlvw9bdefHA4cbMh9asyMBAaalRf73l3NMzZ8ZgY+aWjdvz0oFDLTUCAAAAAAAAAICxMxAJAAAAAAAAAACY8L64cbhr5kNrVrTQZGKYNX0wN1w+1Jg5eHgkn//eMy01AgAAAAAAAACAsTMQCQAAAAAAAAAAmNAOHj6aLz+4szHzhiVzsnrF/JYaTQwfu2pl18xnv/NkRkZqC20AAAAAAAAAAGDsDEQCAAAAAAAAAAAmtK89/Fz2HzramPnQmhUppbTUaGJ405nz87bzFjVmnnrhQL7x6K6WGgEAAAAAAAAAwNgYiAQAAAAAAAAAAExo6zcOd82sW7uihSYTz8evOrdr5tN3bRvvGgAAAAAAAAAA0BMGIgEAAAAAAAAAABPW3oOH87VHnmvMrF4xP+cvndtSo4nlfavPyBnzZzZmvv7Irmzbvb+lRgAAAAAAAAAAcPIMRAIAAAAAAAAAACasv33w2Rw6MtKYWbdmRUttJp7pgwP55StXds199jtPttAGAAAAAAAAAADGxkAkAAAAAAAAAABgwlp//3DXzAen8ECkJPmv3nZ2pg+Wxsznv/d0Dhw60lIjAAAAAAAAAAA4OQYiAQAAAAAAAAAAE9LzL7+ab23d3Zh567mnZ2jh7JYaTUzL5s3KBy5Z3pjZe/BIbt3YfbgUAAAAAAAAAAD0k4FIAAAAAAAAAADAhHTHAztydKQ2ZtatWdFSm4nt4+9Y2TXz6W9vS63Nv08AAAAAAAAAAOgnA5EAAAAAAAAAAIAJaf39w437gwMl1126vKU2E9sV55ye1SvmN2Ye3rkv3932YkuNAAAAAAAAAADgxBmIBAAAAAAAAAAATDjbX3ql6/Ced65aksVzZ7bUaGIrpeRjV63smvvMXdvGvQsAAAAAAAAAAJwsA5EAAAAAAAAAAIAJZ/3G4a6ZdWtWtNDk1LFuzVAWzJ7emPnS5p15du/BlhoBAAAAAAAAAMCJMRAJAAAAAAAAAACYcG7duL1xf8a0gVy7+oyW2pwaZs8YzC+89ezGzJGRmr+6+6mWGgEAAAAAAAAAwIkxEAkAAAAAAAAAAJhQHt65Nw/v3NeYec+blmXerOktNTp1fOTKlSmlOfNX9zyVQ0dG2ikEAAAAAAAAAAAnwEAkAAAAAAAAAABgQrnlvuGumRvWDrXQ5NRzzuLTcs2Fyxozu/a9mi8/uLOlRgAAAAAAAAAAcPwMRAIAAAAAAAAAACaMkZGa9Ru3N2bmz5qWa960tKVGp56PXbWya+Yzd20b9x4AAAAAAAAAAHCipvW7AAAAAAAAAAAAwA98d9sLGd5zsDFz3aXLM3PaYEuNjsP8+clNN3XPdFyen5u6nJ0/ytnR/OQFS3Pu4tOy7fkDo2a+u+3FPDi8J6tXLDihuwEAAAAAAAAAYDwZiAQAAAAAAAAAAEwYt2wc7pq5Ye1QC01OwNlnJ5///EkePTufP8mzoxkYKPnoVefmE7c91Jj77F1P5g9+7rKePhsAAAAAAAAAAMZioN8FAAAAAAAAAAAAkuTQkZHc8cCOxszyBbNy5XmLWmp06rrpzWdl9vTBxswtG7dnz4HDLTUCAAAAAAAAAIDuDEQCAAAAAAAAAAAmhK8/8lz2vNI8oGfdmhUZGCgtNTp1LZg9PTdePtSYOXh4JJ+/9+mWGgEAAAAAAAAAQHcGIgEAAAAAAAAAABPCrRuHu2ZuWNs85Id/9LGrVnbNfOauJzMyUltoAwAAAAAAAAAA3RmIBAAAAAAAAAAA9N2+g4fz1e8/25h54xlzc9HyeS01OvVdtHx+3nbeosbMUy8cyDce3dVSIwAAAAAAAAAAaGYgEgAAAAAAAAAA0Hdf2rwzrx4ZaczcsHYopZSWGk0OH7tqZdfMZ+7aNu49AAAAAAAAAADgeBiIBAAAAAAAAAAA9N36+4e7Zm5Yu6KFJpPLtavPzLJ5MxszX390V7bt3t9SIwAAAAAAAAAAGJ2BSAAAAAAAAAAAQF89t+9gvrV1d2PmreeenrNOP62lRpPH9MGB/PKVKxsztSZ/8Z0nW2oEAAAAAAAAAACjMxAJAAAAAAAAAADoqy/evyMjtTlzw9qhdspMQr945dmZPlgaM//5e0/nlUNHW2oEAAAAAAAAAACdGYgEAAAAAAAAAAD01a0btzfuTxsoue7S5S21mXyWzZuV91/S/Pvbe/BI178DAAAAAAAAAACMNwORAAAAAAAAAACAvnl818vZ9Myexsy73rg0i+bMaKnR5PTxq1Z2zXz6ridTa22hDQAAAAAAAAAAdGYgEgAAAAAAAAAA0De3bBzumrnh8qEWmkxub155ei5ePr8x8/0de/O9J19sqREAAADGa8lpAAAgAElEQVQAAAAAAPw4A5EAAAAAAAAAAIC+qLXm1o3bGzNzZgzmpy86o6VGk1cpJR9/x8quuU9/e9v4lwEAAAAAAAAAgFEYiAQAAAAAAAAAAPTFxqdfypPPH2jMXLv6zMyeMdhSo5P04INJKc1fDz44ytEHU0pp/HpwlLMnat2aoSyYPb0x86XNO/Pc3oM9eR4AAAAAAAAAAJwoA5EAAAAAAAAAAIC+uHXjcNfMDZcPtdBkapg9YzAffstZjZkjIzX/z33bW2oEAAAAAAAAAAA/ykAkAAAAAAAAAACgdUeOjuS2Tc0DkZbMnZF3nr+4pUZTw0fevjKlNGdu37SjnTIAAAAAAAAAAHAMA5EAAAAAAAAAAIDWbdi6O7tfPtSY+eBlKzJt0CtOvbRy8Zxcc+GyxswD2/fkyef3t9QIAAAAAAAAAAD+kbeFAAAAAAAAAACA1t26cbhr5sbLh1poMvX8/JvP6pq5/YEdLTQBAAAAAAAAAIAfZSASAAAAAAAAAADQqgOHjuTLD+5szJy7+LSsOWtBS42mlndfuCynzRhszNy+yUAkAAAAAAAAAADaZyASAAAAAAAAAADQqq889GwOHDramLlh7VBKKS01mlpmzxjMey46ozHz4PDePLF7f0uNAAAAAAAAAADgNQYiAQAAAAAAAAAArbp143DXzI2XD7XQZOq6/tLlXTO3b+r+dwIAAAAAAAAAgF4yEAkAAAAAAAAAAGjNC/sP5ZuP7mrMrDlrQc5bMqelRlPTuy9cmjkzBhszt23a0VIbAAAAAAAAAAB4jYFIAAAAAAAAAABAa27fNJwjI7Uxc8PaoZbaTF2zpg/mpy8+ozHz8M592frcyy01AgAAAAAAAAAAA5EAAAAAAAAAAIAW3bJxuHF/oCQfXLO8pTZT2/WXreiauX3TjhaaAAAAAAAAAADAawxEAgAAAAAAAAAAWvH0Cwdy75MvNmbeuWpJls2b1VKjqe0n37gk82ZOa8zc/kDzACsAAAAAAAAAAOglA5EAAAAAAAAAAIBW3Lpxe9fMjWuHWmhCksycNpifXn1GY+bRZ1/Oo8/ua6kRAAAAAAAAAABTnYFIAAAAAAAAAADAuKu15paNw42ZWdMHcu0lZ7bUiCT54GXLu2Zu27SjhSYAAAAAAAAAAGAgEgAAAAAAAAAA0IKHduzN1udebsy896IzMnfmtJYakSQ/sWpp5s9q/p3fvmk4tdaWGgEAAAAAAAAAMJUZiAQAAAAAAAAAAIy7WzcOd83cuHaohSb8sBnTBnLt6jMbM4/t2p9Hnt3XUiMAAAAAAAAAAKYyA5EAAAAAAAAAAIBxdXSkZn2XgUgLT5uen3zj0pYa8cOuv2x518ztm3a00AQAAAAAAAAAgKnOQCQAAAAAAAAAAGBc3f3E89m592Bj5vpLl2fGNK8z9cM7Vy3JgtnTGzO3bdqRWmtLjQAAAAAAAAAAmKq8QQQAAAAAAAAAAIyrW+8b7pq58fKhFprQyfTBgbx/9ZmNmSd2789DO/a21AgAAAAAAAAAgKnKQCQAAAAAAAAAAGDcHDx8NHds3tGYGVo4O28+5/SWGtHJB9cs75q5fVPz3xEAAAAAAAAAAMZqWr8LMHGUUi5OckmSFUnmJjmYZFeS7ye5r9Z6uI/1TlopZV6Sy5JckGRRktPy2s+2L8nTSR5LsqXWOtK3kgAAAAAAAAAAk9TXHn4u+w4eaczcsHZFBgZKS43o5Ko3LM7pp03PiwdGf0Xotk078pvXXphS/K0AAAAAAAAAABgfBiJNcaWUs5P8RpJfymuDkEazr5SyPsm/q7Xe00q5MSilLEjyy3nt57oy3f9df7mU8r0kf5fkjrw2AKqOb0sAAAAAAAAAgMmt1po/+ebjXXM3Xj7UQhuaTBscyPsvWZ7P3fPUqJmnXjiQzdv35tKzFrTYDAAAAAAAAACAqWSg3wV6pZRyfSnloWO+fq3fvSaqUspAKeW3kzyS5F+meRhSkszLawOG7i6lfOb1gUMTTilleinlt5JsS/LHSd6Z4xv8NTfJu5N8Ism9SVaOU0UAAAAAAAAAgCljw9bduf/plxozFy2fnzeeMa+lRjT50GXLu2Zue2C4hSYAAAAAAAAAAExVk2YgUpJVSd6U5MIf+uff9rXRBFVKmZ1kfZL/Ncnsk7jio0m+W0o5r6fFxqiUsirJd5L8QZKFfa4DAAAAAAAAADDl/eHXtnbN/Mzl3T7Hi7a87bxFWTJ3RmPm9k07UmttqREAAAAAAAAAAFPNZBqINPeY73fUWh/vS5MJrJQymOQLSa4fJXI4yf1J/i7JPUleHiV3QZKvlVK6fyxcC0opVya5K8kVDbFdSTYn+fvXs99P8ur4twMAAAAAAAAAmHrufvz53PPEC42ZOTMG8/NvPrulRnQzbXAg77/kzMbMMy++kvuf2dNSIwAAAAAAAAAApprJNBDphwfb1CTP9KvIBPd7ST7QYf2lJP8iydJa69pa63trrVcmWZTkpiSPdjhzbpLPvT5kqW9KKZcm+VKSJR22H8xrP9cbaq3Laq2X1lp/qtb6jlrrxXltkNZlSf55kq8mOdJWbwAAAAAAAACAyeyP/n5r18xHrlqZ0+fMaKENx+v6S1d0zdy+abiFJgAAAAAAAAAATEWTaSDSS8d8f6AvLSawUsqaJL/VYeuJJG+utf7bWuuPfHxbrfVwrfULSa5I8uUOZ9+V5Nd6XvY4lVJOT3JbkoXHbO3Pa0OO1r7+cz3R6Xyt9Uit9YFa6/9Za/3pvDbk6feSvDKOtQEAAAAAAAAAJrWNT7+UO7fsbszMnDaQf/ITb2ipEcfrbectytJ5Mxszt2/akVprS40AAAAAAAAAAJhKJtNApB/+SLmSZFm/ikxg/ybJ4DFr+5NcV2t9vOlgrXV/kp9N8mCH7d8rpcztTcUT9idJzjlm7eUk7399yNGRE7ms1rq91vo7tdZne9YQAAAAAAAAAGCK+aOvbe2a+cW3ndN18A7tGxwoue6SMxszw3sO5r6nj/38OgAAAAAAAAAAGLvJNBDpH5Ic/aHvzy2lzOhXmYmmlPKWJO/psPWJWuvDx3NHrfVAkn/aYWtRkl8dQ72TUkp5X5KfP2a5Jrmh1rqh7T4AAAAAAAAAACQPDe/NV7/f/FlU0wdL/tt3vaGlRpyo6y9b0TVz2/07WmgCAAAAAAAAAMBUM2kGItVa9ybZkKS8vjQ7ybv612jC6TSw6Pkkf3gil9Ra70ry5Q5bnQYljbf/rcPap2qtX2u9CQAAAAAAAAAASZI//vrWrpmb3nx2li+Y3UIbTsZbVp6eM+bPbMzc8cCOjIzUlhoBAAAAAAAAADBVTOt3gR77k7w2BOkHb9r8ZpKv9K/OxFBKmZbkpg5bf1lrPXASV/5ZkmuPWXtTKeWKWus/nMR9J6yUcm2SNccsH0jyW208HwAAAAAAAACAH7f1uZdzxwM7GjODAyX/3bvOb6lRS2bOTC6+uHum4/LMXNzl7MxRzo6XgYGS6y5dnv/4rW2jZnbuPZh/eOrFvOXcRe0VAwAAAAAAAABg0ptsA5H+Osn/kOTNSUqS95RSPlJr/Yv+1uq7tyc5vcP6F07yvtuTvJLk2I/p+0CSVgYiJfnVDmu31Fqfb+n5AAAAAAAAAAAc499/fWtqbc7csHZFzll8WjuF2rJqVfLggyd5dFUePMmz4+mDlzUPREqS2zbtMBAJAAAAAAAAAICeGuh3gV6qtdYkH02yJ0nNa0ORPllKuamvxfrvmg5rB5LcdTKX1VoPJvl2h62fOpn7TlQpZV6S6zps/WUbzwcAAAAAAAAA4Mc99fyB3LpxuDFTSvLfv3tVS40Yi8vPPj3LF8xqzNzxwI4cHekyAQsAAAAAAAAAAE7ApBqIlCS11kfy2rCcl15fmp7kr0spny2lnN+/Zn311g5r99VaD4/hzns6rF0xhvtOxDVJjn3b6miSr7X0fAAAAAAAAAAAjvEfvvFY1+E4112yPKuWzW2pEWMxMFBy/aXLGzPP7Xs139v2QkuNAAAAAAAAAACYCqb1u0AvlVKWvf4/H09yfZI/S7I6SUnyS0l+qZTyzSR/n+TeJM8k2ZPkwFieW2t9biznW3BZh7XNY7xzU4e1haWUlbXWJ8d4dzfv7rD2aK31YKdwKWVmkpVJ5iXZl2RXkpdqrT6eDgAAAAAAAACgB3bseSX/5d6nu+Z+/ZpVLbShV66/bHn+fMMTjZnbH9iRK9+wuKVGAAAAAAAAAABMdpNqIFKSnUmOHXLzg+/L6//8yde/eqVmAv8eSykzkpzdYWvrGK9+bJT1NyQZ74FIV3RYu/+HvymlLEnyT5L8XJLLkwwek3+llLIhyVeS/N+11u5v5AEAAAAAAAAA0NGffOPxHD7a/NlU771oWS5eMb+lRvTC2rMXZmjh7Gx/6ZVRM3c8sDO/86HVGRwoo2YAAAAAAAAAAOB4TdhBPmMw2ps1xw5GmirOTjLQYX37GO8d7fy5Y7z3eKzusLYtSUopg0l+M8n/lGROwx2zk/z061+/X0r50yS/X2t9trdVm5VSrhrjFZf0pAgAAAAAAAAAwEnate/VfO6ep7rmfv2aVS20oZdKKbn+suX5028+Pmpm98uv5u4nns87zl/SYjMAAAAAAAAAACaryTgQqfmj5rrvn4hTYbjS0lHWxzr4Z7Tzoz2vJ0ops5N0entqXyllXpK/SfKeE7x2RpJ/luRnSyk31lq/O8aaJ+LbLT4LAAAAAAAAAKDn/nzD43n1yEhj5uoLluTyc05vqRG99MEuA5GS5PZNOwxEAgAAAAAAAACgJwb6XYBxt2iU9T1jubTWejTJ/g5bi8dy73FYPsr6oSR35MSHIf2wFUm+UUp53xjuAAAAAAAAAACYMl46cCh/cdeTXXP/7JpVLbRhPFw6tCBnL5rdmPnS5p05crR5KBYAAAAAAAAAAByPaf0u0GPPJan9LjHBzB1l/eUe3L0/yZxj1o79vtdG+6jAf55k6Ji1h5P8eZKvJHk6yStJliV5S5KbkvxCfnwo2OwknyulXFFr7f62HgAAAAAAwP/H3p1H21nWZ+O/7pOZAIEQhjCEEEgAmZFBEHCAioivWCtVa1ulDm9r+5YOih1+fZda21raaltbB8S2igOtYJ1aHFARkFGkIgJqEsjEGEIYQubcvz+SmHjeffY+yTnnOefs8/mstRd738913891lvG/Z30fAIAx7F+/+0BWrdvYNnPK7Ok5dc5Qv2OLoVJKyfnH7J+PfGdBn5nHV63LLQtX5Iy5MxpsBgAAAAAAAABAN+qqgUi11v2Gu8MINKGP9Q2DcPb6FmsTB+Hcdib1sb79MKSa5M+S/HWttfffuXjL5/OllL9NcnWS2b0y05N8JsnzB9wWAAAAAAAAAKBLPb1mff71u/d3zP3Oiw9roA1D6eXHzmw7EClJ/uuHDxqIBAAAAAAAAADAgHXVQCRaGtfHevtX8/VPqzOG+t9Uf87/rVrrRzuFaq3fL6WckeS7SQ7udfn0UspLaq1f35mSO+D0Ae4/Osllg1EEAAAAAAAAAGBHXHHLojy1pv07uY47cFrONCRn1Dtq/90ze69d8sDjz/aZ+erdD+c9FxydCeN6GmwGAAAAAAAAAEC3MRCp+/X11Nlg/G/f6oz1g3BuO53O/1x/hiFtVWtdVkp5Q5JvJym9Lv9RkiEdiFRrvXkg+0vpXRkAAAAAAAAAYOg9u25DLr/h/o6533nxXM83dIFSSs4/dmb++dsL+sw88ez63Lzg8Zw1b+8GmwEAAAAAAAAA0G28jqv7re1jfeIgnN3qjL7uN1jWtblWk/zpjh5Ya/1Okq+2uPSCUsoeO3oeAAAAAAAAAEC3++xtS7JiVbvHOJIj9tstZx+xT0ONGGrnH7N/x8yXf/BgA00AAAAAAAAAAOhm44e7AEPu6T7WdxuEs1ud8dQgnNvOyjbXrqu1/nQnz70syXm91nqSnJnkyzt5JgAAAAAAAABA11mzfmMuu35Bx9zvvPiw9PSUBhqNAPPnJxdc0D7zxS8mhx3WYuv8XNBh7xe/+MUc1mJvk46cuVvm7D01Cx9b1Wfmy3c9mD9+2ZGZPnUw3tUGAAAAAAAAAMBYZCBS93u8j/U9BnJoKWVykkk7cL/BsrzNtesHcG5fe58XA5EAAAAAAAAAAH7mqjuW5pGn1rbNzNl7as47emZDjUaAtWuTe+7pnGm5vDb3dNi7to+9TSql5OXHzMw/fmt+n5k16zflU7csyu+ePbfBZgAAAAAAAAAAdJOe4S7AkHu4j/X9BnhuX/v7ut+gqLU+maSv18z9zwDOXZFkSYtL++zsmQAAAAAAAAAA3Wb9xk358HULOuZ++4WHZVxPaaARTXr5cft3zHzipgeyZv3GBtoAAAAAAAAAANCNDETqfg8mafWKuFkDPLev/fcP8Nz+WNjH+ooBnvt4i7W9BngmAAAAAAAAAEDX+MKdy7Js5eq2mYOmT8krju88OIfRZ96+u+WU2dPbZh5ftS6f//6yhhoBAAAAAAAAANBtDETqcrXWmqTVa/nmDfDouX2szx/guf1xbx/rzw7w3FUt1nYd4JkAAAAAAAAAAF1h46aaD13X6jGUn/dbLzgsE8Z5LKlbvfWsOR0zl9+wMJs21QbaAAAAAAAAAADQbTx5NDbc2WLtuAGeeUKLtaW11uUDPLc/vtfH+u4DPHdai7UVAzwTAAAAAAAAAKAr/NcPH8r9y1u9b2qb/XafnF967gENNWI4vPiIfXLo3lPbZhYuX5Vr732koUYAAAAAAAAAAHQTA5HGhltbrD2nlNJqAFB/ndbP+wyF7/axvs8Az221v4kBTwAAAAAAAAAAI1qtNR++bkHH3P9+wZxMGj+ugUYMl56ekrecOadj7rLrFzbQBgAAAAAAAACAbmMg0thwbYu1cUnO2ZnDSin7JDmhn/cZCrcmWdli/aSdPbCUMiutByI9sLNnAgAAAAAAAAB0i/9ZsjL3PvRU28yMXSfmtSfPaqgRw+mVJxyQGbtOapv53qIncseiJxpqBAAAAAAAAABAtzAQaQyotd6bpNUr+l6zk0f+cpLS+zZJvrKT5+2QWuvGJF9oceklAzi2r73fHsCZAAAAAAAAAABd4bO3Le6YefOZczJl4rgG2jDcJk8YlzeefnDH3MeuX9hAGwAAAAAAAAAAuomBSGPHp1qsvbKUctCOHFJKKUl+u8Wl62qtS3eq2c75lxZrx5RSztjJ897WYm1Fkjt38jwAAAAAAAAAgK7w9Jr1+fIPHmqb2X3y+Pzq8zoPyKF7vP7UgzNlQvsBWF+75+E8sHxVQ40AAAAAAAAAAOgGBiKNHZclWddrbUKS9+7gORclOaLF+j/194BSygOllNrr88COlKi13pDkthaXPlBKGb8jZ5VS3pzkhBaX/qXWumlHzgIAAAAAAAAA6DZf/J8Hs3r9xraZX3rugdl10g49ssEot+fUiXnNye3fxVZrcvmNCxtqBAAAAAAAAABANzAQaYyotT6Y5F9aXPr1UsqF/TmjlDIvyftbXLo7yRcGUG9n/WmLtZOS/HMppfTngFLK85N8oMWlZ5NcOoBuAAAAAAAAAACjXq01n7l1ccfc606Z1UAbRpo3nXFIejo8pfO57y3N48+sbaYQAAAAAAAAAACjnoFIY8ufJVnRYv2KUsrr2m0spZyQ5JtJprW4/Lu11k2D0G+H1FqvTfLpFpfemuTzpZQD+9pbSukppfzvJF9PsmuLyLtrrY8NTlMAAAAAAAAAgNHph8uezD0PPdU2c9LBe2bevrs11IiR5KDpu+S8Y2a2zazdsClX3LKooUYAAAAAAAAAAIx2BiKNIbXW5Une1OLSpCSfKaX8dynlglLKvqWUcaWUPUopLyilXJbk1iStBgx9oNb67aHs3cFvJbmvxfork/yklPIfpZQ3l1LO3fK3vLqU8r4tez6SZJcWez9Xa710CDsDAAAAAAAAAIwKn71tScfMa0+Z1UATRqq3njmnY+aTNy/KmvUbG2gDAAAAAAAAAMBoN364C9CsWusXSil/kuQvW1w+b8unv76S5J2DUmwn1VqfLqWcm+TbSXo/XTUlyYVbPv311SQXDVI9AAAAAAAAAIBR65m1G/Kl/1nWNrPb5PE5/5iZDTViJDruoD1y6iHTc+v9K/rMrFi1LlfdsTS/+ryDG2wGAAAAAAAAAMBo1DPcBWherfWvkvx+koG8du1TSV5da10/OK12Xq11cZLTknxrIMck+dsk59daVw1KMQAAAAAAAACAUezLP3gwq9a1f7zkVScckCkTxzXUiJHqrWf1fo/Z/+vjN96fjZtqA20AAAAAAAAAABjNDEQao2qtf5/k+Unu2MGtDyX5tVrrr9Va1w5+s51Ta300yTlJLkqycAe3fynJc2ut76i1bhr0cgAAAAAAAAAAo9CVty3umHntKbMaaMJI96LD98lh++zaNnP/8lX5xj2PNNQIAAAAAAAAAIDRykCkMazWemut9aQkv5DkE0mW9RFdmeTLSd6Q5JBa66cGeN/ZtdbS6zN7IGduObfWWv8tydxs/pven+TGJA8nWZNk/ZbvP0xydZLfSnJorfWCWuudA70/AAAAAAAAAEC3uHvZk/nB0ifbZo4/aI8cOXP3hhoxkvX0lLzlzEM65j52w46+5wwAAAAAAAAAgLFm/HAXYPjVWq9Ncm2SlFL2SLJ/kqnZPERoea31oWGst8NqrZuy+e+5dri7AAAAAAAAAACMRlfevrhj5ldOmdVAE0aLV55wQP7maz/J8mfW9pm5Y9ETuWPRijz34OkNNgMAAAAAAAAAYDTpGe4CjCy11pW11ntqrbfXWn842oYhAQAAAAAAAAAwMM+u25Av3vlg28yuk8bn5cfNbKgRo8Gk8eNy0fNnd8xddv3CoS8DAAAAAAAAAMCoZSASAAAAAAAAAADwM1+566E8vXZD28wFx++fXSaOb6gRo8XrT52VXSaOa5v5+j2PZOFjzzTUCAAAAAAAAACA0cZAJAAAAAAAAAAA4Gc+e9vijpnXnTKrgSaMNnvsMjG/fNJBbTO1Jh+/8f6GGgEAAAAAAAAAMNoYiAQAAAAAAAAAACRJ7nv4qdy5eGXbzLEHTsvRB0xrqBGjzZvOOCQ9pX3mqjuWZvkza5spBAAAAAAAAADAqDJ+uAs0oZQyKcnxSZ6bZG6SaVs+k5N0ePymo1prPX+AZwAAAAAAAAAAwLC78rYlHTOvPXlWA00YrQ6avktedszMfOWuh/rMrN2wKVfcvCi//wvzGmwGAAAAAAAAAMBo0NUDkUopJyZ5W5JfTjJ1KG6RpA7BuQAAAAAAAAAA0KjV6zbm899f2jazy8RxecXx+zfUiNHqrWfNaTsQKUk+efMD+c0XHJopE8c1UwoAAAAAAAAAgFGhZ7gLDIVSypRSyj8kuS3JRUl2zebhRYP5AQAAAAAAAACArvHfP3woT63Z0DZzwfH7Z9dJXf0ONgbBsQfukefNmd4288Sz63NVhwFcAAAAAAAAAACMPV03EKmUMiXJN5L8Tjb/fSVJHYIPAAAAAAAAAAB0jStvX9wx89qTZzXQhG7w1rPmdMxcfsPCbNzkUSwAAAAAAAAAALbpuoFIST6b5PT8/CCkrcogfwAAAAAAAAAAYNT76SNP5/YHnmibec7M3XPsgdMaasRo98J5+2TuPru2zSx6/Nl8456HG2oEAAAAAAAAAMBoMH64CwymUspLkrwiPz8EKdk8vGhdkm8muSPJ/CRPJVndaEEAAAAAAAAAABiBPnvbko6Z1506K6V4hxj909NT8pYz5+SSq+9qm/vo9Qtz7lH7+bcFAAAAAAAAAECSLhuIlORPe/0uSTYk+UCS99Va27/GDgAAAAAAAAAAxpg16zfm83cubZuZMmFcLjh+/4Ya0S0uOGH//M3Xf5zHnl7bZ+bOxStzx6InctLs6Q02AwAAAAAAAABgpOoZ7gKDpZSye5LTk9StS0nWJ7mw1vpOw5AAAAAAAAAAAOD/9bUfPZyVz65vm3n5sTOz++QJDTWiW0waPy5vPH12x9xHr1849GUAAAAAAAAAABgVumYgUpLnJxm35XvJ5sFI/1Rr/eLwVQIAAAAAAAAAgJHtM7cu7ph53amzGmgyih11VFJr+89RR/Wx9ajUWtt+jupj72jwq6cenF0mjmub+cY9j+Sm+csbagQAAAAAAAAAwEjWTQORZrZYe3/jLQAAAAAAAAAAYJRY8NgzufX+FW0zR+y3W044aI+GGtFtpu0yIa85+aCOuXdcdVeeWbuhgUYAAAAAAAAAAIxk3TQQae9evxfUWpcNSxMAAAAAAAAAABgF/v32JR0zrz35oJRSGmhDt/qN5x+ScT3t/w0tW7k677vm3oYaAQAAAAAAAAAwUnXTQKRN232vSR4criIAAAAAAAAAADDSrd2wMVfdsbRtZtL4nvziCQc21IhuddD0XXL+MTM75j51y+LcNH95A40AAAAAAAAAABipumkgUu8nYbyWDgAAAAAAAAAA+vD1Hz2SFavWtc2cf+zMTNtlQkON6GZvf8nhmTJhXMfcO666K8+s3dBAIwAAAAAAAAAARqJuGoh073bfS5K9h6sIAAAAAAAAAACMdFfevrhj5nWnzGqgCWPBrL12ySUvPbxjbtnK1XnfNfd2zAEAAAAAAAAA0J26aSDS95I8td3vw0opuw9XGQAAAAAAAAAAGKkeWL4q353/eNvMYfvsmpMO3rOhRowFbzhtdk6ZPb1j7lO3LM5N85c30AgAAAAAAAAAgJGmawYi1Vo3JPlckrJlaVySlw5fIwAAAAAAAAAAGJmuvH1Jx8zrTpmVUkrHHPRXT0/Jpa8+NpMndH5s7R1X3ZVn1m5ooBUAAAAAAAAAACNJ1wxE2uKvk6xLUrN5MNL/N7x1AAAAAAAAAABgZFm3YVOuuqP9QKSJ43vyqhMOaKgRY06fhscAACAASURBVMnsGVPzzpce0TG3bOXqvO+aextoBAAAAAAAAADASNJVA5FqrfOTvDebhyHVJEeVUt41rKUAAAAAAAAAAGAE+ea9j2T5M+vaZs47er/sOXViQ40Ya95w2uycMnt6x9ynblmcm+Yvb6ARAAAAAAAAAAAjRVcNREqSWut7k3w+m4cilSR/Vkr5o+FtBQAAAAAAAAAAI8NnblvcMfO6U2Y10ISxqqen5NJXH5vJEzo/vnbJ1Xdl1doNDbQCAAAAAAAAAGAk6LqBSFu8NslntnwvSf6ilHJtKeWMYewEAAAAAAAAAADDatHjq3LDT5e3zcyZMTWnHjK9oUaMVbNnTM0l5x7RMbf0idV53zX3NdAIAAAAAAAAAICRYPxwFxhMpZRf3u7nl5IcmOSsbB6K9KIkLyqlLEhyQ5J7kqxIsmqg9621/sdAzwAAAAAAAAAAgKH24esWdMy89pSDUkppoA1j3RtPn52v3v1wbntgRdvcFbcsynlH75fTD5vRUDMAAAAAAAAAAIZLVw1ESnJlktpivWbzUKQkOSzJoYN8XwORAAAAAAAAAAAY0ZaseDZX3bG0bWbCuJJfOvHAhhp1kSVLkj/4g/aZ978/OeigFluX5A867H3/+9+fg1rsHe16ekouffWxeek/XJ816ze1zV5y9V352u+dlamTuu2RNwAAAAAAAAAAttetT4f0fkVdyc8PShrMV9i1GsAEAAAAAAAAAAAjyoeuW5ANm9o/6nLuUftlr10nNdSoizz1VHLVVe0z73pXH1ufylUd9r6rj73dYPaMqbnk3CPynq/c0za39InVed819+XPX3l0Q80AAAAAAAAAABgOPcNdYIjUFp9O13fmAwAAAAAAAAAAI96ylatz1R1LOubedMYhDbSBn/fG02fnlNnTO+auuGVRbpq/vIFGAAAAAAAAAAAMl24ciFQa/AAAAAAAAAAAwIj3oW/Pz/qN7d//dda8vXPCrD0bagTb9PSUXPrqYzN5QufH2S65+q6sWruhgVYAAAAAAAAAAAyH8cNdYJD9R5L2T24BAAAAAAAAAMAY8uDK1fmP7y3pmLv47LkNtIHWZs+YmkvOPSLv+co9bXNLn1id911zX/78lUc31AwAAAAAAAAAgCZ11UCkWutrh7sDAAAAAAAAAACMJB++bkHWb2z/jrEz587Icw/es6FG0NobT5+da+5+KLc/8ETb3BW3LMp5x+yX0w+d0VAzAAAAAAAAAACa0jPcBQAAAAAAAAAAgKHx0JOr8++3L+mYu/jsuQ20gfZ6ekouffVxmTyh82Ntl1x1V1at3dBAKwAAAAAAAAAAmmQgEgAAAAAAAAAAdKkPX7cg6zZuaps547AZOWn29IYaQXuHzJiad5x7RMfc0idW533X3NdAIwAAAAAAAAAAmmQgEgAAAAAAAAAAdKGHn1yTK29b0jF38TlzG2gD/XfR6bNz8uw9O+auuGVR7li0ooFGAAAAAAAAAAA0xUAkAAAAAAAAAADoQh/5zoKs27ipbeb0Q/fKybOnN9QI+qenp+TSVx+XyRM6P972D9+c30AjAAAAAAAAAACaYiASAAAAAAAAAAB0mUeeWpPP3La4Y+7is+c20AZ23CEzpuYd5x7RMXf9Tx7LvQ891UAjAAAAAAAAAACaYCASAAAAAAAAAAB0mY98Z0HWbdjUNvO8OdNz6py9GmoEO+6i02fn5Nl7dsxdfsP9DbQBAAAAAAAAAKAJY3YgUillSinlsFLKyaWUl5RSfrGU8uJSyvGllINLKWW4OwIAAAAAAAAAwI569Kk1+cytizvmLj57XgNtYOf19JRc+urjMnFc+8fcvvSDZXn4yTUNtQIAAAAAAAAAYCiNH+4CTdky4OjlSc5NclqSY5KMa7NlVSnltiQ3J/lcrfWuoW8JAAAAAAAAAAAD89HrF2bthk1tM6ccMj2nHbpXQ41g5x0yY2ouOH7/fO6OpX1m1m+s+bebHsgfnXdEg80AAAAAAAAAABgK7V+d1QVKKZNLKW9PsiDJF5L8VpITsnkYVGnz2TXJi5L8SZI7SynfLqW8ovm/AAAAAAAAAAAA+uexp9fm07cu6pj7vXPmNtAGBsdbzprTMfPpWxflmbUbGmgDAAAAAAAAAMBQ6uqBSKWUE5PcmeSvk8zOtmFHSVL78dl+QNILkvxnKeVzpZQ9m/srAAAAAAAAAACgfy67fkHWrN/UNnPK7Ok5bc5eDTWCgZu372554eF7t808vWZD/v32JQ01AgAAAAAAAABgqHTtQKRSyv9OclOSedk80Kj3sKP+6J0vSV6V5K5SyvGDWhgAAAAAAAAAAAbgsafX5opbFnXMXXzO3JRSOuZgJHnrWXM6Zv7lxvuzYWP7gWAAAAAAAAAAAIxsXTkQqZTyG0k+nGRitg1D+rlIr8/qJCuSrG9xbautg5FKkgOSfLOUcvjQ/RUAAAAAAAAAANB/H7thYdasbz8M5qSD98zph+7VUCMYPKfN2StHH7B728yylavz33c/3FAjAAAAAAAAAACGQtcNRCqlnJjkQ1t+bh1ilGwbcLQ4yfuSvDLJwUkm1Fp3rbXuXWudnGRKkqOT/FqSf0nydFoPRtozyRdKKZOH9i8CAAAAAAAAAID2lj+zNlfcvKhj7uJz5qaU0jEHI00pJW85c07H3GXXL0itvd+fBwAAAAAAAADAaNF1A5GSXJZkYrYNQko2DzT6cZLza62H1Fr/pNb6pVrrklrrxu0311rX1lrvqbV+utb65iT7Jbk4yZP5+cFISTIvyZ8O2V8CAAAAAAAAAAD98LEbFmb1+o1tMyfO2iNnHDajoUYw+F52zMwcsMeUtpm7lz2VWxauaKgRAAAAAAAAAACDrasGIpVSXpHkxGwbhlS2fD6c5Nha6zU7ematdU2t9YNJjkxye7YNRapbvl9cStljoN0BAAAAAAAAAGBnrFi1LlfcvKhj7uJz5qWU3u8Dg9FjwrieXPT82R1zH7th4dCXAQAAAAAAAABgSHTVQKQkb9rue8nmoUUfqLX+dq11/UAOrrU+kuTFSW7LtqFISTI1yesGcjYAAAAAAAAAAOysj92wMM+u29g2c/xBe+SsuTMaagRD57WnzMpuk8e3zXzrvkfz00eebqgRAAAAAAAAAACDqWsGIpVSJiZ5STYPQdo6sOiuJJcM1j1qrauS/HqS1b0u/a/BugcAAAAAAAAAAPTXE6vW5ZM3PdAxd/E5c1NK6ZiDkW7XSePzK6fO6pi7/Ib7G2gDAAAAAAAAAMBg65qBSEmOTzJpu981yXtrre1ff7eDaq0/SfKZbB66tHX40vMG8x4AAAAAAAAAANAfl9+4MKvWtX885riD9sgL5+3dUCMYehedfkjG97Qf8PWfdy7Lo0+vaagRAAAAAAAAAACDpZsGIs3r9fvZJF8Zonv9e6/f00opnhoDAAAAAAAAAKAxT6xal0/ctKhj7vfOnptS2g+PgdFkv2mT84rj92+bWbdxUz7Zj/9/AAAAAAAAAAAwsnTTQKR9ev1+oNa6dojudW+LNQORAAAAAAAAAABozMdvvD/PrN3QNnPsgdPywsM91kL3ecuZczpmrrhlUZ5d1/7/IwAAAAAAAAAAjCzdNBBpynbfa5JHh/Berc6e0mINAAAAAAAAAAAG3cpn1+XfbnqgY+7is+emlDL0haBhR87cPWfOndE28+Tq9fnc95Y21AgAAAAAAAAAgMHQTQOR1m73vSSZPoT32rPF2rohvB8AAAAAAAAAAPzMR69fmGfWbmibOeaAaXnxEfs01Aia99az5nTMXH7jwmzcVBtoAwAAAAAAAADAYOimgUgrev2eVYbu9XaH9OP+AAAAAAAAAAAw6O5fviofv+H+jrnfPXtuhu7xGRh+Zxw2I0fst1vbzJIVq/O1Hz3cUCMAAAAAAAAAAAaqmwYiLej1e48kLxyie/1ir99raq3LhuheAAAAAAAAAACQJKm15l1f+lHWbdzUNnfU/rvnnCP3aagVDI9SSt561pyOuY9evzC11gYaAQAAAAAAAAAwUN00EOn7SXo/6fUHg32TUsoeSd6YpCYpW/77/cG+DwAAAAAAAAAA9Pb1ex7Jd37yWMfc7549N6WUBhrB8Hr5sftnv90nt838YMnKfG/REw01AgAAAAAAAABgIMYPd4HBUmt9upRyc5LnZ9uwopeVUt5Qa/3EIN7qg0n22XKPra4ZxPMBAAAAAAAAAOD/sXrdxrzny/d0zB174LS85Dn7NtCInzn00OTuuztnWi4fmrs77D20j70kE8f35KLnz85fXXNf29xl1y/MybOnN9QKAAAAAAAAAICd1TUDkbb4ZDYPREq2DUX6WCllU631ioEcXDa/Mu8jSV6fnx+GtDHJpwZyNgAAAAAAAAAAdPLh6+Zn2crVbTOlJO+54OhsftSFxkyenBx11E5unZyjdnIvm73u1Fn54Lfm55m1G/rMXHvvI1nw2DM5dO9dG2wGAAAAAAAAAMCO6hnuAoPsE0mWbfe7ZvPQp38rpXy6lDJzZw4tpZya5LYkb95+ecv5V9ZaF+9kXwAAAAAAAAAA6GjR46vykesXdsy95qSDcvxBezTQCEaO3SdPyGtPPqhtptbk4zfe31AjAAAAAAAAAAB2VlcNRKq1rkvyu9k8rCjZNrSoJHltkoWllKtLKReWUmb1dU4ppaeUclQp5W2llJuS3JTkxO3O22plkncMwZ8CAAAAAAAAAAA/8+4v35N1Gza1zUybMiGXvPSIhhrByHLRGYdkXE9pm7n6jqVZ/szahhoBAAAAAAAAALAzumogUpLUWv8zyT/m54cXbR2KNCnJK5NcmeT+UsrjpZS7Syk3lVK+WUq5rZRyX5Knk9yV5INJTt2yd/vzSpKNSV5fa32koT8NAAAAAAAAAIAx6Np7Hsm37nu0Y+7t5x6e6VMnNtAIRp4D9piSlx87s21m7YZNueLmRQ01AgAAAAAAAABgZ3TdQKQtfj/Jv2bz4KKtarYNRtr62TPJc7J56NELk5yUZF6SKb1yW/dmy+/1SX691vrVIf47AAAAAAAAAAAYw9as35h3f+VHHXNHH7B7fuWUWQ00gpHrLWfO6Zi54pZFWb1uYwNtAAAAAAAAAADYGV05EKlu9qYkb02yKq0HI/UeclT6uF6321uS/DjJabXWzw7ZHwAAAAAAAAAAAEk+8p0FWbJidcfcu19xdMb1lI456GZHHzAtpx+6V9vMilXrcvX3lzbUCAAAAAAAAACAHdWVA5G2qrVenuSEJJ9LsjE/P/joZ7G0Hn601dY9K5L8RZITa63fH6rOAAAAAAAAAACQJEtWPJsPX7egY+7C5x6Y5x68ZwONYOR7y1lzOmYuv2FhNm5q9agYAAAAAAAAAADDrasHIiVJrXVBrfU1SWYneU+SW5Osz7ZBR+0+Tya5JsmbkhxYa/2zWmvnV+4BAAAAAAAAAMAAvecr92Tthk1tM7tPHp93nndEQ41g5HvhvL0zd59d22YeePzZfOOeRxpqBAAAAAAAAADAjhg/3AWaUmt9MMm7kryrlDIxyYlJDk6y55bPlCRPJXliy+eeWut9w9MWAAAAAAAAAICx7Ns/frRfA1v+8CWHZ8aukxpoBKNDKSVvOWtOLrnqrra5j16/IOcetW9KKQ01AwAAAAAAAACgP8bMQKTt1VrXJbllywcAAAAAAAAAAEaMtRs25t1f+lHH3BH77ZbXnzqrgUYwulxw/P75m6/9OI89vbbPzJ2LV+br9zySc4/ar8FmAAAAAAAAAAB00jPcBQAAAAAAAAAAgG0+dv3CPPD4sx1zf/7KozN+nMd/oLdJ48fljafP7pj762vuy/qNm4a+EAAAAAAAAAAA/eaJKAAAAAAAAAAAGCGWPvFs/unb8zvmXnXCATl59vQGGsHo9PpTZ2WXiePaZhYuX5Urb1vcUCMAAAAAAAAAAPpj/HAXAAAAAAAAAAAANnvvV+7NmvWb2mZ2mzQ+f/SyIxpqRL88+mjyoQ+1z7ztbck++7TY+mg+1GHv2972tuzTYi9922OXiXn9qbPysRvub5v7+2t/mleecEB2mzyhoWYAAAAAAAAAALRjIBI/U0p5TpKjk+yfZNcka5I8luTeJHfWWtcPYz0AAAAAAAAAgK52/U8ey1d/9HDH3O/9wrzss9vkBhrRb489lrz73e0zF17YciDSY489lnd32HvhhRcaiLQTfvtFh+Xfb1+Sp9Zs6DPz+Kp1+ch3FuQd5xoyBgAAAAAAAAAwEhiI1EIpZWqS85KckWS/JOOSLEvyvST/WWtdNYz1BlUp5aAkv5vkV7J5EFJfni6lfCnJP9Zab2ukXBullNlJ2r++bedcVGv9tyE4FwAAAAAAAACgT2s3bMy7vvSjjrnD990tbzjt4AYawei3xy4T839ePDd/8d/3ts1dfsP9+dXnHZyZ06Y01AwAAAAAAAAAgL70DHeBwVZKmV5K2We7z/Qd3P+WJAuT/HuS/5PkwiSv2vL9E0keKaX8YSmlDHb3JpVSekopf5Lkx0nenvbDkJJktySvT3JrKeWTpZRpQ90RAAAAAAAAAGCs+PiN92fh8s7v6HrPBUdl/Liue+QHhsyvn35wDtyz/aCjtRs25e++/pOGGgEAAAAAAAAA0E5XPR1VStkzyUO9Pn+5A/vfl+QjSfZOUvr47JLk0iRfLKWMG8z+TSmlTEnypSR/kWRnXmv2a0luL6UcMqjFAAAAAAAAAADGoAdXrs4Hvzm/Y+6C4/fPqXP2aqARdI9J48flkpce0TF39feX5p4Hn2qgEQAAAAAAAAAA7XTVQKQkr0wyIduGFyXJ3/dnYynlwiSXbNlXO3xKkvOTXDaI3RuxZYjT1dncv5X1SX6Q5JtJbkvyTB+5uUm+VUqZOeglAQAAAAAAAADGkL/4r3uzev3GtpmpE8flT152ZEONoLv8r2Nn5rgDp7XN1Jr81TX3NtQIAAAAAAAAAIC+jB/uAoPs3C3/rVv+e1ut9b5Om0opE5O8v9fen13e7nvd7r8lyRtLKZ+ttV67k32Hw3uSnNdifWWSdyf511rrk1sXSykTkrwiyV8mmddrz+wkny2lnF1rbf9UXjMeTvKLAzxjwWAUAQAAAAAAAADojxt/ujz/9cOHOuZ+75x52Xf3yQ00gu5TSsmfvOzIvOayW9rmbvjp8nznJ4/lBfP2bqgZAAAAAAAAAAC9ddtApOdl27CimuQr/dz3piQHZNvAo61DkO5LclWS5UkOTfIrSfbaktt6n79LctwgdB9ypZTjkryzxaX7k5xTa13Y+0KtdX2Sq0spX01ydbYNndrqBUl+M8k/D3LdnbG21tr+qSUAAAAAAAAAgBFiw8ZNedeXf9QxN3efXfPG588e+kLQxU6ds1fOOXLfXHvvI21zf/Xf9+aMw2ZkXE9pmwMAAAAAAAAAYGj0DHeBwVJKmZFkVq/lb/Rz+xu3Pyqbhx39W5Jjaq3/t9b6j7XWi5McleTObBuYlCRHl1JO3qnSzfu7JON6ra1K8rJWw5C2V2tdleRVSVo9hfeeUsqug1MRAAAAAAAAAGBs+Pz3l2X+o890zL37gqMyYVzXPOYDw+aPzjui46Cj+x5+Old/f2lDjQAAAAAAAAAA6K2bnpSa0+t3TXJ3p02llEOTnLwlv9WSJL9Va934cwfW+miSVydZ1+uY1+xw24aVUk5KcnaLS39ea72vP2fUWp9N8pYWl6YneesA6gEAAAAAAAAAjClr1m/MB679Scfcy4+dmdMPndFAI+h+h+2za153ykEdc3/39R9n9bqNHXMAAAAAAAAAAAy+bhqINLvX7yVbBvh08pLtvpdsHoz04Vrr2lbhWuv9Sf5ju2ySnLZjVYdFq4FFjyf54I4cUmu9OcnXWlxqNSgJAAAAAAAAAIAWPnXLojz05Jq2mV0mjsufnn9kQ41gbLj47HmZOnFc28wjT63N5TcsbKgRAAAAAAAAAADb66aBSHv1+v14P/e9qMXaZzvs+fJ230uSY/p5r2FRShmf5NUtLn26n0OjevtYi7UjSikn7sRZAAAAAAAAAABjytNr1udD1y3omPudFx+WmdOmNNAIxo69d5uU33zBoR1zH/nOgjz2dMt36gEAAAAAAAAAMIS6aSDSLtt9r0me7Oe+s7bkt/pRrXVxhz139fo9tZSydz/vNxyel2TPFutX7+R5/5VkdYv183byPAAAAAAAAACAMePyG+7PilXr2mb23X1SfuP5hzTUCMaWN585J/vuPqltZtW6jfmHb/6koUYAAAAAAAAAAGzVTQORJvf6vanThlLK7CT7bP2ZzYORvt2Pey1rsTatH/uGy4tarD2b5OadOazWuibJTS0uvXhnzgMAAAAAAAAAGCsef2ZtLr9hYcfcxWfPy+QJ4xpoBGPPlInj8oe/cHjH3GdvW5L5jz7TQCMAAAAAAAAAALbqpoFIq3v9ntqPPWe0WLu+H/uebbG2Wz/2DZeTW6zdWWtdP4Azb2uxduIAzgMAAAAAAAAA6Hr//O0FWbVuY9vM7L12yYUnHdhQIxibfum5B+aI/do/8rVxU81ff/W+hhoBAAAAAAAAAJB010Ckp7b7XpLM6seeF7RYu7Ef+6a0WGv/pNrwOrbF2t0DPPOuFmt7lFIOHuC5g6KUMrWUMruUcmIp5YhSyr6llAnD3QsAAAAAAAAAGLuWrVydT92yqGPuD19yeCaM66bHemDkGddT8scvO7Jj7hv3PJJbFz7eQCMAAAAAAAAAAJLuGoj0SK/fM0sp0zvsOT9J3e73glpr73Na2bPF2jP92Ne4UsrEJAe1uDR/gEcv6GN9zgDPHYhppZSPl1J+nM3/e9yf5I4k9yZ5OMm6UsqPt2TeUErZdRi7AgAAAAAAAABjzN9/4ydZt3FT28xzZu6e84+Z2VAjGNteMG/vnDl3RsfcX/73vdm0qXbMAQAAAAAAAAAwcOOHu8Ag+kGLtfOSfLpVuJTywiT7ZfNApLLlv9f18177tVhb0c+9TTsorQdfLRvguX3tnz3AcwdijyS/0SEzb8vnN5L8QynlY0neX2t9aKjLtVJKOW2ARxw9KEUAAAAAAAAAgCE1/9Gnc/X3l3bMveOlh6enpzTQCEiSPz7vyNw4/4bUNvOOfrD0yXzlhw/lFcft31wxAAAAAAAAAIAxqmsGItVaF5dSHksyI9uGHL2jlHJlrXVjiy3vaLF2bT9vd0Kv30/VWlf2v22j9u5j/ZEBntvX/r7uNxJNS/L2JBeVUt5Ua/3iMHS4aRjuCQAAAAAAAAA07G+/9pNsajNwJUlOOWR6XjhvND16AaPfc/bfPa864cCOA8su/ep9OfeofTNp/LiGmgEAAAAAAAAAjE09w11gkF2VzYOQtjomySdKKZO3D5VSLklyXjYPTtrqmSRf7ud9Tuz1e8EO9mzS9D7WnxzIoVuGTK1qcWmvgZw7TPZK8oVSynuHuwgAAAAAAAAA0H1+sGRlvvqjhzvm3vnSw1NK6ZgDBtfbz52XSePbP0q39InVueLmRQ01AgAAAAAAAAAYu7ptINK/bPe9ZvNwpNclWVpK+Vwp5eOllLuS/NV2ubIle2WtdXU/73P2dufXJP8z4OZDZ9c+1p8ZhLNbDUSaOgjn7qhnk3w1yTuTvDzJYdk85GhCkmlJZmfzAKz3Jvlpm3P+tJRy8ZA2BQAAAAAAAADGnEu/dl/HzDlH7pPnHtzXe6+AoTRz2pS8+cxDOuY++K35WfnsugYaAQAAAAAAAACMXV01EKnWekeST2fzoKJk29Ci6UleleSNSY7OtkFGW63N5mE5HZVSjsvmgTvbu3mnSw+9CX2sbxiEs9e3WJs4COf2x6Yk30jymiTTa63n1VovrbX+V611Qa11Ra11Q631qVrrolrrV2utf5bk8Gz+t/BgH+d+oJTywmb+BAAAAAAAAACg29340+X57vzH22ZKSd5+7uENNQJa+c0XHJq9prZ/9OnJ1evzT9+a31AjAAAAAAAAAICxafxwFxgCv5/k1GweWlSzbfBR2S5Te33/41rrkn6e/8st1r67oyUbNK6P9Y2DcHarMxr5N1VrXZzkJTuxryb5z1LKd5J8IcmZvSIlyd+WUk7ekh1qpw9w/9FJLhuMIgAAAAAAAADA4Kq15m++dl/H3AXH7Z8j9tu9gUZAX3abPCEXnzM3//eLP2qb++TNi/Lrp83OrL12aagZAAAAAAAAAMDY0nUDkWqty0spZyf5cpJjs234Ue/hNlsHJP1lrfUf+nN2KWVSkjf1Omtxrf8/e3ceZndZ343/fWcjKwkhCVsCERJ2oYJAcAcsCoptH62t4oILoKJoW5fW+mhbl+fXp61IFW0VcAFZ3KoV3EBQKSARVPYQCIQdwiJZyTKZ+/ljkh/jODNnkpk5M3Pyel3XueZ87/O57+97EMZ/vtf71MZPrg2dth7WB+J/++7O2DAA5w66WuuTpZQT0lFmdUCXjw9N8pok32xCjmv7s7+U0ngIAAAAAAAAABgSP771kdz4wPJeZ8aMKvnrP96nSYmA3rzu8N3zlauX5u7HV/c4s35je/75x4ty1usPaWIyAAAAAAAAAIBtx6ihDjAYaq33p6PU5n1JbkpH+VHnV1uSnyY5utb6kS04+s1JZnU6J0kuHaDYg2VdD+vjBuDs7s7o6X7DTq11eZJ39fDxq5uZBQAAAAAAAABoLW0b2/OvP1nccO51h++e3Xec2IREQCNjR4/Kh47bt+HcpTc9nBvu/V0TEgEAAAAAAAAAbHvGDHWAwVJr3Zjk35P8eyllVpI5SbZP8lSSxbXWnr/Gq2fLk/xdl7VL+hV08K3sYX3KAJzd3RkrBuDcpqm1/qKU8vMkL+7y0bGllNGb/j0CAAAAAAAAANgi3/nNg7lr2apeZyaMHZ33HD2vSYmAvjh2/51y2Nwd8qulvRcefeLS2/Kddz4vpZRe5wAAAAAAKo/5pgAAIABJREFUAAAA2DItW4jUWa11WZJlA3DOxQMQp9me6GF9Wn8OLaWMT7LdFtxvOLskf1iItEOSeUnuaH4cAAAAAAAAAGAkW7thY868/M6Gc295/tzM2n58ExIBfVVKyYeP3y9/9vlrep37zX1P5dKbH84rD9q1SckAAAAAAAAAALYNo4Y6AIPukR7Wd+7nuT3t7+l+w9kNPazv1NQUAAAAAAAAAEBL+Pp19+XBp57udWbqhLE59cV7NSkRsCWes/sOOeHgxkVH//yjRVm7YWMTEgEAAAAAAAAAbDtaphCplLJrKeW1XV6HDHWuYeChJOu6Wd+9n+f2tP+efp47FJb1sD6rqSkAAAAAAAAAgBFv1bq2nHXlXQ3n3vHivTJ1wtgmJAK2xgdftk/Gjen98br7n3w6X71maXMCAQAAAAAAAABsI1qmECnJ8Uku7PJ61pAmGgZqrTXJkm4+2rufR8/vYb3xE30jx7ihDgAAAAAAAAAAjCxnX3V3nly9vteZWVO2y0nPm9ucQMBWmTN9Yt7y/LkN5z535V0N/5sHAAAAAAAAAKDvWqkQacckpdNrTZLvDWmi4eM33awd3M8zn9PN2gO11sf7ee5QmNXD+oqmpgAAAAAAAAAARrQnVq3L2Vfd03Du9GPmZ8K40U1IBPTHaUfNy/RJvX+n2sq1bTnz8sVNSgQAAAAAAAAA0PrGDHWAAbT5KbGajkKk+2utbUOYZzi5LsmJXdb2L6VMrbUu38ozj+zhPiPRoT2s39fUFAAAAAAAAADAiPb5ny3JqnW9P66yx44T8xeHzWlSIppm9uzkG99oPNPt8ux8o8He2T3sZXBtP35s3vfS+fno927tde7r192XNz1vbvaaOblJyQAAAAAAAAAAWlcrFSKt6vS+Jnl4qIIMQ5d3szY6yUuTfHtLDyulzErynD7eZyQ4oZu1tUkWNTsIAAAAAAAAADAyPfjU0znvl/c2nPvrP947Y0ePakIimmrq1OTP/3wrt07Nn2/lXgbf6w7fPV+9ZmmWPLa6x5m29pr/84NFOfvNz21iMgAAAAAAAACA1tRKT1c92Ol9SeLrtjaptd6eZEk3H/3FVh752nT8M/692yS5ZCvPGzKllBcleVE3H11Va13f7DwAAAAAAAAAwMh05uWLs76tvdeZ/XbZPicctGuTEgEDYezoUfnw8fs1nLv89kdz7ZInmpAIAAAAAAAAAKC1tVIh0m1drncekhTD1/ndrP1pKWXOlhxSSilJTuvmo5/VWh/YqmRDpJQyNcnne/i4u39eAAAAAAAAAAB/4K5lq/KtGxo/NvGBl+2dUaO6fgcVMNwdve+sPG+vHRvOfeLS29LeXpuQCAAAAAAAAACgdbVMIVKt9fYkj3Raml1KedZQ5RmGvphkfZe1sUk+sYXnvCXJvt2sf66vB5RSlpZSapfX0i3Y/2ellEl9ne/hjOlJvp/kgG4+vjfJhf05HwAAAAAAAADYdnz2ijvTqAPlsLk75Kh9ZjUnEDCgSin5+1fsl9Kgz+zWh1bkO795sDmhAAAAAAAAAABaVMsUIm1yUZLOj528dqiCDDe11oeSnNvNR28qpfx5X84opeyd5NPdfHRLku/2I96W+liS+0spnyqlHLQlG0uHP0lyU5IX9jD2nlrrhv6GBAAAAAAAAABa35LHVuX7Nz7UcO6DL983pVGbCjBsHbDr1Lz6kNkN5/71x3fk6fUbm5AIAAAAAAAAAKA1tVoh0plJ1iap6ShG+lApZfrQRhpW/neSJ7tZP6+U8rreNpZSnpPkp0mmdvPx6bXW9gHItyV2SPJ3SW4spSwppXyhlPLOUsrzSyl7lFJ2KKWMKaVMLqXsXko5tpTyT0nuSEd50249nPt/a63fb9YvAQAAAAAAAACMbGddeVfaa+8zR+87K4fN9QgLjHTvP3afTBg7uteZR1aszZeuurtJiQAAAAAAAAAAWk9LFSLVWu9N8vF0lCHVJNOSfLeUMmFIgw0TtdbHk7ytm4+2S3JBKeUHpZQ/KaXsVEoZXUqZVkp5cSnli0muS9LdV5ydUWu9cjBz98GeSd6R5PNJ/ifJ0nQUP21IsjLJvUl+nI5CqPm9nHNGkr8dzKAAAAAAAAAAQOtY+vjqfO+3DzWce/+x+zQhDTDYdp46Pie/aM+Gc//x8yVZtmJtExIBAAAAAAAAALSelipESpJa6/9JcmGeKUV6fpIrSyn7DWmwYaLW+t0kH+7h4+OSfDfJI0nakvwuyc+SnJxkbDfzlyT50MCnbLpHkryq1vrXtdYG39kIAAAAAAAAANDh8z+7Kxvbe3/U4OUH7Jz9d92+SYmAwXbqi/bMzCnb9TqzZv3GfPqyxU1KBAAAAAAAAADQWlquEGmTNyQ5o9P14Ul+U0r5ainlxaWUMUOUa1jYVBr1V0k29uOY85O8pta6YWBSbZFrk6wYgHMeTPJPSQ6otX5/AM4DAAAAAAAAALYR9z+5Jt/59YMN595zzLwmpAGaZdJ2Y/KBY/dpOPeN6+/P7Q8PxCNOAAAAAAAAAADblpYqBiqlfL7L0u1J9k9Sk4xLR1HSG5KsL6XckuSBJMuTrOnHbWut9bR+7B8StdbPlFKuTXJWkkO3YOvDST5Yaz1/cJI1Vmt9Zynl3UkOSXJkkj9KclCSZyWZ3svW1Ul+nWRhkp8l+WGttT+lUAAAAAAAAADANuoLP1+Stvba68xL95uVA3ad2qREQLO8+tDZOffqe7LokZU9zrTX5FM/uD1fe+vhKaU0MR0AAAAAAAAAwMjWUoVISd6RjvKj7tQkm58s2S4dJUCH9PN+ZdO5I64QKUlqrdcleW4p5aXpKIp6aZLduhl9KslVSb6V5OJa67p+3nduf/ZvOmNjkl9tev3/SikTkuyUZFKSCUnWpyP/8iQraq29P4kIAAAAAAAAANDAQ089nW9ef3/DufccPb8JaYBmGz2q5COv2D9vOOe6XueuuvPx/GzxYzlqn1lNSgYAAAAAAAAAMPK1WiHSZl2/UmtzcVHtsuart5LUWi9PcnmSlFKmJdk1HYVCa5M8Xmt9eAjjbZFa69NJlg51DgAAAAAAAACgdf3Hz5dkw8bev5PpJfvMzMFzpjUpEdBsL5g/I0ftMzNX3vFYr3OfuvT2vHDejIwZPapJyQAAAAAAAAAARrZWLUTq/Ymzvs800nKFSrXWp5I8NdQ5AAAAAAAAAACGo0eWr81FC+9vOPeeo+c3IQ3DxvLlyU9+0vvMsccmU6d2s3V5ftJg77HHHpup3exlaH34+P3yizsfz8b2nh9Fu3PZqlx8/f058Yg9mpgMAAAAAAAAAGDkasVCpJYrKQIAAAAAAAAAYHj4z18syfqN7b3OvHD+jBy6xw5NSsSw8MADyWtf2/vMLbd0W4j0wAMP5LUN9t5yyy0KkYah+TtNyV8eNidfv+6+XufOuGxxXnXwrpkyfmyTkgEAAAAAAAAAjFytVoj0zqEOAAAAAAAAAABAa1q2cm0uaFB8kiSnHzO/CWmA4eCv/njvfO+3D2XVurYeZx5ftT7/8fMl+cDL9m1iMgAAAAAAAACAkamlCpFqrf851BkAAAAAAAAAAGhNZ191T9a1tfc6c+SeO+awudOblAgYajMmb5d3HbVX/u+P7uh17uyr7snrj9gju02b0KRkAAAAAAAAAAAj06ihDgAAAAAAAAAAAMPdE6vW5bxr7204d/ox85uQBhhO3vr8ZzUsOlrX1p5/+dGiJiUCAAAAAAAAABi5FCIBAAAAAAAAAEADZ//PPXl6w8ZeZw6bu0MW7Dm9SYmA4WL82NH54Mv3aTj33d8+lBvvf6oJiQAAAAAAAAAARi6FSAAAAAAAAAAA0IvfrV6fr12ztOHc6cfMTyll8AMBw84JB+2ag2dPbTj3yUtvT621CYkAAAAAAAAAAEYmhUgAAAAAAAAAANCLc6++J6vXb+x15jm7T8sL5s1oUiJguBk1quQjr9y/4dzCpU/mx7c+2oREAAAAAAAAAAAjk0IkAAAAAAAAAADowfI1G/KVq5c2nDv9mPkppQx+IGDYOmzu9Lz8gJ0bzv1/P7w969vam5AIAAAAAAAAAGDkUYgEAAAAAAAAAAA9+PI192TlurZeZw6aPTUv2XtmkxIBw9nfHrdvxo7uvRxt6RNrcv4v721SIgAAAAAAAACAkUUhEgAAAAAAAAAAdGPl2g0593/uaTh3+tHzU0rvBSjAtmHujEl544K5DefO/OmdeWrN+sEPBAAAAAAAAAAwwihEAgAAAAAAAACAbnzt2nuzYm1brzP777J9jtlvVpMSASPB6cfMy9QJY3udWf70hnz2irualAgAAAAAAAAAYOQYM9QBmqmUMi3JEUn2SjJt02tSkv5+Rd9FtdZf9PMMAAAAAAAAAACGiVXr2vKlq+5uOHf6MfNTSn8fPQFaybSJ43L6MfPz8Utu63Xua9cuzRsX7JG5MyY1JxgAAAAAAAAAwAjQ8oVIpZQZSU5NcmKSvdP/8qPu3JJEIRIAAAAAAAAAQIs4/5f35qk1G3qd2XfnKTl2/52alAgYSd64YI+cd+3SLH1iTY8zGzbW/POPFuULbzi0ecEAAAAAAAAAAIa5UUMdYLCUDv+U5L4k/5Rk33T8vmWAXwAAAAAAAAAAtJA169vypV/c3XDu3UfPy6hRHh8B/tC4MaPyt8ft23Duh7c8kl8tfbIJiQAAAAAAAAAARoaWLEQqpcxI8rMkf59kfDqKi+ogvQAAAAAAAAAAaCEXXHdfnli9vteZebMm57gDd2lSImAketkBO+fwudMbzn3i0tvT3u5RNAAAAAAAAACApAULkUopY5J8K8kL8/tFSNl0vSWv3zu6j3MAAAAAAAAAAIxQazdszH/8/O6Gc+85el5Gj/LYCNCzUkr+/hX7NZy78f6n8v2bHmpCIgAAAAAAAACA4W/MUAcYBJ9K8qI8U4KUdJQWrUtyRZJfJVmW5HObZjaXJv1LkvuT7JBkRpJDkjw3yfg8U6pUkrQlOTPJXZ3Ov2rQfhsAAAAAAAAAAJrmooX35fFV63qd2XPGpLzyoF2blAgYyQ6eMy1/8ke75nu/7b3w6P/+6I687ICdM37s6CYlAwAAAAAAAAAYnlqqEKmUMivJu/NMGdLmr+G7NMk7aq0Pdpr9XJft36m1Luxy3nZJ3pDkvUkO3HTumCSnJjmp1vqdAf8lAAAAAAAAAAAYEms3bMwXfr6k4dxpR83L6FGl4RxAknzw5fvmR7c8knVt7T3OPPjU0zn36nvyrpfMa2IyAAAAAAAAAIDhZ9RQBxhg700yftP7ko4Co28n+ZPOZUh9VWtdV2s9J8lzknwiSfumMycnubiU8roBSQ0AAAAAAAAAwJC7aOF9eXTFul5ndp8+MX/yR7s2KRHQCnabNiFve8GzGs59/soleXxV73+DAAAAAAAAAABaXasVIp2QjsKizZYleXutteev1uqDWuvGWutHk7xt81KS0UnOKaUc3J+zAQAAAAAAAAAYetfd/UQ+9cNFDefefdS8jBndao/cAIPtnS/ZKzMmj+t1ZtW6tnzm8sVNSgQAAAAAAAAAMDy1zNNZpZQdkhyw+TIdpUVfqLUuH6h71Fq/luRTnc4fn+Q/B+p8AAAAAAAAAACab/GjK3Py167P+rbev3Nrt2kT8meH7NakVEArmTJ+bN730r0bzl248P7ctWxlExIBAAAAAAAAAAxPLVOIlOS56Sgq6uyiLdjfdW9PPpnk/k7Xh5VSjt6C+wAAAAAAAAAAMEw8snxtTjp3YVasbWs4+66j9srY0a30uA3QTH952JzMnzW515mN7TWf+sGiJiUCAAAAAAAAABh+WukJrVldrlfUWhdvwf7xfRmqta5Ncl46CpTqpuXXb8F9AAAAAAAAAAAYBlas3ZCTvrwwDy1f23B2l6nj85pDZzchFdCqxowelQ8fv1/DuSsWLcvVdz3ehEQAAAAAAAAAAMNPKxUiTe9yfXeD+fYu130qRNrkkk7vS5Kjt2AvAAAAAAAAAABDbF3bxpz6tRuy6JGVfZr/2AkHZLsxowc5FdDqXrLPzLxg3oyGc5+49PZsbK8N5wAAAAAAAAAAWk0rFSJN6fS+JlneYL7r02xTt+Be93S53qOUMnEL9gMAAAAAAAAAMETa22s+8M2bcu3dT/Rp/r3HzM/LD9x5kFMB24JSSj58/H4ppfe52x9ekW/f8EBzQgEAAAAAAAAADCOtVIi0pst1o6/H6lqINGcL7vV4N2u7bcF+AAAAAAAAAACGyD//aFH++8aH+jT7F8+dk/e9dP4gJwK2Jfvvun1ee2jjx9X+9Sd3ZPW6tiYkAgAAAAAAAAAYPlqpEKlzwVFJMrXB/O+6XD9rC+41qZu1yVuwHwAAAAAAAACAIXDu/9yT//zF3X2aPWqfmfnEnx2YUsogpwK2NX9z7N6ZOG50rzPLVq7LF/v49woAAAAAAAAAoFW0UiHSA12ud2gwvygdxUl1088FW3CvfbtZW7cF+wEAAAAAAAAAaLIf3PxwPn7pbX2aPXj21Jx14iEZO7qVHq8BhotZ24/PqS/aq+HcF39xdx5dsbYJiQAAAAAAAAAAhodWemJrUZfr3Usp43uZv7nL9UGllJ36eK/ju1l7oo97AQAAAAAAAABosuvufiLvu/i3qbXx7B47Tsw5Jx2WiePGDH4wYJt18ouelZ22367Xmac3bMy//viOJiUCAAAAAAAAABh6LVOIVGu9N8nKTkujkhzYy5ZfdrkeneS0RvcppUxP8s4knR+PW15rfbSPUQEAAAAAAAAAaKLFj67MyV+7Puvb2hvO7jhpXL76lsMzY3LvJSUA/TVx3Ji8/9h9Gs5969cP5I5HVjacAwAAAAAAAABoBa32NXZXJ3l5p+vnJ7m+h9krkzyWZEY6yo1Kkg+VUq6stV7Z3YZSyoQk30gys9OemuQXA5IeAAAAAAAAAIAB9cjytTnp3IVZsbat4eyEsaNzzkmHZe6MSU1IRkuZOTP52Mcaz3S7PDMfa7B3Zg97GflefcjsfPnqpbnt4RU9ztSanPnTxfn8iYc2MRkAAAAAAAAAwNBotUKkn6WjEKluun5VkjO7G6y1biylXJjk9E3zNcnYJD8upXw2yflJbq+1ri2lzEpyXJIPJ5nX6fzNvj7AvwcAAAAAAAAAAP20Yu2GnPTlhXlo+dqGs6NHlZx14nPyR3OmNSEZLWfWrOQf/mErt87KP2zlXka+UaNKPvKK/fL6s6/rde4HNz+SWx9angN2ndqkZAAAAAAAAAAAQ2PUUAcYYD/o9L4keUEpZcde5j+Z5KlO1zUdJVHvS3J9ktWllA1JHk5ybpL5m87tPH9HrfWbA5AdAAAAAAAAAIABsq5tY0792g1Z9MjKPs1/8k8PzNH77jTIqQD+0PPmzcgx+85qOPeZy+9sQhoAAAAAAAAAgKHVUoVItdZbktzeaWlMknf1Mv9Ykg/lD0uOSqfX6E7v66ZXNl2vS/KGAYoPAAAAAAAAAMAAaG+v+cA3b8q1dz/Rp/n3HjM/f3n47oOcCqBnHzpu35TS+8xltz2amx9Y3pxAAAAAAAAAAABDpKUKkTY5K8mvk9yw6efhvQ3XWr+U5KP5w1Kk7l6blSRPJzmx1vrrAUsOAAAAAAAAAEC/1Frz8Utvy3/f+FCf5v/iuXPyvpfOH+RUAL3be6cpOeGgXRvOnXH54iakAQAAAAAAAAAYOi1XiFRr/Xyt9bBOrxP6sOcTSf4iyYPpKDvq6bu2Nn/26yQvqrX+10DlBgAAAAAAAACgf2qt+cfv35YvX720T/NH7TMzn/yzA1NKT4+KADTPe186P6Ma/Dm6YtGy/Oa+3zUnEAAAAAAAAADAEGi5QqStVWv9ZpJ9krwhyTeS3J1kdToKkFYnuTPJOUlOqLU+t9Z6w1BlBQAAAAAAAADg97W313zku7fkK9cs7dP8wbOn5qwTD8mY0R6fAYaHvWZOzp8+Z7eGc2dcfmcT0gAAAAAAAAAADI0xQx1gOKm1Pp3kgk2vJEkpZVSttX3oUgEAAAAAAAAA0Jv29poP/9fNuehX9/dpfo8dJ+ackw7LxHEenQGGl9OPnp/v/fahbGyvPc78YvFjuX7pk3nu3OlNTAYAAAAAAAAA0By+4q4BZUgAAAAAAAAAAMPXxvaaD3zrpj6XIe04aVy++pbDM2PydoOcDGDLzZ0xKa8+ZLeGc5++bHET0gAAAAAAAAAANJ9CJAAAAAAAAAAARqS2je35m2/8Nt/+9QN9mp8wdnTOOemwzJ0xaZCTAWy99xw9P2NGlV5nrlnyRK5d8kSTEgEAAAAAAAAANI9CJAAAAAAAAAAARpwNG9vzvot/m+/+9qE+zW83ZlS++KZD80dzpg1yMoD+mTN9Yl572JyGc2dcvji11iYkAgAAAAAAAABoHoVIAAAAAAAAAACMKOvb2vOeC36TS256uE/zE8aOzpdPOiwvnD9zkJMBDIzTjpqXcaN7f7xv4T1P5polTzQpEQAAAAAAAABAcyhEAgAAAAAAAABgxFjXtjHv+vqv86NbH+nT/MRxo/OVtxyW582bMcjJAAbObtMm5C8Pn9Nw7tOXLU6ttQmJAAAAAAAAAACaY8xQB2i2UsqoJH+U5KAk0ze9piYZnaTWWk8bwngAAAAAAAAAAPRg7YaNeef5N+TKOx7r0/zk7cbkK285LM+dO32Qk7HNW7s2WbKk95m99krGj+9m69osabB3r732yvhu9tLa3vWSebnoV/dnfVt7jzM33Pu7/HzxY3nJPrOamAwAAAAAAAAAYPBsE4VIpZTRSV6b5K1JFiSZ2N1Ykpqkx0KkUsqLkxzcaWlDrfULAxgVAAAAAAAAAIBurN2wMSd/7fpcdefjfZqfMn5MvvrWw3PI7jsMcjJIRxnSgQf2PnPLLckBB3SzdUkObLD3lltuyQHd7KW17Tx1fE48Yvd8+eqlvc6dcdnivHjvmSmlNCcYAAAAAAAAAMAgavlCpFLKO5J8JMkum5f6cdyoJJ9JR3HS5vNvqrVe3Y8zAQAAAAAAAADoxZr1bXn7V6/PNUue6NP81Aljc97bDs9Bs6cNcjKAwfXOl+yVCxfel7Ub2nucufGB5bli0bIcs99OTUwGAAAAAAAAADA4Rg11gMFSSplZSrkkyVlJdk1HEVJJR5lRd6+Gaq1XJrm501lJ8saBTQ4AAAAAAAAAwGar17XlpC//qs9lSDtMHJuvv/0IZUhAS5g1ZXzedOTchnOfvmxxau3TY3AAAAAAAAAAAMNaSxYilVJmJrk6yXH5wxKk5JlCo87FRn31xU0/66a9f15K2dIzAAAAAAAAAABoYOXaDXnzuQuz8J4n+zQ/fdK4XHDyghy429RBTgbQPKe+aM9MHDe615lbH1qRn9z2aJMSAQAAAAAAAAAMnpYrRCqlTE7ywyTz8kwZUvJM+dE9Sb6a5B+TfGYrbvHdLtfTkhy6VWEBAAAAAAAAAOjWirUb8qZzF+b6e3/Xp/kZk7fLRacsyH67bD/IyQCaa8fJ2+XNz5vbcO6Myxanvb02nAMAAAAAAAAAGM5arhApHUVHh6SjCKlzGdKPkjy/1jqv1vqWWus/Jrl4Sw+vtT6Y5PpNZ252TP8iAwAAAAAAAACw2fKnN+SN5yzMb+57qk/zs6Z0lCHtvdOUQU4GMDROeeGembzdmF5nFj2yMj+85ZEmJQIAAAAAAAAAGBwtVYhUStkzyWn5/SKkmuS9tdbja63XDtCtrtr0c/N9FgzQuQAAAAAAAAAA27TlT2/Im865Ljfe37cypF2mjs/Fpx6ZebMmD3IygKGzw6Rxeevz5zac+8zli7OxvTacAwAAAAAAAAAYrlqqECnJXycZt+n95jKkv6m1fnaA73Nzp/clyX4DfD4AAAAAAAAAwDZn+ZoNeeM51+XGB5b3aX63aRNy8SlH5lkzJg1yMoCh97YX7Jkp48f0OnPnslW55KaHmpQIAAAAAAAAAGDgtVoh0ivSUYK0uQzpF7XWMwfhPjd3uX5WKWX0INwHAAAAAAAAAGCb8NSa9TnxnF/mpj6WIc2ZPiEXnbIgu+84cZCTAQwPUyeOzdtfsGfDuTMvvzNtG9ubkAgAAAAAAAAAYOC1TCFSKWW/JHt0Wf7kIN1uWZfrMUlmDtK9AAAAAAAAAABa2lNr1ufEs6/LLQ+u6NP8HjtOzMWnHJk505UhAduWt7xgbqZOGNvrzN2Pr85/3/hQkxIBAAAAAAAAAAyslilESjK/y/WqJD8bpHt191WEUwbpXgAAAAAAAAAALet3q9fn9V+6Lrc+1LcypD1nTMrFpxyZXadNGORkAMPP9uPH5pQX7dlw7syf3pm2je1NSAQAAAAAAAAAMLBaqRBpVpfru2utbYN0r1XdrE0epHsBAAAAAAAAALSkJ1evz+vPvi63PdzHMqSZk3LhKQuy89Txg5wMYPh68/PmZvqkcb3O3PvEmnzn1w82KREAAAAAAAAAwMBppUKkmZ3e1ySPD+K9uis/qoN4PwAAAAAAAACAlvLk6vV5/Zd+mdv7WIa018xJuejkBdlpe2VIwLZt8nZjcuqL9mw49+9X3Jn1be1NSAQAAAAAAAAAMHBaqRCprdP7kmTKIN5rh27WVg3i/QAAAAAAAAAAWsYTq9bl9V/6ZRY9srJP83vNnJQLT1mQWcqQAJIkbzxyj8yYPK7XmQd+93S+cf39TUoEAAAAAAAAADAwWqkQ6aku1zsN4r3262btwUG8HwAAAAAAAABAS3h81bq8/kvX9bkMaf6sybnolCMza4oyJIDNJo4bk3e8eK+Gc2dctjgr1m5oQiIAAAAAAAAAgIHRSoVIS7tc715K2XmQ7vX8LtcP11qfHqR7AQAAAAAAAAC0hI4ypF/mjkf7Voa0906Tc8HJCzJzynaDnAxg5HnDgj0yq8HfxydWr8/nrrirSYkAAAAAAAAAAPqvlQp/YejKAAAgAElEQVSRftvN2isH6V6vSVKTlE0/fzVI9wEAAAAAAAAAaAmPrVyX133xl1n86Ko+ze+z0xRlSAC9GD92dE47al7DuS9ffU+WPr66CYkAAAAAAAAAAPqvZQqRaq2PJblt82U6yoreP9D3KaUcl2SfLss/Gej7AAAAAAAAAAC0imUr1+Z1X/pl7lzWtzKkfXeekgtOPiIzJitDAujNXxw2J7tNm9DrzIaNNZ/8we1NSgQAAAAAAAAA0D8tU4i0ybfSUYS02fxSyscG6vBSypQkn01H4dJmG5J8e6DuAQAAAAAAAADQSpatWJvXffGXuWuLypAWZEdlSAANjR87Oh86bt+Gc5fd9miuvuvxJiQCAAAAAAAAAOifVitE+s8k6ze9r+koR/pIKeWk/h5cStkuydeT7Ll5adM9vlVrXdbf8wEAAAAAAAAAWs1jK9fldV/6ZZY8trpP8/vvsn0uPHlBpk8aN8jJAFrHCQftkkP32KHh3McvuS1tG9ubkAgAAAAAAAAAYOu1VCFSrfXhJJ9LR1lR0lFYNDrJOaWUM0sp07bm3FLK/CRXJnnFpjM325DkY1ufGAAAAAAAAACgNT2xal1OPLvvZUgH7Lp9vv72I7KDMiSALVJKyUdfuX/DuUWPrMzF19/fhEQAAAAAAAAAAFuvpQqRNvlYkrs6Xdd0FCS9O8ldpZQzSikvLKVM7O2QUsoOpZT/VUo5P8mtSY7IM0VLZdO5n6i1Lhnw3wAAAAAAAAAAYAR7cvX6nHj2dVn86Ko+zR+4mzIkgP44eM60vPqQ2Q3n/u0ni7P86Q1NSAQAAAAAAAAAsHVarhCp1ro6yf9KsrzzcjpKjKYnOT3Jz5KsSPL9rvtLKfeUUlYkeTzJN5O8LsmYPFOCtNkPknxy4H8DAAAAAAAAAICR66k16/OGs6/LokdW9mn+2btNzflvOyLTJipDAuiPD758n0wcN7rXmSdXr8/nrrizSYkAAAAAAAAAALZcyxUiJUmt9ZYkL0uyLB1FRklHmdHmYqSSjt99xqbPSqefeySZ3GmudNq7eeaKJK+ttXYuSAIAAAAAAAAA2KYtf3pD3njOwtz28Io+zR80WxkSwEDZafvxeddL9mo495Vrluaex1c3IREAAAAAAAAAwJZryUKkJKm1/irJQUkuyzOFR8kz5UadS47Sy+edi5BKkv9Iclyt9enBSQ4AAAAAAAAAMPKsWLshbzp3YW5+cHmf5g+ePTXnve2ITJ04dpCTAWw73v7CPbPbtAm9zmzYWPPJS29rUiIAAAAAAAAAgC3TsoVISVJrfazW+rIkJydZnGdKjX5vLL0XJG3ec2uSl9Va31Vr3TB4qYdOKWX/UsprSynvK6V8pJTy/lLKm0sph5dSPH0IAAAAAAAAAHRr1bq2nHTuwtx4/1N9mn/2blPztbcdkakTPI4AMJDGjx2dvzt+34Zzl9++LFfd+VgTEgEAAAAAAAAAbJmWLkTarNZ6Tq11vyR/muSiJA/lmaKj3l4rklyY5Pha67NrrZcNQfxBVUqZU0r5l1LKg+kofbo4yRlJPp7kX5J8Jcl1SZ4opZxfSjl8yML2UyllfCllcSml9vA6aagzAgAAAAAAAMBIs3pdW97y5YX59X19K0Paf5ftc97bDleGBDBIXvHsXXLY3B0azn38ktvStrG9CYkAAAAAAAAAAPpuzFAHaKZa638n+e8kKaXsmeTAJDsmmZ5kWpK2dJQg3Z/ktiS311rr0KQdXKWUUUn+NslHkkzow5YpSU5McmIp5bwk76m1Lh/EiIPhH5LMH+oQAAAAAAAAANAq1qxvy1u/8qv8aunv+jS/785Tcv7bj8i0ieMGORnAtquUko++8oC86qz/SW9Pvy1+dFUu/NX9eeOCPZoXDgAAAAAAAACggW2qEKmzWuvdSe4e6hxDoZQyIck3k7xiK494Y5IFpZSX1VrvGbhkg6eU8pwkfzPUOQAAAAAAAACgVTy9fmPe/tXrc909T/Zpfv6syTn/7Udk+iRlSACD7dmzp+bVh8zOt254oNe5T//kjrzqoF0zdeLYJiUDAAAAAAAAAOjdqKEOQHOVUkYn+XZ6LkPakOTGJD9NsjDJqh7m5ie5opSyy4CHHGCllDFJzsk2XAAGAAAAAAAAAANp7YaNOeW863PNkif6NL/XzEm54OQFmTF5u0FOBsBmH3zZPpk4bnSvM79bsyH/fsWdTUoEAAAAAAAAANCYgphtzz8lOa6b9aeS/GOSL9dal29eLKWMTfKqJJ9KsneXPXOTXFhKOabWunFw4g6I9yd5Tqfr9igDAwAAAAAAAICtsq5tY04974ZcdefjfZrfc8akXHjygsycogyJFrb99slrXtN4ptvl7fOaBnu372Ev9GbW9uNz2lHz8i8/vqPXua9eszSvP2L37DVzcpOSAQAAAAAAAAD0rNRahzoDTVJKOTjJDUm6fu3XPUleWmu9u5e9k5J8O8nLuvn43bXWswYs6AAqpeyd5MYk4zstfz7Ju7oZf0ut9SvNyDVQSilHJrmm89o111yTI488cogSAQAAAAAAANDK1re1553n35CfLlrWp/k9dpyYi085MjtPHd94GIABt3bDxhzzbz/Pg0893evcMfvOyjknHdakVAAAAAAAAAAwvF177bV53vOe13X5ebXWa4ciz7Zm1FAHGAillENKKe8spXyslPLZTa+PlVLeVUo5dKjzDSP/lj8sQ1qd5PjeypCSpNa6Osn/SnJrNx//Uyll2H09WCmlJPlSfr8M6cYkZwxNIgAAAAAAAAAYuTZsbM9pF/y6z2VIc6ZPyIUnL1CGBDCExo8dnQ8fv1/DuZ8uWpZfLH6sCYkAAAAAAAAAAHo3ZqgDbK1SyqwkH0nyuiTTG8z+LslFST5Ra32kCfGGnVLKc5Mc081HH6+1LurLGbXWNaWUk5Nc0+Wj6UlOSfLp/qUccKcmeVGn6/Z05GwbmjgAAAAAAAAAMDJtbK9530W/zWW3Pdqn+d2mTcgFb1+QXadNGORkADRy/LN3zuFzp2fh0id7nfv4Jbflh+99YcaMbonvWQQAAAAAAAAARqgR+eRCKeUdSe5KclqSHZOUBq/pSd6Z5K5SynuGIvMwcEo3a08k+eyWHFJrvTbJj7v56OStCTVYSimzk/xzl+Wzaq0LhyIPAAAAAAAAAIxkZ16+OJfe/HCfZneZOj4Xnrwgc6ZPHORUAPRFKSUfPWH/lNL73J3LVuWChfc1JxQAAAAAAAAAQA9GXCFSKeWTSc5KMjkdZUe1j6+SZGKSz5RS/rX5yYdOKWVMktd089HXa61rtuLIL3Wztm8p5ZCtOGuwfCHJ9p2uH0jy90OUBQAAAAAAAABGrJ/c+kj+/Yq7+jS70/bb5cKTF2T3HZUhAQwnB+42NX9+6OyGc5++bHGeWrO+CYkAAAAAAAAAALo3ogqRSilvTvJ3+f0ipL7qXIz0V6WUkwc+4bC1IMkO3ax/eyvPuzTJ092sH7eV5w2oUspfJnlll+V311pXDkUeAAAAAAAAABipljy2Kn/9jRv7NDtzSkcZ0twZkwY5FQBb4/0v2yeTxo3udeapNRty5k/vbFIiAAAAAAAAAIA/NGIKkUops5Ocme6LkEqDV2ebS5H+rZSyx2BmHkaO6mZtTZJrt+awWuvaJNd089HRW3PeQCql7Jjk37ss/1et9XtDkQcAAAAAAAAARqpV69py6nk3ZNW6toazMyaPy4UnH5E9Z05uQjIAtsasKeNz2tHzGs6dd+29uWvZqiYkAgAAAAAAAAD4QyOmECnJXyXZftP7ziVHJclVSf4myYuT7J/kgE3v37/ps66lSEkyKclfD1bYYeawbtZ+U2vd0I8zF3azdkg/zhson0kys9P1yiTvGaIsAAAAAAAAADAi1VrzgW/e2KdCjOmTxuWCkxdk3qwpTUgGQH+89fnPypzpE3qdaWuv+fglt6XWrt9bCAAAAAAAAAAw+EZEIVIpZbskb06y+QmLmo6So0eTvLTW+uJa6xm11qtqrYtqrbdvev/pWuuLk/zxptl02f/GUsr4Jv4qQ+WgbtZu6eeZN3WzNq2Uskc/z91qpZSXJ3lDl+UP11ofHIo8AAAAAAAAADBS/cfP784Pb3mk4dy4MaPylbcclr13UoYEMBKMHzs6Hz5uv4ZzP1/8WH7Uh/8fAAAAAAAAAAAYaCOiECnJS5NM73RdkjyWZEGt9YpGm2utP01yZJInunw0NR1lSS2rlDIuyZxuPrqrn0cv6WF9z36eu1VKKZOT/GeX5euSfH4I4gAAAAAAAADAiHXVnY/lX368qE+zn/qzZ+eg2dMGOREAA+nlB+6cw581veHcP3z/1qxcu6EJiQAAAAAAAAAAnjFmqAP00WGd3pckNcmptdb7+npArfXeUsqpSb69af9mhyf5/oCkHJ7mpPviqwf7eW5P++f289yt9X+S7N7pui3JKbXW9iHK0yellCP7ecSBAxIEAAAAAAAAAJLc/+SavOfC36S9Np5944I98ppDZw9+KAAGVCklH33l/jnhc/+T2svf+0dXrMu//WRx/uFVBzQvHAAAAAAAAACwzRuJhUhJcnut9btbekit9b9KKbcn2bfT8nP7lWz4m9nD+qP9PLen/T3db9CUUp6X5F1dlv+t1npTs7NshWuGOgAAAAAAAAAAJMnT6zfm1PNuyFNrNjScfe4eO+R/v3L/JqQCYDAcuNvUvPbQObn4+vt7nfvatUvz6kNm59mzpzYnGAAAAAAAAACwzRs11AH66FlJapKy6eel/Tjrkk7nlCR79Dvd8Da9h/Xl/Tm01roxyepuPtqxP+duqVLKdknOzu//u3x3kn9sZg4AAAAAAAAAGMlqrfn7/7o5tz28ouHszCnb5fMnHpJxY0bKYycAdOeDL98n0yaO7XWmvSZ//92b8//Yu+8oPcs6f/zve2YyCekECDUQQhJKQoBQBRUBUbFQFUVFsaArCn6xsa64INh1sVBcQVERCy5VdO30XgMJgUAChBAIJISQXuf+/bF6fmt2Zp4nmXmeaa/XOfPHXPf7up53CJ7xnLn43Otayjq1AgAAAAAAAAD6up5yM23910vd34Gz7lvv++EdOKsnGNzG+tJOOLu1gUiDOuHcDXFmkl3XWzulLMsVde4BAAAAAAAAAD3WZXfOztUPzq2Ya2oo8oP3TM7IoQPq0Ap6kEceSYqi/a9HHmlj6yMpiqLdr0fa2Asdsdng/vn8EbtUzD387Cv5+Z1P17wPAAAAAAAAAEDScwciLejAWevvXf/s3qatV3it7YSz17Sy1twJ51alKIrdk5yx3vIvy7L8U706AAAAAAAAAEBPd89TC3Pu76ZXlT3rbbtln9EjatwIgHp5x96jsu/oTSvmvv3nx/PC4pV1aAQAAAAAAAAA9HVNXV2gSgOTlP/r+6UdOGv5et/39lcWNraxvq4Tzm7tjLr8O1UURWOSH+efBz4tTHJ6PT6/Ex3Ywf0Tk1zcGUUAAAAAAAAA6HvmvbIyp/zigaxtKStmj5u8Xd57wA51aAVAvTQ0FPnKMbvnzd+7td2fBUtXrc0510/Phe+ZXMd2AAAAAAAAAEBf1FMGIrHx1rax3hl/962dsaYTzq3G/0uy73prny3L8sU6fX6nKMvyzo7sL4qis6oAAAAAAAAA0MesWrsuH/vF/VmwdFXF7MRth+Yrx0z0e2qAXmj8lkNy8mvH5Ac3zWo39/upz+ftM17MITuPrFMzAAAAAAAAAKAvaujqAtRcW7cWmzvh7NbOqHxLsoOKohiT5Jz1lm9O8pNafzYAAAAAAAAA9BbnXD89Dz6zqGJu04H98p/v3TsD+jXWoRUAXeG0Q8dl1IhNKub+/bppWbF6XR0aAQAAAAAAAAB9lYFIvd+SNtaHdMLZrZ2xuBPOreSSJAP/1/erkny0LMuyDp8NAAAAAAAAAD3eb+6dk1/c/UzFXEORnH/C5Gy36cCKWQB6rk2aG3POkRMr5uYsXJHzb3iiDo0AAAAAAAAAgL7KQKTe76U21od35NCiKAYk6b8Bn9cpiqL4UJJD11v+WlmWM2r5uQAAAAAAAADQWzw0Z1HOvG5aVdkz3rRLXj1u8xo3AqA7OGSXkXnz7ltVzF18y5N5/IW23tMHAAAAAAAAANAxBiL1fvPaWK98c6V9be1v6/M6rCiKrZN8e73lx5J8rVafCQAAAAAAAAC9yYKlq/Kxy+/P6rUtFbNv2X3rfOS1Y+rQCoDu4qy3Tcjg/k3tZta2lPnCNVPT0lLWqRUAAAAAAAAA0Je0f3Oh+3KTonrPJVmVpP9669t38Ny29j/VwXPb84Ykw9dbuzTJ5KIoNuScrdtY36koigNaWX+wLMtVG/IBAAAAAAAAANDdtLSUOf2KKXnulZUVs+O3HJxvvn1SNvD38QD0cFsOHZDPvGF8zr5+eru5e59+OVfe/2yO33dUnZoBAAAAAAAAAH1FTxyIVCS5qxMu3P3jgKIoinUdOKdMcmBZlvd0tFAtlGVZFkUxK8lu6z0a38Gjx7WxPrOD57antb/0b3bi+Wf+/Wt9OyZ5uhM/BwAAAAAAAADq7ke3PZlbn1hQMTdkQFN+eOI+GdS/J14rAaCjTnzV6Fz1wNxMnftKu7mv/uHRHLbryGw2eP139QEAAAAAAAAAbLyGri6wkYoOftX6vO7mwVbW9ujgmXu1svZsWZaVb04CAAAAAAAAAHU19dlX8q0/zagq+9137pkdNx9U40YAdFeNDUW+eszuaahwM27R8jX56n8/Vp9SAAAAAAAAAECf0VMHIpUd/Oqs83qKu1tZ260oimEdOPNVVX4OAAAAAAAAANCFlq5am1N/9UDWrKt81eGTh43LYbtuWYdWAHRnu283LO971eiKuaseeDZ3znqp9oUAAAAAAAAAgD6jpw1E6qxBRD11sNHG+msra41JXr8xhxVFMTLJXlV+DgAAAAAAAADQhc667pE8/dLyirnDdhmZTx42rg6NAOgJPv2G8dlyaP+KuTOvnZpVa9fVoREAAAAAAAAA0Bf0pIFIRTf86hHKsnw0yaxWHr1zI488Pv/3z18m+d1GnleVsix/WpZl0dGvJDu28REfaGPP07X8cwEAAAAAAABArVw3ZW6ueuDZirlth2+S847fMw0NPeY6BAA1NmRAv5z1tgkVc7PmL8vFNz9Zh0YAAAAAAAAAQF/Q1NUFqvSlri5QQeWbg13v8iRnrbd2dFEUo8qynFPtIUVRFEk+3sqjm8qy7An/HAAAAAAAAACgT5izcHnOvGZaxVxDkXzvXXtm2MB+dWgFQE9yxMStcsjOW+TGGfPbzZ1/48y8bY9tMnrzQXVqBgAAAAAAAAD0Vj1iIFJZlt19IFJPcHGSzydp/l9r/ZJ8Ocn7N+CcDyTZpZX1C6o9oCiKp5PssN7y7LIsR29ADwAAAAAAAACgDWvWteS0Xz+YJavWVsyedti47DN6RB1aAdDTFEWRc46amMO/c3NWrmlpM7d6bUu+eN20XPbB/fI/79wDAAAAAAAAANg4DV1dgPooy/K5JJe28uh9RVG8o5oziqIYn+S8Vh5NS3JtB+oBAAAAAAAAAJ3oe399Ig8+s6hibr/RI/KJQ8bWoREAPdWoEQNz2mHjKuZufWJBrn/4+To0AgAAAAAAAAB6MwOR+pYvJlnYyvrPi6I4ob2NRVHsleRvSYa18vi0sizbfv0XAAAAAAAAAFA3d8xakAtvmlkxN3RAU77zrj3T1Oj6CADtO/k1YzJ+y8EVc+dcPz0vL1tdh0YAAAAAAAAAQG/lRlsfUpblgiQfauVR/yS/LIriv4uiOKooii2LomgsimJ4URQHF0VxcZK7k2zXyt7vlGV5Yy17AwAAAAAAAADVeXnZ6nzqiodSlpWz3zhuUrYdvkntSwHQ4/VrbMhXjtm9Ym7B0lX51G+mpKWlih9EAAAAAAAAAACtMBCpjynL8tok/9bG4yOSXJtkXpK1SV5OclOSk5P0ayX/uyRndH5LAAAAAAAAAGBDlWWZz131cOYtXlkxe8J+o3LE7lvXoRUAvcW+o0fknfuMqpi7ccb8/ODmWXVoBAAAAAAAAAD0RgYi9UFlWX4tyelJ1nXgmMuTvL0syzWd0woAAAAAAAAA6IjL734mf5n+QsXcTlsMyhffulsdGgHQ2/zrEbtkxKDmirn/+POM3DnrpTo0AgAAAAAAAAB6GwOR+qiyLL+b5KAk92/g1ueTnFiW5YllWa7q/GYAAAAAAAAAwIaaMW9Jvvy76RVzzY0NOf+EyRnY3FSHVgD0NpsOas4X3rxrxVxLmZz6qwfz4pKVdWgFAAAAAAAAAPQmbrf1YWVZ3p1kn6IoXp/kvUlen2TbVqKLktya5MokV3R0EFJZlqM7sr8TLErypVbWp9S7CAAAAAAAAAB01Mo163Lqrx7IqrUtFbOff/Mu2W2boXVoBUBvdezkbXP9w8/lphnz280tWLoqp/3qwVz+of3T1OjdjQAAAAAAAABAdQxEImVZ/jXJX5OkKIrhSbZJMijJyiQLyrJ8vgvrdbqyLBclOburewAAAAAAAABAZ/jK7x/N4y8srZg7dJeROenA0bUvBECvVhRFzjt+z7zl+7fm+VdWtpu968mF+c5fH89n37hLndoBAAAAAAAAAD2d1y7xT8qyXFSW5fSyLO8ty3JqbxuGBAAAAAAAAAC9yZ8fmZef3zW7Ym6LIf3zrbdPSlEUdWgFQG83YlBzLnj35DQ1VP65cuGNs3LjYy/WoRUAAAAAAAAA0BsYiAQAAAAAAAAA0APNe2VlPnfVw1Vlzzt+j2w2uH+NGwHQl+y9w6b5/Jt3rSp7+m+mZO6iFTVuBAAAAAAAAAD0BgYiAQAAAAAAAAD0MOtaypx+xZQsWr6mYvajrx2T14zbog6tAOhrPnjQ6BwxcauKuUXL1+Tjv3ggq9e21KEVAAAAAAAAANCTGYgEAAAAAAAAANCDLF+9Nmf/9pHc+eRLFbOTthuWT79h5zq0AqAvKooi33j7pIzebGDF7JQ5i/LV/360Dq0AAAAAAAAAgJ7MQCQAAAAAAAAAgB6gLMv86ZF5Ofy8W/Lzu2ZXzA9sbsz33rVXmptcDwGgdoYO6JcL3zO5qp83P73j6fz+4efr0AoAAAAAAAAA6KnceAMAAAAAAAAA6OZmv7QsH/zpvfnoz+/P3EUrqtpz7lETs+Pmg2rcDACSCdsMyzlHTqgqe8ZVD+fJ+Utr3AgAAAAAAAAA6KmauroAAAAAAAAAAACtW7lmXX5w06z84OZZWb22pep9R+25TY6dvG0NmwH/pH//ZLfdKmdaXe6f3Srs7d/GXuhO3rnvqNzz9MJc/cDcdnNLV63NKb94INd+/KAM6NdYp3YAAAAAAAAAQE9hIBIAAAAAAAAAQDd0w2Mv5OzfTs8zC5dv0L5RIzbJl4+emKIoatQM+D/Gjk0eeWQjt47NIxu5F7qToijy5aMnZtrcV/L4C0vbzT42b0n+/bpp+ebb96hTOwAAAAAAAACgp2jo6gIAAAAAAAAAAPz/5ixcnpMvuy8f/Ol9GzwMqbGhyPfetVeGDOhXo3YA0LaBzU256D17Z1BzY8Xsb+57Nv9135w6tAIAAAAAAAAAehIDkQAAAAAAAAAAuoFVa9flghueyOHfuTl/mf7CBu9vbmzIBSfslcnbb1qDdgBQnbEjB+drx02qKvvF66blsXmLa9wIAAAAAAAAAOhJDEQCAAAAAAAAAOhitz4xP0d899Z8+8+PZ+Walg3eP2m7YbnyY6/KEbtvXYN2ALBhjtxjm5x4wA4VcyvXtOSUyx/IkpVr6tAKAAAAAAAAAOgJmrq6AAAAAAAAAABAXzXvlZU593fT8/upz2/U/mGb9Mtn37hzTthv+zQ2FJ3cDgA23plv3TUPPbsoDz/7Sru5Jxcsy79ePTUXnLBXisLPMgAAAAAAAADo6xq6ugAAAAAAAAAAQF/T0lLm8rtm5/Dzbt7oYUjH77Ndbvj0wXnvATsYhgRAt9O/qTEXvntyhg6o/N7G3z/8fC6+5ck6tAIAAAAAAAAAurvKNw0AAAAAAAAAAOg0s+Yvzeevmpp7nl64Uft33Xpovnz0hOy9w4hObgYAnWvUiIE57/g98+HL7quY/dofHsuWQwfk6L22rUMzAAAAAAAAAKC7MhAJAAAAAAAAAKAOVq9tycW3zMr3/zYzq9e1bPD+If2b8uk3jM97D9ghTY0NNWgIAJ3v9bttmY8ePCY/vPnJitnPXvlQNh/cP68et3kdmgEAAAAAAAAA3ZHbcQAAAAAAAAAANTZlzqIcecFt+fafH9+oYUjH7LVt/vaZg3PSQTsahgRAj/PZN+yc/UaPqJhbs67MR39+X6bNfaUOrQAAAAAAAACA7sgNOQAAAAAAAACAGlm+em3O/d30HHvR7Xls3pIN3j9+y8G54iMH5Dvv3DMjhwyoQUMAqL2mxoac/+69svng5orZZavX5aSf3Js5C5fXoRkAAAAAAAAA0N0YiAQAAAAAAAAAUAM3Pz4/b/jOLfnxbU+lpdywvYOaG/OFN++a35/2muw/ZrPaFASAOtpy6IB8/117pamhqJhdsHRV3nfpPVm4bHUdmgEAAAAAAAAA3YmBSAAAAAAAAAAAnejlZavzqSum5P2X3pNnX16xwfvfMmnr/O3Tr8vJrx2Tfo2udgDQexw4dvN847hJVWWfWrAsH/zpvVmxel2NWwEAAAAAAAAA3YlbcwAAAAAAAAAAnaAsy1w3ZW5ef97NufrBuRu8f5thA/KTk/bNhe+enK2GDahBQwDoesftvV0++8adq8pOmbMon/jlA1m7rqXGrQAAAAAAAACA7qKpqwsAAAAAAAAAAPR0cxetyJnXTM2NM+Zv8N6iSN7/qtH5zBt3zuD+rnJAjzRzZnLUUe1nrrsuGTu2la0zc1SFvdddd13GtrIXeqpTXrdTXli8MlkwpsUAACAASURBVJfdObti9m+PvZgzr52Wrx27e4qiqEM7AAAAAAAAAKAruUUHAAAAAAAAALCRFi5bnR/cNDOX3Tk7q9a2bPD+sSMH5xvHTcreO2xag3ZA3axalUyfXjnT6vKqTK+wd1Ube6GnKooiZ71tQuYvWZU/TJtXMf/re+dky6EDcvrh4+vQDgAAAAAAAADoSgYiAQAAAAAAAABsoMUr1+RHtzyZH9/2VJatXrfB+/s1Fvn4IWPzsdftlP5NjTVoCADdW2NDke+8c8+8tPSe3PP0wor57/3tiWw5dEDevf/2dWgHAAAAAAAAAHQVA5EAAAAAAAAAAKq0fPXa/PSOp/PDm5/MKyvWbNQZe20/PN84blLGbzmkk9sBQM8yoF9jLnnfPnnHD+/I4y8srZg/89qp2WJI/xy+25Z1aAcAAAAAAAAAdIWGri4AAAAAAAAAANDdrVq7Lj+9/am89ps35Zt/nLFRw5AGNTfmS0dOyJX/cqBhSADwd8MG9stPP7Bftho6oGK2pUxO/dUDuX/2y3VoBgAAAAAAAAB0BQORAAAAAAAAAADasHZdS66495kc+u2bc/b107Ng6aqNOueQnbfInz91cN5/4Og0NhSd3BIAerZthm+Sn31wvwwZ0FQxu3JNSz70s3sz88WldWgGAAAAAAAAANSbgUgAAAAAAAAAAOtpaSlz3ZS5Ofw7t+SMq6Zm7qIVG3XOiEHN+d679sylJ+2bbYdv0sktAaD32HmrIbnkffukubHytcZFy9fk/ZfekxcXr6xDMwAAAAAAAACgngxEAgAAAAAAAAD4u7Is85fpL+TN3781n/z1lDy1YNlGn3Xs5G3z108dnKP23DZFUXRiSwDonQ4Ys1m++649U82PzbmLVuT9P7k3S1auqX0xAAAAAAAAAKBuDEQCAAAAAAAAAEgyY96SHPuDO3LyZfflsXlLNvqcfXbYNFd85ICcd/yeGTGouRMbAkDv9+bdt85Zb92tquyjzy/Ox3/5YFpayhq3AgAAAAAAAADqpamrCwAAAAAAAAAAdLU/TpuX06+YkhVr1m30GRO2GZrPvHHnvG78FimKohPbAUDfctJBO2be4lX5z5tnVcze8vj8XHr7U/nwa8bUoRkAAAAAAAAAUGsGIgEAAAAAAAAAfVZZlrnopln51p9mbPQZY0cOzqcOH583TdgqDQ0GIQFAZzjjTTvnxcUrc/WDcytmv/nHGXnNuC2y81ZD6tAMAAAAAAAAAKglA5EAAAAAAAAAgD5p1dp1+fzVU3P1A5UHLbRmu003yemvH5+j99o2jQYhAUCnKooi33j7pMxfuiq3PrGg3ezqdS355K8fzHWfOCj9mxrr1BAAAAAAAAAAqIWGri4AAAAAAAAAAFBvC5auynsuuXujhiGNHNI/5x49MTd8+nU5bu/tDEMCgBrp19iQH7x370zcdmjF7GPzluS8Pz9eh1YAAAAAAAAAQC0ZiAQAAAAAAAAA9Ckz5i3J0Rfenvtmv7xB+zYd2C9fePOuueVzh+TEA3ZIc5NrFwBQa4P7N+UnJ+2XbYdvUjF78a1P5q4nX6pDKwAAAAAAAACgVtzMAwAAAAAAAAD6jBsfezHH/eCOPPvyiqr3DOnflNNfPz63fO6QnPzaMRnQr7GGDQGA9W0xpH/OO36PFEX7ubJMPv2bh7J45Zr6FAMAAAAAAAAAOp2BSAAAAAAAAABAr1eWZX5065P50M/uzdJVa6ve975X7ZBbPndIPvn6cRkyoF8NGwIA7dl/zGb5yGvHVMzNXbQiZ//2kTo0AgAAAAAAAABqwUAkAAAAAAAAAKBXW722Jf92zdR8+fePpqWsbk+/xiLfPG5SzjlqYjYd1FzbggBAVT51+PjsuvXQirmrH5ib/576fB0aAQAAAAAAAACdzUAkAAAAAAAAAKDXWrR8dd536d351T1zqt6z6cB+ufxD++f4fUfVsBkAsKH6NzXmu+/cM81Nla8+/ts1U/PC4pV1aAUAAAAAAAAAdCYDkQAAAAAAAACAXmnW/KU5+sLbc9eTC6veM3bk4Fz78YOy/5jNatgMANhYO281JJ97484Vc4uWr8ln/uuhlGVZh1YAAAAAAAAAQGcxEAkAAAAAAAAA6HVue2JBjrnw9jz90vKq97x2/Ba5+pQDs8Nmg2rYDADoqA8etGMO3Kny8MJbn1iQy+6cXYdGAAAAAAAAAEBnMRAJAAAAAAAAAOhVLr9rdt7/k3uyeOXaqvecdODoXPr+fTJ0QL8aNgMAOkNDQ5Fvv2OPDB3QVDH71f9+NDNfXFKHVgAAAAAAAABAZzAQCQAAAAAAAADoNX5x9+ycee20rGspq8o3NhQ59+iJOfvICWlqdI0CAHqKbYZvknOPnlgxt2ptS/7fFVOyem1LHVoBAAAAAAAAAB3lJh8AAAAAAAAA0CvMfHFJvvTb6VXnhw5oys8+sF9OPGCHGrYCAGrlqD23zZF7bFMxN23u4nz/b0/UoREAAAAAAAAA0FEGIgEAAAAAAAAAPV5LS5kzrpqa1etaqsqP3mxgrvn4QXn1uM1r3AwAqKVzj5qYrYcNqJi76KaZuX/2wjo0AgAAAAAAAAA6wkAkAAAAAAAAAKDH+/lds3P/7Jeryh4wZkSuOeWg7LTF4Bq3AgBqbdjAfvn2O/aomGspk9OveChLV62tQysAAAAAAAAAYGMZiAQAAAAAAAAA9GhzF63IN//4WFXZE/Yblcs+uH82HdRc41YAQL0cNHbzfOjVO1bMPbNwec69fnodGgEAAAAAAAAAG8tAJAAAAAAAAACgxyrLMmdeMzXLVq9rN1cUyZlv2TVfPWb3NDe5LgEAvc1n37hzxm85uGLuivvm5M+PzKtDIwAAAAAAAABgY7jhBwAAAAAAAAD0WL996LncOGN+xdxJB47Oh18zJkVR1KEVAFBvA/o15rvv3Cv9Giv/rP/81VMzf8mqOrQCAAAAAAAAADaUgUgAAAAAAAAAQI+0cNnqfOn66RVz2w7fJJ95w851aAQAdKXdthmaT1fxM/+lZatzxlUPpyzLOrQCAAAAAAAAADaEgUgAAAAAAAAAQI907u+mZ+Gy1RVzXz129wzq31SHRgBAVzv5NWOy3+gRFXM3PPZi/vPmJ+vQCAAAAAAAAADYEAYiAQAAAAAAAAA9zk0zXsw1D86tmDt2r21z8Pgt6tAIAOgOGhuK/Mfxe2RwFcMQv/HHx/L7h5+vQysAAAAAAAAAoFoGIgEAAAAAAAAAPcrSVWvzhWumVcxtNqg5X3zrbnVoBPR5EyYkZdn+14QJbWydkLIs2/2a0MZeoHWjRgzMl46s7n83p/9mSu6f/XKNGwEAAAAAAAAA1TIQCQAAAAAAAADoUb79pxmZu2hFxdxZR07IpoOa69AIAOhujp28bY6YuFXF3Oq1LTn5svsy+6VldWgFAAAAAAAAAFRiIBIAAAAAAAAA0GPcP/vl/OzOpyvmDt1lZN42aeua9wEAuqeiKPLVY3bPyCH9K2YXLludD/z03ixavroOzQAAAAAAAACA9hiIBAAAAAAAAAD0CKvWrsu/XvVwyrL93OD+Tfny0RNTFEV9igEA3dKmg5rzvXftlaaGyv+f4Mn5y/KRn9+fVWvX1aEZAAAAAAAAANAWA5EAAAAAAAAAgB7hBzfNyhMvLq2YO+NNO2eb4ZvUoREA0N29aqfN8vXjJlWVveephfnXq6amrDR9EQAAAAAAAACoGQORAAAAAAAAAIBu7/EXluTCG2dWzO2zw6Z5z/471KERANBTvH3v7XLaoWOryl7z4Nx8569P1LgRAAAAAAAAANAWA5EAAAAAAAAAgG5tXUuZM656OGvWle3mmhsb8vXjJqWhoahTMwCgpzj98PE5es9tqsp+/29P5Mr7n61xIwAAAAAAAACgNQYiAQAAAAAAAADd2mV3Pp0Hn1lUMXfqoWMzduTg2hcCAHqcoijyjbdPyn47jqgq//mrH84dsxbUuBUAAAAAAAAAsD4DkQAAAAAAAACAbuvZl5fnW3+aUTG3y1ZD8tGDd6pDIwCgp+rf1JiLT9w7YzYfVDG7Zl2Zj/78/sx8cUkdmgEAAAAAAAAA/2AgEgAAAAAAAADQLZVlmS9cMy3LV69rN9dQJF8/blKam1yDAADaN3xgc37ygX0zYlBzxeySlWtz0k/uzfwlq+rQDAAAAAAAAABIDEQCAAAAAAAAALqpa6fMzc2Pz6+Y+8BBO2bPUcPr0AgA6A122GxQLnnf3lUNU3z25RX58GX3ZUWFAY0AAAAAAAAAQOcwEAkAAAAAAAAA6HZeWroq51w/vWJuu003yaffML4OjQCA3mTvHUbkO8fvWVX2oTmLcvoVU9LSUta4FQAAAAAAAABgIBIAAAAAAAAA0O2c87vpeXn5moq5rx6zewY2N9WhEQDQ27xl0tY54027VJX94yPz8rU/PFrjRgAAAAAAAACAG4EAAAAAAAAAQLdy2xMLct2U5yrmjpu8XV47fos6NAKoYM6c5FOfaj9z3nnJqFGtbJ2TT1XYe95552VUK3uBjvuXg8fkmYXL8qt75lTMXnLrU9l+xMCc+KrRtS8GAAAAAAAAAH2UgUgAAAAAAAAAQLdRlmX+4y8zKuY2H9ycL7511zo0AqjC4sXJlVe2nzn77Da2Ls6VFfae3cZeoOOKosg5R03Msy+vyK1PLKiYP+u3j2TYwOYcucc2dWgHAAAAAAAAAH1PQ1cXAAAAAAAAAAD4h9tnvpQHn1lUMXf2kRMyfGBzHRoBAL1dv8aGXPSeydllqyEVsy1lctqvHsyFN85MWZZ1aAcAAAAAAAAAfYuBSAAAAAAAAABAt/H9G56omHn9riPzlt23rkMbAKCvGDKgXy49ad+MHNK/qvy3/jQjn73y4axe21LjZgAAAAAAAADQtxiIBAAAAAAAAAB0C3c9+VLueWphu5lN+jXm3KMnpiiKOrUCAPqKbYZvkktP2jcDmxuryl95/7M58cd3Z9Hy1TVuBgAAAAAAAAB9h4FIAAAAAAAAAEC3cP4NT1TMvPeA7bP1sE3q0AYA6Ismbjss55+wVxqqnL1491MLc+xFd+SpBctqWwwAAAAAAAAA+oimri5A91EUxW5JJibZJsngJCuTzE/yaJIHy7Jc04X1KiqKoiHJ9n//GpVk0ySDkvRLsjjJoiQvJHmgLMv5XdUTAAAAAAAAgP/r/tkv5/aZL7Wb6d/UkJNfO6ZOjQCAvuqwXbfMWW+bkLN++0hV+ScXLMsxF92ei0/cJ/vtOKLG7QAAAAAAAACgdzMQqY8rimJUktOSvDv/MwipLUuKovhtku+XZXlPXcq1oyiKIsluSQ5KckCSSX//vqrXgBZFMSfJ9UkuLcvy/lr1BAAAAAAAAKA659/wRMXMCfttn5FDBtShDQDQ173/wNF5ZcWanPeXx6vKL1q+Ju/50V35xnGTcuzk7WrcDgAAAAAAAAB6r4auLkDXKIqioSiKf0syI8ln0v4wpCQZkuQ9Se4uiuKyoiiG1bpjBZclmZbkh0k+kGTvVDkM6e9GJTklyX1FUdxUFMWunV8RAAAAAAAAgGo8NGdRbpoxv91Mc2NDPnrwmDo1AgBITjtsXP7jHXukX2NRVX7NujKf+s1DOe/PM1KWZY3bAQAAAAAAAEDvZCBSH1QUxSZJfpvkK9mwIUL/cGKSe4ui2LFTi22Yfp141sFJphRF8YlOPBMAAAAAAACAKp1/w8yKmXfss122HrYxv+IGANh4x+29XS7/0P4ZPrD6K2vfv2FmPvnrKVm5Zl0NmwEAAAAAAABA72QgUh9TFEVjkquSvKWNyJokDyX5W5J7kixtIzcuyQ1FUWzd6SU7bk2SmUnuS3JDklvzP3+mZe3saU5yflEUZ9S+HgAAAAAAAAD/8Mhzr+Svj77QbqapocjHXrdTnRoBAPyz/cdslmtOOSg7bj6o6j2/fei5vOdHd+elpatq2AwAAAAAAAAAeh8Dkfqec5Ic0cr6oiSnJ9miLMs9y7J8fVmW+ycZkeTtSR5vZc/oJL/6+5ClrvRwkguTvCvJ+CQDy7IcV5blvmVZHlaW5WvLstwzydAkk5J8PckrbZz19aIoDqlLawAAAAAAAABywQ0zK2aOm7xdttt0YB3aAAC0bsfNB+Xqjx2Y/XYcUfWe+2e/nKMvuj0zX1xSw2YAAAAAAAAA0LsYiNSHFEWxR5IzWnn0VJK9y7L8blmW/zQoqCzLNWVZXpVkcpI/tbL34CT/0ullK7snyalJti/Lco+yLD9RluUVZVk+UZbl2tY2lGXZUpbl1LIsP59klyQ3tnH2Jd1gyBMAAAAAAABAr/f4C0vyh2nz2s00NhQ55ZCd6tQIAKBtmw5qzuUf2j/HTd6u6j1zFq7IMRfdkdtnLqhhMwAAAAAAAADoPQxE6lv+I8n6g36WJXlzWZZPtrexLMtlSY5N8kgrj88pimJw51SsTlmW55VleUFZlnM2cv+8JG9Jcn8rj3dKckhH+gEAAAAAAABQ2QU3zKyYOWqPbbLDZoPq0AYAoLLmpoZ8+x2T8pk3jK96z5KVa/P+S+/JL+9+pobNAAAAAAAAAKB3MBCpjyiKYp8kh7Xy6NyyLB+r5oyyLJcnObmVRyOSfKQD9bpEWZYrkpzaxuNj69kFAAAAAAAAoK+ZNX9pfvfwc+1miiL5+KFj69QIAKA6RVHkE4eOy/kn7JXmpuquYa5tKfNv10zNv183LWvWtdS4IQAAAAAAAAD0XAYi9R2tDSx6Kcn5G3JIWZZ3JvlTK49aG5TU7f39z/N0K4+qf30XAAAAAAAAABvswhtnpqVsP/PWSdtkpy0G16cQAMAGetse2+RXJx+QzQY1V73nsjtn58Qf352Fy1bXsBkAAAAAAAAA9FwGIvUBRVE0JXl7K49+UZbl8o048pJW1nYpimLyRpzVHUxvZW3rurcAAAAAAAAA6COeeWl5rpvyXMXcJw4ZW4c2AAAbb+8dNs21Hz8o40ZWP8TxricX5sgLbsujzy+uYTMAAAAAAAAA6JkMROobDkiyaSvrV23keb9PsqKV9SM28ryu9koray11bwEAAAAAAADQR1x008ysaynbzbxpwlbZeashdWoEALDxRo0YmCs/dmBeM27zqvc8+/KKHHvRHfnD1Odr2AwAAAAAAAAAeh4DkfqGQ1pZW57kzo05rCzLlUnuaOXRoRtzXjcwspU1t0wAAAAAAAAAauDZl5fnqgeerZg79bCxdWgDANA5hm3SL5eetG9O2G/7qvesWLMuH/vFAznvL4+npcKwSAAAAAAAAADoKwxE6hv2bWXtwbIs13TgzHtaWZvcgfO6RFEUzUn2a+XR7fXuAgAAAAAAANAX/OfNs7JmXfv/wf/rdx2ZCdsMq1MjAIDO0a+xIV89ZmLOfMuuKYrq933/b0/kY7+4P8tWra1dOQAAAAAAAADoIQxE6hsmtbI2rYNnPtzK2vCiKHbo4Ln19oEkQ9Zba0nyyy7oAgAAAAAAANCrzXtlZX5z77MVc6ceOq4ObQAAOl9RFPnwa8bkx+/fJ0P6N1W970+PvJBjL7ojz7y0vIbtAAAAAAAAAKD7MxCplyuKojnJqFYezezg0bPaWB/TwXPrpiiKvZN8o5VHPy/L8ol69wEAAAAAAADo7X54y6ysXtfSbubg8Vtkj1HD69QIAKA2Dt1ly1zz8QOz4+aDqt4z44UlOfLC23LHzAU1bAYAAAAAAAAA3Vv1rx+ipxqV1gdfze3guW3tH93Bc2vu70OiPprkK0mGrPf4sSSfrGOXV3XwiImdUgQAAAAAAACgxl5csjK/vPuZirnTDhtbhzYAALU3duSQXHvKQTn11w/mlsfnV7Vn0fI1OfHSe/Lvb90t73vVDimKosYtAQAAAAAAAKB7MRCp99uijfUXOnhuW/vb+ry6KIpiryT911tuzv8MPtoxyd5JjkwyopXt9yY5sizLV2pa8p/dUcfPAgAAAAAAAOgyP7r1qaxa29Ju5sCdNsveO7T261wAgJ5p2MB++clJ++brf3g0l9z6VFV71rWUOeu3j2T6c4tzztET0r+pscYtAQAAAAAAAKD7MBCp92vrpmiHhv6UZbmuKIplSQat92izjpzbCa5JssMG7pmf5NtJzivLcm3nVwIAAAAAAADo2xYuW53L75pdMXfaYePq0AYAoL4aG4p84S27ZZethubz10zN6gpDIv/hivvmZOb8pfnP9+6dLYas/55AAAAAAAAAAOidGrq6ADU3uI31pZ1w9rJW1tYfkNSdLUjyL0lGl2X5TcOQAAAAAAAAAGrjx7c9meWr17Wb2W/0iBwwpqvfwQMAUDvH7b1dfvPRV2XkBgw3un/2yznqgtsya35nXPkDAAAAAAAAgO7PQKTer18b650x/GdNK2vNnXBuvWye5MIk1xZF8cauLgMAAAAAAADQGy1avjo/u2N2xdyph42tQxsAgK6156jhuf7UV2fPUcOr3vPcKyvz7kvuytMLWnuHIQAAAAAAAAD0Lk1dXYCaa2xjvf1Xb1antTN62r9TjUkOT3J4URTXJ/lwWZYv1vHzD+zg/olJLu6MIgAAAAAAAAC18JPbn87SVe2/s2ev7Yfn1WM3r1MjAICuteXQAfn1Rw7IF66ZlqseeLaqPS8sXpUTLrkrV3zkVdl+s4E1bggAAAAAAAAAXaenDa9hw7V1q7Qz/u5bO2NNJ5y70cqyHL3+WlEUg5IMSzI+yX5J3plkcivb35bk9qIoDinLsrpbJh1UluWdHdlfFEVnVQEAAAAAAADodItXrslPbn+qYu60Q8f5/ScA0KcM6NeYb79jUnbbZmi+8vvpaSkr73n+lZU54ZK78uuPHJBRIwxFAgAAAAAAAKB3aujqAtTcqjbWmzvh7NbOaOvzukxZlsvKsnyuLMubyrL8ZlmWeyd5XZLHW4mPTfL7oig6458PAAAAAAAAQJ/209ufzuKVbb3H53/svu2wvG7nLerUCACg+yiKIh969Y752Qf3y7BN+lW1Z+6iFTnhkrsyd9GKGrcDAAAAAAAAgK5hIFLvt6SN9SGdcHZrZyzuhHNrrizLm5NMTnJbK48nJfl8fRsBAAAAAAAA9C5T5izKBTfMrJg79dCxKYqiDo0AALqn14zbItd9/KCMHTm4qvyzL6/Iuy+5K8+/YigSAAAAAAAAAL1PU1cXoOZeamN9eEcOLYpiQJL+G/B53U5ZlsuKonhrkhlJtlzv8WlFUXyrLMvlXVANAAAAAAAAoEd7aemqnHL5/Vm9rqXd3C5bDcnhu63/61qAHminnZJp0ypnWl3eKdMq7N2pjb1A7zF680G55pQDc8ovHsitTyyomJ/90vK8+5K78+uPHJAthw6oQ0MAAAAAAAAAqA8DkXq/eW2sb9XBc9va39bndUtlWb5SFMXZSX6w3qMRSd6Q5Nq6lwIAAAAAAADowda1lPnkr6fkuVdWVsyeeui4FEVRh1YANTZgQDJhwkZuHZAJG7kX6F2GDOiXS963T06+7L6qhiI9tWBZTrjkrvz6Iwdk5BBDkQAAAAAAAADoHRq6ugA191ySVa2sb9/Bc9va/1QHz+0K/5VkXSvrr653EQAAAAAAAICe7ry/zMhtMyv/B/zjRg7OERM7+i4fAIDeZUC/xlx84j45cKfNqso/OX9Z3nPJ3VmwtLVrggAAAAAAAADQ8xiI1MuVZVkmmdXKo/EdPHpcG+szO3hu3ZVl+VKSp1t51NGhUQAAAAAAAAB9yp8fmZcLb2ztV9T/rCiSLx05IQ0N/x979x1mV13nD/x9ZjKZSTLpvUFIQgih9wREpIkFZC1gwV7Whu66ti0/19XdVdd1de2udVHBXcWOIoiCIAktoScESINAep1MMjOZmfP7g8AiDpmZZEqSeb2e5z4z95zP93vel7+Y3HPft+iBVAAA+5cB/SvzzTecmFMOGdGh+YfWbssl37g1G+ubujkZAAAAAAAAAHQ/hUh9w51tHDtmL/c8ro1jK8uybP9rPvdN69o4NrzHUwAAAAAAAADsp5atr8/7f3h3h2bfd86MnDp9VDcnAgDYfw3s3y/ffuNJOWlKx25jW7ymLpd889ZsUooEAAAAAAAAwH5OIVLfcGsbx2YVRTF0L/ac08Hr7C8GtXHMnSEAAAAAAAAAHbC9qTnv+N781DU2tzt71swxufTM6T2QCgBg/zaoul++86aTc/xBwzo0v2jV1rz2W7dmy/ad3ZwMAAAAAAAAALqPQqS+4bo2jlUmOWdPNiuKYkyS4zp4nX1eURRFkoltnFrT01kAAAAAAAAA9jdlWebvfnJvFq+pa3f2oBED87mLj01FRdEDyQAA9n+11f3y328+OcdM7lgp0v2Pb83rvn1rtuxQigQAAAAAAADA/kkhUh9QluWiJEvaOPXKPdzy4iTPvDu1THLVHu7X205MMqKN4wt7OggAAAAAAADA/uayucvz87seb3euul9Fvvra4zN0YFUPpAIAOHAMqanKd998co6aOLRD8/es3JI3fPu21DUoRQIAAAAAAABg/6MQqe/4fhvH/qIoismd2aQoiiLJu9s4dUNZliv3KFnve/uzHL+hJ0MAAAAAAAAA7G/uWL4x//KrRR2a/cRLj8oREzr2IX4AAP7U0AFV+d5bTs6s8UM6NH/Xo5vzxu/cnm2Nzd2cDAAAAAAAAAC6lkKkvuPrSZqecawqyb90cp83JZnZxvEvdXSDoiiWF0VRPuOxvJM5ukRRFM9L8uY2Tj1YluUdPRwHAAAAAAAAYL+xtq4h77p8QZpby3ZnXzv7oLz8hEk9kAoA4MA1bGD/XP7WUzJz3OAOzc9fsSnv/P78tHTg/9cAAAAAAAAAYF+hEKmPKMvy8STfbuPU64uiuKgjexRFMSPJZ9s4dV+Sn+1FvE4piuKyXUVGe7vPOUl+maRo4/Qn93Z/AAAAAAAAgAPVzpbWXHrFnVlb19ju7LGT/hkOtwAAIABJREFUh+Uj58/qgVQAAAe+4YOeKEWaMba2Q/M3PbQ+l9+6optTAQAAAAAAAEDXUYjUt3wkycY2jn+vKIpX725hURTHJfldkqFtnH5vWZatXZCvo85Icn1RFPOKonhPURQTOrO4KIpZRVFcluTaJG3dFXJjku92QU4AAAAAAACAA9Knf/NAblvW1tvPf2rkoP756muPT3W/yh5IBQDQN4ysrc7lb52daaMHdWj+369ZnHUdKLIEAAAAAAAAgH2BQqQ+pCzL9Une0sap6iRXFEXx66IoLiyKYmxRFJVFUQwriuKMoii+nuTWJJPaWPu5siyv787cuzE7yReSrCyK4r6iKL5fFMUHiqJ4dVEULyqK4jlFUZy56zW9oyiKrxRFcXeS+5O8PknRxp7LkryyhwueAAAAAAAAAPYbv7pnVb5x07J25yqK5IuvPi7jhw7ogVQAAH3L6MHV+cHbZmfqqPZLkeoamvOpqx/ogVQAAAAAAAAAsPf69XYAelZZlj8riuLvk3yijdMv3PXoqKuSfLhLgu2dIskRux6X7MU+dya5oCzL1V2SCgAAAAAAAOAA8/Daunzwyrs7NPvB82bm1OmjujkRwD5i7drkK1/Z/cy73pWMGdPG0rX5Sjtr3/Wud2VMG2uBvm3MkJpc8bbZeeXX52XFhu27nf3xgpV51cmTc9KUET2UDgAAAAAAAAD2jEKkPqgsy08WRbEjyWeSVO7hNt9P8tayLHd2XbJesyPJx5N8pizL5t4OAwAAAAAAALAvqmvYmb/83vxsb2ppd/a8I8bmHWdM7YFUAPuIdeuSj31s9zMXXdRmIdK6devysXbWXnTRRQqRgDaNG1qTH7xtdl7x1bl5fEvDbmc/8rP7ctV7npN+lRU9lA4AAAAAAAAAOs+72n1UWZb/meS0JPM7uXRVkteVZfm6siwbuz5Zh7whyWeTLNrLfZYl+ViSw8qy/JQyJAAAAAAAAIC2lWWZD115T5auq293duqoQfn3i45JURQ9kAwAgAnDBuTjFx7Z7twDq+ty2bwVPZAIAAAAAAAAAPZcv94OQO8py/LWJCcWRXFOktcmOSfJxDZGNye5KcmVSf53b4uQyrKcspfr/5DkD0neXxTF6CSnJDkpyYwkU5JMSjI4yaAkLUm27npsSHJvkgVJbk9yR1mW5d5kAQAAAAAAAOgL/uvGpbn6vtXtzg2oqszXXndChtRU9UAqAACedM6ssTnn8DG5btHa3c597rcP5vyjx2fskJoeSgYAAAAAAAAAnaMQiZRleV2S65KkKIphSSbkiTKhhiTry7Jc1Yvxdqssy3VJrtr1AAAAAAAAAKCLXTl/ZT519QMdmv23VxydGWMHd3MiAADa8tELjshND61PY3Prs85sa2zOv/5qUb7w6uN6MBkAAAAAAAAAdFxFbwdg31KW5eayLBeWZXl7WZb37stlSAAAAAAAAAB0r1/dsyofuvLuDs2+6bQpeckxE7o5EQAAz2byiIF595nT2537xd2PZ+6S9T2QCAAAAAAAAAA6TyESAAAAAAAAAPBnfv/AmvzV/9yZ1rL92RMPHp6/f9Hh3R8KAIDd+svnTs2UkQPbnfvHn9+fpubWHkgEAAAAAAAAAJ2jEAkAAAAAAAAA+BNzl6zPO76/IM0daEMaPbg6X7nk+FRVugUBAKC31VRV5p9eckS7cw+v3ZZv37ysBxIBAAAAAAAAQOe4GxEAAAAAAAAAeMr8FZvy1svuSFNza7uzlRVFvvya4zNmSE0PJAMAoCOed9iYvOCIce3OfeF3D+XxzTt6IBEAAAAAAAAAdJxCJAAAAAAAAAAgSXL/41vyxu/clu1NLR2a/+RLj8rJh4zo5lQAAHTWRy6YlQFVlbud2d7Ukn/51cIeSgQAAAAAAAAAHaMQCQAAAAAAAADIw2vr8vpv3Za6huYOzf/j+bNy8UmTuzkVAAB7YuKwAXnP2dPbnfv1vatz44PreiARAAAAAAAAAHSMQiQAAAAAAAAA6OMe2bA9l3zz1myob+rQ/AeePyNvfs4h3ZwKAIC98dbnTM200YPanfvoL+5PY3NLDyQCAAAAAAAAgPYpRAIAAAAAAACAPmzVlh255Fu3ZM3Wxg7Nv/N50/LuM6d3cyoAAPZW/34V+fiFR7Y7t2x9fb5x49IeSAQAAAAAAAAA7VOIBAAAAAAAAAB91Pptjbnkm7fm0Y07OjT/hjkH50PnHZaiKLo5GQAAXeG06aNy/tHj25370vUP59GN23sgEQAAAAAAAADsnkIkAAAAAAAAAOiDtmzfmdd967YsXVffoflXnDApH73gCGVIAAD7mf/34lkZ1L9ytzMNO1vz8asW9lAiAAAAAAAAAHh2CpEAAAAAAAAAoI/Z1ticN3zntixatbVD8y8+anz+7eVHp6JCGRIAwP5m3NCavO/cGe3O/Xbhmvz+gTU9kAgAAAAAAAAAnp1CJAAAAAAAAADoQxp2tuStl92eux7d3KH5s2aOyedeeWwqlSEBAOy33nDqlMwYW9vu3Ed/cX8adrb0QCIAAAAAAAAAaJtCJAAAAAAAAADoI5qaW/PO78/PLUs3dmh+ztSR+colx6d/P7cXAADsz6oqK/LPFx7Z7tyjG3fkqzcs6YFEAAAAAAAAANA2dywCAAAAAAAAQB/Q0lrmr//3zly/eF2H5o8/aFi++YYTU1NV2c3JAADoCadMHZmXHTex3bmv/mFJVmyo74FEAAAAAAAAAPDnFCIBAAAAAAAAQB/wL79amF/fu7pDs7PGD8l33nRyBlX36+ZUAAD0pL990cwMbuf/8ZqaW/PRX9yfsix7KBUAAAAAAAAA/B+FSAAAAAAAAABwgPveLSvynZuXd2h2+pjafO8tJ2fogKruDQUAQI8bM7gm73/+jHbnbli8Llff17EyTQAAAAAAAADoSgqRAAAAAAAAAOAAduOD6/JPv7i/Q7OTRwzI999ySkbWVndzKgAAestrZx+cWeOHtDv34R/fk+Xr63sgEQAAAAAAAAD8H4VIAAAAAAAAAHCAemhNXd59+YK0tJbtzo4bUpMr3jo744bW9EAyAAB6S7/KivzzXxzZ7lxdQ3Pe8f352dHU0gOpAAAAAAAAAOAJCpEAAAAAAAAA4AC0YVtj3nzZ7alrbG53dlRt/1z+tlMyecTAHkgGAEBvO+Hg4bn4xEntzj2wui5//9N7U5btF2wCAAAAAAAAQFdQiAQAAAAAAAAAB5jG5pa8/Xvz8+jGHe3ODupfmcvefHKmja7tgWQAAOwrPvyCmRk6oKrduZ/e+Vi+d8uKHkgEAAAAAAAAAAqRAAAAAAAAAOCAUpZl/vbH9+aOFZvana0oki+95vgcMWFoDyQDAGBfMrK2Ov/0klkdmv34Lxdm/oqN3ZwIAAAAAAAAABQiAQAAAAAAAMAB5Uu/fzg/vfOxDs1+5PxZOXPmmG5OBADAvuqlx03KJacc1O5cc2uZd12+IOvqGnsgFQAAAAAAAAB9mUIkAAAAAAAAADhAXHXP4/mP3z7YodnXzj4obzx1SvcGAgBgn/ePF8zKMZOHtTu3ZmtjLr1iQZpbWnsgFQAAAAAAAAB9lUIkAAAAAAAAADgA3PnIprz/h3d3aPb0Q0flny44IkVRdHMqAAD2ddX9KvPVS47PiEH92529ddnGfPqaxT2QCgAAAAAAAIC+SiESAAAAAAAAAOznVm7anrd9d34am1vbnT10TG2+fMnx6VfplgEAAJ4wYdiAfPHVx6WiA32ZX79xaX5976ruDwUAAAAAAABAn+TuRgAAAAAAAADYj9U17MxbL7sj67c1tjs7YlD/fOsNJ2VITVUPJAMAYH9y2vRR+cB5h3Vo9oM/ujsPr63r5kQAAAAAAAAA9EX9ejsAAAAAAAAAALBnWlrLvPcHd+aB1e1/GL1/ZUW+/roTctDIgT2QDKCPmTQp+eEP259p8/Ck/LCdtZOeZS1AV3vnGdNy1yObc+3CNbudq29qydu/Nz8/v/Q5qa12KyoAAAAAAAAAXce70AAAAAAAAACwn/qXXy3M9YvXdWj20684OidOGdHNiQD6qKFDk4su2sOlQ3PRHq4F6GpFUeQzFx+TC790c5atr9/t7JJ19fnQlXfny685PkVR9FBCAAAAAAAAAA50Fb0dAAAAAAAAAADovO/dsiLfuXl5h2bfe9b0/MVxE7s3EAAAB4QhNVX52mtPyICqynZnf33v6nzzpmU9kAoAAAAAAACAvqJfbwcAAAAAAAAAgL3R2NySjfVNWV/XlPX1jdmwrSmb6ptSVVlkyqhBmTVhSMYMruntmF3qxgfX5Z9+cX+HZs8/enzed+6Mbk4EAMCB5LBxg/Oplx+Vv/qfu9qd/dRvHshRk4Zm9tSRPZAMAAAAAAAAgAOdQiQAAAAAAAAA9kmb6pvy4Jq6rN/WlA31jU/83NaY9dueKD3aUN+U9dsaU9fQ3O5eowdXZ9b4ITliwpDMmjAks8YPyZSRg1JRUfTAK+ladz26Oe++fEFaWst2Z4+dPCyfueiYFMX+9zoBAOhdFx47MXc9ujnfuXn5budaWstcesWCXPWe0zNu6IFVRAoAAAAAAABAz1OIBAAAAAAAAMA+Y9n6+lxz/+pcc//q3PnI5i7bd11dY/5Qty5/eHDdU8cG9q/M4U+WJI0fkiMmDM2hY2tTU1XZZdftSq2tZb5+09J85prFae5AGdLEYQPyjdefuM++HgAA9n1//6LDc+/KLbljxabdzq3f1pR3X7EgP3jb7PTvV9FD6QAAAAAAAAA4EClEAgAAAAAAAKDXlGWZ+x/f+lQJ0oNrtvXYtbc3tWT+ik2Z/7QPd1dWFJk+ujZzpo3Mq06enJnjhvRYnt1Zu7Uhf/PDu/PHh9d3aH5Q/8p8640nZvTg6m5OBgDAgayqsiJfueT4vPiLf8y6usbdzs5fsSmf+PWi/NNLjuihdAAAAAAAAAAciBQiAQAAAAAAANCjWlrL3L58Y665f3WuvX9NHtu8o7cjPaWltcziNXVZvKYul81bntecfFA+9IKZGTqgqtcy/W7Rmnzwynuysb6pQ/MVRfKl1xy/z5Q5AQCwfxszpCZffs3xefU3bklLa7nb2f+euzxHTRyal58wqYfSAQAAAAAAAHCgUYgEAAAAAAAAQLdr2NmSuUvW5zf3rc51i9Z2uNynN5Vlcvmtj+TahWvy0Qtm5cVHjU9RFD12/YadLfnU1Q/kv+cu79S6j5w/K2fOHNM9oQAA6JNOPmRE/v5Fh+efr1rY7uyHfnxPaqoq8+Kjx/dAMgAAAAAAAAAONAqRAAAAAAAAAOgWZVnmxofW54d3PJobHlib+qaW3o60R9bVNebSK+7Mjw9bmY9feGQmjxjY7dd8aE1d3vODO/PA6rpOrXvd7IPzxlOndE8oAAD6tDefNiV3PrIpV92zardzLa1l3vs/dyaJUiQAAAAAAAAAOk0hEgAAAAAAAABd7tGN2/N3P7k3f3x4fW9H6TLXL16Xcz/3h7zvnBl583MOSVVlRZdfoyzLXHHbI/nnqxamYWdrp9a+4Ihx+egFs1IURZfnAgCAoijyby8/OotX1+Whtdt2O6sUCQAAAAAAAIA91fV3ZwIAAAAAAADQZ7W2lrls7vKc95839loZUkWRjBzUP5UVXV8M1LCzNZ+8+oFc8MU/5s5HNnXp3pu3N+Wd31+Qf/jpfZ0qQ6qsKPL+c2fky5ccn37dUNIEAABPGlTdL1973QmprW7/+zifLEX69b2reiAZAAAAAAAAAAeK9t+RBgAAAAAAAIAOWLa+Ph++8p7ctnxjl+9dW90vI2v7Z+Sg/hlZW51Rtf0zqrb6qecjn/Z82MAnypAadrbkwTV1Wfj41tz/+NYsXLU1i1Ztzfamlr3O88Dqurzsq3PzutkH5wPnHZYhNVV7td8tSzfkff97V1ZtaejUuonDBuQLrz42Jxw8Yq+uDwAAHTVtdG0+c9Execf357c729Ja5j0/uDNJ8qKjxnd3NAAAAAAAAAAOAAqRAAAAAAAAANgrLa1lvv3HZfnMtYvT2NzaJXsOru6XM2eOyXlHjMvpM0btUeFQTVVljp40LEdPGvbUsdbWMss31Gfhql0lSbuKktbVNXZ6/7JMvjtvRa65f3X+6YIj8oIjx6Uoik7t0dzSms//7qF8+fqH01p27voXHDMh//IXR2bogL0rYwKgC2zZklx77e5nnv/8ZOjQNpZuybXtrH3+85+foW2sBegtLzhyXP72hTPzqasfaHdWKRIAAAAAAAAAnaEQCQAAAAAAAIA99tCaunzgynty96Ob93qvUbXVOXfW2Jx3xNjMmTYy1f0quyDhn6qoKDJ1dG2mjq7N+UdPeOr42rqG3P/41nzjxqWZu2RDp/Zcs7Ux77x8Qc6eOSYfu/CITBo+MC2tZTbUN2Zd3dMe257xvK4xa+sas62xuVPXG9i/Mh97yRF5xQmTOl3ABEA3Wbkyufji3c/cd1+bhUgrV67Mxe2sve+++xQiAfucd5wxLS2tZf79msXtzj5ZilQkeaFSJAAAAAAAAAB2QyESAAAAAAAAAJ22s6U1//WHJfnC7x5OU0vrHu9z0IiBOe+IsTnviHE57qDhqazonYKfMYNrMuawmjxvxuj8ZMFj+ZdfLcym7Ts7tcfvHlibm5esT211VTbWN6a17PqcR04cki+86rhMHV3b9ZsDAEAnvfvM6UnS4VKkS39wZ74UpUgAAAAAAAAAPDuFSAAAAAAAAAB0yv2Pb8kHf3RPFq7aukfrZ44bnPOOGJfzjhiXw8cPTlH0TglSW4qiyMtPmJQzZ47JJ369KFfOX9mp9Q07W9Ows7Fbsr3t9EPywfNmpn+/im7ZHwAA9oRSJAAAAAAAAAC6kkIkAAAAAAAAADqksbklX/79w/nKDUvS3Fp2ev3FJ07KpWcemoNGDuyGdF1rxKD++cxFx+Tlx0/KP/z03ixdX99rWUbVVuc/Lj4mZ8wY3WsZAABgdzpbivSeH9yZL0YpEgAAAAAAAAB/TiESAAAAAAAAAO2669HN+dCVd+fBNds6vXbisAH51MuPyumH7n+FPnOmjczVf316vnrDknzl+iVpamnt0es/77DR+cxFx2RUbXWPXhcAADqrM6VIzbtKkb5UJC84UikSAAAAAAAAAP9HIRIAAAAAAABwQGhuac0v73k819y3Juu2NaYsyxRFkSJJUSRFiid+PsvvSZ4x/6fP8+SaZ9mvpqoyB48cmOljajN9TG2mjByU/v0quu21bqhvSnW/igwb2L9brvGkpeu25Rs3Lcv/3v5IWsvOr3/d7IPz4RfOTG31/vv2dHW/yvz1OTNy/tET8g8/vTe3LtvY7dfsX1mRD79wZt506pRUVBTdfj0AAOgK7z5zesqyzGeufbDd2ebWMpdecWe+9BqlSAAAAAAAAAD8n/33jlMAAAAAAACAJGVZ5jf3rc6/X7M4S9fX93acp1RWFDloxMBMG137VEnStNGDMn1MbQbXVO12bVNza1Zt2ZHHNu3Iyk07snLT9qzc/MTvj23akdVbG9Kyq53osLGD87LjJ+alx0/MmME1XZK9LMvcsWJTvn7j0ly3aE3KPShCOnjkwPzby4/O7KkjuyTTvmD6mNr8z1/Ozo/mr8wnfr0om7fv7JbrTB09KF941XE5cuLQbtkfAAC606VnHZokSpEAAAAAAAAA2CMKkQAAAAAAAID91i1LN+STVz+Qux/d3NtR/kxLa5ll6+uzbH19rlu05k/OjR1SvasgqTYHjRiYTdubnio7WrlpR9bUNXS4hGjxmrp88uoH8ulrFud5M0bnohMn5ayZY9O/X0WnMze3tOaa+9fkGzctzV17+N+0KJK3nHZI3v/8wzKgf+Ue7bEvK4oiF584OWfPHJN//fWi/GTBY122d1VlkdfOPjgfPO+wDOzv7XwAAPZfl551aMoy+Y/fdrwU6fOvSl58tFIkAAAAAAAAgL7OHZQAAAAAAADAfmfRqq359G8eyPWL1/V2lD2yZmtj1mxtzM0Pb+iyPVtay/zugbX53QNrM2JQ/1x47IRcdMLkzJowpN219Y3N+eEdj+bbNy/Loxt37HGG6WNq8+lXHJ3jDxq+x3vsL0bWVuezFx+bVxw/Kf/ws/uybH39bucrimRUbXVGD9712PX7mMHVGT24JmOGVOfw8UNSW+1tfAAADgzvOfvQJB0vRXr3FQtyz8qp+cB5h6WqsvMFrwAAAAAAAAAcGNxJCQAAAAAAAOw3Vm7ans/+9sH89M7HUpa9nWbftbG+Kd+5eXm+c/PyzBo/JBedOCl/cezEDB/U/0/m1m5tyH/PXZ7v37IiWxua9/h6lRVF3nHG1LznrENTU1W5t/H3K6dOH5Vr3/fcXLdwTe5euSU7W1r/pPDoycfwgf1TWVH0dlwAAOhRnSlFSpL/unFp7lixKV96zXEZP3RAd0YDAAAAAAAAYB+lEAkAAAAAAADY522qb8qXr3843523Ik0trb0dZ7+ycNXWfOyXC/OJXy/KOYePzUUnTsq4IQPy7ZuX5ed3PZadLXvXLDVz3OB85qJjcuTEoV2UeP9TVVmRFx41Pi88anxvRwEAgH3Oe84+NGWSz3awFGn+ik150edvymdfeWzOPGxM94YDAAAAAAAAYJ+jEAkAAAAAAADYZ+1oasm3b16Wr92wJHWNzb0dZ7+2s6XM1fetztX3re6S/aoqi7znrEPzjjOmpX+/ii7ZEwAAODC99+xDk3S8FGnT9p1503duz7ueNy1/c+6M9Kv0NwcAAAAAAABAX6EQCQAAAAAAANjnNLe05kfzV+Zzv30wa+saezsOz3DqtJH5xwtmZea4Ib0dBQAA2E+89+xDU5bJ567rWClSknzlhiW5Y8WmfPHVx2XskJpuTAcAAAAAAADAvkIhEgAAAAAAANCusizTsLM1NVUVKYqiS/feVN+UJeu2Zcm6bVm6rj5L1m3L/Y9vzaotDXu859ABVTn/6PGpqqxIWZYpk5RlUqbc9fOJ53ny+TPOte765Ym5p6//v+d52prWsszjmxuyZN22bG9q2ev/JvuiyooiLzxyXN52+tQcM3lYb8cBAAD2Q391zqEpiuSzv+14KdJtyzbmRZ+/Kf/5qmNz+qGjuzEdAAAAAAAAAPsChUgAAAAAAABAm+obm/Ozux7LTxc8lsVr6lLX0JzqfhUZVVudUYOrM7q2f0YPrn7ieW31037vn1GDqzO4ut9T5UnNLa15ZOP2pwqPnl5+tGn7zi7LXN2vIm9+ziF5xxnTMnRAVZft21FlWWbVloY8vHbbE49127Jk7ROvd/22pj3asyiSMYOrM2n4wEwaPiAThw3IpOEDU92vIr+6d1VuWLw2rWUXv5CnGdS/Mq886aC86bQpmTxiYPddCAAA6BPee/ahGT+0Jh/5+X1p2NnaoTUb6pvy+m/flvecOT1/dc6MVFZ0bVEvAAAAAAAAAPsOhUgAAAAAAADAn3hwTV2+f8uK/GTBY9nW2Pwn5xqbW/PY5h15bPOOdvd5sjypul9FHt20PTtbuq+1p6JILj5xcv76nBkZN7Sm267TnqIoMmHYgEwYNiDPnTH6T85t3t6Uh3eVIz29MGnrjuYM6l/5f4VHwwdk0vAnSo8mDhuQ8cNqUt2vss3rvfyESVm7tSE/ufOx/OiOR7NkXX2XvZaxQ6rzptMOyatPPqhXyqUAAIAD10UnTs7Rk4blnZfPz9IO/h1TlskXfv9wbl++KZ9/9bEZM7j3/vYDAAAAAAAAoPsoRAIAAAAAAADS1Nya39y/Ot+ftyK3Ld/YJXs+WZ7U3Z4/a2w+9ILDMn3M4G6/1t4YNrB/TpwyIidOGdGl+44ZUpN3nDEtb3/u1Nz16Ob8aP7K/PLux1PX0Nz+4jbMHDc4f/ncqTn/6Anp36+iS7MCAAA86bBxg/PLS5+Tf/jpvfnZXY93eN28pRvyos//MV941bE5dfqobkwIAAAAAAAAQG9QiAQAAAAAAAB92KMbt+cHtz2SH97xaNZva+rtOJ1y0pTh+dsXzswJB3dtwdD+qiiKHHfQ8Bx30PD84/mzcs39q3Pl/JX548PrU5btr3/ujNH5y9On5rTpI1MURfcHBgAA+rxB1f3yuVcem1OmjsxHf3F/mppbO7Ru/bbGvPZbt+avzp6RS8+ansoKf8MAAAAAAAAAHCgUIgEAAAAAAEAf09Ja5sYH1+V7t6zI9YvXdqgsZ18yY2xtPvyCmTlr5hjFPc+ipqoyFx47MRceOzGPbd6Rn8xfmSsXrMyKDdv/ZK6qsshLjpmYt55+SA4fP6SX0gIAAH1ZURR59ckH5ZhJw/LuKxZk2fr6Dq1rLZPPXfdgblm6IZ982VGZMmpQNycFAAAAAAAAoCcoRAIAAAAAAIA+Yv22xvzwjkdzxa2PZOWmHb0dp9PGD63J35w7Iy87flIqKxQhddTEYQPynrMPzaVnTc/tyzfltmUb8viWhswaPyTnzhqbsUNqejsiAABAZk0Ykl9celr+7if35qp7VnV43bylG/L8/7wxl545PW8/Y2qq+1V2Y0oAAAAAAAAAuptCJAAAAAAAADhANTW35q5HN+fmh9dn3pINWfDIpjS3lr0dq9NGDuqft58xNa+fMyU1VT7YuqeKosjJh4zIyYeM6O0oAAAAbRpcU5Uvvvq4nHLIiPzzVYvS1NLaoXVNza357G8fzM/veiz/+tKjMnvqyG5OCgAAAAAAAEB3UYgEAAAAAAAAB4iW1jILH9+auUvW5+YlG3L7so3ZsbOlt2N1ytgh1Zk2ujbTRtdm6uhBmTluSE6aMjz9Kit6OxoAAAA9oCiKvG7OlBw7eXjefcWCPLJxe4fXLllXn1d9/Za84oRJ+fsXHZ4Rg/p3Y1IAAAAAAAAAuoNCJAAAAAAAANhPlWWZJevqnyhAenh9blm6MVt27OyWax0zaWheccKkVFQUWV/XlHWC6lTYAAAgAElEQVTbGrK+rinrtzVm3bbGrK9rTH1Tx8qX+veryNRRgzJ19KA/KT86ZNSgDK6p6pb8AAAA7F+OmjQ0V733OfnQj+7Jb+5f3am1V85fmd8tWpO/e9HhueiESSmKoptSAgAAAAAAANDVFCIBAAAAAADAfmRTfVOuW7Qmc5dsyNwl67Nma2O3XaumqiIXHjMxr519cI6aNLTd+R1NLVm/rTFr6xqzftsTj3V1jWnY2ZpRtf0zbUxtpo+uzYRhA1JZ4cOoAAAA7N6Qmqp89bXH57/nLs8nfr0oO1vKDq/dtH1nPnTlPbly/sp84qVHZvqYwd2YFAAAAAAAAICuohAJAAAAAAAA9gNrtjbkqzcsyRW3PZKm5tZuvda00YPy2tkH52XHT8rQAVUdXjegf2UmjxiYySMGdmM6AAAA+pKiKPKm0w7JcQcNz7svX5DHNu/o1Prblm3MCz9/U97+3Gm59Kzpqamq7KakAAAAAAAAAHQFhUgAAAAAAACwD1tb15Cv3bA0l9+6Io3dWITUr6LIeUeMyyWzD8qcqSNTFEW3XQsAAAA669jJw/Lrvzo9n7p6UX5w26OdWruzpcyXrn84v7zn8fzzhUfmuTNGd1NKAAAAAAAAAPaWQiQAAAAAAADYB63f1pj/+sOSfO+WFWnY2X1FSOOH1uTVJx+UV500OWOG1HTbdQAAAGBvDR1QlU++7Oi8/PhJ+Yef3pfFa+o6tX7Fhu15/bdvywXHTMhHzj88Ywb7OxgAAAAAAABgX6MQCQAAAAAAAPYhG+ub8l83Lsl3567Ijp0t3XKNokieM31UXjf74Jw1c0z6VVZ0y3UAAACgO5w4ZUSueu9z8s2bluXzv3uw00XCv7z78fx+0Zq8+uSD8pbTD8n4oQO6KSkAAAAAAAAAnaUQCQAAAAAAAPYBm+qb8o2blua/5y7P9qauL0I6ZNSgzJk2MqdNG5XZU0dkZG11l18DAAAAekpVZUXe+bxpOf/o8fnHn9+X6xev69T6+qaWfPOPy3LZvOW58NiJeftzp+bQsYO7JywAAAAAAAAAHaYQCQAAAAAAAHrRlu07880/Ls13bl6ebY3NXbbv2CHVOW3aqJw6fVTmTBuZicMGdNneAAAAsK+YPGJgvv3Gk3L1favzsV/enzVbGzu1fmdLmSvnr8yV81fmnMPH5B1nTMuJU0Z0U1oAAAAAAAAA2qMQCQAAAAAAAHrBlh07860/Lst3/rgsdV1QhDRsYFXmTB2ZU6eNzKnTR2XqqEEpiqILkgIA0K7Ro5OPfrT9mTYPj85H21k7+lnWAvCEoijyoqPG5/RDR+U/rn0wl81bnrLs/D7XLVqb6xatzYkHD887zpiWs2aOSUWFv60BAAAAAAAAelJR7sk7vhyQiqKYleTIJBOS1CZpSLIuyaIkd5ZlubMX43VIURRDksxKMi3J8CRD8sTr2JRkY5J7yrJc1nsJu1ZRFHOSzH36sblz52bOnDm9lAgAAAAAAGjP9qbmfPuPy/JfNy5NXcPeFSGdePDwPP+IsTl12qjMGj/EhzQBAAAgyT0rN+fvf3pv7nts617tc+iY2rz9jGl5yTET0r9fRRelAwAAAAAAAPZ18+bNy6mnnvrMw6eWZTmvN/L0Nf16OwC9qyiKyUnem+Q1eaII6dnUFUXxiyRfKMvyth4J1wG78p+d5Mwkz00ypQNr1iS5PsnXyrL8Q7cGBAAAAAAA2KWpuTX/e/sj+fzvHs76bY17tdfJU0bkr889NKdOG9VF6QAAAODAcfSkYfnZu07Ld+etyH9cuzj1TS17tM9Da7flAz+6O/9x7eK85TmH5FUnH5Ta6n331ts1Wxsyb8mG3LNySzZvb8rgmn4ZO7QmYwfXZNzQmowd8sTPffk1AAAAAAAAABRlWfZ2BnpBURQVSf42yf9LMqCTy7+X5D1lWW7p8mAdUBTFwUkuTnJRkpP2crt7k7x9f21gK4piTpK5Tz82d+7czJkzp5cSAQAAAAAAz9TaWuaX9zye/7j2wTyycfte7XXCwcPzN+fOyKnTRqYoii5KCAAAAAeuVVt25GO/WJjf3L96r/caUtMv584al4NGDMyk4QMyedfPsUNqUlnR83+nr6trzC1LN2Te0g25ZcmGLF1f36F1tdX9MmZIdcYNqcm4ITW7SpOqnypNOmTUoAwb2L+b0wMAAAAAAMC+a968eTn11FOfefjU/bWfZH/jK176oKIoBiT5UZIX7+EWr0syuyiK88qyXNZ1yTrsW0nO7qK9jkryx6Io/j3J35UawgAAAAAAgC5SlmX+8OC6fPo3i7Nw1da92uvYycPyN+fOyOmHjlKEBAAAAJ0wfuiAfO11J+T6xWvz+eseyl2Pbt7jvbY2NOfHC1b+2fF+FUUmDBuQScOfeEwePjCTRgzIpOFPFCaNGdw1hUmb6pty67INmbtkQ+Yt2ZCH1m7bo322NTZn27rmLF337AVKR00cmguOGZ8XHz0hE4d19ns3AQAAAAAAAPacQqQ+piiKyiQ/TvLCZxnZmWRhkvVJBieZlaS2jblDk/y+KIpTy7Jc1R1Z99L6JGt3PfonGZtkapK27iioSPLhJEOSvKunAgIAAAAAAAeuBY9syr9d/UBuXbZxr/Y5etLQvO/cGXnejNGKkAAAAGAvnHnYmDxvxujcumxjvvaHJblh8bou27u5tcwjG7fnkY3b2zxfVVlk+MD+GTqgKkMHVGXIrp9P/31ITb+njg0d+MTPqsqK3PnI5sxbsiHzlm7IA6u3pqe+9vHex7bk3se25BO/fiAnHDw85x89Pi8+anzGDKnpmQAAAAAAAABAn6UQqe/5eNouQ9qc5GNJvlOW5ZYnDxZFUZXkJUk+kWTGM9ZMSfKDoijOLsuypXvidtiGJFcmuSHJTWVZPvbMgaIoRiV5WZIPJpnexh7vLIpiZVmWn+jOoAAAAAAAwIHr4bV1+fRvFufahWv2ap8jJw7J+86ZkbNmjlGEBAAAAF2kKIrMnjoys6eOzKJVW/Nff1iSX96zKi2t3dsytLOlzNq6xqyta+zW63SX+Ss2Zf6KTfn4VQtzyiEjcsExE/LCI8dnxKD+vR0NAAAAAAAAOAAVZU99VQy9riiKY5LMT1L5jFPLkpxTluXS3awdlOTHSc5r4/SlZVl+ucuCtqMoiuuSnL3r6TVJvpnkF2VZNnVwfU2SzyV5RxunG5LMKstyWVdk7W5FUcxJMvfpx+bOnZs5c+b0UiIAAAAAAOibHt+8I5/77YP58YKV2ZvPUB4+fkjed86hOXfWWEVIAAAA0ANWbtqeb960LP97+6PZsbO3vxty/1FZUeS06aNy/tHjc94R4zJ0QFVvRwIAAAAAAIAuM2/evJx66qnPPHxqWZbzeiNPX6MQqQ95RpHQk+qTnFiW5QMdWD8wyW1JjnjGqY1JDi7LcluXBG0/x2+TNCX5aFmWd+zFPl9L8vY2Tv13WZZv2tN9e5JCJAAAAAAA6F2b6pvylRsezmXzVqSpuXWP9zls7OC879xD8/xZ41JRoQgJAAAAetqm+qZcNm95Lpu7PJu27+ztOPuV/pUVee6MUbngmAk5+/Cxqa3u19uRAAAAAAAAYK8oROpdCpH6iKIoTkxyexun/rYsy3/rxD5/VsCzy/vLsvzsnubrjKIoJpZl+VgX7FOTZFGSKc84tSnJmLIsm/f2Gt1NIRIAAAAAAPSen965Mh/9+f3Z2rDnbylMHDYg73/+jFx47MRUKkICAACAXre9qTk/vP3RfOOmZXls847ejrPfqamqyIuPmpBXnjQ5J00ZnqLw7x0AAAAAAADsfxQi9S5fwdJ3/GUbxzYk+WJnNinLcl5RFNckOe8Zp96WpEcKkbqiDGnXPg1FUXwhf557eJI5SW7qiusAAAAAAAAHlh1NLfnHn9+XH81fucd7jBzUP5eeNT2vOeWgVPer7MJ0AAAAwN4Y2L9f3njaIblk9sH51T2r8rU/LMkDq+t6O1anVPeryJETh2ZHU0vWbG3IhvqmHrt2w87W/HjByvx4wcpMHTUoF580OS8/flJGD67usQz7muaW1ty9cnO2N7Vk0vCBmTJyoKIoAAAAAAAA2A2FSH1AURT9kryijVOXl2W5fQ+2/Eb+vBBpZlEUx5dluWAP9utN1z7L8YOjEAkAAAAAAHiGh9bU5V2XL8hDa7ft0fpB/SvztudOzVtPn5raam/VAQAAwL6qqrIif3HcxFx47ITcsWJTbnxwXZatr8/KTTuyctOOrN/W2NsRn1JVWeS4g4ZnztSRmTNtZI6dPCw1Vf9XwNzU3Jq1dQ1Zs7Uhq7c0Zs3WXb/v+rlma2NWb2nIjp0tXZpr6fr6fOrqB/KZaxbnrJlj8qqTJ+e5h45Ov8qKLr3Ovmrz9qZcNndFLpu3PBufVko1enB1TjlkRE6ZOjKzDxmR6WNqFSQBAAAAAADA07jLum+YnWR4G8d/vIf7/SrJjiQDnnH8hUn2t0KkR57l+LgeTQEAAAAAAOzzfnTHo/nIz+9Lw87WTq+tqixyySkH59KzpmdUbXU3pAMAAAC6Q1EUOWnKiJw0ZcSfHN/R1JLHNm/Po7sKklZu2v5UWdJjm7Zn/bamZ9lx7/WrKHL0pKGZM21k5kwdlRMOHp4B/Sufdb5/v4pMGj4wk4YPfNaZsiyzdUdzbl6yPr+8+/H8/oG1aWzu/L+BtKW5tcy1C9fk2oVrMnZIdV5xwqRcfOLkHDxyUJfsv69Zs7Uh37xpaa649ZHUN/15ydS6usZcdc+qXHXPqiTJqNr+OfmQETnlkJE5ZeqIzBgzOBUVCpIAAAAAAADouxQi9Q1ntnFse5J5e7JZWZYNRVHMTXL2M06dleRf92TPXrTzWY53zbv4AAAAAADAfq++sTkf+fl9+cmCxzq9tiiSlx47Me87d0Ymj3j2Dx0CALCfa2hIlizZ/cy0aUlNTRtLG7KknbXTpk1LTRtrAeg9A/pXZvqYwZk+ZnCb57c3NeexXQVJa7Y2ZGvDzmzZ8eSjOVt27MzWXY8njze3lm3uVVEkR00cmtnTRmbO1JE5acqIDKru2luAi6LI0IFVedFR4/Oio8ZnW2Nzrlu4Jlf9f/buOz7Ps7wX+O/RsOQhb8sr3iNO7MTZiZOQQQIkBwijEEobRg7QQkuBlsKhLT0tHBq6KbSlQAsUygiUlUEIkL2cQYYT73jH25LjJduyJT3nj6RpCTJI9ivL4/v9fPRRdD/vdd2/N8lfz/s+1/3k+ty9dEv2t3eerbs27WjNP9+5PP985/LMmTwsbzp7XK6YNSr1tQce6HS0WN3cks/dvSLffXRt9rV3/WuoTbv25ZanNuaWpzYmSYb0q83ZE4fm3MnDcu6koTlp9MBUG5AEAAAAAADAccRApOPD2Z2sPV6W5YGGAXXFw/nFgUhnHEK/3jLxAOsbDmcIAAAAAADgyLR444787tcfy/ItLd2uvWxGYz50xYmZMWpgDyQDAOCIsnx5MmvWL3/N/PnJzJmdlC7PrF9RO3/+/MzspBaAI1e/PjWZNrIh00Z2PjDpxcqyzO597S8MR9qxZ392tbZlYN/anDiqIQPra3s48c8bUFeT154+Nq89fWy2796fHy/cmJvmrc8Dy5vTfoDBTd01d0Vz5q5ozsAbntvrylmjc9bEIamtrqpI/8Nl0YYd+exdy/PDJ9enEv9qnt29Pz9ZuCk/WbgpSTKwvibnPT886qUzGlMUhiMBAAAAAABwbDMQ6fhwaidr8w+x55OdrA0uimJCWZarD7H34fTSA6wvO6wpAAAAAACAI0pZlrn+kWfy5zcuSGtbR7dqz5wwJB+5ckbOnji0h9IBAAAAx5qiKNK/rib962oyZnDf3o7zcwb1q83VZ43L1WeNS/Ou1vxo/sbc/OT6PLRya8oKDADasbctX527Ol+duzoNdTW5cNrwXHpiYy45cUQaB9Yf+gY95Gertuazdy3PHYs39+g+O/a2vTAg6fwpw/KJ187K5BEDenRPAAAAAAAA6E0GIh3jiqLok2RcJ5cOdeDP8gOsT05yNA1EuraTtU1JHj3cQQAAAAAAgCPDrta2/PH3nsqN89Z3q25gfU2ue/0peeUpo1MURQ+lAwAAAOg9wwbU5ZrzJuSa8yZk0469ueWpDblp3vo8tmZbRfrvbG3Lj+ZvzI/mb0ySzBwzMJee2JhLZ4zIaeOGpLqqd++5lGWZu5duyWfvWp6HV2497Ps/sLw5V3z63rz30qn57Ysnp66m+rBnAAAAAAAAgJ5mINKxb1ySqk7W1x1i3wPVTzzEvodNURSvSnJWJ5duKMuye0c9H3yGOYfYYlZFggAAAAAAAEmSBeu3573feDwrm1q6VTd73OD805tPz7ih/XooGQAAAMCRZeTA+lx7waRce8GkLNu8K//5s2fy3cfWpmnXvortsWD9jixYvyP/dOeyDO5Xm4unj8ilJzbmoukjMrR/n4rt88uUZZkN2/fmoZXN+bd7V2bB+h2HZd8D2dfWkb//6dLcOG99rnvdKTln0tBezQMAAAAAAACVZiDSsW/EAdY3HWLfA9UfaL8jSlEUA5J8ppNL7Uk+dRijPHAY9wIAAAAAAA6gLMt87aE1+X83L8y+tu6dm/Cul0zKh14xI31qOjujAgAAAODYN7VxQP7of52UP3zFibl90eZ8+2fP5K4lm9NRVm6Pbbv354Yn1ueGJ9anKJLTxg3OJdMbM3PMwEwY1i/jhvZLfW31Ie+zfff+zFu7LfOe2ZZ5a7dn3tpt2bKztQLvoLKWbd6Vqz8/N79+9rh85MoZGdzv8AyIAgAAAAAAgJ5mINKx70DHvmw/lKZlWbYXRdGSpP+LLg07lL6H0WeSTOpk/XNlWS4+3GEAAAAAAIDDpyzLNLfsy4Zte7N++56s37Yn9y9rzm2LuneexOB+tfnbN8zO5SeP7KGkAAAAAEeX2uqqXDFrVK6YNSobtu/Jdx9dm2/97Jk8s3VPRfcpy+TxNdvy+JptL6wVRTJqYH0mDOuXCUP7Z/ywfpk4rH8mDOuX8cP6ZWB97S/02bu/PQvW73h++NG2PLl2e1Y2tVQ0a/Lc8KZrL5iYpl378tCK5jy8amu27d5fkd7XP/JMblu0KX/6qpNz1ewxKYqiIn0BAAAAAACgtxiIdOwbcID1XRXo3dlApBf/fcQpiuJdSa7t5NLqJH98mOMAAAAAAAAvsmnH3sxftz1bW/alT01Vaqv/66dIn5qq9Kn+77UX/q4pXlgryzIbtu/Nhu17sn7bc7//a/jRc+t7s6+t45AynjlhSD7z5tMzdnDfCr1rAAAAgGPL6EF9896XTsvvXDI1D65ozvWPPJNbF2w85PsyB1KWeeHez4Mrtv7C9aH9+zw/LKlf+vapzlPrtmfxhp1p6yh7JE+SXDh1eH7n0imZM3nYC4OK3nHhpHR0lFm6eWceWrE1D61szkMrtqa5Zd9B79O0a1/ef/0T+c6ja/OJ187KhGFH/Nd5AQAAAAAA4IAMRDr2/eJxNs9pq0Dvzo6m6VOBvj2mKIpLkvxzJ5faklxTluWOw5sIAAAAAADo6Cgzf/323LZoc+5YvCnz1x3Zt+vfffGUfPDl01NbXdXbUQAAAACOeFVVRc6fOjznTx2ebbv35QePr8u3frY2izYc3ntAW1v2ZWvLvjy+ZluP73XFzFF5zyVTMnvc4E6vV1UVmTFqYGaMGpi3nT8xZVlm2eZdeXDl1jy0ojkPrdyaLTtbu73vvU835eWfuifvu2xafuuiye5fAQAAAAAAcFQyEOnYV32A9fYK9O6sxxH7/1RRFKck+V46HxL1f8qyvO8wR0qS8w+xflaSL1QiCAAAAAAAHE579rXnvmVNuX3RptyxeHM2H8QDXofb0P598ndXz86lJzb2dhQAAACAo9Lgfn3y9gsm5W3nT8z8dTvy/cfX5a4lm7OiqaW3ox2ymqoirzltbN5zyeRMbWzoVm1RFJk2siHTRjbkLedNSFmWWdnUki/dvzJff2hNyrLrvVrbOvI3P16SG59Yn+tef0rOnDCkm+8EAAAAAAAAetcRO7yGimk7wHol/tt31mN/BfpWXFEUU5P8OElnn+r+U1mWf3+YIyVJyrKceyj1RVFUKgoAAAAAAPS4Ddv35PZFm3PH4s25f1lTWts6ejtSl50zcWg+8+bTM2pQfW9HAQAAADjqFUWRU04YlFNOGJT/++qTs6qpJXct2Zw7l2zJ3BXN2XcU3Teqq6nKr589Lu+6aHJOGNKvIj2LosjkEQPyideektedfkL++HtPZcmmnd3qsWTTzrzhcw/k1844IRdPH5FZYwdlwtB+qary3VMAAAAAAACObAYiHfsOdJxynwr07qzHEXd8c1EUE5LcnmR0J5f/Pcn7DmsgAAAAAAA4TnR0lHlq3fbcvmhTbl+8OQvW7+jtSN1WFMl7L52a9182LTXVVb0dBwAAAOCYNHF4/7x9+KS8/YJJ2bOvPXNXNOXOxVtyx+LNWbdtT2/H61RDXU3eMmdC/veFkzJ8QF2P7XPmhCG5+X0X5l/vXZFP3/Z0t4aMl2XynUfX5juPrk3yXOaTxwzMKWOfG0Y1c8ygTB7e35AkAAAAAAAAjigGIh37DnQcTEMFenfW44h6kqEoirFJ7kgyvpPL1yd5R1mW5eFNBQAAAAAAR7f97R1p2tWazTtas2VnazbvbM3mnXtf+Oct/+NnX3vXH9A60gwf0CefetNpecm0Eb0dBQAAAOC40bdPdV46Y2ReOmNkPl6WWb5lV+5cvCV3LtmcR1Ztzf723vvaZ5+aqpwydlCumDkqbzpnXAbW1x6WfWurq/I7l0zNK08ZnY/+YH7ufbrpoPrsbG3LQyu35qGVW19Y69+nOiePGZhZYwdl1pjnBiVNGTEg1YYkAQAAAAAA0EsMRDr2NR9gffChNC2Koj5JZ8fZHGi/w64oilF5bhjS5E4ufy/JW8qyPHqfwgAAAAAAgB5WlmUeXf1sbp2/MUs27Xxh4NHWln29Ha3HXTB1WD519WlpHFjf21EAAAAAjltFUWRqY0OmNjbkXRdNzs69+3P/subctWRzHl39bFZv3Z19bT3zVdCiSKY3NmT2uEGZPW5wZp8wOCeOakhtdVWP7NcVE4b1z1f/9zm5cd76fPymhWmuwH26ln3teWTVs3lk1bMvrNXXVuWsCUNz9dnj8qpTRqfKcCQAAAAAAAAOIwORjn0bD7A+6hD7Hqj+QPsdVkVRNOa5YUjTO7l8U5JfL8uy7fCmAgAAAACAo8eiDTvy5zcu+LnT4o9V9bVVGTOob0YPrs+EYf1z6YmNufykxhSFB70AAAAAjiQN9bW5YtaoXDHrua+xdnSU2bhjb1Y3787q5pas3vr87+bdWd28O7tau/5V0bGD++a0cYOfG4B0wuDMGjso/euOvK9aF0WR15w2NhdPH5G//NHiXP/IMxXfY+/+jty3rCn3LWvK5+9enj955Uk5f8rwiu8DAAAAAAAAnTnyPqWj0tYnaU1S96L18YfY90D1Kw+x7yErimJEnhuGdFInl29N8sayLPcf3lQAAAAAAHB0eLZlX/7up0vyjYfWpKPs3SxVxXMPeLUfQpDa6iIjB9a/MPBo9KC+Gfv879GDn1sf3K/W8CMAAACAo1BVVZExg/tmzOC+mTNl2M9dK8syW1v2ZVXz7qzZ2pJVTbuzZuvurGpuSVt7mWED+uTUEwbntHGDcuoJgzN8wIu/antkG9yvT/7y107N6884IX/8/aeybPOuHtlnwfod+Y1/fSiXn9SYj1x5UqY2DuiRfQAAAAAAAOC/GIh0jCvLsiyKYnmSk190afohtp52gPVlh9j3kBRFMTzJ7UlmdnL5tiSvK8uy9fCmAgAAAACAI19be0e++fCa/O1Plmb7nt47V6CxoS6XndSYy2aMzAVTh6dvn+q0d5TZ396Rfe0d2d/Wkf3tZfa1Pf/38z///XeZ9o6ODO1flzGD6jN8QF2qqgw7AgAAADjeFEWRYQPqMmxAXc6cMKS34/SYcyYNzQ/fd2E+f/eK/NOdy7KvraNH9rlt0ebcuWRLfuOc8fnA5dMy7CgbIAUAAAAAAMDRw0Ck48Pj+cWBSLMPsefpnaytLcuy6RD7HrSiKIYm+WmSUzq5fGeSq8qy3Ht4UwEAAAAAwJFv7vLmfOymBVm8cWev7D9r7MBcNmNkLj9pZGaOGfgLA4yqq4pUV1Wnvra6V/IBAAAAwJGsrqY677tsWl516uh89Afz88Dy5h7Zp72jzH88uDo/eHxdfufSqbn2gonu2QEAAAAAAFBxBiIdHx5K8psvWju5KIpBZVluP8iecw6wT68oimJwnhuGdFonl+9J8qqyLPcc3lQAAAAAAHBkW/vs7lx3y6Lc8tTGw7pvXU1VLpw6PJedNDIvndGYUYPqD+v+AAAAAHAsmjxiQL7+znPz+DPbcvO8DXlq3bYsWL8ju/e1V3Sfna1t+atbF+drD67Oh684Ma8+dcwvDDkHAAAAAACAg2Ug0vHhtk7WqpNcnuS73W1WFEVjktO7uE+PK4piYJKfJDmjk8v3J3llWZa7D28qAAAAAAA4cu3Z157P3b08n7t7eVrbOg7LniMH1uWlM0bm8pMac/6U4enbx8nxAAAAAFBpRVHkjPFDcsb4IUmS9o4yK5taMn/d9sxftz1Prduehet3ZGdr2yHvtW7bnrz/+ifypftW5qOvOjlnTxx6yD0BAAAAAADAQKTjQFmWi4qiWJ5kyosuvSkHMRApydVJXnyMS5nk5oPodUiKomhIcmuSszu5PDfJlWVZ7jq8qQAAAAAA4MhUlmVueWpjrrtlUdZt21OxvrXVRRob6jO8oS6NDXUZ8XO/6zNxWL9MbRyQonBKPAAAAAAcTtVVRaY2DsjUxgF57eljkyQdHWVWb939wpCk+eu356m127Nj78ENSZq3dnve+Lm5uWLmqHzkyhmZOJ1ZrYoAACAASURBVLx/Jd8CAAAAAAAAxxkDkY4fX0vyZy9ae21RFOPKsnymq02K555U+N1OLt1VluXaQwnYXUVR9E9yS5I5nVx+KMkVZVnuPJyZAAAAAADgSLVow4587KYFeXDF1oOqr64q8rrTx2Za44A0DqzLiAH1z/+uy+B+tYYdAQAAAMBRoqqqyKTh/TNpeP+8evaYJM8NU1/77J5859G1+cI9K7Jnf3u3+966YGNuX7wp15w3IR+4fHoG9a2tdHQAAAAAAACOAwYiHT++kOSPkvT5H2u1ST6R5G3d6HNtkhmdrP9TVxsURbEqyYQXLa8uy3JiN3r0TXJTkgs7ufxIkleUZbmjq/0AAAAAAOBY9fSmnfnc3Svy/cfXpqM8uB4XTB2WP3v1zEwf2VDZcAAAAADAEaEoiowb2i+//7LpefM54/N3P1mS7zy2NmU37ynuby/z5ftX5cfzN+bvrj4tc6YM65nAAAAAAAAAHLOqejsAh0dZluuTfKmTS28tiuKNXelRFMX0JH/fyaX5SX5wCPG6pSiKuuf3u7STy48meXlZltsPVx4AAAAAADgS/WzV1rzzK4/kZZ+6J9997OCGIZ0wpG8+d82Z+do7zjUMCQAAAACOE6MG1edv3jg7N//ehblg6sENNFq/fW9+498ezCdvWZTWtvYKJwQAAAAAAOBYVtPbATis/jTJ1UmGvmj9P4qiqCnL8psHKiyK4vQkNyYZ1Mnl95Vl2VG5mL/Sd5O8vJP1LXnuPc4oiuJQ99hRluXCQ20CAAAAAACHU0dHmTsWb87n7l6en61+9qD79K2tzu9cMiXvumhy6murK5gQAAAAADhazBwzKF97x7m5c8nmXHfL4izbvKtb9WWZfP6eFbnn6aZ8+tdPM3QdAAAAAACALjEQ6ThSlmVTURTvSPL9F12qS/KNoijekuTzSR5M0pSkIcnsJL+Z5O1Jajtp+6myLO/ssdCde+UB1kckuaVCe9yd5JIK9QIAAAAAgB61r60jN85bn8/fvTxPd/OhpBd79ewx+aMrZ2TM4L4VSgcAAAAAHK2KoshLZ4zMRdNG5PpHnsmnfro0zS37utVj0YYdedU/3pc/unJG3jZnYqqqDvngUwAAAAAAAI5hBiIdZ8qy/EFRFH+c5LpOLl/5/E9X3Zzk/1QkGAAAAAAA0G0trW355sNr8sX7VmbD9r2H1Ovk0QPz51fNzDmThlYoHQAAAABwrKiprso1503Ia04bk3+5a3m+eN/KtLZ1dLl+X1tHPnbTwtyxeHP+9o2zM3JgfQ+mBQAAAAAA4GhmINJxqCzLTxZFsSfJ3yapPsg2X0vyzrIs91cuGQAAAAAA0BVNu1rzlQdW5atzV2f7nkO7VT+kX20+9IoZedPZ41LtZHYAAAAA4JdoqK/Nh6+Ykd88b0L+9sdL8v3H13Wr/t6nm/KKf7gnn3zdKbnylNE9lBIAAAAAAICjmYFIx6myLP+hKIq5Sf45yZndKN2Q5MNlWX6tZ5IBAAAAAACdKcsyizbszDcfXpNv/+yZbp2+3pnqqiJvOW9Cfv/y6RnUr7ZCKQEAAACA48HYwX3zqTedlmsvmJhP3LwoD6/a2uXabbv35z1ffyxvOPOE/NmrT05DvfuTAAAAAAAA/DcDkY5jZVk+lOSsoiguT3JNksuTjO3kpduS3JvkO0m+VZZl6yHuO/EQ6x1PDQAAAADAcWHv/vbMXd6c2xdvyh2LNmf99r0V6fvSGY35yJUzMn1kQ0X6AQAAAADHp1NPGJzrf+u8fGXuqnzyR4uzrxuD3L/z6No8tLI5n7r6tJw1cWjPhQQAAAAAAOCoYiASKcvytiS3JUlRFIOTjEnSP8neJE1lWW7oxXgAAAAAAHBc2bxjb25fvDm3L9qc+5c1Zc/+9or0ra4qctXsMfntiydnxqiBFekJAAAAAFBVVeTaCyblgqnD8/7rn8iiDTu6XPvM1j25+vNz87uXTs37LpuW2uqqHkwKAAAAAADA0cBAJH5OWZbbkmzr7RwAAAAAAHC8KMsy89ftyO2LN+X2RZvz1LrtFe3ft7Y6bzp7XN75kkk5YUi/ivYGAACeN3Bg8oY3/OrXdLo8MG/4FbUDD1ALAHAkmT6yIT/43fPz9z9Zmi/cuyJl2bW6jjL5xzuW5e6lW3LV7DGZNLx/Jg7vn3FD+qVPjQFJAAAAAAAAx5ui7OonTcARpyiKOUke+J9rDzzwQObMmdNLiQAAAAAA6Iq9+9tz39NNuX3xptyxeHM27Wit+B5D+tXmbedPzNvmTMyQ/n0q3h8AAAAA4EAeWN6UD357XjZs33vQPaqripwwpG8mDuufScP7vzAoadKw/hk7pG+qq4oKJgYAAAAAAPhvc+fOzfnnn//i5fPLspzbG3mONzW9HQAAAAAAAOB40dFR5qtzV+Wf7lyWpl37emSPsYP75l0vmZSrzx6Xfn18FAQAAAAAHH7nTxmeW99/UT56w/zcNG/9QfVo7yizunl3Vjfvzt1Lt/zctT7VVRk3tG8mDe+fySMGZFrjgJw4qiFTGwe4LwoAAAAAAHCU82kPAAAAAADAYbB5x9588D/n5d6nm3qk/4xRDXn3xVPyylNHp7a6qkf2AAAAAADoqkH9avOPbz49l5/UmI/+YH527m2rWO997R1ZvqUly7e0JIs2v7BeFMm4If0yfWRDThw1INNHNmT6yIZMHtE/dTXVFdsfAAAAAACAnmMgEgAAAAAAQA+7beGmfPi7T2Zry76K9z530tC8+5IpuWT6iBRFUfH+AAAAAACH4jWnjc2ZE4bkg9+el4dWbu3RvcoyWbN1d9Zs3Z3bFm16Yb26qsik4f1z4siGTBs5ICeObMj0UQ2ZOKx/qqvcVwUAAAAAADiSGIgEAAAAAADQQ/bub891tyzKV+eurmjf4QP65KUzGvPmc8bn9PFDKtobAAAAAKDSThjSL99413n513tX5O9+siT728vDun97R5llm3dl2eZdyVP/vT6wvibnTh6WOZOH5fypwzK9sSFVBiQBAAAAAAD0KgORAAAAAAAAesDijTvyvm8+nqWbdlWk30mjB+ayGY257KTGzD5hsIdyAAAAAICjSnVVkXdfPCUXTh2eD3zrieeGE/WyHXvb8tOFm/LThZuSJEP798l5k4dmzuRhmTNleKaM6J+icC8WAAAAAADgcDIQCQAAAAAAoILKssxXHliV6360OPvaOg66T5+aqlwwZVheetLIXDajMWMG961gSgAAAACA3jFr7KDc/HsX5i9/tDhfnbsqHWVvJ/pvW1v25ZanNuaWpzYmSUY01D0/HGlYzp8yLOOH9jMgCQAAAAAAoIcZiAQAAAAAAFAhTbta86H/nJc7l2w5qPoRDXW5bEZjLjtpZC6YOiz9+vgoBwAAAAA49tTXVufPr5qZ3754cr7zs7WZt3Z7VjW3ZE3z7uxrP/hB85W2ZWdrbpy3PjfOW58kGTOoPudNGZYLpw7Py2eOyoA693ABAAAAAAAqzScwAAAAAAAAFXD30i354LfnpWlXa7fqxgyqzxvPGpfLTmrMrDGDUlXldHEAAAAA4PgwelDf/N5l0174u72jzPpte7KyqSWrmluyYstzv1c1teSZZ/ekvaPsxbTJ+u17873H1uV7j61LQ/2C/NZLJufaCycZjAQAAAAAAFBBPnkBAAAAAAA4BK1t7fnrW5fki/et7Hbtq04dnb943SkZ1Le2B5IBAAAAABxdqquKjBvaL+OG9stFGfFz1/a3d+SZrbuzqrklK5t2Z1VTS5Zt3pWnN+9M0659hz3rzr1t+bufLs2X7l+Zd188JW+dMzF9+1Qf9hwAAAAAAADHGgORAAAAAAAADtKyzTvze998Ios27OhWXb8+1fn4a2bl184Ym6IoeigdAAAAAMCxo7a6KpNHDMjkEQN+4VrzrtYs3bQrSzftzJJNO/P0pp1ZsnFnduxt6/Fcz+7en0/+aHH+9d6V+d1Lp+TN54xPfa3BSAAAAAAAAAfLQCQAAAAAAIBuKssy33z4mXz85gXZu7+jW7WnnjAon/710zNpeP8eSgcAAAAAcHwZNqAucwbUZc6UYS+slWWZTTtaf25A0tJNO/P05l3Zva+94hmadrXmYzctzBfuWZH3vnRq3njmuPSpqar4PgAAAAAAAMc6A5EAAAAAAAC6oa29Ix/9wfxc/8gz3aoriuTdF0/J718+3UMwAAAAAAA9rCiKjBpUn1GD6nPx9BEvrHd0lFnZ3JIHVzTngeXNeXB5c5pb9lVs3w3b9+ZPvj8//3LX8rz/sml53eljU1PtnjAAAAAAAEBXGYgEAAAAAADQRS2tbXnvNx7LnUu2dKtu1MD6/P2bZuf8KcN7KBkAANCrFixIZs365a+ZPz+ZObOT0gWZ9Stq58+fn5md1AIA0H1VVUWmjBiQKSMG5DfPnZCyLPP05l15YFlT5q5ozoMrtmb7nv2HvM/aZ/fkQ9958rnBSJdPy6tOHZPqqqIC7wAAAAAAAODYZiASAAAAAABAF2zZ2Zp3fOWRPLl2e7fqXn7yyPzVr52aIf379FAyAAAAAAAOVlEUmT6yIdNHNuTtF0xKR0eZhRt25MEVzXlgeXMeXrk1u1rbDrr/iqaWvP/6J/LPdy7LH7xsel4xc1SKwmAkAAAAAACAAzEQCQAAAAAA4FdYsWVX3v7lR7Jm6+4u19TXVuX/vmpm3nzOOA+3AAAAAAAcJaqqiswaOyizxg7KO18yOW3tHZm/fkceWN6UGx5fnyWbdh5U36WbduXdX3ssJ48emHe+ZFJeeero1NVUVzg9AAAAAADA0c9AJAAAAAAAgF/isTXP5h3//kie3b2/yzUnjR6Yf3zzaZna2NCDyQAAAAAA6Gk11VU5bdzgnDZucN590ZTc/NSG/MNtS7NiS8tB9Vu4YUf+4Nvz8hc/XJQ3nzM+v3Hu+IwZ3LfCqQEAAAAAAI5eBiIBAAAAAAAcwE8XbsrvffOx7N3f0eWad1w4KR++4kQnewMAAAAAHGOqqopcNXtM/tesUfnBE+vz6duX5pmtew6qV3PLvvzTncvyL3cvz8tPHpm3zpmY8yYPTVEUFU4NAAAAAABwdDEQCQAAAAAAoBP/8eDq/NkN89NRdu31A+tr8pk3n55LTmzs2WAAAAAAAPSqmuqqvOHME/Ka08bkP3+2Nv94x9PZsH3vQfVq7yjzo/kb86P5G3PiyIa89fwJee1pY9O/zlf9AQAAAACA41NVbwcAAAAAAAA4kpRlmb++dXH+9AddH4Y0ZlB9vvOe8w1DAgAAAAA4jtRWV+U3zh2fO//wkvz5q0/OiIa6Q+q3ZNPO/Mn35+e8T96ej9+0MCubWiqUFAAAAAAA4OhhIBIAAAAAAMDz9rV15IPfnpfP3rW8yzUzRjXke79zQaaPbOjBZAAAAAAAHKnqa6vz9gsm5Z4PXZo//l8zMrR/n0Pqt3NvW750/8pc+rd35W1fejh3Lt6cjq5O8AcAAAAAADjK1fR2AAAAAAAAgCPBzr37856vPZb7ljV1ueaCqcPyL9ecmYH1tT2YDAAAAACAo0HfPtX5rYum5DfOnZB/v39lvnDPiuzY23ZIPe9euiV3L92S8UP75VWnjs7lJ4/MaScMTlVVUaHUAAAAAAAARxYDkQAAAAAAgOPeph178/YvP5JFG3Z0uea1p43JX79hdvrUVPVgMgAAAAAAjjYD6mry3pdOy1vmTMwX712RL92/KrtaD20w0pqtu/PZu5bns3ctz/ABdbn8pMZcftLIXDB1ePr2qa5QcgAAAAAAgN5nIBIAAAAAAHBce3rTzrz9y49k3bY9Xa55zyVT8qGXn+gEbgAAAAAADmhQ39r8wctPzLsumpzvP74uX3lgVZZvaTnkvk27WnP9I8/k+keeSX1tVS6cOiIvO7kxL50xMiMa6iqQHAAAAAAAoPcYiAQAAAAAABy3Hl65Ne/8yiPZsbdrJ3MXRfKxq2bmrXMm9mwwAAAAAACOGQ31tXnrnIl5y3kT8sDy5nzlgVW5bdGmdJSH3nvv/o7ctmhTblu0KUXxVE4fNziXnzwyLztpZKY2DkhRGOwPAAAAAAAcXQxEAgAAAAAAjku3PLUhH/jWE9nX1tGl19fVVOUzbz49r5g5qoeTAQAAAABwLCqKIhdMHZ4Lpg7P2md352sPrsm3HlmTZ3fvr0j/skweW7Mtj63Zlr++dUkmDOuXl500MnOmDMsZ44dkSP8+FdkHAAAAAACgJxmIBAAAAAAAHHe+eN/KfOKHC1N28fTtwf1q88W3nZUzJwzt2WAAAAAAABwXThjSLx+5ckY+cPm03DRvfb4yd1Xmr9tR0T1WN+/Ov923Mv9238okyeQR/XPG+CE5c8JzP1NHDEhVVVHRPQEAAAAAAA6VgUgAAAAAAMBxo6OjzHW3LHrh4Y+uGDe0b/792nMyZcSAHkwGAAAAAMDxqL62Om88a1zecOYJefyZbfnqA6vyw6c2ZH97Fyf6d8OKLS1ZsaUl33l0bZKkob4mp48fkjPGD86ZE4bktHGD01BfW/F9AQAAAAAAusNAJAAAAAAA4LjQ2taeD357Xm5+ckOXa04ZOyhffPtZaWyo78FkAAAAAAAc74qiyBnjh+SM8UPyJ688Od98eE2+/tDqbNrR2mN77tzblnuWbsk9S7c8nyE5cWRDzpjwXI5Jw/unsaEuIxrqUl9b3WM5AAAAAAAA/icDkQAAAAAAgGPe9t3781v/8bM8tHJrl2suOXFE/vk3zkj/Oh+nAAAAAABw+IxoqMv7LpuW91wyJXOXN+e2RZty28JNWb99b4/uW5bJ4o07s3jjznzjoTU/d62hriYjGuoy/PkBSSMGPPf7vwYm/dfPsP51ae8os3Pv/uxqbcvOvf/1sz8797Y9v7Y/O//HtV3Pv3ZgfW2mjWzIy04emdPHDU5VVdGj7xcAAAAAADgy+QY/AAAAAABwTFu/bU/e/uWHs3TTri7XXH3WCfmL152S2uqqHkwGAAAAAAAHVltdlYumj8hF00fkY1fNzIL1O54bjrRoU+av23FYs+xsbcvO1rasaGrp0X1uX7w5n7t7eRob6vKKmaNyxaxROWfSUPfrAQAAAADgOGIgEgAAAAAAcMxatGFH3v7lh7NpR2uXaz5w+bS8/7JpKQonTwMAAAAAcGQoiiKzxg7KrLGD8oHLp2f9tj25fdGm/HTR5sxd3pT97WVvR6yozTtb8x8Prs5/PLg6g/vV5vKTRuaKmaNy4bThqa+t7u14AAAAAABADzIQCQAAAAAAOCY9sKwpv/0fj2Zna1uXXl9dVeS6183Km84e38PJAAAAAADg0IwZ3DdvmTMxb5kzMTv37s89S5ty26JNuWPx5mzfs7+341XUtt37851H1+Y7j65Nvz7VuXRGY14xc1QuPXFEGuprezseAAAAAABQYQYiAQAAAAAAx5wbnliXP/zPeV0+EbtvbXU++5tn5NIZjT2cDAAAAAAAKquhvjavPHV0Xnnq6LS1d+Rnq5/NbQs35aGVW7Nww460d3TtXvnRYPe+9vzwyQ354ZMb0qe6KhdOG54rZo7K5SePzND+fXo7HgAAAAAAUAEGIgEAAAAAAMeMsizzubtX5K9uXdzlmuED+uRLbz87p54wuAeTAQAAAABAz6uprsp5k4flvMnDkiS797Vl3jPb89iaZ/PY6mfz6Jpns233/l5OWRn72jtyx+LNuWPx5lR9L5k9bnBeMm1ELp4+PLNPGJya6qrejggAAAAAABwEA5EAAAAAAIBjQntHmY/dtCBfnbu6yzWThvfPV649J+OH9evBZAAAAAAA0Dv69anJnCnDMmfKcwOSyrLMyqaWPLr62eeHJG3L0s07U5a9HPQQdZTJ42u25fE12/KZ259OQ31NLpgyPC+ZPjwXTRuRcUN9DgAAAAAAAEcLA5EAAAAAAICj3t797Xn/9Y/nxws2dbnm9PGD88W3nZ2h/fv0YDIAAAAAADhyFEWRySMGZPKIAXnjWeOSJNv37M8Tz2zLY88PSXrimW3Zubetl5Memp1723Lrgo25dcHGJM8dkHDRtOF5ybQRmTNlWPrXeZQCAAAAAACOVO7iAwAAAAAAR7U1zbvzgW89nsfWbOtyzctOHpnP/Prp6dunugeTAQAAAADAkW9Q39pcPH1ELp4+IklSlmV2tbZly87W5352tb7wz5t3tv7cevOu1nSUXdunuqpIQ31NBtTVpKG+Ng31NWmoq0lDfU2qq6rywPKmbNi+t0fe48qmlqxsaslX5q5ObXWRM8YPyUXTR+SiaSMyc8zAVFUVPbIvAAAAAADQfQYiAQAAAAAAR6W29o78230r8w+3Lc3e/R1drrvmvPH52FWzUu3hBgAAAAAA+AVFUTw/sKg2k0cM+KWvbe8os7Vl3wsDkp5t2Zc+NVU/N/hoYH1NBtTXpG9tdYriwPfmy7LMk2u359YFG/Pj+Ruzoqml0m8tSbK/vcxDK7fmoZVb8zc/XpKpjQPywZdNz5WnjO6R/QAAAAAAgO4xEAkAAAAAADjqPLl2Wz7y3aeycMOObtV9+IoT856Lp/zSBy4AAAAAAICuqa4qMqKhLiMa6g65V1EUmT1ucGaPG5wPv+LELNu8K7fO35hbF2zMgvXd+zygO5Zt3pX3fP2xXDlrVD7+mlkVeS8AAAAAAMDBMxAJAAAAAAA4arS0tuXvf7o0X75/ZTrKrtfVVBX56zecmtefcULPhQMAAAAAACqiKIpMG9mQaSMb8nuXTcszW3fnxws25tb5G/PommdTduMzgq760fyNmbuiOX/+6pl5zWljHK4AAAAAAAC9xEAkAAAAAADgqHDnks356PfnZ922Pd2qG1BXk89dc2YunDa8h5IBAAAAAAA9adzQfnnnSybnnS+ZnM079uYnCzflxws2Zu7y5rR15wSFX2Hb7v35wLeeyE3z1ucvXndKRg2qr1hvAAAAAACgawxEAgAAAAAAjmhNu1rz8ZsW5sZ567td29hQly9fe3ZmjhnUA8kAAAAAAIDDrXFgfa45b0KuOW9CduzdnweWNefep7fknqe35Jmt3TtU4UBuX7w5D3/q7vzpK0/OG886IUVRVKQvAAAAAADwqxmIBAAAAAAAHJHKssx/Pro2f/HDRdm+Z3+366c2Dsi/X3t2ThjSrwfSAQAA/A91dcnJJ//q13S6XJeTf0Vt3QFqAQDgeDewvjZXzBqVK2aNSlmWWd28O/c8vSX3LG3K3OVNadnXftC9d+5ty4e/+2RuenJ9Pvn6U3zeAAAAAAAAh0lRlmVvZwAOUlEUc5I88D/XHnjggcyZM6eXEgEAAAAAVMbKppb88feeytwVzQdV/6azxuWjrzopDfW1FU4GAAAAAAAcDfa1deTxNc/mnqe35N6nm/LUuu052Mcn+vepzkeunJHfPHdCqqqKygYFAAAAAOCIM3fu3Jx//vkvXj6/LMu5vZHneFPT2wEAAAAAAAD+y/72jnzhnhX59O1PZ19bR7frJw/vn+tef0rOmzysB9IBAAAAAABHiz41VTl38rCcO3lYPvSKpHlXa+5f3px7lm7JTxZszI69bV3u1bKvPX96w4Lc/OSG/NWvnZqJw/v3YHIAAAAAADi+GYgEAAAAAAD0utXNLblp3vp897F1WdnU0u36mqoi77lkSn730qmpr63ugYQAAAAAAMDRbNiAulw1e0yumj0mm684MX/6g/n58YJN3erx0MqtueLT9+QPX35irr1gUqqrih5KCwAAAAAAxy8DkQAAAAAAgF6xacfe3Pzkhtw4b33mPbPtoPucMX5wPvn6U3PiqIYKpgMAAAAAAI5VjQ31+dw1Z+aWpzbm/94wP80t+7pcu3d/Rz7xw0X54VMb8jdvODVTG30+AQAAAAAAlWQgEgAAAAAAcNhs270vP5q/MTc8sS4Prdyasjz4XgPqavJ/rjgxv3nuhFQ5gRkAAAAAAOiGoijyylNH57zJQ/Oxmxbmxnnru1X/+JpteeVn7stf/toped3pJ/RQSgAAAAAAOP4YiAQAAAAAAPSolta2/HThptw4b33uWbolbR2HMAXpeS87eWQ+/pqZGT2obwUSAgAAAAAAx6thA+rymTefnledOjof/cH8bN7Z2uXa1raO/P635mXxhp358BUzUu0ABwAAAAAAOGQGIgEAAAAAABXX2taeu5ZsyY3z1uf2RZuyd39HRfo2NtTl46+ZmStmja5IPwAAAAAAgCR5+cxROXfSsHzihwvzn4+u7Vbt5+9ZkSWbdubTv356BvWt7aGEAAAAAABwfDAQCQAAAAAAqJj97R358v0r8y93Lc+zu/dXtPc1543Ph6+YkYH1HiQAAAAAAAAqb1C/2vzNG2fnVbPH5I+++2TWb9/b5dq7lmzJ6z57f/7trWdl8ogBPZgSAAAAAACObVW9HQAAAAAAADg2PLr62bz6H+/LdbcsrugwpKmNA/Kdd8/JJ157imFIAAAAAABAj7t4+oj8+PcvyjXnje9W3YotLXnNP9+fu5Zs7qFkAAAAAABw7DMQCQAAAAAAOCTb9+zPn3z/qbzhcw9k8cadFes7uF9tPvSKE/PD912YsyYOrVhfAAAAAACAX6WhvjafeO0p+ca7zs34of26XLdzb1v+978/kn+9Z0XKsuzBhAAAAAAAcGyq6e0AAAAAAADA0aksy9z05IZ8/KaFadrVWpGefWur87KTR+aq2WNy0fQR6VPjbAcAAAAAAKD3nD9leG79wEvyNz9eki/fv6pLNR1l8he3LMqiDTty3etPSX1tdc+GBAAAAACAY4iBSAAAAAAAQLetbm7JR38wP/c+3XTIvWqri1w8vTFXnTYml5/UmH59fHwBAAAAAAAcOfr1qcmfvXpmzpk4NH/w7XnZs7+9S3Xfe3xdlje15AtvOTMjB9b3cEoAAAAAADg2eKIAAAAAAADosn1tHfnXe1fkM7c/nda2fcO5XQAAIABJREFUjoPuU1Ukc6YMy1Wzx+SKmaMzqF9tBVMCAAAAAABU3pWnjM6EYf3zrq/+LOu27elSzbxntuXV/3hfvvDWs3LauME9nBAAAAAAAI5+BiIBAAAAAABd8siqrfmT7z+VpZt2HXSP08cPzlWzx+SVp45OY4OTkAEAgGPEsmXJa17zy19zww3J1KmdlC7La35F7Q033JCpndQCAACH38ljBubG916Q93z9sTy8cmuXajbvbM3Vn5+bv/q1U/K600/o4YQAAAAAAHB0MxAJAAAAAAD4pbbt3pe/unVxvvnwMwdVP2FYv1x91rhcNXtMxg3tV+F0AAAAR4DW1mThwl/9mk6XW7PwV9S2HqAWAADoHcMG1OVr7zg3f37TgnzjoTVdqtnX1pHf/9a8LN6wMx++Ykaqq4oeTgkAAAAAAEcnA5EAAAAAAIBOlWWZG55Yn/9388I0t+zrdn2f6qr87qVT8+5LJqeuproHEgIAAAAAAPSOPjVVue51p+Sk0QPzsRsXpK2j7FLd5+9ZkYUbduQdF07KnCnDfIYCAAAAAAAvYiASAAAAAADwc8qyzNwVzfnM7U/nwRVbD6rH+VOG5ROvnZXJIwZUOB0AAAAAAMCR4y3nTcjUEQPyO19/NM/+f/buPMzSqroX/3d10w3dDXQzI/MMMkhQVAbjACjilMQhRo1J1IgZjEluchPvvSYxTkl+ek1uNNdERdFoTIxmcIqzeBFUBEFAIDLPU4M0Mz3t3x9Vmrb6PV1VZ+iqrvp8nqcffPY+e73LDP0s9lnvOg+umdKZs69cmbOvXJltt94qTzl0lzzj8N3y1EN3zfIli0acLQAAAAAAzH4GIgEAAAAAAEmS9etbvnjZ7XnP16/O9268p68YOy5bnDc8+9H5uWP2TFUNOUMAAAAAAIDZ5/gDd8qnXvukvPrD5+eK2+6b8rn7H1mbz158az578a3ZakHl+AN3ytMP3y2nPHq37LFiyQgzBgAAAACA2ctAJAAAAAAAmOdWr12ff7/o5vzt16/O1Xc+0HecFx+7d15/2mHZYdniIWYHAAAAAAAw++2949J88tdPyH/7+EX5wvdvn/b5tetbzr5yZc6+cmX++N+/n6P2XJ6nH75bnn74bjls9+38EAUAAAAAAPOGgUgAAAAAADBPPbh6bf7xvBvz/rOvyS2rHu47zkG7bpu3/dxRecL+Ow4xOwAAAAAAgC3Lsq23ynte9rj8n69cmf/zlSsHinXJzatyyc2r8s4v/SB777gkT3/07jntqN1z7L47GI4EAAAAAMCcZiASAAAAAADMMz98YHU+9M3rcua51+WeB9f0HWfxVgvyupMOyulPPjCLt1owvAQBAAAAAAC2UAsWVH736Yfk0N23y+99/Ht5aM26gWPeePdD+cA51+YD51ybx+y1PL998sE56bBdDUYCAAAAAGBOMhAJAAAAAADmiVtXPZT3n31tPnbeDXlw9WDN9z998M55888cmf12Xjak7AAAAAAAAOaOZx31qOy709Kc/uELcvM9Dw0t7sU3rcqrPnR+jtpzbDDSyY82GAkAAAAAgLnFQCQAAAAAAJjDWmu57NZ7c+Y51+XfLro5a9a1geLtvO3i/NFzDs/zjt5Dcz0AAAAAAMAmHLHH8nzqtSfmj//9+/nsJbcONfYlN6/Kr374/By55/Z53UkH5+mH7+a7GwAAAAAA5gQDkQAAAAAAYI658e4Hc+7VK3POVXfl3Kvvysr7Hxk45qKFlV94/D75/WccmuVLFw0hSwAAAAAAgLlvp223zt+87LH5zVvuzecuuTVfvOy2/OD2+4cW/9Kb783pf39Bjthj+7zu5IPzDIORAAAAAADYwhmIBAAAAAAAW7i77n8k515914+HIN1w94NDi71s8cK87Lh988oT98/uy7cZWlwAAAAAAID55PA9ts/he2yf3z/10Fy38oF86bLb86XLbs/519+d9W3w+N+/5d685u8vyKMftX1+e3ww0oIFBiMBAAAAALDlMRCJH6uqw5McmWSPJNsmeTjJnUkuT3Jha23NDKYHAAAAAMC4+x9Zm29fc1fOuWpsCNIVt9039GfsuGxxXnHCfvml4/fL8qWLhh4fAAAAAABgvtpv52V59ZMPyKuffEDuuv+RfOWKO/Kly27P2VfemYfXrB8o9uW33ptf+8gFOWz37fI7pxycZxy+u8FIAAAAAABsUQxEmueqau8kr0vy0owNQurlvqr6VJK/bq2dt1mSm6aqWpDkkCSPG/9zbJJjMjbcaaL9W2vXbb7sAAAAAAAGc9uqh/Px82/MWf95R75306qsG8ZPBXfYc8WSvPqn98+LH79PlixeOJJnAAAAAAAAMGanbbfOzx+7d37+2L3z0Op1OfvKO/Oly27PV664I3c/sLrvuFfcdl9+7SPfzWG7b5fXnXxwnn74blm0cMEQMwcAAAAAgNEwEGmeGh8e9Pokb0iyZApHtkvysiQvq6q/T/JbrbVVI0xxUlV1WKY2/AgAAAAAYIt178Nr8n+/dnU+cM61Wb12sF8E3pSDd902v/7UA/Pco/fQDA8AAAAAADADlixemGccsXueccTuWbe+5YLrf5j/uPTWfPw7N+aB1ev6innFbfflNz763SzeakEOf9T2ecxey/OYvVbkMXstz4G7bJuFC2rI/y0AAAAAAGAwBiLNQ1W1JMk/J3l2nyFenuS4qjq1tXbt8DKbuqpakeTymXg2AAAAAMDmsGbd+nzsvBvyV1++cqBf/53MMfusyG889aCcfNiuWaDhHQAAAAAAYFZYuKDyhP13zBP23zGvO+ngvP8b1+TMc67rezDS6rXrc9GN9+SiG+9Jcn2SZOnihTlyj+V5zF7Lc9Rey3P0Xiuy705LU+U7IwAAAAAAZo6BSPNMVS1M8skkp/X4yJoklyVZmWS7JIcn2bbjcwcn+WpVndBau3UUuQIAAAAAzEettXz58jvyZ/9xea6584GRPecph+ySX3/qgXni/jtqagcAAAAAAJjFdli2OP/91MPyq086IGd849qcee51uf+RtQPHfXD1upx33d0577q7f7y2/TZb5TF7rRgfkLQ8xx2wU1YsXTzwswAAAAAAYKoMRJp/3pTuYUj3JPnTJB9sra360WJVLUryvCRvS3LIhDP7JflYVZ3cWuvvZyYAAAAAAPixS25albd+7rJ865q7J/9wH3ZctjgnHbZrXnHifjlij+UjeQYAAAAAAACjscOyxfn9Uw/Nr/70/jnjG9fmg+cMZzDShu59eG2+cdXKfOOqlUmSRQsrpx6xe176hH1y/IE7+aENAAAAAABGzkCkeaSqjk7yhx1b1yY5pbV2zcSN1tqaJJ+sqs8n+WSSUyd85ClJfi3J3ww53X60JFcluWD8z/lJtk/y7zOZFAAAAADAZG6556G8/Qv/mX+98Oahxl26eGGeuP+OOfGgnXPCgTvnsN23y4IFmtQBAAAAAAC2ZCuWLs7vPePQvOpJ++cD44OR7hvyYKQfWbOu5TMX35rPXHxr9t95WV7yhL3zgsfulZ223XokzwMAAAAAAAOR5pf/nWThhLUHkjyraxjShlprD1TV85Ocl+SICdtvqqoPtdbuH16qk+oafvTd1tqqDT9UVU/djDkBAAAAAEzLfQ+vyXvOujpnfOPaPLJ2/cDxFi2sHLPPDjnxwJ1z4kE75ei9V2TRwgVDyBQAAAAAAIDZZsXSxflvzzg0r3rSAfnAOdfmA+dcm/seHs1gpCS5duUDedvnrsg7vvCDnHrk7nnpE/bJcQfsmCo/yAEAAAAAwPAYiDRPVNWxSU7u2Hpza+2KqcRorT1YVa9Ocu6ErR2TnJ7knYNlOXXjg48O3lzPAwAAAAAYprXr1udj37kxf/WlH+SuB1b3HacqOWKP7XPigTvnhIN2zuP32yFLF7v6BwAAAAAAmE+WL12U3336IXnlk/bPB8+5Nmd8Y7SDkVavW59Pf++WfPp7t+SAnZflJU/YJy943F7ZcdnikT0TAAAAAID5w1sR88fpHWt3JXnXdIK01r5ZVV9IcuqErVdnMw5EAgAAAADYErXW8tUr7sjbPnd5rr7zgb7jHL33irzmyQfkhAN3yoqlGssBAAAAAABIli9ZlN855ZC84sT986Fzr8vHz78xN/3woZE+85qVD+Stn7s8b//Cf+aZR+6elz5xnzxx/x1TVSN9LgAAAAAAc5eBSPNAVW2V5IUdWx9trT3YR8j3ZeOBSIdV1WNba9/tIx4AAAAAwJx33coH8sZPfz9n/eedfcfYa4cl+cNnHpbnPOZRmsgBAAAAAADotHzJorzu5IPzWycdlFtXPZyLb1qVi2+6J5fcvCoX37Qqqx5aM/Rnrl63Pp/63i351PduyQG7LMuLj907Jxy4cw571HZZtHDB0J8HAAAAAMDcZSDS/HBckh061j/ZZ7zPJnkoyZIJ66clMRAJAAAAAGADD61el/ecdVX+9uvXZPW69X3F2G6brfJbJx2UXzp+v2yzaOGQMwQAAAAAAGAuqqrssWJJ9lixJM88cvckSWstN9z9YL5306pcctM9+d5Nq3Lpzavy4Op1Q3vuNXc+kD/7jyuSJFtvtSBH7bk8P7X3ihyzzw75qX1WZI/l2/jxDwAAAAAAejIQaX54Wsfag0m+2U+w1trDVXVukpMnbJ2U5K39xAQAAAAAmIu+dNnt+dNPfz83/fChvs5vtaDyi8ftm9edfHB2XLZ4yNkBAAAAAAAw31RV9t1pWfbdaVmed/QeSZJ161uuufP+Hw9JuuimVbn4pnvS2uDPe2Tt+px//Q9z/vU/THJtkmTX7bb+rwFJe6/IY/ZanmVbe70FAAAAAIAxboznh8d3rF3YWlszQMzzsvFApMcOEA8AAAAAYM644a4H86ef/n6+csUdfcc49Yjd8vrTHp39d142xMwAAAAAAADgJy1cUDl4t+1y8G7b5YWP2ytJcuPdD+Zj592Qj59/U1be/8hQn3fHfY/ki5fdni9ednuSZEElh+y2XY7ZZ0WO3mtFDtx12+y709Lssu3WqaqhPhsAAAAAgNnPQKT54TEda5cOGPPijrUVVbVva+36AWMDAAAAAGyRHl6zLn/79avzf8+6OqvXru8rxtF7Lc//evbhecL+Ow45OwAAAAAAAJiavXdcmj945mH53acfki9fdnv+4bwbcvaVK0fyrPUtueK2+3LFbfflY+fd+OP1pYsXZt+dlmW/nZb+5D93XprdttsmCxYYlgQAAAAAMBcZiDTHVdXiJHt3bF01YOire6wfkMRAJAAAAABg3vnqFbfnjZ+6LDfc/WBf5/dcsSR/8MxD89zH7KF5GwAAAAAAgFlh0cIFOe2oR+W0ox6VG+56MB/7zg355/NvzMr7V4/82Q+uXpfLb703l99670Z7W2+1IPtOGJT0uH13yGG7b5cq37UBAAAAAGzJDESa+/ZOsqBj/eYB4/Y6v9+AceeVqjp+wBCPm7hwySWXDBgSAAAAAJiO2+99OGd849qcf93dfZ1fumhhXnDsXnnWUcuz9UM35NvfvmHIGQIAADBy11wz+Wcuuii5d+OXeK+ZwtmLLroo93acBQAA2NyevDw5/ilL853rH86XLrs937vxnhnJ45Ekl1yfTOye33enpXnmkbvnyQfvkiWLvTIDAAAAAPSnx+yOpZs7j/mqWmsznQMjVFXHJflmx9bJrbWvDhB3YZK1HVt/2Fr7//qNO2xV9dQkX+vY2r+1dt3mzWZjVeX/AQEAAAAAAAAAAAAAAAAAAABgdju9tfa+mU5iPlgw0wkwcjv2WF81SNDW2rokD3Rs7TRIXAAAAAAAAAAAAAAAAAAAAAAA5icDkea+bXus3z+E2F0DkZYNIS4AAAAAAAAAAAAAAAAAAAAAwGxxwEwnMF8YiDT3LeqxvnYIsdd0rC0eQlwAAAAAAAAAAAAAAAAAAAAAAOaZrWY6AUZuYY/1dUOI3RXD/01NzwlDOP+OCWuvS3L+gHEBAGCuOjLJeyesnZ7k0hnIBQAAtgRqaAAA2HzU3wAAMD1qaAAAmDr1MwAATM+xSf56wto5M5HIfGR4zdy3tsf6MP533xVjzRDizhuttW8Ocr6qupbPHzQuAADMVT1q6EvV0AAA0E0NDQAAm4/6GwAApkcNDQAAU6d+BgCA6elRQ9+1ufOYrxbMdAKM3CM91hcPIXZXjF7PAwAAAAAAAAAAAAAAAAAAAACAngxEmvvu67G+3RBid8W4dwhxAQAAAAAAAAAAAAAAAAAAAACYZwxEmvvu6rG+YpCgVbVNkq2n8TwAAAAAAAAAAAAAAAAAAAAAAOjJQKS577Ye67sPGLfX+V7PAwAAAAAAAAAAAAAAAAAAAACAngxEmvtuSfJIx/o+A8btdf7aAeMCAAAAAAAAAAAAAAAAAAAAADAPGYg0x7XWWpKrO7YOGTD0wT3WrxowLgAAAAAAAAAAAAAAAAAAAAAA85CBSPPDhR1rRw8Y85iOtZtaaysHjAsAAAAAAAAAAAAAAAAAAAAAwDxkINL88O2OtcOravkAMY+f4nMAAAAAAAAAAAAAAAAAAAAAAGBSBiLND1/uWFuY5JR+glXVrkmOmeJzAAAAAAAAAAAAAAAAAAAAAABgUgYizQOttcuTXN2x9eI+Q/58kpr4mCSf6TMeAAAAAAAAAAAAAAAAAAAAAADznIFI88dHOtZ+tqr2nk6Qqqokv9mxdVZr7aa+MgMAAAAAAAAAAAAAAAAAAAAAYN4zEGn+eG+S1RPWFiV5yzTjvCLJYR3r755qgKq6rqrahD/XTTMPAAAAAAAAAAAAAAAAAAAAAADmEAOR5onW2i1JPtCx9UtV9aKpxKiqQ5K8s2Pr0iT/NkB6AAAAAAAAAAAAAAAAAAAAAADMcwYizS9/lOTujvW/r6qXbOpgVR2T5CtJlndsv661tn4I+QEAAAAAAAAAAAAAAAAAAAAAME8ZiDSPtNZWJnlVx9bWSf6hqj5XVT9TVbtV1cKqWlFVT6mq9yb5dpK9Os7+ZWvta6PMu5eqempVtU39SdIrt2uncBYAAAAAAAAAAAAAAAAAAAAAgM2kWjP3Zb6pqv+R5G1DCPWZJM9vra2Z5vOvS7LvhOXrW2v7TTPOU9N74NHAWms1qtgAAAAAAAAAAAAAAAAAAAAAAPykBTOdAJtfa+3PkvxuknUDhPlIkhdOdxgSAAAAAAAAAAAAAAAAAAAAAAB0MRBpnmqt/VWSE5NcMM2jtyZ5eWvt5a21R4afGQAAAAAAAAAAAAAAAAAAAAAA81G11mY6B2ZYVZ2S5BeTnJJkz46P3JPk7CSfSPJPs2UQUlVtn+TwUcVvrX1rVLEBAAAAAAAAAAAAAAAAAAAAAPhJBiLxE6pqRZI9kixL8nCSla21W2c2KwAAAAAAAAAAAAAAAAAAAAAA5joDkQAAAAAAAAAAAAAAAAAAAAAAgBm3YKYTAAAAAAAAAAAAAAAAAAAAAAAAMBAJAAAAAAAAAAAAAAAAAAAAAACYcQYiAQAAAAAAAAAAAAAAAAAAAAAAM85AJAAAAAAAAAAAAAAAAAAAAAAAYMYZiAQAAAAAAAAAAAAAAAAAAAAAAMw4A5EAAAAAAAAAAAAAAAAAAAAAAIAZZyASAAAAAAAAAAAAAAAAAAAAAAAw4wxEAgAAAAAAAAAAAAAAAAAAAAAAZpyBSAAAAAAAAAAAAAAAAAAAAAAAwIwzEAkAAAAAAAAAAAAAAAAAAAAAAJhxBiIBAAAAAAAAAAAAAAAAAAAAAAAzzkAkAAAAAAAAAAAAAAAAAAAAAABgxhmIBAAAAAAAAAAAAAAAAAAAAAAAzDgDkQAAAAAAAAAAAAAAAAAAAAAAgBlnIBIAAAAAAAAAAAAAAAAAAAAAADDjDEQCAAAAAAAAAAAAAAAAAAAAAABm3FYznQAwf1TVoiSPTXJYkl2SbJPk/iS3JLmktXb5DKYHAABJkqraJckxSQ5Ksnx8eVWSq5Jc2Fq7czPmsjRjNfShSXZMsjhjNfT1SS5urV2zuXIBAIBRq6rlGat/D0myIsnCJPcmuTbJRa21m2cwPQAAGLmqOjzJkUn2SLJtkoeT3Jnk8ozdT6+ZwfQAAGDOmU09IgAAMEpVtVeSo5Psn2T7JOuS3JPkB0m+21pbtRlz0R8CAABTNJ/fL6zW2kznAHNCVe2Z5HFJjh3/5+OS7Nbx0Ve01s4c4nPPTPLLw4o37vrW2n7DClZVT0jy20mem2S7TXz0liQfTfKu1tqNw3o+AACz00zV0D1yWZzkZUlek+QJSarHR1uSbyd5b5KPjOrlk6o6JclvJXlGxgaJ9nJ1kg8leU9rbeUocgEAYMtWVdcl2XfIYT/UWvuVYQSqqkry/CS/keTJ2fSPeVyS5IwkZ7TW7h/G8wEAYKZV1d5JXpfkpRkbhNTLfUk+leSvW2vnbY7cAACgX1U1ipcU/rS19sZBg8y2HhEAAOaeqjog/9Ub/aM/O3R89GmttbNGmMe2SV6V5FczNoy/l7VJvp7kPUn+pY3gpWP9IQAA9DIT9XNVnZXkKcOItYGvt9aeOqxg3i80EAn6UlV7ZOyl7cle3O4ybwYiVdWKJO9K8ovTPPpQkjcn+fNRXKAAALD5zaYaeqKqOjFjX5odOs2jVyR5VWvt3CHmsleS9yV55jSP/jDJf2+tnTGsXAAAmBtm80Ckqjo8yQcz9sLJdNyc5Ndba58eNAcAAJgpVbUgyeuTvCHJkmke//skv7U5f7EbAACmY7YORJpNPSIAAMwNVbV/frI/utfL211GNhCpqn4myd8k2XOaR7+dsd7ty4eYi/4QAACSzJ76eTYPRPJ+4X/Z1BRVoLfPJTl6ppOYzcYn8X0hyUF9HF+S5G1JTqiqF7XWHh5qcgAAzIRZWUNX1SuT/G2SRX0cPyzJWVX1mtbaB4eQy7FJPpOpD4ra0A5J3l9VT8jYF3/rB80HAABGqaqeleSfkmzbx/E9k/x7Vf1Ja+3Nw80MAABGr6qWJPnnJM/uM8TLkxxXVae21q4dXmYAADB3zaYeEQAA5pQLkyyf6SQ2VFV/nOSNSaqP409M8u2qenFr7T+GkIv+EAAANjTr6ufZxPuFP8lAJGDoqupRSb6a3r86fl+Sy5Lcn2SXJI9O95eLz0nyyap6Xmtt3ShyBQBg/qqqX0zy/vT+su/6JNeN7++fZO+OzyxKckZVPdJa+4cBcjkiyRfTe6L13UkuT/JIkkdl7JcKF3R87vQkLcmv9ZsLAACMWlU9Lcm/JNm6x0duS3JlkrVJ9klyYFeYJG+qqjWttT8fSaIAADACVbUwySeTnNbjI2sy1lOxMsl2SQ5P94siByf5alWd0Fq7dRS5AgDAXDGbekQAAGCUqup/JvnTHtstydVJbsxYfXtwul+03i7Jv1bVM1trZw2Qi/4QAACYIu8XbsxAJJib3pLkswOcf6Tfg+ONe/+Y7mFI/5nkfyT5dGtt7QZnViR5RZI/ycYT/Z6VsUuYN/SbEwAATFRVRyV5b7ob3T6a5K2ttcsnnDkiyf9K8pKJ4TI2PfmS1tolfeSybcZefum6rDgvyf9M8tXWWtvgzO5Jfj3JH2bjLwlfU1Xnt9beP91cAACYN56fZJAXpu/s92BV7ZGxX/7ranb7fJI/aa2dN+HMfkl+L8lvZOMv7t5aVd9trX2x35wAAGAze1O6hyHdk7H+iA+21lb9aLGqFiV5XpK3JTlkwpn9knysqk72Q1MAAGwBjh/w/E39HJpNPSIAADBKVfWMjL1XONH6JO9O8s7W2vUTzhyXsbvpZ0w4s3WSf6qqY1prt/SRi/4QAAC2NL+Z5LsDnL+334PeL+xWG/z3Baaoqi5KcvSE5duSXDD+5/zxf97ccfwVrbUzh5jLmUl+eZTPmI6qem2Sd3VsfS7Ji1prD27i7IFJvpKNhymtS/LY1trFQ0sUAIDNapbV0AuSfCvJ4ydsrU9yemvtjEnOvzrJ32XjRrnzkhzXpvkv2lX1jox9eTfRGUl+bcNhoh1nH5/kC9n4suO+JIe01m6bTi4AAMw9VXVdNr5z3b+1dt3mzyapqk8keUHH1p+21t44ydlnZ+zLvolf2l2f5NGttYeGkiQAAIxIVR2dsbvwhRO2rk1ySmvtmk2cXZaxevjUju3Xttb+ZmiJAgDAgKpqo96J1lrXQKJR5zGrekQAAJh7quqeJMsnLN+Qn+yPXjn+nyd6WmvtrCHlsTTJ5Un2mbD1cJLnt9b+Y5Lzb07yho6tT7TWXtRHPvpDAADYyCyqn89K8pRRxZ8u7xd222qmE4At1G0Ze1H7R3+pXtBa2+jF7arN/r3djKqq7TL2S4YTXZrkhZNdNrTWrq6q0zL2P9elG2wtTPKObDxpGgCALcdsqqFfmo0b3ZLkjZM1uiVJa+19VfWojP0ayoaekLFfBvyHqSZSVfsneV3H1pcy1ni3fpJcvlNVL0jy5fzkL6H8qDY/faq5AADAqFXVk9Ld7PaByZrdkqS19tmqOj3JhyZs7Zvkd5O8beAkAQBgtP53Nh6G9ECSZ21qGFKStNYeqKrnZ+zF6yMmbL+pqj7UWrt/eKkCAMCcMGt6RAAAmLNuSHJVNviR2Nbayg0/UFX7bYY8/ls2HoaUjPUjb3IYUpK01v6oqvZM8ooJWy+sqhNaa+dONRH9IQAAbMJsqZ9nDe8X9lZ+lABGp+vXTZK8orV25hCfcWaSXx7lM6aRy+8neXvH1vGttW9NI87rk/xZx9axrbUL+s0PAIDZbzPV0JckOXLC8qVJfqq1tm6KMbZKclE2funkktbaY6aRy7uT/OaE5Ycz9usl100jzt8mec2E5dVJ9mut3TrVOAAAzD1VdV3GGsI2tP906s0h5vKZJM+esHxHkoNba/dOI87nk5zaEWff1trDg2UJAACjUVXHJvlOx9brW2t/MY04xyfpevHk91pr7+w3PwAAGKau/o8raoVQAAAgAElEQVTW2mb/pdnZ1CMCAMD8Nf5C97UdW09rrZ01hPhLklyfZJcJW59vrZ02jTjLk/wgya4Ttj7dWnveNOLoDwEAoG+jrp/Hn3FWkqeMKv40c/F+YQ8LJv8IwJS9umPt89MZhjTur5PcPcX4AAAwZVV1QjZudEuSt0y10S1JWmtrk7ylY+uoqjpuirlsk+TlHVtn9vFy+luTrJ2wtjgbD08FAIAZUVV7JelqsnvndJrdxr2xY23XJD873bwAAGAz6vrFvbuSvGs6QVpr30zyhY4tPRUAALCB2dQjAgAAI/Zz2XgYUtLdX9FTa21Vkr/s2Hp2Ve0xlRj6QwAAYOq8X7hpBiIBQ1FVj0tySMfWe6cbq7X2YJJ/6Nh60fivrAAAQL9e0rF2V5J/6SPWJ9M9yPOlUzz/7CTbd6z3U0PfmOTzA+QCAACj9uJs/L3U2iQfmG6g8SH8l3ZsqX8BAJiVxnsdXtix9dHxHonpel/H2mFV9dg+YgEAwFw1m3pEAABglLpq34tba9/uI9YHkkwcILogyS9M8bz+EAAAmDrvF26CgUjAsHRNbn4oyX/0Ge8THWs7Jnlin/EAACDprls/1VpbM91A42c+NcVnTDWXa1trF043l3FdNfRRVbVnn/EAAGCYuurfs1trd/YZr6v+PamqFvcZDwAARum4JDt0rH+yz3ifzVhPxkRTvZ8GAID5YDb1iAAAwEiM90mc1LHV1/1za+2OJGd3bA3SH60/BAAAunm/cBMMRAKG5Wkda+e01h7uM943092813VBAwAAk6qqvZMc2LH1lQHCdp09aPxZk+mqoYedS6KGBgBgho03oZ3YsTXs+ndZDNUHAGB26roPfjBjvRHTNt6LcW7HlvtgAADIrOwRAQCAUXlikqUd68OufZ9UVYs2dUh/CAAATJv3CzfBQCRgYFVVSR7XsfXtfmO21lYnuahjq+s5AAAwFY/vsd533ZrkvB7rm6xbq2rHJAcMM5fW2k1Jbp1uLgAAsBkcmWSbjvVBavHvJlnXsa7+BQBgNuq6n76wtbZmgJhd99OPHSAeAADMJbOmRwQAAEasq/Zdm+SCAWJ21b7bJDliknP6QwAAYIq8Xzg5A5FgDquqBVW1a1UdXlXHVNV+VbX9CB61b5LlHeuXDhj34o61oweMCQDA/PWYjrWHklw9QMwrkzzcsT5Z3dqVS6KGBgBgM6qqxVW1Z1UdXVVHjf/nJSN41NDr39bag0mu6thS/wIAMBt11cSjuA9eUVX7DhgXAABGqqqWVNU+473NR1TVo6pq6yE/Zjb1iAAAwCh11b5Xt9a6atep6rp/TmagP1p/CAAAm1tVbTV+b33UeI/13lW17Qge5f3CSWw10wkAI/HzVfWyJMcl2egv16q6P8m3knwjyWdba+cP+LwDe6x3XTZMR9eXjntX1VattbUDxgYAYP7pqluvaa21fgO21lpVXZPk8AlbXdOZJ8slGU0NPVkuAADMP39SVUckOSYd3xVV1W1JzsnYHfInW2s3Dvi8rvr3/tbabQPGvTrJoRPW1L8AAMwqVbU4yd4dW6O4D07GauLrB4wNAABDV1X/N8mTkhyRjh92rqrrM3Y3fXaST7TWVg7wuNnUIwIAAKPUVfsOdP/cWrutqh5IsmzCVj/90fpDAADYUvxGVb05yeOTbDTEv6ruTnJuxu6x/621dsWAz/N+4SQ2+iIBmBNOS3JKOoYhjdt2fP+NSb5TVWdX1c8O8Lz9eqzfPEDMXucXprtREAAAJrNfx9qgNWuvGF3Pmmz/kQGb+XrlsldVGYgMAMCGfiVjX9b1qhN3T/KCJH+Z5Jqq+lhVHTPA8/brWLtlgHg/0k8tDgAAm9ve6e7RGkVPRaImBgBg9vr1JEel9zsM+yZ5aZL3JLmhqv6uqg7q81n7dazNVI8IAACM0n4da8Oofbv6OrqeNdm+/hAAALYUL8rYUP+NhiGN2zHJc5L8WZLLquqzVfXUAZ63X8ea9ws3YCASkIz9xfyvVfXPVbWij/O7dKy1JHcMllZ6TX/ueh4AAEymq468fQhxu+rWyWrWrv1B6+deuSzI2IULAAD0Y6skv5DkvKr6o6rq57ul2VSLAwDA5tarRh20Ju51Xk0MAMBcsCTJ6Um+V1Wn93HevTQAAPPFbKp9Z1MuAAAwSpXkWUm+VlXvrqpt+ojh/cJJGIgEbOiFGfvi8IBpnuv6y++B1tq6AfO5t8f6TgPGBQBgfuqqW1cNIW5X3TpZzbo5c0nU0AAADG6rJG9K8oU+vrTbnPXvkqpaMoTYAAAwLL0aygaqicd7Mh7o2HIfDADAXLI0yd9V1YerqqZxbjb1iAAAwEhU1dIkW3dszYf+aP0hAADMFr+Z5FtVNd27Yu8XTmKrmU4AGKork3whyQVJvp/kxiT3JVmdsb8Qd0vyxCSnJPm5JIs6YuyT5PNVdWJr7c4pPnfbjrX7p5d6p67GvSRZNoTYAADMP5uzbp2sZlVDAwCwua1P8p0kX07yvSSXZexXRFZl7PuiHZLsm+SEJM9N8uQecU5J8tGqelFrbf0Unz0T9e9DQ4gPAADD0FUPJ8OriSfe/7oPBgBgNlmd5NwkX0lyaZLLk6zM2AsZW2fsbvrAJCcmeUGSY3rEeXmSu5L87hSfO5t6RAAAYFRGff880Wzsj9YfAgDAIFqSS5J8McmFGZvRcVvG7rDXZ2xGx55Jjk9yapLTkizoiHN0kk9X1cmttanWqN4vnISBSLDluzXJXyT5QGvtB5v43O3jfy5O8r6q2iPJW5K8ouOzByf5xyQnTzGHrsFKa6d4dlPW9FhfPITYAADMP5uzbp2sZlVDAwCwuVyc5C+TfKS1dlePz6xO8mCSmzP2Yso7quqYJH+TsS/wJnp+kjckedMUc1D/AgAwn3XVw8nM3U8DAMDm8M0kZyT5p9Zarxc41mTs5Y4bk5yV5K1V9dQk70lyWMfnf6eqLmytfXgKz59NPSIAADAqs+3+WX8IAABbimsy9iOzZ7bWbtrE524d/3N+kndV1UEZ68t+Tsdnj89Y7/Urp5iD+nkSXZOngC1Ia+1/tNZeP8kwpK5zt7TWXpnkpUnWdXzkpKp63hTDLexY64o5Xb1iGOYGAEA/NmfdOlnNqoYGAGCzaK09r7X2fzYxDKnXuQuT/HSSv+7xkT+oqkdNMZz6FwCA+ayrHk5m7n4aAABGrrV2QmvtjE0MQ+p17qwkj03yiR4feVtVLZlCqNnUIwIAAKMy2+6f9YcAALBFaK29srX2lkmGIXWdu6q19twkf9DjI79cVT81xXDq50kYiATzXGvtY0l+rcf226YYpmvS3DD+QuwVo9dUOgAA2JTNWbdOVrOqoQEAmPVaa+uS/E6Sj3RsL0vyhimGUv8CADCf9fr1vpm6nwYAgFmttfZQkpcl+VrH9p5JXjuFMLOpRwQAAEZltt0/6w8BAGBeaK29PclbO7YW9Fjvon6exBY3wQmmqqq2T3J4n8evbq3dOcx8ZrPW2vur6iVJTpqwdURVHdZau2KSEI90rC0eQmq9YnQ9DwCAAc2DGvqRJIsmrI2qbp2sZlVDAwDwY7O5Fm+ttar6rSSnJdlpwvbzq+q1rbU2SRj1LwAA81mv+nSm7qcBAGDWa62trqpXJ7ksG9e9L0jy9klCzKYeEQAAGJXZdv+sPwQAgPnkjUlemOTQCetPr6rtWmv3TXJe/TwJA5GYyx6b7l8GmYpXJDlzeKlsEd6cjQciJcmzkkw2EKnrL+PtBs6od4x7hxAbAICNzfUa+r4k205YG1XdOlnNqoYGAGBDs7oWb63dU1XvTvInE7Z2T3JMku9OEmJz17+TfYEIAACbU6/6dKbupwEAYIvQWru6qj6W5JcnbD2+qnZura3cxPHZ1CMCAACjMtvun/WHAAAwb7TW1lbVnyf54IStRUmenuRfJgnh/cJJLJjpBIBZ4xtJ7ulYf/wUzt7VsbZNVW09WEpZMY3nAQDAZLrqyF4153R0xZisZt2cufR6HgAATMdneqz3e4c8qvr33tbamiHEBgCAYel1PztQTVxV2yTp6stwHwwAwFzSdTe9IMnjJjk3m3pEAABgJFprq5Pc37E1H/qj9YcAADAbfC5J61ifbf3VvZ43qxmIBCQZm0CX5OKOrd2mcPy2Huu795/RJs/3eh4AAGxKVx05aM3aK8ZkNWvX/i5VNei/p3fl8ki6h58CAMB0XJjuL+z6vUOeqVocAAA2Nz0VAADQvwt6rE92N+1eGgCA+WI21b6zKRcAABi51todSW7s2Oq3v9r7hRswEAnY0B0da7tO4dy1Pdb3GSCXXucfjgsLAAD601W3Dlqz9orRq0be1P7CJHuOIJfrWmtdL64DAMCUtdbWpfuXQfq9Q96zqhYOllVftTgAAGxut2SssWyiUfRUJGpiAADmlq7e5mTyu+nZ1CMCAACjNPTad7yfY48pPmuyff0hAADMdcOc0eH9wg1sNdMJwKi01s5KUjOdxxyweAqfubLH+iFJzh7g2Qd3rF21Jf5lCwCwJZgHNXRX3bpvVS1ura3uJ2BVbZ3uS4JeNfJk+4ekeyr0VHXV0JPlAgDADNvCa/F+75AXJdkvydUDPFv9CwDArNdaa1V1dZLDJ2wdMmDorno4Sa4aMC4AAGwJJrubnk09IgAAMEpXJnn6hLVB75/3y1hfR9ezJstlIv0hAADMR4PO6PB+YZIFM50AMKt0TZq7d7JDrbU7k9zcsXX0gPkc07F20YAxAQCYvy7sWFuY5MgBYh41HmOiyerWS5Ks7Vjvu4auqupxXg0NAMDAxn+tb6eOrUnvkNNdiyeD1b87J9mrY0v9CwDAbNRVE4+ip+Km1trKAeMCAMBs0utXtCe7m55NPSIAADBKXbXvXlW14wAxu+6fk8lrX/0hAADMR33N6Ij3CydlIBKQJKmqrZI8pmPrhimG+HbH2gkD5LMiyaOn+BwAAJiK85Os71jvu25NcnzH2rokF2zqUGvt4SQXDzmXI5Ns17GuhgYAYBiOSVId61O5Q746yV0d68OuxRP1LwAAs1NXnXp4VS0fIGZXTaweBgBgrnlcj/XJ7qZnTY8IAACMWK974WHXviuTXDPJOf0hAADMK1W1S5K9O7Ym7a/2fuHkDEQCfuSnk6zoWO81mXmiL3esHTP+l3g/Tkn331FdzwEAgEm11u7JWMPbRKcOELbr7Pnjz5pMV2170viw0mHlsibJ1/uMBwAAG3puj/VJ75Bbay3JVzq2hl2L39Zau3SAmAAAMCpd98ELM9YbMW1VtWu6f6FbTwUAAHNNX3fTs7BHBAAARuXSJLd3rA+79v3KeP9HT/pDAACYh56T7h+cHWRGh/cLxxmIBPzIG3qsd11CdPlskomXGguSvKjPfH6hY+3K1toVfcYDAIAk+XTH2jOqaofpBqqqHZM8vWPrUwPkskOSZ0w3l3FdNfRZrbX7+owHAABJkqpakeS1HVv3JTlvimG66t8jq+rwPvLZKskLp/gMAACYca21yzP2y9gTvbjPkD+fjRvqWpLP9BkPAABmnao6MMlLOraubK3dOIUQs6lHBAAARmJ8CFHX3fALq2rhdONV1ZFJjujYGqQ/Wn8IAABzzni9+vqOrZbka1MM4/3CTTAQCUhV/WqSkzq2rknyzanEaK3dkOT/dWy9tqq6ptptKp+9k/xMx9ZHphMHAAA6fDQbD/JcnOQ1fcQ6ffzshlqSf5ji+XOSXNex/rrpJlJVxyV5XMeWGhoAgIGM3+++K8mOHdufaK09MsVQ/5rkgY71ade/GWt2261jXf0LAMBs1lWv/ux4j8SUjdfov9mxdVZr7aa+MgMAgFmmqhYneV+SRR3bU70Lnk09IgAAMEpdNfLuSV7UR6yuH8y6P8m/T/G8/hAAAOaLNyY5pGN9Ov0b3i/cBAORYAtVVYdV1bFDiPOSJH/bY/svxqdET9W7O9YeneRXppnWW5NsNWHtkYx9sQkAAH1rrV2b5HMdW/+9qnaaapyq2jnJH3Rsfaa1dt0Uc2lJ/qZj69Sqeto0cqkkf9GxdUeSj081DgAAc0tVPbWq9howxsIkf5XkFzu21yV5+1RjtdYeSHJmx9Yrq6rry8BeOW2d5M0dWxe31rqG9gMAwGzx3iSrJ6wtSvKWacZ5RZLDOta7ejYAAGCzqqrTptN/0SPGkowNM+rqnbgv3b0WG5lNPSIAADBiX09yacf6m8aHjU5JVR2a5JUdWx8c7/uYlP4QAABms6p6/HjdO2ic30/yv3ps//lU43i/cNMMRIIt12FJvlNVX6uqF1fVdtM5XFWPqqr3Z+yXSRZ2fOQ7Sd4/zZz+Jcn3O9b/sqoOmmJeL07y8o6tM1prt04zHwAA6NL1csmOST5YVZP+e/L4S+EfTLLDhK2WseGe0/F3Se7sWP/geEPdVPxBkid3rL+jtfbwNPMBAGDu+Nkk11TVh6vqpKqaOIR+k6rqp5L8v/T+hZG/aq1dPs2c3p6x4fcbWpTko+MvuEzFXybpum+e7kvkAACwWbXWbknygY6tX6qqKf1K9/jLIu/s2Lo0yb8NkB4AAAzLa5LcUFXvrqrjxl/CmLKqekqSC5K8sMdH/mdr7a5phJxNPSIAADAS4y9Rd9W+B6f7TnkjVbU0Y4NJF03YejjJO6aZkv4QAABmqxOTXF5V/1ZVz6mqbaZzuKoOrKpPpfePyn6ytfbFaebk/cIeDESCLd9Tk/xjkjur6nNV9caqen5VPbqqdq+qpVW1qKp2qaqjqupXq+ofk1yf5FU9Yt6R5EWttfXTSWT8810vxyxP8pWqOnpT56vqZUk+3LF1d5I/nk4uAADQS2vtW+muO5+bsS/alvY6W1XLMjZU9Dkd2x9urX17mrncl+QPO7b2zVgNvd+mzo9Pk/6zjq0r///27j3a1rqsF/j32bC5bEUQxBtqoomhpQJ2FBUFJSM1tTKzMguzTuUpL2Sl45yjad46dswxjml5CVMr09JUxLtw8KQm4CWhxEDiYpGgGxDk/pw/5nKIk3fuveZac6137b0/nzHWYKzf732f59mbzWaOuX7z+yZ5zTyzAACwU9qcSQD9x5JcUlV/WVW/XVWPXvqB3IFVtUdV7bUUon9kVZ1QVack+VySh8yo+8kkL5h3mO7+tww/feSBSd6/rR/aVdXuVfXHSX59YPvU7n7nvPMAAMAI/kcmZyCmvbWqfnZbN1bVYZm8tt93YPu35j3jAQAAa2hLkmcm+VSSi6rqzVX1W1V1dFUdXFUHLJ1t3lJVB1XVI6rqBVV1ZpJTkhw6o+7fdPf/mWeQjXRGBAAA1lJ3vyPJqQNbz6yqP9rWg7SWzmuclOSIge1XdvcFc87ifAgAABtZJXlCkvdlktHxd0vvUT+uqg6pqtsvna3eo6ruUFWHV9Uzq+r9Sc7J5P3lIeckeca8w/h84Ww1CX8F5lVVa/kfzzHdfcp2+j8xybvXoPdFSY7r7rNWWqCqXp3k2QNb12fytMO3J/likm8lOTDJkZk8EeZHZ5R8Qne/d6XzAACwMYz9Gnpqlv0y+YD33Qe2L8jkqSInJzl/ae0eSY5L8twkdxm456tJDu/urcue+HvneXeSJw5sXZXktUneleTsTJ6WcqdMEpt/M8mDBu65LslDu/v0lcwCAMDOYelw2LPWoPSpSR7f3Ves5Oaq2iPJaUn+y8D2ZUn+OMl7M/kh3A1J7prk2Ezecx76EMw3kxy2dJgOAAA2vO2c9zg5kyf/fTrJpUn2SXL/JD+f5JdyyydzJ8mru/u5i58UAADmV1XvyeSDJIv2N0me2t3Xz3vjRjsjAgDAzmXpw8lfXcMWB3f3+XPM8rkk+w1sn53Ja9+PZfL5wc1J7pXJ6/dnJdl/4J7PJDlqha/DnQ8BAOAWxn79XFXPzuR18aKdleRHu/vilRbw+cJbEogEKzT2h7nXKBDpbUl+c7U/oKuqzZnM9tgFzPT87n7FAuoAADCysV9DT6uqH8rkyYJDP8Cbx2VJju7uL620QFXdJpMfMD5wlbPclOQXuvsvV1kHAIAd3BoEIl2X5IVJ/ld337iaQlV1UCaH3g5e5UzfTvLY7v7EKusAAMC6qqrnJ3nZAkq9P8lPruTDKAAAsBbWIBDpiiTP6e43r6bIRjojAgDAzmXsD3RPq6pHJjkpyV6r7Htekoev8gPdzocAAPA9xn79vAaBSDcleU2SF3T3Nasp5POFt7Rp7AGAFbs4kwS31bopyQcySZz7hUU8rWTpoN1PJXn7KsrckORZwpAAAFgr3f1PSY7O6t5EOS8LOOjW3VckeXSSj66izFVJnrIzvFkBAMBCfCmT95FX66okb0zygO5+xWrDkJJk6bDcIzJ5KuFKfT3JjznsBgDAjqi7X57kOUlW8/r6bUmeJAwJAIAN5owkly6gzjcy+VDKD642DCnZWGdEAABgLXX3x5P8WFb3uvzMTF77rurcifMhAABsQP+ayXu9q3VdknckObK7n7vaMKTE5wuHVHePPQPskKpqLf/jOaa7T1nmHLdPclSSI5I8IMkPJDkoyR7buO28JP+Y5DNJ3t3d/7aqabc93y8keWWSO81x2xlJfqO7/3FtpgIAYAwb5TX0tKq6bSZP4v6VJLst87Ybk/xZJunNqw4VvdksuyX5zSQvSrLvHLd+NMl/6+4vL2oWAAB2DlV1SJKHJjksyf2T3CvJHTL7oRk3JDkrk/ePP5Xk75Z+wLYWs+2V5L8nOSHLfzJhJ3lnJk8E/9pazAUAAOulqh6U5LWZnPlYrn9P8jvd/ba1mQoAAFanqirJDyU5Mt99b/oeSQ5MUjNuuzbJFzI53/zJJH+/iA+QDMy2Yc6IAACwc6iqu2d1wZvbc3B3nz/vTVV1UJL/neSnM/t1+LRrkrwqyUsX+Xrc+RAAAL5jo7x+rqq7ZpLRcXgmGR2HZJKHsfuMWzrJv2TyHvanMzlf/Z+LGHhgNp8vXCIQCVaoqh68huXPXs0HTJZ+kHj7TP6C25LJX7xXJNmaZGt3X7eQKZc/z55JfibJkzL5H8N+A5ddlMlfsm/v7tWk1gEAsEFt5NfQSVJVd0vyy0kem8lhvOk3MG7I5PDdSUne1N0XrKbfdmbZJ8nTkjwxkwOCt5q6pDMJOv1QkrcIEwUAYB5VtXuSOybZJ5P3kG9Kcnkm7yFf3t03rvM8ByY5PsnjkzwwyZ5Tl9yU5J+TnJzkzd39z+s5HwAArLWqOjbJU5Mcm8lDsKZtTXJakncleUd3X7uO4wEAwEJU1R6ZvDd96yR7ZxI0tDWT96cv7+6b1nGWDXNGBACAHdvS5+YOW8MWn1vNe8JVdWgmr32PS3JobvkArWuTfDbJe5P8eXdfutJey5jF+RAAgF3cRn79XFWbMnno7L6ZvIe9Kd89X721u29Y2JTLm2eX/3yhQCRg3VXVnZLcLpNE56uSXNzdl487FQAAfFdVbU5yt3w3RfnyJBd09/UjzFJJ7pJk/ySbk3wryYXdfdV6zwIAAGtt6akmd80kWH+3TML+L1yLJ4EDAMBGVFX7JblzJgfZrklyaXf/+7hTAQDAzmsjnREBAIC1VFV7ZfLad598N6D0wvV+cNbSLM6HAADAMu2qny8UiAQAAAAAAAAAAAAAAAAAAAAAAIxu09gDAAAAAAAAAAAAAAAAAAAAAAAACEQCAAAAAAAAAAAAAAAAAAAAAABGJxAJAAAAAAAAAAAAAAAAAAAAAAAYnUAkAAAAAAAAAAAAAAAAAAAAAABgdAKRAAAAAAAAAAAAAAAAAAAAAACA0QlEAgAAAAAAAAAAAAAAAAAAAAAARicQCQAAAAAAAAAAAAAAAAAAAAAAGJ1AJAAAAAAAAAAAAAAAAAAAAAAAYHQCkQAAAAAAAAAAAAAAAAAAAAAAgNEJRAIAAAAAAAAAAAAAAAAAAAAAAEYnEAkAAAAAAAAAAAAAAAAAAAAAABidQCQAAAAAAAAAAAAAAAAAAAAAAGB0ApEAAAAAAAAAAAAAAAAAAAAAAIDRCUQCAAAAAAAAAAAAAAAAAAAAAABGJxAJAAAAAAAAAAAAAAAAAAAAAAAYnUAkAAAAAAAAAAAAAAAAAAAAAABgdAKRAAAAAAAAAAAAAAAAAAAAAACA0QlEAgAAAAAAAAAAAAAAAAAAAAAARicQCQAAAAAAAAAAAAAAAAAAAAAAGJ1AJAAAAAAAAAAAAAAAAAAAAAAAYHQCkQAAAAAAAAAAAAAAAAAAAAAAgNEJRAIAAAAAAAAAAAAAAAAAAAAAAEYnEAkAAAAAAAAAAAAAAAAAAAAAABidQCQAAAAAAAAAAAAAAAAAAAAAAGB0ApEAAAAAAAAAAAAAAAAAAAAAAIDRCUQCAAAAAAAAAAAAAAAAAAAAAABGJxAJAAAAAAAAAAAAAAAAAAAAAAAYnUAkAAAAAAAAAAAAAAAAAAAAAABgdAKRAAAAAAAAAAAAAAAAAAAAAACA0QlEAgAAAAAAAAAAAAAAAAAAAAAARicQCQAAAAAAAAAAAAAAAAAAAAAAGJ1AJAAAAAAAAAAAYJdUVfeoqhdU1Xur6tyq+kZV3VhVPfX1xGXU2r2qfqqqXldVp1fV16rq6oFan1+PXxsAAAAAAAAAAOyIdh97AAAAAAAAAAAAYNdQVbdNcp8k90hyQJJbJbkxyVVJLklyXpKzuvvb6zDHnyR5chbwULmq+skkr0lyl9XWAgAAAAAAAACAXZlAJAAAAAAAAAAAYM1U1f2T/FySxyS5b5Lazi3XVdUZSd6d5K+7+8IFz3PHJP+Q5OAF1fvdJK9YRC0AAAAAAAAAANjVVXePPQMAAAAAAAAAALCTqapHJHlhkmNWUebGJH+V5EXdfe6C5vpEkqPnvO0nuvs9A7UemeQjSTbNUesL3f2AOfvvtKrquOm17v7gGLMAAAAAAAAAADA+gUgAAAAAAAAAAMDCVNV+SV6T5GkLLHtNkhcneWV33wh2/zMAABL8SURBVLTSIlV1bCYBRtO+lOQtS/+8Isl0jy939zcH6n0yyUOnlq9N8rYkH0vy70uz39xV3f1P80+/c6qqWxxg6+4aYxYAAAAAAAAAAMYnEAkAAAAAAAAAAFiIqrpvkvck+f7tXLo1yblJLk+yW5LbLt2zZTv3fTDJz3b31hXO944kT55a/vskT+ruG+asdWiSs6eWr09ydHf/w0rm2xUJRAIAAAAAAAAA4OZ2H3sAAAAAAAAAAABgx1dVhyX5aJL9Z1zylSR/luR93f3lgfs3JTk8yZOSPD3JgQM1jkvy0ar6ke7+5grGfNjA2vPmDUNactTA2juFIQEAAAAAAAAAwMptGnsAAAAAAAAAAABgx1ZV90jykQyHIX0rya8nObS7XzUUhpQk3X1Td5/e3b+X5J5JXpXkpoFLj0hyUlXtMeeMd0hy56nlr3X3V+apczOHDaydssJaAAAAAAAAAABABCIBAAAAAAAAAACrUFV7J/n7JAcMbJ+X5Ijufn1337jcmt19ZXc/L8ljk1w1cMmRSV4756i3G1i7aM4aa1kPAAAAAAAAAAB2eQKRAAAAAAAAAACA1XhJkh8cWL8gyVHdfc5KC3f3BzMJRbp2YPsZVfWYOcrtO7D27RUNtjb1AAAAAAAAAABglycQCQAAAAAAAAAAWJGquk+SZw9s3ZjkJ7v7a6vt0d2nJjlhxvZrq2qPZZZa7nXLteh6AAAAAAAAAACwy9t97AEAAAAAAAAAAIAd1u8n2W1g/dXdfcYC+7wuyVOTPHhq/e5Jfnlpf6dSVbdN8oBMfo23SbJPkuuTXJ3k8iQXJPlqkgu6u9eg/5YkhyW5Z5IDk+ydZGuSS5JclOSz3X3DovsCAAAAAAAAALBrqzU4CwMAAAAAAAAAAOzkqur7kpyXZNPU1kVJ7t3dVy+43/2SfD5JTW2d0933Hrh+IQejuruq6kVJXriAcr/f3S+atVlVd05yfJKfT3LoMmtuTfKPSU5J8q7u/spKh6uqvTIJnvr5JA/Lth+4d3mSjyT5s+7+yBw9Tkzyiyudccrx3X3igmoBAAAAAAAAALABTB9GAgAAAAAAAAAAWI7jM3z+6I2LDkNKku7+YiahP9MOqapHLLrfeqqq3arq95Kck+QPsvwwpCTZL8mjk7wsyTlV9ZQV9K+qOj7J+UnekOTobDsMKUn2TfKkJB+uqg9U1S1CqQAAAAAAAAAAYF4CkQAAAAAAAAAAgJX4iYG1m5L8+Rr2fNOM9SeuYc81VVWbk/xlkpcnudUCSu41Z//bJHl3kjcnucMKe/5Ykk9X1VErvB8AAAAAAAAAAJIIRAIAAAAAAAAAAOZUVXdOcr+BrdO6+4I1bP23Sa4ZWD9uDXuutZcnefI29rcm+VySU5N8LMlnk5yT5LrVNq6q2y7VfMI2LrssyeeTfHyp9yUzrtsvyYer6tjVzgUAAAAAAAAAwK5r97EHAAAAAAAAAAAAdjgPmrH+qbVs2t3XVNUXBvrfu6r27e7Lb7Z25NQ1hyd57dTa55L8xjJavzHJB6fW/iTJYVNrz0xy5jbqXHTzb6rqPkmePXDdZUleneSd3X3OUKGq2j3JIUkenuRxSR6VZK9t9J6+v5K8NckDB7Yvz+TX91dJvtTdPXXv/TP5tT49yW4329orydur6oe6+z9ntH5Jktff7PuhPzPT/+5mOXeZ1wEAAAAAAAAAsIMQiAQAAAAAAAAAAMzrATPWT1+H3qfnloFIlclMp35nobs//T0XVA2FBV0xfd2Q7r4otwwzumLg0rOXU+9mnpbvDRRKknOSPLK7L97OTDckOXvp6/VVdUCSX0syK4ho2glJHjuw/sEkT+3uy7bR+wtJfrWqTkzy3iQH3Gz79pkESD1+xr3n5mZBRpNcpltcM8/vIQAAAAAAAAAAO5FNYw8AAAAAAAAAAADscO45Y/3Mdeh9xoz1WTNtZD86sPZr2wtDGtLdl3X3S7v7A9u7tqoOTvKyga2/SfKYbYUhTfX8hySPSnLN1NaPV9URy6kBAAAAAAAAAAA3JxAJAAAAAAAAAACY10Ez1i9Zh97/OWP9LuvQe9HuOvX9VUlOWYe+z0myeWrtrCS/2N09T6Hu/kKS5w9sPXuFswEAAAAAAAAAsAsTiAQAAAAAAAAAAMxr/4G167v76nXovXXG+m3Xofei3Wbq+yvnDSSaV1Xtn+TpA1u/3d3XrLDs63PLoKonV9WtVlgPAAAAAAAAAIBdlEAkAAAAAAAAAABgXnsPrF2+Tr1n9RmaaaObDne6Q1XdbY17/niS6aCir3T3B1dacClI6V1Ty3skedBKawIAAAAAAAAAsGsSiAQAAAAAAAAAAMxrt4G1a9ep96w+m9ep/yKdNfV9JfnTqtpzDXs+fGDtbxdQ97SBtYcsoC4AAAAAAAAAALsQgUgAAAAAAAAAAMC8hkKJbrNOvWf1+fY69V+kkwbWjkvyhap6WlXtvQY9hwKRTl9A3fMH1u63gLoAAAAAAAAAAOxCdh97AAAAAAAAAAAAYIdz1cDaratqt+6+cY177zdjfWimje5Pk/xukttNrd87yVuSvK6qPpLkE0lOS/LF7r5hpc2qas8k3z+wtaWqHrzSukvuNrC2/yprAgAAAAAAAACwixGIBAAAAAAAAAAAzOs/BtYqyb5JvrHGvfedsT4004bW3VdW1VOSnJxk88AlW5I8YekrSa6uqs8k+fjS16e6u+doecCM9b+Yo8Y8BCIBAAAAAAAAADCXTWMPAAAAAAAAAAAA7HAunLF+r3XofciM9VkzbWjd/bEkj0py8TIu35LkmCQvSfL/kvxbVb2iqu60zHbrHVA0K7wKAAAAAAAAAAAGCUQCAAAAAAAAAADmddaM9R9eh96zesyaacPr7tMyCXp6QeYLdrprkt9Ncl5VvayqNm/n+v1WOOJK7bbO/QAAAAAAAAAA2MEJRAIAAAAAAAAAAOZ15oz1B65D76EeVyX58jr0XjPdfXV3vzzJ3ZM8MskfJvlskhuXcfteSZ6f5JSquvU2rrthtXMCAAAAAAAAAMBa2n3sAQAAAAAAAAAAgB3OGUmuTLLP1PqxVbVbdy8nxGduVXXvJHcb2Dq1u29ai57rbenX8YmlrywFHD04ycOXvh6SZPOM2x+S5K1JfmLG/hUz1u/T3f+80pkBAAAAAAAAAGBRNo09AAAAAAAAAAAAsGPp7uuSfHRg66Akx61h62fMWD95DXuOqru/1d0f7e7/2d1HJzkwydOSfHrGLU+sqqNn7F04Y/2A1U0JAAAAAAAAAACLIRAJAAAAAAAAAABYibfPWJ8VWrQqVbU5kyCgadclecda9NyIuvvy7n5rdx+Z5FeS3Dhw2dDvU7r7yiQXDWx93wJHBAAAAAAAAACAFROIBAAAAAAAAAAArMR7k/zHwPrjq+rINej3nCS3H1h/d3d/fQ36bXjd/cYkrxvYetg2bvvUwNoxi5kIAAAAAAAAAABWRyASAAAAAAAAAAAwt+6+PskrB7Y2JXlDVW1eVK+qOjjJC4fGSPIHi+qzg/rrgbU7buP69w+sPaaq9lzQPPO6dnphkX92AAAAAAAAAADYsQhEAgAAAAAAAAAAVup1Sf51YP2+SV66iAZL4TgnJtkysP2W7v7SIvrswC4dWNttG9e/J8m3ptbulORXFzbRfK4cWLvVuk8BAAAAAAAAAMCGIBAJAAAAAAAAAABYke6+NskzkvTA9vOq6oTV1F8KQ3prkocPbP9Hkueupv5O4p4DaxfPuri7r0jyhoGtF1fVoQubavm+ObB29/UeAgAAAAAAAACAjUEgEgAAAAAAAAAAsGLdfWqS35+x/aqqem1V7TVv3aq6Y5KTk/zMwPb1SZ7S3UNhOjuEqjqkql5eVXdaRY1K8qyBrdO3c+sfJLlsam2/JB9YRChSVd2rqp62zMvPHlg7crUzAAAAAAAAAACwYxKIBAAAAAAAAAAArNaLk7xtxt5vJPlSVT21qvbYXqGq2q+qnpdJUM6jBi7pJL+2FMS0I9uS5PeSnF9Vf1FVx1XV5uXeXFVbkrwxyaMHtt++rXu7+xtJnjGwdfckp1fVs5fqL1tV3bqqnlRV70vy5SQ/t8xbzxhYe1ZV7TtPfwAAAAAAAAAAdg7V3WPPAAAAAAAAAAAA7OCqalOSNyX5pW1cdmmSDyX5TJJzk1yRyUPd9k9ySJKHJTk2yd4z7r8xyX/t7jetYL6jk3xiavnU7j563lpL9U5J8oip5WO6+5Rl3v+AJJ+bWv5mkg8nOT3JmUnOX1q7IsmeSW6X5Acy+T36xSS3Hyj98STH9jIOhlXVf0/ykhnb30zy10lOW5rz0iRbl+a4TSb/zg5Ncr8kP5zkmKW97/hQdx+3jBkOzST8atrFSd6aSWDSpUmuGbjm3O7++vZ6AAAAAAAAAACw4xCIBAAAAAAAAAAALExVnZDk5Uk2L7j015P8THdPhxotyw4SiLRaFyZ5WHdfsNwbquoFSV664DmSZQYiLc3w4SQ/soIex3f3iSu4DwAAAAAAAACADWrT2AMAAAAAAAAAAAA7j+7+oyRHJPnkgkrelOTEJIeuNAxpF/HFJA+ZJwwpSbr7ZUkel+SSBc9z/RzXPj2TwCsAAAAAAAAAAHZxApEAAAAAAAAAAICF6u5/6u6jkhyb5H2ZLxznOy5P8oYk9+nu47v7skXOuAF8NcmLk5yZpFdR5xtJTkhyRHdftJIC3X1SkkOSvHSp3kpdn+TkJE9J8tNz9L8oyeFJPrSK3gAAAAAAAAAA7ASqezVnaQAAAAAAAAAAALatqvZP8iNJHprkB5McnGT/JFsyCQO6KsklSc5N8vkkpyX5RHdfu8AZ7pfkD6eWv9jdv7PCen+Y5H5Ty7/T3V9cQa07JjkqyZFJHpjkXknuOOPyG5J8OckZSd6T5KTuvm7entuYZe8kj03yuCQPXppl1oP3vpbkXzIJdfp4kv/b3Vetsv8hmYQpHZ7kvpn8OdknyV4Dlx/f3Seuph8AAAAAAAAAABuLQCQAAAAAAAAAAIANpqq2JLlDklsn2TPJ1UmuSPL1RQZFLWOOzUkOSrJvkj2W5rgyyWWrDT8CAAAAAAAAAIBpApEAAAAAAAAAAAAAAAAAAAAAAIDRbRp7AAAAAAAAAAAAAAAAAAAAAAAAAIFIAAAAAAAAAAAAAAAAAAAAAADA6AQiAQAAAAAAAAAAAAAAAAAAAAAAoxOIBAAAAAAAAAAAAAAAAAAAAAAAjE4gEgAAAAAAAAAAAAAAAAAAAAAAMDqBSAAAAAAAAAAAAAAAAAAAAAAAwOgEIgEAAAAAAAAAAAAAAAAAAAAAAKMTiAQAAAAAAAAAAAAAAAAAAAAAAIxOIBIAAAAAAAAAAAAAAAAAAAAAADA6gUgAAAAAAAAAAAAAAAAAAAAAAMDoBCIBAAAAAAAAAAAAAAAAAAAAAACjE4gEAAAAAAAAAAAAAAAAAAAAAACMTiASAAAAAAAAAAAAAAAAAAAAAAAwOoFIAAAAAAAAAAAAAAAAAAAAAADA6AQiAQAAAAAAAAAAAAAAAAAAAAAAoxOIBAAAAAAAAAAAAAAAAAAAAAAAjE4gEgAAAAAAAAAAAAAAAAAAAAAAMDqBSAAAAAAAAAAAAAAAAAAAAAAAwOgEIgEAAAAAAAAAAAAAAAAAAAAAAKMTiAQAAAAAAAAAAAAAAAAAAAAAAIxOIBIAAAAAAAAAAAAAAAAAAAAAADA6gUgAAAAAAAAAAAAAAAAAAAAAAMDoBCIBAAAAAAAAAAAAAAAAAAAAAACjE4gEAAAAAAAAAAAAAAAAAAAAAACMTiASAAAAAAAAAAAAAAAAAAAAAAAwOoFIAAAAAAAAAAAAAAAAAAAAAADA6AQiAQAAAAAAAAAAAAAAAAAAAAAAoxOIBAAAAAAAAAAAAAAAAAAAAAAAjE4gEgAAAAAAAAAAAAAAAAAAAAAAMDqBSAAAAAAAAAAAAAAAAAAAAAAAwOgEIgEAAAAAAAAAAAAAAAAAAAAAAKMTiAQAAAAAAAAAAAAAAAAAAAAAAIxOIBIAAAAAAAAAAAAAAAAAAAAAADA6gUgAAAAAAAAAAAAAAAAAAAAAAMDoBCIBAAAAAAAAAAAAAAAAAAAAAACjE4gEAAAAAAAAAAAAAAAAAAAAAACMTiASAAAAAAAAAAAAAAAAAAAAAAAwOoFIAAAAAAAAAAAAAAAAAAAAAADA6AQiAQAAAAAAAAAAAAAAAAAAAAAAoxOIBAAAAAAAAAAAAAAAAAAAAAAAjE4gEgAAAAAAAAAAAAAAAAAAAAAAMDqBSAAAAAAAAAAAAAAAAAAAAAAAwOgEIgEAAAAAAAAAAAAAAAAAAAAAAKMTiAQAAAAAAAAAAAAAAAAAAAAAAIxOIBIAAAAAAAAAAAAAAAAAAAAAADA6gUgAAAAAAAAAAAAAAAAAAAAAAMDoBCIBAAAAAAAAAAAAAAAAAAAAAACjE4gEAAAAAAAAAAAAAAAAAAAAAACM7v8DYHIXqDj8VV8AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "def crosscorr(datax, datay, lag=0, wrap=False):\n", - " \"\"\" Lag-N cross correlation. \n", - " Shifted data filled with NaNs \n", - " \n", - " Parameters\n", - " ----------\n", - " lag : int, default 0\n", - " datax, datay : pandas.Series objects of equal length\n", - " Returns\n", - " ----------\n", - " crosscorr : float\n", - " \"\"\"\n", - " if wrap:\n", - " shiftedy = datay.shift(lag)\n", - " shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n", - " return datax.corr(shiftedy)\n", - " else: \n", - " return datax.corr(datay.shift(lag))\n", - "\n", - "d1 = df['Activity_Act']\n", - "d2 = df['Activity_Fit']\n", - "minutes = 5\n", - "fpm = 30\n", - "rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - "offset = np.ceil(len(rs)/2)-np.argmax(rs)\n", - "\n", - "f,ax=plt.subplots(figsize=(14,3), dpi=400)\n", - "ax.plot(rs)\n", - "ax.axvline(np.ceil(len(rs)/2),color='k',linestyle='--',label='Center')\n", - "ax.axvline(np.argmax(rs),color='r',linestyle='--',label='Peak synchrony')\n", - "ax.set(title=f'Offset = {offset} frames\\nActiwatch <> Fitbit',ylim=[.1,.9],xlim=[90,211], xlabel='Offset',ylabel='Pearson r')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);\n", - "plt.legend()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "In the plot above, we can infer from the negative offset that Actiwatch is leading the interaction (correlation is maximized when Fitbit is pulled forward by 1 frames)." - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
TimeActivity_ActActivity_Fit
02019-10-18 15:30:00335.0105
12019-10-18 15:31:00478.090
22019-10-18 15:32:0077.013
32019-10-18 15:33:00109.00
42019-10-18 15:34:00613.080
............
96192019-10-25 07:49:000.00
96202019-10-25 07:50:000.00
96212019-10-25 07:51:000.00
96222019-10-25 07:52:000.00
96232019-10-25 07:53:000.00
\n", - "

9624 rows × 3 columns

\n", - "
" - ], - "text/plain": [ - " Time Activity_Act Activity_Fit\n", - "0 2019-10-18 15:30:00 335.0 105\n", - "1 2019-10-18 15:31:00 478.0 90\n", - "2 2019-10-18 15:32:00 77.0 13\n", - "3 2019-10-18 15:33:00 109.0 0\n", - "4 2019-10-18 15:34:00 613.0 80\n", - "... ... ... ...\n", - "9619 2019-10-25 07:49:00 0.0 0\n", - "9620 2019-10-25 07:50:00 0.0 0\n", - "9621 2019-10-25 07:51:00 0.0 0\n", - "9622 2019-10-25 07:52:00 0.0 0\n", - "9623 2019-10-25 07:53:00 0.0 0\n", - "\n", - "[9624 rows x 3 columns]" - ] - }, - "execution_count": 47, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfn = df.reset_index()\n", - "dfn" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAADOAAAA1iCAYAAAAimCw1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAA9hAAAPYQB1ayvdAAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xe4NVV1+PHveqnSexVEwYIiIqKISBGNFQ2WWNEYe4zRWJKfLXYTC7aY2GLUqIkdNTYsSBVREVRALAgIFrr0Duv3x55XLpfZc0+Zc+657/1+nmceZeacNfs9d8o+c/baKzITSZIkSZIkSZIkSZIkSZIkSZIkSe1WLHYDJEmSJEmSJEmSJEmSJEmSJEmSpFlmAo4kSZIkSZIkSZIkSZIkSZIkSZLUwQQcSZIkSZIkSZIkSZIkSZIkSZIkqYMJOJIkSZIkSZIkSZIkSZIkSZIkSVIHE3AkSZIkSZIkSZIkSZIkSZIkSZKkDibgSJIkSZIkSZIkSZIkSZIkSZIkSR1MwJEkSZIkSZIkSZIkSZIkSZIkSZI6mIAjSZIkSZIkSZIkSZIkSZIkSZIkdTABR5IkSZIkSZIkSZIkSZIkSZIkSepgAo4kSZIkSZIkSZIkSZIkSZIkSZLUwQQcSZIkSZIkSZIkSZIkSZIkSZIkqYMJOJIkSZIkSZIkSZIkSZIkSZIkSVIHE3AkSZIkSZIkSZIkSZIkSZIkSZKkDibgSJIkSZIkSZIkSZIkSZIkSZIkSR1MwJEkSZIkSZIkSZIkSZIkSZIkSZI6mIAjSZIkSZIkSZIkSZIkSZIkSZIkdTABR5IkSZIkSZIkSZIkSZIkSZIkSepgAo4kSZIkSZIkSZIkSZIkSZIkSZLUwQQcSZIkSZIkSZIkSZIkSZIkSZIkqYMJOJIkSZIkSZIkSZIkSZIkSZIkSVIHE3AkSZIkSZIkSZIkSZIkSZIkSZKkDibgSJIkSZIkSZIkSZIkSZIkSZIkSR1MwJEkSZIkSZIkSZIkSZIkSZIkSZI6mIAjSZIkSZIkSZIkSZIkSZIkSZIkdTABR5IkSZIkSZIkSZIkSZIkSZIkSepgAo4kSZIkSZIkSZIkSZIkSZIkSZLUwQQcSZIkSZIkSZIkSZIkSZIkSZIkqYMJOJIkSZIkSZIkSZIkSZIkSZIkSVIHE3AkSZIkSZIkSZIkSZIkSZIkSZKkDibgSJIkSZIkSZIkSZIkSZIkSZIkSR1MwJEkSZIkSZIkSZIkSZIkSZIkSZI6mIAjSZIkSZIkSZIkSZIkSZIkSZIkdTABR5IkSZIkSZIkSZIkSZIkSZIkSepgAo4kSZIkSZIkSZIkSZIkSZIkSZLUwQQcSZIkSZIkSZIkSZIkSZIkSZIkqYMJOJIkSZIkSZIkSZIkSZIkSZIkSVIHE3AkSZIkSZIkSZIkSZIkSZIkSZKkDibgSJIkSZIkSZIkSZIkSZIkSZIkSR1MwJEkSZIkSZIkSZIkSZIkSZIkSZI6mIAjSZIkLWMRcUJEZMuyx5BxDqzE+epitUlaSiLikspxv9Fit20pioiDKp/nlxa7bdIwvDaMJyIOq3x+D13stkmSBhcRW1Wu5+cudtskSVopIj5ZuV8dvNhtW6oi4kGVz/Q7i902SZIkSZK0fK2+2A2QJEmSJEmSJEmSlrOIWBPYCFgXWBu4DrgauCAzr1/MtkmzKCJWAzYG1mmWGynnzMWZedVitk2SJEmSJEnSqssEHEmSJM28iNgC2GLEt98EXAtcCVyYmTf01jBJQ4uIZwDbt2y6KDPf2/O+XghsUtn808z8Yo/7Wgf4p8rmEzJz6GpQkjQLImJnYLXFbscCTs/Maxa7EVr1RMR6wMsqm4/NTGfeljSSiNgceABwP+BewB2ArYFoeXlGxIXAL4GTgeOAozLznCk1V1p0zXfu/SjnzH2AnYDtgDUqr78U+A1wCvBDyjlzynRaK0mSJEmSJGlVZgKOJEmSloLnA6/tIU5GxHnAL4ATgaOAb2fm1T3EljSYe1HO6flujIiPZeblfewkIjYA3kl90PjJQG8JOMBe1K9Tf9vjfiRp2r4PbLjYjVjAPYGfLHYjtEpaj/r9/a2ACTiSBhYRawFPBg6mJBIMmuAawObNcn+a7xcRcRLwOeBjmfnH3hsszYCIeAjwDOARlOpQg9oQ2L1ZntbEOhv4AvDRzDy556ZKkiRJkiRJWiZMwJEkSdJyEsBWzbI/8BLgioj4NPCOzPzFIrZNWi6Ooj0BZzVgb+CwnvazN90D2naJiE0y8+Ke9rdvx7ajetqHJEmSpCUmItYAXkipqLVVj6Hv2SxviIgvAG/MzFN7jC8tmoh4NPA6YNcew24PvBh4cUQcC7wpM7/ZY3xp2YiIA2h/FvbdzDx62u2RJEmSJEmaphWL3QBJkiRpka0HPAs4OSLeGRFrL3aDpFVc14/w+/W4n66EGCgJeftMYX/nZ+ZpPe5HkiRJ0hIREfsAPwUOod/km7lWB54A/Cwi/jsitpzQfqSJi4gdIuIw4FD6Tb6Z7/7AYRFxTETcY4L7kVZVB1AqRc5fFnoeJ0mSJEmStOSZgCNJkiQVq1NmwfxeRGyx2I2RVlWZeS7wq8rmPn+kHySZp5f9RcSawH0rm531U5IkSVpmong5cASw85R2uwJ4GnDylPYn9SoiDgROBB4yxd3eH/hxRNx1ivuUJEmSJEmStIStvtgNkCRJkmbM7sDhEbFXZl6x2I2RVlFHAXdqWX/viLhNZl49TvCIuA2wxwAv7avizn2AWvWso3rahyRJkqQlICJWAz4KPHWAl18KfBP4HnAKcCZwMXAl5Te89YBtgDsC9wL2p3z/WK0j5gYjNl1aNBHxd8B7KdVqu1xPSWw7Bvgx5Zw5F7gauAlYH9iUcs7cnXLO7Aus0xFztQW2S5IkSZIkSdKfmYAjSZKkpe72mXlWbWMz8GVDYBPgnpSZLQ9u/rtmF+ADzes0ZZk5SOKElrajgGe3rF8D2Av47pjx92piLWS3iFg/My8fc39dlXSOHCRAZm40ZhskaSL6uD5FxJeAv2zZdOkkr3+Z+dBJxZYkqU1ErAD+F3j8Ai89AXgb8H+ZeW3lNTcA1wAXAj8DvtDsY2vgScDfAXfoodnSooqIfwDetcDLzgHeAXwiMy/ueN3FzfJr4OvAWyNiXeDRwPOAvcdvsaRpyczvsHBiniRJkiRJ0lStWOwGSJIkSZOUmTdm5sWZeXpmfi4zXwTcFngVZTBLzVMiomtQvaTRdVWF6aMqTVuMn1Nml55rNUpS3iT2B3ARcGoP8SVJkiQtDW+nO/nmAuDJmXnv5hlFLfmmKjP/mJnvpFQVfRrwu9GaKi2+iHgM8M6Ol1wHvB7YKTPfs0DyTavMvDIzP5mZ96dUxPnhSI2VJEmSJEmSJEzAkSRJ0jKUmVdn5r8AD6b8kF/ziik1SVpWMvN3wBmVzX0kvrXFOBI4ru/9NVW27lfZfHRm5jjxJUmSJC0NEfEU4CUdL/kRsFtmfqqP/TUTjnwC2JlSPcTvHlpSIuKuwMepV7c4F9gvM1+XmV3P7waWmUdRquY+D7iij5iSJEmSJEmSlhcTcCRJkrRsZeYRwIs6XvLgiNhiWu2RlplaFZz7RsSaowZt3rtny6ajgWNa1o9bcWd3YL3Ktq5KP5IkSZJWERGxDfDvHS85Ftg/M//Q974z84rMfAnwcODCvuNLk9BMZvFRYN3KS/4I3D8zj+9735l5U2Z+ENgD+Gnf8SVJkiRJkiSt2kzAkSRJ0nL3n8DplW0rKFVyJPWvlpyyNnCfMeLeB7hNy/pjaE/A2SMi1hljf10JPCbgSJIkScvDvwEbVbb9GjgwM6+aZAMy8zDKZAS/muR+pJ78PfXv/lcDD83M30yyAZn5S2Bv4OuT3I8kSZIkSZKkVYsJOJIkSVrWMvNG4L87XtJWSUNaFBGxaUTsGBF3ioitImL1xW7TGI7u2DZOVZp9W9b9pplp+kfAtfO2rQHs1fP+AC4BfjZGXEmSpFVaRKyIiG0i4s4RcYeI2HSx21QTEZtFxE4RccemH77aYrdJsyMi7g08trL5euCvMvPSabQlM89g/Cqf0kRFxPrAqzpe8qLMnMr36cy8EvhL4JfT2J8kSZIkSZKkpW8pD9aSJEmS+nJkx7adJrXTiNgYeBiwD7ALcHtgQ0r1jmuAy4CzgJ9TKnd8PTMvmFR7lruICMrMp48E9gDuQpnBeHXgAuB8yoCMbwCHZeb5U2jTJsBTgEdQZobdeN5LrouIXwJHAJ/PzFtVeImIdYF7t4S/MjN/1HOTB5aZZ0bEOcB2LZv3Bd48Yui2hJijm31eGxE/pJxz899z+LA7iogVwP0rm4/JzJuGjTltEbEGcABwIHBPyjVvQyC5+bg/mTIj8Lcy87IptGnFnDbdu2nTRk2bLgfObtr0beBrmXnJpNvUJSL2BB5ISdjcCdgaWBcI4ErgXEqltR9SjrPvZ2YuTmtXPRFxF+BBlES6O1GuKesDa1Fmzr4I+A1wIuVa+e3MvH5KbdsReAywP7AzsAWlytcVwIWU+/v3gS9l5mnTaJOmo0mQ3Z9y/74ncEfKdWwNSoLmb4EfAIcCRwx7TYiI9SgDRQ9o4t+Wm6/dF1H6K0cBn25mdp+KpqLcX1Dus/eg9G03o1wTb6Qc+2cDvwCOpVzDfzut9q3qmuSVfYG7U645d6Z8/hsA61GSAK4E/gicwc3Xxe81kxJMq507A0+lHCu7UK6Lc7dfRkli/gblGD6jJcb2wB1awp/d9voR27k5cDDwcEp/ZMN5L7k2In5Bubd/PjO/3xJjA2D3lvCXZeaJfbRz3v72AB7AzX2SbSl/+zUof/vzublP8h3g2Gn1SSLinsBBlO9bdwY2bdp1OaWvdCqlz/7lzDx7Gm3q2es6tr07M386rYYAZOafJhG36affD3gI5di+E+U6sx7lGcYfgMMz8/kjxr9TE3tvbu7XzT2G5/brjmz2dd3o/6KB2hSU73z3pfyb70r5Xr7y2nodcBU3X1/PAs4ETqL0+8/psS23oVw796Dc/3ekXJs2pFxLr27acgVwTtOW31AmovjBpI6LEb2Acuy0OQ748BTbQmbeQLkejS0idqP8nfbi5mvxusBqlOPkPG7+uxwBHL2Yzw6a83pvbnleb8otz+tvZebf97S/21PurftQ7ge3bfa1gvId6RfA34x6L2j6Qw+hnLd3A3agnLPrUM7Xlc9aV953vpqZF438D5qyiNiI8tntSunv3QXYnHJNWh+4gZufQ6y8Fh1FOc7Gul5GxJ0p1+OVNq+8dIuI2GWI0Ndm5q9Hb1l/IuJ2lGf1e1M+2+0pn+ualOvrxZR+9E8pn+s3M/PqxWltERE7AY/m5mN+c8rx/idK3+8cSr/v6z53kCRJkiSpR5np4uLi4uLi4uLiMtMLZTBLVpYdeoi/TUf8n0zg37Mb8BlKJY7aftuW64EvA3v22JYTKvvaY8g4B1bifHUR23RIJc7LWl77BMqP78P8Lf4d2HRCx/wGwNsoA2iGOUZ+BOw7L9YuldeeMom2D/nv/ESlbZcDq48Qb7XmvfPj/c2c17y5ZfuRI7b/Hh1/i5cOGeuSSpyNhozzpUqcg1o+q7+jDIQe9Pi6EngtsM6EjocA/poyGGnQNl0BvBvYZF6sgyqv/1JPbb0N8A9DtnXlchbwMmDdCZw7Txox3hrNZ1lr86hxVw5SmR/vamCtMf79awLPpAwmGvbzvwj4FyZ0/W7atwvwVeCmIdp1OHC/lli9XBsWe6F+bbpkwvs9rLLfhw4Z5+WVOG+Z97oVwPMog90G/dufCjxgwHZsSunfXDlE/C8A2034c96FUlGy6zrSttzUHPsPXOxjtOPftlVH+98yA+3bE3gH8JMhrzlzl/Ob6+JmE27rXZpr4zBtuwH4X2CbebEGOidHbOfGwHsY/rva94D7zot138prj+/xc10f+H+M1ic5G3gpE+rbNe3bjzKYftA23Qh8DrjzgOfiuTNwHu7Qcf5dCmyw2G3saPug97fVKQkTgxxnvxiyDSuAx1MSw4Y9hi+iXAO3msBnsxHwekrffZRr69zz7N2UZIwYsS13Bj5EvV84yHIT5V7xSmDHRT7uVizwud5/sc+NEf5NawLPoSTYD/u3+T3wGmDDntry6sp+3jTvdasDL6QkEyzUxtbnR5TrX9vrz2p57T7ANxmsv7LbCP/u/YCvUJ7XDfP5Xwd8Fti1p8//k5X9HDxGzN2Af6U887txxGvAn4B3AduO0Y7fjbjvhZbTF9jvgyrv+06P5/DDKYmdw/anLwM+QA+/Twz7b6UkYg7btz68r2PdxcXFxcXFxcXFxcXFxWW5LyuQJEmS1DXT4bp97SQiNoyID1Fma3085Qf6YawOPAo4PiL+JyJqs4VqQBGxaUR8Dfg0ZSbbQa1OSV44PSIe0HOb9qTMpPiPzJsRfAB7AEdGxFuamXpn3VGV9evRPlv4QnZv3jvf0XP+/62qBAF7RsRaI+yvrdrOSrV/26JrqnJ8n5JE1laBqGYdSkLkaRExzPkySJu2ocz++zHaZ7SvWRd4EXBqRPxFn22qiYiHU6pLvIvh2rrS7YC3A7+KiINGbMYRlfUHjBhvT7rvd6PG3YuSrDTfcZl57SgBm8//F5RZsXcbIcQmwCson//TRmlDR9tWRMSrKYMbH0FJKhvUAcAxEXFIRKzWZ7s0HRFxW8o95v2UwYiDuivw3Yh44wLxHwacRjNYfoj4jwF+FhGjnsddbdo0Ij5KqVbyNIbvNwfl2P9ORHwhIrbou42rqoh4cUScARwPvISSFDxq329zynXx9Ih4bk9NvIWIeD43XxuHsRrwJMp9/pG9N2yeiNiXUmXvhQz/Xe1+wLER8dreG9YiimdSEv7ewmh9ku0oSX2nRsSDem7f2hHxQcpg1r2GeOsK4HHATyKil2oLU/AM6uffh3IKFSQnqaladQLwXkY7zrpi351yHfsM7VVbF7IJ5Rr4m+a62MtvnhHxJEp/8zWUvvs4tqN8XzmOIb/jRsSaEfF6yn322dy6EtdQ4Sj3ijdTrseL6UHUP9fjM/PYaTZmXM294xTgg5SKJMPahpLs9ZuIeGqfbauJiLtRnk2+h1KxcJL7Wjsi/pPyjOTBjN5fqcXfMSK+SbnfHEh5XjeMNYC/Ak6KiPc0laZmQkQ8KyJOo0w88XLKM79Rr3MbUSYR+VVE/OMSeWY4cRFxh4g4HPgaJYlr2M9lfeC5lM/19RExbP9xaM1zhzdSEleH7VsfQDnWX9l/yyRJkiRJWl5MwJEkSZLKj601N/axg4i4M2WmwmfTz4/NTwZOjIhRBh+LPychHE+Z5XBUGwFfi4iH9tSmh1EG1u8wThjKLNgfXwI/qHclqew3Qry2hJg/ZOZv5vz3cZQZLedaG7hPT/uDMgPmSSPEm7gmwet4RhvgttL2lESvXq4/zaC+HzLa33ylrSjn4pP6aFObZqDrmygDM4ZJXKrZBvhik3Ax7POZ71bWjzrAfqH39R231v6qiFgjIt5L+fz7GCS2CfDfEfH+PhJeImINSpWGN1IGjI9iBSW54vNNPC0REXEXSmLj/cYI8+qIeGcl/gsox/7mI8Ze2V/Ze9TGtbRpL0qiwtPpp2/7GOAE+7YDewr9D5jdEPhARHy0z0TAiDgE+A9glGTnlTai3DMP7qdVtxYRjwW+DWw7RpjVgNdFxAf6aVW7iNiAUlnsw5TKWOPaAfhmRPxjD7GIiI0oM6w/Z4wwawP/1hw/s+6xHds+MrVWTEBE7EP5/nSPCcR+MuU7wDjfS1ZaB3gn8H/N+TFOu15D6dNt2UO7bhV+iHasTTnPX8PwCYG9tWNCVplzJiJeSnmGc8cewm1KeY7z4Ul+F4iI/Snn9d0ntY85+9qQ8t3vWUzguIuIJ1AmsHlwD+FWUBJwj2kmCJkFj6NUEOzTOpSK24eOOBHNKqN5lnsSoz/vmGsNyvX6u5OcVKD5m32BUulq2GSzlVYAb46If+mtYZIkSZIkLUMm4EiSJEllEG7NJeMGbwaXH0M/P8jPtR1wVETs0XPcVV5EbE0ZYLdTD+FuA3wuIrYfs017A4fSXi1iFAdTBoLPrMz8NfDHyuZRkjHa3nOLijfNDNQ/7Wl/tQScYzOzl+S9PkXELsA3gD6qZ20OfDki2ioODdOmHSgDlsYZ7LrSGpSEiv17iNXmfcCrJhD3pcBHhkmYy8yzKDPez3eHiBhllu6FBpz0HXeoBJxmkMmXgReM0IaFPA/42Dgzpjd/u48DT+ipTQdRjjctAU2f4jDgtj2Ee/H8BIOmIsl7GX/Q4trAZyNi/THj0FQiORLYetxY82wHHB4RvQ/01lCeTknsGFtTDealfcSiJLd8pKk00Kum+sun6G+Q+3Mj4uU9xbqFKFVQj6FURu3TCuBtEfHP4wRpkga+wXgJiXO9tBngPpOa/lGtMuQpmXnaNNvTp6ZCxlcoCXB9x3428D8MX/F1IY8AvjXqvS4iXkypRDILPgM8bLEbMSG1f9eNlIHlS0IzOcMh9P9b+zMpz5hGHVxfFRG7Ur5XjZWoNuC+1gS+yHBV0IaJ/1JKNeveKpc37gUcERFb9Rx31hxE+W6wLMeKRKlG/BX6Pxf2pjyr7z0Jp/lb/Q/lb9eHVzTJsJIkSZIkaQS9P7yTJEmSlqBdOrb9fpzAEbE58C26Zyy/jjJI6evAOcD5lJkvb0uZxfFR1JMyNgAOi4jdM/Pscdq6jKxOGdQxf9bwKykzNX8T+C3l77AGZebbfSgzs9cGoK9HGSx94CgNan6Y/QLdA5BOowwu+CbluDyfkjy2DbA/ZeD3/Cour2TMY3gKjgKe2LJ+74hYkZnzq9W0agbA379l09Et644B7jlv3VCDOZtqB7Uf1Lsq+yyWDSmDCzaet/5iyjF1OOVYuYAyI+rWlOSJx1C/fm0PvAn4h1Ea1AzQ/Ards0tfSRkg9O2mfRdTPvftgUdSrpFzZwdeg3KevHKUNnW09dWURI0upzf7Prlp642U6/hdgSfRPXPtX1OS0V4xRLO+SxmcNd8DGWLm6Ii4DXDfAV46bNx1gD1bNl1OqQg3aJwVwOfpHoB4E2UW56MoM9heBFxKOd63AR5AGZBZO9YOBs4AXjtou+Z5Je3XsbmOp/w7Tgf+QDnPtqV8Rk9oaduzIuKIEduj6VlBGbQ/v3/wJ0rFmu9Q/t4XUQYw34FyLD6SeqWkd0XEVzPzkoi4HyX5Zr6fU66fJwDnAVdRjqF7Ao8Hdq3E3gZ4HWMkRDSJCp+nO1HhD5T7yjHA7yj//mjauAvlM9iL9qSiTYCvNn3bC0Zt5zJ2BuW4+BFwNuVY/BPls96Yct25L+WavmNHnKdHxA8yc+RKLhFxIOV4q7mJci/7DKUKxh8o94itKefUIynH89yqc2sAnwQ+MWq7Wtp5W+CzdFdFPZlyj/92084LKAnN21D6S08Adp/3njcBL+qrnU1b16OcW7VzHOAayrl3BOX7w0WU/tRmlP7TXwAPpT7g9A0RcXpmfmrEZv4n3f2KGyn/hi9TvnOdS7k+bsvNfc/5yRNvBX41Ynsm7QEd2749tVb0by3KebHhvPXXU75ffY1yvTmP8jxjU+BulOt7Z2J9RDwCWOjackGz/+9T+tVXUM63HSkVIboSvPakVBN82KDfJZt27QC8ueMl11P6m0cAv27adSXlmN6A8lltS6kWtCtlEP9ISX1NVY+uJLvLKH2M45u2XNi0ZbWmHRtSPqt7NEvXM6+pioidqFcTPTEzL55me0YVEc9j4ckZzqbcO06iHC/XUr4f3pny3aHrWv6XwPspVbT7sjblvJp//b+e8j3qa5RJHuae1yv7baMkE7yW9mvkaZR+7InNvi6hPFPbkTIxymMWChwRz6ckP3X5FaWfcVyzn4son8GWlMpbB1I/N+5Eqby3X2Zet1B7FsHZ3NzfO5Ob+3tJ6e9tTXk+eACwc0ecR1G+y75pko2dNVEqQ3+G7nEyl1Ce0x5NOX8voXyuOwCPpjyHrSUv3QX4ekTsnZnX9tNqoCSIzq8gdhPlXvB1yrl1HuVaswXlGnMQ7c9lVnpXRBy2VK69kiRJkiTNlMx0cXFxcXFxcXFxmemFMnArK8sOPcQ/pCP+q8eM/c2O2EmZMX/TBWJsQPnhvSvOD4DVRmjfCZV4ewwZ58BKnK8uYptqf9ffz/vva5vXbrRAvDUpP0zf2PF3eMCIx8kXO2JeShn4HwPEOYgyKHD++9vinjLuudPH0vzbav/2ew4RZ9dKjLu3vPZxLa+7Alh9iP09p6Pde47wOVxSidV5XLbE+dKAx/2lwMuBtReItwFl8Hft33ojI16HgXd3xL0J+DdgvQVibEkZCD7//WdX4n5phHbuv8B5/3vgwAHiPLijXSv/zQ8bol1PrsT55JD/vgd1tGmcuA+pxPnakHH+ZYHj7z+BnQaIsxbwT5QBi7XPf98Rjo89KIPWam38MbDrAjFWA/6OMnBy7nsvAK6uxB3q2rDYC/Vr0yUT3u9hlf0+dMg4L6/E+eO8/76aMjBqnQXi3YMyoL923LyBMpv3WfPWn7bQdYKSaPE8ysDJttjXA9uN+HnenjJ4sdbu04CnMECftDl3jumINXQfckLH0FYdbXzLIrZrbn/5RMr17XZDvD8oiY0ndvz7LgW2HLF9G1MGANZi/xy47wBx1mzOh/nHc61/O/TfhJIkUWvnxcDTB4zzREqC/CDtPH7Ez/XQjrZeBbxlkL8ZJeHlEOr3rysYoX/XfAa19iVl0onO6w9l4ol/BW6Y995aH+rcxToPm/Z29ZMPWsy2Ddj+2v2t7dj9JLDNADG379i2Ld33kSspFQ87v5dREtx/sMDxNtSzHOBjHbE+BGw7ZLwNgL+iVCu4pokz0DMNyoD6tnZcDbyMBfoZlc/9bynJCAlcsYjH3BM6PudDFvucGPDfsNucv2nbcmFzPex8hkOplPHLBY7jg0do36sHPK9vojyT3GqAmK3nNSUZoXZPmn+POZkBnplR7lEbdGzfryX23OVY4MEDflaPAH7REWuUfsUne/xbzv0ucwrwz8Adh4yxf/OZ1P6N1zDA9+lK7DdVYo71LL1lP7VnFt8ZIdaGdD8740KSAAAgAElEQVSXua75nNdaIM4OlETIrvP333v8t57LrZ9LfRXYeYCYj2reX2vnW/v8e7m4uLi4uLi4uLi4uLi4LJdlWZYVliRJklZqZhF+esdLRq5kEREHUwZct7kJeEpmPi0zL+qKk5mXZebfUmbAvL7ysvtQBqpoYdvM+f9/Ag7IzJdl5iVdb8rM6zLzX4C/6XjZM4ZtTDOT/EGVzRcBe2XmBzIzF4qVmV+izH5/+pzVtdmtZ0VbhZqVhqlKs1/LuospgxTmO6Zl3bqUWYrH2R+UAYs/HiLOtMw97s8C7p2Zb8nMa7re1Fx//p4y+LXNCkr1lqFExN2Bv69svg54RGa+MDOvWKB952Xm44AXzttUm1V5KBGxJvBB6jObHgPcLTO/ulCszPwWcHfKwLfW3QHvbyrHDKIW54AB39/1+rZZWvuIC/V230pT/eP/VTZfSElEeHZmnl55zZ9l5rWZ+TZKpaw/tO0O+GBE1KqStLUvgP+gPnPuRykDzH+2QNtuzMz/oFy//zhn02Z0V0bT4ttqzv//E7BfZr42M6/qelNm/pRSgeQ3lZc8mzIL/+3mrPs6sHtmfmOB2JmlasnBlZesTkmSGUpzvH+EUqGmzcea9v1PZt64ULzMPIEyIPCDlZc8IiLmz/CsmyVlUOZembl7Zr4tM3878JuLb1AqlbRVWYLSh3zZiO17LfXZ8o8G7pWZxy8UpOl/v4YyQHbuDPS99G8j4iDKQMc251L6Sx8bJFZmfprSl5xblbS3fnhE/A1lxvU2v6bcb16emectFCszL8nMl1GqDLX1tdalflzU2rcu8M6Ol7wqMx+Wmecs0LarM/MVlGvk3GtpL327CditY1vn/X/GzT12bwCelJkHZ2ZbH+oWsrsy73uo30fOAXbLzH/PzBsW2MfPKVVw3tfxsldHxJ06G9uIiDUoz1vavDgzn5OZQ1WWbb5HfS4zn0K5n7+B9vNtflv2oAzsnu9aSvLCIQv1M1ra8vvMfH9mHkCZuOKjw7y/Z0v6nGmqc36Qktzf5qeU74efXugZTmZ+j/J5fKnjZe+OiE1HauytzT+vn9A8kzx3oTcucF63uQ23/I70GcoEK0cMsK9LMvOytm3NM9z/pv37102U/sc+zXfvBWXm1yjVcGoVy14aEXcbJNYEHQ08MDN3ycw3Zuavh3lzZh5JeX5Ve6azFgtXc1qVvJl6n+JiSn/qjblA5ZrMPItSVfB1HS97fkTsNUojW2zJzc+lEnhZZh6Ymact9MbM/D/K85kLKy952jDPQSRJkiRJUmECjiRJkpa71wO1H7PPpMwSOLRmAMebO17y/Mz832FiNj+Y/Q3lh7Y2r42I9YeJucxdTRnA8r1h3pSZHwc+Vdn8mBH+Bq+rrL+WMrj858MEawbd/QWlcsLMa/59tbbWklzatCXrHNs26KX5jNoGLQyzv30q649baMDYIjsX2DszfzXk+15HmWW6zdAJOJTrY9sziQT+eqEB5rd6U+Z76R74MKpnA7WBeycDj1ooeW+uzLyUMnj2J5WX3I5bJxPVYp1LqTYx39YRsfOgbaI9UeY/JxQXBkzAaQa3fYD24+QSSrWagQZWzdUkwzyA9gGQd2G4xIRHUxJg23wVeHZm1hJn29r2K0pFikuHaINmw7WUgXE/HPQNmXk+9fN9K+BFc/77u5RKClcPEf+zwBcqm2vJOV0OpiTMtPm3zPybYdoHf04+ex5l9vU2r28Sf3Rrj2+SGRZMYunSJLi8kJJc1eaZEVEbZNwqIrakVGFqcwrwyBGOlW8DTx3mPQN6XWX9lcBDMrOWJNeqSS55MOU+1ZuI2JBSsabNb4D7LZTs2SYzD6Pcy25q2XxgRNTucW1eBGxd2fbuLBMZDNO2o4DHUwaJz7KdKuuvoSS9rwqe1iSYjSUi9gRqiZUXU865gQeWN8meL6AM7G+zFqWS4iD2pFTdmO/YzHz3oG2qyTJpwGsz8xcDvPyhlfVvH/ea37Tl5CwTLCyW2jkDpRLJrPsr6v3/MylVFhdMhFypuR8+ifrEJJsCrxiqhYN5cmZ+bgJx23yRMgFRH9fzf+aWCepzPS8z37BQ4tN8mXk5JdG37XnH6pSknsXyt5m5X2YOPIlFm6bP/VrgbZWXPCkiNh5nH0tBROxIvY96FaWy8YmDxmsS2l9PPWk5gLcP18qBvCgz3zHMG5pnry+tbN6K+r1HkiRJkiRVmIAjSZKkZSsi/g54ScdL3jHsD7dzPBnYvrLt05lZm+27U2b+D/ChyuaNgeeOEneZelmWGehH8QraE6HWocwkPpCI2B3Yu7L5HZn5oxHatnImxlrViFlUG2yyzxADb9sSYtoq3XTtc6CKOxFxe+ozZo5cNWsKEnj6IDNX3+qN5VpYG/hz++YzGUhE3Bk4sLL5I6MO8GsGPoyUNNmmmQH0Hyubr6cMfh56gG0zm+/jaK8yA/DiIQY7j1UFp0kYbKv89Cnaq0cNGndDSjWX+S6mnnw03+MpFYNatw0y02tNk+hSqxr3D0OEqg1guRB4ag5QBWS+5r40asUJLZ5XZeZJw74pM78OLPS+SymJiQMnc83xxsr6u0XENpVttxIRXYMPvwW8eNiGzfN8blm9b6W7UZKKNU9mntlzyBcAbdUdNmb4AXnPpb0yQALPrc1qv5AmqezQUd7bJiL2Be5R2fzmURJaADLzl8BrRm5YuxfTXjXkKkrVwNqM5gvKzO9QH5A70D2xqRhYG9D/M+r3y05NZYL3jPLeaWiujbVKT3/IzLbEpqXm05lZm3xiWC/v2Pb8Ufp2zXeUp1NPdnr0gFVwagP6x048GsEstWUStu3Y1lkha0bUjuOkJLUsWE3mVm8sVWkfD9Tuj8+NiLYEsVF9corJNxdSJiUY+nvRfBGxBfXvcO/JzLZJJAbS9LOfCFzesvmxEbEoVdgm0N97Je2TeKwFPKbnfc2ilwG1Si+vzMzvjxj3H6h/p9s7Iu4/Ytw2/9dMQDOKTwCnVrYNW/FYkiRJkqRlzwQcSZIkLTsRsVNEfBr4946XnUyZeX9Uz6ysv5L6gO5BvRr4U2XbM8aMvVyckpnvG/XNmflb6gP92wad19QqLZzL4LP11nwM+PGYMaallrSyGXDXhd4cEXcBtmzZVEvsgfbknPs3VTcW0lUpZ5YTcL6cmd8c4/1H0T44F4Y77p9OmQl0vsuBVw3Zpvn+gfZZ3EfxQOoD4N474AzWrZoZ9d9V2bwF9QSl+WoJOA8c8P37UWb1nety4IeV2IPG3Z/2gS1HDpHYWhv0+9mmEsK4Pk77LNv3jIha4s+fNYlk96tsfu0oyVlzfISFkzI0O86gfj4P4vMLbD8kM383SuAmoastsQVgtyFCHQjs2LL+BuDvxx1knplXUq8cOUqVNQ2pmYH/LZXNwyZB1fq3n87M44aMNd9LKEmwfai18yzgnWPGfh/tA1yH1lRWfX5l8yFNws+4/pX2gd+PjogNBnj/wyizp7d58ZjXiDcC54/x/knakvpvbEMPwp9B1zBcYnJVM3C+1r89KjNrVWwW1CQv1JKXV1CqCC+k7bskLE4Vo1lqyyTUKmXdxOye68CfJ1Cp9Z8+MU6FoqZqzhsqm9cDnjBq7HmuZvzE6WG8OjMv6inWcyiT3sx3HuU56ViaiWzaJjxawWjVI2dOkwhVO85W6aT3iFibMllWm1OB/xg1dtPP6aosVvuNYFg3MmDF5DbNs5j/rWwe5pmeJEmSJEnCBBxJkiQtfXeKiF06ll0jYp+IOCgiXh8RhwO/ovvH64uBx4w6Q2Mzo3htdruPjDqIcqVmhuPabHc7R0RtJmfdrI+ZlGuJDMP8aPmXlfWfbAajjqz5YbVWLWnWdCWtDFKVpu01VwIndrynLQFnQ+ozoQ/SpquAkaoWTclYx30zqKCW+DDMcf9XlfUfaQYejSwzfwwcNk6MOR5fWX89ZaDquP6VMgCqzRMHjHEk7QlH+w2YTNY2y+kxmXkD7Qk448SlEvNWImJnYM/K5n8eJMZCmmtk7Zx4xAAhasfxhcDIsy/Dn8+1Po4xTcf7xxxc3nUPvI7x7+W1+MMk4NQGL3+8qSjVh/8FLmhZ/9ABrzsa35cr64ep7ngXoFZtYqQKoHM1SfB93ecfVVn/scysVakbSPM98sPjxJjjQGDzlvWXAW/vYwdNVaKPtmxam8FmRK/dE3+QmQPd+2sy81K6J85YTOt1bBsnEXdWfHncvvkcj+HWSd8r1QaDDywzv0CpttRmkH51LUF8/dFaNJZZassk1M6bK/qokjJhte+H0MNxDPwb5btEm0G/Hy7k0HGqpg3pSuB/eoxX64++NTOv6Gkf43w/XCq+Tkmin2/g/t4S9VCgllT8L80zkJFl5vcolUHbPLZJqB7Xl5q+8Dhqz7KH+W4oSZIkSZIwAUeSJElL3zcp1Wpqy08pVTC+CLyGMoCorfLCSr8DHpSZtdnCB/Ggjn18coy4g8Z5UE/7WFXdBHyuhzgnV9bvMMibI2I72meTh/4GKXyOMnh31p1MSXxr01VtZqW2hJjvd/2AnplnAH/ocX8r9zmrn/d5mXlkD3HGPe5vT/24//QoDWrxqZ7i1GaAPayPQUvNYNevVDYfMMiA88y8mHKfm28TBhtA0Tao9vDmf4+izLDaV1wYMAGHenLij3sc7A/1hLIHDPDe2vHxhczsozrDVynViDT7Rp61v9FVTevozBx3NvhaFY7bD/LmiLgN8ODK5r6utzT3z7ZkoU0YLDlWY8rMc4BzWjbtPEQSVO36eQ7dlQmHMXY/uUn0rFVs6asf/in6qcpXuyd+pccBxzDePbH2/XPW+nZ9u03HtrGSuGbEx3uMVbuP/J6SUN6H2jOSHSKi9v1jpVqFjsUYdD9LbZmE2nmzFM6Z2nH8/abC6Via7xCfrWy+X0S0VX8ZVp/n9UIO7es+FRG7AHdo2ZSM3xe/OVjpC7X1zffs6fNfdM1ziLbnOttHxKqS6Nemdv5eAXypp33U7kPrA/fpIX4f/aqf094/3TgiNuwhviRJkiRJy4YJOJIkSVKRlIE9e2TmSWPGqlW/OSszfzhmbAAy89fAj4fcv4pTmpmUx1VL0qrNqDjfvSvrL8jMn4zQnlvJzD8x2xVZgD9XomirSAOjV8AZZJBn2z479xcR21JPIOmqYrDYvtdTnHGP+9r16XeZefwI7WnzJUqVmpFFxPbA9pXNvQ3woT6gdBNg5wFj1JJaHtj1pojYDNi1Fi8zLwHa7ocLxd0CuFvLpj9mZi0RYL7a4JgvDvj+gTQD5c5t2dRZ0SkiVqdeoefz47YLIDOvpiThaLb9vhmoN7LMvIgy8KtNH9fFsyrrBx1gtQ+lCsZ8l9DfoOmVjq2sH6bKmsbTVu1iHWCLAd9f699+p+nv9aE2c/cwau08c8yJGP4sM/9IPXF5GFO5JzLi+RcRdwS2rGzu6554Ou19ksW2Zse2PpJxF1NSPyZGsXdl/efGrCI3V1ei1kLPSE6prH9yREw78aXWljc1kxksdbXzZqbPmYhYj3pC8DS+H65J/d41qJvo77nAIGrPeEZRuxf+IDPbJlYZR9u1b3Vgl573s5ja+nsB3G7aDZmi2n3gq5l5VU/7OJR6MmEfz+rHPn+b5wy/r2we9LmeJEmSJEnCBBxJkiTpUuADwL0y88mZ2fYj5LDuXlnfS/LNHLVBmbX9q+hr8NZllfWD/mDZNkAd2qtZjKPveJNSS17ZuhnY16oZhLRdy6ZBBnu0vWafiOiqktWVoDPLCTizctzXrk+1hMKhNbPsdlWUGETXdbTPa3nX4PpBr+W1BJxaFZqVHsCtq7VdyC2vGYdza6PEBThigfcB0Jx/u1c2T+J61jb4ZPOI2KTjPXcC1qpsO2H8Jk0kliajr2trLQGnj4TcWuxBr9t7VNaf2lVpbkS1wWB36Xk/qqtVJKxVi5lv4v3bJkH07DHDLIl+eERsA2w9idjzNRMUXNmyaaHzr9ZfOS8zfzdeq25hFu+JXRU7upJzloLfNFUSxhYRW1JP4uutX90cb7X7yEL96p/QXnlmBfDFiHh7k2Q+Dd+prN8K+GFEPC8i2hJjl4raeTPr58zdqP+m3uf3wxOAWv9q3Gd9v8rMtuv8pJzYY6xaf3Ra3w9h1eqPjtvfW1IiYg3gzpXNfd6HrqSeRDnu+Xtek9zdh3Gf60mSJEmSJEzAkSRJktah/NA/1uzl89ypsr7vWXtrgzLv0Py4qHYX9hTn8sr6QX+wrM0s+bMR2tJlqSTgdFWs6Up6adt2HYNVDWhLwNkMuOsIbbkG+MEA+1wss3Lc1wY9zNSAV+rX8cupVwEaWmaeS/vss1D/rOY7mvZBWvsscC9oS6Q5cl6FgrbknlHi1mK12Z56ZY5xE6vatA22BNi24z21v83ZzcDwviyV6/dy1te1tZYk00f8Wuz1B3x/bbDYrJyPmiMibhcRT4yIN0fE/0XEzyLizIi4MCKui4jsWqjPMD/o8bJU+rdLpZ218+9a4MwxY7dpOwc3i4iugfFLpW83CVd3bKsl6i4VP+8xVq1fDdN7RtLZr26q8HygsnkN4GXAORFxaEQ8bZLJOJn5M+pVDjYD3g/8PiI+GBEPj4h1JtWWCamdN7N+ztSO45vo8d6RmdcAv6xsHvT7YU2f5/W092d/dI6I2CYiHhcRr2+uSz+NiDMi4oKIuHaA/t6TK6EH7e8tNTtQT/KbifvQAPr63gnjP9eTJEmSJEmUksmSJEnScrYG8Azg4RHxyMwca2bdiFgLqM2af9o4sVucWmsGZdbCPpOKViV/6inOjZX1qw34/i0r688doS1d+qjqNA0/oczC2PaD737Af1Xe15YQ86Nm4MpCTgEuATZq2V/t/Kol4PwgM7tmwV5ss3Lcb1NZXxtkNKpxB+JU2zkvQaUPp9J+Pai14RYy84qI+BGw17xN6wJ7AsdW3tqWKDO/4s2xlIS2uYNVRokLgyfg1AZFA/y6u0BVrzbt2LZUjmNNXl8JV7Vrax/xx71u187JZ0bEM0dozyi6zsdlLyI2AJ5GGUw5/17QlwWrLUTECmDzyuZZ698ulX547fxbC7hhSvfEoHy/rX02y/meWBvACvVnAktFnwnFtWPkRuBXPe4HSr/6EUO0Ya53Ak+nPsh+TeDRzUJE/JwyocP3gGMzs8+kuP8HHEn9N9xNgOc0y/URcULTluOattQSCGbB5bTfK9aLiDUy8/ppN2hAtWPo7AlUlTmV9kptA30/7NDneb2Q6zKzK0lxWLX74bsi4l097qfLovZHm2S7p1D6e/symUlWl3J1rS5d5860ntWPe/729UwPxv9+KEmSJEmSsAKOJEmSlr7bZ2a0LZTBCpsCu1IGpR1KGUjcZivg8IjYfcz21AadQf8/dnfF62rHcjcrSRK1mQUv63k/l/YcbyIy80bqA/q7KuDs17KurbJN2z5von124db9RURXdZyjBtnnIpqV436zyvq+r4/jHve1a+gkBi3VYg5zHa8lt7Qmw0TEtrTP4nyLOJl5Fe2VnWpxbwvs1LLprCEGJY47MKUvt+nYtlSOY03epK+ts3DtnoVzsut8XLai+GvKAPb3MrnkGxhsQN661H9vmLX+7VLph8/C+QfeE2vOp70KIZTnC0tZn+dCrU97efN9rE8j96sz82JKck2tctx8dwWeC3wcOKOpNvZfTVWKsQaxZ+b3gBcBgyT+r0G5/v8T8CXggog4KSIOiYh9Y4rZ6wP6Q2V9UE+OnAVL7fthm77vcVPZV0Ssx2xUZlm0/mhEPJaSKPIhYH8mN75jVU3AmIVn9eOev7PwvVCSJEmSJM1hAo4kSZJWWZl5Y2ZenJknZ+YnMvOxwM7Atypv2QD4WkRsPcZuu36Q7fvH7q54DlScfWtV1k/zOJk1tSSW20XErWY8jYhtgB1bXn/0EPtsS9apJfx0JQLNegLOrFinsr5rBvFRjHvc166hkzifajGHuY7XEnAeWFnflkDzu8xsm4V8flWcYePC4NVvYDYGV8Etq/7MN5XjODOvAPoemCoNaxbOya7zcVmKiPWBrwMfY3YGLNf6tjB7/dul0g+fhfMPZuCeyAx+p2kmEKhWBoqIWvWSpaDPih5Lpl+dmT8C7stolXl2oFRX/hxwbkR8OCLuMkKclW15H/A4hv+cAtgNeCnlO+qZEfGGiJiVqky/69jWVQlzsS2Z47hD35V6prWvpXAvnIiIWDsiPg18Hth+2vtfhdTOnesmUMm6dv6uERGraoKTJEmSJEnLkgk4kiRJWlYy8wzg4cB/V16yFfC/Y8wSukbHtqtGjFnT9YO2AxWXrr6/py2lH3i7kljakl/a1tWq2tS0JeBsHRF3HHB/UCprfX+IfS5ntWvkNK+Pg5hWO6He1mGu48fRPiPqfSOibbBJW6JMLUmmbf0wcbtit+kawD1NXf2AaR4fk4gpDWMWzslZm71/UTWVFb4BPHSx2zKEpdK/nbV2zsL5B7NxT5zmwPFh1BI11gDavk8sR0uqX52ZpwJ3B14CXDBiOzYEngmcEhEfHTX5JTMPpRxH/8Ho1Q9uB/wzJRHnlTMwALwrualWbXYWLKnjeBWzFO6F/e+sJHF+AXjCNPe7ipqF8xeW7zksSZIkSdIqyQQcSZIkLTvNTLXPAo6svGR/4AUjhr++Y1ttduBRrdux7bqe96X+XVNZv0HP++k73iT9GLiism2/Adf9NDOHmYX2BNr/FoPuD+BHmXn1EPtczmrXyGleHwcxrXZCva0DX8cz8xrak8DWBO7fsv4BLetqSTLHc+uBKcPEBTiisr7NUqj4Ms3jYxIxpWEshXNyuTkE2HuB11xMqZDzNuBvgcdQrtH3Ae5JGVzetgyTxDxfrW8Ls9e/XSr98KVw/i2Vvt2knNSxbbeptWK2Lal+NUBmXpeZ7wK2BR4LfBG4dIT2rAY8HTgpIu49wvvJzPMz8wXA1sDfUaq9dj13qtkAeDNweERsMUpberJUz5kldxyvQpbCvXASXk2ZQKrLZZQq7++gXB8eR5kUY6H+3lcn0+SZNQvnLyzfc1iSJEmSpFXS6ovdAEmSJGkxZOYNEfEk4DRgo5aXvCkiPpuZ5w0ZumsQ/jQHdJkMMPsuqayftYF/U9Ocl8cBD27ZPGgFnKOH3Od1EfEDbp1csy/w4ZX/EREbArtWwhw5zD6Xudq1af2e9zPucV9r5yTOp1rMYa/j36UkkM73QODbK/8jInakzIQ93+FtQTPz+og4llufl/Pj7gRs3xLil5n5h86W31LXLLT7AxcNEWscv+3YNpXjOCLWw8lztPiuov3Y/gQluWNabRAQEXenJNTUfBl4J3BsZg49YDUixvmsrwRuoP03h1nr3y6Vfnjt73E5cL8xYw/jjI5tS6VvNyk/7ti2P/CpKbVjli3FfjVQ+sHAocChTeWYPSjJjPtQzsG2Z0lttgcOi4g9M/P0EdvyJ+B9wPsiYt2mDfs1/3tvBq+ssB/wlYjYf5EmkVjonJlVS/Y4XgV09U1eSzlHp+HiKe2HiNgeeEXHS74DvB04vJlkatj4l4/atiWqdu6sGRFrZeaoFcba1M7f60f5W0mSJEmSpNllAo4kSZKWrcw8NyL+CfhQy+aVs4M+a8iwF3ZsG3RwxqC64l3Q877Uv3Mr67freT99x5u0o2lPwLljRGydmX8EiIjNgJ1bXnfMCPs8hlsn4Mz/7/tTHwh/1Aj7XK4uoD35o+/r44Zjvr92De27nV0xh72Ofxd4Q8v6Axb4b4BfZ+bvFog9/7wcJO7K9w6jK8HmvMz8xZDxJmFax8e4x7HUh4uALVvW35SZp0y7MeLFtPdHbgKem5kfbtk2jI1HfWNmZkScR6kYMd92wKkjt6o93jiWSj+8dk9cF/j5KElWE7Dc74mHAwlEy7aHTLkts6p2jKwfESt6Po776lffSjNw+gfN8paIWAHcgzJxwyMoySNrdITYhJKQNVIlnHltuRI4rFmIiLWB+1KSgx5JqXzR5T7AG4GXjduWYWXmORHxS+DOLZvvGhHbZeY5027XAJbi98NVxSXAjZSKUvNdtYr2R19APanunzLz7WPGH7m/t0R1nTsbAcNOvtXF81eSJEmSpGXCWTQlSZK03H0Y+Fll29Mj4k7DBMvMa6jPitiWLDCOu9aaQX1QmWZHbSbpe/S8n77jTVpXMsu+8/5/20C3oSrgNNqSdraPiLmJIvMTcla6AThuhH0uV7VKKG0DsMZxlzHfX21nRLQdd+OoXcuHqRoD8EPgipb1uzcVnFZqS5RprX6zwPZB4sLwCThnd2zbZMhYk7JUjmOpD7VzclbOx2Wjqb7w2Mrmt/aQfAPj/12XSv92qbSzdv6tYDKDvkexrO+JmXk+9Yoet4uIPafZnhlVO0ZWA4Z63jKAvvrVC8rMmzLzpMx8T2Y+GNgc+Hugq8LNHhHxlxNoyzWZeWRmvjYzdwduD7wFuLTjbc+PiK36bsuAvtGx7fFTa8VwasfQ9hGxTs/7mtpxvBRk5g3AHyubV9X+aO08+M8ekm9g1f3carrOnWk9q1+W568kSZIkSasyE3AkSZK0rGVmAq+ubF4NeN0IYX9VWb/bCLG61OKdkZnX97wv9a82C/iuzWy6fen7uJu0HwJXV7bNTYLZt2X7LzJzlFklj6PMqDrs/gBOaGYg1mB+WVm/a8/7GXfAa+06vj6w45ix/ywitgRqA99qn1Wr5rp/bMum1Sgzcq/0gJbXLJQkcyJl5uFh4yZwxAKx5/sV7ecjwB2HjDUptb/N9hHR54DopZZAqVXTaZX1s3I+Lie7Uqp0zncNZaD1WCJiLdqr1wyj1r/trT8aEVsDW4wZZuLt7Cle7fyD2TkHl0rfbpI+07HtuVNrxeyq9atheufcUP3qUWTmpZn578AuwHs7XvrEKbTlrMx8BSURrjZBxW2A3pOBBtR1zjx7AhMe9KF2HK+gx+tdcy+uJUQ2ipMAACAASURBVBxO/DieYcumPxoR29FeNfgm4PU97eb2PcVZKs4Cas/JV5n7kCRJkiRJmi4TcCRJkrTsZeZXKIP+2zwhIoadbbdWUec+Q8ZZSG023ZN73o8m4weUwenzbUA92WMoEXFb4J59xJqWzLwOOL6yeX4FnPnaKtkMss8rgJNq+4uIdYF7Vd7eVbFHt1a7Pu3R1w4iYj3GnyW9dh2Hfq/lXbOij3ItryXSHAAQEXcDtpy3bcEkmcy8ifZjfWXcXWgfDP2zzLyoK3bLvq4GTqlsrlWimrZfA9dWtvV2LPccSxpVrY98lyaJUNNTqyhyZGZe1kP8ewNrjRmj1od7SESsOWbslR7VQ4xaO7eKiF6uvRFxZ8av7nEqcFVl26zcE2v9la2a7yJ9meV74sepD+x9SkSMm9i2pGXmecD5lc299asjYhugdsxN7RlJZl6bmS8EvlZ5Sa1q5CTach7wSOrVQ6bWlrky83jqiZB3Bg6aYnMGdSolAaJNn98P7wWsXtm2nJ/11fqjvTw7mzG1/t6Jmfn7cYM3z7g3HzfOUtJMVlJL4urzPrQOJQmzzXI+fyVJkiRJWiWZgCNJkiQVb6qsXwH885Cx2ioQANy+xwFdO1IGyQ2zf82QzLyQ+g+wT+lpN08GZnH22IXUklruGhGbRcSGtM+CXZvddxBtyTsrBzbej/ogGBNwhlO7Pt02Iu7b0z4OAtYYJ0BmngOcXdn8+HFiz1ObAfsiume9r+lMwKF9kN3PmuvRKLG74na1ZyGHV9YfMAszYjcDeH5Q2fy4PvYREbcBDuwjljSmI6gPOH3gNBuiatWX3/YUv4+B2LXr/sbAw3qIDz30kzPzt8AZk4rfV5zMvBE4srL5QePG70Nm/ho4r7K5r3viTszwpAKZeT71ih5rAm+dYnNmVe07wON67Nt1VZZZjGckh1TWbxERa0+rEU2C5ocqm9uqbExLV5Wgt/SYtNmLZtKOn1Q2T+P74bXAj3rcz1JT+364RUT0XXFtsS2F/t5Ktcq1M3X+Nmr3gQOb7959OAioXd99Vi9JkiRJ0irGBBxJkiSJP1fBqf2Y/sSIGGb24u/QXtkEpjOg69s97UOT98XK+ieMO6t8RKwFPG+cGIuoltQSwD7A/Wn/Ptt3As5OEbE19VlVbwS+N8Y+l53MPJP6gNeuQXPDeFJPcWrX0odFxCbjBm8q9fxlZfN3m6ozwzoJ+FPL+l0iYgvaB8vXBjPdqk0dcftOwKldG2/H7MyI/Z3K+sdGRC1hbxgHAuv3EEcaSzN7/vcrm180zbaoOpjx6nEDR8QawLPHjdMksP64svmF48aPiHtR+oF9qN1rnhoRG48TuLnHP3OcGHPU2vmgprLdLKj1JWatbzdJrwduqGx7SkT0lYA2kCGfX0xDrV+9Hf1VsDi4sv7MzPxNT/sYxgkd2zabWiuKWlum3Y65PgKcWdl2J+A1U2wLEbFR872mS+04vl9E7NBDG1YHnlDZfFxm1iqiLQfHUCapaLOq9Ucn1t9rPL+nOADXVNb3ldDSp9r5uz79VFeE+n3oMuoTeEiSJEmSpCXKBBxJkiTpZl1VcF49aJDM/CPtg/kBntUM6B9ZMyCsNoDttMz82TjxNVWfpD1Za33gLWPG/kfg9mPGWCzHU2Z4bbMf7YO0zs7MWsWSQdRmo6ztD+CkZkZhDedzlfXP6CHxbHfgoePEmKNrJvN/6iH+PwHrVLZ9epSATdJOLYHtQdxc1WmugZJkMvMU2me4r8W9kdGT4r4H/LKy7VWzUAWH+nG8GfCccQJHxArgFePEkHr2X5X194mIB0+1JcvbxZX12/QQ+8nAbXuIA/DxyvoDIuKxowZtrv3vpb/qjrV2bgq8YczYr6afvwvAZ4ErWtYH8Kqe9jGu2j1xz4h4wDiBm8qXLxgnxjRk5unUq4wAfDwipvLdLCL2ZfaqdH6BeoLSsBWHbyUiHkW9StJI/eoeXNex7cqptaKotWXa7fizpqJk1zXsFRHxiGm0JSK2ozwP2H6Bl9a+HwZDPDPs8Hzq1U8W6zieCZl5A/Dflc1P7SMBaoZMrL/XnFN9Ju/W2rptj/voy2GURJg2r4yI1cYJHhF7Un8W9YXmGJYkSZIkSasQE3AkSZKkmx0K/Lyy7ckRsdMQsT5SWb8e4ydWvIEyMGyY/WoGNQO1vlLZ/NcR8bhR4kbEfYFXjtywRZaZ1wA/rGzel/bB/uNUvyEzLwB+0bLpwcCelbfN2sC2peJj/H/27jNOsqO8+/7/mhx3VpuUVllCQgIJBBgkbMDk5Eg0IBBZgG3ANzcYg8nBDxhkksGASAKDjcFgQL4BEYxRREKAEkGruNJK2ji7s5NnrudFHaFl1Keu02GmZ3d/389nX2xXT3X1OXWq6lTXdao88OydTeb9AbVuruP7km4qSXt1nX3C7ygWCP3fkuQ7JX2r0bxVHlDzfyStXPDarOq7dn5QMV9JuqzRADV3d0lnlyQ/QNLbG8m3ldz9l0rBgrW81cxqHZOqXqDyRaRAO3xR0u0laeeY2UFLWZj92OaS1x9RBO41xMwOlfT+Rv++hk9LGi1J+1ATi2T/TtJpDf7tPRQPLSjrM19mZk9sJN8i4OTVDRdsgaIv/WRJ8l+YWdnT1pfSf6t2kK4knd1M/VQKzoh2pVgu/lbSLSVpaySdX1xvi8KSVyvt0tfULk6tVtxrfbMk+VFm9meN5l3s/FrWhs0r3Xu0Q9kuRBPuXmvHysVUVpbblrQUC7j7F1V+39Mh6d+LgLJFY2aPU9ohKAxKcPcrVL5z9vOLXdoaLccapZ20ahlTCsbc331Y0kyN17slfaloC/YFZeO908ys7AEeoeJhTh9r9O9LbCx5/d4t/pymFfOM/1qSfLKaeIhGEST+QZUHiTNXDwAAAADAPogAHAAAAKBQLPgtW/zdqfqeaPmvksp243iumZ1ZR16/ZWZPU3oqZi3bJf1LI/mird6stDBoIZP0BTN7Qj2Zmdn9JJ0nqb8FZWunsqCAU5QW4C9UtutUPWrl8SxJZQs5ftiCz9zvFIEL55Ukv8DMntlIvmb2Zkm/33DBFnD3OUnvLUnuUVoQNlxvvmY2pPSk+L6St7zf3ct2gKqibDHxqTVe+4m772oy71r55spR1TnK74LzvCbzvwcz6zazP6/jT95X8voapSfd1/0UXTM7WdI/1vt3wGIqFqy9qSR5vaSvFrtUtJSZnWBmp7Q6373YFSWvr5N0ZiMZmtmg0lP1VzVYpnso+pX3lCQfLOm79QYhmNnLVb5baTPKdt7olPQfZvaIejIrnn7+daVxQiu9U+VBTZ8ws1rB6U0xs6Gqu08U45YPlySfogb7teLzX9nI37ZDUffPVNoFsJajJV1iZg9q9Web2dFKgVDvV1qMvhzlHkTyL2Z2XL0ZFouePyHpmJK3fNXdf10hn+cWu6C00gtKXr86KMsri/uFligC4M4sSb6qVZ/ThJeoPMh3QNJ3zOyMVn+oma0wsw8qXTf1BPmV1eMOSV80s7UNlKVHqS8uC+D/mLvvqDfffY273yDpoyXJD5b0KTNreftnZg81s1btEljFVaodaNSvBneEK+rYuWrdbod3ubbk9VMWoU1thX9UeR/9HjN7YIP5vlfS75WkXeDuZTtuAwAAAACAvRgBOAAAAMDv+jdJvylJe7aZlS3s+B3uPqP8DiSfMLOn1FOw4inMn1f5OP6tdS6kxjLg7j9T+VMoeyR9y8w+FC30N7MeM3uD0o4Mez7xuOwpzMtd2e4yHZK6arze1A44hVoBOGXBN/OS+BG9cW9QeeDZZxsIPPtLSW9pQbkW+oSkskV795f0NTNbUTWz4jr+qqSyhR03SfpQXSVcwN2vVvlT6Bf6Xp3Z1xNU01QAjrvPKi3Iq1VPJOkzZvZPrVhkZWbDxRPjN0j6eB1/+hVJl5ek/ZFSX1+rvSorx72UFgG2PJABaIFzVN7Xnibp8iIIuGlmdrqZfU1pZ8qWL1TfW7n7RpXv1vm+eo9/sUj4B2ph8Ooe3q/y/vNYSVeZ2fOLxfOlzOxgM/sPSR9ZkNSS8a27XyjpcyXJ/Uo7lrw3euK8mfWZ2duVxpJ7jtlbVc4tSjvO1dJXlLMlu+6Y2briu9ws6fV1/OkHVD7+eLWZ1bU7Z7Hrxb+r9rh/2XL370t6VeYth0q6wMzeWQTANaU4X+9WCup4XLP5LSZ3v0TSf5Qkr5X07Xp2yCoCnc+WVBacMaV0z1HFcyVtMLPPFcHQTTGzJ6s8eCzayeR9km42s3e0aIe5d6v2AyyqlGXRufttkv5M6XzV0qsU2P7lVgRBFO31y5UC/f9K5TtWlPmyynfrPU7SecVuNpXLozTP96iSt2xV87to70vepPJdap8l6Yet2GnMzDrM7I/N7MdK8z5LFoBTzOteVJL8FjP7g3ryK+Yr/ltSpaDaerj79aodQGeS/rmo38uGu29QeRDXkNL1e9968izGN2VjNJf0mnryAwAAAAAAew8CcAAAAIA9FDsevLskuUvVF3DI3b8g6TuZvP7DzD5pZgeUvEfSbxcGf0jSN1X+NOVLVf7UYSx//1fSL0vSTOkpl7eb2ZfM7AVm9lgzO9XMHmVmZ5jZJ5V+9H6HfjdgZEpSSxbjtcGFkmYrvvfOYleVZtWzi87PeQpt49z955L+uST5rsCzD0RPfzazA4uFuQuDVlq14HVa0lkqDwJ5pKQrzSxc8Ghmj5L0C0mPKfs4SS939/FGyrrADyq+r64gmWLBStnubnuaknRBPXmXfN6PJL0985ZXSrrGzM6qd3FP8dTrZ5vZV5UWDL9fUl1P6S12znuFyp+i+3ylJ91nF3KaWaeZvUJpd4tD9kjaImmynjIBi8Xd55UWOW8uecsxki41s0+b2Yn15m9mDzCzd5vZr5Xajz9R/Ytil9oaM7vPIv6rNe7/fElZViotOn1uhaCWrmLx8cIAp3lJtzV0JBYodk16tqTpTHk/JekWMzvbzJ5pZg8v6sETzexlZnae0iLbhQ8t+JnqC5aM/LWkG0vSOpUWTt5uZp83szPN7DHFOPzRxfH+jNI4/I363Z1HdiuN8VvC3c9RelhELV2S3m9ml5nZ0yzteFFZMZ46y8y+K+lWpe+SvUetUb5dKl+AKknvNLPzLHgivpn1m9m7lMYoewY+7TUPFXD3D0t6V+Yt3UoP67jJzN5iZsfWk3+xMPwRZnaOUt39W5XvrLjcvFpp595ajpL0CzN7qQW7CJrZCUr3brkdkt5ZZfebPXQr9XM/N7Mrzezvzez4Ov5eZnaAmf2DpK+p9u+v40q7JUcOUJp72mhm3yuOSV07q5jZ8ZaCWV9b8pafu/tP6slzsbj7xZKeofI+Q5KeKuk6M/u4mT2k3s8ws5OKYLUblII6GwpuKsZDZ2XK+kBJV1uFB+4U3+Onkp6Wedur3X1r3QXdR7n7qPLji9MlXWspeLbe3fY6zeyRZvYRSRuVdrR7aFMFblzZeK9f0v8zs1dUaCfN0q6x1yjNW+yplX3qN0pef7KkXxXj+6ea2WlmdnLJmLfuHdCa8EaVf/+1kn5iZq8rGYf/lpkdbmb/T2mXwjIfLdo3AAAAAACwD9qrnh4GAAAALJFzJb1Z0hE10s4ws7e7+w0V83qO0g/qZU9LfKGk55jZt5SeSHiL0sLGVcXfPFZpAWLuqctbJT29CB7CXsjdx83sj5Secln2tNQBpUUpz6gj67OUnuxay7KuL+6+28wuk1RlcU1LdqJx9xvNbKOqPd20bIceVPdapYUgtRZqm9KC2BcWC8fOV1oEs03SOkmHK+0w8jj97mJXSbpTaTecc1pRSHf/gZm9RdLbSt5yuNIimF8pLYy9UmkB85zSU85PkvRM1f6ee3qPu5/XijIrLVp9ZvCeCaVAt3p9TymwJOdid59oIO97cPe3mNlRSk8mr+VYpafYvsfMLlDaoeM3SnVlu1JA18ri33pJ91PavegEpYXVzZbvEjN7m6S3lrzlVKWFnBcpPfX9OqX6MaBUPx6sdK4OrPG3r1YKrt1bFtViH+fuN1t6qv/3JdXauaFb0pmSnmdm1yhdj5cqtcvblILzRpSux1VK7eL9i391LfZfJl5Y/Fss99Y9A7Q/qLS7xroa7x+R9FlJbzKzL0u6RCnAcFJpQeEhkv5Q0hNVe7z5j5JO0e8GAjbM3S8zsxepfIcZKbWDud1CFtquNBb+85L0use37j5ajMN/rPIdyIaVFvw+u2q2Sn1l2QLPRsfhZyqdn7Kn3z9AaUeLLWb2I6UAhZuUrr9Rpb7nrj7xSN19/R2tFgS8ufsXzOxJkv6i5C1PkHSDmZ0v6b+UgkfuUDru65Xq559LWri74LzSThVfa7aMS8Xd32BmE8oHEq9Wmnd4c9Fm/ljSVUoBAtuUgjU6lZ7Kf7Ckeymd4z/Q3tlmyt03mtkZSue/VoDKsNLusG81s39TasduVQpoO1gp2PMpSovic3X2O8ovio7cp/j3NjO7XdJlxb/rdPcYc0KpL1yrNK78faVdTPoz+f6du99aRzk6le6XHinpo2Z2XVGOy3X3vdE2pTZnUKlNPVEp4P/3VP4Qxlktbv9VN3f/upn9mdIOM2XzX72SXizpxWZ2q1Ib91NJ1yu1JeNK7cWQUj93nKT7SnqE6gy0D8p6hZm9SuUPlFin9MCdGyV9SSnI/jaloJFDJB2v1JfdP/ioc9z93JYUeh/i7hcUgSVfUHk78hpJrzKzK5Tmbq5QmjvdplRH7hqPrpV0stK5OFm1x7ft8GlJr1Nq8xYaULpH/NuinbxYqX5NKPUrB0t6mNKONwfX+PtPKV1LVcc0kX+W9CLVbpMPVwoSjWxQuq9fdMW47+lK9aJWkE2v0q5Tr7X0sJf/VTq+o0r37EdK+lOldjk3n3C5pL9pXckBAAAAAMByQwAOAAAAsIC7zxZPLf1ojeQupafVvrhiXpst7YzwPyoPrOhVWmhUtpAsZ6ekJ7j7TQ38LZYRd7/O0g4Z31aDT2Nd4O/c/TNmdkpJ+lQLPmOx/Y+qBeD8qIWf+b8qXzS4JwJwmuTuE8WC14uVFr7UMqj6FrzOSnqW0qKblnH3txdP0H1p5m3HS3pTgx/xOUmvb/Bva6mys82F7t5IO/B9xQE4de2sU8HzlRaQvyTznmFJjy/+LbW3Ky3SzD29+rTiX1WfcvfPmxm722FZcfdLi/HKeUpBNLWYUvDhSZJetlRl2x8UAcovV1qgXLb4/BhVW+y4p+8oPRG87CnmDXH3cy3tUPYxlS8Er2pU0h+7+68zT31vaHzr7leZ2WOV6vXqRgt4V3aSXuXuXzazsifnN1rOSTN7gqSvKj2oocwaNX5/2awXKS2ifVBJeqdSAHW4e+AeXq8UiLFXcfd3mNnVkj6jewYVLXSi4mDtelzewrxayt2/ZWZnKb+T1YFKwfiNuFTSU4udSlrhIKWdHJ7cZD7/qXvu2lkPUwooOU7V7ldzXuvuy66OuPt5ZvZgSV9RCjjLOVQpiD166EBVtyoFDFfi7h81s/VK84NljlT9/fFdviHGUKXc/UtmNq/0AKWynUq6lPqisv5o2SrmpV+iND9YtpZjvfI7z9VyiVJAa8t2EnT3n1nalbvSPPly4O4Xm9kzlYKWy47vKqX5h9wcRJlfSXpig/MtAAAAAABgL9Hsj14AAADAvurTSj/A1/I8M6u1O05N7n6N0tNQf9OKgu3hFkmPcPeftDhftIm7/0LpSbXN7OiyS9Lz3P3dxf/LnuTdkt0pFlnVIJdWB+BEvOL7EHD365Wedr6pBdnNSnq+u3+vBXnV8jJJ7w7fVb/3K5XbW5Whu2+QdHPwtkaPU5XgmpYG4Lj7vLu/VNJfKgXiLCvFuXuO0g43rcCCOyxr7n6J0mLGS9tdlv2Ru39F0htamOX3JT3F3WdamOdvufsnlIIjb28im2sl/YG73zVGbvn41t0vVRqHN3NvtUPSM9z9g8X/F6Ocu5UCAd6jNCZdVtx9XCm4plUBMx9w9/e0KK8l5+7/qbT73reW6CM3KS0WLtslaVko2oXnqPXjuvMkPcbdd7U432Z9TtLTWhgU1Kh5SWe5+9ltLkcpd79K0gMlfUBLs2vvuNJuFye4e3T/9Dvc/Q1Ku7q2+rx+SimIbFH65X2Fu/+7pIcr7aa2z3H370t6eQuz/ImkJxf9dKv9lVL7u9co+uc/VnqwVStdKOlh7l45oA8AAAAAAOydCMABAAAAaiieUvfekuRu5Z9yWSu/XyktVPxkk0W7y5ckneruV7QoPywT7n6L0iKCF0i6vo4/nZH0WUn3cffP7fH6ypL3b26shEvqAsWLbnZK+nkLP7NKYM1V7r61hZ+5X3P3q9V84Nlmpafif741pbonT/5O0pMkbWxBlpsk/Zm7/59FWowXBcE0FCTj7rcpPdG1zG4t0lPq3f0jSotYF2Nxz4yk/1K8u09N7j4t6RmS3qrGFwu6pA8q1YvpBvMAlkQRQPlQSX+jFHTQahskvVkt3pFlX1EEWr9AzQVUzystcH68u4+1pGAl3P27ku6tdH9Vz8L4LUrBRvd39yv3eH1RxrdFvT5NKQiynoXY05I+Iekkd//yHq8vVjln3P11Sg95uKyZvErsVtpV4LWN/LG7b1cKsP5UE2WYlvQad39VE3ksC+5+g7s/WWkMeeEifcwGSa+SdLS7f2IZBHqE3P0LSvcArajD45JeI+mP3L2RxdRXKdW5Vrtd0nPd/XnuXnV8+NNFKMdd+T7U3f9lkfJvGXffVVz791faoWIxAnG2KfVJR7v76xvtB939vUrtXSseuLNNqb68kHuBatz9YkknK53LxThmV0h6paQrozcuhiJY8SlqPkjkU5Ie7u5bmi/VPRVz6H+k+sdPbeXu/y3pVEk/aEF2M0o74/4hwTcAAAAAAOwfCMABAAAAyn1c0h0laWea2eH1ZObuo+7+YqVFBF9W/T8OzyotQjzN3f9isX44RfsVuz18WtJxkh4j6WylYJQ7lerNrKTtSguFviTppZIOd/czazy19eCSj2nmKeRLolg8FQWZXdDiBWZXKy18yam6Mw8qcveNujvw7IY6/nRC0kcknVgsnlh07n6epHspLTqvJ0juLjcrLWg9zt2/1sqyLZALsNmp5hY75nbP+fFiPq3Z3X/l7k9SWrB5rqRmFo3vUupX/1LSenf/E3dveLF/0Xa/RamfP0/17Uzwv0q72r2yjgWaQFu5+2zxFP0jlNrEq5vM8kqlXcEeptRGvs3dy8bi+71irPgApbFgPe3GvKRvSnqIu79qqZ6w7+473P21kg6RdIbSjhA/VwrgmlXaCeNOSRdL+pikP1Ua376rWNi5p0Ub37r7nLt/TNLRkp6gFBh5kVLQzLTSAsttkn4h6V8lvUipD3lJEaS6JOUsynqhUn/4eKX+rJnFx5uV6tKZkg529+cW+Tdatgl3f6GkR6q+wFyX9DWloKv3Nfr5y5G7n+fuD5X0EEkfVvM7QG6RdI6kxyq1mR9w92W3U2BOEVj3YEnPVGO7T21Xulc+1t3f1+h9YRHssUbS0yR9RvXdj9RylaTXSTre3c+tsyy/J2m9pLMkfV3pPDdqXmnc/hxJDyqCFfYa7n6luz9DaV7kLZKuaTLLCaVj+myldvu1rRhnuPuPJN1H6Zxd20AWm5S+3zH11hf8NmDrtZKOkvQONRcAMqfU579N0snufqq7f9DT7nNt4e5fVXoIxadUfz9/vtI95gvdfVF3wS7uhT+mdB4ernQMv6F03W6VNKXluXPfBnd/pNLugj9S/WUcU/r94Hh3fxPBcwAAAAAA7D/MfdnNdQAAAAD7BTNbpbSo6w+Ufqw/SukpyX1KP0yOSrpRaTHjjyWdx1P0UC8zO0cpqGGhV7n7B5a6PEDEzDqUAs+epLRz2LGSRpQWQuySdIvSIu3zJX3T3aOAqUVlZg+R9CilxYPHKi0sHiySdystsr1O0qVKC+AudCZjWsbMepWeOn260sKkI3X3OehROge7lIKObpH0S6WFcT+T9BN3n13Esh0n6c+VFiCdKGmtpN6iTFuKclwk6evuftVilQNYSmZ2L6UF9w+SdLykwyUdIKlfKchiV/Fvq6RfK10H1ygF1BJs0yAzO1Kp33yEpJMkrVY67nO6u++8VinY7zxPOy7WyqdbUmeNpOnltKOGmd0u6cAaSce6+4alLk8ZM/s3SU+vkfQidz9nET5vhaRHKwV4nKwUHHegUp/YqbRI9K4+8QalOvFLSZdL+vlijk/M7AFKQVWnSzpB0ipJXUWZbldqB36k1CfeuFjlWE6KMe9JSrsuPUAp6OsIpWMzoDRmmFXa3eVOpR0Yf6U0Dr5A0pX72pjSzI5XCig7TakPOUzSsFL9nVAaP21Q2s3lfyR9d7EWO5vZQUU5TpF0jNI4/+CiPEPF23YpzdtsVgrKu0KpP/tFi8tyvNJ1fWJRlmOUxpVDStf3jNJ1PSrpVqVx7hWSvu/ut7ayLO1mZkcotSO/p3ROjpS0Tuk49Cv1exNKgZK3KtWXK5UCAS9ZisXxZnaq0v3sg5Ue3HBoUT4rynaH0v3hZUoPTfgRAfitVfQ5D1Majx6j1JasUKojU7p7PHqHUrt6rdLc6wXuPtqOMldhZocoBYo8QqmfX6M03rtrruRWpX79AqXxXs0x0d4y3muHYkz9BKWdPk9Q6peHJXUrXb9blR7E8nOlfujb7j7ejrICAAAAAID2IgAHAAAAAPZhZna10kKdhR7r7t9d6vIAAAAAjTKzo1R7B7oJSUPLaeGomd2kFIS20OnuftFSlwcAAAAAAAAAAADN62h3AQAAAAAAi8PM7qfawTdzSk+ABQAAAPYmzy55/eJlFnzz+6odfDOptHsHAAAAAAAAAAAA9kIE4AAAAADAvuuvSl6/3N13LmlJAAAAgCaYWZeks0qSf7CUZamgbBx+obtPLWlJAAAAAAAAg3hcWAAAIABJREFUAAAA0DIE4AAAAADAPsjMHiLpuSXJX17KsgAAAAAt8AZJh5akLZvxrZk9UtJTS5KXTTkBAAAAAAAAAABQP3P3dpcBAAAAANBCZrZG0k8kHVkjeVrSke6+aUkLBQAAADTIzB4l6duSOmskX+Tupy9xkWoys0MkXSbp4BrJuyUd7u7blrZUAAAAAAAAAAAAaBV2wAEAAACAZcDMzjCzN5vZqibzuY+kS1U7+EaSPkvwDQAAABabmZ1tZs8xs64m83mepG+pdvCNJP1Dk/m/2Mxeb2Yrm8znAZIuUe3gG0n6OME3AAAAAAAAAAAAezcCcAAAAABgeVgt6S2SbjazT5jZY+pZrGhmh5rZ2UqL/o4qeduopDc1XVIAAAAgdl9J50q6zszeamYn1fPHZnaamX1D0mck9Za87Xvu/l/NFVMHSnqX0jj8o2b2h2ZW+bcTMzvCzD4i6QJJ60vetkXSO5osJwAAAAAAAAAAANrM3L3dZQAAAACA/Z6ZvUrS2Qte3irpYkk/lXR18f8dRdoBSkE795P0MEkPlNQdfMwZ7v75VpUZAAAAKGNm50t61IKXr1ParfGnkjZI2q4UJN4vaZVSMMxDlMa3xwcfsV3SA939+ibL+UZJb1/w8mZJF0m6QtI1unscbkU5V0s6tSjnA1S+O48kuaSnuPt/NlNOAAAAAAAAAAAAtF/lpykDAAAAAJbcaklPKv416x8IvgEAAECbHVv8e1aT+UxKelqzwTcZayX9cfGvWX9P8A0AAAAAAAAAAMC+oaPdBQAAAAAALKp5SW9y99e3uyAAAABAC2yT9CR3/167CxKYk/Qad39nuwsCAAAAAAAAAACA1mAHHAAAAADYd/1a0sv3gsWJAAAAQBXfkvQyd7+l3QUJXC3pLHf/cbsLAgAAAAAAAAAAgNYxd293GQAAAABgv2dmfZIeL+npkp4oaaSJ7H4q6SOSznX3mRYUDwAAAKiLmR0o6SmSnibp99X4A8FmlAJvPuDuP2xN6e5mZgNK4++nK43Hh5vI7lJJH5b0RXefbUHxAAAAAAAAAAAAsIwQgAMAAAAAy4yZdUi6j6TTJN1X0lGSjpC0WtKgpH5JJmlC0jZJt0i6VtJlkr7j7je0odgAAABATUWQy4MkPUTS8ZKOlHS4pBVK49s+SbOSxiXdIelmSb+QdInS+HZ0icrZKelkpXH4fYpy3jUOH1Aah0vSpKStRTmvlfSTopw3L0U5AQAAAAAAAAAA0B4E4AAAAAAAAAAAAAAAAAAAAAAAAAAZHe0uAAAAAAAAAAAAAAAAAAAAAAAAALCcEYADAAAAAAAAAAAAAAAAAAAAAAAAZBCAAwAAAAAAAAAAAAAAAAAAAAAAAGQQgAMAAAAAAAAAAAAAAAAAAAAAAABkEIADAAAAAAAAAAAAAAAAAAAAAAAAZBCAAwAAAAAAAAAAAAAAAAAAAAAAAGQQgAMAAAAAAAAAAAAAAAAAAAAAAABkdLW7AMDewMxOlHQfSYdIGpI0KWmzpGslXeHuM20sHgAAAAAAAAAAAAAAAAAAAAAAWETm7u0uA7Asmdlhkv5a0rOUAm/K7JL0X5I+6O6XLkXZAAAAAAAAAAAAAAAAAAAAAADA0iEAB1jAzDok/a2kN0rqr/PPz5X0V+4+2vKCAQAAAAAAAAAAAAAAAAAAAACAtiAAB9iDmfVL+rKkJzWRzW8kPc7db2hNqQAAAAAAAAAAAAAAAAAAAAAAQDsRgAMUzKxT0jckPaHkLTOSrpG0RdKwpBMlDZW890ZJp7v7phYXEwAAAAAAAAAAAAAAAAAAAAAALLGOdhcAWEbeptrBNzskvVrSWne/n7s/2t0fLGmVpKdK+nWNvzlS0heLoB4AAAAAAAAAAAAAAAAAAAAAALAXYwccQJKZnSLpckkLA2ZukPRod78+87eDkr4i6XE1kv/S3T/SsoICAAAAAAAAAAAAAAAAAAAAAIAlRwAOIMnMzpf0qAUv75b0QHf/ZYW/H5B0qaSTFiRtk3SEu4+1pKAAAAAAAAAAAAAAAAAAAAAAAGDJdbS7AEC7mdkDdc/gG0l6e5XgG0ly93FJL66RtErSS5ooHgAAAAAAAAAAAAAAAAAAAAAAaDMCcIDaATJbJX2onkzc/SJJ366RVCswBwAAAAAAAAAAAAAAAAAAAAAA7CUIwMF+zcy6JD21RtIXil1t6vWJGq+dYGanNpAXAAAAAAAAAAAAAAAAAAAAAABYBrraXQCgzR4i6YAar3+lwfy+JWlCUv+C158g6acN5rmkPnv5LZ5L7+6w7N/PzGf/XOsGe8IybBmfyaYft3ogm75moDubPjWbL6MkrezrzKb3deWPww9v3JFNH5uey6Y/eP1INl2SgkOt3cFnbBmfzqb3dsUxmuMz89n0W3dOZtOjc3nsqoWX0j2NTuW/Z3/wPQ4azHeFm8dnwzIcNJSvc9Fx6sxXJwV/LknqDk5X/3z+XHRMjWXTvbP5IYN358/3buXbh0HPfwfv6o0LYfkDNa/8yehQ/sK7cWe+/ZKkrqAdnZ7Lf0Z/0P4Ef15JdN0EX0ETs3GljY5DpwXnIihDdBzTZ+TTJ4L+IjoXFnyHNd1x+2LTu/NvmM8fa+/JX3cdkzvDMuweWJdN7+vIHyfvyPept4/F101kpDf/GT3Byb59d3wuZoOONxoDRa68fVf4nkNX9GXTjzkgn75he74djfptSbpuS75Ojk3mj+VU0D50Bhf3uhVxW78mGG92RJ8xWKE/CUzN5scnawbyZbxxx0Q2/eIbtoVlWNmfH5/smMhfe+sPyI/DRoIxtyQN9+THD1uD8eiK3vzfR+dSkmaC/iDqCyKTc/k6ffOW+LkOR60dzKYPdOfbuI1BfYmuK0m6/yH5+4+r78y3USetG86mH1Lh2u3rzI8/5jx/LieD9iWqC5K0azrfhkXjk+geKromJKm/u7lKGf31dIX+6qDB/PUdXTfbJvNt4B1B3x+da0natGsqmx5dN0cHbVyVfn3z7nwbdvNovl/tDg5klfmTqE4eGlx7zbaBkrSqP1+v++bybZRN59vJjpn830uS5vPXrk3n85i/8+Zs+sQ1+Sm9m8+/PJsuSQc+8F7Z9MFD8mNuG1yRTe8+7LiwDB1DK7Pp3hG0UcG4fr4vX0ZJmh9a01QZdk7n2/qo/ZHi63s6uA+cb7I/SmXIvyfqL6LPGA7uj6S4X4zyWB1c+9E9WJ/n21Apvh+22Xwe0d93BG2DJM2uOCib3jm2JZvuXfk+1Xvy48D0nuC+fvfWoAz5+8T5/ngeett8vj+J5nh2BNfm5ZviuYneYKwYXZvRbw6R3cE4UZJ+cctoNn3rWH780lNhPj4y0BOMgdYOZdNXDeXHH6MVjuPa4Xx9icY4UTs9Gsw7SPFvRB3BGCoaSx4YHCdJ6gnqbDTPFP1+01ehvkRtfXQcor5gw7b8OO7OYLwsScetzreD0bms0u9GBoPrJhpzTwfzAt0d8bmaD3536Aju9KL7yCrTln1B3x3NLUTz8dHYQIrLOdSTP5bR74XRuZSk1X35z7Dg/mSyM3+vGU3RVJm7iNqP6FwNBD8o2nw8pp5t8jm/UftT5Z68wnRX1mgwPqlShjUDwZh4NhhvBr9ZqkKdnetsfi47p2siPw/dMb49zKNjKj8uj+4DbS7fn8yNHBKWIfqde6K31pKhu/XN58dx8ub7o+ieOzKheL7+jmDdw+278sd6dCr/99EYSpLGZ/LX3kjwm0A0b3h9MD6R4jn9iWCdzQHBby9DwXeYr9C+dEVjyeA79AfnokobF60NmwrKEJ3rKmOkM05d34LZSyB2lh3ZglU2wD19zG+kHQP2YeyAg/3dH9Z4bVzSRY1k5u6Tki6skfTIRvIDAAAAAAAAAAAAAAAAAAAAAADtRwAO9ncPqvHaFe7ezOPQLq3x2qlN5AcAAAAAAAAAAAAAAAAAAAAAANqIABzs706u8dpVTeb5ixqvrTSzI5rMFwAAAAAAAAAAAAAAAAAAAAAAtAEBONhvmVmPpMNqJF3XZNYbSl4/usl8AQAAAAAAAAAAAAAAAAAAAABAGxCAg/3ZYap9DdzaZL5lf39kk/kCAAAAAAAAAAAAAAAAAAAAAIA26Gp3AYA2Wlvy+h1N5lv292Wf1zQzO61VeX3msptblRUAAAAAAAAAAAAAAAAAAAAAAPsEAnCwP1tV8vpoM5m6+5yZ7ZY0uCBpdTP5Bi5cxLwBAAAAAAAAAAAAAAAAAAAAANivdbS7AEAbDZW8PtaCvHfXeG1hQA4AAAAAAAAAAAAAAAAAAAAAANgLEICD/Vl3yeuzLch7psZrPS3IFwAAAAAAAAAAAAAAAAAAAAAALDECcLA/6yx5fa4FedfKo6sF+QIAAAAAAAAAAAAAAAAAAAAAgCVGQAD2Z2U73bTiuqiVR61dcVrl9BbmdWEL8wIAAAAAAAAAAAAAAAAAAAAAYK9HAA72Z1Mlr/e0IO9aeZR9XtPc/aJW5fXZy29pVVYAAAAAAAAAAAAAAAAAAADLTqe1uwQAgL1RR7sLALTRrpLXh1uQd608drYgXwAAAAAAAAAAAAAAAAAAAAAAsMQIwMH+bGvJ6yubydTM+iT11vF5AAAAAAAAAAAAAAAAAAAAAABgGSMAB/uz20teP6jJfMv+vuzzAAAAAAAAAAAAAAAAAAAAAADAMkYADvZnt0maqvH64U3mW/b3NzSZLwAAAAAAAAAAAAAAAAAAAAAAaIOudhcAaBd3dzPbIOnEBUn3ajLr40pev67JfJfEeVduyqaPDPRk0w8e6cumX79ld1iGrWPT2fTxmbls+pEr+7Pp3Z0WlmGgO/89Brs7s+nrBnuz6SN989n0VX35/CVpYtaz6f1d+e/ZYfn0NQNxFzEzny/Dcavz5+KA3vz3HOmYCcsw1J2vk/kSxulrKxyHrtH8dTPTty7/9135eNip2Xydl6TRufw3WdGTr5MDg/lz1TNT4dr1fB6r5yey6UPzk9n0zRrOps8F14Qk3bRjPJu+aaxWXOYe6buCMu7M/70kjQx0Z9M3bssfp9VD+Tp/woH54yRJE0E72h+0cetX5OvT6ORsWIaB4DOOXJlvhwe689fNzun4uokurTnP16mZ+Xw7OhiUsWP3tnwBJHVsvSl8T1b/inz6xM44i/X5PDrGtmfTbT5fHw5adURYhrmgv4naKJvMX/sjvWvCMswGZZgO2uHIir582yBJq4L2Y6gnX+eiMVBv0B9J0lBfvl+MxnHRuezsyJdxosK1vbsn/57oM8am83V2ajY/jpPicVY0nt06nj+O24L+SpJ6OvPnMzoXUXrUjktxf7KiN1+fouuir0KdnZnLn6/u4Dj1BulTQf5VHDaSH0MN9+SPY3dQp7uC7yBJRwT97uhU/ro4eDg/NhgK+kQpPp/RvUd0Kmbm4vZjJmjLZ4K7h6id3RJc21Xy6O7IH6fJoI2K2jhJ6lC+DFGVunFHfsx8azBmrnDLrpt35MfMI/359mNNMLdRRVQno3M5ErSBBw3lryspPheHDOWPw3ww3h2bidu4PuXrVMfUWJhHs+ZWHJxN9678sezsH8mm9+7Kj3ePe/5RuuFLX8++p3/dAfkyHJh/HlD3IUdm02fXHpNNl6S5zqDed+T7G5sNxh/BuF+Sds/nPyMaXVgwxuoM0iUp6g3u3J1vw6JxXjSOk6RdFca0ObdsC+Y2RvPfQZJ2BOVcHbRB9z98ZTY9GiuuG4zb4Q7Lt5PBrYek/GesGyzbyP5ut9yS72/WDR2aTd8ymi/kocP5MZgUjzfvtfqwbHp0L9s7F4/Tbh/Lz9EePpI/1r3BPHWVfnkoGBNH47joM6JrW4r73ZXB+GPHRP44Rveqayscp+i+Pv7dIn/d/WZrPEcc3TNvGc8fhzt25tuw6zfHZVgX3J9EonNxwkHx/OvqJsebG7blv+eq/jj/6HxGbfXYrnzfflMwJo/mBCRpdDJfH6K5ieg3qCr3olH70jWRn8P13nx9mO+M5/wsGJd70EZ1zOSvm5nO+JromRrNv2E+uDcImlGbiuey5gfyY+ZoHrpvKD/HazP5MZQk+Uz+uonuLaaCe6htk/lx4E3B/bQUX9tRnxjdB0b3ulJ87R66Ij/GieaAornTKrZN5NuwqAx3Vph/jfrdaPzR3Zk/1quD3wOS/HjzwOB37ugeywZWZdOn+vLXrST1Tu/Kv8Hz103HeP7a39UX/77TE8zRjAbXZmdfMK8QjB0kqXNiR/4NFX53yOnviu8tjgju81b05PvV6LfXvgrz0Bu2B3N6QRvXH/TtFZqwpudPDw/WRI0HfcGtwXhXkkan8tf2dHCfePWt+d9/pyvUt2jeYFcwrp8N2nKrcN2ccer68D0AAADtwg442N9dUeO1U5rM8/41Xtvo7luazBcAAAAAAADAMhIF3wAA9n4V1hICAAAAAAAAAPYTTBljf3dJjddONLP8oy/zTqv4OQAAAAAAAAAAAAAAAAAAAAAAYC9AAA72d+fXeK1T0qMbyczM1qn2Dji1PgcAAAAAAAAAAAAAAAAAAAAAAOwFCMDBfs3dr5W0oUbSMxrM8umSbOHHSPpmg/kBAAAAAAAAAAAAAAAAAAAAAIA2IwAHkD5f47U/NbPD6snEzEzSK2ok/dDdNzZUMgAAAAAAAAAAAAAAAAAAAAAA0HYE4ADSxyVNL3itW9I76szn+ZJOqPH6hxspFAAAAAAAAAAAAAAAAAAAAAAAWB662l0AoN3c/TYz+5SksxYkPdfMvunuX47yMLN7SXp/jaSrJH2tBcUEAAAAAAAAAAAAAAAAAABAC3SatbsIAIC9EDvgAMnfS9pW4/Vzzewvcn9oZveX9D1JIzWS/9rd51tQPgAAAAAAAAAAAAAAAAAAAAAA0CYE4ACS3H2LpBfWSOqV9K9mdp6Z/YmZHWhmnWa20swebmYfl3SJpPU1/vZsd//BYpYbAAAAAAAAAAAAAAAAAAAAAAAsvq52FwBYLtz9a2b2d5LeVSP5CcW/qr4p6XUtKRgAAAAAAAAAAAAAAAAAAAAAAGgrdsAB9uDu75b0aklzTWTzeUlPdfeZ1pQKAAAAAAAAAAAAAAAAAAAAAAC0EwE4wALu/k+SHirp8jr/dJOkM9z9DHefan3JAAAAAAAAAAAAAAAAAAAAAABAOxCAA9Tg7pe4+wMlPUbSZyXdWvLWHZK+Iel5ko5y988vUREBAAAAAAAAAAAAAAAAAAAAAMAS6Wp3AYDlzN3Pl3S+JJnZSkmHSBqUNClpi7tvamPxAAAAAAAAAAAAAAAAAAAAAADAEiAAB6jI3Xco7XgDAAAAAAAAAAAAAAAAAAAAAAD2Ix3tLgAAAAAAAAAAAAAAAAAAAAAAAACwnBGAAwAAAAAAAAAAAAAAAAAAAAAAAGR0tbsAAJaXtcN92fSVA93Z9J6ufFzf1rHpsAwTM3Phe3KGezuz6QcP9YR5TM97Nv2O8dls+lV37sqmHzbSn00f6I7jI0e68mWQz2eT5zx/nPq7LCzDUEe+nEM+mU3v2vjTbLqvWBuWYXzgiGz6tsl8feq0/Pc8ZmW+zkvSfP9INn3XZP5cjM/k03dOxdfE5Gw+Dyn/Pabn8nW+t2sgLMMN2yey6bd15ocdPV35Ml67eTQsQ2TjaL6ME9PNtT+rKrQvR6zMX/+dHfk6uT5oPw4e6g3LMO/58z06lW9fNu2aCj8jEn3GjTvy5+roA/J18tAV8bkYC66tnqAd3B3Ul77g78eHDsqmS1Jf0L7cMZv/niNBn1hFn/LnyvuGs+lbNJhN37kzHhvcuD3fnxwYXHtrB1Zn0z1sQ6Vfb8vXybGgPoxO5o/jrUH7JEk/3bgjm752OH/937B5dzb92k07wzJMB8cqasOG+/J9QX9PPn10YiabLkm7gmPdFZRxemX+O0bHQJIODdrqqN+OxtTRcZLicxGlR2U4oC8eIw335ssZ9UdrgnuP7mAsKklj0/n60Bt8z+HgWI8H9y6rKhyn6HsO9uTb8qgM8ThRCobEGg7K0NMZ3ztEoiym89Ul/A4z8/FxiOpkMGQO2/oq5yK6boLqEtaHjuhASZoLjoPm83kEt9PhuY6uS0nqD+rkUHDtDvXmP6ND8XHqDIo5Opnvs6L6NNQTH4foHZ0z49n0Mc+PHcam4zo72J0/1r09wb3kTH6c5735saQkeWf+wtga3JOvGV6XTe865pRseu/K72fTJan70GOy6R33Pj2bvnPwwGx6NPchSSNd+esmaiZXBHNVbnGd3TqWL+fuoA2L2rgqojmYqJ3si8Zp3c3fg60Ixg8H9OfTR6LOQtJNW/LtQzRWHAi+51DQTq8ZiO/Zo75763j+XjJqZ7cH7bQkbQ4+I7IruE8c6gnmdyVtD+6BRoKxw7bg7w8O7iMladNYfh4omj/ZOJpv62/dmU+XpKNX5fuTaPwxM9fctS9JM8GHTFUY6zUjqtNVyhDdH4Xjm2A+r0oZtu3OX1djwZh6IvgOkrRrqrm2uCc4EHcG14QUt1FRO/uLW/Jz4XNRpZe0Lri+73XgUDZ9KGhforn0qK+RpF8G6auDOb/oHm7dYNzGdXdG80j549Qxky/DSG88fonukaLfDMeVP07bd8fXzYqe/BxvZMTy14X3xOP6ieB3rP7BVdn00dloPi3+juGlFaRPz+XPd/Q7WtTvt0J3UOGisYMkbdoV99050bU5EswhS82PkaaCscG2CmPFaEwcpR8Q/C4aFFGSFE3hTMzm3xC1o9FxqlLG1f35djS6x4pqQ5X74cGgHZ0Ixi87girfVWFudKg3/3tf9Fv9oOXr5JaZ+LqZC+pDVJ+i+bIqU8TRb2nRWDJqH7ZUuIeL2ofo3uDm4P4map+i8bAU/z4zOh7MOwYd2o4Kx2k0WNvlQYWxYLxrFe7BAAAAljMCcAAAAAAAAAAAAACghij4BgAAAAAA7J1a8Iw5AMB+KH4sHQAAAAAAAAAAAAAAAAAAAAAAALAfIwAHAAAAAAAAAAAAAAAAAAAAAAAAyCAABwAAAAAAAAAAAAAAAAAAAAAAAMggAAcAAAAAAAAAAAAAAAAAAAAAAADIIAAHAAAAAAAAAAAAAAAAAAAAAAAAyCAABwAAAAAAAAAAAAAAAAAAAAAAAMggAAcAAAAAAAAAAAAAAAAAAAAAAADIIAAHAAAAAAAAAAAAAAAAAAAAAAAAyCAABwAAAAAAAAAAAAAAAAAAAAAAAMggAAcAAAAAAAAAAAAAAAAAAAAAAADIIAAHAAAAAAAAAAAAAAAAAAAAAAAAyOhqdwEAAAAAAAAAAAAAAAAAAAAAYKl0mrW7CACAvRA74AAAAAAAAAAAAAAAAAAAAAAAAAAZBOAAAAAAAAAAAAAAAAAAAAAAAAAAGQTgAAAAAAAAAAAAAAAAAAAAAAAAABkE4AAAAAAAAAAAAAAAAAAAAAAAAAAZXe0uAIDlZd2K3mz6UF++2ejssGz6ph2TYRkmpmez6dfctjNfhnwRtHFnd1iGefds+knrhrLpx68ZzKYfNJQ/zrPz+c+XpO75mWy6zU1n03s6899hPiyBNOL589kxNZZN95l8GW02/x0laU1/Z/ienN6ufCxqx9SuOBPPH63erp5s+s9uzx+n8Zm5uAyBsel8HgPd+eMw3BsPGX6zdTyb3t+dP1cjwWeMBW3D1Gxca8cm83lMB3n09+S/w7axfJ2W4naySh7Z/IM2UIrrQ2QyOE67g3MlST3BtdfXmU+fmsuXYedU/B1Hp/JtzHzQZc0EZegLrispPk6dlm8/bt01lU3f0ZO/rmbm4v6mP/ge3R39+TJM5ut0h8WVNjrfW8bj/iKnynEYDdqP6NruDi7O6O+leBx2QH9+jLNtIJ++OhifSNKuyfyx7gq+R3Ttz83nz/XEdJURSl401ozGYQNBXyBJ/7t5SzZ9KOjzovFJdBwl6fbRiWz6XPA9oz5xokJfEtXZ6DgcPtKXTe/tjM/FoSvy7ejETP44RH3FL7fszqafdtjKbLokrRtsbmqmQ/l2+OagLkjSbHA6R4JzGY0lp2bjdnZsJl/ngq5ABwXHsb8rbmej/qQ7aOOi4zTZ5DhPivuj6N7h0BX560qShoN2LuqXozKMTuW/w7rg/kmK27Do2o0EQ9GiDPn0dYP5fjX6jCrXTTSM8r58GSYn858xHlyXkjQ6Gd1rDmTTB/uD8cd83N9MedBvdua/p03n23J15K8Jq1JhZoPrPziZ0TRRhWmk8D0ezIXNWL6NqzCk1kyF85n9jKBK9lUYI3V3VChoxlBwj7VlPG7rm50f2RmMyauYDg5mT/Dstl3BmDoaz84E435J2jaR/4zJ4DtE52qowrh+VX++T+oKr//m5uMkaWcwNzHcm/8eVepkJCpnZ9CGRfWhtys+F8PB+Wy2Tkb5V7F9In9tDgTXfjQ/sia4p5eqtcU5Ve6xmlXlfjanym8nVe5Xc+a68p8RzTFL0khwvqLxbJwet6PRsYrqS5X5spwqc13N5lFlXrFZ0XGM2sDoXErSfJRHkMV08IZK101w/xHN+c305ucmqpyruWguyvLX1UzwPbsq1Omo2kZZRFdmeN1VOFfRPXlvMD6JPiL6LU6q0EYFn9GK3z2jPKLfsaL2ZbTCbw6dg821QdE8VDR2kOI1DXPz+fowHc0RByczagOleG4hqvXDQXqVNq7KPXP274P0KschKsJAMHdpU/nfAzuCe3ZJ6gnah+hYVplfjUT1OmrDovFqdB8oNT9mjvq06H67ytggek/UhkW/g0X3R1I8TzQQ/CYZlXGsyd92AQAA2o0dcAAAAAAAAAAAAAAAAAAAAAAAAIAMAnAAAAAAAAAAAAAAAAAAAAAAAACADAJwAAAAAAAAAAAAAAAAAAAAAAAAgAwCcAAAAAAAAAAAAAAAAAAAAAAAAIAMAnAAAAAAAAAAAAAAAAAAAAAAAACAjK52FwAAAAAAAAAAAACDLRhfAAAgAElEQVQAAAAAAAAAlkqntbsEAIC9ETvgAAAAAAAAAAAAAAAAAAAAAAAAABkE4AAAAAAAAAAAAAAAAAAAAAAAAAAZBOAADbDkf8zMS/69pd1lBAAAAAAAAAAAAAAAAAAAAAAArUEADtCYl0p6WLsLAQAAAAAAAAAAAAAAAAAAAAAAFh8BOECdzGy9pP+v3eUAAAAAAAAAAAAAAAAAAAAAAABLgwAcoH4flbSi3YUAAAAAAAAAAAAAAAAAAAAAAABLgwAcoA5m9kxJT97jpfl2lQUAAAAAAAAAAAAAAAAAAAAAACwNAnCAisxstaQPLnj5Y+0oCwAAAAAAAAAAAAAAAAAAAAAAWDoE4ADV/ZOktXv8/zZJr29TWQAAAAAAAAAAAAAAAAAAAAAAwBIhAAeowMweL+k5C17+a3ff2Y7yAAAAAAAAAAAAAAAAAAAAAACApdPV7gIAy52ZDUn6lwUvf8Pdv9KO8iy2ob58s7CyvzubPj4zl00f6OkMyzDnPU3lcdvoZP7vu+MydHRYNn3HxGw2vbsjH9/Y15XPf9vknNYORE10/nvY1HQ2fbAvjsGcnvP8Z3j+ONjMRP4D5ufzfz+fz1+SOqZ2ZdNH+oaz6V3Bue7YsrlCGXZn09cdct9s+lEH9GfTJ2fyx0mK6/VAd/57RrqD4yRJh430NfUZwz35Oj/v+fooxcdhU9CGjU3l69zMfL4MEz35NlCS1g7k27hIT2f+2t24M98GVjHcmz8X3Z35+rC6wneM6tTkXL7ej07ONJW/FNeXvq78sZ6czZdxqDtuZ6PzGentzH+H/uA79HdJ88rX676gjBYc6r7gOFS4tDUU9P3RueoM6kOULsXXxUxQZ6eC+jIdpFcRjcPmgjasynGIxmGdwRgoMj2b/w6dHRZ+j4npfFs+Pp3/jJu25vv1KuPZrWP5cdjKgXx/1B/0iVVExykSHcdNwZhbklZO57/n3FC+jNuCMXdfV/PXzZbx/LmKrqvdwXE6f8MWPebYNdn3RP1Fl/LfcyIY552wZkAbtufPV9QdrewL6mzQDo/PxOP6TkVtdZhFVtSXSNK6wfwYZkXQF0TNaFSnJenOsalsejQenQs61oMrdLw7JvP1/pdbxrLpv9mSb0c37cjXx19KWj2UPxdjk/ljORscpx9W6K+i+rAzuHeI6kt8DxffW0R995bJfPqvt+bv2av0JWa92fSojENzwbxBBT3d+XvR3uB0d47G9/05h738b7Tl3z6ZfY/1D+bTp/PXTedg/jiuHegK25jBoL+ZDsazUX/kFl9X0X1aMEwL++31K+J5iaFgnDUW9O0zwVzWlvH8vWoV0f1NdM8dTOdJkq7fnK9zUTsctQ+3BXMTt+2c1CHB+ZoJvkh0rxq1s+Mz8xqO7m+Cvj26z4vGilWG7L1BfYjmNqM63xnd1FcQDS+icxmNuasI60s4Xo3LEB/L/N83e6y3T8zooOF8vxv9LhG1YZuCseiOibiNm4ga88BIcL+8eih/DCSpP7j+t+3Of8+J6ebncKL3NDu3UcVEUK+jOd6oTo8GfV5Xh+nOXflj3V/hPi0nGmtun5wJx/XRtRnNnUbX1XyF56FGR6HX8p/R0RON8+IOJ+zzgrHinEdzG3Hb0N8V9MtzwbVr+XY6uk+UpLHg97jJ2XweFaZXs1YP9IR9UjQmjtrqg4J2tEqfGF170e95Ub9c5bf87cFvRJHo3mT9yvxvt1J8LI9YmR/vRlUyXisgeXCsR4L50wlvrh2W4t+5omtXQfvQMTGaTT9Wo7ql55Dse1YEEwPRcewP7qcHKvwe2DEbzPl15Psr78mvedg5Fl8TPUG9nwjauKgdjeaIpbgNi67/6O+juVNJWhOMN8N5gaBfjeYtOzssfE80RorGkgeN5NuwdSviMfXG4Xwb1hOc76iM0TwUAADAckcADhB7t6TD9/j/mKRXtKks2E9UmVBbbFUm5IHlpMqEPLCcNBt80wrRD8jActNsUAmw1KLgm6UQBd8Ay0206HspRIv0gD1FwTdLoUqAH7CcRME3SyEKvgH2FAXfLIUo+AZYbqLgm6XAuB57m1YEpQJLaTn8zhUF3wDLTRR8A2DpteLhJACA/U/774aAZczMTpf08gUvv9Hdb2lHeQAAAAAAAAAAAAAAAAAAAAAAwNIjAAcoYWa9kj6p371OLpP04faUCAAAAAAAAAAAAAAAAAAAAAAAtAMBOEC5N0q69x7/n5P0Endn72cAAAD8/+zde5Sla14f9O9Tu3bdurqru0+fc+ZyhjkMTEiIICFgGNBEJCZICAgRkiVrSQCVkAVDhCiylBWCMgEEFgazckEUAQmsiELAQDDccYg4MIMCwXGA4cwczv1S3dV1r3r9o4960lQ/v/ecXV27+vTns1YvmP3s/ezf+7zP/a3nbAAAAAAAAAAAAO4jDuDACVprH5Xkq257+duGYXj3POIBAAAAAAAAAAAAAADmxwEcuE1rbZLkO5NMX/by+5P8tbkEBAAAAAAAAAAAAAAAzNXivAOAc+ivJPn42177y8Mw3JxHMGO01t52Wnl9y8+977SyAgAAAAAAAAAAAACA1wQHcOBlWmtvSfJ1t738A8Mw/Ng84nkF3jnvAAAAAAAAAAAAAAAA4LVqYd4BwDnzHUnWXva/X8ytX8QBAAAAAAAAAAAAAADuUw7gwEtaa1+U5F+77eWvGobhyXnEAwAAAAAAAAAAAAAAnA8O4ECS1trrk3zzbS//r7n1izgAAAAAAAAAAAAAAMB9bHHeAcA58V8lufyy/72f5N8fhmGYUzyv1CeeYl7vPMW8AAAAAAAAAAAAAADgnucADve91tqfS/LZt738jcMw/MY84nk1hmH4xdPK61t//rdOKysAAAAAAAAAAACAc2fS5h0BAPeihXkHAPPUWrucW79+83LvTfL1cwgHAAAAAAAAAAAAAAA4hxzA4X73rUled9trf2kYhr15BAMAAAAAAAAAAAAAAJw/DuBw32qtfUqSL7jt5e8ahuGn5xEPAAAAAAAAAAAAAABwPjmAw32ptbaW5O/d9vIzSf7qHMIBAAAAAAAAAAAAAADOscV5BwBz8vFJ3nLba9+b5K2ttbeeQv6PtNY+4YTXf2MYhuunkP9d87r15W76ldVpN3374KibfnQ8lDFs7R52069eWOqmLy/2zxY+VFxjkiy0fvoDa/1yqGwsT7rpywc3yzzazmY3faFIX1+70k0/mNRDRLvRj7OKYf+px7rpYwaphZWL3fTJ8qX+5/e3u+ntqF8fb72pX+cW9m5002/s9evD0XEdwsFx/027h/3vmBRHcsfEsFm03Z2if3h82OumT4p2+fj13f4bkrywc9BN3z/sX+jqUr8cq88ndZxVHktFHzfG+nK/da0v9dOPh35fPq060SRHxXAwKcaL5cX+vVib9tOTZFpUqqpOP7u9301fKe7VymI9JlaqcbdKH1NOzx31281C65fjXlGnq3F7TB7PbvdjnC7079W06gSTvP/F/njx6OW1IoZ+OY2ZI1Weu9m/zue2+ulbu/1yTJL1lf4caKOYK27t9dvVafRxm0XbrOpcFcNq0Ufeek+/7S0VfVgVw85+P/8xqu+YLPTTLxf3OqnHzareV2P/wZgJyoyqMW9StO2f+u3n8icevdp9z145KFbt4u6XQ1EM2S+uoUofY7Eo6+peTOvpSTl2HxUFUU0Fq/qUJAvFdawXMW4f9IOoxu0kOU4/zoMZx6y1om948GK9Zp+1f9lY6fflV0f0cVWdWy7abjUXHdPFrRYVe32piGHEvL1SlXXZ/qux/6g/rifJ4ouPd9PbcX/+MTzb/3yO++PuA5/yqXnyH/5Q/zsO+vOsNvRv+MrQL4dqPy9JJrv9LcnJpL/flqHf7l7Yq/uGqguaFvOPa2v9GB9Yq+dpu4dVnP08qjVWNZYk9XhSXeellWqPp27b1Vxuo9j7vFCsJXeLTux4xFiyuVet86pxu5//mHG52guv1qIXirXDmH54o1iD7RV1+mKxD13tbSTJxeI6nrrZ39Pb2u/3w9W4nCSbxVqyqvdVu6v2gJ4v9hSTeo5U3e/qucWY+clBUfG3tvvXWe1bPl/sKyT1vaj6l8rSiD2c/aIP2i7W1NWau1ovJ/V8tSqnas1+o6izSb3P8yu/+2I3/XJxrw6LOj9mj6eK8bef6d/LzaIfHhNDda+q9Goe9par/T3DpN773Cyeiz651d+3HDM/2Vju3+9iK6usD9sjtrKOinn76rQfY9X2q7EgSZaKtrm41E+vvqK6F2PmBtV+2UrRTz56ZbWb/sajlTKGav5QPWOq7sUTW/25RZI8trnTTa/mLwfH/Ur9m0/2n+0mye61fp2r+vrqGh693L9XSd0HPVWU9e8Wzz0+UMT4po06xmvFeHKpeGb5YZde101/6rl6nlatDar9tLUigzFbZRem/Xu1tFf8GVGxb/Dgav9vIpJkbbFfJ9tB/363w/5ccZjWY976my/306u9rKIPLJf8SZb2++177w39/fzre/178czD6930au2R1PsC1Xq5qtNv3qj7+vc93+8fqmdtVbt4ekRfDwBwnjmAw/3qpGXZf/DSv9PwRS/9u90nJ/mZU/oOAAAAzrHq8A0A977q8A0AAAAAAADw2jH7f14YAAAAAAAAAAAAAAAAXsMcwAEAAAAAAAAAAAAAAIAOB3AAAAAAAAAAAAAAAACgY3HeAcA8DMPwM0naaeTVWhtOePmvD8PwtaeRPwAAAAAAAAAAAAAAMF9+AQcAAAAAAAAAAAAAAAA6/AIOAAAAAAAAAAAAAHDfmLQ27xAAuAf5BRwAAAAAAAAAAAAAAADocAAHAAAAAAAAAAAAAAAAOhzAAQAAAAAAAAAAAAAAgA4HcAAAAAAAAAAAAAAAAKDDARwAAAAAAAAAAAAAAADocAAHAAAAAAAAAAAAAAAAOhbnHQC8Bvz1E177mbMOAgAAAAAAAAAAAAAAuDscwIEZDcPwtfOOAQAAAAAAAAAAAAAAuHsW5h0AAAAAAAAAAAAAAAAAnGcO4AAAAAAAAAAAAAAAAEDH4rwDAM6XSyvTbvradDJT/hdGfP7oeOimTxdaN33S+uljFCFkKNKP03/D/lGRvnSh/wVJpgtFF77QL+ubx/30w+PjMobFS6/rpg9Lq930pbf28z9eu1LGcLjxhm76C7tH3fSVxZVu+vrVN5cxZOiX1Vbrf8cTN17spk8n9XnZhaLer037MVZ1vmqXSbJz0C/rotqXdo/613Cz+P4k2do97KZPiv5l/7Afw5hyqr6jSl9anP38dFVfjotO7qC4mVU/nSR7VVkWMVQxjlGVdRVDpSqn1f6QmyS5XvRhByP66p6nb/bbRFKP/dsH/Tyqzz+7fVDGcFC0/6o+XT/sl+OYfrZq/1v7/XK4sV/3UXdb1UetF/PAJFlf7s8/qu9YGlHW3fxHtMvVpX6MVT86pi+vLBffUfU/F4tyHjPfnXW8qer8GDtFvV9f6V/n5l6/Xb1+ffkVx3S7jSKGg6I+rCz2+7jVaV3nF4t7MT3eL2LoX8PaiBgqF5f7eawsFnV6qY6hqpPV/GK5FXW21TFU92upiKFqNrOup8dYL/qHlRFzyaVJUdZFX7661L/Oak5e9aFJcjTMVpbVvRhzr3aLGz6mrHvGzHer8aBag02Lez1GuX6pvuNgt5vcDvfKGNphkcdBP4/huD9eHW/fKGMoHfb78hzd/bliK8o6x8XaoOhHVxcvlTEcFWVd1Zeqzo6p0dV0tFpjVW1zzHp4eaEfRNUPVuPRiBDKOXHVtivT4hoXR6wLqjyq+lB2P8U6M0mWJ/151nox5lX38sqIjYFqrblczMPaUT+Gao8oqce8SrXmPij6hjExbBf7gtXYXs37R+VR1Klq6/JGsf4Z0yyry6jWWDervY1iHpfU/Uc1V6z6p7Xi82Psry1105cX+9e5MaLtVtdZrZervYkxa/Zqf6T+fP8aqnv9wHq/nJO6HKoYNtb69+L5rWIONuI7qnvx5FZ/rjnmuchesXdZqfahq/3bpB53U2zhVnOgMdtt1di9td2/jmpoH7OXXpVD9fy3WsZt7vYL8lrRPyXJcbEersa0akyt9trHuLhctav+5zeKfahb7+m3/2rPr5oDVX1Dklws3lPtya0X/fSYe1Htl1f7BtXexUaxT32t6IeTEfP6apJTrFUvjLhXs25/VG27+tuPWzH07+fqSn9N3Yo5895+HUMV5upi/287ppP+/T4u0pPkuBjzyr+jKfIfc6+nk35fW/+tUP8NVR83Zn1Vte0be8VeVvH5ah2Z1OvVs9jrBgA4zxzAAQAAAAAAADiBPy4DAACA16bZ/zN2ANyPjB8AAAAAAAAAAAAAAADQ4QAOAAAAAAAAAAAAAAAAdDiAAwAAAAAAAAAAAAAAAB0O4AAAAAAAAAAAAAAAAECHAzgAAAAAAAAAAAAAAADQ4QAOAAAAAAAAAAAAAAAAdDiAAwAAAAAAAAAAAAAAAB0O4AAAAAAAAAAAAAAAAECHAzgAAAAAAAAAAAAAAADQ4QAOAAAAAAAAAAAAAAAAdCzOOwAAAAAAAAAAAAAAgLMyaW3eIQBwD/ILOAAAAAAAAAAAAAAAANDhAA4AAAAAAAAAAAAAAAB0OIADAAAAAAAAAAAAAAAAHQ7gAAAAAAAAAAAAAAAAQIcDOAAAAAAAAAAAAAAAANCxOO8AgPNl++Borp9PktXppJt+NPQ/f317v5v+XJGeJI9srPbTLy1309cX+9dwXFzDM9uH/TckWV9a6qZvLK1109cWWzd9aCPOaA79C9lb3uh//oFH+9lP+teYJG047qYvFNdxfa9fZ3cW6qFycdIvy/3DfoxVnV6oKkyS7aP+dWwV1X6h9a9hrWiXSXIwIs5ZHJ9C/kcz5lHeyxH5TxZmqy+z5p8kS5N+uziNsq4UzSbHRZ2s6uy0+oIkkyqPhX45LRd9/fJi//PTEfequo4qxtKI1cCY9j/L58f0HWV9Kcaj6vPVvUqS3cN+YZXXWXT26yuzL82q9n+x+I61pfpeV99Rpc/aD+/N2EcmycXlfjls7/fH1DHlVLm8Ou2mP1jMNXeKGMe+p6cqhyrGpL7fD1wo5rPFvRrTdi8t9+/X7lG/zm7NWI5HI6rsUPRhKeazVT96o5jvJnUfVgyZ1bIg2wd12y+aRem49evLQu7+/KaqkqPG/uI91f2eFvO8ah6YJKvFhVT96IWiPu2v9W921faTeg5U7U1UdX5M/7JRjKsrRR5V/3BwXHcge4f9+lDVuGpOvT5izFsovmW/WvAuFuv+43p/pNIOdrrpR7s3+yHs9NOHMZ39QlGWxd5GOzroZz9mD6fIo6ov1T7RiO2Tsg+aLPTrS9V2V6d1OSwU7eZS0QftL/bv1eZeXRB12+tfRzW/2ViuB9XVon1Xff3KiPGkZ8w6s5r7z7rmHrN/MuY9s6jmWEk9XhwVE7HDYu4wbryp9l/7F1KNy2OeKVT3s9oXqFT7BnuHRyP2oqp9pH76tbX+mHixaPtJvfewW9zLB4oY9i/Pvia/VqwDq3Ics69Q7a9W7aJq+5eL+WySXCkWOEtFfVhd6vfDY/ZHquuo9jeqsaJSXWNS713c7X2mMXlU6VV9O1it71X5jKjof6o+cEwfWY0HdQz9/Md007M+YT4+hXV/lcesda4qxzGqfYHq+U41VpyGaryZdZ6X1GP3rJ8f0wdWc5gnbux10+u/Waifk+8ezFaW1br/iaK6PH59t/+G1PX+4fX+da4u9vehP7jZX7Mn9bi8udvfe6j2gJ7rbzuMcrn4jovFvdofsTdR3YsXd/s3/M3Tflm3leJvQ1Kvd6slWNUPrw713wJNn3lf/w3X3tJNnqz0/5bo+d1+31DVpyRZKjqpN22sdNM/sNlvm+sj9k/ecLF6ftOvk9tF/7R4l9fbAAB3m1/AAQAAAAAAADjBafzBNAAAAAAArw0O4AAAAAAAAAAAAAAAAECHAzgAAAAAAAAAAAAAAADQ4QAOAAAAAAAAAAAAAAAAdDiAAwAAAAAAAAAAAAAAAB2L8w4AAAAAAAAAAAAAAOCsTNq8IwDgXuQXcAAAAAAAAAAAAAAAAKDDL+BAobV2NcnHJXl9kstJ1pNsJ3kxydNJfmUYhifmFyEAAAAAAAAAAAAAAHA3OYADJ2itvSXJv5vkc5J8+Ij3P57kh5N8xzAM77nL4QEAAAAAAAAAAAAAAGdoYd4BwHnSWrvcWvvOJO9L8tUZcfjmJW9M8peTvLu19iOttUfuVowAAAAAAAAAAAAAAMDZcgAHXtJa++gkv57kC5O0GbL69CS/3lr706cSGAAAAAAAAAAAAAAAMFeL8w4AzoPW2r+Q5CeTXOu87bkkv5NkM8l6bv3qzZ1+6eZSkh9qrf3ZYRj+yWnGCgAAAAAAAAAAAAAAnC0HcLjvtdYWk/z3OfnwzWGSv5vk7wzD8GsnfPaRJH8xyVckuXJb8kqS722tfcQwDJunGjQAAAAAAAAAAAAAAHBmFuYdAJwDX5zko094/bkk//IwDF960uGbJBmG4YPDMPznL33+PSe85eEkX3tagQIAAAAAAAAAAAAAAGfPARy49Qs2txuSfNYwDP/bmAyGYfhgkk9N8swJyZ/XWtPWAAAAAAAAAAAAAADgHuVQAPe11tobknzcCUk/NAzDz7+SvIZheCrJ3zgh6cEkn/AqwgMAAAAAAAAAAAAAAM4BB3C43334HV7/wVeZ3z+4w+sf9irzAwAAAAAAAAAAAAAA5mxx3gHAnD18h9d/49VkNgzDB1trW0nWb0t6/avJbx7WppNu+t7hUTd9ZbF/rm9lfbmMYaG1bvojl/p5PHFjr5t+NJQh5AObO930X/m96930t71po5u+WpTTzmE3OUmyX1zIc+1CP4O9427y0XFdUIuT/r066n9Fpgv9GJcX6nOiw1DF2U8/LGLcqy4iyfJxvxy2D/oxbO33b/ikaBNjHBTXUbWLKsYkOS7qzPJiv39ZLtpF1TfcPOj3T0lydX2pm75a9IHThX4MByPazebOQTd9Y23aTb+43J++TUe0m+Oi3VT3oqov1b1K6rK+UsRQxlg33eyn/6ZJUZTVmLdU9JFjWvZu0UlVbXN9afb6Us0Njor6dGGp//ntEW13oc1WJ0+jzk6L+1mp6uyk6F/GvKe6n9Xnx8SwVFxHpfqO/WpgHqHKo4qhqtNjyuk8qOZy1b08jetcLdp/pWw3I9rurNOoqhwPjmevs9X0YSja9kIx3x0zn93c7Y8nC60/P9k56H9+TF+/e9ivL9W4u7o4+73YOejn0V8l1jFu7tVz6jFl1VPNV8c07QvT/nVsFPPRK6v9+rJQBFF9PknWpv179UJxs66s9L+jWrMnyUExwVgqJpNHC0XjP6xjqPq4Wecv1brhNAyT/hptWKm3r6u54nGRnuee7CZPNh7oph8VfWCStNVij6ZysFt8QV1fFva2uunDpF/WVW1aW79WxtCKNdjRUMwVp/06eWnE3GNnoR9D1a4Oiz2ghy7063RSz2GurvSvY+2wfy8fvLBWxnCtiLNaW4zZX+0Z079U77m+299fqfahxnSR1Vzwue39OpOOZ27Wn3+h2Eeq9i6q8erZ7X7+SXJYzCer/bBqflLtKSbJtBpXh36MVX0asy9Qr8lnS5/1+8eo5qtVjLPuCST1vazWgacRw1oxXlT7CmPWulUfVLWb6jovFvPZpN5HrvahLxT7imOeIVWqel2Vw4Vi33J/qV4nVt9RXWeVPmbv4rhVe1H9z1ftpnwQlmR5MtseTjW0V9eQ1PPNatZdlXW1Fk3qOKs9/6ocrhbr3THr4fJ+Fx65tDLT55N67+JSMZ/dO+wX1MWl+hqr+eojl4q1ZpF/9WwmSV5/sf83C9WzkWpMrPZfkuTicvHstaizVZ1+9PJqN716fpQkv/b0jW561S52ivryIRv9GJNkebF/ndUc6cZev86/rnj+nNTPsTeKe1nNHcas0VaKcqjmzMO0X9YLe/17nSTV3TpcvtRNPziFvaoXHvzIbvrNao+4WIvuFf1HtcZLZv/7kOqZwNPbI/ayihC29vvf8YHN/l7WwyPaDZyV0/ibLADuP34Bh/vdnWZQ/aeYfSedzJjtL2gAAAAAAAA4c/fKf4gBAAAAAIC7zwEc7ndP3eH1/n/asu+kz/b/U5oAAAAAAAAAAAAAAMC55QAO97tfzsm/TvMvvZrMWmsfk+Sk3xr+p68mPwAAAAAAAAAAAAAAYP4cwOG+NgzDVpKfOCHp81tr7VVk+YUnvPbuYRh+61XkBQAAAAAAAAAAAAAAnAMO4EDyTSe89rFJ3v5KMmmtfVKSv3RC0jteTVAAAAAAAAAAAAAAAMD5sDjvAGDehmH4mdba38nvPzzzra215STfPAzDcS+P1tpnJvmuJNPbkn5gGIb/4dSCvfP3v+208vqR33jytLICAAAAAAAAAAAAAIDXBAdw4JYvS/Jwks962WsLSb4xyRe01r4jyc8l+e0k15OsJXkkySck+fwkf/yEPP/RS2ln4Z1n9D0AAAAAAAAAAAAAAHDfcQAHkgzDcNha+7eS/EdJ/lqSlZcl/8Ek3/IKsttO8vVJvqH65RwAAAAAAAAAAAAAAOD8W5h3AHBeDMNwPAzDNyT50CTvSPLeV5jFryf5miSPDsPwDodvAAAAAAAAAAAAAADgtcEBHPj9htz6FZvNV/i5N+TWr+V85KlHBAAAAAAAAAAAAAAAzM3ivAOA86K1tpzkP0vyZUlWXkUWV5J8XpLPa639XJIvGobhfacYYs8nnmJe7zzFvAAAAAAAAAAAAAAA4J7nAA4kaa29IcmPJ/moE5K3k/xokp9L8liSF5OsJ3k4tw6+fHqS19/2mT+e5D2ttc8ZhuHH7lbc/69hGH7xtPL60X/21GllBQAAAAAAAAAAAHDuTNq8IwDgXuQADtjZqoQAACAASURBVPe91trVJD+V5CNOSP72JF83DMOzd/j4d7XWlpL8e0m+Kcnay9IuJPmfWmt/ehiGnz3NmAEAAAAAAAAAAAAAgLOzMO8A4Bz42/n9h2+GJJ8/DMPbO4dvbr1xGPaHYfhbSd6WW7+O83LLSb6ntbZxatECAAAAAAAAAAAAAABnygEc7muttU9M8rknJH3TMAzf/UryGobh/0jyb5+Q9KYkf+VVhAcAAAAAAAAAAAAAAJwDDuBwv/vSE157PsnXv5rMhmH4sST/5ISkL2mtaW8AAAAAAAAAAAAAAHAPWpx3ADAvrbWW5E+dkPQPh2G4MUPW35fkT9722sNJPjrJe2bI955wdDx001cW63NI08lsZ5V2D49njmGhtZlimCz0P79flNNvPb9TfsfF5Uk3/Ykbe930tWn/82M8sdX/juPiOh9aX+6mbx8clTFU37G5d9hNr+71mHKazFZd8saLK930vaN+nU6Sg+I9W/v9z+/u98tpzJndi0v9snpgbambfjz07+VOUR+qdpckS0X/cmV12k2v6uQDK/3Pn4a9oo/bS11fqrLcPujfy6rdVPcySTZ3DrrpS0VfvVq0zeUx481C/z2be/0Yt3b77eaJjdUyhvWi3Tx9s2i8hWnRQVV9aJKsL/eXDAdH/TyqezGmvlR98QtFfbpR9HGTEeP+tOhjqhir9Oe263t9VJRVdb8fvNQfdy8W9zoZV2d6iuoy81iQJOsr/etYLdpdNZ/dWKv7+qqvvrreHxMvFeNJ1Ucm9XVU42b1+aock7qfrdrFxaX+vRwzT1sdUVazfEeV/k8/+GI+5UOv9vOY9Mt6YXezm76+dLmf/4hy2qjazYzlOGZ9tVT0YctF+vpSP8YRw82otWJPVU5j7sWsa9F6vKqvsXrPhaL9rxdttxoLqrafJCuL/X72oOjDLhT1ZUw5Vd+xuti/F3vFkLZQfD5Jqu2TKodq3B2zJj847t+L1vpj2sFqf35S1ZckWSnG5jbtr7knGw/0P7+y3k3/kC/+sjz5fd/Z/44rD3XTj9evddO3lvtjyRjrl9/Yf8NRMR+d9OcvOwf1WnSvuKHVnl7Vl4/pQqs9nGo8qvrZSyPm1NV1rCwUc4Od/txg9UK/zib1/sfy4uz7hj1XV+tyqsbEai/sNPY+q/3Xak5dxfjwhX4fmNTX8UBxL48z2zoyqdtmtf6p9gWqzyd1na3yqMqxGs/GWC4G5mqu+eCF/jWOmZNX+waV6l7vjtinrvZYHrrQH0+q50Nj9iWq+UO1nq3W/W+81J9bJMmbin3B6rnFflHWz1cb/knecLkfQ3UvqnVi1e5u7NdzycPiOqt9ycrCiGcG1d5m1Xarfccnru+WMWwUfdz7X+g/M6zK6dkR+47V/arK4fHiyXpV35J6fbJZ7MdX65cxa4ut4n5W692qTlflXLW7pC6H3cP+d4ypD5WqHK4WdXpzt7+f/9CIOVL17HSzWnQXxuyVV88lHtvst/+qzldzySS5WoxZ1bPbjeV+P1mN6zsj5nFvfWCtm171DyvFfPWB1XreX7X//eINV1f7fWC1R5Qkq8VeUxVDVV+qzyfJzmHxdxPFTtLWclHfhvpvXIZpf37y/E4xRyrKem1E//H8jf53LBd7ctd3+/3LU8Wz3TH7bf/smee76ZeLfnaj6MNeLMaSZPY50gc2+/Whmg8nyce8sf/sAwBgnvwiB/ezD0ly0hP2X5gx35+/w+sfM2O+AMBrSHX4BoB7X3X4BoB7X3X4BgAAAAAAAHjtcACH+9mDd3j9qRnzvdPn+/8pSwAAAAAAAAAAAAAA4FxyAIf72Z1+c7P/W8G1O31eewMAAAAAAAAAAAAAgHuQAwHcz569w+t3+mWcse70+WdmzBcAAAAAAAAAAAAAAJgDB3C4nz19h9f/6Iz5fvwdXncABwAAAAAAAAAAAAAA7kEO4HDfGobhepL3nZD0Ga21yQxZf/ZJX5fkf58hTwAAAAAAAAAAAAAAYE4W5x0AzNmPJ/nS2157S5J/J8l/+0oza6394SR/4YSkXx2G4alXHh4AAAAAAAAAAAAAp2nS2rxDAOAe5BdwuN/9/Tu8/jdbax/zSjJqrV1N8j8mOenXc+70PQAAAAAAAAAAAAAAwDnnAA73tWEY3pnkR09IWk/ys621Pz8mn9baxyf5pSR/4ITk30vy7a86SAAAAAAAAAAAAAAAYK4cwIHkK5O8cMLrl5J8f2vt3a21L2+tfWxr7YHW2mJrbaO19hGttS9orf2j3Dp882En5DEkefswDDt3MX4AAAAAAAAAAAAAAOAuWpx3ADBvwzC8t7X2GUl+IsnqCW/5mCTf9iqz/4phGH7wVQcHAAAAAAAAAAAAAADMnV/AgSTDMPxCkn81yXtPKcvNJJ8/DMOrPbgDAAAAAAAAAAAAAACcEw7gwEuGYfilJH8kydcneeZVZrOb5LuTfNQwDN99WrEBAAAAAAAAAAAAAADzszjvAOA8GYZhO8l/2lr7uiSfneRTkvyxJB+ZZHKHj70/yS8l+YUk3zcMw3NnECoAAAAAAAAAAAAAAHBGHMCBEwzDsJ/k+1/6l9baNMnVJJeTXEyyk+TFJM8Pw7AzrzgBAAAAAAAAAAAAAIC7zwEcGGEYhoMkT730DwAAAAAAAAAAAAAAuI8szDsAAAAAAAAAAAAAAAAAOM/8Ag7wz/nA5k43/Zkbe930/cPjmdKTZGmxfzawSp81/yTZ2T/qpk8WWjd9+6D/+aOh//039w/7b0iyOp1003eKGKprXF+ph4jnt/a76Q9eWu6mb+31r3OhKOckWV/uxzkmj57j4+Jmpb7fl1am3fSt4n4/fbNfzkkyLa6zqnMby/0Y16Z1uzkoyqpMP+r3D8tF212d9utbkkxmqw5ZX+rXtzH5V/dq1jo7XajvVVWWVR5VnV8r+qckORr69aGqk1VZj+o/ZryfVYzrS7P102NiqK7zoGj819b615AkV1b776nqy3Fxrx+/vlvG8PRWf/5R9S9VnRxTZ/eKOUzVLqo+boxJ69/vKn1lsb7OWe0W1zlr235gbamM4fruQTe9GhOvrve/Y8wcaWu3P7ZX87CkP/aPmVNXqvlsNWceM97sHvavc+Wwn8ez2/1yqPqnJDlO/4avFtf5QlGfVib9z988qO/V9aJtXj7u51Hdy0eKOXmSVF3Ui0Wdru7V7og6u1G0rYvFuF217WrukSTvfW67fE9PNfY/Vqy3k3q8qa6jGgvG2CzqzHufvdlNf6IYt6s+8nDEmFmN/S8WbbdS3cskeWGn/x3XijGrupdVXRjzHUU3nA9e79+rMXOkq0VffHV1tvnHjb16znxUxLm6cqmbPrn4QDf9eKHf/zz0BW/Piz/4X3ff04pxsx3278VhUefbiLY/tH4MizeeKTIo5twPvbWMYaGI83io1v39/KtySpLdYsDYKcbu1WJ/ZMRwU85Pto/65bR2+ZFu+s5O3W4qe0UHUvXD1b2u9kaS2ef1lWqtOka9Dux/x+ZePV5VeSwVi6it/dnuVTJmftL/fLl2GPGkspoLrk1nK6f9oxF7n8WFLqzMtmZ/5GK/k9sbUenr6+zn8ebLK930ql0m9TptzDqu58aI+cm0WKdVfdxO+ulj9iamxb24WMw3j4p+tkpPkoNiLTlrP1hVyTH5z/rMoIqh6qeTcWXZM/seUL0HU83Lq2uo+q+kXodVO7jVnt6Y9U21Rqr2FmYdr8bkMV3op1ftbta9sjF5VPuGB4uzz4Gq+lK13XpdMGJeP+N+fRXDmL2s6jqr+lSNR2M8VTyrr/qHan3z9FZ/7K/qfFLvn1R9VPVM8/KI/fpqvPndF/u93GmsHao1ULU3WtXJMX9PMGvbe+pmfw708IW1MoajneqZYX/fsbqG57bruebvvNjfo63uVfV8t3pO9mLRJpLkd5/t71M/X9SX6jnW9ojnFlUfVT2jfqr427Lrxd8KwVma9e+IALg/+QUcAAAAAAB4FarDNwDc+8b88ToAAAAAAPcHB3AAAAAAAAAAAAAAAACgwwEcAAAAAAAAAAAAAAAA6HAABwAAAAAAAAAAAAAAADocwAEAAAAAAAAAAAAAAIAOB3AAAAAAAAAAAAAAAACgwwEcAAAAAAAAAAAAAAAA6HAABwAAAAAAAAAAAAAAADocwAEAAAAAAAAAAAAAAIAOB3AAAAAAAAAAAAAAAACgwwEcAAAAAAAAAAAAAAAA6FicdwAAAAAAAAAAAAAAAGdl0tq8QwDgHuQXcAAAAAAAAAAAAAAAAKDDARwAAAAAAAAAAAAAAADocAAHAAAAAAAAAAAAAAAAOhzAAQAAAAAAAAAAAAAAgA4HcAAAAAAAAAAAAAAAAKBjcd4BAOfL/tFxN31n/6ibvnfY//wYk+Ohm74/43ccFfmfxnfsFuU4aa2bPibGo6F+zyzfMaYMqvdU6UfFJYw5JbpQlOV0oSjrIoaDEeVc5XFc5FHVh6pdJsl0YVK+p6eKsbrGJDku6lT1HWV6kf+Ye7W8ONvZ46o+TYr0Mcr+YcZyTJKD4oYeHPX7+uu7B9306YWlMoaqD6qvoyjrEf3omLKa5fNV+sGovr4MYqYYxrTtlaLdTBf66VU/fWllWsZQldXBcb/OVqr+Jamvo6rTVVmP6Z+q/qHqoxam/bFiOqn7sDFl1bM27V/nRlEfqmtMZh9PppPlIob6Xu2vzzZHqiyNqC9VnVxd6teH6juurNZt97ntfgw39g+76VW7e/rmfhnDalHv/9CDF7rpVTlW/dOYOXsrrrMdFeNu0SyWR7Ttw+ItB8ezzalPQ9VHVZc5DHU5VPe7GhM3lvvtYtJ2yxiqfm7/oN9/TIsYq2tIktXiPWtFu6rS6/luN/ml9/TftLXb71+29vrpZ6EaUsfMFXeL8WSlGHe3in54zLhbxXBY3NCdVuxNjCiH5eIth+XY31+/DEX68uWL/QCSZNLvH4bWv1fVWDHGsNif4wxLa/0Mjvv1pRqvkmRpcaWbvnM427x+cUSdLfvZGdf1Y8b+cl5fDGoLezf6n1/oz2+S5KEL/frwQrHu3z6o+tF+OTx9WM/jqnl9dS/L8WjEva7esjzpt92ntna66W887N+HpN7DqfahV4vJ4tq0ntdvFc8E3ljsA20f9D//wFpdDo9u9L+jqi9L2891059ZulLG8OJu8Wxkr5/+7Ha/XV1Z7T+yHdO/PLzWz6NaG4yZf1SquVz1DKnaH5kW7S4ZsZdV5HEae7xVDFXbrtay1Zo+qfcv1pf69eUDm/31y6Xl/uer/JNkofXbTdWXV3PRMXs4k2I+Wt3La0Uf+MJCPUd63XrdD/ZUdXrMHs5GcT8rH3Z1tZv+xI167H/jpX45PJZ+naz6sIUR/eiY53GzqPqXai9sTB7V3sbNYh045hl1tQdT7fmfxrOTMo9yc6H6fF0Xqjj3ivVNFeKILb0yzmoeVvWTB8f9/MdMHapyqmKs0qv1VVKPF9Vzz+oaqnE7SY6q9l/MJWd9pjlG9exku9iXrO5VUs9pqzyWF/tlPSaGneI9x8XYX63BqnIcM9es5sTV85tqrjjqeeBQPR/u51HFMKbdAACcZ34BBwAAAAAAAOAE1eEbAAAAAADuHw7gAAAAAAAAAAAAAAAAQIcDOAAAAAAAAAAAAAAAANDhAA4AAAAAAAAAAAAAAAB0OIADAAAAAAAAAAAAAAAAHYvzDgAAAAAAAAAAAAAA4KxM2rwjAOBe5BdwAAAAAAAAAAAAAAAAoMMv4MBtWmuLST48yR9K8mCSy7l1WO3FJC8k+Z0k7xmGYX9uQQIAAAAAAAAAAAAAAGfGARzOjdbaW5L80dv+XTnhrZ88DMPPnOL3riX5V5J88kv//sUky8XH9lpr70ryPUm+dxiGm6cVDwAAAAAAAAAAAAAAcL44gMNctNY+NMnHpT5sc7e+fzXJpyf5nCR/JsnaK8xiOcknvfTvm1pr70jyzcMwHJ1qoAAAAAAAAAAAAAAAwNw5gMO8vDvJxhy//8/l1q/XnIZLSb4hyWe11j53GIbHTilfAAAAAAAAAAAAAADgHHAAB+5sO8mTSZ5OspPkgSRvTbJ6h/f/sSQ/1Vr748Mw/N7ZhAgAAAAAAAAAAAAAANxtDuDA/+8oyf+S5MeT/HyS9wzDcPzyN7TWlpJ8UpK3J/k3T8jjw5L8RGvtY4dh2L/L8QIAAAAAAAAAAAAAAGfAARzOk8eS/HKSd730f5996f+/234nyd9L8t3VL9e8dKjmp5P8dGvtM5P8d0k2bnvbH07ylUn+xl2IFQAAAAAAAAAAAAAAOGMO4DAvjyV5X24dtPnlJO8ahuHZl7+htfboXY7h/Um+Psl3DcNw+Eo/PAzDD790COcnkizdlvyftNb+5jAMN2cPEwAAAAAAAAAAAAAAmCcHcJiLYRg+es4h/OMkPzAMw8EsmQzD8LOttW9N8h/flnQhyacm+cFZ8gcAAAAAAAAAAAAAAOZvYd4BwDwMw/DMrIdvXuZbkhyf8PqnnVL+AAAAAAAAAAAAAADAHPkFHJjRMAzPttZ+JcnH3Zb05nnEM6uH15e76Tv7R930rd3DmWNYWuyfDVxdmnTTj46HmfJP6uuYLLRu+tWVaTd9ofj82rR/jUmyWrznhZ3+GbPTKKeNtf51PnihX58+ZGOlm77Q+uWUJA8UMewcnHQ+brwXduuzejf2+vXl2tpSN72639sjrmG9aBcHxf2+utovxyr/JNkq+oe1ab9OVddZ1dkx7WalqNc39vv3svqO46EfYzKuXvccHPXLaTqp2+7eYf9eVfVlUlzCyogYpqv9dnGtaNvbB/1rOKpvRXkvHirGxKpOXlzu15dnt+v+pbrOWetT1faTup9dLdpVVRvGtJvqPctFDFXbXR5RZ6t2Ueu33THtZtbrvFH001UfmdR9UFVOy4v9GKenMEeq7ufWUb8cjotr2Dvufz6p+4dZ0/cPZ5vfJPV8trJT9E9Jsl/Ul8rBcf/z1RwsSY6K/uOZm/vd9Pc9d7Ob/qbLq930X396q5ueJP9ncb/f9qZr3fThZr8cxvRxO8Xc4FefvNFN/+CLO930MfXt2oX+3ODJEe1/Vs9s9+tD1faWFvv15fmtfv5JXVZV/1B9/tmtvTKGap1X7QtUMVb3equYkyd1/1KtZ6s1+RjV+mVjpb/tWnWRj23229UY/9ez/T7oZtGXry/NvnXcivnqTtGuxszBDqv9jaF/ne1gt/yOnv3r/bafJGs7/X50YaFf1hc33tBN3x2xAGrH/bbVDvvlMCz293B2F/rrpyTZL9pNtdas9hWq/meMvcN+HtV8dXFE/1K9pdrLWpr0+9HiVidJLq/261y1Fq3WJtXaoso/SRZaP4+qvuwVHe32bh1DtTaoml41Zm6O2EuvyrKqs0tL/YLaH9Funi3mSNUeztPFnHvMOq8aD4Zi3j9dudhN39ru36vFSfL+F/r95LSolNV+XHUvn7pZz+P+7+f684cnb/SvYX253zc8OWIu+Xyxn149e6nmcVW7SupnSJVq3v6bC/U67zefnSmEPHO9X9ZjxryqrKr9tmrdX+9L1veqaheHRV++WKx3d4v8k2RpxJp5FmPu1W5xnVU/WY0VY/b8Hl7vzy8mxf2+ttqPcf+o3oeu8tg57MdYXeeYvfTqPeX8oxjaq3Ks1pFJPd5sLPfLurqGMWuw6hl1dS+qPeYxS/aqXVTlVK3Jx7SbreIZT7UXXu19bhTj8hjV3sXatJ9eVYfni79HGGN3xn2BhVbHUI15VZ1ePIVn1FUMVZ09HvrpY/aAq2fIe0Xbq+rkSrFmT5KFzPYMqPq7izF9/ZXi2Wg1ds/6bHbMs/zJtdm+o3rmWO1tJEk186/2V6u/FarGIzhL6iMAr4ZfwIHT8dgJr73uzKMAAAAAAADg1FSHbwAAAAAAuH84gAOn46T/rMbs/1lqAAAAAAAAAAAAAABg7hzAgdPx6AmvPXHWQQAAAAAAAAAAAAAAAKfPARyYUWvtcpKPPSHpfWcdCwAAAAAAAAAAAAAAcPocwIHZfV6S6Qmv/89nHQgAAAAAAAAAAAAAAHD6FucdANzLWmtrSb7qhKTrSX7yDON422nl9fff88HTygoAAAAAAAAAAAAAAF4THMCB2Xxtkjed8Pq3D8Owd4ZxvPMMvwsAAAAAAAAAAAAAAO4rC/MOAO5VrbVPTvKVJyQ9keQbzzgcAAAAAAAAAAAAAADgLnEAB16F1tobk3x/Tm5DXzIMw40zDgkAAAAAAAAAAAAAALhLHMCBV6i1diHJjyR56ITkvzsMww+fcUgAAAAAAAAAAAAAAMBdtDjvAOBe0lqbJvkHSf7ICcnvSvLlZxvR/+cTTzGvd55iXgAAAAAAAAAAAAAAcM9zAAdGaq0tJPmeJP/GCcnvS/Jnh2HYO9uobhmG4RdPK6/v/9XHTysrAAAAAAAAAAAAgHNn0tq8QwDgHrQw7wDgXtBaa0m+M8mfPyH5sSR/chiGJ882KgAAAAAAAAAAAAAA4Cw4gAPj/O0kf/GE138vyacMw/C7ZxsOAAAAAAAAAAAAAABwVhzAgUJr7b9M8sUnJD2dW4dv3nfGIQEAAAAAAAAAAAAAAGfIARzoaK19S5K3n5D0bG4dvvnNMw4JAAAAAAAAAAAAAAA4Y4vzDgDOq9baNyX5ihOSXkjyrw/D8GtnHNKZWF/qdwsbq9Nu+tHx0M9/pe52lib9s4FVjMdDP4blxfrs4fbqUfmenkevrM70+STZPTzupl8symFtOpkpfUw5be0fdtPfeGl5pvSFVoaQy8v969g76teHosrmwlJdDjf2+vfioQv9drM06V/o1v5KGcOVom3uFfXpymr/GlZH1IfNvX67WVnsX+fuYf9mFE27LMckqS6jahfVdxxVQaZu29OFfpDbB7P1T0kyKa6zivFgsf/5xaIfT5KFoqymRR4LRYxJfS+q8aIa06rPV+W4vjTJCzsH3fdUbXdWu0VdSJLDosrtt+JeFp35wXF9jQdHs5VDdS8PimtIkhFdTNfxmEGtULWL8vNFDFX6Lf0Yjob+3GBlxHjSz7++V1U5TVq/Ui8U5TBpdTmtLtVtq6eqs5NTqE+z5jHmXswaw3FRDivFeJTU96uqk1WM49pN30JRZ2dtN2PmSPtH/fesF3W6WueNqW/VPOzSSn++W43LY8aSi8v969ib9POo1lBV207qstov5gbV55dG1KdqrTlrH1X1swsjupdq36CKsZqDVeljvOvxzW56tYar9j5uvaffbjaLfrJqd48Ua/YkecPFpW76g7nRTT9cvdxN/8CN/TKG/WLdv9n69eXK2pVu+lB8/uJf+PLs/+P/pvueLPbLKTvXu8m7xTW2EfOTagOk7d3sf37z6W7y2mJdX1ZWLnXTj6b9/Y/JwXY3fWeh3j+p6ks15V4v9okORvT1VR91fb/f119PsRdWLeKSrE/71zEt5g/VuFvNkcb0cVUee8XYXn3+oQtFu0xyUNSXymns4VQhVHt21bh8pagLSXKlmIdV49G1tf7nN4r93SRZPSz6qOP+WnSy+WQ3/doDf6Cfvrqex2/05wdVV1zt8VRrrGe36/lJVdbVnLpae1wq5stJsj7iPT1n8YypKuur6/3+4epq3X9Uz052iv7hNNZY1dqh6ou39vrXsLnXr5PV9495z6x7F2NimHV9s1G0uzGq/uG5m/058Qde3Ommj9mnev8LxX58UQ5/8NqFbvqvPNGf7ybJ69f788mni3Ko6uwYZ7En1/PE9d3yPVUM1TXc7XY3Jo9qb2J1xHOLqh+txqzdGZ85JPW+YzUfreZ5W/v1XHLW/YvHrxfrguIaqrlFklzf7ce4ddS/zuoZ0pj92WqdVtWnypjPl8/KijpZ7eHMeg1JXU7vL8ab4xfq9VPVvqu15kMXqrFir4yhKutra/Vcr2ejmMd98Hod46zPHapyfuRSvX/yVDHuVjFWdfY01ssAAPPkF3DgBK21dyT5D09I2kzyp4ZheM8Zh8R9pvqjbQDufafxh50AAMB8lYdvALjnVYdvAAAAAAC4fziAA7dprX1dkq8+Iel6bh2+edcZhwQAAAAAAAAAAAAAAMyRAzjwMq21r0nyNSck3UjyqcMw/NIZhwQAAAAAAAAAAAAAAMyZAzjwktbaVyf5uhOStpJ82jAMv3jGIQEAAAAAAAAAAAAAAOeAAziQpLX2V5O844Sk7SR/ZhiGXzjjkAAAAAAAAAAAAAAAgHNicd4BwLy11r48yX9xQtJ2kk8fhuHnzjgkAAAAAAAAAAAAAO6SSZt3BADci/wCDve11tqXJPm2E5J2knzGMAw/fcYhAQAAAAAAAAAAAAAA54wDONy3WmtfmORvnZC0m+Qzh2H4yTMOCQAAAAAAAAAAAAAAOIcW5x0AzENr7XOTfEeSk35E8BuS3GitfcIpfNW7h2HYO4V8AAAAAAAAAAAAAACAOXEAh7lorT2a5Hde5cd/urWTzs38cz50GIb3d9I/LXf+BaivfenfafjQJL04AAAAAAAAAAAAAACAc+5OBxAAAAAAAAAAAAAAAACAOIADAAAAAAAAAMD/w96dh2u21fWB/64z1HTr3uIO3AtcZgIiQQkoiWAUBwzBKcYxcQYTzWhrP90mMTEkRs3UajrGp+0IGHEg2GgrojZGg4kKSBSUBonM84XLHWuuOsPqP6pMY/HW+u2q9z3nPXXP5/M89Sj79+61f3vttddee++z7gYAAABgyAQcAAAAAAAAAAAAAAAAGFhbdgLsW3ckecYOl39ZvfdvTPKNO7h9AAAAAAAAAAAAAADgAcIEHJai934uyeuWnQcAAAAAAAAAAAAAAEBlZdkJAAAAAAAAAAAAAAAAwF5mAg4AAAAAAAAAAAAAAAAMrC07AWBvue26A8P4vWc2hvEzG1vD+Mmzm2UOB9bGcwPvL3K4/djhYXxjq5c53HhofRg/sr46mIfPIQAAIABJREFUjP/hnSeH8bNb28P4rdcdHMaT5PTGuIwj6+N6PH52XP76SitzOLQ63sZqG5dx8vy4vRwq2kJS18PG9vh4V/t5fkJ7OV21+/Pj9lJUU+4p2nySnN0c18NqsZ/rq+P4ZlGPSXL83Pj8Pr9VnNtF/7BSVFS1D0myvjLO4eT5cQ7Vub/V63o6Vxyr071o00X/McV2kWd13pzbHLf5heQw535W+5AkK63Yz4xz2Kr6l6KPXISjB8Ztsupnp6j6qKrZV+fFlEM9oSvecfPmULWXRaj6yepaMGUfq3OzuvZXw4tyH6oGmfravlacm4fKLdSq603GQ+6yvZxZwLldjbkr5T4mOVDU9ZTr5jCHCdf+g8V+Vtf2qp6qNjtFNeY9MGE/Rw5OWL/qH+bdzyntpTpWVT1V5001Zk/qe8Uyx+r+aMI9VvWbqk1W592UY1n1o/Nuo24P9eBgu/jJ+R1u01NUY8GDa+P+pxovJ3UfVvWT8x+rur208+OHDysHx+fmlGcTa9W1v8px40yxgfEzmoOf9/U5/jM/PP7NiXvH2yhU+zBF2zo/jPezp4bx7VMnxhvYnjA+Ke53q1OzlevX9dSK+8Cd7x1q8x7uKV3cvOPuav26n637uHJ8sr3zff2Ua/dI1Q9PeW5Q9YNVEeX90YR9rPajGm5W15NJfVzRh7Wt8TO9qg+s9uGRN6znQyerZ5fjMsp7j6q9THleP+eYusqxGr8kycHqnrtqtPUmStW5Vd2LVm22ui9Iko3t+cbMqyvj62o1Jk+SM0UZ1bld3XuUY8UJf4Uwbz+7iPLPz/lupWzTh+qKqNpU9W6lMmlcP+ez7Gobk57pFTmU96plH1h3MNV92PkFvJ8ZmfIMuXzGW5Sx0+fdlG0sIodqP6t3RNX6izgW1SPcahunxsOXSWWUz4CL52XV9eb+4t1wUv/9SOVwMT45N+G8LN/NFjlWf58yRdVebij+PmVj+9wwfv2B+nrz0fvHzz+q9lQdi2osmSS3HBnv551Fw3/7PeNnF3edrk+c6pp01+nx8a7G1I84Nn7LVP0dT5LcfXq+dycrxXmxUT1cTX1NnPe1525cj2CqKWNVALiUL+AAAAAAAMBVqCbfAHDtqybfAAAAAACwf5iAAwAAAAAAAAAAAAAAAAMm4AAAAAAAAAAAAAAAAMCACTgAAAAAAAAAAAAAAAAwYAIOAAAAAAAAAAAAAAAADJiAAwAAAAAAAAAAAAAAAAMm4AAAAAAAAAAAAAAAAMCACTgAAAAAAAAAAAAAAAAwYAIOAAAAAAAAAAAAAAAADJiAAwAAAAAAAAAAAAAAAAMm4AAAAAAAAAAAAAAAAMDA2rITAAAAAAAAAAAAAADYLatt2RkAcC3yBRwAAAAAAAAAAAAAAAAYMAEHAAAAAAAAAAAAAAAABkzAAQAAAAAAAAAAAAAAgAETcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAYWFt2AsDe8u77zsy1/oMOrw/jj3rQ4bKMldaG8TMbW8P42a3tYXx9pZ57eFOxH594y3g/jh0ad693njo/jD/mxrqeeh/HD66N6/GWIweG8aMH6np6+93j9vLg68bbuO/sxjBeHMokyYHV8X7WZYwr8nTR3pLk7OZ4IyfOb5ZljFRtforVlXE9nd4YH+/qvEyS7aJRTjmeI6tFk5xybq8X7aWKV06er4/VxnZVT8XJXVivKir1sVppxXlRtKeDa3UOm0WDqNrcoQnbqBxZXx3Gq3qq1j+yPs5xa3v+oXiVQ9Um14tjOUXVPawWP5hy3lV5VqdN1QdOOfWn9INFCcNo1TdMyaHaz5Xtna+HMsdyH+bb/oUy5tvP7aoep+TQxufedlVGUQ8HFtAHHphwvRjZjfayUhyLKdf+eXOotlGedxPaS3XtnnN4MimHqiar/aza05S+vj5WZQFzlZ/UdV31YVWbnXLe1XnON4aadO6W59589VDlML5LvJhDUZcHiutq1Sa35xyTJ/Mfi6q9TflN3cfNP04rf7I9via27fH98mobj3eTevwwt+K+YHujvufvm1Na9uVV/fAkRV33c2fH8c3xs6yVovykPt6taC/VPkzp46p2v1nE18o+bkpHOw5Xz/yqe9Up93lVmtX5X92T1/1HnWO1jWo363FcmUI2tuZ8RlPkMOXZRnU8y3us6nozob2Ux3vO50RTjkU7e278gz4eI/WN8frVOO3Rxw7kQyfn68vLeljAs7CDq+Pr5vrKuB89uIBxfZXnwbX62j6vqq6r55KrxbPRKf1s2QcV26iquhpzT1Ed70PFsaqO9eqE1xpbOzyO29iuX0qUz5HKPm5cT1MuJZPGD6P1FzCun/f+pdrGlHcGVZusnoVXdT3t/c/4N+eL/mPe521bK3WDqfqXqt2fL95pTnlHNe95U8UX8V705Lni3mHOHCeVUZxX54tnPItQ5TjvO8n535vsH/Pe11fHako/W/VRVR9UbWNKDvPeW0x5l1aZ95pX/W3Iu+45Pd7+hLZQ/Y1K1b9UOb59c5zjlDLq56vj50wAANc6X8ABAAAAAAAAmGHeyTcAAAAAADxwmIADAAAAAAAAAAAAAAAAAybgAAAAAAAAAAAAAAAAwIAJOAAAAAAAAAAAAAAAADBgAg4AAAAAAAAAAAAAAAAMrC07AQAAAAAAAAAAAACA3bLa2rJTAOAaZAIOTNBaW0nyiUmemOT2JEeT9CQnk9yZ5J1J/qj3fmJpSQIAAAAAAAAAAAAAADvCBBz2jNbaY5N8yiX/bpzx08/uvf/GLuTTkjw7yfOSPCfJTcUq2621tyb5rSS/nOTXe++ndjZLAAAAAAAAAAAAAABgp5mAw1K01h6T5FNTT7ZZitbas5J8fy7kNdVKkj998d+3JPmnSf7JwpMDAAAAAAAAAAAAAAB2lQk4LMsbkxxbdhKXaq2tJflXSb4tSVtyOgAAAAAAAAAAAAAAwB5gAg5c1Fq7LsnLk/zFwc9OJflwko8kOZ8LX+25PcktO54gAAAAAAAAAAAAAACwFCbgQP7Hl28uN/nmVJIfTfLzSX6r9741Y/2HJ/lzSb4wyRckefDOZQsAAAAAAAAAAAAAAOwmE3DYS96X5PeS/O7F/3vXxf9/N/xAZk++eXmSb++9f2C08sX4B5L8bGvtQJIvS7Kx8CwBAAAAAAAAAAAAAIBdZwIOy/K+JO/IhYk2v5fkd3vvd33sD1prj96NRFprn5/k784I/Zve+7dfaXm99/NJXjp3YgAAAAAAAAAAAAAAwJ5gAg5L0Xv/5GXnkCSttUNJ/t2M0EuuZvINAAAAAAAAAAAAAADwwLOy7ARgyf5mksdcsuyjSUy+AQAAAAAAAAAAAAAAkpiAwz7WWlvL7Ik2/7j3fs9u5wMAAAAAAAAAAAAAAOxNa8tOAJbouUkeccmys0l+egm57BnnNrfnWn99ZTyv7/RGXf7BtXEZW328/pH11WF8oypgQg7nizLuPHV+GF9facP4Pac3hvGk3s/Da1UXP96He89slTncdHh9GP/wyXPDeHUszq7W7eXGw+N6OLI+PpY3Hhqv/857z5Y5rK+Oj+fJ8+O6fPxNh4fxKW12dc4ptdU27j+7WZZxqDhvzm2N6+H0xjh+49q4vd15atzekmRje7yf1Xn1sOvHORwq2luSnCraQ2W1jdvb2Qn9eFXXG21cT4eKBvfwGw6WOZw4N87h2KFxH7bdxzmuFOUnyfUHx8d7q6jK6tyv2tMU1X4ePTCupxNFe5uSY9W/HCjqYXPO8y5J1oskNoqDdbBYfxHHquoD7zkzvrZX6yf1+KEIl9fEKdebStEcStVY8sBavYFqP09vjOMHi21U7e1CDuM2VfXD6xnnUF0LpqjGu9U2Dk84b6omVfVxVY4rE+qhOreqPqxafxH9R9VHrVUnd2Gl19fEtTmvadWxqsYOyfx1XbWns5v1sdoszu+1Yj+qfrqqp6Q+99b7fP1DlWNSt8mNtXFdVteCqv9YmbPNJ8lW0R6qNlmNh5O6D6qO95T2UKnKqM6b6lhV1+Wk7qPa1vj5SNsaj5EOrNaPr8t2X+xo2yju+/u4b9g8O97HJOnn6mcLIytFPU3RNsd5bp8f51juQ3GskyRFDm31QLGN8bOJCUPFbBa/Wa3G3MWxWJ1w3mS7SKIIF11cevHML5lwzVotrv2rxXi2qIfquj0lh3nv2aeNqed8Vl7kMOW6XO/HeP2qn55yD1cdi2osWecwIYmiL25FPNvjNrtSnDcPP7qWD50a90HVXlT7WVXDlPufathdPV8p15/QZqs8qza9CHWe1TuocXuq6jFJVtu4zVXtoXhskO3ieVtSH4spffE85U8a10/Yj7lMuS4XfX11rMox9YQ2X7XZanxS3wdOabPlT8brFzlOabPzWkT3Uh7v8vnszvdx1X5uz7kPVXxSGUUO1T37lOeO81rEsZr3mlblsIg2ffTg+J66+tuQ6lhM+duSKe8+Rm4o9uG2o8V9ZOp3kueqd0wLeIZT9cVHD4zr+vi58Vj09usPlTlUx6s6N285Mq7rY8WxSpLbrx+/Q67Oi+rvcG46NH6Xn9RjlCqHM8VArTqWU8aSJ4vjXb1jOlg8v61yvGCcw63XjdvDvcV70ervNmA37cJtKgAPQL6Aw372V2Ys+8Xe+/FdzwQAAAAAAIA9p5p8AwAAAADA/mECDvtSa60lec6M0K/udi4AAAAAAAAAAAAAAMDeVn//ER6YPinJzTOWv+lyK7TWHp7kllz4FvlHk9zVex9/MxMAAAAAAAAAAAAAALjmmYDDfvW0Gcu2k7z5j/9Ha20lyV9K8nVJPjfJDZeu0Fp7c5JfS/KK3vurdyZVAAAAAAAAAAAAAABgmVaWnQAsyZ+esezO3vvpJGmt/fkkf5Dk55L85cyYfHPRk5N8W5L/3Fr7rdbas3YiWQAAAAAAAAAAAAAAYHl8AYf96pEzlp1Iktba303yg0lWr7DMT0/y6tbad/Xev3fO/K5Ia+0ZiyrrJb/3/kUVBQAAAAAAAAAAAAAADwgm4LBfPXTGshOttb+V5N/OUW5L8j2ttcf23r9pjnKu1Gt2cVsAAAAAAAAAAAAAALCvrCw7AViSG2cse3iS//2SZaeT/FCSZye5PcnBJLcmeUaSf5bkzsuU//yLX9IBAAAAAAAAAAAAAACucSbgsF8dnLHs1vzJr0L91yRP7L1/a+/913vvH+q9n++9f7T3/rre+z9O8oQkP3GZbXx/a+3JC84bAAAAAAAAAAAAAADYZSbgsF+tFfFXJ3lO7/39ox/13u9P8g1JfnRGeD3Jd15degAAAAAAAAAAAAAAwF5RTUKAB6qNQezeJF/Xez87paDee2+tfWuST0/ypEvCX9la+4e993dfZZ5TPXOBZb1mgWUBAAAAAAAAAAAA7CmrrS07BQCuQSbgsF+dH8R+uPf+wSsprPd+trX2T5O87JLQapIvSvJvrzC/K9J7f+2iyvqJN3xgUUUBAAAAAAAAAAAAAMADwsqyE4AluW8Qe+FVlvlzSe6asfxZV1keAAAAAAAAAAAAAACwB5iAw341a6JMkry39/7eqymw976ZZNaXaD7tasoDAAAAAAAAAAAAAAD2BhNw2K8+eJnlvz9nubPWf/CcZQIAAAAAAAAAAAAAAEtkAg771bsus/yeOcu9e8ay9dbaDXOWCwAAAAAAAAAAAAAALMnashOAJXnrZZafnrPcU5dZfjTJ8TnL3hWnN7aG8dW28zls9z6Mb2xtj+Pb4yS3t8flJ8ldpzeG8UfccHAYP7s5zvFksQ/3ntnIysp4P248tD6MV1bauPyjB+s5msWhysG1cRn3nhnX8x0nz5U53HLkwDB+58Z4GzcfHB/LI+t1PWxsjSvi3Ob4vDpQnFj3n9ssc6jOzepYrBbtoeobkmS9SKI6L06cH2/jkccOD+NTctwotrFV9A+bRfxcsY9TVPtxqDiWU+rh3rPj86Iqo+pH//DOk2UOlQ+fHO/nzcW5f7zYxyS59+y4zVbn9i1Hxv3wHSfqPmx9dbyfVf/x+JuPDOPvue/MMH7nqTrH228Y1/W5zXE9FbuY26+vr2cfPH52GD9etdnignWuuC5PcfTA6jBenlfVRTXJsYPz3b5tFOfukfXxPkyxWoxfqm1U15Kt7Z4DRaNaX6ni421U5+UU5Xi2OBbVOC1F35CkHEtW1/4qhyn1tN3HY5jqWFTX1cMT2my1H2tFDtUY6uCEetjYHu9H1e7r3mGsbdXXxNU27uur/SzbU1HPSX2sqm1UptzLVnlWbbZS9U/Typgvh6pNJ/X5vb46btPz9h/rqytzP5uo2staee7WY4N520vVHqaMDar9rHKorttTLolVGW27uJ8t4pNymLM9VA832ub5YfzWr/7m3PHifzfeRlFGVopr2nZ97S9VZWyOrxe9iLet+tlF1R56H597ZXsq1k+S1eLcW23FuVdsY2XCf/Osz/l8dTvFeTf36GF+1bm7mpbqNqwso4hX/ey0Yf981+76mriAMdLcff38D/yrWqo2MWWc1raKfrTQz1zu1c3F8ov+5fbDyYfGj1jKY1WPd8flTzlW5b3kDq+f1HlOeT8zr+2V8Taqcda88SmKx44LsYg8R8o2u7pSPv+oOpB57wPLi02SlGOD8epHq+d1E97vVGVU90fVPdaNh+vnr/Pea95+dLyNKTk86kGHhvGqf7m/eCewiGef1bOoahvVO+4pz6mrZzRVGYt4jzXv9aLqn6aUP28fN2+bT+pnC1X/UR2LRTxPq95j3X923EfddnT8zDBJ7jkzLqPsw4r9rN4P335D3b/cf26cw8lz9d9uzKt6JlfV9fHievLIY+O/eUiSd907/nOoapxWtaeHTGgvt5/74DC+ev3tw3h13pyccN2tVOfuVtH/VNflKX1c9XcTlUW8F62uWdXfsJwt1t+N+wIAgJ3kCzjsV797meXzfqnm2GWWz/tlHfaZKQ/UALi2LeKP/GG/qSbfwF5TTb4BPt6UCeWwl5STb4CPs4D/BgLsqmryDfDxysk3AFzzqsk3AAAAD1T+eol9qff+0SRvnxG6dc6iZ61/qvc+/s+2AwAAAAAAAAAAAAAAe5YJOOxnr5qx7FPmLPPpM5a9Z84yAQAAAAAAAAAAAACAJTIBh/3s5TOW3dJae9rVFNZauyHJn5sRevXVlAcAAAAAAAAAAAAAAOwNJuCwn/3XJO+csfxvXWV5z0tyZMbyX7/K8gAAAAAAAAAAAAAAgD1gbdkJwLL03ntr7QeS/PAloW9orf1I7/13p5bVWntIkn80I/SBJL8yR5oAAAAAAAAAAAAALNBKa8tOAYBrkC/gsN+9KB//FZy1JC9rrT1ySgGtteuT/EySW2aE/0Xv/dx8KQIAAAAAAAAAAAAAAMtkAg772sXJMX8zSb8k9Ngkv91ae+5o/dba05L8RpLPmBH+/SQvXECaAAAAAAAAAAAAAADAEq0tOwH2p9bao5O8+ypXf3WrP/33mN77e6YU1nv/T62170vyDy8JPTzJL7fWXp/kF5L8YZK7kxzLhQk6X5Dk2Zk9ke2uJF/i6zcAAAAAAAAAAAAAAHDtMwEHLviuJLcm+eszYn/24r+p7kzyl3rv711EYgAAAAAAAAAAAAAAwHLN+nIH7Du9957kW5L8/SSbcxT1xiRP772/biGJAQAAAAAAAAAAAAAAS2cCDlzUL/iXSZ6a5JeS9CtY/Z1JnpcLk2/etxP5AQAAAAAAAAAAAAAAy7G27ATYt+5I8owdLv+q9N7fnOQLW2uPS/IlSZ6V5BOTPCTJ4STHk9yV5INJfjPJf0ry2t77PF/OAQAAAAAAAAAAAAAA9igTcFiK3vu5JK9bdh4jvfd3Jvn+i/8AAAAAAAAAAAAAAIB9amXZCQAAAAAAAAAAAAAAAMBeZgIOAAAAAAAAAAAAAAAADJiAAwAAAAAAAAAAAAAAAANry04A2FvWV9uyU8hKG+ewsjKOr6+M5xZut17mUFXDejF9cb3IcbtX+1Afh+pYVfGqnleLeJKk+Ml2UdXz5pgka3O2h7Z5bq71L9geRlc2xznW+zD/eTltPwbrT+gbqm2stnE9VZtYLXZhSpvdKhrl/Zubw/jJ8+P4uc3xPibJk2+7fpzD2fE2tnu9jXkdWV8d51Cd3Atw9OB4mHrbdQeG8Y2tup4OrY0b1Uaxn488dngYP1G0l6qek7rNPeLgxjD+hmIfbzkyrsckufv0OId333dmGN/uO99etopNnDy/VZVQbuNgUZdni/N/Sv9Q+eDxs8N4VQ+VKcPAebdR9XGLUO3HvPuwCNUYp77u1v3HTqv6p6Q+bzaKg1HVU9WPJ8mnPPToMF5VddVX33t23A9PGc9ef2B8zfvvd43P/aqe24QcVlKMcYrrajVeXcR4dqu4nlTXm9MbdV9fWS8GpFUOi7jdru6Hq3FaNb5Jkq2irqpzd7W45z5XjfsXcD2q2lx57zGhf6lUfVTVv2xs12OHg2vz9ZNVH3VgwsE4WNzn5cTd4xxWx+PRg8eO1TkUh6ttjvvRrBbX1WIfHvpVX5N7XvULw99s3V/Uw+HrxvFiH9rm+WE8SVbO3D+Mn7/3zmF868R9w/j6wx9X5zDns4mVcyeG8X7gSFnGgfXxfdz22vi63M6Mczh85OYyh6ofrVRrr7S6ng8W53fVf1Txg8V5tb1S10H1nOlgcepWY+opjz6rRwv1s6pxvKqnJDm3Nb4u33NmHD9SPMg+P6E9VvtZjTerbWxOec5Utesi3reLseDWeFz/sAPJXVsHx0VUY8FiF97y0dPD+JRnXZVqjPSue8Y5HJ7wLOv+4h6pGo9OuYeqnN6Y7zl0VU8nz9X3w9W4fas4Lw6ujet6yph5rWh01el/y5H1Ybx61lXdqybzH+/y+e6E86Zqk9U9VvVMcEo9VGXccGh8LCpT6uH42XE/WbWXX3v3eKw4pc2+4UPHh/GqHqr2NOVY3H7DuK+/+/S4j7vp8DjH6pp456l6XH+seHdyf9FH3XV6vI0pY9UpdTlSPT+Z0jdUZVTnbvUOqnqfmEx4lzbnu5Eptw3VNat67lj15VX3MeWZX/m8rHq/POffZST1O+RF/M1CncM4Xt3/zPusK9n5v8OZ8q6+nR+/U1y7blxGdc2s9iGp+4eTxTaq/az6jyPVzWzm/7utRTyvr56F19soxmnF39jAbmp74G8lAbj2+AIOAAAAAABchWryDQDXvmryDQAAAAAA+4cv4AAAAAAAAAAAAAAAADO11p6U5MlJHpbkaJKzST6a5K1J3th7H386FB4gTMABAAAAAAAAAAAAAAD+h9baI5J8a5KvzoWJN5dzorX2iiT/tvf++l1J7jJaa/8hyTfswqae13v/D1N+2Fp7T5JHLXj7P957/8YFl8kEK8tOAAAAAAAAAAAAAAAAWL7W2kpr7TuT/FGS/yXjyTdJcn2Sr0nyO621l7TWju10jrAsJuAAAAAAAAAAAAAAAMA+11o7nOQVSb43yeGrKOLrkvy31tpjFprY3vP2ZSfAcpiAAwAAAAAAAAAAAAAA+1hrbTXJzyb5gsv8ZCPJHyT59SSvT3LyMr97fJL/3Fp76MKT3Bv+qPf+28tOguVYW3YCAAAAAAAAAAAAAADAUn13kufOWH5fkn+a5Md67/f/8cLW2nqSL07yfUmecMk6j07y0tba5/bet3Ym3Zn+WZIfWVBZfyEX9vtSL15A2V+a5I451v/oAnLgKpiAAwAAAAAAAAAAAAAA+1Rr7SlJ/t6M0LuTPLv3/q5LA733jSQ/21r7f3LhyznPueQnz0ryN5L88ILTvaze+zuTvHMRZbXWvnPG4s0kL1lA8W/svb9nAeWwy1aWnQAAAAAAAAAAAAAAALA0359k9ZJlp5J8/qzJNx+r934qF77o8pYZ4e9urR1dTIq7p7X2kMz+GtAv994/vNv5sHeYgAMAAAAAAAAAAAAAAPtQa+1Tk3zujNA/673/9yll9N5PJ/nrM0I3JfnmOdJblm9IsjZj+Yt3OxH2FhNwAAAAAAAAAAAAAABgf5o1QebuJD90JYX03l+b5FUzQrMm5ux1z5ux7CNJfmm3E2FvmTUrCwAAAAAAAAAAAADgAWlltS07BdgTWmtrSb58RuinLn7V5kr9aJLnXLLsia21p/Xe33AV5e261tqnJ/mEGaEf771v7nY+7C2+gAMAAAAAAAAAAAAAAPvPpyW5ccbyn73K8n4pyZkZy597leUtw/Mvs/zFu5oFe5IJOAAAAAAAAAAAAAAAsP989oxlp5O89moK672fTfKaGaHPuZrydltr7WiSr5wR+u3e+x/tdj7sPSbgAAAAAAAAAAAAAADA/vP0Gcve2HvfmKPM189Y9rQ5yttNX5nk6IzlL9rtRNib1padAAAAAAAAAAAAAAAAsOs+ecayN89Z5ptmLHtQa+1Rvff3zln2Tnv+jGUnk/zMTmystXYgyYOT3JJkO8k9Se7pvZ/Zie0xPxNwAAAAAAAAAAAAAABgH7k4+eMRM0LvmLPod15m+WOT7NkJOK21JyT59Bmhl/XeTy14cy9orf3pJE/NjDkdrbUPJ/ntJL+V5Gd77+9f8Pa5SibgAH/CodWVZadQWp0zx43tvqBMlusBshtz6/PWQ6vak4q+Vqy0tuwUrhlVXW3PfWKRPHDqcesa2I/11er83/n+oTreVY5T+rD1lfFvqjHOItrk3h8p1nW5cg206YPleHd7V/LYadV5sV206eqcSJLDa+PfrBVlVMeiOu9uOlw/drn5yPg3R9bHOVT1cHitPnOr/uFBh1aH8SrHmw6vlzk85LpxPVx36iPDeNs6P4y//6EPK3M4tzWuh0fecKAsY+Std50tf3OgaLPV8d4quofD6/V5U/3iI6fGX5q/7sC4vRw7OI5P6aaPn98axu85Pc7xkccODuMnztf9bNV/VPt57OD4vKmra1niAAAgAElEQVTaY5LccHp8XvTrbxnGq3HegQn9bOtFXW2Pj1Wq9RehzHHvX1fb5riPK+s5dT/Zz4zfGW0cPz2MHzx1vMxh9cChYbxVz2hO3D0Mr6zW/XRfH/fFh47cOIyvnhrncODAkTKHg8WxKNtsUU99/XCZw+rxDw/jm9c9fJxCG9f10QPz3zlcV4wvzm6O+7BDxTV1yl3iZjHWWy36yRPnxufmw66vx0hnN8fXkxuLcdrR9/9uuY3Kwx76tGH8pvsv9x79gn7DY4fxG8+M22OSnPm1lw7jK+vjseS7X/naYfwTvm28/VuT9Md/2vA3W4dvGMeL9nTi4HgfzlUDvSQ3Hhq3qWqsec+Z8RjqtqN1P7tRjGE2ts8N40fWx216ipPnNofxgxPukUYmDNNyqNjGye1xjpW1Ce/Jqhyq5yfV47Zzm+M2uYhnXZVjxXlzorhvSJKtjfFvNoox88FiFw6u1W36dJFDpX7mV9fzSnWvOaXhj9afsHr1m2o/63idQ1WVVVdcxas+srpWJPV9XFVG9bxtinmfM1c5rJTP++sy5myyk/Zx3nqYN8dp25ivnuY975IJx6qMj8ufct5Uae7G+7yqruc+VleYz9LM+T5/Ecdqp8+9KscpbXZe1XV9fcJYcquPx6vz/m3Gqr/tANhrHpHZfw7ywTnLvdz6j56z3J026+s3SfKiHdjWNxbxhyT5sov//nVr7eVJ/lXv/Y07kAtXwAQcAAAAAAAAgBmqyTcAAAAA8LFaa89YVFm99/F/XWZ+D77M8vF/Ca52ufUvt72la62tJvn6GaG37sJxqKwl+StJvry19t1Jvrf33fgv3TGLCTgAAAAAAAAAAAAAADC/1yywrJ3+dNhNl1l+/zyF9t63Wmunklx3SejmecrdYZ+f5KEzlr94txMZWEvy3Uk+s7X2Rb33s8tOaD8yAQcAAAAAAAAAAAAAAPaXo5dZfnIBZc+agHPp/95Lnj9j2WaSn1jgNraT/Lckv5bkD5L8YZI7c2HC01qSG5M8Kskzk3xRks+8TDnPTvJTrbWv8CWc3WcCDgAAAAAAAAAAAAAA7C/rl1m+uYCyN2YsO7CAcheutXZrki+YEXpl7/0jC9jEm5L8YJKf7L3ffZnfnE9yOskHc+ErSv9ba+2pSX44yTNm/P5Lk/yjXPgiDrvIBBwAAAAAAAAAAAAAYN9oqyvLTgH2gtXLLN9aQNmzytircxe+PrMnI71oEYX33r/4Ktd7Y2vtM5L8QJJvnfGT72it/Wjv/Y65EuSK7NVGDAAAAAAAAAAAAAAA15JnLjuBK3C5L90sYo7BrDJmfRVnL3jejGV3JPmV3U7kUr33rdbatyW5KcnXXhK+Lhe+gvO3dz2xfcwEHAAAAAAAAAAAAAAAmFPv/bXLzuEKnLvM8gMLKHtWGZfb3tK01j4tyZNmhH68976ILwHNrffeW2t/N8lzk9x8SfhLW2t/p/fel5DavmQCDntGa+1wLnRgj8+FWXrHcmGm470X//1hkj/azQ6itfbgJE9N8qcu5pMk9yd5R5I39t4/ulu5AAAAAAAAAAAAAAAsyInLLL9+AWXPKuP4AspdtOdfZvmLdzWLQu/9vtbav0vygktCD8mFv3V/w+5ntT+ZgMPStNZuTfLZST4nybNyYeLNSrHava2130zywiS/1Hvf3oG8DiT5miTfkuTPJmmX+Wlvrf1Okn+f5Cd773v1s2gAAAAAAAAAAAAAAB/r7sssf9A8hbbWDiU5eAXbW4rW2pEkXzUj9Ju997fvdj4TvDIfPwEnSZ4eE3B2jQk47KrW2m1JvizJVyT5zNQTbi51Y5IvvvjvPa21b+29/+IC8/v0JC9K8glTfp7k0y7++47W2jf13l+zqFwAAAAAAAAAAAAAAHbIhy+z/CFzlnu59S+3vWX5iiQ3zFj+ot1OZKI3Jun5+I9L3LaEXPatK538APP63iQ/nOSzMn/7e3SSV7TWfqy1NmuW5BVprT0/yaszbfLNpZ6Y5Ddaa8+bNw8AAAAAAAAAAAAAgB32oSTnZix/5JzlXm79d89Z7qI9f8ay40n+r91OZIre+1Zmf0Xo1t3OZT/zBRz2onuT3HnxX5I8OMkTcvkJO9+Y5ObW2pf13jeuZoOtta9N8sJ8/IzAP/beJO+5GH9MkkfM+M16khe11s713n/6avIAAAAAAAAAAAAAANhpvffeWntnkiddEnrCnEU//jLL3zFnuQvTWntcks+YEXpZ7/30buczpwPLTmA/8QUc9oKTSV6S5HlJHtd7v6n3/sTe+2de/PeJSW5M8tW58OmsWb4oF76sc8Vaa5+U5N9n9uSbn0rypN77o3vvn9V7f1bv/ZFJnpzkpbOKS/LCi2UCAAAAAAAAAAAAAOxVs/42+ylzlvnUGcs+0Hu/a85yF+n5mf234y/a7USmaq2tJrl5Ruj4bueyn5mAwzK9Nhcm3Tyk9/4Nvff/0Ht/16wf9t6P995fmuRTk7zgMuX9tdbaM68kgdbaSi50lIcvCW0n+Wu996/tvb91Rj5v6b1/dZJvTtIvCR/OhUk4l/uaDgAAAAAAAAAAAADAsv3OjGVPaq0dm6PMZ0zczlJcnMjyDTNCb+m975k8Z3hqZk8aet9uJ7KfmYDDMvx2ks/rvT/z4qSbU1NX7L1v996/O8nfnxFuSb73CnP56iRPn7H8n/TeyxmMvfcfTfJPZoT+bJK/eoW5AAAAAAAAAAAAAADsll+bsWw1ybOvprDW2q2Z/QWcWdtZluckuX3G8hfvdiJX6Isus3zWV4zYISbgsNte0Hv/8733uTrR3vu/zIUv6FzqMy923FP9vRnL3pzk+66gjO9L8pYZy2dNEgIAAAAAAAAAAAAAWLre+1uTvHNG6KuussivzMd/paUneeVVlrcTnj9j2UaSn9jtRKZqrT0oyd+ZETqR5PW7nM6+trbsBNhfeu8fXGBx/zrJz12ybCUXZiWWHWBr7ZlJnjwj9D29962pSfTeN1tr35PkpZeEPqm19mm999dNLQsAAAAAAAAAAACAndVWL50fAPvaTyZ5wSXLvqS19oje+/unFtJaa0n+9ozQb/TePzBPgovSWrsls78k84u994/udj5TXKzXH0py04zwy3vv53Y5pX2t9d6XnQNcldba0STH8/GzJL+r9/49E9b/oXz8TMC7kzy0975xhbmsJ/lwPr5j+6He+7deSVnL9jNv+pBOYQ+4/sBq+ZvTG5Pnic20vjr+CNqxg/UczXvOjE+V1ZXxTcqNh9aH8TtP1WOCg2vjujq3ubP1lCRb2+PTZnsXrrVHD4yP18acOW5sbV9xTlfqyPr4WK60cXt6xLFD5TY+eur8MH7i/Li9rBdt+v5zm2UOn/HIY8P4B46Pc1wvbv6nHKoPnjhblDFfe9ma0OSr431kfXzuPeZB4+P9trvPlDkcOzQ+b6p+9pNuvW4Yv+fsuD0cXqv7l9Mb4wP6qP82nnP89qd97TB+/YE6h82iTb31rlPD+NmqAJJMu/ZXqjY75dysVM8fq23sxvPL6nqxG9fleVV95LzjwP1k3jHvXafH1+UHiqqebr3uwDB+ZzHGqs7LJLmt2MYdJ8f3BosYr1b3Fg+/4eAwXp2bd5zY+WeeVV1X/UuSnCvqshorVu3p8TcfHq9fjLmT5M5T43vRqq8/cW58rKock2S1qOv33Dcecz/i2Lg9TWnS7z8+3kZxqMp7+imqfvQTH3xkGK/q8e4z9T3WyfPj33zk5LiPetpDrx/GH378bcP45nvfOownydl3jn9z+ImfPIy//bF/cRh/+A3j5ytJck9Rl2/56OlhfN7nK7thyvWm6ger9rQIU/IcqfrZ3XiGU6meQx2acD9c1dNeaJM3Hh6fe1Uft4ix5iLu80huOVL3o3ednv+6OY8p99OPPDYew1R94H+/6+Qw/oRbxs/CkuT85rhRVu1+yjPeypvvHO/HvKp7l6R+Tjzv87Ip72+qcf3B4npy/cFxe6nuEz94vL7/qfr66j7wpqIffujR8Zg7Sd7y0fnayxOL8+Lmw/Wxete943F99a6suhZM6eOq+/pKdR835V60Gj9UZVT9y19+3NEyh5Uz9w/jdx+4eRivnvnfeWrcN7zxwyeG8b3igfA3qrccGfdhH5nznLiwjfG5t74ybi9VHzjFvM/z2V/mfXcy5V533m1U193qvErqa/+18A6p8ugHje8LbpwwPvnDO8fvf6v37NWxmPL85blPvO0BcMXhWvCqJzzt2j/x2ZOe87Y3XHP9WGvtYUneneTSAfNLeu/fcAXlPD/Ji2aEvqz3fulHFy5XxnuSPOqSxe/tvT96ah5F+d+W5AdnhL6g9/7Li9jGx2zrs5K8Y57JR6211SQ/kGTW36NvJfmki18xYpfUI0/Yo3rvJ5PcOyP0kIlFPHfGsldc6eSbi7lsJHnFxG0AAAAAAABwDVj25BsAAAAA2Gm99w8lefGM0Ne31r5iShmttSfkwkSRS705yc/Pkd6iPX/Gsg8medUObOtLkryrtfaS1trntNbq2bAfo7X2Z5L818yefJMk/8bkm913RQcR9qBZbz3K/2xUa+0RSR43I/Trc+Ty60m+8ZJlf+pKP78GAAAAAAAAAAAAALCLvivJVya56ZLlP9FaW+u9v/RyK7bWnpoLHzI4NiP8rb335X++PUlr7elJPmlG6Md77zv16fX1JF938d89rbVXJXlDkjcleWeS40nuz4UPq9yY5NFJnpnki5I8a1DubyX5zh3KmQETcLhmtdauS/LgGaE7Jqz+9Mss/52rzyivv8zyT0liAg4AAAAAAAAAAAAAsOf03u9qrX1Tkv/7ktDBJD/dWvu6JP9nktcluSvJ9UmekuRrcuEDBusziv3B3vurdyzpKzfr6zc9s7/+sxNuSvJXL/6bx39J8sW99/Pzp8SVWll2AjCHZ2V2G37HhHU/ecayM7kwk/BqvT3J2RnLnzJHmQAAAAAAAAAAAAAAO6r3/vO5/FdVnpvk55N8OMlmknuT/EaSv57Zk29emeTvLT7Lq9NaO5zZE1/+S+99nr8f303nk/yDJJ/bez++7GT2KxNwuJY9b8ayjSS/OmHdx81Y9q7ee7/aZC6u+64ZocdebZkAAAAAAAAAAAAAALuh9/7Pk3x7kq05ivnJJF/ee99YTFYL8WVJjs1YvpNfv3lzkg8uoJxTSV6Y5M/03v9F732eY8Oc1padAFyN1tpTknzpjNCre+/3Tyji0TOWLaKD+2CSJ03Y1kK11p6xqLJe9geLqAYAAAAAAAAAAAAA4FrTe/83rbXXJvnhJJ9yBavekeQ7eu8/uTOZzeX5M5bdn+TlO7XB3vsLk7ywtfaEJJ+e5KlJnpLk8Uluy+U/prKZ5C1JfifJa5P8nC/e7B0m4HDNaa2tJvmRzO50/vXEYh48Y9lHrjqp/9+HJ25r0V6zC9sAAAAAAAAAAAAAAB7geu+/k+RTW2vPTvK1SZ6d5PYZP70vyW/mwkSWl/Xez8253UfPs/7A38/H/+35/b33Mzu0vf+h9/62JG9L8mN/vKy1tpbkIUmuT3IkyXYuTAi672JevnKzR5mAw7XoHyb5tBnLf6n3/msTy7hpxrIpX86pzJpdePMCygUAAAAAAAAAAAAA2DUX/zb715KktfagJA9Lcl2Ss0nu6r3fscT0Juu9v37ZOXys3vtmkg8sOw+unAk4XFNaa89J8oIZofuT/K0rKOrojGUnryqpP+nUjGXXLaBcAAAAAAAAAAAAAICl6L3flwtfaIF969LPKMGe1Vp7UpKXZXa7/Ru99/ddQXHrM5ZtXlVif9LGjGUHFlAuAAAAAAAAAAAAAACwJL6AwzWhtXZ7kl9OcmxG+Id67//xCotcnbFs64oTm1bGbpxnz1xgWa9ZYFkAAAAAAAAAAAAAe8rKalt2CgBcg0zAYc9rrT04ya8medSM8C8k+farKHYzH/8VnEWcD7PKmPVVnIXqvb92UWX9zJs+tKiiAAAAAAAAAAAAAADgAWFl2QnASGvtxlyYfPOkGeFfTfJVvfer+XLNuRnLDlxFOVPKmLUtAAAAAAAAAAAAAADgGmECDntWa+2GJK9K8mdmhP9Lki/pvV/t5JYTM5Zdf5VlVWUcX0C5AAAAAAAAAAAAAADAkpiAw57UWjua5FeSPH1G+DVJvrD3fmaOTdw9Y9mD5ihvVMasbQEAAAAAAAAAAAAAANcIE3DYc1pr1yX55STPnBF+fZLn9t5PzrmZD89Y9pA5y7xcGbO2BQAAAAAAAAAAAAAAXCPWlp0AfKzW2pEkr0zyGTPCb0jynN778QVs6t0zlj1yAeXOKmPWtvas1TaOr7TxD7Z7X2A2+9fpja084Zbrhr95x92nh/HqWBw9sDqMb/WeT7j5yPA3b/rI1jB+ZH28jSfecngYv/PUuWE8SW45sl6UMV+bPHawvlSeOD+uh3Ob43h1Xk1x0+FxPdx/bnOu8k9s7/y5ffTAuK4PrY3nDZ86v5UPHD87VxlV/ERRj+sr9bF8293jD7g95bbxeff+ExvD+LvvHfcNSbK+WszBLsLrbfyDKdeC2647MIxXx/L3PzzvXNwLfe3Ik289Ooxf/7qXDuO/9bDPv+KcLlUdqwc/63nD+J8q2nSSfOTUuE29+c756nrKeVGZd3yxiH62ymHebRw7VF9vqm1sFdW0sbV9JSldlQUc7rlV44+T5+e7Ju6G6ppY9V+Jcfsfq/qgW46Mr0f3nBn3kQ+UeqzaSzXmvreopyl95G1Hx9u46/T5YXzCaVE6sl5cd4t6OLkxXv+OE/X9zbyqscP1B8d9ZJJsn52vXVf1+Id3nqpzKM6t2284NIxfX9zHfeTkuD39wYdPlmVU9wbVvcXxc+NGe8OEY1X1YWtFH1jtwxTVNen3PnRi7m3Ma7Woh/PVIOrUvcPw2i0PyRu/4/uGv3niy185jP/Su+4b53D3+Lx524Tvb1f9QzVWXMSYeqdV512SPPT6g8P4O+8Zt+lFXPurMm4snvGsFsfi/nN1jtXxPnaoeM50dnztr54x78a9yW6oxkCLUJ17e+Ee7IGguqbecuRA3nlP/cxtp1XXtCn3iiNVe5sydrj/7Pg3VR9323XjMdiUJv9HO3xiVO0lufB+ZRgvnrdXx7qKJ8nWxngbx4q6vvHwOH779eNjefv16/nt94/HgittnGN1T1/F7zp9Po+7cXzvUI0fqmP19mKc9r61CfdgRXs5WJRRrf/g4ll8Mv81rcpxynlzonhmV+1H1Ue96n3jdzNJsr4yHis++8Y7h/GVez8wLv9RTx/Gb7/+pvzKO+4Z/oZpqmfET751/C7urveMnxtMcW5zPOa97di4vU15T17dztbvFB4YzzYr1f1J+d6Uhamuq5V331v35ZX6veW1f5NV9T9TTv1qvHmy+BuZre3xdXnK2AAAYC9zF8Ge0Vo7nOQVST5rRvhNST6v9168jZ7s7TOWPaq1dtUj/NbawcyegDNrWzBUTb7ZDdXkG9hrqgkbwMerJt8AAOy2vTCxrZp8Ax+rmnwDwLXvWph8A3tNNflmN1STb2CvMfkGAAAArg0m4LAntNYOJfmFJJ87I/zmJJ/be1/kE6c3zli2muTJc5T5SRfLuNTvz1EmAAAAAAAAAAAAAACwZCbgsHQXvxzzc0k+b0b4rbkw+eauBW/2d5PM+ubmM+co8xkzlm0l+b05ygQAAAAAAAAAAAAAAJbMBByWqrV2IMnLkzx3RviPknxO7/3ORW+3935fLkzCudRz5ih21rq/e3FbAAAAAAAAAAAAAADANcoEHJamtbaW5GVJvnBG+G1JPrv3/uEdTOEXZyz7C621G6+0oNbaTZn9BZ9XXHFWAAAAAAAAAAAAAADAnrK27ATYn1prq0lemuRLZoTfkQtfvrljh9P4qSTfnaR9zLIDSb4lyb+4wrK++eK6H6sn+emrzg4AAAAAAAAAAACAhWsrvmEAwJVz9WDXtdZWkrwkyZfPCL8rF75888GdzqP3/u4kvzwj9L+21m6eWk5r7ZYk3zEj9Mre+3uuMj0AAAAAAAAAAAAAAGCPMAGHXdVaa0lelOSrZ4TfnQuTbz6wiyl9z4xlNyX5sYsThYYufsnnx5LceEmoJ/ne+dMDAAAAAAAAAAAAAACWbW3ZCbDv/FCSb5yx/HSSf5DkYa21h825jXO99zdO+WHv/XWttZck+fpLQl+U5Kdaa9/Uez89a93W2nVJXpzkC2eEX9J7/50rSRoAAAAAAAAAAAAAANibTMBht82arJIkR5L8xwVt471JHn0Fv/+fknzmjHX+SpJnttZ+MMmvJHnPxeWPTfIXk/zPSR4+o7x3J/m2K9g+AAAAAAAAAAAAAACwh5mAw77Xe7+vtfbFSX4jyU2XhB+Z5Acv/pvi7iRf3Hu/b3EZAgAAAAAAAAAAAAAAy7Sy7ARgL+i9/79JPisXvl5ztd6V5LN6729eSFIAAAAAAAAAAAAAAMCeYAIOXHRxEs6nJPmRJFtXsOpWkv8jyaeYfAMAAAAAAAAAAAAAAA88a8tOgP2l9/7oZecw0nu/N8nfbK398yTflOQLkjwlH3+ubCb5gyS/lORFvff37WqiAAAAAAAAAAAAAADArjEBB2a4OKHmBUle0FpbT/LIJMcuhu9P8r7e+8ay8gMAAAAAAAAAAAAAAHaPCThQuDjR5p3LzgMAAAAAAAAAAAAAAFiOlWUnAAAAAMD/x969R1uW1fWh/87zqPej3w8a6AYEFAUBMQKJNI+0BAU1ghK9V4URYlDvMNdocjFqyDAhDh8x90YdJl41PnKHci+iIPhAjFEEFAQFG1qaBpqGtrqb7q6u6uqqOnXqnHn/qIq2xa4596m1z977nPp8xjh/nPXba67fWmuuNeea+8yzAAAAAAAAAACYZ96AA/wty4vD5uWtr9UJZXJxe3DldPcz63XYsV45vd6MH1lZ65bRO90nO9t44GR/Gz3HV4eVsbbe3onePiTDz8XQ9dlaFkqZdQpMSFlannUK6dzCsta5v2yVu888XDebncPywvD/jbC61m+zZm1xoX0ce+3yOHp9g3moTz33Hj/VjE9iH+bhOMxDH2i9cyechxznwTQOQ28bHjW3jgncyjfdVri2p3Ect8JxmIihXaSFxWb4aT/6/fmz7/63AzfSNolzZewCtqZ5uPZ63xkMfRbds9y+zybDx4B7VjudzUcf3J3bHzi+qTnsXGofh+XO83TSHwfqxSdR33r99r072vvZ28sxDsNcXDe9vlwvx8XukRgnh842OuMCvfjC6ZUN57TRbfT0xjaWFjf/OM6D3njawgTq01C9+0/Sv256RUziuuqOPXTqXOmM8W6F+jQP5mEMSA5nTOA2Otg0jsM4fw8wVK8v1+sTH+n8/ciupf53TFft3dGM33HkZLeMeTeJ49Drn3zigRMbymkz9Pbz0t3t77DvP7Ha3Ubvuui1afPwHRSMa2EeGjwAthxvwAEAAAAAgAuw2ZNvAJi9zZ58AwAAAADA1mECDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0GACDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0GACDgAAAAAAAAAAAAAAADQszToBAAAAAAAAAAAAAIBpKYtl1ikAsAV5Aw4AAAAAAAAAAAAAAAA0mIADAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQIMJOAAAAAAAAAAAAAAAANBgAg4AAAAAAAAAAAAAAAA0mIADAAAAAAAAAAAAAAAADUuzTgDYXpYXzeubhOsP7up+5v4Tp5vx9Vqb8dX1dvy2+493c+hZWWtv45Z7H2rGx6lP1x3Y2Yx/6shKM766tt6MX71vRzeH+0+sNuPHTnWLGOxRB9t5LhwtzfidD54cnEOvzm0Fa53rYhL7uLrernOr7fBEcux9preN3hTu7vrpH4d5qE9rnRwW9h5oxiexD91z1T2X7fJ78XFy2AoWSvseyPSMc3/g4jGNa7PXn9zViV8s94/Fzm6eOD1Gg9Gw3NtAkmOn2ttYXmiXsTqBc7W80K4Pe5fb2zi9Pvv61DvUOxcXu2Wsrrefb4bux3boW0xCrx82zmHqHctaL4572FDraR/HsrTcjO882B6XSJLO8AhMlD43bFxvGPpxl+3JxyYwXj7veu3VJMaReveoXg7j3OGGtru9PnVvPC7p7+e1+9v9h0MPdr7X6DwfJf3n4d747OneuVps78Pq2jjfObRz7H/P1d6HldP9c7VvR/sZ6Yo9u5vxv+x8z9X7DmosnXvU0DHkpP+c1/tOsbefq2NcmL3rpldGbxML4/SROse67tjT/sBi+9lBL208YwwjDdarDlPJoVMjxslhs581t8uz7FbYj3HGT1vGGa/bs9wfF5y1Xps2ifHV3nFY7GxjK4xt7l7q9bH6dWHofg7txwEAzDt/KQ8AAAAAAAAwwsUw+QYAAAAAgPGYgAMAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0LA06wQAAAAAAAAAAAAAAKalLHqHAQAbp/UAAAAAAAAAAAAAAACABm/AYW6UUnYneVKSxye5LMnBJKtJDp/9+XCSj9Ra68ySBAAAAAAAAAAAAAAALjom4DAzpZSrkjwvyfOT3JgzE296b2U6XEp5R5KfSfLWWuv65mb52Uop//js9kf5ZK31himmAwAAAAAAAAAAAAAAbDITcJiqUsrVSV6a5GuTPCf9CTfnujTJV579ub2U8h211t+YbJbnV0q5NsmPTmt7AAAAAAAAAAAAAADA7G108gMM9bokP5nkuRle/25I8uZSyn8tpewcWNa4fiLJJVPaFgAAAAAAAAAAABh6x1wAACAASURBVAAAMAe8AYd5dDjJPWd/kuTKJE/I+SfsvCLJ5aWUl9ZaVzcrqVLKS5N8zWaVDwAAAAAAAAAAAAAAzCcTcJgHx5K8McnvJ/nDWuvHz/1AKeVAkq9I8i+SPG1EGS/JmTfrfMtmJFhKuSRn3n7zcOvxFikAAAAAAAAAAAAAANj2TB5glt6d5JVJrqm1fnOt9edHTb5Jklrr0VrrLyd5RpLXnqe8V5VSnr1Juf5Ykmse9vuhJG/epG0BAAAAAAAAAAAAAABzxAQcZuGdSW6qtT777KSbh8Zdsda6Xmv9gSSvGREuSV43qST/utBSXpAzE4Ue7juSHJn0tgAAAAAAAAAAAAAAgPljAg7T9tpa69+rtb59SCG11h/KmTfonOs5pZSrhpT9cKWUPUl++pzFb6m1vmFS2wAAAAAAAAAAAAAAAOabCThMVa31zgkW9yMjli0keeEEt/Hvkjz2Yb8/lOTbJ1g+AAAAAAAAAAAAAAAw55ZmnQAM8LtJapJyzvLrJ1F4KeXvJPln5yz+/lrrHZMoHwAAAAAAAAAAAIDpW1g8909PAaDPBBy2rFrrsVLK4SSXnRO6ZmjZpZTlJD+Tv/2WqPcl+U9Dy4ZxLIzRt1+vdfMT2QbW1i+O47RYNveBcHGMSrn4WfMhN+byPcvN+McPn2jGlxf7L/bbs7zYjD94am3wNnqOdbbx7k8fHVT+ODnu29E+Dr3LplcdVk6vd3N47KW7mvF7j692y9hst953vB3f/8xmvF2jx3NwZ7u7fvD3f7oZP3rrx5vxG17xXd0cPpgd3c9stoXOPW47tIm9fUySCdyCgHO4rsazyV3NqW2jp1cfljqdoK3wHc04db73DNX7MmpnZyPjtHk9vT71FZ1ni14Oq2v9/mzvGanXL9+7ox3/5JGT3RyWOzk8+uDOZnwS52Ir6J2rfZ3nxOPv/b1m/KqnPa6bw+6Vw8344kLn4uxXya5efemaQA6bbZzn4Z1Lw47DNK6bXUvt/bj72KlmfJwxnN75nMa9nPHMw/PuZp/vscbbVttt/1Afu789BjQJvePY60suj9HZXO60J72x0d4m7nlopZ9D53zu6N5f2uXv7twjk+H98t65+uh9Dw3bQJKr97XH23rHcecYxyGdMdr7T5xuxq/b3+5LLp18oBlfHaPvsGe5fax756LXZu7r9LnHKaPXd+jVt0ncx9fXhpUxTp3dudT7zmDYdyf7d7bLH8cVe9pj5be3q+RY7c3xTnvz23/VXv/SXe1ng8O3H2nGx+rPdj7T24deW3BkpX1vmIReDr3rMuk/36x1rr1+vJtCV+98XrarXacnkcP+zndM958Y9l3cIw+024ok+fTRdv9hHvq7PYOfp9N/TuvV+25fcYwce/2o3jYmUSd7BveZxzgO/bZ9WP9kGnptQU/vO/Bk+H72ztXxcTqLAABzzJ+asNWNGhGYRC/9e5I8+WG/ryX5llo7o4sAAAAAAAAAAAAAAMC2YwIOW1YpZW+SK0eEDg0s90lJvvecxf9XrfX9Q8oFAAAAAAAAAAAAAAC2JhNw2MpuzOg6fNuFFlhKWUjyM0ke/u73Tyb51xdaJgAAAAAAAAAAAAAAsLWZgMNW9soRy1aTvG1Amf9bkmeds+zba60PDSgTAAAAAAAAAAAAAADYwkzAYUsqpXxhkq8ZEfr9WuuRCyzz+iSvO2fx/1trfeuFlAcAAAAAAAAAAAAAAGwPS7NOADaqlLKY5D9n9ASyHxlQ9H9Jsu9hvz+Q5J8NKG9qSinnvrXngr3pQ4cmVRQAAAAAAAAAAAAAAGwLJuCwFX1vkmeOWP7WWuvbL6TAUso3JXnhOYtfU2u960LKm4F3zToBAAAAAAAAAAAAAADYrka9QQTmVinlhUleOyJ0JMm3XWCZVyX5j+csfmeSn76Q8gAAAAAAAAAAAAAAgO3FBBy2jFLKk5K8PqPr7atrrXdcYNH/KcllD/t9Nck/rbXWCywPAAAAAAAAAAAAAADYRkzAYUsopVyX5DeTHBwR/vFa669cYLkvSfLycxb/cK31QxdSHgAAAAAAAAAAAAAAsP0szToB6CmlXJnkbUmuHxF+U5LvvMByDyT5qXMWfzTJv7uQ8mbs2RMs610TLAsAAAAAAAAAAABgrpSFMusUANiCTMBhrpVSLs2ZyTdPGhF+W5KX11rXLrD4H05y3TnLXl1rPXmB5c1MrfXdkyrrzR++a1JFAQAAAAAAAAAAAADAtrAw6wTgfM6+oeZ3kjx1RPgPknx1rXXlAsu+Mcm3nLP4F2qt//1CygMAAAAAAAAAAAAAALYvE3CYS6WUfUl+K8kXjwi/K8mLa60nLrDsXUn+7yQPf3/gvUm++0LKAwAAAAAAAAAAAAAAtjcTcJg7pZS9SX4zybNHhN+T5EW11mMDNvFvkjz+nGXfVWu9d0CZAAAAAAAAAAAAAADANrU06wTg4Uope5K8JcmXjgi/P8kLa61HB27m5ef8/pEkt5ZSnrnBcq4csWznecr5TK31YxssHwAAAAAAAAAAAAAAmAMm4DA3Sim7k7w5yXNHhD+Y5KZa6wOT2NQ5vz8xybsnUG6SXHOesn4hySsmtA0AAAAAAAAAAAAAAGCKTMBhLpRSdiV5U5IXjAjfnOQFtdb7p5sVs7K2XmedwsxN4xBM4zgvLpw7323yOVTVZdvoncv1KZzsaWxjK+hdmwuL7WubKVpYbIYXd+1or37iSHcTy4tXbyilWVj8rPnVW89lu9vnMkn+4p6HmvFeuzsPljs5ruoHTkzvXq7NO2NolXMcp6d3rCdxLtbW2/HeFjqrz4XePo5DvZ8MTd78qJ06vbBjVzO+//pH9LexY2/nEye6ZQy11qlz22E8bpx9mMR9cLOt9k7WFLjXz4+FMv/PeUNzHOfa3QrHYR70rt15uL+sdXLsjkvWtUmmMzNDx3AWx7gmetdN71wsdXJcOPlgJ4P9nfjwa7u3/s4xxrGXFxaa8XGONZPRu4edOD2sIzeZcYPOfXa9neMk+tzrC8PGR+ahn9dvr8Y51+1rt3esj69u/oNBbz/mIYfh5Q+vT1uhnzeJLtTCwDrZy2Gc71ZOdurDHHQVu3o5XnegPYaTJKc6hbTvLsNdu29n9zOLnSTuP3G6Ge+d62no1tk5yBEAYAgTcJi5UsrOJG9MctOI8C05M/nm3ulmdfH6yiddM+sU8ms3H5p1CgAAAAAAAAAAAAAA8Nc2e+I2NJVSdiR5Q5IXjQh/JMnza633TDcrAAAAAAAAAAAAAACAv+ENOMxMKWUpyeuTvHhE+NYkz6u13jXp7dZab5hEOaWUn0/yzecs/uSkygcAAAAAAAAAAAAAAOaDN+AwE6WUxSS/nOSrR4Rvy5k33xyablYAAAAAAAAAAAAAAACfzRtwmLpSykKSX0zyshHhj+fMm2/unG5WAAAAAAAAAAAAAFwMFha9wwCAjdN6MFWllJLkZ5N8w4jwJ3Jm8s2np5sVAAAAAAAAAAAAAADA+XkDDtP240leMWL58STfk+QRpZRHDNzGSq31zwaWAQAAAAAAAAAAAAAAkMQEHKbvxedZvifJr0xoG59McsOEygIAAAAAAAAAAAAAAC5yC7NOAAAAAAAAAAAAAAAAAOaZCTgAAAAAAAAAAAAAAADQYAIOAAAAAAAAAAAAAAAANCzNOgEuLrXWG2adwwT9epLbz1n2wAzyAAAAAAAAAAAAAAAANpEJOHCBaq2/njOTcAAAAAAAAAAAAAAAgG1sYdYJAAAAAAAAAAAAAAAAwDwzAQcAAAAAAAAAAAAAAAAalmadAAAAAAAAAAAAAADAtJTFMusUANiCTMABALjIrNdZZ5DUOchhOyg7drXjC50XXvbiwJa1uNAeLF7MxTGYfHx1rRn/8GceasZ7x3G59O+j6zNu9BZK/1yvdjoHnzh8YlAOe8bIoaeX4/Ji+1yMcxx6jpxs16erd7TjvRzHsbq23oyvdarb6np7/UmYxjbWOvXhVO9ATEEvx9OdeG/9JOncorIyB8dhKzjVOdY7Hvv53TJO33dXM76+tLNTwrD7LONb8zA6FsdpOmbdT5yUofvR63NPYhvzYBL90aHbmEB3dLCFgc+iq5mDnZiAU6eH9QV7z0fJ8OtmpfPssb7n0nYBh093t9F7dujtw2qnv3t8tf9scvJ0+zO9Z4uLpcs9dD975+rMNobX+1mbRoq9QzmN9mY76NzippPDNujfbId92C7GafdPjtEubnW97wOSZLFzn1ze5D/EH2fsdL22c+id7965nsbzVa892g7PeADAxc0EHGDu/MMvuHbWKWwJ1126d9YpbAmfe/WBWacwF648sKcZ/6Ip5PDmD7f/IAkAYLvxJRLA9tebfAMAAAAAAABsH9vj3wQBAAAAAAAAAAAAAADAJjEBBwAAAAAAAAAAAAAAABpMwAEAAAAAAAAAAAAAAIAGE3AAAAAAAAAAAAAAAACgwQQcAAAAAAAAAAAAAAAAaDABBwAAAAAAAAAAAAAAABpMwAEAAAAAAAAAAAAAAIAGE3AAAAAAAAAAAAAAAACgwQQcAAAAAAAAAAAAAAAAaFiadQIAAAAAAAAAAAAAANNSFsusUwBgC/IGHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAaTMABAAAAAAAAAAAAAACABhNwAAAAAAAAAAAAAAAAoMEEHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAalmadADBffu3mQ5ta/uJC6X7mCZfvacb3LbfnDr73rx7cUE6z8PRr9zfj7z80+33YtdSfo3ny9PqgbbzksqPN+G/cf2BQ+UnyhMv3NuO33vfQ4G1stnGum6Ge8+j2sd79p7/WLeN3rnrBoBw+dvj4oPXHcWTldDP+6IO7mvE7jpwcnMPaeh1cRss49eX46tqgbawMWz1J/159cGe7m3rFnh3N+KFjK90crt23sxnf7Dp5xZ7l7mcu293+zKFnfH0z/heP7tzjJtDcrK4Nawum4aq97XN9z0P9+tLz+E5789FOezNOu7sVjnXPQllsxrfDPk7CQhne9j/yQLtN+/TR4W3aUNfub1+bPYceHH7tDrWWzW3Xk+TJV+9rxv/y3nZ7ddMjhx3nJLnjRPvavfmeY8346hj9n9OdzwztQ41zrlbX2/egk2vtMk4ttPsnq2vD+xa9PtCxU+3+7pGT7fg4Nrs/O45eH+lxe9r7+ZFO+XuW23U+SdZq+zjs39Huz165px1fHKMt6D3PTuJ89/Tq5L3HT216Dj29Onvf8U592fuM9gb2Ji+4ur2NP/xUu+Pda/sn0d7s6Yyn9e5Q26Wfdtt9mz/2MNTV+9rX1YOnhj+ULyy269yjOn3JY6fmfzxtK1jM5o/5TcL+He12cb3TJvZctbdd55PhY1nzoHevv7TTv9nbOQ9J8onDJ5rxwydXm/Hlxc3/v429PtQf3zl8sGrofix3xlfHeb7pedyl7Xp/54PtZ/ZxronetXXPQ+1+2s33tO/1N3cz6DvWadN657JXp//4znY8Sb7gqvaY3iMX2nXytjHG9LaCy3a3n0969/pefJzx+p5jp9r3uEncw8YZo23pXZu972/GeRbtfXdy/4l2ve89T6+ub/54275Om3ZwZ/+7k9656n2/c8u9w8fre3rtxa2dZ5NJ5ND7bmR1fdgY8XUH+uOOvXv9PJiHsa4HO99h9/on4+xD7zuB3ja2gqv29u8fH7irPZbdM/Q49Z63k6Q3LHj/3e17fe9c75xCvx8AYLvTowIAAAAAgAvQm3wDAAAAAAAAbB8m4AAAAAAAAAAAAAAAAECDCTgAAAAAAAAAAAAAAADQYAIOAAAAAAAAAAAAAAAANCzNOgEAAAAAAAAAAAAAgGlZWPQOAwA2TusBAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQMPSrBOA/6mUsjvJk5I8PsllSQ4mWU1y+OzPh5N8pNZap5TPcpKnJHlCkkvO5lOTPHA2n1uSfLjWujaNfAAAAAAAAAAAAAAAgNkwAYeZKaVcleR5SZ6f5MacmXjTeyvT4VLKO5L8TJK31lrXJ5zTniRfl+SVSb4kyc7OKsdLKX+U5GeT/Hqt9dQk8wEAAAAAAAAAAAAAAGbPBBymqpRydZKXJvnaJM9Jf8LNuS5N8pVnf24vpXxHrfU3JpTbNyX5sSSXb2C1PUm+7OzPp0sp31prfcsk8gEAAAAAAAAAAAAAAObDRic/wFCvS/KTSZ6b4fXvhiRvLqX811JK700151VK2VFKeWOSX8jGJt+c65FJfqOU8lOllDKgHAAAAAAAAAAAAAAAYI54Aw7z6HCSe87+JMmVSZ6Q80/YeUWSy0spL621rm5kQ6WUpSS/muTFjY+tJvlIkvuSlJyZpPPEnP/6efXZ2D/ZSC4AAAAAAAAAAAAAAMB88gYc5sGxJL+Y5JVJHldrvazW+rm11uec/fm8JJcm+YYkf3aeMl6SM2/W2ah/nvNPvnlXkq9KcqDW+uRa63NrrTfWWr8gycEkL03y3vOs+6pSyj+6gHwAAAAAAAAAAAAAAIA5YwIOs/TunJl0c02t9ZtrrT9fa/34qA/WWo/WWn85yTOSvPY85b2qlPLscTdeSrk6yb8+T/gHknxprfXNtdaTI/I5Xmt9Y5JnJfmh85TxY6WUXePmAwAAAAAAAAAAAAAAzCcTcJiFdya5qdb67LOTbh4ad8Va63qt9QeSvGZEuCR53QbyeFmSvSOW/2yt9bW11vUx8lmrtb4mZ97gc65rk9y0gXwAAAAAAAAAAAAAAIA5ZAIO0/baWuvfq7W+fUghtdYfypk36JzrOaWUq8Ys5itHLFtJ8q8uIKV/meTUiOUvuYCyAAAAAAAAAAAAAACAObI06wS4uNRa75xgcT+S5I3nLFtI8sIkvzTG+o8fsewdtdZ7NppIrfXuUso7krzgnNDjNloWAAAAAAAAAAAAAJunLJZZpwDAFmQCDlvZ7yapSc7tBV0/5vpXj1j24QH53JLPnoBz7YDyLlpr6514nU4em2mtboOdYGrW1je/vvQ2URYXu2VMI89Z2wr7uBVyHEfvPrmednyc4zCJMjZbr01c6ezDNCwvzv9LNffvbN/DDp8cvg+7l9pl9I7Te//qwe42tsKx7lnvXNvbYR/nxeV72o/7h461B5On0/9ob2OhGPBOhj871KWdE8hhddj6Y9Sn1Tl40Oul2TsV09iH3nWz2evPi+51sbjcKWFlYrmcj+f+rcO5Yt702qPV3oPiBHQebwb3FR95YFf3M58+enLQNraL3jPS0Ppw7f5+X/HYqbVmfGh9WDnd34eDO9vPN/efGNZfnYZ9u9pjE4ud55+Fz/oqjK2sTOF5t1engK2p+93JRfJ80/t+h/mx2ePMiwtTaFM725iH7xM5Yyv0fsbpok2hWgMAMJC/bmLLqrUeS3J4ROiaMYsY9chy7MIzytERy9rfTAEAAAAAAAAAAAAAAHPPBBy2ulH/1mzcf/l294hllw/I5YoRy+4aUB4AAAAAAAAAAAAAADAHTMBhyyql7E1y5YjQoTGLeM+IZX/nwjPKl4xY9scDygMAAAAAAAAAAAAAAOaACThsZTdmdB2+bcz1f3XEsqeWUr5wo4mUUp6eZNR6b9hoWQAAAAAAAAAAAAAAwHwxAYet7JUjlq0meduY678xnz1ZpyT5qVLKrnGTKKXsSfKfR4TeWmv9wLjlAAAAAAAAAAAAAAAA82lp1gnAhTj7lpqvGRH6/VrrkXHKqLWeLqW8Isn/yN++Fp6V5C2llG+stR7q5PGoJP9Pki8+J3RfklePk8cklFKeNamy3vgXfzWpogAAAAAAAAAAAAAAYFswAYctp5SymDNvnBn1Bqcf2UhZtdZ3llL+1yT/LX/7enhBko+UUn4xyVuTfCBnJtWUJJcneWqSlyT5xiR7zin23iRfVmv99EZyGehdU9wWAAAAAAAAAAAAAABcVEzAYSv63iTPHLH8rbXWt2+0sFrr60spn0zyC0me8LDQ/iTffvZnXL+V5J/UWu/caB4AAAAAAAAAAAAAAMB8GvUGEZhbpZQXJnntiNCRJN92oeXWWv84yZNy5o02v5fk9AZWfyDJzyV5dq31y02+AQAAAAAAAAAAAACA7cUEHLaMUsqTkrw+o+vtq2utd0xgM6s5M5lnZQPr7E/yOUmeVkrZPYEcAAAAAAAAAAAAAACAObI06wRgHKWU65L8ZpKDI8I/Xmv9lYHlvzjJ/5nkcRew+mKS55z9eW0p5btqrf9tSD4X4NkTLOtdEywLAAAAAAAAAAAAYK4sLJRZpwDAFmQCDnOvlHJlkrcluX5E+E1JvnNg+T+a5LvOE353krcn+WCS+5KUJJcl+cIkfz/JM8/5/FVJfqmUcmOSf1prXR+S27hqre+eVFm/dvOhSRUFAAAAAAAAAAAAAADbggk4zLVSyqU5M/nmSSPCb0vy8lrr2oDyfySjJ9/8ec5MoHnPeVZ9Q5LvL6V8SZL/kjMTch7uVUlOJ/nWC80NAAAAAAAAAAAAAACYDwuzTgDOp5RyIMnvJHnqiPAfJPnqWuvKgPJflOS7R4TemuRZjck3f63W+ic58xac3xwRfnUp5WsuND8AAAAAAAAAAAAAAGA+mIDDXCql7EvyW0m+eET4XUleXGs9MaD8kuQ/jgjdluQf1VpPjlvW2c++PMnHRoR/uJTiOgMAAAAAAAAAAAAAgC3MxADmTillb868UebZI8LvSfKiWuuxgZu5KckTRyz/NxdS9tl1Xjsi9LgkL9poeQAAAAAAAAAAAAAAwPwwAYe5UkrZk+QtSb50RPj9SV5Yaz06gU29cMSyE0l+dUCZb0wy6s05Nw0oEwAAAAAAAAAAAAAAmLGlWScA/1MpZXeSNyd57ojwB5PcVGt9YEKbe/qIZe+rtY6aQDOWWuuJUsr7kvzdc0JPvdAyZ2G91mZ8oZRNz6G3iSmksOkWt8NOTEBZOzXrFDjryMpaM77/ic/sF3LPsBwWF2Z/XRxfbR+HecjxYrHebo5ycnV98DZ6ZWz2+V5d6+xkkpOn2znuWjKffl6sdfpQMG29+2jPNNq8y/csN+MLaedwz0MXR1/y+v3t43Tn0ZVmvP7ez3W3URba7cn1z39lM37rfceb8ZW1frt954Ptx/Fp1MleX/CWex8aVP4k9uGKPTua8XuPt6+L3j7CxcgYzfaxXZ7ZF+fgMW+zj+U0xpi3i8XOoVodXH7/XGyTS2vmese6NwY0znWz1nkQ/Lwr9zbjt3xmWH93HCud/eztwzyYRI4npnAcenVqKxzroQ7u6v8pxMnT7eOwfuBgM7623v6/kdulf8L86LUnW6GfNYlnsN64IWds9rPFOOdhK9wHh+a4FfaRvzH0fPX6UNOoD5u9DwAA9M3BVzmQlFJ2JXlTkheMCN+c5AW11vsnuMkrRyy7ewLljirjigmUCwAAAAAAAAAAAAAAzIgJOMxcKWVnkjcmuWlE+JacmXxz74Q3O+pfHg39Z3HnK8N1BgAAAAAAAAAAAAAAW5iJAcxUKWVHkjckedGI8EeSPL/Wes8mbHrUhJ5Rb8XZqFFlfGYC5QIAAAAAAAAAAAAAADMy6i0gMBWllKUkr0/y4hHhW5M8r9Z61yZtftSknqeVUhZqresXUmApZTHJ00eETMABAAAAAAAAAAAAmBNl0TsMANg4rQczcXayyi8n+eoR4dty5s03hzYxhfeNWHZZkucMKPN5SS4Zsfw9A8oEAAAAAAAAAAAAAABmzAQcpq6UspDkF5O8bET44znz5ps7NzmN3z7P8n9TSikbLezsPv3AecK/s9HyAAAAAAAAAAAAAACA+WECDlN1dnLLzyb5hhHhT+TM5JtPTyGV9yf5yIjlN+b8E2lafijJs0Ys/3CSD15AeQAAAAAAAAAAAAAAwJxYmnUCXHR+PMkrRiw/nuR7kjyilPKIgdtYqbX+WesDtdZaSvneJG8YEf6+Usq1Sf73WuuxVjmllANJfiLJN57nI/+q1lrHSRoAAAAAAAAAAAAAAJhPJuAwbS8+z/I9SX5lQtv4ZJIbeh+qtf5qKeWtSb5iRPgfJ3lpKeXnkvxuzrzF5v4kJcllSb4wyZcleWWSA+fZxJtrrW/acPYAAAAAAAAAAAAAAMBcMQGHi93XJfm9JM8cEbskyT8/+7NR707y9QPyAgAAAAAAAAAAAAAA5sTCrBOAWaq1Hk/ywiS/NMFifzHJPzhbNgAAAAAAAAAAAAAAsMWZgMNFr9Z6tNb6TUm+Ksl7BhT1niRfVWv95lrr0clkBwAAAAAAAAAAAAAAzNrSrBPg4lJrvWHWOZxPrfXNSd5cSnl6kpcl+ZIkz0hy4DyrHE3yp0n+JMkbaq3vn0qiAAAAAAAAAAAAAADAVJmAA+c4O5Hm/UlSSilJLjn7c/DsR44keSDJA7XWOpMkAQAAAAAAAAAAAACAqTEBBxrOTrA5fPYHAAAAAAAAAAAAAAC4CJmAAwAAAAAAAAAAAABcNBYWy6xTAGALMgEH+FsWyuw7lSdW12edwmCLC+3jeOxUex+fcPnefOzw8UmmtCl6+9mzesXntMt/8Mig8pPk5On2sR66D9tF99pfX+uWsR2O5TzcA7l4HFk5nYM7dce3C7cP5s1WaJYX0k7SdXVWHfZ8VFdO9D+0uNgMl1oH5aCPNT29Y31wV7/vsXbi9KAcjnee6ZcXFwaVnyT3Hl9txn/3jna8l8ODp/rPP48+uKsZ37Pc3sb7Dh1rxp/1yP3dHD7xwPBjOdSVe5eb8SMrw+rTNNz90KlB67/trpJ/cPxPm585eOWzm/GTp9s5TOK6WemMj/RMIofNtm9Huz1L+uNE8+Cj97Xb7mmci97Y5dAcrtzbb48OHZv/OjcNO5fax2FtWDctV+zpn4vefXJofRjnPvyYS3Y34722e31gf3YcQ/thnz660owfiVqPSQAAIABJREFUPtnu3yT9c/HoAzua8Vvv2/zvJA4da+/nVhhjnkSO77nzwU3fRq/ObIVjPdQVe9p1Pkluu79d72+7v73+djmOvWesoZ5+zb7uZ95/V/sZ6WJw1d5+nb39gTHGeRp69+Fp6D0nboXnSAAAAC5u/uIPYA5thck3AAxj8g0AAGx9vck3AAAAbE9f+aRrZp3CIE+9bvO38fir+v9gBKbpMVds/Tr52G2wDwAAW51/IQYAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0GACDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0GACDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANS7NOAAAAAAAAAAAAAABgWspimXUKAGxB3oADAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQIMJOAAAAAAAAAAAAAAAANBgAg4AAAAAAAAAAAAAAAA0mIADAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQMPSrBMA5stjLt3djN9/YrUZf+Lle5rxW+493s3hUQeWm/FPHW3nsH9n+9a2urbezeGeh04140+79kAz/tH7HmrGP3a4fRwOd45zkjzzUQeb8Q/f087hiVfsbcY/cm97/SR5yWVHm/FP7XhEM/5XD51uxo+vrnVzWDndPp8HO/Xh2Eo7h7XaTSE7l9rzWXs5Dl0/SS7d3b5ujp1q7+f7Dz3YjP/F4r5uDkdOtuvtYmmvv3t5sRk/dqpdH/btaK+fJHs621iv7RPeq0+9e2SSfE7nPvnJB04248sL7QPZu3+No3cse+diuXey0z+WD3auzZ4jY6x/7f6dzXjvOBxfbV+bvfbm0LGVZjxJHn9Z+zj12pOdi+37y33H+/Wld4/q3Se/4Kr2/eOWzxzr5nDdgV3N+O0PnGjGr9zTvkceOdmvL2ud+8MH7mrvx+lOfdjXuSaSfpvF/Oi1aSc6fZze+itj9GfvOta+vtfWx+jkDMyh55ZOf7N3H10dYx8u3dW+/g93+i+99Xvtzedf2e9D3XGkfQ97713tvkGv7X/f017ZzeGS3e170Cdvb/f7e3p90SS5dl+7XR6nn9UyiTrb64eNUyeH+kSnzes9Q+3qtOtJv//Q0+sL9trdXn85ST59pNNn7uxDrz6N0Z3NHZ0ces8WvXP1zk/1r7uTYzwrtvT28wmdcYMk2dkp5JEH2tf2DQd3NOP77/toN4dTH/iDZnzHF97YjJfV9nV18gN/1N5+khOH7m5+5rH5H834kx/72Gb85p94QzO+crTfr7/6qdc243uvu7K9/svb7Uk9fqSbQ9nVrlOr135+M/67d7Sff8YZR2I89x0f1u723H1sc8vfTlbHGZwc4O6Htsa5GNoXXChjNO6bbJyxh5ZJ7MPtR9rtxTwcJ5ike8cY+1TvJ6P3/HNI2z+Wceos82PP8mLe/tHPnDc+9Pnkqr3t5+VkMt8JtvTukb1rn/H1xh2fcnV7nHn3Ur89e9en238P8EXXtrdxeW2vX3f0x5GOrrW/+ziw0G4v7v0P/7IZ33V5++94kuSSr/j67mcWH/P07mcAALi4eQMOAAAAAABcgN7kGwAAAAAAAGD7MAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKBhadYJAAAAAAAAAAAAAABMS1n0DgMANk7rAQAAAAAAAAAAAAAAAA0m4AAAAAAAAAAAAAAAAEDD0qwTgCQppZQk1yV5dJJHJbkiyZ4kO5M8mORIks8k+fNa652bnMtCksckeVKSq5NckmRHkgeSHE7yqSTvq7We2Mw8AAAAAAAAAAAAAACA+WACDjNRSvmcJH83ybOSPCXJFyTZP+a6dyf5nSQ/l+QPa611YC7LSZ6d5HlJnp/ki3Jm8k/L6VLKB5K8PsnP1VrvG5IDAAAAAAAAAAAAAAAwv0zAYepKKf82yfcNKOLqJN909ueDpZRX11rfvcEclpPclORrk3x1zrzlZiOWcmaizhcl+YFSyk8m+b5a68kNlgMAAAAAAAAAAAAAAMy5hVknwEVpeYJlPSXJO0spP7jB9b4kyVuTvCIbn3xzrl1JvivJn5dSnjKwLAAAAAAAAAAAAAAAYM54Aw7zZi3Jp5Lcn+RIzkwSO5DksUkOnmedkuQ1pZSDtdZvm2AuK0nuSnJPkgeTXJrkcWfzGeWJSX6vlPLcWuuHJpgHAAAAAAAAAAAAAAAwQybgMGu3JnnH2Z/3Jrmt1npq1AdLKY9P8nVJvj3JtSM+8q2llPfUWn9+QD7vyJk34/xhkj+tta6ek8Niki86m8P/kmTxnPWvSPL2Usrn11rvH5AHAAAAAAAAAAAAAAAwJxZmnQAXpVuS/B9JnlhrfWKt9VW11l+otX74fJNvkqTW+tFa6+uSfG6SXznPx36slHLpBvO5J8m/T/L4Wutzaq0/VGt997mTb87msFZrfU+t9ZuT3JjkzhHlXZPkBzeYAwAAAAAAAAAAAAAAMKdMwGHqzk62+eFa660XuP7RnHn7zFtGhC9N8tIxi/pMkn+R5DG11u+ttd62wTzemeSmJIdHhF9VSnnsRsoDAAAAAAAAAAAAAADmkwk4bEm11vUk35ZkbUT4a8Yo4uacmXjzo7XW4wPyuCXJ94wILST5hxdaLgAAAAAAAAAAAAAAMD+WZp0AXKha66dKKX+U5MZzQk8YY90HJpjKzyT590kuO2f5lyf5DxPcDgAAAAAAAAAAAAADLSyWWacAwBZkAg5b3Yfy2RNwrp1mArXWtVLKf0/ysnNC108zj0m59/hqM37kZDv+vkMPNuPX7d/VzeEzx0e92OhvPHlv+6VFv/1g++Ve9x4/1c3hhY+7vBlf7Lw/7Oa715vxhdLuvO/bsdjeQJIP3/NQM364c65uu799HI+dap+HJLltsX253drJcW29NuPrnXjSP5Z3HDnZjK+ut8/VnuX+uTi91i5jvbb3Y3/nfPfWH8eTr9rfjH/oM8ea8aMr/evmugPt67t3/zix2q5zveNwdOV0M5706/XBXXua8ftPtI/DSqcujOPwifZx6rnuwM7uZ3rHYWfnJtc71sdX+8dh3452N3RxoX1t3985Tr3rKkk+el/7HtXLsbeNRx9s16ffv/1wM54kdxw50Yw/5tLdzfiRk/3rometcwvqXbuTaG969/KV0+06d/PANnMcvRzWOvewA532LElOdu4xi2OU0bLcue7GcWDXcjN+3xj9sJar9u7ofuZI5x7VO1e9vsU47fJap173ymhf2f0ck/497GOn2veXnmv399ub1U6d7T17LHcGvA/u7A9pHDvVrg+9Mnr3h9XOTXKcZ4+TnTr54KmVZrzXZz50rL1+0t/PY2P0s4a6+6H2sdq11O6f9O4P49wjj3fatN69vJfj8kL/RdQPdupszxMvb/c/evuQJA90+g+9/upiae/nFXva5+pD97SfTZLk2n3te9ANl7SfTe493m6vrtnXjifJAyfb9aXXX/3iR7Sf0S7tN3k52unC7N/Z7q/uuPsjzfjqn72pm8PStY9pxh91VXt4rN7y0Wb81KHbuzmUpc756lx7Jz/wR834B37yN5rxZ/zgd7a3n2T19lu6n2l5yvd/W/sDp/v92cVHf14zfuLK9v80OpV2e3V8rX+fPd1ps06cbMefe/2BZvy+E/1ni91L7Tw//kC/3WzZ3+mDjeOy3e1r9zPH2/fp3vNTkjzmknaPszf22Wsze/3dcfonQ59PLt3dvjeM069/TKc96fXjjqy0j9Pdx/p9xd6xHmfssuWeTh8s6Y/hDtUbA0r6Y26TGD/dbL36Mo19eGjgsypsNb1n9kS9n5Zee8YZ49RZJmMS/Zve2OfQbYxz3Wx2Py2d54JN3z5/rfdsceJ0v0/da/N621ja3X4mP73arw+97wRPd56pr3np1zXjZXd7vC1JTl39xGb80PH15N7z/93TlXvaOS6fbn/38pt39J+Hv/yG9hjvyv/X/l/Qqy97TTN+yb1/2c3hT0p7TG8abdaNj7ti07cBAHCh+t/8w3w7MmLZ8L9+3rg7Riy7ZupZAAAAAAAAAAAAAAD/P3t3Hq1pcteH/Vt37dv77DNaBqEFWVhIwvbIQjYIRz4BYYujCGOz6GAIscFyTBKODZhDDiQsinGQFWKMQcIxiXDMiQwOCTIYA7JjRmE5CIMlYW1oGzSapXt6uvvu91b+mM6x1Hqnfm/3e/suPZ/POfePfuo+Vb+nnuepqqeeW/0A7DkLcDjq7pyw7RP7HkUy6b+ZPIiFQAAAAAAAAAAAAAAAwB6zAIej7gsnbPu1fY8iedaEbQexEAgAAAAAAAAAAAAAANhjFuBwZLXWviTJ50xIeus+xzGX5IsnJH1gP+MAAAAAAAAAAAAAAABuDAtwOJJaa5+d5M0Tkt7Re//lfQ7nVUnumrD95/c5DgAAAAAAAAAAAAAA4AZYOOgA4Fpc+drMVyV5Yz5z0cuDSb5+n+NpSb57QtJOkp/bxzi+YK/y+qX3PbRXWQEAAAAAAAAAAAAAwE3BAhwOjdba5yY5fdXmhSSnkjwzyecn+fIkT5uw+/uTvLr3/pEbGuRn+mtJ7puw/Z/23j++j3Hcv49lAQAAAAAAAAAAAADAU4oFOBwm/yDJK65xn0tJfiTJ9/beL+99SE+utfaCJD84IWk1yXfuZywAAAAAAAAAAAAAAMCNYwEOR9XlJN+b5Md674/td+GttVNJfibJiQnJ39l7/+g+hwQAAAAAAAAAAAAAANwgFuBwVJ1I8oYkr2mt/b0kb+u97+5Hwa21+SQ/neSPTEj+hSQ/vB9xAAAAAAAAAAAAAHDt2lw76BAAOIIswOEoa0lelicWw9zfWvu63vsH96HcH03yqgnbP5zka3vvfR9iuNrL9zCv+/cwLwAAAAAAAAAAAAAAOPIswOHQ6L1/8dXbWmsrSc4meVaS+5J8RZIvmrD7y5O8s7X2yt77792oGFtrP5jkr0xIeiTJq3rv525U2SO993fuVV7/6v0P71VWAAAAAAAAAAAAAABwU5g76ABgpPe+1nv/RO/9nb33H+69vyLJS5L85oRfvyPJL7TWbrkRsbTWvifJ35qQ9FiS/7T3/vs3olwAAAAAAAAAAAAAAOBgWYDDkdN7/3d54os3b5uQ/LQkb9zrMltrfzvJd09IupjkS3vv79rrMgEAAAAAAAAAAAAAgMPBAhyOpN77dpKvSfJ7E5Jf11p7xl6V1Vr71iQ/MCHpcpIv673/+l6VBQAAAAAAAAAAAAAAHD4W4HBk9d63knzbhKSFJH9hL8porX1Lkh+akLSW5NW993+7F+UAAAAAAAAAAAAAAACHlwU4HHW/lOTRCdv/9KwZt9Zen+R/mpC0keQ1vfdfnbUMAAAAAAAAAAAAAADg8Fs46ABgFr33ndba7yR55VVJ986Sb2vtm5L8/QlJm0le23v/l7Pkf5itb+8O088cWxymX1jfGqdvjNOTZGNnvDbwQ3Mnh+nHFzeG6fOtlTF87PFxHqtbO8P0Cxvbw/TlhfEx7vRhcpLk9uPjc/Ho6madycCL7z5V/s7uFHGOPF7U09bO+HpMktPFNVnVw8mlcVd4fq2+Znf6bBWxODe+JqvrKamvyY3tcXpVT5tTnItKdT63iguqqqdq/6S+96r2YaM4ho2iDU2SDzy6OkyvzuXi/DjGBy+O269pnC/q8uTS/DD9oct1+1Ndk3eeWB6mny/6m6o/S+p7q7qmqvbjoxfG52Jxrl4Lv1b1N+vjY6jqYZr7ZnVrXNcnl8f1cKmo52nOVaXKo7omd6dox2dt628/vjRMr+6JpL7mzhTnompfplH13Z919thM6b/+sceG6VXbkCTPODMu4/LmuB4uFelVPSfJ006Nz3d1PW1sj9MvT3Eun3vLuK6ef3KcxyM74/3v3J70/yB8urmHPzRMbyfH47jdyxfH+S/dXsaw8b77x+kPPjhMnz82PpfH/8QXD9N3HnxomJ4kWx993zB95b4/O0y/fP8vDNM3H79cxrB0+sQwfeHWO4bp81/4l4bpfaG+dy/vjscXa8V9cfviuH364KX6OXCuGAt+4tK4b6/aj50p+t2qT6pi3NpZG6afWh7X8xN5jGM4c2zcDj7j9Ph8V/VwfLGOcb4YRlX1uLI4zqAa9yfJI8UzVHUcH398vP+FKc7VcvFscH5jfE0+887nD9MXV86UMcxdHLdzuw+O+4L19/72MH1+uW4/5p/xnGH65ruK/0Nnd3y+z37WuB4++fafH+ef5PYvuG8cwsXxGGjhrvFU59wdTy9j6MXzx9JW0V/sjtvZY8fOljGcWxvnsVA89y9kfK5uXanvm6qM08VYrxrH3XmiHiuubo2P49TS+Fw9PJ5WmGq8Wj7f7I7r6daV8TjuoxfG/dFi1ZCn7vMeLPrl6vlneaG+Xla3xpW9XBzHncV490V3jcdgSXJbH4+JVxfHc+Un1h4Zpu8eO13GsPjQeLza54vnn9N3DtPnH/pAGcPu2c8ax7B0fJg+96HfGqZvP/8LyxgWzn90XMbahWH61t0vGKaf2x7fu7elHtdX4+62Oc7jRbeOr8mHN+v75s759fEvFP3JxYXxNVmP6pPtGV9cVM8eF4oxVlKPR59ezBtUx1D1Z0ny8Oq4rj9wbtzGPf/28X1VzV18sMh/P2y1Keb8Zn3R9RQxzfzpyDRzwNO8E7zZVeOfRD0dJtX7lVnvm2neOc5aRpn/NH+0cIMdghD2RXUuq/caO8VcV1K3H5c3x+lL8+MYpnnnuFY8D++mmAO+63nD9L44fj+UJI8Vf/6xujWO4bH1cT2sFDFs7Rbj5SSP746fJW+97xXD9I8U49VTt9Z/Urf6UPGOWX8EADzF+QION4OHJ2y75Xoza619Y5IfzWfO428l+cre+9uvN28AAAAAAACOjmrxDQAAAAAATx0W4HAzmPRfcl3Xpz9aa385yY/nMxffbCf5S733n7uefAEAAAAAAAAAAAAAgKPLAhxuBs+YsO2T15pJa+1rk/yjfOZ9sZ3kq3vvP3sdsQEAAAAAAAAAAAAAAEfcwkEHALNord2V5MUTkt5zjfn8pSQ/mc9cfLOT5HW997ddX4QAAAAAAAAAAAAAHCZz875hAMC103tw1P2VTL6O3zFtBq211yZ5a5L5q5J2knxd7/2nrzs6AAAAAAAAAAAAAADgyLMAhyOrtfaCJN85IelCkp+fMo8vT/JP85lfg9pN8vW9938yU5AAAAAAAAAAAAAAAMCRZwEO+6q19qbW2mtaa23GfF6S5FeSrExIflPvfW2KPL40yf+RZPGqpN0k39B7f+ssMQIAAAAAAAAAAAAAADeHq7/6ATfaS5L8V0n+fWvtp5K8rff+gWl3bq09K8m3JPkbmXz9vi/JD06Rz59O8rNJliYkvznJ+1prL5s2roH39N4f34N8AAAAAAAAAAAAAACAA2IBDgflhUnekOQNrbUPJHlXkt9J8pEkF678zCc5leTOJC9K8ieTvDTJk30951yS1/TeV6co/88mOfYkad905Wcv/Jkk79ijvAAAAAAAAAAAAAAAgANgAQ6HwXOv/HzlDHn8QZJX997fuzchAQAAAAAAAAAAAAAAPGHuoAOAGW0n+aEkn9d7f/dBBwMAAAAAAAAAAAAAANx8fAGH/fatSV6b5FVJPj9Ju858HkzyU0ne0nv//T2KDQAAAAAAAAAAAAAA4DNYgMO+6r3/dpLfTvJdrbUzSV6a5L4kL0jyrCTPTHImyYkkPcnFJI8nOZfkPUneleS3ktzfe9+ZIY7vSfI917s/AAAAAAAAAAAAAADw1GEBDgem934hyS9d+QEAAAAAAAAAAAAAADiU5g46AAAAAAAAAAAAAAAAADjMfAEHAAAAAAAAAAAAAHjKaPPtoEMA4AiyAAf4NFs7u8P0Z9+yMkyfK8ak860etK5ujWNYnh+nr2/Plp4klzZ3Zspjs6jHjSliqFwsYtzp4/2rY7iwvl3GcGxh/CG16nqqYtjarevpeFHG2ta4npaLY6jSk/p8VtfD1u74ZFXHMI3Vudli3Jzimt3p4+OojrPa/5mnxu3P+bWtYfoTMcx2Te4WxzBN+7K8UJRR1WNxOZxcqq/Z7eJ8V+di1ms+qa+H6lzNFf3J3BSTJCeXxkPhM8vj9NuPLw3Tq2N43m3Hs1qc0FNFjMcX54fpuxnXc7V/Urf11bm4tDnuT6o6SOo4qxiqMi5s1H3erSuLw/SLRR5VDNUxTOOhy5vD9DtPjK/Z+Wogl/refbiIoarHP/H0M2UMS/Pja7JIzr23j/uTYxmfyz5XP0ZvFM1gVdWLGWfw8ctlCFnYeHwcwx/89jD9znueNy7gI79XxtCXjo1/YeX0MLmdHZ+rnZX6elm451nD9LnTt43TV04M0/stTx/vf8vT0zbGJ2z+zDiGnVN3DdOP/7EvHKavbKwP05OkFcfZinO5sXxymD63vVHGsDg/vreq58TzO+P917bqsWLVZ1XjzcU9eElT9ReLc8UzWNFOV2PNZIpxVhv3y0tFPZxdGe9/z4mFsh2tqnpte3yctxTNU/U8nSTzZ8eZnD02Ps5za+PrrRqDJclyURGPro2vp+p6WWx1DH2pmCc6e8cwfenecX8zd+JUGUOlasMyNz5Xp+4dt8NJcuy2cZ9WldEWx2Ok3c1xWz7NZ+53F48P07eXxm155fx6Pa6/VLTl1ZC4an92e/0sWs5dFpW5UrTDVRv4RAzjPBaKLO45Ob5eqvYnSU4XcwfHiuPY7uMYnn3LchnDZtHYVnMsz7l13P5U87vnpphHqp5Fq357rbjmT0zR1u8eG7eDKzvjZ7D5iw8N0+ce/lAZw/ajD5a/M4zhlkfH+T9S5z938fy4jGI8u/XJj473f9q4nvrCscytj5+x+vp43F89S1bNx8Zi3SdW99Xx47fOtP9Or9v6zcXxuVjcXhumrxT3xTTTJ9WQtxoDpXgmT+p2tvJoMRas3qU9vjFFv1s831Rt3EOXxu1k9Wxx68piPd4sOubqPdhdxVzX6Sn6xCqGW4s8qj5za4pni6Wd8TPz3Npjw/TdY8X8yhRjpJ3iub5qH1Y2xu30NAPW3aXxPM/ChT8cpvf58fikbY3bn6Seg2nb43H5TtHOzq+eG6b35fGYPUk227g/+eiF8b1bvbc4vVzfN7/xwLhPfOqY7f1vZZr9Zy3jZlC9uz0qdov+aJp30JXq/W71fHOieI6c5nqsjqN6T7V7ctznVX1Bkmyuz/YsurI4jrEV85LT/K1Q+TsnbhkmV/327onxmD1J1rfHbX31t0AAADe7ad7NAQAAe2yahSfAp6sW38BhUy2+AT5TtfgGDpty8Q3wGao/BoLDplp8A3wmfxQOAAAAwM3KXy8BAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAwMJBBwAAAAAAAAAAAAAAsF/avG8YAHDt9B4AAAAAAAAAAAAAAAAwYAEOAAAAAAAAAAAAAAAADFiAAwAAAAAAAAAAAAAAAAMW4AAAAAAAAAAAAAAAAMCABTgAAAAAAAAAAAAAAAAwYAEOAAAAAAAAAAAAAAAADCwcdADA4bI4P16XtzjXZsr/+OJ8+Tvr27szlTFfhLi+vVPmMeNhZrM4hq3dPkzf6eP0JDldpG/tjmPYLcqo9k+SxT6uqOo4q3N1eYpr4dz61jC9OherW+PrYac4hml+p0p/6NJGWUbl0sb2MH2tOM61zdnSk/o454sb6+TyeFjywOPrw/TLm+M6SJKlhXEb98DFcRlzxTHcsrJYxnDPyeVh+uffc2ocQ8YxLC/UDdh8G//OicVx+rHi5m07m2UMC49+ePwLl8+P01fGrWDbra+HzI/bj93jZ8f7t/H1NLdxYZz/yplx/kl2l8fXQ9setx99+cQ4/eSxMobN+fE1+8jquK5PL4/7/g+dXytjWCyuuWrsUPV504xvqjIeXR1f9ztFd3KsaJ+SZK64dytVv1z1iUndn6xujc/3RnHNVvVUncukHm9WbeBKcS56n6JPLMJcKK6508vjGG45Vl8L7fLFYfru+uVh+sKlh4fpm+cfKmPYvfz4MH3+zG3jDObG57It123Y9h9+eFzEiXE7u/XoJ4bpy8X+u2vjek6S3YuPDdMXztw5TO8b4/HL7uY4PUnabnFdFzHOn32kLKOytHR8mH7b8XF6dQw7J+tx2qWt8b23XLQPVRs1zbPupWLcvbUzzqNqf2Z93k6SjSKGx9bHdV3sPtXzcNV3V8e5VMx9HJtiTL1S/M6xjMdIZ4ox0jRjg4X18b25cno8np1fL9rpC39YxtCL/qQ6m71oo3a362eLtrwyUxlVO9rmxudi4/yl7KyP45xffP8wff2xcb99Zmv87NKn6G/aygPD9OW7x88vVb98x+m7yhhOnBg/x60XjVh136xt1W3cdjEm3tgep88V9/6FjXqsWDVz69vjMi5VczxT1MPG9rguq7mFtaKdnWL6tTTrc171fHN+bXxfJcldJ8bPw7PGsHJ6qYwhxfNL2y7auM3xM3fVBibJTjH2nzs+HhP3og2bP1XMvyT1s8HS+Nlg8Y+8dJi+W9Tz7sqZ9IXx+eq3ftYwfbv4PxFPLhVzfo+M+5IkWT4xfsZql8fXw9L6uD86dtuzyhjmLp8bpu8UMc4Vz9yLn6zrYefs04bpa/Mnh+kPr45juDjFPPTZY+O57j+8OJ4fubWYZ/7wY6uqhrzFAAAgAElEQVRlDI+sju+9arxZtWHV89FW9XAyRQzV80+Vftdu3c6eXBqfq+oVUfVsUr0HeyKGcZzjGd5kc2E8Hl4vxjdJslOMYc6tjdOfuzI+hgd36jmc1YvjMp4zP74v+vL43t45eUcZw3wxH9a2xu3o/OPjPnP3WDGPdKx+Z3D8of8wTH/+0vh6aLvjZ5dPzH12GcMfv2c8rn/6qfG5quapH7hYj9OqcX01/7pZtB8fvVCPkU4ujccnVTt8qtj/4hTvZi+sj/ukqg36w+I4n3ZmfO9+sujPkuQ5t49bsQ+fG/dpZ4o+8dzlet5gpajrSvWOe5q/J6j+ZuFkMXaoLBdzXUlyofh7gjuL+2Kz6Ns3pph3rMYX1fubrfnxNVm1DUmyVjywls9xi1VdV38rVNfTWtF37564dZi+XswLrE4xNtgo6mkv3ucBABxlvoADAAAAAADXoVp8A8DRVy2+AQAAAADgqcMCHAAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGLMABAAAAAAAAAAAAAACAgYWDDgAAAAAAAAAAAAAAYL+0Od8wAODa6T0AAAAAAAAAAAAAAABgwAIcAAAAAAAAAAAAAAAAGFg46AAgSVprLcnTk9yb5JlJbk9yPMlykotJLiR5OMnv9N4fOKAYn5fkBVfiO5UnFrBdTvJIkg8l+f3e+/mDiA0AAAAAAAAAAAAAALhxLMDhQLTWnpvkTyX5giQvSvLCPLGoZZp9P5nkF5P8oyT/pvfeb2CcL0vyjUn+XJJ7pvj99ye5P8m/SPKLvffHblRsAAAAAAAAAAAAAADA/rAAh33XWvveJN81QxZ3Jfm6Kz+/21r75t77O/ckuCtaay9O8kNJXnmNuz7vys9fTvKTSb5+L+MCAAAAAAAAAAAAAAD239xBB8BT0uIe5vWiJL/WWnvDXmXYWvu2JL+Za198AwAAAAAAAAAAAAAA3IR8AYfDZifJx5KcS3IhTywSO53k2UnOPMk+Lcl3tNbO9N5ff70Ft9bmk7wl46/WrCd5MMknk6wmOZvk7iT3XG+5AAAAAAAAAAAAAADA4WYBDgftfUn+nys/v5nkA733zUm/2Fp7XpK/mOSvZ/KCl7/WWvuN3vs/vs5YfiyTF99sJfnJJD+T5Fd67xsTYrsjyX1J/lySVyd55nXGAAAAAAAAAAAAAAAAHDIW4HAQ3pvk25P88977+6bdqff+/iTf31r7n/PEYpmvmvBrb2yt/Z+99/PXElBr7VuTfOOEpF9N8vre++8XsT2c5O1J3t5a+xtJviy+igMAAAAAAAAAAAAAADcFC3DYd733n5xx/8dba1+b5GSSP39V8i1JviLJW6bNr7X2kiRvmJD0tiRf3Xvfvsb4dpP839eyDwAAAAAAAAAAAAAAcHhZgMOR1Hvfba29PsmrksxflfzaXMMCnCQ/kmTpqm2/kutYfAMAAAAAAAAAAADA4TY3P3fQIQBwBOk9OLJ67x9L8m8nJH3OtHm01v6zJC+/avNGkm+y+AYAAAAAAAAAAAAAAEh8AYej791JXnHVtnuuYf9vm7DtTb33D1x/SEfbex+6OEx/4PH1YfojlzaG6fNzrYxhc3t3pjzWNneG6RfX67VVDz42Ps6NIsa1rXEMH3lktYyhsrQwXkNZxbBUrOBfLvJP6nOxWpyLnd1eljFrDFUZVT3uRYxVHtPcF7Oqzmd1TU9TD7Me56znqrr3p7G1M45ht89+PVzYGLdBi/Pjeppv4/Rq/ySZK/K4tDVbDPOtbj9uvX28Xnb5zvH+W8WpmOauquphvbgvqqth5dbimi3yT5K1raJPPDbbMWxWFZlkbWvct3/88XH6xvb43vzQubpPPLk8fmzZ3CmOs6qHKc7FytLVH138dA8X9VCp2rhpf2dkdWt5pv2T5Pzq5kz7V/dd1c7uTNEOHyvGOGeK62ljcXyup4mh6k+WFsb1sLEzPobNIv8kOX726cP0xc8a90fbx04N05eeV1+PfaO4v1dOj9MXFsf5LxwrYzh297OG6bvFcbbdop7OPnO8/059z8xtjuvpwsq4Uzxxy73jAnbrMVKv+u4+bicf3r76o7LXbmtzfF1vro/rcrEYa55fq+vh/PrWMP1CkV7ZmmJMvVo8x1XtS2WasWKZx9z4enmseOYuuoJMM+ReKo6jrutq3qFu44rhR3bmxm1YdscZTPXsMcW4eyY3Ov890ndmfxacxW5xLg+LNjce45SmuC8qs06xVLfF7E/s9b23W5RStQ1JMmNTnuIRq+xLkinmaPo4/fLm+ECrGKZp46r5k62isleL5+lza/U47XjxbHB+bbaxwdljRV+R5MRiNYc7Hs/eevfzxwVs1/WwdHY8Hu2L42fN3WNnxgXsQfuys3h8HMPi+Nmhul6SenyxU7x2WF2bbYz0jNufO/6FJJe3xzGurNw6TF849vg4/9Tj/uMn7ximrxYxVu3T3Jm7yxguzZ8cpp8rng0+XrwHu7RZv2Na3Rrf3w9eHM8jXSrmuh9Zrduf6n1dNdc167u6aebbzhwf19O5S+M2qmqHq2e8pH7GmvURaprnwOp59paV8b134aMPj2OYYvBRHWdV1591y7gdXttaK2Ooxg8P3znu83JpnLy1W89Dn1oa91nr2+MYqrHD1sb4vnjggxeG6Uny9NPjeaBLl8f1WL2S/NhD58sYqvcOTz897nePF+ObacZY1Tzzser9b3FbXJji7wlmfYdctQ/T9DfrxcPBpeI4Hiv6k6qtf2iK9yJVf1DFUJVR/U1EUr/X3A/Hi363Os4LJ8f1VJ3rpP7bjaouP35u3JZPcy5uOzHu06oYK9OMP6p3POV78GoMNM3EQOH9nxx3avU47PIwfXuK9qs6n2dXxuO46lxW90SSfNWLx++5AAAO0tF4iwpPbtIs1FRPM621z0vysglJPzFTRAAAAAAAANwUpvkDegAAAAAAnhoswOGom/Rfr31iyn2/asK23+y9v3+GeAAAAAAAAAAAAAAAgJuMBTgcdV84YduvTbnvqyZs+5czxAIAAAAAAAAAAAAAANyEFg46ALherbUvSfI5E5LeOsW+Z5O8eELS7w72uTtPfHFnLskjSR7uvW9MFy0AAAAAAAAAAAAAAHBUWYDDkdRa++wkb56Q9I7e+y9PkcVLMvkLUP/uqnJemeQbknxJktsnxPHBJL+U5O1Jfr73vjtF2QAAAAAAAAAAAAAAwBFiAQ5HSmttLslXJXljkruuSn4wyddPmdUffZLtH75SzguT/MMkf6rI5zlXfr45yb9vrf23vfd/PmUMe6a19gV7ldcPvuP9e5UVAAAAAAAAAAAAAADcFCzA4dBorX1uktNXbV5IcirJM5N8fpIvT/K0Cbu/P8mre+8fmbK4eyds2+q9b7TWviLJ/5rk+JR5/f9emORnW2s/muRbeu/b17j/LO7fx7IAAAAAAAAAAAAAAOApxQIcDpN/kOQV17jPpSQ/kuR7e++Xr2G/eyZsu9ha+/Ik/zSz3Rt/LcmzW2t/fp8X4QAAAAAAAAAAAAAAADfA3EEHANfpcpLvSPLM3vt3XOPimyS5ZcK2xST/Wz598c12kv8lyavzxFdzjiW5LckfS/K3k/zBk+T/JUn+zjXGBAAAAAAAAAAAAAAAHEK+gMNRdSLJG5K8prX295K8rfe+ew37L0/Yduqqf787yVf23t971faNJOeSvOtK2d+b5G9NyO9bW2v/svf+i9cQFwAAAAAAAAAAAAA3UJv3DQMArp0FOBxlLcnLkvx0kvtba1/Xe//glPtW1/67k3xR7/3c6Jd67xtJvq21diHJ9034le9Osh8LcF6+h3ndv4d5AQAAAAAAAAAAAADAkWcBDodG7/2Lr97WWltJcjbJs5Lcl+QrknzRhN1fnuSdrbVX9t5/b4ritoq0r60W31zlB5L8mSSvvGr7F7TWvqj3/m+uIa9r1nt/517l9Xf/9Qf2KisAAAAAAAAAAAAAALgp+H4ah1rvfa33/one+zt77z/ce39Fkpck+c0Jv35Hkl9ord0yRdabg7Sf7r3/u2uMsyf5zidJfs215AUAAAAAAAAAAAAAABwuFuBw5FxZHPPyJG+bkPy0JG+cIpvHBmlvvs64fiPJpIU7r7ie/AAAAAAAAAAAAAAAgMPBAhyOpN77dpKvSfJ7E5Jf11p7RpHFI0+yfTPJr88Q2r+ZsO0lrbXlGfIEAAAAAAAAAAAAAAAOkAU4HFm9960k3zYhaSHJXyh2f+BJtr+3974xQ1i/M2HbXJLbZ8gTAAAAAAAAAAAAAAA4QBbgcNT9UpJHJ2z/08V+H3qS7edmC2diLEly24z5AgAAAAAAAAAAAAAAB2ThoAOAWfTed1prv5PklVcl3Vvs+t4n2b46Y0iXn2T7yRnz3TcfP7c2TD97fHuYvra5M3MM27t9mL65vTtMP740P0zfKfJPktXiOKbJYxY7vc6/qocqxrXd2Y9xc2e2GOr0cf7TqMqYn2vD9Kqe90N1T+yFqp6mqYelhdnW9S4X+1fnqrpvpynjjlPHyjxmdc/ZcRl3nVoeps8V9XB8cdwGJslikcfJpfEQsSrj2IzXQpKsLI7z2NgeX7NtfIhTqcqo2url+XEQa0X+SXK5uK4XizIuboz33yja8SS5sL41TH/o8uYwveorPvJIPfyq+vbq/p+1v0rqNu6hx9fLPEaq9imp28HKmZWlmfZPkksb47HguUvj66E6hr0YY61UY8GiiJPF/rtTjNOqMqp28vbji8P09Sn65aoNuueW8SPTenEQx2+rpxPa5vj+7otFv9vG9dTn6hh6lcfCuN9t2+MPpO4WxzA3V/fL6ePzWV5xxTGmTXFflR3njf//W270iHeae3dW1b2/O0UbN83vDPcvjnMPHrGyO801dcTtw+WyN4r24zDk33dmmyfqU1y0ezD0f0roxTzQfphxOFt2V3txLczN+DA5zf7Vs+Ssz7OzHsNRcTMc56z3xFNKOeadrTKrIdh8a9mo5uOLPLZmHOdtTNEtr23NNv+xsnRqmP7Y6nhOIEnWtsfn6mIxh1OdytNFjEny8MXxXNYDxRzOB8+Pn2UvrI7zT5JbT4znYB44P34Xd/LY+Hm3epeXJOcuj59nlxbGz6ub27ONHaaZ4zl5bDz/8djqeJ5poWhI7z6zUsZQzRsuzc/2PFzlnySnlsfn+47T47mLaa7JSjVnd3F9fP+fLI5hmnqojuOBlfH1Ulndqq/p6t3IdnEc1Rxv1RecX6vPZdXfrBXHWcX4iSnmuS8V18NW8RxX/T3Bw4+P268kZb886zz0hSnORfXOoHq3Wu1/qXg3k8w+n17V4wPnxzFO8262er9Tqc7lrO9N9suFuusequ7tad7lV3X14GPj+78qY5q/Fbo4P24/Zr2mp7oeiqqq7s2qHV3erd5x1+eqqodp7r1Z8p/GrO9mN9cO/u9wAABm4Qs43AwenrDtlmKf/5Dk0oTtp2eM5cyTbJ/1yzoAAAAAAADss2n+SA4AAAAAgKcGC3C4GZyYsG34XyL13neTvHNC0p0zxvJk+z8yY74AAAAAAAAAAAAAAMABsQCHm8EzJmz75BT7/eKEbc9rrc3yFZz7Jmy7GF/AAQAAAAAAAAAAAACAI2vhoAOAWbTW7kry4glJ75li93+W5O8maZ+ybS7Jn03yM9cRy1ySV05I+tdXvrgDAAAAAAAAAAAAwAFr875hAMC103tw1P2VTL6O31Ht2Hv/cJJfnZD0+uuM5dVJ7p2w/ZevMz8AAAAAAAAAAAAAAOAQsACHI6u19oIk3zkh6UKSn58ymx+asO2VrbXXXGMsx5P84ISk1SQ/dS15AQAAAAAAAAAAAAAAh4sFOOyr1tqbWmuvaa21GfN5SZJfSbIyIflNvfe1afLpvb89yb+dkPSW1tqLp4xlMck/TvI5E5L/Qe/94WnyAQAAAAAAAAAAAAAADicLcNhvL0nys0l+t7X2Ha21517Lzq21Z7XW3pjkN5PcPeFX3pfJX6IZ+eYkG1dtuy3JO1prXztaLHQl/rcn+coJyR9L8j9cYywAAAAAAAAAAAAAAMAhs3DQAfCU9cIkb0jyhtbaB5K8K8nvJPlIkgtXfuaTnEpyZ5IXJfmTSV6a5MkWxJxL8pre++q1BNJ7f3dr7b9M8uarks4meWuS72yt/cyV+B5OciLJvUm+NMmXJVmakO16ktf23h+9llgAAAAAAAAAAAAAAIDDxwIcDoPnXvmZ9BWZaf1Bklf33t97PTv33t/SWrs7yfdOSP7cKz/Tupzka3rvv3U9sQAAAAAAAAAAAAAAAIfL3EEHADPaTvJDST6v9/7uWTLqvX9fkq9Pck1f0LnKHyR5ee/952aJBQAAAAAAAAAAAAAAODwswGG/fWuS70/y20n6DPk8mP+48OZv9t4v70VwvfefzBNfu/mpPLG451ri+W+SfG7v/Xf3IhYAAAAAAAAAAAAAAOBwWDjoAHhq6b3/dp5YfPNdrbUzSV6a5L4kL0jyrCTPTHImyYk8sUDnYpLHk5xL8p4k70ryW0nu773v3KAYP5Lkda21v5XktUm+OMkLk9yT5GSSy0keyROLbn4tyb9K8q977xs3Ih4AAAAAAAAAAAAAAOBgWYDDgem9X0jyS1d+Dp3e+yeS/MiVHwAAAAAAAAAAAAAA4Clq7qADAAAAAAAAAAAAAAAAgMPMF3AAAAAAAAAAAAAAgKeMNucbBgBcOwtwgE/z4IW1YfqFta1h+ub2zjB9Z7eXMczPtWH6xfXtMo9ZY5jVXpRR5bGyND9M39zenTmGpYXxQ0ZVRnUMvUjfnaIe54rrpcpj1v33Qu+zl1HV5X5YLeqytXH6UnFNV21DkmxsjtugteKarmwX9bwwRYybO+P7ZtZ7t2obkrouTy6Ph4jHF8dlLE5RDxc3l4fpp5bGMaxujc/1XlgvzsVuce9W9ZQkF4trtjrOqq43iustSTaK46xiePDC+jC9uqbPXd4YpifJ2tb4eph1/DFNvz1rn7gXqjamurd39qC/2dkdH2fVTlZm3T+pz2d17+6FWcuobt396Pb3ZWjRin551vS9MGMZu/OLmdsZP0PdcHPzye6N7zdJ5osh0O4UY6Tq+WRnp3i+Kcbc06hi2IsyRlpL9qGpHlrf3s3KYnH/FzHOWk03up73St+5+duXXox/Fo4tZXt9c5+imWzn0Qczf9vdM+XR+vg4q3p4qpjL0bg3Z3Wjm6C51vZlXD5y68pSzq3d2Hu36lM5OpYX5sr5kxvtgYtbefqpxQONgSdMM0/9VDDNfFo1zzPrnF01V/bghbXcenI8Dz3re67KNHOGVRnVvOSjl8f92TQxVGVcWB2XsVzsv1rMgyf1O+gqxsraFDGcPDaeh571XE1zPT38+Hi+fO3s+Diq8129Q/rIo6vD9KSuyyqGqk99+OL4ncM0Zm2rH1ut5/OOF3VZHWe1/zT3TaV8ZzBjG3d8aX7mOPdjjFUd53707bOWUR3DNPVY9ZtVGZfWx/fFNO93qndM+/G3PLO60ffVXpSxtDBuX6rzsBdlVIypAYCjzvJNgEPoMEwszDqRDfutWnwDh021+GY/HPQfjwDc7A588U1i8Q1HzkEvvklSL76BT3HQi2+SzLz4BvbbQS++SXLDF99wczkM8ycW33DU7MV/sjKravENHDbV4hs4bPZikRAAAMBR5G0yAAAAAAAAAAAAAAAADFiAAwAAAAAAAAAAAAAAAAMW4AAAAAAAAAAAAAAAAMCABTgAAAAAAAAAAAAAAAAwYAEOAAAAAAAAAAAAAAAADFiAAwAAAAAAAAAAAAAAAAMW4AAAAAAAAAAAAAAAAMCABTgAAAAAAAAAAAAAAAAwYAEOAAAAAAAAAAAAAAAADCwcdAAAAAAAAAAAAAAAAPulzc8fdAgAHEG+gAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAwMJBBwAcLqubO8P0i+vbw/Sd3b6X4VxXGb1I394aH2OStLl2TTFdbWd7d6b9p7GxtnVD81/dgzzmZqzHaewWp7M6lzs7s1+zrY3LqOpht7hcpqnH3VbcF322+2Yas9bD0sJ4XXCVPj9FPVW/c/LYYpnHrM6ujMs4c3ycvlm0L9PUQ1WXi0Uec8W5nsaN7i6miXFxvmgfivsmGe+/XNTzNIoQszhfnMvielmer/urqi5nvWbPrC2VMawszhdljNOrcznN+KWKYVZLC3X+1b1bue1EXdeV+eJ6OFtcD9UxVOdimnNVlVGdy2NVjNO0X9vjAUrVzlbt026v27iyHexVf1Jcb3sx3i1iuOH774Pd+cXM7dzYcTtci/14RuPwaOV4lr2wcGwp2+ubBx3GzHrzf3UBR9gN7vOWF+ayWT0MHoJ+t5qfLfefMT1JquFmNa9QHcJSNVmWZHmhmANeGr8eP1WkV8eQJLcUc8BrxXuq08vjGKr5tqSeJ67mLrdnnMCdZg7n1LHxcZ4s6qGaA7rz9HIZw17Mt8+Sf1Ifx+0nx8exslTNnc4ew6niXNx72/Fh+qWN8fvlJDl+aXwcd56qz+fI6hTvh48X84Yb1Xx7UY9bRV9yqXgPn8w+T11d03sxD36yuLeXinrc3Knnsas2Zql4d1K//6lVc/pLxRzxStHfTKOqh+p8V/tXfcFe9Ef78fcllVnrcda+Yi8sTBFDdT5nvR6mOZfTXDMH7UZfs9NcL7O2D1UbOI1Zx5Kz5g8AcNh5qwYAAABwA1h8A3DzuxkW3wAwVi6+AQAAAADgKcMCHAAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGFg46AAAAAAAAAAAAAACA/dLmfcMAgGun9wAAAAAAAAAAAAAAAIABC3AAAAAAAAAAAAAAAABgwAIcAAAAAAAAAAAAAAAAGFg46ADgMGut3ZHk85M8N8mZK5svJPlAknf13h8+qNgAAAAAAAAAAAAAAID9YQEOR0JrrSV5R5IvepJf+e9679+zR2UtJfnaJN+U5KVJ2pP8am+t/XqSH0/y1t771l6UDwAAAAAAAAAAAAAAHC5zBx0ATOmb8uSLb/ZMa+1PJfndJP8oyZ/Mky++yZW0l1353d9trb38RscHAAAAAAAAAAAAAADsPwtwOPRaa89I8nf2oZz/PMmvJnn+dez+R5K8o7X2DXsbFQAAAAAAAAAAAAAAcNAWDjoAmMKPJjl9Iwtorb0uyVvy5F+8+UiSD19J/+wkz5zwO4tJfqK1ttF7/yc3Ik4AAAAAAAAAAAAAAGD/+QIOh1pr7auS/PlP2bR7A8r4vCQ/nsmLb34qyef23p/Ve//i3vsreu/3Jnlhkv99UnZJ3nIlTwAAAAAAAAAAAAAA4CZgAQ6HVmvttiQ/fNXmf7jHZcwl+YkkK1cl7Sb5L3rvr+u9v/fq/Xrv7+69f02Sv5qkX5W8kicW4TzZ13QAAAAAAAAAAAAAAIAjxAIcDrM3JbnjU/79h0n+9h6X8TVJ7puw/Xt67z9R7dx7f3OS75mQ9NIkXz1baAAAAAAAAAAAAAAAwGGwcNABwCSttS9N8rqrNn9L7/3xPf6wzLdP2Pbvk/zANeTxA0n+YpI/etX270jyT64zLgAAAAAAAAAAAABugLk53zAA4NrpPTh0Wmsnk/zYVZv/r977P9vjcl6e5IUTkr6v974zbT699+0k3zch6fNaay+73vgAAAAAAAAAAAAAAIDDwRdwOIzekOTeT/n3pSR//QaU89UTtj2a5GeuI69/luRckluv2v41Sf7f68jvwLzxNZPWJP1H93/ssWH64tzsXyhaXhivDbywsT1M39jeHaY/eGG9jGFntw/TH1vdGqZv7oxjmLX8JJkv6nqaPEbWNsf1nNR1PavNG5z/NGUsFdfjNKpzUcVQneukjnPWutzcrNcl7pbX/WwxrhUx9Bmv+aQ+V1U9L+zBuTq5Xt97IytL8zPtnyRzxXEszo/Tl+fr++b44vh3qr6gMs3+1fk6VuSxXlyz1f7TtKE7xWW9U+SxujW+b7an6K82tsd5zHrvTtNfVWXs9Nna2Vn7zCRZnfE45+fqdnaaNmaWGKaph0vrs42BpunTRqaJcWVx3A5W7eTjxf7TqO7dxflxW1+1LxtT3Lsnl8aP+wtzi8P0te1xjLceO13GsLh8Zpi+VVRUdbanuXVPnHn6OIYik+r55tzquJ7mp/hfs5YXxnV5bm3cPmwtj8uYm+L/XpltFJdc2BjHuFuezWRze/w7VZ9WjU8eurxZxnCpeNasnkUr0zwnVv3mrOP6WdvhafKoxmGXNsftz9YU9VSVUY2zqv1PFW1oUo8/1rbHx7lZtIErC/W5OrM8bj96cV+dasXdvVuPT/rmeI6lSt89/9C4gLm6X26L47ruG/U80MjiiWPD9N0p5k/mimvq1L13DdPnb7t7pvQkaYtL419YKOpxbnwMfXGljGGruL23i/viYtHfrBXXfFLfu+fXxuPdjWKseKx41k2S9aIiqjbqkdVxn1YdQ1KPFavn2apPrMazu8V5SOp+uRpzXy7uzXOX6rHBrSvj++bCxriu59u4LX9sijmgneJcbe2Oyzh78tQwvc1vlDH0zcvj9PlxPfWl4+MCqv4oSYq63JlfHqZXY6iqX07q57BqCDPrO4Np5pHKGPu4Hlsb18PGFPVUPV2sz1gPS1v1GOnx9XF/UbWjjxbpF4r3Q0l9vh98bDw+uXRsfO9//PxaGcOjl8b396xj6r1w6th4/HGxmIeqjmGqecfiXC1NMdc9S/5JPZdVPYNV1+Q057Kqy8eK8cW54pm7etadpoyLMz6TTxNDZdZn8mosuhdmneueZv9Z33tWc+nTnKud3aJvL+bkqv0vTjFOq+b096ceqvcO4/Zj1gKbLxcAACAASURBVPfk07w/ntWsx7hXedxos/7tx16859os3gfuRRnVcc56LqaZj5+1rmf9+5Gq30+S206On7FOFmPFE8Vz5PEpYqje5T/99Hi+7LaV8ThvxiEWAMCBM5zhULnyVZrXX7X5u3rvH7sBxb1qwraf673XM+dXubLPz01ZBgAAAAAAAEfANP8JAgAAAAAATw0W4HBotNaWk7wln35d/laSv38DynpmkudMSPrlGbKdtO9zr5QFAAAAAAAAAAAAAAAcURbgcJh8V5IXfMq/d5L81d77jfhu7X1Psv3XZ8jzN55k+x+fIU8AAAAAAAAAAAAAAOCAWYDDodBa+7wk337V5jf13t91g4p80YRta0k+OEOe70+yPmH7i2fIEwAAAAAAAAAAAAAAOGAW4HDgWmvzSX4iyeKnbP5wku++gcU+Z8K2D/Xe+/VmeGXfD01Ievb15gkAAAAAAAAAAAAAABy8hYMOAJL810nuu2rb63vvl29gmc+asO2BPcj3gSSfO0VZe6q19gV7ldf7Pvn4XmUFAAAAAAAAAAAAAAA3BQtwOFCttWcn+e+v2vzTvfd/cYOLvmPCtk/uQb4PTlnWXrt/H8oAAAAAAAAAAAAAAICnpLmDDoCnvDcnOf4p/34sT3wR50a7dcK2C3uQ76TPx9y2B/kCAAAAAAAAAAAAAAAHxAIcDkxr7RuT/CdXbf723vukr8jstZMTtl3ag3wvT9h2Yg/yBQAAAAAAAAAAAAAADsjCQQfAU1Nr7Z4k/+NVm38tT3wRZz8sTti2vQf5bk3YtrQH+QIAAAAAAAAAAACwB9q8bxgAcO0swOGg/P0kZz/l35tJ/mrvve9T+fMTtu3sQb6T8tiP++zle5jX/XuYFwAAAAAAAAAAAAAAHHkW4LDvWmtfkeS1V23+O7339+xjGNv5zK/g7MX9MCmPSV/F2VO993fuVV7vf+jiXmUFAAAAAAAAAAAAAAA3Bd9PY1+11s7mia/ffKr3Jfn+fQ5lY8K2pT3Id1Iek8oCAAAAAAAAAAAAAACOCAtw2G9vTHL3Vdu+ufe+34tUJn3m5dQe5Dspj8f3IF8AAAAAAAAAAAAAAOCAWIDDvmmtvTLJN1y1+R/33n/1AMJ5dMK2s3uQ76Q8JpUFAAAAAAAAAAAAAAAcERbgsC9aa8eT/PhVmx9O8jcPIJwkeXDCtqu/zHM9JuUxqSwAAAAAAAAAAAAAAOCIWDjoAHjKuC/Js6/a9tYkz2utPW8P8n9Ga+1lE7a/p/f++ITtfzBh2717EMekPCaVBQAAAAD8f+zdebRlS14X+G/c+d7MfPmGqkcVNYClBYIiUyNQ2gKWTAr2Emihu0XFUkDohaC2oIIUCO2CppmaXkwig2A3NiDNINjdaCFCCQ2CtBRjFUUx1PDeq/fy5XDnG/1HJpJ162T89stz7pAvP5+18o/ccU7s344dOyJ27BN3AwAAAAAAANwjLMDhtLQZ2z7r1r9FeMWtf8d9SJJXzdj+qzO2vVNrba33vnc3AbTW1jN7Ac6sfZ1bP//mq8P0X3rTOH1tZfxirb2DozKG5aVZ1eX3XN05GO/jcLyPt17bLWM4OOrD9O29w2H6YfH9ypTvV+VU5THv96eo9rEIm2vLc8VQ1dn1Iv1mHuMYKnsH4/o0pRyrGOY9n1WMU/Zx0vVhSv7zlsMijuHazv4w/XVF+1Kdiyn1cd7rYhEurY+HoQ9fXJsr/2nXzXzHubY8/v7FtfExHvW6Pt7YH5/v1eI49xfQll/ZHtfZt167q6HTfzblujxcGn9m3vZnUn0pzvdW0R9VMS7i2p33+1POxWZRr6t9VGOoyuFRPZasxpu/+qZrw/SqbViZcB6q8UnVxm2tzje2SJIru+Nrd3O1GLcXY+pFuLIzrg9VO1m1kUlyWORxpbi3uLwxrvO7RX2r+oIkubQ+Pt9vLtrZ519aL2Ko+7utoj5UMVbXxdZy3b60XtW5cQy9jY9h55GNMoadw3Gcuwfj9Ov742OYcl1d3R3X62t74zq7U9TJKeOPymrRJ77g0risq/bn+oS+YqmN69yNpXEeu8W5WET7sn0wrrNXd8fn8mBC+1GNT6q5jeX1rWH61sPvVMawvPnAML3tj+dg2sp84/4k6Xs7w/Sjq0+Ov38w7jOXVotx/YTxye6T4/m0ysW1og1bqscOSxcujdOLc9k3x/XlaGXcHyXJ3nZxv1vU2er+Zrdox5Nkr/jM1TnHq1OU93nL4zZudWm+e9Ek2SjGvFUeVTtc9TfVMSZ1n7ZcxFCZcr/86IVxG7Vf1Keqz3vRA6tlDNU4q7qPa0fj/qZPuHaPNsbtR18Zt1GHq+P2o+pTk6Q6XQdFfanO9/aE5xbX5mwfHr8x7m/Wi359Z7O+tneK8WpRJbPc5muHk6S6NHeKMXPVPkyaRyrqVNVGTXmONa9qnFYd5yKe31TOwzOmeS0ihtN43lfVuSq9mpuYEsON8rnEeB/VnF+V/5Q8rhTtaOVaMQeUzH/tzTv3+dSEY7y8NR4/TDnOke0J98PVc66LxfOf6pnDdjH3kdT1vnIabX3VTlbnasq1W81lz/s8cBHlVI3TKkfVdTkhj170/fNdNYvRi+O8UZzL6vtJXZY3dsbX7l4xl1VO7yZZXhkfR1vAcVbm3ce831+Z8Pxnq3gucalIv7gx7is2J8RQ7eOND47n/B69ML7XrJ5xJ8lLnjO+FwUAOEsn/+tKOJ9+dsa25SR/eI483yOzfxH0c3PkCQAAAAAAwBmZd/ENAAAAAADPHhbgcL/66SSz/v7Cy+bI8wNnbDtM8jNz5AkAAAAAAAAAAAAAAJwxC3C4L/Xen8rNRTjHffgc2c767k/f2hcAAAAAAAAAAAAAAHCPWjnrALg/9N5flaQtIq/WWp+x+Qt67698hll9f5I/emzbh7XWHuq9P/kMY3o4yYfOSPq+ZxgTAAAAAAAAAAAAACeoLXuHAQDPnN6D+9l3JDm+mGctyafcRV6ffOu7t+tJ/tld5AUAAAAAAAAAAAAAAJwjFuBw3+q9/3qSfzkj6X9orT0yNZ/W2nOS/J0ZST/Qe3/9XYYHAAAAAAAAAAAAAACcExbgcL/7ohnbHk7yza218vporS0n+eYkDx1L6km+eP7wAAAAAAAAAAAAAACAs2YBDve13vu/T/JtM5I+Osl3tNa27vTd1tqFJP8syUfNSP623vtPLiZKAAAAAAAAAAAAAADgLFmAA8nfSPL6Gds/IckvttY+s7X2rq219Vv/3q219llJfinJn5/xvV9P8pknFy4AAAAAAAAAAAAAAHCaVs46ADhrvfenWmt/Nsmrkjx8LPnFSb7i1r8pnkjyZ3vvTy0uQgAAAAAAAAAAAAAA4Cx5Aw4k6b3/f0k+ODffXnO3Xpfkg3vv/2khQQEAAAAAAAAAAAAAAOeCBThwy61FOO+b5OuSHD6Drx4m+dok72vxDQAAAAAAAAAAAAAAPPusnHUAcBe+YMa2Vy0i4977k0n+emvtHyV5RZI/k+Q98/bXykGS/5jkB5N8U+/9DYvYPwAAAAAAAAAAAAAAcP5YgMM9p/f+ylPYxxuSfH6Sz2+trSZ5cZLLt5KvJHlD733/pOMAAAAAAAAAAAAAAADOngU4ULi10Oa1Zx0HAAAAAAAAAAAAAABwNizAAQAAAAAAAAAAAADuG21p6axDAOAepPcAAAAAAAAAAAAAAACAAW/AAd7GQ5urw/SHL64N09dWxuv69g6OyhiWl9qJ7uPwqJcxVJ9ZXzkYpu9OOM6ztlKU8yKOoTqXi7C1tlzEMN9a06q+Jcna8nz72Cv2MaUcqxj2Dsfnc7mN91HFmNTXXlWW1XW3iPo05fo/7zbXxsO30yinRezj6u64Ha3SK/Nel1NU5XTYi3Isrrvz4qTb8ovrC7glGXcFC1Gd78ub4zHSvWBztS7Iql5X5q9PJ39tV/3Z9oQyqNqwp27sD9Pf9NTOMP25D6yXMTy5Pd7Hb14Z72O1OFcrE9rZy8X1fVSU5WFR1MsTqtNS0dbuFmOka3uHw/Qb++P0q8X3k+SN18qPDFXHsDXh2n70wrgNOyhOxnoxzts5qk/WxvK4viztXR+m99XNYfpmq8/FRjHOurE0Loeqa987rMuhqrP198fHWV13i7B/NK6TG31cXzZW52/r94s6d9TnH99UY7mlFOnF96dUhapbrfKo+uV2NGFMfjDub3KwO0zue+P+aIq+uz1MP9oetx9tddwGrl4Yty+7T14dpifJ+oMXy8+MHBXltHywV+ZRlXU7HOfR+vjabqfQvlSKLjFJPd9V9e2LaEf3q3vJ4jg2in63Sk/qvrtug8bji7WV+dvZ9eVxOa1OGQwOTJn7XC+Oo5pfXStinDIvMO9c1n4bj2+qcV6SHK0+OEzfPhjncbA/7k/2JsRQ3X5U181O8YGd/bo+XCnu83aKOrVVjHGqcfsi7oarcqiajylNYHUuqnmFpWIcN6G6zG3eeewkuVCcz5c8emGYvrqAv8BcHceVG+O+/9JGNQ9dPaur78E2i+c7U/IYmTKP9dZr4/Fq1V9UfeqNCfMC1bl67Op4HHdQ1Mmqv0rq5w7VuXjdY+PJjctb9dzpYXEv+brHxuP6qhy39+r7mzdeGd9bVHN61T3WIupLVdYn/axuymeqcprye4Fng16UUyvqS/X9pC7Leefjqxj6hHb2sOi8WzEmPioGF1U5JtPKchjDAp4vF7fU9ffnzSD1cRzs13ML8zosmrnlYuA/pc5VqjpX7aP6frn/pfpcVtd2NT5ZLvq8KW1DFUOVXs2fPAt+tgEA3Oe8AQcAAAAAAABghmrxDQAAAAAA9w8LcAAAAAAAAAAAAAAAAGDAAhwAAAAAAAAAAAAAAAAYsAAHAAAAAAAAAAAAAAAABizAAQAAAAAAAAAAAAAAgAELcAAAAAAAAAAAAAAAAGDAAhwAAAAAAAAAAAAAAAAYsAAHAAAAAAAAAAAAAAAABlbOOgAAAAAAAAAAAAAAgNPSlr3DAIBnTu8BAAAAAAAAAAAAAAAAAxbgAAAAAAAAAAAAAAAAwIAFOAAAAAAAAAAAAAAAADBgAQ4AAAAAAAAAAAAAAAAMWIADAAAAAAAAAAAAAAAAAxbgAAAAAAAAAAAAAAAAwIAFOAAAAAAAAAAAAAAAADCwctYBAOfLiy9vDNOf3N4fpq8uj9f17RwclTEst3H6tb3DYfr+4XgfFzfqpm+viHO7iOFGkV45POrlZ5aXxgVV5THv98+LrbXlYXp1nPOmJ8naynzrWav6togY5t1HVeen7GPeclpEndyd0AbN4zSum3vl2qwc9pM9jlM5F8UxVDEc5uRjnNJ+VA4Pi/6kzbePKXVhrRhfPBuc9DWRzH+upuRRHce8fcEU1bW3V4wVT6P9qPrMa7sHw/SnijH5FNW5XET7sV6c74M5y3rKuarGivOe7ynHsDLnePPy1uow/aGttWH6paIMkmS9aGc3i3O5vDQuh40p134vxmlFejvYHX+/1TG0o/GY98LSuCyXirLenzAU3ShuiNdXinH7fhFD0a8ndVt+VKSvLs03L7B7WN97VMdRHcON4mRMuW62VsefOSrGepfWxnMT1blOks3iMw+uFPfL20+N0689XsZwdPWtw/SqxvXifPcbT5cx9L2d8jNDxbW/vDFuZ9/xj/+RvOVnfmn4mRtvemKYvnbpwjB9+y1PDtOXVsZ9RZK0zfE+UrRxK0U7urS6WcbwyNZDw/Sn98f7qNrRG/t1+zHvuLuad7w6Yf6kyqPql6vbo0vr9dxnNRYsh4LFLtaK/mzKvclmsY/VIshqFwdH9digGgNVQ8GNop1ePqrH9VWPtN/GBXV1b1zfrk8YoFTXze7BfGOHKddu1fc/98K4ra7G/b/1dN2XvOHK9jC9mj+txu3Vc5EHNuq2vnp+8+SNvWF6OZe1gPvl6vnMIp5bzHs/W+1jytzG9aJeV211Veer+8RkwnEUHUo1f1LNbVwu6nySvNMjW8P05eeOxy8Xi3LcntC+vK7oMOadR7o44dqt6lS1j+298TzScnGPNiWP+Z+tjNufJNks7pHmbaMW0X48+sD4Ofq8bVhVBlPsHRT3N0WMU55xV3N+87q6M66PSd0GzWsRc6OnEcO8ffO8z8kPJ4yp53ey87un5XDOOtsX8Aypz1lW7RSui1bdqxYxHE04xnnzWC7nysf5T/m90oPFOOqR4v6nGis+XHw/SS4WfdILHlgfpr+o6DNP4XEhAMCJMpwBAAAAOAHV4hsA7n3V4hsA7n3V4hsAAAAAAO4fFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMLBy1gEAAAAAAAAAAAAAAJyWtuwdBgA8c3oPAAAAAAAAAAAAAAAAGLAABwAAAAAAAAAAAAAAAAYswAEAAAAAAAAAAAAAAIABC3AAAAAAAAAAAAAAAABgwAIc7gntph9trfU7/HvlKcbyikEcrz+tOAAAAAAAAAAAAAAAgNNhAQ73ik9J8ifOOojW2vOTfNlZxwEAAAAAAAAAAAAAAJweC3A491prL0zyJWcdxy1fk+TBsw4CAAAAAAAAAAAAAAA4PRbgcC/42iQPnHUQrbWPTfIxZx0HAAAAAAAAAAAAAABwuizA4VxrrX1Cko+6bdPRGcXxYG6+/eZ2ZxILAAAAAAAAAAAAAABwuizA4dxqrT2S5KuPbf66s4glyZcned5t/39jku87o1gAAAAAAAAAAAAAAIBTZAEO59lXJnnubf//nSR/97SDaK29PMknHdv8GUmunHYsAAAAAAAAAAAAAADA6Vs56wBgltbaRyT5C8c2f0bv/enW2mnGsZXkG45t/oHe+3e11j7q1AIBAAAAAAAAAAAAYCGWlr3DAIBnTu/BudNau5jk649t/v7e+3efQThflOQlt/3/epJPP4M4AAAAAAAAAAAAAACAM+INOJxH/yjJi2/7/7WcwaKX1tofTfI3jm3+vN77G047ltP0wgvjdXnbz7kwTF8u3lB0cNTLGKqXHF3dPRim7xwcDdMvrtdN326Rx9W9cQzbe4fD9L0i/8MJ5VSZN48qxkXsozKlviwvjStMlX4e3AsxLsJJ15dFOA8xnosY+jiGqq2vvp+cwnGeg2Xm1THeK9d+db7nPY7l1N+fdx8rxfcX0d9U57usDxPe8jjvtXkqda4YPsxbjlMsL89XDuW5nNDGTTmf85hyLk/6upnipMdpU+rL2sp8HUJ57RbpU/ZflUOVx2pR51cm/OWu6iNlenEqp9Sntrc7/sDB3vj7q0WQvb6/qT7TszZMX14e32seTWg/1orCPOzj41wq+tWj1TqGCWHOpWwii6pw0/ieu0rePxyf6yu7dSFcKeYmVqv+ptjFw5v13MXB0eowfb2oTw+sPzBMv/TA88oYltY2h+ntYH+Yvlzkf7RcfSI5uv70OIajcYXoezvlPkYefd8/mDf/1GuGn1laHZ/PNudfWTwqyjlJlravD9N7UY5H154a57/1UBlDP7w4TN9cXR+mrxQXztUJxbhR9avz3t9M+Hp1tk7jj25eL+YuK9WYeGltXOcP25R7sCKGoj5sFue6Sk/qsWDVb1ftcI7q8UlfHo8/ru1Vfdr4XD92vW4/ntwZf+Za0Sc+sDHur27sz1cfk+QNV8ZteTVmvrIzPoaNleU8fm08SKnm05eXxuVYjfursUOSPF2cq9N4blEdx5TnDvOa917zNJ7fVOPy6t5hSgzVZ7bnvPb2Dua/dq/cGNfZixvj/mR7aRzDteLaTpKttfF4c/mgaOur/qbIP0kub43byQeK55rVc8+t1TqGqr5UY6jq2Wz1/SR5crvuk+Yxpb/ZP+HnFleKY6yuiSS5WtTrx4pn2GXbMGGcWLWTVV/w4NZ4fLNZjCWTZLs4zrWVcb2vYnz00vjeJKmv72ofVVm/4+WNMoYXXR7fkz+8OW5f9ovx6ONFnVyaMA9+rThXj14Y14e3XB/PCVbjuCmqYXvVNuwV80xJ8qanxuPV33ryRpnHSNU2JPOPw6ox1o0pMRT3DpWjYlC8NOGmfKmaszso9lF9v9j/lLnyzaLvrsYOVfpDRduQJA8V93EveGDcTj7v4rgtX8QzKACAs3QOfpoIv6e19rIkn3Zs8+f23n/zlONYTfKP87bXyM8k+erTjAMAAAAAOL+qxTcA3PuqxTcAAAAAANw/LMDh3GitreftF738dJKvOYNw/m6S97jt/4dJPrn3Pv+fcwIAAAAAAAAAAAAAAO4pFuBwnnxukne77f9nsuiltfbuSf7+sc1f1Xv/D6cZBwAAAAAAAAAAAAAAcD5YgMO50Fp7jySffWzzV/bef/aU41jKzbfwrN22+TeS/IPTjAMAAAAAAAAAAAAAADg/LMDhzLXWlpN8U5LV2za/Psnnn0E4/32SDzy27dN779fPIBYAAAAAAAAAAAAAAOAcWDnrACDJZyZ5v2PbPu20F7201t4pyRcf2/zPe+8/eJpx3I3W2vFFQ3dt+/q1RWUFAAAAAAAAAAAAAADPChbgcKZaay9J8oXHNn9n7/2HziCcr09y8bb/P5Xkb5xBHHfjJ846AAAAAAAAAAAAAAAAeLZaOusAuO99Y5Kt2/7/VG6+EedUtdb+YpIPP7b5c3rvbzrtWAAAAAAAAAAAAAAAgPPFAhzOTGvtFUn+5LHNn33ai15aa48m+Ypjm388yTecZhwAAAAAAAAAAAAAAMD5tHLWAXB/aq09P8mXHdv847n5RpzT9tVJHr7t//tJPqX33s8gFgAAAAAAAAAAAABOUFvyDgMAnjkLcDgrX5Pkwdv+v5fkk0970Utr7aOTfPyxzV/ae/+F04xjAV62wLx+YoF5AQAAAAAAAAAAAADAPc8CHE5da+1jk3zMsc1f0nt/zSnH8UCSrz22+VeTfNFpxrEIvfdXLyqvnRvXF5UVAAAAAAAAAAAAAAA8K3h/GqeqtfZgbr795na/kuSLzyCcL03ygmPbPrX3vnMGsQAAAAAAAAAAAAAAAOeUBTicti9P8rxj2z619757mkG01j4oyScf2/ytvfd/fZpxAAAAAAAAAAAAAAAA558FOJya1trLk3zSsc3f0nv/N6ccx0aSb0zSbtv8eJK/fZpxAAAAAAAAAAAAAAAA9wYLcDgVrbWtJN9wbPNjOZtFL69M8tJj2/5W7/3xM4gFAAAAAAAAAAAAAAA451bOOgDuG++X5CXHtn17kpe21o4vhrkbL2ytfcCM7a/pvT99bNvHH/v/Lyf5lTt8f+S5M7at3yGfx3rvr32G+QMAAAAAAAAAAAAAAOeABTicljZj22fd+rcIr7j177gPSfKqIpZ3TfLqBcXxvDvk9a1J/vKC9nGifvKN28P0K7sHw/TVpVmn+ve88dpuGcPRUR+mH46TszwOofx+khz18Ye2VpeH6atL4xeMVTFe3z8cfyDJclHWy22cflgc497BURlDZbMop0WozsX6yvhcVPVtihvF+Xq6uG629+rzfdIOi3KYUh9uFMdR1dkqhur71bmeso8Ht1aH6VU5VPknycEC6txJW57Zbf+e8lwV7U+SHGa+cqjqw5T2Z6VqR4v0qzvja7sqpyn1pVL2BXP2FUl9Xcx7nFXbkdTH8WxQ9cunYUo5V9fNbtFOztuWT4lx3muraqcXce3Om8eUcpi3LBdx3Z3GPiqba+P+YN4YN5bH5bw04Rirtrg6l9U92PMvrZcxPLw5busvr4/LcWt1HOPK1beUMbS960X6+F61r22O05fXyhhKK+OyXL0wTl+eMF7dOyzGm3M3QRPa0aJPqpqw6n63slnUpymKKpudor9anfcgUpfT0gL6k3IfRfuyWdXJegonrRf3ilV6pZhfSZIcjceT/Wi+GA539obpa5culHmsPrBV5DFOv/AHxn+/aOUdXlzGsPTAw8P0o62HhumHFx4Zpl9vG2UMu0UjtlPMn9zYH3//rdv7E2IY14dqTnC/uPCqeaokWa3GD8W1W8871m3YhWKMVI2Jq12sFe3ohBDn7k+qGKoxVJLsFx+p7o9Wql1MuQ8s2tHqOKr6MKXPWy/q7E6RXu1iY8IYqVLto7ruKpc3VnKtaKOq9uHi2viRbHUMU+4tqvO5NmdZT5kjrvaxsTLfM4MFDNPKstwv+quqr0jq+7iqPlT7mDIXXqnOVf3MYHwfOaW+PXxxfJ92oSinqt+tvp8km2vj8UNVDtVxTpmnrurDxaLfvrQ+/n7VjidJ9ZFqfFJdN1P6m2of8z5j2pzw7LVqyyvVYVbn+nIxP5Ok7I8ubYz3Uc3fVvkn9blYKyrUvM8cpnymmhOs0h+5UM8jVW3QQxv1+Rx5zlYdw8Ob8/WrVddeXZdT+sTqM+V4tZqfndDfVMdR2VrAOO33PTS+73/OH3qHYfpzi/rwoosTyqGYf1268eQw/Wjz8jB9yvzr3sp4Dvcnf/vaMP0X3nJ1mP4OF+u58KpfnPfeoZorr9rhpB7rVe3PleIZ9pM79fzJm4rfdr3uyRvD9OraXZ9wX/CJ7/PC8jMAAGdl/tk5AAAAAAAAgGehKT9GBgAAAADg/mABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADK2cdAPeH3vurkrRF5NVa6zM2f0Hv/ZUTY3nnBcXxLUn+0rHNv7Go/AEAAAAAAAAAAABYvLbsHQYAPHN6DwAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGLMABAAAAAAAAAAAAAACAAQtwAAAAAAAAAAAAAAAAYMACHAAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGLMABAAAAAAAAAAAAAACAAQtwAAAAAAAAAAAAAAAAYGDlrAOAu/AFM7a96rSDSPK9SV5/bNtTZxAHAAAAAAAAAAAAAABwgizA4Z7Te3/lWceQJL33783NRTgAAAAAAAAAAAAAAMCzmAU4AAAAAAAAGpW1swAAIABJREFUAAAAAMB9oy0vnXUIANyD9B4AAAAAAAAAAAAAAAAwYAEOAAAAAAAAAAAAAAAADKycdQDA+XLY+zB9vXjt4qX15WH65Y262VlfHudRvflxc3X8geXWyhhWl8afWS6yWC6+v1Kk7x2Oz0OSFIdZlsNqjobp7eigjKHtb48/sDQ+3wdrF4fpV3YPyxiu7Y2P4/r+OI8bZfo4/yR5/MbeMH3/aHw+9w7G+7i2U5+LKo+qTm6uja+7Fz9nq4yhurbWV+Zb91vlv1OUwRSXinKozmXVhiZ1ndvemy+9qgtJslaci3nTp8Rw5cb+MP1qUe+3i3K8UlyXSX1dXNxYHaavFR3S5c3x96dcEwdVnSvSq3LaO6rP1fLOuJyqGPYOx/vY3qvbuEoVQ6WqC9PyGJ/PwwllPe8+quOo0qs6nSSH5RhmfJyH+/P1iVMsoqxHqvOQ1O3k/DHUdXbe+lCNDar0JHnu1tow/YGind1awLh+acJnRvaL+rQ/YdxeWS1uLqomrrpHu7hW34NV9yfVGKgaM69feG4dw8XxZ9rB7jD9aHVjmD5vX5HU92lXb4z73Z2ijUySajhZxXA0YTxaqa6b6rKqrs0qxKsTxgbXijFxNea+Uow1q3v+JKku/+pcVPcOGzfqvuTi+nhMfXl9fP3vHa4P0x+98EgZw1Yf1+ula48P0w8f++1h+vbrfrWMYfuJK+MYinZyaXVcTrtPXRum798o5kaSHBX9SRXj0fWnh+l9b6eMIcW5Ki2N+/4po5+qKd4rPlD1y7sT2tl554GqGKaMPar2YUobNLK1Wo/T5h0jVfvYKEKo5l6Tur+p+pODBYzTqn63iqEacy8tj9vhpB5vPl3Mn1bpjxfzM0ny9E4xh1P0ywfFtVmNNZO63zwq8lgt2tlJ449i/FDdz+5tjdOre/Ip1+314jiq+bjKlHv2ee81q3H7Iu6HK9VxTrm3qI5zd7OoL8V1M+WZwRPXxvOjV7bnrQ/ja39tpe6PqrK+WDxTrMp5SjlV89DV+a7meKfMEV3eGs+PXCzG9dX9UTW/MkXVjlbPZzYmlEN1nzavahyYJDtFvS7n24q2urruprTTVZ29sj2+9qs6XeWf1PW6ui6qGKY8a6vyuHgwvm6q70+Z+1wt5omrMc6UMXGlGh9Uc34pfi9QXbtTxifVPdZDxbO06tqdMpas4pz3HmxKOVT3UFX65kpxb7F3vYxh6dpj4w889pvD5OX18fxr363nJrY2LwzTP/iBR4fp/+V7veN4BxPmPvry+LnF1eI5VvXs9npR56f8/mRtzmcG1bU7ZQ75xlLdb47sF+PZKf0yAMB55g04AAAAAAAAADNM+RE/AAAAAAD3BwtwAAAAAAAAAAAAAAAAYMACHAAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGLMABAAAAAAAAAAAAAACAAQtwAAAAAAAAAAAAAAAAYMACHAAAAAAAAAAAAAAAABiwAAcAAAAAAAAAAAAAAAAGVs46AAAAAAAAAAAAAACA09KWvMMAgGdO7wEAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMLBy1gEA58vrn9oepu8f9mH65Y1xs7K+XK/72z8a7+Pg8KjMY6Q4hFOx3OrPVOWw1MaZrK+My3p1afz95SJ9SgxH/WCYfmP/iWH64zf2yhjeem38mcOiHBdh72BcJ3eL9CrGa7vjckySazv7c8VQ1ZfNtXrIsFbksTbh+h+ZUicrW2vLw/TLW6tz5T8lxs0ihoc2xzG84IGNYfrKnOWcJM8pymF1abyPKSFUTfm8h1G1T0mytTo+F8tFHmtFYz4hhPSiiTrKfG1Ymf+E7KtzUZ3LwyKIKe10tY/dw8Nh+k7RBt7Yr8cWN/bH+6j61d3iIKr8k3ocVn7/aL7+aMpnru3UfdZI1adW6UndFs+bXrXjSfKcC2vD9Kqtv1j0u+/04LgvSJKLq1W/PF8btzFhQNsOdofpS9tPjb9/OB7f9KV6fNKOijrZ57u3mPv7SdpBPeYdOhq3H227vi770+Nz1a8/PU4vYugH43M5RVspxicPPTqOYf1CuY/Di88dpq9sXB6mL7Xxdbd1VA9wDop2turTtg/G358yxrpQ3RsU7ct60T6sFveJqbvEtKLvb/s74wyKOru0faUOYru4LnbHMRw++ZZh+tG1cRuZJIdXx5/Zf/rGMH37ifFxvukNby5juPpb4zx2nx63cTeeGMf41ifG81RJcq0aP8w5Xr0yYay4U4yzHlgp7kWL66pKf2DCvez6A+tzpW89Z3OYvvFQPT7ZeGTcjj746IPD9Hd48NIw/V0fHbfjSbL0wCPj9EvjGJYvj7/f1+r+5mhrvI++Nj6fR8U+9if83bVrxYVxvaj3u0V/8/TuuJ29tlePT65MmA8bqeY2Hi7G5Endp1Vj4uo+canXnd7a0vhcXFgf5/GO40s7f3jCtduXLg7TWzEmbvvjtnzKuD7FOKsal7eDYmywPG7jkqQvF3WmirHKvyiHo9T3YHvF3EPVpW0XferV3bpPvFpc31eKeYMnimcCU9qGK9vj+49qbqOae3jqxvz3N29dGx9ndV8wZX6keq6wdzBh4D2wiGcvTxXn6sbeOMbqmcSUGLcnzMmNVNfd2kHdNlRxbhflcG1tfK6rckomzJcVk93VmLr6flKfi3mfEVXlmNTn4qRjmFJn67nLcX+yiGu3nl8trs0FPDOoVPVp3r4gSR5bGc+nXSx+N1GV44UJz2ar32ZUz8qq311cLerslN88XC/OxWuL++Wni2fgU67tRTxjnlf1XKE639W5fv7FYuCf5OLaC8bpL3jRML16VjelmKvL+3pxPh//zfE80hSHfXxvUN2vVr+7qJ73TfntR9V3z/ssbcqzvKqdrMZp1Rhpkvd/p/nzAAA4Id6AA3AOVYtvALj3VYtjAACA869afAPAva9cfAMAAAAAwH3DAhwAAAAAAAAAAAAAAAAYsAAHAAAAAAAAAAAAAAAABlbOOgAAAAAAAAAAAAAAgNOytLx81iEAcA/yBhwAAAAAAAAAAAAAAAAYsAAHAAAAAAAAAAAAAAAABizAAQAAAAAAAAAAAAAAgIGVsw4AzqvW2mqSP5LkXZI8mORykp7kqSRPJvnFJK/pvR+eWZAAAAAAAAAAAAAAAMCJswCHe0JrrSV5VZI/cYePfEHv/ZUL2M9Wkj+f5JOSvH+S9eIrN1pr/y7JNyX53t773rwxAAAAAAAAAAAAAAAA58vSWQcAE31K7rz4ZiFaa38xyRuSfPOtfVWLb5JkK8mHJfnOJK9trX3UyUUIAAAAAAAAAAAAAACcBQtwOPdaay9M8iUnmP9aa+17knxrkkfmyOqFSb6/tfa1t97YAwAAAAAAAAAAAAAAPAusnHUAMMHXJnngJDJura0k+e4kozfX7Cf55SRPJGm5uUjnXXPn6+dTb6X9tcVFCgAAAAAAAAAAAABw+lpr757kDyd5xyQXk+wkeSzJLyb52d77/hmGd0+79bKK90zy+3LzN/OHSZ5K8itJ/kPv/coZhscxFuBwrrXWPiFvuzjmKIt9c9PfzJ0X3/xEbr555//qve8ci2sryUck+Zwk7zfju3+1tfYjvff/fYGxAgAAAAAAAAAAAACcuNbai5J8RpL/NjcX3tzJ1dba9yX56t77T51KcAOttXdO8usnkPUn9d6/ZREZtdYuJnlFkr+amwub7uSgtfajuflCi+/pvfdF7J+7t8iFDLBQrbVHknz1sc1ft8D83yHJP7hD8hcm+S977993fPFNkvTeb/TevyfJB+bmIp1Zvry1trGYaAEAAAAAAAAAAAAATlZrbam19veS/HKSv53x4pskuZTkv0vyk621b2utXT7pGO9lrbX/KskvJfnKjBffJDdfuPLyJN+V5NWttXc74fAoWIDDefaVSZ572/9/J8nfXWD+H5fkwozt39R7//ze+1GVQe/9sPf+OUm+bUby85N86JwxAgAAAAAAAAAAAACcuNbaZpLvS/LFSTbvIotPTPL/ttZ+30IDe5Zorf2DJP8iyQvu4uvvn5uLnD5ysVHxTKycdQAwS2vtI5L8hWObP6P3/nRrbVG7+bMztu0m+Xt3kdffSfIJSdaObf/oJN9/F/kBAAAAAAAAAAAAcALasncYwHGtteUk353kTgs89pO8JsnjufnWm3dPcnHG516a5F+31l7We3/jScR6L7r1VqEvuENyT/LaJL+ZZDU3y/AdZnzuUpJ/0Vr7iN77q04iTsYswOHcaa1dTPL1xzZ/f+/9uxe8q5fO2PZjvfe3PNOMeu9vbq39WG6+4ut2v/+uIgMAAAAAAAAAAAAAOD1fmNmLb57KzYUj39x7v/K7G1trq7n5QoT/Mcm7HPvOOyf531prL++9H55MuM/Im5L8uTnzeO3dfrG19mFJvmhG0lGSr0ny5b333zj2nQ/IzXL/sGPfWU/yna219+69/87dxsTdsQCH8+gfJXnxbf+/luTTT2A/s1YFvmaO/H4xb78A5/lz5Hcm/um/e/0wvfc+TH/w0vow/dJG3ezsHRwN03eL9MryUv0WpZUJnxlZWxmvjr+4sTpX/klyaX1clptryyeaniQbK+PPLBfF+PTuwTD9rdf2yhieuD7+zHLx1qwp9aGyvT8eGx4eja+bMv+9cTklydWd8WeqGBZx3a0X9b4q6yrGzbX5hy17h/O1H1WM1bWfJNt74/oy5dobKurjFNW1u7U6jvFwQpU/KvqTea+b1Ql/pWR1aXzdVMd5aX2cvlbEsDqh/anasLXiZFWlMOXNgqtFJtW1XZ3KBTTD2S92clBUyr0J9a3ax1LGB1J9/7C4JpL5r4udoi3fn3Dx3ijamOo4K/tFOz2l314q6vW87c+UGNaL63+jGisWfd561VCnbh+q8e5G8f22v13G0PZuDNOXdq8W+9gd76DX/Xqv8jg64Tm+Cfn33Z1xepFHP9ifK/8kycF4TH20Mz6X1XH2/Xpcn6PifC6Nr5vDx357mN7WNsoQli49NExf2dgapl9aH799vRXHkCRZHt8r9rXxPo5WxzGm1zG0G+Pz3Q6L+5OinW1Hxfer9GTua7e6bg6vPFHnUV27e+P0o6tPjtOr6y7JwfXxPvavj9vqw53xtdmr63KCVvUnxXWxOWFcXw1h1paqseD4+9uHxZh8aTlPH4zr5FrR724W5XShmH9Zf2A8H5ckqxfG7cvqxXH6UnGvOuUvRa5sHH95+NtanjO9H9Ztw9GN8fij7NOK9mNpQn+zfFC0H6vjtn5peTxWXK3a6SSbq+M4H1m7UGQwPhdp4/rQi/4uSfpS0a8W/UXbuz5O33+6jKHtjdvJdm3czrbDYgw0YTxbqepkVafbyoR56mp8slzVh3Eb14s6nSRZKj5T1LlqfNFXxtdESz0OK2Os6mxRH5aqY0yyXJyLzeJcrk05F4WjjPuLau7hyaLPrO75k+Ri8Rxqdcq4fODyVnHdTXCxeL5TzbVvTOl3FzA3ObJbzOFMOVdVDNX8bDW/8tbt+lxVz6mqubB5nzkkycNFv/rQZjGOK8pxdcI8UjUPXeVxdXf+OcOnd8bnqzoXO8W5mDK3Wn3m2pzP4q4W9a16VnfzM+NyuFE8g5r3eeEiVM/B5p0HT+o53GpudMrzvuq55eaN4jl61QZOeF54/WIxDitU5/vKjfn7vKpOVsf5VNGWn0adXYTNok+ryuHy1rgvqNrIpH7ucLkYn1TPVqb0/VV/UPUFj90ofhsyYXxT1ZnqNypVnb5S1Nkpv/2ojmPe33ZU/VmS9OrZa1HnDvbvjWsTgLfXWnvPJJ89I+nXk/yp3vvrjif03veTfHdr7Ydz8805H37sIx+U5FOT/K8LDvdu7Pbe//1Z7Li1tpXkG5O3+4HRTpKP6b3/0Kzv3Yr3w1tr/zDJ5x5LfjTJVyX5rxccLgXvT+Ncaa29LMmnHdv8ub333zyJ3c3Ydm2O/GY9sTsPKzYBAAAAgBNQLb4B4N5XLr4BAAAAgGeH/zl5u7+wcj3Jn561+OZ2vffrST4myS/MSP7C1trFxYR4z/qbeduXU/yuT77T4pvb9d4/L8k3z0j6uFu/vecUWYDDudFaW0/yj/O29fKnc/O1WifhzTO2PTJHfs+Zse1Nc+QHAAAAAAAAAAAAAHBiWmv/RZKXz0j6h733X5qSR+/9RpK/NiPp4SSfPEd497TW2maSz5iR9MO993/6DLL6rCRvmbH9c+4qMO6aBTicJ5+b5N1u+/9hbq7sO6k/I/lTM7b90Tnye/8Z287kVWUAAAAAAAAAAAAAABPMWiDzRJL/5Zlk0nt/dZJ/NSNp1sKc+8WfS/LcGdtf+Uwy6b1fSfIVM5L+TGvtHe8iLu6SBTicC62190jy2cc2f2Xv/WdPcLffPWPbe7XW3vOZZtRae58ks773Xc84KgAAAAAAAAAAAACAE9ZaW0nycTOSvuPWW22eqW+cse0P3vqt9f3ov5mx7ed77z95F3n9k9x8wcXtlpJ8wl3kxV2yAIcz11pbTvJNSVZv2/z6JJ9/wrv+niS/djycJF/bWtuYmklrbSvJ181I+sHe+3+cIz4AAAAAAAAAAAAAgJPyAUkemrF91osOpvjBJNsztn/kXeZ3z2qtrSX5kzOS7qpse+9vSfJjM5Luu7I9SytnHQAk+cwk73ds26f13q+f5E577wettb+c5FV522vhA5P8QGvtE3vvbxzl0Vp7UZLvyNvH/0SST11ctGOttQ9cVF4f/BU/uqisAAAAAAAAAAAAAIDz60NmbLuR5NV3k1nvfae19hNJXn4s6U8m+eK7yfMe9v5JtmZs/5E58vyRJB98bNsfb62t9t7358iXiSzA4Uy11l6S5AuPbf7O3vsPncb+e+8/3lr7C0m+PW97Pbw8yS+31r4tN1di/sfcXFTTkjyS5L2SfHSST8zbN4yPJ/mw3vtvnXD4t/uJU9wXAAAAAAAAAAAAAHDvO/4SgiT52TkXc/xU3n4BzvvMkd+9albZHiT5mTny/KkZ2zaS/KEkPzdHvkxkAQ5n7RvztgtYnsrNN+Kcmt77d7bWfiPJtyZ5l9uSLiX59Fv/pvqhJH+t9/7bCwwRAAAAAAAAAAAAAGDR/siMbf9pzjx/fsa2B1tr79R7/405855ba+1CkucmeTg33/bzZJK3nsAbZGaV7Wt77ztz5DmrbJPkPWMBzqlYOusAuH+11l6Rm68Tu91n997fdNqx9N7/fZJ3z8032vxIbq4unOqpJP8kyct673/a4hsAAAAAAAAAAAAA4Dxrra0ledGMpF+bM+vX3mH7S+bMdx6XW2vf1Fr75STXkvx6br6J5heTvCnJXmvtl2995i+11i4uYJ+/f8a2ucr21u/sr89IOsuyva94Aw5norX2/CRfdmzzj+fmG3HO0n6SK0l2M/36uJTkDyR579baz/Xet08qOAAAAAAAAAAAAADm05a9wwByc/HNrIth3pcR3On77zxnvvN4MMlfKT7zLrf+/ZUkX9Va+8YkX957f+Nd7vOdZ2xbxIsefifJSyfsixNgAQ5n5WtysyH7XXtJPrn33s8imNbaRyX5ysxeaVhZTvInbv37/Nba3+q9f/si45vgZQvM6ycWmBcAAAAAAAAAAAAA3Bdaax+4qLx6769eVF538Nw7bH/znPne6ft32t95dDnJ307ySa21V/Te/8+7yGPW8c5btsnNN/YcX4BzL5XtPc0CHE5da+1jk3zMsc1f0nt/zRnF82VJ/tYdkl+d5P9J8vNJnkjSkjyc5D2T/KkkH3Ds848m+aettQ9K8im996MTCfqYRXawH/KV/3ZRWQEAAAAAAAAAAADA/WSRfwi/LTCvWR6+w/Yr82Taez9srV1PcuFY0iPz5HtGHknyva21L+69f+7UL7XWtpKsz0iaq2xveXrGtnuxbO9JFuBwqlprD+bm229u9ytJvvgMwklr7X/K7MU3P5ebC2h+6g5f/a4kn9dae/8kX5+bC3Ju91eTHCT564uKFQAAAAAAAAAAAABgQS7eYfu1BeQ9awHO8f+fhhtJ/m2Sf5PkF5L8UpInc3MRy1aSh5K8W5I/luTj8/Zvlvldf7+19ljv/asm7veky/a4syjb+9LSWQfAfefLkzzv2LZP7b3vnnYgrbWPzM1Xgx33g0k+cLD45j/rvf9kbr4F51/OSP7U1trxN/0AAAAAAAAAAAAAAJy11TtsP1hA3vsztq0tIN8pjpL837m5oObh3vtH9t6/tPf+g7331/be39p7P+i9P917/43e+w/33j8vybsm+Zgkv3OHfL+itfbBE2N4tpbtfc8CHE5Na+3lST7p2OZv6b3/mzOIpSX5ihlJv5bkE3rvO1PzuvXZj0/y2hnJX9pac50BAAAAAAAAAAAAAOfJ8h22Hy4g71l5rCwg31Lv/Q299w/rvf/zZ/KSiH7Tv0jyHkl+bMZHWpIvu/U79MqzsmxR0JyS1tpWkm84tvmxzH4DzWn40NxcpXjcK3vvz/jVXr33a621z0/y7ceSfn+Sj8zNt+oAAAAAAAAAAAAAAM9eLzvrAJ6BO72NZRFrDGblMevNLedO7/2trbWPTvLjSf7QseT3TfJxSf6PIhtl+yxlAQ6n5f2SvOTYtm9P8tLW2ksXkP8LW2sfMGP7a3rvT8/Y/uEztm0n+e45YvieJDtJNo5t/9BYgAMAAAAAAAAAAAAAz2q991efdQzPwJ3eDrO2gLxn5TH5bTRnrfd+pbX2aUl+dEbyx6ZegKNsn6UswOG0zHrV1mfd+rcIr7j177gPSfKqGdvfZ8a2n+m979xtAL337dbazyT5Y8eS3utu8zwLv/zqXximHx3sDdM3HnreMH1lbbWMoXozW++9zGNkeXmpjmFpHMPq+rj5XN8cp1ffPzo4GqZPyWPjwrisL24Ux7BSl9PFjfE+loty3N670wLfm97ydD0e2NkeL9o9OhrXl6Uixur7SXKwPz5f1fk8Kur03va4nJJk5/r42lyacD5HFnHdLK+M06trfxHnamXtTm91vGm9qNNV+7O0POXNkmPLxblaL679SfsoyvKRi+Mx/uba/DHsTWjn5rFZnOskeXBzfL6f+8D6MP2RrXE5PXphnH5xQjlWl95Scd1sFPWpqgtJslpde8Wld1B8YHdCXdg/Gn9mp8jjRtFO39iv3+x6cDjO47Aoh92D8T6q7yfJTpVHUdbVdTflury2M+6TqvNdxliV84S2vjKl3s8bw9qEfnPkUjFOe+fnXKjzKNrBzdVx+qWiv9larY9xa/XiMP3ixuVh+saF8blam9DvrlTjkyq92EX1/XZUty/tcDyebYfjcV7bvT5MXzqob3Pb0fjabnvbw/S+e6NIr2Poe+PP9KIsl9aO/y2Mt9U26+smWw+OY1gf53G0XIwllyaMoZbG11ZfGR9nqhjahHH9wfg+rKovqepTMa9Q7X/SPnrRpxVji5WiPiUT6mxR7w+LfSzdmPX3ZN7W8oXxPlYvbY3TL2yW+6j0ou9eKe7rezEIOpwwTlu6Nm5Hd4oYl9s4hrWlcfpqMSa/mcf4M5vF2GH14vja3niorrPrxf3NZpHH+kPjNnD9wUtlDBdf8Nxh+tojDw/Tly48ME6/NG7Hb35oPAZa2hgfZ9WftJV67vNoY1xWfa3os4q2vFdtYJK+Nm4f+uq4fSj7vGLIvD9hTH1YtA/LS+N77vXNcXpbrfubcoy0Oh4DVX3alH65UvbLhaPl+jlvXx23H/OOTw6X6uvmsKhU+0V9qWrczkFdJ7eLe+aq3rc2LsdFONib75772t64Tj9+o/4DmleKeYNqfuTJYr6/mpdI6vmN6r6+mqvanjA+qVT35FvVPf2Euc+1Yl6wSq/ud6tynDL/Mu/8STU3er14BpUkV4p6fdLz2EmyvTeuU9eK46jKYXXC/MlqcS86ZR5oHEP9/eoZUJV+uD+uk1Paj6vFZ6rr/4lr476/OtcHE+rbQRHD4YQ+bWTK8GSlaMOq51xV+zNl/rUqy3lVMd40nt+o5njnnadOkjdeGe+jKsvqWX11TUzpj6pr78Gt8ViwimF3Ql1YmbPPmzc9qfv27f3xuayevVS//Ziieh5Y3cdVzySTZL8Yj1ZzONW1P+VczPusrEqvrqsbE+ps9VudKo8qxqovSZJenO/qNzIHRYzVb0sAOHVX77C9nvivzcqjfgh2jvTe/21r7UeTfNCxpA9rrS333kcdn7J9lpp/dh/uTbOe9r55AfnOyuM5C8gXAAAAAACAU1YtvgEAAACAe9gTd9g+4a9e3VlrbSPJrL9Kc6f9nWc/MGPbQ0n+wOhLvfe9JNdmJM1VtoM87sWyvSdZgMP9ataff6j/dFdtVh6uMwAAAAAAAAAAAADgPHnTHbY/b8587/T9O+3vPPuZO2x/hwnfnXW885btnfK4F8v2njT/Oyjh3vR4knc9tm3WW3GeqVl5PLaAfAEAAAAAAAAAAABYgLbkb6tDkt9Jspu3f1vNi+fM907f//U58z0Lb7nD9kcnfPfX8/ZvypmrbFtry0ne8Q774hToPTgVvfdX9d7bIv7dYRdfcIfPv+oOn5/VGL53a+2ur4lbDdr7zEiyAAcAAAAAAAAAAAAAODd67z3Ja2ckvcucWb/0Dtt/bc58z5O1CZ/51Rnb5i3bd06yOnFfnAALcLhfzXod2MNJ/sQceX5IkgdnbP+pOfIEAAAAAAAAAAAAADgJPztj23vOmed7z9j2W733x+fM9yzc6U03T0/47qyyfWFr7eE54plVtknyc3PkyTNgAQ73qx++w/ZXttbu9JadO7r15pwvvEPyv3qm+QEAAAAAAAAAAAAAnLCfnLGouwopAAAgAElEQVTt3Vtr/z97dx6u2XbXBf673veMNdwhNxOkGRMUBASMtCShGRqUBDuKAtIYEGhUDOAADt1G+wEVsUXTaD9AmrlFHIIRNAI2NkMUZNIQ4AECYnhCBgPJvXWnqjrzu/qPKjVW3rN+u+o9VefUrc/neeqP+6691/7ttddea+21z7r7/hXyfMHE49wNnn/M72+ZsO9x5/zCW4wlWV62Dyf5tRXy5CZYgMO96meS/MqS3z8+xy+kGfmbWd6g/VKSn7+F/AAAAAAAAAAAAAAAbqcfXPLbPMkn30pmrbVnZvlXWpYd527w0iW/7Sb55Qn7/kKS31zy+6esEM+yfX+o995XyJObYAEO96TrjcxfOib5L7fWvqW1dqHKp7V2X2vtO5L8uWM2eYUGDQAAAAAAAAAAAAA4a3rvb0zypiVJn3WLWf6hJO3GwyT53lvM79S01j4uycctSfrR3vt+tf/1vyFfdt6f0Vqb30I8H5bkQ5ckvfZm8+LWWYDDPav3/k+TfN8xyV+Y5K2ttVe21l7cWnvv1tpWa227tfac1tqnttb+TpK3JvncY/J4be/9n9+O2AEAAAAAAAAAAAAATsB3Lvnt01pr73MzmbTWWpIvWZL0ut77224pslPSWrs/yTcck7ysvI6zbNtnJ/nMmw4q+dIlv11O4u/V7yALcLjX/aEkP3lM2gNJvjzJv0zy9iQ7Sa4meVuuLdz500nuO2bfn0jy2ScaKQAAAAAAAAAAAADAyfqmJDd+0WU9yVfdZD5fkOSDl/z+dVMzaK29ubXWb/j35pvY/w+01s5P3f6YPJ6W5F9k+ddmfj3JP7qJ7P51kl9Y8vtfba1t3ERMvzXJ/7Ik6dt771duIh5WZAEO97Te+9Ukn5Lk759gtt+R5MXX8wYAAAAAAAAAAAAAOJN67/8pybctSfojrbVJX2pprf2WJP/nkqRfSPLPVgjvZn1Fkre21r66tfbbb2bHds3vT/LzSf6HYzb7k733g6l59t57li9k+qAsL69lcZ1L8g9ybVHUu9tN8renxsLJsACHe17v/Yne+x9J8vuT/PQKWf10kt/fe/+83vsTJxMdAAAAAAAAAAAAAMBt9b8nubTk97/fWvvs0Y6ttY9K8kNJ7l+S/Kd674sTiO9mPJjkLyb5udbam1prr2qtvby19qLW2vu11h5sra211i601t63tfZ7Wmt/Ncmv5Npioecck+/X9N7/xc0G03t/da59CedGX9Jae2Vrbe24fVtrT0/yfUmevyT5b/be33Kz8bCaYy8WnGF/Zclvr1s10977a5O8trX2O5J8RpLfleR3JrnvmF2eSPLvk/xUktf03n9m1RgAAAAAAAAAAAAAAO6k3vvDrbUvTPI9NyRtJvmHrbXPTfKNSX4yycNJLib5iCQvS/L5ec+vsyTJ1/bef+S2BT3NByb5EyeQz9cm+d9W2P/zk7whyQM3/P7lSV7cWvvaXFvE9LZcK8sPyrWPS/zpJE9bkt9PJfnrK8TDLbIAh7tO7/0rb3P+P5PkZ5JrnxLLtYbugfzXVZmPJ3ksyWPXPwsGAAAAAAAAAAAAAHDX6r3/s9baK5J89ZLkl1z/N9X3JvlfTySw0/UbSf74rXz55t313t/cWvv0XPuazdYNyb8tyTffRHa/luTTe+8Hq8TErbEABwauL7B59Po/AAAAAAAAAAAAAO5ybT477RDgTOq9/43W2k6Sv51kfovZfGeSP3pKC0R+IskHJLlvxXzenuRbk/zd3vullaNK0nv/4dbaS5L8kyRPv8VsfibJp/Xe334SMXHz9B4AAAAAAAAAAAAAAEB6738nyYuSvP4md31Hks/tvX9u733v5COr9d5fnuRpSf77JH86ybfn2nlUi2iuJPnRJK9M8tIk79d7/4qTWnzzbvG9LslHJvmuJP0mdt1N8lVJXtR7f+tJxsTN8QUcAAAAAAAAAAAAAAAgSdJ7/6kkv7O19slJPifJJyd5zpJNH8u1hSuvSfLqVRfe9N7ff5X9r+dxlOTfXf/3X7TWtpM8K8n5JNtJ9nMt/seTPNF7v5kFMavE9/Ykn9Va+8okX5jkxUk+JO/5cZW9XDuH1yb59t77w3ciPsYswAH+G+/9wR84TJ8Xn11c2xh/bW6xWL1vOjw4Gqfvj9OrGJNk1tpNxXSj7Ysbw/SqHKdYWxvncWFr3MRf3Fofpm8U+SfJRnEeU/IYubA1vpZJcni4GKZXdW6+YoxJMpsdjtPPjcv6YG98nlPqYytOo4+LKbP5+Biz2ZQYxtusb47r5Nr67f8wX3W9z22Pr9V+Ud/mE8qpUuWx6n015RhHxX1zeXf1L4NeLdrqKoYqfYpLRTv5jsd3h+lVOd5f1KfNE7iW20WfVtXZKfWpOsaq12LK/tU21bW4vDtup6fEUB2jqtMnYf+oaIOK/qLaf2d/XE7J6vfmXlEnT+LeXrWdXLW+JclasU2Vx04x3q3uyyTZLcYf1TjuclGnz03oty9sjNvZg6KdPF+c50YxfkmSrWKb6lpsr63Wt69Vg7QkbVHce9VArko/CcV5tM1z4/S18bVOkr5ebzM8xsbWeINZfd8s1jeH6X1exFiV05RrVbTVafvD5KoVnVKj2+F4DNSOijq7GLcfZf77O+P8s/p90/fHMRxdeaKMoe9eHafvjc/j6PFHhumLIv8kOdod14fDnfG7jcOr43LYf/JKGcP+lfGzweFOMQ6r5niK/ZPkYFGMcaox0NH4zqn2350wftmvnrGqcfuT42u9vjW+lknSquf+Kn3C+KOyfn7cVs/Wi3mDlSOo+6RF0YbNivQ+oc+bzcZnsijSe5FetpEnYFb1adUYaLZav58kE4aCK+vVeayN54DL/FfcP0l60S9X448+r++svnF+mL5YG4+hDos2cPegHiNV77yrLKr9q3Z61pKdg+J5uIqx6G+q/mwx4b3/1aIgdov+5nIxL/Dw1XF/lCTvemI8/tgpnjUf2xmPLabMXaw6R1PNC1TnMEU1d3Gueh6e8v5mbbW+e9U55CnzJ7d7DnhKfXns6rjOrXqeU8qhup4Xi3nsSjVHnEyYHynmeCpTrmV1var+pDKlHFatk1V6L9Kr92xJ/a6tmNoo69tJ1Nnq3UdVn6bUl/3DcVtc35urv+Ou5lcfKOZnV21np6jq/ZN7q/UV1Xx/Up/Hw8XYofrbkCl/f1JM0axsPmEOeaeYC3+vB27vu7gk2Srq7Ln1cQxVnZ3ymvzgaBzDQXGe1b1ZvQ9Mbn/fXo3Bptw3VTu5ar99En9vULUv1d8TnEQMANxZvfcfTPKDSdJaeyDJe+faApbdJA/33t9xiuHdlN77TpI3n3Yc/1nv/Y1J/lySP9da20ryvkkuJjnKtYVBb72+mIgzxAIcAAAAAAAAgCWqxTcAAAAAcK/ovT+WawtDOGG9990k/+G046BmOTEAAAAAAAAAAAAAAAAMWIADAAAAAAAAAAAAAAAAAxbgAAAAAAAAAAAAAAAAwIAFOAAAAAAAAAAAAAAAADBgAQ4AAAAAAAAAAAAAAAAMWIADAAAAAAAAAAAAAAAAAxbgAAAAAAAAAAAAAAAAwMDaaQcAAAAAAAAAAAAAAHCntLlvGABw8/QeAAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADa6cdAHC2zOfjdXmztSJ93obpa+v1ur/FopfbjPRi/1kbx5gkbTbepkqvYjhcHJUxHB2O87h6tBimXymu5WPbq3cBR0UMrSjr3oty2h/nPyWGWXGtqjo5pT4eHlQxjNMP98f1YW/3oIzhYHecR1VnqzW5i6MJ5VCcx86T+8P0tY35OIYV24Ykma+Ny+HJ4r6pYjiJcqra2arOVnV+yjGqvqCqT4vD1e/dVWOYF+eYJFeqsqz6xCKGc1t1O7tRxLlZpG9vjI+xs384TD+acF/Nq7Iu01df879qDHeiHCrVMabEcFhss1bEeLVqp4v0pB7jVPfm4UHRX00Yp1Wm3P+r2C76qyTJijGsWt+SCXVutnq/uqpqXH4CxZCqR2pFMVS3ZlWKBz1ZP4HzGGp34P+t0ouSLNL7oh4b9KOifZiP773qGFMuQ1uM+4scjcflfVb0/VPauFWv50nUh+p6rVgfKn1jO21/Z7xRdS0Oi/S93XH6/jj9Wh7jGBe7V4fpR1cuD9MPr9QxHB2Mz3NRjIEOd8bPaNX+SdKLcf3BbjEOK8YffcIzVmVe3ntFn1mEcH4+y5Xq+aYIYWPF55vZhPFJ9XzTiiAPd+q5iUpZ5w7G9aW6N/v6RhlD1T60qg2s+putc2UMOdwb53G0Od5/xXb2Wh4r3lvV/kWdny8OcjRbXy2Gs2DVazFl/2p8cRLHqBRz2a1KP4H/F2B1FtU8c7V/0YxnY96yU8x3LaoYVkw/mNAnVs+BZQwnMHdRbbNXlGO1fzW3kSSXi/FH5bCIcX9vwhipqFO71Tx1NTYo+vVkwvzpig/dVTlNUc0RrzwPNeEd05T3LyNTrkWZRzHWe3TCu9WRKe9WqrnuaixZtcPVtUxO5v3LqsoYTqDer2rVdyPF0/a0GIpnrGpqoqpvJ/FutrpWVZ845d4un9OKZ6zbPY+d1PfeSdx31XvLtfXx8+paUQ71O+5a1edV7+qq/at3eUn9Pm/Se4eBt1+q7+5Ll8fP5BeK95oXNsfpU8qhqnMHK/49QHUtk3q8WV2LqpweujCem5gyBqu2efzqauOXKeW06lhx1TE5AMBZ5ws4AGdQtfgGgLvflMlNAO5ut33xDTwFlYtv4IypFt8A7+kpsfiGe0q1+AYA4F405X++CgAA8FTkaQgAAAAAAAAAAAAAAAAGLMABAAAAAAAAAAAAAACAgbXTDgAAAAAAAAAAAAAA4E5pM98wAODm6T0AAAAAAAAAAAAAAABgwAIcAAAAAAAAAAAAAAAAGLAABwAAAAAAAAAAAAAAAAbWTjsAOGtaa7MkH5DktyV5VpIHkmwkeSzJo0nemuT1vfedUwsSAAAAAAAAAAAAAAC4YyzA4VS01vptyPav9N6/8hZiWU/ywiSfmOR/TPL8JOeK3Q5baz+X5NVJvq33/sjNHhcAAAAAAAAAAAAAALg7WIDDPen6opvfneQzk3xarn3l5mas5dpCnecn+autta9P8pd777snGigAAAAAAAAAAAAAAHDqZqcdAJyS35Xk+5J8fm5+8c2NtpL82SQ/21r77SvmBQAAAAAAAAAAAAAAnDG+gAPH20vyG0nemeTJJA8meW6S+47Z/rcm+aHW2if03n/xzoQIAAAAAAAAAAAAAADcbhbgcJa8YMX933YCMfxorn0Z598k+fe994N3T2ytzZM8P8mXJHlZkvkN+z89yQ+21j60937pBOIBAAAAAAAAAAAAAABOmQU4nBm99588pUO/M8m3JPn23vt/HG3Yez9K8tNJfrq19k1JXp3kOTds9uwkfyPJF92GWAEAAAAAAAAAAAAAgDtsdtoBwCl6V5I/n+QDeu9/qVp8c6Pe+79N8ruTPLok+Y+21j7wBGIEAAAAAAAAAAAAAABOmS/gcK/6hVxbeHNllUx6729srf3FJP/3DUmzJH8gyStXyR8AAAAAAAAAAACAk9Vm89MOAYC7kC/gcE/qvT+26uKbd/MtSS4t+f1TTyh/AAAAAAAAAAAAAADgFPkCDqyo937UWvvhJJ9xQ9L7nUY8q3rkN55caf/5fPV1fW3WVtr/YO9wmD6bEOPaxmqr29fWV9t/cbgotzk6Gm9TlWN1raZch8ODo3Kbkeo8F4te57FiObQ2Tq/yT5KD3avlNsNjHOwP0w93L5d5HO7vrBTDSfwfHY72xjFUx5hvbg/TZ8X+U86hjGFjHEOlL+p7otqmKof1rXPD9JNo42bFfTFbGx+jT7h3q23KGOfjGKe044tFUR/m4xhbUdRVGzYvyjFJNopt9op2dGd/XN+OJlyredGOVjFWx6jyn7rNyH5RTlV6Up9npSqHKddi1bLcL+rDlD6vqtezIoajw/o8R6r7Lll9bFCZ0uNWdWrVOv3A9vpK+yd1nZ4XfcGU6YRZG9e5y/vjcft8Nj7Gxgk8e8zbuE6uz1Y7Riv6qyRZnxfXs6j4bTYeS/b5RhlDeXOtFe1Dr/rMur60tdXqdXWefUIDsti4UByjiHFenOeURqzYpophsbZZH6Mw68X1Xozv3TL9oCiH6vgTtKKcyvo2YVxfRVld7fn2eFw/RdsdH6W4EpkdjOvsbGPCvVu0xfNiXF7tP6Udnfdqm9XGH5Xz81l2F6vV2+o0q+efKj2py3LVazlfnzA2KOrUrMijrY3b+kl9SZHHbPv8OP3cxXEMxf5J0jfG2yzWi/bhBOZw+vpWkT6em1gU7Wz17DLlGexwxeefoyJ9c0qfuWqfNB/vX44tknosWI0dqn55wjitF2V1WPR6e0dFfSjSk6QX480qi6Ny/3H6xrzlyn4xl13kcVD0FQfFSVQxTomBa6bMwYxUcx8ncYyzYNVzmPJ+p5ojLvMo0qu2I1n9PVVfq56HV5sDmqKMccK1qN8p3v46XV2vVeclT6JOVu9mp5T1yJQYK6uWw5T75nY7LPrcpH5HXaUfFff+lLa+suo76pNQztcXdfpw/2CYPl+b8BxYPWuu+O5lyn1Xvddc9e8m5mv1taz+fqSKYdVzSJK1jdXy2CzmBbZX/BubpH6vuVekT/n7lVXfU62quu+SenyyX/xNVNWWT6kvZRu2YjtZ/T1CkuSlH7rSMQAAbidfwIGT8ZYlvz37jkcBAAAAANwxqy6+AeDsqxbfAAAAAABw77AAB07Gsv/1hzcyAAAAAAAAAAAAAADwFGABDpyM91/y2zvudBAAAAAAAAAAAAAAAMDJWzvtAOBGrbXtJM9I8lCS/SSXklzqve+damDHaK3NknzCkqT/eIdDAQAAAAAAAAAAAAAAbgMLcDgzWmvfkORjk3xolnydqbX260n+bZIfTfKa3vvDdzbCY70kybOW/P59dzoQAAAAAAAAAAAAAADg5L3HIgc4RS9P8uE5vl6+X5I/nORVSd7SWvvG1trz7lRwy7TWWpKvWJJ0lOS1dzgcAAAAAAAAAAAAAADgNvAFHO5W20n+eJLPaa19We/9m04pjpcn+eglv//j3vvb7lQQrbUXnFRez335Pz2prAAAAAAAAAAAAAAA4CnBAhzudueSfGNr7WOTfF7vvd+pA7fWPiTJ1yxJuprkFXcqjut+/A4fDwAAAAAAAAAAAAAA7hkW4HDa9nNt8cgPJfmFJG9M8nCSJ5JsJnkwyXOTvCjJpyf5qGPy+dwkjyT5stscb5KktXYxyXcnOb8k+RW997fciTgAAAAAAAAAAAAAuEmz+WlHAMBdyAIcTstPJPnWJK/uvV8+ZpuDJJeTvDXJ65L89dbaJyR5VZIPXrL9n2mtvaH3/h0nH+5/1VqbJ3n1MTH8v0n+r9t5fAAAAAAAAAAAAAAA4M6anXYA3Jt67y/svX/rYPHNcfu9LsnvSPKaYzb56tba9qrxFV6V5CVLfn9zkpf13vttPj4AAAAAAAAAAAAAAHAH+QIOd53e+05r7WVJHkryiTckPyfJlyb5W7fj2K21r0nyx5YkPZzkJb33S7fjuBO88ATz+vETzAsAAAAAAAAAAAAAAO56FuBwV+q977fW/liSX0qycUPyp+c2LMBprX1lkj+/JOmxJL+n9/7LJ33MqXrvP3FSeT3vi7/7pLICAAAAAAAAAAAAAICnhNlpBwC3qvf+piT/aEnSR7fWnn6Sx2qt/cUkX7Ek6ckkL+69v+EkjwcAAAAAAAAAAAAAAJwdFuBwt/veJb/Nkjz/pA7QWvvyJF+9JOlKkk/tvf/USR0LAAAAAAAAAAAAAAA4eyzA4W73+mN+f9ZJZN5a+1NJXrkkaSfJS3vvP3YSxwEAAAAAAAAAAAAAAM4uC3C4273zmN+fuWrGrbUvTvJ3lyTtJfm03vuPrHoMAAAAAAAAAAAAAADg7Fs77QDgNtlYZefW2hcl+bolSftJ/mDv/V+tkv9Z9uJPet4wfefgaJy+fzhMf3J3nJ4k81kbph8t+jD98tWDYfr2Vt30bW/Mh+lrRYxPu7A5TJ+38f5VOSd1Ody/vT5Mv1iUQ1UGSXJ5wvUc2TtcrLR/kuwXeVT1qSqHq/v1tXh8Z1znqhgu7473n3Lf7BRxVtdzY228JrfKP0muXNkvtxmZzccxLI7G1/rocHxPJEnv421acW8eFTEcTrh3D/bG17OKYWNz9eFbK+rkqqpySpJFce9WMVbp86I+TVGdRz+o69xIVaeTpC/G9+6qfWaVPuUYq+4/Jf+q3121HKo2cMo2U8pyVauW5WFx3y3qJqy0KMqhaocr/QRiTBHj4micfrhf37ttxSZor+h3p9TZC3vjsWA5Hr0wjuH+c+P8k2TvcLU+66ioL+fW6/FqtU3VviTj671R9DdFdboexPjxdb5W9Im9qJMHu3UMvbieVaU+KsaBRxP6klVvnLXxOfQp+c+KOlVcqz4r6vyUGIp7s8/HMewXlW5KO7y5cW6Y3qox9WI83u1rW8P0WXUdkqQoh17E0A7HdXZSDFWdq+rLohgPr9ft7Hx7/Cy5tj++/+fFMY5262e8w52iLOdFnS7q7GLCs+hB8cw83ynSi2e0/WosOaGNu399fP9fKJ7zth4c3zeb943noaZsU6Wvnx/HMN+qY6jyWLtwYZg+O39xmN62zpcxtPXxvdm2ijZwe3yMtjE+xyRZFO1H1R9V7UuK9uXaMcZ1rurTquefqreZMkYqtyliKJqfLCb8/+lacS3avOgLioescuxwLYhx+mx8jGqsOGmMVGxTDS+qx+Up45ODIpNVp5mrGLfXZ9k5KOYmi/OopoF2i5PYmzCPdLno03aLPJ4s9n/XE3tlDI8Uc8TVPPOTxVz548X7nyQ5WrFCVHVyyjx0pZoLnxfP/Scxl7Wq6t3MlLmyw8NxY13NM1XlNKUulHNZK8YwRTVmro5RxVid45RjVPPtt3tOMKnPszKlHKoplnr/2z9HXL4bWbFOVu+orh1jtfc3J1FnD4t+uXpfNyvOc8p7tKqsq3t7rZi33Jjwrr56JzDlff9I1dafm5D/ha3xmHm7KIfqHKfE8LQL42eo+4oYt4prvT6hvsyKbao8qvFwVaeTeq68iqHavyqnJDkonlcvFXM4T1R/VzHlbxqKv2mqVGOcarz7zglj6mpc/8jlcR7V30xN6StW/fuS6t58xsV6/gQA4CzzBRzudsd96eaJW82wtfaFSV6V5Many4Mkn9l7//5bzRsAAAAAAIC7R7X4BgAAAACAe4cFONztnn/M72+5lcxaa5+X5JvynotvDpN8Vu/9tbeSLwAAAAAAAAAAAAAAcPea8H17ONNeeszvb7jZjFprL0vybXnPhWmHST679/49N5snAAAAAAAAAAAAAGfMzDcMALh5eg/uWq215yb57CVJv9p7f+tN5vVZSf5e3vOeOEryOb3319xalAAAAAAAAAAAAAAAwN3OAhzuSq21jSTfnGR9SfJ33mRef/D6PvMbko6S/JHe+6tvKUgAAAAAAAAAAAAAAOApwQIc7qjW2ktaaw+tmMd2kn+Q5BOXJD+Z5OtvIq/fl+QfJ1m7IWmR5PN77//wVuMEAAAAAAAAAAAAAACeGizA4U77oiRvaa19XWvtY1pr7WZ2bq19fJLXJ/mMYzZ5Re/9kYl5vTjJP8l7fkVnkeQLeu839SUdAAAAAAAAAAAAAADgqenGr37AnXAuyZdc//efWms/kORnk/x8kl9P8sT1f+tJHkzyvCQvyrVFNx81yPe7eu9fNyWA1trHJvmeJBtLkr85yX9orX3MpLMZ+6Xe+xMnkA8AAAAAAAAAAAAAAHBKLMDhtL13ki84gXy+K8nn3MT2n5xk65i0L7r+7yR8YpLXnVBeAAAAAAAAAAAAAADAKZiddgCwoieSfGHv/bN67wenHQwAAAAAAAAAAAAAAPDUYwEOd9rrkzx8AvlcSvK1ST6s9/5tJ5AfAAAAAAAAAAAAAADAUmunHQD3lt77X2utfVWSD0/ygiQfleQjknxgkmckacfsupfk55L8dJIfS/LPe++7tz9iAAAAAAAAAAAAAADgXmcBDndc770n+fnr//6L1tpGkmcnuZBkO8lRkseSPJ7k8d774gRj+MokX3lS+QEAAAAAAAAAAAAAAE9dFuBwZvTe95O85bTjAAAAAAAAAAAAAAAAeHcW4AAAAAAAAAAAAAAA94w2n592CADchWanHQAAAAAAAAAAAAAAAACcZRbgAAAAAAAAAAAAAAAAwMDaaQcAnC0f+T73D9PPrY8/u3j14GiYPpu1MoYLG6s1TU/sHgzTn3lhs8xjcz5en3iw6MP0/+6+8TFmbVwOB0fj/JPk8v7hMP1ZFzaG6c84Ny7nC9kvY9ifj89zvbjci4w3OOp1OVQ1ai2LYfrs6qPjDOZ1fezr2+NjXLk0TF9sj++7J7JVxnBpd1wfqqKs6vTuwbgck+RNj14ttxmp7v2qzlftT5LsHdbnMVLVycevjtufJHnHY7vD9HnRTlbpU1zcGpf1k0V92i/K8fLeeP9rxxiX1dqK5bA9oS+p8tgo+oKdos7dv70+TD+3UX/K+EJxrZ5+ftzWXylivFxc62T1OnlUtC9V+pRjVKacZ2VjbVwfqvuiSj+cUA5Tymqkujd3inY2Wb0drcrhJOpLpTxGEeOU8Wxb8b6p7v2nna/Hs1VbX8Vw/7lxG7ZdPBckdVktin61utxTxswHs/E2xbA8fcXx6oQQy2OU+7dx+9RmE/7fK4fF/b8Yp7ejKr0eI+Vwr95mpBftU1FOSdI3zq90jFakV9fqTkwg5qsAACAASURBVGhVpU/SFuPxQyvqQ6r9j4pnzSn1pcijqpNVjP1wSp0db9P3x+P+Mv2gjmFR5HG0Oy6no+IYiwljg8XBeJuj/XFZl+kTnvN60dhWfXvVVtfpE8ZxxSblOeyPz2FxVI/RerHNorgWi/WirZ/Q31R1qqrTbX08Psna+PlokrXxMfreOMbM6jFS1Ub1ok6VbdwEverTirZ+NhuXUzXOm/KINy+2WfVZddbr9qUVbX07LOrs4bgd7idQZ9tBFcN4jNVnE+Y+N8bH2Fgbz12uF3OnG/P6vqmemau5zaqFqqY+79+cZ6fsT8ZHOSyq3MXNcTnsTngev1DMNVXP9PdvjuvD+QnPgdXz7E7R31Tzko+fq8dI1fxGNS9Q1bfqHKaontmreaiNtQnXorieq863VXM8U/Iv52iK/qSav53i0pXVnkUvbI37xCkxVvWhmqOpTLkW54v59IsT5rJXVc0jVe9W6/FHXQ5VHo8XbdRu1dgXTmKufGtC+zCyXg3CkmwV9XqzaMMqU+bTqvcz5d8sFPVha8I5VPOj1X2zXpTj+oR7t7pemxPGWSPVPTHlWp9bL/q04hwuFPufW6vLabYz/nuA2c7jw/R2MO4ryrmuZNLc5MiUcXsZQhVnNb9aJPcJ78mzOZ5/XTztwfExti4O0w83LpQhXCkG/+Wcf1EO1VjyiQljySeL93mXdsbp1d9MTXnPVbVBU9rqkSntLADAWWY0AwAAAAAAALBEtfgGAAAAAIB7hwU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADFuAAAAAAAAAAAAAAAADAgAU4AAAAAAAAAAAAAAAAMGABDgAAAAAAAAAAAAAAAAxYgAMAAAAAAAAAAAAAAAADa6cdAAAAAAAAAAAAAADAHTObn3YEANyFfAEHAAAAAAAAAAAAAAAABizAAQAAAAAAAAAAAAAAgAELcAAAAAAAAAAAAAAAAGDAAhwAAAAAAAAAAAAAAAAYsAAHAAAAAAAAAAAAAAAABizAAQAAAAAAAAAAAAAAgAELcAAAAAAAAAAAAAAAAGBg7bQDAM6WzbX5MP3S7sEw/f7N9WH6ufV63d+stfExtsZN17n18Tlc3BinJ8mD2+Pz2DtcDNO3i/PcmtflcOWgOsbGMP2BrfF5Xui7ZQzzK48M0zc3zw/T2+H+MH02G1/LtdmEdaKLcTm1w71xDLtPDtP72rguJEnfqMphXNbzK4fD9Pu3LpYx3Lc1rg+z3SeG6a2Py6lv1EOGD/6g9x6mr83G9/b86qXxAeabZQx9bbxNL+pcW4yvReXyom5fHt4ZH6NqHzbXxuW4vVbfN9v7jw/T+/r2OIM2PsZ+q+vLwVEfpp8rznO2f2WY3vYulzFU+vrWMP3y2n3j/Scc42Ax3up80Z9sHI3v3UcXdRt2eX/cjlaKW7s8xz6loArF0CE7RZ9a1cekHl88uT++t6uxw5P7R2UMB0fjPNaL9uNyEePlvboNnFVteXExqnKq9k+SnYO6rFZxVNTZ+7bq+2pRVOxqvLs+H6dPGUtuTugPRu4vzvPChDH1VhHD+eK+2i76grWinJJko2qkCtW4vi3q+liNL9rezjiDo2L/Yrw7JYZSL/qKYtzeU9831ZXqxfijGp9MKYNWjS8Oimu1YozJhPOcj8tyuxi/VOPhJJlV46iqPhT3RfV8dC2G8bXoe1fH6QfjZ9G+X8ewuDJ+Vlxcfmx8jJ3xOew9PH7+ObhS1Lckh7vj8zwq0qv9d945Psck2Xl0XJaHu+N7r0pfTBin9WKMVDkq+u39Ymwwby1Xihh2ivO4cji+b+ZXxtfqsV/bz9aDxf1fxHBYPKuuFTFsnB/PSyTJbKPuD4bHuG9c39Yvju+7JGlr4zjb9niOp2+dW2n/JJnfPy7L+dF4/nVKW17p68X8STXXVZRjihg3Us/hLNbH9aUah03pb8ptVpx3LMcfE8aSVb/bjsb1qZqfnTJa7sV59Nm4z+ob43LeWhu3X0nqcVT1bFCVdfV4M6/r7JSx3shi0tUYq+ZgqufdwyJ957Dul6v3GlW/u1vs//iEuYtq/qRSDT+qZ/6kLuuLm+N2crN47q/mDZJ6LmvCFMzQlDm9qqyqObmqvkyZR6pc2hn3u5VV31kmyUZxPTeL9PVqvm7C3EgVQ5W++pWoFdNEdb98MH6OTFK+hzrafGicXs2F1xGUeVTXcz1FG1j1V9UzfyaMcYpjLIq5jWouPan7pN0JeYxU87dJ/b5uq7hvqmtZvVdNJoyJi2eLSp8yTivqTPU+L9Xc6dUJc5/F/T27Op7fWDw5Tj8q5pGqOaBrB1ntvUbbHL+77UcT8i+eDfrhavVlyjm2c+N3q2vPfM44g4vjdrhtXChjuO/cg8P08nm5aB+qdvyh7XmeLN7NXijeSzxQvL+5sj9+Zq/GWEmyPuVvdQY2ijayGr8AAJx1voADcAZVL6nuhGrxDZw15UtwOGOqP4q4E1ZdfAN32u1efAMnbeWFL0+RGOBmVItv7oRq8Q28u2rxzZ1QLb6Bs+YszOFMWaAD/9lZqLNwt5myUAn4b1V/tA1nzoQFW7fbpMV1cIZUi28AALg7WIADAAAAAAAAAAAAAAAAAxbgAAAAAAAAAAAAAAAAwMDaaQcAAAAAAAAAAAAAAHDHzOanHQEAdyFfwAEAAAAAAAAAAAAAAIABC3AAAAAAAAAAAAAAAABgwAIcAAAAAAAAAAAAAAAAGFg77QDgbtFa+6AkH5LkfZJczLUFbFeSPJzk15L8cu/90dOLEAAAAAAAAAAAAAAAuB0swOFUtNb6bcj2r/Tev/IkM2ytfUySL0zye5O814TtfzXJjyf5l0l+oPf+2EnGAwAAAAAAAAAAAAAA3HkW4MASrbWPSPLKJJ90k7t+0PV/n5fk7yX5/JONDAAAAAAAAAAAAAAAuNNmpx0AnDWttb+Q5N/l5hffAAAAAAAAAAAAAAAAT0G+gAPXtdbmSb4l46/W7Cb5jSS/meRqkgeSPDvJe93u+AAAAAAAAAAAAAAAgNNhAQ5nyQtW3P9tK+7/jVm++OYgyd9L8t1Jfrj3vnfjBq21ZyT56CS/N8lLk7zPirEAAAAAAAAAAAAAAABnhAU4nBm99588rWO31r48yRcuSfqRJF/ce//l0f6993cl+f4k399a+5NJPjW+igMAAAAAAAAAAAAAAE8JFuBwz2utfWSSv7Ek6TVJPrv3fngz+fXeF0m+9yRiAwAAAAAAAAAAAOBktdnstEMA4C6k94Dk65Ns3PDbD+cWFt8AAAAAAAAAAAAAAABPPRbgcE9rrf2BJC+84ee9JF9k8Q0AAAAAAAAAAAAAAJAka6cdAJyyv7Dkt7/Te/+PdzySM+L9H9gepv/qpcUwfXNtvK7v/q31m47pRk/bHufxrPPjGLbXW3mMBzbnw/Re7H9ufRzDbP/qMP3h2WZxhOTJ/aNh+rzV5znSW71Gsx3uj9OPDooMimMcjetbkqSPt2mLYi1dVU7zGz+QtSSEWdGdbpwfpxfl1Ne2yhiOqm1m4zrdDnbGMayP24YkubxftA/zcVmf235wmH5Y3Hj7R9WdmRwV28zauJwqVRkkSS/CXBQbzDIux6KYrzka3xd9a1zvq/tqSgizaqPi3k4RQ3lfJmmHe+U2I9U5zIsNdqtKPUF1LfYOx+Xw8NWinU6ydzi+FrOiHZ0XTf2FjfpabRQVe70o68Pis9FFt50keWBr3D5UMVZt1IWNuv2oynKrGIdd2hlf7yf3xmOLJLlYjJE25+P0d1we33dP2x7Xh6q+JXU7ul7Uhyf3x/fVs87X47RFMVq8Uozjqmt5YaPur6r+pnJxs7pv6muxXZzHrI/LYbb7+Dj96pUyhtnOOI+qvzm69BvD9MWVJ8sY+u44zqPHHxkf43B87+6889Fh+sGV3WF6kiwOiv7ksfF5Hu6MnwuOduv+ZufROs6R+ca4vu1fqWPYfnA8pm5FvZ9VDfUJ2H7mA8P0rYfuG6avn6+fLao6M18ft9WtKIdePOedRJ1dNYbD3XGdvhbDuE4tiv5k74nxM9jh7ur/X5hVy2Hviboc9i/X24wsqme0KQ84Rb9YzURtFOVwoeqX12a5XIyZL6yNz+P82vgcZsU59inPw8X446Ao66OD4r7ZqetsK45R1snHLhf5r94Oz4o2rrJWPE8nyeaDF4fp6xfG80h9Mb6W+0U5Jcm8iHPtwoVhelsf31n9qBjnnR/3V0kyWxsfY7E7nl9d7BRjsJ3x/kldH6r+qKrTVTlfC6Joy/fH/WYV43yzfr6ZPfjMcR73P7RSerbG98QUfb04j2qeacI80qKKc0Iew92LufJJc13r47Hear122eVeNz6P6rH+QjFJc35CEIeL1R6ID4p+tZp3mKKaX6lO4QRCyMGiGJcX5VDtP+X1ztWDcX9RpVeq+ZUkeXxv3E7Wc5/j9JOoL1Pmw1aNoZovq97/ViFW7zWSeu5zrSjrrfm4ndxeHz9PT7G7M66TvSjr6rY4WrH9Suo5u6NiPm5anR1frOLxKLtH4zni/QnvTi4Xz9y7VRCF9QnPolUbU82VVzaK58ikvt4bRQzV3xPsF895U5qn8+vj55uqmDaLeerq3UySzPeKZ8n7x3Ofs6NiFFX9PUKSVr73HKf3tfpZs1TFUP3txqrpSfraeNx+uDl+Rqr2X0x4179TtA+7u9V70XH+1X1xpZhfSZLLxRxO9X63GkNNeb9zbn1clgdFn1Udovq7LwCAs84XcLhntdY+PMnHLEn61jsdCwAAAE891eIbAO5+1eIbAO5+5eIbAAAAAADuGRbgcC/7n5f89u967796xyMBAAAAAAAAAAAAAADOLAtwuJe9ZMlv/+qORwEAAAAAAAAAAAAAAJxpa6cdANyotbad5BlJHkqyn+RSkku9970TPMYDST5iSdLPD/Z5dpJn5trCtYeTvOskYwIAAAAAAAAAAAAAAM4mC3A4M1pr35DkY5N8aJZ8nam19utJ/m2SH03ymt77wysc7iOXHSPJz91wzE9K8gVJPiXJ05fE9KYk/1+S70/yfb33xQoxAQAAAAAAAAAAAAAAZ9CyBQhwWl6e5MNzfL18vyR/OMmrkryltfaNrbXn3eKxPvSY39+cJK21D2ut/ViSH0zysixZfHPdc5P8iSSvTfJzrbVPu8V4AAAAAAAAAAAAAACAM8oXcLhbbSf540k+p7X2Zb33b7rJ/d93yW8Hvfe91tqnJ/mOJOduMs8PS/I9rbVXJflTvffDm9z/lrXWXnBSef2bN63yYSEAAAAAAAAAAAAAAHjqsQCHu925JN/YWvvYJJ/Xe+8T93uvJb892Vr7fUn+cVa7N16e5ANba//THVyE8+N36DgAAAAAAAAAAAAAAHDPsQCH07afa4tHfijJLyR5Y5KHkzyRZDPJg0mem+RFST49yUcdk8/nJnkkyZdNPO6DS35bT/L389/eF4fXf/vuJD+X5J1Jzid5vySfkmtf4fmAJXl9SpK/meTPTowHAAAAAAAAAAAAgDthNj/tCAC4C1mAw2n5iSTfmuTVvffLx2xzkORykrcmeV2Sv95a+4Qkr0rywUu2/zOttTf03r9jwvE3l/x28Yb//sUkn9l7f+MNv+8luZTkDa21r03y15L8+SX5fXlr7V/13n9gQjwAAAAAAAAAAAAAAMAZNTvtALg39d5f2Hv/1sHim+P2e12S35HkNcds8tWtte0JWVWLz34xycctWXxzYzx7vfe/kOQvH7PJV0yIBQAAAAAAAAAAAAAAOMN8AYe7Tu99p7X2siQPJfnEG5Kfk+RLk/ytIpuDIu1lvfdLNxHWV1+P5ZNu+P0FrbWP673/m5vI61a88ATz+vETzAsAAAAAAAAAAAAAAO56FuBwV+q977fW/liSX0qycUPyp6degLM/SHt17/3nbjKe3lp7RZKfWpL8aUlu6wKc3vtPnFReP/prj5xUVgAAAAAAAAAAAAAA8JQwO+0A4Fb13t+U5B8tSfro1trTi90fG6R98y3G89NJli3c+fhbyQ8AAAAAAAAAAAAAADgbLMDhbve9S36bJXl+sd/Dx/y+n+VfsZlq2ZduPrK1trlCngAAAAAAAAAAAAAAwCmyAIe73euP+f1ZxX5vP+b3N/be91aI52eX/DZLUn2RBwAAAAAAAAAAAAAAOKMswOFu985jfn9msd+vHfP7pRViSZJHjvn9oRXzBQAAAAAAAAAAAAAATsnaaQcAt8lGkf7GY36/uuJxrxzz+4UV871jDhaLYfr7P7A93v+orxzD/Zvjpun8+nyYfnFzvLbw8v74HJPkkZ2jYXpr4/3nRXpmW8PkrWr/JLM2LofDxfhavP1wfZi+mFfr2OrzfPqF8bX85Yd3h+nnN8bnmCRHvahzRYxv2xnH8OZ37JQxPPvCOM6fffvl8f73j+vD+uzxMobdo0eH6fuH43p/VNSXD3lmXSm31sb33ntf3BymP3L1YJj+nPvGTfvOQd3+VG3cxnx8Dltr43J4xrl6aLV/ND5GVdLn+7jOzi4/UcbQ9o/rrq6nH42vxWynqJMPvX8Zw2xtXO9nu48N09cefdswffHob5YxtM1xDLkwXj97/vz+eP9e1LdzD473TzJ//Li1xtfMro7v/fd62vsO0w/OnS9jqPqTi0VbXe9f/z8BzrdxnVysjduHqwfja7E/YfzywNb4PB8aN3HZXYzv7ku747FHUrcP67PxFruH43OYMo6bFYOg9WJwUPUVm/NxjEUznSS5ejAuyyq9irEaayb1tbivuG+qsWbVbyfJbxb96q88PO4LHtwejxWrc0yS9eKCHRyN782nnxs/e/zmlXqsmNw3TH3nlfEHUN/r4vsN0w/Oj6/FbjEGS5KnP29c1o/ujK/lhY3x+GNRjZcn2Czui71qrDkhhKefG5dDdYyHr4775fd/4FwZw69fHteHqs+r7psp7WzVju4U995sfXytdibUh+3ielc91rkihsoDB0+W21RjoLZfPMcV47S0CeewO45z8fhx/4+W6+k743a4X63H9aXZlHZyEMPhuP1Jkl6cx+Hl8fPw4uBwmL73WF0f2mx8vfafHE/3XXnH+FodFH3F3hPFc0GS888aj7vXtsbj2a2H7h+mb1ys27iN+8YxzIsYWtGvV9chSeb3j5+xZg+O56Kq/bOox9T9oHjeve9p4/3n43Lq68WDQZLF5sXxBuvFs2ph3BtdV7SDfVbMb1TtZJX/+niclyT7RZe1ezjeoHoWPZgwpq6eFat5yb0ixsd3x21gUs9lnSvmyqv0efXwkXpMu1HMl13ZH9+bJzFGWhTzgk8rxmllORwmixR1rmiCqmfRS8W4//J+/frqYDHul6tn+mq8W+2f1HWuupbVO4EpjzfVM9C8GFNX8wITiqFsg6oxd9VGVfknU+Ks+u7qeXa8/5THgupaVdeiqm9T3jFVbVRVZ6t3ChvlC8OkmmJZq+psGeOE9zuz8bXoxbNFdW+W7/JSz31W9+7scDxubwfjZ5OkHuttbo7HMHtFn1aNLaa0cdW93aoNVrzvkvr9cHWerRhLXpgwoD1fvFeo2tGqrC/v1+O06r1DlV7N8VbtT1KPYao8qr69mo+bYsp5jDywNa4QFya8Y7qwPn5mPl+8353tjN9ZtuJaJylGkilfflTtU6vmupK0w/E75j5lPmyYwYT6Ur2D3i3mw6pxXh1B1ubjOnVfdR5FevUe/qFqTiBJPze+3kcPPTBMr/ubusOpHtOqZ/Kq779vwr0LAHCWGc1wtzvurWz1Vwq/kmTZLNv4r7Nqx70NX/XLOgAAAAAAANxh1eIbAAAAAADuHRbgcLd7/jG/v2W0U+99keQnliTVn/wYO27/h1fMFwAAAAAAAAAAAAAAOCXj72jC2ffSY35/w4R9fyDJ777htw9qrd3Xe6++oHOcj17y25PxBRwAAAAAAAAAAACAs2E2P+0IALgL+QIOd63W2nOTfPaSpF/tvb91Qhb/NEm/4bdZkk++xXhmST5pSdK/vv7FHQAAAAAAAAAAAAAA4C5kAQ53pdbaRpJvTrK+JPk7p+TRe39zkh9ZkvTFtxjWS5O875Lff+gW8wMAAAAAAAAAAAAAAM4AC3C4o1prL2mtPbRiHttJ/kGST1yS/GSSr7+J7F655LdPaq192k3GdC7J1yxJupprsQIAAAAAAAAAAAAAAHcpC3C4074oyVtaa1/XWvuY1lq7mZ1bax+f5PVJPuOYTV7Re39kan699+9P8mNLkr6ltfYRE2NaT/L/JPktS5K/off+rqnxAAAAAAAAAAAAAAAAZ8/aaQfAPelcki+5/u8/tdZ+IMnPJvn5JL+e5Inr/9aTPJjkeUlelGuLbj5qkO939d6/7hbi+RO5tqhn891+eyjJ61prX5rkH/be+7IdW2vPS/KqJJ+8JPmtSf6PW4gHAAAAAAAAAAAAAAA4QyzA4bS9d5IvOIF8vivJ59zKjr33X7y+0Oabb0h6IMl3JnlFa+27c22R0LuSnE/yvklenORTk2wsyXY3yR+8ma/xAAAAAAAAAAAAAAAAZ5MFONztnkjyZb33b1slk977t7TWnp3kry1J/m3X/011Jckf7r3/+1ViAgAAAAAAAAAAAAAAzobZaQfAPef1SR4+gXwuJfnaJB+26uKb/6z3/lXJ/8/evQd9lt91gX+f33Pv63TPJTOZZHIlBEIIArIJEgKurG5tgsLKVVyjIEgh62XXW8kuUAZjUdZaq2wJCSxEDWUpWkpkjUiEFUmCRpBcTDC3mUkmc+/b05fn/t0/urMOT379/Zzu39PP0z39elVN1fT5nvM9n3PO93xvp7/9yxuTXJwhm08m+crW2s/vRUwAAAAAAAAAAAAAAMDBswCHfdVa+2tJ7knyqiR/KslPJHlvkieStM6h60n+fZIfS/KtSe5vrf351tqn9ji+t+Xyr928PcnWNRz6WJI/l+QLW2vv38uYAAAAAAAAAAAAAACAgzV/0AFw+2mttSTvv/Lf/28YhsUk9yY5kmQlyXaSM0nOJjnbWtvZp/geSvIdwzD8hSTfmORrknxRkvuuxHYhl3/F57Ekv5bkl5L8v6219f2IDwAAAAAAAAAAAAAA2F8W4HDTaK1tJHn4oOP4rNbao0n+ryv/AQAAAAAAAAAAAAAAtykLcAAAAAAAAAAAAACA28YwmRx0CADcgrQeAAAAAAAAAAAAAAAA0GEBDgAAAAAAAAAAAAAAAHTMH3QAwM3l5MpCN31ta6ebfr5td9PvObxYxjAM/fSV+f4Oc0UGC5PiBEkOLfTXJx6b61/nsHWxm761eKSbvrD6WDc9SdaOPKebvr3TuumLc3Pd9Eub/WedJNUea1v9GCbFs3rywkYZw12H+mXqqYt1Hj2nRsRQ7XP8UP+9qmwWzzJJHjuz1k1/9Gw//chSv0tw/7HlMobNhX6Zeqx+9bqevrjVTV8u3tsk2dyu3ovi+OJZVGU+SY5vn+um7ywf76YPF/r1S4b6PuwcvrObvrHUj2Hh8Mlu+uT8U2UM85v969i866Xd9K1j/fKwdd8XlTEsnH+im7595O5u+mbxuJc2L3TTP7NWP6vF5ed20z+10X+Wm6f7QZ5e68eYJEeKF2PWvsNH1vrPMknuO7rUTf/o06e66etFDBc3++16kjy+ut5N/4ZX3NtNr7ofZ0bch0NFPbvT+s/70+f613D60mYZQ3Wvluf75bpq+1fX+/dhTJtYXcfRokyvbdd9oMrxpf57UfVPFub69+nx83X/ZK4odJvFdVbpS3P1dEL1PC8V5empi/1nOebd3dzpX8eljX4e1dji3iP9+ul8cQ+S5HwRQ6V6L9a36vyLLlJptbiGqn5K6jHYE0Wfu+rnnV6r67i7in77Hcv9cl+NZc+OqOsfPd2vq6t7Wd2Hs+v1fXjhHYe66ceLsUPVXj2y2h+b3Fe8V0myvFC0u0tFe7PRfxYPF+OnJDm5cn83/b4H+tfx+IX+sz66WNezdx66sVO7K0W7niRV07xYtGmVY4t1DKvr/TroeFG/PPczv9VNb0WfeXv1TDc9SebufVF/h2Ict31Hf1xwaeFoGcOZtf592i7ql/mib3FkxJh8qygwZ9f77faFou1fnKtjuLt4b6r7VHlsRD9tZ61/H44U739Vl1f9lyQ5tNBv86r+6MKkf69XirZgrejnJcm5oh9VjfOqMl312ZN6fFOdo+r3V9eQ1H29akxe1cNVHyxJlor5+DHz7T1rI+ahq7mFysnlfpk8NmL6dmfo53G6qD/mi3nHx4v+bjU+Surxz8nl/oUuzffTRwzJc7zoM5ftSdH2n7o0ok9dzOFU79VS0Z4cXSoe5ogYXnbX4W56NZ4e805Uz6sa91fjxGr+ZS/GolU9XM1bfvFz6j7SsaJ+qL6VbZTzSHU9W+VR9XerdvtYMYZL6m+vk6Hqx/Vj/MhT9Tx0NZZ84Hj/O1XdpvXfuyRJUcU88mT/Oh451x9LVvVP9V4m9XtzougbVGP65434Hlh1Nx87368DqzmeqiwkyRPFOao87iy+L58v5g0u79Mv91WfuHoWd4/4exVVP6waG1TPcr347jlmfrb6JlDlcbh4t+9ZqcvL/OmHu+ltYaWfQdHv3zl0oozhyfTbpCeLvt6jZ/plvhpHJsm9R/plqur3V2OLpy/W5eGp4v0/WczPVnNVyzPOQyWzz2UdL77DZ6e+T5eG/rPa3Oi3F3esF9/qR8TQFvpzm8PCHd301Y3+e1N9wwIAuNn5BRwAAAAAAACAKarFNwAAAAAA3D4swAEAAAAAAAAAAAAAAIAOC3AAAAAAAAAAAAAAAACgwwIcAAAAAAAAAAAAAAAA6LAABwAAAAAAAAAAAAAAADoswAEAAAAAAAAAAAAAAIAOC3AAAAAAAAAAAAAAAACgwwIcAAAAAAAAAAAAAAAA6Jg/um5fpwAAIABJREFU6AAAAAAAAAAAAAAAAPbNZO6gIwDgFuQXcAAAAAAAAAAAAAAAAKDDAhwAAAAAAAAAAAAAAADosAAHAAAAAAAAAAAAAAAAOizAAQAAAAAAAAAAAAAAgA4LcAAAAAAAAAAAAAAAAKDDAhwAAAAAAAAAAAAAAADosAAHAAAAAAAAAAAAAAAAOizAAQAAAAAAAAAAAAAAgI75gw4AuLkszvXX5S1M+unHlvrVyrHFet3fduun37E8102fDEN5jsqxue1u+rC+2o9h/UI3fb7t9ANoxU1Isri93t9h0r9P51s/vbrPSbK1U8fZszzfLw+L8wtlHjvpx3BksV8mVzf6z/o5R5fKGCqfOn2pm/7ce5e76Tsj7vPZ5f513rPTv46TRxa76UeKdztJFib9d6963hc3++/F5k6Rvl68VyNMhn653+oXl2xUFViSyVq//sjQv09DUX8MW0XdkKTN9Z/nenEdC8V7t3P0njKGne3NfgzF41xeOd5NP1e820ly4tCJbvpm8TjXtvo7zC8d6aZfurTRP0GS9e3+dTx1sX8fHzm31k1fqwr1COfXtrrpi8W7v7JYtzefOH3xmmLabWO7X6A2tur6o7qOdz98upu+VsSwPaKuv1SU63uKNmu56OetjygPhxb6z6uqq1eK48+t98vTGBc2+nmcW+u/N4+e6b83H3m0qMeT3H9ypZtePe/qWVfvXZIcKfoGZ4v640V3H+6mV/VPUpeHR071+0hV/+TESt1XPLrc3+di8V5U45vKmD7UZlU/FNXDxc1+eZkbMTyq3u2qz1wdX/UTx6j69TvFGGptRF1fObHSj2GuGItW9ymp+8xHinZzsygwY8rDyeI692LMPWv+i8WFVGVuteiGnRxRv5wo6peiesldh/p13PyI92alKC+VqvsxZshfhVmlV2Vybv18GcOhhX6btdCKdnOnX8e1zbrNq7RzT3XTJ0fu6KYPxTzT4UtnyxiWj9zd32HGd3vYOFfu0xYO9XdYmu29qurhJGlFe/H0pf7zrtqbR8/XY/Kq3C8V7/bx4j5V48ikrmur9mSzPEe/vVpZqJ/V3KRoj9LPo5ozHFNeqvZmvZgXuPtwv65fHTH+KbqKOVz0L44vFf3dusnLejGPXJXp7eK9GfMsKtU5qnZ1aEWfuu0kxZzcncv95324KPfrW/054jE+fqrfXlTzRNXYY8wY7GwxXq3GiUeLfv8nz/THkcmYerZfpqsx1uaITlJ1L+t+XNUnr+v6O4vnVc1VrVXz9cXxY8Ye1X1aKDKpvil8qijzSfLIuX7bfXa93zeo5njmRvTrx8zz9FRzQGPGotV3qOpZVX2k8yPavGr+tfKcot2981A9R1O1SVWZrOqHam6imhNIku0ij6cv1t8deo4WZT6p+yeniz51VR7GlNlJ8W5VferTxRzxmG+zdb+9X+aq9ubDT/bb9SS561C/rq/a5arMzfruJ8k9xbtZjfMeWe3X0//5yRF96tYfc1dt1kIRZDVHlCQnVvovzt3Fszy+VPTJR7Q3hxf611F9514sznFkxN8FWprvf8e6u6irV7b678WwUX9PbMW3+Ml60d8sxgXtUx/upu9cqt/to/fc38/jrhd204dHPtJNnxw+WsaQ4lkdOVm0q4v97+QrZz9dx3Do8+p9AAAOiF/AAQAAAAAAAJim+ge1AAAAAAC4bfgFHAAAAAAAAAAAAADg9jGpf30PAHbzCzgAAAAAAAAAAAAAAADQYQEOAAAAAAAAAAAAAAAAdFiAAwAAAAAAAAAAAAAAAB0W4AAAAAAAAAAAAAAAAEDH/EEHAD3DMCwn+eIkL0tyd5LDSTaSrCZ5JMnHk/yX1trmDTr/3Ul+V5KXJjl+ZfPZJB9L8puttSdvxHkBAAAAAAAAAAAAAICbhwU43HSGYVhJ8k1J/miSr0qyXByyNgzDbyb5lSS/kOS9rbXtGc6/mOSPJPmeJF+RZLjKrm0Yhl9P8pYk/+BGLQICAAAAAAAAAAAAAAAO1uSgA4DPGi77rlz+dZm3Jfl9qRff5Mo+r0nyV5L8uySvnSGG35Pk/Un+7yT/Ta6++CZX0l59Zd/3D8Pwldd7XgAAAAAAAAAAAAAA4OZlAQ43hWEYnpPkXyV5a5LnHlAMfyLJLyf5/Os4/OVJfmUYhj++t1EBAAAAAAAAAAAAAAAHbf6gA4BhGF6ay4tvXtzZ7XSSx5I8kcvl9niSFyU5vEcxfEeSn8zVf/HmoSQPXkl/UZLnT9lnIclPDcOw3lr72b2ICwAAAAAAAAAAAAAAOHgW4HCghmG4P8m7kjwwJfmhJG9J8vOttQ9OOXaS5GVJXpvkDUm+LsnydcTwyivnmbb45u1JfqS19uFdx7wiyV9N8m27s0vyk8MwfKC19oFrjQUAAAAAAAAAAAAAALj5WIDDgRmGYTHJP8/nLr7ZSvLmJG9urV262vGttZ0kH7ny31uHYTiZ5E8kefoaYpgk+akkK7uSdpJ8d2vtp65y7g8l+fZhGH45yU/kdy7eWcnlRTivbq21sbEAAAAAAAAAAAAAAAA3JwtwOEhvSvJlu7ZtJfm21trPXWtmrbVTSf7mNR727Ul+95TtP3S1xTe7zvnWYRjuS/LDu5K+Ipd/HednrzEeAAAAAAAAAAAAAG6gYW7uoEMA4BY0OegAuD0Nw/CFSf7clKTvvp7FNzP4S1O2fTDJX7+GPP56kg9N2f6XrysiAAAAAAAAAAAAAADgpmIBDgflzfncX2B6V2vtp/crgGEYvjLJF01JelNrbXtsPq21rVz+NZ/dXjkMw6uvNz4AAAAAAAAAAAAAAODmsHsBBNxwwzC8PMkbpiR9/z6H8m1Ttj2d5J9eR17/JMmpJCd3bf/2JO+9jvwOzJHF/rq87Z3WTZ8MQzf90EK97m+7f4os7GyUefQszi3WO21vdpOHrX4MbSius0qfjPh5y2Kf7clCN31js7/OrHjUSZKtMTt1rG5sFTHMln+SXNzc6aafL2K4UNynMTa2+jFcLM6xWb0Uqd/N9SKGKsbz6/37lCRL8/1yXdUP1fNeLa5xTHlZmOvHuDDpP4vqGse8EztLh/t5LB3rps8Vddjk4ukyhkr/SSVp/fKSIjlJWYctzvWjGNbXu+mHF/r3OUmGzUvd9Pmlfj26XPSk59bOddNfupw8un2on0fxMI4v9YM4XwS5vFW3y5vb/Qda1T+Vo4v1kKR696p6tKp/Di/U7e5adR+K21Bd5/aIOmyxqMOq9uLQQv8+TCbl23/DzdpWJMliUV6qNu+eY0vd9LkR9+mO5X79sVa1u2t1u1up4qzuU1Umx5TZueJ53nvHcje9uo/HijowSZaL6zxS5LFQ3MejS/3642jmyv5oijpoteiHnV7rj13uP9q/z2NU7VGVXj2HJFkoMjm/0a/rq/ZoacRY9KmL/XHeo6v9/seJlX6ZrdqrJNkq2psji/3ycrxo+8+O6Nc/dbFfpqp7/bxj/TJX1YFn1/vnT5KnLlZtXv8+Vfeh6mMldZldKcr9MIzpNPdV3bCV+X6MI4aaperVWq4qiGpsMWJIPl8MQKp+/86lC930trHWz38yV+axvd7Po61d7KbPFfNIba5f/yTJ5NKZfh7zxXzZTnGft/p1ZJIMm/19jhy7r5u+URTa+aq8pR5bVP32zeI+HC3q6TGqfv3FzX49Wc0BJcmhhWIOpmh3q+us+4p1PbuTYh66OL5qbxaLOjJJJtUcbmFjq+hTj2gKqv5mNZ9/rKge5s4/WcawvNyfqxq2+nXcHUt3dNM3ivKY1P3yJ4t+3KHiec+d/kwZQ5v0y20r5vxWijm9Qwv9hzVmPFyNA6t+XFXH7cV8fdV/efxC/1lW8/lJPRat5h4uFf32MfMClY+f6vdPquscU9f/dnGzq7HFfUdnmx+pxkdJPV9fjaEuFp3FB8/073NS38tLRZtYzr8U15gkx4t7VdWBS/P9Z1mNXZL6PlRPs5pDruZfkvrd/NTZ/vN8QTHPNL8H727VdlfvVZVePcskWd8q3otiHmpEcShVY+4qvSpv1X1Kks3tfpk6XswrVvNtC0UfK6nbxWrOrur3j2l3z67N1qZV9XD1blfHj1Hdh6pff/pSPY80X8RZfourvi+PeLGq+qMc1hfzI2O+1VXfXst5pmISaMx38mHW69ju9xXHzE1MivHLsFH0H4q/S7T26Y910zeePtXPP8nyxf435sXFfpu3tdafp9o5358jSpKhOMdk+Wg3fflEMY48+1gZQ+77vHofAIAD4hdwOAh/Mp/7d3vf3Vr78D7H8d9P2fbzrbV6hL7LlWN+fuQ5AADKxTcA3PrKxTcA3PKqxTcA3PqqxTcAAAAAANw+LMBhXw3DMCT5lilJb9/nOJ6f5CVTkt41Q7bTjn3plXMBAAAAAAAAAAAAAAC3KAtw2G+vTHL/lO2/uM9x/O6rbP/1GfL891fZ/mUz5AkAAAAAAAAAAAAAABwwC3DYb18zZduFJB+ftvMwDPPDMLxkGIYvHYbh5cMw3DUMw16U2y+esu3S1eIY6aNJ1qZsf9UMeQIAAAAAAAAAAAAAAAds/qAD4LbzpVO2faC11j77h2EYjiR5Y5JvSvLqJIu79t8chuG9SX4pyT9qrX3kOuJ4yZRtn3hmHNeqtdaGYfhEki/clfTi680TAAAAAAAAAAAAAAA4eH4Bh/32iinbHvzs/wzD8J1X/vx3knx1PnfxTZIsJHltkh9O8qFhGP7+MAzXusjlhVO2PXKNeUwzLY9p5wIAAAAAAAAAAAAAAG4RfgGH/fbAlG2rwzAsJPnpJH/kGvObJPmOJF8/DMO3ttb+5cjj7p6y7fFrPPc0j408154ahuE1e5XXQ0+v7lVWAAAAAAAAAAAAAADwrGABDvtmGIb5JHdNSTqf5B8k+eYZsj+W5B3DMHxXa+1nRux/csq2szOc/7POTdl25x7kW3n3PpwDAAAAAAAAAAAAAABuSxbgsJ+O5/Iv1uz2zUnu37Xt00l+Isk7kzyYywtb7k7yyiTfkOSNSRZ3HTOX5MeHYfhga+19RSxHpmw7XxwzxoUp2w7vQb4AAAAAAAAAAAAA7IXJtL/OCgB9Wg/209JVtu9efPNjST6/tfam1tr7WmtPtdY2WmuPtNbe2Vr7niSvSPIbVznHPx6G4Wrn+qyFKdu2imPG2JyybfdCIQAAAAAAAAAAAAAA4BZiAQ77acwvLv2N1tr3t9Yu9nZqrX0syddm+iKcFyb5Y8V55qZs2x4RX2VaHn5pCgAAAAAAAAAAAAAAbmEWBrCfpv06zDO9N8kPjM2stXZuGIZvT/KbSVZ2Jf/FYRje2lprVzl8K5/7Kzh78T5My6O67r3wlXuY17v3MC8AAAAAAAAAAAAAALjlWYDDftoo0n+gtXZNv0LTWvvtYRh+Jsn37kp6SZJXJnn/VQ5dz+cuwFm8lnNfxbQ81vcg367W2nv2Kq+HT53fq6wAAAAAAAAAAAAAAOBZYXLQAXBbOZvkar9I84nW2ruuM9+3XGX76zrHrE7ZdvQ6z1/lcW4P8gUAAAAAAAAAAAAAAA6IBTjsm9baVi4vwpnmV2fI+reuku+rO8c8PWXbHTPE0Mtj2rkAAAAAAAAAAAAAAIBbhAU47LdHrrL9P11vhq21luT9U5Lu6Rz22JRt915vDEUe084FAAAAAAAAAAAAAADcIizAYb994irbT82Y77Rfmbmzs/8np2x7YMYYrpbHtHMBAAAAAAAAAAAAAAC3iPmDDoDbzoeTvGHK9osz5nthyrYjnf0/OmXbC4ZhWGytbVxPAMMwLGX6Apxp57pp/fInT3fTVxbmuunHl/rVymPn1685pt0mw9BNn+snZ3Onlec4sbLQTX/hHSe66fOTfhAffOh8N31uqKvni5tnu+mHFvprLC9u7nTTq3uQJE9f7L8u1bO6uLndTV+er9eJHlnsl8lDRZld3+rfh8PF8UmyMNeP89Kh/nWeWO7f6/XtfoxJstPqct1z8vBiN31MeVgqntfRxX653i6uYa4oT9XxSV2mVor3ZqF4t48u1mV27sy0NaPPMPTzGNanNXnPyP9ivx5Pkraw1E0/fOJwN31yoThHcQ2Xg+iX62G+H+NkfbWbvni0jmFyoXgWm2vd5Ln5/nszt/p4N/3OO1/aP3+SraLNOlm8m1X9UdXDSXJ+faubXtWBVVtwfHkfhiRFFba5PVsdOkZVR+2M6J9UdVDVx6navIVJ/d5U/YvzG/0YqmuYvadYt/2VxaKtOL5Ut4lV/yTpv1d3H+3XgRsj+gaLxbu5MmMfakz9UT3v7VZ03Aun1zbLfap+VqW6ztWN+j5Uqvt0qYihererPnuSTIoYqhhPX+o/i7NFW5LUz6p6FlU9OldcQ1Lfy7q/2s9/a8S7W6lirJqTMeOGs2v957W504+hatur+1CNVZNks8ijet7V8XeszN4/qeYFDhd95mpskiSH54v5kaI/2ib96xy263q2Mlk7N9M5dk73ryFJ5u56Xn+H1ae6yRd+499105df/qpu+rC0nJ3TT3T32T7bH3vMHe/9O0LJ5Lkv6aa3p672o+PPyONkP33Y6vfEdlaO92MoxnBJMne+/yyGrf4Y7J4jd3fTdxb7Y9kkmT/9cDf95KF+eVqcm71+qJqDI0v993+r6H6sbtTt7h3VOOx8v/9QjT0WivbmyIj5k6rN2qgaveI2bI8Ygz1W3IcxbVbPiO5JHj7brycfL2Ksx0dHyxjOn+rHMCnmsp++2P/3155/fKWMoep/PHWxH+PqetGn3u7XcUndf/j0uf5nrsW5fh1XjfOec6SuZ08WfepqfrWaFxgzDqxUeVTzSGPM2ldcK47fLMY/ST12OFqMyav7MF+M+ZOk+FxX1uWnLvUr0qeKsebyiBiPFEFW85LVNYyZI6rGklWM1XfRMc+qGuedL9r2SVFH7sw4/5LUZfLOQ/258jHK73nFu7lYDMrPrNV12EoxL1g9zgeKNm25GOcdX6rLbNX/qNq8heI+jYnhcHUdy/08qnb7xXfUbd6TF/vXubLQv84nLvRjGDNXXvVPqv5sNS4Y8538RDF/8ehqv66++3C/7zBreUrqeeqFlerd7deBs34jT+rv4HsxV/7Ehf6zeMmJ5W76pa3+dV7Yg3nqs8XzPlbUDw+e6fd3k+R8EedSUV42d/oxzA3HyhiOLPYnSE4e6peHh89e6qYvvepl3fTXPK8eg33q3Gxzcu8915/b2Fms35tXP78/RnrifD/G//z+/pze5k4xn5fkT5d7AAAcHL+Aw35731W216Ogvmk9/95Xnd+csm0uyRfNEMMrr+Sx23+aIU8AAAAA4CZVLb4B4NZXLegAAAAAAOD2YQEO++3XrrL9nhnznXZ8759UfF+SaV9MvnKGGF4zZdt2kv84Q54AAAAAAAAAAAAAAMABK358GvZWa+0zwzB8MJ/7SzNffr15DsOwmORVU5Ie7MRxZhiG9yX5il1Jvz/Jj11nKL9/yrb3tdbOXGd+AAAAAAAAAAAAAOy1ydxBRwDALcgv4HAQfm7KttddWUhzPb46ydKU7b9cHPeOKdv+u2EYTlxrAMMwnEzydVOSfv5a8wIAAAAAAAAAAAAAAG4uFuBwEN6WZGfXtruSfPN15vd9U7btpF6A8/Ykbde2xSTfcx0xfPeVY5+pJfnZ68gLAAAAAAAAAAAAAAC4iViAw75rrT2Y5J9MSfqRYRiOXUtewzB8XZI/OCXpn7bWThVxfDLJ/zMl6S8Mw3DnNcRwV5K/OCXpX1y5VgAAAAAAAAAAAAAA4BZmAQ4H5QeTbO7a9kCStw/DsDQmg2EYXp7Lv6Yz7EpqSX54ZBxvmrLtZJKfHoahfD+GYZhL8tNJTkyJ4UdGxgAAAAAAAAAAAAAAANzELMDhQLTWPpzkR6ckvT7JLw3D8AW944dh+MNJfjXJfVOSf7y19sGRcbw3yd+bkvSGXF4MdKgTw+EkP3sl5t3+Xmvt18fEAAAAAAAAAAAAAAAA3NzmDzoAbms/lOSrkrxu1/avSvL+YRjemeSdST6ZZDXJXUlemeQbknzJVfJ8d5I/e41x/JkkX53khbu2f2uSrxyG4W8l+ZdJHryy/cVJ/kCSP5/keVPy++R1xAAAAAAAAAAAAAAAANykLMDhwLTWtoZh+ENJ/nWSL9+VPJ/Lvywz7ddlruZ9Sb6xtbZxjXGcGYbh65P8SpKTu5IfSPK3rvw3xtNJvr61duZaYgAAAAAAAAAAAAAAAG5ek4MOgNvblYUqX5vkH86Y1duTvLa19vh1xvGBJF+Ty79ec70+keRrWmsfnCEPAAAAAAAAAAAAAADgJmMBDgeutXa+tfZtSb4+yfuv8fB/m+RrW2vf0VpbmzGODyT5siQ/nmT7Gg7dTvJ3k3yZxTcAAAAAAAAAAAAAAPDsM3/QAcBntdbekeQdwzC8Jsnrk7w6ycuS3JlkIcmpJE/l8i/N/Jskv9ha+9Aex3A6yfcOw/DmJN+Z5H9I8qp87ruyleS3kvxCkp9qrT28l3EAAAAAAAAAAAAAAAA3DwtwuOm01t6T5D0HHMPDSX4wyQ8Ow7CQ5IEkx68kn03ycGtt86DiAwAAAAAAAAAAAOD6DJO5gw4BgFuQBThQuLLQ5uMHHQcAAAAAAAAAAAAAAHAwJgcdAAAAAAAAAAAAAAAAANzMLMABAAAAAAAAAAAAAACAjvmDDgC4uUyGoZs+10/O3KS/Q5X/GAtFEPU5dspzVHl85KkL3fTl+f76xuo+brd++pg81rf611ndx83t+j4tFM97qbgPVXp1jUmyudO/Wasb2zPFsLIwV8ZQxfl5dx3upn/B3f30Jy9sljE8cHy5m/74+Y1u+vOO9Y8/damOYWHSv5cXN/vPonpW1fGvuvdIN30vXNrsl7d7D9drmzf+4y910xdf9bpu+rDdf5Y7F86VMQzH7+mmn28L3fRjc/30neVjdQybF/s7zC12k9vWej//Vtdh2dnqJk82L/UPL7IfNvrHL7T++ZNkfq7fXV9Z6FdARxb7dVhRjY9StRdVm1rFmCRFVT+z7bn6BGPapJ5JcbN39uAi14pnUbVpY67x0Ih2sWdhrl9PHlro34cxfaSbQXWfdlr/Qqr3Zn2r3yYmdZmrzrFcPKu5Ef36qp+1UPVXq0pqRFVf9ctvtOpZj9mnepbVfaqOT+p+1pHFGz99tD5i/NEzX5TZMeObqp6sntXx5f59qsYuY1Tv1dHiWVXPOkkupr/P3NCPoRqLVvf55Epd3lbX6+voqeYuyvon9fNsRXmp2rQx7XIr6uI26d/Lqs88bK3VQVQuFeOTYhy5vXqmPMX8Sn9MvfXEI930cw8+2k1fvP8F3fSdS/05oiTZOHO+f47i+PlT/Ri3Tz9RxjDZ6D/PKo/Fz/uS/glGjcH67241hsrhO/shjOifDGf69/LEiQe66ZP11W76ykJ/fiVJqibp3Fr/PlVzelU9nCQPnemXh/Mb/fFq1a+vLI6o5C4UczCTFPPYRYhrI+5T1WdeKk7yxIX+3MXx5f78SjKu7e6p2qsx7W7V/6j63DvFPNOYPvtCq9rufpmtxmjVfVqanyvHYYdnHC9PhqIvOqIvWfX9Zx3TV2U+Gfdu9VT9sFmvIannoja3++/FmO9c1fim/BZX9VdHPIuqzFYxVM+iGieO6VNXyvFwcfzxpdnHslU9XI1F92JeYnOnOMeM7XJSj9OqMn20uNfbI+qwqtwfmvRjrKZg5keUyepxVddZxVA9q+VRk9DFGKqohvfgU335rLaK571ZDIiHEUHupJ9H1Zes+szLyyPq2eI6HjzdH9/cX3ybPbpUt3nbRaE7u97vIz14ph/j733RiW76qbX6O9fTF/vfmF9+10o3faO4z3cdqkbUyaPn+/3yp4oYX3RH/92/70gdw7niO/ilrf51VmOojRH1x6z9j6p++YK7DpUxfLIYi1bnOL3Wf1bHl+oxVjXefcEdS930qsx9/HT/G/jHTvfLY5KcKsrkc4oyd/+x/jV84PH+3EaSfPTpfv3w+Xf2n/cjq7PPUwMA3Mz8Ag4AAAAAAADAFGP+EQQAAAAAAG4PFuAAAAAAAAAAAAAAAABAhwU4AAAAAAAAAAAAAAAA0GEBDgAAAAAAAAAAAAAAAHRYgAMAAAAAAAAAAAAAAAAdFuAAAAAAAAAAAAAAAABAhwU4AAAAAAAAAAAAAAAA0DF/0AEAAAAAAAAAAAAAAOybid8wAODaaT0AAAAAAAAAAAAAAACgwwIcAAAAAAAAAAAAAAAA6LAABwAAAAAAAAAAAAAAADoswAEAAAAAAAAAAAAAAIAOC3AAAAAAAAAAAAAAAACgwwIcAAAAAAAAAAAAAAAA6LAABwAAAAAAAAAAAAAAADoswAEAAAAAAAAAAAAAAIAOC3AAAAAAAAAAAAAAAACgY/6gAwBuLnNDP31hrr9ub6lIX6hOMMJk6OdRnWJnUsewPN+/jvWt7W76QnmOYv3j9k5x/Ljr6KlinBuR/6TYpyov1XWWxyfZbv086iI3W3lK6ji3d1o3fak4SVUeL8cw27NYXije3Y3Z35vt1r8Pa1tFeSjK28qI+1SpzrGx3b+GjRHv7tIf+N7+Dk9+tJt84Tlf0E3fLGJMkur1Prp2qpvehv69XpsslTFcmlso9+k58cF3dNM/8yV/uI5h/vnd9HsP97vKW8W7feH48W76b3xitZv+bLFTvPunL22Webz+RYe76Z+61C+Tpy9tddM3d+p3t3q3Lm72+wabRXmp+w51PbmyMFfm0Y1hVLs70ynK8lD188Z0f9aLuvhQcZ+qZ32oaDOT5OTKbHXcZOiXpzH9k/niea4X5enIUr8OrMpjUvcNquddvRfzxXuVJMeXZ5v2WBpxnT1j2uVKWb/Mz1amk2RuxjHWenGKMb20s2v9uros98VJRhSX8l5Vfe6Hz671YxgTRKEaW1TvXTVmT+pYDKmbAAAgAElEQVR3r2rT7jq02E0/VbT9Rxbr97Z6Vkszjg2OLtZtajW+ObnSv47q+KXNC2UMw4V+f3Ju9fFu+s7y0X7+2/33MkmGzUvd9O2zT/czmPSfVdvov1dJsvXEI9309Yc+1k3fONe/1+3iuW766scf6qYnyerD/Wcxt9wfQ917+Fg3ff2xx8oYlu65u5u+c6m4D+sX+yeY1O9NW++Xl+p5Dyf7MUwmdf1Rlclha72fQTEPNSnmmS7vNHt7MKuqTav6ipVJUY+Omm8r2qOqHl0o6pfJwuzz1JvFs1wq+mljxhZV212lV2OwvegrLs1V11nEMGJMXo4divtQnaO6Twtzk3IMVM2VL1dzyMWjqMZ4Y4yZe+gZ882gzmO2ceJeqOqH6t0dU4dV9+roUv8cC1uzfzNYXZ/tXlZzG7N+DxhjzPil53nHlst9PvLU+W56NT45XsyfjJkjOrve73dfKuYFqvpjTD37/OMr3fSnLm5001eLazhXpCf1+1/V1S+8o/+8HzlX9PNSj3fPrtVz2T0nivKwc6z+tvKJU/0+9T2H+3k8eKbfp65iTJKLm/0y9Xtf2P828vj5fnk6s9Yv80ny6WIO5gvv7n9TOFN8M3j+sf7cRpJ86lz/Oqr3qpynHjGP9KLj/TjPFfeyqss/Vbw3d4yYe72jmB+pytPDZ/tl/v4Rdf09h/v3qeoTP36hfx/mRnwXrerJqk/90Jl+DGPKy8Nn++lHinHcExf6Zb66z0ny2Gr/Omb9LjGm61C17etb/Xu5utF/llV7dupi3ZY8Xtzrql2unFypn9W5os1796fOdNOr+1CNjwAAbnZ6MwAAAAAAAABTjPkHCAAAAAAAuD34BRwAAAAAAAAAAAAA4LYxjPhlbwDYzS/gAAAAAAAAAAAAAAAAQIcFOAAAAAAAAAAAAAAAANBhAQ4AAAAAAAAAAAAAAAB0WIADAAAAAAAAAAAAAAAAHfMHHQD0DMOwnOSLk7wsyd1JDifZSLKa5JEkH0/yX1prmwcWJAAAAAAAAAAAAAAA8KxmAQ43nWEYVpJ8U5I/muSrkiwXh6wNw/CbSX4lyS8keW9rbfsGxvedSX7yKskPtdZeeKPODQAAAAAAAAAAAAAA7L/JQQcAnzVc9l1JPpbkbUl+X+rFN7myz2uS/JUk/y7Ja29gjPcl+Zs3Kn8AAAAAAAAAAAAAAODm4xdwuCkMw/CcJH8/ydcddCyFH0tyx0EHAQAAAAAAAAAAAAAA7B8LcDhwwzC8NMm/SvLizm6nkzyW5IlcLrfHk7woyeEbHuAVwzD8j0m+cb/OBwAAAAAAAAAAAAAA3BwswOFADcNwf5J3JXlgSvJDSd6S5Odbax+ccuwkycuSvDbJG3L513OWb1Ccd+Tyr988006SyY04HwAAAAAAAAAAAAAAcPOwAIcDMwzDYpJ/ns9dfLOV5M1J3txau3S141trO0k+cuW/tw7DcDLJn0jy9A0I9/9Icu8z/vxokl9P8oduwLkAAAAAAAAAAAAAAICbiAU4HKQ3JfmyXdu2knxba+3nrjWz1tqpJH9zLwJ7pmEY/tskf3zX5v85yev3+lwAAAAAAAAAAAAA3GCTuYOOAIBb0OSgA+D2NAzDFyb5c1OSvvt6Ft/cKMMwHEryll2b/8XNFCMAAAAAAAAAAAAAAHBjWYDDQXlzPvcXmN7VWvvpgwim401JXvyMP19I8n0HFAsAAAAAAAAAAAAAAHAAdi+AgBtuGIaXJ3nDlKTv3+9YeoZh+Iokf2bX5v+ttfbwQcTDfzU39NMnQ3+HSXH8mH2qc8xqYW6S7Z1WxHBDQxh1jbPeh/pZzX6RVR7brbrPs9+H7cx2jn15FukfP7cX96G413MzFuq9WFVcXeZevPpDcR+ys9M/vsh/L+qGofVjaEP/bo+qZ4v0fgRJK+7TGHVd308fZnx3v/y5x/K+z5zrn6Rwo9ujm0b13hSq+3Tq0laZx04Rw8KML9/aVl2mjy/3h29n1/rXUdWzVR8rSZ53fLmbXvVfThTX8NFTl7rp9xxe7KYnyelLm930qj2q7uMYnz63NtPxhxZu/E+dLyz2z1E9y+NL9XRCVeaqc1THL8/Xrf+jq+vd9P2oR6vnub7df/8X5vrXeWhhtjoySdZH1EE9S8WzGFO/7BTlYb64D1vFfaxiHBPDzOVlDzqs1XtRxTiqz10Uh1nHy1UMY27zQlGoFib9m70w6V/kmNtUdU8mxTiwfOt26vZoKPZpW/02cdguzrGzXcZQnaNtFG1i8azK45Myzo3VC9309TPnu+nbF1a76YfvvzunPvjJ7j5rp/sxzC32r3PrzKlu+uaFfh8qSeaL69i60I9hcfVM/wTFs0ySYdJvE9vaxf4ptosyvVWXl53iOiZVHpPZP6lUczBVHVfVs9XxSbJQxFC1u1X/pKqHq/F0klRN91DUw/Nz/R2GnTFzXeUuXVV/tbpPY/Ko+prVWPbI4ph+fT+9uo7F+YV+/iPKQxXD5nb/Oo8u9e/TmGdR9tuLAlM9q82iL3pxs26XjxbjvM2d/nWeWO4/qzExbBYvZ1WmqxhOr/XbgqSO8+x6vw90rjjHyogx+/mNfgxPXdwo8zhoj6zONrcxRvX+V3M4lcfO9+cE9sKlorztRQxVmTu50n9vxpS36nlX/Y9qnqi6T0lypMijerc/8Hi/X1+9l0lypKhHy/tQzH1WbcGx4vxjYqie94mivIxpEw/1s8j8ev+7RzX9+tj5usxWfZjFok+8WXxjmh/RETxW9C+qZ1X106pxQ5IUXaCyzFXfJao5wzH3aaMIsroP1ZzemBiqOeK7DvW/O1T9lzEx1PNlZRZdSyMyqPqbY/rlsx4/mXVucy/+Hs+kGCsWWVTXuRcx7sl1zpB/Us8LbBbzcbPObQAA3OwswOEg/Ml87t8ffndr7cMHEcw0wzAsJPnJ/M6/HvMfk/ztg4lo/3z773reQYeQf/hbjxx0CAeu+suIANz6Zl18A8DNbz8WUwFwsKrFNwDc+qrFNwAAAAAA3D724h+Lh9GGy/+03bdMSXr7fsdS+CtJXvmMP28n+e7WWv1P4wAAAAAAAAAAAAAAAM8qFuCw316Z5P4p239xvwO5mmEYvjDJX921+f9srf3GQcQDAAAAAAAAAAAAAAAcrPmDDoDbztdM2XYhycen7TwMw3ySFyQ5nuRikqeSnGqt7dyI4IZhmCT5ySSLz9j8UJL//UacDwAAAAAAAAAAAAAAuPlZgMN++9Ip2z7QWmuf/cMwDEeSvDHJNyV5dX7nYpgk2RyG4b1JfinJP2qtfWQP4/vTSV6za9v3tdYu7OE5AAAAAAAAAAAAAACAW8jkoAPgtvOKKdse/Oz/DMPwnVf+/HeSfHU+d/FNkiwkeW2SH07yoWEY/v4wDC+eNbBhGF6Q5Ed2bf5HrbVfmDVvAAAAAAAAAAAAAADg1uUXcNhvD0zZtjoMw0KSn07yR64xv0mS70jy9cMwfGtr7V/OENtPJDnyjD+fSfJnZshv3wzDsPtXe67bM36MCAAAAAAAAAAAAAAAiAU47KNhGOaT3DUl6XySf5Dkm2fI/liSdwzD8F2ttZ+5jtj+pyS/f9fmv9xae2yGmPbTuw86AAAAAAAAAAAAAAAAeLayAIf9dDyXf7Fmt29Ocv+ubZ/O5V+keWeSB5OcS3J3klcm+YYkb0yyuOuYuSQ/PgzDB1tr7xsb1DAM9yT5W7s2/1qSt4zNAwAAAAAAAAAAAIBbxGTaX2cFgD6tB/tp6Srbdy+++bEkn99ae1Nr7X2ttadaaxuttUdaa+9srX1Pklck+Y2rnOMfD8NwtXNN87eTnHzGnzeTfE9rrV1DHgAAAAAAAAAAAAAAwLOUBTjspzG/uPQ3Wmvf31q72NuptfaxJF+b6YtwXpjkj40JaBiGNyT5ll2bf7S19qExxwMAAAAAAAAAAAAAAM9+YxZEwF7ZLNLfm+QHxmbWWjs3DMO3J/nNJCu7kv/iMAxv7f2KzTAMx5L83V2bP5rkTWNjuIl85R7m9e49zAsAAAAAAAAAAAAAAG55FuCwnzaK9B9orW1fS4attd8ehuFnknzvrqSXJHllkvd3Dv/RJPfv2vanWmtr1xLDzaC19p6DjgEAAAAAAAAAAAAAAJ6tJgcdALeVs0mu9os0n2itves6833LVba/7moHDMPwuiTfvWvz21pr/+Y6YwAAAAAAAAAAAAAAAJ6lLMBh37TWtnJ5Ec40vzpD1r91lXxfPW3nYRiWk7w1yfCMzU8l+V9niAEAAAAAAAAAAAAAAHiWsgCH/fbIVbb/p+vNsLXWkrx/StI9Vznkh5J83q5t/0tr7anrjQEAAAAAAAAAAAAAAHj2mj/oALjtfCLJK6ZsPzVjvk9P2XbnVfb9ll1//u0k/2UYhqm/mNNx95RtS1fJ58nW2sevMX8AAAAAAAAAAAAAAOAmYAEO++3DSd4wZfvFGfO9MGXbkavsO+z68+cnec+M5/+se6+S19uSvHGPzgFwS5obdle/v9Okn5y5aoc9UP00YJU+FNeYJGk7RXrrx1CcY0wIpSLG6hR7EUL5M4072/3jR92I/r2unudkqI7vn31cjCQpy+RkmOumz+3B735Wz6t+nv3ysheqenI/ytys59iHqr5sj/ajvalUMdwKMe5FHlV5OrGyMHMMmzs39t1c3y7a/RF2ir7Bwh5UcrPmMfuT2IPrmD/4+3AzeOLCxkGHkEdW12Y6fnV9q9xnaa7f9p9d3+ymH1roH780V9dxk/n+PuvF619Vo8PWiGe53d9n++lHu+lz9x/tprdz9Y9FD0sr3fSdC+e66ZPDx/oxrF8qY6jsbPTL1NZaP706/o6XPT9Pf+iTM52jFe3Rzmb/+M0L9Xu3UOyzfma1m76yero8R6Vt9d/NjUc/3U0/dOxkN32+KE9J8si/fXc3/bnPfWE3va337+N9X/B7yxiqPs65jX57dGK+X8Fc2Om/l2MsTIoYVvqflp53uH/82R/7S2UMx++f9u9f/VdzR+/opi+84OXd9MnRfnlKkuwU9cPhq/0bYJfde89zu+l3tGmfNX6n1RP9uvrYxce76W2u31ObP/VQGUP17m4//Vg3fe7Oe/v5X6rvw/bpJ7rpL/g939qP4Vw/xot39GNMkrPr/bmoJy/0y8vdh/vvzWrReXj8wno3PUkeOL7cTT+/0b+G5xzul5dTl/rHJ8nFzf4+R5f6/bB7i/v0+MW6z35ubbZ5w/Wt/vF3HVosY9jcKZ5X0eUd0R29LSzsyUzzzW+7mJq4FcrDvny/uQXm9CrVHM/2iHmqai6rKi9FNZ254rvH5Tz6+7S5fj1Z1ZHVfRqjupfVNYx5FtW0X3UdVQxzkzExFNdRxFCWyT14FnvxPJ8NMVRm/QY1pg6s7sOsMYz5PlRex4zfVqvvP2P2qWJYKHaoYqyOH5PHrG3eZMTxsz6L8j7cAu02AECPBTjst/ddZXv9dbTv+JRts/6qDgfkW191/0GHADeVF/S/5Y/yxc+dVk3ur//w8Ox/WQcAAABuJtXiGwBufdXiGwAAAAAAbh8W4LDffu0q2++ZMd9px9f/TCcAAAAAAAAAAAAAt5Vhrv9LrQAwTf073bCHWmufSfLBKUlffr15DsOwmORVU5IevN48AQAAAAAAAAAAAAAAPssCHA7Cz03Z9rorC2mux1cnWZqy/Zen7dxae2FrbZj1vyRvm5L9Q1fZ/43XeW0AAAAAAAAAAAAAAMABswCHg/C2JDu7tt2V5JuvM7/vm7JtJ1dZgAMAAAAAAAAAAAAAAHAtLMBh37XWHkzyT6Yk/cgwDMeuJa9hGL4uyR+ckvRPW2unriM8AAAAAAAAAAAAAACA38ECHA7KDybZ3LXtgSRvH4ZhaUwGwzC8PJd/TWfYldSS/PDMEQIAAAAAAAAAAAAAAMQCHA5Ia+3DSX50StLrk/zSMAxf0Dt+GIY/nORXk9w3JfnHW2sfnD1KAAAAAAAAAAAAAACAZP6gA+C29kNJvirJ63Zt/6ok7x+G4Z1J3pnkk0lWk9yV5JVJviHJl1wlz3cn+bM3IlgAAAAAAAAAAAAAAOD2ZAEOB6a1tjUMwx9K8q+TfPmu5Plc/jWc119Dlu9L8o2ttY09ChEAAAAAAAAAAAAAACCTgw6A21tr7UySr03yD2fM6u1JXttae3z2qAAAAAAAAAAAAAAAAP4rC3A4cK218621b0vy9Unef42H/9skX9ta+47W2treRwcAAAAAAAAAAAAAANzu5g86APis1to7krxjGIbXJHl9klcneVmSO5MsJDmV5Kkkn0jyb5L8YmvtQwcUbpL8syQP7tp25gDiAAAAAAAAAAAAAAAAbiALcLjptNbek+Q9Bx1HpbX2z3J5EQ4AAAAAAAAAAAAAt4rJ3EFHAMAtaHLQAQAAAAAAAAAAAAAAAMDNzAIcAAAAAAAAAAAAAAAA6LAABwAAAAAAAAAAAAAAADqG1tpBxwDcXFQKwA3xHx4+3U1f3djqpp/f2O6mf+m9R645pt0W54Zu+sZ2v4o8ujRXnuP/Y+/Owy296jrRf9cZakxSIakkxECYh4AI5mIDKiBXRMAAaitOqBC01e7WbtvhtiNg27bSardt+2iDEBXhqg04oC2igVYRlBsjIBCReUjMRJJKJTWdOmfdP6pybyzfs9Y+Z++z9z5Vn8/z1PMk6/e+a/3e+X333r/z7ixrzfjyzR9qxo9e9MhmfGVt/NP4nrtvak9Q2jXcR/de0B3j0Ep7PfSc887XNuM3fd7Xd/s4fLydw8VnLTfjxzvr+u7OMv71DQeb8e1ieXHra/rv/5IXNuOf/TMvb8YP3uchzfh7bjrUzaF3bJ21o338HzjSPseNcuw+9LzdzfjHbj/cjPe21Z7l/ra8/MJdzfjxzt942PPpa5vx685+TDP+oHN3NONJ8qmDx7rTtHzoM+31OA0Xn7WzGf+Hu45OKZP13e+cdo5JslDa19VPHjjSjC8vtOd/9AV7ujl85Pb2GAc79xcAW2X/nva95u2HV7p9dB5Pus7u3L+cLufIzmPe2OtxlOvR+2/p32/O2sPOb99rTuIeqXe/+aBz2/eak1iPF+1t30/edPd495KjmMa6PhP0ju2eR12wtzvN393a3ucu6xz/77/57g3lxOY9Yn97W3ywsy0noff8s+b72CT99fTA+7SvBR+9bfxz5LjXfthuHtC5x0qSY8fbB0bvs6jedfk+u9vPP0n/GWg7HLu9+91xvxdJxr8HmoRL97XvZ6+69HHN+DM/8FfN+Mrq+OuJ0fSOq2nsb4/rfL/77hvv2vokTgOPubD/fPO3nk8mYh6uR9M4NudhOa+47KI5uOpxJlj9wP+egz2e09Hio77IeQxOY0uzTgAAODN83qX3mXUK28MD219M9H/aNQF7HzjW7P2v0pKxy6We+S+a4QeM2/8EnN+JX3re+EVj8+D3r+sUbAEAAAAAAAAAAMBpYOv/XDUAAAAAAAAAAAAAAABsYwpwAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGpZmnQAAAAAAAAAAAAAAwNQsLM46AwC2IW/AAQAAAAAAAAAAAAAAgAYFOAAAAAAAAAAAAAAAANCgAAcAAAAAAAAAAAAAAAAaFOAAAAAAAAAAAAAAAABAgwIcAAAAAAAAAAAAAAAAaFCAAwAAAAAAAAAAAAAAAA0KcAAAAAAAAAAAAAAAAKBBAQ4AAAAAAAAAAAAAAAA0KMABAAAAAAAAAAAAAACAhqVZJwAAAABsL/t39z9OWFwozfgnD7TnX15sz3/fw5/q5nDb7s9qxg8eW+32AZPS2aWTJKt1vD5680/DKMtJcp/OefT2wyvdPsZd12ftaOdwaKV/jtzqfW4Sx81W57B/zwjXxG1wXCyWdpKTWIbeGMude4dJ5NC7v5iHbTUPOcyD3rE97rF/+PjaeB2M0Mc8XJfPFHevzMO2aA9yOuwPk7kutyc4evz0X48wbUc658gkWVkb/7rYcnQC193tYG0K56h5OA/2nhX/5b9+YjP+oc6Kmodl5IRpbIs7O5/P2h9Gc+ex/nnWujx92JYAALOnAAcAANi0Ky67aOsH+a0/HGv2czvxp561Z6z+58UjLzpn1in0PfwLmuFHT2CIR+zeNd78F26D9TgFv3/dTbNOAQAAAAAAAAAA5ooCHAAAAAAAAAAAAADgjFEWFmadAgDbkKsHAAAAAAAAAAAAAAAANCjAAQAAAAAAAAAAAAAAgAYFOAAAAAAAAAAAAAAAANCgAAcAAAAAAAAAAAAAAAAalmadALSUUnYl+ZwkD09yQZK9SY4lOZjk+iQfSfL3tdaVLRh7+V5jn5tkX5Ka5I4ktye5LskHaq2rkx4bAAAAAAAAAAAAAACYHwpwmDullN1JvjrJNyb5wiS7OrMcKaX8TZL/neQPkvzlZotiSil7kjw/yYuSPCHJzs4sh0opb0/yqiS/U2s9tplxAQAAAAAAAAAAAACA+bUw6wTgHuWEb0ny4SS/muTp6Rff5OQ0T0ryA0nenuTJmxz/m5J8MslVSZ6SfvFNkuxJ8owkv5nkI6WUKzYzNgAAAAAAAAAAAAAAML8U4DAXSikXJfmjJK9M8llTHntHKeWNOVH0c/4YXd0vyZtKKb9YSimTyQ4AAAAAAAAAAAAAAJi1pVknAKWUh+ZE8c2DG5PdnuTGJDfnxH67L8mDkuwdc+ylJG9I0npzzUqSDyb5TJKSE0U6j8j6x8+3n4x96zi5AQAAAAAAAAAAAAAA80EBDjNVSrkkydVJLh0IfyLJK5L8Xq31fQPzLiR5eJInJ3lOki9JsmuDKfy7rF98844kP5XkLbXWI6eMvSfJM5P8+ySfNzDvt5RSrq61/sYG8wEAAAAAAAAAAAAAAObMwqwT4MxVStmR5HfzT4tvjif5D0kuq7X+xFDxTZLUWtdqrX9Xa31lrfW5SS5J8n058aaaUca/KMmPrhP+sSRPrrX+3qnFNyfHPlRrfWOSJ+VEkc6Qny2lbLQgCAAAAAAAAAAAAAAAmDPegMMs/XiS/+OUtuNJvq7W+vqNdlZrvS3JT29glq9Ksneg/VW11peMOOZqkn9fSrk4yTedEr44J97K86YN5AQAAAAAAAAAAADAVlpYnHUGAGxD3oDDTJRSHpXkuwdC/2IzxTeb9NyBtqNJfnATfX1/kmMD7c/ZRF8AAAAAAAAAAAAAAMAcUYDDrPyn/NM3MF1da71qijk8bKDtz2utN2+0o1rrTUn+fCD0kA1nBQAAAAAAAAAAAAAAzJVTCyBgy5VSHpnhN8N855RTuWig7QNj9Hddki8+pe3iMfoDAAAA2FZWazu+WKaTxzh6yzAJxyYwyLhdHF1d3dL+J2E75PCnn7gzT33AOWP1sR1MYhlWa7uTtWnk0BlkHrbVPOTACWudfZb5sZBtcIMBwGlvde3MuHfo3dcv7drZjLvH4t7sDif0jouF0r7fXV7o3w879gAAYHIU4DAL35r8k29D3lFrvW7KeQw9gd41Rn93DrS1f8kAAAAwh664bOjvFUx4jHP3jtnDBd0pPqcX/6x9Y+YA28vvX3fTrFOA006v+AYAAAAAAAA4fSzMOgHOLKWUkuRrBkKvnXYuSYZ+dXL+GP3tH2i7cYz+AAAAAAAAAAAAAACAOaAAh2l7TJJLBtrfMu1EkrxroO2fjdHfEwba/nKM/gAAAAAAAAAAAAAAgDmgAIdp+6KBtruTfGRo4lLKUinlIaWUy0spjyyl7C+lTGq/fcNA2+NKKY/daEellMuTDM33+g1nBQAAAAAAAAAAAAAAzBUFOEzb5QNtf1trrff8TynlrFLKvy6l/GlOFOd8OMlfJ7kuyS1JjpRS/qyU8qOllEeOkcsbT/Z9byXJL5ZSdo3aSSllT5JfGgj9Qa31PWPkBwAAAAAAAAAAAAAAzAEFOEzbowfaPn7Pf5RSXnzy/38+yVOS7BiYfjnJk5O8LMn7SymvKaU8eKOJ1FqPJ3lhkuOnhJ6U5PdLKRf3+iil3D/Jm5N83imhzyT59o3mBAAAAAAAAAAAAAAAzJ+lWSfAGefSgbaDpZTlJFcl+YYN9reQ5AVJnltK+dpa6x9uZOZa61+UUl6Q5Nfzj4+HL07ywVLKryX5gyTvyYmimpLk/CSPS/KcJN+YZM8p3d6a5Bm11k9vcFk2rZTypEn1da+XEQEAAAAAAAAAAAAAAFGAwxSVUpaS7B8I3ZUTBTDPH6P7c5K8qZTyLbXWX9nIjLXW3yylfCLJryZ5+L1CZyf5Vyf/jeoPk3xrrfX6jeQwAe+Y8ngAAAAAAAAAAAAA21NZmHUGAGxDrh5M074M73PPzz8tvvl0kh9J8nlJLkiyM8n9kjwrySuSHBvoZzHJL5VSHr/RxGqtf5nkUTnxRpurkxzfwOx3JHl1ks+vtT57BsU3AAAAAAAAAAAAAADAFlKAwzTtXKf9klP+/78neUSt9cdrrdfUWm+ttR6rtV5fa31zrfXbkjw6ybXrjPE/SynrjdWzkuRAkqMbmOfsJA9N8rmllN2bHBcAAAAAAAAAAAAAAJhTCnCYpqURpvnJWut31loPtSaqtX44ydMyXITzwCTfvJHESilXJPlgkt9I8pVJ9m5g9sUkT0nyC0k+Xkp5wUbGBgAAAAAAAAAAAAAA5tsoBREwKSud+F8m+eFRO6u13llK+fokf5Pk1DfPfH8p5ZW11trrp5Ty00m+Z53wO5P8SZL3JvlMkpLkvCSPTfL0JE88ZfoLk7ymlPLUJN9Wa10bdXnG9PkT7OsdE+wLAAAAAAAAAAAAAAC2PQU4TNOxTvyHa62rG+mw1vrBUsqvJPmOU0IPSfKYnCicWVcp5T9nuPjm3TlRQPOudWZ9fZIfKaU8Icn/yImCnHrpGpUAACAASURBVHv7liTHB/LaErXWd05jHAAAAAAAAAAAAAAAOBMtzDoBzigHkqz3RpqP1lqv3mS/r1in/amtmUopz0ryvQOhP0jypEbxzf+n1vpXOfEWnP81EP72UspX9voAAAAAAAAAAAAAAADmmwIcpqbWejwninCG/PkYXb9nnX6fuN4MpZSS5L8MhD6c5GtrrUdGHfzktF+T5CMD4ZeXUhxnAAAAAAAAAAAAAACwjSkMYNquX6f93ZvtsNZak7x3IHRhY7YvSfKIgfaX1lrv2kQOdyV5yUDoIUmetdH+AAAAAAAAAAAAAACA+aEAh2n76Drtt43Z72cG2s5vTP+lA22Hk7xhjBzemGTozTlfMkafAAAAAAAAAAAAAADAjCnAYdquW6f90Jj93j3QdlZj+ssH2v661jpUQDOSWuvhJH89EHrcZvsEAAAAAAAAAAAAAABmr9RaZ50DZ5BSylcn+a2B0Itrra8eo983JbnilOa/qrU+cZ3p35fk0ac0v6HW+lWbzeFkv29I8pWnNL+/1vrZ4/Q7ZU4KAAAAAAAAAAAAzEKZdQKcGdY+8i6/lWRLLDzknzmPwWlsadYJcMb5i3XaLxyz36H5b21MP7Tvr4yZw3p9eNMUAAAAAAAAAAAAwLwoftoJwMa5ejBVtdYbkrxvIPT4zfZZStmR5LEDoY83Zhsqzrlgszl0+rhlAv0CAAAAAAAAAAAAAAAzogCHWXj9QNtTTxbSbMZTkuwcaH9bY56bB9o+t5TNlzSXUhaTXD4QUoADAAAAAAAAAAAAAADbmAIcZuFXk6yd0rY/yfM32d+/GmhbS7sA568H2s7LiWKezXpaknMH2t81Rp8AAAAAAAAAAAAAAMCMKcBh6mqtH0/yhoHQfyylnLORvkopX5LkeQOhN9Zab2vM+uZ12l9aSikbyeFkHgtJfmyd8B9ttD8AAAAAAAAAAAAAAGB+KMBhVl6SZOWUtkuTvLaUsnOUDkopj8yJt+mcWjBTk7ysM/u1ST440P7UrF9I0/JTSZ400P6BJO/dRH8AAAAAAAAAAAAAAMCcUIDDTNRar0vy8oHQFUn+pJRyWWv+UspXJfnzJBcPhH+p1vq+zvg1yQ+tE/7hUsovl1LOavVxMo9zSim/luR715nkB0+OBQAAAAAAAAAAAAAAbFNFbQCzUkpZSvInOfHWmVMdT/Lmk/8+luRgkv1JHpPkK5I8bp1u35HkabXWYyPm8PtJvmyd8B1JXp3kj3PiLTa35cTbds5L8tgkz0jyoiTnrDP/79VanzdKHnPGSQEAAAAAAAAAAIBZKLNOgDPD2kev8VtJtsTCgx/vPAanMQU4zFQp5dycKHB5/AS6uybJFbXWmzYw/p4kVyd54gTGv7d3Jnl6rfXQhPudBicFAAAAAAAAAAAAZsEP15kKBThsFQU4cHpbmHUCnNlqrXckeVqS3xizq9cmefJGim9Ojn8oyZcmec2Y49/bryV55jYtvgEAAAAAAAAAAAAAAE6hAIeZq7XeVWv9uiTPTfLeDc7+Z0meVmt9Qa31yCbHv7PW+k1JnpfkXZvp46R3JXlerfWba613jtEPAAAAAAAAAAAAAAAwR0qt3qDGfCmlPCnJFUmemOThSc5PspzktiS3JvlokrcmeUut9f1bMP7lSb4qyROSPD7JOetMemeSa5L8VZLX11qvnXQuM+KkAAAAAAAAAAAAwCyUWSfAmWHto9f4rSRbYuHBj3ceg9OYAhxoKKWUJOee/LfvZPOBJHckuaOengfQ6bhMAAAAAAAAAAAAzD8/XGcqVj92rd9KsiUWH3S58xicxpZmnQDMs5MFNref/AcAAAAAAAAAAAAAAJyBFmadAAAAAAAAAAAAAAAAAMwzBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGhTgAAAAAAAAAAAAAAAAQIMCHAAAAAAAAAAAAAAAAGhQgAMAAAAAAAAAAAAAAAANCnAAAAAAAAAAAAAAAACgQQEOAAAAAAAAAAAAAAAANCjAAQAAAAAAAAAAAAAAgAYFOAAAAAAAAAAAAAAAANCwNOsEAAAAAAAAAAAAAACmpniHAQAb5+oBAAAAAAAAAAAAAAAADQpwAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGhTgAAAAAAAAAAAAAAAAQIMCHAAAAAAAAAAAAAAAAGhQgAMAAAAAAAAAAAAAAAANS7NOAJgvv/eBG7e0/z3Li91pdi62awPvOna8GV/uzH9oZbWbw3Zw1o72urzrWHs5e+v56OpaN4eFUrrTtOxaaufQyzFJLj57RzP+gNWbm/Gj53xWM76U/nq4/ee+vxnfff6+Znzla3+4GX/7Jw90c+ityyPH28vx0PP3NOPLC/1tfd0tdzfjz37QWc340s0fasY/cfbDmvH33HhXMz6Kxc5y9vb5lRGOm56Lz97ZjF+4d7kZH2U97N/TPm7ud047fmilNuMfuf1QN4fVtXYf47p03+7uNLcfWWnGL9zbXg87Ftv7w93H2vvDJw8cbsa3i3272o8Ui53j5rbD7e0wLx5yXvs8edaO9nl4EueordY7BybJA89tH1u7O9ejY6vtY//vP9O+lmwX5+1un6sfeO6uZvzafzg4yXS2RO9akvTv/Xvnwd56nMT5o3fdPXtH+xw3iX32orPa6/Kmu46NPcZW6113T5drXs+4+1OSrKV9njyn8xw4ifNH79niwr3t5Vyr7WX49J1HmvH7ndM+RybJrYfax8Uj9rev29O4LvfOgb14bxkn4bH3bT+jnd3Z35L+82pvf5rEZzj7draPrd5zXG9dP66znvb+SvuZPkmO3tHe5973gp9oxnv7yyjrqbceevf1t0/guvvkS89pxq992hd3+3jKX71j7DwAAAAAAABgs7wBBwAAAAAAAAAAAAAAABq8AQcAAAAAAAAAAAAAOHN03hwOAEO8AQcAAAAAAAAAAAAAAAAaFOAAAAAAAAAAAAAAAABAgwIcAAAAAAAAAAAAAAAAaFCAAwAAAAAAAAAAAAAAAA1Ls04A5k0pZSnJQ5NcluSCJOfmRLHaHUluT/KxJO+utR6bWZIAAAAAAAAAAAAAAMDUKMBhqkopL03ykikM9bJa60tHmbCUsifJk5M87eS/xybZ2ZntaCnlmiSvSfLrtda7x8gVAAAAAAAAAAAAAACYYwpwOCOVUnYnuSLJVyf5siR7NtjFziRfcPLfy0spP5Hkp2utqxNNFAAAAAAAAAAAAAAAmLmFWScAW+RDnfg/T/JbOVGAs9Him1Odk+Qnk/xFKeXSMfsCAAAAAAAAAAAAAADmjDfgcDo6kOSNE+jnUJIbk9yc5HCS85M8LMnudaZ/QpK3llKeUmu9YQLjAwAAAAAAAAAAAAAAc0ABDtP2y0nePKG+HpPkFQPtr6u1Ht5Ef6tJ/jgn8vvzJO+uta7de4JSyo4kX5Dku5J8+UAfD0nyllLK5bXWY5vIAQAAAAAAAAAAAAAAmDMKcJiqWuunk3x6En2VUr5+ndCrN9jVx3KikOfXem+uOVlU87YkbyulPC/JrybZd8pkj07yPUn+0wbzAAAAAAAAAAAAAGCrLSzMOgMAtiFXD7alUsrOJN8wEHpvrfWaEbv5eJJvTfLwWutP9opvTlVr/d0kz0sy9KabHyql7N1IfwAAAAAAAAAAAAAAwHxSgMN29eVJzhtoH/XtN3+UE4U3v1xrPb7ZJGqtf5rkZwdCe5M8c7P9AgAAAAAAAAAAAAAA80MBDtvVlQNtx5L8+igz11pvqbWuTCiXn0myNtD+7An1DwAAAAAAAAAAAAAAzNDSrBOAjSql3D/J0wdCv1Nr/cy086m13lpKuTbJ408JPWDauUzCkeNDtUT/v8XSnn/P8mIzfmhltZvD6lodq4+FzjKsdPrfLnrrqbecvfmTZK2Ot656+0PPQ8/b1Z1mR2enPJiLm/Hdf/LKZvwzf/P+bg7nPKgzxv/51c343x9qv4hrpH12zP3+jsPtHHYt9Wt29+1q31bcdLS9rfbf91HN+O23HmnGL923Ox+/41BzmuXF9nKsrLbX40JpL0Ov/yR5wLnt/fqmu44143t3tI+rh5+/t5vDzqX2chw42j7P9s7DvfWYJKtjnoqXF9rLsHu5vy3WanufPXCkfVwsd84/vfW0b9dSbj3UrgfuXXfnwdHO+adn3GvNKM7a0d7WDzt/d7eP6+9sH5trtX1sTmM5e/btWm7GH7Cvf929sXOOWulc+4+uto+LeVhPvXP5/j3t9ZgkBzvn0d55dhrrYedSe1tdtHdHM37b4f7fM1hZa58fesvZO49O47rby3ES26q3v8zDcdFz4Gh7f9gOy5D0j4tLO+fJ3j67Z7l/Yf/YHUeb8YNHx/tbOqM8o/WmufVQ+7gZ16fvPJLzdrfPtb3nm951exqOdu6JJ3Fc9LbVg+/TvsfpXdfvHGF/6T0r9rbVQmnHR9lnDx5rH3vn7W7fCz77Ae31dP2PflszfleShR3tffasS/Y341/0wH3N+CcO9PfpD992uBk/crz/mVxL7576rmP9l4x/8s729eIJV/9he/5DC/nQzQfXjd/ZuaYmyfUH258tjPJ52VabxOerTMco96Nbrfe5wbifv0zLFZddNOsUAAAAAABgJLP/dgA27oUZ3ndfPeU87u2TA233nXoWMEHb5UdycI9e8Q3Mm17xDQDAmahXfAPzpld8Mw294hsAAAAAAABgMhTgsK2UUkqSFw2EPpXkj6eczr0N/YJ2vD8HDwAAAAAAAAAAAAAAzAUFOGw3T0vyoIH2q2qtsyx4eeBA2z9MOwkAAAAAAAAAAAAAAGDyFOCw3Vw50FaTXDXtRO5RSjk3yeUDoQ9POxcAAAAAAAAAAAAAAGDyFOCwbZRS9iX5yoHQW2utH59yOvf2DUmWB9r/YNqJAAAAAAAAAAAAAAAAk6cAh+3k65LsHmh/1bQTuUcpZU+S/2sgdGeSq6ecDgAAAAAAAAAAAAAAsAWWZp0AbMCLB9puT/Lb007kXl6a5P4D7T9faz06rSRKKU+aVF+/+Z7rJ9UVAAAAAAAAAAAAAACcFhTgsC2UUj47yeMHQq+rtR6Zdj5JUkp5WpLvGQj9Q5KfmnI675jyeAAAAAAAAAAAAADbUi0Ls04BgG3I1YPtYujtN0ny6qlmcVIp5ZIkv5HhY+g7aq0Hp5wSAAAAAAAAAAAAAACwRRTgMPdKKTuSvGAg9O5a67UzyGdvkjcluXAg/D9qrb875ZQAAAAAAAAAAAAAAIAtpACH7eC5SfYPtL9q2omUUpaT/M8knzsQvibJv5luRgAAAAAAAAAAAAAAwFZbmnUCMIIrB9qOJnntNJMopSwkeU2SZw2EP5zkObXWo9PM6V4+f4J9vWOCfQEAAAAAAAAAAAAAwLanAIe5Vkq5JMkzBkK/XWu9fYp5lJx4487XDIQ/meTptdYbp5XPqWqt75xUX7/13hsm1RUAAAAAAAAAAAAAAJwWFmadAHR8c5LFgfZXTTmPX0zywoH2G5J8ca31E9NNBwAAAAAAAAAAAAAAmBYFOMy7Fw20fSLJ1dNKoJTyc0m+bSB0c04U33x4WrkAAAAAAAAAAAAAAADTpwCHuVVKeWqShw6Erqq11inl8DNJvmsgdGtOFN/83TTyAAAAAAAAAAAAAAAAZkcBDvPsyoG2tSRXTWPwUsrLk/y7gdDtSb6k1vq+aeQBAAAAAAAAAAAAAADM1tKsE4AhpZSzk3zVQOjqWusnpzD+TyT5voHQgSTPqLW+e6tzmJW17suFylj9r66N8PKixbGG6C5Dfxm3i/a26K+HSeYybKGMt7/sXOzPv2upXUvaS+Hg33+kGb/xmo92czh28FAzfunjb2nGd1xwaTM+2j473rpe7JTkLo+wLRY7K3tHp4/F40fGymF1hNW0MOaOP4nzR289jTv/wgjdL3cmWuzExz22p6G3jEmys3P+WFlb64zRnn+xtOcfxSj79XY3D8u4NML+0jtP9o6LaSxn71TdW8zOIXFijM403fW0Nvv11LM8gT62w/1mL8dDK6vN+MoUbiZ7+8Mo6/nuY53lWG2fq49M4ZK3HfaXnpV5OHinoHdcHD3e3p8msZa2w33YdjCN425xzGe0STgddpdRnm/GVVaPNeO9Z/4kWVxuf8x+7Ow9zfhZa+3zy+mwLZOk/7GjvxeWnB73BtMwD+vp6PH2sbvceUDav6f/9LFnuf1heed2Nvt2tef/+B3tz+OSZGdnOW6++2gz3lsPZ+1YzFs/3P789NBKe0F7z8O929VRPke669jxZnzfrvb2PHBkpTvGVtu51N4fevv06aJ3T306fDY6L6647KJZpwAAAAAAE+cbLebV1yYZ+mb6VVs9cCnlx5L8wEDozpwovrlmq3MAAAAAAOZfr/gGgO2vV3wDAAAAAMCZw7eDzKsXD7TdluR3tnLQUsqPJPmRgdDBJM+stb5rK8cHAAAAAAAAAAAAYIt5KzcAm+DqwdwppTwqyRMGQq+ttR7dwnF/IMmPDYTuSvLsWus7t2psAAAAAAAAAAAAAABgfinAYR5duU77q7ZqwFLK9yb5iYHQoSRfVmt9+1aNDQAAAAAAAAAAAAAAzDcFOMyVUspSkhcMhK6ttb5ni8b8N0n+80DoUJIraq1/thXjAgAAAAAAAAAAAAAA24MCHObNFUkuGmjfkrfflFK+I8l/HQgdTvLcWuvbtmJcAAAAAAAAAAAAAABg+1CAw7x58UDbkSSvm/RApZQrk/zCOuM9r9Z69aTHBAAAAAAAAAAAAAAAtp+lWScA9yil3DfJMwdCb6y13jHhsZ6f5JVJykD4J5McLKU8cQJD/U2t9egE+gEAAAAAAAAAAAAAAGZEAQ7z5JszvE++agvGenbWfwPUS0/+m4QHJfn4hPoCAAAAAAAAAAAAAABmYL0CBJiFFw20fSzJ26adCAAAAAAAAAAAAAAAwD0U4DAXSilfmOQRA6Graq112vkAAAAAAAAAAAAAAADcQwEO8+LKgba1JL8y5TwAAAAAAAAAAAAAAAD+kaVZJwAn/VySV5zSdqTW+qmtGKzW+sIkL9yKvgEAAAAAAAAAAAAAgNOLAhzmQq31PbPOAQAAAAAAAAAAAIAzQFmYdQYAbEOuHgAAAAAAAAAAAAAAANCgAAcAAAAAAAAAAAAAAAAaFOAAAAAAAAAAAAAAAABAw9KsEwDmy9pabcYXFkszvtqePWu1M8EI0/TG6PbfWcZJWFhor6dJ5LC20O6jN8Zqaec4Cb1tuZh2DqOspd4YC50xFna0L4WLO/q1qovLncvpwmIzPMJh0dVbD93jaq3dfy+eJKtjjpGl9npaWV1txkc7v7TjY59fRsihN8lqJ8ne/CNsqm6e3TEmcJ4eZV2152/He/tjkqx0Eu3FF0p7ba90khx3HSTJcud6M+4+PYrecs6DXo63HT7e7ePg0fY5qLe/zIOjx9v77G2H28uYjL8eetuic6s5Fb3z8KGV/pm2tzvcday/zzEZW329mYRtcPpgjkzi/oFkYQrPw8D0OUcybdO4nvTGWB3pE1TGddaOJc9xp5HuZ+ke0iZitSa/9d4bmtP0PgeyKaZnqz+T27Pc/v4nSR5w7u5m/Ma7jjbj9z1rZzP+4dsOdXM4E54VP+eivc34e2+6e6R+rrjsokmkAwAAANuSN+AAAAAAAAAADFB8AwAAAADAPRTgAAAAAAAAAAAAAAAAQIMCHAAAAAAAAAAAAAAAAGhQgAMAAAAAAAAAAAAAAAANCnAAAAAAAAAAAAAAAACgQQEOAAAAAAAAAAAAAAAANCjAAQAAAAAAAAAAAAAAgIalWScAAAAAAAAAAAAAADA1xTsMANg4Vw8AAAAAAAAAAAAAAABoUIADAAAAAAAAAAAAAAAADQpwAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGhTgAAAAAAAAAAAAAAAAQIMCHAAAAAAAAAAAAAAAAGhYmnUCwPayVuusU+jmsFDKlDJZ39ra7NfTdrDaWU+9eJKsLrS3d027jx1n723Gd5/fjifJzvuc1YyXHbub8dUpHFe94+LQymozvrK21h3j0Ep7ms8cPt6MH11t1wUfOLrSjE/j2F/sDDHKPnvb4fZyrHT66M2/OEJ59eHFxWb8rmPtbXXkeHtb99bTCVu7ve440l6GZIT9frVzjuocuyur7fU0iX22kyLAGW/cc23nVnMiRrtuArBlir9Rxejm4bNR5kdvf1icwGcf4+5z87DLjvJ52bw7a8dS9/MyTh+950jXgtFM4lnX8zIbcefR9nm693n9KHrnh3272j+/2bXUfvbofc+W9K+rvevVx24/0owfPd7+3uQeb/jbG0aabjOWR/ii68K9O5rx3vc/vduTA0fa38WNore/nL2zvb/s68ST5EBnv+/O31nOPcvt7xN763kSeutxcYQPcHvrcv+e9v70sTsOd8c4XVxx2UWzTgEAALYFBTgAAAAAAAAAAxTfAAAAwOmp+gNNAGyCqwcAAAAAAAAAAAAAAAA0KMABAAAAAAAAAAAAAACABgU4AAAAAAAAAAAAAAAA0KAABwAAAAAAAAAAAAAAABoU4AAAAAAAAAAAAAAAAEDD0qwTgO2glLKQ5LIkj0xySZKzktQkdyW5OclHknyw1npwZkkCAAAAAAAAAAAAAABbQgEOU1VKeWmSl0xhqJfVWl86TgellJLk6UlelORLk5zXmWWtlHJdkrcn+V9Jrq613j1ODgAAAAAAAAAAAAAAwOwtzDoBmEellKcm+X+SvCXJ16VffJOcOJ4eneTbkvxuku/bsgQBAAAAAAAAAAAAAICp8QYcTlcf2sxMpZSlJC9P8m+TlIlmBAAAAAAAAAAAAAAAbEsKcDgdHUjyxo3OVErZm+T1SZ7ZmOzuJDcmuSnJsST3SXJJkv0bTxMAAAAAAAAAAAAAANgOFOAwbb+c5M0T6usxSV4x0P66WuvhjXR08s036xXf3J3klUl+J8nba62rA/PfL8kTklyR5MuSXLCR8QEAAAAAAAAAAAAAgPmlAIepqrV+OsmnJ9FXKeXr1wm9ehPd/WyGi29en+S7T+a9rnst1xtKKTuS/PMkK5vIAwAAAAAAAAAAAICtVBZmnQEA25ACHLalUsrOJN8wEHpvrfWaDfb17CTfORD6r7XW795obrXWY0n+743OBwAAAAAAAAAAAAAAzCflm2xXX57kvIH2Db39ppSyK8l/Hwj92maKbwAAAAAAAAAAAAAAgNOPAhy2qysH2o4l+fUN9vMdSR50StstSRTfAAAAAAAAAAAAAAAASRTgsA2VUu6f5OkDod+ptX5mA/0sZbjQ5kdrrbdtNj8AAAAAAAAAAAAAAOD0sjTrBGATXpjh4rFXb7CfZyW5/yltR5K8bhM5nTZ2Ly8242u1NuMrq2tj57Cy1h5joZSx+l9YGG/+SVjrLOMoVsfsorctR9HbFkeOt/eHxc62uOXQajeHxYX2NL3d5cFXfEsz/rCn3tzNYW3X2c34wX2XNuO33XKoO0ZPb3/obe/+/jD746ZnlH16cczzR289T+L0Mu6xOcppeG1h/OO/mcPWdj+SSZzj+mNs+RDAaWoCt8yMaNzrgXP9mWUa9w/0rY6wHVbHPDinsq075/re8/QoOfamOda5MV/pxUd4bujd+/e2Ve/ZZKX/scAIn1V1ctixtxnf/zkPacbLQv9vXO2+6IJm/Mhae3/ob8v+zcW4nwusrLXHGOU5sNfHkexsxo+trozVfzLCPjkH14JxP+OZB5M4x50OevvbKM8FvWm6x3Z6OYxwvdniz5FGuaxv9WeXvf73LC/m0CgXpTl3phx745rGepqHz09hmnrf/SbJsc5Fr3dff7SMf7/a18mh871ozyj39d1nsE68993tXJyfRlgPvXXdfd7t7JOj7LM9ve8Me9tiufMdeDL+bzPGXQ+TWE89y51H7ov27Oj2ce6u5bFyeOh5u5vxGw4e7fbRW1UHjvSed6dzcP7Ge65fN7an81ui5Ql8Uf7kS89pxndd99ZmvFzY/l1Gkhz/0N8049d/zlc0471Ncc0Nd3Zz2Gq93yPd9+z25y9Jctn+Pc344c45bN/O9v5y5Hh/n77kPu3P7AAAZskbcNhWSiklyYsGQp9K8scb7O5rB9reVGud/dMQAAAAAAAAM3c6FN8AAAAAADAZCnDYbp6W5EED7VfVWkf+8x4nC3m+dCD0ls0mBgAAAAAAAAAAAAAAnJ6WZp0AbNCVA201yVUb7OcxSc4faH/vejOUUu6XZH+StSS3JLm11tp+DywAAAAAAAAAAAAAALDtKcBh2yil7EvylQOht9ZaP77B7i4faFtL8r57jbeQ5HlJvjHJFyc5ZyCn9yX5kyS/V2t92wZzAAAAAAAAAAAAAAAAtoGFWScAG/B1SXYPtL9qE309eqDt5lrroSQppXxhkvckeWOSr8hA8c1Jn53k3yZ5aynl7aWUp24iFwAAAAAAAAAAAAAAYI55Aw7byYsH2m5P8tub6OvSgbaDSVJK+c4k/yXJ4gb7/IIkbyul/Eit9T9uIqdNK6U8aVJ9vfFvb5hUVwAAAAAAAAAAAAAAcFpQgMO2UEr57CSPHwi9rtZ6ZBNdXjzQdrCU8i+T/LdN9HePkuTHSykPrrUOFQxtlXdMcSwAAAAAAAAAAACA7auUWWcAwDa0MOsEYETrFbO8epP93Weg7X5Jfu6UtkNJfj7J05NckmRnkguTPCnJf0hy8zr9X3nyTToAAAAAAAAAAAAAAMA2pwCHuVdK2ZHkBQOhd9dar91ktzsH2i7MP34r1J8l/SzEHgAAIABJREFUeWSt9btqrVfXWm+otR6rtd5Sa/3LWuuPJnl4ktesM8bPnHxzDwAAAAAAAAAAAAAAsI0pwGE7eG6S/QPtrxqjz6VO/G1JvrTW+qnWRLXWA0m+OckrB8LLSX5wc+kBAAAAAAAAAAAAAADzoleEAPPgyoG2o0leO0afK43Y7Um+sdZ6ZJSOaq21lPJdSb4gyaNOCT+/lPJDtdaPbTLPUX3+BPt6xwT7AgAAAAAAAAAAAACAbU8BDnOtlHJJkmcMhH671nr7GF0fa8R+odZ6/UY6q7UeKaW8LMlvnhJaTPKcJP/t/2XvzuNkOet6j39/3dOzz5mzn5PtZE/YA4EIQZAgyCK5LAqIokJARBBRuXBVBEUERK6EK8IVRJYru7IbdgIJS0LCkoAhgZA9OcnZlzlzZu/+3T96jjnpVD+/mqme7pnpz/v1mldy6tf11K+qnnrqqafnmVpgfgvi7pe3qqxPX3NXq4oCAAAAAAAAAAAAAAAAAAAAAGBVKHU6ASDwPNUnsTR6b8FyDyRi/7rIMj8laU/G8scssjwAAAAAAAAAAAAAAAAAAAAAALAMMAEHy90FGctulXRxwXKzJspI0q3ufutiCnT3OUlZb6J5xGLKAwAAAAAAAAAAAAAAAAAAAAAAywMTcLBsmdljJJ2WEXq/u3vB4rc3WX51wXKz1t9UsEwAAAAAAAAAAAAAAAAAAAAAANBBTMDBcvaCjGU1Se9vQdk3NVm+r2C5ezOWVcxsTcFyAQAAAAAAAAAAAAAAAAAAAABAh/R0OgEgi5mNSHpmRuhid7+tBZu4rsnyiYLlHm6yfFjSWMGyAaCpwUo5Ga8FLw6bmqsVikvSSF+6W3HLgclkvFKyZHxitlpofUmqlNNzj0u1Yi9YK+fKIf2ZaD+i9csW59DXkz4Os7X0+a56lEOYQmGlYD/7yulrQpKqQbWuefoD0bmq1tLx0b4ejc/MpZNYAaJzEWlHfYm20ZJrN7w2w00suehcRfuQ5zPRNkpW9EWWSy+qDzmqS3i+8xzrTit6bbdDnhwrpeDeH9bZBaXUtaK+5moR7Wc1isddakXd0bj/ki4gz7lqRRnFyi9UvKQ8/dni24hE7Udcn+JtLPV+RHVaKl4f4n0ovpPRfnjBe57XarLgfrMSFK1Py+FekK+dLX7tdVqUY56u5tLvZ/HjHO3HSjhX0XGI7lf1z6QPRFina8XGDOs5FD2fUY5xDuFngmY4XD8YM+zrKYdjk7NBI7Qc6mw09tmKHJfD/aCo6DlxNewj0G552vroe6joflQO4q24dsNn9iA+G3wg2kcpPpZzwf0oOg7R+m0R3Jel+FhF8XBsohWDE8FuFB1nkvLVmWQO0XGM6lMrjlOgGn2vkeN5vDf8XiO9fvTda57vZos+I0XtRztUy+kc8nxXH+md2p+MH7ryW8n44H0fGG5j19cvTZfx0F9PxqNmshXnaqn7m3nq7HBv+tqKihispNffMzkT5gAAALCcMQEHy9VzJA1mLH9vi8r/fpPlRd9UM9pkedE367TNMx5wTKdTANosuOw3bQtLiIb1mjUMRzxyaCAdDzOQLrpuZ45PAVhOVsPkGwAAAKDbrYbJNwCAtGjyDQAAAAAAAACgezABB8vVCzOW7ZP0mVYU7u67zeznkk5vCG0uWHTW+ofdfapguQAAAAAAAAAAAAAAAAAAAGgF4w8sAQAWjrsHlh0zu5+kh2eEPuzu0y3c1Jczlj20YJnnZCy7pWCZAAAAAAAAAAAAAAAAAAAAAACgg3gDDpajFzRZ/t4Wb+cTkl7WsGyjmZ3t7j9caGFmtkbZE4e+sZjkAAAAAAAAAAAAAAAAAAAAAKDT5l+w8ABJx0oaljQlabek6yRd5e6zHUwvl/nf9b6fpFMlrZO0RvX92C9pn6Qfu/vNncsQKwETcLCsmFmPpN/OCP3Q3X/U4s19U9KNqjeiR3uppN9bRHkXSBrMWH7xIsoCAAAAAAAAAAAAAAAAAAAAgI4wsxMkvVzSb6k+8aaZQ2b2OUlvd/cr25JcDvP5P07SYyX9kqSTcqyzU/WXL7zL3S9tUR6XSHpMK8o6yqXufl6Ly0QOpU4nADQ4X9KWjOWtfvuN3N0lXZgRep6ZPWwhZZnZVkmvyQjdIemLi0gPAAAAAAAAAAAAAAAAAAAAANrKzEpm9mpJP5P0SqUn30jSiKTnSrrCzP7NzEaXOsdmzOxEM3uVmV0p6TZJ75f0u8ox+WbeFknPkXSJmf3YzM5dmkyxUjEBB8vNCzOWTUn6yBJt772qvwXnaD2SPm5m2/IUYGYjkv5d0saM8JvdfbpYigAAAAAAAAAAAAAAAAAAAACwtMxsQNLnJL1R0sAiivgdSd8zs5Nbmlh+75X0FknntKCsB0r6tpm92cysBeVhFWACDpaN+bfIPCkj9Cl3P7AU25yfHPMSSd4QOkXSd8zsyan1zexsSZdIenRG+GpJ/9qCNAEAAAAAAAAAAAAAAAAAAABgyZhZWdInJT2lyUdmJf1I0sWSrpQ03uRzp0v6upkd0/IkW2OPpGtV/x3wy1R/mUPj75IfUZL0Z5Le2ZbMsOz1dDoB4CjPU3adfO9SbtTdv2pmb5L0lw2h4yV9Yf4VZJ9VvaHdK2lU9Qk6T5H0eGVPZNsj6em8/QYAAAAAAAAAAAAAAAAAAADACvB6SVkvLzgg6W8kvd/dDx5ZaGYVSU+V9CZJZzSsc5Kkj5rZ49y9ujTp5rZX0idUn3DzLXff3vgBM9so6dckvUrSaRllvMTM7nD3N7Uopz+U9MMC64+1KA8sEBNwsJxckLHsZknfaMO2Xytps6QXZcR+Yf4nr12Snubut7YiMQAAAAAAAAAAAAAAAAAAAABYKmZ2lupveml0s6THu/tNjQF3n5X0STP7kupvznliw0ceI+kP1Lm3x3xZ0r9K+py7z6Q+6O57JP2Lmf2bpLepnnej15rZR9395hbkdq27f7cF5aDNst7cAbSdmT1K0pkZofe7e7NXerXM/DZeLOnPJc0VKOoqSefQIAIAAAAAAAAAAAAAAAAAAABYId4qqdyw7LCkX82afHM0dz+s+ttjfpIRfr2ZDbcmxVxc0hdU/33uJ7n7J6LJN/dY2X3K3V8i6d0Z4X5Jf9WiPLFCMQEHy8ULMpbVJH2gXQl43d9Leoikz6veAOd1o+pv8DnH3W9bivwAAAAAAAAAAAAAAAAAAAAAoJXM7GGSHpcR+lt3/2meMtx9QtKLMkLrJf1+gfQW6vnu/hR3/37Bcv5E0i0Zy59mZj0Fy8YKxsnHcvGPkv6lYdmUu9/e7kTc/RpJ55vZqZKervrrz+4raaukAUljkvZI2i7pW5K+Kulydy/y5hwAAAAAAAAAAAAAAAAAAAAAaLesCTJ7Jf3TQgpx98vN7MuSntgQepGkCxeZ24K4+/YWlTNlZm/XvfNeJ+lc1X+HHF2ICThYFtz9R53OoZG736j669Te2ulcAAAAAAAAAAAAAAAAAAAA0BpupU6nACwL829zeWZG6MPzb7VZqPfo3hNw7mNmZ7v7DxdRXid9pcnyE8UEnK7F3QMAAAAAAAAAAAAAAAAAAAAAgO7zCNXf6tLok4ss7/OSJjOWP3mR5XXSbU2Wb21rFlhWmIADAAAAAAAAAAAAAAAAAAAAAED3eWzGsglJly+mMHefknRZRuiXF1Neh802WV5raxZYVpiAAwAAAAAAAAAAAAAAAAAAAABA9zknY9lV7t5s8kkeV2YsO7tAeZ1yUpPld7UzCSwv5u6dzgHAMvLFn+5c0kahUo7n/c1W0xNDdx2eScYHKuUF5bQY03PFJq+WLR2v0jS3THSssXysG6gk4xOz1WQ8z3XZE7RBo309yfj4zFwynufarZTSlXI6aAOLli/FbfFUcCznghz7euK2Psph22h/Mn7z/qy3lC7MYHC/qAQNSFTnon3sy3FP3D+Vfo6t1tKVrpyjPkSibUR1thasn0cp2I/NQ73JeNFzJcXX1nBv0fYjPk6jfel28pYDE2EZKdE+SPF+FO0jbRhMn8szNgyEZUQpDPSkz2XUlm+tpPuiknTQ+5LxqWAjN++fSpc/nT4PUvH7ZtSnznO/idrZ0f50nTtry2A6h599M8zh4CmPSsbXTOxMxmvDG9Pxcvq63DEej0dGbfX1e9P3vOh+Et3PpPgZa7g3fS7P3JA+V3mOQ+TYkfSxPjxb7DlSkk5bl+5/TM6lr909E+lrc7gvvt+UlD5fU8F9d7Qvfa6i9kWSZoN7d1QfNg+lz9VM0AaOBOVL0mTQhm0aTLcv/Uqfq0mPc4juFwNBn7hcS18X+2bj+hL129f1p/fj8Gx6J/J0JaMmZu3s/qCAoP/hcd+idPNVyfjMTT9Jrz80kozb4Jowh8nr09s4dFv6frPxEenvm/rum/W911GqcTvrc+nP+OiWZLzWlz5O4bmUVDq8Nxm32emggHSdrt52XZhDz5YTknHvG04XUEv3sTR9OMxh7tj7J+M2F/QFe9Ym43nGwgbL6evfgmvvx3vT7ei6gXR92DIU15fdwX31yu1jyXj0fDNYidvZHYeCOllQK8ZPomf2qE+e59kiqlMTQT8sWj8ar5Pisaho3CAam4jWl6TZ4OYf9buj9duhHd9L1PjeGV0mz5gepLLF7Wz0rBmNZUVteTRWlke0H9F4WZRjK+4Vs7X0ceqPvh8q+B1Vu0R9nKLHcnqueH2JRP28POOv0RhOuP4S97Gk4v2LqP8S1QVp6X9/ZHwmri9RHyk6F8ugKxmeizx96sjp64eS8ePXBN8H5jhQ0djjD+46FJaRsn0sHn+NLHX/Is91c8xw8D1XcF+OthF9By5JzznrOH7bB20xs+eOZdDKYjXq3Xj8imrHzOwWSSc2LH63u/9BgTKfI+mjGaGT3P3WxZbbbmb2UknvzAj9grt/bwHlXCLpMQ2LH+vul5hZj6RNkjaq/nKVfZL2u/v44rLGUou/5QAAAAAAAAAAAPcSTb4BAKx8y2HyDAAAAAAAALAUzKxXUtZfr7qhYNE3Nll+iqQVMwFH0gUZy3ZK+kELyn6pmf2t6m8gutcMWDPbJ+kySd+R9Bl3/2kLtokWiP+sFAAAAAAAAAAAAAAAAAAAAAAAWE1OUPZ8gu0Fy222/kkFy20bMztf0sMyQp91D14ln8+zJD1KGZNv5q2XdL6kv5N0rZl93szOa8F2URBvwAEAAAAAAAAAAAAAAAAAAAAAoCAzO7dVZbn75a0qq4lNTZbvLFhus/WbbW9ZMbNhSW/PCFUlva3N6UiSSfpVSb9qZu+U9Ep3n+pAHhATcAAAAAAAAAAAAAAAAAAAAAAAaIXLWliWtbCsLOubLD9YpFB3r5rZYUlDDaENRcpto7dLOjlj+bvc/aftTqbBH0p6lJk9zt33djiXrsQEHAAAAAAAAAAAAAAAAAAAAAAAustwk+XjLSg7awJO47+XHTN7kaQLMkK3Snp1weJd0n9J+oqkqyT9RNIOSWOSaqpPiDpO0rmSnijpyZJKGeWcJek/5yfhTBbMCQvEBBwAAAAAAAAAAAAAAAAAAAAAALpLpcnyuRaUPZuxrLcF5S4ZMztP0jszQnOSftvdxxZZ9E2SvibpA+5+R+Jzd83/fF/SP5nZaZLeJun8jM+eO5/rCxaZExaJCTgAAAAAAAAAAAAAAAAAAAAAukcp66USQNcpN1lebUHZWWUs27kLZvZASZ9S9qSkP3P3by+2bHdf1CQZd79B0v8ws1dJekvGR55nZm9396sXmxsWbtlWYgAAAAAAAAAAAAAAAAAAAAAAVpBHdjqBBWj2pptWzDHIKiPrrTgdN/+mmS9LWpcRfoe7X9jmlO7B3f+3mY1K+suGUEnSGyU9pf1ZdS8m4AAAAAAAAAAAAAAAAAAAAAAAUJC7X97pHBZgusny3haUnVVGs+11jJmdKOliScdkhD8g6eVtTai510l6pqQzG5b/ipmNuPuh9qfUnXh/GgAAAAAAAAAAAAAAAAAAAAAA3aXZpI2RFpSdVcZYC8ptGTM7TtLXJW3LCH9M0gvd3dubVTZ3n5P05oxQRdKvtDmdrsYEHAAAAAAAAAAAAAAAAAAAAAAAusveJsvXFinUzPol9S1ge21nZltVn3xzSkb4U5J+x91r7c0q9AVJWROCzml3It2MCTgAAAAAAAAAAAAAAAAAAAAAAHSXHU2Wby1YbrP1m22vrcxss+qTb87ICP+npOfMv3FmWXH3XZJuzwhtaXcu3YwJOAAAAAAAAAAAAAAAAAAAAAAAdJc7JU1nLN9WsNxm699csNzCzGyT6pNv7psR/pKkZ7n7bHuzWpBdGcs2tz2LLsYEHAAAAAAAAAAAAAAAAAAAAAAAuoi7u6QbM0JZb4ZZiNObLL+hYLmFmNlGSRdLun9G+GuSnuHuWROSlrveTifQTZiAAwAAAAAAAAAAAAAAAAAAAABA97kqY9lZBct8SMayO9x9T8FyF83M1kv6qqQHZoS/Iemp7j7V3qwWJettN2Ntz6KLMQEHAAAAAAAAAAAAAAAAAAAAAIDuc0XGsvuZ2WiBMs/NuZ22MLO1qk++eXBG+JuSznf3yfZmtXBmtknSCRmh29qdSzdjAg4AAAAAAAAAAAAAAAAAAAAAAN3naxnLypIev5jCzGyzst+Ak7WdJWdmayR9RdLZGeHvSHqKu0+0N6tFO1+SZSzPeosRlkhPpxMAsLxMzdWS8Zp7ofIrtXj9avCZapDDdLAPeZSzbk9Hma0V20bN0huI9nG5GKyUk/GJ2WoyXg6OQymIS9JJaweS8e2H0m8EjOpLnhyi66JSSpexYbA3GZ+uxvXt4NRcMl702s0j2s+ecnre76GZdH2JzlWefVw3kK6z0bGezdGGRaar6TJqwTaG+9Ldt+i6lKSDU7PJ+GRw7UZtVLCLkqTh4No6NJ3OIcqxryeeZ14JGvvRvkoyvmtuOp1DUOejNlKK78v9wX5Gbdj0XJxDVEZ07Q8GdXb/ZLo+StJwb7qMbaP96Xj5UDJ+69xgmMNoX/pYX7cn/UcwovN93Jr0PtRzSF/feyaKtQ/RPVOSZoMLPOpDRfsZXZd5unnDvelzFd3ap2bSG7GZeMzlsNLtR9RMbh1J9w3y9BVng3vaQ05I/6Gaa3cdTsbz3Hejz0TX/80HZpLx007KGhu7p9vH0mX0ljck4zMH0tfubDXdB8sjauu3j6WvzeHeoH/TguejyHV70tdFtI+SdOaGdFsctS/R/eiY4fR1JUkjQTvb15Ou01PBdVfKHAe9pxNGig3VWS1dJ4c3x/e8Q0E7OBb02weC/slguonU2qAdl6Sa0ueqXEu3L+X96T8ANTi4LszBK8GxjJqH4IbUU4r79cf2pvdz3IPjFBzqPOeiNJO+X1SHNybjPYd2JeNucQ42MJSMl0bTbX3PpuPS5VfSlfbwpd9MxiVpZNuWZLz3lPsn47WB9H27NL4nzEEj6eNQC+r9oZ41yXjcwklDa9Jtsc2l73lzA+uT8UpwnCRprie4H0R1rpRup70cNHKSxj39meHgVhDd28dn4/tub3BjHaykj0M0Nhrdlw/nyHEmePZ44OaRZDx6LljbH7ez5WOHk/Edh9ONfdRvXxf0PaT4XHx3+3gyHvXDjhnuC3OIxsv2TKT7gtFzQZ6xrKX+3iKP6HxGY93tGPMvOt6+HMaQ26G0DHJA94jG+7tGjj8LG32vEH0/UwrWb8W5qIWjesF4fbiPxcdw4vHbdDxavx2iMSApzrPoscxzGKL7Zvgdc/j9b3zhRGPA4fpFr6s29B2iSzfPd7elgsepFd+1RaJxxUj0Ozat0BsNJLUgh+i7tJlgG3nGoaPn4aLPHtF32K1Q9HxHzw1SfC6K/t5EO763AAAsjLtfZ2Y3Sjq1IfQbkj65iCKfrXt/deCSLlpEWYWY2YikL0k6JyN8uaQnu3t6oHWZMLMeSX+eEXJJ32hzOl2NCTgAAAAAAAAAAAAAkGGl/MEsAAAAAACwQDn+CBTQRT4k6a8blj3dzE5w99vzFmJmJukPM0KXuPsdRRJcKDMbkvQFSedmhK+Q9CR3T/9V3+XldZLOyFje9mPb7bh7AAAAAAAAAAAAAAAAAAAAAADQnf5F0kzDsoqkNyywnAsk3Sdj+TvyFmBmt5iZN/zcspAkzGxA0n9KelRG+HuSnujuYwspczHM7BwzO7MF5bxS0l82Cb+5aPlYGCbgAAAAAAAAAAAAAAAAAAAAAADQhdz9Tknvywj9rpk9K08ZZnaGpAszQtdI+kyB9BbEzPrmt/fYjPAPJD3B3Q+2KZ1flHSdmX3GzM43s/6FrGxmp5rZ5yT97yYf+aS7f6VwlliQnk4nAAAAAAAAAAAAAAAAAAAAAAAAOua1kp4taX3D8g+aWY+7f7TZimb2EEmfkzSaEX65u9dal2bok5KekLF8t+r7eB8zK7qNMXe/NudnTdLT5n/Gzeyrkr4v6ceSrpd0QNKYpJqkdZKOk3SupCfP/zR74cr1kn5vsTuAxWMCDgAAAAAAAAAAAAAAAAAAAAAAXcrd95jZCyV9uiHUJ+kjZvY7kt4t6buS9kgakXSWpOdKer6kSkaxb3P3byxZ0tme0mT5JklfaNE2LpV03iLWG5b0jPmfIn4i6YnufqBgOVgEJuAAAAAAAAAAAAAAAAAAAAAAANDF3P0zZvZqSW/KCB95I0teF0n6s5YkhiNqkv5R0qvdfarTyXSrZq8kAgAAAAAAAAAAAAAAAAAAAAAAXcLd/07Sn0qqFijmQ5Ke6e6zrclqxbpB0k0tKGdG0sclnevur2DyTWfxBhwsO2a2XtLDJB0jaa3qr9uakHRA0i5JP3T3u9qUy/Gqvx7tZElrVL+ZHJB0/XweB9uRBwAAAAAAAAAAAAAAAAAAAAAsNXf/P2Z2uaR3SnroAla9S9L/cvcPLU1mK4u7XyTpIjM7QdKjJZ0t6cGSzlD99+SbzeVwST+VdKWk70r6lLvvWvqMkQcTcLAsmNkpkn5P0rMknZbj89slfVbSe9z96hbnMizphfP5PCDx0Tkzu1TSP6vesHkr8wAAAAAAAAAAAAAAAAAAAACAdnP3KyQ9zMweL+m3JT1e0nEZHz0g6VuSPiHp4+4+XXC7JxVc34qsvxTc/XZJH5n/kSSZWUnSFkmjkgYklSQdVP14HnD3uQ6kihyYgIOOMrO1kt4q6QJJC2nwjpP0UkkvNbOLJL3E3e9oQT5PU322ZtYNolGPpMfN/1xhZhe4+3VFcwAAAAAAAAAAAAAAAAAAAACATnP3r0n6mvTfv/d9rKQhSVOS9rj7XR1Mb8Vy95rqbwzi+K0wpU4ngO5lZg+S9BNJL9DCJt80Ol/ST8zsiQXz+StJn1a+yTeNHq76JJwnF8kBAAAAAAAAAAAAAAAAAAAAAJYbdz/g7te6+/fc/b+YfINuxAQcdISZPUDSxarPgmxmr6Tvz3/uCkmpN9yskfSZ+decLSafV0v6G2VPBHJJN0j6hqRvS9rZpJgRSZ82s/MWkwMAAAAAAAAAAAAAAAAAAAAAAFieejqdALqPmfVI+rCkjRnhOUnvlvQud78mY93jJT1f0iskrWsI90v6kJmd6e4HF5DPEyS9ISNUk/QOSRe6+60N6zxC9Qk7T2hYp0/Sx83sIe5+Z94cAAAAAAAAAAAAAAAAAAAA0CbGOwwAAAvH3QOd8GJJD8pYvlfSo9z9ZVmTbyTJ3e9w9zfMr391xke2SHpd3kTMbFDSe3TvN99MSTrf3f+4cfLNfB7fdfcnKnvizmZJ/5g3BwAAAAAAAAAAAAAAAAAAAAAAsLwxAQed8PyMZS7pGe5+RZ4C3P0OSU+StDsj/Fyz3FOTXyFpW8by33f3L+bI47WS3p8ReqaZPTJnDgAAAAAAAAAAAAAAAAAAAAAAYBljAg7aysyOlfSwjNBn3P1bCynL3XdK+ruM0CZJj8iRy4Ckl2eEvuTuH1xAKn8qaVfG8j9fQBkAAAAAAAAAAAAAAAAAAAAAAGCZYgIO2u20Jss/ucjy/qPJ8lNzrPsM1SfrNHrdQhJw94OS3pYResr8hCMAAAAAAAAAAAAAAAAAAAAAALCC9XQ6gZXCzH5J0u9KepSkrZLKkrZL+r6kD7v7FzuY3kqypcnyaxdTmLvfYWbjkoYbQsfkWP03M5b92N2vWEQq75P0BtXrxRElSc+RdOEiyuuY6WotGa/VPBmfDeJVnwtzKJsl49Nz6RzLlfT6s8E+SlJfTzkZj3IoBftQqaTnP1ZK6fUlqZo+1Kp5+gNRjnmE9SFI8tBcuj4MVdLnQZIOTqfLiHLs60mfi75yPFf1+DX9yXjRYz0xWw0/s39yNhkfCI7lSG86Hh0nSdp1eCYZHwxy2DhYScbXDaS7LaN9cX2JrCun69PumfQ2esvxub5m90QyHrUvUX24aypuZ6P2Iaov0fqjfXEXc+NgbzLeH7STI32Nt/57ynPdRecrui6G+9I5zgRtYI7mJbxuRoJ63x9cu7cemCqcw/hMus5Vgh3tyXMgAj/dk76uSptGkvHJ4LqTpGpQ76M+UCtEeY72p6+9uD4NhTlEdWogiI/0puNR/2a0Np7+gKTyjp+lPzCXvl9tGt6QXn/iQJjDib3pvoFK6XNVHUrncEq6StcNB/3V6b3J+MknpB+pbDo+F9XhrL93cHQh6fpQmjmcjJdv/1GYwwPWH59OYWoyGfdKX3oDpbj9iFQ3p3O8z8Z0fYjapzyt7ORcuozonhnddtcG174klaYOpj8QHOo1A+kLo5Tj2u3Zfmc6vmZrMr5xYGMyPhj0bySpfGB7Mu796f0cL6f7SDM57ldTwTPzvon0s8eBybg/mrI26PdLUjXYj0opfaxHB09MxqeiG5KkanDdDAX3RAsunL3BM54kTfan+9QHp4PnxCDH/hzPN+VKuv+wfyJdHzYOb07Ge6bia9engz5tLX6mTpn6r8uT8fFcB7XuAAAgAElEQVTtu8MyLOjzRrd2q6b7L16L70c2O52OT6fvu0P9o8l4nutGpfRzvzwY86um98F7B8MUvCd9b7dq+rqJ1j84F7f1d46nz+dwb/o43XUofRyi8V0pHu9aP1Ash+HedFs+UI2P087gOFWCNmrr8EAyPrw7eG6QNLv59GQ8aiejW2KecaS+w+k25r5BX3FfME60Lsd42r6pdDsa3Zcj0biCJJ0wmn7GevCW9P1oOmijbs4xPhJdWtEzeTTmF5nKsX50LKMx3h3BtZ2nqY+2EVX70zekz+WZozmeLSb2J+M3+dpk/KTBYEzvYPq5QZJqg+uS8V2e7rdHz2h5ni2ij+yZTF/bY8F3L2uDOt+T63uu9H5uGUxvI2p+rt8XX9vRd5LReNq+oN/+833pPpYUf49VCo5llOOdYzmOQ7CNkWDMvz/oW+ybip9vimrF+G1URlRfqlF/Nrgs8rSz0fcz0T4ouO3O5ni2iBTtG0T1USr+PXlkJkefuqhoP/PUh6Lnayb6vYsoxzZ8L9IK4XVRUDSWlsfkzNL2uVthJhgLz3PtRqL+7FjwbHIox7NF0Ryi+/ZKOJd5RP2L6PeupoO+QSvOFQAAQCd1xQQcM3u2pKNH53e5+5dyrjso6YOSnn5k0VHhMySdLuk3zexiSS9w9ztakPJq1uyJK/7trebGdO8JOMknGjPrlfTLGaFFvYnH3XeZ2bckndcQerJW2AQcAAAAAAAAAAAA1LXhd3ABAAAAAAAAACvEqp+AY2anSfqYpKOnkL9GUjgBx8x6JH1F0rm6e+JI41T0I8sfL+lbZvZId7+rUNKr284myzdI+vkiy8z6E287gnUeLinrTyJevMgcjqx7XsOyR5lZxd2X/s/6AAAAAAAAAAAAAAAAAAAAAACAJRG/n3rle+b8f23+Z0rSu3Ku+zeSHjn//657T75pXH6ipM+bWTcc18X6gbLfTvMLiynMzB4sqS8j9N1g1XMyls2pnt9iXZmxrF/S/QuUCQAAAAAAAAAAAAAAAAAAAAAAOqwbJoqcN//fIxNlLnb3/dFKZrZV0p/q7sk1dtR/G3901OfOkvRHhbNepdx9XPW3CjV6nplZxvLICzKWXeXuNwbrPShj2Y3uPrWIHI74cZPlZxUoEwAAAAAAAAAAAAAAAAAAAAAAdFg3TMD5BdUnxxyZ3HFRzvX+WPW3lxytJukdkh4l6T6SniLpq7rnJByT9Boz6ymQ82r3loxlZ0t6+UIKMbNflPQHGaE35Vj91IxlNyxk+43cfYekwxmhU4qUCwAAAAAAAAAAAAAAAAAAAAAAOmtVTxIxs22S1urut9NI0jdzrv5buufbb1zSi939fUd95npJXzSz90q64KjPr1d9cs5nF5n6qubul5jZu3TvyTMXmlmfpH9w91qqDDN7mqQPSKo0hD7u7p/IkcZJGcu251gvcqek03Nsq6XM7NxWlfXRq+9oVVEAAAAAAAAAAAAAAAAAAAAAAKwKq3oCjqSTG/49o/qkmaT5yQwn6O432rik7zZMvjnay1SfcLPpqGVPFxNwUv5I0hZJzzhqWUnS30u6wMzeo/pkqZskjUkalHS8pEdIep6kX8oo8wvzsTw2ZSzbmXPdlB269wScrG212mVt2AYAAAAAAAAAAAAAAAAAAMDKZ6VOZwAAWIFW+wScbQ3/viV6s8q8X85Y9n+bfdjdJ83s/0l6le6etPPQ3Fl2IXefM7NnSvpfkv5aUv9R4ftIeusCipuQ9EZJb85zfs1sUFJfRujgArbZzFjGsg0tKBcAAAAAAAAAAAAAAAAAAAAAAHTIap++Odrw77wTLBon4MxK+lywztca/n2mmVVybq8ruXvN3d+s+puK3qQcbydq8BNJr5V0kru/KefkKkkabrJ8fIHbz3I4Y9lQC8oFAAAAAAAAAAAAAAAAAAAAAAAdston4Awe9f+u7LeT3IOZlSU9XHe/ycYlXebuh4JVf9rw7x5Jm/Kn2tVc9bfYLPQNNMeq/rac+y1wvWYTo+YWWE6W2YxlvS0oFwAAAAAAAAAAAAAAAAAAAAAAdEhPpxNYYo0TLfLs74NUn7jjRy37Zo719mQsWyPpzhzrdiUz65P0t5L+SFL/IopYJ+m5kp5rZt+U9EJ3vyHHeuUmy6uLyCFPGe24zh7ZwrIua2FZAAAAAAAAAAAAAAAAAAAAAACseKt9As7Rb60x1SfERB6dsSzPBJzpjGWDGcsgycyOlfQlSQ/MCE9Iukj1436bpAOShiVtUX2iyfmSjmlY55ckXW1mz3L3Lwabb/amm1ZcD1llZL0Vp6Xc/fJWlfWxH21vVVEAAAAAAAAAAAAAAAAAAAAAAKwKq30CzljDv0/Osc5jG/5dlfTdHOtlTe7JmpTT9cxsvaSvSzozI/xPkl7v7llvFJKkD5hZr6QXSXqL7jnJaUjSp83sie5+aSKFZuelN515LlllUA8AAAAAAAAAAAAAAAAAAAAAAFjBSp1OYInd0vDvtWZ2WrMPm1m/pF+R5Kq/MUeSfujuEzm2tS5j2XieJLvQP+vek29c0vPc/eWJyTf1D7rPuPs7JZ2r+ttxjtYn6YNmNpoo4lCT5SOp7eaUVUbjRDAAAAAAAAAAAAAAAAAAAAAAALCCrPYJOFdnLHtm4vPP0j3fqOKSvpFzWydlLNuZc92uYWaPlPTsjNBb3P3fFlKWu/9Y0m9lhE6Q9CeJ9WaUPTlq7UK230RWGXtbUC4AAAAAAAAAAAAAAAAAAAAAAOiQVT0Bx90PSLruyD9Vf6vNK8xsa+NnzaxX0qvnP3e0L+Xc3NkN/97h7lMLSLdbvCxj2T5Jb1xMYe7+RUlfywi9xMxS9XtHxrJ71YtFyCoja1sAAAAAAAAAAAAAAAAAAAAAAGCF6Ol0Am3wEUl/q7sn1myU9A0ze7G7f1OSzOx4Se+WdKbuOQHndne/NOd2HnbU/7uknxfKehUyM5P0hIzQ59z9UIGiPyLp8Q3Ltkh6kLLfgiRJN0s6rWHZtgI5yMzKko5tsq0V4+DUXKH1Z2u1ZHxmLh2XpAdtXZOMP2btZDJe2n1jMl7d3HjqM1T6k+Gv3FlNxvdPzibj4zPxcZ6cTW+jWmucL7iweG9Peg7mUG98i9g81JuMnzA6kIzffjB9LreO9IU53HfjYDJ+84H0XMi+cjkZH+qN56ruC873aF8lGe8tWzIeXVeSdPax6etmy2D6fN6wv/ic0cFK+lhOBHV6tprOcaaartM35diHanAo+4PrYmoufe1G60vSTfsmkvFSKagPwXHYPzET5lBU1L7cb8tIWMbGoE4O96brU3Td9Ht8HKya/sxEOd2+7BhPV6jhvnR92DBY0aaB9HFIH+n4OFSUzrGvnG6nJWnfZPraLQfVPmobjs3R1kfbiI7jmkO3J+O1oQ1hDt6TznN9f7q+7Cl4HCWpbOnzHfXjonOxZSh9v5Jy9D+CSjtUCvo3pSCHyRx91YH0PVGeTtIP7krGq3vj+fU9pzwovY2+oWTcasF+etw3mFt7fDJeTf69Amn/dHob5b64/RifSJcxW0vXh/5yuk++6dRfDHMYm0lvo3ckfV3NBHW+FX/VZP9EOsexqelkPOorloK2Q4r7aZVSek+jNmykL3626C+nr4sNA+k2bHTX9cl4bfdtYQ4aTd8PbC59LvqC+3IpWF+SVE63g15JX3sDwcnoDeq0JE3MpuvUaH/6fEb91WrQDq8J+oGStGUgfay9lC7j4HS6zs/MxO3s2HS6rR4PrptacBx2Hs7Tr0+3k9M5xmBSDk7H7Udkf9A/iZ7zhnvjZ4sNx98vGS/PpY+l9aWPY+X49DjSyb9zmnZ++avJzwwdk25ffHRLOh5c+9aT3gdJqg6MJuMzwbGeCK6LqB8oSbVgDKa/dzgZnw3asL6+9DiVFLflHrTDs5ZuA6s5+mnR2MRkcO1G9/5KMK4gSZXgnhW11esG4meHlOhcSnGO0XhbeBSC+ihJpYn9yfim3vRzoA+kr93SdPy1SGl8TzI+umVTMj5XS+9nnnMRPYuuD+rDVFCno3uiJI0EY9VRCT3BdTGcYyw86lZHYzTR00N0384zRhwd6yge1YeobZAkFfuKKRzb2DcY3/NGhtLXRX8wRmNz6fHbWl/cP1EpXac2Bn3eW8bS3znkaOrDOhmVET0HRtdEdD+T4vbl8GwwhpOnTgbW9Af9k+AZa6CS7n+M9MX3m53j6f5qdG1uG01fF3nauL3B9wrReP14MP4Snes8n1kTjC2cvC59310XPMtK0njQ5x0Jxvy3VNJt2G2T6eOYp50dCL6HivbhRzvGkvE1/XE7uz4Yj98zEbVh6XM9WCk+4rZ1OD2ePxN0yqN9kKS+PIP6yW0U/z6vEuQQXdtTpfRxiL5TmJ5LX/tS3IZF9SF6LohyzLON6Pcy+nJ8/xuJxssq/Sv/72fn6ddHxzJ61lwbtOV5xtMqwfdURcfT1ge/Q9MOufrtgejZITpX0e9ERX1NAACA5a4bejPvk3R4/v99/udM1SfhjJnZdkm3SHrSUevY/Of+Oc8GzKxH9YklR96yI0nfL5z56rNNUta3zd8uWO63mix/cGKdrAlSZxTM4yRJWU8YTMbCgkWDPACAlS+aNAIAAABg+Ysm3wAAVr4cvzcOAAAAAAAAAOgSq/63/tz9LjN7o6Q36Z5/BMskDc///PfHj/r/7ZL+MedmHidpXcP6ly8821Wv2Z+c2lmw3Gbrb0ysc1XGsuPNbL2771tkHg9psrzZW3gAAAAAAAAAAAAAAAAAAADQZm7d8A4DAECrdcvd4y2S/kN3v53Gm/xo/jMzkn7T3adylv9bDf92NX8rSzdrNuErfn9vWrP1U/X7iibLH1kgj3Mzlu2RdFOBMgEAAAAAAAAAAAAAAAAAAAAAQId1xQQcd69Jeq6kCyXVVJ9k0/jC+CPL9kj6VXf/Tp6yzWyrpN/Q3RN4XNJV7r6rBamvNnuaLG/2Zpy8mq2/O7HONcp+c84TC+SRte7F7u4ZywEAAAAAAAAAAAAAAAAAAAAAwArRFRNwJMnd59z9lZIeJOnvJV0taZ+kOdUnhlwi6VWSTnH3ry+g6JdL6tXdE3hM0kWty3xVaTYp6aEFyz2nyfKmE3DmJ8Vknadnmll5oQmY2QMk3T8j9LmFlgUAAAAAAAAAAAAAAAAAAAAAAJaXnk4n0G7ufp2kv5j/aYX3S/p4w7KbW1T2quLuY2Z2g6TTGkJPNbNXunt1kUX/WtbmJH0vWO9Dkl7YsGyrpGdJ+tgCc3hZxrJxSZ9dYDkAAAAAAAAAAAAAAAAAAAAAAGCZ6Zo34CwVd/+5u/+o4Wes03ktY1/KWHaKpN9dTGFmdn9Jz8kI/cjddwarXyrpmozlrzez3gXkcKakF2SE3u/uh/OWAwAAAAAAAAAAAAAAAAAAAAAAlicm4KDdPtpk+dvN7MELKcjM1kv6lKTyArbz39zdJb0hI3S6pAtz5jAo6cOSKg2hKUn/kKcMAAAAAAAAAAAAAAAAAAAAAACwvDEBB23l7pdJuigjNCzpUjP7jTzlmNk5kq6UdEZG+E5J/5Qzn4+r/iacRn9oZm81s55EDhslfV7SQzPCf+/ut+XJAQAAAAAAAAAAAAAAAAAAAAAALG9MwEEn/E9J+zOWr5H0MTO7ysz+2MzONrMNZtZjZqNmdqaZXWBmX1B98s2pGWW4pJe7++QC8nm+pAMZy18h6Udm9ntmdrKZVcxs0MzOMrO/kvQzSedlrHeFpDcuYPsAAAAAAAAAAAAAAAAAAAAAAGAZa/p2D2CpuPv1ZvZUSV+RNJDxkQdL+j+LLP4V7v7JBeZzi5n9uupvs+lvCN9P0nsWUNxNkn7d3WcXkgMAAAAAAAAAAAAAAAAAAAAAAFi+eAMOOsLdv63622Oub1GRByU9z90XNXHH3b8u6cmS9hTI4YeSznP37QXKAAAAAAAAAAAAAAAAAAAAAAAAywxvwEHHuPuVZvYQSa+W9PuSNi2imClJ/y7pNe5+e8F8LjGzB0u6UNKzJNkCcvgHSW9096kiOQAAAAAAAAAAAAAAAAAAAGCJGe8wAAAsXNdOwDGzx0v6RUkPlXS6pNH5n/4WFO/u3rXHdiHcfULSa8zs9ZJ+TdLjJD1c0v0klZusdoukKyV9W9JH3H1vC/PZLuk3zOx1kl4o6UmS7qt7vy1qWtL3JH1O0vvdvcibcwAAAAAAAAAAAAAAAAAAAAAAwDLWVZNEzKxH0islvUTS8UeHOpMRjnD3GUkfm/+RmVUkrZe0VtKIpElJByTtc/fJNuRznep15ZVm1i9p23we1fk8bnf36lLnAQAAAAAAAAAAAAAAAAAAAAAAOq9rJuCY2QMkfUTS/XXvCTfeyk21sKyu5e6zknbO/3Q6lylJ13c6DwAAAAAAAAAAAAAAAAAAAAAA0BldMQHHzM6U9HVJG1SfINPKCTcAAAAAAAAAAAAAAAAAAAAAAABYxcx9dc9FMbOKpJ9IOk33nnizVG+rcXcvL1HZwJL64A/vSDYKx4z0Jdc/a8tQMr524q4wB//595Lx7Z/9fDJ+x3duSsanDkyFOViplIyPHDucjJcr6fX71/Un431rBpJxSaqsSR/rwU1r0/FjNiTjpZ5KmENtbjYZLw+NpOObjkvGfTZdviTVDuxKf6CUbo6rhw4k43OH4/rSM5Q+n6X+wWS8vG5zMl45/tQwh9pIugwvp89nbShdH2at+Jzdnuiu67Vk2Krp+mC1uTiJ2fT5tCCHiPf0xp/pTV+7bun243A1fSDHpqthDodm0vt5y4HJZHz/ZHxtRvp60vs5MRvvR0p/OV2+JPUEnxmfSdepXYemk/GB3nT7s7Y/bmcjlVK6PkT7ODYVn8vDwbmo1tLPE73BuT5uJN2GStJZW9P33eOC22bPnnTfwObS51KSfPJQOj4dtC998X5GrDddxtzGk4MCgusiikvySvpgR/eLSjV9rG12IhkvTR9OxiXJS+kcvJLuz4ZyHKfpvtFkfGw63Q6PB9fd5Gx8v9pXsK2enktvo2Tx4/R0tdh9dThoR49bE5/LcpDncG/6fK4JcigHdTZP/ySqswr6cdF1N56jvkR1KqgO4b2iN8d9ObilaTB4xto8kD5XpamDYQ6K2o+edJ0brxUfCioHx2Gmmr7vTgXx6bl4HDDqTx6cTrcvs0EOtWAscrg3fvYY6Usf66mg0kY5Rv1AKe6vRu1kOaj0szna0NGgPxlfV+njuKYvPhdRO9obVOoNM3uTcf/pZWEOe7/9rWT8zsvSL7bef1N6XOCOHeNhDteMpfs41aDebwzq/bbBdPyEk9JjQJJ0/CNOSMaPffRDkvH+c34lGT+w6X5hDjcfmEnGo/Zhtla8f1IJxvyK5jCR4757MHgOi/ZjNngGi+4leVSCe3fURkXr5xG15f3Bs2bUxkV9Tan4PS3ah0qOkzUStA8Hp9P3rKL3Kyk+39E9LToXeZwSjKefOHlLMl697bpkPM84tM+kn/t9Kv28WhpOt9WlB56XjN/i65JxSbp9LJ3jjmAsK2pfWiG6J0b1ZTRH/ySq19F1sX4g3cfKU6eHgjYmGtOL+v194WC71B+0MdG12xN1JgN5Vh8I2vLefTenC9gRjPnlGI+b27MjGR+/5upk/NDt6e+ohrauD3NY85CHJeOVbWcm47X+9HdxB0fS/UBJunZ3+juB6DuD6blgDDlH8xLdFqP+xUBwbUbXnRS3g1EZUfux83C6P5xH1AeK7tvjM+lzlec4Rd/vROcqasvztLNRW3//jekxnJ696fYjj+j7PgX3vGgsPBqnkqTDo9uS8QNT6fMd9Weje0WeXv/Ow+n+6s/2pJ+5j1uTbsuPDX5/RYrvm9EY8sZyug/Vc3B7mEM0Blxde3w6Xgq+68/xu39Rfbhxf7ovuWci3YZF41SStHEw/ZlNQfyYvf+VjE9fc3mYw+z+/cn43p+k+x+3XnJDMj43ma7zZzz1Acm4JB28ZWcyPjOefn7ZcvZJyfjWpz49zEHB7wvVxvYl46XTHhpu4r23pX+34sUPP3Gpfq8TuIfpQwdW9y9Qo2P6RtbSjgGrWDe8AecluvfkmyMN23ck/bukH0i6QdKYu8e/aQ0AAAAAAAAA6HrR5BsAwMoXTb4BAAAAACzMix9+YqdTAAAAWLRumYBzZPLNkYk3t0m6wN2/0ZmUAAAAAAAAAAAAAAAAAAAAAAAAsFKs6gk4ZrZN0pm659tvdkl6jLvf2pmsAAAAAAAAAAAAAAAAAAAAAAAAsJKUOp3AEjvnqP831Sfi/BWTbwAAAAAAAAAAAAAAAAAAAAAAAJDXap+As6nh37OSPtKJRAAAAAAAAAAAAAAAAAAAAAAAALAyrfYJOOsa/v1Tdx/vSCYAAAAAAAAAAAAAAAAAAAAAAABYkXo6ncASmzrq/13Snk4lAgAAAAAAAAAAAAAAAAAAAGAZMOt0BgCAFWi1vwHnzoZ/D3UkCwAAAAAAAAAAAAAAAAAAAAAAAKxYq30Czo+P+n+TdEynEgEAAAAAAAAAAAAAAAAAAAAAAMDKtKon4Lj7dZJuPWrRCWa2rVP5AAAAAAAAAAAAAAAAAAAAAAAAYOVZ1RNw5r1H9bffHPHsTiUCAAAAAAAAAAAAAAAAAAAAAACAlacbJuC8Q9Jdklz1iTh/ZmajnU0JAAAAAAAAAAAAAAAAAAAAAAAAK8Wqn4Dj7mOSXqT6BByXtF7Sf5hZuaOJAQAAAAAAAAAAAAAAAAAAAAAAYEVY9RNwJMndvyDpT45a9DhJXzKzLR1KCQAAAAAAAAAAAAAAAAAAAAAAACtEV0zAkSR3f4ek50maml/0y5KuNbM3mNkpncsMAAAAAAAAAAAAAAAAAAAAAAAAy1lPpxNYKDN7X8EirpF0jiSXtE7SX0j6CzO7S9J1kvZJOlxwG+7uLyxYBgAAAAAAAAAAAAAAAAAAAAAAAJaBFTcBR9LzVZ880wouyeb//1hJx7SgTJsvlwk4AAAAAAAAAAAAAAAAAAAAAAAAq4C5t2ouS3uYWU33nDhTROPOt6JMqf4GnHKLygLa6us37E42CpuGepPrr+tLV/2BSinMoaeUvhQHx3ck46XdNyXjc3vS60tSbfxAMm6l9H5Y/1AyXhpZm4yX121OxuuFFJtD6cH6vj8+TnO7t6c/UKsmw9FxsnILmtLgXKmU3ob1VOJt1GrJsAfHoRzUBw2ti1MYGE3n0NOXLqAnfW3XetPnKo/SxP5k3Kqz6QI8OM7BMcgjui6i+jKVY27z3sm5ZLya3k2NTafr056JmTCH/VPpY33n2FQyvm883kaktyd9bY5PpY9T0fLzfGZyJn2sdx2aTsYHKun6MtJffC58tA/l4J460Bu3s6dtSF//GwfT7ceGwXQ72t8Td8EHgv1cX0qfi/Khncm4zabXlySbCV6SGbQP3tOfXj/HPa/WN5KMTw1vScYrSjcwUTstSSoH/YfKQDpeTteXqWr6+TSq05I0G5QxUwu2Yelt5EghbKsn59I5HAja6Z052uGx6eB+E4wFRMdh63DQt5BUKafLGOlN16cNg+l41DZIUrAb6g1OaHS++3LkEKkGdXIuiM8GfYfpueADiutkZDbIMc91Ez0HRschqrNRnZekmaD9iI7loZn0dRe1T5JUC/KcCnKIzsVc1NnMUcZsUEa0m0HToFKOClMJnvOi4xjJU19qUb0P9iO+38THIWqDKkEOx4yk2/JjhtP3bUnaMpjuw5QP3pmMl/bdnozPXH9VmMP+a65PxnddlR4n2n3tnmT8Z3eOJ+PXjMV9yYGg4p8U9KlPHkr3qTfdd0OYw8YzNyXjmx92n2R84D4PSsZLJ94/zKG69vhkfN9c+t6/83C6j3RHjnOxN3hmjq7/6NrP0dRrNhhHikR9h3aIcoj67Xn2oeg2oufl/nLxflxRee55UZ7RfTuq09E9NY+o39/XgmN9RjA2cfpg+tou778jGbdajnGo4DM+lR43sMH02GWtLxgrn4ufAz16Zg/GFfb2pu8nV92VvidK0v7JdFt9MHhWjfpA/TmewfL0o1KGg/GyPGMTg8G4YCTq9+c5DtG1F127Q8FxaEU72hvkMNyb3kY0LlDK8Tc9y+O702WMp/uKVk1fmz4XfO8hqXYoPSZXO3wonUMl3VcsH3tamMPcxlOS8YO19DbGg8GJn+2ZCHO47WD6e4mdwfcW0Vh3nmu3aP9jKBjrGgvG/PL0kaI+zkzQfkTxPN+tFO2HDQVtZCVH+xK19WdtTd/z1venc8jTY4/asOi5P2rj8ihPjSXjNpu+biLR9883HIqvq52H089p0T1ttC/d/gxW4hymgwe13cGz5jEj6Wf2oRy/AxNd3lG1j7aQp85OB2PA4zPRmF96/TxdsKidOxh8P3zS2vR3bWuDa1vKce1O7EvHx3alNzCVvm9rYE06Lmn6yi8n47WZ9LXdu+2MZLx8UjyGc3DtqeFnUg4F9em2g/EYzqNP2dCq3+MEkqbHD3Z+sA2rUt/wKO0YsIqtxDfgHLEUN75WlEmjCQAAAAAAAAAAAKwGeSboAAAAAACAlcc6/0daAAArz0qdgMMkFwAAAAAAAAAAAAAAAAAAAAAAALTFSpyAc0GnEwAAAAAAAAAAAAAAAAAAAAAAAED3WHETcNz9/3U6BwAAAAAAAAAAAPx/9u483JK7LPT9991jd6e70+mEDMyTcATBEAYROYgHBL0HERAQ5RwBQREfwAFn9DmAgILR4wURMHLlIggoIIKHSRACyEwS1OAVUSImQEKSTg/p7j2t9/6xdpudlbXrrb1r7fn7eZ719N71q/rVW7+q+tWvau23S5IkSZIkSZIkaecY2+gAJEmSJEmSJEmSJEmSJEmSJEmSpM3MBBxJkiRJkiRJkiRJkiRJkiRJkiSpgQk4kiRJkiRJkiRJkiRJkiRJkiRJUoOJjQ5AGhQRB4H7AecBB4C9wFDar1IAACAASURBVHHgBuAa4JLM/PrGRShJkiRJkiRJkiRJkiRJkiRJknYSE3C0KUTEnYFnAE8A7tpi/quAvwIuyszL1ji8wXX/JvDryxRfnJkPXcdwJEmSJEmSJEmSJEmSJEmSJEnSGhvb6AC0s0XEgYh4HfBl4FdpkXyz6DbATwOXRsS7I+K2axXjUhFxL+CX12NdkiRJkiRJkiRJkiRJkiRJkiRpc9gRb8CJiIPA3iWTMjP/Y0R17wLOHph8dWbOjKL+7Swi7g28F7h1x6oeBTwkIp6Yme/vHtlwETEOvA6YXKt1SJIkSZIkSZIkSZIkSZIkSZKkzWenvAHnk8BXlnxeN8K6dwH/MFD/r42w/m0pIr4N+BDNyTfXAZ9bnO/TwJUN8+4H3hkRDx9ZkLf0s8D917B+SZIkSZIkSZIkSZIkSZIkSZK0CW37N+BExHcD37JkUgIvGVX9mXlDRLwa+KUlk58eES/MzN6o1rOdRMQE8CbgrCHF88Brgddk5j8OWfa2wFOBnwfOGCjeBbwxIu6emYdHHPOdgRcNTO6xc5LYJEmSJEmSJEmSJEmSJEmStoUM//xTkrRyO+Hq8YTFf3Px33/OzItHvI5XD6zjPOAhI17HdvJM4N5Dpl8HPDgznz0s+QYgM6/MzBcvLn/ZkFnOAV4wqkCXuAjYs+T3v6f/ZiVJkiRJkiRJkiRJkiRJkiRJkrTN7YQEnEfQT4yJxX/fOuoVZOa/A59ZXMcp3zfq9WwjTx0yLYHHZuan21SQmVfSb+NvDil+csToUpMj4unAf1syqQf8JP239UiSJEmSJEmSJEmSJEmSJEmSpG1uWyfgRMRZwF0HJr93jVb3nsV/T70F57+u0Xq2tIi4NXC/IUXvzMyPraSuzLwa+K0hRbcCHriK8G4hIs4DLhyY/IdtE4UkSZIkSZIkSZIkSZIkSZIkSdLWt60TcIBvHfh9Hrhsjdb1uSU/x5B1q28wIeqUt6+yvr9YZvpdVlnfoD8ADiz5/Srg+SOqW5IkSZIkSZIkSZIkSZIkSZIkbQETGx3AGhtMwvhKZs6u0bq+OPD76RFxZmZet0br26rOWWb6YPu1kplXRsQxYO9A0XmrqW+piPgh4HEDk5+TmUe61r2ZHTox11g+Odactzc1Hp1jqOrYPX1acwV7z2wsntxzehlD7/C1jeUxOdlcPrWrsTynBw/Zm1soygEYb46B7DUXT0w1lo9NTpchTO070DxDb6E5hsndzctHnSeaE0U7jDVf6rIobxND1dbVWbEw0dzWObWnDGFuorktZxeysbwoZuZk8zYCVHPsnT7YWD5ZnPvj0Vy+kMVGtLDQK9qp2MgTc83HPMCRmeZ55oqdcX3RT193vB7qHJ6Zb17HseY6rrux+3Bqarz53DpWxFjWP1Gfu9UxVcVw3bGZ5vrHmuvft6v7UHxqYrwor67bdTudsbu5n+0V515VvneqbofZqeY69uxt7gN37zmjsTzmTpYxjI03t3Ulx5uvu+X1iPp6cHK+6Aer46HF9Yax5nZYGG++ps0WHemJYhsi6r7+6EzzOsp+uNe8fNVPQ93Pzsw3x3Bstrn85Hx9XT5ZrKO65lWOt7jmjRX9bHXt31X0UdMt+vpKFWPVl08W5aNQHXJVP9tmX891PB6qGKp2BqhuJas6dhXHQ5sYKtV2tjk31zqG8nhosatHMa7uEkObM7vazjqGtd3GUei6jZtlHZ0VYw9pqS1xTO8QXcea6xHDXIt7i3IdIxiHVWaKMXF1j7Ue+6JaR/Vsok2M1fOuK09vfi6wb/p2zSuoBiBjLe5vppsrmVko7kVPdh9T94p76rkTzeXXHDvUWH7Vkfr5SbU/TxT3u9U9WKtnfkUdVfmx2ebxR5v7wOnimV3Xr9LmJusx0kIxz65sbsvTprbBOKz47mZd7N5fzpJn3amxfGy++Tl09X3h3N5blTFcV3wHdMPJ5nP36Gzzs7DqWRnUz+Sq/mW2uCevzv0266j7l+Z2qmJso6qj/p5r7ccvXfdFm+dU1XWxumb1svk5drtnWc3z7J1q7mfnq+OtxbVifLz4m4KivLxuzzSXf/Xwjc3rp/77k4livHt4qrn/aPMd00wxZr62GGuO4nuurs9Pq2fpbe6Hu34HPYpnwFUd1fcOVVu36T+qv0faO9n8NzCnndn8Xdr4sW82lvd27WssB5h+wCMby2PuRGN5Fn9TNX/G7csYqmt/1dSHi+UPnWw+3iRJkja77f4GnKV/ZZ/A9Wu4rmF1N/+l38603J3MsQ51DkuIqf8arEFEHKD/9pul3pmZf9mlXkmSJEmSJEmSJG0do0jmliRJkiRJkiRtD9s9AWfwv3Oo//uF1RtWd4tXWOw4Vy8zvfmVJc2GLfuNDvUB/B5w7pLfjwLP6VinJEmSJEmSJEmSJEmSJEmSJEnagrZ7As7S9xUG3ZI8KgeHTPO/xLqlzzP87TQPWE1lEXE+MOz9wJ9aTX2LdT4MeNrA5Odn5pWrrVOSJEmSJEmSJEmSJEmSJEmSJG1d2z0B5/DA7+es4brOHTLt6Bqub0vKzGPAB4YUPSUiVpOw9ONDpl2amf+6irqIiD3AHw1M/izwqtXUJ0mSJEmSJEmSJEmSJEmSJEmStr7tnoDz1YHfz42IO6/Ruh48ZNpVa7Sure7lQ6ZdADx3JZVExHcBPzWk6KWrCWrRi4Glx8g88BOZ2etQpyRJkiRJkiRJkiRJkiRJkiRJ2sImNjqANXb5kGn/F/AHa7CuRw38/h+ZeWIN1rPlZeZHIuI13DJ55vciYhq4sEp4iYgfBF4PTA4UvTUz37aauCLiAcDPDMaUmV9YTX3rKSK+c1R1ve3vzRuTJEmSJEmSJEmSJEmSJEmSJGmpbZ2Ak5lfjYirgFsDCQTwCxHxR5k5O6r1RMT5wPctWUcCnxhV/dvUc4BzgMcumTYGvAx4WkRcBHwU+DfgCLAHuC3wQOApwEOG1PmexbIVi4hJ4I+5+VuhvgK8cDX1bQCPN0mSJEmSJEmSJEmSJEmSpDZirJ5HkqQBO+Hq8W76STGn3A74tVFVHhETwCsG1gHwrlGtYzvKzHng8cCvAicHiv8L8LvAZ4HrgDngMP03Gr2OWybfHAeeD/xAZs6sMqRfBe41MO1ZmXl8lfVJkiRJkiRJkiRJkiRJkiRJkqRtYick4Lxuyc+n3lDzGxHx1BHV/yfAgxfrPuV64J0jqn/bysxeZv42cCfgpcCXVljF5cBvAHfMzJdmZm81cUTEPegn8Cz15sx8/2rqkyRJkiRJkiRJkiRJkiRJkiRJ28u2T8DJzM8DH+SmN9ScSsL544i4MCKmVlNvRNwmIv4G+FFuSr6JxZ9/PzMH3+qi5SX9t9gcXuFyt6b/tpx7rHbFETEG/DGw9Dg4BPzcauuUJEmSJEmSJEmSJEmSJEmSJEnby8RGB7BOfg74HDclWST95KOfAx4bEX8AvD4zD1UVRcTdgGcBTwP2cVPSzal6vwz8zkij36YiYhr4TeA5wK5VVHEG8GTgyRHxUeDpmfnlFdbxbOA7B6b9UmZevYp4NtKDRljXJ0ZYlyRJkiRJkiRJkiRJkiRJkiRJW96OSMDJzMsj4heAV3LzZJkA7gRcCLw8Iv4J+DRwJXADcALYDxwAvgV4IHDbxeWXvlHn1O8ngB/OzNk13aBtICJuDbwPuNeQ4uPAXwMfBb5Kf1/sBc6hn2jyKOC8gWUeAlwWEU/IzPe2jOEOwEsGJn8UeF3Lzdg0MvOTo6rr7f/wtVFVJUmSJEmSJEmSJEmSJEmSJEnStrAjEnAAMvNVEXF74Be5eRIO9JNnxoFvA+7ZUE0s+TkHps8Aj8/My0YT8fYVEQeBvwXuPqT4lcCLMvPaZRZ/fURMAT8BvBzYs6TsNOAvI+KRmXlxi1BeSz+x55RZ4JmZmcvML0mSJEmSJEmSJEmSJEmSJEmSdqCxjQ5gPWXmLwO/BPQGi7h5Ms5ynxyY99T8XwEe3PbNK+LV3DL5JoGnZOZzG5Jv+jNmzmbmq4DvpP92nKWmgT+NiNOb6oiIHwMeOTD5tzLz/yujlyRJkiRJkiRJkiRJkiRJkiRJO8qOSsAByMwLgf8K/AM3Jdb8Z3HxWSroJ/L8KXBBZn5+bSPfHiLiQcAThxS9PDPfsJK6MvPvgR8dUnQ74GcbYjgb+N8Dk/8Z+K2VrF+SJEmSJEmSJEmSJEmSJEmSJO0MOy4BByAzPwXcB3gS8BH6yTWDb7s5ZdibcI7Rf4vL3TLzKZl5eN2C3/qePWTa9cBLVlPZ4luHPjik6FkRsdzx/Qrg4NJqgGdm5sxqYpAkSZIkSZIkSZIkSZIkSZIkSdvbxEYHsFEyM4E/B/48Im4FPAy4L/AtwG2AvcA4cAP9BJFrgcuAi4FLMnNhI+LeyiIigEcMKXpXZh7tUPWfAQ8fmHYOcG/6+2zQDw/8/lFgJiIeuML17h82bZl6rszMK1dY/4Y4fddkp+VPzPU6x3BoZvCFUze3sPu0xvIzzv6WxvKxk3XO3NjU7uYZ5ucai3sTze3Y23NGGUNvd/M8883NVJrvNVewe3JPXUk27++Ya85ry6KdY/ZEHcP4VGNxb7JYx0KxL1vsq1LRTow3Hy+zUV+uq3Ov3wUv7+hs82VtocWpPVGk9Z4oDtrZ4pgcL7ZhdqHjSQGMNa+ChSLGG+frhpor4jxZ1HFsdr6xvNqXANffONtYfl1Rfvh4c3kbUxPjjeVHTzafm7NFO+2Zaq4fYG9xzds73Xzu7S7WsXuyjmG6OHHGi4NyqjrxCrfaN13Oc5v9uxrL9041t9OB3c3lU+PFiQdMFu1wdKb5uD8xvq85ht3DhnU3l7vPbiyfKGI8XvTTR1qcu7MnmvuPb954Y2P55Ngo/v+F5j6ol83n7kI2b0PVTv15mtuqV6yj6odbHJKlk8WFs4phrte8/Ik2x0uLa9Jaq/qwXnY7Jttc+qv9OTHeHMNcce2fa3G8jBVjmOqY7araBuh+XlTrqNqgzTrGqoFaVX/H5aEeC860GTR31KuOyaK86ocBZor+o00dXcz16rF/NTYYwa1BqTp3x4oY5m7xsu2ba3M9qtqhl83l9fWoRf9RzDI20TzejOnmZw8x1TwWBRgvxqNTpzU/N5gsyg8W4/6HnLWHS2442TjP/mLcfnCquXz3geZ23H1G3U6T+5ufp03ubS4f29M8Zs4Wz5GyeIazUIxxqvvluRb9cFVHdW5XfWB1rYDNMU6r4qyum222s6uu6yiv/c2HYytVjOvRTtXxtBn21ShimJvsds2qrnm1bDGub+7Duj4TbDOerdq6bKeivE3/Vc3TtQ8cxfHU9XnabIt9MYp7pC71Q31/UsVw/YnmZzy7OrYj1M9GT59ufn5bxVDc8gMwNd78HdD0gTOL5at7k3pfVUOYseIroupwmL2x+Xke1N/fVH1UdR853WJnHCye1+8pnrdX98ttLgVdn9FU59X4nu5jrLW+7ra53lTzlOUd7/nbqPZF134Y6me4R2ab90W1nW1CrJ8LNC9f/b1A9d3rbfbv4l+vP944T3XujRXnXdX/jEX9rPzwTHM/WPVh1XcS1fdkALsmm/vB2aIfrmJYD/X4pq6j2o4TRfm1xXfUvaz/3mmyuHbPzDdfb8ZPa35Gs2v/uY3lcy3+9mPyYPNznlgo2mG6+XvRI7P1mPzITPF9X1FFta/aPMORJEnazHZsAs5SmflN4C2LH62d2wPDnlJ+vGO9H1tm+vkMT8AZ9N3AJzvGcMp9lqnrhcALRrQO7QBV8o0kaeurvmCWdEub4UsmaSVG8WW+tNNUf4gjbTZV8o0kaetzXC9JknRLVfKNJElbQXrPL0laBf/qT+vpVstMv7pjvcstf1bHeiVJkiRJkiRJkiRJkiRJkiRJkkzA0bpa7o1Lze+trC23vMe3JEmSJEmSJEmSJEmSJEmSJEnqzAQFradrl5m+3Jtx2lpu+W92rFeSJEmSJEmSJEmSJEmSJEmSJMkEHK2ra5aZft+O9d5/melDE3AyM0bxAS4eUv3Fy8z/go7bKEmSJEmSJEmSJEmSJEmSJEmSNogJOMuIiP0RcV5E7NnoWLaLzDwCfHlI0aMjYrxD1Y8btjrgsx3qlCRJkiRJkiRJkiRJkiRJkiRJAkzAYTHJ5n9ExKsi4pKIuDYi5oBDwJXA0Yg4GRFfj4gPRcSLI+K/R8SuDQ59q3rfkGl3Bn5sNZVFxD2BJw0p+kJmXr2aOiVJkiRJkiRJkiRJkiRJkiRJkpaa2OgANkpEPBh4DvAYbmqHWGb2KeAc4GzgoYvTDkXERcAfZuZ/rGGo282bgWcPmf6KiLg0My9rW1FEHATeAQx7e86bVxmfJEmSJEmSJEmSJEmSJEmSJEnSzey4N+BExIGIeCtwMfB4YJJ+4s2p5Jts+MSSz0Hgl4AvRcTz1nMbtrLM/ATw10OK9gIXR8QPt6knIu4PfAa425DirwGvXHWQkiRJkiRJkiRJkiRJkiRJkiRJS+yoBJyI+E7g7+kn3pxKpBlMsmkyLCFnGnh5RHwwIs5co9C3m+cBh4ZM3w+8JSIujYifiYgLIuLMiJiIiNMj4u4R8bSIeA/95Ju7DKkjgedm5ok1jF+SJEmSJEmSJEmSJEmSJEmSJO0gExsdwHqJiAcB76P/phW4ZbJN0E4O+TmA7wE+HBEPycwbVh3oDpCZX4qIRwMfAHYPmeV84PdXWf3PZ+bbVx2cJEmSJEmSJEmSJEmSJEmSJEnSgB2RgBMRtwbeQT/5ZljiTQ+4GPgUcCnwNeAwcALYB5xO/20r9wEeCtxzcdlc8m8sTn8z8P1rsyXbR2Z+PCIeCvwpcLcRVHmY/ptv3jCCuiRJkiRJkiRJkiRJkiRJkiRJkv7TjkjAAV4JnM3Nk2+CfoLNhcAfZeZVRR0X/+eCERcAzwN+hFsm4TwiIp6ema8bUezbVmZ+JiLuA/wa8JPArVZRzUngz4Ffz8z/GGV8kiRJkiRJkiRJkiRJkiRJ2n5y8L/zlySphW2fgBMR9wMey02JMrH4798B/yMz/32ldWbmJcCTI+KPgLfQT+6Bm5JwXhARb8jMuU7B7wCZeRz49Yh4EfA44GHAdwD3AMaXWewK4DPAx4E/y8zr1iHUYV4PfGRg2hXrHoUkSZIkSZIkSZIkSZIkSZIkSVpT2z4BB/jpJT8H/SSZvwEem5knulScmRdHxEOADwG3WVJ0a+AxwF90qX8nycxZ+slMbwGIiEngIHAA2Ef/bUU3ANd33W+jkpmv3+gYJEmSJEmSJEmSJEmSJEmSJEnS2tvWCTgREcAPctPbbwCuAX5kVEkcmfkvEfE0+kk9S9fzQ5iAs2qLbw+6evEjSZIkSZIkSZIkSZIkSZIkSZK0YcY2OoA1dk/gjMWfT7395oWZeWiUK8nMDwHvXrKOAB48ynVIkiRJkiRJkiRJkiRJkiRJkiRpY2zrN+AA3zrw+zzw52u0rjcCP7Dk9/MiYl9mHl2j9Ulr4vjcQmP53EKvsXxyPBrLd03UeX8n55rXcWS8Ocbp8eaubc/uMxrLAeg1xzB+43V1HR1Eb76cZ2Ks6MKzeRvGxsebYzhxvIwh5maK8uJlYzGCPNBiOxkr1pHN7XAjU2UIh2eaj8mZheYYTs43L390ZraMoTx3e9lYXi0/X5z7ozA21tx/jEVz+XrEWKnaGep+dKGoYq7on2bn63YYL9r67H3TjeXnnb6rsXyqRV9fxVBtx0LR1m1iaNNWXWKoVG0AcGK2+dysYqjWsZDdtqG/jubyMYpzuygHyjmi6B+qo6HFrqDa3cUQqEV5HURVx2RxzavGaaNQtdNYrzmGybHimG61CcU6mi/95fWmjcny1Kr6n+Z9uTDR/dztqlVfX52bRXmb80L12KGNXnk96HY9aXO96VXHS9W/RPMM9TbWbVnVMVdU0CaGStWWo4hhthivdh1DVdqMkcrOvDCKMVDVDm36ySbVOQH1/Ud13lTLtzp3q1mKZzRZPdsYq/f12GRzHVEMIMY6jpEuOLCLS2442ThPdU2ryqMY50U1KAfGqucjVVt3XR7oldeT5uWrPq7NNXEUfXFjDC3uE6t5upa36Ue73s92vScfRTtVqnYYRTutx75a6+cnXdsZWl67t7he5kjuFZtU7TjZop277opqHV3HN22M4tztWsfuYqzZ5lionsF0vd+dbrEvqv05WYwfui7faljf8VnWRDV8afHcsRynFU1dDyXrGLK4n60Ol+3yP66W9+QjuGZVquO++h6r1ry3xotjAWBsoupfVhTQLYziOVOlirFNO1f3Btfc2Pzd6rHZ5u/iR9EO5XaW/U+ba3/zPNV3kjNFedXOVTtC/Wyh6oer8/JIi/vhrs/Trj0+17x8i/5pTzm+aF6+aqc2Y4P6mlf0gcX3O+uhjHEEY/bqeCn/NqQ4JmcXmpcH2D3Z/Dcq01PN3+XPzjdvw5HZ+vnu9Seaj/vqsK/6hzbnjSRJ0ma2XZ7HLOc2A79fkZnXr9G6Ptdi/ZIkSZIkSZKkbaJKvpEkbX1rnXwjSZIkSZIkSdo6tnsCzmlLfk7ga2u4rmF171nD9UmSJEmSJEmSJEmSJEmSJEmSJGkdbPcEnKXvMwzWNiFm95Bp9TsbJUmSJEmSJEmSJEmSJEmSJEmStKlt9wScwwO/33YN1zWs7sH1S5IkSZIkSZIkSZIkSZIkSZIkaYvZ7gk4Vwz8fm5EfPsarev7B35fAL66RuuSJEmSJEmSJEmSJEmSJEmSJEnSOtnuCTiXDpn2jFGvJCLGgacCuWTyFzNzYdTrkiRJkiRJkiRJkiRJkiRJkiRJ0vqa2OgA1lJmXh0RXwS+lX5yTAA/FRFvzMxPj3BVvzKwjgQ+NML6JUmSJEmSJEmSJEmSJEmSJI1AL7OeSZKkAdv9DTgAb6GfFAP9xJhx4N0RcZ9RVB4RzwBeyM3ffgPwplHUL0mSJEmSJEmSJEmSJEmSJEmSpI21ExJwXg3cuOT3BM4CPhIRz4mIVbVBRByIiD8EXstN7Xjq7TcfzcxLOsQsSZIkSZIkSZIkSZIkSZIkSZKkTWLbJ+Bk5nXAi7jpLTjQT5LZB/w+cHlE/EJE3K5NfRFxQUT8HvAvwDO5KenmlAXgZ0cRuyRJkiRJkiRJkiRJkiRJkiRJkjbexEYHsE5+F3gE8DBuSpZJ+skzdwdeBrwsIq4GLgW+DhwBTtBP1NkP3Bn4dmDv4vKxpJ5Tvyfwa5n5hbXcGEmSJEmSJEmSJEmSJEmSJEmSJK2fHZGAk5m9iHg88AHg/tw8CQduSqY5F/i+hqoG36Iz6Pcz88IusUqSJEmSJEmSJEmSJEmSJEmSJGlzGdvoANZLZh4Gvgf4f7h5Ig30k2lOfaLhs3S+UwI4DjwzM5+3hpsgSZIkSZIkSZIkSZIkSZIkSZKkDbBjEnAAMvN4Zj4DeBxwBTcl1txstobPUqeW/RBwn8y8aO0ilyRJkiRJkiRJkiRJkiRJkiRJ0kbZUQk4p2TmO4G7Ao8BPgDM0fzmm8HPIeAi4N6Z+b2Z+eX13gZJkiRJkiRJkiRJkiRJkiRJkiStj4mNDmCjZGYC7wLeFRFTwAXAA4E7AGcsfnYDR+gn3BwCvgh8MjP/eUOCliRJkiRJkiRJkiRJkiRJkiRJ0rrbsQk4S2XmLPCpxY8kSZIkSZIkSZIkSZIkSZIkSZL0n0zAkXQzZ+yabCyf6/Uayw+fnG8sP3Rirozh8ExzHZXJsei0PMDkeHP3OBbndqp/7obmdpzrHS3r6GU2lo9Ft3bYMzleznP69B0ayw/sK9qR5hjbbMJC0Q55sq6jycyJmXKeyfFubT230LwNMwvNxwvAsdnm86ZYBfMt1lEZK8696pjs2IwwPtaxglFo047NcTb3wkDVRbYY3Y0X+2qh13zATE00b0NVfxvVOrrGCN3boSqv6l+PdqrsanHeTBbzTI5Vx0Nz/W1O3botuy5f74so+tGu62hzOIzgkNlw1ViyGt9U1zOor2lzxblbjSXbxFBtZ3XtPzm/0Fg+O19fb9rM00Wb86breTHe3Axl/wQw3nFMXKmPhxYHzBrrFcc81GPqrkaxH6r+oSofRQz1eLZqxzqGajs2g65jqK1gFNvQdaw4Cp3vsVrI6piNoq8uyqMYawJEcT0oy6vrUdGO69HOY8VKqnKo26Fevvk50VY586u+fD2uJ12N4p58re93u96rtomhq/WIcRTXgq5xdo1xFEZxzev6XLFcvkUzV3VUz0eg+Qanuldto6qi6z33ehwv6zEOq86r2RE8K+9l9TxtHa4n1fPVLLazWH6suP8pbukBmNwMj/TXWJtdXQ0vqmbqVePVVs9wiudl1Xi07GfrGKp1VOdVZazF/XY11uv63Wv1HVLxSLEfwxr3H21auXrWVMU4kudERR/UdWzQppm7fldff2fQ4twtZukV65jMbvuiTYxdnzvWY6T6xKnGONW+rJ73n2zxLH5uBOOLJm2+t6iOl6qtq+812qjacqZoyysOHW8sv6rFwL46Jqs+qhrHTYzgbxaqdezqeJ94dLYeqVX7orxuF8fTKNpJkiRpI5mAI0mSJEmSJEmSJElDdP+Da0mSJEmStBltlf9YSJK0uZhOLEmSJEmSJEmSJEmSJEmSJEmSJDUwAUeSJEmSJEmSJEmSJEmSJEmSJElqMLHRAWw2EbEfOACcAewBDgM3AIcy88RGxiZJkiRJkiRJkiRJkiRJkiRJkqT1t+MTcCLifsCjgAcA9wcONsx7BfAZ4NPAX2TmVesRoyRJkiRJkiRJkiRJkiRJkiRJkjbOjkzAiYgx4BnAM4HzlxYVi94JuCPwRODlEfFe4BWZ+aG1iFOSJEmSJEmSJEmSJEmSJEmSJEkbb2yjA1hvEXFf4PPAq+kn38SST7b4nJp3gv6bcz4QEW+OiFut75ZIkiRJkiRJkiRJkiRJkiRJkiRpPeyoN+BExC8CLwHGyEiJIQAAIABJREFUueltN7nCapbOf6qOJwLfGxE/lJkXd4tSEXEQuB9wHnAA2AscB24ArgEuycyvr0Mcu4H70H/z0QHgdGBuMY7rgX8A/iUzV3oMSZIkSZIkSZIkSZIkSZIkSZKkLWTHJOBExIuA5zM88SYGZp8DjgIngH30E0CWvi0oB/4N4CDwvoh4VGZ+aISh7wgRcWfgGcATgLu2mP8q4K+AizLzshHGcQD4n4uf+1CfI4cj4kPAHwPvz8zeqGKRJEmSJEmSJEmSJEmSJEmSJEmbw1g9y9YXET8K/Prir8nNE2cCuBT4FeBhwFmZOZ2ZZ2Xm7TLzQGZO0H8LymOA3wW+xs2Tdk7VOQ28PSLutNbbtF1ExIGIeB3wZeBXaZF8s+g2wE8Dl0bEuyPith3jGI+I5wFXAa8A7k+7BLXTgccB7wH+MSIe1CUOSZIkSZIkSZIkSZIkSZIkSZK0+Wz7BJyIOAt4FTd/4w30E2guBi7IzPtm5ssz88OZef2wejLz3zPzXZn5i8DtgScC/84t356zH7hopBuxTUXEvYHLgR/nlu24Eo8CLo+IR64yjgP0j4ULgT0d4vhW4GMR8fwOdUiSJEmSJEmSJEmSJEmSJEmSpE1m2yfgAL9A/y0lp5xK9HheZn5PZl620gqz7230Ey7esaTOU0k+3xMR37PagHeCiPg24EPArRtmuw743OJ8nwaubJh3P/DOiHj4CuPYB7wf+K6G2U4AXwA+DHwc+BLQW2beMeDFJuFIkiRJkiRJkiRJkiRJkiRJkrR9TGx0AGspIgJ4GjclxsTiz8/NzFd1rT8zZyLiCcDbgMdy87fsPJ1+woYGRMQE8CbgrCHF88Brgddk5j8OWfa2wFOBnwfOGCjeBbwxIu6emYdbhvMy4AHLlL0H+F3gY5k5NxDHfuBxwK8Adx+y7G9GxIcz8xMt45AkSZIkSZIkSZIkSZIkSdI66GU9jyRJg7b7G3DuA9xq8edTyTfvH0XyzSmZmcBPAteemrS4rkeMah3b0DOBew+Zfh3w4Mx89rDkG4DMvDIzX7y4/LC3F50DvKBNEBFx78VYBvWAn8zM/56ZfzuYfLMYx5HMfD1wPvDGYdUDIzvOJEmSJEmSJEmSJEmSJEmSJEnSxtnuCTj3GjLtd0a9ksy8DvgT+kkXp5wZEeeMel3bxFOHTEvgsZn56TYVZOaVwPcB3xxS/OSIaHNs/0+GnwP/KzMvahnHSfrbM+xtR+dHxLBjUJIkSZIkSZIkSZIkSZIkSZIkbSHbPQHn7IHfb8jMYYkSo/COIdNMwBkQEbcG7jek6J2Z+bGV1JWZVwO/NaToVsADW1Tx6CHTvsEKk7QycwF43jLFP7CSuiRJkiRJkiRJkiRJkiRJkiRJ0uaz3RNwJgZ+v2IN1/VvQ6aNr+H6tqq7LjP97aus7y+WmX6XpoUW35Bz5yFFf52ZMysNIjMvBf51pXFIkiRJkiRJkiRJkiRJkiRJkqTNbzBBZbs5suTnBG5Yw3UNq/voGq5vq1rurUBfXE1lmXllRBwD9g4UnVcseibDj/9VxbHon7hlwk0Vx6Zz6ORcY/ncQq+xfGa+uXxsLOoYTjTHUBmL5nXcODtf1jE10ZyfuG+qW/d5sminXman+gEmW7R1k2pfAuybas4z3F+UT403xzhdlAPM9prban6hubzayuNzdQzVdlRunGuO4trj9b6YK9pherzKuW0ub7OJk8U6qnOzYzOWbdBGFWNlpsXiE0WY1flfxTjXq4OYK86Lhanm8vGif6nK25ht0Qd1tVAcM9V2VNeKUejaltU2trkuV/3HdNEO48Ux22YLu7Z01Q69Fu2Q5bW523ZW7dSfp7l8V7Evqn3V5tq/0HGMUm3nKK4V1f4cKzahOi/aHY/VXNVYsHn56piGuv/o2ge26Z+mOo4NqrHFKFTHVHHJ7Dx+gRbHfdHWk0X9LYazpeq8qMYWo2inSnW9anPMjlXXi6IPHC/62ep4Apgv7rmrG5heVPtiBFfe4r+bqa4VXfsf6H6/W7XjeIuDdqG4oHS95k22iKFqh4nivKiWbzU+qfZFr/kZTBTlOXuyjKHX4jlP4zqKY7J67lCVQ4vzoiqfW2gs77XoYLLsX5rXkTPFviiWBxij2/WiOi/aXG/qebr1L63GSMX1orofrpZvE0PXe+6uY8U249muRvFsYjNY67Zaj3YaxTqq87+6d6j7j7Vvh/LaX7RTdU8PQHlud3tusLt43g/r80yvUp03XZ/ptbq3qMaCHcdhbZ5jd33G0vVZeRvVPVZVnlnEOIJNqB6FVcOw+plii3UUy1eXijaP86p5yvvh4rSqv6Oqv4Oe63hMVvVDfS/Y9fvb8nrTonuaHFvb52VttrHNPXOT0XxfWDx3XIfvscY7djLVtb9NP1w+Nywu3XPrMBbsFZ1U9eyivk+sz4nyO6LiuD9rz1Rj+e1Ony5j2DNZPfNvXr56btCmZzi4u/lvXGaLII7Ndh/nHSnquO54898KzRQxHp2pnxFdc+Nscx3zzXV0fbZ5YFf1RJ/y5N1VLt58RBw6UT9vO1L87dixk83tdLQoP3t/fd5IkiRtZtv9DThfWfJzsHzyxygM1r0AfHUN17dVLXencaxDnUeGTKueRW6WOCRJkiRJkiRJkiRJkiRJkiRJ0ia33RNwLoGb/bd6d4yI3Wu0rnsO/P7FzGxOm9+Zrl5m+pkd6hy27DeKZa4HhqXbd4njrFXEIUmSJEmSJEmSJEmSJEmSJEmSNrltnYCTmd8APrdk0m7gB9ZodU9a/DfoJ/28e43Ws9V9nuFvhXnAaiqLiPOBYe+l/FTTcpk5Tz9Ba1RxjAH3W2kckiRJkiRJkiRJkiRJkiRJkiRp89vWCTiL/oCbkmICeGFEDEvYWLWIuBfwo9z0tp154LWjXMd2kZnHgA8MKXpKRMQqqvzxIdMuzcx/bbHs24dMe2REnLuKOB4DHByYNoOJWJIkSZIkSZIkSZIkSZIkSZIkbXk7IQHnjcBnlvx+N+APR1V5RBwE3gRMclOiz4WZeeWo1rENvXzItAuA566kkoj4LuCnhhS9tGUVFwGHBqbtAV61kmSgiDgbuHBI0R9n5jVt65EkSZIkSZIkSZIkSZIkSZIkSZvTxEYHsNYyMyPiR4BPAreinyTz1IjYD/xEZt6w2roj4lvpv0Xl7tz0hp0PA/+rc+DbWGZ+JCJewy2TZ35v8e1EF2Zmr6mOiPhB4PX0E5+Wemtmvq1lHIci4qeBNw8UPQ74s4h4ZmYeKeK4J/BW4E4DRV8GfrVNHKMQEd85qrr+6vKvj6oqSZIkSZIkSZIkSZIkSZKkTSczNzoESdIWtO0TcAAy8ysR8d+A/wPcgX6izOOA746IFwFvXEkiTkTcBXgO8Cz6bXjqbSnvBX44M+dHGf829RzgHOCxS6aNAS8DnhYRFwEfBf4NOEL/zTS3BR4IPAV4yJA637NY1lpmviUibgv8zkDRk4CHR8TrgA8Al9N/W84E/USu+wI/BDyBWyYB/Rvw8Mw8upJYOvrEOq5LkiRJkiRJkiRJkiRJkiRJkqQdZdsn4ETE7Rd/PEY/6eb3gO+mnzRzFvB/AxdGxAeBzwJfAL5BP+njBLAX2E//DSfnA/8VuN+p6hf/7QGvAv43cDAiDq40zsz86kqX2coycz4iHg/8Ev03Bu1aUvxfgN9dQXXHgZcAv129OWeZWC6MiH8CLgLOW1J0FvDLi59WVQFvAp7T5c1KkiRJkiRJkiRJkiRJkiRJkiRpc9n2CTjAFfQTIwadmhbAFPD9i59KLPl5aR3PXvysRrIz9sXNLCbL/HZEvJ7+G3EeD9xtBVVcDrwFeG1mfrNjLP8nIu4MPB14MvAd9N/I08Y3gLcBr8nMy7vEIUmSJEmSJEmSJEmSJEmSJEmSNp+2CQZbXQx8WPJvLn4G51nus3SZYXWv9rOTJf232Bxe4XK3pv+2nHuMMJaZxTjmV7DMQeCuwH0iYsclUkmSJEmSJEmSJEmSJEmSJEmStN3tlGSBYW/AWc08o1zulB2bfBMR08Bv0n/7za5VVHEG/bfVPDkiPgo8PTO/vMpYnga8FDh3FYtPAd+3+HlRRPxUZn5gNXF08KAR1vWJEdYlSZIkSZIkSZIkSZIkSZIkSdKWt1MScLTJRMStgfcB9xpSfBz4a+CjwFeBG4C9wDn0E00eBZw3sMxDgMsi4gmZ+d4VxDEJvAF40pDiBP528fNPwPXAJHAmcF/6CTeD8d8JeF9EvCAzX9Q2jq4y85OjqutdX/zGqKqSJEmSJEmSJEmSJEmSJEmSJGlb2AkJOF+l+1tqNEIRcZB+UsvdhxS/EnhRZl67zOKvj4gp4CeAlwN7lpSdBvxlRDwyMy9uGc6bgCcMmf63wLMz85+WWe6twC9FxCOB1wB3XFIWwAsjYiYzX9YyDkmSJEmSJEmSJEmSJEmSJEmStElt+wSczLzjRsegW3g1t0y+SeCpmfmGauHMnAVeFREfAy4GDiwpngb+NCLulZmHm+qJiGcxPPnmIuCnMrPXIpb3R8QFwN/QfyvOUi+OiL/NzM9W9UiSJEmSJEmSJEmSJEmSJEmSpM1rbKMD0M4SEQ8Cnjik6OVtkm+Wysy/B350SNHtgJ8t4jgNeMmQor8DntUm+WZJHIeARwM3DBRN0H9LjyRJkiRJkiRJkiRJkiRJkiRJ2sJMwNF6e/aQadczPBmmlJnvBT44pOhZEdF0fD8ZOGPI9F/OzIVVxPE14MIhRQ+NiHuutD5JkiRJkiRJkiRJkiRJkiRJkrR5TGx0ANo5IiKARwwpeldmHu1Q9Z8BDx+Ydg5wb+CyZZZ55JBpV2Tm33WM48VDpn8vcHmHetfVoRNzjeVzC80vB5rrZecYDhcxLBTrGB+LxvITs3WOVVXHwp5u29kmhmo7K1MTzTmW1TYyM8/uyfHGWa4v9tVZe6Yay6fGm2OYLcoBFrK5nWYXurXjyfn6hVizC81xRrEZYzTP0Oa8mini7BV1nCzO7V3jdc5u1dTzxToqY9UxCxyfaz635oogdxXnTaU6HgH2FOdVta9m5lecJ3oL1Xbummg+d6u+4fTpeojZta2rfb13qo7h0MnmPmyyOOami22ojjeoz+9rbpwp62hSHU+9XnLuvl2N85y9d7KxvGynFv1HpTr9q1OvOmu6XnPb1FEdDm36j2qeuV5zPztWXK+q5Ueh2oZeUb5ncpyjxTiqOveq7exlfb2plPuqiHG2uGa2OWa7jpm7lgOMFYOgaqhXLd/GRNEH1etobsc2MVZtNYrtbDI9MV7ex1XjrOp6UhnFfWLVTlX/0RvBdbnrvqpihPp6UVnrfdnGeH0D1LmOLbGdHbXahuZheam6XrU4ZOna1Nn4/+cAY/VGjhVj/xhrXkcUx9NUUf7Ag7u55IaTjfPsLq5H1fFUbcM3L7+Wc88/u3Gezlrsi0qveP5R9YHVGKpNH1rN06av7mq2eIZT3lt0HOe1madNHV3rr9qhawxV/bPzve7PTztaj3vRStVObZTP0kdwzFbK7y0WiutNiy6u67W/6l+q6/LxuYXuzy6r50Tr0AduBtVxX/UNbUxWh1w13u14P91G12viXIvuo4qz6/OTqp0XSKpHk9V2VKd+Vd7ma5GqHaojslrFKO7Jq756erzoSKdHsI6Jbtesmfn63D5jd/Oz8H3FvccZu5vL21zyTs4376/qu9U2z5mbtPledbaIcbKIsbz/adFOX77+eD1Tg71TzcfsweJYaFPHTNFOE8VpU333AnBstvm8uPb4bGP5VUea72UnW3y/U8VZPcOpxjdfOVTv66kizup5+2nF956HZ+Y7lQOcfVrzd6/V3+mUY4MWx8tZe5qP6+q6e3S23s7Ktcebt7P8e6Xi+53DRf0A1xxp/u61GjNXx1MbB4o+Zu+u5uvJ7qL/qVx5/Ylynurvtk4Ux0P19yvX39jcP0mSJG12JuBoPd0eOHPI9I93rPdjy0w/n+UTcC4YdRyZ+ZWIuAq4zZA4pBUZxZevXVV/YC9tNlVChrTZjOKLz66q5Btps6mSb6TNZq3/aLON6o8Rpc1mrRNbpFGrkm/Ww5on30gjNoqkj65G8Qf22jk2w/ika/KNtN5GkSTUOQZPG20xVfKNtNm0SRJaa1XyjbTZVMk3ktbfJvizDUnSFuSdiNbTrZaZfnXHepdb/qwVxtI1juXqaIpDkiRJkiRJkiRJkiRJkiRJkiRtcibgaD0t98al+h2gzZZbvun4HhZL1ziWq8PzTJIkSZIkSZIkSZIkSZIkSZKkLWy5hIhNLyL2D0w6mpkb8kK4iLg98LNLp2Xmz29ELJvctctMX+7NOG0tt/w3i1huM+I4lqujKQ5JkiRJkiRJkiRJkiRJkiRJkrTJbdkEHOAG4FTCTQIPAj7TduGIeMjApEsy89gqYzmPfgLO0gQgE3Bu6Zplpt8XeGOHeu+/zPSmxJdruGUCzn07xEBEnAXccYVxSJIkSZIkSZIkSZIkSZIkSZKkTW5sowPoKJZ8VuojwIeXfO4xwpg0RGYeAb48pOjRETHeoerHDVsd8NmGZT4/ZNq3R8SdOsTxGIafU60TwyRJkiRJkiRJkiRJkiRJkiRJ0uaz1RNwsp6lZMLM+nrfkGl3Bn5sNZVFxD2BJw0p+kJmXr3COAJ4wSrj2AU8f0hRD/jgauqUJEmSJEmSJEmSJEmSJEmSJEmbw1ZPwNHW8+Zlpr8iIs5fSUURcRB4BzDs7TnLreeUDwDXD5n+YxHx9BXGMQb8v8AdhxS/PzOHrUeSJEmSJEmSJEmSJEmSJEmSJG0RJuBoXWXmJ4C/HlK0F7g4In64TT0RcX/gM8DdhhR/DXhlEcdR4KXLFP9RRLw4IqZaxHEu8B7gicNWA/xaVYckSZIkSZIkSZIkSZIkSZIkSdrcTMDRRngecGjI9P3AWyLi0oj4mYi4ICLOjIiJiDg9Iu4eEU+LiPfQT765y5A6EnhuZp5oEccfAJcMmT4GPB+4IiJeFBEPjYhzI2IqIk6LiDtExOMi4iLgK8Ajl6n/lZl5WYs4JEmSJEmSJEmSJEmSJEmSJEnSJjax0QFo58nML0XEo4EPALuHzHI+8PurrP7nM/PtLeOYiYjvB/4OuOuQWc4DfmPxs1LvAH5uFctJkiRJkiRJkiRJkiRJkiRJkqRNxjfgaENk5seBhwJfGlGVh4GnZOaKEncy8xrgIcD7RhRHD7gQ+JHM7I2oTkmSJEmSJEmSJEmSJEmSJEmStIFMwNGGyczPAPcBXgJ8c5XVnATeANwrM9+wyji+npnfD/w48MVVxpHAh4DvzsxfzMzZVdYjSZIkSZIkSZIkSZIkSZKkNZR+/KzRR9L2NrHRAWhny8zjwK9HxIuAxwEPA74DuAcwvsxiVwCfAT4O/FlmXjeiWP4E+JOIeCjwaOAB9BOE9iyzyLXAZ4FPAW/JzFG9zUeSJEmSJEmSJEmSJEmSJEmSJG0iJuBoU1h8Y8xbFj9ExCRwEDgA7ANOADcA12fmiTWO5SPARxbjGAPOWIzjdGBhMY4bMvPwWsYhSZIkSZIkSZIkSZIkSZIkSZI2BxNwtCll5hxw9eJnI+PoAdctfiRJkiRJkiRJkiRJkiRJkiRJ0g40ttEBSJIkSZIkSZIkSZIkSZIkSZIkSZuZb8CRdDP/du2NjeVTE815e+Nj0al8FHVUMS70soyhMjvf61xHkzbt1LWOqnws6hh2lcdD8/LVKlqEQBS7s00dTdq0QzXLeDFDdj8kyzjHquOh1215gPFill7H47raxsmxNnnFzefuZNdzr0XXUB5TxWZMFifWQosDqut2Vvt6spqhxTwLRVtW7Vj1P1C3Q9djbtcIRtpzRUNUx0O1K+50xu4yhjvsHW8sH5s52hzDsW82lsfsiTKGnDneXMf0nuYKormdeoevLWOIA2c3lucN1zSW7zr3Lo3lY3tvU8Ywu9B8fs8VY5xdxfFy3Ym6E5srYtg3XRwvHS/Mh07MlfPM9Zq3o1e003iLPqxS9Q/j1QCmsGuiuZ0Beh0HGGU/26KZqj6qMoJdseFa3Xus8X+N0uZYqM6LcixYbmf3sWTR/XBsdqFcR6Xuo4r+o+M2QN2HVap92SaGtVbdH7VRXY8q5TivRQfU9byp2qHNmH26uCev+uGu9/RQH/cxP9tcvtBcnrMnyxh6s/PN5XPN5fMnm8tni339bfunueSG5jir+7RqHVWMC3N13zF/cqaxvDffPM7Kal/2mmMEGCv60ap7qM7NNmOHep5ufdRUmxNnqrm4eu7Y9fls23maVGOcUTwjXusYRrGOrsu3iXEUz7K7xrDW62gTQ9cxTjUmrpq5l1k/f+1YXo0N2txPV01Z9aPV+KNVH1foesyN4ryp+tHq+UmbZ+V7p5ofDJ4+3Vxef39ThsC+IoaTxfWmOl6qMXk11gTYM9n8fOPArubyvVPdj8mqLaumnpptfjZKm+8t5uoxb6d1tNgXObGrKJ9uLD8yW41HJ8sYuj77rMbU1x2vnyse2NUcZ9UNVmPN+nuN+rrfdTxbPSZqc1ZVcXb9/rdNHzdd7Izq2j+K62513Zwv2qmKoc0Vs+t31JWuz/Pb1FGVV+OP6tlIG9Xzk2pf752qn9efVswz0/G6XH2vCm32RV3HWqvGD7uKXqrN3/HsK77ArcZhXf9W6ODe4qFAixiq8uo7pPGxeuyxuzhmy7/bmm9+Xl/VL0mStNn5BhxJkiRJkiRJklahSr6RJG19o/jjU0mSJEmSJEnS9mACjiRJkiRJkiRJkiRJkiRJkiRJktTABBxJkiRJkiRJkiRJkiRJkiRJkiSpgQk4kiRJkiRJkiRJkiRJkiRJkiRJUgMTcCRJkiRJkiRJkiRJkiRJkiRJkqQG2ykBJzd4eUmSJEmSJEmSJEmSJEmSJEmSJG1DExsdwIgE8KmIWM1yXZaXJEmSJEmSJEmSJEmSJEmStIX0/G/7JUmrsF0ScOCmZJqNWl6SJEmSJEmSJEmSJEmSJEmSJEnb0HZKwFlpLupgwk3XXFYTeCRJkiRJkiRJkiRJ+v/Zu/NoTbe7LvDffaY6p4Zbt27u6E1CEoiiTDEkCkRJC2EIQwei0hIaUddiBVwQpIGFNh1QGl1BhAi00ioiSJZ0aFoabINCYySRBAQNiYjRzMPNcKe6NZ959x9VtLF4a/+eqvfUOafqfj5r1VrJs99nP79nP3t69nv2fQEAAADgNnQ7bMC50Y0ze/3jcX6MDgAAAAAAAAAAAAAA4DZ0q2/A8aszAAAAAAAAAAAAAAAA3FS38gacv3bQAQAAAAAAAAAAAAAAAHD7u2U34PTebcABAAAAAAAAAAAAAADgpls46AAAAAAAAAAAAAAAAADgMLMBBwAAAAAAAAAAAAAAAAZswAEAAAAAAAAAAAAAAIABG3AAAAAAAAAAAAAAAABgYOmgAwAOl5Wl8b68Kn1ntw/TN7d3546husalzZ1h+uJCK2OoVDFU15g3PanLaXVxvj2WyxPOrz6zVsR4dHn+faBVUS0W6Zs742e5e+Q6A5qhussqhpNH6uH6/Mb2MH2jaHvLRUEutLpObhXtYkoeI6tFfaqedZIUxZQjxTUqS+MiSFLHuViU0271rHpdEEtF261iPLK0OExfXpjQfxSfWWjjwlzeHQc5JYaqTi4XBVF1k1X+1bO+fI0qj/limLNZXtaLsX23HvtLu+OxfW4T6kta9cDH6b04v+hCk9Tzjyp9d7FI73UQUz4zz/lVORRD5uU8qnIq8lioYpzwsKo50k5ZDkUfOGk+uxcN/Nqqcf+ycftf35mvf5jSj1ZjezVebBV9WDXHmjL/qcabSlUOU2LY2B73s1PeDUbWJ7wH3mzVs0zq+lA+q+L8efvQpO6DFqr+YULbndK25jGlL6/M2Wwm5D9hnjZnEFXbLJ/llDyq+W5RZ6eUw1Lxkba9MUzfvXB2rvQk2Tx3cZx+YWuYvr0+flG8VFTaKj1JLhRj3pmtcfrJC5vD9I2z43JOktU714fpW2fH5biyPk5vO+MYk6Ttjst6sZgz78WYdxjc7HXDm92PJykXu8r+ZbmOsZozz/t+VK2tTlGtde/FWnm11l3lUd3nY0X/MuUaVZ08vz7uh9dW6rXP6horc76DVc8qqcvh5NryMP3MpXE57BTz1eOr4/yT5MzF+nnOY0o5TXmeI8eLtfAp351sFuPuieIaJ4+Oy3pK/1H1xSdWxuurxet0pqyUVfV+o3wnn6+frK6fJLupvlMYn1+lT6mzrVrDnfc7xWrtNEnbGfcPfbFo/wtFu9ueME9r489UMVTlNGkZqagP5dl78K5ZmXc+Wr1GTlnzKz8z57rBlKlk2ynmeuVcsYihDiFHl8f9aBXDkcXx+VO+wz55ZL7v2laKDyxNqA/V6+jJ1XH/cEcxv6jKeS/WuqqyrtrVlL+JOF7MT6r73CrGzIvFO32SXCjm9dW4eWpl/Ky29mLBrVB9Vz/FXcWceauYI1XrzFPWoVfunO8+Hj8/35x7L95Fqxj24m+i1op2Ub2Dbe7BfQIAHGY24AAAAAAAAADMMGWzFAAAAHDr6fuxkxuA247txgAAAAAAAAAAAAAAADBgAw4AAAAAAAAAAAAAAAAM2IADAAAAAAAAAAAAAAAAAzbgAAAAAAAAAAAAAAAAwIANOAAAAAAAAAAAAAAAADBgAw4AAAAAAAAAAAAAAAAMLB10AHC11tqDSZ6T5J4r/xaTnE3yniS/1Xv/8E2+/lKST0jyB69c/85c3qz2RJLTHxPH5s2MAwAAAAAAAAAAAAAAOBxswOFQaK09kOSbk3xxkj9UfPatSX48yY/13s/uwbWPJvnjSf7ElX+fluRIcdpGa+03k/xkktf03i/MGwcAAAAAAAAAAAAAAHA4LRx0ADy5tdZWW2vfl+RdSb4txeabKz4tyauT/JfW2p+5weuutdb+dGvtp5M8kuRfJPnKJfEvAAAgAElEQVT2JH8k9eabXPnMC5L870k+1Fr79tba4o3EAgAAAAAAAAAAAAAAHG424HBgWmsPJnljkm9NsnYDWdyX5Kdaaz/cWmvXee6fTPLTSf50kqM3cO2PdUeSVyX51dba0+fMCwAAAAAAAAAAAAAAOGSWDjoAnpyubL759SQPDj727iQfvvK/H0jyrGt87huSLCf5uj0L8LKLST6S5OEkl5I8Jcmzc+3NQn80yb9qrX127/1DexwLAAAAAAAAAAAAAHtg96ADAOCWZAMO+661tpLkZzJ7882FXP41mZ/ovX/gqvOeluRrkvzlJMeuOu/lrbW39t5/ZI7QdpL8UpJ/kcu/zPNbvff/Zo51JfYXJHlFki+bkcfHJ/nF1tpze++bc8QCAAAAAAAAAAAAAAAcEgsHHQBPSt+Z5DNmHH9nkk/uvX/P1ZtvkqT3/oHe+/ck+eQrn73a32qtfdwNxPOeJH8lydN77y/uvf9g7/3fX7355koMm7331/fevzyXN+CcmZHfJyX5lhuIAwAAAAAAAAAAAAAAOIRswGFftdbuyuVfj7nao0le2Ht/b5XHlc+88Mo5H+tokr95HeG8N8nXJvn9vfdX9d4/dB3npvf+c0lekmTWL918R2vt6l/pAQAAAAAAAAAAAAAAbkE24LDfviHJiRnHv/F6NsBc+eysjTx/qrX2ByZk8S9zeePNj/bet6ded0Ycv5LkB2YkHUvyhTeaLwAAAAAAAAAAAAAAcHjYgMN++7IZx96d5LU3kNdrr5z7sRaSvLw6sff+SO996wauOcv3J9mdcfyL9ih/AAAAAAAAAAAAAADgAC0ddAA8ebTW7kryaTOSXtN779ebX+99t7X2miTfeVXSy1pr39p7n7UpZs/13h9trf37JM+7Kunj9uP6e21tZXGcvjxO39wZF/vObv2oV5bGewM3t+d7tIsLba7z9+MaU8ppdXFcTkeWxs/q4tbOMH1hQrN8/5lLw/SHzq6Pr9HG5bQ4oRiPFPVlp7iN6hqf+8w7yxhOPPaO8Qd2x2XdV9aG6Tt3Pq2MYb1oF7vF81yu6lORniRbu+MYFovnXdWH1eJZV9dPkjPr4x89O74ynhpNuUblaNGPVs/q3Ma4Pm0U/XCSHC/6+uWFcVk/fGFjmH6mjCDZ2h1fo+oGz6yP99FO6EZzfnNcH577wKwf7fuv7lob15dqejNlrKjqXFWnl4tO7gNnxs8ySd57enwfp9fH6QvtnmF6Vecv5zG+j+2z43L6k88eP8v+9n9SxpCPfmCYfOG/vH2YfueX3DtM31i5rwxhq6jY73r84jC96uMeu7hZxvCcB+4orjFu28eKPvBSMZ5V85fLnxnXl61icnB0uRpv6jpbjZt1HuO2Xc0Dp11jrGp3U55FNR+t5mmVKXPFatytntWl4j/bsFuU88KEvr6aI+1c/+vydavqy8JCMZcs5g7VeJTc/HLY7XUM1ZhUTQUXx9Vt0vyk6qMqVe8wpU5W5n3eG0VfX/U/SXJydTymVW27mjNXfUcy7b19HlPmivPO6zd2xn35Q+fqueKHz1dxjueCy3eN50B3f/5nlTEsfsE4/ZPPvWuYfvrn/vEw/eTr3jJMP/+rHxwHkOQFn/HgMP3jv/S5w/RTnz/rv2n0X/3K0ieWMdx3arz28HDRLh67OB4UL16a8L58abxOVLXd6h2uWjdIkgfvWB3HUORRtaszG/WPrZ8uJhgPrY/X2556cvwsp8yRquGmGhOrd9G7jy4P089v1nPJaq1rc3scw5mizj7r7mNlDJX1hWItbGF8n6vFfDmp1wWqtfJjxXvglPGsGrsrVYxPObZS5nG8GPur9Oo+p3znUOVxX9G/PHp+PK5W+d91vC6nR87WY/c8ptSXk0X7r/I4dXR8n1P6uLNFX1y1i1Nr43uY4oHjR4bpdxbriheKfnLKO3k1LlZ9cXWNhy+M15GmvAdW8+7jy+O++tSRYuyfMKfeLurkwxfH9WmxHR2mb054xzt+ZHyfZ4tn9db3ny+uUM+RVpeq73fPDtOr75iefnLcRybzjzdVnZvw1Um5tlmtXawujdOrGvnBx8fz5Smqcqza3ZS2W61dVHPq1aLtPmWtniNVLasasja2i+9vJow3aym+p1oejyfHd8Ztt10ar/cnSV8bf++wXPSD5ffHxflT5rPVOs9TirnDR4q1iSnjdvXdSBXDSlEhqr4jqXvi950Zj6vVs3rH4xfKGKqxveo/PnJm3EdNWcuq5t333FHMoVbHz+pCsW6Q1HPBqv1X91n9vdMDJ+oxsYqh+q6t+m7mP2+fK2Oo5u3z/l1X9bdpAACHnV/AYT89P7Pr3JvmyPPNM47dl+TT58jzRrx/xrH79zkGAAAAAAAA9tDN3ngLAAAAAMCtwwYc9tO1/vMb/3GOPK917ovmyPNGzPrPm+zLL/AAAAAAAAAAAAAAAAA3lw047Ke7r3H8iTnyvNa5z5sjzxvxjBnHPrzPMQAAAAAAAAAAAAAAADeBDTjsp7VrHN+YI8/1axx/zhx5XpfW2p1Jnjsj6Z37FQMAAAAAAAAAAAAAAHDz2IDDfrrWr9WcnCPPO69x/ONaa0tz5Hs9virJ8ozj/3yfrg8AAAAAAAAAAAAAANxE+7VBAZLksWscvz/JozeY5/3XOL6Y5GlJ3nOD+U7SWjua5NtnJJ1N8ss389pXxfGZe5XX97/BD/cAAAAAAAAAAAAAt6/eDzoCAG5FNuCwn95/jePPT/LbN5jn8wdp9+Ymb8BJ8ldzeaPP1X64975xk6/9sd60j9cCAAAAAAAAAAAAAIAnlYWDDoAnlX+X5NKM458/R56jc58yR76l1tqfSPItM5I+nOR7b+a1AQAAAAAAAAAAAACA/WMDDvum976Z5NdmJL20tXbv9ebXWrsvyZcPPnLsevO8jms/mOT/yOw29PW993M369oAAAAAAAAAAAAAAMD+sgGH/faaGcdWkrz6BvJ69ZVzr2WUdsNaa8eS/LMkszYN/b3e+8/djOsCAAAAAAAAAAAAAAAHY+mgA+BJ5zVJvjvJg1cdf1lr7dd77z80JZPW2jcl+criY3u+way1tpzk/0zyh2ck/2aSb9rra070WXuY15v2MC8AAAAAAAAAAAAAALjl2YDDvuq9b7bWXpnkx2Yk/2Br7ZlJvqv3fnbW+a21O3J5A8+UjS7rNx7pzGsvJPnJJC+ekfzOJF/ae9/Yy2tO1Xt/817l9QNvfNdeZQUAAAAAAAAAAAAAALcFG3DYd733f9Ra+xNJvnpG8l9K8j+21n42ya8k+ciV4/cneWGSL09y91Xn/EaS58/I6+LeRJy01lqSf5jkf5iR/P4kL+q9f2RGGgAAAAAAAAAAAAAAcIuzAYeD8nVJHkjyohlpdyf52iv/Kr+Q5MeTvHZG2sM3GtwMP5Lkz804/qEkn9t7f98eXgsAAAAAAAAAAAAAADhEFg46AJ6ceu8Xk7w4yd+bI5ufSvLSJGvXSP/wHHn//1prP5jk5TOSHs7lzTfv3IvrAAAAAAAAAAAAAAAAh5MNOByY3vt27/3rkrwwyRuv49QPJPmq3vvLeu/rSU7O+MyFJA/NG2Nr7fuTvGJG0qO5vPnm7fNeAwAAAAAAAAAAAAAAONyWDjoA6L2/Iclnt9Y+NckXJPmcJM9Ick8ub65ZT/K+JL+Z5OeT/HzvfftjsvjEGdn+Tu+9zxNXa+1vJvmfZiSdTvJ5vfffnid/AAAAAAAAAAAAAADg1mADDodG7/1tSd6W5Puu89RPnXHsTfPE0lr7G0m+bUbSmSSf33v/rXnyP8zOXNwapq/cMf7hrJXFcfrR1cUyhoXWhumP724O01eXxte4++hyGcNOsX3r0tbOMP34yjiGo8vj9KoMkuRZp9aG6fceG3fxK4vjayxsb5Qx7C4dGaY/sT4upw+dG9e3KS4Wz2JjZ3eYvrwwLod3PF6Xw6OX7h9fo2oXbZz+wcfOljE8cHz8LKpyOlLFWNTZJDm9Pl9ZV6p2MaXdnL40rnOn1sb9w9HlcfrW7rgMkuS+Y+M8qt2jR5fHz7J61klyz9GVYfqRpXFZVtdYXap/ZPGuoi9eyDiG9e1xWd93fHyPSXJuY3uY/uYPnBmmP3jH6jD9SFEOVV1IkuMr47686OJy59r80/0Lm+PnfaYox6rtn14fn5/UfdB6URA/9+4Lw/Tlp39ZGcNHzo/Hg6d89ouH6dunxzFuPXa6jKHq54qhPQ/eMa4P5zfrZ/EbD43bxbNOHR2mP3RufZi+uzvuBZ9S9F9J8ujF8VzxiWIsuL8YU+8t0pO6D3rkwjjGjaKPe9rJ8TwwSXaL/x5B1Y+eODJud49fquvL00+O+8n3nxnXh43tcf8zZey/qxjbq372HY+P+4+q/1nu9Zi4VYz+60U5VO8/U8bl9z92cZh+shi314r3n3d85HwZQ/WOtVmUQ2WlKKckWSvGmwfuHNfpp95Zt81KNZ/cKfrJxTa+h63i/CTZLOp1VeeWd8dt87GiD6zuMUmOrxwfpq8eGdf7aj5bvdMndV+9XL1zF33Y8kLddk+tjeOsesnN3fE1qjl5khSvklkr+qBq/nLXxQ+VMWR3PCb1pfG4fNcXvnSYfucLPmeY/tRf+H+G6Uly/1f++WH6zol7x+kL4/Hqabvj/imp14nOb47rdFUfLkx4F10s3g2qtarF8XA1ae2ianvV9GK1qvQTnF2fbz3sRNFHnVyt3wOrcqjmkh9dHPflTy/mq9WcPanX9M6s1897pHpnT5KtYpG46sOqtfIHTtTvFltFOVRrXcePFGvEE8qhcryoc9XYfn8xx0qSO4r7qNb0qvX+alxP6nbxtOL9p2qb1fvwlHfRE9U6UnEPi0XfUJ2/F3nce2y+de4kWSjGm+p5P1b0UVPWuU8Wdfb+Yt1gvY1jfLT4Li+p+7C3Pzp+T6v6sPPFmmA17ifJsaLOninWDY8uj2N83xOX5o6hUvUNZ4p+OklOTVjvGnm0WLes3tmTuhyq+6zmYXftwTp1VacfPTNuux88O16HSpIPnBk/i6oPetZd47XR+4o+bopqTHzfpXG9r9+H62dV5VGtx10o+ocpaxfvfWL8PE+t1t+/jDx4om6XS4+9e5h+7NTTxhlsj+tsXxnXpyS5sDUeL6r06r3gqcX3YBOWZ0unir8fqeazU95/qrXwDxTr1NV3J9XfAiT136hUfdyDa+P+49l3HStjWCm+/62+t3hGsfY5pRze8qHxd0xVnauuMWW+WpXVPcX3txeK9ZNqzHzPhPlJ1Q8+Wjyr6j3vD9x3ooyhuo9qTlx9n1e988N+mjD1AIDfY/6VdThArbXFJJ8yI+n1c+T53Un+yoyks7m8+eY3bzRvAAAAAAAAbh3VH58BAAAAAPDkYQMOt7rPS3LHVcfOJ/nFG8mstfbKJK+ckXQuyRf23v/tjeQLAAAAAAAAAAAAAADcumzA4Vb31TOO/dPee/2bnVdprf2VJN89I+l8ki/qvb/5evMEAAAAAAAAAAAAAABufTbgcMtqrT0zyUtnJP3tG8jrW5P8jRlJF5N8ce/931xvngAAAAAAAAAAAAAAwO3BBhxuZX83yepVx17Xe3/L9WTSWvumJN83I+liki/pvb/hBuMDAAAAAAAAAAAAAABuAzbgcEtqrX17ki+86vBWkm+5zny+PrN/MedSkv++9/76G4sQAAAAAAAAAAAAAAC4XdiAw4ForR2/wfNaa+2VSV41I/m7eu9vv468/kKSvzMjaT3JS3rvv3wjMQIAAAAAAAAAAAAAALeXpYMOgCett7TW3pTkJ5K8ofe+XZ3QWvusXP61mufPSH5dku+devHW2lck+QdJ2ozkVyU511r7jKn5Dbyl976xB/kAAAAAAAAAAAAAAAAHxAYcDspakj975d+Z1tq/TvLWJG9P8niSC0nuSnJvkk9J8iVJnnWNvH4tyVf03nev4/pflGv/AtRfvfJvLzwzyXv3KC8AAAAAAAAAAAAAAOAA2IDDYXAyyUuu/Lter8vlzTcX9jYkAAAAAAAAAAAAAACAy671CyBw2K0n+bYkX2rzDQAAAAAAAAAAAAAAcDP5BRwOys8m+Yok917neeeTvCbJX++9f3DPowIAAAAAAAAAAADgttZ7P+gQALgF2YDDgei9f2Nr7RVJnpPkM5M8L8mzkzwjyZ1JjibZSHImybuTvC3Jv0ryC73383tw/T+X5M/Nmw8AAAAAAAAAAAAAAHD7swGHA9Mvbx9+y5V/AAAAAAAAAAAAAAAAh9LCQQcAAAAAAAAAAAAAAAAAh5kNOAAAAAAAAAAAAAAAADDQeu8HHQNwiPzsb3942Cmc39wZnv+exy4M0+85caSM4aHTl4bpx1eXhunn17eH6U9c3CpjWFxow/SPnBnHeNfx8X3u7I773rXlxWF6kjzl+MowvbqHqhw3t3fLGKr7uNnpSXKueN733jF+FitL472oj5zdKGNYWxk/r+o+qmf18IQYqvpQPc9560sy/31W6ZeK/qd6lklypmj/1bPci3ZTXWNlcXwfl7bG5XBspX5Wi+OiztGiD3rk4uYwveqHk+Tk0eVh+mIbB3l+Y3yNKfWhqlPzPu8718b3mNRlvVCUw/bOOIatol0emVBOleWi7R5ZGt/j7oT3kbuL+nJuY/wsK3dNeFY7RZzVHOlcUWerupAky0Xj3doZx1hd46Fz62UM1TW2dsd18rEL4/6jGkum9LNVH1T1w3fNOcdKkruPjvPYKO6javsnJ4zLF4vx4vSl8Zi4F/3D8WJMmrcPmzJnPnlkHENVTlXbntKHVdeoVPWhcqKo80ldllW9P1LMX6aUU1WvHyja5n3HirnFbv0emJ3xZxbPPzI+v4/rdNscv0cmSV8u3iXveGCcwcL4WZ7v9ZhXtb07ijpVVdmqOkypL5e2i/GiGK8+cn78rFeW6na3VvSTT18ar49U9WXx7MNlDNvvfMswfffiuWF6Wz02TN957MNlDL0Y+ytbZy8O0y8+fLrMY/nY6jD93Ac+Oky/9Oi4nJYmzBX/5U//p2H6S77+M4bp9z7vk4bpfXs8h1r9wy8cpidJv3B2mL710LuG6SvPGse4c7roI5O0lfGzWrznqcP0rXufPb7Abj3mnunjfvbx9XEeVdt/+EI93lTz+mfeOY5xtY/rQ9ss+p8kWRiPu5eWTwzTH74wnnOfPFKsbRT9eJJc2Br3L6tFX71UzF9Wq8WRJK0Y1B4v3j2q8WhzQjmcXh/XqfVqza+4zUcnrJVX89nqGtXcolpXSJKF4jPLC+M6V8VYPKok9RylmlNXa3qVKe9o1btmtbaxH3bLtar515Gq+6zWNiZ0D6XqPo4Xc+qN4n15yntm1S7Ob477sOpddMqzqFTXqJ5F1TdUbWJKDJWqHKa0u+pZVdfYLOrLlLWsaj2+UpXjlLXPSlUOW0U5rBfpyfzPorrPqi+v+qeknktW353U+dfjTVXWVR7V2F+17aS+zyn3MXJHsaaY1GvA5RyquM8p35OfKcqh6gersaBa390LVbuo1rGrNpHU849KNZ+dMpZUcVYxVv3LXvRx1fc7VYxT2m71XdlqMYeqVPeQ1GU5b3pVZ6fUl2q8eaJ4T6z+3mAv2vYDxd9+PevUeA3o/Gb9rD71953cg5k51D74+PmDf1nmtvTUu47rx+A25hdwAADgAOzFl44AHG7zbr4B4PCrNt8AcOvbi40GAAAAAADcHmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgIGlgw4AAAAAAAAAAAAAAGC/7B50AADckvwCDgAAAAAAAAAAAAAAAAzYgAMAAAAAAAAAAAAAAAADNuAAAAAAAAAAAAAAAADAgA04AAAAAAAAAAAAAAAAMGADDgAAAAAAAAAAAAAAAAzYgAMAAAAAAAAAAAAAAAADNuAAAAAAAAAAAAAAAADAgA04AAAAAAAAAAAAAAAAMGADDgAAAAAAAAAAAAAAAAzYgAMAAAAAAAAAAAAAAAADSwcdAHC4/IcPnx2mb27vDtMfPrcxTF9Zqvf97ez2uWJYXGhzpU+JocqjirHK/9Lm9jB9L5xfH1+jijGpy6HKY7tIPzKhvizN+SzWVhaH6cdX5x8qqxjK9J1xelK3vXnbzWMXNssY5m03i22cfqJ4FlOe1T13HCk/M3JsZXyNteW63ez08WcWinKY0o9WtopntVPcxp2ry3PHsLo4vo/jR8ZlfWptHMPuhD5s6cQ4hsV6uBg6sjTuX7YmtO3dor6kKMeiGLNcnJ8k69WYVoRY3cORCTEcL9re0eVxWV/c2hmmV+0ySTaKcqiucXp9a5j+2MW6n63abqVqN6cvjWNMkuWiL6+exf0nVofp1dhftonUz6Iab6p7nPIcqvpS9fXHi/nJA8fr8ax6FlW9r+ZYE5puFjLOoxrSqpJemTCvr5zfGj+rJ4o585ki/fyEeX1VH+4q2m71rKdYXR4/jJViUFwrHuap1TrGzWJAqepkNV4dXarnihd3x3Gunvq4YfrSxvh9ui2eK2Nou+M6s7A+vsbG8fvGF6gG7tRta2n9iXH66Q8O0/vFM8P07Y+8f5ieJIsXx2XZVsbjzX33PDi+wFI93909Py6HjXf9zjj9ieIeFuqOtu+O6/1u0Qe1ojO/9PD4HqfksXLH0WH6ThHj1sX1Moad9fE8avPsxWH6xtnx+eunxzG84I89Nf/+zQ+Nr3F6/Lw3T4/LenF1ZZi+88j4+knSt4r55m4xZz79yPj0c6fLGLI0vo8U9X5psWibE9rNqSMnxulVHlvjOfP9d54qY2i7xbx7s6j3fdz2+9K4D0ySneVx27y0Oa4P1dzgQjHH2py07jhOr+YGVW2o38iT7WJ+UanePeoZb3KqWIOZ8o40cu+x+t2iehbVfLaaE29NmJ+Ua1lFenV+PW9vZZzVu+Ri8Z5XrSNNWafaKbrZai2qKqftCWtZla02X52t6tsUu0UME6rk/DEUbXdKu5j3GvOq1hXqPrC2UK3RFOU05buVeb+32A9VvZ/3u5kpquddpZ/ZmL//qJ7FpWoNeML8Y2fpYPuoal0zqcu6+j6wsjZhnalqW4t7MF5UqvpwoZi3V+X0RLGenyTvP3Op/MzIvN+zT/nMvOlVu5q3viXzl8OUPq76bnVKWY9MaTcb2+NrVGu81Zi43Ov34fJvL4op8dakt6ixet4+3zWmPMtq/rC1UORRLE1U69TL834BnfqdfXNhHEP1vesUVdM7XnznUH0fAPvpJr86AXCb8gs4AAAAAABwA6rNNwDc+vZiMwQAAAAAALcHG3AAAAAAAAAAAAAAAABgwAYcAAAAAAAAAAAAAAAAGLABBwAAAAAAAAAAAAAAAAZswAEAAAAAAAAAAAAAAIABG3AAAAAAAAAAAAAAAABgwAYcAAAAAAAAAAAAAAAAGFg66ADgaq21B5M8J8k9V/4tJjmb5D1Jfqv3/uEDiGkhyR9M8olJHkxyPElPcj7Jw0neleQ/997P7XdsAAAAAAAAAAAAAADAzWUDDodCa+2BJN+c5IuT/KHis29N8uNJfqz3fvYmxtSSvCjJn0/yBUnuKk7Zba39pyT/Jsnrkvxy7/3CzYoPAAAAAAAAAAAAAADYHwsHHQBPbq211dba9+XyL8h8W4rNN1d8WpJXJ/kvrbU/c5PiemGS30jyi0m+MvXmm+Rye/qkJC9P8nO5fD8AAAAAAAAAAAAAAMAtzgYcDkxr7cEkb0zyrUnWbiCL+5L8VGvth6/8Ws1exLTUWvuBJK9P8ul7kScAAAAAAAAAAAAAAHBrWzroAHhyurL55teTPDj42LuTfPjK/34gybOu8blvSLKc5OvmjOlYkp9J8oWDj11I8pEkH02ymeRULt/D3fNcGwAAAAAAAAAAAID9sdv7QYcAwC3IBhz2XWttJZc3uszafHMhyauS/ETv/QNXnfe0JF+T5C8nOXbVeS9vrb219/4jNxjTUq69+eZCkn+Q5P9O8m967zszzn9qkj+a5EuSfHGSe24kDgAAAAAAAAAAAAAA4PCxAYeD8J1JPmPG8Xcm+bze+3tnnXRlQ873tNZek+SXknzCVR/5W6211/Xe33cDMf1AZm+++Zkk39x7/+Do5CvpH0zyf13ZYPQnk2zdQBwAAAAAAAAAAAAAAMAhs3DQAfDk0lq7K8krZiQ9muSF19p887GufOaFV875WEeT/M0biOmLknzjjKS/3Xv/09Xmmxnxbfbef6r3/jPXGwsAAAAAAAAAAAAAAHD42IDDfvuGJCdmHP/G3vuHpmZy5bOzNvL8qdbaH5iaT2ttNcn/NiPpH/fev3lqPgAAAAAAAAAAAAAAwO3LBhz225fNOPbuJK+9gbxee+Xcj7WQ5OXXkcfXJ3nmVcceSWLzDQAAAAAAAAAAAAAAkCRZOugAePJord2V5NNmJL2m996vN7/e+25r7TVJvvOqpJe11r61975bxLOU2RttvrP3/vj1xnO7OL467hY2t4fFmp3d8aM8dXSljKHKY21lscxjXuV9FlX2xJFxOZ7b2C6u34bpSXJkab49lIsL9TUqK0UMVTluF8+6qgtT8pjXlBiqz1zc3BmmV+VUpSd1u6ie1dry+Px569uUGOY9/9hKPa3ZLdpu1bYrU85fbOO2t1rc5+7W+BrLi1Pa9vgzVR4LbRzjuc1xH5ckC0UftFCU03Jx/uJyXQ5VHlUMVX2qzl9dqutsFePRou2W5TihvpwvnueZ9XH6xa1xH1ilT/nMXoxplaqv39gZ99W7xfnVs0ySO1aXh+kPnV0fpp8s5if3HqvnaRvFmHSymEvetTa+h5WiThbFnCR57NLWML26h3PFuL2xXdfZI0vj53l0edyPztu2k7ovrtpuVaenzJGWF8f3WY15+6HqX8ychccAACAASURBVM4X8/b1opy2dupyqsaTxy5uDtPL+jKhj6zyqNKPF3PRS9vzLz+tFPdRlfTmbl3fLm2Nn+el7fFVjq/M+sHf/2p16UgZQ3aLPmZhXNYXi3vYnFAnq3H12MqxYfruytowfWF33K7a2jj/JFkoyqEtj8e0duyOcfrChP5pezzeLK4dHaYvb9Vz5nntLs93jcXVem7Qir6+yqMq6531cR+YJAvL4z6minGhmhMvjuvb2oQ59WLxvlrFWKVnaTzHSqq3wJT9S6p2UZ2fpBVxtpXVYXpfKupk8a46KY+FYsxaHKf35XEfmCTFsnVakV7ZXazrw4XNYsybc0ys1kcuFHPuKS4Vc8lqzjxhSl3Oeas5dVUO5/egHKoY67WwuUPIdjEnrubcU2Ko7mNemxNeNqs5UnWfN/sekmnviiO3QoyTlj4L89b7/YihWrM7MmFdsTLv2udyL9Zn53zWSd2PVuW0XIzbSf3evrU737g87Tumop8s8ri0B+NJ9R1R9TznbdtTVHVyL9aIq7Ku0qvv87aK9ZO9+E6ySj8Ma+l7YXEvOuM5HYayvtmqe5hyj/PWh+oae9Fubvb5yfzfQVemNIlD0GzqOlWMJ1Pm7WUMc5ZDNebdCuW8F5aLdaKlOZ81AMBhd/B/7cKTyfMzu869aY483zzj2H1JPn3CuS9O8rSrjq0n+SdzxAMAAAAAAMBt4nb4A1oAAAAAAPaGDTjsp3uvcfw/zpHntc590YRz/8yMY/+s9352jngAAAAAAAAAAAAAAIDbjA047Ke7r3H8iTnyvNa5zxud1FprSb5gRtIvzhELAAAAAAAAAAAAAABwG1o66AB4Ulm7xvGNOfJcv8bx5xTnfUqSp8w4/rZrndBae2oubyLaTfJIkkd771tTggQAAAAAAAAAAAAAAG5dNuCwn671azUnkzx6g3neeY3jH9daW+q9b18j/bkzju0m+e3f/T+ttYUkL0ny1Uk+N8kdV5/QWvvtJP9vkp/vvb/+egIHAAAAAAAAAAAAAABuDTbgsJ8eu8bx+3PjG3Duv8bxxSRPS/Kea6R/0oxjD/feLyZJa+2PJfmRJJ9cXP+Tr/z7S621X03yHb33Xymj3mOttc/cq7y+/w3v3KusAAAAAAAAAAAAAA6dftABAHBLsgGH/fT+axx/fj7ml2eu0/MHaffm2htwnj7j2Lkkaa19Y5JX5/ImnuvxgiSvb629svf+16/z3Hm9aZ+vBwAAAAAAAAAAAAAATxoLBx0ATyr/LsmlGcc/f448R+c+ZZD2wIxj51prfzHJD+X6N9/8rpbke1pr//AGzwcAAAAAAAAAAAAAAA4ZG3DYN733zSS/NiPppa21e683v9bafUm+fPCRY4O0UzOOPTXJD1517GKSH07yoiQPJjmSy7+s85lJ/tckD18j/79w5Zd0AAAAAAAAAAAAAACAW5wNOOy318w4tpLk1TeQ16uvnHsto7QjM47dm2TpY/7/G5J8Yu/9Fb33X+69f6j3vtl7f6T3/mu99+9M8vuT/OQ1rvH9rbVPHt0AAAAAAAAAAAAAAABw+C3VH4E99Zok353LvybzsV7WWvv13vsPTcmktfZNSb6y+Nhog1lV91+f5It67+ujD/Xez7TWvibJepKvvSp5Ocn/nORlxbX2wmftYV5v2sO8AAAAAAAAAAAAAADglmcDDvuq977ZWntlkh+bkfyDrbVnJvmu3vvZWee31u7I5Q083zThcqPNM1uDtNNJvrrafPO7eu+9tfaKJC9I8oeuSv6K1tp39N7fMyWvG9V7f/Ne5fUDb3zXXmUFAAAAAAAAAAAAAAC3hdEvhMBN0Xv/R0l+8hrJfynJu1prf7+19lWttc+98u+rWmt/P8m78ns33/zGNfK6OAhjc5D2d3rvDw3Sf48rm3X+2oykxSRfej15AQAAAAAAAAAAAAAAh4tfwOGgfF2SB5K8aEba3Um+9sq/yi8k+fEkr52R9vDgvCcGaT864bqz/NMkj+Zy/B/rhUl+6AbzBAAAAAAAAAAAAAAADphfwOFA9N4vJnlxkr83RzY/leSlSdaukf7hwbmPXuP4+3rv77uRYHrv20nePCPpM24kPwAAAAAAAAAAAAAA4HCwAYcD03vf7r1/XS7/Qswbr+PUDyT5qt77y3rv60lOzvjMhSQPDfK4VtpvXUccU8+/Z848AQAAAAAAAAAAAACAA7R00AFA7/0NST67tfapSb4gyeckeUYub1w5mWQ9yfuS/GaSn0/y81d+beZ3feKMbH+n994Hl333NY4/fn3R/x6PzTi23Fq7o/d+ds68AQAAAAAAAAAAAACAA2ADDodG7/1tSd6W5Puu89RPnXHsTcU5/+kaxy9e57WvduEax48nuSU24Fza3Bmmb27vDtOfuLQ1TF/fHuefJGcujvOo0k8eXR6mV/eQJCtL8/1A2PbuaP/XlHKuy+lcEeNia8P0KsYzxbNMkpNr85X15s44fWWxfg6XtsZldaQop+Or8w+FayuLw/TFhfGzeKKo05fObQ/Tk+Tc+jiPpSKGe06sDtOrcpyius/KU46vzB3DqaLOLhTtZqOo02c26v7l8Qubw/TzRVlX9/CMO9fKGM4XfdDdRT/60fPje7j32JEyhqrtnt8c1/sHjo+vsVX0cUldr6t+9KPFs9wd7gVOTh6p+5/1ovlX93lf0W4en9Au339mfZh+sXiWi+NizDNOHS1jOFKMB/ceH9fZ954e38NGMR5NsbUzfhb3FnX24yeUw9buOM6nnxz35VWMHz6/UcZQ1etK0ayyUoxXW6mvX8VY9fVVnV2eMD9ZLfqXEyvj9j9v/5QkW5vz1eudon+p5jdJslx8psqiqrNT+vrqeW4V7X+hCrKets+tKIayHBYmNNuthXE5rBd1ruqnJ7zelKqWt1v0D5tVQSbZLMqyp3h/2RmX08pKPUdqu+PC2m3jd4/1Yg5Vte2krnM7R4o59fJ4TOs74xgXjt85DiBJXxov37TVYlxdPTHOf0I/24pxeeHY+BrLxbPeD7vb47ngyno9N6gsHxu/n/TV+edhC8W4unVxPBfcLd6Pdoux4uTyuF0myZE7i/pw57jetyPjclw8Ubeb3UvXWra8co3VY8P0hSI9C3U5LKyM56sLJ+4apu8s1++7lb40jqG6j7YzHpG2Joy7u32cx3IRw0Ix5lVrflOUY0Ex567Gm3nfK/ZL9apYlcMePIpJY/c8tie8D9fz0XEe1Xy1WiNObn45TLl+9Q60U4zt+3EPU97TRvbiPXAv8pj3/OWF6p16rhDKNpEkG3vxEjSw2OogyvfZ6vwJc+J5Vdco1xXmvMfLFxkn787ZdtcmzBWrdaRKudZ1CNrulNOrcqiGi2p+UY3byYT+Y86vyqr8zxXv9FNU64brxfdcJ47UdbZ6FtX3O0eLdvH4hO+oq/nFwxfG77Pz/i1AUreb6hrVs1pdrmM8sjQuy+pZVP1sNeZN+S6/sh99/ZT19JGq/1idUA7nirWHqhwqU+Yn5bhbTJIW2/zP++I+zAUrU8pqZD/qbDX/qPqf6u909uKdvKr21bi+sjj/miDslQNecgDgFjX/7BgOUGttMcmnzEh6fXHqb17j+B3zRZST1zg+7y/rAAAAAAAAsM/24g/9AAAAAAC4PdiAw63u8/J7N82cT/KLo5N6748keceMpHvnjGfW+Rd67+P/1CYAAAAAAAAAAAAAAHBo2YDDre6rZxz7p733SxPO/Zczjn36nPE8f8ax986ZJwAAAAAAAAAAAAAAcIBswOGW1Vp7ZpKXzkj62xOz+JkZx+5urT33BuO5I8kfnZH0+hvJDwAAAAAAAAAAAAAAOBxswOFW9neTrF517HW997dMPP8NSd414/hfvMF4/nySozOO//IN5gcAAAAAAAAAAAAAABwCNuBwS2qtfXuSL7zq8FaSb5maR++9J/mBGUlf01p73nXGc3+S/2VG0geT/ML15AUAAAAAAAAAAAAAABwuNuBwIFprx2/wvNZae2WSV81I/q7e+9uvM8t/mN/7KzhLSV7bWnv6xJhOJPnpJHfPSH5V733jOmMCAAAAAAAAAAAAAAAOERtwOChvaa39RGvtc1prS1NOaK19VpJfT/LdM5Jfl+R7rzeIK5tjvj5JvyrpWUl+tbX24iKm5yb510n++Izk30ryo9cbEwAAAAAAAAAAAAAAcLhM2vgAN8Fakj975d+Z1tq/TvLWJG9P8niSC0nuSnJvkk9J8iW5vClmll9L8hW9990bCaT3/kuttb+R5DuuSnpqkte11v5tkp9L8jtJHkty8kosX5zkRZm9ke3RJF/m128AAAAAAAAAAAAAAODWZwMOh8HJJC+58u96vS6XN99cmDOGV+byZp+vnZH2R678m+rhJC/pvb9vzpgAAAAAAAAAAAAAAIBDYNYvd8CtYD3JtyX50j3YfJPee0/y8iR/Ocn2HFm9Jcnze++/Nm9MAAAAAAAAAAAAAADA4eAXcDgoP5vkK3L5V2eux/kkr0ny13vvH9zLgK5swvne1to/T/KqJF+UpE08/V1JvifJT/bed/YyLgAAAAAAAAAAAAD2Tu8HHQEAtyIbcDgQvfdvbK29IslzknxmkucleXaSZyS5M8nRJBtJziR5d5K3JflXSX6h937+Jsf220m+pLX28Um+LMkLk/zBJPcnWUtyNsmjSR5K8sYkv5Tkzb33eX45BwAAAAAAAAAAAAAAOKRswOHAXPnFmbdc+Xfo9N7fleT7r/wDAAAAAAAAAAAAAACepBYOOgAAAAAAAAAAAAAAAAA4zGzAAQAAAAAAAAAAAAAAgIGlgw4AOFze9oEnhukXN3eG6ecvbg3TLxXnJ8nDZ9eH6Tu7fZh+fHXctU2JYWVpvD/xzPnNYfpicf7WxnYZw25xnx8qrtFaG6Y/+/fdUcZQ2dzeHafvjNPL/Oc8P0meuDSuk+fWx89iL2Ioy2l7XCe3i7ow6RrF+R88fbG8RqVqm1V65R0fHaevrSyWeZxYXZ4rhp3d+evDvOVwvLiH//DQ2TKPE0U/ef+dq8P0R85uDNOn9LNV26w8655jc52fJHcfWxmmLyyM+9GHz43LYYpTR8cxVFaLsaByZr1+Do9fGvcg54t+dLEox1Nrdbs8ujxu3ye3x3X6TDHubk/o63eKpnt+c3yN5cVxOawX/XiSbOyM29aRxXE5bRV92EYxHiV1OVT3URV1lX+VniRbxYd2+ji9uofd4vwk2SrqffUsFnbG56ce8spy2CrGoyp9SjlUdntVTkWME9ru8mIxLy+usVHUhyo9qetcNTeo+tEUrxZF95Ok7qMWirKu6nRVBlOU/UPVvyzUMVR5VKNuNW/fnNCJLbbxVar6Ul1jyrOo7rN6R1paPjJM7zvjuebCWj3Pq1pelcfuUjH/WKiXTBd2xvOotjK+z3ZknN6LcT9JWjH2V3lUz7oVfegUbWG+PKbEMO81KgtFDJ/wec/MO3/pPTc1hsqU+jK3hQkTkFtA6+MepPc56+yEz0wZm0d6seZXrSkmE+YnRXo1nOzBclqpvEY19k+YnlRz3mrOXZ0/ZY1o3nl5VR+q/JN63l3lcWlr3EdNWUea8pl5THkW5bx8zmvMu2aY1DFW33vM/W6yR3mMVPeQ1OvEU/KY13wrn/W65G4xFiR1N1j1H8tFDItFDFPWcOYdE6sYp8RQrQtO6SfHGdT910YVQ3Ej85bjFGWd3IM+7EjVRxWXqJ7l+oQJSnUfVQzl2F+knym+Z98L1Xr+lD6y+k6y+u61ukY1d0gmrI/M+d3slPGqukb1dxXV+VOexbzzi+o+501P6rY9fwx1Oc07B6rOX9mD9ZOjxfxl3nneFDe7viR1va9ieKLoJ6eUQ1XW1Vyy+j7wodOXhul7UU6PXRh/d7tWfK8675w8Se44Ml4/feTEeI34dDFWJMnHXVdEAAD7yy/gABxCe7FQDcDhNu/mGwAOv73YeALA4XbQm28AuPn24g/UAAAAAAC4PdiAAwAAAAAAAAAAAAAAAAM24AAAAAAAAAAAAAAAAMCADTgAAAAAAAAAAAAAAAAwYAMOAAAAAAAAAAAAAAAADCwddAAAAAAAAAAAAAAAAPtlN/2gQwDgFuQXcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABpYOOgDgcLnr+JFxenH+U562MkxfWar3/T3rnmPD9J3dPkxfXGjD9MfOb5YxvO+xC8P0u+4Yl9OR4j5PHj0xTF9bXhymJ8n5je1h+mPnN4bp73t0fI8bRf5JslTEWT2LytpKXQ7VNZaK9O2iPlX1bUoMm9u7w/RLmzvD9K0Jz2JnexxnK5reYlFnq2c9RZ9QliOtKOcp9e3S5rgsqzzm7X+S5GLxvCsrS+NnsbJY97PVfcybvhfmvca8/c9+WJwQ4s7NL+o6hptcH6bc47zlUJX17pT6UtznQhvnUaVPaLpZ2J2vXu/2+StUlce83UOV/5Rb2JoziCqGKfWximG9mBvsjJOzPKEubBSZbGyPx6Pt4vx6dlKX1U7R9vbiWSwUz2K36uPKGG7+mLlY9R9FdVjYgzFx3nG1uIUk09r3PNeYkn0Vw+6kXA5W9aimtJuqLNuUBzrSx/1L3y06wUmXGOfRqhiK9L3Qd+Z7L7hd9GrQm5LHnHVmt4ihepd95n/39Lzz9e8bfmZnqxg596DeV9rC/O/1h161+JGkLxRfiRR9XC+uMWWkqKcHxbtHDv/7LtPsxTvavKr57OXPzHmNW2CdaaN4R0vqdeZKtQ69H86tT3mTu7Z5y2AvVGvtyd6s4c57/pTvwoaKqWL1npjUa1FbxfxjeWF8D9W76JS+o+oH63uY7/zLefx/7N19tGbZXRf4777vt+reqq6ufkt30ulOaBhCSEBQTER5WyNhdPCFuFBnzYwIC0URBoZZy0HFgIlrdBQEcbk0CjMqaw0ywgJfYFAwkVkhAXmPBgJJSDpJv1d3vd73u+ePLpym8tT+PVXPrXtvd30+a/UffX7n7PM75+yzzz773F3P+DzsFAcy6zEk9bncLPqr1bWa5nlTjl0ewu1f1Zl6nGgcr67lQeyjchDPvFv93Jym/Oq5ubEz2/tu9d00SfaKe7f6FlcdZ/WtP6nPw6x9oIN45lXvs9X4bLV99e02STZm/PZ6EKpn96zxw3AccjgI1b01a595mnu3UtXJ2b/11zlW9/807cPIrz9xsVynOg//pjgP1d+f7E7xrHjHN3xeuQ4chGMwPAPAi5BfwAEAAAAAgJtQTb4B4MXvOEw8AQAAAADgeDABBwAAAAAAAAAAAAAAAAZMwAEAAAAAAAAAAAAAAIABE3AAAAAAAAAAAAAAAABgwAQcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAZMwAEAAAAAAAAAAAAAAICBhaNOAK7VWnt5ktcneTjJqSR7SZ5L8v4kP997P3+IuZxO8juSfHKSO5LMJ7mQ5ENJfrH3/rHDygUAAAAAAAAAAAAAADgaJuDc5lprr0ryWdf8d2bCql/Qe3/HLcxjLclXJvmqJK8drLrbWntnkr+f5Ad77/0W5NKS/NEkfy7J78vgPmmt/UqSf5zkH/feLx10LgAAAAAAAAAAAAAAwNEzAec20lp7OMlnp55sc6haa38oyd9L8sAUqy8k+aKr/72ntfYVvff3HWAur0nyvUl+15SbfHqSv5Pkf2mtfU3v/V8eVC4AAAAAAAAAAAAAAMDxYALO7eUXkpw+6iReqLX2LUnekqTdxOafk+cn4Xx57/1HDyCX/ybJ9ydZu4nNH0jyw621v9p7/2uz5gIAAAAAAAAAAAAAABwfJuBwZFpr35zkW68T7kk+kOTRJItJHkly74T11pP8UGvtTb33d8yQyxck+cEky9dZ5fEkv55kN8mDSV49qZgk39Za2+m9/283mwsAAAAAAAAAAAAAt85+P+oMAHgxmjvqBLg9tdZ+f5K3TgjtJ/muJA/33h/pvX9h7/339t7vS/KGJD8+YZvlJN/fWrv/JnO5P8//8s2kyTc/luRzeu8v673/vqv5fFKSh5N899V8r/W2q8cHAAAAAAAAAAAAAAC8BJiAw0eS/FCSv5TkTUk++1bvsLV2Isnb8/wvxrzQZpI/2Hv/+t77h6/drvf+7t77F2fyxJ17knznTab0XUnunrD8W3vvX9J7/5kJufxm7/0vJPnSJFvXhOeS/MPW2upN5gMAAAAAAAAAAAAAABwjC0edAIfqI0l+I8nPXf3vP/ben37hCq21hw4hj29M8uCE5V/de//RauPe+19prT2Q5CuuCb25tfbG3vu7pk2ktfa5Sb5sQuh7eu9vmSKXf91a++ok/+c1oVcm+YYkf33aXAAAAAAAAAAAAAAAgOPJL+DcRnrvr+u9/9He+9t67z927eSbw3D1V2G+bkLox3rv//QGivqGJE9OWP4XbzClSes/ebX8qfTe/0mS/2dC6Otbays3mA8AAAAAAAAAAAAAAHDMmIDDYfsjSe6esPwtN1JI7/18ku+YEPoDrbX7pymjtfbyJF8yIfTtvfcLN5JPJud/T5I/fIPlAAAAAAAAAAAAAAAAx8zCUSfAbedPTFj2y73399xEWd+T5K1J5l+wbC7JH0/y7VNs/+X5xElou1fLvSG993e31t6b5LXXhP5kkv/rRss7Sp/2wKlhfG+/D+MvPzX+0Z8Ti/PD+DTrzLU20/aPXdoqc3jv4+M5WEsL4/mLp5bHzeuZ1cVh/PTKOJ4k5zd3hvGPXtgcxs9d2h7Gn7xYn6c7iuOYnxtfqyq+ulTXl2qdje29meJVnZ9mna3d/WH8/Mb4Wj53ZXytkuTS5u4wPuu1qOr8NLaL81CdxyqH5SlyXF2areuzvTuuLwehOg9VDttTnIcrM94X1fbVtX5+H+M6W52Hqs5PY9b74vyV8b1bHUNVflKfy6oNXC2eic8W7U+SPHVh/Dx4rihjvnhu33lyqcxhoziOlaLeP11cq80DuLdnrZPnprgW1fOkagd39or7qri3k2Svj8u4uDU+D9snqr7D+Bj26uYlO8VKxWnITnHvVucxSRaL+7vqXuwX53mK7snM52GKwyzNzXgc1bWYxk5RZ2a93gfRl6zsLRRlVO9YU+RQtdXVO9jy/Pje3d6d/TxUOVbt095+/dytymhFGdX1nqY+zM2P99HL4xyXP007mrnxPnar42hFf3Ru3Cdvi8vj7ZNkf3zvVWXsz4/7H73I8fl1infmhfE+2vJquY9KK56b2S8u+Py4/VhYmeJaFOZXivNQtB99ikpblTG/OL6e80WfuhfPgqp9miaHtjjuI7WFIr5Y96mrFqgtjcf02vI4Plfcl0mS4jj6fBEv7quy/UmSueJ6V21UxmM00/QVqzV6UaWqKle200l2izyrV6Tq3aR6pm5OMW5Qqfon+8WJrHJM6uu5VbRRVZ98mnewW21/ivpSvTNXYxezjs8mU9S5Gfth09SHWc06TjTN86YeRZ7N3hRjWbfaNONps475VaYZK59mfHRk1rHyg9hH9VcE1UjWQXxbqezsF/3AKe6b6v6f9VrOWt+Sup08iDpfXYtpvtfNUn4y+zhQ3TeYva0/iGfarNvP+jypnqnT1Pntqo9TfMOuvnMdxHjarN8kp7kWm8WY/m4xMFn1wxYW67a+2sdOMV5f2SvOYzVOlSQLU/x9yEgr6vQ05c8VZVTjcZX5KZ7L88XYxUJRxtrK+MG8PsXflxzEM2lWZ4tvgtVxVvGzJ+rxkerZ/8zlca+6+jubg2jDKtVz+c618XlYKupjkpwrzsNHn90Yxh+5d20Yn+ZaAQAcZ34Bh0PTWltK8oUTQv/iZsrrvT+Z5KcmhCb9qs0kk9b7qd77UzeTT5L/e8KyL7x63AAAAAAAAAAAAAAAwIuUCTgcps9JcmLC8p+YocxJ235ua234zztcnRTzew4hl5N5/rgBAAAAAAAAAAAAAIAXKRNwOEy/c8Ky3SQ/N0OZPzNh2UqSTyu2e+3V9a71nhly+fkkk36L+LNmKBMAAAAAAAAAAAAAADhiJuBwmF43YdkHeu+bM5T5y9dZ/vqbyCVJ3nuzifTeryT5jZvIBQAAAAAAAAAAAAAAOMZMwOEwvXrCskkTVqbWe388yeUJoVfdRC6XrpY3iw/cRC4AAAAAAAAAAAAAAMAxtnDUCXBbeWjCso8dQLkfT/LIFPuq4h8/gFwmHc+kfR2o1tobDqqsv/uuDx5UUQAAAAAAAAAAAADHTu9HnQEAL0Ym4HCY7p6w7IkDKPfxfOIEnEn7OqxcptnXQXvXIewDAAAAAAAAAAAAAABuS3NHnQC3h9baiSTLE0LnD6D4CxOWnS22ufMQc1ltra0eQNkAAAAAAAAAAAAAAMARMAGHw7J2neWXDqDsyxOWnSy2mZTPrcolqfMBAAAAAAAAAAAAAACOKRNwOCyL11m+ewBl70xYtlRsMymfW5VLUucDAAAAAAAAAAAAAAAcUwtHnQC3jfnrLN87gLInlVHV7Un53Kpcklt/r73xAMt61wGWBQAAAAAAAAAAAAAAL3om4HBYrvfrMgdRByeVcb1fovktk/K5VbkkdT4z6b3/9EGV9d0//aGDKgoAAAAAAAAAAAAAAF4S5o46AW4bW9dZvnQAZU8q43r7G8VvVS7X2x8AAAAAAAAAAAAAAPAiYAIOh+XidZavH0DZk8q4UGwzKZ9blcv19gcAAAAAAAAAAAAAALwImIDDoei9bye5NCF0xwEUP6mMZ4ptJsVvsD/T+QAAIABJREFUVS4Xeu87B1A2AAAAAAAAAAAAAABwBEzA4TA9PmHZfQdQ7qQyJu3ruOYCAAAAAAAAAAAAAAAcYybgcJg+NGHZg7MU2FqbT3L/lPuq4g9cLW8Wk46nygUAAAAAAAAAAAAAADjGFo46AW4rv57kv75m2SfPWOZDSRavs68ql2stXi3vAzPk88hN5HKs3Lky6XT+/3b2+zC+tjRuVtaX6zlOJxbH6+ztj7dfWmjD+Pw4fLWM8fzE+blxIdUxVOfprhPj65Aky/PjHKtrtbIw63yz5O5Ty8P44lxxHotrsTxFjsvFtdotKsyVnb1hfG98GpNMV6dGnri4NYw/9lx9Hs4vbQ/jS8W5XFse18k7pqiTle3d8bXYKuLVta7uy6Sus1UZG9vj+jJNDuev7Azj1XmqjuGO1fpanSna+ofPrA7jH3p2Yxiv2p8keezi5jB+aXN3GP8dD5wu91E5M8W5GvnI+vgYqjo9TVu/WZSxUtwXD54eX8unr4zbjiRZLBq55zbGdbryiiLHJFks7q2XrY3vi4tb4/q0UTwLkrpeV/f/+tK4Ha6u5TTm2ziH/WIXc8X2U+UwRTs4zCHj7Xur25f6OKZ4uA/M+tw/LLNez/0+23lKkv2i375X5LhTdMSmybFqP3aKvuJOcRDVc3tvimdipbqvtqsXpClU56mKb814HpP6ehavP/V74nx9Lao6V91W1bNimneLuRnL2CvO4zS3drVOWa3b+GL1Ij6VudnfZ18KenVv7Y/7OH2vitf3bqtuzhntFzkm9b8wNc1xjHOYvZ2tcqiuRSuuZXWtn19ntvpS1qcpcmj7xb1bNkDFMUxTHfu4jLY/fneocpyxO/x8DsUDp9rHNClU+6ieebP2Nat3l8MoY5rtd2Z8d6jO0zTnseojHcR7HMdD9e6wN0V9nPWdvCx/qhamKKPIcaGIT3OMs37fqRxGDrPGk7qd25sb16nq+069/2k+rsy0i/KbwcoUfdXqHWt+ZbYcpmmnF4s8q+9Y1Tt79c3y+RzGZdw541j6NF3q1cXqXI63r9qPaawW17Ma/6jel6txxSs7s48jrS6Od7K5O97HNONM54pvAv/5qUvD+OnlcX26tF30yVOPfzx1YfzttfretzvFmN4Hi+N8pviWVvXJl6e4706cHJdx5fL4G9BC0T5sFt80d6f4tlLtY664d6vzNF/8bUiSnFoff0M6UXy/WS3+tmMa1bO76jssFc+K9ZU6x1nHqg+if1J9566eWdWzfXWKZ17Vll8p6kN1rSoH0Wc/XXxjPlmch2n+DqdS/k3DyfG1nuY7ORyW/RnHfwC4PfkFHA7TL0xY9vLW2p0zlPmZ11n+izeRS5K8/mYTaa3dleTlN5ELAAAAAAAAAAAAAABwjJmAw2F6z3WWv3GGMt8wYdnTST5YbPeBJM8cQi7J9Y8bAAAAAAAAAAAAAAB4ETABh8P03iRPTFj+xTOUOWnbn+h9/JvDV+M/cQi5PN57f+8MZQIAAAAAAAAAAAAAAEfMBBwOzdVJL/9qQujNrbX5Gy2vtfbaJJ82IfQjUxbxLycse21r7TU3kctCkjdPuQ8AAAAAAAAAAAAAAOBFxAQcDts/m7DsviR/7CbK+toJyy4l+eEpt/+hJJcnLP+6m8jlzUnunbB80vECAAAAAAAAAAAAAAAvIibgcNjemeS9E5Z/W2ttadpCWmufkuRPTwh9b+990qSaT3B1vf9jQuhPt9Y++QZyWU7y1yaEfrn3/h+mLQcAAAAAAAAAAAAAADieTMDhUPXee5K3Tgg9kuTbpymjtXYiyfclWbwmtJnkb91gSv97kq1rli0m+b7W2uqUZXxHkk+asHzScQIAAAAAAAAAAAAAAC8yJuBw6Hrv35/nfwnnWn++tfa3W2sL19u2tXZXkn+d5LMmhP9G7/0jN5jLh5P8jQmhz07yr67u73q5LLTW/k6Sr5kQfmfv/QduJBcAAAAAAAAAAAAAAOB4MgHnNtJae6i11kf/JfnQdTb/99W2rbWHbiCdP5XkuQnLvzHJL7XWvqq19nBrbbG1dqK19vrW2rck+bUknz9hu/ckedsN7P+F3pbkZyYs/8Ikv9pa+8uttde11lav5vOq1tpXJ/nlJF8/Ybtnk/yPN5kLAAAAAAAAAAAAAABwzFz3l0bgVuq9/2Zr7cvy/K/ZrFwTfk2St99AcR9M8mW9952bzGW7tfZHk/xUkoevCZ9N8teu/jeNjau5fPhmcgEAAAAAAAAAAAAAAI4fE3A4Mr33n2ytfUmSH0hy100W8/NJ/nDv/WMz5vKx1trnJfnhJJ95k8U8leSP9d7fOUsuAAAAAAAAAAAAANw6vR91BgC8GM0ddQLc3nrv70jyGUn+eZIb6c5sJnlrkt/Te3/0gHJ5NMkbk7ztavlTb5rn8/8Mk28AAAAAAAAAAAAAAOClxy/g3F4eS/KGW1z+Dbv66zVf3lp7S5KvTPKmJJ+aT5wgtpXkZ5P8SJLv7b0/ffOpXjeXzSR/ubX2nUm+IsmXJvnsJMvXrLqf5H1JfjTJ9/Te33fQuQAAAAAAAAAAAAAAAMeDCTi3kd77VpJ3H3Ue13N1Ess3Jfmm1tpKkgeTrCfZS/Jckkd773uHlMtTSf5mkr/ZWptP8ookdySZT3Lhai438is5AAAAAAAAAAAAAADAi5QJOBxLVye3vP+o80iSq5N+fvOo8wAAAAAAAAAAAAAAAI7G3FEnAAAAAAAAAAAAAAAAAMeZX8ABfpvf/YrTw/jmbh/G718bNytL8/W8v4XN54bxtrM5LmB/bxh+8BX3lznsjQ8zJxbHx/GKUyvD+MuK85Qkyxc+Poz3s+Nr9ZH1U8P4Yxe3h/HTK3WOd51YGsar87Q4N46vFNs/X0Ybxjd394fx85u7M22fJIvz4xwqJxbnh/Glhfo8PPbceJ2F4jytLo1zOH1iscxhb39842wX53KpihfnYb44xiQ5WZzruSnKGObQ6u23l2Y7zrPFfVfFk+Rla8vD+H1r9fUe2aka0STVbXNldXyeHjl7Yhif5lKeXR23c1WOZ1fH52mv1+fhvpPjHHaKJmhtaVxflj/6i8P47l2vGu8gyStOnxnGn90YP3erNvJT1uvz1HbHz/75j/3sMP7yh984jF+pTnSSoonLxe3xebjnxPhan7rw4TqHU+Nnf9sbP9P2l9eG8afvGl/rJNktTsTZ1XE7u3Lug8N4O3euzKGv3zWM333/K4fx7aKNOr81vpY7VWVI3T9ZnrHvMDfF8+bS8rhen94e15dLRZ3e2avvm2nyHNlaGO/jMHKo+gZ7K3V9qPpIlaqPU71jTXMOlhfG9+5y0T9ZLnJYmaI/W6mOsxe7qPrDSbK0MF6nurer+DS3ftmnLepT2R+dm+K5WxRRHkcf35utiO+fOJO5y8+M91G891c5zJrjVPuocqziB6HMYYrjLPSiLe7FPmbdPklmPYpe9A16cd89/PkP5jf+fd2XG6rOU3kep6hPM9bJch/T1KcZ793q3pzm1k35njZj+zHjuEIy3fNiuP0UOcwXz4OqiHosrOgPL8zlys64PlTPtGnGDUemeGUv+1FbRRtW9Vf3p0hiiiGWoepSzVrfkrqfVtXJaepsNW5Yqfrk0/TZp8nzVpru3r61Oa5N8c2gymGlePeo6uQ047dnVsZjdtV4fNXGrS/V52F9uRhvL+LVeaje0ZJkuVqleKbNbZ4v91FqRRJzxbmscrz01Hj3O1vj8jNF/6I6hqr8vfG3uCTpm5fHK5y5Z7z9ucfG8ctXyhzaQjHW/dHxt9u5k+tF+fV3i71nxseRqozd4lzPje+7JGV/dfHBTx5vfuKOcflFfdo/eXa8fZJe3DfVWHpfH1+rnTb+fpQkV4pvSFU7ebL4JnlhazxumSRbRd/giZPj49go+qLTfN85URzHY8W3uMrZk/V9U3nm8vi+WC2eiecu1+3olWIceb3oPywVfYPKNP24e9bH12LW7+QH0Qer+kiVaf5eYb84V1U/q/rbjmlyqPph1Thztf0dxbffJJkr3lerd9Wnz4zvq+p7YTWGnCSLM46331O0H8vFOHiSVJ9fLhfHef/6OIfqGzcAwHGnNwNwDFWTbwB48asm3wCfqJp8A8fNrJNv4HZUTr6BY2bmyTdwG6r+oAmOm6OefAMvSjNOXAHg+Ksm3wAAALxUGfkCAAAAAAAAAAAAAACAARNwAAAAAAAAAAAAAAAAYMAEHAAAAAAAAAAAAAAAABgwAQcAAAAAAAAAAAAAAAAGFo46AQAAAAAAAAAAAACAw7Lf+1GnAMCLkF/AAQAAAAAAAAAAAAAAgAETcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAYMAEHAAAAAAAAAAAAAAAABkzAAQAAAAAAAAAAAAAAgAETcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAYMAEHAAAAAAAAAAAAAAAABkzAAQAAAAAAAAAAAAAAgAETcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAYWDjqBIDj5cTieF7eatFqnNg8N4zPbzxb5tCf/tgwvn/lwriA/f1h+OSrP7PM4ZPufNkwvlacp7sXd4fxxcfeN4xvve9nh/EkmT973zD+4Ke8YRi/974zw/h9a0tlDuvL4/Mw39owXpzGrMyPt0+SucvPDOP9xNowfunUiWH88s64PiXJ3n4fxneLIlYWxidibbl+XJ89Ob5e+0WOe+Nw1pfmyxx2in3MFfVhv4+3X5wbbz9XxJPkxOL4OHb2xhfrzMriML4+xbWq6kvlrhPjaz0/xfTqU8vj83BmbmcY3y4eBsWlTJLsFSs9dnFrGD9ZNCDTnOaiCUvbHedwYnFcH3pxjKttb5xAkjY/47meK7Yv4tNYLNrq5YXi3p2ib9D2xnVy98lx32HlleNrubSyUuZQWSrOw9rWuI+08ws/We5j/vTZYXzv8riPNFdsf+9Drytz2F9cHcYXPvrhYfzyu//tMH7+A+NrubQ+fm4nydk3fekw3lZODuN3nRr3sfpifd/MV/2T554oyxhpi3U/bf/sK4fxvbvvGcav7I3r9O4UDe1y0cepHt2XtsfP5Y2qk5Wk6h1sV32kYheXt8dt+eYUOV7aHr87VGVUfaitKXJYLfpIp1fG9f7ek8vD+N0n6r7kdtEhrdrZavv1ov+TJOe3xtez6matLY3XmOb9pu2P60Mv+gbVear6/Un9Hlfto21sjnewtz0M9+1i+yT7F58b57A0frbPtfG16vN1O5uty8Pw/qVxjn2rPs7S3Iz/ttL+uM7v7Yz7YNOYL9q4vc1xfdgvtk+SuaXxfbG3U5cx0ooH1iNf9FA++JPjPtDMimtVjYUlSd8dX8/q3ivju+NrOY25og2szkNr9XlItY/C3JXx+8vK2t1lGVVb37YuFQUU78Mrp8oc5hbHz+6t3fED4/Ty+L5YKO6bvV73qZeKMqp30RmHX5LUYzh378z2XK76L9OUMatpcri4Nb63ruyM782LRVt+frO+L8txw2JArLqWVflJsrxQ9ydHtnaL526RQjWGnNTjp9V5qrav3gumsVj0X6rTXPVVk+R00fdfKcaqqjZsrhgzTJK2c2Uc3xz3JVsf33dtd4q+5N64zvXiWTB3eTyWVZqb4p6pxi6rfvtzT47jVR8qSXX3t9XxOFJZ/jQ5FO8GczvjOlf286bIoWU81t2KsfC2MH6HqrZPkrY8Hnes9P1xnZtmPK1vbYzjRZ+4rY7v3fJpU9T5abS9YlyhaF/KwbQpVN8DqzHBadr6qi9YfQ+snnnTPHerPlCl6p/cOcW3+tXi++1a8eyu4usXxvGLU/Tj1ot9VMdZHeNGMT6b1N/aq/pyZnXchk3z7bfaxzR1bqQai0/qfthq8e21um+muHXL77urRT9tvshhaX+asYnx9dqeG48rntsY14fq70uqb+TTqNrJU8U49TTvmRvFuED1baT6Tj7NNyY4LNW3QACYxC/gAAAAAADATbjlk28AOHKzTr4BAAAAAOClwwQcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAZMwAEAAAAAAAAAAAAAAIABE3AAAAAAAAAAAAAAAABgwAQcAAAAAAAAAAAAAAAAGDABBwAAAAAAAAAAAAAAAAYWjjoBeKHW2suTvD7Jw0lOJdlL8lyS9yf5+d77+SNMDwAAAAAAAAAAAAAAuA2ZgHMba629KslnXfPfmQmrfkHv/R23MI+1JF+Z5KuSvHaw6m5r7Z1J/n6SH+y991uV0/W01r4oyb+7Xrz33g4xHQAAAAAAAAAAAAAA4BCYgHObaK09nOSzU0+2OVSttT+U5O8leWCK1ReSfNHV/97TWvuK3vv7bmV+L9RaO5HkHx7W/gAAAAAAAAAAAAAAgOPBBJzbxy8kOX3USbxQa+1bkrwlyc38aszn5PlJOF/ee//RA03s+t6a5FWHtC8AAAAAAAAAAAAAAOCYMAGHI9Fa++Yk33qdcE/ygSSPJllM8kiSeyest57kh1prb+q9v+NW5PlbWmu/K8nX38p9AAAAAAAAAAAAAHDr7fd+1CkA8CI0d9QJcPtprf3+PP9rMtfaT/JdSR7uvT/Se//C3vvv7b3fl+QNSX58wjbLSb6/tXb/Lcx3Mck/ym+/X/Zv1f4AAAAAAAAAAAAAAIDjxQSc29tHkvxQkr+U5E1JPvtW77C1diLJ25O0a0KbSf5g7/3re+8fvna73vu7e+9fnMkTd+5J8p0Hnuz/739N8ukv+P8rSf7pLdwfAAAAAAAAAAAAAABwjCwcdQIcmo8k+Y0kP3f1v//Ye3/6hSu01h46hDy+McmDE5Z/de/9R6uNe+9/pbX2QJKvuCb05tbaG3vv7zqIJH9La+01eX6C0gv91SRrB7kfAAAAAAAAAAAAAADg+DIB5zbRe3/dUefQWltN8nUTQj/We7+RX5T5hiR/IM//8s0L/cUkX3qT6X2C1tpckn+UZOkFi38xyd9J8pcPaj8AAAAAAAAAAAAAAMDxNnfUCXBb+SNJ7p6w/C03Ukjv/XyS75gQ+gOttftvIq/r+dokb3jB/+/n+V/q2T3AfQAAAAAAAAAAAAAAAMecX8DhMP2JCct+uff+npso63uSvDXJ/AuWzSX540m+/SbK+21aa69M8rZrFn937/1nZy37uLvjp79vGF/8tDcM47t3PjSMb5w4Wydx9pOG4ec294bxJy6P50ittHru4SPzF4bx/ZUzw/jCk785jD93z2uH8cWXffowniTz2xeH8T43WxO/ubdfrrO32Yfx1YXxuX75pQ8M41vv/jdlDh971y8N43c88ophfO21nzGMn7n/oTKHvrszjLellWH8wZd92jD++OZymcMHnt0YxhfnxtdifXl+GL9vbbHMYXtvXB/6OJyN3XGdm29tGJ+mzj5xaXtcRrGPE4vFeVyq77unr4xzOL81bsOe3RzXtxOL42s5jffOuP00OewU12tnf1xh3vnh524op0lOL4+v15nVcb2/9+T4GFaL+vLE1jCcJDm3MV7pVHHvPnD3+Jk6f+GxModXbo/blyyMz9Pu6YeG8f3UfYPN4rVl+Xd/2TC++OSvj3NYWS9zSNF/OLV2V13GwNLrf1+5zs6v/L/D+MVfe/8wvvbqh4fx+fU7yhzavY8M4zvFM+3k546faSffWMx1n6If1xfG++iXnx3G566M25d+/skyh91nnxrG9y88M85hbXwt+vZmmcPi/rjPPLc57u+eLspvW5fKHPaK89B3x8/ElYWlYTxF/yZJ9p762DC+cO+D410U98X++rU/zHpNfO3kMJ4kmR8f59biqWH82eL9aK94pibJ4ty4D1Q905bmx9tPkUJ29sfP1XPFcVZ90Q89Vz94t4r+yWbRX90vOrzVeU6S4jDKPlR1DNP006apMyOL86vD+CvvGL9P3/+K8fMqSdb6uB2cK9qo3flx32L+8ridfr6QcRvWij5S3xlvP3dyfO8nyeJDnzpe4WTxPCnan6Vev2OlGHuY2zg/jO988FeG8e2Pf7hM4dLHxs+bNj9uw7Yvj6/FuV8f9x2m8eQvfWQYnyveJe98zauG8d3HPlTmsL9xuVhhfL3bifE41PzpKcb8imf3/qVxP2z/0XG//jDsL47v7YUz475BkuyffeV4hbmird4bjwvMnx/3f5Jk3FIn95162XiFKseiL1q9RyYpjzN7RV+wGOPZm6/H25aLXcxX56GwMl8/c6vHctUPW9wb94E2imdBklzZmeJ5MDDNeFmlOg9VN6saG10pxrGTZLlYp+oLzhV1sghP15ec7VKVORSP1KlUY7zVN4VpnCzeX+aL+6JtFWNhe/W/09eKNqztF2VU/bDiuT3VPnaLdvL8uE9cfRcpnwUHYPfxcR+rLdZtXPX9pnzmFe8FqcY2krSijWrLRY7Fc3VumudVdb2KMtrqePyjr91ZptDuHvd5Z71vpvlu2ubH5/LxhXGf99EL4/alelZsPlXf25e2x3XugfXxu+RaH9/7j56vx/wqj10cn4e1pXF9evmpos4nOb08vlbrxfefleKhVvWxkuTlp8d5Vt9Fq2+OUzz6y+fmrH3JZzbG991Hizqf1H2YO0+Mr2W1fTVelyQ7xYDbSnEt1or49hRjabtFMzvNcYwsLdQVpqqTu8VxbBTvBYtT3Ddbu+N93LEybh/Wlsb72MgU75qFCzOOQ1/eHm9/bqPoQ6V+P7n7ZDGmV1yLqv15fp1x/HTxwnzyyvhbWvvwr5Y55DPfVK8DAHBE/AIOh6K1tpTkCyeE/sXNlNd7fzLJT00IfcnNlDfBP0iy9oL/fzTJXzqgsgEAAAAAAHgRqCbfAAAAAABw+zBizGH5nCQnJiz/iRnKnLTt57bWZvonDVpr/0OSL75m8df23mf/514AAAAAAAAAAAAAAIAXHRNwOCy/c8Ky3SQ/N0OZPzNh2UqST7vZAltr9yT5jmsW/2Dv/UdutkwAAAAAAAAAAAAAAODFzQQcDsvrJiz7QO99c4Yyf/k6y18/Q5nfleTOF/z/hSR/YYbyAAAAAAAAAAAAAACAF7mFo06A28arJyz7jVkK7L0/3lq7nOTkNaFX3Ux5rbX/NsmXX7P4m3vvH7+Z8gAAAAAAAAAAAAA4fvZ6P+oUAHgRMgGHw/LQhGUfO4ByP57kkSn2NdRaO5Xk71+z+N0Tlh1LrbU3HFRZGz/6Dw6qKAAAAAAAAAAAAAAAeEkwAYfDcveEZU8cQLmP5xMn4EzaV+VvJnngBf+/m+Sre+/7N5vYIXvXUScAAAAAAAAAAAAAAAAvVXNHnQAvfa21E0mWJ4TOH0DxFyYsO3sjBbTWPi/JV1+z+G/13n/lprMCAAAAAAAAAAAAAABeMkzA4TCsXWf5pQMo+/KEZSen3bi1tpLk7UnaCxZ/MMm3zZgXAAAAAAAAAAAAAADwEmECDodh8TrLdw+g7J0Jy5ZuYPu3JHnkmmVf03vfuOmMAAAAAAAAAAAAAACAl5SFo06A28L8dZbvHUDZk8qYql631j4zyf98zeLv673/+MxZHb43HmBZ7zrAsgAAAAAAAAAAAAAA4EXPBBwOw/V+6eYg6t+kMib9Ks5v01pbSPKPr9n+XJJvOICcDl3v/acPqqzNH/uHB1UUAAAAAAAAAAAAAAC8JMwddQLcFraus3zpAMqeVMb19vdC35TkM69d1nt/avaUAAAAAAAAAAAAAACAlxITcDgMF6+zfP0Ayp5UxoXRBq21T07yV69Z/I7e+/ceQD4AAAAAAAAAAAAAAMBLjAk43HK99+0klyaE7jiA4ieV8cz1Vm6ttSRvT7LygsVbSf7sAeQCAAAAAAAAAAAAAAC8BJmAw2F5fMKy+w6g3EllTNrXb/kzSX7fNcv+eu/91w4gFwAAAAAAAAAAAAAA4CVo4agT4LbxoSSfdM2yB2cpsLU2n+T+6+zrer78mv9/Jsk7Wmu/+wZ3//Lr5DSpnAu99/98g+UDAAAAAAAAAAAAcAvs937UKQDwItS6BwhXtdYeyuTJK1/Qe3/HjGX/vSR/7prFH+29v2KGMl+d5DcmhN7ce/8X19nmHUk+72b3eZPe2Xv//EPe50377p/+0LBRuLS5O9z+kbtODuM7+3Wb88SlrWH8/JWdYfzJC+Pt7zixWOawtjKen7i0MP4BsVfesTqMLy/MlzlULmyOz8PC/Gw/cnbnan2e/quz4+N8/7mNYXxrd38YPzNFDncV1/PU0vg8XNoZ53BpexxPkvViH9tFvZ9LG8aL6pYkOb+1N4xvFue6eqE8sVjX2V99+vIwfnp5fF89eXl7GF8uTsTi3Pg8Jsml7fF5euzC5jB+uqiTGzvj8pPkk86O28nqWlXn8XTRfiXJ4tz4XJ5ZHV/v+TY+18sL9bXYKO69rb1xndwu4kWKSZKVop28UNxXK0WdXF0cJ1GdxyR5+sr4ubtUnOvt3fF5evrK+L5L6jp1paj3VX1bX67bl6eLZ391X9y/vjSMT9F8ZK1q64s6udbH7cv+0okyh3Mb43NdPfqrV78zy/UDp+2Mn+3P9uXxPubHdXp/Ybz9NK+v83vjvuD23Lg+LO+Mn2e9TXGeetG/mBtf78cvj8/TNHW2amLuLO7tqs4/WeSY1P2o/Ywv6MnFcQ6np2g/5ovzUL2eXCmeV6040dOMuVTtYHW994qD2CieBdOUUdWH6jzOT1Fpq3eDqp29XGz/seI9MUl2in1Uz/694npX2yfT9btHqufyevHMTOr3k0rV/lT99mnGDXaLdc4XYxdV/2aaD26rRRu1VBxnVR+WqgYsdX+1uv/vLPr9dxT3fpK0vaI/WZzLavte9A2mMX/+4+N9fPzXh/Gdj7x/GN9+5lyZw/obv2i8wul7huH95fVhvM/V9/b85WeG8bZ1aZzDepHj4niMKEmyuDIM7y2vDePzG8+Ny99VXSXRAAAgAElEQVSr+ydtf7xO262fFyP7K+NrlSRbK2fGORTbL19+arz99rg/myTt4tPD+P6d42H76jzNbZwvEqjbl/3z4xwrc+t3jMs/eXam8pNkf/X0MN6L+2Kae7fqyi0W7z/zl8b1Ze/UfWUOH7o0TqJ6dlfPtGqMKEnObYzHBap+3DPF+MfFYswwSZ4tyqj61GWfu+ifnD0xfpdN6r7gpa1xG3hqZTz2OU1ftepnVX3Bu4rjPF8cQ5KsLc02tnlqZbz9NO+idxSfNrb6uB3cKN5v9urbphwnqlRjONWzoM/XdfZyxutU32+qQ6zeZZPk5Mb4edO2Lo4LKJ5pu3c+VOZwpWjsn9oYX4v7To4r3MreeDwvSbYXxs+s6r6pvlFVdTqpnyerxTvUvYvj8zR/8Ykyhzwx+nc+k71H3jCMP7oxzrGqk9O0L3N7xffhJ8fvN/25J4fx/Yc+o8yh6nfvnrxrGK++g50sxtKTul9f9rPmxud6I/U36l964kq5zsjdJ8dt4DRt2FoxNlGNbiwX/bSnim9Uv/j4+D0yqb+dvuae8Xtg9Vx/7GL9netjF8d1qvr7lLsPoH9S9YHmivgzxXf0acZft6u/zSiOs+rnzU3x3XO36MSsFv3Nab7FV+5ZG481VXXuPz81rve//sQ4frEYt0zqv0eq3i2qv4m6+1Q93nZ6eVzGpe3xcVR/2/Fc8Y6XJN/4e18920A1TOldv/mMP6DmlnjjQ2e1Y/ASNuPQG0ztFyYse3lr7c4ZyvzM6yz/xRnKBAAAAAAAgCT15BsAAAAAAG4fJuBwWN5zneVvnKHMSf/EzNNJPjhDmQAAAAAAAAAAAAAAAL+NCTgclvcmmfS7zl88Q5mTtv2J3rufBQQAAAAAAAAAAAAAAA6MCTgciquTYv7VhNCbW2vzN1pea+21ST5tQuhHijw+v/feZv0vybdep/xJ63/+jR4fAAAAAAAAAAAAAABwfJiAw2H6ZxOW3Zfkj91EWV87YdmlJD98E2UBAAAAAAAAAAAAAABclwk4HKZ3JnnvhOXf1lpbmraQ1tqnJPnTE0Lf23u/fLPJAQAAAAAAAAAAAAAATGICDoem996TvHVC6JEk3z5NGa21E0m+L8niNaHNJH9rpgQBAAAAAAAAAAAAAAAmMAGHQ9V7//48/0s41/rzrbW/3VpbuN62rbW7kvzrJJ81Ifw3eu8fOaA0AQAAAAAAAAAAAAAA/gsTcG4TrbWHWmt99F+SD11n839fbdtae+gG0vlTSZ6bsPwbk/xSa+2rWmsPt9YWW2snWmuvb619S5JfS/L5E7Z7T5K33cD+AQAAAAAAAAAAAAAApnbdXxuBW6X3/puttS/L879ms3JN+DVJ3n4DxX0wyZf13ncOKj8AAAAAAAAAAAAAAIAXMgGHI9F7/8nW2pck+YEkd91kMT+f5A/33j92cJkBAAAAAAAAAAAA8FK2t3/UGQDwYjR31Alw++q9vyPJZyT550n6DWy6meStSX5P7/3RW5AaAAAAAAAAAAAAAADAf+EXcG4fjyV5wy0u/4Zd/fWaL2+tvSXJVyZ5U5JPzSdODttK8rNJfiTJ9/ben775VA/EO454/wAAAAAAAAAAAAAAwCExAec20XvfSvLuo87jenrv70vyTUm+qbW2kuTBJOtJ9pI8l+TR3vveEab421z99Z53HHEaAAAAAAAAAAAAAADAITABh2On976Z5P1HnQcAAAAAAAAAAAAAAECSzB11AgAAAAAAAAAAAAAAAHCc+QUc4LdZXxo3Cyvz43l7a8X209ja3R/Gl4ocKqdPLJbrVPs4sTg/3sfKeB+Lc63M4crO3jA+V5SxsjDbebqys5czxXEszY9zOL083v5S2x3GF+fqY6jO5drS+FotF+dpvo2vQ5KcXR3v49LOuE6Xx5DtMofFufG995ELW8P4navja7VZ3JdJsr/fh/HzW+PrXdX5M0WOSbJc3LtV+/LA6dVyHyMbxTEkyaXiPOwU57E6hkfPb5Q53LO2PN7H3vhcV/f2wtz4nkiSqkpV7Utle298HpP63q3K2M84vl1Wh54Ti+M6u1ich9WiDVstHsunV1ZzpWijXr4+vt4bu+PzsFvU6TtW6vpSteXVPnov2qftuo1rRZXcK4pY37syjC9sXihzOLN+3zA+18eVbnN/fBBzm+fLHLJXPLuXV4bxtjt+Hs212f+NiGofCyvjNjA7m+Pyp8mhF/3ZkyeH8Rm7u8+XUVTaqp2d37o0jJ9YPFHmsFfce/t9nMNC0Uc6OV+39XM74+diL+rcidXZ+gZJsl/UmoXN54bxtnV5HC/q21qSvVPj9mN/ftzWz196ehjvK+vD+HZbGsaTpHgclX2kpSnesSpbRWNe9Ver7adxz8nxuareRav4uSs7ZQ7VvVv1R6scphk3OLk0vjeXF8bXe315nEN1LZPkUtGZu3dtfK1OFv205aIdnqY/XI1dbO0V4wpF+W2vfhed2yj6D/vjHNr+uG+xv3q6zKEX78OVtjC+lm2+GFe45+5c+ejHh+v0nfG913aLe3OxOo97SfEe1opn4v7F8fOoF8+S6nmUJL2oU61of1rVTyv6gc8nMc6zbRd9h8VxX7LtTjGGkyKHqs98+dx4++K+SpL9reI4l9fG8eK+K9uGvp++NO5nzZ0c9y+qOr93+v7x9kn2V06NVyj61Jd7Mfa5Nb7WF7fq53L1LlqN0dxV3LuX9ut38icujd9nq3HD0yvj+rJf3PtJ/d2iHOMt+or3VAnceSJ7RX+0Oo5qqGq9GPtIkruLvuJzm+M69XTRF6y+B1R9rKQew6kudzVWNk0O1ftwZX25+A5W5Jgk8xcfH8ZXl4txgaVxG3hxirGsKsvqvqn6J/tL42OYxu7OuEJcLNrR81O0ow+sj5/dq8WzoM0Xfc1iXOFyMXY6japOr/Rx/2Ph/MfKfbT1e8fxoh92Zu3uYXzW8f4kOVm8By4+9qvD+O4THy73sf3B/zSMr975smH8zjsfGW8/RfsxV5zrXozhZGEcb3c9MIyfny/6R0lOroyP431Pj4/hycvj/u7r7h33RZNkZaEYhy62r8aR2hS3bjUuUH7/KXKoxg2S5GQbt4N78+M2cH5/vP1c0f78jpet5+kr4/ePpeLe/aQzRY7FuOSDp5JnFs4M16n6D9VY1qvPjMfCp3keVeeyaus/9FzxTj9Fn7pSfWev+vXT9MHObYzPVXUtnrw8fuZN06eujrP6O5tqbPPOom24c20p5y6Nj6N696i+ndx3etxGVmPQSf23Gec3x+e6Oo/T/C0QAMBxpjcDcAxN88dAt1r1sQ2Om2qwDI6b6uPLYagm3wAwm2ryzWGoJt/AcVNNvjkM1eQbeKFq8s2hmOIfQYDjpJp8cxjKyTfwAtUfwB2GavIN8ImqyTdw3FSTb+C4qSbfHIZq8g0cN9XkGwAAXhyO/os2AAAAAAAAAAAAAAAAHGMm4AAAAAAAAAAAAAAAAMCACTgAAAAAAAAAAAAAAAAwYAIOAAAAAAAAAAAAAAAADCwcdQIAAAAAAAAAAAAAAIdlv/ejTgGAFyG/gAMAAAAAAAAAAAAAAAADJuAAAAAAAAAAAAAAAADAgAk4AAAAAAAAAAAAAAAAMGACDgAAAAAAAAAAAAAAAAyYgAMAAAAAAAAAAAAAAAADJuAAAAAAAAAAAAAAAADAgAk4AAAAAAAAAAAAAAAAMLBw1AkAAAAAAAAAAAAAAADHU2vtNUlem+T+JGtJNpM8leR9SX6h975zhOndkNbaXJLXJ3lNknuTnEhyJckTSf5Tkl/uve8fYj6vTvK6JA/m+XO7neRckl9L8nO9943DyoWaCTgAAAAAAAAAAAAAAMB/0Vp7RZKvS/In8/zEm+u52Fr7kSTf1Xv/mUNJ7ia01j41ydcneXOSs4NVn2mt/UCS7+y9/+otyuWuJF+T5E8ledVg1c3W2o8n+bu99393K3LhxswddQIAAAAAAAAAAAAAAMDRa63Ntda+Oc//Ass3ZTz5JknWk/x3Sd7TWvsnrbXTtzrHG9FaW26tfUeSX0nyZzKefJOr8T+b5L2ttW9vrS0fcD5fleT9Sb4t48k3SbKS5EuT/NvW2r9prT1wkLlw40zAAQAAAAAAAAAAAACA21xrbTXJjyR5W5LVmyjiv0/ys621hw80sZvUWjub5KeS/E9J5m9w8/kk35DkP1wtZ9Zc5lprb0/y9iRnbqKIL0nyc621z5o1F27ewlEnABwvZ1YXh/HN3f1hfGtvHF+er+f9Pbe5M4zv7fdhfG1l3LTdsTI+xiSZa20Ynx+H85HzG8P4icXxM3y/OMYkubi9V64z8uzG+Dx/7MLmTOUnyaPFeVgtzsP5rd1yHysLJ4bxC9tbw/gTl7aH8bWlur91enmliI/LmNu+Mo5febbM4cTJl43jxbleXRjfmwtzRaVPcqq4t/b7uF7v7I3ji0UOK8UxJMlysU6RQpnDuY36PM0VZVws2sCVKdrRMoeijavaySqF3SnasOpyzRfnaW1xXEArjjFJTl18dBg/vzT+hxu2imb4ZWvj83huo27jnrw8bqPuOjHeR9WGrS/V9Wn9yhPD+O7KPcP43bk03n7ujjKHKzvj/kV1uZ8uzvWHnh0/r5JkfXm2V6dnTq4P46+6Y6ks4zfOjZ/N739m/Dyp2rDqvkuSzd1xndnaPVfExzfOGx8cP1PXpqiz9y6Mr9X54ua9c3Gcw9zlZ8oc5i49PYwvtfFxvHJtPMayuV9fq43dcVt8sTgPH90a18n/9NRzZQ7PXBm3YQ/dMR6nq55XHy36WEnykfPjvuBW8X7zKXeNy7/nZP1u8WtPj+/Nqk7u7I3/IZ2qrf+UVj+X7z05Pg+n9sb9k7kLjw/jS+v3ljmcXR6fy50Zh7AubtftbDKus1UX50SxwpWd+h2u2kfVZ97ZK+rTFP206r19p6hTe0W//9L2+Ll8fqvOcXGueB7NODZxouhrJslHz4+fy08U+zhd9C2q85jM/o61tz++L8a9wOdd3l4bxs8W40wP3DGOL2xdKHNoe+N7tzK3Pu6Pzp0af0tZe83ZbH7o/cN1+u44x7n98X3RV8f/SNz24slhPEnmT903jF+5d3zfPHF5nONdU4yfFN36nHtufJ56H/eRqjqfJEsL4/7FXWfG92b17vHo+bo+nj8/7htUXnF6/A/h3b1aPzNP3Fecq6K/msVxP6582y363EkyNz9uo6p7vxf7uJy6b1A8TnKyeF48szF+Ll8snolJcqp4Xtzdzw/j849+YBi/Y7luPx449cgwfn5zfJynV8btw/YU9271PrtR9OsvFuPMi1OMt1V9uWpscqeoUNVY+t6Ts/eRqhxn/a6RJGeKccVX3zkezz+Aoc9StY/q3r+4XayQZPfk+B3oXHHfXLg8fpet3umTuk98//r4XfO9T47b2cW58Xvip95dty/Vd4nHLo3Pw5NF/Fefvlzm8Jq7x/3ZR+4c9xUfvTA+Tx85X/dnq++e1b27cs/4XN+zOsXf8hT91Sfm7xzGL10Y14fqO1lSv69u7hbPgvVPGcdXx8+zJHnFp3/JML6/MR7zq76NVPfus1t1I7g0V9zb/x97dx6mWVbXCf57YsnIPbOysnYoip1ilU02R2URBB1UUNFebBG1fRrHHhSXdsYWFdvREbXVbrtFBZ/G7sYWbRFUEASmlaUEGZAdaqGg9qzct8jIiDN/RDBdRL1xzhvxvhGRWfn5PE8+UPf33nN/99x7zz3nvu+Ju++aZvxI5/nuMN9b3HyknUNvrLpzS7t/07uvJ8kXOufckdPt/bhyd7sNfPj2dvlJcvXudvsxdab93UhPHeJZ2MTx9rPq6c6z7LO339SM3/+K9tjjiouvacaTJLXz/c5H3tWMn73txmb8ssc8o5vC6T3XNuPX7m+3o3s7/dneb2iS5KbD7XFg77cbJzp90WF+A/PoS9vfU+3utNW9a3OY35fcb3d7nNbrb053fqjT6w8nydxCez9uPtI+Fr1nm/fvfO+xZYjfNPRs6T7bbNfjEEOw7nfUPb3+y+Mub5+PsJGGeRYPF5pSymSSN2Vxoscgc0k+keRAFt9688gkgzrID03y16WUp9dab1uPXIdRStmZ5K+SPH6Fj5zK4v4czuKEmEdm8Y0zy31lkreXUr661tp/6LCy/5Dke1eIzWfxjUO3L+VwbQZP0rlsKZf/pdb6iRFyYY28AQcAAABgHfQm3wBw/utNvgHg/DfMRGoAAAAAuI/42QyefHM4i2+CuaTW+hW11ufUWp+SZF+Sb00y6AuTa5L8l6VJPZvlP2bw5Jtbkrw0ycW11ict7c8Tk1yc5GVJbh2wzhOWyluTUsr3Jfm+AaHTSX4myZW11kfVWp9da31Gkv1Jnpvk7wassy/Jm5YmGLHBTMABAAAAAAAAAAAAAIALVCnlcUl+fEDoxiRPrLX+Wq1f/lruWutcrfVNWZyc8rYB635Nkh8Ye7JDKKV8Y5J/NCD0oSRfUWt9fa31y14LXWs9WWv9vSRfkeTDA9b9x6WUF6whlyuSvGZA6GCSr6q1vqrWeueyXBZqrX+V5OlJXj9g3Uck+enV5sLoTMABAAAAAAAAAAAAAIAL12uSLH9bzYkkL6i13tBasdZ6IsmLknx8QPhnN/pNLaWUiQye8HJbFvfnQGv9WutdWXwT0O0Dwr+yVP5q/FySXcuWLSR5ca31Q51czmbxrTzvHBD+l6WUB6wyF0ZkAg4AAAAAAAAAAAAAAFyASilPSvLsAaGfq7V+apgyaq0nk3zfgNC+JN8/Qnpr8aIkDxuw/BXL3zSzklrrHUleMSD08CTfPGwipZQrk/zTAaHfrrW+e8hcFpJ8b5LTy0LTSX5k2FwYDxNwAAAAAAAAAAAAAADgwjRogszdSX5jNYXUWt+X5G0DQoMm5qynQfvzySR/uMpy3ri03jDlr+S7k2xZtmwuyc+vJpFa601Jfn9A6LtKKTOrKYvRmIADAAAAAAAAAAAAAAAXmFLKVJJvHRD6g6W32qzWawcse0Qp5QlrKGvVSimXJnnWgNBra611NWUtff53B4SeU0q5ZMhivnPAsr+otX5xNbksGVS3e5J8wxrKYo1MwAEAAAAAAAAAAAAAgAvPU5NcNGD5m9ZY3luTnBqw/PlrLG+1nptkcsDyP15jeX80YNnk0naaSin3S/LoAaE11W2t9UNJbhoQ2qi6JcnUZicAyy01No9L8sAku5PMJzmc5DNJ/r7WemSD8phMcm2SR2bxxrI3SUly5B75/EOt9cxG5AMAAAAAAAAAAAAAMEbPHLDsZJL3raWwWuvpUsp7kzx7WehZSX5+LWWu0qD9+Vyt9fNrKazW+vlSyvVJHrws9Kwkf7CGXJLknWvJ5R7rvmxALmwQE3AucKWUByV54rJ/g2YxPrPW+u51zGNnFhuD783gmX5fcraU8p4kv5Xkj1f7KrAh8phO8sKlXL46yY7OKmdKKdcleV2SN9ZaT4wzHwAAAAAAAAAAAACAdfLkAcs+XGudG6HM63LvCThPGKG81Ri0Px8Ysczrcu8JOE9cYy631FpvGTGX5RNwHlRK2VtrPTxCuQzJBJwLSCnlgUmelP5kmw1VSvmmJP8uyVVDfHwqiw3ys5N8oJTy0lrrJ8eUxwuyOLHn6lWstiXJVy39++VSyo/UWl83jnwAAAAAAAAAAAAAANbRYwcs+9iIZX50wLK9pZQHrPVNNMNYehHDtQNC49if71y27JGllKla69nGehtVt0nyuCTvGbFshmACzoXlw0n2bHYS91RK+ddJXpWkrGH1p2RxEs5Laq1/MUIOJcmvJ/nBtZax5KIkv1dK+eYk315rnR2xPAAAAAAAAAAAAADGbKFudgaw+UopW5Lcf0DocyMWff0Kyx+UZN0m4GTxJQyD5kesx/5MZ7Hubmyst/ytOeuVS7JYtybgbICJzU6AC1cp5SeT/EwGT76pWWxg3pXkb5LcsUIxu5L8SSnla0dI5d+nPflmIcmnlvJ4dxZnDrYm17xwKafpEXICAAAAAAAAAAAAAFgv98/g+QS3jFjuSutfM2K5PSuVv+H7s/Q78ivHnUut9a4kZ1aTC+PlDThsilLKc5O8ekBoIclvJvmV5a8YK6U8NYsTdp67bJ2ZJG8spTy+1nrrKvP49iQ/sEL4Y0l+Mcmf1lqPLVtvS5KvTfLKJF83YN3nJ/mRJP/XavIBAAAAAAAAAAAAAM5PpZSnjausWuv7xlXWCi5ZYflKL04Y1krrr7S9cVmv/bl9ldtLkoszeHLTqLl8qYzlby5a77pliQk43JzkQ0k+uPS/B5b+/7oppWxP8trc+803p5O8qNb6F4PWq7W+P8nzSik/l+T/XBa+NMm/TfJtq8hjJsmvrBD+3ST/otY6aIZglpa/PcnbSyk/mOTXc+/9+alSyu/XWm8bNicAAAAAAAAAAAAA4Lz13jGWtfy3yeO2b4XlR0YptNY6X0o5kWTHstDFo5Q7hHXZnyRHV1je2p/1yiUZnM961y1LTMC5sNyc5HNZnGjzoSQfrLUeuOcHSinXbEAeP5zk6gHLv3+lyTf3VGv9qVLKVUleuiz0raWUp9dah71xPSfJVQOWv30pl4VhCqm1/mYp5ZIk/3pZaHuSb03yG0PmAwAAAAAAAAAAAACwEXausPz4GMoeNAFn+X+P23rtz4kVlrf2Z73rdjW5MEaDXmvEfVSt9bG11hfVWn++1vqXyyffbIRSyrYkPzQg9Je11v+0iqJekeTOAct/YhVlvHCF5T867OSbe/iFDH4l2P+6ynIAAAAAAAAAAAAAANbb9ArLz46h7LkBy7aModyW9dqfQfuStPfnvla3LDEBh432LUkuGbD8VasppNZ6JMmvDgh9QynlyiGLeeiAZZ+rtX50Nbks5XM6yVsGhB682rIAAAAAAAAAAAAAANbZ5ArL58dQ9qAypsZQbsvA/am1jro/K63f2p/7Wt2yREWz0b5zwLKP1lo/sIayfi/Jq/PlDdREku9I8itDrH/ZgGWfWEMeX/LJAcuuGKG8TfEN+VQz/oHdj2nGbzp0qhnff9G2bg77tp3/kzCv2dvez4fta8f/n88f7m7j0h3tetq3baXJs4t6OX76wEpvzLtHDjvb2zhw8ky3jFFtmy7N+FznfVYzk+25qLu2jH6rPH6mncSxM+163Lez35TMnq3N+IGTK03AXjQ3315/Zqo/Z/eyzjk5X9vbmJ5oH8tLd8w049umR59XPLfQqYfO+XLodLuek+Sire3jPY5j0bNnpn1eb51qH4vJ0o7v3NLPcbJdRH/9zvkyjInTx5rxbTva+3F2oX1t91JsH+lF2zvn9dbO+bC1U9FTQxyIiWOHmvFtuy5vr3/4SDM+Odm/789MjdYWz3fO2V49Jv1jcfBU+49T9O6Jl2zv72OvLZ892z4nz3YOd68NTJKdW1Z6NrCoV0/TnXPuo3e0r8vevWIxh3aOcwvtY3Ht/vYbeae29Of7n93b/sx8p60/dqCd4/1296+bXv+j11bfb3fnfrWwvZvD9Z3D1TtWvevm9uOz3Rx6981tnRwu7vSpd3bO+WHu27Mn2seq24eabOd4eIj+yZn5dg6TE/ua8R2d8+mG2093c3jYxe128MZD/fFJy8FT/Xp42MXt639Lpw07Mdd+TjrM/aZ3P9jR6afVzj3vVG+AlH5bfabThvVuJ72mfJgcz3Q2cvvxdvuxq9cf7vT7k6Rz2XTbuIu2teO9PneSnO4k0RsnjjqeTpJ0+ga962ai811HHaKvuDC9tf2Bzouue+OCerbdfkxu7ec4ua/dZ57fcXG3jFGd7Vw3vWt7W6f96fUTk35/c3Z+tPFu77pM+ufk3q3t/Sid+/LhmX499O7tvet/d6eud5T+Pa+c7txXS+dYzLfHP1NHb2/GF7btaZefZOJUeyy5cLz9/HRiot3Wb7+ofd9PkhPzvXtirw/VLn96on/O967dhW0XNeNTnW3UE+0xf5JM7GrHj8y2z7mdM+0chnnEM8Stual37+/ZOjWR050x967OtXnsTPue1xvvzgxxvvTaj4s645ueYcY3vT5vr4vTe/4633kelwzTb2+XcWKu3cYdm+3/gdKdne8VDnXGJ73zbZjxcG8seMvR9jjt2Jn2fu7rPOf+zN0nm/EkmeicEHeeaO/nMO1oT68e+t+ttI/VQue+n/Troaf7TG+y3waWs+0xVO95/FSvDRv1C4EhtjFf2/GzC/0cSu9YdMYWnS5193uRYcaBW3o3xYX2ObvQ+Ru9x2b7vwHr3Q8mO33J3nOH3vcaSXKy8wymNybf1rtfdfqiSf/HVr0ySud8qp1nfkkyebLdl5s/2O6Xz991SzM+sbXdZy67Lm3Gk6RuaT9HntjR6Wz2yj/VHtMnybb9vfO+fSxOde7Lvf5w0u+H9dqP6c613/vtSJJc3vltx8VbO9f28bua8X2Xtp8hJ8klM53x8JFbm/Grr7y6Gd9S+/20U7XdPtx6vF1G7779wM7vcBaG+C6ud2/v9dN2d8Y/w/ym4TGXtq/NO060+w53duK98VGSPPbK/rMDgHPc0zc7gVVY6eYyjjkGg8ro34xGM3B/SilTtQ7RYVjZSvXR2p/7Wt2yxAQcNkwpZUuSZw0IvWkt5dVa7yyl/I8kX7ss9PwMNwFn0Kjo+FpyWXJ0wLJxzFIEAAAAAABgE/QmQwAAAADAPdVa37fZOazCSn8BYxx/SX9QGf2/LDKa1v6MMgFnpfpo7c99rW5ZMvqfhYHhPSXJoD9v8c4Ryhy07leVUob5M153DFg2yp+b3D9gWftPigAAAAAAAAAAAAAAbLyVXis42usKVy5j0MsOxmm99mel9Vv7c1+rW5aYgMNGevKAZWeTfGiEMq8bsGxrkketcd0nltJ5J/LKnjJg2fvXWBYAAAAAAAAAAAAAwHq5e4Xle0cptJSyNcnMKrY3LtvNuv0AACAASURBVOuyP431W/uzXrmsVMZ61y1LTMBhIz12wLLra62nRyjzoyssf9wQ675pwLL9Sb5xtUmUUq5K8twBof+22rIAAAAAAAAAAAAAANbZ7Sssv3zEcldaf6Xtjcu5tD+HkpwZdy6llMkkl6wyF8ZoarMT4ILy4AHLPjdKgbXW20spJ5LsWBZ60BDrXldKeXeSr10Wek0p5W9rrUPNBFxqyP59km3LQh9N8pZhygAAAAAAAAAAAABgY8wv1M1OAc4FtyaZzb3fVnP1iOWutP6NI5bbs1L5G74/tdaFUsrnkzx0zLlclcEvYVnvumWJCThspGsGLLtlDOXemns3ToO2Ncj3Jflwkp33WPaQJO8opbyk1vqZ1sqllIuS/E6SFy4LnU7y3bXWhSHzGEkp5WnjKuvsx981rqIAAAAAAAAAAAAAgHNQrbWWUq5P8shloYeNWPTy33V/yUgvbhjCbUmO58t/F56sz/4cS3JHZ73PDlh3ver2syOWy5BMwGEjDXrdVa/hGcbtuXdjMmhb91Jr/Vwp5RuTvDVf/hadr0jy0VLKG5P8SZK/T3JXkvkkFyV5TJKvT/I9S/99TyeTvKjW+uFV7sco3ruB2wIAAAAAAAAAAAAAzn8fzr0n4DxuxDIfP2DZF2utB0Yst2lpQtFHkjxjWWg99ucjtdbeq7Q+nOQFy5Y9tpRShlh3NbmcTfKxNZbHKg16/RCMXSlle+79erIkOTKG4o8OWHbxsCvXWt+T5ElJrlsWmknyXVmcgPP5LE6smc3ihJ+/SvIjuffkmw8keVKt9W3Dbh8AAAAAAAAAAAAAYBN8YMCyR5ZS9oxQ5tOG3M56GLSdp5ZSyloKW1rvKUNuZ5jP7E7yqLXksmRQ3X6k1jo7Qpmsggk4bJTlr/L6kuNjKPvEgGU7BixbUa31U7XWpyT5piRvTnJqFaufTPJfkzy/1vrUWusnV7NtAAAAAAAAAAAAAIBN8I4ByyaTPGcthZVSLs3gt7QM2s56GLSdS5I8YY3lPTHJ/iG3s9x7svh2muWet5ZESinTSZ61xlwYExNw2CjTKywf1Kis1tyAZVtGKOtoktOrWGdbkockeVwpZe8atwsAAAAAAAAAAAAAsGGWXjxw/YDQS9ZY5LcnWf62mZrkLWssb7XeneTYgOVr3Z/vGLDs2NJ2mmqtR7M4CWdcuTwvyaDfqr95jeWxBlObnQAXjMkVls+PoexBZazq3C6lPC3JbyV53Bq2X5I8aenfT5ZSfibJr9Za6xrKWqunj7Gs946xLAAAAAAAAAAAAADg3PWGJD+9bNk3l1LuX2v9wrCFlFJKkpcPCL271vrFURIcVq31VCnlj5P8s2Wh7yml/Eyt9cSwZZVSdiR56YDQH9Vah33ZwxuSPHvZsieXUp5Sa/3AsLks+cEBy26stfrt9wYyAYeNstKbbsZxDg4qY9BbcQYqpfzvSX45gycJ/UOSv0zyoSR3L5W7L8kjkzwzi6/xuucszd1JXpPk2aWUF6+icR1JrfV94ypr/hPvHldRAAAAAAAAAAAAAMC57beT/KskW+6xbDrJq3PviSwtL03yiAHLf3PYAkopNyV5wLLFn6+1XrOKPH4z98774iQ/lntPNGr58Sz+bnxQ+cN6Y5JfSnLJsuW/mORrhy2klPKsLL4BZ5RcGIOJzU6AC8bsCsu3rLB8NQaVsdL2vkwp5eVJfjX3nnxzU5Ln1VofW2v9sVrrG2ut76i1vqfW+ie11p+vtT4nyaOS/PWAol+Q5E1LMzkBAAAAAAAAAAAAAM45tdZbk/zegNB3lVK+bZgySikPS/IrA0IfS/LfR0hv1WqtH8ziCxiW+1ellKcPU0Yp5auS/MSA0J/XWv9+FbmcyuLLHZb7mlLKK4fM5ZIkrxsQujOLk6fYQCbgsFGOrbB81xjKHlTG0d5KpZTHZXBD/8Ekj6+1vr1XRq31k0m+LslrB4RfkOQVvTIAAAAAAAAAAAAAADbRTyU5OGD5fyqlfGdrxVLK45O8M8meAeEfqrUujCG/1XpFkjPLlk0neevS22RWVEp5TpK3LH3+ns4k+eE15PJrST47YPkvlVKa5ZVSHpjFl0VcPSD847XW42vIhxGYgMOGqLWeSTLoAt87huIHlXH3EOv937n323MOJXlhrfXwsBtfuin8iyTvHRD+6VLKOCYZAQAAAAAAAAAAAACMXa31QJKXDQjNJPnPpZQ/L6V8UynlslLKZCllbynla0opv53kA0nuN2DdX621vms9815JrfVTSX5sQGhvkneUUv5LKeW5pZR9S/tzcSnl60spb0zy9gyeTPSjtdZPryGX2ST/JPeeEFSSvKaU8t5SyneWUq4qpUyVUnaWUp5SSvnlLL5B6NEDiv3jWuvrV5sLo5va7AS4oNye5CHLll0+hnIHlXF7a4VSysOz+Oaa5V5Ta71ttQnUWs+WUn4syd8sC+1O8l1J/t1qywQAAAAAAAAAAAAA2Ai11v9eSvnJJP9mQPj5S/+G9ZYkPz6WxNao1vpvSymPTPL9y0IlyXcs/RvWf6y1/voIuVxXSnlZkt/PvV+i8rSlf8P6uyQvXWsujMYEHDbSjbn3BJxBr8MaWillMsmVK2yr5bkrLH/DWnOptf5tKeXzSR6wLPR1MQEHAAAAAAAAAAAA4JywUOtmpwDnpFrrL5RSTiX55SSTayzmDUm+t9Y6N77M1uwHkhxN8soRyvilJD8xaiK11jeUUuaS/F6S7Wss5u1JXlJrPTpqPqyNCThspM/m3m+dediIZV6TZHqFbbU8YcCyL9ZaPz9iPn+Te0/A+YoRy9xQCyfa7fHMrva9dGpy+aTMZetP9u/F05Ol+5nNNlHaOW6datfDVGcfe/WYJNOdz/TqcXqivf7OLf1jdWa+PQjp1cPcQnv902cXujl85PbjI22j57bjs93PfPyukTZxTjh4avR+7v7tg5rj/+nQiNu46fDJZrxzOg6l1/z0trFzS79rdfzM2WZ8+3T/+h/V3m3tPPdtbV//vctq+2T/YJTavr5radfDxFz7fKgT/WMxd9MnmvG9l1/bzuFef4jgy0127hU7hzjWe2ba11VvG4dm55vx3UO09Qt33tz+wGXtelrYcXEzfmpiazeHu0+easZ7/YstU+16muncr5LR7/29YzU10e//zHTu/b02bKKzjZkhcuj1P3r1NN15gDnfaWAmh8ix1xbPLbTbn5nO+dLLcRi94z3MOdkz36nrzqHKdCfH3rFOku3T7Wuz11+dmWqvPztEX7F7Tnb2c1vnfOgdy961P0wOE7Ud730xcKxzL0iGOFadHOf7h6LrrhPtPlJPrz87zBcoH7+rPbbo1UOvjbpqV/+ed/BU+57Xq+sjs+167O3DMHr7eWdnDLWtc77t376lm8NspyJ6bfXNR04343tm+n3Ji7a1+2kn59rX3rZOX3CIblq29u7LadfD3pn2RnbUdj0lyR1n28frsunOtb3QPp/qZLuek2Ty5MFmfOILH2tvY2ZbewML7WN5+/va5SfJAx//1c1473DX08ea8c4eLOrck7ZcfE0zfnSifSymjzVfSJ4k2Xr4lmZ8/orHN+NbOn2Hk3P9G1L32rvh/c34wiUPapc/ta+bw1Tn+cns2fa1e6Kzn0fP9Nv6U3Pt7/R6z+ROzrXP2iOnr2rGd83329npiYua8Zm97WN5/GT72p0/fqKbw4P3ta+u3rPRPZ12dtt0v3/S69d/5tCZZnzv/sc145dNtddPkpvubN8Pev3yz97d7t8M00/rjYd7faDe87jes/Kk/8yu91xgVMPk2Hum3+uf7O70gcYxJh+1P3rXyf45u6/TT+ul0KvH3rWdJEc647De+KXX3x1mTL6j0++e62yjN07s6ZWf9J+39/rlvfOt1zYk/fHHMHXd0rvukn5dHzrdPl9659v0tp3dHLZsae/n8dn28bxke3sfdt/R7zMvbG/f+xdu+mgzvu/yB7bX37m/m8PZd/1ZM/7x1725GX/kK5f/MeXlSbSP1cVXLv9bpgNMtOv61N/8aXsbz/3uZnx2R78/u7fzHdLH72p/f3NJ57q7/NQXujl8fL79vcMzrmhv43Tnp1KTdxzq5lBPHWl/4ES7jGPXtP+w9a5D13dzONP5Hmvu8kc14+VRy3++s6z8Tjt918l+O3vgcLsNu3OineORqx/ejJ880W9n86kDzfBG/PD6cZfvasaPdtr6izvXzbEz/Xr40G3tZwu9Z5fHz7THkcfO9MdYvT7zybk9zfgtN9/RjA/zXX3vO6K5Tgel90yw9/uSYX6/0us/9MYGD97XPlbXH2y300ly7f72+bCj02fuXVfDPH8FYPPVWn+tlPK+LL6A4ImrWPW2JD9Wa13zCxHGrdZak/xoKeWvk/zbJA9dxeqfTfJDtda/HGM+byylfCTJbyR5zipWPZLkVUl+vdbOj+9YV+v/C0/4nz48YNn9Sin9pzgrW+lb2f+3s94lA5a1R2rDGVRG/2keAAAAAAAA55yN+IM5AAAAAHCuqbV+oNb6pCy+fOH3k6z0l7YOJ/mzJP8syQNHnXxTa72m1lqW/btmlDKXyv2LJNcmeVGSP0yy0p9ev2sp/qIk145z8s09cvlUrfXrkjwlyW8luT4Z+Nf1TiR5R5KXJ7l/rfXXTL7ZfKYTs5E+sMLypyd5yxrLHPRnQQ4kuaGz3qBzfxyvORtUhm9mAAAAAAAAAAAAAIDzSq31HVmcBJJSyt4kVybZkeR0kgO11ts2Mb1VqbXOJ/mTpX8ppexPclmS7UlOJrmj1tp+jeJ487kuyXVLuexMcr8kO7P4e/SDSb649AYfziEm4LCRPpbFN8Rctmz587L2CTjPG7DsnUM0NoMax0FvxVmtQWWsNEMSAAAAAAAAAAAAAOCcV2s9nMU33twnLE222bAJNy211uNJPrXZedDnzRxsmKVJMYMm2nxrKWVyteWVUh6d5FEDQm8eYvU7Byx7YCll32rzWObJA5aZgAMAAAAAAAAAAAAAAOcxE3DYaG8YsOzyJN+2hrJ+cMCy40n+dIh1PzRg2USSF64hjyRJKeWhSR4zIHTdWssEAAAAAAAAAAAAAAA2nwk4bLT3JPnYgOU/W0rZMmwhpZSHJ/meAaHX1VpPDFHE25PUAct/cjV5LPNzKyx/2xrLAwAAAAAAAAAAAAAAzgEm4LChaq01yasHhB6a5FeGKaOUsj3JHySZXhY6neSXh8zjriTvWCGP3ymllGHKuUdOL0/ykgGhAytsBwAAAAAAAAAAAAAAOE+YgMOGq7W+MYtvwlnu5aWU15RSplZat5SyP8lbkzxxQPgXa603ryKVn8zgt+D80yRvLqVc0iuglLK1lPJLSX5jhY+8esg38gAAAAAAAAAAAAAAAOcoE3AuIKWUa0optfUvyY0rrP6u3rqllGtWkc53Jzk8YPkPJ/lIKeV7SykPLKVMl1K2l1IeV0r510k+neRrB6z3gSQ/v4rtp9b6wSS/tUL4G5PcVEr5D6WUby6l3H8pjy2llMtLKc8qpfx8kpuS/GiSQW/MaZUPAAAAAAAAAAAAAACcJ1Z80wisp1rrTaWUF2fxbTZbl4UfmeS1qyjuhiQvrrXOrSGVH0pyZZJvHhDbnuSfL/1brc8meUGt9cwa1gUAAAAAAAAAAAAAAM4hJuCwaWqtf11KeX6S/5Zk/xqL+fsk31xrvWWNOcyXUl6S5N8keUXG81aov0jyslrrXWMoCwAAAAAAAAAAAIAxmq+bnQEA56NxTDaANau1vjvJVyT5wySr6c6cTvLqJM+otX5hxBzO1FpfmeRrkrxzlXnc0yeSvLTW+oJa622j5AQAAAAAAAAAAAAAAJw7vAHnwnJbkqetc/mrtvT2mpeUUl6V5GVJvj7Jtbn3BLHZJH+X5M1JXldrPbD2VAfm8TdJnlNKeViS70jy1CRfmeTiFVY5meTDSa5L8qe11veMMx8AAAAAAAAAAAAAAODcYALOBaTWOpvk/Zudx0pqrZ9M8sokryylbE1ydZJdSeaTHE7yhVrr/Abk8ZkkP/ul/y6l7Emyd+nfZJIjS/kcqrUurHc+AAAAAAAAAAAAAADA5jIBh3NSrfV0ks9sdh5JUms9ksVJN5/f7FwAAAAAAAAAAAAAAICNN7HZCQAAAAAAAAAAAAAAAMC5zAQcAAAAAAAAAAAAAAAAaJja7ASAc8stf/SmZnzPK5/ZjE9PlGZ898xkN4eZyfbcwIVau2Wst+lOjntmppvxiybm2uV36jFJtk+PlsPMVHsbvX1Mkt1b2sdz55b2bebk3HwzPje/0M1h61TnfOlsg/HZPt0+H46cPjtS+ZOd62JiYf3bhiEuzXXXq4f5Ierhc3ef7MRXldI5qt3OJsnWK5/XjJ++4ei4kjmv/f2Op7Q/cMPhEbdwZMT1N8aobVjP39w8ej1s67TDPcP0sXr35vlOEb17xcRku43r9X+S5JId7T7QwVPt9qG3hRuPzHZzOH22XU+9tryX45bLdnZz+Ogdx5vxXZ1+XO9YzQ9zvnTuSXOdE6Z3vk0McWPunFKZ7Wzj+kOnm/HbjrfPh97YJklmOv3ZXj32HD/Tb7+unJhpxvdubZ8P2zr7cPepfvu0rXN9n5xrH8zesRxG75xc6JxQEwvt+KHT/f7Jnpn2GGrnlnY99ephmLFm75ycLO0yjnT2s9cG3nmi385etK3d1u/pxHvH4tiZ0ceRvXvB3m3tY92r58XPtOO9Is502pddpw51c9i2/Yr2B2q7Hupku/254Wj/WFy9+6JmfPLzn2rGzzz7+5rx7Rfdr739Hbub8SQ5fP+vbMZPzbXr6dBsux7OnO3fK3rPYG65vt13+Mqr2vu578TBbg5/O/WIZnzPsfa12bsf3XWif8/r3bsfeekTm/FDp9r1ePxMu++Q9NuHXj9sV+f56vUH22P+pP/cb6LTgPT65b3yL9u5pRlPkh2dbWzp3E+OzLbruXdNJMlFnXOu11Kf7FzbvfKT5NbOddG7pz1ob3vsUGbPdHNIemOD9tq957e9ayJJjsy2r++znT5Q77pa6NwTZ88uZGenn3bpjvZ53bsv9/rtF21t92+SZF+nD9Qbx/X6w73yk+SLR9vt4OcOtvez1x8eZnxzrHPf7I2xjnauq91DHIsH7N3a/UxL75zc2RnTJ/2+Yk/vOVPv2h6mT917FrVvW/u66p0vd57ot3G977F6fYdH7N/ejN9ytD++6em1Yb17/z907kdJ/3zptfU9l+64pvuZu29vH69L9391M36y00+bO96vh6se853N+OwvvaQZ//T2dvtwyfb2+XZD5zlUksx3Lq09z/yXzfgnbm33+ydK/3uRFz5kTzN+/cFTzXjvnP7kxJXdHJL2tTVX2nX91k+3vwi7aNv9uxn0nk189syl7QI+0x5DPfHKB3Rz+NCn+uP2lt4+9J4hX7W7PaZP+m1973vNXvvUO582wjDfrfSui5mp9n70nvnNDtGn7j0X7I0tes+693fawCTZ0TmnTveej3S+O5keogO0c0s7z6OdsccVO9vn/dV72vFhxqK9fnuv//KIHe16mprY0c1h8h2vbcYf+tQXNuPzF7Wf113e+S4PAOBc5w04AAAAAAAAAAP0Jt8AAAAAAHDhMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKBharMTAAAAAAAAAAAAAADYKAu1bnYKAJyHvAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgIapzU4AAAAAAAAAAAAAAGCjzC/UzU4BgPOQCTjAl6nzC+tafinrWvz5o45ez5Odyhy1rieGKOB8OJ7D7Afj0TsnJydGOxa9Yzmf82NQ3KsHg3tgswxzz7xi10wzftux2WZ8//bpZvzI6bPN+PEz8814knzm7pPdz7QcODk30vpD6ezG1qn2y2qH2cdeGXOd+82R2faxuGhr+1gmyc4t7XjvnHvwvu3N+E2HT3Vz6NmzdbIZ79XD9un2+kny6Et3NOMfu/NEMz5R2seql8MwV8SWyfax2NqJz3TerzxMPXVz6JzT0yP2NZP+OTnqNmYm+y+inunsZ6/PfeT06G3Yns71Pdd5bjBqPc4v9Ot59mw7h9mzZ0bKYZh74jDndcu2zrHeMd0/X3rXTZlrtx+9bUzecXs3h127L2+XcfC2ZrxuabeRWyYv7uYw1TlcC6d67WxnA51nOOWhT0797N+1P9PZxHxnGDjRKWGY03G6c231rovuUPXU0W4OW3eO1sb1cpzuXBOL22jHpzrb2NI54Sbm+jn08uzdLnrPFYZpw0Ztq7vPgDop1CEefZzpXRgdvXoc5nzpnQ+99mNL57rrlZ/0z7nudTHfHqNNHr2jm8OuLVd3PjF6n7nn5Fx7EDUx6nXROV9Ozs3n0h3tAc7Vu9t9qC2dk/LGQ+3xzf7tnQFWkst2tL/2PT7Xvqf1rruLt/eP5cFT7c8c6vRXbzvePmeH6ZOfGvV86cRnz/afTXz8zuPdz4yUwzp/l5cku2ba59OeTvzYmf6YvXc8T3f6/Xceb/fzhmnre2PN42fabVzvlBymDbzjRHv80suxZ4hq6OrV5UKnszjMsbgQ9I5k79lo0j+nere83rGaGOJYlc4YqVdE777c62smycIwHUrWncOw6Fz4PcIwOfTHkr31O/FhxqKd5xuj1uV46mG059S9cV6vf5Mk0xPtbfSejWa+17dof9eXJMevv7EZ3/eYg+1t7Gg/0xvm2ScAwLlMbwYAAABgHfQm3wBw/utNvgHg/NebfAMAAAAAwIXDBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGqY2OwE415RS7p/kUUmuTLI3ybYkR5IcSnJbkg/WWo9uXoYAAAAAAAAAAAAAAMBGMgHnAlZKeVCSJy77d9GAjz6z1vrudczjkmU5PCnJ/Qd89Gdqra8a87Ynkjw5yTOX/j01ye7OagullE8m+eMk/7HWess4cwIAAAAAAAAAAAAAAM4tJuBcIEopD8zixJbeZJv1zmP/sjxWmmyznjmUJF+d5NuTvDjJZassYiKLb8h5VJJ/VUp5Q5IfrrUeGmuiAAAAAAAAAAAAAADAOcEEnAvHh5Ps2ewkkvxOkm/a5ByuSvLuMZU1leS7kzy3lPJPaq3vGlO5AAAAAAAAAAAAAKyDhVo3OwUAzkMm4MBgc0luT3JXksNZnLx0TZKLV/j8lUneWkr5BpNwAAAAAAAAAAAAAADgvsUEHPifPpzkvyf5H0neX2s9dc9gKaUkeVSS70/yvUm2LVt/W5I/K6U8odb6mQ3IFwAAAAAAAAAAAAAA2AAm4FzYbk7yoSQfXPrfA0v/f6MdXNr+l/59MMm7kzxgA7Z9NMnrkryu1vqR1gdrrTXJx5L8UCnlPyT5oyTXLvvYjiS/nuTr1yFXAAAAAAAAAAAAAABgE5iAc+G4Ocnnco9JLrXWA/f8QCnlmg3I42CSd+QeE39qrTcu/9Diy2bW1bEsTpR5Ta310GpXrrV+opTyrCTvS3LNsvDzSilfU2t9z+hpAgAAAAAAAAAAAAAAm80EnAtErfWxm51DktRav2ezc8jim36uqbUeHKWQWuvtpZQfSPKXA8LfmsQEHAAAAAAAAAAAAAAAuA+Y2OwEYKPVWk+POvnmHmW9LclHB4ReMI7yAQAAAAAAAAAAAACAzecNODC6tydZ/oah+5dSSq21bkZCo7jkZ3+7Gb/u1uPN+EJnl287dqabw9zCeVBt8wvN8BePnm6vXmea8WHq4Mjs2Wb89Nl2jtOTpbuNnls7x/PQ6blmfL6zn/NDnAq9/Rz1fBqmmnp59soYdf1xeNSlO5vxz9x9slvGYy9udyv2bm3HP3rHse427gsWhjmx13H9YUxPtudo75lpH8tjZ+a725g92//Meuu1H9unJ5vx42fa7XCvHuc695IkuWjbdDN+6FS7nR2HR+xvtw+fOtDuG1y6o33Pu/PE7KpzWq2JMnpDuqfThh053T4fxqF3Tp6cW//ratRzrrd+777d6zuwcXptYDJMH6fdDs522slxnA+9e8FMpy3vXXe3HO2Pf3r7ccWudjt627HR29EvHGmXccPBU8147553rDN2GYdxtPUTnSJGbYd746MkOXCyf860jKMeRr2fTHYqstfW99YfpozpThm9c3aYehymz7vepjr7OVE69dTZzYVTJ7o5lNpuR8vZznk/0WnD2t3hxSJOH2nGj916ZzO+rVP+ws797Q88/vmZuvum5kfuPNluB/dubbcvZ+bbB6s/skiS9jZ618WO6c498YPv7maw9ese34xv75yU+6Y79+1d/ROmd91cMXdXu4CZS5rhySHaj/nO89N9nbHHzi3tY/G5IZ7hbO8cz0t2bGnGt3QeVn36QDuHXZ19SJLbjrfvib0xWO9+NjPVviaS5Mqd7XPq/be0n2Vd2qnHYc6X3nPmnj//fLsdXqjtczpJpifbbXWvP9sbBz704h3dHLrPgDtjh27/pLP+MGPhd954uPuZUdx0uH9tHzjZbj9G7eddP8Sftlvv73eGKX+qc08bVe+emSTznT7SRpgY8YuF3jju4BieS476qHscx7p3T+uNLXrPDYb5Lq73kV4OvfHLOOqpl2PvbNg61c+hl+eoz2iGOd964/7evXtrJ8deH2xmiHrq5djLoVfPvfMtHBAcWQAAIABJREFUSSZOHupso30/mpka7bpL+vWwZa49nu3Vda/8YT4zzPFs6Y3BxrGN3nXTi1+9p/3cMkm+eLTdl+y1L7193ICvTc8J/etiiO8ct7bHN73n8b3n0MOMsYb5brS9jfb50Pu9UjLMWLG9jRsPt5+V33a8XU/DtC/D7EdLOdseT99wpD/OvOy6Tzfje77yc8349kc+vBmfOj3E+Gnb5f3PAABsEm/AgdHdPGDZdJKLNzoRAAAAAGDj9CbfAAAAAAAAAPcdJuDA6Fb6oz6b/+etAAAAAAAAAAAAAACAkZmAA6O7ZsCy2VrrwY1OBAAAAAAAAAAAAAAAGD8TcGB0zxqw7PoNzwIAAAAAAAAAAAAAAFgXU5udAJzPSimPTvLkAaG3bnQuAAAAAAAAAAAAAPTN183OAIDzkQk4MJpXrbD8TzYyiVLK08ZV1rETJ8dVFAAAAAAAAAAAAAAA3CeYgANrVEp5QZIXDwi9t9b6vg1O570bvD0AAAAAAAAAAAAAALhgTGx2AnA+KqVcluR3B4QWkrxig9MBAAAAAAAAAAAAAADWkQk4sEqllKkkb0xy+YDwr9dar9vglAAAAAAAAAAAAAAAgHVkAg6s3r9P8jUDln8kyU9scC4AAAAAAAAAAAAAAMA6m9rsBOB8Ukr5P5J834DQ4SQvrrXObnBKX/L0MZb13jGWBQAAAAAAAAAAAAAA5z0TcGBIpZSXJ3n1gNCpJC+stV6/wSn9/2qt7xtXWcdPnhpXUQAAAAAAAAAAAAAAcJ8wsdkJwPmglPLSJL8xIHQmybfUWv/HBqcEAAAAAAAAAAAAAABsEBNwoKOU8o+T/E6Ssix0Nsm31VrftvFZAQAAAAAAAAAAAAAAG8UEHGgopXxbkt/Pva+V+ST/qNb65o3PCgAAAAAAAAAAAAAA2Egm4MAKSikvSvKfk0wuCy0k+We11v+28VkBAAAAAAAAAAAAAAAbbWqzE4BzUSnlm5L819z7GqlJXlZr/YONzwoAAAAAAAAAAACAUS3UutkpAHAeMgEHlimlfGOSP0wyvSxUk/zzWuvrNzypDfTXNx0Zaf3pyfaLtYbptG6dOv9fzjU7v9CM33T4VDM+jjo4OTff/sBcO7x/+5buNkYdhGyfXv6CqS93/MzZbhm9ulro1cMYTJbNXX8cHpy7m/E7ZnZ1y7jhB/9xM/7Qn/uFZvxjZV8zPjnRrqj5hfNjUDzqfmxEPfSuzav3zDTjNx+Z7W5jrtNOboTePeuyne128OShdvuyc0u7Ho+c7h+ry3e26/rI6X47OaqH7Ghv4zN3t8/J++1u1+OBk2dWndNmOBeOxb5ty7unX6577x+Dizo53Hasff3v2doegh6bbe/DyYX138fzQe9ekKz/fbF3r0iS+U5fcXqi3Q7vmmlvYxznfK8vuWemfc72+v1X7Or3qQ+dbnfMH9C57955YvR29NId7Tx7/fKdW9r1tBHt00bonZO982F6iGuX8ejdbw6cbF93w4zRJspox/OWo+175oEhngv0+h+9c3L/9vZ9fW7nE/o5fP5E5xOXt8Mne1volZ98oveB5/14M3zt8XY93nCofayeeflVvQwydaZ9vnzw1uPN+LnwJfDf3Xqs/YEn/UC/kEPt52E9/zDS2osefemOZvwdB7Y343u2ts+HXn826V+bExe1c/jQbe1jMUxf8fiZXp7t/kVv/d497x/u7F/bvX7YXKe/O47n1AdOjdaH6W1jmH7cMMdzFPfbubX7mV5f7shsux2dTHsfes/Kk2SmezxHq6fe+TIOV3SeK9x2vP88rafbH92A/ewNFc+Fe9pGGGbMvNl6x+LqPe324eYjp8eZzkBPuar9vcT7vnh05G188kD7nnT1nm3N+JHOvf+LnX7/MI717ruda3scp+NlnecGd3TuaQdP9Z+d9q6b3v2mN0Yb5roc9bzu1cOn21/FDeXk3GjPgcbRPr3tQPuetn97+5y8uzMmHybHXl/wL29pXzfX7G33uWfn+/3A9f6+/yN3tMeJ49jGqA4O0V/u5di7dnv3q/aTjfuOXj0NM254yL72vb037u/db8bx3e+zHri3Gf/rGw+PvI311vtuZj79/nBv/NPzljvb7XTSvy8f+z9+txn/XK+AW0bvp33LRSMXAQCwbs7/X7nDGJVSnp/kj5IMeor48lrrazc4JQAAAAAAAAAAAAAAYJOZgANLSilfl+SPkwz6UwD/W631tzY4JQAAAAAAAAAAAAAA4BxgAg4kKaU8K8mfJhn0ztVX1Fp/c4NTAgAAAAAAAAAAAAAAzhEm4HDBK6V8dZI/S7JtQPiVtdZf2+CUAAAAAAAAAAAAAACAc4gJOFzQSinPSPLWJNsHhH+i1vqaDU4JAAAAAAAAAAAAAAA4x5iAwwWrlPKVSf48yc4B4Z+stf7iBqcEAAAAAAAAAAAAAACcg0zA4YJUSnl8krcl2T0g/FO11l/Y4JQAAAAAAAAAAAAAAIBz1NRmJwAbrZTy8CR/lWTvgPCbk7yjlPLUMWzq+lrrXWMoBwAAAAAAAAAAAAAA2EQm4FwgSinXJLlxjau/q5TS+8wDa603DZnLTUkesIY8frqU8tOdz7y01vr6zmeeluTiFWIvXPo3Di9N0ssFAAAAAAAAAAAAAAA4x01sdgIAAAAAAAAAAAAAAABwLvMGHAAAAAAAAAAAAADggrGwUDc7BQDOQ96AAwAAAAAAAAAAAAAAAA3egHPhuC3J09a5/GF9S5KZdcrj+t4Haq2vT/L6ddo+AAAAAAAAAAAAAABwH2MCzgWi1jqb5P2bnUeS1Fo/vNk5AAAAAAAAAAAAAAAADGtisxMAAAAAAAAAAAAAAACAc5kJOAAAAAAAAAAAAAAAANBgAg4AAAAAAAAAAAAAAAA0TG12AsC55eH7tzfjH77tWDN+1a6tzfierf1m57bjs93PjGL/9i3dz0yUdvzOE2fGlM1ge2b69XRk9uxI25go7Z0ctfwkOX12YaT4MI6dmR+5DJK7t17ajB87eLxbxle96uea8bmLH9SOHzzUji/Ubg49j7t8ZzN+w8FTzfg4zrddnev7QRe129EP3tpuhzfC7Hz7WAxTT9unJ5vxcbRBPQu1nWevjeqdk8c79TDMOX33ybmRyxjVkTrTyeF0M37gZPtYDrMP050bc69/0dvEsSHOt96xGDWHufn+PfHYmdHqsnfdLdT+sThyerQceuvPTLX/RsTcbD/HyU4/rtOEdfXqMUlOzq1v/2Qc1/6o9XTZzn6f+jN3n2zGpyd67WwnPsR18+jL2vf+Tx9o59jTy+FAp+1Ikp1b2ufUXb12dIh66Dlwsj2+meucEP346DmeC47Ntq/t3rHstYHJcG3xKHZu6Y81j3fuN+eC3ri+d6x65+T8QqeRTDLZ6Z/0zofevWIc4+XefvbqaZjzsbeN6cnOvb2z/rWXtNvxpN9Pu/NE+znT3afa60/3bppz7f5wksyebZ+zs2dH6zvMTPX7J71nTb16Oh886tJhzpfR+rOjjhOT5CH72s9fT5wDz7o2YKh5Xljn2zLnkPlxjLF6XyqcA0bta/a+UxhmG70x9XqPpzfKE69o35N647ybDrefUw9j//bpZvyKzrj++kP9Ps56u/nI+n4XN4zec+ru87ohxsPPuP/uZvxvv3C0GT8X2p/1HssyvPnOsdiIYzXZuV/07gU7hnj+emSife317u07trTHqpNDPBqZX9j8Nmqz9eoxGaKf1SliHP20+4Qx1NPFOTFyGettptw3niMDAHDf5w04AAAAAAAAAAAAAAAA0GACDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANU5udAAAAAAAAAAAAAADARpmvm50BAOcjb8ABAAAAAAAAAAAAAACABhNwAAAAAAAAAAAAAAAAoMEEHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAaTMABAAAAAAAAAAAAAACABhNwAAAAAAAAAAAAAAAAoMEEHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAaTMABAAAAAAAA+P/Yu/Noy7K6TvDf/YaYcx5IyCTJZGwEQaZSQLAQGkVBoahSy6p26iqQ1SoqDmXZljS9pNRSS6lisWyg0dJl26hlWbQlIKNMgkhSFIpCQibJkElm5BAZQ8aLF+/t/iOyysjgvr1vvHPfvffF+3zWegvi/M7Z53fO2Wef4ebvXgAAAAAAaFCAAwAAAAAAAAAAAAAAAA0KcAAAAAAAAAAAAAAAAKBhadYJAAAAAAAAAAAAAABMy3qts04BgG1IAQ5wH717yvX1YTed49y0Dl1Hz9o47S+ULc2h59DKyRzYtbVDdO9YjHOsFkp7P3lI4XR1DvrLPHTJscYgpmJtxodiz9JCjp9cn20SU9C7VoxjsXNdXhw4vvTaPzVPO77aOZQzvrVIkix2chhneNoO1/ZZn9tMzzSOde+63cvhpkPHc/UFe5rzDL01mMZ+6J37a934JLOZnf4YOHywH7qv+mP9uXEwen1uGtvZGx+mcdt/rhzPlmls4tD9+N67dudrL16dUDZste41q3PyrnSe4VbX+s9493QeHo6trg1ex1CrnQeYXg5r68PfAc3Dfji00j63L9qz3Iwf6xzraWzDBZ0cD5842W3jfvt3N+MHj504q5y2wtc96IJm/B033LXlOfTGj4dc1N6PNx9ZmWQ6zNg8vALuDTFzkGL3vNm73H4hN4137b13essLnZeGY7iwHm3Gu5/nTeGhu/ceexLXtO3wmeN2yPHIifY91CMv3d+Mf+Jguz8m/eN9uJNDrz/tWeqfV711fMNDLmrG//wLh5vx1THOq6HH+7m3va0Zf8sVzx7U/jQsjfXZSnue3nm1NhdXrHNDWT3emaP97DANJzP8ugoAANPgzhVgDm118Q0As7cTim8Adrpe8Q0A25/iGwAAAAAAANg5FOAAAAAAAAAAAAAAAABAgwIcAAAAAAAAAAAAAAAAaFCAAwAAAAAAAAAAAAAAAA0KcAAAAAAAAAAAAAAAAKBBAQ4AAAAAAAAAAAAAAAA0KMABAAAAAAAAAAAAAACAhqVZJwDbQSnl6iSPSnJNkvNz6tw5muSOJDck+WSt9UszSxAAAAAAAAAAAAAAANgyCnB2sFLKg5M84Yy/i0bM+oxa67u2MI/LzsjhiUkeOGLW/6PW+vKtymNEXo9K8s+SfGuSa8eY/6YkH0jy5iR/oiAHAAAAAAAAAAAAAADODQpwdohSyrU5VdjSK7bZ6jwuPSOPjYptZubeffWLSf7hWS569b1/357k3Un+/mQzAwAAAAAAAAAAAAAAZkEBzs5xXZILZp1Ektfl1C/KzKVSyncleXWSA7POBQAAAAAAAAAAAIDJW6t11ikAsA0pwIF7lVJekeRnGrOsJrk5ya1J7s6pgqbLcupXbwAAAAAAAAAAAAAAgHOUAhxIUkr5mYwuvqlJfi/JG5O8pdZ6ZMSyFyZ5QpLnJHlekodvYaoAAAAAAAAAAAAAAMCUKcDZ2W5K8pdJPnzv/x689/9P2x33rv+//304ybuSPGgaKy+lvDDJK0aEPprk+2utH2wtX2u9K8nb7/37sVLK1yX5exNPFAAAAAAAAAAAAAAAmAkFODvHTUmuz2lFLrXWg6fPUEq5Zgp53JHkbTmt8KfWesOZM5VSppBKUkq5MslrR4Tem+Q5o37xpqfW+u4k7x6aGwAAAAAAAAAAAAAAMB8U4OwQtdbHzDqHJKm1ft+sczjDv0ly0RnT/jqbLL4BAAAAAAAAAAAAAADOPQuzTgBmpZTy+CT/+IzJNcn3K74BAAAAAAAAAAAAAAD+O7+Aw0724yOmvbHW+p6pZzJHdi2WZnxhoR1f7iy/vNCv+1ta3NrawD1Lw9tfKO3tHGq5s5/nJYeerc6RydnVOd6dU/uUe+5uhhdWj7fjnf4yVg4dS53tnEYOvXGyl+Mkcujpnf+9HMcZP3r7YRrb2dO7ZvVy7O2H1TG2cR720+7OdbO7HyawDb1zsxdf7lz6x7le9frDWmcd67UOzmFx4BjV34/dFHJsdW1QDr3lh/a3pL+dvWPRM84YNw9jWE+/z7X309p6fx2rnZk63SHHT7aXH2c/947X2np7O5d3Dbvm3Xx4pRlPkov3Ljfjk7ju9vTGl/44O/zc3Q7694qTOBaDm2g6V57RhvbZbvsTOK/640+nP42Twxhj8RDz0F/GeUXUm2foGLZa2teKD9y5K0/Zf6g5z+LCgWZ86P3LOGPHFr9uG8vQ7ZzEONy9Zg19bzCB5+F5OPcYz9Bni2no3e8unCM3avvv/nwzvrq+f0qZbKx37veef8ax1X1ynGeP1U6f65nEfhiqtx+/6orzum2sdJ6He+9HJrEfLtvfftY8sdbezmnkeO2Fe5vxh+xvr+Pjt279OHzFgd3N+LUX7mrG33z9ie46Fo7e3o6XC7ttbLV5uH+Zh3uk7r3eFIaw/j1ze/kJfEy+Laxtg/u0srd9f9J7tzoPbjrU/uw36W/HVr/PP1esd67bY1lbba+jDvtPCMcZp3vH829vb79Pn4f+8NjOveA1J29pxt90e/sdEQAA28MOebyG+yqlXJzkhSNCr592LgAAAADA9tQrvgEAAAAAAADOHQpw2KlemOTMr366Jck7ZpALAAAAAAAAAAAAAAAwxxTgsFM9Z8S0t9da27+nDgAAAAAAAAAAAAAA7DhLs04Apq2UUpJ83YjQxxrLXJLk/kl2JTmY5GCt9djWZAgAAAAAAAAAAAAAAMwTBTjsRA9KcvGI6f/19H+UUp6U5J/n1K/lXHXmzKWULyR5W5K3JPn9Wuvq5FMFAAAAAAAAAAAAYJLW1+usUwBgG1KAw070qA2m35gkpZSrk/z7JM/rtHNlku++9++VpZT/M8kbaq1TvysrpTx5Um19+ra7J9UUAAAAAAAAAAAAAACcExTgsBNdvcH0w6WUpyX5wySXnGWb1yR5fZLnlVL+aa316ID8NuP9U14fAAAAAAAAAAAAAADsGAuzTgBm4P4bTH9kkj/J2RffnO75Sd5bSjlvQBsAAAAAAAAAAAAAAMAcUYDDTnTRBtN/M8n+0/5dk/xBkm/PqV+42Xvvso9O8tIkH9ugna9K8oZJJAoAAAAAAAAAAAAAAMyeAhx2ot0bTL/ytP//hSRPrbX+w1rrG2utn621Hq+13lVr/ata66uSPC7JjyZZH9HWC0spL5pw3gAAAAAAAAAAAAAAwAwszToBmIFev78lydfWWm9szVRrXU/yb0sptyX5rRGz/HQp5Q211tXNpXlWnjLBtt4/wbYAAAAAAAAAAAAAAGDbU4DDTtQriPlfe8U3p6u1/nYp5RlJvu+M0NVJ/nGS/3B26Z29WusHJtXWZw4enlRTAAAAAAAAAAAAAABwTliYdQIwAycasffWWv/LJtr8V0lOjpj+/E20BQAAAAAAAAAAAAAAzBEFOOxEdzVir91Mg7XWLyT54xGhp5dSymbaBAAAAAAAAAAAAAAA5oMCHHaig43Ynw1od9SylyR56IA2AQAAAAAAAAAAAACAGVOAw070hQ2mH6q13jig3Y9uMP3yAW0CAAAAAAAAAAAAAAAztjTrBGAGPrPB9DsGtnv7BtMvGdguAAAAAAAAAAAAABOyVmedAQDbkQIcdqJPJlnPl/8C1LGB7R7dYPqBge1O1b7l9g9jLS+UzvKLzXhpL54kWRxjniF2L/V//Guxk+hW57g8xgq2Oodjq2uD2+j1l2lYXZ/9k1LvWE3iYW5of5jIoTp5ohku6yeb8a3u00l/OxfnoM/Og7U6rFOuj7W8fb1d1IH94Vwx9LyYhIVxbqTYFnrHcrxxlEmwr0+5457VZvy83cNeH50r41fvXnES27nV+2qc+93tcLyGXpd727g2gefIebh36NkOY+CJMR6YVzvz9Lbz+Mn1dvud/rC+v//dOycOD8uxZ5z3Cr39NA1Dt7O3/HomcO72zv/2q8+JjB/TMLQ79JafxOuVOeiyg/X6wzxs4zhdduitwSS2c7kTP3HhA5vxxYNDv39tuDuPt9+3T+LdaO9zjWkY+pnAJN6lD22jd6949ET73iFJVpfabax07j8msR/GyXPWDp9of2Zw2+reKWWysfN3tT9TvOGu9uciz1v9r911rH1qo+94POUrvuJ5zfid97T34xfuPt7N4bkP2tOeYbE9Ei8vtPfTp+8c+jH8fLj/ebub8ZsOtff14644rxnvfU6fJJ842N6XvWNxw13tHK88r9MXkuzt5PnZu+5pxo90zv3V9c5Nd5LVtfYYd+Oh9rl55MTwz8GHvj+pX/msdvs3zv95M85z5tD9tB3eU20Xt++9ohlfKHdPKZONHVppv6eeB73r7oELHtCMrx88NMl0Rvqaqy5oxq+75Ui3jce98V814xc9+mHN+JFnvaQZf89NW78fAAC2Uv8JHs4xtdYjSf5mROj8gU1v9AQz+092AAAAAAAAAAAAAACATVOAw071vhHTLimlDDknLt9g+sEBbQIAAAAAAAAAAAAAADOmAIed6i0jpu1L8hUD2nzSBtM/O6BNAAAAAAAAAAAAAABgxhTgsFO9OcmREdOfPaDNUct+vNZ624A2AQAAAAAAAAAAAACAGVOAw45Uaz2a5I0jQt9fSiln214p5bFJnjoi9PazbQsAAAAAAAAAAAAAAJgvCnDYyX4lST1j2sOSvPRsGimlLCR51YhQTfK6zaUGAAAAAAAAAAAAAADMCwU47Fi11r9K8jsjQv+6lPLMs2jql5I8fcT0P6i1fnxTyQEAAAAAAAAAAAAAAHNDAQ473cuS3HHGtD1J/riU8tJSytJGC5ZSriil/D9JfmRE+O4k/3JyaQIAAAAAAAAAAAAAALOyYXEB55ZSyjVJbtjk4u8spfTmubbWeuOYudyY5EGbyONnSyk/25nne2utvzFug7XWL5VSvjPJf8l9C9J2J/nVJD9cSvmPST6Y5NYku5JcleSZSb4lyYFRzSb5p7XWT42bBwAAAAAAAAAAAAAAML8U4LDj1VrfUkr53iRvyJf/KtQ1SX70LJo7meQHaq1vmlB6AAAAAAAAAAAAAEzQeq2zTgGAbejMYgPYkWqt/yHJNye5fUAzB5M8u9b665PJCgAAAAAAAAAAAAAAmAcKcOBetdY3J/mfkrw6yT1nseihJK9I8tBa6zu3IjcAAAAAAAAAAAAAAGB2lmadAFNzc5Inb3H743pBkt1blMenhyxcaz2Y5AdKKT+T5PlJnpXkK5M8MMmBJMdz6pdubk3yoSR/muQdtdYjQ9YLAAAAAAAAAAAAAADMLwU4O0StdSXJn886jySptV436xx6aq13JnnDvX8AAAAAAAAAAAAAAMAOtjDrBAAAAAAAAAAAAAAAAGCeKcABAAAAAAAAAAAAAACABgU4AAAAAAAAAAAAAAAA0LA06wSA+XLp4Rub8bV6UTN++f72sLJnsXRz+Pit3VkGuWTvcnee0knzhrsmlMwGztvVH54PHlvd2iQmYK3WWacwF9amsBuGruOtnxneqf8gj2zGH33Prk4LJwbn0HPV4tFm/Pbdu5vxQ8eHn3eX7mvvhwes3NxpYf/gHHr2LLVrtO85ud6MH1td667jyvP3NON33tPe19M4ry7Ys9iMr663k1joXEzG2YYL97SvBzcd6rcx1IFDn23G1+oF7eV3tfvTOPuhd/tw3u7Oseqs5PCJfp89f3f7WJxYa58XvRzGuWbuW25vZ29fLnd25PoYOWz1udfbxvHuf3r7+iwSGqG3H8dbx9bmOJ5hOZy3e+u/z2OcPtmz2LuxH2gSOfYsdDZhGjn0LHa6wzzkOA+2y37YDnkuL7Q73epa+9o+jW3sjT+rnXG4d+6PP9PGlnsn7zg69/69e+KevZ1nkyQ51pmnl8PBY+1n0Qs69+THF9rPkafWcaQZH7qflsfoC7sH7qftYNcY+2Gce7mWcZ53e5Y6efZynMSx6u2q3vPuOH2uvf7+8qudZ6xp9NkvHWmPD/c70H7Hc8c97f4yzn4ces3q9adx7peHvuMdeNolGaM/dK6r8+Bc+EbEcc67Xp8deu6O05/66xjYp8c4mL1zq5fjJLZh6Hug3nk3iXO7d19/vPNyYhI59LT3Qn+MXD/e/kwiSWpnnl5/6u3Hcc67sta+5q0vte95Fxfa17xpHKtp6B2L3nb2DsU448vQ90Td/jTGwerlMHSsXzk5/J77+Gr77D3e+ZxrGm5ZGfYZ1DjO29VexzifjbQcWjk5aPmk/5nAJJ7BenrdfvfS8Bzvt7/97PClo+1xeOgzWJJ85s7jzXjvWPSO9yTG+t7nwz2TuF/tvS/rjZO9dxMTeR/XsauT4zj96Z7b7mzGD9zV/u9Leu8+zoX3UADAznYuvO8FAAAAAAAAAAAAAACALaMABwAAAAAAAAAAAAAAABoU4AAAAAAAAAAAAAAAAEDD0qwTAAAAAAAAAAAAAACYlrVaZ50CANuQX8ABAAAAAAAAAAAAAACABgU4AAAAAAAAAAAAAAAA0KAABwAAAAAAAAAAAAAAABoU4AAAAAAAAAAAAAAAAECDAhwAAAAAAAAAAAAAAABoUIADAAAAAAAAAAAAAAAADQpwAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGpZmnQAAAAAAAAAAAAAAwLSsrddZpwDANqQAB+ActbxQZp1C1+oUHmIWp7Ab1jqbMY0ctoN56JMLxw8348uLe7Y8h6XOflg4dqjTwv7JJbNRDqWd42InPo6hbUzjvDp4bLUZ7/XpIydONuPjbMNf3XpkcBtD/XV5QCeHo834dTd3zrsxxoZen1xb7zbRNM5+/NuD7e28+oK9A3PoJ3HzkZVmfOg4u7zY/4Fb4o2yAAAgAElEQVTU5YWBO7tj5WS7/fvt35WDx04MWsfQ82a1d+GfwDqmcW73zqukvZ3HVre2L0zK0EvWJK55Pf1jwbQMPRa9YXSc9tfrsGekSfSn7dAne/t6sXfPPQfndi/HaeQwD+voLT9O89MYq1v+8uYjedIDDsw0h3HMej9Nwzgj6NBxdujySdJroreOSeTQ1bnVm0QOvfN/KtvZsdXj6DS2sff6dZxnjzk4FF11B4xxbC9Dz5tJjA/zMI729HKch03o5dCLL+zqf+ZQO/MMvXcYy0LnPxsp/feG9A3tT+NYm8L97noddh83xuvVwYbuh2nYDuP0NMzDfuj1yUnk2OuT/efAdvvjPLv0PkubxrF47BXnNeMf6Xym2DOJc/8hF7Svy1860v6M6qI97WvqsdW1s87pbN18pP0Z9zjvJa/5Fz/bjK/vv6QZ/9tODitDP9wFAJgxBTjAfSxd9ahm/Nuu2vocvu0x+7Z+JQM99LL2i4FpeNLVFzXjf/jxm6eUCQDAdAwtvgEAmLTtUHwD82Y7FHsCAAAAAACM4qtKAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGhTgAAAAAAAAAAAAAAAAQMPSrBOAUspSkocmeWSSy5JcmFPFYXcluTPJDUk+Wms9MeW89iV5fJJHJLk4ya4kR5J8NsnHaq2fmWY+AAAAAAAAAAAAAADAbCjA2cFKKQ9O8oQz/i4aMeszaq3vmuB69yV5WpJn3Pv32CS7O4utlFI+nOS3kvx2rfXopPIZkd+zkvxgkmcn2dOY79NJfjPJa2qtB7cqHwAAAAAAAAAAAAAAYLYU4OwQpZRrkzwx/WKbrVr/3iTPTfKPknxzkn1n2cTuJE+99+8XSymvTPJLtda1CeZ4VZLXJvnGMRd5SJJXJPmRUsqP11pfP6lcAAAAAAAAAAAAAACA+aEAZ+e4LskFM1z/C3Pq12sm4fwkP5/kBaWUb6u13jS0wVLKE5P8f0nut4nFL0ryulLK30vyklrr+tB8AAAAAAAAAAAAANgaa+t11ikAsA0pwGGeHEtyS5Jbk9yT5JIkD0uyd4P5vzrJO0opT6+1fnGzKy2lPCrJW7PxLwLdkeQTSVaS3D/JI5IsjJjvRUlqku/fbC4AAAAAAAAAAAAAAMD8GVVEANOyluTNSX44yROSnFdrfUit9cm11q+vtT42yYVJvj7Jf9qgjYckeWspZddmEiilHEjyBxldfPOhJM9Kcmmt9Wtrrc+stX5FkiuTvCKnCnLO9OJSyj/bTC4AAAAAAAAAAAAAAMB8UoCzs92U5A+T/HSSb0zyxCmt94YkP5Xk6lrrc2qtv1Zr/Uitdf3MGWutJ2qt76y1viDJ85McGtHeo5K8bJO5vDynftHmTK9P8tRa69trrff5ncFa6y211p9N8rQkd45Y9ldKKVdsMh8AAAAAAAAAAAAAAGDOLM06AabmpiTXJ/nLe/8+XGs9ePoMpZRrtjiHG5P8XJLfqLWePNuFa61/VEr51iRvTXLmL978dCnlVbXWo+O2V0q5NskPjQj9aZIXjSoIOiOfvyilvDDJ23LfYrbzcuoXcl40bi4AAAAAAAAAAAAAAMD88gs4O0St9TG11n9Qa/25Wuubzyy+mYK3JHl4rfV1mym++e9qre9O8isjQvtz6ld8zsbLkiyfMe14xii+OS2fdyZ57YjQd5dS7n+W+QAAAAAAAAAAAAAAAHNIAQ5TUWu9rda6OqHmfjnJqAKZbxq3gVLKniT/y4jQb9RabzzLfH4uyZlFRbuSfPdZtgMAAAAAAAAAAAAAAMyhpVknAGer1nqwlPKRJE88I/Sgs2jmm5OcP2L6/7WJfD5XSnlzkueeEfrOJD9/tu0BQMvy4tbXT9969MSg+EIp3XUcPtH+Qbxx2thqx1bXmvF5yHEajmyDY9WzVuusU9gW1tZnv592L7XHuHH62+JCe56h27m82M+hl+dW5ziOXg4jv/LgNLsnsB96JrGf9g7sU3fc0/4eiUmMgXs6OX7y9mPN+CTuDXr78vBK+1pweGVwCltuGtertc55s75NrkdbneckjkVvX8M0/cUXj+RJDzjQnGdxG9wznwvG2ctDx6BpXE9665hGDkPvFSdhOzxrDjWd/rTlq9gRxwqmrXdebZdni53AEMgkzcHr2akY47XiBNbReT87B+du9x3yHOQ4DfNwL9nb15PIsdcnp/Ec2HuNPI0+OY3nk63WfV7umIc+P45SOw/+nfhC5y3NdtkPAAAbUYDDdnVTvrwA54qzWP45I6bdUGu9bpP5/H6+vADnK0spV9Zav7DJNmGQFzz6/rNOAc7Kwy4/b9Yp5Kt68SsvnEIWZ17ezvDXt0whBwAAAMbRK74BAAAAAAAAzh1b/xXqsDVGfQ3x2Xzv3jNGTHv7JnNpLfv1A9oEAAAAAAAAAAAAAADmgAIctqtrRky7eZwFSykXJ3nwiNAHN5tMrfXzG6z/CZttEwAAAAAAAAAAAAAAmA8KcNh2SikXJnn8iND1YzbxmA2mf3xzGf0PHxsx7bED2wQAAAAAAAAAAAAAAGZsadYJwCb8kyTLI6b/8ZjLP2SD6eMW8Gzk0yOmjfqlHQAAAAAAAAAAAABmZG29zjoFALYhv4DDtlJK2ZfkJ0eE7k7y9jGbuWbEtJVa68HN5nWvL4yYdlUpRaEbAAAAAAAAAAAAAABsYwoD2G5enuSBI6b/u1rryphtXDZi2q2bzujv3DJi2kKSiyfU/oZKKU+eVFu1quoGAAAAAAAAAAAAAIDTKcBh2yilPCPJy0aEbk7yC2fR1MUjph3aVFL3dfcG0y/JFhfgJHn/FrcPAAAAAAAAAAAAAAA71sKsE4BxlFKuTPK7Gd1nX1JrPXwWzR0YMe3IphK7r6MbTN8/gbYBAAAAAAAAAAAAAIAZUYDD3Cul7E/ypiSXjwj/eq31j86yyeUR006edWJfbnWD6bsm0DYAAAAAAAAAAAAAADAjCnCYa6WU5SS/l+RxI8IfTvLSTTS7OGLa2ibaGbeNpQm0DQAAAAAAAAAAAAAAzIjCAOZWKWUhyW8lec6I8PVJnldrXdlE06N+7WYS58JGbWz0yziT9JQJtvX+CbYFAAAAAAAAAAAAAADbngIc5lIppSR5fZJvHxG+Kcmzaq23bLL5UUU7uzbZ1jhtbKZI6KzUWj+w1esAAAAAAAAAAAAAAICdamHWCcAGXpPke0ZM/2KSZ9ZaPzug7cMjpp03oL1eG3dPoG0AAAAAAAAAAAAAAGBGFOAwd0opv5bkxSNCt+ZU8c31A1dx+4hpFw5ss9XGqPUBAAAAAAAAAAAAAADbxNKsE4DTlVJ+OckPjQgdzKnim7+ZwGpuGTHtslLKQq11fUC7V4yYtpLkrgFtAgAAAAAAAAAAADBBa+t11ikAsA35BRzmRinlF5P86IjQnUn+51rrxye0qhtGTFtMcuXAdq8eMe3GWqu7NAAAAAAAAAAAAAAA2Mb8Ag5zoZTyyiQ/PiJ0KMmza60fneDqPrXB9Icn+dyAdh92FuuaW8fvuacZ/5NPD/tBn+XFft3f6tqQHyJKFhfKoOUn4ZoL9zbjV5+/3Iz/2U13TzKdkZ76wPOb8etuOdpt46pf+OfN+GVfNeq0+DtL3/uKZvzdnz3UzYHJeMSl+5rxT93eHhuS5ClXndeM78+JZvzjneHlC4ePd3NgPowzDt96tN0fem1ctKc9jt55fLWbQ8+RE2vN+Dxcb3oWSjvHfcv96/LBY+19+ZCL2+PHjXe1x4/lMfbjaudbZ4aOD739lPTvYR568e5m/D2da/vQ+59xHDp+cnAb+5YXm/EjJ4atY+Vkez+sj1Pb3tmVY7XRXH6ceTozdXK86vw9zfjn7+73+aE59JY/MYFvg9rqHJPk/MX2WD60P/TGj3HaP97p91ee1+4PNx3q36fN2jjj7HZweKU9xu07sKsZn4f9MM7tyzzk2bO82M7x4LHh17yhVtfb5/ax1fb4NM637vWuyz29Pj3O/W5vnBsaPznGfujt6946Lt/fvo9b6dynLfcuWEnWBt9/DNuP4+Qw9Jo4jklcN4GdyfgAzMrQx6O63r7vT5J05unl0LvH2g7vsXeK3rEc42P0rsWBnXacdwK9LrUd3iucK9YG3iJ1Xq9MxHbIcRq2+rwYZ6yfh3Nz9hn0Dd1Pc7Cbu8a6Nei8b+vGAQDOcX4Bh5krpbwiyU+NCN2dU8U3H57wKv9bklH/hcFjN9tgKaVssPwkC4cAAAAAAAAAAAAAAIAZUIDDTJVSfibJz4wIHU7yjbXWD016nbXW40k+NiL0lAHNPjrJqJ9++OCANgEAAAAAAAAAAAAAgDmgAIeZKaX8VJJXjAgdSfJNtdYPbOHq3zZi2teXUpY22d43jJi2muTdm2wPAAAAAAAAAAAAAACYEwpwmIlSyo8leeWI0LEk31xrfe8Wp/CmEdMuSvLsTbb3HSOmvavWeniT7QEAAAAAAAAAAAAAAHNCAQ5TV0p5aZJ/MyJ0LMlza61/NoU03pfkxhHTf+hsGyqlfE2SJ4wI/fbZtgUAAAAAAAAAAAAAAMwfBThMVSnlJUl+dUToniTfUmt95zTyqLXWJK8eEfqGUsozxm2nlFKS/MKI0K1J3rjJ9AAAAAAAAAAAAAAAgDmiAIepKaV8X0YXvRxP8q211rdPOaVfT3LbiOlvKKVcOmYbP5Hk6SOm/1Kt9fimMwMAAAAAAAAAAAAAAObG0qwTYGcopXxbktcmKSPCP5/kcCnlayawqutqrSvjzFhrPVxK+ckk//cZoQcleXsp5VtrrTdutHwp5ceS/OsRoU8l+bUx8wUAAAAAAAAAAAAAAOacApwdopRyTZIbNrn4O0sZVTdzH9e2ilWSfFM2/sWll9/7NwnXJmnlcR+11jeUUr4lyfPPCD0mycdLKa9O8vtJ/jrJSpL759Qv3vxgkq8e0eSJJN9Zaz1x9qkDAAAAAAAAAAAAAADzSAEOJN+d5O1JnnjG9P1JfuLev3GsJ/neWuuHJ5gbAAAAAAAAAAAAABO0tl5nnQIA29BGv0gCO0at9e4kz07ytgHNHE3yHbXW35lMVgAAAAAAAAAAAAAAwLxQgANJaq13JvnGJD+S5NBZLv62JE+otf7exBMDAAAAAAAAAAAAAABmbmnWCTA1Nyd58ha3v6Fa6/ck+Z4tXP9gtda1JL9aSnl9ku9K8vyc2mf7z5w1yWeSvCXJb9ZaPzTVRAEAAAAAAAAAAAAAgKlSgLND1FpXkvz5rPPYDmqth5O8OsmrSyklyVVJLk6ynORIks/VWo/OMEUAAAAAAAAAAAAAAGCKFOBAQ621JvncvX8AAAAAAAAAAAAAAMAOtDDrBAAAAAAAAAAAAAAAAGCeKcABAAAAAAAAAAAAAACAhqVZJwDMly8ePdmMLy6UQe2v19qdZ+g65kFvO9f7u2HL9XJYGyPJpT272vG9u5vxOkZ/AIBx7h9mnUPvmtZbfpz7n4Uy+3uk+5/XvrbfdGjYsTp8Yq0Z3720OKj9STh+cr07z9A8H3hB+x7rS0dPDGp/Ej51+z3defYstb/zY20Kp3ZdaL/22Oo+Nc74defx1Wb84r3Lzfgknp/GufcHGKV3f7LcGaPW1tvx3Yv9MW73Ynss7+bYWcd6bcfLevtdWpIsLwz7Hqz+NvTb712Xp3Gv2b1m9W+zmvYu9/fDR285MmwlE9A7XDcfXmnGe8dynPvVc0GvP03j/mYentF6ev3lS0f6zxaX7ms/n0xDb5xbPHbHoOWnoXdmzkOOk7CY3nW1fW5OYz/0cuzpnVdJ8snbjw1aR2+MG2cbVjsP3TcfaV9vpnEs9i237+P2LrW3cxrj8N7O8V452d7PJ67/WHcdy1c/fFgOS+0cxtlPC4e/1J5h30XN8K7FA4Nz2A72dO43e+fN/s7yB8a4n+2dNz23dt4r3u9A/7rf65O9Z6xp9IfP33185jn0fOTmw834WOduZ5bdc/Ds0Mux995gdQ6eVXs59uJJcsGe9nvqW48Oew4cp7/0njWvvmBvM76yNry/XHXy1mb8I6WdQ884+6F3P3r1+e338Z+6/WgzvnJyTzM+Tn8Z6tN3tO9FH37J/m4b//n2y9sztIewJO39NI39AACwlc6Nt7kAAAAAAAAAAAAAAACwRRTgAAAAAAAAAAAAAAAAQIMCHAAAAAAAAAAAAAAAAGhYmnUCAAAAAAAAAAAAAADTsrZeZ50CANuQX8ABAAAAAAAAAAAAAACABgU4AAAAAAAAAAAAAAAA0KAABwAAAAAAAAAAAAAAABoU4AAAAAAAAAAAAAAAAECDAhwAAAAAAAAAAAAAAABoUIADAAAAAAAAAAAAAAAADQpwAAAAAAAAAAAAAAAAoEEBDgAAAAAAAAAAAAAAADQowAEAAAAAAAAAAAAAAIAGBTgAAAAAAAAAAAAAAADQoAAHAAAAAAAAAAAAAAAAGpZmnQAAAAAAAAAAAAAAwLSsrddZpwDANqQABzgrQ286FxfKXKxjaA5D19Hbwqc+8Py873N3D1pHN4fazuJxV+zPdbccbc6zsNy+jJSF9g+trXmGmRud7pD13gzp9+uU9nmzXte76wAm69jqevYtn/s/irnQGX+m0cYkcpgH41wPYJ7UGZ97kzj3L9/fvue+4a4JjHGL58YYNWt33HOyGV9enP0199hq/557HvLsOXhstRmfxjb0rolHTqw1493xYYxNmMT7j6029Ll/nOWH3p/0ll/rxN93y4k85coDnXW0++xQh1dOZt/yYnOetTl45N7qD7PnYRvH4TN9pmkS58V6/63fluuOHwvte+a19fZ1eRpWTnauN9tgcBjnmrvV7z8m8V5iaI7n7WpfcyeRw2rn5P2aq87vruNg5/mkt45ejuPcc/fW0bvPmodLez/Hdnxh7/7uOhb2tOcZmsNYFncNiu+UV4ZDt7M31t91fC2X7W7Ps2epfe71zt1eDuN8XnD+rvY8y53Ph5me3nPioePta8U0LPfeS27t4/RYJpHjUucdzjx8hjSNz3/q3gua8YUy+wN+fODLrNXOOPuIS/fnE7cdac4ztD/0juWx1f7zkc8DAQDaPPkCzKGtLr4ZR6/4BoDtbycU3wAAwFbqFd9MQ+8/qgIAmLZe8Q3w5XrFNwBsf73iGwAAtgf/xR0AAAAAAAAAAAAAAAA0KMABAAAAAAAAAAAAAACABgU4AAAAAAAAAAAAAAAA0KAABwAAAAAAAAAAAAAAABoU4AAAAAAAAAAAAAAAAECDAhwAAAAAAAAAAAAAAABoWJp1AlBKWUry0CSPTHJZkgtzqjjsriR3JrkhyUdrrSdmliQAAAAAAAAAAAAAALBjKcDZwUopD07yhDP+Lhox6zNqre+a4Hr3JXlakmfc+/fYJLs7i62UUj6c5LeS/Hat9eik8jkbpZRHJrkuG+d7ba31xullBAAAAAAAAAAAAAAAbDUFODtEKeXaJE9Mv9hmq9a/N8lzk/yjJN+cZN9ZNrE7yVPv/fvFUsork/xSrXVtook2lFIWkrw+/WIhAAAAAAAAAAAAAADgHKIAZ+e4LskFM1z/C3Pq12sm4fwkP5/kBaWUb6u13jShdnt+IMmTp7QuAAAAAAAAAAAAALbA2nqddQoAbEMKcJgnx5LckuTWJPckuSTJw5Ls3WD+r07yjlLK02utX9zKxEopD0ryc1u5DgAAAAAAAAAAAAAAYD4pwGGW1pL8aZI3J3lPko/WWtdPn6GUsivJU5P8UJLnj2jjIUneWkp5fK31xBbm+utJDpz27/UkC1u4PgAAAAAAAAAAAAAAYE4oINjZbkryh0l+Osk3JnnilNZ7Q5KfSnJ1rfU5tdZfq7V+5MzimySptZ6otb6z1vqCnCrAOTSivUcledlWJVtK+a4k33DapPUkr92q9QEAAAAAAAAAAAAAAPPFL+DsHDcluT7JX9779+Fa68HTZyilXLPFOdyY5OeS/Eat9eTZLlxr/aNSyrcmeWuSXWeEf7qU8qpa69Hhaf6dUsrlSf7tGZNfk+TDSV48yXUBAAAAAAAAAAAAAADzSQHODlFrfcyMU3hLkv+31ro6pJFa67tLKb+S5F+cEdqfU7/i8wdD2h/hVUkuPu3fX0zyL5P8gwmvBwAAAAAAAAAAAAAAmFMLs06AnaHWetvQ4pvT/HKS9RHTv2lC7SdJSinPS/LtZ0z+wVrr3ZNcDwAAAAAAAAAAAAAAMN/8Ag7bTq31YCnlI0meeEboQZNaRynl/CSvOWPyf661/sdJrWNeveMzdzTjl+zb1YwvL7br+m45fLybwyMuPdCMd1aRvzl4tBm/fP/ubg6HTpxsxi/dt9yMHz85qkbs73zoC4eb8QO7Fpvxcdx41z3N+Ns+c2czfmx1rbuO+//4mafJfV13e/tYXHPXiWa8tx+T5J5Ono++/LxmfM9Su0N95OZ+zd2V57f71K1H29u5u9OpL+2cd0mystbeVzcfXmnGP/j5Q834Wq3dHN73ufa+OrLSPq9W19vrGCeHc8FiKYOWH2c/9daxu3Ne9MaHA7v6t5jrnTxX19rxi/a0x+Fx9M69Xo69c3t5ob2fe31+EhY6x/r2Y/0cetvx8S+1r2l7l9vXtHHG+odfsq8Z//Qdx5rxCzr95YLd/T57uHNv8Kk72uNsbx0Hj7X7U9Lvk8dW2/uyd3/Ru6YmySc78/TaOL+zH3rXs97YkAy/j5pEDvuW2+NLr4n33dS+LvfuuZNkrTPG9I7VQufcH0dvDNrXGR9WO8dinD775uvb97y9NnrHanH4bspS53j+2WfvasZ7536vPybDt7N3rHv33OPk0OsP1160txlfXujn0Lsmray1+8sd97SvFY+53/5uDie75247/snOM9jFe/v3UNdcuKcZv/Gu9nP911zRfj4qq+1n1ZvX2tf9JNm71O5zl9z5qWb8yGWPaMdP9O9P7nfje5rxev+HNeMfW72kGe/1t6R/PA8st8+LI53xY5z7tEee157nSGn3pwsOf64ZX3nb67s5XH31w5vxr1pqP1Mv7rqsGT/653/ajK8m2feMFzbn+crLH9KMX3jrx5vxlb/682Z814Mf1YwnyaELn9yMX7y3fV2+dF/7Pu5vDvbf+T38knZ/WOn0uTtX2ufFFV9o76ckee792udmXW7nWFbb21lOtMfhJCnHv9SMP+yem9rL37/dn9YuvKqbQ/2z32nGP/emtzfjD/mRH2nGb7/icc34oc6xTJIHvKv93nH3k57djH/+vIc24//t1v6x6jl4rP2dY+Pct2+1I51n2XFy/Gzn2j8P2/neg+17g3nI8W9vb7+7mIccGc/n7m6/A0r679O6Ov3haOc+Lklu630usTTs/Un3eXiMPt0bRx9/YXs7J3HePPPaCwYt/+EvHmnGz//7L+q2cfFH/1Mz/onb2uNH753hON581/ntGe7qXbvbz3mTeC9w8d72/ehXL36xGb9+d/8/JdjbyfOKdD4zvLD93N/77OUdn2u/a0/6++naC9vPgU97xy814xc963ndHG65/5Oa8QdftCefubP/fAAAAADblQIctqub8uUFOFdMsP1fTHLlaf8+nOR/m2D7AAAAAMA21yu+AQAA2Gme9uD2l04A9/UVV3QKIXeIFwyri52KF35l/0uWWrbLsX5SLpp1CgAAc83XKbFdjfpKpP7XPY2hlPJ1Sc78OqL/vdb6+Um0DwAAAAAAAAAAAAAAbC8KcNiurhkx7eahjZZS9iR5bZLTfzj9L5L8+6FtAwAAAAAAAAAAAAAA29PSrBOAs1VKuTDJ40eErp9A8y9P8rDT/n0yyYtqrRP5dR0AAAAAAAAAAAAAZmttvc46BQC2Ib+Aw3b0T5Isj5j+x0MaLaU8LsnLzpj8q7XWjw5pFwAAAAAAAAAAAAAA2N4U4LCtlFL2JfnJEaG7k7x9QLtLSV6f+/4q1I1JfnazbQIAAAAAAAAAAAAAAOeGpf4sMFdenuSBI6b/u1rryoB2fyzJ486Y9pJa67EBbU5NKeXJk2rrtR+8cVJNAQAAAAAAAAAAAADAOUEBDttGKeUZSV42InRzkl8Y0O7D8+W/dPO7tdY3b7bNGXj/rBMAAAAAAAAAAAAAAIBz1cKsE4BxlFKuTPK7Gd1nX1JrPbzJdkuS1ybZc9rku5L88GbaAwAAAAAAAAAAAAAAzj0KcJh7pZT9Sd6U5PIR4V+vtf7RgOZfnOTpZ0z7iVrrlwa0CQAAAAAAAAAAAAAAnEMU4DDXSinLSX4vyeNGhD+c5KUD2r4qyS+cMfk9SV632TYBAAAAAAAAAAAAAIBzz9KsE4CNlFIWkvxWkueMCF+f5Hm11pUBq3hNkvNP+/eJJC+utdYBbc7KUybY1vsn2BYAAAAAAAAAAAAAAGx7CnCYS6WUkuT1Sb59RPimJM+qtd4yoP3vSPLcMyb/fK31E5ttc5ZqrR+YVFuv+9BnJ9UUAAAAAAAAAAAAAACcExZmnQBs4DVJvmfE9C8meWatddNVIqWUS5K86ozJn0zyys22CQAAAAAAAAAAAAAAnLsU4DB3Sim/luTFI0K35lTxzfUDV/GrSS47Y9qLa60rA9sFAOD/Z+/eozXN7rrAf/e5n7p2Vac7nZCEzo1bTBAIEoLCcI/IRURhyUWjojOiA47IQhaDMjhySQZvM6IzKoQBHQFHVAZFEEFEroGggrK4JTSd9K26q0/VqXM/Z88fVS6a4tT+PVXvqTpV6c9nrV6Q9/e++/m9+9l7P/vZz9n1AgAAAAAAAAAAwHuhheNOAJ6rtfaNSb74kNCFXN1884szlv+mJJ9/3cvf0nv/4VnKBQAAAAAAAAAAAODesH/QjzsFAO5BNuBw12itvSXJnz8kdDHJJ/bef/4IDvM51/3v7ST/pG2lHpQAACAASURBVLX2hpss55U3eP1DWmsPXX+M3vs7brJ8AAAAAAAAAAAAAADgLmEDDneF1trXJvmyQ0JrST6p9/5zR3Wo6/73cpLvPaKyk+SfHvLaryd5+AiPcawO+njX9/z1NXyd/Qmbxtd39obxxfm5Yfyg2Jm+u39Q5lB9z629cRnrO/vjHIoc93frHKu6rkw5F5W1rfG5qr7n2vbuML5d1HNSn8+qPW3vjyuyagtXj1Gc77KyZ/sOSV3Xuwd1XY5U/Sqp+0XZ7ou6npJDZW5ufL4X58bjy6vvPzGMv/vSVpnDi04vD+OPXtoexveKNr8/oXMvFvUwqyn9pjqfVRkbu+N+N+VfKTmxMj+Mr23XfW+YQ5HCXKvPQ1UPVRmnlsbfsRq/ktmvF9V3mNJeLm8X57soomoPVXu6+p5qHB23l6pJVmPkUajqenlhPAYms7eHWb/nlPZSOb+6OIw/cWWnyGHC/KT4nlP6/0h1zZ2inp7MXtcHKfp/0eY2J/TNModqHK2uiUU9VP2muu4nyRPr4zZXqcb6D3rwZFnGuy6O5zAXt8bz9hTnen7C3KMaq08vj5ewXnluXNe/eKGep1Vz5lefXx3Gq6/5G5fqc31+dfw932/h4jC+ceb0MP7ohPlqNS+v/IfHxsdYnBu32Y3djfIYK0Xfe9nZG/27KVedK+ea9Ti79qqPHsaXipv2xWer9jCupyR5z+XxvcPppXF7Or1cjB8n6vaS4n51f3HcN9vO5jC+/EG/q0yhLY/7Zivu8/reeIxbeskrhvG9X67/3Z0zZx8Z5/Dgy4bx5d/xxvHnWz2PO9nH5/P0/towPvfkOP7BZ6//N4l+u/kn3zmMn1wan8uzZ140jPf9eu7Q3lP8wPqLP2AYPlg+Nf58FU/S9sbnop08P85habw2sZnxfDdJTj/8gcP4w28e1/XB6QeH8TM/+93D+KlLTw/jSZLllWF4+6e/fxh/cPlHhvE3vfT9yhRakcPek+8exhcefs348+fHfT9JdhbG/WKxWFec2xr33YPVc2UOV/bG181qprdYXBPXtib03eIeqnhkkO3iO0yZ/2zuFvVQVEQ1N7i4Ob6mTlm7qOp6eX587a/uny5PWKeu1vRPFfOTak4+5Vb18oxrepUp52LW9Y/q/mjKml51LqY8Kxs5KG6AjuJfkX4m4+vq7v6lmY/x1Ma4vVTDQ1WPFyeMcff/jo8ZxrefnO1c3Q3/onfVXpI6z2qNePtlrx7GLz01vvdIkp3FcQ6rJ+8bxte2ivubhXE9TBk7qnqqnr1+4Kf+4XEOD47rMUmevTw+F+9/8O7sDW7tL5waz4HOzVXrUEmKNdq+OJ5DVfObs2vje5ckabvje/JHz4znm2tFm56yhLxSTIKqJf/Noh4qU543bhXj5JXimlatbUypp6eKNf+zK+NjVNf+an6T1H8v8MjaePyo/kbmbLF2msz+9wJJ8nGvemDmMgAA4L1B/WQObrPW2tck+YpDQpdydfPN2+9wSgAAAAAAAFBuvgEAAAAA4PnDBhyOVWvtq5J81SGhy0ne1Hv/qTucEgAAAAAAAAAAAAAAwG9hAw7HprX2FUm+5pDQepJP6b3/+B1OCQAAAAAAAAAAAAAA4LexAYdj0Vr7C0m+9pDQRpLf13v/0dtx3N77m3vvbdb/kvyxGxzi5Ye8/+Hb8V0AAAAAAAAAAAAAAIA7wwYc7rjW2pckeeshoY0kn9p7/5E7nBIAAAAAAAAAAAAAAMAN2YDDHdVa+9NJ/sYhoc0kn957/6E7nBIAAAAAAAAAAAAAAMCQDTjcMa21P57kbx8S2kryGb33H7zDKQEAAAAAAAAAAAAAAJQWjjsBnh9aa5+d5O8laYeEvz7J5dbaG47gUO/ovW8fQTkAAAAAAAAAAAAAAABJbMB53mitPZzknbf48R9q7bB9M7/Fy3vv7xrEPyU3/sWlr77231F4eZJRHgAAAAAAAAAAAAAAADfFBhwAAAAAAAAAAAAA4Hlj76AfdwoA3INu9IskAAAAAAAAAAAAAAAAQGzAAQAAAAAAAAAAAAAAgKGF406AO+axJB95m8u/od77m5O8+TYe/077uST/yyGvP3unEwEAAAAAAAAAAAAAAG4vG3CeJ3rv20l+4rjzeG/Re/+5XN2EAwAAAAAAAAAAAAAAvJebO+4EAAAAAAAAAAAAAAAA4G5mAw4AAAAAAAAAAAAAAAAM2IADAAAAAAAAAAAAAAAAAwvHnQBwd7m4uTvT5/f7OL57cFCWcWFjnMPifBvGr+zuD+NzW/V33CjKOLM8Hj639sbf88LGzjC+Ml/vj6zq+myR48buOMeHTq+UORz0cRLr23tlGSPVeUjqNvXElXFdF80pu/t1m62+5/be+HvsHoyTOLE4X+ZQ1dV20SaPwuLc+HvsFfG5Po7vZvwdprSXxT7uW7v7xbkqOt7ihL77xPq4TW4W36Nqk7sHxeCQ5GDCe2Y5xqzlJ3VdVv2iGp+SZLuoy9NL42O88OSpYXy/yKG63iXJBz1wYhh/emM8/lTXmynjy8c+MD7GwcrZYfxdl8dt+kWnFsscelGXL79veRhfXhi3p7O/8K/KHNorPnQY//W5Fwzj73N6/D3nt9fLHB7fH1+bn9kcn6vXbf/KML5/avwdkuTntsbn+76V8fyj6hf3rYzb5GpxLpPk8SvjvlWV8YITS8P4+56t2+zS9towvvD0u4bxgyuXhvH+4g8oc2iP/OfxG1748DC8c/8rh/GFKxfKHHb+9TcP43ML47pcfuOnDuNtc1xPSdKXTg7jByfPFwWMrxV9eXwt6PP1sks7tTmOv/Nnx/GXfOAwfuXkfWUO54u+W80lq3F2faeep23sjseH08vjY6xces8w/rrz9Rj31M64TZ7dH7e5g+XTw3h1vUqSlf2iPWxcHsZfd/+5cfzcaplDK65Jm6v3D+NPF9ejnWJOvTw/HoeT5FQxTzszP25zbW9jGH/o1HjsSOp7g4tb4xyq+eqEW4vMt/E9VHXdrc5F2xvPJa8epJjTFpfNav4xt1S32f2Vcd9LG1fm3CP/aRjffexd4+Nv1fW0/NKXD+NL9z0wjO/d//D4AMV3TJL9xfG9RV8oxqi5cb+b0l4OVsdzyb487ntrB8U4/cqPKHNou+Nxdm9lfN2cck2rnNsfj7NzV54ZxqsVnvmT9RjWz4zbXM6/dPz5oj0svvjhYfzgdD0/2Xv68fEbDsbnYuFFRQ4vH9/jJUkvrkntwVcN45snxtfM9WJ9Nkm2N8ffc3VhfC04uzC+j7yyV6+frO+M86xyqI7wTHHNTJKFYl3xFWeKdaKl8Xy36tunFuvzVSwzl156dtzetiecq7PFnHn1YGsYnyvmgbsPPFjmsLA9njPPXx7P2/dXx/PZjZXiHi7JZlFXzxT9qpqHFVOwJPVa+WZx/7Nc9Kul6sHGBNVzrGq++4pz4/GlGhuSuv9X9fhp94/b7N7ZF5c5VPOog6J3f8z7juc3JybUQ7s8vof6qJeO233VHpYOJszri3uH92yPx9m17fG5fOBEvZ62UtTVjz86vh/eLNp01eanqNZHqmcO1T3YlGeS5bP44g37J8fj7O5cfU++tbc9jB+cGh+juqbtrtbrJ3PFYFyd760ih9PFc48kaYvj++HqfFftqfqOSTJXzLSq9rIzoc2Ny69z3CrmUNXz3cW58Tg9Zf2keq5Zt5fqXE34m4aq/5fPVmcbf67mMNv5fv8XnMivXbjxWDxldrJUnLC9oh4ubo2vmb944UqZw6ni3uBS8fdE5d/pFGvta8V3SOq1zw96cHzf/zPvHs/Jq++QJOdWx9fuleKZwNqEv8uqfNZrJ8zlAACOiV/AAQAAAAAAADjElM1SAAAAAAA8P9iAAwAAAAAAAAAAAAAAAAM24AAAAAAAAAAAAAAAAMDAwnEnAAAAAAAAAAAAAABwp+wf9ONOAYB7kF/AAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYWDjuBAAAAAAAAAAAAAAA7pT9g37cKQBwD/ILOAAAAAAAAAAAAAAAADDgF3CA32JpYbwv7/4TS8P4S86sDOPrO3tlDi87Oy5jcb4N4xc2dobxcyuLZQ6VV91/YhhfLerxoI93z59drofnrb2DYfxFp5eH8UfWtobxV9+/WuawNDc+F796cWMYf/DkuD3t7tf/ysDG7jj+olPjelgpztXG7riek+RUcb52i38t4dTS/DA+pc3OtfG5uLhZVFRhuainJJkv2kNVT+vb4/HhoPiOZ5freqr63n4Rv7g1Wz0myfZ+3aZG5op6njLCVWXMF3W9vDCOb+/tz5xD1eaevLJd5FDXc3WMxflxvLreVH1/Y7eup6ouq2FyszhG1eaT5O3LJ4fxjafHY/3lom8/eqm+5lX/6kzVr6px9lXv/8llDs9ujevyl5+8PIw/dnl8PTqxWNfDY+tXhvFLxRi18uL3G8a3Jlzzfvnp9WF8dXFc15WzK+N6ODGh/AvF5KCYSubyzvhcr22Pz2WSPHBi3G8eeOh1w/hSMf5cKnJMknOv/shhfGdhPNd76sq4Hs+vnC9zOP0hHz2M9+3xfHT/5P3D+Nz8eC6ZJH1hfL4OVs8WBRRzh4XxvcuUcXZp5fQwvnDuwWF8rxinp1wTq+6/VVxw9vu4gM29KfP6cbsuukUOivayOWGWtL47vmadP3Pf+BhFXa9P6Ltnl8dt6sSpB4bxKwfjcXJ+rr7eLJ8Y19XGzvh7bhXne7NocPsT7j3m2riM+Tauh6XFcb9ZL75jUs9PqvZweXvcHnYP6hyqNrW8N9vaxMGZYoxM0vbG8/KdYvzoy6fGOZQZJH1xvEaT4v5m7tS4b8+fHI/TfX9tfPwkbWnct6vr1VGoznebG/ebg+JctYN6za+vnBnH54uxurglX+/1WL+8PJ4/7BX3FtXaR3UfmCTbJ8dj+UIx1l8qxqhLVyasvxbHSHFt31sZ95u9Mw8N4+1gwrrBzvj+J3vje/K9Uy8YxqfMkaoxbH/h3DC+vj4+F89u1eeqWru4sjtuk2fOjuf9B7t1m10rrln7fZzjQyfHffP0Un3t3yjyvDhuDtnZH9f1lQn3w5eK9Y3Fudn+zcPVYg61M2FNcb+Px/ITi8Va+er4enVps26zL9ov7vPOvGgYX2vj6/p6sT6TJBO691A1T5ui6rvV/c/ywrjfnFqc0t7Gc/+niuvFhY3xPO/pCe2hUj232Nwb18P60rg9XblUn8vex+85yLhvLhULTScn3N+cPvnCcQ7F9eg969Vzi2IxLEkxxGV7r2ov44G4Wq9L6nusd18ajy/veHz2f3u2fMa8Ou5X1fO8R4tnsw/fV9zbpH5O/tjlcd/9x+8ZXws2fv3JModqffXni0WcZ7fGx6jWRpN6ze18cS6qNeDXvnB8/5MkT6yPr7ubu+N7xQ97n/H90YRHbXlkbXMYr+5PqvX2D3lovH7yjseLOfsRqO5lc1CPcbvFPOqgmM9Wt3lljhPeU8Wr6Wr1HZP6mWL5HL04RLH8ci2H2eqhyuFgwj15VVdT7utHquvZlPZS5VAVMet3SCa0ydtcjwAAdzu/gAMAAAAAAABwiGrzDQAAAAAAzx824AAAAAAAAAAAAAAAAMCADTgAAAAAAAAAAAAAAAAwYAMOAAAAAAAAAAAAAAAADNiAAwAAAAAAAAAAAAAAAAM24AAAAAAAAAAAAAAAAMDAwnEnAK21hSSvSvKBSR5Icl+ubg57NsnFJO9M8nO99507mFNL8uokr01y/lpOi0nWruX1ziTv6L1v3qmcAAAAAAAAAAAAAACA42EDzvNYa+0VST7suv/OHfLWj+29//ARHvdEkt+T5GOv/ffBSZaLj2231t6e5NuSfHvv/cpR5fOcvOaSfGKSL0zyCbm66WZkr7X2H6/l9G2992eOOicAAAAAAAAAAAAAAOD42YDzPNFae3mS16febHO7jr+a5FOT/KEkvy/JiZssYjnJR1377y2tta9N8r/13vePKL+PSPIPkrzmJj62kN+sy69rrX11km88qpwAAAAAAAAAAAAAOHr7vR93CgDcg2zAef54R5Kzx3j8z8rVX4o5CmeSfH2Sz2ytfXbv/ZFZCmutfXmSr00yN0Mxq0m+4VpOn9J7vzhLTgAAAAAAAAAAAAAAwN3DBhzuJhtJHk/yZJLNJPcneXWubm45zEck+bettY/uvb/nVg54bfPN1w/e0pP8WpInkmzl6q8GvTrJqRu8/w1JfqC19vG997VbyQkAAAAAAAAAAAAAALi7zPKLHzCr/STfl+TPJfmwJKd776/svX9k7/3jeu8fnOS+JB+X5J/doIxXJvn+1trSzR68tfYRSb7uBuFfT/Jnkryg9/6q3vtH9d4/vvf+oddy+qgk33mDz35Yrv4aDgAAAAAAAAAAAAAA8F7ABpznt0eSfHeSr0zypiSvv0PHfWeSr0jyst777+29/83e+8/23g+uf2Pvfaf3/kO9989M8vuTHParMq9J8qW3kMf/kaQd8vq/TPK63vs39d6fOSSn/d77j/XePyfJZyXZOaSMP9la+5BbyAkAAAAAAAAAAAAAALjLLBx3AtwxjyT5lSQ/c+2/t/feLzz3Da21h29zDu9K8leTvK33vnezH+69//PW2mck+f4k1//izVe21v5W7/3KlLJaa6/J4RuOfj7JH+y9b07M6Z+21v6HJN98XWguyecneceUcgAAAAAAAAAAAAAAgLuXX8B5nui9v673/gd673+19/5912++uQP+dZL3673//VvZfPPf9N7/XZK/dkjoZK7+is9Un36D179y6uab53hbkv94yOufdpPlAAAAAAAAAAAAAAAAdyEbcLgjeu9P9d53j6i4b0xycMjrn3ITZbz6kNeuJPm+m02m996T/JNDQi9vrbWbLQ8AAAAAAAAAAAAAALi7LBx3AnCzeu8XWms/m+T114Xe9yaKeeEhr/1q733nFtP6r4e8tpDkgSRP3mKZx2Jn77C9Tb9p96AP449e2hrGD4rPJ8kTV8an4aDXZYw8vVGf5q39cT387HsuDeOLc+O9Vxu7+8P4hQk5VnX5ZFGP23vjHC5tzb5nbrtoT7/2zMYwvj/hVG8V3+O/PLVeFzIwpb2t74x/2GunaE/PFnVdncsk2S/y3NwZ19Op5fGU4MnL22UOz26Ov8fq4vwwXtXT+ta4npcW6n3F1fd8qvieT084F5VqnK3ilf0J42xlvhjDTq2M67E6V1NUxziK73m7nTuxVL7nSjF+XN4ex1cWxv2qGsurc50kjxX9ohrrq2veUbhU1NNWkeNDp5bLY1wsxrj1YpxdnB9/fveg7vvV9eZykcOVnWKcLcpP6vNZXbur62oVr9pbUp+r+aLZV/W4MuF6szg3fk9VxNL8uB42dut6WD25Oi6jbA/j+JR/aeDUufcZv+Fg3Oa2V84N40uLJ8ocDhZXhvGqLqv2cmWrHuP2imvWicXFYfy+Mw8N4ztFPa2t1327+qcjdorOXc5FJ7TZanyZK5LsZ8Zj+U7RppP6freKV9OT6vNJPY72heJ7FgUUw8vV9xSD1P7B+FxV8/rt/fHn5yf8c0E7++P2UPW7xaJzT5lqVueqqIZsF2+YMt/dLcqo+k01R+rz9Xw2Rf/f3RvH+/x4DGwLE3KYG8+JU7TZtKLRFeUv3Hc++5efHZdRKeYOVY69+g5JqhZVtbm56hgTcqguOL2o64MU53LKOFvcA9V9u2jTE8aP6i29qKfqilZdl5Okz43vuVsxT6uO0YoU5qt+mwk5zs82jk5Zd6zqumpy1TVtecK9RaU6F8UwXF4zk/o+bLX4HtX1ZrNKMslj69Xa5HiOVN1zr01Yy3qmuNec9bnFYtFgqut6kpxfHfebqozqfndKPc2dOz+M7+yO6+npjfG5rtpTUp+LtWIdqfqeU/puVZfV96hyWJuw7jjrc6jq/qVaf5lyrqq1qCqH/RPjueSUNluNo/NFv6nuLbaX6j/H2JrxnvvpjfG5mDJ+7BY5VP2qWk/b26+fOVbPb6q6rtbSp9yTV9e8xy6P+001vlT3cPX1rl6rqp4pPlkcY8rzneq5QhVfK9rsFNUc5vGl8XxzyrORyoWiLmd93jc3IccnihyqOXH1bOQHfm3cnv7r45eH8SlWZzxXT12q+031DHnWc3W2uB4l9bmonuUfxXPRqq6rHH78nc8M41P6VfWe6lzciefgU/7mYJbyq2fgU3L4yUfH56r6+5OlCQuw1d88VaaMYQAA9zK/gMO96pFDXhv/VdJvddhMf5a/0r/Rbozb/xenAMA9qdp8A8C9b8ofNAJwb5t58w0Ad71q8w0AAAAAAM8fNuBwrzrsacfN/LMUTxzy2v23mEuSvOCQ17aTXJyhTAAAAAAAAAAAAAAA4C5gAw73qocPee2xm/j8Tx3y2qtaa+duLZ18xCGv/XTvfbbfqgUAAAAAAAAAAAAAAI7dwnEnADertXZfkg89JPQrN1HMv0jyt/Jb+8B8ki+49vrN5HMyyWcfEvqumykHAAAAAAAAAAAAgNtv/6AfdwoA3IP8Ag73os9LsnjI6987tYDe+7uTfPshob/UWnvFTebzDUledN1rjyf55pssBwAAAAAAAAAAAAAAuAvZgMM9pbV2IsmXHxK6lOQHb7K4L03y7uteuz/JD7bWfteEXFZba9+U5M9cFzpI8oW99/WbzAcAAAAAAAAAAAAAALgLLRx3AnCTvjrJSw95/X/vvW/fTEG992daa5+U5IeSPPic0MNJfqy19j1JviPJTyV5Isl2knNJPiDJxyf5k0lefF2x+7m6+Wbyr/EchdbaRx5VWW/54V8+qqIAAAAAAAAAAAAAAOC9gg043DNaax+bq79ac73HknzDrZTZe/8vrbUPSfIPkrzpOaH5JL//2n9T/WKSP9F7/7FbyWVGx3FMAAAAAAAAAAAAAAB4Xpg77gRgitba+yT5xzm8zf7p3vvlWy279/6e3vvvTfIx145x6SY+vpfke5J8TpLXHNPmGwAAAAAAAAAAAAAA4DayAYe7XmvtZK5ucnnwkPD/2Xv/50d0qINc3XyzcROfWUjyyiSvTfLCI8oDAAAAAAAAAAAAAAC4i9iAw12ttbaY5LuSfMgh4bcn+ZIjOMYHtNZ+OMm/T/Knkjx0k0V8UJL/Ock7W2tf11pbmjUnAAAAAAAAAAAAAADg7rFw3AnAjbTW5pJ8W5Lfe0j4V5J8Wu99e8ZjfHaStyVZPST8q0n+ZZKfTPJUkq0k53P1F28+5lpez+1Dy0n+YpJPaK19cu/9mVlyu0lvPMKyfuwIywIAAAAAAAAAAAAAgHueDTjclVprLck/SPI5h4QfSfIJvffHZzzGZyT5R0nmrwtdSPJnk3xX7/3gBh//xtbay5K8NclnXxd7fZIfaK397t775iw5TtV7//GjKuut/+5XjqooAAAAAAAAAAAAAAB4rzB33AnADfydJG8+5PX3JPn43vuvz1J4a+3FSb4lv33zzbuSfGjv/TsGm2+SJL33R3rvn5PkLx0S/tAk3zBLjgAAAAAAAAAAAAAAwN3BBhzuOq21v5nkvz8k9GSubr45ip9o+eok5657bS/Jp/Xef+NmCuq9/5Uk33lI6M+01l5+a+kBAAAAAAAAAAAAAAB3i4XjTgCeq7X2jUm++JDQhVzdfPOLR3CMs0k+/5DQ23rvP3+LxX55kj+Q39qn5pJ8UZIvu8UyAQAAAAAAAAAAADhi+wf9uFMA4B7kF3C4a7TW3pLkzx8SupjkE2fYHHO9j06yesjr336rBfbe35Xkxw4JfeKtlgkAAAAAAAAAAAAAANwd/AIOd4XW2tfm8F+KWUvySb33nzvCw33oIa8d5PANNDfj3+fq5p7nem1rbb73vj9j2XfM6tL8MP7Y5a1hfH6uzZzDxYsbM31+Z+9gGH/mCHauP5OdYbyqh2r3/JTd9bPWdXWMpYV6j2ZV19Uxqs9P+Y7VMWY9F0dhu/ieleUJ56I6RvU9T6+MpwSXt/bKHCpVmyrby/74Oy7N1/V0ohjjnt3cHcZXF8efn6LsN322NnkU48d8G8er73AU7WXW8WXvCPr2wm0eZ9ePoJ6q6/azG+M2PeU7Vu2+6ptH8T0rF4u+e2p5PMY9dWV8XU+SJ4r3PLm+PYxXfXtrr741q77nM1WOV8Y5buzWU9YLxTFOFdeTWa+7+xM+vr03/h5VGVd2xm12Y7c+V5eLMk4vV9eTcb/amVAR1XuqeDW3WF6ox4++sDx+w/742r1b5LhYlZ/Z66EaJ6vrzZTrevWevrB023OozmZZxsG4hIMJOewW32P3YNwmD4pvMWX8qMaoXp2rMl7nUA6TxcmqjtFTJ9GLg1R3N8XUYOb41RzG36Mqoqrn6lxeLWO28121tyn9pmrXVRllPRT3BUnSiveU36IV93FVPEmfG1+bq29RfT5z4+v2/Nn7c3D54jiH+XEZvfieZY4TzLp+UtVD73Xnrb5HPQ6Pyy8uR9fKmK1fVP1uyny3ek95XT6CcbTqW9W5qr5m1Zym1NNc0eZyUHyHovxp56qIF+2p+nw1351iqZiXV0eo5mBX3zPbWlY1X52yhrNbVGaVY1XXVT2cXl7IhY167WA2s60hJ8nW3rhfLM5V8XH5U9pL1ayrMraKe9HtCYNc1b+r9lStK0yZp+0Vx6jWYKpjHMWzuEq1LlCtlU15LrK2PV7rqtbC9g8O+/cWf9PifF1P6zvjc1HlUD2/ObVUz+NOFJ2vqsuynibdxQG6uAAAIABJREFUi87Wb7aK+MqE5zdVGY+tjZ9RV/Ep69RV36rO1fLCeP6yWfT9JyesU1ftuqqHp9fHx6iezST1s7aqHi9vH8GzkRmf11XXiktb436VzF6XT50af36laE9JslmMYVUOjxTx6vNVe0vq57evfcnZYbxq848+s1nmsFHUU/Wc/Omibx5Fm67qerN45rA0ob1UzxTvW10cxs+fGq9TrxXPJJPk0Yv1+RrZKeZpU8awUyvj71n9TcOsz7CnqJ5r3ndi/B2qNj/l70+qeqj+HqC6Vrz/C0+XOQAA3M38Ag7HrrX2NUm+4pDQpVzdfPP2Iz7kA4e8drH3Xt8Njj1xyGtzSc7NWC4AAAAAcBeqNt8AcO+7/ZtvAAAAAAC4V9iAw7FqrX1Vkq86JHQ5yZt67z91Gw572D8VMOvmm1EZ+hkAAAAAAAAAAAAAANzDbAzg2LTWviLJ1xwSWk/yKb33H79Nh75wyGv3t9Zm/b32w35Zpyd5esZyAQAAAAAAAAAAAACAY2QDDseitfYXknztIaGNJL+v9/6jt/HwTx7y2mKS181Y7ocf8tozvff9GcsFAAAAAAAAAAAAAACOkQ043HGttS9J8tZDQhtJPrX3/iO3OYWfucHrn3mrBbbW7kvysYeEfupWywQAAAAAAAAAAAAAAO4ONuBwR7XW/nSSv3FIaDPJp/fef+gOpPETSZ495PUvbq2dv8Uy/2KSU4e8/q9vsTwAAAAAAAAAAAAAAOAuYQMOd0xr7Y8n+duHhLaSfEbv/QfvRB699/0k33VI6FyS72qtLd5Mea21T0/yZYeEdpL805vPEAAAAAAAAAAAAAAAuJssHHcCPD+01j47yd9L0g4Jf32Sy621NxzBod7Re9+e8L6vSfIFSVaue/3jkvxIa+1ze+/vHBXQWptP8ueSfF0O38z2Tb3335iQCwAAAAAAAAAAAAAAcBezAed5orX2cJLhhpKBH2rtsH0zv8XLe+/vGsQ/JTf+xaWvvvbfUXh5klEeSZLe+6Ottb+U5C2HhN+Q5Jdaa9+Z5HuS/FSSp3L1l3rOJXl1kv8uyZ+4drzDvDPJ/3qTuQMAAAAAAAAAAAAAAHchG3B43uq9v7W19tIk/+Mh4YUkn3vtv5v1VJJP7r0/PUt+AAAAAAAAAAAAABy9/YN+3CkAcA+60S+SwPPFlyT58iTbR1TeTyX53b33Xz6i8gAAAAAAAAAAAAAAgGNmAw7Pa/2qtyR5fZJ/lmT/Fov69SRfmuSNvfdfOqr8AAAAAAAAAAAAAACA47dw3AlwxzyW5CNvc/k31Ht/c5I338bjz6T3/vNJPrO19pIkn5vkjUk+PMmLb/CRnST/KclPJvlXSf5V7/3gTuQKAAAAAAAAAAAAAADcWTbgPE/03reT/MRx53G3670/muQt/+1/t9ZOJTmX5L4kS0kuJXk2ycXe+96xJAkAAAAAAAAAAAAAANxRNuDAQO99Pcl6kt847lwAAAAAAAAAAAAAAIDjMXfcCQAAAAAAAAAAAAAAAMDdzAYcAAAAAAAAAAAAAAAAGFg47gSAu8v+QR/GVxbmh/GDPv78zv5BmcP8XBvGqxyrz1fxozjG6tK4nqrylxbq/ZFnlxfL94zsHozPxXyr6+npjZ1h/PFnt24qp+tNqYfNnf1hvDoXO3vjeqg+n9TtYX1rb6ZjTGmzs7b7M8vjKcFy0feTZHF+fIyN3fG52t0f94tLW7vDeNWvkuTUyvh7nt0a96tZ+35St9mnLm3PlMPTV8b9MqnbfXWMjeI7TBnrK89ujs93ZUp7WJovxphiDKrqcbuIr2+Px4Yk2dypxo9xm64+vzShb1djcVXXU85Fpeq7s46zcxOuedX5rNrDQVEPexP6zVrRL9Y2injR5qpxOkmeWR+PMdW5qFT1eGalnv9cLOYn1TGq7zBlflK1qROL4zZZxdcm1POJxeq6PG6TzxTtbUq/ObjvzDDeDqo2WfWL+lzsFH1vs2gPC8U1cavou1MuiS3jN/XlE8N4VU2ThuHiPVeKa//i3PhcXC6uR0myNuNc70pREdW5vprDOM/Nk+MxaKeYz1bxpL7e7K4sDeNbe7ONw1NUdVldT6p4ta6QJPNz47nB4oR7qJHNvTqH6nzOWg9TVO2lml9U9VSVnyTLC8vD+EEf9+2DjHM4kn896mC2up47cXoY71cuzVxG2x/33ba7MT7A/HhsSJITfTxH6sW5bLub4wMU/TJJeivOaNH1ymvahGveetEvqrlDdW3fnXDhrS4H1fzjcnFdfra4pibJlZOrw3hxac/a1jiHaqo4Zd1xZWF83V1YHLf7y0WOU8b66nxWl6xqrL9Q3Lsk9by7Wo87uzy+t7i8XY/1F4p7zSrH6nxPqYeLxf3JYrHGs1t03qpfzbVW5jCr4lRmbspzjaJNrhT3s+vFvL2qpyRZ2x73zVn7xfaEm6xqDaZaH3mmWF+dsi5QvadaI67uNau19KRuU9X5rNbjZ332ktRrWVU9VusnC9X6b+rvealoL1WOU87Vxm7RXop+s19ckKbkcKVcRx7nWD3XOHtitmeaSb1mVz23mLIeXzl/ajzGVfVUtfkp/aby2Nr42ex60eYvT1h3rJ4hLRf1sFeM0/edqO9vZn0uUeU4ZZ27KqPywlPje7CzxbPbJDm3Ou5brzw3XldcWqjuyYu10QlttppfvPj0uB6uFGPgR73svjKHl50Zt6nH18f9orp3+LnH6nWBSnXNOl1cd6fMVd99aTw+nCraXNXe3rdob0ny0H0rw3h1ba+uaVWOU1Rzg4986blh/Pzq+Dv8+tr4mpnUf7vxn564PIxX40d1/5QkD54c95ufL3J45zPjtay17dt7fwUAcLv5BRwAAAAAAACAQ9zuzTcAAAAAANw7bMABAAAAAAAAAAAAAACAARtwAAAAAAAAAAAAAAAAYGDhuBMAAAAAAAAAAAAAALhT9g8OjjsFAO5BfgEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgAEbcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABmzAAQAAAAAAAAAAAAAAgIGF404AAAAAAAAAAAAAAOBO2T/ox50CAPcgv4ADAAAAAAAAAAAAAAAAAzbgAAAAAAAAAAAAAAAAwMDCcScA3F2+6P3Gw8LllRcM489s7Q/jfcKvNu7sj9/0yNrmML6xO87h7MpimcPy/Hh/4oWNnWF8s8jhqeLzJxbnh/Ekee0LTw3ju0U9Pnppaxh/usgxSXb2DobxZzd3h/HqZzxXd+p6WNsc57m6OW7T83NtGD+9N/ulcruopyqH973/xMzHqNpk1eZOLdf1UPW9y9t7w/j61jhe1dNRmDWH1aW6zc76Pap+c//JpbKMp6+M+03Vt5eKMXLKd6y+R5VDZWdv3B6TZGdu/D1W+/h8zprj+tZ4jEySpYXZ63pkSj1t7IzfU53LKn7+VN1mTxdj0GaRYxVfK8anpB7jqmNcLK6JW/t1e6rGqEr1Haq5Q1K3yWocXNsY18NTl7aH8Sk/AV7VU9Wmq2tm9R2SZL7N1jcXi75d5TjF+s64nh5bH5+L3Qnn4qVnxvPV1sb9/4nierW6WP+bIntFnmtFe1mcH5+LlaJPTLE4N+43B4srw/jO5rg9HMUUqporLi+MD7KxW9fTBz4wbi8PnBhfC872jWH89InVMoed/XGbXC2+54miTZ5druthuWhTc3vjvrmyMK6nKcNTdUVaLXI8vTxuL1V7KqaaSZIPPFO8oRdjdRsf5PzCuD0lyc6pc8P4I5fGn3/l+fF93oMn63uwav1kfWd8Nqs2fRT3YC85VbTJg/G56vP1Gs7claeH8YVnHy0KKNYNzt4/jB9sXB6Xn6StnhyXsXp2GO8L42vBJAvL42MU/SKL43F0d66e1+/sjdtsdd3dLubME6YnWSqOUZVRzdunrH1WY/Gzxfpq9fnl+Xptokqzuh4tFedyuajnCbceqUagXlT2QpHDqQlj3JXd8fmu5ppVPVbxKRaLtY3qWrF7UN+LVmvllSvF/ct6cY+WJJeL9+wWa927Rd+tckySZ9br9fJZHMV199TK+JpW3dNX7elKcR95tYzZxvIninvRKetx1dpBtW7wbHHfP+VcVf27vFctctg8VbfZKs/qGJeLejoxYS28MmtdV226iid1PVTtpTrG5on6XFVlVO2+ik9ZT6vWNqtzUT1zqMqfcozqmWNdTxOeGRRlVO2lOpfV56uxIUkWinqqzvep4jl51feT5HRxvamOsTbhGXRltVhbuL947jBrm0+mjTEj1bPd3cW6PVRlrG2P29z5ueKeu/iK1RpzUq8jbxbf4ULRb6r1uCQ5VbSXjd1xjtXfhkxZK9+qznexPrJe/N3EwYQcXnX/eG3i/Oq4PcwVN6Nni7EhSV5TrAFXfwu0WNybvHDCM8f3X74yjO+tvnAYnyvuqBff+ZPD+PmX/s5hPEku7I3P9+tfPF4cfdniuB578cwhSQ6KNbn3Ozeu6yt754fxC5uzPfMEADhufgEHAAAAAAAA4BC3e/MNAAAAAAD3DhtwAAAAAAAAAAAAAAAAYMAGHAAAAAAAAAAAAAAAABiwAQcAAAAAAAAAAAAAAAAGbMABAAAAAAAAAAAAAACAARtwAAAAAAAAAAAAAAAAYGDhuBOA1tr9SR5O8tIkDyU5mWQ1yWaStSQXk/xCkl/qvR/cgXweSvKaa/ncdy2fy9fyeDLJ23vvT9/uPAAAAAAAAAAAAAAAgLuDDTjPY621VyT5sOv+O3fIWz+29/7DR3TMB5O8MclHJfmdSV6b5IUTP77eWvvRJN+a5Lt779tHlNPrknxcko+9ltf9Ez7zK0n+vyR/p/f+S0eRBwAAAAAAAAAAAAAAcHeyAed5orX28iSvT73Z5nbm8PFJ/s0MRZxK8qZr/z3VWvuy3vu33mIuH57kD1377+FbKOJVSf5cki9prX1Pki/qvb/7VnIBAAAAAAAAAAAA4M7ZP+jHnQIA9yAbcJ4/3pHk7DHnsHiEZT2Q5G2ttc9N8lm99/Wb/PyPJ5k/gjxakk9P8jGttT/Ve//OIygTAAAAAAAAAAAAAAC4i9iAw93k8SRPJLmUZDfJmSQvvvbfjXxSkh9orb2p9752hLkcXMvnySTPJDmd5CVJXnSD959N8v+01hZ67//oCPMAAAAAAAAAAAAAAACOmQ04HJcnk/xIkn+fq79G84u998uHvbG19kCSz0jyRUk+5JC3vCHJ30zy5hlz+qUk/++1nP5D7/3SIbm88tpx/myS+64LzyX5v1trj/bef2TGXAAAAAAAAAAAAAAAgLuEDTjPb48k+Zkkb7/2fy9c+/9vl6eTvDXJP0vyE733gykf6r0/leTvt9a+OcmXJvmGJO26t/3R1trbeu8/fJM5bSf5h0m+pff+oxNy+dUkX9Va+7tJviPJR133lvkk39Ra+529972bzAUAAAAAAAAAAAAAALgL2YDz/PFIkl/J1Y02P5Pk7b33C899Q2vt4duZQO/9p5P89AyfP0jy1tZakrzlkLd8YZIfnljcVpK3Jfm63vu7byGXd7fW3pTkh5K8/rrwa5J8XpJvvdlyAQAAAAAAAAAAAACAu48NOM8TvffXHXcOR+ivJfljST7wutc/vbU233vfn1DG+9/Kxpvn6r2vt9benOQ/5uov3zzXH4wNOAAAAAAAAAAAAAAA8F5h7rgTgJt1bYPNdx4SOp3kRRPLmGnzzXPK+YUk33tI6BNba4tHcQwAAAAAAAAAAAAAAOB4+QUc7lW/cIPXX5Tk0TuZSJLvT/Lp1722nOSFx5DLzP7ds6vD+Nbe5WF8ca4N4ycWr/+xoN9ue/9gGN/v488/eHJ5GJ+fsPXwifWdYXxzd/xDS7sH4ySXiiS29w5ybnW8h2tta28Yv7Ax/g6/9szGMP7Upe1hPEme3dwdxh97dnMY36/qaaE+WetFPcxqdalus1WeJ4oy7jsxPtePXhzXY5LMF32vim8UbXptu67ntaI9rG2M4xs74xxOr4ynLVPOVZXDY2tbw3hVj1Ny2Nkbj3HbRbzKYYrNnfH5fLLo/6eKczFFVQ9VvDKlnqrzVZVRjWH18RfybDFWXy7GuKWFcXyz6FdTxtmlhXGOlVPL4/ZS5ZjU42DVZqtx+MxKvW/6iUvj8eHpK+N6mlLXlapf7M3YJs9O6NuLD5wcxl9wYmkYn2vF9aroui87O56rJslSUch+H9dTNY+r5rtJct/KuM2dXS7Gn+31Yfxg8UyZw9z2eN6+uXR2GH9msxh/JkyqTxV9rzoXJ5fGxyiaU5Jkpeh7u/vjHJcWxgc5tVjXw8niPatFfOHS48P4i4r4Q/PjfpkkmSvO1dnxv3XRdsb3Fq84Odv4lCTt8ngcbpcvDONzZx4sj/HyMw+Nj7Hz7LiAufE4erA0HkOTZG7r0vgNB+O+eXrl3DA+67UiSYquW44P+3PjAqb0q4sHRb8q+n51vdnsdb9ZuzI+F1U9VTmu79Tz4ep8XinmWft9nMPcZj1PO12M1ZWVhfE8bOHKuG8nyfyVp4fxvjMePyp7T4/H2ba0koPLF8c57BZz6lbUYxWfoN+BY1Q298ZtdrtY9NvcHcertY0k2T0Y962N3XF8q5iTT5krXl06vrFqXeBMMdc8tVyfyxPFWDu3N77HWp4f993FYqCdm3A9qtaAd4o3LM24VpbU14uL2+M2d1BdDCaYLya9U9bbh+VPqIfqGKeXZlsnqu4Trx5jnMNycV29sDHuV9Wa4fxcm3kdqLqnr8o/ijXBai1sf2Gcw5S1+EvFOvJu8fznKNYMz58cz+Vmrevzp+q54qznq8rx/GqdQzUGVWtV1Xeo1oinrIVV37N6ZnAU/YJpymdQUxZpClV7uN3xpL7HqsqY9fnPlByr1frq+U9lY8JYP2vfq557TKmHWcfy6ll/da6m5FAd43JxrqbMkap7oPVqHC2OUc3rL094vlNd+6t7k+oebIrq70+qeqy+55R70ao9zDpXnOJE9T2LNb1qbjHl/qeat1d1vVLMV6u1sCTpp8drtNUzol58z8UT9w3j+wsrw3iSbBR/d7FZtZfT42dI1dpHkuzuFc+Yi3H24tb4849frp8/v3+9pA8AcGz8Ag73qrUbvD773ffNe+QGr4//cgcGqs03ANz7qs03ANz7qs03ANz7qs03ANz7juIPHgEAAAAAeO/gL0G4V91on/tjdzSLq270Tw8cx2YgAAAAAAAAAAAAAADgiNmAw73q9xzy2rt67++545kkD9/g9ePYDAQAAAAAAAAAAAAAAByxheNOAG5Wa+2FST7nkNC33+lcrvm4Q167nOTJO50IAAAAAAAAAAAAAGN7B/24UwDgHuQXcLintNZWknxbkrPXhS4k+VvHkM8LknzqIaHv673v3+l8AAAAAAAAAAAAAACAo2cDDveM1tobkvyHJJ94XWgvyZt770/d+azyF5OsHvL6d9/pRAAAAAAAAAAAAAAAgNtj4bgTgNbaS5K85LqX55KcSvJgktcl+aQkH3zIxy8n+SO99++9rUkeorX2wUm++JDQu5L8kzucy0ceVVk/8EtPHlVRAAAAAAAAAAAAAADwXsEGHO4GX5jkL9/kZw5ydZPLl/fe33XkGRVaayeSfHuSxUPCX9Z7373DKf3YHT4eAAAAAAAAAAAAAAA8b9iAw72mJ/mWJH/lODbePMf/leR3HPL6d/fe7+iv3wAAAAAAAAAAAAAAALfX3HEnADepJfnjSf5ta+0vtNZO3/EEWvvKJJ93SOjdSf7UHU4HAAAAAAAAAAAAAAC4zWzA4V718iRvTfJfWmufcKcO2lr7giR/5ZDQTpI/2Hu/cKdyAQAAAAAAAAAAAAAA7oyF404Aeu9fneSrn/taa20xyX1JHkry+iSflOQzkyxf9/GXJPm+1tof7b3/w9uZZ2vtM5J8c67+Cs9zHST5gt77T9zO4xfeeIRl/dgRlgUAAAAAAAAAAAAAAPc8G3C4K/Xed5M8de2//5zkW1prDyT560k+77q3zyf51tbaO3vvt2XzSGvtk5N8Z357n+lJ/mTv/Ttvx3Gn6r3/+FGV9W9++amjKgoAAAAAAAAAAAAAAN4rzB13AjBV7/2p3vvnJ/mfDgnPJ3lba+3IN5W11j4uyXcnWTok/Gd779981McEAAAAAAAAAAAAAADuHjbgcM/pvf+NJH/3kNCrk3zWUR6rtfZ7kvyLJKuHhP987/2bjvJ4AAAAAAAAAAAAAADA3efIfy0E7pCvTPJHkpy47vU/nOQ7juIArbU3JvmXSU4eEv6K3vtfP4rjAAAAAAAAAAAAAHDn7B/0404BgHuQX8DhntR7fybJDxwS+t1HUX5r7Q1Jvi/JqUPCf7n3/vVHcRwAAAAAAAAAAAAAAODu5xdwuJe9PclnXPfa/a21E733jVsttLX24bm6+eb0IeG/2nv/mlst+17w/b/45DB+eXtvpvLnWyvfs7N/MIyvb+0O46tL46Ftys71y8UxKjt7xXfYGJe/tDRfHuPBM8vD+LPFMZ5d2xrGN9d3yhy2N8ftYW93fxjvxbloc3V7OSjqekoZIwuL9blYXB6/58Tp8bl6uqjr1QntYXlhvKd2u6inE8Ux5ufqPbs7e+PzXeVQ9Zv5Gc9lUtfThUvbM5W/uVOPkdUYtLEzrseqHk6vLJY5/P/s3XmUZVld4PvvvjfmjJyzsqqoogZKpUFQGlAEccABQZ+IYD9WqwioD0RaBZXn3CBKq4iCLoVWoIRWfPKw5WlLN1JMgshM4UCrKNRIDTlVRmbMEff+3h8RaBF1Y/9OxL0ZNyPz+1krFsXZ9+zzu+fs6exzd56zi/U4sxiza5WlA6w2+ExNN4nx6IGJNI9+y9ShPWPV9Nmkz7z8wGR6jGNnkrY6KS/TE/U+8ei+Bucp6bs70d+/CNOkXx5L6m7WJ2bn4chUXm/aSXF5zDWHqulX76+f6y75eciuxWhSpsdH6uljDerEaHIiRrMsol73o1Xvj5Y7+XnK+puSnMf5lfr+/ZZ5gNJNxkjtepks3by/aS2eraZPtOtt2MGJepmdWjmTxjBy5+3V9GjV6+Z1Uweq6a25U2kMMd7rhab/5sp9h5MMkv4quRZlMR9btE8cr6av3vGZavpKp16eynje1sdSvb8ZuSy/3lWr+b0FI/UyGUsL9UOcvKuaPtpgPNsdq5eX1ko9hrTujtT7q7UP1eOMkfr1XE361QbNKFnXnPXdWXcSUf9Aq8G8QdbnZTFk48DJBjOmnahfq4l2cr+bfM8mQ9VsfDI9Wo8xOw/7k3tdgPZKfQou67PKXL2/as/W20iA1btvraZ3kvaBpF+ev/2ONIazt9Xn046uJvNASf6je+tjzW7S3wHEaHL/kY1xkj5xrEEbd2Ryf/0DybWY3l8/xtxKXmYXkrFe1kwm05Y0aMLSupuN+5Ppl0bj1c+erZfJVtIfrSR1u0X/95FjyYnKzlO71I8xmbSRACNJO3kk6TDGpuv7X3sgrzf9/iusU0l/RMk7vbnp+hhnT3KvuZqEMJneSMJtM/Vx9WJyH7iSnMd2ycfM2Tgqq9tZDJmjyTwUwJGp/DM12XmcbTD3OZXMp2fn4bK99WuxkjXEwELyXOLUXP/z8f2aaNfboFZSL7J5boBu0taOJ/dg2T3Uwcl625CN2aH/ua5rDk5V05uMqe86W29fZpI53uz+ZaLBtcr6xaV2Mh8/Uk8/3uC5x+mF/p6LnpqtH2N/g/Ypuz/Jng9n+zfpU7O+P5unztKzZzPZM3KAyQbPLav7J8/Rxxu0gf0+I8qeawzCbHItsud5TZ5zZWUqO0ZWN5en8hhmkt8DZOaTPjNrh+9p0HZkfX+Wnh0jG3usfaZeHu5M+oJjydjhpuNzaQzZ899s/DI93v9vYGaSZ2n7Gzwrq9nT4FqMj9Q/c+s99XmmrJ29ZyG/x7p8+mA1fW6lXuay29nrjn5hNT27Hwf4p5P185CNyyeT8zSXlDfI7w2yMc7tSRv32eQZOMDXXHck/YwkSdKw+AYc7WabPYGv3y1VlFIeDrwd6PU0+Fci4me3m7ckSZIkSZKkC0u2+EaStPs1WcQsSZIkSZIkSbo4uABHu9lm/7Rjg39a975KKQ8DbgB6/TPLvxYRP7mdfCVJkiRJkiRJkiRJkiRJkiRJ0u7mAhztZlf22LYCnNpqRqWUhwLvAA71SH5lRPz4VvOUJEmSJEmSJEmSJEmSJEmSJEkXBhfgaDf7ph7bPhURna1kUkp5MGuLbw73SP6tiHjBdoKTJEmSJEmSJEmSJEmSJEmSJEkXBhfgaFcqpTwWeHCPpPdsMZ8HAu8EjvZIfnVE/NDWo5MkSZIkSZIkSZIkSZIkSZIkSRcSF+Bo1ymlTAOv2iT5D7eQz3XAu4DLeiT/DvC8rUcnSZIkSZIkSZIkSZIkSZIkSZIuNC7A0Y4opfxAKeX5pZTJPvM5DLwNeGiP5L+MiL9umM/VrC2+uV+P5NcCz42I2HagkiRJkiRJkiRJkiRJkiRJkiTpgjEy7AB00bgMeBHwk6WUNwJ/DHyw6SKXUsoB4OnAi4FDPT6ySMM31pRSjrK2+OaqHskfAq4HHlVKaZJdze0RcXu/mUiSJEmSJEmSJEmSJEmSJEmSpOFyAc5FopRyDXDTNnd/d4PFKNdGxM0N8roU+NH1v7tLKR8HPgF8Cji9/rcK7AMOAg8GHg48DhjfJM8AnhURn2xwfNbzfMAmaY8CGr1Fp4GfZ23BkCRJkiRJkiRJkiRJkiRJkiRJ2sVcgKNhuhR44vrfds2xtvjmzYMJSZIkSZIkSZIkSZIkSZIkSReyTjeGHYIkaRcDPq6yAAAgAElEQVRqDTsAqQ9/Dnyxi28kSZIkSZIkSZIkSZIkSZIkSdK55BtwtFNeB8yw9rabrwbGt5nPPPAW4PqIeNeAYpMkSZIkSZIkSZIkSZIkSZIkSdqUC3AuHncCjz7H+W8qIm4DXgG8opQyDjwMeBTwEOBa4BrgILAHGAXOAmdYW7TzaeDj63/vjYiz/QQaEe8BSj95SJIkSZIkSZIkSZIkSZIkSZKki4cLcC4SEbEEfHDYccC/xvKh9T9JkiRJkiRJkiRJkiRJkiRJkqTzWmvYAUiSJEmSJEmSJEmSJEmSJEmSJEnnMxfgSJIkSZIkSZIkSZIkSZIkSZIkSRUuwJEkSZIkSZIkSZIkSZIkSZIkSZIqRoYdgKTzy7GzS9X0heXVvvIfG+l/3d/p+ZVq+tnF/mIEmE/y6Hajmh5RT19aqOe/stSppgPcmcSwOFc/T3NnFqvpC7PLaQxLC/VjrMzNVNNbo2P19JF6ehOj4/U8xsbrXeHk3jyG8YnRavqll0xV07/0/geq6e1WSWM4Mj1eTd871q6mTyfn4chU/TsCtEo9zvmVerkebdXbh9F2Pf92cnyA8aQNunWmXi9um1mopu9PziPA8fl63eokdXsmaQOz/QEecMmeavryareaPpmUp6sO1ss85NdzvJ2Vh3r6Vfsn0hgmk/IwlsTYSdr6xdV6evIVADiZ9XlJf7F3PKn7Y3mZvSdp67O6n8XQqRc3ID9XWfuxmJTpiQbjk5VuPY99yfccS9ryLnkbNpGUyZJci+VO0j40KJNZWxvZ1yj187SwUj/PC0m9gnwcBvX0rG43KbN969brdlmt91cAZWmumt5q1ev/1Fi9v2rP3JXGkGrXy0NroT6W7J64PT1EGav3B+3kPJVucl9w5lQ1vTNzspoOsHr6WDV9+WQ9j9WF+j3cyGR9nAgwum9fNb2M189ja6I+tiBppwHKnnoeZbIeY/vwFdX0lX2XpzHMlfr3HJtKxqNJW5+2w8DoWP16LSeNUDYUHGlwb5F9JOt3s/5oIRtrjjQY1yd9YjY+GYQm17NmMv0OeR5pt5v120mfl5U3gMl2cq+YtKMlkmOUBgOUVr0/iaV6v7l8z+lq+sLxevrZW49X0wFGJupzC4dG6udx5OiV1fT24cvSGFpJn0gyNuhO7K2mR2syjSGSY2RlOmvjVhvUy+wT6dxCK7nPa9D+ZG1xUK8X+RHyT4wlN1lZ+5Dds2f3cE3a0Cbnsib7Dtk9P+RzLIvJ9xhEb5SdqfQYSTtaOvkc8HTW9y+craaPL9fn064cycerl19xpB5Ddg+V9Eeddh5Ddq+YldlsbmI5KW9N6kRWrrN6kZXp7J59LYb+2oes528yBMvq7sMur99bZPNxM0v5M6il1XqZXElinE2OsZDMtUM+F35kqj4+yea6p0brY7DsO0L+PbI8smu9fzJ/rjG6v36eHtDnc4nsPAFMj9VjyNKzeehbkuceAHcnzwTPJGXy2Gx9bqLJc65Mk2cfNdlzD4CF5XqZPDRdrzdZvbp8X31M/sk7zlTTIT+XVx+uz69cdiCZK2twrWYX6+3koT31fnWywXOJTPabg6N76zGcnu//NwtTybOy1W69PFyWPMdq0n7sS9rqo8nz4ybPNWuyMg/5HM2ByXoMZ5P2p8l5unRPvT+4LKnbN59OflfRoF/O2qA7k2Nk5a3Jb2SydnRipH6MueS3QtmzW4Cp0aTPm6iXhyzGrE40iaGbPmOqay3Wn2tMjtTHopDHuNKpp48n86udyK9VVnezY5zr8yxJkjRsvgFHkiRJkiRJkiRJknrIFt9IkiRJkiRJki4eLsCRJEmSJEmSJEmSJEmSJEmSJEmSKvp/t6skSZIkSZIkSZIkSZIkSZIk7RKdrm+9lSRtnW/AkSRJkiRJkiRJkiRJkiRJkiRJkipcgCNJkiRJkiRJkiRJkiRJkiRJkiRVuABHkiRJkiRJkiRJkiRJkiRJkiRJqnABjiRJkiRJkiRJkiRJkiRJkiRJklThAhxJkiRJkiRJkiRJkiRJkiRJkiSpwgU4kiRJkiRJkiRJkiRJkiRJkiRJUoULcCRJkiRJkiRJkiRJkiRJkiRJkqQKF+BIkiRJkiRJkiRJkiRJkiRJkiRJFS7AkSRJkiRJkiRJkiRJkiRJkiRJkipcgCNJkiRJkiRJkiRJkiRJkiRJkiRVuABHkiRJkiRJkiRJkiRJkiRJkiRJqhgZdgCSJEmSJEmSJEmSJEmSJEmStFM63Rh2CJKkXcg34EiSJEmSJEmSJEmSJEmSJEmSJEkVLsCRJEmSJEmSJEmSJEmSJEmSJEmSKkaGHYCk88sDLtlTTV9e7faVfmh6LI1hZn6lmj451l/TNTnaTj+zsNKppy+vVtOPnVmqppdSquljY3mMVx+pX6tP33W2mj4yNlWPYTw/z7OnF6vpi60D1fSJqXp5GGlwHpaX6tdiJLneE3tG+9q/SR5TyfdYWK6XtyYmk2OMtutlrrNYP4+tpMwCrHTq9X8pSc90B/Da1/GR+trjE0n7c2puuZreiTzGrI3LXm+blZelpB0GaLfq1zNry7MYl1ablOl6mW2V+jHarXp6gyLbt514E/FKJznXSb2a6uZtWKZJua7J2o+VyMvsymo9hk7yzwrMJv12N/LzdDbJI6tXK0k73OQ0L63W88jKfXYtlzt5xVlIrsVY8j3z/JO+JDk+QLvPf2ZibiUb7+YxdEnasFIfZ02OTFbTR0bG0xgo9RMRIxNJev0YZWkuD2G1PlakXR8LRvId2ofvl8ZA0sZEq17/06vdqsdYRuvjRIAyVr8WowfqY2o4nR4j1e1vPFrG69+hjOTnIbveaUOZlacG9aZTb+pZSvrldjI4WE72B+gk/UmWRdbW51cC+h1GRRJDdimTZhjIr0VJam9ymhuN87IxcZbF6gAGk1m/m12LbG5iJDtRAKv1+5uyPF/fv1O/x4qF+twGQMydqaavzs4mIdS/w8pcvT9bXUgaD6CbjCVjuX6MWFqop6/UzyM0aIuzdjjTyueR0mFUMkZaShqI2QYNyGKDe+aa+WTOsMn8yWgyfljq9HeMdoMYJkb7u96jSfuQhdBoXN/njX02Jh+Efu+Pug1uBLN7zew8ZUeYbDBGyi5FK7m3KNkgK6kTTawm/95gpyRjxQbzllm/mZ3trO9fTcY3DW7Z02Nk97vzWTub9GcA4+3+5qmzubAm9SZrq08t1Pv+M8kzh2Oz9ec/ALPJfHvmbLJ/Ns8NMJZ8Jnum0O93mG/w3GM2OddZG3h4T71uX3ag3j4BTCQTSeMj9fOUlckm1+rgRPKMKXlOlc2F3T2bjxVnk+uVzY32+/wY8nusfutFVicgrxdZv5u1P1kb1yTG7DwdO5u3UTUz83l5yep3FuPJpExm1wHyZ6/TyXPurP1ZbvCc65aT9TzmkzKbPXPMvgPk7eTVR+q/B7hyf30eem9yni/fm48ls3J/Ormnvm2mfj98cDKf7To0WT+XCyv1GLPvcKpBO5tdq1Nz9bq73Kl/z2Nnkrn4BjHsn6of4zPH6s8EFg7k9ebSpMxkz8Gz5+xNHlGlz6GyecfsGAP4p9CzacPRPh+ENXmWl33PbAw1kfRp033+7kuSJGnYfAOOJEmSJEmSJEmSJPWQL76RJEmSJEmSJF0sXIAjSZIkSZIkSZIkSZIkSZIkSZIkVbgAR5IkSZIkSZIkSZIkSZIkSZIkSapwAY4kSZIkSZIkSZIkSZIkSZIkSZJU4QIcSZIkSZIkSZIkSZIkSZIkSZIkqcIFOJIkSZIkSZIkSZIkSZIkSZIkSVLFyLADkEoph4FrgPsDlwF7gElgAZgB7gE+CXwqIrpDivEy4CHAA4D9wDgwD5wGbgL+OSJuH0ZskiRJkiRJkiRJkiRJkiRJkiTp3HIBzkWslPIA4BEb/g72+OjjIuI9AzrmUeAxwFcCDwMeClzacPfZUspfAW8A3hIRS4OIaTOllGuB7wWeCjyowefvBj4IvB14a0Tcci7jkyRJkiRJkiRJkiRJkiRJkiRJO8MFOBeJ9cUkjyRfbHMuY/h64B19ZDENPGH973gp5YUR8YaBBHcv64uEfpG1xTftLex6KfBt63//N2tv9ZEkSZIkSZIkSZIkSZIkSdJ5pNONYYcgSdqFXIBz8bgR2D/kGEYHmNclwOtLKd8JPDUiZgeRaSnlCay9YefoIPKTJEmSJEmSJEmSJEmSJEmSJEm7nwtwdD65C7gbOAOsAPuA+63/bebxwA2llCdExEw/By+lPBt4FZu/9aZzrxhPA3uBw6y96abVz7ElSZIkSZIkSZIkSZIkSZIkSdL5ywU4GpZjwHuB9wEfAP4xIs72+mAp5RLg24AfBP59j498BfAbwDO3G0wp5enAfwVKj+S3AX8IvDUiTvXYdw/wMOCbgG9d/29JkiRJkiRJkiRJkiRJkiRJknSBcAHOxe1W4GPAR9f/98T6f58rJ4FfBf4/4IMR0W2yU0QcB15bSrke+DHgV7jvQplnlFJeHxHv2WpQpZRHAa/rkedNwPMi4n8l8c0B71//+8+llH8PfPtW45AkSZIkSZIkSZIkSZIkSZIkSecnF+BcPG4F/oW1hTYfAz4aESfu/YFSyjXnMoCI+AjwkT727wK/WkoBeFmPj3w/8J6t5Ln+9pr/BxjdkPSPwOMi4q5txHkjcONW95MkSZIkSZIkSZIkSZIkSZIkSecnF+BcJCLiS4YdwwD9OvAs4EEbtj+plNKOiM4W8voZ4NoN246xzcU3kiRJkiRJkiRJkiRJkiRJkiTpwtMadgDSVq0vsPl/eyTtBS5vmk8p5XLgR3sk/ZiLbyRJkiRJkiRJkiRJkiRJkiRJ0uf4BhztVp/cZPvlwO0N8/hhYHzDtg9FxB9sO6oLwFs/cGs1fXS83myMjNXX9Y2MttMYVpZWq+nLS/WXHLVaJT1GZjmJIbpRTV9a6G9/gNHx+rmaPbNUTZ8/W0/PLM6vpJ9ZOLtQTe8s1dNHRg/U9+900xhWV+rlobtaz6M9Ui8vq8v5S7WyMndypF4vxkbq17rdoEx3kjK1nJyHzMxSg/KQnKssPZN9xyayc3nnzGI1/diZevreidE0htPzy+lnarJr2eRaNylTNZNj9TK71CCGvRP1/mQsqTdZDE3Ky96kT5sarcew0qkfYz5pnwBapX4tjs3Vy8vscr2/yWKYXc5vB2aSPnG83d+a/pUB1O3xdn/XIrsOkF/v5dV6eov6MTqRn4d2n0OclW69bq628mu53K2fy9FO8j2T5mGuQb0ZxPWsmVmsl/mlBuOTI516f5CVh4VkfDLWoDBMj++vpi8nZXp1uf499+85nMZQVuv9ZrTH0jz6VaL+PaKd9N1Jmc9qTXvfEVg4U/1MGamfhzKX7N+u94nRadAfTe6pp0/tTfOoxrBcLwsAZWTj7fkG3XrdJDkPZTW/PxptTdRDSJrqkrQ/yfAGyMdp2b1kg+4klWWRtUD5eUj61E6XPck4bKTP8Wy/fSrARHJBs2NMJt+xSYgjJG1cgzmYagxJGwhQOvXxalmpzwu0lpN5hbmzaQydmZPV9MWTM9X01cX6d+iu1O+H9119iNOfqcewulhvg1bOzlfTy8jxajpJXwIQi/VjZNqHk/KWtePAaIPP1EyP1fdPhjdAPo7K2vqx5P6nSfPUTtrJ5U7SBvZXtQdiNPmiWTs9OZKPRzNZn5f1R03G1JnsziA/Rh5DVl6S7iQdW7Q7DeaQk/6gLCftS7Z/g/6mtVIfT6ZjyURyS09EpO1DJJdzJSkwC0kQyw3uRTPZ/XQ2BzSzmM8RZ1V7KhmfdJPKvdhg3jGbLzubfM9Ts/WxQTaHDPk8ciabS8/mRiGv/+PJePZ08owom79tEkM2l50dYxDPDC7ZV28/RpO+fyWpm9l5HoTRZE4vu3eBZvNdNVmZPZnMczfJYyGp21l5yZ7FQV6m+n22srxa/453nKrfHwF0kxi7ybU8ub8+93FPgzZuca7ePmTPd2dP14+xtJD3N5nxyfqc3+JcMm/ZYHzSXenved/Ne+rzbdnvMiD/7UX2e4PpA/XykJ1HgKNJO7p/qn6/mvUFs8n4o0m9vPLgVDX9suQ8zCR94i0n59IYsu95LKkX7aSNa/L7kyyGu2bqbdCJ5Pcpn7ztdBpD9j32T+VlruaDn87r7u+/76ZqetbOJo8c0nqXtdOQt7MlKffZb66a/G6rlVyr8cl6G5U9Y8r2B3j6w69MPyNJkjQsvgFHu9VmT84bzQ6WUtrA9/ZIet22I5IGKLsplyTtfv0uEpAuRk0WtknnlWTxjaT7yhbfSOebbPGNpPvqd/GNtNMG8Bt/6aLT70IFSdL5L1t8I0mSJEkXKp9oa7c6usn2Oxvu/3U98lgG/njbEUmSJEmSJEmSJEmSJEmSJEmSpAuSC3C0W31Vj203R8QdDfd/Yo9tH4mIe/qISZIkSZIkSZIkSZIkSZIkSZIkXYBGhh2AtFWllEuBp/VI+oMtZPO1Pbb9beWY+4ErgXHgHuB4RMxu4XiSJEmSJEmSJEmSJEmSJEk6D0Q3hh2CJGkXcgGOdpVSygTw+8D+DUkngN9smMco8JAeSX+z4XP/DngO8K3AdT3yOQG8E7gB+KOImGtyfEmSJEmSJEmSJEmSJEmSJEmStLu4AEe7RinlK4DfBh6+IWkVeGZEHG+Y1RcBoz2237x+nEPArwHPAEolnyOsvYnnacAvlVJ+GfitiFhuGIckSZIkSZIkSZIkSZIkSZIkacBKKftZ+935FwEHgDZwBrgJ+EREfHaI4TVWSmkB1wIPBi5l7buMAaeBe4DbgI9FxMLQgryIuABHQ1dKuRK4csPmFjANHAW+BHg88KU9dj8LfE9EvHULh7xqk+1nSykPBt4KXLOF/AAuYW3RzlNKKU+JiGNb3L8vpZRHDyqvL//5tw8qK0mSJEmSJEmSJEmSJEmSJEnaEaWUAjwF+EHgq6mslyil/B3wOuB1ETG7MxHmSimjwGOAxwFfBzwCmEp2Wy2l/A3wJuD6iDg5gDi+Fnh3v/n08LiIeM85yHdHuABH54PvB160xX26wB8DPxERN29x38s32X4J8CesrQzcrq8EPlxKeWxE3N5HPlv11zt4LEmSJEmSJEmSJEmSJEmSJEk6b6y/iOH3gC9vuMtDgVcCLyylPDci/sc5Cy6xvujmG4H/ADyZtbfcbMUIawt1HgG8pJTy28DPRsTiQAMVrWEHIG1RANcD10XE07ax+Abg4Cbbf5v7Lr55B/As4AtYeyPPPuCBwLOBv9okn6uBN683hJIkSZIkSZIkSZIkSZIkSZKkc6SU8s3Ah2i++ObergD+tJTyc4ONakseBbwVeCZbX3yz0QTwY8AnSilf0mde2sAFONptCvC9wLtKKT9eStm7jTzGN9l+xb3++wzwpIj4xoh4fUR8OiLmIuJsRHwqIl4TEV8FfBfQa2XgVwA/v43YJEmSJEmSJEmSJEmSJEmSJEkNlFIeB/wJay9b6OUu4H3Au4FPb5YNa2+O+cnBRzgwS8AtwEeAdwE3svab9808EHhnKeWLdyC2i8bIsAOQtula4FeBHymlPCsi3rGFfbNyPw88LiI+nmUUEX9YSrkDuKFHvj9USnl5RJzaQmySJEmSJEmSJEmSJEmSJEmSpEQp5X7Am+j9goa3AS+KiA9v2Oca1t4Q84Pc94UmLy2lfDwi3j74aLflfay9Gee9wEcjYuXeiaWUNvAI4HmsvViivWH/I8A7SilfPKDftN/I2nnrx/8eQBxD4wIcDV1EvBh48b23lVJGWXt91mXAI4HHA9/OfRvHK4G3lVKeERFvbHjIlST9hU0W33xORLynlPIS4CUbkqaB/9Rj+7nwmAHm9dcDzEuSJEmSJEmSJEmSJEmSJEmSzoXfBC7psf3n13+jfh8RcTNrL1p4G/Df+fzfp7eA3y2lPCgiFgYca1PHgNcCvxcR/1L7YER0gA8DHy6l/C5ri5Gu2PCxy4BfAp4zgNjORMQHB5DPruUCHJ2X1lfnHV//+zvg90oplwCvYG113r21gTeUUm6KiCaLR5YrabcA/3UbIb8ceD5waMP2J7MDC3Ai4gODyutRL7lhUFlJkiRJkiRJkiRJkiRJkiRJ0sCVUh4LPLVH0vWbLb65t4h4aynl2cAbNiRdDbwA+C99B7k1x4GXAa+KiPmt7hwR7y+lfCPwfuDghuTvL6X8SkR8ZgBxXtQ2vjJJOm9FxPGI+G7WGrSN2sDrSylNFpWdrqRdHxHdbcS2APx+j6QvLaXs32p+kiRJkiRJkiRJkiRJkiRJkqRN/WSPbcfo/VvzniLivwF/0SPpR0opE9sNbBv+Hrg2Il6+ncU3nxMR/wD8VI+kFvDt281X/8YFONp1IuKV9H5LzRfSexXjRicqae/dVlCb79sCvryPPCVJkiRJkiRJkiRJkiRJkiRJ60opVwJP7JH06xFxZovZvbjHtqPAk7ca13ZFxOmImBtQdq8FTvXY/s0Dyv+i1uRtIdL56GeA7wGmNmz/j8Cbkn0/W0n7RB8xbbbv0T7ylCRJkiRJkiRJkiRJkiRJ0gB1uzHsECT152nc92Ukq8D1W80oIj5YSvl74CEbkr4T+KPthTc8EdEppbwL+I4NSVcPI54LjW/A0a4UEaeAG3okPbbB7p/ZZHsHmNl2UHByk+2H+8hTkiRJkiRJkiRJkiRJkiRJkvRver395n0RcXyb+f1xj21fV0oZ22Z+w3Zrj22X7XgUFyDfgKPd7KPAt23YdriUMhUR85vtFBGnSinHuO+baRYjop8lzZu99mu6jzx33JVX7qumT421z3kMnWRl+en5lWp6u1Wq6cur3TSGdmuimj6ZnIcmx6gZG8nXRx7dV48xiyE7RrvUzyPAzMJyXzGsJtc6KwsAM7NJDIur9WNkMa500hhWl+ufuefUQjV95vRiNb00uBYHD9bLw+Hp8Wp6Vm+mx/sfMownZW56on6MJuUhk+WRlfusDczOYxNZvVlIynSjrmy0v7Z8NolhZqHeTkP+Pfcm5SE9T9N53c10uvXzNNpO6s1Y/TscnhpNYzgyVb9/W+rUv+fepO5OtPP+Zi5pBztJlzc2Uj9PZ5fq5QlgJilz80mM9yRlMksHOD5f72+ycz3aqp/rpdW8zHaS6p0USRaTi3VoIi+TI0mZmUralzTGpG4vZQUOGG9QrmvOJGUyixHyMpl9jb3j9fM41uA7Lqxk47A0i6rxPfWxBcD4eL1MRau//qh06vUSgJX6OCtayRgnSY+JvfX9R/Pz1B7f+GLXDSHsr/+bDt29B6rpZaw+TgRo7T1UTV/dl8zBtZPzGHmBi9H6ecjy6I7V9z+1kLezM/P1+p8N9bKxZKfBOC0b+mfdRZf+xrtNZOdhbjlry/sbv0A+hun3PDQZUmdjpFZ2bzFa/w5Nbi0mk3usbmQx1vMfaRDE3on99Q906vWqdJP0kXx80q/OYr0/WZmr9yV7Lt3D8U/Wn+NMHZmtps8fu6ea3hqt14vW3s2mJf9NjNf7g1bSX0S7fm8SSTsMsNyq55Hdsy8m8y+zSfsDcDqbJ0oagGycl437AbKh3HwyjhtN6mZ2rwr5eDQzkbQ/2RxQdh6bWElukLLzvNrtv33J7g2alIdM1nVn3zPr8yZH8n53NBkTj03U248m/Ukmqxcri/3NQy9nN9w0G8vVZOXl7FK9XjS5H+43hjOL9fmRU0l6E9m8QdY+NHn2cip5ZjCf9CfZ3Oadp+vz/QBzc/UYsn9heTUp83MN5gU6fZaZ+TNLfe2fPTeB/mMcTe4dxicb3Fsk86/79tfv67PnhdmzGYArD05W0w9N12PM5vRaDdrh7P7laDIPdHnyPZf6nYgin5fcm1yL0Qb1JmsnZ5frY8lsfHLX2fq9RbvB2OFs0hYvJHUvfXabtD+Q191I2rjxyWTOsMHzwJKU64k99WOMJP1Rln8TI8l9/1jShrUa/F6gnZTr7Dl3FkN2LbI+FWBptV7uTyf9dlbexhvMI2Vxnm7wjKimyfjkUNJOXn14TzX9qiP1e+4mz3f2JZ85lPSbWV/RZN4xu189mDwfHk+eOTa5A1tM2uql1f7G/dl9Q5PhT3Yqp8eSup/U3SY/u8i+R3Z7dHyuXq9OJM9dJUlqYn1RzFf2SHpnH9m+E3jxhm17gEcB7+sj32Hp1Sn3f5Mu34CjXW2zJ9sHG+z70R7bpkop/fwCbLNfHJzqI09JkiRJkiRJ56ls8Y0kaffrd/GNJEmSJEmSpIF7CNDrXwf6UB95fhzotYL7EX3kOUzX9Nh2504HcSFyAY52s83+CYgmy+Tf32NbAS7Zfjj3eaPO55zoI09JkiRJkiRJkiRJkiRJkiRJ0pov2WT73283w4iYB/6lR9KXbjfPYSmltICv7ZHU6/v1c5x9pZTrSikPL6V8USnlSCklf1XlLucCHO1mV/bYtkKzN878xSbbH7n9cPiyTbbf3EeekiRJkiRJkiRJkiRJkiRJkqQ11/XYNhsRd/WZ76d7bHtAn3kOwxOBS3tsf+sA8r66lPLGUsotwAxri3o+BvwTcBxYKqX8TSnlVaWU/7OUMjaAY55XXICj3eybemz7VET0ev3XRh8HPtNj++P7iKfXvjPAjX3kKUmSJEmSJEmSJEmSJEmSJElac02PbXcMIN/PNjzWeauUUoAX9UjqAH82gENcA3wncNUm6S3W3lD0XOBNwC2llJ8rpewfwLHPCxf8K350YSqlPBZ4cI+k9zTZPyKilPJ64CUbkr6nlPJTETG3xXiOAt/RK56GC4IkSZIkSZIkSZIkSZIkSZIk7WKllEcPKq+I+MCg8rrAXNJj290DyLfXG3R6Het89lzgy3ps/6OIuH2ngwEuY+33+t9XSvmuiHj/EGIYKBfgaNcppUwDr9ok+Q+3kNWrgZ8Epu61bT/wUuD5Wwzr14HxHttfs8V8JJeRONgAACAASURBVEmSJEmSJEmSJEmSJEmSJO1Ofz3AvMoA87qQHOqxbWYA+Z7psW2ylDIZEQsDyP+cKqU8CHhZj6R54Kd3OJyNrgb+spTyvIj4nSHH0pfWsAPQxaGU8gOllOeXUib7zOcw8DbgoT2S/zIiGndaEXECeEWPpB8upTx9CzH9CPBdPZI+EhFvbZqPJEmSJEmSJEmSJEmSJEmSJKlquse22QHkO7fJ9j0DyPucKqXsBf6E3rH+dETc2uchZoC3AC8AHg9cAxwERtf/9zrgycDLgTs2yaMNvKqU8pQ+YxkqF+Bop1zG2mKXm0opv1ZKeXQppfGqzFLKgVLKDwGfAr6yx0cWgedtI66XAv+y8XDAG0opv1hKmeqxz+di2ldK+Q3glT2SV1hrYCRJkiRJkiRJkiRJkiRJkiRJgzHaY9vqAPJd2WT72ADyPmdKKW3gTcC/65H8NuA3t5n1CmuLbr4FOBwRT4mIV0bEDRFxS0ScjojV9f/9TET8aUS8kLXFOd9H77cStYA3llK+aJsxDd3IsAPQziilXAPctM3d391grcy1EXFzg7wuBX50/e/uUsrHgU+wtrDm9PrfKrCPtdVwDwYeDjwOGN8kzwCeFRGfbHD8z98xYqGU8h2sve7t3ottCvAzwPeXUv4E+CvgrvXtlwNfA3w7cHiTrF8QEe/fajySJEmSJEmSJEmSJEmSJEk6tyJi2CFI541SypXAbcOOY90bIuKZyWfaPbZ1BnDszfI439dcvBp4Yo/tNwPfFdts8NZ/C7/l38NHxApwfSnlHawtAHrQho9MAL8M7Mo34ZzvhUEXtktZq+y9KnxTc6wtvnnzdjOIiL8ppTwZ+FNgckPypcBz1/+a+sWI+O3txiNJkiRJkiRJkiRJkiRJkiRpV3rMsAO4CPR6280g1kVslsdmb8YZulLKy4D/q0fSCeCJEXFqh0P6VxFxaynlm4APsfYCjHv79lLKl0XER4YQWl9cgKPd7M+B/xQRt/SbUUTcUEr5auDNrL32ajvmge+NiDf1G48kSZIkSZIkSZIkSZIkSZKk3SUiPjDsGC4CSz22jQ0g383y6HW8oSulvBh4YY+k08DjI+Ifdzai+4qI20opPwH8tx7JTwV23QKc1rAD0EXjdcCPAjfQXyM0D7wR+PqI+NZBLL75nIj4KPAQ4BdZa3iaWgR+E/gCF99IkiRJkiRJkiRJkiRJkiRJ0jlztse2vQPId7M8eh1vqEopPwW8qEfSWeAJEXHjDodU8wfATT22f/NOBzIIvgHn4nEn8OhznP+mIuI24BXAK0op48DDgEextuDlWtbeOnMQ2AOMslb5zwAzwKeBj6//vTcizlkjFhFzwM+VUn4JeBLwjeuxXg3sY+2VZSeA48CNrC0oumGYr+eSJEmSJEmSJEmSJEmSJEmSpG2aY+0FCeeDv27wmZM9th0YwLF75XEmIlYGkPfAlFJ+FPgvPZLmgG+OiA/tcEhVERGllP8JPG9D0kNLKRMRsTiMuLbLBTgXiYhYAj447DjgX2P50PrfeSki5oE/Wv+TJEmSJEmSJEmSJEmSJEmSpAtORNwDfPew49iCu3psu2wA+fbKo9exhqaU8sPAr/VIWgC+NSL+aodDaupjm2w/Cty6k4H0qzXsACRJkiRJkiRJkiRJkiRJkiRJkhq4qce2K0op7T7zvarhsYailPKDwG/0SFoCnhwR797hkLbi2Cbbj+5oFAPgAhxJkiRJkiRJkiRJkiRJkiRJkrQb/HOPbaPANX3m+4UNj7XjSinPAX6rR9Iy8JSIePsOhzQoY8MOYKtcgCNJkiRJkiRJkiRJkiRJkiRJknaDGzfZ/qXbzbCUcgS4skfSJ7ab56CUUr4PeDVQNiStAP8hIv7nzke1ZZu96ebMjkYxACPDDkDS+eWrH3hJX/u3Wxvb9s+3f3y0r/wBZpZW+s4j0+lGNf3KfRPV9NF2fX1jq9TPU7ueDMDByfq5XOnUv8Pe8fqb9kZb+RrNTtSP0U6+Z5f6/kn2AIwlJyuLYSW51qtJehPZtZhdXq2mn5hfTo8xPlK/nt3kZP7T8dlq+sJyJ41hebVbTT89X6+7t5ycq6afnK2fh5Wl+nkE6CbXc/b0YjV9eaF+jJGx/A2WSwv9tWGRfIeStMMA40n7MZq0D9kxPpOUBYDJifowdDI5l+Mj9TZqLEkHOLSnvng+a6unRusxTo3WYxht0NjPr9Tr3lJyrrP2Z3osvx3I2qj8e9TP09mlvH05kbQfWYzHzy6lx8jcfs9CX/tnY4tjZ+rtTxPZOCxrp/cm9RLyujU90d9YL4txIbnWAJNJuc7O00zS78436BMPT49X0688OFlNn06uRZM27kCfY8Wsat9/f/07QD7ezGLIHJmaSj8z1t5TTc9KfVZeJvccqqYnXcFaHtTbuLJ4tprentxX33+1QRsY9brXnjtZ3z+5dygr/bfDdOv1P0brZfKSfZemhzi4/0A1Pbv/WVytp8+v5GOk7BirSb05nYxXs/sCyO+Rsj7tnsWk307G7dm9DcB0MlbMvkPWxjWJIRt/ZOOsQ5P19CbjtOx2Nbs1mE4aqf3d+n0iwMgdN1fTV26r/4NgS3ffWk0/e8sdaQxnbrqznn77TDV9/sR8NX3uWD19psFYM7uPW12sl6el0/VrsW8uH6tOXZWMNy+5oprcbtXrRbTzf5xsLmkHj8/Xz8PZpP04lbSBAHedrZ+HM8kxsvFqlg75+CKbg8n2bzJWzGR5ZPfs2f1yk3HgRBZDcoxLk3v+5JYfgH3J9zw6VW+r95RknLdcnwsDaC3VP1Pm8zzqGeQnIsbq4+5o1+89olU/TzG5P42hlPq1WFit15vZpF7d2aAtP5vkkY2zsjHQYqfefpxK5kabyMZxWfvT5H44M5XUq0EcYyGZT8vPQ/1aZe0wwEjSRmXaI/XyUBrU3ZHorz9oJd8ziyEa3Htk8/X9xjAylp+D8fFzO0+dlTfIn31kdfPUWH3/bJ4J4PBUf//QbDaXvpS00430OVfeRNaWLybHWOzze159OJ/rysabWTu6nPQ3s9N5WUiPkcSY1Yv5Bs/ROskxusl4M2t/BmEkuefO+op2g3F91kZlc/7ZfP5Y8puHBxytz70CXH2gPmd3+d76XPrRZFx/cKLBPFIyLm+fPVZNz+ZnWcrHkp2TN1fTW9P1ecksPcby+fru2HQ9j/H69Vwdr89Dn2kwjsvmR5eTunsimTdoInuumd2vLnXq3zP7nU3WlwAcnqrXzax1yOb8mvSY2bXI0i/ZU/8Oh5JnWJIkNfRp4CRweMP2xwB/ss08H73J9g9tM7+BKKU8A/hd7rv4ZhV4WkT82c5HtS2P2GR7/YHhecg34EiSJEmSJEmSJElSD9niG0mSJEmSJEk7K9b+9Y939kj6pj6y7bXvXRHx933k2ZdSyncB13PfNR+rwH+MiLfsfFRbV9b+JZVv6ZH0mYjYdW/AcQGOJEmSJEmSJEmSJEmSJEmSJEnaLf5Hj20PKaU8eKsZlVJGgO9oeIwdUUp5GvAG7rveowN8d0T88c5HtW1PB67psb3XIqrzXv6+YUmSJEmSJEmSJEmSJEmSJEm6QEQ3hh2CpP68BZgD9mzY/sPAD2wxr+8ALu2x/Q+2EVffSilPWT92e0NSB/ieiHjTzke1PaWU+wO/vEnyUM5vv3wDjiRJkiRJkiRJkiRJkiRJkiRJ2hUiYg54fY+k7y2lfFHTfEop48Av9Ej624h47xbyeWYpJXr8PbNpHuv5PAn4I+77opUu8MyI+MOt5LddpZSnlVLG+szjKuAvgMt7JH9gK+f3fOICHEmSJEmSJEmSJEmSJEmSJEmStJv8KrC0Ydso8MZSymTDPF4BfEGP7b/YT2DbUUp5AvBm1r7DvXWBZ0XETr4x5neAm0opP11K6XV+NlVKGS2lPAv4G+BBPT6yCjxvADEOxcaVUZIkSZIkSZIkSZIkSZIkSZIkSeetiLillPIrwH/ekPRI4M9LKU+LiBO99i2ljAAvB57bI/kvI+LNg422rpTyWOAtQK+3zrwG+FQp5SsGcKj/HRFnGn72fsBLgZeWUv4eeBfwt8DfAXcBM8AsMA0cAh4KPBb4TuCKSr4/EhE3bi/84XMBjiRJkiRJkiRJkiRJkiRJkiRJ2m1eCjwB+PIN278O+MdSyiuBPwP+mbU3r9wf+Abg+fR+O8s9wDPOWbSb+wZgYpO056z/DcLjgPdsY7+HrP/1owu8MCJe1Wc+Q+UCHEmSJEmSJEmSJEmSJEmSJEmStKtExHIp5SnA+4BrNyQfBn5h/a+JBeCpEXHLAEPUmn8GnhERHxh2IP1qDTsASZIkSZIkSZIkSZIkSZIkSZKkrYqIzwJfA9zYRzbHgSdGxLsHE9Wu917WFiT165+BHwcediEsvgHfgCNJkiRJkiRJkiRJkiRJkiRJknapiLitlPIY4GeBHwMmmu4KvBl4QUTcca7i220i4kmllDHgUet/DwMeClwN7K/sOgN8BPgw8E7g3RER5zjcHeUCHEmSJEmSJEmSJEmSJEmSJEmStGtFxCLws6WU3wCeBTwJeCQwvuGjXeAfgP8FXB8R/zCAY78eeH0f+78YeHG/cQxSRCwD71v/+1ellGngKLCHtYVOC8BpYCYizu50nDvNBTiSJEmSJEmSJEmSJEmSJEmSJGnXi4jjwMuAl5VS2sD9gQNAGzgD3La+WEfbEBGzwOyw4xgWF+BIkiRJkiRJkiRJkiRJkiRJkqQLSkR0gJuHHYcuHK1hByBJkiRJkiRJkiRJkiRJkiRJkiSdz3wDjiRJkiRJkiRJkiRJkiRJkqSLRrcbww5BkrQL+QYcSZIkSZIkSZIkSZIkSZIkSZIkqcIFOJIkSZIkSZIkSZIkSZIkSZIkSVLFyLADkHR+WV7tVtPbrdJX/u0Gu0+P15umo3vGqun7J+r770vyBxhNvuf0WH39Ykm+Zzv7QANjycmcX0muZRJCp8EbNpeTD2XpC6v19Nnl1TSGUwv1z2R5zK90+kqHvN5k6ZlOg9ed9ls37zy9WE1faHAeMsfO1I8xM7tcTV9erF/LToPzHMm5XE3qzWpyHrJ0yF9f2x6pty9jk6PV9FaDsjAxVc9jbLLeTo6MtqvpVx+dTmPYn3yPqbH6MbIyP530BQCdyNqwenlYXK1f7+Nz9fxPzK9U0wHOLNY/s7Bcj2EyOY9Znwtw/OxS+pmarA27c6beNgDcfmq+mj6/UD9Pi3P5uc4sJcfI6m5Jyuxy0p+t5ZGkJ+OLrI0bG6+XF4DRpMxM7KnX7SzGblLvOsnYASCSup2ZT8p8k/yPT9XHq7ftG6+mjyTlKavbAEf3TVTTs/p/eLr+HY5O178DwKFWvTzsHU/6vGTAerBBmR1PzmXWbWbj9nanXl7KykL9AEBrYSbJo95OlqXZ5AD5eYqRennpjtf79hibrB+g22A83E76pE7STib7x9ieNISs759bqdf/pWT/hWR/gC71zywmbXk3aaOy8Q/k9WI0qVfXHZyqpu9J2rD9Dep2dk8+XurnqZXVzaTeAZRIynWnnkdrpT6+KQt5+xGn63nESv0eKxbr+3fnzqQxLJ68q5q+cPfxavr8Xaeq6bOfre8PcPbOejs4e0c9ff5E/Vzfk8wrzCT1EmDPbWer6d1k/mRppt7fLJ2u5w+wJznXk0dvqaZPXXFTNX3ksqvSGI5eckU1/cjUgWp6d9/BanpcsjeNYa5b/0w2V5XNty00mJuYSeY3ZpbO7VwXwOnk/mYmuV89fqZeJleT+8B+58qayMaz9zuQjF+Ag9ncRTI/ciSZf9k7ls+fTI7Wy+z4RL1PbCf3kdk8OMBI8pksj/ZqvU+M7GYX2DOa3CON1GPoTNXHilftq5cXyOfLs3vFbP9s/mQQ8/VzSfuQzVWdmK+PLQBmkzYsiyFrX441mKc6OVv/TNYGLSXzbcvJdwRYWarnkc1TD0I2F5XpJPc32XfYie/YSu5NVlfy9mV1OZkDTvrMVtLQZnOGkM9lZ3Mbk2P1/ZvMIx1P+rxMNl8/n9SrQcjO004YS2LI5vOXGoyRsud1aX8ygHFav8fI0tvZAIZ8npmkSA/imWMmm4/PNJmHnu3zGXVWN7N6lZV5yK93Nv7IxtRHkrn4Jp/ZO355NX3PdP1edrzBj2BGr6iPTzpJme5069cqnacCaPKZipHl+vzKoQZ5HGrX617pJPNh2eVu8jucrG5l3WZyjBipB9md2J8cACKZ08++wmJS97O5D4CZZDx7d/LbjpnkGXc29wHwxZfvSz8jSZI0LMOfhZAkSZIkSZIkSZKk81CTxS+SJEmSJEmSpIuDC3AkSZIkSZIkSZIkSZIkSZIkSZKkChfgSJIkSZIkSZIkSZIkSZIkSZIkSRUuwJEkSZIkSZIkSZIkSZIkSZIkSZIqXIAjSZIkSZIkSZIkSZIkSZIkSZIkVbgAR5IkSZIkSZIkSZIkSZIkSZIkSaoYGXYA0vmqlDIFPBx4IHAIGANmgVuAv42IzwwxPEmSJEmSJEmSJEmSJEmSJEmStENcgHMRK6U8AHjEhr+DPT76uIh4zw6G9nlKKb8A/OwmyX8ZEV874ON9A/BDwOOBicrnPg28AXh1RJwYZAySJEmSJEmSJEmSJEmSJEmSJOn84QKci0Qp5VrgkeSLbc4rpZSHAj+xQ8e6EngN8ISGu1wHvAR4QSnlhRHxunMWnCRJkiRJkiRJkiRJkiRJkgYiusOOQJK0G7kA5+JxI7B/2EFsRSmlDbwOGN2BYz0S+HPg0m3sfhB4bSnly4HnRjgskyRJkiRJkiRJkiRJkiRJkiTpQuICHJ3Png982bk+SCnli4G3s/kbgU4B/wAsAZcDDwRaPT73bCCAHzgHYUqSJEmSJEmSJEmSJEmSJEmSpCHptYhAGrpSygOAl2zYPPA3y5RSpoH/Tu/FNx8GvgE4EhGPjYivj4gHA1esx7bUY5/nlFK+f9BxSpIkSZIkSZIkSZIkSZIkSZKk4XEBzsXtVuAtwM8ATwAeOdxwPs9rgKl7/f+/BT5wDo7zYtbeaLPR64CvjIh3RkTcOyEi7oqIFwFfBdzTY99fL6VcNvBIJUmSJEmSJEmSJEmSJEmSJEnSUIwMOwDtmFuBfwE+tv730Yg4ce8PlFKu2fmw7quU8n3A191rUxd4NvArAz7OtcAP90i6AXh2RFTfuBMRHymlPBV4B5+/mG0va2/IefagYpUkSZIkSZIkSZIkSZIkSZIkScPjApyLRER8ybBjaKKUcjnw8g2bXxURHyqlDPpwPwaMbti2SIPFN58TEe8upbwGeM6GpGeUUl4UEXcOIE5JkiRJkiRJkiRJkiRJkiRJkjRErfwj0o76LeDAvf7/Z4GfGfRBSikTwNN7JL0+Im7eYnYvBVY3bBsDnrGN0CRJkiRJkiRJkiRJkiRJkiRJ0nnGN+DovFFKeSrwlA2bfygizpyDw30LsK/H9t/dakYRcVsp5W3A/7Eh6Tvh/2fvzoMt287CsH/rTHfo29Ob0EMykh5DORBByRKDsAMG2QiSQIhJISrlkFAYFApkoHAg5FGxxGAhGyRMIQggGaXsMg5QQJmyy8QQJFKRzOASYGKjGNBDA0/Tez3c23c408of/Sj6Xd1e3359zj3n9uvfr6r/uHvtvfa3pzXts3rH999BbGv1M2/742b6YNhP0tvz+s6f30hjeOjCZjN9Z6NddN2/M2qmP/LAuTSGC8k+PuHiVjN9KzkPvQ4fdBokK20N2vuYzutC+UdE1NrOY5LsYzxrpx9N2x+bmiTb38xj1kzfn7TTrx5MmukfuX6UxrA/bu9j7+j4HL1jMeyP29sftrfv4iiJYe/qYTP9YLcdY0TEPLlfDnYPmunj3Seb6ZPDvTSG2VF7H/Np+zgmhzea6XXWvtZd1Hk7j96wXYZt7Fxupg+2dtIYNnbua6aPzp1vpvf67fJn90r7OkRE7Fxql/XbW8c/Uvd0WVk/S8qniIiL2+19bI3adV4mq0si8jrt4mY7vZd8IXA7qbcjIjaT+uQ5O3nd3TJM7pcrSTkcEfHkwWLl5BN77e271Invv7LfTM/qgoMkff9GXs5m5km9OU1i6KImz9bRQftanLuw2P3U60f0kut1Pnm270/u6ey5vJTkH5GXL+dG7X2cT8qfrQ7P9n1JOZqVL+eSfVzcyP8/j+2kTdxPrmXJ6sxxu96OiCg32s9umSVl0Lx9T5ekbdFlHzVp49SD9nHO9nfTGFKD9v3SG7Xr7ZJs30VJ2kDRa9+TZdh+tuuo3YeLiDi3ebGZvrXRbmfNt7ab6fuT/GO7WR/qcNjO42DaPk9ZPzEib9fPksMY9hf7gvG1o1mcS8qP7DzVpHwZDJNxgeG5GGSHkXw8uSTlR03KsDLK+6JlIyvj2jH0pu19lM32PR0REUlZnT95iytJezNrOwy22nXi8Eq7v/xQREz22mX9xeefNAz5585/fLt8OfdQu48WEbH9nPvbeTzcTh9dvtRMHzz0vGZ6//6Hm+kREfPt9j7qRvs466j97E5K3gebztvP7jgp5LKxsC5jWVk5m6YnMWTpXXTpUy9iNOjFOBkXzGRtycyfXj2IB5P+STZ2mVV5e+PF/w+8WW3X7Ye99rXKTlMyrHAzj0ja7Ukew1772ZwndWpE/uzOI2kbLOGWzh6LbB/LiDErH7IyaHfcbhtkY+ldyrhM9uyOknGqLv3hS9vtvsU4eadwlPTJ95IYIyLGw/Y+5kl9s4yyPJO1kbIxnlkk7eEu76BO+Thns3n0k7biaetyjFm9m/XjZkkZGbHYOHcX2bPdZfw1k5+H039uFo0h277fKwu3kTLZ/dJl3CA7zkXTu5SB2TvsRS2jDMvK2Sy9i35SJ2XP5qLpH7x2EM9Jfjdx2s/mR/fH8UBS9y/aDltB8ZIGUbI2c4c2dbpOSerMRbfvkscy9pHp0glqqEn/Jvrt+7E3OYijZGxyltQFWbP8cJr8bqNDXbOb/L4kS7+W/Uamw/thAICzzBdwOBNKKZfi5tdvbvWLtdZfOKVdfskJy95Ta33XHeb3cycse1Ep5bl3mB/3uGUMRC/qtAcuYdmyyTdw1mQ/8l+FbPINnDXLeCkJq5RO8AE+Rjb5ZhXSyTdwi2zyzSpkk2/grDntH5Z2kU2+gVut5EeXaQxnIAi4y6x78g08U2ehjQTPRDb5ZhWyyTdw1mSTbwAAuDsYdeKseENEPOeWv3cj4tWnuL8vOGHZry6Q3+22/cIF8gQAAAAAAAAAAAAAAM4AE3BYu1LKyyPia44tfrTW+v5T2t99EfHICUm/cad5PhXr4yckveRO8wQAAAAAAAAAAAAAAM6GwboD4N5WStmOiJ84tvi3IuJNp7jbT7/N8t9fMN/fi4iHjy37jAXzBAAAAAAAAAAAAGCJaq3rDgGAu5Av4LBu3xtP/xrNNCK+rtY6P8V9fuJtlv/hgvn+0QnLTvrSDgAAAAAAAAAAAAAAcBcxAYe1KaV8VkR887HFb6i1/u4p7/oFJyw7qrV+dMF8P3DCsueVUnxpCgAAAAAAAAAAAAAA7mImBrAWpZRhRLw5nj4J7D0R8doV7P7BE5Z9eAn5fvCEZb2IuG9J+d9WKeVly8rrpa/55WVlBQAAAAAAAAAAAAAAzwom4LAu3xkRLzq27Btqrfsr2Pd9Jyy7toR8r99m+f1xyhNwIuIdp5w/AAAAAAAAAAAAAADcs3r5KrBcpZRPjYhHjy3+6Vrrqj69snPCsr0l5HvjNsvPLSFvAAAAAAAAAAAAAABgTUzAYaVKKb2IeHNEjG5ZfCUivnWFYQxPWDZdQr6T2ywf3WY5AAAAAAAAAAAAAABwFzABh1X7poh42bFl315r/dAKY+ifsGy2hHxvl8dgCXkDAAAAAAAAAAAAAABrYmIAK1NKeX5EfN+xxb8eEW9ZcSgnfe1mGc/C7fK43Zdxlulzl5jXO5aYFwAAAAAAAAAAAAAA3PVMwGGVfjwidm75exwRr6q11hXHcXTCstES8r1dHiftb6lqre9cVl6f+dr/c1lZAQAAAAAAAAAAAADAs0Jv3QFwbyilfHVEvOLY4tfVWv9gDeHsnrDs/BLyvV0e15eQNwAAAAAAAAAAAAAAsCa+gMOpK6U8FBFvPLb43RHxujWEExHxxAnLLi0h39vlcdL+AAAAAAAAAAAAAFiD+byuOwQA7kK+gMMq/HBE3HfL3zUiXlVrPVpTPB88YdmDpZRFn4fnnLDsKCKuLpgvAAAAAAAAAAAAAACwRr6Awyq88tjfvx4RR6WUz3mG+Vw4adlt8nl/rfX9t8nnPScs60fEcyPifc8wplt9wgnLHqu1miYNAAAAAAAAAAAAAAB3MRNwWIfPj4h3LimvF98mr9dGxGtus81/vM3yT4nFJuB88jPY15n1rV/2qc30Qb/9oaDtYb+Z/sD2MI3h3Kidx6hf2tsP2jHev50Xfb3xfjO9v/t4M70cLvaBpzKf5itNk330k3OdfPSpZttHRB1tN9PnG+ea6eOLl5vpe5N5GsNzxxvN9CsH7XP5nqsHzfRzo/x++eheci2ut5PH01kz/WDcTo+ImCWfRJ1N2+dyctTex/govyez+Yazo/a5nhzuNdPnk3F7//P8PM2nk3YeszyPlv5wlK8z2mymD7Z2munnH/6kZvq5C+38IyIGo/bzP0jK8ix9uNFOj4joJ/XJQ8lxPHyxnX7fTodr0WvXJ3uH7fs+e+6enLfv2S7SZ3vBzyFn5yAiYj8pg8ZJ+TKetdP3DtvPZUTEbnItshiy81Q7nMejpD6ZJcc5T2KcTjqU9ck+smcze+56SRvq5j7a64w2Futi9jvEkDnt52YZMaTbLyHEWVIv90r7+c8uRUm277KP3uSwvY9ZuxwtRzfSGMqk3a4vSdsgiyFmeRlW5+1ntx61z0Paxumd/seNa3aeenndn0qPcwn7WDCGWNG8MgAAIABJREFUrJ9Wku37HZ6bpLubPlf9XlLn1TyGLMykOkmPM9u+w2lK+x4RHTJp5d+ljEue7fSeToPI+8OpLIakDKvjdvkUkZcPddouR6f77X1MD/M29Txpr86TenmatPMme3lZfyPp12/faOcxTtJHN9rjDpPkPEZETJOxqmFyrWrSJ49k+4i83q2j5L5fwv9ztOiTlYUwycqGiNhP2v5Z+m5yz1/v0Md6cq99va4eJPfsgn2wbCysi6w/m/VFu7TZxzvtPLJxw0myj/1J3r7Jxts3kop1mDQuurRP8vZHe/tRskKXRzvr32Syw+yS/fyU/6+15JbttP+sDMpu+1X0lxfVJcasfMjSBwtu30XWPlmF2XTx8bJFty/JuczKn2z7LH0Z5tnDG3mffdF6NTMa5PXNURJD9lzkMeTnIXu2svOw6LPfdZ1Ftl9GOZu9t8jG82dJ22I0yNtpWVsuu6enSxi/zd6dZnlMx9mzm8eQlXPTBfuqXWTvdw+TcnQ/eV+YvVPodK2S/k2X9+CnrbfgOFKXsn4wbP+mIRt3TEfCpvm4QDrWNOvwG5WWDuPUJRk7yI6jJMdQex3eUS045laSfdQk/1GX3+H02++558k9W5LRjy5jxDtJf/faoH2/bCblR5e2AQDAWaY1w73o30XEST2Bz7jTDMvNX5+dtP3v3GmeAAAA3N2yyTcA3P2yyTcA3P1Oe/INAAAAAAB3DxNwuOfUWg8j4vdOSPrcBbL9TyPi/AnLf2OBPAEAAAAAAAAAAAAAgDPABBzuVb9ywrIvLKV0+B7piV5xwrJJRLz9DvMDAAAAAAAAAAAAAADOCBNwOHW11rKMf3HyZJa332b91yRh/dIJyy5HxBfd4WF+1QnL3lZr3b3D/AAAAAAAAAAAAAAAgDPCBBzuVf9PRDx2wvK//UwzKqV8TkS85ISkf/JM8wIAAAAAAAAAAAAAAM4eE3C4J9Vaa0S86YSkV5RSvqBrPqWUEhGvPyHpwxHxM3cYHgAAAAAAAAAAAAAAcIaYgMO97Mcj4iMnLP+pUsoDHfP49oj4vBOW/0Ct9fCOIwMAAAAAAAAAAAAAAM4ME3C4Z9VadyPiO05Ien5E/Gop5QWt7UspfyciXndC0n+MiH+4aHwAAAAAAAAAAAAAAMDZMFh3AKzGU5NJ3nOHm/9aKSVb54W11sfuMP+1qbX+VCnlyyLiy48lfXpE/H4p5U0R8XMR8e8j4igiHo6bX7x5dUR89glZjiPiv621jk8vagAAAAAAAAAAAADuVJ3XdYcAwF3IBByI+O8j4lcj4qXHlp+LiG9/6l8X84j4mlrrby8xNgAAAAAAAAAAAAAAYM166w4A1q3Wej0ivigifmWBbG5ExFfVWv/pcqICAAAAAAAAAAAAAADOChNwICJqrVci4osj4lsj4toz3PxXIuIltdafXXpgAAAAAAAAAAAAAADA2g3WHQAr83hEvOyU8z9tb42Itx1b9tiyMq+1ziLih0opb4mIr46IL4+b5+zc8VUj4o8j4pcj4n+vtf7msmIAAAAAAAAAAAAAAADOHhNw7hG11qOI+DfrjmMRtda3rmg/uxHxpoh4UymlRMTzIuK+iBhGxF5EvK/WemMVsQAAAAAAAAAAAAAAAOtnAg401FprRLzvqX8AAAAAAAAAAAAAAMA9qLfuAAAAAAAAAAAAAAAAAOAsMwEHAAAAAAAAAAAAAAAAGgbrDgA4Wz6yP26mj6fzZnq/V5rpH94apjFs9ttzAwdJ+vaw30x//qXNNIZzw3acly48vx3DoH0eynzaDmA2aad3yaMkcyxr+1qm20dEHWw002e99nk8mLRjyNIjIt577bCZ/r4k/U+e3G+mP7HXfiYiIp68cdRMv7rfvp57SfrkaJbGMJu1z9XkqH2/zOe1md4f5PfDLCkfBls7zfStfvvZnU/a16LO8/M0n7bzmCXpXfaRKb32cfaS9MmNa8303eQYIiJ6g1EzPbve/aycTsrhiIjBqL3OtSfaz+a7N9rN2I2tvJmbHceiSlInjjo8V1m9umj6IEmPiDhKnu3MLClfsrZFRMQ0WScrwzK9Duehn9Xtvfb1rMn9lt0vERGD5Dh7yT01GCbPdod7Mnu+dzbbz152Ty7DdlK+7CTlx6XtdvslO8Yu+xj2k2c3OU3LOI/l9C/F4rL26ir2sYoYMvMFY+iyfdL+yPexeBupzpJyMpI2TlIOxzR/dks/aQtO2+VD6bfbWBvDvC9aSlanJX3ypB8363Cp53WxenW4YPtkK6lzIyI2k4KyzNrXskySPneyfUSkz1ZJ+vVl2u6rlvFBGkJ2nPXwRjN9dmO3nX7tiTSGebLO4RPt/svRlb12+tV2jBERR9fbffKja+308Y32tTpM+tt7HdqzF5IYB0n/pZ+0wYbn2tc6ImJ8frsdw2Z7jKd/sb2P+UEeQ3/zXDO9TNvnqUza/cRhhwbOzjDpDyd59Eo2NprXN9nY5cVxewzn2kY7fT9pz0ZE3H+ufR52k3GkrB+3jH5glkcm63Nf7HCezo/a13MruZbnk75Jdi90WWejQz+uZRn9ggWbDp1kcWYxZPfTZJYfxCSp+5PqIm1jzZL0LjHuT9rt8r1xlt5+9p+8kbeRriVj3Vn58uReuy7oMl6/6Fh4ZtrhvUUWQzaWXpP7oXR4eLM8ZtN2+jwbj0vy73WIMRsPy9KzMb0Or7nSsa40huQ4u4z5HS54nLtJ/+jJpC0aEbGVjHdl9WpWH00XfO4i8rI862t2aVtk66wihsxRUpZPk7ogK8OmSf7L2EemSzmdlVHZe9PsGJYhK6u7jMdnsvdc2TuD7L1Hlv/RQfJ7hejwnvywnZ71HQ47/PYje8+VtcNKSfrLHdrU54ZJvz8ZXy1H7fGT3lE+fpKONQ3afaSaVawd+sOR/MalJOPxNRl/rcOtNIT8OJL0LIbkNzTXOwzQjpNydJyUcUdJ3+HGOC+nP7DbHrt8fLfdvriR9C0OOtQ3AABnmS/gAAAAAAAAAJwgm3wDAAAAAMC9wwQcAAAAAAAAAAAAAAAAaOjw/UcAAAAAAAAAAAAAgGeHOq/rDgGAu5Av4AAAAAAAAAAAAAAAAECDCTgAAAAAAAAAAAAAAADQYAIOAAAAAAAAAAAAAAAANJiAAwAAAAAAAAAAAAAAAA0m4AAAAAAAAAAAAAAAAECDCTgAAAAAAAAAAAAAAADQYAIOAAAAAAAAAAAAAAAANJiAAwAAAAAAAAAAAAAAAA0m4AAAAAAAAAAAAAAAAECDCTgAAAAAAAAAAAAAAADQYAIOAAAAAAAAAAAAAAAANAzWHQAAAAAAAAAAAAAAwKrMa113CADchXwBBwAAAAAAAAAAAAAAABpMwAEAAAAAAAAAAAAAAICGwboDAM6WX/53H2ymj6fzhfKv8/V/tnEwyOce9ntloX3MFjzOaYfzPE/2UZNPZJbSPsZeh3NQFjxP2f2QHWOnfSTnYZac69rhls/2kV6rJH06meUxJHnMZtlxLn6us3umnzx7dT5qppdeP9k+P0+9QbKP8cHC+8hkx5HFONjaaab3B3nzrtdvX4vsWvaSa9mlbCgLTgPvUkaddYvWFauSxblo+irqvDz/hTa/GUOSx6IxdpE+u0l61jaIiBglz/9Gh3bWaRsN2uXs9qidvrVgekTEMDnXw95i5zHLPyJiM8mjn1zvbB/9DsVwr7brzTIbtzOYTdvbz9vpEREleTiz9Ejq/poVIF3aDuk+kjySGOqsQwzJOmkMSfum03lYUBkm7bzRZppH79z5Zvpg+2Izfb7Z3r6MzqUxbCVtwc3hVjN9PGy3BSezvD7K1siaMFn5MEpWGNYOz/ZRu90e03b5UmaTdnqH8iWSMqxkZdj0qJleD3bzEA5utPMYHzbT5zfa+5jvXkljGF9r5zHe3W+mT/bb13J60L5WERGzcbuMmU3a5eT0oH2tDpL+dIfHKmbjdh7jvfZxDjbb98vh1fZ5jogYnNtrpvdH7fJjeP6JZAft8isi0jorbWUlz2ZNnv2IiOHmhXYMo+12elLGDTq00w6SPlC/DJvpWVtyd5yXYcNkXGB72L4aR8kxTJLnposuz1ZL1h7eSo4xIuLiRvu5yM7T+Y12enYtIyI2Bou1y3tJu3/eoa+6aNsgeyy63C7Z/ZDFkG2fnaeN6KXnKmtnzRYcF5j08u2z9xpZ+jBrp3Uo49I+9X67zsv6ql3e3eyP289uNlaVvQfrMqY3nbRjmCZtg0Xfa0R0eP+SvddI9rGK9zfLeI+VxrDgccyyUrJDd/i0351m4/kREYf7yXuLbNwxKT+6vGvLLHq/dBmfze7r7LnI3o0s41pn7wyz94FZ+ZNtfzOPZBxpwTqvy3maTTv021vbZ+MKS9BLxqoGo4329kmbvYv8nkzK0aTJ3OVaZ++A9pP76WqHcYFMVncfJvf9tcP2/XY+6TdEROx0eK/QMq/tMcGILD1vE0+O2uch6wcednnft2D5kB1DFmNElzZvlkM29tBO7xJjdk/uJ3XBXnLPdvnd19Wk3X4teTav7rfPw0Hy7EdExMs/JV8HAGBN1v/rKAAAAAAAAIAzaNEfCgIAAAAA8OxhAg4AAAAAAAAAAAAAAAA0mIADAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQIMJOAAAAAAAAAAAAAAAANBgAg4AAAAAAAAAAAAAAAA0mIADAAAAAAAAAAAAAAAADSbgAAAAAAAAAAAAAAAAQMNg3QGwPqWURyLiJcf+XT5h1S+otb5thaE9TSnleyLiu26T/PZa619dYSz/SUS8KyI2brPKC2utj60qHgAAAAAAAAAAAACemTqv6w4BgLuQCTj3iFLKCyPipZFPtjlTSikviojvWHccERGllF5EvCVuP/kGAAAAAAAAAAAAAAB4FjIB597xroi4uO4gnolSSj9uTngZrjuWp3xTRLxs3UEAAAAAAAAAAAAAAACr1Vt3ANDwLRHxmesOIiKilPL8iPi+dccBAAAAAAAAAAAAAACsngk4nEmllEci4ruPLZ6vI5an/HhE7Nzy9zpjAQAAAAAAAAAAAAAAVsgEnHvbeyPiFyLi0Yj44oh46XrDeZqfjIjtW/7+vYh45zoCKaV8dUS84pZF87gZHwAAAAAAAAAAAAAAcA8YrDsAVua9EfGHEfFvn/r327XWj966QinlBasP62OVUr42Ir7wlkXziPj6iHj9GmJ5KCLeeGzxj0XEb0fEq1YdDwAAAAAAAAAAAAAAsHom4Nwjaq2fvu4YuiilPBwRP3Bs8Y/WWn+jlLKOkH44Iu675e8/jYj/JSL+xjqCAQAAAAAAAAAAAAAAVq+37gDgmB+JiEu3/P2BiHh0HYGUUr40Il55bPGra63X1xEPAAAAAAAAAAAAAACwHr6Aw5lRSvmK+Ngvy6xlwksp5UJE/Nixxf+81vrzq45l1XZ3j5rpdb5Y/rNZnsF82l6nSx4tpZd/TamXfHEpy6PO60Lbd4oxy2PBr0aVDlM0+4P2Stl5mCfpXe637H5Y9H7KjiGiw3HUxY5zlhzDzTySc53EcBaUXn+h9DqfpfuovfY6pZ/sY9bevksMveGonT5opw832umjjbx5t2gZ1B+00wfD9nnssk6WPtxop29t5ueh36GsXcSsQ/lx2pYRQ3aeFj2Ps6QuWYZlXOvsXI6z+ibZvlNZn5Tl2XOzNWqndzlP55Nna2dz2N7HCr5quZ0c54MXNprpl7fax7DToZzd6Lfv6+3kWm0mz8XOKI/h3CjJY5jto52+2cvLl97htWZ6GR+006eH7fRJu+9yc532PuYHN5rpddyOIVOnk3ydLIYkj0Vj7CRr4yTttFUog/azWybjhffRS44zrdE6dHDqbHOhPEajc830wbB9niLyOit7+gdJfdKbtp/d7LmNiChH7eemzNrXu0yT+6FDuz7bR/bsZuXPfD8fDkvLj6R8mN/YbaZPrucxHDzRLuuPru6106+0j+HwSl7GHSTrHF1v33OHybjAOGsHdmhzT+btfWwk6bNx+56cHkzTGGaH7fMwudE+j+PkWm70PpzGkOq1S9L+xaRP3qHezZ7v7Nk+l5Sz/Q7ttKQZFgdJOytpasawn7e5s3b5MCnL95Pxlcl88X5eNt6WjY0u2iaPiLiY9H+yPDaS8ZNRhz7YKDmO7H7I1JrHkBVzWV81M0lbFxH9aMeZx7iEcYHkOJOu6MK6nOasvtmftG+Y/UlyT3e44TYGydhE8tyMkv5wlh4RsXfUrhfzMZykbdBhDOcoWWfvsB1jNk7U5bnr8m6jZTpZ8IXgEvQ61Gnrtuh70077WLCc7XIes3p1UfMOZX12LrO2QdZb7fJMZO9GBklhv4p3s1kM2XnK3ptOJ3l/OCsf0jIsGyvv8FuAbCw8Ow/9Qbudl99v3d4JLraPDr+rSM5Vdj2zeza73w5v5H2w7Ln6ULL9uxfMPyJ/r9lP2jjD5J1Al/ei2XvNUXKus/c72XuRiIhR0k7L2kBX99vX++q1DmM4e+0+d3ZPTZJ23t5H87GJw2sfaabvP/GnzfRZ9l4jGUPuj7aa6RERo3MXmumDrZ1m+sbOfc30rcsPpDHsXGqPU2/tJO/a7msf5/077d88AACcdb6Aw5lQSrkUN79+c6tfrLX+wjriiYi/HxHPveXv3Yj4xjXFAgAAAAAAwBpkk28AAAAAALh3+AIOZ8UbIuI5t/y9GxGvXkcgpZTPj4ivP7b4u2qt719HPAAAAAAAAAAAAAAsz6JfDwXg3uQLOKxdKeXlEfE1xxY/uo4JL6WUzYj4yYi49Ru0vxUf+3UeAAAAAAAAAAAAAADgHmECDmtVStmOiJ84tvi3IuJNawgnIuI1EfHJt/w9jYivr7XO1xMOAAAAAAAAAAAAAACwbibgsG7fGxGP3PL3NCK+bh0TXkopL46Ibzu2+Idqrb+z6lgAAAAAAAAAAAAAAICzY7DuALh3lVI+KyK++djiN9Raf3cNsQwi4i3x9GfisYj4u6uO5U6UUl62rLz+yt//v5aVFQAAAAAAAAAAAAAAPCuYgMNalFKGEfHmePpXmN4TEa9dT0TxdyLixceWfUOtdX8dwdyBd6w7AAAAAAAAAAAAAAAAeLbq5avAqfjOiHjRsWVrmfBSSvmU+Ngv3fyzWuu/WnUsAAAAAAAAAAAAAADA2WMCDitXSvnUiHj02OKfrrX+8hpiKRHxkxGxecviqxHxLauOBQAAAAAAAAAAAAAAOJtMwGGlSim9iHhzRIxuWXwlIr51PRHFqyLi844t+/Za64fWEQwAAAAAAAAAAAAAAHD2DNYdAPecb4qIlx1btpYJL6WU50XE648t/r/j5gShu83nLjGvdywxLwAAAAAAAAAAAAAAuOuZgMPKlFKeHxHfd2zxr0fEW9YQTkTEj0XEhVv+HkfEq2qtdU3x3LFa6zuXldd/9g9+bVlZAQAAAAAAAAAAAADAs0Jv3QFwT/nxiNi55e+1TXgppXxVRPyXxxZ/f631P6w6FgAAAAAAAAAAAAAA4GzzBRxWopTy1RHximOLX1dr/YM1xHJ/RPzwscX/X0T8vVXHAgAAAAAAAAAAAMBqzecr/7/jAXgW8AUcTl0p5aGIeOOxxe+OiNetIZyIiB+KiAePLXtVrfVoHcEAAAAAAAAAAAAAAABnmwk4rMIPR8R9t/xdY00TXkopXxwRf/PY4p+qtb5t1bEAAAAAAAAAAAAAAAB3h8G6A+Ce8Mpjf/96RByVUj7nGeZz4aRlt8nn/bXW93eI5Sgifu4OYvnE2yx/cSnlOcf3UWt91zPMf23+i5c+r5m+dzhtpo+n82b6/niWxjCetfM4GLdjGA366T4WNUs+Pzmbt48h2/4oOY8REYNeSddp6S+4fZc8svthmpyHbPuI/FymMUzyezKNIdnHfJbcL2cgxlrbMdb8UqSyz7bWJL0k91t/sPg9PZu2Y5h3uCcz2XFk6YNhe/70YJSXgf1+O4/0XCfbD0b5HO/BsB3nzma7mXppe9RM3+pyHspi98wseW6y8qnLOlk522Ufi+TfZR/jabuMyuvMxT/pnB3HMuq8RePMts/qxC62k/s+ayONBvmzu5U8u+eTZ3cZ1yKTHceFzeFC6ec7lC8bSQybSfp2cp5HSTkcEbGV7GMrqU+yYyjj/TSGMh0n6Yft9Fm73V9m7fwjIup0kq5zmspgGJH0DWovu6fax1B67WtVk/13ksSYxrCM65Cdp0XTIyKS48jyqL1kmC1L77CPLI9akmvRobpZvEa6+5UuHaB50k9bNH0Vkns+e7YjInpJndTL9tFP+kcd6rx12+qXOEj6/VnfIzvX2XnOzmMXWQzptehSzqYxnP6Y3mlbQXP3TOil/enTr02ycaZ5L0nvUClOkmd7PkjGumrSp+9wmrKxh5gvdtNlY4IREVmt2KV90dy+wzrJK4OYJ7ksGmNERNZtz/ax4DBUp+2zZzNPb+c/7FAvD/vtizVMdpKN6WVjHxHLGG9rH2e/l7cV+70Fx8s6jNFkFh3Lmg6X0Jdc0CA5D2dhzG+6hHcGi8rG87N3L8vYx1kYn13GPrqMj552DKctO4+7+/kYzmGyztFBO/3G9fb/09rlvejksD2uOBhtNNOzPtZoK69vxslxZu3V3hLul4Wf/+SWT9/dJmPMEXmM2XnIzmOX98PZO8mNrfY7gVH23qND2ZGVL9m7la3R4u9esvd52Tuk85vta7G3nz83m8n73exa3LjefvaPDi6mMdQFx+Sy7QdbO830zYsPpvvYvnjSz+P+XHaezl/easdwrr19RMTF7fY6z7u83Uz/jL/QvhYPJPcCAMBZZwIO6/D5EfHOJeX14tvk9dqIeM0Jy4/3Ojci4l8sKZaIiJ8/YdmfRMQLlrgPAOBZYBkTTwA445Yx+QWAMy2bfAPA3c8QDgAAAAAAf+bs/xeCAAAAAAAAAAAAAAAAsEYm4AAAAAAAAAAAAAAAAECDCTgAAAAAAAAAAAAAAADQYAIOp67WWpbxLyLefkL2b7/N+q+5TSz/w5Ji+ZrbHO4LT1j/Bcs5kwAAAAAAAAAAAAAAwDqYgAMAAAAAAAAAAAAAAAANJuAAAAAAAAAAAAAAAABAgwk4AAAAAAAAAAAAAAAA0DBYdwAAAAAAAAAAAAAAAKtSa113CADchUzAuUeUUl4QEe+5w81/rZSSrfPCWutjd5g/AAAAAAAAAAAAAADAmdVbdwAAAAAAAAAAAAAAAABwlpmAAwAAAAAAAAAAAAAAAA0m4AAAAAAAAAAAAAAAAEDDYN0BsDKPR8TLTjn/0/bWiHjbsWWPrWC/J/mdiHjtCcuvrjoQAAAAAAAAAAAAAADgdJmAc4+otR5FxL9ZdxyLqLW+dd0x/Jla6+/EzUk4AAAAAAAAAAAAAADAs1xv3QEAAAAAAAAAAAAAAADAWWYCDgAAAAAAAAAAAAAAADQM1h0AcLY8cv+5ZvrBZNZM3x1Pm+lP7o3TGEaD9tzA8XTeTN8a9Zvps3lNY+j3SjM9izGzOWjHOK95jDujdhE+7LeP4eJGe/vtYTvGiIjLW8Nmer+0Y8jMOpyHzFFyv+wn93R2HiMiDpN97I3b+7h22H5u9pLnqovs2e3yXGSyPLL0g+Q8Zc9dl+cyi2EvuRb7SYzjWfteWIZRv32c20kZGJGXcdl5ys51ln+XPHY222XUfZvt8mcnKeMiIobZeUgei6yszs5jl7I+k8W4DNPkvp5kz35ynPMO5U8vuVabyXMxSNKze2EVujw3mY3kODcXbL9ERGwkeWT7yIrJyby9QlavR+R1d9aG2srqmw5tg2yV7Hpn2w863C/ZtehP9pvpvd29ZnqZHKQxlHF7nTI9bGcwb9e7dZxsHxF1tlge6T6Se7ZO8v5PPbyxUAx1MmmnT/MYMjU5ztJr32/Z9l1k+yijzWZ6b6vd142ImCf3XOm121m9JMbo0j+qyblK0rOSvvTbbaiIiH5JrmeSXpJ7ssza92SZ5M92mbfb7Vl6LKEdlkrul4XTu65zyrJn816w1S9xsIqG+YJK0lZcePsO98LC90t2z/c7PBNJGZalZ2Vgl+GVRWvFrDrp0rfI2szDedKuX8EtP+8ttpNsbLPL2Ge2TjZGk/UdRl3GT5I8SnJDZLuY1zyGmvXr0xzaZvMOMaT3QzuPZYzYZc2HZYzzLK59HraHSRlX223FbAwoImKajb8mY937k/bVunbYbmtG5HFmY1HZOFQXk6SgzN5LZDoMTSw8npbJxoi6lLPZGM2D59r3ZH5PpyHkY7xJHuNkhS4xZONh2Xhadgxd7rd0jDdJX/SdQ0TEUXKg2bu4ZZTDvQXfay4aQ5exz8mC76EOk+0/eDXvkz9+rb3OXlJWP5H8XmDa4Z6djtvHMRgl7wySMip7RxWRv9fMZL9p6NKu7zJO3JK/q2uXw+c7vIvL9rHobzuy7SPyd4ZZnXX/9qiZ3uXdS/b+JothGe93svd1WRF4I7nnP3A9Lz+y301kMWblz//7gWtpDB+6+vHN9P2kjKrJPbmx1b7fHri81UyPiHje5e1m+qXt9rP58Zfa+8h+5xMR8UCyj0+42B6Pf+755LdEB1fTGAAAzjJvSAEAAAAA4A7cDZNvAFjMmZhbAwAAAADAmWACDgAAAAAAAAAAAAAAADTk3wMFAAAAAAAAAAAAAHiWqPN1RwDA3cgXcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoMAEHAAAAAAAAAAAAAAAAGkzAAQAAAAAAAAAAAAAAgAYTcAAAAAAAAAAAAAAAAKDBBBwAAAAAAAAAAAAAAABoGKw7AAAAAAAAAAAAAACAVZnP67pDAOAu5As4AAAAAAAAAAAAAAAA0GAAYzo8AAAgAElEQVQCDgAAAAAAAAAAAAAAADSYgAMAAAAAAAAAAAAAAAANg3UHAJwt920Nm+mTUb+ZfjnZ/uGdjTSGjUF7H/Na29v323MLJ/P29hER/dJO75X2Ctk+svz3J7P2ChGxPWyfp2FyHi5utKuAzWE+R3Mz2ccsuVazeTv/ySy/VpN5O5Psfsmu5bCXn4fesJ3HxY3suWjHeDhNTlREbA4Wuxb95Dxk20dEHCVxZnlk22f39HaHeza73lcOJs30a0fTZvpekt7FYfJgjJPzNEruhYj8emfnKXNxM29iPrA9aqZf3mw/N8+90E6/3Gtfy4iIMtlvr5CUL9NzDzTTr4/bZfm0QxmXPf1H03Ye80jKwMivdVanjZN7NivDsme/i2FSsWb3dPZMROT1TVZnZWVglzovk7UNzm8kbYcOdd5WUudl7bBecqo7NNNSm4P2TnZ67Wezt/vhdvrBXhpDmR410+skST86aKcfJuVXRMx3rzTTZ9eeaKYfXb/eTB/v3khjmNw4bKdfbx/H9LB9nmaH4zSGabLO9LBdd4/32vVJTcrA2SQv446ut48ziyEz2Mrr5Y0L7Xp5mNTtw53Fto+I6Cd1//DcZjN9dOFcM33j0k4aw+b9F5vpg/3dZnp///5mem/nUhpD79z5ZnrdaB9HzcqfQd4nr7329SpJfVGm7eeuzNr3dBnnZVxazh6186hH7fJpnhxDREQdt/Ook6T8OGyXo1l6RH4cs6P2eZom5XSXsv7giXZ9cXSl/dwcXmnHkJWRERGTG+1zPT1ol/UHWR8sKcq7NOPGSSNnIxkHmiXp2TFGRIyTere/2S4fsmu5FL12e7XOk3bc+cv5LqZZ3Z48/0n5sJmU0xERw1G7TjvstW+6wbTd3j1Kto+IGPba9e75jWxMb7H+TZdxh2xMr8tYVUuXfuAo6Vsk3Z+0f9OlN5w1J/u9xc71KBuojohR1s9L6vZI0nvTvI/VO7zWXuFaux83v9Euw7LyJSIikvIjBu3nKrJ9JGXgMvSS8ieLoQyTY4yIkuyjDrfaGST9gvmFvJxN65N+0j9J2sNR8vGT+ajdP7mRjOkdJum1QxnY5V1Yy1FSlmfFaJdyNhsnysaZOrwSSM2T8dHsVI/6iw9mzeZJDMn22aXOxgS75LFovdtF1r5YPP/F88jaJ4vK3kFFROwu+B7qIOlbjHfyE7WbjKcdjNvp/eThn3UoPzaS8a7tZCzq/uQ3CxeT3zxE5Mdxabudx04SY5f3fdmYfvqbh+QYst8C7CS/N4joUJYnQWZFwzLeDy/63nQZZUOWR5ffCyy6j+wd04Xsel9I2pqR9xWzPlb2fvmBDr9H+tD19ljU49eS8bLkWtx/rh3jCx9stxMjIh5K8tgZta/Fw+fb56FLP3CQlA+XN9v3S/+wPWZYxu33YAAAZ50v4AAAAAAAAACcJJt8AwAAAADAPcMEHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAaTMABAAAAAAAAAAAAAACABhNwAAAAAAAAAAAAAAAAoMEEHAAAAAAAAAAAAAAAAGgwAQcAAAAAAAAAAAAAAAAaBusOAM6iUkqJiE+OiBdFxH0RcSkihhFxLSKuRsR7IuJdtdaDtQUJAAAAAAAAAAAAwDNW53XdIQBwFzIB5x5WSnkkIl5y7N/lE1b9glrr21YY2tOUUr4nIr7rNslvr7X+1SXtpxcRfz0i/lZE/LW4OemmZVpK+d2I+McR8Y9rrU8uIw4AAAAAAAAAAAAAAOBsMQHnHlFKeWFEvDTyyTZnSinlRRHxHSvYz2dHxFsi4tOewWaD+PNz+bpSymsi4gdrrbPlRwgAAAAAAAAAAAAAAKyLCTj3jndFxMV1B/FMlFL6cXNSzPCU9/MdEfH3IqK3QDZbEfH6iPivSyn/ea31ylKCAwAAAAAAAAAAAAAA1s4EHM6yb4mIzzzNHTw1+eb7G6vUiPjjiPhQRBzGza8GfXJE7Nxm/c+JiH9dSnl5rfXaMmMFAAAAAAAAAAAAAADWY5EvfsCpKaU8EhHffWzxfMn7+OyIeN1tkv8kIr4xIh6otX5SrfUv11pfXmv9SxFxKSL+ckT8zG22fUnc/BoOAAAAAAAAAAAAAADwLGACzr3tvRHxCxHxaER8cUS8dL3hPM1PRsT2LX//XkS8c8n7+JGIKCcs/5cR8em11h+ttT55PLHWOqu1vqPW+sqI+IqIGJ+Qx9eVUl683HABAAAAAAAAAAAAAIB1GKw7AFbmvRHxhxHxb5/699u11o/eukIp5QWrD+tjlVK+NiK+8JZF84j4+ljiV2VKKZ8WJ084+v2I+G9qrQdd8qm1/nwp5X+MiH90LKkXEX8zIt61UKAAAAAAAAAAAAAAAMDamYBzj6i1fvq6Y+iilPJwRPzAscU/Wmv9jVJO+ljNHfuy2yx/tOvkm1u8NSK+OSI+49jyL42Ib3uGeQEAAAAAAAAAAAAAAGdMb90BwDE/EhGXbvn7AxHx6Cns55NPWHYjIv7VM82o1loj4udOSHphWfKsIQAAAAAAAAAAAAAAYPV8AYczo5TyFRHxN44tfnWt9fop7O7jTlj2R7XW8R3m9x9OWDaIiAcj4sN3mOdaPHJ5s5k+mddm+mzezn+abB8RMeq35y1l++gnUwuz7SMi5tGOsyaHMU9WOJy2gxhmBxERG8k6R8mBTubt9N0b0zSGa4f5Ou0Y2udp2uViJQbJecr28dDORrqP7eFi81kfOjdspo9n+XOzMVhsvl8/mS/Y65B9h8e7Kbtns3t+q8M56CcHsjduX++rh7Nm+kf382oku++zPK4cTJrps6yA6rBOlp7dL13Khv1J+1w+dmW/mf6ux9v5d3hsIqluUrP6oYXy7xLjQ+dGzfQHttvp28N+M/25F9rlT0TE5XLUTC/z5HpPk+ein3dJSpbHrP1clFmyfc3rm7p5rp3eS45j0L5WXcxH7Rj+dL99HO+71r6W144Wr/uz9sU8KQN7XSqcxGZSX2wM2umf+dyTugp/7uN2HsiDmLfLuP7eR5rp5Wq7kKuH7TIyIqJste+XkuQxudEu4/YffzKN4fp7212h/SfaHx+tXQrKxGzcvhbZPibJPT/cbD/7pUNlMz1o72OaxJBtX67nMUxutMvJ0ms/N/3R6f//LqOkTtxM+rKjnbzO6yf15qK63A+9Yfue6o+ye659LbJr2UXpt8/T5v0XmunbD11upo/uvz+NobdzqZ1+sZ1H//JDzfT51sU0hpqsU/rte7YOt5rp/UmHDzRPDpvJoySPMk7qkxtX0hCmH3xvO/1D7fTrj7XrvP0PPpHGsPf4tfY+3tceWuw9vtdMH+2325p7yRhPxOJ9j3lSX80meQzjG+3j6F3Zbacn5cdskrclRwft9uhG0j7pXdlupveTZz8iLx9659tlVFZTlEFe3wwObzTThwft9PNJm7tm/aeIqEft8mO+d7W9fRLjfNq+37qYj9v3VC+pE3ujdtsgOtSJddw+T+n2ybXqdbhfatK3KFlfMznOMsz7qr3t8+08Ntp1WlnGtViwT1022+VHSa5VRKT9vExNnosu5UdmntyzaQyjJbSH++3jqMP2+Gsdtq9V3Wj3dW/m0b4n50mM2Xj8UYe6//Cgfb98JHn/ko0RZ+PcEfn4ay8Z483ee2Tjjuc63E/nkn1sJmP+5/rta1Wm7bZHJ9mpTvpgNbnfIiKmSQsjGx5Zxj2brTFLxvTGSfoHd/P2yXuvtcuwJw/aeRwkY0CPX12sXo/In71s3DHbvsuzfd9Ou058MHlnkLmwkY/Xv+i57X7/jUm7rH5yr30txx3u2Yvb7WfrcnIesncv920tXi9fTMYNh0kbaNChWu6lhVRb9t/JZn3ZLvdsJnutmb1XXbS/HZGXswfJPXljnN+zWVm8m5Rh2e9PsnI6IuIgaRvsJM9/1nbI3mFHROwk7YPNpBxd9B1VF9l78PuT8uMTHmi3Z//CxXZbNSLi4eQ3Kjsb7fP04Fb7Wma/yYqIGNb2ue5fe18zvX7g3c30+bV8zC8+7oX5OgAAa+ILOJwJpZRLcfPrN7f6xVrrL5zWLk9Y1n7b3na7N/mLvZEBAAAAAABgfRacfAMAAAAAwLOHL+BwVrwhIp5zy9+7EfHqU9zfSf+dc/5fJN7eSf8N9lFE5P9VKAAAAAAAAAAAAAArUzt8RQwAjvMFHNaulPLyiPiaY4sfrbW+/xR3+5snLPukUsrlO8zvs09Y9lu11sW/bwoAAAAAAAAAAAAAAKyVCTisVSllOyJ+4tji34qIN53yrv95REyPLetHxH/3TDMqpZyLiK88Ieln7yAuAAAAAAAAAAAAAADgjDEBh3X73oh45Ja/pxHxdaf95Zha6wci4p+ckPS/llIeOWF5y+sj4uFjyz4YEf/oTmIDAAAAAAAAAAAAAADOlsG6A+DeVUr5rIj45mOL31Br/d0VhfBtEfHXI+K5tyy7PyJ+tZTyylrrb7Y2LqVsRcQPRsQ3HEuaR8TfqrXuLTPYJJaXLSuvP/rI9WVlBQAAAAAAAAAAAAAAzwom4LAWpZRhRLw5nv4VpvdExGtXFUOt9clSyhdFxK9FxEO3JL0gIt5RSvmliPg/IuI3I+JDEXEUEZcj4i9GxMsj4usi4uOPZTuLm5Nv/sXpRv8x3rHi/QEAAAAAAAAAAAAAwD3DBBzW5Tsj4kXHln1DrXV/lUHUWv99KeXFEfGWiPjiW5L6EfHlT/3r6g8i4mtrrSbDAAAAAAAAAAAAAADAs0gvXwWWq5TyqRHx6LHFP11r/eV1xFNr/dNa65dExOdHxD+LiOvPYPNpRPxSRLwyIj7N5BsAAAAAAAAAAAAAAHj2MQGHlSql9CLizRExumXxlYj41vVE9DTzuDn55pl8hWcQEZ8YN7/m83GnERQAAAAAAAAAAAAAALBeg3UHwD3nmyLiZceWfXut9UPrCCYiopTyFyPif4ubX8C5E5/61L//qZTyxoj4u7XW8bLi6+hzl5iXr/gAAAAAAAAAAAAAAMAtTMBhZUopz4+I7zu2+Ncj4i1rCCciIkopXxkRb42IrROS/ygi/mVE/EZEfCQiDiPivrj5xZvPj4gviac/QxsR8T9HxF8rpbyi1vrk6UX+dLXWdy4rrz/+6O6ysgIAAAAAAAAAAAAAgGcFE3BYpR+PiJ1b/h5HxKtqrXUdwZRS/quI+KcR0T+W9NG4+aWen621zm+z+Q+WUj4hIv5BRHzlsbSXRsS/LqX8lVrrwTJjBgAAAAAAAAAAAAAAVs8EHFailPLVEfGKY4tfV2v9gzXF8/ER8VPxsZNvHouIz6u1vi/Lo9b63oh4ZSnl9yPiu48l/6WIeH1E/O3FowUAAAAAAAAAAABgWebr+b/jAbjL9dYdAM9+pZSHIuKNxxa/OyJet4Zw/sxrIuLysWXTiPjSLpNvblVr/Z6I+JkTkr6xlPLCOwsPAAAAAAAAAPj/2bv3aE2zvC7s333upy59uqpvc2GaGRhmCCggzkQGYmBwERRBg8FlFko0JMEVUDQKkYREAUUQVLJU0ETFMSGoeMGICALKCDKMODBc5DYOMPR00zM13XU9Ved+dv6oRpuaU/v3VL2nzjnV9fmsVYvh3e+zn9+zn3179nN2vwAAAAAnhQ04HIW/lOT8i/7/nuQP9t63jiOY1tpakt93QNJbeu//7i6z/RO5uYHnxeaSfOFd5gcAAAAAAAAAAAAAAJwQC8cdAA+E33PL//8DSbZaa59wh/k8dNBnt8nn6d7707fJ5z9PsnrA599yh/H8B73397TW3vZC3i/2aXeb53E5vzI/TN/YHf/s4n7xq4wbu/tlDK88uzhMb/t7w/S5rWvD9P2VtTKGtn/rfqpb0nc2xjFcf34cw8OPVRFkfe7U8Bun58blsNPGXfzS9ricdpcPanK/1lNXt8vvjFzbGl/Dczfq/PeKOrezV9W58V7U5fl6r+pOEcRcG8fwnsubw/TF+VbGcH513G6Wijz2Mr6GqpyTpPpV1u0pmQycXRpfw5mti2UeCxd/eZh++uzjw/RHH3rZMP3JtdNlDNd3xvXhvVfGbfendsZtt6qPSf0TuttFu5kv6tPm7rhtJ8ni/Pg6d4oBZa6NY5jyM8ErC+Mxb6/Ko4jx1OI4/yTZLMp6q0h/z+XxeLRV3IufeH/dv+wX1zlj0858q+tLZXF+aZw+tzxMn5ury6FS1cknTo/Hkw8/t1KeY60cs8bHv/KhcTm8rI/LMan78s2ij5u17d7YqetL9Z2qbb774rhd/duNnTKG5aJ/Wd8+Mz5+/vXjE9TDTVYWxvVl7ZXjfnj5Y8fXMKWfrfrR6l5VY1p1jVNU86yqVZxZqpdVVos4Hzs1LuuFGfuohQmHbxVT5pU+27x/4dJT5Xfazvi/0dHnxmV94/Fxu7m0Wfcfpxdnq1PVtH1+wr2cn7GfrO538Ug/yeLejP89lbliwOr1ukH18FHlsF+co+3Vdb7tjJ/jsjvOY37jyiHEML4XbXccY98dj2l9q7jGJHOnx2sHCy8f/zj0w2dv/YHqX2vtw66WMfRinWj9ve8fpm9dWh+mb1+7Xsaw8fw4j7NPjteBlh8ezw3mirWJ5YfPDtOTZPHseJ2p7xfzuKVivlrch0mK/qFvj+vk/o3x83KS7G/eGH/h2fcMk9vKeCLWFsbrM0l9HZWq3bWV8b1OkrniOiq9uM5W9C9TzG2M216r+p/HXjnO/+zDZQx9p+iLi3ZT5l+MFUnSinbRlsdts+8Va+mrdV3oiwe9Tnlx+vhZsy8U/Uer52C96h+KdabqHH2pLof9+XG9r9dGx/Vls3j+2ZowkauewTZ2xuk7RZ0ul9qTVMvpVzbH716e+cC4j3zq8ngOlSQb2+N14o3tcbv45efH/c+Uef1q8ay4XazZzc8Vz/TF+4AkObsyjuH8mfET70PL4+PPFOmLE8ppsagw1RpOdYopa+WXNsdj1qViHWh9a1ynp1hdGl/nYlEfKlPW66t6XT2rLh/CGs1W8Q75dFEfnjgzHo8+4tG6r6/Weapyqte6in52wjN71S4+pFgDrtZnp7Sb1RnXTy4X7W6Kh1fG/eCjq+NyWmvj5+m5zQnPokvFvLuN+4dezS2KtbAk2S3eGewW73eqv+2oqkOfsEY8q/miC5syI69qbDWqzhdzySlj3vXt2Z4dNos+cn2vHo+q+1ldR3X8z7+/fib/sMfGffFHnB+nVzGsFfOfJHn1w+O2e6ro484WY8W51WIOVvxNVpKcmh9faNsd92HzV58ZpvfivWqS7J95dPyFol3MPfbkOP3RDyljAAA4yWzA4Th8cpIfPqS8fsNt8vrKJF9xm2M+/oDP9pO8bcZYfjAfvAHn17fW5nvvh/AGmgdJtfkGgPtftfkGgPtftfkGgPtftfkGgPtftfkGAAAAAIAHh78E4UF00H9y8lLvfdb/1MpB/znNuSTj/5QnAAAAAAAAAAAAAABwotmAw4PooF9+mv13jm+fh3YGAAAAAAAAAAAAAAD3MRsDeBA9d8Bnj7TW2oz5HvTLOj3J8zPmCwAAAAAAAAAAAAAAHKODfgkEDlXvfdaNLUmS1tpbk3zyLR//q977p9xhVhcO+Gwxycck+Yk7j+w/eOMBn13sve/NkCcAAAAAAAAAAAAAAHDM/AIOD6Ifvc3nn323GbbWHk7y5gOSfuRu8wQAAAAAAAAAAAAAAE4GG3B4EL09yeUDPv/i1tr5u8zzy5KcOeDzf36X+QEAAAAAAAAAAAAAACeEDTg8cHrve0n+/gFJ55L8/dba4p3k11r7HUm+9ICk7ST/6M4jBAAAAAAAAAAAAAAATpKF4w4AjslXJfm8JCu3fP6pSX6gtfa5vfdfGmXQWptP8keTfE0O3sz2Tb339x5GsAAAAAAAAAAAAAAcjr7fjzsEAO5DNuA8IFprr04y3FAy8P2tteo7r+m9v+cu8z9yvfenW2t/MsnXHZD8CUne1Vr7tiTfkeRHknwgyWZu/krORyT5lCT/XZLX3OYUv5Tkzxxy2AAAAAAAAAAAAAAAwDGwAYcHVu/961trr0ryhw9IXkjyuS/8u1MfSPLpvffnZ4kPAAAAAAAAAAAAAAA4GeaOOwA4Zn8kyZ9IsnVI+f1Ikv+s9/7vDyk/AAAAAAAAAAAAAADgmNmAwwOt3/R1Sd6Q5B8n2bvLrH45yR9P8om993cdVnwAAAAAAAAAAAAAAMDxWzjuADgyzyZ50z3O/157S5K33vLZew4j4977v0vy2a21D0nyuUk+Mckbk7ziNodsJ/nJJP8myXcl+a7e+/5hxAIAAAAAAAAAAAAAAJwsNuA8IHrvW0neftxxzKL3/pYjOMfTSb7uV///1tqZJOeSPJxkKcnVJJeTXOq9797reAAAAAAAAAAAAAAAgONnAw4M9N7Xk6wnee9xxwIAAAAAAAAAAAAAAByPueMOAAAAAAAAAAAAAAAAAE4yv4AD/Br/388/P0xfnGvD9Fc+tDJMf+bqZhnD6uL8MP1961vD9I967Mww/bXn98sYFufG+xMfufLsMH1/5aFhetu8Nkw/farunuduXB2mL5x+ZKYYpgwQZ5dOD9O398ZlvbM4LuczS3UUO/vjc2yNq2yyOz5+cb7KINna7cP0/T5O3yvSs1eGkKKok3GzShFBtveqb9Sq65xv47Iuup+0vZ06hivjPm5uddx2sz++GW1+9qnVte3dYfrljfF1bmxPqDD32Hx1syaormNpYfZ95FeKsqyuY3Vp3LB29sd1vuojp9gp2ubm7rgc94oYk7ocqntVnePMSt1uqjxmrQ9V/zNFNUc6W9SXjWIsSZIzRTnsFunVcDOXuhyuF33UelEfdop6vzg/vpc3duo+rvrOZjH2n10e18nlhWJQTX2/t4q2Wc0dtoprSJLnb2wP059dH9/vql1MuRdVu6imF1UftjLhXlRluTxj/1HNV8+vLpZ5LMyNn6GWinZRWVmo2/Zm0QfNLS8N06szzLcJ17C9MU4v5mnvvz7un97xK+PnpySZK+r9pWruUBTE3IQ5UvUs+sqHlofpT5wep08Z8qowl+fHbW99Z9xHXd4Y90/VM16SPHdjfC/Wi/Fqvxgzr26Nj0/qtYvKXBv3H2sr474hqfvZU0WMVZ1fO1/P08p+tqgvq8W6wPnVupwf2R4/5z380z84TN/7wDPD9Gu/NP5h7LNPPpGLP/vLw+88/vEfOUxfecNvGab3pdVh+o1HXjtMT5JfWR/X66p/uLI5HperdpfU87BqflGNq1cmtN2q3p9fHdf76hqmPFtU84eqXVzeHPeBVzbrcqj6h1c+OR5Pzq0UbbuYYy1sTRiXr4/b9n6x9vlcxuuWFzfq+Wx1O3/+uevD9I2iTi+v1HOkc0W9r+YOZ5eLtYsJa37lM9b1cbu4cH089k9RPUPt7I/PsVY8513cfO6OY7rVdtE/VGsb1frKlDW/aq3qcjGHqmKc8vx0/sz42eEw1okqry3eET16atyu9l776DD9ybV6nlb1g88XzxZVP32qGCuSek1/qXiAqeaay8Wz5pQxsXperfKo3jlsFM8mSfLLV8b9x0/tjN+lXSz6wMNYf11cGt/v6hnq4nrdD1f9R7X+WtWXzQlr4e+7PH6HXPUPVbvZm1Anq/lmNa5Wlot2N+XdSjkPu/L0MH1/5ewwfXfl4TKGueKt4tXt8f1++9OXh+lT5iez9pNveMV4nenxh15WxrBeXGf5irm4zPddref171u/MUyv1rKqop7ynFep+vLqGat6J1HNwZJpffHIWjF3mDJPmzWGWfvApG5bH/34uP0/sTi+F5/yoa8uY1h8298dpv/s14zTP/R1rxim726O/5YoSR79mPEaysJD4/5h4c2fOz5BsRa+t1j3s8+uj9vuuWLdcPmR1wzTLxdrPEnyo+9dH6Y/ufb4MP1S8bcb3/kz7y9j+LrxZQAAHCu/gAMAAAAAAHeh2nwDAAAAAAAAvHT4BRwAAAAAAAAAAAAA4IHRZ/yVMgAeTH4BBwAAAAAAAAAAAAAAAAZswAEAAAAAAAAAAAAAAIABG3AAAAAAAAAAAAAAAABgwAYcAAAAAAAAAAAAAAAAGLABBwAAAAAAAAAAAAAAAAZswAEAAAAAAAAAAAAAAIABG3AAAAAAAAAAAAAAAABgwAYcAAAAAAAAAAAAAAAAGLABBwAAAAAAAAAAAAAAAAZswAEAAAAAAAAAAAAAAIABG3AAAAAAAAAAAAAAAABgYOG4AwAAAAAAAAAAAAAAOCr7+/24QwDgPuQXcAAAAAAAAAAAAAAAAGDABhwAAAAAAAAAAAAAAAAYsAEHAAAAAAAAAAAAAAAABhaOOwDg/rK5tz9Mf+rK5jB9v/fyHHPFOU4tzg/TL27sDNN/8VIrY5gvtic+t/KaYXq1u3Fzd3yNVy7sFjkke311nMf7rw7Tt/ZWijOMyzFJdvYuDdMX58dlfWZpPAydX62HqStb47LcKerT+vbeMP3nn7texnBjZ5xHdZ2V9e26PlSqGJYXxrV2ca5uN1Xb3CruxdryOMaqnJ+7cWqYniRrj33SMH2vqPYrl8Z92PLCdhnD8kJdliNLxb2an3Cvtos+aG9/fJ1VDK94qOpfkuWio726Na73lzfHN+sDV7fKGKqyOn9maZi+ODe+hmrMq8o5SbaKe1W1uyq9aldJUnTlWVmYLYYq/yTZKcrqwvr4fp8p+pcqxiRZnfCdkb3idl/erPv6/Ywz2S5OMt/GhV3Nf5LZ6/W1Ytzd2h237Slzyb3iO1W7qurbxoR2c3VzXNZzRf+zXvSBVX1K6ra1U2Ry7vTiML2aOyTJflGWVdt8+ZnlYfrZ5dnaZZIsFPeiGlafuToe+x8/My7HJCmqZFaLLLZ2x+W8U+Sf1Nd5tZhzLxbVYXtt/PyUJKfOv3qY3ueKueal8b2YMp9dLsa0ql09W4xHGxt1/zLysvYAACAASURBVFH1oxc3xtf5U7k2TF+fMN5Uc6Qpc5hZnD89noMlyUc8cnqY/pqHx8/Lv3DpxjD9kVN1DNXzTdXPnioazsvPjvvApH7Oq8a8lSKGcxP62Wo8WCmef6p+eH5rvYyhz4/LYfEVrx6nv+ojxulP/sowfX7lB4fpSbLw5OuG6XunHxmnr71ifIIJzbKqc6cXx/fioaXx8dt79drH1e1xndwt+pe1ok7+2LPjPjBJNvcnDIwDF66P+/qq7SfJ2aXxdVRzpOo5rnreTpL3XN4Ypv/MB8ZtrxpXq2KoyiBJziyfG8dwragvK+N16in36tFiPHhdMR5Va0BLEx6Iq+e4i8XYPpfx8SsTli1PF/ermmatFSep1leSZGuvnkcNY1geT6qfu1Gv6VXPitU6dFXlrhZrXVM8tDK+zvddG7eL6v3PlHng+dV6HjVSjVcXrtf36gNFX12lV/Ph914Z96FJ3U9Wzx6VqpymnKNaj3+4eD9zrhXPTxPWwau54AdujPu4ixvj9Cn9y04xN6jWDR8t1i6q/JO6j6rudzXvn2KlmD9U/cuTa+N3AlcmPItWZf30pXHbe3fxPm/Ku5Nqrle9W6nSzxVzi5UJ623VM9j+fvH+eGs8Fpxbfb6M4VxRH6rn5WrN8NFT9XraWhFD/X54nL65V48377s2/k71NwuXirH/WrFGnCRni768ms8+Why/W5TjBybMoU4XbbuaK1bt4tqE9+hV26z6h2o8OXumnlRXc4OqLKt5WNWPJ8l8G+fx4+8bPweeKZ4L5lt9L85/9O8apn/kt/zXw/S2Pz5H263fD18o/k7m0dXxdX7/U+O1h6o+PXvtuWF6kjxTzDc/rHgWfb6oT+eqlw6px+7qb1h+oRiXq783AAA46cxmAAAAAAAAAA5Qbb4BAAAAAODBYQMOAAAAAAAAAAAAAAAADNiAAwAAAAAAAAAAAAAAAAM24AAAAAAAAAAAAAAAAMCADTgAAAAAAAAAAAAAAAAwYAMOAAAAAAAAAAAAAAAADNiAAwAAAAAAAAAAAAAAAAMLxx0AnDSttZcl+egkr0rycJLTSa4luZTkQpJ39N6fP74IAQAAAAAAAAAAALhbvffjDgGA+5ANOA+w1tqHJfmNt/w7d8BX39x7f+shnfOtST75MPJ6kX/Ve/+Uuz24tfYxST41yZuTfFKSRyYc8+4k/zTJX+29v+tuzw0AAAAAAAAAAAAAAJx8NuA8IFprr0nyhtSbbR4IrbU3JvndL/x79V1k8dokfzTJH2mtfUeSL+y9P3N4EQIAAAAAAAAAAAAAACeFDTgPjncmWTvuIE6QH04yfwj5tCS/I8knt9a+oPf+bYeQJwAAAAAAAAAAAAAAcILYgAMH20/yviQXklxMcjbJhyR5+W2+v5bk77TWFnrv33o0IQIAAAAAAAAAAAAAAEfBBhxOgi9K8mMzHH/1kOJ4V5J/mOQHk/xQ7/2D8m2tfXiSP5DkDyV5+JbkuST/d2vt6d77DxxSTAAAAAAAAAAAAAAAwDGzAefB9lSSH03yjhf+73Mv/O+j9jO997cfw3mTZCvJ/5vkb/Xe/3X15d77LyT531trfy3J30vySbd8ZT7JN7XWPq73vnvo0QIAAAAAAAAAAAAAAEfOBpwHx1NJ3p2bG21+NMk7eu/PvfgLrbVXH31Yx2YzyVuSfE3v/Zk7Pbj3/kxr7bcm+f4kb7gl+aOT/N4kf3vWIAEAAAAAAAAAAAAAgONnA84Dovf+Mccdwwnz+rvZePNivff11tofSPITufnLNy/2ObEBBwAAAAAAAAAAAAAAXhLmjjsAOA6zbr55UT4/neQ7D0j6tNba4mGcAwAAAAAAAAAAAAAAOF5+AQdm9z1Jfsctny0neSLJ00cfzmyevrwxTF9aGO/bq9KnmJ9rw/SN7b2Z8t/vvfzOzv74O3v7M4WQK1u7w/SrmzuznSDJtaKcqnLY2JmtnJPkoeXxMDPXxvd6ZUJ9Wt8el+WN4joub8xe1tu74wqxV5R1dfysdX5KDGf7+F6Ne4abtoqGsbM3jqGqD1Wdft+1zWF6klzZGl/nYtH/VH1DdY03YxjXub2y/xmnV31oUvfV1TlWF2/94bdf61SRPuU7VX1aWRgfP6UcKkvz43KqrmFnf3wN2xMGk+XiXlX9bFVnp4yJs7aLU4vja6jafpIsFOc4tzre93ymKKe1Ij2px5OqHKqxfcqYV6nmF8tFnV6cr+/Fczdm68MqW7vjcp6b0LZXiuusVHOgSXW2KuviOraK4+cmtN35Ks6iD6r60Z3tKXPq8TlWi/pStbuHVurxpupqZx0uqhh7r/+7DHsp5orF/KJKn6IaD6oz9D4uyDah3VS2ijnzxWJeXx2f1P3o4lzVtsfpK6uz9/XV/KPqfzZW6meLqp+rhouqSlb17ZFTS+MMkjxxZvyd08X848bO8jB9Sl9fDTebRZ1bWx73D2sT+rjKUnGzqrFiypy6KOosFlm0veKZfKd+zmu96uyLsixi6PvjdtOKtp8kbWF8v9vu+DrbftE/tTqGteXxdxZSjNutWPtYqse8x5a2xl8ormPu2vuH6Wc+9OVlDNd3xtdRTbO2904N0x9ZrdtuNa4uF2338ua4Tl4s0pNksejELhXj6trKbGt+j56q60sVQ6WaB1ZjSZKcXRrfz2qtarV4znvv1aJNJHm4KOuqL39oaRzDlGXuG0W7WSjGi+p5d7UaTJLcWB+X9dnlaq1qHGNVp5N6rvf+6+P7WR1fzZGubI7Hgil5VM/UK8V/t3FvwnS2WqOp1omeOD2ep62t1O2mek6r1i7Wi7Y9Zf2kUvWTu0UnNmW+Wq1FVZdRzXevV+U0YY5Utf9q/bRapzpT9ONJPV5UazhlOc64TpXU97t6DqzeQSX1s+aUdeR7efxRmfUZ6TDeS1T2Z1x/ndJ/lDEU93OnaFjVusGz63Vf//TV8TNU9Q6pWgOaUs6zvjOo3t1OeT9cjWnVe8tqflG9h58SY/WdzWqduqizhxHDmWIuWNX5qi5MMaWvnjWGai5Y1ukZ23ZSP0OdKeYGVT+7NL9axvD+68V7ruI6LlzfLs8x8oHiuSFJ1ou2Wc3zrhTP09X75ynnqNpFdQ1T1usBAE4yv4ADs3vqNp+/7EijAAAAAAAA4FBN2UgAAAAAAMCDwS/gwOxut+3fdn0AAAAAAAAAAACAE6bP+AuDADyY/CebYHavvs3nzx5lEAAAAAAAAAAAAAAAwL3hF3A4MVprC0keS/Jobm4Ou5jkUu99/VgDq33qAZ9dS3LhqAMBAAAAAAAAAAAAAAAOnw04nARf2Fr700nemGT51sTW2sUkb0vyQ0n+ce/95444vttqrT2a5DMPSPru3vveUccDAAAAAAAAAAAAAAAcPhtwOAl+d5F+Pjc3uXxmkj/bWvuuJF/fe3/rvQ5sgi9LsnrA599+lEG01t50WHn9me/7+cPKCgAAAAAAAAAAAAAAXhJswOF+05J8RpLPaK19Y5Iv6b1vHksgrX1ski8+IOk9Sf7B0UaTtx3x+QAAAAAAAAAAAAAA4IExd9wBwAy+KMnbW2uPHPWJW2unknxLksUDkr+0975zxCEBAAAAAAAAAAAAAAD3iF/A4bj0JD+V5HuSvDPJTyd5X5KrSfaTnE/yyiRvSvLpSX5bDt4w9rFJvqO19lt67xtHEPev+r+S/LoDPv/23vtR//oNAAAAAAAAAAAAAABwD9mAw1H7xSTfl+QtvfenB9979oV/70jyl1trr03yDUk+84DvvinJNyb5/EOO9UCttS9P8nsPSHomyRccRQwAAAAAAAAAAAAAAMDRsQGHI9V7v6tNMr33dyf5rNbalyb5ugO+8vtba3+p9/7jMwVYaK19XpI/fUDSdpLP6b0/dy/PP/CJh5jX2w4xLwAAAAAAAAAAAAAAuO/ZgMN9pff+9a21tSRffkvSXJKvTvLb79W5W2u/M8k3J2m3JO0n+bze+9vv1bkrvfcfPqy8vvpfvOuwsgIAAAAAAAAAAAAAgJeEueMOAO7CVyT5+QM+/7TW2tl7ccLW2qcn+bZ88Ka1nuR/6L1/2704LwAAAAAAAAAAAAAAcPz8Ag73nd77bmvta5P8rVuSFpN8WpJ/dJjna619apJvT7J0QPIf6r1/82GeDwAAAAAAAAAAAIB7Z3+/H3cIANyH/AIO96t/lpu/PnOrNx7mSVprvznJP0myekDyH+u9f9Nhng8AAAAAAAAAAAAAADh5bMDhvtR7v5DkvQckPXFY52itfWJubvQ5fUDy/9J7/4bDOhcAAAAAAAAAAAAAAHByLRx3ADCDC0mevOWzxw8j49baJyT57iRnDkj+U733rz2M85xE83NtpuP3DuFnGWeNYa6Nj6/Sb35nnD4/4/bF+SL/c6uLubK1O/zOvf4JzFnvQ5LMFXlU5TAlhOp+zlfpxUkOpU7PGMNhqGKY0i4qdR6zleV+Hx+/NyH7nSlfmuH4nf39Mo/t3fF3DqPOzaqKsbKzVx+/U9T7Wct61mtIku3iOqoYqmtYWZjP9e1xX1/lUbWLut3U9W2u39s+akofWF1HNd5UFicM7ItF21xeGMdw4frWMP0XLt4oY7i6uVN+Z+RVDx/0o47/0ZSxYGNnb6YYqv6h6qb39npOLc4Pv7Mw40Ttxs64nKfUl62qD1qYLcZqXE/qst4s0q9sjvunGxPqwubu+DsrRVnuLM++ZFH1c8Vl5moxJ3/m2maZ/uTauO1VY//51cVh+mZR36o2cxiWij5wcacel3eXx3FuFPWp6mer56ukHvsrV26M+4+lCW2/Ghd3ivpS3e+qviQTntPK57ziGatolxeub+XcyrjeV1OYakpdxTBt3aCo93Pj+71YFPRhPCZWlzFrejJhLteLOrc/btutOn5CHn23mEMVx1fpZ3/DG3Pjp3+8yGN8HW2v6KOKcphUXdq4TpZlXZTD3Fw9bre98b3oVYy743F3qerAkuz38Tl60T9UpzhVjIlJsl/csfn9cTlV892FCR1IdR1V+uKMndSljZ2cK+Y4lWpMm2vjOru9V9fZ9WLOe22r6MOKYrpwfbuMoZp3X9oY15dqbjBljlTFUM3rV4sYzk6Y9z91ZWOYXs0/qhjWi/WZpB7bqzyqucOlG+P6sLFdP4OtnRq3q4vr43McxrpktV62tjyO8Ubx7FDV+Zt5jMuqWmdaL9rF6lL9jDXrnLhqV1OWubeKZ6iqXextVOuWs6+/VutM1Zj3fNFupszrq/GoWo+r1lemrOHsFeVQ3ctK1faT2d9TPVc8D1ftLqnb7nqxiDPlmbuysVTMH2Z87zBhujqzqn+o+ulyXTPJldTj5ki1ZngY73cqp/ZmXy+rynrWd69nVuo5UjVeLC+Mr/PUYrE+uz9Of/zs8qR14pFqjrVyCG27GrurGNaKezHlXu8W48XyjNd5Zmn2tfRZ15GnPCeeLdaAzxT3qjrF8oSOdm2limG2+lCZ0maq8ai6V9WYOOVe7xTrs1XbPH9maZh+FH09AMC95BdweKkZz+AnaK29MTc335w9IPmre+9fNes5oDLlxScA97dq8w3wwY5iIwEcpmrzDfDBqs03cNKUm2+ADzLr5hs4atUfZQIAPIhm3XwDAABwv7JizP3soF+7uTpLhq21j0/yPUnWDkj+c733/22W/AEAAAAAAAAAAAAAgPuPDTjcl1prjyV51QFJT82Q58cl+d4kDx+Q/Bd67192t3kDAAAAAAAAAAAAAAD3LxtwuF99ZpJ2wOfvvJvMWmu/Psn3JTl/QPL/0Xv/krvJFwAAAAAAAAAAAAAAuP/ZgMN9p7W2kOSgX6PpSb7/LvL7qNzcfPPIAcl/pff+P91pngAAAAAAAAAAAAAAwEuHDTjcj74iyesO+Pytvfen7ySj1trrk/yLJI8fkPxXe+9/+M7DAwAAAAAAAAAAAAAAXkpswOFItNbe+MJml1nz+ZIkX36b5K+9w7w+PMm/TPKyA5L/zyRfdGfRAQAAAAAAAAAAAAAAL0ULxx0AD4xPSvIXW2v/JMnfSPJ9vffNqQe/sFnmG5J81m2+8g97799zB/l9aG5uvnnFAcl/I8n/2HvvU/MDAAAAAAAAAAAA4P7Q9/eOOwQA7kM24HCUWpLf+cK/9dba9yZ5R5KfTPKuJJeTXE2yn+RcklcmeVOS3/bCv9v9YtO7kvz3k4No7fHc3Hzz5AHJ/ybJNyf5Ta21qVneztO996dnzQQAAAAAAAAAAAAAADheNuA8IFprr07yS3d5+PdP2Izymt77e+4gzzNJPvuFf7P46SSf3nu/fAfHfFSSD7tN2m9K8rYZY/pVX5nkKw4pLwAAAAAAAAAAAAAA4Jjc7hdF4KTbT/INSd7Qe3/muIMBAAAAAAAAAAAAAABeumzA4ai8O8kvHkI+20n+XpI39d7/WO998xDyBAAAAAAAAAAAAAAAuK2F4w6AB0Pv/Z8m+aettVcl+c1JPj7JxyV5XZKX5/Z1sSf5uSQ/kuTtSf5R7/3CvY8YAAAAAAAAAAAAAADgJhtwHhzPJnnTPc6/1Ht/b5JvfeFfkqS1NpfkiSRrSVZz85eZriS5nORy7333MAPtvb81STvMPAEAAAAAAAAAAAAAgJcuG3AeEL33rdz8BZkTp/e+n5sbeCZt4gEAAAAAAAAAAAAAADhKc8cdAAAAAAAAAAAAAAAAAJxkNuAAAAAAAAAAAAAAAADAwMJxBwCcLGdWxt3CfGvD9MW5cfoUc0Uee/t9mL68MN5beGpxvozhxs7ezHmMbO7uD9MXd+py3CvuxXwbX0My+72qlPVlfnyvVop7mdR1bqM4vqpPUxxGHrOaL8phrrgXVbvZ3RvX2aS+F/vz4/RTi7PtC14s8p9yjqpO3si4Xe33Ooaloqzvh/o0a31Lkr3iMvf7+AvbRT+6VaRPUZ5jfpy+XbSb9c3dO47pVlW93ykK+vp2HUN1v6ty2lxZHKZPabvV/byysTNMX10aj9v7E9pdNTeovP/a1jC9KsckuXxjfJ2Vqv9ZKvrAJNmYsRyqPq5K3ynmqkmysjvbeHJpxvqU1HOgnf1ivCnKuco/qfugqs6tFPVhc7euC9U5qrGgUgwVSZK5Ys5bzV/OrY7rXPVcMOXx6Klrm8P0K1vjvnq96Mure5nUc8H17fH9fuTU0jD9wvVxH5gka8vjsq7aZjWPe/z0OMakrpPVkHW2uIYpz5HVPKp6RlouymFrwry+inPW5/69ovE+cXq5zOOxU+MYq3n/+vZ4fjLF4tz4HDv747JeXpj9+ajqBxeKcbW6l6cnxLDUx31Q274+zmCvOH7rWhlD2x33D3vPPzvOoLhX+9evDtNXnnx1Lr3zJ4bfWS3ymNsYp5flOFfPkRbnx/1g29seZ9DH5dTn63bVttbH6cXxczcuD9MXz9d93F617lg811cl3Xaqlahkfm7ch1V5PLTy8DB9d8Ik69Fi7L7Xxz88YV5f9bNbe+P5yZml8TkeXqnH5dVi3K3m5Q8tjY+v5j9JPU+7sVONN+Pj9zfq+lJd52oxd6jmFlPWwqoYqjlUta5Q5b/fezluVjFUc8lq/WWKaq1p1nXHKettV4q1i+r55MbOOP3KVr02Uj2LVunVNVTrK1O+s1E8Y005R6WqD+fPzNaXl8/8E+rbtSLGhaJdXCuel6esn5wtxqQbxb2q1sqmtO0qzlnrwweKdYckef76eC5Y9fWPPzR+jptSDk9fHM+BqjXgqpymxDDr+mt1jqrtr52q59TVvaieuas+bkrbrdaRq3lYdY4pa+VVHtW9qJ7Zp6jymHXcnVIOG8V7y9Wl4nm3F31g0cddXC+eIzPhvUSRXq2lV+0qqe9FteZf/e3GlPXXnSKG6j1V9Tc01XvVpH5nWOVRzYfnZ/wbmqTuw2Zdv51yjupezdq2p8RY/d3WQlHnThf98JT13bNFu6hieKRYjz+Md/kAAMfJL+AAAAAAAMBdqDbfAHD/O4z/8BgAAAAAAC8NfgEHAAAAAAAAAAAAAHhg9P3619QA4FZ+AQcAAAAAAAAAAAAAAAAGbMABAAAAAAAAAAAAAACAARtwAAAAAAAAAAAAAAAAYMAGHAAAAAAAAAAAAAAAABiwAQcAAAAAAAAAAAAAAAAGbMABAAAAAAAAAAAAAACAARtwAAAAAAAAAAAAAAAAYMAGHAAAAAAAAAAAAAAAABiwAQcAAAAAAAAAAAAAAAAGbMABAAAAAAAAAAAAAACAARtwAAAAAAAAAAAAAAAAYGDhuAMAAAAAAAAAAAAAADgqfX/vuEMA4D7kF3AAAAAAAAAAAAAAAABgwAYcAAAAAAAAAAAAAAAAGLABBwAAAAAAAAAAAAAAAAYWjjsA4GTZ2+/D9Pn5Nkzf3Nsfpq8tL5YxFKfIyqmlYfqpxflh+o2dvTKGjeI7T1/dGqbvFOVQ5f/zF9aH6Uly/sy4HCrrm7vD9I3tupwqZ5fHw8xcK272BFVZlvfiEK5ze3d8jvWtcVlX7e7KjZ07julW83Pjsq7a3U4RY1K3rap/qOwXMTx7ZbPMY+v0uN1UdfL69uztZtb7uTvhXsyqqpOnlsb97OmiH06S5YXxd56/sT1Mv7hepF8fp0+xvDDeq161/aocL0+oC1UeS0WM1fFT6mx1jqoc9vs4hv3ZuoZJqj5wrkif8p3FuXE5zVqOSX0dC0X60vw4hsUJ5ZCifVf9aFUf9or0ap6XJCvFdVb2im52pbiXSV0OZ4p+dNZrSOqxu5ojnVsdz9sXJ8RYnePRU+NzVOlry3V9qPrBqq+v6uS5lXGMjxVzjyS5tDEeD6p7Uc3jqjE3Sc4WdXJxfjwHOr86nvdXdSFJ1lZmW6Kq2t2U/HeKDmCxKuzCmaU6hqqvP7U4rrPL87M/D1d97dLC7M9xI2vLdf+y1sbP5POXPzBMf83DT46Pn3CJVTHsFOPJ0u7GOIb1Z8sY+vy4j+krZ4fpbfvGOIaLF+oYblwZpu9vXB/HsDC+hv3N8fFJMv+y14zTX/m6cQab18bpC+N++KFXv3x8/AS773tqmL5YxJD9um3vnz4//kIv+uo2bpvz6+N2lyR7T/3s+AvFw8HG0+8epq/O1WPewqlzw/S+sDzOoCjr9szPlTHMnX14HMPueG4wt/bEMP2xhz+kjCEZ16lqLDhb9NUbxfNNNZ4lyeVi7bIa85aKzvz0hBhWi7litUZztpivVvO8KR49NU4/Xczz5iesz24W97OaZ1XPy1Mef9aLNblqLrherH9MeR6unh2qZ7AqxnOr4/OvFvcyqdcWzsw45z6MdaTyHMV8dcrzcvWdncVibaK4l2vFs+qUGKrnwMqUdaSt4jvVOnV1fPXeo1qHmpJHZa+YO6xOeAa7Vow31TNaZUo5VPV+e8Z3KzcmtN2q3l8o6sMzl4pniwnlWMVQ2d4dn6Oq01NU66/V3ODi9XFfPqVtV6qyLv8WYMK9Kt85FmP/9u64Ts7a7g5DdQ03vzNbnIdxLyr1vZrtHFPmktU7xVnfc00xa/sv15AnxFjN5ao8qr58Sv/x8IQ5zEj1XnPKPPBKMQeatc5OKYcqzmrsLudAM86Hk/rvbKr35BeujddOHz9brH1k9jFp1joNAHDS+QUcAAAAAAAAgANUf3QJAAAAAMCDw4oxAAAAAAAAAAAAAAAADNiAAwAAAAAAAAAAAAAAAAM24AAAAAAAAAAAAAAAAMCADTgAAAAAAAAAAAAAAAAwYAMOAAAAAAAAAAAAAAAADNiAAwAAAAAAAAAAAAAAAAMLxx0A3A9aay9L8uuSfFiStSTLSW4kuZzkl5L8+97708cXIQAAAAAAAAAAAABT9L294w4BgPuQDTgPsNbahyX5jbf8O3fAV9/ce3/rIZ3zrUk++TDyepF/1Xv/lEPOM6211yT5/CT/VZL/ZML335/k7Um+J8l39t5/+bBjAgAAAAAAAAAAAAAAjp4NOA+IFzaTvCH1ZpsHXmvt8SR/Jjc338zfwaFPJPmdL/z7n5O8+tCDAwAAAAAAAAAAAAAAjpwNOA+OdyZZO+4gTrrW2m9N8reTPH7csQAAAAAAAAAAAAAAACeDDTjwgtbaFyT5ptz+V2/2krwvyfuTXE5yNskjuflLN3NHECIAAAAAAAAAAAAAAHAMbMDhJPiiJD82w/FXZw2gtfZ5Sf5aknZA8ncn+dYk39l7v3jAsaeTfFyST0/yWS/8bwAAAAAAAAAAAAAA4CXCBpwH21NJfjTJO174v8+98L+P2s/03t9+DOdNkrTWflOSv5kP3nzzS0m+qPf+XaPje+/Xk/zQC//+ZGvtNyT57HsRKwAAAAAAAAAAAAAAcPRswHlwPJXk3bm50eZHk7yj9/7ci7/QWnv10Yd1vF749Zq/k2TxlqSfS/Lm3vv77jTP3vs7k7zzEMIDAAAAAAAAAAAAAABOABtwHhC994857hhOqC9P8ppbPruQu9x8AwAAAAAAAAAAAAAAvPTMHXcAcFxaay9P8scOSPrjNt8AAAAAAAAAAAAAAAC/yi/g8CD74iTLt3z2b3rv33IcwZwUF9e3h+kvW1sZpq/Mj/f1XdnamTmG+bk2TD9/eqk8RxnD9XEMa6cWh+nrm7vD9I3tvWH6hWtbw/QkuVacY6Eop2tb4+PXN+t7tbQwX35n5PLG+ByPnKrv5bNXN4fpVVlfvjGOYW+/lzFUtnf3h+lbRfrGzvgakmS+je93VSeXFsZtd0o5bBd1riqH9flxjDtFDNW9TpL1hdnKobqGKv0oLBfXcBjOrIynkMsT+oYqztXFcR6rS7OlTzHrOar6cGpCjNU5qnF3r6gOe0t1267aRZVe3evFubrOLvZxnHtF+qmiPlXpU8wV/fBh1MlKNUeq7kVVn5Jkc29cr6vxqLpXlSn3arEoh+pe7RUhTuln58enyEqRx35RTtU1JMlcca+qcqr68qqckjrOqiyXijpZzXeTpCqq6OlSGgAAIABJREFUxeJ2zvVxBtW9rMo5qcu6OkfVLhYntO3qXizvFunzs13DlO9U5TRru7uZx7hiLxYnmfVeJnW7qcbNpYXx8fu9jqHKo+rrZ1WNZ0nS9sfz+hTpVX2ZFMPe+Flyfm68bjDrNSRJa+P72ctzFM9QE2Loe1UexTNSGUP9nFeWZVlOs8dQmjWP4vhelfPNLw2T2964HPt88SphSgzFd6r6VF7nlHIuyiHFPKwVx5f1KbNfR91/TFhHKvqoavpQjSbVWDGhmy3H3WrMrIaraixIkrmM60OVRyvq02GMqdXcoDpHVc43zfZcX51jSjFUc9pyDjU/2/NRUs/1qrXLKsbqOXDKM9j84r2dp01RrxONy7F6NpnyPFyZK/rhWdfjkrrOVuc4jPcS1dpjFcOs7wymrJ/Muk6UFNdwCM/D1bPBrOtxR+HsynjcT6Zc53h+MV+NR1MG/3tsaaGub3tT5rSjc5QxFGsbE9bKK1VZH0b/Mmu7mDX/KWa9zikxzBpnFeNh3KtZY9jena3tJ8l2sU5d9dVVOVf5T1G//x2Xw5S/mVjamm3eXr7DnlAO1d+XrBd/P1KZMq5X73+r+13FeGa5/jPIWcfuKe93R6p7mdRts8rj8bO3/incrzXlneWrzq0O0y8Vf+tTXcNjJ2BuAAAwi+Nf8YFj0FqbT/L5ByT9zaOOBQAAAAAAgJNpyn9sBgAAAACAB4NfwOFB9alJHr/ls+0k/+AYYgEAAAAAAAAAAADgiEz5RWsAuJVfwOFB9dsO+Ozf9t4vHXkkAAAAAAAAAAAAAADAieYXcDgxWmsLSR5L8mhubg67mORS7339HpzuUw747CcHsa0l+ZAky0kuJfnAPYoLAAAAAAAAAAAAAAA4YWzA4ST4wtban07yxtzc4PJrtNYuJnlbkh9K8o977z83y8laa4tJft0BST9xy/c+MskfTPJZST78gHyeS/Ivknxvkr/be78+S1wAAAAAAAAAAAAAAMDJZAMOJ8HvLtLPJ/nMF/792dbadyX5+t77W+/yfK9LsnjA5+9Jktba+SR/IcnvT9IG+Tya5Pe88O9rWmtfm+Sv9N637zKuu9Zae9Nh5fUnv/tnDysrAAAAAAAAAAAAAAB4SbABh/tNS/IZST6jtfaNSb6k9755h3k8eZvPr7XWPirJdyZ59R3m+Vhubtr5Xa2139V7v3CHx8/qbUd8PgAAAAAAAAAAAAAAeGDMHXcAMIMvSvL21tojd3jcy2/z+WNJ/mXufPPNi31Skh9prX3IDHkAAAAAAAAAAAAAAAAniA04HJee5CeT/PkkvzfJxyV5WZJTSVaSvCLJG5N8cW7+Is3+bfL52CTf0VpbvYNzn7vN59+Y5IlbPvu+JP9tktcmOZPkoSSvT/IFSf71bfL50CR/v7W2eAcxAQAAAAAAAAAAAAAAJ9TCcQfAA+cXc3NTy1t6708PvvfsC//ekeQvt9Zem+QbknzmAd99U25unvn8iTEs3+bzV77of19N8vt6799xwPeuJXlXkr/eWvvcJH8zNzcNvdgnJPnKJP/rxJgAAAAAAAAAAAAAAIATygYcjlTvfeommVuPe3eSz2qtfWmSrzvgK7+/tfaXeu8/PiG7qt7fSPLm3vuPTYjrW1trv5Lkew/I9w+31v587/3ihJhm9YmHmNfbDjEvAAAAAAAAAAAAAAC479mAw32l9/71rbW1JF9+S9Jckq9O8tsnZLNTpH/plM03L4rpra21r0ryVbcknUnyhw74/ND13n/4sPL6U//85w4rKwAAAAAAAAAAAAAAeEmwAYf70Vck+Zwkr7/l809rrZ3tvV8rjt8epP1ykr92FzH9+SR/NMn5Wz7/L3MEG3AAAAAAAAAAAAAAmKbv7x13CADch+aOOwC4U7333SRfe0DSYpJPm5DF5UHaN/fe9+8ipo0k/88BSR/7wi/2AAAAAAAAAAAAAAAA9ykbcLhf/bMk/YDP3zjh2OcGaT9wd+Hc9ti5JP/pDHkCAAAAAAAAAAAAAADHzAYc7ku99wtJ3ntA0hMTDn9mkPbjdxfR8NjHZ8gTAAAAAAAAAAAAAAA4ZgvHHQDM4EKSJ2/5bMpml1+8zed7Sa7MEM/zt/n8kRnyfMl55dmV8ju//vGzw/T3X98epq8sjPcWbu7ulzEsF3kszs22f3F+rg3Tz6zU3fPq0vxsMbRxDEmyvrU7TH/lQ+P7eW51cZg+V8SwtVffq8WiLJ+6vDFM39s/6Me0/qOloi4k9b2ozrGxvTdMf+TMUhlDFWeVfn51fI4rWztlDOub4/qyVtSHh1bG6ZVHTi3lwvWt4XdOLY7v1c5eUR/mx+U4pe1uF31QVV8qU/qGKoYqvTrHqcW63SwvjPPYXR6XZdV/VNcwxWNnl4fpdX0ax/Do6aVcLfrZ00vjcqjazX4f16e1lYVsFWVVlXVlbUK7qEwZu0eqcb26l0ldDvNFMW3tju/VStG/JLOPN2tFu1qcEMPcznjMmtV+cQ37+z2rxf2qrqO6VztFDNVcM6nrS1Uni+GovIYp9udmu86qj0uSFHlU56iq5JRyKNtuMZdMUR8WiyAubuzksVPjeVZVDtWzx5S2u1x8pz7H+Drr9CkxFm17btz/VDFU+SfJXBvX6+oZqno2qWK8GcNseczlEGIo8qhuZ3X8/oE/aPwfXd3ey7nl4n7tjedQrUgv236SVsyj0os5VHGd2S+uocg/SXr1nSK9FTFkf8K4vzt+VuxVHkUI2Z8w3kwoq/E5xjH2nfE1Lrz8Ndl+6t+P86iuo0jvRTnfzGN8HVW7KI+f8fxJ0nfGa3rlvSjmH1PKqa73s6VPule743LoW5vD9LZX3KvqGpLMt/HzyULRTy5UY3/RBW7v9XLtoJqfVI+q1bh8cXMvj58aPyO1vfG9Wpgbl2N5/CFM7Jeqsb8oh8OYIy0tVM/LxfxlQjFMeW4f2e/j46esfdTPSNXzzWz3e3VxvlzD2Zkybt5j1fNulV4+J04oxvKZuhiyqnWHal3z5neq5/7Z1oB3Furjq/XRai27WmeaUqer78zaLqaY9d1JFeOsa+lJslS8W6kcRjlWdbbqfypHca8rU969zPp+pmrbU97Nzto/VOeYNf+kfldW3e+9arI4wb2uU9V8OJn2Dnmkqm9T6uO97menxFCVQ9UPVukrE8bdWedA1bv6w+jrq3tRXWc1R7ox4d1NNae+tj0ej6r6cLZ4B5XU78IWivTqbwHOFu9Vp6jGxOo9VjUXnXKOatytnqfXq78/Kd5ZJMnrHzk1TP/Z564P06t3u4fxngsA4DjZgMNLTfmU0Hu/2Fq7kA/erLPZ+0wrTrd7ujgzQ55H7is//SPvaf7f/u+evaf5c3iqzTdw0lQLbnDSVJtvjsKsL07hqFV/BAMnTbX55ihUm2/gpCk33xyBcvMNvEi1+eZITNksBSfIlP9wx71Wbb6BF5vyH2K416zhcL85CRsuZv3jeDhqh7E5Bo7SSehnT8IGZLgT1eYbAADuD2Z13M8O+rWbqxOPfccBn51qrc3yVx5rt/n84gx5AgAAAAAAAAAAAAAAx8wGHO5LrbXHkrzqgKSnJmbxQwdlm+Sxuw7q4A1BSfLcDHkCAAAAAAAAAAAAAADHzAYc7lefmZsbZm71zonH//PbfP6GuwsnSfLG23z+nhnyBAAAAAAAAAAAAAAAjpkNONx3WmsLSb7sgKSe5PsnZvNjSX7xgM//i7uN6zbHXsn0TUEAAAAAAAAAAAAAAMAJZAMO96OvSPK6Az5/a+/96SkZ9N57krcckPTftNZO32lArbXHk3zObWLau9P8AAAAAAAAAAAAAACAk8MGHI5Ea+2NrbXXH0I+X5Lky2+T/LV3mN1fTXLjls/Wknz1ncaV5C8mWT7g879+F3n9/+zde5RtV10n+u+sx3nlnISEJCQkQEJamvBQeQgiKBdFEUSl27ZleLW59Gig4QqKtrZXRETERkfzEGUwWqBt9TaKFxgtDxUhHVQQRBBEFFEiSUgIJIc8zvvUa94/zkEPxa45d9XetXfVqc9njBrJmXPNuX5rrvda9asFAAAAAAAAAAAAAABsIXPTDoAd49FJXlFKeVuS1yd5T631xLCNSylXJXllku9cY5K31Fr/aD0B1VoPllJema9M6HleKeUjtdbfGjK2H07yfw6o+ota6zvXExMAAAAAAAAAAAAAm6uuLE87BAC2IQk4TFJJ8t2nf46UUt6d5MNJPp7k75PcmeRQkpUk5ye5LMmjkjzx9M9aX2z6+yT/YYMxvTTJ9yX5F6vi/I3TX+z5hVrr6q/knJqolHOTvCTJ8wZULyZ5/gZjAgAAAAAAAAAAAAAAthAJODtEKeWKJJ/ZYPNrSym9aa6stV6/jj73J/lXp39G8TdJnlBrvXMjjWutx0sp/ybJnyXZd0ZVyakv4/yHUspbk7wvyedPl1+a5LE5Ffvd1+j6+bXW928kJgAAAAAAAAAAAAAAYGuRgMN2tZLkl5P8VK31xCgd1Vr/qpTylCS/l2Tvqup7JHn26Z9h/Xyt9TWjxAQAAAAAAAAAAAAAAGwdM9MOgB3j00n+cQz9LCR5U5JH1Vp/dNTkmy+ptb47yTcluX6Ebo4leWqt9YXjiAkAAAAAAAAAAAAAANgafAGHiai1viPJO0op90ryjUkemuRrk9wvyaVZe1usSf4uyYeSfDDJW2utt25SjB8upTwoyU8m+aEkdxuy6Ykkv5bkZbXWWzYjNgAAAAAAAAAAAAAAYHok4OwctyR51Cb331Vr/WySN57+SZKUUmaS3CPJeUn25tSXme5KcmeSO2utS2OPdu34jiZ5YSnlvyT5riTfmlOJQvdJcm6SpSQHk9yW5KNJ3p3k3bXW2ycVIwAAAAAAAAAAAAAAMFkScHaIWuvJnPqCzJZTa13JqQSeLfP1mFrrsSS/c/oHAAAAAAAAAAAAAADYwWamHQAAAAAAAAAAAAAAAABsZRJwAAAAAAAAAAAAAAAAoGFu2gEAAGeHb7nqwmb97ccXm/Xzs6VZf+vRhWb9vvnZZn2S7Jlt5x7v39Wu3zPXrh8mhsMnl5r1K7U265fb1VlaXunGcP7e+ZHm0YvxSGcZk+SuzjSzpb099JbhvD39y9xji8sjxbC7sz3s7WwPMzPt/pP+NtvbJu/o7HcznWVM+vvm/l3tsd43347xyEJ7PST95ew5sKu9Ls7b3d9e5mfacfbGcnGlvd8cW+yvi5nONrvSmUcvxvkhtsneNN15dLbpxc4xbJhtYZhjcUvvGDhMDMuddTHqNj2MUcd6f2e/6S1j0j/OjrpN9o5PSdILc77TRenE0Nveji4u54K9ox0ne+eb+c7xY5hx2jXXnmbPcjuGuc447e5sj0k/zt5+0z/+9Meh93dqRo1x9+xox6ckmZ/prIvuLPrrotfHMOeLltm0288O0X9Z6FxvrnSOP8vta6TU/jV16fXRbd9ZhqV+/72RKkvte6istGOoCye6MdROnPVkp4/59nV9PXm8H0MnzjLXm0cnxs447rrnfXLihuva8xhiLJvtFzvrcojtZWbfiNv9qPUZYhw6++7yifY4dNdlkrK3Mw4z7fN2d78aYl3Uxc5+0+ljprPvZrkTY5K5+X3N+t5ps3cuWCrti7BhTsv9c1qnfSfGYc43WWpvk/Nzu5r1pbOu52d292MY0a4Rr1+SZFfnjLO300dvfQ/zbKJ3f9J7htNb3b32Sf+6vKcXQ/f+Z4htdnFlc+8152f6x/reOPWe0fTaL3buTZL+s8veOPWeC/Tu4ZL+PfnSEMvR1l8X+zvPR/d0DrTd59SdG+6hjrObbNcQ++3eEY8vC53nK+cM8ZyqF0NPL8Zh1kVvrBaW2svZm8cw62JUvRiGeZY16nY9if2i18ckYuw9m+g9PznZ2Z5Gfe6QjP6ea5jzfu/9Te8d0GInyMWV/rF+mGuYlt5y9p7vDvMs/rIDe5r1lx5oX1Nfck77fHbbsf47yd429fe3t589XH9nu/7Cfe1lSPrjsH93e12cv7s91ref6L9r620unzp4rFnfe6dw6YH+/c2l+9tj1VtXf/n5I836K+62txtDT+8eqjeOC519u3fsSJLPHmo/37ig856893sZBzrvdpPk3nvafdy2rx1DzxC/0gAAsKVJwAEm6l896NJphwBskr+48Y5phwAAsKX0km8A2P56yTcAbH+jJt8AAAAAAHD28JsgAAAAAAAAAAAAAMCOUTtf5QaAQfzJJgAAAAAAAAAAAAAAAGiQgAMAAAAAAAAAAAAAAAANEnAAAAAAAAAAAAAAAACgQQIOAAAAAAAAAAAAAAAANEjAAQAAAAAAAAAAAAAAgAYJOAAAAAAAAAAAAAAAANAgAQcAAAAAAAAAAAAAAAAaJOAAAAAAAAAAAAAAAABAgwQcAAAAAAAAAAAAAAAAaJCAAwAAAAAAAAAAAAAAAA0ScAAAAAAAAAAAAAAAAKBhbtoBAAAAAAAAAAAAAABMSl1ZnnYIAGxDvoADAAAAAAAAAAAAAAAADRJwAAAAAAAAAAAAAAAAoEECDgAAAAAAAAAAAAAAADTMTTsAYGv5jY98dlP7nyllU/tnfGbHsKrmZtt5nkvLK6PPhImYmdn8fXf/rvZlyb752U2PYaXWZv2xxeWR6sfh/D3zzfojC0vdPu462Z9mFMNsL/tmRlufvXU1jN4217Nnrn2MO7HUPsaNOv9h5rF3DPvNhfva29yxxXYMK51Vden+3d0Y7ranPVaXHWjHuNzZXnYvHO7GcPPS3mb9hfvaMf7Nbceb9cMcP3pjfcfxxWZ97zg6TAyXHmivr7t1jlG7OhcYC8vtdXXOfP9vSOyea8+j18PRzjjPD3GMO77UXo7OJVIWOzvOTPox9Pro6e03i511lSSznbE60DkOznXazw91edJen2Wpvd/Mzba36fmZ9socZnvp9dEbh92d81HvfHUqhs5Yd2LsbdPzQ9xcjLqco47jMLrbZGc5hxmH2c49c3esu8s5xL7biWEcY9nSO1ckSZbb+25ZXhitfR3iXnWlc01dOitrpX3eLb3+k9TlTZ7HiNfsSVJmO3305jFMDKPGOYbl7Oqti7n2+WYsett1Z7/ojVNdONEP4cTRdv1ye5wWDrXbrxw71I1h7pwD3WlaevvNytF+DOmcs+pie13MnDjSrC+LJ7sh7NrTPtbu6pxwesfq5ZVe/8NcI7Wn6fXQaz+z1B+nstTerud27Wt30Dkfzc3s6cbQ07vs7w313BCHwKXlzlh25tG7LxjmLwWOej3auyYe5r1F756696yqN4/uvcVs//pkecT7wJ7F+X7/vX3vgr3tc96ezn3/OJax91pi33z7OLx/V3/HOaczzZ3H2+eT7nODIe7Jb+88Jzqwe7Rnk3edaPc/31uIbP7z9POGWMbeM9refdyRhfYyDLO93HWitz2Mdhy+eYjn0L177uOdddVrv3uI7aGnNw69eQzz7qT7TK5zLO+NU6/9JN7N9s5XK0McZ3vvHXrnzN47qqEeC3TC7C1n7zi6b4jn0L3l7K3v3jFwcaUfw6jbTC/G3vYwzL59snPi7b33+PzR9vZy14n+uaR3LD/ZedfWu05bHOJ3Hu7onDePLPSOL+1jee+8n/Sf+fW2yd72cPBYP4beUPXWVS/GWw737/N6hnmG29I7vgzTf+99X2+/ObnUHqfe9UuSnLunfb/7hSOdZzRjeJcPALCV+QIOAAAAAAAAwACT+MNAAAAAAABsDxJwAAAAAAAAAAAAAAAAoEECDgAAAAAAAAAAAAAAADRIwAEAAAAAAAAAAAAAAIAGCTgAAAAAAAAAAAAAAADQIAEHAAAAAAAAAAAAAAAAGiTgAAAAAAAAAAAAAAAAQMPctAOAQUopM0muTnL/JJcl2Z+kJjmS5NYk1yX5VK318CbGsC/JQ5P8yyQXJNl1ev43JPl4rfUfN2veAAAAAAAAAAAAAGyOlZXlaYcAwDYkAWcHK6XcN8nDVv2cP2DSx9Va3zuBeEqSxyd5epIn5FTSS8tKKeWTSd6X5PeTXFNrPTqGOB6f5LlJvi3JnsZ01yX5jSSvrbUeHHW+AAAAAAAAAAAAAADA1iQBZ4copVyZ5OHpJ9tMRSnlsUlenlNxDWsmyQNP/zwryYuT/OwIMVye5HVJvn3IJlcl+bkkzy+l/Hit9Q0bnTcAAAAAAAAAAAAAALB1ScDZOT6a5LxpB7FaKWUuyS8l+ZEkZYpxPDzJO5LcYwPNz0/y+lLKI5I8u9a6MtbgAAAAAAAAAAAAAACAqZKAw9SUUs5J8ua0vzhzNMnnk3whyUJOJbtcluTCMcbxwCR/lLW/CHR7kk8mOZnk0iT/Mqe+vrPaM5PUJP9xXLEBAAAAAAAAAAAAAADTJwGHqTj95Zu1km+OJnldkv+V5H211uUB7S9P8sgkT07yHUku2mAc+5O8JYOTbz6U5KeS/O9aaz2jzSVJnp3kPyfZvarNs0opH661vn4j8QAAAAAAAAAAAAAAAFuPBJyd7cYkH0ny4dP/PXj6/yfhFRmcfPPmJM+vtd7Uany6/qYkbyml7EryPUkWNxDHz+bUF21We0OS/1hrXRow788neVEp5R1J3pWvTN55RSnlHaenAwAAAAAAAAAAAAAAtjkJODvHjUk+nVOJNh9J8uFa68EzJyilXDGJQEopT0ry3AFVr6q1Pn+9/dVaF5L89gbiuDLJ8wZUvTvJM2utK535/kUp5XuSvCfJzBlVB5L8XJJnrjcmAAAAAAAAAAAAAABg65GAs0PUWr962jEkSSllT5JfHVD1mxtJvhnRjyWZX1V2IkMk33xJrfXaUsrrkjxrVdXTSikvqrXeMoY4AQAAAAAAAAAAAACAKZrpTwJj9ewkV64quy3JRJNvTicC/eCAqv9Ra71+nd29NMnSqrJdSZ62gdAAAAAAAAAAAAAAAIAtxhdwmJhSylwGJ9r8TK319gmH8x1Jzh1Q/mvr7ajW+tlSyh8mefKqqu9P8rINxDZV8zNl2iFsCTOdcVhZqSO13ylmO8OwYpy2jJky/XXRO/4sdr5NthWWYRLmOzvWMONg1xtO7xjWG+te++3i5FJ75zu5tDxS/V0nFrsx3HhXu37X7KDLun/24c8d6s6j7/AY+ljbMPvuSm1ff+ybb/99hSMLq3PG1++WwydHqj8bDLOuZjsH2uXOteQkLHZiWFpu7/vLQyxCb5u9+dCJZv25u9uPLB52zwPdGI51LiAuP7C7WX/nifYxbHGl3f+Jpf72cuG+9nKe7Ax2b5xmh/jTK+fMtSc6b/dss35356R35a72uk6SmeNfbNYfvfDyZv1dJ9vr6qLOOCf99d3bde917uqP7H653cfay5gkZbl9XpxZONJuf7x9zlu66KpuDF8s7X2rd43Tu26vnWPDMJdQZam9Ta0cbY9D6Xz4uCwcGyKKjuX2ebe3LuvJfgylfQhLWWnHUBaON+uXO+OYJMt33Nqsr0vtbbrs2tOewdJCN4astPfd7imr175zrF882h7HJJnff7QdQieGmQPnN+vrcrv9qU7ax/Ke2lkX3XWZpC62t4elI+39YnmxvU3X4+1xTpK60D5+lM449dqvHL6zG0NPPdHZXvae0+7ggnt15zGX9nbdubXIXOd6t3dvsmuxv672z+9t1i8Mc0HaUE707/FmFtpx1t3tc+bM8fbN7Mze9r1s0r+36F3qHehcxx1a6Jy4kxxbbB9jZkc8vswOcY91snOc2512DIc714qXdu4Lkv79zYnO85ML9ravFRc7y7jYuUdL+vdpvWXo3av22ifJsRFvd1c6HfTuZZP+fXvvWVW///408zPtvfOuk+1zWu9Z+R1DPE/rOXmsfW7fN9/er/bvat9jDRPjqM/0++8U+tvLLUdGe5bVe35y+xA35b0+eu8cd3fm0XunkPT371HfHw9z/Oh30q4+1rmmHvHS4VQIneXY3Xm+0nu/3Gs/jN5+1X3XNsT2Mt/Z5kZd38MdG3rzaPfROcR1l3EYvXHoXeeN45zX04thrnt86Y9T7/jRuxbsHX6GWVW9YRr1fd843s32jtW9dTXMNXUvzu5ydMZ6mHNFbzl711Dd7WkML8H722Tnd4k6zx17yzjMPHrjsNLZMbbC71VshRgAAEYhAYdJemKS1W//TiR545RiWe0ztdaPbrC/N+crE3AeXEq5rNZ68wb7BAAAAAAAYIrG8ovjAAAAwJZTO4ncADDI6H+2AYb31AFlb6+1juNPkq/X4waUXTNCf2u1/eYR+gQAAAAAAAAAAAAAALYACThMRCmlJHnCgKo/mkIsFyS574CqP99on7XWm5LcMqDqYRvtEwAAAAAAAAAAAAAA2Brmph0AO8aDk9x9QPnH12pQSrk8yYVJVpLcluRgrXVxDLF89Rrlnxix348nuXRV2deM2CcAAAAAAAAAAAAAADBlEnCYlIcOKFvJGUkvpZSZJN+d5AeTfEuSc1c3KKV8Isl7kryt1nrtBmO5ao3yT2+wvy+5bkDZoC/tAAAAAAAAAAAAAAAA24gEHCblgQPKbq21HkuSUspjkrw2yYM6/Tzo9M+PlFLen+QFtdY/XmcsVwwoO1lrPbjOfla7eUDZ5aWUuVrr0oh9N5VSHjWuvv7nX352XF0BAAAAAAAAAAAAAMBZQQIOk3LvAWWHk6SU8twkr0wyu84+H53k2lLKC2utL11Hu4sGlN26znkP8vkBZTNJLhhT/y1/tsn9AwAAAAAAAAAAAADAjjUz7QDYMS4dUHa4lPKcJK/O+pNvvqQk+flSyhvW0eaCAWV3bXD+Zzq0Rvndx9A3AAAAAAAAAAAAAAAwJRJwmJTzB5RdnuSXV5UdS/IrSR6f5LIku5NcnORRSV6Stb8k8+9Pf0lnGPsHlB0Zsm3L0TXKzxlD3wAAAAAAAAAAAAAAwJRIwGFSdg8ouzjJ3Bn//pMk96+1Pq/Wek2t9XNGuuKwAAAgAElEQVS11oVa62211g/WWn8myf2S/NYa83h5KeVBQ8QyP6BsaYh2PYtrlO8aQ98AAAAAAAAAAAAAAMCUzPUngbHobWvXJnlSrfVEa6Ja612llKclOZHkGauq55P8VJLv78xrdkDZcqfNMNbqYxL72TeMsa8/G2NfAAAAAAAAAAAAAACw7UnAYVLW+jpMktyR5Ad7yTdfUmutpZTnJXl0kgesqv63pZQX1Fo/0+hi0NduxrEvrNVHa9nHotb6gXH19caP3jSurgAAAAAAAAAAAAAA4KwgAYdJWWjUvabWevN6Oqu1niilvDjJm1ZVzSb5ziSvbjQ/OaBs13rmv4a1+hg0PwAAAAAAAAAAAACmoK4sTzsEALahmWkHwI5xZ6Pu9Rvs861JDg4of2yn3eEBZQc2GMMwfRwaQ98AAAAAAAAAAAAAAMCUSMBhUgYlyiTJDbXWGzbSYa11KckHBlR9fafpFweU3W0jMQzZx6D5AQAAAAAAAAAAAAAA24QEHCbl5jXKPzZiv4PaX9Rp8/lBbUopo+4PlwwoO5n2138AAAAAAAAAAAAAAIAtTgIOk/KPa5TfPmK/g74uM19KObfR5jMDymaTXDZiLPceUHZ9rbWO2C8AAAAAAAAAAAAAADBFc9MOgB3jk2uUHxux36NrlO9PcmiNun9Yo/x+ST47QixftY55bVm75+TlDWWmTDuCbWH33Gx7gqXlTY9hplhX28WezvFnvpPPuLi8Ms5wtqx98+396tjiMOOwM8Zqs/W22ZWzJAe3d22wuDL95dy/q3P8mD07rm9m45y2Xcxvg2vF2V6M2+C+4GOfPzJyH38/6E86MCUH2tV33DWZMDbVMI/hetPsbdY+5l5XNetPLvfP2xcu3NasX9l7t2b93O1r/Q2W047e0axe/Nz17fZJllZGu5fcdeCCdv8XDPobK19u9qa/btbXu7f7WPrUh5v1y18c9AHnL7f7gY9o1s90Pva8sve89gzu3fvIdDJ/Tutv4CT1+FqP7k7HsHCiWb/0uUF/R+fLnfir9zXrF+5sny9uvPavmvVHv9BehkM3HW7WJ8klX3txs355oX2Pdp9vbe83e+7eWZdJVg51Tnoz7XvN+XsNevT5z5bvaB87kmT+3vdr1u85v73NLV/z9mb9zIHzuzGsXHTfZn399F+0Y+gs5+6vf2I3hqy013ed29WsnznR2eYO9Y8fs51pLuxsD8vnDvoY/D+b69wPzx7tX4TNXfSAZv15M4vN+ptPtpfhi3P97eXQSvsYN3+83X55/vJm/e5uBMkthxaa9b1nn7ccaY/TTYfax+EkuWDvfLP+C0fbMfae2Q1zz957xjJTlpr1vWc4xxb71xZHFtrTHD7ZjmG2s66We88+x/D8ZXdnrBfL5j/j6S3Hyc47g/27+tfUd5xob/ej3rMfPNbuf5hpZjshHOusikm89xhmv2gZJsbeuuhuL713Apv/CioznWUY5hlxr4+e3jgMsy562+Ryp4/ecp63p30uSfqvXudnes+p2+Nw14n2cfpUH+36/vmosxCdU94wx7ieUc95w5xvevNYHvGcNcy1QS+GE0vtldm7Ptm/q/OOO8mBzvo6p9PH8c4Gd/BY+xorSeY7O29vnHrb7K2d67wL9va32d66+Myd7YvqR9xzf7N+YYhnXZfubx+D9nS2ud61xTDuON7uo7cYe+ba7XvXecno15Pnd47lV5y/p9vHrs7B/shQ77nXdv+7t5+dJsnxpfY4HDrZPk72jqOXn9u+09vVO+kmOW9Pe9/q9XG4swx/d7D9rCtJZrKvWd+9Duua/vtlAIBRbP3fqOFssdZvFbTfYPWt9Xa59WWdv04y6Anb12w0iFJKWaP9xzbaJwAAAAAAANPVS74BAAAAAGDnkIDDRNRab8vgr8G0//xj36D2R2uta/7ZttN1Hx9Q9Q0jxPGgDP5zvX8+Qp8AAAAAAAAAAAAAAMAWIAGHSXrXgLKHjdjn1w0ou36Idu8ZUPbNpZSNftf5CQPKFpP88Qb7AwAAAAAAAAAAAAAAtggJOEzSmweUXVhKeehGOiulnJvkkQOqrh2i+dsHlJ2f5Ns2EkuSpw4oe2+t9fAG+wMAAAAAAAAAAAAAALYICThM0p8kuW5A+XM22N/Tk+wbUH7NEG3fn8FfynneeoMopXx9Bn/J5/9db18AAAAAAAAAAAAAAMDWIwGHiam11iSvGFD1tFLKw9fTVynlkiQ/PaDqpiR/MGQsrxlQ9YRSyuPWEUdJ8osDqm5N8rvD9gMAAAAAAAAAAAAAAGxdc9MOgB3nDUl+NMlVZ5TNJXlTKeVxtdYbex2UUg7kVHLLhQOqX1ZrPTlkLP8tyU8kuWhV+a+XUh5eaz04RB8/keSbBpT/11rriSHjAAAAAAAAAAAAAGBC6vLytEMAYBvyBRwm6nRyzLOT1FVV903y/lLKE1vtSykPTfLeJN84oPpjSV6/jlgOJ/nPA6ruk+SaUsoVnVj+U5L/MqDqH5L88rBxAAAAAAAAAAAAAAAAW5sv4OwQp5NJPrPB5teWUnrTXFlrvX6Yzmqt7y6l/EKSF6yqujzJ75dSPpTk95L8bZIvJjkvpxJ0viPJ4zM4cexgkqes4+s3X4rl10sp35XkKauqvjrJJ0opr0ny5tOxnExyaU598ea5SR45oMuFJN9fa11YTxwAAAAAAAAAAAAAAMDWJQGHaXlhkouTPGNA3SNO/wzr1iTfXWu9YYOxPC3JNUkevqr8nCQ/cfpnGCtJnl5r/fAG4wAAAAAAAAAAAAAAALagQV8SgU1Xa61JnpXkJ5MsjdDVR5N8Xa31gyPEcijJtyV5zwhxHE3y1FrrG0foAwAAAAAAAAAAAAAA2IIk4DA19ZRfTPKQJO9MUtfR/LokT8+p5JsbxxDLHUm+Pcnzk9y1zubvSfKwWuv/N2ocAAAAAAAAAAAAAADA1jM37QCYmFuSPGqT+9+QWusnkjy5lHJVkqckeWySq5NckmRvkkNJDia5OcmfJnl3kg/UWkf5cs6gOJaTvKqU8oYk/+50LI9Kcs7qSZP8Y5J3JfmNWuuHxhkHAAAAAAAAAAAAAACwtUjA2SFqrSeTfHDacbTUWq9L8vLTP9OM43CS1yR5TSmlJLk8yQVJ5pMcSfLZWuvRKYYIAAAAAAAAAAAAAABMkAQcaKi11iSfPf0DAAAAAAAAAAAAAADsQDPTDgAAAAAAAAAAAAAAAAC2Ml/AAb7M/Ky8vCSZKaVZv1LrhCLZ2nrjdPm5u5v1Nx06Oc5w2Oa+9pJzmvXHFlea9R+55cg4w9myHnJB+zj9iZn2fpcktx5t73vLDnFDucf+Xc36G+48MaFINtc9zmlvUyeXjjfrJ7E9nfOB327Wz9zryZsfxIjmZ9rn1CRZXNncwZzth9Bdn8P0sRPs39W+1T6ysDShSICd5s9vPjyGXvZ26nv3cZe1q+c69fd+UKf/MVjo1H9+iHPuXCfOuzrtL39Sp74fQldvOXv1w5i5ul3fvs3r15//mPVEszGPa1f/H1ec1+1i/o72x7P/9Ek/0Kw/8dtva9bf2pn/V919X2eK5B++eKw7zUguGUMf7dv+5HHPH30ed7SrH3h1e9/8m1uPtjvoVI/DTLl7s34szy176+L2UWfQ32YzlnPa1jbMs/jF5d7KGM2euX4MxxaXm/W9+9nZMvo7h9nOc+ie3jjecXz0ce6NZW8ce4Z5btDTOz5shXv6ffOzzfphjnHn7fb6eyuY39Vel8PY511dkuSyc/c063vjcMvh6b+LG8f5bKWzST2k847pQ0NcW7RHOnnARe15XN95J7DcPQ73D8S988kkzjeLyyt+pwAAAIAdzRNIAAAAAADYgF7yDQAAwNnm8V910bRDgCTJxf2/mdF1XuePg3zVxQdGnwlj8eBLx7DCydfd+/yR+7BfAAA7nQQcAAAAAAAAAAAAAGDHqCujfUEQgJ3Jd2EBAAAAAAAAAAAAAACgQQIOAAAAAAAAAAAAAAAANEjAAQAAAAAAAAAAAAAAgAYJOAAAAAAAAAAAAAAAANAgAQcAAAAAAAAAAAAAAAAaJOAAAAAAAAAAAAAAAABAgwQcAAAAAAAAAAAAAAAAaJCAAwAAAAAAAAAAAAAAAA0ScAAAAAAAAAAAAAAAAKBBAg4AAAAAAAAAAAAAAAA0SMABAAAAAAAAAAAAAACAhrlpBwAAAAAAAAAAAAAAMCl1ZXnaIQCwDfkCDgAAAAAAAAAAAAAAADRIwAEAAAAAAAAAAAAAAIAGCTgAAAAAAAAAAAAAAADQMDftAICtZX6mTDuEbWG2GKdhzHa2p9nOMC7XIeZhVZw1vnh8qVl/Yqm9QeyUbeHg0nyz/uTyiZHnsVPGcrOdLeM46ilvEuNQF9rb/dmyLjZ7OWaGWtlDnJzJ7Cb/qYth1tVKta4AYBzKynKzfum8e2bujhvb05xo3++OyuM8YJrcewBsru5joB1yGO5d8+6awEPguU2+8B7u+ez0nb93Ph+84fY16+84vjhS/4+597ndad5346GR5gE70TC/e/Hkq++x+YEAAMBZwBdwAAAAAABgA3rJNwAAAAAAAMDZQwIOAAAAAAAAAAAAAAAANEjAAQAAAAAAAAAAAAAAgAYJOAAAAAAAAAAAAAAAANAgAQcAAAAAAAAAAAAAAAAaJOAAAAAAAAAAAAAAAABAw9y0AwAAAAAAAAAAAAAAmJS6sjztEADYhiTgsCWVUmaSXJ3k/kkuS7I/SU1yJMmtSa5L8qla6+GpBQkAAAAAAAAAAAAAAOwIEnB2sFLKfZM8bNXP+QMmfVyt9b0TiKckeXySpyd5QpILOk1WSimfTPK+JL+f5Jpa69FNjvHqJB9NsnuNSa6stV6/mTEAAAAAAAAAAAAAAACTJQFnhyilXJnk4ekn20xFKeWxSV6eU3ENaybJA0//PCvJi5P87NiDO+30V3nekLWTbwAAAAAAAAAAAAAAgLOQBJyd46NJzpt2EKuVUuaS/FKSH0lSphxOzw8ledS0gwAAAAAAAAAAAAAAACZLAg5TU0o5J8mbk3x7Y7KjST6f5AtJFnLqqz2XJblw0wM8QynlPkleOsl5AgAAAAAAAAAAAAAAW4MEHKbi9Jdv1kq+OZrkdUn+V5L31VqXB7S/PMkjkzw5yXckuWjzok2S/Lck+8/490qSmU2eJwAAAAAAAAAAAAAAsAVIwNnZbkzykSQfPv3fg6f/fxJekcHJN29O8vxa602txqfrb0ryllLKriTfk2Rx7FEmKaX8uyRPOKNoJacShJ61GfMDAAAAAAAAAAAAAAC2Fgk4O8eNST6dU4k2H0ny4VrrwTMnKKVcMYlASilPSvLcAVWvqrU+f7391VoXkvz2yIENUEq5OMkrVxW/NqcSlSTgAAAAAAAAAAAAAADADiABZ4eotX71tGNIklLKniS/OqDqNzeSfDMBr05ywRn//lySn0ryr6cTDgAAAAAAAAAAAAAAMGkz0w6AHefZSa5cVXZbki2XfFNK+c4k37eq+Lm11kPTiAcAAAAAAAAAAAAAAJgOX8BhYkopcxmcaPMztdbbJx1PSynl3CSvXVX8tlrrW6cRD2ef5TrtCMZjtrTrD59cataPYxzOlrHcbL11tR3MnAXLALCVrVQn1XFZXtnc/q0rAABgq5gp7Yd27l/g7DSJfX+281JgZYe8IJpJexyqdycAjMk7PvmFaYcwdaP+XsUOuTyZiCdffY9phwAAsCYJOEzSE5Pca1XZiSRvnEIsPb+U5LIz/n04yf89pVgm6on3dwMzCR5cAAAAAAAAAAAAwHTUlU3+y4oAnJVmph0AO8pTB5S9vdZ6aOKRNJRSHpvkmauKf7rWetM04gEAAAAAAAAAAAAAAKZLAg4TUUopSZ4woOqPJh1LSyllT5LXJV/2Le+/SPKr04kIAAAAAAAAAAAAAACYtrlpB8CO8eAkdx9Q/vG1GpRSLk9yYZKVJLclOVhrXdyc8P7Jzyb5qjP+vZTkmbVW3xoEAAAAAAAAAAAAAIAdSgIOk/LQAWUrST7xpX+UUmaSfHeSH0zyLUnOXd2glPKJJO9J8rZa67XjDLCU8pAkP7aq+FW11o+Ncz4AAAAAAAAAAAAAAMD2IgGHSXnggLJba63HkqSU8pgkr03yoE4/Dzr98yOllPcneUGt9Y9HDa6UMpfkDfnyfeL6JC8ate9JKKU8alx91VrH1RUAAAAAAAAAAAAAAJwVJOAwKfceUHY4SUopz03yyiSz6+zz0UmuLaW8sNb60hHj+09JHrKq7NlfShDaBv5s2gEAAAAAAAAAAAAAAMDZambaAbBjXDqg7HAp5TlJXp31J998SUny86WUN2w0sFLK/fKVX7r5nVrrH260TwAAAAAAAAAAAAAA4OwhAYdJOX9A2eVJfnlV2bEkv5Lk8UkuS7I7ycVJHpXkJUluXaP/f3/6SzrrUkopSV6XZM8ZxXcm+ZH19gUAAAAAAAAAAAAAAJydJOAwKbsHlF2cZO6Mf/9JkvvXWp9Xa72m1vq5WutCrfW2WusHa60/k+R+SX5rjXm8vJTyoHXG9awk37Sq7CdqrV9YZz8AAAAAAAAAAAAAAMBZaq4/CYxFb1u7NsmTaq0nWhPVWu8qpTwtyYkkz1hVPZ/kp5J8/zABlVIuT/KLq4r/NMnrh2m/xXzDGPv6szH2BQAAAAAAAAAAAAAA254EHCZlsVF3R5If7CXffEmttZZSnpfk0UkesKr635ZSXlBr/cwQXb02ybln/HshybNqrXWYOLaSWusHph0DAAAAAAAAAAAAAACcrSTgMCkLjbrX1FpvXk9ntdYTpZQXJ3nTqqrZJN+Z5NWt9qWUpyZ58qril9VaP7meOAAAAAAAAAAAAADYXurK8rRDAGAbmpl2AOwYdzbqXr/BPt+a5OCA8se2GpVS7p6vTND5+yS/sME4AAAAAAAAAAAAAACAs5gEHCZlUKJMktxQa71hIx3WWpeSfGBA1dd3mr4qyUWryp5Vaz25kTgAAAAAAAAAAAAAAICzmwQcJuXmNco/NmK/g9qvTq75J6WUb0/yA6uKf73W+t4R4wAAAAAAAAAAAAAAAM5Sc9MOgB3jH9cov33Efr84oGy+lHJurfXQgLrvW/Xvk0neXErpfTVntavWKH9IKeWS1fOotX50nf0DAAAAAAAAAAAAAABbhAQcJuWTa5QfG7Hfo2uU708yKAGnrPr37iTvHDGGM711QNkNSa4Y4zwAGODK8/fmM3ccn3YYwBSUuflphwAAAGtaWa7TDoGzyOzM6kfcX872BsAkrNTNP98srzinMTybC9uNy3YYv3FcnzifAAAwDAk4TMqH1yg/d8R+z1ujfNQv68CmevLV95h2CHBWuv89Rj2tjOYP/u4LU50/AAAAAAAAAAAAAJtjZtoBsDPUWm9L8g8Dqi4esetB7Y/WWk+M2C8AAAAAAAAAAAAAAEASCThM1rsGlD1sxD6/bkDZ9SP2CQAAAAAAAAAAAAAA8E8k4DBJbx5QdmEp5aEb6ayUcm6SRw6ounatNrXW/6vWWkb9SfL0NWZx5YDpr9jI8gEAAAAAAAAAAAAAAFuDBBwm6U+SXDeg/Dkb7O/pSfYNKL9mg/0BAAAAAAAAAAAAAAB8BQk4TEyttSZ5xYCqp5VSHr6evkoplyT56QFVNyX5gw2EBwAAAAAAAAAAAAAAMNDctANgx3lDkh9NctUZZXNJ3lRKeVyt9cZeB6WUA0l+N8mFA6pfVms9OZZIAQAAAAAAAAAAADjr1JXlaYcAwDbkCzhM1OnkmGcnqauq7pvk/aWUJ7bal1IemuS9Sb5xQPXHkrx+DGECAAAAAAAAAAAAAAD8E1/A2SFKKVck+cwGm19bSulNc2Wt9fphOqu1vruU8gtJXrCq6vIkv19K+VCS30vyt0m+mOS8nErQ+Y4kj8/gxLGDSZ7i6zcAAAAAAAAAAAAAAMC4ScBhWl6Y5OIkzxhQ94jTP8O6Ncl311pvGEdgAAAAAAAAAAAAAAAAZxr0JRHYdLXWmuRZSX4yydIIXX00ydfVWj84lsAAAAAAAAAAAAAAAABWkYDD1NRTfjHJQ5K8M0ldR/Prkjw9p5JvbtyM+AAAAAAAAAAAAAAAAJJkbtoBMDG3JHnUJve/IbXWTyR5cinlqiRPSfLYJFcnuSTJ3iSHkhxMcnOSP03y7iQfqLWO8uWcUX0syYsHlN856UAAAAAAAAAAAAAAAIDNJQFnh6i1nkzywWnH0VJrvS7Jy0//bGm11o/lVBIOAAAAAAAAAAAAAABwlpOAAwAAAAAAAAAAAAAAnDVKKecleWiS+yW5W5LZJIeSfCbJx2qtN08xvG2vlDKfU+N7/yQXJdmT5EiSzyX561rrJ6cY3qaRgAMAAAAAAAAAAAAAAGxrpZSS5F8neU6Sb0ojX6KU8tdJ3pDkDbXWI5OJsK2U8j+SPG3M3d5Qa71iXJ2VUh6R5IeTfGeSA43pPpfkfyb5lVrrZ8c1/2mTgAMAADBlszOlO83Kct3UGGbKEDHUzY3hbDE7s7n9W1cAMDmlrjTrl+92eWbvuLE5zeKRxWb97LqjYrNs8mXcWCyvuM5ja3HvAQwyjsdYvcdlm/yobCxm+49wug7sbl+hLHQGYjuM0zBmO8/D9t/+6Wb9cr145BgunGtf1392rr2uFjsrY0+nfZLcdbI7yabbN9++gzl4rD1O3f5v/VR3muV66UjzgPVwvQsAsL2UUh6Q5NeTPGLIJg9O8qokP15KeXat9e2bFtxZoJRytyS/kuQHhmxyzyQ/nuSHSikvSfKyWrf/RbYEHACAMXni/e8x7RBy2fnnTDsETnvwpedNO4SJeMAl5047hOT+z2xWP3EMs/iDv/vCGHoBAOBs00u+AQAAAAAAYPOVUp6U5E1J9m+g+WVJfq+U8qJa60vGG9nZoZRy3yTvSvIvNtB8b5JfSPINpZTvrbWeGGtwEyYBBwAAAAAAAAAAAADYMVZWlqcdAjAmpZTHJXlrkt1rTPL5JP+QZCnJvZNcNaibJD9XSlmstb5sUwLdpkoplyb530nus8Ykh5P8bZIjSS5KcnWS+QHTPTnJW0op31Vr3bYHYQk4AAAAAAAAAAAAAADAtlJKuWdOfflmUPLNHyZ5Ua31Q6vaXJHkx5I8J8nMqjYvLaX8Za31j8Yf7Yb9fJJ3jtD+5EYbllJmk/xOBifffCrJ/5Pk7bXWpTPa3C3J05O8KMl5q9o8KcmLk/z0RmOaNgk4AAAAAAAAAAAAAADAdvPqnPrqymovrrX+7KAGtdbrkzy3lPKHSd6SL0/emUnya6WUq2utx8cc60ZdV2v94JTm/ewk3zSg/PeTfG+t9djqilrrnUleWUp5W5Jr8pXJOz9ZSvndWuvHxx7tBKzO2AIAAAAAAAAAAAAAANiySimPSfI9A6r++1rJN2eqtb4zyTMHVN0nyfNHi277K6UcSPJzA6o+keTfDEq+OVOt9bokT0yyerrZJP91LEFOgQQcAAAAAAAAAAAAAABgO/nJAWW3Zh3JM7XW30zyrgFVP1xK2bPRwM4Sz0py/oDyZwz7daBa6yeTvGRA1beWUh42SnDTIgEHAAAAAAAAAAAAAADYFkopl+fU11VWe0Wt9dA6u/vZAWUXJ3nKeuM6yzxjQNkf1lo/uM5+Xp3k9iH73/Ik4AAAAAAAAAAAAAAAANvF9+UrcyGWkvz39XZ0OqHkEwOqvn8DcZ0VTn+d5n4Dqn5tvX3VWo8leeOAqu8tpcytt79pk4ADAAAAAAAAAAAAAABsF4O+fvOntdbbNtjfmweUfXMpZdcG+9vuBo3v8SR/sMH+Bo3vBUkeucH+pkYCDgAAAAAAAAAAAAAAsOWdTop59ICqa0bodlDbc7INE0TG5HEDyt5faz2xwf4+kFMJPKt98wb7mxoJOAAAAAAAAAAAAAAAwHbwoCR7BpT/+Qh9/mWS5QHlDxuhz22plFIyeLk3PL611oUkHxtQte3GVwIOAAAAAAAAAAAAAACwHXz1GuWf2GiHtdZjST49oOprNtrnuJVSZkopF5dSHlBKeUgp5YpSyrmbMKv7JDlvQPmGx/e0jw8o2zLjO6y5aQcAAAAAAAD8/+zdeZxsV1kv/N9zzsk8kxCGhJBEwDDPIqCiXBSiiIoovqiXScThinJ9Fe91uCDCFRVU9KqvIqKAiiAKqIiAICKQMAk3MochA4FMZE5OzvC8f1QfT59K9a4eq7pPvt/Ppz/de63aaz1VXXuvrt3r2QsAAAAAgFnpPZMWugC2iK+aUHZdd39pje2en+Srx8rOXGOb6+F7q+r7k3xtkqPHK6vquiTvS/LuJH/f3R9YY3+TXt9kcoLSSpw/oexOVbWju3evse2ZkYADAAAAAAAAAAAAAABrVFUPXa+2uvu969XWQeb0CWVfXId2L15mX7N29pT6o5M8auHruVX17iQv7u6/XWV/py9RPun1WYlJ+29Pcqckn1tj2zMjAQcAAAAAAAAAAAAAANbuPevYVq1jWweT204o+/I6tDtpBZ1JfW12X5fk66rqdUme0d1XrXD/Sc+5k1y6xriWWqHottlCCTjb5h0AAAAAAAAAAAAAAADAMtxmQtnV69DuNRPKjqiqI9ah7Xl4QpKPVNWZK9xv0ut7fXfvWWM8k17fJDlxje3OlBVwAAAAAAAAAAAAAACAreDoCWXXrUO71y9RflSSG9eh/ZX6dJK3JPlgkv9IcmGSa5PcnFGSzO2SPCTJo5J8V5JDJrRxWpJ/rKqHd/dly+x3Hq/vliEBBwAAAAAAJrh+7/bhBxx3Ro7ee8PgQ+7xxHsP1n9ypUGNuXlPr7EF9rlxt9dyObzl1se2vdNfyK3wWm+v4fqt8ByAlZt27DOyHufAq3cO31h2zzLGk4PBrinP8+rjv2q4geuuXXMMX941PL3mhl3D87Cm/ar29tb4XV590+6Nbf/Eu0ohmK8AACAASURBVE1/0EVr/31utK3y+wQAgC1sUqLJenxg2bVE+aHr0PZyXZLkRUle3t2fGnjclxe+Pprkj6rqjkl+JclTJzz2rkn+Msl/WWYMB/Pru2YScAAAAKY4+6zbzTsEYAO8+RNfnncIAGxx05JvAAAAAACAW52HzTuAlaqqUzNaXWUz+NPufsqUx0y6g9rwXSyWZ6k2ZpZz0d3/Y5X7fTHJ06rqrUlemVu+Ro+sqsd19xuX0dxB+/quhy0VLAAAAAAAAAAAAAAAbEbd/d55x3ArMGk1lvXIi1iqjaVWbtl0uvsvquqoJH80ofqFSZaTgOP1HbBt3gEAAAAAAAAAAAAAAAAsw84JZYeuQ7tLtTGpv02ru1+W5J8nVN2zqs5aRhNe3wEScAAAAAAAAAAAAAAAgK3g2gllx6xDu0u1Mam/ze75S5R/6zL2nfXre806tD0z67EUEAAAAAAAAAAAAAAAsPVcn+TV8w5iwXuW8ZgrJpQdvw59T2rjmu7etQ5tz9q7k1yVWz6nBy9j30mv7+FVdVh3r2W1mqV+R5P627Qk4AAAAAAAAAAAAAAAwK1Qd38lyQ/MO44V+NKEstuvQ7uT2pjU16bX3bur6qNJvmGs6nbL2H2p53z7JF9YQ1hL/Y621GssAQcAAAAAAAAAAAAAuNXovXvmHQKwep+bUHZKVW3v7rUc3Kcts6+t4tIJZScvY7+lnvNpWVsCzqTX96ZIwIG1q6ptSe6e5KwkpyQ5OkknuS6jk8H5ST7Z3dduUP+V5K5J7p3kNhkteXVIkqszWo7rc0k+3N03bkT/AAAAAAAAAAAAAADcwqcnlB2S5PSM5piv1l2X2ddWdugyHrPUc75bkn9dQ9+TXt/PdHevoc2Zk4BzK1ZVZyZ54NjXCRMe+k3d/c4ZxFNJHpXkqUkenVHiy5C9VfXxJO9O8g9J3t7d16+h/21JvjnJDy3EcfyUXXZX1UeSvDLJK7v7ytX2DQAAAAAAAAAAAADAVB9eovy+WWUCTlWdlOTUCVX/vpr2NolJq91cM22n7r6sqi7OaBGNxe67xnjuP6Fsy72+EnBuJarqjCQPyvRkm7moqkckeXFGcS3XtiT3XPh6ZpLnJXnuKvt/SJI/XmhruXZk/2v5v6vquUlevMalywAAAAAAAAAAAAAAmOz8JFckOXGs/GFJXr/KNh+6RPk5q2xvrqpqR5L7TKi6YJlNnJPk8WNlD1tDPMcnufsS/Wwp2+YdADPz4SR/leQ5Ga3usimSb6pqR1W9JMk7srLkm/WM4TlJ3pOVJd+MOyLJi5K8u6o2xWsLAAAAAAAAAAAAAHAw6e5O8vYJVY9eQ7OT9v1Sd5+3hjbn6euTHD+hfKnVg8a9bULZ/avqtquM51GZnLsyqZ9NTQIOc1NVRyV5U5JnJ6klHnZ9RlmK70nyziQfSXL5OsbwnCS/mqWPhV7U/z9ndNK5bqDJr03y1qo6br1iBAAAAAAAAAAAAADgP71pQtm9quoeK21oYbWYJyyzj63iF5Yon5S4NMnfZzSPfrFtSb5nlfF834SyT3f3J1bZ3txIwGEuFk5Ur0vymAnV1yf5rSTfmOS47r5Ldz+8u7+pu+/X3bdNcqeMTnSvSHLZKmN4SJL/vUT1F5L8eJKTFvX/X7r7ARllAz48oxWFJnlgRqvhAAAAAAAAAAAAAACwvv4moznn4561iraekOR2E8pftYq25q6qfijJIydUfTbJe5fTRndfkORdE6r+W1UttfDGUvHcKcl3TKjakq+vBJxbtwsyOvn8fEaJMA+aYd8vyeTkm9clOau7n93d/9Ldeybt3N0Xdfdfd/dTk5ya5ElJVrrE1+9m8so7/5DkPt39e9195YS+93T3e7r7iUm+O8nNE9p4RlXdf4XxAAAAAAAAAAAAAAAwoLuvz2ghh3FPq6q7LbedqjosyfMnVH20uycloCzVzlOqqid8PWWZ+59VVWuey19V/0+SP1ii+kXdPb6qzZDfnVB29yRPWWFYL0iyY6xsZ5I/WmE7m4IEnFuPfck2v5Dk7CS37e47d/fju/uF3f2WJFfMIpCq+tYkPzGh6re6+3u6+6KVtNfdN3f3X3T361YQwz0zOeHovCRP6O5rltn365P8yISqbUl+YLnxAAAAAAAAAAAAAACwbL+eUSLHYockeXVVHbHMNn4zyV0mlP/KWgJbhbOSvL+q3lFVT6yqY1ayc1XdoapeluTPk2yf8JD3J3nZCmN6fZL/mFD+m1U16TWbFNcTk/zghKo/7u5LVhjPpjCeScRBqrvvM+8YkqSqDs/kbLg/6+5nzzCUxy1R/vPdfeMK23pFkp9Mct+x8m9P8tMrbAsAAAAAAAAAAAAAgAHd/YWqelGSXxqrelCSv6uqJ3b35ZP2raodSX4jyY9OqP6X7n7t+ka7bN+48LWzqv45yblJPprk40m+kuSaJLuSHJ/k9kkekuRRSR6fUfLRJJcm+Z7u3ruSQLp7b1U9K8nbx6qOS/L2qnpcd39kqf2r6vuTvHxC1ZW55e9sy5CAw6z9aJIzxsouSzLL5JskueuEsuuT/ONKG+rurqrX5ZYJOGdUVa1wqS4AAAAAAAAAAAAAAKZ7QZLHJPmasfJHJvlEVf1Wkjcm+XSS3UnulFHCyk8lufuE9r6S5MkbFu3yHZbk7IWvtbgoyWO6+wur2bm7/3nhNfypsarTMlqx5+VJXp1RktB1SW6b5KFJnpnk0Us0+9TuvmI18WwGEnCYmYVMwUmJNr/U3VfOOJzbTSg7v7tvXmV7H59QtiOjk8ilq2xzLv7yIxfPO4Q121Y17xBg5rZvgbf9tGPzyEMmrXq4394p+YyHbN82NYarb9o19TFDDtsxHOMxhw7XJ8nlNwwPNdNep8N3DD/PXXun533umfKYab+LnXuGE+F3TalfjrWey6c9hyS5Ydeewfppr/W0/ZfznpzmuMPW9uf6accdNlh/3a7pv6s7HbPUjRFGzrn4usH6OxwzHMO0YztJTj/u0MH6d1947XAMRw/HMO13vRzX3rx7sP7M44dj+Pjl0xdhvGn3lGNvyrF9myOG30+XXDu+Iu/KTTv2psV4+vHDq//unPIaJMlJRw4/zw9dMvx+mWY555eHnDK8CvB7LhqOYdqxf8gyBv5p56jrbh6uf+Adhp/DJ6+4YWoMX7lxeNw97vDh88u09/zO3cPPIUlOOGK4j2njzXVTju219p8kN0w5F5923OGD9dP+tljOe3basTWtjROmnF/udOTUELLjCx8crN9z8pTVqw8Zfp0+t3N4LEmS044dfsyOq4Y/L9ee4d/F+YecMjWG4w4bfq2njVg7tg2/p4+5cfoliu1Tnufuk8bvq3Kgi/cOnz8+cfnw+ePOU8aCJDnz2OHX6Zopf/Z/8JLhv1/OOGG5q9Evbdo5bNrv+tT+yvQ+jrrtYP1RF31osH7naQ8crN928/Rz/fbrh6+Lf/GlLxysv8Pjv2tqH9PceN4HBuuvveDLg/WHn3jsYP01Fw4fN1deP/3vuMNPPG6w/hH/908H6+uIowbrr3j/v0+N4Wtvf+Jg/dEPethg/c5PDfdx/cWXTY3hhIc+fLC+9wyP7TtOHj6P7jnlXlNjuHjX8N/ll1w3fC7fswlutbTH/Z4OGsu5hrMVbIbjYjNYzvUNOJjM4hQ27dLlreW4+/KUv0+mOVhep2mfsc7/yvC1zfV4Hb5w1XAf067xTHPTMh6z1ucx7f9DyzHtetla/0c07Xe5Hn0AbJSDZdwFgK2mu2+uqscn+dfccpGIE5M8f+FrOW5M8t2rTVbZhF6V5Ce6+6o1tvOzGS1+8W1j5YdklGjzzBW09T+6+41rjGeuJOAwS2dnlDW42E1J/nwOsUyakTI8+2LYNUuUT58RBgAAAAAAAAAAAMDM9F7TO+Fg0d0XV9Ujkrwhyf1X2cxlSb6nu/9l/SJbkYuTfCzJPdbYzt4k/5jkt7v7n9YcVZLu3lVV353kj5N8/yqb2Z3kp7v7pesR0zxJwGGWvm9C2Zu6e6nklY006daXw7eBHHbShLKdGS1DBgAAAAAAAAAAAADABujuC6vqYUl+IclPJzl8ubsmeW2SZ3f3FzcqvqlBdL8/yT2r6uQkX5/kgUnul+SsJKckOXRg988mOTfJOUn+ZiNW8OnunUl+oKrekuRFSe6wgt0/mOTHuvvc9Y5rHiTgMBNVVUkePaFqXTLrVuHcJE8ZK7tLVZ3Q3atJmnnIhLL3d7e1jwEAAAAAAAAAAAAANlB335TkF6rqt5M8NcnjkjwoyWFjD92b5ONJ3pzk5d398XXo+xVJXrEO7Vya5K8XvpL85zz8k5Mcl+TIjHJArklyVZKruvvmtfa7gvheWVV/leSJSZ6QUbLQ8RMeelGStyV5dXe/bVbxzYIEHGbl3pm8wsxHl9qhqk7NaGWZvRkt63V5d+9ap3jemOSlOfAY2J7kBxfKl62qjkryvROqXrvq6AAAAAAAAAAAAAAAWJHuvizJryX5taranuROGSWJbM8oceXChWSdLaG7O8mXF77mbmE1nD9b+EpV3SGjOf+HJ7k+ycXdffX8ItxYEnCYlQdMKNub5Lx9G1W1Lcl3ZJQE81+SHDu+Q1Wdl1E23Bu7+x2rDaa7L66qV+WWq+D8UlX9XXd/dgXNTVpG60tJXr7a+AAAAAAAAAAAAAAAWL3u3pPk8/OO42DW3ZckuWTeccyKBBxm5Z4Tyi7t7huSpKq+LsnvJ7nXlHbutfD1U1X1b0l+vrv/ZZUx/XSSb05yyqKyE5O8vaqe2N3nDu1cVUckeXGSHx2r2pvkh7r7ulXGtWJV9dD1ausv/v2i9WoKAAAAAAAAAAAAAAAOChJwmJXTJpRdmyRV9RNJfjOjZb1W4uFJ3lFVv9jdL1hpQN19ZVV9S5J3JDl5UdXpSd5TVW9K8pok52a0ZNfOJCckOSujFXqekeSOY83uySj55u9XGs8avWfG/QEAAAAAAAAAAAAAwK2GBBxm5Q4Tyq6tqh9L8tI1tFtJfqWqzuzup6905+7+WFXdP8kfJ3nMoqrtSb5z4Wu5PpHk6d0tGQYAAAAAAAAAAAAAAA4i2+YdALcaJ0woOzXJb4+V3ZDkd5I8KskpSQ7LaHWahyZ5fpJLl2j/aQsr6axYd3+xu89O8ogkf5nkmhXsvjvJm5I8Mck9Jd8AAAAAAAAAAAAAAMDBRwIOs3LYhLKTc+AqTO9KclZ3P6u7376QGHNzd1/W3e/r7l9Kcrckr1yijxdX1b3WEOPejJJvbljBPjuSfFWSeye53Rr6BgAAAAAAAAAAAAAANqkd0x8C62Lae+0dSb61u28aelB3X11VT05yU5JnjFUfkuR/JnnSSgKrqrOS/EFGK+Csxj0Wvn6mqn4zyf/q7ptX2dZqPWwd27KKDwAAAAAAAAAAAAAALCIBh1nZNVD3lSQ/OC35Zp/u7qp6VpKHZ5T4stj3VtXPd/fnltNWVX1vklckOWJC9flJ/iHJOUkuyyjp5zYZrXjziCRn58Bj6LAkP5fkUVX16O6+cjkxrIfufu96tfWXH7l4vZoCAAAAAAAAAAAAAICDggQcZmVoRZj/090ryvro7puq6nlJXjNWtT3Jtyd56bQ2quo7kvz5wj6LXZ7kvyV5bXfvXWL3F1fVaUl+Pcn3jtU9KMlbq+rruvvGaXEAAAAAAAAAAAAAMDu9d8+8QwBgC9o27wC41bhqoO5lq2zz9Rkly4x7xLQdq+qOSf4kt0y++XySB3T3awaSb5Ik3X1Bdz8xyS9NqH5AkhdNiwMAAAAAAAAAAAAAANj8JOAwK5MSZZLkC939hdU02N27k7x3QtXXLmP35yY5Yaxsd5Jv7+4LVxjH85P81YSqH6+qM1bSFgAAAAAAAAAAAAAAsPlIwGFWLl6i/N/X2O6k/W87tENVHZfkByZUvaK7z1tlHM/JKIFnsW1JfmyV7QEAAAAAAAAAAAAAAJuEBBxm5bNLlF+5xnavmFB2SFUdO7DPNyQ5YkL5q1YbRHd/Psl7JlR982rbBAAAAAAAAAAAAAAANocd8w6AW42PL1F+wxrbvX6J8qOTXLNE3QMmlO3N5ASalfjXjJJ7Frt3VW3v7j1rbHtmLr/h5nmHMNX2qsH62x992GD9kYdsn9rHl67bOVi/a8/ewfqbptTPwrTX6ZBtw/XLsW1KG2eddNRg/WHbh38Xn75yqUN8v717e+pjhuzYPpyLeviO6bmqe6bEcOOu4VPAerxfjj50eEg/7rDh+l1TnsNDTz1megx902D9524cjmHKWzaf/8pw+0cfOv3YvuDqGwfrpx0309zuqEOnPuask44erD9sx3AMp++8YLB+283DzzFJvnj8WYP1Rxwy/L6/+Npdg/U7d09/Tx8+pY+Lrh7+fR93+LT3/CFTY7jrkcNj3g3bjxysv2nP8HHzycuHfxdnnHD4YH2S3Obw4ff17inH7jU3D/8uDp9yDkySKU8zV+8cXwTwQA+/0/D54/Crht/TSbJ726mD9aceOzz2H7WMsX+aE48YbuOwm4aP3cOmjCc3TBkrkuSkI4fPMcccNhzjiUcMHzfblnEOPOnI4WNr2p8XX7pu+Libdg786uOmf4Q95MufHKw/5dTh99MXdg3//TJtzEySa6cce9unvE63OWL4dd6b6TFM+xtmWh/HHja8/zdcfe7UGL74utcNx3CvMwbrD/nOZw/WX37z9HPYzVP+zto+5U1785ST4NU3DR+7R095HZOkp/w6Tz5y+H1/t+OnHBfv/LOpMey6/MuD9YedMfy3w447nD5Y39dPH/N61/D5oXYPf0br7cOvwylHDx/bSbLjmi8Nx7B3eMzr7cPn6bte87GpMez6/FKXT0Z2nHqX4RiOOWlqH1Nj+OLnB+tvft9bB+tPmfJ+ueOeKWPe8K8hSVKHDJ/Djp+y/zdde9Vg/SF77zY9iG3D427fOPx5tm8e/nv3ug+9b2oI114wfOxesXf4HNhTzpFHnjztlUyOvP2Jg/U7jho+/ndffP5g/bajp8dwyG1vN1g/7dNsTfmbeNu24frthw//LZokl33kC4P1F7/nM4P1J3714ILfU59Dkpxw1p0H6/dcMXzwHXa3+w3X32X658DaMXzs7rrk84P1N1zw6cH6nW9709QYDrtm+HL0vU8bfj/tuWl4vLrsw5+aGsMdv2H4taxDh4+bQ8+81/D+h00fd3efep/B+h1XL7Wg/cieY+8wWL/tusuGA6jp79macn1j7xHHDTfQ63B9dkqcO4+5/WD9jbunXDNcxvWTtV7DnfYx78Zd02M4dMo55qRDhv9Gql3Dv8tpf0MlSbYPnz+u2zv9c/97L7p2ej8AAAAAADCFBBxm5QNLlA+tVLMcS/2XbWhlnUn/sf5Kdw/PJp5u0qyHbUlOSHL5GtsGAAAAAABgFR579+EEOwBg63jwvAMAAADgVm36bcZgHXT3ZUkm3aLw5DU2PWn/67sHl2GYlHi21uSboTYcZwAAAAAAAAAAAAAAsIVJDGCW3jKh7IFrbHPSzU0+P2WfSavRnFhVtcZYJq2s00muWGO7AAAAAAAAAAAAAADAHEnAYZZeN6HspKp6wGoaq6pjkzxkQtU7pux66YSyQ5LcZzVxLDIpGejK7t6zxnYBAAAAAAAAAAAAAIA5koDDLL0ryfkTyn9sle09NcmRE8rfPmW/Dy5R/l2rjCNVdXySb5pQde5q2wQAAAAAAAAAAAAAADYHCTjMTHd3kpdMqHpyVT1oJW1V1e2T/MKEqouSvHnK7u9LctWE8mdV1W1WEsciP5fk6Anlb1llewAAAAAAAAAAAAAAwCaxY94BcKvzx0n+e5KvWlS2I8lrquqbuvuCaQ1U1TFJ/irJSROqf7W7dw7t3917quq1SZ4xVnVCktdW1WO6e9e0OBbF87gkPzOh6uYkr19uOwAAAAAAAAAAAABsvN67Z94hALAFWQGHmVpIjvnRJD1WdWaSf6uqs4f2r6oHJHlnkq+fUP3vSV62zFB+OclNE8ofmeRdVXXGtAaqantV/XSS12XysfR73X3hMuMBAAAAAAAAAAAAAAA2KSvg3EpU1elJPrfK3d9RVdMec0Z3f345jXX3W6vqhUl+fqzq1CT/UFXnJnlDko8luSLJcRkl6HxbkkdlcrLL5Um+c9rqN4tiuKiqfinJr02o/tokn6qqv0rypiTnJrkso4SdE5LcNck3Jnl6kqUSdT6X5FeWEwsAAAAAAAAAAAAAALC5ScBhXn4xyclJnjGh7msWvpbr0iTf0d1fWEkA3f3rVXWnJD8xoXpHkictfK3UZUke3d1XrGJfAAAAAAAAAAAAAABgk5m0kghsuO7uJM9M8nNJdq+hqQ8neXB3v2+V+/9kkuckWdbKOctwbpKv6+5Pr1N7AAAAAAAAAAAAAADAnEnAYW565EVJ7p/k75P0CnY/P8lTM0q+uWCNMfxakgcl+dske1bZ1BeS/HSSh3X3p1YbDwAAAAAAAAAAAAAAsPnsmHcAzMwlSR66we2vSnefl+SxVfVVSb4zySOS3D3J7ZMckeSaJJcnuTjJvyZ5a5L3dvdaVs6ZFMN3VdWpSZ6U5GFJHpzkjkvscnOSjyY5J8mbk7y5u/euVzwAAAAAAAAAAAAAAMDmIQHnVqK7dyZ537zjGNLd5yd58cLXvGK4KMmv7duuqqOTnJDk+CSHZpQMdFWSr6xnAhAAAAAAAAAAAAAAALB5ScCBAd19XZLrklw471gAAAAAAAAAAAAAAID52DbvAAAAAAAAAAAAAAAAAGAzk4ADAAAAAAAAAAAAAAAAA6q75x0DMGdV9dAk7xkrflh3v3ce8QBwcDLeADALxhsANgPjEQCzYLwBYBaMNwDMgvEGANgqrIADAAAAAAAAAAAAAAAAAyTgAAAAAAAAAAAAAAAAwAAJOAAAAAAAAAAAAAAAADBAAg4AAAAAAAAAAAAAAAAMkIADAAAAAAAAAAAAAAAAAyTgAAAAAAAAAAAAAAAAwAAJOAAAAAAAAAAAAAAAADBAAg4AAAAAAAAAAAAAAAAMkIADAAAAAAAAAAAAAAAAAyTgAAAAAAAAAAAAAAAAwAAJOAAAAAAAAAAAAAAAADBAAg4AAAAAAAAAAAAAAAAMkIADAAAAAAAAAAAAAAAAAyTgAAAAAAAAAAAAAAAAwAAJOAAAAAAAAAAAAAAAADBAAg4AAAAAAAAAAAAAAAAMkIADAAAAAAAAAAAAAAAAAyTgAAAAAAAAAAAAAAAAwIDq7nnHAAAAAAAAAAAAAAAAAJuWFXAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGCABBwAAAAAAAAAAAAAAAAZIwAEAAAAAAAAAAAAAAIABEnAAAAAAAAAAAAAAAABggAQcAAAAAAAAAAAAAAAAGLBj3gEAs1NV25LcKcltk5yY5Kgkh2Z0LtiVZGeSa5JckeRL3f3lOYUKwBa3MObcJlPGm+6+em5BAnDQqKrDMnm8uba798wzNgAOblV1pyRnJjk9y7zmluRzST7T3VfOIWQAAAAAAABglaq75x0DsAEWJj4/JMkjkzwwyX0zSr7ZvoJmbkrymST/nuScJG/r7k+tc6gAbHFVdYccON6cmeTULG+1xZ1JPp/k09k/3vxLd1+/IcECsGVV1Y6MPuMsHm9Oz2iy8xEDu16T/ZOd/3O86e6PbWS8ABycqup+Sc7O6DPQA5Icv4bmLsrCNbckf9fdX1x7hAAAAAAAAMBGkYADB5mqun+SZyT5noxWHvjPqjU0u/hE8ekkr0zyMivkANx6VdXtkjw5yZOS3Hu8ehVNLh5rdiV5Z0bjzWu7++bVxAjA1ldVhyb5zozGm0dmtKLAAQ9ZQXPjF0C+lORNSV7V3e9edZAAHPSq6sgkP5zRNbezFletQ/O96Ps7k/xOd79hHdoFAAAAAAAA1pkEHDhIVNW9kvxGkm/eVzT2kNUe7JMmEnRGKxa8LMn/6u6vrLJtALaYqjo5yS9nlHxzaJYeJ1bc9BJtXJrk15O8tLt3r6JdALagqjosybOT/GSSk/cVT3joSsacof0/muT53f36FbQHwEGuqirJj2T0Geg2Wb/rbQd0M6G9/5vkWd39rnVoH4AtrqpOyeSVQE/M6CYFhybZkdFNbXZmtAroFbnlSqAf7O5rZhw+AAAAAMBBRQIObHELEwGel+TnkmzP/n/ab+TBvbiPK5M8pbv/fgP7A2ATqKqnJXlJkmMyeZLYunY31v6nkjypuz+8AX0BsIlU1aOS/GGSO2f24807M/p8c+EG9AXAFrKw6udfJHlENn48+s9ux/p5SZKf6+49G9gnAJtQVX1NRiuBnp3kLpMesoxmxsesPUk+kOSNSf68uy9YU5AA3Gos3CxnUtLntT6vALBWVbUto5vfDN5koLuvnluQAACLSMCBLWzhQtfrknxrhhNvlvOPmCFLnSgW9/lz3f3ra+wHgE2qqn4vyTMzPdFzLWPOtDZ3ZjQp+jVr6AOATayqfjbJCzK6uUAyPMl5NWPOcsavK5M83qoDALderDL9kgAAIABJREFUVXV6krdntMJAZWXX265f+NqV0UTnHRlNGjgmyWFL7LNU+53kTUm+p7t3LSt4ALa0qvq+jG64du99RQMPX83npV70/U1JXtDdH1hRkAAclKpqR5KHZPKqa0cM7HpNbrnq2jnd/bGNjBeAramq7pDkkTlwvDk1ybZl7L4zyeezaLxJ8i/dff2GBAsAsAQJOLCFVdUbkzx2YXP8YN73z5UbM/rQ8dEk5ye5OKMLYNdk6ckAxye5fZLTktw1yf2T3D37P+xM6quTPKu7/886PDUANpGq+oMkP7ywudR4kySXZG3jzX0XyveZ1NeeJE/s7tev6UkBsOlU1S9ktLrnpInOi8ebPUk+k9WPN6cuamupfm5I8pjufveanhQAW05VHZvk/RmNGcmBY8Xi623vSXJuDvwM9OXu3jvQ9mG55TW3hy58X2r86ySv7O6nrPpJAbDpVdU9k7wsyddkY1deG2+7k/xpkmd39zXr3BcAm1xVHZrkOzNade2RGa06cMBDVtDc+Jj1pYySPV/lGhvArdvCStNPzmi8ufd49SqaXDzm7EryziSvTPLa7r55NTECAKyEBBzYoqrq55K8MJP/MX9lkj/PaHWc967HHTKr6rgkj0ryfUm+I6MJbeMTEHYleVh3f3Ct/QGwOVTV0zL65/+k8WZ3kn/MaLx5e3dfvA793SvJozMabx64UDw+3lyX5IHd/em19gfA5lBVj03yhklVC9/Py8J4k+RD3X3jGvo6MaPJzo9O8oQkt8vkce7SJPfr7i+tti8Atp6q+tMkP5jJiTdvSfJHSf6+u3euY5+3TfLEJD+W5KwJfXeSH+juv1ivPgHYPBZWvXlZRqsLTFt9OlnbZOhJ7XSSzyZ5XHd/fAVtA7BFLdwc4NlJfjLJyfuKJzx0JROKhvb/aJLnu7kawK1LVZ2c5JczSr45NGsfa/6z6SXauDTJryd5aXfvXkW7AADLIgEHtqCqOjXJJ5Mcvrg4o7s0Pz+jDxKrnpC2zP5fmOQHcssJAe/v7odsVN8AzM7CBOVPZbRywGKd0aSzF3T3RRvY/9cmeVGSr8/+8WbfxbR/6u7HbFTfAMxOVR2V5BNJTsktP1+8Jclzu/ucDep7e5LvyegfQHfJgeNNJ3lNdz9pI/oGYPOpqgcnOSe3HI/+I8kzuvt9M4jhaUlenOTYsRi+mOSM9bjRDgCbR1U9JaPkm20LRUOrgd6UUaLMSlcCPS3J9kXtLNXH5UkeIQkH4OBWVY9K8odJ7pyNXXUtE9p/Z5KndPeFG9AXAJvIwjWul2T0+WTW482nkjypuz+8AX0BAEjAga2oql6U5Gdy4OSwLyQ5u7s/McM4npjkT5McsiiOTvLN3f3Ps4oDgI1RVb+Q0YTkxePNV5J8d3e/c4ZxPCejxM//LFqI6SHd/YFZxQHAxqiqZyX5rRw43uxM8sPd/coZxXDoQgw/MhbH3iT37O5PziIOAOarql6Z5PszGgv2fe54S0afgTbsZjcT4rhbkrdllJyaRbH81+5+9aziAGBjVdVDM5qIfEgmr7x2ZZI3ZrQS6LmrXQ164fPOvbN/JdBvzihRZ1IizmeSPKi7r1lNXwBsblX1s0lekP2Jmeu14to+S7W3uK0rkzy+u9+1ivYB2AKq6veSPDPTV/hczVizz7Q2d2aU9PmaNfQBADCRBBzYgqrqoiR32LeZ5KokD+zuz80hlu9P8socODHhFd399FnHAsD6qqpPJzlz32ZGd9n8+u7+4Bxi+X+T/FoOHG9+r7t/YtaxALC+quojGU0G23eO35Pkcd395jnE8ltJnpUDx5vf6O7nzDoWAGarqnYkuSLJ0fuKMlqB+gGzTL5ZFM/9k7wvo9UM9o1Jb+ru75x1LACsv4Vx56NJzsrkldd+Jclfd/fuDej7hIwmw/1MkhNy4E0IXHMDOEgt3HTtedl/vj+getHPezJKyDw/K1917a5JTl3U1lL93JDkMd397jU9KQA2nar6gyQ/vLA5NN5cktFnotWON/ddKN9nUl97kjyxu1+/picFADBGAg5sMVV1VpKP5cAJYf+9u397jjH9Y5JvWRTThd1953nFA8DaVdUZGV3sWjze/HJ3P2+OMb03yUMWxfSZ7r7bvOIBYO2q6o5JLsqB483vdvdPzime7dk/CS4LMZ3X3feZRzwAzE5VPTjJOTlwTHpCd//NHGP6wyQ/tCimr3T3ifOKB4D1U1VPSfLy3DL55blJXtjde2YQw4lJXpHk28bi2J3kzO6+aKNjAGA2quqxSd4wqWrh+3lJXpfRqmsfWstNCBbGl32rrj0hye0yeVL0pUnu191fWm1fAGwuVfW0JC/L5PP+7iT/mIXxprsvXof+7pXRePN9SR64UDx+g4PrMrqp9apWFAUAmGTbvAMAVuzeY9u7kvzJPAJZ5A/Gtk+tqmMmPhKArWJ8ovHeJL8/j0AW+Z2x7TOr6oi5RALAernfhLIXzzyKBQuT3H47B96F7e5VdeicQgJgdu4+tn1dkjfOI5BFXjW2fXxV3W4ukQCw3n540c/7km+e2d3Pn0XyTZJ09xVJviPJa3PgZ6DtSZ42ixgA2HhVdVRG/9+p8aokb0ny0O6+T3f/cnf/21pXAO3uK7r77xZWUzs1yZMyuuHbeP+3TfKStfQFwOaxkID567ll8k0n+f8ySvJ/XHf/2Xok3yRJd5/X3S/u7gcneViSf80tx5ujc8t5BgAAayIBB7aeO45tf7y7r5lLJPu9d0LZKTOPAoD1NL6S2Se7+9K5RLLfu8a2K8md5hEIAOvmjLHt87v7grlEst9bx7a3xXgDcGtw20U/d5KPzWoC9ICPTCg7aeZRALCuquqkHLjKcyf5i+5+2axj6e69SZ6a0cqkyf7Jco+ddSwAbJinZ/S/+8Wrnd2c5MndfXZ3n7NRHXf3nu7+yyT3yuimnvsmRe8bA7+3qr56o/oHYKZ+NMkJi7YryVVJHtXdP7rRK2x29/u6+xFJ/sfi4oXv31xVD9rI/gGAWxcJOLD1HL3o505y2bwCWWRSDEfNPAoA1tP4eHPJvAJZZFIMR08oA2DrOHbRz51k3sk3SXLhhLJjJ5QBcHA5fGz72rlEcaBJMYzHCcDWc//c8q7ML5hHIEnS3Tck+c3sj6mS3Leqts8rJgDW1dMX/VxJ9iR5fHe/clYBdPfN3f1jSV6aA8fAilXXAA4WT86ByZ43JfmW7n7nLIPo7hcleU5u+ZnrybOMAwA4uEnAga3nprHtzTDxeFIM43ECsLXcPLZ92FyiONCkGHbNPAoA1tP4ygI75hLFgSbFMO8VEADYeNct+rmyOVaamRTD9TOPAoD1dpex7Qu7++NziWS/N49t70hy2jwCAWD9VNUdk9w7B6669nvdPX7en5WfTrJvzNsX09lzigWAdVJVZyT5qn2bGZ3jX9TdH5xHPN39G0nOWRRLJXn0PGIBAA5OEnBg61m82kwluUdVzftYvs+EsstnHgUA6+nKRT9XkrvPK5BF7jGh7MoJZQBsHVct+rmS3HVegSwyKYarJpQBcHD54tj2ParqmLlEst/XTigbjxOAree4RT93ks/NK5BFPjuh7LgJZQBsLfebUPbimUexoLv3JPntHLgqwd2r6tA5hQTA+hifN7Y3ye/PI5BFfmds+8yqOmIukQAAB515T9oHVu4TY9vHJHnsPAJZ5PvHtq/q7i/PJRIA1ssnx7ZvU1XfOI9AFnnC2Pb13X3xXCIBYL18amz79lX1wLlEst/jxrZ3JrlwHoEAMFPnjW0fkuQpc4hjsWeObV/c3dfMJRIANlLPOwAADlpnjG2f390XzCWS/d46tr0tyZ3mEQgA6+bOY9uf7O5L5xLJfu8a264YbwCAdSIBB7aeDyW5duHnfctk/mpVHT6PYKrqPkmelgOXrf7XecQCwLr6UJKbFm1XkhfOa9W1qrpzkh/PgePNe+cRCwDr6kNJdo+VPW8egSRJVZ2Y5Kdy4Hjzge42IQ7gINfdH8/+1WX2jQPPXfgsMnNV9X1Jzs6BY9Lb5hELAOvu6kU/V5LT5xTHYqdPKLt6QhkAW8uxi37uJPNOvkkm3+jm2AllAGwdRy/6uZNcMq9AFpkUw9ETygAAVkwCDmwx3b07yd/lwGWZvzrJX1XVYbOMparOTPLGjO4IutjrZhkHAOuvu2/M6C5k+yZ6JclDMoeloqvqNknekOSosaq/nXUsAKyvhbv4vyv7x5tKcnZV/eKsY1n4PPWaJCeOVb1x1rEAMDd/kf3X3DrJCUneVlV3nWUQVfXdSf4kt1wR4VWzjAOADfOZse07V9VXzyWS/c4e296dzTFJG4C12TO2vWMuURxoUgzjcQKwtdw8tj3T+WtLmBTDrplHAQAclCTgwNb0W4t+3jdJ7duSnFNVD55FAFX15CQfSHJaDpwMcElGk9YA2Pp+Z9HP+8abH6qqN1fVTJZnrqpHZDTe3DsHjjdXJ/mzWcQAwIZbnNy5eMWBP6yqmdyNrKruklEi0DflwPHmpowmQANw6/DbSW5ctN1JvirJB6vq/93oFair6pSq+pMkf5X9kwT2Jal+sLv/eSP7B2BmPpxbJln+z3kEkiRVdUSSZ+fAmD7S3SZDA2x9Vy36uZLM9OYCS5gUw1UTygDYOq5c9HMlufu8AlnkHhPKrpxQBgCwYhJwYAvq7vcneXUOvCNnJblPkvdV1d9V1eOq6tD17LeqTqyqH6mq85K8PMnx2f8PmX2TAZ7T3e4YAHAQ6O63JXlLbjnefEuST1TV71bVfde736raVlWPqap/SPLPSU5fFMO+8ea53X39evcNwOx1918nef/ioozO909P8umFCc/jq9Ksi6o6q6p+L8l5SR6UW443L+7uKzaibwA2n+6+KMkLcuDK053k6CQvSnJBVb2kqr6uqravR59VdUxVfVdV/WWS85P81xy4Emkyuhv0j69HfwDMX3dfnuTcHLgS6A9U1VPmFNIfZ3SztSyK6e/nFAsA6+tTY9u3r6oHziWS/R43tr0zyYXzCASAdfPJse3bVNU3ziOQRZ4wtn19d188l0gAgINOdY/fYAnYCqrquIxWBDhzcfHC930H9o1J/i3JORlNKPtMkouTXNoDB39VHZLk9hn9w+VuSe6b5GFJ7p9R4t54P/u8urv/6yqfEgCbUFWdktF4c/Li4oXv+8aBzyV5exaNN9297LvHLPSxeLx5ZJITFvU1Pt68LcljhsYyALaWqrpHkvclOWpx8cL3TrI7yb9m0XjT3ZeusI/KKKlz33jz6CT3mtDXPh9O8rDuvnkl/QCwtS2MF29K8q05cFwYHytuyGisWHzN7csZrdZ5XUZj154kO5IcmuSYjG5mM37N7R5J9iXzLHXN7dnd/dK1PzsANouqempGiS+Lb3K2J8n/SvK/Z3Hdq6pOyGjFz29fXJzRGHbmQmIqAFtYVR2b5PKMPnPs+3/Lm7v7sXOK58Qkn0hym0Xx/Ft3f8M84gFgfSysqnlFRis677u+9b4kX9fde+cQz50zumZ3ZPaPN2/r7kfPOhYA4OAkAQe2sKo6M6OVAU7L5AkByS3/Yb+v7PosPRng8EndTWhjcd3fJfluq98AHHyq6kEZrYRz/HjVop/Hx5udSS7N9Mlnt83+yWbT2q2MVkj4lu6+esVPBIBNraq+NclfZzROHFC18H18rLkuyRez/MnOpyQ5ZEK7421Xks8meYS7oQHcOlXV4Ulen+QxueX4M+2624q6GtuedH3vf3b3r66xHwA2mYUbof3fJHddXJzRWHBekucn+Zvu3rMBfR+X5JlJfiYHToDe9/0PutvKawAHiap6W0Y3Plt8rn9udz9/xnEcltEKa+OxPKe7f2OWsQCw/qrqDRkl9y8+x7+su5854zhuk9FcuvuMxfLfuvv3ZxkLAHDwkoADW1xV3T7Ja5J8fSb/03/8H/lrsdSEg99K8rPdvXsd+wJgE6mqe2Y0KfpuWfl4MzRhbTmP37fP3yZ5cndfO2V/ALaoqvqmJH+ZUYLmcseP5VzYWO6+leTcJI/v7i8uo10ADlJVtS2jyc8/m9FNAzbquttS7V6Z5Ond/YZ16AOATaiqHp7RxLAdi4sXvndGd5B+YxZWAu3uz66ynx0Zrf65byXQb8nohgXjNzvYdzOCB7r5DcDBo6q+O8lrc+D5vjNaie2/d/d1M4jhLkleneRBi4uT3JjktO6+YqNjAGBjVdWjkvxTbjne/FOSH+7uC2cQwyMyWuXzzouLk1yV5E7dff1GxwAA3DpIwIGDwMKEgB9L8rwkJ2Ttd9+c2uXC9/9I8qzufscG9wfAJlBVR2U01vxERisIrGXCc1aw/2UZ3QHtFct4PABbXFXdIcnvJHn8QtG08WI5k5+X08bOJC9K8gIrewKwT1XdN8mLM7pLc7Kx190qyc1JXp7kF01CAzj4VdXTkvzRePGinxePOzdmlCBzcZa/EuhpGU0+W7wC9aRVRiujhJ9v7O7/WP0zAmAzqqpzcsvkl05yaUafd/5kIz5/VNVZSZ6V5GkZ/V9pfNW1F3T3L613vwDMR1W9OaOk//EknJsySoz5o+7+yDr3uS2jmww8a6HvxZ939vX/7O5+6Xr2CwDcuknAgYNI/f/s3XeYrVdZP/zvfXJSCCWFFikhEgglEEpogVACEQIoKCJFEAFRUH9cgggiL6+Fqq/687Ig0jQ0BRVBitRAEGkhMZRQQ4ohgcQkQAolpNzvH3uGs88+e+bMzN4ze8rnc11zzTzreZ573UOZdZ79rHutquskeUaSp2WwQ8G8afwfffgB5T+T/E2Sf2t/RAC2nKo6JMnvJHlikuvNNU9rPBieYHB2klckedVarMAGwPpSVUcneX6S45Jsm2ue5vPH/JjzvSTHJ/nT7j5nivEB2ESq6sgkT0/y8xksgDNvkrFp+PnnjCRvSvLq7v7WBDEB2GCq6olJXpVkn3Gnx7QtZ+xZyv2Vwedwj+ju05YRG4ANoqpun+RTSa493Dz3vTMo5vxY5nZdS3Jad//vMvuoJIckuVN27Lp2hzF9zTs1yb27+0fL6QeA9auqbprk5CQ3Gm6e+z4/BpyVofEmyde7+9vL7OOw7BhvHpgdn9XNF9wM+1CS48xvAwCmSQEObFJVddckD01yTJIjk+w3QbjzMnjw+VCS96zFtqAArH9VtXeSh2fHeHPLCUNeleTzGYw37+ruj08YD4BNYO5lymMzGG/uk/GT0pLxk8gWcnEGL3jeleTt3f39SfMEYGuoqj2S3CuDZ6C7Jzkiyc2zo1h0Ka7IoODm1Mx95tbdX5lyqgBsIFV1xySvy2B3gsVe3i5lB9BhS4n1hiS/1d2XLDM2ABtIVT0sydsy2C1tp1Nz30fHjMuTfDNL33XtphnscjMadzR2ZbCj2/27+7wV/joArFNVdbck789gfNjp1NDPo2POFRnsyra78eaG2Xl3z8XiVpLPJHmwZx0AYNoU4MAWUVW3SHJoBqvO3DDJgUmuk8GHYHtk8PByRZLLMpiMdn4Gqw6c3t0XzSBlADaYqjogg8lnKxpvknyhu69Y88QB2DCqas8MVs6cZLw5tbvPWOvcAdi85sanm2eJY1J3f3NGqQKwjs3tHPCEJM/Ljh0Dpv0id3iS9X8keUl3f3rKfQCwTlXVMUneksGzy1IXs1nKWLTUeyvJSUke5bkIYPOqqsMzKPo8LOPHkcUWFljOYmvjrp+/5x1Jfrm7L9vN/QAAy6YABwAAAAAAAGCdqKqjkjw+g51ADx1zye5e8I6bpHZNkpMz2An0zd199iQ5ArAxVdVPJPnrJI+aa1rJmDJqKTGuSPInSV7a3VcuISYAG1hVXTvJHyV5ZgYL1UxS0Jll3H9hkt/t7uOXcD0AwIoowAEAAAAAAABYh6rqZknungl3Ak1ycndfssbpA7BOVdXRSZ6f5Lgk2+aapzmBaH4S9feSHJ/kT7v7nCnGB2ADqKpDkvxOkicmud5c87TGm+GCnbOTvCLJq7r78inFBwAYSwEOAAAAAAAAAABsMVV10ySPzWDXtfsk2WeBS0cnFy22S8HFSU7IYNe1t3f39yfNE4CNrar2TvLwDMabY5LccsKQVyX5fJIPJXlXd398wngAAEumAAcAAAAAAAAAALawqtozyR0y4a5r3X3GWucOwMZSVQdksvHmC919xZonDgAQBTgAAAAAAAAAAAAAAACwqG2zTgAAAAAAAAAAAAAAAADWMwU4AAAAAAAAAAAAAAAAsIjts04AAICNr6pumuTIJHdKcsskhyS5YZLrJ7l2kr0y+LfnlUmuSHJpkouTnJ/krCSnJ/lsklO6+9I1Th8AAAAAAAAAAABgUdXds84BWCeq6rAkD0ty9yQ3TnKjDCZMX5rknCSnJjmhuz81syQBWDeq6h5JfjHJQ5PcatwlSwgz+o/Rq5OcnOSdSf6xu8+ZKEkAtrSqunMWf745qbuvnF2GAAAAAAAAAABsFApwgFTVTyd5WZLDR08N/Tz8x+LMJH/c3a9b7dwAWH+q6nFJnp/kjvNNi1y+2D82F7qvh76/K8lLu/vkZSUJwJZVVTdO8sIkj0py0G4uvyzJvyT5s+7+6mrnBgAAsNqq6sAMdqoeuxBBd583w/QAAAAAADY0BTiwhVXV9ZO8JckDs/gk6HHnOslJSX6hu89dnQwBWE+q6vAkr01yjyxcpDmVrkZid5LXJ3l2d1865b4A2ESq6oVJnpfk2lnaTmzJYJy5OslfJPl/uvuqVUoPAABgVVTV3kn+T5Kfz2AX0G2LXH56kjcm+dvu/s4apAcAAAAAsGkowIENqKrOHDrsJI/q7s8tM8YhSd6X5NbZMTFtOX8Q5u85P8kDu/sry+kfgI1lbteb1ya5VpY2bix10vNS43QGO7A9oru/vIzYAKxzVfX3I00v7u6zlhljryRvzmDXm+U+3wxf/7EkP93dly+nfwAAgFmpqicmeVmSm843LeG2zmBH0N/r7leuVm4AbCxVtUeSw5PcKcktkxyS5IZJrp/Bgjd7Jdme5MokV2Sww9rFGcwZOCuDIs/PLvezPQAAANhIFODABlRV12THzjSd5KjuPmkZ9++X5HNJDp5rGveHYPQFzWLXnJPkCLsSAGxOVfXkDIpv5lfOHB0ThseMH2ZQKHNeBi9cLk3yvQxexlydwYuZvZJcN8n+SQ7KYDw6OMkeQ3EW6uOiJPdXhAOweQw938xb7vNNJXl/kgdlxzPSilKZu/fEJMe2D0wAAIBVUlW/P9L02u7+5gri/HmSZ2X5u1UPL0Tw1iS/1N1XL7d/ADa+qjooyeOSPDTJ0Un2WejSMW0LjTkXJTkhyTuT/Ht3/2DSPAHYmqrq2kl+KoOdPm+c5EYZzDe4NIP5aqcm+chKnqcAAFZKAQ5sQFMowPnnJI/OwpObv5vk80n+d+74RkmOyGCidEbum8/hjd395KX/FgBsBFV1VAYTkffMrn//k+TbGbxAOSHJSd19+gr72SvJHZMcleQhGXyItlfGj1VfT3I3hZ8Am8MUnm9emORFWXzRgM5gNc5ksGLnQrvkzOfw/O7+06XmAAAAsByTLkQwF+P4JL+U6SxE8Nbu/sUVxgBgA6qqeyV5fpKHZ8cCbLvbRW3ce6LdXXt5kr9P8ufdfe5y8wRga6qqI5K8NIN5A3vu5vJO8pEkf9zdJ6x2bgAACnBgA5pkglpVPTLJ2zN+otmHk7w4yX+NrnQ2t930/ZK8MMkxI/3Pf3+wBxmAzaOqtmdQkHnb7PpS5YtJXpLkbd191Sr0fUCSpyd5bpIDhvqfH3P+trufOe1+AVh7Ez7f3DnJSdl5F7XMxbo4yd8keXeSU7v7mrl7tiW5S5JHJPnNJAdm13HuiiR37u6vrvDXAgAAWNAUFiL41SSvyuILESxkoYUIntrdr19qDgBsTHM73vxlBgt2JsvfRW3JXY3E/WGSP07yMruuAbCQqto7ySuS/HIGBaK7e74Z1kn+NcmvWswTAFhNCnBgA5pwgtp/ZrB19PBE5quTPKO7X7fEGE9L8srsvBJOJ3lPdz9iqb8HAOtbVT05g1XJRotf/jBr9IKkqq6f5PgMVmAbzuOqJLe0WhrAxjfh880/Jnlcdh4jkuRNSZ7Z3Zfs5v79MijSeUJ2He9e093PWMavAgAAsCQTPgcdmuRzSa41eirJj5L8UwYLEZyS5H/nzt0oyZFJfibJ4zN+t+tLktyhu89bwa8EwAZQVfdL8tYMxoWFdoje5bYlhF5qjE7yqSSP7u5vLSEuABtEVX14pOk3uvsry4xxQJJ3JTkqSx+nfnz70PVfTfIgYw0AsFoU4MAGtNIXM1V1ZJLPZNeJZb/Y3W9dZg6PT/Lm7FrIc8vu/sZyYgGwPlXVJ5LcKzuPOU/v7teucR7bMpg48AsjufxRd79oLXMBYPomeL65WZIzs2P3m/n7/6q7n73MHP4yyTOz8/PN5Ulu0t2XLycWAADA7kxYgPN3SX4tuy5E8JEMVno+czf3H5rkNUkekF3fF/3f7n7u0n8TADaKqjouyb8l2WeuadyOaMO+l+SbSc5Pcunc8ZUZzAnYnmSvJNdNsn+Sg5LcJIMCz3mL7dL29STHKPoE2DymsMvn3hkUaR4xFGPspXPfd3f+C0nu3t0/WmoOAABLpQAHNqAJJqj9fga7Fgzf+w/d/bQV5vHaJE8diffs7v6rlcQDYP2oqhskuWD+MIO/8f/U3U+cUT77JvlKkpsONZ/S3feYRT4ATM8Ezze/leQvRu79ZJL79jI/7Jgr9vxYBquqDcd7Sne/YTmxAAAAdmeC56DrJzknOyZPz9//r0me2N1XLrH/PZP8Y5Kfz85FOBcnualJagCbS1XdNsmnMyiYGVd4c3UGn42dkOSkJJ/v7guyDHOfrx2S5C4ZfMb2kCSHz50e3XUtSU5OcrQxB2BzmEIBzl8n+c0sXMDZSb6RnXf5vPnQueHrLDCxOHNHAAAgAElEQVQAAKyqbbNOAFhTR48cX5nkhRPEe+FcjGH3nCAeAOvHXbLramcvnUUiSdLd389gkvV8TpXkTlW1x8J3AbDJjT7fJMlvLrf4Jkm6+5oMXuyMOmrZWQEAAKyeRye51tzP85+TfSXJk5ZafJMkc9f+0ty9ww5M8shJkwRg3fmH7Fp8U0kuTPJ7GewC/cDufml3f3C5xTfJ4PO17j6zu9/W3b/T3XdMcsckr05y1fClc9+PTPKClfwyAGwuVXX/jC++qSRfS/KUJAd19yHdfY+5r0OS3DjJryQ5PTsX4swX4Tyrqu62Br8CALDFKMCBreVe2bnS/+3dff5Kg83d+2/ZeQUBOxEAbA63Gjn+Rnd/eSaZ7PDekePtSQ6eRSIArAv3yc7PN//Z3Z9babDu/mySj2bn5xsLDAAAAOvJfUeOO8mvd/cVyw3U3T9M8uvZdRGecYsdALBBVdWjMviMa3h3gMqgKOew7v6T7r5wNfru7i929zOSHJHk1OwYc+Y/e3tuVR24Gn0DsKGM7lIzP1a9NMkduvv148aq7r6ou/8hgx3XXpZdn222JXn2KuQLAGxxCnBgi6iq6ya5zkjzh6YQejTGLatq+xTiAjBb+w393EnOmlUiQ84c07bfmDYANrmq2ifJQSPN75pC6NEYh1fV6AsbAACAWZlfiGDeqd39nysN1t0fzY4J0fNxLbQGsLn8+tDP83/vX9zdv9Ldl65FAt391QyKSOcXv5m3T5Inr0UOAKxPVXWbJA/NzoWineR53f3/dvfVu4vR3Vd39wuTPC+7Fns+qqpuMP3MAYCtTAEObB3jVo759BTijoux/xTiArC+jG73DACzNO755hNTiDsaY3sUewIAAOtAVe2V5Bbzhxl8Xve2KYT+1+FuktxpCjEBWAeq6npJ7p+dd5H+QHf/wVrn0t0/SPILSb49cuqRa50LAOvKz2ZH0cz8WPXu7v6z5Qaau+fd2bnYc68kj5o0SQCAYQpwYOs4YEzbBVOIe/6YNgU4ABvfJUM/V5JDZpTHsEPGtF0ypg2AzW9cAc7/TCHu2WPaPN8AAADrwbjnoI9PIe5ojL2rykIEAJvDXTNYYGbYmhffzOvui5L8VXZMsK4kd7cDNcCWdp+R42uSPHuCeM+eizHsXhPEAwDYhQIc2DquGNM2urrMSnx3TNv1phAXgNn6+sjxLea2f56lh44cX5XknFkkAsDMjfs84ztTiDsuholnAADAejCuAOeMKcQd/Rww8RwEsFkcNnJ8QXefNJNMdnjHyPHeSW4+i0QAWBfunZ13antvd5+50mDdfUaS92bnYs97TCFPAIAfU4ADW8dFY9r2mkLcPce0XTWFuADM1qkZfCA17AWzSCRJqupaGaxWM5zT57r76hmlBMBsjXu+mcZzyOiqaInPTgAAgPVh3Dud1VqIwE6gAJvD8N/zTnL6rBIZMi4H4w7AFlRV186uCw28fwqh3ztyfNuq8q4HAJga/7CAreOiJJePtF13CnHH7Xbz/SnEBWCGuvuiJCdl55VhnlhVT55RSq9LcvDcz/M5vWdGuQAwexdm14KbaazQPC6G5xsAAGA9uHhM2xVTiHvlmLY9phAXgNkb/Xs+7m/+WjPuADDvgDFtn5xC3NEYFcWeAMAUKcCBLaK7O8mnMniomDeNrZzHPQxdMoW4AMzeq4d+ni/CeU1VvaCqaoF7pqqqDqiqdyR5bHbe/ebqDIpyANiCuvvKDHZrGx6PbjSF0OMWGLhsCnEBAAAmdWF23bVz3DPMco2L8YMpxAVg9i4d+rkynfkBk7rZmDafvwFsTaO73yTJeVOIOy6GAhwAYGq2zzoBYCoeXlW3XcJ1o6vJHJ7klAn7vt3I8Y+6+8IJYwKwPrwpye8mufXccWewCtmLkzy2ql6c5O3dffW0O66q/ZI8PclzM/jgbXgnnk7ymu4+d9r9ArAuHFRVB+/+snwxyd2Hjm+f5MsT9n3oyPE1Sc6fMCYAAMDEuvuHVfXFJHcYar5Bku9MGHpcAc7lE8YEYH04a+T40Kq6eXd/YybZDDxo5PiaJOfMIhEAZm50gYEk+fYU4o57RtpvCnEBAJIowIHNoJK8cBnXz09eTpIjk7xhwv6PGDmexkoEAKwD3X1lVf1Kkg9nx78b58eROyZ5a5KLq+qdSU5I8unuPnMlfVXV9gwmD9w7yUOSPDjJXtkxZg3vfnNWkhespB8A1r1K8vZlXD/8fHOnJG+bsP/R55sLunvcCyAAAIBp6t1fkiT5rww+l5t3uySnT9j3LcbkYiECgM3hcyPHleTZSX57BrmkqvaY63943Ptyd/9oFvkAMHMXjWnbNoW442J41wMATI0CHNgcaveX/FhnxyS1h0yh73uMxP7KFGICsE5098er6teTvGa4OYNxpDJYZfMpc1+pqh8kOTODgswLklySwYqZVyW5OoN/f+6V5LoZbPN8UJKDM3jRv8dQH+MKbyrJxUke2d2XTO2XBGC9We7zzbxjk/z+hH3fdST2pBPZAAAAdqeSfKpqyY9CwwsR3CHJOyfsf3Qhggu7+6oJYwKwDnT3eVV1WpLDs2P8eGZVva+7PzCDlP4kg12s53PpJO+bQR4ArA8XJrkig/kD86431z6Jcbt8/mDCmAAAP6YABza2pa6ItpBbV9WtuvvrK7m5qq6T5IHZ+QOyz06YEwDrTHf/fVX9KMmrkuwz3zx0yfDsgH0zePF/+DK6GDe7YHSMqyRnJ3lEd39xGbEB2DhW+nwz/zxy96o6oLu/s5IgcytwPiQ7P9+MrhIKAACwGla6EMGDkrxswr7vPBJ7RTtcA7BuvS7JX2THQp17JHl7Vf1qd//jWiRQVduT/N8kv5mdx7Geyw+ALai7r66qzyQ5eqj5oExegLP/mDYLfAIAUzONLfuA2agJv+Y9dYIcHpZk75G2UyaIB8A61d1vSnKvDP7Oj04I6JGvZHlj0uj9o8U9leQNSe7S3adN+VcDYPPYluQJE9x/vyQHjrSdOkE8AACApRr3+dhCX/PXV5J7V9W+E/Y9vBBBYiECgM3mtUnOGzruJNdK8saqendV3W21Oq6BxyQ5LYPim/mxZv7d0L9091dXq38AZuquVXW/3X0l+dbIfctZ6HMhh40cX9XdF0whLgBAEjvgwEb1+inGmmQXnWeMuf9jE8QDYB3r7i9U1T0zmNz8vAx2ukl2HQsm3aFt/gVMJ3lPkpd096cnjAnA+nVOJh875h2b5G9WeO+Tx7R9fOWpAAAA7NYkz0KdZK8kj0ly/EoCzH3Wd5ORPCxEALCJdPf3qur/JPm34eYM3sU8NMlDq+rzSd6W5IQkp3T3j1baX1Xtn+TeGRR4PjqDnQyG3/vMuyjJb6+0HwDWtUryimVcP7wgwF2SvGXC/o8YOR4t8gEAmEh1T2uOC7CVVNWRST4z0vzF7r7jLPIBYO1V1VFJHp/BC5pDx1yyu39oju6kkyTXJDk5ybuSvLm7z54kRwBYiqq6aZIzk+w51Hxudx88o5QAAIBNrKqumWK4T3T30SvM468z2JFgfsJbJ7mTXagBNp+q+v0kf5id390Mv6eZb78qyRlJvp7BzjkXJLkkyeVz567OYLHfvZJcN8n+GRTZHJzBjgM3GxN/tM8fJHlod//nhL8WAOvE3DPOcCHNcuy0I2d332XCXN6W5OeyY/w5obsfPElMAIBhCnCAFamq2yS57Ujzed198izyAWC2qupmSe6ewWoyhyY5JMkNkxyY5DoZTGjeI4OXM1ckuSzJxUnOT3JWktMzWF3z5O6+ZI3TB2CLq6r7J/nZkebTuvt1s8gHAABgtVXVgRnsSLrvUPOF3X3jGaUEwCqrqhckefG4U2PaVjKZaDTOaIxK8t0kP9/dH1lBfADWqaECnInCZLBg58Hd/c0V5rF3kguTXDs7Fhn48+5+3oS5AQD8mAIcAAAAAAAAgC2kqo5L8vSR5lO6+yWzyAeAtVFVD07y6gx2rFlswtBKdzBYLNZHkzy5u/9nBbEBWMcm3AFnWCd5YXe/fIV5PDzJu7LzLp9P6O63TJgXAMCPKcABAAAAAAAAAIAtoKquleQ5SZ6Z5IZzzasxeWh+EvZpSV7S3f+8Cn0AsA5U1YmZ3lhyRnc/bYV5vD3JI7NzAc7B3X3elHIDAFCAAwAAAAAAAAAAW0lV7ZPk55I8PskDk+w7cslyJhSN7nhwQZJ3J3lTd390xUkCwBJV1WFJvpydx6QzuvvWM0oJANikFOAAAAAAAAAAAMAWVVV7JrlnkrsnOSLJoUkOyWCHnL0XufXyJOcnOSvJ6UlOTfLp7j5tNfMFgFFVdbck9xlp/np3v2cW+QAAm5cCHAAAAAAAAAAAYBdVda0k10myZ5I9klyV5Iokl3X3lbPMDQAAANaaAhwAAABg06mqGyR52HBbd79hRukAAAAAAAAAALDBKcABAAAANp2qumeSTyb58Qcf3b3H7DICAAAAAAAAAGAj2zbrBAAAAABWWc06AQAAAAAAAAAANrbts04A2Piq6n4jTf/d3ZfPJBkANi3jDQAAAAAAAAAAADArCnCAaTgxSQ8dH5XkpNmkAsAmdmKMNwAAAAAAAAAAAMAMbJt1AsCmUrNOAIAtwXgDAAAAAAAAAAAArCk74AAAAAAAAAAAAKuqqg4eafpWd185k2QA2LSMNwDAalKAAwAAAAAAAAAArLazk/TQ8VFJTppNKgBsYmfHeAMArJJts04AAAAAAAAAAADYMmrWCQCwJRhvAICpU4ADAAAAAAAAAAAAAAAAi1CAAwAAAAAAAAAAAAAAAItQgAMAAAAAAAAAAAAAAACL2D7rBIDlq6onzToHADY/4w0AAAAAAAAAAADAgAIc2JiOT9KzTgKATe/4GG8AAAAAAAAAAAAAFODABlezTgCALcF4A8BGZhwDAAAAAAAAAGBiCnBgY1svuxKY0AawuRlvANiIvpTkmFknAQAAAACzUlX3m3UOAGx+xhsAYCtRgAMb2/BE5PUyORqAzcd4A8CG092XJfnorPMAAAAAgBk6Md7tALD6TozxBgDYIhTgwOZhVwAA1oLxBgAAAAAAYGPxfgeAtWC8AQA2PQU4sDFdkORGGawcUHPfb9rd588imaq6Zhb9ArDqjDcAAAAAAAAb33rZlcDEbIDNzXgDAGx622adALAip2TXB4UjZ5EIAJua8QYAAAAAAGDjq6EvAFgtxhsAYNNTgAMb0ylj2u625lkAsNkZbwAAAAAAADaXmuEXAFuH8QYA2JS2zzoBYEVOHtNmRwIAps14AwAAAAAAsHF9J8n+STqDCcmdwWJr355BLpXkzBn0C8DqM94AAFuGAhzYmIZ3JJh/cDEhGoBpM94AAAAAAABsXKckOTaD9zzzbtDdp84imSqbEgBsUsYbAGDL2DbrBIDl6+5vJrlgpPmgqvqJWeQDwOZkvAEAAAAAANjQThnTZrE1AKbNeAMAbBkKcGDjOiWDnQiGeXABYNqMNwAAAAAAABvTuAnRd1vzLADY7Iw3AMCWoQAHNi4rBwCwFow3AAAAAAAAG9Pwe57OYNE173kAmDbjDQCwZSjAgY3r5DFts1w5oEa+A7A5GG8AAAAAAAA2oO4+K8l3RpoPrqoDZ5EPAJuT8QYA2Eq2zzoBYMVOTvL5DFYNmLfHLBLpbsV8AJuX8QYAAAAAAGDjOiXJsdn5Xc/dknxgNukAsEkZbwCALUEBDmxQ3f2tJHeedR4AbG7GGwAAAAAAgA1tfkL0sCNjQjQA02W8AQC2BKuIAwAAAAAAAADA5nTK0M/zuxIcOYtE5tTIdwA2B+MNALAl2AEHAAAAAAAAAAA2p5OTXJodk6GT5FYzyuUnR46/NZMsAFgNxhsAYEuo7t79VQAAAAAAAAAAAAAAALBFbZt1AgAAAAAAAAAAAAAAALCeKcABAAAAAAAAAAAAAACARSjAAQAAAAAAAAAAAAAAgEVsn3UCwPpRVTdI8rDhtu5+w4zSAWCTMt4AAAAAAAAAAAAAG01196xzANaJqrpnkk8m+fEfhu7eY3YZAbAZGW8AAAAAAAAAAACAjWbbrBMA1q2adQIAbAnGGwAAAAAAAAAAAGDdU4ADAAAAAAAAAAAAAAAAi1CAAwAAAAAAAAAAAAAAAItQgAMAAAAAAAAAAAAAAACLUIADAAAAAAAAAAAAAAAAi1CAAwAAAAAAAAAAAAAAAItQgAMAAAAAAAAAAAAAAACLUIADAAAAAAAAAAAAAAAAi1CAAwAAAAAAAAAAAAAAAItQgAMAAAAAAAAAAAAAAACLUIADAAAAAAAAAAAAAAAAi1CAAwAAAAAAAAAAAAAAAItQgAOMU7NOAIAtwXgDAAAAAAAAAAAAbAjbZ50AsK58Kckxs04CgE3PeAMAAAAAAAAAAABsKNXds84BAAAAAAAAAAAAAAAA1q1ts04AAAAAAAAAAAAAAAAA1jMFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAAAAAAAAAAAAsAgFOAAAAAAAAAAAAAAAALAIBTgAAAAAAAAAAAAAAACwCAU4AAAAAABsKlV1y6p6QVW9s6rOqKpvV9XVVdUjXz+7hFjbq+rnq+qVVXVyVX2zqr4/JtZn1+J3AwAAAAAAAGZj+6wTAAAAAABgY6uqA5LcPsktk1w/ybWTXJ3ke0kuSHJmki929w/WII+/TfKYTGEBqqp6VJK/THKzSWMBAAAAAAAAG5sCHAAAAAAAlq2q7pTkF5M8LMnhSWo3t/yoqk5J8vYkb+nub0w5n4OSfCLJT04p3u8m+eNpxAIAAAAAAAA2vuruWecAAAAAAMAGUVX3T/IHSY6ZIMzVSf4pyR929xlTyusjSR6wzNt+rrvfMSbWA5N8MMvbRedz3X3nZfa/aVXVcaNt3f2+WeQCAAAAAAAA06AABwAAAACA3aqq/ZP8ZZInTTHsD5O8KMmfdPc1Kw1SVcdmUDAz6rQkr5/7fmmS0T6+2t3fGRPvv5LcZ6T5iiRvSnJCkm/N5T7se939heVnvzlV1S4vH7p7d7skAQAAAAAAwLqlAAcAAAAAgEVV1eFJ3pHkVru59LtJzkhySZI9khwwd8++u7nvfUke393fXWF+b03ymJHmf0/y6O6+apmxbpfkSyPNVyZ5QHd/YiX5bUUKcAAAAAAAANhsts86AQAAAAAA1q+qukuSDyU5cIFLTk/y6iTv6u6vjrl/W5K7Jnl0kqcmueGYGMcl+VBV/dS4HWmW4Ogxbc9dbvHNnPuOafsXxTcAAAAAAACwtW2bdQIAAAAAAKxPVXXLJB/M+OKby5P8epLbdfefjSu+SZLuvqa7T+7u5yc5NMmfJblmzKVHJnlPVe21zBxvnOQmI83f7O7TlxNnyF3GtJ24wlgAAAAAAADAJqEABwAAAACAXVTVtZL8e5Lrjzl9ZpIju/vvuvvqpcbs7su6+7lJHp7ke2MuOSrJK5aZ6g3GtJ27zBirGQ8AAAAAAADYBBTgAAAAAAAwzouT3GFM+zlJ7tvdX1tp4O5+XwZFOFeMOf20qnrYMsLtN6btBytKbHXiAQAAAAAAAJuAAhwAAAAAAHZSVbdP8qwxp65O8qju/uakfXT3R5M8Z4HTr6iqvZYYaqnXLdW04wEAAAAAAACbwPZZJwAAAAAAwLrzR0n2GNP+F919yhT7eWWSJya510j7IUl+Ze78plJVByS5cwa/4/WSXDfJlUm+n+SSDHYYOivJOd3dq9D/vknukuTQJDdMcq0k301yQZJzk3ymu6+adr8AAAAAAACw0dUqvL8DAAAAAGCDqqpbJDkzu+6gfm6S23T396fc3xFJPpukRk59rbtvM+b6qXyo3d1VVX+Y5A+mEO6PuvsPFzpZVTdJ8pQkT0hyuyXG/G6Sk5KcmORfu/v0lSZXVftkUOj0hCRHZ/HFuS5J8sEkr+7uDy6jj+OT/PJKcxzxlO4+fkqxAAAAAAAAYCpGX6ACAAAAALC1PSXjPzt+7bSLb5Kkuz+fQZHJqMOq6v7T7m8tVdUeVfX8JF9L8pIsvfgmSfZP8uAkL0vytap63Ar6r6p6SpKzk7wmyQOyePFNkuyX5NFJPlBV/1FVuxRBAQAAAAAAwFakAAcAAAAAgGE/N6btmiT/sIp9vm6B9p9dxT5XVVXtmeQfk7w8ybWnEHKfZfZ/vSRvT/L3SW68wj4fmuRTVXXfFd4PAAAAAAAAm4YCHAAAAAAAkiRVdZMkR4w59bHuPmcVu35bkh+OaT9uFftcbS9P8phFzn83yalJPprkhCSfyWCnnB9N2nFVHTAX85GLXHZxks8m+fBc3xcscN3+GeyGc+ykeQEAAAAAAMBGtn3WCQAAAAAAsG7cc4H2T65mp939w6r63Jj+b1NV+3X3JUNtR41cc9ckrxhpOzXJbyyh69cmed9I298muctI228m+e9F4pw7fFBVt0/yrDHXXZzkL5L8S3d/bVygqtqe5LAk90vy00kelGXsflNVleSNSe425vQlGfx+/5TktO7ukXvvlMHv+tQkewyd2ifJm6vqjt39vwt0/eIkfzd0PO5/M6P/3S3kjCVeBwAAAAAAAGtGAQ4AAAAAAPPuvED7yWvQ98nZtQCnMsjpo/MN3f2pnS6oGleccunodeN097nZtXjm0jGXfmkp8YY8KTsXsCSD3W0e2N3n7Sanq5J8ae7r76rq+kmekWShwpdRz0ny8DHt70vyxO6+eJG+P5fk16rq+CTvTHL9odM3yqBg6REL3HtGhgpnBnVAu1yznP8MAQAAAAAAYF3ZNusEAAAAAABYNw5doH2x3V+m5ZQF2hfKaT17yJi2Z+yu+Gac7r64u1/a3f+xu2ur6ieTvGzMqX9O8rDFim9G+vxEBjvv/HDk1M9U1ZFLiQEAAAAAAACbjQIcAAAAAADm3XSB9gvWoO+Fdni52Rr0PW03Hzn+XpIT16DfZyfZc6Tti0l+ubt7OYHmdsP5vTGnnrXC3AAAAAAAAGBDU4ADAAAAAMC8A8e0Xdnd31+Dvr+7QPsBa9D3tF1v5Piy5RbALFdVHZjkqWNO/U53j+5ks1R/l10Lox5TVddeYTwAAAAAAADYsBTgAAAAAAAw71pj2i5Zo74X6mdcTuvdaDHRjavq4FXu82eSjBbGnN7d71tpwLnCnX8dad4ryT1XGhMAAAAAAAA2KgU4AAAAAADM22NM2xVr1PdC/ey5Rv1P0xdHjivJq6pq71Xs835j2t42hbgfG9N27ynEBQAAAAAAgA1FAQ4AAAAAAPPGFcFcb436XqifH6xR/9P0njFtxyX5XFU9qapWY1efcQU4J08h7tlj2o6YQlwAAAAAAADYULbPOgEAAAAAANaN741pu05V7dHdV69y3/sv0D4up/XuVUl+N8kNRtpvk+T1SV5ZVR9M8pEMdpj5fHdftdLO5nbWudWYU/tW1b1WGnfOwWPaDpwwJgAAAAAAAGw4CnAAAAAAAJh3/pi2SrJfkm+vct/7LdA+Lqd1rbsvq6rHJXlvkj3HXLJvkkfOfSXJ96vq00k+PPf1ye7uZXR5/QXa37CMGMuhAAcAAAAAAIAtZ9usEwAAAAAAYN34xgLtt16Dvg9boH2hnNa17j4hyYOSnLeEy/dNckySFyf5eJL/qao/rqqfWGJ3a10Qs1CxFAAAAAAAAGxaCnAAAAAAAJj3xQXa774GfS/Ux0I5rXvd/bEMCotekOUVEt08ye8mObOqXlZV43bRGbb/ClNcqT3WuD8AAAAAAACYOQU4AAAAAADM++8F2u+2Bn2P6+N7Sb66Bn2vmu7+fne/PMkhSR6Y5P9L8pkkVy/h9n2S/F6SE6vqOotcd9WkeQIAAAAAAACL2z7rBAAAAAAAWDdOSXJZkuuOtB9bVXt091KKRpatqm6T5OAxpz7a3desRp9rbe73+MjcV+YKau6V5H5zX/dOstBON/dO8sYkP7fA+UsXaL99d395pTkDAAAAAAAAO9gBBwAAAACAJEl3/yjJh8acummS41ax66ct0P7eVexzprr78u7+UHf/fnc/IMkNkzwpyacWuOVnq+oBC5z7xgLt158sSwAAAAAAAGCeAhwAAAAAAIa9eYH2hYpkJlJVe2ZQeDLqR0neuhp9rkfdfUl3v7G7j0ryq0nG7TY07j+ndPdlSc4dc+oWU0wRAAAAAAAAtjQFOAAAAAAADHtnkvPHtD+iqo5ahf6eneRGY9rf3t0XrkJ/6153vzbJK8ecOnqR2z45pu2Y6WQEAAAAAAAAKMABAAAAAODHuvvKJH8y5tS2JK+Z27FmKqrqJ5P8wbg0krxkWv1sUG8Z03bQIte/e0zbw6pq7ynls1xXjDZM8387AAAAAAAAsNYU4AAAAAAAMOqVSb4+pv3wJC+dRgdzxRjHJ9l3zOnXd/dp0+hnA7toTNsei1z/jiSXj7T9RJJfm1pGy3PZmLZrr3kWAAAAAAAAMCUKcAAAAAAA2El3X5HkaRnsRDPquVX1nEnizxXfvDHJ/cacPj/Jb08Sf5M4dEzbeQtd3N2XJnnNmFMvqqrbTS2rpfvOmLZD1joJAAAAAAAAmBYFOAAAAAAA7KK7P5rkjxY4/WdV9Yqq2me5cavqoCTvTfLYMaevTPK47h5XvLEhVNVhVX1UiesAAAaQSURBVPXyqvqJCWJUkt8ac+rk3dz6kiQXj7Ttn+Q/plGEU1W3rqonLfHyL41pO2rSHAAAAAAAAGBWFOAAAAAAALCQFyV50wLnfiPJaVX1xKraa3eBqmr/qnpuBoUZDxpzSSd5xlzhz0a2b5LnJzm7qt5QVcfN7fizJFW1b5LXJnnwmNNvXuze7v52BjsXjTokyclV9ay5+EtWVdepqkdX1buSfDXJLy7x1lPGtP1WVe23nP4BAAAAAABgvajunnUOAAAAAACsU1W1Lcnrkjx5kcsuSvL+JJ9OckaSSzNYAOrAJIclOTrJsUmutcD9Vyd5ene/bgX5PSDJR0aaP9rdD1hurLl4Jya5/0jzMd194hLvv3OSU0eav5PkAxnsYPPfSc6ea7s0yd5JbpDkthn8Z/TLSW40JvSHkxzbS/hQv6pemOTFC5z+TpK3JPnYXJ4XJfnuXB7Xy+C/s9slOSLJ3ZMcM3du3vu7+7gl5HC7jN8F57wkb8ygQOeiJD8cc80Z3X3h7voAAAAAAACAtaQABwAAAACA3aqq5yR5eZIl7+ayRBcmeWx3jxbRLMkGKcCZ1DeSHN3d5yz1hqp6QZKXTjmPZIkFOHM5fCDJT62gj6d09/EruA8AAAAAAABWzbZZJwAAAAAAwPrX3X+e5Mgk/zWlkNckOT7J7VZafLNFfD7JvZdTfJMk3f2yJD+d5IIp53PlMq59agYFVgAAAAAAALDhKcABAAAAAGBJuvsL3X3fJMcmeVeWV4wx75Ikr0ly++5+SndfPM0c14GzkrwoyX8nmWQL+m8neU6SI7v73JUE6O73JDksg51wvj1BLlcmeW+SxyX5hWX0f26SuyZ5/wR9AwAAAAAAwLpQ3ZO8/wOA/7+9+1f5OYoDOP7+Kf+eSFkok4GFDDKQjCZX4SZchKtwCRYrxaxkYrBaZCGK1DH8TOITnifE6zWeTud8hu/6/h4AAADgf7XZbI5X16ur1fnqdHW82mkbn7xr+wLLi+pJ9ah6sNb6sIczXKhuf7X8dK116xfPu11d+Gr51lrr6S+cdbK6Vl2pLlVnqpPf2f6pel49ru5W99ZaH3/2zmGWw9WNtq/iXP4yy/d+0vWyetY2IrpfPVxrvdvl/WfbxjsXq3Ntv5Oj1aFvbL+51rqzm/sAAAAAAABgrwlwAAAAAADgN9lsNjvViepIdbB6X72pXu1lmPQDc+yvTlXHqgNf5nhbvd5tbAMAAAAAAAD/IgEOAAAAAAAAAAAAAAAADPb96QEAAAAAAAAAAAAAAADgbybAAQAAAAAAAAAAAAAAgIEABwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAgwAEAAAAAAAAAAAAAAICBAAcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIMABAAAAAAAAAAAAAACAgQAHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCDAAQAAAAAAAAAAAAAAgIEABwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAgwAEAAAAAAAAAAAAAAICBAAcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIMABAAAAAAAAAAAAAACAgQAHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCDAAQAAAAAAAAAAAAAAgIEABwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAgwAEAAAAAAAAAAAAAAICBAAcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIMABAAAAAAAAAAAAAACAgQAHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCDAAQAAAAAAAAAAAAAAgIEABwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGAgwAEAAAAAAAAAAAAAAICBAAcAAAAAAAAAAAAAAAAGAhwAAAAAAAAAAAAAAAAYCHAAAAAAAAAAAAAAAABgIMABAAAAAAAAAAAAAACAgQAHAAAAAAAAAAAAAAAABgIcAAAAAAAAAAAAAAAAGHwGGv87IzQCoFUAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# Windowed time lagged cross correlation\n", - "minutes = 5\n", - "fpm = 30\n", - "no_splits = 20\n", - "samples_per_split = df.shape[0]/no_splits\n", - "rss=[]\n", - "dfn = df.reset_index()\n", - "\n", - "for t in range(0, no_splits):\n", - " d1 = dfn['Activity_Act'].loc[(t)*samples_per_split:(t+1)*samples_per_split]\n", - " d2 = dfn['Activity_Fit'].loc[(t)*samples_per_split:(t+1)*samples_per_split]\n", - " rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " rss.append(rs)\n", - "rss = pd.DataFrame(rss)\n", - "f,ax = plt.subplots(figsize=(10,5))\n", - "sns.heatmap(rss,cmap='RdBu_r',ax=ax)\n", - "ax.set(title=f'Windowed Time Lagged Cross Correlation',xlim=[0,301], xlabel='Offset',ylabel='Window epochs')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);\n", - "\n", - "# Rolling window time lagged cross correlation\n", - "minutes = 5\n", - "fpm = 30\n", - "window_size = 300 #samples\n", - "t_start = 0\n", - "t_end = t_start + window_size\n", - "step_size = 30\n", - "rss=[]\n", - "while t_end < 5400:\n", - " d1 = dfn['Activity_Act'].iloc[t_start:t_end]\n", - " d2 = dfn['Activity_Fit'].iloc[t_start:t_end]\n", - " rs = [crosscorr(d1,d2, lag, wrap=False) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " rss.append(rs)\n", - " t_start = t_start + step_size\n", - " t_end = t_end + step_size\n", - "rss = pd.DataFrame(rss)\n", - "\n", - "f,ax = plt.subplots(figsize=(10,10), dpi=400)\n", - "sns.heatmap(rss,cmap='RdBu_r',ax=ax)\n", - "ax.set(title=f'Rolling Windowed Time Lagged Cross Correlation',xlim=[0,301], xlabel='Offset',ylabel='Epochs')\n", - "ax.set_xticks([0, 50, 100, 151, 201, 251, 301])\n", - "ax.set_xticklabels([-150, -100, -50, 0, 50, 100, 150]);" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "At offset close to 0, seeing high correlation across many of the epochs, with some epochs with lower correlation values regardless of offset, meaning there are periods with low correlation between the two devices' activity data." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Code to shift time series data: [Andres Araujo](https://stackoverflow.com/questions/33171413/cross-correlation-time-lag-correlation-with-pandas)" - ] - }, - { - "cell_type": "code", - "execution_count": 49, - "metadata": {}, - "outputs": [], - "source": [ - "def df_shifted(df, target=None, lag=0):\n", - " if not lag and not target:\n", - " return df \n", - " new = {}\n", - " for c in df.columns:\n", - " if c == target:\n", - " new[c] = df[target]\n", - " else:\n", - " new[c] = df[c].shift(periods=lag)\n", - " return pd.DataFrame(data=new)" - ] - }, - { - "cell_type": "code", - "execution_count": 50, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Offset is 1.0 frames\n" - ] - } - ], - "source": [ - "print(\"Offset is %s frames\" % offset)\n", - "if offset > 1:\n", - " df_new = df_shifted(df, 'Activity_Act', lag = int(offset))\n", - "\n", - " overall_pearson_r_new = df_new.corr().iloc[0,1]\n", - " print(f\"Pandas computed Pearson r: {overall_pearson_r_new}\")\n", - " # out: Pandas computed Pearson r: 0.2058774513561943\n", - "\n", - " r_new, p_new = stats.pearsonr(df_new.dropna()['Activity_Act'], df_new.dropna()['Activity_Fit'])\n", - " print(f\"Scipy computed Pearson r: {r_new} and p-value: {p_new}\")\n", - " # out: Scipy comput\n", - " \n", - " f_new,ax_new=plt.subplots(figsize=(7,3))\n", - " df_new.set_index('Time').rolling(window=30,center=True).median().plot(ax=ax)\n", - " ax_new.set(xlabel='Time',ylabel='Pearson r')\n", - " ax_new.set(title=f\"Overall Pearson r = {np.round(overall_pearson_r,2)}\");" - ] - }, - { - "cell_type": "code", - "execution_count": 172, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-10-24 16:30:00 NaN\n", - "1 2019-10-24 16:31:00 NaN\n", - "2 2019-10-24 16:32:00 NaN\n", - "3 2019-10-24 16:33:00 NaN\n", - "4 2019-10-24 16:34:00 NaN\n", - "... ... ..\n", - "20123 2019-11-07 15:53:00 NaN\n", - "20124 2019-11-07 15:54:00 NaN\n", - "20125 2019-11-07 15:55:00 NaN\n", - "20126 2019-11-07 15:56:00 NaN\n", - "20127 2019-11-07 15:57:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-10-18 15:30:00 NaN\n", - "1 2019-10-18 15:31:00 NaN\n", - "2 2019-10-18 15:32:00 NaN\n", - "3 2019-10-18 15:33:00 NaN\n", - "4 2019-10-18 15:34:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-11 17:20:00 NaN\n", - "1 2019-11-11 17:21:00 NaN\n", - "2 2019-11-11 17:22:00 NaN\n", - "3 2019-11-11 17:23:00 NaN\n", - "4 2019-11-11 17:24:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-24 11:45:00 NaN\n", - "1 2020-01-24 11:46:00 NaN\n", - "2 2020-01-24 11:47:00 NaN\n", - "3 2020-01-24 11:48:00 NaN\n", - "4 2020-01-24 11:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-11 13:50:00 NaN\n", - "1 2019-11-11 13:51:00 NaN\n", - "2 2019-11-11 13:52:00 NaN\n", - "3 2019-11-11 13:53:00 NaN\n", - "4 2019-11-11 13:54:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-05 15:15:00 NaN\n", - "1 2019-11-05 15:16:00 NaN\n", - "2 2019-11-05 15:17:00 NaN\n", - "3 2019-11-05 15:18:00 NaN\n", - "4 2019-11-05 15:19:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-05 14:15:00 NaN\n", - "1 2019-12-05 14:16:00 NaN\n", - "2 2019-12-05 14:17:00 NaN\n", - "3 2019-12-05 14:18:00 NaN\n", - "4 2019-12-05 14:19:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-07 14:50:00 NaN\n", - "1 2019-11-07 14:51:00 NaN\n", - "2 2019-11-07 14:52:00 NaN\n", - "3 2019-11-07 14:53:00 NaN\n", - "4 2019-11-07 14:54:00 NaN\n", - "... ... ..\n", - "20123 2019-11-21 14:13:00 NaN\n", - "20124 2019-11-21 14:14:00 NaN\n", - "20125 2019-11-21 14:15:00 NaN\n", - "20126 2019-11-21 14:16:00 NaN\n", - "20127 2019-11-21 14:17:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-07 14:45:00 NaN\n", - "1 2020-02-07 14:46:00 NaN\n", - "2 2020-02-07 14:47:00 NaN\n", - "3 2020-02-07 14:48:00 NaN\n", - "4 2020-02-07 14:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-22 21:45:00 NaN\n", - "1 2020-01-22 21:46:00 NaN\n", - "2 2020-01-22 21:47:00 NaN\n", - "3 2020-01-22 21:48:00 NaN\n", - "4 2020-01-22 21:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-29 13:45:00 NaN\n", - "1 2020-01-29 13:46:00 NaN\n", - "2 2020-01-29 13:47:00 NaN\n", - "3 2020-01-29 13:48:00 NaN\n", - "4 2020-01-29 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-02-12 13:08:00 NaN\n", - "20124 2020-02-12 13:09:00 NaN\n", - "20125 2020-02-12 13:10:00 NaN\n", - "20126 2020-02-12 13:11:00 NaN\n", - "20127 2020-02-12 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-04 11:45:00 NaN\n", - "1 2019-12-04 11:46:00 NaN\n", - "2 2019-12-04 11:47:00 NaN\n", - "3 2019-12-04 11:48:00 NaN\n", - "4 2019-12-04 11:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-12-02 10:45:00 NaN\n", - "1 2019-12-02 10:46:00 NaN\n", - "2 2019-12-02 10:47:00 NaN\n", - "3 2019-12-02 10:48:00 NaN\n", - "4 2019-12-02 10:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-01-27 13:45:00 NaN\n", - "1 2020-01-27 13:46:00 NaN\n", - "2 2020-01-27 13:47:00 NaN\n", - "3 2020-01-27 13:48:00 NaN\n", - "4 2020-01-27 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-02-10 13:08:00 NaN\n", - "20124 2020-02-10 13:09:00 NaN\n", - "20125 2020-02-10 13:10:00 NaN\n", - "20126 2020-02-10 13:11:00 NaN\n", - "20127 2020-02-10 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2019-11-08 23:45:00 NaN\n", - "1 2019-11-08 23:46:00 NaN\n", - "2 2019-11-08 23:47:00 NaN\n", - "3 2019-11-08 23:48:00 NaN\n", - "4 2019-11-08 23:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20076\n", - "[]\n", - "subject 20076 no fitbit data available\n", - "20103\n", - "[15]\n", - "merging 20103_2_20_2020_4_45_00_PM_New_Analysis.csv with WA_20103_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-20 16:45:00 NaN\n", - "1 2020-02-20 16:46:00 NaN\n", - "2 2020-02-20 16:47:00 NaN\n", - "3 2020-02-20 16:48:00 NaN\n", - "4 2020-02-20 16:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20105\n", - "[16]\n", - "merging 20105_2_20_2020_1_45_00_PM_New_Analysis.csv with WA_20105_minuteStepsNarrow_20190901_20200327.csv\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - " Time R\n", - "0 2020-02-20 13:45:00 NaN\n", - "1 2020-02-20 13:46:00 NaN\n", - "2 2020-02-20 13:47:00 NaN\n", - "3 2020-02-20 13:48:00 NaN\n", - "4 2020-02-20 13:49:00 NaN\n", - "... ... ..\n", - "20123 2020-03-05 13:08:00 NaN\n", - "20124 2020-03-05 13:09:00 NaN\n", - "20125 2020-03-05 13:10:00 NaN\n", - "20126 2020-03-05 13:11:00 NaN\n", - "20127 2020-03-05 13:12:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20108\n", - "[17]\n", - "merging 20108_2_25_2020_4_45_00_PM_New_Analysis.csv with WA_20108_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-25 16:45:00 NaN\n", - "1 2020-02-25 16:46:00 NaN\n", - "2 2020-02-25 16:47:00 NaN\n", - "3 2020-02-25 16:48:00 NaN\n", - "4 2020-02-25 16:49:00 NaN\n", - "... ... ..\n", - "20123 NaT NaN\n", - "20124 NaT NaN\n", - "20125 NaT NaN\n", - "20126 NaT NaN\n", - "20127 NaT NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20113\n", - "[18]\n", - "merging 20113_2_28_2020_2_15_00_PM_New_Analysis.csv with WA_20113_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-02-28 14:15:00 NaN\n", - "1 2020-02-28 14:16:00 NaN\n", - "2 2020-02-28 14:17:00 NaN\n", - "3 2020-02-28 14:18:00 NaN\n", - "4 2020-02-28 14:19:00 NaN\n", - "... ... ..\n", - "20123 2020-03-13 13:38:00 NaN\n", - "20124 2020-03-13 13:39:00 NaN\n", - "20125 2020-03-13 13:40:00 NaN\n", - "20126 2020-03-13 13:41:00 NaN\n", - "20127 2020-03-13 13:42:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n", - "20115\n", - "[19]\n", - "merging 20115_3_12_2020_2_40_00_PM_New_Analysis.csv with WA_20115_minuteStepsNarrow_20190901_20200327.csv\n", - " Time R\n", - "0 2020-03-12 14:40:00 NaN\n", - "1 2020-03-12 14:41:00 NaN\n", - "2 2020-03-12 14:42:00 NaN\n", - "3 2020-03-12 14:43:00 NaN\n", - "4 2020-03-12 14:44:00 NaN\n", - "... ... ..\n", - "20123 2020-03-26 14:03:00 NaN\n", - "20124 2020-03-26 14:04:00 NaN\n", - "20125 2020-03-26 14:05:00 NaN\n", - "20126 2020-03-26 14:06:00 NaN\n", - "20127 2020-03-26 14:07:00 NaN\n", - "\n", - "[20128 rows x 2 columns]\n" - ] - } - ], - "source": [ - "r_window_size = 120\n", - "rolling_r = []\n", - "rdf = pd.DataFrame(columns = ['Time', 'R'])\n", - "\n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " act = pd.read_csv(f, skiprows=header_offset + 6)\n", - " act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - " act = act.resample('1T', on='Time').sum()\n", - " \n", - " fit = pd.read_csv(fitbit_files[indices[0]])\n", - " fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - " fit['Activity'] = fit['Steps']\n", - "\n", - " df = pd.merge(act, fit, on = 'Time', suffixes = ('_Act', '_Fit'))\n", - " df = df[['Time', 'Activity_Act', 'Activity_Fit']]\n", - " \n", - " rolling_r = df['Activity_Act'].rolling(window=r_window_size, center=True).corr(df['Activity_Fit'])\n", - " rdf['Time'] = df['Time']\n", - " rdf['R'] = rolling_r\n", - " print(rdf)\n", - " rdf.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/correlation/\" + subject + \"_\" + str(r_window_size) + \"_window_rolling_r.txt\")\n", - " \n", - "# df.set_index('Time')\n", - "\n", - "# d1 = df[['Time','Activity_Act']]\n", - "# d2 = df[['Time','Activity_Fit']]\n", - " \n", - "# d1.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/\" + subject + \"_act.txt\", sep = \" \", header = False, index = False)\n", - "# d2.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/fitbit/\" + subject + \"_fit.txt\", sep = \" \", header = False, index = False) \n", - " " - ] - }, - { - "cell_type": "code", - "execution_count": 211, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:13: FutureWarning: Sorting because non-concatenation axis is not aligned. A future version\n", - "of pandas will change to not sort by default.\n", - "\n", - "To accept the future behavior, pass 'sort=False'.\n", - "\n", - "To retain the current behavior and silence the warning, pass 'sort=True'.\n", - "\n", - " del sys.path[0]\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
RSubjectTimeUnnamed: 0
0NaN100112019-10-24 16:30:000.0
1NaN100112019-10-24 16:31:001.0
2NaN100112019-10-24 16:32:002.0
3NaN100112019-10-24 16:33:003.0
4NaN100112019-10-24 16:34:004.0
\n", - "
" - ], - "text/plain": [ - " R Subject Time Unnamed: 0\n", - "0 NaN 10011 2019-10-24 16:30:00 0.0\n", - "1 NaN 10011 2019-10-24 16:31:00 1.0\n", - "2 NaN 10011 2019-10-24 16:32:00 2.0\n", - "3 NaN 10011 2019-10-24 16:33:00 3.0\n", - "4 NaN 10011 2019-10-24 16:34:00 4.0" - ] - }, - "execution_count": 211, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "subjects = []\n", - "for f in glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/*_act.txt\"):\n", - " subjects.append(str.split(f, \"actiwatch/\")[1][0:5])\n", - "\n", - "subjects \n", - "\n", - "dfcor = pd.DataFrame(columns = ['Time', 'R','Subject'])\n", - "a = pd.DataFrame()\n", - "\n", - "for subject in subjects:\n", - " a = pd.read_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/correlation/\" + subject + \"_10_window_rolling_r.txt\")\n", - " a.loc[:,'Subject'] = subject\n", - " dfcor = pd.concat((dfcor, a))\n", - "\n", - "dfcor[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 232, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Subject Hour\n", - "10011 0.0 0.139213\n", - " 1.0 0.061152\n", - " 2.0 0.135681\n", - " 3.0 0.225732\n", - " 4.0 0.150240\n", - " ... \n", - "20115 19.0 0.377630\n", - " 20.0 0.194753\n", - " 21.0 0.328070\n", - " 22.0 0.221494\n", - " 23.0 0.180645\n", - "Name: R, Length: 480, dtype: float64" - ] - }, - "execution_count": 232, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "import datetime as dt\n", - "\n", - "dfcor['Time'] = pd.to_datetime(dfcor['Time'])\n", - "dfcor['Hour'] = dfcor['Time'].dt.hour\n", - "dfcor['Hour'] = dfcor['Hour'].astype(float)\n", - "dfm = dfcor.groupby(['Subject', 'Hour']).mean()['R']\n", - "dfm" - ] - }, - { - "cell_type": "code", - "execution_count": 243, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Hour\n", - "0.0 0.281796\n", - "1.0 0.282439\n", - "2.0 0.283439\n", - "3.0 0.280574\n", - "4.0 0.230017\n", - "5.0 0.242924\n", - "6.0 0.293340\n", - "7.0 0.325577\n", - "8.0 0.332633\n", - "9.0 0.366684\n", - "10.0 0.390324\n", - "11.0 0.362339\n", - "12.0 0.393035\n", - "13.0 0.392728\n", - "14.0 0.366866\n", - "15.0 0.379989\n", - "16.0 0.389629\n", - "17.0 0.380125\n", - "18.0 0.364146\n", - "19.0 0.360860\n", - "20.0 0.355317\n", - "21.0 0.354799\n", - "22.0 0.363602\n", - "23.0 0.309182\n", - "Name: R, dtype: float64" - ] - }, - "execution_count": 243, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "dfm.groupby('Hour').mean()" - ] - }, - { - "cell_type": "code", - "execution_count": 242, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 242, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "dfm.groupby('Hour').mean().plot(figsize = (10, 8))" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_minuteStepsNarrow_20190901_20200327.csv\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_minuteStepsNarrow_20190901_20200327.csv\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_minuteStepsNarrow_20190901_20200327.csv\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_minuteStepsNarrow_20190901_20200327.csv\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_minuteStepsNarrow_20190901_20200327.csv\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_minuteStepsNarrow_20190901_20200327.csv\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_minuteStepsNarrow_20190901_20200327.csv\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_minuteStepsNarrow_20190901_20200327.csv\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_minuteStepsNarrow_20190901_20200327.csv\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_minuteStepsNarrow_20190901_20200327.csv\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_minuteStepsNarrow_20190901_20200327.csv\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_minuteStepsNarrow_20190901_20200327.csv\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_minuteStepsNarrow_20190901_20200327.csv\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_minuteStepsNarrow_20190901_20200327.csv\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_minuteStepsNarrow_20190901_20200327.csv\n", - "20076\n", - "[]\n", - "subject 20076 no fitbit data available\n", - "20103\n", - "[15]\n", - "merging 20103_2_20_2020_4_45_00_PM_New_Analysis.csv with WA_20103_minuteStepsNarrow_20190901_20200327.csv\n", - "20105\n", - "[16]\n", - "merging 20105_2_20_2020_1_45_00_PM_New_Analysis.csv with WA_20105_minuteStepsNarrow_20190901_20200327.csv\n", - "20108\n", - "[17]\n", - "merging 20108_2_25_2020_4_45_00_PM_New_Analysis.csv with WA_20108_minuteStepsNarrow_20190901_20200327.csv\n", - "20113\n", - "[18]\n", - "merging 20113_2_28_2020_2_15_00_PM_New_Analysis.csv with WA_20113_minuteStepsNarrow_20190901_20200327.csv\n", - "20115\n", - "[19]\n", - "merging 20115_3_12_2020_2_40_00_PM_New_Analysis.csv with WA_20115_minuteStepsNarrow_20190901_20200327.csv\n" - ] - } - ], - "source": [ - "def crosscorr(datax, datay, lag=0, wrap=False):\n", - " \"\"\" Lag-N cross correlation. \n", - " Shifted data filled with NaNs \n", - " \n", - " Parameters\n", - " ----------\n", - " lag : int, default 0\n", - " datax, datay : pandas.Series objects of equal length\n", - " Returns\n", - " ----------\n", - " crosscorr : float\n", - " \"\"\"\n", - " if wrap:\n", - " shiftedy = datay.shift(lag)\n", - " shiftedy.iloc[:lag] = datay.iloc[-lag:].values\n", - " return datax.corr(shiftedy)\n", - " else: \n", - " return datax.corr(datay.shift(lag))\n", - "\n", - "cc = []\n", - "metrics = []\n", - " \n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " act = pd.read_csv(f, skiprows=header_offset + 6)\n", - " act['Time'] = pd.to_datetime(act['Date'] + ' ' + act['Time'])\n", - " act = act.resample('T', on='Time').sum()\n", - " \n", - " fit = pd.read_csv(fitbit_files[indices[0]])\n", - " fit['Time'] = pd.to_datetime(fit['ActivityMinute'])\n", - " fit['Activity'] = fit['Steps']\n", - "\n", - " df = pd.merge(act, fit, on = 'Time', suffixes = ('_Act', '_Fit'))\n", - " df = df[['Time', 'Activity_Act', 'Activity_Fit']]\n", - " df.set_index('Time')\n", - "\n", - " d1 = df['Activity_Act']\n", - " d2 = df['Activity_Fit']\n", - " minutes = 5\n", - " fpm = 30\n", - " rs = [crosscorr(d1,d2, lag) for lag in range(-int(minutes*fpm),int(minutes*fpm+1))]\n", - " offset = np.ceil(len(rs)/2)-np.argmax(rs)\n", - " \n", - " cc.append([subject, max(rs), offset])" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
subjectcross_coroffset
0100110.4637741.0
1100120.7624351.0
2100140.5967351.0
3100160.7503651.0
4100230.6505561.0
\n", - "
" - ], - "text/plain": [ - " subject cross_cor offset\n", - "0 10011 0.463774 1.0\n", - "1 10012 0.762435 1.0\n", - "2 10014 0.596735 1.0\n", - "3 10016 0.750365 1.0\n", - "4 10023 0.650556 1.0" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cc_df = pd.DataFrame(cc, columns = ['subject', 'cross_cor', 'offset'])\n", - "cc_df.to_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/crosscor.csv\")\n", - "cc_df[0:5]" - ] - }, - { - "cell_type": "code", - "execution_count": 64, - "metadata": { - "scrolled": false - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Mean Cross-Correlation')" - ] - }, - "execution_count": 64, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACIYAAAV2CAYAAADlECVqAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAA9hAAAPYQB1ayvdAAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xe4LFWVsPF3kZMkAUGCBFEUFBAFDCAYBhUDoqiAylVnzI5hHPOnmLMyY86KIirmGQMjwZxAQEFQQIIBAZEsGdb3x66r10vtPh2q+/Tp8/6epx6xqnrXut2VTu1Va0dmIkmSJEmSJEmSJEmSpNmzwnwHIEmSJEmSJEmSJEmSpPEwMUSSJEmSJEmSJEmSJGlGmRgiSZIkSZIkSZIkSZI0o0wMkSRJkiRJkiRJkiRJmlEmhkiSJEmSJEmSJEmSJM0oE0MkSZIkSZIkSZIkSZJmlIkhkiRJkiRJkiRJkiRJM8rEEEmSJEmSJEmSJEmSpBllYogkSZIkSZIkSZIkSdKMMjFEkiRJkiRJkiRJkiRpRpkYIkmSJEmSJEmSJEmSNKNMDJEkSZIkSZIkSZIkSZpRJoZIkiRJkiRJkiRJkiTNKBNDJEmSJEmSJEmSJEmSZpSJIZIkSZIkSZIkSZIkSTPKxBBJkiRJkiRJkiRJkqQZZWKIJEmSJEmSJEmSJEnSjDIxRJIkSZIkSZIkSZIkaUaZGCJJkiRJkiRJkiRJkjSjTAyRJEmSJEmSJEmSJEmaUSaGSJIkSZIkSZIkSZIkzSgTQyRJkiRJkiRJkiRJkmaUiSGSJEmSJEmSJEmSJEkzysQQSZIkSZIkSZIkSZKkGWViiCRJkiRJkiRJkiRJ0owyMUSSJEmSJEmSJEmSJGlGmRgiSZIkSZIkSZIkSZI0o0wMkSRJkiRJkiRJkiRJmlEmhkiSJEmSJEmSJEmSJM0oE0MkSZIkSZIkSZIkSZJmlIkhkiRJkiRJkiRJkiRJM8rEEEmSJEmSJEmSJEmSpBllYogkSZIkSZIkSZIkSdKMMjFEkiRJkiRJkiRJkiRpRpkYIkmSJEmSJEmSJEmSNKNMDJEkSZIkSZIkSZIkSZpRJoZIkiRJkiRJkiRJkiTNKBNDJEmSJEmSJEmSJEmSZpSJIZIkSZIkSZIkSZIkSTPKxBBJkiS1iojDIiJbphfMd2xtImKnSrynzHdsy4uIr1Zi3W++Y5M0PyLivZXzwnPnOzZpLhHx2Mr++8X5jk2SpPkQEedVro1bzndsC1VEHFr5Tg+d79gkSVoIVprvACRJkiRJkqTFLiJWA9YB1gRWBa4HrgH+kpk3z2ds0rSLiFWAdSnHz2rADcC1lOPnxvmMTZIkSZoGJoZIkiTNs+btltdMcJMvzMzDJrg9SQtAU7HmKz1WeUNm/r9JxSNJsywiNgP2Bu4N7AxsBdyusvotEXExcAZwKvBD4HuZefEkYpWmTURsSDl+7gPsAmwNbAJEy+oZEZcAv6UcPz+mHD9/mFC4kiRJ0lQwMUSSJEmSBLBkjuVPjohXZ2ZOIhhJmjURsRbwFOBAYHfaO7HbrABs3Ex7A/9O6ez+CfAF4NOZeWn3EUvTIyJWBQ4CngjcH1ix348CGzbT/YBnNe2dDBwFfDIz/9x5wJIkSdKUMTFEkiRJYxURGwPPbFl0YWZ+cNLxzJKI2A54Qsui32Tm5yYdzyCacvkva1l0XWa+ZdLxLHbNm7cPm2O1LYAHAMeOP6LpERHPBjZqWfR+39bX8iLiFcAqLYvelJk3TDoeTYeIWBN4CfA8YL2umqVUS7gP8OaIOAJ4Y2ae11H70lSIiJUpyVAvpiRHdWXnZnpdRHwJeH1m/rrD9qVFIyKWAFu2LPqk1yVJkqaHiSGSJEkat41pHyrnl4CJIaPZjvbv9mvAVCeGUMZ+b4v9CsDEkMk7GFi5j/WWsMgSQ4BnA9u3zP8iYGKIlvcKYM2W+e8ATAxZhCLikcB7gc3HuJnVgX8FDomIDwCvzswrxrg9aSIiYg/gQ8BdxriZlYDHAwdExGeAl2TmRWPcnjSLllAq+Szvu8B5kwxEkiTVrTDfAUiSJEmS5t2SPtfbPyJuM85AJGkWRMRKEfEuSrLmOJNClrW0ssLxE9qeNBZRvIyyL48zKWRZKwBPBk6d0PYkSZKkibJiiCRJ0nTbB7ig4zYdQ1vS30XETsCOfa6+BnAA8PHxRSRJC1tErA58hXIfN5e/AEcDPwJOB84FLgeuoQxLdBtgM2BbYFdgb2AnylAyNWsPG7s03yJiReATwJP6WP0K/nH8nEY5fi4F/kZ57r0WcHvK8bMLsBflOFqxR5seP5IkSZpJJoZIkiRNtzPna0zezHwB8IL52Pasy8z95jsGaRlLhljfxJCOZeZzgefOdxySRtMkhXyDksDRy/HA24HvZOZNlXWubaaLgZOAzzfb2IoyBNizgU06CFuaChGxAvBZ4HFzrHoi8Dbg65l5fWWdm4DrgEuAXwFfaraxCXAg8Bxg6w7CljQhmXkocOg8hyFJ0oLlUDKSJEmStEhFxMrAQZXFP63Mv19E2JEiSe0+Tu+kkPOBh2bmAzLzWz2SQqoy89zMfAOwFSWh7K/DhSpNnbfTOynkL8BBmXmvzDyqR1JIVWb+OTPfBdyJMnTMH4cLVZIkSVpYTAyRJEmSpMVrX2DDlvlJ6Sy5rGVZAIeMMyhJWogi4iXAE3qscjSwY2Z+u4vtZeb1mfk+4M7A4V20Kc2XiDgYeFGPVU4AdsrMI7vYXmbenJmfBu4CvJty7yNJkiTNLBNDJEmSJGnxWlKZ//3MPAv4QmX5kyMixhOSJC08EbE98Poeq3wZ2Dczr+h625n518w8BHgScHXX7UvjFhG3B97bY5UfAntl5gVdbzszr87MFwEPoww7I0mSJM0kE0MkSZIkaRGKiA0pnSBtPt38b+0N9C2BvToOSZIWso8Cq1SW/QQ4MDNvHmcAmfkZ4P7An8e5HWkM/htYt7LsLODhmXnNOANoKvnsBpw5zu1IkiRJ88XEEEmSJElanA4GVm6Zfx3wRYDM/DHwu8rnl4wnLElaWCJiP2D3yuLLgcdn5g2TiCUzTwIeOYltSV2IiHsBj6ksvhE4YByVdtpk5jmU5CpJkiRp5qw03wFIkiRptkTExsAGy8zaprLqahGxw4DNn52Z1w0X2a01D6IfCdwL2A5YH1gD+BvlbdtfA8cBX87MeX/7NiK2ANZeZtYWlVVvM8R3e3pm3jJcZHOLiNsCmywz6zaVVVcYIvbzM/Oq4SKDiNgGeAhwX+BOlO91Lcqb39cAfwXOAU4Gvgf8X2ZeP+z2psghlfn/s1wHzGeA17Ss95iIeE5mTnTYgohYCdiD8nvdE9gK2BRYk5LocjVwJfAn4HTgNMrvdnJm5hxtrwbccbnZq1ZWv+OAo+lckpkXDvIB9Sci7gLcB7grcBdga2AdyvlyVUqy0+XAH4EzgBOAozOzlvTU73bX5tbn4doLOHeJiGsHaP6CzLx0uMiKiNgAeDBwb2B7SqWf21KOlZspx8kVwNmUY+Vk4JhJ7afN77Yf5bfbnnLvsDpwKXAxcD7wf8A3M/PsScQ0gtf2WPaazPzDxCIBMvOycbQbEStTOs3/BdiRcs1cj7JPXUM5xo7KzEOHbH9H/rHPbss/zu0rUu7NLqYkK54AHE8Z9mysVViaa87ewK7AzpT7xXWaaQ3gesq//WrKded8yj3DL4CfZOZFHcayNrAPcI8mli3553PdNc10JfD7JpazgJ8BJ0z6ej2AQ3ssOywzfzmpQKC74yciVqRUV9uLcr+yDbAR/zgH/41yzJxFqSr0f5l5ahfbHlZErAE8iHIc7kC5J1q6r18FnAd8IDM/3NH2dgEeSvlb7M6U72ctSkLQhZR7t8eO0P42lH/LfZr2t6D8DbI6cC3lerP0Hv94ym/Q2d+a4xYRm1Huiben3P8sPSevTfnNbqD8bn+iXOtPBI6hj3viOba7MuX7XNaaldW3iohBhmi6LDP/NFxk3YqIe1COh90p16TbU/6dK3Dra9JxwA/G+fd0PyJid279fGMlyjBZF1PON98CvuXfJZK0SGWmk5OTk5OTk5PTPE6Uh6FZmbacx7gOq8T0giE/18W0U4/t7lT5zCkt6z6S8sC+3+3eQBlaY/OOvtuvVraz35Cf62Jad8z70wvGGHvP760ST1A6JH80xPYuB94DbDZfx2cHv8fde/z7HrHcunfsse6SCca8DfBeyoPNYfaTiyhDPezWYxv3HON++o45/n3vrXzuuX18N8+ofPZ9I3zfx/b4t4zS7vcqbd53gDbWAB4PfJaSxDfsb3IC8ERghSH/LY8d4/4y5+9eiSmAh1MSKm4aYru3AKcALwM26uC7+GLLuvemdEwNEtf/Anee1PlmwO/8vj3iPhdYab5j7BF7X+cdSifqK4AL+vitjhkwhpWBf6Uk4w66v15AuY/u/B6Gksz6Tkrn9CjH8pnAm4AdR4hlF+AIStLHsHHcREk+eCGw6Xzve8v827ZszjttMV8BrD3fMQ7xb1ofeP2Q+86plIpsnZw3gG9XtvOQlpjfDlzWR4wfrGzriZX1P7PcegE8CfhVH9u6eoh/84pNLD8f4vu/HHgXsHFH3/95le1sOWR7K1ISXT5IObcMez44B3gxsMYIx+0o58Ve0yfn2Pahlc8d2tFvtgrwTOA3Q8T+J+BVdHTeGuTfSvm79pQBYr0Z+Ahwuy5idXJycnJaOJNDyUiSJGnRiIg1IuKzwNcob1v2a2XKA8bfRMRTxxKcJiYi7gz8APgK5Q3CQa0DPBc4KyJe3rxNvNA8pTL/Ekonwt9leVP/J5X1l3QYU6uIWD8i3k95AP4cSsWDYWwEPA34aUQc3VV8U+L4yvwHDNNYUzml17ExbLur0z7cxtWUDpy5Pr9eRBxBeePxc8CBwMbDxNK4JyXp7xcRcbcR2pkKzVuiJwD/Q+k4WnGYZiiVIN4M/DEiDukwvpUi4l3AD4EHDvjxfYHTIuJ5XcXToaf1WHZYZt40sUjGoNmvTgPeyD9X/uqi7ftSOsI/Qqn4M6hNKBWtftfVvhrFcyidgi8Cbjdik9sCLwdOiYiB2oqI20TEeyjnx4MoCTrDWpFy/n0XJTFrWjyVct5p8+HMvHKSwYwqIp5GqSDwKobbd3YAPgH8sjn2xi4iHkXZ318MrDvmbW1KSRA9HOj8uhsRe1GSzD5NqZgwqHUoyVNnRsQzOwxtZM318wJK4uczKOeWYW1FSQQ6MyIe3kF4M2GZ/ecD3LoiSj9uT0kK+11EHNRhaFURsU5EfInyd+2OA3x0BUpS5lkR8dCxBCdJmkomhkiSJGlRiIh1KG/AHzhCM2sAH4uIt3cTlSYtIh5NqRZz3w6aW43yFvC3I2K9DtqbiCaRpfaw8vOZeWPL/E9X1t8zIrbqJrJbi4j7Ud4ofRbd/v1aG+JqQcrMMynl6Je3XUQM05F7H8r+XTNsu/ejvIm5vB9W9rvl3Y6y79bKlQ9rJ+DnEbFfx+1ORESsEBGHUiog7dJh0ysDm3fRUESsSSld/kKGP5ZXAv47Il7aRUxdaIaKqO03N1I/dy4IEbE/JfFs6zG0/QJKB/EwnW/LWx/4ZER8MiLazjH9xhSUN/Hfyz8P3deVvscfi4h1Kfetz6X757cDjYM2Zo/psezjE4tiRBGxWpO4+FG6Sa64K/CDJklpbCLi+ZQO5Q3HuZ1mWztQkpz2GEPbK0TEmyjnqy7OKbcBPhARnxnlnNKxp1OSnLu0KfD1iHhVx+0uOM29xbHcekjJYWwAHBERH2qG3RmLiNgc+DGw/wjN3Ab4avM3siRpETAxRJIkSTOv6bj5Au1vqg/jxRHx5o7a0oQ0b259ke47lR8IHL+AkkP2pf5gudaJ+XnKkErLC+DJXQR1q4YjDqCM173pONqfQbWqIYNWZoD+KoJ02e5xQ7TVtdWAoyLiIfMdyCCaDofPUaomTOUznibGLwMP6qjJt0zR2627A7Vz/7GZeekkg+lSRNwfOJLeSWLDtn0o8G6Gq2rTyyHAl0foiHsHpfN1XjUJnEczXMWDBSMi7kC9UsxpmXnGJOMZVkSsSqlG2HWFgJWA90bEyztuF4CIeBJlCNCxJwpFxGaUinS3H0PbK1Gug+P4ng4GvrBAqwP2K4DXR8TL5juQ+RIRbwHeQvf3UU8HPjeO/SciNqBUjxmm2tbyVgE+GxGjVKGRJC0Qs3xTI0mSJC31cuBfWuafTen0OJUyJjCUTui7USqL9Hpj6GURcVpmHtFloBqPiNgb+BS9H/hdChxFeev+T8CVlDL1W1HeaN2D+sPzHSlv3O29AIYNWFKZf1Zm/qxtQWZeGhHfpP3N+CdHxOsyM7sKMCIeSTk25+o0PAX4JnA6ZXiRSyiJP+sDmwG7NtNduoptih0HPKll/gOAzwzYVj+JIV22O2piyPWUyjInAidT9oXLgSso+8N6lH1gN2AfYK1KOysBR0bE3TKzrQLLVGmqGxwBHDDHqtdQvuNjKJVlLgb+Rvle1qd8N7tSkhyGHaqpl3dx62vwTZS3XL8J/LaJ6UZK0to9gEcDO/do8wMRsX1m/q37cAeyd49l35lYFN1bn9LRuvyb8tdS3qj+NvB74CLgFsrb0TsCjwR6Xgsi4l8piUy9/JFyDTiJcj2+nnJ/dmfg8ZQqPzX7Ah+mPmRaLa57AS/oscp1lAon36fcP15IOY6SMvzEOsAdgLs3084Mn/jyfMoxWfNXSuLIiU0slzaxrEKpdLIucCfKb7Izow05MU6zcvx8jPa/M5Z1MiVJ/UzKPr0KZZ++B+Vvjs16fPZNEXFBZn6qg1iXuhOlI3x5V1CO72ObOC+i3Dtv3MTaq8JLTVASj5dP9L2FMlTh/1K+l4so16t1KdelfYA9+2j/U/S+DialUsl3KVUDL6HcI6xLuc/fE3h4S3xLPQp4J+W4nDa3UIYBOoHyb7sAuKyZVqVc57cE7k0ZYq7X8HtvjIifZ+Y0JOtOTEQ8F5irEtn5lGviKZTj4gbK/rId8AR6D4u0P/AeSvXDrqzQxLPdcvOvoSSKHw2cSzmmVqLcW92XcvzWKoCtRrl29jovS5JmQWY6OTk5OTk5OTnN4wQcSnlg1TZtOY9xHVaJ6QUDtrNTpZ1TOo63tp2LKQ/zl513IfCoPtrcr1m39vtcAWwxRKxfrbS334Dt7Fdp56vzvV/3Efu6ldgvH8O2Npzjd7yWMq76ynO0sy2lQ6jWTgJvme/vdo5/wwaUh5ltsb96js8+use/+/4dxrgDcHWPbd1C6QzfaoA270Q51/6uaePsAT57WiWOHTr+bd5b2c5z+/z8FpXPnzdgHGtROuh77efDtLs2JRlg+XYuBVbos43tljtuv0zpJF5jgDjWAf4DuKrHv+1LI/yOtX13rS73l2Zbh87xG/2V0tG9Wp/trQQ8hNLJdk3Txqv6/OxjKzFc0DLvKGCbPtp8QrN/1P59L+/6Ox3iN/hKj/juOd/x9RF/7bxzxXL//6Zm3fX6aLN6X0TpPLt2jn32ICDm2MbuwBlz7P9LBvwujqm0czPwVuC2A7Z3W0pFra/yj3Pfxn18bnVKYmpbLJcB/wqsMmAs21CGcfpp085v5nvfa+J6T4/fb6B74nn8N/zbHPvhacC95mhjhWZfuaxHO9cAdx0ivm/3eYxfA7yaPq4XwOaV+U/sc1sJfAPYto9t9fw7C3jJHN//Z/r53ijXv+c156BaW48Y4vs/r9LWlkO0tfT+4mZKksszgQ0G+PzKlPPr+T3+jWczx99DPdr/bqXNvTo+5g6tbOfQIdrahfrfRUl5jvA45r4m7QGcNce++IQO/61/Wu7/30g5n/bcH5r9/EX0vs8feD93cnJyclpY01SWGZUkSZI6tCHljamlTgK2z8yvzfXBzPwqpZP65MoqawNvHzlCjdvbgdtVll1E6bx7R2be2KuRzDwL2Ivev/mLI2LHoaKcjIMpD4bbzFX94RuUTto2S4YNaFlN+f/DqQ/3cwmwR2YenJnn9ttuZp6ZmYdSEkQOobxdOVMy8/eUxJfl3SEithmgqT25dXXRtmGEBm33/rS/Pf+9zLxlgHb+BryN0lm0f2Z+PjOv6ffDmXlFZr6T8ib9qZXV9o+IXhUJ5l1E7Aa8qscq3wLumJmHZeZ1/bSZmTdl5rcz8xDKG6Xvonzfo9hkmf++GXh6Zh6QmW376vLxfI7yhvOVlVUGqggxJrX95BZKh/BCtfYy/30NsE9mPjczL5vrg8256FaaCjcfoj40zamU+7PPZmbOsY2fUiphfLHHau+MiA3nireJbQPK9b3NEzLzpZn5137aWibGv2bm4Zm5H6UC3bsonXFz2Qe4Tcv8y4DdMvOjmdl2Tu4Vy+8y892ZuTtwH0pC0zTodZ791cSiGFJE3I7e94RHALtk5gm92snMWzLzcEri1G8rq60OfLA5jrqw7DF+EbBrZr6un+tFZv5hhG0BvCgz923uq+faVuv5BCAi7g68obL4CuDRmfnEzDy9j+3clJnvoSSd1e4v3xcRnQ+tNYCb+Eeiy16Z+cHMvKTfD2fmjZn5WUpFo69XVtuGMQ0ROW0iYgVKhYza30UnU5LAv9DHNekHlPvK/+mx2n91OOzoskMyXQU8JDOfN9f+0Ozn76Ik3tbuvZ/aUYySpCllYogkSdJ0u1NE7NDR1PaQebE5F3jYIA/3mwcsD6P+kPBxEXGPLoJT9yJiB+oPOK8EHpqZv+63vebh/UuAj1dWWZHyZvG0WlKZ/+PMPKfXB5uOqC9UFj82ImrJHIN4NvXhI/4I7JmZPxq28cy8uemoe/iwbUy5WvnvfoaG6bXu8ZQ3IbtuFwYbRuaPlLdsX5qZfxngc7fS7O/7UN6cbfPsUdofp6Zj8P3Uh6n4HKUq1pyd+DWZeWFm/kdmvnvYNlo8JTM/MmAcvwD+X2XxthFx39HDGk6TyLZFZfH5/SbkTLmbgYdn5rEdtLU/ZTiDNudTOrYu7Lex5vt9IuUt9TbrA6/ss7kH0X48fS4zj+o3pprMPK85nvq5/3xIZf7LM/PMDmL5SWa+fNR2OlIbsvE6SqWFafcqShWqNt+iVK25vt/Gsgxhtg/w58oqe1CGNenSFcDemTmpRLaXdHhdeT/tnfrXAA9qEvwH0iSr3J9SOWR5mwNPH7TNDu2cmU/KzFryUF8y8wrK0DvfrazynFHaX0AOpAyP1OZ3lGvSxf021iQpP54yTF6bjZh7yJpB3Qg8eNBrdGZ+iTIEVpt9m2RJSdKMMjFEkiRpuh1NeYOyi+mBE459Gj05My8a9ENNR8WSHqu8aOiING4vpYxt3uZFmVmrBjOXZ1KvOrHPNFYbaN6srMX16T6bqa23FsONO/93EbEG8IrK4puBx2TmGaNsYxEYV2LIcUDbQ+eJJoZk5tWDvB3bR3t/pp4AckBE1BIv5tv+1DszTgKeNFcFpHnw6czs9zyzvPcBtTfUB9kHu7YJ9edqg75RP63enZnHd9TWy3ose2JmXjBog02n++OAyyur/FtErN9HU3eozP/coDF1YJpiGZuIWInSUdrmggErSU1c03H6tMrivwAHZeZNg7abmefTu2JDr+NoGC+d4L3V94F3dNFQRDwEqCUGHpKZJw7bdlMRpfbbPr/Dqi0DGaRSXh9t3UCpoNeWuLRzRNy5q21NsdqxlMCBgySF/P2DmddShta7urLKsyJi+Qo6o3hVZv5s2M9SqtAsb2VKEpokaUaZGCJJkqTF4qjM/OGwH87M7wNfqix+jBVZpk/z4O2xlcUnUq/6Maem0/UFPVapPVCeT7VhF3pVAvknmflj2ocrgdGHk3k89U6it2Tmz0dsfzEYKTGk6UBtGwrp2Erb/ba7AaVE/vIuGqRizzhk5jeBtofq6wL3mnA4/fr3yvzrKQmQA3dGjtl1jJBAmZk3U+8Ur1UYmoRNeizru/LFFLsIeE0XDTWJifesLP7siPdnfwEOrSxeg/JW+Fxqw82dN0RIo2qL5fLmLf9Zcjvqz6UXwvFzEGV4lzavzMxastKcMvMYoFbtYreI2H7YtpdzEmUojUl59lxDcgygdg/+f5nZa4ipvmQZcrTt3mBr4H6jtj8NmmF6PlpZ/OBJxjJpEbErZbjYNp+Ya/inXpqk49oQR2tTqrV04RxGSLRqEl++U1k8n/dWkqQxMzFEkiRJi8WbxtjGasAjO2hf3Xok5bdp8/pRH05n5tHUywU/br7eKGzTvJl7UGXxNzPz0gGa+0xl/l4RUXvTuR9LKvMvA944QruLRvOQty3RYqNmWKW57MWtnxNcRhln/XjKW5TDtLs37ZV7uqpEMKqvVebvPtEo+hARWwN7VhZ/Yr4TbSqO6KDSy9GV+fPZebFWj2VDdwpPkc80pfG78Lgey17bQfvvA2pvdz+hj8/X7gfmI+m3LZY1priC0bAW+vFT26f/SH2IhkG8useyfvbpfnykw0SNufyoq+tTRGxGPXHhVV1so3FYZf6+HW5jvi2Y+5+O1Y7fBF7XQfuHUe6f23R1/L6ng8pK03hvJUkaMxNDJEmStBj8JjNPGbWRzDwJqI3v/qBR21fn/qUy/6+Usd+7UEuS2Ai4e0fb6MLDqFfjGHR4h9r6Qe/y51URsR71kuCfbEozqz+jVA1pW+e7mXlL07F/aoftwgDDyIzZjyrz+0l6mbSH91j2gYlFMZguhsBo2/cAtpjHJLxatQBoL8+/0BzeYVu16/EJmVm7r+pbUyWntp/tFhG9khCg3Be0mY8O4LZYVmH27jMX7PHTVKTbrbL4yC6GwcnMU4FfVRZ3sS/cwGSHJ+ryfPJw2vs0zh6l0kOLY2hP1Nq7w23Mt4V0/9Ol2jXph81wTiNphjk7qrL4fhFRe3FhEJ/voI3avdWWHbQtSZpSJoZIkiRpMagNATOM6kOeDrehbtR+k680Q8F04fNArQNgmvaJJZX5lwHfGKShzPwd9UophwzS1jL2AmpvQw895M8iVUu2eGAfn21L4Diu8t+jtltrbz5cVJm/5SSD6FPt+/5FZtY6EefTzcBPR22kqYZzVcuiFehdeWCcVumxrKtrzHy5gnqH0UAiYnXgHpXFXXRsLXVkZf7K1DvxlzqlnrRvAAAgAElEQVStMv/5zZADk1SL5bBmWK5ZsZCPn92BlSrLJrFP3zMiVh2x7dNGGe5mCD/osK1ap35t+J2hNAmxv21ZdPdZqeDTVIW6umXRlhMOZWIiYh3qiS+TOH5XA3YZse1zmiFrRnV2Zf7aHbQtSZpSJoZIkiRNt60yMzqaOn1YtsCc2GFbv6jM3yYi1uhwOxpB83bwlpXFP+9qO80QLGdVFt+tq+2MIiJuS/2t56Oat9oGVasask1E7DFEe7VOw8tpHxpFdd+lPVlpz14dGRGxCXCXlkXHVv6733Y3Be7Usuj3TZLRNKgNpbTxRKPoT+1Y+eFEo+jf2ZnZ1uk0jCsr8+erA6PXubNXp/dCcHKHQ0zclXriX2fXY+Ak6gkFc12Pvwfc1DJ/deD4iHhl05k4CcdU5m8HnBQRBzXDwy10C/n4qe1P1wO/7HA7taS6lWi/Xg/ipBE/P4i/0Z5gMax7VuZ3+d0v9aeWeasBowydOG3a7oHW6aiqxTTagfbhDaHba9IJ1F8eGPVvxJNH/PxS03ZfJUmaABNDJEmStBh0+aCw9kZ2ANt2uB2NZlvqD/26epi2VG2Yojt3vJ1hHUy9k2XQYWSW+gKlDHmbJUO0t31l/gkddk4uCs0bwG37+LrUkwqgvarHnzPzjGX+//cpFSBGbRc6rBYSEStExG4R8cyIeF9EfC8izoiIP0bEFRFxc0RkbQIurjR9m65i7EIzfMFmlcVddmZ06ZIO22qrGALz14HRa4irUd/mn2+nd9hWW2IYlCEaOrs/y8wbqMfd83qcmVcAR1QWrwG8AbggIo6IiAMiYt3hI53T0UAtaW5zSpy/j4j/iogHdFA5Yr4s5OOntk+f1gxr1JVew2COeo/Z5TE+l992MbwOQHPsbV5Z/JsutrGc2jBTm45hW0OJiLtGxCER8Y6IODoiTouI8yPisoi4qdf9T3MPtEWl6am6B+pQ7fi9iY4qZQFk5t+ovzww6vHb1b3VtN1XSZImYBYyzCVJkqRebgDO67C9cyhvpK7csuz2jOdtNQ3u9j2WndFj2TBqFS16xTBJSyrzz6U+tnhPmXlpRHwDeHTL4gMi4nlNeep+1R7yd/aAdpE5jvYy1Q+kvMHYZq5hZMjMKyPiRG49LMOg7d6q7WFExPbAU4AnMJ5Omml7W7Z2nMD0HiuXddjW8klJS81XSf9ahwrA+hOLYjy6HGKidi38U2bW3lYe1q+BHQeIYVmvBfYDapVB1gAOaqZbIuKXlOExfgz8MDPbKgsMLDNvjoiXAl/ssdomwL8303UR8VNK1aAfAz/q4nuNiDswesfwNZl5TmXZQj5+avtTp/eXmXl5RFxQ2d6o95iTHEamy23VkhgAToio5YR37raT2lCbpsrbUyjno1py9aim7R6oK7Vj57zMvK7jbf2a9iSQUY/fTu6tmutN2yJfJpekGWZiiCRJkmbdFV1WHMjMjIgraX8guGFX29HIar/Fjc0bXF2qPfCe9/0hIu4G7FxZfMSIx8anaU8MuQ2wP/CZAdq6XWV+bYgP9XYc8J8t8x8AvKXymTkTQ5aZt3xiSK92967MHzoxJCLWo7zB/0zG+/B6vhIOamrHCUzvsTLMUFULxQU9lk3jMESD6DJho3YtHEfH9NDX48w8NyIOBr7M3EOZrEC5tu5MSc4gIn5LOa99Azh6lMoRmfmliHgT8Io+Vl8N2KuZAG6OiBOaWL6SmcMOp/ghYJ8hP7vUz4DdK8supryh3/ZsetqPn0nv022dyKPeY3adlDWpbU1L0vXq87HRiFgZeCHw/4C1xry5absH6sqCuCbNYZbvrSRJY2b2nyRJkmZdrzcSh1V7wLnGGLal4dQe2E5yf5iXh8bLeUqPZcMOI7PUN6h3Ri8ZsK3asTPJN1pnyQ8olY2Wd7+IuFWHZ0RsBWzZsv6xfc6rtbs1cIeW9c8c9u36iNid8lb2s1l8zzR6XWM8VibvQkrHdpu2/X4h6TKBsnYtHEfH9EjX48z8BiWZrVfST82dgWcB/0sZdua/IqJXlZ+5Ynll096gHYArUpIxXkGpoPCbiPjPiFhz2FjGITNvphxDbW4fEdP8MuOC2ad76DpJelLbmpbhTeZKHutcRGxGqc72VsafFDLLZuH4lSRpaIvtIYokSZIWn0GGs+hX7QHnxB8SqqptqB9YRPtD06lycGXxmcAqEbHDsBNljO7vV9rfe8AOsdp3dfUAbajRVMX5ecui1YF7t8xvqxZyTmae3zL/R9y6o3KQdmHIaiERcS/gGHpXzphlteMkx1AJSXNoOrZrw2RsFhHT0oE53xbU9Tgzf0xJ8ngtw3cUbkipJHJWRBwWEUMlDmfmB5tYPk09CWkudwbeBpwTEc8aso1xObMyf2Vg20kGMqAFtU/PmFXnO4DGxMasAYiI2wHfo32oLA3G41eStKhNc/a1JEmS1IVxVPGovXV5wxi2peG0VUuAxbU/PAzYqLLsTsCpY9z2CsAhlOE++nE97W+B+kbk8I4H7tsy/wGUzoXl5y2vNXkjM6+LiJ/wj2ELBm13aWwDiYi1gS9SP96W+i3ljdozgd8Df6F07l5DOS+0DZ+0LqXKyrSrVQ6IiFjT5JB5cTLlfNpmJxbGfjVuC+56nJlXA4dGxNuAxwAHAXsyeMyrAs8HHhQR+2dmLRGiVyznA0+OiJcATwIeC+zC4MM8bAS8PyIeDDy5+TfOt5OpXyd2olSHmkYLbp+eIbfMdwCTFhFBSQ7beo5V/0RJCv41cD5wEeX+52pKYtnNlc8dzfQM0TMJHr+SpEXNxBBJkiTNunG8sbt2Zf443jTScK6tzJ/k/lCLYVKWzPP2n0z/iSG1Y2fdjmJZjI4DXtUy/4HAa5abt3fLem1Dxizb9l5DtpsMkRgCvBzYorLsauBdwMcrVU56iohaAtW06XWNWZfJDg2g4hfA4yvL9sLEEKhfC2vXzlF0ej3OzGsoHbKfbobLujdwf0qSyO7Mnai21PbA0RGxW2ZePGQsFwJvB94eEetQ9q/7A3sAO9N/osijgSMj4lGZOd+d7L/osWwv4MgJxTGoBbtPz4Be18FHAOdNKI4/Tmg7APsDD64suwX4GPD+zDxlmMYjopYwMqs8fiVJi5qJIZIkSZp160REZGbbW+IDa97aqj3k+UsX21Anar/FymN4s76WvDBv+0NE3BbYd76239g2Iu6bmT/qY92Lae/0X6/jmBaTHwPXAastN3/XZY+BiLgLsEnL53sN93Ic8Lo52r0rsHHLZ0/LzIGOjYhYHXh2ZfHvgEdk5ihvli+U/axXh/J6lLeFNVnf6bHsIcDrJxXIFKsd7+NI/Bvb9Tgzb6BURfoe/H24tntSkjMeDtyH3kN2bwl8GNivg1iuAL7WTETEWpQKUQ8AHglsN0cTD6cMdXNYj208ZNQ4+3AsJVmwbViOfSaw/WHNxD69QP21x7JLMvO0iUUyOf9RmX8VcEBmHj1i+wvlHqgrHr+SpEWt1x8skiRJ0ixYhfIwvitbUx+b+IIOt6PR9Pot7tLxtu46RAzjdjDTMX71kj7X+31l/t06imPRyczrKckhy1uZ8ob5Um1l/E+b4632n1OqdAzaLvROOKnZh/aEvBuAx46YFAKw/oifn5Q/9FjmsTIPmje0/1xZfO+I2HyS8Uyp2rVw04jouorXxK7HmXlTZv40M9+amXtQEuxePse2HhUR9xxDLFdn5tGZ+dLMvAulQsl76P1W+ssjYhxDJ/Stuc7UqobcISJ2m2Q8A6j9xp3eXzaVYWpDfCzWvzlq94uwcK7lfWuuIfeuLH7uqEkhEbEyi2/Yxtqxs2VELJ9MPapp/BtRkrTImRgiSZKkxeDuE2grgbM63I5GcxblN2mzU8fbqrX32463M4gl87jtZT2uqfYwl19X5u/aVOnRcGpJGA9c5r/bEjh6Jm9k5o20D5ExV7tztl2xR2X+V4ctnb6crTtoY+wy80rqySHT2oG6GHyhMj+Af5tkIFPqzMr8AHbsaiNNB2etE27s1+PMvDgz30Kp1vH5HqvWhh7qMpbTM/PfgR2AWgWFjWgf7mvSen1Xz5hYFIOp7dPbN5VkutLrfnU+7zHn0x+4dWLqUttOMpAJuV9l/u8y8/AO2l8Q9z8dqx2/K1HOmZ1oEu/uVFm8WI9fSdIUMDFEkiRJi8G9Omxrl8r8c5qx6DUFMvNq4NzK4l272k5ErEf9od+pXW1nEBFxN2DnyuLXZ2Z0PQF7Vba3NvDoPsKuvTG8LuXNZw2nloTxAPj70Fh7tSw/dsi2l7a7AmV4heXdTDMMw4DuXJn/9SHaalNLPJlGtWOl1nmk8ftoj2XPbob5WMxOpxz7bTq7HlOue7VKWRO7HmfmVZSqXSdVVqklzY0jlnOAhwK14fMmFksPhwM3VpYdHBGbTjKYPv2qMn81uk1GryX83QSMWilrQcrMW6hfB9vuOxa62v3P/3TU/kK6/+nKadRfHujymnRP6n1v8/I3oiRJYGKIJEmSxq/WGTDJYS4e02FbB1Tm/7DDbfRrGr7bYU0i9tpv8ugO3+g8gPrfVfOxT0DvaiFHjGmb36deyWBJH5//LqWjo81Th4inSwv5ODuBMgb98nZqkpp24tal1/tN3mhLDOnVLsBJmXlFH20vb6PK/POHaKtNl2/Nj3t/OaYyf5eI6LJDUn3KzNMo57A2twVeNblopk9mXku9I/dxHW7qCZX5NwI/63A7c8rMm4F3VxbfYcKx/BH43DTE0qYZTqZWNWQV4K0TDKdfP6V+zzKJffrEZri4xaqWvLpnUzloloz7/qfL5LAFcb/c3IfWEjMmcfxeR/2aKEnS2JkYIkmSpHG7rjK/n+ElurJdRIw8fEhE3IN6dYhaZ904TcN3O6xa7Kt1OHTIdyrzNwD26WgbT6zMv5j6G6Vj0yS8HFxZfFJmjqV0cWYm9Y6nB0bEZnN8/grahyYBWNLncDTjsmCPs8y8ifbvdQVKMsQDW5b9os/kjVOASyvtdjmMDNQ7Fa4dsr2/i4gHUz+vD2Pc+8v/Un/T9VkdbUOD+389lr2wuX+YmIjocp/uQu16vFtE3HHUxiNiReqdcD9tqohN2omV+es3VZUmqRbLBhONou611BMtDo6Ih04ymLmOn6YqTC3Z6MAu7mMj4q7Uq7/VjqfF4iuV+belfl++UI3z/ud2wP6jtrOMhXS/XDuG9oyIzUdtvElQqiWZ/CAza9+VJEljZ2KIJEmSxm35jsOlNu4wAaAfr+igjZdX5l9Pd0MaDKL23U5j2e1/kpk30j5GeACbdLSZr1N/SPmqUfe/iHgA9RLMn2+SJSbtocDtKsvGVS1krvZXAJ7cx+c/UZm/Ht0cv8NasMdZo9dwMm0JHH0lbzTl3L87QLt9t92i9hvcfsj2lvWSDtpY1lj3l8w8Hzi+svgpTWeiJiwzf0j9PmAV4KiIuO0kYomI/YEvTWJbA6hVhIBuKqo8g/q9Qy1pcdxuqMy/tjl/TlItltoQMxOVmWcDH+6xyuERsdUkYomIPemvalZtn94COKSDUA7tsWy+9ump0FRp+nll8cs6rAo4DcZ5//MCYNUO2llqId0v147fAF7ZQfvPoyQqtVnUx68kaf6ZGCJJkqRxu5T2t5pWA7aeYBwHRMT9hv1wROwBPLay+MuZeeWwbY/gj5X5W85zhYV+1eK/SxeNN7/JFyuLd2eEtwqbt5P/q8cqHx+27REtqcy/hTE/iMzMXwKnVxb300lyFHBhZdnLIuJeQwU2urHupxNQS8b4F9oTm2ol2vttu9buDQw/vNJfKvPbKp70LSL+DXjQKG20mMT+8t+V+atSOlBnqVNsIXk2UKu2szVwdESsO66NR8RKEfEmynVvqu4BMvNU6lUrnhwRuw7bdkSsD7y+svga5q8TrlZ14oKJRlFMUyw1L6M+JN0GwDERMbYO5iheSKkAuF4fHzmSetWGN0fEbUaIZS/qQ1f+LDNr91qLybsq8+8EHDbJQMZsXPc/uwIvHqWNFgvmfjkzTwBOqyz+t1EqjUbERsCrK4t7/W0qSdJEmBgiSZKksWqqJvymsvgRk4yF0mFWq6ZQ1XzmUz1WeefwIQ0vMy8CLmtZtDLdDZUyTmdU5ne5X7yV+rAL/x0ROwzZ7nuB2me/nZmnDNnu0Jq30R9eWfzdzJxEB1CtasidIuLevT7YlFV+Q2XxSsCXI2K7UYIb0iT203FqG/IFYFtgreXmXQ/8aIC22xJD2tqF0pl1zQBtL+vkyvwlEbHhMA02nSLj6Dwa+/6SmV+j3sm+C+Vat3JX21N/MvNPlOSQml2An4xjmJeI2JGSePVyyhvP0+gtlfkBfHbI+7OVKYkf61dW+XBm1t5iX7adpw97LunhqZX5tc5IImKdiPjXiOjsLf6IWA04cNBYJq0ZnmUJcHNlla2Bn40jSTQitga+RUk26OvcmZmXAB+rLN4Y+HSTRDxoLJsDn+6xypsHbXNGfYH6dfA5EfHvXW8wIlaMiNpLAuNSu/+5b0Tcd5gGI+L2wGcp99Zdqt3/7DsPw2f1o3ZNWgE4cpgqX825+wvAOpVV3j9PL5NIkvR303hRliRJ0uz5cWX+KyJi2wnGsRXwzUEe9ETEBsA3m8+2+WJm/qKL4IZU+27fHBEbTzSSwdVif0ZE7N7FBppy07WknnWBbw/SSde8UfpG4JmVVW6mvPU6Hw6iPhb5ZycUw5E9li3p4/MfAmrH02bAD4Z9EA5/f6h/cET8zwAfq+2nu0TEc4eNZVKa5Lzv9rn6TzKz73HrM/MM4M99rj7sMDIAR1fmr0N5eD9QJ2pE7NPEs8YIMdXU9pf9I6LLZKJnUe9APRD4akT089Z7q4jYKCLeFhEvGLaNxSgzP0tJSKzZDjg5Iv4jImrn675FxB0i4v2U8+Zuo7Y3Zl8GflJZtg3wrUGSM5rj/nDgwZVVLgXe1GdzLwLOj4j3RcQd+42hR2xPp17x4Qs9Pro68BHgvIh46SjHcBPHipQhWrZoWXwLU/bmemYeRxneomZT4EcR8caIWHPU7TXnuTcDv2a4hOo3UK8S9CjgI4Mk6UXEJsC3Kfc7bX7QJAYues29zdOpD5P0XxHx0SYxaiQRsXpEPAs4k8lXIPoBpfJRm8ObJI++RcSdKfcp24waWIva/c9WwP8bw/ZGdST1vzm2A77RVKTqS1Ot80jg/pVVLgbeNlCEkiSNgYkhkiRJmoSvV+ZvCJwSEZ+KiKdGxJ4RsXNE7FCZhnm49xfKW/BL3QM4LSIeNdcHm3VOaz7T5irgP4eIqUu173Y74IyI+EBEPDEi7hcRO/X4bufjb4Na7KtREgC+GBHPiIi9I2KXHrHPVa77JcBFlWWbUjrpnh9zDL8QEdtQOpNf0WO1dzZDqsyHJZX51wNfmkQAmXku9QfDj5/rGM7MmyjDzlxdWWUDyr7xmYioJWvdSkRsHRGvolQv+gyDlbX+OfUhbt4TET9oOnkfEhG79thP5zNRq9+kjGGSN44fY9tLnUL9zfYHAt+PiLvO1UhEbBIRH6ck+y3bqVgbvmAY36a9oyqAr0XENyPieRHxoIi4Z4/9pWdnRGaeCLyuxyoPA86OiH/v99oZESs0cX0MOJdyfWur/qLeXgF8osfyNYB3AL+LiP+MAYfHiDJkzMMi4nPAWZQkoYErE0xa05H7TP75nmxZOwO/jogDIqJn1ZMoFX9+ATyhx2ovzszaMAxtVqdUfDkrIn7WnNfbEip6xXX7iPgQJcmxzcXU732WtTHlbfYLI+J/I+LJEVF7A70Wyz0oQ4M9qbLKt5oqN1MlM99L74SelSnH2PkRceigiTzNeW6v5jx3HiWZd6jkgaZy30t6rPIU4OfNb9ErpoiIgykJKrVr2bXUk5IXpcw8GXhpj1WeBvy2uccfKJEoItZszkWfpxy372eyQ6ACkJnXU0/g2hr4aUT8y1ztNP+e1wInAXdYZtGV1JObBpKZZ1OvGnJoRJwQJeHtYc398t0q9z9jGzJquXhvoRxTN1ZW2Y1yTdpvrrYi4j6U6i6P7rHaCzKzrdKnJEkT5bizkiRJmoRjKG9ZtVVmWAN4cjPNZWdKB+EgLgDewz93oG1MeZv6LMqbPacCSx+ObwrcnfLG9VwPm5+bmecNGE/XjqR0HrS9Vbou5YFXPw+S1wMu7zCuOWXmmRFxDPCglsUrAY9pprk8Gvhqj+38JSIOBP6P9r+B1qAMKfHKiDiKktjwJ0riz8aUB6+PprwB1iuB5ofAK/uIt3MRcTfqCUzfyMxJ/rZHAPdpmb8OsB9zvG2Zmb+OiCdSklnaOjsDOBg4KCJOoXTyn055cP9XSufe+pQ3bu8J7Arcbah/SYnnloj4IHBoZZX7NdNc3kn347n3q9+kjGOHaPtYSrWaXq4BfjpE20DpUI6IV1MqDrTZlZLw9x1KdZFfUYbZWhnYiHIufxiwJ7ceJuBG4F+pVyUZNNbLI+KztCdqBfDQZprL8yhDVvXyesqQVrXKBOsD/wW8KSKOo1yL/0g5Vv5GuUasT0kkvBdwb8r3pRE054ynUTpyew0tsxnl7eG3NueyH1HOZedR9t9rKFWg1mrWvRNlX78vCzRhJzN/FRHPo1SxaLMhpaLG+U3iy8mU6/ENwO0p38HjqV/vlvpUZvZKzpnLrs30joj4A3ACZdiK8yiVSC5rYlqTcp+wHbA37eeYZT07M/82QByrAPs20y0R8ZsmlpMo1ZoubaYVKPvEFsD2lOoXO/Vo92pgaiteZeYrI+Jayjmu5rbAa4DXRMTplHuw0yhJbZdSjp8VKd/LJpR9ZxdgD9rvmYeN9cMRcX/q18GdgF9ExInAUZS/hy6g7CebNjEdCGw+x6aenZmndxP17MjMw6IMBfS8yipbUO7x3xgRPwG+T0kSXnrsrEy5Fq5LOcfsRPl7865MT7/Jayn7SNu5ZXPg6Ig4mfK30C8oL0XcQrmebw78C6WyUlsi/Qsox9FAiWc9vI/6vcs9m2kun6K/KoMjy8wTI+I/gP+urLIx8JWIOIfy98svKdekGyn7y3aUBMUd59jUhzKzV1VFSZImZlpucCRJkjTDmk6S51M6cHu+BTomb6Y8rF8+AWFb4NVDtvmOzDx8pKg6kJlXRcTLqL+dOu3+g1KRYaChIAaVmcdHxBJK2flacseGlE68Xh15Nb8CHtlUvJgPS3osm9QwMkt9gdIZ3fb35hL6KMOdmV9rkkM+XWkHyrlk52Yat3dQKpn0XaVkmmTmGRHxZ0rnWM3VlGNxUP0knfwoM2vl3vuSmV+JiC8D+1dWCUrnx5xvzi7nWZRO1i69ipIEtW7H7f6TJmHmYMox0ust1TWBRzSTJqCpjvGciPglpcOp1zVuHOey+RzirqfM/EhEbEbv+6870LsSQC/fpAwx0ZXNm6l27unX+zNzlOpdK1A6q+9KuR4N62bg6VOQ2NxTZr4hIn4NfBJYe47Vl34vXRn0+HkqpaJZr+tPv53ibV6VmZ8c8rOLwfMplYh6Jd+uSfk7sC0Zfapl5jkRcSjwxh6rDXMN+UBmfiIiXjN0cLf2Ycr59+4dtjlWmfme5prUq/rP1vSuGNnLV5jiRDxJ0uLjUDKSJEmaiMz8NuVtrlvmYds3Ud6oHqbTs81h9H54NFGZ+WEW6JjFmfkryltw101gW0dQ9oNB3tbtx3HA3vNVHjjKEDgHVxZfAfzvBMMhMy+hVGdp8+B+S0Rn5uconSwXdxXbsJo3vPelVFtYqOYa8uX7wyQ2NZ2L586x2ijDyCzrSZS35btwC/DCzPxYR+39XTM8wyOZQBWmzLyRcl5bkNeAWddcn+9FqWYwCb8DHpeZj5/Q9oaSma8BXkRJUujS4cD+oyaijcFbM/M58x0EpfP8sQvlzfXM/AqlgsM3JrTJP1M6tfcY5EPNcB+PolTx69JNwPMys1dCwKKXxX9Sko9rQxEuaJn5Jkolja58kjEkKzT3JI+kDHO2YGTmS4GX0/1zio8Aj5/HFwckSboVE0MkSZI0MZn5PkoJ9O/Ow7YvBx5IfZzmflwLPCMzX9i8DTw1mgda+9L9m+9j1zz4vwfwdWCs32tmfpnyxuaPO2juekplgH0y89IO2hvWQ4HbVZZ9uemwmLRalZIVKJ37fcnM4ylvHR7RRVDL+OWgH8jMMyilot9LKVG/0MyVnDFK8sY42/67zLwGeAB9VJ2Zw8XAfpl52OhRtcvMH1D23c9QOvfGJjNvbq4BDwR+22HTfwPO7rC9RSkzT6VULTuQIc49ffoVpWrBdpl51Ji20anMfDewF2VojVFdBjwlMw8Z8pr3S7pPUgE4B3hEZr6sz/WvA84YQxxQkgN3yczq0HvTKDPPzcyHU+5xu7h3a/M7ypAaW2fmRzJz4M7hzLwuMw8C/o2SlDuq04E9MnOuIcXUyMxPUa67tWHnRnEz8G3mHjpvnJ5KGVZmlOSF64AXZ+ZThtnP+5GZ51OGSHobcOU4tjEOmfkWSkWZ33XQ3CXAEzPz6U2yjCRJU8OhZCRJkubfd3ssG/vbxpOWmT8F9o6IbYCHAbtRxv3elDLm96qMKYE5M68GDoiI/SnjKfdb5vYm4PPAK5uHXVMpM78JfDMi7k6ptHAvynA5m1CGNFiFKU0ObzrdHxURt6fsF/cG7gJsBqwPrE5HsWfmbyLifpShHv6z2dYgrqS8lfy2zPxDFzGN6GbKg+I2o5StH8VXqcd04SANZeZFwBMj4m2UMuGPAdYYIqY/NnF9KDNPG+LzNAlAz4uIVwAPobxVvANl2IMNmrim9e/scSZvHAs8rbLsSjoc1qI5jx8YEV8BXslg5covp7y9+eZJVPhpzg9PiogXUs5r96EMd7A5ZX9ZHVixw+0dFxE7AI+nVOjabYhmbqFUZfks8KnM7KKDc9Frkkk/B3wuIh5AqfK0H+X6Nqw/UUrUH5mZ4+owH6vM/GGzzy6hdMwPOhzIhZShC8Tc+0YAACAASURBVA4b5ZjOzMdHxPqU43Rfyrm9r+pWFT+n3Cd8LDP7rojWJDHfNSK2pgz99BDKPco6Q8ZxI6Uz+2OZ+bUh25gKy9zj7gY8kXIv0Gt4tLlcAnyNcn9/TFcJ35n50eb69EJKkshGAzZxGvBu4HCrDAwuM88FHhMRO1Kug49l+OPnb8D3KVXwvpCZF3QT5XCaRI5DI+I7lL9jHzzAx2+gXINel5ldJD70lJlXAS+NiNdS4tyTcr+2JeX+Zy2m8H65GXp0e0oSzvOBOw/YxAXAB4H/9v5JkjStYspedJQkSZImJiJ2pzx4vxewHSUxZQ1KNYA/A7+mdJZ+ab4fBmp8miSlh1I6bbejdNreBliZsi/8lfLW78nA94D/G6SjR92KiKXjxN+PUsFja2BDyrF7C3BVM/2e8ub1r4Hjh00G0XSLiD0p+8MewBbAbSkdDtdSEkHOplRTOAY4tqk60tbOai2zc54q7nQiIraiJAnuTjm33YHSQbYa5fu5ivIdnUU5Vk4GvpOZf52XgBeZZhiwHSkd/zsDW1F+o3Up57NVKZ15fwMuoiS3nUHZn3+YmV1Wh5kKEbETZZ9dNml4LUpi6DWU7+FsSrLZccD3MnMclT6IiDtQfpsdgG2aaeMmnrUo15srm+lC4JRm+n5mdlEFZWkcKwDbU76TuzRxbM0/znVrUiqYXdHEcj7lWD6Zcs67pKtYpsky38u9KdUJtqYcP+vzj+PnJsp+czHl+PktcCrwI+DUcVf/i4gVgb2baRfgjpREkaX3K1dTErzOBH5Cub/81ThjWmwiYmXg/pR7/KXn2aXnlVUo+8dVlGPnT5Rz7G8oVYR+NoXDUv1dk1T3UMq/b1vKOWFdyvngKsowf6dTqgV9u3YuiIhVgWhZdP20VcictIjYhXKPuTvlO96Ucs4N/vmadCLlmvT9cVVikSSpKyaGSJIkSZIkSZIkSZIkzaipLCMtSZIkSZIkSZIkSZKk0ZkYIkmSJEmSJEmSJEmSNKNMDJEkSZIkSZIkSZIkSZpRJoZIkiRJkiRJkiRJkiTNKBNDJEmSJEmSJEmSJEmSZpSJIZIkSZIkSZIkSZIkSTPKxBBJkiRJkiRJkiRJkqQZZWKIJEmSJEmSJEmSJEnSjDIxRJIkSZIkSZIkSZIkaUaZGCJJkiRJkiRJkiRJkjSjTAyRJEmSJEmSJEmSJEmaUSaGSJIkSZIkSZIkSZIkzSgTQyRJkiRJkiRJkiRJkmaUiSGSJEmSJEmSJEmSJEkzysQQSZIkSZIkSZIkSZKkGWViiCRJkiRJkiRJkiRJ0owyMUSSJEmSJEmSJEmSJGlGmRgiSZIkSZIkSZIkSZI0o0wMkSRJkiRJkiRJkiRJmlEmhkiSJEmSJEmSJEmSJM0oE0MkSZIkSZIkSZIkSZJmlIkhkiRJkiRJkiRJkiRJM8rEEEmSJEmSJEmSJEmSpBllYogkSZIkSZIkSZIkSdKMMjFEkiRJkiRJkiRJkiRpRpkYIkmSJEmSJEmSJEmSNKNMDJEkSZIkSZIkSZIkSZpRJoZIkiRJkiRJkiRJkiTNqJXmOwBJsyMiNgEevtzsc4Br5iEcSZIkSdL/Z+/+gyy9yvvAf5/WSA1GtGRsaIHAYLqQKRZawUCCzEyRMLNQmI7bZWO82PwStuyknLDOxlkSKqlsIDibHzja4GzFEGQE2ClsSNy4bQdnxsbMGBa5KC1tWIyhDbslLDpgjBokaCT12T96ZIvW28N033v73n7v51M1VZrnvO9zHl6hf3q+cw4AAAAwTN+S5PG7aquttdvHMczFEgwBhmkpyZvGPQQAAAAAAADAIfmJJG8e9xAX4ioZAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ46Nu4BgF75k92FX/iFX8hTnvKUccwCAAAAAAAAMDR/+Id/mJ/8yZ/cXX7An5FOGsEQYJju2l14ylOekuuuu24cswAAAAAAAACM2gP+jHTSuEoGAAAAAAAAAKCnBEMAAAAAAAAAAHpKMAQAAAAAAAAAoKcEQwAAAAAAAAAAekowBAAAAAAAAACgpwRDAAAAAAAAAAB6SjAEAAAAAAAAAKCnBEMAAAAAAAAAAHpKMAQAAAAAAAAAoKcEQwAAAAAAAAAAekowBAAAAAAAAACgpwRDAAAAAAAAAAB6SjAEAAAAAAAAAKCnBEMAAAAAAAAAAHpKMAQAAAAAAAAAoKcEQwAAAAAAAAAAekowBAAAAAAAAACgpwRDAAAAAAAAAAB6SjAEAAAAAAAAAKCnBEMAAAAAAAAAAHpKMAQAAAAAAAAAoKcEQwAAAAAAAAAAekowBAAAAAAAAACgpwRDAAAAAAAAAAB6SjAEAAAAAAAAAKCnBEMAAAAAONK2traytbU17jEAAABgIgmGAAAAAHCknT59OmfOnBn3GAAAADCRjo17AAAAAAA4qI2NjZw7dy5J8rSnPS3z8/NjnggAAAAmixNDAAAAADiSWmtZWVnJ9vZ2tre3s7KyktbauMcCAACAiSIYAgAAAMCRtLa2lvX19b/4/fr6etbW1sY4EQAAAEwewRAAAAAAjpytra2srq4+oL66upqtra0xTAQAAACTSTAEAAAAgCPn9OnT2dzcfEB9c3MzZ86cGcNEAAAAMJkEQwAAAAA4UjY2NnLu3Lk918+ePZuNjY1DnAgAAAAml2AIAAAAAEdGay0rKyvZ3t7e85nt7e2srKyktXaIkwEAAMBkEgwBAAAA4MhYW1vL+vr6N31ufX09a2trhzARAAAATDbBEAAAAACOhK2trayurl7086urq9na2hrhRAAAADD5BEMAAAAAOBJOnz6dzc3Ni35+c3MzZ86cGeFEAAAAMPkEQwAAAACYeBsbGzl37ty+3zt79mw2NjZGMBEAAAAcDYIhAAAAAEy01lpWVlayvb2973e3t7ezsrKS1toIJgMAAIDJJxgCAAAAwERbW1vL+vr6gd9fX1/P2traECcCAACAo0MwBAAAAICJtbW1ldXV1YH7rK6uZmtrawgTAQAAwNEiGAIAAADAxDp9+nQ2NzcH7rO5uZkzZ84MYSIAAAA4WgRDAAAAAJhIGxsbOXfu3ND6nT17NhsbG0PrBwAAAEeBYAgAAAAAE6e1lpWVlWxvbw+t5/b2dlZWVtJaG1pPAAAAmHSCIQAAAABMnLW1tayvrw+97/r6etbW1obeFwAAACaVYAgAAAAAE2Vrayurq6sj67+6upqtra2R9QcAAIBJIhgCAAAAwEQ5ffp0Njc3R9Z/c3MzZ86cGVl/AAAAmCSCIQAAAABMjI2NjZw7d27k+5w9ezYbGxsj3wcAAADGTTAEAAAAgInQWsvKykq2t7dHvtf29nZWVlbSWhv5XgAAADBOgiEAAAAATIS1tbWsr68f2n7r6+tZW1s7tP0AAABgHARDAAAAABi7ra2trK6uHvq+q6ur2draOvR9AQAA4LAIhgAAAAAAAAAA9JRgCAAAAABjNzs7m6WlpUPfd2lpKbOzs4e+LwAAABwWwRAAAAAAJsLi4mIWFhYObb+FhYUsLi4e2n4AAAAwDoIhAAAAAEyEqsry8nJmZkb/I6uZmZksLy+nqka+FwAAAIyTYAgAAAAAE2N+fj7Hjx8f+T4nTpzI/Pz8yPcBAACAcRMMAQAAAGCinDp1KnNzcyPrPzc3l5MnT46sPwAAAEwSwRAAAAAAJsrs7GyWlpZG1n9paSmzs7Mj6w8AAACTRDAEAAAAgImzuLiYhYWFofddWFjI4uLi0PsCAADApBIMAQAAAGDiVFWWl5czMzO8H1/NzMxkeXk5VTW0ngAAADDpBEMAAAAAmEjz8/M5fvz40PqdOHEi8/PzQ+sHAAAAR4FgCAAAAAAT69SpU5mbmxu4z9zcXE6ePDmEiQAAAOBoEQwBAAAAYGLNzs5maWlp4D5LS0uZnZ0dwkQAAABwtAiGAAAAADDRFhcXs7CwcOD3FxYWsri4OMSJAAAA4OgQDAEAAABgolVVlpeXMzOz/x9lzczMZHl5OVU1gskAAABg8gmGAAAAADDx5ufnc/z48X2/d+LEiczPz49gIgAAADgaBEMAAAAAOBJOnTqVubm5i35+bm4uJ0+eHOFEAAAAMPkEQwAAAAA4EmZnZ7O0tHTRzy8tLWV2dnaEEwEAAMDkEwwBAAAA4MhYXFzMwsLCN31uYWEhi4uLhzARAAAATDbBEAAAAACOjKrK8vLyN31ueXk5VXUIEwEAAMBkEwwBAAAA4Mi5UOhDIAQAAAD+0rFxD8DkqKonJXlykkcluTzJ15J8PsnHk9zaWrt7jOMBAAAApLWWlZWVtNa+6TM33HCDkAgAAABTTzBkylXVY5K8KsmPZCcQspcvV9V7kvy71tothzLcHqrqrUlefghbXd9ae+vFPFhVn0ny2CHvf3Nr7RVD7gkAAABH2traWtbX17/pc+vr61lbW8u11157CFMBAADA5HKVzJSqqpmqek2STyT5mVw4FJIkD03yo0k+VFVvq6orRj0jAAAAwP1tbW1ldXX1op9fXV3N1tbWCCcCAACAyScYMoWq6sFJ3pPk9UkefIAWL03yB1X1nUMdbPJ8ctwDAAAAAH/p9OnT2dzcvOjnNzc3c+bMmRFOBAAAAJNPMGTKVNUlSd6d5AV7PHJ3ko8kOZPkliRf2eO5JyT5nap65NCHnAyfaK39/riHAAAAAHZsbGzk3Llz+37v7Nmz2djYGMFEAAAAcDQcG/cAHLrXJnl+R/1LSf5Zkl9srd1xX7GqLk3yfUl+Nsk1u955XJL/VFUnW2v3jmbcTq9L8h+G1Ou52fnfvdtNQ+j9A0luH+D9zw9hBgAAADjyWmtZWVnJ9vb2vt/d3t7OyspKbrjhhlTVCKYDAACAySYYMkWq6tokr+5Y+nSSU621P9m90Fq7O8m7q+q/ZuekkefteuTZSf5Wkn8/5HH31FpbT7I+jF5V9ZqO8j1J3jaE9re21j4zhD4AAAAw1dbW1rK+fvAfBayvr2dtbS3XXnvtEKcCAACAo8FVMtPlDUku2VW7M8n3doVC7q+1dmd2TsD4WMfya6vq8uGMeHiq6qp0n57ym621zx32PAAAAMADbW1tZXV1deA+q6ur2draGsJEAAAAcLQIhkyJqnp6kpMdS69rrf3RxfRord2V5IaOpYcl+YkBxhuXl6f71JxhXCMDAAAADMHp06ezubk5cJ/Nzc2cOXNmCBMBAADA0SIYMj26ght/luSN+2nSWvtgkvd2LHUFRibd9R21jSS/cdiDAAAAAA+0sbGRc+fODa3f2bNns7GxMbR+AAAAcBQIhkyBqjqW5IUdS790/hSQ/XpzR+2JVfXdB+g1FlX1rCTf1bF0c2vtnsOeBwAAAPhGrbWsrKxke3t7aD23t7ezsrKS1trQegIAAMCkEwyZDs9M8q0d9XcfsN9vJPlqR/35B+w3Dq/co+4aGQAAAJgAa2trWV9fH3rf9fX1rK2tDb0vAAAATCrBkOnwNzpqdyX54EGatda+luQDHUvPOUi/w1ZVlyd5UcfS77fWPnHY8wAAAADfaGtrK6urqyPrv7q6mq2trZH1BwAAgEkiGDIdntFRu7W1dvcAPW/pqB2Vq2RelOTyjvpbDnsQAAAA4IFOnz6dzc3NkfXf3NzMmTNnRtYfAAAAJolgyHRY7Kh9dMCeXWeuXllVjx2w72HoukbmK0l+ZRSbVdVlVXV1VV1bVU85/88PHsVeAAAAcNRtbGzk3LlzI9/n7Nmz2djYGPk+AAAAMG6CIT1XVZcleUzH0qcGbL3XJb+PH7DvSFXVNUme1bH0ztbanUPe7p9W1S1J7kxyW5L/OzuBmtuS3FVVt1fVu6rqp6uq698RAAAATJXWWlZWVrK9vT3yvba3t7OyspLW2sj3AgAAgHE6Nu4BGLnHpDsA9NkB++71/uMG7DtqXaeFJKO5RuYV32T9qiQ/eP7Xv66qdyX5V621W0cwy0WpqusGbPHkoQwCAADAVFpbW8v6+l5/F2X41tfXs7a2lmuvvfbQ9gQAAIDDJhjSfw/foz7oWal7vb/XfmNXVZckeVnH0sdbax887Hl2OZbkf0rywqp6bZLXt9ZG/9ejHugDY9gTAAAAsrW1ldXV1UPfd3V1NU984hMzOzt76HsDAADAYXCVTP89bI/6HYM0ba3dm50rUnb7tkH6jtj3JnlkR/2mwx7kAo4leW2S91bVg8Y9DAAAAAAAAABHm2BI/12+R/0rQ+jdFQx5yBD6jkrXNTL3JHn7EPfYTvKhJK9P8qLsXK3yiCSz2fk2j07yrCT/IMn7L9DnVJJfqir/jQIAADAVZmdns7S0dOj7Li0tOS0EAACAXvOHzv136R71e4bQ++6O2mVD6Dt0VfWIJC/oWFptrQ16rU6SrCX56SSPaK09s7X2j1trv9pa+1hr7fOtta+31u5qrX22tfaB1tq/aa09O8l3J9nrGpsfSPKPhzAbAAAAHAmLi4tZWFg4tP0WFhayuLh4aPsBAADAOBwb9wCM3CV71O8dQu+uHpP6/6mXpTsk85ZhNG+tfd8B37u1qk4k+bkkr+p45H+tqje31m4faMCL9z0Dvv/kJG8axiAAAABMn6rK8vJybrzxxmxvb490r5mZmSwvL6eqRroPAAAAjNuk/iE+w7PXySDD+Hff1aPrFJFJcH1H7fYkv3XYg+zWWru3qn46ycOSvGTX8kOyc2rITx3SLHudXnJR/DANAACAQc3Pz+f48eN5//svdAPr4E6cOJH5+fmR7gEAAACTwFUy/be1R30YV7509dhrv7GpqmcmeVLH0s2ttWGcnDKw1lpL8neT/FnH8g+UxAUAAABT5NSpU5mbmxtZ/7m5uZw8eXJk/QEAAGCSCIb035f3qD90CL27emwOoe+wvXKP+k2HOsU30Vr7UpKf71i6KslTD3kcAAAAGJvZ2dksLS2NrP/S0lJmZ2dH1h8AAAAmiWBI/3WdQJEkVw7StKoelKTrJyh77TcWVfUtSX64Y+lsa+2Thz3PRVjdo/6MQ50CAAAAxmxxcTELCwtD77uwsJDFxcWh9wUAAIBJJRjSf5/bo37VgH33en+v/cblh5J0nT37lsMe5CLdmqR11F16DAAAwFSpqiwvL2dmZng/vpqZmcny8nLc2AoAAMA0EQzpvz9NstVR/44B++71/qcH7DtsXdfIbCb51cMe5GK01u5N96krjzjsWQAAAGDc5ufnc/z48aH1O3HiRObn/d0LAAAApotgSM+11lqS9Y6lawZs/YQ96p8asO/QVNVCkhMdS+9srd112PMM6LJxDwAAAADjcOrUqczNdR0Guj9zc3M5efLkECYCAACAo0UwZDrc2lG7dsCeT+2o3dZa+8KAfYfplUm6zoad1GtkUlWXJPm2jqXNw54FAAAAJsHs7GyWlpYG7rO0tJTZ2dkhTAQAAABHi2DIdPhQR+1JVXXFAD2vu8h9xuJ8wOLlHUsfa61NzJwdnpruMMv/d9iDAAAAwKRYXFzMwsLCgd9fWFjI4uLiECcCAACAo0MwZDqc7qhdkuTUQZpV1SPSfWJI1z7j8rwkV3fUbzrsQfbpb+5R7zr1BQAAAKZCVWV5eTkzM/v/UdbMzEyWl5dT1fX3MAAAAKD/BEOmQGvt40nWO5Z++IAtX5QHnmrRkqwesN8ovLKjdneStx/2IBerqq5M8nc6lr6c5JZDHgcAAAAmyvz8fI4fP77v906cOJH5+fkRTAQAAABHg2DI9HhHR+37q+ox+2lSO3+95qc6lt7XWrvtQJMNWVV9e7pP3vj11trnD3uei3H+u74xycM6lt/VWts65JEAAABg4pw6dSpzc3MX/fzc3FxOnjw5wokAAABg8gmGTI83Jfn6rtqlSf75Pvtcn+SJHfWfv9gGVfWZqmq7fn1mn3NcyEuSXNZRf8sQ90iSVNVfr6pHD9jjkiQ3Zmfu3e5N8q8H6Q8AAAB9MTs7m6WlpYt+fmlpKbOzsyOcCAAAACafYMiUaK39aZKbOpZeVlU/dDE9quqaJD/XsfTRJL82wHjD1nWNzGeTvHcEe31/kj+pqrdV1XOq6th+Xq6qv5Lk/UletccjN56/CggAAABIsri4mIWFhW/63MLCQhYXFw9hIgAAAJhsgiHT5Z8k+WJH/e1V9eILvVhVT01yJskVHcuvaq1tD2G+gVXVM5I8pWPp5tbavSPa9tIkL83O99moql+uqp+pqudW1UJVPbyqLquqB1XVI6vquqr6+1X1viS3JvmePfqeS/KaEc0MAAAAR1JVZXl5OTMze/9Ya2ZmJsvLy9m5uRUAAACm275ON+Boa619oap+LMl/2bU0m+SXq+qlSX4hyf+V5AtJHprk2iQ/muQV2QlA7PZvW2u/O7Kh96/rtJCW7tNSRuFhSV58/tcgfi/J97XWdl//AwAAAFNvfn4+x48fz/vf//7O9RMnTmR+fv6QpwIAAIDJ5MSQKdNa+7XsfQrF87NzJcznktyT5M+TvC/JDekOhawmefXwpzyYqnpwugMZv9daWz/seQ7o60n+UZKTrbXNcQ8DAAAAk+rUqVOZm5t7QH1ubi4nT54cw0QAAAAwmQRDplBr7V8k+XtJBrla5R1JXthau3s4Uw3FD6b7qptRnhby0SSfHUKfO5P8xyR/pbX2v4/w2hsAAADohdnZ2SwtLT2gvrS0lNnZ2TFMBAAAAJNJMGRKtdZuTPKsJB/e56u3J3lpa+2lrbWt4U82kK5rZO5I8q5Rbdha+4+ttUcn+a7z+78xyfuz8522L/DqPUk+kuRNSa5P8qjW2g2ttY+PalYAAADom8XFxSwsLPzF7xcWFrK4uDjGiQAAAGDyHBv3AIxPa+1DSZ5eVaeSvCTJqSRXdzz6pSRnsxOweOeggZDW2uMGef8C/mEeGHa6o7X21RHt9xdaa3+c5I+T/OJ9tao6luSqJA9N8i3ZCYrckZ3veYdTQQAAAGAwVZXl5eXceOONSZLl5eVU1ZinAgAAgMkiGEJaa6eTnE6SqroyyaOSPCTJ15J8obV2+xjHu2ittVvGPcP9tdbuSXLbuOcAAACAPpufn8/x48dTVZmfnx/3OAAAADBxBEP4Bq21L2XnRAsAAACAI+HUqVPjHgEAAAAmlmAIAAAAAEfa7OzsuEcAAACAiTUz7gEAAAAAAAAAABgNwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnhIMAQAAAAAAAADoqWPjHoDJUVVPSvLkJI9KcnmSryX5fJKPJ7m1tXb3GMc70qpqIcliku/Izrf9A+rUqwAAIABJREFUepIvJvlEkg+31r46xvEAAAAAAAAA6CnBkClXVY9J8qokP5KdQMhevlxV70ny71prtxzKcHuoqrcmefkhbHV9a+2tB325qr49yd9O8ookj7/Ao1+rqt9O8sbW2umD7gcAAAAAAAAAu7lKZkpV1UxVvSY7J1b8TC4cCkmShyb50SQfqqq3VdUVo57xKKuqH0/yx0lemwuHQpLkQUm+L8l/q6rfrKqrRz0fAAAAAAAAANNBMGQKVdWDk7wnyeuTPPgALV6a5A+q6juHOtjk+eR+XzgfuHlzkjcn+dYD7Pn8JB+uqqcd4F0AAAAAAAAA+AaCIVOmqi5J8u4kL9jjkbuTfCTJmSS3JPnKHs89IcnvVNUjhz7kZPhEa+33D/Def0jy43us3Zvk/0nyO0k+kOTP93huPslvV9WTDrA/AAAAAAAAAPyFY+MegEP32uycSrHbl5L8syS/2Fq7475iVV2anWtOfjbJNbveeVyS/1RVJ1tr945m3E6vy04AYxiem53/3bvdtN9GVXVDkhs6lr6W5F8m+T9ba//9fs/PJDmZnZNbnrHrnYcleXdVPaO1tlc4BwAAAAAAAAAuSDBkilTVtUle3bH06SSnWmt/snuhtXZ3dgIK/zU7J408b9cjz07yt5L8+yGPu6fW2nqS9WH0qqrXdJTvSfK2ffZ5ZJI3dCx9MclzW2sf3r3QWttO8t+q6nezc/XMK3Y98sQk/zTJP9jPLAAAAAAAAABwH1fJTJc3JLlkV+3OJN/bFQq5v9banUl+IMnHOpZfW1WXD2fEw1NVV6X79JTfbK19bp/tXpfkobtq20l+sCsUcn+ttXuS/Fh2ru/Z7X+uqsfucxYAAAAAAAAASCIYMjWq6unZubZkt9e11v7oYnq01u5K91UpD0vyEwOMNy4vT/epOfu6RqaqHpXkpR1Lb2qtve9iepw/PeTHs3PtzP1dmuTv72ceAAAAAAAAALiPYMj06Apu/FmSN+6nSWvtg0ne27HUFRiZdNd31DaS/MY++7wiyWW7ancnef1+mrTWPpPk5o6ll1XV7D5nAgAAAAAAAADBkGlQVceSvLBj6ZfOnwKyX2/uqD2xqr77AL3GoqqeleS7OpZuPn+1y368uKP2W6212/Y/Wee3vSLJCw7QCwAAAAAAAIApJxgyHZ6Z5Fs76u8+YL/fSPLVjvrzD9hvHF65R32/18g8OsmTO5YO9G1bax9O8pmOpaP0bQEAAAAAAACYEIIh0+FvdNTuSvLBgzRrrX0tyQc6lp5zkH6HraouT/KijqXfb619Yp/tur5tkpzZZ59v9u6R+LYAAAAAAAAATBbBkOnwjI7ara21uwfoeUtH7ahcJfOiJJd31N9ygF5d3/azrbXPHqDXfbq+7eOr6soBegIAAAAAAAAwhQRDpsNiR+2jA/Zc66hdWVWPHbDvYei6RuYrSX7lAL0O69smybUD9gUAAAAAAABgygiG9FxVXZbkMR1Lnxqw9foe9ccP2HekquqaJM/qWHpna+3OA7Rc6KhN5bcFAAAAAAAAYPIcG/cAjNxj0h0AGuSqkwu9/7gB+45a12khyQGukamqS5M8qmNpoG/bWvt8VX09yWW7lh43SN+LUVXXDdjiyUMZBAAAAAAAAIChEAzpv4fvUd8YsO9e7++139hV1SVJXtax9PHW2gcP0PLb0h26GfTb3tdj90kvh/FtP3AIewAAAAAAAABwSFwl038P26N+xyBNW2v3Jum6euXbBuk7Yt+b5JEd9ZsO2G8k3/a8zY7aJH9bAAAAAAAAACaQYEj/Xb5H/StD6N0VDHnIEPqOStc1MvckefsB+/m2AAAAAAAAAEw0wZD+u3SP+j1D6H13R+2yIfQduqp6RJIXdCytttYOevWLbwsAAAAAAADARDs27gEYuUv2qN87hN5dPSb1/1MvS3eQ4y0D9Ozjt/2eAd9/cpI3DWMQAAAAAAAAAAY3qX+Iz/DsdXrFMP7dd/XoOuliElzfUbs9yW8N0LN337a19sFB3q+qYY0CAAAAAAAAwBC4Sqb/tvaoD+Nakq4ee+03NlX1zCRP6li6ubU2yOkeU/9tAQAAAAAAAJhsgiH99+U96g8dQu+uHptD6Dtsr9yjftOAfX1bAAAAAAAAACaaYEj//dke9SsHaVpVD0oyu4/9xqKqviXJD3csnW2tfXLA9iP5thfoMVHfFgAAAAAAAIDJJxjSf5/bo37VgH33en+v/cblh5LMddTfMoTef57k6x31gb5tVV2S5OEdS5P2bQEAAAAAAACYcIIh/fenSbY66t8xYN+93v/0gH2Hresamc0kvzpo49badpL/t2Np0G97dbr/25y0bwsAAAAAAADAhBMM6bnWWkuy3rF0zYCtn7BH/VMD9h2aqlpIcqJj6Z2ttbuGtE3XdTSj+raDXn0DAAAAAAAAwJQRDJkOt3bUrh2w51M7are11r4wYN9hemWS6qgP4xqZ+3R928Wq6tr3YnV923uSfHSAngAAAAAAAABMIcGQ6fChjtqTquqKAXped5H7jEVVXZLk5R1LH2utDXPOrl5zSf6HAXp2fduPtNa6rgQCAAAAAAAAgD0JhkyH0x21S5KcOkizqnpEuk+16NpnXJ6X5OqO+k1D3uf3snOaR9f++1ZVlyZ5TsfSJH1bAAAAAAAAAI4IwZAp0Fr7eJL1jqUfPmDLF+WBV7S0JKsH7DcKr+yo3Z3k7cPcpLW2mZ1wyG4H/bbPS3JlR/09B+wHAAAAAAAAwBQTDJke7+iofX9VPWY/TaqqkvxUx9L7Wmu3HWiyIauqb0/yNzuWfr219vkRbNn1bZ9RVX/tAL3+Tkft0621DxygFwAAAAAAAABTTjBkerwpydd31S5N8s/32ef6JE/sqP/8xTaoqs9UVdv16zP7nONCXpLkso76W4a4x/29M0lX4ORf7qdJVT0n3VfQXPS3BQAAAAAAAID7EwyZEq21P01yU8fSy6rqhy6mR1Vdk+TnOpY+muTXBhhv2LqukflskveOYrPW2leTvKFj6dlV9TMX06OqHp7kFzuW/nt2Qj0AAAAAAAAAsG+CIdPlnyT5Ykf97VX14gu9WFVPTXImyRUdy69qrW0PYb6BVdUzkjylY+nm1tq9I9z6xiSf7Kj/q6r6Xy70YlV9Z5LfSfIdHcuvbq19ZQjzAQAAAAAAADCFBEOmSGvtC0l+rGNpNskvV9VvVtVyVc1X1SVVdWVVPbuq3pTkQ0ke3fHuv22t/e4o596nrtNCWrpPSxma1tpWdq6w2X1dTyV5Q1V9oKpeXFVXV9Wxqrq8qv5aVf2b7Jy48uSOtv+5tfbWUc4NAAAAAAAAQL8dG/cAHK7W2q9V1WuS/GzH8vPP/7pYq0lePZTBhqCqHpyk6+ST32utrY96/9baLVX1Y0luzgNDV9ed/3Wx/iDJ9cOaDQAAAAAAAIDp5MSQKdRa+xdJ/l6SQa5WeUeSF7bW7h7OVEPxg+m+6makp4XcX2vtHUl+JMldA7T57STPba1tDmcqAAAAAAAAAKaVYMiUaq3dmORZST68z1dvT/LS1tpLz1+fMkm6rpG5I8m7DnOI1to7kzwtyel9vnpHdgI7z2+tfWnogwEAAAAAAAAwdVwlM8Vaax9K8vSqOpXkJUlOJbm649EvJTmbnYDFOwcNhLTWHjfI+xfwD/PAsNMdrbWvjmi/PbXW/ijJ/1hVfzXJK5I8N8njk9SuR+9M8sEk/yXJ21trXz7MOQEAAAAAAADoN8EQ0lo7nfOnW1TVlUkeleQhSb6W5AuttdvHON5Fa63dMu4Zdjs/0y1JUlWXJ3l0ksuT3J3ki0lua6218U0IAAAAAAAAQJ8JhvANzl9h4hqTEWitfSXJH417DgAAAAAAAACmx+5rNwAAAAAAAAAA6AnBEAAAAAAAAACAnhIMAQAAAAAAAADoKcEQAAAAAAAAAICeEgwBAAAAAAAAAOgpwRAAAAAAAAAAgJ4SDAEAAAAAAAAA6CnBEAAAAAAAAACAnjo27gEOQ1U9M8mzkjwtyROSXHH+14OS1IDtW2vtigF7AAAAAAAAAAAMXW+DIVVVSX7q/K9r7r805K3akPsBAAAAAAAAAAxFL4MhVfWEJO9I8vR0B0GGFeYYdsgEAAAAAAAAAGBoehcMqarvTPK+JFdlJ7jhRA8AAAAAAAAAYCr1KhhSVZck+fUkj8xOIOT+oRCnewAAAAAAAAAAU6VXwZAkP57kSXngKSGV5CNJfiXJh5N8Kslmkq8e6nQAAAAAAAAAAIeob8GQv7vr95Xkc0l+srX262OYBwAAAAAAAABgbHoTDKmqq/ONp4VUki8m+euttT8e22AAAAAAAAAAAGMyM+4Bhuiv3u+fKzsBkf9NKAQAAAAAAAAAmFZ9CoY8Ytfv70nytnEMAgAAAAAAAAAwCfoUDHnYrt9/orW2OZZJAAAAAAAAAAAmQJ+CIVv3++eW5PPjGgQAAAAAAAAAYBL0KRhy+67fP3gsUwAAAAAAAAAATIg+BUPW7vfPleSqcQ0CAAAAAAAAADAJehMMaa19LMlt9ys9tqquHtc8AAAAAAAAAADj1ptgyHk3Zee0kPu8cFyDAAAAAAAAAACMW9+CIf9Hks8nadkJiPyjqnrIeEcCAAAAAAAAABiPXgVDWmt/nuRv3/fbJA9P8stVVXu/BQAAAAAAAADQT70KhiRJa+0/J3lN/vJKmaXk/2fvzqMlO8t68X+fTocQMg9IGMMMMsokBBBlkIiiIl70JxG5TA4oKNMFZ68KjoCA+FNQBMKgFxkuRFRACSpTRANRwzxGQCBzgMx57h9Vhz5dXaf7nFNVp07v/nzW2qv2fvfez/vUOd1ZK8l3vW/eVFXHLK8rAAAAAAAAAICtN7hgSJJ09+8keWKSq8ZDD01ydlU9q6qut7zOAAAAAAAAAAC2zs5lNzBPVfXCiaEPJDlpfH69JM9O8uyq+kSSs5Ocn+Rrs87b3U+etQYAAAAAAAAAwLwNKhiS5GeS9JTxlbGV7WVuleSWc5ivxrUFQwAAAAAAAACAbWdowZAVNeW6s3toZPIZAAAAAAAAAIBBGWowZNqqIZt5Zl+ESwAAAAAAAACAbWuIwRBhDQAAAAAAAACADC8Y8qRlNwAAAAAAAAAAsF0MKhjS3S9edg8AAAAAAAAAANvFjmU3AAAAAAAAAADAYgiGAAAAAAAAAAAMlGAIAAAAAAAAAMBACYYAAAAAAAAAAAyUYAgAAAAAAAAAwEAJhgAAAAAAAAAADNTOZTewDFV1WJJ7JrlJkmPGx2FJLkpyfpILkpyd5EPdfc2y+gQAAAAAAAAAmMUBEwypqhOTPDHJyUlun/WtlvL1qvpAkv+T5BXd/fUFtggAAAAAAAAAMFeD30qmqm5TVW9K8okkT09ypyQHJal1HIcluV+SP0zy+ar63aq6zpZ/CQAAAAAAAACATRh0MKSqfirJvyb53uwKgyRJb+BYCYkcleRpST5YVd+6dd8CAAAAAAAAAGBzBhkMqaodVfXKjFb6uE5GwY7VYY/dHp9yrDYZErllkn+uqkct7AsAAAAAAAAAAMzBzmU3sCAvSvKj4/NpQZAV5yT5QpKLklya5IiMVga5eZJjVj3XE587k/x5VV3Y3W+ZY98AAAAAAAAAAHMzuGBIVT0iyU9leiDk0iRvSvLqJO/r7vP3UufEJPdP8mNJvj27Vh3J+HNHkldW1e27+wtz/RIAAAAAAAAAAHMwqK1kquqQJH8w7VaSU5PcvLtP6e637i0UkiTd/dnufnl3PyDJtyY5I3tuM3Nkkt+dQ+sAAAAAAAAAAHM3qGBIksckuX52rexRSa5K8qPd/eju/tJminb3vyY5KclLsysc0uPzH66qm83UNQAAAAAAAADAAgwtGPKoVecrW788rrtfM2vhHvmJJK/K7iuH7Ejyo7PWBwAAAAAAAACYt8EEQ6rqyCT3zK6VPDrJm7v7VXOe6klJ/nti7LvmPAcAAAAAAAAAwMwGEwxJcrfs+X2eP+9JuvuiJC/PrvBJJbnLvOcBAAAAAAAAAJjVkIIhN5+4vqC7/3FBc71p4vqQqrrRguYCAAAAAAAAANiUIQVDjp24/uwC5/r0OuYHAAAAAAAAAFiqIQVDDll13kkuXOBc02ofvMD5AAAAAAAAAAA2bEjBkK+vOq8kJyxwrutNGbt0gfMBAAAAAAAAAGzYkIIhX5q4vmlVHbqguW4/ZezLC5oLAAAAAAAAAGBThhQM+djE9bWTPHRBc/3QxPWF3X3uguYCAAAAAAAAANiUIQVDPpjksvF5Z7SdzK9U1c55TlJVt0nyyFVzdJL3znMOAAAAAAAAAIB5GEwwpLuvTPK3GYU1VtwuyXPnNUdVHZ7klUkOmbj15nnNAQAAAAAAAAAwL4MJhoz92arzlRU9fqaq/riqDp6lcFWdkOTvk9xjXHvFJUn+YpbaAAAAAAAAAACLMKhgSHf/dZJ/WT2UUTjkCUn+s6q+r6pq6strqKrDquppST6S5O6rb43rv6C7L56tcwAAAAAAAACA+du57AYW4MeTvC/JtcbXK+GQWyZ5Y5L/rqq/SvL+JGcm+WKSi7v7mqq6VpIjk9w8yV2SfHuS70tyaHZtUdOrPj+S5NmL/kIAAAAAAAAAAJsxuGBId3+oqn4iyZ+vHh5/VpLrJ/mZ8fENVXVVpv88JgMhK2PnJnlYd18xj74BAAAAAAAAAOZtUFvJrOjuV2a0fcxkaKOzawWRyePgNcZX3llRSc5J8sDu/vjivgUAAAAAAAAAwGwGGQxJku5+WZJ7Jjk7u1b9+MbtDRwrVoIir01yp+7+90X2DwAAAAAAAAAwq8EGQ5Kku89KcvckP5vk49l9JZD1WP3s25I8pLtP6e6L5t0rAAAAAAAAAMC87Vx2A4vW3ZcneVGSF1XVg5KcnOSkJHdNcu29vHpekvcleU+S13f3xxbdKwAAAAAAAADAPA0+GLJad78jyTuSpKp2JrlekmPGx6FJLk5yQZILuvvLy+oTAAAAAAAAAGAeDqhgyGrdfVWSz48PAAAAAAAAAIDB2bHsBgAAAAAAAAAAWAzBEAAAAAAAAACAgRIMAQAAAAAAAAAYKMEQAAAAAAAAAICBEgwBAAAAAAAAABgowRAAAAAAAAAAgIHauewG9qaqnjptvLuft5HnF22tfgAAAAAAAAAAlmlbB0OS/H6SnjK+VhBjrecXTTAEAAAAAAAAANh2tnswZEWtOl9P8KP2/cjcLCOIAgAAAAAAAACwT/tLMGQlfLHewMdWhTW2MoACAAAAAAAAALAh+0MwZKPhC2ENAAAAAAAAAIBs/2DIcxf8PAAAAAAAAADAYG3rYEh3P2ORzwMAAAAAAAAADNmOZTcAAAAAAAAAAMBiCIYAAAAAAAAAAAyUYAgAAAAAAAAAwEAJhgAAAAAAAAAADJRgCAAAAAAAAADAQO1cdgPzVFVnrbrsJKd0938sYJ47Jnn16rm6+87zngcAAAAAAAAAYBaDCoYkuUNGgZAaf15nQfNcZ8pcAAAAAAAAAADbiq1kAAAAAAAAAAAGSjAEAAAAAAAAAGCgBEMAAAAAAAAAAAZKMGRzJn9u1yylCwAAAAAAAACAvRAM2ZzDJ66/upQuAAAAAAAAAAD2QjBkc242cS0YAgAAAAAAAABsO4Ihm/PgVeed5HPLagQAAAAAAAAAYC2CIRtUVack+YGMAiE1Hv7Q8joCAAAAAAAAAJhu57IbWK+qOjHJD27wtUdW1X1nnPrgJIcluWmSk5LcPKNASK965l0zzgEAAAAAAAAAMHf7TTAkyW2T/H52D2RMU6s+nzTnHlZqr+7hoiRvmvM8AAAAAAAAAAAz25+CIavVvh/Z0HPrNRlK6SS/2t2Xz3keAAAAAAAAAICZ7a/BkLVWDZkMguxrdZHNWpnnRd39ogXNAQAAAAAAAAAwk/0xGLKRVUDmvWJIklyd5O+SvKC7376A+gAAAAAAAAAAc7E/BUM+neS5+3jmaRmtElLjz9cm+eIMc3aSy5NckuSCJGcn+VB3f3WGmgAAAAAAAAAAW2K/CYZ098eSPGNvz1TV0yaGXtjdZyyuKwAAAAAAAACA7WvHshsAAAAAAAAAAGAxhhgMqYlPAAAAAAAAAIAD0n6zlcw63XHi+pNL6QIAAAAAAAAAYBsYVDCku/9z2T0AAAAAAAAAAGwXQ9xKBgAAAAAAAACACIYAAAAAAAAAAAyWYAgAAAAAAAAAwEAJhgAAAAAAAAAADNTOZTew1arqkCQnJjl6fByWpGYse2Z3f3rW3patqm6X5A5JbpDk8CSXJflKkg9n9B2vXGJ7m1ZVRyS5U5JbJTk2yXUy+m6XJDknySeTfLy7r1lakwAAAAAAAACwAAdEMKSq7pnklCQnZRQQmPf3flKSP5pzzS1RVTdO8uQkj8woELKWS6rqzUle2N1nbElzM6iqozL6nT8yyT2z79/5V6vqA0n+PslbMwrC9AbmOz3Jt2+u2zW9q7u/Y841AQAAAAAAADiADDoYUlX3T/JbSe6xMrSAadYdHthOqmpHkmcl+aUkh67jlSMyClqcUlWnJnlSd1+0wBY3paoOTvLUjL7b0Rt49fAk3zE+fiPJzZJ8Zr7dAQAAAAAAAMDWGmQwpKoqyf9O8vNJdmT3QMg8gxyLCJosXFUdmuR1Sb5nkyUeleReVXXydtpCp6pumeQvk9x12b0AAAAAAAAAwHYwyGBIkucm+dnsCm6sDoOsJ8wxLTyyX4ZAJlXVQUlen+QhazxyZZKzk5yb0Soht8toNY1Jt0ryD1V17+7+4iJ63YjxdkGnJTl+L499JcmXxp/XzmhFkZsnOWThDQIAAAAAAADAEgwuGFJVpyT5uYzCHZOBkEuS/HuSLyd52Ph+jT9PT3JxkmMyChfcOrt+Pr3q2auSvDWjAMWKTyzkyyzGr2d6KOTCjFZZ+fPVW8SMt2b5viTPyehnstpNk7y2qh7Y3Vcvpt19q6o7JvnbTN865j+T/GmS/zttdZOq2pnkm5M8IMlDM9pKZl5/L346yb/N8P7Fc+oDAAAAAAAAgAPUoIIhVXWtJL83OZzk80mekeQN3X3F+NlrJp77+e4+Y1Wt6yQ5Kcnjkzw8ycEZhUMOSnLjJI/o7k8t4nssSlXdOckzp9z6dJIHTfs+3X1lktdX1d9mtNLIyROPfHuSn0zy4jm3uy5VdUxGK4VMhkK+luQXk7y4u69a6/3xvX8fHy+oqhsm+fEkl86hvbO7+31zqAMAAAAAAAAAm7Jj2Q3M2WOSnJBdq3skyYeT3L27/2IlFLIe3f317v777v6RjFaUePeqmt+S5N1Vdfv5tb4lnptRsGW1ryX57n2FXLr7axkFZP5zyu1fr6pp281shT9JcpOJsa8m+a7ufsHeQiHTdPfnu/tXu/tLc+sQAAAAAAAAAJZkaMGQUyaur0zyP2b9n/zj0MT9kvxZdoVDrpfktKo6fpbaW6Wq7p7kgVNu/UZ3f2Q9Nbr760meMOXWsRmtsrGlqurBSR4xMdxJvr+7/3mr+wEAAAAAAACA7WYwwZCqOiTJPbJrtZBO8oru/vA86nd3ZxR+OG1V/Zsked486m+BacGN85K8aCNFuvu9Sf5uyq1pgZFF+90pYy/r7n/Y8k4AAAAAAAAAYBsaTDAkyd2SHDIx9vJ5TjAOhzwxydfHQ5XkkVV163nOM29VtTPJ/5hy69XjVUA26qVTxm5bVXfdRK1NqaqTk9x5YvjrSZ65VT0AAAAAAAAAwHY3pGDIjSaur0jyLxt4fzJUMlV3/1eSV2fXljKV5LEbmGcZ7pXkmCnjr99kvb9OcumU8Ydsst5mTFsB5U3dfd4W9gAAAAAAAAAA29rOZTcwR8dOXH+iu6/awPvX3sCzb8po65SVbWtOTvKsDby/1e4/ZezrSd67mWLdfVlVvSfJAyduPSDJszdTcyOq6ogk3z3l1qsXPTcAAPu3K6+8MuedJ0sMsL+76qqrcuGFF+71maOPPjo7dw7pP30BHJiOO+64HHzwwctuAwBgvzakfztevSJGJ7lgH89/Lcl1Vl0ftoG5/mPi+nZVdVB3X72BGlvpHlPGzuzuK2eoeUb2DIZs1VYy98+eQZ6rk/zDFs0PAMB+6rzzzsvzn//8ZbcBAACs01Oe8pSccMIJy24DAGC/NqRgyGTI4bJ9PH9xdg+GTG5FszdfnrjemeTGST6zgRpb6U5TxibDLRt11pSxo6vqxO7+7Iy19+U7pox9rLun/s6r6pAkJyY5IsklSb6S5MLu7oV1uPv8O5NcN8nxGW3fdH6SC7r7q1sxPwAAAAAAAAAHriEFQy5edV5JjtzH85ckWR0zvvEG5jpoythRG3h/y1TVtTL9u31ixtKfXGP85kkWHQyZtjLJh1ZfVNXxSR6f5AeT3CV7/s4urap/TvL2JH/R3ecsoM8nVtVvZLRiyyGTN6vq/CTvSfLuJG/q7o8soAcAAAAAAAAADmBDCoZMruKxr6DGJ5PcOqNtZ5LkbhuYayMhkmW7cUarVEz6/Ix113r/pjPWXY/bTxn7TJJU1UFJnpHkl7L37YEOTfKd4+M3q+olSX6zu780xz4fsY/7xyZ56Ph4TlX9TZLf6+7T59jDhlTVSTOWuMNcGgEAAAAAAABgLoYUDPnoxPWJVVV72S7k35M8ZHxeSe5ZVYd09+XrmOv+U8bOW2efW+26a4zPGoBY6/215puLqjo0oy1ZJl1SVUckeWOSB26w7LWS/EySh1fVw7r7X2ZsczMqyXcn+e6qenGSp6+1Nc6CvWcJcwIAAAAAAACwINNWkthffSLJVauuD0lym708f+bE9XWSPHJfk1TVjiRPnBi+MrMHLRbl2DXGL5qlaHdfneRrU24dN0vddbj+GuNXJHlrNh4KWe0GSd5VVQ+eocY8/HSS91XVon+WAAAAAAAAAAzcYIIh3X1lkn/NaOWFFXfjNPN5AAAgAElEQVTfyytvTbKyIkOP33t2VV1vH1M9J6PtMlbe6SRnjOffjg5fY/yrc6g9LRiyt+1b5uGYNcZ/Lsl9J8Y+kuTpSe6cUUDm0CQnJvnBJK9Ncs2UOocmeW1VnbjJ/jrJWUl+P8kpSb4lyQkZBY+unVH45B5Jnpzkr9foIeOe3zJeIQUAAAAAAAAANmUwwZCx08efK9vHPHStB7v7koz+x/zqIMkJGa3U8JCqWj2eqrpRVb0iyTNW1V/xf2dpesEOXmP8qjXGN2JaGOZac6i7N4esMX7DVeed5JeS3LG7n9vdZ3X3Bd19WXd/rrvf0N2PzCig8ZkptY5N8poN9vWpJL+c5CbdfefufkZ3v6a7P9TdX+ruS7v78u7+Ynd/oLtf1N0PzWhVm9PWqHlSkhdvsA8AAAAAAAAA+Iady25gzt6e5Jnj80pyclUdvJfVPJ6d5Aeya+WPZLSixGlJzq2qj2e0ssYNktxu/NzqZ5PkwiR/Ms8vMWcHrTF+9RxqT6ux6D9T66n/U929z99Jd/9bVd03ybsz+r2vdu+qenB3v209TXX3Y9fz3JT3PpHke6vqGUl+d8ojj66qF3b3BzdTfxPuPeP7d0jyknk0AgCwCMcdd1ye8pSnLLsNAGZ07rnn5tRTT93rM4961KNy/PHHb1FHACzKccfZcRsAYFZDC4acnuTLSa6bUXjjyCQ/kuSV0x7u7g9W1R8neWJ2hT1Wtoi5bpKV/3qwevWQXjXWSZ7a3fPYlmVR1loZZB6/+2k1Fr2lzr7qv249oZAV3f35qnp0kndm999zkjwrybqCIbPq7t+rqqOS/OLErR0ZBZi+Z4v6eO8s708stAMAsO0cfPDBOeGEE5bdBgBb4Pjjj/fPfAAAAMjAtpLp7muSvD67VvaoJE/bx2tPTfJ32TP8sRIQqYmx1Z7f3a+Yse1Fu3yN8Xls+TKtxlrzzcsVe7nX2TNYsU/d/a4kfzvl1rdX1dEbrTeDX0vy0Snj31lVR2xhHwAAAAAAAAAMxKCCIWM/l+SYVcf99vZwd1+R5GFJXppdYZBv3M6egZDKKPzwc9399Pm1vTCXrDE+j6DBtBoXz6Hu3ly4l3und/fHN1l32vYnO5J82ybrbVh3X5Xkt6fcOjjJd25VHwAAAAAAAAAMx+CCId19ZXdftPpYxzuXd/dPJLlnklckOTe7rzqycnw2yQuS3LK7X7iwLzFf560xPtNKGFV17SSHbGC+eTl3L/f+cYa6a717rxlqbsZbs+fKNElyjy3uAwAAAAAAAIAB2LnsBraT7v7XJI+pqkpykyTXS3JUkouSfKG7/2uZ/W3Sf68xPusmu2u9v9Z8c9HdF1XV15IcNuX2B2eoe35VnZPkxhO3vmmzNTfZx5fHfdxk4tb1trIPAAAAAAAAAIZBMGSK7u6MVgf57LJ7mYMvZLT1zeTqHpPBg41a6/1Pz1h3PT6V5I5Txs+fse552TMYctyMNTfjy9nz57ulARUAAAAAAAAAhmFwW8mwu3HI5ZNTbt16xtK3WmP8EzPWXY8PrzH+9Rnrfm3K2OEz1pyXay27AQAAAAAAAAD2P4IhB4Yzp4zdecaad5ky9l/dfe6MddfjA2uMHzlj3aOmjM26CslmTFsd5OIt7wIAAAAAAACA/Z5gyIHh/VPGbldV04IQ63XSOudZhHevMT7rdivT3t+KoMs3VNV1s+d2Nknyua3sAwAAAAAAAIBhEAw5MLxjythBSR60mWJV9U2ZvmLItHkW4f1JLpwyfvfNFqyqm2R6MOQzm625SQ9NUlPGp636AgAAAAAAAAB7JRhyAOjuDyf55JRbP7zJkj+UPcMLneS0TdbbkO6+Osmbptx68Axl13r3nTPU3JCq2pnkWVNu9Vb2AQAAAAAAAMBwCIYcOF41ZexhVTVt25I1VVUl+ekpt07v7v/aVGeb87IpY3esqvtust4Tp4ydn61dqePXktx6yvhW/2wBAAAAAAAAGIidy25gb6rq2GX3sB7dff6ye1iHlyT5+STXWjV2cJLfTPLoDdR5TJLbThn/w/UWqKrPJDlxYviz3X3T9dbo7n+qqjOSfOvEredX1UndfdUG+nl8pm+N87LuvmYf794jycXd/dH1zrdGnacn+cU1bv/2LLUBAAAAAAAAOHBt62BIknMz2kZjO+ts/59juvsLVfWyJD85cevHquq07n7dvmpU1a2TPG/Krf/I9K1dFu0Xk7x9YuzuSV5cVT/Z3fv8s1NV90ny/Cm3vp7kd9fRw32SPK+q3pzkT5O8o7svW8d7K/PfYjz/967xyOu7+23rrQcAAAAAAAAAq237QEOSWnYDA/LLSX4oyeRKLKdW1c7ufu1aL1bVXZK8OclRU24/eV8rayxCd7+jql6d5JSJWz+e5Juq6klrbcFSVTuSPCGjoMt1pjzyv7v7K+tspZJ8//j4alW9PckHkpyV5GNJLkxycZJrkhyT5IZJTkrykPGx1pZOH0vy+HX2AAAAAAAAAAB72B+CIdt5xZD9KrTS3edW1eOSvHHi1iFJXlNVj0ryJ0nel9FqLUckuXNGwYv/mdHWM5Oe393vXFjT+/ZTSe6WPbe3eViSk6vqtCRvS3JOksuSXDejVUUenuRWa9R8XXevZ7WQaQ5P8gPjYxb/meTk7r5wxjoAAAAAAAAAHMD2h2AIc9Tdb6qqX0jynCm3V1awWK/TkjxzLo1tUndfUlUnJ3lnkptP3D40ySPGx3r9bZLHzKm9zbgmyQuS/MJGtqQBAAAAAAAAgGm2ezDk/GzvFUP2S939W1V1aZLfT3LQJsu8Ksnju/vK+XW2Od39uao6Kclrkzxgs2WSPDfJMze4Lc4nknwqe4ZSNuqKjFZyeV53nzFjLQAAAAAAAABIss2DId19/LJ7GKru/oOqem+SF2e0Fct6fTHJ/+ruVy2ms83p7i9X1YOSPDrJL2djQY03J/m17j5zE/OeluS0qrpxkm9Lctck35Lk1kmun7X/jnWSjyQ5I6Ote97Q3V/e6PwAAAAAAAAAsDfbOhjCYnX3+5PcfRyo+NEkD0pywymPXpjkn5L8VZK/7O7LZ5z3prO8v5e6neTlVfXKjFYOeUiSb01yyyRHZ7Q6ynlJvpLkY0nekeRt3f2pOcx9TpLXjI8kSVXtSHK9JEdltK3NjiQXZfTzvLC7r5p1XgAAAAAAAADYG8EQ0t3vyCgkkao6OskNkhyW5LIk53b3F5fY3oaNt4L5xndach9fHB8AAAAAAAAAsOUEQ9hNd1+Y0YoWAAAAAAAAAMB+bseyGwAAAAAAAAAAYDEEQwAAAAAAAAAABkowBAAAAAAAAABgoARDAAAAAAAAAAAGaueyG9hKVXVQkrskuXeSOyU5dnwcleSgJN3dd15ehwAAAAAAAAAA83NABEOq6jZJnpzkUUkOW+uxJL2POj+S5AdWDV2R5H9291Xz6BMAAAAAAAAAYJ4GHQypqiOT/FGS/y+j4Eet8eheAyGrnJnkVSvlx++9PskbZ2gTAAAAAAAAAGAhdiy7gUWpqpOSnJXkRzL6nitBjmnHunT3R5K8PbsHTH5sTi0DAAAAAAAAAMzVIIMhVXX3JH+X5CbZPRCS7Fo5ZPWxES8bf/b43e+qqmvP2jMAAAAAAAAAwLwNLhhSVTdL8tYkh2fPQMjFSV6Z5AlJvjPJYzYxxd8kuXLV9bWS3Hez/QIAAAAAAAAALMrOZTewAM9Lcnx2D4RcmeTXk7ygu7+68mBV3XOjxbv7kqo6PaNgyYoHJHnHZhsGAAAAAAAAAFiEQQVDqup+Sb4/u4dCLkzykO5+/xynOiOjYMjKPHebY20AAAAAAAAAgLkY2lYyP7nqvJJcneThcw6FJMlZE/Pcds71AQAAAAAAAABmNphgSFXtSHJyRqt41Pjz1O4+fQHTnT1xfcOquvYC5gEAAAAAAAAA2LTBBEOS3D3JMRNjL1zQXOdPXFeS4xY0FwAAAAAAAADApgwpGHLjieuvdPcHFzTXRVPGjljQXAAAAAAAAAAAmzKkYMj1Jq4/u8C5Lp8ydtgC5wMAAAAAAAAA2LAhBUOOXnXeSS5e4FxHTRm7YoHzAQAAAAAAAABs2JCCIZetOq8kxyxwruOmjC0yiAIAAAAAAAAAsGFDCoacO3F9owXOdZeJ62uSfH6B8wEAAAAAAAAAbNiQgiGfmri+blXddkFz3Xdy7u6+akFzAQAAAAAAAABsypCCIWcmuXpi7BHznqSqDknyw0k6oy1rOsn75j0PAAAAAAAAAMCsBhMM6e6vJXlvdoU1KsmTq+rIOU/1mCTXnRj76znPAQAAAAAAAAAws8EEQ8ZeO3F9bJKXzat4Vd0iye9kFDxZcVGSt8xrDgAAAAAAAACAeRlaMOTlSc4dn6+sGvIDVfXSqjpolsJVddMkpyU5YmVoPMdLuvvSWWoDAAAAAAAAACzCoIIh44DGr2QU2kh2hUMem+TdVXXvjdaskUcneX+S22T31ULOS/JbMzUNAAAAAAAAALAgO5fdwAL8SZKHJXlwRiGOlXDItyb5p6o6M8nrk3wgu1b/+IaqukGS45OcmOT+Sb4vyc2yK2yS7Fot5Ce6+6KFfRMAAAAAAAAAgBkMLhjS3V1VP5LkXUnukN3DIZXkrknuMvFarfo8Z417PTH+nO5+47z6BgAAAAAAAACYt0FtJbOiuy9I8oAkp2f3YMdKuKNWHZNq4lj93sr93+7uX5574wAAAAAAAAAAczTIYEiSdPe5SR6Y5Neza8WQZFfQYzLwkX3crySXJPnR7v6FBbUNAAAAAAAAADA3gw2GJKNtZbr715LcMcnLk1yZPVcK2VtQZOXZK5K8NMltuvs1i+0aAAAAAAAAAGA+di67ga3Q3R9O8tiq+oUkD09yvyTfluT6e3ntgiTvS3Jakv/T3ectvFEAAAAAAAAAgDk6IIIhK7r7v5P80fhIVR2b5LgkxyY5OslVSS5Ocs74WQAAAAAAAACA/dYBFQyZ1N3nJzl/2X0AAAAAAAAAACzCjmU3AAAAAAAAAADAYgxmxZCqumuSx08Mv62737SMfgAAAAAAAAAAlm0wwZAk90ryk0l61dirl9QLAAAAAAAAAMDSDWkrmaNXnVeSC7r73ctqBgAAAAAAAABg2YYUDLl64vqcpXQBAAAAAAAAALBNDCkYcsmq805y3rIaAQAAAAAAAADYDoYUDPn0qvNKctyyGgEAAAAAAAAA2A6GFAw5a+L6RkvpAgAAAAAAAABgmxhMMKS7P5/k7FVDx1bV3ZfVDwAAAAAAAADAsg0mGDL28oy2kenx9WOX1woAAAAAAAAAwHINLRjyx0m+OD6vJI+vqm9ZYj8AAAAAAAAAAEszqGBId381yY9ntGJIJ9mZ5K1VdYulNgYAAAAAAAAAsASDCoYkSXf/dZInr1wmOSHJB6rqccvrCgAAAAAAAABg6w0uGJIk3f1HSR6e5PyMwiFHJXlJVX26qn61qu5XVYcvtUkAAAAAAAAAgAXbuewG5qmqzp4YuipJZRQOqSQnJvmV8dFVdUmSi5J8fYZpu7tvP8P7AAAAAAAAAAALMahgSJLbZlcIJOPzTJzXqs+jxscset+PAAAAAAAAAABsvaEFQ1ashENWh0BWxucZ5Kh9PwIAAAAAAAAAsBxDDYYkVvIAAAAAAAAAAA5wQwyGWMUDAAAAAAAAACDDC4Z887IbAAAAAAAAAADYLgYVDOnujy67BwAAAAAAAACA7WLHshsAAAAAAAAAAGAxBEMAAAAAAAAAAAZKMAQAAAAAAAAAYKB2LruBeamq70jyCxPDr+ruVy6hHQAAAAAAAACApRtMMCTJHZM8KEknqfHnU5faEQAAAAAAAADAEg1pK5kjJ66/3N3/sZROAAAAAAAAAAC2gSEFQ66cuP6vpXQBAAAAAAAAALBNDCkYcuGq805y8bIaAQAAAAAAAADYDoYUDPnUqvNKct1lNQIAAAAAAAAAsB0MKRhyZkYrhay4SVUN6fsBAAAAAAAAAGzIYIIT3X1ekn9ZNXREkvsuqR0AAAAAAAAAgKUbTDBk7E8z2kZmZeWQn1liLwAAAAAAAAAASzW0YMgrknx0fF5JfrCqTl5iPwAAAAAAAAAASzOoYEh3X5nk0Ukuz2jVkEryuqq6z1IbAwAAAAAAAABYgkEFQ5Kku89I8kNJLhsPHZ7knVX1W1V15PI6AwAAAAAAAADYWoMLhiRJd5+W5NuSfGQ8tDPJ/0ryxao6taoeW1V3rqrjqmrn0hoFAAAAAAAAAFigQYUiquqKyaHx58q2MocmeeT4WP3e1TNM2919yAzvAwAAAAAAAAAsxKCCIdn79+nxZ025N8vPoff9CAAAAAAAAADA1htaMCTZM6hR2X3lkHkGOaaFTAAAAAAAAAAAtoUhBkMmWdEDAAAAAAAAADggDTEYYhUPAAAAAAAAAIAMLxhy8LIbAAAAAAAAAADYLgYVDOnuq5fdAwAAAAAAAADAdrFj2Q0AAAAAAAAAALAYgiEAAAAAAAAAAAMlGAIAAAAAAAAAMFCCIQAAAAAAAAAAAyUYAgAAAAAAAAAwUIIhAAAAAAAAAAADtXPZDWylqjo4yd2SnDQ+bpLkmPFxWJKLkpyf5IIkZyd5b5L3dvdHl9IwAAAAAAAAAMAMDohgSFXdMMkTkzwhyXGrb008emiSE5J0knsnefz4/f9I8sIkr+7uyxbeMAAAAAAAAADAHAx6K5mqOqiqnpPk00meleT4jMIgK0cyCoGsPjLxTCW5Y5KXJPlsVX3/ln0BAAAAAAAAAIAZDDYYUlW3SPK+JM/MaGWUyp4hkJ7y6lrPVJLrJnlDVb20qg5Z6BcAAAAAAAAAAJjRIIMhVXXrJP+Y5K7ZPRCy22PrOFasDolUkscmeUtVXWtx3wIAAAAAAAAAYDY7l93AvFXVkUnekuT62TMQshL2OCfJ+5OcmeQLSS5KcmmSI5IcleQWSe6S5F7j66yqsxIOeWCSP84oJAIAAAAAAAAAsO0MLhiS5HeS3Cp7BkI6yWuT/HF3/9N6Co23i3lYkp/NKCQyGQ55dFW9sbvfMqfeAQAAAAAAAADmZlBbyVTVrZI8IXuGQj6R5Nu6+5T1hkKSpLsv7+6/7O57j+teuvr2uPZvz945AAAAAAAAAMD8DSoYkuSns+s7rWwb88Ek9+3u98xSuLv/LMl3Jbl44tZtq+q7ZqkNAAAAAAAAALAIQwuGPCK7rxby1SQP6+4vz6N4d/9zkidmV+hkxQ/Noz4AAAAAAAAAwDwNJhhSVbdMcv2Vy4wCIr/V3Z+b5zzd/dok/7hqjkpyv3nOAQAAAAAAAAAwD4MJhiS5w8R1Jzl1QXO9YuL6ZlV16ILmAgAAAAAAAADYlCEFQ248cf3Z7v78gub6pyljN1rQXAAAAAAAAAAAmzKkYMjhq847yaJCIUnyhX3MDwAAAAAAAACwdEMKhvTE9UELnGuRtQEAAAAAAAAA5mJIwZBLVp1XkhsscK5ptS+ZMgYAAAAAAAAAsDRDCoZ8buL6JlV18wXNdf+J605yzoLmAgAAAAAAAADYlCEFQ86aMvboBc01WfcT3X35guYCAAAAAAAAANiUwQRDuvuzST67cpnRdjLPqKpbzXOeqnpsknuumqOTnD7POQAAAAAAAAAA5mEwwZCx12UU1lhx7SRvrqobzaN4VT0oyQszCoOs9hfzqA8AAAAAAAAAME9DC4b8YZIrx+c9Pm6T5D1V9ZDNFq2qg6rqqUnekuQ6K8Pj+md19+mb7hgAAAAAAAAAYEEGFQzp7s8leVF2XzWkk9woyWlV9daqelhVHbyeelV1bFU9MclZSX4vySHZc7WQp83eOQAAAAAAAADA/O1cdgML8MtJHpTkjqvGOqOwyMnj42tV9cEkZyb5YpKLk1ya5IgkRya5eZK7JLldRj+jWlVndc0Xdfc/LOybAAAAAAAAAADMYHDBkO6+tKq+L8npSW6aXWGOlXBIkhye5D7jYy01cd0T996Q5KkztgsAAAAAAAAAsDCD2kpmxXhLmfskeWf23FZm5ah9HJPPZzzeGW0r88Pdfc1CvwgAAAAAAAAAwAwGt2LIiu7+YpIHVtXTk/xqksOy51Yw67USFPlUksd197vm0yUA+4srr7wy55133rLbAAAAkpx77rlzeQYAANgaxx13XA4++OBltwEHrMEGQ1Z09+9X1UuTPC7JTyW5xbTHxp+T28eseGeSFyV5s1VCAA5M5513Xp7//Ocvuw0AAGCdTj311GW3AAAAjD3lKU/JCSecsOw24IA1+GBIknT3RUmel+R5VXWLJCcluVeSE5McMz4OTXJxkgvGx9lJ3pvkvd19/jL6BgAAAAAAAACYxQERDFmtuz+Z5JNJXrXsXgAAAAAAAAAAFmnHshsAAAAAAAAAAGAxDrgVQ1hbVd0uyR2S3CDJ4UkuS/KVJB9OcmZ3X7nE9jatqo5Icqckt0pybJLrZPTdLklyTkYryHy8u69ZYA83SnLnJDdLcmSSq5NcmORjSf5tvN0RAAAAAAAAAMyVYMgBrqpunOTJSR6ZUSBkLZdU1ZuTvLC7z9iS5mZQVUclOSWj73XP7PvP+ler6gNJ/j7JWzMKwvSMPRye5HFJHp9R4GYtV1XVu5L8/0neMOu8AAAAAAAAALDCVjIHqKraUVW/kOSjSZ6evYdCkuSIjIIW76+qV46DF9tOVR1cVc9M8pkkL05yn6wvAHV4ku9I8htJ/jXJiTP28f1JPpLkD7L3UEjG/T0wyV8leW9VffMscwMAAAAAAADAiv1uxZCqul6SgyaGr+jucxc03yFJjpty6/zuvmwRcy5aVR2a5HVJvmeTJR6V5F5VdXJ3f3p+nc2mqm6Z5C+T3HXJffxKkl9LUpt4/Z4ZhW9+uLv/5v+xd+dRtl5lnfi/T3ITEgJkMGBkFiHKZEBACKDMQ5jVgCKNiAgqKK3+QERaQQRssJla6W5FgUbQRkDCJMo8CCFMUWaQIQgBAgGSkJBAhuf3xznFrXvuW/eeqnOqTtW5n89a76rz7v3uvZ/zprJYK/Vl77kWBgAAAAAAAMABZ0cFQ6rqlkneM9HcSR6YUdBhMxyU5JQkN5tof2WSB2zSmpumqg7OqPaT1njk4iQfT3J2RruE3CCj3TQmXS/JW6vq1t39lc2odT3GvxuvS3LsPh77epKzxj8PS3JUkuskudwc6/iDJH+8Rncn+WySLyY5JKN3+IMDz10xyauq6u7d/fZ51QZsvuNvc5ccdoUrLboMAABYepddemm+d+EF+3zm0MOPyEEHT/5/iwAAgHm76Pzz8ul3v2nRZQD7sKOCIUmekT13YegkT+3uzQqFpLsvrKr7JPn3JFde1fVzVXXz7v7AZq29SZ6c4VDIORkFGl7Y3eeuNFbVIUnuk+RpSY6fGHPtJH9fVXfq7ks3p9z9q6obJ/nnjIIekz6W5K+TvHpod5Oq2pXk+knumOReGR0ns6F/L6rqrkmeMtB1WZK/SPKs7v7CxJhbZfTe7zox5nJJXlZVN+3uL2+kHmDrHXaFK+XyRx6z6DIAAOAAceX9PwIAAADkoEUXMK2quleSn8ooDLJyvSejIzs2VXd/NclDV27HVyV5+mavPU9VdUKSxw10fT7Jzbr7OatDIUnS3Rd39yszOp7lXwbG3i7Jr8+92ClV1dEZ7RQyGQq5IMlvJ7nJ+HsNHnnT3Zd090e6+7ndfZeMwi5PTnLhOuu4fJLnZ+/jYy5Kcq/u/q+ToZDx+u/t7rtlOFBylSTPXU8dAAAAAAAAALDajgmGJHnUqs+V5NIkv9bdvRWLd/c/ZXRczeo//N++qm60FevPyTOTTO6hekGSe3T35/Y1sLsvSPKzGe3AMenJVTV03MxW+Msk15xoOz/J3cdhj0vWM1l3n9ndT+zus9ZZx+8O1JEkj+juN0yx7h8meeFA18lVdet11gIAAAAAAAAASXZIMKSqrpLkztm9U0dndOTJx7e4lMcmmQwa/NIW17AhVXXzJHca6PqT7v7kNHN093eSPHyg65gkj5ihvA0ZH91y/4nmTnLf7v7XLazj8CSPHuj65+7+23VM9TtJvjbQ/vsbKgwAAAAAAACAA96OCIYkeWD23Omikzxjq4vo7v9M8rLsDqdUkgdV1eTxIdvRUHDjG0n+fD2TdPepGT5SZigwstmGfgde0N1v3eI6fibDBxs/aT2TjI/xefZA1z2r6qobqAsAAAAAAACAA9xOCYbcddXnTvKu7v7sgmr564n745LcZBGFTKuqdiU5eaDrpeNdQNbr+QNtP1ZVP7GBuTakqu6W5ISJ5u8kedxW1bDKAwfaPtzdp21grhdkdEzSagcl+YUNzAUAAAAAAADAAW6nBENunt07dCTJyxdYyzuTnDXRdotFFLIOt0py9ED7Kzc43+uTXDjQftIG59uIoR1QTunub2xhDamqQ5PccaBrQ++2u7+W5F0DXVv5bgEAAAAAAABYEts+GFJV18zex3S8bRG1JEl3d0bhkNXHx2z3YMgdBtq+k+TUjUzW3Rclec9A11BAYu6q6opJ7jHQ9dKtWH/CLZNcfqD9LTPMOTT2tlV1yAxzAgAAAAAAAHAA2vbBkCQ3mLi/qLs/sZBKdvvQ+GePf95wUYVMaSi4cnp3XzzDnO8baNuqo2TukOSwibZLk7x1i9ZfbejdXpLkgzPMOfRuD8v2/z0DAAAAAAAAYJvZCcGQySNQPreQKvb0mVWfK8kxiypkSj8+0PbRGef88EDbUVV1rRnnncbtB9o+Pd7JZC9VdbmqOr6qbjb+eXRV1dCzGzD0bj+7Vi1TGnq3SXLCDHMCAAAAAAAAcADategCprA6GNJJvrWoQlb55sT9ZHhl26iqQ5NcY6DrMwNt6/HZNdqvk+QLM869P0M7k/z76puqOjbJryb5uSQ3TXLwxPMXVtW/JnlTkv/X3V/cYC0/MtA207vt7q9W1QVJjglXuhsAACAASURBVJjous4s8wIAAAAAAABw4NkJwZAjJ+4vXEgVe5rcDeKohVQxnWtkeGeYM2ecd63x155x3mkMHalyRpJU1cFJHpvkv2XvYMVqhye5y/h6SlX9VZKndPdZ66zl2gNts77bJPlykutNsdZcVdWJM05xo7kUAgAAAAAAAMBc7IRgyGUT94ctpIo9TdYwWeN2cuU12tcbgJh2/FrrzUVVHZ7k2IGub1fVFZO8Ksmd1jntoUl+M8nPVtX9uvv96xg79H1nfbdJ8tXsHQzZ1Hc79p4tWAMAAAAAAACALTK0k8R2851VnyvJMYsqZJXJGr4z+NT2sNb7OneWSbv70iQXDHT9wCzzTuGH1mj/XpJ/yvpDIatdNck7ququ0zxcVZdPcrmBrpne7dh5A22b/W4BAAAAAAAAWDI7IRjy9Yn7ay2kij398MT9ZI3byRXWaD9/DnMPBUP2dXzLPBy9RvtvJ7ntRNsnkzwmyQkZBWQOz+j35+eS/H2Gd3o5PMnfV9U0v2fL9m4BAAAAAAAAWDI7IRhyxsT9EVX1o4soZJWbrfrcSb6wqEKmcMga7ZfMYe6LB9oOncO8+zK0Q0eSXG3V507y35LcuLuf2d0f7u5vdfdF3f2f3f2P3f2LSW6RvX+/klGI5O+mqGXZ3i0AAAAAAAAAS2bXoguYwqcy+kP/ancct2+5qqokt8+ophr//PgiapnSwWu0XzqHuYfm2OzfqWnm/43u/sv9PdTdH6qq2yZ5d/beiebWVXXX7n7jPqZYtnebJLeecfyNkvzVPAoBAAAAAAAAYHbbPhjS3d+qqv9Icr3sDog8MMn/XlBJd0jyg9kzrHLagmqZxlq7V8zjn/3QHEM7XczT/uZ/+TShkBXdfWZVPSTJ2zIK+qz2+0n2FQxZtneb7j51lvGj3BQAAAAAAAAA28VOOEomSd6S3X+0ryS3qaqb7eP5zfT/Tdx3RqGC7eq7a7TP41iSoTnWWm9evrePvk7yhPVO2N3vSPLPA123q6qj9jF02d4tAAAAAAAAAEtmpwRDXjlxX0mevdVFVNVdk5yUPY+ReU93n7XVtazDt9dov+Ic5h6a47w5zLsv5+yj7+3d/R8bnHfo+JODkvzUPsYs27sFAAAAAAAAYMnslGDI25J8bvx55QiX21TV47eqgKq6SpK/yZ5HyGTctp19Y432fe2EsV9VdViSy61jvXk5ex9975xh3rXG3mqtAd39vSTnD3TN9G73Mcdmv1sAAAAAAAAAlsyOCIZ0d2e0Q8jKcTIrO3b8SVU9ZLPXHx8n8k9JrjbR9eUkL93s9Wf01TXaj5tx3rXGr7XeXHT3uUkuWKP732aY95tJvjjQdZX9DB36vrO+27Xm2NR3CwAAAAAAAMDy2RHBkLG/TPLpVfedUf1/U1V/VlWHbsaiVXWrJKcl+Yns3i1k5RiZJ3T3JZux7hx9Ocl3B9qvOeO8a43//IzzTuNza7R/c8Z5h3bk+IH9jBn6vjO926o6OMlVp1wLAAAAAAAAANa0Y4Ih4wDGI7PnUS4r4ZDfTfKhqvrpea1XVUdW1Z9mdMTIdVd3jdd9W3e/eF7rbZbxbiufHeg6fsapr7dG+2dmnHcan1ij/Tszzju0E8kV9jPmPwbaZn23105yyJRrAQAAAAAAAMCadkwwJEm6+61JnprdR8oku4+VuUGSt1XVh6vqkVV17Hrnr6qDqurEqnpBkjOT/F6SXavWWXFWkgdt5DssyOkDbSfMOOdNB9q+1N1nzzjvND6wRvuVZpz3yIG2/e1CMvRur15Vx8xQx9C7TWY4KgcAAAAAAACAA9Ou/T+yvXT3E6vqWkl+KbvDGivhkEpyoyR/nuTPq+oLSd6f0R/vz05ybpJzMjpa5cjxdVSSH07ykxn9Qf7w8Zy1au6sajsnyUndfdZmfL9Nclr2DrLcoKqO7O5zNzjniWussxXevUb7VWacd2j8/oIua33nWyd53QbrGHq3Z2ftI3QAAAAAAAAAYNCOC4aM/UqS7yX51ewZDkl2B0SS0ZEc10py8pTzTu5EMtn3tST36u5/X2e9i/bmgbaDk9w5ySvXO1lVXSXDu1oMrbMZTssooHPURPvNk/y/jUxYVdfMcDDkjP0M/WhGO8j84ET73bLxYMjdBtreMj4WCAAAAAAAAACmtqOOklnR3Zd19yOS/E5GAZHJQMfqq9ZxrR63WiV5X5Jbdvdax5hsW939iSSfHej6+Q1O+YDs+c6T0TvbaBBiXbr70iSnDHTddYZp1xr7tv3Ustb3PrmqDl5vEVV1oyQ3HOh6zXrnAgAAAAAAAIAdGQxZ0d3PzWiXiH/NnjuF7PHYOq5JleT8JI9Pcuvu/sKcv8JWeslA2/2q6hrrmaSqKsmjBrre3t1f2lBlG/OCgbYbV9VtNzjfIwfavpnRMUT7M/Ruj0ty/w3U8ZsDbecnefUG5gIAAAAAAADgALejgyFJ0t0f6+6fTnKvJG8dN68VEpnGytizkzw9yY9099O7+7KZi12sv8pod5XVDknylHXO89AkPzbQ/hfTTlBVZ1RVT1xnrKeI7n5XRru4THp2Va3riKSq+tUMH43zgin/ub8joyNlJj25qg5dRx0/mtExSZNe2N0XTDsPAAAAAAAAAKzY8cGQFd39T9195yTXTfKYJG/JaKeFaY+RSUbHrTw/yX2SXL27H9/dZ2/l99gs3f3lDO+y8UtVNdXOFlV1fJJnDXR9NMNHu2y2Jwy03TzJ88Y7m+xXVd0mybMHur6T5BnTzDE+TmYoYHO9DL+voToun+SlGYV1Vrsoyf+YZg4AAAAAAAAAmLSunRV2gu7+fEZ/jH9WklTVdZNcJ8nVkxyd5PCMvvdFSS5I8tUkX0zy8e4+bxE1b6E/TPKAJMdMtP9tVe3q7r9fa2BV3TTJa5IcOdD96EXsqNLdb66qlyZ50ETXI5Jcpap+a63jbarqoCQPz+j35PIDj/xxd399HbW8rKp+I8ntJroeVVXfTfK47r5kjVqOTfLyJDcb6H56d//ntHUAAAAAAAAAwGpLFwyZ1N2fSfKZRdexHXT32VX1sCSvmui6XJK/q6oHJ/nLJO/N6CidKyY5IaPgxS9n790skuTZ3f22TSt6/34jo0DF5PE290tyt6p6XZI3ZhT+uSjJlTPaVeRnM9rRY8jLu3uq3UIm/HKS05McNdH+u0nuXlXPzmgnmy9l9C6vl+S+Sf5r9g7rJMlpSZ66gToAAAAAAAAAIMkBEAxhT919SlX9QZKnDXSfNL6m9bokj5tLYRvU3d+uqrsleVtGO8OsdniS+4+vaf1zkodusJYzqurnkrw+yWET3TfI6JiiaX0uyc9198UbqQUAAAAAAAAAkuSgRRfA1uvuP03yO0kunWGalyQ5eTsEF8ZHrZyY5K2zTJPkfyS5Z3dfMEMtb80oXHP2DLV8KMntu/vMGeYAAAAAAAAAAMGQA1V3PyfJbZJ8cJ1Dv5Lkwd394O7+7vwr25ju/lqSO2e028fn1jn8NUlu1t2P7e7L5lDL25PcJMk/ZBQ4mdZFSZ6S5Dbd/cVZ6wAAAAAAAAAAR8kcwLr7tCQ3r6o7J/kvGQUrrjbw6DlJ3pXkFUleNmsgpLuvPcv4fczbSV5UVS9OcseMdu74ySTXTXJUkoOTfCPJ15N8Osmbk7yxu9cbJJmmljOT/HxVPSnJw5LcPcn1s3cY67tJ3p9ROOWF3T3LTiMAAAAAAAAAsIcDOhhSVT+c5PGrmrq7f21R9SxKd785o5BEquqoJFdNckRGO1ic3d1fWWB56zbe9eP732nBtXwiyWOSPKaqDktyzSRXzOgYn3OSfLG7ZznSBwAAAAAAAADWdEAHQ5JcJcmvZnTcR41/HnDBkNW6+5yMAgvMWXdflNFOJQAAAAAAAACwJSaPtQAAAAAAAAAAYEkIhgAAAAAAAAAALCnBEAAAAAAAAACAJSUYAgAAAAAAAACwpARDAAAAAAAAAACWlGAIAAAAAAAAAMCSEgwBAAAAAAAAAFhSgiEAAAAAAAAAAEtKMAQAAAAAAAAAYEkJhgAAAAAAAAAALCnBEAAAAAAAAACAJSUYAgAAAAAAAACwpARDRmrRBQAAAAAAAAAAzNuuRRewSN19WlUdsug6AAAAAAAAAAA2wwEdDEmS7r500TUAAAAAAAAAAGwGR8kAAAAAAAAAACwpwRAAAAAAAAAAgCUlGAIAAAAAAAAAsKR2LbqA7aqqjkty2yTHJTk4yZlJPtjdn19oYQAAAAAAAAAAUxIMmVBVN0nyZ0nuuEb/qUke292nbmlhAAAAAAAAAADrtFRHyVTVoVX14ar69KrruesYf3KS92QUCqk1rlsneWdVPX7+3wAAAAAAAAAAYH6WbceQuyW5UZLOKMTRSV49zcDxTiF/m+Ry46bex+MHJ3lKVZ3X3c/beLkAAAAAAAAAAJtnqXYMSXLvifvPdvdbpxz71xmFQjp7hkJW7xayYiV48syqOn6DtQIAAAAAAAAAbKplC4acmD13C3ntNIOq6j5JfiJ7B0IuTvL2JK9Icnr2DIckyaFJnjVTxQAAAAAAAAAAm2RpjpKpqiOSXH+i+Q1TDn/E6qkyCoi8P8nJ3f3FVWvcLsk/JDk2uwMoJ1XVtbr7CxutHQAAAAAAAABgMyzTjiE/kr2/z+n7G1RVxya5a/bcLeT8JPddHQpJku5+R5JfyN47hzxo3dUCAAAAAAAAAGyyZQqGXHvi/mvd/Y0pxt01u3dOWdkt5IXd/dWhh7v7bUnetOrZJLnduqsFAAAAAAAAANhkyxQMOW7ifjDYMeAOA20v2s+YV6z6XElOmHItAAAAAAAAAIAts0zBkCNWfe4k50057nbZ8xiZM7v73/Yz5v0T91euqqOmXA8AAAAAAAAAYEvs2v8jO8bhE/cX7W9AVR2b5LoZBUNWjoZ5yxRrnTHQdlSSc6YYC8AOdMkll+z3mYvOnzaTCAAAAAAAy2Ga/zY+zX9jBzbPMgVDLp64v/wUY2490PauKcZ9e6DtyCnGAbBDnXPO/rN/n373m7agEgAAAAAA2FnOOeecXP3qV190GXDAWqajZFZH0SrJcVOM+emBtmmCIUOBmppiHAAAAAAAAADAllmmYMg3J+6vWVWX28+YkzI6PmbF17v7P6ZY6+iBtgumGAcAAAAAAAAAsGWWKRjy0Yn7XUluv9bDVXX9JNdfuc0oIPKOKdc6dqDt3CnHAgAAAAAAAABsiWUKhnwqyYUTbY/ax/O/OdD2linXuvHE/UXd/bUpxwIAAAAAAAAAbImlCYZ092VJXp/du39UkntW1W9NPltVt0/y8Ox5jMylSV495XI3m7j//HrrBQAAAAAAAADYbLsWXcCcvTjJyePPK+GQ51TVfZK8Lsl5SX4yyUMz+u4rz3SSf+nus6Zc5zbjnytjPzaX6gEAAAAAAAAA5mipgiHd/bqqem+SW640ZRTeuOP4WrES6FjtKdOsUVVXzyhcsjJ3kpy60ZoBAAAAAAAAADbLUgVDxn4tybuTHDG+Xx3gyKq21Z9f2N2nTTn/ydk7WCIYArDkjjrqqP0+c/xt7pLDrnClLagGAAAAAAC2h4vOPy+ffveb9vnMNP+NHdg8SxcM6e6PVNW9k7w2yRUyCnBM7g6yopK8Jckj17HEwyfmOyfJ+zdQKgA7yK5d+/+fzMOucKVc/shjtqAaAAAAAADYOab5b+zA5jlo0QVshu5+R5IbJHlFkksyCoBMXucl+aMkd+/u700zb1XdI8n1V24zCoj8S3dfNtcvAAAAAAAAAAAwB0sbzeruLyV5QFUdleSOSa6R5EoZ7fDxsSTv7u7vrnPamyR5/UTbi2YsFQAAAAAAAABgUyxtMGRFd5+T5B/nNNfT5jEPAAAAAAAAAMBWWMqjZAAAAAAAAAAAEAwBAAAAAAAAAFhagiEAAAAAAAAAAEtKMAQAAAAAAAAAYEntWnQB21VVHZfktkmOS3JwkjOTfLC7P7/QwgAAAAAAAAAApiQYMqGqbpLkz5LccY3+U5M8trtP3dLCAAAAAAAAAADWaamOkqmqQ6vqw1X16VXXc9cx/uQk78koFFJrXLdO8s6qevz8vwEAAAAAAAAAwPws244hd0tyoySdUYijk7x6moHjnUL+Nsnlxk29j8cPTvKUqjqvu5+38XIBAAAAAAAAADbPUu0YkuTeE/ef7e63Tjn2rzMKhXT2DIWs3i1kxUrw5JlVdfwGawUAAAAAAAAA2FTLFgw5MXvuFvLaaQZV1X2S/ET2DoRcnOTtSV6R5PTsGQ5JkkOTPGumigEAAAAAAAAANsnSHCVTVUckuf5E8xumHP6I1VNlFBB5f5KTu/uLq9a4XZJ/SHJsdgdQTqqqa3X3FzZaOwAAAAAAAADAZlimHUN+JHt/n9P3N6iqjk1y1+y5W8j5Se67OhSSJN39jiS/kL13DnnQuqsFAAAAAAAAANhkyxQMufbE/de6+xtTjLtrdu+csrJbyAu7+6tDD3f325K8adWzSXK7dVcLAAAAAAAAALDJlikYctzE/WCwY8AdBtpetJ8xr1j1uZKcMOVaAAAAAAAAAABbZpmCIUes+txJzpty3O2y5zEyZ3b3v+1nzPsn7q9cVUdNuR4AAAAAAAAAwJZYpmDI4RP3F+1vQFUdm+S6K7cZBUTeMsVaZwy0CYYAAAAAAAAAANvKMgVDLp64v/wUY2490PauKcZ9e6DtyCnGAQAAAAAAAABsmWUKhqw+OqaSHDfFmJ8eaJsmGLJroK2mGAcAAAAAAAAAsGWWKRjyzYn7a1bV5fYz5qSMjo9Z8fXu/o8p1jp6oO2CKcYBAAAAAAAAAGyZZQqGfHTifleS26/1cFVdP8n1V24zCoi8Y8q1jh1oO3fKsQAAAAAAAAAAW2KZgiGfSnLhRNuj9vH8bw60vWXKtW48cX9Rd39tyrEAAAAAAAAAAFtiaYIh3X1Zktdn9+4fleSeVfVbk89W1e2TPDx7HiNzaZJXT7nczSbuP7/eegEAAAAAAAAANtuuRRcwZy9OcvL480o45DlVdZ8kr0tyXpKfTPLQjL77yjOd5F+6+6wp17nN+OfK2I/NpXoAAAAAAAAAgDlaqmBId7+uqt6b5JYrTRmFN+44vlasBDpWe8o0a1TV1TMKl6zMnSSnbrRmAAAAAAAAAIDNsjRHyazya0kuWHW/EuBYffVE/wu7+7Qp5z85uwMhKwRDAAAAAAAAAIBtZ+mCId39kST3zigcshLg6IlrRSV5a5JHrmOJh0/McU6S92+0XgAAAAAAAACAzbJ0wZAk6e53JLlBklckuSR77xhSSc5L8kdJ7t7d35tm3qq6R5Lrr9xmFBD5l+6+bK5fAAAAAAAAAABgDnYtuoDN0t1fSvKAqjoqyR2TXCPJlTLa4eNjSd7d3d9d57Q3SfL6ibYXzVgqAAAAAAAAAMCmWNpgyIruPifJP85prqfNYx4AAAAAAAAAgK2wlEfJAAAAAAAAAAAgGAIAAAAAAAAAsLQEQwAAAAAAAAAAlpRgCAAAAAAAAADAktq16AIWqaoOS3L0+DoiyblJvpnknO6+ZJG1AQAAAAAAAADM6oAKhlTVTZPcLcmJSW6V5Nh9PPuZJKeOr1O6+6wtKRIAAAAAAAAAYE6WPhhSVZXk55P8VkZhkO937Wfo9ZJcN8mDkzy3ql6e5Lnd/YFNKRQAAAAAAAAAYM4OWnQBm6mqrpXkHUlemlEopFZdPcW18uyhSX4xyXur6tlVdejWfhMAAAAAAAAAgPVb2mBIVd03yb8luU2GwyDTmAyJHJTk0Uk+MA6dAAAAAAAAAABsW0sZDKmqeyd5eZIjs2cg5PuPrONasTogcqMk76iqq23qFwEAAAAAAAAAmMGuRRcwb1V1vYyOjtmVvXcGqSTnJzklyXuTnJ7ky0nOTXJhkitmFCb5kSQ3TXKHJHdKcvCquVbCIddM8o9VdWJ3X7aJXwkAAAAAAAAAYEOWLhiS5P8kuUL23iHk60n+W5KXdvd31hj73SRnJ/lskjcmeXpVHZfkd5L8dna/r5VwyM3Hfc+c83cAAAAAAAAAAJjZUh0lU1V3yGiXj5VQyMpxMKckOb67n7+PUMig7v5qdz8uyQkZBUZWjpdZCYf8flVdfh71AwAAAAAAAADM01IFQ5I8YtXnyii88XdJTu7uc2eZuLs/meSnknxqouuYJPefZW4AAAAAAAAAgM2wNMGQqjo4yT2z5xEyn0/y8O6+bB5rdPdZSf5Lksn57jeP+QEAAAAAAAAA5mlpgiFJfjzJFcafV3YL+ePuvnCei3T3B5O8fNUaleTW81wDAAAAAAAAAGAelikY8qMT999N8qpNWuvvJu6PraqjN2ktAAAAAAAAAIANWaZgyA9N3J/R3edv0lofHmg7bpPWAgAAAAAAAADYkGUKhlx+1edO8pVNXOur+1kfAAAAAAAAAGDhlikYcvGqz5XkyE1c64r7WR8AAAAAAAAAYOGWKRjyrYn7a2ziWtccaDtnE9cDAAAAAAAAAFi3ZQqGfG7i/tiqutUmrXXvifuLk3xpk9YCAAAAAAAAANiQZQqGfChJT7Q9at6LVNXhSR46sda/d/dl814LAAAAAAAAAGAWSxMM6e5vJTk9SWUU2qgkv1hV95jzUk9Lcq3x55W13jTnNQAAAAAAAAAAZrY0wZCxl676vBIOeVlV3WUek1fVE5P81+y9M8lL5jE/AAAAAAAAAMA8LVsw5PlJvrnqvpMckeR1VfX0qjpiI5NW1Q9X1WuS/NHq5vH8r+3uT260YAAAAAAAAACAzbJUwZDuPj/J72cU2kh2hzcOSfKYJJ+vqudU1YlVdei+5qqqI6vqPlX1D0k+nuSeq+ZbcVGS353z1wAAAAAAAAAAmItdiy5g3rr7r6vqTkl+PrtDHCvHyhyb5LfG1yVV9ckkX0lyXpILk1wxyZWSXCfJtVZNW6vmWbnvJL/e3Z/bvG8DAAAAAAAAALBxSxcMGXtIRgGPk7JnOCTZHfI4JMmNk9xoYHxN3PdA32O7+29nLxUAAAAAAAAAYHMs1VEyK7r7e0nuneTJSS6d7F51JaOgx+TVA8+tPHtWknt297M2q34AAAAAAAAAgHlYymBIknT3Zd39pCQ/leS92R362OOxNa5JleTiJP83yY27+w2bVDYAAAAAAAAAwNwsbTBkRXef1t23SXKzJC9M8uUM7xKy1s4hH03yxCTX7O6HdvfZW/4lAAAAAAAAAAA2YNeiC9gq3X16koclSVVdPcmtklwrydHj6/Ak5yX51vj6eJLTuvvbCykYAAAAAAAAAGBGB0wwZLXu/lKSVyy6DgAAAAAAAACAzbT0R8kAAAAAAAAAAByolmbHkKo6JsmNJpq/0t3/sYh6AAAAAAAAAAAWbWmCIUnul+T5E20PSSIYAgAAAAAAAAAckJYpGHJsklp1f2GSVyyoFgAAAAAAAACAhTto0QXM0SHjnz3++aXuvmhRxQAAAAAAAAAALNoyBUMuWPW5k5y5qEIAAAAAAAAAALaDZQqGfGXi/vCFVAEAAAAAAAAAsE0sUzDkE6s+V5IfXFQhAAAAAAAAAADbwa5FFzBHH0nyjSTHjO+vVVVX7e4vL7CmHaWqbpDkRkmumuQKSS5K8vWMQjend/fFCywPAAAAAAAAAFinpQmGdHdX1SuTPGJV888m+YsFlbQjVNU1kjw6yS9mFAhZy7er6jVJ/md3v29LituHqrp2ks9vwtQP7e4XrXdQVb09ye3mXMs7uvv2c54TAAAAAAAAgAPIMh0lkyTPSXJJks7oOJknVNUVFlvS9lRVB1XVHyT5VJLHZN+hkCS5YpIHJTmtql5cVUdudo0AAAAAAAAAwGyWKhjS3Z9M8uyMQiGd5CpJXlpVBy+0sG2mqg5P8pokT01y+AameHCS91fVD8+1MAAAAAAAAABgrpYqGDL2B0nemFE4JEnuleS1VbW/HTEOCOOQzCuT3HONRy5O8u9J3pLkfUnOX+O56yV5a1X90NyLBAAAAAAAAADmYteiC5i37r60qu6T5IVJHpjRziF3S/KxqvqrJC/o7k8tssYFe3KSkwbaz0nyx0le2N3nrjRW1SFJ7pPkaUmOnxhz7SR/X1V36u5LN6fcdflqkp+ZcY7PzqOQsUcl+dAM48+bVyEAAAAAAAAAHJiWKhhSVX+06vZTST6W5Ibj+yOTPCbJY6rqrCQfTPKlJOcm+c4s63b3k2cZv1Wq6oQkjxvo+nySO3f35yY7uvviJK+sqn/OaKeRu008crskv57keXMudyO+293vXXQRq3x8m9UDAAAAAAAAwAFmqYIhSZ6U0Q4hk1baVo6XOS7JPea47o4IhiR5ZpKDJ9ouSHKPoVDIat19QVX9bEbHy9xwovvJVfV/u3utY2cAAAAAAAAAgAU4aNEFbJJadWXVz1511ZyuHaGqbp7kTgNdf9Ldn5xmju7+TpKHD3Qdk+QRM5QHAAAAAAAAAGyCZQ2G9MA1zTPrvXaSoeDGN5L8+Xom6e5Tk/zLQNdQYAQAAAAAAAAAWKBlDIbMayeQZdotZFeSkwe6XjreBWS9nj/Q9mNV9RMbmAsAAAAAAAAA2CS7Fl3AnP3xogvYpm6V5OiB9lducL7XJ7kwyeET7Scl+dAG5wQAAAAAAAAA5mypgiHdLRgy7A4Dbd9JcupGJuvui6rqPUnuNNF1xyRP3cicAAAAAAAAAMD8LeNRMuztFgNtp3f3xTPM+b6BNkfJAAAAAAAAAMA2slQ7hrCmHx9o++iMc354oO2oqrpWd39hxrlnVlVHJLlykmMy2h3lW0m+OWMYZqO17BrXcmxGYaxvJvlWd5+/1bUAAAAAAAAAcGARDFlyVXVokmsMdH1mxqk/u0b7dZIsKhhyZFX9TZLbJjl+6IGq+nSSf03yziSv3ORwxiOr6k8y2rHlcgO1fDPJe5K8O8kp3f3JTawFAAAAAAAAgAOQ1SNx0wAAIABJREFUYMjyu0aGjww6c8Z51xp/7RnnncVRSX5lP88cP75+Jclzq+r5SZ7V3V/ZhHruv5/+Y5Lca3w9rarekOTPuvvtm1DLVKrqxBmnuNFcCgEAAAAAAABgLgRDlt+V12g/a8Z51xq/1nrb0ZFJHpPkoVX1sO5+9QJrqST3SHKPqnpeksd090ULqOM9C1gTAAAAAAAAgE0ytJMEy+WYNdrPnWXS7r40yQUDXT8wy7wL8gNJTqmqpyy6kLFHJXlvVe3EdwkAAAAAAADANrKjdgypqkOS/F6Sgye6Ptzdp2zSmsdk9If6muh6S3e/ezPWnLMrrNF+/hzmviDJERNtk/db4TtJ3pnkbUk+luSTSb6V5Lwkl09ydJLrJ7lNkp9Pcr015nlCVX29u587Qy2d5CNJ3pjk9HE9Xx3XcllGQZ2rJTkxyd2SnJThgNYJSV5bVXfq7gtnqAcAAAAAAACAA9iOCoYk+fUkf5LRH99XnJnklpu1YHd/s6oOSvLEiXUfVFU3GO+csZ0dskb7JXOY++KBtkPnMO80LkvypiR/neTV3f3dNZ47b3x9Ick/V9UfJblfkr9IctWB559dVf/e3W9fZz2fS/LmJC/q7i/t47mvjK8PJPnzqrpukmcnudfAsycmeV6SX1lnLQAAAAAAAACQZAcFQ6rqikn+cOV2/POSJL/Q3V/ZzLW7+4+r6lYZ7fCw4rpJfi3J/9rMtedgcneVFfMItAzNsSW/U939n0nuuoFxneRVVfWOJKck+amJRyrJ/6iqW4yfnXbeDYU3uvszSe5dVY9N8oyBRx5SVf+zu/9tI/NvwK1nHH+jJH81j0IAAAAAAAAAmN2OCYYkeXSSYzPataPGP5/R3e/ZovUfktERJUeO7yvJH1bV87t7aOeM7WKtnUHm8c9+aI7t/C6+b7wTzL2TvDvJDSe6b5bk5CQv38J6/qyqjkzyhImug5I8Nck9t6iOU2cZXzV54hIAAAAAAAAAi3TQogtYh4dkz6NcvpTRH8y3RHd/LcmTsnu3kiS5SpJ7b1UNG7TWESvzOPJlaI611tt2uvvcJI9co/vntrKWsScl+dRA+13GO+YAAAAAAAAAwLrsiGBIVd0yo6Nbkt27hTy9uy/c4lL+d5IvT7T90hbXsF7fXqN9HkGDoTnOm8O8W6a735nkHQNdd62qtY7h2axaLkny3we6Dklyl62sBQAAAAAAAIDlsCOCIUl+YeL+3CR/s9VFjI+MeV52h1Mqyd3HR4BsV99Yo/2oWSatqsOSXG4d621nrxtoOzq7w0hb6Z+y5844K26x1YUAAAAAAAAAsPPtlGDIrcc/VwIZr+zuRR1Z8pLs+Yf7Q5LcckG1TOOra7QfN+O8a41fa73t7INrtP/gllaR7x9Z9MXtUAsAAAAAAAAAO9+2D4ZU1SFJTsieYYyhHR62RHd/McmHJ5q3824OX04yFKK55ozzrjX+8zPOuwhfW6P9KltaxW5D9SyqFgAAAAAAAAB2sG0fDEly4ySHTrS9axGFTKy/sntJktx8gbXsU3d3ks8OdB0/49TXW6P9MzPOu51M/t4t0naqBQAAAAAAAIAdYicEQ64xcX92d39zIZXs9vFVnyvJtRZVyJROH2g7YcY5bzrQ9qXuPnvGeRdhrd04ztvSKnYbqmdRtQAAAAAAAACwg+2EYMhRE/dfWEgVe/rPifujF1LF9E4baLtBVR05w5wnTrnOTnCzNdon/zlvuqq6cvYOQy2kFgAAAAAAAAB2vp0QDFkduugk315UIatM1rDdgyFvHmg7OMmdNzJZVV0lwzuGDK2zE9x7oO2iJJ/c6kKS3CujXWgmDe36AgAAAAAAAAD7tBOCIUdM3F+6kCr2dNnE/WSN20p3fyLJZwe6fn6DUz4ge4cXOsnrNjjfwlTVTyf56YGud3X397a4ll1Jfn+gq5O8bStrAQAAAAAAAGA57IRgyEUT99shhDFZw2SN29FLBtruV1VDx5asqaoqyaMGut7e3V/aUGULMj5K53+t0T30vjbbk5IcP9C+494tAAAAAAAAANvDTgiGnL/qcyW52qIKWeWqE/fnDz61vfxVkskdMA5J8pR1zvPQJD820P4X005QVWdUVU9cZ6xj/M9U1UwBoao6Jslrk9xwoPsLSf5+ynluUVU/Okst43kek+QJa3T/91nnBwAAAAAAAODAtBOCIZM7JVy1qg5bSCW7XW/i/syFVLEO3f3lJC8Y6Pqlqrr/NHNU1fFJnjXQ9dEkp8xQ3no9MckXq+ppVfXj6xlYI/dN8uEkP7XGY7/V3RdPOeVtknyiqk6pqnut93ezqn6kql6T5M/WeOSV3f3G9cwJAAAAAAAAACt2LbqAKZwxcX9wkp9M8s6tL+X7Thz/rCSd5PMLrGU9/jDJA5IcM9H+t1W1q7vX3CWjqm6a5DVJjhzofnR3Xza/MqdydJLHJ3l8VX0uyRszCnt8OKMw0XlJvp3ksIy+748luW2SX8jewZ7VntHdr11nLZXkvuPr/Kp6U5IPjGv5dJJzxvVcNq77ahn9Dp00vtYKaH06ya+usxYAAAAAAAAA+L6dEAz5ZJILM/oD/4p7Z0HBkKo6KqNdIjqjQECSnL6IWtaru8+uqocledVE1+WS/F1VPTjJXyZ5b5Kzk1wxyQlJHpTklzM6embSs7v7bZtW9HSuk+TX5zDPs5P8/oxzXCHJz4yvWXwsyd26+5wZ5wEAAAAAAADgALbtj5Lp7ksz2n1hZXeOSvLAqhoKKWyF/5K9AxKnLqKQjejuU5L8wRrdJ2V0JMxXk1yS5FtJ3p7k4RkOhbwuyePmX+WW+2qS+3T373Z3L7iWyzIKqNy8u7f9EUUAAAAAAAAAbG/bPhgyNnm0xw8ledhWF1FVhyV5TEYBlRXnJnnXVtcyi+7+0yS/k+TSGaZ5SZKTu/vi+VS1LqdmdDTLrM5M8uQkN9zA8TErPpPkc3Oo5XtJXpbkxHFA5aI5zAkAAAAAAADAAW4nHCWTJK9I8vTx55VdQ55aVf/Y3V/bwjqemOSaq2roJKd09yVbWMNcdPdzqurUJM9LcrN1DP1Kkt/r7pdsTmX7192/UVW/meQnkpyY5CZJfjzJDyc5Zh9DL0jyoSTvy2gnlDeMd6SZpZbXJXldVV0jyU+Na7pJkuMzCjCt9e9YZ3RM0vsyOrpnq3+XAQAAAAAAADgA7IhgSHefUVWvT3Kv7N6t4+gkr6yqO3X39za7hqq6b5Lfy567hSTJn2/22pulu09LcvOqunNGR+TcOcnVBh49J6NdUV6R5GXd/d0Z1732LOPHc1ya5P3j6/uq6vAkP5jkiCSHZ7QTxzkZ7exy3mYdFdPdX0zyd+NrpZaDxrUcOa7loHEd5yQ5ZycGigAAAAAAAADYWXZEMGTsTzMKhiS7d+y4dZLXVtXJ3f3tzVq4qn4myUtXN41reGN3n75Z626V7n5zkjcnSVUdleSqGQUrLkpydnd/ZYHlrUt3X5jkjEXXkSTdfVlGO6zsmPcHAAAAAAAAwHI5aNEFTKu7T81oN4ZaaRp/vnOSj1TVHee9ZlVdvqr+MqOdMg6b6L44yW/Pe81F6+5zuvvj3f3+7v7ITgqFAAAAAAAAAAB72jHBkLFHJzlz1f1KOOSaSd5YVS+uqlvOukhVXaGqHpnko0l+Nbt3CMmqz3/U3Z+adS0AAAAAAAAAgM2yk46SSXd/s6run+Qt2b2Dx0pg46AkD0ryoKr6cJKXJXlfkg9093n7m7uqfjTJLZLcIcn9MzpKZfXuJFn1+VXd/YwZvw4AAAAAAAAAwKbaUcGQJOnu91bVyUleleSQ1V3ZHeQ4IcmPr7RX1RlJzk5ybpJzknw3yZHj66gk10pypVVzDQVCVtrflOSB8/guAAAAAAAAAACbaccFQ5Kku99QVXdJ8o9JfiC7Axyrj3upVZ+vM74mgx5Z9dweS6zx3EuTPKy7L95g6QAAAAAAAAAAW+agRRewUd39riQ3T/L27B3u6IEr2R0YWX0NPb9aJflOkkd294O7+3tz/SIAAAAAAAAAAJtkxwZDkqS7v9Ddd0zyy0n+M3uGPfZ6fB/XkBr3vTTJjbr7/8yvcgAAAAAAAACAzbejgyEruvvFSY5P8otJ3prksuy9K8j+rH7+rCTPTHL98S4hX5h70QAAAAAAAPD/s3fnUbadZZ2Af+/NzQSBjMwEAjbIEMUwhjEqk4CIYJyQyCQ0gmCDdKs4EgFXoxBRAZWmiUyKgIwuMTKjDEHGBhlMAgiBAGFISEjI9PYfp8pUTnbd3Kpzqk7VrudZ66yq/e39vd97duoPFve3vg8ANtjuRTcwL919cZK/TfK3VXVokvskOTbJMUlumuS6Gf6+30nyxSSfTPKhJO/o7g9uStMAAAAAAAAAABtoNMGQlbr7W0letfRJklTVriTXSHJgJt/7wiTnd/cFC2kSAAAAAAAAAGCDjTIYMqS7L0tyztIHAAAAAAAAAGD0di26AQAAAAAAAAAANoZgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIzU7kU3sJmq6rAkN0ty8NLngCQ1a93ufumsNQAAAAAAAAAA5m30wZCquleSRyS5a5IbbdAygiEAAAAAAAAAwJYz2mBIVd01yYuSfP/y0AYt1RtUFwAAAAAAAABgJrsW3cBGqKrfSPKuTEIhtfTpDfgAAAAAAAAAAGxZo9sxpKoen+RZS5erBTg2avcQAAAAAAAAAIAtY1TBkKq6UZLnZPUwyGVJzkhyWpJzk1ywed0BAAAAAAAAAGyuUQVDkvxekv1zxWBIJfmPJM9O8pruPmcRjQEAAAAAAAAAbLbRBEOqaleSB+fyUEgt/f7SJI/t7osW1RsAAAAAAAAAwCKMJhiS5I5JDskkDLIcCnlPdz9ikU0BAAAAAAAAACzKrkU3MEffNzD2tE3vAgAAAAAAAABgixhTMOSIqetvdPd7F9IJAAAAAAAAAMAWMKZgyNWmrs9YSBcAAAAAAAAAAFvEmIIh5674vZOct6hGAAAAAAAAAAC2gjEFQ05b8XslOXxRjQAAAAAAAAAAbAVjCob8W5LLVlwfVVW1qGYAAAAAAAAAABZtNMGQ7v5GkndnsltIklwzybGL6wgAAAAAAAAAYLFGEwxZctLSz176+SuLagQAAAAAAAAAYNFGFQzp7jclOSWTXUMqyc9W1d0X2xUAAAAAAAAAwGKMKhiy5OFJvpTJriG7kryuqm692JYAAAAAAAAAADbf6IIh3f3VJPdOcubS0GFJ3l9Vj62q0X1fAAAAAAAAAIDVjDIo0d2fSXKnJO9eGrp6khcmOaOqTqyqe1fVDarqwIU1CQAAAAAAAACwwXYvuoF5qqpLB4Z7+XaSGyX5rak5sy7b3T2q9wgAAAAAAAAAjMPYAg2rpTw6VwyIAAAAAAAAAACM3tiCIcnlAZBllcvDID1wfxZCJgAAAAAAAADAljXGYMi0eQZBAAAAAAAAAAC2jTEGQ+ziAQAAAAAAAACQkQVDunvXonsAAAAAAAAAANgqBCkAAAAAAAAAAEZKMAQAAAAAAAAAYKQEQwAAAAAAAAAARkowBAAAAAAAAABgpARDAAAAAAAAAABGSjAEAAAAAAAAAGCkBEMAAAAAAAAAAEZKMAQAAAAAAAAAYKQEQwAAAAAAAAAARmr3ohvYDFVVSe6e5M5Jjk3yfUkOWfpcfQ5LPLG7XzCHOgAAAAAAAAAAczPqYEhVHZTkcUmekORGK2/NcZmeYy0AAAAAAAAAgLkZbTCkqm6X5FVJbpLhIMg8Ah3zDJgAAAAAAAAAAMzVKIMhVfWAJK9Nsm8m4Y09hUCWwx1788z0c3YLAQAAAAAAAAC2rNEFQ6rqFklekWS/TIIby+GNq9rdY7X70zXsEgIAAAAAAAAAbAu7Ft3ABnhxkmvmirt5VJK/T/KgJNfPZCeRrHimkxy7NH7tJLdK8rAkf5nknFwxDHJJkhOT7O7uXUufF2zMVwEAAAAAAAAAWL9RBUOq6rgkd84Vd/j4XpKHdPfx3f2m7j6ruy8dmt/dl3b32d396e5+ZXf/cpIbJnlKku8u1d0nye8keUNVHbDR3wkAAAAAAAAAYL1GFQxJ8isrfq9MghyP7e7Xr7dgd3+3u/8kyW2TfDaXHydz/yR/M0OvAAAAAAAAAAAbamzBkOMyCYMsh0Le3d0vn0fh7v6PJPdK8vkVa/xEVT1pHvUBAAAAAAAAAOZtNMGQqrplkiOmhl84zzW6+8wkj8nlwZNKcmJVXWOe6wAAAAAAAAAAzMNogiFJvn9g7C1rmL/v3jzU3W9LckomoZAkuUaSE9awDgAAAAAAAADAphhTMOSwqesvdPe5a5h/wBqe/buln73080FrmAsAAAAAAAAAsCnGGgzpJF+9iue/N3W9lmDIe1b8XkmOXcNcAAAAAAAAAIBNMaZgyO6p6+9cxfPT96+zhrXOmro+qKquu4b5AAAAAAAAAAAbbkzBkOmgx4FX8fz0MTNHrmGtCwfGDl/DfAAAAAAAAACADTemYMi3VvxeSQ6+iufPWnpu2a3WsNYRA2P7r2E+AAAAAAAAAMCGG1Mw5LSp6+tdxfP/b+lnZxIQuesa1rrDwNi31zAfAAAAAAAAAGDDjSkY8ump68Oqak/hkI9PXV+vqu6+l2v94sDY1/dyLgAAAAAAAADAphhNMKS7z01yxtTwbfYw5ZSBsadXVQ2M/5equneSB2ey08iyz3b3d/aqUQAAAAAAAACATTKaYMiSd2ZyLMyy+672YHefnuTUpeeXj5M5LsnJVXW1oTlV9cAkr145tDT3n2fqGgAAAAAAAABgA+xedANz9o4kj8rlQY8HJnnyHp5/QZI7Lv2+POdhSX6sql6f5FNJzkty/ST3W3p2OQyy7LIkfz6/rwDAdnXheecuugUAANgRLrv00lx0wfl7fGa/A6+eXfvss0kdAQDAzuX/G4etb2zBkDcnuSjJvkvXN6mqY7v7/UMPd/dLq+pxSY7NJOyxHA65VpJfGpiyMhSy/PvJ3f3Z+X0FALarz/6rDaQAAAAAAADYWkZ1lEx3n5PklFx+nEwleepVTHtEkq+uLJPLAyLTn56a+7EkT5ypaQAAAAAAAACADTK2HUOS5GlJ3rDi+tI9Pdzdn62qeyX5xyQ3zOXhj+kQyEqVybE1x3f3hTP0CgAAAAAAAACwYUYXDOnuTyT5xBrnfLKqbpHkt5P89ySH7uHxLyZ5ZpIXd/ceQycAAAAAAAAAAIs0umDIenX3d5M8rap+J8ndk9wuyXWSHJzknCRfTvKeJB/u7j3tJgIAAAAAAAAAsCUIhkxZ2gXknUsfAAAAAAAAAIBta9eiGwAAAAAAAAAAYGMIhgAAAAAAAAAAjJSjZABgLxx++OF58pOfvOg2AACAJGeffXZe9rKX7fGZE044IUccccQmdQQAAOzJ4YcfvugWYEcTDAGAvbDvvvvmute97qLbAAAA9tIRRxzhf8MDAABAHCUDAAAAAAAAADBaO2rHkKr6viR3T3KXJD+Y5LClz8GZhGS6u3fUOwEAAAAAAAAAxmv0IYiqqiQPTvKrSe628tY6aj0uyZNWDF2U5G7dfd5MTQIAAAAAAAAAbIBRB0Oq6uZJXpnkmOWhqUd65eN7UfINSZ6XyXurpfnHJzl5pkYBAAAAAAAAADbArkU3sFGq6mFJPpxJKKRyeZBj5WdNuvsrSV6zolaSPHwe/QIAAAAAAAAAzNsogyFV9ZBMdvG4Wq4YCKlVPmvx8pVLJblbVR08Y8sAAAAAAAAAAHM3umBIVd0hySsy+W4rdwapJB9P8r+S3DnJ9ZIct44l3pbkvBXXu5L88DrbBQAAAAAAAADYMKMLhiR5XpL9c8VAyDeSPLi7f6i7/7i7P9DdX01y0VqLd/dFSd6aK+408qMz9gwAAAAAAAAAMHejCoZU1fFJjs0VQyGfS3JMd79hjkt9aOnn8jq3mWNtAAAAAAAAAIC5GFUwJMnDV/xeSS5Icr/uPnPO63x8ap1bzLk+AAAAAAAAAMDMRhMMqar9MznSpTMJa3SS53X3Zzdguema16qqgzZgHQAAAAAAAACAdRtNMCTJHZMcODX24g1a69sDY4du0FoAAAAAAAAAAOsypmDI9aeuv9jdp2/QWucMjF1zg9YCAAAAAAAAAFiXMQVDrrPi905y5gaudenA2AEbuB4AAAAAAAAAwJrtXnQDc3TQ1PUFG7jWIQNj39vA9TZFVd0qydGZ7L5yUJILk3w9yaeSfKS7L15ge9taVd0wyW2S3CST3WUuzeRIos8m+XB3D+1CAwAAAAAAAAAzGVMwZGUQpJIcsYFrXXtg7FsbuN6GqaojkzwpyUNz5eN4VvpOVb0xyZ9296mb0tweVNVRST63AaUf2d0nz6NQVR2U5NFJfimTwM1qLqmqdyV5YZK/7+6ex/oAAAAAAAAAMKajZM6aur5xVdUGrXWHqetLknx5g9baEFW1q6qeluQzSZ6aPYdCkuQaSX4hyQeq6qVVdfBG97idVdWDknw6yZ9kz6GQZBLQumeS1yR5X1XdcoPbAwAAAAAAAGCHGFMw5LSp62smOWaD1jpu6vpT22mXh6o6MMkbkzwzyYHrKHFCkg9W1U3m2thIVNXvJnldkhusY/qdMgnf3G++XQEAAAAAAACwE40pGPLRJBdOjT1i3otU1SFJfjpJZ3JkTSd577zX2ShVtU+S1yZ5wCqPXJzkY0neluTUJOet8tzNkry9qq439ya3saVdWJ6eyd/GtM4kwPSOJP+S5KurlLlGktdV1Q9vRI8AAAAAAAAA7By7F93AvHT3xVX1tkwCD8uhjUdX1R919xfnuNRTklxtaY1lb5xj/Y12YpKh3Si+nUmg4SXdfc7yYFXtm+Qnkjwryc2n5hyV5G+q6p7dfenGtLsmZyV58Iw1Tl/vxKq6T5JnDNy6LMmfJ3lud39has6xmbz3+0zN2T/Jq6rqmO7eVscUAQAAAAAAALB1jCYYsuTlueJOGAcm+buqukd3Xzxr8aq6S5LfzBVDIWcmOWXW2puhqm6T5NcHbn0uyb26+4zpG0vv7bVV9ZZMdhq579QjxyV5XJLnz7nd9fhed79/EQtX1dWSvChX3inkwiQP6e5/HJq31O99q+oPkvz21O1rJ3leJjvUAAAAAAAAAMCajekomSR5dS7f8WE5vHHHJP9cVYfOUriq7p7JziD7LA8trXFSd182S+1N9Jxc3v+y85PcfygUslJ3n5/kIUk+OXD7xKo6aD4tbltPSXKjgfHHrhYKWam7fyfJSwZuHb8USAIAAAAAAACANRtVMGQpoPGUXL5rw/KRMndP8u9V9Ziq2m8tNavqiKr6o0x2BTkslwdOOslpmRwRsuVV1e2T3HPg1h9096f3pkZ3fzfJYwZuHZbksTO0t61V1YFJnjRw6y3d/bI1lHpykq8NjP/GuhoDAAAAAAAAYMcbVTAkSbr7TUn+KlcOh1wnyV8k+VpVvaKqnpxJYOQKquo+VfXQqvrNqjolyX9mEjbZP5eHQirJxUlOmMcRNZtkKLjxjSR/tpYi3f2+JP80cGsoMLJTPDjJtQbGf38tRbr7nCQnDdx6QFVdfx19AQAAAAAAALDD7V50AxvkiUmOTHK/TMIcKwMd10zyc0ufrBhf/jl97MfKgMnydSf5pe4+db5tb4yq2p3k+IFbr1jaBWStXpTkvlNjt6iq23b3h9dRb7v7+YGxj3f3B9ZR6/8meUaueOTPrkz+Xp+7jnoAAAAAAAAA7GCj2zEkSZZ28XhwJjuE1MpbuXwHkZq6t6ymPtPBkouTPLy7X74hzW+MY5McOjD+2nXW+4ckFwyM32+d9batpaOJfnTg1rrebXd/Lcl7Bm7tuHcLAAAAAAAAwOxGGQxJku6+qLsfn+Rnknw7wwGRlaGPq7pXST6T5K7bLBSSJD8yMPbdJO9bT7HuvjDJewduDQUkxu5OSa42MP62GWoOzb1bVe07Q00AAAAAAAAAdqDRBkOWdfdrktw4yVOTfCnDu4WsFgRZ/nw+ya8m+YHu/reN73ru7jAw9pGlnVXWa+gYndvOUG+7Gnq3lyT50Aw1h97tAUluPUNNAAAAAAAAAHag3YtuYDN093lJnltVz0ty1yT3WPocneSwJPtNTflmkn/PZEeNNyf5l+6e3llkO/nBgbFPzFjz4wNjh1TVjbv7CzPWnllVXT3JtTL57/vdJN9K8s0ZwzBDht7t6Uu7qqzX0LtNktsk+egMdQEAAAAAAADYYXZEMGRZd1+a5N1Ln/+yFCI4JJOdHs7t7gsW0N6GqKr9khw5cOu0GUufvsr4TZMsKhhycFW9OMndktx86IGq+mySf8nkb+C1S6GhWXzfwNhM77a7z6qq85NcferWTWepCwAAAAAAAMDOs6OCIavp7vOTnL/oPjbIkRk+MujMGeuuNv+oGevO4pAkj7qKZ26+9HlUkudV1YuSPLe7v7LONY8aGJv13SbJl5PcbC/WmququvOMJY6eSyMAAAAAAAAAzIVgyPhda5Xxr85Yd7X5q623FR2c5KlJHllVj+7uN6yjxtD3nfXdJslZuXIwZDPe7Xs3YQ0AAAAAAAAANsnQThKMy2GrjJ8zS9GlY3mGdlk5fJa6C3J4ktdX1TPWMqmqrpZk/4FVPRjxAAAgAElEQVRbM73bJecOjG3HdwsAAAAAAADAAtkxZPwOWmX8vDnUPj/J1afGpq83w3eTvDvJO5J8Msmnk3wrk3DF1ZIcmuSWSe6a5Gdz5Z04lv1WVX29u5+3l+tu9Ludtoh3CwAAAAAAAMA2JhgyfvuuMn7JHGpfPDC23xzq7o3Lkvxzkv+T5A3d/b1Vnjt36fOFJG+pqt9N8pNJ/jzJ9QeeP6mqPtbd79yLHsb6bgEAAAAAAAAYCcGQ8dtnlfFL51B7qMam/E11938muc865nWS11XVu5K8Psndpx6pJH9cVXdYenZPxvhu7zLj/KOT/NU8GgEAAAAAAABgdoIh47fa7hXz+G8/VGNop4stp7u/WVUPTPKvSW49dft2SY5P8uqrKDO6d9vd75tlflXNqxUAAAAAAAAA5mBbBEOWjv/Ysrr7xEX3sAerHbEyj2NJhmqstt6W093nVNXjk7xr4PZP5aqDId4tAAAAAAAAAFvatgiGJPn9JFd1rMcibeVgyHdWGb/GHGoP1Th3DnU3TXe/e+lYmeOmbt2nqvbp7j0dC+PdAgAAAAAAALCl7Vp0A2tUW/Cz1X1jlfFDZilaVQck2X8N621lbx4YOzTJf9vTpO6+KMl5A7dmerd7qLEd3y0AAAAAAAAAC7TdgiG9xT7bwVmrjF93xrqrzV9tva3sQ6uMX2cv5g5931nf7Wo1tuO7BQAAAAAAAGCBtlswZDvu2LFoX07yvYHxG81Yd7X5n5ux7iJ8bZXxa+/F3KHvO9O7rap9klx/L9cCAAAAAAAAgFXtXnQDa9SZhEE6yRezfXbtWJju7qo6Pcmtpm7dfMbSN1tl/LQZ624l++3FM/+R5N5TY7O+26OS7LvKWgAAAAAAAACw17ZbMGSly5L8dZKTu/sLi25mi/tIrhwMuc2MNY8ZGPtSd589Y91FWG1nkHP3Yu5HBsZuWFWHdfc319nP0LtNko+usx4AAAAAAAAAO9R2O0omuXyXkBsn+d0kp1fVP1fVQ6vqgAX2tZV9YGDsVlV18Aw177yX62wHt1tl/D/3Yu5q3/ku6+wlGX63Zyc5Y4aaAAAAAAAAAOxA2yUY8oVMjpCpqfHK5Dv8aJKXJflKVb2wqu60yf1tdW8dGNsnyb3WU6yqrp3hXS2G1tkOHjgwdmGST+/F3E8k+erA+H1n6Gdo7tu629FJAAAAAAAAAKzJtgiGdPdNMgkx/E0m/2C/HBLppc/y9cFJHpvkvVX1yar6taUQw47W3Z9KcvrArZ9dZ8mfyZVDOp3kzeustzBVdY8k9xi49Z7uvuiq5i+FNYa+9/FVtc86+jk6ya0Hbr1xrbUAAAAAAAAAYFsEQ5Kku9/e3b+Q5HpJHp/kg7lyQGRlSOSWSZ6d5EtV9YaqetB6/qF+RF4+MPaTVXXkWopUVSV5wsCtd3b3l9bV2YIsHaXzglVuD72v1Qw9e90kP73mppJfGRg7L8kb1lELAAAAAAAAgB1u2wRDlnX3ud39F919pyRHJzkpydezekhkd5IfT/L3Sb5cVX+8tCvDTvNXSaZ3wNg3yTPWWOeRSW4xMP7ne1ugqj5fVT31+fwa5j+4qq6+t8+vUuOwJG/K8O4cX8hkd5q99a5MjpSZdmJV7beGnr4/yaMGbr2ku89fQz8AAAAAAAAAkGQbBkNW6u5/7+5fS3LDJD+VyT/0X5rLjzmZ3kXkWkmenORjVXVqVT1uadeI0evuLyf5vwO3frGq9mpni6q6eZLnDtz6RJLXz9DeWv1eki9W1bOq6gfXMrEmHpTk40nuvspjT+zui/e25tJxMkMBm5tl+H0N9XW1JK/IJKyz0oVJ/nhvewEAAAAAAACAlbZ1MGRZd1/S3a/r7gclOTLJbyT5TPZ81Mztkzw/yVeq6hVVde+FNL+5fifJNwfGX1ZVP7+niVV1TJK3JRkK0jypuy+bQ39rcWiS38wk5HN6Vb2wqn65qu5aVTeuqkOrandVHVRVN6qq+1TViZn8Xbw+yQ1Wqfvs7n7TWpvp7ldlsnPItCdU1XOqavdqc6vqiCT/kOR2A7f/d3f/51r7AQAAAAAAAIBkcszKqHT3V5M8O8mzq+rYJI9O8jNJrrH8yIrHK8kBSX4uyc9V1ZeSnJzk5O7+3KY1vUm6++yqenSS103d2j/JK6vqhCR/meT9Sc7O5J3dJskvJHlErrybRZKc1N3v2LCm985NkzxuDnVOyiRUtF6PSPKRJIdMjT8lyY9V1UmZhGu+lMm7vFmSByX51SSHDdT7QJJnztAPAAAAAAAAADvcKHYMWU13v7+7H5Pkukkemct3dFjtqJkjk/x2ktOq6h1VdUJVHbjJbW+o7n59kqetcvt+meymcVaSS5J8K8k7kzwmw6GQNyf59fl3uenOSvIT3f2UpWNh1qW7P5/JkUYXDty+VZIXJTkjyUVJzk/y0SRPz3Ao5IwkP7WWI20AAAAAAAAAYNqogyHLuvuC7v7r7v6RTHZpeFYmuzbs6aiZe2Sye8hXqurOi+h7o3T3HyZ5cpJLZyjz8iTHLyi48L4k586hzplJTkxy6/UcHzOku9+eScDm7BnKfDjJD3f3mfPoCQAAAAAAAICda0cEQ1bq7jO6+7eTHJXkx5K8OpMdHKZDIlm6vkaSa21+pxuru/8kyV2TfGiNU7+S5ITuPqG7vzf/zq5ad/9yJrts3DGTY1heksn3+OZVTD0/yXuSPCfJA5PcuLt/r7uvat5a+3tnkh9K8ne54tFFV+XCJM9Ictfu/uI8ewIAAAAAAABgZ9q96AYWZenIkFOSnFJVhyZ5aJJHJTkma/vH/G2ruz+Q5PZVda8kD0tyryQ3GHj025kEKl6T5FWzBkK6+6hZ5i/VuDTJB5c+/2Xp6J/rJLl6kgMzCf18O8k5Sc6d5aiYNfZ3ZpKfrarfT/LoTEJIt8yVw1jfy+Q7vDHJS7p7lp1GAAAAAAAAAOAKdmwwZKXu/lZVfSrJp5L8QJJ9FtzSpurutyZ5a5JU1SFJrp9JsOLCJGd391cW2N6adPcFST6/6D6Wdfenkjw1yVOr6oAkN8pkF5pLMwmsfHEp5AIAAAAAAAAAc7ejgyFVdVSSRyR5eCb/YP9ft7JDdg2Z1t3fziSwwJx194VJPrvoPgAAAAAAAADYOXZcMGTpqJHjkzwyyT0yCYHUikc6Vw6FnL853QEAAAAAAAAAzM+OCYZU1V0yCYP8TJKDloeXfq4MgiyPfSHJyUn+urs/vwktAgAAAAAAAADM1aiDIVV1/SS/mMlxMTdbHl7xSE+NXZDk75O8pLvfvhk9AgAAAAAAAABslNEFQ6pq3yQ/mcnuIPdOsivDYZCsGP9Akpck+dvuPncz+gQAAAAAAAAA2GijCYZU1W0zCYP8fJJDl4eXfg6FQc5K8rJMdgf59KY0CQAAAAAAAACwibZ1MKSqjkjysEwCIUcvD694ZDoQcnGSN2eyO8g/dvelm9EnAAAAAAAAAMAibLtgSFXtSvKATMIgD8jkO1zVUTEfzyQM8oruPnsz+gQAAAAAAAAAWLRtEwypqltlEgZ5WJJrLw8v/RwKg3wrySszOSrmw5vSJAAAAAAAAADAFrItgiFVdWqS2y1frrg1HQi5LMkpmewO8vruvmhzOgQAAAAAAAAA2Hq2RTAkye1X/D60O8hpmYRBXtrdZ25aVwAAAAAAAAAAW9h2CYYkVw6EfCfJqzM5KuZfF9MSAAAAAAAAAMDWtZ2CIcsqk5DIaUlunuQPq2rPMzZWd/dxi2wAAAAAAAAAAGDIdguG1IqfPzQ13ld+fMMtal0AAAAAAAAAgKu03YIhK01vE7LZ24YIhAAAAAAAAAAAW9p2C4YIYwAAAAAAAAAA7KXtFAzZ7B1BAAAAAAAAAAC2te0SDHn6ohsAAAAAAAAAANhutkUwpLsFQwAAAAAAAAAA1mjXohsAAAAAAAAAAGBjCIYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACMlGAIAAAAAAAAAMBICYYAAAAAAAAAAIyUYAgAAAAAAAAAwEgJhgAAAAAAAAAAjJRgCAAAAAAAAADASAmGAAAAAAAAAACM1O5FN8DWUVW3SnJ0kusnOSjJhUm+nuRTST7S3RcvsD0AAAAAAAAAYI0EQ3a4qjoyyZOSPDSTQMhqvlNVb0zyp9196qY0N2dVdUCSjye52SqPPLK7T15n7XcmOW59na3qXd39w3OuCQAAAAAAAMAO4iiZHaqqdlXV05J8JslTs+dQSJJcI8kvJPlAVb20qg7e6B43wO9n9VAIAAAAAAAAAIyOYMgOVFUHJnljkmcmOXAdJU5I8sGquslcG9tAVXVMkl9bdB8AAAAAAAAAsJkEQ3aYqtonyWuTPGCVRy5O8rEkb0tyapLzVnnuZkneXlXXm3uTc1ZVu5O8OI5OAgAAAAAAAGCH8Q/lO8+JSe43MP7tJE9P8pLuPmd5sKr2TfITSZ6V5OZTc45K8jdVdc/uvnRj2p2LpyY5ZsX1ZdmcUNQTknx4hvnnzqsRAAAAAAAAAHYmwZAdpKpuk+TXB259Lsm9uvuM6RvdfXGS11bVWzLZaeS+U48cl+RxSZ4/53bnoqpunuT3pob/IsnjN2H5f+/u92/COgAAAAAAAAAwyFEyO8tzkuwzNXZ+kvsPhUJW6u7zkzwkyScHbp9YVQfNp8X5qapK8qIkB6wY/liSkxbTEQAAAAAAAABsLsGQHaKqbp/kngO3/qC7P703Nbr7u0keM3DrsCSPnaG9jfLfk9xjxfVlmfR5yWLaAQAAAAAAAIDNJRiycwwFN76R5M/WUqS735fknwZuDQVGFqaqbpjkf08NP7+7T11EPwAAAAAAAACwCIIhO0BV7U5y/MCtVyztArJWLxoYu0VV3XYdtTbKC5Ncc8X1l5L81oJ6AQAAAAAAAICFEAzZGY5NcujA+GvXWe8fklwwMH6/ddabq6r6uSQ/PjX8K939nUX0AwAAAAAAAACLIhiyM/zIwNh3k7xvPcW6+8Ik7x249aPrqTdPVXV4kj+dGn5dd79hEf0AAAAAAAAAwCIJhuwMdxgY+0h3XzxDzVMHxrbCUTJ/kuRaK66/k+SJC+oFAAAAAAAAABZq96IbYFP84MDYJ2as+fGBsUOq6sbd/YUZa69LVf1YkodNDT+tu89cRD/Lqmp3JmGVIzIJY30zybe6+7xF9gUAAAAAAADA+AmGjFxV7ZfkyIFbp81Y+vRVxm+aZNODIVV1UJK/nBr+QJIXbHYvKzy+qv4gkx1b9p++WVXfzORInn9N8vru/vQm9wcAAAAAAADAyAmGjN+RGT4yaNZdNFabf9SMddfrD5PcaMX1JUke292XLaifJPnpq7h/WJIfX/o8q6r+Mckfdfc7N7qx1VTVnWcscfRcGgEAAAAAAABgLgRDxu9aq4x/dca6q81fbb0NU1V3SfL4qeHndPfQcTdbVSW5f5L7V9Xzkzy1uy9cQB/vXcCaAAAAAAAAAGyQoZ0kGJfDVhk/Z5ai3X1pkvMHbh0+S921qqr9k/yfXPFv+YwkT9/MPubsCUneX1Wb+i4BAAAAAAAAGB87hozfQauMnzeH2ucnufrU2PT1RvvtJLecGnt8d1+wyX0s6yT/L8kpST6S5JNJzkpybpLLMgnq3CDJnZPcN8n9MhzQuk2SN1XVPRf4XQAAAAAAAADY5gRDxm/fVcYvmUPtiwfG9ptD3b1SVT+Q5Nenhl/Z3f+0WT2scEaStyY5ubu/tIfnvrL0+bckf1ZV/y3JSUl+fODZOyd5fpJHzblXAAAAAAAAAHYIwZDx22eV8UvnUHuoxqb8TVXVPklenCsGX76Z5Mmbsf607l5XeKO7T0vywKr6n0mePfDIw6vqT7v7ozM1uPfuMuP8o5P81TwaAQAAAAAAAGB2giHjt9rOIPP4bz9UY2gXkY3wP5LcYWrsf3b31zZp/bnq7j+qqoOT/NbUrV1JnpnkAZvUx/tmmV9V82oFAAAAAAAAgDnYtegG2HDfW2V8Hke+DNVYbb25qf/f3t0HXX6W9QH/XmSXhJCYyBZIIKEkNBEibQjIQKBWxACizKA1ohZwpKGkI5a6lBYHwQJFoxYMUq1KKjAN4tABiZloqyUCQ4cYrIaXOLyUQCrIS7phllcT8nL1j11mlpPf2ezznHOeZ5/7fD4z54/nus/vuq/nZslM2C/3r+rMJK+cKb8nyRtXvfeKvTzJxybqT6qqE7d4FgAAAAAAAAAGIBgyvq/MqS8jaDDV48tL6Ht3Lkty/CE/35rk4u7uLdh7Zbr79iS/PLG0O8mTtngcAAAAAAAAAAYgGDK+m+fUT16kaVUdl+TYDey3FFV1UZInzpQv6e6pmzZ2oj9OMhVwmX1tDgAAAAAAAADcLcGQ8X1+Tv2UBfvOe37efgurqlOTvHqm/NEkl6xqz63W3Tcl+fTE0v23ehYAAAAAAAAAdr5d2z0AK/fZHHjVyuztHg9asO+85z+1YN/DeXLuetPJG5I8sqo20ufUOfWHVNVjJ+rXdfetG9lgQTflrud7vy3cHwAAAAAAAIBBCIYMrru7qm5Ics7M0tkLtj5rTv0TC/Y9nKn0x68usf9LD35mnZHkxiXusxn33Ob9AQAAAAAAANiBvEpmPVw3UTt3wZ7nTdQ+0937FuzL9O0gX97yKQAAAAAAAADY8QRD1sO1E7VzquqkBXqef4T7sAFVdd8kp08s/c1WzwIAAAAAAADAzicYsh7eOVE7JskFm2lWVffL9I0hU/uwMU/L9Ctzpm59AQAAAAAAAIDDEgxZA939kSQ3TCz92CZbPiN3DS90kqs22e+IdPebursW/SQ5Y84Wz5nzzI2r/L2+qap2Jfm5iaVO8q6tmAEAAAAAAACAsQiGrI83T9R+qKqmXlsyV1VVkudPLL27uz+zqcn4ppcnOXui7mwBAAAAAAAA2BTBkPXx+iTfmKntTvKqDfZ5TpKHTtR/40gbVNWNVdUznxs3OMdRoaoeXVXfsYQ+L0ry83OWf3nR/gAAAAAAAACsJ8GQNdHdn03yhomln6yqHz2SHlV1dpJfm1i6PskVC4y3kz0+yUeq6oqqelpVHbeRh6vqIVV1ZZL/OOcrb+/uP114SgAAAAAAAADW0q7tHoAt9bIkz0hyn5n65VW1q7t/f96DVXVekiuTnDSx/ILuvnN5Y+44leTpBz9frar/meR/J/lQko8n2Z/ky0nuTPLtSR6Y5PwkTz34mRfQ+niS5650cgAAAAAAAACGJhiyRrp7X1VdlOQdM0vHJnlLVT07ye8k+fMk+5KcmOTcJM9M8lM58OqZWZd297tWNvTOc0KSHz74WcRfJ3lKd+9ffCQAAAAAAAAA1pVgyJrp7iuq6iVJfmli+Zs3WBypq5K8eCmD8U13Jvn1JC/p7lu2exgAAAAAAAAAdrZ5r7BgYN19SZK9Se5YoM2bk1zY3bctZ6od6xNJPrmEPt9I8tYk53f3C4VCAAAAAAAAAFgGN4asqe5+bVVdk+Q3kzxqA49+Lsm/6+43r2aynaW7r0pyVVWdnuS7kzwyySOSnJ3k1Mz/71gn+WiS9+fAq3v+oLtvWv3EAAAAAAAAAKwTwZA11t3XJvmuqrogybOSXJDkgRNf3Z/kvUneluSt3X3rgvs+eJHnl2B/kldM1D+w2Ybd/ekkbzn4SZJU1T2S3D/JSUnulQM39Hzp4P77u/v2ze4HAAAAAAAAAEdCMIR09zuTvDNJqurkJA9Icu8ktyTZ192f28bxlq679yd5+Rbsc2cO3LAy1PkBAAAAAAAAsHMIhvAtDoYm9m/3HAAAAAAAAADA4u6x3QMAAAAAAAAAALAagiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQQmGAAAAAAAAAAAMSjAEAAAAAAAAAGBQgiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQQmGAAAAAAAAAAAMSjAEAAAAAAAAAGBQgiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQQmGAAAAAAAAAAAMSjAEAAAAAAAAAGBQgiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgULu2ewAAAICtctttt+Xmm2/e7jEAWNC+ffuW8h0Ajn579uzJ7t27t3sMAIAdTTAEAABYGzfffHMuvfTS7R4DgC1w+eWXb/cIACzB3r17c8opp2z3GAAAO5pXyQAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwqF3bPQAAAMBW2bNnT/bu3bvdYwCwoNtvvz379+8/7HdOPvnk7Nrlf/oC2On27Nmz3SMAAOx4/u0YAABYG7t3784pp5yy3WMAsASnnXbado8AAAAAO4JXyQAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQeGSWncAAA40SURBVAmGAAAAAAAAAAAMSjAEAAAAAAAAAGBQgiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGtWu7B+DoUVXnJHl4kgckOSHJLUn+X5KPJLmuu2/bxvF2tKo6Lcm5Sc5I8m1J7kiyP8nHk/xVd39pG8cDAAAAAAAAYFCCIWuuqk5P8oIk/ywHAiHzfKWqrkzyuu5+/5YMt2RVdVySDyU5a85XntPdb1rifickuSjJc3MgcDPP7VX1niS/leQPuruXNQMAAAAAAAAA682rZNZUVd2jql6S5GNJXpTDh0KS5MQkz0xybVX916o6adUzrsDLMz8UslRV9fQkH03y2hw+FJIcCGh9X5K3Jbmmqh624vEAAAAAAAAAWBOCIWuoqu6V5Mokv5jkXpto8ewkf1FVZyx1sBWqqvOS/Jst2usXkrwjyQM38fhjciB889TlTgUAAAAAAADAOhIMWTNVdUyStyf5wTlfuS3JB5NcneT9Sb4653tnJfmzqjp16UMuWVXtSvK72YJXJx28heUVSWpiuZN8Ism7kvyvJF+Y0+bEJO+oqiesYkYAAAAAAAAA1odgyPp5ZZKp2yj2J9mb5L7d/YjuvqC7H5PkPkkuTPLxiWcenOT3D4ZNjmYvSnLeIT/fuYpNqurJSV41sXRnktclOaO7z+ruJ3b3d3f3KUnOT/KnE88cm+StVXV3r/gBAAAAAAAAgLkEQ9ZIVZ2b5MUTS59K8qjufm13f+nQhe6+rbvfnuSRSf5k4tnvSfIvlz7sklTV2Un+/Uz5t1ewz/FJLstdbwq5JcnTuvtfd/f/nX2uu/+8u5+S6UDJ/ZL8+rJnBQAAAAAAAGB9CIasl9ckmb3d42tJfqC7P3m4B7v7a0n+aZK/nlh+ZVWdsJwRl6eqKgfCGscdUv5gkktXsN0Lkzxoov687v7vd/dwd78syRsnli6sqsctOhwAAAAAAAAA60kwZE1U1Xcl+b6Jpf/Q3R89kh7d/fUk/2Ji6T5JnrfAeKtycZJ/csjPd+bAnLcvc5OquleSF0ws/Y/uvnwDrfYmuWmi/nObGgwAAAAAAACAtScYsj6mghs3J/lPG2nS3ddk+pUyU4GRbVNVpyX5lZnyb3b3+1ew3Q8nue9E/eUbaXLwNT5Tt5n8YFU9YBNzAQAAAAAAALDmBEPWQFXtSnLhxNLvHbwFZKMum6g9tKoeuYleq/JbSb7tkJ8/k+TnV7TXT0zUPtTd126i1xuS3DFTu0eSH99ELwAAAAAAAADWnGDIenhskm+fqL99k/3+KMnfTdSfusl+S1VVP57kaTPln+nur6xgr3smeeLE0qbOtrtvSvLeiaWj4mwBAAAAAAAA2FkEQ9bD907Uvp7kms006+5bkrxvYmkqILGlqmpPktfNlN/R3X+4oi0fk+T4ifrVC/ScevYfV9XuBXoCAAAAAAAAsIYEQ9bDoydq13X3bQv0fP9E7Wh4lcxrk9z3kJ+/kuRfrXC/qbO9PclfLtBz6myPS/KdC/QEAAAAAAAAYA0JhqyHfzRRu37Bnh+aqJ1cVX9/wb6bVlXfn+RZM+WXdPffrnDbqbO94eCtKps1dbZJcu4CPQEAAAAAAABYQ4Ihg6uqeyY5fWLpEwu2vmFO/cwF+25KVZ2Q5Hdmytcm+c8r3vohE7WFzra7P5/kaxNL23K2AAAAAAAAAOxcu7Z7AFbu9EwHgBa9RWPe8w9esO9mXZLkQYf8fHuS53X3nSve98ETtWXcUPLZJGcdwV5LVVXnL9ji4UsZBAAAAAAAAIClEAwZ333n1L+wYN95z8/bb2Wq6nFJfnqm/JrunvdKlmWa+n0XPdsk+XzuGgzZirN93xbsAQAAAAAAAMAW8SqZ8d1nTv1LizTt7jsy/bqTPYv03aiqOjbJf8m3/ln+ZJJXbMHexyc5dmJpobM96MsTtS09WwAAAAAAAAB2PsGQ8Z0wp/7VJfSeCobcewl9N+KlSR42U/vp7v67Ldh79LMFAAAAAAAAYIcTDBnf7jn125fQ+7aJ2j2X0PeIVNU/TPLimfJbuvtPtmiEYc8WAAAAAAAAgDHs2u4BWLlj5tTvWELvqR5b8meqqo5J8rv51nDGF5Ps3Yr9DxrxbB+34PMPT/L6ZQwCAAAAAAAAwOIEQ8Y37/aKZfxnP9Vj6qaLVfjZJI+eqf3b7r5pi/ZPBjzb7r5mkeeralmjAAAAAAAAALAEXiUzvlvn1JfxWpKpHvP2W5qqOjPJK2fK70nyxlXvPWO4swUAAAAAAABgLG4MGd9X5tRPXELvqR5fXkLfu3NZkuMP+fnWJBd3d2/B3oca8WwXdfxs4cMf/vB2zAEAAAAAAACwVHP+7vMuf0d6tBEMGd/Nc+onL9K0qo5LcuwG9luKqrooyRNnypd098dWue+U7v5GVX01yQkzSwud7WF6rPRsl+TM2cLFF1+8HXMAAAAAAAAAbIUzk1y93UMcjlfJjO/zc+qnLNh33vPz9ltYVZ2a5NUz5Y8muWRVex6Bqd930bOd12NlZwsAAAAAAADAmNwYMr7P5sCrVmZv93jQgn3nPf+pBfsezpNz15s03pDkkVW1kT6nzqk/pKoeO1G/rrtvnfPMp5L8g5naQmdbVcckecCcvQAAAAAAAADgiAmGDK67u6puSHLOzNLZC7Y+a079Ewv2PZyp9MevLrH/Sw9+Zp2R5MY5z/yfJE+aqS16tg9OsnvOXgAAAAAAAABwxARD1sN1uWsw5NwFe543UftMd+9bsO9Oc91E7bSquk93f3GTPafONkk+sMl+W+mqJM+bqX0yyde3YRYAAADG9/Akr5+pPS/J9dswCwAAAOM7PsmZM7WrtmOQjRAMWQ/XJnnmTO2cqjqpu7+0yZ7nz9ln3cz7nR+Xzf8DYOps9+VAwOKo1t2fS3LZds8BAADAepjzatnru/uarZ4FAACAtXH1dg+wUffY7gHYEu+cqB2T5ILNNKuq+2X6VoupfUZ3fZIvTNSfskDPqWev7u5eoCcAAAAAAAAAa0gwZA1090eS3DCx9GObbPmMJLP/l5zOiq/I6e43dXct+klyxpwtnjPnmRsPM9O83/vCqjpmo79jVT08yXdOLF250V4AAAAAAAAAIBiyPt48Ufuhqjp9I03qwB2tz59Yend3f2ZTk+18U2d7SpIf3USvn5mofTXJH26iFwAAAAAAAABrTjBkfbw+yTdmaruTvGqDfZ6T5KET9d840gZVdWNV9cznxg3OcTR5Tw68UmbWK6vqnkfapKq+I8k/n1h6Y3d/bbPDAQAAAAAAALC+BEPWRHd/NskbJpZ+sqqO6GaLqjo7ya9NLF2f5IoFxtvRDr5OZipgc1amz+suqur4JL+XA2GdQ92S5NULDQgAAAAAAADA2hIMWS8vS/LFifrlVfUTh3uwqs5LcnWSkyaWX9Dddy5hvh2ru9+aAzeHzHp+Vb2mqnbNe7aq/l6SP0ryqInlX+nuv1nSmAAAAAAAAACsGcGQNdLd+5JcNLF0bJK3VNUfV9XTq+r+VXVMVZ1cVd9TVa9Pcm2S0yaevbS737XKuXeQn0qyf6L+wiQfrKrnVtUZVbW7qo6vqnOr6heSfCzJEyaeuzbJL65sWgAAAAAAAACGN/cWA8bU3VdU1UuS/NLE8lMPfo7UVUlevJTBBtDdN1bVj+TA7R/HzSyfk+SyDbT7ZJIf6e7bljUfAAAAAAAAAOvHjSFrqLsvSbI3yR0LtHlzkgsFF75Vd/9ZDoRr9i3Q5q+SPKG7/3Y5UwEAAAAAAACwrgRD1lR3vzbJ45P85QYf/VySZ3f3s7v71uVPtvN197uTPCLJf0vSG3j0liSvSvL47v70CkYDAAAAAAAAYM1U90b+3poRVdUFSZ6V5IIkD5z4yv4k703ytiRv3emBkKo6OcnPTixd0d0fWPJeD0tyUZLvT/Kw3DWMdWuSv0hyZZI3dvciN40AAADAWqmq85O8b6b8uO6+ZjvmAQAAgKORYAjf4mBo4gFJ7p0DN1js6+7Pbe9UY6iq45I8KMmJOfAan/1JPt3di7zSBwAAANaWYAgAAADcvV3bPQBHl+7enwOBBZasu29J8vHtngMAAAAAAACA9TH7WgsAAAAAAAAAAAYhGAIAAAAAAAAAMKjq7u2eAQAAAAAAAACAFXBjCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQQmGAAAAAAAAAAAMSjAEAAAAAAAAAGBQgiEAAAAAAAAAAIMSDAEAAAAAAAAAGJRgCAAAAAAAAADAoARDAAAAAAAAAAAGJRgCAAAAAAAAADAowRAAAAAAAAAAgEEJhgAAAAAAAAAADEowBAAAAAAAAABgUIIhAAAAAAAAAACDEgwBAAAAAAAAABiUYAgAAAAAAAAAwKAEQwAAAAAAAAAABiUYAgAAAAAAAAAwKMEQAAAAAAAAAIBBCYYAAAAAAAAAAAxKMAQAAAAAAAAAYFCCIQAAAAAAAAAAgxIMAQAAAAAAAAAYlGAIAAAAAAAAAMCgBEMAAAAAAAAAAAYlGAIAAAAAAAAAMCjBEAAAAAAAAACAQQmGAAAAAAAAAAAM6v8DvO3Y+CvWLusAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "sns.set_palette(sns.color_palette('Paired'))\n", - "fig, axes = plt.subplots(dpi=400)\n", - "sns.boxplot(y = cc_df['cross_cor'], ax = axes)\n", - "axes.set_title('Fitbit to Actiwatch Cross-Correlation')\n", - "axes.set_xlabel('')\n", - "axes.set_ylabel('Mean Cross-Correlation')\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "** Future ** \n", - "1. Sleep stages (Where is this info for actiwatch? For fitbit, read in the sleep file)\n", - "2. Add metrics (sleep efficiency, onset latency, rest-activity measures, etc.)\n", - "3. Group comparisons between young and old" - ] - }, - { - "cell_type": "code", - "execution_count": 201, - "metadata": {}, - "outputs": [], - "source": [ - "#total slep time\n", - "\n", - " # problem with fitbit on this subject?" - ] - }, - { - "cell_type": "code", - "execution_count": 401, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "[0]\n", - "merging 10011_10_24_2019_4_30_00_PM_New_Analysis.csv with WA_10011_sleepDay_20190801_20200223.csv\n", - "0.43712572020543233\n", - "404.75\n", - "452.75\n", - "10012\n", - "[1]\n", - "merging 10012_10_18_2019_3_30_00_PM_New_Analysis.csv with WA_10012_sleepDay_20190801_20200223.csv\n", - "0.5577895564104254\n", - "460.625\n", - "468.75\n", - "10014\n", - "[2]\n", - "merging 10014_11_11_2019_5_20_00_PM_New_Analysis.csv with WA_10014_sleepDay_20190801_20200223.csv\n", - "-0.24001630690962514\n", - "463.375\n", - "398.25\n", - "10016\n", - "[3]\n", - "merging 10016_1_24_2020_11_45_00_AM_New_Analysis.csv with WA_10016_sleepDay_20190801_20200223.csv\n", - "0.5150449868048569\n", - "364.94444444444446\n", - "406.44444444444446\n", - "10023\n", - "[4]\n", - "merging 10023_11_11_2019_1_50_00_PM_New_Analysis.csv with WA_10023_sleepDay_20190801_20200223.csv\n", - "0.010588429625877095\n", - "352.0\n", - "334.09090909090907\n", - "10024\n", - "[5]\n", - "merging 10024_11_5_2019_3_15_00_PM_New_Analysis.csv with WA_10024_sleepDay_20190801_20200223.csv\n", - "0.8861869111036961\n", - "374.0357142857143\n", - "426.07142857142856\n", - "10025\n", - "[6]\n", - "merging 10025_12_5_2019_2_15_00_PM_New_Analysis.csv with WA_10025_sleepDay_20190801_20200223.csv\n", - "0.896163486670367\n", - "402.67857142857144\n", - "446.42857142857144\n", - "10033\n", - "[7]\n", - "merging 10033_11_7_2019_2_50_00_PM_New_Analysis.csv with WA_10033_sleepDay_20190801_20200223.csv\n", - "-0.19098409963335677\n", - "475.38461538461536\n", - "509.2307692307692\n", - "10035\n", - "[8]\n", - "merging 10035_2_7_2020_2_45_00_PM_New_Analysis.csv with WA_10035_sleepDay_20190801_20200223.csv\n", - "0.8119841885482925\n", - "404.0\n", - "422.14285714285717\n", - "10038\n", - "[9]\n", - "merging 10038_1_22_2020_9_45_00_PM_New_Analysis.csv with WA_10038_sleepDay_20190801_20200223.csv\n", - "0.5375240772667004\n", - "362.10714285714283\n", - "406.57142857142856\n", - "10040\n", - "[10]\n", - "merging 10040_1_29_2020_1_45_00_PM_New_Analysis.csv with WA_10040_sleepDay_20190801_20200223.csv\n", - "0.5681335673696446\n", - "444.2857142857143\n", - "445.14285714285717\n", - "10045\n", - "[11]\n", - "merging 10045_12_4_2019_11_45_00_AM_New_Analysis.csv with WA_10045_sleepDay_20190801_20200223.csv\n", - "0.7311272070953267\n", - "406.64285714285717\n", - "431.2142857142857\n", - "10049\n", - "[12]\n", - "merging 10049_12_2_2019_10_45_00_AM_New_Analysis.csv with WA_10049_sleepDay_20190801_20200223.csv\n", - "10062\n", - "[13]\n", - "merging 10062_1_27_2020_1_45_00_PM_New_Analysis.csv with WA_10062_sleepDay_20190801_20200223.csv\n", - "10076\n", - "[14]\n", - "merging 10076_11_8_2019_11_45_00_PM_New_Analysis.csv with WA_10076_sleepDay_20190801_20200223.csv\n", - "0.0007197990452573281\n", - "498.0769230769231\n", - "507.46153846153845\n" - ] - } - ], - "source": [ - "fb_sleep_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*sleepDay*\", recursive=True)\n", - "tst_cor = []\n", - "\n", - "for f in act_files:\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - " indices = [ff for ff, s in enumerate(fitbit_sleep_files) if subject in s] #what if there are multiple matching files?\n", - " print(subject)\n", - " print(indices)\n", - " \n", - " rs = []\n", - " offset = []\n", - "\n", - " if not indices:\n", - " print(\"subject %s no fitbit data available\" % subject)\n", - " else:\n", - " print(\"merging %s with %s\" % (os.path.basename(f), os.path.basename(fitbit_sleep_files[indices[0]])))\n", - " \n", - " header_offset = []\n", - " footer_offset = []\n", - " rpx = []\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for header_offset, line in enumerate(file, 1):\n", - " if 'Statistics' in line:\n", - " header_offset = header_offset\n", - " break\n", - "\n", - " with open(f, encoding='utf-8') as file:\n", - " for footer_offset, line in enumerate(file, 1):\n", - " if 'Line' in line:\n", - " footer_offset = footer_offset +6\n", - " break\n", - "\n", - " subject = str.split(f, \"act_files/\")[1][0:5]\n", - "\n", - "\n", - " rpx_metrics = pd.read_csv(f, skiprows=header_offset, nrows=footer_offset-header_offset, engine='python')\n", - " rpx_metrics = rpx_metrics[rpx_metrics['Interval Type'] == 'SLEEP']\n", - " rpx_metrics['Sleep Time'] = rpx_metrics['Sleep Time'].astype(float)\n", - " rpx_metrics['Start Date'] = pd.to_datetime(rpx_metrics['Start Date'])\n", - " \n", - " fb_sleep = pd.read_csv(fitbit_sleep_files[indices[0]], engine='python')\n", - " fb_sleep['Start Date'] = pd.to_datetime(fb_sleep['SleepDay'])\n", - " fb_sleep['Sleep Efficiency'] = (tst_df['TotalMinutesAsleep']/tst_df['TotalTimeInBed'])*100\n", - " \n", - " tst_df = pd.merge(rpx_metrics, fb_sleep, on = 'Start Date')\n", - " \n", - " try:\n", - " r = np.corrcoef(tst_df['Sleep Time'], tst_df['TotalMinutesAsleep'])[0,1]\n", - " m_act = np.mean(tst_df['Sleep Time'])\n", - " m_fit = np.mean(tst_df['TotalMinutesAsleep'])\n", - " m_eff_act = np.nanmean(tst_df['Efficiency'].astype(float))\n", - " m_eff_fit = np.nanmean(tst_df['Sleep Efficiency'])\n", - " \n", - " \n", - " print(r)\n", - " print(m_act)\n", - " print(m_fit)\n", - " \n", - " tst_cor.append([r, 'Actiwatch', m_act, m_eff_act])\n", - " tst_cor.append([r, 'Fitbit', m_fit, m_eff_fit])\n", - " except:\n", - " 'NA'\n", - "\n", - "tst_cor = pd.DataFrame(tst_cor, columns = ['tst_cor', 'device', 'tst_mean', 'efficiency_mean'])" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "10011\n", - "10012\n", - "10014\n", - "10016\n", - "10023\n", - "10024\n", - "10025\n", - "10033\n", - "10035\n", - "10038\n", - "10040\n", - "10045\n", - "10049\n", - "10062\n", - "10076\n", - "20103\n", - "20105\n", - "20108\n", - "20113\n", - "20115\n" - ] - }, - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
SleepDayTotalSleepRecordsTotalMinutesAsleepTotalTimeInBedSubjectinterval_number
010/25/2019 12:00:00 AM1508556100110
111/4/2019 12:00:00 AM1450488100111
211/5/2019 12:00:00 AM1480544100112
311/6/2019 12:00:00 AM1405429100113
411/7/2019 12:00:00 AM1373404100114
.....................
83/22/2020 12:00:00 AM1491553201158
93/23/2020 12:00:00 AM1423477201159
103/24/2020 12:00:00 AM24484572011510
113/25/2020 12:00:00 AM15085732011511
123/26/2020 12:00:00 AM24344622011512
\n", - "

230 rows × 6 columns

\n", - "
" - ], - "text/plain": [ - " SleepDay TotalSleepRecords TotalMinutesAsleep \\\n", - "0 10/25/2019 12:00:00 AM 1 508 \n", - "1 11/4/2019 12:00:00 AM 1 450 \n", - "2 11/5/2019 12:00:00 AM 1 480 \n", - "3 11/6/2019 12:00:00 AM 1 405 \n", - "4 11/7/2019 12:00:00 AM 1 373 \n", - ".. ... ... ... \n", - "8 3/22/2020 12:00:00 AM 1 491 \n", - "9 3/23/2020 12:00:00 AM 1 423 \n", - "10 3/24/2020 12:00:00 AM 2 448 \n", - "11 3/25/2020 12:00:00 AM 1 508 \n", - "12 3/26/2020 12:00:00 AM 2 434 \n", - "\n", - " TotalTimeInBed Subject interval_number \n", - "0 556 10011 0 \n", - "1 488 10011 1 \n", - "2 544 10011 2 \n", - "3 429 10011 3 \n", - "4 404 10011 4 \n", - ".. ... ... ... \n", - "8 553 20115 8 \n", - "9 477 20115 9 \n", - "10 457 20115 10 \n", - "11 573 20115 11 \n", - "12 462 20115 12 \n", - "\n", - "[230 rows x 6 columns]" - ] - }, - "execution_count": 40, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fitbit_sleep_files = glob.glob(home_dir + \"/Box/CogNeuroLab/Wearables/data/fitbit/*sleepDay*.csv\")\n", - "fitbit_sleep_files\n", - "\n", - "fit_sleep = pd.DataFrame(columns = ['SleepDay', 'TotalSleepRecords', 'TotalMinutesAsleep', 'TotalTimeInBed', 'Subject'])\n", - "\n", - "\n", - "for file in fitbit_sleep_files:\n", - " subject = str.split(file, \"WA_\")[1][0:5]\n", - " print(subject)\n", - " \n", - " a = pd.read_csv(file, sep = \",\")\n", - " a['Subject'] = subject\n", - " fit_sleep = pd.concat((fit_sleep, a))\n", - "\n", - "fit_sleep['interval_number'] = fit_sleep.index\n", - "fit_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 57, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
analysis_namesubject_iddata_start_datedata_start_timeinterval_typeinterval_numberstart_datestart_timeend_dateend_time...percent_immobilefragmentationnumber_of_scoresnumber_of_manualnumber_of_schedulednumber_of_no_responsesavg_scoreavg_manualavg_scheduledUnnamed: 30
39New Analysis1001110/24/20194:30:00 PMSLEEP010/24/20198:55:00 PM10/25/20196:07:00 AM...89.1314.57NaNNaNNaNNaNNaNNaNNaNNaN
40New Analysis1001110/24/20194:30:00 PMSLEEP110/25/201910:42:30 PM10/26/20196:44:30 AM...92.957.05NaNNaNNaNNaNNaNNaNNaNNaN
41New Analysis1001110/24/20194:30:00 PMSLEEP210/26/201910:11:00 PM10/27/20197:09:30 AM...93.5918.31NaNNaNNaNNaNNaNNaNNaNNaN
42New Analysis1001110/24/20194:30:00 PMSLEEP310/28/201912:17:30 AM10/28/20195:57:30 AM...92.3514.79NaNNaNNaNNaNNaNNaNNaNNaN
43New Analysis1001110/24/20194:30:00 PMSLEEP410/28/201911:29:00 PM10/29/20196:02:00 AM...93.266.74NaNNaNNaNNaNNaNNaNNaNNaN
..................................................................
1507New Analysis201153/12/20202:40:00 PMSLEEP93/21/202010:58:00 PM3/22/20208:02:00 AM...86.6719.82NaNNaNNaNNaNNaNNaNNaNNaN
1508New Analysis201153/12/20202:40:00 PMSLEEP103/22/202011:23:30 PM3/23/20207:07:00 AM...88.0323.91NaNNaNNaNNaNNaNNaNNaNNaN
1509New Analysis201153/12/20202:40:00 PMSLEEP113/23/202010:47:30 PM3/24/20207:22:30 AM...87.9622.64NaNNaNNaNNaNNaNNaNNaNNaN
1510New Analysis201153/12/20202:40:00 PMSLEEP123/24/202010:03:30 PM3/25/20206:48:30 AM...88.3819.31NaNNaNNaNNaNNaNNaNNaNNaN
1511New Analysis201153/12/20202:40:00 PMSLEEP133/25/202010:16:00 PM3/26/20207:06:30 AM...88.9716.74NaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

274 rows × 31 columns

\n", - "
" - ], - "text/plain": [ - " analysis_name subject_id data_start_date data_start_time interval_type \\\n", - "39 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "40 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "41 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "42 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "43 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "... ... ... ... ... ... \n", - "1507 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1508 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1509 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1510 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "1511 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "\n", - " interval_number start_date start_time end_date end_time ... \\\n", - "39 0 10/24/2019 8:55:00 PM 10/25/2019 6:07:00 AM ... \n", - "40 1 10/25/2019 10:42:30 PM 10/26/2019 6:44:30 AM ... \n", - "41 2 10/26/2019 10:11:00 PM 10/27/2019 7:09:30 AM ... \n", - "42 3 10/28/2019 12:17:30 AM 10/28/2019 5:57:30 AM ... \n", - "43 4 10/28/2019 11:29:00 PM 10/29/2019 6:02:00 AM ... \n", - "... ... ... ... ... ... ... \n", - "1507 9 3/21/2020 10:58:00 PM 3/22/2020 8:02:00 AM ... \n", - "1508 10 3/22/2020 11:23:30 PM 3/23/2020 7:07:00 AM ... \n", - "1509 11 3/23/2020 10:47:30 PM 3/24/2020 7:22:30 AM ... \n", - "1510 12 3/24/2020 10:03:30 PM 3/25/2020 6:48:30 AM ... \n", - "1511 13 3/25/2020 10:16:00 PM 3/26/2020 7:06:30 AM ... \n", - "\n", - " percent_immobile fragmentation number_of_scores number_of_manual \\\n", - "39 89.13 14.57 NaN NaN \n", - "40 92.95 7.05 NaN NaN \n", - "41 93.59 18.31 NaN NaN \n", - "42 92.35 14.79 NaN NaN \n", - "43 93.26 6.74 NaN NaN \n", - "... ... ... ... ... \n", - "1507 86.67 19.82 NaN NaN \n", - "1508 88.03 23.91 NaN NaN \n", - "1509 87.96 22.64 NaN NaN \n", - "1510 88.38 19.31 NaN NaN \n", - "1511 88.97 16.74 NaN NaN \n", - "\n", - " number_of_scheduled number_of_no_responses avg_score avg_manual \\\n", - "39 NaN NaN NaN NaN \n", - "40 NaN NaN NaN NaN \n", - "41 NaN NaN NaN NaN \n", - "42 NaN NaN NaN NaN \n", - "43 NaN NaN NaN NaN \n", - "... ... ... ... ... \n", - "1507 NaN NaN NaN NaN \n", - "1508 NaN NaN NaN NaN \n", - "1509 NaN NaN NaN NaN \n", - "1510 NaN NaN NaN NaN \n", - "1511 NaN NaN NaN NaN \n", - "\n", - " avg_scheduled Unnamed: 30 \n", - "39 NaN NaN \n", - "40 NaN NaN \n", - "41 NaN NaN \n", - "42 NaN NaN \n", - "43 NaN NaN \n", - "... ... ... \n", - "1507 NaN NaN \n", - "1508 NaN NaN \n", - "1509 NaN NaN \n", - "1510 NaN NaN \n", - "1511 NaN NaN \n", - "\n", - "[274 rows x 31 columns]" - ] - }, - "execution_count": 57, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_sleep = pd.read_csv(home_dir + \"/Box/CogNeuroLab/Wearables/data/actiwatch/Combined Export File WA (2).csv\")\n", - "act_sleep = act_sleep[act_sleep['interval_type'] == 'SLEEP']\n", - "act_sleep['interval_number'] = act_sleep['interval_number'].astype(int) - 1\n", - "act_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 54, - "metadata": {}, - "outputs": [], - "source": [ - "fit_sleep['Subject'] = fit_sleep['Subject'].astype('int')\n", - "fit_sleep['interval_number'] = fit_sleep['interval_number'].astype('int')\n", - "act_sleep['interval_number'] = act_sleep['interval_number'].astype('int')" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
analysis_namesubject_iddata_start_datedata_start_timeinterval_typeinterval_numberstart_datestart_timeend_dateend_time...number_of_no_responsesavg_scoreavg_manualavg_scheduledUnnamed: 30SleepDayTotalSleepRecordsTotalMinutesAsleepTotalTimeInBedSubject
0New Analysis1001110/24/20194:30:00 PMSLEEP010/24/20198:55:00 PM10/25/20196:07:00 AM...NaNNaNNaNNaNNaN10/25/2019 12:00:00 AM150855610011.0
1New Analysis1001110/24/20194:30:00 PMSLEEP110/25/201910:42:30 PM10/26/20196:44:30 AM...NaNNaNNaNNaNNaN11/4/2019 12:00:00 AM145048810011.0
2New Analysis1001110/24/20194:30:00 PMSLEEP210/26/201910:11:00 PM10/27/20197:09:30 AM...NaNNaNNaNNaNNaN11/5/2019 12:00:00 AM148054410011.0
3New Analysis1001110/24/20194:30:00 PMSLEEP310/28/201912:17:30 AM10/28/20195:57:30 AM...NaNNaNNaNNaNNaN11/6/2019 12:00:00 AM140542910011.0
4New Analysis1001110/24/20194:30:00 PMSLEEP410/28/201911:29:00 PM10/29/20196:02:00 AM...NaNNaNNaNNaNNaN11/7/2019 12:00:00 AM137340410011.0
..................................................................
269New Analysis201153/12/20202:40:00 PMSLEEP93/21/202010:58:00 PM3/22/20208:02:00 AM...NaNNaNNaNNaNNaN3/23/2020 12:00:00 AM142347720115.0
270New Analysis201153/12/20202:40:00 PMSLEEP103/22/202011:23:30 PM3/23/20207:07:00 AM...NaNNaNNaNNaNNaN3/24/2020 12:00:00 AM244845720115.0
271New Analysis201153/12/20202:40:00 PMSLEEP113/23/202010:47:30 PM3/24/20207:22:30 AM...NaNNaNNaNNaNNaN3/25/2020 12:00:00 AM150857320115.0
272New Analysis201153/12/20202:40:00 PMSLEEP123/24/202010:03:30 PM3/25/20206:48:30 AM...NaNNaNNaNNaNNaN3/26/2020 12:00:00 AM243446220115.0
273New Analysis201153/12/20202:40:00 PMSLEEP133/25/202010:16:00 PM3/26/20207:06:30 AM...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
\n", - "

274 rows × 36 columns

\n", - "
" - ], - "text/plain": [ - " analysis_name subject_id data_start_date data_start_time interval_type \\\n", - "0 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "1 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "2 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "3 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - "4 New Analysis 10011 10/24/2019 4:30:00 PM SLEEP \n", - ".. ... ... ... ... ... \n", - "269 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "270 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "271 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "272 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "273 New Analysis 20115 3/12/2020 2:40:00 PM SLEEP \n", - "\n", - " interval_number start_date start_time end_date end_time ... \\\n", - "0 0 10/24/2019 8:55:00 PM 10/25/2019 6:07:00 AM ... \n", - "1 1 10/25/2019 10:42:30 PM 10/26/2019 6:44:30 AM ... \n", - "2 2 10/26/2019 10:11:00 PM 10/27/2019 7:09:30 AM ... \n", - "3 3 10/28/2019 12:17:30 AM 10/28/2019 5:57:30 AM ... \n", - "4 4 10/28/2019 11:29:00 PM 10/29/2019 6:02:00 AM ... \n", - ".. ... ... ... ... ... ... \n", - "269 9 3/21/2020 10:58:00 PM 3/22/2020 8:02:00 AM ... \n", - "270 10 3/22/2020 11:23:30 PM 3/23/2020 7:07:00 AM ... \n", - "271 11 3/23/2020 10:47:30 PM 3/24/2020 7:22:30 AM ... \n", - "272 12 3/24/2020 10:03:30 PM 3/25/2020 6:48:30 AM ... \n", - "273 13 3/25/2020 10:16:00 PM 3/26/2020 7:06:30 AM ... \n", - "\n", - " number_of_no_responses avg_score avg_manual avg_scheduled \\\n", - "0 NaN NaN NaN NaN \n", - "1 NaN NaN NaN NaN \n", - "2 NaN NaN NaN NaN \n", - "3 NaN NaN NaN NaN \n", - "4 NaN NaN NaN NaN \n", - ".. ... ... ... ... \n", - "269 NaN NaN NaN NaN \n", - "270 NaN NaN NaN NaN \n", - "271 NaN NaN NaN NaN \n", - "272 NaN NaN NaN NaN \n", - "273 NaN NaN NaN NaN \n", - "\n", - " Unnamed: 30 SleepDay TotalSleepRecords \\\n", - "0 NaN 10/25/2019 12:00:00 AM 1 \n", - "1 NaN 11/4/2019 12:00:00 AM 1 \n", - "2 NaN 11/5/2019 12:00:00 AM 1 \n", - "3 NaN 11/6/2019 12:00:00 AM 1 \n", - "4 NaN 11/7/2019 12:00:00 AM 1 \n", - ".. ... ... ... \n", - "269 NaN 3/23/2020 12:00:00 AM 1 \n", - "270 NaN 3/24/2020 12:00:00 AM 2 \n", - "271 NaN 3/25/2020 12:00:00 AM 1 \n", - "272 NaN 3/26/2020 12:00:00 AM 2 \n", - "273 NaN NaN NaN \n", - "\n", - " TotalMinutesAsleep TotalTimeInBed Subject \n", - "0 508 556 10011.0 \n", - "1 450 488 10011.0 \n", - "2 480 544 10011.0 \n", - "3 405 429 10011.0 \n", - "4 373 404 10011.0 \n", - ".. ... ... ... \n", - "269 423 477 20115.0 \n", - "270 448 457 20115.0 \n", - "271 508 573 20115.0 \n", - "272 434 462 20115.0 \n", - "273 NaN NaN NaN \n", - "\n", - "[274 rows x 36 columns]" - ] - }, - "execution_count": 65, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep = pd.merge(act_sleep, fit_sleep, how='left', left_on=['subject_id','interval_number'], right_on = ['Subject','interval_number'])\n", - "df_sleep" - ] - }, - { - "cell_type": "code", - "execution_count": 62, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['analysis_name', 'subject_id', 'data_start_date', 'data_start_time',\n", - " 'interval_type', 'interval_number', 'start_date', 'start_time',\n", - " 'end_date', 'end_time', 'duration', 'off_wrist', 'percent_off_wrist',\n", - " 'total_ac', 'percent_invalid_sw', 'onset_latency', 'efficiency',\n", - " 'wake_time', 'percent_wake', 'sleep_time', 'percent_sleep',\n", - " 'percent_immobile', 'fragmentation', 'number_of_scores',\n", - " 'number_of_manual', 'number_of_scheduled', 'number_of_no_responses',\n", - " 'avg_score', 'avg_manual', 'avg_scheduled', 'Unnamed: 30'],\n", - " dtype='object')" - ] - }, - "execution_count": 62, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "act_sleep.columns" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Index(['SleepDay', 'TotalSleepRecords', 'TotalMinutesAsleep', 'TotalTimeInBed',\n", - " 'Subject', 'interval_number'],\n", - " dtype='object')" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fit_sleep.columns" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Total Sleep Time Correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 69, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.6274709645794498" - ] - }, - "execution_count": 69, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "column_1 = df_sleep[\"sleep_time\"].astype('float')\n", - "column_2 = df_sleep[\"TotalMinutesAsleep\"].astype('float')\n", - "correlation = column_1.corr(column_2)\n", - "correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 86, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch mean TST is 421.75 +/- 106.93\n", - "Fitbit mean TST is 428.77 +/- 100.81\n" - ] - } - ], - "source": [ - "print(\"Actiwatch mean TST is %.2f +/- %.2f\" % (df_sleep[\"sleep_time\"].astype('float').mean(), df_sleep[\"sleep_time\"].astype('float').std()))\n", - "print(\"Fitbit mean TST is %.2f +/- %.2f\" % (df_sleep[\"TotalMinutesAsleep\"].astype('float').mean(), df_sleep[\"TotalMinutesAsleep\"].astype('float').std()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 90, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "-7.0166937010002925" - ] - }, - "execution_count": 90, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"sleep_time\"].astype('float').mean() - df_sleep[\"TotalMinutesAsleep\"].astype('float').mean()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Time In Bed Correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 70, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0.5758078399291401" - ] - }, - "execution_count": 70, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep['tib'] = (df_sleep[\"sleep_time\"].astype('float') * 100)/df_sleep[\"percent_sleep\"].astype('float')\n", - "column_1 = df_sleep[\"tib\"].astype('float')\n", - "column_2 = df_sleep[\"TotalTimeInBed\"].astype('float')\n", - "correlation = column_1.corr(column_2)\n", - "correlation" - ] - }, - { - "cell_type": "code", - "execution_count": 71, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 551.997205\n", - "1 482.014388\n", - "2 538.528421\n", - "3 339.984817\n", - "4 392.996531\n", - " ... \n", - "269 543.998220\n", - "270 463.475524\n", - "271 515.000542\n", - "272 524.980699\n", - "273 530.477759\n", - "Name: tib, Length: 274, dtype: float64" - ] - }, - "execution_count": 71, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep['tib']" - ] - }, - { - "cell_type": "code", - "execution_count": 72, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0 556.0\n", - "1 488.0\n", - "2 544.0\n", - "3 429.0\n", - "4 404.0\n", - " ... \n", - "269 477.0\n", - "270 457.0\n", - "271 573.0\n", - "272 462.0\n", - "273 NaN\n", - "Name: TotalTimeInBed, Length: 274, dtype: float64" - ] - }, - "execution_count": 72, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"TotalTimeInBed\"].astype('float')" - ] - }, - { - "cell_type": "code", - "execution_count": 87, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch mean TIB is 466.92 +/- 113.54\n", - "Fitbit mean TIB is 458.29 +/- 108.92\n" - ] - } - ], - "source": [ - "print(\"Actiwatch mean TIB is %.2f +/- %.2f\" % (df_sleep[\"tib\"].astype('float').mean(), df_sleep[\"tib\"].astype('float').std()))\n", - "print(\"Fitbit mean TIB is %.2f +/- %.2f\" % (df_sleep[\"TotalTimeInBed\"].astype('float').mean(), df_sleep[\"TotalTimeInBed\"].astype('float').std()))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 91, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "8.624066661546749" - ] - }, - "execution_count": 91, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "df_sleep[\"tib\"].astype('float').mean() - df_sleep[\"TotalTimeInBed\"].astype('float').mean()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/docs/actiwatch-vs-fitbit.Rmd b/docs/actiwatch-vs-fitbit.Rmd deleted file mode 100644 index 525f16e..0000000 --- a/docs/actiwatch-vs-fitbit.Rmd +++ /dev/null @@ -1,115 +0,0 @@ ---- -title: "Validation Study" -author: "Megan McMahon" -date: "1/11/2020" -output: html_document ---- - -```{r setup, include=FALSE} -knitr::opts_chunk$set(echo = TRUE) - -library(readr) -library(tidyverse) -library(ggplot2) -library(lubridate) - -steps_files <- list.files("~/Box/CogNeuroLab/Wearable Assessment/data/fitbit", pattern = "WA_?????_.*.minuteStepsNarrow.*.csv", recursive = TRUE, full.names= TRUE) - -d <- read.csv(steps_files[1]) -head(d) - -``` - - -```{r} -read_activity_file <- function(filename, device) { - # read actigraphy file - csv format, 2 columns, datetime and activity - d=read.csv(filename, header=TRUE, sep=',', na.string=' ', stringsAsFactors = FALSE) - colnames(d) <- c('time', 'activity') - - if (device == "fitbit" | device == "Fitbit") { - d$time <- lubridate::parse_date_time(d$time, "%m/%d/%Y %I:%M:%S %p") - d$record_id <- stringr::str_sub(basename(filename), 4, 8) - d$period <- tail(d$time, 1) - head(d$time, 1) - - } else if (device == "actiwatch" | device == "Actiwatch") { - d$record_id <- stringr::str_sub(basename(filename), 1, 5) - d$period <- ymd_hms(tail(d$time, 1), tz="UTC") - ymd_hms(head(d$time, 1), tz="UTC") - - } else { - print("Invalid device type") - } - - d %>% - mutate(hour = lubridate::hour(time)) %>% - group_by(hour) %>% - summarise(activity_h=sum(activity)) %>% - na.omit() - - return(d) -} - -get_all_activity_data <- function(actiwatch_file, fitbit_file, print = TRUE) { - #act <- read_activity_file(actiwatch_file, "actiwatch") - fitbit <- read_activity_file(fitbit_file, "fitbit") - d <- merge(act, select(fitbit, -record_id), by = "time", all = TRUE, suffixes = c("_act", "_fit") ) - - - print(head(d)) - - return(d) -} - -# generate random actiwatch data for testing -ex <- read_activity_file(steps_files[1], "fitbit") -act <- ex -corrupt <- rbinom(length(act$activity),1,0.1) # choose an average of 10% to corrupt at random -corrupt <- as.logical(corrupt) -noise <- rnorm(sum(corrupt),0,10) # generate the noise to add -act$activity[corrupt] <- act$activity[corrupt] + noise # about 10% of x has been corrupted - -# full data -d_new <- get_all_activity_data(NA, steps_files[1]) -``` - - - -```{r} -plot_steps <- function(d){ - - #alpha = 0.4 as example to make transparent lines - p.act <- ggplot(d) + - geom_line(aes(x = time, y = activity_act, color = "Actiwatch"), size = 0.3) + - #geom_line(aes(x = time, y = activity_fit, color = "Fitbit"), size = 0.3) + - theme_minimal() + - scale_color_manual(name = "Device", values = c("blue", "red")) + - facet_wrap(. ~ day(time), scales = "free_x") + - scale_x_discrete(expand = c(0,0), label = '') + - xlab("Time") + ylab("Activity") + - ggtitle(paste("Activity Band Data", d$record_id[1])) - - return(p.act) -} - -plot_steps(d_new) -``` - - - -```{r} -plot_steps_diff <- function(d){ - - p.diff <- ggplot(d) + - geom_line(aes(x = time, y = activity_act - activity_fit), size = 0.3) + - theme_minimal() + - facet_wrap(. ~ day(time), scales = "free_x") + - scale_x_discrete(expand = c(0,0), label = '') + - xlab("Time") + ylab("Activity") + - ggtitle(paste("Discrepancy in Activity Band Recordings:", d$record_id[1])) - - return(p.diff) -} - -plot_steps_diff(d_new) -``` - diff --git a/docs/cosinor_analysis_example.ipynb b/docs/cosinor_analysis_example.ipynb deleted file mode 100644 index aed04ae..0000000 --- a/docs/cosinor_analysis_example.ipynb +++ /dev/null @@ -1,984 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import datetime as dt\n", - "\n", - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n", - "\n", - "from matplotlib import rcParams\n", - "rcParams['figure.figsize'] = (10, 8)\n", - "rcParams['legend.fontsize'] = 16\n", - "rcParams['axes.labelsize'] = 16\n", - "plt.rcParams['axes.prop_cycle'] = plt.cycler(color=plt.cm.Dark2.colors)\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Load an actigraphy file" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "devices = ['Actiwatch 2.0', 'Fitbit Charge 2 HR']\n", - "actfiles = ['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/actiwatch/10011_act.txt',\n", - " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/fitbit/10011_fit.txt']" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "def read_actig(file): \n", - " # actigraphy input file is a file with two columns, Time (\"%Y-%m-%d %H:%M:%S\") and Activity, with no header\n", - " \n", - " data = pd.read_csv(file, sep = \" \", header = None, names = ['time', 'activity'])\n", - " data['time'] = data.values[:,0].astype(str)\n", - " data['clocktime'] = [int(dt.datetime.strptime(x, \"%Y-%m-%d %H:%M:%S\").time().strftime(\"%H\")) + (int(dt.datetime.strptime(x, \"%Y-%m-%d %H:%M:%S\").time().strftime(\"%M\"))/60) for x in data['time']]\n", - " data = data.groupby('clocktime').max()\n", - " data['lmaxact'] = np.log10(data['activity'] + 1)\n", - " return data" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "act = read_actig(actfiles[0])\n", - "fit = read_actig(actfiles[1])\n", - "fitInt = read_actig('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/interpolated/WA_10011_interpolated_mean.txt')" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "x_act = act.index.values\n", - "y_act = act['lmaxact'].values\n", - "\n", - "x_fit = fit.index.values\n", - "y_fit = fit['lmaxact'].values\n", - "\n", - "x_fitInt = fitInt.index.values\n", - "y_fitInt = fitInt['lmaxact'].values" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Pre-processing" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of missing values: 0\n", - "Total number of missing values: 0\n" - ] - } - ], - "source": [ - "print('Total number of missing values: %.f' %(act['activity'].isna().sum()))\n", - "print('Total number of missing values: %.f' %(fit['activity'].isna().sum()))" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Total number of missing values: 12\n" - ] - } - ], - "source": [ - "hrfile = '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_heartrate_1min_20190901_20200327.csv'\n", - "hr = pd.read_csv(hrfile)\n", - "hr['Time'] = pd.to_datetime(hr['Time'])\n", - "hr = hr.set_index('Time')\n", - "\n", - "\n", - "fitn = pd.read_csv('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/circadian_measures/raw/fitbit/10011_fit.txt', sep = \" \", names = ['Time', 'Activity'])\n", - "fitn['Time'] = pd.to_datetime(fitn['Time'])\n", - "fitn = fitn.set_index('Time')\n", - "\n", - "hr = hr.join(fitn, lsuffix = '_hr', rsuffix = '_fit')\n", - "print('Total number of missing values: %.f' %(hr['Activity'].isna().sum()))" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
ValueActivity
Time
2019-10-24 16:18:0056NaN
2019-10-24 16:19:0058NaN
2019-10-24 16:20:0055NaN
2019-10-24 16:21:0055NaN
2019-10-24 16:22:0057NaN
.........
2019-11-07 15:53:007435.0
2019-11-07 15:54:00750.0
2019-11-07 15:55:00730.0
2019-11-07 15:56:00710.0
2019-11-07 15:57:00700.0
\n", - "

19298 rows × 2 columns

\n", - "
" - ], - "text/plain": [ - " Value Activity\n", - "Time \n", - "2019-10-24 16:18:00 56 NaN\n", - "2019-10-24 16:19:00 58 NaN\n", - "2019-10-24 16:20:00 55 NaN\n", - "2019-10-24 16:21:00 55 NaN\n", - "2019-10-24 16:22:00 57 NaN\n", - "... ... ...\n", - "2019-11-07 15:53:00 74 35.0\n", - "2019-11-07 15:54:00 75 0.0\n", - "2019-11-07 15:55:00 73 0.0\n", - "2019-11-07 15:56:00 71 0.0\n", - "2019-11-07 15:57:00 70 0.0\n", - "\n", - "[19298 rows x 2 columns]" - ] - }, - "execution_count": 8, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "hr" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here showing way more missing values compared to R" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array(['2019-10-24T16:18:00.000000000', '2019-10-24T16:19:00.000000000',\n", - " '2019-10-24T16:20:00.000000000', '2019-10-24T16:21:00.000000000',\n", - " '2019-10-24T16:22:00.000000000', '2019-10-24T16:23:00.000000000',\n", - " '2019-10-24T16:24:00.000000000', '2019-10-24T16:25:00.000000000',\n", - " '2019-10-24T16:26:00.000000000', '2019-10-24T16:27:00.000000000',\n", - " '2019-10-24T16:28:00.000000000', '2019-10-24T16:29:00.000000000'],\n", - " dtype='datetime64[ns]')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "missing = hr[hr['Activity'].isna()].index.values\n", - "missing" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "12" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(missing)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAACEwAAANiCAYAAABxGs61AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOzde5gc1X3n/29VdfdcJSQNioQASQGDYQHLIGQHzBPFP8k2GF8wOGsWCBCzwQk4cZAdWDC72CYQ1olvYrF+JiAbGbwYCzDYToyNiRdj4ouEEQYWwk0XQJfRbaSZnp7uqnP2j+7TXT3T09eZququ9+t5eBjNtaamu/rUOZ/z/VpaawEAAAAAAAAAAAAAAIgTO+wDAAAAAAAAAAAAAAAACBqBCQAAAAAAAAAAAAAAEDsEJgAAAAAAAAAAAAAAQOwQmAAAAAAAAAAAAAAAALFDYAIAAAAAAAAAAAAAAMROIuwDEBE59NBD9eLFi8M+DAAAAAAAAABAFRs3btyttZ4b9nEAAAAAUyESgYnFixfLhg0bwj4MAAAAAAAAAEAVlmVtCfsYAAAAgKlCSw4AAAAAAAAAAAAAABA7BCYAAAAAAAAAAAAAAEDsEJgAAAAAAAAAAAAAAACxQ2ACAAAAAAAAAAAAAADEDoEJAAAAAAAAAAAAAAAQOwQmAAAAAAAAAAAAAABA7CTCPgAAAAAAAAAAAAAAAKrZuHHjWclk8mqt9WIRscI+HkSfZVn7lFL/6nne7UuXLt1c6XMITAAAAAAAAAAAAAAAImvjxo3HdHV1fW3x4sVuX1/fHssiL4HqtNaSzWaT+/fvP3/nzp1nbty48dxKoQlacgAAAAAAAAAAAAAAIiuRSFw3f/58q7+/P01YAvWwLEu6urpy8+bN2ztv3rxZjuNcXunzCEwAAAAAAAAAAAAAACLLsqwlM2fOHAn7ONCeZs2addC27bMqfYzABAAAAAAAAAAAAAAgsrTWs5LJpBv2caA9pVKpnNZ6dqWPEZgAAAAAAAAAAAAAAESZTSsONKvaY4fABAAAAAAAAAAAAAAAiB0CEwAAAAAAAAAAAAAAIHYITAAAAAAAAAAAAAAAEJDVq1cPWJa19Nlnn+0a/7FcLieWZS1dtWrVgjCObdWqVQsefvjhGfV8rvk9zH/JZPKUI4888sRPfvKTh6fT6aZ6qDTy86dCIqgfBAAAAAAAAAAAAAAAousrX/nKYa7ryoc+9KGD9X7N2rVrX124cGH2wIEDzv333z/rtttum3/w4EH7rrvu2hbEz28FgQkAAAAAAAAAAAAAAGJsdHTU6unp0c187bJly9InnnjimIjIRz7ykQOvvvpq13333Xfo2rVrtzmOM7UHOsVoyQEAAAAAAAAAAAAAQIS98MILqQ996EN/OHv27CWpVOqU44477j+tW7dulv9znn322a5zzjnnDw8//PCTuru7TzniiCNOuvDCCxcODg6WpRbOO++8xfPmzXvbo48+2nfyyScf193dfcoVV1xxhGVZS0VEbr311sNMm41mWoMsWbIknclk7B07dhQLODzwwAMzly9f/pa5c+e+raen5+RjjjnmhBtuuGGe67rFr6v183/0ox/1n3baacf29fWd3NPTc/IZZ5xxzG9/+9vuRo/PjwoTAAAAAAAAAAAAAIC28+kn1h/5wr4dvWEew3Gz56e/dMZHG249ISLieZ7kcrmy97mua43/vJdffjl5+umnHz8wMODedNNN2+bNm+fee++9cy699NKjHcd5+cILLxwSEdm2bVvyiCOOyH70ox/dNjAw4L700ktdX/7ylw97z3ve0/v000+/4P+ew8PDzsUXX3zUlVdeuXPJkiVv9Pb2qosuumjvypUrjzvvvPP2/NVf/dWgiMjixYuzjf5eW7du7erv7/fmzZtXTEO8/PLLXX/yJ39y8Morr9zV09Ojf/Ob3/T+0z/904LBwcHE17/+9TdERB599NEXJvv599577yEXXXTRW5YvX77/G9/4xmsiIl/60pfmr1ix4rinnnrqube85S25SsdSC4EJAAAAAAAAAAAAAAAC9va3v/3Eej7vuuuuW6C1ll/84hcvzJ8/3xMROe+88w6cfvrpyRtvvPFwE5g466yzhs8666xh83UrV64cfutb3zp25plnvvWXv/xlz7ve9a5R87F0Om1/4xvf2HbRRRftH//zFixYkF2xYsVIvb+HCX7s37/fueeee2Y98sgjs7/whS9sTSRKcYSrr7560LytlJIzzzzzYDabtdasWTP/1ltvfcNxHDE/s9LPv/rqq49ctmzZwZ/97GevmPe9//3vP3D00UefdPPNN89fu3ZtU6EVAhMAAAAAAAAAAAAAgLbTbGWHqFi3bt0rixYtKqvg4LqutWLFiuP87/v5z39+yLvf/e6hgYEBz1+RYuXKlQduvPHGI/bu3WvPmTNHZTIZ63Of+9y87373uwPbt2/vGhsbK1areO6557r9gYlEIqHPP//8CWGJZowPflx00UWD11133aD/fVu2bElee+21C37+85/P3LVrV9LzvOKxvfHGG4mFCxe6Monf//73Xdu2betatWrVdv/vP2PGDHXyySeP/OpXv+pv9tgJTAAAAAAAAAAAAAAAELCTTz559MQTTxzzv298iw4Rkb179yYefPDBgVQqNVDp++zatSsxZ86c7F//9V8f/q1vfesPrrrqqu1nnHHG8CGHHOJt2bIldckllxydyWRs/9fMnj3b9VeAaIUJfuzYsSPx1a9+dd7dd989953vfOfIJz/5yT0i+QoUZ5999lt27dqVvOaaa9484YQTMr29vWr9+vWzbr311sNGR0ftat9/+/btCRGRq666avFVV121ePzHDzvssIbbhhgEJgAAAAAAAAAAAAAAiKhZs2Z5y5YtO3jttdfuqPTxRYsW5UREHnrooTnnnnvuni9+8Yvbzcd+8IMfOJW+xrKsSu9uij/48cEPfvDg8ccff8INN9xwxMUXX7xv5syZ6vnnn+967rnnem+77bbXrrjiir3m6x588MFZ9Xz/uXPneiIi11577RtnnnnmgfEf7+rq0s0eO4EJAAAAAAAAAAAAAAAiavny5UMbN27sP+WUU0b7+/snDQdkMhk7kUiUfXzt2rUVq1JMJplM6loVH6rp6enRN91007aLLrroLf/4j/8498Ybb9w5PDxsm+9tPm9sbMy6//7759Tz85csWZJZsGBB9vnnn++5+eabK4ZGmkVgAgAAAAAAAAAAAACAiLrlllvePO20047/oz/6o+M+8YlP7DrqqKPG9u7dm/j973/f89prr3V973vf2yySD1Y88MADA7fccsvoscceO7Z+/fpZGzdu7G/kZx199NGZRx999JAHH3zwwMDAgLtw4cLc4sWLJ/YJqeLCCy8cuuWWW9Jr1qyZf8011+w6+eSTMwsWLMjeeOONhycSCUkmk3r16tXzGvn5X/7yl7deeOGFR5999tnWn/7pn+6dO3euu3379uSTTz7Zv3DhwuznPve5nY0co9F0MgQAAAAAAAAAAAAAAEyvY445JvvrX//6+RNOOCF94403Hn7OOeccu2rVqoVPPPFE/7vf/e5ii4rbb79924oVK4Zuvvnmwy+99NKjhoeHnW9/+9uvNvKzvva1r23p7e1V559//luWL19+/OrVq+c2c8yf//zn39izZ0/iS1/60tzu7m79ve997+W5c+fmrrjiisWf/vSnF55++ukH//Zv/3ZCtYjJfv7HPvaxoR//+McvptNp+2/+5m8Wn3vuucfecMMNR+zatSt5xhlnDDdzjCIiltZNt/OYMqeeeqresGFD2IcBAAAAAAAAAKjCsqyNWutTwz4OAAAQL5s2bdq8ZMmS3WEfB9rXpk2bDl2yZMni8e+nwgQAAAAAAAAAAAAAAIgdAhMAAAAAAAAAAAAAACB2CEwAAAAAAAAAAAAAAIDYITABAAAAAAAAAAAAAABih8AEAAAAAAAAAAAAAACIHQITAAAAAAAAAAAAAAAgdghMAAAAAAAAAAAAAACA2CEwgVC8OTIkB7OZsA8DAAAAAAAAAAAAABBTBCYQigsfuVO++vTPwj4MAAAAAAAAAAAAAEBMEZhAKIayozKUHQ37MAAAAAAAAAAAAAAAMUVgAqFQWosWHfZhAAAAAAAAAAAAAECozj///EWWZS297LLLjmz0a3fv3u2sWrVqwRNPPNE7/mPveMc73vqOd7zjrY1+z/Ff9+STT/asWrVqwc6dO51Gv1fUEZhAKJTWoslLAAAAAAAAAAAAAIix4eFh60c/+tFsEZHvf//7c3K5XENfv2fPHucrX/nKYb/5zW8mBCbWrFmzZc2aNVsaPabxX7dhw4ber3zlK4cNDg4mGv1eUUdgAqFQokWRmAAAAAAAAAAAAAAQY/fcc8/s4eFhZ/ny5UN79+5NrF+//pCp+t5Lly7NLF26NBPU17UjAhMIhaYlBwAAAAAAAAAAAICYu/vuuwdmzpzpfec739nc3d2t1q1bNzD+c9atWzfrlFNOOa63t/fk/v7+k0866aTj77nnnkNefPHF1HHHHXeSiMinP/3pRZZlLbUsa+nq1asHRMpba2zdujWRSCSW/v3f//0fjP/+119//bxEInHKm2++mRj/datXrx741Kc+tVhE5KSTTjrR/IwXX3wxdeyxx/6n97znPUeP/34//OEPZ1iWtXT9+vUzp/BUTYuOK5mB9qCpMAEAAAAAAAAAAACgBTvuvOzIsdefm9CKIkhdR5yQnn/Zndua+drNmzcn//3f/33mxz72scEFCxa4K1eu3P+Tn/xk9uDgoDN37lxPROSmm276g+uvv/7IlStX7v/617++Y8aMGWrDhg29r732Wte555574K677nrlkksuOfrKK6/c8ZGPfGS/iMjxxx8/Nv5nLVy40D3ttNMOfPe73x24/vrrd/k/dt999w388R//8YEFCxa447/uox/96NArr7yyffXq1YetXbv21YULF2YL3y/38Y9/fPD6668/cvPmzcnFixcXe4l84xvfOPTwww/PnnvuuQeaOS9BosIEQqG0FkWFCQAAAAAAAAAAAAAxdccdd8zxPE/+/M//fI+IyKWXXronm81a3/zmN+eIiOzdu9e++eabD3/Pe96z/6c//ekrl1566f7zzjvvwD/8wz/suP7663f19PTod77znWkRkaOOOmpsxYoVIytWrBipFHwQEbngggv2PPvss72bNm3qMu978skne1566aWeCy64YE+lr1mwYIF79NFHj4mILFu2LG1+Rk9Pj/7EJz6xp7u7W992222Hms9/8803E4888sjsiy++eNC2ox9HoMIEQqG0FvISAAAAAAAAAAAAAJrVbGWHqLj33nsPXbRo0djKlStHREQ+/OEPH5g7d27uO9/5zsDVV189+Nhjj/Wn02n78ssvH5yKn3fRRRft/8xnPqPuvPPOgdWrV78pIvLNb35zoL+/37vgggv2N/r9Zs+erc4555w999xzz6G33HLLdsdxZM2aNQNaa7nyyit3T8UxT7foRzrQkWjJAQAAAAAAAAAAACCuHn/88d5XXnml+/3vf/++3bt3O7t373b279/vnHXWWfs2bdrU98wzz3QNDg4mREQWLVqUnYqfOWPGDHXmmWfuu//++weUUuK6rjz00ENzzj777H29vb1NLd5+6lOf2rV9+/bUfffdd4hSStatWzf3ve997/7DDz+8YpWLqKHCBEKhtBZNiQkAAAAAAAAAAAAAMXTnnXcOiIisWbNm/po1a+aP//gdd9wxsHz58mERka1bt6aWLVuWmYqfe/HFF+954IEHBn7yk5/0p9Npe3BwMHnJJZdUbMdRj2XLlmWWLl06/M///M9ze3p61NatW7tuvfXWLVNxrEEgMIFQaE2FCQAAAAAAAAAAAADxk8lkrIcffnjO2972tpGbbrrpjfEf/7u/+7sj169fP/D5z39+R29vr7r99tvnnnfeeQcqfa/u7m4tIjI6OlpXd4kPfOADB+fNm5e76667BkZHR+0FCxZk3/e+9w1X+5quri4tIpJOpyv+jMsvv3zXFVdccdTQ0JCzaNGisQ996EMH6zmWKCAwgVBQYQIAAAAAAAAAAABAHN13332H7N+/P/GFL3zh9Q984AMTwgXPP//84DXXXLPwiSee6PvsZz/7+mc/+9mF73vf+46+4IIL9sycOVM99dRTPd3d3fqzn/3sriOOOCI3a9Ys9/7775/z9re/PT1jxgx17LHHjs2fP9+r9LMdx5Fzzz13z9133z3XdV3rL/7iL3badvWsxdve9rZREZGvfvWrcz/+8Y/vSaVS+h3veMeoCWtccskl+6+77jr3qaee6r/hhhten4JTFJi6UibAVNMiVJgAAAAAAAAAAAAAEDvr1q0b6OvrU5deeum+Sh+/7LLL9nZ3d6tvfetbA9ddd93g2rVrX92+fXvyE5/4xFF/9md/dvRDDz00+6ijjhoTyQcgVq9evWVoaMj58Ic/fOzy5cuPv++++2ZV+/kf//jH9xw8eNAZHR21L7vssprtOE477bTRVatWvfnoo4/Oet/73nfc8uXLj9+yZUvSfLyrq0u/973v3d/V1aX/8i//cnej5yNMlo7AovWpp56qN2zYEPZhIEBHfvNaee/C4+XOFReHfSgAAAAAAAAA6mRZ1kat9alhHwcAAIiXTZs2bV6yZElbLcTHSS6Xk8WLF5+0bNmy4e9///uvhX08lWzatOnQJUuWLB7/flpyIHC60I6DChMAAAAAAAAAAAAA0J727t1rb9y4sefb3/72wI4dO1JXX331jrCPqVEEJhA4Lbrs/wAAAAAAAAAAAACA9vLkk0/2ffCDHzx2zpw57o033rj19NNPHw37mBpFYAKBM4UlqDABAAAAAAAAAAAAAO3pAx/4wEGt9cawj6MVdtgHgPhRpsIEeQkAAAAAAAAAAAAAQEgITCBwprKEoiUHAAAAAAAAAAAAgNqUUsoK+yDQnnR+fbri4jSBCQSu2IqDEhMAAAAAAAAAAAAAarAsa8fo6Gh32MeB9jQyMtJrWdZrlT5GYAIhoMIEAAAAAAAAAAAAgPq4rvv5zZs3p0ZGRnqoNIF6aK0lm80mdu/ePWvz5s2JXC73xUqflwj6wABTYYICEwAAAAAAAAAAAABqOeWUUx556qmnPvnKK6/coLWeLxQGQG3Ksqx9WuvHXdf9h6VLl75U6ZMITCBwJjChtAr5SAAAAAAAAAAAAAC0g1NOOeUREXkk7ONAZyF5g8AVAxO05AAAAAAAAAAAAAAAhITABAKnhZYcAAAAAAAAAAAAAIBwEZhA4HQhKaGpMAEAAAAAAAAAAAAACAmBCQROFStMEJgAAAAAAAAAAAAAAISDwAQCpwpBCUVgAgAAAAAAAAAAAAAQEgITCJzJSRCXAAAAAAAAAAAAAACEhcAEAmdaclBhAgAAAAAAAAAAAAAQFgITCJwJSmhqTAAAAKDgx1uek1s3/VvYhwEAAAAAAAAgRghMIHDaBCaoMAEAAICCf9nyrNzzH78O+zAAAAAAAAAAxAiBCQTOVJYgLgEAAADD00o8xQgRAAAAAAAAQHAITCBwpiWH0irkIwEAAEBUaK1FEakFAAAAAAAAECACEwicCUwwHQ4AAADD05qWbQAAAAAAAAACRWACgStVmGBCHAAAAHmeUuJRgQwAAAAAAABAgAhMIASFChMEJgAAAFCgRROoBQAAAAAAABAoAhMIXKklBxPiAAAAyPO0EkWFCQAAAAAAAAABIjCBwCmhJQcAAADKeYoKEwAAAAAAAACCRWACgStVmAAAAADylGjxCEwAAAAAAAAACBCBCQTOzIOzgxAAAACG0orxIQAAAAAAAIBAEZhA4LTke1NrJsQBAABQoLQWpVXYhwEAAAAAAAAgRghMIHCllhwEJgAAAJDnUWECAAAAAAAAQMBqBiYsy1prWdYuy7Ke9b1vjmVZP7Us66XC/2cX3m9ZlrXasqyXLct6xrKsU6bz4NGeioEJ5sMBAABQoLQWjwEiAAAAAAAAgADVU2HiWyJy5rj3/TcR+ZnW+hgR+Vnh3yIiZ4nIMYX/LheRNVNzmOgkZhpcCSWXAQAAkKe0Fi2atm0AAAAAAAAAAlMzMKG1flxE9o5794dF5K7C23eJyDm+96/Teb8SkVmWZR02VQeLzkCFCQAAAIzn6XyYlrYcAAAAAAAAAIJST4WJSuZprbcX3t4hIvMKbx8uItt8n/d64X0TWJZ1uWVZGyzL2jA4ONjkYaAdmUlwJsMBAABgFMeIwhgRAAAAAAAAQDCaDUwU6XzN3IZnNbXWt2utT9Vanzp37txWDwNtxJRZ1kyGAwAAoIBQLQAAAAAAAICgNRuY2GlabRT+v6vw/jdE5Ejf5x1ReB9QZIIS9KcGAACAUWrJoUI+EgAAAAAAAABx0Wxg4mERuaTw9iUi8pDv/RdbeX8kIkO+1h2AiJR2DRKXAAAAgEGFCQAAAAAAAABBS9T6BMuy/reI/ImIHGpZ1usicoOI3CIi91mWdZmIbBGR/1z49H8RkfeLyMsikhaRP5+GY0abM32pmQwHAACAYSpLeIwRAQAAAAAAAASkZmBCa/1fJvnQigqfq0XkylYPCp2tVGGCyXAAAADkecUKE7TkAAAAjcu4OTmYy8jcnhlhHwoAAACANtJsSw6geZRbBgAAwDi05AAAAK244/kn5P0P/6+wDwMAAABAmyEwgcDRkgMAAADjmcoSjBEBAEAz9mRGZO/YSNiHAQAAAKDNEJhA4EqT4EyGAwAAIM+MET1acgAAgCZ4SokmeAkAAACgQQQmEDjKLQMAAGA8jwoTAACgBUo04wgAAAAADSMwgcBRXwIAAADjeYRqAQBAC5TWxfEEAAAAANSLwAQCp5kMBwAAwDilMSItOQAAQOM8pUSLpi0HAAAAgIYQmEDgzCS4psYEAAAACkxLDnaGAgCAZqjCPBPzTQAAAAAaQWACgVNUmAAAAMA4jBEBAEArFOFLAAAAAE0gMIHAcdsKAACA8ahCBgAAWkH4EgAAAEAzCEwgcNzAAgAAYDyzG9S05gAAAGiEx3wTAAAAgCYQmEDgij0luYEFAABAAaFaAADQCjOGYL4JAAAAQCMITCBw5sZVUW4ZAAAABaayhKLCBAAAaIIZQ1CtCgAAAEAjCEwgcLqY+A/5QAAAABAZVJgAAACtYCwBAAAAoBkEJhC4YksOKkwAAACgwCxueCxyAACAJhSrVTHfBAAAAKABBCYQOH/Sn76SAAAAEPG35GB8CAAAGqeKFU0ZSwAAAACoH4EJBM4/Cc6EOAAAAHTZ+JC+4wAAoHGlalWMJQAAAADUj8AEQuCbEKdMIgAAQOz5FzYI1AIAgGZQrQoAAABAMwhMIHC05AAAIBwv7tspbw7vD/swgAk835iQXaEAAKAZZr6JwAQAAACARhCYQOBoyQEAQDj++vF75YtP/STswwAmYHwIAABaZcYQbM4BAAAA0AgCEwicvw0Ht7AAAARnODsmI+5Y2IcBTKBoyQEAAFpkxhBUqwIAAADQCAITCJx/DpzUPwAAwckpj8VoRBIVJgAAQKtMUEKxPQcAAABAAwhMIHD+kITmJhYAgMC42mPHHSLJ/7hkkQMAADTDhC4JXwIAAABoBIEJBM4/Cc5NLAAAwckpJZ7itRfR4x8TeopQDwAAaJxp8cVcEwAAAIBGEJhA4FRZhQkAABAUV3nFiWQgShQVyAAAQIuoMAEAAACgGQQmEDhd1qOaRRsAAILiKiUeE8iIIH9LDipMAACAZngEJgAAAAA0gcAEAudvycEtLAAAwXGVV7YwDUSFP8ijGCECAIAm0JIDAAAAQDMITCBw/goTOqSb2MffeEl+uf2VUH42AABh0FqLqxXVnRBJ/jEhVVAAAEAzSi05GO8CAAAAqF8i7ANA/EShR/WXn35UehJJeddhR4fy8wEACJpbmDh2aXeACPJXPgkrUAsAANqbR4UJAAAAAE2gwkQEPf7GS7J602NhH8a08YckwrqJzSmP/tgAgFhxlSci7N5HNKmyChOM0QAAQOOKFSZo7wUAAACgAQQmIugHm5+Rrz79s45d0C+rMBHSPazSmhtoAECs5JTZcdeZ4wu0N//jkl2hAACgGaWWHIwlAAAAANSPwEQEKa0kqzzZkT4Q9qFMC/+Na1ihBVd5lHsGAMRKqcIEgQlEj7/yCaEeAADQDDPHxFgCAAAAQCMITESQCRRsPrA75COZHv6WHGGFFpTW7DgAAMRKjpYciLCyQC2PUbQ5pZX8j189LK8ODYZ9KAAQK16xohpjCQAAAAD1IzARQWYhY/PBvSEfyfTw37eGFZhwteIGGgAQKy4tORBh/sonhHrQ7naPjsja//ukPPb6i2EfCgDEihZacgAAAABoHIGJCDI3dlsO7gn5SKZHWY/q0FpyqNB+NgAAYaDCBKJMU2ECHcRcb8c8N+QjAYB4MQFM5nsAAAAANILARASZQMHmAx0amIhESw4qTAAA4sU1gQlFhQlEj7/CRFjjQ2CqEJgAgHCYeR7FeBcAAABAAwhMRJDX8RUmfDsIQ6wwwWQ8ACBOcvR0RoT5K594tI1BmyMwAQDhMOMJKkwAAAAAaASBiQjyV5joxEV9/28U1q9HhQkAQNyYChOu9kI+EmAiRUsOdJBSYCIX8pEAQLyY+TTGEgAAAAAaQWAigsyN3YiblT2ZkZCPZupFoUe1q5VodhwAAGIkVwhKeEwgI4KUr6oEFSbQ7kxALUOFCQAIlJljYrwLAAAAoBEEJiLIHyLoxLYc5SGJ8FpysOMAABAnbrElB4vRiB7/uIxQK9odFSYAIBwmKNGJ1VoBAAAATB8CExHkaSV9iZSIiLx2oLMDE2GFFmjJAQCIG7OA5yle/xA9/qoSPEbR7kqBCSpMAECQtCYgDAAAAKBxBCYiSGkti2YOiCVWR1aY8O8aDGs6nJYcAIC4MSXiaXeAKCoL1DJGQ5szFX0ITABAsEyFCTbIAAAAAGgEgYkIUlpLt5OUBX2HyGYqTEwLj5YcAICYoSUHoqx8fMhjFO0tWwioZQhMAECgzHjCY74HAAAAQAMITESQp5U4liWLZw7I1n/kWiMAACAASURBVIN7wz6cKacj0KPa05rABAAgVkoVJnj9Q/T4K58wRkO7c4stOXIhHwkAxIsZT1CtCgAAAEAjCExEkNJabMuSBX2HyPb0UNiHM+X8N65hTIhrrcXTVJgAAMRLrjCBTEsORJF/XMZjFO0uWwxMUGECAIJkNuho5nsAAAAANIDARAQprcS2bJnXO1N2pQ92XFni8hvX4G9izYR8WNUtAAAIQ7HChOqscQU6g6LCBDqIud5mXCpMAECQTCU1xhIAAAAAGkFgIoKU1uJYtszrmSmuVrI3kw77kKZUeY/q4G9iXVOikRtoAECM0JIDUeaFPD4EppJLhQkACIVHRTUAAAAATSAwEUFeoSXHvN6ZIiKyM30g5COaWv6WHGHMh5udtUzGAwDiJFd4/dOiKVOMyAk7UAtMJVpyAEDwNGMJAAAAAE0iMBFBalxgYkeHBSbKbmJDaIvhUWECABBDZsezCLvupls6l5X/78Evy1ODW8M+lLZBSw50ErcQUCMwAQDB8Y9vCQcDAAAAaASBiQhSWoltWTLfVJgY7bDAhO/tUFtyhBDWAAAgLLmywASvgdNpd2ZY/mP/Lnlx386wD6Vt+B+TBHrQ7nLFChO5kI8EAOJDMZYAAAAA0CQCExHkaSWOZcvcnn4R6cCWHL6bWB1CaKG4g5HFIgBAjJgdzyLlu/kx9cxYx1Oc53qVjQ8Zo6HN5TxacgBA0LyQq5kCAAAAaF8EJiLItORIOQkZ6O6THSMdHJgIo8KEosIEACB+qDARHDPWcQmm1M2/E5RdoWh3rs5fb7PKE08pGfNcufc/fktYDQCmUVn7V8a6AAAAABpAYCKCTGBCRGRe78xiS44rfv4defCVp8M8tCmhyvpKBv/zzW5PbqABAHHi+gMTVD6oi/+cNcKMdZr9+jhikQOdJOuVnvtZ5cr/eeM/5DO/vF+e3v16iEcFAJ3NK5trYiwBAAAAoH4EJiJIaS2Olf/TzOuZKTvTB2VvZkQefu0Z2bBrc7gHNwX8t61hVHkwN9FMxgMA4iSnacnRiNcO7JZjvv0/5KX9uxr+WjO+YaxRv/IKE5w3tDd/WCrjuXIgmxERkcH0wbAOCQA6nn/cxVgCAAAAQCMITESQp1WxwsT8vpmyM31AntnzhoiU9x9vVzrslhwEJgAAMeRfwKNVRG3bR4YkpzzZPjLU8NfSkqNx/oUNTds0tLmc755tzHMl7WZFRGR3ZiSsQwKAjqcIBwMAAABoEoGJCMq35ChUmOidKYOjw/LUrq0i0hkT7/6gQhgVJszPZzIeaE/X/+oh+W9PPhj2YQBtx7+Ax6672kyo02ti7GXGGrQ+qZ8/RMt5Q7vLKbf49piXk5HcmIiI7MkMh3VIANDx/PNLbJABAAAA0IhE2AeAifKBiUKFiZ6ZokXLY6+/KCKdMYHsv4kNpcKEosIE0M7+794d7BgCmuCvMKE6YDwx3Vppq9FK2CKuzLlKWHYogVpgKo2vMDFSqDAxOEpgop3d99IGOXLGHDlt/lFhHwqACjxFtSoAAAAAzaHCRAR5WolTCEzM650hIiJP794mIp1RYSLslhyezi8YEZgA2pOnFbvjgSb4AxMs5NempqDCRCeM24JSDEzYDqE4tD3/9Tbj5iRNhYmOcPOGH8vDr24K+zAATMI/ZvOHJwAAAACgFgITEeSvMDGvd2bZxzquwkQIP9/cOBOYANqTqxTPX6AJtORojDlHta43a5//pXzvpY3jvjZ/rjth3BYUc56Tts01Hm0v5wtMjHmuDOfyFSZ2U2GireWUK0nbCfswAExCh9z+FQAAAED7IjARQUorsa38n2Z8YMLVXqUvaStlN7FhtOQoLGJQohFoT0ornr9AE8pacrCDv6Z622p87+Wn5KHXynccm0l6l8BE3cyY0LEdAj1oe+MDEyOuqTAxEtYhYQpklUdgAogw/5iN8CUAAACARiTCPgBMpESLUwhMHNrdL7ZlidYiC2fM7oidiv4b1zAWPc055AYaaE+uVuKQ9wMalitrycFrYC0mVFJrvKC0mtBiTBerU7T/uC0o5jynbIcxGtre+MBE2lSYoCVHW8t5niQdAhNAVJVVM2UsAQAAAKABBCYiyFOllhyObcvcnhkyI9klfcmujuiF7b9tDWNC3KtzAQRANHlKUR8JaIJb1pKj/ccT003VWWHC03pC2WfztZ0wbguKOc8J22aRA20vpzyxxBItWjJeTkZy+QoTezNpcZUnCaoUtB2ttbhaUWECiDDTflWEsS4AAACAxrDkFEFKSoEJEZGVRxwnHz5qiTiW3SEVJkq/QxjT4S6BCaCtuVrx/EWs7EgfkDdHhlr+Pv62Xp0wnphuJgRRT4WJ8Z9TDExwnutmzlnSdqZkkeOO556Qr//+/7T8fYBmuEpJXzIlIqYlR77ChBYt+8bSYR4ammSqhqRs9pwAUeWvYMr9IgAAAIBGEJiIIKWV2FIKTPzPd50rV719pSRsuyN2Kpa15AjhJtYENsJoBwKgda6aWP4e6GTX/PIB+cwT61v+PlSYaIxXZ1sNT+uJgQmhJUejVLHCxNS05PjBa8/Ij7c81/L3AZqRU570J7tEpNSSw7Rc3D06EuahoUkmMEGFCSC6/OPb8dW/AAAAAKAaAhMR5Ckljj3xT+NYdkfsVPQvdIaxkOA/hyy6Au3H0x47hhAruzPDMjh6sOXvYxZ7REphAExOF1tyVD9XnqpSYYLARN3MeU5Y9pQEeoayowSDEJqc8mRGsltERDJuTkbcMTmif5aIiOzJDId5aGhS1gQmHAITQFT5x2OqA+bOAAAAAASHwEQEKdFlFSaMhD01E8hh05O8HZSyXQcsGAFtx1WKHUOIlVE3KyO5bMvfxx8YpPJBbaoYmKh+rpTWE6pWmfNL65P6met6wranJNB6IJthnIfQuMqTPl+FiZFcVhbNGBCRfAgO7SfnmZYcBCaAqFJUmAAAAADQJAITEaS0Ftvq3AoT+d/PKr4dNP/iBTfRQPvxtGIRErEy6uZkODfW8vehwkRjVLElR40KE3ryChOdEHQNilJKHMsW27Kn5PFJhQmEKas8mZEygYmcpN2sLJwxR0REdo8SmGhH5jU0QWACiCxP+auZMtYFAAAAUD8CExGktBbH7twKE0rrYg/f8Tsyg+BSYQJoa65SoVw7gLCk3ayMuK0HJlzlFV9/O2E8Md3MOWolMEFLjvp5hUCtbVktj88ybk7GPJdwHULjKk+6naQ4li0Hc2OSU54c1jtTEpZNhYk2lVWuiIgkCUwAkeXfEMNcDwAAAIBGEJiIIE+rii058hUmvApf0V6UlAITYdzElvW15CYaaDuVFieBTpZ2szLmuS2PAVytpMtJiAh9neth2kLUWnRXWk9eYYLzXDdVFpho7bwNZUeL3xMIQ055krBt6XISsm9sRERE+lPdMtDTT4WJNmUqTNCSA4iu8varjMEAAAAA1I/ARAQprcW2J/5pErbTGTtCtRan0JIjjGlsf1uTqeiRDSBYriIwgfjQWsuomxMRabktR055xcAELTlqM7sUa429PD2x6o35dye0UguK0vmWHI5lt9wy7UA2IyJUUkF4ckpJyk5Il5OQvZm0iIj0JVJyaHef7MmMhHx0aIYJLSYdAhNAVGk2xwAAAABoEoGJiDEp+EoVJhKW3RET70q0OIVASBiBBU+Xdui2OiEPIHieViyCITYyXq74djqXbel7uWWBCZ5DtZiJ9lotgKpVmGB3Y/08rYoVJlqtzHGgUGGCYBDC4voqTJiARF+ySw7t7qclR5vKeqbCRCLkIwEwGY/ABAAAAIAmEZiIGHODZyow+Dm23RELHPmSy2EGJriJBtqZqxTVYRAbabcUkhh2W60woaTLSYoIgYl6mHPkqVqBCTUhGGG+1uU8100VKpDZltVyoHX/mGnJwflHOLLKk4TtSLeTLAYmehMpWnK0MdOSI0lLDiCy/K/7bI4BAAAA0AgCExFjFvBNoMCvYypMaC2Jwu8Xxk2s/xwykQ60F621eFoxAYbY8FeVaLUlh6s86TYVJjpgPDHdTDCrdkuOyStMcJ7r52ktlmWLLVbLgVZaciBsrvIkZTvS5SRk35ipMJGSuVSYaFtZWnIAobv8sbvlsddfnPTjbI4BAAAA0CwCExFTbMkxSYWJTtipqEUXK2iEcQ/rD0mwSx1oL2bxiwkwxMWoryXHSIuBiVxZSw6eQ7WU2mpUP1eeVhM+pxS24DzXy4wPbctu+Ro/ZFpyEFhBSFxTYSKRLAZ4+hJdMtDTL6NuruXrOYJnKkykqDABhEJrLf+y5Vn59+2vVv0cg/tFAAAAAI0gMBExqtiSo3KFiU6Y+NW+lhyhV5hglzrQVjwWITuS1rojXt+mg7/CxIjv7Wa4ShUDE1RYqq0UmKh+rpTWoqVyhQlXe9NzcB3IU0ocyxbHmooKE4XABK8VCEnWV2HC6EumZGayW0RarxiE4OU8V0REEgQmgFCYsVa6Sos6f2UpAhMAAAAAGkFgImLMxG4nV5hQWkvCzj/0wqjw4JVVmAj8xwNogVlU1x1wLUTJ7c/9Qt770NfCPoxISrtT15IjX2EiKSIsJNfDjBdqnStPTawwYQKZBIHq52kllmWJZVktt9IYGjOBCc4/wuEqJYlxgYneZFexnYOpVoD2UWzJQWACCIUZa1ULEPvHbIwBAAAAADSCwETEVGvJka8w0f6Ta8pXYSLswAS7DoD24tKSoyO9dmCPbB3eG/ZhRNKoO3UtOVzlSXfCtORgErkWs5Ox1rnytJ4YmChWmOA818u05HAsu+XxoWnJQSUVhEFrLTnlScK2ywIT/ckuSdn5f2cL1QrG+/QT6+WO554I5DjRGFpyAOEyY6tqAWL/+IH2qwAAAAAakaj9KQiSqlphwumIiXctIk7h9xtfwjoItOQA2pcJjRGY6CwZN1d2bUbJ6BRWmHC1KlaYYCG5tlJLjsmvN7rQjmOywATXqvp5SottWWJPRYUJWnJExpsjQ/LG8D45ee6RsWllYO7XUrYj3YVrrohIj5MsVpjIThKC/+X2l8uu+4gO11SYcOLxOAaixrymp6tcI9kcAwAAAKBZVJiIGHOD51gT/zT5ChPtv8ChtC7+fmHcxHITjXa3cdcW2TeWDvswQuHWWSIf7SXjEZiYjH9SuNoEcT3yLTlMhQmeQ7XUE3owY4rxAVATSHE7oDJYUJTkx4e2ZbU8PjuQzYgIlVSi4KFXn5aP/Mv/L2OTVFToROZ572/J0ZNIimPbxeoEOa/ytSHrebweRlSpJQd7ToAwmIoR1Squ+ccPbI4BAAAA0AgCExFTrcJEwrY7pMKEFscutOQI4ef7J88p04h24yklf/qvt8u3X/hV2IcSCrOIEEZ1GkyfjJcTLbojQoFTLe1rydFKhQmllSiti4t3LMjVZkIl1RbdvUlCFcWWHJznunlaiT3FgQmCseEzz4G4VJcQyYceRESStlOs6tOX6BIRkVThGjxZhYkxL0fQJ6JMyIWWHEA4TABipM4KE1xLAQAAADSCwETEeMXAxMQ/jWPZorRu+zLa+QoTVvHtoJW15Gjzc4n4SbtZySqvuBgUN2bii0WwzjJaCAXk2I0/gSnNPjPV3VJgwrz2mcAEr3+16WIYYvJzpSYJVZhJfa5V9VOFlhxmvNuKobFCSw4CK6HLFXflx+e209X+wET+mtuXTBXfJyKSVZUrboxRYSKySo9lAhNAGMzYIJ2bPDDh3xDD5hgAAAAAjYjPzFWbMDd1ziQVJkTav4y29rXkCOMmljKNaGemJH82RqWt/cwiAouQnSVTCEywE2wi85wf6O6vWoK4llJgIr/bud3HEkFQdbQAUpOEuIoVJnhM1y3fksMS27JavhYMZQuBCR7noXOVJ7ZlVQyDd6pc4XrrD0z0JvKBiZotOZTLdSNCsp5bHKNkCUwAoTJjrmoBYv/rPveLAAAAABoRn5mrNmEmiCu15DAhg3bfdaREFydNwyirX15hgptotJeRwo6aOPUC96PCRGfKeFSYmEzazUm3k5SZqe7i878Z5tx2FxbvCKfUVk+VCDMxPz4Aav5NhYP6ecq05GitwoTSqliFSYtmh2nIckrFboE5VxijJR1/hYl8Sw5zLiq93rnK64hqgp3khl//QC772ToRKf+7AgieeT0fcScPTJjxQ2IKqlUBAAAAiBcCExFjbuoq7cIyFSbafRJNae37XYK/ifV0aYKSSXS0m3RhgiiugQkTeGIRrLNkCo/ndg8ETodRNyu9iZT0JlJVJ4hrMSXiaclRPxOGqHauiiEumazCBCGgeimtCpUIrJbGh8O5rGjRckiqW0QIB4XN1Z4kYlRdQqRUYSJhO9JdqOrTZypMFK7BlcZxY7wWRs729JBsG94nIqUKE3F7PANRYcZlY54r7iQha/Oan7AdXv8BAAAANIS7/YhRMagwkW/Jkf/9wljupEwj2hkVJkqTYzx/O4cpd02FiYlG3az0JpPSn+yqWoK4llyxJUehwoTi+VNLsUpECy05aAlRv3xLDlscyxIlzY91h8bSIiIyu6tPRPgbhC2nPEnErMKECUolLVu6E4WWHMlxLTkqvN6Zdmss8kWHq1RZkCVlO2JVuE8HMP38Y6104d5hPDN2S9o24XoAAAAADSEwETFmUtepWGHCKXxOe0+iaV9LjjB2uJa15AglsgE0L+3mAxNZFc/ABM/fzmRacrT769t0SLs56XFS0pfsaqklh1tsyZHf7cy5rq0UeqhSYUJVbtthvoaWHPXzlC5WmGgl0GPacczu7hURqqmEzY1lS45CYMJxpKtYYaKr+D4RkVyFcdxY4Trd7uH4TuJp5Wsb5sbusQxEif/eb7IQsb/CBPeKAAAAABpBYCJiSi05Ju5cSXRIhQmldTEQEsYtrH/inB3q0++FfTtkdJIdIGjcSCEwkYlphQmX529HosLE5NK5rPQmU9Kf7JKRlipMjG/JwfOnFqUrhyH8vEkqTGgxLTnae8wWJCX5wIQlVkuLHEPZURERmUOFiUjIV5iI1y2nud4mbad4ze0rVpgwLTmoMNEOPF+FiazyJFn4ewIIXlmFiUkDE6bChMNYFwAAAEBD4jV71Qa8ai05CpON7T75rrQu/i5hlElkwTU4GTcnZz60Wv7LI3fIwcKOT7TGTA6NefEMofh3a7NruHNk6Ns+qVEvKz2JpPS12JLDnNtUYbHH1YRTaikFJiZ/XJrP0eMW+Ov5WpRTWhVacrRWRtsEJmZ35StMUOUjXK7yYrcr3wQmEr7ARG+hwkTKqd2SwyU8GBmeLgUmcp5XbKkCIHj+sYHZRDDZ5yRsm8AkAAAAgIYQmIgYXaUlh1MIUXhtPommpfS7jF9gCEL5xDk30dNpzHPF1Uo27NoiF/zkzpZ2RyPP9Gsdo8IEgacOkVNeMSxIYGKiUdOSI5GSjJdreiHNLM6ZwASTyLWZsEO1czVZhQnzbx7T9fOUKrXkaCFoMr4lB7v1w+UqVWwrGBfVKkwkCxUmKrbkKFaY4PocFa5S+XFK4f9xq5YSdS/t3yUv7NsR9mEgIP4Q6mTzCuY1P2k7oWzOAQAAANC+uOOPmOoVJvKTjR1RYaIQCAljwdNjwTUw5ly/c94fyu8Gt8ljr78Y8hG1PzM5lI1pYKK8wgTP307gb9nDrtqJ/C05REqhqUaZc5u0bLEtSxQL+TWZthDVFtwna9th/s1iff1MSw7bslu6vg+NjW/Jwd+gloPZjJz2vf8pX9z4yJRfh3PKk2TMFplNUCofmEiKiL8lR/5+LluhJcdYIURBVZToMPfdY56bb8lh05IjSj73mx/Kf//Vw2EfBgLiD5NNFphQvg1I3CsCAAAAaES8Zq/agKpSYSJReF+7T6JprYuBkDDuYdmhHhyzSHHy3CNFRCQ9SelM1M+cw7hWmCDw1HkyvgBAjjYRE6TdrPQWWnKISNNtOXKFsUPCdsSxKFNcj2K7jSrnSk1SYcJU0KLCRP2U1mJLvsJEK61MhrKjYoklM1PdIsJu/XoMjg7LtuF9svqZf5P//ON/LguytcpVHhUmpNSSw7QnyVaoMFFsyUHIJzLMfXfGy0lO0ZIjag5mM5KJaZvCOPKPtSZryeGvMEFgEgAAAEAjCExEjJnUtSpWmMj/udp9Ek1JqTSvCqElhlKln8mC6/QyC0W9ifyuurhWRZhKZjdNXAMTblmFifa+FiLPP9Hd7oHA6TDq5qQnUaow0WxrI9e3gNdqy4O4KFWJqNaSoxCqGDeeMY9lTytKQtdJaS2ObYtjWa1VmMiOysxUV2msyXWlJnM9OH3+UfKbnZtl464tU/a9c0oVQwJxUQpM2NI9rsJE/jFuS65ChQlTdYLXwugwz42M50rOcyXpxOuxHHVjXo77+Rjxj7VGcpUDE+ZzEjYVJgAAAAA0hsBExJgFQKdCYKJzKkyUfr8wFhFc3w7mMAIbcWImKUxgIq6L/FPJlOOvFT5J57Ly5vD+IA4pUGUVJnj+dgR/YCJHS44J0m62LDDRbIUJE5hIFBbrCBzVZs5RtXGXN0mFCf/1iQn7+nhaiV1oGdNsVQittfx252Y5vH92caxJOKg2c45OHFggIiLZKbwWu9or3sPERel668gR/bNkZqpbjjnkD4ofT9pOxXM8Vng9dKm2FBnFwISbi2X4J+rGPLft50ZQP/94Ku1WHg97ygQmnAlhVgAAAACoJl6zV23A3ATalQITnVJhQmuxCxOnYdzE+idV2PU5vcyEb29hV91UTsDH1UhhcihTIzBx+3O/kLN/+L+COKRAlVeY4PnbCfwtOWhfUE5pJRkvJ72JZPE6mm62JYevRHHCpiVHPcw1plq4ZLKWHP5/t/u4LSillhzN7wr91y3PyXN7t8vlJ5xRHDfzWK/NPI67CtUQ3Ckcr+Vi2JLDjHdTtiPzemfK8xd+Tk4ohFFERLocp2LwdUxRYaIZrvLkd4Pbpul75/8WY55LS44IGvNcXmNjpKwlxyQVJkxgNdHCWAIAAABAPBGYiBizi8WusBPLKbyv3ReUlOjiTrMw7mH9E+fcRE8vs8OjpzABP0aP2ZalC5NDtap17BtLy+Do8JT2IY+CsgoTPH87gj/8w6R3uYybPze9iZT0J6aqwoQjtmWz674OxcBElXCneZ2rFpigmkd98i05LLEtq6lzprSSL/3up3L0IXPlnKPeXhxLc/5rM4/jbichIlNb7ceN4a58//W2kqSdqHiOTYiCkE9jHtn6vHzwh7fJ9pGhKf/epZYcOckpN3aP5agb81yu8THiH1tNNh42j4ek4zDWBQAAANAQAhMRYyoeVGzJUdwp1943frowIS4SziS2y4JrYMxjNeUkxLHsYm9mNG+kMDk05rlVK6SYYNW+sXQgxxUUf2CMBYXOUF5hgmuEX9rNB6R6EinpMy053Mo76moxi3NJ2xbHsnj9q4MJSpjF5ErM65wWXXZN9r/d7kHXoHhaiWOZljGNPz7/dctz8uL+nXLV21dIwnaKQWNeK2pzJ1SYmLrHbL7CRLxuObPF6+1kgYnKLTlMYILwYGMOZjMi0nygsJpShYmcZJUnyUKoCNEw5uW4xseIf+4oPcl42FToSdoOY10AAAAADYnX7FUbMDf81StMtPeCkpZSS45quzani7/MbRg/P07MQpJj25KapPwwGpMuLC5r0VUn1M253z82EshxBcXz9fWmpU5nyPgqz0zlruZOYCaDexNJ6S8EJpptyWEWfcxCMov4tZXabVS71vpCEr4xhX98weJnfTylxJJ8hYlmFsCeGtwmXU5CPrj4bSJSCh+3e9A4CKWWHNNRYcKL3a5817dgV0nKqVxhwlQP83gtbIi5xk7HGMJcP8Y8V3KeJ8mYhX+iLuO5jGdipLwlxyQVJsRsQLK5VwQAAADQEO74I6Z0g1epwkR+0q3dJ36V1sXwRzgtOagwERQTTnEsS1J2QsYUgYlWpd3S5FC1thzmcb4307kVJijB2xlGyypM8Df1KwUmUtKXTIlI8ztoc74dz/kFac51LWaMUG3xXk0ypvC/7fG4rosWLY5ti21ZEyp21ONgNiOHpHrEKSxo0pKjfuYx3p3IV5iY6pYccaswUWrJUfn3TtmVQ8RZRYWJZphr7HQGJjJuTnIxDP9Emdaalhwx4w+jjuQmqTBReD1L2M1VqwIAAAAQX/GavWoDZsLHqhCYKFWYaO9JgXxgotCSI4wKE1pJohjY4CZ6OplJxoRlS5eTqLrAj/r4J4fGfDvzxzPXkr2ZzqowUdZShwoxHcFfYYJFonImTNKTSElvIiWWWE0HJrxihQnT8oBzXYuZaK9eYaJyYMIre5tzXQ9Pa7ELFSZEGg+1HsxmZEaqu/jvYoWJKi1VkGceo93FlhxTt/Acx0Vm024jZVdu35B0nEkqTOTfR8iqMWbsMB1VGEstOVzJKm/SvymCV6zIwmtsbJRVmHArj4e11mKJJY5l89gAAAAA0BACExFjJuWdCi05zC6ldr/xU7rUkiOMwIKnVLFaB7sOppeZwLQLgQlacrRuxM0WS2abifVKzLnfN9ZZFSbKWurw/O0ImbIKE5Qh9zMVJnoSSbEsS/qSqUlLENeSK7SzSVpOYRKZ508t9VWYqFxVQvvGaix+1kdpLbZtiS3NhWoPZEdlRtIXmOiQcXMQzGN0elpylMbdcVG7wkRCshXGcNniAjDX50YEUmHCy8WyvUyUlVrYcI2Pi/KWHJNVmFDiWPnwJfeKAAAAABpBYCJizE2dmSz2S3RIhQkRLZZIvuRyCDexrlaScpzCkXATPZ2UKpXETDmVJ4fRmFE3K7O6ekWkRoUJ05JjrIMrTDAJFmnP731TdqUP1vw8f4WJ6VjsaGejvpYcIiJ9yS4ZcStPENfiFitM0JKjXvVUmCgLSUjl8ASVU+qjtBLHsotBh0av8QdyGZnpqzBhwrksPtdmrgcmMDGV9xr5ChPxfMGNdAAAIABJREFUuuX0t0CqJOU4xfYbfuZ9nlZUwWuAucZOxxhifIWJpBPvwMSbI0Pywr4dYR+GiPgrTPBciQtzXexLTB4gzm/OscS2bOZ6AAAAADQkXrNXbcDc8Dt2hZYchcnGdp94Nzexllih3MJ6ShUnMFlwnV5uYUezY9n5fs0VJodRv5zyZMxzZU4xMDH5+Sy15KDCBMLxX392t9z6zL/V/Dx/hQl2CZZLF3bP9SYLgYlEqvi+RpUW8Ox8X2faFNRUT4WJyVpylLfn4HFdD08rsSU/PhSpHlSp5GC2PDBRbP/G+a/JPMa7p6PChPYkYcVrkTmnPElYdsUWiyL5IEXllhylcR3XjfqVKkxM/TnzV5jIeZ6kYl5h4ku/+6lc+fP/HfZhiEgpOM5zJT7M33pGqrtYhW3i5+SrmdpChQkAAAAAjSEwETGm/LBdqSWH2SnX5gtKpdR/ODexnqYlR1BKAaB8hYlqC/yozSyUzq4nMEGFCYRsxB2bdDLTL+N7HFNhotxoYTGgx0mKiEh3IllWkaMRpRLxDn2d62TGZNXOlTdJSMLfTqLdx21BUVqLY1vFtnSNXuMPZjMyoywwQUuOeplQSXcif62ZyvZIWc+LXUuOXI02JEnbqdqSQ6QTKgoGxwS0p6Otl+erMJFTbuxbcqRzWRlxm2sNNtUyXqkiC+LBjK1mJLsnbcmhtcrPNdkW1UcAAAAANITARMSowqSMXWFHUsdUmBAtlpVvOhJGmURPq+LuIMo0Ti8zyehYtnQRmGiZKcU/p7tPRMon1scz534/FSYQElepunZ2Z7xccUc5C0TlxleY6HISZQGTRuRoydEw8/itVhpfTRLi0rTkaJintVhiFcfAjS50DGUzMjPpb8nR3PeJI3PtTdmFChNT+Jh149iSw3OL7f8q6XISFauuUWGiOebxm53iwITWunj9HnVzklXxC/+M52kVmbFascJERI4H08+Ms/pTXZMGdzytxbEsKkwAAAAAaFi8Zq/agEnNO1UrTLT3DlytRSwRsUKrMKFpyREQM9lrAhPVFvhR26hbf4UJt1hhorMCE2YXoQhl1qPmsddflPUvbyz+W2lV10Jlxs1JfyEQwMJyOVOhozdRCkyMtVhhImnbVJioU6klR5UKE2UhrtLb/sc+izn10VqLY9nFoEMj1/ic8iTj5ca15OiMymxBKI7XbEuStjOlO/VdXb3aQidytarahiRpO5KrVGHCd96jsijdDszjd6orTPjvE/MVJmjJobSOzGNzrFhhgvv5uDBh1BnJ7uJzcjx/NdNqgVcAAAAAGI/ARMSYG36z29bPKUzQtPuCkpb8TawlVij1HVylCEwEpBSYsCRlJ6Z851fcjOTyO2lMhYnqLTnyj+29mc5qyTFZ+XuE754Xfy1rfv948d+e1nUtyo+6Oekv7AqfjnLa7cy05Ohy8ru+u52kZNxmK0zkz61j2eLYtniK508tpcDE5Oeq7Jokla9PhFPq42klju0PTNT/GD2YzYiI1N2SY9TNyace/65sHxlq5ZA7hjnXjuVIwrYrLuY3K6e82LUxyNWoqpG0nYpjYv+4jlBo/UwFpakeQ/ivHaNuVpTWkqxSOSQOlFaRmYswFbd4rsSHea0yr/XpCm05lFZiF8KXjL8AAAAANILARMSYlhyOPTEwkeiQnXLlqf/gfxdPewQmAuIVS8DbknIcKky0aGRchYlMlZ3m5tzv67AKE2W7uWmpEyn5Fhzli8SqjkX5jJeTvkKFiUo7xeJsNJeVnkRS7MLrf2sVJvJhQavw+ssCQ23m8VztXE3WksP//qgsLkWdaclhgg6NjNEOFAIT/goTtj158OKVoV1y/yu/k9/u3NzCEXcOV5UCrknbmbJrsdL514XYBSY8r+rCespJSK5CSw7/OJnrRv1M9cWpDmb7F1sPFkLLyULbmrjytI5MtUsTMOK5Eh/m3q8/2SUipXtjP69YrcpmrgcAAABAQwhMRIy5CbQrVJhIFHYqRaUMZrOU1mIXamiEcQvrKV0sDcyC6/QyE1i2ZUvKSRR3AqE5ZhfN7EKFiWyVHaCmdUXazcqo29wCaxS5qvLiJMLnjtt1qOqsMJHxctLtJCVh2W3/+jbV0m622I5DRKQ7kWz6Ouoqr7gQnW/JwfOnllJgos4KE763tW980e5B16BorfJ9xwsVJhrZGVqsMJEsBSYSVSpMmIW2HAttIlI6R7ZlS8JypmwB0uz8j11gQntVW3KkbKfiGK4sMMF1o27m8TrV58z//YYL1xhacuji8zpsmcL9jdKa1gsxYcZTJhxpqi/6+TfnMNcDAAAAoBEEJiKm1MJg4p+mWmnhdqJF+3a4Bn8T62klqcKuLyZXppf5+yZsW7qdBBUmWpQeV2Gi2k5z/3Ork6pMeLq0wMAO+WjxlCr7m3ha1ReYcF3pTiQlYU/dIl2nmBCYaKHChL9EvEOZ4rqYx3P1lhyTVZigJUejvOIiRzMVJkZFRGRmV0/xfdXGzcXABOMSESk91hO2LUnbnrIKE6ZFQqJKe4pO5G//V0m+isf/Y+/dg2XZ7vq+71rdPY+993ndc690HwiQBLEFIsTmEQJJVQrnQUiCKRxTpMqJU3ZV8odTrhBXGZdJxQ6p4CixCxeV2CBDHBwKHFCJKAYpgMTDoAdCQhK6uldI96177zn3nud+zqN7rZU/un+rV/d09/TM9Ozp7vl9qqRz7j6zZ8/u6Vm9+vf7/r7fxXNv5nyN1436UBO1aZcqd09yEsaCiX0T/+TRNfd2l0E2wobv6fcBk3eYKBBMKKPjvQQE13oYhmEYhmEYhlmJ/apedQC62ZcFhcU+OUwIG8mxG8EER3JcDqnFs8RA+pgXFIeZ+lBRKBVMlB9Pd514ODvf7gu7RLblMPHs/du9EpbsAlcgYYyBTv63DHKYCKRsPH+860yiEGM/sP899ILKz30VkdHWXSm2Ke72XuIyoMnE6kgOx1WiTDDR8X3bZaGMTmy0y6M0yqBm5lXHYUJawcTi81grd35vAKTHyBMyFq81tBZTA3vfmsyhiiojOQLPL4yPmLHDxFqQsCGscF5bB5VxmEgiOSre131AGdOac9MVkLLgdj+gfQG5SRVFchjHYaIt4h6GYRiGYRiGYboBCyZahhVMFERy0KRclwsCJvP77cYmMdJp04gFE9vFdUwZsMPExlBR6JFRLJioEqAoo+1k+v1pf4QAZdPcm/JDv/5P8DNf+P3Gnm8fUUZD6WyEQS3BRBRi5PvwGmzS9YWLaI5xzmFiumbETuwwEV/7fMmRHHWg87eq4O6KKdw9jXvud3nfdpnENtoSnhVMrBHJMUgFE55MnqeguUeNaRZyxlBjWAoBX3qNWe5TY9XfN8HEEoeJYY1IDm701YfO38g0LJhw3oNTdpgAEK/LBqYVQsCsw8TuXw+zfaxgIrnWX5Q4TMTiS8m1HoZhGIZhGIZhVoIFEy2DbuqoyOtCDhOqww0lKwjZucNEYvfMuZZbJRVMiMRhorvnbhuYkGBieAig2mFCaY3HxlcAAPenPXWYaPDzezqf2oYbsx6RE8mhcn9WkXWY4IK3yyQXybGRw4RWdh8hheRmXA3qCH9UiatERjDB53Ut3NxxoDoKJc9JkWCiwmFizg4TGVyBa5NuP+G+RnIYVR3J4XmJyDB7/rkiCl6j60OitCIRyia4788pOUzsuWCC1tM2CAFnGYER39PvA6nDRBLJUeAw4e4lWDDBMAzDMAzDMMwq7Ff1qgNQcay3DhNJgzP2lxA7kSsoo+GLuNhlOnwsu4BbgB/6PmYq6k2WqDEGn3zjpUv9fc7DOTwhbW7rtCqSw2g8Nj4CgF5FTURbcpgIdXsymbtKHMlBE/krOEyoOHbCF17j06Fd5yIXyTHyfERGr9XMdCeePS4i10Lnzuciylxvsn/ntaUO2hh4QkAk+92VIjlIMJFcHwE4wosqhwlec4D0GPlSIpCeFTpsSrSnkRxzpSpFIoH0AWDhOM91hJEXr/ks5qmPdZho+PMcFThMDPbsXM5D9/JtcATLRtjs/vUw24fE8lcHYwDptT/zmMStSgphz1eGYRiGYRiGYZg6sGCiZVBRnXKXXYQQ8IRshQXmuqQOE3Jnqn+lNQYeCSYu/cfvFXSuelJimBSH+9Kc+ON7r+EHPvhT+MirX7y0n3keznAYDCCEwNDzMYvKBRPaaNwcxU4U92f9cZhw17+mmpBKx/bC3JzYjEgr23TLO01UMYlihwlfysZs4PtCkcMEUO0uU0bsMEGCieYmyPuMzp3PxY8pEUk4RfouC10vE2U0pEwjOVZpdJyGUxz6g0z0g2eFF+WCCf4cxLgOcE0KJsI9jeSIdLXDxDC5D8nviacqsmt+l+/3LhtaY5veQ7j7wnBPxT95UnHK7s/PqUojylgEuh9QxNZj4yvwhMSt8+PFxxiDwGgM5xe8jjIMwzAMwzAMsxIsmGgZbsGyCF/KThfe6fcTQkAI7MRtIDLplC1HcmwXmsr1hLQilfmadvJt4zzJTP2Xr3358n6m0zwden5l9nqkNUZegGuDEe5P2WGiznN2eW1tA8oYRyhBk/k1IjmiECM/gC89LmzmuFgQTMTCM7dJUJdQK/iCIjkE21fXwDpM6AqHCeecdRv8bpOez+vlWMEwhHVZW8X152Q+zcRxANWRHPQZakoY0HWo+ekJCV96jTVDyTUoKBCC95lwiWAidZjI7uPmKsJBkDhM8J6kNiR8yh/PTaE1yH0vg+Q6vK+ssr9bl+PZpJYoepqJ5ODPSxH/6PO/i4/een7XL6MxqHYz8Dw8cXgVr50/XHiMMhr/7gu/j+/5pf+Gaz0MwzAMwzAMw6zEflWvOoDbYC6i6w4T1EyQIi6IX/ZNrDEG2hg76cbTKNuFCpielBhYh4l+CCZI7POx2y9c2s+cRHMcJnbjQ8+vnDJXRkMKgRvDwx47TDQkmEjOU7bN3wyltW2ypU4TdSI5YgvyQEpuXuaIIzlSwcQoieeocpcpI8pEckg+32tAe5SqvUpVJAdZt++rOOWlk3u4Nz2r9Vht978CUq4eyXE6n+JqTjBRFckxtw1WXnOAbIRak2sxXV/3zWFiuWCCRMS5SA4V4dCP93ldvt+7bNSWHCboeV3hIkdyxOvyttbOi3COb/+lv4d/8eLnlz525ohH2+B40Ub+9z/+bXzghc/t+mU0hh2+gcBTh9fx2lmxYOLa7AyjyTHXehiGYRiGYRiGWQkWTLSMvjtM0D2rAAAhLt1hggpfAxZMXAo64zARCybWafS1EWqgffHB7doNoU05D9Np84H0M4XCPMpo+FLixugAD3vlMJEWaJv6/FLRl4utmxEZbRvD1mliyTENkxiPkecnU83cvHSZRHOME5EE4DpMrCGYMDoTybGvTfxV0Lnzueox+b8bY2xTtMv7tk34qx/5Z3jPp3+j1mOV3f9K6zCxiqjnZD61meZEGsmxeK7P2GEig92vSdnoWkwN7EDu1y1npHWlSIQiOfLn31wrK5Jz9ztMNZGNiWj2mNEe5igRKwMcyUHHZFuCnrNwhvNojlfPHix9rCsc53v6YmZK9cbdEcjWyp48vF4YyWGMgQQgkkEZhmEYhmEYhmGYuuxX9aoDWEviEsFEnDve3cK7zjlMrJJP3QRUkKci5i4iQfYJahL5QtpG36wnDhNuAebjty7HZeI8mmUiOaocJiKt4QmJR4aHuDftq8NEQ5bhOVcEZj2U1o5Qgiybq9fYaRQ3LUd+AF90WxDYNEprzJw8ewAYebF4Yp1Ijkgr27SUUvD0cg3SSI7yY1XmMKGMsdbtak+b8g/nE9yvef1xmyCeEJmv1eE0nOJKkIvkkInDRMH7R9dPFkzEpA4TAr70GpvU31eHiXnNSI55puGrEWplRXIsaqtP6jDR7OeZ9iSHQXodDrz9Opfz0LHe1n6N1oyLaL70sTOO5FjKXEeV94tdwzh7haeOruPWxfHCNV4Zg/jyz4IJhmEYhmEYhmFWgwUTLcOdyC/Cl7LTBQG3IC5E6jhxWdANtXWY4FzLreIKgEgwkbcf7ipuAeayYjkuwrkt2taJ5PCExFEwxHmNomNXiJLfC2gwkoOKv9xA3ojIqIVs62WiFmr8j7wgmWrm94CYJMfGFUxY4dk6DhNaZRwmuIi8HCsAqjhW7r8ZZMUT+x7JESq19FydqwhfuPe6PdaekE6URv3jdlIYySGT5ykXTPCaExM5xz+QskGHifh59m0q3xWoFWEjOZzjPEv2x7Tms6itPvQ5blwwoUkw4ThMiP06l/PQ3mFbjmBh4qxCgtoq3Md0uT6yLSKtoI3pTRwmkB2+efLwOkKtcCfn9KiNiX2q2GGCYRiGYRiGYZgVYcFEy1C1HCa623CmgriAgBTi0m9iqSBM00F8E71dqNDoS2kbR32xBaVz5+boEB+79fyl/MyLaO44TATVgglt4EsZx/h0eM3Io7S2jYamBE90fLjYuhnKGEcokRVOlOE6TARS8rS3w0UYC53cSI6RjeRY3WEidD47vui2+PKyoPO4yg3LdarKxHMgjeToe+Pz/vQcf3TnlYWvz3W09Fx9//Ofwff+i//NOiFJIazQYSWHiQLBhFchmJhbh4l+7Ek2RWsNAQEhBALpNbYWu/vAfSIWTPil/z4oiOSgc5KEsVUT/LcvTvCTn/stdspLUFsSvtLzHvqOYGLPHSasYGKNPcT96Tk+/ebitcKF3sOVHSZ6fp1dBxpSWCfGra3Y4RsIPHV4HQDw2tnD3GM0BOIIWAPD6yTDMAzDMAzDMLXZr+pVy5hEIV4+vZeZjogV8XHBsoiuO0zQ7aoQAmInkRxUuCXBRHePZRdQzsTiYIPJ6DZC5853PfFOPHd8B3cmp1v/meehK5jwljhMKHhCJtba/WlCR0bbqc2mBE90fHjSeDOoWK2NXhBOlEFF3JEXdF4Q2DQTFTcLMpEciXhifYeJJJJDiE7vJS6LTSI5jEkFE32PmvnZZz6Kv/ih9y58fudquWDi9sUJlNF4MLsAQIIJiuSof9xO5hNcWRBMlDtVTK1got/vTV2UMXZ9aFIwsa8OE/MlDhODgkgOmgIfW4eJ8vfgAy98Fv/LH/0Gbp0fN/FyOw/t35qepLeCCSeSY7Bn53KeVJyy+hrxT5/9GP7ih34akwr3iHDtSA5uiuehGMy+DCsAznCRlHgyEUy8fp4TTMAkRc74nOABGYZhGIZhGIZh6sKCiR3yyTdexHe973/F5++9Zr+mjSl1lwAAT3Tbstw4UwG7cJhYiOTgG+itorRO4lfSSI5ZT6Y56dx529EjAID704ut/8xQKys8GXpBZQFMGQMvcfbo8pqRRxltpzYbi+TQ281j3hfo+BU5TZQxSQriI89HID1+DxwuwrihMA4KIjlqWFXnCbWyTUuPHSZqkTqlVEVyFAsmtCuY6LkQ6OFsgpmK8JrTtDDGYK7VUlv1h4lQ4iycAYgFE6vGLk2jEHOtSh0mSHjx45/6ED76+nMA0kZb2JOYsE2JjLb3H03GI9G57+9Zk9mNQCqCXArmGYeJbCTHMocJII1u2ne25jCRPJ8rXNw38U+eNJJj9WN9kazVX374Rulj6JhXiSqImeJIjiroPrEvwwpAtpb01FGxYEJpHRc5k8dyBCvDMAzDMAzDMHVhwcQOKcqvVUbbibgiuu4wYW0URWyUeNm3r3Ts6NhftsPFvqGMsQ0LavT1ZcqFii8jP/69LsPWO9SRPXeHnl9ZAIu07qXDhNLaWlk3LZhgO9/NoGlYpXX9SA6VTtQ22aTrAzRdOfbcSI747+vYK0da2waeJyWU5uvfMmidr7J0zsdwpF/XvY3/Op1P8ROf/bBthpOLxEsn9+xjaG+7rFFzPJ8AAM4TwYQnpG3c193vnoZTAMCVICeYSCb8aW3/2Wc+iv/vlWeS1xW/5j5dHzdBG233a03GI5GDR5XbQh+ZOwK1Iki47R5nOicphqlKqHX7PBFM1JjC3wci6xTW7OeZRCtHgRvJUR61sg9sEslB4rVnH9wufczaDhO8f1yA7rn7cu8NZGtJVwcjXAmGi5EcMDaSw/0ehmEYhmEYhmGYZexX9aplFE0exg4T5W+LL2SnG0ruTa4U4tIzJZXOCib4Bnq7RE4Bvsh+uMvQuTNMGpjzS2i6hDqNo1gmmFDJsQ9kv2IOIqPtudScYCIptJv+HKddkDpMpJEcyyySafp85AfwG2zS9YFp0iw4KHKYWGOqOORIjpXJO0YU4R5HkxNP9DWS46O3nsc/+MyH8cz9WwDSz/HLp/ftY+havyyS43gWCybOCgQTddf403ksmLg6GGe+no/kiLS2DWaa5uc1J0ZpbdcHX3iNXQ/30WHCGBM7glUKJhKxrbOPm+UcJqoawLcv4iiOOlP4+0AaydHs59k6TDiCCY7kWN/Ng77n2eTaUfWYOmKgmYrsvoj3NIvUFS52iezwDfDk4fWMuxU9RsCkDhNc72EYhmEYhmEYpiYsmNghqWDCtXPW1ZEcHXeYIEcHAQGBy3d4oKaFz4KJS0E7jikUJXEZwoLLwFjBBBW9L0MwoWwcxaCGYMKXscNEn5p1SjtT2w2tH2HSGOL1YDPc+AJyL9BLHSYSwYTnw5ceTwg60HSlawU+3MRhwigEIo3kWPbeMNk1oWzv5Tp15AUW1Fjr23lNx4KatanDxF37mHniujSNVnOYEImgFqi/Jh9bwUTWYYIEyMpomCQqiCIM6PrZJ0HhJihHsB07UzVzzoa07xb702QOtYI2BiM/KH0M7WNmbiRH8pk5DJZHcrxxcQqABRNE2sRvWDCRPO8hR3JY0kiO1Y817TueqRBM0J68zrk9VWEqMOI9/AJ0nZv3JA4TSO/9RLJPeOroOl4/P84+xhhICOtlyvtdhmEYhmEYhmHqwoKJHZJGcqQ3sdqY6kiOnjhMUEH8shuUygom4lOfSyvbJXImFjeZjG4jOi+Y2HLThSYW3eM5KymAaaOTtUQi6FkkR2R06hDTWMb6drKv9w0bbWK0LU4ujeRgh4lSLpJj4womqAG3nsNEuh57QnBzoQZukb3seLmPyQsmaK3qstC1CBIMkvigyGGCpuWXOUw8TBwmTq3DhLCN+1UdJq7kBBPx80loY2zzeRLOk9cXv66+iDg3xY0EbNKZip5nnyI5qEk5rIhusJEcjth27kRUAWnMVR5jDN6YcCSHy7YcJuh5Dx2np31ySylCN+Ew8eB2qcskCQzrRHJMVeQIJvp1nW2C1OmpP4IJOm8kHIeJXCSHMjpT5GRBPMMwDMMwDMMwddmf6lUL8QscJuIJr3LBhBQdd5jIR3Jc0s/97J2v4L1P/54twgzYYeJSiB1TkkgOK5joR3OCJlxGl+ScQc0eOnerIjmosecJAV/GzaK+TNcordPPb0MrCDV0ury27hqa3gbiz72N59DV71HqMBEgaNAGvg9Qs2DsTCmnwrM1HCa0sg38ru8lLousAKLEYcIVTCArmPB7GslBx4WatRPrMHHPPsaN5KiKX3uYc5iQQtjGfd01/iRMBBNBkWAijp+hdX6SE0qww0QMxXgB5DDRzHEJ9zCSw72ulUFrcajdSI7479QALls3Hswu7GMnPREhbwrtHbbnMMGRHISNOFrjukbH88HsArcvTgofQ2tGHYeJmYqsmIX3NIvQda4vcZhA+j57iQjvqcPruD87z4jH4kiOBGO43sMwDMMwDMMwTG1YMLFD0mJZWtxxG8xF+B2P5KDi9/D0TYzD6aU1cd///Gfw45/6kC3uUKxBVRGf2RxljOOIkDiq9KRoQwVDKoiHW/697JRm0jAdekHplDkJgzzpOetMd9cNl8hoK75pqgCWOkxw42xd3OuS0lnxRBU09TbyAniy2w5KTTMpiOQYSA8CYi0b9kgrW2CmqXummrxjRBGq5DE6EcD6QvYwkoMEE4sOE7Svor2t6+5QxHHiMHFmBRPSWm3XPW6nJZEc9HzKGHsNvEgcJug1s8NEjHYEEwPpNbYW0/PsU4yB65xUho2pc0TEecFE2fl/+yK1n+dIjphtOYWlDhOxYEIKYa+j+4qNX1tj7XT3is8+uF34GNqL13GYmKkQB4mYpSnXuT4xy0VQ9QGdd5g4ug4AuOXEcriCCYHmBPYMwzAMwzAMw/Sf/b7j3zFkT5sVTFQ7THgdj+SgQvrX/cJfx3/4pQ9fWsNmokJERtviCx37vkzdu/zylz+NLz98c9cvA0Bc9LIOE5KcGPpRtDHJuTO8JIcJKqrTuTuUXqbQ7mKjZ4S0ueF9EQNE2onkaGj9CO2kcf/Wg8si65SkoRNniWWxD25jKWiwSdcHKJJj7AgmhBCV7jJVhM5np+viy8vCLbKXHS93H+GKMA2Mba717bym42IFEyr9843JKYCsOHJa0tSdRqH93jMbySFt497UbHLMKyIQPCFi15ucwwR9hvpybdwUpQ08Gd9/+NLLRCttQmQdJvbnlnOVSA53T0x/TyMGis//2xen9u8cyRFD63PTe3GVOFeQi8E+CX/KoGO9jhBbGYPrwwMAwDP3bxU+JqwZyWGMwUxFOEiESX1zcmoCuk/sy7ACkI13BYAnD68BAF47T2M54kiO5HHoj8siwzAMwzAMwzDbZ3+qVy3EL3CYUMbYQnHx93S7yUFFdm92inE4ubSfS0V9ysoOGrb0bxM/8rH34xe+9MldvwwAiSX5QiRHP4o2VLAZJg4T24/kIMEEOUz4GZtxFxvJIYVtUvRlilYZZRsNTTnEcCTH5uQn6+lYLjumdP0LpIQvZWM28H1gEs0hIGzsDzH0fNtkXoVIKyugkkJAG8MuS0twi+xlAi336yr3+DheQvauWE+CQRvJEYV4bHwEAHjp5C4AYOY0gsvO1+N5ug90IzlocrSuw0RY0ZT3ZOzwkbd5p70IrzkxkeMw0aQzVbrG70+juVYkR7Kuu+cfNTdtJEfJuckOE4vtQDcVAAAgAElEQVRsyymM9tOHyXuy73EcQHpdXGfPrLTGjeEBnjq8jmcfFAsm6D2cqajy2hkZDW2Mdf9YJtDdR6ww0OjeOF2RkJIGjG6ODgEAD6YX9jGZSA5wBCvDMAzDMAzDMPVhwcQOGSQRBaFyHSZ0pcOE33GHCXvDauKT79IcJpKiPlk/+w1PqLeFuYow16o1BVS3AE9Fxr4JJshyeduRHFRITyNO4p9bdDzJJtcT0jYp+jJFG2mNIFk7mxI40FRal9fWXeNO9imjnUiO6jXWWusKmVzf+nGeNsFFNMfYD+wUHTHygw0cJtJIDoBFQssoE0O4lEdyaEjEorW+Tb7S7+k6S/yp648DiGM5gHoOE65g4tQ6TAjrdFBX1GpdlQqamRTJEeWmlmmavy9xVevw+vmxdfZwIwFpn9HEekzHvei96SvTKImaqorkIIcJ5QomEoeJIP6+sjXn9vmJ/ftkDfFcH0ldD5rdQ9D5e5A05Um0vM/Q+r/OnlkZDV9IfMMjT+CL90siOZzzvup+lq4rB4n7R9+EiU1Q5GDTddL7hnifcG0wBpDdT2ijWTDBMAzDMAzDMMxabCSYEEL8sBDiC0KIp4UQvyiEGAkh3i6E+AMhxHNCiP9bCDFY/kz7ibXKNytEcnTcYYKmWQUMhKlvt7wpqcNEPH3gSwkB0bsb6HM77dkOi15ltM36JSv5shiJrkGNnGHBlOA2oMYFFdmHFY4dVGz0hLTigr40hZTRNt6lqc8vFX27vLbuGjfLOtLavjfLCtjKnqsCvvR611jehEkU2kljl9EakRxKaxgY27RMBRP9ugY2jeuSVLbe5F0l0q8bSCEhOy50LYLOGxvJEYV457XH4AuJl0/uAcg2gsvOVxKxAq7DhITAaucnXd/8Aoc2iuSga/Q02R+lDhP9aCKtww9+6L34yc/9FoD4WPsLDhOb72tcF6F9YZaIGKoiOYKCSA46J8fWYaJEMHFxgkdHRxj7QWsE0ruGjlXTe3Fa349IMOHtj/CnDGUFE6sf60jHgyE3R4eZBnf2MenzVsVy0OfFRtj07DrbBBnhYs8GFsiJigQTD2eTzGPoiiOM4b0uwzAMwzAMwzC1Wbt6JYR4CsBfB/Ctxph3A/AA/BCA9wD4CWPM1wF4AOCvNvFC+0iR5a1eFsnR8Qlce7tqDIQobkAYY3Bvetboz7UOE0lxxhcSUoje2ZFfhKk9dhtQWsNzBEAD6fVuwoUK4tuOvEgtx+N1oyriJI3kkAhEfx0mmorUoWPbt6bmZRJlmsbaieSofo+UK+6RHr8HDhfRvEQwEZRO7JeRt8UnYSZPZFajTSoyKTuX3WPoikBNIoD1exjJoa1gIt1zHAVDPHV0Ay+dJoKJFSM5zpxIDnKYqLtHUxWxD551mIgfc7EQydGv92YVHs4nuD89BxDv12hd8K0z1ebHJtIqjlmpuLfpG9SYrIrkEEIgkF6mwU8xNrYBXLJuvHFxgscPrmLsDawAaN+hY9X0XpeejyM5Uuh6to7AVRsNX0oMvXKnLHdNrrqfzQsmWHC7SJGDTdehzzpdr0Z+gJEX4KGzn1BOJIdAcxGORYRa4dNvvoI7k9Ot/QyGYRiGYRiGYS6PTatXPoCxEMIHcADgFoDvBvC+5N9/DsD3b/gzeoud/HZuYNWSSA5PdntSMRVIxH8W3b9+7PYL+JZ//uO4fXGy+I9rQgUXKs5LGQsmmmq4toXzKG44rJNvvw2UE8kBxE3+vkRymJxgItyycwYVEOs4TChn2tbvWSRH7DAR/05NFcDS+Ijurq27xr0uKWeaa5lrR5wzLCCEsA5KfROy1eHDX3kW7/i5H8UX7r1uv3YRxpEceYZrrKPUSPAXIjn271ivAjV36O9FlEdymKT5379IDmNSh4lQK0RGY+wH+NqrN/FS4jAxy0RyFJ+v5Po19HzrMOEJYSdH67r+hLkGiosUAspoew0NtcJcRbZRve1rd5vJittSRzA655uY1p9rVShk6TO0B68STADxfi4siuRY6jBxjLceXGWHCYfUYaLZtZY+H+Mk9mGfomXKSCM51nCYSO4Lq5yy6jtMxOc+iVn65hrZBLMCB5uu4943ENeGYxwn+4n0MTECZqv3d8ezCf78r/0jfPClp7f2MxiGYRiGYRiGuTzWFkwYY14D8PcBvIJYKHEM4NMAHhpj6I7sVQBPFX2/EOK/FEJ8SgjxqTt37qz7MjoNWd+Gzk2cTiycy7/H67RtPBUzhIkV/0WChTcvThEZjfsNukxQxq+N5EgcJvpWXDlvo8OEY8McR3L0o2CjrGAiLohvO5KDbMOpWDuqjOSIX0s8tU+Nj+6uGy6R1jZDuqm10DpMdHht3TXZKAJti5PL1ljlNKSD5Nq3j+9DID3Mtco0ByYqtNbsLkPPX1kUl3eYoAl+trCuRhtjj1nZelMWyaGROkw0cZw/9cbLrRET0e88iULrdjLyArxlfIR7iWOBO9ladr6ShfbjB1cdhwlp98F192hKawTSyzRQCC85/m4TznW2cGPx9g1tjN0bKKPtfcmgQaFlpFVhVEqfIYeJqkgOAAg8P9PQpP3xyA8gIErXnNvkMMGCCQCxgIuOVeORHDpegwbSs//bd9JIjtWvaxRVVSX8DGsKJuhzdhBUO7LsM+49d1/uv8m9y+X6YJyL5NBwH7HNARkbg7lHsVMMwzAMwzAM02c2ieS4AeDPA3g7gCcBHAL4nrrfb4x5rzHmW40x3/rYY4+t+zI6DdmxugVJXXAT6NInhwkBFFpMpEWv5n5PG8mR3EzHGdn9E0xcJA2HthRQ3UxsABjIbHG4y1BDeOgt5lBvg3mu4Zk6TCy+11Tg9WQ/HSboGDT1+aU1tctr665xm47aaNsgXlbAjgpt4Ptxrq4CTRRnBBPRHAcFDhMjv9zKugzrOmMjOapdE5gYDbN0vdG63GFCCAFPbO4w8cd3X8X3f/Af4xNvvLjR8zQF/Z5TFabT9IktNv33vMZkKwkX3poRTIiVI2NCrUrj7PzEucZ9Dx4k4tlAehlhx76hMmt1KtimdaKJ5nOo9d5N5VsRUcH67ZJ3mJipCAIicQeThdfPmYpwb3qOxw+vYuwPMFEcyeFa9IdaNSoss81QITHyg71zS8ljjLHRU+sIFNJIDj9elwvWGPd5q+5n6VqzzJFln3FFEr1xmMBirezacJwRQiqjIUFDOsbeF28D19WRYRiGYRiGYZjus8nO/t8B8KIx5o4xJgTwfgDfBeB6EtEBAF8F4LUNX2Ov8aXMFMviCINywYQvigtoXcHmexsDaUyh4t9mozbYNKOCC+Vb+kkkR1umNZvi3OaJt6OAGhmdcUzpk8MENYykkAs51NuACoFUrB0kgomiZg+tEX7y2oDtO2BcFkprDLymBRPxseny2rprVEkkhzamcp3VTmxPeq7u3/tQJJiIIzlKHCZWFMXR55/cPHyO5KiFNsaJ5Cg+VhmHCWQFExJp1Mwm3Do/BgA8mF4seeTlQL+n6zAx9gOM/MD+t7u3nZQ4TBzPJrg6GOEoGNpz1BPS7oNrO0wYbd2U8kghoY3J7ClpEvUwGO6lQIuIHSZU8vf0/qPJtTjaw0iOmY3kWOIwkds7zrTCwPNSoVXB8b8zOQUAPH5wDWM/wEXYjv3+LqHjRBEoTe7llHPtHHq+jdPcV9w1eZ37ikjH6wy58xU18d11p+p+lr73MBgmr23/9o7LmGfWl/7cfxc5TLiCiWwkh1N/2gIkGPfZYYJhGIZhGIZhesEmO/tXAHyHEOJAxB64fw7AMwB+G8B/kjzmLwP4wGYvsd/ki2XLIjm67jCRNs5M8t+Lj6FiTJMNXiuYcCI5yiJBugxFckxbIkpw89+BuMnfl2lOKr5IxE4x285BD5P3lIq1lQ4TNG0npT3+XV43CGMMIsdhoqkCGDtMbI47ve1GcgDVTU9ljG3SkZ2t2sMG5tgKJtLP80U0t0IKl5G3usNElI/ksIIJPuerMMbAF8sjOah474qDSAzURCQHOSKsGsWyLej3nERzK4YYeeQwEZ+bbnOmTODzcD7BtcE4c57HDhOrCXpCreCVNOU9EUcbhBnBRHw8j4IBIqN7J56ti9LanteRE6GW7hsaiOQwau8aSfQZoAZ+GYOCSA4SWZQ5TNw+PwEQu7KMvaBUjLRP0HEabSEiL+Mw4QV7H8mhcnu9VaHr4rAqVtB5/6ocJuh76frBAtBFZn10mDAGAgUOE7OsYIKuOgJmq46itL+rqt8xDMMwDMMwDNMd1t7ZG2P+AMD7APwRgM8nz/VeAD8C4L8VQjwH4CaAn23gdfaWQHqZRpN2Cu9FdN1hgm5YBeITpmgaRDUsmNBG2yaDG8nRT4eJ2NJ62haHCZ11TKnKrO0adC57MnZxmG+5yRsmn5VAkGAiLgwXiWNce1Brrd2DnHY65tT03bQJSdB0UJfX1l3j2t1qbTKF66rjqhwXmr12mEgyuCehG8kR4iBYbLits46G+UgOGa/LTX2G+ooyxorUyiydjSmO7aApSCnExmIsEky0J24r/n0mKuswMfYDK05w3aTKhB7Hs1gwMXaiC6QQEKs6TOhyhwkv2Te77wEJJg79eDK5Lw5Mq6KRd5jIr8XNRHIMZLXTQt8gIetwicNEPpJjriLrHlbmMHF/dg4AeHR0iJEftGZN2CV0nGgdaXIPQeu4ECJ2mNizczmPu7db57pGwqyhHx/HonsYd925qHKYiLKRHLyfWcS9DvfH4XHRjfXaYGyv6/FjDETO8WtbUB2PIzkYhmEYhmEYph9sdNdvjPk7AP5O7ssvAPj2TZ53n/Cll7mB1TClOczx47vtMKGdSA4AhfPhJKIoK3i977lPYyB9fN87vrnWz3QbS/lIjm3eQO8CsuZty8SZW4AH4uLwvEeWoEDsMHEZUSNlDhNFxzOdiBNp46MHzh70e9Hv3pRDDBVnu7y27hrlCHKU0bkpxKpIjvSa1+RUc9cojOSIyiI5gpWdBkgUFCTHmh0m6qGNsUVwgzKHifgxMywKJoQQ8KXc2Cq8bQ4T2jpMhJlpeprwnkZhrez04/kE14aLDhNegWNHFaFWpXtn2uuFBZEcVwYj+/2DJc3tvmFMPHVLa4AyxopOSFjVxDUx0nvoMBFFCKRnHTvKWIjkUJEVl3iieN2YOE3isT9gwQQchwkrmGhuPx5pba8BY39gI+H2FXdNXkdQpZI9XxrJUe6SB6AycsY6TATkMMH7mTx9dZjIDxddG45xHs0RJhFQyug0ksNs99wgMe2y9Z5hGIZhGIZhmG6wX9XBFhLkBBBKL94EusSTct1tJrmRHALFin9qrpU1zf7psx9HpFVtwYRbTKRigScEhJD9i+RIHCbaUkCNtMYgSJeZgefjfNaODPZNsW4piShh2xOqJCAiAUSVnS0Vhjzp2UZFHyZoVW5KvinBE63BBiZx+eGi16q417EoF8lR1fSMdBrbQ02JaA+L3gdJo8cVTEyiOcZeUSSHX9hkqCKyOewUyZE4TPRMNNgkxhgYGMfRpvhYKaPTNcmdaES8n/NzTmLrcH8aT5WXRVtcNq5ggjLmR35gG5ZTFWZcl8pe9/Fsgn/lxlsxcgQTXuIABtRvckQ6jWrKkzpMpK+HBCiHwf46TOTj7yKt4fnxcSdhVRPOVNTA2iemKrTRGlUMcmLbuU4dJsoE8nSNGPsDjP2gNY5yu4SOEx3zJh0mIpNG1fx33/a9GTecfWTTSA5VI5Ij1BoCAgamcgCAvvfQZ8FEGa6ovs+CieuDAwDAyXyCm6OjxGEiRsBs1VGU6nLsMMEwDMMwDMMw/YAFEzsmkH6mILk0kqNHDhOxVWKRYIIcJooLtTMV4aWTe7Ubm0XiAU9KSPQwkiOZxAm1Sqb6dlukVibrmHIZTgyXhUnOXZkIJrYeyZE8f14wUdSIciM5KMKjD1P71HQMpIRAcw4xmWa/1hh4XPRaFbdQrY1eMZIjvualU83dP1dXxZceBtKzzbBIK8y1KonkCAptrKtIBVfxuU3Xzk2dD/oMrfHULCs7j7UTyWFyQiGJOJJjU6vwtjpMTKN5GsnhBbZhOYlCzFRk42PKXvfD+QWuDcZWMATE56Znz896a3yUc7Ny8aSE0sbGWgFpJMfRHgsmrLNEcm66e+om12JXFLcvzFRkxUNV5PeO9JkBkkiOQoeJ+Bpx4AcYe0FrHOV2CR0ncmRqcg+htLKN0O964p2NPW9Xca+D6whTYoGhtNeKoiZ+pBUOgwHOwlllJAddVw5YMFHKXCkrPumNYAIGIne9vzYcA4jdo2LBhOMwgS1HcuTE/AzDMAzDMAzDdJv9qmC1kEDKjFW+RlxgL8MTm08q7hJXoFB2A0sNnDJhyDwpvr969rDWz5wUFFt84fUzksP5XVdtqG0DlWtiUPOkD1CTQQqBgXcZDhNZwQRNxp4XnN+ZSI7EPjjs8LpBqOQY0ARyc4IJN06iX2vCZZFxSnJs3uP/Lj/33NgeGx/TYVHgJoz9gV3DJ7lsbpeRH6+jqwj+Fh0mSATA53sZdGwG5DBRcqyoAQQsRnJIIeCXND5XgRr8bXGPon3aRDmRHL4TyaHiSI6h52Po+ZhGi9d9YwyOZ5NEMJGN5BArO0yUuxjE14qsw8RxEs92lFi57+OakzpMUCRHeh7bfUMDxyVsgXj3splGoRU+VJHfO86Vst/nS1kotKI1YNSTSI5Xzx5s/By0N6T1Z95gBF3sMLFf528V7r5DrXHfo3Qskq1ymKD1fOwHmNSK5Bgmz837mTwzFeHKYGj/3gdIjOpybZAKJoAkEs1xNd1qJId1deSyKsMwDMMwDMP0Ad7Z7xhfetlmndaVN1xlBbSuYJsJpiKSQ1MRt/jGnuwlv/zwzVo/k4qJbvFSCtFLwcR5OLN/LxKKXDZuAR4ABtLP2IN2GXJLkUgiObZciMoLJq4kBcKTpPGTeW06Ld4EPZrap6ajLz14DX5+w4xgorvr6y7JCCS0htbZxnH596UuNPRnH87VdTjwB3bddm3X86TZ3/XXnPz64a3YkN5H6Lz1rXtEuWAiKIgJigUTMnY42PA4t85hAouRHGM3kiOKIzkC6SVCycXXTbEd14fjzHnuCWHXAlMzNi2q2DvHkRymOJLDJ4eJfuxLVoHOVTouyrE5J2eqJvY1VXEpfWWmItu8r2Ig/cz+Y6ZCK9AqdZhIPksjz8fYDxBq1VmHlM/dfRXf8cvvwbP3b2/0PHScRr6f/Hdzx0MbY6+XTFY4uI4QUBkNX3jOPmbx2hAma8bYG1Q6qJBYjxyKeD+zyFxHuBKM4r/3RDBRGMmROEyQGFK5kRwGW41gJcE4rxMMwzAMwzAM0w9YMLFj8naslHldhifjAlpXoyToVQvEN7JFv0UayVHmMBEfr+eOawomkmLLY+Mj+zVfSgghtnoDvQvOnUmcNkyd0SQREec1d7Owm4eaDXEkh7/1SI4o1/D0pYejYIiT+XTxsSQsEJ4VrPShCZ0WpZLPb1MOE06RtQ/HaRcsRnLUc5hwIzkoLqLLLkqbcBAMcBHG6/aFY7ueh6ysV2mep5bBzUZyTKKw0yLOKmh9CazDRHkkB4kq3D0Fndu+8JqL5GjBdR1w3QkUzhKh5shzHSYizFWEgfQxKomQoUnQa8N8JIewa0LdieHIlDtMeEJAGZ3ZU9LPvjKIG0ldjrpbFzqfab1VOnX7ofO5CWeq2GFiv243pyqsJZgIpJcRvt2ZnOHmKL5X8SocJsZ+ACEExo5AqYuQu8Td6elGz0PHaew1H8kRaW0jOZjsdXCddTPSGlJWO0woo+AJiYMgwEWlw0QSB5UI7vo2BNEEc6Vs9FRfHCZUgYjp+vAAAHCcXNsNHMEEzFbrZqmrI68TDMMwDMMwDNMHeGe/YwLpZQoOusBm0MVfMde5bdjmjDEQMCWRHNmptzx0w1/XYYIaT4+Nr9iv+UJCon8OE9lIjt0XUGmSiBh4Xm8KNtoYCMTW4ZcRyTG3gol02b46GBU6TNAEmJQinRTtQUNImbTpKxsUPGXjJLp/nHZBdSRH+fuktbHNNL9HbijrcFAQyVHkMDFqwGGCjvmmFtbf8//+JH76C7+30XO0FSqwp/ElxWuD0tpOhbt7CpMIYD0hNhIBGWPwYEoOE+24frq/J4k5Rn6QaeDOtcLAI8HE4n6ERAvXB1mHCSmkbYbUXeMjrUubFVLIhUgOijihaKu+CDlXwQomrMOEG4/UnNCyKi6lr0zVepEcty6O8eThNQDxfUrRmjON5lYYQJ+bNgik14HEVpveF+QdJpr8PCuj2GrfwV3711kftDHwhbSfj6JrGjlMuHuiImZJ7BPVRpp0FukLcx3haiIM7I3Do9E2totIIznia7vS2hY5yxxNm3w9APYueophGIZhGIZh+sryag6zVQKZLZZpY+B51ZEcQJKp2kG9S3rDapL/LxJMkMNEceGDbvifO75T62eSXfRbHMGEFHHDtatOHWVkIzl2X0ClSSJiKP3eCCaMa18tty+YCJMCcOAU4a8OxjieLTpMUK6wL2SvmtCuw4SEgGlI3OAem32cNG6CvKNEJpqg4phGySQhkDbzu2ovvikHfuAIJshhoiiSYx2HiWRNcOzegc0FQq+fP8Tt8+ONnqOt0LEZeItiiOzjUtGPu6cg22hPyo2K9afhzDYE2xC1BWSPBTUoRok4AkjiNlSEYXLsiibgj+fx910bjjMNTk9IiEQ4XNcBJY59KI/kCLXKrO30mmnytg/Xx1VJxcmJw4QxtjHc5L4hygln94GZimw8TRVxnFt8jE/mU5yFMzx5eB0ASqN8yGECAMbJ522i2rEurMpp4pC2sWAiOU9p/WlyHxc7TOzX+VtFVjCxhsNEsuercpiIEleasT+ovJeNo2/81JGoZ/f0TTBTEW4MDyAg+nP/XeDGeq0ikgMwWxXDu/emDMMwDMMwDMN0H97Z75h8o1UZXekwYZscHW3q2WZCciNbJFhQuSJuHiqsf/nhm7UED1RscQUTdkK9Z8WV82iOK0kDoA2NFZokIoae358JF2QFE9ueUKXJKfd4XitxmHDtQamJ1IcmtOswETcTmvn8Ztbgjq6tuybvlFQ3ksPNIvZkt69vmzJ2pinpz3FRJIe/jsMExfRQJAc1GDY71vF73a/rKEH7A7/APSL7OF34GHIM84XcqPH8YHZu/95Wh4lAevClZ8/N2GEijeQoOlfvTePf68bwIHOek8gk/3OqiCqmwCmSg66hgfRwmohLrcNED66Pq2IFE8lx0UZbZ49UvNZMJEeZmKVPvHJ6H6+c3gcQn//1HCZ8zJI98evnDwEATzgOE0X3QRfRPBVMJH+2QSC9DieNCSaSSI7keIQNOg1ERvfKYSLUCvMNjncmkmON/QMJs4bWKWvx3A0TV5qxIyItIv6cxfE0npCV4tx9ZZ64cPTN4TEvmCBHkuP5BMaYJJIjvsYJs12HCffelGEYhmEYhmGY7sM7+x3jy2whPb4JrOcw0UXc21VhUGi2rCocJpTWUEbj+vAAx/MJ7k7Plv5MKiQ+VuAw0ZSlf1u4COc2/7gNBVR3ehyIi8PamF5Mc7oFm4H0EG5ZCEKCDNfa+upgbAvOLtTA9KTrMNHNNcMlcpq+osFIHffYdHVt3TX5XOt8REfV91mHCYqP2dP34MAfWKEb5XZXOUzMovprTrnDxGafIaV1oVNUH6D9gY0vKTkvXWFgXjAhhIAsaXzWheI4gGKnhl3gHov70wuMknOS/pyoEHMVR3IMPb/QDeXFk3sAgK+5cjMTyeEJYYXDdQU9UWLhXkQcyWFs8/9KMLL/dmWPHSbSSI70T1oX/IYjOfbBqvxHPvZ+/K2P/QqA2GGF3A6qGDgOE7cSpx6K5PCkLNyPTKLQXhe6H8kR7183aeAD6blMxzxsUMCstbFCoj7wP3zyV/Gf/vrPrv397jVuHXGrStaZUcU+RulYpOLuiYqYqcg6QG0afdVX5lolwsX+ODzGYtTFWtn14RgPZxf2HKVPrYDZqqNolBMkMwzDMAzDMAzTbXhnv2OKIjnyqnmX1GGim8VdW2hJHCaK7JbpMUWCCZoC/MZHngAQu0wsg4otj42P7Nd82WzDtS2cRzM8mvyeq9i1bwvX4hmIBRNAP/LCtTHWNjzw/K07OERaZSZvAeDqYFQsmHCKN9So6MMErUqmBq3gqSnBhDON2AdhyS5QGYGEXmgcl3+fawO/WZPuldP7+PBXnl3re9uAm9c9SdbvdSI5Xji+i7/1sV/JvCckQqFJb68hhwllTG8dQajAXiSGcFGuw4QjHiHbaL/EWr8uD5L4iKuDUSuu60DWHezB7Nw2bl2HCWpmjfygUOjx4sldvGV8BVcGo8x5Tus7sILDhNPsz+NJgUgru65QnjuQOkz0wYFpVfJubtqZpB80GI8UVohZ+sTdyRnuTE4BrBjJYR0mYsGE6zBRtLZOHIeJkXWY2L2j3Do07TBBx6PJz3Ne+N11Pv3mK3jt/MHa3+/et69znEkkWxXJQWtGvUiO+D1v0nWuT8yT6/DA8zcWJrUFEqPmuTYY43g2sfsw4QgntjkgQ0KdqoEnhmEYhmEYhmG6A+/sd0xRJEfVJIudFu/oFEV6wxpbJa7qMEE3+ySYeO74ztKfSQ0G12HCEwJSiK1OHOyC83COm6NDAO2YOFO5JgYV4Wc9iOXQRmciOWZbFoHME4tal6uDsc1rdXGLN0GDk6K7xk7xJJE6TU22R7lmP7M67jVJG505jkXCOPff6HOUCibWew9+7tmP47/+3X++1ve2gYNggIswXrfTSI5FwcTIq47k+O3X/gQ//yd/gNsXJ/ZreYcJSZEHG4gdtIndJdro1DSJwo2v76nNspf57zzaGLs2m9z0rSc2jw8iwcQTB9da4zDhvucPZhf2nKQ/pyqO5BgmkRzFDhN38farjwLAQiSHEGIlUWtUcH0kPBEf/zAnmCDasdIAACAASURBVIinnJtvsHYFWpdp7VbGOA4TzQkmYoeJ/t9unodzKwBYKZJDRTDG4NbFMQQE3npwFUC8f4sKoiUmKsTIOkx0O5LjLInG2TSqj85hOh5N7neV1r05f40xeOH4zkaidfdats5+meocqWBi8dyNjIIvJA6WRHLMdWSfxxOycq+5r8SCidjpqVcOE0WCiWF8T0xCs/Qh242OU869KcMwDMMwDMMw3Yd39jvGl14mI3hZJAcVM7s6Bb3oMLF4A5ufenOhotpXX7mJQ3+A52o5TISQQuCRREggEFtkiwYbrm1AaY2pClsVyeHa7QPLG31dwi3YDL3tR3JEWlnBCUEOE/kioXaKN3T8+9AQoqK4l0wgNzXZnhetMauTdZgwmeNYVaiMjLYT/Gl8zHrn6kSFnV5bxo7DRBrJsTilvMxh4jxpQrn/HuYEE01EctD3tq1J8cbFCb7pF34MH731/EbPQ/sTWnerHSYKIjnIYaJkUrwuJJh4/PBaaxwm3N/z/vRiYeJ9GoWYqwiB5yWCicXP5QvHd/GOa7Fg4iATyREfy1VchCJT4TCRNNLIhYJESEPP75SgcBLNbYO5CbTda8e/uyvYTgUTm3+2wz2J5DgNpzhJBKxTZ/K9iscPrmKuFd6YnOLW+UO85eCKFf74Uhae/5MoxDh57rGXRHK0ZF1YldOGHCZofd2GACpyHIQK/10r3Do/ttfsNvPG5BTn0bxQpFAX95xcpxZBAhRfevCELHGYiNeMZQ4T00QMACSRHB2tjWyTqYowkD6GXrCxMKktaFMck3NtMMbD2cTWdkRyqgpT361qHZRzb8owDMMwDMMwTPfhnf2OGUgvU6h1p22LWJalvWtePz/G3/zo+0uLX+n0pYEwxZmSduqt0GEi/trQ83FzdFQ4XZ9nEs0x9gKbW03HUPYskoMabY9ah4ndF+/yjimUNdsHW1BXMBHI7UdyFDUdrg3GMDA4yxVqSVjgJ8KgeJ1p55qxClonFvlSxrn023CY6MFx2gVRRiCRjeSoul4po61IMNiwSTdTIUKtWtfAr8uBH0/ia6NtY7zQYYKa0iXr6Ok8EUw4jQY6x5uM5KDPitLtuo4+fe91TFWIr5ytbzsOpAX2ZQ4TynGYyEfRCCHglUyK1+XB7AICAo8fXGmNw4R7LKYqtOdkID34QmKqIsxVkp3u+wsNuuPZBHenZ3jH1UXBBFlte6sIJmo6TPhS2p8VCyaSmDCtYIxptXDiRz/+AfxXv/XzjT2fsnttbf87XYubE5JEexLJcR7OcBbO7fpdRzDxTTefAgA8fe81vH5+jCcOrtl/84Us3LdNotAKlMZWoLT7/f46nIQNRXLkHCaaEPoQeae8PLfOj/Ftv/T38Ksv/XFjP3NbPJ+4Mm7iiOeu/etc1yJnnSlzPaA1wxWRFjFToeMw4XV277dNYhcODwPpdVpQ7EJi1DzXhwd4OJ9YMS89QgBbdRRlhwmGYRiGYRiG6Re8s98xfi6SQzuWuEW03WHiE7dfwC986ZP4kwe3C//dOLmSwvlvF7rxLGpA083+wPMx8Ord/MfFxQGuDOKsarrJXmV6sQucJ0Wlm+PYYaKsmXaZ5K1saRKoF4IJmEyjdxOL2zqEWhc6TACwU40EFTTJdt/PCbO6ChVnfSEbFTy5Rd+uxh3tmmwEh0H9SI50Uiy9vq13rlIToMlmyWVCjdxJFOIinEM6ttUuVdnfAHAekcNE+u8LkRxi0RFhVeh72xbJQU2hTcUFxqQCLaD8WGnHYYLOe/peCbF5JMf0HFcHIxz4w9Y4TOSbDyPnPB0lwp+5VokVeIBplD1XXzy5CwBWMDHy0++n9UAIUVvQE2kNr6RZIWXsRkSiCmqqZh0mNH77tS/h3b/wYzZWoW28MTnFa+cPG3u+BYcJZ7/WpDMVCVX6zExFsegGBifzKWYqwtBfHsnxDY88AQGBz997DbfOj/HkYSqYiNeNxfN/Gs2tkK7zkRyJuG9zh4n4PKWokiYd31TJNDvhdSgq88XjeN2lGJh1cPdz69QitDF2PRh6fuG9Kq3nroi0iLlSGCbCJE+KrcYudJW5Sq/DvRFMGA2BAsHEYIzj2cRe2wTSP7cppnGHFBiGYRiGYRiG6T68s98xgZQ5O/hi1TzRdocJukm9Nz2v/HcAgACKahtU8Cgq1JKd5FB6GHp+rcY7TWMdBbFggm5oRc8EExeJVfON4QEERCscJtxJIgAY2GnO7hdtjDGQScFmkBM+bYNQRwsOE1cHYwAFggmdLd7k15muQr+XJ+NIjqYmhtyib1vFaG1H5Vw6XNeBqiK2chqdwYaNB5pi7+q5ToKJi2iOh/MJrg8O7LS9CzUIygQBZHPuNtdTh4nE7l1svpeg96lt+5Hn7BTthk04WwRf5jCRTtCTCJT2Fk1FcjwyOiyNttgF+b3TyHGIGHmBjeQYeh5Gnr8g9HiBBBPXHgMQC3hoIp+a9Z6Qtdf4yCgrfsgTR3IYhDaSwxFMeORqE+GF4zs4C2e4Nz2r9TMvm0irymnrVbEOE0bDGJPcf6T746AhZ6oq94++cO5EpdydxOdPHYeJw2CId1x7FE/fex2v5wQTscPE4rXsIpo7DhOpyK6LkMPEpiJq6zDhNe8wERlVKsYCnGtpB/aOz5/E10YDs/Y+KxvJsYbDhOPYETtMLJ678ZqRxiflBXfETIUYOiLQPgjDm0RpDWV0EsnRI4eJklrZteEYUxUW1j+2KaZx700ZhmEYhmEYhuk+vLPfMcGqkRwtd5gwdQQTpPw3xZOpNAVQKJhwHCbqTktMVE4wQZEcQhQ6XHSV8ySW4SgYYuT7rbDuzjum0GR0W5o+m5CJ5PAuQzCxaGt9LXGYOM5NxFIh1M0j78L02zIip4EpV5g+XkaoVSMN5H1mMZIj+99luE06f0MbeLoehB1dX1zBxP3pOR4ZHRQ+bmwdJorXeGreuddH150FiKcxgc32Enk3hbbw/PGbALCxGwPtTyhKqqzgrrSxYra864YUIm7kbLCuPJhd4MbwAGM/3vO0oTGnjMk0hLMOEz4mUYi5jpJIjmBhP/LCyV1IIfDVVx6xX6Pz33UBW8lhomS600uehxr3mUgOkcYAkRihrc3nSGtcNPja8rFJ+Qg1XzbTgIyMtqKjvnIapnuwNyenALKfiSreffNJfOL2i7iI5ngi5zBRFslxsOAwsXuB9DqQuG9zh4n4OFE0UJONc6Wrz98mrqWXBbkvAesfc/c6uOp1zRgD48QplN3Hx3tyL7MnKmKmotRhomdDEE1AwwlUM+mDuyOQDCwUCSaSIYL70wsATiSHMVs9N9J7bi6rMgzDMAzDMEwf4J39jvGlh3kukqNKMOFZh4l2TlFQk6BsQs/AOJmSprDRktoELxZiKPaAIjnqNN4niX2tLz2MvMA255q09G8DZMN+6A8w9gaYtMC6O1qI5EiaE1uOr7gMMoKJxGFim43DsGBK0zpMzLIOE9SsJqvgfPRPV4kyDhOysc+v0norhfZ9IuMwkTTfCK3L3yftNOno/F73XKXrw7yj7+E4SJoDYYh703M8MjosfJx1mCi5/p0lggm3SU3HNFiI5Fi/yUPf2zYb7KYcJmh9oWuYKTlW2mjrbmAFE9ZhQsKX0lrGr8ODaSyYoDWqDVOi2mgrQgXSRiWQOEyo2GFi4PkYeQGiRLBAvHh8F287upGJnKHmr7QRPfX3aFGBoJCQIo42iEwcDZE6TASOw4SyotP2CiZUo41x97MfahJMpPu1oKF9Q6jL3T/6AkVLAMCdFRwmAOCbHnkKx4lL2JOH1+3XPbEYyRFqhchoew4H0kMgvUaFNJeFckRKm7rOUcNyZB0mmtsDRKY87gdIm6RdENs+n0RyAOu7etCa7K3hnJS6NsXHbOT5hdezKHFtOkjO82rBhJ88p9eJ9+AyoWM79LzaMaZdwBVau1wfxiLj+7N4aEfYaI7tRsfR3oYdJhiGYRiGYRimH/DOfscMcpa3+YJlnrY7TNSJ5EgzJYszwangERaIQmY0LSG9eFqiRpFtEoW2iHZlMMw4TPRKMJEU+w+CIcYFE52XjTY6M0kEwE7h9sHtQBlt7fIpamSbooRIK9vcIa4OY4eJfOY6rQ9uJEcfhABusVUK0VgBLNTKrhFccF2PrMOEyTTRq45pPH2cWvAve3wVfYrkuD89x41hscPEcInDxFmRw4SOM5+poJse6/U/QxS70gbHA+LB9NzuPzZ1mCABXBrJUeIwYQw8kXOYSM5hG8mxwXEmh4mRdWjafXPUwGDgefazO/YKBBNaJVbgdL6m5+MLJ3fx9quPZp4zdZigWIj6x62qqUmRHCSqGDsOE74j0iLR6bSl0/qR0Y06jLixSZFWsSOYzAomNt2raaOhjVmIE+sbZ04kx5uTEwCx00od3n3zSfv3J3MOE/nzn8Q8Y0egNPaDTjpMuK4cm7rO0Z537De/F4+d8qqiMqsjm9rCXEX4ytl9PDY+ArD+Madr22ANZ70oF10wLBNMaBK3VUfOkCgPIEei/tzTNwGJiIdeULtm0gXKhouukOtiMkTgDujoLe5TrbiWHSYYhmEYhmEYphfwzn7H+NLL2Jcvd5hod8OZCkZlggl3Al8AhZEY1Q4TNC3hl06m5HHzfo+CUSajuU+CCZrAOQwGSQF1t00VVVBA6FLW7zIMDCSamYyvw1yVO0zQdCKhnGYdEDf8msx03hVZhwnRmKNHZLRt6rVVjNZ23GllvUokh9Z2TU4/R+u9B+QsMe+og82BY6/+YHZR6jDhSYlAeqW53tZhQmUdJtwpb2oAbdLksZEcLYq2eq4By3HCXsNktZAnbggnDhPIOUwkIpVNjvOD2QVujFKHiV2LIYF0r0qvaZRr4E6jCDMVYeB5VoxG56MxBi8c38E7coIJ2qd5jsNE3XMrKnBgItJIDg3fEUwMpIeBTF2vLhLRaVsjw0j0WDZtvSruOUmNNC8ncN3Uwp3W8rL3psu8fn6M33ntSwBygomL2GFiWNNh4hsdwcQTB6lgwi+Y4CdhxNgb2K+NvaAVjnKr4h6zTc8zOpdHyXFpch8XOZFtRXgtH2QgXj69D20M3nXjCQDrH3M61gPpr3xdc90pgCrBROxOuCySY+o4THhydceLvjN3hkwGsj8OExolgonE9epknhVM0PdsCxsXyQ4TDMMwDMMwDNMLeGe/Y/INIl1iM0i0veFMDcz7VQ4TtslpUNTvpAJM0UQ8FXgG0sdA1hNMTJ283yvB0B7DJifU2wDl1h/6Q4y8ABO124kzlZskcv/eVsHPKmQiORLnh21GARRFcqTFoazDBB17Kt4E0uuXw4SUjUbqRFrZomufRFSXScYpSevMpF+VsMWdaqbzdd1zlRrJXXeYOA9nuD89xyPDYsEEQI2GaocJt7EeT2ym60cTkRz0eWzTZC0JJjwhNxYW0FpA625ZtIwyGlKIjIgrjeQQ8IRcu5k2jUJcRHPcGB7YJmkbHCaUMZBI4y3cBu7ID+z0+EB6jtAj3q+9MTnFeTTHO649lnnOcc5hQgpRe68balXqziYTpwoSDbmRHKnrlcJ5RJEc7ZzWp3OoOcFEej7PIhJMuA4T65+3BK3lfWwk/V9f/AT+yod/DsaYTPP/zuQUAKwjzDJuDA/wtqMbkELgLQdX7Nd9KRHlnPZICJ2JwPEHOxdIr4O7b920kUvnKR2XJifpI10dybFMUNcWnk+uje+68TiA9Y85XduGnr/y+kD3fqlgIijcx9B+ZbxSJMdmwsQ+Ymsmnl8qTukixqQDCy5HQeIwYQUTiaOpMVu9t7P1DnaYYBiGYRiGYZhewDv7HUOFeCoqLrP+bHvDmW5I707PCv/dwLFINIDG4u9BRdyiKWFqhNHNf50JmUkUOg4TTiQHmptQbwNU7D9ojcPEYgEhjZTpZkPTxRVMuFOq2yJMLGpdfOnhKBjaaRoiX5T0pexEE9kYg9957UulTTI3akQmU8NNEGltC+19ODd3wWIkR/a/y4hjqBInFLnZpCYJlsKO2g6TYOLNySkio/HIqDiSA4hjD8qK30WRHKHWJQ4TG0RyOM5YbeG54zsYej7ednRj4+bAgmCiRGCpkyg1V8SVEUwkDhPr7Deo8H99eGAt/nd9bQfS6x8JJdz4gZEX2GbowPOtwwQ1xn7q878LAPiWx74685xpJIdI/pS1Ra0qidsowhMC2mjbhDtwIjnoMzFXyopO23B8i6A1tinBhHs+UtydzOzXvMJovFWgfUcfHSYm0RxzrXAyn2biJd4kwYRfz2ECAL750a/CU4fXM6I2T3gFDhM9iuRwBBObukLRtSiQciOBWtlzUyxTEXQtbbvDxAsndwEA73okFkys6zBB17aB5638O9v7wiWRHGEuPqlI/GiMwVyngokm7wn6wkxlayZ9EUyUR3JkhwjSSI7t7lNJ2NZHYSDDMAzDMAzD7CO8s98xdHNFjR6aVCx9fMsdJuiGtNJhghT/AoUOEzTxmp+sAoCZFUx4tW/+J2puiy5HwTAzvdimRs+mkJ30oT/A2B/s3LabGnEZwYQVCLXz/F0F1w2GmgHbzIcNkzz4PFcHo0KHCSkEhEgjQ7ogmHju+A7+0m/8H/jAi58r/HeVrAkUydGkwwQ19arEaL/05U/hL3zwp3sltGoKpeOmsYDIxEwBSyI5nM+RTIQw64pWqCG7TaeXbUKN3FfPHgLAUoeJIqcBpbVtqLr/nneYoHV5o0iOxHGhTbnhzx+/ibdffRQHwWBjJwaDbHOnbN+lEqGruyZpu88Rdt+2znpFe5yRIzxog8OEIcEERXI48QMjL7AZ4gPPt2KKqQrxsVvP42ee+Sj+i3f9G/imR5/KPGc+kiMWoCw/P40xiEz5FDhZtadNuMRhwvchBTVYlf3ctDXegNbFpprj7mefzjM/4zCxekM0jxU59lAwQXuF+7NzK7aRQuCNixMA9SM5AOC///b/CD/z3f9Z5muxw0T2+NM5Svc08d+Dne/31+HMuuINSt2S6mKdTIRsfL+7zGFCNizg3Ra3zo9xdTDCzdERgPXvV9xIjqL79MrvzU3ij/yg8HoWmTgGpSqSIzIa2pg0koMdJhag93govdpDJl1Al9TKDhPXRRtTmey5BMxGbmrLoOtclUMswzAMwzAMwzDdgXf2O2bRYUJX3nD5bXeYSJoE98oEE860YJnin5ovRQWvTCRHhSW5i+sw8f3v+NfwQ1//rQBIMNHO47gO59EMgfQw8Px44qyhov8kCvHXfucX8erZg5W+T+m0uU10xbq2Dm6GapAU7DadkqsiKnCYAIBrg3FaHEpQxmQaH34DjY/LgIqif/jGS4X/njpMeBn7+00JtbZF17Km6L3pGf7uJ38Vf/DGi7Uan8YY/NyzH7eNlL5DThFe0jRWTnxB1fFSRi006cJ1HSaSz982nV62yThIBBPn8Vr7yKhcMDHyix0mzp3GQtZhIhfJkawlZTETddDWYaI9a8uXH97B1197SyIoadZhouy6pZJ9m3AEE8YRDNqM+zWOUxpp4EZb7L45SuJeek3jTESAb12PhtK3jePT+Qx/4/ffh6+9chN/+1v+g4XnpOYYHS9P1hPF2enyJZEc1IQbJ69nmAgQfSkx16nDRBuObxE2kiNs5vUVCSY8mTahfCk3dlwKexzJQe/Hg9kFTpNz57HxFdyZxA57dSM5AODJw2v4xptPZr4WN+Gz5/+UnORchwmvuf3+ZUJC30fHRxuLHFPnAg9Bw45qy5wfgVio0fY99lk4xZVgZPe6614fU4eJ1SM5bKyeqHaYiHLitiLBBH2fFUxImdl3MtlIjkGPHCaUMXYgwOUoKHaYALbrMBG70PTvGscwDMMwDMMw+wrv7ndM4CVW/jq1tq5ymPBa7zARv66zcFZioakh6KbVGJgCu2X63YoKMenNPzlMVBfFjDGxYCIpkH/fO74Zf+1f/bcBxJOffSqtnIdz23AYec1Fcjx//CY+8OLn8JGvfHGl7yt0mLCRHO08f1fBOJ/VIUVybHGyfa5Voa311cF4wWEiygmvuuIwQQWtT735cuG/26gRKVeya19GZJY7TLzn079hj3OdY/nsg9v40U98AB9e8XPTVVQyhUnxA9lIjgqHCW0yTbp4SnBTh4luFoVp/X4tcZi4URHJMfT8wmvsmSPQyTpMZCM5/A2a+PY5WxbJEWqFr5zdxzuuPYqRt/nUtcoJJsp+z7ihlrjeoDiSI/7a6sea9oaB9Ow+ZlMhSBPQ72wdJvyswwSdGwPPs43jP3zzZXzl7AH+5p/993AQDBaek55LWIcJWcu9hI6RtySSg0RD9LOp0TaQXuIwEZ8vbY03IPFCU5Ec7vlMjbSm9w30mvsYyUHH5sH0AmfzKQ79Aa4Pxrg/iwXjq0RyFOELaYXHBAkjsg4Tg9bGyFRxlsSY3BwdbbxWu3FtfvJ5borIFIuVXbwCN5C2cTKf4igY2nVv00iO4TqCCZrET/Z8ZcLGSCt4MnWYKDq/ab9HgjxPyNaIN3/l+c/iH3/+d/H6+fFOX8fMEUwMPR+R0Y3Uj6ZRiL/8m/8nvvTwjY2fax0MTKa2QATSyzhcuVWepu4Xi4jvY7ikyjAMwzAMwzB9gXf3OyYQ1GiNb2rVkkkWO6nY0uanW4AtiuUwJpspWTQhTgWPQocJnTpM0GRK1ZR5qBWU0ZniIuHmjfeBi2iGw4DyxJvLNKYmwotJ/m1dotwkEZC6TbT1/F0FbQwk0sgLIP0cb4OoJJLj2mBkp3nT16YzBd6g4QLytqDP/hcfvJHJtyZSO9/Y/r6pabJIa2sbX1RMfOb+6/jFL/0hrg/jBnadwviD2QWA9jbfmiZKJqzi90Vn1tYqwUTeVSmeDl3TYSI5x7fp9LJNBtKDJ6R181kWyVE0LUhNKCA7KR8alclhp33GJm4/9Hlti2PQNAqhjcHVwaiRvO68w0TZfoHcVSQETO6YSIiNhIK0bntC2gZsG9YUnUx4jr14z0F/AtlGcRzJEf/3x249DwD49sffXvicB/4g0wRxHTuqsA4TJQ0LX8TNzEjH10V6rdQ49BNhwEUiNmrrtD5dd7YhmJhvKZIjdBxS+gZ9Nh/MznEWznA0GOHqYGT/fbiCw0QRnvQW9hrUOHYdXcYN7vcvE+swMTps0GFCYrCBS1Xhc2sNT1Sfv0XilrZxFs7stRHA2tfHNJLDW1ncWtdhguKTqiI5aGBikAyeeEK0QrQyiUL8yMfej//pUx/Cv/5L/zN+4rMf3tlrmbmunMn9YxOC4tfPj/GRV7+IP3rzlY2fax2qhouuDIbWddHWm8y2HSYUO0wwDMMwDMMwTI/g3f2O8W0kh+swUf62eG2P5HBuSItiOTSMVfyLQn+JdAqgSDCRFkjiPG8DUzkBV1RcJGKHif4IJs7DOQ792I5y7AeNTaFSIfbFk3srfZ/OTRIBqUCorefvKpAlOeBEcmyxYBqWRHJcLYjkiLTOOnts0IS+TGia2MDgM3e+svDvrgjHnebelEhXO0z85ivPAgD+yru+E0A9h4mHiWCiDdPgl0Gc8+3ZHOmsw0RVJIfJnavriXuMMbY43AU3lSKEEBj7Ad64OAWwJJLDK17jXYcJtxFBFtcE7TM2mcgkwVJT0Tib4k6zx8dns8Y37Wess1fBsTLGxPs2maxJJuswIRyHibUiORwxwMg6TOy+oW+SSKrUYSJtDpMTBhA3auh1/+GbL+Gpw+t4/OBq4XP+ubf9afznf/o77H97NWOXQkdUUoSUEtoYx2EiieRIXhc1WCnOpq3T+nR+nzfUHC+M5MitxaFW+Pzd1/C3P/7/rPU5tw4pPWwm0Wfz/vQiFkwEQ1wdjO2/j7wmHCbygon4vXc/Y7Fgop3nbBWn4RSekLg2HNeKV6wi7zDRpHg5ygmQi5Ci/Q4T8Tk6wqAhh4mB5698X0HHSFrBRLDw3iutYWDgS2mvK0WCoLzDhEz2nrvmd1/7Ei6iOd7znT+A//jt34R/8JkP4wMvfG4nr4XEEcPElRNo5p6EnndX57w7sJDnKHCGCExab9qmYILEmAzDMAzDMAzD9APe3e+YNJIjLoRqpwlbBN2QtTeSI70hvTs9q/x3gWLFPzVhippmc5Xe/NNUSVWTmiYFi6xxZc3pxa5wHs6t1fTYGzQ2cUaF2JdOVxNMVDlMtPX8XQWasAXihgsAhFucbA+1sue8y9XBaCGSI5547q7DBFAcy6Ec6/V4mruZz2+otS0mFp2bX7h/C19z5RE8Oj4CUM8h5WFiCbtpI6ArUIavl+Suu4IiXfF5p+l8wl/TBt69DnRVMAHEU/YGBoH0cCXJYy4itrJePLfOSyM5VMYyOF2L1/8MUXOiTmzCZUDnwED6GPrLHSZeP3uIF47vlP47rS+BjdQocsQiUYXI7Cnoe6UQG0WpRc6EPu1jptHuRVjKaEg4ggmngZt1mPDsv02iEH/2sa8ufc7vfOKd+B+/4/vsf0shajXA6LiWxT7Q+jJXUSI8GdjXBsTHdq4inIfxnmnTeIBtQU3hSdi8wwStFRmBa7IWf/Dlp/HPvvgJnDprS12iXjtMxO/Hg5krmGjOYcIviHlIReDdj+Q4nc9wZTDC0As2doWia74UItlDNHePkRcgF+HLRXFL2ziZTxt2mPBXFijQmkO1jFGBU2ToCB+liIWCF4WRHFQPIKcg2Yp7+g++/DSuDw/wg1//LfiH/9YP4tve8jX4G7//Pjx7//alv5a5M2SyaRRL9nkTV9QdnfPu/XeeK8HQieSA/XO7DhPLXWgYhmEYhmEYhukOLJjYMTR1RY1WyoUuo4nc8W3iOjYUOkwYA0EPMabQ4SGN5Fj8Hec6SqbLpZ0qqWpI2mmsfYnk8CmSIy5CNZHnSlaor5zeX6nprnKTREBaJGvr+bsKxrEETSM5tuwwUVCQuToc43Q+y7zXKjftEjtMtL+J7DZeP10kmMg7cs5RbQAAIABJREFUTDTw+aVptmGFw8Qz92/hG28+aY9pnWK8dZjoYCNjHWwsQZIjrY2xn4uqhno+ksNfc0rQLf5v0+ll29C16pHhQWlBGIgb1EUNj9N53NQUEJl/D7XKNJSbiOSg97Ut19HU/j9usiz77P3YH/4afvj3frn0323UA4mpCo6VG70hhLSuN/SnFGkkxzrH2m0ejVvkMKFNnNlN56vr4jVacJhIG8ff8pZywUSeOJN+BYeJkglP2lPPVARfePa10pofSA+n4dTuR/clkmO5w0S8b3hzcgJgvSiY9Pzt3+0m7YfvT+NIjitBNpJjU4cJ2uO4zeTCSA4vwER1L5LjNJziSjBMYhk2+8yRYFMIkTjGNLcH0DlRZxHxvqUd18EyzsIpjoKhjWaYrenCkTpMrB7ZQ4/3rMOED21MZt9t41WSxxz4xQMAdoBCevbxm0YIbcpMRfjNV57Bv//V34BAehh4Pt773X8JMxXh117+/KW/nrkTybGpUCb7vPHna1f38uRwVcRRMMRxMkQgbI3JNFIPKSN22KteIxiGYRiGYRiG6Q79q2B1DCrEh0kOqKrIZQTSgvA2b/w2wS1u3y8QTJhMJEdxw5OKTmUOE2Qnam/+K6YtbXGxoHBZNx+7K5yHcxwGFMkRNzGamESlYxhqhdfOH9b+Ppo8cRv3VADrgtvBMjRScVNQw+1kU0Kt7c9xuTYYwcDYRikQF7HcdSQoyMKuwyffeAnv+fSvr/eC14DWtT91/a34ozuvLEwvuTnVTdnv0nGhqej8c56FM7x0eg/fcOPxNFJmBYeJfYnkUFrDkzKJ5IgdJgZWMFH+PuWtbNedDnWn5sIOH/OD5Dy8URHHAQBD3y8UBJDDxCOjg8y/549zGsnRhMNEO/YjVMQPPN9OrlZxOp9mIkzykOghqDhW1mFCyozrDX1dQmzkrBQ511HrMNGChr42BgLCiiEqHSac//4zFQ4TeURdhwkbW1I84SkdwUQgPVwbjDH0fDyafMYC6dn1GlhPGHAZ0LlwWYIJcqaiiKB1fm56/vZv+tZ1mDidT3EYDDKRHBs7TBQIreg9cD9vR4MhJlHYSCP0MjmbT3FlMMJA+hvvnaNk/wEkzhwbPt+XH76Jv/+Z34RJmvnekvPXkxLKtPu+5iQ53qMNG+d0bRt6scPEKk5veTFEURPfFQkCFDlTFMlBDhMUyVHverFNfv/153AazvC9X/Nu+7XHxlfwlvERbq1w/9wUM526cGwaxVL0vLt0mCirlV0ZjOweyTpMmO0KeyOz3IWGYRiGYRiGYZjuwLv7HUNTV6FSMInjQmUkh23YtaNBkccthhQ5TBhjnNTJIn+J9DmKJoRmStmbfvqzakqmaBqLkEKUvIJuchHN7e/Z5CSqW6h66aR+LAcJX/IFeKC95+8quAWbNJJjewXrMGn25KECvc1sRZHDxHqRHB96+Wn81NP/co1Xux5U0Pq2t34tTsMZnj/J2uW7OdVNOUzQcRmVRHJ8MbHRjR0mVhBMzGOHiX2J5IiMhi+8pHGgobRBkEwyVhXUY5Ggu0bUa3bkC+hFBfcucuA4TFRRJgggAcCjo6PM+r8dh4n4e9siPKT3fSDjGIhl17+5VpW/vxU9yHKHCPsYIeHJdE1yv5eO9TqiNeuaITwMpAcB0Qr7fbr+ja2rleswkTaKB55vm7sD6eHdN5+s/TM8US92KXUWWRLJoSP4UuIgGOAj3//D+IF3/hkAseDxeO4KJnZ/fPOYRIQGNCeYcD+3ZQ4TkdZ4cxILJtY5LiQGH/RSMJE4TMzOcR5lHSaGnl/pEFQHr2C/PIlCDD0/46by1OF1AMDrO2jIbsJJOMWVYGTjkzaJWCOHCSCNktmEX37u0/iHn/0ITsNZvJ9eFskhVndbuEzmKsJMRbgSDDdunLuRHMBq1zUbq5d8NoqcIvMiqwN/0JlIjg+9/DSuDkb4N5/8uszXnzi8jtfPjy/99cydY9Ssw0T8HLtymMjHTrocuVF2yekgYLZ6bmiTvedmGIZhGIZhGKbb8O5+x7gNuLTwvtxhoq2RBvQ7PDo6xN3pWcm/k8MEYAobEPHXiopPoVbWfrPOzf80KSwfFEVy9Mxhwi0gkHCiicK/+xwvriSYyE4SuX9v6/m7CjRhC8A2hrcdyVEsmIgL9CeJBSmwmKcaSLlWRnSoFUKtLm2KiEQ2bxlfAQCczKaZf6fzRgrRmOAptIKJ4kiOL9x/HQDwDTeeSAVuq0RydGzqc11ShwmRRHKkjijVTems3XUdW+Uv3Hsd7/r5v4un771mv9aXSI6DIBFMLHGYKIvkIMHEzdFh5tyLtMo0fbyC6eVV0ZoEE+1Yz8NEPBlIL7F5r/7shVpVnmvUwJMQpfEQ6XVOZGK+6JjEDhPLPwdl2BgiGdvNj0qcRS6bVDCRiDRLIjmG0sfIj6+P77751EpT97Kmzb1yhHRFeDmHCQD42qs3beMwdpi4sI/ftYPHM/dv4S988KcyojD3urQdwUT8O3s5Z6pQK9zZQDARLRGzdBnaOzyYXuB0PsNhMMSVZD+2aRwHUOwwMVHzhYjBrzq6AQB49ezBxj/zMjmdT3FlMMQw2T9vct12HZSaEEy8cnofQPxZi2o0Qz0pW31fQ85TR4PRxo1zurbR86wT1ejn7+OjRcErHfODYICLsNxhgtZxryHXuU14/fwY77z22MJ17snDazsSTCSCNc/fOIol+7zxc+xq7+fef+c5CtJYJOHUm7bqMKGz99wMwzAMwzAMw3QbFkzsGDuZbnRhgzmPLaC1dJKFbkhvjo8KIzm0MRCk+DdlDhPxV8OCm3o3kqOOrSgVlgsdJiBa0+hpgqxgIi6oNmEtPYnmtjHy4snd+q8nN0kEpAUw1eGGJmEchwlqwmyrUWuMiSM5KhwmHroOE7kmtC88RGvYBVMz8bKsnqlBeZg0jfONK5r0E4lgohmHCYrkKHaYeOb+LVwfHuCJw2urOUwkFu/75TCRRHLo2MY6jeSodphYsIFfcq5+8OWnERmNrzgNoozDxBrioLZgHSaWRXJ4fmFj9yycIZAerg7G2UgOk10/mvgM0fvalux2EjKRYEIZXdk4m6uossGiHIGWV2L37e7bhBA2xsMVwG6yb1uwJ/cGO2/oA6nQifZWboN4nInk8CGFxI3hAb7j8bev9DPqnp+hTkUlZc8DxGtEUeM+kKnDhCfkzh0m/vjuq/iDN17C7YsT+zX3mtNUZIh7PlNjTeacqWYqwt1JvJefrvFzw9y0eJ+gBvmD2QXOwxmuDIa4luzHRgX3HKtC53PeYSIfMZgKJrrlMHEWxq4cTUy+uyJhvwHBBO0tzsMZdG6PUoQvZGvvy4HYzQMArgYj+NKDFGJthwlakwdWMLGCw4RzTQVSwYQr7sxHLI28ABNVFcnh2+fc9XsQlQjbY8HEw41cVNZhntRRYtetBh0mks/XrlxV3PvvPFcGrsMEvT5j92bbQLHDBMMwDMMwDMP0is0CVpmNoSJiqKKMtXMZbXeYoJvYm6PD4kgOGKv4B4oV/2kkx+LvONepYIKmJaqKPmkkx6LDhOiZw4Sb4UuFkUYcJlSIA3+Atx3dWDGSY7FQTkXHsKXn7ypoJz5nkEzSN5ENW4QyGgamsBBHDVa3OaqMWYjkqOOKkIeKzlMV2sn3bULnDP1O+cKee45LNJNX/P+z966xtiTXfd+qqu7ej3POPefeua+Z4fAxQ1KkHqQIW5QoJowUSXASG5QcJXBkJbAdxIGRBEECBQ5iIEaCwMkHGQiC2IYNxDFsOIkRSAkgCwqiRLRiKwwt0ZJNSRQfIw1nOJz33Pc5++zdXVX50L2qV1dX9e7u/ejeh/X/QN659zz27t1dXb3Wf/3+uJaWhIlqof13770O33n9LjDGzDFtU4w3hIns24cwkZM/8klLSRr0TcY0qVWl8NnmXP3cq18FAKhgmleqPqF4iMJ71fW1kRw+wsQlHMUTgzlH5RO41fWjDc2jSXjt7LsJ4JOJ5BDCNCwpVcDWag1hgu7JuIcwQY0RtMGPxXnOmEHz99m32XjyaeQ2yuxbCjQwxuCHn/0O+MZH3oVbs2Pzb9OKYSJ/3X//j/37cGd+0ul3cNbO1Co1xpa0IUzUvybipUnixnQ+OMEDDUj03KRr4kW6nddHjU54TkWWee3Ni0eG5LTocd5lxvBz9ZpJ+Pm8vXgCGjQck0iOaQeSik8uCtBlltYM4E8fnQJn7OAIE49Wl3CSTDeOiACoEiYSITZ+9nm5IEw8LshtwtOcRQm+2b1013qyQsJE3kxuQ2DyCdcNNMR2iuQovhc/K5dZBu/jeP7PowTuLev1BPwevNYiJgYnTNgGYNQzR2ewyFJ4sFqs3dttU3iMYi62cp3ZP3eoWpRqMExUCRPF/+vd0jCyFrE9QUFBQUFBQUFBQUGHo7C7H1gU8d4mkmP0hAnQwIHBjekRvOuJ5DAPsKCdjRZlisX1ptdSZqZI02YqCQu8TsLEFTNM0CkobLpto7Fyka5gFsXwgWs3uxEmrEkigNykMvZJrLbCBjFAOQm1q0Zt05QmXg+0YZwpWSnaJUJ0wubSnwMAe2sg4TmD12uNMKHLWAFfA7OrMlUiaxmwStFbKgVfuf8GfOeNpwGARii1ieRYON/DVRVOWJWRHKXBx0cgUMZURc09zevDmxeP4LeLKA46aU3vA9tADg+lLoQJF0Ehn9qdwFTElXMvVbI2Acc91IS2ws9v6CYFKiXNAcxGb1q7UiXXxMXYZohmwgRnzOxp8HtZQacA2JQwgWbIeHACAkDRsAAGHzy7DX/pUz9RMfpS2gTGVb3/2lNO42qTBOOtpkLXUQyEZR60heZbAICnpseDH19XLB2lcm0rkoNG4uH6aUdy0IZYn+NS4vWvIGGieG9oKDneciSHcBImVrXnmZgLuDu/dlCGCa31lgkT5f0tYpsRJh4uF8bwilF3Ys35G40gDqJJlDABkK95ffdJ+D77RHLg1+L9Aq8TSmLD8x33j/5Ijvx70AjAORucdkVJj1TPHJ0CAMDr5/ulwKykhImIgDG2levM/Nzi3BnqWZ4OLNg6iQlhwkRy6J3We2zjd1BQUFBQUFBQUFDQYSsYJgYWFpMzJU1huGmSpcuE8xCSSoPgHG5Oj72ECaCZko5iOD6AOwkTUpriSCvDRNZkmODgDgU5TNEYBny/X73/Jnzm5/8yfPnea71/LhImPnDtJrzy+F7r4pg9SYQa+yRWWykoM1RL08KuDBOy8nuoYoGUmvJ320W7vgVk/Jwud0TOsIUFrVkDYQLPJ9qc3ER0mi3i1aL3S4/egUuZwnfdeAYAAGJDSGlBmFgVhImWx+7txWN4uFys/8KRCgkGeY60BqmUWat9jQQ8vyrnKueN5+o/KOgSAFXDBJ2aO+xIjnztvjFZZ5goCQpUT9IlHBnDRNVEZZMWBOMbTd3hvXroJgVqZcwF7fDTK5k13os0aLi5fAyzn/0RuLN85Hyf+HeCceBQmriM2QJIJEcvwkSxPqFhIooHJyAAFAZNDzWANosnon+jvC1iXaq68cr+OShX455+383p8eAmN5dpuEKY2FokR3k+43XCrbWYqk8UiN38vEqy71PH8XYjOVyEiYVMncaj546vH1Qkx6XMIFWyQpjYpJGbT3jn51i8Zg+xTt98cs/8+VER1bNuenzszzVPCuPHMSGg9D3euO/uE8mhdLXO0USYwPVn5onkwPs9/gwxAjM+peBRPX10BgAAr50/3OvrWalyyGSbhAmMcBrqnFdaG3KXLTzHAcBEwOL37EougltQUFBQUFBQUFBQ0OEqGCYGFhYEVkqaB/0ml3psJpzH2RDCJvJT0yN4ki5rBRml9doHWDRRaNC14ofr4b+p6POkmKo5iia1f+NwtQgTUmtT7EbDxH/3zz4Hf/DoHfj6g7d7/9xFtoKpiOH9156CTCv4VssJGXuSCJVPYo3z/O0imqGK5+KuGrUZaQTaih1mDTQulV/Tr5hLIzn2oXWGCZpTvS1CDG3ocFYlTLxSTGw+f3oTAChhovlzvsxSY9Zq29z8s5/7u/Bf/vovdnvxIxKadLDJKQlhwteUl2aCv4qBbzq+v/LqV+D2LEf704nnasH9KhAm1kRyRPXJTIDcMHEcT4qGCCVM1Au6eWNpA8OEZQ4YWilZJw1homHtWinZeC+SSsEziwfA3/p9eM/FfafhQeG+jefRG2b/QhpDOJ3cK5ID89yLdW9mGWGGEhImXKpEcvD+0QScHM8moYHNS5iomAfrjz30vvrU7KiXMWCbMrF05Nyk5872DBPlz8QmWsSrazHVRQ+jDv7cyRYiKsYmqVXlfR3HExPJsY33i58F/ZyQ+Gbr2ePrB0WYwKiLk3iylcn3TJeN6lhEGz0jYxwHAMDD4nX6zFiosRMmHqd5JAdO3yci6t04x/t+n3oErmNobnF99vbzTk6YqK89uL/Be/0YPgOp3dEMSJjYt2FiKbPakMk29g947gz1LK88JA+AKmGC7ZEw4Xs9QUFBQUFBQUFBQUGHp7C7H1i04IBNJbvBTIUPZLuaZN9UusASGqS+VWDVmj7AukVNEvb7XJGH/zYTpA+WC5iIyDntxRm7QnwJLCDkRxUnPF+/yIszm0yUXGT5RNvz1/Km8YstzRdYnLCLR9GGTbqxiEag9Ink+Iff+nrrZvqqwTCBDSn6u2uECZ5n+3YlMmDhchsI1zbCc2YeuafnbcJEm2baOmVkOtkuuC6tSJ/IfM7N5+/DVUmKaHvsXn1y35nTfCjKisgHwXkRyaFMjIBUzZEclKoUMeFtLK9kBv/otRfhx577KESMew0TY70/ttE8LgwTawkTRfE7qxMmjuNJQSLIzDWfEybstbhfVA8KP79dZkN3UblORjCNcH/QEMkhZaORLDeAlsYH1/ppR3LUCBMbRnKU61O+9kyjeHACAkD+vn0TnlPSLE42aBxHTLQy+hnChGfvXFlfHI3PimFicjSCSI783KHnC71Ot2XoUGRdLiM5qmQqqj6/d3mFDROpUsa8B5A36k7iLUZyMEckR0F8s/Xc8XV44+LRaM30tp4UDfzjZAoTR6xcV0lVNqojzs0EfB+9QgwTaOxYh9sXfPhmfZOMQYUYevru62uRHB3etyQGQ/ozKpEcunrP8xEm7LVl04ixbQij6Wzdnp1AxDi8tvdIjsw8I06K/9/kOjM/t/gZQxImfIbNo7g+IMP0bqPjfJ97UFBQUFBQUFBQUNBhKuzuB1ZpmFCm+ed7CATI87AT3q6IPIRUMXWfeB7M8wZEIe12/NO/s4t/KyXLh39H9qmtB8sLOJu4J3XZlibUxyJJUKA2srdvVi0AwGW2gnkUw4fPbgMAwIsP32r1fRlpJFFh8/7QpQhhIu5Y8H3z4hH8yV/+m/CL3/jtVl9vJq4ceHOXWQOb101f00ZoDNhXgw7Pi7khTFR/b0aMIG1x7etEp9kiXkX6YtEd1xxsOK9rSjwg0Rptj93D1eKgoyRkcT2YSA6tTOSU73qncQaoiHPv8X3j4hE8SZfwiVvPwSyKK5PWFcLEAR/H46Lh9tS02TDhyv4GKA0TExGBBm2u+XxNqK4fEd8s6z0zholx3Efxc09ESZhYZP41OVVZY7OHErE4uKNHDCUFWGGYwJiS0gC7SSRHSc0oM9/HEMlBCUu2qoSJ/pjqaRS1eq8lwt39u2yCjS36d9enc8i0GjT2zhAmKvf0cj+1LcIENRyWkRzlZ4rn3GnRZO1jJLk0U+BXzzCRKQm3iGHiOJnCNIphIqKdESYWWeo0gD97fAZSK3h9zxPsfWXWNcbNWr2JsZtGIcRMQLbB5Ps3n9w3a/bjFAkTzeuYYOOO5EDCBO4vNiFMoHEQz/Eu+3A8l/H4uqLFMssAN4sTWGRpzZiJpAS8x4gxECaUct4XBedwZ35t/4QJRQgTaCJt2BO1/rmGMDGgYcKz/6gQJnSz4XVbylQgTAQFBQUFBQUFBQVdJYXd/cCijVacwvXlQtPvGStyHB9isbFrN67yxkqJSGya2ASoNyZzvCRGcgjzdz49XC3grMgUtsVgPI2ebYhGchwVU8o/+txHAGCzQuSiIExcnx7BzekxfP1BO8MEFtHs8zkaeWGxrRSUGaqMseK6bFekxcbDI0IiaBI27l1FW7zW6GcsCf0i/776pGIbYdF5f4SJqmHCbpblpqD8mHPGQW+BMIHYc8E4CCachAksOEbE4NakB8sLAMib3m0afiuZwSJLB23SbaocRSxM0boayeH+nMqmcnUC3HccsFF4HE9gFiWVBh41Kx3ycfzsBz4Gf/nTPwnPHJ81fl2JV/ZFcmAkRX5cUqVqzeK+UT0oNAsM3aRAUfPT1DG5aotGobmkNSFMgPt9GpIE55WYL2xGM8bMPbAfYaK69k+jeHACAkCVsGQLDZsJF14KRRtNRTuahmnCefbO9O+d91BEv0eJiW8b0pTiuq7wXnwtmTrx9L1+j6rf62wyFQDA3fkpTETU67y7yoSJTCm4NTs2/31cNOquJdOtECYiF2EiW8HM8bOfO74OAACv7nmCva/MvZ/zVs9ybX4eHq9YiI0odi8/vgcvnN4CgJIWtq4ZGh0AYYLeF7dBmDBRhD0ME8IYJuoxEaUBLv+a8nmg+npXMoOJiMw9RnDupZntS1mxD3bpmaPTQQgTE6yZbJMwIdGIO5xhwre3QFMQ1baIhD4FwkRQUFBQUFBQUFDQ1VLY3Q8sJ2FiTYE54mK0yHFs2uODuU020GRikwE4H2DpFKddiMECCUA5mdL08P9guYCzidswwXc8cbBv0UiOs8kc/sYP/zT8V9//WQCAjfC0F1mZmfyhs9vtDRMO3D4AomvHef52kY0EjbloPdmOxoC2DQhslrimdRMHPcKO5OhPmMi/fl/NI0Um1zhjtYLuQqYwE3nxlDYnNxE2jZAwkTkIE7jmtM1sRsPE3fm1VkXpRwUuuQvaeGzCCU9RkHuUVqYR4otsMCh9cl7PoqRWGEfh9TKLEphFiZMwcRxPRnt/bKMb0yP4Nz78fWu/zpdHfU4iOQDKRmimZT0eiQljGOojpcZFmKDRRRPLMGJLaw0rKSFriCqiexFB6BFUNFaGRnLgz+SMmQZK2oswUTUDzFqaCHYtBQ2EieLc3CSOI/857d6rTeGwVb0X1r8G15+jODHXzZCmFDyn6P4X70vXkunWCBNVc2B+ndCmD67ft+cnuUHNgcVfp6WZAr+Chgkt4anpsbkO0DDxo899FL7/7gc2/vnckGloHEtaI8gBADx7lBsmvvXk/sa/dx+i62ZizG1bIkx02Iu79Mrje/Chs9sgGDd7s3XN0LETJp6kl3AcT0yTOeFRb/Ig3hcTQxBrf6wNVYxXDRNVwkQ1ghANQvb6syT1AIBxECboeWjrmaOzXgSY//T//d/gF1/6Uq/Xs5LS7IXw3oZxOJvIRHIMRZho2H+cJIQwQQyvu9ynBsJEUFBQUFBQUFBQ0NVS2N0PrIg0MrH5sM4wkYjxRnJoyJvIriYu/juN5HA9v9KmRD2Sg+RxtiiyPVwt4NRDmMgnDsZ5HPsoIxNWAAB/9P3fA7fn1wBgs4mSRVZmJn/47DZ8/eFbrYwmvqnPtrnkY5eNBI07GJmwyNS28ZXK6sQVlcsMIXW1aGfICB2bo/g57S+So4xocE3AXaQrmBf0FNqc3ER0mk0wXikAYkG5JEzkx3Rd4/NBMZV4d37a6tjhFOMhkxFwwhOzvClhwhVlgN8DUDVVHUUJnGfugi42CmdRDLMohgVpHCJh5SieHPRxbKvSEFFeI0oreJIu4aiI5AAozU6pkg7CxGZrMX5+YzFMpKTRMouaCRNSK0Oo8TVZFCFMcOZ+n3TNojFfhjwBzDSe+5CepIMwMQbDhFQKmCc+LuICIsad8RddNI1ir3mKqoyr8EVyUIJNE2Fi4m3O7VNoJMsqkRxImJjBpazj6fuIns94r6PxJWj0uT07gZnoRzZZygxiLtaS8w5RSO05S/LYPzRM/OynfxL+9Ec/tfHPN5EcZGr+UqbGwEz1bEEk+ubBGCbKdXO6BcMEJUxEjPeO5JBKwatP7sN7T27APIrhcWGYOHjCRLqEEzJ5P92AMIGfHdLtuuwhDHmQYcRU/T6dWUZa3PNfpHXDBDViCcYG/wyU9RxO9fTRKbx+/rDz2v0LL/0z+JVXv9Lr9eQ1k/w4xlzAnfk1+NaTzSkXuJfZRixiH2lrYIGqQpjQSDT1P4dsQ/aQQlBQUFBQUFBQUFDQYSvs7gcWTrulShrawtrCDBt/JAc2GO0GAW1AMAAnUl/qMgPUbkCnUpqfjUUA3wQpAMDD5QJOGwgTY2n0bCqtdX7sraI0HqNNCpH5RFteoP3g6W14tLqENxeP136fNAYgyzCxIQZ+LFK6mlWbiPaRHFgAb9uAwJ/rmtIsY32IYUJVi3ZYeO9KGsHfu69IDix2MsZgIuLatX2RLc25yBnbSgEsswgTVUx5gRPn/QgTd1oSJh4sC8PEBlORQytTEiLOgTMGmVJFfEo9g51Kmin88lydxxPvBPUlIUzMrUgOPFdO4gmkezpfh9TUMkQAAFwUfz6Jp7VIjkypWrM4X4v7n3NoLhq6SYHCfVGFMOFpuNO10Hc/UlASsYR2rzc0VoYzZvY0ihAmYoPC7n6s0ZwVkQbTkHERKA26sQk+jeKNCRMTEbUyh5RreBvChMswUUaZzcZAmCjOIXpe4rWG+ezbeH0uwoRg1XgkAIDbs2s1g1pbLWV6JeM4APJ7Xsw5XJ/OgQEzxuJtCc9bs84qBUuZOQ0TExHBndkJvLqFZug+RI1m24gKwP0HAEAsot5UvTcuHkGqZG6YiCeGMLHuuTwnTIx3//Z4dVmZvE9E1DuqERv+uAfpZJioRXLUjZ8mhopVIzkurDVvdXCEiVNYKQnvXp53+pkrJeF+8UzRVSuZVe7D7z0vqOiCAAAgAElEQVS+Dq88udfrZ9mvCWC4vZ+0nr+ppiIy5w5+hQAAvcPXKlWI5AgKCgoKCgoKCgq6Sgq7+4ElGAcGDFIly8K7xzWPSoTYKGJhl0LDhKuJi/9uy6YVSK1NEcQuQC2VNNOaeVO1uejzYHkBZ5O589/YlpD+Y1A5rVU9dxjLaR+bRnJMCWECAODFFrEcWBCtYeA5P+joAZSTMNGyAIkI29aECeUnTLDieqPN9ozEs+BrA1jf6LeFX7+vBp0mRfScMFH9vRdZajLmtxWpg8dWOAgT+HnimhN5yDmo/+TXfg5+8aUvwYPlAgTjcHN6BJcyXfs6rwJhAq8HwTgorUBpDYLx4r/d759iuVHzKJ9kdk2uLVoSJg45kqOtpo5GA07DHhPCxLI4/1LSUELFvL3JyyWbpjC08D6XCEGOj3vtos05X9Ffa1UhTLi+TpEGEI0JohFrkw0IE5nKo1QQpT6N+k36b1t2JJWtqYiN0ayvpiJude/JyBrukssEQIWGlqMi6gdgf/c8l3DvVCVMYCRHbgDeRixHhTBhDBN1c8md+UnNoNZWKyWvsGEiN6HdmMzhJCnjDralkjBRRLgVaxnGktl6z/F1ePVgCBOl0awNLXCd6IR3vIER8OXH7wIAwPtObsBRlMCjYm+2rhkacTF4s75Jj9PLyuS9i+DWVvg+0ejSheZhCBO8iAYRdVO/MQliJIcxsa2J5OD+vea+1EQaeOYop8C81iGWQ2sNS5nBvct+hoklGTIBAHju5MZW1ghDmBgqkqOIf3WJMQbHSXGuk9rITiM5AmEiKCgoKCgoKCgo6Eop7O4HVt7s5Llhopg6tykBtjbFaO9SSitjZABwECZAAzOIRHezRWllpk5S632uZFYpwjcVfVIl4TxbNURy8K00XMcge2qHKhFR78ktpRVcyhTmRcHqQ2d3AADgaw/eXPu9mSmIVl/T2Cex2qpumIhaN2qxIdK2AYE/14c4zxufpAFoTTmVsR3d1g1cZ/ZHmCibjFMR1yM5spWZNttWpA5eOzHLseG0Ub+SGQjGTeEWJ5F96+/ff+lL8Le/8oXCqDWDaRSDKprVTXpYECYO2UiURwKJYspPF4Vj1ohJdq1baIhZOBrd2CScF4QJ2jTM8cxirYnuqshEbpDjdF5kUx/FExPZcZll5TleI0xsGMmhMJJjHOctjeQoj49/f4DyHQOpywgxzhgo5SJMlAV5Sq2iEWs+4lYbpRYZZCZiyLQa/B4qtT9DHABgGkWmGdZX0yhq9V4zsoa7RPcgrq/BdX0eT8zUtGv92Zfw3KHRT3gMTid5I2hnhglHlNft2UlhUOsTyXG1CRMR53B9Mjf3rW0qMoSJ/LPHhjFGFNh6z/H1reD296EKYWKD9RFFCUoRF5Bp1ev57v974w8AAOCF09tw1IEwEbFxk/Mery7hWlIaJpINKBwbRXIYYlL5WUWMOwkTuC7PDGGiuuZdyrRiBhCMDxYRgcoaSAPPHJ0CAMBr5+2vUdyn9CVMLGUKE7J/eO74Orx2/nBjczaeO0Od8/bzty0kMQEaV2HHkRyBMBEUFBQUFBQUFBR0pRR29yNQ3rSQBuW8jjARcbERunSX0qBBEMKE/VDuyp20YzmU1gT1Wf1+Gy+ZcL9hApuQPsJE3nC9KoaJOtoelfD+DUQ8tliwujU7htNkBl9vQZjAor9dRBj7JFZbaahOuCQdprWxyNR2ijVrYZioRHJY0y6GMNEx1xnfT1sSxqaixAFXxvJ5ujTNgm1F6pT0DlHLvl7KrNL0wyKvr4GXaQX/5K2X4fWLh3A2mTspAC7hFOPQTdBNhChiXhgkcmQuB14YKFxCkyBt0h0Vny82/6kWJpIjrjXwViq/N2xKTTgUuaZynxTH7CSZVLLBU7MWV9cPNGv2Fa7jQ091olIlgUFOOUHDiI8wQYk8vvuR0qXBMwLt3C9IYgxkzEWY4N79UBtR1DwAlEaYgU1BSuvGifqZSDaO5LBjZXxaS5hwmACosPF3FCWGpjUkxQPXS9lAmDhPNzdMUMPaykmYKCI55icwi5JekRyXMjMG6KskrXVuEuQCfuL574Wf/o5Pbv13CJswgfc/z/G8MT2C+8tuuP+hJMlebxuECTrhnfRcbxdZCn/7974AP/Kej8AzR6cwj+LWhAnBh4+DaNKTdAnHcWnqcRHc2iqP1mTmOHcx+pZG+vLeYb+WjOzJAcpIDntNtgkTnLHBTcdSS6+55qQwrHRZu/EcvtcxxgN1KTOYEYPVc8fXQWndybThEtaghjrn8+dv//4Dz3X8CrYPwkQwTAQFBQUFBQUFBQVdGYXd/QiUN3hUpYDUpC6N2X1LKm1NVDoME8Xbw0aE/RCbR3IUhAnSvFRaQaZVpWncNE2MmHs/YeIqRXL4z51E1A02f+9rvwGf/rmfXTuBhRM9WKBljMGHzm7D11oYJjLH9Dj+d1fSwRhlI8ljISBtWfDFz6trJIfPMJEIK5LDIkxEhozQNZKjm7FjUyli/HHl1y8qhAl/I76L8D3GnNcIE0uVGexw/jXNhXipFKyUhF977ffhLJk5KQAu4Vo11qilNpI6jw7ACI4ykoN5CQQuwsS8KHS6JqgpYWJmIeKxeG6bh66qSoJEeQyeEMLEhDSb7YlNFJo1+wqv111O7nVRWkR2UcqVb+1aKjrR2mCYKP7MgDmnVxUx/VATplnLoNwP9WkIZhZhwpgIBo7l0Fo37lWnUVxZO/toXawKqlzD3ffHajyVK5KjMEzEiRf/vk/hukj3SXjPwSnxbbw+Sp4pIznKY3V3fgoxF/D+azdzg1qPBusyy64kYaIkU3H47PMfh//oe39k678D74s2kQzXflvXkik8Wi1HQ/xpkiHwcL6dSA4y4Y3rTtd9wM+/+Jtwb3kOf+57PgMAAPNoAo+Le+rhEyaWpmEPUAwb9Lz3l/SwqqGnjfC+SA0oE4smZ6/nvjV5JTNjDKU/c8jzX2rtNdf0iUbE+saj1WWvvdoiW1UMVs8dXwcAgFcfbxbLgZ/XaAkTdiQH1IdztimpQiRHUFBQUFBQUFBQ0FVS2N2PQDgRawrshxzJARo4cDN5YjfqFWiwS9r2I6zSihAmSPPS5JO3i+R4YAgTbsMEg6tjmKB4W1v5MaoWWv7g0Tvw8uN31xYUsUBLEcAfOrsNLz5cb5gwzVDrfI758NjUbageydG+UYtmkrZTrNgs8SHO7al6pbXBOeO/5z+n23HHn7m/SI5qrnU9kiMtDRPAthKpk5Lp5MgyYaykdBZkXesvTpwC5AaJs8mcTLk3H78ykmP/jf7LLO09vUYllc6PYTFpaYrqDde7yySI8T8Xjik80zASOWGiHskRjdpQuE1NHPQSPB5HUWKazQuZlhP4rG6Y2MS8huf7WBp0qZJmrYt5Hg/TFNmF8k2l5usLmrjc75Oew3RNwr0FY8zEiPUx8mRKVpr80xE09AEAFKjGhsU8ijdulNNYmSbhuulrWFASlGsKNDaTzBPTnBuS4IHnGW2Q4Xl2Em83koMBg0QIY0qhx+qff+aD8Jt/4i/A3fk1mPaO5LiahgkftWebwnMV16d3Lp8AQE6ScOlsMgMN2sRIjFmVSA6+uWEiVeVkP+6Tu5D1lFbwN373H8HHb74HfuDOBwCgpF0B+Ok1KCRrjVFaa3icXpq1AwAKglt/wgRnzOyHu+y3XHuR3BxdN0zgMZ97IjmWFnHSNhgNoUwpJ+kRYL3h2iU0tWjQxljdRYssNYRIAIDnTm4AAMArTzYzTOC1NRTRwx5YsHVsRXKInRMmZOWZOygoKCgoKCgoKCjosBV29yNQVGCxsUh6yJEciGn2ESaqE5sewoRS5vvpxD4+oE9I0zhxTKGjHhSZn6cew8RVIkzQRrMtVyQH/ve6posLAfyh09vw7uU53F/TZMUmqT2FKjgfpDG8bdlI8omIWhfCcLquNWFCVhG1tmIeVZpxmYWFjXpMNuHP6fI6N5UiRXR76mwlM0iVNEXsbV2/dMo2PzfLAqAdAdRUILZfy9lk1noa/EFRCB2CvPKXf+v/gs/+4l/b+OdgDAxn+SS+1LmBggHzFrDNPY+cq5gFf+4hTExEBIJzmImkcl5iYy4RUYW2clU1dUzlXpIJZDq1m3om8GPONyRMjCuSYyVlZY10UWpQlUgOzzFQUO5XhOc8ViRKja5JJS2HmciHtgQiqrwQX76nWcuYil0LaWI+/cwnfgx+5hM/utHvKCM5tkmYqH9NRAgTxmg0KGEiP3fovQjvOUhMcxnKukoVlJCICXM+0eloxhhcL5rzMxH3MmksZXolDRNlbMDuHqMjM8Gf/67Xzx8CAMDT82vOr8dz4zAME+XzAZpVN3mulbokTLjMhOv0T995FV569A78mY/+oNnXU8PEumbomKMGl8Xe+SQpIzkSEfUmmkmdxxGa54oO75vu8VG2Obok6uVfgya2i7WRHH5D874ktfKeK30ME/TZ/d7lRefXs8hW5vgBADxzdAqCcXh1U8NE8R6GGn6QWjVGgqE5CEmmHHYbH4LPO0FBQUFBQUFBQUFBV0Nhdz8CJTyCjBAm1kZyiPESJnQxeVIWBjLr38FEcpRoCVckR2GYoM3L4mdRzPOkoeiD0xhnDZEcdb7FYUo2TLu5Ijmw2GEXoGyZSA5ScLlbFGvfLqbdvK+p+Ozs4lHExJUlTLQthHUmTOjmhpA9VW8Xb2LWfRIMoDQ87as5h40i5iBM0DgGgO0ZJlJVmlEiZkVyWIYJXhgCXE1m/ExxsulsMm8fyYGEiQHICL/59ivw9uLxxj8nK5DYZSSHKiI5uD+SQ9XvedikOC9Q2FR0Wm4e54Ya/LxW32aRHDEXwIDVTCMA+X2RRnbYmeCoiG1G48BjP6pIDiu+wtc0qxrMfOenKgvuzG0MoWh5TuJnNJlsjFhuHOpzXqaqGkNmzBcDm2YVaO8kLQDADz79Avzg0y9s9DumUXOsCsqeSLblMg9S4TlzFJWRHENGnuB5ViFMFO8RUePr9m5tJIvc9Yhzc6/3fabzKIHLXoaJwyVMpErCv/u5vwtfvvda7d98a+o2FVmEiTcucsPE3fmp8+vRMIH7iTGLxq8BNNMC24jG0KGpvsvPe7LK9xvvKybwAaAymb+uGSpGHMnxOM0NNJQwMRERSK167TlVQQ8rDT3t37drrZ5YtAs0aqNREPf8tUgOlRlzDEC5jxySeIX7YJf6GCbo195fdjNMZErCSsnK83vEBTx9dA1eeXyv08+yVRImhtlr6yLyz6eSMJGL75goKpXfKBMUFBQUFBQUFBQUdHgKu/sRCAkTkkwkNqlLY3bfwiZymdltESagxCj6CBN5JEf+gE+LOStHJEcTVhQJE2eTufPfryJhwmW2cU1ctydMVJvUAOXxXFeUlY7pcYC8UDbEJP22pUBVaDAxF60ntvBab9uUwclkn2EiFqIyvWwXb0rCRLfjjtffvggTmpjGplFcubaxQTQzhgm+lYmhcjqZ1+gneUG22uyJPTEGWDT+dNEkPJvMWkdyPDKEif2u61pr+Or9N7ZiMJAF1USwnNKRZ/oyENy/zrpie2Ye/DIAwKVcmciOmSiK6MU5UhImxODN5H0ITUXUzITX6VTEMDP34NQ03GKrkB9zsRFSGdcxDXor8TibKlVZZY1sIkysrPXSJUqY4OCL5CgnZhljhjhBCRM5dUv0aghmSlauDzSM9p0O3pb0GiT2NtSaMKGrE8m26B4kdjQ1SsLExKw/feIntiU8z+h9Bk2T15LtRXJIgtanBh+XZlHybRHJ8Z99/n+H/+mrvw4AAG9ePIJfevl34AtvvFT7umyNiXUbEkXDGNen188fwWkyq0TkUSFNrw+6f9+yn1ly4sGGhAljvsjXjS7ECvxa+nki7QqgDWFiO/vRXehxYQY5TkrDhI8C2Ub4nC8aiGs+lZ97NWaqSpioXlslYaIeyUHXFjQqDGXgVFqBBn8jPzKGifbnybJCmOgWnYd7Q9wro547vgHf3JAwga9rqOEHe2DBljnXieF1l3vUTKtAmAgKCgoKCgoKCgq6Qgq7+xEIDRC+BrPr6zcpLO1SmFufeCYptFZglxdrkRyUMEG+Hx/QqWEiaZhKwqLhNVIkotr1xME+Ja1pLaqER7D0ECbaRnJMiWECi7IP1ky74PS4PW0Tj7iw2EV2wSanPLS7LhGxvJDtmh7rkOP2VH2mqzm6UY/JJvw5AADLNRny2xItptYIEwVxgEZyYJPnl1/5Mnyz58QUzVS26SdLmVWINgB54dw1VYXH6g/ffh/8+Ac+Dp955sMlYWJNo+nhQIaJ1y8ewcPVZSUSqq9wsg6n7BHb3GRscRXP8fN1IecvUkqYqH4d0kBi3j4a59A1jeLKuUUJExMS3eAlTGwYyUE/1zHcS1dKVtbIaRR76ThpC8KE1toYO32RHLTxx4GZorwdk2VTgNoqU6piBIh7mt+2rXUNi21o2pL2kCkFDJh370xNAC4iQNmYSyDhAjhjezMJuoTnmawQJvI/4352G5EhWuemTxr54puOnkUxrJTsvF7YU+Bj16+8+hX4tddeBICyQeu6brHp2TTlvKnwvKWEiaeP3HQJAIDTJDczPzgow0RJmNiEZEYn+/H5s8u+1fV8SSM51jVDo4MgTJQGkAkxVHaVLJ4vcN3s8jznMvdPRFRZ40tiYn7MefE8YBu2LmVWIUpxQ7wYZv8ndbPpLDH37n6RHF0JEwsHIRIA4Lnj6xsbJvB5cxPD7SbKCVcNhoni2mUmMm23e1SpZCBMBAUFBQUFBQUFBV0hhd39CBTzPGJD6/aEibEWZpTWwICR6ZWs/u8MCRO57EdYqZUp5tD3iRNAE2uC1Dcd/XC5gJN44kXm0mnQQ5dyFKFQrtgS/FzWYZ0XZqq/LLicGcNEc1E28xiAcnTt4Tc0a5Econ2jFgtrvonNz736VfiLX/gF89+u6TcquxmndBULG/eYBKNfv6/mEW0y2kXUpkiO/+D/+Xvwt37v871+JzWj5ISJqmEC8c6oyNP4xCLtRETwV3/op+AP3X4vmZBuLtyjYQKjLPalr95/w/zZpgF1lSwQuaIwSJSRHE2EiXqeNU51njsaggu5gplAwkRs/g6gpIF0Ib0cumyUNSVMULOOPbGJ2pRWRRslYzDBZUpBIizChGeNXVWa0R7CBDFM+DKwKVqeF3E09O9Zsc3uO0GdKVnZw2AkR5fp6V0ob5rtizDR/F5tU4mtdZEceF0cxQkwxmAq4q0YEvoKzzMaSYfX8LUidmFbhAmM5ED5TCcmqqTjOXxohAmplDm2aMZzrZG4h2067zaVsCbmXz9/CE974jgACGHiACI5bJP3ZAuECSRyTKLuhAn8jGkDnpL11hljxIiN4E9WhWGCDA9MCiPwslckR7nXA+hHmKBrznPH1+H37r9h7sNlTF75NfMoqa3J+dpCIzmGJUyUcSPu5zTB82iuLseL7lO6EiZcz+8AAM+dXIc3Lx5tFDu1GgFhgjXsP547vg7zKCGEMLbT6zMrnneCgoKCgoKCgoKCgq6Gwu5+BIqK6XBX88ilMWe068L1jwVo+3VqgJIwYRoLdEo1/zMWWOn3p45IjomIGyI5FqaA6BK7UoQJ/7RbIupEEizYrGsK2E1qAIAzM8XWPO2iHIWx/L/FaAuLXaR1NcO9S6MWm/K+gtWvfPMr8L98/TfKr29BmKhMTBdxCKg+hAmllbk+9mWYQMOVK27g3DZMkOv3Uqadp69QJi+ZCxCMVQqAq4JaQOUzrKVmKq7asMXX1yTa4NhnXM1XiGFiU2qRLEw6gjOQShcGCmYMFL7vAagavQxhwrE2XaQrQ5aYGcJEGcmR8Kj3JP8haiqqKOtLQpgQPJ8AXVYIE/W1eBPzJVKEAMZBmEhlPZLDR6Ci57tvSlJqBax4W5y53yM9h6k5yDbAJjzqZXJIlaq8p5j1owVtW8q6/+1CU2OKWkeYkI0T4MJhHqQyhoni3jKL4lFEctB7EZ5nsyiGiPEtGSbySXG6LvieP8qokm6/9/LQDBNal4aJrKQX2coc9/ttK7Im5l+/eAh3j655v/4sOZxIDmWay/n62LRWtxE1TaHpoYu5Z+UkTHSI5Bg1YSKns22LMIFmcUOY6PC+8RjRe8cPPfsdcH95Ab/97reKr5HAWZUYNI+S2pq3khlMaSSHMUwM8zkYM0jDuZJHxrW/d6cbESbyz5Y+vwPkkRwAAN86f9Dp51HhXmaIY232Vg2RYH/8+U/A5/+1P18aJnY8ICNViOQICgoKCgoKCgoKukoKu/sRKBECMoJE9+EcUXEH9P++hYUULFg5CRPFn3Fykz7CommkJEyUhQV8QK9EcnB/LvjD1QJOE79hgjM2itz1bQgbV9zxwO5q1CwNYaK5+H3pmFA5SSbAgK0nTCj3+Rwxvtem8K5kI0ETLlo3xLBYvJCp8xxcqaxivlipsqnvUmxRROi0HUA/jDv9jDYpZHeRKprsAGiGopEchWECUatFc1Kq3NjRd6oyJZOiedwGpdrIWrMn4tw9cerKZm4xIS2Vgsfp0jTr9tkI/er9N82fN/2Mc5MOTtmrvBnHMZLDvc7idUDXramIgQGD86LIT7WQqZcwgZPMcceC9CFrKqKKGecyS2EiIjN5h/9enuM2YcJ9LrdV1ew4/L00j+Qor9epiL1mJdtg5lL+nsrivIv+Qs2KlFqlbMOE6Ec+yXQV9YyEiaHPcb0Gib0NTaN2kUaZVl4zIUAbwkT+7/OioTi0YQL3c/QzNlPXjMM8TpyRRV2F91t6THzPH7jedjVqHBphItMlYQLPAff9vvw8diWcVM+0gpXM4O3Fk0bCxCyKIebioAgTeG32NZSVP09W4j0AuplAVw5DfoUwsaYZioSJMT5TPnYQJkoKZPf7CEZv4jHpEsugtK5dM5959oPAgMGvfutrAFA3CQK41+SlZWjmhflmKOqBHSXiUv782/6YUwLI/WVXwgRGctiGiesAABvFcuC1NYRJyI47c0lwDjdnx2YwRwDs9NqUjvM6KCgoKCgoKCgoKOhwFXb3IxA+QGMBqQkzCDD+SA7OOAie4zrtwgBtiKLoQ6wyhom8OEu/32TMtpwgfbC8gLPJ3PtaKdL/0NVktklEVMPtY7FjXVMAm5G04MIZh9PJbK1hQmp3rnjE+WAFrW2qFsnRYbIdC4xKa+f3rGQGUiuCqK2f+1SJZaKSyo7k6N5ko2alTdCtXUQx79Pi2sb1YWERJkTRmEczSd+pykyV56mwzs2lTCHhLsKEP5KDHvdpYTRqmuJ7VORL35wdA8B+G6EVwsQGzQqlFWgoMc0pMUvlU/e+Cf46VYkxBvMo9hImcC1C4wyuYcYwUVyH+4w2GUr2/e9SpsakA5Cffzlhwj0NHXnO5bai04VjiLdKlawQBKZNhAlVNZi5pKE0eApwo74pWp7uKfB4iAphovuxTpXceC3fhaTafSTHxBjOWhAmGpoVwrpP2/rg2W147/ENeOH0FgAAzESyN6qSS3g+0mtTkmt45pi27vV7is+QNnq8hAlrvW2rpUwr2PyxSyppzCh4jF2N95Lasw/ChII3Lx4BAMDTR37DBGMMriXTgyBM2E3PbRAmcJ0s6QkdDBOOPTbSrgDaESYAxhFNZetxscc83hphoiDTFO+5yx4ic0ziPzU9ho/dfNYYJmyTIECdMJEpWYnvBKCRHMMSJpruRV2iGwHKtYczBvcvOxImMKLNiuR4T2GY+NaT/oQJrCkMcayV47nBrzJSbVf1Hq11biIKhImgoKCgoKCgoKCgK6Owux+BsMGjWz4ExmK8kRy04emKgtCgDeKaIboaqGEif/jGB3xqDMH3TAsk9hQ6VRvCxBiaPNtQU5zLpCGSY13RHQvHdgbqWTJbG8mBU0i2Is7NdN4hC+MjUHGHCWLazHU1IPDn4DmPTX1fQaYWyWHly5eEiQ4oWIdZadeimPepiEFDaSipRXIUzUn893UGHp8oyjli1biYpZS1SI6IC+dEnZswsX5CGqdBn5oeF69nP9eGVAq+/vAtuDM7AYDNIjkyMlmXGybyn4UGCh9hwldgPooncO6YoL6UqVmLDGGCNLUmIjIGl6tAsVmnaRRXzq2lhaieiAgusxTSYr2Na+Y1sdFxotfBGExwuWGibHjZx6fytTSSw3PNUSIWB3dzgKLlKbVKWQZY136ojXLzW/mesKGX9pgM3qYU6EYk9jY0a7F+AuAa7m9cU9Oma/r3A9duwuf/9T8Pd+d53MF06EiOYl9Kr6+UGPLmUbKV15dTsniVMOHZY5Trbfvfq7XOjWw7NBVsW65IDtfzFq6broiXbQnP1UwpeL2FYQIA4DSZHQRhQln3/kREm+1BCFUtGYQwUcRTjNCEX0b6ETqjMUx0v4+gWTzi3cl1SruNdj/07IfhN99+BR4sLyrmF5RtEsPPy22YGOYzMFTFhnMl5rzTvRvP4VvTY7jXM5LDfn5Hc/bbi8edfl7ldanhCBP23qpJZXzH7swdbaJYgoKCgoKCgoKCgoIOS2F3PwLFIidGtMEMAhTN0T01MLtKk6n7PKJAOv69+j3U9W8iORwNXiwcVDPK/ZEcD5aLRsIEu0KECVk0xFyGCRfqFj8XXyPic69+FV59ch8WMoWYi1oz4mwyX0+YUNpZOBJMjKK5tqnswl/ShTBB3r9rkhU/LzznV1JCIvxNB2rWwEI0LTjSwntbrXuNuxA9pvaUIJp3cOoPDU/YnO9PmJCm8Ct4NYcam/BUMXdnVUtTlCYNW4GECf96ja/75vQIAPbX6H/58buwlBl87OZ7AKBb3rctatgSjJn1Bafufdd7aZio3hRcedUAeQEYmxhImqCEiaQgTAAMP4G/D9UIE1lamSbESArfNHR+Lm8SyVE3Ow6plZQQW4aRTQgTUiuDdObgRjrTcz+P7UDDRHU/F/cmTFQNE/jnoU2z1Ny2KzWjtksAACAASURBVOG5vG5tyvQawgTZdLZpauT4980JDn2likgOep+h1/C2Xp8qTK206e+N5IiqBrU2ynQel3VIkRxSK2POxFgoV4PTR+3ZpnDtkFrB6+cPAQAaIzkAAE4nM3h0EISJqsl7IqLN9iA7IUyURIZ1gwx43Yzx2ca1z9qEMCF1ThMrnys6ECa0cq7BP/zsd4DSGn7ttRcre3KUHcmBrztxGCaG2ou4TNO2Yi46DQzgeXlnfg3udzZMFAMPohrJMRERnE3mvQ0TeYRsfv0OQZjAIZtWhCtDANsdYaI0yhyOMTAoKCgoKCgoKCgoqFnBMDECRUwUCP4S7dyk2DPhPAbRqUPXxJDSGoQ1lUifYbHYhMWc1GGYSCzChG+KaC1hongdY8yc7SrMvPZFctjHyDShPcXvf+9X/2f4K1/6VVhkaW06BSAvyq6bYpOeJkbE+ZWY/q5HcrRHrdIJKNfEJn4+ZorHgailomYNU8hnZfGmTxMZv1YwvlfChPAZJizCBBqe0CjS1zBBMf4R4xZhom6Y8MUYmGIpaT7h9zYZTgxhwkRy7OdY/14Rx/E9Tz0LAJsRJiQx6QjOzWciGCtIIJ6GtHIXmOdxAhdFs4rqIluZ9Whe/H85BVwQJgRO4I/TVLhNTS3Ckn2+omEg9TT3kJbS9x5Im0NjoDWlKqs0vNAw4hI9331GsgphgnkIE8X7ZsDyNQmqhAncZ7hIT22UWTEjyUgMQdq6/+1CbdZPgPWECVEhTKxvasxEbHDmQwjPM5saBZDfo+INyTDm96gyRgnle/6wDWpthGvTYUVyKNNovCjeqyuuKiPEj10pMtQCBW9cFIaJFoSJBwdhmKhHcvTdg2itc8JE8VkgZWrZYS+FBjS6jlDCxNpIDjQPjPDZ3FVbmBTHqI/xDkmSJpKjw3uWRZyHre+99R44TabwD197sYihqq7TOVWnfF69NGsLNUywzq9nm3KZ1W3FvD2JEKD8fO7Mr8G9y/NOr8dHmAAAuDM7gTcv+hkm6OsfkjDRjnBV0ih2VevxGb+DgoKCgoKCgoKCgg5XwTAxAiWi2rRoQ5hYSTnKRj9tItsxAQB5cwHfHsPGgiOSAwuslViA4s8JrzaEMq1qDcxFlsJSZnA6aY7kwNd86JKOZi3KlZ3eFMmhtYYn6RJefPhW0aBMal9zNpnBgzXTLlJrZ+Eob0of/vS3bZhIRDVap0m08eaO5MiLgTjZaE9O26JmDRepxqBzOxx3vKaO48laJPq2JMnUst0su8hWwIAZagMWp7Aps8jSfg1JgnKuESasBiyAe10DIBnzNA+e582ty6wNYQIjOfZTgPzGo3cBAOCjN+4CwGYT6xkx13DGzQQYNuN8zXQzZWphh46ixEz5orTW6wkTvIzkGHoCfx/Kp3LLa/NSpub6AKgTJmx8fNyj4UFF1zE07Q0pu3HeRJig17BvSlJpbTbJOdK5/h7tSI6SMFFtUvVFzqdKVs1vonu80i4k92CY4IybWJkmZao5P5w26JqMFaimKJd9CM9HWSFMKBCMA2PMew/q83t48fMAmpvChjDRwUiCU+CHQpjAxvtSZpApWcY9uQySHmrPNoVGlkzlhIl5lMAJoR641MbMPAbh+kgJE32Nufiz8PzFWKpukRz5Xo9i/o+6RHJgHMQI9x3K0dA1huQe6xya5RhjeeRahz0rJYFQRVzA86e34JtP7lVi8lA2dQzPFRpBhp/RUHuRzGMApoq56LTHR3PC3fk1eLhadDrWlw2GiVuzk96ECWpEGoIwoVrWygCAEMLYzqJaaCRhUFBQUFBQUFBQUNDVUNjdj0A4sdzWpR5zARr0IA+q60SbyAmPahM+eQOieGgtHl5pg9lEcjQQJmjxtcyqrRapsJl/1sYwMYLJ2E3VRCdJitgSepxXpMlsCyd3Xnr4Tk6YcEwHniXztVNsmXJPEkWeSINDE+Z/o7BR26aRQYte7kiO/GcsTU6srDXuqWISf4PnAi3eYPGxy1Qqfu1JMtkIldxF1UiOapzFRbaCeRSbgjZOF9Eiex/KBC3O2oSJPJKjev5HzH3+Zp7psqmIGrHH+JqfMpEc+ym44++5VlB4+qCZUeW9i1fuX5wxEJx7C9hlbIFNmJjAeVo1TKyKeyQaJdA4cZGtQGud0xWiyDSUh57A34fsJpNNmJhGcUGYcDf3ygzyfseKXitjuI+ulDSfP0Bz47sNYUITw4QAN+qbnvuccXOfVWSyEcBvtFqnTFdNIOOK5Nj9ROXUMgW5RClBLomKeXD9Y8/Uwr/vW9gQSonBMSONxm0ZJnAPg43GpqawMUyk7SM5lsW+fBIdhmGCmqcvsrSkFzn2P3i/j9nuDBP4eUut4PWLR/D00Wmloe/SWTLrTdvapyQxmgG4owPbyt57JaJHJEcR6UU1jwlhYs26UZqSx/dsQ+9RKPPs3Iswoc3P6koMpN9r6/bsBN66eFzEdjRHcuC5QvfnQ0dyuI6zrYiLTuc5rj135tdAad0pbmchi0gOx9DDrdkxvL140vpnuV4TZ2yQZ/m28bW5yki1XQ3HqBafe1BQUFBQUFBQUFDQYSns7keguECY2xM3/q/HhtD4CjOK4DYTIRzZv2VkBz7qVg0TBO1uNSbLSI7qBClAvdmHBcOzpkiOK0SYcE0QoZrMJy7CxGXxd28uHsPbi8fO6ZSzIie5qTCF+di2BBtvpEwX5eaf+sRWm0ZLlTBR/wzw80EjUI6obYjkEMJEENBpf1SfxijSKI6iCUgHxWUXUqSYal/bF+mqUsDGdYZe+30mK2leMiVMaK1hpWRlvQHIj6WrWeWbLpuIuNFwgq/51uzEvJ59CM9BNB50wQTbohNW9P3nTeSGSA7PPW8exbXrwuQxF+vRNIrM32PRf8Ijc3/c5P0ciuzIicsshSlZr3E6Hz8fe7p+070EndhTI9iPpCqrNDCbppZpo8h3P5IVwgRz7hWoWZF+jT0FmfB+E9Q2PcFEcgx4fmutQcO+DBPraQ9Sq8Z9M/23NoSJsURy0P0vjeXammFC5RFYeEyaPs+ZKIg+vQgThxHJQfdlF9kKLgpzSOP9fodTxSZioCBMPD1vjuMAyCM5Hq0uR0kgpJKWWXITwoQd7TXpQZjITVf1GAjUuqhMSgMZm6SuT+T7np3biBqbuxIDm9bqu/Nr8ObicbEnX0OYKKht1Eg+dCRHG9JAZ8KEKg0TAAD315AdqZoiOW7PTuDNxaNe6wReV/MoGYQW2ZbGWnxx8bW7M/WWhq3dmeeCgoKCgoKCgoKCgvarYJgYgWIeQaZLwsS6CaKyyTG+hpBNmLAnKfJ/x//S5H9z0eZDPrlCmvwKCyTVSA6AMq4DVRIm5t7Xyopm99gLi23UNNniQtTjn13N/Qvyd7977/VK0RB1NpmB0hoer5be15RPCbkJE12womOVneGONJMHq/UFLVqYdzXTl8YwUURzKAkxb4rkELVIjophovhzl2kybNyfJFPv69y2KOYdG7/4e8+zFcyjEkeN6+SmhAmalyxI8bfMX68e95yQ4ojk8BEmovWEiYQLOC5Q2/uaHJcqL3pPekxj1n6WidbglWtCFAYKHwo386xbR9EEzrPq2nJhir/5esQZh6mIK1EsExGVDeUR3h+3LRdhwo7kqBImqsfZ5K5fEcJEKi3ChIidkV0AViSH535E9yveSA5iVuSMmWOijRkIiTn1aKw2yix6whj2f52Q2BtqGjUbzgDczU6qKmGihWEiSoxxdAjheUbP25wwkb/2bUZyYGwSQLNZG82KLoOnT7576FhVMUykS9OgdZmT8Pg3kU02FS8Mh1IXhomja2u/53QyA6kVPEn9e/MxyB4Q6BtZBFAnTERcAGes055m6SBMJCJqFVdDf/coyY/FXo/WFkoKR/d1hD7ndyUGSqVqEWyo27MTeLC8gPN0VVunkfqD91WzthAzAJpahvoM8NlhXSRHl7Ubjb9omLh32d4wcZGtIGLceW+8PT+BpczgcY91Al//LIoHMQjhXnOdiQmAmCv07mo9baJYgoKCgoKCgoKCgoIOS2F3PwIh0lJ7pm1txT2mxfclWkiJHYQJpTUIXRRLzCQmabqQ5kNcRJWgsLBDi1oT7iFMFFPbpy0IE3oEjZ5N5ZogQuGEPC1GlpEc9eI3/bsHywsnzvMsyY0oTeYAShuhijiHTKuDN6rYSHI05zywKAdffPNl+PK91yp/R4tMTsJEcd7j/69DjmMkh9baxB/Q5ihjrIiSaL9m4NT5UdHI3ySyoa2qkRzVRv6iiORAYROMTtjbx76NpFak0F4Wf/HYJ9w2TAjnRL6L7JG/jxgus2bCxOlkRtb1/RQg0dC0FcMENuRZlTDx9D/5Ofjg2y96C9jKTOlW162jOKlFclxahAn88yJbmddOGxxpT7z3IQkjN1CXMq00JydFnEFmmns+wkS/vYQiUStjaBStrOiipnObvmffRKqCkjDBmC+So9y3MeYnTOSNkj6ECVlpHo3CMGEw1/shTKy790iLwmGL7kPaNLina6hAu5Y2hglCmCBT17aZuK+kVsAIYaLp2WPagaCFwutueiCGCXq8L7KVMUzY0YIA+5sqFozDP37zJXhr8bg1YQKgn3l0n7Kx+vm9qi9hor73moioZqRv0kpJ8zxJhYbxdZEcYydM1Pel+XnbZ19PKRFdiYH597qvmduFKeC18wde2gfu95eqbsbCz0h5IuB2Ldezl62449q9UhlEjJvIvvvL89bfu8hSJ10CoCTavb143PrnobAWM4+SQWge3Qyb5dfuao/qM8sHBQUFBQUFBQUFBR2uwu5+BIp5jtNvanpXvh4b4GM0TJDIjYRHtUKj0hrw7ZlIDuvfAfLik42+T02BZH1DBLHBFOFv62pGcjgIE45jhMfVVfy2/85VcDlFmkJDg5pmblNFA08BbUvSMkxcN4aJ0kTy5sUj+Olf/pvw33zx/6x8Lz3nXEViE8mhKGHCX5jHJmGmlSlg2WYVX6PfJ0OYKAwTTU3/bYlGckyt8/YiW1mI5C0SJsiELR6/lWc6Nl5LmLAm44qmtU8PVwu4lszMur6vRmh+/nJz7vTNDweAyjlHp7mf+fzfgU+88sWGSA73ujWPJrW4IPxveg7Mo6RGmIg3yOY+NCFhAo/vpUyrhIkorkRy2OdmtKFJh67hcqAmBZW9TuKxcF1/1EAoPeeK1opEcrjvWZKYPDljxoBpGoK4HxJRr5iYVKnKe0Lz2xgIE7uMI0Dl5/CGhInidXLGWk2lzuPciDSUKbmM5KiaevB6TXi0lc9f6zySA/dpTYaJiAtIuOhlmLBNh2NVNZIjNe/VRZjIiElwl3rh9BZ84Y2XQIOGj918z9qvx715n3iyfUq5CDxS9jJSu8wreQRS+3PVphOhjopnyHWDDGMmTEhiREZhTE6fe5LS2qypcVfChCeqEaCkKHzr/IEzkgOg3Ae61hZjWhkgJiL/vetJA3HHtXtVkE9uFM+X9zpGcrgIkQA5zQMA4K0ehgl8VphFySC0SGOYaGPYNF+7u1pPSZjYvYE0KCgoKCgoKCgoKGg/Oowq1hVXzPMJDVp4X/f1AADpgBNwPuWGCGwQCJMBjNIAtUdc+hBrmgw8b+TRBu9K5o1Nbk0R5f9WPRYrU0zxF9GvkmGiKTvVbohqrU0z0W5KAtQzqt2RHHnxpqkoiw1ZW4I06Q418xMz3NkawsR//cX/A86zVS1egBb03IQJVySH/1hhkziVspz2t86FRIiOhIn8a/dJmKCFXWOGKpoW5+nKxFYAlNcvNZz0aRJkpCEZcW7WA0otoIqYG6nrw7JORNxIb3i8uoRryRRitl9ykCwmlsvC+SaEiXL9EZXzVAEDd5QBkL+31wnasMQ1wpXHPItiuMhW5hxISCTHJu/nUISf3VJKmEUcljKrGHxwUt6Hj8f/7tt8pc2hMZCa7OiiSYRriMOU1oIwIXVJmBDg3isoYhbiUCdM0P1QH4pLpmWtKRsLMaghyLy3vRAmmg1nAAUlqKFJJQjlo42Oiuin83RlGtD7lDFMkPMyI8Y+XyxU99+jC3NyYZjwoPJRSPRpK9wzHGIkxzmJ5HBda8YwseM97C//+H8Iqcrvo/ZexKVrCUbDHYZhAu/9ExGBBg2pkq3eJ5Vr7zXtaFBbqcz5vIhrwbrpcbw2x0iYUIQIgcL32o8woc3aLzquRVJr77G8UzTxn6TL2lqN+z7cB+LrpvQafCbw7Td3LWmIaU3GMw5p2v54LWV+PVxHwkSHSI5FtoKpzzAxLwwTFz0ME8U+Zh4lgxxre2/VKDKItKtaT1m7O8x6RlBQUFBQUFBQUFBQXYEwMQJhpmXbh8ASyTy+wowmU/cJr2d2a61BlP8BANUmBJ06sovCOGlB5aIn5F9bNIgaCm9Y8LkKhgm7+EiVGFNJNeYBoDmS41oyBYB8wtPWmSFM+Is38goTJrQDSW4fky+++TL8/O//FgBAzThEi0yXjolNQ5hoaZigphiKiKeKWDfDBBZ+DWFiL5EcmhTQcTq8JEzQZjlev1shTBAkOb5vn2ECDW62fFjWdQ2/J+kSjuOJ+b59EiYE4yayZ5NIDjPhaREmmPZP5gNUI5iosElxQa4NLJRTA9cMCRMEzzyGyIJ9CZsFeH5dZmllvTaRHJ5s7ZIwsblhYgzred5sa0eYSKU0jVzflCSNXfIZf5CsITivFOW1lbOddMwuR7lITUlBJRtKpUlkP5Ec6+496RrzJX4GbWkAaBI875Hvvg3hOVQhTJD3mAjRazLclixi0yK2PpIDAGAaJU6TrU9LD6VprKKUnItsZT5/l/kOn7/amnD6ihexWW1NBGfJYRAm7AEBJAX0MYK59l6J6EaYWDqeLwFKSuE6Mo0YMWHCjg8EyM9bBqzX8VaEEhF1jOTIlPQeSyRMALioY27CRDWSQ5jXN4Rwn9V0n+m6D0iLmLFZw17Gp11FclDDhAa99+PdK5IDdmfqDZEcQUFBQUFBQUFBQVdPYXc/AuFUMxZH1xUtkxE3hGi2acxFrdCYF27yP5ePug7CBDBjJEEtVb2gNTENo+rvMfmmDcVMNKaoEUzGbqomOokpRJLmO+qiIZLjO288DQCeSI4WU2w+9Oq+G8O7kI0TBiDHpDBM/A9f/jW4OT2GH33uI7UmA23QuQpgmBGLGcy0qe8SbRL7Yg7y7Nz2hS38fI4L48xib5EcFmGiOD4LK5ID3x8tivcxTEhdNiQjzk0BcOXISMavcTWYDeXFOu7TqJkwcZ6t4Cia7L3Rj2u1L9aoi4zxgXPrvNPAwG9KwwZ0Db9cNClowxKvIboezQvChCmec1FGVm2hoTh2TQ1hIjP/T8/Xs8kcljKDe8VUot3cizY0X9IG49DGQ6kUKK0r79G3PwDIzWWzYj3xTQUrQpjIkc7NkRyM1QkTxkAqol7Uk8yx9sc8GiQ7HKU8prxdCGNlmkTXcJdKMkO75jaSjM47mAO2Kdwf0OuSGmfyz3/z9Q3vt20iOQAAZiKuEciadGmamu6m3dhEr6lFtjL7Y9c9WTZQ3YYUElEejZwwYe9T7f1eF6WOZ+euEUjYmLY1j5JWRiv83UNEFKyTJPtqFGMMEiGc98Z1opEcEeed3rPS2ns8b0zn5t/svcpJ8RyChIWVw9CM73EoyocxqzcSJroZ1/NBEWH21l32EAvpN0ycJTNIuOgVyYHPpfPiZ+/7ePuM1k6RSI5dXZs+umBQUFBQUFBQUFBQ0OEq7O5HIERIY9NjfVYqNjnGhxynkywTUSdMKNDAND7k1gkT2IDhnBeFhWokh13Q8uHkXcUUW0gH6JOZOzb5muQApBBpxTwAeCI5iiLxd994BgDckRy2OcD3mlyvB8/fMU5itZWL6JGICI6ixJhIXjt/CB+9cReemh7XDRNaQVJMeLkywbEAjNnZqVwXySHM1/mmXboW6vBrj6NhIjnsZvB5ujKTvwAkkoMcv6apyofLBXzpnVdrf58W0RQAYCZtM6UqTXgq28iFyohpgGoiosaG33m6hKM4MZ/hvoqP2IArJzs3IEwQs0hl6ksDcNDeQiWeY/bEIRImKAHHRZiYImGCNObGbCjctqZF5MRlloJUClZKmusGAOBjTz0LAABffOtlAKg3jGODEe93rKiBYKipThTuNeh7bCJMrKQ0BX/fvUgDMUwwVjGI0K8ByIk3nDFjwLRNdUim6XqcUhIZhIp4t8bJttVtwnMzYaxMk1JVjy2hwtfZtrmNhoknAxEmsPFGz0v6HvPPf1uECVYhLDVpHidrzStUh0eYKI/peboy9x/XvTE16824HqNxb97HPLpPqSLWgRFDGUBpFu4il3ll0pEw4SIYAgAcxUljAxyF186QRjafVEGSsTXtaeKTWhnCW8R5p71WppT3eHLGDfnAvq6++6n8efS33v4mALjXFnyPQ5k3ZYvGedyRDpRHxeTvsWus12W2MmQKW4wxuDU72SiSY1YYm/f9LK+g/f5DExrWroZjxmqeCwoKCgoKCgoKCgrqr7C7H4EwRxwfhA85kgOLYADYWKw+3GtCmEDnv658fzk5ELFqIQYnLagmHpx8K8MEEiauhGGiKZIDJ67LKWQAbOQ6DBMy/zssULkmVKZRDLMobmxQew0TI876bStffM7ZZG4moN5ePIZbsxOYR0kt+kQWRcNpVG+mS6VMAQoL9SslG5sOZSSHNMfVLiZFHVGwK0OYwEiOfREm7InDMpJjTs5FfH/47/MoaWwS/K3f+zz88V/667WGZUYakhSr7FtDbCMXShLTANU6pPx5usojOVj5Ge5DeH0KziFifCuRHJxVCROsaDj7CpW+SXX8nM9JlA2ajmgm8zyKYUEIE4kQ5vP6djBMTIipyEVE+fjN9wBA2WSIHSYqAIC057Q6bQ65zAT7FH7eScUwURpKXF+/jjAhlTIRYr5oGZpbzoEZA6a5R0CVmNOlWSKVAg31zPeER4Oe37iGtsoQ31DrDGcAGP/VTBOjxoB1chFu9ik8vvQzphSNpKP50f97dBHJkf/cdQ2omYidBk+f8B46PRTDBHkWuMhW5p6TOq7ZEr8/rtz643gCgvGDiOSgE+IYJeV6JlknGgmGSnhkJuHbaKWkaUxTHUWTVoQJvDbHS5hwxzX22fdRElzERaeGufI8F6Juz3PDhG0SvDU7gfefPAW/8dY3AMATyTFw3KMxTTcZJpjoRAeiUTH5Od2BMJGlZo/j0q3ZycaRHABDECbw+btFCRNrI3p3tZ42n3tQUFBQUFBQUFBQ0GEp7O5HICwMlISJ5qIlNsDH2BDSoC0EtUWYIIhr5iJMkAfPRFSbAnTSAjWxptDLr5XAgLWaOrwKhgllmjZNkRxlvANAPonWFMnx3cV08jGZ6qc6S+bwYOUnTPgmicSIC4ttpT0TLmeTGTxYXYDWGt5aPIZb02OYR0ntOEutIGIcZiKpIa7pNCMWpi6z1BSUXUJKTaqkt3Efc96psIVfi5//vggTjFUbjJcyA6UVXGSrSvGPWYaJW7NjeNDQJHj38hyWMoNLK1okn9zFCdsS6bvyTMfGnok6g4V2ESYaIzmWMI8mppm9jUZYG+Wmnc3iAujPAsibBtX3n0dy+K51X5TQkUHilw3LhSOSY1YQJsrieWzup/syngwpijHHpjJdJ04nM/jg6S24lClwxmqGOjxWfQvetDExdLQVmjNpo2VenEcuklKqpJm+9E0FK0qY0NqZgS0JSYKTSA77HlGSXLph4u33BJBPqQ5pODQTnrAHwkTUbDgDqFKCfBKM1wxDPiFVaTjDREGYIJ8xjeXqan70/x5VRHLgz10TyeEwfzbJrMvRoRgmyuN9TgwTrsY7Xn9N5K8hxBiDa8l09IQJqXRlr3AcoUmpu2GCmtZQk457GpchHyDfb7SZHDdG8C1E5WxbvnjErscIhUYrgPx9d3qu8LwW1N35tfznOq6rT955P/zGmy+D1tppmMD97FCGCSTUNJ0vsRBOA5ZPlKw56Rgzkxsm/M+Nt2fHvSI58BnVGCb2fLzRlNpu/4H7sN3VelzrT1BQUFBQUFBQUFDQYSvs7kcgLLhhUXjdlJeZCh0QyewTjeSIeR0fmRsqzH+Yv0NJMnEccV5pHj5cXZocU1Q5tVn9Pcui+NU0AYn/NnSjZxuSnkltAKhNXOOxOk1mkCpZK7yjYeL9J0/BX/sXfgr+1Rc+4fydp5NZY4NaeaaasGnRd6p5DFKegs31yRE8WC7gSbqEpczg1uwEZlFcO85ZgcidOfLZ6TWDf76UaeOUZkmdyUgkh41x79Zkwa89ifNrzjYa7EKaTK5Vm8H576aRHHhu4TG6OT1ubBJg84s24QFwOrma4Z5pZZokbsKEI9PcMeUIUDT8PFO5qZKwlBkcxwmJWtrPdZEXrstCbB8UNoq+92okR26Y8BUqfWQcnPCmRiNXJMc8SmAhV6R4Lkxjeoz3x22rjJzIjClnaiGYP3HrOQBwN/bwvO97zrnMjkMJGwkxaXo1RSssZWbOM59JiRKzOHMbf/B98+Lct5vddD+Uv87256VvcjFifKMInU1lyDB7aBBMRbTWMJHTF5ob15yx1jQAvM886THtvg1JH2GiOA9yepvaOE5O6rxpbd//fJpF3QgTaLKceLDwYxNdwx4sL8x57rqXZCNukp0mMxMNN1YpEr8GQK+57iYlF2Fi0pGe4CNM/KHb74Pvv/OBtd8/ZiO4L5Ij4f0IE1IruHb5CFZvfA2E9Zze5nubrpnbGMnheL3fd+f9cG95Dn/w6J2SKsbrkRxDfQa4n20a1MC1u61SJc0zSFeDy0KuGg0TOWHiSeufh8JnBdyL7/t4d4oEM6Sv3cXGlbSh8d0LgoKCgoKCgoKCgoL6KezuRyAspOM007qipcloH2FWKkV/TkS9Qau0BmbVeGnTRemyyRBbDd53Fo/h1uy48r2Jhe1HrWS2Njf5KhEmZPHAalrr9wAAIABJREFU7jp37NgSbLScTfKsY7sAvshWwIDBRETw2ec/Dk9Nq8ccdbbGMJF5pj6xSTvGwmJbSU/BJj8mFwZzemt+YopK9DgrnWPWp44GBJ0gwvN/KbPGpkMZuyJJA6/62mLeDQWLRdD9EibK9YMxVuDYM7M20mY5vj9spt2cHTdiqLFpak8w0ulkbLpJpcpmD68bJlwFz7KBYscGxd6iNJo4juKJ+Qz3NTmuyKRf0jHv2xadsKpGcvijDPA1ANQJE/g5X6RVwgRnrBK5MItiuEhXJI4iJuahwzVktVXFVGSak9Xz9RO33gsA7mJuSZjod6zoGr5p83ZT4Xug58dRg2EiVdKYS3wTkjRCjAGrIPtRylqz0IBp52zjXqULYQLfk212selb+5bPMLgLTUUMl1nWeH7llKA2hIm2homhIzny95p5CBMxF6BBb2xSkloBB2buf2sjOaLYSWvxyTUFPmbR4/3u4hwAwBhebZX0l/E9Rp9OZgcSyVEeO1yrL3oQJjJDuCqv720RJn7qw98H/+OP/qm1349mrH1P27dRTvPwECZ6GO+U1vAv/vYvwGt/9U/UntPXv5bmSI47hjDhMEzcfh8AAHzhjZfgl1/5Mrzv5EbFfIE/13Wf3oeMwbGJMOGIKm1STtbMz62k4+e1LpLj9vwE3r0877z/w+sKzRj7PuftvVWjzF5lh4SJPRpIg4KCgoKCgoKCgoL2o7C7H4E+cv0uAAD84zdeAoD1udDxyAkTjDQI7IIVjewwiAkfYYLxyoP4O4sncNNq3pfYfjvWwD0tRIXF/qEbPdsQxYLbKlHghWGiaMifGsNEtUB5WWA8152HZ8kcHiz9kRxSa2dBAwthYywstpXymBLOJnN4sFwYzClGcgBUsfBZUTSciRgWsnr8nZEcrQkTkhSPralkzjuhYPHnnCST4jXsfr2hkRwAOCWYGirEnExL4fVbRnKctCJMXFgTjHStoBnIeJ3YhImYc2ejykuYKCakXesMmjeO4okpuHcppm6ijJA1JjzaKMKinPAU1TWoIEz4Cti+c/UI8dzkmlnIFOZRUjk/csJESqYNhSEMfDtEcpS57yWFxY7u+cTNnDDhmsCP+GYmHWpwGqpJgSobmOX1imYvV+M7n9wUIBj3mvdohFhecHdf93jOc2Cgi68xOduAxJwehAlHIxCgaLpsQITZVPhZr9sjbEPTKAYNuvF6zilBzWaIPHqiZSRHg9FmH8J7CTU4SqXMfX5bpjBE6+PP2z5hIlsbjTcm0XXg7ct8D3eazGClZO3+nSnpjDkag64lU3i8uhz6ZTRKEpoYQGlS6nPNlVS18rNIehAmNolXwWbpkFFJPtnmFFSyJi7OJ6U1TLIl6OV57Tl9/WvRjevB7XlBmHB8Fi+c3oLrkzn8t//0/4bfufca/Mwnfqzy74Ls34eQMQ43vD+f4dqnnJaZ72kSB7WzSYssNbFjLt2enYAGDe9cnrf+mQDlMyoaJvY9/CBVl/3H/iI5DuU+FxQUFBQUFBQUFBS0XmF3PwJ97OazcHd+Db707rcAYH3REgsJY2wIaSuSI9Oq0mRQWgOWQRhOYjoIE8IiTCit4J3Lc7hV4DpRU8/Upm9aiApfpyuX/NAktb9QYyZbDWGiMEwkuWHCnhhcyObcU9TppBn7q7RyIrBN7MEIC4ttpT0No5IwkWNOb81OYIbxAmRyDguYeVxDnY5i/lx8VpdZWmuEUsVkTfCdC0fRpNKAXie89nDyzxcrsU1pK8ZlWtAZLtIijoFEcuCxXxLCxEW28jaRfISJ83Rp3iPFKq8807EYbeJqoOT/Xj3ueC25Cp1oBDmKEtIE2891QYvofbOsUXgtc84swoYGDtqLwqVxBlRHjkb3RVrHC8+iGJTWpjk0EXFJYBqwobwvTQhhCa8D21j1kRt3YSIiZzMo3jCSQ+qyiTt4JIdj4huNN64m3EpmkPCoiP7yn5+lYUI7C+6S5LnTSA6MJ2NmP1Q1LrZR6llTuk71blu6waC5bZnYmYb7T0rMXz7xDoSJeZQAAzYYYQINKVXCRImy39a9Qul88hzvA+smZGeFQa2tLgvS2z6MNdsQXcOQMHE2mQNAfY3MyNo3Ns1EvDbGZmjZMRHHUXHP7xPJUXw29Od1pSe0oRI2KRq4Wd8kRe5RVLkBqjvRQ2qV2wC16mxMkZ54ENSdWU6YcF1bjDH45J33wxsXj+C7bzwDP/H8xyv/jhSNoeiFvggtqqTjvTvfp5SEibbHWmsNizXPjVhPefvicevXk7+m/PUjvaILuXAb0uAm07m/uKRh7cow0YYsEhQUFBQUFBQUFBR0WAq7+xGIMw5/5L3faf573UNgsuFU6C6lQJnJ74lp1JcP06qYOAYAA5agz7Am6oBziEU5RXl/eQFSq3okR9GEsIvpS5WtJ0xcoUgOpcrjZiuxPgdsjKJhwhXJ0cYwkdMULryEjoxM3lLFZhLrcBuaiAS1C2NnyRwyreClR+8AAMDt+bGhItDCpFQKBGfOguWSXC9LmYHSClZKNhZz8d/SBsPE9ckc7jcQQWxhEewknhavZV+RHDZhYl0kR34+I33Gh6J+YggTq9rfHxemFix6Z1qV1AKbMOEpjJdTjnYkhzs2iL6mo3hSklf2dF1Qw0Qiuk2uuX4WQH78qoQJKAgT/gl+V3G5pLKU5xwSJqiwmfrrb34j/744Ieah8RGYtq2SsJSZBtnUmiiMuYCPPfWss6FcEib6GybQmDj0fRT3CrTRIjiHWRQ7G98rJSEWAiLGTaSVLUWIWHm0jCuSo7zPCcbNcdBaVyIr8Dh1o/y4IzmGNkz4CEu7kKGoNNx/pG4XybGOQoFijMFRnAwYyZEfX/oZ5+Yk2zCx2RqH94DWhAmRdGqwLmV6MHEcANX71NuXuekVo+tsU3am5NrjNZSmUbwXItgmkta9f75BDA5eJzSOKeGi0zFYyeyKEybqa/VZMu8V3SJVbiTUWnc228o15rY7BWHCd219/50PAADAX/jD/3LNeDE0YUJ5iGlUUUGo85mIbeUkrHwN7XKslzIDDbq2Z6ZCmsebi0etfqb52YYwkf/sfRtUukSC4UBMUzTgppJobB3p/SAoKCgoKCgoKCgoqLvC7n4k+iPv/S7z53VF6GhLxdJdSFmECYBq0VdTw4SV9Z1/f1GIBwYRK5sCdGKfSnAOgvFac6zNtBArHm6HbvRsQ2WT3JFTW3wOWOTAwi9OztkF8Bzj6S+yoD56/S4sZQa/+q2vOf89n16sLzE4gX7YkRzuDFUsrn/twVsgGIfrk7kpKlFjSl7AFM5JQHoup0qaRrbdCKWiMT3Y1LOLdtenc7h/2d4wgdOrUxGDYHwvBfh86tBlmKhHcmBx9DJLIeHCGIB8sRwuwoTSCi6yVY0wkSllrpeJVUQXnunezINlNRPSjobfhYnkSLaGWW+rjEwsu+KTuogisWmhm0FzJIevkD8REXDG4MIiTNjXADZZfunl34F/+6M/CMfxpEJbueqi59bSQ0QBAPg3P/ID8OPPf2/t7zedVKcxAW0bALuSIUxY7/84nsCTtN7kTYts8CbCBN2vMMiL77ZBUJLriDFm9jMKqpFUaOBcdiJMuM1vMReDnt/Sc//bhabCHbtG1YYwITir0EfW6ShKBo/koA2elDTot0WYkEoBA0KYWPN5zqLYmDjbaCmzxiixsYmuAxg3h/sKOwIxVarT+bRPTUW8FyLYJrLv/SVVqjvxYOUwt05E3GlPQxvTfYTrz9D3QZd8kRzrKIE+adA5IVLrzua9zNrj27ozR8KE+9r6tz7y/fC//kt/Fj7z7Idq/zZ0PFim3c8AVLgPaLt2r6QkkRzto/Pwub5p+OFuQfN4szNhIt87xQMdb9/zt1PF18aOOtG21IYsEhQUFBQUFBQUFBR0WAq7+5HoU08/D9eSfJJ7XSZusqVi6S4kiWEicSCoNZQnHSOTmPT7AcBMveGD6DuFYeKmRZgAcE9d0CKDTzidcLUMEy0iOZAwMfERJtpFcnz2Ax+DZ45O4b//0j9w/rtvAs+ga0d4/raVb8LlemFCefHBW3BzegSccTItb0dyMJg6MsErkRwyM4Xv5kiOMpoGj6u9jlyfzOHB6qJ1QZdGTOTGhf0QJmys8lKmpbEgKiM5cJ1ZFpOBeD4/WEuYIE344thiZj3FKpeRHPbEvpsEYa5Bq9DbhjBxHE+AsTzrfV+GCUWypCci6tTItVVmN4tqEbOINPBHcrhR0YwxOIqSSoTMQqbGIIFCY9enn34B/uIn/6j53piLb4tIDjN9n6XlOuEwVv3kC5+A//z7/pXa329KNVFaGwPn0PdRNJAmlsHpKJo4p5ZTKSHmEQgmmgkoupxQBHCRZdyRHFLpShRBH8IE/i578jkRQxMmMJJq948QZSSHf32SWq2lR/AOhAmAvIFr04j2JTy+FcIEMSfFojRIbvp7BCeEibWRHOs/C6qlzGr3zzELr7djEv2FxmK7UdnmnBtKrn3l2GRHcsRcwEREvUxKS0OYoIaJ9tQsrTWsNjRMmKjBERomlNbOWBykBHaVNEZCXZht29+LlMe8gXpqegQTERmjua1ZlMAPPv2C89+GJkyYZ681hAmA9nuupSojOboQJvD69x1HAIBbSJi46EaYyCNPo8GoKqVhosX+o/jaiRAm2nHbMs8/IzXQBQUFBQUFBQUFBQV1V9jdj0QxF/Aj7/kIAKx3zZti6QgnaDVpHuDrtCM5uJXJQQkTZcGBFZOfFmFiWjdM5Lme1WOxIkUGn/A4azh8w0TTxIXXMFFMztlNgbaRHImI4M9992fg19/8BnzhjT+o/buN3EWZIssIC4ttVTaMbMJEYZh4+LahoSAVoWqY0BAVuPgaYYIaJlQGi4bJcVRC1oTMgwe9PpmD0hoerS5bvUdcX2Iu8onFQQgTcUGYyI8RbZgzapgQUSNhQmttmqZ0gpFGYgCUhc5M0UiO6jriizHoQ5g4N1EjE/Oz92WEy5Q01+KEd8uhrv0sD2ECisK6VO41VnkIEwAA87ja6F5kK5hZzbdPPf08/KmP/AD89R/6k5XmVT71OD4C07Z1LZ4CAwYPVouSRNNi7UbFrFg3emZQZ1qZ++xQU50oul5R5YSJehNuqSQkopkwIQvDD0C5WbaNIRrK6A3OmDGA+ggTXaYcU2Jao4q4GDTSSptIqnFEcqSqTSQH69Tg9p03+xBeS/S8TMl6HW3JNK1AF8cFCRPrDBN182eT2pDexiRstGIMGQDAWbGvsBuVbc65oTQVUeP1MgZJpUHw6vpxFPUzKZXm1vL67kKYcEV6dJUxTIzQCK6sqDvUWTKDpcw6m2tyMg0AFPf/Lve0bA0NiDMOf+fH/gz86Y9+qtNrAgBzPg1lxm9DmOhKkkNzAkC36LyFRMNEM5nw5vS4u2FCSUh4RAzm+92LYM3IZQKqK//ahHNYyN0YIA3VcaT3g6CgoKCgoKCgoKCg7gq7+xHpP/7eH4H/4pN/bG2OKhZLN0Go70o0kmPiaBAo0oBA0f6DIqQEivp8e5EjI52ECUfBhhYZfMLXOfRk7DbURJiIGAcGzEzIlZEcHsOETGHaMJVC9VMf/iTcnB7DX/nSr9ZfE0GVU8WehvMhSXsMKmiYuJQpMUzUmwyZksAZh6moTwIuyXFZSmnIDu0iOWRJabGOPb62+y0nyjKVT4IxxmAa7YcwoSyTDRb+zwsqBJ2WwiblssDD4vnsymReyswUM+nncE4IDwBQKQCuZAbc0WTz4dDx59vnBDaMXIhs+/fHxCS2a1FD06aRHJkq33u1MJ8bJpTHlNZUPD+Kksq1kZNvquvS3fk1+Euf+gm4Pj2q/H0i2qOLD1mCc7iWTOH+5YVpkHVpUJbmn34NBqXLqXc7qmLfwusxtgxOR57Gd1qsG4Jxr3kvn8zN/4xntW0Mye9zhWECSsKE1qpCICqNix3w5R4TSMxFp5+zbXXJEN9UeN/zNYqUVhXSiU+C8U4NjaPYTSbZh3AfTK/LTEtjcEo6Nt18kkoV5I22hon8s7Bj3HxaHpxhIj+vkfYHUO6b7GOdKTlewkQR9Tb0mtwkV0zEUdwvBscVyZGInFDYpnm+chAqugqvoaHoBk3yRXKYPXPHWA4NGrjOIzm6EiZ8VDGqTz/9gonm6KKhCRN4v24iDXQ1TKRKmvU+Ee2NzSaSYw3h5+78GrzR0TCxlFlhNt1s/9hXSnWP5Eh4BIss3UlkjonkCISJoKCgoKCgoKCgoCujsLsfkZ4/vQX/znf9c2u/LhnoIbWNqGEidiCoFZSZ4NhDc0dy5Fh1fI9vL55AwoWZIqdyNfuWLSI58HVcBcOEmW53PLAzxiqTKWguwWPpjORoiVGeRTH82Hs/Cr9777Xav0mtnA2KMU9itZX0NMexAAkAcKsw97imMjEOYWo1hQGqRqhUSYO/bo7kKExUSnrNM9c7GiZSJc35NBFxawz3JqKRPub3yswU/45Iwxwb85cyzSM5GggT5ySGg8Y8GMJE8XMjSpgopqhs+ZC6UuXnuz31VE5I14/fuSFc5L8/5tEeDRNlEX3Ssejt+lkAueGkUgzXAAy0t0hpY7mp5lG1ebLIVsZ8tE7Jt0kkB0CB1V5dlISJDgh8jJfp23iVxDAxdKMI4wnsKeFjT+M7VXkkR8S5t6mmtXYQJuxIjvIcZowZc5DSNmEC1+guhAm8r1uRHB1z47ct3/1vF6KxMy417X2oqDGgjfo2b7chJPJo0ObczIgBdVumU5w8x/Nr3eeJ6++ipXny4AwTxbE+IYYJjPqyKXa52W+khokoBqX1KCmEKOVonPc1Kf3/7L150G3ZWd737PlM33SHvrfvvT2oJSShASGBQAxGgAdiUi5nwDZOHCdFQZVTNqlKuRJXCiqVOHHKZZdTLtukKnZIoEjZIhMGYowDBoQRGhAIGlrd6lZLPd3uvuM3n2EPa+WPvd+1115n7emM+7tazz/33u+e7wz77GHt933e36MzPLQh+oQlNLE26vJ9TZlJgcxAOpNx9fOlhAnOeWvCRMLXR2bZtmGCagmVhAmnHR1IHv4IbLfxtm4SyQEA1wa7C0VyBFIkx6a3N2tDuJIiOYDmcVJtlJRQHY2MjIyMjIyMjIyMLq7M6v4Cqu2EwiaVGiLSm1hdwYpzeafLi8KkvBCf5k1TIez+9BRX+iMtglE34RKxGEFNMdN6hAgTdZmecvYpbau9MsJEw0gOUq8EfZso8QqkLk9iNRUVbNQJW9nQQ4QJ3VQmNT+IoCCbhnK8cPqd0eR4lYmlGMmhbyAd9DLDxLQpYSIR55pNIZ7nIznSiapxFqMhR3LQ42ZJnMaGVDTW5MbXWPq7GskhF1zLcOJlMQZxCVFlmMVt6FDTZ9EMFiyxj3i2vTEygvx+20yu6SRMOrajbAOK5CiLPNDH9gBplvX96Zn497jFecnbckN5kzoIBjhamjCxoGGCcVHM3/b5PI+vqI/kyDPrawgTctxG9jOVMCHjzm0rJ0yoDcFlCBNqIX7b+3dZJNU61CNCT8n1Jy4xlagaer4g+TRR2rxdD8K7TvKxRN9zzHJzkmyQXPZ1bMsS+1edoSRfyzQ1TEQXyjBBx5scyUFrOjXiqS5aYJvKY8C6RyEkJZo4rqHrL3TM6QwPtN81Wdc86oSJsugz2rePGpqoSQnLyEucwbPdVtciXRTLqpSv37dzTx+XmNVlifuHBsaHfJ1CkRzNjc25YaJ6zXxtsIs7k+UiOTZOmKA6USPCFREm0u2+SORPnWLp/sfIyMjIyMjIyMjI6NFQN6s9RpXyFphU3JS4VJih4pV8gy/nfVtSY4HEBGHCLuDp703ORANalW7CJWxAmKCGK0f3ClxtlVMF9AUE384R9VSo2ffTBrqWMNFwkhugZut8ESfh+oLytoosq1RZw6jneqJARYQJMZUpbWeWTffTdpYL27Qvj7wAYRKLKIyqxoOXFXojFq+QMJFPUBLpYd1SIzkCN23kvz0+wcgLCmh6akbOkgi+44jtozsvylOLckF+LpLDzguuZdOxZRjassk5MnnoJifHcYiB64nP4trOxggTTCLA+LaD2RLXEzJEuJZdPAfxzDBRUsDWNU1IN0cHuH12JP7d5rzkSWa7R137QR9H4SQnTLQwu7l2u2lHVXIkx7aNh3nTaz6SQybMAHJmfTVhImE5ESsnUs0TJuicJdYUnKdmC5kwIdZDLfLeud785m7ZMMGlddq6VUuYaJAbDwD/8Lt+EH/jI9/X+HVH7vx+synJ+xhdz2NpP1slYYLMyUCDSA6nPJKDcYa/8Mv/BL/6+vPiZ9MG0XhdkhrJYcEStAn1eIvY+ibll1W/5pjpgnQxESPNubqJZpLJmNTKMLECwkR+X9O9dUdZPOKikRwMHBZHFsmR0gubxr+k9z7raSznMZvbubekdURlJIfTnBCqrmkCpw1hIovkqDVM7OD+5LxwfvvZlz6PH/m1nyn9nSiL5KDPWWY4XZfaGDZpv/Sz97oOw4T43jdgIDUyMjIyMjIyMjIy2oy6We0xqpSVTYR1seEsI/VzwoQUycGlSA5CV2sIE4QJjoRh4hRXeiPta+qmo0NWX6gl48a2Gz2rUFmTnOQ7jigKkrlhxw9gwZorfrclTJThwWOmx+2LhnMHJ7GaqqphREYUMvj4TjqJIxdq4qxRLArb0vQsfT8jL8CMxcKoUIXaFyaqJCk1z5Bhouk0WUqYSD9fz3U3UnxXqSQ9x8UsifDZO1/FNz32VOGxlkSYcG0njcOApS2Qn8kmCU0kx0ghTMQsyVC484XdshiDsolTitsYayYnz6JZYeo5Pedt5riIJbNCUEKJafxcEtVEPiYspJEGi0Ry3Bzu4f70TBiN2hAmfOdrizBxOB1jEkewYM0ZBqrklcTLNFXcIcMEfd/eHGFiPlpBfmxKmNB//tT0kP7dxrzBEyjizuU1BVciOTzNeqhOccln2vb+vclIjqCWMEFkkerbmfccXMON0X7j191qJIe07+SEifx6TJ91WVMYGTfp+eq+z57G/EmaxjE+9dbL+L27r4mfXbhIjmy/JsNE3/VKG+8xT+aOy64oJ0x01zChRhYBqbl0sUiO9LuRvw9hoG1lmFh8X6Xp8i4SJtSoOxJRBtsSJhhnsMABcLGdm16P4gqT7LIShuct1UZoHVFlpHLt+UGSMon9Mls7+HZzEhzFJjWJ5ODguDfJaW6/+vrz+NXXXyg1wcwy6gV9zk1vb3pfzdYfWSRHtt2b0pHaqGksmJGRkZGRkZGRkZHRxZFZ3V9QeU43J2jlIpjI6pRu8JmUCU4+Ca4hTNiWDc92xI3o/ckZrvT1hgk5boI0S+LaxlE+jXLxDROpEcUqnbjwbVdMkBNhwrdd9F1PY5iI2hkmHAcJZ3NFE8a5tnDkLtmk64JYRcGGoi+uSvvrwPMLDfOEUyTHPOKa9uWRFyBKEmFU6LnlxVxfTIpLhgll/9/1e7AtqzFhIuYJXCsnTCwT2dBUahE9cDw8mJ7jxaO7+Lbr7yg81pEME57twLKszBg0v1/JjS95fz9XIjlcqegdshiBxqRSFmOQlEzOUSTHuWay6TyaYSAZJvwNEibkqcMgmxJc+LmkBmrBRFRDmKjCmt8cHQAA3jw/wjSOMEti7DRE6nu2U7juPMo6CAY4CseYZs3JNjEJ9F0t2nxPOO+OYSI77j2l6TX0AkziqHB9orWT5ziVhAnOOezsY1HUmNoQk3HnZJxg4HNNqmARwkRJ3ERXIjk2YZiQ4wV+6vlP4/mHbxf+v2kkR1vp9ptNifG8ESkIExLxybfbNSnLlGRxMo0JE9m6UDelO0nSnxXNn3Gl0bNrom1NVImB6xfWVrLk76Nr6mmMuF1TKWFioUiOJI2Wkb4Pf4FIjmUMMF0m5zHNtgZyc3dbwkTCsvt46frf9FyUcF5JYFhGwvC8LcJEg+uiX3L/oJMgYWVrhzY0DxHJUXP+vT7YBQDcGeexHK+dPkTEklIaQ5jE8G1XrHc2TphAXieqlSBMrC+So25gxcjIyMjIyMjIyMjo4sms7i+outoQYpzDEpj3rGAlFQY4suzT7F+AapjIG2+enTfi70/PCw1oWbqpizBJaifbRHNDU3y4fXbUGDHaBVWh7YGiqSRMEjiWDce2MXB9jKVmfcQSxJzVFllk5SSR+YxnXWHM0RQWf+r5T+OHfvWnG7/mtpUXbOa3+X6WC/yYFCHTd/1CoSZhFMkxj07OIzl6CFkiit665j3JsW3YlpUaJkrwoLZlY98ftIrkoGJoz3E3UnxXIzl6Ej3m264/U3gsbftpHBWQtTPN+yRjxK7fUyI50r/PEyZYqekqLxAXi4R1hAnd5OR5FCqECXtjjdCEM2GI8TWmszaSm5bFoiEZJkoiD6TpfFW3smnw22dH+OrJAwDA07tXGr0fT4ogetS1HwxwEk4xjmat4jiAlNIiGxPbSo7k0H3HjDO8KcWqrFN5zIZKmJg3LNG+HthuGoNTSkDJ1ytEmFDNP4l0zrIkE2ZqDpUiOUquk00+k6ecV7ZumGjTsFhS1HD/yvE9/Phnfh7/x5c/X/j/poSJtqL9Zh0NljoxziRTBBkmEvEZV2U6JaITNXvrGpm0XikjTADFeLFZEl0owgSdB3c8yTBRQiqoMvttWz2isnQ5koPNN84HbrAQ1SVkiTheSFURbXO/r4n0aCv6LGXm0G0qUdbVJKIMHs3aR3IAaQRn2fFR+l5YsrbGsmVZsGBtzbyZsDTmrsq0KggTDc7dM4V80obmISI5vBrCRL9omOCc47XThwBQul+EmTk3J3psdi0ijCloYNjcoGGiqwY6IyMjIyMjIyMjI6P26ma1x6hWXlbk55zjuQdvbvvtCHHkTQIxmSUVUmLG4NJNbnYjK5c26EbYyRo5AHB3coqEMxFxoCrN9SzesIcsrp0WEs0NFIsrX3z4Jr71//zoyubjAAAgAElEQVTb+PzdVws/f/X0AX7plT+qfM5tSVd8lJU2RNNtJEcNqIQJMZVSg/EsPnf6XKppRTdBBkjYVKlJ9ez9N/A5ZXt3WVUZqvtZ9IVMRBm4fqHJkGT0jXx6Vm7m5ZEpYRKL7dqrKeZ6dkpXqMKD7gd9HE5bRHI4ZJjwthLJQSaRvuvhG67cKjyWzjMhy9HYfkmjnIrwj/V3ChnZZ/EMFiwMsv2dTCYJzwwTmm1e1qyKS/b3nuPBgqUt1J1FM/HawGYboTFjsG2K5HARaygxTSVPWNFzAsgIExRloG+olxm9bmWEiTfOD/HyyT0AwDv3mhkm5AiiR10UtXNnfLJQw8e17YUbrwljopmv+37/5avP4Tv+77+LB9Ozuf9btcoiOYgeIzfixGOd1OBTtt8nnMGmc332s7lIDpafs+QMdcZZ4frQdhIXyM8xKrnGsx0wzreGHm+HxF5OZAL6F9naS23Wk9mlCoO+iHT7zaaUcC6u9zFLwDlHzCXChKCVLBvJkRrW6JpWT5hIr1W6tQCtIwvmzwrj8h/cfwP/5s2XFnrf65JKmOi7Xh53phy3kWRg6Zp6FcaWrogpaz0gNSkt0tBMG7hKbJFNUT7NCROq6aKN8niC7hk11XU1ybZs7AX99oYJzgRhItAMRlS/Fz15cFVybXtrsShlQwKy2hAmyOwTSJEc6c+bGCaaESauKYSJw9kYp9k17zjU3yuGLIHvODlVZdOECVp/2E3WH2SYSN+rStRchWJmCBNGRkZGRkZGRkZGj5rM6v6CKm2OxvjC/dfxfb/wD/CH929v+y0BKCL1xeSJdHM/jsO8gGrlv0OSG29UjHz97BAAcLVXQpjQNMfCkmanLHqf6jDK72YZzHKmJwD8zAufxY/+5icqn3Nb0hUfZfm2I4ov6TRWWrQZKOQDMZXSJpKjBA8dSZnbsvJIg7zIMmPxhWpwChKKZsJlPxjAtx3sZaQJYN6YkhYwbe3EJkWnDN0AsySWIjmqvxPfdhCxWIpHmN/2B0EbwkQiCmK+44h83nWKKcQBOld882NPzTVCC81IaQJLtx+dS4aJcVSM5Bh6vniu3AzBECax1qTiljQ+k5KJU8uyMPR8bSNgHKuEicWn/dtKjsxZZPpdVj5hZc8VDS3xmPmpv7LJRyAt5NqWhdtnR3j56C4A4Jndq43ez7Yn8DcpMmi9PT5ZCH+/zLZKOBfHnm6qk9DOd8anCz1/G5Vh1QVhQmp8U6PZs9NIjmaECfpZ8bFRluedPiYnTHAU9+0yY2GV6H3pCBNAs8bJOtRqwnNJ+bYDCxbeGh8DmJ8QzQkTK47kcOf3m00pkSa3Y8by86tFhInmTbcqkWGN9qcqShkAYe6bJJpIjmydUljLVBAmfuLZ38B//ZlfXOh9r0uqYWLoBaWRHIlE1+maciNuhw0TmL/2j7wAEUtax4Pp7vd6LcgHZOr3nMW/T7r/2lYcRJVUcpusPb+Po5LGeJkSxrIzP9dGb1b+bnbvsy7ZlrW1WJSE19Mz6B6hyZpLrFMc1ShXv60nSQQLVq2J9nJvCMeyhWHi1YwuAQCHFYQJ33a3RlXhSxAm1mEik+9/jIyMjIyMjIyMjIweDZnV/QUVNTnoJrdtwWNdkqMhdEX982iGXnbTbwnChBTJwWhywMZHrj4JAPjHf/RvABQn9mX5TjGSg3OeTUDUGCao5MNVwsRb2fsuFiUmcdQ4P3TTijmrnNqRkftycbHneoVIjpww0cIwIQqTUvQK55jEkZZUkWf95o+XSQoXQVUZ7v/he74F/+23/plCQ1+NPqHmus4wEWZREL6THuNU9K5rhnq2i4glYiJ2qNn2B70BDmfnjT5jLEVyeLaLaMlp1iZiWaY6iYp9ahwHUJzm8cXkrSsMJ7IEYWKwWyRMRDMxSZw+Z9aIqiBMeBrDDwBEFcXSoeuL+I8H0zP85u2XpNffEmFCer+0nRc9BmMpBkZ8fzSZn50uddPw8nS+Ks92cH2wizfODvHyyX3cGO5hUIMXln/3ayWS46AnGyYWIExY5ZEUdUo4E8eermhOk6un4XSh52+jKDvuywwTOsKE77hwLLu0wcLB4WTrhNz4U3zsNInEds8JE7xgHk3/zxYUoKYqMwNQ42RbpiA5Om3dsiwLPTffr9UJ0XURJkYUpbThSA7atoFEmJAjj4DVGWbIsEbXgbpGZlUkxyRbp8hN+lkSl0aJXe4NcX8D5Jk2omvUbnbOqIrkiNYYLbCshGGiw4QJ3bWfru/jlialkMVzdAi/xZqG6AjLECYsy6qkFW1TVZGN+0EfxwtEcljgAOetqAdAubF4VXIsW0u72oQSzms/m1cyYKATrWloG9O5tMk+nd5/e5XxIEAaJXO1P8KdSVpLek0yTByVmOvp3iinqmyaMNF+/UGEiXVEcsj3P0ZGRkZGRkZGRkZGj4a6We0xqhXljlMjYlk076qUTmTmmHegWGgcxyF6oijFxe+QcsKEhW+59jQ++thT+OXXngOA8kgO2y2YG6hwE9QUv0RzQ4nkeI4MEyq1QiI0dE11UzupqSSL5JCKiwPXx1QTydFrFckxX5icJTE4uNZ4QVMpcpMuTBIknC09MbkpVRkmPnTlFv6j936s8DOV5BFnRJArGTXl7iSfwCZDi5/t17Rd6yaFPCdtEh/OxhhKhX5ZbQgTIUsKDZpN7PfzkRzpZ/iYxjAhPy6P5NBHMZxFMwSOi12/h3GUNxHOo1nBWJJn8jJtLrb8GLXJXFUIHniBMGr8zAufxV/6lf8V59EMY8WwsUnDRCLhgwON6anVc3EGCxZsyxbnIRsUZTBvjCMxXo0wvjU6wO3zI7x8fA/v2nus8fsJHPdrhzCRkWzuTc5qKTQ6eba9BGEiN1XpCBNUcD+NNmCYSBLYljW3Pw21hAlqRDiVCG8mRcrQsyas+DmncSS2e5VhAqDju7kpKWJEmCgaJlxrNYSBRVV1/VuHqAHs2U7BeAiskTCxpUgOMh7R9TtibM4U4q2IMJFksTH0fHWmE89OMexawwRFcmSGCcbTa2jZuuVyf4Sj2aRTDWZqfBFhYlARyRFLUWBdE52PmsRRbEuJ5vyoM7c1UZjMG+R195/lv09r7OW+zypa0TYl35er2g8GC0Ry8NRAyFlrclLMq2mIyyq9nnP8d7/zS/jUWy+v7XV0ipk+lk+W14IwQffstC/T/tmEBDeNw8aDD9cGu3g7o4AVDRMlhAmWRuDo7uU3oabrD3m4hYy9MmFwVZLvf4yMjIyMjIyMjIyMHg2Z1f0FlZdFLFDW5KIo9VVKzbVWM7s55xhHYT4Fywt/AChGcliWhR/90PeK/6siTMiNPtEMqSl+WaK5kd/sJ4zhhcO3s+cpFjRkQkPXVIVcBYBAieSg76avEiYy1HJd7qksHbJ4UkFF0E2liPfWEeNPnahg03TCMN3OeaGGZXnkN0f7AIDbZ0fi/6hRT1SQaRzBlpoaZfJtB1GS4Gg2FlPnqtoYJmIpUoVoF+uWGsnx3Tffjf/4vR/Dh68+MffYgmEiO9YDhTZDOo9mGHkBBq4/R5gYFQgTeQEwNa7Mb3OvpFlZVSwdur4o1D2cnoNxjtfPDlPChGLY2JhhQo7kEKanxSZSY8ks0iaSo46Mc3O4n0ZyHN/DM3tXGr8fLzsWvhZExzoHrzVV6ZTGwLTfVjwzBeSGifmiOZ1rjjdAmAhLGpgjd74JJ8d3VBEmEspqB+BmO7KKuU8JE+l1zpJMmAnnsBRktGxcbKLcDKBEcjirIQwsqm0YJvb8Hr7xyq2CwROARF9YNWFiO5EctC4is17Ck7n9QF1bLypaN1Ljq8q8RlLXMiQ1koP28zLS2+VgCA7eeD2yCdH9x25mmOh7fmnjPV7zpPwy6rsXIJKDz6+XaC3Uluoyy6hsssSaptEkP10PFidMAOgsYUK3rUn7fh/HYTvDhIjk4Lw0sqbsfQDrjS6wLRtfOb6P//mPfhO//Opza3sdnZKK7UxqQ5hQaxl0TWhiThm3MExcH+wKWukrpw+wk137yggTYZLeo+b38ptdh9CQS+36Q2eYWANhIuHdvRYYGRkZGRkZGRkZGS0ms8K/oCLCxFnWiOhCc0gtoqt5myFLEHMmYcOzyWPpplZ9ju+5+W584NINeLYjJmlV+ZIZIH2dIsayTPI0KOnV0wfihlpF+1ORoovREem0eHnxQI3koCLwwPULiOuFIjns4vcsP48OoS/ytwuECdq23S3wyqKCTR3ulKRu57S5bqHv+rgUDPHG2aH4P2rUU3ONGnJ1r0V0gsPZGAfBUPuYg2CISRw1QjXHCmFiM4aJ4vTZM3tX8be+7d/RNkLl7SFHcuhMN2SMGHo+ZkksGlDnCuGBil6MsVKcuFMyIVZVNBt6vmi80bT9a6cPMY6jOcLEpqbGY4lK0xarrEouFBOWliKXhGFCF8mhGGRU3RztC2PJO3evNn4/f+5d34S/+g3f3fjxF1n7fm6Oqovt0cm1HUEyaCO6brrCMFFBmNhIJEcy1zQD9KSAHHXdhDCRKsie+0RpLk2TWGx3OeaLayaoybj422+9jP/gX/1k7bEelRgmRJNqS2uRfJ22mVuIJ3cO8Gfe8SHs+L05ukGkxFWsStsiTBCJJ5AJE8pnbNOkrBJFYNH1tYkBpu/6WsIENeenwjBBptkSw0QvXaN0KZaDzgM7HhEm/FJzSmr26yhh4iJEcmhM3joaUBOlE+96wkSjSI6GJvs6dZUwodvWpP2gX9oYLxMDh8U5OHhpZI1OeXTBOiM5LPz22ylZYh3N8SrFLKk1nbUhTIRKzFibbT2JI/SdZqTIlDCRR3K8e/8afNupJEz4jgtHcy+/CSXi3qJuP8rXpG52bZusocbQhCxiZGRkZGRkZGRkZHSxtNw4hdHWRPj9kw4RJoTrP2saqE04yqUV2FM+j2qXCRNA2hT9e9/5A/jDB7dLG8a+MlVeN9lGkpsbpC9mcRyAJpKjw4SJJpEc1EiW8bUD18e5hKicCsNE+0gOeR+kKVBdwUZEGkgFI/rOuowQlqXSVOrUVyI55ALmrdE+bp8XCROB46bECJZkjfv6UzVRZ1LDRDlhAkgnvx939yqfL2IMIy9HoYdJAl6B9l2FGKpJKbLkx3ki49fVngvPMmPEMJs2H8cRdn0HZ9EMN4b74nGuRJhIt7uGMCFw6MUiYTpxqi+4911fTNKeZM3jLx3eAQfXGCY2U3xMWCKOxbZY5bnnkswiVDCmvYT+1BEIWEW2NgDcGh6Iv79rv7lh4o8/8d7Gj73o2vV76WQrZwsRJjzbXsikQ0Vy2nd0poOjzFywCcNESsSZ//w6UkAorRFSwoT+83PO8/WM4wLJ/GdJIznS162N5HBS8slvvfll/OabL+FoNiklZwH5NlUbs22mVNchWuttKrP7E//Wj8AC8Fc/+Ym5Jli+jVbbsKDz8joQ3lWiZhAZDWKWzBln3BUZJhLOYNu2uJY22YZ91yuYP0lkoiDjRF2U2OVsv38wPW//xtck2vZ5JEeFYUK6fnZNvQtAmFDj1wDZMNHumNNGctjNm8u0ZqyLcaxTFa1om0oYg11iqN/LCBOs5h6SRGQpCwBYHsnVxGxLx9c6m8uuZYtzj+48tU4xidpWJqJDNVlzhUotIyfB1f/uNIkarwev9XdwNBtjGkd47fQhvvX6O/D62WEpeSQlurhaWuQmRPffVUMi2QPFXy3LSq9da4rk6Oq1wMjIyMjIyMjIyMhoMZkV/gVVihyPBWFiW2hmWXTT7ChNOCpYEWa1ZxcNE/Jkqi7q4P2Xb+AH3/3R0tcNMjMA3UQ3zaOV8dmk5x6+JYp4aqGN0K4qeaILoknBMskUjkhCl+/6vcLELBWYWhEmNJNcVaQKep+xLpKjg9tWJzFhi6aECa8wlZnwROzjN0f7xUiOrBjlOw4SznAehY0mx33HTQkT03LDxH4vN0zUSW4I+LYDDl46ib0qJax6P5Ylb3sxgWXrIzmIMEHEE2qenkVhwbBA566EsXSKSlNAd6sIE2WRHF4gGm9kmHj+MDVnjRTDxKbO5XIkB+1fixomiJgCSGY3orBkf+oiOVIyTjVhgtSGMPG1JMuysJfRlxYnTLTf58gAQ8eIjjBxOKVIjnbI70UUskQ0I2SNtISJPJLDtZ1GhAk/26/VeBE5kqNgmMC8YcK3U0PXvWyqnmgzZSJ6gkrYyadUt9Oco+96neY5WfQ9qddRoJzCsax0+80mJCI5yDDB2ZwpJG/iL/790/FrIydMNGlklhEmaO2YR3LUGCYywsTDLhkmsu3Zd31c6Y1wc7hfaiaU19FdE5ltukyY0MUIjrL1WdtjLl2rlURyNFjTEKFRd/1ooypa0TZVFdm4HwzAOMdZw0ayOPeDA1IMWBNjijoQsQ7Jpo+NEyYaNM4p0q/JOl818gTCnNJgn2as8f78+DA1zz/38E28eX6MJ3culZJHOOeZQcmRhh82u883vv+W16ScY6AMLqxKhjBhZGRkZGRkZGRk9OjJrPAvqDzbQcyZKCx1IZKDiwZZ3jizYImCNt2oqohemfBATbU22djUzKWJ18aRHJiP5Pjiw7fwdXuPwYI1V9AgxLAO+b9t1WWnBhJhYpZFPgBpsew8DsV3tEwkh9x0q3oe27JhW1ahsJhHclwww0SLSI5xHIp9PWFcNIpvjQ7wxvlhwfDjO47Yf0+jqZgYrFJqokojOfYbECbqJDcEPGczE80JZ42bcPK2Fxm/jqPdh86jGYZugEFGTqHmzjieFQwLogDIWSG6RlZOmGg+cTp0fZzHWSRH1nB94fBtABDviV5/U5EcMpVGNbe1lTzdr56HRCSHppGQaKbwZd0apYSJgevj+nB3off2taCDzAhFpIM2WpRqQtdqEWOji+QINxjJkSTCSCCr73qwLatImKA1guPArZgKTjiDLSIS0mNET5hIz8+yCVM3sevZ6fnp/uRM+1yq4hIzQN4w31YkR95s36RUUhOQN7lXHckxyL7Ts3izhgnatoGWMJFHZAHLff/5tLcl9q8mE+Z919NizcsJE/q1CxkmukSYiHm2nS0bv/bv/uf4T77+22BbNlzLnjdIVhClti3XTs9r68DPr0qJhi41EASwdsdcek+jj+RoQ5iou2esUxWtaJvSbWvSXpCaLY8bxnLIAwbgPCdJNjFMiHP1GiM57Lz+oDN2rVMJq6d05ISJ+jWXSpigc2mYxJjEIf7O7/6r0s+YsHIDt6o/+cTXY8/v46//1v8FDo6ndy5hPxhoDRMxZ+CZUYbW+ps2CTW//96MYaKu/mJkZGRkZGRkZGRkdPFkVvgXVITIp2nlbaGZZak3sZZlFRqYhFnNsacZYQIyYYIVnqOJ1FxP+rMuksOy5g0Tzz18E++79Li28ZpHWnSvqZ82HmsiOSSKA30HNJl8nGWVUoF1sEgkh0yYSIhUoX8etUknzBxx97atTlQgatrcH3g+GOdin5ILLDeH+5jEkShOzbLmMxV8j8NJ40iOaRLhJJxiPyuCqmpjmJAjJsgUs26zEG8RySFve2ogpcagcsLE0CXCRCh+LhMm6BiKsygU3TnEtfUFz6qi2cDLo29oqvzl4/sAoBg2Fpv2X0Rpw4cIIvOxOm0USmYRcf6nScTs9KolTNTkwN/M4lKe2b3SqJn3tar97Dxe1pys0qImHTEJb+sjOaZxJIr5dSSFVSgqieSwLAtD1y8SJqgRYbtwKqaCdYQJmcjEOcekjDChMQMFGQXoviBMVDcGy+gJZGDbFlmsrWFwVdLRDeicteomnG3ZaYNl04QJTgYdMimyuUajY6em02UmewXNzbal563/PvuOJyLXZNHakagGYQ1hgtYidCx0QbJh+1JvWEDhq+uKiHUbw95zvU4TJnTN5Zzq0jaSY97c2oYw0TTGsU6ubWuNg9tWVWQjrR2OZs0oUHQusgGAc2EAaLJuTRa4v28rx7IROC6+6bEnt0OYqFmnunZzczI9RhD0JNrNZ++8gn/w7K/jt996Wfu7EUsaG7oOekP89Q//CXz5+B4A4Mmdy9j3+yJSTRadU3qOJ0z/GydMoBnhiheORZ7FSa3+nBh3/FpgZGRkZGRkZGRkZNReZoV/QeXZDiIW4yxrRHRhMl9XRPelBiAVnkVURvZ4+Z52EWRnoBTGmha/bMUwcTQb4+3xCb7+0uPaxqsgTHQwNiKpuWH37fzzREmOLqfpImrW55EcLQwTWZNqpiNMlDTw1Eksijnpwn7cRLxlw6ivkA3kzFOKHXgji+VIi7+O2H9PwmnDSA4H96fn4OClkRz086NpM8IEvceyHO9VKy2itydMyJEcuuPzPJph6Pl5RnY8Q8IYJnEkMNAAsOv1sOf38MWHbyFk87nY6WvpIzniionToRuI4i2Z3OhcN5Re319w2r+tOE+JPLQN1XNoW0UsEeeBPJID2Z8UvaQjTJRPPgKp0eRKb4R37T+20Pv6WpEgTCzQ8Fk0Boa+T2req40iudiuxlisQzosO2noBYLwQo8F0mnPKsIEBxeLZMey0HM8nCjRHoxzsd2JuMA5B+d8jsDgZ6Sn5oSJ9BhVm12C6rQl2pUuOm0T6rsepklUOJd86fAOAOAdO5dX/nojL2jdvF1WdF2ga0/CEhG9IV9fyDS9qHJzsi1Ma8tFcqQ/myQROOeY1hiXXdvBQTDoXCSHY9lzjTjdOTLmSeMJ7m2o53jiO+iiGOdzcVxDJTKtqUJp/UGic2STCMVIECaWI4Y4liNIh11SVSSHuAcMGxImhBGWg3Omvf8rk4gWWiOZZegF+Pbr78SlYChi8Daluog5IN/HmqzzZ6x4DpWHE8gAendyqv3duGVk0F9+78fwnv1rAJBFcugJE0QQ6rme2Kc2vc/zpsabQiSHnlC1ChnChJGRkZGRkZGRkdGjp+XGKYy2JprQpwnFLhImgOJkFt2oBkqupkyYWCiSQ2n25bmf1cUCeg2KEqFG5uXeMGu8FrepHGnRNdU1Hn0nLfhyzrPGUrrNKLqBMuYnYnqk+alBh/Ovi/ZwbbtQZBGRHB00o+hE+2xTJDlth3Ec4QB5IwwAbg3T2IE3zg/xwSs3ESYxBp4vil2n4VSYKqrk2Q7ujk8ApBNDOrUiTPBE5O2SwWbdE80M1aQUWXKByhcTWK62iUSEiYGXEybOs/ORTHhwbBsfv/lu/MrrzwPQHwfUXCJ8NymuKJoNPR9RRq04CadZREeY/Z9KmFj/MUDnakGYWNIwEbPchEVTyrQlqiI5WA0ZBwD+yff+JVwbmDiOKu376XG9EGFCg5tvIjp/07E3Z5iQzjEbieSoaBAMlcY3nce8jDBRVvCXCRPgHLt+r0CYoIYkRXLkJkymjZtJG68x7mWGibMa8kbMmPYz5dnh21n3tSUsrUpkwJzGsTiXf+He63h653LpNW8ZDb2gdfN2WdEamNZoEWNIsmuNJ50rvSWvFbpIjmaGCU/bdCLqBOMcEUtErMKgIk7scm/YqUgO2cgqy3ecOXNS1fmmC+q5brcJE5p7lp4zH5/URBRjJ8uyLASO24haFyYJHMuubXbXybVtQWDokqruD8U9YEPCRH6/zoEsmgFoRkwgk8A6CRP/08f/IkZ+D//D5//l5iM5WhAmmqy56JxDNRPZnELXfrrnUxWXnMuq3tff/2N/Hr/w1Wdxrb+DvaCv3SfkGgE9f7LhdYioE9Xef89HckzWYZgwhAkjIyMjIyMjIyOjR05mhX9B5WUN8NMuRXJQE1kp6lJzghqEPZoEEoQJKZIjayS3KcQHCk6+aSQH3WxTo4eahT3HSw0GaiSHiLTY/rZWVYVcBaQ8X5ZgluST83sKjnUSR/Btp9UEkK8pAI1rSBWOMtUrDBMdNKPo1HbCdqAQJphUWLuVmSFuE2Eim5ZrS5jwbEcYqMoIEz3XQ9/1cDirb1JEhciG5TPTmyidhFuAMCEyft25fYhxhvM4xNALMBQZ2aGY0KLcbNL33nqPMJToMq1z2oYSyVFRNKPv/8HkDAlneN+lx8X/DaXX92x77nnXITHpZ+VRJsDikSthkk/b0nnIEcVMIkxoIjkYq8XAf/Ta03hy59JC7+trRYIw4S5GmFhkn0uE6UYfyUGGiT2/vyHDBBOmHVUpKUAXyZESJsqaXIznhAmO1DAhf5apMAamxzft+wxpJIe6jvEdF4fTsZjSPKkjTJRMsXt2fj3fhtoSllYlcR1N8qbHF+6/jg9ffWItr6dGuWxCtG0DkXWvJ0y4Cx63pERqXqrI9yqVYc1pn07/HosIKtmQqOpybyhoK10QESZU6chVTabJt6m+4xe+k65JFyNI8UnnLZuaYUl8WpBFEX7x4Vv4/J1XK39/FeYXx7I6SZioimwkw0TbSA4LSCM5WhgANkEmetf+Y7g+2E3jlDYdydHgnFBGqNMpFOST/P4GSPfX8waEibYEnA9euYkf++ifhmVZ2Pf7OI/DuTqIIEw4nrhX2/Q+33g/ku45OHi2T6whksMQJoyMjIyMjIyMjIweOZkV/gWVZ3UxkoOyTfMiuhxtQQVUar4Sql02TCQV6NAy+Uqzr7Fhwsrx2YCczenCt9052gFNkzaZpNm06hrNVHAJkxiRhC4/EDhWMkyEpVSI0ufWTBjl0R765/Jsp9Bgo8bPrMMFXlkCS9uwYUSNHirgyQWW/WCAvuvh9nkeyeE7jiCknEbT0hxwWXJzv8wwAQBXeiPcKSmyyZKRrtSgWzcCvk0khyWdZ2TChHoupALZyAsE8nkch6LgqDZ0vvvme8Rz684hZdPd1YSJ9DXenqTTYO+7dEP830ghTGxialzNks4jORY7/mKem7BoG7iZEYK+Ja1hwhQaVyLKIV+IMLHgPseyxolXQpgg09FTO5cKVIZ1KUoqIjlcX0SCAVIjwqkmTCQKYWLH7xVMDnnzIIvkkGK+UlpO8VwW2I44zwOobcaX5ZDrTIqb1DYjOZFNinsAACAASURBVAAI1Pqb58e4Mz5Zn2FCiXLZhOjcTMdyzJloUsqGPDnubhHJBmffcfETH/+L+Pff+ZHa3xvURHKkf88NicNKw8SoU5Eccckkvi6SIyqhv3RFvSy+pqtiJdt6qJjbmmimieQA0jXxLInx33z2F/Fjn/nnpb8fsmSOfLiI1KjBrqhsWwOSab7hNZru8y3OAc60hMEyEZVtE1E2gxISzjrVZD1rWzachlQvqmmohrZQMqTdGZcZJsojAptIpU+SphI90rZs2JalXduvU83vv4uEidTsZwgTRkZGRkZGRkZGRkb1Miv8CyovQ8R2PZLDk4q6hOgVhans8cVIjuYNU5JasKEsVV0BTRbdbNPrU3ExcL2C0YMUdtgwUVeoEaYGFiOUCROZYeI4a26N4xC9EipE3XPPCoaJ6kgOuWDEOBN/XyaTe5PS7etVUg0Tcn6zZVm4NTzAG2eHANLt6Ds5YYJxLpDvVZKnq/ez71Wn9x5cx/MP36p9vlhq1lHBbhORHE2bcOp5Bkgbkuok6JlkjKDv4TyaFX4u60p/hA9duQVAP3FbNlFXVTQbZq/79jkZJnLCBKHl6bkjxgomsnUoVhpw/pIT61GSSFj3LJIj+9PKPkp5JMdmp9QfRVEcQZsoJZJrLxbJkeeR24V/k2hi9YmdSzipiZ5YhVJEvv7zq4QJuRGREib0n59zDpvWJ5xh1++XGCaKkRycc3CN+dNz3EITp5YwURrJsWXDBLZNmEi3+xfuvQYA+PDVJ9fyeiMvEI2pTSk3TKT7cswSRJpGo2sv15ylxifto3/2mQ/h8eFe7e/1XL9A+CDJholpEglD4tCtJkx0LZLD0Rxv6v1Awhg4eKebZD3HxbRBHMW2VHbPMvQCYYhqqjCJtYYH+t6+dHSn0oRRRqhoK1cxgndF8v2Gqn52v3vUIKYPyM/9RJgQMRHZ8fHXPvkJ/GoWaacqYdl1YwPHTT8zdq17LS0rvWeq/2xN11wzYewkEly6zpglsdif70z0kRzLRgaVkUfUGDJXoUVuQo0JV4Xvnq+NOhLzxBi/jYyMjIyMjIyMjB4xmRX+BZVvOzgKJ6Jx21XDhC8VGscKYYIk39OyBSaO81zPoqGhbmJIngYF5EgON3vfxW06UwwZXVIVchXICy6zJCkQJnbVSI4kEjnhTeVrmunU0CgjI8hZv/J2viiECd6yYdQXhon088UK+vnmaF+K5IgR2G6h2NU0koNURZh4/+Ub+PLxvdqidDpBmTXUnfU36DjnrRro8sQcmUV8xwXjvNBIOpcmXWXjSv7zeYPQH3/iPQD0E/uWZc1FygDZdGqZYSIzZbw1PgYAPD7cw6UgbXIP3aJhgoOvveieKM2yNlOCOqUxMk7hOT0QYSI9VqhYLivmTMSCGC0uIkw0MVap8mxnIaRyLO1DjmXPNSaoAfPk6BImcbT2NUpY0awYKo3vSJgqHTgV0QYMrECY2PV6BVqGoFJl212O+dKdy9S1TxPChO6csonzcZUojsWqzRBfrciASc35L9x7Hb7tFAxoq5RqtNmEaD1KDdwiYSLffzzbXcrASOfjphFYJIrkUI/3gmEijksNibIu9YY4nI1LI3E2rYSxkgicIs2Dzn1dvnZ1nTCRlKz1FjnmygwPvuPirfExHkzPK41PIVtVJMfmm8dNlHBWID+q2vf7cySB0udikmECxWsR4wz//Cu/j0/efqn0fQCbIkz44OAbPQaaEjKb0oGiJDU90L19fq+dn1/vVhImFt/OZLpXjTQ5iTO9FlcRutalxoZNrhIm1hPJ0fV4JiMjIyMjIyMjIyOj9jIr/Asq13YKE/1doB7oMIkyyvY8DrPMcCXbvkCYqI6W0ClQIiEWjuQQTX4PvmZSXRAsOliErEKuAsVIjlmSwMu2jWc7GHmBKJZN42jhSI5IIUz0HK/UxOFYeZFFLvp3IVqmiYQ5qGHDSKDE4xCc82ySUTJMDPelSI6kQJgAmk2OUzHNtizs+r3Sx33w0g0wzvH8YTVlIpYmtgVVYY0EkLbUDnnfkiM5gKIJR27cBI4Lx7JxHoWVDZ3ve/J9sGDhSja5r0o3IVbWbAFyigQRJna9Hp7YOYBvO4XvOZ8c36xhgowh0wWPP3lfcQRpIv2/PJJj/jMljMG2DWFiWR30UoPURiM5pFgG27JEE510NJvAsx1cH+4CAE5raArLKpJMO6rUJlzE0olAx7ZTwkRJwZ8pkRy7fg+nkUyYIJNlkTDBwME4mzMUyMf6yAtqt0kimdZkbeJ8XCWuRPpsSn2F1PSFe6/j/ZdvNIqsWkRpBMv642RkzRMmcgKXGsmxDGGCXqdprBipX3KtkFHnk8yQaFtW5Xrycm8IDi7ie7at0kiOjOgnHqf5PrqmnrMe/PyqVGaOT6fAqw0TMUvwvT/3P+KXXvkjMM4Qc6YlCgaOiz988CYAVE6WhyWRHm3l2uXXkm2K1RjqR35PGIjrlH++4vU/TGJhmio7Z+brzvVfN+R7rjK9fvoQP/fy76/sNRPezKTQdM0VsmLMWD74EItj5N7kVEvRiHkz2kWZcsJE8dxM5xRa81QRutalpveKXInkSOOk1hDJwflGTEBGRkZGRkZGRkZGRpuTWeFfUKnTMOtG5TeRDpMoo2zPoxADL8hv7rM/5Zv9usKOTmqTNBTTozWGCWkaFChOTvgaBK9o8HcwNqJuwkGeTEkJBvn+s+f3cUyEiTgSTYmmci0bFqzCPjiNQzHNr5NnOxJhIt/OF8UwkbRsGAmUeBRKjcb8d2+NDvBgeo5JHIoiWWDLhonmhIl9f1B5DH3w8k0AwB9lheQyRdKEEj33jK3v+2FSAbaJisasdFtRk0l+n3KWumVZGHp+IZJDl7H+vks38Kkf+C/wx268S/vanqbgWVWgFJEcGWFix+/hydGludem5ui6c7BpSpDeb7ACwoQayUHfoyBMlERyGJTt8rra3wEA7FUYpcrkLRnJ4VhWZpgofr+HszH2g754T3XxE8sqkoyAqoZegHOpCTdL8oniNNpA3+RKOIdN6xTwrIEuGSYUwoSI+eJcO0FN12ELFp7auVS7TSKeaKfYNxWRVCbdNWwTorXJJI4QswTPPngDH77yxNpe73JviIfTzRIQ6NxM1/+IJVKDPt8XFo3SIcmGpzbKKR/FxtMkicQ6Z5pEOI9DDF2/0pBxpTcCgM7EcrASSpRvu4U1BW33VVAJ1qWe4y1sgNyEEqaPiSgjTEziSNwf3Juc4cWju/ji4VvifkwXnyZHTUziSGvaBCjSY3nDRGcJE4zBqTCmDl2/cfQQ3a/nRkImBiNyw4T+ukbn0U1M4w+ka0WZPvHS5/Gf/ebPriy2I2asUf3Cr6BayQqTuLCmsS073dZJIo6RkCXaOJWYLUdvI8KESh5RIzmcBQlly0jcf9cNLKiRHJ6HWRKv/HpeRRc0MjIyMjIyMjIyMrqYMiv8Cyp1knJbk4ay1KlloIiyHcezrHFIN7E6wwRrPbUomwEAmTDRMJIDRJigQkA63T+TtqlMm+gCzUNVWR4wiUwladGQFyZd94M+jkIqKoatCROWZcF3isSTSQ2pwpGK/RfRMKGjqVRJzl7PsbT5/nlztA8AuH12hFmGF5b33yaofSqs0bR5mSgO4g8f3C59DGV0U0PAl5o36xIVsZoTJookGyBvMsn70blCkqAcW5o8K0OGP7lzqbT46WoKngljcEoKlGokx47fw4984Dvx4x/9/sLj6HOs2zARC8OPLf50LXuOqtNU8nQ/PacjIjlSqQSC9GfVZByjZnrvwXX873/qh/DdN9/d+nfTacf2BWQ5j9y2LG0kx74/wI6XGibWTZgIKzK7R16AWRKL81fEEnF+dW0bPCNCqOKcIwdicez5fcySWJxfiEpFBCA55otDY5igc3QwwEEwxFlUvU1ixrSfaVPniTIlwhy72VsIeWr4Kyf3MYkjfOjq+gwTV/s74OB4ONtcQ5/2Q9o/ZbOuPMXqO+6ShonFpr37JY3IaRzhUrb2mCYpMl5nRpR1OSM43Z+etXoP65IalUbyFcKEWMN12TDhusLQ1UUlJfd6A6/YvE8Yw089/2l808/+Lfz4Z34eAHB/ku4v42hWaZCXTRAcHNNYv74Jk/JrRxt1lTBRFxUx8PyCobD6uTIyjTT4QIMRtKYui/fQ1QjWpYFCIwKA49kEP/bpnxfnrvNoBg6+svuahJdT5mSl9w/1a+1ZUhxuACDol/Ix8rYmliNiyVLnp32fCBOqYaK45kkJE5vd53nT9Yd8LHKOvpPfh69SVXRBIyMjIyMjIyMjI6OLKbPCv6BSb4QXbXStUiJXUnL9+1LO8jiOMPT83PUvTW6SmmaAyiIMOTUx6M+6iSF5GhQoRnIESiRHIf6kA9taVd12o6YwFRrl4uA8YaI91l3NZK17HhmDPivZzl0WbzmdSZEM4yjU0ikeH+4BAN4enyBMEgSOK6gJQP2+DOTGoX2/X/k4y7Lwgcs3KgkTkTLR6lFO8Rq/HzoPNG3CyY0eai75GlKCGr1BhokmGetlci1bQ5gox/FS8ZYiOfb8Hj5y9Un8ha/75sLjNjU5nojvN3+/geMufPzFrDjd71g23GLykj6SgzebyDOq13fffPdCBXLPbpanrUpuuDqaWIuj2RgHvQF2BGFivdEGcU0kB5CfC6ZxJM6pZFzTmUYY5/kimTPxWcj8oRImaO3DOc9oWSphIn3Nq/0RRl5QS5iImZ5aIyI5tkyYaBvnsKwEwSAOxVrm+mB3ba93pZ8SEO5NNtfQp21L69qUMDHfoHet5QgTi5pe8slthTARRzgIhuL/zhsYJi5lhImHHSFMlK2j5fsYII/M6nKTLCVMdNcwURbJMXKLNKC/+Tv/Aj/+mZ/HOArxwuHbAHKDzTiOKiMYVRNFWTxDaqBbQSTHFprHdeIl5j1ZQzfAuCFhQo7QzF5AHB/CMDErM0wsRrVZRPI9F+mzd76Kn37h08IsTsaJlRomGpAGvIaECd1+SfTLs2gmyIN3JycLv5cy7fgBLFhzcUnqmsex7Y0TJhrHN0omXs65dp9YhWKeGMKEkZGRkZGRkZGR0SMms8K/oJKnz/0M0bht6YrovuNIkRyzdDpNmURlXDZMtJ84znHyFMmRFdDqIjkUwwQ1C/uOOxfJMes4BaFuuz2xcwAAePn4HoBiA34/GIgpktNoWlvk1kndXpMkrIz2cCQMelhC8uiyGhdsMlHu9zgORdFQLmZR0+eNs0Nw8DSSQyZMtIjkqCNMAMAHLt/Al47ulNJSqADmKZEc62zk58XUxQkTeTzPPGGC9uuhF+A8yjPWm2xbVa6mSBizpLQQTK/99vgEjmWXxtW4dnnzdpXSFa7VY7iNwqTY2HUsCzbUSI55wgQz2b9bl87800Ty1LtjWYXrOJBFcvh97GUGrpMamsKyiioIE3T8nWUGheNwIt4XFbrLImNy9DjHrmL+yKctM8OEtKbQxYvRuu1Kf4Rdv6dFz6ufSWeCEcawLRkmeMtz9aqUx0FEYs1yEFQbBJfR1ayhf3+DhgnaD2mNFhcMExK9zVnM6ERiGuNmE8nfgaxJEuEgy72fxmlDr86MeKWfGiy6EsmRMH2TMcXg59fGWGM47Jr6rtdxwgTXnj+GCmHic3dewbdffwZ/9pkP4d4knaSn4/E8mlUSBelndCyVGSZSqtvyhIltNI/r1ITqMPR8nJdsm7nnYxTJQYRIlhkAGhAmNhjJ0dcQJuicRWYvIg2s6jqalBBqVDU1qYbJvGEicFxMkxjn0Qzv2L0MALi7BsKEbdnYC/qlhAnavo5lbdwk1Pz+W4nkkAhVq1TT793IyMjIyMjIyMjI6OLIrPAvqOTGwKXecGuThrK45ia2SJgIlUgOAJwXbmnZAhPHVFCYUfEjSWBbVm1RxpKmQYHi5ETaPJQa+TJhogPmFFW65oysG8N9OJaNl47vAihOY+0FfRyHE8Qswe2zIzwxOmj9+un33DySw7MdUci7kJEcaGeYcGwbgeNiHIei2C4XWK4PUsLEq6cPASCL5Mi/oyaRHFTwpaZFlT54+SYiluDFozva/1cJE/4GJppbR3JAY5jITFLyvniaNSV3s2iAgZvih6mhs8iUtGc784SJkmZL+prp9zdNosrXJIPKus/nuiK6vwxhghen+23LhpM9dR7JMV9UjZnJ/t22mk47qspJOTYsy54zxBzNJtgPBnNUhnUprGgQkNHhNDNtnIRT7GaGCTLs6ExKCWfSWUY2TKTPQw2Y3DCRPhdDZpiASpjIDRMjLxDvp0xlDVz6nOsk/lSp7fVvVZKbYNSUI3T4OnSVCBOayAjOOf727/5y6TV0UdFxRNf/mDNtg96znaWi+Bad9haGCYVeMInD3DCRRClhosI0C+RrlQddieTgetOjr5hT1PVRF5USJrq7ni6jSw29IDUWZ+fjN84O8czeVTzW38Xd8Sk45+J4HMehINRVRXJ84NINACgYMWSlkWKPJmGiyXE+cH1hLK4TGa1kIyFFWNL1sIyclPDNkVkGmuggYZTIfkb3/KuKNI1rojFJnjN//6BTyOI5EyjFn5zHM7xj9woA4M5k3jCRxnktt533/TyukyTqJBKha+OEiabrD16sNZXFSS2ruGEUi5GRkZGRkZGRkZHRxZFZ4V9QyYW6y71hozzMdUvn+vek7N9xFKaTnlWECcbh2O2K8HmTNCNMJHGj4peYBoUayeHCt51CVIQ8gULN2H/64ufwsy99vtV7XZcSxiq3m2c7uDncx5eP7op/k/b8Po5mY7x5foyYMzy5c6n16/uOg5lUdJrEkaAq6ORIU81l0SddlqCpoPm+2nd9TOJQ/K5cWOu7Hvb8Pl6TDRPSPtxrgAsWhIkGhokPXE4LyH9YEstB3w09Zx7Jsb5GPmsZyWEpxiwgL5DL++JZOIVtWaLRM/R8jKM0kqOM9FAn13bmGqxVxVLXdsR7o6arThTDsm7DhG5iubeEYSJKis1qx7Lg0veT7e8qgQAozzE32pxcjfmniVg2aerYKWGCK6juo3CMg0CO5FgzYaJiSng/OyceZtOSOsKErujPoRImMloGRXIkRTy1HPOlw6BTE/xqb4Qdv4fTcCYMm9rPVELNoOJ8tKVp5rbmtlWpSJhIGzn7Da53i+pKfwcAcF/TkHowPcc/evY38NPPf2alr6lG3cSMSTSXfF9YNEonf53FKCEiB16a0mWcYZbE4ruYZJFXdYQJ13awHww6Q5hgnGsNfKohONFcP7umnush4awTZnqdWEn8ybV+Slt7e3yCcRTicDbGrdE+rg12ELIER+FEHI/jOBQGdl1sHZ1vv/HqE+LxOoUrIkzYVvcIE01IMhRT1+j56DovrlscQUaSpHPCOA61+128INVmEQ00hImx9P6A1UdyNDUAeyVU0H/9+gv4u7/3/4l/z5J4br+mIZSzKMTV/gg7XoA742IkB+d8acIEUKRPkiZJBNeyxXM7dmoSujc5xd/83P+70FqyrZrefxfXVlxLHVnV+zHGbyMjIyMjIyMjI6NHS2aFf0HlK4SJbaGZZWkx75Lx4DwOswzJ/CbWAgqNlqThhIYsgafOmn0zFhfiDMpE059yJIdvO7AtW0xxkGbSNB39/J+9+DvdMUw02G5P7V7CS1kkh69EcoQswZeyfOCndi63fn3fdgtFp0kcVlIR5EiDWcl27rLaRnIAaUN6mkSiWa0WWK4PdgVhIrBdYVIA8jzzKuWGiWHtY5/auQTXsvHq6QPt/0dKQ8BTTEnrkCjsNjShyPu7p6CX5f3oNJphR6I6DN0Ah7Mx7o5Paxs6ZfLs+fz4hLHSSAAgL+BWGSbcDRMmymhAbRWyImHCse25SA6maSSU5ZgbbU50Lq5q3OuUSI1dW8EyT+MIkzhKCRPZMbZ2w0RFJMd+ZnSgbPXj2QR7QZEwoZsMTikRqTjn2MkoNRQvok5bzkdyFM9lniBM7GDH64GDV6LQyyYXLcuCvyRhYBkJc1sLw+Aq5NkOPNvBOA5xNJvAs51KktWy2vECBI6Le5pIDjJsfO7OV1f6mjL9x82uM6WEiRbn64SxwlpLJsS0UV+DNZ/G6fNSHNg0SfH8TeLdrvSGnTFMxCVoddn4Dcjro24TJgB0NpaDlURyPJ3FDLxy+gC3z48AADeHB3gsMy/dHZ/ifra/nEdhHsmh+S7ovPyNV1LDxKTMMMGamezr5NoXkzAx9AKMo7DRGiCP5MjEuTgXjSWCx4kmloPWgJs4bnTxC3kkR/Znkv7fqqIgWUPSgGc7iPn8ufsTL/0OfuLZ3xD7dJjVJGRRzOk4mmHoBXhssIu7iqGP7k+XpR7sB31xnSNN46hwb+9mJqFP3n4R//i538JLR/eWes0mah4nVSRMDIThcrWGiZglhjBhZGRkZGRkZGRk9IjJrPAvqKjg0Hc99B1v4ez5VUq4/uUmnONKhIl0olsuyljghX/XRUvolDdJqcgwn/upkzwNCqSFAHouf84wkUh/j7PPE3amGKlrzqh6cnRJFD8CqQhDzaQ/eHAbAPD0IoYJp5jxPI4jMc2hk5tNTgLFJvysg3EnOi2S/x1k2NqyTOHrwz2JMOEgaEmYoILvfoNMd9uyMfD8UjQpEWs8a3ORHGLiteGkToFkQ5Ec2XaSp7fOoilGXm5SuDHax+tnh/j1218q/LyN1Kl8znlKmKh470MvPR52KgkT6edY95SWmJAtRHI4C19HYqVZ7Vg23OzrySM5dIQJfdPEaHMS+1zLydhYOo/Zll2IXDmiuISgD9d2MHT92viJZcQ5R1hlmMgm3wkvnRIm0uOwijDBOIclBmmZ+B1qBk2TGI5li9fNTZhMS0+h9cXV/qhRVEmVCYRy47ehPH5t87cQA9cThIn9oL9QpFJTWZaFK70R7msMExQJ8sLhnbmm0jJKJDOmmx1XtFaS94W2hol/+Oyv49/+xX8k/r3IGgYoUj5I1HgUkRxx1IgwAaSEs+PZfHN1GyozHvu2i5m0rQWBq8NNsp7me+qSEs5ga9ZLT2WEu1dOHuCNs0MAwK3RPh4bZIaJyYk4HsdxKJrdunu+Pb+Pg2CAZ/bS6IKy2IkwSQoG5UXl2N0jTCTCoF1+nA89HzFnjQyzeSQHkSaYuF+WzQnHs/nrmjCLb4Iwka23ZRMHxQip0RybJky4tq0lTLxy8gAxZ/jKyX3xvtT92ndcnEUzhCzByAvwWH8HdxXCxKoig670RnNxSdMkFmYsICdMnGXbma4F61TjgQWuGibWQ5gw0YJGRkZGRkZGRkZGj56WH6kw2oqocLrr9eA5biewqxzzE+I7Xg8n4QQJYziPwzTTOOTK7+VKC5aLRnLIUxnNIzm4RJigIqM6bS03Eunn0yTSYua3oSaECTlqQy68U4P92ftvwLcdXB/stn591WAyjcPKyU/HzhtsZSSPLmsRwgRRS+TJbFnXB7v45OxFAFkkh1TAraJ1kKjg2ySSAwD6jldaTI+VCUpPGCbW16BLWm7TIh2haOyQJ8ZOw2Lj5r/6pu/D9z35Pnz27a+KaJK2SptVeWG8yUTX0E3fw26FScMV23m9RfdEM+kXON7CkRwhUyM5bDiicZBuG93kZVmOudHm5EomnSpCiiomGyZQjOSgBjKdi3b8nnbidFWiJpVuyhiAoEkczybgnOMknIpIjirCRMJZ3hgCnzM5TJMIPccVTXuVMKEio6n5caU3Es2702iKx7Gn/1wVhXjXdrZGFlvk+rcq9bJoq9Nohn1/fXEcpCv9Ee5NdYSJdH/m4Pj83VfxJ574+pW8nmxkcDNTBE0jy2s8V7kG1em104d4PTNkAvLkeVvDxHwOPBEmhq6PICNpnUUzDBoYJgLHXdmE97JKONPGbPiOg0i6Nsaa62fXRCbbaQfX1KxkDQwAN4b78GwHr54+EPdmN4f7mGbb/874FPcokiMKxZpFZ5j40W/4Hvzguz8qjptxyXo3ZHHBoLyoXKt7hIn8fFK+zhKN5GimjTYpPh8ZJbIfcC5IkvI5QU+YqKddrEq65vgkKholaOBhVaSmpoRM33bnzDucc7ySEf++dHgH7z24jpAlc5Qe33bxMCOspISJHfz+vdcLj6Hzk7dkE//aYBd3xqfgnIs1TkqYyPcRMvXR59mEQavxfqREcgw0165VKOGsEJdlZGRkZGRkZGRkZHTxZToVF1TUGBj5vdI8zE1LV0S/OdpHzBnuTk4lRK9EmOAcD6fn+MZ/9t/jU29+uTTXtkpphno+sRGyuBFhQhgmsveTNj8yw4STFqqp2FSMjcgIE3HYmWJkkwmHpyTDhLx9qJn0B/ffwBM7lxaalJCjV4B0kqdfESPhSRP6ZJhICQzdKJzXaREkOeVg583q+UgO+bGu7Yh9tK6ICciRHM2aSNR40okMWFRwy2Nv1kiYYO0mXuVmJJlFfIU2A6QNSZnq4NoOvuXa0/jRD30PvufWexZ6rymGVpo4LflOZQ0aECb8DRhTgJJIDsdZ+PiL1EiOLKYBgJjQ10VyJEzfoDLanDwRA9Ou0SOjvh3bEqhuADjMDBN0bdnz+2uN5BAT3yXnyaHrw7VsHM0mOI9DJJxhlwwTgjAxf27jnEuTtBxDz4dtWeKzqHhqQa3KyFllkRxFwoR+6pk+V5mJxXccYWzbtHTnj02JjH7Hs0kjmtKyutof4b6CPAdyigoAfObt1cVyyM2gdJ2kJ0z4LQkj4zjEJIlEE5otSAnpa7Dm9Pe+66OXTUDPkhgjr5wyRuq5XmdIbWkkx/w+rdI8dBEpXZOI5OjIPYqsqpgIx7bxxOgAr5ykkRyuZePaYFciTJzi/lQmTKTfhc7wcNAb4t3714TJp2yyvCmVsE5pvNX278VlNblXoaZ8VTwUic79VvYnBxckyQJhQmOYoONmE4YJumcqGCZKCBOrMh7GDdezFLUk6+7kVLyfF4/uAEiNpyqlp+e4nHqugAAAIABJREFUYn01dH1c6+8IUwNpVYSJa4MdRCwRrwcU6yRARlVhTGznTZzLaZ+up0vl24RzXnseWFQxY7ArCC5GRkZGRkZGRkZGRhdP3a32GFWKboRHXoDAcToxoaUzTNwYppOTXzm5D0ZIxEIkB/Dcwzdxf3qGLx/fSyc6FyjCyzj5MElKJ01lydOgQIqapCJLoKD95e1LrzPJctq7oCZGk6ekqI2CYSJrHD2YnhdMFW0kR68A6bapiuRwpEgOQh3veL1OGH+aSOzrLQrmKYUjERNoaqPi8UE+ZSyiYbIicK/CfELazRpw1xoSQvpuFWGiWHDLCRNrNEyg+fQZm53DCvMinie207xh4iyaYWfB6I0yuUoDRWCPmxAm/PImn2jerrkRmhNE8vcb2ItN+iaMgXFeQFrbli3hqzLCRGkkh1mGbFMyYaKNxHnMtuBYtjh+gRx9TpE3O36v0hiwrOi6UXbdtywLe0Efx+FE4P/JzOFkk4G6yWDGeb5IzuLCdrwgN0wozQOVMKHu2x+/+XX4Tz/wcbzv0uPinFQVVZI2YLoXybFNwkQaJRVmkRwbIEyURXJkTaRndq/gc3deWdnrJZKRIW1GJTnKXjpfu3Y7w8wkTolodN0SU/4tm/60rpMb8bSO6Dkueo6HB9kEdJNIji4ZZVlZJIeTEueoKbmqhuQ6RUaurphRZCU15tindi7j1dM0kuPx4R4c28bICzBwfdwZn4j96zyeifsxvyJSYygapfprUMTiVnSlMjmW0znCBBkZK+Pisu1zHjUxTCjrOM4FkVFuROsMksIoswGjkW3Z6CtmrLGIjciME1l8xKrua5oSJnRxSq+cPBB/f+HwbdwZn+DV04f48NUnCo/znZwwkUZy7GKaRIXtrYvcW0R0L/m2FPkxTYr39vOEifVHcujMqCUPLPx9kJ0TV22YSAkT5j7GyMjIyMjIyMjI6FGSWeFfUFFxaNfvwbO7EcmhwyTeGO4DAL58dBcANIYJjpeP7wHIC7qL5JsGjicIByGLG03k53njFMkhESZEzAfFb6TP3Xc9hEkMznmnCBNNokzkSA65sSQ3HZ5c1DAhRZhELEHEkspIDlfK+qWC547fuzCRHCLDvQ1hIpvgp6KhWmC5PtwtPFb+s0kkx/fcfA/+n+//K3jX/mON3k9qmCgjTBQnWol2sc7zTFlUiU53fvKHcf9/+SHxbxHJIYxOciTHFDt+feOmjTylWdWEMDHMpm13KwgTmzCmAPK2lgwTjrtQcyWnkUiECdsSmdn0bSYKYYJzDo6GhU+jtWnRfU6O5LBgFb5ful7S9ZSiudalJg3M/WCAo9kYx5nRio7DnDChMUyAS2d4nv1eX3yWaRwXzs10PeCcg2n27cu9EX7so38aru0IwsRZBXkjYknpOcWz3a0ZDInKtY04nb7jYRxHOArHGyJM7OD+9HyOkEORHH/yyffh2ftvrKxRJMcVeNn0rkp8Sv/eLpJFTABnx+aikRx+thaQzZbUgOy7PnquL4gcKk5ep57jdWYdXWZQ8pVzpI740TXR+nvaETOKrDq6ydO7lwVhgu4hAeCx/g5ePLoDxjn2gwEmcSTWLFWECKJ7jUsMAbMVEiZ0xtBtqgkNaCAIE/WmRrr3yclLLKNcxoVzIBkTde9lUybZgeuXECaKf0YrOkbKIn1UaQ0TWRzHBy7dwJcO7whq0ceuP1N4nO+4Yq0y9AJc6Y8AQJiIgNUZuoh6eEcyTEziSBjT09dITX3nCrVjnUqNrPXXLTkmDuBSnNQaDBMdpg0ZGRkZGRkZGRkZGbWXWeFfUHkSYaIrkRxUKLI0hImXjlPDRNo0LBaUvppNVkySsPGEhqpA2gZN8aoyPhsoNj/Uxiv9uev1MGMxQpaAcd4ZwkTCWW3zYi/oC5qEjjABAE9LFIo2kgkfVMAcNCRMCMOEF3Rm0rBOi0zY0gR/LCazqyM55D+bECYc28a3XHu68fsZuL4oIKrSIafXfZ6hSTirwfEfn9xFcnq38N6AeaMTkBImRisnTNgKYaIeNUzHQxXtYtFp/7bSFa53/B7OovYUgDwvWY7ksOFQQVNBwFe9B6PNa1GqiTAJZZPwTIrkoGsAZV3v+r21RnKEGtOOqj0/I0xk72PfJ8KE/vPzjBJBZ3ie/X9Ky5AJE/m1VCVMVNGydrIm1UkVYYIn8EqysamZvg3VTYivUzlhYlJYu6xLV/ojJJwJgwTpOJxgxwvw7defQcwZfu/uayt5PZlW5FoOYs5S8hqswhovjWRpfp2gtSodm6KR2sL0CaTr5tS0oovk8NBzXNynCWi3GWGiK039mDPtPq2uK+ILcO0SkRwduUeRVWeOfWrnEs7jEM89eBO3Rrlh4tpgB889eEs8BsijH3xNJAfJsx14toNxybYIWYxgJYQJW2u826Z0gwyqxOR9I8IERXJkP+AcQUZgmcSRWOfqIjnK4gjXpTnDRPZ3NT5ilZEczQkTxf3klZMHcC0b33vrPXj19CF+4/aXMPICvP/S44XHycMORF0BiiaAWGOwW0TXNIYJNYbMUQkTGzC/JSXn6TkphInAcWFbVqP9vNX7YUyQyoyMjIyMjIyMjIyMHg11t9pjVClqrO14vSzLePuGCa5pIu/5fQxcH18+SikSAy8oZG0C+TTENE6n7xeZWkzjDnLCRLNIDrvwvmdJlEchZJP9qmFi5KexEVScSDjrxLZvEskB5EVGubi44wfiO1s4ksPOscpUmK8iTHi2g4QX405SwkQ3Cud1WsQwQfsokxqNsh4f7hUem/6Z7odNiCltVRXJoZtQapuZ3lYcLSZeOSv4rlQiR4EwEU1Fc3JVSgkTUqa5KARXYKGz97DTgDCxqgJumQTlRCqoypPzbUTTefJnty0brjVPmPi1N74knTubR7AYrU/UkG97HZOjA2xYhUgOmhinpt2u36uMnlhWdF6quu7vB30czeYjOegYUFHqdD6yxHqFCBM9YboojeRAapiouj7khIlyk1LEWCm+PCUMbCmSgwgTLZvtq1Df8XAaTXEWzTYWyQEA95RYjuPZBHtBHx+8fBMA8OLR3bnfXUQ5tt4S07sRS+aaX67Vbt0/EYSJ9NhkJcbNJuq7fpEwIa35em4eydGEMBE4XmfWfYxzbTOX4qboWreqhuQ6JQwTHaF3yKozS75j9woA4DwOcWt0IH7+WH8XD2fpvvXkKL1XISNT3Rp54PpagoIuUmxRubYtzLNdURNyG8XFnTcwzOYkqfy6SIb5cRzicm8Iz3a0Bsl4w0Y71TAxFhSEEBFLxLp9O5EcxXPeKycPcGt0gPddvgEOjl/46rP4lmtPz91TyMMOQ88X9BT5fByJCKfl9umr/R0AimFCWfNQNBTFuazajKBTnRlViBcJE5ZliX3iRz/5CfzTFz+3kvcTG8KEkZGRkZGRkZGR0SMns8K/oKLGwI7fK5gFtildEd2yLNwc7uOlozsAaMpaiuSQbmgncZhlCLcvpvhSDvIsiRsRJuRpUCBF16qRHBTzMRMUhF5WGJovFm9TTSI5gDQbGCjm/dqWjd1sUvOp3cUJE1R0olzYKsOEY9uiqDPLqAU73gUyTGCeplIn2kfjkgLmpWAojuvAKRITmkRytFXf8UvRpFTYlBuQ647+aTXxyjmA3CTk2UVjyUxqbEziCKMVR3K4ynR3zOonTikneq+BYWLdk+P5hLhsmOjhJJzNoefrROYOv0CYsKTvMT1Wvnx8D3/5V/43/PxX/gCAhJ43hcatalGqCRNFeQu2ZRUMBzlhIovkyAgTqllyVYqya0hV02s/GOB4NhGmoF2VMKHs97QuEGej7N+7Xm7+UKctrQJhglWey4aeDwtWJWEiYayUmuE724tiW8QwuCr1XV9kqm/EMJEhzylmgnQUjrHn93G1P8LA9fHq6QPdr7cWnRdty4abmaETjXFGXnM1kYqhZ1jcsKbGeU2lSI6+6+FolsbeUAxVlXqu1xkKQswS7fbwFSPjqpD36xSdl7qybWXVnT9k4/ZNiTDx2GAnf8xu+pjDzEDh1xgeBq5+vRsKs93ypuQuEiYSPr/WU0XHaRmBQxZXDIScMXFvMI5DDFxf0JxUsQ2TWfqur71Xn8RR4b59lYSJppEc6hr/ldMHeHr3Mt6zfw1Aeg+jxnEARWPQ0AvQz2oWdN8N5N+5t+R2DhwXl4Ih7kjXPrlOAuT7PJmR5PexLvGGAyIFV3223/ZdD7/2xpfwc1/5fXzqzZcbvd6bZ0f416+/UPr/TckiRkZGRkZGRkZGRkYXR2aFf0GlRnLEnLVudK1aeaG3WAS7MdwTN9xD1y+4/uVHTpJIWxhuIl+atgyTuNFEPjUzhGEizgkTgYjkUCkIAUIWYyoXiztQkGxK5nhSECaKxUVCWz8xWpwwQdtoIppl5cVy17JFg01EcvgXKZKjPc46cNLMeTHxpXwHlmUJBKqI5MiKwE0iOdqqLWHCc9plpreVKKI3OP45Z0A2wW3BEsUqYXTK9iOKmKiKwVhEagZxE9QwTYJVESbo99fdCBWRK4phgoOLSbHmz1USyZEdGmSKe+Hh2wDyabXcZLL5pqtRLk/sc+3WDzIhxLHtQl40IfbpvDV0/cJE56oVafZBVXt+H0fhWDRy6JpXRpiYM0wIwkROYknzvCXCRPZoivOoMhTYlo2R5+OsIqokYknpOcW17K0aJixYrQyDq1Lf9cT08n6w/kiOq5lh4t50njCxHwxgWRae3LmEV08fruT1EqmZnJK4WEaYKO7brm2DcT6335aJGllkbsiP3/bf4aCMMOF4heNh1IAw0cuMpOsyU7VRGalNjeijbd7lqWKKCtoEIr+t6ggTT+xcgpWdS28OJcNEPzdM0L3MYWbOqTM8DDwf42h+W9BacRUUN0e6r+mKGkVyZMepjsChSkRvisM1JUzMskGCnutl5tt5w4Qc47UJDVRjlzBMhIWfRyuIGmScgaNZI9+1i/dSnHO8cnIfT+9extO7l8X9+ceuv2Pud+X9dOQFYjBBJjus0tB1bbCjieTI34Njp2ZZev1NDJAwVK+thKRrCl1fBq6Pr5zcB4DSgQFVP/n8b+OHf+1nSmtsTQdWjIyMjIyMjIyMjIwujrpb7TGqFBVPd7yeaKq2bXisWmVTQzekCaGhpxomZMJElDX+lyNMhCxpNC1kSfhsIC2c0VSWmChLioSJkRdgliTFXNQNTFTUKalorMj6his30Xe9ucnM/aCPa4PdSipElbwMyQoUi+dlcux8EitkMVzLRt/1L5BhYoFIDtvBjMVSRvn8714nwwRFcthk4Fn9JGPfLeaQy9Ihp33bWUlhsUyshLyhFedAlmPrO444lh3bhmvZwrxDhokmjZs2cqxFCBPNIznaTvu3VY59L0ZyANCilKtE21ouzjq2PbctXswoQ5RvX9c0MdqMFiVMUKSSndFEEqmYnEdypOcvZ83klKaRHCfhFA+nY1iwsJNRZ1xBmCh+/kQ1TGT/3vF7OJUjOVxNJAdntYYJABh51VElsaZRTvJaEgZWqSafbV3qS0bMTRAmrvaIMFE0TBzNJsJ089TOpZURJuTzomOlJC4d6t3L1gZNTYzU0KKmIa1DFjG99BSzJTWe+m7RMNEsksMFB197DFUTlaHV6Rik4y0SjV9DmFhEdXFcgePiRhZRV4zkSA0TrmXj8UH6/xTJUUcVHJZEckRirbuaSI6uEiaqIzkywkQDs+xcJAfnCDLD/DQjTOz6fRFbJYux5qboVSg1yegiOSIlwmL5+05dzF2ZfKcY6fdwdo7TaIandy7Dsx08s3cVA9cXcU+F35VqG0M3yKidRWPUKiODrg12BdEJmI/kyAkTGzRMNF1/KJEcQHH90ISoAgAPp2eIWCLMWapixpaOPzEyMjIyMjIyMjIy6paWH6kw2ooIPb3j93CWFdybkhXWpVLDRFb4AoCBG6CAScxkwRKRHIugUQMpliRM4lo8q/w+80iOvBAgJspKIjnkosA03n6TP+G8UaP5+5/6AD5+891zDeT3HlzHE1Jhsq3SglkWyRHXR3J4tiOyfsMsQiVw3K1lsrfVIoYJ2kerGsXXsyKwMExk26UJPaStesqUqCzREChEcqy3QZdQMbVRJAcDz6ac1QKlHFF0GmaGiQqTwiJScehNCBOEPd6toF2ojZl1SbcPkpHjOJzgJva1v6cTvVdfIUzQsUGEiVeyhuKDbFJ7m1h/o1xin+NtDRNZgyAjTNDxC+S0JmrGUuE+LeSvnpYjml4V6x9qbr9+dohdPxDnVKeEMMGFYSJDj2fHjBxdk64Z8teU1xTpFGT1eXvX74lzlE4xZ6VNWd92G2XOr0PbNEwMZMOEv37CxF7Qh2vZuKcYJo7DiTBsPLVzCb9x+8X0mrTkdpHPi55tI2YJjsPpHCWpzTHFORcNNTIzLYPH77tewSgsU8XkdV8zwkT6+NmW71+AtPGlO2ZpPUbxcatsSK5LtF2nHSRMUJyTbZcfK0/tXMLt8yPcGM5Hclzuj8S+RU3MOlNxGs+gieTIvtMmMY51ciw7j2PqiBE0aWBSoHNqE8IEU66L4Dw17yUJxnGEx/o78B0Xx7N5wkSkIZutUwPlO19nJEesibkrk2ul9w+MM3zl+L4w/bxj9woA4Ae/7ptxOBtrTTxU23AtG4HjCgOA/DkjEZe2CsLELl44fFv8exJHhXO8aztIGBPm9KbUhmVEhKt6zUdyjLwAl4Ihntm70vi90r58d3yGy5mBUlbMko3t00ZGRkZGRkZGRkZGm5ExTFxQXevv4onRAd5/6XF84d7rANbfZKtTXugt3jjKSNWB5xfuYQnr+c69K5hmhIlFCri+7YrCIDXg60S329QYmSV5JEdeICUTRjrpSU193XTdNpU0LNBZlqUtYv+97/yBpZDIfhY3AUiEiYpIDpqcBNIitO+48G33AhImmu+r1MgXhAlNAfP6kCI5nOx3nEJDbpUauB6mSaQt7saaqTtPir1Zh0SmepMmBOdAhmVVi4opbSZ9/2QmqzIpLCK1+E7F0qqi2Xc8/i78wDs/IlDSOm3KMBFrkOJ7mWHitCVhQsR7SN/DBy/fxK0JIerT75WOGZrUNoSJbsgVjde2kRz592fBEscvoJ9CBLC26VtqeFRldlNz+7XTh4KmAuRT4up7o89jS42h9Hn64OA4DqeYxsU8bzqPMnDwRoSJoJIwURXJsW4DW5W2S5jIt/cmCBO2ZeNyf4T70zzHnXOO41AmTFzGLIlxZ3IqKFGLSjYyOHZKMnrz/Ag3R0UTW5trxSyJxfmX1mc5qr/999h3fDycnYt/TySijExcIapSlQKx1o4ArPY63VaMM+013BfbOl3/xCtsSK5L3SZM1F/733/5Bm6fHxWO98f66bF1tTcSBtSj2RiuZdeuxQducZ8l0TpuFbF3It6Jc1R4QTaqJuQ2x7bRc7xGcWwiloAu99mQQ8zTpvnTO5dhWcDrmogiohDQd7duqRQ9ulcfx2HB8LUKcp4wTTdYz5Lh+he++iz+2ic/gStZE/4du5cBAD/8/u8s/V06Xw49H5ZlYZAdH3JNgt7LSggT/R3cm5whYSnRT13buZaNhDOMyTCxAYNW0/VHoaaR/f2//MifAgD85Bc/hdcaxmgdZfEy6RrgeuH/ZkmMmLON7dNGRkZGRkZGRkZGRpuR6VRcUO0FfXz6z/0NfOPVJwRtYttI27zBoBImpEgOdz6S40pvhGuD3ax5u9iEni9FQswaRnLI+GwgzV2nQkCg4I7JTEFNb7kI04UJrrLs5TZaZjLSd9Ks7YSxRoQJ17ZFUSdkMYLMjEJTN10XR/vpeD+jcFThiL/+4Dp2/Z5AWfu2i2AFhVydyNCiM6nkTXApkiP7ftYl2h+amFA4Z0BGVVEx/IFk7DilSA5/tZEcu14PZ9FMFOQonqDK7PHM3hX8/e/685VmLnfN0QUkXcMij+SYnwysUj6hmX8Pf+c7/j38lQ98l/bxD0QkR322ttH65S5o0pHx2o5lFc7b07gYVbHuqBlqeFQRJvaDdP9+7fShaHQD+TGrHnP5JG2m7N/UtLs7PsX0/2fvzaMlSc/yzifWXG/mXavq1trd1dWrutWtbq0g1FJLYpERQjDCBgMCz2BslsFge/DgMTbMYRjAPoY5c8AcPIw42AO2xixjY2NWCRkhFqGtu0W3utVb7VV3zT2Wb/6IeL9YMjLzi8yIjKhb3+8cnWrl3SIjY/nifZ/3eZzotGXEYUJEMDHFYcK7F7KJU/e6qha25nP9OKQiCO/vdiV/hwnAa9CGHSYGjoWhY/Nj6pzf6HrpYPFYjvB10VA96/ZXO7sR4TGQTjARbmLRetWZQ/RJbNYauNjZ4/e/vu010RRF4WtoVVGEIt7K1Nj3rNXHj+v4vr4VHCYMVYOuqBiUUITsCIh1/uHr3o1ff8/fibx23HeY2Kw1fbdCL5JDRCDfMMxERx5yqFivLi6+4sLAguMxw4gKUxtGsgPH+O+LOS+B8bXf/rCPmm74kRzj68iuNYSmqJmIU0SohVz0GGM8gmE8kiMDwUSCCHkSuuo5kXzq+iswVQ113cRqpR6Jn5kE1TboGbFKkRwJ70fPyGHCYS5uDrp8TRJe25Goj0dyCIhuFkV8/TEeyfGW7fN4y/b5sVipaez514i4yxQAfk3JOvZRIpFIJBKJRCKRFEt5qz0SYfj0U8GFMd5gGIvkCDlM6CZvNhPn25uoat7Dq8vcuSbewu4EXjRJikgOeBaqQ8dGVSeHCY3/LsATTnjNa+/vRB0mii/0OnPut6wI8rTtkMPE5KKYpqi8qBiO5AAC2+MyM0+cAE0VUTErqYD59Xe/Dp/4734w5HSi5VZcrGnjk0kEuX8YSiySI8fPhqXapwzwG5KGluQwQZEc3vR23M58UZpm1Zuq8ouEIg4TIlADZnmRHMG+pn2UlD09DXrvY/bBdD8ICeQMVcMNP5JjmtOKZHmYc4oZwseQ5jcAiLD4EJgsSsgKkRz6VdNriN0YdCKNdjpnnbjDRHyS1v8Patpd6x+MCUPo2sUYg8PcmbbRLaM60WGChEUb1Ubi101Vz02AMgsXTCw6KQfIPl6Bkrlz0CQ2ak3+eQDgFup0HJ3zXYNeOsxCMEHCQQW6omHgWLjSO1jIYSIaIReN5JhH+PLI5hncGHTwamfX/50jvt6jfxu6KSTCrcTc3IrEe/5IssGPbuOBf48se5Os6ruIlQ1XQBxb001s1VYir61V6jBUDZvVJr8O7E2ILogTj2cgdv3zer2SfJ1NQ+AwUR7BhCsoTK3ryYKSSb8PoX+pib8/6qOmm2ibNRyMBmOuhR1riKYhdl3IgrpucgH/0LF57aHvjCICrSyEh2kc0+h5+emdy7iwegwf/bofwB9//T8UEv7Q99C1p6rpPNKU4IKuCXFeaTjuOyZd7R1w8VXcYaJrDwMHoyU5TAgJrRMcJoi6bgpvK93vbyQIJmj9VvZ7gUQikUgkEolEIkmH7FQcAYyYG0JRTGp4bjfaALyHbE1VYw4TwF3tLS8T2bb8xn/6w7Ki6/z9i0dyBNOg1KSnaX76ee5aEXaYcJ1I1mvRBUlG06wFNh4rXGDi8CJETZtsUWmoGpgvVBn5kRxRa+ZywwUTKZpG9P5o/yQJXFRFxYoZNIG2ais8tzlraglWrkRSzIIXyZGnw0QKi3DXBcCgKCq//hEV3wUGyK+YRY06crDIKjN4WZEcvLgb2t52ZTySw3FdvPPX/yX+4xc/M/F3kZvH2DQbv84H1/vXbp7GzqAHx3UTRRuS5TOvqwlFWOh+JIcTd5gI3YPzdpigYzDuNhMmLJJoha6xsx0mog0icpi42NmDzdxoJAfSOkxU0JkgULrR9yIgkjKzAXi58QVGchQldKL7VsusLm0bVis1nmMOBA2UVd+p5FRjFaqi4CVBi+9phBucuqriYncfLmNjgolZzjB/ce1lvPnf/+/YH/YjzTRqei3i8PPYsbPe37j+sv87A6cVOh8agvdcWhcVvY4GvGta0oS4GdvXl7p7WKvUp8bOlYGqZpTCuSPOvMeeoij4Hx78Unz1nQ9zC3ybuRNdeMJ4MWrj+2LHnx5fy9BhwimVw0TyIEMcTzCRIpKDYC5/XnaYi7puomVWYbnO2DndsQZoLknkBnjvaeQ6sN3gubRtVtG3rYh4xsogatBOIQAmYfRTO5dxYfU4dFWLrEmmEURyeNdXxXfy6SdEBGZxf+SCCV8gCmDMYSJ8b1zGAIkLQSfSiEgiKpioaYZQnCrFbwGzHCaKjZOSSCQSiUQikUgk2SIFE0cAM9SsLpJJDbCabmC90uATQeEH1zccO4cnT9/nPfA7Iz/7NX0DraJ6TVKXubD9TNVZKIoCxW+HDEIZzEBgeznkkRx+U99//SDU5CjaYWKRLOqsMCMOE2KRHIDXaB65Nkw/kgMox6ThLOZxmOCCCb8oKWLd+k9e/x786ye/eY4tnA0V+5Om7qwEy2kz5wYdn6wVEqEwwHWhYjySwwwJJjq+3f2KYDFSFIr4IHFBmvziaVDBPXfBhDvZYSIcyXFz0MXnd6/gszcvTfxdtK3xz4E7CYXqlG88ficYGHaHvVQRLEcVkYnOvJnlavJHl57Dd3/kV8amRcNTwpqiRL4+cKLOC1yUkdPkLXc5meIstRoSTIQjOSZNBQeiOA/mf50cJl7xp+sjgomQaxUDm3lP9qzLkwUTVJzfqk0QTKhqYWs+l7GZ7hl5Qfet1criDU5R2jGL+f1RL7INpqbjVGM1E8FE4LyjQFdVbgcej+SIN/HjPLN7Ga90dnGxuxsVTHCHifnXjfetnUBNN/DJa55gom9b/HOh815UpEjnTxnWfbabbPVOzy4d/3p9sbs39nmUkaqul0KIEmcRseT//PhX4skz90WeL0wBR8GGYaKXcL/dydRhwtuOcjlMiO3rhlERaiDHIznAWMTho269WhdoAAAgAElEQVQYXJy4N4zGcngOE8ubxK/zZxyLP3et+Z8zXVcBZOKcZ6dymPAjTEZ93LN6LNXfIXFKQw/2Yy0WL5FlZBAJJq70DsbqJID3zBNe14kcQ4viMlGHq2BNGl+/1g1TqHZD8VsAcN0XsYahSDXpMCGRSCQSiUQikRwtbt9OxREiKJyWI5IjqeB4qrnKJ4LCqv//+53fiq849yDPGnXndJjwnB9s7hQh4jBB28oY4w/EVe4wEYvk8GM+wlmtRNEFyTRWoHkROHI4wpEcgNccGMYiOUYlKJzPgvZ5GmtZEpWQQEGkUbxiVidOGC9KnTtMjBe4enySKJigNNR8BRP8+iFS5GN+Q1JVxuyYTVXnQqdDawAFCn+vWRGIC7xmZ+DIsdg5qCiKn1ufb8HdTshbNjUdNd2IiMGoQHiQkEcd/13jkRz+OeIXLRu6iQfXtwF4sQiiVtFHld1BF2/+9z+BX/6rTxS6HfoM94c/uvQF/PoLnxorLjuu//mpKlRF5Y0UwBdMxIrq3t/I57geCURyhEUSEcHEhG0LHCZ8/P/fMCpoGhW86McvhIUhdD8QdZhom1UMHCvxnnfTj67ZnCiY0At0mBDNEM+eQDBRm/Gd2RG3mKf1X/g4OreykW0kB6L3tniDnsRBk85buq8fjAaRyfq+M4r+nTmuv7qq4bWbp/HJ66/4f8viEV+1uR0mil/3ucxNFD2SuwdFkFzs7I05fpQRUdeAZSMSyTELVVH5M4aIQD7sNhBmZ9hDxV/7LEre97l5EH0+bBgmugLN7qRIjnAEZt2P5ACigwWAJ5gQvS5kQT0kCieHCYq42glFLGXhnEfHtMgzQPi6fiGlYKLi/yyvp2A8bsbi27J4JMdWrQkFCq72DvgaMCluDfDe1zIGSJjoYE1MJBGmphmRiMxJ7IZqPdcH4w4TJKIjEb1EIpFIJBKJRCI5GtyenYojhhFqVhfJNMHE3e0tPqmQlCvp2SNacESzKWOYqoaRY/PGQ0Vg4oi21WUsZDUZdZgIIjlsVDSDvx6eTinaYaIMggkqAA0dG33bgqlqU4s1VFSymeuLUXQehxKfNHSZix/6+K/jszcu5rT16REu2IQgUQkdL4s21xeFGk9Jx2/fHkGBMmarn6eYxU1xHDPmAv6UUXyqvKJpPNaFMpOzdjEg+9yOFXOYyKBAqatqbtEFxKRrRsuo4sAKitzXuGAieQoeCOIQxgUT0UiOu1eP8ebvzX7nto/k+JnP/AH2Rj28/tgdhW5HEAOT3OShQnz4ngdEp4Q1JR7JYUdzrifEXmSF5Uw4BkOYms4bKOF4Do07TETPORfR4zc8rXi83sLLvptA+BqpxgQTyozrTmtCYwkIO0wkRzLlLWCbhogYJC+osblshwmHubw5sucLyMKijXMr63jpIHCYeOVwB//uuT9P/bfImcdzbgmOn5NxwYQ63Vmu5zfKD0eDmMOEd64ETev5PsfXbZ3FUzuXMLAt32HCj+Tw/20IxlXQ95chOsKeINherdTRNmvcQeRSd2/s8ygjLbPGY8nKBBfbLXgNoSl7EYE8NZjjsRx7wy7WKvVU4udJaKHnmrLgTHkuD+OJa2Y7Xo27Z7CIYKXmR3IA40LbjjXEyhIFEzX6zK0Rvx6SYOKmL5hQoGRyH+UxGCkcJgDgQns+h4mwo8Ekh4lFHe8Ab1s3aw1c7R3y4ZCwuCj8NzaqjeVEcswjmEhwmABm129IHKlA4TFpYbhgQjpMSCQSiUQikUgkRwopmDgC8MJp0Q4ToInM8cPqf33T1+AX3kHRAuO5klXdwMCx4LguVDV94crUdAwcO9S8E3eYcBkLWU3GHCb830exEVSs2B/1eaGg6ELvIlnUWUFTgpbroG+PZk5r6YpvXes6GLkOTFXn+zwumNgd9vChz/8JPnLp2Ry2fD5cpBf20LFDDciiJ+vpM+onOKT07BEahhkpIps5TzTzwq6I1SpjgJ9jmxzJ4W1nXpnJ9DsPucNEdqIlU9UymXibxkTBhD9JTVwXEEyQnfFYHAKfQPT+ubu9xQUTNwbdiEPB7cbLhzv40DMfxwfufgz3rh0vdFsCMcP0SfW9UbJgQlVUKP59lBiL5FCm/41FsQQcJoCgwR11mKBJ/ZjDhP//lfhELYBjtRXeHA+/T7p2MXKYmHEtm9RYAoAb/Q4qmj6x8WwWLJgo6v5VL8Jhwv9bFMvBHSZCoo2zK+vYGXb5PeEXn/ljfP/HPoyPX3kh1d8KXxfpeF6r1HmDhzDU5OOWoMbwgTWMTB/TWnfRdeNjW2dhuQ4+d/MS+vaInwe0hhaP5ChPFJvjuhPvR54g5iYORgMcWsNbIpKjZVYjbnhlga8/Frz307WgIiCYIIFwXBSwM+hhvbp4HAcQCECcgq7LSYgKkRtGJTGeb9LvIwcxxtzI2q+uG/z+uh+7r3WX7jARuOjRc84aOUz4AtCWWcnkPppmcIGE1Yaq4VxrI9XfSRZMRB0mAge5xQXcAHC81sLV3kFosCTsMBH8ja3aitAxtCiOoMMVS6g1ETVtciRlGFr3nm6u4kZ/isNEDs+ZEolEIpFIJBKJpDhuv07FEaSiBs3qImFTJlnalVpgLZ3kMKEbcBlD37HmKuBW/CbpiEdyiBUKFHiNniF3ptAj/1LERxAbEWSP0oRjUsN5mYQzr4vC5NOONvqOFYlySCLsMOHtW407TMStmXcHXsGi6OM7zDwTtmSlShMtpRFMJEVyWCNejCYMbVmRHCKCCd9hQlHGxFHetcA7hg5HQ6zkYJVKjc5Dv1jmpLDjncUyrPaTIjkA732Fm7fX/ALhtEgObv+rxK+5Qdb18doKXn/8DmxWSTDR4RP9RZ8HRfATn/yvUBUVP/Dou4reFBj+52axSZPq3vUqnkfOj3l/Ej4imLCtmMOE39zNafKWBEZx8VQcauS0zHGHifi2kQCUH51hwUR9BTtDb0I1/D7JycaFFxk0O5LDz3pPEkwMOp4d9oTfoRcomHCYm8lE9jxwhwlzuZEcQCCU2Bv2oCoKmiERAzW+XjzwYjn+avcqAOCnPvk7Y/np0wg7t9B5c7q5NvZ9+gyhNDWCPIeJYI1KTS9nQYeJR7fOAgA+ef1l9J0gkoNc2sQjOZKdxYrAYWziVPa5lQ28eLiDS909AMDJRnuZmzYXbbOG/Slix6IIXA8WFEz459+s6z4QiCvi692dQRfrlYwEEznf5+ZBVBjVEIxv4VFVISHhuMMECSaix97haLjUSfxIJIcddZjYHXShKypqupmJc96kNXUSdLze1dqcKfKc9LN1fbbDRNrfPYnjdV8w4SREcoTuHxvVxlIiSl0wsWvHFIeJ6pTn3zDkrHZh9RhuDLqBYMiHXAalw4REIpFIJBKJRHK0uP06FUcQmu4ouqEcZNJPL8AmFY/pAbxrDeeyaTVVDQyMF4lFMm0B32ECbGxyIjmSQw9FcvTRMExUNaNwh4ks8oAXhcfCuHYkz3oS1KSyXC+Sw1R1LlKJNwBoEsgqOHImjMsYFBEnhBDjDhPFRhFUtWSLYu+1EZ/II7xIjjwFE0F2+0wYA/wp53hR0FR1fgx5FsB5OEx4xbG4w0RWFrhWzm5B7oQi+opZncNhwtvWMZFaqKD+Jx/4QXzTPW/AaqUGVVH8SI5sbLlvRX7rxc/iAxcew3YJmm76zEl1iuSICyYCgaSmKJFCsucwEdyDZ7lYLErgcjL9vk8ix3AkB52zTuz9j+2P0Ps7UWvx/w5PWyqhSA7HnT0FOSnrHfAcJjaryXEcQCBgS9OMzwqG2e4ZeRE4TCwxkqMSFbbsj/pom7XImuu+Vc8p5pndywCAz+9dRcus4hNXv4iPXf6C8N9yQ81kOm+SmvPUOJu07k8STBiqxhtaTLCROolj9RWcba7j3z77p7jWO+TrBfpX3GGChLLFrqMZY97k8iSHidY6LnZ2eRTPqeat4DBRG5vyLwNuSBS0CHQtEIrk0JMnyneHPaxXs7mWTLqXFAltyywhct2ooGtPjuT46MXn8I5f+xfo8v0XEkxEHCZMtCvemns/FuPVtZcrmKiFPvNeTDCxM+yhphuZOefN4zBxYTVdHAcQCMzCYr2aZkaun2nEGyIcr7dwtR9ymNCSIzm2ak0MHTv34188EnNKJEeCgOpgNMD3fORXcK0XRG/QuvdC+xgc5mI3dkyTw4RoBJVEIpFIJBKJRCK5NVjoaUpRlFVFUT6sKMrnFUV5RlGUNyuKsq4oyu8oivKc/+/4aJQkU6hhWPSElvjEWvDgSkXbwC51NNfEGxXMKK9XxKIV8LaV+S4HQFAI0FRvapZHcpBggiI5hn1UNQPV2GRHEZQikoNPO4pFcvAiuT3iYhRyShmL5PCzZvOOKUiDeMEmgI6dgeMLJjKa/pmXqQ4T9ojb2RJ5W8BPauInwlzAn+CON+pNTefOMIfWAE0zP8HEgX+9sTOymAaikSJ5YU9wd2jHIjmocHgwJQedirNx4UrQyGUwVA2KokBVVGxUG7g56EYiHW4nLD+G6HhtcjN8mRhcvDa98RqP5HB9QYDi/88JFaQHjr1Uhwk6nmdNVJJAoR26JkxymLjmi4Xo3ha2dz5WDz67amitoYYEE66Aw0TLbywdJNjmXx90sFmbPPlsFjjN7DJWmKNV06hAgcIbX8ugHYtO2fMFE2Huam+ioZv4zM2L2Bv2cLV3gO948K042WjjX37q94X/VsRhwr82JsU/zBI60X39YDTg/71eqfP1Kl83LvA5/uib3ou9YR83Bh0ukKLzQdxhohyRHLT+mOYwYTMXf3r1RQDAyVsgkmO1UsPBqD82FV00aZrL02hwh4nZz3vkRhF3UdgZ9rCWkfhq0r2kSEQjOer+s+ykZvcnrn4Rz+5dw3N717wX+PLOjTlMGNxhIryWZIyhYy3bYcJbg3gOE951j9xEdgZd1HQzM+c8J43DhLaIYML72YYRdZjohY5rej/ZCSZWcKPfRce/j0QjOYK/seE7yOUtfhOJOwMQE0nEIjn482+wrb/7yjP4tRc+FRE4kqvU+dUtAMD1WCxHxxqirpu3ZbSgRCKRSCQSiURylFl0hf/TAP4LY+w+AK8F8AyAHwTwe4yxCwB+z///khyZNWm2LLhV56xGcsJDLD28MlGrxRjUjO6MPLW/iEUr4DtMMMYf8MNCC1PTxhwm6Ot7ox7qhomqphc+GedkNK21CLT/R46NgW2NuRPEoczgnUEPI5ciOfzCeUyAQhMdeU0nz4NIMywOHZNkcV/0ZD1N2CQ5pPTs0VjDI2/ngyDXWiCbljEw14UCZaxJWtE0DP1zsjMaYiWHAq2mqmgaFXT8grCTocOEqWq5i4PC7gBhxiM5yGFi8pQqicrGm9Xe34hPwG9Um7gx6MB1qWF3exUa6XybdY1cFtUJVuUECSb2ExwmqAnjRXKEHCbikRxKvg4TJDAyZhxLqxUSTIw7TNiugz+7+iIudTzLfZokb1BzIHQcH6+HHCbCkRx+EZ8xJhTbNCnrHQBu9js8wiYJOt+KcF7yGhbFnLerlTp++d3fhg9ceHxpf3M8kqM/5nChKipes3ESn71xEc/6TcWHNk7hHafvwxf2rwn/rXAzmRpeSW4GPAZtViSHFThMrIUs0500jk4TePLMffjD938//t4jT+Ib73kDgOB8aBhi1zdqvhXt1EZN7klNxnMr6wCAj195Abqi4lhJBG/TaJlVuIwJRS0sE3fC+iMtgcOEeCRH2GHCcV3sD/tYy0h8VUqHCUEnr4Yf8TApYvJKbx8A8ML+df+VsMNE8Nxc100Yqoa6bkbWjX3bgstYLgLmSQQuAlYgmOAOE13UdCMz5zx7HoeJdnrBBO3rsPCkrpvoO6HjemJM3nwcr7fAwPCKvyYKi0TDzzy0Xsl7iEQ4EnNKJEf42CA+fuUFAMCV3gF/bW/Ug66ouGPFi9y6kSCYyOMZUyKRSCQSiUQikRTL3BVPRVHaAL4MwL8GAMbYiDG2B+BrAHzI/7YPAXjfohspmQ49QBcdWcCEi2DjD7FhR4J5po6o2X7Vf9AVLcoo8AUTsUgOwJtaokn1kevFRtC+PhgNUNMM1HSz8EJvVnnAixAWTPQda6bDxLrfbNgZdjFyHC+SQ6dIjuhxzCM5SiSYELFbj0NWqlSwzWr6Z16SJmyInjXiBSXCCDk35AEdx4rIbcl3mHj/+Ufx7rMPRL5kqoFDw6E1yG2irWlUuKNNlg4ThqbxmIu8cFwXmqKOidsokoOu5RTJ0betiTnP1qS85FAkR5jNajPiMFG0cGjZ9BPuNUVS0w1UNB27CS4HQCCkiEdy2Cy4BpLwEPDWAV4kx7jDhJVTI8lyHeiKOvMe2PbvO62wYCIUD/XB3/0QfuovfwcA8EpnBwqUIF4qdByHm6Xh90n7Q9Rta1LWu8tc3Bh0sTWlKWvMaJjnicPYbGFsjrzt1D1LnVSm44aELfvDfiTWhXho4xSe2rmMp3e8WI57146ndmYKC4/pvDnVHDfqmxmlY5HDRB89ewRNUdEyq3y9mlWU22qljh949F147Ng5AOkjOQKHiYLX0e70/UENs8/evIjtRvuWEPpNE2QVSSo3sSnQGlXEUbDuCwLCgon9UR8MjD+PLArdS5wSOUyIOnmRwKk3QVxzues9Wz9/cMN7ge73YJEBBfpM2rE4GIouKCqSox+L5Oj7os6snPPo+iFyXXjN+kk8efo+fMnJ86n/ztnmOr76jofx5u27+Guew0Rw/Zy4Jp+TE75A9KXDmwDiDhPe31AVBWt+tM0k8W1WuMLrj5Cb6QSHifD14E+ufBEAcLm7z18jcSSt+cYcJkZDYTcliUQikUgkEolEcusglluQzJ0ArgP4RUVRXgvgLwD8jwCOM8Yu+99zBcDxpB9WFOU7AHwHAJw9e3aBzZAYoTiEInH9B9KZE2sJqv/wtO08DTSKc/jMzYsAgHtXEw+7MRRFgQvG7YDDhbeKpociORyYodgI2uYyOExklQe8CDwWxnXQty206tMFK2TdeXPQ9R0m9ImF892BJ5go+vgO44JBSTmZSVaqVKApOorAUDVoijoxkmOzFp1uzjuSg2eqC1mEM4AB3//oO8e+Ej5vD0cDrOQ00dYyqzj0HW0cssDNxGFCz/1Yt103UbDTMmuwXAcDx0ZNN3C9f+g7izg4tAbY0MYn3q0JkRwhz+bIqxu1Bj59/dVUE3lHCZoErGnlEEwAwFqljr1hN/FrPJIjlt3sMpcf75qicsFTPN4KCDWS8nKYcB3eQJ7GHSvraJlV7jThbZv3c7uDLvZHfe4O8PLhDo7XV6Dy3RIcxydCDhO1BMEE7TNjhlV8VdNhqtqYg8vesA+HuVNjJz54/5vxrfe/OZNrTlrmiaS6lWkaJlRF4Q4T+6M+dxwI85qNUxg4Fv7Ti59FQzdxqrHqR0SJi1rckHMLXVOTIjlmrft7vjCCIjnquoGqZvDGJW9aZ9z4p2nbVVOsCe0JnZTCIzmCqezk/XG83uLuT7dCHAcALurxri/lScfMLpLDO9bEIjn8BmlIELDjx/2tVbJxmKD3U65IDjFxSt3fl117CGBcqEdN5Kt8+n6ywwTgrY/3h4EQsOOLi5fZXF7hUUoDLmhYD91Ta7oJTVEyea6hWDCR+/FmrYkPveuDc/2dqm7gZ9/+jZHX4g4Tdop4EBGO10gw4TlMhOs19H4buhlyccnbYUJwYCGFw8TV3gG+6IuByE0FCMSR9Dx8Y3AY+T0da5jbM6ZEIpFIJBKJRCIpjkWepnQArwPws4yxRwF0EYvfYF4HjCX8LBhjP88Ye5wx9vjW1tYCmyEhO9JJE8DLQnhqKCGSI5oDPn8kx6dvvIqtWnOs2TsJFQqfiPW2I+QwEYnksFDR9Ij1a103UdPN3O0nZ5F1cWQeKiGXk91hFyvG9ALCuj+JsjPoYuh4ggkqeg5ix/Gu38grUyTHPA0jOkbpeCmi0RVGURTUdCPRgrdnJzhMqBoc5uZmN5yqiO56DhNJmJqOkWPDcV107VGODhPVBIeJxSe6zIwylafhMjdxP7d5gbmPvj3CoTXkk7UHsSl4wpoUyTHVYaIjnK191BjY3v6a5cKzTFYrdS5Mi0OTi/EpZcd1ebM17DDB76V6cE83Qi4OeWA5tpAt+9+45/X46Pv/fqTBQ0LDF/3pyef3r4ExhpcPd3F2ZT10HAfbfmxCJAdNPZIzy+YMq3dFUdCu1MbiTm4MvCnGaQ4TuqrBULVCnB68pv7tI5hQFRWt0MT03rCX6DDx8OYpAJ619z1rx6EoSmqhocNcvm/p2pgsmJgec0NCyMPRAD0/Ji0s8BW16k/LyeYqfvHJb8Ffu/Mhoe9XFAVVzShceGzPcIXRVBVnfJHMyUZ7adu1CORgE3cHKhruiickjp1M3b+HmkIOE+ORHOReR88jixIIA5Pvc33bwuGEdVReuILneUOf4TARaiIDgBK6L4bvvTXfqaJdqUWEgCTUWmZ8QdOooGlUcLV3gL49gqookTiumm7A0LRMXJqcnARoIlR1A33b4qJzut9kJpggh4kD32EiHMnh/426UQm5FubsMAEm9NzApggmarHrAblLbFQb3E0F8CI5Vs0a2mYNpqrhWi8eyTHg545EIpFIJBKJRCI5OizyNPUqgFcZY5/w//+H4QkoriqKsg0A/r/i4b2SuaBGs0hR9lJ3H12/cJE11PCcXcDP3mGCCjZP7VzCfWsnhH+OGj2JgomQtf/Qd5gIF+ZqulEqh4lCIzn8ZunAsXClezBzAq+mm6jpBnYGXiRHRdV4ESYu/NkdltBhgokVbMLQeUrFpDI0ij0r12SHifgkGJ1jeTXzuRW5kHMHGyuAEabmOTQEBdp8pn8ovgIICuRZiGC8TOV8xW92qCkXhhosB6MBt549397iryVhOQ5URRkvFPPPZ1wwcWgNuXCoDOfBMqHzvyyRHIDvMDHBtr03IZLDYYzfc7z7qHcODBIcJjQ/Szsvq3LLdYTsp3VVGxNTqv6EO00XHlpDXOsf4pXODs401xBM0gY/0zQqvEgefp/krkXnzjSHCKJl1sbOLfp5UeHnsnFEJzyPEG2zhr1RHwPbwu6wh+MJYpbzrS3emCWXM1PT4TImLPgMn1dv2b4LX3vXI9isjR9HxowoPjpvDy3PYaKmG7yxBgTrxrROWSK86+wDkTX9LCopXTjygPbHNKcachU51bw1HCZWQ/fzMpGVWJJcEUTEco2ESI5d32FifUkOEz/8if8PH/zdDyV+LS9E46EokqOb0Ow+HA34enoMxiJOSuScNSmSY9nxBSfqLVzu7nMReN0Irks13YCp6pnEmWb5DJAWutYGYjjv/pxVTWCj2oCmqLjaP4SuqJFrJB3zTaPCP/skEX6WuMIDC+PDOUQ9Ju74kysvoGlU8MSpeyIOExTJoSgKNqpN6TAhkUgkEolEIpHcJsz9NMUYuwLgFUVR7vVfehLA0wB+E8C3+q99K4DfWGgLJTNJE8nx9b/1r/AvPvV7uWwHqflnPciyhEZneNp2niIaNaOHjo37UwomGJAYyWH61v6MeZEdFVWLWL/WSuIw4Yg6e+QICUkudvdgM1doAm+90sDV/qGXgavpqPjFlnjhnAQTWRS1skK8YBMQd5goQwa2Z+Wa4DBhjXhBiaDrTH6CCXJpmL1fmetOFExQbM5NvxjeNPMp0LaMKi8CZ+nyYvi233liu26iG0bYwpim5APBRHJD3XLdxGY1Q7LDxIbf/LvW837/olOmtxpU1C5bJEeSw4TLXL698UiO+CQ8NWYG9rj4MHCYyC+SY5G8bl1Rud00ADyzewWXuwc4s7LuXWswvm4hlwkSvlg3XgLbvwIgJJgQEDy0zOrYuXWDBBPVcgomXJY+kupWZ9V3AqFJ6yRRqKaqeHB9GwBw75onmEh733RD59WbTtyF/+Ntfz2x8TXrnKLGsBfJYXGRKp2f1OArwzqkFA4TAg3Pc77bUpLjRxlp+ffzuDtQ0fBjb0HRFYnWKgKRHOR41E1wmFjLyGGCzvXBhGfCVzu73MloWYgK6uu+oCRpoOKKH8Nxz+qx4MWQIJbiBlVF4c/QrZCgGCjGYQIAthttXOkd+NdAA4aq8XO8pps8cm5R7AIHF4Lmv3fciQpIRdFUFVv+WiYu9KVnnoZuohqLucgL4fXHFIeJaiw+5ONXXsAbjt+B0801XOsfcoFj2E3qWH2Fr+2IjjVcughIIpFIJBKJRCKR5M+iT3bfA+DfKIryGQCPAPgxAD8O4F2KojwH4J3+/5fkCBdMCExoXe0f4IX967lshysomAg/uFJTLdw8mqfgEBY6pHGYUHyHib5tQYES+T009WYzFwwMFU2PfJ0m9iYVx5ZFEGVQXAODHCZe9C07hQQT1Qaf5DBDcSdjggm/kZd3TEEaXLDUVuhUVOxxh4niG05VzRizT2WMcQvvMHkLJrhNs6jDxMRIDm87KZ+6lZPDRNOscHvlrDK5Ae+6s4xIjqTGUDiS45ovmLh7lsOEaycXZyc0mqkJfLXvFeFvP4cJiqwoj43vWqXOhWlhwoXvsUiO0DFE91EgHMkR3NNpIjGvOB/bdYRy7CehqSqGjs3XLh+5+CwYGM411xFcZ6LH8fH6ChQo/N535Re+HQe/+g8ABJEcIg4T5FwQJojkKKdggiG9YPBWhxqAl7q+YGKCy8BDG14sx72r3jqU1oyiDgrhqJtpGDOc5XqhSA7uMBESJuQVyTEPFU0fi2JbNnRtmibgO8cjOW4NwUS74gkB4pE/ReOIPivOgNxcRCI5VEX1IuhCjmo7GTtM3NXeBAB8fvdK4tcPrcGY8DBvRM/zaQ4Tl/1r3ptP3BV6NRDE0r23rpv8uag1wWEir4i8SWzX29xhoqZ575EGNGqakZlA2ck4BiMN8XgJ23UyX1dTLEc1JvTVeCSHubRIDvFIzCmCCU2HAgV9e4S9YQ9f2L+ON9fMrzQAACAASURBVBy/EyfqLbiMcWHE/qjPnXo2q00uZiU61nDpIiCJRCKRSCQSiUSSPws9UTHGPsUYe5wx9jBj7H2MsV3G2E3G2JOMsQuMsXcyxnZm/ybJImiqCk1RZzbZHNfF0LF58SNrhAUTsyI55pg4DhfM7l/bFv45FZ6V+NCxUdH0SBPc9K3xSYgSbuoDXnGophnoO/kWB2ZRikgOf/8HgonZBeX1UFaoqWrQVQ2aoo4Jf3aGXlGzVIIJxgQb+wHljOQYd0gZOBYYGC9GE7T9ebkfuGmcUpjLJ7/jkFPJTb/p2MzJLrVlVHFoeSKCrB0m8nZTSRXJsTpLMJHsMDGp0Xxny2sq/MYLnwZQjobdMqHzrabP3+DPmrVqHXvD3pi4hQrwhqqNNXpc5vJ7jqaogWCCO0yEcq7977NYPse15TowBGzZJ0Hbd8/qcTR0E3/w6l8BAM6srAWF9ti+OV5roaoHawa3fwD49yo6d9YVFS/98OsxeOHPJv7tdkIkx41+B5qiYrVSm/BTxTJPJNWtDlnMX+rsAZjsMvDE6XvRNCp4zcZJAMHaSHT9Eo7kmMY0AaPLXPRtC6qioGuP0LGGqOtmRDDhgtbrxX+OFU3H0C5YMMFmO0w8duwcarqRysWuSJqGCQVK6RwmsnpmoSa/SCQH4MVyRCI5hj1UND3icLgIG9Umzq1s4C+uvZz49c5oiKFjL9WVUFTMS+v9XoLDBLnqRAQT/v2QsWD9F35maFdqOBwN+WddZCTHtf4hutYwEEpQnJZuwNSycZggYUoRkRz1mLODtybPdjtOcEet6LqV3m9Dr4xtR164ooLNhOEcQlEUT0Blj7g4/GxzDdv+sMeV3gFs18HBaIBVX3iWJCyWDhMSiUQikUgkEsnRpPhKmSQTTG32lAQVii73chJMiBZgE2wSwwWrtI1oIHA4UBUFd4dtQ2egqQps17Mdr8SmlLxIDicS11EJTVcEDhNFT8YVPylITYGXDlM4TFTq3GGC9n08y5oxhj1/Oq5MggnxCZcAeo89v5GR1qEiD2qhTHOCrhNxwQQ1JK2cJkF51rJIoY/NdpigIlhe0z8rZhV924LlOtyON4smojfxlu81xWXJU8wUyXE4GuBa/xAKFC5wmBzJMcH+d0Kj+cLqMfztB9+KFw5uAAA0JTvr4El890d+BT/32Y/m/ndE4A4MWrkcJmzmjuWU07Vgu97GoTXkNsWAd98hcaNasMPEyHEWalRQPM3Z5hruXj2GL/guXGeb66HjOLrtbzxxJx4/di70CuPfuzPseuuF3i6GL30Sw1c/O/FvJ0VyXO8fYrPaKEUzOwnKSL+daJteJMfFrieY2J6wxnnH6XvxzDf9U6z77iKBA5x4JIfIGnhaJAetSbd8N5/r/Q5fr/ZtC4wxuG55PsOqXoJIDoEm/qNbZ/DcN//oRHeRsqEqKlpmtXSCiaxiBKnxLeouVNfNiIPC7rCLtUo907X4Y8fO4pPXX06MnjzwBbbLdJlw/efDWetqEp/0EprdNGTxxhN3hl4NOUz4a+7wc3zbrIKB4XDkrSmCSI58BMyT2G604TAXL3d2+fES/GtkJlDmzwCFOExEnR0c5vI1V1ZMcpig62VjiQ4TjuC9i4XXbBOiYPu2FTjNVBtcGHK5u8+FrBTJ0TAqkevH0LFhuc7Sj2mJRCKRSCQSiUSSP+WsxkpSY6razEYmPejdHHRziZHgU0Mzi71s7L/DD+FCDdMY1LC/s7WZalpou97Gq91dDGxrLJvTVHWMHJs38E1N58IMwHeY0McjDZaNU2ChhqBm1e6wh6pm8ImMaWxUG5F9C4xbMx+MBvz9lUkwMU/DiBonDKyQKaQkko7fnm9ZTAVUIu9IDu5QI9AsYsxNLIABQfH8jy+/AF1RcW9O06BkLdwZDXgjOQuHCVPThZtr82K7bmKzoh3KPL/eO8RGtYG2WYUCJX0kB5IFEwDwPz325Xhk8wyA+RyF0vKX11/BUzuXcv87IgSRHNlMtWYBXa/j03M9y9tWag6HjwGHBceQpij8Ok3X7/A9XZ/S3M0Cy3WEbNknQdfj0801nPcjaAxV85sEycfxt9z3Jvw/X/7fBy+4bkRUQdEzST8bpl3xGvHhBtvNQRcbJY3jAPwM8ZI025dFu+I5TLza2cWx2sqYwDZMxKlMI2cmMRGcy5jQNVFTVChQEs8pEjpRk+tq/4A7TABeo8cpkUtINSaULQInQ5eoMrFaGXewKZqsYgRpsnvauRimbpjohkSBO4MeFzZlxeu2zuJa/5ALq8J0RiSYWJ6ARXRf13VvX3aTHCa6+9isNrFVW8EaPdvx+5XniKMrasQpktzKSKzTtYZQ/an+ZUJrly8e3Ag5TASRHHpGAmW6fhRxTaX3Q9d9y3UyF0wcq634fyv6XEjXy4ZR4V9bhsOEIjJYw8ZrTWHqvsMirXvXKvWQw8Q+FzbR+rhpVCLnR5e7ppRH/CyRSCQSiUQikUiy4WhVhm5jDFWf7TARym6l/PgsEY7kSHCY0FSVixHmKaKR/Xdaq9zz7S08v38dQ8eOWIgD3qT6MCSYqKjRSI4gE9pOnCZaFkEecHGns6IovGh5stEWaqaEC5XU5DY1HcPQpCHFcQDlEky4czhMhPdRWSaHkyI5aMJsPJLDn5TNO5JDpIE+xWGC9vFHLj2LR7bO5JaZ3CI3BmuYqcOEqWZjETwNmyULJqp+prMXyXGIrVrTn1KtpI/kCBXU45iajp9/+zfhex9+O+7yHSzypK4bESvuIiGB0rIbB9NYmySYIIcJv4gcnox1QpEcamIkR4LDBMvHYWKiy4kgJDY8s7KGu33BxKnGqvf6lOM4DGNupIS/UW3wn2FT3nfLrMH2IxSI6/0OdwcoI6xEzfZl0TZrsFwHLxzcmOgukYSZ0mEifF5NQ1EUGGpyFF9cMDF0bNR0g19zBo5VKpeQcFRIURRpqZ8nLd8ZJU7XGuJXn/vziGvQssgskoMcJgQFE/esHsOnrr/Cn9d2hz2sV7IVTDy2dRYAxmI5HNflQwu7oeeavBGN5KhqOjRFHXOZAjxXSrrm3dHa8H4X3Rd9oYCp6dFIDh7v5h17h6MBmkZl6UK77bq33UPH5tsXjuYwVY1H6i1Cls8AaYlHYdjuYo5bSQQOE5MiOZbnMOGtP1IKJiY4TPTsEXYGvmCi2sB6pQFT1XC5e4A9/9hdNclhwoTlOjw2lCIZpcOERCKRSCQSiURy9DhalaHbGEPVYM2YkujZQSGELDazRFQwwSY8xNLD9jwFByqY3TeHYOJ6v4Nr/cMxq8mKH8lB0ycVTYeqqJG81ppuwGFuoc18kezlZUCNgZMTsr3jRAQTvhClqkWFP9TA0xU1E9vUrHAhljMeh/ZRWaYY67qBvhMtbnX960R8kog7TOT0OTjCDjXwJrknOkx423kwGuBLT96d2fbFaRpBfIXjutAVNZNi8FIiOVyWeAwqioKWWcWhNcC1fgdb/lRZy6yljuTg1/kJn9PJ5ir+4WNfnvkkXBINo1IawQQ5MNS08gsmqPBNEUu7ocabwwKnHC+SgxwmEiI5FHKYyCmSY6LLiRhJDhNnV9YBBNnXs0WRURHXRrXJm0nTxBatkKsLcXPQKbXDhDOHYPBWh2y5n9m5jFOCaxwguB/NWp8TrmgzCLTuny2YALz7Oa1xSeRbFtFLPIqtCBzm7ceyiFmzop1w73aZi+/96K/iBz72YXzm5sWlb1MQybHYNYQaxaLX/idO3YOr/UM8s3sFALAz6GK9OtsNLw33rZ9AVTPwyetRwUTYyn+ZDhOiz+WKomC1UhtbAwDAld4Btv1ryR0rG/7v8u+L/r9xwURwX/Oayl17iIaej3h5Gica4Wugd/2rxyM5MlhvuwU61Iw7TOQYyRET+mohhwlD1aArKvo5i9+8gQWR/TxLMEEOE56AieJ5TtTbvsOEL5jw18fkaEPOEoHDxPKPa4lEIpFIJBKJRJIvR6sydBsjYuPeDTlMXO4W6DAxoXlQ9YsY8xQst+ttfPv9b8HXnn8k1c/RNOlTO5cnRnKMYrERVACPF6CLIit720Wh/XOqKTZ9GZ7sqoQiOcKF811/8mOz1iyVwwSbs2FE+6joz4pIcpjo+9eJejySg1uL5/M5sDROKYxNbGCGpw2/dPt8JtuWBBWED6yBF3GRUaHUWEYkB3MmNstWjCr+8NVn8ezeVWz5TdsVs4rDSQ4Tjg1DmxLJMWMyfxnUdTNy/yuSvj2CAkXYRnwZcMHEINlhgkRw4aZ+OEfai+SIO0wE74+aCE5OggnLcSLuT2mh7TvTXMOF1WMAAsEEZgh/OK4bOdTDDhOY8r7bMetywHPyWBOItSoKt0TuBMuCpkwPrSFONcUFE3TfHKZwmBAVMnj3ivG1ZyCYWOGv1TQTVd3bloFt+X+nHJ9hRTOKF0y4vsNEScSsWdEyq5FrCwD887/8Xfz2y08DCNZ7y0TU9WAWx+orMFVNWMD0tlP3AAD+8OKzAICdHK6zhqrhtZunxhwmOqH1095oXJSQF2n29Ua1gZ3BuPvF5e4+TviiySfP3Ie3nrx77L5oqhrqoWfoVV9gRu4mHWuUm9vbNMgxAMBYJEdVN7xraAbPNHaBgwvxKAzHdWFkfB074d9L4oMl9H7DIpTcIzlEn79nRHIEDhPdiAPTiUYLlyORHL7DhP8eSfx0OPIEEyumFExIJBKJRCKRSCRHjaNVGbqNMVVtdiRHaMLlSi97hwmaNJmZLTnhIZYmbucp4mqqih9503txbmUj1c+db3vNkb1hb6yBZWo6Rm4QycEFE/6/1dADdt4WlNOgyRa14EIvTXltCxYvN5IiOdRoJAdNfhyvt0olmHAZE3NCiEHvU1Pyn6oXoaaNF7foOtGYEMmRxTRWErywK3AcM+Z6LhMJ0Hlc0w28zrdHzoMVXzDRGQ3gsOwscCtLiORwpgg8zre3cLV/gNdunsY33vMGANR0mS+So8i4IqKum+VxmLAtVHV96dbU01jzp2z3JkVy+NOF4a+7LDiGlFAkB90vIw4TKjlM5HNc22zCMSgINZPONNdxx8oGtmpNPLJ52vsiXWdmxYkwF16eu/e5btSaQnEegXW5d345rotDa8hfLyPCGeJHiFbo80jjMFHhUVZi901HeHoWOFZr4mrvcOx1aoJHHSYM3uzq21apXEKqus6FVkVRpKV+nrQr0UiOv7j2En7607+P1/rXtyLE3q4vTln0mWWrtoK//Ov/2GvgC3C83sID69v4g1f/CrvDHvaHfaxVs43kAIDXbZ3DUzuXIsf0YSjqYpkOE4Gbx+x9vVZp4GZMMOFN4Pd4tMX77noEv/SubwtipvzfX9UM1EOCiFYskqMzGqBZQGNZURQeJ8Kb+ho1971Ijixc80gMmpVwOg0kmKDjzXKd/BwmtLjDhPd3yGWhniDCzxoXTHD9PMNhQjMxcKyxaJ7tehtXugd4aucygMANkwQ/FFvTkQ4TEolEIpFIJBLJkaU8I46ShTA0DdaMwlfYEjTPSI6ZBYPQg2u4mbZIJMe8nF1Z47bG8UKAqWkYOYFgohITTNQjDhPFFXvTFMTyhPbPScF876RIjkpsup7sYY/VVhInn4pCeMIlBneYUMvSqPAEE4wFBaieX+yqT4rkyKnpScexWCQHmzjxTcfhG4/fKZxtPQ8rfpHswBrCdt3MJlMNTYPD3KmihkUJxynE+cV3fgts143su7ZZw8uHO4nfPymSQ3gyfwnUDRO9kjhMDByLF+zLAjXn43bccYeJsGDCDk3Ca0mRHKH7qaqoUBWFi6KyZuQsGMmhqmiZVR678Gcf+EfB/VTwOGZ+TJAKBS4YNqqNoKnkzo7koMYS/Uuvl5EyxTksCzo2APHYMSBwmBBtyrkpnB+2G6u4nCB+5g4TtUAwUddNLmIaOJbvElKOz7AcDhPFNTzzpGXWImLHn/zk72Cz2sSPvPGr8TX/6WcLeXbJ0hUvfF6K8MSpe/Dzn/sj/P2PfRiaouCrzj248DbEeXTrDCzXwdO7l7lot2OFHCYSYi/yQtz50ROxf2H/WuQ1Gq7YDkVbAAjdF73P8kff9F6cCAm0WjHnpI41LMRhAgBO1Ft46XCHu1jWDd9pQvMiOWzmLnw9LFJwRcMmdN23MxRwE2uVOgxV4y5FBP2dpu9IWF2COFl4YGFCrYmoGyZe7exiZ9CL1CNO1Fv4re4e/q+n/xvef/5R7kITj+QgwcSKUd61mkQikUgkEolEIpmPo1UZuo0xQg4TjDH8xxc/i3/33J9Hvoemzmq6kVhkXRQqgs1+kE12mKBi7jKn3nRVw50tz5WiGmuuVlQdQ8cJBBO+OwD9W4s4TBQpmChJJIdKgok5HCYikRwhh4lBD5qiYr3ayC0KYh5cJjrhEqXiC0PK0myq6SYYWGTKsGt7RaC4YII+o7ziItIUdmmaOwkSTHzpttjU4bxEHSbczFxDDDXf6BPAK+5OKg6rijomNFkxqji0JjlMTBBMlCiSo1Eih4m+7zBRJnRVQ8usjgsm/DUD5YBHIjlCojEt5DDBIzn0cevmvMRWk49BMTRFxenmGv//uqqFru+CxzFjQCiqYrPaCLmsTBaKUGOJpo6pubmashG4TNK4IBwVwo4faSI5zLkcJsTWFicbbVzs7I29TqLHEzGHiZoWFkyUR/QSX/cVgVOgpX6erJo1DBwLQ8fGx6+8gI9d/gK+6+G3Yc2fqC7CYSKrSI55eOLUPbCZi99++Wl83yNP4oH1k5n/jQc3tgEAT/sT6kBxDhMkZBS5pqxXxx0maLiCHCYCovfFJ8/chwc3gn3ZNEyoisKdkzrWEA29IMGEL+LnURxaEB9BYn1rwbiwNA55WUPxieR06Qm4s3WYUBUV7z77AB47di7yOr3fuv/ZepEcSxBMCBzPUZFEksOEgb4zws6wG4nm2W60YbkOGkYFP/yG9/DXA8GE9/6kw4REIpFIJBKJRHJ0KVfVXjI3FU2H5Tq40e/gez76K/ijS1+AoWp4312P8OYXOUycb23hcvcg820QbniGH2LDDhPa8h0mAOCu1hae3buGypjDhBfJMRpzmPAKEZGJvQIFE8F+L7bQS/tF1GGibdagQAEDC4lQTFzsBg2AnWEPq5UaKpoOu0SCCYb5HCYqBR3jk6jz43fEi4nUJK0ZkyI58hJMpCg4TnGYuHftBL7roSfwgQuPZbl5YzT9qaJDa5Cpw0RFC/ZzDcaM754Pl6Xb3pZZ5YXvOJbrJE8OlslhQje5EKho+rbFLZTLxFqlPiaYICHgilHFilGJNHpc5vLmouce4QsmHBuaoo4JGHRVy+0avqhg4kxzDZu1leQv8sN4lmDCc5ggocVGtQmA3u/knyVhBDlL7HOHifIKJuZ1WLqViTpMiK1xgGBdJCo0dEPOLbM41VjFjUHHj/kJ7hUkDlut1HlcX3y96jBWuMiWqGpGIY37MHaKxvKtBB23+8M+fuqTv4PjtRX8zXvfhF2/MV6EUCWVODZjHj92Di2zijtbm/iuh5/I5W+caa6haVTwTEgw0fHXT6qi8KjBZZBGnLJRbWB32Iu4LdzodwAAW/XY/XHG+k5VVKwY1YjDxEoBkRxAIPbgkRz+dbCmGxHnvHgsZxrIoaYIwZWhatAVlQvlbNeFkYNw41+9/ZvGXqN9SuuYmm7kXg8Rd2GaHsnhOc9Z2FF6OLuyzl+n//7Hj3+lv47zIBeNIJLDO6dXpGBCIpFIJBKJRCI5cpSjaydZGEP14iM+9PmP479dfh5ffcfDsFwHz+5d5d9DNoLn21u5OExQEWz25P0EwYT/4L3sItrdq1sAMDb1a2oaXMZ4ESLsggBEJ/b6hUZylMNhwkjpMKGpKp/qoH378OYp/NXuVW5ZuzvscSvQvBr18+AwV8wSNAaJDrJqri8KnXNhhxT670Y8kkPLWzCRJpJjssOEoWr4R49/RcRiNQ+qmg5D1XAwGkTiCRaFziNLcCJ5HmxX3PYdAFqVGg5HQy5qCTPTYaIMggnDy1VO2v5l40Vy5COEWYTVBMFEzx5BVRRUNB2rlXrESjwcGaMqnvCNMYaBY425NQHeNc9ecIpzEiPH4Y3pefiFJ78Z/9ub35f4tUAoISCYCAnpNqoNgN7vlPe9wiM5vOL7vi9KaUvBRKlo+QK5iqZH3LFmYXLHILHreZp9S8KN+HqeBBN13eDHV003IhFyDnPncsnKAxJ8OzldH0Sge0PWk9lFQ9E+f3H9JXzi6hfxnQ99mXcsFCj2LtJhwtR0fPgr/zZ+6V0fXEhkNw1VUfHA+jaeSnCY2K63l+ow4aQQp6xV6nAZ4/cgIBDwjd2PBNyT2maN/66ONSxsEp+cdmjdFQgnzEAwsaBgy+bXj2Ke7bw1rnfdt1xnaU4Xj2yexofe+UG86cSdAMi1IW/BhKDDo6DDxN6wi/VKcE9/x+l78R++6jvxDRcej3w/uWj07GgkR8MonwBaIpFIJBKJRCKRLEY5unaShaFIjpcPd7Bdb+MfvO7dAIDP3rzEv6dnj6BAwR2tDVzrHWbe+GQL2iTS1Meyi2h3tz3BxJjDhF/opikCashQc78sDhNFFh/DVDTP1j1NTu16lQQT3r5968kLYGD4+JUXAAC7gy7Wqw1fEFQewcS8DSM6dop2AyF4pEyowNWzR9ATYhkMbi2ez+fgpJjwpOZskSiKghWjio41hJOhwwTt52GOx7uTUuDRMqpgYDgcjbs0WK6T+N4Zb36VQDCRIAwqin5sGrwsrIUEESSu7Nkj1HUTiqJ4zY8JkRz0r8vY2LQ7oSsabypkjSfamX86VFXUKQ0G//id0cxlruutgRASTAjEeRiqhrpu8n1LThPtEkdyuKHokdsFTVXRMqvYrrdT3b+50FDwep7m2nzKF6de6kYFE30ei2PyfPVaaL1K4rGi14wEbdewQJcJEnOVZZ9kBTW6P/yFTwIA3nPHwwAC4XcR+5ya+EXt6wfWtyOT43lw/9o2ntm5zIU49Bx5ZmUtIjzMG9f1rtUiDWbaJzuh7ZsomBAQxLYrNRyMBmCMeQ4T/rVo2WzHIjnC/5oZReCR2KuoZ7uwUMFe0HErDYqi4Mkz9/H3TeLkPBF+/p7gZkrU/G3dHw0ikRy6quENx+8YO2eottEJRXI0dLM0z/MSiUQikUgkEokkO+Qq/4hg+hP4r3b2cLq5hjta62gaFXwuJphoGCa2G20wMFzvHWa6DS4EM5EnRXL4RQxVXW4h/nz7GACMTcVSQZEmP0lQQQWWqmYEDeciBRNucdmpYSqakZBzOx1yAaB9+sjmadR1Ex+79AUAXuGOHCbKFMnhzpnhTiKEsuRkc4eUUOZs1xryTNww9BktOok1CZcxKBAr7E6L5FgmK2Ylc4eJIPokv0aGkzLjmKZUD63xWA7LdfixEaU8DhM02djLOVtZhH4o/qZMkIPEn1x5AQ/8m3+G5/evc8FE8PWwYCI45ulfh7m+w8T4+zNydJhYNJJjKqIOE/CuSYHDRDOYwp3xvttmjQsl9mQkR2lpmzWcaoo5aBF0bRwKXs8dlwmv5bZ9wcTlUIwZ4F1jFCioajoX3ow7TAiu15dA0Lwvg/D4aB3XdB35/Vf/Cq9ZP8ldSWifDwqJ5Dia8SdhHtzYRtce4aXDHQDgYtPTjbWlO0yInuckYL85CCJD9ocDVDR9TATJBctT1ndelFsfA8eGw9zCHCZIMBF2lgC855+snPNs5v18Uc92Vd3k61ubudCVYpxyapoZeZ7MAy8SU2Q/zxBMhNapIo6E5CTRtQKHiTQDIhKJRCKRSCQSieTWoRzVMsnCmJqOkWPj1c4uTjdXoSoqHlw/ic/dvMi/p2d5zQ9qamcdy+G4okX05AILFTGWXcQ936ZIjpjDhF9QvOQXo6uhSI6KpkNT1UgBuiiKntYivve1b8c/ecN7Uv0M2WBS8dbUdLzx+J342OXn4TIXN/odrJJggrmlsNQHxN1U4lT8pl5ZCsV0zvXsqMNETR8XTISzfvPATZOpzlzfAr9YPIeJQaYOE3TdEZ1Ingc75YQ4NV0ORuOFfstxeNE5AjWLS+Ew4V2nu1bxgomyRnKs+ZEcv/nFz8BhLp7buxa5FqxWatFIDuby5kDUYcJOdJjQVDU30Zsn2slZMDFL+BOK5KjpBuqGGbIrn/6zLbOK/aEnRiKB5mqZBRNgc0VS3ep8w4XH8XXnH031M2ZKh4k07h3UCLzYiQomPKGTwV2QAK9ZWAs5opVJ9BI074tzmCDhcVni0rJi1RfMWK6Dd529n7+uqxp0RS3GYaIkIu88eWBtGwDwtB/L0bEGqOkGNmpN7I2W5zDhpLieUNTQTlgwMepPiIeaLSQkVypqMBfVXH7txmn80ONfibefvhcA8OYTd+Gv3fEQTjTagXPeguvtNNEneVDXDe506TlMFOR0oRu5C5MdJrj+mBXJEVqnroccJiZR1QyoihIIJkZDNM1iXFMkEolEIpFIJBJJvhzdasVthqFq6NkjXO7t43RzDQDwmo2TeGrnMi9Odf1p0W2ee3yQ6Ta48CbEZzLJYUKjSI7lFhxaZhU/+sb34uvOvy7yOjVg/u2zf4a3nLiLWzaamsabSNUSWL2XZTLuTSfuwttO3ZPqZ7jDRMjd460n78bz+9fxY3/+X3Bj0MFbts8HTYcCM67DuFgskqMsRfnAISUocPVti09ihaGmeJ6RHMIF9JI4TDS5w4STmWAp7+gTwGtspzkG235RcH+U7DCRWJwVbTQvgSB7uHjBRJkjOQ5GA/z2y08DAK70DtC3RlxscqLewsXuHhdMhV126F+XMd9hYtxxhERveWC5E0Q7mSB2HDPXBVwXiqJik+ze+Tkww2GiEsSd7A/70BW1lC4kxLwOS7c63/fIk/hALNd8FoHlu6DDRIqJ8JpuYKPaGIvk6Fkj7hK1Ylb87zVDAl+7VLEqZRAe26xYS/28ea+2sgAAIABJREFUCDe733Xm/sjXqrpRcCRHOY6/PLh37QRUReGCiUNriJZRxVqlhr5tLS3GMU30DgnYb4oIJgTubS2ziv3RgDuTFSWY0FQVf+eht2HFX8feu3YcP/f2b4KhaiFHt8UjOXRFFXPIy4GaHkRh2G6KZ6nMt8MoTyRHSCSRFOEYfs4VcZhQFAVNo4KOdJiQSCQSiUQikUiOPEerMnQbY2oarvQO4DKGM75g4qGNkxg4Fp4/uA4A6FlDHskBAFe62TpMMNECbOjBNTx9TE2kIgqW3/bAW3Bh9VjkNWpuKwB+/C1fywshpqpzcUetQFtbwr2FC72bPJIjaHZ96cnzAICf+9xH8Y7T9+L9dz3C7UXLEssx73QmHVNFu4EQ9QTBT88eoZEgmOCFxZycDxwmKLgC+DR30ZxbWcfz+9dhZ+owQRNv+TUybDedwIMKzYcTBRPTIjmKFzlR87BXFoeJEjbDSRB41RdSXu0doBcSTz127Bz6tsUbQI7rQvPjs6jxNS2SQ1PycZhgjMFynVQRM+n+gHf8znZKYYDvvEBZ8KJiC5rEBfwGVaVWWONFhDI128tOWmemNBPhAHCqsYqL3SSHCe+8pTilum6gqnvX6b49KlUkR5VHckiHiayhz/94vYWHNk5FvlbR9KU17sM4t/Aziyg13cD51lbgMOFPo6+a3n12L8GtKw+cFM5ta/7z2O4wEEwcjPr8GIpADmJT7m1ts4b9YfEOE9MwMorAK1KkAHjPciQIzjWibAbVkHAjL0Sfv9mE4Rwi7KS4JuAwAXj7uevv5441KOUxLZFIJBKJRCKRSBbn6FYrbjMMVYfrPxAGDhNecexzNy8BAG9+rJo1VDUDlzMWTMyj+o84TOjkMFGOw5K253te+3bc5cd2AMCF1WO4f/0EgLI4TNy601rfcM/j+PG3fG3EYeK+tRPYqDbQNmv4iS/5OiiKkru7QVrcNM39EGQ9XRYr4sBhIiqYoAZzmLwjORhzhY9hVhKHiYc3TuPmoIuXD3cya9jSRHJe+xnw3TxSXGfjzfQwk4qzIhnXy6LBo2eKF0z0bQtVbfz8Kpo1P79cgYKWWcWV3n7kWvD4sXMAgD+7+iIAbyJbS4zksPh1LoyharBzcAii8ySvSA4m6BIB1+VRTWRtDnq/M352o9rAjX4HADWo0sdxfPrGq/jIxWdT/9w8lCnOoeyQAE5UDJB232432mNr+XCUDkVy1HQTqqLCVDUMbBuOWx7RSzUUFVIUtI7WS/L8kRWmpmOj2sBXnH1wTIRV1YpxmGAlEuvkyQMb2yGHCa+5ShEp4XirPPEEWOKONXXdjEZyDD0B3ziz13ftSg0Dx8LOwHuvKyVsLhsaOQAtGsmRncvcPHjODiN/W9z8BKQC2zFwrFzjM4UjMWdEctRDwuU1AYcJwBP9dKXDhEQikUgkEolEcuQ5+hWL24Rws4AEE3e3t1DRdHzu5kUAQNceom5UoCiKV2TtZS+YEGp4TniIrRYUyTGJt568gB978/vwdx96IvL6P3jdu/FL7/o2AMFkXJEOE0Ekx613Op9b2cDfvPeNkddURcVPf9k34EPv/CBO1FsA8nc3SMu8E7bUDC/LZ0VNFSoAef89ikzeEEFURD4FdidNo4i5AhPf+fPw5mkAwLN717KL5FiCOMhJGclxurmGE/UWPnb5+bGv3RqRHP5xbg9nfGf+lDWSY9UXxbxu6wzOt7dwtXcYmVTfbrRxprmGP736Ihhj6FpDXpQPIjlcDBw78f1paj4OEySYyG2iUvQ49l1vKpqOY/UV7yXMnsIFgBONNq73O7Bcx2tQzSGY+LnPfhT/y5/8Zuqfmwf3Nml4ZoGqqDBUTVgAl8ZCH/AcJi7FHCbCsVrkDkTiyKrf0GJgpRFuVsrgMMG8z+couh78xnv+Ln7o8a8ce72i6YU8u6RxPbiVuX9tGxe7ezgYDdCxhlgxqvw+uyzBRNpr9Xq1ni6SY8o6nIR/JBpZSXKqKJisni3TrqmzpqYb6PmCs4lr8iVA9508r+UuRJ+/s3eYaBgVdH2nuoORdJiQSCQSiUQikUiOKkk+2pJbEIPHRyg46Udu6KqG+9e28VlymLBGvAF9ot7K3GHCYQyKQGGGTXSY8B5ey1KwbBoVfMt9b5r6PYqioKrln9k5Ddf19qFakuJ3Fjxx6p7I/6fGXJkiOXR1HocJ732Updm0VWvCUDW83Nnhr/XtEbYbrbHvVRQlVeMnLd5kreB+KYnDxP1rJ6ArKmyWYSSHuoxIDvGpQ8D77J84dQ9+66XPwY7FH8yM5CiBsIVHchR4nQa8xnlZIznW/YLxu87ej0/feBXP71/H0LEjReXXH78Df3TpOXzy+it4pbOL7/LFhKrvtuPCc5hIiuQwVA12DlOHo7wFE4KxGoy5AGP4P9/2N3jsmUjOOwCcqLXAwHC938H+aDBhonc68UZXnnhrvaPf8MwKQ9WEr+dpozJONlZxaA1xMBpw6/yw0Om9d74WmqLy/1/TPMGEw1x+3hZNxb9eFCuY8B0mjtA6mrijtZH4elUvxmEijevBrcwdK+sAgFcOd3A4GmCz1Qw5TCwnksNljEdnibBRbXJHCADYHw2mOx5NcY2i69HPfOb3caF9DPevbwtvx7LIyjnPdtMJ3bKmppvcYcLbloIcJrTAtTBJeJ8Ftqg70gyHCdq+mm4Ir8kbuomuPQRjDDcGHWzy+DWJRCKRSCQSiURylDj6FYvbBGqyHa+vROINzrXW+fRZzx6hoXtq+DwcJpif3z37G6dHcpTFJliUqm4UaiVsc4eJW2u/pSFwNyiPYGIuhwmK5CjJZ6WrGu5sbeD5/ev8tfB1Io6harm5fKSarPWbk0VT1Q1eBM7MYSLn6BPAm6ZNaz3+xOl7cTAa4C+vv8JfY4zBcp3kJpNAxvWyoGZhzyrWYWLgN6eSBAVF88D6Nn7g0Xfim+55A47XW7jaO4g0XgHgDcfuwPV+Bz/257+Fhm7ifecfARBEDDmuJwhJdJhQ1FwiOUhEZybEgGSCwCQt/z7G8PjxczjVXPVfc4OvTeGEL1C70tv3J3rTT+KuVxvYH/WXIioUtsSWAPCOTdG1i5PSvYoE0mGXCe+89c7BC6vH8H2PPMkFLrReddzyOEyUwamNrk23QyOfqGh6Ic8ubor4tVuZs75g4uXOjucwYVawVvGs/8sYyQF4k/Y7Q0945zIXB6M+F3kQbEYjmiBnioPRAP/sjV+do6hxfrJydEsbc5c1XiRH8Q4TVMdJG38XfgadxeEsEQ8xodZE0LauV8TiOABymBiiYw0xdGxs1qRgQiKRSCQSiUQiOYrcPpWhIw4VIs74cRzEVrWJ6342dtcaoeFP2m7X27jSPcg0Z1K4iTyheUAPr7daIc2b2EtXHMgSiuQ4atnLYcwlNJHT4CKFG0IIiuQoKl82ibtaW2OCCZrIj2OoWm6iFdFIDiY4tb0sHt44BSC7yVQzo0zlaczTLHvr9t3QFBV/ePFZ/hqJtczE47k8DhMN3zY3XMQ9GA3wt37vlzJ3WprGwP/7ZXSY0FUNf++Rd2Kt2sCJehv7owH2hv1IzvPrj98BAPjE1Rfx/vOPcjtiOm9d+IKJRIeJnCI5nBJFcsSvSaIOE77z15XuwdyRHBv+pOPuEhpxLsrjTnArYKoaRoJCw7QW+iTOudgJCSasEWoT7uHkiDZvrFgelMNh4uivo+N4kRxFOEyUR6yTJ2e4w8QuOtYATaNagMNEumv1RrWBHd+pqGON4DI2fj8K3QunCWLp57787AP4slMXUmz18ggiORY7DyYKh5dEPeQw4TC3sGdMcm1I47r51M1LeNt/+Of4ry8/PfN7R46Nrj3CqtAaSVAwUU0nmOhYI15X25KCCYlEIpFIJBKJ5Ehy9CsWtwnUZDsVE0xs1lbQs0foWSP07BF/mN1utGEzN1MLZ/Gp++TpFGqy3GoTXk3/AbooSPRyq+23NOhlE0wwQTeVGHSelqVRAQDn21t46XCH79uuNZpopWpq+UZyCImlRBuYS+LhzdMAAD0jC9ysMpWnMc80XLtSw+u2zkQEE7xZnTTdX6LPiWyCu6Hr9NM7l/DbLz+NP7r03NK2o+8X5csomAhzor4CwLvehh0mLqxucfeDb77vjfx1LphwXT+SY/x40PzomqwJIjnyuv+RU8qMbU90vRFzWTlR91wCrvT2cTDqi01PxqBIlbCdel6ktXm/3fHum6KRHOmm77cbnmAiLPzqx5xhwlR1L5LDRTphRp5Udd9hokCnNsd3mDiKkRyTqPrxLMvmdonkWDVrWDEqeOlwB4fWECtGBXXdhKFqSxG2ASSOFb+erFcbvC6w729ja8zxKNyInnxffHDjJL7lvjfhR9/4XuG/v2woTm7R55qhYxfqHFbTDYxcB7breOKNgs4vWtv2UzhMfPHgBgDg157/1Mzv3R95QqNVf70zjVnrLrpHrgn8LqKhm+haQ9wceIKJzdqK8M9KJBKJRCKRSCSSW4ejX7G4TTAnOExs+sr5a/1DDBwr5DDhTTRmOV3rMlcs13qCTSJNAZfRtnMaLbOKg9FypoWScFxvHx7liS1TK5dgYl5L8or/PspUlL+7vQXLdfDK4Q5c5mLgWJGp8jCGKt74SYt4Eb08zgUA8NrNbB0mgviZ/CY/vQm09Nv7xKl78Okbr+KGP11lTWtWl0gwoakqqpoRcZjo+PEcLx7cXNp2kMNEGSM5whz31wcAIm4zqqLiHafvw1tP3o0H1k/y16nx6jAXA8dOjOQwVC2XSI7gGMwnkoMJO0wwsNg1idH7nSG2WK/WYagaXji4AZu5aFfmcZjw1npUyM8ThzEo0mFCGEPVhR0mHDddM/l4bQUVTccXD4PrWDxKJ0xV0zFwLDhueWIRyuQwUSYxa95UNL2QfS4sjr3FURQFZ1bW8ezeVbiMoWlWoSgKViu1pUZypBFGbVQb6Nkj9G0LB6MBAIzfj8L38Sn3xZpu4Mfe/D6cpIiqEpJV3OPAtlDJKxZMAHL76loj2G6RDhMkmBAXYl3tHwIAfueVZ9CdEZtHziwigomIE0rC8yINBqxVxQUTTaOCrj0MHCaq0mFCIpFIJBKJRCI5ipSnaydZCHroPx2P5PDV7y8f7gAIFPXbfu5xloIJhpQT4ohOADy2dRY/8savxptO3JnZNi2DllnD/pLsVZOgQu9RLkAaS5i6T4O4m0oUiuQoy2QnANzV3gLgZchSkauhVxK/N03jJy3CIhS/WDtremhZ3Lt2AhVNz+wzJReSPI91253Pjv0t2+cBAJ+68QqA6c3qYCK/HJ9TXTcjgonDkS+YOFyeYILOr/I7TLT5f8fdZn7my74Bv/yub4+8Rm47luvCcp1EQYiWVySHLyzKL5JD7DhmUxwmZoktVEXFsdoKnt29CgBzRXKs+4X7nQxdwybhXavLcw8rO6aqCQvgGNKtLTRVxV2tTXxh75r384yhZ1tTHCZMDGzbE72UZM1IjcYi3A4IHslxiwm2F6GqG4UIJjyxzu1x/TjTXMPTO5cBACt+U3vVrGNvSSJ7N+W1eq3iCe92B12+jeP3o2SXyFuRrMT4wwlC0WXRNDwXkENrUGg8CN13+imu5dd6nmBi4Fj43Vc+P/V7yZllVUhUKhjJUUkXydG3LVzzRR6bMpJDIpFIJBKJRCI5ktweFYvbAGqynY5NctDD3Et+U4gaoVww0TvIbBscV6zQyyYUWzRVxbc/8CX8vdwqtCpV7PuTOEXg+oWAo9zA4JEcrCSCiZRNDYIaA2UqFp9vbwIAvrB/nTeU6xPyz73GTz6fgfgkXLkcJgxVw/vPP4rHj53L5PeZy3KYmOMYPLeyAQB4tbMHICyYSGgylchhAgAahomeFXaY8K7ZS3WYcEgwkXx+lYWIw0RsWxVFGXMzUv3/TzbMkxwm8nAIIgEXNT4yR9hhwsXYNYn/7GxnjRP1Fp71m97tMQv02az7U5I7S5hcvl0mxLPC1FI4TLD0URn3rB7Hc/6xM3IdOMydKJg421zD53ev4MagU5p1CAmsBgU6TJD7ze10XFc1vZAYFEfUjfAIcG5lnccIUFO7XVmeyD5txA85Fe0Mu3wb483piFi5JOu7eclKjD9wkqPIlsWKv2agz6wop855Ijmu9g6wXW/jeG0Fv/nFT0/9XnJmEYrRmHGcGqqGJ07dgzefuEt4W8ml9aXDm1Cg8PNFIpFIJBKJRCKRHC3KUS2TLEy7UoMCBXe2NiOvk13gS+Qw4T/sbVQbMFQt20gOMKgih9QRKrYAXk5toZEct4HDhFkyhwnHdeeyJDdLKJhYrdSxWW3i+f3r6PoN5YmRHJoGK6emhujEa2BzX55rx09+ydfhOx/6skx+l+EfI3k5eQB+EX2OgupWrYmKpuMV/34yNZKjJIIWoq6b6NqB3e+hFThMLMuthBwmiiysi0BZ68C4YCIJuvd0eeTI+PvTVY3fq7KEGp35NQgEBROuG7UqB7hQgokIJhpt3PDjNOaJ5FhfaiTHfA41tytmCrGQ47pQ1XT79sLqMbzS2UXPGnHR4yQXm7/1wJdg6Nh4fv96adYhFFU2LIHDRFn2yTKoatk4TLjMxUVfRCn2/beP4OpMc53/94rpDSw0jQqPBMubtJEcwX2ky59rW3GHiYhLZPb39GWSlUB56Ng8WqgIyL2EHBiKcpioat56sZdCiHWtf4gTjRbec8dD+MOLz+JwygDKHneYEInRmO2E8svv/nZ81R2vEd5Wio596eAm1ir128qRSCKRSCQSiUQiuZ24fSpDR5wvP/sA/vN7vxtnV9Yjr1PxIx7JoSoqjtdXcLkXCCYs18Hnbl6cextcYYvfo2PnCXjFpIPRoLCIgNuh0MungHJyN0hLWttsggsmCipmTeJ8ewsvHNwINVuSm6RGjg4TTLiILj61fSuyjGN93vx6RVFwprmGVzq7AKZHckyKXiqKumFGiriUlXwwGvAic970Z5xfZUFRFO4yMUk8FYYiOXpTHCZ0RYUVFxRkwCj3SA7m/zNr2xkmO0zMPv6P+/FpQEKDSgBD1dA2q7i5hEgO8bWeBPCEhtSYvtTZmypqcedwmLh79RgYmBerZU13ibp79RhvEJVF9KIqKiqaXkg8BBFEcpRrbZYnFU3PJAblP7/0FL70//1J4TigtE38W5nwM3nTCAsmluNKmDY+kDtMDHrcGWNqJEcJ1naLQALlxSM5inWYIPcSLphQbi2HieO1Ft5++l4MHRtP7Vya+L173PVkcYeJeSCX1hcPb2JLxnFIJBKJRCKRSCRHltujYnEb8P+z9+ZRjl31ve/3zJpVY1d1dVfP3e52e8Zgm8GGeIghJgQyASGQ5GXi5b6bm+TlrbsyrJtk3ZDkkpsLIbkkeRDChSTPlxjMbDDEzB7oxjZu9zxWdXfNKs3Smd8f5+ytI5WkOlJJJZXO/qzl5SpNpT7a2mef/fv+vl+JF3DT6I41t4dECQk5RAUTUc8m6vZIssph4smZU3j4cx/CS8vtiSZsvxszW3yDpZaEHIJpW7RYtNmYltPtOcgFDGkTYgpaoZ2iBgAo7r+j37rr9ifHcT69RDe5GnWVy7wArWsOEz430e3+c5joJJsRyWG0GckBADtjw7i6RjCxjsNEH3xWEVFG0dPV6e1iu7RJsRzEcr5R93c/MRFxCvh+HCZIJAcRoYTqdFqKPA+zC4IJMgbleqKdTuBT9GDbVp3HtBDJ4cakAfUKVP4YVqJYLXdf/GPDpiIZxvoovEjn81/7xj/jvzz7hYaPbdVCHwAODW0DAJzLLFZitZp8b/+vW14PoH8EE4BbvO9BPASBONUMcrRdLZ1ymJgrZKBbpm/hoWnbgTnO0/Fh+nPcLWr3s8PENle4d62wioxaAs9xVOhBGSCXSLIO3qhgotxjh4mEG8lBREu9En6RtW0rc/lCKYeJSBwHkuMAgAuZ5YaPTatFCBxPHTWaYne+OSdGIzlSNPKWwWAwGAwGg8FgDB7B2LEIOGOhGK7knIKQdxN1e7RaMEG63r5w+aW2/o5vm9UB2mwBKt2gm5VJW0s7mddbDcm1bDa6UHBrh1a7tgjEYaLfuhj3J8eQUgvUVjnaYDNqSIkg3aX4Gd827wMwZzSD4zhILVi4t4pt285c3eYYrHKYMIlgok43Wxc2KzdCVJSrRG15XaWxOpdzFcHE8cUr+OALX+/KeyjRyIr+F0xMRpwCfrhBp7oXUjzPUAvv0JrHiDzflTFNXrNbc6pNx+76kRy1TiqtxAdNuo4eAJCsc/z8MBqKbprDRL+5JPUzTpSVM06XSjksFLMNH+ucB1s7tnvioxA5HufS/gQTN43uwC8deTXunTrY0t/pJo7bQW8dJtoVEW5VFEGEaVsbnpfJmPNbJLXaEAVtVaZjFcFEzI3kiMuhzRNMWK3N1XE5hKloEqdXF5DRykjI4TpifO81fH9ck7ULFeNvMAJPNXUoPXWYqI7k6F5EWXPIeafkcy4oGzrSahETkQSmokNQBBEXs00EE1oJybpjci22Z5x2yuUu4h5n1TSYYILBYDAYDAaDwRhggrU7FFDGwjGa1x4RK4XQ7ZEk5otZeiFJLnC/ePmlti4u/edaD5ZgghQ3Mk1yN7tJEPLEKw4T/RHJ0a4lORFM9Ft33YGk06H6n5/+DIBKF00tI10syPkVoXit8fsh6qEbSF128gDaj/DZGRvGqlpEXlfp91Gqs1Fs95kwLizJKOgVwUROL2NPYhQcOFz2bND+/Ylv4/3PP9k0R7ldyDl2azhMkEiO9QUTpPhFuhuH5LV2ySIn0LHXSUihQxa6G8mx7hi2LawVVbTgMOERTLQTyQEQwUTjuIdOYdoWc5hoAdnjMFHQNSosqkc77lWyIGJvYgxn0wtYdr+D0XW+t39y94/jl4++tqW/000iotySjXunabWwPAiQ6KSNukyQ4r/feI8giLwJYVGmrg3EYSLqOkxYmyA2sNq4Pjw8PIkzq/PIuMXpNfSZGHYjCDwPgdu4mLNsGHWjyDYLIlIlgolezWUSL0DgeN9z+VIpB8BxNhF4Hnvio7iYWWr4+NVyEcMhH3EcQGWcclzHrkG8bivjISaYYDAYDAaDwWAwBpVg7FgEnDHPRV1VJEc0ibKp045x0iV0ObeCU6tzLf8dy7Zpx25TvNn2W3yzBagUN7Jd6rxfDysAecBEMKH3sAPRi402HSZc2/h+62R81cQevHnPLXjj7qP4gzvfhBuGJus+bjQURapc6IpQwXehqM8K8d1AFsSuiYNM95i125FPOiav5ldhbKFIjqioVG3i5nUVo6EodsSSuOxGcti2jWfmLwEAzqwudPw9kIJS2IcIoddsb0EwwdcKJpS1RZZuO0xI3Yrk8OEwYTcSVbi/+1nnEEePuKS0XewYDkWR8mmLvxHaFQwGFUkQqLCnoKtN3cjada86MDSOc+lFfOL0MxhSIrhtfLrt99sLIjUOQJuNaZsDv46uhUQIbDQKhQgR/b4OiREMCmTNRJzbSJxAcRMiaCy0Lk65YWgS5zNLSJULdc/lg7YGl3hhw+vtXjtMREQZHLieO0xwHIewKPmeyxeKjmCCCHT3J8dxoYlgIq0VMeRXUEoFEzw6F8lREUyMuUIoBoPBYDAYDAaDMXj07uqOsWmMe2wDvcUPkpk9V8hgWImgaGh0E+uLl0/gxpGplv6O3yJyv3Ueb5Sk0lvBhOk3CmULQzZ/+iqSo40O21CfOkzE5RA+/IZ3rvu4sVAMumUiq5XpuO8UvgtFVV15W3/+qIfMVyzcO425waz2nfGKYIJES2yFSI6IKKHg2cTNaSqGlDD2xMdoJMfZ9CJSqlP0P7U6hzsnduN9x74MRRDxO7c/uOH3QBwmQj3cWPfLj+25GatqETtjQ+s+loylFSqYqOMwwXfHYUJ3O/e7ViAgoodm5x67gZME+d3HeYs4TLTrLgFUC9q6KWiw2yzqBxXFdZjQTAOaZTZdK5ptxhUcGprAE1dO4mJ2Gb9z+wMNY7X6lZikVDkAbTambfddVFq3IQXejTpMFA3iMOHvdSzbCpSbx3R8BCdS1+nxjrlOEzmtXFWA7Qam1fp8cnhkErpl4sXlWdwytnPN/d2IOuglsiBUifE/eeZZpNUi3n34nrrxYvVQTaOnUWscxyEuK1gtO4IJsUeCCcBxUPMbybFQcuKpJiKO+GB/chxfnTkJ3TLrrunSaok6tqyPRzDRqUgOzx7aOIvkYDAYDAaDwWAwBpbg7FgEmNFGDhORimACcIo5cSmEuyb24kuXT7T8d/x3xg2WYCLRF5Ecg/1VlmkkR384TLTbBUoiObbqxvxIKAoAXYnl8D2OB0xwVQ+n4607Y91wi7jtupyQbsnZ3Kqnu7+5YKIfNtWjkoKiodH3ktfLiEsh7EmMUoeJZ+YvAnCOzenVeZiWhU+eeRbfuHa2I++hbOqQeKGnm9l+2R5N4nfveMjXd5IUv1LuZn09MZXYAdvreuiuGEHummCCiB2ajGHymJpxXhn364//iCQjIYc2JEQbDUWhWyaNYOsW7cRGBBlZEKFbJu26zekqFa7VYrW5njs4tA02bMQkBb945NUber+9IOLGFPQKwxr8dXQtpMDrN0qjEUToUmKRHHV5677b8K4b7qK/E5HEZox3sw3x3OGhCQDONe26kRybECvSbSReoGsT07LwX7//Jfz58a/g7k/9OX7nO/+Gfzv/g6YCANOyoFlmTx0mACfyhThM9NLFMCzIvueChSIRTDiC0X2JMRi2hdlcqu7j02qxvutJPdxxynVQMFHlMMEiORgMBoPBYDAYjIElODsWAYao4DlwVR0Q5PZlN/O6aGgIixLunTqIc5lFFFrczGnLUr8POo83CtlQapZL3U2CULwgBcZuFNzawbSttjp4ZcH5d2xVR5BRKpjId/y123KYGIDN2np0wiK4EaTLv90Oz7FQDCFGMhs1AAAgAElEQVRBwmw+1Vww0WfCuLAow7Jt2gWb01XEZAV74qNYVYtIq0U8PX8RU9Ekbh+fxqnVeZxJzyOrlZHtkBiuZOgI9zDnulsQt52UWkBMUuqOB5EXGhaJNwIdg0J3HSaajuFGwghyu89/92Qk4bujtR4jijM/p7ogaPNiMoeJlpB4AZppoOhxUMjq9eeUdh3DSIzWuw/fXdfhpd+JijJ1KugFpm31XVRat6k4TOiwbMt3V3gtxLnJdySHHaxIjvunD+OP73oz/X0zBRPtRDbuT47T56wvmOj92m6jeNfbZ9ILyOsq/sMtr8cbdtyAJ668jP/07f+Nfzn7XMPnE3FzrwUTMUmpCCZ6KMp3HCb8uQUtlnIQOR7D7jlrX3IcABrGcjiCCb/nN3ds8p2L5GAOEwwGg8FgMBgMRjAI1u5QQBlzL+oiolRV5CWbNkQYUTI0RESZXri22qXov4i89TdYvMTdAkfPIjksCwI/2JuPEhVM9EeBvF1Lcpnvz0gOv5COmm44TFg+C0V2nzkXdANFELseydGuyIrjOEzHhjGbX6WbzBJfZ6O4z4RxEVeoQDZy81oZcUnBjSPbAQAfPfldPDN/CXdP7sORke04vTqPZ+YvAejc3F4y9J7aNncL8r1dKecbdv+JPN+V+VtzBTDdcu2wfQgmbFeEtGY+Irf7HP+/ddsD+PWb7m39Tbp00wGIYNs2bHQ38mPQkAURmmVWRQJl1PpzitlGgRMADg9P4B/e8C781m33t/0+e0lUknscyRGsmAgACInEYcLAJ04/i1f/21+0Fc9BriH9OlUEQeTdDHLNmHdFU9+9fr5rIrd23DxCooS9iVEAjSKi+mttt1FkXqTCy+OLVwAA7zj0Svzt69+Bl975hwgJEq7n0w2fT4RCoR6LYRNyCKtupFzXIsp8EBZl/5EcxSy2ReL0mnh/cgwAcDG7vOaxxD1r2K9ggqzHOugwIfA8FT2P+Y4GYTAYDAaDwWAwGFuN4O5YBIjxkHNRV5tpTH4nNsFFVzARk93ulxa7an0XkQewOyUiyh3rQm4Vo80N9q1ERTDRJ5EcaG/DV9nikRyjfRHJ4XWY2PrzRz28FsGdZqORHACwMzaMq/k0DCqYWPtadp99TlGPQNC0LBQMDTEphNdNHcBPH7gD/+OFr2O5nMfdk3txeHgSWa2Mxy++CAAdm9vL5mA6TJDieapcxJBcfzNb5HnYsGF12BWGfE+6FsmBBu4RVQ+pH8lBn+Pz3/zmvbfggekjLb07L2R+TnXBAYhAxB9b1SWpF8i8AM00qzrKG4mwHKel1udmjuPwpj03IezpgN1KRESlSlCy2ZiWFbgxTdajZUPHhcwSlkp5vJy63vLrUMFECw4TQTvWXmJuNGZOU6GZBn7uq/+Ifzr1dFf+VrtuHjcMO441dSOiBi2SQxCoQPnY4hWMh2PYFRsB4Ijbx8MxLDU5pxLXst47TIToWrWXsW+Ow4S/uWCxmMO2cIL+PqREMBqK4kKmIphYVYu4XshQkaFfhwkiYOU43rdo1Q9R0bmWGHPXWwwGg8FgMBgMBmPw2JpVO0ZLjIadi7rajVSZFyByPN3EJXbhccnpfmnVYcKCTa25m9JnncedICmHe+Yw0Y7l6lZD4HnwHNe1rvtW8R0fUYPsbqht1c9rJNQ9y3f/kRyDN3/UIgkC7ZzvNJa1sUgOAJiOOw4T5PtYNw6hzz4nYqVbNHRamItJCjiOw5/d81bcPj4NALh7Yh8Ou8WCHyzNAABU0/BdDGpGydAG1GHCGUtFQ2u4mS1y3XEJah4L0wFsH6IHel+DSI5NEgzR+dm15e4Gpvtv8bXWYwBworhM20LOI7xqFOEWBMewekQlGcVNiChohBPJ0bsiYy8g5yLVNJB2x+OxhSstvw4R3Zd9rll8i2MHlJh7jV3QVayqRRi2haVSrit/q103j8PDEwCAoXUcJgbB5c2J5HDG7rHFGbxifHeVg9JYONb08yGuLKEeCybicqUpppfxQq1EcswXs5iIVDs17EuMVUVy/Oa3HsXPfeWjSLvrmkYuZmshDhNcR9dgUUlBUg7R63kGg8FgMBgMBoMxeAR3xyJAjIeJw0S1YILjuCobXOowQfNVW+uq9V9EHiyHCcCxwsyovXGYaMdydSvidN33RzeTZdvg2igYbXWHiZAoISYpWO5CB7Nv4U+fORd0A9mTqdxpiMPERjo8d8aGkVaLNC+5biRHn83zRDBRMFTqnkTclEKihI8/8Av4hze8C/uSY1QwAYBGdnTCZaJk6D23be4G3u9ts0gOoBIJ0ym0bgsm3HHctDDUQFRBXVY2qQu30w5Av//04/jXs9+vus0iggmfa47Ff/4tZL75kY68n60KmR/THiFLo0gO38LjASMqytAss2NCQdOy8PtPP463fOF/4kc+81e4nF1p+nijzU78rQwp8JZNnY7NY4vVgom8rq7bLU6uIVuL5AjWsfYSd6+xc3oZqbJz3DstciMF/nbdPG4Y8usw0fu13UaRXUe3pVIOV3IruHPb7qr7t4XjWCo1c5hwIzl6LIYlzS5Ab68xW4nkWCzlMBFJVN22LzmOi1lHMLFSzuOb187hXGaRxnT4dZgAWWt2MJIDcBxiWBwHg8FgMBgMBoMx2GzNqh2jJaKijJAg0YKRl4iooGg4XV1FXUNYlGmXQk5r0WHCp5Wwt/AwCN0pgLOp1KhjsNu0a7m61XA2tfokkqNNhwmJF/Dn97wVb913exfe1eYwGop2KZLD3zG1Byw/uR6yIK6J5PB2XG0EkwgmNlBgPuqKCD5++hkA9SM5+m1TPeIKBku6Rt2TvBvMI6Eo3rTnJgCOAG5HdAgA8KAbkdAJB6FBj+QAGm9mkw38TkfN6KYJiReq3kNH8eESYTeK5Nhkh4mIKEMRxI45AH3x8gn8+9XTVbcRwYTf41144fMonnqqI+9nq6K4DjxpzxySqSPAsm3bWVtsUUHlRqiNCNwos/lVfPz0M1gq5XE2vbhu1IRpWVtWyNouRLynmgbSroDn2OKVquuy9zz5MfzJc19o+joFo8VIDsvakMPVVidKmxJUpFRnru6ka9sLS7O44/97H44vzsC02nPzuGf7Pty34xBeMb5rzX3V1+29X9ttFBKBd3zRcRSrFUyMhfw5TPQ8kkOurGe7JyBdn7AgoWSuP4+XDR2rahHbasQHh4a2YamUx4XMEr58+WV6zfKNa2cBNHI9qQdxmODRyXE6Ho7TyBYGg8FgMBgMBoMxmAR3xyJAcByHsXAU0TqCiZikVHUHRSSZ2oV2zWFiwDZbAKfA1rNIDssOxOaj6G5q9QM22hNMAMC7Dt+FPYnRDr+jzWMkFO2fSI4+KMR3A6lmrP9gaQb3ffq/48TKtQ2/Nunw30iH571TB/GOQ6/ElZzTtVt3c9YrjOuDeT5KHSY0em4jbkr1uHFkO0aUKO5wCwb1CpytUjL0nnchdgOhSjDRwGHCtbs37M7O4YZldrc4QMdxkzHsfqfWCEBt4k6xOQ4THMdhROnc/JzX1TXOKuTf6Hf+sC0TdpfihbYKxGFi1fO51BPYWi0e20GCCib0zggmSCH6V46+FoATf9AMMwDRdrWQAm/ZcBwmOHBYLOVwNb9KH3M1n8bVfLrha5iWRbvJfTtMwJ+4flCRBRGKICKvq3ROqJ2zZ3Ip/PLXP0EjM1vhi5dPwIaNuWLGcfNo4/pwWIngnx/6JUzFhtbe6T2f9Ynr30ZwIvBMHFu8ApkXcNPoVNX945E4UuUijAbXn0Qo1Gv3sIRnPSv2UDARkdZ3mPjQi0/hNY+9HwAwHa8WH/zk/jsQFWX8+fEn8LlLL2I6Ngye4/DU1TMAWnCYIOJOvrMOE3/12p/GX73upzr2egwGg8FgMBgMBqP/CO6ORcB4eNdRvHbqwJrbI5JMN2SKhoawIFG70FY3aizfTgeDV/BMyOGOWLa3Q7uWq1sNuY8iOZyurcE/5vUYC8X6JpJjswqRm43EC7RrDQC1E19sYgvsFxLJsZGMY47j8Kd3vwWv3LYbPMdBqSsC6K95njgsFY36DhO1/OEr34SPPfBuKgDoiMOEMZgOE965cEiuv5lNRA1GFyI5uimYaOgeUfUg8m+qfczmOkwAnXMAMiwTZVNfEx1Buj19n/9sC+gTZ6heIbsOE6se2/168wl1/wlgMZkI2vJG6wXieqy6UQe73GLcetczQXQ9IOI94jBxx/g0AOCY22kPOALDYpPPxOsI4tdhIuiRHAAQFRXXYcIZp6s1kRzPLVzCEzMv43hNRIofvjZ7CoDjptWV68MBa3qQeRGaZeAb187i1rGda4QP46EYbNgNz6sVh4neru28DhMbWd9vlLAgNRVMlAwdf/GDr2B7JIm/e8PP4a37bq26fywcw6/ffC++fOVlPD1/CW/bfzsODU1g1hVyDfsVTHTJYWJbJE6jbhkMBoPBYDAYDMZgEqzdoQDzR3e9Ge+9+b41t0dFmW54FXUNEUmusgtthfYcJgaDpBzumcOEE8kx+F9lSeijSI6A5owDjsNEdyI5fIpQAuAwodREchA74E7YlVs0kmNjc4YsiPj4g7+IRx/+FSoCyD//OWS++REANd32ffA5RdzzWkHXkHfFbTG5scPEvuQ4XrFtNxKu/W+uA4I4J5JjrdPTVsdb4G3kMEHGW6cFE/pmOUw0FWc1EEZQscXmCbsmIgnMFzMbfh2y/qt1QiAuCH4FE7ZlBd5hQuarBRNDSmSNEAVwYqkABGI9V0vUMz93AtKxTwQT672uYVs9LTL2AuIwUTJ0pLUi7prci6go45inSF/U1abHruAVTPj8nptW8Nw8aonLCnJamY7TVLlQtWYikZinV+dbet1L2WWcyywCcNaLfqMyW2OwYjUlXsCZ1QWcXp3H2/avjUskxfHlBoJl4qzS60iOhEcA3EuHiZDoCCYajY0VV3D/rhtehUf23Fx3fP7q0ddhWzgOGzZ+fO+tuN0Vc/EcR2Nj14P+fY4fBF0Pg8FgMBgMBoPB2ESCvWPBQFRSUNBV2LaNkqkjIsrULpRs2PjFfxG5vwppncCJ5FBpMXIzCUq3lsgJ0PokksOybd8Z7oPGqBvJ0emNUv+CK893bEDmj1okXoBuegUTzgZjuQOCCcPqXBdzQg7hnsl99PfMtz6G1Sc/5P7WX12IEVfUUTI0Wgxu5jBBSLhde51wEBrUSA6uKpKjkcOEK5jocCSHbhldzute3yXCthq4UNib7zCxIzaE64WNCyZIkXSNYAItFvUtE3afCB17hexGcqTVEkKChGEl0iCSY+NxSVuViOQ6ALURQVAPEskxGUlA5Pj1HSbajC7YypBO+uVyHpZtYywUw23j09TVQDMNaJZZJYqoxft5+XWY8C2OHWBi7rU3EUwYtkWdr4CKYO3M6kJLr0vcJYCKYII5TDRH4gUUDQ0hQcJb9t225v7xcAwAsOgKl2shDhO9Xtt5BcBSD+eysCjDho2yaeD5pVl8ffZ01f1EeDIaijZ8jaik4M/u+Qm85/A9uGF4ggomknLY/9rDI5gYBGEPg8FgMBgMBoPB2DyCtTvEWENUUpDXNaimAcu2aadwXArRnHe/+C4iD9hmC+BcxNuwke9Qd1wrGJbV026SzUIWhI53J7eLbduB7ZAbC8WgW2bHI2gsn8fUHsD5oxaJF6B6ioxkg7HosyDRDKObtu+2Vb9I3AeblSSSo6CrtBgRk9bvVCMOE/UKnK1SMrSBjOTw5TDBdSmSwzRp5EFXcMeu3WyuaeAkQeaqzYwOmooOYVUtorjBtUjOXf9ltTJMz2dGivq+HZZsCwi4w4TkieSISjKSchiZOudP4jARxLUFieRoVpxvhZVyATIvICYp7nWOj0iOgB13kePBcxzmi1kAzty9LzFGBVcV98HGx87rPkE67dfD71pvkIlJCnKeSA6g4ooCVObfM+nWBBNPzpzCoaFtAByBZjfEKVXnwj65JtsIZP3wyJ6bqUDWy3oOE2qfOEzE+8Rhgqxxy4aGD7zwdfzudx+rup84FI66QpRG/Ojuo/jTe94CALh9bBeAxoLc+jjjlOM7G8nBYDAYDAaDwWAwBp9g71gw3EgOFSV3Y4zYhZPNnFbwXUTus0JaJyCbLJmaHNrNwApIt5bTdd8fhRffbggDyIjbFdTpWA7mMFFBFsQahwk3kqMDgizLco6Z2I0OtEaCiT7YrJQFEQk5hIVSjhYj/AgmQoIImRc6IhAqm8aACiZacJjYapEcPhwmKvf1PpJjR3QIAHC9kN7Q6xQ867+cRzzbciSHbcHuE2eoXkEcJlbVImKSgqQSrhvJQcUoAVxbdCOSYzgUBcdxiEkKisZ6DhPBE0xwHAdFELFABRMRx3XQPVZkvdFMxJL3HFe/gokgHutaYlIIeV3Fqmcdveq5fvQ6TJg+z5k5rYxnFy7joV03QhFEFA2tO5GNfba22yhk/fCOQ6+se7/XYUIzDTx67hg0z7Vo2XAdJnq8tovLXsFELx0miJubjuVyHoulHJ1jgEokx1iouWDCy6GhbYiKckNBbl2qIjm2/jhlMBgMBoPBYDAYm0ewdywYiEoyCrpGO5dJF25cbt1hwm8ni91nVu2dgHQhd7rr3g9mQLq1RL6PIjkQXMEEsVFNdVgw4XsTfcA2a+sh8wJ0j8PEkrvBWDI7EMnhRiJ0Y86wLdNTHO4/YdyB5DacSy8ir6mIiLIvC3aO45CQw8hu0GFCt0zoltlz2+ZuwPsQTAhUMNHpSI4uCyb8xGq4Y36N7XMPIjmmokkAwLVCGpZt4cHHP4BPnTve8ut4O/K97iqtCiZgmYF3mJA9DhMRUUZSDtWdT1o+tgMEFUx4CvCGZeIjL39n3agH27bxxJWXce9jf4n/+dI3ATjHesSdi2I+HCYMywxkFEpIkKoEE3FJgWoa0Eyj4jBhaA0t7YmoIimHaeF4PUzbBs8H71h7icnOmEypRYwoa9fU5FqybOqYyad8vebF7DJM28JtY9OIiDJKNJKji4KJ/ljabYjDw5N41cQevGpiT937o5KCiChjuZzHE1dexu9859/wdye+Re8v943DREUA3EuHCbKPVDJ16srx0so1ev8ycZhoEslRi8DzeOPum3DH+C7/b4QJJhgMBoPBYDAYDEabDH6VldGUqKSgaGh0k5J0BsQkBTmtNYcJ/x3itufHwbiITSobs20vGXpVx0or6JbR026SzULm+yeSw3f8zABCuoKWy/XtadvF9B3pM/gOExIvVomDaCSHvvFIDmr73iWHCTqnV+kl+uNzOjjkCCZyulq1ubweCTm0YTEcKfoNosOEt4M1KdfvACSiBqPDbgu6ZULuYqGiMp4bv28aubFmnK//3E6zI+Y4TFwrpDGbX8Wp1Xl8e+58y6/jdRjzuiFUivp+c8Qt2FbABROuw0RGLSEqKW4kR/Va8VvXzqHsrgGDIICthURyeF2Uvr94BX/03Bfw7evnGj7Ptm3839/9N/zyv38CF7PLeHruIgCn+EzcsKKSQp0rji/O4Be/9nHoNcKtrFamwucgoQhiVSRHxelDpc4Slm3TsVkLcaIZDUVbiORgDhMxUUFeL2NVLWB/cgwAsKpWBBN5vQzRPUanV+d9veZszhFW7IoPIyLK1GGi80Ig7zV8f1yTbYT33nwfPv2mX296/TEejmGxlMMPlmYAAB/64VM0uoZ8N0K9Fkx4HCakXjpMuKLgoq7R60SvYGKllEdIkKiwwi8fuPdn8Md3vbmFZ7iRHByL5GAwGAwGg8FgMBitEewdCwaiorM5Ruz1I55IjlYdJizbBucn13oAIzmS7kZFu0W1d3zlI/iz40+09dyiodPPcZCRarruewUpoPnOcB8wRrsUyeFE+rQquNr6m7X1kAUBmmnCtm2YlkU3HTvhMEHsnbtSsLAtT7e997Ppj3n+0NA2LJfzmM2nEKuTVd2IRJ0CZ6uQYlK4xU3irQARSoYEqaEghIy3bjhMiF0tvvl3mGgcybF5438ikgDPcbiWT+NcehEAcCGz1PLrFDrkMGHbFuyAO0xIrsOEDRtRUXbmE7VE1xInU3N451c/is9efAFAMAUT5NrD6wSx4goFl5usNT5x5lk8eu44fv2me3H/zsM0isbbue91mPje3AU8OXsKl7LLVa+zqhapwCJIhASJOkkMyREaU5XX1ao5oFGkCRFVjIai6zqBELpTxN9axOQQcpqKVLmIfclxAECqXInkyGkqjo5OgQOHM6sLvl5zJr8KAJiOjbiCCd1x8+iqw0R/rO26zVgohuVSHs8vzWJvYgyWbeN9x74MAFD7xGEiJlXWtL08h5A17nI5D9U9959YuU7vXykXMBaOdr3pgIpdeeYwwWAwGAwGg8FgMFojeLtyjCqiknNhu1TMAagVTLTmMGH7jikYPEv9SiSHU1gwLQsfO/k9lHxuIM7mUms2cP1S0FX6OQ4yUp9EcpgBzhkHQIsKvYrksAPgMCHzAmzYMG0Lq2qRFilLTbLE/UI6/LsTyWGhboG5Tz6ng0MTAIAXlmZpYcgPyQ44TJBzQa+7ELsBGUvN8qWpw0SHXYI006QF6a5Ax24zwUR9UQXZsN9MYZfEC5gIJzBXyNBC2/n0YlOXF9u219yf84z3aoeJFs9/lun8F2AUvvKdj0oKkkoYhm3ROYF03553hS1BjCsQeB4hQaIFeKAiymwkznx55Tr++Lkv4PU7DuH37nwYu+IjFcFEuYCRkBPJ4UQPOtczaXeNfilTWW/btl31+CDhLfIOKWEqJMzrGhVSAKAOHbWQ4zrSgsOEaXWhiL/FiEsKyqaOoqFhT3wUAscjVeMwsS0cx674CM6sLuCxC8/jT7//5aavOZNLObEqcggRSUZR11w3jw7PJwGIxatlPBzH9UIGJ1LX8eD0YfwfN74Gj198AYvFHFTTgMwLPR/TIUGk4tGuxpStAxHNzroCHpkX8MNlbyRHHqOuU2F38URyBGScMhgMBoPBYDAYjM4Q7B0LBiJu0Yh0MJPOgLjb/dIKvrNS+6R41kkS7iYj6cR8ev4i/vDZz+Frs6d8Pb9gaG0X5IqGNpBdy7VIQn9EcgQ5ZxwAQqKEmKR0PJLDf8xJ/xXiO43kFjF0y8RSqXKcOxHJQQqeXYnxsSznPwD9+DkdGtoGAG4kR2sOE1lPl71t2/jwS9+kVuZ+KBmD7zAxpDQuOJIImG44TMh8F0Uo1DHFh8NErTCigZCi2+yIDeFaIY2zaUcwUTA0zDUZqx85+R3c9+n/XnVbtcNEZW1iud9r30U4i0VyeCNjopJM14ukeH8yNQcAuJJbARBMhwnAOTZFz7gjBeTVBoKJv3z+ScSlED5478+A53hMRZPI6SrSahFptYTh0FqHiYzqdPFfdo814JwPDNuijhRBIuQWN6OiDFkQqZCwoKtVIon1BBOjoVjD2I5aLNsK7PqZ4BVsjoSiGAlFqhwm8rqKmKTg8PAEvnb1FH7zW4/iwyearzlmcynsjo8AcIrWRUODaVldiF/rv7VdtxkPx3ApuwzVNHD7+C7cOrYTgLN3UjZ0+j3qJRzH0VgOsR8EEzlHMPGqib2YK2ZotOBKuUCdCruKXYnk6JdYQAaDwWAwGAwGg7E1COauHIMSI9aJJSKYcC5024nkcKw/g1nwjEshcOCQdjsxSeYs6XZrhm3bKBpaVRdnKxQNjeY/DzISL0DrA2vvljPcB5ARJdpxhwnfudZW/0U9dBrZ3exUTQNLpRy9vRORHAaN5OhCwcJu4DDRJ5/TVDRZdY7zS7zGYWKukMGfHvsyvnDph75foxLJ0fuN9U5TEUw0cZjgXIeJNt0WUuUCvnnt7JrbdcvsbjelD4cJu1H0RiMhRZeZiiZpJAdZG1zIOPEcV92uTy/funYeF7PLVWuQvK7RiDVvJIdpeXPB18e2LaAPztu9xDs+I6KCoRpHspdTjl355SwRTASzmBwVFd8OE6Zl4Zn5i/jRXTfSbuWp6BAA4NTqPGzYGFGIw0RFMEHW6JeyFcEEWcsE0WGCOB4RsVvMjffL6WUUDH+RHDIvOI4JviM5fIrrB5hqwURkzZo6p6mIyyEcHp5EydBpgf6Z+YsNX3Mmv4rp2DAAxy2yZGhdieSoKj4PaCxeLePhOP359vFpJD1zuGoaPY/jIBAhsNQNQbRPiFMpWWu8fschAMAJ9zy3XMpjbDMcJmyPw8SA7DUxGAwGg8FgMBiMzSHYOxYMRN1NmyW3W5xc6MalEDTLpPmTfvDbIV692TIYF7ECz2N3fIR2dBLBxFwhs+5zVdOAZdtVRQm/2LaNoq4hEpBIDr1D3cmGZeJ/nX6mrW5nG8F2mAAcR5Vci4Kq9Qiy4KoWUmDTLZPOzWOhGIoNujxbwaSRHJ0vMtuW6cZyoC8jOXiOx8Gk4zLRimAiIYeq5mfScZ9uYc4mcSohYfAEEzSSQ/bjMNFegeWTZ57Fzz/5sSrnAwBYLOUw3MTZYuO4Y7fZ+3bvs2tFFX7iPLrAVHQIc8UMzmUWcf/0YQDA+fQSji/O4O5P/QX+/eqZqsefXHUcDq4VKmKKvF7GsBKBxAtVQgp6/oP/SA7mMFHtMJF0hUUZtQTbtnHKdZgg3eN+xSiDRsQTnQFUhAz1BBMvp64jp6u4e3IfvW2HK5g44UacjHgcJgq6Ctuzzr7sFUy4ThbDQXSYcM9HROwWkysOE8UmDhMnU3OwbAsFXUNEUhASJZRN3Vcnt9mNmIgtBok+ARwB8nAoglXV6zBRRkxS8PaDd+L373wjHnvjryEuKXhm/lLd17NsC9fyq5iOOQ4TEVFG0ehSJEcA1uC1jIdj9P87okNUMJFRSyibev8IJmQFHLieCvpD7j4SieS4zxVMvLR8zYk/UgubG8nBs0gOBoPBYDAYDAaD0RrB3JVjUEihnXQxE8EEKSZ5XSb+5odP4ROnn2n4Wrbfgmcfdh53glvHdtKczv5XFawAACAASURBVDOucKKZDTaBFNLaieTQLBOGbSEq+i/+bVU6KZh4duEyfu/px/F0k26tRlCHCb8FowEkUdNx3wmcSB8fgitP4XJNgXJAIAU23TSx7M7Nu+IjKPrs4GyGSRwm+C47THg+m376nA66sRykMOSHpByGahq0g5Z0hqc9BY71IHblgXWY2GAkR1otwrJtXPeIEDNqCQvFLA4NT7T1mn6wfYkeGkVvOL/bmxwltSM6BNU0UDJ0vGb7ASTkEM5nlvClKycAAE/OnKSPXSnnseCuU67mK45YeV1FXFbWiIVajqRiDhPUMQhwog8Snu7ka4U0MlqZFuSA4DpMxCQFRY/DBIkoIIIGL6RwfPfkXnrbVDQJAHhpxelkJhEbMUmBYVtQTYOO5UvZZfq8VffvDAfQYUKpdZig135qlXjF+7lcyi7joc9+EE9cOYmioSIqylR44Udk70RyBHv7YU0khxLFqjvOVdOAZpmISyFMx0fw3pvvQ0iU8MqJPQ0dJuaLOWiWiV3xisNE0XWY6Libh+c8F5SoA+IwcfvYNDiOQ0JxBC9ZrQzVNPpGCBuTQj11lwAqa1ziMLE3MYrd8VG8tHINeV2FahoYC29GJIf7f+YwwWAwGAwGg8FgMFok2DsWDFpoXy45GzXkQjfuFpNyWmXD7NMXnscXL59o+FoWLJ9F5MHcbLllbAeuFdJYKuVwZtUVTPhwmCBF0KKhtSwIIJuYg1iEq6WTgglS8KzXubgeLReMBpCEHG47QqYRpu9NdM+cscmFyM2COExolonFUh6KIGJbOE7FVRuBRCKI3ShY2JYnhqA/uxAPDjnFdWJd7IeE2w1KXFXI/NHKd2CQHSYqgonGBUeSqa23aeGddzucvTFXxNHphqHuCSbo2G02huu5qsAT1bHJgqEdsSH68w1DE9ifHMf5zCK+NnsKAPCNa2fp2uuk624AANc8gomCriIqKUjWzPXk/NeKuI05THgdJpRKd7JWosf/oekb6WOCGlcQFeUqJ4MV112pXvzXM/MXsSc+iu2uSAIAtkXiEDje4zDhRnK41zkFQ6Vj+XohQwVwNJIjiA4TInGYqMSXAI5gwivQ9EalXMmlAABn0vPI6ypikoKQ6IxxP4IJ06c4dpCJewQTw0oEI6EoFQiRRoVaF6x7JvfhfGYJi8Ucapl1P5PpuOMwERZlFA0dlm/nthYIZCSHI2i7fXwXAFTN4X0VySErdK3VK8LuGne5nEfcdZ+5eXQKJ1auY9md00dDmyGY8MSH9dE1CIPBYDAYDAaDweh/grkrx6CQDZnlcq3DhFMg8jpMFHStqQ2/Zdv+upb7tJC2UW5xM2a/ePkEim6ur7e40whv51auxa59YpkbbcFefqvSScFEXqvOs24FJpgAkko3HCYsnw413g3awZk/vMhUMGFguZTDeDiGiCSj1AGHCTLfENvcTmJbJp3T+zV66WByHECrkRykI9wZ8zSSoyXBhPPZDaK4jQh8RppsghOBTrsOE2Qt4nWYOJteBAAccl1DusP6Y5cKI2qLR2Tc98BhgnBwaBsOJMdxfHEGFzJLODI8idn8Ki66HfakYC9wPK561is5XUVcUpBUwlUOEyTSx0/8GjkedsAdJiSvw4SkIOkKsNJqCS+nroMDh4d2VQQTQV1b+I3ksGwLzy5crnKXABxR1kQkjvOZJQDVDhOAIwLIaCWMhqKwYWMm7xSZiYNFs/lrUKEOE+45rsphwvA4THg+l3l3Dr6STdFIQCIELJvrr1GcSI5gbz/EPILNISWMEcWJ5LBsizYqxOVqUSeJn3l2YW0sx4wrmNgV8zhM6CpsdMFhouqc2D9ru25yeHgSD04fwY/tuRlARXCb0UgkR3+s6+J94DChCCI4t3mGRG/cPLoDM/kULmaWq27vJtTZLuBzDYPBYDAYDAaDwWgddhURcCqRHE4XM8kZj3s2zQh5Xa36vRbLtulFclMGNJLj5tEd4MDhU+ePAwDumtyLxVJu3QKRd4PYW5jwAyl+RrpQ/Ow3OiqYcI/5ah2r5/WwQLpWglnUAJwCctbnWLVsy1eh328kx6AKrrxUR3LkMR6OIyxIVeKqdiH24yNN3ADaxrYadNX3z+d0w/AkgOZuCLUQhwkyP+eocML/fE0KSd0QqvSaqKTgw69/J3724CsaPoZ0PRpNxAPHF2cauqiQObvWYSIsSlWOCh3Hl/14AxcKX3EenWfKPR4TkQSSShj7k9vo+PuTu38cAPDU1TMAgJdTc5iMJLA7PoJrroU2UOMw4RnndiuCQTIXBN1hoiaSgxRCs1oZJ1Nz2JsYxQ2eWJmgFpOjokKL9E7WfREix6NoaFVriFOpeWS0Ei0ge5mKDlFRK4nYIILijFpCXldx29g0AOCSW7xLlZ2/Ew+A8LgWUugl50OJF6AIouMwoWu0k97r/DHvRvhcya2gYGiIikpdwcQnTz+LD7/0zTV/03E9COYYJxBhSlIOQ+QFjISiMG0LWa1M1xe14/Hm0SlERbluLMdMPgUOHHYQwYQkQXOvlzouwPKewwd0DV5LVFLwsQfeg33JMQCAwDvzRSWSoz8cJqZjwzQ+pFdwHEeFwWPhimACcNytAGBsEwQTdGzyPPrpGoTBYDAYDAaDwWD0P8HesWAg6hZvajM4YzJxmKhsXhZ0FfkmXeX+N8EG88I1Jik4kBzHi8tXAQD3TR2CZdtYLOWbPs9bBG015oCILaLS4BXhapEEsfOCCbd43AqWWwTyFz8zmCTkEAqG5qtb/K9ffAqve+z968bvmD7nD9se/M3a6kiOHMZDxGFi44KJlFpwMse74XRgWfUjDProc9qTGMXHH/gF/MS+W30/J1njMEHEQmnV//xBHSb6ZGO907x57y1NuwZFvrnDREYt4W1f+jv85Q+erHt/RTDhdZhYwKGhie4W3/zYj1sNojeo28rmOkwMyWGERYlGlRxwXVUOD0/insl9OJAcp4WLk6k53DiyHTtiQ7jmEaMQq/2kUonkuJRdxtNusc7P+c92P+ugO0wIPE9FEFHJsUwfC8Xwr2e/j6fnL+HGke2YjCToY4IaVxCVKpEcOV2FbpnYkxgFAKy6LhNlQ8e/nP0+ACeioBbirhIWJYSpY55TeCZzx23jjhvcpewKAOecOBKKBlIESwq9Q0qY3haTFNdhQqPW+V63iQUqmEi5wqrKeqJsVL7rn730IhWQezEty58b4QBDxiRxNRl2/58qF6mTY6zGYULkBdy5bTeOLV5Z83qzuVVMRhLUMcQrou+0AMtGf67tNhtybiwb/eMw8R9v/RE8/mPv7fXboOOPzB83j04BqAgmNiWSgzY38AMV/8pgMBgMBoPBYDC6DxNMBBxZEGn3m3eDhXS2EGtQzTJh2BZy6zhM+Os6tAHyuAG7iL1lzOmi2BkbwkHXJnzOU+Cph7dzrtWYAyK2CA9g13ItEs9DNzsrmEi36OgBsEgOoGJHu16EjG3bePTcMcwXs1haRzhko4X5w/OsQUQWXMGEaWC5nMdYOO5YLBv6hjf+UuVC16zHbdus31XfZ/P8/dOHW4oxSihuR7hbOM624TBB5vlBdJjwA3WYaCAemMmlYNoWPn3x+bqiCjJnz9VEchxMdjOOA9UiiUbjmERPNHKY2OTxz3Ec3n3D3fjpA47jB1mLPDh9BABw345DeHr+IlLlAs6nF3F0ZAo7okO4lq8VTISow8RSKYfXf/qv8EfPfQECx2Mymlz/jTCHCQqZ04mr24ff8E5si8SRVou4bWwaIi/QYn9Qu+8jokLXtCtu1v0B9/u9Ui7gVGoer3ns/fj46afx8K6jdZ1ltrvjksRxABWHCSII2hUfxbASweWcI5hYLRcx3A3HpS1ArcME4BFM6CricghhUaLxf0DFYWKxlMNSKY+opFDhhddhoqCrWK0jKjTtbsREbC2oYMI97mT8raoFeq6r53gyEUnUPaaz+RR2xYfp797r+Y5fq1S5Lm2uGLCfIE57qmkgJPaHEDYkSi25p3UL6jDhimiHQ1HsjA3hkhsFtinxR2SccsxhgsFgMBgMBoPBYLRGsHcsGACAiLspE/G4FJB8VZIbTpwMioYGs4Gltl/BhNOdwtHfBolbxpzOtcPDk3Tjds7TtVkPr8OE35iD2udGA1CEk3gBhm11pFOEjOv2HCacvx/kDV/aca83F0w8vzyLWdfmfdbNC2+EafnMtfZs0A5q1xBxmCibOlbKBYyHYwiLEmzYUDfYrZ0qF7u3WWlZlc9ngIQtiRqHCSKUyKgl32OQRnIMqMPEeogccZhoIJhw54elUh7fvHZuzf15rTqSI6OWsFDM4pAnyqAb+OmmrR9D43luD4pKf/iqH8Nb998GANiXGMN/e83b8KtHXwsAePOeW6CZJh75/N/CsC3cOLIdO2PDWCzlUHaFPY5gQkZSDiOrlXF8cQambeFD974dL77jD3Cru9ZpivtZB91hAqjEcsREZ719z+Q+fOGR38BX3/If8QtH7gEATLsFT6HHGfS9IibJUE0DumUi5a7NDrlinxW1gM9cfB6pcgGP/ugv4//9kXfVfQ0iOvGe46jDhCsIGpLD2JMYpcW7VbV7IsJ+hxR6ax0mCrqKoqEhKspuVEq1YIJc6y2X81WOVWWPADyvq1gtF6vOkbZt+xfHDjACzyMsSnTcEeFEqlygjQnkOtxL1P1sapnJrWI6NkJ/D3fRYaKfxbCbCRETlk2jbxwm+oXaSA4AuGnEaSiJS0p3HO5q8QomAjxOGQwGg8FgMBgMRusEc1eOUQUptlc5TMiuw4S7MZP3bNCQjbPvXj+Pl5av0c0wCzY4PzEFtu1mSmLgLmJvHXWKCDcMeQQTxeYOE1WRHK06TLhdX610S29VZN7Z2CWxHGVDx9dnT7f1WjSSowVLfQIRTATRvpmQIBnsavPx+vlLP6Q/X8mtI5hoxaGm8sv6j9+CyG5RfaGYhWXbGA/H6QZ4vViOv/nhN/C+Y1+u+1q2bePrs6epw0FKLXSvm9a2gDpF4q0ubEm6450IJYhwwrCtqkLSS8vX8MEXvk5FhWVDpy4sJUNHSJACO2+sF8kxm3OEVQk5VNfGndiUXy9kYNs2zqYXAIDGTnQNP/NNIyeJuuKhzYfjOLzz0Kuo7fudE7vx0ft/HkvlHAA4kRxuofl6IQPTslA0NOowYdoWvjt3AQLH4+HdR313sJJIDuYwUZnTvfFpHMfhxpEpWjyajjmCiaDGfZF1bFHXkCIOE65gIlUu4Fx6EfsSY3jN1IGG8+gUcZioI5ggDhNJOYy9iTEqmEgxh4mGDhNRSUFUkquuU+aLGRwdmaK/RySFRjrWOkwYtlV1/Wi6c2KQBceEsVAME5EEgMp4XSkXaPQluQ734nw2WtWaaq6QwXwxi/1u9BJQE8nR6fiTAKzB/ZCQQ8hoZZRNnUahMBzCNZEcQCWWo1l0W2dxr9V5JphgMBgMBoPBYDAYrcF2LBh0AzfsUfyHBAkCx9ONm4LHjjWvlVE2dLzzq/+IN37+Q3jg8Q/gYmYJtm35y162bXDcYAombh7bgQenj+CNu49iSA4jJEjrRnJ4rW5bdZggxbpIABwmSMGNCCb+1+ln8J6v/RPd9G4FGsnRhmCCbFQGuUMuoZCO+8bj1bItfP7SD3Hv1EEAjuV+I1rqOvR2azfoVt/qkG7kF5evAQB2xUfod7zo6eAEnO/Dh1/6Jr50+UTd1zq2eAXv+do/4YuXHfHKahcdJmzLhG3ViyfY2vN8SJAg8QIVSnijkzJuTMfxxRn8zBP/gPc//yReWJ4FAPze04/j7V/5CACgbGhV59igQSM5GnxnZ/MpJOUQfnL/HfjqzMk1c3NBV6EIIoqGhoxWwtn0IoBK3ETXqOmOrv8Yq/r/tc/tw3XOQ7tuxONvei/+6FWPYF9ijMYbXC+k6boiJilIunP9t66fw+HhidbGsM0cJgjENSjSRNxKBBO+1tEDCHG5KxgaVsoFAKCRO6lywYngWef7PkUcJjwCAHKNQwUTShgHkuO4Xsggp5WRCrLDhFvoHZK9x8sRTBQNHRFJRkSUqauBbplYLhVw18SeyuNFuSKYqHGYAKqFySZzaKP84/3vwe/c/gAAYDKSAAcOVwvpdR0mTNtC2TOnfur8cdiw8cjem+ltXsfIjkf8eM9nAY7kGFLCyKhuJAdzmKiCHI8xjzjiZteVanSz5lrqMCFgq1+DMBgMBoPBYDAYjM2F7VgwaFeX18KT4zjEJIVu3HgtQHO6irRWgmlbuG/qIM6kF/C9+Yv+O8Rhu5mSNXbXA4AiiPjYA+/BbePT4DgOU9EkrnsEE7Ztr4k0KVQ5TLQomHA/F+/m2KBCCg6aK5j42uwpAKg6vn7ZkMMEmGCi0nFf7TDhjYs4tjiD+WIWP3XgDkxEEk0jOVqJORmkQnwjJNdN5YmZl6EIIu6Z3EsLlbUOE9+bu4CMVqKZ77U8ceVlAMBV1448pRaqikkdpcphYnBsmzmOQ0IOUYGQVyiUVou4nF3Bz331oxgJRcFzHJ66dhaaaeDLV05Q54SyqQdbMEEiORoUWIil+E/suw2aZeI718/T+1TTgGaZtIP2eiGDs+kFhEUJO91Cf/dYvzhkN3KScH/v15z3o6NT+OWjrwXHcdjpFuuv5lfp+TEqKTR+6UJmCbeNTbf2BzxCEntAxW1+IQ5ZzeLTpuOOpT4f0EiOqEgcJlSk3LXZ3uQYBI7H9UIas/nUuoIJIvxpFsmRlMPUIeFE6jpW1WL3zol9zrZIAjIvYCISp7fFpZAjmNBVREUFUUmhDhNLxRxs2Dg4NEFdOaKSJ5LDXQNaHvcl7zrbcueEIK+fCUdGJjEedo67LIjYHk1gNpdCXi9D5Pi68V1kLJNrP8u28Oi5Y7hnch/2Jsbo4yIskqPrJOQwsloJZUMPbNRaI8j4G/VEchCHCW9MRzeh14rMYYLBYDAYDAaDwWC0SDB35RhVkE3KSE0xx7H+dAqieaMimMjrZdr9+cjeW5zbNBVWK5b6A+owUcv2aLLKYeIfT30Pr33s/VVF35KhgQOHESVa1bnsB2KzHwSHCWJpbVgmsloZzy1cBuDEFrQKKQhltfIaAct6aKYj2AhqFyjgbBQC1YXj5xYu48gn/wuOL15xf78EALh/52Hsjo80jeQwW9lE9xYfB3T+kAVHHLRQzOK12w8gLMoeh4lqwQRxlsjpalV3J+BsGD4xcxKAkzuumgbyutq9blrb8rh+DNam+pASoUW8rFbGhFvoSGslPDN/EXldxUfvfzduH5vGN66exXMLl5HTVWS1EmzbppEcQaVeJMfJ1Bx1npnNp7ArPkIFEGm1MreQ4tAhN35jrpDBD5ZmcHh4svPds7X4Ef40Oof0SSSHH7ZHk7TDmaz74h6HCQC4dXxnS69pe+NXGkSxBAUypzdbq71qYg+OjmzHPk/hM0gQJ4i8rmKlXIAiiIiKMoaVCL6/eAWWbdM5oBHDSgT37TiEeyb30dtEXoAiiFgsOaLCpBLGUbd49/TcRVi2HViHiTfuOorv/NT/U/Xvj0oKCrqKgqEhIkquw4Sz7phz19uTkQT2JEbp40nBmERyeJ2wvIIJIoTb0XWh29ZjV3wEM7kUcpqKmByqGzsT83xHAODp+Uu4kkvh7YdeWfW4sGet0fFrFT+uSwEgKYdRMDSUTZ0KhhgORBzsdZgYD8dxaGhbVXRMdyHxmUwwwWAwGAwGg8FgMFqDCSYYnkiO6o3cmKQgp9V3mCA25FPuJntOL8PyRm00xXYU/wFgeySJuWJFMPGDpRnMejo4AacAGhElJJVw6w4ThgqR46mF/yBDIzlME9++fo52Ki8Wcy2/Fjn+NuyWY1CuFZyO8e3R4G74VgQTTmHNtCz8wTOfhWaZeGH5KgDgcnYF4+EYkkoY07HhppEcxGHCV/FzgJwLGkG6kQHggenDAFBXMGFaFnWhABzbci9n0gu4klsB4OSOk8LFiNK9SI66DhMD4AQyEY5TcVZWK9Nu8IxawrVCGhw47EuM4fU7D+HF5at49NwxAI6jQtnUUTKC7TAh1HGY+E/f/t/43e8+Bsu2MJtfxXR8BHHXhjynV8SD5Ocb3GLpcwuX8fzSLH50143df+O2DdCCU6NxXL+ARH/uU4cJL5LbZX5tjcNExRa+bYcJ1IgnAojMiwiLEoQma9+dsWF85S2/iYlIYhPfWf9AznEFQ0OqnMdoKAqO4zAaiuKHbjzVeg4THMfhnx/6JTy8+2jV7VFRgQ0bYVGCIoiYCMcxForh29fPAQCGAyqYEHgeU9Fk1W0xSUZWK6Oga4hKSlUkx7x7PTMZSWB33BVMiErFYcIVSnivcVbLzrrDtm385fNPYnd8FD+2pxIfwXDYFRvBTH4Veb2MRJ04DqDiCEk+j389+30k5BDetPumqsd1M5IjCC5vfkh4zo0Kc5ioggomwtXz6hce+Q/43Tse2pw3QSM5uIFzM2UwGAwGg8FgMBjdJRhVa0ZTyCZlbedbXA7RTS+vYCKvq9RhYliJICY5m2k2bPDw0yGOirBiQAuehO3RJBaKOepiQIrGS6WKfX5R1xCRZMfyXW3NYYI8t14n0qAheyI5/v3qaSTlEMKihIWSU8SsF3fSiLyu0g2uVmM5LmaWASCwXaCAs6HOgUPWLWT+69nv42RqDgBwKescn8u5Fbqhvis+grlCFlqDLPuKYMJnpA/9aTDnD8kjgLp/pyOYqERy6Di2cAW/9LWP433Hn8BKuYBH3OLDck0sx1euvAwOHG4Z3YG5QoYKKoZD3YvkqMQPDJawZSKSwEIxC9t2RFbTboRBWivieiGNbZE4ZEHE63fcABs2PnPxBXDu+TCjld1IjsF3AmoEx3EQOb7KYWK5lMexxSu4mk9DNQ3sig0jLErgOa6q4EbWH3sToxA5Hp888ywA4M2uw1V38eGI1dD1pp54qH/ZGRvGtXyaHu+4HKKRHGFRwqF1itW1VEWRWPXn/qAgCQJ1c2PUhxSDi67DxKjbnTwcisC0LQgcXxU70AokyoCMZ47jcHRkO55fmgWAwEZy1CMqKSibOmzYiIgyopJMhZrzxGEimsBuVzQYlWTqnkQcJrzXjKuqs+748pWX8XJqDr912/1VaxyGw3R8GAvFLJbLBcTk+nMFGcfUYWLuAh6YPrJGjBmuiuTo9PWh53wW4KilpGfOYIKJasKiDJ7jMCRXz6sRSd7E7z4RTDCHCQaDwWAwGAwGg9EaTDDBoBsw9SI5SGent3iR18rUCWFIiSAmhZDTnUgOgV9/Y8b2RnIMaMGTsD2ahGlbWCw5Lggkz36pVHFFcBwmZCTdPNRWKLjPDQKS23WvWQaeunoW9+04hMlIknZ9f+DFr+Ohz37Ql0VsQVdpZnurgolL2WWERQmTAe0CBZyOtbisIKs6+b3/7Qdfxd2Te3HTyBQuZR1HgyvZFPa4gond8RHYsHHVzRCvxXLnAV8buwGI5JBc+/YbR7ZjyrWuDnscJr4ycxJfnT2Fvz/xLYRFCT994BUAgOUah4mvzJzEHePTuHl0B+aLWay693fLfty2rMpnMmBOIEQwUTQ0GLaFXR6Hiav5NHa4jjO3jO6g2e73TO4FAOS0cuAjOQDHGt9wCyy2bSOtFqGaBj5/6YcAgOn4CDiOc+PAPK5WrtNVQg5jIpJARivh1rGdVJDVTWzbBkc2+BuMY7uqaOQd9+TfujWKSrviI7iYXabHOybJtCh08+gOiK0WOjziGLuBWC4oyLxI3dwY9SHXIo7DRJGKGIhwYnd8pO3CJDn2RDABAEdHp6jjTVAjOeoR97gbRCXFjehwBROFLGRewIgSxV4SySHKaxwmcp54QbLG/usX/x37k+P4iX23bsq/Y6sxHXPWFKdTc4hL9QUT0RrBRForYZsbD+bFez0vdDq2ijlMAECV+1LQ13a13LltNx6avrGpo1LXIeOU5xHkccpgMBgMBoPBYDBahwkmGIi4GzC13a9xqeIw4bWBdxwmnMJ+Ug4jLjvFDdO2/DlMwGNxPQCFtGaQItpMLoWCrtIO8FrBRFh0HCa8kRwLxSwe+uwHcS692PD1SwESTJBIjheWZrFYyuFHdh7GRKRik398cQZn0guYza82fR3LtpD3CCbIWPbLxewy9ibGAuHq0YyEHEJWK+NybgUptYB33XAX9ibGcDm7gpKhY66Ywe6EswFMNoJn8vVjOYgziJ+N3SDYAYcFCTIv4CFP5AD5npcMDYulLHZEh/D5R34Djz78K5iOO2N5xeNcU9BV/HDlGt6w8wZMRhNYKRdo/ni3IjlgmZ4i8WA5gUxGEtAsE1dcl6DtkSQEjkdaLeFaPo2drrBF4Hncu+MgAOBt+28HAGS1EkqGFuhIDgCQ+IrDRMnQobk/f+r8cQDALndOdgQTlYIbWYfEZIXax795z2a4S8AZz65QoLHwoUHHbT3xUB9ziyusupBZAuAU52KSjKgo485tu1t/QYs5TBAUQQzMWq1daCSHriFVLlARw6j7//XiOJpBxBhDSkUwcdPIFP2ZOUxUiHqK9VFRRkSsOEwslLKYiCTAcRxePbkf90zuw5GR7ZB4AQLHo+wKo6odJorQTAMvp+bw5r23tC68CghEhLlQyiHWIJIj5onkKBs6VNOoEgERvHMN3/Gi9WCJYdsl4TnuzGGimp86cAc+cv/P9/ZNuGOTYw4TDAaDwWAwGAwGo0XYFR4DUXdjpVYwEZMV2iWU11XwHAfLtpHTyzAsCzzHIS4riEkh5LUyLNv2V0QOkMPE4eFJAMCZ9ELV5spiHYeJhBxG1tOV9fWrp3EyNYcXl6823CgmGcNBgERyPHX1LADg3qmDeOrqGby4fBUAcNl1Nnhu4TLdeKxH0e2A20UdJgoNH1uPS9kVHB3Z3tqbH0ASriPKVVegsis+gr2JUXzpyglcyjoFtz3xMXofUImkqcVyC5H+5g9vEW5rdG63NHMCfwAAIABJREFUSkiU8PlHfgP7k+P0Nm8kx1Ipj22ROG4fnwZQKU54IzlI7M+O6BDtoj29Og8AGOliJEdlY3KwNtWJowwRsCWVMIaUMNJqEXPFDB6OHqWP/e3bHsDrpw5hn/v5OZEcRuAFEwIv0LGY9ogDz7sFeiJii0sh6nIAeAQTkoKp6BCAK5sUx4Hq9UqjcdzQYYIIJrbGPHXHtl0AgG9dPwfA+Rx4jsfnHvkN7HAFQa3gFZgE3WHiLftureq6Z6yFRnIYKlbKeSqUIMKJQ0MTG37tWocJwjBzmKDEPNcUEcmJ5CibOkzLwnwhgwn3XDgVG8Kn3vir9LEhQaSRHPkawcT1QgY2bBplxViL97qlUSQHifXJGyq9XkzIa8UVsiA6EVi+GxlaIACiZT9455JQwNd2/QmL5GAwGAwGg8FgMBjtwQQTjIaRHEk5jIxWgm3byOsq4pICzTKR11SUTR0JOQye4xGTFGTdblDep2CCW68AMSBMRZNIyCGcXp2vinBY9nSCF3UNUWmtw8T35i4CQNVttThii2Bs1EhuB8+3rp/DweQ2bIvEHYeJUha6ZdLC/bHFK/ipA3c0fB1StNjRRiSHbpmYyaXwyJ6b2/1nDAzOeC3TmJldsRHsTYzBtC18+/p5AKAOExOROBRBrBJMFHUNsiBA5AU8duF59zV8bKYHZLPWW8wBKh2DRUPDYilH88PJfSFBqorkWHHFE6PhGN0uP5WaA+BEKXUD27YqxeEB+5xIkehsegGAM/6TchgXsktQTYO6CQHA/uQ49ifHqbjCieTQAm/b7DhMuIIJd96djCQwX3S6lknRYU0kh7u+iEkhvP3QnTg0tK2tAn57OOsV2/25/kM8wgDbpt83u+53oX+5aWQKiiDi2OIVAJUi8w3DbRaqvZEcAXeY+NmDd/b6LfQ9EdFxVvrnM8+hYGhUKEHcHzrhMJH0OEzsiY8iIsowLJMKxxnVgomopNAifdHQMF/M4sYGguGQKNFIjrzrSJGUw0iXi7jmrs93MsFEQ7aFY1AEEappVMWieCHRMgVdpRGO3jHtJSLJyGplf1F3reB1DxtQ0bIfvEIV5jDRf1CXO45FcjAYDAaDwWAwGIzWYJEcDETcDZhau+DRUBSqaaBgaCjqGiKi4nR+6irSWglDbndFTFJop4svwQQqHZv2FikktAvHcbhhaAKnV+dpsTgsSnUdJoaUMFTTQNnQYds2np67AKBSWKqH89xgOExI7pjJaCW8evt+AE4Rs2ToOJ2adzqpOA7fX7jc9HVIN/5UNAme41qK5JjNpWDaFvYlxtr7RwwQSY/DREiQMBqKYo+baf2Na44LyN648zvP8dgZG6bfAd0y8fDn/ho/8pn/gc9f+iH+7PgTeHD6CB6YPrL+H7brWN4HAK/DxGIxh3FPbjXHcRgLR6siOYjDxHgohsmIE2PwcmoOSTkEqVuW2JZZmdPtwXKYIIIJ4oYQl0MYUiI46YpQ6hXwyYZ6ViuhbDCHCYHjobtFdHJee3i348zhFUvVCibInB2XFLxu6iB+87b7N+st+3KYsBvNSe7PjaM8+gtZEHHTyBR0y4TMCxsvAnn/3QF3mGCsj8gL+Jv73kFFVSR+Z8oVozUq1PuhnsOEwPM4MjyJ4VA08BFrXqocJtxIDsBxjZgvZqvE314Uj8MEmbOnY8NYVYu4WkgDAI2uYqyFrJOB6s/AC7k9r6tUTJ+oE8kBVFwjOx3JUR2xtvXXdu3ijfdRAi6G7UtIJAfPHCYYDAaDwWAwGAxGazDBBIN2D9VGchA73JVyHnldRUxSaLZ4Wi3Rrpa4rNBOF4HzMaRsG+h4pmr/cmRkO06vzuNybgUxScG+xBgtZgJORETYjeQAnG7aC5klLLiiikyTgn5R16jgZdCRPMWbV2/fB6BSxHx24RIAJ6bjTHqhrmvEqdQ8SoZGC3GkQ7wVh4lLbuzHviQTTMSlELJaGTP5FKZjw+A4DntdIcmz85eQcAvKhF2xEVzILMG2bXzx8ku4mF3GYimH937jXxAWZfzFq9/mq2jhFVkNuuDKi8gLkHkBWa2ElFrANo9gAgBGQ7GqSI5lj8PEZDRBbxtWumg9bluobKAPlmCCHO9zrsNEUg67oiFHLFivEFQRTJRRMpnDhMQLMN1iKCn2PLzLEUxMV9mRh5DXK/EFOXfOjvbqXEcFRo0cJhoVkOp8F/qcV7ixHJ2I+rKZwwSjRd605yZ8422/jcfe+Gv48b23AgAenD6Czz3yf9KIu3ao5zABAO8+cg9+7tCr2n/DA0iVw4Qo02uM64U0ioaG7a6QpZaQIKFsON9zss7e6QomZvOr4MBhe6T+cxkO0zSWqv78K7pCtryuIeOuPZJ1IjmAShNENx0mBmFt1y4hQaLi4xBzmOhDKg4TQbpWZDAYDAaDwWAwGBsnOFVrRkOi1GGiupgzGooBAFbKBRR0FVFJQVwOOZ0taokWQ2Nu4RTw7zBBIzm2UCGhXQ4PTyKrlfHs/CXsio9gWziBJY/DRMl1mCDFtYxawvfmnTgORRCrst5rKRhqYKyEvV3x90zWF0z8zIFXAAB+sDhT9dzHL76ABz/7AfzTqafpRm5UUjCsRLBa9i+YuJh1usv3MocJJOQQcnoZV/Np2hU3GorS6J7d8dEqAcT904dxJr2AT50/jr8/8W3sT47jOz/5u3jXDXfhb+97O7ZF4o3+VDVV3dqDP394CYsyZtwIlFrBxFgohhVPJAeJ/RkLRTEkh2m3+GgXs9pt2wKIRfOAfU4hUcKQEsHFzDIAV3DlKb5NRdcKJsiGekYroWTogc+5Fjgeuk0cJpzz2t7EGH77tgfws+7cDTgFu5xW7TARFWXwfgSZHcT2diiiif14Q4cJ9/YtZFt+x7gjmGjU4dwSzGGC0QYiL+Cuyb2Q3XOWwPN0XLYLGc9DcnUc1U/uvx2/ffsDG3rtQSMmexwmJJleY5CYwJtGd9R9XkiUqhwmOHCYiiaxqjqRHBOROP1MGfXZ5QoHYw1EEIAzlqsiORo4TJBrel+NDK1Q7xwXQDiOo8eeOUz0ISySg8FgMBgMBoPBYLQJE0wwqDBipKaQRn5fLRdRMDRE3Y2zvK4irRarIjlUdzOcg88O8XUsrgeJI25X3KnVeUzHhrEtEqtxmNAQESXqMJHRyvje3AVsjyRxaGiiucOEoQfHYcItWh0ZnqRjc8ItGj87fxkRUcaDu45A4gU854nl+Oa1s/itb38KAHAll6KCibikYEiJIK2tFUw8OXMSj547tub2S9kVJOUwhpXImvuCRkJxuutnciuYjjuCCa/LxB43joPw7sN34a6JvfjP3/sMXlq5hl89+jqMhWP481e/FfftOOT/Dwe4uy0iyriSc1xOxsOxqvvGwlEqkgAcN4mkHIIsiOA4jsZy1M7zHcUyQTYm7QH8nCbCcRhugSAuhaglc1SU6xYtOI5DQg7Rz6XWxSloeB0mSCTHkBLGb9/+AF4zdYA+Lu46WRFyWrkzBfxWqdpwBxo7TFgNft56DhN3bNsNoPOCCeYwwegl0QYOE4y1VDtMKPTYfWfuPDhwuHVsZ93nhYSKYMJxJZQxEooir6u4nF35/9m792BJsrs+8N+TWXUffe/tx3T39Dx63tI80MwICQkka40lrAWFQMgseO0wBq0D78YuqzWxXrPGDnaXWEIb9joMa2PHru21NzB4AQNrWAMBwjaYNUggCRsEkpiRZqTRPHqmu6cf932r8vz2jzzn5Mm8mVmZWVV5M6u+nwipb92ue6c661RW1jm/8/25wloqdv9mXDBxeji5YMJ+NixqyZEkTMy6YGI52+LlsRsd1gcsBOoee/2mln6cEhERERFRPSyYILz14n34F+//L4/t4LpjLV4U9ltybK2sYfvoALeO9t1i0ZY3sVMpYUIk/gBrv15wj3kxwg9s3YELa1u4drADLRoigt1RnDBhY1VvHu7hY1eew7vufgRnV9fdwlKevdGhmxRbdMMgnpB6192PuO/daRImXj/cxYOnz2N9sIKnzt+Ln3jmE/hbv/tR/Ne//hP48x/9v/DGs3fi4dMX8PLuTbcQV5Yw8Q/+8P/DD37il47FeD536xoeOn2B/a6RxADfOjpITYQ/eDoulHjg9B2p+wcqwA/98W/DIAhxYW0T3/rIW5r9h4sWJ5fAqeEKvrT9OoBk7Fvn1zZx/WDHjdlr+zu44KVQ3G3actjz+lxonZzTF7B1iu3dvhoOsDYYuiKJy6YlTZ6t4Zprr7Tssc1hEGCkk4SJYRDmvn9tDFexMzpy42Z3dFS643Z+MgUTBeO4qDjIfb9HCRP3bJzBXadOz6RgItWSgwkTdIJcS46CxWVK2DaNQJxAaIuyP/nal/Do2TsLzw1r4QAH46Rgwl5jA8Afvv4KCyYqsMXHfspH1oZLmIg/y5ye0JKjWvJjHd57XI+KAefBFmAxYaJ7bCKYYsIEERERERHVxIIJglIKb7/04LEFH78lx97oCBvDVWwOV3HbFEyc8RImrKotOSbu2Fwgp1fWcK+Ja79/6zwurm9ipCPcOtzHQTSGQHBquOqO5z/93Mdx/WAXf/K+x3FmZb2wJcdIRzjS0dK05Lh74wwePn0BHzB9rYF47NnxZxMNfvAd34ynzt+Dv/t7v4Z/9eXP4ruf+hP4qff953jkzEW8snsLO6Mj97PnVk/hRk5Byks7N3HzcA/P3b6W+v5zt6/i4TNsxwGkd7Xd502EFyVMAMADW+fxk+/7i/gn7/3O5u0JFjC5oKr1cIi9cTx+81pyHOkI2yZB5drBDi54aRI2YeLc6pxbcsAuFPvPzWI8T7YFkF2gsItBee04rDOr63ht7zYAJkwMgxCRGSO26DKv0GRruAaBuLG+PTqhhAk74W7bQRWdb/wkBX+s29dDz8b/f/uV78W3P/bV0/8iv6CNCRN0gmxKwlkmTEy0Gg5cC7z1wdAVUBxGY7zl4n2FPxe35Ihf57umyN6+R+6Nj3B5s/h9kmJvuXg/Htw6j8e9QvuszeFq3BrzaN8Vb+ZZn1vCxPJeg2eddi05lrsYtpuYMEFERERERM3wEx4V2hisYDUc4PrBbrxbyPQQf21/G1oEZ81EmL8TptLEjIip+MfSfIh94o678NLuTdy3eQ67ZkHztf0dF6vvt+T41y9+Dm++cBnf+OCT+M1XvlDYkmPPLPwvS0uO0ytr+I1v/SvHvn/p1Gns3Lrqkg3efOEy/tk3fBeu7e9gNRxgyyxu3rNxBr/z6hddS45NE6mfTfAY6wgv794CEO+oe+TMRQDA/niEl3dv4eHTLJgA0rva0gUTNmHieMEEgKl7kUvR4uQS8F/rFzItOc6b29f2d1wbiEfPXnJ/b9MR5tqSwz43ohdyUj0pmIjP1bbI7d6ShaCt4Ro+u/MKgHjxaZmFKsDIa8lRtNvbXlNsm13KdvGtfWbc2oKJSi05csZ9z5JwZlIsAaSSNZgwQSfpLRfuw1ddvB9vOHPnST+UzlNKYWO4iqNojEAF2PCuO95Scv22Fg6PJ0x4iVaXN5gwMck9G2fw777te0vvszFYxeuHu6mNC3ns9WI444SJdKJSv97bZs0m7a0xYaJ73DhlwQQREREREdXDhAkqpJTCHasbeP1gF7vjePJra2XVRWrnteSo1KpABAiWJ2ECgNst9MDWHbh4Kt4Zfm1/2+2gPTVYSS1A/89f880IVBAnTBzu5Uba77qfPYmFpO64ZHbaP5hZoL+wvumKJYA4oeLW0T6u7m8jVAHWwgHOrZ7C7vgIR95izqt7224X9Cdf+5L7/hdvXweQJCgsO7/Hso0RBoD3PfAk/upbvwFvv/OB+fyHF3Ahviq7Y/DMyvqxHW02TeL6wQ4A4NrBrivIAryCidV5tuQwEfwimedmMZ6nuzIJEzaO+d6ShInTK2u4frALgJPqwyBA5Aom9l3RZZYtjtgxkePbJ1Qw4d53TYGnFC0O6aKe7sfb0ywTvyUHEyboJD185gJ+/pu+252zqdzmcMUVSvgpdpMTJuKCiWzCBFBeWEjV2YSJ20cHhe04AK8lRzDrqZ7lvQbPOsOEie6y7V+VwqJ8BiEiIiIionbwEx6VOr+2gVf3t3EYjbE5XMXAm3jJbcmBei05FqW3/STf8vBb8PrBXmpR/7X9HVc8cWqwgrXBEOfXNvB1lx/DV90Z7+I6u7qOsWjsjY9cpLC17xVbLLM7zSJmXgsI391mUfPZm69hc7gKpRTOmUXmG4d7bvf4izs3AMSTxJ/yCiaeN+05mDARs7vs1wdD3OG1edgcruK/efN75vcfLtrNvQTWzYL7pVNbx/7ugmmhdO1gByMd4ebhnmurBAB3bcQtOeaVMHF81+HiTapnEybsgn/ZQpC/oLH0CRNB4Aoubx3t545jICnCtO1ldk6qJYcZt5MSsaSo/YyfuLKMhAkTRH20MVh1iYG2UHN9MMSjZ4sTOtbCpGBiZ3SI+9c2Ui3ALm8yYWIWNoYrpmBiQsKEud5gS475YUuOLhMACoBamrkmIiIiIiKaDX7Co1Ln1zbw5e3XAcAUTITu7+xi0ZbXkiOokDAhfkuOJfHYuUv4X9/1nwAALppEhKv729gbxYv8Njr1ox/8ntSCpt0Nd/NwH9cPdvETz3wCf/kt78UwCF1rj40laclR5FLFgol7zILxMzdfdYtvdrf96wdewcTuTQDA+x54E372C/8eNw/3cHb1FJ4zBRMPnWHBBACcXo0XNe/bPFctWWZmFi+5oCp7nrDnEJ/fksMmGvgJE2+9eD/efOEynjx/73wenL84mk2YWJDJSnuOsDHMT5+/F3/xK96F91x+rPBnWDCRGAYh9k1k+83DvcLFN3t+3nUFE0fYHBbvpJ0f25JjQguxVMJE5nUAQDQLJoQJE0S9sbWyhmAUX9ethgOEKsDT5y+nPgNmrYUD15JjdxQXefsJE5eZMDETm6ZN1e2jg1SxcpYtdKm2kaEG732wMHVpSXzLI1+JrZVVrLBgonv8hIkF+QxCRERERETtWK5Va6rtjrUNt+P+1HAltcvTLub7CxlVCib8hIll/BB7emUNq+EAr+1vu7YadmLr0qnTGPpFKSvxZOOtoz38y+d/Hz/y+7+GX3nhMwCQauexzN573+P44ENvxl0bp0vvd/epuGDiyt5tN44v2EXmg213v5fMeP/mh94MAPjdq18GADx/+yruXN86mZ3OHWR3VrW9a1AK4+8Xn32t5xVM2OKfawc7uL4ft+XwEybu2TiDX/zAh13h0Mz58fuiU7vuZUEKW7IJE2uDIX7gaz6QWhTKOu3tAF32lhwDFbqECVuIlscWYW6PDiAi2Dk62YQJd71SNI6LUm/c14sx/utKt+SIiu9IRJ3y+Lm78JhpJaiUwqNn78R773u89GfilhxxYdSOacmxPhhiNRzg/NqG+5xD09kYrmJ3dISbh3uucDlP0pJj1gXNy1u0nPX4ubvw4afnmKhHU4gLJhRbchARERERUU0siadS59c2cGQmujcHq6nYSbvY4S9kVNppbqv+4xsze6x9oZTCxfVNXNvfcW01NgomEm1Ryo3DfVe48qOf/Ri+6cGnsDsyBRNLnjDxzrsexjvvenji/e46lRRU2DFrF55fMwvMAPDizk2cX9vAO+96GKEK8KnXvoSvu/wYnr99HQ+xHYezZY7hfa3HLOdE3i8Jm1BwKadgYiUc4MzKOq7t7+LqQTye/YSJeTtWyLKACRMX1zcxUEFpgUTWViphYrnP1YMgQKQ1xjrC9ugQZ1fz48Rt+6mdo0McRmOMRaeSrNpjWnLYIsaicZyTKpH6/pKdpxy25CDqpb/xx74ldfujH/yeiT+zMVjBSEc4GI+wOz7ExiBufXd29VTq+pumszlchUBwZe82zpa25IivN9iSg5ZRfC0Wt+TgOCUiIiIiojqYMEGl/B3KG8NVbHqLP7Z36oZXMFFpYkbKEyaOrjyLL//N90If7Bz7u0VxYW3LtOQoL3o4ZxaUbh3u48umYOJjV57DH9141RVbLHvCRFVrgyHOm3YnLmFizbYxSBImXty5gcub53BquIInz9+Dj195DgDw3K1reOh0eduPZTIIQnzfV30D/swb39buf1gXLE4ugbKECSBOTHlt/zau5SRMzJ1k2hIs4KT6MAjxY1//F/AXnvhjlX/mDFtyOIMgwEhHuH10AACF/de3TGrV9ugAO6Ytx4m05MgmTBQUPqTPQznjfkHGf23+8WJLDqLeUm6ndrH7TVu8z996DYfRGJvmc80bzlzEk3fcM/fHuCzs55fDaJxKsMqy1xth5nnTo0Pow90pHsHiXdvRAhKJz1lMmCAiIiIioppYMEGlzq0lO2k3vJYcq+HATcashgOXPFG1JYcqKZg4+OKnsP/ZX8Po+peme/Adduf6Jl7d357YVuOMaclx82gPL+3cxNdcegir4QD/9HMfc+08itIp6Lh7NuIeyrbI5/TKGlaCEFdTCRM3XJuJd939CD712gt4ZfcWrh3s4OEzF9t/0B324affg6cvXG75v7q8ccA2oeDiqfyCiSfP34PfvvJFvLp3O75fiwkT6ZYcgkV9nv74PW/EnQXHPw9bciQGKkQkGjcP9wCgsCWHPT/vjo68gokTeJ/LFEwUFmgVteSw435JEyb8lhxMmCBabI+ciRPYfu/aSwCS8/iPvvc/ww++45tP7HEtGn+TwumV4kJCu8FhGKTDRK/98+/DS3/7Gxv/93NTlIg6xyRMKCZMEBERERFRPSyYoFJ2Rz4Q72qxMfzZGFBbSBGgYkuOoKwnuPmeXtyJmIdOX8Dzt6/h5uE+gOKCCRtZftMkTDx94V584MGn8TOf/128thenIix7S4467tk4AwAu3j1uj7LlduSLCF7avYnLprDiT9zzRoxF4/9+5ncAAA+zJcfJK1ycXHy2SO3OgkKI993/Jrx+uItfeeEzWA0HqXZJ8yaptgQ6ff5esufJt8WECSdOmNC4Yd73igombBFmnDARp1GcRMKEHdOuJUdR4U82XSX5BeaPJR3/mgkTRMvCFhR/+npcMGGvP9YGQ6yE7AA6K/513ZmCtlYA8CcvP4aPvOODePTsnanvj2++jPGtK80fgPd+trTvbdR9rv2r4jglIiIiIqJaWDBBpY615DCLFtmFDvv9SZGtAFItOXI/xOrF7/v91ZcexGE0xsdMu4ei3vanBisYqADP3bqKg2iEy5vn8KEn3ond8ZFbxD81OIne7v1016m4YGLDO2YX1jdx1bR/uXawg8NojHs344KJt116EGvhEP/sj+Jj/RALJk6cLGCrh6psmsyd6/n9wN9z+TGsBCF+9+oLuLC2We18PCuZhWJZ0ISJuvyWHGssmMBYRy5hoqglBxCfo3dGh9h2CRMn8D53rCVHUcFE/jnJFREt8LVMGSZMEC2PzeEqLq1v4fevvehu0+ylEybKWnKs4ENPvPP4daCOpnxP4rUd9YAtmGBLDiIiIiIiqokFE1TKT5jYGKy6nfnZXS02eaJKSw5BUjBRdA9gsXeufPWlBwEAv/nKF6CgsFaw+0ophbOrp/AH118GANy3eQ5vuXgf3nzhMr68cwOBKv5ZOs4mTPgTuRfXN3F1P07reHHnJgC4lhyr4QDvuOshvLa/DQWFB7buaPkR0zGpid7FPUfk+fr7vwLf91XvwxvP5reG2Ryu4j+65w0A4kKgVvktOSCFi8jLZssUEw5UgKFLKlhOw2CA/fEIN4/ihIlzJbtjt1ZWsX10gN2TLJiw5xf7vBWM41S6Sl5/92Ud//5xYcIE0cJ7+MxFfO5GnF6wwYKJuUglTJS05CgiOpruPYnXdtQLpiUH2JKDiIiIiIjqYcEElboj05JjLRwiVMGxlhx2YiwsLYQwRKBUSUuOJdiVeW5tA4+dvYSDaISN4UrpTvAzq+v4o5uvAgAum+SDDz3+DgBxAkWru8h77h7TamPTm2S8sLbpWnK8tHMDQFIwAQBfe88bAQD3bp5Z+h3inbDEk7V3rG3gw0+/G0HJefYb7n8TgHhct0mOtSVgbDOQ7ABd9nYcAPCWi/fh9cNd/JsXPweguCUHEF9v7I4OsX108gkT7nql6JqksE2QHP/7ZeL/u5kwQQtm73P/Fld/8ntP+mF0yiNnLuLIFE8yYWI+0gUTxUWHhXSUvl6rK3UNvqTvbdR9JmFCKRZMEBERERFRPSyYoFJnVtYQqgAKCuuDIZRS2ByuHk+YWKmeMAHYvpLI/RDrFtcWfCLGpkycKmjHYZ1dWcfITEDeuxEv5H/goTfj7OopF9FP1dy9EbcySCdMbOH6wS606GMJEwDwtffGBRMPn87f1U8t83ctL/g5oomvv/8JKChcWN+YfOdZ0plF47yF4yW0tbIapwixYAIfeOhpnBqs4Bee/zQA4HTJ7tjN4Rq2R4f44vY1KCjcZdKB2mUTJia05MiO/cz3l7VgKNWSgwkTtGB2f++XcONXf+SkH0anPOy1rWPCxHz4nxnLWnIUEj3lAvLyFi1Tf4ida2JLDiIiIiIiqokFE1QqUAHuWDuVSkH4H97+fnzn4+9M3W/TxI5XSjsQKe8JLnaRYbEXQ7/mrocAxH1my9jilNMra+7r9cEQ3/uW/xjve+BN832QC+aNZ+/EqcEKHjmTFD9cXN9EJBo3Dvfwws7rOL2yllrIe+zsJbzxzJ146533n8RDpgxZ4oSJKi6ub+Ej7/wg/vxj72j1vyviLY5mJ+SX+HkKVIDN4QrWQxa3bQ5X8YGHnkYkGlvDVQxKWpRsDlexMzrEH1x/GQ+fuXCiCRP2ekUKJ93zi4OECRPJ11FUfD+iPhKdaUVF/rU1EybmYzYtOZq/J4le3rZ41CMiULYlBxERERERUQ2Dk34A1H13rG7gptp3t//so28/dp8tM4ETVPlgKgIVlLXkMN/Ti73I8NWX4oKJUxN2HtvYcj/1AAA+9MQ78+63x77OAAAgAElEQVROJc6vbeKz3/4DCIOkVuzi+hYA4Or+Dv7oxhU8evZS6meUUvjon/oeDKq0m6H5E07WTvKdj7dbLAEgZ5c9Cyas0yvrbMlh/LlH346fevaTpe04AGBzZRVfuHUVf3Cwi7fd+UBLjy5NjrXkyB/HqeLOvLSJZR3/fhoQEyZowcSFgRoiwtZ4xsNnkoQJFkzMx8YwKb7calAwAYkw3bWzVxS44J/TqcfES5hY1mswIiIiIiJqhCuANNH5tY2JE182YaJ6S47AfXn8r5djV+Y9G2dw/+YdE1ty2B6192UKJqgZv1gCAC6sbwIAXtvbxmdvXMFX3HH3sZ8ZBiEnxLuCyQXd5J+vj0U+L/fztLWyxpYcxlsv3o9Hz96J82ubpffbGq7hyt5tvLR7E0+ev6elR5dlW3KE6dtZRTtu7Wtiwa9liqRackQsmKAFY1/3TJlw7ts8h6E5X7Ilx3wEKsCpwQo2J6Q0FRGtpyt04LUd9YIAYEsOIiIiIiKqjwkTNNE3PPAmvLa3XXqfrZV4YiycQUsOWaJFhu9/+/snFpmcNW047t0428ZDWjoXzcLd719/EbePDvDEubtO+BFRORZMdJG/OAoRtk7xXFrfMpO2pJTCP/q678DhhAX0jeEqDqIRAOCp8/e28dCOM4tKyi5KFS0yeeM7f9wv6fj3jxcTJmjR2PaB0Rgq5MdpABgEIR7YugNf2n4dqzwmcxMXSzTc86I1ZpUwsezXdtRhNmECKn1dRkRERERENAFnM2ii7/qKd028j91JFFRoWyB+wUT+Pcz9Fr9g4v0PPjnxPi5hYosJE/NgEyb+7UvPAkBuwgR1iJ7P7rbR1ecRbl1EMGHnOxXw4/clOyG/3JOVf+td33rSD6FT/D73Rba83clvOumECVfsUjCOC3fcmmuZZY0t988JTJigBZMUdzNhwvfImYu4drB70g9joW0MV5sXpEg0XctLJkxQH7AlBxERERERNcSWHDQTdnGjWtsCgQqU+SrnQ6yLuV3SRYYM2+v9MltyzMWZlXWsBCE++dqXAACPMWGi02RO/ZNf+MjX4sav/PDMft/SSbXkkOJd90vons2zuGeTCUF12DZglzfP4px5D2ydHbcliVjxtzNj337pzk/LOf5TqTNMmKBF4yVMUOI7Hn8H/qsnv/akH8ZC2xyu4szKWqOfFR1Nl+Dovw/yczp1lJiWHApsyUFERERERPUwYYJmYnMYT9xMai8BYGJLjuSDLT/gAsAbzlzEMAjxxDkmH8yDUgoX1jfx8u4tPLB13i3UUUelJnpnd47QezcQ7d2c2e9bNumWHJmEiSUvmKD6tsxi0JN3nFA7DnjFWSb6vLDwp6Bgwr0GlnVRyU+Y0NyFTwvGFXezYML37nsfxbvvffSkH8ZC+/DT78aKbRVVl44wzbVzqmiZn9Opq5gwQUREREREDbFggmZia8W05EC1hAmgJOLaRu4vQUuOKr7y4n347Lf/ANYGw5N+KAvr4voWXt69hSeYLtF9MqeFeK2Xd2FzFkoSJlj8RnXZNl9PnVg7DrgxrJRdmKrQkiO3eGJJx79/LLioTAvGFgEVFQNd/effh42n3odTT7y7xUdFy+AbH3yq8c+K6OnS2eZ1DU40UxKnnrJggoiIiIiIamJLDpqJr7xwH/70G96Kpy9U2A0q4nZs5n2IlWXv+52DxRLzdWFtEwDwxB0smOi8OSVMiGgWaU3DO18fO5acrKSabBuOpy5cPrkHIemEicLzQ9FYt5H9S3pe8ReS2baAFo59XReM7Ru//EO49rPf3+IDIqpgyoSJwgJBoi4RuzmHLTmIiIiIiKgeFkzQTGytrOGH//h/irNVeo2LQJW15LATMJyIoZZcWI8LJr7iDrY96by5JUxEXNifQnqXraTbF/C4Uk3vuPQQ/o/3fDvefe8bT/BRmHFb2kIsXRAhea1olrX4M9WSgwUTtGBsQVROwoSIADrCwec/hsOXPtP2IyMqJDqa8j2J13bUA7b9KxMmiIiIiIioJhZM0AmQZAEir+rffrBlwQS15M71LQDAE+dYMNF1Mq/kAtFLuxN8JlLx+5otOWgqYRDgmx58CoE6wctU15KjvGCiOE1lyVtyaO/fzYQJWjT2dZ9XDOSdE27/xj9p6QERVTCrhAnFnfvUZRKPUaXShaxEREREREQTsGCCWifiF0zk3cHu2spfvLzx0b+Lm7/+j+bx0GhJve+BN+FDj78T92+dO+mHQpN4C5KzmgRL0hA4qdbYsVYp3vPE3V3UR64lRxjfLDo/FBQHuWuYJU2YEDE774OQCRO0cOzrOzdhwisQuv1bPwYZH7X2uIhKTV0cnCQv8dqOOkviggkFJkwQEREREVE9LJig9olABWUtOcoTJrY//hPY+cRPz+nB0TJ684XL+Mg7P3iyu5mpmmySwSx/55IubM5CatFIZH6tU4haYheVlCmYYMJETeZ8qgYrTJigxWNf93lj2xQIrT/xHkTb17D7e7/U4gMjKibTtp+zyUtByCRI6qy4mEexJQcREREREdXG1UE6AUnCRN7uFLfzpWAiRkQK0yeIaMHNo9WDLj/nUAXesYvP4WzJQX2X7KSNbxZck/jXIznFE8va6scWUalwhQkTtHhcGt7xsW3H/vojXwMAGL3+YnuPi6iMjqa61nWf21XAhWjqMIFSCgBbxxARERERUT0smKD22ar/+EbB36N4Ika06cFKRMtGCndzT/E7zfmE8cJTyD4vqYSJ5Vwwpp6TbMFEzYQJV/y5pOcVSRImhAkTtGDctUje5xEz3tVgtfg+RCdg6oQJsGCCesC05GDCBBERERER1cWCCToBApS25DC7tooW2URyewYT0RKYR8LEhFQbmizdkkOzJQf1n4set5fKReM4+b7kjftlPa94BRNgwgQtGl2WMGELJlbMbX5moY4QPd17EltyUC+wJQcRERERETXDgglqnwiUKlmAmLTIwIQJouU1h4SJ5HdyUq0xnX5eBCyYoL6rljCRbhHmFU/Yr5d0/LuWHEyYoEXkWnJUSJgQfmahjtDRdGlqXvKS8JqZusomTLAlBxERERER1cSCCWqdiJQuQMiE3d4imru1iJZWwW7uaX6ji9bmbrnGUoUs6YQJTqpTL9kxHITmZs2WHN75ZCnb/biEiVUmTNDCcZ9DcoqBkmIhtuSgbolbckyTMGF+NmBLDuowSRImlvL6i4iIiIiIGmPBBJ0Ar2Ai96/jD7ZStHgpwslHoiVVtJt7KpoJE9Pyi9hEhC05qP9s9Lgr8Cy5Jklu5H+9jK8Be7yYMEGLqCxhwrbkGLIlB3XMtAUT8FtyLOH7GvVEnDChFBMmiIiIiIioHhZMUPtEkp7geZMtExIm2JKDaJnl7+Ce7lfG55PCIi2aLJswseyLxdR7UrElR2rs64K0iSXs9e522YdDCBMmaNG4ZKqchAnXkmPF3IefWagbJJMAVv/n7ftiuJTva9QPImKKJRQ/gxARERERUS0smKD2+S05cqv+bd/v4t2cwn7ARMtpDgkTrlCCk7/NSeZ5yd4m6hsXPR7ab+TfzRvrkmoZVFA8UYM+3MXz3/cE9p/5d41+/kRpDagAKhzmti0g6jMpSZhwBUIhEyaoY8xYbNymwLWqCsBrO+osryUHCyaIiIiIiKgOFkzQCYhjEoH8CZuJi5dMmCBaYnNILhC25JhWKp1D6/jcbs7znKykXjrWkqNCwkRBKxppWIwV7VzH6MozOHz5M41+/kSJBoIAKhwwvYcWjx3Tphho99O/gt0/+GjqeyocxAVX/MxCXWHHYuPrMu99kZd21FWik88gHKhERERERFTD4KQfAC0hP2Eid8Im/l7RBHscJzqnx0ZE3TaP5AIXrc1Fvca81B+BJOd5icATNvWS20lbnjBRVCQxk+IutyjbvwVX0VG8qBYMctsWEPWaS5iIx/brv/A3AAAbT3590o4mGEAFIRMmqDPcWBSNRvtmXEuOoHlKBdHc2aJtJkwQEREREVE9TJigEyDJjs28BQj3wbZkcYKTj0RLSVK7tmfUksMufHBhv7lMwkQ8WTlhZz5Rp/nR48VFnIVFXP79G7f7sQWkPSw4EA0EIVQYQtiSgxaNfV+zLQ7GR8k4t6/XIGTCBHWLfS+auiVHyDZ21F1+Sw4iIiIiIqIaWDBBrZNJCROTdnuL5m4tomVVFH8/DXs+YcJEY5JdNJakMI67EKmXsi05CgqqUmO/MAGn2WvA/e4+XvOIjq/1aiZM3P74T+DqT//1OT4woum5QktTJCF6DIlGqe/ZlhwiPXz90kKyn5+btolKt+TgtR11lG0LWNICloiIiIiIKA8LJqh9Im7HZlnCROFkDhMmiJZXKv5+RgUOtlCCu+Wa88/JIpPP80QdJ170uPlG/h11QRGXFKRN1HsQ8R89TGgQHUEFIVQwqPX4d//DL2L74z85x0dGNAPuusG890XjpDDIJUwMoBQTJqhDXEuOpkV8fvISr+2om+LEQNOSA2BxDxERERERVcaCCToBXsJE3t9K+eKlMGGCaHnNIWEiKc7ihFpjx3bZSxzZDJQ+T4df/jRe+7G/VNzugOjEVCyY8M4b6ZZBOvfreg/BJkz0r2DCJUyEg1otRSQasXiNus8USqQTJuzX8d+5hAl+ZqEOEBGvJcd0CRNQbMlBHSYCpRSUa8nBz3dERERERFQNCyaofV5Ue35LDvM9JkwQUVbqnDGjCTAbrc1F+8bSi8My+Txv7H76V3DzX/99jG+9Mu+HSFSPbclhC3+Kzje6oA1HUdpEHdqem3p4zaPjggkVDOLd9xVJNOrnv5eWirtesC0OxqOchIkwPn9wPM/d0ZVn8fKPfCv00cFJP5TumsX1s3tfDNjmgLor05KDCRNERERERFQVCyaoffZDLAp6SrodlQUfbkUnEbhEtFSkYDf3dL+UCRNTS7Xk0PHzpKq05Ij/bnzjpbk9NKJm0gkTRQVVUph6M337IHu+62VLDjEtOWomTIAJE9QHrtAyKZKQaBR/z7xeVRAnTLBgYv72n/1N7Hzq5zC+8eJJP5Tu8sfhlG2ioAIuQlOHsSUHERERERE1MzjpB0DLaMJCmu3ZXZgwwZYcREuraDf3FNz5hAkTzWUXjUUqtDKAO+YsmKDOseeDSQkThakSMzhXSXoXe6+YhAk0SJhgwQR1Xua1KdE4KQa34z0cQLElRzumbjWx+PxxKI2vn/1CQi5CU0dlEyY4VomIiIiIqCImTFD7vISJ/JYc5ZNewpYcREtsBjH3x34lJ9qnldp9LzpuyRFMTpiwhXHjGy/P8dER1WcXlNw4LjrfZMd+8gu8b0+3m7dWQkNHiI6AIDALxnUKJsZcYKbOs+9dtjhCIq8lh0nBY8JEe1j4WoHMImEi/iNuNcNjTV1l55pKEk2JiIiIiIhyMGGCWicQqJKIRLfrhQkTRJSlM0kGM/ydzXfcUXpBSOAnCZVOVAoTJqij/Ojx+BsF98tPkpCZ9Is3v7uHLTkgOl5UCwf1WoowYYL6wF43uIX6MUTMe55tycGEifbYpA+eO4oVFffVIUyYoO6Lr79U+QYdIiIiIiKiHCyYoPalYhJzPsDaCZ2iD7dMmCBaWjLPhAnulmvMX6QQreNjWqUlh/m56CYTJqhjxCZMhKnbx+/mjf2ilhzTJkxID695zDlABYNk532VHxsf8VxM3ZfTksOl0djxHoTx//r4+u0b99mR544icqywtcHvsD8XBNy1T91l5poUW3IQEREREVFNLJig9tmqf5sycfwO5m5MmCCiDJl9wkRyruGEWmPZXfaCyTvzAfccsiUHdU86YaL4mqSgiGsGCRPS44QJ0VF87GomTEg06meBCC2VbEsO6DFEq9T3VDAAFBMm2iBsrTaZd15t3iYq/jml6rVaImqXTTNlwgQREREREdUTTL4L0ax5CRN5H2An7BIS0bV2KxLRArEJNZhhCw27mMGJ9uZ0eje9iCS7bUsmKoUtOairsi05ClOv8ltypNtzTLc41cuFKdOSo3bCRDRiwgR1n1ugtwkTo+R1av80LTmYitcCm/TBc0ehWSRMuPfBIOAiNHVXKs2UiIiIiIioOhZMUPsmtORwi6BFk14igAijQImWkeg44hqYecKEaJ5TmpJji8ZSrSWHZsEEdVWDgomilhxNz1X25/q44GpbctRNmBiPWLxG3ee14nB/2q/N36lgAARMmGiDsPB1skxhayOpQkJeM1NHHSuY4FglIiIiIqJqWDBB7fNacuQWPdjFy5KWHAD6uYBARNMRgarS6qEON3HMCbXGvPO1aG0mK6u05Ih/Th9sQ+9vz/EBEtVkrk9cUkrBOJaCIomi79d7CJnY/x5xLTlqJkwgYsEEdZ9LMrCfRfTYJUy412sQMmGiLcKCiUnSrY6aXu/a98WQCRPUYZn2rxyrRERERERUEQsm6AQkkfq5H2Dt9yb0C+eOLaLlI3NImEiKsDjR3lg26tkrbClLA/IL48Y3X57XoyOqzY3bSeebwiKJgq/rPYj4zz625NCmJUc4OHa9Fu3dKvyxuLUBr++o47x2OaKj+LWqo/gcYF6vNmGCBRMtsIkfLJgo5o3D5m2ikvdFHmvqrGzCBAsmiIiIiIioIhZMUOtEBEopqIKWHElfYCZMEFGGyPwKJpgw0Viqb7hoAN7zVJowkfwd23JQp5jzglJh6nbR/eKvi1pyNF2csouyPbzeER33uQ8GyUIygNG1L+ELH76I/c9/PP/HmDBBfWDHaDROJ8BEY0hkWnKEAyi25GhFkvjBc0chfxw2vH6253GlAi5CU2eJ25yjkttEREREREQVsGCCToAXk1iSMCEFk17Cggmi5SV68gJm7V/JKOepZReN/ZYcZZPqfsIECyaoS9xOWjPhXjSOU9cq+akSZSkr5Y8hWZTtG9uSQ4WD+BvmPDu+dQXQEcY3Xsz/uWgEiDQ/ZkRt8IuZvAQY0ePk84lNmBB+Xpk7tuSYSGZRxGff44o2PRB1gWn/qpgwQURERERENbFggtqXjUk89teTEibYkoNoaYnEu5YxxSLksd9pFz440d7YsZ2LAhVULJgwhRXjG2zJ0YbDlz6D0ev5i9XkswtDQfr2sXsVtd4oSJuo9RB6fL0jpiVHEBdM2F34Mj4yt0f5P2e/z4VP6rAk0SAnYcK25HAJExzL88bC1wpmkDDht+Rgmgd1lkkzZUsOIiIiIiKqiwUT1D5T9Q9VnjAxsV84d2wRLR3xFthntruNLTmm5u9cFNFxMUuF50lEQ62eQrB+hgkTLbnyD74D13/2+0/6YXSfZAomaiZMpAq6Gsef22Ku/iVMuGIolzBh/g2mIMIWThz7MVswwcU46jI/YcIr/pFolCTCBCGgQibitcEcY2HBRKFU4d2UCRNKBeA1M3WXl2bqbhMREREREU3Gggk6AX5fybwPsLZgggkTRJQhAhWE7uuZ/Er2vp5eaUuOkp/TGkoFGJy7B+ObTJhogz7Yhj7cO+mH0QNmYWjS+cYf+7og8nzKhIlet+QoSJhAQcKELZjgwid1mtcux0+YEO0lTJiWHPy80gLhddxE3jhs3ibKKyTkrn3qqmyaKccqERERERFVNHXBhFIqVEr9e6XUL5jbDymlflsp9Xml1E8ppVamf5i0UPwPsXkfYM1kV9Fkufs+JyCJlg8TJrrp2M5FMTsQMWGiMi6sGJy7hy05WiLRmLHlFcixhIkJ1yQobs/RePHf7mLvY6KWacmRTZiQyLTkGB8vmBCRpDiE13jUYeK9NlMJMNE4GbtBGLem4lieO7bkqGCWRXxBMLu2eEQzl23/yrFKRERERETVzCJh4nsAfNa7/TcB/LCIvAHADQDfNYP/Bi2c+AOsNEqY8GJwiWjJzD5hIlmU5ER7U+ljJ3HhWxCYWyXPk44LYAZn78X4JltytEIijvUqxCZMTCjQskWg3s8cu3/j3bzJLvbeMa9te75OEiZMgkRewoT/7+QYpS7T3mvTb8mhTeKECuJzBxMm2sGWHBOlW3I0vX72kpd4rKmrBEi15GBxDxERERERVTRVwYRS6jKAbwTwf5rbCsDXAfgZc5cfBfCnpvlv0GKxu1FUScLExHh8+zOcgCRaPlrHfcGBGbbkiJLfTc14xy4+h/stOYqfJxENKIVg4xz03q05P0gCzMI13z8rSCdMFO6m9VNv/PsUteeo8wh63IJMTMKEMgkTcixh4uj4z/gLz1yMoy4zqS+io3RLjsi05DDXKSoIeb5tARMmKjiWBFZfOnmJi9DUTZJpycE0FCIiIiIiqmrahIn/DcB/D8B+6j4P4KaI2JmjFwHcm/eDSqn/Qin1SaXUJ69evTrlw6DecBMtCgoFLTmYMEFEBcRLmJjZghpbckwv1TJAzGRlhdYpoqFUAKUCLpC2RbMlRyW24GFSgZZtPRHfSL49y4SJPl7vmIQJBKYlh0uYMAUTOQkTqe/18d9MSyMp7h5nWnKMgGjsCoXAgol2sPB1Iv9zc/M2UV7BBBehqbMEys41mdtERERERERVNC6YUEp9E4DXRORTTX5eRP6hiLxNRN528eLFpg+Desd+YPX7SmbvUhyPn9ohwAlIouWjC3ZzT/s7/T+pNvGPnUmYUFWeJ7s7XwVcxG+JRGMWp1TiRY97t4/fTfKLKlJfT7c4JX1sySEREHgtOeyisimKyE2Y8L/HMUpdZj+r5LXk0GMoUyikghAi/Lwyb1Ly2ZEM/9hM25KDBRPUZbZoO7ddGhERERERUbHBFD/7LgDfrJR6P4A1AKcB/B0AZ5VSA5MycRkAm5JTwkuYiPtK5nyAlZKECRZMEC05b3FyRjuG3EQ7dyA1lzpfS3yuDqsUTAhg+ryzYKUlOuKxriAdPY7CYybitwnKtOEwhUCN46B7nDAhWiMYBkCYTZgwi8s5CRPphWeOUeow77WZKmiyLY/suFdMmGgFW3JMNoOWHO56LghZnELdJYJ4c45/m4iIiIiIaLLGCRMi8tdE5LKIPAjgzwL4NyLy7QB+DcC3mbt9CMDPT/0oaXG4D6wmYSLnA6ybgClr1wFwxxbRMjItHOKvZzQB5s45nPxtLDsRX7Elh9iWHAFbcrRF2JKjmmzBRGHChIZStk1QJmEir5CizkPQtgVZHxMm4oIRu9Pe/htcS468hAm25KCecIWWmZYcuQkTHMvzx4KJiVLjcMqECbbkoG4Tb3OOuU1ERERERFRB44KJEn8VwF9WSn0ewHkA/3gO/w3qLS9hoqBgwkVQ5016pWLfOQFJtGzEX4Sc1QSYm2jnhFpT/vk6XjSWpJUBW3J0ikRj7t6vxIseB4pTIvyEidQ5SSa386j4GNDDlhyio/h1bXba2134tihCchImUt/j+YC6zBUzRanXp4xH8W372g+YMNEGVwzA97ZiM0iYsNcOKgjARWjqLJFkrsneJiIiIiIiqmCalhyOiPw6gF83Xz8H4Ktn8Xtp8dgFB2U+wOZG4Jfs9k4tynECkmj5pOLvZ9uSgwt0U8i2IvASJkrbEWhtJjVZMNEaHfFYV+GixyclTCC3OEi0d65quohnd7H3MVFLNFQQup32yCZMROUJE0ycoU6z4zMaZ5JRTMKEbcnBhIl2uHMlzxtFjhe2Nvot8R9ByOsI6jDbkqNkvomIiIiIiCjHPBImiIr5LTlQnjCRu8Dg358TkETLR8Tb8T2jyVq3U5STv00di3qu0ZIjSZiQKSbxqQrR2hS0cKxPZhOxygu03Bg+dp8kYaLxZL30N2HCteSwCRPmHGELJWR8PGECTJigvvCLmfyWHNE4/nziteTg55X5E7bkmGwGCROpz/G8XqOOEhGzOYcJE0REREREVA8LJqhlmZYcOYsIpbu9mTBBtNwKFyen/J3xF7P5fcsolTAhEAhUUGGi0hTAqGDGzynl46JSdTYRy43NgmPmJ0lkXgfuXNWwGMteD4nuX8GEa8mRSZhwRRETEia4yExdJqmECa9gQse3mTDRMr63TZQeh1MU8ZnP8Cxwpc4SMQETLJggIiIiIqJ6WDBB7ZKkYMJ9iC24T/7ucSZMEC01vy8tW3J0h7cgLJmWHKUT86LjlgdqwqI0zYRdeGeaSgXuesWOzaL76WRx1L+T3z6o6eKUfZ76eL1jW3LYhIko25LjeMKEnzrBaH3qNJuYoqP0WI7ilhw2mYYJEy1xzwfPG4X8cdj4OMWtDuKkNy5CU1eZlhw2YYJjlYiIiIiIKmLBBLWsSkuOksVLzYSJPtKHu3j57/8ZjK4+f9IPhXpOYBfi8xNqGnE7Ezmh1tTxnYtSLQnEb8lhb9P82OeJ758TuQX7oLwlR6r1hn8fSb7ffFybAtI+tuTQOjdhwhVMjCclTPBcQN0ktu0UEJ9L/YSJaARkEiYgPN/OG1tyVOCnNM4gYYLnaOosf5za20RERERERBWwYILa5SVMFO4Qd5OQxydiUjsOueDTGwfPfQI7n/gZ7H/+Yyf9UKjvtI7TaWaYMFFapEXV+LvptTbP0+SCificrtx9WQg3X26XP8f6ZLYlhx2bBQtMYgsDvJ8xNyoUW0x6DLYlR/9eF6IjIAiOJ0yYooi8hAmwJQf1gfd6FpsoYW/rMURHUKZQSCm25GgFr+MmklklTCi7c5+L0NRRYhImWDBBREREREQ1sWCC2uU+sJZMttgFgrxJr9TuTU5A9sXRq8/EX3DSmKYmXiLBbFtyMMp5CqLdAtGxhImy50lrqCCI23KY30NzZBf2eJwrMON2UtFDQesN0dpLnmh4vF0BaQ8TJmxLjqCgJceEhAkW9VBnZYq3Uwkw0Th+vfoJE7z2nTsmTFRwLAmsPrEL0UHARWjqLBGdFEvE3zmxx0JERERERP3Cgglqld2hqUoq/t0uzrJ2HejnjstlNbryLACkduERNWImwZRS6fj7abhCCU6oNSY6WSDSJq7cFEGUP0+2AMZLp6C54aJSDS4Ra0IxT0Ii+4kAACAASURBVKr1RiZhQk2XMOGKufrYksO22wnzW3Ig59+USp3gGKWuSn0WGaeSUUSPIdHYnRNUwISJVphjzMLXYqlxOEURnzIJEyxqo+7yk1AmfQ4hIiIiIiJKsGCC2pVpyZH7AVaXxap69+cEZG8cXYkTJnq56EPdIjALmGp2C2r2PMTJ38biCHKzmx4Sn9srtOSwi6rKFVfwOZgnV7TGRaUKTIFnUD6OxU+Y8MeviPezDY+3fZ56eL0jOjKv7XTChF1cnpQw0cd/My2H1KK8jtLFwNEoHrsBEybaJMJiwIlShT5TtOTAjNviEc2aCJTfkoMF8UREREREVBELJqhdfksOVdT/tHjx0p/g4Y6t/jgyCROcNKZpieh4d9sMJ2uTXfecUGtMdLJAJBqAQFVoySFax/ebtIufZsO2RWBLq8myCRNF41g0lLKtNyT1/dxCinoPwvx4D4sNTUuOYwkTkWnJ4RdHWGzJQX2QSZjwi4ElMgkTXksOfl5pQWmxPQGYSUsOSLxzXxW11STqAjtOSxJNiYiIiIiI8rBgglrmJUygYMHTfC93stz/HtMKekGiMUZXvxB/zUljmpZNLpjl7jYbe8+J9ua0ThaIxLbkqNCOwPYZZsFEK5gwUZ0ca8lRXDDhxrq3gBSnrOQUUtR6EOZ56uP1TkHChIxLEibGbMlBPSDphAn/9Sl6DEiSMKGYMNEOUwTI67hiqc9gTa8BzEI0goCL0NRhJgkFLJggIiIiIqJ6WDBB7fJacriq/6L75E3meB94ufjeD6PrX0omk/mc0bREI5kEm23BBBeRmxM/gtwmTOQsIuf8YLyoahal2X98zjRjy6uzLTkmFD0UFgd5r4GGx1tcAWn/3jvFJEzYQiqpkDBh/y6+f//+zbQc/EV5icaZlhyRSZgwr/0g5Pm2Be7agdcQxWaRMOEvRHNcU1fZwh625CAiIiIioppYMEEtm9ySwy1KTEqY6OECwjIaXXnGfS193CVL3SIS72ybaUsOe17hhFpjkpMwMWlnvv27IAACuwuME/Dz5Hb58zhPZs8LE4oe4jZBOWNd62opK2V6nTARF0O5QqoqCRN+EQUXPqmr/LGpx+mEiWgUF1CY174ruOJ4ni+2Vpso9b7f9BrAX4jmsaausuOUCRNERERERFQTCyaoXV7CRHFLjuJ4fAETJvrm6MqzyY0+9mGnThGTMKFUkDofTPdL2ft6WvFu8oH7OpmsLG9H4Bab2ZKjHfYczONcgUmYsGOz6HxT0JJjFgkT/sJs7xZcJQKCwFswtgkTpigiJ2ECY+8agWOUusor2BYdpRImJIoLKOz7oW3Lw4S1+bKfCVkMWMIbg03bRAnEpETO8BqcaMbEJqEoFkwQEREREVE9LJigVtkJGlVW8V+WMJHa1cXJxz44uvIM1OoGABa50AyIQAUz3t3mJto5odaYjjK76W1sM1ClJYctmOBix3y5c3DfFt9PgivwnJCUonVSGKG9+3gpK83PLX5iRb8KDkVrKBUCNnkmMufZsW3JYf4UgT7aN98beT/P6wXqJr94SaKxS00BAOgxREcucSkpGOJ4nisWvk6mZ5MwoexCNK8jqKsyLTlY3ENERERERFWxYIJa5iVMFLTkcJM4eRMxft9gTj72wujVZ7By9+PxjZ4t+FAHmYSJWfZPFk60Ty/VkkPHC8RVYptFu92KAFgIN2+2LQKPcwVm3AaTWsuIKxZKpWD5yRMNzy1+AVHvWlqJNgkTJnnGvv/bggmzyLz7uz+P5/7S3dAHO+mWHDwfU1dJpng7mzChx0krGncO4Dl3rlgMOJH4Y3CaNlGu1QEXoamrBIotOYiIiIiIqAEWTFC73I7N+P/yd11K5s+cnwe4sNYTR1eexcrdjwHo4YIPdc88+ieXFWlRJfHisC2YkHgXYlnrJftz2uzCt4vSfA7mStiSozKXiKXy2m149/MTJiSdMJH7/XoPIvm6b9c8Oopf26aQyr7/26IImzAxuvZF6INtRDvXWTBB/WDHZhBC9Dge2zb63dy2r30mTLTDHV+eN4rNKGHCtTrgIjR1lRmnSlVIuiMiIiIiIvKwYILa5SZXiidbbNRtXjS7MGGiV/ToEOPrL2Dl0hvjXXZ8zmhK4lo4zKFgghNqzekoWRyGJEkgRUlClmgoFSSLSlzsmCtXtMbjPJmkEyakqJjHJCmYG/5fTJ0wkU7V6lfBoUhcSKJcIZVpyWFbcdjCidFB/OfRPsCCCeoB+z6lwiGgI0g0ggpXABXE4zovYYLXv/PlWqvxvFHE/9zcuE2UK1oOWDBB3ZVpyUFERERERFQVCyaoZUlLDlX4IdbcJ3dxose7LZeQXQgJ1raggkHvFnyoi8TFAc+qJ21ZkRZVJDrZSa413PM0sSWHSZiwLTmmeA5kfIRo90bjn18KXFSqwV6v5BVDZO6XlyRRlDxRh/ZafPQtockUt6lswoRpyWFbc2hznaBH+6mECRbFUmeZawY1WImva/UYCAdQ4QASjSE6SlpUsWCiFWytVkGqJUfDNlEQV7TM6wjqLpOEwpYcRERERERUEwsmqF2SFEwU9j/VJZNefhEFo9u7z4stRhACfVvwoe7RcSLBTBMmXJQzJ9SaEi3JTnJIsrtrUp9ruzt/BgUTN375h/HCD7y98c8vA1e0xvfPySRTMFF0frDnpGP3SQopmi4sSZ+LRG1LDnte0NmWHCOISCphItWSg2OUukqSgglEpgVHOIzHum3RYca9cgk1PXv99o09vjxvFPPH4JQJE2pSehjRScomTPDzHRERERERVTSYfBei2Ukm/8t2Hpvvlf0dABFOPnaenZwzu0w5YUzTs31pA8xsspY7E6fn76gVbeKe40n1suhnEQ0FlSxKT7HYMb51BeNbrzb++aXgWnLwXDyRGbepVjO5d9NJUYB/DhFxi6XNF6cWoSWH2Y2cTZgQidsZ2IKJbMIEz8fUVXZshisQHUH0OH7/E4nHub0NMGGiLUxPmijVVqrxcRJTLDHDomWiGZNU0TbA4h4iIiIiIqqKCRPULrsAoYp729vJrtxJr1TCBCcfu871eQ5CgC05aBa0TSRQM9tJ6M413JnYnGhA+e0HvMnK0pYcGipQyS7caRY7dMSilwls0ZpwrE8kfkJS/I2COyatN/ziIEm9Jhoeb+lzwoROCqGCQVIMYQsmYFImbEuOo31g7CdM9OzfS0tD/IQJPQaiUVw0FcbjPE6YiF/7ypwD6hQM6/1t6KOD2T/wBeaOL68BinmFko2vtUwxLFTAggnqMDHF2EyYICIiIiKielgwQe0SL2EidTvnPjkLOpLabcnJ9M5zCRMqXlDic0ZTklRf2hknTHAHUmPxLnuv/YBI0jql7LjaRdUZtOQQ0XxfmMQWrXFRqQK/hVjJApMkrTdSY11kYjrF5IfQz4QJEUna7QBQw1XI+DD+u2gEmN33Mj4qbsnBMUpdZd5nVDiMUyXGR1DhIG5LpU3CRNA8YeLFv/1+XPvpvzbrR73YWDAxkcywJUecEsljTR2VaclRlnRHRERERETkY8EEtcxfgCjYeVwaj9/j3ZZLKLVDNxy4SG6ixkS7iPeZ7RjSJak2VI2O0s9LalK97HmSmRVMMGFiMncO5nGazCZilRV4AvE5SeW13hA3rpsmeqR+rk/vn5l2JsHKKcjRfvxX4yMEKxvx/aIRNFtyUN9oL2ECgIwPocJh3HouGkO8FlVJ+kz1zyzRrVcQ3WZ7qTpcOiHTk4qlCiaat+SAv3OfqJPizyCKLTmIiIiIiKgmFkxQu8QrmFDK7BbPv8+klhzcSdwDdheeCpKdd0TTkGSydlY7htxCBncgNSdeUoRowE8CKTmuYhab1ZQLy+4xcJG1nDkHczG6gsz1StE49tNV0kWdBd+v9yCSr/p0zWPHl7IJE+uQo7343yAaajUumJDxkSuk0NmEiT79e2mpuJYc4TC+PTowLTmGpkXHOL4NNEqYEB3xHF0XEyYm84/NlAkT7pqN183URZIp7OE4JSIiIiKiilgwQe1KteTI353iJglzP9wyYaJXtJcwEYT9WvChbrIL87NsyWHHKSfaGxMbv5+XMDGxJYdy0f2osQs39zGIcAK/hDsH81xcgXe9ogIUjmO/JUcmYcK15GhaCOSfk3pUcOjGmVlUC1bW44KIcVwQEdiCiWjkteQ4ANiSg/pA0gkTenQQt+RwCRNj99p3CRN1zrk6an7OWFLCgomJZAYJE5JpdcDjTZ2UHadMmCAiIiIioopYMEEtS3ZsqqIdm/Z7OZMwwoSJXrE791UQxPHEPVrwoY6yu9uCYHY7hkqLtKgSHUGpEEoFpuitYksOP5kCmG6RiAsmk9lzMBfjJnP1EhPGseikMMIbe+IXUjSdrPf+m31oabX9Oz+N6//v/5IsKNtF45VTccJEdAQACNY2AZiEidFh/PVoHzI+cseM0frzt/Opn8Phy5896YfRP5mCCRkdAeEQKhjEKSk6AsLpEib4PlYT3/8n88Zg88JSLz0s/kXTPiqiOeA4JSIiIiKiZlgwQa2yEzSqbAFCSnZ7p3ZbsmCi8+yChwoBFfZiwYe6zbZwmGXChGQXOak+bRImTAsOMXG4CgWtlwwxBRNJn/cpW3LYx0K57DmYce8V+C05oIqPmdeSI3X+cOcqNF/E69k1z/Zv/yRu/cY/Th6rbcmxsg59dACMTcGElzChTcKEbcmhBqvxz/bg39t3r/7od+Pmv/p7J/0wescV83gtOVQwAMIBZBwXAKkpWnKALTnqM8eLhVbFZpEwAZHkM7y5TdQ1x5NQOE6JiIiIiKgaFkxQy7ItOYoTJvInC/3FCE6md56dnHMJE3zO+mT7d34aL/2dbznph5HmT4LNamI81deZk+1NiEuKUPExlKoJExKnhVRcWN7+5P8DfbCT/6vM+YXpQ8UYW16dLfRRKihOxEK8QKfyWnJ4CRNNF/HSqVrdLziM9m7FqRF2fHktOeKEibjlhlo5BcAmTNiWHKZgYmgKJjhG5070GGAha302YcIvmAgHUOHQjWdlEiaatORgwkR9fG+rIHWtO0XChFLJNRtbHVAX2cIekzBRVrhNRERERETkY8EEtSu1YxMFEzbme3kLDGzJ0StJS44wjiruwYIPJfa/8HHs/cFHT/phZIiZqJ1dwkSqkIe7kJrRUbwwpEyrFNFQtjCuTkuOksWO8c0reOXv/Wlsf+Jnin/XhN+x9Ow5mMdoMrfoX1LgGd+xoPXGDFpy+D/Xg2sevXcz3mGvsy051uOCiEzCBKJRUjAxOgCiMdRwLb7NMTp/onkt3UROwQSCARAMXIsZ2IQJ126qXsIEk5JqYsHERLNKmABMW00w0YO6yrTkYMIEERERERHVNDjpB0BLRryECZW/AOEmX3Imc6RniwdLT3u7TIOQz1nfjEfdW0zR2iUXzKp9RmrCl5PtzZQlTJQtFosGoOKUCZRPvtuoc7vAevxXccFkEonsMYrbpthFD8rhX68EQfGEu9ZewU86YcIlTzRdVPLbBfUgCUDv3YzbbkiSLgUAwcop6FFSMKFcS44kYUKPMi05+DqeP615nBuwxTxqsBLfHh2Y4glJEiZssVCjhIkxn5eabIE2C61KpMZgw+tne20He+3AhWjqIDNOFQsmiIiIiIioJiZMUMu8hInCBc+SlhxMmOgV9xwFIVQ46MWCDyUkGnVw0j5OmCiLyK//K73zCifVGhHRpnVBYArbqrXkEK3jRdUqLTlcj/KCc7+e8PeUJEwAHXxtd0wqEatkHIvfksOMQXvfaRMmvP9mHxKaor2bcZsNmzCh/ISJpCWHTZiQ8eh4Sw5bMMHX8fwxYaIZc8xswYS2LTmCAbQt6DMtOdw5oE4bQR1x4b8uO46ZeFDMe603T4YwO/eDnCJBos5gYQ8RERERETXDhAlqV3YBIvc+JbHq/vc4ydt9dheeCuJ4Yj5nvSJ63LnnTLT2+tLOvmCCi8gN6SheGLIFEia2uUpLDlWxJYdbQCoqvBImTEySWhzV2lvQp+MyiVgF40pEQ5n4fVcoYf50u8sbjknp0TWPaA29dwuAJI81iK/z1Mop6FRLjs34Z7yECTEJEwFbcrRGRHd+XHVSTsIEghAIh17CxMD82SRhIuL7WF0l6YQUS59Tm10/i015s5/hebypi+xnECZMEBERERFRTSyYoHZlW3LkfYDNLDhk/jL5ipO83ecnTAQhn7O+MbuBuxXdL6bFS0lEfu1fyYKJqbmWHEG8a9lLmJDSiXlJfs7+niITEiTcjkmeZ4p5xSYiuqhskYB0gWfZOBZJxq+7j/3ZKXfh+qlaHU9o0oc7ScJGFBdG2H9/MLQJE5mWHOOR25Gvj/aB8QhqaBMmeC6eO2FLjibce004jG+PD6HCAfyWHAhNMZqybXnqJUzweamHLTkqyBZMNmI+D3AhmjpMUm0BASZMEBERERFRVWzJQa2yCw5KKaiiHeIlCROpCFEuinWem7hUQRxP3INIcUrY+PROvdbE3902mwmw1AI8J38bEa2hgiCVMKGqtE7RcaGFMvHOpTHR9nxSdB7RXDCZRNiSozLxCibUhJYcx+LJ7TjOtOpo8CiSLzv+/qn3brqv5WgfQLK7Xq2eir/nEiZMwcToICnMOzrItOTg+Jw7zZYcjeQlTIRDqGCQJEzYQomaCRMiYlql8FqkFs2EqUlER0mrmKnaRCUJE+UFsUQnJf4MkiShcJwSEREREVE1LJigdmV2bOZ9gLWLFPkLZ0yY6BXb59kmTHR8hyylydgUTHRpAtru5lZqdgtq3r+Pi+0NiW3JEcTH0O7umlDYErcz8BImSs7r4navF7XksAUVfA6LpI4dx/oEpsATyiSnlBRMqCBzTZNuydF4Tck/N3X8mkfv3nBfu132XsIEAOiD7fj22kbqdvwzcUsOmzDBc/H8CRMmmrEFE2FcMAEdxS04woGXMJFuyVG58LSsLSHlEtcGDHz/L2PHKaY5vwoQJEWuXIimTsokTAjHKRERERERVcSCCWqZ15IDKGjJUTJZ6E+ESbcXDwjJc6gCgC05esfuRu/S8xZP8sYL8TPb2ZY6r3BSrQmxSRFu0djrH1x2TO3zaRZWSyfxJyRMiEuY6M547Rzvtdyl13UnZQs8C843Scui5D5uct7uLm+4OJWa5O94wkTkJUxokzBhX9dqZd3c5xaAJGHCL5jQR/vphAkuGM+fMGGiEVcwMXTfUuEgnTBhFqbrJkwkSQm8FqmMbdWqEZ2M2aaFJZmECR5v6iQzThVbchARERERUU0smKB2VVmAsPfJm4Txd1syrSDXK//7n8P2p/7FST8MAMkEcZwwwZYcvRN1M2FCBRVaPdT6lZxsn5roOP5WBfEx9BMmJhVMBIGJzkX58TcT/IULT0yYmCjVkoPHaQJ7vTIh0cYmTATBsYJPF8vf9FzVo2ueVEsOt2hsWnKYggm9f8vcNgUT+7e9n9kHvISJTrWCWlSieZwbsAl4tiUHgLglRziEmLYzqmHChLC1RH1+ISCPW6GZteTwdu6zsIe6yU+5A8cpERERERFVxoIJapf4CRMFC2mlcbT+bsvqk7z6cBej6y9Uvn+f7Xzq53Dw7G+d9MOIMWGi18QWTHRpYdUlEsyuYIK7E2dAm5Yc9ryemlQvK5gQd36Ib0+TMMEo84nYkqM6O57UhEQbWzABlSRCZBImGh9r/9zb8ffPKFUwkU6YCGzBRDZhwhZMhAOITZgYrsW/g+NzrlwbAx7n+uwxyyRMJIvRADIJE5Vfvy4pic9LVanPFjxuxbyWHNDNrp/FTw8z3yHqHBb2EBERERFRQyyYoJalEybyFiDsgoPkLNJKw8WDG7/8Q3jhB99V76H2lEjUmYlWN4kZhPFkcsd3yPaBiOCLf/0p3P6tH5//fyvqXksOSNw/2Y+/n/pXpibbOanWhBzbZV+tJYf4yRRAaXGOPa8V7rS3f9+l8doxqXYlHXmf6C6vwLNsHJuin3TqTfyn213e+LyS/Jx0PKHJFkMAXkuOwLbkOBV/3yZMZFpyhKfOsSVH29y1Ns+XtdkEGS9hQgWDZDEaXrpKzZYcTJhowD+2XSrw7Rg/YaJxSzvbgsqlgvGamboo0zqGhT1ERERERFQRCyaoXcdacuTdp1rCRJ1J3mj7GvTu65Xv32vRuDsThnZS2bTk6PqCTx/I6BBHL38GR688M///mF2Y7tDEvdiEiSCYS8JEV4qNescWPphd9uK15JCy50nHhRbKLKyWHn9XEFFwHuFC02ResQnHejnxrlfisV1c4Klc9LO5j30PnjJhIvUcdXxhu6wlh02YiAoSJoKNc5CRTZhgS45WuMQeHue68ltyZBImwkzChFRNmDDn6K5cx/eAsCVHNaKhbCpK0+Nkru2UWYjm8aYuEiZMEBERERFRQyyYoFa5xYXSlhw20jpnEsafQKw6+QhAxkdLsYuuc5H09pjbyP0leA7mzUadt1F8YltydOq1I+ItzM9onKfOK5xUa8S05FA2YUI0lFJmIbmsJYc2k5pBcrvwv1G+wCelxXYEZM4bXXpdd5FfDFGUMOG3nfLuI5mEidKioQqPAShJVumIVEuOo3RLjmzCRLC2Gd/2EibkaB8yOkxacnDBeL7c+ZLvebWZzx+phIlwmCxGAy5tQqlmCRNciK6BbdWq8VtyTJV6xIVo6jiReK6JrWOIiIiIiKimweS7EM2Sv2OzfAEif4GhWcKERKPlWBwyi2FdmWh1u/BMS46uL/j0gVuIamE824KJTk1AuwX28lYPtX9n3tdUmYhOt0qR6i054LfkKDn+E1ty2IWmZTjXN8WEiRq8lhxQ5UWcmYKJJE2rQiFQ6UPw0m86Pq79hAltEiaSgol1c59MS479uGAi2Dgb358tOVpjr8+6Pq46yV7bZgskAm/MZhMmqh5nJiXVl2qrxuNWJG7JMZuECRZMUKfZz4r2JscpERERERFVxIIJatexD6wlRRE5kzmpHYd1CyZEQ2zv1QXVud7HNgUkCIBgkEQNU2N6dAIFE11aUBGJWzhgQnJBrV/JlhxT06Ylh1JmMSlpyVGeMBEnhiizsFq6q9xFyBecR5gwMVFqcZQ7+MtlW4jlTLjb84UKTNFPdgzaxdKm56qG1zwnISptyWETJkwLjuEaoFSSMLFxzv2sLZjgQv6c8XzZmHvdewUTCAepY2nHvj0H1E2Y4PNSHd/XKpIIKpxBwkSqYILHmzpI/M8gYGEPERERERFVxpYc1DJvAaKgJUdpWwkv/rrWZPr4qPh3LhJ7TLqy0OB234ZQQcgFkBmQw734zzaOZdStxBIA80mYSO1O5KRaI6LjhSEVoE7CBGwyRVBhJ/6EhAn3muCCSTG/2KRLr+tOShdM5O5QFC+FQinXisO183C7y5sda4G4HcFdT2jSe7dci4LjLTnihInItORQg1WocOgKJoKNO9zvcW0OOD7ny55PeV1Wny2YyLbkCLx9CLYlR9OECb6PVecd205dr3aMaHFjtOlxEv/aDkje84g6JR6nii05iIiIiIioJhZMULsyiwt1Eybs36lwUD9hAuhOIcGc2AWVrvT+thPxKgji3XdMmJjasidMiL+7bWYtObzfw8n2RkRHcfKHv7BcUhjn/WD1lhz2vFY0HrkAOFFq0Z1jvZzXVkPZQqBj97FJEib1xo1186fdXT5FSw63i73j75967ybC03cCSBIm7Os6GKZbciAcAoMVlzgRnvISJsJhOq2D5sKNSZ4v67PHzk+YCAZQA69FR6YlR92ECS78V5c6VjxuxXQE2DHa9PqZO/epD1psHSM6wujal1yLMSIiIiIi6jcWTFC7jkVc59zH9VUu6RceDmsVBdiF364UEsyNdCzK14slVyrs/A7ZPrA7d0VaLJjoyngCktYPc2rJwcnfhsS25PAWOm2LjpLnSVxiiG3JUTKuXUHEhISJLo3XrvF34nKhtJSL3S8r0MqOdXMfe63hdpdPsThlCya6/nxFezcRbsUFE7awz/77lWvJYRImwmEqYSLVkiMcxovMfB3PV1maG5Vyr+9UwsTApUoAcDv5GydM8HmpLpUSxuNWSKIkBaXxcRIoKNdGjdfM1EWC9gp7op3reP6vPIzbv/Xjc/tvEBERERFRe1gwQa1Koju9D7E594r/OD6ZY39eBQ0TJlpYZD5JXVswdI9H2YSJxT7+bXBR520Un+gOtuQwMasIgtlNgGnuTpyaa8mh3OtcKZVOnMhjCmBUhYQJ93dFY1+4ADiJsCVHdalxq/KPl2SvafITJhofa9HJomwvEiYuAvDep4J0Sw69fwsIB1BBABWuQI7iFlPBxln3e9RgBapu2zWqj4k8zdliKi9hQgWDJFUCiK95geQcULVgu2PX8X0gqUJAHrcioqNkjE6bMOF27vN4UwdJXNiDNlpyuLmOonktIiIiIiLqExZMULsyCRN5C2lStujldnUNaxU/yNgmTCz4xLBdSOzKBJYku2xVMCjcGU7V2Z27bYxl+7rpVKGL1mYRTs2ukMP7Pd0qDukHETGT6HHChDuGVVpywPxclUWlCQkTSTpRh8Zrx6RSfriwVM5Fj6MwYcKlUATphAm/nYf5RrOHoLVbeO3yuBatofdvYXD6UnzbtORwCRODFZM+kyRm+O0L/JYcCAfxOZ7jc75YYNacfd17CRMIh5mEiTD1Z9VUMHs/LvzXwISJarR2Y3SaNlFttTogaizTOqa0cHvq/1SSpklERERERP3Hgglql/nAance5y4i2Ejr3N2cfkuOGosHUQcXfufA9T7uykSrnzARhAt//Nsgh/GO3DaOpUtm6cp4AmATJlRRRH6T35iabOfkb23+ojGUNzZtK4OS8aO1OT+Ylhwl95UJBRFdS9jpJK/YhMVBk5g0GwCFLYBSLTmCYwWfyo7rxudQidNXgrCdVKGG9ME2IILwdNySwxZM2IIRpZRLmVDhSupP8rf0bQAAIABJREFUAAjYkqN1woSJ5nIKJlQ4SCVOuOIJxZYcc8eCiUpE/ISJpgUT5n1xymJAovmy47SFwh67mUdxWpWIiIiIaBHwyp5alomvzu0Jbr6Xu8AwZUuORZ8Y7thEq/gJE+EgvbuZGpEWEyZsoVHVnZFtENHJwvysJmr910tHXju9Ys/VKoyfGz9hoqgwzrDPJ1tytEO4sFSdlzChgiB/h2KqYGL2CRPxbt6g8wlNeu8mACA0CRPatuTwFhCClVPxt+wis11cVgGC9dPufiocsiVHG+x5m8e5Njs2UwUTmZYc9muXMFHxOEvXkuJ6wC/+YyFgCR0lrWIaLiAL4vdFpezOfR5v6qBs65g2WnIEnFYlIiIiIloEvLKndvktOfzbqfvYyZec+GtbxV8zYULGR+bnF3ti2C2odGUCK5UwMQBEzzUWcxnoI7Nzt4UiBjeeupQwId6uoVmNpVTBBMdnXW7xyLZK8RMmJrXkEI3UbsUKBRPFLTlsws5in+en4h87HqcJvJYckwo8M6lZAu9aR6nm51A76d/xhCZbMDE4fRFAUtinvIhqmzAB15LDJE0M1xAM15P7DYamfUeH3ncWEQvMmnOfRfyWHGGqJYf7OmiaMMFrkcr8Y9ul69WOER3FGw7iGw1/SbrVAccpdZIZp8qlhM3zP5VsDiEiIiIiov5jwQS1LLOIUNKSoyxhAiETJnLZBcOuTIB7fT1V3UljytVmwoR93XRqAdrsuJ6UXFDrV3J34nT8XfZB4BVKVShscc+nuRzRJWkUE3ZEu+eOCyaFJEqO3SzG+pf+p7fhxq/+yNS/p4vEFmcBha1l3ES5Mqk3mesX5cb2lAkTHU9oinZvAIDXkuMw/ouShAnbvkAN15JiCiAuqAhCnovnjC05mnNj02vBocIhVOgVCNlr3roJE127ju8BJidVJNolnzQuXhfTJqqNVgdEjbXYksP/DERERERERL3HK3tql/vAWrzz2E3i5k16NUyYQBcXfucgSQToxr/T7Tw3Cz4AOr3o0wf6cM98Md/nWESS1gddmoB2MavB7BJW/QX2nH/rwRc/hRc+8rVJzDyleYVRfsKEMrsQpeyJEgGCwKRTTFgkmrTA53bmduP810kzXlg6uvIMRq89N/Xv6SQRFzteWKDl2tFki4O8a52CYotKD0HreHGqLy05tuKEibyWHLYowhVMeAkTfsGEbcnRleuYhcWEieZsoZTfkiMcpBMmMi05Ko9n+/7F56U6/z2fC/jFdAQoMx4bjy+7ED1luymiOZKTaMnBggkiIiIiooXAK3tqlUg2YSL3XuaPnMkcSQommDCRQ3dsotVfSHWTxt1d9OkDlzAx78KTqHvR/cn5I4BSanbtXXT5ZPvBc7+Dg2d/E9Ht12bz31swqcKoVJS+aVNQ8DzZ50/5CRMVCiZQNPZdQUVHzn8dlFp0n8VxEt2Z88PsiTcBXtSSwy+Y8JIkUq06ginOVSZWuuMtOSJbMLFxDmqwAhnFraPSLTlMwoRNljB/BsM1qOFacr+QLTlaMSGxh0r4n0WsYJC6rTItOeomTHD81+C9lzGZo1jckiM059fmCROpz/C83qJOEle0Hd+cX8EEW3IQERERES0WFkxQy+wCWUlLDl226y1pyVEnLULGR/GfC77z2EX5dmQCyz0OFbjJ40VP+Zg3sTt3550w4S2sdmYCWrzzB5rv2j7+a8sTJmy8PMduAT+OVqmSXfdlPze5YCKJkM8vmOBC02R+odVMXtdad+f8MGtaJ4tCBQtMLj3FjH3JXr/Ysd24X7xpWdPxlhx67xYAIDh1FhisuMI+BH5LjrgoIi9hIhimEyYQhJ25jllUbMkxBdM6Kp0wMXRJavFtkzBh3werHueOXcf3QWoM87gV01FcwDNF6pEt4rML0aUJYkQnxbZUa6MlBxMmiIiIiIgWCq/sqV2Zlhz5uy6THZrZvxevJUed2PWlSZjoWgsFf9eFnUhmwsRUbNT5vIt/3GsG6M54yixOzmwCzC5KAvmLoqZggmO3gJ8ko1SygO4m1QueJ6+wQpnjX7p4N2lHNBcAJ9PjZJFvBq9rkahD54dZMxPuiBc9cxeG7DWJCuCP9WNpWlPu5lVBWOuap202YSJYPw0VriSFfX5LDlMUoUIz/uyC8nANajBMUqjCYdyip8P/3oXAlhylRATXfvZ/xOj6Czl/l5MwkW3JobzdxjVevyz8ayDVkoPHrZC91vXTkGr/DgBQro0aW6BQJ0mLhT2ptoRERERERNR3LJigdqViqosiriX/6/gb8Y8Hg4YtORZ7Iq1zE63ergul6sUSUz452ou/mPdx9AsmuvKc6YoL8XWJdrtB83bLaxMvz7Gbz2/JARV446V8sVj8XfhB9ZYcRTvtO3f+q0Ef7WN0/csuDWleREeAXeSbxXjWupfHuxI34Y50ckrqPnaiPMhc0/hpWs0TJkR0/LoKup0wIUd7ceFDEEINVtw504+oDmxLjoFpyeElTACAWrEFFaYlR43rtWj3Bm7/1o9P/w9ZJiwwKxXduoLX/+VHsPsffvH4X9qCCT9hIhjkJkwAgFJh9ePc4/exk+If24VNPJoB25JDqaBxgolkFqI5Tqmb4oJX1ULChKQKZ4mIiIiIqO94ZU8t8xMm/Nvmlv1AayfZsxMxdoInHNab5F2Slhx2l1VXJgzdQmoQAqF5Tju86NMHLup8zsU/Mk4KJroynuaVMCFaJztDcxMm4sW/zhSOdI0di4EtkMi06CgqbHEtVoJkN27ZuJ7QkqPPO6b3/vBX8fx/9yAOX/z0fP9DUZIwMe3rWkQA0Qu74CrwCiaKCrT81Cx/rOvMa6DpuUrHO4JVOOh0wo1EI7fbXg1W8xMmTEEETMKEu78pmLBtOdRgCBWEtcbn9id+Blf+4YcwvvHyVP+OpeISe/p3vmyDLVDKPb+5Qql0gUQqccJPmwjCytcPfS78OzH2mIUDHrcyfkuOxgXH4rXVBBMmqJtsYU8b49TOLQWcViUiIiIiWgS8sqd2pWKqcfwDrGvhMEjdTn7cxuBWn3wEsDQtOdwO1K5MgPu7b81zWrjYSZW4lhxzHsup56kjr5tkF4+acsI3+4ujZCd0zmS7jG1Ljm4ch87x4mj9nYtKlbVeQub8YFpylCx2uL8rKrpyvd97+Dy1lMAjepy0RJj2fcI+r4u6QCUCBS9hIq+Yyl2zmJYcmYSJeIdjMEVxip30r7FD/SRE46TFxmAlKexLFUzkJ0wEw1Xz99mEiRrXeKYoVh9sT/GPWC5uTC56IXFTJYUL7j0uCFOtZLIFFO7roH7CRNMEgKXkt0jhcStkEybqJvikf4ltVZW/8YGoM1RL49QVyLIlBxERERHRImDBBLXMK5hAzgJEJmHi+EKb2ZFcM2HCFkx0esFhFrq2M8215PAmlRf9OZgzObJpB3MuPPFbcnRlPHkJE/Ei5IwmwLR2i315C5vClhylUi05oLzXfXlLjnQSRYWWHLo8Qt49dz1cMHGLa/MeYzpKYuSnfV33+HhXkmrJUdDzPTuG3SL0hGudyo/BS5jocDqT6LErilSDlSQ9JtWSwyuI8P+0LTmGNoFiWL+NiTk2+nC3+T9i2bAlRymXSJebMGF3FIfJuM+05Ej1s6+VMDG2X9R9yEvLXYOEww4lonWQeT+ZquDYvi+6NmosmKBukWPJX5jrOE0XzhIRERERUd/xyp5alfshNnUHu0soP2HCb8lRffJRJ/dd8InhZKK1GxNYyS68wD2nXe7D3gf6aA9ACzvRvYKJziyouMXJgoSapr9WtJcwUdySg+ko/z977xZj3bLdd42quVZ3f9+399n7+OTkxDIORsJSYiQkUB5QkIKSECHBQyIe8gIhClJCgIREQqCIhBceQgQivJhLjCNkg1+QzcWGBEzs4MQ2QrGxc7FDOOdgy5dj+1z33t+lu9daswYPVaNqVM1rzcvqmrPHT9r6dve69py1ataq8R//fwe8aKx5N71yHfrt54nfb5Rgwhfo+x0mNlloIpHgyvMjLhnJQZ3QWzzeo6BOWgBQHU4pSfwM3QeTz8TUMUl58Uofip5/sL7YdRkE5wj7Q5vDhLudojmckEInDhM544rGoggmMti74GkuffMbj9xxc7eN5Dj43yv+HWeCw8Qmr2NPhY/kOMpx6wFdJMds1yO/ttvz9V/YLD7uj+81rekwQSJx2VYVBEEQBEEQhD0gK3vhuvAvsS2FNEwcJpobX9S1eBi9+Vhk4XctSitgsS48XxAsuOizBbzV+RUFE8UUVDA4TNiu7YXeF5pgpS2RHPmwSI4shwkmqKJNzX4bcleM7ozk2G7HtLqWA48JgonZr+ULrts73qNA9F20qmu+YU4Sio/1ZK0z+ZqMxjq3ZHSoPwnm4ovF6nAbfs86LhsOE4fEYYLdrnSVd91x6wp8fDPt/T9DaK5FieRoBXuE1ryj2IskqmMQDXGnCXDze24kRynr+A3AHSZEMNGDj+RQ8yI51HU69wVhGonDF8C64zT6DiQIgiAIgiAIwtY5DN9FEJaEfYlt69j0m5BUPEodJlwR4jDeYSKKFii54LAAfRu8TwGyLjyyLS7lvW0VPFnBxOpFYVaULqUAHTsSzLC5bzyx8UW8PocJGbvt8EgOxR0mMiI5fCdYT7HDzycdoitf+NtiwcSLBNcWQgUngMUiObZ4vEdgx3FwmGidG2jNQiIuLwJlQgqtp89VJkRylOzOhHUSyeFQLNM7dZhQ5DCRRHKo6uhcOXJi1ySSIxtxmOjHjanW9U/kIBMcJvwaQSdfrzMcJsI6Xs7LaLg7oRy3bpzDRGfE1CgSwcSanfuCMIUWN9PFIhzbXi6KJRQEQRAEQRAEYevIyl64Lo0vsalggooMzo0gKcQg3T/DnvpZOUzUhWUfmzp03kokxyKY0xM4TJQynqhrW6fFyZlPS5vI9ofm7efHcD+hCS8egWLHqd1JiD2QPc79OyKSo/M8mO0W8KnYvPoYwzpEcswsLO0+koM6aQG6hT9JJIe/j4k/E9PHJOXFH1YX08zCXPw1npwjACBymFA3VhjhoziccEc7wYT2t7tIjpzxiRLJkc3eHWJm4ufiVmeZphhY6UP4DLQ5TIz9/EokRzbcYWK316MFQHIsmuEwYedlHqMmggmhMLjzF1xB2CMOE4IgCIIgCIKwK8RhQrguyG0SobnRwruE2M/N28c7TODlFH7Y+cawL2CV0mGFxm+qqSt1UO8dPL2z/z5LwUTsMLFYx5Axfs5p22w3Z4rkELFPK4ZtFio9OpKD5imVKZhoOw+IOCyoKBmKLFpZUIb1JUQmzP1ce8ePQuaHxUEXqQHdHbleGJGKQLk4dLrDBLprqNIVYF3uuI4cJqrgMMEzvbV3mKBIjm6HCVtgHj+u6HODj+8m/gXPD7rWSSRHB3Rc2iI5+OfeR3IcQHmHiaRwpsZHcvQKNYR26JhJJEc/zGECZzhMKBZ1IAIVoTyaDhNXieQQhwlBEARBEARB2AUimBCuTPgSazPBOxwmurq9TRBMjLa3jQq/O98YLsySHikvF8BbFIvDxDzQO0ysXVgt0JnFzw+63aFm8vMa72rTF8lRzHEoDCq4KXdefLcnCVu6zhOP7gArnOg7xr7A1zaH8PNWyPyXQ4ihWlkIZS4hMmF2JEcd/7s3EGEokiNySVGauZzE8WOTjzVicGjia5nCQO4wcbz1v1escBwEEW78OYcJL5i4cbcfjrHwagxGHCay2b3gaR5BgNwRyeHc05SP5DiG7yi66TAxev3gnXukc380zGFii9f/a0FuamrmNcmah12hEC0IE8B0/WV/ud7rGfYdSBAEQRAEQRCEzSMre+GqNL/EYnI7bTa6btvGRq6z5M9wmIASC78rgaVFcqCJ850BpEt/BmgM4OVK8RC8KF3SeAIAAGVdCRbaAEM03a42AP6Y792hZjI8foC7RFAXYtd5SgQToHV/8c6Qg0TLHMLPzRYLgFcSTICpg5vKzNdCfz42eLzHwCM5QLV20sYuKUEc5Ncy7jMxufjpHSb6xURPzgiHiSCIuIn/9ZEcwWHCHrMMhwk3J4hgIgM6vmikON9G33qauaeRGBhYJAckkRygMxwmChM+b4FQsDzs93q0BCRin7N+dkJCJZEcQqlQfCNzQllMYN+G/w4kkRyCIAiCIAiCsAdEMCFclyiSQ3Xf7ruzEkEFfSk9HEdv8j6nSI7QmVbIhqGpG5EcRRd9CoecDgBg/U503s1cyDlDvwlmi5OLFRTQ2CKdfZHmzeIw0Q/L71VKsUgOt2HZFcnhH6f94/sjOdzztFmks8dt0WKeis3rR+1cQkF7tsOEif/dHcFhonMcszEc3YdnaM/q5nWFWX0o2p0J63MQnR2CYII7TPhIDnKWSB0mnAMFTIjk8GsfEUyMhx9fKXo2GHaYiNe2qjoE0dACDhP7nVdXAOPvhkIHftzOWT9j0rkvx1sojetGcvi5XRwmBEEQBEEQBGEXyMpeuDKu4ElfYhtfYN3tvtu2w2FCd3eDN14xcpjY98aO77wu5O9ENI1IDii46FM6eAr57OsXVtnnppQNUe5I0FOIz4ZynaH9b/VCFRFMtOK7O5V2hhLBCcT+1+UwwQUwLpKjZ6z1R3KwxxUy/2Xhr3krz49LRnLsvbCXOEy0j+NkY97PSdxNS3c8dsx7sM+h9KFsdyZT+2u8OuQ5TGgX4VG9/1nQLz6wAhM14DaTQHOCOYlgYizRXCvXtiZ0TNoEei1xc6o6etGQmuMwwWJ9xPljHH4NIpEcnXg3JF3Zwu7EsYUUVaWu0LkvCFNoi+RYc5xyRzFBEARBEARBEDbPYfgugrAgjVzv5AssbXR12ePTl1LqBmeFzs6X5J3yG+w8zqK0AhZ3mPA28AUXfQrHnO7ZD1eM5CilmDI0f0x+WtMrwvIxKCL2accLWVwkB++26jtP/HH0b6/DhLtth5Ec13DgQWMAEH2heq6A0AtYSpkfFga5YKKrwMTjaLioIoqpUZPHJKKxm/A5HepPgHUucY4Rh9twAysgeIcJEkwkDhOf/n1/Et7/Hf+ie9i0SA5xmMiAjUk0NSg4PuGbKZC+aAzTdJgAfWDxHMn3kpzPbxSHxkVbQicimBjGr8uqQXFqP+g66dfv3BeEaTTdTFcVnzGXPUEQBEEQBEEQto8IJoQrE3+JxVTx7zuOO7q9aYPXbbTbTd6BV4wcJsotOCyBtxAuZMMQ0YQNBMr23Pk5WBM8W8GEunl5VYeJYjagucNE2/wxFcPGaU8kx+4FVxPBaLOQWz1Td1fHeTItgom+wjLvvDUGFLO/jSM5ChmvOegrzI9UVFrKYeIZRHKEjsH2cUxjTSXiIIycJ+Y4TNiCqaoORbszobmApmiNjkgOcpgAL6yIBRP6xftw8+K3uTtXeSITN7aNCCbGE0Vy7PUzPJ3BSA66/nBXCePGdEskx3iHiZr/AGIGOQx3mNi7k+BU/DHS1TzBMSIoUH79JS4oQnFgWH+pK0ZyiMOEIAiCIAiCIOwDWdkL14V9iY1/ph8TlX5jE9cJKsiBYswG5OUU/n/vxfq620L4STB1sNsnh4mCiz6lg85hQt+9t/o5LlFohLCOwwSgCXNKS+HIOMFEKcehOPhmodZs89B1d3UmcnABzIiu8j4L+UaRaVtQgW1dhwk391auoD33tUpzNFoaNKG7WylA0zKQI3EQG7/MDUcpNb2I5zLnlT6UPf/UF79uiyI5dLfDBCQOExFaZwnUfCSHCCZGI5Ec/fi1apvrFDm/QBAFKX0I64iWSA4cO55x29eyJ4F/d5Rj1k7qBDb1OHnXE/oeL8dbKAxsOkxMFq2Oej1xmBAEQRAEQRCEPSGCCeG6NHIl2x0mQrdtvBHjM1iZw8TgS/JO+Z1vCmOfhfBTwB0mrtFBvXPM6R0AAOjb91aPNok/N4WMJ/r8K+2K8UsKJtyc0uow8eheX8ZuK36zUINqcZjo7EBMc38HNvEjF4l0/G+9+OfnxxU/164A6CM5Zl4nQiTHTjtMKasdoHu+8WuWJH6Gj+1ZDhPO+l9X646NmaC5+GKxqphggnVcVh98Dt7/nf8yvPxt/4y9iaI5WgQTSuk8kYlb++Dju9y3/nyJ5tMNzplrM+QwQWOb3CSqo///hsOEGu8wwe8nbgkj4d8NS/n+UxosksMKWadet9118Qqd+4IwBRLXK4pEA1h3nKbxgoIgCIIgCIIgbBqJ5BCuCrepVm0d4lRkIDeCDocJv0GZKZjY/aaw3+AtY8MQTc1ynqmDutyiT+mQw4S6ew/g7dfXfTHmBFJOxEFic7/QBhiaOnRCYyrSqgHcHCLuKO14IZuuYtGDUv3CFi+gGyeYiG5LzgWf28sZr+OhLuVrOEwsFslB73Wv11XfSQvQWWBiG+WKx3ZE4tDp3byICNpFchQ9/9SXUCw+3vpfR5EcuoJv/mPfE352IjXd6TAx/piJw8QE+Dpxg3Pm6vTNbyYIJlQUyeG+m6Sdxnp8xEwzkkMYwrtaHY6bvP5fAx7JMejm1ftEGK5r9hfLvEFBWIpGcw60r9+WejmJ5BAEQRAEQRCEXSEre+G6IKn+yaq93WFCdUVykKDikOEw8YwiOfoshJ8ENOFcSiTHbAxFctxeN5KjmM8NFRy0BoicDGaCJnSEpoIJcpcAKOc4lAYdF9fN5eflrnmeQH4+7eN7xV7stsbcv/XiX4er0qL4ohJFcswVTFD8xAaP9yiCw0SXQAsjJwk+1heKD6JYEH2AnIiKaxM5TBzaHSZS9MsP7b+vvql5o9J54iF3XxFMjAfFYaIXf0y6Ijl0HMkBugoxM6nDhK7GH2MRTORDx6w6luOIVhp0/ZjrMOEFExLJIRRKFP96hUgO/91UIjkEQRAEQRAEYQ+IYEK4Lm2q/+hm+tLZUbz0tqviMNFKaZnykcPEviI5zl//FfiFf+fb4fyVX7jaa+LZCSbu3lt9LEfClmIsd7nDxBxLYfaMiPZ5vEgrfk68PLL77mPsLk6aje0LFv3nKSo2A9gCVM8xjjoiE6ea6NxscI65isMERXJUC0dylHK9WRjkDhNDkRyJMMILf5S28RIzu3mVrooWG2J98UXirkiOlJe//ffAt/7Zvwm33/IdjdtUpisHuafgSQQTo8GNi8zWhmJexkRy6AqUc4IBAC8Q9ujxkRxbd0t6CoJ7wkHGcgf8mpTr4BM9jxcS2mtjZ+SaIDwZzb2mVcepFyPJtqogCIIgCIIg7AFZ2QtXJlX9DzlMpF9wKZLDFZfGFDBL7JRfib6OuKcADXOY2Fkkx/k3vgDnr/x/8PirP3e118STzWfXd++vP5YLFBr5Art2TgZLbIDRnNMRA4Tnh/BDIcehNMJ5qdx5SRwmOiM5DLsfJGKLnvtDi1NN5D5RxvyXhY+ZWm9+DJEcR/rFvCcs7HqzOIjODQucGKLl70zFQn6sMzet2Q4T2hZgS752mosvEnOHCdVTQFBaw4tv/53tN+oqb1xJJEc+kQBNrm0p/hozIJhQuvLxMmkEHTHZYWKL17KnwMc5SiRHJ15UMtOhjUR8V4g6EIRJtDbnrBnJEYu/BUEQBEEQBEHYNrKyF65LRzdmuD22NWxsfBnjNmrGuxXghRV+994hTl2WpWyyYu07LnznXcFdslm4sWke3lztJX0kx917q4/lSNhSygY0s1lVfYX4rOd0fxsVPFKHCSaYwHrn88dUWCSHUjpszA8Vi3nHI7iiUt9YiyzkU8HEtm3Mr+Ew4c9LtVAkBx3n3RZbWSQHdAi0IsGECuOXW0JnuiVET+8iOZQ+FCNcawPrc3CYIMHEnOLBkHgqfX13bFAEE+PpizgSegVhyNzTbBSHG/tKAVSHsN4ltJ7kMLHFa9mTwCM55Ji1gjySoyNiauQzubWd9j8LQlH4OYA5ma7qMCGRHIIgCIIgCIKwJ0QwIVyZWDDRKEA0HCbSjS90dqIZgon6FH7Y+aZwaQ4TVuDC8p1hP6IVOtbm4fX1XvNki/f69r3VhSdcaFTM5yYpTi4SyeG77trnHDyHSI5ijkNppOfFHyfq7uo6TxgeR//2zF2RECw5F4gbL/5dIbIoOExIJMcoEIPgr2O+8Z2FvmsXw2PtDd3uFCPfg6I1T8FiQ6wvXnTmBRMz7KmV1nlrBRKLXk7xtUvoJPrc7vUzPAMvwulwmKA1g9JV5CihqmNz7Otq/HgWwUQ2fh13OIorRxdeyGrjY2bFRAHr3JfjLRQGsuYcBes7oSATjQuCIAiCIAiCsH1kZS9cF951aX+R3Ezd3mRPnmzE+G7L8d24GEVy7LwThrquC9lkRVN7S26/obyXLv0n6GjFs3WYUHfv2Z9X3Kjkn5tiCqKRQw23v5/znNQZdIh/dhjuMLHFQvwVCEVj27nox4uL5OiKTmnY2A514u/YYQKu4TBBBXcqaC8VybHXggka8GuVTuEPc73hogr+GVB6enyQs/63DhPlCibAXHxXPQkmvBPYFCY6TABILMdoti4yWxs/v7UcGxMiOayjxNHfpPShGcmhqgyHifA5L2btVTpI7kniMNEJzadaz3OYcJEcXd/jBeHpcc03cJ1IDh8JJA4TgiAIgiAIgrALRDAhXJWG6r+xYdPvMIG82xJg3AbkhW8+7ntT2HfElbJhiMafqyByKbjokwEd46tGcjy+A1AK9M1L94s1i6slOkykXdvLCSbCnNMdyQE7nz8mg3wjPnaY6OrMbzwOYLhIyue1tNt+493S3sJ9xfkxOEy44t5MoUOIn9je8R6FLwxB93wTxcpwUUW61pmXFw96fMH1KcD6EorECzhMgK7yjhn73JiTCCZGsfE5c21ovmxbTyOaWAzMIziq5GcA6zAx9vMbif+kGD2GINo8lPP9pzDo+68Vts65Jjkhobs2ThYDCsJacHG9d5hY8/XieEFBEARBEARBELaNrOyFK5Oq/pNvsL74QPHQic1FAAAgAElEQVQNbQ4TOtNh4vlEcvR2xD0Bcc4zFQTLeG+zeYpIjvM9qOMLX1xdsys0ErYUsgFN84GiTbAl3pfvujtEr+Ff8yKRHIMwO1rFOxe1dnuVA4IJt6FpbfinOUzwz8Imu6XdPLnqeydL7mophwkXybHF4z0CBGc9DgBd8w2mYiE39pG7aenp3bxIa57qYGMvSsVcfJFYHW7t72YUD5TSWeOKuy1d0/Vpy/RFHAkQ1gYdkRxhbZtEcrQ5TGQInqJx3zNHn778Rfjyf/unVnUa2wymDsKyQtarxeHXadUshzZ0Ij7vDCbHWygNL5iAIHpdNZJDBBOCIAiCIAiCsCdkZS9cl8hSX7Xdwd7c4TBhbXBVlsNEFC2w801hX1ApZQOL5zxTkb/kok8OJJh4vKLDxOke1M2LMP5XdDzA+gzqeGf/v5gN+dhhYonONi/CoI7QHoeJ3YzdhfHHkDoXPSRs6YjkSLuyBiI5egt8G++WVhQzs6YIqiaHCSuYmH09pPlng8d7FIhOnAXd8w2NfUhigvxnwjlPzHCYUEpZQReaYrt5ucOEj+SYY089FM+TwuZmieQYiURy9OKPSds4ZIIJVR3C+gEAoDqGNRqR4xDDxX89n4F3f/eH4aO/9p1Qf/zr4553z2Btj3FmlM9zwo9nt06bvq7H+Dt8odck4TnDBKvkhCKRHIIgCIIgCIIgjOQwfBdBWJDUJjHdaKENHG9Pnm7ooN0Qy3GYuBQYLbAWFMlRyoZh5DCREaOyAZ4ikgPP96BvXgQHljWP5eUM6nBrBQOlRFH4Lp6BqIes5ySbYhJMJA4TXDCxk7G7OJHwIQgmFG2qd0ZykEBunGAiKvCl4hV+bkqZ/3LJsW2fgI/kqI70i5nP98wiOdo23CM3FQVoMP79TIeJ1FULTN20+y+ByGHCOZjM6bbM7BTnjjPiMDGSjYvMVsevp1vmZBMEEx/8rn8VXv723+1vaggowBbSxs7tOPJahpdT9/t7ZqCpQalq2KXqOcNEfGqGwwQgMpdImP48grAWrZEcK45T5rInCIIgCIIgCML2KXDXVdg3ieo/7eZOHCYa9vhoHSZURof9s3KYKKzjF7nDBEUemJ106dNm+hUdJvDxHaibl3HxbK3Xqs+gjrcA9wUJcLjDBHQUMLOfMhFppXOSRHIMwzcL+Yah36wciOSgTl2l+8daXyQHv60UgU8mqjqsO8ZIHHRYKpKjMIHe4oRIjihqJrpLGMOKiyqSDfvJRTwWyQHgnBwKFExEDhPVfMFEbiQHmBr03ftgHl6Lw8RY+JiUa1sDP/5ajo1d29rx/fI7fm90283nvh2Ov/kfjR+Q4zDBr199jkv03WYva+o5GOYwUcj3n+JIIzlmO0xQJIcIJoSy8G4SJK5f+/V8tKMIJgRBEARBEARhD5S36yrsm4bqP9lo8XngVXx/9nildF6HfX0K/7/3TeHSIjlaHCZ2E2vgHSZeX+0lzfke9PHFVY4lmovtRF85JiAHZA4Tvc4FOc+ZWKk2RFrMYaIYp43C6I3k6ItOSSM5dP9Yi87Nbh0mVvxM+0iOW/vz3ONE56OU683ScIeJjmgZP/ZJxOXug5GQYo7DhHsP3gGnvDkIjQFA44Uc6mjH1yx7ap1X+MT6AvrlByKYyIB//qUrvwU3F7ceGxbJkfIP/bs/3PhdjsNEdC0bIZjYuxB8DIjGufyIYKILGidhnTbzmuTEhDJ3CMWBSXOO/eWKryeRHIIgCIIgCIKwJ0QKLVwZLpiAZiHNW7S32+O32lMPveLlDOp45x6+741F+vtK2cBCY3xxXznL8lKK73OhY20erlecwdM9qJsXV3GYgPpsi3SZhat1cfODdzJYIpKDRFrtc47hkRx7EfssjUmKw4TPuW4/T5EAxj2+d6zxAl8y9qM5r5jxmodSGV3IU6BIjoUcJvwx38mc3iSJ5GgtnLI1DRdxNX4/7VgjGlBszVPkHETnXy8YyaGqPEGPqUHffQoAQCI5xiIOE730OUz0CSZa0dVosRO/tvWu5b3DhJw7cJEc4MRpnSLN54yfp+1xmu56hMxRCcRhQigP2kuSSA5BEARBEARBECYgK3vhqmCq+u8QTASHiWRDxxjXbZkhmKjPvqN29xuL1J1cSoe1K/Z49GF3kRzmmpEc5wdQNy8AKnJDWDmS43AEpTI6I9cGWYFdqWWiAKgzqCuS4/yMHGqmQuOQRFEeZbOuBxwm/BwxtIkfFfi6HSaKGa+55HQhT8AX26uj/XnuaxUm0FsadIUhAOh2tIlcUrg4yG3YA1mXz+zmpfmpwOsndbqrgx1XPpJjRrelGnCbabwHYx0mAEAcJsaC3QI0AcL4a1lnoKnzuolz1lEj3ZLEYSKALpKDYlKkiN8kdj2a49DmoqpEMCEUS4vDxIrjNHUqFARBEARBEARh24hgQrguTPWv2jqP/ZdOl9ed2uMDRg4TYzYKsT7ZjfyMDq+t4o9HKQUsyhV2KF01rfQ3Co1Nc3/FSI7TPejjne2kA1i1gI+Xs43kKMlhwndtp8XJGU+ZdEenf6uP5FBaChMdkHDFd3gSQ9Ep0fl080OfBTkv8KXzyB4cJqrDyg4TzpLbCSZmH6fdR3IYK3gAAAAVcrGT+9ibdTxX+ngx7cRdUwUT5Krl1kQFzkEkglSJw4Sak+eda61vatAvrMOEeXw3/XWfEXtw5VmTXsc2k+cwofR496DoM953Pbw4MWeBc8LVIQELnRMZz02iSI7p63okEZ8f/yKYEAqjEf8KsOo4TeMFBUEQBEEQBEHYNLKyF64MU/2Dat6aOkyk3VVorNAiM5IDqmNehvBWKUwwgaltcXVY1RXhqjyFw8TpHaibl6PG/+Mv/134+Me+e/prmYvtRM/Y6F+bULhQMzvk+JPGDhOplTNeHgEAQN+9V8xxKI6kOOzxm5X9DhOgg8NE79zV4zARuY1s9TzpatXIBV/Yrg6LZL37Y17I9WZxfFa7K/63zDdxrIwK8wdz01KzHCZMEGMAlCk49M4lC0Zy6CrLuQTNxQsm8CQOE6PYw5y5Jt6xrSOSI0cQlPP9Y2QkhzhMMGieFMFEN1Ekx/SYKEC062/fuS/HWiiMNBKN/24NJJJDEARBEARBEHaFrOyF69KV9+1vT2wN040YTB0mRhQP6rO1iNZVOVEVK0HFtmI2UE0ddZkqfSiz4DMB3334cD3BhDndg7p5Mcph5ZMf/x748n/zb01/sfoMSh9Azck6XhpyqKHC/JKCiY45B88P1ur5cLufOJmFQbZZyCN4VFf0Ej0uieRQWvd34rP5uzH2x+a+F4xa2wWJ5l5dOceluQ4Tbg4s5XqzNEww0S38IdesxOY8XetMXHugK05ty2Hi1v08I5JD5UVygKlBVTegDrcSyTEWNi9vdc5ckz7HNkzj5gbIc5i48B+67+cEE3t3zhuDj+Rw52SRuLadgQ2HicnPBFHTg0RyCMXRjORIxfCLvpr/HinbqoIgCIIgCIKwB2RlL1yXhuo//QIbO0w0NnF9tyXleY+J5Dj7SI7duBt0gWU5TPjzRezJ5cMdY7w8WheTa7zk5WS7d6kQ1SM+QXOx722iQAVrF8mxQCf6YjCHicUiObzLQXckhzrcFuW0URxcdJI6TPRGcvDufMhzmNhhJAeodcdYKJg4IdTcohI9frfFKSoMQbfowTtMaHdXO9YjMdAiDhPkKlSgaMs7TNj3uIjDROZ1B+sLqOoA6vaVCCZGEq2v5drWxPQIwtK17RA56wd+v765VRwmAhTJocVhohMWG6CUmi6SckJCL04RwYRQGMj2mtQ1IjlMLe4SgiAIgiAIgrAjZHUvXJkkkiPdaDGxPX6jeGmM/QI8osPeP+ZyAlUdQa1cjCqB0BGHRWxiIW1iOpQ+lFnwmQLbyL5aLIe52GKnFxR1j2caC1OLR1jXQWhUyufGR/Ys6DDRmHOSlzw/gjrePY9In6nw/F6+aUgxBV0blbzYTP/2ddSy21K3j+jcbPQ8qeqw7hgzLDpBZ3bwt9DXgb0LxjhMRLEyXQ4TM0RnVJyiyKACHZqaDhPzBRNqQiQH6Ar07StAEUyMI5pPtzlnrgodkwUEEznrh+h+Yxwm5Nx5hwmJ5OjGjyvvMDF1/YxJ1IEca6E0yPnrSpEcuRFNgiAIgiAIgiAUjazuhavCVf/Rz3Q7FSQUdVOmGzFou1p8t+U4hwmoCiv8rgUvphQgmEg3lVV1KLLgMwU+lsyVYjn8pvAYhxWKZ5laPHKfG1Wqw8Scrm2O30R2BcnkbzXnB1BHcZjoA6Mue+4wMSRswXA/+nekw0RjHomKf4WM11x0tWpkER0zpQ/LOMeQy04p88PCIDDBRMc4xnRO8vcJ4lDbzTvXYWK8q9a18eOKRGfV0f48I5IDlM5zLjE1KH0ALQ4T4+HHd6ef4Tn42LW2SA6DefbrEx0m+uZWvJwa93+2OHF2cD2Q8dyAR3KAmifigysVogVhCsiac9T6DhNojG3KEQRBEARBEARhF4hgQrgyA5Ecabd3o90732EC6jOow01WhvBWGduZdi18gZ/Y0zlgx/d6DhO1tR0fMf7nO0ycncVxOeeMio7KOUwsURj31vnOTj7d/MXzA+jjHSi9cvf/lokiOfiywhaLuzYq6fxRkUPpgXPKb0vORWlz3xTWdjHxrhyusDS7qESP3+vnggpDAO54tTlMoL8duM05d55Q04tTiAaU0mzOL1Bw6MeVc5hQyrpMzLGoznRAwfoC4CI5xGFiJBLJ0Yv/rC3lMDEyEjC6BvYUo1EiOQJ0PuicbFU0uSKRw4Se7jCB3nnpClEHgjCFqDnnCsIeU4vDhCAIgiAIgiDsCFndC9eFigtdkRy08eKLA8mmF2KS5z3GYcJGcpRU+F2N0oqGaBqRHEUWfKYQOUy8vspLku34qPGPCwgmqiOA0uV07LNubtVlkT/1OXVHDNDFRnLY+WMnY3dpmMNEyAuGsFnZtVEZxRnArEiOXRT/dOU/t6tAHabVwb3WvM/1c4jkUN79pEP0kAojaE5KOxwnO0y44lRhkRyPv/S34Qv/xmfg8tGvM4eJY7jD4WZeASFX0OM6zK3DxLvpr/uMiOfTnX6G50AOEwsIJiAnEnDsOl4iOTw+/o/mnL1ek+ZAwlZl46OmCyadkNAfaxFMCKXR4jCxeiSHOEwIgiAIgiAIwl4QwYRwXZjqX3Hrdn87dSq3Fy+DPfV4hwm8XEBVx9W7d0uA/31FbICbOt5Urg6rWs5fk6jYcKVIDjC1tf0cM/5ps/80NZLjYiM51i7i5uDnj6Goh5znTFxtUsHE+QHU4fZZzB9TCZ2LcSSHzw8eEkyQyELp/mOMxnauAzTnkZE25iWztosJiUx8JMfca8TOIznI0QoA2h2x6D4AQSzkxnoUPzYn/sStecKaqIw56PTlL4J59xFcvv7LoXDrncEAVHUzy6JaZQp60FxA6QOo25dgpl7znhv8+BYyroqiRxCG6dp2CNfRPyqaB8ddy/AiDhMecrNTIpjohDlMKD1j/WyM+/5O0ZpyrIXCaHOYWDWSow7iWkEQBEEQBEEQNo+s7oUrM9B1ibHDRKN46TZqVJbDxFkcJp4INKnDxI6Kztxh4oqRHMAiOfrGs4/kmCjm4A4Txdgb++LkzK7t6ClZnARA4znx/MAcJnYydpemJ5IDepxAkBWbAVznY9+8hQbAdbGn9ubRpn0Bc98kdLWuoKzmBZMlIzk2erwHwSCY6HBKiYUR7D68m1fN6OYlhwkSyZUiOCRBXn2KhTgOtYDDRNZ86wqm+kYiOUbDPre7WZctiD8mHQ4TKmN8Z31n4ffpmVtRHCY8FP9HRUsp4jehcWXH4vSYKLouqmt07gvCFNJ1GcA4sdrk18t0HBIEQRAEQRAEoWhkdS9cF6+XaC+kIcbFy+amVxLJMaIrDusTwIGiBfa9sRjZ1JewYYhJrueOIjn4WJoqSsh+zfribIdH5NmTYGJWJMfBFlaL+dwwh4nFIjmoiOws7xuRHCdQx7vVu/83DRc+cOegQYcJF9FEc8RQV7nhDhPJuaBzo9Rmz9PagjJfMKkO+QXpnufbbcEOAYL7Scc4TmzOIY3kUMoJgabmxTuHCXJvKORY07nHy4lFcnDBxO28AoIvfI47bmguoKqDjeS4luPTxomudbsVPc3Ara9a52QzIZKj67kaz83cK/ocJuqe9/fcQOPFaQAg47kN5jABM65J9nGKjX8RTAhlgaw55xrCHpRIDkEQBEEQBEHYFSKYEK5LVzdmervvxmqL5FDe6nnURuHl7CM5dm87XJotvTF+oxjACWH2srnLjq95eL3+yyEC5aT6Tt4+hwnaTJ8hmAByZilhLAFzg1DKW1zPhp7TR3K0OEwcbpzDxD7EPkvj52GlY1taVyzuLHomDhNDbiaIBlR14x6anAsfrXIsZrxmM+IaVd9/AuZ0P+356ZhRJMfc42T2HcmB5O4A4MZofyRHPCcxN6053byuEEhzfjGCQ4pjuZziceVQh5vIXSoX1eEy1kl9AVAVqNtXk0WCzw6J5OjFX9faIjnQZDmo5DpMKOek1Dv+65O7j5w7H8mhh4Umz5bkWjX9uo1R576IU4TiIDH2lSI5QCI5BEEQBEEQBGFXyOpeuCoYFRHsb+I7kMPEIfo53J44TGRGcuy9Eyu28n36vxVNHdsWV/txmIgiOR6uUKDhnw09QjCE8xwmwFxYJMfTjyUL69oGxeaTGc9Ic0zHnGNYJMfe54/JRJEczGGCope6zlMayTG0iY/cYeKS3MScQja6gW9dTPrf+6/+J/8CfPW/+zOTnp87AShdzRY6+FiU3Ran0HcnKqXaz42Js7L9MfXzSiqkyH0LcSTHqpEtOXiHiccOh4mbRRwmxhWYg+hN30okx2jY53Zo3nmWDEVy5IzvjO8sUF+sKx70i9HwcnZvRdYl9ruGRHL0wSM51AyHtiAkvEIhWhAm0YzkWDU6RiI5BEEQBEEQBGFXyOpeuC5c9a9Us/PYO0y0dwnZTTAVIjvGCiao23HvG4t1aZEcsU2l0odyCj4z4WMPH9e3APfZ9boa1a1I7888vpv2esyZpZjNZ8MK7EotUxjHUGzjP/ubz4+gj3fPY/6YShTJETtM9EVy+CId7+IfEky4ztvG3O+LpsdQyN8auhqcHy8ffQkuH/3atOcnsZqqho/1qOdLxAF7g6zHAaArAohEW94O3o31sLZJhBTZ7yGO5CilOMojObocJuYUEEhoOaqQz15f376yIo5CjlPJRMdWjlcDP8bbxmBmgSzrOwsyh4k+x6X67O4j587G/1WjokyeLWkkx9T1s4/kUO5HEUwIhcHXX2p9YQ8aieQQBEEQBEEQhD0hggnhysTdmA37+6R42SaoUJo7TAxv+ODl5B0m9r6JxguFJXQMIs9iBnBd+k//vhaB4jFuXl4lkgNYd9gohwna7D/NieRYyLp/MRKb+yU2wHyx3x3TtkiO4y2oarj7/7kSIjn45iS3w+13mFA8kqOvo9Ywh4lGJIf7fByOG3aYGOFiUp8nu/T4DlP6XM89TvRZQdxn0SSK5OgQ/jCxkOJuKkwcqhZxmHBrIiqSPjVMMNHuMHE7K5LDr/FGXHuizumbl/Z3U2NrnhMSydGPj+RoOTYms6PYj+cRx3lkJIcIJgJojHO4Imeaba4B1oTPk/Z6Ni+SIzis7PDaL2wbTPaa+O9Web3ETVMQBEEQBEEQhE0jq3vhurSq/ltu79osp27LTIcJqI6g1DOw1Od/38JF7vrtN+A3/ut/LS/iAU1UNFH60Cx0bhQSg+i798A8rO8wEbrDDnkOE1PfW4FRNl6woHV3ATP7OVkR2f4ivp0iOZQ4THTiikfWOYgvK/odJhqRHEr3i1LQADjBBDYiOdzjqmNBAp9M9HD8DV5Ok116YpcaPftzjSteb8qAOUx0Rctw1xsuAsX099OODzrrf19ALUQwQeLWSDDBHCaq974J9ItPTX+BjEgO/3moDqCdYMKcpjkrPSskkqMXEqa1zZOIJq9AlvOdhQkmep1paonk8NAahJxpdnk9mknqBDZDxOcdlQBEnCIUSHOvaVVRrzFedC8IgiAIgiAIwvYRwUSBvPmZH4Kv/sC//9RvYx2Y6r81Q5U6jnsFEyozDzgUfvde8MQVIznu/98fh49/7Lvh8Zd+dvyDEocJVR0ahc7N4jKT9e17YK4RyWGoKMUdJnqOpY/kmOgwYS42kqNAhwk1VIjPwYswaM5JHCYuj1YwoavJnf27B42PUVJcCNfhJBQel0Qw6RGRHNRpn54LL3w5brb4p/RhME4EZzhMgLnEwpa5n2v++I0e814Qw9jsKjD5IlQyJ/EOx1nFKYrkcAXUQgQTwWHiMYggSdQBAJ/7I/8VfO6PfNfkp6fu5TGFz8hh4tY5TEyMonpWRJ/ffa+NJ0HHZJFIjgwBkKnDZ6nPYeJyGv+ce0ciOQbxwhrnMDE9Jgoh6twXhwmhNPhe01UiOcRhQhAEQRAEQRD2hKzuC+TNz/wgfPxj3/3Ub2MlEtV/S+QGAIQs7LTbG9FuiOV0a11O1sa9oE751WB/39IdVlR4zxE8ICa5niM6qDcDRXJc3WGiCp28vQ4TrgN4qmCiRKERjWnturYXjORQXXPO+cHZy+9o7C4MmjqO1SB8F2L7efIRTGMjOWg+aRmTIc5pyw4T1aB7BF5Ok116bOeyG+cLCyb22NFr/ybabG8vMKGP3nBdu36sp2udecUpiqLxRdKnhq4vl3NrJMfhw98Chw9/y/Tnz4jk8J8HfQB9Sw4T0657zwkuLBsSaj1H/PeFtmOTKZiY6jDRJ0RDcZjw+IKlCCa64cKy6FqVi3NeokK06CWEwsAoksP/csUXzLweCIIgCIIgCIJQNLK6LxE0++nCT4m6LpuCCV/08puLTYcJBYo5UIyL5FDV0T5m5xuLUefxwh2/6CyuszpceSEVXAf1Trr0qUis796/imAiREdU4xxW3HGe4jCBiLZwWx0AlC6nGMoifZTWi1ishkL7IfrZ/j+GSI7nILiaSiSMih0mlFLd5ymJ5AA1EBNhXDyBbnGqYZE1m53nR4wxrM+Al4lzaH3xYkSlq9mf6+i9bvWY94HouxNVl6MNF3EpFYRq7PdKzZiraCO+MIcJKrDbSA77nngkx2wyCp8hEqQCdSMOE6PZu0PMXMhFpS2SwzmMjUWpDFe8kZEcfi7Y49ybi6mtJb6P8pHx3IC7qSk1/RiRw4Sfo0UxIZQGcyMEWM6RsPPlkuYQQRAEQRAEQRA2jQgmSsTUxeRUL02s+m+L5CCHia5IDmeRnbH5iPXZFht0tVmr9tHwCIzFHSZcASJHzNNwmNiRaMX9bfr2FeAVIzmsw8RwtyLdNqnT1ncMu0iOUs6Znz+cw8QSYzzKdU421agQeLyzxcBSjkNp8O6qyJZ2IJKD5mNflB6O5ACtrZAnFV5Rp//hWI7AJ5MhUZ8VMk2P5LAxO8xhYu71kB/njR7zfpAZTAwIJiCJGUO2YT/DYQKdaMN3nJeyNqSxUzPHk2o5wYSP5BizxiPhbFWBviGHCRFMDCKCiV782FsgkoPWwZev/zJ86Tv/IJj7172vq8ZEcpDDhLiDOPcp7W3xt7oGWJPI0WuGwwQCRlEHcqyF4mg4TCzkSNj1cklziCAIgiAIgiAI20ZW9wWCpt5NF36TRPXfKEAMCSZcnvdIe1sqMKnDzTNxmBi30TrpuX0kx/iCTbqJoKp9OUyArkBfOZJDqbEOE6478mGCw4QJggnQVTHF0LDh2xHpMwU6hrSJzP5Wc36wNx1uneBqH2N3aeLPeXCY8OdpIJIjiC0GxpqLZFK6ajhMBAeW7UZyWAeens80/c1THajqS5g7tB7l0NTLihFQRYDOehwAOjfcuYiLz0mRm9YM+3Na81AkRyGCCRqn1mGCHB4WdJjQGZ3i7PW9w4QIJgaJ3ZR2+PmdC43xtnnS5Akm6DvL27/zV+HNT/0APP7q3+t/3cOIdbw4TARMbdfGEsnRDYv1425I2SAGIaD9xSJvTxCWIxFMXMNhQgQTgiAIgiAIgrAbZHVfIqYuZlN8cZJIDmw4TFAkR9Me3/+s1LiCMUDUKW+LoTvfWDSXUFhZeBOVOjazisYNh4nD9GJfaUSRHN3dgku+HgAAVIc8h4kpkRzkrFAdbfRFKd2nqcPEAhu1/m/TTYcJdIIJfbx7FoKrybDPuVJBMNEVvcQe6O7GIzl6OmrRRnK0xm74CIQNO4HoqumcwQiZ9RMdJrAORe2BYz3q+fjjS5kjloSsxwGcwKQ5jkOMmI7FQamQYnJxygkmyKL/Usja0EdyPK7iMOEFE2MiOVghUN++AgDmiCV0E31+NzpnrkhwmGiJ5EDj3QxG4a6Ppy9/0T6+T9CDXPjcvcYJ14Mdzr2ZkIBZBBPd8HlSzRLxSSSHUDgsvtH+s67DhERyCIIgCIIgCMK+EMFEgaCpAerL9MzrookFE42NljSSI90IRHQZ9uPsmuPC73A+/NZBU/us87UcJrIswXlECMC+zoGP5HgPzDUiOVhOe47DxBTBhD/H1dHG35SyIe8dCRZ0mGA2xUrpuOv2/GhvO97uK05mYZB/zqMuq47oJcJHcmj3z0Akh6HicYtTDZ3HaruRHDAwP+LlZP9njsOEK2oPxp+MIYrk2ONnI3aYaB1XUaQPE1Us5jDh7M9JMFGKmHZlh4mcSA4SbCh9AHVLDhMTrnvPDVbk2c26bEkWjOQgkev5N6xgok/Qg/UlfN77IjnoeiDnzgqYvRBARCStuGu0cg4T06//dF0kp0g51kJhROJ6ALt+k0gOQRAEQRAEQRDGIav7EqHNrz1uQjDVv2LW7eFmKnrRxnubAwV1fA4XMLlgArTe/8Yij+RYeMPQO0xkFOtsF17iMLGTWAOkDdorR3KAroIDS9+xpILWhMIRdTGrqnKd1RhC698AACAASURBVKXMRUnX9iJPSc4EVVzwhOAwoY63rki/8/ljKu6zAADxeRkStniBHBNb9EZy2Jxy0If+SI6NFkuGXEx8R/HEojmaSzhPC0Tt8M/DHgtUyB0musYxF3FBuE9wz1JWiDXh+NAGv1IawDlHZQkWV4T+Hryc2GdvSYeJjli21vfCHCZcJIc4TAxj12funBVzjS8HHzvTJgbLtWAnwcQYh4kR63hEZIIOWZcAOUxkONM8O0yHuC8X7zDRFa0pCE8LJpEcau1IDiMOE4IgCIIgCIKwJ0QwUSAhG7qMjfFFwXEOE76oY1pu19rfZ9BhgjqwDjeD3bt7AGsWybHwhiE5FWQV61KHiapZ6Nws7m/Td+8D1Ocw1lYCfXfYoduBhd/fiSkmRXKYEGVjIznK+Nz4oqMK3W1zu4aQOUykXXd4IYeJO+e0sZOxuzRUrABodZjoOkdhjqKidL9ggiI5VFt0BZ3Hw5YjOfpFOVjbOWZyJEd9saI1ABvJsajDxB4LVOi7BlWXU0oSveGPaVdUR9bLh/VSiORY9zozGh/JcQqOJws6TGRZ6/votQOoG3KYuF/uvewVNAAHKsxvdM5cE5pnW9ZZaKYJJsz9x/bfnnUZmjqcl67xz9bhpazPnhIf1yWRHJ14YZsXB0+NiYoFE/t0wxQ2jRebBoewyS5fo16uDmItQRAEQRAEQRA2j6zuS8R3De2xOMdzJVu+wPIcemgp+iOGDbExFvneYeIASs3vqC0e3pm2dCQHdcSNFDwgohO4cIeJHYlWKJLj7j0AADAPr9d9PV+UqrygqPdYkvBqdiRHeQ4TPJZndtcQHUPfdccjOchh4m5fcTILg8xhQiUOE6qvWMyLygDDnfhoXPG4RVhAP284kqNVCMIhEeVU0ZmpvQuAUgs4Lu1dMGHMoMNEEFypuIuRZ2hPnUNZ3IcVXuhiIjmCsPcxCOyoyLsAOZEcXkDEHSb6OvgFizGjoh+eK37soWkWhdGENcgIVNJ9bPoEPSPW8dE8IOuSINqkeUPGcxNyStEVKDU9ogCd02OIIBDBhFAYqRgbYHWHCYnkEARBEARBEIT9IKv7AqFO8t104jMw12Ei2fSyXUQhkqPVKpffP4rk2H/BE01wmFi6gOUdJsYKeZJiqP3/nUVyKA369hUAwOqxHFF3mHeY6OlG5xnzmW41xX5uWhwmZo9zL9LSjTnJCyYOt+MEWs+VLoeJsZEcXgQ3UFimrt6WeYSEFqo6brd4P/BZ85EcUx0mzCVY8C8QtRNFcmz1mPdCWe3QbWEedZozcVCy1pkUWcIEEwB2bJcimAB2fXlyhwl/bTxY0UZ17Iw8ePylvw31m68v9S63DY/kkGtbE35MGuLtTIcJFQsm+iI5EOtBIQtf0xWzPntC0K1BfNFyhxFRc8EecXDmMyWRHHKshafB3L+GL/7Jz8Hbv/fD8Q18/UX/rimYQInkEARBEARBEIQ9IYKJEqGN6FI2xpcktUls6doCgLDx3uMwodRwAdMXfg83g/nwu8DUPut86Ux5dJngo4U8fnMucZjYixDIbZCoa3W0+pz2EMkxxmECID+WA7nFeYEOE2R/b381M5KD5TqrJKaAR3KIw0Q33GECmMOEIiehTsFEXBAeE8kBWrdH+1BkTXXc7Dw/dI3ykRxT59D6EglbMI28yoWfq40e817IehygEdcT7tPhQoHxvDKlCxeT9ZI63JSzLnR/H15OLMJpQcHEiNgp/1aY+xIAgL552XnN+5X/+J+Db/xv/+kib3HrIBrrIgVSdG+FH5NkHGISNzdEw2Gib03GHSY6xj9dC9wPo9/HbqE1iM4QWj03nGOSGhKyDoHorknLrMEFYSqXj74E9euvwulXfi65pUUwsWYkR25EkyAIgiAIgiAIRSOr+xKhjZ6ddOLHcJvq5hdYTBwmGkV/ZwUKAKM63ynvmzrld1nUcUQd1vYXiz6/yY3koPfDHSaqw27OARWJvaPHyoUsX5RikRx9G+X8s2FOmbEcaSRHKefMFyHZZu3cTTDvhEK5zsxhgs8fOxq7i4MDDhMd58jPEV4Ep/vndMopb5nLw3xz2K7bwcAY813FE+caO2e5SA69QERVT0FxFySCCWwdxywmjAkjGm5aCzhMQHX0c9JT4x2M6lMQcSxYMKB1w5CLmHsT9jEUN3P7Esxju4DR3H+yfnzWVkDT6eYmxE4+jesSP3ZjSO6LHePTR9llRHKI2CU4TGQ50zw30nXa1GOEznnJH2sRTAhPQ33/sf337TfiG3gkGv27ssOERHIIgiAIgiAIwn6Q1X2BUOFnN534nMgmsSVD1TtMdGziIvoOIqWr4eI9K/zuvkPc54ivE8mBFMkxtljH8nIJpQ+T7eSLw3UYeuvktQtZhh1PV/TsnSOwtlESEM7dWBqRHE+w+WzOj43fhY7r4DAxNYc5PCkrSiZd5N5p43AEpar9jN2Fsd229DlnmcH+mA45TPDYg56x5mzQW+cRU9vnWUII8EQMjTHvMDF1HJqLFWUAzLTkdu+Hf1Y2esz7QBbJoTo23JFnV0fRGxgeN9FhIrWVVtVxdWHeaNJIjuoQnMOWIMNa38/T7rqob152Rh5gfd73OjAHH3G0bzHxZKJIjuT4ZHYUe3FFdQT98sNuRzITi38651Ues7bhc4eI8O4f/I1F1nHKu/ns83o0FxsjGNZp049RHMkhx1p4Ksz9J/bfdx9Fv0dsOky0C14XQiI5BEEQBEEQBGFXiGCiRPYcyQFJ12Xj5thhIi3oIFfxV4dhh4mk8LvljcUh0G+0rmOx7Dd4xxbrTNIdC7Cvc0CRHBSBsrrDRNhI95+PXvv+C+gXn7J3myGYUE/gMPHwiz8NX/jjn4Lz134peWM0H6juWJ9M0lznqAhsWCFuT2N3aVgkB3eUCU4gIyM5dNVfIKUiVXVoiuVow7IkR5RchsYYzTETxZRYX1h0ygJRO/xc7bFo0ojkaBnHPJKDj3Uv/mwKsca/fvz5KCmSA5lgAs3FixUWI8f5wMTiTHXzsrUgjcbY59ujGHkCiAaU1lZMvMfP70yiNXSb253O+ArtxubxM78V9N373YKeZB2/d4eJh8//BPzKf/i74fEXf3reE6UOE3t0PJoLHSNw67QZkRxLrsEFYSrmnXOYSAQTXrAaRXKsR25EkyAIgiAIgiAIZSOr+wLxm1977GZmNomqzaqdNgepC7bhMGF8A7PNe+8/Rt5S/3DzDBwmxm20Tn76TIcJv/HLHSaq/ThM+EiOqzlMsJx2H1nTM55NDfrlB/Z+2YIJlkn/BB3756/8AkB9gcs3vpS8MTdfaA2LR3Iobeckvvlbh2O++/ljBsg24iOHCRe91Nk96rvAyDVI9xbufIGvxYnBdk+64t9GiyVDY4wiOaY7TNTenUZpNX88RwXFPX42kG24d7hEYIjkiOYPbgmt9KQOamQCMQB7bS8lkoPmTe4wsSS+U3zEuPLCNvce9O2r9oI0iTx2sgaZjXPs2bTIbE3YMUnHYSTeHgGtg4+f/TbQt6+6Raz0OrSO77iWRevwDZ+7y+uvAACAcdb6U/FrEBKxiACoAV5OwYEQJor4iCVj8QRhIuah3WEijeTocghbDPfdRBAEQRAEQRCEfSCr+xLZscMEJpEczS+w1BVQxfcPTxCKE9Vwt2XDYWJMHvZG8fEMh3UEEyGSY2SxIe0eB7DFur10d1IkBzlMrFzI4gIURQ4tfcVVU4O+cw4TD2/yXoxH2Sh99QI0ujiOxuebFxD9xvjMTTDDO8HjrvtwzA+2ILjhwsSqMIcJ3nWrlOrdqKSCsN9oHBnJYc9FW8evK5hstVjixlhXcd1Hckx1mOAFE6Vnd+HuPZLDZ7UDuPm25W/kneZtggn/GZjiMEGOW+SqdSxmXbi6w4QaX/j0nwfFHCYe2xwm3P1kHrfQfCruSa1EIolW8Xa+w8ThM98Gqi8yxot/nBC3y2GCrzc3fO7QrU1nr59JwCyRHJ3Y67+N6YOJDhPIRa5LrcEFYSLmnRNMpIKrlkiOVcepOEwIgiAIgiAIwq6Q1X2B+E26vRSWI5hNYssXWF+Y7XOYoI6BEfbUyAq/oPS+O8QxjeRYbsMQjQE8P7iXyXOY4LmeyjsjbH8zE6lAS8d77UKWP57uszEkADL1IpEcTyE0wosVTEByTLHNYWLmxrjfWCc7Zz4nUYHNxaBIZ3IHXQ4TPnppZCTHSMGE0oemaIA2LDc8z3dFURHkMAH1eZpjARdMLGHDzx+/xwIVE2h2RcvEneb8PklhacpmfUskRzonPhn0GbucbNTLwg4T3kUpI5LDO0zcvGgtSNN1bargaHcYmk8lkqMVdr1vXFPMNMHE8bP/COjbl2BO9x2vOdIpbieRHObRCSbmzmvcLYV+FiLw8hg5TEz6zCP7Dr/QGlwQpkIOE12RHOH7SM/3kAXA3IgmQRAEQRAEQRCKRlb3JbJn2+AOR4n0567CESKGL6WHm+GuJCr8ukiOLXdiDRFiFNyG2IKbWFHxIdNhIrKppGL/HsY2dbTRBuTaDhN0fimDWA3Y92MN+sX79v9PMwQTC3Si5zLkMKGACvEwv2uIRXJYERfrmvfH/GC7l3c8f8wBucNElBXcLoxjD4wf4wQrnQ4LxtiO/ZZoHxvXYaNTNruB7zrku8YZOUzYH/L/Rl4wUUPilDFEkRwbPeZ9oIk6FFvHJRNxcmEEiQJ9YWlGcYreQ1GRHN5h4tFez6nAuxBehDJiXCGPqwIAddvuMOHXLjt2GsuBIo4kkqMdNHUQb7dFcmQUyGhdfvysc5gYiOTw68ou8dxOIjnMg3Oumzmv+TVIxrzx3MDLI6ijdZhQqTh4/LOAewJ/XZoi3hSEJTDvPnb/dkRyXM1hwnhnVEEQBEEQBEEQto8IJkrEb0QX0km4JIisoNbyBdbb43c4EbBuTlUdB4vUtAlHnfJb7sQaxG+0Lh/JYZhgYnQnGB1r1oVHHaC76PCk7syrO0y4TZmhiAhTg37xgf3fTIcJX1jS5KzwNA4TTcEE69p2RUqc2zVEc4zSNn6Ef254IU5XvcX8Zw0Gh4ko170zesk9jB17+8+AxTPN/1o3hVvMYWKrgongwNPxeeNdxRPm0MiSe4HjFEVy7PDaimy9orqcUriIM+raZR2OSzlMlBTJ4d4bksPE0pEcfi4YMa54dBIA6I7IAxJW7GL9sQQskkMcJlowdbcAOTOS4/Zb/3H4zf/Kd8J7/+QfcA4TXZEcicOE6YpnYteCDQuAjI/6mzmvkcuVlkiOLuLr/0wRHyh3TQRYs3NfEPqo7wccJq4ZySEOE4IgCIIgCIKwG2R1XyB+82sPXfgNkkzw1tvBFb5aNnRYpnhOJIeqjlb9v+NNtMZG65IOE6zgPtb5hDYsFYvk8MX+HRTXfEe76wRcu/MXk6KQ0lV/4cfUUHnBRPvmfOdreWeWoyv2XdthoiP+hXUNqYUcJpAXJZNNteDacgjjeAdjd2nQGOYwwW4YiuTgEU0Aw3baPJIDmx2/FKuy2eJ9RzczEYkoJ6wPIkvuJY4Tf/wur61o3WwAmnE9dA9eOOXzB4sPUhPtz/011K95juUU+0nYW58AzPKRHDnxXf6YuPegbjoK0nS/Xa6tJ0DzaeIwYU738NXv/7PZ64a9gaZmEXdpJEdeZr3SGj78Pf866JsXzmGi49jS69Drdlw79+IwgRTJMddhAp3jm0RydILn+Po/TcTXUojOdPPA+gK1cwYQhDmYezuO8OFNtDZCJuyhf2eL63vATAGdIAiCIAiCIAhlI6v7EvEb0Tvc1OUOEy2CiVC87LCxZjmRqroZdOGIogV2HsnhiwCuI25MoWH0U0+J5GhzmHDF/l3EzbgNc+pAXN9hIrYdHxrPWF9CJEemw0QayXHtArRxkRzQ5zCxdCSHbnEn8I43h+COsrM55PyVX4R3P/+j857E1CFOIto0HIjkSHPgRwomoDq0OkwopTcdyTHkMMEjOSY7TJAl9xJCKP74jR7zXhqOWC1/Ixov+FE8J9vfV80vTmn3Hqqb5pz4RNAYJYcJWNphIqfw6cWE9vOjb1+1XvPoura3OXwqaMixJ15LPHzhJ+Hr//NfgPsv/OQTvrsCqC+hwMyODxXjIjFwBrpL0AMZwmfuMLHh8WwerGBi9rxGaxARTHRiBZMzHSagWYjOdZj46K/9Z/CL/94/Jm5twmyMc5iw/89EOJiKsVd2mEAz+XogCIIgCIIgCEJ5iGCiQKjQXYr18rIkBQiAeNPEf8nVrZ3tyPLC1eEQZ7q3vRp1LR1uniRa4Jr4jdaB7OMp8EiH0eOSXn+nDhNAHe0HiuS4lsNE5f/tsmJGRPv+qiOo413YlB77WtyZ5QkK0D6SIxFE+Y5rpVihfalIjgrS+AgS9qjqwMbuDsQ+jG/8r38Rfu2//JdmPQeSHTZALIRTynbXd50jJoCzd9fh+VrvbnPjlT40RVckpki6pTfFwBiL5t4J6wO8PAaLeVXNznnnorx9WqAnAs+2DXfEVocJ5J24k+3P00iOw+pORqOJBBPnxR0m/DEd8Vn2c4EODhN4fmiIRv399ihGnoKbf1USyUE256WIc54KxDo4iLWJwyZ2FKsOQQ8ABPGPj+RonzeieWCr1zsAMN5hYvpYs+tdF43k5409Xo/mgZezF0wopSd13GObw0RmIfry9V+G+qNfA8z8XiIIKVwwEcdyxOO0M1JtsTeS5zgkCIIgCIIgCELZyOq+RHYcyYE8UqOtQzzKR9VNlwREn3NvHSYGigfPymHiOpEcY8elL/Bzh4nKdVDvoGCBprbFWypAXlb+m7xVsytMqZ7xzOJQ1O0rMKc8hwlfUNKHJylAd0ZypJE9AMt1yWsNSuuoMOIjOfTBOyjsTXRlHl774z39SeowL/PP+4DDBBfAAUAQTww5TOiqUfT0oo3kHG4JNTDGeFFpssMECeoWcZhg73NnnwsAAB4B1h4hBmFMAiROEqzDcSH7c1UdyxHSurGDl0e7JljYYcK7rYwZo36eJoeJl/ax5/vW++1tDp9Mh8iMilDFjLWnwtStDhNBZDntKzQ5TLR12JMIdmgdjztzmJg11vh6160hrrkGOH/lF+Hzf/QVfPIT33u115yCdZhw40rpaaKSRue+htxCNH1vr998Nf/1BYFh7j/xIiDDBRMtkRxrOkxQRKcgCIIgCIIgCPtABBMlsvNIDtWI5GgRTLTZ4wO4n93jDjeDm2xpJMeWNxaH8N3w1BG34N/Ks6znOUzsMZLjWg4T7vyqEMnReY7p9/rQaU/e+1rp5+apHCbSseYLFS6yB2D2Jlgk7GlEcoQYFLUndxSGOd/PLoxh1F0VO0z0blSiiQQWPtajayPfFfhUdWiOfXTuEws4JzwZeqCrPiqSTRVMsA7TuZ9rfpw3KlLpJY3kAGgUOZHHyvAuRmOC0GGiiCc46jgx0og1z7VIIzlWc5gYcdy801IVHCYA4nWLfSr3mdnZHD4V5AI0dpzN/Wt7+4yu/63jXQuqtkgOFuM1AXXz0j5f22eZXudwiF6r8f74Yzc8ntGJeWc55/j4vyeK5NCVdbQp/PPSiOSY1HEfF6KVUtnxj/RdqX7ztQmvLwgBc/8xHD7zrfb/2wQT14rkEIcJQRAEQRAEQdgVsrovEL8RXcjG+LKwjk3/q3aHidauTGZ/rQ43AAObbL5D/OCiBTa8sTjImg4TJx7JkecwwTcR9lR0po4SL1BZ+/PqRRAukqM6dB5HHt+hb9+LIlXGEH1u2oRLK+MdDxpjjc8P7QXM/Bdj3aLJplrIEz8EZ48djF0OnuYLJqzDBAl5uABC92/Mk422v3t/d2go8B2aTjeUYa63G8lBRedOh4kokmOKYOIxdEwv4BwTubFsVaTSC3PE8u4n6ZrERCLQcEz4Wmdicco/F3OYKCySA0xtBW4LO0zkRHJATaI35zBx8wIAAPCUCCZcQXOrYuTLJ1+G89d/ZbknNFawZt3cxGEiwkfcOUHsgpEc+vaVfYmWdRmOXcfTuelZB24B8zBfMBHF1T2BYCJct8ueVyKHqckOE1y0DDDl2uYdJl6Lw4QwD3P/CRw/8w8DAED9tiWSY+4abCzcaUwQBEEQBEEQhM0zeXWvlPpWpdRfV0r9vFLq55RSf8r9/puUUv+7Uurz7t9PL/d2nwl+I7rszZc+7j//E/Cl7/yDrZEaacdmVKDknVttluEs835M8YAKr+p457voZhdYC8VvGnoL4eU2DKlTU9+9n+0wwW0qt7KxOAoXAeAdJlYuZEXFe7DHtbPww8QV6vZVtmCCO1Q8RZQNntsdJvx8orWNe7C/nflizAml02HiEIr5Gy22dYHne4D6Mm9epDgMAGg4TPR1dqWbjEPFDuNcJFrGPvLbtup2QMewY4zxOSZ3DkVTW2HLkTpMFxBC8Xlhg8f8o7/+l+Br/+N/0Hk7jSlLVwQQE3FyNxUuBpppf+6fpzq2d6U/AbzAjqeH5R0maL4dcdzSa6MvSCeCCT+f4zYLzF/5vj8Nv/6X/tByT0jr6eQabx6sw0QpY+0p8KLRFoeJuYIJdWsFPY3xCRDiZUgw0TH+Sfyjjnebds4zj8tFcoDW3o3nqgI+EovVZZ8HvDyy67+atk5aoHM/RHKIw4QwHTQ1mIfXcPjMbwWA2GECr+wwYdeKEskhCIIgCIIgCHthjhz6AgD/NiJ+BwD8UwDwbyqlvgMA/gwA/AgifjsA/Ij7WcggWB1vd7Py3c/9CLz5qR9oRgFwwURbJAfrCmizDEc0vlA6xp6aCv3q+CJ8md1gYWcUVGSrWjriZoIkmHj5wfjO5haHibCxuP2is48hIBHI2p2/dRBB+H87Cj/IMt1tJEfLxnwPPv5DV8tY92fSGcnh5gfFHCbmR3Jw2/vEYaK+ACjlBFyVe7myN8VzMSfn5jGj6IJogvNJ5DDRH8mBjUiOAcEEc5hoCAboPTyBI8pSqIExFuXWZxaYaH6iAqDSenZRKZoXNli0e/szPwSvf/p/6LkHc4nomm/SSA53O/L4MKWmjcmkMFtSJEcU4fD4NhR4FyJrvcaEbQAhkiNdf9J1cauit/rt16F+/ZXlntA5tqUiM/MgDhO0tvIF5mium+kw4cdnc12WOkx0R3LY+Vwf7zYrAAIAMA9WMAEzIu2Cm10VxGXiMNEAz49RJNcksTEmnfttTpBDT+HW9yKYEOZAc8fxNzmHiXcfhxtbBBOrNstgHbvrCYIgCIIgCIKwaSav7hHx1xDx/3b//xoA/j4AfAsA/H4A+B53t+8BgD8w900+O0gwUfjmSx/1228AQFfBM3GY4PCNyLbCF+vaVNXNCIeJe1DHO1vEy7F43iCjrXwnYFwkh37xwehNdF+I5g4TVBDcwzmgSA6lAKrj6sUFKqL646mq7uOIQVyhb1/6Lr7RPLnDBEVyJMeUd1yr5HeTX4x1J+pEHGIuQQig9hMnw8HTvf13ThGRR3JE8zoJWzrOkTFMOAcjukNdga/NhpwETAtETTwZA2Msut5lni8vmKACoHNcmgV3GdigSAXNpX+stDliJWPZRjNxF4rgMBGiOihqJrOw5O5Pz2NdtQopYkcOE++eNJIjsuQHAH1rC9JdDhNbXX9gffEi4EWejwRryZwpkRwtwoWWuU5NLJAp54CSRsbYX7rXGVjHe1Hs8cVmxzMAAJLDxJx57akjOdzcV7oQK47kUJNcjxDaOvfznkccJoQlMPdWIHH48JsBlAbz7hvsViaud/83SSA0EuTCWUEQBEEQBEEQNs8iq3ul1LcBwD8BAP8XAHwOEX/N3fTrAPC5jsf8MaXUTymlfuorX1mwY2oH+M2vwjdf+iBrxGYXcNNhIi4isM2YNhtr1rVpuy0HBBOP70C5POtdFevbIFcA2hBbUjBBDhMvPjW+GOmL9i0OExsWA3lYDIE63ACs7TDBRQzgxnNXYZU2kBVFcmQ6TDCHisl28jPodJjwY1qxzam5DhPMCSURaWF98Zvh5CSy2WJ8B3i2gok59uvIIznYpqFSClRfZ1cayaG7Yg/o17bAp/ShGclBAibv0rC96KXQqdoxxrjDRG4kh/tMeYv5JZw4+OO3KJioLwNFrqH1CkRrEhsjhuyxTtw51Q0ndZiojoNrnmvBx6g5vQNVLWtH7cVTY8aVd9dKHSbi656/nmx1/VGf24vsU6EiTyKe8oKJUsQ5T4GPuDtGPwNA43OZCzlMtEWljRU+80iOLa9J6BjMmtdYBN1UwcTpy1+Ez//xD+D065/Pf/1qG99r8BIcJmAxhwkVRBSj3wcJJr6a//qC4KDrlH75IeiXH0LNIjlShwm1ciRHLBoXBEEQBEEQBGHrzBZMKKXeA4AfAIA/jYif8NvQ7iy3fkNBxO9CxN+BiL/js5/97Ny3sS/IYWLD3V3+i2ta1GIFiLYiQmSP35axihgXDwaK1Ob0zm9O+oLehjcX+8Bkg3fJDF98fAvq5oV19Rg7Lr1byD4dJtDUvqijruEwwUUMAAC6x2HCBLGKqo75G7nMocK6LlzbYcIJJtKCjd8E06yAuUzRVykVWeoDgD2OFROoQPldhLkYcpiYs9mPbLOQOUbYTfWeDkQ2n9u7j4jkoHiU9P1yh4m+5ygZOoYdYyyaYyY7TLhIDqVnz8OxG8sGj3d9gV47ewyOWD46piGYQCYKZPMHd0+ZKu7iAjGAwiI5YocJtbTDREYkB4+QAmAF6VMqmNh2JAdezmBI4LbIExrnrBSvJUJMQiFj7Qnw6y0nMGuNH5oomFAd45M/d3C26Bj/dRBMbHU9jaZmDlczBZsAPkLO/i7venT+yi8APryB81d/Ifv1t+MwwQUTEwvIqevRlEgOd67FYUKYAzlM6Befgurlh75Rx9LihLKiw0RD/C0IgiAIgiAIwqaZtbpXSh3BiiW+DxH/e/fr31BKfbO7/ZsB4Mvz3uIzxG3MbXUTDKDfYUI10tn2dgAAIABJREFUIjnaHSZUSwdsZH99uBnc0MXTO785SYX7LR/XXlaN5LDHUR2and1dhE1MNs1QJ1bhG4ujQBM5TAyJd2bDu+gA2mMJ/Fur/X3auvGHwPpiP4Na28/NlYuh5tzuMOGLFsoV4u0v570YO4+g4kgONMxhYqeCqyUKFlas0HSYgDYRCn/tKM4gPLZTBOM2JVXV7jARdZhu8TwNCMr4HDPZYeKwoMMEiVRgm9dVrM+9cyO2OGI1Y8LYRnkk8mTxY/TY3HmURxABWJv+Qrr+eUHSPL4L1/alyPkcp+5LXZEH9JnZ4FgFcOP18d1i7jnXjOQw50d/Xd8EdDxovmyN5JjWUUyRMa1uIZFbQrfYEOvtO0xwh41Z62e+LtQTBZPueE56H35tWPb3Gh7JERx8cueSpBDdJ4jtegY3D9SvRTAhTMc7TLz4AHQqmEidUGBdhwnk3yMFQRAEQRAEQdg8kwUTyrYX/GUA+PuI+BfZTT8IAH/Y/f8fBoD/afrbe57sIZKDHCaalvptBQj2JZZb3bYVdNJIjsupd8PHnO59t6HK6FjcIrhiJAc+vgV9+8oWJMZuCtLra+4wQZbz2x3bHlYsnNL5e//5n8zanA0ClFDA7zyOfNO9yjhn/PHeycJ+Dq8ZcUDF3YYgyne36ek2940XCwVPlWyqYX3xMQkh6mGbxYkuKJJjbocnHR/FHSa8sGVcJIcaKJL6Ap9uEQs5x5fgYrO9eT5cozr+fh7JMdVhgjpM9TKRHPT52OJ1Fc1loNjYInpIxjLyNQnvYuTOExMdJnxhtsBIDi7+WMNhIieSI7gv2cd0RR54h4mNrj+wPtvP2VJCBnQuKLqKjrN5WF4w8fGP/OfwhT/6Eup3Hy/2nGtC13laT0eCMMMK9BPQN1bQ0xvJQeK/PsGEUnbtucFrHQAAkpMJwPxIMIBZkRx0fZwy5q2wWBUtGkRT2zXSkTlM2Bsyn6gZyZHvMGGPtRGHCWEGdC3RLz7lIjnYtQVbHCbWjuQQhwlBEARBEARB2A1zVvf/NAD8IQD4PUqpn3X//fMA8BcA4PcppT4PAP+s+1nIYQeRHKYjkiMqQES/o/9lX3KjPHB2uw7Fg/bXYHc/vQN188L+sNMOcQ/9Xd7Kd7m/0zjBRE70hH99vomwo3OAxoQi8Yh4GM7l49+AX/7zvwte/63vH/+CVOTxhelq2GFCV9McJkztC2ChiHtFwcT5wf7bEEy0OEzMtFlFY8JGV1pENhfmnLCfscuhSI5ZAj0usEkjOfo2KlmxGQBCgbmrAGSYw0TDvch1eE3tMC0BLygbdpjILjDRY32HaTW70IYG/fVmk8f7cu4vniMyAVCHQAuRuaSEsY5ovJsWPUf28U5zuA9HAMQyCnOpqGdphwm/VhhxzLCOXp9cxcg9J9zNfWZKOH5TcO/fPLY4E0yB5tNrOEw82uK4vntvsedclT7HNi8GnhjJQQ4TbecxLf53CSYuJ1DV0a7PNjqeaUwAzHSYaIvkmCiYmCzcyBGTPwHk6hAiOToipoafyf7jxYATBBPuWNdvvpr52oIQIGFf9eIDqF5+EDlMICTCnj7h9hJIJIcgCIIgCIIg7IrJO5yI+OPQrHwTv3fq8wqsg7ngzZchzNtvAEBLJ1+Gw4RK7PHD7cFhAsB2q6jDsf19nO795rkasDvfOiGGYQWHCYrkaLHC73lD9v1wh4lqG1m/o0BWJK6G42E45vENACKYtx8N35leLo040T1RGfS5U9ZhIrvwYS5RTIV7AzAzxWk02BHJ4Te8lG6fP6Zg6rgTPIrkqIPDRNVfzN4iaOpgRb2Qw0RrJEfn40xcdBoTyaG1G/s1ICtoIzm+bDiSwx/DrvmRO0xkrg8MRXLQ9WEJhwlTW7EY5Beo1gQvJ/iN7/0T8Jnf/+fg+Jnf2n2/IYcJxChuw/8ufpL4PsgcJvxaZ5rDROS4BeHc4eUM6uZp7Z/TeXBph4kc4RPWl+j1KfKgISxwn5mtrj9ojsbTO4BXH85/vmg+5Q4Tr+3/LCmYeHgD6ubF5BiLq0Prrb5IjokFMu+Akgh6ABKxq9LdIqv6bMVqulr0PF2TpSI5Wh0mMsVp3mFiYuRR1nejJyA4TLnx7AWAcx0mNCtOj8QLJr4WreEEIQfzjiI5PtUZyaHYftOaLok2XnAj1zZBEARBEARBEAYROXSJeIeJcjdf+sD6wjZcewQTLR2byL/ktnRXIStg8OJB53s53YP2DhPbLaSNgmypSTyyoE2veXxnIzmq4/jN2VaHif1EcvgCLdhjnmWV7s6VOTc3zDsxSRetrro70dkGsprQ+RZFLDyB0Cg4TMTvG7kV9gqRHI1uufrixywMFbM3CB1nAFjOYYLrKJkTSPtmJUZFp8HYJHeufHE06fq1jioUnVJOAX80A5+1OZEcVKQIltwLR3IUdF09ffmL8Mnf+Mvw7ud/tPd+WJ/7jyNFFgCLiEiLQ+w+dh6h21viPLKLU3R/93jvqlVAgdTUoVsZWCf+QvjjPWZcRfMP+EIynmLBhD/XG11/0Oc/a93Q+4TGxxjRfImXs3fmmFo8bsM8vgF9uxF3CQhjxX/PaHOYmCiYULc2kgNbIjkihwnN55P0/Z2dw4TerIjTsEiOWW4mXJzthVbTYiKmRh4p3eJ6VRAUc0dzNgmvc4vImLoeKZV9XfPilPNDY47eOu/+wd+Et3/vh5/6bTwLzP0n9vvA7SuoXn7oo2ABIHz+o3G6biSHOEwIgiAIgiAIwn6Q1X1hIKL/UrfVSA6y8wVo/g3YmgnO78A2IpVuFv3R+I0e7jDRBZ7eefvb5+Mw4SI5FiwYGnccczYFkW9iOvz/7+EcRJEcN1nFBTpXUcF68DEXG8NB9Fkx8y7F6phfXOVCgYmZ0HOgzd1mYTARVLHfTX4t1hmUutqguQSHiR3OH9yyfq7DhC9YMscIBSp0eLVtVqY2tgNjDanA1+ZU4+zln2K8LsXQ/Bh14eaKoHzBhCI55hfa0NRFRnL4gu9QYbkecJiAFkesZE3C44siwRV3T5lqf07310GYBzC9qLckiAbU8S78Yq1IjjEOEyZ2mFBKgb59BSYtxpHDxEbncO8wsVQkB7I50x0TL3aGedeEFHP/GvTd+4s93+r0OEz4OWCqYMJ9bhrjE4KYWOlD+3cgup8TTEBPNFvp4MKRHD5eBvK///gi/tQxXx2KFtOm1//p6yS3BudRB9mRHI/+9es3X8t8/bL5+g/9efjq9/+5p34bzwJz/zHoF5+y1/uXHwI+vmXfw68cyZG65QmCIAiCIAiCsGlkdV8a0aZcuZsvfdTvvuH/v1GobXGYiDo2WVeA0v2RHLRB37fRZk7vQB/JYWJHxfo2aKP1sEIkx+Nb0BTJMVYY0OYwsdNIDitKyNjwpcJNhmAi7aJVVbfDhD/21cH+l1tcRRax8ASfm+AwkYw1wzu+yblgfpd8GKNtDhPJccD9zB/cEnxWdyR3JIkcJlh0SttmpekQTHRGzbj7U3GUvWcvfNlwJIf/uzrGGNZnX2zLnUODJffSDhOuiL+go9Fc/Pxx6p9fsT73jnvbTZs4YqXjuL4wsUBwU4nEoTBtrkqt//2xXrDzfzKmBkXuXQDLR3JkFPSQz9P08JuXjQ5+f9w2urb2zlRLdWX7+bTyx7lP8DzrpR7fgLrbkMMExoIJvtYKYuCJggml7PhsO4/cHaxnjkYXydHnNFY65DChX3446zsBjzGZKgTwc8Nl2vso32EiieSY6tCWdO7bdUSuYOIE1QefAwCA+vVX816/cKzD5pvhOwqzMfefgH7xAQDYOcT+7mN7Y2OcruswEX1nFgRBEARBEARh84hgojCiTbkSNsUnEOVINjaQQl5pa+cxt6Bu2yxEZN2WbuOnZ1MXT/dNh4kdFTw5fuys0PFrTiySY+ymIL1+q8NEuRuLY0FTh0LW4SZrw5fuiy0Z1r2vx7t4ezoLoxxsPSFbmcV/TO3Ymwoi+m64ZsEmRPJAS6TPJHjRXsdzDu9cVj5OZj/zB+/An+UwwcRDUZcVi+RoO0/IHIMAuE10TySH1mEujxwmrCXuliM5Wv8uBl7OoG7s9Sw3lgHPSYeprubHNjHBRFEOE25cm4H5Fc2AwwS2OEwk4ziaI/h92GPVRJv4hq00CSYKcB9DU4OmsQiwuMNEbiSHSl5f37xsCAtwLw4TGeuG3udz8y+PdeAOE0tGv+DGIjkaDhMLRnIAQLsDCjSL/13XMbyc7HvrcxorHOMcJqpXnwaY45rDY0yGRJdd0Gdr7w4TPJILIP+67a9J7ueJkRyHD74ZAPbnMAGmBjy1RO0Ii1M7hwkAgOqlFU6EWI4WwcTaDhMSySEIgiAIgiAIu0FW96XBBRMbLSrXbwccJhq53shuZl9yWzZikDlM+M6vIYcJ2tRXe3eYoEgOshBebnMAH9+CunGRHCM3FP3Gr+IF0R0VnY0JReLqmGUpTJ9tk+MwkXTR2s7CjjnCu3tUtpCEJqsDHOtLELdcu2O/vvg5oTHW0MBQATMX2xnErfPZfMSEI/7YF7wpnktUeJvzd5maxcVwhwnVf564YxBA7yY+XRuU0uGc8DHpxBQhOmGDc8xQ7Et9Bu26+rMdJurYYaLVwSkTG8XSci6eGOOcJYYjOfodJgAwOKZ0OKVgzYr1/D4uPsbd4H6dW5yKC7MlRXKs7jCRGcnRcJi4bengr90Y3egcTtfDxRwmWiM5VnKYuH8D+u7VYs+3Nn5+JUFY5P7X4p6WSZsDSvTcumoIOCMokmPLDhMuWka/+qZZDQKYHjP7y7zn8JEc0+bW4h0mvGDSCSYmuh5BGnWgVPjePvYZ6hMcPiTBxM4cJow4TFwLc//aCyW8wwQJJjAZpxOiY7JA01iDCIIgCIIgCIKwXUQwURp842ujm7rcYaJZ8OSRHP6X7H/Jgto5TKRFXsQWe+r2DS5EBDy9A+UjOTI6FjcIJpEcS3ZYm8e3oG9fueiJkeOSb2ISVdNKf6twC051yBNM0Gc7J5KjYfnZ01kYcrCraQVNUweBUUbhagmiY5LMH8g+/50W+bmwziClFCAXGtXcYWKgmL1BokiOOcUxHhcTFZGYw0TbeWKOQdFj28YaKx4H4RWL5DBO+DLkUlEwwYGn43N9OXmHidziTNOSe6lIDncuCjreJJQYml+xznGY6HCJqM9hjuVuKvyxEx0mwjGlGDJ37kpwH0Pj42EAoOHwMBsv1BtxzEzdEGzom5e+IEsEh4mNrj8WdpggwYTSlR9ra0Zy6Lv3F3u+1UkEyO2RHNMLZPq2OT6j1yG3hA6hKzrBhNqwwwQ+kMPEh/NEYCy6aKojGr3+WOHG1//qX4Q3P/u/+J9VNcHJ7Yqk1/+lXI/stSk/kiMIJr6e9/qlU1/AtAmhhMUxzGGCBBPUsIPpOF0xkoOaEZQ4TAiCIAiCIAjCbpDVfWHwTZ4SbJenMBTJAWkmeBTJESz3VZsdLXURAxMGdGy04fkRABF0Esmx1c3FQfwG77IW6V54cvvK2c6OdJhosS2mLvRdFJ15ob06ZtlX098/2AEdvR7r5gbo7yzkOdhU0Mx6fxf/uCxr9AUg62CADoeJHoeaaS9o4mJ/GsmROkzsYew6FovkMEzMwwRxijlMtHYhoknmBxprLXOXYfMJbfZHkRyu+OedhMop4I9mQNyE9Tl09ec6TKQdpqyrfDKm1EgOK5QYjOSozwCI3e47PFajoyM3miMiUUXbWmea/TkVt8qL5AgOE7Cww0SI5xkeo1hfGoINdfOyISzwx22jc3iI5FjGYQKNc0GJHCZcJIdSywomHrYVyeEd0ijCYOFIDjs+W84jj1Pri+TYhcPEGwClQd+9P1+wCRBHckx2mBj3Pr7xV/4jePt3/kr4ha6KFoL7SI7EYSL7OCVRB0rrrDU4mhrA1FB98FsAAKB+vTOHCaytc1UJosadY+4/CYIJJ94M3x/d2omtwXCtSI4FrgeCIAiCIAiCIJSFrO5LYxeRHNxhoiWSI7XUj77EJh2d6UYMi/TwnV8dGxNUDFTPJJLDb/C2ZS7PeV5XdNA3L63DxNhxybOYCSpqFNyJNRrWVa8ON3kOE2aCwwSPyQDo7SyMcrBbuvGH3x9zDKDi9JUK0DympHX+iOIzYLZgAlPrfP583Op95w4TcyM5/GeBbxoqZUUTAK3nKT72wDrxm8c4dPV2OExgHVtyb/A8BReT9nOB9dlHTGU7TNQtDhPQIWQZ+5zIImsKEqjQuB6O5HDHsHOs9EeIAbg5KonkQIpA0kH8aX+f281beCTHVRwmRowrZNcrh+3gTzp9ydlpg+sPNLUfe4tGcmjtir2xw4R++WGWCHQI8/Aa1N12BBN0DVKtkRzzC2T69lWrw4S/9ukK2mIJw93OAAfnMDFCVFQi5uEN6Lv3QFWZ6+eEaL2bM2/w56DXHzm3RnGPAC6So9zz4B0mSAA01WHCH1cedZAR9+feh759Bfrlh2DefC3v9UvHXVvEZWJ9rMOEjeSAVEyaOEyoFR0m/PiXSA5BEARBEARB2A0imCiMaMNlg5u6AEkkR1LUwVbBBL8D6zhuy+/NcJigTWXqyPXFqII6YReF8rlp42ChzTvqglO3r5zt7MhNdL+JwDrIpxTvC8VGZITO3ywHB9pUyxBMRCIGGNigbXGYyJlPkFucT8yEngp3mGgUbJjDBBXiZ3cN9cw5aAyL5HDHY6PFiTZwgUgOb0fb4jABQ5EczKXFPUn4ffOFwn2qFicG1y296Xk+J5Ij22EiteReIGqHOUyUdLzJTWMousB37Hcdb7beCMM4GceGxfZEogomttDzHCb8pr+PIXv67lU0dXA7AVjcYSInCgpZdBLR1sHv1x1oZgmFngJ+zvGUsW7ofVIeyeEcJu6tw0T13mcWHWf4uFGHiUPLerplbZuLunnRKnzxr6uqhuNVxOVsReNqu5Ec5vENqNv3AHIFxylMZKImRnJ5h4kRYz5y3SOqQ9Hf2b3DBMU6TXU9os79iVEHPBqkev83Qf1mZw4T7hpjTiKYWBvuMNH4nnvVSA6as2VLVRAEQRAEQRD2wsI7nMJsuMNEAbbLU6h5JEfjb+iP5EBEthHTtKNFNMFi0RcPOiI5XPeWt43eoaU+B9OOuIUKWNQpo29eQF0dAepLfJ663g/f+CX2dA6M8a4lkx0mMgofkYgBwB7LjuK9P/bVIRTZshwmgrPCtWNUqNgJ0LJ5HTlMTN3wTTA1K9onecyse9wX4gveFM8liuSYKmLidtgAiQBCQVdnvnvRWGDRlz/OBBNeeBVFctSzLLlLQA25mNRn0Deuqz9XMOEdJlgkB4CdxyZ2xqGp2zuwnxga132RHGhMGCNdYx8xsnR2v4zvEsVBsPtE18iJ8UENhwkSiRawNkQD+hgEE34cLERWFFQiJgSwjlhpl2903AxzR9kC7L0v6jCRRHLU3mHi04uNM7ycAC8n0HfvL/J8a/K1H/zzcPMtvx0q17nsC8xcSEluR3McJm5ewuX0K80bkniJrrggiuRQG47kwMe31mHicDPLzSQSbU6N5KjHR3Lg+QEAscVhoty1oY/kcg4T012P6P782jZBMFHdQPXqM1DvzWGC4hbFYWJVEBHw/ADKrUGacWUkmOj4brfom5kvoBMEQRAEQRAEoSxkdV8YPK+55M2XPsy7b/j/b7PUV4nDRLRhw7q9VVt3FWKzeNAlmEgjOXZoqR/hjrW3XO+xpD196f+Bj370vxj1tF4wcfuKddmP2Iw0zU0EKixtveiMiPYYUJGmuslzmKBNtSyHiUtcFNJV93GkMa4qgMo9JtthIonkuJbDRBTJER/TSDA1tQiZvp4xwSlEq6hAgYbFoOxJ7OOIIzmmOkwk0Tupw0Rr9JL7DXf34M/RNta4DXpLdAXy4h/ANs9Tm3MGA2vmMJEbyUEFE+8wMa0TN35SE5wFCurYpzmkd37lY6drrHBHrC4Lc3MJx4CLg1LnGvtCY/8E9zRUmI1FoktGJUwmcZhYLZJjjMOEaTpM6BefAvPwOr4juwZubQ3Cr4Wpc8bk52SuPHTdQxedoY+3ix0jv4bcQCTHx//Hd8Gbv/UDjYi7VoeJGYIJdfuq9Tzy66lqc9mj+9VnUIeDi1PZ4LUOXCTH7Svr0DbHYcKvd3XWvMHxDhNjBBPevTAIJop3mGgIJhdyPdLdop7Wh5OD3OEI1fv7E0x498CHN0/8TnaOSRpE/No5uEjZO7DvIys7TICaJjwWBEEQBEEQBKE8RDBRGjuI5KjffQT61TfZHxpFnVCAUG0dm1Fkh24W/VlHshcGdGxwGe8w8dI93f4KnhxMNhD6CmGf/J/fB1/+3j8xqruIIlb0yw/zLMEx6Txn/7950QoVsnw8zHF09jEAhCz1Acv4+CWZiAHceO4qrLrPnd10nxCDwpwVIKfTdwG8dfDNi+bmNRNM9ToXZL2gid0ReCdpzUQqexm7jFicMvF6k3zOI+cZxSI5Wh0mMO7S7Sl2IPvMtcbMuM/HliM5gptL+7nAyzk4JuU6TFxO1p0j+VzPuh6iCSK4go43CYH6BBOxO0nXsWw6YjVcr+pz85g6hwlQ/Y8dBOMuSTXgqnVNvLuInx+fLpID6kRMCE4wcf9JtMaJPlcbi1aKBRPj1w39T+oiZ7T2x6O+/wT03aesOGchYQ4JVzSPMCgUNBcrtk4EE9E4NPMFE20OKNFzV4fGeiR6n/UZYOMOE+bxLehb6zAxx83Ef671IQjxM4r4AODH+pi51aTuhbAhhwkaz5PXz0nUwVSHicMN6JefjiI8dwFFcojDxKrQ+o3WXuneBKZOKGpFhwkT7wcIgiAIgiAIgrB9ZHVfGjuI5DDvPobq/c8CQEthHXkBgv+O/j/pypzjMOG7gOJIjq1uLg6Sdlz0FBr8MRtxLOq31jFEv/p0s4ujB2+Tq3iRv7+DejP4DXNXJK5usvK+fc5tlsNEYiHet1HObJ2nuHqgqf156+36XwEqcurb95oFmyjCodu5IO8FuctBknPLOpd3M3YZvPA29XrT6K7KjeTgDjTketBW7GiL5Ei7fmd0mBbBgKgP6/N0h4n6FIolAIscpyiSo6DjTXNIbyQHL0CPcJhQHePYRnK4YxDdJ6x1vChoT5EcLgbDO5Ys7DCRE8lhx2HTYQLQxF38O3GYWD6So/JrGvPwCei790FVh8WEOdRtrV+UH8kB9QXM+SGMu5bIIcT5BTJ1+7L1PHKxa59gAi7nIFja6JrEPL4BdTffYcIX4Y+3dp5WKvt65F8/x2HilkVyVAfAutzz4IXIMx0mWgvROde1S3C6yI4y3ADePVAEE+vCRVIA0GgMcGMydTRdBR/JIQ4TgiAIgiAIgrAXRDBRGHxzuORulT7M229A9f5vAoCWvyFykGgpQCRdmY1uTmT2+QPdllQseT4OE+5Yt3XEddx3TOGFIlaql58OmxJjCja+aM+mmb1EciQxBKo6esvbUY8nh4kMwQSaSyI+6XOYYO+PCv05RTYuzrhyxAF1wum796/iMIFoQkFT62jOQX4cWmIgtk40/qYWYdNIDiaIsy5CruOzTdiSRHL0FvF58bhFuGWvDdXVx+uSqAFRn43keOH+P+984fkxFEv4a82N5BiIEXkK0DtM9HTi889x1/WoxSWiIdDikRzMSYJH/Sxmf97I6X46KAJHVRTxsrTDRIagx9QNhwt9Z4vz5t3H/nfRcStovI5iBYcJuvZxlwJz/wnoF59ya5qFHCYerWBC3ZYfyYHmAnh68PPDWpEc+uYV4OO7pssbEyAq1R13YJ1tjv3C2cLBhzfLOEyQGKAi94QeoUnnc4yP5CChi+aRHPowSkj+VJCgWx1JMOEEadmC48RhQmloXBP7Hl0Hh4ldCiZqcZi4BqnDBPi1EX0GE2EPqFGOmpPeC48EEgRBEARBEARhF8jqvjSiSI6n3xSfQv3uIy+YgEbHDXOYUPx37v9Y8VK1bXqh8Q+kzbGuDa5GF5DvlN/m5uIgaSRHnyUt2VaOGGP1W2uZWr36NCvYjHCYaOm6UHs5BxiLQbI3fEmw0lfQazymTuJNDt3Hsc1hImMzl8d/XDviwG9+373XOKbII3low3fuJpipQwd3ai9cc4eJ/QmuTOQwMXGzn401+y9bVmjd2Zlvf8UdQ6BXMBEca3QYk0kkB/Dbci25S8CLDwa6iifkpXc6TMw5TmjGXW+uDAmBeiM5LiMcJqL1Sp/DhJsjOhwmYKLDhO9kp8cXFMnhI3BoTFULd1d6h4nhcZXGVQEA6Jcf2Ld5/wm736X1/7cAn+sWc5gwTrDGIjnMwxuoXthIjqUEE0iRHHflCybA1IDMYaI9kmN+gUzfvgRA4wWiRCx27YvksPN5n3C2dMzjWzsmXPzL5LUci3mw/7OuYCJ8twwRM6qqihaCp6ISf63KvW63de5nPAeP5FhSlFUM9N3uJIKJVfFOPHEkh18XYyrsyXRCySFdpwmCIAiCIAiCsHlkdV8YkcNEwfaefZh3H0H1XrvDBLZ2bEZ3CL8fG8nR0dmfdgENde9uHTT1/8/eu8Zas6T3XU9V91r7dt73PWc858zFdmI72JaQHQhgJ3ywsIgSIYVPEC4CJTJgQOIDH0DCEpGxQIpIIBhBjLATSEAgBSeKSRCykxjZJiYQe3DAl2hmsGc8tzNn5tze6957Xbqr+FD1VD1VXdWrL2v16t5+/tLozLv3Wr169+qurq7n//z+AEKYrtYDC4ZukarDAh8SJuT1674o0oMwESwiyIdBmIgjOcyCb9W5aOiwrb0IEyF2vC27WtMitiNM9Djm1JwxOWHCRnKkCBOg/fk0tGu78YEkFkLIYPFXK18MfYiRPtSwM/SajGkr4bh+IJJDqXB86EKYkMKf0/T+opU935cbySEOUEx0vQNRrAflpev91neXAhzlOAVj0oyOt7LndVsnfnD8csc7IGJlTA+UMEFnv/JNAAAgAElEQVTP9QRNq7fpzHWyW5MYFgTnUGSKIzmOTJjohdZXVRhXBQDy8jEAANQbb5gI7oELm4MEETLHjOSQJpID5y6GMPHIFKCORZjASI4lECbqyowbzoCMhAkyL3CRHMNNQi5aKS6s0rlbS/e+JpEceqEGZLV9BXJ948kQQ+cgJJIDAFrJHNlt2OfILmY0pAcsijBhjTkxYSJ3fuU3lOjc70OYcNEgD5QwgaQeJkycVO55pUDKY0S/jOlcsRn+qDuDzya8pMpisVgsFovFYj0U8ex+bgq6mOa7+JKT2m1A7zdQPn4TABLdOlo3MyWDSI6oeBk/39KOZNdtmSNMmGKJWF357QEsthvroFQVdnl3MEx0I0w8dZnWvpu4w7mJ3yslTCRQ+ktUI5Kjb7b8gEiO4PsFaM+udvvX8zuz0qryxQBHBZmWMCEvbpoFG6UaRcixi2BaKR91El83tT/mriD4gMYPvbt3EQ+Dr8koeifIdRc+kiP9PZGIFfLeZLGDYNA9NYVGWNXGfLHkcV7kKSZa1eb+WQ4kTFQ7X5gCaDendJXyhIk5GSZwXFVt0QV1N8JEbNBqxIQRwkRwrpO4GTG2OIXbmVMkhyNM2AJcceRIDgBrYDt8HZt9CR9n5JUxTOQJEwsbH8h3rnY95g0tcrEqZC6h7l+AvDxyJAcaJmxMyqylKlApwgQ9X5S/Fw0VFq5zhAmQJpIj172v6z1AsTJzl6Wdy1Zq8wrE5WvmngZ58/shOcME3t8OPP+kt4Em8g6Eia0lTBDDRJuBeQ5yxxbv14MJU9E9qWfnvidMXByVYjMbYSTHhg0Tp5R2hAnStABAnmMiY88JCRMcycFisVgsFovFYj088ex+bqIFoIwRYM5Sdza+4ZExTDSLOk3EddCdQggTQsigOKHj4gEuZGY6VJxhIorkmPOi1hiZgqEt7grZ+nf2MUyo26cgb94w2427OA7sD+6Lk8NsL/w7iDpKPA602zWLiz262nU+FlqpoKNRyBYEsCaL7sUAqgchTLjoi4mQ+8oRJl5LjIFk/IAWckEfUZMWhItqphD3cAkTanfvOrGHLlyPIkyQorLdiP95/FKaG99CmJg6QuaYaqMguQzyoYSJahtEcohjjMVaeePijK4LvPe3RR7pLrQBYtASGYOWrvdkjCAUigRhoj/+HF+PMWTzMUzgtXsqwoTZZtHpOtY1oXxYFSnDBL2fLMy0eSrChHCRHJYwsXlhDbJHNExs0TCxEMLEftOIuAvuSUfoKM6abOn9NHoGClR7wsQSDRO62gHUe5AXr3mKx0DagJ44ksPRCy8iwsSMqTV6b+7/jYaFwSY+Ql4aZJgwhIlRUSwzFM7LmDBxYuG15iI5wrUJzZEcLBaLxWKxWCwWa4R4dj8zhR2z8118yckZJl77BgBI/A2pSA5aoNTKdwrG3VWYnSpDw0RugcstalnChCvoLXBxsZNU7bs8Dy0Y4vfSYYGvvntq4jgAfBdHl4VBt6hMivxCmH/PeGGxi7wZJCJMdF3wJXE7cYdhVqoOi0ItC+VYDBQ0kqMPYaKuGkYBmAj7rPfmGKYiObSiBJojGibQhCWjAgVBvT/E8UPv70Fema7fwTE5FCEOEBkgROvCvFY6IlK0FPGVX5R0i6NVRAmghIkFGibc+J0yTJAO0SHFTF3tPA0AgFw/IyM5ZDOSo371IXztz/8A1KRYPaVwTNW7+2wxJihAZ8e2DgatuvL3RUKY0IE5dBhhwu17ZMybg5lWo6kODRPl6sA7Bqhr4ZMSkaxShAlYMGECz1exunRz29FS1vQiTHe81hrU5qU5dqcgTMw8kkMrBaAV6P2972DGuR19NjtCgcxfy+GcMYxTy5//2hom5k42yMlTR17rT2iLFBsmYrN9p21gJEeHeRAalgLCRNHfxDiljGHS3/+dYbJ3TFSqEN19G4Fhos/z5FKEcYtsmDip3PhMn8+EIHOj6Dw9ZSRH/AzEYrFYLBaLxWKxFi82TMxN+OA1ALk9B9V3TwEAoHj0UQBILT5RwwT+SIe/xyJDvFgYd1seKFLr3R1AUfqFfPHwOsSpTJGbFC1bullxUaEbYeIZFNeWMCG7EybcuRwtKg/pjp6d3ALJsM5fWqDrGssRfL+A3bcZwwTFOo8kTAxH9w6Tj+R4LXE8mwXMPvnJyc/DQrvbJjFwpYwjD2j80Lt7j0kfWqzQEWGCjO+CRnLkCBNAX99idiBdvZgdHhQOkcCy4EgOR5hIXatYMB0cybF1xW0A8MSUMcYSnY7k2Hz+l+DF3/kfYPvb//fwbY+QImSJrIlNdSBMpCgR0XmsFYnkQGqWUvZ8jMxdAwkT7rrA728OhAkXyYEY/PNGcsSf7wwTm5f+dV2oIjMV3gvl1RNHUBm/UWtAlOY46/0GoK5AXj0248yRDRPi4uYo2zuZsNhJCRNYZKbnIaUdDVQrYUIIc+9sMQwZA9x6sYQJ7MCXFzfOKDiYMFGTmAeAg88/SeEzUYd9wKgnSc5nIcvhptMJpKtdeP8feE/SqaiDHnNwnN+LYk2ugWHf+xzlCBM7NkycVBFhAv+/W1vABpspIjlwnjaCOMRisVgsFovFYrHmJZ7dz0yaLNLNArvcU0iYkNdv2KJO9DcEkRuJzmMV5n4HxZw4ksN1FKQXW9Tu3hXW3OsBltl53EW0yH0gw7dPJEd99xTkjSFMeGNAhy4st4gQdV0sdIE3UETPcBnMnQkT/vipFmx8IFWHCGhZ5o8jxTr3MblYaV277w0XgaYyGqGBRF49auJ6tW4WIY9AmHAFyWihXavKf8cPMZJjvzGL/kKOJ0yQOCAvT5hIdvrHkRxtYzQpUsmrJ+ajafe4NtfHkiM52mguPqd9NTCSYw9y1ewwHWWEIlQjGtmD5xKi+KcWNaHlissBYaLtmsZxxl3/hFKgdUD+EUDnNGG8mPlpX/w5nvPziuTQWoOLwLE4fWcaOaK6RnJAXTU+H41gQSRHQJiYb3EzKWeYeHy0SA7tIjkKAK3csZJXNpLjSCQTvX0F4uJm9gUlX+y892NCmYjkUOMNE5AhTJj7mB1PhMxGoel6b2hDblxa1v0OO/DFxbU3XR2JMHHo+Se5jbp7JIfbd/J8CUU565ifmDAxlHrkCtEkkqNPpEaKMDEHYtLRZOc+TJg4rZxRm9z3RUFMfgkSylhzfVbufsCECRaLxWKxWCwW66Fo3qtXvxOliWFixosvOdV3zwHALOomizoHIjkAoo5Osuilo+IBgOlSyS1w6d1duKD1ADvEqbTy3fAHkbR4zDqcY+r2KRQ3hjDhkfEdzs0cYaKYdydWF2UjOboSJmjhpithQhP8PdgCvtbpxUrlDR1uQanPMa99FEVrEfsE0vut6bC0UTrNzs6wCHmUSI6c0YgW4mQ+LmGp0rt7EKsLe00OLFY0IjkIQUiIqIgcv1mHJqCWIj7FoCe7x9FsNzER5ahqiSRxSP5iNWwMrXcABSVMjI8ucQXXiASA+6ruX+beelJRk4TOGNLo8UvNtfy4ikQrW2yi14mKFu2piStJpxiKP48jOc7ckeuKZhIEmnBORpg4fMw0NYviW8u1ia+gpqrEd7cUYVFRXj9xHe7jNxpGcuB4Ki9ea51b95XavJx9HAcA+DlSvXfEATQEpSI5YIQBBLcbmwS08mbVHGFCaw1gIzn8c82y5tTh/WzcuIZzRkpF6x3JgZ/dhbq3vTPXDSE2zJ4wsd8GhsnB1KMo6kDA0EiOC39tPRDCBDUtIVWHdSK52ElqmKDXYERCgdMRJjxxkpdUWSwWi8VisVishyKe3c9MrhC7ulwcMhgATFEGwCyiJ7DhYa53FM0BWPQiv6eLOWSRHiXKdXaxRW3vkoSJh9QhHiiOUTgWYeL26bBIjojC4PQQCBPxAgli6Tsu+AbFuo6GCair8Fi2GIB8TELpv7MeC+qNRXuY7rrR+w2I1WWaZqK1L4gPLULGn6c8tUKACAwo1KQiEh3mS5cxTFyZ83docYzSTMz/8b8TAqCFBKIp3QMIzST1nZKuXtc9bg16uB8Cc98BIEVpmLsEFn3aDBPl2tJl+p2Har8FsaJI7iNc12g2ahiNrGFicybDxH7jDF/Z4vKh4nnUSetMcfutf0m8aC/8ezWlpww0d/nrgFAuhDg7YYJmduM4fQrCBEZFHN6fKiicuLdfPQZ178eIQyaZOctFclwejzDhiG72+kWjkVhfgyhXRzRMvAJ5OX/DBD0nEKnviuKJeEAxgjDhqGTx8wud54lMMdoZtVaLfa7BYy1k2dtw3NhWvTMFeEHMtAMNE11MG3p3Z8gY9Bl27oSJyDA5nHqUiOToQ5ioCQ2k7E+/m7Xo+MGEiZPKjdV03lGQe5Y7TQnR9NSRHGOIQywWi8VisVgsFmtW4tn93GQXveRqmZEcroCQw4ZrTVCeacIExePrxCJl4OIvVtkFLr2/B7G+8j948ISJmnS6tndm4uLqIRSqrnagd3cgLWHCL/J2iORwFIaIMDEAJz83xXEjvlOq4zVLCRMdu0XjLlq3UJ76LmjXP5o5+hiwVOWx0FMTJhAd7PaboPN1ZKgyPx35gaSwmSBMNEgbD2j8UHaMFMVq+DXZRpgAERSRG6LfJwApLLdEckgJolyBWF9FkRy2W3qhiHKUkEXymnb3OSRM9MVYVzvf1QyU0DIykkPIBtHIESbO1GWpdvfO5NeFMJG+pqNOWkuYCAqc8aI9xZwnaVrDCBPO0CWEuVbPHclBTFJY7EwZFsaqayRHijABACCvnoRjBKUELGwcx++8uH4Mer85yvimtQJhY4y0qkFZI4a8uHYmuj64/ZzU9pUzuc1ZdEzAgqczbtLzJUNP6yM3Z4yeX2Kzaur8p3SGxc5L8FgfgzBR7QLaQ1cyTbwNgG5zeLULzfjmI+dPmBApwkTve1JEeuxrmKi88dPNR85NTDqSAkPesUxtrKQaZlX8/zgniyM5QMDoZ8Wc4mcgFovFYrFYLBaLtXixYWJmcotyxXqRRWW3kCfL9MJ+qohAH2JJAa3RJRR3W4LtUskstqgokmOpnVidpSrADM2DhYaOkRz17VMAAFd8ctjtMYSJBxDJ4RfMMZIj0y2YUYB37kqYUGEkh4/KSHWj42KSj+QYS5iYakFeV1tDmHDHlJxriKE2O2bfMHIRzBZ9/TYJYYLG3MgjdOTPTHp3D3J1dZRIDne+ADVACEiO8yjV3TARd3HJy8egNr4Y6s7Zic/XoytH4KFFsgEGF3NdkYLJEYxQWHAFWQTbcYaJ7XkME3q/cSa/3PhKz/fk/agRyZEiTPj5jvk/dEzSPo5GDiNM+OJUaBI9e4FJ+wKBK1SegjDRtVNcVUnChSFMkDGCfs9Lm4MQwgRAj3lDm9AsaCN1HGFideXvs0cYR5dCmAiMrGj2wntKIpJDjCiQJec3AAEpTmQK/+49xcrNQZc2L3GEiYIQJo5lmIiNr122UXc3TDTiHgHMc82Mn9mdERk1NNKuQZiQ0KcQ7e6f5ZpQ5JbXHJIUuQaZMHFiJQgTlIqk40iOExImkvM0FovFYrFYLBaLtWjx7H5usg9ecnU5HJF+TtVo+CiTkRyQiOQIOtgC5L4MH3CjPG8AsJEc6eOkt/dhF9BSO7E6qkv2sXtt1S2SQ1nDhLx53WzWddt1J0zE0StCFski/6IURXL4bsGO1yztZOxMmKjCBfq2hXKKTHcxKn0IE2TRHo1GUxEm9hubb9zE9WpqmEiNH0M+L0bn2wKFyQmPYlCK8kGNH47CU6yGFxCj7ipBCECiQyRHMJ67mIgWwgQaJqJiaFD8g+nO16NLFi5Sh8pnf6/NNd3z+9IRYcIbS8YQJpQZh+KC4hkjObTWoPf3UNx8xPw7N77Se1jqfhSdb6miHiVq2RfbfVDmfCdRP+7nvf6YqJsX2uc8k4nE45ySMBGfVznp2ptFqeTV4+AcDO4lMy5upuQiOa6fmH8fo4MZx0xreELCBFKH6OeOkdq8AnFxM3o7p1aSMCGLhiGMnv9DlSVMaDKPzxX+g3vBMp9rPCWjdDSxwabNatuIm+g71rrvoQthYnsLMjqfh9yTp5Su9qGpZCD1SMed+0L0O9YYyVGsRxtl5ibNkRyTKUWYAEp5iSLVzPnKkRwsFovFYrFYLBarm3h2Pzdht+7qYpFd+L5rKB/JEWRKmh+Gv6ddmbRr1T2URsWD1kiOS/8DV/hd1sJiZ6maxAccMEzU3QwT9Z0lTNhuXdx+J2OAzccWkWECZo6u7aJGJEdvwgTpZOxBmAgiOfC7TiyUB13/7nU9CBM1yYQ/Brq/hxAdnCrYUMNEcvwY9IHKI+8lWWjH75h2MIlicYW2NqmdjeSQJyBMRNEp6axsHS4yypZzTbUbJhDLP3WEzLFlsMIpaownTIgB3awxYcIRUwYeJ621OcayGckBldk3dT+9YQLqPYDWzuSXM6QdIkzEhaH2SA7sCCfmIK0ARhMmEibRuUVyFKclTHQ6P2kcGZG8fAR1EMlRgVhduvcsSXiOImFCjTRMmOvXGJSdKdIW+eT6+qiGCb19BfJiWYQJR8eRhRnf6PmSigfsq9zxVbU3/8Smcfx4ajZYKjmPRnJgIb/j/DmWrnYgVxE9oe99DZ+JOhTvY3qh+ci00XEuahAmht6ToqgqgL6RHMTs88AIE0EkBxsmTitCqEEJGyNllDpPT7UvHMnBYrFYLBaLxWI9NLFhYmZyC9HlxSILc2EkR6owTiM58EcEgU+Kl43F8lzxoCWSgxImXGFuaQuLHWWK3B7l27aA6g0T3SI5pI3k8JjmDuemrpMLyqIoexXvZ6koksN1t3Vd+Kv7GyZ0XBRq6yzUIwkTmpgzJu5gVPuNKWrhuRZEclSkMHesSA5KOSCLv24RLDrmD2j80PuNjeRYDTcx6WixUJJjSf+b+p6CYw/t5pyoSBV3j4NWZoxf+jgvi3QBH++t5dqck70NE4mcd4Dhx8l18CHSvxnJoc9AmECDBMZI6X3OMEHG4OQYGnYopiM54i5HYuKi8WMDTWfOmEdjyGZgmAjuL7ZQ6Skbx5OIO/tzu0Oik6hSkRxomFiaadMRJq5sJEdHMlV+g/b8ln7MRJOAow4BHIV0pzavQF49Gr2dUysgTNhIDiHL5n3/CAh2NxbHhIkokiNlGArMc0slTCg/dvYmtMWqdgFhIr4fHdwXrd1zZKdIjpheCJAhKs5HxjBJKByDqUc6eL/ImHry+7EDKEoz7jwwwoS7BouVGz9Yp5Ebq6MmgpgwQQ3cY2mE2X3hSA4Wi8VisVgsFuvBiWf3cxMhTMDQxaNzynUNWcxqtPikKUEiVUgjvxdxl1Ciq0sU62xXv95GXUCuE2uZnccHRYvchzqssNjWMZIDCRO++N5hUVEpEAlMNohied1wsaJz0XVKdVz4o39/rqDXkArjIVyHeAthAoT0VJAehQ9d+0z41piEEwg74VLnWhjJMbRDLvo82yUPAAGZxeP2SQeTfADnrpWu9qYze31lF/tPQ5gQLZEcQI+92UiwzeClEfa22T0eEiaWGskhMqYcN7YgYaI6UiTH0ONEu+piGhRGcmynLxpgIVneoGEiY0ij53vSfBIuuDvCRJUiTBCyEwCA1oaoQo1YMLw4Fcx5WqhaU8ld88ITJk4XydGNMJHq7mxSaJZLmMC5tbw+DmGCFv1xzFQbSpjoQRM7ILV5uQjCRED+wg5xe0+h1+4xEOzOgJUgTATReonz35vnVm5smDPdICV3XhVlb0JbY1t1aAYMSGFdRM1zXSI5dncgLq6CnyWJijNS4/5/LMKEEL3mEHQ/xBFNWXMQfv/F9RNQOyZMnFLJSA5qJo0JYSeM5MAxWjBhgsVisVgsFovFejBiw8TMtHjCRBzJEXfcBF2XEWnCbMAv5DQWC6OOAQCAljxvtbsDeUEIEwvtxOqqRoxCS6GheyTHMwDwxSePUO1wbqoWwsSMO7G6KC4S983iDbJuexAmgpz2tvMZi8dC+HOiz3hCC1BuYXWa60bvtyBXl2QRPUTne8PEsAzmhlRNCh9+Uc19R/ExfyDjh7JGHeEIEwMXrSPaijuWIjLGJRYrNY0toO9tI0wkIjk0pQ85csIyDROQM+UEkRyrI0RyjDOW6KjgGpjA0DBxhi5LNEgUNx8x+5CN5OhGmICYMEGKelnChNYASnk6xeBIjkTnYsKIOrnw2pLCFypPEMkhZDspC0UNflTF1WNQmxd+fKj33viysPm1I0xcHoswQc4tF8nhCRN+rjfOnKO1BrV9BfJy/oYJOi9V1jDhCBz0PFSJ67KnciZb3Zh7JcYMZzZYLmEC6LPiSMKE3m+b9KQ+RXw8x2WRHVuf/dyPw/t/9YfN6yN6IQA4wsSputjHCqPuvAbOn3XCMNGjEG0M0dYw8dAIE2hqu3pizoWH8nfNUbFZFeyYan8eENnM/xttrs/KEbd4SZXFYrFYLBaLxXoo4tn93EQJE6qe7eJLTq7oJguAZM66JnjpVCGNECjirlXV7OoS5TpL4tC7exAr0gUkFrqw2FUU5XugwwoXJg8ZHxxhwuLN3eJEl4KNVulMz4fQpR8Xiftm8ZJoCYp4P/SZAe1AIDElhe8n8SzOeND9mGtVeTqIu24mJEys1j7ju4o6wWPDxNiuIXqeCulJGinCRHJMW6ZcJ/76alR3pKakAYCmUeIAYULQRUbZcq5FRari6onvHqcGpokNPseWkGVy32n2tynsnJkwoUlXXVygcoaJM0RyWCMQUpFyheVgrE4ey4xhIojkQBNLGbzWvDdF0+pbnMJzfl6RHJrG8JQnJEx0jOTIEiYuH5vClT0HaCTH0kyb+J0X108AYDxhIphPYyQHxlCsr5OGxUGfU+0A6grEwggTavsqjCWj96QE7a6vWgkTlO6VjOSw94JiPXlk2rFEzWZjzTmGMEHMAH0NE/beKi9uQFe75HP37a/+NLz8u3/JvH4X0QuBjH8zJVshuc1pKKEtjjoA0WsKbqLBwhinc9/PjiW8L8orO0ZvmTJxKqUIE6ZJx65tVGSMBLAklBNFchzBQMdisVgsFovFYrHmJZ7dz0yuc32hi7pYCBZCmMWQeCEkRZigD7Ek016ACIv+ueJBposjR5hYKqr9kLSqQ8JEm2ECv5eDhImnIC5u3OK5W+DqUFzVQee+l5BlP9rBDOWQzBjJMYAwIS9NpnfXTlFdh5EcXQgT5nUDCRO4aN8S/XEKmW7BiySuV1d7EEUY/TDWVKY1GXMEJUxgEZ4UAsXDIUzgeSfWlwDleMJEgBEHcN317YYJHS4yOrx4okgUXXOSdo9T2oEzEi10nM9FcgSEiX4GF11XxpyyShRMhh4nGvsT3W/0GQ0TSJiQ168H/25IdSRMxJEcqSgPO1bhOa+1Mu+nUT/BNrsJx7bAJNoy55lMNJIDDRMnIEx0LXxqVSUNGy6+whmrKpDrK/uehY3jSJiwxTh9rEgOSSI5tq8AhKWG4P13ZCSHtmMAzndmLXJOqM0rbzqVRRB5cZRIjpQhFPdBePNh6j5GIzncc83Czmc3jhalM10NjgWr9k3CRI/7miuuXtyYH2Tuv9XL98yvt7cg8bX4kS76bp7PNsaoEMaWAPR/HtaxkVDKXnNwGp/yYAkT12yYOLlShIly5RoDnPmqoPSvU0VyxLGELBaLxWKxWCwWa+liw8TcRCI5ALoVpuckunDdOZKDLLZo0L7QFhEmGihQwAfk5iKbriuDX6ZdQAvtxOosWiQ/VGjoGMmhbp+6Tl0A8FSEzpEczQUEUSTOi6Up7qofQJjABddsQS/xmXRBxi3QphZ3NaGNDFjI1fSz8L8TGY30fgNidZnsPtP13v1ctBXie32gIjESZKHdLciFJpWlFSZyiiM5hprzDhImWiI5gJhVzFv7RXJg93gQkSNbtrEACVkkr9UAMSz7xRoFdAr3OeOMUDSSIyCzkH09SySHNQIVrx2K5EgYH4IXdCFMxBQaMibpIxImaGxNSwzZZCLXvOvgPAFhQojDkRxa63bCBACojY3uqSvfZb20ubUzTJwgksMRJl4augQangFGn2s4BsjLmwOvPL+CmJ7trT+n40iOVFROX2VMAuYZqn0ejyYLUay8uWJp8xKVIEwMLJwbk+3K/fsQYa/xfkKYAMic86oGvXkFarcxZvw4kmOIMXlCNQgTYyM5AsJEv2PtTXYPjDChMJLDjtFsmDiZkoZ2Wfq1jWpnIovoetPJIjmYMMFisVgsFovFYj008ex+btIkkgNgcYQJXe+9o78oE4t4zSKChjRhwiwWkt8lMLiiWCcX2Vz3NI3kWGgnVlfRIreIEcLxa3FR4cDiXn37FOS1N0y4xYkO56WOiqFOsnDn+VKlaXc1DCFM1KbQVKxAdTRMaF1Hi0PthAkXqdFzIdcXoEixAKa7bnBhN2eYOHokBx1ziEkrjXx9eIQJF8kx9F6TIUzExrhUF6JWKuzS7WWYMB3L6v5FeG9w5ISFfk85wgSOLUiY6FFk0JUp8qeR3EMJEz6SQ0Rj+iwIE1dPTId2ZnylEUVJ0xmEdIfUGO/un26s9IYJTcyhvpt3IP6cov9HmJuOJUp7wbnqSQgTXSI5cF8Sn4+FKyRM6Hrv6G1Lmwfqag8gBEgbbTE6koNSEpAwsXnlCBxHM0xsrWFiAZEcEEVyUNNoQHqI5n9DlDMJ6IAOlovkQDrDarHPNd5stiJj60DCRJ2Im+pTxLfd6HJtDROpZ0p7zOtX74PeJiI5Zk6YgGoXEqYGUo/w9S5KrehHDDTmFvtdPTTChL0GC7zvbKc3jP6OkYrNqhDOi+uYOnM6woRmwwSLxWKxWCwWi/XgxLP7mcm55lP45yWornwH+CHCBP2Z/wcptEWYb4g7W5Aw0VxswcVkeeENE+J3AmGi8EXutg4rV+ip2he61N2zgDDRJ5IjJiK4bcgyKFYtUtoXCwFI53bXxVJlomvk+qp7p57t2QkAACAASURBVGgUydGGYqaL7r0XcuO/7UyEiSS1Q/nxZXAGc/x5qiYFSbKo5oqhIdVjaYWJnDQSJtZX5lgP7YyMCBNxFIdoM7ZoFd4PnNkhba4wL7GGCdo97jKEi8VHLwmZOceCSI5Vv0gOR5jwXbijyTFokECTCi0o2sKX3t5OHo2idv68FqvL/PhKx5XU2OjOKXt+uvGIzDdiwoRbMNcAoIkZaCRhIo7kOPe80BWMC9dpHXYvH0kdCp/uvpaK5LhqRnK4ouFMO8FzQrqSsDFzejuSMEFy13FMVdtXvhB8dMLE/CM5AsLE7t7f06QMDWHRHGmInEkgfn6hxufcPJ7eCxb6XEMjOcaac3RsBuhpmMD7lYvkSFILzc+qZ18F0CqIewSAZRAmqKlk6D0peg4XRdnL6ELNLanYvSULxw+MTeJIjtMped8nUXVxBA2AGB3fmBVHcrBYLBaLxWKxWA9OJ2gJY40SFoUeQiRHWYKKFnU1MUQkC2mESiAizLc7NkHxIEeYMIaJVCTHQyl4xtKqArlCPPaBBUMsaB1YqKpvn8LqzW/1P8Die5cFshxhoiiXv0AWF4l7IoV1ba4TsbrsHMkRdB6aDw33Jdq/uIjXdTHaL0RFxICpDBPVFsTqIrmYaopGMf5+5H7VOzfe0jGnidsH2/2fH5PVbhPkis9ZakcjOQpQ24HFihxhohFH0CGSoy1XOxXJAaYYqh+95d8/8fl6dGUIPA7DPiiSo0mYwPvoUGOJjgqudDt0rFHbV67jcgo5wsTqCsTqykXPNF5HrmOdJB5FhSEhTBwGjeQgWHn7ItygJdcQ8yf+vM/foiPTBhjTi7qfntxBRWN4Hv2BfxGKx2+6CJRjqkskR1uxokmYqDxhYq6d4DlZuhIaVHLndWclqDx6c+uobMcqZiJlRl7OnzDReN5y97SI+qOaRqa+ErIwBJx4Lh1H6yUMZ5oYJhb7XEMjOUaSBuLiaOPZ8dD7kTBxmY/kwPGiev+L5jMahIkieN2cpLVumEpGU4/wOb6ngY/ux9jvfW7ykRzGMMGRHKeTThImVn5towqpM0Kc0DDBhAkWi8VisVgsFuvBiWf3M5N2kRy4qLuswrKuSCSHTKA6aa63aBbSKMa6UfRPFA+gXCcXdJXDzftFLSGEee/SFha7StW+iH6g0NA1kkPdPU0SJrp0UeksYaJDEWTmCnDWQLsFO5oSLGGij2HCdB5G8RCQ+Q4pYUKIfthcLEDZ67iNZHEK6f0WxOrSdcMHkRzVnhAm8lEPfaQoIphiW11RkBgmRNF6HL70I/8oPP0bPzpqf6aSi+RYXfYmFoQbCs1DcRRHapz379XhImOvSA5SDHXFv4JQKpY5xghZJIsuOiBMlL2+L0+YiLDlAK3RTa1yhWrZ6OgNrtnNtFhqR05ZXbYSJoJCZYp4FBWGAIzhJCRM+C5p+wr7VgUAqbnOsLz40CQ6H8KEkAUUN2/Ao+/5o6f5nAPRYgDk/tdGmNi8cK+VS43kQMKEjczQIyM56HiK93i1TUdy1K8+hNvf+FuDPgax9GIJkRzRuOvM33EkRyoqZ4BEsW4QJoJ5sxDJMYOO554AtrTzGWmKq97z58a2YnrCIcN44/3WMHGRN0zgWL//4Ev2tTnCxAy/B5w7BBSgkYQJQl7qZ5jwUQnHiv2Zjex3L6+ZMHFy1c3nM0Nns4SJehcS1QQAnCqSg8TTsVgsFovFYrFYrIchNkzMTfjAjZ0gM+xWaZU6HMnhyRJRNAcAgCaZ9jFW1RUwSPGgPESYuAp/kenefQjShCogWpC0Win/uw6ECUkNExLjHUYQJlLnxdI0kjCB5oe2DmgqrbU5nnRBpgXFbEgvNL6jxzEnuHX7Ztxot/ePlNpvQJQX5JiGhAmIDBNjIzkMYQINE76jM9nBJIvWBfH9B1+Eve1AnLuCSA5ZDi9WYPE0Ol8acQSJxUqtlc/CJu/ta5hwxU9S/FtqJAdkzrHA9NBzDE0aJuTI65p+H9E+B4SJzbQ0BDSgifWViTzKGdIoYSJ5TTcNExATJhyFxs556JiktT/GQVRHD7nvhuzDHAwTU3VUdil8thEmbGxPjUSOar/8SA5ZgCjXzhQ8eHvU9ImGiY2P5KCGxee/+Bfh7f/sjwwqADpjXjwXn6GyhIlMJEfyGaaPysS1rEPCROo+Ft67l02YAFn6+JcjESb6RnK4++P6JrsfLpLDGiYahIk2A/OZhfespGFyKGECPGGiF4Wm3gFgJMdIo8zc5CM57NyUDRMnU44w4ZpBqn0zguZkhAkST8disVgsFovFYrEehHh2PzPppUdy1HvfBZ/sgm0nTAAhTMT5vUk8dbFKLm4pa5iQ8aLWgQ7xRauuDqJ8AaLu35aFKrW7B729heLaGyZcJEeHYl0jQgJw19pjDZYgHRkm+uZ9a2W+K9mVMJEoCuFCUfJ8prQRgF4EgcZC1IQd+1opgHpvxr/UMaWRPy2F+F6fWflIDlqga0ST2P9/iNyyFLywi+RYX/Vf9A42NIYwEUVyIBo+aQLCLq7IMLHxhAkhSCTHUHLCmWW65BJ/v6MZGMJEn++rNZJj4HXtCq6yaNyr4YyGCbXDSI5LEOsrV1yMFY8rzReEhSGApkHTGSbiSA7Q9njYuYwceKxxF8hCvCjXAGceYxoxPCdSl0gON04XLYSJe0+YcPS2hY0Puq7c3yhWV+MJE4rMp+1YQAkTQAyL6u4ZgFagBtBikmatuapBmPCRHMF5SCMxRiiOFNTVHqoP3w4iwlKF/yBOq8U4O2d5YlLpKWiDCRO7kJ6QMZq0vR/AUyPaIjn2HxhDbOPZssez0dRK3f+HUo/0yEgOQ3Sz103CFL1o2XlEcY2RHCPHaFZeqeezwkfV6To2UZ3QMHGEiCYWi8VisVgsFos1L/Hsfm7ChWi7qAtLW0igi7qpIhyN3EgVPGkBrVH0T+Cpc4SJLRImYmyqXNzCYldpTSIb2jozaWdtZnFP7Tbwzo/9cwAAcPl7vtf9XAhhFig6EiaSBZVMQXBRiiM53IJvx0JWXZmF4vVVFhkfflxUlKb/P1lcjuJQyELSQcX0jAk79nFhF2MiACA417DL1uzYcQgTmkRyCBCgXSRHVAwFuyieOY5aa4C6cn/D3OUjOa5AlKvBC/3xuemNLF0NE6RLt416EHW1FzYnur5/Sc5Z6bexsIKoU46CFERy9ItQSRMmEOU+LpID0KRCjvdcCBNidZXtxKfne9KgkonkCMZ4FRfrQ8KEcEUlzGrvN5+Lo5/MtmZAmEjdj04hWXQgTOA43XyckasLQ2O4f26+T1X7ufUMC5utIvc+cXENamwxzsUYESrP5pWjstH7L3ZKDzFpuHN1AYaJHGFCRNEwrthfjjRMRJGC7//UfwC7dz4Dr/+T/6Z9Qdr4HFA7FmuYiOg8GfN7t22FxVHRYhjPvR8AQGJsTEskR/XBl81nZCM55jeuuPv/KkGY6G04xufwYYYJIDQQRwDo+tw0c+E8AslGGEfEOr508vmMEiZ20T2HxC0efV+mMZCyWCwWi8VisVis6dRsyWKdV/jghajKGS6+tEnTSI4ihQ0nhokDhIlGfm/CxW8ygJuLNRhz0MAAH+gQX7QIYaLR8UvUiDhI6Gt/7o/B7a//DXjrB34cbr7rDwe/61ysU3Wy46Kt6LwYJQpGcbdgm7SN5ABZBIj3/Odl4iGghTARR3J0JUzUUQFqSsIEooNXJJIjJqKUkWFixCKY1touttvOuyCSw47FtHNZFqBzkT64nwshTNDC8phIjgb9xBneQuOETkVyqCi2B6koqWJHZJgQl4/MS+9fEPrQ8iM5hCxcvjuVrnYAsjDXZc8xNN1hesxIjtCgFxompi0aOFz96tIQfHYZgk+9B4dub4nkEDFhIhXJISMaj9ZA5zoePd5zbMhRtc5smEga+E4hIQ8a4vy+pB9n5NUTQ5iIzMiLm1sTw4RcX2fJKZ23l6DyqC0xTBBcvraGCTWEalEdh8YwheLnFXdPiyM5sABdjDOBUJPA7W/8LXj60/8JPPn+fwMefe8/Tz43Fclh792ry/Z54JxFIzkg/yzXRXq/DYujXaJ86Pvx+7ywkRxJwoT52d5GciySMFFQU4mdl/U1lrrX23tSz/sRnW/T2J8HIY7kmEzecEWfz8hzbrUL7zlCeBPs0XeGCRMsFovFYrFYLNZDE8/uZyZXpLM5y3NcfGlTEMkhy2a3jQaAKPeXPsRSjHUDq5oqHpTrZBEiKAYSCZHOh38ICqgCLRm+weJUZqHq9td+Bp78Ez8Ir3//v978ZdGtuKqzhInlm1ZSHSW9ClmWxCJWF6A6RHK440ViNnxx+biECWcIcNcxfs6JFpvoZ1fthglD5kDDxMAMZqq6Mp3guNguSBdStKBvfp0fP1xn00K65YKiS7Ea3BnZKJ5GhjjRSgLRYfc8RhekikQq7LY33eMXYTFUFpMafE4imT7HaMG0jwEKIE2Y8JEcwwwTYSRHEcZn1XuQaGg5B2GiWJn9Wl/mIzloPENqbMwQJnQbYYKauBShp+CY1ddM5fZhZoSJBPniFOoSyQGpwgmRvHpsTFVIBUDCxMLGh+D6Xx8hkiNhMgOtXSGY3n+x8DekAOijF+ZPmGhcz1jMF0UwTvp4pHE9B+b5xWzrxd/5H6F49Ca8+S/9qP99xvjs791XrfPAOUtXewAh3D3fUK76z50M2Wsf4fcPG63CfUHCxE3w7+A19txQtx+aj2jQC2dMmCBGZKeRhAlvBuwX56YpYcLO15YSY3dIPs5wBWJ97YxmrBMo9XxGzsVkJMeJCBNsmGCxWCwWi8VisR6eeHY/N8WRHOdeGO+rIJKjSZjQMUHC/JS+gMQcRIteieIBFCuDwY8Wx2gxMJAsFtt5fEi62voO4jaUddCxn4kXqPdQvPbR5O+E7Fh8zxEmUkaapSmxQJKLh0m/vQYhJcj1VbdO0RTy0xU5MoSJgEbRgyAQfZYvYk9BmLDXbXnh840pOp8aspBcMOJ6xgX6JGEi2cEUormDbVUEBbsAeaz42ozVQ+OfcoSJOJIjtVjZIEx0iOQg6H1TDH0eXo9jyQlnlsgYyoJCQ5LelJcrmFDCRFv8SRfRSI446qquQN58xLxsYsOE2t2DtPd9sbrKGtJ0vffzg9TYljRMHCJM0K5dDXgNuG793oaJqJsXAKDHfeZkmpIwcaAQjPelHA4bDROu+7fNJDNj6Xrv7omivOhGpmoTJbZR42cUyUENE3pADIi/xy6HMIFmL0+YiExs9rsQQsSb6CVKmNC7OygevxVS8TLGZ7W7N2aD1YX77pZmQqY0QgAA6EFoC+TmMf7e1kbYa9sGRnIk58rRz9Bc4T5zzoSJOkFEwXO3r2HSPWuTSI4ec0fznEqMm3MwAB5LeA0WJciLGyZMnFC6rgLDFQA+55rrT1dVSFQBMc5c37YvHMnBYrFYLBaLxWI9OLFhYmZyD1528Wdx2OAgkiO1EEJyvSHReUwz7WPMt+tqDAsYANBYzAoKr0Qi0737EKT3W9dBZDoz04sDjYiD+PdKmU7+TOZ050gOrZIFlb7FvlkqVTDqs/CnKgBZglhdunO1Te54pSI5EsdSq8rQEPC1PY55wyjQFpNwZNHoAJ+hbhfAbAa9Kxq1kgs6fp4rJGPHG1lodx1M0XHMEiZs4ePcxcyO0tXOdxd3vaZTwvPCxQHFRomW70mrwADRyTAhYsPEi2DBcumRHG2ECUcq6Gk680XLRIb50PuhIgaWqLCn6wqKmzfMyzbTFg30fuOKvnJ9BXqXMaTVVTvJqwPRynfP2zEJvDlIa+3O7eGGCXvN0KJA0a+j9xSaqkAgyg4klbrZaUolL3GMsPe1NpPMnEUJE+XF6PuMJ8TIcEzFznl3/92D3o0gTBwpvmIS2XMEC+fu3i9lYBjVMe59qAhhQlfbpsGbGDip9O7ekKGE8Nfg0p5r6irsDh84rqXoSbnjdnAbF/bcTz0XRaaAHGFijs/sJyVM9I3kqHZhIXsOBsAjiRooBRsmTitVN+759Fw0hIkwkuNUhgkmTLBYLBaLxWKxWA9PPLufm7BbzuUHz2/xpU26rnyhNRnJ4bsuIdmdpf1DZ6O7KoGnzhQi/AJRkzCxuIXFjtI1WYhqi+Sg30lLVm/OMAEdu9G1qtPIblksr1gRyRWMhhIm6sosqnU0TPgufkpXwQXaDGEioFH0KLDG8R9jO9F7yJNhLpr5xlFxEo5hmKji7lePbW10jwPY8SNPZaHbnLviiIehRdhGh7cjBEXjfOJ70jomTORztb1hrmmYSBImFjrOG8JE4hyj31dRAmjdvau4ikgq4I/jUGNJ8L1HHb263oN0homJIzlsMREA7PiaieRAWk1Rpg0qkCJMXIT3vlwkh9YAWjkDBd6X+3bSps75WXTkTkSYaDMGqO0tvP1f/jOwe/dz5rU5wsTFNajtLTECLnVuTQ0TRygypiI5AEzMA8SECUOWGBIDcqz4iimUI0yYKK5wfDuGYUIUKzc2G8Nz+Lxi5nvN+6ba37vvabGEiXof0LuGntPeZEueV2T++Se9jTiSI/9c5D7iIjRMuL9lhuMKNSKjhkZy6Zi81IdeB9YwQY0bc7ifHUvEZC0vbjiS44QyzTnRPcUSRwFSprYJIjmYMMFisVgsFovFYj0YzX8F63eYXE47LmwsbSGBdA0lu9oPRHJo5X/fwKqqpovfLep2NEzkcOcPQZQw0UCkU5HFwGRhDo9lpiNQFKtuxXeVIUzIB0CYSCyQiHLd+XrVykTXiNWVwSsfer1uFqjaOgt1ZJgwRbaOhImIrCAmXJDXpLBLCzbmv7bgFZgbAMYsgjUWkmkkB8HrooSUoPa562oYYWL//hdBVztYf/zbe71vrHS9ByjbaEAdFRtsYrJE2/dEisrmrcJ2giUW8RPjv7x8DGrz0n9XsiBRNQ+MMBFEcvi4mi5d/nieQ1BUGnmcyPch4o7eeg/i8jWT4z21YWK/8UXfdX58NebOFQiRMahE6HEAM/aouxfBNgCIqYp27ZK5jjfA9rzGcrEgZzZl6Yk6Ks3fmo6e2L3zWbj9e3/dFbdzhAlxcWMK/a5wX2RNMnOWrit37xPlGtTd85EbTJjMwBeC6RiDndKDCRNHiK+YQngfkZeWMOHM3zIw+ep6nzcU9xAl1qj9xsXF+BfItHlwd++iO9z4vzATslYRYYLQNnptJ0GYEEKC6mOYQAITGibqxPiqKluQtcbdiDAhZIuB+cxKUzjQ3Dc+kgPqPWitO13jKcIELMRkfEiUzifWV6C6xC2yhsk2HVCZNSdiXI/P91NHcjBhgsVisVgsFovFejDi2f3cpGoAIfwC+wzxnm2irn8hUzhlQphIotq1f+iMizBJRHbaMKFcJEe0qPmQCRPV1hV+TSRHLjqAGCaSnVTtmdOiY0eR1nWI20cV/XDyc1QKSU7zqA9K1SBkAbIrYSJFOxAtKGa7faeiA9qcvNdsPioCTkGYoHQTggQPficT3dxDPy9eSBakC0lljvmB66pvMfO9v/TvwNf/wg/2es8xFCxcj4jJaVwLbvw+TJgAElvglKPjOJMSJUw8CggTQsrBnZOzUcbUF3Q14znZ8ZrOYssBhl/X1DQWUYNwX+Xlo8kJE2p/7wqPctUWybE396Jc8dyer0EEWBFFcjTGSnque1rW8EiOjElU1b7T9xyaLJIjT5jA8XbzW/9X677I9TWo3Z2P5JBlZm46c5FInjYjSWdRA1obYaLaObJE9lpq05FoDJMI51k2kgNjzYzRmhAmrAlkrMyc0XZE7zdh57354OT4rPf3LnZoqYQJqKvgvOg1fybKmgF6ESbMWHKIMFE++bjbfoNeWPS7J0+pFGFibCSHi9bE58SOx9tEJRDDxEMiTDhje2nmHls2TJxK2HRAJYoVgFY2VvQ4prZOUs1nExaLxWKxWCwWi7Vs8ex+btK2Mxxx+x2iD+YkjUUIALOgGO9/gjChNi/h8//ut8HdZ38x/H2EVdWugEGLB+nOTb3fmC71qOMFCRNPf/bH4Nkv/Llxf6vW5y1aEGlVmyI5Lri2LBgGx6olqze7yE2wl61Syi04U5mO3oUt7sZKFbJ6dMj1jeQIOujx81oWynVE9zCRCx2Lq3VImABXgJ6QMIEdqbJoRHK4QkWCUNP/8xKECXtd++5xaoopDxqRkt2JLarvXkB9/+LwC4+tIOLBdwn2VnxuxoQJjNlIGiaiSA6Aw4aJVCQHpVy4CJlljjFCZiIiAsKEnR90vab3LZEcA40ltKtOSGnoUPg7NExcPQK1fTVo+0Ol9xtXTBTrK9D7TfLcM+bOlZkTJI9jgjCxunD0KgDwY6ozVRHDhFLu3B9tmCD7EBvJzqHU/egUEuU6PN50H+yx3NtIjlzkA2bJB4QiWcwSnd8mXfkIgzYjSeftUZMZvcdd2EI8Oc/GEiYmK1yNFJpoHGHC3dOKJkHnGIaJcuXmC/jMEr4gZ5jY+NihFtLYnJWM5BhDmCgiM2CP+1ojkiN+nlQ1gNZQvv4Js/n1dfLZ0rx3fuOKJy5Sw4Td/773/4h65I1VXWIalTHKlCFh4tzEpGOJPjOIdT4OjDVeOkGYoEbimGRyUsJEggDJYrFYLBaLxWKxli02TMxMWtUgROEfBGfYrdIq0jUkkl3txBBhVT3/GlQffBF273w6LKDFi4VJwgQaJuJIjk2zAwjAdcI+//mfgJd/9yf7/31EX/uJPwZf/2/+1VHbOJYai4YtC4YBYSJxfnnCRC6So2NmbRthYoaLir2UMjD0IkzYSI71lekWPrTYmOrobUMxqzpYTEpfixlp/CwkxUwXcRAQJiDsPqO4W7tj9k3HI0wISbaJx4sW4loKbbitvou/utqeBUlssOLEMAEw6DuOi6ciIkyIlkgOrVUDY5uj47gCX2CYeAJq88IX/aXHyy+VMGFMfalx2XeY9yZMpMZ0PNeHFtpipD81N1bGOCkvXgN1P3Ekx44YJlZXZr9SxsB6b8a4jEElG4cRECbiMQnNQQo0pWllosMO/i1oEpWhMW/Ito6qiQgTEBE9AkXfaaN4YiXX14aQoLy5xRAmllhgPiJhIhfJgYQJpLfVe9DWKIGkiV4fsyTCRBTJ4c7vE0VyAJ3fJJ5ZhIxiCXE3d/eOBAILNUxAFMkBxWpQg4A3vYb3ttRxy28jjOSA+HnSzvkKS5iQURyH+eF8n9lT939nmOxrOI6jqnoY+JLxKQ+IMKHJM0PXuEXWQKmqYVAI7ln1LqJkiv7neud9aT6bsFgsFovFYrFYrGWLZ/dzkzKECZofvCRpRVz/thBBuzvN/w87kLH7RVd7CHK/hYgWvbCAQU7bTCFCV9u0YcLSDaqnb48uOOzf/RzssLvxzGp0ELUtGJIFvdRCVRJxSySKVafiu1Y6WVBByseSlYzkKNfdO74JYQIADlImtIo7mQ90tCGpBtWHMNEgBowsrPaQuyYJ+cAbJpB8Yo0c4IuTYz/Pd3b64r7/jsNjrjPkAl/46FfI0tXuLAvGtANLjCEaNSI5kCxhzxvZYmxRCcKEzJi9VAthQvt9EEJAXyT3rJSLjSJFOlHYa7/j9+XuDykk98Dj5K47WTTNjUEkx7SECUXQ9ji+JgsXdQVQrrIGlbRhIursj6g3gkZyaO2MDkIIS2Y6UiQHpO/dkymxX6eQWLVEcsQ/z5g3xMU16N09MZWWNvZmYXNrGsnRcly6b9B/h8E8Bs1GsgAQAnRFCBNDDBMZwsTTn/2z8N5f+fcH7PjphHMpefnI/ABNgDI08Zl75zEiOdbEaJl4ZskYn/VuA9J9T/bevbA5ta6roKApyvUgao67rlcRPamPYcJ+LhohGvdV+3tKmIjVl/o0pdL3/4GECcgQJroYJup4vg0AD4gwAeSZQa6vmDBxQum6Cgg1AGQsrKclTPi5Ii+pslgsFovFYrFYD0U8u5+ZtKrNQqVbfFlW5wV2lgKQrku6gKS1LypgNyYWEapd2HEcLxYmCmZuITY2TKTygMEsfKr7F6Dun48+tnq/nc1CTxwt0LZgSBcDhxgmoCthQtXpBQRZzrILq5dSBaM+BTFLmMBuThUZJp79wp+HL/+pP0hen+jodZnJiW78ugq7kouy+0JuFEWB2xljTOisiDBBY310VJwEWpwcqEZ3ojOHKD9u0UU5kSlmk33vG8mhq/OMIwGxAP874LrMGWxEHM2R6u7SPrbASRbpscsV6P15XVw9NoYTLIgH945lFZCcMoYyXfsinStSjCBMOMPV0Os6iOQI99lFcly+BmozMWFif+/GVSwq6oRhwhEmigxhIhXJEUVENKg39FzXqvne3pEcCdPGDAwTKcPgKdRGUojH2bh4gkLMvsLYI1ma1y5tfCBmZFNoH0eY0LQrNjBM+GKwKFagdrfuWA2K5MjQGDaf/2V49ct/uff2TiqM5LiwhIkiHclxLGoGNQkkqXjZSI57/9oEYeL+N/9PuPvs3x69f6eUG3+tRFEOmgdlIzn63NfqHUCxcs9PjUiOyDAhLxKGCWdcmd+zTSN6DoA8u/SbP+uoONzrfoTfb0SYOGe81DGla2LcXV8l5x2sIykm1AAEtJP4vmOeR04UyTEVcYvFYrFYLBaLxWJNJjZMzE0RYWJxhWVVHSjqaPDR9tYwgQXRamcJE/alQgJ9wNWQRmQDJBa4WiI5qg+/Yv7/yCKl2m/GY5GPJG9ywGJyi2GCHqtEET3u8o9lFrg6nJdaJbs+exXvZypXbGhEcnTs+LbGKDT1xJ1I2y/9Kmw+/8v+B6kIEFG4baW2HxMmOhdXcfEnMApMU4D2i99NwoQzUxzVMBEVkgUlTKBxJCJMZI7D0EgOqHbnMV7RSA45wqCnagAhmgaJyBiX/J50kzAhRJqOk4zkuHxs/pTbp/bvKNx/JzH4nEC5Yq7aUgx7wozYIl3tDCaaRiSNJEwEBpaI6OENg4I9mwAAIABJREFUE49AbaclTNB7v1jnCT5a1SCKPGHCmyFIF3SRjuRI0lQILQtgqGEiZcybgZk2cT86hUR5kZ2n4b3WYfRzhAlrAEDDhChW5n64sDlIEKF0TMIEiTEC8CYjAAAoVqDunvm3DCBMQLVLziXLJx+H6vnXAgLduaVrg3lHygYIH8mho0gOOEIkB41xU/sNyIZhIqbsGandfUgCgXAe+P5P/Qi8PzN6R0PWNIyKx9auSsZNtUQSJrdhKSge6R+ODY48cvMR87pUJEeqQWAmcmNlGXXcA/S//8cmvh73I+WMGyFZZMj3PkvR2KffAZEcd5/+BVA9iXrHUpIwgeQ1JEwEY/QpCRPTELdYLBaLxWKxWCzWdOLZ/cyEhU6KFlySMGoAANJFnbZIjnoXFtCEBNDaL6gmciKdKSNaPFYZw4QQBVQffMl/3gjpajvadHEsNTqIZJFdMHTRBuVF+vxyhelMJEfHYoNWdTrT03aQz2mhvLdSBoZi1f2cst0xuUgOE9PQLMwFC0SuszDxXSCpxu1b90gOtz1BDReZrv8jKzYwiJJEcqi4gNlCLuj8eQkyCxhDjDvHY6pH5ji6BeOeY4KutmeK5NiTSI4REVBx/EuDLJE3TGgSW+DfnzF7JRYl5ZVBp6u7p+Hv+naYzkkiXcBX98+huH5sX9Kvm1Xvt83xnNJUBijoqosKVEgvEecgTNBioiP4pCI5LA1Lpg0qvhBHijurizBypzZFvzRNRQfnKsXvd/5bnEmoaRI959yjQZU5kdBkkpor4Pdz9Q/8AfPauNvUCrvB1QYNE6U5ZxdmRjbjNRoJxxMm8pEcEWGCGCaOSZgoHn8M9O5+8vGhTRgp6AxXaMCLCBNQHY8woVsIEzlSnN7fe2NLgjChNi8HfVdTyhQ8aeF8NWge5OMmKD2pJZIwtQ0srmaeJ/0zUQnytY+66A6qeRMmMqYSgAFFZPN6jMQTpKv/oBI0EGMamt8xGyJqNn/okRz7p2/DV/70H4RXv/JTZ/n8IP7VitJOdGzUO2Ukx0TzIRaLxWKxWCwWizWd2DAxN2GReQ5dhAOksQgBmaIO7brE/9bYmb0PDBVCRgs6boE3QZiIIzmqbbNbCwBAFm6BdnQkR7WdEWHCLhqufOE3u2CIi3/rq3QkR6pji6roGKmhVYDPR7lFjqUhsalS2fI9OoixO0bkkPH1DqCuHMnCFaiIiUFePzEvvXvR/ICIMCGKcYQJIaTbl1NKRxQJSphw9A7cr1MSJrRy53h3wgQh5fTch3N02NGIB0D0+JCChaod7QSAGNri6KVsJEfCMJE61xKRTPLmDQAAqF68b39AYkEWOr6YYm6CMHH/AuSVueZ7EybqXTOiykXtDDxO9PuIC1SUMDFxQZSaJXEOkI7kqFzxPGUUSqHe427YxqI9GZO0Uo25Su/rPKJUmP05fyQHJGgvp5A79qm/1f7s6ju+z7w2EcEGAK64Wd89tz8o7f1wWeMDjVAaRCuJt0fnMBnChChW/rgBgN72J0yYLPkUYeJjAABQP/9a722eTNYA1TAjyPB+crRIDkuY0KoGqKvmOZy5FxpzRbiPAQFjezv7OAAdIfWHGMoA6Bwuipvoa5goVtnxhs5Lyycfc0bNQLMmTDQjOdDw0JvEFREm+tyP3HdFznNjlJlH48FoEZO1WJlIjkU3BrRIWaqbi7qaWnVIqAEAN57oem8JehFh4lSRHBPNh1gsFovFYrFYLNZ04tn93GRjDLpGclQv3oWv/Jl/CuqX70+wcx1EIzmSmHdCmLALLooQJjQtsjeQ4WF2KgAxTDQiObbhAhqKFJFHLzjvt2fDUcZqLBq2RnLYQvD6ujWSI2eY6BqpoVXdLIYCMdLMcGGxq1KZpUF8xMH3h52MKiZMuGvCbi/xefLyEYjyAuqX7za3r0PCBMg+hIlEt4ycpgDtFk7x3KP5xrlIjiMSJmius4tdiakemQIz7rsZx7rvkyHVnIEwUVce8T6mCBvHv0Td9qJvJEemO1RThLxV8fgtAPBFN1ywXHIkB1hTzvarn4ZnP/8T7sfq/jnIq4gw0XW8SRAmxEjChEf6F7YDu1lQlJePQG9eTWK2cp+9uwdpi4nOkJbo9NT13sxRcoSJVN56eREY2eJFexczphUAaFeUMu8dGMkRXx8Zk+ikmoow4SKrmvMs/Psf/eP/MnzsX/tv4eJ3/b70NhqRHKUlcC1s/kGK9GJ1AaDqcaYPQmzLESbiSA41IJLDGPMShIknHwcAgOr513tv81Qy8zIflYbnt7mfkPGt2gXkmcFCggpSEmKTt0zP49Xu3lMwRIIwsbubf3d7vQ/nVuV6mGEzF8nRxzBRx5EcecPEW3/8v4KP/tE/2djG4ggTcUNC962Z/6BhInPMWveDjgc9npvmLhrj5+ce81gjOLaQYNM1hvLYMrGWGcKEHfuC8+yUhInEswmLxWKxWCwWi8Vatnh2PzNpi9L3BZH2BdHtl/5fuPuNn4XtV359it07qCCSo2x23Kj7Fz4fGN9ji5ZmMYUUGSLDhCtgkodSfCBuECb2m2THoTiqYWLj6BjnVgNL21LgxsUpmSNMHDJMyLLbApdWYdEehT8b2tk8BzniAxlC+xTEbJFZ5iI58LyqsAhvr6GoOFc8fgvqF03DhNk+7d7rQZhIRVFMFMkBVRi7Qc+1Bn2CxGcMVaMoSovI7jjQDvI8YcIt9mvdq8sQCROTd6LRjuWeEQ9UeM9yigkTmUgOrXWyg/5QJAft4iofmy7lCruUaSTHhEX6Y0oUpoD/7H/7MXj3v/+3TB6zUqA2Lx1hwi0Md76m4zxnIOPwsPPOmcYsYYJ+ZwbDbwwTAAB6QKF10D5pHaDt8XjVt8+aL64rExuSo8a46KqQMAHgx41mpzk516Nze5hhIkGYsOauc9KtUobBU8gbYpvHzc1jLm7gyff9QDPax0pe3AAAgLKkBFGszH1lgYQJGskBMHIOS4s8gWEiJEw4w0RRDiNMEGMeVWkNE7MjTASRHEizCiM5jkmYgHrv5n+pSI6keXDXjOSg8yC9vQU1d8JEXYeRHJa20VspY1tPIpohTKxtvJRoPt+Q+ffV7/n9cPHNv7e5kWK+5Dxd7cx9JBivCU2t18ZwvmDf72JMOhgmEuaWoWSRWYoYCWWLWfMhCOd0Z/vuVJMw4Z5j7H0qNFGJ4BmrfvUhqAH3s/S+NAmQLBaLxWKxWCwWa9liw8TchN26DrndvgjhFu7n0sVAIzmijht1/xJ2X/ssXP5u7AS0Cy74N1Q7syiJXcKNgmi0UAPgF2vqlGEiHcnhXnOMSI6ZHPe4U35UJIfrAsosCBerbgXhHGFCLp8wQburUYLSEA69/UAkhybUFQBIEiYAIGuYMMYlsm9dTS7mze497v1CTlJgcguqtiAURHKo0Ezhx4EjECZclI2Pj/DdYmG0SdaIRBaM+yCG9X5rFqEnXmgPUOn43yHdYhnChIijl+LvyS5eNjC2BwwTdEwpHr0JAKTolkGoL0qyAK0q2L3z/wGAIUuozUsArYdHcuzuG0ZFd38daoSKkP64HY2GoWIF8tIWq6eK5aj3xqhn7/3lG58EAIDq2VcbL9XY4WyPd+P3KeNgERbw2yI5YjrEkMKQ1qpxfQhnsjvj3GMqwkQLTQPH22x0GG4DCRMbiw6XpZmjLmz+oWPCBIw8B7KRHJ4wIUofyVG89tFhhIlq564bqtkSJorSxV0Icj/REUEHDpx3XSQcYQINE4lIjmh8Nqaw++Y+UsLEAiI5II7kKNeDnsn8s09ET+gbyVGSOWdswI/pZgnN+bkGKS+Cmu8GEiZ8lE8YydHl2adh7Mf3PxTCRF0BCAFCSn+fnvt1OFBImDhX00jQnIOy5yLuW3CeRXTAr/ynfxje/6kfPs6+JJp5WCwWi8VisVgs1rLFs/uZyRMmunWQNgqrZ5amkRxR9MLmC78CoDVcfus/Zl6MkRwRYcIVHdyCjl2gSWTYuwfiBmFimzRMBAXnEZ0RWtUGiTyTzphGNmxrJAcSJq6TWGqd6KylMpEcHRbHbLxMQ4kF3qUpGcnRizBhOxkz3cKuIIfb0+kCVfHoo1Cl4njiInaPApGLbDkDYcKfe3YRtiS4XvwvdhW1RT10/TwsuhUthIkokiO3IE7H4K7ngdaaRHlMu2gcdiz3IxYE24nONRGTJbLfUzNiCf+d7A5VzdfLi2sQl69B9ewd+6vlR3JgvMX+a58FAID69imoe1u0vI4iOTp+X4rEVPgPiiOveiqI5CD3m9obm+TFa+bzcXH9xMKOQaQKuC52e35Q4VwlZ4JK4cPd/RWv7zhHm0T6NOgQQ7LatYLAIEr2IaYSTSmdMC+dQs4wkYrk6FDEBEgRJkoQIm2SmbUCIlCevNFVNHc9mMes0oSJ4tGboIdcx3H0glXx2jcAyGJWhAltCRNI/qKRHAERjZoNRwgNoRjJJuNnlgQpSVc7AK29AS6aT2utQdtIjsmpVT2kqz2IIoq0G/A81YgjBGh9/klugxpgEtEg3QwTSPqY33MNNYR40fioPhsLGxf6xLmlTIiDyEszlSYmIHlhjXpMmDiNVN24r+C/0dgXEGzKi2AeUT39KtRPm0baQZpoPsRisVgsFovFYrGmE8/u5yZtik+uIHKg47dRWD2zNF0cjTpPNr/9KQAAuPzW7wEAUlhzxYeQMAExMjTqbAEgC+rxAtd+Ey6goY4UyeGMKtV2FouSrsuKFn4zSFq3+Le+PkCYyBkmVt2KDapudo8D6cRaWsGCKrFA0rVDTitlFryLknQLR5EcVRhD4U0M4QJRmSNMRDEJBkHe8Xjjgm9UCJyEMBGde7T7zJsb7LhyBMMENIxGfszxphjSBSmLg1E39O84KFW7/Z96DMfYBADaHTmMMNFA8wtBxukMYSJhgDP/lGFxCt+t011c5aO3oHpuC+KIxO1ZMJmVZAF6v4Hq6dsAAKBun7pir4/k6NfNajqSE8U4gMHRJWEkh78uaHFJ2GL1oELrAKmd7Sy0xQpRrqF49GaSMAH13hQ3coSJFD7cXi/O5NlGmAAN1OwgimYh7qC0buRi4/eozmiYyBGPjq02Y8Ch6DC3DXsu1NZ05AgTMyxstikkTOSNJJ1Fx188x4QIKQfFyo2jxaM3BxMmUt+RkBKKx2/5OKU5SIXkL/e8cKpIjnJt5hpY4IueWYRskuKwYx2R/3Gh3nW0az2b58KU4rFzOGEiYfDue/+PCRPx8yTeH+KOdqqe1Kcppatdg4gihhomHRlsgGGibppbUsd7sSJFfDSePXTCxLnGGDS3Ublz0Y2nkWGCNCbo/eZoZhY9EXGLxWKxWCwWi8ViTSc2TMxMWtVmcQ4fBLsSJmawMOZQ3DIdybH5/Kdg9ea3QfHoo/YdtsOF5IFrQphoduw0O4xzyGaVieSgxbZR3Xm0WDGDxR6HOsVogcRCq1Ntix3ry7QhB49LrhAhy25/c44wgV1lM1xY7CpfTKfI9Y4dcmTx1XULx4SJ6LrOLcgUj96C+uW7TdOOjgkTq+7FVVcIpYaLaQkTLtanWIGuKrtfJ4zkiAkToMn3FJI2dKKYDwAAlT++nQkT9HufmjBhc7sBgJjbxhMmAMAcxziSIzpHcwaIrNkr08VVPPkYqNun5h+u8LfcSA5RlMGxqu88YUJex5EcHSOA9ttGJAceq8FGKEeYkEFmPDVMIN5/SKF10C7ZRXwaK1C+/kmoEp2Euq5AlCszT2kjTASGiZAwgdFKXn5M0kqF94dy3SnnPdyJJmFCZqhEkwqvz1MbJtqiJ9y94gBhAs/BexMLI4rSEGgWNP/Q1ljnDG7leMJEeP1aksLqKsD2U1NA+eijg4xPbeaC8snHZ0eYENIbWV3xMxHJccio00V4XDCyKG1qi+6bLr4jpGA4wxoZa2ddrLWxTU6DCRPRHA4guB8BALz85b8Cz37uv85vo94FJt3GfsTks4T6Up+mVNK0NDCSwz+H23GCCRNOhjBhx9JM3OIQ3f7az8Du3c+N3s4xhTSvsxkmVNU0bDYME5QOdhms25hI1SOZTh2tSRx4IYvFYrFYLBaLxVqK2DAxN2Ekh7S54AcWdXW1Df57VuFDIy6CFWHHzea3P+XjOADcgoumkRwks9vHFWDRuPlQ6joKGpEcmybe1rzB7NrrnzAdWAOLRUGnwgwWe3yOb49IjtVVOpLjQOemKLsV33WWMDFfdG1nJYrE3QkTvjs31y3cIMdkOnqLx2+B3t03ChnOeIX7VpQHzVdOKaPARAVok3e+CrrXPGXDHlssFuP4MSqSIzzX8XzVStk8YhkWPUUbYYJGcnQbj+nYMfk4EiDeRxAmdIYwgcjm3PfkxqdokVFkzF45w8SjN8lbPUJ9qZEc8biibp9C3SBM9ItQUbt7EOvwfui+s4HHyY3foggz40khG7v79USGCex6xBgGAIDijU+4yBYqXe+NWUIWoK2J8L3/6d+DV7/y18zvM8UdAFLAV2GXozvXlQKICRPlgIJgC2HivJEcExEmWowB5l5RHixSIOVEbV6Yfxcr853ljG8zVExXcnPjEYQJGskRF/lQ9NwvHr8FanfX+36bI0wAGLNblSBknU3KROy444BzqMgwqo8UyQG2SK/u7bnZJZLDdkU7U0c0n6bxR3rGcQABjRDsuVbvB51f7v0oGT7/PP8//jt49nM/3rKNfTthIqabpTRjwgQQQ4hXRHDsqkYkR3fzZvK7ekiEidpTU5AAcwyKwTs/8cfh2d/8L0Zv55hykRznioOtq+YzuD32bgyM4tRcI4LWxjCx6zeHuv/cL8HLX/mfm79ImcZZLBaLxWKxWCzWosWGiZmJduuKojy4kODQ/bMo2uOiUpMwUT3/OlQffAkuv+17yTtShglCmHDYYXyobSFMRItUutpmCBPm2K4++q3+MweILlTPwazSyPFtIQIcjuRoXxwU8vB5CQD5RYSO9JRZSyuIC7dg4yMOLvjWnjAhXfErMvxUoWEihwRGWkuj6BDlu5rvrCdhInj/RAXouBuVjoFRl5+gNIiB0tXWFEgIkhy3SbvFwv1JH8chkRzhOHLGSI4eXYINReYcAPvdxNFK8fdEOpyD92bGLm+YiyI5Hr9F3+z/u1BDVlyErm+fumJvYQ0TMCCSQ64iwsRQJDdKEUIIMeh5wkTpu/u30xImBDFMlK9/Mh3JoUyHMyVMPP/FvwCvfvWnzbYS0VRxRESDMEHGDzqXwff2vcY1MZC67bh7xgwIEyfO7I5Ns1RdYxHcOWhNR1CUdm69oPEhNgtmyGq9RA1odgymZBaAcA5YPHoTQNX9z+EWGsNcCRMyMiPEkWSamA3HCI9LK2EiGp9VFMnh5ii6aZhQMyZMNCI5BlKu3DhNo2Si46b3u9bx0hhg7HNrwvjcpJs1tVTCRH/DcUiY6BXJkaKBlGsfy7lw6RNFcqjNCxc3NhedPZJDxXQv/2yottZURq5Xsbr0Ear1HkDr3rFmH/z1/wje/8kfau5Laj2AxWKxWCwWi8ViLVo8w5+baB68PNwV7s0GM+jQiIq6nv6wh81vfwoAAC6ShAlSHCYI6kYnZWKR3hUwEoSJYAHNvcG8d/XmtyTf11XzJUz4TnmdyaZ3hIn1Vdow4QrTGeRwV1pBZhFB9Cz2zVFaNbvq3SLgISqMW3wtSadoRJjA6xq7d1oIEwAA9cv3wvfH3Td9CBP1eQkTQUe3NaGY30VGHixGZs7zzp9HO+/oNhu4fXv8c4SJAbSIgEoxeSTHnkRyDDcxpa4FAOE7vzORHO7f8RiRo+NkDBYFMUzQAtcUETInEVKQ7N+l7p65Yq+8emxe0tN0pnf3Gdw7DD9O7vsojKEKkfAkksN19w9A+Q8RRn/IyDBRv/h6wlRpO5xl4cZkvd82xt4Q6xxRr+LCqTumunH/M4W4voSJZiRH7p4xpabK7G4QPeg+xGN3bhtFCaJcu1gbpIosybAZF2zFMWJZyHzaRXLEhAnyefLykfnMnrQYpEalVD75OFQvvp6dq04tjYSJVWhGaNz3jxbJYTuiM4QJkShqO8KEo2CE0UpBJMeMCRNxJMfQmBld7cw5TMYiEVGq9H7TOl4G804y5/T7GhmWUkLSxwyfa1KGCTGWMBEbJjqsQbh5cTTHfzCECVW5+duxIjl0tQOoq7Pe71PSZ47koPGvTtikk4rkIOZLR5roOT7u3/ls+ntIGFtZLBaLxWKxWCzWssUz/LlJ1W4BzCwkHDJMROj+Mwr3tRHJoSrYfP5TAELC5bf8I833uQKFcf1jQcwZJvD3riOOFBBcVxItPFbGeJKK5IgIE10z4Bv7TLMwz9npifsQd1m1FQwdYeIqWdw/GMlRrLotjiULqdDIXF6kMpEcAIeLGO46IVnZ8Xvc9RxFcsSfid31dYowQReQu1JBAAhunXZOT1OAjruGg0iORpdfhlzQ5/P226gzkRAmdB0eAwCLclfJAk9AmOi46B8QJiZG25rc7ogwMcR4lyLJSEmOZdowESDhqRIYcvOGTCRHgjBhCvjzKML1FRbRLr7594IoLwxhwhbU5PWT4DVdizMmkiMqhpL4mSHykRwxYcJep+XKdayfM5KjfOOTAFpD9eLrwWtNh+IKROGLobraujHXGbRSkRw4XtdVNEb4c13HhIkhWe2tkRxnnHfMIZKDEHIObmd97a4hQxQyBp/69hl88Ue+B7Zv//2j7fMpRE1IAPQ8HH7P0NSAZr/HmDCBc3hxcePidXqbn1rMBcXjjwHUFajbD/tt81Sy13Mcd3GqSA5PmHhlPqaDqQ0LsGjqEEIEhtYgkmPOhIk4ksOZ3/vNQXS1bZ5f0RxCV9vWebmuvaHAPN9EBvyIbpaSEGK2RqwkYYKa+/psK4rkgF6EiSYNZNB9sYN0XU0+B6TEKSR6jY3kwOt5brQYJF7MijBRIGHCksaShomtI0v0MaGo3T3s3/9CehzhSA4Wi8VisVgsFuvBiQ0TM5PWyj94dYrkwIX7ORgmMLs8iuSoK9i9/fdh/fHvCAoZjjCx96YPrZXrfGkQJuxCjYi6NvG9bj+QtpCL5ChWpogCwx/2VTX3SI58gVvXe9ORVV5kIjmaKHIqIctu2FmtGsUefL/59fwWFrsqiUrHzNpDC1vO/CDNgo+QCcJEFMlReyoFVZExTGgdLeC0REk0VDfNGVMVoFOECbffcZefIxeM+Lw42xmLyFrZDsjweMuMwSXYP4DOiOGAMDExJUjXe4A4kuOIhAm3oC4yxpYM1l9ImY5/yRApgkgOV+CSrqi7ONm/Yf3x7wR584Y1TDw3JAcsaLq89I4mqP2mGcmBY/PQ40QNL9RQ5eYBK7e/Uy325yI5AADqp1EsR703x9ESJrSqAVTt7+14DQcGrnC+0Vi0D851DZQOMaQwpFOEidUR6AJj5cwypzZMIE0jTZiADoQJAGOYwHusKFbmO68r2L/7W7D94t+D+8/87ePt9Ank5mklxgYc4Ryg1y+alDOECXlxM9j81GYuKJ98DAAAqpnEcuD17J4d8NpORHIcxTCBBT6M5CgjKh7e68jcqxHJAWDHsOVFckAikmMIYaJx3KLnn06ECTuWJCM5DsQUosyz0fzmHY15LgBkyV+Htxa83x2TDnPHdMzVypqQj3vcvvAnvhue/eyfPeo2D0rVnrB5JMKEi76YK2HiTGtPumFWJUbiBGFCEqOpa8Lp8d3sv/6bxgibmotk1jpYLBaLxWKxWCzWcsUz/LmJFJ9Ep0gO87CqZkA5ABUWdWmmq9q8AHnzRvSGMJIDYsJEjJ5OECaE7Y4LIjJwYTxlmCjXUL7+SdLZPzCSYz+zSI59GMkRL/AGr62xszaNQnULIFGx2KlYdcoZ1qpOF1RmjK7trERHiV+QaV+E0fF1srrMR3LguaXThIni0ZsA0IzkAFU7zDZAt7HE71+ie3iiAnQDcU8jOaIu2+ELvuTzIsKEIAUKk7EdUURaFkFTpq0un+/+/9QLjxUp+jhz25EIE0L47ycbyZEgBgGExXf68gyRIojkwN+JYlRUyzmF59zqE98Jxc0boO6eQX33HOTVExdz0pcwofdNwgSMJEzQSA4gEVD0OkWD5OSECdIpj+bI6llomHD3QVkCqNpjmqOxNxnJgddtVPRzJlClAJRySH0AACiGESZETJiYRSSHvRZPXCRoJSn0KFpTo66QpfvOMcJl/8GXxu/sKVUdnzBBiT04V4gJE4FhwsXr9DRMpIq1VsWTjwMAQB3RX84mW/BEM4KLKiGRHObaro8TyYGEiVwkBzVwWrnnGzKeB/u3oEiOgNhQ9iAVaA3v/eQPwfbLvxbQIZziSI5q2z5e1nsXE5F8LoriJrMqyk7PRlNLV/tmROVAwoRrXIAokqPL92bvm5Sk4sey4xqG9+99Hvbvfu6o2zwkaqCMDfT7974waLzWzjAxgzUeImfkONf6h66baxRoQEPDBDW7rjDea+PmeKrHHGr3zmfM+1N/r+JIDhaLxWKxWCwW66GJZ/gzk1aeMCHKLpEccyJM+KgBACBxGXtQm9uQLgHgij9YKDQPor4rsxlXkO4wNgVnv5iAD8GpBc2P/JEfgo/9Kz/Ra5EnJT07woTdB1xQPxTJUa7MYoOqg3xksy2TOS3iQqaV6EA+AYBmwYi833zQ/DqxukqT6BxU546iOlx8FauLxmKYJ0tgJ7M1MUQGFLm+AnH5GlQJw0RAiChK0x3TpTjqCBi0EDhRATomTJQkksOSL/wiux0/xkRyxIvttEM8kZEr1mZMSmF2g0iOroQJ+rqJFx5pIcsd0wP3m/17X4DP/dufgN3XftNvJxVPIxKRHPH3lInYyMa/UIQ8UZEgTGQpFUuQI0x8O8hrY5hQ98+hsHEcAKRI0aWrU2vQyUgOa2oZeJxoJIeQHgnvDBMEbd8b4z9Q2PWYIkxQw4RWCkArMy5a2oCPQcLxJmGYiCIidF3tQ6+lAAAgAElEQVSHWHloJ0z0nqdp1bzPSAlQrM4778gY+I6tNpJCslCaUWAEKEpDXFKVK0ZVH87bMNGM5LDFzzH3DEr4iWLwUO7zSCSH3vW7ltuiU0prmKiezYUwUYeEiUQkhyYEndGKCRONSA40G1LDRBjJ4fZvaZEcKuwQd/e0DoVhtXkJT3/mz8DLT/3VZNxE/Pxjusp3jWcd93u6jYQhvGHWzagzfW9imb8v3Hf3/N33/q9DwkQvo4trZiDmDbJOcCxpVZuon6lNhXXl441W/nlQbe/gC3/iu+H5L/7F3pucLWECjVnniuRIESZkSJiATCQHHss+4+Punc/698fjCEdysFgsFovFYrFYD05smJibKN5cdojk2Eed6GdUI5KDdMGq7SuQl6+Fb3CRHORvUL5AgF0oamcXCnII9/IijMiwD8ONPGAAuPhd/xDcfNcfas3G7iK6eDGLY19tQZQX3uQQZfgGr633pphVZIqkLZnTAEAQqgcW2uJYCJTs1x09S2nVoA9Ih59v78BMESbihb24y9kdqwT1o3z0VjOSI45J6IPNxf0LIjnyxJJjSkfnXtDtFxUqxDEIE1U6ksMQJsJiKEC4CJrad7rdbp9PCRPTRXJoVQNo7RbRRUfCxO7d34L6xbuu2woAwnsWSvhIDr8wHxmzEhFL+O/k2JIxWBSPiGHCESZ8AX9pQmPh+pP/IBQ3r5tIDkuY8C/CSI4O13Oiq9OpzVh3cMMU6Z8uKAopQayvnJHh1HKECWKYKB6/BSAkVE/fIS/E8ZQQJqoEYULIcBx0i+47v50EYQK0Nv8ToWGiP2GiGckBYL7LyYtBRNQsc0q1kRR01Z0wgcV+ACRMFKagtkXCxJePsLenU9MwgcdluGnGEXukP8fpcQIAd6+V62s/v+lxLWttjYcHCBPV85kQJqxJUhQllG98I5Qf+SYAwHuSPec7Fs+76BBhwlMAmpEc9LWCRHJQwsSsIznqfTCfbRrkW95r/676xbuGEpYgTNDnH1cgzZgxqGFCFKvGeNPVMAF2XJmb0pEcOHZ3mz/ff+6X4O0f/af9M7N9vzsmVZe5yMbcE2nn/8hn8fTnbP3nTSjz3BVFcuzvob79EPTubpAxDK/nuRkm1JkjOUA1IxNdxBFGs9HoFxLxSs+PnIkq1u6rn/b/iCN7EsZWFovFYrFYLBaLtWwd4EuyJpeufUGwWHWO5JhD0d5HckRFONvJJy4iwwREhInaEiYQO74K0dMeyd7M9A7Q9hhPkSoQ4XtGIo3DSI45ECZ2YdeOzBfCMH+ZUjZo91GqYysQFohUBSDzr9NKNYgIAKQQv9CCJgAkO0piwsTdZ/53qF++D4++558N3xsRJuTqMiycK+Ve44qPqZgMq+JxaJjQWpvX08VoYl462JWL3wtdjCIF0VOqkXdeUMKE71y3/wffNfzzokiOgDARF0OhnSISRnL0J0xMOYY3Mrk7GmpwLMaOWAAAnTJGUcLEoUgOGRWEZdrs4GIAovG/eO0jrvAvSEfwUgkTj37/vwCrj307rD7yTYYw8dVPg7q4CQwTNO7qkHxX51Xzl2MME4pQBigCHa9TNOOsrw+ayI4ltbsDUa5D6oMsoHjy8ZAw4QpgpS02VgTT7A0Tjc5lnDe41+xDegEZk+JF9GGGCR9RFuxHgko0qVQNIESWQnUsOYNKoijTizBBDRPWJKNV7YpR1dwjOWKz4JEjOTA6TUZjhLuGL64dtUX3ocUcKDTLq8cgyguon8+FMFGBtBSpb/lTn/FzAxp5kYjqGSpX4MsSJryB0+2jnXvIdY4wsaBIDnJeSFLQPCRnmHj5rjG9lXHcREhOCsxw6+ZzITXOinIF6j4yMOOcPUNKcR9bzJcwAQ1TiR27O5Lj7j/983D7az8DV9/xfcH7e0VyVFsQq8vgvuHmMkeM5HDf9+SGiSpsGClKULt7UPfPze8HkLaw+D838xPO6Y4dpdJVKcIEHnu8ryfj1KotibpUQRxPm5AwAQBNk1bKNM5isVgsFovFYrEWLbZEz0ymQwE7N8qDD6NxV+Q55SI5sFiB/633oDavGpEcKcKEJlmQIl5A05lIjvIiLDinsJ+xcJFnqGGiaho0zilDmCCLAyKPpDedXStPeogW+Bpd95GEQ7AeWBhUdbrY06PYN1dp1ewooR1FAABP/+Z/Dh/8tf+w+V4dmh9EeRESS1KkAlzUTBkmHn0U6hckksN1jlJCRI8Ca90kTICYkDBRhIQJiA0TuMjec8E3/XnhuU4zw3VdQUyYwKJzKpIDlkSYwAIkFgk6LlrjWKe2r/wPVd00RglB4gmOGMmR6OISsoDi0ZvBtlojiWYueXED199pihLFzRuGMHH/AuTVI/Ki7pQeh3BPFIrEiOva3V+kDI53bMaRFzdB1/MpZYyZN42fl298MjJMEHMnRlPtm4SJhmGiiCI5VDRGtBEmiv6GCZ0hTJgYsjN2nGqVvBcdW96gkjJM7DvHIghqapGFLTBXrhhVPX171sSrXCTHqHk/HX/xmSMiTNBruCtBK/iIA+YCIYQxM83FMEGKcPLi2s/RiAGvM22ggxxhYmPup/EzCz4L0rl8ygBn9s8aOoJIjnl1pVM1Ijl6GCbwHKxevJc0A8TPP54wkd62mQf6RoXGXCyOm8xJlvMcR1Im+J6G4/r2KQCQud8Qw8R+k4j9eTiECair4LlJrq5MJMfdMwDoN3aiZhvJgft1rmYdVTXmIJ4wcR/8G4COL9vgWHYhdWmlYPe1z+YNnEyYYLFYLBaLxWKxHpx4hj83qdp1e0GXPNQ5ESZwwQSRlIUvrKvtK5ANwoRRGD9ACRMRotUt8EaEiaxh4jBhYmhualjoPP+xNx0PlDDRQgSwnV2OKhHjJQ90bnbF9ycxsAC9cPKzlW52lMTIarW5TS9yRfEaIiZMBP/fF+YA0gu2xeO3oHpJIjkcLp1GcvQ45ol8ejEVYSKinYiAMBHHkmQK8X0+b79LEyaUMsdcxN9xeyRHX1T6uQgTDQpAx0VvR5i4p4aJRPG0A2FCZ8ZzyJm9tEoasABs7AIQk8+CIzmo5M0boO6fQ333NEmY6HI9q1RHsvuAYrjhyBE/CqAI9LigKNfXbtH/1FLb26YxEwDK1z8B1TMSyUHmKkIWoGtPmHBzqkQ0lade2dfWMYWGnuuamIbsnEOrfgYVrV3RNNyP8xomdMokdQq1kRSq9ugwKndOCGkiKAokTNhxXKvAUDM35SM5hpvsPLHHR3LEhAkghgk0IvW5lruYC4rHb0H98r3s7ydVoggHAMH9REf3zjGihAlRrpvElrZIDjqeC0KYWEAkh49qGWaYQBNg/eLdvBkADS5a+3l0zjBBtzEikkMUZafYu6mVNMFjw0LH+78zTGxw7mfP1b6GiYgG4g34JyBMVBMTJnQdzAfE+spEctwNJ0zomRom1JkNE0lDexthovTE0oAQ2mGMrD78MujdPay/6bvsNsLnO47kYLFYLBaLxWKxHp54hj8zaYL2M93V7YsvKjAbnFc6iuRwXbDVFvTuHuRlJpKDFCioU98/4OLDaYYw0Yjk6G6YGB7JQYgAsyBM7MKFqCjDN3itLUrnusobsQixcJGiZWFQaw16d5/8DvD8noJYcDK1RXLYxVy9u0sucsXmh5gwAfScxO9GNU0MqNIWHDCLVSfiO7qaXOj7g+tsqgJ0vQ/yzoNuv3oPIAtfVMhFPfSQMQeRc5123aUW5A5EcmDs0CDCxFkiOezf5wgk7d+x69QkhAmdwNEKIYgRIvM9kYJd8N6cOUerxmtRpTVMuO9vwZEcVMX1GwBaQ/X0bZDX1DBhiwydIjmamfduOzaOYpAUIUzQDuc4PmB9PS1hYn3d+Hn5+iehevq2fx2lYckSQNcNWpeudsFYBEDmDWjiiggTODZprSCO0xg058hRVSKT6ORK3P9OoTaSAkaLddqOPSeC8U5VQXF5zrEccZH+qIQJ6SM5RGSqcgYNQpjoUmByH9EhvsIQaOZR2E8V4QAgMCC76/cIhAk0BKn7F+nnlYRhQu/uAYQIj6ks3L1bbW9BXj02r51rJIebow4kTFhTcv3yvbQZQBID34H4RK1qQ8kqkba1SpjIo2fbjMRMCRMpE7zoSZhQdyFhQkSEiS7NBypBmMB77DHnv54oMvE9Mho/xOoqiOQYYhydLWECIznO1DASE2oAwI3JeMyShokqJEx0uffs3vkMAABcfPN3u20E4kgOFovFYrFYLBbrwYkNE3MTWYgWRXm4wDkjwkQcyYH/VXcvzL9jwgQWF2hnp04QJnDxI1dgiyMN7PZaDRNjIzn2tDN8DoaJfpEcQpb5SI5EZy1VF3y/WyhPdjUfNlyE+1PBF37498Gr/+d/6fT6KUSjY1ANwsT2Non7bFwnq8toUZecWw793jRBoIpHbwHUlcO+Js0VBZpUOhzzugqNCeaDJylAm8VvsghmTWNa62aBzBUnxxAmtk2jEYAlTNSNBbm2SA5d710nc9duuWD8mTSSAw0TpEjQYR9cJIfNXDf/SBRPhQRnlBA5EkjaAJeL5EjF4KCKxzaSA++dLYaxJUnevG7+j6qhIISJPpQeXBAWcfc4oJlhWFENxwMhZGjQiwkTF9eTdTpnCRNvfCOoVx+AQlR37Q1DwhYb3bnt6BGJIpNbdEeTZ7RoH0RyhHEag+YcM43k0Jm4rWOr7ZgZk2i3ojXem52Jx1JFaAFrP2PDBMQmpAHmm/r2Geze/Zz/AYnkEEUJ8vIRlE8+EbzHU2JGEiZaviexvkxHXJ1DKibGGLmoLqUa49sY4f1XbV6mDW30c61MrMFVMD8T0hMm9PbW0IhkMRsjSqyUAQH//k6IfHu+qLtnoDavmvGLZL6aog8G20LzKBomynUikgOvvwORHHMmTDQoHHiv6kqYsLESbu5nn9Oluf93MmNXW5CNSI7uhouuwu+8y7l0TMXmYbkOIzmGGEfxeXJu5qdzEyZiQg0AaQxIESZoJMeBMSHW7p3PAgDAxe/6h902AjFhgsVisVgsFovFenDiGf7MpFVNumTLg13dbuF+BkX7RiSH/W9tFwvkZVTIEBFhotqBJl3EjUgOV2ALCwhydRk8tOMiiYzQn8FHR52ifXWuzvCcjGEiKvy2GCagWGUXqlKZwFQe35//u3ULBt4RJjp2YqnNS9h9+ddg++Vf7/T6SaQThIlVgjCRui4jQ4NYrbNdcO7cwkXYVCTHo48CgMUTQ9pcIfoUWFNGgUkjOULCBAAY00RkmBDHiOSIiqKuQxy0OebRgpyL5Ng2Fz51vXcUndkTJmrs/F0F/z10TeLY6rHMzUViI+ELqjlji/IFu+CdUoJWie+0ZVGyePwx914AMJ+tF0ywsSpu3nD/PyRMpM1uKTniUmIsNmaGgfQH16Fe2OOdjuQQ6+vk9XIKqd1d2jDx5OMAAFBjLAcet2Jl9p9EclDCRNMwYecNOF43xggyJhHzp9mJ/jFgOhfJcW7ChFaTRHIIKa1pLmGY6EOYsOeEu68VZm6td3fuO60++PJxdvoEckVdnFuv+hMmPvxf/2P4yp/+Q2SjoWHid//JX4cn3/+DwXsoYUKUa1MY7TFedKExyNXVZOPDIbUSJgDMOVOHBfYxwvtuljAhm0Vttb9vjuWUMLG7A7G+BrG+mo8RJVbCgCD7RHIQI0j17O3GOCBoJMchGqDbF28ejZ8LO0dyzJUwkYstAehsLHWECTRMiNAM2DmSIzZMjKQ9pj9n6z5vUql0JAc2jagB45zeeWNC1/iUU8sQJK2R41yRHAnChIs4wntUYMgy90y13wT3zS5jZPXhl0Gsr6B84xvNZ0fzEa1Ucp7GYrFYLBaLxWKxliue4c9NWgWRHIcWX/QsCRP2IRUfXtEwERUyXMHTZQPvzOINEiYQV4uLHrkC22qd7BhoJ0yMjOSo0gXuc0nvt2GXlWyJULCFBm98iBa6UotrRNJ2Oiuby5renzwG3kd6dCto4uLHnJCkyRgCF9dgi8rb226RHFG3cECYqDoQJmwcQWUNE+64UjRsD4R/Msd7oo79OA4myDeuq7DwcoxIjv02xDkTBLbpHm+PXQlU7V1hrrthwl97x8xwPqgq7FiGjpEtrnOvQZiIphLSEyZEJpLDEQri9+bMXlplu9pLa5jwZr0ibbpYmOQ1MUxYzLr5B5rOOmCw28xrY+IyaHSPyBsmjCmjP4p6iPT2LhnJIa8NqUNtXoT7KEtT5FK1v2bJnKpxH4zMgo2iPZ6fWoMGHVCI3Fh2NMLE+eYdeqJIDgDb8Z34W5PfT0aeMGHHB2GiaNT2DuRr3wD/P3tvHixblp31fXufk/O9941Vr6pLVd1dUkutgZYY1GAjwAqBhCdMBDZ4FoPDhDEBGIMDLAKwMUYEBNjhQISFPIQJjEDIssGWG7CtBllGUwOtVnRL3V3VqqFreK/qvXeHnPPs7T/2Xns6e588mffezHxP+/un6t3h5LmZZ9hnrW/9Pn50B8uHh0uYCOPuGC+UeWETwsTFe6jO3nW26RPbOndeTB7vvDcCYwy8N9rMYNXCXEBNxYNQijBB11spLD3tCgkTcjFZE8lh72VyMa1P6YeEid5IGVEOlTARrIEBd23VIpLDjdJ5/HbcDBAhTMSJb35sDCs6tfPK3GfXXfOK8iCNmtHYkg0jOaqxMkzImb6Xe2bADQwTwSBD8jn0EjKmx10TJqoVWOEY1TsDiMUMFUVybEWYsGunQ6g1AL5haR+1JylllDBB/yYDnnvMc2cAR3gmqjbXm6kyodViYmkju1sPZWVlZWVlZWVlZWXtRtkwcWjaMJLDFAZ22WxLyBZ1w0gOMkzEIznsBhR2nwo5jDE/bsNMxPm/p35mQ8OEIUxsG8nhNrgP4L2vll4hyqB8I81kVdTp2CnlKozkiBTXHBVHdwAA1cX7yZ+hJl1sqpklokBSkvPDM0wgEg9gIjnI4LGYqMnl0BhC77cbyZEgDVjCRCRmQ4sIE0J/HuY8dCeAizph4sH3/2FMv/D/1bYXNYPwYjeRHAnChKyWujnp4u/r+d4bv95q4RuN6NoiRG1aDLAUEbGIFd6XNue9rWHCvW4dQiTHmnNSGsKENUzIaLGQWWR4KpLDfG7BfSAVySHrMTikk2/5d/Hsb//LKIjC0EDYeZJU6EY/YI1qgCahaDLCOlnzWtwwsU2uNgAvkoM5E85mYrfcB2EiHsnBB8fq+/q49aICeAGIBGEiuA+qNYlt4MsqbLA6x7pj/gS2NGlKGTUJsU7XRofsQzvM7GZlN/6eaVJWG/EkYWIM3h2ic/tFrHQkx17f14TMvSGYmN3ENCMXU8jlzJ6nhhCTfgy0kRzqvqbO5Q0iOVqYC1RT8TAa+0nChJnGr6KfxbbyzaERIl5kjSMThAkYwsQUvKcIEwdrmGiI5NiUMAFR1Q0TnKvnSSkDwkQsksOnbSEWyaFJQix8Zg10sISJWLwUkb/aEibGAWEijJtq8RysjP3XQ5hYnb6LlSZI7cswAbECnOcubggTOpJji7WWZ5g4kGdgz2S7ZQ3lcjtAZuvg+Uyvi00sa1m/vsrlzI9UbXGNlMsZeKfvHKvBfbchLjArKysrKysrKysr68lUXuEfmLxmJS/WGyaWtri/d62J5GD9NYYJ6AdRt8ngTVLGM+9DPDX9fJNhwhQ7t43kWNr9PISpD7mc+wWxhmayrFaqkJCM5GhGXbcxTFBhJ5yEU1+0eOM2ouLMrvNoGxWL5NDNN7mYQkppM16DpkaNMFH2/IkX91g2k8wrgLEo9pOaqnSeWXOFM90cmFRktcKjT/wFXPyTv13/20RVn9xhDcSSK5RcLfxGhHOM1qa5r4IwUS0Millt007dSVHVmie8gTBBZg/V4Gt5Tagi5pgdqBbJwTnA2FrzlzFMuIVfUdXw/MwhTCQ/JxknBiXNDg1FyfLm87j5z/37/jZ2cLxet/goQZgA2mOwF2naD+8Ot2+quSYub6I3JExsOJV+Ccn5OE6Y6GvDxFQ3e6ipxUtlTBWVt5aSUkabTAB0Q81GJfkmLvdYl/CaStuYNBMxNDygEu1cbnTcNSsVPxKdmk5tQ1+37fWugKwUYYL1RijvvIjl+2/g8Se/F6/83mdQNdCz9iLX4KPFiu5GxxKtMcz5nrr+OjLvV0+dU7w33AgrH07vx8R7l7gGXbFimHcA/pr1SiM5HHNo5Ppsjc9OJMdiWjO/uYY1ugayzpMQyeFO45NhYv3aKTTY1KgFDpkjFXdnv+abeljR2fiZyLxuUbY2gu9KUgigWqUjOVoQJqSoIIiSMNdxbFtFcgQkRMChNl3OMPzOX/lOvPN9v0PtozY075wwETwzsE4fcjF13rvNDROuOeFQDBP0d/DByX4IE5U/nOPKnKe88GMpTYzVwnsf29QVKEomFYUVjyXMysrKysrKysrKynqSlQ0ThyaHMMGHN8yDdkqmoXoAhgnzEEtFXUOYUH9DjTAR28Zq7hVw3biCECFsfyZhmIhNbNHvXHKqRazmpgmzTzQ2Sa4ShonY9FC11I2ieKFKNX4bMqfJMDFuMkw0ECYSZIuUDjOSIz7tbnKjq6VFJAf7bf5uOs/bECYakJ8GN6/PMxmjUQSECSp4idlF5G+rR1GAF7uZ2A8JExTLs5rrKT/3uEyQCzZQWMA1DQohonhuG7sSMUxQnEjZNVj/mOZv/ize/zt/BkAwzbxLwkTQ1Kb/X2/QixAmonh+5hTUU4QJ/e/ABMQ4i089JprHMe2KiHLdKhzDhKFnaCmUfQucMJnXYtfi3mB7M4PbcGXORG8QyXGp2I8NJeYJwkQ/QZgoOobU4RXBq2WyScYKSzxQsT1Og0Qf61IKhHSIbdYcsjGSY3/3QynFbiM5Iu+ZMrS0JUxoEw19VrxUVJHFRBMmXsLywat47wf+U8j5GNXFe1e1+1ei6PV6U8JEYHZzCTEpuaYnAGC9EeQG8Tqx/a69RueAIjlimHfg2iI53PVM3FwcIUwspvVrOS9AURB0DeSHTJiIRXJsS5hAxLziRqutI0wENLzYOqhm1k2pJfVpl5Ipg48x961fJxEhAXCeGdyBB76ehgnYxrO3G1dEmJi/9k9QnWvKHkXH7foeGRCnWFfRc8yz2SUjOQ6FxENrRj68tZ/ak3nGjZjbDOHUP19dQ5b3vL2YQixmeOPPfCumX/zx6MsR1cdQKsK/eYNnk6ysrKysrKysrKysJ0N5hX9gcp3q5fGzqE5t5rCYT+rxCWYq8gCa9uHkvH5gNZEcIWEi0ghAtbKZ96CiMBU9iDBxhZEcW8ZpyOUcrDfSU9kHYFYJogWIRBBrGlK0gWtcmL36UyaeYV02OBEmxMXD9P4s0hh4bBrJcYCGCUSbxHpiez5pzp3VxR4TXePGzgQ/bxpzkSl+85qDGwBjqCaP/O270zX0nuuiJqFh5bxumIhGUXBWjxa5BhnTgZaJuFhMk4SJWOxM69cLp8id+IgwjxjQ72nRiRYuZbUEyq7XUI3p/Cd/AO//4B9TU3DVwhTadkuYiGDFdROx8fcIdewabWLTVcwxTCQIE8mGXVMkRwM+vvb6TwFhgnWH5jNyIzkAdW60MTs0XYv5JeIyjIGRF/ZzkbKGW+c69uMy52lbtTdM2AlFxktIWQVriHnyPug1qkXQYHWP9cDssFVjSMroMZ+iLuxMO43kSBEmlhsQJnTD34mLk6Iy2eTlnZcg52ODnT+0RnNoQgK0kWQDwgQds2ZtItYTJujaw/Q5pc7lKyZMdAdq6vcArtdJwkQkkuMqDBM+YaIhksMxECqTZ0CYYA5hYjFRhInuARlRAtXM9XDMsa0mvvXfZdbQccOEFFXUTO+q0kMJdH9lRad2jZY1s25cjJcHcRx7or8lvFY6FI51qvR1EbCECYbNCRNiOasd5+Y8uoRheHX2ANX5e+a42FckR2g2p0gOIhZtRZg4xEgOvU/F8OZ+CBNiPWGiFkHjRXL49aLV47cw/fl/iOkXfiz6eoIIE2YbAWEiGyaysrKysrKysrKynjrlFf6hyZkkL27cg5ieGrzka3/il+Ph//Fngx/XD6sH0LRH2ITTfwdFBdQaGak8WB4nTKQKvGFBXRjDRANhgugKW75vNtNyz40L2p/V3G8eNEZy6MazQ5h47299Fx58/x/W22o2TPDuAKw7aIzkoIZydKp5w0gO2tahFIsAQCaIDzQtKRowqjVjkRc7ExyTdE4lJh/Vdjh4/8Tm5EYIEyHVwxAmIgU8NTUdNsCLOK3kiiVDwkSPDBMT3SBzpreuIpJjOfdJNO5kolglTDGJRoQ2e6xrZFEzTi7G6vW7g1bxS1eqSCNrW8JE1DzEnEgObB7JEW06bFKUTMV6PGFijBnKRGiYaEtuMAbCyLX4UnEZ0on+Yc41PVgHsO7Q//o1SUqpmoWNhokLvevOPhrChEv2matzOEIwYEXXnD8hYcI1TEgp4WPLtzFMHChhImEYvA41EiZaNq2JMGE+K16o5vd8DN4bonPnRQBA57mvVts+UMMEPMPEdoQJ04BLEH5c0f3WJ0xscL2IGfPC12igNu1cqXUWESZcw8RVRHJ4xJB2kRxq2jn4WX08A9Y0xjoD8+x4cBI2EonEGGt9XRPzCVjZRXlyT/1uETZH9b+rZWCYqG9bTM8AAIWOvGJlV10b3PVKtYwbaUIV5QESJuKmJcYcGtIaCccwISOECVbWY0yi+6Kfm739uALCxOLtz6n9NM+K+jOvVq1JhleiIM6Q6cgzIoXKxSROT2va5PxqIjle/8//GTz84T+/9e+7MpEco1v6WWnHJqGqfv0g2ajL4HgvSvVssZoH1JmpuQakahpyOdf1HjpW60MQOZIjKysrKysrKysr6+lSNkwcmKSoTPOhOHkWAFCdP4BYzrF85/NYvP3z/s87udv7VpgryRgDeGEauawWyZEwTHiEib7C8cMp7ISEiU59Qp+VPV+QTtYAACAASURBVNtQjb2CyRPfkjBBr1H2DuO9D7Nh6eE9Vgyr1LSUO9lTTR7b6dsW2eDF0Z1Gw0Qj5aN4GggT8UgOrhGs7lRQbWKOij10nujjlwq0sUiOdRmpfHjTYnMjhAlTWBLrIzmiDXDOlUnkmpUiTCi6zvJKIzmklLUIEHNtodznWEGuE0ddkxEp1eAjUa64mF0Yc1JsqvE6FUWlF+Xa4rIwhgl73MSOTeYQJkxhPvycUga4lNlB/OKL5AAU9lj9N0KYaDHtLQxhItKQu0RchnQ+P5doFE5gU7N1k8n0rfZnOQOkTBAm1NrDGH0c0xqtV1xqjFjNk/dBFQG2MNvxYiG8XHjp3SPsmmMzwkSsob1ps/zKJarGKIerVNowsWzdtDYmGjLx6Ou6mJ2Dd4cYfsO34+Zv+H24+1v+lPr6Ia01ALNmqBEmNol32SaSQ7+/3BAmBpsRJkx8RfpzIlrCIeDmU4QJ5hoprzCSwydMRNbKEeOzSERySBFGcvQPw4QSkb1HBCSzloYJuZyCdQbmGTk0x9t7ztgzjcSumSIgTCBCPFgXU2j2nxetn2t2JXO8xvafsXaEicmjyFc3J0zI1bweyZGIhtxEiy9/Vm1j4RMmgN0+N4bXD4podKNVN90fMR9bw9aWf4uYjzF79Scxf/MzW/1+KFozFiMVB7nrGogdOog8E9P5G1279WuRHGI5h5gpw4QYx6mZcjFVhIkORXIE15FMmMjKysrKysrKysp66pRX+IcmN5Ljhpqeqc7eRfX4bfXtoHBhs7QPoGlPBQ+3YFB0bEEqiOTwDA3ug6/zde4V0KT+dtBgCyf0I9jPUFtNezqyhonuYRAmqoU3Kc8iKF/7s7qx6xgXxPTM0gaqxVr8bDFaZ5jwc4FdmYJS1ZIwMSfDxP7fZ6MUYUI3IP2poADfGSFMQArTFPGKfXRer5noLUa3LDY3ku9qi5L6NRYNhIlI04Axvh/CRNcSJiBWfpOCt0cKR1/LFJLrhAkJqYwAMeSrNsWk9n0ddcZtXNF5u2nz67KKIt6L9VOCLmHCTGAmCBMsjOQIj5+EAU7lsUeOtU0JE4eGxt5SxegWwBh4YDhkvaE5j5skF1OAsWhzuW2sR3zDQm2XMa+xFx5brEcT5NdsmNDXshhhQp2XXSeSg6bEO8ag6u3faqGIMbFIDueeL6ulP+XoUm+ECKZwN19zpFDP+yZMQIodEiYS19PV+nUKiYx35nqu911Mz8B6IxSjW3j23/qLKG8+D8CuXw5F8UiOzehmZvqajvMU4ccRNTeJ0LIpYcI7zxKi5v8hvOcqhitGmLCRHG2oGa3lUsDKWCQHXU8CwkTYdCZiClF2ukNDOztIGdOw/x5uRJjoDVEc31W/F06Td+09x4+4ixkmVLOUE2Ei0sBXx0WLz7uF6XTXsuvcmGmJxddagQxhIhY/BQBtDRM62sDbg6sgTLz1ObN99d89GSYqn0rHtbm6mjw2x/qmsRxyPkYxuq3+f8u/ZfnuF9Vr62P9sjKEieF+DBP2+hF5BjexWxE6GA0nLGfmnqYIIGpdmCZMBJEctcie3RG3srKysrKysrKysrJ2o2yYODCpBy/1sRTHanpmdfouVo/fAuBniQK2AHQQzeTIFJwpsDBen6ByjRFOM8ifynTzwhOECV04NhP6kaJMTSaiYNtIjrmZODgIw0QiWiA2ZW2mpUwsyRJiemZJDi0mN/nRHVQX8WkMwJ1qTkdytMV40tTQIU19SiGi0y2qmT7zGpm1IpfBiarfp2PVnMsmc7h0CBOJbG0tRZg4NT8L+NM3LKB6mCnTWPEuSphINLGvUER8cIvohFIXC0WY8N+DejMhptXZfTz6+/+Nj1gGTIyRZ9BwjUZiFUW+piI5iI6xzvxgpuDmOpJDN3N3GckRw4qzohOdjpy99k9tlAFdi6Wwf0eMfsIYEEZyBIQJ+jxqE84Jc46UwpAM1orvJkJmF+Kjm+D9k9rfrggT6xti6n44iBKXWHcIOZ/Uz402EpVttkYME3SPtZSYzfO7N9odKuJHTHoAwPrHjmHCIp0tYcI3uaWiqVihzm8pBCBl0GB1j3Xp/BvANo0hKbysePMqHX/Ns2utIx5dpdT11L82Sik3I0zoY5Cu5+Yzn56Z4xOw65WDolkhZZi4HGEiRfhxdfRLfxPu/a7vM1El6prT/jxuRZg4pEgOUSUw73rN6hrCriKSwzGyNRImnHuZmnaOESaER9lJGTsPQaFpmLQJYYJ3BuYZOZwmdwkT7vZizxDWMKEIE9G4xtAYlxDjpY0bORA1noOctzIcU92hvPmC/SLbgjCxnNWNQVdBmDCGiTphYqfPjYHJmnUHysg0u0B58wNq3zZcB4n5GFwbJrY9nxfvfkH9vhuldwkZwoSmn+2PMBG5VpNRN7Z26/TVumk1N8Q2uZwZwkRYXzOvFxomlsHfK+PEyaysrKysrKysrKysJ1d5hX9okgKMBYSJ8/vWMBE0qU1D9RBiIYQfyQHYB1reP4o0bJyCizsV6hZiPEOCpI36W6ECjC64tDFMMMZUoWbbSA4dgUHNk31LES+cAgGvo3zNz+rinxvJIWbntomeaBS5Ko5uNxMmdGEn2rwK4iHWiRpZB1FQJyXiAXh3UCdMrELCBEVmUNYqFWH0dJQ+nnj/2EG/N0+w8OENNcVEPwv4P2+oHkEkx7weyRElKzB+/Tm1xnAVJ0zIKsTfUwZzc8H34if/Fh78tT+A1XuveV+nzyUayQGpXi9mimmI5EAbwwRFcjiECew8koNMOS5hoqw3JlcLvPGn/lk8/pHvVf92jHnm2InRVhi376U7de9tXF+bAiMA4zwepyEFkIxxCl8+sY0nUOWN5w163BXT15p1EstplPQDaEOSg5nfRC79wDPBVUugKM39nu7t102YMIaJCGECUNdTmiSE24DmdcKEXM31uZmK5Jjb+5dL8qFrkjZTuMe2ua5tZJiIR3JwY7Lb09pjhxOVUYqXqLRZpSVhQh8TZvpUf2ZyNQfruYYJ/b4e0loDiFINNo2DqxkmEtdfV7w3wo1f8zu8c3kTIk3M6BGKrk1bk26uSOqcFXHCBLOEiauM5ABgjFQ8FpnE68Znsahfzw1hQr+HrDfUa9EDO461bCSY/17zTr9Vg1vq96CkSI6QMOEaJloTJo69bfmEiWWrz5sdImGiaiZMtFknUdxfefsrvN81/1d0rBE8tR9SxiM5aL9W2xsm5mSYWC0gRbU/wkQYyeEYm8pbyjCx6XVOLsaGpLI9YeIV9drXRZjYMeE0jH/1ZJ6rY3SwHsRypuo33aF67lpOzfuSqmlQDJKloUQiOdqaubOysrKysrKysrKyngjlFf6hySlEFyfaMHF6H6tIJIesVqboeRiRHJEGAhWoE00MkhfX4RIm3IkjkTBMUK7kkib060WZmC6DwSeDgkI8HgBhYjX3Y0icAm9NFMlBOd7LmWpILya6qNXGMHEHYtwUyaGb0S0JE6vH72D22j+Nb4sME4c09ZmM5FBFaneKqLbf1Gijc0N/bmJlj19AUVcsYaJ5orcY3TLXBmvISBMmaP+IHFDbv+C12C4IE6aw6xAmKN98PqnRJxiLkwtCmemh8wf+68VQxW5meIIwoXKJI8ciRXKsMVHRlJhwCRNFd2vz1laKNbKKTs3ERA2H6uI9AP6xbKb1RQWKNbByCBOpzymFhGc8bqZKmJSieooiOe7+lv8CH/h9/0vt623jNGQs817Li7zZVO41yZmEliufBGMIE3uM5AC0YSIgTLCitPdB55otVnP1d8RysAtFPIgX7cNjPRLJsclaLWESCk12u5Z06SLXrNg6bdMpf2YiOfT1zsWmO8cLN837w2o0W+OBs7bekjBB5wk1SjeZjOXd4UYT0mb/Gj4nusfvvbkfiTIzctasV0mYAJyJ6CbChBfJMTPvmbd/snIoOwceyRExmwHtCRNCx44Ux8+o3wuoBdw12jrbi227mp6C9Y/svczQBzc3TICXB7fuaIrkYKw9YYKVPRRHd+zvembAznqjSLVUJrfQMHFJwkQ1fozq8Vvget/kcuabZHZ5jwwjOZx1l4l72oIwURxdLpLDECauzDChByJGijCxkQn0SnYgfv0A7PNjyjAhV3MIPVRDBi16DhbjODWzHskRDkHEiZNZWVlZWVlZWVlZWU+usmHiwOQ2RnlvCNY/wursXaweUSTHQxs94UxIHwLlIB7Jof4/zF9XP+hGciQIE2XPFnpNgbceyQHY9yOK/Yzo8oaJntq/PZtVpBBAtfL+ZtYYyaHyeOlzMiYcKXWxadGIUAaUYaK6eKheO7ZPS4rkiBSBC592AADv/50/jbf+698c3RbRGg7JMKHO09jk7wBiOQ3w7v5+m0Yb0Vc6IWFCFQ55/8gWERPNe/O6w5utCBO0vbWEibABvoMGtJ06dAgTPSp8T9P54msKvtQkpaa/fb2YYcJOiEdJGwB4tx8nTLiRHA3FX7mgxtWFNif1wMrOTq8j0UgOXtb229Jd6uegJLNNxMzDOHcmruKECZkwTJQ3nsfq4Zs1csjGkRxPC2Hi5nPovfB1ta+z3rCV0SGWeW+2cZnpbocw4RKNpPDz3tmuIjn039BEmDDNYndiP0KYwGrRQJigSI4IFppb4wjgr1W2ympPECbCGKeda9eRHMG1cdMpf3NMcJ8wAdjjE8DhRnLQ9LX7nm94zzCECTrOU4a1BvHeSK0RU+u+auVdt5uatSQTybHn5n4syoxkviaFs065GsIErXfaGCaklOp6XiNMKAKYcExjBx3JEXtWRHvDhFzMwLsDFCdkmGiK5LDnSGzbYnoG3j+x+0D75EVyrICyJWHiUCM5YucgY63WSdX4IfjoVnBvdZ7DW0RykMk4fDbfykjoaPG2okv0P/hL1XYW0z0SJqrg3mLPaYrk2CjSSKjou8Ixg2yj5btfVK99RYYJipwsKNZi15EcDYQJQ26MXJ95p6/j1nT9Rg84rCNMWMOEOlZFOCSziZk7KysrKysrKysrK+uJUF7hH5oC1HF5/Cyqs3dNJAeqlS36UyGkd6RwrHuebFkXyVGTZ5hoQZhIRXJ09EOsbh7Q9MA6tc1djUlFcqgH6H0TJpoav4gUts20lC4AVhcOtcTEBDQXB4ujO4AUENPT6PfFYgow5lMvaNe4TzsAAHHxPqrkdIeeyD+kJkaiQEJNTLcolorkoPPcNL+WAWHCieRYS5gY3oScXaiGRQNhgkwqkkwo83E90qJaWVML/T4vrv36YggTTqHLnU6XlT+5rn6YrTdMaAx/dR4aJshwVjcaQUdyRCeYGiI5WNFRDdWGa4IXybGyhIl9RHJ4je3I9VA6NAxAnYM0VeYRJmrHZp0wUTvOIk1lAOg89xGI2Tmqs/vBTrcvSt79zX8Sz/3uv9rqZ59Use7Qi/5JScQy77XMJG6L7YRSBpaAMCGFiaYxr9G7BMViA4m1hIkjm+HtmB1YUXi/D0DnXCcME4WOiCDDn1eYp2NdXysvaZiQiWxs1tkvYUIhqHdlmLAUr8f/1/dg/vqnLY2nLWFC32Pps3ZNKLwbieQ4pLUG9Fqp6AQGnPZ0M8LhA86Es9jcMNFEpJGiwqv/8Ydw9v/+j/aLica4K3uP33NzP0LIM3KJbZF4lMvITETH1spkfNaflVwtACnrxCDmR3JwHcmBarn358KYYsQUgJ731h/TijAxMFFV4fMK69UJE3xwEt22mJyaxi9gn1WNAVnvb23tGRMv10ZT7FrNhgneyjAhxo9QjG6nBxuKci0hzXwOKcLElpEciy9/FgDQ+9AvV/u6nK2lilybhP/s5EVykGFik0gj/axQjMgwsV2tYXFfGyZmV0WYmCjDARkMD4gwQdflZJyajuTgnb6pL5FhQi6m0fuQMh0PlGG76AChuWeDZ5OsrKysrKysrKysrCdDeYV/YAqbT8WNe6jOHqDSkRwATGOZHp55X2Wv7p0yQQWTSCRHlDDh4qr7thDjFYU7fevmNwXeBGGCJvSXi2gecO3VL0OYWM7AOr2Nc6SvQ7HGrzvxW1O1BEonksMxKojZhW6YryNMKERociJjoaaaw2ao2jd9fDuFXDG7MJEgoQ6SMCHjBgbWUVN9bkO9HsmhDQ0UyREev44RyhxbazLj+VA3sSePAVlHS4cmFZtjLmvN/5g5g3XbTbNfRqZZX7rT6YTrntQasfongLWRHESY8I/VxkgOoSI54oSJIcQyfM+Emrom80PDtJyN5Jgo7H/ZW0uluGpFJzyLerHfkCWMSW+O4kjlKYsGwgQ4t7n3TkzB4v6rznRy3ADXvfdVAIClxgjbnWlflOx+4KPof+iXtfrZJ1W85Tkpl7N0JEfvEvQHJ5bBNvYqE/lk95OmfXcTydFEmLCRHM6UeIQwIZYNhgm9brDbcI59MgeZSCq7DqFJ8s0IE+siOfZj1lxn4LtKmfdbStz/a78fpz/2PzmGrxZNTKgJfNYdONOnzr2x5xgmDiSSY/n+67j/V3+fxdxHIgE2Wb96UUq0niJi2wbZ603xOmI+RvX4bTPNDGxImNjzex4zfJPYtUZyNBAmgnU8vUe1WANtaBXONZAdStRJTMlIjl6rdb5cqpipdCSHQ5ggA/LgJE6YmPmEid5L3wQAmH3pp+3rVatG04/Z/wMkTJjmbuyZjreM5Jg8Bh/dAvMGH1zDxPrhA3tPDIxBJpJjS8LEW58D6/TR+8BH1XYWU8+kvkujvaxW3n3Ri+S4tXkkB53PxbFec29B4RGzC1SP3wbrjfR7c/nnDDkfK4rNJekgW79+E2GCvhaLU9P1GhVh2jXmd2OkBWqDG1IItRYk02VkSGaX66GsrKysrKysrKysrN0oGyYOTcGDV3HyrIrkePyWeTitLrRhQj+k0kTM3hv39BDrTvtQgbofaWK4hImuO7niTP+1IUwEzQNlZlhfzLzMVLeN5Nh/HIotSreN5FjqyVpNmHAKBDRVta4YzPXES8owIZbpqWbGOcCYl3krFpNo8x5ANA5g70oQJjghPp2iWFiwCyM5wqlW+jx5b2iwwMk4Ci2akKsmj53tOwWcgDDh7V8YyyGrWiGbD06uDOeaVIx6wAuwsqeaPLGidYuCrzFMtCBM2GsSESYipphunTDhIf7XXBPcLHl1HekopPEuryORKdlY0Zuaa8I5B6lJYaf1E4QJeiv1e1qd3scv/NGvxcWnfkh9PYGE79z7CABg8c7n/U1m7K2ndXh8klzM1hMmtjFDCWEbetwnTLhrALZjwoRLDHDFB65hgugQpTUOzh2T22quzpFY0b2jcrBlrOmnj3UyE3lxDyU1hjZoqK2L5NgbYaLa2blIueNydqGOr/l4q6Y1743s9c75zDzCRNlVa5M9rzXGn/m7ePx//yUsH7wKAJYK5ojelzbyDBMLMktuQZigcznS9KOIJo/UUq2Pr7hULNAVKlyXeXIJOhvGwawVTUQ3RXLoZ59k1B3XhAmi7HSHB2P+iSn6rAgyyLcwTMwnYN0hus99NTrPfBjdILLKHqdTtb2io0y/kfNFTM7Ah9Yw0Xn2K8FHtzF79aecH1q1I4qwYrPr+w7UZFpiYNFnxFBi/AjF8GbwnO7SbiJ0smBdQtegmtmHMW3W3a6Rvzp9G+XtrwDT+yaXvmFit4QJ/9nJjc4ptiFMkGFCDyhs87cstIGNjEBXQZkQi7GKjN0mZuwqJOpDASRmCBP189Ws3ZZzsLIPrq837rOtuAgME2S4MoaJnqGZ2h8StUGerKysrKysrKysrKwnW7n7cECSUiJEHZcnz6I6fRerR2+h89zXAADEREUoHBphwjQQ3EgN/fDqFVroe3AjOeLZqO7EkTQId/+w5UGet1zOwMqWhIktJyPUhAIZJvYdyUGTO05BzMlcrv08Fd/JMOGYHkRLwwRlqq7L/EyK+5NYIlJsN99zmrUxAsVelCA+EInBbSi4Gcrqd22zDnAMP3T8ruaqwFv2bBFSriNM3FSbnjx2ikluJIdu1gmK5HD2L3jPZVWfluGDE4jZ+drm7GWUKuxSzEnYiNXfXVvwtYSJ0DDRQJiQmjARK8h1B/W8dacxxMqun38dyI/kUFPsrOzuFOUc+9tZ0anhuy1hwjVMqHOfjDZRIgnjQBDJsTp9B6hWWD18Q/9efMK5c/dDQFGaQq/ZFyk2moZ+2mXw+GumDhVOuI57d7exTbMyFskhpVDUlFiszrUTJtT205Ecxyaex4sKoOnx+dj+PxkeIk0yY7SMTDnSmkbqc4O79IKtCBMSiBEm9hzJIcXuIjnIgFbp+C+6bgKbNa1Zd2ipTu690TVMMKYw3fumHZBRjcg+kXvftoQJc7/fwjBBx3OcMEFrOPu9NoQJfigkBLMuixzXDhXNrMmu6Pin94bHrtEu8QrW/MBCYpAhTFAkx8g+F20xlX7dMkaa0JjrGeTTIkN2MbqFD/+5L2Lw8sf97eh7gFiM7bNawowREiYYY+i//M2YfckaJtQ9bf3nzYrSHkcHovWRHC0IE+NH4KNbyUgOZfhVn+ni/it457/7XfjCv9fHxT/+3+x+GMNEJHrmEsMLYnoO3j82z5tiMfUIALu8R8qASheL5Ngk/syYQAc31Dm+xd+y1HEcRFy7CuO7MiyN9maYaKQBkWEitnYrKZJDE0L1s5xrIqmRCOm41ddcVZNSx9eDv/6HcPqj/0MiljArKysrKysrKysr60lW7j4ckgwi1yVM3EN1/gBieoreV3w9gAbCxI6xiDVVSzWx6RVSdCRHPxLJ4U6ouN93mmKs07eGBJmI5OjECBPrDRMqi7L9VMv0lZ/A+3/7vzSvxTp9PbGwb8IETconogXcn5VSNdSLjik2VONH5vuVNuO0NUyIhkiOFAZe7V7hRXIY5H9scpGK81IcTD5wKpKD/uZq/NA23zYkTMBpotM5LUUFxtIFmWJ0S7/uI9P0jhEm6LXNlCmcaAXzhcrL4QUcU9Y26P6WSk2j8u4QgiI5QoQzY2sLvvT3pQkTjmmAkPpSqvc8FsmhY1ei+06RHA3XBBvJcWFJNTsmTETf68iUHzXGPMJEJJKjVixkzLlO09S9KkpWk1O9E/GGHStKdJ55+VKRHL8Y1NaIIBbTeoONtqEbINsRJuqRHBBCrwPcWJ0dESYW7SI51LltC+50nRSLCfhANc4MISKVg71a2G00ECY82gVta4N1mpQyahJigUl05xIiev+7DnFNUiAzp4lnwmaECTWN/rL6h3NdD48X1hnsnTAhgvWQijjzz+F1hInZa/8Er/2Jb4aYngeRHHqbiYi7Jpkp7sg1x9BbFnXCRNN0vjV+7fc9byJMmEgOQ9DpxuPmthBrIEyEpDh6j8K1Na2n6b1nvdHBRJ1EFZiGSaylYWLt84U+V8R8og30veT5Uk1OwTWhjdR/+eNYvPmz5joeI7xEX5eXTxRhAoxFTfWhxOQRiiCSgwWRHLR2fPO7vw3n/+ivA6LC4h27hksRJuj3t42kE/MxeO/IHA9yMYVYze3xv6Prinm2TkVy3Hze7G9bCZcY0/LcCEURSb0P/lK1zSswTKj3fH+EiShFkaS/Fl+79SGXc/vcpf8tZheGnFeL5DAxSD293Z5Zw539xN/Axaf+V0CK2iBPVlZWVlZWVlZWVtaTrbzCPyRRA5m5hIl75v+7H9CGCf1AVyNM7CnPmhTLeaXiI+81Gyb877uEib6e6loB6yI5nAn9NoaJTeM0zn/8+/H+D/1xNclFRbjiAAgTy3q0QDKSw5mspc9KOAUCoc0T67LBLWHiYfT7cplu0qkNBIQJXRhyG/lmW07Bd99FdaNEPAAV/6vz94yJoXZ8GJS7LuwYwwQdv4t63Eu1qhWXXa0lTFATQKyP5JBiVWvS8YG6xlRXgHNNKUmY0NSOWI67ula0jOQIJ4ciUTYeYaJaxZGvOpLDpZ24E8+s02s0r9HxLD3CxH4MEz6FpF7slwuHhiEl5Gpu85T1tH7UPBQhTAhtlKDGpy3U1xtP3Xtf5RXbzc/noqQR6+mGwJoCvFzOks2lS9Ef3M+Drhd6AtuL1dkRcp/+hmT8SO8IkMLP8S465hyXi4mZNKZrRrToTvf8KtL00++HaXQ4zXhD+dmIMJG4z+hr1i7z2T2tIR5dqfR9UEQIE60w+Vov/KFP4Jnf9mcBBISJnh/hoibR90yY0Osgsy6aj+vGjjUko9mrP4n5a/8Yy4eve8eJcAkTjG3U+DeEiRgJbFYnTKBa1E3UgQ4mOiLRxAfgGJAr9Z5fVRwH7DUm+sziRB0B1nTGwtihkDDxpERyhM+LrQ0Tk/p74G6Hc7VOm48hl3PwTl/TKyKRHLMzY5Qj9V/+OCAFZq/9Y/V6bSM5DpkwEYmXakOYkKKCmJ6BD295xCRv4EEbHuRqgdXDN3D7X/6jAPxnC0tCjBgmLhFtKWbn4P0jzyAhlzPzTLSzZ0Yz8FKP5GDdoTnGNjGO0tqO90at42pCLd79Aoobz6G89QIAoLoKw8RiqvZpG2rWVSgWh6ZlIzkSZtflzNSIWLcPsZhCTM9Q3v0QgPpzogiMPqzs2mf1+QVWp+/mZ5OsrKysrKysrKysp1B5hX9AspPh9mMpbjxr/p8IE2bSbuUTJpqKp7uQjCDsDQI5Rphw5BaD3b/fmCGWM0tLSBEm3EiOBILc+70NizRidgZIqR6oq6WeUOjt36iyrvHr/qyZzHQjORzDhG5qRotrjvjwJsB4MpJDRCYiXTHmEyYszjlSiHcK8HtrEAWKxRAAAOuqoko1fqiabxGMqhSValTo45yOVfrb1PRL1zs+U69HouJgNXlsYxWCZjhgC9VukzVKmAhoFqaReAXFtpRS06i8O1STghFDFloRJrRhogVhwlxbhNDXs8hn3BloQ4WdiHPPK7egVvsbpQwiOebWeLXlhN02MkYNt+jNy9o+GLLEfKz+XikVHrjo2GJ45HjxCBNkA/Bx/QAAIABJREFUmNDHDjU+zecWmaDv3PsIlve/6EXASJGnuFzxlnEacpm+Fpus90tGctQmsF3DBGPK9HTtkRxjNYmZiG0hY6mYnZuCO+MhYYJ+hggTMaxz1ydMuNckOtbndcIE41wZBTc1TEQMRTww2e1aini0m3NRxRUtDQlLLqZOBFJ7woTXtHfWqTxovHJtiFsnKSUe/vCfw+L+q633oa1co4T670UtamYdYcIYGGYXfiSHS+za8DNkJuogRpjQ0/guYWK1fjKflV2Asb2TEJoIE4YWFjGEXVa2wdcQyaHX8YZcExjQGS8AaQ0TrDeyUScHGMmRani2MUxIUUGuFo2ECUA9U4rFxJkm70bX4nJ2gWIQECY+/M0AgNmrOpbjSSZMVM2EibWRdrreUDREcpBhwo2QYL2RibYC7PMNjxmDLkOYmFEkhzYILaeQqwUKMpHv6B4pYxFdep/48AYYL5TpYQvCBEXsbHONXL77Crr3vsrSs64kkmMM1h1YwsSO6aax99qIak6RtQHdM6lGRBFAYnqGzt0PArBDI+a1AqoPK3sQqzmklBDzMarTd3IkR1ZWVlZWVlZWVtZTqNx9OCRR4cKL5LCGic69rwIruzaSgxp+RJjYdyTHalmfztJFpihhwmkE+JEdAWEC9LeuIUzowohoGcmhijzti1s0Ub169Jba547GvO75fTdFc7cg5kz8ej/rZAfbSA5rmKh0cWwd6ppxDj66hWqciORYzpsLmsE0u0FPh817+AXfgyFMJCZsqUhdnT9QWGSdmepJ+OQCHuDVTTPbjXZYM9FLNAsxeax+Fv4UrXk9iuSYT5IxG7EoCq/ZeE1KEiZ6Q4thD68vGxkmHiRer240klJEo0kAWzjzJjcds0dTJIdcLcz+ipAwscvrSBCbAEBPcvvFZelEcrgFbzfeAFLWjs3OnZfQufNB/a+4YYIK9bHGa/e5j0Auplg9fsvZGRE1V/xiVduoC2Vei98Prelii6aaE8nhNvZk5NjivWGUHnSVEouxPwEbiA/UGkPMzv1IGjKTzcd1wkSs6N7RRfeVvZc631XbIsNF2OTeNKtdyugxX4tx2rVEtbNzka7PdP0W87HTBNyucc2aIjm67SI5xMX7eO9v/hE8+sRf2GofGretG9/SGNYm9SY5GXcS9z+63sr52Gu0GQPqFoYJul5Eo9OM6dVZr1WLtaYWxpiOQdmzYUKkm3BmLeVEclyVmggThhSnjYPGiBUa0JkfyeESJvZtRInJXDujkRzNDW6DyG8gTND3FWFCPQ+ysr5teqYLCRPlyTPoPPNhzF75CfWa1XItdQ+AJkxU639uh2qK5FDHV/P6meoNxegmWIIEqZ7nlo6hZwTeO/IJEzSpHzEGXY4wcQHWP7LPUYupev7UJpid3SMDciBgnxXIvMF6o+0iOXTEzjZ/y+r0HZS3XkBh1jZXQZiYqPsmGSZ2bdxsQZiIEWEo4tVGqqr7jpidozy5B1b26iTC5dT8rvovrf8WgKiwOn0HEFXSqJuVlZWVlZWVlZWV9WQqr/APSHJNJEd58wXw4S0ToUDNLdP4PATCRDKSI5Ir7k6oeKhPhzDhTN9T0TBssNUiOZaz+BRL+PIbYvCpibJ69GW9b33VZNw7YUIfB502kRxOY5cX6jNwJntMJEeLgnBxdCdJmFCZ22nKB+MWXStFZQpBScIE4cwPxTDRIpKDm9zZoAldrfwpJJeiAt1koEgO3RiSVRWffHRftyghJo+jk5KGMOFEchQ37un/D0wq1arWAL/K6aSk3Cam+9rdoWrobhHJIaX0Ijk8YkGkkGyuLSI9bUoUES8qxo3kcD632v54k74BYWK1Q8JE5L3kvaMabYSaX9R4ANTxyvtHqiksIuYcAM//3h/As9/5Pep7AWGimuhjiK5NkfOoc+8jAIDlu04sR8beejJ4/HWEiYa897ami/iGhb1OBFE2tXVAd7QjwkRknUH74Ji+pBOnYegYq4VDmEhHcqDoAtXKnuPutdwQJuxkqLcPDdeG6N+UIEyEVK1dS7qf/TWLPoPqjAwTE6fhumXj2lljh43XtpEcZC6dfOYTSdPCtopHcgT7SY3HxGQ2HcNibgkTfHBizalbEHt4G8KEs4ZT5oIWk/ndwbVH9qxVlW7CuZEccrW4UsIE9PsTNbUFhAk5r0f9qB+zkRzKbFsediRHjM4DZcaUeno7JWEMEy0IEzqSg3WIBug/P5B5MzRMACqWY/YlRZhoQ0oBNGHi4CI5iH4WJ0xANBMmqol6JlSRHGnCBKqlZ+jhfX89aaIjY8Yg/fvbSBJhwjEIydXcRmDs6JnREkIjhAlt3uAUL9h2m0EkxzZ/S3XxPvjo9jUQJkb2mKLn1Cu+DyZfv4EwYaimiUgOsZzZSFVN7RBTFcvDj+54AySAY/QxkRw9YLW097lqqeog+dkkKysrKysrKysr66lSXuEfkiLNp0IbJlh3AD68geLotkUTm0iOAzFMVKtasZEeXnm/2TDBu/FCDJkA1EOrrH0fcJoHbqRBK8LEZs0LKv6sHmvDRNkDPwjCxCaRHH6hweCAdbGJimNoaZgQFw+j3xMNGHgAJnMZ8E0SMcOEXEwMQeFQDBPpSA79Pl68r6aCIrmzUviGBBbg1eVSRXLAzShfg/xkjKEY3lRNnEgkB52XbiRHcazoNWGTXMq6OaPYgWEiSZjoDhRhImLIAm/OYJbLOVCtFKlHCoMXVq9HkRzueaMnxBMTkIAtgnrkk8oWpZum5bxJ35klTKDomKLjLhSbkuWD4xpBxCVM2MJhzxImYsca9NSwuU6r/1a6OWE+A5E2THS1YWLxzuftvmTDhCdjdmgwIlAETDKSQ197xBZmBi+WwUxCx5H1ijBxvQ1R1VROGyYsJedCNWd4oY5Rl/bTX2+YMBhqwt+718rAMFFrxm86SSslGI8ZJvZPmGBhDM81KSRMyMUVEybCSI7OAHLRgjChr2PLB1/C8t0vbrUfyW2TqUEfY2IWi+Rozo83RJ/52KxBiqM7do21BbGn6ZpjzB3OeS5XC2UwWiPVSDx8wgRd32LTy9uKrpVRkzf31/GpSA5wTZiYj81xctCRHBWtG+qECaB5Yp3+nnWmeKab03KlCRPajOGKzpGYYaL34jdi9f7r6rgWq1afOdOEiV01jtvImnljhon1hAky0dciOVCP5LBkpSNNmHDMU0Hj2duNLQkTKhbhArx3ZA0TSxW5wHsjRb7Y1XXFMWGSaJ/o+OKbEib0vm9rmJBCQEweoTi64xgmLk8JVISJoTmm5GqB6Rd+DK/8B7ewevzOpbe/TrLJ0G4ijurHO0VwoFqCd/pg3YEyO0gBPjhR9bUaYSI0TCgSnztoUJ29myM5srKysrKysrKysp4y5e7DISnSfOLDG2BlF+XND4AxBj5yDBNLIkyo4tm+pg2NYhPglHG+QSQH8wgTTmMgMZHsFtlktVITrrE84FBFR8WItBShLCmSg5raeydMLGONX5qICw0TwRS/LjiUN55TP06RHC2Kg8WoXlwwr9Mw1ay2X5oCkxvDEUM9i8UExei2+v6BGCaSkRz0N1dL8O4APDLVpvCd7hRSQEhZOYQJjdxOGTS81x7eUoSJyHXEfJ4OYaK88az5f08RwgTbRSRHE2FiPok2YhmaM5jpnO088zIAoLp4z75ezKBBjV8yL0QKcrFIDp8w0VNF8wia2W1eqEgOPf14CSTxNopNyfL+MWRomKD9rVa2idzpW9xygjDhyRAmTr3/ms+N1RvC5e0Xwcqe34jcYiL6aZaN02gwIlRL1XRPESY4N4akjeU0XOvI+qARtuFk5TYSTrMwJtcMIcXKXINZaF4rOrYYHim6E17bXEu8Bqs+1h00uavNDRMJwkQQQ7ZryZ1Gcqjr1OrsPgC6bl6SMOF+5iG5oduuMVU55rvxZ/7udvuRkDFKkHFiMa7FMKyjjBjDxMwhTISGiS0jOZoIE16TlAyBa6SuQXtu7LchTEihnnOuMpKjSEdymHOfDBP6fa9dV3gBWa1QTU/N9w46kqNKR3IAzet8Y1RriF8CqDk9gVwu7DR5kjBxo/77wxv6Z87UPa2B8GZ/Sf/MIcVy0Fo2QZiQawgT9EzIR7d8o467btOGCZcwwfpHPm2myTChf39TycUEkBJ8cGwMQmI5tevqLakM28g08V16UdkFtJkdAFhvFH3GTW7TIcrwiPl+ncT0FJASxei2WhsxZo75y4iMWfYetMTirc9BzM4xf/Mzl97+WkXMKUa8gTBR9szvsrJnDRRQhvFidMcYhEjGtKKPL1Z2IZZz/7lZyvxskpWVlZWVlZWVlfWUKa/wD0gy0nxijKE4eRblzQ8AUMV6E8lREWGCDBOHEMkREib09FSYuQs4E8i6uGemVZ2vu2YIEW+w2UiOhZ0abxXJsSFhYhpGcvT0A/hybdHpOmUn5Z0CAU8RJmgSXk9h0OczvKnyOyen9W0l1BjJsZw1InNddK1HmAgK8VJKyMUEXBsmNi0YXZfkmkgOwJkKWm0YybGaa6wy4U41/n3NNC0f3lRmqth1hHNVHCWTysISJsICXsycUVzhdFJKScJEb6gQ5dWqXiBjrJEwQU3+zjMfAqCiUhpfzxAm9PcaKCIxwgR0JIe7DW9/qHlRdFTme7UCCk2l2BJJvI1iU7K8f6yvoXa/XfIAZVmzTh98oHHLCcKEpyCSwxRsZTxiCVDHa+feV2HhGia2mIh+mtUmTsMUe5uuxd0t6Q9CwEQbOAa96LGlTU/XKbmYtiJMyNm52kdzD3SvxfpcpEnZSEO+OHkGgGOc9AgT2nClIxVCeoGK3tnQMBE7P2hdtC+TbAsD31XJRnIow4ScT5w4lC0JE6ap0qv9HYTpXidjLi27mHzmE1vtR3Lb80gkRxA3Q2u3JGFC3/vk3NKBitFtG8khNzegUZM6ds2hZqn3vWiMVl28M2gVg3KdaiJMwCVMXHEkB2uI5GCcyD0BYSJ8nuIFICvMvviP0Hvpm9Tvdm0D+dCUmhAPaYExiaXfwEyJYl7Ecmae1cLnB3reiREmPINdy+PYRN9VhxPL4Zp5Q7EWhInKMZW4hkRWi+SwplreP1KGlWgkR32YYVvDMD2P8P6RH8mxnJuG+M6eGWktXPj1G9YZGPONiRdsu8n5GGDMElI2/Fvo+bw4uqUGbvonl6YEKqrHWEVOOoQJ+qyX91+51PZb7UMbwkTseHeGSpShxl5DeP8YxdGtFoSJnooNCo0vmTCRlZWVlZWVlZWV9VQpdx8OSab55H8sw2/4Dgy//tcDgB/JYQgThxHJgUgkBzU4awhZAAiQnqZxmSJM6MIOSxom5o1TLLVX37BIQ8Uga5jo28iQHTY7Q8UiOQxCOJy+dxq76nfI0HIC1huZ6Yo2k5vNholp82egEcIAPLRlrXm/nOsJmcOK5Eg1jNzGJOsNVXGlRpjwzxNWlAodS5Ecq6Vu3OmGSLWAmJ6b8zylYngDYnKq6BdAvYDDS48wQbm/YSRHuH8ALGHiOiM5gmPTvHZ3aF63XgRjaCr4UkG1c/fDAFKECee8oWuP2ZeGSA638BlEcrjbd0Umi+L4rjEg8E5PTdjt8vodi+SIUETc5pfQ53oskqO5eaqv1/pnq8mpQlaT0SVhgihOnvWnvaSMNo9/sYqal01mBzpGY00K0qa52mbbojINPc+gF8l7V6anXURypKeOveO7soQJeBOhurFGhokYYULHpJl1gHuNYD5hokYv2NCkKaWMnh+hyW7nksJ7365TtUgOd5235aS/iSSLGGxU875NJIdqJA5/yW/E5Oc+CdEixqOtbCSH/W8tkqPTTBmh67iYW8JEcXTHXi8Sps8mMV6o8yMWnfaEEybCuDpX5v5GkUPXQpiIXKODaD05v/BMmUa8QHXxEMv7r2D49b9BfcmsUw5kzezKTIgH94k2hIlFe8KEJIoXTZOHkRyaQFbECBMD/36xzrCsfomOkwMzTBSlvVe7Yqxmqg8lJvY98o06gWECDo2ipw0T7rNd0zBD0dnKZGKIFr0jdd7yApIIEwmqyHXJXD+CZ6fb/9IfwfGv+jfU93rDDSM5xmDdoTZebGGY0MM1NHDAB1dgmFjOASnUQAA961QLc79ZPvjSpbbfSk2EiaKBMOEce0QgIfHBCfjojnnPSDXDRKcHOAYRu8H8bJKVlZWVlZWVlZX1NCmv8A9IqebTc7/ze3HnX/ljANSDb50wcRiGCVVIDApgnAwT6clPwG80eoQJtzGQmup3CsdNUyyx12z7nkkp64aJsmfymfcZh2ILUZFIjhRhgoo69PnoiaDKmZpcp/LWC5CLCVZnD2rfE4tp4wQYK0pLO3AJE6FhQhdHiyOK5DiQabnEtLs3sdJtR5gA4BkrZLXwCBNytYSYnYH361NwrvjIj+QIM+ZZUUKuFA1FLqYK80rRCt6fVjeDcB0bcZ2RHKjihAneHdo4iNAwcRnCBDWaopEcwXni7c+aSI6iwTChf6c4umtJC/sgTEQjOVQx3C0Eus14KiSyTh+spwkTKXOOqzByo1qq9yERsWT359gr7m4zEf00iybO5Tx9TaTrJWu6Fnc3K+Lbjdv7MX0ukhqKMcLENRsm5HzsEX5CWcPEBaqL98EJk+0SJjo9sE7PXBNj98Hyhm+Y8Jp+ZJiYX0TpBdgikoPFIjn0vV7sMZJjX4QJYLPosKj0vscMNqoxtX6dQdPpx7/yt0Eupph98ce225eIaN0jFhN1z14t6jEMhW1WxWQNE2PTNC+O7qjr72q5NbFHYeXThAmzfaD9ZH53sNHk9bXIGNabIzmumjBhzMuxRnKwjlemsPqzFOOF+Znh13+b+toTGMnBWxgmxGL9PQ2AISfJ5Qy80weLxOOJNoSJ6QaECX6YhImkAZ7xWmxjKDF5DDAOpp8R7e/WDRPVWF+X+0fg/SN/LUnRB5HjnLe85tb2zRAt1GdF1xG53H0khzHJBPfFO7/puzD86K9T39oiksNE7Gzxtwhtyi6O7qjXH94wJqFt5cbYuOZwMqcvH7x6qe23ka2VNREmYoYJ+zVW9rwBB94/QXF0G+LifWVU1TLXG/2zihI2r62Z87NJVlZWVlZWVlZW1tOlvMI/JLXAmxejW2qyd7WEXIaRHPtr2gPwcsFJZpIvEsnhF1y6TuMhEsmxmgOQ9eYbHFPFau4UZVoYJjbITZXLuZki9yI51kz57ULmc480fsNimC1UBpEcgxNVYJxowkQLw0TvpY8BAOZvfNp/DSlVQ74BAw9exCM5giKEwe+OyDBxGNNyUlQ1QwLgT72x3lAXuYJjQ6xq07ms04fQn6PCyXb96Z3pmYnFSKkIIjnC6RuKQZFODjbvH9WbpaKKTu7wwcmli21Nsrn0dcIEmSK2N0y8DAAeEUXGDBoUyWEmmDaL5GBFx0wixhpZdH0qju/a7XV6asJuh4a3aFN7DWGCyEa8068TJpqmzSPXbDE9NfSbVKFRvYZzvG0xEf00i5q9TWYHcz9suBbz3jDaAF0nKYVdq9B/pYgeW6y73WtsolQzkWQNQedYvP1z6D7/NfobEcKELv43EyZ0JIdruKC1S7WK0gtY2QU2MkzEqSqMsTi9aFcS1c7icULCBGAbnVsTJiiSI2KwaUs7oEbi4Ct/FQBg+d5rW+1LdNsOWYL+P4xhWEuY0GYzObuw9x3dOBPzsTp/t7ie8t4QYlG/5sSMdm0JE/wQCBMNkRw2amGp1gZXGslBhIlIJIcxotlIjli8IV3DylsvoPv8R73tHXIkR/isa/e5iTCxPmYKcAgTTvMc1cqsWQCn4T6MECbCSI6YkSYUHTuHRJioms7BZkIboCI5+OBE33O69m9013XGMKHXiL0jZap1CRPLmfqdyLnDR7cMcW0TGZKTPid4ZwC5nKlIyC1jLLaVWQvHqAdam8afiUsaJkwkBxEm+ieXjlWk+wofnKjzlzEdybFDwoRIEyZs3FbEMOFFcvQDwsSxiqxaLbznHkNydQgTYjk3sWt2AzmSIysrKysrKysrK+tpUu4+HJCkXI83p8ZxNXlsGmyHRJioPcBSQz4WyREUXEzh0CnEc7eAlsrz5lxFGmwayZHIExfLOR7+79/tF4CdJqKJrSh7XmzCvmSMM5FogXokh4/CNYaJ/rEqMNI0RYuCcO/FbwQAzF//mfprSNE81cxLG8kxa4jk0E224sAME6phFInkcAkTGlka7rMUVTvCBB1bi6manl4TycGHNxVhwqBhg/0rSpUzTA2Y3gisd6Qwz+7+Vat43MgV5N82yRgYgskgbwq4ViBjkA0FX6nP2+LGPbDuoE6YKDp+xA+dN0SMiJliIpEc0onkMGatRsLEHbu9Ul/7qqU32XSdUtfq9YYJd+q3MpEcffD+kUKwJ2KkXMUm5MXk1Jq5IoYKQBVkK/d423Ii+qlV0VHGszaRHI2GidF2092ismYX534TPbZ6o+0oFpvsTiS2wBUrSmVMm55h8fbP28aiG49U+iSd2H2QD07Ayi5Wj79c+333WI7SC4rNIjnUmid+fsQmpnclKaqa6e+6FIs4qq6MMBExtXQHrd5XMXkMPjgx1/LKjQ+6pGgdJOZjY06IxbsALQgTi7H5ezgZJhZjtUbbwjDBumsIE7BGu7bmAtYZ7J8eRmvjyHFNNBoxOY3GWV1GZg0ee2bhIWHiAqwbOWb1Pg+//teb9YzB+B8gYQLVSsVEhPGKm0RyNNCEAEs1cpvnatvWYCQmpwAvotvy1kOianccUxTioREmEscr49yYcVISk1Nz/APOs7wbnVlSJAcZJkZ2jUj7sZyp+2vkflYc3YEYx+MdG/ctQpiQi/1EcpjrR4OxZh1h4vwnfwD3/+c/aP7trmn4FhQeY2AxkRzH/pp6C1nChDbR6DqKMUzcf+Xan2PMM27s+Ywop5Hz1YvkKHtgXccwoQkTQGCsDyM5yp5HmChuPKc3mJ9NsrKysrKysrKysp4m5RX+IYmaTw0PXgUV7sYPbRSDLmDss2kPQE1VhpOlhY18qMuN3ug6jdJ4JIcUIlpsoZ8TerIEaGmYSOSJX3zqh/De3/oujH/275mvxaIIWKfv7N8+CRM0Ke9QNajQ6kxTAW5jl4oK+vMZnPjNgxYF4eL4LspbL2D++j/1vm6oEE0TYEVppszMpAbj6UgOXfBpky2+E6UiOZzCK+smCBPVqlZU487PqQJnz6LIdRTCesLELV3I0c2McHpPEyboPWa9oWpkhlmsMmEG0VSB65IpgoWxPu57WqNmcBvtEJFbUC2O7qK6cAwT1aIe3UOECWrOxUgbayI5TExP5JpATSGPMFH27LVvR4V2uao3fbzMbvq5xdQUHikKipU98P6xZ1BrG8nhGv7WRnLovGUqvuZIDl+MsVrUxfLBL+D1P/WrjTHIRnKk74eqybAF/cEhTDCXaFQt6+dpb7jda7TdFSkhpqdmfZQS7x9j/tZnIReTKGFCRQ/1bFMuNqXIGIqTe04kh2uYcJpIscZm2TUknTZqogDE4p52Jil2HskBuI3r9tFh0W0WacIE7/RbTeVXk8fgw5tqurkojZH2spJSmnu0WExM05F3E5EcsfuMlMbcKGYXZrq70JP0cj7emtjDe/EIn2i0WuN0u/O3HEAkRxNhohjdAqAakCrioAVtoKVY2U1O3oeRHHI+biRMDL/u2/xfPwByR0wpYkMbw4RoSZhgvREkGSY0OSjctpiemcZvKGOYGLc3ZxkSySERJpooL4xjHWFCTE9RDCyBwxAPPEKk+rur8SOw7gCsKMF7R2qNSNGLq3lyHVIc3UF18XCteSMUmb2NYaLTN1QyVvb0tXw390hz/WgaeOmNGgkTp//g+3D6//xl8z7I+dhc97eK5KBnR339ojX1ZWQIE/peQnUUc7+ZnpnXvS410jwMYSJimPAIE72AMHFink9mr/wEzn/qBxUtM1hDs04PWC0gZuoeR/RCls3cWVlZWVlZWVlZWU+V8gr/kETFgqZIDnLAO4YJG8nRvhB/HVK51vUYACA+yedFcjgRBG4j2i+gxfHU6vd7kMu5bXSsybcFoAqUkfds/OkfBhBMGdCk+s0PeK9pHsD3SPcwxhm3+RsUWs3PpiI5+sd+nETLRkTvxY9h/oZPmDBTzU1NOlY4hAk9qXH8TD2Sg+IjjlTBZ5/GFFfJSI5OzxzXvDfU+M6QMLGqNxSdaWGK5KDGOzU/qaGdEhWwlu9+Xm2zRpjoQFYr09jg3SF4vz75rQgTiUiOS+Jcm2RNB0Ej350KqhWt10Vy2IJqcXwX1ZnFuseynU3jl86TaFG/HslBP++ScqKRHIYw4RomHJrIrkxvsUgObbxzP2OxmBhzh0+YUMdiRWj8xuapvc6Xt79Cv8YpTKE+cU0vBieKukHnfMO0/S9Wsa5vRJi+8o8we+XHMX/zMwDa5b1viokmKcqA/uycSeho3AtN+17T5KFqAFfggzpa3duP/jHmX/ppAED3A18LwC+6q6lUp6ieyH4vbtyz97mNCBNl6xgwAICUyUL8/iM5dmWYsJ9HqddfhuawNWFCr0sjTVfWGSh0/xrzmpg8RjG8qQw0w1vG2HhZyeXca5CvjeRIkYxofTW/0FP2AzOtLOaTrYk9KSKNRwozkRx181R0m4fQ2G+YECejTjV+FL2+XUbDr//1uPFrf1e0aW/WI/q6KWbjKK2P1hw1w0RncDgmY0dSrOI4/VaECaImrSFM9EaAlBCzM02YsNGNpGp6Ct6PG5HNGoeMom1MMnTsBEb1fSq2zjVirNFwDGhTiRNZEo2aMqbaR+b4NBFYFC+kSR8xFUd3ACkMvaCtaK3KnUgOsybVkZk7u0cmohBd0Xottg6SUmL2C5+CXC1Qnd1Xm5xPzPu9bSQHH9xwBlcuH6tYEWGCzpuSCBP2+r+8/+qlXmP9TqSv1aa2ETO7us+Snb5PhOwfG1rU29/zr+Ptv/TBIRuaAAAgAElEQVRbsXjjZ9R7XpTWZKkJE/Qc3b33lXoDOZIjKysrKysrKysr62lSNkwckDaK5KBJp7JrHwL3HMmBaCRH6TURPaUMEy5hwsWoNkzE0bQloZrXTZrSa8pq4RUvpKgw/swnAADCyVQljGXnmQ87r2kpAHub9HRf2ynipiI5TLOGpjDIMDE4Afcm+VsaJl76Jize/pw3xWMLmg2Uj6KErKigT2jLe7Vc0JAwceiRHIRBBlRxjEemgGW1qtMfnGKYiuRwCBO6Uc3XRHJQsef0k39FnXNBk5QVJeARJkY6ZziYFk3FjQyOrzWSwzUduPJQ5GGBjK0zTLiEiTsBanUeIUzo88YYiyIFuS5Fcthj0Y3kiCHkzc+RYeL4Gbu9wtJ1dmV6kzEKQCSSQ84nxtxBTUrW6RsDnClwtyRMdBzDhMmfThTRqSBr9mfLieinWWra25odyFxFx3mbvHfe3ZL+4BA/DIpcVOm4F1FdG2XCFPEjWfThftB7RJEc3rFbdn1SU8I4WJ48a//hnUeuYSJFmNgwkiMSaQPYNc8+5Jllrlnu2rG89TyAKyBMEBklEckBrF9rqEaiWmfy0e2rI0w454hYTLz7tbefTca84BpOzUo6JuVivDWxh3UHUay8mF+Y5xPTJK0amrXuNjtbUm6uUE2ECcYL8MENRfa74kiO0Tf8Btz7Hf9t/JvBOl4sxlEj1o1f+zvx/O/5fpQ3n/O+zrelB123IjRCwJpj2xAmmmKm1Pf1+yRlM2Eicc+g880aJp5QwkQT5YXxxvUzoCM5HLod7x3Vjav6vakmj415wZqz1Dqv2TBRj0JoI9cQDahjwtwbOn2wcneRHJYw0RzJASmj5rDlg1fNPWT18A0A+pqqz3d6RtzEdFqNH5r3FlAmZDHZzJQSip4BC4cwAR3JUd55CQCwuP/KpV5jnRqv1WYYJGaYcMywpUOY4AVYd4D+B38Zjj/+W3Hya347AGB1/gAiOG5pDSfmFwBjKO9+SH8jP5tkZWVlZWVlZWVlPU3KK/xDkonkaCBMaLSiieQo3WbbfqfvZVWfnO/cfgndZ78y+vNutj1zTBVuEdfPnZXJCWPeUYQJKpZw/T41iZVdVSxypoFmr/wEhC7auMUbKkB7hgmnCCf2apjQxhn3vXER6a4CwoSN5Dj2CvKtCRMvfQyoVli89VnzNbFsMdXMVfMesAW14uiu1/xT39OEiRERJg7DMCGlSE/+6kIt743iU8AxEovT/JKrhW7cBYaJNZEco2/8F/Hsd34Pnv8P/wY+9Kc/UyusM14qwgRRO3ojhc0NIjlipBhgB5EcJlqmPp1OihImGpDCYnquCqdFqQgTTiQHYs0cfQ4ZmkLEpLIukqPRMKGPBbeIyTo983fJaoH3fvCPY/yzfz/5N12FYk0fm9ltjwdFmFDmDjKQsU7fHItU4G1svDGXMPEiAEWmWD18UxUcb70Q/TUbEaIKtHLLieinWSFhgiYTqcljIqoamkusO6xdd1vJieRwiUZRwoSDtL8OCWOUXGOY0McUH90yx7V7rfONm+n7YOEYJry/1TWBRiagNzdMNFC1djk9G0pUO4zkiBAmaIp420l/WvfEPiO95lwXEaEiOdTxVoyujjDhGhjlfGyx8zXDRDoOzjU2itkFxHLqG93mY03s2cYwESfSiNmFMRIZwkS1jKLRQ/HesFUMynXKRIIlGp7F0W1jVN+abLKpuE+Kk7MLFQETqHP3gzj++L9W//UrPC6vUusiOZqoGET24msogu7618Xvu+eLmJ4lo+4Y52C9kTVCtfnM6W/aUbRaG9HzRFysZqoPVU1PPXKTuob4z+EuYYIiQo05a0aGiblvRnTER8rsvbFhwlwbtUnDNUzoYZKdGSYM9SB9X2TGsFa/fhL5CgCW778OAFi9/7pZMxsz0Qbrh2r80JjYAPUMKReTtfSkJplIDn3esIIIE+fovfgxtf8PvrT19lupgTABQ4KIGCac4493+mZdTLE8fHCM53/PX8et7/iPAKjjWS6m3rWGtlGNH4H1RihvKJPartZDWVlZWVlZWVlZWVm7Ue4+HJBMLmNTJEeNMNGzOPc9EyakqKP8b/0Lfwgv/Wc/nfgNK1Z2bfHbbTp07FRQ00QcYRKr8WaECQAeInv86R8G9DRZNa5HcriGCe5gXvcdyVErRPFUJIcuCpf1SA63IN+2EdF76ZsAAPPXP21fQxeoGjOGeWGOdzkfKxpD/8hr1gK2sMT7xypS4kAMExBV0thEfzfrDqMFu2gkh46UAejzdAwTJpKj2TDBe0Pc/NbfjeNv/lfRfe4j9R8ICBO8N1Lv+dx/zyHqBAx6/eskTMhqqSZ9QvqGa5gImy8tCBNkBCiO7pr3EqACbmiYUOfN4h0Va9K9F3sfOwDjXiSHT5hIo9JNJMexH8kB5xr+6P/88zj/yb+Z/JuuQrGmD48RJhZTFMe6mD2mSI6eMXysznXESetIDlX8FZNTLN9/HcWN58BDyke4P3TMbTkRfYhaPnxzbUO2jcLmZaU/D3GhmjyyhXmN97YjTEjhmMbcCKhV3TBhjZ7XZZggwkTzfZ+ajd3nP2oNhs6xyx1qFNBkmLhnf8Y1XKyN5NiCMJEwiap7y54IE65Z5prlfgYUiSYmj9X7suU+UJxWzNTSZsqd9qEYOIYJ3ai7rExk1uAGhBvJEUQxNBnz6BrOOn2I+RhyOdMNIscwsSWxh/dG0euFmF+Y88IQJpriANy/pWUMyrWKqAAJpL6iiDyMxlldm4JoPTVxHok3TKi88Ryqx+9cx55dSrK6TCTHRCHy1xhxvHVjp2/OaxESJhrW1bx/jGqiTaEtIjkOkTCBVZowwXgbwsTjIJJjWLsnMUOYeGTjMUwkh3q+EPoaFBPR8TYnTJx7NRDW6ZnrMNcmmV1HcjQdJ8ZsHSH0zL70KXO+rx6+ieriIcTksRk4MVGAG6wbxYVPmDBG50sY341hQhPgiNQpZucoTu6huPEclg+uN5KjHWEiTbABfBNVSG+0Bt+HNTKKGZIZPwTvHRnDRCZMZGVlZWVlZWVlZT1dyiv8QxKRDhojOW4BjKE6f880/BgvVAN635Ecq3okB+NFunHuGiMKZ7LTi+pwcmdFQ/NAGyYMYWJNlrl6zbrRZPzpH8bgI9+C8s5LqJxIDkOYIPwicDiRHMt5bYJoXSRHWFTggxPfMNGSMNF59ivBukPfMEHI3ERxTL1uYaZExOxC0w5GNdSzMEh5FW9xMHnMDQ0jKmzx3iiOTRer2mQM6/Tsz5ERSjcaRMtIjnVShImlh/jmvVGteCcT08NXkX/bJNVciRS53MZj+H3GGhG1rmGivP0ixOQxVnoKX1aLWiQHNTyX73we4IV3vrs/w4LMdWNE8ggT9WuCXM4AxozxDYAXvyKmp+o6dt1ToZGmD+v0gKIMDBNOJIe+HvJOH3yoG+BE4miaqnMJEzefAxiHmJ5i9fB1dG6/lPw9U9x1DBNPQ1FSSonX/vgvw6NP/MVLb0vFadjjkAwTNFVsrp9N1+JtIznchqtLmBB13Lo1el7PcV21vO/TtaD7/NeYr7nHrkuNApBs9paOYSIVyUHNaf8Xu0AkQiGldSZRsSfDxG4JE04kh2OYYEXHp2ptIiJMxCI5TNO2uTGlGokUyXHLi3C7jISOJStOnvEME/VIDmdtHG5DXzPLm89Dzi/qkRzzcSMlq0m8O4ysGQTkfIziRNOINLGmebrd+Vu6mzcDr1prCROjm8qofsWRHE0y63hBholxzTjTpPLGc1idvn0t+3YpRe4RQDvDhAgmvlPyn2d6nvnebGt6utYwYShabQwTh0iYaIzFYTVTvfe7UmoKh0uYqEdyuIQJet/pOBWz9pEcYotIDqJGAYo6QuZJilzY1TNj60gOpAwTP43+h38FWHeA1cM3sLj/RQBA5x4ZJurH7zpV44fes0bNhLyFxOQUrDuwJpXSEib44BidZ16+dsJEE83DvP8xwoQbydHpm9pUeA0o6Plm/LhumOgQYeIheG+EgggTT8GzSVZWVlZWVlZWVlaWVV7hH5BkC8ME44WalD67r5DyumiqDAMHQJjYaPLKKboUHaCIGCY4Byu7uuixDk+tDBOsf9QKA2yjTNT7Vp2/h/kbn8bol3wHiqM7XtOSij6pSI59vvdxwoQ+hsJiGNE06HPSxQXePw4m+dsVhBkv0HvxY5i/8TN2f5brM4YZL02BSczH4P2jePPe5BXHaQ37EBWvU80Gwnzz7tBEcrhNfVnVm02q+aV+zkSs6GOYYiRoomdrFTqSwyFMsN6Rap7ov0lSRE2kOMwHx5CL6bVNgaYaEd5xGRpNGEdjJIdjmBh89bcAAKY/9w/U6y3nkUgOPeH16MvoPPPh5HWEdwc+QpzO/3WRHAtCo9umh0vXqU7VNGh1cT2T+GY/Iu81Y8yLXZFSqkiO4U117Cwm6tpcdEwRthVhwp26H9wAH97QhIk3UN7dwDCx5UT0oUnOLiAu3sfyvV+49LZYb+ARJlZnvmFCLtZHcvDuEHK12Py8dkxjdC2U1UpfP8JIDt0QuS7CxFQ1SYrWhomvdb7oRnL0/KJ6ijBxw4nkcK9Jzj0hSpjYJpIjdZ/Z5/1QVDs7F/1IjucBaIPMJZrW9JlFP6MWzXspKnVv0YaJYnT7yiM5iuNnFD59Zu/X3n62IEwUNz9gCBOs01fT4VBRS1tHckQIE3IxAaQ0RiJjfG1JY6AG+F5jOVoQJgzZb1+EidmFmdxvo+Lm86jOH+yX3BGRrOo0QsA1TKSNYHIxiZJhQiUjOVZ+JEeTyY73j61xvlUkh7ofHhJhQq4aDD5rCBNydgFI4ZGbYpEc9N7I5cwcn0RzEm4kR4ImZgkTm11DxezcRIAA+tqtzxWiiuzsHnmJSA4pBGavfQq9D/8KlLdfxPL917G8/woANZQAtDMT1XbpIojk0KSQSxkmZv45w8quesadj8H7x+g882Gz79cmTUGMGibLdpEcZKgB6s/WyhDSQzV5BLGYeutn81weRHLsiriVlZWVlZWVlZWVlbUbPfndh6dJLSI5AJWfXZ3f95DyqhC/P8oBkC6CJeWRJDq2ORkUcanpvJ4wsUA1edQqjgOAweCTiWClm5WdZ19WecXOtAsVGDzChDMZvi80NqAK5jWsPb2HIkGY0J8TTU2FhIlNMpq7L3wdFm991vzbTjU3R3LQ8S4XY7DeSOUFL0LChI7k6A4OxjBhSDCJSA4qrjBNmICU1qgCqGJPUJTnhFc3BJCuaebTcbgukmOdGNeRHPSe6kgOwCngUbExQZgALodzbVIqG9zNma81KljzhJw7gdb/8K8A7x9j8rkfAQCszt+rN8yca080joN+rBMSJpxIjqKhkbWcgnUG3rSwex1Znb4L4Pom8c3+pmge/WOTOY1qqSbJu0PzGbBOXxkrCFlLESctIzl4/1jFHU0eY/X+ZoSJbSeiD01kgKL/Xka8O4ScRyI5yDDRIpKDmk+bTndLUdmpOn0tpDVIKpLjuo5rQ5Zac+9fS5jo9DwTVarRVJ5Yw0SSMBGjF2xsmBDeNr1tuVSiHStFIboOeYSJW4owcelYBN4QyUHY9KYpd31NKlzCxPTUmp4vIekYJiClNUxuQ5i48RzE/EI9K3QH4F0iTGxvmCDChGsCpaZooc8LWgPKhjgA72/p9u1+7UlrCRPDWxDjh+pevyvDhBOtJ1cLddzHyDUJlTeeA6TE6uzda9rBLVXVaYRAe8JEkwHQbMt5n1TU0naECRvJ0caEryM5Dsigos7B1L6zGoXQVTWlqCv7HrHeqNaodukbZGAgU7DUkRxylTZM8OFNgLGtIjlc8p67zqGG+K6eGWWrSA5tWAsGA5bvfB5ydoH+h345OndexOrhm1jeV7EWnWdeVtvd0DAhhYCYPDJmFMCN5LgcYcI9Z1jRRaWNsLx/jM6zL2P18I1rHSJpqjWZ2kaUMOFHaxgaZGBCo2ccMX5k4qzc3wNU3IkiTNyjF97+D8rKysrKysrKysrKOjjlFf4BqQ1hAlBFydXZAwiHLLBxIf46lCiCJeVkiDNeWPNHWIzRsQaykTChphwUJvlWu5cPIjmo+Vcc30VxdMc3TMzOwboDm13OuM7RTRetd6UYYWLjSI7+sW3wbIi6Lm9+wJtio4JOI2GicAgTswvw3pGJ5PBoDLqRzw7IMCEbTAWAbcLw7tDBqNrjI9ZsUoSUmTkW3bgXE4Vw2UiOouMRJlh3ZBGx1CQ316A4YQK43HRSo9oQJmqFX9Y4ISdm52bSjRUlBl/9LZh87pNY3H8V8y/9FIbf8B3B5uxx32kyTNQiOex5ZUxUEfS+XEzBu4Na/I35rLVh4rojOWSi4egSJgirzntDc22g6wwfnAC8MA36xuapR5g4QTG4geW7X4RczlDeaTBMhAadpySSg+4rV4HwD6k8JpLjwo/kSDUq1DZ0g3jTWA4pbEOPCBP6OheepzaS45oIExOdqz1sS5j4qLNzCcIEY8m1WOFEcniFe/dYjzTjWeGv08Y/8wk8+P7/JL3DsmHNQ0bSfaghkuqq5REmbjxn3uM0Zn69eHcA8MLLdzevR42pBgORNeio460Y3QakNDj4y4iuu2TKoQip0NxhCRNLhKKGWHnzeaBaoZqeqSglFwm/JbGH9UZqneCYQIVuihJ5hdYYqftMbZvUSNwjYWJdw7M4uo1q8khFHOwoksOYpaQw1/lNCBOGyKLN4IciKRKECYoma7iuqTXUpoSJfo0wIabnkKuFwe9Ht9E/MvfpNpEcZt18UISJdCQHY82EiRi5qXP7K8CdJjzgm0no+KT/0nHbFMnBeAE+vIVqvJlhQs594goPohPombEptu/KRJ95w9AIS0RyzH7hpwEoU3d5+0UsH76O5btfRHnrBRsbkTDyTb/wY3j1D36otrYSk8eAlEEkR0Bt20JVhDBhTP39I3XNkdLS565DCQoiUK9teN8r/UgOQ5iImKaK0S1U44eajFI3TFAkB+8OcPPbfz9GH/uN2/89WVlZWVlZWVlZWVkHpye/+/A0qSVhojx5VkVyONNbrOxGG3S71LaRHLUH3JAwQY3yNXnecjVHNX7cmjARNjZpkq84uqvxuw9NoUVNspyAd/uaHNADY8w2xPcZybGc1/HU3Ef5mp+lhjz9PBEm+iemILPp5CZNsVGzzsZoNEyBMUuYEPOJKjz0jgAp/Qmw+UQ1sXhxMIYJaypIRXKo4oohTMAvcsmqTpgwhT2a0C675jOtLt5TxZ0WMTNN4qObWJ2+o4p1jIN1eraBsqAGB01ZRggTYUTCFStJPXApEFHCRLNhonBwq4Ov/VYs3/l5PPrhPwcwhpNf/W8Hm2tHmOAdP5LDnP+O8SsaybFU05E1woT+u4hyc+2EicSUrBfJ4UTruIQJQJnaitEtS5hI0Fb0N+32ByfgwxuYf/lnAQCdOy8mf8tOwz2dholNpyljYt2hMZXJ1dJEXtDxU53dR3H8TKMBzhImNjNMSCeWwRj0EoQJ1j8CeHFtkRzV5LEyHiUaMqTBV/0qDL7m1/rRWiFhgkyoRTf5vnmGCedvdX8+JAIA9XXa6T/87/Ho7/1XJhIplJQNVC1tJPV/fgeNIejPflcIamdtw4c3zfF6mfsh7x/hxe/6UZz86u+sfY+mTmVD877ShonCRHLc1F+//PEt9b2YaA3V2X0VScbr5DUgQZjQBkhqmIuL9/Sx3QGKjiZEbEfsiU1JG8LE0V2AMWO+akuY4C1iUK5dVXPDkw9vAdUKcnaxs0gOc10VwrzHsRiZlAr9+a8ev331O3cJySr+rKieqZrX+SqSowVhIlxjBRP68zc/AwDovvC19V/W4oNje349qYSJapE2TK4jtGkDmNsgv/ntfwAf/JM/5f+ga5gICBNtDBMAakMKbSSmvmHCj07o2YiOHXweTc9OJFoTyMAwMf/yZ4GiRPf5j6K8/SKq03ewePvnTRwH4Bj5gvvS9Is/jtXDN2oxGLQGLI6sIegqnuHE5AyFS5jwDBPHiowEoDq7PsOEMlwl3ueiJWGi07NmlIhhQhl4HqtntuD3AGUmomvMs//mX8Dwo79uuz8mKysrKysrKysrK+sg9eR3H54mUeFiTVOoOHkW1dm7uhhpi/v7JkzIatU4XRGKmguu6UN/w/85KqA1RXLoSAMxeQw+2tAwkSBMoFrZaevZuZmwL47ueu+72sYeCRPVAiFhwkZy+IhoKmIUx3fVjxnCxJEp5mw6PUdISooTEAYDny6OsaI0BSYxvzCRHIBfTJKLicndZp1+4+TZzrQukoMwn72hiUrxjo/IdJ2hqDiGFkMdOH/v0nEcAND/8Ddj8ebPojq7D66xukRfkDXCRCySQxMmriuSow1honZ9YQDWESYsmWP4td8KADj95Pdi8NFvRSckHLiEiec2I0ywUjVYbSMrEsmx0JEcZdcr7JnPWqOz5WJq6ADXokQji/ePTGPGi8Oha4NzTvOhNUy0Jkz0j8GHN8w5Xt75YPrX9BS4ieQQacPck6SrNEzw7tB8Tibig3FDmFg9fgvlzQ80byMx9Ug6/9QP4Y3v/rZ63IBrYGQ+YSJsLimDze3ri+SYnoIPbqwlI40+9s/jxT/6I/60sHNNYUXXFMSb7oPF0W17j11DGvK+FpDAFm99FhAVRKrR3mQS7fiEibe/9zvx+p/8eHKfr1RuHMs1y/0c+ODEmrcuQZgAgMFX/spo8zlmcgwVEiYoJ/4qqDF0HhrDxPmDqPkGDcY8MT0DGDfrvOr8PTtNq0le2xrQaD3mEmkIu8/7x8rE5RAmWjWau+tNKtctIp4lCRMj23i87LHXWm4kB5HBehsQJm4cpmGiiUa4zjAhljPT6GwSdyI51DS5H8kxf+PTAIDeS9+U3oYb99DGJMPJMFGnvuxLjaalloQJl9zEu31jxDKbiRAmWECvE8tZ/TnVUXF0Z+Prp5hf+J+Ra5jo9AxxYhfkGtmCMMET0WSrh2+ivPkCWFGic/tFQErMXvtUwjAxC373DfVfTSIi0WvwUT2Sg6JWtpGYnfnPo2XHGGE9w8T5/divX40aak1EjInFs7nGIddEFaM3FqNbEJNH6rh1DRN07Zcyfl/OysrKysrKysrKynoq9OR3H54iyZaEieL4WYjpGarpmTUbdHoe9n8vqpZbTf2Zv4EeRGuECWoMrMFTr+aoxo/aEyYokkMXt6iBVRzdMahmQfj06Zl5qC6OHcOEaYjvr0Am51MPRQo4k2nB9NDq0ZfVxLF5zztqerEoHez+ZsXg8sZzACz2Vy5UQYd3GoqavDQIUzkfa8JEZHJxMTENEq5NMfuWjeRIECaMwWPg5SavHr8NMbvQxqIgkqMMIjnKrjXjLCaXjuMAgP7LHwekwOTnf9R81nYKTOcMi3SO974IE36xqk6YaJqqdo1OANB76RtNIe3Gt/w79V9oSZhg3YFfuFwtTGOomTChim+MMVPQZ2XP/O7KQWdf1zQ+0BTJcWQJE3OKwxmawqB7nSlGtw1VpnHaPIjkcKcVa4YV79eYIl7Q8eZGQDzBIjNDNX7/0kQAIkxIh/DTufshE+myOn0Hxc3n1m4DSEdyTD/3SUx/7pOYv/5p/xtOLAOtWUwkR6QZRpnQ1yEVxdXuvh+qRpigdUjDfZDxQjUGGK/fB/TxHm3Gl11AVJCigljOsXjn8wDqzQ4jKZPHPAvuh7w7wOrRm8l9vipJKXcbycEYUHRUM54XXnTYdSikHcTO0coYJogwoRthV0CYoEgOY3Y4ux+NYbD3mRhh4lyZ0xyTo2uYEJcwTNB6jO4PavtkmDgyJi4pZTJmq/a3dCgW6IAJE058y2VpX63FrGFCzO173FalNjM/KZEcwHrDhJy3JUy4UW49xwilzpf56z8DPryJ8nYD5cptxrcYBqDrwHWu3TZVUyTHOsJEFSFMRDdT1gkTZAomM9X/z96dx8lR1vkD/zxV1XfPfeVOSAKBQCDhRhEQRBABERXxXsELf96KCuq63q7rsZ67q6KLLqK4HIKLoKIicgcI95VA7mQymbtnps96fn/U0VXdXd3V18xk5vN+vfJKMn1UTU9Nd9XzfJ/PV2ZTRdepTmq8s/qEieS4vT3Afc3pasMyHYX2FVr6AIDWkk8NcsoO74LWucS4j5W6lsv6LJjYWfI5dXs8w9GSw7qGm6wnYWLUVTAh1KB9DCnhFmjTlTDh8TpHj3glln3+fgQdr529r1bBjhqAUBQIVUNo+dEILy8umlJiHchNDENmkkWtXuz7VFG8RkREREREB5YDf/ZhLimzuttJbTUuSLPDO13FBrOiJUcVCRP2RFrBRGPhKlFrYkCWTZgwCiaMiRPvnrSux5RImFAirRBa0EiYgKPffDK/kkWNd+Wj6WdBwkRurN9ejWizEyYKCiYKVhwLcyICQAMSJsyCCXNAp9ygplBUu0BITybMgonilc4yPZWP4A6EZjay2VLh91QEIkbbBUVxDXLt+Oqp2P/bK43VuZ4JE9aEY7BoZW29wiuN1ceZvc/mJ8CtPsN+EibsFglNKpjIZUoO7Aoh8qu1S6xc91ohJ3UdMlmwAk1RET3sNIhQDPFjLix+kCP1RivXLiIQdk3uOAsQnEUyRfuUzq+OdBYoWd93bjQ/6NnMthzeBRP5lhzWBLoIRvOruh0rBJVYu93GoVyRn3C25AjF7X7YIhSzV9x5USKt7oKJOZQwgVy27uIjJRQ12xil7En34MI1kJkk9PQUssM+EiZKTIA6We/rU8/+3fV1Z0sOVGjJAaCpCRO5qVHXKtiqOBMmtFA+YaLChLza1ld60N5qU1KqJYd9vpBBZu9z9vttzkxnKiJ1AB7nPJo7YUJtW4Dc+EDz4+DN99tKhb2NJLSgXZyQfy9qzir/fNpBEvtv/AK2f/GkovvoBS05rISJXAMSJqwkATVuFExkx/aVPpbMQhKvhNDXZpwAACAASURBVAkl0upuS2Cds1pFVjUm9ohSha3WZH4oDmEVZFgR9T4KW6ziopk8v6uYMBF1JkxMc0sO6WzJ4X9Vs9CCUOJdsy5hQuZynkUnlRMmpuwCm3IUZzJZIAzFPi+zCiYeRWjZ+rKpRK5zRx9FMlbxeHYWFahUSpgoLKp3KkzS8eJqSxU2z2uFgBLKJ5Y1pSWHWRhmb9s5se34LJ+Oggn7c7fcubAWMH4fC46P7PBOBDoWAwACnfki4mDvSvvf1nVDYfJRdngXAOSLl03WZ5EacxRMhFugti1AatvDvr6nUozPlvzx4L5ObbHHp+x2fU1QLs1UKArCBx3reRvUgKsAYvkXHkTrS99edF811gF9Ysgcg3C3erEwYYKIiIiIaO468Gcf5hDps2BCs6J6R/fmL1a1mW/JgVzWM2a1NHNysnBFZ8EgrhIIm6uCpHc8tRaCnp4y4iL9JkwUFkwk9tuD1MUFE+P25HJoyToEzIGM/IDMzBVMZEf2FEWkOqN8Xfcd3g2tIz+B1nbau9F90dcA5FcaVxs3rJn93K0VLtZEctl+8s6WHOkJiHC8ZEsOZ8JEpYHU6WInwXi05IgefgZaTrjYuI/V7zSZQGbgBSS3PVJydYzQQoCU9uCi0W/cMRDVgIQJrbUHgR7zuLUTJtxFKnYfXrVMS46pZrXkSAMeg9J2akfh+4tQ4NWSwzqOCl+7njd/B0s+9efSq3bN95dA7+ryRQAeLTkAGMeyFipa8QXA1Q/XLlBy/KydA6mNaNlQitR1o2inVPsTR8GEtFtyRF1tcSzOgVg/CRMiHIdQFHvwPdC1vGILBSXSmi/QmSMFE7rj51rvz9h6z5bpyXzCxMI1xnOP7UNudG/FgolSEftO1urkyWfudN8g9Xy6guKnYMJYsdcM+uQo1BoLJlwJE1oonx5VYUJea+0tPWhvJUx4tOQAjPe61K4n7a97xVdLWSZVq6BFldbWBziSRprG53lqIwktZL9v2IVmTZq0tosc00mktm5E6sUHkSsobLJW6OYTJsxEsoYkTEwY369VoDgx5Gov4N7XkHfCRKS15OprV8JEDYk91ueWTHsnTMj0pF3AXU3ChPR4D5oOlSY8nSu1MV0tORyFz9Y5WrWrmrX2hbOuYAK5jHeSR6WEifRkyfSeQkLVXAmM9u91NgWp55Da+ThCS48s+xyuc0c/hT+xTkANzK5Ej1zaMy2pXMExkE+Tq5jaqBYnTABmYlnKX8GEUlPBRMJuKwgAIlhYMDGdCRPe6XxOWmufq0BSSmm05DCTTpyF2oG+1fa/859L7qKyjEfChHWupTjO04UQiB3xSkw88afiFms+SF0vaslReJ2qRDsARW3ueUiZhIlKjPcC79YwFiXaAX1qzPg89kiYKFXISEREREREc8OBP/swl0ifLTnMCWpI6Rrcn8m2EID3qmVPjtXczr8LV1TaKynLTJgJLWTEkEvpuyWHPehpteQY32/HIOdXDDoKJsxBgu6Lvo4ll//Rtc8zle6hpyahT40WF0wIj4KJkd1QHRNokYNfgraT3wHAsVqiyokIJRyHCMcdCRNTxmBVmclQYbbkkFIaLTmCXgkT+fjd2VIwYb+mSunvr+W412PBpT8FkB/kyuzfCkiJ9J6nSw4W23HB5mS10IINL5gAgPAqI2XCnqw3Bzft2FxZJmEibCVMNKdgAh4JE4CzmKe4JYdXpHDOnGgvLIwIdC1DxEzbKN6QWTDhGKgsebdAxNVv3dlORAgBrWOxvfLLSXesVrJ7PatB+7G58QH7fbFZq/Ht/tplEiaklPnCp1DUVbRk39fZ091HwYR1/FiTjOUSPPL705ov4KhxRTQAjN39C0w88aeaHttouUR+5Z1ed8GEFWU/aa/oCy44BACQ3vMMIHVoHQs9Hw84EiY8JivthInn7jKKbWAUjWVH9uSLE82fi526UurYampLjtGKseGeClty+CyYUFt7PQbtzfOaUoPp1nNm00g7CiayXvHVUvf8HFUCYSCXsX8mWpvxc2726mZ7omUai5eEFsynOdSYhOWXVVigZ4yEFgBI73zCdR+7JYd5Tmi35Eg0oGAiPWmk7zjTITwmZpRgFPpkcT96q4WcUiphIhQz2n7U2ZLDnTCRL060Eias6xFfCRPBWdCSQ88Biur9++ZMmJiulhx24bO0z9GqnaTT2hbMrgl8WJH6Xglt4aJV9K7Hpv0lTACO4qpA2JX8lenfDJmeRGjZUeUf75yM93EcC0WB1tZ3QCVMlGvJoU+NGr8TJYr/XE/jLJhwvGZWwoQ0U7Ccq/MLqbEuyPQk9LS/azw9kwJyGde1keJMAghMb8GE9NGSAzCSqZwtuPTEIGQmabfkUEIxe/wh0FO+JYfMZpAbNYqhCtt62S1GC1LcouvOgj4xhOSLG/1/c9b2UhOAlN4JE+EWCEWBGu9uasGEzFWZZuqgON4LyrHbsk4MFbSFdHy/LJggIiIiIpqzWDAxi+QHoisVTOTbL+SLDULGSpIZVHVLDhQUTFiDLgWr3uxVdFKiXEsOa6WMEvOZMGFuL58wMWgnS+QTJoxJS2sAGjAGxayVtUJRAUWdsYSJrDlYora5+9TbPeUdg2Eym0FurN+VMOFUz0SEc1C2MMKy9MaMlhwyPWUMwDgSJrxbcpQfSJ02VaywtQsmBl40HjoxjOxof9EEs51EMWVMfhiT6I1tyQEA4ZUnGM9nrtDLT/SYk/Nl0jOUiJUw0aSWHFnvgivFoyUHhOoZQS/NJIyqik3M95dg38Fl76ZE21yr5WUu49o3o2Bid/E+ZabsQV0lFDO251gJCanbK830BsS7l5TznshSwi1ALmu0QLISJgIRx8RDfqDRd8IErIIJs/WPeSwHupZ5PsJ+2khLPtGkxhXRADB40xcxdtfPa3pso+USg/ZEZb0JE85ih9zYPkAoCJrFPuldTwHIT6R7ET4KJtSWHugTw0jvfBwAkNxyH/TEIGLrzjKew/z5Z/ZtAQAEShTDNLUlx+SI72SpQkJRHMWbIcf5SPnPwehhL0fk0FOLn69swoR5zpHLILXrSQQWHAIIpWQajXHH8kWiQD7VwzoHaPrkqM/C3kZyJi7YLY2alTDhaMlhFb2lzOPeok+OGC0vzNdAaEGjUKABx7dMTbhalAGAEi49MRNaug6pbY8UfV2fGocSaXFP+NrJRlHI1IRxblhTS47ihAlpJWOFrISJqXzChI80BjthIjOzLTnKHdPOhIlaVzdXy9WSwy5KqSFhYhZN4ANmmofH769XYXR2bAB7f3oJssO77MnlSlytxFQNEApkJoXUjkcBoGLBhLudm7+fudq2YFa93kYxb5mCCY+ENgDImYWIlZLAhEfChAjHjUn2XNYo/ivbksNcpDAxiNzEMNJ7nkV63xa7ILCQVUDkbsnhLJgI5wvRp+O60UdLDsBIpsqN5RMmrIQIzWzJAQCBzqVQ4l1QHWMZ+YKJ/FhDdnSvPe5ReA6hTwwZP7uC96rYEWcCQmDy8dv9fme2nHl9al0LAih5naq29iDb5ISJ6tJM85zJI+U4F94UFuLYX68y7YeIiIiIiA4cLJiYTXR/A9Gas2DC6retBcy2FTNDSll9Sw5rksJama16JExYA2g+Jg8AH/Gh9mPc6RDOhAk7YtkcAC/slVq47Zlqh5Izo3Y9EyYcg03ZsX5ASs+CCVFHwYTa2oesGTMqM8mKBRNC1YBc1h4Edq6olGnnysXJ/ATzLEmYsIpQvFpyOFnHZWbghfzj05NFvyeKXTBhFCOIQMh1n4YlTJjJCsKM+Fai7RDhODL7txn7Zg36lfg9FuZKs2YlTBhtLTwG0T0SJgKdS5Ad3F7yMdZ+VvPaKeEWRNedhdiGc8veL9C1DPrkSD6q3dGSAwC0jkXIjhQnTDhXR4pg1CiMMXvR28/da0x4N6t9gZUwUer33HqtZCphT4h5JUy4Vq75SZiwBlPNaH2t00/BRGu+QKeOlhyB3pV20dJMyyWG7JZOdbfksNpppIyWHGpLt91WKrXLWBWverzfW0qtGLfoyQRkMoH4ca8HAEw++3cAQOKRWwBVQ/SIs8wdMX4uVpFGcOFhxduJdUCfGq0pCroSfWoUaq0JE4Cd+GOsSi1MvCqt7ZRLsPjDN5W4xTzeS6w+dBZppnc9idCSdVBbul0TKC5SehYJFU6gaGbBRNPj961zimksmAj0HITgwkMB1Hee4odQNUBRoU+O2qtkUztKFUy4jzc11oFcg1pyKKGYK0nAayVreOUJSO183EiMcD6Heb5aKmFCbekxCm1rTOwpnTCRMFaiB0JQQlEzYcI8J9YqXxPYRSo+V5c3RS7r2SYCMD+vfRZTNYzIJ0zU2pJDbVuI3Ohe4xpttshlPAsQjOu94mvZPf/xZozdew06Xv0pdJ7zSV+bsVvPBcIQQtjXkqntjwKqhuCitWUfX21LDsBsuTAyywomvFpyqFrZRAd9yl+rK+d5uShMmEhN2Ndt5QsmzEUKI3uw9dOHYesVa7H1k4dg57+9EpkS5/i6XRDteI9zTmxrISOFCdOVMOGvJYda0JIjO2wWTDiKgEIrNhSl4NnFH44UHuuxQgsWJTrkJobcbYSs7ce7ED7oeEzUUDCRb9FSImFCKPZ1mtrSYyeeNUM9CRPOtmvluBL0nAkTmrMlR+XWQEREREREdGBiwcRs4nPlugjF8m0KVMfg/gxN2gPIF3s0oCVH4WoWqyWHEcnulTBROiq+7OatggkzOjiX2G9PNglVgxJpQy4xCJnLQqanvAsmPPpIT4esXTBRMClWoiWHtVrSq6d9fjVWLQkTffakj56esmOtPSkqpMzlVwmFYnafbqsfNmC25DAHJUQwMisKJvK/p5XfPpWChAlL4WCPPRg25WjJ4ZhIb1TCRGjZekAN5NNEhECgazkyg0bBRKWiLdcEdoM521oUbdc6BgoKOQIL1yC95xl7MiC1+2l7oqaWggmhaljy8VsRXXNK2fsFupcDALJWoUnBvmvti5Ad3lU0SaE7iomUUKxEOyJzdb4aaF5Ljqy18rdUwoQx2K0nx+1JOCUYLZkw4bslR1HChDHYGuj2UTARbrWLUqSsvSVHoGcV0mb6wUzLJQbtthmNS5iYMAsmeuw459ROo+WD1/u9/RyxDijxLgzd8jUkt21y3WatlI2sOh5a9wpMPXMnAGBi0+8RXXNqfuDcKpjY8wzU1t7SA/WxTmPir0QLgXrIXNZYlV9jwgQAR1KA/5Ycnqz0qVIJE+b5WnZkNzL7tiC4+HCorb1FcdoWoziv9DlP26mXYuX39uQLkayCiVGP4osGkT4LextpyeW3o/uirwNwpg01b5W/CEZcRY6lWnIUHm9KrDOf1FQHmZqACEZdCSVWgWOh8MrjAT2H5NaHXF+3+sy7Vnub5xjBRWuRHdxufD7WkNhTKmFCTyaghOLGpHQwatxmJxlV/j2yizBmsCWH0SaiTMGEEHZbjmlryeE4j9eTNbbkaF8ImU03JP2kUcq91iIQKjrPl1IitXUj2k57D3re8FX7fLCSfKFnyPXcqe2PIrjwMLtQ2fPxzoQWnz/z2ZToIfWckezg8VkWWmIk1Hi18/Td6srVksPRIiMUg55M2AkPio+CicRDNyE3PoDO8z6D7ov+FckXH8S2z65Hasdj7n0rcX7vntgOTmtLDruQsMLnkta2wHV+nTUTJgKd+VSuvnf+GIs+dKPrcUooDrW1D8nN99hfsx4bXHpkUcJEbrQfaksvSomuOwvJFx7wff6550dvwsBvPmUnIFrt9YD8eZISjtvjM2pLk1ty1JMw4UgeKceZoOc6rlwJE2zJQUREREQ0V7FgYhbxOxAthIDa2mf82xoIUoN2UsJMsFamV1P1LwpbcjhWKrjuZycLyMYmTFirPXNp6OkpyNSEnTABGAM4ucSgPVDpWTChBmeuYMIcmCtMmLAmFvVMEoM3fxW5iRFkR4wWAc7oT9dj7FX8NSRMOGJoZaZySw6huBMmnCsqnasl9fSka3X7bCiYsFb++1npZydM7HvBaL3gMdmjtvQAANK7n3Y9zh6MalDBhBIMo/u1X0DLSW+2vxboWmanNFirpLxWWja1YCKXAbxWwnnEsAcXrIE+NYbcaD+yo/3Y9rn1GPnrjwHAPt7V1p6G76vWZRRMWIUmsihhYjFkeqpoclimp+xBYxGKORKC8o9V411QY51Nm+CwEiZKDTha73F6ctxolwPjfUFxrNS099PZkqNc2oqdMGE8d3Dx4Qj0rkJ41YkV91WJtEBPmsebXl/ChJ4YRK7Bk/W1yE0MItC7ChCi/oSJYD5hIjs24CpWSO96EhACmnmu4EUJhLD0k38ChMCOr56C1K4n8/tqvqerbQsQXXsGJh69FaP/uBrp3U8jtj6fwmJHx2dTJdMlAEf7nwYf1/Ygvo+VsJ5UzThOFbVkEVN1vBMmwqtPhAjHsfv7rwekRGjJ4VBbepEb85hckNKzSEgJx6G19trtwZRgGEq0fdpactT6u1gLoWr5opYmJ0wAxvucVWClda9AaufjruI3fXK06DxTjXZAnxype9t6atI4H3IUTHi1YQivMlpsJV94wP0cU0bChCulwnzvDi0yfj+N94d6EiYc52mphL2PSijmSpjw83MSWsAoovVoCzQtKiRMAI62HE1qB1NEyRdMyNSEu32XT1qb8f7f9OSZalTZkkOfGII+NYagmb7lV77QM2z/nZsYxNQLD1RsxwHU3pIjN7avKUlK1ar0OxhZ8zLI9CSS2x4uebs+NearYMKrJYfxXpCwr4+t9KZSrIKJsXt+CRGMoPO8K9B5ziew/IuPAEJg8Hdfcu+bXWzv2J51nWAWnE9nwUQ+YaJCS9U2o4jBWmCQHd4FKCrUtvx5mlDUogIdoShofclbkNj0ezu9wVoEEV6+Admxfa7PqPS+LXaSWaHYurMAqWPwxi94tjyxpHY/jfEHrsPEo7fa135KiYQJ5++KkTDRxJYc9SRMBEKuogcv7oQJR3KJswVJle2RiIiIiIjowMGCidlE9z8QbbXlcCZMzFRbCABGT0mgtqp/qyWHXTBRoiVHNlW+JYez6j9abcJE2p64UsxBG+PfnWbBhLmSJeKdMDFTK+OyI3uMxADHfgOwB1onHrkFgzd8DuP3XYvssFkw4bHiWCgKRDAC4SNCuZDWtgD6xDD0TMpsO1B+BYdQNUg96yhGiedbcphFFDKbgT45mi/kMAdSZzpaOL3bjJ1fVHpi0Ml6HbJDO6C1L0Jw4Rrj6wWDPZFDXgYRCCPxyM3G7QWTdo1qyQEAned+CvGjzrH/r3UvR2b/VuM/lRImwi1Na8mBMgkT+UKTgoKJhcZK/fSeZ5B8cSOQyyK55T4AQGr7oxBaCMG+Qxq+q4EuK2HCLDTJZdwJE2YbBGdbDimlUUxkDr7FDj8DsQ3nA3APOKvxLqjxxqxWLsle+VsiYSKSL5iw3tOUYOWWHOUGie1VZ2bRT6BzCQ76xnMI9lWe/FDCrZDJhDGoK/WaVkQDQKDHGDh2rhqfCTKbhkwmjCSIaEf9CROO1d5WSw4jOj4EmZ6E2tLja2VsaNlRWPrZuyGzaYzd/Uv763ZBXtsCdL/+K9C6l6P/p5cAgKtgwpmKFVx0aOl9NY8XvcGtZqwiGD/R4V6EUI10CSHyxZe1xu5byVklEiaCvauw6IPX2z/34OLDobX1IjdeOmHCOOcp3z/eSXMULjaL9JmE1ix2OlITJ61FIIKMWTARW3cW9MkRezUvYBTpFBboqPGOhhQD6WaqlnU+BnivZNVae6F1r0Byy/3216SUZkuOVuP8Qc23mwGMY874HsZqSuwplTAhkwkIc+JShIyECVnmc6bk8wYj0DOzN2ECyF9bTFdLDrsQTdeNopRgzDNlz4tqFlPPpoIJqXtPeCqBMPRMEno6aU8MZ/YZn9uB3oOq2k5+Aj1k/z1+/3XQJ4bQfvr7Kj++lpYcbQsAqXsXwU2jfJqYR8HEIS8DAEw99w/X17PDuyF13UzSqVys7TzHcKVyhONGWy8fLTmsa9js0E5E155h/+yCvSvRfsb7kXjoRqT3PGvfv9R1ud3uzvp5T2fCRK58sbnFWuxiJUFlh3ZCa1/kK7Gp9aVvB3IZjN33a/uxIhhFcMEaIJexC7T1TArZwe0IeJxjh1edgLYz3o+RO36IPT+8qGw711GzAD3d/3x+nMRZwK8WX6NqLT3QJ4Y9k0vq5ee92osIRPwlTESdBROh0v9mwgQRERER0ZzFgolZREr/vaGtFemuqNEZSjkAUPXgqHFn4XqMPahTMIirdSxGbny/MSHq1ZLDuULbbzS3s2DCHJhzJUzEOpGbGLJXOHtNWgcXHYbkCw/622aD5UZ2Q2tbUDyIar6Gk0/+GQCQfOF+5EZ2A6pmHzuliGC0toSJVmvVzD7omaQ92OW9IRXQc5BpozjCbjMjhJ06MXzbt6BPjSJmTu7b/WhnsjAIQHrXU4Ci2rH65diDK1I3CybMPuwFv+NKKIrIYachO7TDuN0qhLIGozyKdRoh0L3CKHaZGq/YFkhr60PGMXHUSIUpDU6KV8KE+Xqm9z6LlLlKLrXtEQBActsmBJeua0p8ttraC6GF8gkT2YxrQN1KcbFWgBn3SRsrxs3vpfWlb8eCS35ifF+O71uJdRjx7g2eWHbtR8E27W2bk1761LgxIaZqEFog3xbH1frIkTDhoyWHqKHoxyqy0FMJ4/OxjoQJID/xMlOsAWc13gk13gW9QS05dLNgQmvpNaLjzZXQldpxOAU6lyB66CmYeOQW+2vWoL7athBaaw+WfPwPUNsXIrRsPYLO1YuOQhavQjIrkaThCRPmqn5f0eFeVM01qWb8XeP7hvBOmACA2OGvwMLLfoXYhvMQ7DvYSJjwaqNR5TGvti1ofsKEuSJV1Fi8VC9RR+sw/9uI2IWbsXVnAQBSOx+3by/ZkiPa0ZBiIJmayCf6FPxdSnjlca6ECZmeBKQOJdJqvBdYhQzm506gd2W+KKiWggktCAjFO2EiWH3CBAAogYidajQTpJ+EidgMtuRITdS0ollrMwomcqOzqGAimynTksMojN539WXY9oUTIKW0Cx2twke/RCgGCMXelhIIA1JH28vfi8jqkyo+3pUw4fPa1koKmA1tOSr9DmrtCxDoOxhTz91lfy29+xm88ImVGP3bf0GfKk7SKcWdMOFItQnFIVP+CiZUR9F/fMN5rtvaz/wghBbC0K3/Zn+tVPKjnUTnSBQBpithwmpLWqklh3F8WAkTmaGd0DqX+NpGaOk6hFYcg7F/XG0+dge0ziX562+z8DK7fysgdQR7V5V8HiEEet/6PfS86VtIPHQjBm/455L301OTGLv7F8a5VS6DlNmyzXmuZRf3FyRMAEab06bQczUXbHZd8Dl0nXdlxfs5EyYUV6sXtuQgIiIiIpoPWDAxm1TRG9q6QLYH99WZTZiopSWHXTBhDeZYyQYFk/8dZ34QgZ6VyPRv9o6ntiamFRXC56CiXRiQy9rxkWrc3ZJDTwwZE8nwnvCLrTsbmb3PIjPwoq/tNlJ2ZE9ROw4Aroh0AJja8gCyw7uhtS0sO9GhhGKebRHK0cz+6bnRvZCZpK+ECUiJnBXxGYrZ/a/19ATS+7Zg8HdfQvzY19lpCNO6WqiM1O6nEOw72F/UtON10DryBROlkljiR77a8biClhzhxrTkKCXQtQyA0V7CjpX1GPQLLlmH9J5nmvJeI30kTBTul9axBCIYQXrvc3Yf9/TeZ6EnE0ht34TQ0sqxy7UQigKta1k+maNESw6goGDCTmwoLiZyJUzEOqHGOprekqNkwkTYmTAxCcVcsWcnTDhbH/lMmEBBwkQ17MSLqTGjF3etBROzJGEiXzDRZfR5nqizJYdZyKJPjkKfGLbbz1jFCaU+G8qJrT8f6T3PIN2/2djfkT1GXLQ5mRHoWYEVX34Miz9+q3s/HD8X+z2ugGK35GhsIVC+JYfPQskShKK6ik+B2ifkBYRdaOSl5dgLsfjDN0GoGtTWXleii4uUVaWqaO3TkDAh50PChDnhpoUQWXMqACC98wkAZoJDYrC4JYdZYFsv3VEwIYLm32UmZiIrT0B2aIedIGDHpjtaZLi+J0XN/47WUPQihIAIGedp9j4nJ/KFGaEoZHoqX8Dtd2V++6L85+lM8JMwYRVMTFdLDkfBhDPFoxqanTBhvC/kJkex6zvn2+/xM0L3Lk4RgTBy4wMYu+9XyO7fitzoXvvaKtBTZcJEKOY6BxfhONS2Beh+3Vf8PT5SfcGE9Xo3vXDNB6tNZ7nPosghJ2PquX/YrRmGb/+OkWJwzzXQJ0f9FSI6UiJdxb/VJEwEI3bBQ+yoV7tu01p70XrKJRi753/spEQrYcL5O2G3uzM/w63/69NxzWilbJZrTwdnwoRxfGSH/RdMAEDrye9AatvDSG1/FNnhXdA6ltjnfbkxo2DC+t32SpgAjPfxjrM+grbT3o3h276FqefvLrrP+P2/hj45gs7zPwvAWHgBuBMmSrfkMMZRmtWWQ+q5mltyxI54JaJrT694PyUQyl93Oq7ZXMd3De/HRERERER0YGDBxCxSTdRxvmBilrTkMCfhoFYziF46YaJwUkwJx9H3rp8ZE2+eCRPmAEm03XdkrbVdoyVHiYSJeJe7JYdnwYSxAnHi8dt9bbeRsqN7oZrFCi7OCaylRyKz91mkdj9VccVxoHeVPYFeDatgIju612jJUSlhwhzssAf3Q3H7b5mawMD/fBhCC6L3Lf+e/5bMQbCZLphI73oKwcVrfd3XVTBRpiUHAMSOelX+P4UtOZqYMKGZ7SUy+7fl34M8Bv1CS44AchlXNG6jlE+YKN2SQygKggvWIL3nGaS2Pmz8/kqJxKbfQ58YQnj5hobvpyXQvQzZQWdLjvzPVDVXdWaH86s6pRk3XnLQ2NWSo7Nhk2+lfxn/tQAAIABJREFU+C2YkOnJ/IBhwaQbUND6qNxnlqIidtQ5iBxyctX7ag3M6lNjxsr2Ggsm1GgblHjXzCdMWElG8S7jZzxeZ8JEuBVQVAzf9m3jec3PL6tgQq0iYQIA4mabjYlNvwdgfr609rmK7NR4p71K0ib8J0w0viVHAxImFNWRLOFO96maEFCC/lceatZkR4nJBSl1owDDJ3UaWnLYhb01/i7Wy17V2cS2CFahmNaxCGqsHVrXMqR2PAbAWL2rJ8eLjnMl1gGZnoKeru/8RKYn7PdbXwkTq44HAEw89gejmMM6pzLfO+1WGY73buv8pdafoRKMQRYlTLj31SoW9JuKEFqxAamtD89YyzWZ824TYbHew5qZbuJkv+9KsyVHDSualXAcSrTdLjqYfPovmHj0/zBuxvrPBJnLehfHBsJGSopZhJ/a/ijS+7ZAbe2r+vsvLJjoe9sPsOTy26HG/BXXiWDU/mzz2wLAeS0043ykvETWvAz6xDDSu59CdrQfY3f/Ekq0HcnN9xqth3x8rgohjM/QgglkJRQ32pOYn9HOgttS1Hg3QgcdV7LQs+OM/wfkMkg8dBMAQCaNgi1XwkRhSw4rgWuqSW0EHexFI5USJhxpjFJKZId2ItBRRcHEiRdDBKMYuu3bxmM7F0NtMZ4zaxZMWO2kAr2V2971vPHfEOhegb0/eacrNWjiiT9h4NqPI7j0SLSf9m4AsFM+nYUC+YKJ/NfshIkmFUwgl62t/WuV7EQhZ9GVEPkCISZMEBERERHNWSyYmE2qSJjQzFUKzkH+GU2YsFem19CSo2ByuFRRRHTNy9D9hq8jtuH80k9lvg6+23E4tidzaXviqihhYmoU+qQxweNVMBFYcAi07hUzUzDhkTBhrxxUNXSd/xkAQOrFjdA6yk+gLf7Y/6Hn4m9WvR9WDG1q5xNI734KwQoDNdYxbg3uOycIpjbfh4nH/oDOV3/atb+zIWFCTyeR2bfF7gNeiXOAUOtYXDZhItBzkD0JYxcPTUfCRLdRMJEd3G4PUnsN+oWWHgnAHU/eKDKb9lyNqoTjgBooWQwVXHAIklvuR3Z4l9HjF8DYXT839nf5+obvp0XrWoHMfqslhzsdQwmGocS7kB3JJ0xYK8hLFRM5B+GUWCeUePMLJkolydiJDskE9NQkFDPBoHCVMmB8j3YEcpnPLCEEFn/0FsSOfJXnfbxYx72VMFHLimhLsHcVMgNban58I9g9oGNddkFePdRYOxZe9iv7MzPQvcJ8fmOgt9L7faFAzwoEl6xDwmzLkRvd6yulwvr5K+EWO12leF+blDBh9u2u5rO/kFA0R7JEfQkTEEpVA+nOdlZFpKyqSEhrWwCZTNhx5U1RRWFvM9jvOU1si2BtwzqWQ8uOshOMki8a7dfCK49zPcY6vq3zxVrpqYl8ok/B+28poeVHQ21fhP6fvRvbPrceg7/7kvEY83zVLrpwFUyY5y8+i4sLKaGo3ToNMD4v8q0/jH2efPqvgFAQXuavaDG0bANy4wPIjuyuaZ/qpleehFPNVkd+UzPqZ/x8pK4bn8c1tOQAjGN1ast9AIDkFqN9y9Szf2/MLtZA5jKer7V1jmEVWKa2P4rMwIsIeLQXKKf99MtcRdfhlccZRb8+CSHyr7nflhzmtfmsSJiwxgTKFJdFDnkZACCx8QYM/+FbkLk0Fr7vGvt2JeqvEFGogaLj00p7tFqPVUoe7Ln4G+h9U+nrz+CiQxFceCgSjxgFE/mFDI7J+6C7YEKNtUPrXIrUixt9fQ/18LvgRWhBKLFOZEf7oU+OQKYnq0qYUONdaD/9fRi/71o7YUIrOIfI9G+GEml1LQDxokRa0PfO/0Jm3xaM/vW/AADjD1yHXd9+NbSu5Vj8kZuhRFqgdS6BzCShhFtcBbTWdY8rYcIsAs2ONSthIutrnKxeSomCCeP/5gIdFkwQEREREc1ZLJiYTcxITH8JE8YFqSthIjcLWnJUVfXvVTBR+rDsPOcT6HnDV0s/k3UB64iJr7h1q2AimzESJoTID4jCmLgEYE+KKh6R8kIIxNadhcmn/zKtRSt6JgU9MVi6JYd5DEUOeRmih59pD4xXSphQAqEqf4YGa5Bw5E/fg8ym0XrqpRUeYCZMWKuD7TjnGNI7H4cIx9H28ve6HjIbCiYye58FpI6QxyrqQkJR7IFWrX0hAn0HmwNZPSXvHzvyHHOFsjnwp1oJE80rmFBb+yC0IDL7t1Yc9AsuWAOoAaR2NL5gorCthVPbae9xDeI6BRausVetxzacB7W1F5NP3QEIgdCSdY3fT2u73cuRG+uHnk4a770FA+pax2J3Sw7zuC3VkgPIDzwaLTk6IZOJ5ryfWKsOKyVMZKYckbTmxF3BwKG14rZZk6f5Ao4xY7V9HavaAz0HIbNv+tsmOVktONSW7oYUTABAy3Gvx4qvPoll/3wfouvONp7f/BzTSqUPVRBffy6mnrsLuYlhZEf3FqdJlGL+XAILD/VMeBJaECIUa3irGatgwu/ETkmuhAmrzVmNk6JC2IVGfuQjuvuLb5R6VZPa1s+qmaubpTTOU6djwqKUfEuO5q3yt84nrfOl6JpTkdn7HLLDu5F84UEILVT02dKIgiCp60ZCl1Xk4KMlhxKMYMWXH0Xv238INdaJ8Qf/19h3s9jDmlB0TvrY5y81vp+KUMxIAYDZomRiyG5ZZx37k0/egdDSI32nY4VXGIUVqa0P17RP9fKTMGGlKjXz2HNvsP6ECQCIrH4J0jsfR25qDMkXzIKJzffMXJG97v1aW+cYned/BlrXcqR2PIrMvheqbscBGIVOrS95S127ap0T+f08UEJRKJHWWZEwYbXFKVf8F+g5CFr3Cgze9AUM3/YtxNafh9iRZyN00LEAqrj2ULWiFgV22oz52Wa9r3ppOf6isklk8WMuwOQzdyI3MYzUzscggtGCIl7zusnxtcghL8Xkc/9ofnKNnjWKJX18XmttfciN9SM7tNP4v0eRqZeOsz9uHI9Sh9a5uKgFRnrfZgR6V/tO24yuPQPRw8/A0P/9K1K7nkL/z96D8MrjsfQzf0egaymAfKu1wsSRUimI+YSJ/VV9X37JaUuYMM6jC6/Z7ERTFkwQEREREc1ZLJiYRaze0H4GootbcoSAXNbuQzrtrFXL1fSVtC7mHf1PzRuq3rw1QKJWM2livs5GwsR+KLFO12uvthh92/df92nzub1XsMbWnQWZTGDq+Xuq3fWaWSuYShZMBKNQwi1oOeGNUKNt9mBHtSuO/VICISixDuTG9iGy5tSKBQXW65zZv82cYHLHObedcmlRbO5sKJhI7XoSAHwnTACOyZeOxVCCYaz42tN2xGmhzvOuwKIP3ZBfNaUVr95pNKEo0LqWITO4rWLKjdACCC46DKmdjzV8PwpTGpwC3cvRctzrSt5mtTkBgPCyDQgtWw9IiUDfITWvyPTDal2T2r4J6d1P59NDTFrHIrvfMlChJQfy739qrNOe8G70anygfEsOqwe1nhyH7mjJYU9SFkQq2wVqzSqYKEyYqKdgoncVMoPb7OK+maAnjGIBNd4FJd4FmZ6sO8IfMAoVwyuPswfIrYHeWt7vY0efD+g5JB652bvlU9EOGD+X0KJDy96tGa1m9CmzYKKOojKhavlzqUCdCROotiWHuTp0vFTCRHXHvNUKqKmrmyu0bWo2u4iriav8lYKEichhpwEwUhOSL25EaPmGouNDNc/D0ntrb1dlfUbkz4es99/yn2NqvBPtp78PS6/4K1b/xzBWfO0phFccDSCfUiFKJUzUmNijBPMJE6ntjyI3PoDI6hPt2wAg0/88wqtP8v2coaVHAUIgtX1TTftUL+knYcJacdzEdBMXkS+YkMlEzRHw4dUnAVIi+fw9SG7dCK1rGWR6yk5LmW7lWnLEj7kAned+GtG1r0Bo2ZFIvvAgskM7EOhdOc17acgXTPi/tlXbFiI7uhe5iZEZSR60SB8tOYQQWHrlnVj0wevR+9bvo/et3wNgFC8A/q+pSyVMWO9jI3f8EEq0vegcuVqxo18D5LIYuuWrGL//N2h/xf9zFwWoAUAIV2FG5OCTkRvZjay58KFZjGPa3zGitvYhN7YPmaEdAFBVwgQAaO0L0GZeQ2odS8zUig5XS45AX3WJLF2v/QJy4wPY8eWTISGx8L2/hOo4p8oXTLjPs/IpiI6CiXgXIETzWnKUKbhqJMUc8ylKmNBCRuLhNLVmIiIiIiKi6ceCidmkioFouyWHeSGXT0sov2IoO7K3KauKamrJYcr3DDcLJ2oYxLUr/qNVJEwIYbcyySX2u9pxAEDsiFei/cwPoeuCz2PRR37nSp8oFD3sdEANYHzj9VXvu0VKiYFfX47Jp/7i6/7ZkT0A8pMkTkowgoO+sx1tp74LABBeafS5blbBBJBfzdx++nsr3BN2Yc34vb9C/OjX2APQSigGKCo6zvxQ8UPMY12fwYKJ9O6nAUVFcMEhvh9j7bc1+aK1L/AcaFFjHYg72s5MR8IEAAS6liO7f7v9e1yu8Cm0ZB3SO59o+D7IXLqmlZvBBUbBRGDBIVAiLfZEUXjZUQ3dv0Ka2cpk5M8/APQcWo690H17+2JXvLi0WnIEyiRMqBpEOG5PeDejLYddMOFxDIpwC/RkAjI1ZU9+2RHxBSsE7Z7uTZo8tY57PTluJDDVmTABPYfM4PZG7V7VcolBiGAESjDiKIqpP2WikJWOVClRqJTwQcdB616B8ft+jdzYPl8pFSIQgtCCRrFS2f3qqFgEpE+NY+9VlyK993lf+5ubHDFjous4BoUzYcL8vai5JYewJ6n9yLfkKJ5ckFJWdT5k/ayamjBhpxDNzOVDvnirmQkT7s/s0NKjoMQ6MPnkn5Hc+hDC5uprp8iqk6C2dGP8/t/UvF2rCKEwWaKalaxKMOIqIsy3ysh/7gR6V0JooZoTe4yECePzLPHw7wChILb+PNc+A0CkioIJJRxHcMEaJGcoYQI+EiYiB78U0cNfgUDfwdOyS9ZksJS60aql1pYcq04AhMDo36+CTCbQ8cqPAAAmn5mZthzlWnKElh6J7td/BUJREFq2HpmBFwCp15Qw0QhWcko1bVi0tgXIjfZj/2+vwK5vnYPkthkqAvJRMAEAgc4liB9zAdpf8X47UaD1JW9FdO0ZCB90vK9tCTUAUZgwYR6vmf7N6DzvStcEfC3CK46F2r4Iw7d9G0q0HZ2v/pR7H4SACERchb2Rg18CAJh6/u66tu0l8cjNGLj2E8aiEZ+T+FprL7Kje5HcfC8gRE3tZjrPuxJtp77LbqmitvQiN7YPMptBZv/Wim0xC0VWn4TokWdDnxpFz8XfLPp9Cy6qkDDhKJgQigol1tm0golqilPqoXq15NCCTJcgIiIiIprjWDAxi8gKq7udgkuOQO/bf4DYBmOQ0upRWq4tR3ZkL7ZesRa7f/CGmvYv3b/Ze7LJWrVbxUWsNRhoTZLWlzBh9iytto+5FgRyGeTGB4v6farxLvS+5TvouuCfEV9/btmnUSItaD3xYoz942rkErVNck5s+j2Gb/s2+q9+v69V0NlRo2DCq8e8Gmm1X2OrYEKtYQLNL619EdTWXsSPeW3F+wrVTPfIptB57hX211tOehO6L/wSAj0rih8zSxImgn0HVzVZY0++1PDa5wejmpeUAMB3wgRgDGhnh3bWfJyXIvUcIGVNKzet4hWrUCK0fIPr72YJdBkFE+MPXAetazlCK45x3a51LEJutN/+XdbNCSbPlhxaEGqs0+ibbU546w1o2VBIlmnJARgDn/mECePYDfSuRMtL3mqvtLbv2+yECatgYmrcaMlRxyStNSidGXjBeM7UBIZv/25Dj+NKcolBY/UdYBfoNeNnHOhZAaEFoZnHaDWEEGg5/g2YfOKPgJ6DVqIgr5ASjGDZFzai7fTLyt5PjXXa7XO8DP/pexi767+x/7ef9rW/+tRofe04YCVMFLTkqHFCXlTZkkMJxSCCUbv/uIvUUc35kGoXTJRo79EoVZynNoM9UdHEhAmrqM1KjRCKgsiaUzD+4G8hUxMIrzyu+DFaAPHjL8LEI7cgNzVW03alWTAhQgXJPnVMzthpFY5JH6GoCB10rP05U/VzBiPITQxBSonEwzchcvBLoZltAq3iOiA/WelXaPl6pLY9Yv9fTyaM9+gmJC0VknrlSbhAzwosufz2uid+qyIUQDdbclSRXOOkRloRXLIOiYduAgDEjnoVgkuOwNQzf2vgjlbB5wrx0NIj7X8HemYwYUJRfbc3AIyWC+n+5zF2zy8BmEW1MyB/rlf9Z5nW1ocln/xjyWuxUoyECffxaRVQaF3L0H7G/6t6H4q2oSiIH/0aAEDnuVfaE9qu+wQjrs/u4JIjoERaayqYSO18Ajmz5VchKSWG/vAt7P7ehRi+/TsY33iD789Eta0P2ZE9GP3bTxBbf66dMlUNrbUXfe/8LzuJUWvtRW5sAJmh7UAuW3XCBAD0/dN/oe+Sn9gLLZyCC43UyMIWS3ZRf0EKotba29SEiarSTGuk2AUTxS05WDBBRERERDS3NaVgQghxthDiWSHEZiGEv1FvyidM+LjoFkKg/fTL7IE7e4CgTHrE/v+9EvrUKCY2/R6JR2913eaMji8lvfc5bP+X47H1isMxetd/IzPwIsYf+C0yZg/OcjHvZb4L177bq0LqSZgoMYBS9nFqwJEw0VX1dp06zv4YZGoCo3/7cdWPlbqOwRv/BSIcR6b/eYzd8z8VH5Mb8W7JUajluNej7eXvrWrFX7V6Lv43LPrwTf4mmsxjPHrEma7Vmm0veyc6z/1UyYfYBRPmxHO9Kh3zpaR3PYXg4rVVPUZoISjhFt+9vN2PDUCEYk2fnAp0r0BudC/0ZML4QpmJg9CSIwAAqZ2PV70dKSVG77wKo3f+1NVTuJ6BXSUcR9drv2APyEbWnILg0iMRO/JVVT9XNbSOxcZxbKZLFA6oax2LAKnbq73tlhwVCiYAONIHmpcw4TXhqIRbkNm3BTKVyCdLaEEsfM/VCBashLNXYDWtJYfxO9OolhyAsdoRAPb94gMYuPZj2PuTdzSsv/XYPddgx9dOR3rflpK35xKDUGNWwYTxdzP6PLccfxFW/Ouz9iRmLY+3qG19vh4TWnw4lAo9ytVYO3KT3pOfuYkRDN/2bYhwHImHbvK12lyfHLGjk2umqBAB93lILe9FBmG3jfBLbe1FdqxEkYOU1bXkiHcBqoacmT7VaNmRvflizplqyRHKvyc1bRsFLTkAIHrYy+1zj/BBxQUTANB60pshM0kkHrqxpu3aCRMFhRL1FEzaCRMFq2QXf/hG9L7t+zU9Z/Sw05He9SSGfv91pHc8Zk9iAvl9VtsWQOteUdXzhpYfjezQDuTG90NKif6rLzPeo3/6zoa9R3uapkm4qimK0ZIjNQFRx3EQWX0SIHUo0XYE+g5GdM2pmNp8L2Q207BdzQ7vxsRjfyj7s5K67rs41plYVHjuMV2UcLzq5ES1bQFyI3sg01OIrDkV4/f+qmGf8+MPXIfh279bsv1mbmIEA9ddYSdaWAsopqN1gBJpLbqGDnQuAYRA9+u/AiVYuhVdtTpe8QG0nX4Z2s94f+n9CEZc73VCURFefVLVBROTT/8N2z5/DHb+6xnQU5NFtw/e+C/Y/5tPIn7s6xBcfDiyg9t8LxjR2hZApiaQGx9Ax5kfrGq/vKitPciN77PPbwNVJkwAxs+r7ZRLShYHBc02m2pBwgQ8ivrVlp6SqVmNMH0JE8Z1mFKYMBEIFaWpEBERERHR3NLwgglhZHP/EMCrAKwF8CYhRHUzjPOM1HVIPecYiK6hYMAc7NfTk8ZzFfyZ2nwfxv5xNdrP+ggCCw7BwK8+Bj09hczAVuz67gV44aNLsevfX4PMwItFj81NDGPXv18AoQUQPug49F91KV68fDX2/OhibL1iLYZu/SbS5kV6VX0l7YQJYzAqvPJ4dJ7/WUQOPrn671+rLWFCqEHITBK58f1FCRPVCi09EtEjzsTwn74PPVX65+D1J/HQDUht34Tet34PoeVHY+jmL0NPJ8s+Jju8CxCKHeldjtrSjb53/KipqyJCy45CZNUJvu6rhI1Cn87zrvT9/NYgmJ6aqOq1Lfzj55gv+h2YGsPAry9Hpv/5irHzpfa71mQPoQab3o4DAALdywAAmYEXje1WSJgAgNSOx6p63fVMCvt++QH0//w96P/5e7Hvlx+AnkkZt1upITWuGu56zWft1axaay9WfOkRhJauq+m5/BKqBq3D6D0cP+51Rbdr7cZkW3Zoh/H9m4OuXi05oAbsFb92S47x/f5e31wW4xtvwPYvn4yd33glJp+6AzKXLX3fTMrYD49B9LaT34Hk5nuR3v10xYlfaz+blTAhVA0iGIU+OVJ3wYTWvghq+0Lsv/6z2PfLD2Hs7l8gvPokTDx6K4Zv+05d7ylSz2H07z/D3p+8A1PP3omdX3s50nueLX4fSQxCiRcUTDQhYUIoKgJdy2p+fGj5BgT6jAF3rb1ySw6/tPbFSO95FoO3fK3k59vw7d+BPjmCxR+9BUqsA4M3fr7ye/PkaFFMdLWCvSvtCQYrrarmSSahVP05q7X2ITfWX/S9Gce8/5XNQlGgtfYhO7K77uO58Ljt/+/L8MJHl2DPD15vbmuGEiasdhVNTJgobKMFANFDTzNui7R5tmQIrzoRgZ6VGL/3VzW9znpy3PjeCloh1XPeZk2yFxZMqPGumpMS2s/8IMKrTsTg9Z8FAMSOzrcRs/Y5svqkqlblA0DYTIVKvrgRY3f9HOP3/sp4j37kFoz88XsNPaaL/mSnZxKuWkIokJkkZDZtF7/UwiqWDq88DkIIRNeeDpmawJ7/uBiZwR11v36JTb/H1s+tx65vn4s9P7wIucSQx+tsnH/4KU4JdK8w2i0FwnZ6znRTwi1VJScC+SL2yJpT0Pv2H0BmUxj564+rfk3Tu5/Bnh+/A1uvXIfh276D/f/7Gez50ZuMIqL/fIvrWigz8CJ2fOVlGL71G9jx1VOQeOQW+7x6OgomFl52Lbou/KLra4Geg7DqBwNoPenNDdtOcNGh6Hv7DzwLMJRIW9E1U+TglyK98wnf59PpfS9gz4/eCK1tAVLbN6H/qktd59Mjf/4Rhm7+MlpPucT4vi/4ZwD+xz+sa/bgorWIHHZ6Ha+G+zmzo/12K7NgX/UFE5WeX21bUPR7WKolB2CMOeTGB5ryXj1dxW2hxYdDiXUWLcRhwgQRERER0dzXjCuO4wFsllK+AABCiF8DeA2Ap5qwrTlh7O5foP+qS43/CFHToJ1iTsK9+HHvPq9q+0J0X/AviB3+Cuz69rnY/B6rt3EUradcgvH7f4MXL/e4yFY1LLn8j4gccjLG7vo59EwKoaXrMHzrN7H/unwiQGGP+7KEYqzsdKxi7r7wC/4f72DHDleZEiGCEYze+VMAxoqIenWc/XHs+ubZ2Pze6tMEAgvWoPWkt0CNd2P3v5+Pze+pfEGuti+asYmLerQceyGC//Kg3UbBD+tnvOeHF1W4Z2X2MX/fr72P+RLaTns3Os78UFXbUkJxKJHaBrpFKAo1Wl1qSi20buN9w/pdLre6Wm1fCLWlGwPXfAQD13yk6m11nPNJAMDwrd/A6F/+03Vb4Uqe2S7QcxBkLoPwyuJCIasX9I4vuwvAvAbalGDULtqy3sf6f/Zu9P/s3f73p+9gZFIT2PmNV1a8b+EEmqXj7I9CzyQxeP1nK65sVlt6zM+sJk5eRtsxfPt3ANQ3SSoUBUuv+Bv2/OhNGLnjh4gcehqWXH479vzojdj/m8ux/zeX172v0SNeia4Lv4Dd3zkPW68oXSdqpTc0s2CiXkZbjjdi6Jav2IU/jdD5ms8iO7oHg9d/1p5sLRQ/9kJE15yCjrM/jsHrP4vnL6k82ROr0DKrkkUfvN7+t9BCRtFDlSkR+ccH7YJAv9S2Pkw8cnPJ77Xq1c3tizD2j6sx9o+rq3pcRYqK1pe8FROP327sVzXneo3cDTOpqdafj69thFsAobjaaAUXHw61pQehZUd6tgYSQqDlxDdh6Jav+DpuPbdvTvgpkTZAKHWtZlUjbcZ7tFehXg2EqmHBu3+Obf98NAK9q12r/619D6+urh0HkG+jtevbrwYARA47HUsuvw27v/86DFz7MQxc+7EG7L236OFnNPX5a6IG7M+/eopnw2ZBaXjViQCA2Ibz0fW6L2Po5i8j8dCKuncTMBIhYqdfhqH/+zoSG28oe187UbDcfRQFoWXrkUsM1tWOqx5qrMO+vvbLKphof8UHEFq8FtHDz8DgDZ/D4A2fq3r7IhhFaMkRGPj1JwAAradcimDfauz/7RUYf+A6132VaDsWvv9ao1XEdy/IP8c0nFd7FSiXapvRTAvf9z9FBZSRg18KANjyQX9pWYDxWi79zJ+ReOjGkq91bMP56HvHfxhtQo65EKGlRyE34e9czvpcaT/zA1UXlXk+Z9sC6BNDGLjmwxChWMMLjIQQWHrlnfkiaZNd1Ffwc1Zb+5DeeENdn4PlRA57eVOe1yl29Guw6ujXFP2MlFCsqkJWIiIiIiI68IhGx5wKIV4P4Gwp5bvM/78NwAlSyg8U3O89AN4DAMuWLTtm27ZtDd2PA0lq+6NIPHILACDQtwqtJ76p6ufITYxg9M6f2KuHS4kfc4Edpz/+wHVI73kOQg2g5aQ3IdC1DJnBHcbKuFxxRGvkkJciWuICVUqJ1Isbkd7zNPSpBNpOe1dVq1kSj96K8IpjoPmM/S5n/IHrEFv3qqpaH0w8dhuSL24EhILWl77NnuSsldFy4KfI1dBDPL7hPISWHVXVc4QPOhaxI8+uZVcPOFJKjP71P5Ebr2+C0X3Mb8f4vdeWPOYLRde9EpGVx1e9veQLD0IEwjUlHqR2Pw19cqSprVQAI+J05I4fQZ8agxLvTc76AAAPrUlEQVTrQPvpl5UdoLZ/b6oUWnYk4huM1aiJR25Gavtj9m1CDaDt1EvrTnqZTsltmyAzSURWn1h0m5QSo3/5T9eEuNrWi7ZT311ykHRq831QIq0ImS1fxu75H2QGtvrel+DCQxA/9nWQ2QzG7/81sma7pFLUlm60vfy9ZQdrEw/dhODiwxFcUHo1NWAkYExtvsf+mTZD4tFbkdr6sDFh+9K3GTHPddAzKYzf9yvE159nrIKbGsPY33+Wb0dTIyXajrZT3wUlGEa6fzPG77/OSAgoED/2tQgtPhwym8bgLV9D/KhzEF5ZOuJ/JuWmxjCx6fcNXR1qmXjyz0huvq/4BkVF68lvR6BjMfT0FEbu+JGvFkyx9ecivLy65J9yEpt+j/DK42vqLT759N+gdS1DsHel78c4zwFdajjmp56/G5NP/dX3/X0RCuIbzkVo6ZHITQwj8cjNaD3xzb5i9Zth/KEbET30tKZNxmVH9iC57RHEjzrH9fXJZ++CGu9EaPHhno/NJYYw+ref+DqnKEUJt6D9jPdDaAFkx/Yh+cIDiNdREJQdG0Byy32Ibziv5ufwMvnMnVDCcYRXHOP6+th91yK+/ryaWomM3XctMv1bIAJhtJ3yTqjxLuM9+s6r7JYlzVLrOV4zjW+8AeldT0GoAbSecknNbZYAYPyB3yK69nRX64TMwIsYv/83+YTDGqmxTrSeeimUQAjJrQ9joqDto5NQNbS+7J2+rvtSOx6DnposeY41HTL7tyGzbwuia/0nAeipCSQ23oCWk94CoShI733emHCvcrxFCcfRctKbobX2Yur5u5EZ3IGWE94IIQQmn7oDU8/fm7+zUNBywkUI9q2GnprA6J1X+T6fn+ukrhvXN5Mjvh/jvB4fu/sXyA7usG9Tom3muV6+kCa99zlk9m9D7IgzK+9PNoOxe69B60lvadhnaHZ4N0b/cTWg5xBadlRT3u9LkbqO8XuvQctJb3Yt3kjv24Lx+35d9THvV8vxb0Bw4ZqmPHclya0PA0LYiUhkEEI8JKU8tvI9iYiIiIhmvxkrmHA69thj5caN1U++EREREREREREREdH0YcEEEREREc0lzVhysAuAc5n+EvNrRERERERERERERERERERERLNCMwomHgRwsBDiICFEEMDFAG5uwnaIiIiIiIiIiIiIiIiIiIiIaqI1+gmllFkhxAcA3A5ABfAzKeWTjd4OERERERERERERERERERERUa0aXjABAFLKWwHc2oznJiIiIiIiIiIiIiIiIiIiIqpXM1pyEBEREREREREREREREREREc1qLJggIiIiIiIiIiIiIiIiIiKieYcFE0RERERERERERERERERERDTvsGCCiIiIiIiIiIiIiIiIiIiI5h0WTBAREREREREREREREREREdG8w4IJIiIiIiIiIiIiIiIiIiIimndYMEFERERERERERERERERERETzDgsmiIiIiIiIiIiIiIiIiIiIaN5hwQQRERERERERERERERERERHNOyyYICIiIiIiIiIiIiIiIiIionmHBRNEREREREREREREREREREQ077BggoiIiIiIiIiIiIiIiIiIiOYdFkwQERERERERERERERERERHRvMOCCSIiIiIiIiIiIiIiIiIiIpp3WDBBRERERERERERERERERERE8w4LJoiIiIiIiIiIiIiIiIiIiGjeYcEEERERERERERERERERERERzTssmCAiIiIiIiIiIiIiIiIiIqJ5hwUTRERERERERERERERERERENO+wYIKIiIiIiIiIiIiIiIiIiIjmHRZMEBERERERERERERERERER0bzDggkiIiIiIiIiIiIiIiIiIiKad1gwQURERERERERERERERERERPMOCyaIiIiIiIiIiIiIiIiIiIho3mHBBBEREREREREREREREREREc07LJggIiIiIiIiIiIiIiIiIiKieYcFE0RERERERERERERERERERDTvsGCCiIiIiIiIiIiIiIiIiIiI5h0WTBAREREREREREREREREREdG8w4IJIiIiIiIiIiIiIiIiIiIimndYMEFERERERERERERERERERETzjpBSzvQ+QAgxAGDbTO/HPNQNYP9M7wRRA/GYprmIxzXNNTympw9fa5preEzTXMTjmuYaHtPzw3IpZc9M7wQRERERUSPMioIJmhlCiI1SymNnej+IGoXHNM1FPK5pruExPX34WtNcw2Oa5iIe1zTX8JgmIiIiIqIDDVtyEBERERERERERERERERER0bzDggkiIiIiIiIiIiIiIiIiIiKad1gwMb/9eKZ3gKjBeEzTXMTjmuYaHtPTh681zTU8pmku4nFNcw2PaSIiIiIiOqAIKeVM7wMRERERERERERERERERERHRtGLCBBEREREREREREREREREREc07LJggIiIiIiIiIiIiIiIiIiKieYcFE7OEEGKpEOKvQoinhBBPCiE+bH69UwjxJyHE8+bfHebXDxVC3CuESAkhPlHwXB8WQjxhPs9HymzzZ0KIfUKIJwq+XnKbJR5/jRDiWXNbPxNCBMyvnyaEGBVCbDL//HO9rw8dmObYcX2545h+QgiRE0J01vsa0YFljh3THUKIG4UQjwkhHhBCHFHv60MHpgP0uL5KCPGoefz+rxAibn79FCHEw0KIrBDi9fW+No02y17rN5iP1YUQx5Z5fNX7RvPHHDumX2O+p2wSQmwUQpxcz2tDB6Y5dkzzupwAzLnjmtflRERERETUcCyYmD2yAD4upVwL4EQA/08IsRbApwHcIaU8GMAd5v8BYAjAhwB80/kkwpjwejeA4wEcBeBcIcRqj23+N4CzS3zda5uFrgFwKIB1ACIA3uW47S4p5Xrzzxc9v2ua6+bMcS2l/DfrmAZwBYA7pZRD5b99moPmzDEN4EoAm6SURwJ4O4Dven/bNMcdiMf1R6WUR5nH73YAHzC/vh3APwH4VblveAbNptf6CQAXAvh7hX2uat9o3plLx/QdAI4yz/UuAfDTCs9Dc9NcOqYBXpeTYc4c17wuJyIiIiKiZmDBxCwhpdwjpXzY/Pc4gKcBLAbwGgBXm3e7GsAF5n32SSkfBJApeKrDANwvpZyUUmYB3AnjYrTUNv8O40K4UMltlnj8rdIE4AEAS/x8rzR/zOHj+k0Ari31eJrb5tgxvRbAX8z7PANghRCir8y3T3PUAXpcjwGAEELAKASS5te3SikfA6BX+LZnxGx6raWUT0spn/Wx29XuG80jc+yYTpiflQAQg/m+QvPLXDqmiSxz+LjmdTkRERERETUECyZmISHECgAbANwPoE9Kuce8aS+ASpNZTwB4mRCiSwgRBXAOgKVV7kJV2xRGvPvbANzm+PJJwojK/oMQ4vAqt09z0Bw5rmFu/2wA11e5fZpj5sAx/SjMAU4hxPEAloOFb/PegXRcCyF+bt7nUADfr3I7M24WvNZ+VbtvNE/NhWNaCPFaIcQzAP4PRsoEzWNz4ZgGr8upwBw5rnldTkREREREDaXN9A6QmzB6cF8P4CNSyjFj4aRBSimFEGVXOkkpnxZC/CuAPwKYALAJQK7W/fGzTQA/AvB3KeVd5v8fBrBcSpkQQpwD4CYAB9e6D3TgmyPHteU8AHdLxn7Oa3PkmP46gO8KITYBeBzAI/XsAx34DrTjWkr5TiGECqNY4o0Afl7rtqbbbHut/fL5XkPz0Fw5pqWUNwK4UQhxCoAvAXhFs/eBZqc5ckzzupxc5shxbeF1ORERERERNQwTJmYRc/Xv9QCukVLeYH65Xwix0Lx9IYB9lZ5HSnmVlPIYKeUpAIYBPCeEWCqE2GT+eV+Fpyi5TSHE7ebj7X6+QojPA+gB8DHH9seklAnz37cCCAghun29CDTnzJXj2uFiMPZzXpsrx7T5Xv1OafT/fbt5+wu+XgSacw7E49rcXg7ArwG8zv93O7Nm0WvttX8/Nx9/a637RvPLXDymzSj5lbyGmZ/myjHN63JymivHtQOvy4mIiIiIqGGYMDFLCKO0/yoAT0spv+246WYA74CxEvgdAH7n47l6pZT7hBDLYMStnyilHAGw3ufulNymlPKsgu28C8BZAM6QUuqOry8A0G+uAjgeRmHOoM9t0xwyl45r87Y2AKcCeKvPbdIcM5eOaSFEO4BJKWUawLtgpE+M+dw2zSEH2nFt7u8qKeVm89/nA3jG5/PPqFn2WpckpXxnwZeq3jeaP+bSMS2EWA1gi3kNczSAEHgNM+/MsWOa1+UEYG4d1+Y+8LqciIiIiIgaSkjJVN3ZQAhxMoC7YMSiWxNaV8LoK3kdgGUAtgG4SEo5ZA5+bATQat4/AWCtGat4F4AuABkAH5NS3uGxzWsBnAagG0A/gM9LKa8SQnSV2maJx2fN28fNL90gpfyiEOIDAC4DkAUwZe7DPTW/OHTAmkvHtXnbPwE4W0p5cc0vCh3Q5tIxLYQ4CcDVACSAJwFcKqUcrvnFoQPWgXZcCyEUc39bAQgAjwK4zNz+cQBuBNABIAlgr5Ry1vRsn2Wv9WthtDPpATACYFNhwZX5+JI/k3L7VsdLRAeYOXZMfwpG4lIGxjXM5VLKf9Tz+tCBZ44d07wuJwBz67g2b/sn8LqciIiIiIgaiAUTRERERERERERERERERERENO8oM70DRERERERERERERERERERERNPt/7drt7hZRWEURvfbFILqCBhA+QlJmyLRDIABFcUE0HgUo0CgGhBtBUGgUCQUV/XWVH25H+qGk9yzltxqD+ARTAAAAAAAAAAA0xFMAAAAAAAAAADTEUwAAAAAAAAAANMRTAAAAAAAAAAA0xFMAAAAAAAAAADTEUwAAMDKquqoqt5W1ZPRXwAAAAAAWCaYAACA9Z0lOU/yYPQRAAAAAACWCSYAAGB9J0luk1yNPgIAAAAAwLLq7tEfAABgM6rqOsnxzvypu9+M+AMAAAAAwDLBBAAArKiqXib5mOQyybv7+Vd3/xz3CgAAAACAXYejDwAAwMZ8S/I4yfvu/jL6DAAAAAAAyw5GHwAAgI15luRhkovRRwAAAAAA2E8wAQAA6zpN0km+jj4CAAAAAMB+ggkAAFjXSZIf3f139BEAAAAAAPYTTAAAwLqeJrkafQIAAAAAgH87HH0AAAA25k+S06p6neQmyffu/j34EwAAAAAAO6q7R38AAIDNqKrnST4keZHkUZJX3f157CsAAAAAAHYJJgAAAAAAAACA6RyMPgAAAAAAAAAA8L8JJgAAAAAAAACA6QgmAAAAAAAAAIDpCCYAAAAAAAAAgOkIJgAAAAAAAACA6QgmAAAAAAAAAIDpCCYAAAAAAAAAgOkIJgAAAAAAAACA6dwBTDub5J3QwjkAAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "hrn = hr.resample('30min').mean()\n", - "plt.figure(figsize = (25, 15))\n", - "plt.plot(hrn.index, hrn.Value, label='Heart Rate')\n", - "plt.plot(hrn.index, hrn.Activity, label='Activity')\n", - "for i in range(0,len(missing)-1):\n", - " plt.axvspan(missing[i], missing[i+1], facecolor='b', alpha=0.5)\n", - "plt.xlabel('$t$')\n", - "plt.legend(bbox_to_anchor=(1.5, 1), loc='upper right', ncol=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Cosinor analysis" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "def hillfx(t, actmin, amp, phi, m, g):\n", - " # takes 3 x: min, amp, m\n", - " c = abs(np.cos((t - phi) * (2*np.pi/24)))\n", - " return actmin + amp*(((c+1)**g )/( m**g + (c+1)**g ))\n", - "\n", - "\n", - "def antilogfx(t, actmin, amp, alpha, beta, phi):\n", - " # takes 5 x: min, amp, alpha, beta, phi\n", - " c = np.cos((t - phi) * (2*np.pi/24))\n", - " return actmin + amp*((np.exp(beta * (c - alpha)))/(1 + np.exp(beta * (c - alpha))))\n", - "\n", - "\n", - "def arctanfx(t, actmin, amp, alpha, beta, phi):\n", - " # takes 5 x: min, amp, alpha, beta, phi\n", - " c = np.cos((t - phi) * (2*np.pi/24))\n", - " return actmin + amp*(np.arctan(beta * (c - alpha))/(np.pi + (1/2)))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "from scipy.optimize import curve_fit\n", - "from scipy.optimize import Bounds" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch Hill cosinor model parameter estimates:\n", - " min: 2.33\n", - " amp: 0.59\n", - " phi: -15.19\n", - " m: 1.63\n", - " g: 23.81\n", - "\n", - "Fitbit Hill cosinor model parameter estimates:\n", - " min: 0.90\n", - " amp: 0.75\n", - " phi: 2.60\n", - " m: 1.67\n", - " g: -26.84\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:4: RuntimeWarning: invalid value encountered in double_scalars\n", - " after removing the cwd from sys.path.\n" - ] - } - ], - "source": [ - "hill_act, hill_act_cov = curve_fit(hillfx, xdata = x_act, ydata = y_act)\n", - "hill_fit, hill_fit_cov = curve_fit(hillfx, xdata = x_fit, ydata = y_fit)\n", - "\n", - "print('Actiwatch Hill cosinor model parameter estimates:\\n min: %.2f\\n amp: %.2f\\n phi: %.2f\\n m: %.2f\\n g: %.2f\\n' % \n", - " (hill_act[0], hill_act[1], hill_act[2], hill_act[3], hill_act[4]))\n", - "\n", - "print('Fitbit Hill cosinor model parameter estimates:\\n min: %.2f\\n amp: %.2f\\n phi: %.2f\\n m: %.2f\\n g: %.2f\\n' % \n", - " (hill_fit[0], hill_fit[1], hill_fit[2], hill_fit[3], hill_fit[4]))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "bounds = ([0, 0, -np.inf, 0, 0], [2, 2, np.inf, np.inf, 24])" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": { - "scrolled": true - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch Antilogarithmic cosinor model parameter estimates:\n", - " min: 1.60\n", - " amp: 1.35\n", - " alpha: -0.77\n", - " beta 13.89\n", - " phi: 14.74\n", - "Fitbit Antilogarithmic cosinor model parameter estimates:\n", - " min: 0.05\n", - " amp: 1.67\n", - " alpha: -0.63\n", - " beta 14.48\n", - " phi: 14.41\n", - "Fitbit Interpolated Antilogarithmic cosinor model parameter estimates:\n", - " min: 0.05\n", - " amp: 1.68\n", - " alpha: -0.65\n", - " beta 16.10\n", - " phi: 14.52\n" - ] - } - ], - "source": [ - "antilog_act, antilog_act_cov = curve_fit(antilogfx, xdata = x_act, ydata = y_act, bounds = bounds)\n", - "antilog_fit, antilog_fit_cov = curve_fit(antilogfx, xdata = x_fit, ydata = y_fit, bounds = bounds)\n", - "antilog_fitInt, antilog_fitInt_cov = curve_fit(antilogfx, xdata = x_fitInt, ydata = y_fitInt, bounds = bounds)\n", - "\n", - "print('Actiwatch Antilogarithmic cosinor model parameter estimates:\\n min: %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (antilog_act[0], antilog_act[1], antilog_act[2], antilog_act[3], antilog_act[4]))\n", - "\n", - "print('Fitbit Antilogarithmic cosinor model parameter estimates:\\n min: %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (antilog_fit[0], antilog_fit[1], antilog_fit[2], antilog_fit[3], antilog_fit[4]))\n", - "\n", - "print('Fitbit Interpolated Antilogarithmic cosinor model parameter estimates:\\n min: %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (antilog_fitInt[0], antilog_fitInt[1], antilog_fitInt[2], antilog_fitInt[3], antilog_fitInt[4]))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[ 1.59784582, 1.34907229, -0.77169917, 13.89295938, 14.73995808]])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "antilog_act[None]" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
actminampalphabetaphi
01.5978461.349072-0.77169913.89295914.739958
\n", - "
" - ], - "text/plain": [ - " actmin amp alpha beta phi\n", - "0 1.597846 1.349072 -0.771699 13.892959 14.739958" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fitdf = pd.DataFrame(antilog_act[None], columns = [['actmin', 'amp', 'alpha', 'beta', 'phi']])\n", - "fitdf" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Actiwatch Arctangent cosinor model parameter estimates: min:\n", - " 2.00\n", - " amp: 2.00\n", - " alpha: -0.87\n", - " beta 10.67\n", - " phi: 14.62\n", - "Fitbit Arctangent cosinor model parameter estimates:\n", - " min:\n", - " 0.89\n", - " amp: 1.99\n", - " alpha: -0.62\n", - " beta 22.27\n", - " phi: 14.40\n", - "Fitbit Interpolated Arctangent cosinor model parameter estimates:\n", - " min:\n", - " 0.89\n", - " amp: 2.00\n", - " alpha: -0.64\n", - " beta 19.70\n", - " phi: 14.53\n" - ] - } - ], - "source": [ - "arctan_act, arctan_act_cov = curve_fit(arctanfx, xdata = x_act, ydata = y_act, bounds = bounds)\n", - "arctan_fit, arctan_fit_cov = curve_fit(arctanfx, xdata = x_fit, ydata = y_fit, bounds = bounds)\n", - "arctan_fitInt, arctan_fitInt_cov = curve_fit(arctanfx, xdata = x_fitInt, ydata = y_fitInt, bounds = bounds)\n", - "\n", - "print('Actiwatch Arctangent cosinor model parameter estimates: min:\\n %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (arctan_act[0], arctan_act[1], arctan_act[2], arctan_act[3], arctan_act[4]))\n", - "\n", - "print('Fitbit Arctangent cosinor model parameter estimates:\\n min:\\n %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (arctan_fit[0], arctan_fit[1], arctan_fit[2], arctan_fit[3], arctan_fit[4]))\n", - "\n", - "print('Fitbit Interpolated Arctangent cosinor model parameter estimates:\\n min:\\n %.2f\\n amp: %.2f\\n alpha: %.2f\\n beta %.2f\\n phi: %.2f' % \n", - " (arctan_fitInt[0], arctan_fitInt[1], arctan_fitInt[2], arctan_fitInt[3], arctan_fitInt[4]))\n" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Compute predictions with found parameters:" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "y_act_hill = hillfx(x_act, *hill_act)\n", - "y_fit_hill = hillfx(x_fit, *hill_fit)\n", - "\n", - "y_act_antilog = antilogfx(x_act, *antilog_act)\n", - "y_fit_antilog = antilogfx(x_fit, *antilog_fit)\n", - "y_fitInt_antilog = antilogfx(x_fitInt, *antilog_fit)\n", - "\n", - "y_act_arctan = arctanfx(x_act, *arctan_act)\n", - "y_fit_arctan = arctanfx(x_fit, *arctan_fit)\n", - "y_fitInt_arctan = arctanfx(x_fitInt, *arctan_fit)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x_act, y_act, label='Actiwatch Raw')\n", - "plt.plot(x_fit, y_fit, label='Fitbit Raw')\n", - "plt.plot(x_act, y_act_hill, label='Hill Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fit_hill, label='Hill Transform', linewidth = 3)\n", - "plt.xlabel('$t$')\n", - "plt.ylabel('LMAXACT')\n", - "plt.legend(bbox_to_anchor=(1.6, 1), loc='upper right', ncol=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x_act, y_act, label='Actiwatch Raw')\n", - "plt.plot(x_fit, y_fit, label='Fitbit Raw')\n", - "plt.plot(x_fitInt, y_fitInt, label='Fitbit Interpolated')\n", - "plt.plot(x_act, y_act_antilog, label='Anti-logistic Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fit_antilog, label='Anti-logistic Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fitInt_antilog, label='Anti-logistic Transform', linewidth = 3)\n", - "\n", - "plt.xlabel('$t$')\n", - "plt.ylabel('LMAXACT')\n", - "plt.legend(bbox_to_anchor=(1.8, 1), loc='upper right', ncol=1)" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x_act, y_act, label='Actiwatch Raw')\n", - "plt.plot(x_fit, y_fit, label='Fitbit Raw')\n", - "plt.plot(x_fit, y_fitInt, label='Fitbit Interpolated')\n", - "plt.plot(x_act, y_act_arctan, label='Arctangent Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fit_arctan, label='Arctangent Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fitInt_arctan, label='Arctangent Transform', linewidth = 3)\n", - "plt.xlabel('$t$')\n", - "plt.ylabel('LMAXACT')\n", - "plt.legend(bbox_to_anchor=(1.8, 1), loc='upper right', ncol=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "-----------------" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## How do these metrics compare to Stephanie's?" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
actminactampactalphactbetaactphi
00.2096351.767917-0.5072289.92874914.542104
\n", - "
" - ], - "text/plain": [ - " actmin actamp actalph actbeta actphi\n", - "0 0.209635 1.767917 -0.507228 9.928749 14.542104" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cr = pd.read_csv('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/circadian_measures/7_days/cosinor_7days_act.csv')\n", - "cr[cr['record_id'] == 10011][['actmin', 'actamp', 'actalph', 'actbeta', 'actphi']]" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
actminactampactalphactbetaactphi
00.01.00.91331.22975211.728705
\n", - "
" - ], - "text/plain": [ - " actmin actamp actalph actbeta actphi\n", - "0 0.0 1.0 0.9133 1.229752 11.728705" - ] - }, - "execution_count": 25, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cr = pd.read_csv('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/circadian_measures/7_days/cosinor_7days_fit.csv')\n", - "cr[cr['record_id'] == 10011][['actmin', 'actamp', 'actalph', 'actbeta', 'actphi']]" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "y_act_ss = antilogfx(x_act, 0.209635, 1.767917, -0.507228, 9.928749, 14.542104)\n", - "y_fit_ss = antilogfx(x_fit, 0.0, 1.0, 0.9133, 1.229752, 11.728705)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(x_act, y_act, label='Actiwatch Raw')\n", - "plt.plot(x_fit, y_fit, label='Fitbit Raw')\n", - "plt.plot(x_fitInt, y_fitInt, label='Fitbit Interpolated')\n", - "plt.plot(x_act, y_act_ss, label='SS Act', linewidth = 3)\n", - "plt.plot(x_fit, y_fit_ss, label='SS Fit', linewidth = 3)\n", - "plt.xlabel('$t$')\n", - "plt.ylabel('LMAXACT')\n", - "plt.legend(bbox_to_anchor=(1.8, 1), loc='upper right', ncol=1)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "anaconda-cloud": {}, - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 1 -} diff --git a/docs/preprocessing.ipynb b/docs/preprocessing.ipynb deleted file mode 100644 index 83fc5e8..0000000 --- a/docs/preprocessing.ipynb +++ /dev/null @@ -1,134 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Preprocessing" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import os\n", - "from datetime import date\n", - "import pandas as pd\n", - "import datetime as dt\n", - "import logging\n", - "from pathlib import Path\n", - "\n", - "%matplotlib inline\n", - "import matplotlib.pyplot as plt\n" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "today = date.today()\n", - "\n", - "home_dir = str(Path.home())\n", - "work_dir = os.path.join(home_dir, 'Box/CogNeuroLab/Aging Decision Making R01/data/actigraphy')\n", - "in_dir= os.path.join(work_dir, 'raw')\n", - "out_dir = os.path.join(work_dir, 'processed_2020-06-17')\n", - "\n", - "# if os.path.isdir(out_dir):\n", - "# print(\"ouput directory exists\")\n", - "# else:\n", - "# os.mkdir(out_dir)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [ - "recording_period_min = 7 # days\n", - "interpolate_limit = 10 # SR = 1/30s, so 5 minute limit\n", - "\n", - "from Wearables import preproc\n", - "for in_file in sorted(os.listdir(in_dir)):\n", - " if in_file.endswith('.csv'):\n", - " preproc(in_file, out_dir, recording_period_min, interpolate_limit)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import glob\n", - "\n", - "procfile = glob.glob(out_dir + '/*.csv')[0]\n", - "\n", - "proc = pd.read_csv(procfile, header = None, names = ['Time', 'Activity'])\n", - "proc['Time'] = pd.to_datetime(proc['Time'])\n", - "proc = proc.set_index('Time')\n", - "proc = proc.resample('30T').mean()\n", - "\n", - "plt.plot(proc.index, proc['Activity'], label='Preprocessed')\n", - "plt.xlabel('Time')\n", - "plt.ylabel('Activity')\n", - "plt.legend()" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/fitcosinor.py b/fitcosinor.py deleted file mode 100644 index 47e6ffa..0000000 --- a/fitcosinor.py +++ /dev/null @@ -1,61 +0,0 @@ -def fitcosinor(data=data, transform='antilogistic'): - # performs cosinor analysis based on sinusoidally transformed cosine methods outlined in Marler (2006) - import numpy as np - import pandas as pd - import datetime as dt - - %matplotlib inline - import matplotlib.pyplot as plt - - from scipy.optimize import curve_fit - from scipy.optimize import Bounds - - transforms = ['hill', 'antilogistic', 'arctangent'] - if transform not in transforms: - raise ValueError("Invalid transform type. Expected one of: %s" % transforms) - - def format_actig_file(data): - # actigraphy input file is a file with two columns, Time ("%Y-%m-%d %H:%M:%S") and Activity, with no header - - data['time'] = data.values[:,0].astype(str) - data['clocktime'] = [int(dt.datetime.strptime(x, "%Y-%m-%d %H:%M:%S").time().strftime("%H")) + (int(dt.datetime.strptime(x, "%Y-%m-%d %H:%M:%S").time().strftime("%M"))/60) for x in data['time']] - data = data.groupby('clocktime').max() - data['lmaxact'] = np.log10(data['activity'] + 1) - return data - - def hillfx(t, actmin, amp, phi, m, g): - # takes 3 x: min, amp, m - bounds = ([0, 0, 0, -np.inf, -np.inf],[2, 2, 24, np.inf, np.inf]) - c = abs(np.cos((t - phi) * (2*np.pi/24))) - return actmin + amp*(((c+1)**g )/( m**g + (c+1)**g )) - - def antilogfx(t, actmin, amp, alpha, beta, phi): - # takes 5 x: min, amp, alpha, beta, phi - bounds = ([0, 0, -np.inf, 0, 0], [2, 2, np.inf, np.inf, 24]) - c = np.cos((t - phi) * (2*np.pi/24)) - return actmin + amp*((np.exp(beta * (c - alpha)))/(1 + np.exp(beta * (c - alpha)))) - - def arctanfx(t, actmin, amp, alpha, beta, phi): - # takes 5 x: min, amp, alpha, beta, phi - bounds = ([0, 0, -np.inf, 0, 0], [2, 2, np.inf, np.inf, 24]) - c = np.cos((t - phi) * (2*np.pi/24)) - return actmin + amp*(np.arctan(beta * (c - alpha))/(np.pi + (1/2))) - - if transform == 'hill': - - params, fxcov = curve_fit(hillfx, xdata = x_data.index.values, ydata = data['lmaxact'].values) - - elif transform == 'antilogistic': - - params, fxcov = curve_fit(antilogfx, xdata = x_data.index.values, ydata = data['lmaxact'].values) - - elif transform == 'arctangent': - - params, fxcov = curve_fit(arctanfx, xdata = x_data.index.values, ydata = data['lmaxact'].values) - - else: - print('invalid transform type; exiting') - - paramsdf = pd.DataFrame(params[None], columns = [['actmin', 'amp', 'alpha', 'beta', 'phi']]) - - return paramsdf diff --git a/hr_interpolate.R b/hr_interpolate.R deleted file mode 100644 index 93a3edd..0000000 --- a/hr_interpolate.R +++ /dev/null @@ -1,320 +0,0 @@ -# Find watch off times from heart rate data and interpolate missing steps counts -# Question: How does the way we handle missing actigraphy data affect rest-activity rhythm measures? - -## TO DO: -# 1. decide how to interpolate steps data best (mean, or other function) -# 2. write a loop to perform this for all subjects - -library(lubridate) -library(ggplot2) -library(zoo) - -data_dir <- "~/Box/CogNeuroLab/Wearables/data/fitbit" - -# list all heart rate data files and select the first as an example -hr_files <- list.files("~/Box/CogNeuroLab/Wearables/data/fitbit/", pattern = "heartrate_1min", full.names = TRUE) -hr <- read.csv(hr_files[1]) - -# find fitbit data start and end times and create a sequence in 1 minute intervals -df <- c() -df$Time <- seq(mdy_hms(head(hr[,1], 1)), mdy_hms(tail(hr[,1], 1)), by = "1 min") -hr$Time <- mdy_hms(hr$Time) - -# merge sequence with actual fitbit data to identify nans in hr data and associated timestamps -df2 <- merge(df, hr, by = "Time", all = T) -watch_off <- df2$Time[is.na(df2$Value)] - -# calculate total time watch was off in minutes -total_time_watch_off <- sum(is.na(df2$Value)) - -# load in subject's activity data file -act_files <- list.files("~/Box/CogNeuroLab/Wearables/data/fitbit/", pattern = "minuteStepsNarrow", full.names = TRUE) -act_fit <- read.csv(act_files[1]) -head(act_fit) -act_fit$ActivityMinute <- mdy_hms(act_fit$ActivityMinute) - -# merge heart rate data and steps data -df3 <- merge(df2, act_fit, by.x = "Time", by.y = "ActivityMinute") -head(df3) -sum(is.na(df3$Value)) - -# step counts at times when watch was off should all be 0 -df3$Steps[is.na(df3$Value)] - -# set NA values for steps where HR is NA -df3$Steps <- ifelse(is.na(df3$Value), NA, df3$Steps) - -# now we want to interpolate step counts at minutes when watch was off -plot_interpolation <- function(df, starttime, endtime, method = "linear", f = NA, maxgap = "none"){ - - df3$`Steps Interpolated` <- na.approx(df$Steps, maxgap = maxgap, method = method, f = f) - - df3 %>% - filter(Time > starttime) %>% - filter(Time < endtime) %>% - pivot_longer(cols = c(Steps, `Steps Interpolated`), names_to = "Key") %>% - ggplot() + - geom_line(aes(x = Time, y = value, color = Key), size = 2) + - facet_wrap(. ~ Key) + theme_classic() + theme(legend.position = "none") + - ylab("Steps") -} - -# let's try out different interpolation methods -df = df3 -starttime = ymd_hms("2019-10-25 18:00:00") -endtime = ymd_hms("2019-10-25 19:00:00") - -# constant, replacing NAs with median value -method = "constant" -f = 0.5 -plot_interpolation(df, starttime, endtime, method, f) - -# constant, replacing NAs with upper value -method = "constant" -f = 1 -plot_interpolation(df, starttime, endtime, method, f) - -# linear interpolation -method = "linear" -f = NA -plot_interpolation(df, starttime, endtime, method, f) - -# linear interpolation with a maximum number of interpolated values -# If exceeds maximum gap, data left unchanged. -method = "linear" -f = NA -maxgap = 30 #minutes -plot_interpolation(df, starttime, endtime, method, f, maxgap) - -maxgap = 60 #minutes -plot_interpolation(df, starttime, endtime, method, f, maxgap) - -# interpolate method #2: find average steps at time when watch was off from other days -library(imputeTS) -plot(df$Steps, type = "l", xlab = "Time", ylab = "Steps", main = "Raw") - -# summary of missing periods for which the watch was off -statsNA(df$Steps) - -# mean interpolation -plot(na_mean(df$Steps, option = "mean"), - type = "l", xlab = "Time", ylab = "Steps", xlim = c(1500,1700), - main = "Mean") - -# last observation carried forward -plot(na_locf(df$Steps, option = "locf"), - type = "l", xlab = "Time", ylab = "Steps", xlim = c(1500,1700), - main = "LOCF") - -# next observation carried backward -plot(na_locf(df$Steps, option = "nocb"), - type = "l", xlab = "Time", ylab = "Steps", xlim = c(1500,1700), - main = "NOCB") - -# linear interpolation -plot(na.interpolation(df$Steps, option = "linear"), - type = "l", xlab = "Time", ylab = "Steps", xlim = c(1500,1700), - main = "Linear") - -# spline interpolation -plot(na.interpolation(df$Steps, option = "spline"), - type = "l", xlab = "Time", ylab = "Steps", xlim = c(1500,1700), - main = "Spline") - - -# method #2 -library(dplyr) -library(reshape2) - -# create new clocktime variable -df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 -df$StepsInt <- df$Steps - -# find missing data chunks -find_missing <- function(df){ - x <- df %>% - dplyr::mutate(missing = ifelse(is.na(StepsInt), 1, 0)) %>% - dplyr::group_by(group = cumsum(c(0, diff(missing) != 0))) %>% - filter(missing == 1 & n() > 1) %>% - summarize("start_missing"=min(as.character(Time)), - "end_missing"=max(as.character(Time)), - "length_missing"=n()) %>% - ungroup() %>% - select(-matches("group")) - - # create new cloktime variable - x$startclock=lubridate::hour(x$start_missing) + lubridate::minute(x$start_missing)/60 - x$endclock=lubridate::hour(x$end_missing) + lubridate::minute(x$end_missing)/60 - x <- x[order(x$length_missing),] - return(x) -} - -# this shows us the data during the missing period of interest -x <- find_missing(df$StepsInt) - -# view missing data period -df %>% - filter(Time >= ymd_hms(x$start_missing[1])) %>% - filter(Time <= ymd_hms(x$end_missing[1])) - -# now we want to loop through each missing period, interpolate, update what periods are missing, -# and interpolate some more, using the average value from the same time period on other days -# of recording - - - -# note to self: check export that we have both stepsnarrow and hr minute - -interpolate_steps <- function(df){ - # where df is a dataframe containing Steps by minute from fitbit - df$clocktime=lubridate::hour(df$Time) + lubridate::minute(df$Time)/60 - - # create new dataframe - df$StepsInt <- df$Steps - x <- find_missing(df) - - while (dim(x)[1] > 0) { - # convert start and end times to clocktimes - startclock=lubridate::hour(x$start_missing[1]) + lubridate::minute(x$start_missing[1])/60 - endclock=lubridate::hour(x$end_missing[1]) + lubridate::minute(x$end_missing[1])/60 - - # get index values for missing period - replaceindex <- which((df$Time >= ymd_hms(x$start_missing[1])) & (df$Time <= ymd_hms(x$end_missing[1]))) - - # now we want to see the steps data during the time period of interest on all other days - mean_steps <- df %>% - filter(clocktime >= startclock) %>% - filter(clocktime <= endclock) %>% - summarise(mean_steps = mean(Steps, na.rm = T)) %>% - unlist() - - # replace values with the mean steps value from all other time periods - df$StepsInt[replaceindex] <- mean_steps - - # checking that we replaced them all - missing <- df %>% - filter(Time > ymd_hms(x$start_missing[1])) %>% - filter(Time < ymd_hms(x$end_missing[1])) %>% - summarise(missing = sum(is.na(StepsInt))) %>% - unlist() - - if (missing > 0){ - print("error - detected missing values!") - } else { - print(paste0("all missing values replaced, ", sum(is.na(df$StepsInt)), " remaining")) - } - - # make a plot to check that NA periods of interest are being interpolated - - x <- data.frame(x, seq_along(start)) - p <- df %>% - filter(Time > ymd_hms(x$start_missing[1]) - as.difftime(5, unit="mins")) %>% - filter(Time < ymd_hms(x$end_missing[1]) + as.difftime(5, unit="mins")) %>% - select(Time, Steps, StepsInt) %>% - melt(id.vars = c("Time")) %>% - ggplot() + - geom_rect(data=x, inherit.aes=FALSE, aes(xmin=ymd_hms(start_missing[1]), xmax=ymd_hms(end_missing[1]), ymin=-Inf, - ymax=Inf), fill="yellow", alpha=0.02) + - geom_line(aes(x = Time, y = value, group = variable, color = variable)) + - facet_wrap(. ~ variable, nrow = 2) + - scale_color_brewer(palette = "Set1") + - theme_classic() + - xlab("Time") + ylab("Steps") + - ylim(-0.1, max(df$Steps, na.rm = T)) - - # to do: figure out how to get these plots to print while in a while loop! - print(p) - - # check for missing periods and update on each round of interpolation - x <- find_missing(df) - print(dim(x)[1]) - } - - return(df) -} - - -##### START HERE -#dir.create(paste0(data_dir, "interpolated/")) -out_dir <- paste0(data_dir, "/interpolated") - -# write the for loop! -i = list.files(data_dir, pattern = "minuteStepsNarrow", full.names = T)[1] -act_files <- list.files(data_dir, pattern = "minuteStepsNarrow", full.names = T) -hr_files <- list.files(data_dir, pattern = "heartrate_1min", full.names = T) -# for every subject that we have fitbit data for -for (i in act_files){ - hr <- c() - df <- c() - df2 <- c() - df3 <- c() - dfInt <- - - # get subject number - - fname = strsplit(i, "/")[[1]][9] - subject = substring(fname, 1, 8) - - # use hr data to id missing periods - # TO DO!!!! - hr_fname <- # match, %in% ## string match ## <- hr_files[!!index!!] - hr <- read.csv(hr_fname) - - # find fitbit data start and end times and create a sequence in 1 minute intervals - df <- c() - df$Time <- seq(mdy_hms(head(hr[,1], 1)), mdy_hms(tail(hr[,1], 1)), by = "1 min") - hr$Time <- mdy_hms(hr$Time) - - # merge sequence with actual fitbit data to identify nans in hr data and associated timestamps - df2 <- merge(df, hr, by = "Time", all = T) - #watch_off <- df2$Time[is.na(df2$Value)] - - # TO DO - add this in - # calculate total time watch was off in minutes - # total_time_watch_off <- sum(is.na(df2$Value)) - - # load in subject's activity data file - # read in their fitbit data, df - df <- read.csv(i) - df$ActivityMinute <- mdy_hms(df$ActivityMinute) - - # merge heart rate data and steps data - df3 <- merge(df2, df, by.x = "Time", by.y = "ActivityMinute") - - # set NA values for steps where HR is NA - df3$Steps <- ifelse(is.na(df3$Value), NA, df3$Steps) - - # check that there are NA values in steps variable now - #sum(is.na(df3$Steps)) - - # create df$StepsInt - # TO DO: comment out the plot step from interpolate_steps function - dfInt <- interpolate_steps(df3) - - # just keep Time and StepsInt from df3 - dfInt <- dfInt %>% - select(Time, StepsInt) - - # rename variables or remove headers completely to be compatible with cr packages - - # save it out as a new file without overwriting the og - # TO DO: make our actigraphy data readable by TWO packages without duplicating data files - eg header vs no header - write.table(dfInt, paste0(out_dir, "/", subject, "_interpolated_mean.csv"), sep = " ", row.names = F, col.names = F) - -} - - - -# graph -df %>% - mutate(Date = lubridate::date(Time)) %>% - mutate(Hour = strftime(Time, format="%H:%M:%S")) %>% # change this from hour to hour minute format - select(Hour, Date, Time, Steps, StepsInt) %>% - melt(id.vars = c("Time", "Hour", "Date")) %>% - ggplot() + - geom_line(aes(x = Time, y = value, color = variable), na.rm = F) + - facet_wrap(. ~ variable, nrow = 2, scales = "free") + - scale_color_brewer(palette = "Set1") + - theme_classic() + - xlab("Time") + ylab("Steps") + - ggsave("~/Box/CogNeuroLab/Wearables/results/figures/interpolated_ts_fitbit.png", dpi = 300, width = 15, height = 10, units = "in") diff --git a/notebooks/Sleep Diary Analysis.ipynb b/notebooks/Sleep Diary Analysis.ipynb index 21a4fc4..63ddba9 100644 --- a/notebooks/Sleep Diary Analysis.ipynb +++ b/notebooks/Sleep Diary Analysis.ipynb @@ -9,7 +9,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 1, "metadata": {}, "outputs": [ { @@ -395,7 +395,7 @@ "[303 rows x 104 columns]" ] }, - "execution_count": 32, + "execution_count": 1, "metadata": {}, "output_type": "execute_result" } @@ -417,7 +417,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 2, "metadata": {}, "outputs": [ { @@ -452,10 +452,15 @@ " 'Watching TV, movies',\n", " 'Working',\n", " 'None of the above',\n", + " 'Sadness',\n", + " 'Happiness',\n", + " 'Stress',\n", + " 'Rumination',\n", + " 'Alcohol',\n", " 'COVID']" ] }, - "execution_count": 33, + "execution_count": 2, "metadata": {}, "output_type": "execute_result" } @@ -465,13 +470,13 @@ "cols = cols[cols.str.contains('Which of the following did you do yesterday?')].tolist()\n", "cols = [i.split('choice=', 1)[1] for i in cols]\n", "cols = [i.split(')', 1)[0] for i in cols]\n", - "cols = ['record_id', 'age_group'] + cols + ['COVID']\n", + "cols = ['record_id', 'age_group'] + cols + ['Sadness','Happiness','Stress','Rumination','Alcohol', 'COVID']\n", "cols" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 3, "metadata": {}, "outputs": [ { @@ -506,15 +511,15 @@ " Doing nothing (sitting around, daydreaming\n", " Drinking, eating\n", " ...\n", - " Talking, socializing in person\n", - " Texting, talking on the phone\n", - " Thinking, reflecting\n", - " Using social media\n", - " Using a computer\n", " Walking, running\n", " Watching TV, movies\n", " Working\n", " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " COVID\n", " \n", " \n", @@ -523,14 +528,14 @@ " 2\n", " 11\n", " Younger Adults\n", - " 0.0\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", - " 0.0\n", + " NaN\n", + " 2.0\n", + " 87.0\n", + " 6.0\n", " 0.0\n", " 0.0\n", " 1.0\n", + " 1.0\n", " ...\n", " 1.0\n", " 1.0\n", @@ -547,12 +552,12 @@ " 3\n", " 11\n", " Younger Adults\n", + " NaN\n", + " 0.0\n", + " 89.0\n", + " 0.0\n", " 0.0\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", " 0.0\n", - " 1.0\n", " 1.0\n", " 1.0\n", " ...\n", @@ -571,14 +576,14 @@ " 4\n", " 11\n", " Younger Adults\n", + " NaN\n", " 0.0\n", - " 1.0\n", - " 1.0\n", - " 1.0\n", + " 93.0\n", " 0.0\n", " 0.0\n", " 0.0\n", " 1.0\n", + " 1.0\n", " ...\n", " 1.0\n", " 1.0\n", @@ -595,11 +600,11 @@ " 5\n", " 11\n", " Younger Adults\n", + " NaN\n", " 0.0\n", + " 98.0\n", " 0.0\n", - " 1.0\n", - " 1.0\n", - " 0.0\n", + " 2.0\n", " 0.0\n", " 0.0\n", " 1.0\n", @@ -619,12 +624,12 @@ " 6\n", " 11\n", " Younger Adults\n", + " NaN\n", " 0.0\n", - " 0.0\n", - " 1.0\n", + " 92.0\n", " 1.0\n", " 0.0\n", - " 1.0\n", + " 0.0\n", " 0.0\n", " 1.0\n", " ...\n", @@ -667,13 +672,13 @@ " 462\n", " 127\n", " Older Adults\n", - " 0.0\n", - " 1.0\n", " 1.0\n", - " 0.0\n", + " 36.0\n", + " 50.0\n", + " 22.0\n", + " 25.0\n", " 0.0\n", " 1.0\n", - " 0.0\n", " 1.0\n", " ...\n", " 0.0\n", @@ -691,13 +696,13 @@ " 466\n", " 129\n", " Older Adults\n", - " 0.0\n", - " 1.0\n", " 1.0\n", - " 0.0\n", + " 43.0\n", + " 28.0\n", + " 18.0\n", + " 20.0\n", " 0.0\n", " 1.0\n", - " 0.0\n", " 1.0\n", " ...\n", " 0.0\n", @@ -715,13 +720,13 @@ " 467\n", " 129\n", " Older Adults\n", - " 0.0\n", - " 1.0\n", " 1.0\n", - " 0.0\n", + " 43.0\n", + " 38.0\n", + " 27.0\n", + " 5.0\n", " 0.0\n", " 1.0\n", - " 0.0\n", " 1.0\n", " ...\n", " 0.0\n", @@ -739,13 +744,13 @@ " 468\n", " 129\n", " Older Adults\n", - " 0.0\n", - " 1.0\n", + " NaN\n", + " 27.0\n", + " 37.0\n", + " 7.0\n", " 1.0\n", " 0.0\n", - " 0.0\n", " 1.0\n", - " 0.0\n", " 1.0\n", " ...\n", " 0.0\n", @@ -763,13 +768,13 @@ " 469\n", " 129\n", " Older Adults\n", - " 0.0\n", - " 1.0\n", - " 1.0\n", + " NaN\n", + " 25.0\n", + " 39.0\n", + " 4.0\n", " 0.0\n", " 0.0\n", " 1.0\n", - " 0.0\n", " 1.0\n", " ...\n", " 0.0\n", @@ -785,131 +790,105 @@ " \n", " \n", "\n", - "

303 rows × 30 columns

\n", + "

303 rows × 35 columns

\n", "" ], "text/plain": [ " record_id age_group Attending classes, meetings \\\n", - "2 11 Younger Adults 0.0 \n", - "3 11 Younger Adults 0.0 \n", - "4 11 Younger Adults 0.0 \n", - "5 11 Younger Adults 0.0 \n", - "6 11 Younger Adults 0.0 \n", + "2 11 Younger Adults NaN \n", + "3 11 Younger Adults NaN \n", + "4 11 Younger Adults NaN \n", + "5 11 Younger Adults NaN \n", + "6 11 Younger Adults NaN \n", ".. ... ... ... \n", - "462 127 Older Adults 0.0 \n", - "466 129 Older Adults 0.0 \n", - "467 129 Older Adults 0.0 \n", - "468 129 Older Adults 0.0 \n", - "469 129 Older Adults 0.0 \n", + "462 127 Older Adults 1.0 \n", + "466 129 Older Adults 1.0 \n", + "467 129 Older Adults 1.0 \n", + "468 129 Older Adults NaN \n", + "469 129 Older Adults NaN \n", "\n", " Being physically animated, moving around Browsing the internet \\\n", - "2 1.0 1.0 \n", - "3 1.0 1.0 \n", - "4 1.0 1.0 \n", - "5 0.0 1.0 \n", - "6 0.0 1.0 \n", + "2 2.0 87.0 \n", + "3 0.0 89.0 \n", + "4 0.0 93.0 \n", + "5 0.0 98.0 \n", + "6 0.0 92.0 \n", ".. ... ... \n", - "462 1.0 1.0 \n", - "466 1.0 1.0 \n", - "467 1.0 1.0 \n", - "468 1.0 1.0 \n", - "469 1.0 1.0 \n", + "462 36.0 50.0 \n", + "466 43.0 28.0 \n", + "467 43.0 38.0 \n", + "468 27.0 37.0 \n", + "469 25.0 39.0 \n", "\n", " Commuting, traveling Doing a favor, helping others \\\n", - "2 1.0 0.0 \n", - "3 1.0 0.0 \n", - "4 1.0 0.0 \n", - "5 1.0 0.0 \n", + "2 6.0 0.0 \n", + "3 0.0 0.0 \n", + "4 0.0 0.0 \n", + "5 0.0 2.0 \n", "6 1.0 0.0 \n", ".. ... ... \n", - "462 0.0 0.0 \n", - "466 0.0 0.0 \n", - "467 0.0 0.0 \n", - "468 0.0 0.0 \n", - "469 0.0 0.0 \n", + "462 22.0 25.0 \n", + "466 18.0 20.0 \n", + "467 27.0 5.0 \n", + "468 7.0 1.0 \n", + "469 4.0 0.0 \n", "\n", " Doing household chores Doing nothing (sitting around, daydreaming \\\n", - "2 0.0 0.0 \n", - "3 1.0 1.0 \n", - "4 0.0 0.0 \n", + "2 0.0 1.0 \n", + "3 0.0 1.0 \n", + "4 0.0 1.0 \n", "5 0.0 0.0 \n", - "6 1.0 0.0 \n", + "6 0.0 0.0 \n", ".. ... ... \n", - "462 1.0 0.0 \n", - "466 1.0 0.0 \n", - "467 1.0 0.0 \n", - "468 1.0 0.0 \n", - "469 1.0 0.0 \n", + "462 0.0 1.0 \n", + "466 0.0 1.0 \n", + "467 0.0 1.0 \n", + "468 0.0 1.0 \n", + "469 0.0 1.0 \n", "\n", - " Drinking, eating ... Talking, socializing in person \\\n", - "2 1.0 ... 1.0 \n", - "3 1.0 ... 1.0 \n", - "4 1.0 ... 1.0 \n", - "5 1.0 ... 1.0 \n", - "6 1.0 ... 1.0 \n", - ".. ... ... ... \n", - "462 1.0 ... 0.0 \n", - "466 1.0 ... 0.0 \n", - "467 1.0 ... 0.0 \n", - "468 1.0 ... 0.0 \n", - "469 1.0 ... 0.0 \n", + " Drinking, eating ... Walking, running Watching TV, movies Working \\\n", + "2 1.0 ... 1.0 1.0 0.0 \n", + "3 1.0 ... 1.0 1.0 0.0 \n", + "4 1.0 ... 1.0 1.0 0.0 \n", + "5 1.0 ... 1.0 1.0 0.0 \n", + "6 1.0 ... 1.0 1.0 0.0 \n", + ".. ... ... ... ... ... \n", + "462 1.0 ... 0.0 1.0 0.0 \n", + "466 1.0 ... 0.0 1.0 1.0 \n", + "467 1.0 ... 0.0 1.0 0.0 \n", + "468 1.0 ... 0.0 1.0 0.0 \n", + "469 1.0 ... 0.0 1.0 0.0 \n", "\n", - " Texting, talking on the phone Thinking, reflecting Using social media \\\n", - "2 1.0 0.0 0.0 \n", - "3 1.0 0.0 0.0 \n", - "4 1.0 0.0 0.0 \n", - "5 1.0 0.0 0.0 \n", - "6 1.0 0.0 0.0 \n", - ".. ... ... ... \n", - "462 1.0 0.0 0.0 \n", - "466 1.0 1.0 1.0 \n", - "467 1.0 0.0 1.0 \n", - "468 1.0 0.0 1.0 \n", - "469 1.0 0.0 1.0 \n", + " None of the above Sadness Happiness Stress Rumination Alcohol COVID \n", + "2 0.0 0.0 1.0 0.0 1.0 0.0 Pre \n", + "3 0.0 1.0 1.0 1.0 1.0 0.0 Pre \n", + "4 0.0 1.0 1.0 1.0 1.0 0.0 Pre \n", + "5 0.0 1.0 1.0 0.0 1.0 0.0 Pre \n", + "6 0.0 1.0 1.0 1.0 1.0 0.0 Pre \n", + ".. ... ... ... ... ... ... ... \n", + "462 0.0 1.0 1.0 0.0 0.0 0.0 Post \n", + "466 1.0 1.0 1.0 1.0 0.0 0.0 Post \n", + "467 1.0 1.0 1.0 1.0 0.0 0.0 Post \n", + "468 1.0 1.0 1.0 1.0 0.0 0.0 Post \n", + "469 1.0 1.0 0.0 1.0 0.0 0.0 Post \n", "\n", - " Using a computer Walking, running Watching TV, movies Working \\\n", - "2 0.0 1.0 0.0 1.0 \n", - "3 1.0 1.0 1.0 1.0 \n", - "4 1.0 1.0 1.0 1.0 \n", - "5 1.0 1.0 0.0 1.0 \n", - "6 1.0 1.0 1.0 1.0 \n", - ".. ... ... ... ... \n", - "462 1.0 1.0 0.0 0.0 \n", - "466 1.0 1.0 1.0 0.0 \n", - "467 1.0 1.0 1.0 0.0 \n", - "468 1.0 1.0 1.0 0.0 \n", - "469 1.0 0.0 1.0 0.0 \n", - "\n", - " None of the above COVID \n", - "2 0.0 Pre \n", - "3 0.0 Pre \n", - "4 0.0 Pre \n", - "5 0.0 Pre \n", - "6 0.0 Pre \n", - ".. ... ... \n", - "462 0.0 Post \n", - "466 0.0 Post \n", - "467 0.0 Post \n", - "468 0.0 Post \n", - "469 0.0 Post \n", - "\n", - "[303 rows x 30 columns]" + "[303 rows x 35 columns]" ] }, - "execution_count": 34, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "d = d.filter(regex = 'record_id|age_group|COVID|activities*')\n", + "d = d.filter(regex = 'record_id|age_group|COVID|activities*|sad|happy|stress_a11e49|ruminate|alcoholic_drinks')\n", "d.columns = cols\n", "d" ] }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 4, "metadata": { "scrolled": false }, @@ -946,16 +925,16 @@ " Doing household chores\n", " Doing nothing (sitting around, daydreaming\n", " ...\n", - " Spiritual, religious activity\n", - " Talking, socializing in person\n", - " Texting, talking on the phone\n", - " Thinking, reflecting\n", - " Using social media\n", " Using a computer\n", " Walking, running\n", " Watching TV, movies\n", " Working\n", " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " \n", " \n", " \n", @@ -964,13 +943,13 @@ " 11\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 0.692308\n", + " 96.384615\n", + " 3.076923\n", + " 0.153846\n", " 0.000000\n", " 0.461538\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.307692\n", - " 0.153846\n", " ...\n", " 0.000000\n", " 1.000000\n", @@ -988,13 +967,13 @@ " 12\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 5.857143\n", + " 55.142857\n", + " 49.500000\n", + " 0.000000\n", " 0.642857\n", " 0.285714\n", - " 1.000000\n", - " 0.857143\n", - " 0.071429\n", - " 0.642857\n", - " 0.214286\n", " ...\n", " 0.142857\n", " 0.428571\n", @@ -1012,13 +991,13 @@ " 14\n", " Younger Adults\n", " Pre\n", + " 2.000000\n", + " 43.416667\n", + " 52.000000\n", + " 61.916667\n", + " 51.916667\n", " 0.000000\n", " 0.416667\n", - " 0.833333\n", - " 0.500000\n", - " 0.000000\n", - " 0.500000\n", - " 0.583333\n", " ...\n", " 0.000000\n", " 0.583333\n", @@ -1036,13 +1015,13 @@ " 16\n", " Younger Adults\n", " Pre\n", + " 5.714286\n", + " 37.785714\n", + " 53.857143\n", + " 43.214286\n", + " 4.571429\n", " 0.571429\n", " 0.071429\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", " ...\n", " 0.000000\n", " 0.857143\n", @@ -1060,13 +1039,13 @@ " 23\n", " Younger Adults\n", " Pre\n", + " 3.333333\n", + " 48.714286\n", + " 54.928571\n", + " 65.928571\n", + " 65.642857\n", " 0.785714\n", " 0.500000\n", - " 0.785714\n", - " 0.071429\n", - " 0.214286\n", - " 0.142857\n", - " 0.142857\n", " ...\n", " 0.000000\n", " 0.214286\n", @@ -1084,13 +1063,13 @@ " 24\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 42.230769\n", + " 67.846154\n", + " 59.692308\n", + " 28.000000\n", " 0.769231\n", " 0.923077\n", - " 1.000000\n", - " 0.153846\n", - " 0.384615\n", - " 0.076923\n", - " 0.923077\n", " ...\n", " 0.076923\n", " 1.000000\n", @@ -1108,13 +1087,13 @@ " 25\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 28.642857\n", + " 70.714286\n", + " 68.785714\n", + " 33.142857\n", " 0.428571\n", " 0.857143\n", - " 0.500000\n", - " 0.142857\n", - " 0.000000\n", - " 0.214286\n", - " 0.500000\n", " ...\n", " 0.000000\n", " 0.857143\n", @@ -1132,13 +1111,13 @@ " 33\n", " Younger Adults\n", " Pre\n", + " 1.000000\n", + " 31.692308\n", + " 64.846154\n", + " 51.615385\n", + " 27.461538\n", " 0.615385\n", " 0.692308\n", - " 0.846154\n", - " 0.923077\n", - " 0.000000\n", - " 0.384615\n", - " 0.307692\n", " ...\n", " 0.000000\n", " 0.615385\n", @@ -1156,13 +1135,13 @@ " 35\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 47.750000\n", + " 65.750000\n", + " 45.333333\n", + " 28.166667\n", " 0.500000\n", " 1.000000\n", - " 1.000000\n", - " 0.916667\n", - " 0.916667\n", - " 0.583333\n", - " 1.000000\n", " ...\n", " 0.666667\n", " 1.000000\n", @@ -1180,13 +1159,13 @@ " 38\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.266667\n", + " 65.866667\n", + " 28.733333\n", + " 6.933333\n", " 0.666667\n", " 0.866667\n", - " 1.000000\n", - " 0.066667\n", - " 0.466667\n", - " 0.466667\n", - " 0.066667\n", " ...\n", " 0.000000\n", " 1.000000\n", @@ -1204,13 +1183,13 @@ " 40\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 52.500000\n", + " 63.428571\n", + " 52.000000\n", + " 47.357143\n", " 0.714286\n", " 1.000000\n", - " 1.000000\n", - " 0.714286\n", - " 0.071429\n", - " 0.285714\n", - " 0.000000\n", " ...\n", " 0.571429\n", " 1.000000\n", @@ -1228,13 +1207,13 @@ " 45\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.461538\n", + " 74.384615\n", + " 28.923077\n", + " 20.153846\n", " 0.538462\n", " 0.846154\n", - " 1.000000\n", - " 0.923077\n", - " 0.769231\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 0.692308\n", " 1.000000\n", @@ -1252,13 +1231,13 @@ " 49\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 24.818182\n", + " 66.363636\n", + " 40.909091\n", + " 23.818182\n", " 0.636364\n", " 0.545455\n", - " 0.909091\n", - " 0.636364\n", - " 0.181818\n", - " 0.727273\n", - " 0.363636\n", " ...\n", " 0.090909\n", " 1.000000\n", @@ -1276,13 +1255,13 @@ " 57\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 35.250000\n", + " 70.000000\n", + " 45.750000\n", + " 20.750000\n", " 0.625000\n", " 0.125000\n", - " 0.125000\n", - " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 0.125000\n", " ...\n", " 0.000000\n", " 0.375000\n", @@ -1300,13 +1279,13 @@ " 62\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 29.153846\n", + " 58.461538\n", + " 65.153846\n", + " 48.538462\n", " 0.153846\n", " 0.230769\n", - " 0.769231\n", - " 0.846154\n", - " 0.230769\n", - " 0.692308\n", - " 0.307692\n", " ...\n", " 0.000000\n", " 0.692308\n", @@ -1324,13 +1303,13 @@ " 76\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 5.214286\n", + " 50.153846\n", + " 34.214286\n", + " 5.071429\n", " 0.214286\n", " 0.714286\n", - " 0.714286\n", - " 0.142857\n", - " 0.071429\n", - " 0.857143\n", - " 0.071429\n", " ...\n", " 0.000000\n", " 0.928571\n", @@ -1348,13 +1327,13 @@ " 105\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 2.857143\n", + " 92.500000\n", + " 6.642857\n", + " 0.428571\n", " 0.142857\n", " 1.000000\n", - " 0.357143\n", - " 0.785714\n", - " 0.214286\n", - " 0.571429\n", - " 0.071429\n", " ...\n", " 0.071429\n", " 0.928571\n", @@ -1372,13 +1351,13 @@ " 113\n", " Older Adults\n", " Pre\n", + " NaN\n", + " 10.714286\n", + " 53.785714\n", + " 33.642857\n", + " 13.357143\n", " 0.428571\n", " 0.928571\n", - " 0.928571\n", - " 0.928571\n", - " 0.357143\n", - " 0.857143\n", - " 0.714286\n", " ...\n", " 0.142857\n", " 0.928571\n", @@ -1396,13 +1375,13 @@ " 115\n", " Older Adults\n", " Pre\n", + " 1.333333\n", + " 18.666667\n", + " 80.400000\n", + " 25.400000\n", + " 77.800000\n", " 0.000000\n", " 0.933333\n", - " 0.666667\n", - " 0.533333\n", - " 0.066667\n", - " 0.666667\n", - " 0.800000\n", " ...\n", " 0.000000\n", " 0.400000\n", @@ -1420,13 +1399,13 @@ " 120\n", " Older Adults\n", " Post\n", + " NaN\n", + " 10.777778\n", + " 74.666667\n", + " 35.333333\n", + " 5.111111\n", " 0.000000\n", " 0.444444\n", - " 1.000000\n", - " 0.444444\n", - " 0.444444\n", - " 1.000000\n", - " 0.111111\n", " ...\n", " 1.000000\n", " 0.222222\n", @@ -1444,13 +1423,13 @@ " 122\n", " Older Adults\n", " Post\n", + " 5.545455\n", + " 3.636364\n", + " 83.090909\n", + " 7.727273\n", + " 5.272727\n", " 0.000000\n", " 0.818182\n", - " 0.818182\n", - " 0.181818\n", - " 0.000000\n", - " 0.727273\n", - " 0.000000\n", " ...\n", " 0.000000\n", " 0.636364\n", @@ -1468,13 +1447,13 @@ " 123\n", " Older Adults\n", " Post\n", + " NaN\n", + " 7.400000\n", + " 81.800000\n", + " 31.600000\n", + " 16.400000\n", " 0.000000\n", " 0.600000\n", - " 1.000000\n", - " 0.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", " ...\n", " 0.000000\n", " 0.200000\n", @@ -1492,13 +1471,13 @@ " 124\n", " Older Adults\n", " Post\n", + " NaN\n", + " 2.777778\n", + " 88.000000\n", + " 7.222222\n", + " 5.444444\n", " 0.000000\n", " 1.000000\n", - " 0.555556\n", - " 0.222222\n", - " 0.555556\n", - " 1.000000\n", - " 0.111111\n", " ...\n", " 0.000000\n", " 0.444444\n", @@ -1516,13 +1495,13 @@ " 125\n", " Older Adults\n", " Post\n", + " 2.500000\n", + " 8.909091\n", + " 67.454545\n", + " 13.727273\n", + " 9.090909\n", " 0.000000\n", " 0.909091\n", - " 0.909091\n", - " 0.363636\n", - " 0.000000\n", - " 1.000000\n", - " 0.272727\n", " ...\n", " 0.000000\n", " 0.909091\n", @@ -1540,13 +1519,13 @@ " 127\n", " Older Adults\n", " Post\n", + " 1.000000\n", + " 29.500000\n", + " 48.250000\n", + " 36.000000\n", + " 19.750000\n", " 0.250000\n", " 0.500000\n", - " 0.750000\n", - " 0.500000\n", - " 0.000000\n", - " 0.750000\n", - " 0.000000\n", " ...\n", " 0.750000\n", " 0.250000\n", @@ -1564,13 +1543,13 @@ " 129\n", " Older Adults\n", " Post\n", - " 0.000000\n", - " 1.000000\n", " 1.000000\n", - " 0.000000\n", + " 34.500000\n", + " 35.500000\n", + " 14.000000\n", + " 6.500000\n", " 0.000000\n", " 1.000000\n", - " 0.000000\n", " ...\n", " 0.000000\n", " 0.000000\n", @@ -1585,238 +1564,182 @@ " \n", " \n", "\n", - "

26 rows × 30 columns

\n", + "

26 rows × 35 columns

\n", "" ], "text/plain": [ " record_id age_group COVID Attending classes, meetings \\\n", - "0 11 Younger Adults Pre 0.000000 \n", - "1 12 Younger Adults Pre 0.642857 \n", - "2 14 Younger Adults Pre 0.000000 \n", - "3 16 Younger Adults Pre 0.571429 \n", - "4 23 Younger Adults Pre 0.785714 \n", - "5 24 Younger Adults Pre 0.769231 \n", - "6 25 Younger Adults Pre 0.428571 \n", - "7 33 Younger Adults Pre 0.615385 \n", - "8 35 Younger Adults Pre 0.500000 \n", - "9 38 Younger Adults Pre 0.666667 \n", - "10 40 Younger Adults Pre 0.714286 \n", - "11 45 Younger Adults Pre 0.538462 \n", - "12 49 Younger Adults Pre 0.636364 \n", - "13 57 Younger Adults Pre 0.625000 \n", - "14 62 Younger Adults Pre 0.153846 \n", - "15 76 Older Adults Pre 0.214286 \n", - "16 105 Older Adults Pre 0.142857 \n", - "17 113 Older Adults Pre 0.428571 \n", - "18 115 Older Adults Pre 0.000000 \n", - "19 120 Older Adults Post 0.000000 \n", - "20 122 Older Adults Post 0.000000 \n", - "21 123 Older Adults Post 0.000000 \n", - "22 124 Older Adults Post 0.000000 \n", - "23 125 Older Adults Post 0.000000 \n", - "24 127 Older Adults Post 0.250000 \n", - "25 129 Older Adults Post 0.000000 \n", + "0 11 Younger Adults Pre NaN \n", + "1 12 Younger Adults Pre 1.500000 \n", + "2 14 Younger Adults Pre 2.000000 \n", + "3 16 Younger Adults Pre 5.714286 \n", + "4 23 Younger Adults Pre 3.333333 \n", + "5 24 Younger Adults Pre NaN \n", + "6 25 Younger Adults Pre NaN \n", + "7 33 Younger Adults Pre 1.000000 \n", + "8 35 Younger Adults Pre NaN \n", + "9 38 Younger Adults Pre NaN \n", + "10 40 Younger Adults Pre NaN \n", + "11 45 Younger Adults Pre NaN \n", + "12 49 Younger Adults Pre 1.500000 \n", + "13 57 Younger Adults Pre NaN \n", + "14 62 Younger Adults Pre 1.500000 \n", + "15 76 Older Adults Pre 1.000000 \n", + "16 105 Older Adults Pre 1.000000 \n", + "17 113 Older Adults Pre NaN \n", + "18 115 Older Adults Pre 1.333333 \n", + "19 120 Older Adults Post NaN \n", + "20 122 Older Adults Post 5.545455 \n", + "21 123 Older Adults Post NaN \n", + "22 124 Older Adults Post NaN \n", + "23 125 Older Adults Post 2.500000 \n", + "24 127 Older Adults Post 1.000000 \n", + "25 129 Older Adults Post 1.000000 \n", "\n", " Being physically animated, moving around Browsing the internet \\\n", - "0 0.461538 1.000000 \n", - "1 0.285714 1.000000 \n", - "2 0.416667 0.833333 \n", - "3 0.071429 1.000000 \n", - "4 0.500000 0.785714 \n", - "5 0.923077 1.000000 \n", - "6 0.857143 0.500000 \n", - "7 0.692308 0.846154 \n", - "8 1.000000 1.000000 \n", - "9 0.866667 1.000000 \n", - "10 1.000000 1.000000 \n", - "11 0.846154 1.000000 \n", - "12 0.545455 0.909091 \n", - "13 0.125000 0.125000 \n", - "14 0.230769 0.769231 \n", - "15 0.714286 0.714286 \n", - "16 1.000000 0.357143 \n", - "17 0.928571 0.928571 \n", - "18 0.933333 0.666667 \n", - "19 0.444444 1.000000 \n", - "20 0.818182 0.818182 \n", - "21 0.600000 1.000000 \n", - "22 1.000000 0.555556 \n", - "23 0.909091 0.909091 \n", - "24 0.500000 0.750000 \n", - "25 1.000000 1.000000 \n", + "0 0.692308 96.384615 \n", + "1 5.857143 55.142857 \n", + "2 43.416667 52.000000 \n", + "3 37.785714 53.857143 \n", + "4 48.714286 54.928571 \n", + "5 42.230769 67.846154 \n", + "6 28.642857 70.714286 \n", + "7 31.692308 64.846154 \n", + "8 47.750000 65.750000 \n", + "9 17.266667 65.866667 \n", + "10 52.500000 63.428571 \n", + "11 17.461538 74.384615 \n", + "12 24.818182 66.363636 \n", + "13 35.250000 70.000000 \n", + "14 29.153846 58.461538 \n", + "15 5.214286 50.153846 \n", + "16 2.857143 92.500000 \n", + "17 10.714286 53.785714 \n", + "18 18.666667 80.400000 \n", + "19 10.777778 74.666667 \n", + "20 3.636364 83.090909 \n", + "21 7.400000 81.800000 \n", + "22 2.777778 88.000000 \n", + "23 8.909091 67.454545 \n", + "24 29.500000 48.250000 \n", + "25 34.500000 35.500000 \n", "\n", " Commuting, traveling Doing a favor, helping others \\\n", - "0 1.000000 0.000000 \n", - "1 0.857143 0.071429 \n", - "2 0.500000 0.000000 \n", - "3 1.000000 0.000000 \n", - "4 0.071429 0.214286 \n", - "5 0.153846 0.384615 \n", - "6 0.142857 0.000000 \n", - "7 0.923077 0.000000 \n", - "8 0.916667 0.916667 \n", - "9 0.066667 0.466667 \n", - "10 0.714286 0.071429 \n", - "11 0.923077 0.769231 \n", - "12 0.636364 0.181818 \n", - "13 0.000000 0.000000 \n", - "14 0.846154 0.230769 \n", - "15 0.142857 0.071429 \n", - "16 0.785714 0.214286 \n", - "17 0.928571 0.357143 \n", - "18 0.533333 0.066667 \n", - "19 0.444444 0.444444 \n", - "20 0.181818 0.000000 \n", - "21 0.000000 0.000000 \n", - "22 0.222222 0.555556 \n", - "23 0.363636 0.000000 \n", - "24 0.500000 0.000000 \n", - "25 0.000000 0.000000 \n", + "0 3.076923 0.153846 \n", + "1 49.500000 0.000000 \n", + "2 61.916667 51.916667 \n", + "3 43.214286 4.571429 \n", + "4 65.928571 65.642857 \n", + "5 59.692308 28.000000 \n", + "6 68.785714 33.142857 \n", + "7 51.615385 27.461538 \n", + "8 45.333333 28.166667 \n", + "9 28.733333 6.933333 \n", + "10 52.000000 47.357143 \n", + "11 28.923077 20.153846 \n", + "12 40.909091 23.818182 \n", + "13 45.750000 20.750000 \n", + "14 65.153846 48.538462 \n", + "15 34.214286 5.071429 \n", + "16 6.642857 0.428571 \n", + "17 33.642857 13.357143 \n", + "18 25.400000 77.800000 \n", + "19 35.333333 5.111111 \n", + "20 7.727273 5.272727 \n", + "21 31.600000 16.400000 \n", + "22 7.222222 5.444444 \n", + "23 13.727273 9.090909 \n", + "24 36.000000 19.750000 \n", + "25 14.000000 6.500000 \n", "\n", " Doing household chores Doing nothing (sitting around, daydreaming ... \\\n", - "0 0.307692 0.153846 ... \n", - "1 0.642857 0.214286 ... \n", - "2 0.500000 0.583333 ... \n", - "3 1.000000 0.000000 ... \n", - "4 0.142857 0.142857 ... \n", - "5 0.076923 0.923077 ... \n", - "6 0.214286 0.500000 ... \n", - "7 0.384615 0.307692 ... \n", - "8 0.583333 1.000000 ... \n", - "9 0.466667 0.066667 ... \n", - "10 0.285714 0.000000 ... \n", - "11 1.000000 1.000000 ... \n", - "12 0.727273 0.363636 ... \n", - "13 0.000000 0.125000 ... \n", - "14 0.692308 0.307692 ... \n", - "15 0.857143 0.071429 ... \n", - "16 0.571429 0.071429 ... \n", - "17 0.857143 0.714286 ... \n", - "18 0.666667 0.800000 ... \n", - "19 1.000000 0.111111 ... \n", - "20 0.727273 0.000000 ... \n", - "21 1.000000 0.000000 ... \n", - "22 1.000000 0.111111 ... \n", - "23 1.000000 0.272727 ... \n", - "24 0.750000 0.000000 ... \n", - "25 1.000000 0.000000 ... \n", - "\n", - " Spiritual, religious activity Talking, socializing in person \\\n", - "0 0.000000 1.000000 \n", - "1 0.142857 0.428571 \n", - "2 0.000000 0.583333 \n", - "3 0.000000 0.857143 \n", - "4 0.000000 0.214286 \n", - "5 0.076923 1.000000 \n", - "6 0.000000 0.857143 \n", - "7 0.000000 0.615385 \n", - "8 0.666667 1.000000 \n", - "9 0.000000 1.000000 \n", - "10 0.571429 1.000000 \n", - "11 0.692308 1.000000 \n", - "12 0.090909 1.000000 \n", - "13 0.000000 0.375000 \n", - "14 0.000000 0.692308 \n", - "15 0.000000 0.928571 \n", - "16 0.071429 0.928571 \n", - "17 0.142857 0.928571 \n", - "18 0.000000 0.400000 \n", - "19 1.000000 0.222222 \n", - "20 0.000000 0.636364 \n", - "21 0.000000 0.200000 \n", - "22 0.000000 0.444444 \n", - "23 0.000000 0.909091 \n", - "24 0.750000 0.250000 \n", - "25 0.000000 0.000000 \n", - "\n", - " Texting, talking on the phone Thinking, reflecting Using social media \\\n", - "0 1.000000 0.000000 0.076923 \n", - "1 0.000000 0.071429 0.857143 \n", - "2 0.250000 0.083333 0.583333 \n", - "3 0.857143 0.071429 1.000000 \n", - "4 0.714286 0.142857 0.142857 \n", - "5 1.000000 0.846154 0.923077 \n", - "6 0.928571 0.000000 0.928571 \n", - "7 0.846154 0.615385 0.923077 \n", - "8 1.000000 1.000000 1.000000 \n", - "9 0.933333 0.400000 1.000000 \n", - "10 1.000000 1.000000 1.000000 \n", - "11 1.000000 0.923077 1.000000 \n", - "12 1.000000 0.363636 0.818182 \n", - "13 0.125000 0.000000 0.125000 \n", - "14 0.615385 0.461538 0.692308 \n", - "15 0.928571 0.571429 0.000000 \n", - "16 1.000000 0.000000 0.000000 \n", - "17 0.857143 0.857143 0.928571 \n", - "18 0.266667 0.533333 0.000000 \n", - "19 0.888889 0.000000 0.000000 \n", - "20 0.272727 0.272727 0.090909 \n", - "21 0.800000 0.400000 0.000000 \n", - "22 0.777778 0.444444 0.000000 \n", - "23 0.363636 0.454545 0.545455 \n", - "24 0.250000 0.000000 0.250000 \n", - "25 1.000000 0.250000 1.000000 \n", + "0 0.000000 0.461538 ... \n", + "1 0.642857 0.285714 ... \n", + "2 0.000000 0.416667 ... \n", + "3 0.571429 0.071429 ... \n", + "4 0.785714 0.500000 ... \n", + "5 0.769231 0.923077 ... \n", + "6 0.428571 0.857143 ... \n", + "7 0.615385 0.692308 ... \n", + "8 0.500000 1.000000 ... \n", + "9 0.666667 0.866667 ... \n", + "10 0.714286 1.000000 ... \n", + "11 0.538462 0.846154 ... \n", + "12 0.636364 0.545455 ... \n", + "13 0.625000 0.125000 ... \n", + "14 0.153846 0.230769 ... \n", + "15 0.214286 0.714286 ... \n", + "16 0.142857 1.000000 ... \n", + "17 0.428571 0.928571 ... \n", + "18 0.000000 0.933333 ... \n", + "19 0.000000 0.444444 ... \n", + "20 0.000000 0.818182 ... \n", + "21 0.000000 0.600000 ... \n", + "22 0.000000 1.000000 ... \n", + "23 0.000000 0.909091 ... \n", + "24 0.250000 0.500000 ... \n", + "25 0.000000 1.000000 ... \n", "\n", " Using a computer Walking, running Watching TV, movies Working \\\n", - "0 0.923077 0.923077 0.538462 1.000000 \n", - "1 1.000000 0.571429 0.571429 0.285714 \n", - "2 0.583333 0.333333 1.000000 0.416667 \n", - "3 0.928571 0.857143 0.928571 0.714286 \n", - "4 0.428571 0.214286 0.285714 0.000000 \n", - "5 0.769231 0.923077 0.692308 0.000000 \n", - "6 0.857143 0.071429 0.857143 0.000000 \n", - "7 1.000000 0.923077 1.000000 0.692308 \n", - "8 1.000000 1.000000 0.416667 0.000000 \n", - "9 0.533333 1.000000 0.800000 0.333333 \n", - "10 1.000000 1.000000 0.928571 0.000000 \n", - "11 1.000000 1.000000 0.307692 0.000000 \n", - "12 1.000000 0.636364 1.000000 0.545455 \n", - "13 0.125000 0.125000 0.000000 0.000000 \n", - "14 1.000000 0.230769 0.461538 0.615385 \n", - "15 0.714286 0.428571 1.000000 0.000000 \n", - "16 0.428571 1.000000 1.000000 0.000000 \n", - "17 0.571429 0.928571 0.642857 0.000000 \n", - "18 0.800000 0.533333 0.866667 0.000000 \n", - "19 1.000000 0.888889 1.000000 0.000000 \n", - "20 0.818182 1.000000 0.545455 0.000000 \n", - "21 0.800000 0.000000 0.200000 0.400000 \n", - "22 0.888889 0.555556 0.666667 0.000000 \n", - "23 0.636364 1.000000 0.545455 0.000000 \n", - "24 1.000000 1.000000 0.000000 0.000000 \n", - "25 1.000000 0.750000 1.000000 0.000000 \n", + "0 0.000000 1.000000 1.000000 0.000000 \n", + "1 0.142857 0.428571 0.000000 0.071429 \n", + "2 0.000000 0.583333 0.250000 0.083333 \n", + "3 0.000000 0.857143 0.857143 0.071429 \n", + "4 0.000000 0.214286 0.714286 0.142857 \n", + "5 0.076923 1.000000 1.000000 0.846154 \n", + "6 0.000000 0.857143 0.928571 0.000000 \n", + "7 0.000000 0.615385 0.846154 0.615385 \n", + "8 0.666667 1.000000 1.000000 1.000000 \n", + "9 0.000000 1.000000 0.933333 0.400000 \n", + "10 0.571429 1.000000 1.000000 1.000000 \n", + "11 0.692308 1.000000 1.000000 0.923077 \n", + "12 0.090909 1.000000 1.000000 0.363636 \n", + "13 0.000000 0.375000 0.125000 0.000000 \n", + "14 0.000000 0.692308 0.615385 0.461538 \n", + "15 0.000000 0.928571 0.928571 0.571429 \n", + "16 0.071429 0.928571 1.000000 0.000000 \n", + "17 0.142857 0.928571 0.857143 0.857143 \n", + "18 0.000000 0.400000 0.266667 0.533333 \n", + "19 1.000000 0.222222 0.888889 0.000000 \n", + "20 0.000000 0.636364 0.272727 0.272727 \n", + "21 0.000000 0.200000 0.800000 0.400000 \n", + "22 0.000000 0.444444 0.777778 0.444444 \n", + "23 0.000000 0.909091 0.363636 0.454545 \n", + "24 0.750000 0.250000 0.250000 0.000000 \n", + "25 0.000000 0.000000 1.000000 0.250000 \n", "\n", - " None of the above \n", - "0 0.0 \n", - "1 0.0 \n", - "2 0.0 \n", - "3 0.0 \n", - "4 0.0 \n", - "5 0.0 \n", - "6 0.0 \n", - "7 0.0 \n", - "8 0.0 \n", - "9 0.0 \n", - "10 0.0 \n", - "11 0.0 \n", - "12 0.0 \n", - "13 0.0 \n", - "14 0.0 \n", - "15 0.0 \n", - "16 0.0 \n", - "17 0.0 \n", - "18 0.0 \n", - "19 0.0 \n", - "20 0.0 \n", - "21 0.0 \n", - "22 0.0 \n", - "23 0.0 \n", - "24 0.0 \n", - "25 0.0 \n", + " None of the above Sadness Happiness Stress Rumination Alcohol \n", + "0 0.076923 0.923077 0.923077 0.538462 1.000000 0.0 \n", + "1 0.857143 1.000000 0.571429 0.571429 0.285714 0.0 \n", + "2 0.583333 0.583333 0.333333 1.000000 0.416667 0.0 \n", + "3 1.000000 0.928571 0.857143 0.928571 0.714286 0.0 \n", + "4 0.142857 0.428571 0.214286 0.285714 0.000000 0.0 \n", + "5 0.923077 0.769231 0.923077 0.692308 0.000000 0.0 \n", + "6 0.928571 0.857143 0.071429 0.857143 0.000000 0.0 \n", + "7 0.923077 1.000000 0.923077 1.000000 0.692308 0.0 \n", + "8 1.000000 1.000000 1.000000 0.416667 0.000000 0.0 \n", + "9 1.000000 0.533333 1.000000 0.800000 0.333333 0.0 \n", + "10 1.000000 1.000000 1.000000 0.928571 0.000000 0.0 \n", + "11 1.000000 1.000000 1.000000 0.307692 0.000000 0.0 \n", + "12 0.818182 1.000000 0.636364 1.000000 0.545455 0.0 \n", + "13 0.125000 0.125000 0.125000 0.000000 0.000000 0.0 \n", + "14 0.692308 1.000000 0.230769 0.461538 0.615385 0.0 \n", + "15 0.000000 0.714286 0.428571 1.000000 0.000000 0.0 \n", + "16 0.000000 0.428571 1.000000 1.000000 0.000000 0.0 \n", + "17 0.928571 0.571429 0.928571 0.642857 0.000000 0.0 \n", + "18 0.000000 0.800000 0.533333 0.866667 0.000000 0.0 \n", + "19 0.000000 1.000000 0.888889 1.000000 0.000000 0.0 \n", + "20 0.090909 0.818182 1.000000 0.545455 0.000000 0.0 \n", + "21 0.000000 0.800000 0.000000 0.200000 0.400000 0.0 \n", + "22 0.000000 0.888889 0.555556 0.666667 0.000000 0.0 \n", + "23 0.545455 0.636364 1.000000 0.545455 0.000000 0.0 \n", + "24 0.250000 1.000000 1.000000 0.000000 0.000000 0.0 \n", + "25 1.000000 1.000000 0.750000 1.000000 0.000000 0.0 \n", "\n", - "[26 rows x 30 columns]" + "[26 rows x 35 columns]" ] }, - "execution_count": 35, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" } @@ -1829,7 +1752,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -1839,7 +1762,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -1874,16 +1797,16 @@ " Doing household chores\n", " Doing nothing (sitting around, daydreaming\n", " ...\n", - " Spiritual, religious activity\n", - " Talking, socializing in person\n", - " Texting, talking on the phone\n", - " Thinking, reflecting\n", - " Using social media\n", " Using a computer\n", " Walking, running\n", " Watching TV, movies\n", " Working\n", " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " \n", " \n", " \n", @@ -1892,13 +1815,13 @@ " 11\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 0.692308\n", + " 96.384615\n", + " 3.076923\n", + " 0.153846\n", " 0.000000\n", " 0.461538\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.307692\n", - " 0.153846\n", " ...\n", " 0.000000\n", " 1.000000\n", @@ -1916,13 +1839,13 @@ " 12\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 5.857143\n", + " 55.142857\n", + " 49.500000\n", + " 0.000000\n", " 0.642857\n", " 0.285714\n", - " 1.000000\n", - " 0.857143\n", - " 0.071429\n", - " 0.642857\n", - " 0.214286\n", " ...\n", " 0.142857\n", " 0.428571\n", @@ -1940,13 +1863,13 @@ " 14\n", " Younger Adults\n", " Pre\n", + " 2.000000\n", + " 43.416667\n", + " 52.000000\n", + " 61.916667\n", + " 51.916667\n", " 0.000000\n", " 0.416667\n", - " 0.833333\n", - " 0.500000\n", - " 0.000000\n", - " 0.500000\n", - " 0.583333\n", " ...\n", " 0.000000\n", " 0.583333\n", @@ -1964,13 +1887,13 @@ " 16\n", " Younger Adults\n", " Pre\n", + " 5.714286\n", + " 37.785714\n", + " 53.857143\n", + " 43.214286\n", + " 4.571429\n", " 0.571429\n", " 0.071429\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", " ...\n", " 0.000000\n", " 0.857143\n", @@ -1988,13 +1911,13 @@ " 23\n", " Younger Adults\n", " Pre\n", + " 3.333333\n", + " 48.714286\n", + " 54.928571\n", + " 65.928571\n", + " 65.642857\n", " 0.785714\n", " 0.500000\n", - " 0.785714\n", - " 0.071429\n", - " 0.214286\n", - " 0.142857\n", - " 0.142857\n", " ...\n", " 0.000000\n", " 0.214286\n", @@ -2012,13 +1935,13 @@ " 24\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 42.230769\n", + " 67.846154\n", + " 59.692308\n", + " 28.000000\n", " 0.769231\n", " 0.923077\n", - " 1.000000\n", - " 0.153846\n", - " 0.384615\n", - " 0.076923\n", - " 0.923077\n", " ...\n", " 0.076923\n", " 1.000000\n", @@ -2036,13 +1959,13 @@ " 25\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 28.642857\n", + " 70.714286\n", + " 68.785714\n", + " 33.142857\n", " 0.428571\n", " 0.857143\n", - " 0.500000\n", - " 0.142857\n", - " 0.000000\n", - " 0.214286\n", - " 0.500000\n", " ...\n", " 0.000000\n", " 0.857143\n", @@ -2060,13 +1983,13 @@ " 33\n", " Younger Adults\n", " Pre\n", + " 1.000000\n", + " 31.692308\n", + " 64.846154\n", + " 51.615385\n", + " 27.461538\n", " 0.615385\n", " 0.692308\n", - " 0.846154\n", - " 0.923077\n", - " 0.000000\n", - " 0.384615\n", - " 0.307692\n", " ...\n", " 0.000000\n", " 0.615385\n", @@ -2084,13 +2007,13 @@ " 35\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 47.750000\n", + " 65.750000\n", + " 45.333333\n", + " 28.166667\n", " 0.500000\n", " 1.000000\n", - " 1.000000\n", - " 0.916667\n", - " 0.916667\n", - " 0.583333\n", - " 1.000000\n", " ...\n", " 0.666667\n", " 1.000000\n", @@ -2108,13 +2031,13 @@ " 38\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.266667\n", + " 65.866667\n", + " 28.733333\n", + " 6.933333\n", " 0.666667\n", " 0.866667\n", - " 1.000000\n", - " 0.066667\n", - " 0.466667\n", - " 0.466667\n", - " 0.066667\n", " ...\n", " 0.000000\n", " 1.000000\n", @@ -2132,13 +2055,13 @@ " 40\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 52.500000\n", + " 63.428571\n", + " 52.000000\n", + " 47.357143\n", " 0.714286\n", " 1.000000\n", - " 1.000000\n", - " 0.714286\n", - " 0.071429\n", - " 0.285714\n", - " 0.000000\n", " ...\n", " 0.571429\n", " 1.000000\n", @@ -2156,13 +2079,13 @@ " 45\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.461538\n", + " 74.384615\n", + " 28.923077\n", + " 20.153846\n", " 0.538462\n", " 0.846154\n", - " 1.000000\n", - " 0.923077\n", - " 0.769231\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 0.692308\n", " 1.000000\n", @@ -2180,13 +2103,13 @@ " 49\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 24.818182\n", + " 66.363636\n", + " 40.909091\n", + " 23.818182\n", " 0.636364\n", " 0.545455\n", - " 0.909091\n", - " 0.636364\n", - " 0.181818\n", - " 0.727273\n", - " 0.363636\n", " ...\n", " 0.090909\n", " 1.000000\n", @@ -2204,13 +2127,13 @@ " 57\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 35.250000\n", + " 70.000000\n", + " 45.750000\n", + " 20.750000\n", " 0.625000\n", " 0.125000\n", - " 0.125000\n", - " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 0.125000\n", " ...\n", " 0.000000\n", " 0.375000\n", @@ -2228,13 +2151,13 @@ " 62\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 29.153846\n", + " 58.461538\n", + " 65.153846\n", + " 48.538462\n", " 0.153846\n", " 0.230769\n", - " 0.769231\n", - " 0.846154\n", - " 0.230769\n", - " 0.692308\n", - " 0.307692\n", " ...\n", " 0.000000\n", " 0.692308\n", @@ -2249,150 +2172,116 @@ " \n", " \n", "\n", - "

15 rows × 30 columns

\n", + "

15 rows × 35 columns

\n", "" ], "text/plain": [ " record_id age_group COVID Attending classes, meetings \\\n", - "0 11 Younger Adults Pre 0.000000 \n", - "1 12 Younger Adults Pre 0.642857 \n", - "2 14 Younger Adults Pre 0.000000 \n", - "3 16 Younger Adults Pre 0.571429 \n", - "4 23 Younger Adults Pre 0.785714 \n", - "5 24 Younger Adults Pre 0.769231 \n", - "6 25 Younger Adults Pre 0.428571 \n", - "7 33 Younger Adults Pre 0.615385 \n", - "8 35 Younger Adults Pre 0.500000 \n", - "9 38 Younger Adults Pre 0.666667 \n", - "10 40 Younger Adults Pre 0.714286 \n", - "11 45 Younger Adults Pre 0.538462 \n", - "12 49 Younger Adults Pre 0.636364 \n", - "13 57 Younger Adults Pre 0.625000 \n", - "14 62 Younger Adults Pre 0.153846 \n", + "0 11 Younger Adults Pre NaN \n", + "1 12 Younger Adults Pre 1.500000 \n", + "2 14 Younger Adults Pre 2.000000 \n", + "3 16 Younger Adults Pre 5.714286 \n", + "4 23 Younger Adults Pre 3.333333 \n", + "5 24 Younger Adults Pre NaN \n", + "6 25 Younger Adults Pre NaN \n", + "7 33 Younger Adults Pre 1.000000 \n", + "8 35 Younger Adults Pre NaN \n", + "9 38 Younger Adults Pre NaN \n", + "10 40 Younger Adults Pre NaN \n", + "11 45 Younger Adults Pre NaN \n", + "12 49 Younger Adults Pre 1.500000 \n", + "13 57 Younger Adults Pre NaN \n", + "14 62 Younger Adults Pre 1.500000 \n", "\n", " Being physically animated, moving around Browsing the internet \\\n", - "0 0.461538 1.000000 \n", - "1 0.285714 1.000000 \n", - "2 0.416667 0.833333 \n", - "3 0.071429 1.000000 \n", - "4 0.500000 0.785714 \n", - "5 0.923077 1.000000 \n", - "6 0.857143 0.500000 \n", - "7 0.692308 0.846154 \n", - "8 1.000000 1.000000 \n", - "9 0.866667 1.000000 \n", - "10 1.000000 1.000000 \n", - "11 0.846154 1.000000 \n", - "12 0.545455 0.909091 \n", - "13 0.125000 0.125000 \n", - "14 0.230769 0.769231 \n", + "0 0.692308 96.384615 \n", + "1 5.857143 55.142857 \n", + "2 43.416667 52.000000 \n", + "3 37.785714 53.857143 \n", + "4 48.714286 54.928571 \n", + "5 42.230769 67.846154 \n", + "6 28.642857 70.714286 \n", + "7 31.692308 64.846154 \n", + "8 47.750000 65.750000 \n", + "9 17.266667 65.866667 \n", + "10 52.500000 63.428571 \n", + "11 17.461538 74.384615 \n", + "12 24.818182 66.363636 \n", + "13 35.250000 70.000000 \n", + "14 29.153846 58.461538 \n", "\n", " Commuting, traveling Doing a favor, helping others \\\n", - "0 1.000000 0.000000 \n", - "1 0.857143 0.071429 \n", - "2 0.500000 0.000000 \n", - "3 1.000000 0.000000 \n", - "4 0.071429 0.214286 \n", - "5 0.153846 0.384615 \n", - "6 0.142857 0.000000 \n", - "7 0.923077 0.000000 \n", - "8 0.916667 0.916667 \n", - "9 0.066667 0.466667 \n", - "10 0.714286 0.071429 \n", - "11 0.923077 0.769231 \n", - "12 0.636364 0.181818 \n", - "13 0.000000 0.000000 \n", - "14 0.846154 0.230769 \n", + "0 3.076923 0.153846 \n", + "1 49.500000 0.000000 \n", + "2 61.916667 51.916667 \n", + "3 43.214286 4.571429 \n", + "4 65.928571 65.642857 \n", + "5 59.692308 28.000000 \n", + "6 68.785714 33.142857 \n", + "7 51.615385 27.461538 \n", + "8 45.333333 28.166667 \n", + "9 28.733333 6.933333 \n", + "10 52.000000 47.357143 \n", + "11 28.923077 20.153846 \n", + "12 40.909091 23.818182 \n", + "13 45.750000 20.750000 \n", + "14 65.153846 48.538462 \n", "\n", " Doing household chores Doing nothing (sitting around, daydreaming ... \\\n", - "0 0.307692 0.153846 ... \n", - "1 0.642857 0.214286 ... \n", - "2 0.500000 0.583333 ... \n", - "3 1.000000 0.000000 ... \n", - "4 0.142857 0.142857 ... \n", - "5 0.076923 0.923077 ... \n", - "6 0.214286 0.500000 ... \n", - "7 0.384615 0.307692 ... \n", - "8 0.583333 1.000000 ... \n", - "9 0.466667 0.066667 ... \n", - "10 0.285714 0.000000 ... \n", - "11 1.000000 1.000000 ... \n", - "12 0.727273 0.363636 ... \n", - "13 0.000000 0.125000 ... \n", - "14 0.692308 0.307692 ... \n", - "\n", - " Spiritual, religious activity Talking, socializing in person \\\n", - "0 0.000000 1.000000 \n", - "1 0.142857 0.428571 \n", - "2 0.000000 0.583333 \n", - "3 0.000000 0.857143 \n", - "4 0.000000 0.214286 \n", - "5 0.076923 1.000000 \n", - "6 0.000000 0.857143 \n", - "7 0.000000 0.615385 \n", - "8 0.666667 1.000000 \n", - "9 0.000000 1.000000 \n", - "10 0.571429 1.000000 \n", - "11 0.692308 1.000000 \n", - "12 0.090909 1.000000 \n", - "13 0.000000 0.375000 \n", - "14 0.000000 0.692308 \n", - "\n", - " Texting, talking on the phone Thinking, reflecting Using social media \\\n", - "0 1.000000 0.000000 0.076923 \n", - "1 0.000000 0.071429 0.857143 \n", - "2 0.250000 0.083333 0.583333 \n", - "3 0.857143 0.071429 1.000000 \n", - "4 0.714286 0.142857 0.142857 \n", - "5 1.000000 0.846154 0.923077 \n", - "6 0.928571 0.000000 0.928571 \n", - "7 0.846154 0.615385 0.923077 \n", - "8 1.000000 1.000000 1.000000 \n", - "9 0.933333 0.400000 1.000000 \n", - "10 1.000000 1.000000 1.000000 \n", - "11 1.000000 0.923077 1.000000 \n", - "12 1.000000 0.363636 0.818182 \n", - "13 0.125000 0.000000 0.125000 \n", - "14 0.615385 0.461538 0.692308 \n", + "0 0.000000 0.461538 ... \n", + "1 0.642857 0.285714 ... \n", + "2 0.000000 0.416667 ... \n", + "3 0.571429 0.071429 ... \n", + "4 0.785714 0.500000 ... \n", + "5 0.769231 0.923077 ... \n", + "6 0.428571 0.857143 ... \n", + "7 0.615385 0.692308 ... \n", + "8 0.500000 1.000000 ... \n", + "9 0.666667 0.866667 ... \n", + "10 0.714286 1.000000 ... \n", + "11 0.538462 0.846154 ... \n", + "12 0.636364 0.545455 ... \n", + "13 0.625000 0.125000 ... \n", + "14 0.153846 0.230769 ... \n", "\n", " Using a computer Walking, running Watching TV, movies Working \\\n", - "0 0.923077 0.923077 0.538462 1.000000 \n", - "1 1.000000 0.571429 0.571429 0.285714 \n", - "2 0.583333 0.333333 1.000000 0.416667 \n", - "3 0.928571 0.857143 0.928571 0.714286 \n", - "4 0.428571 0.214286 0.285714 0.000000 \n", - "5 0.769231 0.923077 0.692308 0.000000 \n", - "6 0.857143 0.071429 0.857143 0.000000 \n", - "7 1.000000 0.923077 1.000000 0.692308 \n", - "8 1.000000 1.000000 0.416667 0.000000 \n", - "9 0.533333 1.000000 0.800000 0.333333 \n", - "10 1.000000 1.000000 0.928571 0.000000 \n", - "11 1.000000 1.000000 0.307692 0.000000 \n", - "12 1.000000 0.636364 1.000000 0.545455 \n", - "13 0.125000 0.125000 0.000000 0.000000 \n", - "14 1.000000 0.230769 0.461538 0.615385 \n", + "0 0.000000 1.000000 1.000000 0.000000 \n", + "1 0.142857 0.428571 0.000000 0.071429 \n", + "2 0.000000 0.583333 0.250000 0.083333 \n", + "3 0.000000 0.857143 0.857143 0.071429 \n", + "4 0.000000 0.214286 0.714286 0.142857 \n", + "5 0.076923 1.000000 1.000000 0.846154 \n", + "6 0.000000 0.857143 0.928571 0.000000 \n", + "7 0.000000 0.615385 0.846154 0.615385 \n", + "8 0.666667 1.000000 1.000000 1.000000 \n", + "9 0.000000 1.000000 0.933333 0.400000 \n", + "10 0.571429 1.000000 1.000000 1.000000 \n", + "11 0.692308 1.000000 1.000000 0.923077 \n", + "12 0.090909 1.000000 1.000000 0.363636 \n", + "13 0.000000 0.375000 0.125000 0.000000 \n", + "14 0.000000 0.692308 0.615385 0.461538 \n", "\n", - " None of the above \n", - "0 0.0 \n", - "1 0.0 \n", - "2 0.0 \n", - "3 0.0 \n", - "4 0.0 \n", - "5 0.0 \n", - "6 0.0 \n", - "7 0.0 \n", - "8 0.0 \n", - "9 0.0 \n", - "10 0.0 \n", - "11 0.0 \n", - "12 0.0 \n", - "13 0.0 \n", - "14 0.0 \n", + " None of the above Sadness Happiness Stress Rumination Alcohol \n", + "0 0.076923 0.923077 0.923077 0.538462 1.000000 0.0 \n", + "1 0.857143 1.000000 0.571429 0.571429 0.285714 0.0 \n", + "2 0.583333 0.583333 0.333333 1.000000 0.416667 0.0 \n", + "3 1.000000 0.928571 0.857143 0.928571 0.714286 0.0 \n", + "4 0.142857 0.428571 0.214286 0.285714 0.000000 0.0 \n", + "5 0.923077 0.769231 0.923077 0.692308 0.000000 0.0 \n", + "6 0.928571 0.857143 0.071429 0.857143 0.000000 0.0 \n", + "7 0.923077 1.000000 0.923077 1.000000 0.692308 0.0 \n", + "8 1.000000 1.000000 1.000000 0.416667 0.000000 0.0 \n", + "9 1.000000 0.533333 1.000000 0.800000 0.333333 0.0 \n", + "10 1.000000 1.000000 1.000000 0.928571 0.000000 0.0 \n", + "11 1.000000 1.000000 1.000000 0.307692 0.000000 0.0 \n", + "12 0.818182 1.000000 0.636364 1.000000 0.545455 0.0 \n", + "13 0.125000 0.125000 0.125000 0.000000 0.000000 0.0 \n", + "14 0.692308 1.000000 0.230769 0.461538 0.615385 0.0 \n", "\n", - "[15 rows x 30 columns]" + "[15 rows x 35 columns]" ] }, - "execution_count": 37, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -2403,7 +2292,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -2438,16 +2327,16 @@ " Exercising, physical activity, sports\n", " Hygienic activities (grooming, showering\n", " ...\n", - " Spiritual, religious activity\n", - " Talking, socializing in person\n", - " Texting, talking on the phone\n", - " Thinking, reflecting\n", - " Using social media\n", " Using a computer\n", " Walking, running\n", " Watching TV, movies\n", " Working\n", " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " \n", " \n", " COVID\n", @@ -2477,16 +2366,16 @@ " \n", " \n", " Pre\n", + " 2.363946\n", + " 30.882152\n", + " 65.331654\n", + " 47.368836\n", + " 27.107122\n", " 0.509854\n", " 0.588128\n", " 0.851235\n", " 0.583438\n", " 0.220461\n", - " 0.468302\n", - " 0.379206\n", - " 0.861838\n", - " 0.329962\n", - " 0.788729\n", " ...\n", " 0.149406\n", " 0.774878\n", @@ -2501,54 +2390,46 @@ " \n", " \n", "\n", - "

1 rows × 27 columns

\n", + "

1 rows × 32 columns

\n", "" ], "text/plain": [ " Attending classes, meetings Being physically animated, moving around \\\n", "COVID \n", - "Pre 0.509854 0.588128 \n", + "Pre 2.363946 30.882152 \n", "\n", " Browsing the internet Commuting, traveling \\\n", "COVID \n", - "Pre 0.851235 0.583438 \n", + "Pre 65.331654 47.368836 \n", "\n", " Doing a favor, helping others Doing household chores \\\n", "COVID \n", - "Pre 0.220461 0.468302 \n", + "Pre 27.107122 0.509854 \n", "\n", " Doing nothing (sitting around, daydreaming Drinking, eating \\\n", "COVID \n", - "Pre 0.379206 0.861838 \n", + "Pre 0.588128 0.851235 \n", "\n", " Exercising, physical activity, sports \\\n", "COVID \n", - "Pre 0.329962 \n", - "\n", - " Hygienic activities (grooming, showering ... \\\n", - "COVID ... \n", - "Pre 0.788729 ... \n", + "Pre 0.583438 \n", "\n", - " Spiritual, religious activity Talking, socializing in person \\\n", - "COVID \n", - "Pre 0.149406 0.774878 \n", + " Hygienic activities (grooming, showering ... Using a computer \\\n", + "COVID ... \n", + "Pre 0.220461 ... 0.149406 \n", "\n", - " Texting, talking on the phone Thinking, reflecting \\\n", - "COVID \n", - "Pre 0.751325 0.398589 \n", + " Walking, running Watching TV, movies Working None of the above \\\n", + "COVID \n", + "Pre 0.774878 0.751325 0.398589 0.738031 \n", "\n", - " Using social media Using a computer Walking, running \\\n", - "COVID \n", - "Pre 0.738031 0.809884 0.653932 \n", + " Sadness Happiness Stress Rumination Alcohol \n", + "COVID \n", + "Pre 0.809884 0.653932 0.65254 0.306876 0.0 \n", "\n", - " Watching TV, movies Working None of the above \n", - "COVID \n", - "Pre 0.65254 0.306876 0.0 \n", - "\n", - "[1 rows x 27 columns]" + "[1 rows x 32 columns]" ] }, - "execution_count": 38, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" } @@ -2559,41 +2440,29 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 39, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" } ], "source": [ "import matplotlib.pyplot as plt\n", "\n", - "ya.drop(['record_id', 'age_group'], axis = 1).groupby('COVID').mean().plot.bar(figsize = (10, 10), width = 5)" + "ya.drop(['record_id', 'age_group'], axis = 1).drop(['Sadness', 'Happiness', 'Stress', 'Rumination', 'Alcohol'], axis=1).groupby('COVID').mean().plot.bar(figsize = (10, 10), width = 5)" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -2628,16 +2497,16 @@ " Exercising, physical activity, sports\n", " Hygienic activities (grooming, showering\n", " ...\n", - " Spiritual, religious activity\n", - " Talking, socializing in person\n", - " Texting, talking on the phone\n", - " Thinking, reflecting\n", - " Using social media\n", " Using a computer\n", " Walking, running\n", " Watching TV, movies\n", " Working\n", " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " \n", " \n", " COVID\n", @@ -2667,16 +2536,16 @@ " \n", " \n", " Post\n", + " 2.511364\n", + " 13.928716\n", + " 68.394589\n", + " 20.801443\n", + " 9.652742\n", " 0.035714\n", " 0.753102\n", " 0.861833\n", " 0.244589\n", " 0.142857\n", - " 0.925325\n", - " 0.070707\n", - " 0.955556\n", - " 0.685426\n", - " 0.813997\n", " ...\n", " 0.250000\n", " 0.380303\n", @@ -2691,16 +2560,16 @@ " \n", " \n", " Pre\n", + " 1.111111\n", + " 9.363095\n", + " 69.209890\n", + " 24.975000\n", + " 24.164286\n", " 0.196429\n", " 0.894048\n", " 0.666667\n", " 0.597619\n", " 0.177381\n", - " 0.738095\n", - " 0.414286\n", - " 0.965476\n", - " 0.719048\n", - " 0.896429\n", " ...\n", " 0.053571\n", " 0.796429\n", @@ -2715,64 +2584,54 @@ " \n", " \n", "\n", - "

2 rows × 27 columns

\n", + "

2 rows × 32 columns

\n", "" ], "text/plain": [ " Attending classes, meetings Being physically animated, moving around \\\n", "COVID \n", - "Post 0.035714 0.753102 \n", - "Pre 0.196429 0.894048 \n", + "Post 2.511364 13.928716 \n", + "Pre 1.111111 9.363095 \n", "\n", " Browsing the internet Commuting, traveling \\\n", "COVID \n", - "Post 0.861833 0.244589 \n", - "Pre 0.666667 0.597619 \n", + "Post 68.394589 20.801443 \n", + "Pre 69.209890 24.975000 \n", "\n", " Doing a favor, helping others Doing household chores \\\n", "COVID \n", - "Post 0.142857 0.925325 \n", - "Pre 0.177381 0.738095 \n", + "Post 9.652742 0.035714 \n", + "Pre 24.164286 0.196429 \n", "\n", " Doing nothing (sitting around, daydreaming Drinking, eating \\\n", "COVID \n", - "Post 0.070707 0.955556 \n", - "Pre 0.414286 0.965476 \n", + "Post 0.753102 0.861833 \n", + "Pre 0.894048 0.666667 \n", "\n", " Exercising, physical activity, sports \\\n", "COVID \n", - "Post 0.685426 \n", - "Pre 0.719048 \n", - "\n", - " Hygienic activities (grooming, showering ... \\\n", - "COVID ... \n", - "Post 0.813997 ... \n", - "Pre 0.896429 ... \n", - "\n", - " Spiritual, religious activity Talking, socializing in person \\\n", - "COVID \n", - "Post 0.250000 0.380303 \n", - "Pre 0.053571 0.796429 \n", + "Post 0.244589 \n", + "Pre 0.597619 \n", "\n", - " Texting, talking on the phone Thinking, reflecting \\\n", - "COVID \n", - "Post 0.621861 0.260245 \n", - "Pre 0.763095 0.490476 \n", + " Hygienic activities (grooming, showering ... Using a computer \\\n", + "COVID ... \n", + "Post 0.142857 ... 0.250000 \n", + "Pre 0.177381 ... 0.053571 \n", "\n", - " Using social media Using a computer Walking, running \\\n", - "COVID \n", - "Post 0.269481 0.877633 0.742063 \n", - "Pre 0.232143 0.628571 0.722619 \n", + " Walking, running Watching TV, movies Working None of the above \\\n", + "COVID \n", + "Post 0.380303 0.621861 0.260245 0.269481 \n", + "Pre 0.796429 0.763095 0.490476 0.232143 \n", "\n", - " Watching TV, movies Working None of the above \n", - "COVID \n", - "Post 0.565368 0.057143 0.0 \n", - "Pre 0.877381 0.000000 0.0 \n", + " Sadness Happiness Stress Rumination Alcohol \n", + "COVID \n", + "Post 0.877633 0.742063 0.565368 0.057143 0.0 \n", + "Pre 0.628571 0.722619 0.877381 0.000000 0.0 \n", "\n", - "[2 rows x 27 columns]" + "[2 rows x 32 columns]" ] }, - "execution_count": 40, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -2783,7 +2642,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 10, "metadata": { "scrolled": false }, @@ -2791,16 +2650,80 @@ { "data": { "text/plain": [ - "" + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "oa.drop(['record_id', 'age_group'], axis = 1).drop(['Sadness', 'Happiness', 'Stress', 'Rumination', 'Alcohol'], axis=1).groupby('COVID').mean().diff().plot.bar(figsize = (10, 10), width = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmEAAAJSCAYAAACLGxJIAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de7hXZYH//c8tGOLjgRKmRm2Cfh6C5JRbybRGPA1ZqVmmjTloBzup83t+Y401U/Hww8ka09+V+ozSCceMKMYms55xSrLGxtINIaBomOGAOSWQFI6EwP38wWYPEga2N97Afr2ui8vvWt/7u9b9/f7h9b7WWnutUmsNAADPrd1aTwAAoC8SYQAADYgwAIAGRBgAQAMiDACggf6tJ/CHGDx4cB06dGjraQAAbNXs2bOX1VqHbL5+p4ywoUOHprOzs/U0AAC2qpTy8JbWOx0JANCACAMAaECEAQA0sFNeEwYAbN1TTz2VpUuXZvXq1a2n0ifsscceOfDAA7P77rtv03gRBgC7qKVLl2bvvffO0KFDU0ppPZ1dWq01y5cvz9KlSzNs2LBt+ozTkQCwi1q9enX2228/AfYcKKVkv/32e1ZHHUUYAOzCBNhz59n+1iIMAKAB14QBQB8x9JJv9ur2Fl/2uq2OufTSS/OlL30p/fr1y2677Zbrrrsu48aN2/q2Fy/O61//+ixYsKA3prpDEmEAwHZx55135pZbbsmcOXMyYMCALFu2LGvWrGk9rR2G05EAwHbx6KOPZvDgwRkwYECSZPDgwdl///0zefLkHHHEETnssMNy/vnnp9aaJJk9e3ZGjx6d0aNH55prrunezrRp03L66adnwoQJOfjgg/PBD36w+71//dd/zVFHHZVXvOIVOeOMM7Jq1aokySWXXJIRI0Zk1KhRufjii5MkX/3qV3PYYYdl9OjRec1rXvNc/QzPSIQBANvFSSedlCVLluSQQw7J+973vnzve99LklxwwQW5++67s2DBgjz55JO55ZZbkiTnnXderrrqqtxzzz2/s625c+dmxowZmT9/fmbMmJElS5Zk2bJlmTJlSr7zne9kzpw56ejoyBVXXJHly5fna1/7Wu69997Mmzcvf/u3f5skmTx5cm699dbcc889ufnmm5+7H+IZiDAAYLvYa6+9Mnv27EydOjVDhgzJmWeemWnTpuW73/1uxo0bl5EjR2bWrFm599578/jjj+fxxx/vPkJ1zjnnPG1bxx9/fPbdd9/sscceGTFiRB5++OH88Ic/zH333Zejjz46Y8aMyfXXX5+HH364e9w73vGO3HTTTdlzzz2TJEcffXTOPffcfOYzn8m6deue899jc64JAwC2m379+uXYY4/Nsccem5EjR+a6667LvHnz0tnZmRe/+MWZNGnSNt1ba+MpzY3bXLt2bWqtOfHEEzN9+vTfGX/XXXfltttuy8yZM3P11Vdn1qxZufbaa/OjH/0o3/zmN3P44Ydn9uzZ2W+//Xr1+z4bjoQBANvFAw88kEWLFnUvz507N4ceemiSDdeHrVq1KjNnzkySDBo0KIMGDcodd9yRJLnxxhu3uv1XvvKV+cEPfpAHH3wwSfLEE0/kJz/5SVatWpWVK1fm5JNPzpVXXtl9evOnP/1pxo0bl8mTJ2fIkCFZsmRJr37fZ8uRMADoI7bllhK9adWqVbnwwgvz+OOPp3///jnooIMyderUDBo0KIcddlhe9KIX5Ygjjuge/4UvfCFvf/vbU0rJSSedtNXtDxkyJNOmTctb3/rW/Pa3v02STJkyJXvvvXdOPfXUrF69OrXWXHHFFUmSD3zgA1m0aFFqrTn++OMzevTo7fPFt1HZ+BcJO5OOjo7a2dnZehoAsENbuHBhhg8f3noafcqWfvNSyuxaa8fmY52OBABoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAA+4TBgB9xaR9e3l7K7c6ZK+99up+qHay4WHcnZ2dufrqq3t1KieffHK+9KUvZdCgQb263e1JhAEAO71vfetbrafwrDkdCQA08Y1vfCPjxo3L2LFjc8IJJ+QXv/hFkmTSpEk555xzctRRR+Xggw/OZz7zmSTJ7bffnte85jV53etel0MPPTTvec97sn79+iTJ0KFDs2zZsixevDjDhw/Pu971rrz85S/PSSedlCeffDLJhscWTZgwIYcffnhe/epX5/7770+SfPWrX81hhx2W0aNHdz9A/N57782RRx6ZMWPGZNSoUU97/FJvcSQMANhunnzyyYwZM6Z7ecWKFTnllFOSJMccc0x++MMfppSSz372s/nkJz+ZT33qU0mSefPm5Yc//GGeeOKJjB07Nq973YZHLt11112577778pKXvCQTJkzITTfdlDe/+c1P2+eiRYsyffr0fOYzn8lb3vKW/NM//VPe9ra35fzzz8+1116bgw8+OD/60Y/yvve9L7NmzcrkyZNz66235oADDsjjjz+eJLn22mvzl3/5lzn77LOzZs2arFu3rtd/GxEGAGw3AwcOzNy5c7uXN14TliRLly7NmWeemUcffTRr1qzJsGHDusedeuqpGThwYAYOHJjx48fnrrvuyqBBg3LkkUfmpS99aZLkrW99a+64447fibBhw4Z1h9/hhx+exYsXZ9WqVfn3f//3nHHGGd3jNj5v8uijj865556bt7zlLTn99NOTJEcddVQuvfTSLF26NKeffnoOPvjgXv9tnI4EAJq48MILc8EFF2T+/Pm57rrrsnr16u73SilPG7tx+ZnWb2rAgAHdr/v165e1a9dm/fr1GTRoUObOndv9b+HChUk2HPWaMmVKlixZksMPPzzLly/Pn//5n+fmm2/OwIEDc/LJJ2fWrFm99r03EmEAQBMrV67MAQcckCS5/vrrn/be17/+9axevTrLly/P7bffniOOOCLJhtORP/vZz7J+/frMmDEjxxxzzDbta5999smwYcPy1a9+NUlSa80999yTZMO1YuPGjcvkyZMzZMiQLFmyJA899FBe+tKX5qKLLsqpp56aefPm9dbX7uZ0JAD0FdtwS4nn0qRJk3LGGWfk+c9/fo477rj87Gc/635v1KhRGT9+fJYtW5aPfOQj2X///fOTn/wkRxxxRC644II8+OCDGT9+fN74xjdu8/5uvPHGvPe9782UKVPy1FNP5ayzzsro0aPzgQ98IIsWLUqtNccff3xGjx6dT3ziE7nhhhuy++6750UvelE+/OEP9/r3L7XWXt/o9tbR0VE3nk8GALZs4cKFGT58eOtpPGuTJk3KXnvtlYsvvvhp62+//fZcfvnlueWWWxrNbOu29JuXUmbXWjs2H+t0JABAA05HAgA7lEmTJm1x/bHHHptjjz32OZ3L9uRIGABAAyIMAKABEQYA0IAIAwBowIX5ANBHjLx+ZK9ub/7E+Vsdc+mll+ZLX/pS+vXrl9122y3XXXdd7rzzzpx//vnZc889e3U+OxsRBgBsF3feeWduueWWzJkzJwMGDMiyZcuyZs2anHnmmXnb2962xQhbt25d+vXr12C2zz2nIwGA7eLRRx/N4MGDu5/lOHjw4MycOTM///nPM378+IwfPz5Jstdee+Wv/uqvMnr06Nx555354he/mCOPPDJjxozJu9/97qxbty7r1q3Lueeem8MOOywjR47MlVdemST59Kc/nREjRmTUqFE566yzmn3XP4QIAwC2i5NOOilLlizJIYcckve973353ve+l4suuij7779/vvvd7+a73/1ukuSJJ57IuHHjcs8992S//fbLjBkz8oMf/CBz585Nv379cuONN2bu3Ll55JFHsmDBgsyfPz/nnXdekuSyyy7Lj3/848ybNy/XXntty6/7rIkwAGC72GuvvTJ79uxMnTo1Q4YMyZlnnplp06b9zrh+/frlTW96U5Lktttuy+zZs3PEEUdkzJgxue2227ofpv3QQw/lwgsvzL/8y79kn332SbLhGZNnn312vvjFL6Z//53rKquda7YAwE6lX79+3Xe6HzlyZK6//vrfGbPHHnt0XwdWa83EiRPz8Y9//HfG3XPPPbn11ltz7bXX5itf+Uo+//nP55vf/Ga+//3v5xvf+EYuvfTSzJ8/f6eJMUfCAIDt4oEHHsiiRYu6l+fOnZuXvOQl2XvvvfOb3/xmi585/vjjM3PmzPzyl79MkqxYsSIPP/xwli1blvXr1+dNb3pTpkyZkjlz5mT9+vVZsmRJxo8fn0984hNZuXJlVq1a9Zx8t96wc6QiANBj23JLid60atWqXHjhhXn88cfTv3//HHTQQZk6dWqmT5+eCRMmdF8btqkRI0ZkypQpOemkk7J+/frsvvvuueaaazJw4MCcd955Wb9+fZLk4x//eNatW5e3ve1tWblyZWqtueiiizJo0KDn9Dv2RKm1tp7Ds9bR0VE7OztbTwMAdmgLFy7M8OHDW0+jT9nSb15KmV1r7dh8rNORAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBowH3CAKCPWPiy3r1dxfD7F251TL9+/TJy5MisXbs2w4YNyw033NAr9/L66Ec/mte85jU54YQTnvVn586dm5///Oc5+eSTkyQ333xz7rvvvlxyySU9ntez4UgYALDdDBw4MHPnzs2CBQvyghe8INdcc02vbHfy5Ml/UIAlGyLsW9/6VvfyKaec8pwHWCLCAIDnyFFHHZVHHnkkSXLsscdm443Xly1blqFDhyZJpk2bltNOOy0nnnhihg4dmquvvjpXXHFFxo4dm1e+8pVZsWJFkuTcc8/NzJkzkyRDhw7Nxz72sbziFa/IyJEjc//99ydJ7rrrrhx11FEZO3ZsXvWqV+WBBx7ImjVr8tGPfjQzZszImDFjMmPGjEybNi0XXHBBkmTx4sU57rjjMmrUqBx//PH5j//4j+79XXTRRXnVq16Vl770pd377gkRBgBsd+vWrcttt92WU045ZatjFyxYkJtuuil33313/uZv/iZ77rlnfvzjH+eoo47KP/7jP27xM4MHD86cOXPy3ve+N5dffnmS5GUve1n+7d/+LT/+8Y8zefLkfPjDH87znve8TJ48OWeeeWbmzp2bM88882nbufDCCzNx4sTMmzcvZ599di666KLu9x599NHccccdueWWW3rlyJlrwgCA7ebJJ5/MmDFj8sgjj2T48OE58cQTt/qZ8ePHZ++9987ee++dfffdN294wxuSJCNHjsy8efO2+JnTTz89SXL44YfnpptuSpKsXLkyEydOzKJFi1JKyVNPPbXVfd95553dnz/nnHPywQ9+sPu90047LbvttltGjBiRX/ziF1vd1tY4EgYAbDcbrwl7+OGHU2vtviasf//+3Q/jXr169dM+M2DAgO7Xu+22W/fybrvtlrVr125xPxvH9OvXr3vMRz7ykYwfPz4LFizIN77xjd/Zz7O16bx649nbIgwA2O723HPPfPrTn86nPvWprF27NkOHDs3s2bOTpFeur9qSlStX5oADDkiy4Vqzjfbee+/85je/2eJnXvWqV+XLX/5ykuTGG2/Mq1/96u0yt8TpSADoM7bllhLb09ixYzNq1KhMnz49F198cd7ylrdk6tSped3rXrdd9vfBD34wEydOzJQpU562j/Hjx+eyyy7LmDFj8qEPfehpn7nqqqty3nnn5e///u8zZMiQfOELX9guc0uS0huH055rHR0ddeNfVAAAW7Zw4cIMH9679wbj99vSb15KmV1r7dh8rNORAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBowH3CAKCPuOY9s3p1e++/9rhtGvfP//zPeeMb35iFCxfmZS97WRYvXpzXv/71WbBgwbPe59ChQ9PZ2ZnBgwdv0/hp06als7MzV1999bPe1/bWK0fCSikTSikPlFIeLKX8zhMtSykDSikzut7/USll6Gbv/0kpZVUp5eLemA8AsOOYPn16jjnmmEyfPr31VHYoPY6wUkq/JNckeW2SEUneWkoZsdmwdyT5Va31oCRXJvnEZu9fkeT/6+lcAIAdy6pVq3LHHXfkc5/7XPfjgDa1bt26XHzxxTnssMMyatSoXHXVVUmS2267LWPHjs3IkSPz9re/Pb/97W+7P3PVVVflFa94RUaOHJn7778/SbJixYqcdtppGTVqVF75ylc+44O+dyS9cSTsyCQP1lofqrWuSfLlJKduNubUJNd3vZ6Z5PhSSkmSUsppSX6W5N5emAsAsAP5+te/ngkTJuSQQw7Jfvvt1/28yI2mTp2axYsXZ+7cuZk3b17OPvvsrF69Oueee25mzJiR+fPnZ+3atfmHf/iH7s8MHjw4c+bMyXvf+95cfvnlSZKPfexjGTt2bObNm5e/+7u/y1/8xV88p9/zD9EbEXZAkiWbLC/tWrfFMbXWtUlWJtmvlLJXkr9O8v9sbSellPNLKZ2llM7HHnusF6YNAGxv06dPz1lnnZUkOeuss37nlOR3vvOdvPvd707//hsuU3/BC16QBx54IMOGDcshhxySJJk4cWK+//3vd3/m9NNPT5IcfvjhWbx4cZLkjjvuyDnnnJMkOe6447J8+fL8+te/3q7fradaX5g/KcmVtdZVXQfGnlGtdWqSqcmGZ0du/6kBAD2xYsWKzJo1K/Pnz08pJevWrUspJe9///t7tN0BAwYkSfr165e1a9f2xlSb6I0jYY8kefEmywd2rdvimFJK/yT7JlmeZFyST5ZSFif5n0k+XEq5oBfmBAA0NnPmzJxzzjl5+OGHs3jx4ixZsiTDhg3LkiX/fQLtxBNPzHXXXdcdUytWrMihhx6axYsX58EHH0yS3HDDDfnTP/3T37uvV7/61bnxxhuTJLfffnsGDx6cffbZZzt9s97RG0fC7k5ycCllWDbE1llJ/nyzMTcnmZjkziRvTjKr1lqTvHrjgFLKpCSraq073t+QAsAuYFtvKdFbpk+fnr/+679+2ro3velN+fjHP969/M53vjM/+clPMmrUqOy+++5517velQsuuCBf+MIXcsYZZ2Tt2rU54ogj8p73vOf37mvSpEl5+9vfnlGjRmXPPffM9ddf/3vH7wjKhhbq4UZKOTnJ/0nSL8nna62XllImJ+mstd5cStkjyQ1JxiZZkeSsWutDm21jUjZE2OVb219HR0ft7Ozs8bwBYFe2cOHCDB8+vPU0+pQt/eallNm11o7Nx/bKNWG11m8l+dZm6z66yevVSc7YyjYm9cZcAAB2Bh5bBADQgAgDgF1Yb1x2xLZ5tr+1CAOAXdQee+yR5cuXC7HnQK01y5cvzx577LHNn2l9nzAAYDs58MADs3Tp0rjJ+XNjjz32yIEHHrjN40UYAOyidt999wwbNqz1NHgGTkcCADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAA70SYaWUCaWUB0opD5ZSLtnC+wNKKTO63v9RKWVo1/oTSymzSynzu/57XG/MBwBgR9fjCCul9EtyTZLXJhmR5K2llBGbDXtHkl/VWg9KcmWST3StX5bkDbXWkUkmJrmhp/MBANgZ9MaRsCOTPFhrfajWuibJl5OcutmYU5Nc3/V6ZpLjSyml1vrjWuvPu9bfm2RgKWVAL8wJAGCH1hsRdkCSJZssL+1at8Uxtda1SVYm2W+zMW9KMqfW+tst7aSUcn4ppbOU0vnYY4/1wrQBANrZIS7ML6W8PBtOUb77mcbUWqfWWjtqrR1Dhgx57iYHALAd9EaEPZLkxZssH9i1botjSin9k+ybZHnX8oFJvpbkL2qtP+2F+QAA7PB6I8LuTnJwKWVYKeV5Sc5KcvNmY27Ohgvvk+TNSWbVWmspZVCSbya5pNb6g16YCwDATqHHEdZ1jdcFSW5NsjDJV2qt95ZSJpdSTuka9rkk+5VSHkzyv5JsvI3FBUkOSvLRUsrcrn9/1NM5AQDs6EqttfUcnrWOjo7a2dnZehoAAFtVSplda+3YfP0OcWE+AEBfI8IAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABrolQgrpUwopTxQSnmwlHLJFt4fUEqZ0fX+j0opQzd570Nd6x8opfxZb8wHAGBH1+MIK6X0S3JNktcmGZHkraWUEZsNe0eSX9VaD0pyZZJPdH12RJKzkrw8yYQk/2/X9gAAdmm9cSTsyCQP1lofqrWuSfLlJKduNubUJNd3vZ6Z5PhSSula/+Va629rrT9L8mDX9gAAdmm9EWEHJFmyyfLSrnVbHFNrXZtkZZL9tvGzSZJSyvmllM5SSudjjz3WC9MGAGhnp7kwv9Y6tdbaUWvtGDJkSOvpAAD0SG9E2CNJXrzJ8oFd67Y4ppTSP8m+SZZv42cBAHY5vRFhdyc5uJQyrJTyvGy40P7mzcbcnGRi1+s3J5lVa61d68/q+uvJYUkOTnJXL8wJAGCH1r+nG6i1ri2lXJDk1iT9kny+1npvKWVyks5a681JPpfkhlLKg0lWZEOopWvcV5Lcl2RtkvfXWtf1dE4AADu6suGA1M6lo6OjdnZ2tp4GAMBWlVJm11o7Nl+/01yYDwCwKxFhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAANiDAAgAZEGABAAyIMAKABEQYA0IAIAwBoQIQBADQgwgAAGhBhAAAN9CjCSikvKKV8u5SyqOu/z3+GcRO7xiwqpUzsWrdnKeWbpZT7Syn3llIu68lcAAB2Jj09EnZJkttqrQcnua1r+WlKKS9I8rEk45IcmeRjm8Ta5bXWlyUZm+ToUsprezgfAICdQk8j7NQk13e9vj7JaVsY82dJvl1rXVFr/VWSbyeZUGv9r1rrd5Ok1romyZwkB/ZwPgAAO4WeRtgLa62Pdr3+zyQv3MKYA5Is2WR5ade6bqWUQUnekA1H07aolHJ+KaWzlNL52GOP9WzWAACN9d/agFLKd5K8aAtv/c2mC7XWWkqpz3YCpZT+SaYn+XSt9aFnGldrnZpkapJ0dHQ86/0AAOxIthphtdYTnum9UsovSil/XGt9tJTyx0l+uYVhjyQ5dpPlA5Pcvsny1CSLaq3/Z5tmDACwC+jp6cibk0zsej0xyde3MObWJCeVUp7fdUH+SV3rUkqZkmTfJP+zh/MAANip9DTCLktyYillUZITupZTSukopXw2SWqtK5L87yR3d/2bXGtdUUo5MBtOaY5IMqeUMreU8s4ezgcAYKdQat35Lq/q6OionZ2dracBALBVpZTZtdaOzde7Yz4AQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYV++/IMAAAdhSURBVAAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACgAREGANCACAMAaECEAQA0IMIAABoQYQAADYgwAIAGRBgAQAMiDACggR5FWCnlBaWUb5dSFnX99/nPMG5i15hFpZSJW3j/5lLKgp7MBQBgZ9LTI2GXJLmt1npwktu6lp+mlPKCJB9LMi7JkUk+tmmslVJOT7Kqh/MAANip9DTCTk1yfdfr65OctoUxf5bk27XWFbXWXyX5dpIJSVJK2SvJ/0oypYfzAADYqfQ0wl5Ya3206/V/JnnhFsYckGTJJstLu9Ylyf9O8qkk/7W1HZVSzi+ldJZSOh977LEeTBkAoL3+WxtQSvlOkhdt4a2/2XSh1lpLKXVbd1xKGZPkf9Ra/+9SytCtja+1Tk0yNUk6Ojq2eT8AADuirUZYrfWEZ3qvlPKLUsof11ofLaX8cZJfbmHYI0mO3WT5wCS3JzkqSUcpZXHXPP6olHJ7rfXYAADs4np6OvLmJBv/2nFikq9vYcytSU4qpTy/64L8k5LcWmv9h1rr/rXWoUmOSfITAQYA9BU9jbDLkpxYSlmU5ISu5ZRSOkopn02SWuuKbLj26+6uf5O71gEA9Fml1p3v8qqOjo7a2dnZehoAAFtVSplda+3YfL075gMANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGhAhAEANCDCAAAaEGEAAA2IMACABkqttfUcnrVSymNJHm49D2CXMzjJstaTAHY5L6m1Dtl85U4ZYQDbQymls9ba0XoeQN/gdCQAQAMiDACgAREG8N+mtp4A0He4JgwAoAFHwgAAGhBhAAANiDAAgAZEGABAAyIM6PNKKS8ppZzQ9XpgKWXv1nMCdn0iDOjTSinvSjIzyXVdqw5M8s/tZgT0FSIM6Oven+ToJL9OklrroiR/1HRGQJ8gwoC+7re11jUbF0op/ZO4gSKw3YkwoK/7Xinlw0kGllJOTPLVJN9oPCegD3DHfKBPK6WUJO9MclKSkuTWJJ+t/ucIbGciDOizSin9ktxba31Z67kAfY/TkUCfVWtdl+SBUsqftJ4L0Pf0bz0BgMaen+TeUspdSZ7YuLLWekq7KQF9gQgD+rqPtJ4A0DeJMKBPKqXskeQ9SQ5KMj/J52qta9vOCuhLXJgP9EmllBlJnkryb0lem+ThWutftp0V0JeIMKBPKqXMr7WO7HrdP8ldtdZXNJ4W0If460igr3pq4wunIYEWHAkD+qRSyrr8919DliQDk/xX1+taa92n1dyAvkGEAQA04HQkAEADIgwAoAERBuxSSikvKqV8uZTy01LK7FLKt0oph5RSXl5KmVVKeaCUsqiU8pGywZ+WUu7cbBv9Sym/KKXsX0qZVkp5c9f627s+P6+Ucn8p5epSyqA23xTY2YkwYJdRSilJvpbk9lrr/6i1Hp7kQ0lemOTmJJfVWg9NMjrJq5K8LxvuE3ZgKeUlm2zqhGx4sPfPt7Cbs2uto5KMSvLbJF/fbl8I2KWJMGBXMj7JU7XWazeuqLXek+SQJD+otf5r17r/SnJBkktqreuTfCXJWZts56wk03/fjmqta5J8MMmflFJG9+q3APoEEQbsSg5LMnsL61+++fpa60+T7FVK2ScbguusJCmlDEhycpJ/2trOaq3rktyT5GU9mzbQF3l2JNDn1Vo7Syl7lVIOTTI8yY9qrSu28eNlO04N2IWJMGBXcm+SN29h/X1JXrPpilLKS5OsqrX+umvVxqNhw7OVU5GbbKNfkpFJFv6hEwb6LqcjgV3JrCQDSinnb1xRShmV5IEkx5RSTuhaNzDJp5N8cpPPTk/ytiTHZRsuti+l7J7k40mW1Frn9do3APoMEQbsMuqGR4C8MckJXbeouDcbQuk/k5ya5G9LKQ8kmZ/k7iRXb/LZhdnwGKNZtdYnfmfj/+3GUsq8JAuS/F9d2wV41jy2CACgAUfCAAAaEGEAAA2IMACABkQYAEADIgwAoAERBgDQgAgDAGjg/wfLFFKSOw+FzAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "ya.drop(['record_id', 'age_group'], axis = 1).filter(['Sadness', 'Happiness', 'Stress', 'Rumination', 'Alcohol', 'COVID']).groupby('COVID').mean().diff().plot.bar(figsize = (10, 10), width = 5)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" ] }, - "execution_count": 41, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -2812,12 +2735,19 @@ } ], "source": [ - "oa.drop(['record_id', 'age_group'], axis = 1).groupby('COVID').mean().diff().plot.bar(figsize = (10, 10), width = 5)" + "oa.drop(['record_id', 'age_group'], axis = 1).filter(['Sadness', 'Happiness', 'Stress', 'Rumination', 'Alcohol', 'COVID']).groupby('COVID').mean().diff().plot.bar(figsize = (10, 10), width = 5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Rest-activity measures" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -2832,8 +2762,10 @@ }, { "cell_type": "code", - "execution_count": 88, - "metadata": {}, + "execution_count": 14, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -2883,63 +2815,111 @@ " \n", " 0\n", " 10011\n", - " 1.498280e-01\n", - " 1.273941e+00\n", - " 0.485009\n", - " -103.793422\n", - " 1.934184\n", - " 5.499584e-03\n", - " 1.512651e+00\n", - " 0.575390\n", - " -8.891799\n", - " ...\n", - " -3.061485e-04\n", - " 1.579498e+00\n", - " 0.569379\n", - " -8.586889\n", - " 1.971324\n", - " 1.140916e+00\n", - " -4.261664e+00\n", - " -14.074745\n", - " -22.251637\n", - " -52.500316\n", + " 2.432565\n", + " -2.447323\n", + " 14.409872\n", + " 21.201700\n", + " 92.880844\n", + " 1.048527\n", + " 1.820719\n", + " 0.768953\n", + " -14.117220\n", + " ...\n", + " 1.138832\n", + " 1.751524\n", + " 0.769270\n", + " -13.078016\n", + " 2.640273\n", + " 1.224985\n", + " 1.679375\n", + " 0.771681\n", + " -13.104473\n", + " 2.647754\n", " \n", " \n", " 1\n", " 10012\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " ...\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", + " 1.378764\n", + " 1.292044\n", + " -0.678648\n", + " 27.546799\n", + " -7.280237\n", + " 1.474886\n", + " 0.934578\n", + " 6.984927\n", + " -9.156320\n", + " ...\n", + " 2.125595\n", + " 0.341217\n", + " 4.515416\n", + " -8.367047\n", + " -9.001245\n", + " 1.176810\n", + " 1.344468\n", + " 5.442158\n", + " -8.101281\n", + " -18.069600\n", " \n", " \n", " 2\n", " 10014\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.883334\n", + " 1.900828\n", + " -0.674685\n", + " 5.680145\n", + " -7.491036\n", + " 1.253748\n", + " 1.560074\n", + " -0.634767\n", + " 8.827035\n", + " ...\n", + " 1.720730\n", + " 0.728035\n", + " 4.629720\n", + " -9.518540\n", + " -9.511485\n", + " 1.892944\n", + " 0.626165\n", + " 6.185474\n", + " -6.415972\n", + " -12.150579\n", + " \n", + " \n", + " 3\n", + " 10016\n", + " 1.468775\n", + " 1.524313\n", + " 0.713096\n", + " -4.830436\n", + " 2.861393\n", + " 1.876456\n", + " 1.110198\n", + " 0.638584\n", + " -8.346138\n", + " ...\n", + " 1.986456\n", + " 1.000151\n", + " 0.653496\n", + " -11.215384\n", + " 2.878217\n", + " 2.006809\n", + " 1.019504\n", + " 0.647388\n", + " -9.535801\n", + " 2.887949\n", + " \n", + " \n", + " 4\n", + " 10023\n", + " 1.557981\n", + " 1.316398\n", + " -0.847699\n", + " 30.328659\n", + " -6.785045\n", + " 1.623585\n", + " 1.262882\n", + " -0.854330\n", + " 25.440830\n", " ...\n", " NaN\n", " NaN\n", @@ -2953,311 +2933,215 @@ " NaN\n", " \n", " \n", - " 3\n", - " 10016\n", - " 3.089956e-03\n", - " 1.573217e+00\n", - " 0.507209\n", - " -5.369870\n", - " -21.561872\n", - " -4.445964e-02\n", - " 1.728003e+00\n", - " 0.532648\n", - " -5.114050\n", - " ...\n", - " -5.975025e-02\n", - " 1.763454e+00\n", - " 0.529335\n", - " -4.901354\n", - " 2.589463\n", - " -5.975025e-02\n", - " 1.763454e+00\n", - " 0.529335\n", - " -4.901354\n", - " 2.589463\n", - " \n", - " \n", - " 4\n", - " 10023\n", - " -4.162423e-01\n", - " 1.898317e+00\n", - " -0.829578\n", - " 7.660312\n", - " -6.727331\n", - " -2.373019e+00\n", - " 3.958145e+00\n", - " -1.102268\n", - " 4.176345\n", - " ...\n", - " -5.666754e+00\n", - " 7.281475e+00\n", - " -1.363325\n", - " 3.485568\n", - " -6.529643\n", - " -1.182390e-01\n", - " 1.724487e+00\n", - " -0.818430\n", - " 10.443968\n", - " -6.709902\n", - " \n", - " \n", " 5\n", " 10024\n", - " 9.391136e-02\n", - " 1.407384e+00\n", - " -0.730184\n", - " 80.651553\n", - " -6.498182\n", - " -2.853713e-02\n", - " 1.599325e+00\n", - " -0.769046\n", - " 15.164640\n", - " ...\n", - " -4.042464e-02\n", - " 1.662724e+00\n", - " -0.762861\n", - " 13.656660\n", - " -6.718875\n", - " -3.453266e-02\n", - " 1.684204e+00\n", - " -0.760088\n", - " 13.661519\n", - " -6.728423\n", + " 3.036926\n", + " -0.401042\n", + " 12.349571\n", + " -7.930544\n", + " -35.583343\n", + " 1.434901\n", + " 1.531952\n", + " 0.845901\n", + " -17.390933\n", + " ...\n", + " 1.456431\n", + " 1.527021\n", + " 0.850317\n", + " -16.523697\n", + " 5.405994\n", + " 1.529499\n", + " 1.468530\n", + " 0.845736\n", + " -15.776267\n", + " 5.388757\n", " \n", " \n", " 6\n", " 10025\n", - " 2.060434e-01\n", - " 1.358972e+00\n", - " -0.480184\n", - " 8.222317\n", - " -4.853813\n", - " 2.529416e-01\n", - " 1.323455e+00\n", - " -0.508819\n", - " 13.341673\n", - " ...\n", - " 2.263066e-01\n", - " 1.410208e+00\n", - " -0.531714\n", - " 10.994653\n", - " -4.766890\n", - " -2.993769e+00\n", - " 4.729876e+00\n", - " -1.199374\n", - " 2.857966\n", - " -5.489378\n", + " 0.887890\n", + " 2.091595\n", + " -0.885842\n", + " 21.945144\n", + " -30.027998\n", + " 1.067901\n", + " 1.919542\n", + " -0.886590\n", + " 29.439124\n", + " ...\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " -50.762123\n", + " 53.842955\n", + " 1.617283\n", + " -5.565424\n", + " -17.863623\n", " \n", " \n", " 7\n", " 10033\n", - " 1.536080e+00\n", - " -1.484628e+00\n", - " -0.581124\n", - " -65.531039\n", - " -9.599399\n", - " 1.549015e+00\n", - " -1.497881e+00\n", - " -0.582442\n", - " -55.572184\n", - " ...\n", - " 1.615447e+00\n", - " -1.563355e+00\n", - " -0.580480\n", - " -51.471342\n", - " -9.587446\n", - " 5.408549e-02\n", - " 1.601614e+00\n", - " 0.584732\n", - " -48.973293\n", - " 2.387816\n", + " 1.242333\n", + " 1.568933\n", + " 0.639032\n", + " -30.826566\n", + " 2.462808\n", + " 1.358338\n", + " 1.456933\n", + " 0.639890\n", + " -35.834795\n", + " ...\n", + " 1.489933\n", + " 0.957407\n", + " 9.759133\n", + " -8.789658\n", + " 1.573778\n", + " 5.134583\n", + " -2.655075\n", + " 18.210916\n", + " -13.173022\n", + " 7.915980\n", " \n", " \n", " 8\n", " 10035\n", - " 1.088797e-01\n", - " 1.349586e+00\n", - " -0.613020\n", - " 252.822366\n", - " -6.871241\n", - " 1.257789e-01\n", - " 1.463653e+00\n", - " -0.610337\n", - " 440.765781\n", - " ...\n", - " 1.293256e-01\n", - " 1.496312e+00\n", - " -0.610180\n", - " 440.777116\n", - " -6.864791\n", - " 1.332177e-01\n", - " 1.540560e+00\n", - " 0.609982\n", - " -440.856547\n", - " -18.864421\n", + " 1.130020\n", + " 1.765778\n", + " -0.724800\n", + " 185.332528\n", + " -6.824674\n", + " 1.200380\n", + " 1.758045\n", + " -0.729250\n", + " 68.432426\n", + " ...\n", + " 1.302437\n", + " 1.670913\n", + " -0.730694\n", + " 55.758243\n", + " -6.798061\n", + " 1.373475\n", + " 1.609496\n", + " -0.729089\n", + " 69.585766\n", + " -6.793869\n", " \n", " \n", " 9\n", " 10038\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 1.635671e-01\n", - " 1.277282e+00\n", - " -0.626480\n", - " 387.089882\n", - " ...\n", - " 1.470486e+00\n", - " -1.278021e+00\n", - " -0.627187\n", - " -1511.220750\n", - " -8.015321\n", - " 2.093756e-01\n", - " 1.284383e+00\n", - " -0.646601\n", - " 183.023943\n", - " -7.898776\n", + " 2.895722\n", + " -0.777806\n", + " -0.690728\n", + " -13.005098\n", + " -8.466495\n", + " 2.170354\n", + " 0.755679\n", + " 0.692503\n", + " -20.868824\n", + " ...\n", + " 2.932025\n", + " -0.599292\n", + " -0.653876\n", + " -100.123668\n", + " -8.070665\n", + " 2.349814\n", + " 0.595015\n", + " 0.670183\n", + " -130.757799\n", + " 4.026063\n", " \n", " \n", " 10\n", " 10040\n", - " 9.654419e-02\n", - " 1.510475e+00\n", - " -0.536578\n", - " 37.418342\n", - " -7.110018\n", - " 9.853208e-02\n", - " 1.545742e+00\n", - " -0.533701\n", - " 35.400726\n", - " ...\n", - " 9.826283e-02\n", - " 1.574103e+00\n", - " -0.531625\n", - " 33.886660\n", - " -7.119768\n", - " 9.929714e-02\n", - " 1.587373e+00\n", - " -0.549218\n", - " 62.810948\n", - " -7.071323\n", + " -3.401144\n", + " 6.391208\n", + " 1.115683\n", + " -5.202940\n", + " -17.753858\n", + " -4.934099\n", + " 7.939505\n", + " 1.208165\n", + " -4.752587\n", + " ...\n", + " -1.186910\n", + " 4.205626\n", + " 1.019116\n", + " -5.086760\n", + " -17.844257\n", + " -4.873827\n", + " 7.908448\n", + " 1.245725\n", + " -4.421485\n", + " -17.844574\n", " \n", " \n", " 11\n", " 10045\n", - " 2.230497e-03\n", - " 1.362506e+00\n", - " -0.546018\n", - " 10.191411\n", - " -5.965898\n", - " 5.863094e-02\n", - " 1.396463e+00\n", - " -0.618115\n", - " 121.397729\n", - " ...\n", - " 5.648553e-02\n", - " 1.483012e+00\n", - " -0.622768\n", - " 61.569724\n", - " -5.515466\n", - " 5.964428e-02\n", - " 1.526655e+00\n", - " -0.620661\n", - " 54.901056\n", - " -5.518533\n", + " 0.936148\n", + " 1.891692\n", + " -0.738042\n", + " 7.228794\n", + " -6.131985\n", + " 1.705239\n", + " 1.160109\n", + " -0.643770\n", + " 53.934596\n", + " ...\n", + " 1.693932\n", + " 1.201932\n", + " 0.676174\n", + " -18.553951\n", + " -17.567710\n", + " 1.761701\n", + " 1.148013\n", + " 0.665370\n", + " -21.600841\n", + " -17.546436\n", " \n", " \n", " 12\n", " 10049\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " ...\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", + " 0.913626\n", + " 1.923249\n", + " 0.887175\n", + " -121.373865\n", + " -18.633138\n", + " 2.325314\n", + " 0.233009\n", + " 4.233220\n", + " -9.217501\n", + " ...\n", + " -0.437034\n", + " 3.067061\n", + " 5.422966\n", + " -14.103322\n", + " -8.309635\n", + " 2.871435\n", + " -1.804360\n", + " -0.927371\n", + " -96.002515\n", + " -7.060955\n", " \n", " \n", " 13\n", " 10062\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 4.143237e-01\n", - " 9.774066e-01\n", - " 0.705131\n", - " -378.089421\n", - " ...\n", - " 4.678555e-01\n", - " 9.885927e-01\n", - " 0.621269\n", - " -435.689510\n", - " 2.686489\n", - " 4.788005e-01\n", - " 1.024258e+00\n", - " 0.621045\n", - " -404.652634\n", - " 2.686727\n", - " \n", - " \n", - " 14\n", - " 10076\n", - " 1.642263e+00\n", - " -1.509251e+00\n", - " 0.013360\n", - " -6.704104\n", - " -9.864119\n", - " 1.699240e+00\n", - " -1.632855e+00\n", - " -0.059402\n", - " -4.592369\n", - " ...\n", - " 1.720189e+00\n", - " -1.701182e+00\n", - " -0.117497\n", - " -4.311277\n", - " -9.523047\n", - " 1.765729e+00\n", - " -1.786049e+00\n", - " -0.147384\n", - " -3.900697\n", - " -9.437700\n", - " \n", - " \n", - " 15\n", - " 10139\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " -8322.236717\n", + " 8325.057546\n", + " 1.775532\n", + " -10.982247\n", + " 2.574043\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " ...\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " -4168.940442\n", + " 4171.805933\n", + " 1.810182\n", + " -9.801077\n", + " 2.611993\n", " NaN\n", " NaN\n", " NaN\n", @@ -3265,434 +3149,398 @@ " NaN\n", " \n", " \n", - " 16\n", + " 14\n", + " 20076\n", + " 1.526371\n", + " 0.567259\n", + " 6.020799\n", + " -6.607788\n", + " -6.765901\n", + " -0.482320\n", + " 2.623988\n", + " 7.790539\n", + " -6.950773\n", + " ...\n", + " 1.763587\n", + " 0.416798\n", + " 7.866024\n", + " -10.307468\n", + " -3.782279\n", + " 0.860242\n", + " 1.358709\n", + " 4.930827\n", + " -7.485486\n", + " -1.036203\n", + " \n", + " \n", + " 15\n", " 20103\n", - " 1.567005e+00\n", - " -1.486232e+00\n", - " -0.515298\n", - " -20.879761\n", - " -10.015067\n", - " 1.569310e+00\n", - " -1.488544e+00\n", - " -0.514997\n", - " -20.815028\n", - " ...\n", - " 1.094885e-01\n", - " 1.536120e+00\n", - " 0.506885\n", - " -19.649729\n", - " 1.983796\n", - " 1.138180e-01\n", - " 1.582129e+00\n", - " 0.504111\n", - " -18.689214\n", - " -22.027810\n", + " 1.132446\n", + " 1.701162\n", + " 0.579959\n", + " -92.050824\n", + " 1.871446\n", + " 2.364058\n", + " -6.744281\n", + " -11.162305\n", + " -3.139133\n", + " ...\n", + " 1.363524\n", + " 1.502704\n", + " 0.574372\n", + " -83.887816\n", + " 1.860763\n", + " 1.420190\n", + " 1.462180\n", + " 0.571645\n", + " -88.417981\n", + " 1.848547\n", " \n", " \n", - " 17\n", + " 16\n", " 20105\n", - " -7.937666e-02\n", - " 1.856535e+00\n", - " 0.519655\n", - " -7.387269\n", - " 1.607532\n", - " 1.218083e+00\n", - " -5.312664e+00\n", - " -17.116577\n", - " -29.692282\n", - " ...\n", - " 1.288374e+00\n", - " -8.204300e+00\n", - " -12.349581\n", - " -22.831074\n", - " -12.545450\n", - " 1.857181e+00\n", - " -1.814990e+00\n", - " -0.577335\n", - " -22.553110\n", - " -10.275631\n", + " 0.082219\n", + " 2.380384\n", + " 11.625227\n", + " -7.667272\n", + " 21.079234\n", + " 0.867993\n", + " 2.067560\n", + " 0.783241\n", + " -398.029004\n", + " ...\n", + " 3.125222\n", + " -0.597005\n", + " 7.315936\n", + " -6.932374\n", + " 38.172156\n", + " 0.964368\n", + " 2.052078\n", + " 0.754236\n", + " -24.539640\n", + " 2.280103\n", " \n", " \n", - " 18\n", + " 17\n", " 20108\n", - " 3.379677e+03\n", - " -3.379479e+03\n", - " -4.350228\n", - " 2.418493\n", - " -21.326018\n", + " 1.342009\n", + " 0.924136\n", + " 7.100368\n", + " -7.310077\n", + " 0.739958\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " ...\n", - " 1.059081e+00\n", - " -7.396861e-01\n", - " -0.274338\n", - " 467.999524\n", - " 1.020176\n", - " 1.094692e+00\n", - " -7.363745e-01\n", - " -0.298258\n", - " 515.253206\n", - " 0.946826\n", + " 1.237593\n", + " 1.335523\n", + " 0.860568\n", + " -8.846168\n", + " 4.625016\n", + " 1.571529\n", + " 1.010569\n", + " 0.816653\n", + " -12.261027\n", + " 4.804126\n", " \n", " \n", - " 19\n", + " 18\n", " 20113\n", - " 1.427139e+00\n", - " -1.581861e+00\n", - " 0.143567\n", - " 2.257930\n", - " 1.442885\n", - " 1.369031e+00\n", - " -1.434061e+00\n", - " 0.192200\n", - " 2.892573\n", - " ...\n", - " 1.300959e+00\n", - " -1.245515e+00\n", - " -0.278575\n", - " -5.405110\n", - " -10.081652\n", - " 1.363998e+00\n", - " -1.284790e+00\n", - " -0.271716\n", - " -5.661094\n", - " -10.095691\n", + " 1.440838\n", + " 1.338084\n", + " 0.578272\n", + " -35.989451\n", + " 1.813847\n", + " 1.593704\n", + " 1.222583\n", + " 0.558698\n", + " -22.842250\n", + " ...\n", + " 1.683488\n", + " 1.155345\n", + " 0.542743\n", + " -19.349388\n", + " 1.837730\n", + " 1.774703\n", + " 1.083588\n", + " 0.539876\n", + " -14.428132\n", + " 1.805983\n", " \n", " \n", - " 20\n", + " 19\n", " 20115\n", - " 5.958383e-02\n", - " 8.187173e-01\n", - " 6.186292\n", - " -5.982511\n", - " -8.690442\n", - " 6.267755e-01\n", - " 2.928533e-01\n", - " 9.714231\n", - " -10.807681\n", - " ...\n", - " 1.696491e+00\n", - " -7.468483e-01\n", - " 8.737649\n", - " -9.050064\n", - " 0.627744\n", - " 1.679336e+00\n", - " -1.622530e+00\n", - " -0.220805\n", - " -2.668178\n", - " -10.031367\n", + " 1.488548\n", + " 1.306056\n", + " 0.465118\n", + " -48.329954\n", + " 3.090200\n", + " -2.941540\n", + " 5.325181\n", + " 14.573312\n", + " -19.938178\n", + " ...\n", + " 2.825312\n", + " -1.143046\n", + " 0.468917\n", + " 104.413972\n", + " -116.939255\n", + " 1.724968\n", + " 1.106933\n", + " 0.533558\n", + " -462.829431\n", + " 2.804946\n", " \n", " \n", - " 21\n", + " 20\n", " 20120\n", - " 1.273591e+00\n", - " -1.148784e+00\n", - " 0.239461\n", - " 925.237196\n", - " 1.184746\n", - " 1.309567e-01\n", - " 1.249188e+00\n", - " 0.239673\n", - " -571.445836\n", - " ...\n", - " 1.454657e+00\n", - " -1.319582e+00\n", - " -0.239615\n", - " -930.751592\n", - " -10.817235\n", - " 1.091430e+00\n", - " -1.592007e-01\n", - " 6.139185\n", - " -6.065396\n", - " -16.633912\n", + " 1.218679\n", + " 1.321886\n", + " 0.543107\n", + " -459.968901\n", + " 2.400240\n", + " 1.333574\n", + " 1.223772\n", + " 0.544728\n", + " -440.463143\n", + " ...\n", + " 1.422815\n", + " 1.156894\n", + " 0.544543\n", + " -459.462711\n", + " 2.408327\n", + " 1.477648\n", + " 1.134205\n", + " 0.544053\n", + " -459.572786\n", + " 2.407815\n", " \n", " \n", - " 22\n", + " 21\n", " 20122\n", - " 1.065194e-01\n", - " 1.508556e+00\n", - " 0.484770\n", - " -5.088845\n", - " 2.537389\n", - " 6.764635e-02\n", - " 1.630374e+00\n", - " 0.509933\n", - " -4.886715\n", - " ...\n", - " 3.029815e-02\n", - " 1.716570e+00\n", - " 0.542068\n", - " -4.479368\n", - " 2.769676\n", - " 4.148404e-02\n", - " 1.725604e+00\n", - " 0.560755\n", - " -4.492102\n", - " 2.855212\n", + " 5.369195\n", + " -2.870833\n", + " 11.412373\n", + " -16.568019\n", + " -22.413881\n", + " -5.545094\n", + " 8.413067\n", + " 1.518012\n", + " -3.234838\n", + " ...\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " -143.881542\n", + " 146.774580\n", + " 2.541702\n", + " -3.111851\n", + " 3.640661\n", " \n", " \n", - " 23\n", + " 22\n", " 20123\n", - " -3.938996e-02\n", - " 1.878928e+00\n", - " 0.299135\n", - " -5.945061\n", - " 2.320582\n", - " -5.626900e-02\n", - " 1.911264e+00\n", - " 0.316051\n", - " -5.701098\n", - " ...\n", - " -3.524171e-02\n", - " 1.891440e+00\n", - " 0.332600\n", - " -6.514964\n", - " 2.285575\n", - " -1.400653e-02\n", - " 1.864330e+00\n", - " 0.348856\n", - " -7.681337\n", - " 2.322318\n", + " 0.920480\n", + " 1.917277\n", + " 0.484341\n", + " -13.290076\n", + " 2.815197\n", + " 1.047557\n", + " 1.808673\n", + " -0.477010\n", + " 13.519638\n", + " ...\n", + " 1.103467\n", + " 1.774092\n", + " 0.490255\n", + " -12.957627\n", + " 2.703866\n", + " 1.185442\n", + " 1.704768\n", + " 0.486392\n", + " -12.929933\n", + " 2.672762\n", " \n", " \n", - " 24\n", + " 23\n", " 20124\n", - " 1.361959e-02\n", - " 1.482281e+00\n", - " 0.436845\n", - " -13.777923\n", - " 2.703122\n", - " 4.390732e-02\n", - " 1.489792e+00\n", - " 0.499192\n", - " -46.508500\n", - " ...\n", - " 4.777285e-02\n", - " 1.514942e+00\n", - " 0.496688\n", - " -42.430132\n", - " 2.542145\n", - " 4.505044e-02\n", - " 1.567154e+00\n", - " 0.491314\n", - " -33.275463\n", - " 2.513901\n", + " 0.862030\n", + " 1.897321\n", + " -0.544459\n", + " 27.870454\n", + " 14.891195\n", + " 1.550722\n", + " 0.695251\n", + " 7.151361\n", + " -9.313397\n", + " ...\n", + " 3.026270\n", + " -0.717050\n", + " 5.827807\n", + " -8.990460\n", + " 3.092604\n", + " 1.319514\n", + " 1.523231\n", + " 0.551828\n", + " -24.636007\n", + " 2.707138\n", " \n", " \n", - " 25\n", + " 24\n", " 20125\n", - " 2.077439e-01\n", - " 1.361577e+00\n", - " 0.213287\n", - " -6.025082\n", - " 2.343538\n", - " -1.336959e-01\n", - " 1.799307e+00\n", - " 0.466993\n", - " -3.477303\n", - " ...\n", - " -2.551225e-01\n", - " 1.946941e+00\n", - " -0.564769\n", - " 3.865575\n", - " -8.799264\n", - " -1.565747e-01\n", - " 1.873835e+00\n", - " 0.538828\n", - " -4.055396\n", - " 3.219966\n", - " \n", - " \n", - " 26\n", - " 20127\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " ...\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", - " \n", - " \n", - " 27\n", - " 20129\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " ...\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1.346618\n", + " 1.351780\n", + " 0.740786\n", + " -27.399960\n", + " 4.010187\n", + " 1.508629\n", + " 1.230524\n", + " 0.713775\n", + " -17.115975\n", + " ...\n", + " 1.521717\n", + " 1.250673\n", + " 0.699904\n", + " -11.619732\n", + " -20.041456\n", + " 0.764678\n", + " 2.044402\n", + " 0.940041\n", + " -5.034099\n", + " 4.399277\n", " \n", " \n", "\n", - "

28 rows × 21 columns

\n", + "

25 rows × 21 columns

\n", "" ], "text/plain": [ - " Unnamed: 0 actmin_7 amp_7 alpha_7 beta_7 phi_7 \\\n", - "0 10011 1.498280e-01 1.273941e+00 0.485009 -103.793422 1.934184 \n", - "1 10012 -6.410901e+00 8.866697e+00 -2.262784 0.748250 -7.154961 \n", - "2 10014 NaN NaN NaN NaN NaN \n", - "3 10016 3.089956e-03 1.573217e+00 0.507209 -5.369870 -21.561872 \n", - "4 10023 -4.162423e-01 1.898317e+00 -0.829578 7.660312 -6.727331 \n", - "5 10024 9.391136e-02 1.407384e+00 -0.730184 80.651553 -6.498182 \n", - "6 10025 2.060434e-01 1.358972e+00 -0.480184 8.222317 -4.853813 \n", - "7 10033 1.536080e+00 -1.484628e+00 -0.581124 -65.531039 -9.599399 \n", - "8 10035 1.088797e-01 1.349586e+00 -0.613020 252.822366 -6.871241 \n", - "9 10038 NaN NaN NaN NaN NaN \n", - "10 10040 9.654419e-02 1.510475e+00 -0.536578 37.418342 -7.110018 \n", - "11 10045 2.230497e-03 1.362506e+00 -0.546018 10.191411 -5.965898 \n", - "12 10049 6.262768e-41 2.395130e-40 1.000000 1.000000 1.000000 \n", - "13 10062 NaN NaN NaN NaN NaN \n", - "14 10076 1.642263e+00 -1.509251e+00 0.013360 -6.704104 -9.864119 \n", - "15 10139 NaN NaN NaN NaN NaN \n", - "16 20103 1.567005e+00 -1.486232e+00 -0.515298 -20.879761 -10.015067 \n", - "17 20105 -7.937666e-02 1.856535e+00 0.519655 -7.387269 1.607532 \n", - "18 20108 3.379677e+03 -3.379479e+03 -4.350228 2.418493 -21.326018 \n", - "19 20113 1.427139e+00 -1.581861e+00 0.143567 2.257930 1.442885 \n", - "20 20115 5.958383e-02 8.187173e-01 6.186292 -5.982511 -8.690442 \n", - "21 20120 1.273591e+00 -1.148784e+00 0.239461 925.237196 1.184746 \n", - "22 20122 1.065194e-01 1.508556e+00 0.484770 -5.088845 2.537389 \n", - "23 20123 -3.938996e-02 1.878928e+00 0.299135 -5.945061 2.320582 \n", - "24 20124 1.361959e-02 1.482281e+00 0.436845 -13.777923 2.703122 \n", - "25 20125 2.077439e-01 1.361577e+00 0.213287 -6.025082 2.343538 \n", - "26 20127 1.126017e+00 -1.114323e+00 0.423147 13.870503 2.504065 \n", - "27 20129 NaN NaN NaN NaN NaN \n", + " Unnamed: 0 actmin_7 amp_7 alpha_7 beta_7 phi_7 \\\n", + "0 10011 2.432565 -2.447323 14.409872 21.201700 92.880844 \n", + "1 10012 1.378764 1.292044 -0.678648 27.546799 -7.280237 \n", + "2 10014 0.883334 1.900828 -0.674685 5.680145 -7.491036 \n", + "3 10016 1.468775 1.524313 0.713096 -4.830436 2.861393 \n", + "4 10023 1.557981 1.316398 -0.847699 30.328659 -6.785045 \n", + "5 10024 3.036926 -0.401042 12.349571 -7.930544 -35.583343 \n", + "6 10025 0.887890 2.091595 -0.885842 21.945144 -30.027998 \n", + "7 10033 1.242333 1.568933 0.639032 -30.826566 2.462808 \n", + "8 10035 1.130020 1.765778 -0.724800 185.332528 -6.824674 \n", + "9 10038 2.895722 -0.777806 -0.690728 -13.005098 -8.466495 \n", + "10 10040 -3.401144 6.391208 1.115683 -5.202940 -17.753858 \n", + "11 10045 0.936148 1.891692 -0.738042 7.228794 -6.131985 \n", + "12 10049 0.913626 1.923249 0.887175 -121.373865 -18.633138 \n", + "13 10062 -8322.236717 8325.057546 1.775532 -10.982247 2.574043 \n", + "14 20076 1.526371 0.567259 6.020799 -6.607788 -6.765901 \n", + "15 20103 1.132446 1.701162 0.579959 -92.050824 1.871446 \n", + "16 20105 0.082219 2.380384 11.625227 -7.667272 21.079234 \n", + "17 20108 1.342009 0.924136 7.100368 -7.310077 0.739958 \n", + "18 20113 1.440838 1.338084 0.578272 -35.989451 1.813847 \n", + "19 20115 1.488548 1.306056 0.465118 -48.329954 3.090200 \n", + "20 20120 1.218679 1.321886 0.543107 -459.968901 2.400240 \n", + "21 20122 5.369195 -2.870833 11.412373 -16.568019 -22.413881 \n", + "22 20123 0.920480 1.917277 0.484341 -13.290076 2.815197 \n", + "23 20124 0.862030 1.897321 -0.544459 27.870454 14.891195 \n", + "24 20125 1.346618 1.351780 0.740786 -27.399960 4.010187 \n", "\n", - " actmin_8 amp_8 alpha_8 beta_8 ... actmin_9 \\\n", - "0 5.499584e-03 1.512651e+00 0.575390 -8.891799 ... -3.061485e-04 \n", - "1 -6.410901e+00 8.866697e+00 -2.262784 0.748250 ... -6.410901e+00 \n", - "2 NaN NaN NaN NaN ... NaN \n", - "3 -4.445964e-02 1.728003e+00 0.532648 -5.114050 ... -5.975025e-02 \n", - "4 -2.373019e+00 3.958145e+00 -1.102268 4.176345 ... -5.666754e+00 \n", - "5 -2.853713e-02 1.599325e+00 -0.769046 15.164640 ... -4.042464e-02 \n", - "6 2.529416e-01 1.323455e+00 -0.508819 13.341673 ... 2.263066e-01 \n", - "7 1.549015e+00 -1.497881e+00 -0.582442 -55.572184 ... 1.615447e+00 \n", - "8 1.257789e-01 1.463653e+00 -0.610337 440.765781 ... 1.293256e-01 \n", - "9 1.635671e-01 1.277282e+00 -0.626480 387.089882 ... 1.470486e+00 \n", - "10 9.853208e-02 1.545742e+00 -0.533701 35.400726 ... 9.826283e-02 \n", - "11 5.863094e-02 1.396463e+00 -0.618115 121.397729 ... 5.648553e-02 \n", - "12 6.262768e-41 2.395130e-40 1.000000 1.000000 ... 6.262768e-41 \n", - "13 4.143237e-01 9.774066e-01 0.705131 -378.089421 ... 4.678555e-01 \n", - "14 1.699240e+00 -1.632855e+00 -0.059402 -4.592369 ... 1.720189e+00 \n", - "15 NaN NaN NaN NaN ... NaN \n", - "16 1.569310e+00 -1.488544e+00 -0.514997 -20.815028 ... 1.094885e-01 \n", - "17 1.218083e+00 -5.312664e+00 -17.116577 -29.692282 ... 1.288374e+00 \n", - "18 NaN NaN NaN NaN ... 1.059081e+00 \n", - "19 1.369031e+00 -1.434061e+00 0.192200 2.892573 ... 1.300959e+00 \n", - "20 6.267755e-01 2.928533e-01 9.714231 -10.807681 ... 1.696491e+00 \n", - "21 1.309567e-01 1.249188e+00 0.239673 -571.445836 ... 1.454657e+00 \n", - "22 6.764635e-02 1.630374e+00 0.509933 -4.886715 ... 3.029815e-02 \n", - "23 -5.626900e-02 1.911264e+00 0.316051 -5.701098 ... -3.524171e-02 \n", - "24 4.390732e-02 1.489792e+00 0.499192 -46.508500 ... 4.777285e-02 \n", - "25 -1.336959e-01 1.799307e+00 0.466993 -3.477303 ... -2.551225e-01 \n", - "26 1.126017e+00 -1.114323e+00 0.423147 13.870503 ... 1.126017e+00 \n", - "27 NaN NaN NaN NaN ... NaN \n", + " actmin_8 amp_8 alpha_8 beta_8 ... actmin_9 amp_9 \\\n", + "0 1.048527 1.820719 0.768953 -14.117220 ... 1.138832 1.751524 \n", + "1 1.474886 0.934578 6.984927 -9.156320 ... 2.125595 0.341217 \n", + "2 1.253748 1.560074 -0.634767 8.827035 ... 1.720730 0.728035 \n", + "3 1.876456 1.110198 0.638584 -8.346138 ... 1.986456 1.000151 \n", + "4 1.623585 1.262882 -0.854330 25.440830 ... NaN NaN \n", + "5 1.434901 1.531952 0.845901 -17.390933 ... 1.456431 1.527021 \n", + "6 1.067901 1.919542 -0.886590 29.439124 ... NaN NaN \n", + "7 1.358338 1.456933 0.639890 -35.834795 ... 1.489933 0.957407 \n", + "8 1.200380 1.758045 -0.729250 68.432426 ... 1.302437 1.670913 \n", + "9 2.170354 0.755679 0.692503 -20.868824 ... 2.932025 -0.599292 \n", + "10 -4.934099 7.939505 1.208165 -4.752587 ... -1.186910 4.205626 \n", + "11 1.705239 1.160109 -0.643770 53.934596 ... 1.693932 1.201932 \n", + "12 2.325314 0.233009 4.233220 -9.217501 ... -0.437034 3.067061 \n", + "13 NaN NaN NaN NaN ... -4168.940442 4171.805933 \n", + "14 -0.482320 2.623988 7.790539 -6.950773 ... 1.763587 0.416798 \n", + "15 2.364058 -6.744281 -11.162305 -3.139133 ... 1.363524 1.502704 \n", + "16 0.867993 2.067560 0.783241 -398.029004 ... 3.125222 -0.597005 \n", + "17 NaN NaN NaN NaN ... 1.237593 1.335523 \n", + "18 1.593704 1.222583 0.558698 -22.842250 ... 1.683488 1.155345 \n", + "19 -2.941540 5.325181 14.573312 -19.938178 ... 2.825312 -1.143046 \n", + "20 1.333574 1.223772 0.544728 -440.463143 ... 1.422815 1.156894 \n", + "21 -5.545094 8.413067 1.518012 -3.234838 ... NaN NaN \n", + "22 1.047557 1.808673 -0.477010 13.519638 ... 1.103467 1.774092 \n", + "23 1.550722 0.695251 7.151361 -9.313397 ... 3.026270 -0.717050 \n", + "24 1.508629 1.230524 0.713775 -17.115975 ... 1.521717 1.250673 \n", "\n", - " amp_9 alpha_9 beta_9 phi_9 actmin_10 \\\n", - "0 1.579498e+00 0.569379 -8.586889 1.971324 1.140916e+00 \n", - "1 8.866697e+00 -2.262784 0.748250 -7.154961 -6.410901e+00 \n", - "2 NaN NaN NaN NaN NaN \n", - "3 1.763454e+00 0.529335 -4.901354 2.589463 -5.975025e-02 \n", - "4 7.281475e+00 -1.363325 3.485568 -6.529643 -1.182390e-01 \n", - "5 1.662724e+00 -0.762861 13.656660 -6.718875 -3.453266e-02 \n", - "6 1.410208e+00 -0.531714 10.994653 -4.766890 -2.993769e+00 \n", - "7 -1.563355e+00 -0.580480 -51.471342 -9.587446 5.408549e-02 \n", - "8 1.496312e+00 -0.610180 440.777116 -6.864791 1.332177e-01 \n", - "9 -1.278021e+00 -0.627187 -1511.220750 -8.015321 2.093756e-01 \n", - "10 1.574103e+00 -0.531625 33.886660 -7.119768 9.929714e-02 \n", - "11 1.483012e+00 -0.622768 61.569724 -5.515466 5.964428e-02 \n", - "12 2.395130e-40 1.000000 1.000000 1.000000 6.262768e-41 \n", - "13 9.885927e-01 0.621269 -435.689510 2.686489 4.788005e-01 \n", - "14 -1.701182e+00 -0.117497 -4.311277 -9.523047 1.765729e+00 \n", - "15 NaN NaN NaN NaN NaN \n", - "16 1.536120e+00 0.506885 -19.649729 1.983796 1.138180e-01 \n", - "17 -8.204300e+00 -12.349581 -22.831074 -12.545450 1.857181e+00 \n", - "18 -7.396861e-01 -0.274338 467.999524 1.020176 1.094692e+00 \n", - "19 -1.245515e+00 -0.278575 -5.405110 -10.081652 1.363998e+00 \n", - "20 -7.468483e-01 8.737649 -9.050064 0.627744 1.679336e+00 \n", - "21 -1.319582e+00 -0.239615 -930.751592 -10.817235 1.091430e+00 \n", - "22 1.716570e+00 0.542068 -4.479368 2.769676 4.148404e-02 \n", - "23 1.891440e+00 0.332600 -6.514964 2.285575 -1.400653e-02 \n", - "24 1.514942e+00 0.496688 -42.430132 2.542145 4.505044e-02 \n", - "25 1.946941e+00 -0.564769 3.865575 -8.799264 -1.565747e-01 \n", - "26 -1.114323e+00 0.423147 13.870503 2.504065 1.126017e+00 \n", - "27 NaN NaN NaN NaN NaN \n", + " alpha_9 beta_9 phi_9 actmin_10 amp_10 alpha_10 \\\n", + "0 0.769270 -13.078016 2.640273 1.224985 1.679375 0.771681 \n", + "1 4.515416 -8.367047 -9.001245 1.176810 1.344468 5.442158 \n", + "2 4.629720 -9.518540 -9.511485 1.892944 0.626165 6.185474 \n", + "3 0.653496 -11.215384 2.878217 2.006809 1.019504 0.647388 \n", + "4 NaN NaN NaN NaN NaN NaN \n", + "5 0.850317 -16.523697 5.405994 1.529499 1.468530 0.845736 \n", + "6 NaN NaN NaN -50.762123 53.842955 1.617283 \n", + "7 9.759133 -8.789658 1.573778 5.134583 -2.655075 18.210916 \n", + "8 -0.730694 55.758243 -6.798061 1.373475 1.609496 -0.729089 \n", + "9 -0.653876 -100.123668 -8.070665 2.349814 0.595015 0.670183 \n", + "10 1.019116 -5.086760 -17.844257 -4.873827 7.908448 1.245725 \n", + "11 0.676174 -18.553951 -17.567710 1.761701 1.148013 0.665370 \n", + "12 5.422966 -14.103322 -8.309635 2.871435 -1.804360 -0.927371 \n", + "13 1.810182 -9.801077 2.611993 NaN NaN NaN \n", + "14 7.866024 -10.307468 -3.782279 0.860242 1.358709 4.930827 \n", + "15 0.574372 -83.887816 1.860763 1.420190 1.462180 0.571645 \n", + "16 7.315936 -6.932374 38.172156 0.964368 2.052078 0.754236 \n", + "17 0.860568 -8.846168 4.625016 1.571529 1.010569 0.816653 \n", + "18 0.542743 -19.349388 1.837730 1.774703 1.083588 0.539876 \n", + "19 0.468917 104.413972 -116.939255 1.724968 1.106933 0.533558 \n", + "20 0.544543 -459.462711 2.408327 1.477648 1.134205 0.544053 \n", + "21 NaN NaN NaN -143.881542 146.774580 2.541702 \n", + "22 0.490255 -12.957627 2.703866 1.185442 1.704768 0.486392 \n", + "23 5.827807 -8.990460 3.092604 1.319514 1.523231 0.551828 \n", + "24 0.699904 -11.619732 -20.041456 0.764678 2.044402 0.940041 \n", "\n", - " amp_10 alpha_10 beta_10 phi_10 \n", - "0 -4.261664e+00 -14.074745 -22.251637 -52.500316 \n", - "1 8.866697e+00 -2.262784 0.748250 -7.154961 \n", - "2 NaN NaN NaN NaN \n", - "3 1.763454e+00 0.529335 -4.901354 2.589463 \n", - "4 1.724487e+00 -0.818430 10.443968 -6.709902 \n", - "5 1.684204e+00 -0.760088 13.661519 -6.728423 \n", - "6 4.729876e+00 -1.199374 2.857966 -5.489378 \n", - "7 1.601614e+00 0.584732 -48.973293 2.387816 \n", - "8 1.540560e+00 0.609982 -440.856547 -18.864421 \n", - "9 1.284383e+00 -0.646601 183.023943 -7.898776 \n", - "10 1.587373e+00 -0.549218 62.810948 -7.071323 \n", - "11 1.526655e+00 -0.620661 54.901056 -5.518533 \n", - "12 2.395130e-40 1.000000 1.000000 1.000000 \n", - "13 1.024258e+00 0.621045 -404.652634 2.686727 \n", - "14 -1.786049e+00 -0.147384 -3.900697 -9.437700 \n", - "15 NaN NaN NaN NaN \n", - "16 1.582129e+00 0.504111 -18.689214 -22.027810 \n", - "17 -1.814990e+00 -0.577335 -22.553110 -10.275631 \n", - "18 -7.363745e-01 -0.298258 515.253206 0.946826 \n", - "19 -1.284790e+00 -0.271716 -5.661094 -10.095691 \n", - "20 -1.622530e+00 -0.220805 -2.668178 -10.031367 \n", - "21 -1.592007e-01 6.139185 -6.065396 -16.633912 \n", - "22 1.725604e+00 0.560755 -4.492102 2.855212 \n", - "23 1.864330e+00 0.348856 -7.681337 2.322318 \n", - "24 1.567154e+00 0.491314 -33.275463 2.513901 \n", - "25 1.873835e+00 0.538828 -4.055396 3.219966 \n", - "26 -1.114323e+00 0.423147 13.870503 2.504065 \n", - "27 NaN NaN NaN NaN \n", + " beta_10 phi_10 \n", + "0 -13.104473 2.647754 \n", + "1 -8.101281 -18.069600 \n", + "2 -6.415972 -12.150579 \n", + "3 -9.535801 2.887949 \n", + "4 NaN NaN \n", + "5 -15.776267 5.388757 \n", + "6 -5.565424 -17.863623 \n", + "7 -13.173022 7.915980 \n", + "8 69.585766 -6.793869 \n", + "9 -130.757799 4.026063 \n", + "10 -4.421485 -17.844574 \n", + "11 -21.600841 -17.546436 \n", + "12 -96.002515 -7.060955 \n", + "13 NaN NaN \n", + "14 -7.485486 -1.036203 \n", + "15 -88.417981 1.848547 \n", + "16 -24.539640 2.280103 \n", + "17 -12.261027 4.804126 \n", + "18 -14.428132 1.805983 \n", + "19 -462.829431 2.804946 \n", + "20 -459.572786 2.407815 \n", + "21 -3.111851 3.640661 \n", + "22 -12.929933 2.672762 \n", + "23 -24.636007 2.707138 \n", + "24 -5.034099 4.399277 \n", "\n", - "[28 rows x 21 columns]" + "[25 rows x 21 columns]" ] }, - "execution_count": 88, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "cr_fit" + "cr_act" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 15, "metadata": { "scrolled": true }, @@ -3736,126 +3584,110 @@ " \n", " \n", " 10011\n", - " 1.140916e+00\n", - " -4.261664e+00\n", - " -14.074745\n", - " -22.251637\n", - " -52.500316\n", + " 1.224985\n", + " 1.679375\n", + " 0.771681\n", + " -13.104473\n", + " 2.647754\n", " \n", " \n", " 10012\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", + " 1.176810\n", + " 1.344468\n", + " 5.442158\n", + " -8.101281\n", + " -18.069600\n", " \n", " \n", " 10014\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1.892944\n", + " 0.626165\n", + " 6.185474\n", + " -6.415972\n", + " -12.150579\n", " \n", " \n", " 10016\n", - " -5.975025e-02\n", - " 1.763454e+00\n", - " 0.529335\n", - " -4.901354\n", - " 2.589463\n", + " 2.006809\n", + " 1.019504\n", + " 0.647388\n", + " -9.535801\n", + " 2.887949\n", " \n", " \n", " 10023\n", - " -1.182390e-01\n", - " 1.724487e+00\n", - " -0.818430\n", - " 10.443968\n", - " -6.709902\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 10024\n", - " -3.453266e-02\n", - " 1.684204e+00\n", - " -0.760088\n", - " 13.661519\n", - " -6.728423\n", + " 1.529499\n", + " 1.468530\n", + " 0.845736\n", + " -15.776267\n", + " 5.388757\n", " \n", " \n", " 10025\n", - " -2.993769e+00\n", - " 4.729876e+00\n", - " -1.199374\n", - " 2.857966\n", - " -5.489378\n", + " -50.762123\n", + " 53.842955\n", + " 1.617283\n", + " -5.565424\n", + " -17.863623\n", " \n", " \n", " 10033\n", - " 5.408549e-02\n", - " 1.601614e+00\n", - " 0.584732\n", - " -48.973293\n", - " 2.387816\n", + " 5.134583\n", + " -2.655075\n", + " 18.210916\n", + " -13.173022\n", + " 7.915980\n", " \n", " \n", " 10035\n", - " 1.332177e-01\n", - " 1.540560e+00\n", - " 0.609982\n", - " -440.856547\n", - " -18.864421\n", + " 1.373475\n", + " 1.609496\n", + " -0.729089\n", + " 69.585766\n", + " -6.793869\n", " \n", " \n", " 10038\n", - " 2.093756e-01\n", - " 1.284383e+00\n", - " -0.646601\n", - " 183.023943\n", - " -7.898776\n", + " 2.349814\n", + " 0.595015\n", + " 0.670183\n", + " -130.757799\n", + " 4.026063\n", " \n", " \n", " 10040\n", - " 9.929714e-02\n", - " 1.587373e+00\n", - " -0.549218\n", - " 62.810948\n", - " -7.071323\n", + " -4.873827\n", + " 7.908448\n", + " 1.245725\n", + " -4.421485\n", + " -17.844574\n", " \n", " \n", " 10045\n", - " 5.964428e-02\n", - " 1.526655e+00\n", - " -0.620661\n", - " 54.901056\n", - " -5.518533\n", + " 1.761701\n", + " 1.148013\n", + " 0.665370\n", + " -21.600841\n", + " -17.546436\n", " \n", " \n", " 10049\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", + " 2.871435\n", + " -1.804360\n", + " -0.927371\n", + " -96.002515\n", + " -7.060955\n", " \n", " \n", " 10062\n", - " 4.788005e-01\n", - " 1.024258e+00\n", - " 0.621045\n", - " -404.652634\n", - " 2.686727\n", - " \n", - " \n", - " 10076\n", - " 1.765729e+00\n", - " -1.786049e+00\n", - " -0.147384\n", - " -3.900697\n", - " -9.437700\n", - " \n", - " \n", - " 10139\n", " NaN\n", " NaN\n", " NaN\n", @@ -3863,187 +3695,159 @@ " NaN\n", " \n", " \n", + " 20076\n", + " 0.860242\n", + " 1.358709\n", + " 4.930827\n", + " -7.485486\n", + " -1.036203\n", + " \n", + " \n", " 20103\n", - " 1.138180e-01\n", - " 1.582129e+00\n", - " 0.504111\n", - " -18.689214\n", - " -22.027810\n", + " 1.420190\n", + " 1.462180\n", + " 0.571645\n", + " -88.417981\n", + " 1.848547\n", " \n", " \n", " 20105\n", - " 1.857181e+00\n", - " -1.814990e+00\n", - " -0.577335\n", - " -22.553110\n", - " -10.275631\n", + " 0.964368\n", + " 2.052078\n", + " 0.754236\n", + " -24.539640\n", + " 2.280103\n", " \n", " \n", " 20108\n", - " 1.094692e+00\n", - " -7.363745e-01\n", - " -0.298258\n", - " 515.253206\n", - " 0.946826\n", + " 1.571529\n", + " 1.010569\n", + " 0.816653\n", + " -12.261027\n", + " 4.804126\n", " \n", " \n", " 20113\n", - " 1.363998e+00\n", - " -1.284790e+00\n", - " -0.271716\n", - " -5.661094\n", - " -10.095691\n", + " 1.774703\n", + " 1.083588\n", + " 0.539876\n", + " -14.428132\n", + " 1.805983\n", " \n", " \n", " 20115\n", - " 1.679336e+00\n", - " -1.622530e+00\n", - " -0.220805\n", - " -2.668178\n", - " -10.031367\n", + " 1.724968\n", + " 1.106933\n", + " 0.533558\n", + " -462.829431\n", + " 2.804946\n", " \n", " \n", " 20120\n", - " 1.091430e+00\n", - " -1.592007e-01\n", - " 6.139185\n", - " -6.065396\n", - " -16.633912\n", + " 1.477648\n", + " 1.134205\n", + " 0.544053\n", + " -459.572786\n", + " 2.407815\n", " \n", " \n", " 20122\n", - " 4.148404e-02\n", - " 1.725604e+00\n", - " 0.560755\n", - " -4.492102\n", - " 2.855212\n", + " -143.881542\n", + " 146.774580\n", + " 2.541702\n", + " -3.111851\n", + " 3.640661\n", " \n", " \n", " 20123\n", - " -1.400653e-02\n", - " 1.864330e+00\n", - " 0.348856\n", - " -7.681337\n", - " 2.322318\n", + " 1.185442\n", + " 1.704768\n", + " 0.486392\n", + " -12.929933\n", + " 2.672762\n", " \n", " \n", " 20124\n", - " 4.505044e-02\n", - " 1.567154e+00\n", - " 0.491314\n", - " -33.275463\n", - " 2.513901\n", + " 1.319514\n", + " 1.523231\n", + " 0.551828\n", + " -24.636007\n", + " 2.707138\n", " \n", " \n", " 20125\n", - " -1.565747e-01\n", - " 1.873835e+00\n", - " 0.538828\n", - " -4.055396\n", - " 3.219966\n", - " \n", - " \n", - " 20127\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", - " \n", - " \n", - " 20129\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.764678\n", + " 2.044402\n", + " 0.940041\n", + " -5.034099\n", + " 4.399277\n", " \n", " \n", "\n", "" ], "text/plain": [ - " actmin_10 amp_10 alpha_10 beta_10 phi_10\n", - "Unnamed: 0 \n", - "10011 1.140916e+00 -4.261664e+00 -14.074745 -22.251637 -52.500316\n", - "10012 -6.410901e+00 8.866697e+00 -2.262784 0.748250 -7.154961\n", - "10014 NaN NaN NaN NaN NaN\n", - "10016 -5.975025e-02 1.763454e+00 0.529335 -4.901354 2.589463\n", - "10023 -1.182390e-01 1.724487e+00 -0.818430 10.443968 -6.709902\n", - "10024 -3.453266e-02 1.684204e+00 -0.760088 13.661519 -6.728423\n", - "10025 -2.993769e+00 4.729876e+00 -1.199374 2.857966 -5.489378\n", - "10033 5.408549e-02 1.601614e+00 0.584732 -48.973293 2.387816\n", - "10035 1.332177e-01 1.540560e+00 0.609982 -440.856547 -18.864421\n", - "10038 2.093756e-01 1.284383e+00 -0.646601 183.023943 -7.898776\n", - "10040 9.929714e-02 1.587373e+00 -0.549218 62.810948 -7.071323\n", - "10045 5.964428e-02 1.526655e+00 -0.620661 54.901056 -5.518533\n", - "10049 6.262768e-41 2.395130e-40 1.000000 1.000000 1.000000\n", - "10062 4.788005e-01 1.024258e+00 0.621045 -404.652634 2.686727\n", - "10076 1.765729e+00 -1.786049e+00 -0.147384 -3.900697 -9.437700\n", - "10139 NaN NaN NaN NaN NaN\n", - "20103 1.138180e-01 1.582129e+00 0.504111 -18.689214 -22.027810\n", - "20105 1.857181e+00 -1.814990e+00 -0.577335 -22.553110 -10.275631\n", - "20108 1.094692e+00 -7.363745e-01 -0.298258 515.253206 0.946826\n", - "20113 1.363998e+00 -1.284790e+00 -0.271716 -5.661094 -10.095691\n", - "20115 1.679336e+00 -1.622530e+00 -0.220805 -2.668178 -10.031367\n", - "20120 1.091430e+00 -1.592007e-01 6.139185 -6.065396 -16.633912\n", - "20122 4.148404e-02 1.725604e+00 0.560755 -4.492102 2.855212\n", - "20123 -1.400653e-02 1.864330e+00 0.348856 -7.681337 2.322318\n", - "20124 4.505044e-02 1.567154e+00 0.491314 -33.275463 2.513901\n", - "20125 -1.565747e-01 1.873835e+00 0.538828 -4.055396 3.219966\n", - "20127 1.126017e+00 -1.114323e+00 0.423147 13.870503 2.504065\n", - "20129 NaN NaN NaN NaN NaN" + " actmin_10 amp_10 alpha_10 beta_10 phi_10\n", + "Unnamed: 0 \n", + "10011 1.224985 1.679375 0.771681 -13.104473 2.647754\n", + "10012 1.176810 1.344468 5.442158 -8.101281 -18.069600\n", + "10014 1.892944 0.626165 6.185474 -6.415972 -12.150579\n", + "10016 2.006809 1.019504 0.647388 -9.535801 2.887949\n", + "10023 NaN NaN NaN NaN NaN\n", + "10024 1.529499 1.468530 0.845736 -15.776267 5.388757\n", + "10025 -50.762123 53.842955 1.617283 -5.565424 -17.863623\n", + "10033 5.134583 -2.655075 18.210916 -13.173022 7.915980\n", + "10035 1.373475 1.609496 -0.729089 69.585766 -6.793869\n", + "10038 2.349814 0.595015 0.670183 -130.757799 4.026063\n", + "10040 -4.873827 7.908448 1.245725 -4.421485 -17.844574\n", + "10045 1.761701 1.148013 0.665370 -21.600841 -17.546436\n", + "10049 2.871435 -1.804360 -0.927371 -96.002515 -7.060955\n", + "10062 NaN NaN NaN NaN NaN\n", + "20076 0.860242 1.358709 4.930827 -7.485486 -1.036203\n", + "20103 1.420190 1.462180 0.571645 -88.417981 1.848547\n", + "20105 0.964368 2.052078 0.754236 -24.539640 2.280103\n", + "20108 1.571529 1.010569 0.816653 -12.261027 4.804126\n", + "20113 1.774703 1.083588 0.539876 -14.428132 1.805983\n", + "20115 1.724968 1.106933 0.533558 -462.829431 2.804946\n", + "20120 1.477648 1.134205 0.544053 -459.572786 2.407815\n", + "20122 -143.881542 146.774580 2.541702 -3.111851 3.640661\n", + "20123 1.185442 1.704768 0.486392 -12.929933 2.672762\n", + "20124 1.319514 1.523231 0.551828 -24.636007 2.707138\n", + "20125 0.764678 2.044402 0.940041 -5.034099 4.399277" ] }, - "execution_count": 89, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "cr_10 = cr_fit.set_index(\"Unnamed: 0\")\n", + "cr_10 = cr_act.set_index(\"Unnamed: 0\")\n", "cr_10 = cr_10.filter(regex=(\"_10.*\"))\n", "cr_10" ] }, { "cell_type": "code", - "execution_count": 72, + "execution_count": 16, "metadata": {}, - "outputs": [ - { - "ename": "KeyError", - "evalue": "'record_id'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/usr/local/lib/python3.7/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 2645\u001b[0m \u001b[0;32mtry\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2646\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2647\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'record_id'", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'record_id'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwhere\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'age_group'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'Younger Adults'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'1'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'record_id'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrjust\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfillchar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'0'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'2'\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mdf\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'record_id'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mastype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrjust\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfillchar\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'0'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", - "\u001b[0;32m/usr/local/lib/python3.7/site-packages/pandas/core/frame.py\u001b[0m in \u001b[0;36m__getitem__\u001b[0;34m(self, key)\u001b[0m\n\u001b[1;32m 2798\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mnlevels\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2799\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_getitem_multilevel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2800\u001b[0;31m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolumns\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2801\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mis_integer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2802\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0mindexer\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32m/usr/local/lib/python3.7/site-packages/pandas/core/indexes/base.py\u001b[0m in \u001b[0;36mget_loc\u001b[0;34m(self, key, method, tolerance)\u001b[0m\n\u001b[1;32m 2646\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2647\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0mKeyError\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m-> 2648\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_engine\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_loc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_maybe_cast_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2649\u001b[0m \u001b[0mindexer\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_indexer\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mkey\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mmethod\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mmethod\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtolerance\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mtolerance\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2650\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mndim\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mindexer\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msize\u001b[0m \u001b[0;34m>\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/index.pyx\u001b[0m in \u001b[0;36mpandas._libs.index.IndexEngine.get_loc\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;32mpandas/_libs/hashtable_class_helper.pxi\u001b[0m in \u001b[0;36mpandas._libs.hashtable.PyObjectHashTable.get_item\u001b[0;34m()\u001b[0m\n", - "\u001b[0;31mKeyError\u001b[0m: 'record_id'" - ] - } - ], + "outputs": [], "source": [ "df['record_id'] = np.where(df['age_group'] == 'Younger Adults', '1' + df['record_id'].astype(str).str.rjust(4, fillchar = '0'), '2' + df['record_id'].astype(str).str.rjust(4, fillchar = '0'))" ] }, { "cell_type": "code", - "execution_count": 90, + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "df = df.set_index('record_id')" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -4053,7 +3857,7 @@ }, { "cell_type": "code", - "execution_count": 129, + "execution_count": 19, "metadata": { "scrolled": true }, @@ -4090,11 +3894,11 @@ " Doing nothing (sitting around, daydreaming\n", " Drinking, eating\n", " ...\n", - " Using a computer\n", - " Walking, running\n", - " Watching TV, movies\n", - " Working\n", - " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " actmin_10\n", " amp_10\n", " alpha_10\n", @@ -4131,326 +3935,326 @@ " 10011\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 0.692308\n", + " 96.384615\n", + " 3.076923\n", + " 0.153846\n", " 0.000000\n", " 0.461538\n", " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.307692\n", - " 0.153846\n", - " 0.923077\n", " ...\n", " 0.923077\n", " 0.923077\n", " 0.538462\n", " 1.000000\n", " 0.0\n", - " 1.140916e+00\n", - " -4.261664e+00\n", - " -14.074745\n", - " -22.251637\n", - " -52.500316\n", + " 1.224985\n", + " 1.679375\n", + " 0.771681\n", + " -13.104473\n", + " 2.647754\n", " \n", " \n", " 10012\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 5.857143\n", + " 55.142857\n", + " 49.500000\n", + " 0.000000\n", " 0.642857\n", " 0.285714\n", " 1.000000\n", - " 0.857143\n", - " 0.071429\n", - " 0.642857\n", - " 0.214286\n", - " 0.785714\n", " ...\n", " 1.000000\n", " 0.571429\n", " 0.571429\n", " 0.285714\n", " 0.0\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", + " 1.176810\n", + " 1.344468\n", + " 5.442158\n", + " -8.101281\n", + " -18.069600\n", " \n", " \n", " 10014\n", " Younger Adults\n", " Pre\n", + " 2.000000\n", + " 43.416667\n", + " 52.000000\n", + " 61.916667\n", + " 51.916667\n", " 0.000000\n", " 0.416667\n", " 0.833333\n", - " 0.500000\n", - " 0.000000\n", - " 0.500000\n", - " 0.583333\n", - " 0.666667\n", " ...\n", " 0.583333\n", " 0.333333\n", " 1.000000\n", " 0.416667\n", " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1.892944\n", + " 0.626165\n", + " 6.185474\n", + " -6.415972\n", + " -12.150579\n", " \n", " \n", " 10016\n", " Younger Adults\n", " Pre\n", + " 5.714286\n", + " 37.785714\n", + " 53.857143\n", + " 43.214286\n", + " 4.571429\n", " 0.571429\n", " 0.071429\n", " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 0.928571\n", " 0.857143\n", " 0.928571\n", " 0.714286\n", " 0.0\n", - " -5.975025e-02\n", - " 1.763454e+00\n", - " 0.529335\n", - " -4.901354\n", - " 2.589463\n", + " 2.006809\n", + " 1.019504\n", + " 0.647388\n", + " -9.535801\n", + " 2.887949\n", " \n", " \n", " 10023\n", " Younger Adults\n", " Pre\n", + " 3.333333\n", + " 48.714286\n", + " 54.928571\n", + " 65.928571\n", + " 65.642857\n", " 0.785714\n", " 0.500000\n", " 0.785714\n", - " 0.071429\n", - " 0.214286\n", - " 0.142857\n", - " 0.142857\n", - " 0.785714\n", " ...\n", " 0.428571\n", " 0.214286\n", " 0.285714\n", " 0.000000\n", " 0.0\n", - " -1.182390e-01\n", - " 1.724487e+00\n", - " -0.818430\n", - " 10.443968\n", - " -6.709902\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 10024\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 42.230769\n", + " 67.846154\n", + " 59.692308\n", + " 28.000000\n", " 0.769231\n", " 0.923077\n", " 1.000000\n", - " 0.153846\n", - " 0.384615\n", - " 0.076923\n", - " 0.923077\n", - " 1.000000\n", " ...\n", " 0.769231\n", " 0.923077\n", " 0.692308\n", " 0.000000\n", " 0.0\n", - " -3.453266e-02\n", - " 1.684204e+00\n", - " -0.760088\n", - " 13.661519\n", - " -6.728423\n", + " 1.529499\n", + " 1.468530\n", + " 0.845736\n", + " -15.776267\n", + " 5.388757\n", " \n", " \n", " 10025\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 28.642857\n", + " 70.714286\n", + " 68.785714\n", + " 33.142857\n", " 0.428571\n", " 0.857143\n", " 0.500000\n", - " 0.142857\n", - " 0.000000\n", - " 0.214286\n", - " 0.500000\n", - " 0.928571\n", " ...\n", " 0.857143\n", " 0.071429\n", " 0.857143\n", " 0.000000\n", " 0.0\n", - " -2.993769e+00\n", - " 4.729876e+00\n", - " -1.199374\n", - " 2.857966\n", - " -5.489378\n", + " -50.762123\n", + " 53.842955\n", + " 1.617283\n", + " -5.565424\n", + " -17.863623\n", " \n", " \n", " 10033\n", " Younger Adults\n", " Pre\n", + " 1.000000\n", + " 31.692308\n", + " 64.846154\n", + " 51.615385\n", + " 27.461538\n", " 0.615385\n", " 0.692308\n", " 0.846154\n", - " 0.923077\n", - " 0.000000\n", - " 0.384615\n", - " 0.307692\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.923077\n", " 1.000000\n", " 0.692308\n", " 0.0\n", - " 5.408549e-02\n", - " 1.601614e+00\n", - " 0.584732\n", - " -48.973293\n", - " 2.387816\n", + " 5.134583\n", + " -2.655075\n", + " 18.210916\n", + " -13.173022\n", + " 7.915980\n", " \n", " \n", " 10035\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 47.750000\n", + " 65.750000\n", + " 45.333333\n", + " 28.166667\n", " 0.500000\n", " 1.000000\n", " 1.000000\n", - " 0.916667\n", - " 0.916667\n", - " 0.583333\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.416667\n", " 0.000000\n", " 0.0\n", - " 1.332177e-01\n", - " 1.540560e+00\n", - " 0.609982\n", - " -440.856547\n", - " -18.864421\n", + " 1.373475\n", + " 1.609496\n", + " -0.729089\n", + " 69.585766\n", + " -6.793869\n", " \n", " \n", " 10038\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.266667\n", + " 65.866667\n", + " 28.733333\n", + " 6.933333\n", " 0.666667\n", " 0.866667\n", " 1.000000\n", - " 0.066667\n", - " 0.466667\n", - " 0.466667\n", - " 0.066667\n", - " 0.866667\n", " ...\n", " 0.533333\n", " 1.000000\n", " 0.800000\n", " 0.333333\n", " 0.0\n", - " 2.093756e-01\n", - " 1.284383e+00\n", - " -0.646601\n", - " 183.023943\n", - " -7.898776\n", + " 2.349814\n", + " 0.595015\n", + " 0.670183\n", + " -130.757799\n", + " 4.026063\n", " \n", " \n", " 10040\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 52.500000\n", + " 63.428571\n", + " 52.000000\n", + " 47.357143\n", " 0.714286\n", " 1.000000\n", " 1.000000\n", - " 0.714286\n", - " 0.071429\n", - " 0.285714\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.928571\n", " 0.000000\n", " 0.0\n", - " 9.929714e-02\n", - " 1.587373e+00\n", - " -0.549218\n", - " 62.810948\n", - " -7.071323\n", + " -4.873827\n", + " 7.908448\n", + " 1.245725\n", + " -4.421485\n", + " -17.844574\n", " \n", " \n", " 10045\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.461538\n", + " 74.384615\n", + " 28.923077\n", + " 20.153846\n", " 0.538462\n", " 0.846154\n", " 1.000000\n", - " 0.923077\n", - " 0.769231\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.307692\n", " 0.000000\n", " 0.0\n", - " 5.964428e-02\n", - " 1.526655e+00\n", - " -0.620661\n", - " 54.901056\n", - " -5.518533\n", + " 1.761701\n", + " 1.148013\n", + " 0.665370\n", + " -21.600841\n", + " -17.546436\n", " \n", " \n", " 10049\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 24.818182\n", + " 66.363636\n", + " 40.909091\n", + " 23.818182\n", " 0.636364\n", " 0.545455\n", " 0.909091\n", - " 0.636364\n", - " 0.181818\n", - " 0.727273\n", - " 0.363636\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.636364\n", " 1.000000\n", " 0.545455\n", " 0.0\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", + " 2.871435\n", + " -1.804360\n", + " -0.927371\n", + " -96.002515\n", + " -7.060955\n", " \n", " \n", " 10057\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 35.250000\n", + " 70.000000\n", + " 45.750000\n", + " 20.750000\n", " 0.625000\n", " 0.125000\n", " 0.125000\n", - " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 0.125000\n", - " 0.125000\n", " ...\n", " 0.125000\n", " 0.125000\n", @@ -4467,277 +4271,277 @@ " 10062\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 29.153846\n", + " 58.461538\n", + " 65.153846\n", + " 48.538462\n", " 0.153846\n", " 0.230769\n", " 0.769231\n", - " 0.846154\n", - " 0.230769\n", - " 0.692308\n", - " 0.307692\n", - " 0.846154\n", " ...\n", " 1.000000\n", " 0.230769\n", " 0.461538\n", " 0.615385\n", " 0.0\n", - " 4.788005e-01\n", - " 1.024258e+00\n", - " 0.621045\n", - " -404.652634\n", - " 2.686727\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 20076\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 5.214286\n", + " 50.153846\n", + " 34.214286\n", + " 5.071429\n", " 0.214286\n", " 0.714286\n", " 0.714286\n", - " 0.142857\n", - " 0.071429\n", - " 0.857143\n", - " 0.071429\n", - " 1.000000\n", " ...\n", " 0.714286\n", " 0.428571\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.860242\n", + " 1.358709\n", + " 4.930827\n", + " -7.485486\n", + " -1.036203\n", " \n", " \n", " 20105\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 2.857143\n", + " 92.500000\n", + " 6.642857\n", + " 0.428571\n", " 0.142857\n", " 1.000000\n", " 0.357143\n", - " 0.785714\n", - " 0.214286\n", - " 0.571429\n", - " 0.071429\n", - " 1.000000\n", " ...\n", " 0.428571\n", " 1.000000\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " 1.857181e+00\n", - " -1.814990e+00\n", - " -0.577335\n", - " -22.553110\n", - " -10.275631\n", + " 0.964368\n", + " 2.052078\n", + " 0.754236\n", + " -24.539640\n", + " 2.280103\n", " \n", " \n", " 20113\n", " Older Adults\n", " Pre\n", + " NaN\n", + " 10.714286\n", + " 53.785714\n", + " 33.642857\n", + " 13.357143\n", " 0.428571\n", " 0.928571\n", " 0.928571\n", - " 0.928571\n", - " 0.357143\n", - " 0.857143\n", - " 0.714286\n", - " 0.928571\n", " ...\n", " 0.571429\n", " 0.928571\n", " 0.642857\n", " 0.000000\n", " 0.0\n", - " 1.363998e+00\n", - " -1.284790e+00\n", - " -0.271716\n", - " -5.661094\n", - " -10.095691\n", + " 1.774703\n", + " 1.083588\n", + " 0.539876\n", + " -14.428132\n", + " 1.805983\n", " \n", " \n", " 20115\n", " Older Adults\n", " Pre\n", + " 1.333333\n", + " 18.666667\n", + " 80.400000\n", + " 25.400000\n", + " 77.800000\n", " 0.000000\n", " 0.933333\n", " 0.666667\n", - " 0.533333\n", - " 0.066667\n", - " 0.666667\n", - " 0.800000\n", - " 0.933333\n", " ...\n", " 0.800000\n", " 0.533333\n", " 0.866667\n", " 0.000000\n", " 0.0\n", - " 1.679336e+00\n", - " -1.622530e+00\n", - " -0.220805\n", - " -2.668178\n", - " -10.031367\n", + " 1.724968\n", + " 1.106933\n", + " 0.533558\n", + " -462.829431\n", + " 2.804946\n", " \n", " \n", " 20120\n", " Older Adults\n", " Post\n", + " NaN\n", + " 10.777778\n", + " 74.666667\n", + " 35.333333\n", + " 5.111111\n", " 0.000000\n", " 0.444444\n", " 1.000000\n", - " 0.444444\n", - " 0.444444\n", - " 1.000000\n", - " 0.111111\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.888889\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " 1.091430e+00\n", - " -1.592007e-01\n", - " 6.139185\n", - " -6.065396\n", - " -16.633912\n", + " 1.477648\n", + " 1.134205\n", + " 0.544053\n", + " -459.572786\n", + " 2.407815\n", " \n", " \n", " 20122\n", " Older Adults\n", " Post\n", + " 5.545455\n", + " 3.636364\n", + " 83.090909\n", + " 7.727273\n", + " 5.272727\n", " 0.000000\n", " 0.818182\n", " 0.818182\n", - " 0.181818\n", - " 0.000000\n", - " 0.727273\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 0.818182\n", " 1.000000\n", " 0.545455\n", " 0.000000\n", " 0.0\n", - " 4.148404e-02\n", - " 1.725604e+00\n", - " 0.560755\n", - " -4.492102\n", - " 2.855212\n", + " -143.881542\n", + " 146.774580\n", + " 2.541702\n", + " -3.111851\n", + " 3.640661\n", " \n", " \n", " 20123\n", " Older Adults\n", " Post\n", + " NaN\n", + " 7.400000\n", + " 81.800000\n", + " 31.600000\n", + " 16.400000\n", " 0.000000\n", " 0.600000\n", " 1.000000\n", - " 0.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.800000\n", " ...\n", " 0.800000\n", " 0.000000\n", " 0.200000\n", " 0.400000\n", " 0.0\n", - " -1.400653e-02\n", - " 1.864330e+00\n", - " 0.348856\n", - " -7.681337\n", - " 2.322318\n", + " 1.185442\n", + " 1.704768\n", + " 0.486392\n", + " -12.929933\n", + " 2.672762\n", " \n", " \n", " 20124\n", " Older Adults\n", " Post\n", + " NaN\n", + " 2.777778\n", + " 88.000000\n", + " 7.222222\n", + " 5.444444\n", " 0.000000\n", " 1.000000\n", " 0.555556\n", - " 0.222222\n", - " 0.555556\n", - " 1.000000\n", - " 0.111111\n", - " 0.888889\n", " ...\n", " 0.888889\n", " 0.555556\n", " 0.666667\n", " 0.000000\n", " 0.0\n", - " 4.505044e-02\n", - " 1.567154e+00\n", - " 0.491314\n", - " -33.275463\n", - " 2.513901\n", + " 1.319514\n", + " 1.523231\n", + " 0.551828\n", + " -24.636007\n", + " 2.707138\n", " \n", " \n", " 20125\n", " Older Adults\n", " Post\n", + " 2.500000\n", + " 8.909091\n", + " 67.454545\n", + " 13.727273\n", + " 9.090909\n", " 0.000000\n", " 0.909091\n", " 0.909091\n", - " 0.363636\n", - " 0.000000\n", - " 1.000000\n", - " 0.272727\n", - " 1.000000\n", " ...\n", " 0.636364\n", " 1.000000\n", " 0.545455\n", " 0.000000\n", " 0.0\n", - " -1.565747e-01\n", - " 1.873835e+00\n", - " 0.538828\n", - " -4.055396\n", - " 3.219966\n", + " 0.764678\n", + " 2.044402\n", + " 0.940041\n", + " -5.034099\n", + " 4.399277\n", " \n", " \n", " 20127\n", " Older Adults\n", " Post\n", + " 1.000000\n", + " 29.500000\n", + " 48.250000\n", + " 36.000000\n", + " 19.750000\n", " 0.250000\n", " 0.500000\n", " 0.750000\n", - " 0.500000\n", - " 0.000000\n", - " 0.750000\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.000000\n", " 0.000000\n", " 0.0\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", " \n", " \n", " 20129\n", " Older Adults\n", " Post\n", - " 0.000000\n", " 1.000000\n", - " 1.000000\n", - " 0.000000\n", + " 34.500000\n", + " 35.500000\n", + " 14.000000\n", + " 6.500000\n", " 0.000000\n", " 1.000000\n", - " 0.000000\n", " 1.000000\n", " ...\n", " 1.000000\n", @@ -4753,217 +4557,188 @@ " \n", " \n", "\n", - "

26 rows × 34 columns

\n", + "

26 rows × 39 columns

\n", "" ], "text/plain": [ " age_group COVID Attending classes, meetings \\\n", "record_id \n", - "10011 Younger Adults Pre 0.000000 \n", - "10012 Younger Adults Pre 0.642857 \n", - "10014 Younger Adults Pre 0.000000 \n", - "10016 Younger Adults Pre 0.571429 \n", - "10023 Younger Adults Pre 0.785714 \n", - "10024 Younger Adults Pre 0.769231 \n", - "10025 Younger Adults Pre 0.428571 \n", - "10033 Younger Adults Pre 0.615385 \n", - "10035 Younger Adults Pre 0.500000 \n", - "10038 Younger Adults Pre 0.666667 \n", - "10040 Younger Adults Pre 0.714286 \n", - "10045 Younger Adults Pre 0.538462 \n", - "10049 Younger Adults Pre 0.636364 \n", - "10057 Younger Adults Pre 0.625000 \n", - "10062 Younger Adults Pre 0.153846 \n", - "20076 Older Adults Pre 0.214286 \n", - "20105 Older Adults Pre 0.142857 \n", - "20113 Older Adults Pre 0.428571 \n", - "20115 Older Adults Pre 0.000000 \n", - "20120 Older Adults Post 0.000000 \n", - "20122 Older Adults Post 0.000000 \n", - "20123 Older Adults Post 0.000000 \n", - "20124 Older Adults Post 0.000000 \n", - "20125 Older Adults Post 0.000000 \n", - "20127 Older Adults Post 0.250000 \n", - "20129 Older Adults Post 0.000000 \n", + "10011 Younger Adults Pre NaN \n", + "10012 Younger Adults Pre 1.500000 \n", + "10014 Younger Adults Pre 2.000000 \n", + "10016 Younger Adults Pre 5.714286 \n", + "10023 Younger Adults Pre 3.333333 \n", + "10024 Younger Adults Pre NaN \n", + "10025 Younger Adults Pre NaN \n", + "10033 Younger Adults Pre 1.000000 \n", + "10035 Younger Adults Pre NaN \n", + "10038 Younger Adults Pre NaN \n", + "10040 Younger Adults Pre NaN \n", + "10045 Younger Adults Pre NaN \n", + "10049 Younger Adults Pre 1.500000 \n", + "10057 Younger Adults Pre NaN \n", + "10062 Younger Adults Pre 1.500000 \n", + "20076 Older Adults Pre 1.000000 \n", + "20105 Older Adults Pre 1.000000 \n", + "20113 Older Adults Pre NaN \n", + "20115 Older Adults Pre 1.333333 \n", + "20120 Older Adults Post NaN \n", + "20122 Older Adults Post 5.545455 \n", + "20123 Older Adults Post NaN \n", + "20124 Older Adults Post NaN \n", + "20125 Older Adults Post 2.500000 \n", + "20127 Older Adults Post 1.000000 \n", + "20129 Older Adults Post 1.000000 \n", "\n", " Being physically animated, moving around Browsing the internet \\\n", "record_id \n", - "10011 0.461538 1.000000 \n", - "10012 0.285714 1.000000 \n", - "10014 0.416667 0.833333 \n", - "10016 0.071429 1.000000 \n", - "10023 0.500000 0.785714 \n", - "10024 0.923077 1.000000 \n", - "10025 0.857143 0.500000 \n", - "10033 0.692308 0.846154 \n", - "10035 1.000000 1.000000 \n", - "10038 0.866667 1.000000 \n", - "10040 1.000000 1.000000 \n", - "10045 0.846154 1.000000 \n", - "10049 0.545455 0.909091 \n", - "10057 0.125000 0.125000 \n", - "10062 0.230769 0.769231 \n", - "20076 0.714286 0.714286 \n", - "20105 1.000000 0.357143 \n", - "20113 0.928571 0.928571 \n", - "20115 0.933333 0.666667 \n", - "20120 0.444444 1.000000 \n", - "20122 0.818182 0.818182 \n", - "20123 0.600000 1.000000 \n", - "20124 1.000000 0.555556 \n", - "20125 0.909091 0.909091 \n", - "20127 0.500000 0.750000 \n", - "20129 1.000000 1.000000 \n", + "10011 0.692308 96.384615 \n", + "10012 5.857143 55.142857 \n", + "10014 43.416667 52.000000 \n", + "10016 37.785714 53.857143 \n", + "10023 48.714286 54.928571 \n", + "10024 42.230769 67.846154 \n", + "10025 28.642857 70.714286 \n", + "10033 31.692308 64.846154 \n", + "10035 47.750000 65.750000 \n", + "10038 17.266667 65.866667 \n", + "10040 52.500000 63.428571 \n", + "10045 17.461538 74.384615 \n", + "10049 24.818182 66.363636 \n", + "10057 35.250000 70.000000 \n", + "10062 29.153846 58.461538 \n", + "20076 5.214286 50.153846 \n", + "20105 2.857143 92.500000 \n", + "20113 10.714286 53.785714 \n", + "20115 18.666667 80.400000 \n", + "20120 10.777778 74.666667 \n", + "20122 3.636364 83.090909 \n", + "20123 7.400000 81.800000 \n", + "20124 2.777778 88.000000 \n", + "20125 8.909091 67.454545 \n", + "20127 29.500000 48.250000 \n", + "20129 34.500000 35.500000 \n", "\n", " Commuting, traveling Doing a favor, helping others \\\n", "record_id \n", - "10011 1.000000 0.000000 \n", - "10012 0.857143 0.071429 \n", - "10014 0.500000 0.000000 \n", - "10016 1.000000 0.000000 \n", - "10023 0.071429 0.214286 \n", - "10024 0.153846 0.384615 \n", - "10025 0.142857 0.000000 \n", - "10033 0.923077 0.000000 \n", - "10035 0.916667 0.916667 \n", - "10038 0.066667 0.466667 \n", - "10040 0.714286 0.071429 \n", - "10045 0.923077 0.769231 \n", - "10049 0.636364 0.181818 \n", - "10057 0.000000 0.000000 \n", - "10062 0.846154 0.230769 \n", - "20076 0.142857 0.071429 \n", - "20105 0.785714 0.214286 \n", - "20113 0.928571 0.357143 \n", - "20115 0.533333 0.066667 \n", - "20120 0.444444 0.444444 \n", - "20122 0.181818 0.000000 \n", - "20123 0.000000 0.000000 \n", - "20124 0.222222 0.555556 \n", - "20125 0.363636 0.000000 \n", - "20127 0.500000 0.000000 \n", - "20129 0.000000 0.000000 \n", + "10011 3.076923 0.153846 \n", + "10012 49.500000 0.000000 \n", + "10014 61.916667 51.916667 \n", + "10016 43.214286 4.571429 \n", + "10023 65.928571 65.642857 \n", + "10024 59.692308 28.000000 \n", + "10025 68.785714 33.142857 \n", + "10033 51.615385 27.461538 \n", + "10035 45.333333 28.166667 \n", + "10038 28.733333 6.933333 \n", + "10040 52.000000 47.357143 \n", + "10045 28.923077 20.153846 \n", + "10049 40.909091 23.818182 \n", + "10057 45.750000 20.750000 \n", + "10062 65.153846 48.538462 \n", + "20076 34.214286 5.071429 \n", + "20105 6.642857 0.428571 \n", + "20113 33.642857 13.357143 \n", + "20115 25.400000 77.800000 \n", + "20120 35.333333 5.111111 \n", + "20122 7.727273 5.272727 \n", + "20123 31.600000 16.400000 \n", + "20124 7.222222 5.444444 \n", + "20125 13.727273 9.090909 \n", + "20127 36.000000 19.750000 \n", + "20129 14.000000 6.500000 \n", "\n", " Doing household chores Doing nothing (sitting around, daydreaming \\\n", "record_id \n", - "10011 0.307692 0.153846 \n", - "10012 0.642857 0.214286 \n", - "10014 0.500000 0.583333 \n", - "10016 1.000000 0.000000 \n", - "10023 0.142857 0.142857 \n", - "10024 0.076923 0.923077 \n", - "10025 0.214286 0.500000 \n", - "10033 0.384615 0.307692 \n", - "10035 0.583333 1.000000 \n", - "10038 0.466667 0.066667 \n", - "10040 0.285714 0.000000 \n", - "10045 1.000000 1.000000 \n", - "10049 0.727273 0.363636 \n", - "10057 0.000000 0.125000 \n", - "10062 0.692308 0.307692 \n", - "20076 0.857143 0.071429 \n", - "20105 0.571429 0.071429 \n", - "20113 0.857143 0.714286 \n", - "20115 0.666667 0.800000 \n", - "20120 1.000000 0.111111 \n", - "20122 0.727273 0.000000 \n", - "20123 1.000000 0.000000 \n", - "20124 1.000000 0.111111 \n", - "20125 1.000000 0.272727 \n", - "20127 0.750000 0.000000 \n", - "20129 1.000000 0.000000 \n", - "\n", - " Drinking, eating ... Using a computer Walking, running \\\n", - "record_id ... \n", - "10011 0.923077 ... 0.923077 0.923077 \n", - "10012 0.785714 ... 1.000000 0.571429 \n", - "10014 0.666667 ... 0.583333 0.333333 \n", - "10016 1.000000 ... 0.928571 0.857143 \n", - "10023 0.785714 ... 0.428571 0.214286 \n", - "10024 1.000000 ... 0.769231 0.923077 \n", - "10025 0.928571 ... 0.857143 0.071429 \n", - "10033 1.000000 ... 1.000000 0.923077 \n", - "10035 1.000000 ... 1.000000 1.000000 \n", - "10038 0.866667 ... 0.533333 1.000000 \n", - "10040 1.000000 ... 1.000000 1.000000 \n", - "10045 1.000000 ... 1.000000 1.000000 \n", - "10049 1.000000 ... 1.000000 0.636364 \n", - "10057 0.125000 ... 0.125000 0.125000 \n", - "10062 0.846154 ... 1.000000 0.230769 \n", - "20076 1.000000 ... 0.714286 0.428571 \n", - "20105 1.000000 ... 0.428571 1.000000 \n", - "20113 0.928571 ... 0.571429 0.928571 \n", - "20115 0.933333 ... 0.800000 0.533333 \n", - "20120 1.000000 ... 1.000000 0.888889 \n", - "20122 1.000000 ... 0.818182 1.000000 \n", - "20123 0.800000 ... 0.800000 0.000000 \n", - "20124 0.888889 ... 0.888889 0.555556 \n", - "20125 1.000000 ... 0.636364 1.000000 \n", - "20127 1.000000 ... 1.000000 1.000000 \n", - "20129 1.000000 ... 1.000000 0.750000 \n", + "10011 0.000000 0.461538 \n", + "10012 0.642857 0.285714 \n", + "10014 0.000000 0.416667 \n", + "10016 0.571429 0.071429 \n", + "10023 0.785714 0.500000 \n", + "10024 0.769231 0.923077 \n", + "10025 0.428571 0.857143 \n", + "10033 0.615385 0.692308 \n", + "10035 0.500000 1.000000 \n", + "10038 0.666667 0.866667 \n", + "10040 0.714286 1.000000 \n", + "10045 0.538462 0.846154 \n", + "10049 0.636364 0.545455 \n", + "10057 0.625000 0.125000 \n", + "10062 0.153846 0.230769 \n", + "20076 0.214286 0.714286 \n", + "20105 0.142857 1.000000 \n", + "20113 0.428571 0.928571 \n", + "20115 0.000000 0.933333 \n", + "20120 0.000000 0.444444 \n", + "20122 0.000000 0.818182 \n", + "20123 0.000000 0.600000 \n", + "20124 0.000000 1.000000 \n", + "20125 0.000000 0.909091 \n", + "20127 0.250000 0.500000 \n", + "20129 0.000000 1.000000 \n", "\n", - " Watching TV, movies Working None of the above actmin_10 \\\n", - "record_id \n", - "10011 0.538462 1.000000 0.0 1.140916e+00 \n", - "10012 0.571429 0.285714 0.0 -6.410901e+00 \n", - "10014 1.000000 0.416667 0.0 NaN \n", - "10016 0.928571 0.714286 0.0 -5.975025e-02 \n", - "10023 0.285714 0.000000 0.0 -1.182390e-01 \n", - "10024 0.692308 0.000000 0.0 -3.453266e-02 \n", - "10025 0.857143 0.000000 0.0 -2.993769e+00 \n", - "10033 1.000000 0.692308 0.0 5.408549e-02 \n", - "10035 0.416667 0.000000 0.0 1.332177e-01 \n", - "10038 0.800000 0.333333 0.0 2.093756e-01 \n", - "10040 0.928571 0.000000 0.0 9.929714e-02 \n", - "10045 0.307692 0.000000 0.0 5.964428e-02 \n", - "10049 1.000000 0.545455 0.0 6.262768e-41 \n", - "10057 0.000000 0.000000 0.0 NaN \n", - "10062 0.461538 0.615385 0.0 4.788005e-01 \n", - "20076 1.000000 0.000000 0.0 NaN \n", - "20105 1.000000 0.000000 0.0 1.857181e+00 \n", - "20113 0.642857 0.000000 0.0 1.363998e+00 \n", - "20115 0.866667 0.000000 0.0 1.679336e+00 \n", - "20120 1.000000 0.000000 0.0 1.091430e+00 \n", - "20122 0.545455 0.000000 0.0 4.148404e-02 \n", - "20123 0.200000 0.400000 0.0 -1.400653e-02 \n", - "20124 0.666667 0.000000 0.0 4.505044e-02 \n", - "20125 0.545455 0.000000 0.0 -1.565747e-01 \n", - "20127 0.000000 0.000000 0.0 1.126017e+00 \n", - "20129 1.000000 0.000000 0.0 NaN \n", + " Drinking, eating ... Sadness Happiness Stress Rumination \\\n", + "record_id ... \n", + "10011 1.000000 ... 0.923077 0.923077 0.538462 1.000000 \n", + "10012 1.000000 ... 1.000000 0.571429 0.571429 0.285714 \n", + "10014 0.833333 ... 0.583333 0.333333 1.000000 0.416667 \n", + "10016 1.000000 ... 0.928571 0.857143 0.928571 0.714286 \n", + "10023 0.785714 ... 0.428571 0.214286 0.285714 0.000000 \n", + "10024 1.000000 ... 0.769231 0.923077 0.692308 0.000000 \n", + "10025 0.500000 ... 0.857143 0.071429 0.857143 0.000000 \n", + "10033 0.846154 ... 1.000000 0.923077 1.000000 0.692308 \n", + "10035 1.000000 ... 1.000000 1.000000 0.416667 0.000000 \n", + "10038 1.000000 ... 0.533333 1.000000 0.800000 0.333333 \n", + "10040 1.000000 ... 1.000000 1.000000 0.928571 0.000000 \n", + "10045 1.000000 ... 1.000000 1.000000 0.307692 0.000000 \n", + "10049 0.909091 ... 1.000000 0.636364 1.000000 0.545455 \n", + "10057 0.125000 ... 0.125000 0.125000 0.000000 0.000000 \n", + "10062 0.769231 ... 1.000000 0.230769 0.461538 0.615385 \n", + "20076 0.714286 ... 0.714286 0.428571 1.000000 0.000000 \n", + "20105 0.357143 ... 0.428571 1.000000 1.000000 0.000000 \n", + "20113 0.928571 ... 0.571429 0.928571 0.642857 0.000000 \n", + "20115 0.666667 ... 0.800000 0.533333 0.866667 0.000000 \n", + "20120 1.000000 ... 1.000000 0.888889 1.000000 0.000000 \n", + "20122 0.818182 ... 0.818182 1.000000 0.545455 0.000000 \n", + "20123 1.000000 ... 0.800000 0.000000 0.200000 0.400000 \n", + "20124 0.555556 ... 0.888889 0.555556 0.666667 0.000000 \n", + "20125 0.909091 ... 0.636364 1.000000 0.545455 0.000000 \n", + "20127 0.750000 ... 1.000000 1.000000 0.000000 0.000000 \n", + "20129 1.000000 ... 1.000000 0.750000 1.000000 0.000000 \n", "\n", - " amp_10 alpha_10 beta_10 phi_10 \n", - "record_id \n", - "10011 -4.261664e+00 -14.074745 -22.251637 -52.500316 \n", - "10012 8.866697e+00 -2.262784 0.748250 -7.154961 \n", - "10014 NaN NaN NaN NaN \n", - "10016 1.763454e+00 0.529335 -4.901354 2.589463 \n", - "10023 1.724487e+00 -0.818430 10.443968 -6.709902 \n", - "10024 1.684204e+00 -0.760088 13.661519 -6.728423 \n", - "10025 4.729876e+00 -1.199374 2.857966 -5.489378 \n", - "10033 1.601614e+00 0.584732 -48.973293 2.387816 \n", - "10035 1.540560e+00 0.609982 -440.856547 -18.864421 \n", - "10038 1.284383e+00 -0.646601 183.023943 -7.898776 \n", - "10040 1.587373e+00 -0.549218 62.810948 -7.071323 \n", - "10045 1.526655e+00 -0.620661 54.901056 -5.518533 \n", - "10049 2.395130e-40 1.000000 1.000000 1.000000 \n", - "10057 NaN NaN NaN NaN \n", - "10062 1.024258e+00 0.621045 -404.652634 2.686727 \n", - "20076 NaN NaN NaN NaN \n", - "20105 -1.814990e+00 -0.577335 -22.553110 -10.275631 \n", - "20113 -1.284790e+00 -0.271716 -5.661094 -10.095691 \n", - "20115 -1.622530e+00 -0.220805 -2.668178 -10.031367 \n", - "20120 -1.592007e-01 6.139185 -6.065396 -16.633912 \n", - "20122 1.725604e+00 0.560755 -4.492102 2.855212 \n", - "20123 1.864330e+00 0.348856 -7.681337 2.322318 \n", - "20124 1.567154e+00 0.491314 -33.275463 2.513901 \n", - "20125 1.873835e+00 0.538828 -4.055396 3.219966 \n", - "20127 -1.114323e+00 0.423147 13.870503 2.504065 \n", - "20129 NaN NaN NaN NaN \n", + " Alcohol actmin_10 amp_10 alpha_10 beta_10 phi_10 \n", + "record_id \n", + "10011 0.0 1.224985 1.679375 0.771681 -13.104473 2.647754 \n", + "10012 0.0 1.176810 1.344468 5.442158 -8.101281 -18.069600 \n", + "10014 0.0 1.892944 0.626165 6.185474 -6.415972 -12.150579 \n", + "10016 0.0 2.006809 1.019504 0.647388 -9.535801 2.887949 \n", + "10023 0.0 NaN NaN NaN NaN NaN \n", + "10024 0.0 1.529499 1.468530 0.845736 -15.776267 5.388757 \n", + "10025 0.0 -50.762123 53.842955 1.617283 -5.565424 -17.863623 \n", + "10033 0.0 5.134583 -2.655075 18.210916 -13.173022 7.915980 \n", + "10035 0.0 1.373475 1.609496 -0.729089 69.585766 -6.793869 \n", + "10038 0.0 2.349814 0.595015 0.670183 -130.757799 4.026063 \n", + "10040 0.0 -4.873827 7.908448 1.245725 -4.421485 -17.844574 \n", + "10045 0.0 1.761701 1.148013 0.665370 -21.600841 -17.546436 \n", + "10049 0.0 2.871435 -1.804360 -0.927371 -96.002515 -7.060955 \n", + "10057 0.0 NaN NaN NaN NaN NaN \n", + "10062 0.0 NaN NaN NaN NaN NaN \n", + "20076 0.0 0.860242 1.358709 4.930827 -7.485486 -1.036203 \n", + "20105 0.0 0.964368 2.052078 0.754236 -24.539640 2.280103 \n", + "20113 0.0 1.774703 1.083588 0.539876 -14.428132 1.805983 \n", + "20115 0.0 1.724968 1.106933 0.533558 -462.829431 2.804946 \n", + "20120 0.0 1.477648 1.134205 0.544053 -459.572786 2.407815 \n", + "20122 0.0 -143.881542 146.774580 2.541702 -3.111851 3.640661 \n", + "20123 0.0 1.185442 1.704768 0.486392 -12.929933 2.672762 \n", + "20124 0.0 1.319514 1.523231 0.551828 -24.636007 2.707138 \n", + "20125 0.0 0.764678 2.044402 0.940041 -5.034099 4.399277 \n", + "20127 0.0 NaN NaN NaN NaN NaN \n", + "20129 0.0 NaN NaN NaN NaN NaN \n", "\n", - "[26 rows x 34 columns]" + "[26 rows x 39 columns]" ] }, - "execution_count": 129, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" } @@ -4975,7 +4750,7 @@ }, { "cell_type": "code", - "execution_count": 130, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -4987,7 +4762,16 @@ }, { "cell_type": "code", - "execution_count": 110, + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "new = new[new['amp_10'] < 10]" + ] + }, + { + "cell_type": "code", + "execution_count": 27, "metadata": { "scrolled": true }, @@ -5024,11 +4808,11 @@ " Doing nothing (sitting around, daydreaming\n", " Drinking, eating\n", " ...\n", - " Using a computer\n", - " Walking, running\n", - " Watching TV, movies\n", - " Working\n", - " None of the above\n", + " Sadness\n", + " Happiness\n", + " Stress\n", + " Rumination\n", + " Alcohol\n", " actmin_10\n", " amp_10\n", " alpha_10\n", @@ -5065,839 +4849,600 @@ " 10011\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 0.692308\n", + " 96.384615\n", + " 3.076923\n", + " 0.153846\n", " 0.000000\n", " 0.461538\n", " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.307692\n", - " 0.153846\n", - " 0.923077\n", " ...\n", " 0.923077\n", " 0.923077\n", " 0.538462\n", " 1.000000\n", " 0.0\n", - " 1.140916e+00\n", - " -4.261664e+00\n", - " -14.074745\n", - " -22.251637\n", - " -52.500316\n", + " 1.224985\n", + " 1.679375\n", + " 0.771681\n", + " -13.104473\n", + " 2.647754\n", " \n", " \n", " 10012\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 5.857143\n", + " 55.142857\n", + " 49.500000\n", + " 0.000000\n", " 0.642857\n", " 0.285714\n", " 1.000000\n", - " 0.857143\n", - " 0.071429\n", - " 0.642857\n", - " 0.214286\n", - " 0.785714\n", " ...\n", " 1.000000\n", " 0.571429\n", " 0.571429\n", " 0.285714\n", " 0.0\n", - " -6.410901e+00\n", - " 8.866697e+00\n", - " -2.262784\n", - " 0.748250\n", - " -7.154961\n", + " 1.176810\n", + " 1.344468\n", + " 5.442158\n", + " -8.101281\n", + " -18.069600\n", " \n", " \n", " 10014\n", " Younger Adults\n", " Pre\n", + " 2.000000\n", + " 43.416667\n", + " 52.000000\n", + " 61.916667\n", + " 51.916667\n", " 0.000000\n", " 0.416667\n", " 0.833333\n", - " 0.500000\n", - " 0.000000\n", - " 0.500000\n", - " 0.583333\n", - " 0.666667\n", " ...\n", " 0.583333\n", " 0.333333\n", " 1.000000\n", " 0.416667\n", " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1.892944\n", + " 0.626165\n", + " 6.185474\n", + " -6.415972\n", + " -12.150579\n", " \n", " \n", " 10016\n", " Younger Adults\n", " Pre\n", + " 5.714286\n", + " 37.785714\n", + " 53.857143\n", + " 43.214286\n", + " 4.571429\n", " 0.571429\n", " 0.071429\n", " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 0.928571\n", " 0.857143\n", " 0.928571\n", " 0.714286\n", " 0.0\n", - " -5.975025e-02\n", - " 1.763454e+00\n", - " 0.529335\n", - " -4.901354\n", - " 2.589463\n", + " 2.006809\n", + " 1.019504\n", + " 0.647388\n", + " -9.535801\n", + " 2.887949\n", " \n", " \n", - " 10023\n", - " Younger Adults\n", - " Pre\n", - " 0.785714\n", - " 0.500000\n", - " 0.785714\n", - " 0.071429\n", - " 0.214286\n", - " 0.142857\n", - " 0.142857\n", - " 0.785714\n", - " ...\n", - " 0.428571\n", - " 0.214286\n", - " 0.285714\n", - " 0.000000\n", - " 0.0\n", - " -1.182390e-01\n", - " 1.724487e+00\n", - " -0.818430\n", - " 10.443968\n", - " -6.709902\n", - " \n", - " \n", - " 10024\n", + " 10024\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 42.230769\n", + " 67.846154\n", + " 59.692308\n", + " 28.000000\n", " 0.769231\n", " 0.923077\n", " 1.000000\n", - " 0.153846\n", - " 0.384615\n", - " 0.076923\n", - " 0.923077\n", - " 1.000000\n", " ...\n", " 0.769231\n", " 0.923077\n", " 0.692308\n", " 0.000000\n", " 0.0\n", - " -3.453266e-02\n", - " 1.684204e+00\n", - " -0.760088\n", - " 13.661519\n", - " -6.728423\n", - " \n", - " \n", - " 10025\n", - " Younger Adults\n", - " Pre\n", - " 0.428571\n", - " 0.857143\n", - " 0.500000\n", - " 0.142857\n", - " 0.000000\n", - " 0.214286\n", - " 0.500000\n", - " 0.928571\n", - " ...\n", - " 0.857143\n", - " 0.071429\n", - " 0.857143\n", - " 0.000000\n", - " 0.0\n", - " -2.993769e+00\n", - " 4.729876e+00\n", - " -1.199374\n", - " 2.857966\n", - " -5.489378\n", + " 1.529499\n", + " 1.468530\n", + " 0.845736\n", + " -15.776267\n", + " 5.388757\n", " \n", " \n", " 10033\n", " Younger Adults\n", " Pre\n", + " 1.000000\n", + " 31.692308\n", + " 64.846154\n", + " 51.615385\n", + " 27.461538\n", " 0.615385\n", " 0.692308\n", " 0.846154\n", - " 0.923077\n", - " 0.000000\n", - " 0.384615\n", - " 0.307692\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.923077\n", " 1.000000\n", " 0.692308\n", " 0.0\n", - " 5.408549e-02\n", - " 1.601614e+00\n", - " 0.584732\n", - " -48.973293\n", - " 2.387816\n", + " 5.134583\n", + " -2.655075\n", + " 18.210916\n", + " -13.173022\n", + " 7.915980\n", " \n", " \n", " 10035\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 47.750000\n", + " 65.750000\n", + " 45.333333\n", + " 28.166667\n", " 0.500000\n", " 1.000000\n", " 1.000000\n", - " 0.916667\n", - " 0.916667\n", - " 0.583333\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.416667\n", " 0.000000\n", " 0.0\n", - " 1.332177e-01\n", - " 1.540560e+00\n", - " 0.609982\n", - " -440.856547\n", - " -18.864421\n", + " 1.373475\n", + " 1.609496\n", + " -0.729089\n", + " 69.585766\n", + " -6.793869\n", " \n", " \n", " 10038\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.266667\n", + " 65.866667\n", + " 28.733333\n", + " 6.933333\n", " 0.666667\n", " 0.866667\n", " 1.000000\n", - " 0.066667\n", - " 0.466667\n", - " 0.466667\n", - " 0.066667\n", - " 0.866667\n", " ...\n", " 0.533333\n", " 1.000000\n", " 0.800000\n", " 0.333333\n", " 0.0\n", - " 2.093756e-01\n", - " 1.284383e+00\n", - " -0.646601\n", - " 183.023943\n", - " -7.898776\n", + " 2.349814\n", + " 0.595015\n", + " 0.670183\n", + " -130.757799\n", + " 4.026063\n", " \n", " \n", " 10040\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 52.500000\n", + " 63.428571\n", + " 52.000000\n", + " 47.357143\n", " 0.714286\n", " 1.000000\n", " 1.000000\n", - " 0.714286\n", - " 0.071429\n", - " 0.285714\n", - " 0.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.928571\n", " 0.000000\n", " 0.0\n", - " 9.929714e-02\n", - " 1.587373e+00\n", - " -0.549218\n", - " 62.810948\n", - " -7.071323\n", + " -4.873827\n", + " 7.908448\n", + " 1.245725\n", + " -4.421485\n", + " -17.844574\n", " \n", " \n", " 10045\n", " Younger Adults\n", " Pre\n", + " NaN\n", + " 17.461538\n", + " 74.384615\n", + " 28.923077\n", + " 20.153846\n", " 0.538462\n", " 0.846154\n", " 1.000000\n", - " 0.923077\n", - " 0.769231\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 1.000000\n", " 0.307692\n", " 0.000000\n", " 0.0\n", - " 5.964428e-02\n", - " 1.526655e+00\n", - " -0.620661\n", - " 54.901056\n", - " -5.518533\n", + " 1.761701\n", + " 1.148013\n", + " 0.665370\n", + " -21.600841\n", + " -17.546436\n", " \n", " \n", " 10049\n", " Younger Adults\n", " Pre\n", + " 1.500000\n", + " 24.818182\n", + " 66.363636\n", + " 40.909091\n", + " 23.818182\n", " 0.636364\n", " 0.545455\n", " 0.909091\n", - " 0.636364\n", - " 0.181818\n", - " 0.727273\n", - " 0.363636\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.636364\n", " 1.000000\n", " 0.545455\n", " 0.0\n", - " 6.262768e-41\n", - " 2.395130e-40\n", - " 1.000000\n", - " 1.000000\n", - " 1.000000\n", - " \n", - " \n", - " 10057\n", - " Younger Adults\n", - " Pre\n", - " 0.625000\n", - " 0.125000\n", - " 0.125000\n", - " 0.000000\n", - " 0.000000\n", - " 0.000000\n", - " 0.125000\n", - " 0.125000\n", - " ...\n", - " 0.125000\n", - " 0.125000\n", - " 0.000000\n", - " 0.000000\n", - " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " \n", - " \n", - " 10062\n", - " Younger Adults\n", - " Pre\n", - " 0.153846\n", - " 0.230769\n", - " 0.769231\n", - " 0.846154\n", - " 0.230769\n", - " 0.692308\n", - " 0.307692\n", - " 0.846154\n", - " ...\n", - " 1.000000\n", - " 0.230769\n", - " 0.461538\n", - " 0.615385\n", - " 0.0\n", - " 4.788005e-01\n", - " 1.024258e+00\n", - " 0.621045\n", - " -404.652634\n", - " 2.686727\n", + " 2.871435\n", + " -1.804360\n", + " -0.927371\n", + " -96.002515\n", + " -7.060955\n", " \n", " \n", " 20076\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 5.214286\n", + " 50.153846\n", + " 34.214286\n", + " 5.071429\n", " 0.214286\n", " 0.714286\n", " 0.714286\n", - " 0.142857\n", - " 0.071429\n", - " 0.857143\n", - " 0.071429\n", - " 1.000000\n", " ...\n", " 0.714286\n", " 0.428571\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.860242\n", + " 1.358709\n", + " 4.930827\n", + " -7.485486\n", + " -1.036203\n", " \n", " \n", " 20105\n", " Older Adults\n", " Pre\n", + " 1.000000\n", + " 2.857143\n", + " 92.500000\n", + " 6.642857\n", + " 0.428571\n", " 0.142857\n", " 1.000000\n", " 0.357143\n", - " 0.785714\n", - " 0.214286\n", - " 0.571429\n", - " 0.071429\n", - " 1.000000\n", " ...\n", " 0.428571\n", " 1.000000\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " 1.857181e+00\n", - " -1.814990e+00\n", - " -0.577335\n", - " -22.553110\n", - " -10.275631\n", + " 0.964368\n", + " 2.052078\n", + " 0.754236\n", + " -24.539640\n", + " 2.280103\n", " \n", " \n", " 20113\n", " Older Adults\n", " Pre\n", + " NaN\n", + " 10.714286\n", + " 53.785714\n", + " 33.642857\n", + " 13.357143\n", " 0.428571\n", " 0.928571\n", " 0.928571\n", - " 0.928571\n", - " 0.357143\n", - " 0.857143\n", - " 0.714286\n", - " 0.928571\n", " ...\n", " 0.571429\n", " 0.928571\n", " 0.642857\n", " 0.000000\n", " 0.0\n", - " 1.363998e+00\n", - " -1.284790e+00\n", - " -0.271716\n", - " -5.661094\n", - " -10.095691\n", + " 1.774703\n", + " 1.083588\n", + " 0.539876\n", + " -14.428132\n", + " 1.805983\n", " \n", " \n", " 20115\n", " Older Adults\n", " Pre\n", + " 1.333333\n", + " 18.666667\n", + " 80.400000\n", + " 25.400000\n", + " 77.800000\n", " 0.000000\n", " 0.933333\n", " 0.666667\n", - " 0.533333\n", - " 0.066667\n", - " 0.666667\n", - " 0.800000\n", - " 0.933333\n", " ...\n", " 0.800000\n", " 0.533333\n", " 0.866667\n", " 0.000000\n", " 0.0\n", - " 1.679336e+00\n", - " -1.622530e+00\n", - " -0.220805\n", - " -2.668178\n", - " -10.031367\n", + " 1.724968\n", + " 1.106933\n", + " 0.533558\n", + " -462.829431\n", + " 2.804946\n", " \n", " \n", " 20120\n", " Older Adults\n", " Post\n", + " NaN\n", + " 10.777778\n", + " 74.666667\n", + " 35.333333\n", + " 5.111111\n", " 0.000000\n", " 0.444444\n", " 1.000000\n", - " 0.444444\n", - " 0.444444\n", - " 1.000000\n", - " 0.111111\n", - " 1.000000\n", " ...\n", " 1.000000\n", " 0.888889\n", " 1.000000\n", " 0.000000\n", " 0.0\n", - " 1.091430e+00\n", - " -1.592007e-01\n", - " 6.139185\n", - " -6.065396\n", - " -16.633912\n", - " \n", - " \n", - " 20122\n", - " Older Adults\n", - " Post\n", - " 0.000000\n", - " 0.818182\n", - " 0.818182\n", - " 0.181818\n", - " 0.000000\n", - " 0.727273\n", - " 0.000000\n", - " 1.000000\n", - " ...\n", - " 0.818182\n", - " 1.000000\n", - " 0.545455\n", - " 0.000000\n", - " 0.0\n", - " 4.148404e-02\n", - " 1.725604e+00\n", - " 0.560755\n", - " -4.492102\n", - " 2.855212\n", + " 1.477648\n", + " 1.134205\n", + " 0.544053\n", + " -459.572786\n", + " 2.407815\n", " \n", " \n", " 20123\n", " Older Adults\n", " Post\n", + " NaN\n", + " 7.400000\n", + " 81.800000\n", + " 31.600000\n", + " 16.400000\n", " 0.000000\n", " 0.600000\n", " 1.000000\n", - " 0.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.800000\n", " ...\n", " 0.800000\n", " 0.000000\n", " 0.200000\n", " 0.400000\n", " 0.0\n", - " -1.400653e-02\n", - " 1.864330e+00\n", - " 0.348856\n", - " -7.681337\n", - " 2.322318\n", + " 1.185442\n", + " 1.704768\n", + " 0.486392\n", + " -12.929933\n", + " 2.672762\n", " \n", " \n", " 20124\n", " Older Adults\n", " Post\n", + " NaN\n", + " 2.777778\n", + " 88.000000\n", + " 7.222222\n", + " 5.444444\n", " 0.000000\n", " 1.000000\n", " 0.555556\n", - " 0.222222\n", - " 0.555556\n", - " 1.000000\n", - " 0.111111\n", - " 0.888889\n", " ...\n", " 0.888889\n", " 0.555556\n", " 0.666667\n", " 0.000000\n", " 0.0\n", - " 4.505044e-02\n", - " 1.567154e+00\n", - " 0.491314\n", - " -33.275463\n", - " 2.513901\n", + " 1.319514\n", + " 1.523231\n", + " 0.551828\n", + " -24.636007\n", + " 2.707138\n", " \n", " \n", " 20125\n", " Older Adults\n", " Post\n", + " 2.500000\n", + " 8.909091\n", + " 67.454545\n", + " 13.727273\n", + " 9.090909\n", " 0.000000\n", " 0.909091\n", " 0.909091\n", - " 0.363636\n", - " 0.000000\n", - " 1.000000\n", - " 0.272727\n", - " 1.000000\n", " ...\n", " 0.636364\n", " 1.000000\n", " 0.545455\n", " 0.000000\n", " 0.0\n", - " -1.565747e-01\n", - " 1.873835e+00\n", - " 0.538828\n", - " -4.055396\n", - " 3.219966\n", - " \n", - " \n", - " 20127\n", - " Older Adults\n", - " Post\n", - " 0.250000\n", - " 0.500000\n", - " 0.750000\n", - " 0.500000\n", - " 0.000000\n", - " 0.750000\n", - " 0.000000\n", - " 1.000000\n", - " ...\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.000000\n", - " 0.0\n", - " 1.126017e+00\n", - " -1.114323e+00\n", - " 0.423147\n", - " 13.870503\n", - " 2.504065\n", - " \n", - " \n", - " 20129\n", - " Older Adults\n", - " Post\n", - " 0.000000\n", - " 1.000000\n", - " 1.000000\n", - " 0.000000\n", - " 0.000000\n", - " 1.000000\n", - " 0.000000\n", - " 1.000000\n", - " ...\n", - " 1.000000\n", - " 0.750000\n", - " 1.000000\n", - " 0.000000\n", - " 0.0\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.764678\n", + " 2.044402\n", + " 0.940041\n", + " -5.034099\n", + " 4.399277\n", " \n", " \n", "\n", - "

26 rows × 34 columns

\n", + "

19 rows × 39 columns

\n", "" ], "text/plain": [ " age_group COVID Attending classes, meetings \\\n", "record_id \n", - "10011 Younger Adults Pre 0.000000 \n", - "10012 Younger Adults Pre 0.642857 \n", - "10014 Younger Adults Pre 0.000000 \n", - "10016 Younger Adults Pre 0.571429 \n", - "10023 Younger Adults Pre 0.785714 \n", - "10024 Younger Adults Pre 0.769231 \n", - "10025 Younger Adults Pre 0.428571 \n", - "10033 Younger Adults Pre 0.615385 \n", - "10035 Younger Adults Pre 0.500000 \n", - "10038 Younger Adults Pre 0.666667 \n", - "10040 Younger Adults Pre 0.714286 \n", - "10045 Younger Adults Pre 0.538462 \n", - "10049 Younger Adults Pre 0.636364 \n", - "10057 Younger Adults Pre 0.625000 \n", - "10062 Younger Adults Pre 0.153846 \n", - "20076 Older Adults Pre 0.214286 \n", - "20105 Older Adults Pre 0.142857 \n", - "20113 Older Adults Pre 0.428571 \n", - "20115 Older Adults Pre 0.000000 \n", - "20120 Older Adults Post 0.000000 \n", - "20122 Older Adults Post 0.000000 \n", - "20123 Older Adults Post 0.000000 \n", - "20124 Older Adults Post 0.000000 \n", - "20125 Older Adults Post 0.000000 \n", - "20127 Older Adults Post 0.250000 \n", - "20129 Older Adults Post 0.000000 \n", + "10011 Younger Adults Pre NaN \n", + "10012 Younger Adults Pre 1.500000 \n", + "10014 Younger Adults Pre 2.000000 \n", + "10016 Younger Adults Pre 5.714286 \n", + "10024 Younger Adults Pre NaN \n", + "10033 Younger Adults Pre 1.000000 \n", + "10035 Younger Adults Pre NaN \n", + "10038 Younger Adults Pre NaN \n", + "10040 Younger Adults Pre NaN \n", + "10045 Younger Adults Pre NaN \n", + "10049 Younger Adults Pre 1.500000 \n", + "20076 Older Adults Pre 1.000000 \n", + "20105 Older Adults Pre 1.000000 \n", + "20113 Older Adults Pre NaN \n", + "20115 Older Adults Pre 1.333333 \n", + "20120 Older Adults Post NaN \n", + "20123 Older Adults Post NaN \n", + "20124 Older Adults Post NaN \n", + "20125 Older Adults Post 2.500000 \n", "\n", " Being physically animated, moving around Browsing the internet \\\n", "record_id \n", - "10011 0.461538 1.000000 \n", - "10012 0.285714 1.000000 \n", - "10014 0.416667 0.833333 \n", - "10016 0.071429 1.000000 \n", - "10023 0.500000 0.785714 \n", - "10024 0.923077 1.000000 \n", - "10025 0.857143 0.500000 \n", - "10033 0.692308 0.846154 \n", - "10035 1.000000 1.000000 \n", - "10038 0.866667 1.000000 \n", - "10040 1.000000 1.000000 \n", - "10045 0.846154 1.000000 \n", - "10049 0.545455 0.909091 \n", - "10057 0.125000 0.125000 \n", - "10062 0.230769 0.769231 \n", - "20076 0.714286 0.714286 \n", - "20105 1.000000 0.357143 \n", - "20113 0.928571 0.928571 \n", - "20115 0.933333 0.666667 \n", - "20120 0.444444 1.000000 \n", - "20122 0.818182 0.818182 \n", - "20123 0.600000 1.000000 \n", - "20124 1.000000 0.555556 \n", - "20125 0.909091 0.909091 \n", - "20127 0.500000 0.750000 \n", - "20129 1.000000 1.000000 \n", + "10011 0.692308 96.384615 \n", + "10012 5.857143 55.142857 \n", + "10014 43.416667 52.000000 \n", + "10016 37.785714 53.857143 \n", + "10024 42.230769 67.846154 \n", + "10033 31.692308 64.846154 \n", + "10035 47.750000 65.750000 \n", + "10038 17.266667 65.866667 \n", + "10040 52.500000 63.428571 \n", + "10045 17.461538 74.384615 \n", + "10049 24.818182 66.363636 \n", + "20076 5.214286 50.153846 \n", + "20105 2.857143 92.500000 \n", + "20113 10.714286 53.785714 \n", + "20115 18.666667 80.400000 \n", + "20120 10.777778 74.666667 \n", + "20123 7.400000 81.800000 \n", + "20124 2.777778 88.000000 \n", + "20125 8.909091 67.454545 \n", "\n", " Commuting, traveling Doing a favor, helping others \\\n", "record_id \n", - "10011 1.000000 0.000000 \n", - "10012 0.857143 0.071429 \n", - "10014 0.500000 0.000000 \n", - "10016 1.000000 0.000000 \n", - "10023 0.071429 0.214286 \n", - "10024 0.153846 0.384615 \n", - "10025 0.142857 0.000000 \n", - "10033 0.923077 0.000000 \n", - "10035 0.916667 0.916667 \n", - "10038 0.066667 0.466667 \n", - "10040 0.714286 0.071429 \n", - "10045 0.923077 0.769231 \n", - "10049 0.636364 0.181818 \n", - "10057 0.000000 0.000000 \n", - "10062 0.846154 0.230769 \n", - "20076 0.142857 0.071429 \n", - "20105 0.785714 0.214286 \n", - "20113 0.928571 0.357143 \n", - "20115 0.533333 0.066667 \n", - "20120 0.444444 0.444444 \n", - "20122 0.181818 0.000000 \n", - "20123 0.000000 0.000000 \n", - "20124 0.222222 0.555556 \n", - "20125 0.363636 0.000000 \n", - "20127 0.500000 0.000000 \n", - "20129 0.000000 0.000000 \n", + "10011 3.076923 0.153846 \n", + "10012 49.500000 0.000000 \n", + "10014 61.916667 51.916667 \n", + "10016 43.214286 4.571429 \n", + "10024 59.692308 28.000000 \n", + "10033 51.615385 27.461538 \n", + "10035 45.333333 28.166667 \n", + "10038 28.733333 6.933333 \n", + "10040 52.000000 47.357143 \n", + "10045 28.923077 20.153846 \n", + "10049 40.909091 23.818182 \n", + "20076 34.214286 5.071429 \n", + "20105 6.642857 0.428571 \n", + "20113 33.642857 13.357143 \n", + "20115 25.400000 77.800000 \n", + "20120 35.333333 5.111111 \n", + "20123 31.600000 16.400000 \n", + "20124 7.222222 5.444444 \n", + "20125 13.727273 9.090909 \n", "\n", " Doing household chores Doing nothing (sitting around, daydreaming \\\n", "record_id \n", - "10011 0.307692 0.153846 \n", - "10012 0.642857 0.214286 \n", - "10014 0.500000 0.583333 \n", - "10016 1.000000 0.000000 \n", - "10023 0.142857 0.142857 \n", - "10024 0.076923 0.923077 \n", - "10025 0.214286 0.500000 \n", - "10033 0.384615 0.307692 \n", - "10035 0.583333 1.000000 \n", - "10038 0.466667 0.066667 \n", - "10040 0.285714 0.000000 \n", - "10045 1.000000 1.000000 \n", - "10049 0.727273 0.363636 \n", - "10057 0.000000 0.125000 \n", - "10062 0.692308 0.307692 \n", - "20076 0.857143 0.071429 \n", - "20105 0.571429 0.071429 \n", - "20113 0.857143 0.714286 \n", - "20115 0.666667 0.800000 \n", - "20120 1.000000 0.111111 \n", - "20122 0.727273 0.000000 \n", - "20123 1.000000 0.000000 \n", - "20124 1.000000 0.111111 \n", - "20125 1.000000 0.272727 \n", - "20127 0.750000 0.000000 \n", - "20129 1.000000 0.000000 \n", + "10011 0.000000 0.461538 \n", + "10012 0.642857 0.285714 \n", + "10014 0.000000 0.416667 \n", + "10016 0.571429 0.071429 \n", + "10024 0.769231 0.923077 \n", + "10033 0.615385 0.692308 \n", + "10035 0.500000 1.000000 \n", + "10038 0.666667 0.866667 \n", + "10040 0.714286 1.000000 \n", + "10045 0.538462 0.846154 \n", + "10049 0.636364 0.545455 \n", + "20076 0.214286 0.714286 \n", + "20105 0.142857 1.000000 \n", + "20113 0.428571 0.928571 \n", + "20115 0.000000 0.933333 \n", + "20120 0.000000 0.444444 \n", + "20123 0.000000 0.600000 \n", + "20124 0.000000 1.000000 \n", + "20125 0.000000 0.909091 \n", "\n", - " Drinking, eating ... Using a computer Walking, running \\\n", - "record_id ... \n", - "10011 0.923077 ... 0.923077 0.923077 \n", - "10012 0.785714 ... 1.000000 0.571429 \n", - "10014 0.666667 ... 0.583333 0.333333 \n", - "10016 1.000000 ... 0.928571 0.857143 \n", - "10023 0.785714 ... 0.428571 0.214286 \n", - "10024 1.000000 ... 0.769231 0.923077 \n", - "10025 0.928571 ... 0.857143 0.071429 \n", - "10033 1.000000 ... 1.000000 0.923077 \n", - "10035 1.000000 ... 1.000000 1.000000 \n", - "10038 0.866667 ... 0.533333 1.000000 \n", - "10040 1.000000 ... 1.000000 1.000000 \n", - "10045 1.000000 ... 1.000000 1.000000 \n", - "10049 1.000000 ... 1.000000 0.636364 \n", - "10057 0.125000 ... 0.125000 0.125000 \n", - "10062 0.846154 ... 1.000000 0.230769 \n", - "20076 1.000000 ... 0.714286 0.428571 \n", - "20105 1.000000 ... 0.428571 1.000000 \n", - "20113 0.928571 ... 0.571429 0.928571 \n", - "20115 0.933333 ... 0.800000 0.533333 \n", - "20120 1.000000 ... 1.000000 0.888889 \n", - "20122 1.000000 ... 0.818182 1.000000 \n", - "20123 0.800000 ... 0.800000 0.000000 \n", - "20124 0.888889 ... 0.888889 0.555556 \n", - "20125 1.000000 ... 0.636364 1.000000 \n", - "20127 1.000000 ... 1.000000 1.000000 \n", - "20129 1.000000 ... 1.000000 0.750000 \n", + " Drinking, eating ... Sadness Happiness Stress Rumination \\\n", + "record_id ... \n", + "10011 1.000000 ... 0.923077 0.923077 0.538462 1.000000 \n", + "10012 1.000000 ... 1.000000 0.571429 0.571429 0.285714 \n", + "10014 0.833333 ... 0.583333 0.333333 1.000000 0.416667 \n", + "10016 1.000000 ... 0.928571 0.857143 0.928571 0.714286 \n", + "10024 1.000000 ... 0.769231 0.923077 0.692308 0.000000 \n", + "10033 0.846154 ... 1.000000 0.923077 1.000000 0.692308 \n", + "10035 1.000000 ... 1.000000 1.000000 0.416667 0.000000 \n", + "10038 1.000000 ... 0.533333 1.000000 0.800000 0.333333 \n", + "10040 1.000000 ... 1.000000 1.000000 0.928571 0.000000 \n", + "10045 1.000000 ... 1.000000 1.000000 0.307692 0.000000 \n", + "10049 0.909091 ... 1.000000 0.636364 1.000000 0.545455 \n", + "20076 0.714286 ... 0.714286 0.428571 1.000000 0.000000 \n", + "20105 0.357143 ... 0.428571 1.000000 1.000000 0.000000 \n", + "20113 0.928571 ... 0.571429 0.928571 0.642857 0.000000 \n", + "20115 0.666667 ... 0.800000 0.533333 0.866667 0.000000 \n", + "20120 1.000000 ... 1.000000 0.888889 1.000000 0.000000 \n", + "20123 1.000000 ... 0.800000 0.000000 0.200000 0.400000 \n", + "20124 0.555556 ... 0.888889 0.555556 0.666667 0.000000 \n", + "20125 0.909091 ... 0.636364 1.000000 0.545455 0.000000 \n", "\n", - " Watching TV, movies Working None of the above actmin_10 \\\n", - "record_id \n", - "10011 0.538462 1.000000 0.0 1.140916e+00 \n", - "10012 0.571429 0.285714 0.0 -6.410901e+00 \n", - "10014 1.000000 0.416667 0.0 NaN \n", - "10016 0.928571 0.714286 0.0 -5.975025e-02 \n", - "10023 0.285714 0.000000 0.0 -1.182390e-01 \n", - "10024 0.692308 0.000000 0.0 -3.453266e-02 \n", - "10025 0.857143 0.000000 0.0 -2.993769e+00 \n", - "10033 1.000000 0.692308 0.0 5.408549e-02 \n", - "10035 0.416667 0.000000 0.0 1.332177e-01 \n", - "10038 0.800000 0.333333 0.0 2.093756e-01 \n", - "10040 0.928571 0.000000 0.0 9.929714e-02 \n", - "10045 0.307692 0.000000 0.0 5.964428e-02 \n", - "10049 1.000000 0.545455 0.0 6.262768e-41 \n", - "10057 0.000000 0.000000 0.0 NaN \n", - "10062 0.461538 0.615385 0.0 4.788005e-01 \n", - "20076 1.000000 0.000000 0.0 NaN \n", - "20105 1.000000 0.000000 0.0 1.857181e+00 \n", - "20113 0.642857 0.000000 0.0 1.363998e+00 \n", - "20115 0.866667 0.000000 0.0 1.679336e+00 \n", - "20120 1.000000 0.000000 0.0 1.091430e+00 \n", - "20122 0.545455 0.000000 0.0 4.148404e-02 \n", - "20123 0.200000 0.400000 0.0 -1.400653e-02 \n", - "20124 0.666667 0.000000 0.0 4.505044e-02 \n", - "20125 0.545455 0.000000 0.0 -1.565747e-01 \n", - "20127 0.000000 0.000000 0.0 1.126017e+00 \n", - "20129 1.000000 0.000000 0.0 NaN \n", + " Alcohol actmin_10 amp_10 alpha_10 beta_10 phi_10 \n", + "record_id \n", + "10011 0.0 1.224985 1.679375 0.771681 -13.104473 2.647754 \n", + "10012 0.0 1.176810 1.344468 5.442158 -8.101281 -18.069600 \n", + "10014 0.0 1.892944 0.626165 6.185474 -6.415972 -12.150579 \n", + "10016 0.0 2.006809 1.019504 0.647388 -9.535801 2.887949 \n", + "10024 0.0 1.529499 1.468530 0.845736 -15.776267 5.388757 \n", + "10033 0.0 5.134583 -2.655075 18.210916 -13.173022 7.915980 \n", + "10035 0.0 1.373475 1.609496 -0.729089 69.585766 -6.793869 \n", + "10038 0.0 2.349814 0.595015 0.670183 -130.757799 4.026063 \n", + "10040 0.0 -4.873827 7.908448 1.245725 -4.421485 -17.844574 \n", + "10045 0.0 1.761701 1.148013 0.665370 -21.600841 -17.546436 \n", + "10049 0.0 2.871435 -1.804360 -0.927371 -96.002515 -7.060955 \n", + "20076 0.0 0.860242 1.358709 4.930827 -7.485486 -1.036203 \n", + "20105 0.0 0.964368 2.052078 0.754236 -24.539640 2.280103 \n", + "20113 0.0 1.774703 1.083588 0.539876 -14.428132 1.805983 \n", + "20115 0.0 1.724968 1.106933 0.533558 -462.829431 2.804946 \n", + "20120 0.0 1.477648 1.134205 0.544053 -459.572786 2.407815 \n", + "20123 0.0 1.185442 1.704768 0.486392 -12.929933 2.672762 \n", + "20124 0.0 1.319514 1.523231 0.551828 -24.636007 2.707138 \n", + "20125 0.0 0.764678 2.044402 0.940041 -5.034099 4.399277 \n", "\n", - " amp_10 alpha_10 beta_10 phi_10 \n", - "record_id \n", - "10011 -4.261664e+00 -14.074745 -22.251637 -52.500316 \n", - "10012 8.866697e+00 -2.262784 0.748250 -7.154961 \n", - "10014 NaN NaN NaN NaN \n", - "10016 1.763454e+00 0.529335 -4.901354 2.589463 \n", - "10023 1.724487e+00 -0.818430 10.443968 -6.709902 \n", - "10024 1.684204e+00 -0.760088 13.661519 -6.728423 \n", - "10025 4.729876e+00 -1.199374 2.857966 -5.489378 \n", - "10033 1.601614e+00 0.584732 -48.973293 2.387816 \n", - "10035 1.540560e+00 0.609982 -440.856547 -18.864421 \n", - "10038 1.284383e+00 -0.646601 183.023943 -7.898776 \n", - "10040 1.587373e+00 -0.549218 62.810948 -7.071323 \n", - "10045 1.526655e+00 -0.620661 54.901056 -5.518533 \n", - "10049 2.395130e-40 1.000000 1.000000 1.000000 \n", - "10057 NaN NaN NaN NaN \n", - "10062 1.024258e+00 0.621045 -404.652634 2.686727 \n", - "20076 NaN NaN NaN NaN \n", - "20105 -1.814990e+00 -0.577335 -22.553110 -10.275631 \n", - "20113 -1.284790e+00 -0.271716 -5.661094 -10.095691 \n", - "20115 -1.622530e+00 -0.220805 -2.668178 -10.031367 \n", - "20120 -1.592007e-01 6.139185 -6.065396 -16.633912 \n", - "20122 1.725604e+00 0.560755 -4.492102 2.855212 \n", - "20123 1.864330e+00 0.348856 -7.681337 2.322318 \n", - "20124 1.567154e+00 0.491314 -33.275463 2.513901 \n", - "20125 1.873835e+00 0.538828 -4.055396 3.219966 \n", - "20127 -1.114323e+00 0.423147 13.870503 2.504065 \n", - "20129 NaN NaN NaN NaN \n", - "\n", - "[26 rows x 34 columns]" + "[19 rows x 39 columns]" ] }, - "execution_count": 110, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -5908,7 +5453,7 @@ }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 28, "metadata": {}, "outputs": [ { @@ -5933,13 +5478,13 @@ "Text(0.5, 0.98, 'Rest-Activity Measures by Age Group and Before vs During COVID-19')" ] }, - "execution_count": 92, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -5962,38 +5507,22 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 29, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n", - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n", - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n", - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n", - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, { "data": { "text/plain": [ "Text(0.5, 0.98, 'Rest-Activity Measures in Older Adults Before vs During COVID-19')" ] }, - "execution_count": 93, + "execution_count": 29, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6016,32 +5545,24 @@ }, { "cell_type": "code", - "execution_count": 151, + "execution_count": 30, "metadata": { "scrolled": true }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/usr/local/lib/python3.7/site-packages/numpy/core/_asarray.py:83: VisibleDeprecationWarning: Creating an ndarray from ragged nested sequences (which is a list-or-tuple of lists-or-tuples-or ndarrays with different lengths or shapes) is deprecated. If you meant to do this, you must specify 'dtype=object' when creating the ndarray\n", - " return array(a, dtype, copy=False, order=order)\n" - ] - }, { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 151, + "execution_count": 30, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6065,7 +5586,7 @@ }, { "cell_type": "code", - "execution_count": 136, + "execution_count": 31, "metadata": { "scrolled": true }, @@ -6338,7 +5859,7 @@ "10139 27.0 0.296260 1.0 0.0" ] }, - "execution_count": 136, + "execution_count": 31, "metadata": {}, "output_type": "execute_result" } @@ -6352,7 +5873,7 @@ }, { "cell_type": "code", - "execution_count": 159, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -6364,22 +5885,22 @@ }, { "cell_type": "code", - "execution_count": 169, + "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 169, + "execution_count": 33, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6400,22 +5921,22 @@ }, { "cell_type": "code", - "execution_count": 170, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 170, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEGCAYAAABvtY4XAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAaUUlEQVR4nO3dfXRV9Z3v8feHGEx8gjua6R1AG+ogLkUqmuvS6m2t1Iv1EdEidNqOOmtYdy3vqCOXrqL3okM7t3UxrX2y46JKHecyKLSApT5gR62Oc1uniVDQUsQqSoKOyBgUCRLo9/5xdjCJyck5ydnnJDuf11qsnPPb+/x+33NIPtnZD7+tiMDMzLJnRKULMDOzdDjgzcwyygFvZpZRDngzs4xywJuZZdQhlS6gs2OOOSbq6+srXYaZ2ZDR1NT0VkTU9bRsUAV8fX09jY2NlS7DzGzIkPRqb8u8i8bMLKMc8GZmGeWANzPLqEG1D97MLA3t7e00Nzezd+/eSpfSbzU1NYwbN47q6uqCX+OAN7PMa25u5sgjj6S+vh5JlS6naBHBzp07aW5uZvz48QW/LtWAlzQauBuYBARwbUT8Ms0xzaz/Vq9rYdHazWxvbWPM6FrmTZvI9CljyzP4huXw+ELY1QyjxsHUBTB5Zkm63rt375ANdwBJHH300ezYsaOo16W9Bf8d4NGIuFLSSOCwlMczs35ava6F+Ss30tZ+AICW1jbmr9wIkH7Ib1gOa66H9rbc813bcs+hZCE/VMO9Q3/qT+0gq6RRwCeBewAiYl9EtKY1npkNzKK1mw+Ge4e29gMsWrs5/cEfX/hBuHdob8u1W7+leRbNeGAH8CNJ6yTdLenw7itJmiOpUVJjsX9+mFnpbG9tK6q9pHY1F9c+xEQE55xzDo888sjBthUrVnDBBRfw1ltvUV1dzV133VXycdMM+EOA04C/j4gpwHvAV7qvFBGLI6IhIhrq6nq82tbMymDM6Nqi2ktq1Lji2ocYSdx1113cdNNN7N27l927d3PzzTdz5513smLFCs4880yWLVtW8nHTDPhmoDkink2e/5hc4JvZIDRv2kRqq6u6tNVWVzFv2sT0B5+6AKq7/SKprs21V8DqdS2c/Y0nGP+Vhzj7G0+wel3LgPucNGkSl1xyCbfffjsLFy7kS1/6EscffzzLli3jm9/8Ji0tLTQ3l/YvltQOskbEG5K2SZoYEZuBqcBv0xrPzAam40BqRc6i6TiQmtJZNMVI82DzrbfeymmnncbIkSNpbGxk27ZtvP7665xxxhnMnDmTBx54gLlz5w74PXRI+yyavwKWJmfQvAxck/J4ZjYA06eMLd9pkd1NnlmRQO8u38HmgX42hx9+OFdddRVHHHEEhx56KA888AAzZ+be86xZs7j22muHTsBHxHqgIc0xzMxKKe2DzSNGjGDEiNze8WXLlvHGG2+wdOnS3Bjbt7NlyxYmTJhQmrFK0ouZWUaU62Dziy++yO7du2lpaWHr1q1s3bqV+fPnl/RgqwPezKyTch1sXrZsGZdffnmXtiuuuKKkAe+5aMzMOkn7YPNtt93W67LJkyezadOmkowDDngzsw+p6MHmEvIuGjOzjHLAm5lllAPezCyjHPBmZhnlgDczyygHvJlZGTQ3N3PZZZcxYcIEjj/+eG644Qb27dt3cPn06dM588wzSzqmA97MLGURwYwZM5g+fTpbtmw5eBXrLbfcAkBraytNTU3s2rWLl19+uWTjOuDNzLrbsBzumAS3jc593bB8QN098cQT1NTUcM01ufkWq6qquOOOO1iyZAl79uxh5cqVXHLJJcyaNYv777+/FO8AcMCbmXXVcX/YXduA+OD+sAMI+RdeeIHTTz+9S9tRRx3Fcccdx0svvcSyZcuYPXs2s2fP9lw0ZmapKfP9Yd9++222bNnCOeecwwknnEB1dTXPP/98Sfp2wJuZdZbC/WFPOukkmpqaurS98847vPbaa6xfv563336b8ePHU19fz9atW0u2Fe+ANzPrLIX7w06dOpU9e/Zw3333AXDgwAHmzp3L1VdfzQMPPMCjjz56cMrgpqamku2Hd8CbmXWWwv1hJbFq1SpWrFjBhAkTOOGEE6ipqWHOnDm8+uqrXU6PHD9+PKNGjeLZZ5/N02NhPJukmVlnKd0f9thjj2XNmjUfam9p+fANvZ977rkBjdXBAW9m1t0guT/sQHkXjZlZRjngzWxYiIhKlzAg/anfAW9mmVdTU8POnTuHbMhHBDt37qSmpqao13kfvJll3rhx42hubmbHjh2VLqXfampqGDeuuFM1HfBmlnnV1dWMHz++0mWUXaoBL2kr8C5wANgfEQ1pjmdmZh8oxxb8pyPirTKMY2Zmnfggq5lZRqUd8AE8JqlJ0pyeVpA0R1KjpMahfADEzGywSTvgz4mI04DPAtdJ+mT3FSJicUQ0RERDXV1dyuWYmQ0fqQZ8RLQkX98EVgFnpDmemZl9ILWAl3S4pCM7HgP/DSjNLPZmZtanNM+i+QiwSlLHOP8UEY+mOJ6ZmXWSWsBHxMvAx9Pq38zM8vNpkmZmGeWANzPLKAe8mVlGOeDNzDLKAW9mllEOeDOzjHLAm5lllAPezCyjHPBmZhnlgDczyygHvJlZRjngzcwyygFvZpZRDngzs4xywJuZZZQD3swsoxzwZmYZ5YA3M8soB7yZWUY54M3MMsoBb2aWUQ54M7OM6jPgJR0uaUTy+ARJl0qqTr80MzMbiEK24J8GaiSNBR4Dvgjcm2ZRZmY2cIUEvCJiDzAD+EFEfA44udABJFVJWifpZ/0t0szMildQwEs6C/gz4KGkraqIMW4ANhVbmJmZDUwhAX8DMB9YFREvSPoY8GQhnUsaB1wE3N3/Es3MrD8OKWCdj0TEpR1PIuJlSf9SYP/fBr4MHNnbCpLmAHMAjjvuuAK7NTOzvhSyBT+/wLYuJF0MvBkRTfnWi4jFEdEQEQ11dXUFlGNmZoXodQte0meBC4Gxkr7badFRwP4C+j4buFTShUANcJSk/xsRXxhIwWZmVph8W/DbgUZgL9DU6d9PgWl9dRwR8yNiXETUA7OAJxzuZmbl0+sWfET8RtLzwLSI+Icy1mRmZiWQ9yBrRByQdKykkRGxr7+DRMQvgF/09/VmZla8Qs6ieQX4V0k/Bd7raIyIb6VWlZmZDVghAf/75N8I8pzuaGZmg0ufAR8Rf1OOQszMrLT6DHhJdeQuVjqZ3OmOAETEeSnWZWZmA1TIhU5Lgd8B44G/AbYCv06xJjMzK4FCAv7oiLgHaI+IpyLiWsBb72Zmg1whB1nbk6+vS7qI3AVQf5ReSWZmVgqFBPzXJI0C5gLfIzdVwY2pVmVmZgNWSMC/HRG7gF3ApwEknZ1qVWZmNmCF7IP/XoFtZmY2iOSbTfIs4BNAnaSbOi06iuLu6GRmZhWQbxfNSOCIZJ3OV7C+A1yZZlFmZjZw+WaTfAp4StK9EfEqgKT/BLRGRJSrQDMz659e98FLWiDpxIh4VdKhkp4gNyfNv0v6TPlKNDOz/sh3kPUqYHPy+M+TdeuATwH/J+W6zMxsgPIF/L5Ou2KmAcsi4kBEbKKw0yvNzKyC8gX8+5ImJZONfRp4rNOyw9Ity8zMBirflvgNwI/J7Za5IyJeAUhuor2uDLWZmdkA5DuL5lngxB7aHwYeTrMoMzMbuEKuZDUzsyHIAW9mllEOeDOzjOoz4CUdJul/S/ph8nyCpIvTL83MzAaikC34HwHvA2clz1uAr6VWkZmZlUQhFywdHxFXSZoNEBF7JKmvF0mqAZ4GDk3G+XFE3DqgaoeZ1etaWLR2M9tb2xgzupZ50yYyfcrYSpdlNuj4Z6VnhQT8Pkm1QABIOp7cFn1f3gfOi4jdkqqBZyQ9EhG/6n+5w8fqdS3MX7mRtvYDALS0tjF/5UYAf+OadeKfld4VsovmVuBR4FhJS4HHgS/39aLI2Z08rU7+eRbKAi1au/ngN2yHtvYDLFq7uZdXmA1P/lnpXZ9b8BHxc0nPAWcCAm6IiLcK6VxSFdAE/ClwZ3LxVPd15gBzAI477rgiSs+27a1tRbWbDVf+WeldIWfRnA3sjYiHgNHAzZI+WkjnyeRkpwLjgDMkTephncUR0RARDXV1dUWWn11jRtcW1W42XPlnpXeF7KL5e2CPpI8DN5GbE/6+YgaJiFbgSeCCoiscpuZNm0htddc7I9ZWVzFv2sQKVWQ2OPlnpXeFBPz+ZNrgy8jtZrmTrrfw65GkOkmjk8e1wPnA7wZS7HAyfcpYvj7jFMaOrkXA2NG1fH3GKcP+oJFZd/5Z6Z36uvuepKfIHWS9Bvgk8Cbwm4g4pY/XTQb+gdwNukcAyyNiYb7XNDQ0RGNjY+HVm5kNc5KaIqKhp2WFnCZ5FfB54C8i4g1JxwGL+npRRGwAphRVqZmZlUwhZ9G8AXyr0/PXKHIfvJmZlV+vAS/pXXo+b13kTnM/KrWqzMxswPLd8KPPA6lmZjZ4FXzzbEl/DNR0PE921ZiZ2SBVyIVOl0raArwCPAVsBR5JuS4zMxugQs6D/yq5aQpejIjxwFTAE4aZmQ1yhQR8e0TsBEZIGhERTwI9nnNpZmaDRyH74FslHUFubvelkt4E3ku3LDMzG6het+CTC5ogN0XBHuCvyV3R+nvgkvRLMzOzgci3Bb8aOC0i3pP0k4i4gtzUA2ZmNgTk2wff+bZ8H0u7EDMzK618AR+9PDYzsyEg3y6aj0t6h9yWfG3yGDxVgZnZkJBvqoKq3paZmdngV8h58GZmNgQ54M3MMsoBb2aWUfkudHqsnIWYmVlp5duCrytbFWZmVnL5TpMcJWlGbwsjYmUK9ZiZWYnkDXjgYrpe0dohAAe8mdkgli/gX4uIa8tWiZmZlVShUxWYmdkQky/gWyWdXbZKzMyspPLtonkQ+DtJfwIsB5ZFxLpCO5Z0LHAf8BFyfw0sjojvDKRYM0vH6nUtLFq7me2tbYwZXcu8aROZPmVspcuyAep1Cz4ivhMRZwGfAnYCSyT9TtKtkk4ooO/9wNyIOIncPV2vk3RSSao2s5JZva6F+Ss30tLaRgAtrW3MX7mR1etaKl2aDVCfV7JGxKsRcXtETAFmA9OBTQW87vWIeC55/G7yGm8SmA0yi9Zupq39QJe2tvYDLFq7uUIVWan0GfCSDpF0iaSlwCPAZqDX8+N76aMemAI828OyOZIaJTXu2LGjmG7NrAS2t7YV1W5DR76pCs6XtARoAf4SeAg4PiJmRcSDhQ6Q3LD7J8CNEfFO9+URsTgiGiKioa7OF8+alduY0bVFtdvQkW8Lfj7w/4ATI+LSiPiniHivmM4lVZML96W+8tVscJo3bSK11V1v/1BbXcW8aRMrVJGVSr6Avwg4Evhqshsl3xk3HyJJwD3Apoj41gBqNLMUTZ8ylq/POIWxo2sRMHZ0LV+fcYrPosmAfKF9L7APeAa4EDgZuKGIvs8GvghslLQ+abs5Ih7uR51mlqLpU8Y60DMoX8CfFBGnAEi6B/i3YjqOiGfoeR4bMzMrg3y7aNo7HkTE/jLUYmZmJZRvC/7jkjrOehFQmzwXEBFxVOrVmZlZv/Ua8BFR1dsyMzMb/HxPVjOzjHLAm5lllAPezCyjHPBmZhnlgDczyygHvJlZRjngzcwyygFvZpZRDngzs4xywJuZZZQD3swsoxzwZmYZ5YA3M8soB7yZWUY54M3MMsoBb2aWUQ54M7OMcsCbmWWUA97MLKMc8GZmGeWANzPLqEPS6ljSEuBi4M2ImJTWOGaWMRuWs+eRBdS0vcH2PxzN3SO/wKkXzWH6lLH97nL1uhYWrd3M9tY2xoyuZd60iT32V+h6JbNhOTy+EHY1w6hxMHUBTJ5Zsu7T3IK/F7ggxf7NLGs2LGf/g3/FYW2vM4Jg3Ii3+HL7D3hm1Q9Yva6lX12uXtfC/JUbaWltI4CW1jbmr9z4of4KXa9kNiyHNdfDrm1A5L6uuT7XXiKpBXxEPA38R1r9m1kGPb6QQw7s7dJ0mPZxI/ezaO3mfnW5aO1m2toPdGlraz/wof4KXa9kHl8I7W1d29rbcu0lUvF98JLmSGqU1Lhjx45Kl2NmlbSrucfmMdrJ9ta2Hpf1pbfXdW8vdL2S6eW99treDxUP+IhYHBENEdFQV1dX6XLMrJJGjeuxeXsczZjRtf3qsrfXdW8vdL2S6eW99treDxUPeDOzg6YuYH9VTZemPTGSbzOLedMm9qvLedMmUltd1aWttrrqQ/0Vul7JTF0A1d1+eVTX5tpLJLWzaMzMijZ5JofAh86iOWcAZ9F0vK6vs2MKXa9kOs6WSfEsGkVEyTrr0rG0DDgXOAb4d+DWiLgn32saGhqisbExlXrMzLJIUlNENPS0LLUt+IiYnVbfZmbWN++DNzPLKAe8mVlGOeDNzDLKAW9mllEOeDOzjHLAm5lllAPezCyjHPBmZhnlgDczyygHvJlZRjngzcwyygFvZpZRDngzs4xywJuZZZQD3swsoxzwZmYZ5YA3M8soB7yZWUY54M3MMsoBb2aWUQ54M7OMcsCbmWWUA97MLKMc8GZmGXVImp1LugD4DlAF3B0R3yj1GKvXtbBo7Wa2t7YxZnQt86ZNZPqUsaUexszStGE5PL4QdjXDqHEwdQFMnlnpqoZ8vqQW8JKqgDuB84Fm4NeSfhoRvy3VGKvXtTB/5Uba2g8A0NLaxvyVGwGG1H+C2bC2YTmsuR7a23LPd23LPYeKhnwW8iXNXTRnAC9FxMsRsQ+4H7islAMsWrv54Iffoa39AIvWbi7lMGaWpscXfhDuHdrbcu0VlIV8STPgxwLbOj1vTtq6kDRHUqOkxh07dhQ1wPbWtqLazWwQ2tVcXHuZZCFfKn6QNSIWR0RDRDTU1dUV9doxo2uLajezQWjUuOLayyQL+ZJmwLcAx3Z6Pi5pK5l50yZSW13Vpa22uop50yaWchgzS9PUBVDdLTSra3PtFZSFfEnzLJpfAxMkjScX7LOAz5dygI4DHUP5KLfZsNdxIHWQnUWThXxRRKTXuXQh8G1yp0kuiYi/zbd+Q0NDNDY2plaPmVnWSGqKiIaelqV6HnxEPAw8nOYYZmbWs4ofZDUzs3Q44M3MMsoBb2aWUQ54M7OMSvUsmmJJ2gG8Wuk6UnYM8Fali6iw4f4ZDPf3D/4MoHSfwUcjoserRAdVwA8Hkhp7O6VpuBjun8Fwf//gzwDK8xl4F42ZWUY54M3MMsoBX36LK13AIDDcP4Ph/v7BnwGU4TPwPngzs4zyFryZWUY54M3MMsoBXwGSFkn6naQNklZJGl3pmspN0uckvSDpD5KGzelyki6QtFnSS5K+Uul6yk3SEklvSnq+0rVUgqRjJT0p6bfJ9/8NaY7ngK+MnwOTImIy8CIwv8L1VMLzwAzg6UoXUi6dbkT/WeAkYLakkypbVdndC1xQ6SIqaD8wNyJOAs4Erkvze8ABXwER8VhE7E+e/orc3a6GlYjYFBFD5+7FpZH6jegHu4h4GviPStdRKRHxekQ8lzx+F9hED/eqLhUHfOVdCzxS6SKsLAq6Eb0ND5LqgSnAs2mNkeoNP4YzSf8M/OceFt0SEQ8m69xC7k+2peWsrVwK+QzMhiNJRwA/AW6MiHfSGscBn5KI+Ey+5ZKuBi4GpkZGL0bo6zMYhlK/Eb0NfpKqyYX70ohYmeZY3kVTAZIuAL4MXBoReypdj5XNwRvRSxpJ7kb0P61wTVZGkgTcA2yKiG+lPZ4DvjK+DxwJ/FzSekl3VbqgcpN0uaRm4CzgIUlrK11T2pID6/8DWEvu4NryiHihslWVl6RlwC+BiZKaJf1FpWsqs7OBLwLnJT/76yVdmNZgnqrAzCyjvAVvZpZRDngzs4xywJuZZZQD3swsoxzwZmYZ5YC3spJ0IDk17HlJazpm0pR0rqSfFdnXzZ0e15d6hkJJp0qK5LqFUvV5sE5JDZK+mzw+V9In+tHfvZKuLFV9li0OeCu3tog4NSImkZt06roB9HVz36sMyGzgmeRryUVEY0Rcnzw9Fyg64M3yccBbJf2SrpNtHSHpx8lc+UuVc56k1R0rSDo/mUP/G0Bt8tdAx1w+VZJ+mMyz/Zik2uQ1v5B0h6RGSZsk/RdJKyVtkfS1ngpLrjj8HHA1cL6kmqS9PqnvXkkvJnV+RtK/Jv2dkax3m6R/lPTLpP0vexjjXEk/Syad+u/AXyfv57923zKXtLujLknfT+aU/2fgjzutc7qkpyQ1SVor6U+K/P+wjHHAW0Ukc6NPpeul+lOAG8nNlf4xclf9PQmcKKkuWecaYElEfIUP/hr4s2TZBODOiDgZaAWu6NT3vohoAO4CHiT3l8Mk4GpJR/dQ4ieAVyLi98AvgIs6LftT4JvAicm/zwPnAP+Trn9VTAbOI3e17gJJY3r6LCJia1LXHcn7+Zee1ktcDkwk9xl9KamzY36T7wFXRsTpwBLgb/P0Y8OAA97KrVbSeuAN4CPkbn7S4d8iojki/gCsB+qTidj+EfhCsr/+LHqfXvmViFifPG4C6jst6/hFshF4IZmX+33gZbpOANZhNrn52km+dt5N80pEbEzqfAF4PKlzY7cxH4yItoh4i9wvqjN6qbsYnwSWRcSBiNgOPJG0TyT3C+vnyef7vxiG9xmwrjybpJVbW0ScKukwcnOyXAd8N1n2fqf1DvDB9+ePgDXAXmBFp5uldNf99bU9LPtDt/X+QLefg+SviyuAy5IpnQUcLenIHsbp3F/3vrrPA1LMvCD7STbAJI0ARvaxvsj94jqriDEs47wFbxWRzKJ5PTBXUt4NjWRLdTu5rdIfdVrUnuyaKLWpwIaIODYi6iPio+Smd728yH4uk1ST7AI6l9xskr15l9wEdB22Aqcnjy8FOt7n08BVkqqSfeyfTto3A3WSzoLcLhtJJxdZr2WMA94qJiLWARso7CyVpcC2iNjUqW0xsKHTQdZSmQ2s6tb2E4o/m2YDuV0zvwK+mvyi6s0a4PKOg6zAD4FPSfoNud1S7yXrrQK2AL8F7iN3oJrkFoBXArcnr1mPz8oZ9jybpA0Jkr4PrIuIeypdSyEk3Qbsjoi/q3QtNnx5H7wNepKayG3Bzq10LWZDibfgzcwyyvvgzcwyygFvZpZRDngzs4xywJuZZZQD3swso/4/Rpyf60Vmt2IAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] @@ -6436,22 +5957,22 @@ }, { "cell_type": "code", - "execution_count": 171, + "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 171, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6479,22 +6000,22 @@ }, { "cell_type": "code", - "execution_count": 166, + "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 166, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6508,29 +6029,29 @@ "source": [ "plt.scatter(ya['phi_10'].values, ya['RT'].values, label = \"YA\")\n", "plt.scatter(oa['phi_10'].values, oa['RT'].values, label = \"OA\")\n", - "plt.xlabel(\"Acrophse\")\n", + "plt.xlabel(\"Acrophase\")\n", "plt.ylabel(\"PVT Mean Response Time\")\n", "plt.legend()" ] }, { "cell_type": "code", - "execution_count": 167, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 167, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6544,29 +6065,29 @@ "source": [ "plt.scatter(ya['phi_10'].values, ya['FS'].values, label = \"YA\")\n", "plt.scatter(oa['phi_10'].values, oa['FS'].values, label = \"OA\")\n", - "plt.xlabel(\"Acrophse\")\n", + "plt.xlabel(\"Acrophase\")\n", "plt.ylabel(\"PVT False Starts\")\n", "plt.legend()" ] }, { "cell_type": "code", - "execution_count": 168, + "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 168, + "execution_count": 40, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -6580,11 +6101,215 @@ "source": [ "plt.scatter(ya['phi_10'].values, ya['NR'].values, label = \"YA\")\n", "plt.scatter(oa['phi_10'].values, oa['NR'].values, label = \"OA\")\n", - "plt.xlabel(\"Acrophse\")\n", + "plt.xlabel(\"Acrophase\")\n", "plt.ylabel(\"PVT No Responses\")\n", "plt.legend()" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Mood and rhythm amplitude" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "pre = new[new['COVID'] == \"Pre\"]\n", + "post = new[new['COVID'] == \"Post\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 42, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pre['amp_10'].values, pre['Sadness'].values, label = \"Pre-COVID\")\n", + "plt.scatter(post['amp_10'].values, post['Sadness'].values, label = \"COVID\")\n", + "plt.xlabel(\"Amplitude\")\n", + "plt.ylabel(\"Sadness\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pre['amp_10'].values, pre['Happiness'].values, label = \"Pre-COVID\")\n", + "plt.scatter(post['amp_10'].values, post['Happiness'].values, label = \"COVID\")\n", + "plt.xlabel(\"Amplitude\")\n", + "plt.ylabel(\"Happiness\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pre['amp_10'].values, pre['Rumination'].values, label = \"Pre-COVID\")\n", + "plt.scatter(post['amp_10'].values, post['Rumination'].values, label = \"COVID\")\n", + "plt.xlabel(\"Amplitude\")\n", + "plt.ylabel(\"Rumination\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pre['amp_10'].values, pre['Stress'].values, label = \"Pre-COVID\")\n", + "plt.scatter(post['amp_10'].values, post['Stress'].values, label = \"COVID\")\n", + "plt.xlabel(\"Amplitude\")\n", + "plt.ylabel(\"Stress\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.scatter(pre['amp_10'].values, pre['Alcohol'].values, label = \"Pre-COVID\")\n", + "plt.scatter(post['amp_10'].values, post['Alcohol'].values, label = \"COVID\")\n", + "plt.xlabel(\"Amplitude\")\n", + "plt.ylabel(\"Mean Number Alcoholic Drinks per Day\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Why do I have amplitude values > 2?" + ] + }, { "cell_type": "code", "execution_count": null, diff --git a/notebooks/analysis.ipynb b/notebooks/analysis.ipynb index 89cb36b..ded7b3b 100644 --- a/notebooks/analysis.ipynb +++ b/notebooks/analysis.ipynb @@ -54,7 +54,9 @@ { "cell_type": "code", "execution_count": 4, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "data": { @@ -100,7 +102,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/plain": [ + "['/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10011_10_24_2019_4_30_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10012_10_18_2019_3_30_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10014_11_11_2019_5_20_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10016_1_24_2020_11_45_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10023_11_11_2019_1_50_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10024_11_5_2019_3_15_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10025_12_5_2019_2_15_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10033_11_7_2019_2_50_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10035_2_7_2020_2_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10038_1_22_2020_9_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10040_1_29_2020_1_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10045_12_4_2019_11_45_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10049_12_2_2019_10_45_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/10062_1_27_2020_1_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20076_11_8_2019_11_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20103_2_20_2020_4_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20105_2_20_2020_1_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20108_2_25_2020_4_45_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20113_2_28_2020_2_15_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20115_3_12_2020_2_40_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20120_7_30_2020_8_00_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20122_7_24_2020_4_30_00_PM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20123_7_30_2020_9_00_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20124_7_30_2020_9_08_00_AM_New_Analysis.csv',\n", + " '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_files/20125_7_24_2020_4_30_00_PM_New_Analysis.csv']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "act_files" + ] + }, + { + "cell_type": "code", + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -109,7 +157,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 7, "metadata": { "scrolled": true }, @@ -118,18 +166,6 @@ "name": "stdout", "output_type": "stream", "text": [ - "record 10011\n", - "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10011\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10011\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10011\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", "record 10011\n", "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", @@ -144,18 +180,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10012\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10012\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10012\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10012\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10012\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10012\n", "----- saving\n", @@ -168,18 +192,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10014\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10014\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10014\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10014\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10014\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10014\n", "----- saving\n", @@ -192,18 +204,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10016\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10016\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10016\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10016\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10016\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10016\n", "----- saving\n", @@ -216,18 +216,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10023\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10023\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10023\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10023\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10023\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10023\n", "----- saving\n", @@ -240,18 +228,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10024\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10024\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10024\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10024\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10024\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10024\n", "----- saving\n", @@ -264,18 +240,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10025\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10025\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10025\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10025\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10025\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10025\n", "----- saving\n", @@ -288,18 +252,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10033\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10033\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10033\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10033\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10033\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10033\n", "----- saving\n", @@ -312,18 +264,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10035\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10035\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10035\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10035\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10035\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10035\n", "----- saving\n", @@ -336,18 +276,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10038\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10038\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10038\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10038\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10038\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10038\n", "----- saving\n", @@ -360,18 +288,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10040\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10040\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10040\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10040\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10040\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10040\n", "----- saving\n", @@ -382,24 +298,6 @@ "record 10040\n", "----- saving\n", "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", - "record 10045\n", - "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10045\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10045\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10045\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ "record 10045\n", "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", @@ -414,18 +312,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10049\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10049\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10049\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10049\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10049\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10049\n", "----- saving\n", @@ -438,18 +324,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 10062\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10062\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10062\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10062\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10062\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 10062\n", "----- saving\n", @@ -460,42 +334,6 @@ "record 10062\n", "----- saving\n", "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", - "record 10076\n", - "----- saving\n", - "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", - "record 20076\n", - "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 20076\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 20076\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 20076\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", "record 20076\n", "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", @@ -510,18 +348,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 20103\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 20103\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 20103\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 20103\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 20103\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 20103\n", "----- saving\n", @@ -534,18 +360,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 20105\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 20105\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 20105\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 20105\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 20105\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 20105\n", "----- saving\n", @@ -558,18 +372,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 20108\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 20108\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 20108\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 20108\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 20108\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 20108\n", "----- saving\n", @@ -582,18 +384,6 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 20113\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", - "record 20113\n", - "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", - "record 20113\n", - "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", - "record 20113\n", - "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 20113\n", - "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 20113\n", "----- saving\n", @@ -606,26 +396,80 @@ "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", "record 20115\n", "----- saving\n", - "----- success: 0 percent NaN, 3 days 00:00:00 recording period\n", + "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", "record 20115\n", "----- saving\n", - "----- success: 0 percent NaN, 4 days 00:00:00 recording period\n", + "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", "record 20115\n", "----- saving\n", - "----- success: 0 percent NaN, 5 days 00:00:00 recording period\n", + "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", "record 20115\n", "----- saving\n", - "----- success: 0 percent NaN, 6 days 00:00:00 recording period\n", - "record 20115\n", + "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", + "record 20120\n", "----- saving\n", "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", - "record 20115\n", + "record 20120\n", "----- saving\n", "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", - "record 20115\n", + "record 20120\n", "----- saving\n", "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", - "record 20115\n", + "record 20120\n", + "----- saving\n", + "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", + "record 20122\n", + "----- saving\n", + "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", + "record 20122\n", + "----- saving\n", + "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", + "record 20122\n", + "----- saving\n", + "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", + "record 20122\n", + "----- saving\n", + "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", + "record 20123\n", + "----- saving\n", + "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", + "record 20123\n", + "----- saving\n", + "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", + "record 20123\n", + "----- saving\n", + "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", + "record 20123\n", + "----- saving\n", + "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "record 20124\n", + "----- saving\n", + "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", + "record 20124\n", + "----- saving\n", + "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", + "record 20124\n", + "----- saving\n", + "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", + "record 20124\n", + "----- saving\n", + "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n", + "record 20125\n", + "----- saving\n", + "----- success: 0 percent NaN, 7 days 00:00:00 recording period\n", + "record 20125\n", + "----- saving\n", + "----- success: 0 percent NaN, 8 days 00:00:00 recording period\n", + "record 20125\n", + "----- saving\n", + "----- success: 0 percent NaN, 9 days 00:00:00 recording period\n", + "record 20125\n", "----- saving\n", "----- success: 0 percent NaN, 10 days 00:00:00 recording period\n" ] @@ -647,7 +491,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -2622,7 +2466,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -2632,7 +2476,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 10, "metadata": { "scrolled": true }, @@ -2640,106 +2484,58 @@ { "data": { "text/plain": [ - "{'3': Time\n", - " 2019-11-04 16:29:00 605.0\n", - " 2019-11-04 16:30:00 1137.0\n", - " 2019-11-04 16:31:00 571.0\n", - " 2019-11-04 16:32:00 551.0\n", - " 2019-11-04 16:33:00 364.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 4321, dtype: float64, '4': Time\n", - " 2019-11-03 16:29:00 0.0\n", - " 2019-11-03 16:30:00 0.0\n", - " 2019-11-03 16:31:00 0.0\n", - " 2019-11-03 16:32:00 0.0\n", - " 2019-11-03 16:33:00 0.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 5761, dtype: float64, '5': Time\n", - " 2019-11-02 16:29:00 23.0\n", - " 2019-11-02 16:30:00 0.0\n", - " 2019-11-02 16:31:00 357.0\n", - " 2019-11-02 16:32:00 38.0\n", - " 2019-11-02 16:33:00 22.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 7201, dtype: float64, '6': Time\n", - " 2019-11-01 16:29:00 610.0\n", - " 2019-11-01 16:30:00 774.0\n", - " 2019-11-01 16:31:00 824.0\n", - " 2019-11-01 16:32:00 1038.0\n", - " 2019-11-01 16:33:00 828.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 8641, dtype: float64, '7': Time\n", - " 2019-10-31 16:29:00 165.0\n", - " 2019-10-31 16:30:00 56.0\n", - " 2019-10-31 16:31:00 373.0\n", - " 2019-10-31 16:32:00 147.0\n", - " 2019-10-31 16:33:00 62.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 10081, dtype: float64, '8': Time\n", - " 2019-10-30 16:29:00 620.0\n", - " 2019-10-30 16:30:00 0.0\n", - " 2019-10-30 16:31:00 0.0\n", - " 2019-10-30 16:32:00 36.0\n", - " 2019-10-30 16:33:00 0.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 11521, dtype: float64, '9': Time\n", - " 2019-10-29 16:29:00 23.0\n", - " 2019-10-29 16:30:00 28.0\n", - " 2019-10-29 16:31:00 22.0\n", - " 2019-10-29 16:32:00 436.0\n", - " 2019-10-29 16:33:00 459.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 12961, dtype: float64, '10': Time\n", - " 2019-10-28 16:29:00 117.0\n", - " 2019-10-28 16:30:00 165.0\n", - " 2019-10-28 16:31:00 521.0\n", - " 2019-10-28 16:32:00 711.0\n", - " 2019-10-28 16:33:00 830.0\n", - " ... \n", - " 2019-11-07 16:25:00 272.0\n", - " 2019-11-07 16:26:00 399.0\n", - " 2019-11-07 16:27:00 162.0\n", - " 2019-11-07 16:28:00 344.0\n", - " 2019-11-07 16:29:00 292.0\n", - " Name: Activity, Length: 14401, dtype: float64}" + "{'7': Time\n", + " 2019-10-31 16:29:00 165\n", + " 2019-10-31 16:30:00 56\n", + " 2019-10-31 16:31:00 373\n", + " 2019-10-31 16:32:00 147\n", + " 2019-10-31 16:33:00 62\n", + " ... \n", + " 2019-11-07 16:25:00 272\n", + " 2019-11-07 16:26:00 399\n", + " 2019-11-07 16:27:00 162\n", + " 2019-11-07 16:28:00 344\n", + " 2019-11-07 16:29:00 292\n", + " Freq: T, Name: Activity, Length: 10081, dtype: int64, '8': Time\n", + " 2019-10-30 16:29:00 620\n", + " 2019-10-30 16:30:00 0\n", + " 2019-10-30 16:31:00 0\n", + " 2019-10-30 16:32:00 36\n", + " 2019-10-30 16:33:00 0\n", + " ... \n", + " 2019-11-07 16:25:00 272\n", + " 2019-11-07 16:26:00 399\n", + " 2019-11-07 16:27:00 162\n", + " 2019-11-07 16:28:00 344\n", + " 2019-11-07 16:29:00 292\n", + " Freq: T, Name: Activity, Length: 11521, dtype: int64, '9': Time\n", + " 2019-10-29 16:29:00 23\n", + " 2019-10-29 16:30:00 28\n", + " 2019-10-29 16:31:00 22\n", + " 2019-10-29 16:32:00 436\n", + " 2019-10-29 16:33:00 459\n", + " ... \n", + " 2019-11-07 16:25:00 272\n", + " 2019-11-07 16:26:00 399\n", + " 2019-11-07 16:27:00 162\n", + " 2019-11-07 16:28:00 344\n", + " 2019-11-07 16:29:00 292\n", + " Freq: T, Name: Activity, Length: 12961, dtype: int64, '10': Time\n", + " 2019-10-28 16:29:00 117\n", + " 2019-10-28 16:30:00 165\n", + " 2019-10-28 16:31:00 521\n", + " 2019-10-28 16:32:00 711\n", + " 2019-10-28 16:33:00 830\n", + " ... \n", + " 2019-11-07 16:25:00 272\n", + " 2019-11-07 16:26:00 399\n", + " 2019-11-07 16:27:00 162\n", + " 2019-11-07 16:28:00 344\n", + " 2019-11-07 16:29:00 292\n", + " Freq: T, Name: Activity, Length: 14401, dtype: int64}" ] }, - "execution_count": 18, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -2818,7 +2614,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -2828,58 +2624,75 @@ }, { "cell_type": "code", - "execution_count": 147, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "10011\n", + "10011\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/scipy/optimize/minpack.py:794: OptimizeWarning: Covariance of the parameters could not be estimated\n", + " category=OptimizeWarning)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "10012\n", "10014\n", "10016\n", - "10023\n", + "10023\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/site-packages/wearables/fitcosinor.py:33: RuntimeWarning: overflow encountered in exp\n", + " return actmin + amp*((np.exp(beta * (c - alpha)))/(1 + np.exp(beta * (c - alpha))))\n", + "/usr/local/lib/python3.7/site-packages/wearables/fitcosinor.py:33: RuntimeWarning: invalid value encountered in true_divide\n", + " return actmin + amp*((np.exp(beta * (c - alpha)))/(1 + np.exp(beta * (c - alpha))))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "10024\n", "10025\n", "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "10033\n", "10035\n", "10038\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "10040\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "10045\n", "10049\n", "10062\n", "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", - "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", - "10076\n", "20076\n", "20103\n", "20105\n", "20108\n", "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", - "local variable 'params' referenced before assignment\n", "20113\n", - "20115\n" + "20115\n", + "20120\n", + "20122\n", + "Optimal parameters not found: Number of calls to function has reached maxfev = 1200.\n", + "20123\n", + "20124\n", + "20125\n" ] } ], @@ -3003,7 +2816,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 13, "metadata": { "scrolled": true }, @@ -3054,62 +2867,108 @@ " \n", " \n", " 10011\n", - " 0.149828\n", - " 1.27394\n", - " 0.485009\n", - " -103.793\n", - " 1.93418\n", - " 0.00549958\n", - " 1.51265\n", - " 0.57539\n", - " -8.8918\n", - " 1.96925\n", - " -0.000306148\n", - " 1.5795\n", - " 0.569379\n", - " -8.58689\n", - " 1.97132\n", - " 1.14092\n", - " -4.26166\n", - " -14.0747\n", - " -22.2516\n", - " -52.5003\n", + " 2.43256\n", + " -2.44732\n", + " 14.4099\n", + " 21.2017\n", + " 92.8808\n", + " 1.04853\n", + " 1.82072\n", + " 0.768953\n", + " -14.1172\n", + " 2.71093\n", + " 1.13883\n", + " 1.75152\n", + " 0.76927\n", + " -13.078\n", + " 2.64027\n", + " 1.22498\n", + " 1.67937\n", + " 0.771681\n", + " -13.1045\n", + " 2.64775\n", " \n", " \n", " 10012\n", - " -6.4109\n", - " 8.8667\n", - " -2.26278\n", - " 0.74825\n", - " -7.15496\n", - " -6.4109\n", - " 8.8667\n", - " -2.26278\n", - " 0.74825\n", - " -7.15496\n", - " -6.4109\n", - " 8.8667\n", - " -2.26278\n", - " 0.74825\n", - " -7.15496\n", - " -6.4109\n", - " 8.8667\n", - " -2.26278\n", - " 0.74825\n", - " -7.15496\n", + " 1.37876\n", + " 1.29204\n", + " -0.678648\n", + " 27.5468\n", + " -7.28024\n", + " 1.47489\n", + " 0.934578\n", + " 6.98493\n", + " -9.15632\n", + " -21.7969\n", + " 2.1256\n", + " 0.341217\n", + " 4.51542\n", + " -8.36705\n", + " -9.00124\n", + " 1.17681\n", + " 1.34447\n", + " 5.44216\n", + " -8.10128\n", + " -18.0696\n", " \n", " \n", " 10014\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 0.883334\n", + " 1.90083\n", + " -0.674685\n", + " 5.68015\n", + " -7.49104\n", + " 1.25375\n", + " 1.56007\n", + " -0.634767\n", + " 8.82704\n", + " -7.49854\n", + " 1.72073\n", + " 0.728035\n", + " 4.62972\n", + " -9.51854\n", + " -9.51148\n", + " 1.89294\n", + " 0.626165\n", + " 6.18547\n", + " -6.41597\n", + " -12.1506\n", + " \n", + " \n", + " 10016\n", + " 1.46877\n", + " 1.52431\n", + " 0.713096\n", + " -4.83044\n", + " 2.86139\n", + " 1.87646\n", + " 1.1102\n", + " 0.638584\n", + " -8.34614\n", + " 2.96355\n", + " 1.98646\n", + " 1.00015\n", + " 0.653496\n", + " -11.2154\n", + " 2.87822\n", + " 2.00681\n", + " 1.0195\n", + " 0.647388\n", + " -9.5358\n", + " 2.88795\n", + " \n", + " \n", + " 10023\n", + " 1.55798\n", + " 1.3164\n", + " -0.847699\n", + " 30.3287\n", + " -6.78505\n", + " 1.62359\n", + " 1.26288\n", + " -0.85433\n", + " 25.4408\n", + " -6.80046\n", " NaN\n", " NaN\n", " NaN\n", @@ -3122,298 +2981,206 @@ " NaN\n", " \n", " \n", - " 10016\n", - " 0.00308996\n", - " 1.57322\n", - " 0.507209\n", - " -5.36987\n", - " -21.5619\n", - " -0.0444596\n", - " 1.728\n", - " 0.532648\n", - " -5.11405\n", - " 2.60256\n", - " -0.0597503\n", - " 1.76345\n", - " 0.529335\n", - " -4.90135\n", - " 2.58946\n", - " -0.0597503\n", - " 1.76345\n", - " 0.529335\n", - " -4.90135\n", - " 2.58946\n", - " \n", - " \n", - " 10023\n", - " -0.416242\n", - " 1.89832\n", - " -0.829578\n", - " 7.66031\n", - " -6.72733\n", - " -2.37302\n", - " 3.95814\n", - " -1.10227\n", - " 4.17635\n", - " -6.55066\n", - " -5.66675\n", - " 7.28147\n", - " -1.36332\n", - " 3.48557\n", - " -6.52964\n", - " -0.118239\n", - " 1.72449\n", - " -0.81843\n", - " 10.444\n", - " -6.7099\n", - " \n", - " \n", " 10024\n", - " 0.0939114\n", - " 1.40738\n", - " -0.730184\n", - " 80.6516\n", - " -6.49818\n", - " -0.0285371\n", - " 1.59933\n", - " -0.769046\n", - " 15.1646\n", - " -6.70543\n", - " -0.0404246\n", - " 1.66272\n", - " -0.762861\n", - " 13.6567\n", - " -6.71888\n", - " -0.0345327\n", - " 1.6842\n", - " -0.760088\n", - " 13.6615\n", - " -6.72842\n", + " 3.03693\n", + " -0.401042\n", + " 12.3496\n", + " -7.93054\n", + " -35.5833\n", + " 1.4349\n", + " 1.53195\n", + " 0.845901\n", + " -17.3909\n", + " 5.44104\n", + " 1.45643\n", + " 1.52702\n", + " 0.850317\n", + " -16.5237\n", + " 5.40599\n", + " 1.5295\n", + " 1.46853\n", + " 0.845736\n", + " -15.7763\n", + " 5.38876\n", " \n", " \n", " 10025\n", - " 0.206043\n", - " 1.35897\n", - " -0.480184\n", - " 8.22232\n", - " -4.85381\n", - " 0.252942\n", - " 1.32346\n", - " -0.508819\n", - " 13.3417\n", - " -4.5991\n", - " 0.226307\n", - " 1.41021\n", - " -0.531714\n", - " 10.9947\n", - " -4.76689\n", - " -2.99377\n", - " 4.72988\n", - " -1.19937\n", - " 2.85797\n", - " -5.48938\n", + " 0.88789\n", + " 2.0916\n", + " -0.885842\n", + " 21.9451\n", + " -30.028\n", + " 1.0679\n", + " 1.91954\n", + " -0.88659\n", + " 29.4391\n", + " -54.0193\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " -50.7621\n", + " 53.843\n", + " 1.61728\n", + " -5.56542\n", + " -17.8636\n", " \n", " \n", " 10033\n", - " 1.53608\n", - " -1.48463\n", - " -0.581124\n", - " -65.531\n", - " -9.5994\n", - " 1.54902\n", - " -1.49788\n", - " -0.582442\n", - " -55.5722\n", - " -9.58898\n", - " 1.61545\n", - " -1.56335\n", - " -0.58048\n", - " -51.4713\n", - " -9.58745\n", - " 0.0540855\n", - " 1.60161\n", - " 0.584732\n", - " -48.9733\n", - " 2.38782\n", + " 1.24233\n", + " 1.56893\n", + " 0.639032\n", + " -30.8266\n", + " 2.46281\n", + " 1.35834\n", + " 1.45693\n", + " 0.63989\n", + " -35.8348\n", + " 26.4831\n", + " 1.48993\n", + " 0.957407\n", + " 9.75913\n", + " -8.78966\n", + " 1.57378\n", + " 5.13458\n", + " -2.65507\n", + " 18.2109\n", + " -13.173\n", + " 7.91598\n", " \n", " \n", " 10035\n", - " 0.10888\n", - " 1.34959\n", - " -0.61302\n", - " 252.822\n", - " -6.87124\n", - " 0.125779\n", - " 1.46365\n", - " -0.610337\n", - " 440.766\n", - " -6.86506\n", - " 0.129326\n", - " 1.49631\n", - " -0.61018\n", - " 440.777\n", - " -6.86479\n", - " 0.133218\n", - " 1.54056\n", - " 0.609982\n", - " -440.857\n", - " -18.8644\n", + " 1.13002\n", + " 1.76578\n", + " -0.7248\n", + " 185.333\n", + " -6.82467\n", + " 1.20038\n", + " 1.75805\n", + " -0.72925\n", + " 68.4324\n", + " -6.80115\n", + " 1.30244\n", + " 1.67091\n", + " -0.730694\n", + " 55.7582\n", + " -6.79806\n", + " 1.37347\n", + " 1.6095\n", + " -0.729089\n", + " 69.5858\n", + " -6.79387\n", " \n", " \n", " 10038\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " 0.163567\n", - " 1.27728\n", - " -0.62648\n", - " 387.09\n", - " -8.01106\n", - " 1.47049\n", - " -1.27802\n", - " -0.627187\n", - " -1511.22\n", - " -8.01532\n", - " 0.209376\n", - " 1.28438\n", - " -0.646601\n", - " 183.024\n", - " -7.89878\n", + " 2.89572\n", + " -0.777806\n", + " -0.690728\n", + " -13.0051\n", + " -8.4665\n", + " 2.17035\n", + " 0.755679\n", + " 0.692503\n", + " -20.8688\n", + " 3.81684\n", + " 2.93203\n", + " -0.599292\n", + " -0.653876\n", + " -100.124\n", + " -8.07066\n", + " 2.34981\n", + " 0.595015\n", + " 0.670183\n", + " -130.758\n", + " 4.02606\n", " \n", " \n", " 10040\n", - " 0.0965442\n", - " 1.51048\n", - " -0.536578\n", - " 37.4183\n", - " -7.11002\n", - " 0.0985321\n", - " 1.54574\n", - " -0.533701\n", - " 35.4007\n", - " -7.1159\n", - " 0.0982628\n", - " 1.5741\n", - " -0.531625\n", - " 33.8867\n", - " -7.11977\n", - " 0.0992971\n", - " 1.58737\n", - " -0.549218\n", - " 62.8109\n", - " -7.07132\n", + " -3.40114\n", + " 6.39121\n", + " 1.11568\n", + " -5.20294\n", + " -17.7539\n", + " -4.9341\n", + " 7.9395\n", + " 1.20817\n", + " -4.75259\n", + " -17.77\n", + " -1.18691\n", + " 4.20563\n", + " 1.01912\n", + " -5.08676\n", + " -17.8443\n", + " -4.87383\n", + " 7.90845\n", + " 1.24572\n", + " -4.42148\n", + " -17.8446\n", " \n", " \n", " 10045\n", - " 0.0022305\n", - " 1.36251\n", - " -0.546018\n", - " 10.1914\n", - " -5.9659\n", - " 0.0586309\n", - " 1.39646\n", - " -0.618115\n", - " 121.398\n", - " -5.47153\n", - " 0.0564855\n", - " 1.48301\n", - " -0.622768\n", - " 61.5697\n", - " -5.51547\n", - " 0.0596443\n", - " 1.52666\n", - " -0.620661\n", - " 54.9011\n", - " -5.51853\n", + " 0.936148\n", + " 1.89169\n", + " -0.738042\n", + " 7.22879\n", + " -6.13199\n", + " 1.70524\n", + " 1.16011\n", + " -0.64377\n", + " 53.9346\n", + " -53.4846\n", + " 1.69393\n", + " 1.20193\n", + " 0.676174\n", + " -18.554\n", + " -17.5677\n", + " 1.7617\n", + " 1.14801\n", + " 0.66537\n", + " -21.6008\n", + " -17.5464\n", " \n", " \n", " 10049\n", - " 6.26277e-41\n", - " 2.39513e-40\n", - " 1\n", - " 1\n", - " 1\n", - " 6.26277e-41\n", - " 2.39513e-40\n", - " 1\n", - " 1\n", - " 1\n", - " 6.26277e-41\n", - " 2.39513e-40\n", - " 1\n", - " 1\n", - " 1\n", - " 6.26277e-41\n", - " 2.39513e-40\n", - " 1\n", - " 1\n", - " 1\n", + " 0.913626\n", + " 1.92325\n", + " 0.887175\n", + " -121.374\n", + " -18.6331\n", + " 2.32531\n", + " 0.233009\n", + " 4.23322\n", + " -9.2175\n", + " -14.3869\n", + " -0.437034\n", + " 3.06706\n", + " 5.42297\n", + " -14.1033\n", + " -8.30963\n", + " 2.87144\n", + " -1.80436\n", + " -0.927371\n", + " -96.0025\n", + " -7.06095\n", " \n", " \n", " 10062\n", + " -8322.24\n", + " 8325.06\n", + " 1.77553\n", + " -10.9822\n", + " 2.57404\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 0.414324\n", - " 0.977407\n", - " 0.705131\n", - " -378.089\n", - " 3.11167\n", - " 0.467856\n", - " 0.988593\n", - " 0.621269\n", - " -435.69\n", - " 2.68649\n", - " 0.478801\n", - " 1.02426\n", - " 0.621045\n", - " -404.653\n", - " 2.68673\n", - " \n", - " \n", - " 10076\n", - " 1.64226\n", - " -1.50925\n", - " 0.0133601\n", - " -6.7041\n", - " -9.86412\n", - " 1.69924\n", - " -1.63285\n", - " -0.0594016\n", - " -4.59237\n", - " -9.6793\n", - " 1.72019\n", - " -1.70118\n", - " -0.117497\n", - " -4.31128\n", - " -9.52305\n", - " 1.76573\n", - " -1.78605\n", - " -0.147384\n", - " -3.9007\n", - " -9.4377\n", - " \n", - " \n", - " 10139\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " -4168.94\n", + " 4171.81\n", + " 1.81018\n", + " -9.80108\n", + " 2.61199\n", " NaN\n", " NaN\n", " NaN\n", @@ -3421,423 +3188,361 @@ " NaN\n", " \n", " \n", + " 20076\n", + " 1.52637\n", + " 0.567259\n", + " 6.0208\n", + " -6.60779\n", + " -6.7659\n", + " -0.48232\n", + " 2.62399\n", + " 7.79054\n", + " -6.95077\n", + " -6.81854\n", + " 1.76359\n", + " 0.416798\n", + " 7.86602\n", + " -10.3075\n", + " -3.78228\n", + " 0.860242\n", + " 1.35871\n", + " 4.93083\n", + " -7.48549\n", + " -1.0362\n", + " \n", + " \n", " 20103\n", - " 1.56701\n", - " -1.48623\n", - " -0.515298\n", - " -20.8798\n", - " -10.0151\n", - " 1.56931\n", - " -1.48854\n", - " -0.514997\n", - " -20.815\n", - " -10.0146\n", - " 0.109488\n", - " 1.53612\n", - " 0.506885\n", - " -19.6497\n", - " 1.9838\n", - " 0.113818\n", - " 1.58213\n", - " 0.504111\n", - " -18.6892\n", - " -22.0278\n", + " 1.13245\n", + " 1.70116\n", + " 0.579959\n", + " -92.0508\n", + " 1.87145\n", + " 2.36406\n", + " -6.74428\n", + " -11.1623\n", + " -3.13913\n", + " -1.81514\n", + " 1.36352\n", + " 1.5027\n", + " 0.574372\n", + " -83.8878\n", + " 1.86076\n", + " 1.42019\n", + " 1.46218\n", + " 0.571645\n", + " -88.418\n", + " 1.84855\n", " \n", " \n", " 20105\n", - " -0.0793767\n", - " 1.85653\n", - " 0.519655\n", - " -7.38727\n", - " 1.60753\n", - " 1.21808\n", - " -5.31266\n", - " -17.1166\n", - " -29.6923\n", - " -11.7627\n", - " 1.28837\n", - " -8.2043\n", - " -12.3496\n", - " -22.8311\n", - " -12.5455\n", - " 1.85718\n", - " -1.81499\n", - " -0.577335\n", - " -22.5531\n", - " -10.2756\n", + " 0.0822193\n", + " 2.38038\n", + " 11.6252\n", + " -7.66727\n", + " 21.0792\n", + " 0.867993\n", + " 2.06756\n", + " 0.783241\n", + " -398.029\n", + " 2.40551\n", + " 3.12522\n", + " -0.597005\n", + " 7.31594\n", + " -6.93237\n", + " 38.1722\n", + " 0.964368\n", + " 2.05208\n", + " 0.754236\n", + " -24.5396\n", + " 2.2801\n", " \n", " \n", " 20108\n", - " 3379.68\n", - " -3379.48\n", - " -4.35023\n", - " 2.41849\n", - " -21.326\n", + " 1.34201\n", + " 0.924136\n", + " 7.10037\n", + " -7.31008\n", + " 0.739958\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", " NaN\n", - " 1.05908\n", - " -0.739686\n", - " -0.274338\n", - " 468\n", - " 1.02018\n", - " 1.09469\n", - " -0.736375\n", - " -0.298258\n", - " 515.253\n", - " 0.946826\n", + " 1.23759\n", + " 1.33552\n", + " 0.860568\n", + " -8.84617\n", + " 4.62502\n", + " 1.57153\n", + " 1.01057\n", + " 0.816653\n", + " -12.261\n", + " 4.80413\n", " \n", " \n", " 20113\n", - " 1.42714\n", - " -1.58186\n", - " 0.143567\n", - " 2.25793\n", - " 1.44289\n", - " 1.36903\n", - " -1.43406\n", - " 0.1922\n", - " 2.89257\n", - " 1.65092\n", - " 1.30096\n", - " -1.24552\n", - " -0.278575\n", - " -5.40511\n", - " -10.0817\n", - " 1.364\n", - " -1.28479\n", - " -0.271716\n", - " -5.66109\n", - " -10.0957\n", + " 1.44084\n", + " 1.33808\n", + " 0.578272\n", + " -35.9895\n", + " 1.81385\n", + " 1.5937\n", + " 1.22258\n", + " 0.558698\n", + " -22.8423\n", + " 1.84056\n", + " 1.68349\n", + " 1.15534\n", + " 0.542743\n", + " -19.3494\n", + " 1.83773\n", + " 1.7747\n", + " 1.08359\n", + " 0.539876\n", + " -14.4281\n", + " 1.80598\n", " \n", " \n", " 20115\n", - " 0.0595838\n", - " 0.818717\n", - " 6.18629\n", - " -5.98251\n", - " -8.69044\n", - " 0.626776\n", - " 0.292853\n", - " 9.71423\n", - " -10.8077\n", - " -10.727\n", - " 1.69649\n", - " -0.746848\n", - " 8.73765\n", - " -9.05006\n", - " 0.627744\n", - " 1.67934\n", - " -1.62253\n", - " -0.220805\n", - " -2.66818\n", - " -10.0314\n", + " 1.48855\n", + " 1.30606\n", + " 0.465118\n", + " -48.33\n", + " 3.0902\n", + " -2.94154\n", + " 5.32518\n", + " 14.5733\n", + " -19.9382\n", + " 41.236\n", + " 2.82531\n", + " -1.14305\n", + " 0.468917\n", + " 104.414\n", + " -116.939\n", + " 1.72497\n", + " 1.10693\n", + " 0.533558\n", + " -462.829\n", + " 2.80495\n", " \n", " \n", " 20120\n", - " 1.27359\n", - " -1.14878\n", - " 0.239461\n", - " 925.237\n", - " 1.18475\n", - " 0.130957\n", - " 1.24919\n", - " 0.239673\n", - " -571.446\n", - " 1.18269\n", - " 1.45466\n", - " -1.31958\n", - " -0.239615\n", - " -930.752\n", - " -10.8172\n", - " 1.09143\n", - " -0.159201\n", - " 6.13919\n", - " -6.0654\n", - " -16.6339\n", + " 1.21868\n", + " 1.32189\n", + " 0.543107\n", + " -459.969\n", + " 2.40024\n", + " 1.33357\n", + " 1.22377\n", + " 0.544728\n", + " -440.463\n", + " 2.41075\n", + " 1.42281\n", + " 1.15689\n", + " 0.544543\n", + " -459.463\n", + " 2.40833\n", + " 1.47765\n", + " 1.1342\n", + " 0.544053\n", + " -459.573\n", + " 2.40781\n", " \n", " \n", " 20122\n", - " 0.106519\n", - " 1.50856\n", - " 0.48477\n", - " -5.08885\n", - " 2.53739\n", - " 0.0676464\n", - " 1.63037\n", - " 0.509933\n", - " -4.88672\n", - " 2.67561\n", - " 0.0302982\n", - " 1.71657\n", - " 0.542068\n", - " -4.47937\n", - " 2.76968\n", - " 0.041484\n", - " 1.7256\n", - " 0.560755\n", - " -4.4921\n", - " 2.85521\n", + " 5.3692\n", + " -2.87083\n", + " 11.4124\n", + " -16.568\n", + " -22.4139\n", + " -5.54509\n", + " 8.41307\n", + " 1.51801\n", + " -3.23484\n", + " 3.5046\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " NaN\n", + " -143.882\n", + " 146.775\n", + " 2.5417\n", + " -3.11185\n", + " 3.64066\n", " \n", " \n", " 20123\n", - " -0.03939\n", - " 1.87893\n", - " 0.299135\n", - " -5.94506\n", - " 2.32058\n", - " -0.056269\n", - " 1.91126\n", - " 0.316051\n", - " -5.7011\n", - " 2.2909\n", - " -0.0352417\n", - " 1.89144\n", - " 0.3326\n", - " -6.51496\n", - " 2.28557\n", - " -0.0140065\n", - " 1.86433\n", - " 0.348856\n", - " -7.68134\n", - " 2.32232\n", + " 0.92048\n", + " 1.91728\n", + " 0.484341\n", + " -13.2901\n", + " 2.8152\n", + " 1.04756\n", + " 1.80867\n", + " -0.47701\n", + " 13.5196\n", + " 14.7945\n", + " 1.10347\n", + " 1.77409\n", + " 0.490255\n", + " -12.9576\n", + " 2.70387\n", + " 1.18544\n", + " 1.70477\n", + " 0.486392\n", + " -12.9299\n", + " 2.67276\n", " \n", " \n", " 20124\n", - " 0.0136196\n", - " 1.48228\n", - " 0.436845\n", - " -13.7779\n", - " 2.70312\n", - " 0.0439073\n", - " 1.48979\n", - " 0.499192\n", - " -46.5085\n", - " 2.55314\n", - " 0.0477729\n", - " 1.51494\n", - " 0.496688\n", - " -42.4301\n", - " 2.54214\n", - " 0.0450504\n", - " 1.56715\n", - " 0.491314\n", - " -33.2755\n", - " 2.5139\n", + " 0.86203\n", + " 1.89732\n", + " -0.544459\n", + " 27.8705\n", + " 14.8912\n", + " 1.55072\n", + " 0.695251\n", + " 7.15136\n", + " -9.3134\n", + " -4.17445\n", + " 3.02627\n", + " -0.71705\n", + " 5.82781\n", + " -8.99046\n", + " 3.0926\n", + " 1.31951\n", + " 1.52323\n", + " 0.551828\n", + " -24.636\n", + " 2.70714\n", " \n", " \n", " 20125\n", - " 0.207744\n", - " 1.36158\n", - " 0.213287\n", - " -6.02508\n", - " 2.34354\n", - " -0.133696\n", - " 1.79931\n", - " 0.466993\n", - " -3.4773\n", - " 2.90198\n", - " -0.255123\n", - " 1.94694\n", - " -0.564769\n", - " 3.86558\n", - " -8.79926\n", - " -0.156575\n", - " 1.87383\n", - " 0.538828\n", - " -4.0554\n", - " 3.21997\n", - " \n", - " \n", - " 20127\n", - " 1.12602\n", - " -1.11432\n", - " 0.423147\n", - " 13.8705\n", - " 2.50407\n", - " 1.12602\n", - " -1.11432\n", - " 0.423147\n", - " 13.8705\n", - " 2.50407\n", - " 1.12602\n", - " -1.11432\n", - " 0.423147\n", - " 13.8705\n", - " 2.50407\n", - " 1.12602\n", - " -1.11432\n", - " 0.423147\n", - " 13.8705\n", - " 2.50407\n", - " \n", - " \n", - " 20129\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", - " NaN\n", + " 1.34662\n", + " 1.35178\n", + " 0.740786\n", + " -27.4\n", + " 4.01019\n", + " 1.50863\n", + " 1.23052\n", + " 0.713775\n", + " -17.116\n", + " -20.0176\n", + " 1.52172\n", + " 1.25067\n", + " 0.699904\n", + " -11.6197\n", + " -20.0415\n", + " 0.764678\n", + " 2.0444\n", + " 0.940041\n", + " -5.0341\n", + " 4.39928\n", " \n", " \n", "\n", "" ], "text/plain": [ - " actmin_7 amp_7 alpha_7 beta_7 phi_7 actmin_8 \\\n", - "10011 0.149828 1.27394 0.485009 -103.793 1.93418 0.00549958 \n", - "10012 -6.4109 8.8667 -2.26278 0.74825 -7.15496 -6.4109 \n", - "10014 NaN NaN NaN NaN NaN NaN \n", - "10016 0.00308996 1.57322 0.507209 -5.36987 -21.5619 -0.0444596 \n", - "10023 -0.416242 1.89832 -0.829578 7.66031 -6.72733 -2.37302 \n", - "10024 0.0939114 1.40738 -0.730184 80.6516 -6.49818 -0.0285371 \n", - "10025 0.206043 1.35897 -0.480184 8.22232 -4.85381 0.252942 \n", - "10033 1.53608 -1.48463 -0.581124 -65.531 -9.5994 1.54902 \n", - "10035 0.10888 1.34959 -0.61302 252.822 -6.87124 0.125779 \n", - "10038 NaN NaN NaN NaN NaN 0.163567 \n", - "10040 0.0965442 1.51048 -0.536578 37.4183 -7.11002 0.0985321 \n", - "10045 0.0022305 1.36251 -0.546018 10.1914 -5.9659 0.0586309 \n", - "10049 6.26277e-41 2.39513e-40 1 1 1 6.26277e-41 \n", - "10062 NaN NaN NaN NaN NaN 0.414324 \n", - "10076 1.64226 -1.50925 0.0133601 -6.7041 -9.86412 1.69924 \n", - "10139 NaN NaN NaN NaN NaN NaN \n", - "20103 1.56701 -1.48623 -0.515298 -20.8798 -10.0151 1.56931 \n", - "20105 -0.0793767 1.85653 0.519655 -7.38727 1.60753 1.21808 \n", - "20108 3379.68 -3379.48 -4.35023 2.41849 -21.326 NaN \n", - "20113 1.42714 -1.58186 0.143567 2.25793 1.44289 1.36903 \n", - "20115 0.0595838 0.818717 6.18629 -5.98251 -8.69044 0.626776 \n", - "20120 1.27359 -1.14878 0.239461 925.237 1.18475 0.130957 \n", - "20122 0.106519 1.50856 0.48477 -5.08885 2.53739 0.0676464 \n", - "20123 -0.03939 1.87893 0.299135 -5.94506 2.32058 -0.056269 \n", - "20124 0.0136196 1.48228 0.436845 -13.7779 2.70312 0.0439073 \n", - "20125 0.207744 1.36158 0.213287 -6.02508 2.34354 -0.133696 \n", - "20127 1.12602 -1.11432 0.423147 13.8705 2.50407 1.12602 \n", - "20129 NaN NaN NaN NaN NaN NaN \n", + " actmin_7 amp_7 alpha_7 beta_7 phi_7 actmin_8 amp_8 \\\n", + "10011 2.43256 -2.44732 14.4099 21.2017 92.8808 1.04853 1.82072 \n", + "10012 1.37876 1.29204 -0.678648 27.5468 -7.28024 1.47489 0.934578 \n", + "10014 0.883334 1.90083 -0.674685 5.68015 -7.49104 1.25375 1.56007 \n", + "10016 1.46877 1.52431 0.713096 -4.83044 2.86139 1.87646 1.1102 \n", + "10023 1.55798 1.3164 -0.847699 30.3287 -6.78505 1.62359 1.26288 \n", + "10024 3.03693 -0.401042 12.3496 -7.93054 -35.5833 1.4349 1.53195 \n", + "10025 0.88789 2.0916 -0.885842 21.9451 -30.028 1.0679 1.91954 \n", + "10033 1.24233 1.56893 0.639032 -30.8266 2.46281 1.35834 1.45693 \n", + "10035 1.13002 1.76578 -0.7248 185.333 -6.82467 1.20038 1.75805 \n", + "10038 2.89572 -0.777806 -0.690728 -13.0051 -8.4665 2.17035 0.755679 \n", + "10040 -3.40114 6.39121 1.11568 -5.20294 -17.7539 -4.9341 7.9395 \n", + "10045 0.936148 1.89169 -0.738042 7.22879 -6.13199 1.70524 1.16011 \n", + "10049 0.913626 1.92325 0.887175 -121.374 -18.6331 2.32531 0.233009 \n", + "10062 -8322.24 8325.06 1.77553 -10.9822 2.57404 NaN NaN \n", + "20076 1.52637 0.567259 6.0208 -6.60779 -6.7659 -0.48232 2.62399 \n", + "20103 1.13245 1.70116 0.579959 -92.0508 1.87145 2.36406 -6.74428 \n", + "20105 0.0822193 2.38038 11.6252 -7.66727 21.0792 0.867993 2.06756 \n", + "20108 1.34201 0.924136 7.10037 -7.31008 0.739958 NaN NaN \n", + "20113 1.44084 1.33808 0.578272 -35.9895 1.81385 1.5937 1.22258 \n", + "20115 1.48855 1.30606 0.465118 -48.33 3.0902 -2.94154 5.32518 \n", + "20120 1.21868 1.32189 0.543107 -459.969 2.40024 1.33357 1.22377 \n", + "20122 5.3692 -2.87083 11.4124 -16.568 -22.4139 -5.54509 8.41307 \n", + "20123 0.92048 1.91728 0.484341 -13.2901 2.8152 1.04756 1.80867 \n", + "20124 0.86203 1.89732 -0.544459 27.8705 14.8912 1.55072 0.695251 \n", + "20125 1.34662 1.35178 0.740786 -27.4 4.01019 1.50863 1.23052 \n", "\n", - " amp_8 alpha_8 beta_8 phi_8 actmin_9 amp_9 \\\n", - "10011 1.51265 0.57539 -8.8918 1.96925 -0.000306148 1.5795 \n", - "10012 8.8667 -2.26278 0.74825 -7.15496 -6.4109 8.8667 \n", - "10014 NaN NaN NaN NaN NaN NaN \n", - "10016 1.728 0.532648 -5.11405 2.60256 -0.0597503 1.76345 \n", - "10023 3.95814 -1.10227 4.17635 -6.55066 -5.66675 7.28147 \n", - "10024 1.59933 -0.769046 15.1646 -6.70543 -0.0404246 1.66272 \n", - "10025 1.32346 -0.508819 13.3417 -4.5991 0.226307 1.41021 \n", - "10033 -1.49788 -0.582442 -55.5722 -9.58898 1.61545 -1.56335 \n", - "10035 1.46365 -0.610337 440.766 -6.86506 0.129326 1.49631 \n", - "10038 1.27728 -0.62648 387.09 -8.01106 1.47049 -1.27802 \n", - "10040 1.54574 -0.533701 35.4007 -7.1159 0.0982628 1.5741 \n", - "10045 1.39646 -0.618115 121.398 -5.47153 0.0564855 1.48301 \n", - "10049 2.39513e-40 1 1 1 6.26277e-41 2.39513e-40 \n", - "10062 0.977407 0.705131 -378.089 3.11167 0.467856 0.988593 \n", - "10076 -1.63285 -0.0594016 -4.59237 -9.6793 1.72019 -1.70118 \n", - "10139 NaN NaN NaN NaN NaN NaN \n", - "20103 -1.48854 -0.514997 -20.815 -10.0146 0.109488 1.53612 \n", - "20105 -5.31266 -17.1166 -29.6923 -11.7627 1.28837 -8.2043 \n", - "20108 NaN NaN NaN NaN 1.05908 -0.739686 \n", - "20113 -1.43406 0.1922 2.89257 1.65092 1.30096 -1.24552 \n", - "20115 0.292853 9.71423 -10.8077 -10.727 1.69649 -0.746848 \n", - "20120 1.24919 0.239673 -571.446 1.18269 1.45466 -1.31958 \n", - "20122 1.63037 0.509933 -4.88672 2.67561 0.0302982 1.71657 \n", - "20123 1.91126 0.316051 -5.7011 2.2909 -0.0352417 1.89144 \n", - "20124 1.48979 0.499192 -46.5085 2.55314 0.0477729 1.51494 \n", - "20125 1.79931 0.466993 -3.4773 2.90198 -0.255123 1.94694 \n", - "20127 -1.11432 0.423147 13.8705 2.50407 1.12602 -1.11432 \n", - "20129 NaN NaN NaN NaN NaN NaN \n", + " alpha_8 beta_8 phi_8 actmin_9 amp_9 alpha_9 beta_9 \\\n", + "10011 0.768953 -14.1172 2.71093 1.13883 1.75152 0.76927 -13.078 \n", + "10012 6.98493 -9.15632 -21.7969 2.1256 0.341217 4.51542 -8.36705 \n", + "10014 -0.634767 8.82704 -7.49854 1.72073 0.728035 4.62972 -9.51854 \n", + "10016 0.638584 -8.34614 2.96355 1.98646 1.00015 0.653496 -11.2154 \n", + "10023 -0.85433 25.4408 -6.80046 NaN NaN NaN NaN \n", + "10024 0.845901 -17.3909 5.44104 1.45643 1.52702 0.850317 -16.5237 \n", + "10025 -0.88659 29.4391 -54.0193 NaN NaN NaN NaN \n", + "10033 0.63989 -35.8348 26.4831 1.48993 0.957407 9.75913 -8.78966 \n", + "10035 -0.72925 68.4324 -6.80115 1.30244 1.67091 -0.730694 55.7582 \n", + "10038 0.692503 -20.8688 3.81684 2.93203 -0.599292 -0.653876 -100.124 \n", + "10040 1.20817 -4.75259 -17.77 -1.18691 4.20563 1.01912 -5.08676 \n", + "10045 -0.64377 53.9346 -53.4846 1.69393 1.20193 0.676174 -18.554 \n", + "10049 4.23322 -9.2175 -14.3869 -0.437034 3.06706 5.42297 -14.1033 \n", + "10062 NaN NaN NaN -4168.94 4171.81 1.81018 -9.80108 \n", + "20076 7.79054 -6.95077 -6.81854 1.76359 0.416798 7.86602 -10.3075 \n", + "20103 -11.1623 -3.13913 -1.81514 1.36352 1.5027 0.574372 -83.8878 \n", + "20105 0.783241 -398.029 2.40551 3.12522 -0.597005 7.31594 -6.93237 \n", + "20108 NaN NaN NaN 1.23759 1.33552 0.860568 -8.84617 \n", + "20113 0.558698 -22.8423 1.84056 1.68349 1.15534 0.542743 -19.3494 \n", + "20115 14.5733 -19.9382 41.236 2.82531 -1.14305 0.468917 104.414 \n", + "20120 0.544728 -440.463 2.41075 1.42281 1.15689 0.544543 -459.463 \n", + "20122 1.51801 -3.23484 3.5046 NaN NaN NaN NaN \n", + "20123 -0.47701 13.5196 14.7945 1.10347 1.77409 0.490255 -12.9576 \n", + "20124 7.15136 -9.3134 -4.17445 3.02627 -0.71705 5.82781 -8.99046 \n", + "20125 0.713775 -17.116 -20.0176 1.52172 1.25067 0.699904 -11.6197 \n", "\n", - " alpha_9 beta_9 phi_9 actmin_10 amp_10 alpha_10 \\\n", - "10011 0.569379 -8.58689 1.97132 1.14092 -4.26166 -14.0747 \n", - "10012 -2.26278 0.74825 -7.15496 -6.4109 8.8667 -2.26278 \n", - "10014 NaN NaN NaN NaN NaN NaN \n", - "10016 0.529335 -4.90135 2.58946 -0.0597503 1.76345 0.529335 \n", - "10023 -1.36332 3.48557 -6.52964 -0.118239 1.72449 -0.81843 \n", - "10024 -0.762861 13.6567 -6.71888 -0.0345327 1.6842 -0.760088 \n", - "10025 -0.531714 10.9947 -4.76689 -2.99377 4.72988 -1.19937 \n", - "10033 -0.58048 -51.4713 -9.58745 0.0540855 1.60161 0.584732 \n", - "10035 -0.61018 440.777 -6.86479 0.133218 1.54056 0.609982 \n", - "10038 -0.627187 -1511.22 -8.01532 0.209376 1.28438 -0.646601 \n", - "10040 -0.531625 33.8867 -7.11977 0.0992971 1.58737 -0.549218 \n", - "10045 -0.622768 61.5697 -5.51547 0.0596443 1.52666 -0.620661 \n", - "10049 1 1 1 6.26277e-41 2.39513e-40 1 \n", - "10062 0.621269 -435.69 2.68649 0.478801 1.02426 0.621045 \n", - "10076 -0.117497 -4.31128 -9.52305 1.76573 -1.78605 -0.147384 \n", - "10139 NaN NaN NaN NaN NaN NaN \n", - "20103 0.506885 -19.6497 1.9838 0.113818 1.58213 0.504111 \n", - "20105 -12.3496 -22.8311 -12.5455 1.85718 -1.81499 -0.577335 \n", - "20108 -0.274338 468 1.02018 1.09469 -0.736375 -0.298258 \n", - "20113 -0.278575 -5.40511 -10.0817 1.364 -1.28479 -0.271716 \n", - "20115 8.73765 -9.05006 0.627744 1.67934 -1.62253 -0.220805 \n", - "20120 -0.239615 -930.752 -10.8172 1.09143 -0.159201 6.13919 \n", - "20122 0.542068 -4.47937 2.76968 0.041484 1.7256 0.560755 \n", - "20123 0.3326 -6.51496 2.28557 -0.0140065 1.86433 0.348856 \n", - "20124 0.496688 -42.4301 2.54214 0.0450504 1.56715 0.491314 \n", - "20125 -0.564769 3.86558 -8.79926 -0.156575 1.87383 0.538828 \n", - "20127 0.423147 13.8705 2.50407 1.12602 -1.11432 0.423147 \n", - "20129 NaN NaN NaN NaN NaN NaN \n", - "\n", - " beta_10 phi_10 \n", - "10011 -22.2516 -52.5003 \n", - "10012 0.74825 -7.15496 \n", - "10014 NaN NaN \n", - "10016 -4.90135 2.58946 \n", - "10023 10.444 -6.7099 \n", - "10024 13.6615 -6.72842 \n", - "10025 2.85797 -5.48938 \n", - "10033 -48.9733 2.38782 \n", - "10035 -440.857 -18.8644 \n", - "10038 183.024 -7.89878 \n", - "10040 62.8109 -7.07132 \n", - "10045 54.9011 -5.51853 \n", - "10049 1 1 \n", - "10062 -404.653 2.68673 \n", - "10076 -3.9007 -9.4377 \n", - "10139 NaN NaN \n", - "20103 -18.6892 -22.0278 \n", - "20105 -22.5531 -10.2756 \n", - "20108 515.253 0.946826 \n", - "20113 -5.66109 -10.0957 \n", - "20115 -2.66818 -10.0314 \n", - "20120 -6.0654 -16.6339 \n", - "20122 -4.4921 2.85521 \n", - "20123 -7.68134 2.32232 \n", - "20124 -33.2755 2.5139 \n", - "20125 -4.0554 3.21997 \n", - "20127 13.8705 2.50407 \n", - "20129 NaN NaN " + " phi_9 actmin_10 amp_10 alpha_10 beta_10 phi_10 \n", + "10011 2.64027 1.22498 1.67937 0.771681 -13.1045 2.64775 \n", + "10012 -9.00124 1.17681 1.34447 5.44216 -8.10128 -18.0696 \n", + "10014 -9.51148 1.89294 0.626165 6.18547 -6.41597 -12.1506 \n", + "10016 2.87822 2.00681 1.0195 0.647388 -9.5358 2.88795 \n", + "10023 NaN NaN NaN NaN NaN NaN \n", + "10024 5.40599 1.5295 1.46853 0.845736 -15.7763 5.38876 \n", + "10025 NaN -50.7621 53.843 1.61728 -5.56542 -17.8636 \n", + "10033 1.57378 5.13458 -2.65507 18.2109 -13.173 7.91598 \n", + "10035 -6.79806 1.37347 1.6095 -0.729089 69.5858 -6.79387 \n", + "10038 -8.07066 2.34981 0.595015 0.670183 -130.758 4.02606 \n", + "10040 -17.8443 -4.87383 7.90845 1.24572 -4.42148 -17.8446 \n", + "10045 -17.5677 1.7617 1.14801 0.66537 -21.6008 -17.5464 \n", + "10049 -8.30963 2.87144 -1.80436 -0.927371 -96.0025 -7.06095 \n", + "10062 2.61199 NaN NaN NaN NaN NaN \n", + "20076 -3.78228 0.860242 1.35871 4.93083 -7.48549 -1.0362 \n", + "20103 1.86076 1.42019 1.46218 0.571645 -88.418 1.84855 \n", + "20105 38.1722 0.964368 2.05208 0.754236 -24.5396 2.2801 \n", + "20108 4.62502 1.57153 1.01057 0.816653 -12.261 4.80413 \n", + "20113 1.83773 1.7747 1.08359 0.539876 -14.4281 1.80598 \n", + "20115 -116.939 1.72497 1.10693 0.533558 -462.829 2.80495 \n", + "20120 2.40833 1.47765 1.1342 0.544053 -459.573 2.40781 \n", + "20122 NaN -143.882 146.775 2.5417 -3.11185 3.64066 \n", + "20123 2.70387 1.18544 1.70477 0.486392 -12.9299 2.67276 \n", + "20124 3.0926 1.31951 1.52323 0.551828 -24.636 2.70714 \n", + "20125 -20.0415 0.764678 2.0444 0.940041 -5.0341 4.39928 " ] }, - "execution_count": 14, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "cr_fit" + "cr_act" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "cr_fit.to_csv(data_dir + '/fitbit/cr_fit.csv')" + "cr_act.to_csv(data_dir + '/actiwatch/cr_act.csv')" ] }, { @@ -3849,7 +3554,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 19, "metadata": {}, "outputs": [ { @@ -3858,20 +3563,18 @@ "" ] }, - "execution_count": 1, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -3880,9 +3583,11 @@ "import matplotlib.pyplot as plt\n", "import numpy as np\n", "from wearables import plotcosinor\n", + "import seaborn as sns\n", + "sns.set()\n", "\n", "d = np.load('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/actiwatch/act_preproc.npy', allow_pickle=True)[()]['10011']['10']\n", - "plotcosinor.plotcosinor(d, 'antilogistic', 'Actiwatch 2.0')" + "plotcosinor.plotcosinor(d, 'antilogistic', 'Actiwatch 2.0')\n" ] }, { @@ -3894,7 +3599,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -3919,15 +3624,15 @@ " \n", " \n", " Unnamed: 0\n", - " actmin_3\n", - " amp_3\n", - " alpha_3\n", - " beta_3\n", - " phi_3\n", - " actmin_4\n", - " amp_4\n", - " alpha_4\n", - " beta_4\n", + " actmin_7\n", + " amp_7\n", + " alpha_7\n", + " beta_7\n", + " phi_7\n", + " actmin_8\n", + " amp_8\n", + " alpha_8\n", + " beta_8\n", " ...\n", " actmin_9\n", " amp_9\n", @@ -3945,15 +3650,15 @@ " \n", " 0\n", " 10011\n", - " 1.222309\n", - " 0.824902\n", - " 6.383225\n", - " -7.084618\n", - " -9.242750\n", - " 1.824477\n", - " 0.318040\n", - " 6.326477\n", - " -8.318291\n", + " 2.432565\n", + " -2.447323\n", + " 14.409872\n", + " 21.201700\n", + " 92.880844\n", + " 1.048527\n", + " 1.820719\n", + " 0.768953\n", + " -14.117220\n", " ...\n", " 1.138832\n", " 1.751524\n", @@ -3969,15 +3674,15 @@ " \n", " 1\n", " 10012\n", - " 0.953520\n", - " 1.459876\n", - " -0.617031\n", - " 417.211574\n", - " -78.991526\n", - " 2.049888\n", - " 0.097579\n", - " 6.257981\n", - " -5.927575\n", + " 1.378764\n", + " 1.292044\n", + " -0.678648\n", + " 27.546799\n", + " -7.280237\n", + " 1.474886\n", + " 0.934578\n", + " 6.984927\n", + " -9.156320\n", " ...\n", " 2.125595\n", " 0.341217\n", @@ -3993,15 +3698,15 @@ " \n", " 2\n", " 10014\n", - " 0.478673\n", - " 2.083462\n", - " 0.531145\n", - " -10.781934\n", - " -19.005365\n", - " 0.528766\n", - " 2.123009\n", - " 0.624188\n", - " -6.913380\n", + " 0.883334\n", + " 1.900828\n", + " -0.674685\n", + " 5.680145\n", + " -7.491036\n", + " 1.253748\n", + " 1.560074\n", + " -0.634767\n", + " 8.827035\n", " ...\n", " 1.720730\n", " 0.728035\n", @@ -4017,15 +3722,15 @@ " \n", " 3\n", " 10016\n", - " 1.371522\n", - " 1.370968\n", - " 0.530029\n", - " -8.743808\n", - " 2.089830\n", - " 1.599548\n", - " 1.194495\n", - " 0.502885\n", - " -11.487648\n", + " 1.468775\n", + " 1.524313\n", + " 0.713096\n", + " -4.830436\n", + " 2.861393\n", + " 1.876456\n", + " 1.110198\n", + " 0.638584\n", + " -8.346138\n", " ...\n", " 1.986456\n", " 1.000151\n", @@ -4041,15 +3746,15 @@ " \n", " 4\n", " 10023\n", - " 1.193353\n", - " 1.547031\n", - " 0.697427\n", - " -417.502095\n", - " -17.730469\n", - " 1.062984\n", - " 1.728813\n", - " -0.839612\n", - " 18.514056\n", + " 1.557981\n", + " 1.316398\n", + " -0.847699\n", + " 30.328659\n", + " -6.785045\n", + " 1.623585\n", + " 1.262882\n", + " -0.854330\n", + " 25.440830\n", " ...\n", " NaN\n", " NaN\n", @@ -4064,23 +3769,23 @@ " \n", " \n", "\n", - "

5 rows × 41 columns

\n", + "

5 rows × 21 columns

\n", "" ], "text/plain": [ - " Unnamed: 0 actmin_3 amp_3 alpha_3 beta_3 phi_3 actmin_4 \\\n", - "0 10011 1.222309 0.824902 6.383225 -7.084618 -9.242750 1.824477 \n", - "1 10012 0.953520 1.459876 -0.617031 417.211574 -78.991526 2.049888 \n", - "2 10014 0.478673 2.083462 0.531145 -10.781934 -19.005365 0.528766 \n", - "3 10016 1.371522 1.370968 0.530029 -8.743808 2.089830 1.599548 \n", - "4 10023 1.193353 1.547031 0.697427 -417.502095 -17.730469 1.062984 \n", + " Unnamed: 0 actmin_7 amp_7 alpha_7 beta_7 phi_7 actmin_8 \\\n", + "0 10011 2.432565 -2.447323 14.409872 21.201700 92.880844 1.048527 \n", + "1 10012 1.378764 1.292044 -0.678648 27.546799 -7.280237 1.474886 \n", + "2 10014 0.883334 1.900828 -0.674685 5.680145 -7.491036 1.253748 \n", + "3 10016 1.468775 1.524313 0.713096 -4.830436 2.861393 1.876456 \n", + "4 10023 1.557981 1.316398 -0.847699 30.328659 -6.785045 1.623585 \n", "\n", - " amp_4 alpha_4 beta_4 ... actmin_9 amp_9 alpha_9 \\\n", - "0 0.318040 6.326477 -8.318291 ... 1.138832 1.751524 0.769270 \n", - "1 0.097579 6.257981 -5.927575 ... 2.125595 0.341217 4.515416 \n", - "2 2.123009 0.624188 -6.913380 ... 1.720730 0.728035 4.629720 \n", - "3 1.194495 0.502885 -11.487648 ... 1.986456 1.000151 0.653496 \n", - "4 1.728813 -0.839612 18.514056 ... NaN NaN NaN \n", + " amp_8 alpha_8 beta_8 ... actmin_9 amp_9 alpha_9 \\\n", + "0 1.820719 0.768953 -14.117220 ... 1.138832 1.751524 0.769270 \n", + "1 0.934578 6.984927 -9.156320 ... 2.125595 0.341217 4.515416 \n", + "2 1.560074 -0.634767 8.827035 ... 1.720730 0.728035 4.629720 \n", + "3 1.110198 0.638584 -8.346138 ... 1.986456 1.000151 0.653496 \n", + "4 1.262882 -0.854330 25.440830 ... NaN NaN NaN \n", "\n", " beta_9 phi_9 actmin_10 amp_10 alpha_10 beta_10 phi_10 \n", "0 -13.078016 2.640273 1.224985 1.679375 0.771681 -13.104473 2.647754 \n", @@ -4089,10 +3794,10 @@ "3 -11.215384 2.878217 2.006809 1.019504 0.647388 -9.535801 2.887949 \n", "4 NaN NaN NaN NaN NaN NaN NaN \n", "\n", - "[5 rows x 41 columns]" + "[5 rows x 21 columns]" ] }, - "execution_count": 5, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -4105,24 +3810,20 @@ }, { "cell_type": "code", - "execution_count": 163, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "actmin_3 -525.311110\n", - "actmin_4 -161.464307\n", - "actmin_5 -443.221843\n", - "actmin_6 0.242448\n", - "actmin_7 -395.158808\n", - "actmin_8 0.764479\n", - "actmin_9 -217.945037\n", - "actmin_10 -1.323034\n", + "actmin_7 -331.605774\n", + "actmin_8 0.647948\n", + "actmin_9 -187.983865\n", + "actmin_10 -7.179659\n", "dtype: float64" ] }, - "execution_count": 163, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -4133,19 +3834,17 @@ }, { "cell_type": "code", - "execution_count": 230, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] }, - "metadata": { - "needs_background": "light" - }, + "metadata": {}, "output_type": "display_data" } ], @@ -4186,41 +3885,6 @@ "\n" ] }, - { - "cell_type": "code", - "execution_count": 223, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "alpha_3 0.449550\n", - "alpha_4 1.313509\n", - "alpha_5 1.071003\n", - "alpha_6 0.873999\n", - "alpha_7 -0.178698\n", - "alpha_8 -0.699226\n", - "alpha_9 -0.471981\n", - "alpha_10 -0.978219\n", - "dtype: float64" - ] - }, - "execution_count": 223, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "cr_fit.filter(regex=(\"alpha.*\")).mean()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## How much do cosinor measures vary as a function of device?" - ] - }, { "cell_type": "code", "execution_count": null, diff --git a/notebooks/cosinor_analysis_example.ipynb b/notebooks/cosinor_analysis_example.ipynb index aed04ae..2e23c7c 100644 --- a/notebooks/cosinor_analysis_example.ipynb +++ b/notebooks/cosinor_analysis_example.ipynb @@ -2,13 +2,14 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import pandas as pd\n", "import datetime as dt\n", + "import glob\n", "\n", "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", @@ -110,7 +111,28 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_heartrate_1min_20190711_20200811.csv'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hrfile = glob.glob('/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_heartrate_1min*.csv')\n", + "hrfile[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -122,8 +144,7 @@ } ], "source": [ - "hrfile = '/Users/megmcmahon/Box/CogNeuroLab/Wearables/data/fitbit/WA_10011_heartrate_1min_20190901_20200327.csv'\n", - "hr = pd.read_csv(hrfile)\n", + "hr = pd.read_csv(hrfile[0])\n", "hr['Time'] = pd.to_datetime(hr['Time'])\n", "hr = hr.set_index('Time')\n", "\n", @@ -138,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -250,7 +271,7 @@ "[19298 rows x 2 columns]" ] }, - "execution_count": 8, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" } @@ -268,7 +289,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 26, "metadata": {}, "outputs": [ { @@ -283,7 +304,7 @@ " dtype='datetime64[ns]')" ] }, - "execution_count": 9, + "execution_count": 26, "metadata": {}, "output_type": "execute_result" } @@ -295,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 27, "metadata": {}, "outputs": [ { @@ -304,7 +325,7 @@ "12" ] }, - "execution_count": 10, + "execution_count": 27, "metadata": {}, "output_type": "execute_result" } @@ -315,22 +336,22 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 11, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -344,7 +365,7 @@ "source": [ "hrn = hr.resample('30min').mean()\n", "plt.figure(figsize = (25, 15))\n", - "plt.plot(hrn.index, hrn.Value, label='Heart Rate')\n", + "#plt.plot(hrn.index, hrn.Value, label='Heart Rate')\n", "plt.plot(hrn.index, hrn.Activity, label='Activity')\n", "for i in range(0,len(missing)-1):\n", " plt.axvspan(missing[i], missing[i+1], facecolor='b', alpha=0.5)\n", @@ -361,7 +382,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -385,7 +406,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -395,7 +416,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 31, "metadata": {}, "outputs": [ { @@ -440,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -449,7 +470,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 33, "metadata": { "scrolled": true }, @@ -496,7 +517,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -505,7 +526,7 @@ "array([[ 1.59784582, 1.34907229, -0.77169917, 13.89295938, 14.73995808]])" ] }, - "execution_count": 17, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } @@ -516,7 +537,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 35, "metadata": {}, "outputs": [ { @@ -565,7 +586,7 @@ "0 1.597846 1.349072 -0.771699 13.892959 14.739958" ] }, - "execution_count": 18, + "execution_count": 35, "metadata": {}, "output_type": "execute_result" } @@ -577,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 36, "metadata": {}, "outputs": [ { @@ -631,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 37, "metadata": {}, "outputs": [], "source": [ @@ -649,24 +670,24 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 21, + "execution_count": 38, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -687,24 +708,24 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 22, + "execution_count": 42, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -714,11 +735,11 @@ } ], "source": [ - "plt.plot(x_act, y_act, label='Actiwatch Raw')\n", - "plt.plot(x_fit, y_fit, label='Fitbit Raw')\n", - "plt.plot(x_fitInt, y_fitInt, label='Fitbit Interpolated')\n", - "plt.plot(x_act, y_act_antilog, label='Anti-logistic Transform', linewidth = 3)\n", - "plt.plot(x_fit, y_fit_antilog, label='Anti-logistic Transform', linewidth = 3)\n", + "#plt.plot(x_act, y_act, label='Actiwatch Raw')\n", + "plt.plot(x_fit, y_fit, label='Raw')\n", + "#plt.plot(x_fitInt, y_fitInt, label='Fitbit Interpolated')\n", + "#plt.plot(x_act, y_act_antilog, label='Anti-logistic Transform', linewidth = 3)\n", + "#plt.plot(x_fit, y_fit_antilog, label='Anti-logistic Transform', linewidth = 3)\n", "plt.plot(x_fit, y_fitInt_antilog, label='Anti-logistic Transform', linewidth = 3)\n", "\n", "plt.xlabel('$t$')\n", diff --git a/notebooks/figure1.ipynb b/notebooks/figure1.ipynb new file mode 100644 index 0000000..27b2fcb --- /dev/null +++ b/notebooks/figure1.ipynb @@ -0,0 +1,516 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import datetime as dt\n", + "import glob\n", + "\n", + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "\n", + "from matplotlib import rcParams\n", + "rcParams['figure.figsize'] = (10, 8)\n", + "rcParams['legend.fontsize'] = 16\n", + "rcParams['axes.labelsize'] = 16\n", + "plt.rcParams['axes.prop_cycle'] = plt.cycler(color=plt.cm.Set1.colors)\n", + "plt.style.use('seaborn-dark')" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "subject = 40861" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
actminactampactalphactbetaactphi
160.1149511.120207-0.7568893.53102512.103077
\n", + "
" + ], + "text/plain": [ + " actmin actamp actalph actbeta actphi\n", + "16 0.114951 1.120207 -0.756889 3.531025 12.103077" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cr = pd.read_csv('/Users/megmcmahon/Box/CogNeuroLab/Aging Decision Making R01/data/actigraphy/circadian_measures/7_days/cr_7days.csv')\n", + "cr[cr['record_id'] == subject][['actmin', 'actamp', 'actalph', 'actbeta', 'actphi']]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [], + "source": [ + "def read_actig(file): \n", + " # actigraphy input file is a file with two columns, Time (\"%Y-%m-%d %H:%M:%S\") and Activity, with no header\n", + " \n", + " data = pd.read_csv(file, sep = \",\", header = None, names = ['time', 'activity'])\n", + " data['time'] = data.values[:,0].astype(str)\n", + " data['clocktime'] = [int(dt.datetime.strptime(x, \"%Y-%m-%d %H:%M:%S\").time().strftime(\"%H\")) + (int(dt.datetime.strptime(x, \"%Y-%m-%d %H:%M:%S\").time().strftime(\"%M\"))/60) for x in data['time']]\n", + " data = data.groupby('clocktime').max()\n", + " data['lmaxact'] = np.log10(data['activity'] + 1)\n", + " return data" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "act = read_actig(\"/Users/megmcmahon/Box/CogNeuroLab/Aging Decision Making R01/Data/Actigraphy/processed_2020-06-17/%s.csv\" % subject)\n", + "x_act = act.index.values\n", + "y_act = act.lmaxact\n" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
timeactivitylmaxact
clocktime
0.0000002019-05-03 00:00:30147.02.170262
0.0166672019-05-03 00:01:30152.02.184691
0.0333332019-05-03 00:02:3075.01.880814
0.0500002019-05-03 00:03:30157.02.198657
0.0666672019-05-03 00:04:30104.02.021189
............
23.9166672019-05-02 23:55:30118.02.075547
23.9333332019-05-02 23:56:3094.01.977724
23.9500002019-05-02 23:57:30118.02.075547
23.9666672019-05-02 23:58:30133.02.127105
23.9833332019-05-02 23:59:30118.02.075547
\n", + "

1440 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " time activity lmaxact\n", + "clocktime \n", + "0.000000 2019-05-03 00:00:30 147.0 2.170262\n", + "0.016667 2019-05-03 00:01:30 152.0 2.184691\n", + "0.033333 2019-05-03 00:02:30 75.0 1.880814\n", + "0.050000 2019-05-03 00:03:30 157.0 2.198657\n", + "0.066667 2019-05-03 00:04:30 104.0 2.021189\n", + "... ... ... ...\n", + "23.916667 2019-05-02 23:55:30 118.0 2.075547\n", + "23.933333 2019-05-02 23:56:30 94.0 1.977724\n", + "23.950000 2019-05-02 23:57:30 118.0 2.075547\n", + "23.966667 2019-05-02 23:58:30 133.0 2.127105\n", + "23.983333 2019-05-02 23:59:30 118.0 2.075547\n", + "\n", + "[1440 rows x 3 columns]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "act" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "def antilogfx(t, actmin, amp, alpha, beta, phi):\n", + " # takes 5 x: min, amp, alpha, beta, phi\n", + " c = np.cos((t - phi) * (2*np.pi/24))\n", + " return actmin + amp*((np.exp(beta * (c - alpha)))/(1 + np.exp(beta * (c - alpha))))" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "from scipy.optimize import curve_fit\n", + "from scipy.optimize import Bounds" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.11495149956431,\n", + " 1.1202066228596599,\n", + " -0.756888733320116,\n", + " 3.53102546343027,\n", + " 12.1030770805243]" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cr[cr['record_id'] == subject][['actmin', 'actamp', 'actalph', 'actbeta', 'actphi']].values.tolist()[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "y_fit = antilogfx(x_act, 0.0769933554092863,\n", + " 1.0,\n", + " -0.921034160375523,\n", + " 4.015655046645279,\n", + " 15.706432915450598)\n", + "\n", + "\n", + "bounds = ([-np.inf, 0, -np.inf, 0, 0], [2, 1.9, np.inf, np.inf, 24])\n", + "antilog_act, antilog_act_cov = curve_fit(antilogfx, xdata = x_act, ydata = y_act, bounds = bounds)\n", + "y_fit_py = antilogfx(x_act, *antilog_act)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([], )" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_act, y_act, color = \"gray\", linewidth = 0.7)\n", + "plt.plot(x_act, y_fit, color = \"black\", linewidth = 5)\n", + "plt.xlabel('$t$')\n", + "plt.ylabel('LMAXACT')\n", + "plt.yticks([])" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(x_act, y_act, label='Actiwatch Raw', color = \"darkgray\", linewidth = 0.7)\n", + "plt.plot(x_act, y_fit_py, label='Cosinor Model', linewidth = 6, color = \"black\")\n", + "\n", + "plt.xlabel('$t$')\n", + "plt.ylabel('LMAXACT')\n", + "plt.yticks([])\n", + "plt.savefig(fname=\"/Users/megmcmahon/Desktop/%s.png\" % subject, dpi=400)" + ] + }, + { + "cell_type": "code", + "execution_count": 210, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Solarize_Light2',\n", + " '_classic_test_patch',\n", + " 'bmh',\n", + " 'classic',\n", + " 'dark_background',\n", + " 'fast',\n", + " 'fivethirtyeight',\n", + " 'ggplot',\n", + " 'grayscale',\n", + " 'seaborn',\n", + " 'seaborn-bright',\n", + " 'seaborn-colorblind',\n", + " 'seaborn-dark',\n", + " 'seaborn-dark-palette',\n", + " 'seaborn-darkgrid',\n", + " 'seaborn-deep',\n", + " 'seaborn-muted',\n", + " 'seaborn-notebook',\n", + " 'seaborn-paper',\n", + " 'seaborn-pastel',\n", + " 'seaborn-poster',\n", + " 'seaborn-talk',\n", + " 'seaborn-ticks',\n", + " 'seaborn-white',\n", + " 'seaborn-whitegrid',\n", + " 'tableau-colorblind10']" + ] + }, + "execution_count": 210, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "plt.style.available" + ] + }, + { + "cell_type": "code", + "execution_count": 211, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.74102601, 1.9 , -1.10623008, 9.89787049, 12.04599 ])" + ] + }, + "execution_count": 211, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "antilog_act" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 222, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "14 30274\n", + "33 40629\n", + "44 30412\n", + "50 40825\n", + "70 40170\n", + "79 30581\n", + "Name: record_id, dtype: int64" + ] + }, + "execution_count": 222, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cr['record_id'][cr['actamp'] == cr['actamp'].min()]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/plotcosinor.py b/plotcosinor.py deleted file mode 100644 index 9b82f14..0000000 --- a/plotcosinor.py +++ /dev/null @@ -1,21 +0,0 @@ -def plotcosinor(paramsdf): - import matplotlib.pyplot as plt - rcParams['figure.figsize'] = (10, 8) - rcParams['legend.fontsize'] = 16 - rcParams['axes.labelsize'] = 16 - plt.rcParams['axes.prop_cycle'] = plt.cycler(color=plt.cm.Dark2.colors) - - y_act_hill = hillfx(x_act, *hill_act) - - f, ax = plt.figure() - ax.plot(x_act, y_act, label='Actiwatch Raw') - ax.plot(x_fit, y_fit, label='Fitbit Raw') - ax.plot(x_fit, y_fitInt, label='Fitbit Interpolated') - ax.plot(x_act, y_act_arctan, label='Arctangent Transform', linewidth = 3) - ax.plot(x_fit, y_fit_arctan, label='Arctangent Transform', linewidth = 3) - ax.plot(x_fit, y_fitInt_arctan, label='Arctangent Transform', linewidth = 3) - ax.xlabel('$t$') - ax.ylabel('LMAXACT') - ax.legend(bbox_to_anchor=(1.8, 1), loc='upper right', ncol=1) - - return ax diff --git a/preproc.py b/preproc.py deleted file mode 100644 index f547a8e..0000000 --- a/preproc.py +++ /dev/null @@ -1,76 +0,0 @@ -def preproc(in_file, out_dir, recording_period_min, interpolate_limit, truncate=False): - import os - from datetime import date - import pandas as pd - import datetime as dt - import logging - - today = date.today() - - log_file = os.path.join(out_dir, 'logs', 'log_' + str(dt.datetime.now().date()) +'.txt') - logging.basicConfig(filename=log_file, filemode='a', format='%(asctime)s - %(message)s', level=logging.INFO) - - record_id = in_file[0:5] - print('record %s' % record_id) - - actig_file = os.path.join(in_dir, in_file) - out_file = os.path.join(out_dir, record_id + '.csv') - - data = pd.read_csv(actig_file, skiprows=22, usecols=[1, 2, 3]) - data['Time'] = data['Date'] + ' ' + data['Time'] - data['Time'] = pd.to_datetime(data['Time']) - data.index = data['Time'] - data = data['Activity'] - - start_time = data.first_valid_index() - end_time = data.last_valid_index() - period = end_time - start_time - - missingNum = data.isnull().sum() - error = 0 - logging.info('%s processing' % record_id) - - if missingNum > 0: - #remove trailing and leading activity values - length_init = len(data) - data = data.loc[data.first_valid_index():data.last_valid_index()] - - logging.info('----- removed leading and trailing NaN activity values') - missingNum = data.isnull().sum() - - if missingNum > 0: - #interpolate up to 5 minute periods - data.interpolate(limit=interpolate_limit, inplace=True) - logging.info('----- interpolated') - missingNum = data.isnull().sum() - - if missingNum > 0.10 * len(data): - print('----- error: missing values = %s percent' % (missingNum/len(data))) - logging.warning('----- discard: missing more than 10 percent of data, %s percent missing' % (missingNum/len(data))) - error = error + 1 - - if period < dt.timedelta(days = recording_period_min): - print('----- error: less than %s days actigraphy data' % (str(recording_period_min))) - logging.warning('----- discard: insufficient recording period %s' % (str(recording_period_min))) - error = error + 1 - - if truncate == True: - data = data[data.index > end_time - dt.timedelta(days = recording_period_min) - dt.timedelta(seconds = 30)] - start_time = data.index[0] - period = end_time - start_time - logging.info('----- truncated recording period') - - if missingNum > 0: - print('... error: after processing, still missing %s values' % (missingNum)) - logging.warning('----- error: missing %s values after processing' % missingNum) - error = error + 1 - - if error == 0: - print('----- saving') - logging.info('----- success: %d percent NaN, %s recording period' % ((missingNum/len(data)), str(period))) - data.to_csv(out_file, index=True, index_label=None, header=None) - print('----- success: %d percent NaN, %s recording period' % ((missingNum/len(data)), str(period))) - else: - print('----- exclude from analysis') - - return data diff --git a/readactig.py b/readactig.py deleted file mode 100644 index b2922da..0000000 --- a/readactig.py +++ /dev/null @@ -1,7 +0,0 @@ -def readactig(file): - import pandas as pd - # actigraphy input file is a file with two columns, Time ("%Y-%m-%d %H:%M:%S") and Activity, with no header - - data = pd.read_csv(file, sep = " ", header = None, names = ['time', 'activity']) - - return data diff --git a/tutorials/covid-mood-sleep.Rmd b/tutorials/covid-mood-sleep.Rmd new file mode 100644 index 0000000..407ffe7 --- /dev/null +++ b/tutorials/covid-mood-sleep.Rmd @@ -0,0 +1,111 @@ +--- +title: "Mood, Sleep, and Activities Pre vs Post COVID" +author: "Sarah Parker, Megan McMahon" +date: "10/23/2020" +output: html_document +--- + +If you don't already have the pacakges below installed, you can install them using `install.packages(packagename)` in the console. + +```{r setup, include=FALSE} +knitr::opts_chunk$set(echo = TRUE) + +library(readr) +library(tidyverse) +library(dplyr) +library(reshape2) + +# add more libraries here as needed +``` + +## Load Data + +```{r cars, echo = FALSE, message = FALSE} + +# change the file path to wherever the data file is on your computer +d <- read_csv("~/Box/CogNeuroLab/Wearables/data/sleep_diaries/qualtrics_sleep_survey.csv") + +``` + +To simplify things, we are going to subset the qualtrics dataset to only contain the date, subject ID, and survey responses. + +```{r} + +d <- d %>% + select(Subject, StartDate, matches("Q.")) + +head(d) + +``` + +We are also going to create a variable called questions that has what each "Q_" represents in the dataset. + +```{r} + +questions <- d[1, ] +questions + +d <- d[-(1:2),] +``` + +We can search what question means what using this: +```{r} + +questions[1, grep("sleep", questions[1,])] # change sleep for other keywords +``` + + +Now we need to create a new variable called age_group. In this dataset, participants with subject IDs that begin with 1 are young adults, and those with subject IDs that begin with 2 are older adults. + +```{r} +d$age_group <- ifelse(d$Subject <= 20000, "Young Adult", "Older Adult") + +d %>% + select(Subject, age_group) + +``` + + +```{r} +## find mean of sleep quality, mood, other measures, grouped by subject +## google aggregate means by subject +d_means <- d %>% + group_by(Subject) %>% + summarize(stressed_mean = mean(as.numeric(Q26_1), na.rm = T), + ruminate_mean = mean(as.numeric(Q27_1), na.rm = T), + sad_mean = mean(as.numeric(Q24_5), na.rm = T), + happy_mean = mean(as.numeric(Q25_1), na.rm = T)) + +d_means$Group <- ifelse(d_means$Subject <= 20000, "Young Adult", "Older Adult") + +# get mean +head(d_means) + +``` + +Now we can make plots! + +```{r} +### age group differences (boxplots, violin plots) + +d_means %>% + select(-Subject) %>% + melt(id.vars = "Group") %>% + ggplot(aes(value, group = Group, fill = Group, alpha = 0.75)) + + facet_wrap(~ variable, scales = "free", ncol = 2) + + geom_density() + + theme_classic() + scale_fill_brewer(palette = "Set1") + + ggtitle("Mood by Age Group") + xlab("") + theme(axis.text.x = element_blank()) + +``` + +### To Do +* How to also look at sleep variables with respect to these mood measures? May need to recode the sleep variables +* Exploratory scatter plots (below) +* Merge with redcap survey data later on + +```{r} +### scatterplots (sleep vs. mood, activities vs. mood) +## exploratory analysis on new_df- *google*, remove subject numbers, dates +``` + diff --git a/analysis.html b/tutorials/covid-mood-sleep.html similarity index 63% rename from analysis.html rename to tutorials/covid-mood-sleep.html index 1a5b8f6..e098d87 100644 --- a/analysis.html +++ b/tutorials/covid-mood-sleep.html @@ -10,10 +10,11 @@ - + + -Fitbit Analysis +Mood, Sleep, and Activities Pre vs Post COVID